PYTHON

Sommario

PYTHON
CAPITOLO 1 Cos’è Python?
CAPITOLO 2 Istallazione di Python
CAPITOLO 3
Iniziare a programmare con Python
CAPITOLO 4
Interprete e compilatore
CAPITOLO 5
Il tuo primo programma Python
CAPITOLO 6
Valori, operatori, variabili ed espressioni
CAPITOLO 7
true, false, if, else: gli operatori condizionali e logici
CAPITOLO 8
Le funzioni di Python
Capitolo 9
Le interazioni
CAPITOLO 10
Le liste
CAPITOLO 11
I dizionari di Python
CAPITOLO 12
 La gestione dei file con Python
CAPITOLO 13
L’indentazione
CAPITOLO 14
IDLE, un’interfaccia visuale per Python
CAPITOLO 15
Directory, moduli e package
CAPITOLO 16
Le eccezioni in Python
Conclusioni
 CAPITOLO 1
Cos’è Python?

Prima di addentrarci nello specifico in tutte le funzioni e le caratteristiche di

Python, è bene fare una panoramica generale, rispondendo a una semplice
domanda: cos’è Python?
Python è sostanzialmente un linguaggio di programmazione Open Source che
ha un largo spettro di utilizzi, in quanto multi-purpose e multi-paradigma.
Python può essere utilizzato per la creazione di software da istallare sui
terminali, ma anche per soluzioni da utilizzare sul web.
Ma la grande versatilità di Python non si ferma qui, infatti, questo linguaggio
di programmazione può essere impiegato su diversi sistemi operativi, tra cui i
più diffusi sono ad esempio Windows, Linux o Mac OS.
La sintassi di Python è piuttosto lineare, quindi è stata resa anche più facile
da fruire.
Python ha anche influenzato in vario modo il mondo dei linguaggi per la
programmazione destinati ad ambiti differenti come Java, Ruby e addirittura
Swift che è un prodotto della Apple.
Un'altra caratteristica molto importante di Python è il sistema automatizzato
che gestisce la memoria. Questo limita quei fenomeni di overheard e porta
un risparmio molto importante delle risorse accessorie, per evitare il consumo
eccessivo di script di esecuzione.
A tutto questo si va ad aggiungere la presenza di una libreria integrata che
migliora in maniera sostanziale la produttività e i vari meccanismi legati alla
gestione delle eccezioni e gli esiti imprevisti o errori che derivano
essenzialmente dall'esecuzione delle applicazioni.
Come dicevamo in precedenza Python si distingue anche dagli altri linguaggi
di programmazione per la semplicità. Infatti, è un linguaggio che permette
agli sviluppatori di imparare velocemente la sua applicazione, quindi non c'è
bisogno di essere degli sviluppatori avanzati per cominciare a utilizzare
Python, almeno per ciò che concerne le implementazioni basilari. Questo
perché Python è basato su una sintassi piuttosto intuitiva, per cui il codice
sorgente risulta facilmente leggibile e memorizzabile.
Tutto questo fa di Python uno dei linguaggi di programmazione più in voga
per lo sviluppo di progetti in cui non sono presenti sviluppatori Senior che
hanno alle spalle una conoscenza più allargata dei sistemi di programmazione
più complessi.
Una curiosità che riguarda Python è legata proprio al suo nome. Quando fu
creato negli anni ’90, lo sviluppatore gli diede questo nome non in
riferimento ai pitoni intesi come rettili, ma al gruppo comico Monty Python,
in particolare rifacendosi alla loro programma televisivo “Monty python's
Flying Circus”. L'idea era proprio quella di basare tutto sulla semplicità,
mettendo appunto un linguaggio di programmazione con cui poter sviluppare
applicazioni anche molto complesse, ma con una struttura modulare lineare e
molto facile da fruire.
In più è bene ricordare che Python è gratuito e la licenza è molto permissiva.
Caratteristiche molto rare per un linguaggio di programmazione così robusto
e versatile.
Dobbiamo solo pensare che alcuni siti web importantissimi del calibro di
YouTube sono stati realizzati proprio utilizzando Python.
Un altro vantaggio di Python è sicuramente la portabilità. Quindi una
sorgente scritta su una piattaforma Windows, può essere poi facilmente
trasportata su un sistema operativo differente, ad esempio Linux e questo è
sicuramente un altro grande punto a favore di questo linguaggio di
programmazione.
Grazie a questa guida potrai iniziare a muovere i tuoi primi passi nel mondo
di Python. Imparerai le basi della programmazione che concernono questo
straordinario strumento. Mediante l’utilizzo di esempi pratici che potrai
utilizzare come esercizi, sarai capace di iniziare a “dialogare” con Python,
capendo il suo linguaggio e i costrutti basilari che rappresentano il punto di
partenza per approfondire tutte le sue declinazioni.
Il consiglio fondamentale è quello di leggere questa guida accostandola a un
computer che sia esso desktop, portatile, Linux, Windows o Mac OS. Questo
ti permetterà di esercitarti praticamente replicando sul terminale gli esempi
che ti verranno proposti.
Quasi sicuramente il tuo computer ha già Python istallato, se così non fosse, o
se la tua versione fosse obsoleta, imparerai anche a istallarlo e aggiornarlo in
modo facile e veloce.
 CAPITOLO 2
Istallazione di Python

In questo capitolo ci occuperemo dell’Istallazione di Python su diversi

sistemi operativi come Linux, Mac OS e Windows.
C’è però da fare un piccolo appunto, poiché le versioni di Python sono due, la
2x e la 3x. Nonostante la 2x sia quella maggiormente usata per via della sua
anzianità, il consiglio è di dedicarsi solo alla 3x perché è naturalmente quella
che, pur prendendo il testimone dalla precedente, continuerà a essere
sviluppata, aggiornata e migliorata in futuro.
Istallazione su Linux
È bene sapere che le distribuzioni basate sul Kernel Linux, hanno già Python
di default all'interno del PEG di installazione. Per questo chi intende
sviluppare dei software in ambiente Linux, potrà facilmente trovare Python
già presente nel pacchetto. Tuttavia potrebbe accadere che la versione del
linguaggio programmazione non sia la più recente, in questo caso è
necessario fare un aggiornamento.
Per verificare la presenza di Python su Linux basta usare questi comandi da
shel:
$ python
$ python3
Se entrambi i comandi non danno esiti, significa che Python non è presente.
Se il primo comando avvia Python, vuol dire che è presente solo la versione
2x, giocoforza in relazione all’esito del secondo comando, sapremo se Python
3x (quello che ci interessa) è già presente o meno sul terminale.
L’esempio che segue spiega come installare Python in un sistema Ubuntu, ma
lo stesso vale anche per Debian e relative varianti.
Prima di tutto dobbiamo lanciare il gestore di pacchetti apt-get per
l'installazione della libreria openssl .
$ sudo apt-get install libssl-dev openssl
$ sudo apt-get install libssl-dev openssl
In seguito andremo a utilizzare il download manager wget per scaricare la
versione di Python che ci interessa, in questo caso l’ultima del 3x.
$ wget https://www.python.org/ftp/python/3.4.3/Python-3.4.3.tgz
A questo punto otterremo un archivio compresso scompattabile tramite
questo comando:
$ tar -xvf Python-3.4.3.tgz
Ora bisogna andare nella cartella dove è stato scompattato l’archivio, per
procedere con l’istallazione:
$ cd Python-3.4.3/
$ ./configure
$ make
$ sudo make install
$ ./python

Installazione su Mac OS o SX?

Come avviene per Linux anche per quanto riguarda i sistemi operativi Mac
OS, normalmente Python è già disponibile all'interno del package. Tuttavia se
la versione presente non dovesse essere aggiornata, si potrà effettuare
tranquillamente un upgrade andando sul sito ufficiale e scaricando il
pacchetto che è un file con estensione ".pkg ", disponibile sia nella versione
32 bit, sia nella versione da 64 bit.
Gli installer sono molto facili da lanciare, basta un semplice doppio click.
Dopodiché si procederà con l'inserimento del nome utente, della password
dell'amministratore e poi partirà il setup del linguaggio delle librerie.
Dopodiché basterà richiamare il comando che riportiamo di seguito sul
terminale.
$ python

Per quanto riguarda la versione di default su sistemi operativi Mac di seguito

riportiamo i percorsi che solitamente sono presenti all'interno dei terminali
per raggiungere Python su Mac OS.

"/System/Library/Frameworks/Python.framework"
"/usr/bin/python"

