Differenze tra le versioni di "Python Lezione 4 Giugno 2008"

Da GolemWiki.
m (info prontuario python3)
 
(35 versioni intermedie di 5 utenti non mostrate)
Riga 1: Riga 1:
 +
{{Note
 +
|type=info
 +
|text=La lezione fa riferimento a Python2! Dai un'occhiata anche al [[Pillole_Python | prontuario]] Python3
  
 +
La versione 2 sarà dichiarata deprecata a gennaio 2020.
 +
}}
  
 
== Python ==
 
== Python ==
è un linguaggio di programmazione interpretato.
+
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) 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.
 
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.
È meglio di quelli compilati perchè si adatta ai vari 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.
Python è un ottimo linguaggio di prorammaziobe ma è un pò più lento, diversamente da quello in c.
+
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.
Python ha 4 interpreti:generamlmente si usa cpython (classic python, scritto in c) in tutte le distribuzioni python, ma c'è anche pypy e jython (scritto in java per python).
 
  
La prima riga di ogni script python deve iniziare con #!usr/bin/env/python
+
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete "ufficiale", scritto in C e disponibile per linux, mac e windows.
 +
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java,
 +
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre
 +
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python
  
il #! del file fa capire al sistema operativo che quello non è un file di testo ma un eseguibile.
+
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.
  
== I COMMENTI ==
+
== COMMENTI ==
  
 
: sono righe che l'interprete salta e non legge  
 
: sono righe che l'interprete salta e non legge  
Riga 20: Riga 28:
  
 
== PRINT ==
 
== PRINT ==
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.
+
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.
+
L'espressione da valutare può essere anche un semplice numero o una semplice stringa o in generale un oggetto qualsiasi
PRINT stampa l'oggetto che viene dopo.
 
Se scrivo:
 
    ''print 3''
 
se si esegue questo stampa 3
 
se scrivo
 
    '' print “3”''
 
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa
 
se scrivo
 
    ''print 3+2''
 
scrive
 
    '' 5''
 
se scrivo
 
    ''print “3+2”''
 
lui mi dà
 
    ''3+2''
 
  
Le variabili non importa dichiararle, basta scrivere ad un certo punto
+
  >>> print 3
    ''messaggio=”hello world”''
+
  3
    ''print messaggio''
+
  >>> print "3"
se questo programma viene eseguito il risultatato sarà:
+
  3
''hello world''
+
  >>>
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world
 
  
 +
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.
  
== ECCEZIONE ==
+
Invece
:se io commento la definizione di messaggio (es: ''# messaggio = " hello world "'' ) il programma non sa cos'è messaggio e se scrivo:
+
  >>> print 3+2
    ''print "messaggio"''
+
  5
il risultato sarà:name error, che, viene chiamato eccezione.
+
  >>>
 +
 
 +
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.
  
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio
+
  >>> 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''  
 
     ''print messaggio*2''  
 
l'esecuzione darà
 
l'esecuzione darà
Riga 57: Riga 106:
 
''
 
''
 
esempio:
 
esempio:
     ''Print “ciao”+”mondo”''
+
     ''Print “ciao”+” mondo”''
 
lo eseguo e mi darà:
 
lo eseguo e mi darà:
 
     '' ciao mondo''
 
     '' ciao mondo''
 
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.
 
 
== '''LE STRINGHE:''' ==
 
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.
 
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.
 
    ''messaggio=”ciao”
 
    messaggio=”ciao mondo”
 
    print “messaggio”''
 
lui scrive
 
    '' ciao mondo''
 
LE STRINGHE SONO IMMUTABILI.
 
  
 
== '''Funzione DIR''' ==
 
== '''Funzione DIR''' ==
Riga 82: Riga 119:
  
 
== I '''metodi''' ==
 
== I '''metodi''' ==
sono operazioni che si possono applicare alla stringa.
+
sono operazioni che i vari oggetti supportano.
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.
+
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.
  
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione
+
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...)
+
''__ 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:
 
 
metodo '''IS''':
 
tutti I metodi che iniziano per is danno come risultato o vero o falso.
 
 
es:  
 
es:  
 
     ''messaggio.isalpha()''
 
     ''messaggio.isalpha()''
