Python@Unina - Theory

Introduzione a Python
Prof. Roberto Canonico
Napoli 10/04/2019
NaLUG Workshop@UniNA 2019

Obiettivi
• Introdurre un linguaggio di programmazione la cui popolarità negli ultimi anni è in
continua ascesa
• Mostrare come si programma in un linguaggio interpretato
• Spingere ad imparare nuovi linguaggi di programmazione
• Caveat: saranno mostrati prevalentemente gli aspetti sintattici del linguaggio,
tralasciando gli ‘internals’, cioè i meccanismi utilizzati dall’interprete per eseguire il
codice Python ed implementare le astrazioni del linguaggio
Fonte: IEEE Spectrum,
Interactive: The Top Programming Languages 2018
Fonte: https://www.theatlas.com/charts/BJlUylxqQ
su dati raccolti dallo
StackOverflow Developer Survey 2018
https://insights.stackoverflow.com/survey/2018/
Prof. Roberto Canonico – a.a. 2018/2019

Python: principali caratteristiche
• Python è un linguaggio di programmazione:
• di alto livello e general-purpose ideato dall’informatico olandese Guido van
Rossum all’inizio degli anni novanta
• interpretato
• interprete open-source multipiattaforma
• con tipizzazione forte e dinamica
• il controllo dei tipi viene eseguito a runtime
• supporta il paradigma object-oriented
• con caratteristiche di programmazione funzionale e riflessione
• ampiamente utilizzato per sviluppare applicazioni di scripting, scientifiche,
distribuite, e per system testing
• Oggi se ne utilizzano prevalentemente due diverse versioni, identificate dai
numeri di versione 2 e 3
• Le due versioni non sono compatibili
• L’interprete è scaricabile dal web: https://www.python.org/downloads/

Interprete Python: modalità interattiva
• Lanciando il programma eseguibile python si esegue l’interprete Python
in modalità interattiva
• Si ottiene un prompt dal quale si possono eseguire singoli statement
Python
• In modalità interattiva i comandi vanno digitati da tastiera
• L’interprete tiene memoria dei comandi eseguiti precedentemente, che
possono essere richiamati al prompt usando i tasti freccia-sù e freccia-
giù della tastiera
C:UsersRoberto>python
Python 3.4.4 (v3.4.4:737efcadf5a6, Dec 20 2015, 20:20:57) [MSC v.1600 64 bit (AMD64)]
on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 4+7
11
>>> print("Hello world!")
Hello world!
>>> exit()
C:UsersRoberto>

Script Python
• Un programma Python è tipicamente scritto in un file
sorgente testuale
• I file sorgente Python sono anche detti script perché
possono essere eseguiti direttamente dall’interprete
• Per convenzione, gli script Python sono salvati in file
con estensione .py
• Per lo sviluppo, una pratica comune è quella di
usare un normale editor di testo per scrivere il
codice sorgente

