Python Lezione 4 Giugno 2008

Da GolemWiki.
Versione del 21 set 2015 alle 19:48 di Giomba (discussione | contributi) (Pagina categorizzata)

Python

Python è un linguaggio di programmazione interpretato. Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware. Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina. Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.

Esistono vari interpreti: Cpython, o classic python, è l'interprete "ufficiale", scritto in C e disponibile per linux, mac e windows. Jython è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, IronPython è un interprete python che gira sulla piattaforma .NET mentre PyPy è (anche) un interprete python scritto in.. python

La prima riga di ogni script python deve iniziare con #!/usr/bin/env python

il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.

COMMENTI

sono righe che l'interprete salta e non legge

es:

   # stampa:”hello word”

PRINT

Lo statement print valuta tutte le espressioni presenti e quindi le stampa a video. L'espressione da valutare può essere anche un semplice numero o una semplice stringa o in generale un oggetto qualsiasi

 >>> print 3
 3
 >>> print "3"
 3
 >>> 

stampa lo stesso valore anche se abbiamo passato prima un intero, poi una stringa. Questo è normale, perchè il numero "tre" viene rappresentato dal simbolo 3 nel sistema decimale.

Invece

 >>> print 3+2
 5
 >>>
 

otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il risultato Mentre se scriviamo

 >>> print "3+2"
 3+2
 

in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.

 >>> print "3"+"2"
 32

Stampa 3 concatenato a 2, ovvero la stringa 32. Uguale all'esempio del 3+2 tra interi, solo che qui ha usato l'opertatore di addizione tra stringhe, che fa la concatenazione

Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore >>> messaggio = "Hello, World" >>> print messaggio Hello, World

l'interprete valuta l'espressione messaggio e stampa il suo contenuto

Errori e Eccezioni

Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:


 jdoe@waste-bin ~ $ python
 Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) 
 [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2
 Type "help", "copyright", "credits" or "license" for more information.
 >>> print messaggio
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 NameError: name 'messaggio' is not defined

NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere catturate e gestite appositamente, sia per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.

Un altro esempio, tendando di sommare mele e pere:

 >>> print 1 + "a"
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 TypeError: unsupported operand type(s) for +: 'int' and 'str'

Vediamo che a questo giro l'eccezione lanciata è ValueError.

LE STRINGHE

Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili. Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.

   messaggio=”ciao”
   messaggio=”ciao mondo”
   print messaggio

stampa

    ciao mondo

In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo. Le stringhe supportano anche alcuni operatori base:

   print messaggio*2 

l'esecuzione darà

   messaggio messaggio

esempio:

    Print “ciao”+” mondo”

lo eseguo e mi darà:

    ciao mondo

Funzione DIR

   messaggio=”ciao”
   dir(messaggio)

a questo punto il programma da una serie di caratteri incomprensibili. Praticamente dà i metodi che suporta la stringa messaggio.

I metodi

sono operazioni che i vari oggetti supportano. alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente, senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.

Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.

"ciao" + " mondo" 

chiama in realtà

"ciao".__add__(" mondo")

__ doc__ ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto.

i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera: es:

   messaggio.isalpha()

mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc). isalpha è un oggetto quindi ha le proprietà doc . se io scrivo

   messaggio.isalpha.__doc__

mi dice che fa.

es:

    messaggio=”gigio”
   messaggio2= messaggio.upper()

es: TYPE(3) mi dice che variabile è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente. Se io scrivo DIR(3) mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)

Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:

LE LISTE

es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale. Lo scaffale si chiama Lista .si usano le parentesi quadre con oggetti separati da virgola es. a = [ “pc1” , “schermo rotto” , 2] dir (scaffale) da la lista dei metodi, da qui si capisce che la lista è un oggetto. Ad esempio:

   a.append(“4”)

aggiunge alla lista a la stringa "4". La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir

Se faccio print (“a”) mi da la lista degli oggetti più "4"

Da notare che

 >>> mialista = []
 >>> mialista
 []
 >>> dir(a)
 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', 
  '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', 
  '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',
  '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', 
  'pop', 'remove', 'reverse', 'sort']

Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.

Vediamo come una lista può contenere qualsiasi oggetto, anche una lista o una tupla (vedi sotto)

 >>> mialista = [ (1,1,1), [2,2,2], 3, ([4,4,4],(4,4,4))]

Questa è una lista di 4 oggetti, uno dei quali è una tupla, il secondo è una lista, il terzo un intero, il quarto una tupla contenente a sua volta una lista e una tupla.

TUPLE

simile a una lista, è un contenitore di elementi. La tupla non è mutabile, per cui se definita con 4 oggetti non potrà mai contenerne 5 come non si può cambiare il valore a uno degli oggetti

 >>> miatupla = ( 1, 2,  "a" ,(1,2,3))
 >>> miatupla
 (1, 2, 'a', (1, 2, 3))
 >>> len(miatupla)
 4
 

Dall'esempio vediamo come una tupla possa contenere al suo interno oggetti di vario tipo (tra cui una tupla stessa): a tal proposito si vede che la lunghezza della tupla è 4 , infatti la tupla in essa contenuta - e che a sua volta contiene 3 oggetti - viene considerata un unico oggetto (perchè difatto lo è.)

Vediamo come si può accedere posizionalmente agli elementi della tupla (l'indice parte da zero)

 >>> miatupla[0] # primo elemento
 1
 >>> miatupla[2] # terzo elemento
 'a'
 >>> primo, secondo, terzo, quarto = miatupla  # scompatta la tupla in 4 variabili
 >>> terzo
 'a'
 >>> quarto
 (1, 2, 3)

Inoltre, tentare di assegnare un nuovo valore a un elemento della tupla genera una eccezione

 >>> miatupla[0] = 3
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 TypeError: 'tuple' object does not support item assignment
 >>>

DIZIONARI

il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore} a[chiave] da il valore associato alla chiave.