Istallazione su Windows
Per quanto riguarda i sistemi Windows, la situazione è un po' differente,
infatti, gli sviluppatori della Python mettono a disposizione un installer
pensato proprio per Windows, sia su architettura da 32 bit, sia su architettura
a 64 bit. Questo installer è scaricabile dal sito ufficiale di Python.
Una volta terminato il download bisogna procedere con un doppio clic sul
file, a questo punto si aprirà una schermata in cui bisogna scegliere se
consentire l'accesso a Python solo all'utente corrente a tutti quelli che hanno
accesso al terminale.
Si procederà cliccando sul tasto “Next”. E poi si sceglierà la directory di
installazione che potrebbe essere per esempio, quella che riportiamo di
seguito.

"C:\Python\"

Si procederà nuovamente cliccando sul tasto “Next”, accedendo alla

schermata per personalizzare l'installazione. Tuttavia, per quanto riguarda
neofiti e bene lasciare inalterata l'impostazione di predefinita.
Cliccando nuovamente sul tasto “Next” si potrà passare alla vera e propria
fase di installazione.
Tutto avverrà in maniera assolutamente automatica e una volta completata
l'installazione basterà cliccare sul tasto “Finish”.
Per fare una verifica e capire che effettivamente è andato tutto per il meglio,
basterà recarci sul tasto “Start”, poi “tutti i programmi” e vedere se tra questi
c’è Python. Cliccandoci si aprirà una finestra interattiva con all'inizio la
parola Python è la versione che abbiamo installato.
A questo punto l'ambiente di programmazione sarà pronto e potrà essere
utilizzato dallo sviluppatore.
 CAPITOLO 3
Iniziare a programmare con Python

Per iniziare a programmare con Python bisogna imparare a interfacciarsi e

“parlare la sua lingua”. Infatti, a differenza dei linguaggi umani, Pythaon ha
un linguaggio piuttosto ridotto. Questo linguaggio è fatto da una serie di
parole chiave che sono molto importanti per la programmazione. Durante la
creazione di un programma potrai scegliere le tue parole chiavi che
tecnicamente sono chiamate variabili (ne parleremo in seguito).
Tuttavia Python ha alcune parole riservate che tu non potrai mai usare nelle
variabili, eccole:
and, de,l global, not, with, as, elif, if, or, yield, assert, else, import, pass,
break, except, in, raise, class, finally, is, return, continue, for, lambda, try,
def, from, nonlocal, while.
Nel corso dei seguenti capitoli impareremo a utilizzare queste parole
riservate.
L’esempio classico che si fa quando si inizia a programmare con Python è il
seguente:
print ('Hello World!' )
Si tratta di una frase elementare, ma sintatticamente corretta che inizia con la
funzione print , seguita da una stringa di testo racchiusa tra virgolette
singole. Le stringe possono anche essere racchiuse in virgolette doppie,
tuttavia le singole sono le più utilizzate. C’è da dire però che queste possono
essere interpretate erroneamente da Python in alcuni casi, per cui spesso è
preferibile usare le doppie. Ora che abbiamo a disposizione una frase che
useremo come punto di partenza per la programmazione in Python, dobbiamo
capire come interagire con esso.
Dopo aver lanciato Python sul terminale, vedremo apparire una finestra con
una dicitura simile a questa:

1. pi@raspberrypi:~ $ python3
 2. Python 3.7.3 (default, Dec 20 2019, 18:57:59)
3. [GCC 8.3.0] on linux
4. Type "help" , "copyright" , "credits" or "license" for more
information.
5. >>>

Focalizziamoci sull’ultima riga, in altre parole sul prompt >>> Ecco, questo
è il modo in cui Python ci chiede cosa vogliamo fare.
Come esempio puoi stampare a video qualsiasi frase rispettando la sintassi
vista in precedenza:

1. print ( 'Ciao' )
2. print ( 'Buone feste' )
3. print ( 'sto imparando a usare Python' )

Fai attenzione però a non sbagliare la sintassi, altrimenti ti succederà questo:

1. print 'sto scrivendo un programma'

2. File "<stdin>" , line 1
3. print 'perchè è molto potente
4. ^ SyntaxError: Missing parentheses in call to 'print'
5. >>>

Come puoi notare, mancano le parentesi, quindi Python ti definisce l’errore.

Quando devi terminare una conversazione con Python puoi seguire due
strade; chiudere la finestra oppure usare l’apposito comando:
>>> quit()
 CAPITOLO 4
Interprete e compilatore

Python in quanto linguaggio di alto livello può essere traslato su vari

computer utilizzando un interprete che funge appunto da traduttore di
linguaggio, questi sono denominati: interpreti e compilator i.
Python è un interprete che legge il codice sorgente scritto dal programmatore
e lo esegue. Quindi possiamo digitare un comando in modalità interattiva,
Python lo elaborerà in modo veloce, diventando poi disponibile per
interpretare il comando o frase successivo.
Per fare un esempio, possiamo dire a Python di memorizzare un valore che ci
servirà nel corso della programmazione. Ovviamente dobbiamo assegnare un
nome alla memorizzazione del valore, questo nome viene solitamente definito
“variabile ”.

1. >>> x = 7
2. >>> print (x)
3. 7
4. >>> y = x * 5
5. >>> print (y)
6. 35

Traducendo in modo discorsivo il precedente esempio:

1. abbiamo detto a Python di memorizzare il numero 7, usando

l’etichetta “x” per recuperarlo.
2. Usiamo print per verificare che Python abbia effettivamente
memorizzato il valore.
3. Costatiamo che il valore di x è 7
4. Chiediamo a Python di recuperare “x” e moltiplicarla con il
simbolo * per 5 e di mettere il risultato della moltiplicazione
nel valore “y”.
5. Usiamo il comando print per verificare il valore “y”.
6. Vediamo che il risultato è 35, quindi il risultato della
 moltiplicazione 7*5.

È facile comprendere che le varie istruzioni date a Python sono concatenate,

cioè il sistema è in grado di memorizzare quello che abbiamo scritto nei
comandi precedenti e quindi utilizzare i dati in quelli successivi.
Questo è ciò che fa un interprete , nel caso di Python questo interprete di alto
livello si chiama C.
Il compilatore invece deve necessariamente memorizzare tutto il programma
in un file, quindi eseguire un procedimento per tradurre il tutto in linguaggio
macchina, quello più semplice usato dai terminali, restituendo un file
esecutivo.
 CAPITOLO 5
Il tuo primo programma Python

Forse non te ne sei ancora reso conto, ma eseguendo gli esempi che abbiamo
riportato in questo capitolo, hai già creato il tuo primo programma. Infatti, hai
chiesto a Python di eseguire delle operazioni di moltiplicazione basilari,
usando la memorizzazione delle variabili. Questo è in tutto e per tutto un
programma, anche se allo stadio più elementare.
Un programma, infatti, è costituito da una sequenza di operazioni volte a
risolvere un problema. Proprio sulla base della risoluzione dei problemi
possiamo andare ad addentrarci nella creazione di programmi più avanzati.
Mettiamo che tu voglia fare un’analisi dei termini più utilizzati nel blog di un
competitor, per fare ad esempio un piano editoriale SEO. Fare questo lavoro
manualmente sarebbe molto difficile, richiederebbe molto tempo e potresti
commettere degli errori, poiché dovresti stampare tutti i post del blog o
comunque quelli della categoria che ti interessa, leggerli ed evidenziare tutte
le parole che ti interessano, per poi contarle tutte e capire quali sono le più
utilizzare. Sicuramente impazziresti. Mentre con un semplice programma
Python, risolveresti questo problema in pochi minuti. Vediamo come.

1. nomeFile = input( 'Inserisci il file:' )

2. file = open(nomeFile, 'r' )
3. contatore = dict()
4. for riga in file:
5. parole = riga.split()
6. for parola in parole:
7. contatore[parola] = contatore.get(parola, 0) + 1
8. bigcont = None
9. bigparola = None
10. for parola, cont in list(contatore.items()):
11. if bigcont is None or cont > bigcont:
12. bigparola = parola
13. bigcont = cont
14. print (bigparola, bigcont)
Per lavorare al meglio sulla programmazione è bene essere a conoscenza di
alcuni costrutti concettuali che si utilizzano non solo in Python, ma che fanno
parte anche degli altri linguaggi di programmazione, del linguaggio macchina
e di quelli di alto livello. Tra questi troviamo:

input , che serve per ottenere i dati, nel nostro caso dal
programmatore o dall’utente.
output , visualizza sullo schermo, oppure salva su una
memoria fisica.
Esecuzione sequenziale , che dice di eseguire le istruzioni
nell’esatta sequenza in cui sono inserite nello script.
Esecuzione condizionale , che verifica le condizioni e le segue
secondo le variabili.
Esecuzione ripetuta : che esegue le istruzioni in modo
ripetitivo.
riuso , riutilizza le istruzioni assegnate nell’intero
programma.

In sostanza un programma intreccia alcuni o tutti questi schemi per