Esecuzione di script Python
• L’esecuzione del programma si ottiene avviando l’interprete
Python e fornendo come input il path dello script Python
• In Windows:
C:UsersRobertoPython> python prova.py
• In Linux, se il file script è eseguibile:
chmod prova.py a+x
– e la prima riga dello script è:
#!/usr/bin/python
– è possibile eseguire direttamente lo script dal
prompt dei comandi:
user@computer:~$ prova.py
Per queste lezioni useremo l’ambiente Thonny (https://thonny.org/)

Python: aspetti lessicali
• Un programma Python è una sequenza di linee di testo
• L’unità di esecuzione è detta uno statement
• I caratteri di una linea successivi ad un eventuale carattere
hash (#) sono considerati un commento ed ignorati
dall’interprete
• Una singola linea di testo può contenere più statement
separati da punto e virgola
• Uno statement termina con la fine di una riga, a meno che la
riga non contenga parentesi aperte e non ancora chiuse
a = 5; b = 8; c = 3
# Esempio di statement su due linee di testo
a = 3 + 5 + 7 #continua nella prossima riga
+ 4 + 2 + 1

Python: indentazione
• Python non usa parentesi per delimitare blocchi di codice,
a tale scopo, Python usa le regole di indentazione
• Per indentazione si intendono gli spazi (o caratteri di tabulazione) a
sinistra del primo carattere dello statement
• In una sequenza di statement, uno statement deve avere la stessa
indentazione del precedente, altrimenti si genera un errore in
esecuzione
>>> a = 1
>>> b = 2
File "<stdin>", line 1
b = 2
^
IndentationError: unexpected indent

Sul concetto di oggetto in Python
• Un oggetto è un’entità caratterizzata da un insieme di attributi
e metodi
• Attributi e metodi in Python sono generalmente pubblici
• Si assumono noti i concetti della programmazione ad oggetti
• In Python "tutto è oggetto"
• Anche valori di tipi come int, long, float, string sono
"oggetti"
• Esistono attributi e metodi predefiniti associati a questi "tipi"
• La funzione predefinita dir() restituisce una lista di attributi e
metodi di un qualunque oggetto
>>> dir(-5)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delatt
r__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '_
_floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__g
t__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__in
vert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__ne
g__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdiv
mod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__
', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '_
_rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__',
'__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__'
, 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', '
real', 'to_bytes']

Esempi di invocazione di metodi su oggetti
• Sintassi:
nome_oggetto.nome_metodo(argomenti)
• Esempi di invocazione di metodi su valori numerici e
su stringhe
>>> (3+5j).real
3.0
>>> (3+5j).imag
5.0
>>> (-5).__abs__()
5
>>> ('Pippo').upper()
’PIPPO’

Tipizzazione dinamica
• In Python non si effettua la dichiarazione esplicita del tipo di
una variabile
• L’interprete determina a runtime il tipo di una variabile in base
al valore assegnatole
• Il tipo associato ad una variabile può cambiare nel corso
dell’esecuzione
• Si parla pertanto di tipizzazione dinamica
• La funzione predefinita type() restituisce il tipo di una
variabile
>>> x = "Pippo"; print(type(x))
<class ’str’>
>>> x = 123; print(type(x))
<class ’int’>
>>> x = 3.14; print(type(x))
<class ’float’>
>>> x = 3+5j; print(type(x))
<class ’complex’>
>>> x = [4, 5, 9]; print(type(x))
<class ’list’>

Sul concetto di variabile in Python (1)
• In linguaggi come C, C++, Java, che adottano un controllo
del tipo dei dati statico (a tempo di compilazione) una
variabile è un "contenitore di memoria" atto a mantenere un
dato di un certo tipo
• In Python, il modello di programmazione è
significativamente diverso:
• il linguaggio effettua un controllo dinamico dei tipi (a
tempo di esecuzione o runtime)
• l’operatore di assegnazione semplicemente associa un
nome ad un oggetto:
a = 5
• a è un nome per l’oggetto 5

Sul concetto di variabile in Python (2)
• Lo stesso "nome" può essere associato (binding) in momenti
successivi ad oggetti diversi, anche di tipi diversi:
a = 5; a = "Pippo"
• Questi nomi sono tipicamente chiamati "variabili" in
Python
• Un nome non può essere usato prima che sia stato
associato ad un valore
• Un oggetto esiste fintanto che esiste un nome che fa
riferimento ad esso

Statement di assegnazione
• In generale, l’operatore di assegnazione crea un’associazione (binding) tra
un nome ed un ’oggetto’
• La funzione predefinita id(my_var) restituisce un identificativo associato
all’area di memoria che contiene il valore associato al nome my_var
• Si consideri quanto illustrato nell’esempio seguente
• L’esempio mostra che, nel momento in cui un nome
(nell’esempio x) viene assegnato ad un nuovo valore
(x = 12), cambia l’area di memoria associata al nome
• Questo è molto diverso rispetto a quanto succede in
C/C++
>>> x = 5
>>> y = x
>>> print(id(x), id(y))
30696568 30696568
>>> x = 12; print(x)
12
>>> print(y)
5
>>> print(id(x), id(y))
30696544 30696568

Compound Statement
• I compound statement (if, while, for, try, def, ...)
"contengono" una sequenza (suite o body) di statement
elementari
• Il body di un compound statement è formato da linee con la
stessa indentazione allineate più a destra rispetto
all’istruzione che "le contiene"
• Python raccomanda di usare 4 caratteri spazio per ciascun livello di
indentazione e di non usare il carattere tab
#valore assoluto
a = int(input("Digita un numero intero e premi ENTER: "))
if (a >= 0):
b = a
else:
b = -a
print("b=", b)

Statement if
• if (cond) esegue una sequenza di istruzioni se cond
ha valore diverso da False
• Si consideri il seguente esempio:
>>> a=2
>>> if (a):
... print("eseguo if")
... else:
... print("eseguo else")
...
eseguo if
>>> if (a==True):
... print("eseguo if")
... else:
... print("eseguo else")
...
eseguo else

Statement if (2)
a = int(input("Digita un numero intero e premi ENTER: "))
# la funzione int puo' generare un errore
# se l'input da tastiera non e' corretto
# in questo caso il programma termina
print("Hai digitato",end=" ")
if (a > 0):
print("un numero POSITIVO ( >0)")
elif (a < 0):
print("un numero NEGATIVO ( <0)")
else:
print("ZERO")
• Le parentesi intorno alla condizione non sono necessarie
• La parte elif e la parte else sono facoltative
• Si possono aggiungere un numero di arbitrario di elif

Operatori and, or, not
• Ordine di priorità decrescente: not, and, or
not a and b or c equivale a: ((not a) and b) or c
• not ha priorità minore di altri operatori non-booleani
not a == b equivale a: not (a==b)
>>> True or False
True
>>> True and False
False
>>> not True
False
>>> not False
True
Operatore Valore restituito
a or b
b, se a è False o un valore assimilato a False
a, altrimenti
a and b
a, se a è False o un valore assimilato a False
b, altrimenti
not a
True, se a è False o un valore assimilato a False
False, altrimenti
>>> 3 or 5
3
>>> 0 or 5
5
>>> True or 5
True
>>> False or 5
5
>>> 3 and 5
5
>>> 0 and 5
0
>>> True and 5
5
>>> False and 5
False

Statement while
a = input("Digita qualsiasi cosa e poi ENTER (QUIT per terminare): ")
while (a != "QUIT"):
print("Hai digitato: ", a)
a = input("Digita qualsiasi cosa e poi ENTER (QUIT per terminare): ")
print("Hai digitato QUIT ed il programma termina.")
• while esegue un ciclo finché una condizione è vera

Statement while (2)
• Lo statement break nel corpo di un ciclo fa uscire dal ciclo
• Lo statement continue nel corpo di un ciclo salta all’iterazione successiva
conta = 0
while (True):
a = int(input("Digita un numero e premi ENTER (0 per terminare): "))
if (a > 0):
print("Hai digitato un numero positivo : viene contato")
elif (a < 0):
print("Hai digitato un numero negativo : NON viene contato")
continue
else:
print("Hai digitato 0 ed il programma termina.")
break
conta = conta + 1
print("Hai digitato %d numeri positivi." % conta)

Statement for
• Lo statement for esegue una sequenza di istruzioni (corpo del ciclo) per tutti gli
elementi di una struttura dati iterabile
• Vedremo dopo le strutture dati in Python
• La sintassi è:
for iterating_var in sequence:
corpo_del_ciclo
• break nel corpo del ciclo fa uscire dal ciclo
• continue nel corpo del ciclo salta all’iterazione successiva
• Esempio:
nomi = ['Antonio', 'Mario', 'Giuseppe', 'Francesco']
for nome in nomi:
print('Nome :', nome)

Statement for (2)
• E’ possibile iterare su una lista mediante un indice intero come
nell’esempio seguente:
nomi = ['Antonio', 'Mario', 'Giuseppe', 'Francesco']
for index in range (len(nomi)):
print('Nome :', nomi[index])

Funzioni
def funzione_1():
pass
def funzione_2(x):
return x
ret = funzione_1()
print("Valore di ritorno =", ret)
ret = funzione_2(1)
ret = funzione_2("PIPPO")
Valore di ritorno = None
Valore di ritorno = 1
Valore di ritorno = PIPPO
• Una funzione è un sottoprogramma al quale possono essere passati dei parametri
(argomenti) e che eventualmente restituisce un valore
• Per definire una funzione si usa lo statement def
• Una funzione che non prevede argomenti ha una lista di argomenti vuota ()
• Per ritornare al chiamante un oggetto x si usa lo statement return x
• Un oggetto speciale None è ritornato da una funzione se:
• il flusso di esecuzione della funzione termina senza aver eseguito un’istruzione return
• lo statement return viene eseguito senza argomenti

Funzioni: esempio
def max(x, y):
print("x =", x)
print("y =", y)
if (x >= y):
return x
else:
return y
ret = max(1, 1)
ret = max(2, 1)
s1 = "PIPPO"
s2 = "PIPPONE"
s3 = "PLUTO"
ret = max(s1,s2)
ret = max(s2,s3)
x = 1
y = 1
x = 2
y = 1
x = PIPPO
y = PIPPONE
Valore di ritorno = PIPPONE
x = PIPPONE
y = PLUTO
Valore di ritorno = PLUTO

Funzioni: argomenti, variabili locali e globali
def f1(x):
a = 3 # variabile locale
x += 1 # argomento
print("In f1:")
print("a =", a, "x =", x)
a = 99
x = 1
print("Prima di eseguire f1:")
print("a =", a, "x =", x)
f1(x)
print("Dopo aver eseguito f1:")
print("a =", a, "x =", x)
Prima di eseguire f1:
a = 99 x = 1
In f1:
a = 3 x = 2
Dopo aver eseguito f1:
a = 99 x= 1
• Un nome di variabile usato in una funzione è trattato come
una variabile locale
• Il valore assegnato ad una variabile locale non si riflette sul valore
assegnato ad una variabile con lo stesso nome definita all’esterno
della funzione
• Gli argomenti di una funzione sono trattati alla stregua di
variabili locali

Funzioni: argomenti, variabili locali e globali
• Per modificare in una funzione il valore associato ad un nome
di variabile definito esternamente, si usa lo statement global
def f2(x):
global a
a = 3 # variabile globale
x += 1 # argomento
print("In f1:")
print("a =", a, "x =", x)
a = 99
x = 1
print("Prima di eseguire f2:")
print("a =", a, "x =", x)
f2(x)
print("Dopo aver eseguito f2:")
print("a =", a, "x =", x)
Prima di eseguire f2:
a = 99 x = 1
In f2:
a = 3 x = 2
Dopo aver eseguito f2:
a = 3 x = 1

Funzioni: argomenti con valori di default
def f(x, y = 5, z = 3):
print("In f:",end=" ")
print("x =", x, "y =", y, "z =", z)
f(0, 1, 2)
f(0)
f(8, 1)
f(7, z = 2)
f(6, y = 2)
f(0, z = 2, y = 1)
In f: x = 0 y = 1 z = 2
In f: x = 0 y = 5 z = 3
In f: x = 8 y = 1 z = 3
In f: x = 7 y = 5 z = 2
In f: x = 6 y = 2 z = 3
In f: x = 0 y = 1 z = 2
• Per ogni argomento di una funzione si può specificare un valore di default
• Non è necessario che dato il default ad un argomento anche tutti gli
argomenti che seguono abbiano un default (come invece in C++)
• Quando ad un argomento è assegnato un valore di default, nella chiamata della
funzione, un parametro può essere specificato con la notazione nome = valore
• In tal modo i parametri possono essere passati in ordine diverso da quello con cui
sono elencati nella definizione della funzione

Strutture dati container in Python
• Uno degli aspetti peculiari del linguaggio Python è la ricchezza di strutture dati
definite dal linguaggio
• In particolare, il linguaggio offre al programmatore diverse strutture dati di tipo
container atte a contenere oggetti di vario tipo
• liste, tuple, dizionari, stringhe, set
• il modulo collections definisce ulteriori tipi container
• Le varie strutture dati differiscono in vari aspetti:
• il modo con il quale si può accedere agli oggetti contenuti
• la possibilità di iterare sugli elementi contenuti nella struttura dati
• l’eventuale ordinamento definito tra gli elementi contenuti
• la possibilità o meno di modificare gli elementi presenti nella struttura dati una volta che
sia stata "costruita"
• si parla di strutture dati mutabili o immutabili
• liste, dizionari, set sono mutabili mentre stringhe e tuple sono immutabili
In Python le stringhe sono immutabili. Dunque:
• s = "pippo"; s[0] = ’P’ produce un errore:
non è possibile modificare un carattere di una stringa in maniera diretta;
• s = "Pippo"; s = s + " e Pluto" produce l’allocazione a runtime di tre stringhe:
"Pippo" , " e Pluto" , e "Pippo e Pluto"

Liste
• Le liste sono strutture dati ordinate che possono contenere oggetti di tipi differenti
• Il seguente statement crea una lista associata al nome l:
l = [1, 2, "Pippo"]
• La scrittura [] indica una lista vuota
• Sulle liste si possono applicare gli operatori + e * come per le stringhe
• La funzione len(l) restituisce il numero di elementi di una lista l
• Gli elementi di una lista possono essere individuati e modificati tramite un indice come
per gli array in C/C++
• La scrittura l[i:j] indica la lista costituita dagli elementi di l compresi tra quello di
indice i (compreso) a quello di indice j (escluso)
• Se i non è specificato, si intende i=0
• Se j non è specificato, si intende j=len(l)
>>> l = [1, 2]
>>> m = ["Pippo", 3, 4]
>>> l + m
[1, 2, ’Pippo’, 3, 4]
>>> l*4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> m[0]
Pippo
>>> m[0] = 99; print(m)
[99, 3, 4]
>>> len(m)
3
>>> n = l + m[1:]; print(n)
[1, 2, 3, 4]
>>> n[1:2]
[2]
>>> n[1:3]
[2, 3]
>>> n[1:4]
[2, 3, 4]
>>> n[1:5]
[2, 3, 4]
>>> n[5:6]
[]

Liste: metodi
Una lista un oggetto sul quale si possono invocare dei metodi predefiniti
• l.append(obj) aggiunge obj "in coda" alla lista l
• l.extend(l1) estende l aggiungendo "in coda" gli elementi della lista l1
• l.insert(index,obj) aggiunge obj in l prima della posizione indicata da index
• l.pop(index) rimuove da l l’oggetto nella posizione index e lo restituisce
• l.remove(obj) rimuove la prima occorrenza di obj nella lista l
• l.reverse() dispone gli elementi della lista l in ordine inverso
• l.sort() dispone gli elementi della lista l in ordine crescente
• l.index(obj) restituisce l’indice della prima occorrenza di obj nella lista l
• l.count(obj) restituisce il numero di occorrenze di obj nella lista l
>>> l1 = [6, 7, 8, 9]
>>> l2 = [1, 2, 3, 4, 5]
>>> l1.append(10); print(l1)
[6, 7, 8, 9, 10]
>>> l1.extend(l2); print(l1)
[6, 7, 8, 9, 10, 1, 2, 3, 4, 5]
>>> l1.insert(0, "START"); print(l1)
[’START’, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5]
>>> l1.insert(6, "x"); print(l1)
[’START’, 6, 7, 8, 9, 10, ’x’, 1, 2, 3, 4, 5]
>>> l1.pop(0); print(l1)
’START’
[6, 7, 8, 9, 10, ’x’, 1, 2, 3, 4, 5]
>>> l1.remove("x"); print(l1)
[6, 7, 8, 9, 10, 1, 2, 3, 4, 5]
...
>>> l1.reverse(); print(l1)
[5, 4, 3, 2, 1, 10, 9, 8, 7, 6]
>>> l1.sort(); print(l1)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> l1.pop(-1)
10
>>> l1.index(1)
0
>>> l1.index(9)
8
>>> l1.index(10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 10 is not in list

• range(n) restituisce una lista formata dai numeri interi compresi tra 0 ed n−1
• range(m, n, step) restituisce una lista formata dai numeri interi compresi
tra m (incluso) ed n (escluso), con un incremento di step
• len(x) restituisce il numero di elementi di una lista x
(si può applicare anche a tuple e stringhe)
• max(l) restituisce l’elemento massimo di una lista l
Liste: altre funzioni predefinite
>>> range(5)
[0, 1, 2, 3, 4]
>>> range(1, 6, 2)
[1, 3, 5]
>>> len([0, 1, 2, 3])
4
>>> max([1.0, 2.5, -2.3, 1.3])
2.5
NOTA: questa slide si riferisce a Python 2
In Python 3, range() restituisce un oggetto di classe “range” e non più una lista
>>> a = range(5)
>>> print(a)
range(0, 5)
>>> print(type(range(5)))
<class 'range‘>

Tuple
• Le tuple sono strutture dati ordinate che possono contenere oggetti di tipi differenti
• Il seguente statement crea una tupla associata al nome t:
t = (1, 2, "Pippo")
• () indica una tupla vuota, (a,) indica una tupla con il solo elemento a
• Sulle tuple si possono applicare gli operatori + e * come per le stringhe
• La funzione len(t) restituisce il numero di elementi di una tupla t
• Gli elementi di una tupla possono essere individuati (ma non modificati) tramite un
indice come per gli array in C/C++
• La scrittura t[i:j] indica la tupla costituita dagli elementi di t compresi tra
• quello di indice i (compreso) a quello di indice j (escluso)
• Se i non è specificato, si intende i=0
• Se j non è specificato, si intende j=len(t)
>>> t1 = (1, 2)
>>> t2 = ("Pippo", 3, 4)
>>> t = t1 + t2; print(t)
(1, 2, ’Pippo’, 3, 4)
>>> len(t)
5
>>> t[0]
1
>>> t[2]
'Pippo'
>>> t[0] = 99
TypeError: ’tuple’ object does not support
item assignment
>>> t[1:3]
(2, ’Pippo’)
>>> t[1:1]
()
>>> t[5:5]
()

Creazione di liste mediante for
• Lo statement for può essere usato per creare liste i cui elementi sono generati da
un’espressione valutata iterativamente
• Esempi
>>> l1 = [ (2*x + 1) for x in range(0,10) ]
>>> print(l1)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> l2 = [ (x, x **2) for x in range(0,11) ]
>>> print(l2)
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49), (8, 64),
(9, 81), (10, 100)]
>>> l3 = [ chr(i) for i in range(ord('a'),ord('z')+1) ]
>>> print(l3)
[’a’, ’b’, ’c’, ’d’, ’e’, ’f’, ’g’, ’h’, ’i’, ’j’, ’k’, ’l’, ’m’, ’n’, ’o’,
’p’, ’q’, ’r’, ’s’, ’t’, ’u’, ’v’, ’w’, ’x’, ’y’, ’z’]

Dizionari
• Un dizionario è una struttura dati contenitore di coppie (chiave, valore) in cui
ciascun valore è identificato univocamente da una "chiave"
• Il seguente statement crea un dizionario associato al nome d:
d = {chiave1: val1, chiave2: val2, chiave3: val3}
• L’accesso agli elementi di un dizionario avviene fornendo il valore della chiave:
d[key]
• Se il valore di chiave non esiste nel dizionario, si produce un errore
• I dizionari sono strutture dati mutabili, il valore della chiave è immutabile
• L’operatore in restituisce True se una chiave è presente in un dizionario
>>> d = { "NA": "Napoli", "AV": "Avellino",
"BN": "Benevento", "CE": "Caserta",
"SA": "Salerno"}
>>> d["BN"]
’Benevento’
>>> d["MI"]
KeyError: ’MI’
>>> d[0]
KeyError: 0
>>> d["NA"] = "Naples"
>>> d["NA"]
'Naples'
>>> "NA" in d
True
>>> "AV" in d
True
>>> "MI" in d
False

Dizionari: metodiUna lista un oggetto sul quale si possono invocare dei metodi predefiniti
• d.clear() elimina tutti gli elementi del dizionario d
• d.copy() restituisce una copia del dizionario d
• d.has_key(key) restituisce True se in d esiste la chiave key
• d.items() restituisce una lista con le tuple (chiave, valore) in d
• d.keys() restituisce una lista con le chiavi in d
• d.values() restituisce una lista con i valori in d
• d.update(d2) aggiunge al contenuto di d quello di d2
• d.get(key,val) restituisce il valore associato a key, altrimenti val
• d.get(key) restituisce il valore associato a key, altrimenti None
>>> d = {"NA":"Napoli","AV":"Avellino","BN":"Benevento","CE":"Caserta","SA":"Salerno"}
>>> d.has_key("NA")
True
>>> d.has_key("MI")
False
>>> d.items()
[(’NA’, ’Napoli’), (’BN’, ’Benevento’), (’SA’, ’Salerno’), (’CE’, ’Caserta’), (’AV’, ’Avellino’)]
>>> d.keys()
[’NA’, ’BN’, ’SA’, ’CE’, ’AV’]
>>> d.values()
[’Napoli’, ’Benevento’, ’Salerno’, ’Caserta’, ’Avellino’]
>>> print(d.get("NA"))
Napoli
>>> print(d.get("MI"))
None
>>> d.update({"NA": "Naples", "MI": "Milano"})
>>> print(d)
{’AV’: ’Avellino’, ’NA’: ’Naples’, ’BN’: ’Benevento’, ’MI’: ’Milano’, ’SA’: ’Salerno’, ’CE’: ’Caserta’}

Uso di librerie in Python: import
• Lo statement import my_lib dice all’interprete di rendere visibile (nello script in cui si
trova) tutto ciò che è visibile a livello globale nel file my_lib.py
• In questo modo si possono usare variabili e funzioni definite in una libreria
• I nomi di variabili e funzioni della libreria sono associati al namespace my_lib
• Il nome n definito in my_lib.py dovrà essere riferito come my_lib.n in uno script che fa
import my_lib
• Se lo script my_lib.py contiene statement eseguibili, essi sono eseguiti nel momento in
cui è eseguito l’import
• Il file libreria my_lib.py si può trovare:
• o nella stessa cartella dove si trova lo script che fa l’import
• o in una cartella prevista dall’interprete (es. in C:Python27Libsite-packages)
• Lo statement from my_lib import * dice all’interprete di rendere visibili nel
namespace dello script corrente tutti i nomi definiti nella libreria my_lib.py
• In questo caso, il nome n definito in my_lib.py potrà essere direttamente riferito come n
nello script che fa l’import
• Occorre fare attenzione a possibili conflitti di nomi definiti in file differenti
• L’interprete Python rende già disponibili al programmatore molte librerie che
implementano funzioni di utilità (si parla di standard library del linguaggio)
• Ad es. time, datetime, string, os, sys, getopt, fileinput, ...
• Molte altre librerie Python possono essere scaricate ed installate con il tool pip
• Ad es. numpy, matplotib, …

Uso di import: esempio
# File: my_lib.py
currentYear = 2018
def currentAge(birthYear):
global currentYear
return (currentYear-birthYear)
print("Libreria my_lib caricata")
Libreria my_lib caricata
Eta' dei miei amici nell' anno 2018
Giovanni2: eta' 42
Mario: eta' 46
Andrea: eta' 40
Luigi: eta' 50
Giovanni: eta' 53
• L’esecuzione di my_lib_test.py
produce come output:
# File: my_lib_test.py
import my_lib
# NB: le chiavi devono essere uniche
annoNascita_amici = {
'Mario': 1972,
'Giovanni': 1965,
'Giovanni2': 1976,
'Andrea': 1978,
'Luigi': 1968 }
print("Eta' dei miei amici nell'anno ",
my_lib.currentYear))
for amico in annoNascita_amici:
print("%15s: eta'" % amico,end=" ")
print(my_lib.currentAge(
annoNascita_amici[amico]))
• Si osservi che gli elementi di un dizionario non sono memorizzati in un ordine
particolare, pertanto l’ordine con il quale l’iteratore in restituisce gli elementi di
annoNascita_amici non coincide con quello con il quale gli elementi sono stati scritti
nello statement di assegnazione

