curriculum.pdf 
Python e' un linguaggio OOP
interpretato
multiparadigma e multipiattaforma, di facile utilizzo, molto potente e flessibile.
Multiparadigma signica che Python puo' essere utilizzato sia come linguaggio di scripting che come linguaggio Object Oriented.
Multipiattaforma perche' Python, essendo un programma interpretato, cioe' eseguito su una macchina virtuale, puo' essere elaborato su tutte le piattaformi esistenti (Microsoft, Linux, Mac) senza alcuna modifica dei sorgenti.
La velocita' di Python non e' paragonabile a quelle del C ma in certe condizioni puo' essere paragonato a quelle di Java, inoltre Python permette di aggirare in modo facile l'ostacolo delle performance pure: e' infatti relativamente semplice scrivere un'estensione in C o C++ e poi utilizzarla all'interno di Python, sfruttando cosi' l'elevata velocita' di un linguaggio compilato solo nelle parti in cui effettivamente serve, e sfruttando invece la potenza e versatilita' di Python per tutto il resto del software.
Python deriva dal Perl ma ha una sintassi piu' facile e con regole di scrittura piu' rigide.
Una delle regole fondamentali di Python e' quella di identare il codice.
I blocchi di codice (funzioni, istruzioni if, cicli for, ecc.) devono essere scritti con caratteri di tabulazioni;ogni blocco inizia con una identazione e la sua rimozione lo termina.
Non ci sono graffe, parentesi o parole chiave da scrivere e lo spazio in mezzo non provaca nessun errore da parte dell'interprete.
Ad esempio scrivere una "if" cosi' provoca un errore:
if a == 1: b = 1 print b SyntaxError: invalid syntax
invece e' corretto scrivere la if con la tabulazione nella 2^ riga; per interrompere il blocco della if basta togliere la tabulazione:
if a == 1:
b = 1
print b
Un'altra regola importante di Python riguarda la dichiarazione delle variabili.
A differenza di altri linguaggi come Java, in cui le variabili devono prima essere dichiarate e poi inizializzate, in Python una variabile viene dichiarata nel momento in cui viene usata.
Ad esempio scrivendo a = 1 si dice all'interprete Python che la variabile a e' di tipo intero e il suo valore iniziale e' uguale a 1.
Quando dichiarate una variabile di un tipo particolare non potete subito dopo trattarla con un tipo diverso se non attraverso una conversione esplicita.
Ad esempio scrivendo questo codice l'interprete provochera' un errore di tipo:
a = 1 b = a + "123" Traceback (most recent call last): File "<pyshell#1>", line 1, in <module> a + '123' TypeError: cannot concatenate 'str' and 'int' objects
Avete cercato di sommare una stringa a un numero e l'interprete ha giustamente generato un Error Type
Si puo' dire in questo senso che Python e' dinamicamente e fortemente tipato per le ragioni mensionate prima.
Ovvero, dinamicamente tipato nel senso che Python scopre il tipo di dato nel momento in cui l'ho utilizzate, fortemente tipato nel senso che non potete cambiare la natura del dato senza una specifica operazione di casting.
In Python il "casting" si effettua utlizzando dei moduli "built-in" pronti all'uso.
Per l'esempio precedente e' possibile fare la somma utilizzando la funzione "str":
a = 1 + "123" b = str (a) + "123"
Python e' allo stesso tempo un interprete per gli script che un shell interattiva.
E' possibile infatti lanciare un'applicazione dalla riga di comando precedendo il nome del programma da lanciare con la parola python:
python mioapplicativo.py
oppure con un doppio clic sulle applicazioni stesse dalla finestra di navigazione.
Come shell interattiva Python puo' valutare dichiarazioni ed espressioni arbitrarie.
Cio' puo' essere estremamente utile per il debugging, l'hacking rapido ed il testing.
Ecco un esempio di uso della shell interattiva:
>>> 1 + 1 2 >>> print 'hello world' hello world >>> x = 1 >>> y = 2 >>> x + y 3
In python tutto e' da considerarsi un oggetto; anche i tipi primitivi, come gli interi e i float, sono degli oggetti.
Esistono diverse strutture dati in Python come le liste, i dizionari e le tuple.
Le liste sono un tipo di array in cui ciascun elemento e' un oggetto identificato dalla sua posizione, con la prima posizione che e' uguale a zero.
Se, ad esempio, definiamo una lista di questo tipo:
>>> lista = [1, "test", 3, 2.33333]
Tenendo conto che in una lista di n elementi la prima posizione e' 0 e l'ultima e' n - 1, possiamo stampare sullo schermo ciascuna posizione dell'array.
>>> print lista [1, 'test', 3, 2.33333] >>> print lista[0] 1 >>> print lista[1] 'test' >>> print lista[2] 3 >>> print lista[3] 2.33333
Per assegnare un nuovo elemento alla lista basta utilizzare il comando append:
>>> lista.append (4) >>> print lista >>> print lista [1, 'test', 3, 2.33333, 4]
L'elemento sara' aggiunto in coda alla lista.
Per rimuovere un elemento dalla lista e' possibile usare il metodo remove specificando come argomento il valore da rimuovere. La prima occorrenza di valore sara rimossa:
>>> lista = [1, 2, 3, 4, 5]
>>> lista.remove (4)
>>> lista
[1, 2, 3, 5]
Occorre fare attenzione al metodo remove in quanto se si specifica un valore inesistente l'interprete generera' un Value Error:
>>> lista = [1, 2, 3, 4, 5] >>> lista.remove (8) Traceback (most recent call last): File "<pyshell#1>", line 1, in <module> lista.remove (8) ValueError: list.remove (x): x not in list
In alternativa a remove puo' essere utilizzato il metodo __delitem__ che rimuove un elemento specificando la sua posizione.
>>> lista = [1, 2, 3, 4, 5] >>> lista.__delitem(1)__ # rimuove il 2^ elemento >>> lista [1, 3, 4, 5]
Molti altri metodi possono essere richiamati sull'oggetto lista. Per conoscerli basta utilizzare la funzione "dir" e come argomento l'oggetto lista creato.
>>> dir (lista)
['__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' ]
Un'altro trucco che vi suggerisco e' quello di utilizzare la funzione "help" per conoscere dettagli utili su un metodo.
Ad esempio per sapere cosa fa' il metodo 'sort' basta digitare:
>>> help (lista.sort) Help on built-in function sort: sort(...) L.sort(cmp = None, key = None, reverse = False) -- stable sort * IN PLACE*; cmp(x, y) → -1, 0, 1
Il dizionario e' un tipo predefinito in Python che definisce una relazione uno-a-uno tra chiavi e valori. Un esempio di dizionario e' il seguente:
>>> dizionario = {'primo':1,'secondo':2}
Ogni elemento e' contraddistinto da una coppia chiave-valore, e l'intero insieme di elementi e' racchiuso tra parentesi graffe.
In questo caso alla chiave 'primo' e' associato il valore '1', alla chiave 'secondo' e' associato il valore 2.
Non e' possibile duplicare delle chiavi in un dizionario mentre e' possibile sovrascrivere il vecchio valore assegnando un nuovo valore ad una chiave esistente.
E' possibile creare nuove coppie 'chiave-valore' tramite la sintassi dizionario[nuovachiave] = nuovovalore.
Ad esempio:
>>> dizionario['terzo'] = 3 >>> dizionario {"primo": 1, "secondo": 2, "terzo": 3}
Per rimuovere una coppia 'chiave-valore' si utilizza il metodo __delitem__(nomechiave):
>>> dizionario.__delitem__ ["primo"] = 3
>>> dizionario
{"secondo": 2, "terzo": 3}
Una tupla e' una lista immutabile. Una tupla non puo' essere modificata in alcun modo una volta che e' stata creata. Non e' possibile aggiungere, modificare e rimuovere i dati all'interno di una tupla. Esempio di tupla:
>>> a = (1,2,3)
Come per le liste anche le tuple hanno gli elementi identificati dal proprio indice.
Cosicche' avremo:
>>> a[0] 1 >>> a[1] 2 >>> a[2] 3
Ci si potrebbe chiedere a cosa servino le tuple visto che non sono modificabili.
Innanzitutto le tuple sono piu' veloci delle liste e questo rende il codice ottimizzato a livello di prestazioni.
I vantaggi sono anche a livello sicurezza. Infatti il vostro codice risultera' protetto dalla scrittura usando le tuple anziche' le liste.
Infine le tuple sono usate sia nella formattazione delle stringhe che nella impostazione dei valori delle chiavi di un dizionario.
Le stringhe come le tuple sono immutabili; e' possibile solo fare operazioni di estrapolazione ma non possono essere modificate se non attraverso il riferimento a nuovi oggetti.
Infatti se dichiariamo una variabile stringa , richiamando il comando dir noteremo
che non sono presenti metodi di aggiunta o aggiornamenti.
Per aggiungere porzioni di stringa a quelle gia' esistenti creeremo altri oggetti
Ad esempio:
>>> string1 = 'test' >>> string2 = string1 + ' OK' >>> string2 'test OK'
Python supporta la formattazione dei valori nelle stringhe attraverso l'utilizzo dell'istruzione %s.
Il modo piu' semplice per spiegarlo e' attraverso un esempio:
>>> k = "rosa" >>> v = "rossa" >>> "la %s e' %s" % (k, v) (1) la rosa e' rossa
L'intera espressione viene valutata come stringa.
(1) Il primo %s e' rimpiazzato dal valore di k mentre il secondo %s e'
rimpiazzato dal valore di v.
Tutti i restanti caratteri della stringa ( il simbolo uguale) rimangono invariati.
Un' istruzione if consiste di una serie di blocchi caratterizzati da un inizio e fine tabulazione:
if parola = = "avere": saldo = 500 else: if parola = = 'dare': saldo = -500 else: saldo = 0
L'esempio precedente mostra una if nidificata uno dentro l'altra.
E' importante identare i blocchi in maniera opportuna altrimenti l'interprete
generera' un errore di sintassi.
Il tipico utilizzo di un ciclo for si applica alle liste per iterare all'interno degli elementi della lista stessa.
Nell'esempio la variabile lista e' una lista e la variabile i assume in sequenza, a partire dal primo elemento, il valore di ogni elemento della lista.
In questo caso la stampa di ogni valore della lista rende ben chiaro il comportamento del ciclo for.
lista = ["rosa", "tulipano", "margherita", 1] for i in lista: print rosa tulipano margherita 1
Occasionalmente e' utile avere un ciclo con contatore in modo tale da avere ad ogni ciclo un valore intero che corrisponde a ciascuna posizione della lista:
lista = ["rosa", "tulipano", "margherita", 1] for i in range(len(lista)): print lista[i] rosa tulipano margherita 1
In questo esempio abbiamo introdotto la funzione range che crea una lista di valori ordinati interi mentre len restituisce la lunghezza di un oggetto.
Quindi valutando il codice piu' attentamente osserviamo che len(lista) → 4 e range(4) → [0, 1, 2, 3], quindi il codice precedente si puo' scrivere:
lista = ["rosa", "tulipano", "margherita", 1] for i in [0, 1, 2, 3]: print lista[i] rosa tulipano margherita 1
Vediamo il funzionamento di un ciclo for applicato a un dizionario; in questo caso il nostro dizionario e' agenda che contiene i dati anagrafici e il numero di telefono.
agenda = {"nome": "Paolo", "cognome": "Rossi", "telefono": 339999999} for k, v in agenda.items(): print "il %s e' %s" % (k, v) il nome e' Paolo il cognome e' Rossi il telefono e' 339999999
il metodo items() restituisce una lista di tuple: [(chiave1, valore1),
(chiave2, valore2), ...].
Nel nostro caso agenda.items() → [("nome", "Paolo"), ("cognome", "Rossi"), ("telefono","39999999")].
Il ciclo for itera su questa lista considerando che ogni elemento rappresenta una tupla.
Al primo giro, si assegna "nome" alla variabile k e "Paolo" alla variabile v, cosicche'
k = "nome" e v = "Paolo".
Al secondo giro, la variabile k = "cognome" e v = "Rossi".
Infine al terzo giro k = "telefono" e v = "339999999".
while e' una istruzione che viene uitlizzata quando si vuole eseguire una serie di operazioni ciclicamente fino a quando una condizione rimane vera.
Ecco un esempio dell'utilizzo di while:
n = 0 while n < 5: n = n + 1 print n 1 2 3 4 5
In questo caso il blocco di itruzioni viene eseguito fino a quando n < 5.
In generale occorre assicurarsi che la condizione del while diventi falsa altrimenti si verica un loop infinito che manda in crach l'applicazione.
Nel nostro caso abbiamo provveduto a incrementare la variabile n di una unita alla volta affinche la condizione non sia piu' soddisfatta quando n = 6
Importare i moduli significa mettere a disposizione un modo facile per organizzare i componenti tramite un meccanismo di pacchettizazioni dei nomi.
In termini generali, un programma Python consiste in vari file di testo conteneneti istruzioni Python.
Il programma e' strutturato come un file principale, al livello piu' alto, e da zero o piu' file supplementari chiamati, in Python, moduli.
I file modulo sono librerie di strumenti, usate per raccogliere i componenti utilizzati da file di primo livello e , possibilmente, da altri file.
In python, un file importa un modulo per avere accesso agli strumenti in esso definiti come le variabili e gli attributi.
In definitiva, importiamo i moduli e acceddiamo ai loro attributi per utilizzare gli strumenti definiti al proprio interno.
Esempio:
>>> import sys # importa il modulo sys >>>sys.path ['', '/home/mario', '/home/mario/Desktop/develop/python', '/usr/lib64/python25.zip', '/usr/lib64/python2.5']
L'importazione del modulo sys restituisce tutte le sue funzioni e attributi disponibili.
Nel caso si usi la forma import nomemodulo bisogna richiamare ogni metodo nella forma nomemodulo.metodo o nomemetodo.attributo.
Nel caso si usi la forma from nomemodulo import * non occorrera' specificare davanti al metodo o attributo il nome del modulo
Come in tutti i linguaggi di programmazione anche in Python esistono le funzioni.
Una tipica funzione in Python e':
def miafunzione ( argomento1, argomento2, ..., argomentoN ): elaborazione1 elaborazione2 ... elaborazioneN return valore
Dove argomento1,argomento2 ... argomentoN sono i parametri che vengono elaborati
dalla funzione e valore e' il valore ritornato dalla funzione.
Un classico schema di funzionamento prevede che la funzione sia richiamata con lo stesso numero di parametri
e nello stesso ordine.
Ad esempio:
ipotenusa = 10,54 altezza = 5,25 area = calcAreaTrian (ipotenusa, altezza) print area def calcAreaTrian (ipotenusa, altezza): area = (ipotenusa * altezza) / 2 return area
>>> 27,6675
Possiamo impostare un valore di default tra i parametri di una funzione.
Ad esempio riprendendo l'esempio di prima potremmo scrivere:
ipotenusa = 10,54
altezza = 7
area = calcAreaTrian (ipotenusa, altezza)
print area
def calcAreaTrian (ipotenusa, altezza = 5): area = (ipotenusa * altezza) / 2 return area
In questo caso il risultato sara' :
>>> 35,27
Il valore di altezza nel namespace della funzione avra' il valore di default 5.
Se la funzione viene chiamata passando anche il 2^ argomento, questo sovrascrivera' il default.
ipotenusa = 10,54 # in questo caso viene passato un parametro, il 2^ sara' preso dal default area = calcAreaTrian (ipotenusa) print area def calcAreaTrian (ipotenusa, altezza =5): area = (ipotenusa * altezza) / 2 return area >>> 27,6675
In Python le classi si definiscono con la parola chiave class seguito dal nome della classe ed eventualmente eredita da altre classi padre. Vengono poi indicati gli attributi della classe, 1 metodo costruttore ed N metodi.
Un classico schema di classe e' il seguente:
class NomeClasse (SovraClasse,...): data = value def__init__ (self,...): ... def metodo1(self,...): ... def metodon(self,...):
come per le funzioni anche le classi costituiscono uno scopo locale dove vivono i nomi creati dagli assegnamenti annidati sotto di esse.
Quando viene creata una classe cio' che si puo fare e creare delle istanze di quella classe.
Le istanze vengono create semplicemente richiamando il nome della classe con eventuali parametri richiesti dal costruttore.
Ecco un esempio piu' esplicito:
MioModulo.py ← nome del file del modulo class MiaClasse: # definisce la classe MiaClasse data = 'spam' # assegna un attributo alla classe def __init__ (self,value): # assegna un nome al metodo self.data = value # assegna un attributo all'istanza def display(self): print (self.data, # attributo di istanza MiaClasse.data) # attributo di classe if __name__ == '__main__' : miaclasse = MiaClasse("Esempio di istanza" ) # crea l'istanza miaclasse miaclasse.display( ) # viene richiamato il metodo display su miaclasse >>> ('Esempio di istanza', 'spam' )
Innanzitutto spieghiamo che if __name__ == '__main__' : e' un trucco per far si che il modulo possa essere eseguito come un programma indipendente. Ogni modulo ha un attributo built-in __name__ che nel caso il modulo sia importato e' uguale al nome del file del modulo altrimenti e' uguale a __main__.
Home
Dati personali
Istruzione e formazione
Esperienze di lavoro
Conoscenze informatiche
Hobby
Python in pillole
Download Curriculum
La mia chiave GPG
Mappa del sito