raggiungere l’obiettivo, quindi per risolvere il problema per cui è stato creato.
Nell’esempio del semplice programma per la ricerca delle parole nei post dei
blog, sono stati inseriti tutti questi schemi e andando avanti con la lettura di
questa guida riuscirai a identificarli e interpretarli nella maniera corretta.
 CAPITOLO 6
Valori, operatori, variabili ed espressioni

Prima di andare avanti è bene chiarire il concetto di valore . Guardando gli

esempi che ho riportato nei capitoli precedenti, puoi individuare i valori senza
troppe difficoltà, infatti, questi sono sempre racchiusi nelle virgolette singole
(o in casi differenti doppie). Quando un valore è caratterizzato da una
sequenza di caratteri, il tipo è definito ‘str ’ (da stringa ), quando invece si
tratta di un numero intero, il tipo è ‘int ’, mentre per i decimali il tipo è ‘float
’.
Per identificare il tipo di un valore puoi ricorrere al comando type , così come
vedi nell’esempio che segue:

1. >>> type( 'Hello World!' )

2. < class 'str' >
3. >>> type(40)
4. < class 'int' >

Mentre per quanto riguarda i decimali, la verifica si ottiene così:

1. >>> type(0.2)
2. < class 'float' >

Come puoi notare, sia il numero intero del primo esempio che il decimale del
secondo, non è inserito tra le virgolette. Infatti, Python interpreta come
stringhe tutti i valori inseriti tra le virgolette, come puoi vedere nell’esempio
che segue.

1. >>> type( '13' )

2. < class 'str' >
3. >>> type( '1.2' )
4. < class 'str' >

Molta attenzione va anche data ai numeri molto grandi, in cui non vanno
assolutamente inserite le virgole, altrimenti Python li leggerà come una
stringa composta di diversi numeri interi.
 1. >>> print (1,000,000)
2. 1 0 0

Ora invece approfondiamo il concetto di variabili . Come abbiamo visto in

precedenza una variabile è sostanzialmente un nome che è assegnato a un
valore in fase di scrittura del programma.
Proviamo a dare dei nomi ad alcuni valori usando il simbolo = e vediamo poi
come richiamarli:

1. >>> messaggio = 'Buongiorno a tutti'

2. >>> numero = 300

Per visualizzare questi valori procederemo in questo modo:

1. >>> print (numero)

2. 300
3. >>> print (messaggio)
4. Buongiorno a tutti

È molto importante usare nomi indicativi ed esaustivi, anche lunghi e

comprensivi di numeri, a patto che questi siano inseriti all’interno della frase
e mai all’inizio. Le maiuscole sono consentite e il segno di linea basso, è
solitamente usato per identificare nomi compositi come nome_utente .
Qualora sia assegnato un nome errato a un valore, il sistema ce lo segnalerà
come nell’esempio che segue:

1. >>> 3inquilino = 'Mario'

2. SyntaxError: invalid syntax

Un ruolo fondamentale nella programmazione è ricoperto dagli operatori

oppure operandi , questi sono:

+ addizione
- sottrazione
* moltiplicazione
/ divisione
** esponente
Ecco degli esempi pratici:

1. 20 + 32
2. ora - 1
3. ora * 60 + minuti
4. minuti / 60
5. 5 ** 2
6. (5+9) * (15-7)

Adesso che conosciamo anche gli operatori possiamo definire e conoscere il

concetto di espressione . Questa è in pratica una combinazione di valori ,
variabili e operatori . Ecco di seguito un esempio di espressioni.

1. 15
2. x
3. x + 14

Tuttavia quando appaiono più operatori in una singola espressione, Python

segue un preciso ordine di precedenza, eccolo:

1. parentesi
2. esponente
3. moltiplicazione e divisione (alla pari)
4. addizione e sottrazione (alla pari).

Nel caso di operatori con la stessa valenza, la precedenza è data da sinistra

verso destra.
L’operatore modulo è invece caratterizzato dal simbolo della percentuale e
restituisce il resto del primo operando , diviso il secondo:

1. >>> quoziente = 8 / 3
2. >>> print (quoziente)
3. 2,66666666
4. >>> resto = 8 % 3
5. >>> print (resto)
6. 2

Una precisazione va fatta per gli operatori + e * , infatti, questi sono utilizzati
anche per le stringhe , tuttavia non hanno una funzione matematica. Il +
serve per concatenare le stringhe :

1. >>> numero1 = 20
2. >>> numero2 = 25
3. >>> print (numero1+numero2)
4. 45

Mentre l’operatore * moltiplica il contenuto di una stringa per un numero

intero:

1. >>> stringa = 'Test'

2. >>> numeroDiRipetizioni = 3
3. >>> print (stringa * numeroDiRipetizioni)
4. Test Test Test

È d’obbligo dedicare un piccolo paragrafo ai commenti , infatti, questi ultimi

sono utili quando i programmi diventano più strutturati e complicati. Grazie
all’inserimento dei commenti possiamo aggiungere delle note con la
spiegazione di quello che stiamo facendo. I commenti si aprono con il
simbolo # e non vanno in nessun modo a interagire con il programma, sono
soltanto un riferimento per il programmatore.

1. # cerco la percentuale di utilizzo del computer

2. percentuale_computer = (uso_computer * 100) / 50
 CAPITOLO 7
true, false, if, else: gli operatori condizionali e logici

Per programmare con Python, bisogna familiarizzare con le espressioni

booleane . Nonostante il nome possa far pensare a qualcosa di estremamente
complicato, in realtà un’espressione booleana è un’espressione vera o falsa .
In programmazione per operare con le espressioni di questo tipo si usa
l’operatore == che tecnicamente confronta due operandi e restituisce True se
sono uguali (dall’inglese true, vero) e False (dall’inglese false, Falso) nel
caso non siano uguali. Vediamo un esempio pratico:

1. >>> 3 == 3 True
2. >>> 5 == 2 False

True e false sono operatori di classe bool e non sono assolutamente stringhe .
Per quanto riguarda gli operatori per fare confronti, non esiste solo quello
riportato nel precedente esempio == , ma anche altri operatori che eseguono
determinati confronti, eccoli:

x != y # x non è uguale a y
x > y # x è più grande di y
x < y # x è più piccolo di y
x >= y # x è più grande o uguale a y
x <= y # x è più piccolo o uguale a y

Gli operatori logici in Python sono:

and , restituisce True se le espressioni alla sua sinistra e alla

sua destra sono vere. In caso contrario: False .
or , restituisce True se almeno una delle sue è vera. Altrimenti:
False .
not , inverte i valori, quindi falso diventerà vero e viceversa.

Ecco alcuni semplici esempi:

1. >>> 1 == 1 and 2 == 2
2. True
 3. >>> 1 == 1 or 2 == 3
4. True
5. >>> 1 == 2 or 2 == 3
6. False
7. >>> not (1 == 1)
8. False

Le dichiarazioni condizionali sono molto importanti quando si scrive un

programma, in quanto spesso abbiamo la necessità di controllare le
condizioni e cambiare la “reazione” del programma. L’istruzione if o anche
chiamata condizione è un punto focale in tutta la programmazione Python.
Infatti, grazie a if possiamo scrivere delle istruzioni composte in cui
l’istruzione if è seguita da due punti e le righe successive sono indentate.
Con questo tipo di istruzione possiamo fare in modo che qualora la
condizione logica fosse vera, questa sarà eseguita, nel caso contrario verrà
ignorata.
Vediamo un esempio pratico:

1. if x > 0 :
2. print ( 'uso x per gli esempi' )
3. if x < 0:
4. # Devi gestire i valori negativi
5. pass

Come puoi vedere, qui ho usato l’istruzione pass che funge da promemoria
con un commento . In più ricorda sempre di lasciare una riga vuota alla fine
di un blocco , altrimenti si verificherà un errore di sintassi.
Ci sono anche altri modi di usare if , in particolare quando ci sono due
possibilità e tramite la condizione il programma si deve individuare quale
delle due seguire. In questo caso si introduce anche else , vedi l’esempio di
seguito:

1. if x > 0 :
2. print ( 'x è maggiore di 0' )
3. else :
 4. print ( 'x è minore o uguale a 0' )

Ma se le possibilità fossero più di due? Bene anche in questo caso c’è una
soluzione per fare in modo che Python esegua correttamente il nostro
programma. Questa soluzione prevede l’aggiunta di elif , vedi l’esempio:

1. if x < 0:
2. print ( 'x è minore di 0' )
3. elif x > 0:
4. print ( 'x è maggiore di 0' )
5. else :
6. print ( 'x è uguale a 0' )
 CAPITOLO 8
Le funzioni di Python

La funzione nella programmazione è una sequenza di istruzioni che esegue un