Uso di from-import: esempio
# File: my_lib.py
currentYear = 2018
def currentAge(birthYear):
global currentYear
return (currentYear-birthYear)
print("Libreria my_lib caricata")
Libreria my_lib caricata
Eta' dei miei amici nell' anno 2018
Giovanni2: eta' 42
Mario: eta' 46
Andrea: eta' 40
Luigi: eta' 50
Giovanni: eta' 53
• L’esecuzione di my_lib_test.py
produce come output:
# File: my_lib_test_2.py
from my_lib import *
# NB: le chiavi devono essere uniche
annoNascita_amici = {
'Mario': 1972,
'Giovanni': 1965,
'Giovanni2': 1976,
'Andrea': 1978,
'Luigi': 1968 }
print("Eta' dei miei amici nell'anno",
currentYear)
for amico in annoNascita_amici:
print("%15s: eta'" % amico,end=" ")
print(currentAge(
annoNascita_amici[amico]))
• L’output prodotto da questo programma è identico a quello prodotto dal precedente
• Si noti che i nomi currentYear e currentAge sono adesso nel namespace principale
• La notazione my_lib.currentYear e my_lib.currentAge produrrebbe un errore

Alcuni semplici script Python

Esempio #1: calcolo numeri primi
def primes(up_to):
primes = []
for n in range(2, up_to + 1):
is_prime = True
for divisor in range(2, n):
if n % divisor == 0:
is_prime = False
break
if is_prime:
primes.append(n)
return primes
print(primes(1000))
• Come esempio di funzione, si riporta sotto il codice di un programma che calcola i
numeri primi compresi tra 1 e 1000 mediante una funzione