mi dicese messaggio è o meno alfanumerico.
+
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).
isalpha è un oggetto quindi se non mi ricordo ha le proprietà doc quindi se io scrivo ''messaggio.isalpa.__doc__''
+
isalpha è un oggetto quindi ha le proprietà doc .
mi dice che fa.
+
se io scrivo
 +
    ''messaggio.isalpha.__doc__''
 +
mi dice che fa.
  
Importante metto tra “ solo se è una stringa.
 
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.
 
 
es:
 
es:
 
     '' messaggio=”gigio”
 
     '' messaggio=”gigio”
Riga 107: Riga 146:
 
es:
 
es:
 
''TYPE(3)''
 
''TYPE(3)''
mi dice che variabile  è.se è intero o stringa.
+
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.
 
Se io scrivo ''DIR(3)''
 
Se io scrivo ''DIR(3)''
mi da lo stesso pappie di roba di prima.
+
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)
 
'''
 
'''
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE
 
  
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i CONTENITORI:
+
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:
  
== '''LE LISTE=''' =
+
== '''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.
 
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.
Riga 122: Riga 160:
 
dir (scaffale)''
 
dir (scaffale)''
 
da la lista dei metodi, da qui si capisce che la lista è un oggetto.
 
da la lista dei metodi, da qui si capisce che la lista è un oggetto.
Se io faccio
+
Ad esempio:
    ''b = dir (a)''
 
o
 
 
     ''a.append(“4”)''
 
     ''a.append(“4”)''
aggiunge alla lista a il 4.
+
aggiunge alla lista a la stringa "4".
'''la lista MUTA!'''
+
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”)''
 
Se faccio    ''print (“a”)''
mi da la lista degli oggetti più il 4.
+
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''' ==
 
== '''TUPLE''' ==
  