calcolo. Il nome della funzione è type , mentre l’espressione che si trova tra le
parentesi è l’argomento . In questo modo è possibile richiamare le funzioni in
qualsiasi parte del codice del programma e fare in modo che eseguano i
calcoli per cui sono state create, dandoci il valore di ritorno.
Con Python, non c’è necessità di creare funzioni o librerie ex novo, infatti, gli
sviluppatori hanno già fornito questo linguaggio di programmazione di una
folta schiera di funzioni da utilizzare per risolvere i più disparati problemi. Le
funzioni min e max , ad esempio, sono state create per restituire il valore più
grande e quello più piccolo contenuti in una stringa .

1. >>> max( 'abcdefgh' )

2. 'h'
3. >>> min( 'abcdefgh' )
4. 'a'

Come puoi vedere dall’esempio, la funzione max ha individuato il carattere

“h” come il più grande della stringa , mentre il valore min ha individuato la
“a” come carattere più piccolo.
Un’altra funzione molto interessante e utile è len che restituisce il numero di
elementi contenuti in una stringa o argomento .

1. >>> len( 'ciao' )

2. 4

Con la funzione int puoi convertire invece un valore in un numero intero,

oppure, qualora non fosse possibile, otterrai un errore.

1. >>> int( '52' )

2. 52
3. >>> int( 'Prova' )
4. ValueError: invalid literal for int() with base 10: 'ciao'
Con float e str puoi convertire un valore a virgola mobile in una stringa e
viceversa.

1. >>> float(32)
2. 32.0
3. >>> str(32)
4. '32'

Tuttavia se vuoi definire una funzione , quindi crearne una tua, puoi farlo
utilizzando def . Facciamo un esempio:

1. >>> nome = 'Agostino'

2. >>> def salutaUtente(nome):
3. ... print ( 'Ciao' + nome)
4. ...
5. >>> salutaUtente(nome)
6. Ciao Agostino
 Capitolo 9
Le interazioni

Il ciclo while è stato pensato dai creatori di Python per effettuare delle
interazioni in modo semplice e preciso. Si tratta di automatizzazioni spesso
ripetitive che caratterizzano molte attività svolte dai terminali.

1. n=3
2. while n > 0:
3. print (n)
4. n=n-1
5. print ( 'Azione!' )

In questo semplice ma efficace esempio abbiamo replicato in forma di

programma il conto alla rovescia di un regista. In sostanza abbiamo detto a
Python di mostrare il valore “n” che è uguale a 3, decrementandolo di 1 fino
a quando questo non sarà maggiore di 0, dopo di che dovrà mostrare la frase
“Azione!”.
Scrivendo questi codici si può anche fare in modo che il flusso ricominci da
capo, portando quindi il programma a un punto precedente, questo
tecnicamente è chiamato loop .
Nell’esempio che abbiamo fatto precedentemente, il loop aveva 3 interazioni
che lo portavano a ripetere il ciclo con delle variabili, il decremento di 1.
Dopo di che c’è stata una condizione che ha restituito un falso , cioè quando
il valore di “n” non è stato maggiore di 0, per cui il loop si è interrotto e ha
mostrato la parola “Azione!” Questa variabile che controlla la terminazione
del loop è detta variabile di interazione . Qualora questa non fosse presente,
il loop continuerebbe all’infinito.
L’istruzione while crea quindi un ciclo infinito che si interrompe solo quando
interviene una condizione falsa .
Tuttavia si può lavorare anche su elementi definiti come righe di parole o
numeri. In questo caso è meglio usare l’istruzione for .
Questa istruzione va a interagire con tutti gli elementi noti attraversandoli
uno per uno.

1. clienti = [ 'Rossi' , 'Bianchi' , 'Verdi' ]

2. for cliente in clienti:
3. print ( 'Salve: ' , cliente)
4. print ( 'Salve a tutti!' )

Ecco l’output di questo ciclo for :

1. Salve: Bianchi
2. Salve: Rossi
3. Salve: Verdi
4. Salve a tutti!
 CAPITOLO 10
Le liste

Bisogna fare molta attenzione a non confondere le stringhe con le liste .

Infatti, le prime sono composte di caratteri, mentre le liste possono contenere
qualsiasi valore e sono definite dalle parentesi quadre.

1. [539,367, 670, 491]

2. [ 'Aglio' , 'Olio' , 'peperoncino' ]
3. [ 'test' , 7.9, 300, [40, 70]]

In questo esempio vediamo nella prima riga una lista di numeri interi, nel
secondo rigo una lista di stringhe e in fine nella terza riga troviamo una lista
che contiene una stringa , un float , un numero intero e addirittura un’altra
lista .
Quindi la sintassi per accedere alle liste prevede come abbiamo detto, l’uso
delle parentesi quadre in cui è contenuto l’indice che abbiamo deciso di
selezionare. È importante sapere che i valori all’interno di un indice si
contano partendo da 0 e non da 1, vedi l’esempio:

1. >>> ingredienti = [ 'Aglio' , 'Olio' , 'Peperoncino' ]

2. >>> print (ingredienti[0])
3. Aglio

Le liste consentono di fare un’operazione che nelle stringhe ci è negata.

Infatti, possiamo modificare l’ordine degli elementi presenti nelle stesse.
Nell’esempio che segue andremo a modificare il penultimo elemento della
lista modificandolo con “Prezzemolo”.

1. >>> ingredienti[1] = 'Prezzemolo'

2. >>> print (ingredienti)
3. [ 'Aglio' , 'Prezzemolo' , 'Peperoncino' ]

Anche nelle liste l’operatore in ha la stessa funzione:

1. >>> ingredienti = [ 'Aglio' , 'Olio' , 'Peperoncino' ]

 2. >>> 'Aglio' in ingredienti
3. True
4. >>> 'Pepe' in ingredienti
5. False

Con le liste è possibile fare davvero molte cose e Python mette a disposizione
dei programmatori tutta una serie di operatori e metodi che possono
rispondere alle più disparate esigenze. Adesso andremo a elencarne alcuni tra
i più importanti e utili.
Per scorrere semplicemente una lista puoi utilizzare il ciclo for :

1. for ingrediente in ingredienti:

2. print (ingrediente)

Per scrivere o aggiornare gli elementi devi usare gli indici e la funzione len e
range :

1. numeri = [10, 25, 66]

2. for i in range(len(numberi)):
3. numberi[i] = numberi[i] * 2

Per concatenare gli elementi puoi usare l’operatore + , mentre per ripetere c’è
l’operatore * , per tagliare invece si usa (: ).

1. >>> a = [1, 2, 3]
2. >>> b = [4, 5, 6]
3. >>> c = a + b
4. >>> print (c) [1, 2, 3, 4, 5, 6]
5. >>> [0] * 4 [0, 0, 0, 0]
6. >>> [1, 2, 3] * 2 [1, 2, 3, 1, 2, 3]
7. >>> t = [ 'a' , 'b' , 'c' , 'd' , 'e' , 'f' ]
8. >>> t[1:3]
9. [ 'b' , 'c' ]
10. >>> t[:4] [ 'a' , 'b' , 'c' , 'd' ]
11. >>> t[3:] [ 'd' , 'e' , 'f' ]

Append() invece, aggiunge un elemento alla fine della lista .

 1. >>> t = [ 'a' , 'b' , 'c' ]
2. >>> t.append( 'd' )
3. >>> print (t)
4. [ 'a' , 'b' , 'c' , 'd' ]

Mentre extend() aggiunge tutti gli elementi di un imput preso in precedenza

alla lista in cui è stato chiamato.

1. >>> t1 = [ 'a' , 'b' , 'c' ]

2. >>> t2 = [ 'd' , 'e' ]
3. >>> t1.extend(t2)
4. >>> print (t1)
5. [ 'a' , 'b' , 'c' , 'd' , 'e' ]

Per ordinare gli elementi in ordine crescente si usa sort().

1. >>> t = [ 'd' , 'c' , 'e' , 'b' , 'a' ]

2. >>> t.sort()
3. >>> print (t)
4. [ 'a' , 'b' , 'c' , 'd' , 'e' ]

Invece, i metodi pop() , del e remove() rimuovono elementi dalle liste . Se

conosci l’elemento che vuoi rimuovere puoi usare pop() , se invece vuoi
rimuovere l’ultimo elemento usa del , se invece conosci il valore e non la
posizione usa remove().

1. >>> t = [ 'a' , 'b' , 'c' ]

2. >>> x = t.pop(1)
3. >>> print (t)
4. [ 'a' , 'c' ]
5. >>> print (x)
6. b
7. >>> t = [ 'a' , 'b' , 'c' ]
8. >>> del t[1]
9. >>> print (t)
10. [ 'a' , 'c' ]
11. >>> t = [ 'a' , 'b' , 'c' ]
12. >>> t.remove( 'b' )
13. >>> print (t)
14. [ 'a' , 'c' ]
15. >>> t = [ 'a' , 'b' , 'c' , 'd' , 'e' , 'f' ]
16. >>> del t[1:5]
17. >>> print (t)
18. [ 'a' , 'f' ]
 CAPITOLO 11