Esempio #1: calcolo numeri primi
• L’output prodotto è mostrato sotto
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73,
79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163
, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251
, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349
, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443
, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557
, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647
, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757
, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863
, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983
, 991, 997]

Esempio #2: analisi di dati da file CSV (1)
Cognome,Nome,Voto,Lode
Amato,Alfredo,21,NO
Andreolli,Antonio,24,NO
Baresi,Carlo,19,NO
Carbonara,Francesco,27,NO
....
• Scrivere un programma Python che estragga da un file dati testuale in formato CSV
(comma separated values) i voti in trentesimi conseguiti da un insieme di studenti e
successivamente rappresenti con un istogramma la distribuzione dei voti nel
campione
• La struttura del file voti.csv è la seguente:
• Ogni riga contiene una sequenza di dati separati da virgole
• Il significato dei dati è descritto nella prima riga del file

# File: elabora-voti.py
csv_file = open("voti.csv", "r")
lines = csv_file.readlines()[1:] # Ignora la prima linea del file
votes = []
for line in lines:
line = line.rstrip('n')
data_item = line.split(',')
cognome = data_item[0]
nome = data_item[1]
voto = int(data_item[2])
lode = data_item[3]
if (voto == 30) and (lode == "SI"):
voto = 31 # 30 e lode si rappresenta come 31
votes.append(voto)
csv_file. close()
....
• Soluzione (prima parte):