Dizionari liste e tuple sono dele sequenze e sono iterable e si possono quindi scorrere.

If elif else

 if condizione :
     statement1
     statement2
 statement3

Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione. Di solito si usa 4 spazi. Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre un blocco indentando Nell'esempio precedente, statement1 e statement2 vengono eseguiti solo se la condizione è vera, mentre statement3 viene eseguito sempre.


Esempio:

 >>> a=3
 >>> b=1
 >>> if a > b:
 ...     print ("a è maggiore di b")
 ... elif a == b:
 ...     print ("a è uguale a b")
 ... else:
 ...     print ("a è minore di b")
 ... 
 a è maggiore di b
 >>> 

in questo programma definisco due valori, a e b. Chiedo al programma se a è maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.

2.is, is not or, and,!=

 >>> if a is 1:
 ...     print (“si”)
 >>> elif a is not 1:
 ...     print (“no”)
 no
 >>> if a is 1 and b is 3:
 ...     print (“si”)
 >>> if a is 3 or b is 3:
 ...     print (“okkei”)
 okkei

!= è il diverso.

Oltre ai classici test a volte siamo interessati a vedere se un particolare elemento è presente in una tupla, lista o dizionario

 >>> miodizionario = { 'primo': 1, 'secondo': "golem", 'terzo': [1,2,3] }
 >>> if "primo" in miodizionario: 
 ...     print 'yeah'
 ... 
 yeah
 >>>

Vediamo come l'operatore in cerca nelle chiavi del dizionario Analogamente possiamo farlo nelle liste

 >>> mialista = [1,2,3]
 >>> if 4 not in mialista:
 ...     print "non c'è"
 ... 
 non c'è
 >>>

L'esempio precedente mostra anche che l'operazione può essere negata usando not

append, insert

   a.append(“4”)

aggiunge alla lista a il 4. Se faccio print (“a”) mi da la lista degli oggetti più il 4.

con insert devo inserire anche la posizione

   a.insert(2,34)

mette il 34 in posizione 2


for

specifica un ciclo, fa le cose tante volte fino ad una condizione. For variabile in una sequenza di qualche tipo.

 >>> miatupla = ( 1, 2,  "a" ,(1,2,3))
 >>> for variabile in miatupla:
 ...     print "nella tupla: ",
 ...     print variabile
 ... 
 nella tupla:  1
 nella tupla:  2
 nella tupla:  a
 nella tupla:  (1, 2, 3)
 >>>

In caso volessi, nel ciclo, sapere "a che punto" della tupla (o della sequenza, in generale a che punto dell' iterable) sono:

 >>> for indice, variabile in enumerate(miatupla):
 ...     print "elemento",
 ...     print indice
 ...     print variabile
 ... 
 elemento 0
 1
 elemento 1
 2
 elemento 2
 a
 elemento 3
 (1, 2, 3)
 >>> 

Iterando su un dizionario, che è un iterable, vengono resistuite le chiave, non i valori.

 >>> miodizionario = { 'primo': 1, 'secondo': "golem", 'terzo': [1,2,3] }
 >>> for chiave in miodizionario:
 ...     print chiave,
 ...     print ":",
 ...     print miodizionario[chiave]
 ... 
 terzo : [1, 2, 3]
 primo : 1
 secondo : golem

Vediamo come gli elementi del dizionario non ci vengono resistuiti in un particolare ordine, anzi, non ci soono garanzie a riguardo

 >>> dir (miodizionario)
 ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__ge__',
  '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', 
  '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', 
  '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 
  'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

se vogliamo iterare su i valori e non sulle chiavi dobbiamo usare il metodo itervalues degli oggetti dizionario:

 >>> for valore in  miodizionario.itervalues():
 ...     print valore
 ... 
 [1, 2, 3]
 1
 golem
 >>>

xrange

xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista. se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)

es: for I xrange(10)

              print I

lui stampa 1 2 3 4 5 6 7 8 9 10

range

ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista. E' più lento di xrange

 >>> print range(10)
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 >>>

len

   len (a)

da la lunghezza della stringa

enumerate

se io ho una lista di tre elmenti a=[“ciao”,”bel”, “mondo”]

for I, elem in enumerate(a):

    print str(I) + “:” + elem

da la posizione corrente di ogni elemento. 0:ciao 1:bel 2:mondo


raw_input

dai il valore. Base= raw_input (“inserisce la base:”) esponente=raw_input (“inserisci l'/ esponente”)

ti chiede il valore di base ed esponente.

Int

forza il fatto che quel valore sia un intero. Es:base=int(base)

 result=int(result)


UPPER,LOWER,CAPITALIZE

capitalize è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola

es:

   print “ciao mondo”.capitalize()
   Ciao mondo

es:

   print “ciao mondo”.title()
   Ciao Mondo

LOWER: prende la striga e emette tutto minuscolo UPPER: il contrario di lower

ESEMPIO DELLA SERATA:

Calcolo di una potenza.

   
   base= raw_input (“inserisce la base:”)
   esponente=raw_input ('inserisci l\' esponente')
   base=int(base)
   result=int(result)
   result=1
   for i in xrange(esponente):
        result = result * base
   print result

il built-in int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero una trasformazione di tipo, da stringa a intero. E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire "awlerorj" in int!