I dizionari di Python

I dizionari somigliano alle liste, ma hanno un carattere più generico.

In più nelle liste le posizioni dell’indice devono essere per forza numeriche,
mentre nei dizionari no.
I dizionari contengono elementi o items formati da una chiave o key e una
valore o value . I dizionari vanno creati con un insieme di coppie <chiave,
valore>, in questo modo la chiave può essere usata per ottenere il suo valore
corrispondente.
I dizionari sono definiti tramite le parentesi graffe, in cui sono contenuti una
serie di elementi separati da virgole.
Ogni elemento è a sua volta formato da una chiave e un valore separati dai
due punti.

1. >>> d = { 'a' : 1, 'b' : 2, 'c' : 3} # nuovo dizionario di 3

elementi
2. >>> d
3. { 'c' : 3, 'a' : 1, 'b' : 2}

Una volta creati i dizionari, è possibile ottenere il valore delle chiavi usando
la sintassi dizionario[chiave], come puoi vedere nell’esempio che segue.

1. >>> d = { 'a' : 1, 'b' : 2, 'c' : 3}

2. >>> d[ 'a' ] # ritorna il valore associato alla chiave 'a'
3. 1
4. >>> d[ 'c' ] # ritorna il valore associato alla chiave 'c
5. 3

Ovviamente, qualora una chiave fosse inesistente Python ci avvertirà tramite

un errore o meglio Keyerror .
Possiamo evitare di incorrere in questo inconveniente utilizzando l’operatore
in oppure not in , per verificare l’esistenza di una chiave nel dizionario.
 1. >>> d = { 'a' : 1, 'b' : 2, 'c' : 3}
2. >>> d[ 'x' ] # se la chiave non esiste restituisce un KeyError

3. Traceback (most recent call last):

4. File "<stdin>" , line 1, in <module>
5. KeyError: 'x'
6. >>> 'x' in d # la chiave 'x' non è presente in d
7. False
8. >>> 'x' not in d # la chiave 'x' non è presente in d
9. True
10. >>> 'b' in d # la chiave 'b' è presente
11. True
12. >>> d[ 'b' ] # il valore associato alla
chiave 'b' è 2
13. 2

In più è possibile aggiungere elementi o modificarli usando la sintassi

dizionario[chiave] = valore , oppure cancellarli con del dizionario[chiave] :

1. >>> d = { 'a' : 1, 'b' : 2, 'c' : 3}

2. >>> d[ 'a' ] = 10 # modifica il valore associato a una chiave
esistente
3. >>> d
4. { 'c' : 3, 'a' : 10, 'b' : 2}
5. >>> d[ 'x' ] = 123 # crea un nuovo elemento, con chiave 'x' e
valore 123
6. >>> d
7. { 'x' : 123, 'c' : 3, 'a' : 10, 'b' : 2}
8. >>> del d[ 'x' ] # rimuove l'elemento (chiave e valore) con
chiave 'x'
9. >>> d
10. { 'c' : 3, 'a' : 10, 'b' : 2}

Di seguito trovi una tabella riassuntiva dei più comuni metodi utilizzabili per
i dizionari di Python, e degli esempi con esercizi.
 Metodo Descrizione
Restituisce gli elementi di d
d.items() come un insieme di tuple
d.keys() Restituisce le chiavi di d
d.values() Restituisce i valori di d
Restituisce il valore
corrispondente a chiave se
presente, altrimenti il valore di
d.get(chiave, default (None se non
default) specificato)
Rimuove e restituisce il valore
corrispondente a chiave se
presente, altrimenti il valore di
d.pop(chiave, default (dà KeyError se non
default) specificato)
Rimuove e restituisce un
d.popitem() elemento arbitrario da d
Aggiunge gli elementi del
d.update(d2) dizionario d2 a quelli di d
d.copy() Crea e restituisce una copia di d
d.clear() Rimuove tutti gli elementi di d

1. >>> d = { 'a' : 1, 'b' : 2, 'c' : 3} # nuovo dict di 3 elementi

2. >>> len(d) # verifica che siano 3
3. 3
4. >>> d.items() # restituisce gli elementi
5. dict_items([( 'c' , 3), ( 'a' , 1), ( 'b' , 2)])
6. >>> d.keys() # restituisce le chiavi
7. dict_keys([ 'c' , 'a' , 'b' ])
8. >>> d.values() # restituisce i valori
9. dict_values([3, 1, 2])
10. >>> d.get( 'c' , 0) # restituisce il valore
corrispondente a 'c'
11. 3
12. >>> d.get( 'x' , 0) # restituisce il default 0
perché 'x' non è presente
13. 0
14. >>> d # il dizionario contiene ancora tutti
gli elementi
15. { 'c' : 3, 'a' : 1, 'b' : 2}
16. >>> d.pop( 'a' , 0) # restituisce e rimuove
il valore corrispondente ad 'a'
17. 1
18. >>> d.pop( 'x' , 0) # restituisce il default 0
perché 'x' non è presente
19. 0
20. >>> d # l'elemento con chiave 'a' è stato
rimosso
21. { 'c' : 3, 'b' : 2}
22. >>> d.pop( 'x' ) # senza default e con
chiave inesistente dà errore
23. Traceback (most recent call last):
24. File "<stdin>" , line 1, in <module>
25. KeyError: 'x'
26. >>> d.popitem() # restituisce e rimuove un
elemento arbitrario
27. ( 'c' , 3)
28. >>> d # l'elemento con chiave 'c' è stato
rimosso
29. { 'b' : 2}
30. >>> d.update({ 'a' : 1, 'c' : 3}) # aggiunge
di nuovo gli elementi 'a' e 'c'
31. >>> d
32. { 'c' : 3, 'a' : 1, 'b' : 2}
33. >>> d.clear() # rimuove tutti gli elementi

34. >>> d # lasciando un dizionario vuoto

35. {}
 CAPITOLO 12
La gestione dei file con Python

Programmando con Python, spesso è necessario interagire con il file system ,

quindi bisogna imparare a gestire i file. Per svolgere questa operazione
Python ci mette a disposizione una funzione specifica: open().
La funzione open() è pensata per accettare numerosi argomenti, tuttavia i più
importanti sono il nome del file e il modo con cui vogliamo aprire il file.
Il nome del file è necessariamente una stringa che in pratica rappresenta il
percorso per raggiungere il file tramite la sua posizione nel file system . Il
modo per indicare questo percorso è duplice, infatti, possiamo indicare la
directory (ad esempio 'file.txt', 'subdir/file.txt', '../file.txt', ecc. ) oppure
possiamo indicare un percorso assoluto (ad esempio '/home/ezio/file.txt' ).
Mentre, per ciò che concerne il modo , solitamente il valore di default è ‘r’ .
Tuttavia con questo valore Python aprirà il file solo in modalità lettura.
Qualora volessimo accedere al file per effettuare delle modifiche, dobbiamo
indicare un modo differente che si identifica con il valore ‘w’ . Questa
opzione restituisce due risultati differenti. Se il file non è stato
precedentemente creato, Python ci permette di crearlo ex novo. Nel caso in
cui il file esistesse, allora questo comando eliminerebbe il file e ci
permetterebbe di crearne uno nuovo.

1. >>> open( 'test.txt' ) # il file non esiste, quindi Python dà

errore (FileNotFoundError)
2. Traceback (most recent call last):
3. File "<stdin>" , line 1, in <module>
4. FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'

5. >>>
6. >>> open( 'test.txt' , 'w' ) # aprendolo in scrittura, il file viene
creato
7. <_io.TextIOWrapper name= 'test.txt' mode= 'w' encoding=
'UTF-8' >
8. >>>
 9. >>> open( 'test.txt' , 'r' ) # ora che è stato creato, possiamo
anche aprirlo in lettura
10. <_io.TextIOWrapper name= 'test.txt' mode=
'r' encoding= 'UTF-8' >
11. >>>
12. >>> open( 'test.txt' ) # se omettiamo il
modo, il file viene aperto in lettura ('r')
13. <_io.TextIOWrapper name= 'test.txt' mode=
'r' encoding= 'UTF-8' >

Ma se la nostra intenzione è quella di aggiungere del contenuto al file senza

eliminarlo? Python ha una soluzione anche per questo, la stringa ‘a’ .
Nella tabella che segue riassumiamo le varie possibilità di scrittura,
eliminazione e modifica dei file testuali, con alcune varianti utili.

Modalità Descrizione
Apre un file di testo in lettura. Modo
'r' di apertura di default dei file.
Apre un file di testo in scrittura. Se il
file non esiste lo crea, altrimenti
'w' cancella il contenuto del file.
Apre un file di testo in append . Il
contenuto viene scritto alla fine del
file, senza modificare il contenuto
'a' esistente.
Apre un file di testo in creazione
esclusiva. Se il file non esiste,
restituisce un errore, altrimenti apre
in scrittura cancellando il contenuto
'x' del file.
Apre un file di testo in modifica.
Permette di leggere e scrivere
'r+' contemporaneamente.
 Apre un file di testo in modifica.