# File: elabora-voti.py
....
import matplotlib.pyplot as plt
import numpy as np
hist, bin_edges = np.histogram(votes, bins=np.arange(18,33))
x = range(18,32)
plt.bar (x, hist, align='center', width=1)
x_labels = x[0:-1] + ['LODE']
plt.xticks(x, x_labels)
y_labels = range(0, max(hist)+1+1)
plt.yticks(y_labels)
plt.xlim(17, 32)
plt.ylim(0, max(hist) +1)
plt.xlabel('voti')
plt.ylabel('numero di studenti per voto')
plt.grid(True)
plt.show()
• Soluzione (seconda parte):

• Il programma produce come output la figura seguente:

Esempio #3: plot di una funzione
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0.0, 2.01, 0.01)
y = np.sin(2*np.pi*x)
plt.plot(x, y)
plt.margins(0.1)
plt.xlabel('x')
plt.ylabel('f')
plt.title('Plot di f = sin(2*pi*x)')
plt.grid(True)
plt.savefig("test.png")
plt.show()
• Output prodotto (test.png):

Esempio #3: plot di una funzione
x = np.arange(0.0, 2.01, 0.01)
y = np.sin(2*np.pi*x)
[ 0. 0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1 0.11
0.12 0.13 0.14 0.15 0.16 0.17 0.18 0.19 0.2 0.21 0.22 0.23
0.24 0.25 0.26 0.27 0.28 0.29 0.3 0.31 0.32 0.33 0.34 0.35
0.36 0.37 0.38 0.39 0.4 0.41 0.42 0.43 0.44 0.45 0.46 0.47
0.48 0.49 0.5 0.51 0.52 0.53 0.54 0.55 0.56 0.57 0.58 0.59
0.6 0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69 0.7 0.71
0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.8 0.81 0.82 0.83
0.84 0.85 0.86 0.87 0.88 0.89 0.9 0.91 0.92 0.93 0.94 0.95
0.96 0.97 0.98 0.99 1. 1.01 1.02 1.03 1.04 1.05 1.06 1.07
1.08 1.09 1.1 1.11 1.12 1.13 1.14 1.15 1.16 1.17 1.18 1.19
1.2 1.21 1.22 1.23 1.24 1.25 1.26 1.27 1.28 1.29 1.3 1.31
1.32 1.33 1.34 1.35 1.36 1.37 1.38 1.39 1.4 1.41 1.42 1.43
1.44 1.45 1.46 1.47 1.48 1.49 1.5 1.51 1.52 1.53 1.54 1.55
1.56 1.57 1.58 1.59 1.6 1.61 1.62 1.63 1.64 1.65 1.66 1.67
1.68 1.69 1.7 1.71 1.72 1.73 1.74 1.75 1.76 1.77 1.78 1.79
1.8 1.81 1.82 1.83 1.84 1.85 1.86 1.87 1.88 1.89 1.9 1.91
1.92 1.93 1.94 1.95 1.96 1.97 1.98 1.99 2. ]
[ 0.00000000e+00 6.27905195e-02 1.25333234e-01 1.87381315e-01
2.48689887e-01 3.09016994e-01 3.68124553e-01 4.25779292e-01
4.81753674e-01 5.35826795e-01 5.87785252e-01 6.37423990e-01
6.84547106e-01 7.28968627e-01 7.70513243e-01 8.09016994e-01
8.44327926e-01 8.76306680e-01 9.04827052e-01 9.29776486e-01
9.51056516e-01 9.68583161e-01 9.82287251e-01 9.92114701e-01
...
• np.arange(start,end,step) restituisce una lista di numeri float
prodotti a partire da start con incremento step fino al valore massimo end (escluso)
• np.sin(2*np.pi*x) (essendo x una lista) restituisce una lista di numeri float
prodotti applicando la funzione sin(2*np.pi*x) a ciascun elemento di x

Python@Unina - Theory

More Related Content

What's hot (20)

Similar to Python@Unina - Theory (20)

More from NaLUG (20)

Python@Unina - Theory