è una lista non mutabile.
+
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
La tupla è molto piu veloce rispetto alla lista.
+
valore a uno degli oggetti
Con tuple si usano le parentesi tonde.
+
 
 +
  >>> 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''' ==
 
== '''DIZIONARI''' ==
  
 
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}
 
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}
a{chiave}
+
a[chiave]
 
da il valore associato alla chiave.
 
da il valore associato alla chiave.
  
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.
+
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono quindi scorrere.
  
== '''1.If elif else''' ==
+
== '''If elif else''' ==
  
 
+
  if condizione :
if condizione :
+
      ''statement1''
indentato roba da fare se vero.
+
      ''statement2''
 +
  ''statement3''
  
 
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.
 
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.
Meglio lo spazio perchè in futuro I tab verranno lasciati.
 
 
Di solito si usa 4 spazi.
 
Di solito si usa 4 spazi.
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.
+
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:
 
Esempio:
    ''a=3
+
  >>> a=3
     b=1''
+
  >>> 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
 +
  >>>
  
    ''if a >b:
+
in questo programma definisco due valori, a e b.
      print (“ a è maggiore di 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.
    elif a==b:
 
      print (“ a è uguale a b”)
 
    else:
 
      print(“b è maggiore di a”)''
 
  
 
'''2.is, is not or, and,!='''
 
'''2.is, is not or, and,!='''
    ''if a is 1:
+
  >>> if a is 1:
      print (“si”)
+
  ...    print (“si”)
    elif a is not 1:
+
  >>> elif a is not 1:
      print (“no”)
+
  ...    print (“no”)
 +
  no
 +
  >>> if a is 1 and b is 3:
 +
  ...    print (“si”)
 +
  >>> if a is 3 or b is 3:
 +
  ...    print (“okkei”)
 +
  okkei
  
    if a is 1 and b is 3:
+
'''!= è il diverso.'''
      print (“si”)
 
  
    if a is 1 or b is 3:
+
Oltre ai classici test a volte siamo interessati a vedere se un particolare elemento è presente in una tupla, lista o dizionario
      print (“okkei”)
+
 
''
+
  >>> miodizionario = { 'primo': 1, 'secondo': "golem", 'terzo': [1,2,3] }
'''!= è il diverso.'''
+
  >>> 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''
  
== '''3.append, insert''' ==
+
== '''append, insert''' ==
  
 
     ''a.append(“4”)''
 
     ''a.append(“4”)''
Riga 196: Riga 306:
  
  
== '''4.for''' ==
+
== '''for''' ==
  
 
specifica un ciclo, fa le cose tante volte fino ad una condizione.
 
specifica un ciclo, fa le cose tante volte fino ad una condizione.
 
For variabile in una sequenza di qualche tipo.
 
For variabile in una sequenza di qualche tipo.
Es:    ''for elemento in a:
 
              print elemento''
 
  
es b è una tupla.
+
  >>> miatupla = ( 1, 2,  "a" ,(1,2,3))
Allora posso scrivere:
+
  >>> for variabile in miatupla:
    ''for elem in b
+
  ...    print "nella tupla: ",
        print “altro elemento”
+
  ...    print variabile
        “print elem”''
+
  ...
 +
  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)
 +
  >>>
  
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.
+
Iterando su un dizionario, che è un iterable, vengono resistuite le chiave, non i valori.
  
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:
+
  >>> miodizionario = { 'primo': 1, 'secondo': "golem", 'terzo': [1,2,3] }
for chiave in a:
+
  >>> for chiave in miodizionario:
    ''print “chiave: “ + chiave
+
  ...    print chiave,
    print “valore: “ + a[chiave]''
+
  ...    print ":",
 +
  ...    print miodizionario[chiave]
 +
  ...
 +
  terzo : [1, 2, 3]
 +
  primo : 1
 +
  secondo : golem
  
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''
+
Vediamo come gli elementi del dizionario non ci vengono resistuiti in un particolare ordine, anzi, non ci soono garanzie a riguardo
  
== '''5.xrange''' ==
+
  >>> 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.
 
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.
Riga 236: Riga 387:
 
9
 
9
 
10''
 
10''
xrange vale solo per for.
 
  
== '''6.range''' ==
+
== '''range''' ==
  
è una lista.se io scrivo:
+
ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista.
    ''print range(10)''
+
E' più lento di xrange
lui mi da    ''[0,1,2,3,4,5,6,7,8,9].''
 
è più lento di xrange e poi sta morendo
 
  
== '''7.len''' ==
+
  >>> print range(10)
 +
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 +
  >>>
 +
 
 +
== '''len''' ==
  
 
     ''len (a)''
 
     ''len (a)''
 
da la lunghezza della stringa
 
da la lunghezza della stringa
  
== '''8.enumerate''' ==
+
== '''enumerate''' ==
  
 
se io ho una lista di tre elmenti
 
se io ho una lista di tre elmenti
Riga 264: Riga 416:
  
  
== '''9.raw_input''' ==
+
== '''raw_input''' ==
  
 
dai il valore.
 
dai il valore.
Riga 272: Riga 424:
 
ti chiede il valore di base ed esponente.
 
ti chiede il valore di base ed esponente.
  
== '''10.Int''' ==
+
== '''Int''' ==
  
 
forza il fatto che quel valore sia un intero.
 
forza il fatto che quel valore sia un intero.
Riga 280: Riga 432:
  
  
== '''11.UPPER,LOWER,CAPITALIZE''' ==
+
== '''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
 
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola
Riga 299: Riga 451:
 
Calcolo di una potenza.
 
Calcolo di una potenza.
  
     ''Base= raw_input (“inserisce la base:”)
+
     ''
     esponente=raw_input (“inserisci l'/ esponente”)
+
    base= raw_input (“inserisce la base:”)
 +
     esponente=raw_input ('inserisci l\' esponente')
  
 
     base=int(base)
 
     base=int(base)
Riga 307: Riga 460:
 
     result=1
 
     result=1
 
     for i in xrange(esponente):
 
     for i in xrange(esponente):
    result = result * base
+
        result = result * base
 
     print result''
 
     print result''
  
l'operatore int forza il fatto che l'operatore deve essere un intero, lo dobbiamo scrivere, altrimenti non funziona perchè lui lo vede come stringa
+
il [http://docs.python.org/lib/built-in-funcs.html 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!
 +
 
 +
[[Category:Corsi]]

Versione attuale delle 13:47, 9 mag 2019

Golem-template-note-info.png La lezione fa riferimento a Python2! Dai un'occhiata anche al prontuario Python3

La versione 2 sarà dichiarata deprecata a gennaio 2020.


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!