Permette di leggere e scrivere
contemporaneamente. Cancella il
'w+' contenuto del file.

Adesso andiamo ad analizzare la gestione dei file oggetto o file object.

Ecco una scheda riassuntiva dei diversi attributi e metodi dei file object.

1. >>> f = open( 'test.txt' , 'w' ) # apriamo il file test.txt in

scrittura
2. >>> f # open() ci restituisce un file object
3. <_io.TextIOWrapper name= 'test.txt' mode= 'w' encoding=
'UTF-8' >
4. >>> dir(f) # possiamo usare dir() per vedere l'elenco di
attributi e metodi
5. [..., '_CHUNK_SIZE' , '_checkClosed' , '_checkReadable' ,
'_checkSeekable' , '_checkWritable' ,
6. '_finalizing' , 'buffer' , 'close' , 'closed' , 'detach' , 'encoding' ,
'errors' , 'fileno' , 'flush' ,
7. 'isatty' , 'line_buffering' , 'mode' , 'name' , 'newlines' , 'read' ,
'readable' , 'readline' ,
8. 'readlines' , 'seek' , 'seekable' , 'tell' , 'truncate' , 'writable' , 'write'
, 'writelines' ]
9. >>> f.name # l'attributo .name corrisponde al nome del file

10. 'test.txt'
11. >>> f.mode # l'attributo .mode
corrisponde al modo di apertura
12. 'w'
13. >>> f.closed # l'attributo .closed è True se
il file è stato chiuso, altrimenti False
14. False
15. >>> f.read # read è un metodo che,
quando chiamato, legge e ritorna il contenuto
16. <built- in method read of
_io.TextIOWrapper object at 0xb67cb734>
 17. >>> f.write # write è un metodo che,
quando chiamato, ci consente di scrivere nel file
18. <built- in method write of
_io.TextIOWrapper object at 0xb67cb734>
19. >>> f.close # close è un metodo che,
quando chiamato, chiude il file,
20. <built- in method close of
_io.TextIOWrapper object at 0xb67cb734>

Questo è un esempio pratico che potrai usare anche come esercizio.

1. >>> f = open( 'test.txt' , 'w' ) # apriamo il file in scrittura

2. >>> f.write( 'prima riga del file\n' ) # scriviamo una riga nel
file
3. 20
4. >>> f.write( 'seconda riga del file\n' ) # scriviamo un'altra
riga nel file
5. 22
6. >>> f.close() # chiudiamo il file
7. >>>
8. >>> f = open( 'test.txt' ) # riapriamo il file in lettura
9. >>> content = f.read() # leggiamo tutto il contenuto del file

10. >>> print (content)

11. prima riga del file
12. seconda riga del file
13. >>> f.close() # chiudiamo il file

Nell’esempio riportato vediamo il metodo file.read() che ci permette di

leggere un file. Il metodo file.write() che ci permette di scrivere in un file. E il
metodo file.colose() che chiude il file e che non va dimenticato in nessun
caso.
Nell’esempio che segue, invece, andiamo a vedere il metodo file.readlines() e
il metodo file.writelines() che permettono di leggere e scrivere una serie di
righe in un file. Mentre file.readline() permette di leggere una singola riga.

1. >>> # definiamo una lista di righe

2. >>> lines = [
3. ... 'prima riga del file\n' ,
4. ... 'seconda riga del file\n' ,
5. ... 'terza riga del file\n' ,
6. ... ]
7. >>> f = open( 'test.txt' , 'w' ) # apriamo il file in scrittura
8. >>> f.writelines(lines) # usiamo il metodo writelines per
scrivere le righe nel file
9. >>> f.close() # chiudiamo il file
10. >>>
11. >>> f = open( 'test.txt' ) # riapriamo il file
in lettura
12. >>> f.readlines() # usiamo il metodo
readlines per ottenere una lista di righe del file
13. [ 'prima riga del file\n' , 'seconda riga del
file\n' , 'terza riga del file\n' ]
14. >>> f.close() # chiudiamo il file
15. >>>
16. >>> f = open( 'test.txt' ) # riapriamo il file
in lettura
17. >>> f.readline() # usiamo il metodo
readline per ottenere una singola riga del file
18. 'prima riga del file\n'
19. >>> f.readline() # usiamo il metodo
readline per ottenere una singola riga del file
20. 'seconda riga del file\n'
21. >>> f.readline() # usiamo il metodo
readline per ottenere una singola riga del file
22. 'terza riga del file\n'
23. >>> f.readline() # quando abbiamo letto
tutto, il metodo restituisce una stringa vuota
24. ''
25. >>> f.close() # chiudiamo il file
26. >>>
27. >>> # È possibile utilizzare un for per
iterare sulle righe di un file:
28. >>> f = open( 'test.txt' ) # riapriamo il file
 in lettura
29. >>> for line in f: # iteriamo sulle righe del
file
30. ... line
31. ...
32. 'prima riga del file\n'
33. 'seconda riga del file\n'
34. 'terza riga del file\n'
35. >>> f.close() # chiudiamo il file

Ci sono anche dei metodi alternativi come file.tell() e file.seek() che

verificano e memorizzano la posizione di un file.object .

1. >>> # definiamo una lista di righe

2. >>> lines = [
3. ... 'prima riga del file\n' ,
4. ... 'seconda riga del file\n' ,
5. ... 'terza riga del file\n' ,
6. ... ]
7. >>> f = open( 'test.txt' , 'w' ) # apriamo il file in scrittura
8. >>> f.writelines(lines) # usiamo il metodo writelines per
scrivere le righe nel file
9. >>> f.seek(0, 0) # eseguiamo un seek per spostarci all'inizio
del file (il secondo 0 indica l'inizio)
10. 0
11. >>> f.write( 'PRIMA' ) # scriviamo
'PRIMA' all'inizio del file sovrascrivendo 'prima'
12. 5
13. >>> f.seek(0, 2) # eseguiamo un seek per
spostarci alla fine del file (il 2 indica la fine)
14. 62
15. >>> f.write( 'quarta riga del file\n' ) #
aggiungiamo una riga alla fine
16. 21
17. >>> f.close() # chiudiamo il file
18. >>>
19. >>> f = open( 'test.txt' ) # riapriamo il file
 in lettura
20. >>> f.readline() # usiamo il metodo
readline per ottenere una singola riga del file
21. 'PRIMA riga del file\n'
22. >>> f.readline() # usiamo il metodo
readline per ottenere un'altra riga del file
23. 'seconda riga del file\n'
24. >>> f.tell() # vediamo che la posizione nel
file è avanzata
25. 42
26. >>> f.read() # usiamo il metodo read per
leggere il resto del contenuto del file
27. 'terza riga del file\nquarta riga del file\n'
28. >>> f.tell() # vediamo che la posizione nel
file è avanzata ulteriormente
29. 83
30. >>> f.read() # quando abbiamo letto tutto,
il metodo restituisce una stringa vuota
31. ''
32. >>> f.seek(0) # eseguiamo un seek per
spostarci all'inizio del file
33. 0
34. >>> f.tell() # vediamo che la posizione è
ritornata a 0
35. 0
36. >>> f.readlines() # rileggiamo l'intero
contenuto del file come lista di stringhe
37. [ 'PRIMA riga del file\n' , 'seconda riga del
file\n' , 'terza riga del file\n' , 'quarta riga del file\n' ]
38. >>> f.close() # chiudiamo il file

Ricapitoliamo in una tabella i vari metodi per i file oggetto .

metodo Descrizione
Legge e restituisce
l’intero contenuto del
file come una singola
file.read() stringa.
Legge e restituisce n
file.read(n) caratteri (o byte).
Legge e restituisce una
file.readline() riga del file.
Legge e restuisce
l’intero contenuto del
file come lista di righe
file.readlines() (stringhe).
Scrive nel file la
stringa s e ritorna il
numero di caratteri (o
file.write(s) byte) scritti.
Scrive nel file la lista in
file.writelines(lines) righe lines .
Restituisce la posizione
corrente memorizzata
file.tell() dal file object.
Modifica la posizione
corrente memorizzata
file.seek(offset, pos) dal file object.
file.close() Chiude il file.

Come abbiamo visto in precedenza, è sempre importante ricordarsi di

chiudere i file con il metodo file.close(). Tuttavia questa operazione non è
infallibile, in quanto la dimenticanza è sempre dietro l’angolo. Per cui quando
si lavora con i file è possibile o meglio è consigliabile utilizzare un costrutto
che risolve in modo automatizzato questo problema. Con il costrutto with ,
usato con dei context manager puoi ovviare a questo problema. Vediamo un
esempio.
1. >>> f = open( 'test.txt' , 'w' ) # creiamo il file object
2. >>> with f: # usiamo il file object come context manager nel
with
3. ... f.write( 'contenuto del file' ) # scriviamo il file
4. ... f.closed # verifichiamo che il file è ancora aperto
5. ...
6. 18
7. False
8. >>> f.closed # verifichiamo che dopo il with il file è chiuso

9. True
 CAPITOLO 13
L’indentazione

A questo punto sei già in grado di creare programmi basilari su Python e hai
gli strumenti per approfondire questo linguaggio. C’è un aspetto di cui
dobbiamo parlare ancora: l’indentazione .
Altri linguaggi di programmazione chiudono i blocchi di codice con parenti
graffe o parole specifiche. Python invece, usa l’indentazione che come vedrai
è anche utile per leggere in modo più veloce il codice. Questo però non è un
aspetto secondario, infatti, un’indentazione sbagliata può comportare
problemi, quindi va sempre fatta molta attenzione a questo elemento del
codice.
Vediamo un semplice esempio di indentazione :

1. print ( "eseguito sempre all'inizio" )

2. if condizione:
3. print ( 'eseguito solo se la condizione è vera' )
4. print ( 'eseguito solo se la condizione è vera' )
5. print ( 'eseguito solo se la condizione è vera' )
6. print ( 'eseguito sempre alla fine' )

Come puoi facilmente notare il primo e l’ultimo print hanno la stessa

posizione dell’ if , mentre gli altri print centrali sono spostati sulla destra.
Questo significa che se la condizione dell’ if è vera i tre print vengono
eseguiti, viceversa questi non verranno eseguiti. Con un’indentazione
differente, quindi errata, tutto questo non avverrebbe. Per questo
l’indentazione non è da considerarsi come un semplice stile per leggere il
codice in modo più veloce, ma è significativa per il corretto funzionamento
dei programmi.
Proprio considerata l’importanza dell’indentazione, gli sviluppatori di Python
hanno rilasciato delle precise linee guida per effettuarla nel modo corretto, tra
cui le più importanti sono:

usare sempre 4 spazi per livello di indentazione;

evitare l’uso dei caratteri di tabulazione;
non mischiare mai l’uso di tabulazioni e spazi.
 CAPITOLO 14
IDLE, un’interfaccia visuale per Python

Fino ad ora abbiamo utilizzato Python dalle linee di comando. Ma c’è un

modo più semplice per aprire e lavorare i file Python, grazie a un’interfaccia
apposita chiama IDLE che è l’acronimo di (Integrated Development and
Learning Environment ).
IDLE offre un’interfaccia visuale molto intuitiva e può essere eseguita su
Windows, ma anche su Linux e Mac OS. Da Windows l’opzione più facile
per accedere a IDLE è tramite il menu Start , seguendo questo percorso: Start
-> Tutti i Programmi -> Python 3.X.
Una volta aperto IDLE apparirà il prompt comandi di Python con gli ormai
famosi simboli: >>> . Fino a qui nulla di nuovo, quello che invece cambierà
è il menu posto sulla parte superiore della finestra che è simile a quello di
molte altre interfacce visuali.
Il tutto è più tosto intuitivo, per aprire un file esistente, per esempio,
clicchiamo sulla voce del menu “File”, e successivamente su “new file”.
Mentre per aprire un file esistente, andiamo sempre sulla voce “File”, ma
optiamo per “New Window”. Per eseguire lo script andremo invece sulla
voce “Run”, poi su RunModule.
IDLE permette anche una vasta personalizzazione. Infatti, andando sulla voce
“Options” del menu e successivamente su “Configure IDLE”, accederemo a
una schermata in cui è possibile personalizzare diversi aspetti dell’ambiente
visuale, come la dimensione del font, la larghezza dell’indentazione, i colori
delle parole chiave e una serie di altri elementi.
 CAPITOLO 15
Directory, moduli e package

Anche Python, esattamente come avviene per altri linguaggi di

programmazione, riconosce delle directory che sono file e sotto-cartelle. La
gestione delle directory è consentita da un modulo apposito denominato os .
Per poter operare con le directory e gestirle è importante prima di tutto
individuare quella in cui stiamo operando, a questo scopo viene in nostro
aiuto il metodo getcwd().

1. # Individuazione della directory corrente con getcwd()

2. >>> import os
3. >>> os.getcwd()
4. 'C:\\Python'

Oppure, in alternativa, il metodo getcwdb() che restituisce la directory

corrente sotto forma di oggetto di byte .

1. # Individuazione della directory corrente con getcwdb()

2. >>> import os
3. >>> os.getcwdb()
4. b 'C:\\Python' n'

Entrambi i metodi però, restituiscono dei backslash addizionali, di cui magari

non abbiamo bisogno, per cui possiamo utilizzare il metodo print() per
eliminarli.

1. # Individuazione della directory corrente con getcwd()

2. # ed eliminazione dei backslash addizionali
3. >>> import os
4. >>> print (os.getcwd())
5. C:\Python

Per modificare una directory e tornare nella directory corrente si usa il

metodo chdir() come puoi vedere nell’esempio che segue, utile anche come
esercizio:
 1. # Modifica della directory corrente e ritorno alla directory
precedente
2. >>> import os
3. >>> os.chdir( 'C:\\' )
4. >>> print (os.getcwd())
5. C:\
6. >>> os.chdir( 'C:\\Python' )
7. >>> print (os.getcwd())
8. C:\Python

Per visualizzare il contenuto di una directory , bisogna usare il metodo

listdir() che stampa a video gli elementi presenti in una determinata directory
.

1. # Visualizzare il contenuto della directory corrente

2. >>> import os
3. >>> print (os.getcwd())
4. C:\Python
5. >>> os.listdir()
6. [ 'app.py' , 'ciao.py' , 'DLLs' , 'Doc' , 'include' , 'Lib' , 'libs' ,
7. 'LICENSE.txt' , 'NEWS.txt' , 'nuovo_file.txt' ,
8. 'PrimoProgrammaPython.py' , 'Progetti' , 'prova.txt' ,
'python.exe' ,
9. 'pythonw.exe' , 'README.txt' , 'Scripts' , 'tcl' , 'Test' , 'test.py' ,

10. 'text.txt' , 'Tools' , 'x.py' , '__pycache__' ]

Qualora invece vogliamo stampare a video il contenuto di una cartella

specifica, il metodo è il seguente:

1. # Visualizzare il contenuto di una directory specifica

2. >>> import os
3. >>> os.listdir( 'C:\\Python\\Tools' )
4. [ 'i18n' , 'pynche' , 'Scripts' ]

Per ovvie ragioni, durante la fase di scrittura di un programma può essere

utile dover creare o rinominare una directory , per questo scopo possiamo
usare il metodo mkdir() .
 1. # Creazione di una directory all'interno di una directory
specifica
2. >>> import os
3. >>> os.mkdir( 'C:\\Python\\Progetti\\new_dir' )
4. >>> os.listdir( 'C:\\Python\\Progetti' )
5. [ 'Guide' , 'new_dir' , 'prima_app.py' , '__init__.py' ,
'__pycache__' ]

Per rinominarla invece dobbiamo usare il metodo rename () .

1. # Rinominare una directory

2. >>> import os
3. >>> os.rename( 'C:\\Python\\Progetti\\new_dir' ,
'C:\\Python\\Progetti\\new_dir_1' )
4. >>> os.listdir( 'C:\\Python\\Progetti' )
5. [ 'Guide' , 'new_dir_1' , 'prima_app.py' , '__init__.py' ,
'__pycache__' ]

L’eliminazione invece avviene o mediante il metodo rmdir() che elimina

directory vuote:

1. # Eliminare una directory vuota

2. >>> import os
3. >>> os.rmdir( 'C:\\Python\\Progetti\\new_dir_1' )
4. >>> os.listdir( 'C:\\Python\\Progetti' )
5. [ 'Guide' , 'prima_app.py' , '__init__.py' , '__pycache__' ]

Oppure il metodo rmtree() che fa riferimento al modulo shutil() ed elimina

una directory con tutto il suo contenuto:

1. # Eliminare un directory popolata

2. >>> import shutil
3. >>> shutil.rmtree( 'C:\\Python\\Progetti' )

I moduli in Python sono file che contengono codice. Il modulo è identificato

con l’estensione “.py ”. Il loro scopo è appunto quello di contenere istruzioni
e definizioni da poter riutilizzare all’occorrenza, ma servono anche alla
gestione di codici particolarmente estesi.
Come detto, i moduli contengono i codici di Python, quindi è possibile
incorporare in essi tutte le regole che abbiamo visto in questa guida. La
creazione di un modulo è piuttosto semplice, procediamo con un esempio.

1. # Definire il codice di un modulo

2. def mul(x, y):
3. """Semplice applicazione che moltiplica
4. 2 valori e restituisce il risultato"""
5. prodotto = x * y
6. return prodotto

A questo punto non ci resta che salvare questo file con estensione “.py ”, ad
esempio: moltiplicatore.py e il gioco è fatto. Abbiamo creato un modulo
Python da importare e utilizzare tutte le volte che vogliamo.
Adesso vediamo come importare un modulo Python in modo da poter
richiamare lo stesso quando ci serve. Per fare ciò bisogna usare il comando
import , come vedi nell’esempio che segue:

1. # Importazione di un modulo
2. >>> import moltiplicatore

A questo punto è d’obbligo richiamare anche la funzione presente nel modulo

che in questo caso è soltanto mul() , quindi procediamo nel modo che segue:

1. # Importazione di un modulo e chiamata alla funzione

2. >>> import moltiplicatore
3. >>> moltiplicatore.mul(6,5)
4. 30

Come detto in precedenza, un modulo può contenere diverse funzioni e in

alcuni casi non ci interessa importarle tutte, quindi andiamo a richiamare solo
quella di cui abbiamo bisogno con la parola from , in questo modo:

1. # Importare una sola funzione di un modulo

2. >>> from moltiplicatore import mul
3. >>> mul(3,5)
4. 15
Se volessimo importare più istruzioni, tralasciandone alcune si può utilizzare
lo stesso codice, chiamando più istruzioni, utilizzando la virgola come
separatore:

1. # Importartazione multipla di istruzioni da un modulo

2. >>> from moltiplicatore import mul, seconda_istruzione,
terza_istruzione

Python dispone di numerosi moduli pre-impostati che svolgono diverse

funzioni, uno dei più famosi e utilizzati è calendar , che come suggerisce il
nome permette di gestire dei calendari. Vediamo qualche esempio utile che
potrai usare anche come esercizio, modificando i valori. Per fare ciò devi
tenere presente che questo modulo prevede che il primo giorno della
settimana sia il lunedì, identificato con il numero 0, mentre la domenica che è
l’ultimo giorno è identificata con il numero 6. Per richiamare il modulo
dovremo utilizzare la funzione firstweekday().

1. # Importazione del modulo calendar e visualizzazione

dell'indice
2. # del primo giorno della settimana
3. >>> import calendar
4. >>> calendar.firstweekday()
5. 0

A questo punto però, è utile sapere come gestire i moduli che spesso sono
tanti, per cui nasce la necessità di organizzarli a loro volta in contenitori più
grandi. A questo scopo Python mette a disposizione dei programmatori i
package .
Tramite i package è possibile organizzare e catalogare i moduli in modo
funzionale. Immaginando di dover organizzare una cartella di progetti da
realizzare, facciamo un esempio pratico che ti farà comprendere meglio la
natura dei package e ti sarà utile come esercizio.
Prima di tutto dobbiamo andare a creare una directory chiamata “Progetti” ,
sullo stesso percorso di un modulo chiamato “xmail ”. È utile utilizzare la
lettera maiuscola iniziale per denominare i package così da distinguerli in
modo più intuitivo dai moduli .
A questo punto copiamo “xmail” all’interno di Progetti e rinominiamo il
modulo in project_moltiplicatore _xmail.py
Ora dobbiamo importare il modulo nel package , per farlo puoi procedere
come segue:

1. # Importare un modulo da un package

2. >>> import Progetti.project_moltiplicatore_xmail
3. 10
4. 8

Lo stesso discorso avviane con i sub-package che sono effettivamente delle

sub-directory, quindi creando un sub-package “Lezioni”, procederemo in
questo modo:

1. # Importare un modulo da un sub-package

2. >>> import Progetti.Lezioni.project_moltiplicatore_xmail
3. 10
4. 8

A questo punto però è necessario richiamare la funzione del modulo

“moltiplicatore” che ricordiamo essere mul(), quindi procediamo in questo
modo:

1. # Chiamata della funzione di un sub-package

2. >>> import Progetti.Lezioni.project_moltiplicatore_mul
3. >>> Progetti.Lezioni.project_moltiplicatore_mul.mul(7,8)
4. 56
 CAPITOLO 16
Le eccezioni in Python

Nell’ultimo capitolo di questa guida ci occuperemo delle eccezioni . In

Python le eccezioni sono sostanzialmente dei messaggi d’errore che Python ci
invia quando rivela un’anomalia nella programmazione.
Python ha tutta una serie di eccezioni predefinite atte a segnalare anomalie.
L’eccezione più comune e utile è SyntaxError , questa segnala al
programmatore che ci sono stati degli errori di digitazione durante la stesura
del codice.

1. # Notifica di errore sintattico in un costrutto condizionale

2. >>> x = 10
3. >>> if x > 4
4. SyntaxError: invalid syntax

Un genere particolare di eccezione , sono gli errori a runtime che si

presentano durante l’esecuzione, uno dei più frequenti è l’apertura di un file
non disponibile:

1. # Apertura di un file esistente

2. >>> open( 'C:\\Python\\README.txt' ,'rt)
3. <_io.TextIOWrapper name= 'C:\\Python\\README.txt'
mode= 'r' encoding= 'cp1252' >
4. >>> open( 'C:\\Python\\README.txt' , 'rt' )
5. <_io.TextIOWrapper name= 'C:\\Python\\README.txt'
mode= 'rt' encoding= 'cp1252' <
6. Apertura di un file inesistente e output di errore
7. >>> open( 'C:\\Python\\README2.txt' , 'rt' )
8. Traceback (most recent call last):
9. File "<pyshell#33>" , line 1, in <module>
10. open( 'C:\\Python\\README2.txt' , 'rt'
)
11. FileNotFoundError: [Errno 2] No such file
or directory: 'C:\\Python\\README2.txt'
Come possiamo notare, in questo caso non ci sono errori sintattici, ma solo
l’assenza di un file che è stato richiamato nel costrutto. Questo errore si
genera in tutti i casi in cui la sintassi è corretta, ma viene a mancare un
elemento richiamato nel codice che può essere una directory (come nel primo
esempio che segue):

1. # Tentativo di accesso ad una directory inesistente

2. >>> import os
3. >>> os.listdir( 'C:\\Python\\Lib\\directory_inesistente' )
4. Traceback (most recent call last):
5. File "<pyshell#35>" , line 1, in <module>
6. os.listdir( 'C:\\Python\\Lib\\directory_inesistente' )
7. FileNotFoundError: [WinError 3] Impossibile trovare il
percorso specificato:
8. 'C:\\Python\\Lib\\directory_inesistente'

Oppure un modulo (come nell’esempio che segue):

1. # Richiamare un modulo inesistente

2. >>> import nomodule
3. Traceback (most recent call last):
4. File "<pyshell#36>" , line 1, in <module>
5. import nomodule
6. ImportError: No module named 'nomodule'

L'Exception Handling invece, ci consente di gestire specifiche eccezioni

basandoci sulla delimitazione di blocchi di codice, in cui andiamo a scrivere
specifiche istruzioni come quella di associare un valore a una variabile “x”,
come nell’esempio che segue, in cui è digitato un valore superiore a quello
dichiarato nelle istruzioni (prova questo esercizio):

1. # Exception Handling in Python

2. >>> try :
3. x = int(input( "Digita un intero uguale o inferiore a 7: " ))
4. if x > 7:
5. raise ValueError( "Numero superiore a 7" )
6. except ValueError as y:
7. print (y)
In questo caso tramite la parola raise abbiamo definito la modalità di gestione
dell’eccezione, mentre con except definiamo l’eccezione.
Se invece il nostro scopo fosse quello di dare comunque un’istruzione,
indipendentemente dal verificarsi di un errore, possiamo inserire la clausola
finally in un blocco try , così come si vede nell’esempio che segue, in cui
andiamo a chiedere l’apertura di un file.

1. # Utilizzo della clausola finally

2. >>> try :
3. f = open( "nome_file.txt" ,encoding = 'utf-8' )
4. # eventuali operazioni sul file
5. #...
6. finally :
7. f.close()
 Conclusioni

Python è un linguaggio di programmazione di alto livello ed estremamente

complesso e versatile. Ha dalla sua però il pregio di essere lineare e
relativamente facile da imparare.
Con le spiegazioni e gli esercizi/esempi riportati in questa guida, hai gli
strumenti per iniziare a programmare con Python. Ora tocca a te approfondire
e avanzare nello studio e nella pratica.
Python è un linguaggio in evoluzione e come tale è soggetto a numerosi
aggiornamenti e variazioni, quindi il consiglio è di tenerti sempre aggiornato
e di studiare in modo progressivo tutti i costrutti, i metodi e la sintassi di
questo strumento di programmazione che può veramente esserti utile per
sviluppare ogni tipologia di programma e applicazione.