Python 3

01/02/2014 release #1.00

Premessa del traduttore:

Perch Python secondo me:
Perch racchiude in se il meglio di tutti gli altri linguaggi di programmazione, ponendo cos il
programmatore nello stato di grazia di non dover saltare da un linguaggio ad un' altro per poter sfruttare le
rispettive potenzialit. Questo il vantaggio che ha un nuovo linguaggio che si affaccia nel mondo
dell'informatica, ma che dura poco in quanto verr prima o poi superato a sua volta da altri linguaggi che
implementeranno il meglio di quelli fatti in precedenza.
Anche in questo meccanismo Python ha una marcia in pi. Infatti passato dalla versione 2.x alla 3.x che
pur simili, sono fra loro incompatibili. Questo pu suonare strano mentre tutti si preoccupano di
mantenere rigorosamente la compatibilit! Se Python non avesse spezzato il legame tra la 2 e la 3 per
garantire la compatibilit, avrebbe di fatto legato la il suo destino alla versione 2. Invece la versione 3,
include tante nuove migliorie e correzioni di difetti della 2. Qualcuno potrebbe obiettare che questo
passaggio costa caro! La risposta : meglio un po' di tempo per adeguarsi senza uscire da Python che
imparare un linguaggio nuovo o pseudo tale. E' una scelta che pu far discutere, ma sicuramente la meno
invasiva e dispendiosa in termini di tempo-programmatore, e forse sar cos anche per una ipotetica
versione 4.
Inoltre esso rappresenta una caratteristica speciale. Non gli importa nulla dell'ambiente grafico! O meglio,
lascia agli altri il modo di implementare l'ambiente grafico non ponendo limiti di piattaforma o toolkit
grafico. Infatti sono presenti moltissimi ambienti grafici a cui associare Python, da QTx, GTKx,
TINKER, WxPython, JavaSwing ecc. ecc. Il tutto disponibile su praticamente tutte le piattaforme tenendo
divisa la parte del codice da quella della grafica (pi o meno). Per finire, ultimo ma non ultimo il suo
codice estremamente compatto, che riduce il tempo di scrittura e la gestione degli errori minimizzate da
robuste funzioni precostituite. Se questo non vi sufficiente, allora potete evitare di leggere questa guida e
aspettare che qualcosa vi cada dal cielo.
Sulla traduzione:
Questa traduzione di Python 3.x.x resa libera per tutti gli usi e a tutti purch rispetti la licenza del
documento originale essa tratta dalla pagina http://docs.python.org/3/tutorial/index.html. E' nella forma
in cui , e non pretende di essere perfetta nella consapevolezza che di errori ve ne sono anche se sono
stato piuttosto attento, ma avendo eseguito il tutto da solo senza alcun aiuto esterno, resta la
consapevolezza che non potr mai essere sia pur minimamente perfetta. Inoltre anche nella versione
originale di questa guida, vi sono dei passaggi trattati in modo stringato che inducono ad una traduzione
che pu non esplicare quel concetto nella sua interezza. Inoltre ho eseguito anche la traduzione di quasi
tutti gli esempi (cosa generalmente sconsigliata) per facilitare la comprensione in quanto molte istruzioni
mescolate con il testo con l'inglese possono confondere il lettore. Mentre tradotte in italiano rendono il
codice pi comprensibile anche se esposto maggiormente a potenziali errori. Ci detto, sono sicuro che
sar graziato per tutto quello che non va, ma dentro di me ho sentito il bisogno di fare questo lavoro in
quanto ritengo Python veramente superbo in tutti i suoi aspetti con una documentazione si completa in
inglese, ma carente in italiano specialmente per la versione 3.x. La dove qualcuno noti degli errori delle
incongruenze o altro che possa essere migliorato pu liberamente modificare questa guida oppure
contattarmi e informarmi sul quanto a questo indirizzo di posta elettronica: [email protected] . Sar
comunque mio compito aggiornarla al meglio. Declino ogni responsabilit su eventuali malfunzionamenti
di programmi tratti da questa guida e/o da cattiva traduzione. Chi vuole copiare diffondere questa guida
libero di farlo, sarebbe comunque gradita una citazione in tal caso. Spero che vi divertiate come mi sto
divertendo io! Python veramente grande! Buona lettura.
Il traduttore
Maurizio Da Lio

La Traduzione:

Guida introduttiva a Python 3

Python un potente linguaggio di programmazione facile e divertente da imparare. Possiede strutture di
dati di alto livello molto potenti e semplici da maneggiare utilizzando un' approccio object-oriented cio
orientato agli oggetti. Inoltre la sua sintassi elegante ed ha la gestione dei tipi dinamica unitamente alla
sua natura di tipo interprete, tutto questo rende Python un linguaggio ideale per lo scripting e lo sviluppo
rapido di applicazioni in molte aree sulla maggior parte delle piattaforme.
L'interprete Python possiede un'ampia libreria standard liberamente disponibile in formato sorgente o in
forma binaria per tutte le principali piattaforme disponibili sul sito Web di Python,
http://www.python.org/, che possono essere utilizzate e distribuite liberamente. Lo stesso sito contiene
anche collegamenti a molti moduli liberi prodotti da terzi per Python, programmi strumenti e
documentazione aggiuntiva.
L'interprete di Python facilmente estendibile permette di aggiungere nuove funzioni e tipi di dati
implementati in C o C + + (o altri linguaggi richiamabili da C). Esso adatto anche come linguaggio di
estensione per applicazioni personalizzabili.
Questa guida, introduce informalmente il lettore ai concetti base e alle caratteristiche del linguaggio e di
sistema. Aiuta ad utilizzare l'interprete in modo pratico per esperienza alla mano con tutti gli esempi
pratici descritti in modo da poterla utilizzare anche senza l'utilizzo di una connessione.
Per una descrizione degli oggetti standard e dei suoi moduli, consultare la libreria standard di Python. The
Python Standard Library fornisce una definizione pi formale e dettagliata del linguaggio. Per scrivere
estensioni in C o C + +, fare riferimento a The Python Language Reference. Inoltre ci sono moltissimi
libri in lingua inglese ed alcuni in lingua italiana di ottimo livello per poter approfondire la sua
conoscenza con tecniche altamente professionali. Altri importanti riferimenti si trovano a questi link:
Extending and Embedding the Python Interpreter e Python/C API Reference Manual.
Questa guida, non intende essere esaustiva e coprire ogni singola caratteristica, o anche tutte le
funzionalit di uso comune. Tende invece a introdurre molte fra le caratteristiche pi notevoli di Python e
vi dar una buona idea sul gusto e stile del linguaggio. Dopo averla letta, sarete in grado di leggere e
scrivere moduli e programmi e sarete pronti ad imparare di pi sui vari moduli della libreria Python
descritta in in The Python Standard Library . Vale inoltre la pena dare un'occhiata al Glossary.

INDICE

1. Tanto per stimolarci un po

2. Usare l'interprete di Python
2.1. Invocare l'interprete
2.1.1. Passaggio di argomenti
2.1.2. Modo Interattivo
2.2. L'Interprete e il suo ambiente
2.2.1. Trattamente degli errori
2.2.2. Scripts Python Eseguibili
2.2.3. Codifica Del Codice Sorgente
2.2.4. Il File Di Avvio In Modalit Interattiva
2.2.5. La Personalizzazione Dei Moduli
3. Un' Informale Introduzione A Python
3.1. Usare Python Come Un Calcolatore
3.1.1. Numeri
3.1.2. Le Stringhe
3.1.3. Le Liste
3.2. Primi Passi Di Programmazione
4. Strumenti Per Controllare il Flusso
4.1. L'Istruzione if
4.2. L'Istruzione for
4.3. La Funzione range()
4.4. L'Istruzione break e continue e La Clausola else Sui Cicli
4.5. L'Istruzione pass
4.6. Definizioni Di Funzioni
4.7. Ancora Sulla Definizione Di Funzioni
4.7.1. Valori Argomenti Predefiniti
4.7.2. Argomenti Chiave
4.7.3. Liste di argomenti arbitrari
4.7.4. Scompattamento degli elenchi di argomenti
4.7.5. Espressioni Lambda
4.7.6. Stringhe di documentazione
4.7.7. Annotazioni di Funzioni
4.8. Intermezzo: Stile di Codifica
5. Strutture di Dati
5.1. Approfondimento Sulle Liste
5.1.1. Utilizzo Delle Liste Come Pile
5.1.2. Uso Delle Liste e Delle Code
5.1.3. Comprensioni Di Lista
5.1.4. Comprensioni Di Lista Nidificate
5.2. L'Istruzione del

5.3. Tuple e Sequenze

5.4. Insiemi o Sets
5.5. Dizionari
5.6. Tecniche di Ciclo
5.7. Approfondimento sulle condizioni
5.8. Confronto Di Sequenze e Altri Tipi
6. Moduli
6.1. Ancora Sui Moduli
6.1.1. Eseguire Moduli Come Script
6.1.2. Il Modulo Ricerca Path
6.1.3. Files Python Compilati
6.2. Moduli Standard
6.3. La Funzione dir()
6.4. I Packages o pacchetti
6.4.1. Importazione * From Da Un Package
6.4.2. Referenze Intra-package
6.4.3. Packages in Directory Multiple
7. Input e Output
7.1. Formattazione Avanzata dell'Output
7.1.1. Formattazione Stringhe Classica
7.2. Lettura e Scrittura File
7.2.1. Metodi dell' Oggetto File
7.2.2. Salvare strutture di dati con json
8. 8. Errori ed Eccezioni
8.1. Errori di sintassi
8.2. Eccezioni
8.3. Trattamento delle Eccezioni
8.4. Lancio delle Eccezioni
8.5. Eccezioni Definite Dall'Utente
8.6. Definizione dell'Azione di Pulizia (Clean-up)
8.7. Azioni Predefinite di Pulizia (Clean-up)
9. Classi
9.1. Considerazioni Circa i Nomi e Gli Oggetti
9.2. Spazio dei Nomi e Visibilit in Python
9.2.1. Esempi di Ambiti e Spazio Dei Nomi
9.3. Un Primo Sguardo alle Classi
9.3.1. Sintassi nella Definizione di Classe
9.3.2. Oggetti Classe
9.3.3. Instanze di Oggetti
9.3.4. Metodi degli Oggetti
9.4. Note Casuali
9.5. L'Ereditariet
9.5.1. Ereditariet Multipla
9.6. Variabili Private
9.7. Varie
9.8. Le Eccezioni Possono Essere Anche Classi

9.9. Iteratori
9.10. Generatori
9.11. Generatore di Espressioni
10. Panoramica Sulle Librerie Standard
10.1. Interfaccia al Sistema Operativo
10.2. File Jolly
10.3. Argomenti della Linea di Comando
10.4. Reidirizzamento Output degli Errori e Terminazione Programma
10.5. Corrispondenza di Stringhe
10.6. Matematica
10.7. Accesso a Internet
10.8. Date e Tempo
10.9. Compressione Dati
10.10. Misurazione delle Prestazioni
10.11. Controllo Qualit
10.12. Tutto compreso
11. Panoramica Sulle Librerie Standard Parte II
11.1. Output Formatting
11.2. Modellazione
11.3. Lavorare con i Data Record Layouts Binari
11.4. Multi-threading
11.5. Logging
11.6. Referimenti deboli
11.7. Strumenti per Lavorare con le Liste
11.8. Decimal Floating Point Arithmetic
12. E Adesso?
13. Input ed Editing Interattivo Sostituzioni e Cronologia
13.1. Editare le Linee
13.2. Sostituzione cronologica
13.3. Tasti Collegati
13.4. Alternative all'Interprete Interattivo Predefinito
14. Aritmetica in Virgola Mobile: Problemi e Limiti
14.1. Errori di Rappresentazione

1. Tanto per stimolarci un po.

Se lavorate molto al computer, vi sarete resi conto che molte delle operazioni che facciamo, potrebbero
essere automatizzate alla fine di risparmiare tempo ed evitare errori, rendendo inoltre il lavoro pi
piacevole. Ad esempio, si potrebbe desiderare di eseguire una ricerca e sostituzione su un gran numero di
file di testo, o rinominare e/o riorganizzare un gruppo di file di foto in un modo complicato. Forse vuoi
scrivere un piccolo database personalizzato, o un'applicazione grafica GUI (Grafics User Interface)
specializzata oppure un semplice gioco.
Se sei uno sviluppatore di software professionale, potresti avere l'esigenza di lavorare con parecchie
librerie C / C + + / Java, ma utilizzando linguaggi compilati come noto, il ciclo usuale di scrittura /
compilazione / test / ricompilazione, molto lento e tedioso. Forse stai scrivendo una suite di un test per
una libreria e scrivere e provare il codice diventa un compito noioso, o forse hai scritto una libreria che
potrebbe essere usata come estensione per altri utenti potenziando cos il linguaggio. Se questo vero
anche in parte, allora Python quello di cui ai bisogno.
Si potrebbe scrivere uno script con una shell Unix o un file batch di Windows per alcuni di questi compiti,
ma gli script di shell, sono pi adatti per la rimozione o la modifica di file di testo ma non per le
applicazioni GUI (Grafics User Interface) giochi o per programmi interattivi. Si potrebbe in alternativa
scrivere un programma in C + + / C o Java, ma tutto questo richiede un notevole tempo di sviluppo anche
solo per un primo e semplice programma embrionale funzionante. Python viceversa semplice da usare, e
cosa da non sottovalutare disponibile per Windows, Mac OS X Unix e quindi Linux. Questo ti aiuter
a ottenere un lavoro fatto pi velocemente e probabilmente migliore oltre che multi piattaforma.
Python semplice da usare, ma non significa per questo che sia un linguaggio di programmazione dalle
scarse potenzialit. Python per esempio offre un supporto per gli script veramente notevole assai migliore
di qualsiasi semplice script di shell o batch. Questo non deve per trarre in inganno in quanto solo uno
dei lati positivi. Infatti esso un linguaggio di programmazione vero e proprio di livello molto alto che
racchiude in se tutte le migliori caratteristiche di altri linguaggi aggiungendo funzionalit non presenti in
alcuni ed eliminando molti dei difetti.
Per esempio Python offre molto pi controllo degli errori di C, e, essendo un linguaggio di livello molto
alto, possiede tipi di dati di alto livello integrati, come array (matrici di dati) flessibili, dizionari, liste
tuple e la possibilit di combinare queste strutture fra di loro (veramente potente). Queste
implementazioni, sollevano il programmatore dal dover reinventare l'acqua calda e dalla gran parte degli
errori che possono essere commessi in fase di programmazione a causa della complessit degli argomenti.
Questo ha fatto di Python un linguaggio molto popolare, molto usato e molto diffuso.
Esso permette di suddividere il programma in moduli che possono essere riutilizzati in altri programmi
Python. Viene fornito con una grande collezione di moduli standard e di una sterminata collezione di
librerie prodotte da molti appassionati, che spaziano fra gli ambiti pi disparati che potete usare come
base dei vostri programmi e/o come esempi per iniziare ad imparare a programmare. Alcuni di questi
moduli offrono cose come l' I/O (l'accesso ai file), chiamate di sistema, connessioni di rete, ambienti per
interfacce grafiche utente come TK QT GTK ecc.

Python un linguaggio interpretato, ci significa che possibile risparmiare molto tempo durante lo
sviluppo del programma, perch non necessaria la continua compilazione e conseguente linkaggio.
L'interprete pu essere utilizzato interattivamente il che lo rende facile per sperimentare le caratteristiche
proprie, scrivere programmi usa e getta per testare funzioni durante lo sviluppo di un programma
principale. Inoltre anche un'utile calcolatrice.
Python consente ai programmi di essere scritti in modo compatto e di essere di facile lettura in quanto
obbliga a scriverli in un certo modo. I programmi scritti in Python sono in genere molto pi brevi dei
programmi equivalenti C C + + o Java, per diverse ragioni fra cui:

I tipi di dati di alto livello consentono di esprimere operazioni complesse anche con una singola
istruzione;
Le istruzioni vengono raggruppate tramite indentazione anzich usare parentesi iniziale e finale o
blocchi tipo INIZIO BLOCCO FINE BLOCCO;
Non necessario dichiarare alcuna variabile.

Nota:
Quest'ultima caratteristica, far storcere il naso ad alcuni programmatori specialmente di provenienza C
C++ e Java. Ma come vedremo pi avanti, la richiesta di scrittura di codice talmente minore rispetto ad
altri linguaggi per esempio da minimizzare la questione. Inoltre essendo fortemente dinamico, usa un'
approccio totalmente diverso da altri linguaggi (argomento complesso che sar trattato pi avanti)
Python estendibile: se sapete programmare in C facile aggiungere una nuova funzione o un modulo pre
costruito per l'interprete, sia per eseguire operazioni critiche alla massima velocit, o per collegare
programmi Python a librerie che possono essere disponibili solo in forma binaria (ad esempio librerie
grafiche proprietarie o di sistema). Una volta che siete diventati davvero pratici, possibile collegare
l'interprete Python in un'applicazione scritta in C e usarlo come linguaggio di estensione o di comando
per tale applicazione.
Molti si domanderanno perch si chiami Python! Non ha nulla a che vedere con i serpenti, il suo autore
Guido Van Rossum un'appassionato della serie televisiva di sketch Monty Python". Fare riferimenti
alle comiche dei Monty Python nella documentazione permesso, non solo ma incoraggiato! (l'uso
della parola spam ad esempio veramente ossessiva (sar perch la carne in scatola non mi fa impazzire,
ma tant'...)
Ora che sarete senz'altro entusiasti di Python, vi consigliamo di esaminare in maggior dettaglio il
linguaggio e il suo ambiente. Dal momento che il modo migliore per imparare una linguaggio quello di
usarlo, questa guida vi invita a giocare con l'interprete Python ed ad eseguirne gli esempi.
Nel prossimo capitolo, verranno spiegati i meccanismi per utilizzare l'interprete. Si tratta di informazioni
piuttosto banali, ma essenziali per provare gli esempi mostrati successivamente. Il resto della guida,
introduce varie caratteristiche di Python attraverso esempi iniziando con semplici espressioni, istruzioni e
tipi di dati, attraverso funzioni e moduli, ed infine, toccando concetti avanzati come le eccezioni e le classi
definite dall'utente ecc.

2. Usare l'interprete di Python.

2.1. Invocare l'interprete.
Su sistemi UNIX/LINUX:
L'interprete

Python

su

una

macchina

Unix/Linux,

generalmente

installato

in

/usr/local/bin/python3.x (la x specifica il particolare numero di versione) su quelle macchine dove

disponibile; mettere /usr/local/bin nel percorso di ricerca della shell Unix/Linux rende possibile

avviarlo digitando il comando:

python3
Poich la scelta della directory in cui risiede l'interprete un'opzione di installazione, possibile installare
Python in altre posizioni che potete decidere da soli o con l'amministratore del sistema. (Ad esempio,
/usr/local/python una scelta piuttosto popolare.)
su sistemi WINDOWS:
Su macchine Windows, l'installazione di Python di solito collocata in C:\Python3x, anche se
possibile modificare la posizione in fase di installazione. Per aggiungere questa directory al file di path,
possibile digitare il seguente comando nel prompt dei comandi in un terminale DOS:
setpath=%path%;C:\python3x
Digitando un carattere di end-of-file ( Control-D su Unix/Linux, Control-Z su Windows) al prompt
primario fa s che l'interprete esca con uno stato di uscita uguale zero. Se questo non funziona, si pu
uscire l'interprete digitando quit().
E' possibile inoltre far convivere quante versioni di Python si desidera senza che entrino in conflitto far di
loro.
Gli editor di linea per l'interprete di solito non hanno funzionalit molto sofisticate. Su Unix/Linux,
chiunque abbia installato l'interprete pu avere abilitato il supporto per la libreria GNU readline, che
aggiunge pi elaborate funzioni di editing e una cronologia interattiva. Forse il controllo pi veloce per
vedere se la modifica della riga di comando che si sta scrivendo supportata Control-P quando si
ottiene il prompt di Python. Se si ottiene un beep, allora si ha l'editing della riga di comando, fare
riferimento all'appendice Interactive Input Editing and History Substitution per un'introduzione sull'uso
dei tasti. Se ci non sembra funzionare o se viene visualizzato ^P allora l'editing della riga di comando
non disponibile, sarete solo in grado di utilizzare backspace per rimuovere i caratteri dalla riga corrente.
L'interprete di Python, opera all'incirca come una shell Unix/Linux, quando viene chiamato con lo
standard input connesso a un dispositivo terminale (la tastiera) legge ed esegue i comandi in modo
interattivo, se Python viene chiamato e come argomento, viene passato un file di script, allora Python si
avvia eseguendo lo script del file passato.
Un secondo modo di lanciare l'interprete python -c command [arg] ..., che esegue
l'istruzione/i al comando, analogo a -C dell'opzione della shell. Poich istruzioni Python contengono
spesso spazi o altri caratteri che sono speciali per la shell, di solito consigliato l'uso preventivo di apici

al cui interno racchiuso il comando nella sua interezza. Alcuni moduli Python sono utili anche come
script. Questi possono essere richiamati utilizzando python -m module [arg] ..., che esegue il
file di origine per il modulo, come se si fosse scritto il suo nome completo sulla riga di comando. Quando
si utilizza un file di script, a volte utile essere in grado di eseguire lo script ed entrare in modalit
interattiva successivamente. Questo pu essere fatto passando -I prima dello script.

2.1.1. Passaggio di argomenti.

Una volta attivato l'interprete con il nome dello script e gli eventuali argomenti aggiuntivi, essi vengono
trasformati in una stringa il cui interno contiene i parametri passati separati da degli spazi. Questa stringa
cos composta, viene passata alla variabile argv gestita dal nel modulo sys. Quindi per poter
utilizzare i parametri eventualmente passati, necessario importare il suddetto modulo digitando import
sys. Per poter processare gli argomenti passati, la lunghezza della lista deve contenere almeno un'
argomento, se non contiene argomenti, significa che la stringa vuota e sys.argv[0]. L'argomento
pur non essendo difficile, richiede una spiegazione ampia, per cui si rimanda alle varie guide presenti in
rete.

2.1.2. Modo Interattivo.

Quando l'interprete legge i comandi da un terminale (tty) tipicamente la tastiera, si dice che in modalit
interattiva. In questa modalit viene richiesto per il comando successivo un prompt primario, di solito tre
segni di maggiore (>>>), per le righe che richiedono una continuazione di comandi, viene attivato un
prompt secondario costituito da tre punti (...). All'avvio l'interprete stampa un messaggio di benvenuto
che indica il numero di versione e un avviso di copyright prima di attivare il prompt come indicato sotto.
$python3
Python3.4.0(default,Jan132014,23:33:01)
[GCC4.4.3]onlinux
Type"help","copyright","credits"or"license"formoreinformation.
>>>
Le linee di continuazione, come gi detto sono composte da tre punti ad esempio al seguito di
un'istruzione if
>>>il_mondo_e_piatto=1
>>>ifil_mondo_e_piatto:
...print("Attentoanoncaderegi!")
...
Attentoanoncaderegi!
>>>

2.2. L'interprete e il suo ambiente.

2.2.1. Trattamento degli errori.
Quando si verifica un errore, l'interprete stampa un messaggio di errore e una traccia dello stack. In

modalit interattiva ritorna al prompt primario. Quando invece l'input venuto da un file, esso esce con
uno stato diverso da zero dopo aver stampato la traccia dello stack. (Eccezioni gestite da una clausola
except in un'istruzione try
non sono errori in questo contesto.) Alcuni errori sono
incondizionatamente fatali e provocano un'uscita forzata con un valore diverso da zero, questo vale per le
incoerenze interne e alcuni casi tipo esaurimento della memoria disco ecc. Tutti i messaggi di errore
vengono scritti nel flusso di errore standard-output tipicamente il monitor o dove specificato. Digitando il
carattere di interruzione (di solito Ctrl-C o CANC) al prompt primario o secondario si cancella l'input e
ritorna al prompt primario (>>>).
[2] Provocare un'interruzione forzata mentre un comando in esecuzione solleva l'eccezione
KeyboardInterrupt, che pu essere gestita tramite un'istruzione try.

2.2.2. Scripts Python Eseguibili.

Sui sistemi Unix/Linux in stile BSD, gli script Python possono essere direttamente eseguibili, come script
di shell inserendo la riga:
#!/usr/bin/envpython3.x
(supponendo che l'interprete si trovi nel PATH dell'utente) all'inizio dello script e dando al file il permesso
di esecuzione. I caratteri #! devono essere i primi due caratteri del file. Su alcune piattaforme, questa
prima riga deve terminare con una linea finale in stile Unix ('\n' cio il terminatore di linea significante
'nuova linea'), non tipo Windows ('\r\n' cio il terminatore di linea significante ' ritorno del carrello pi
nuova linea'). Va notato che il carattere '#'o hash, o carattere cancelletto, viene utilizzato anche per
descrivere un commento in Python. Uno script per poter essere eseguito, deve avere un permesso come
tale. E possibile renderlo eseguibile utilizzando il comando chmod:
$chmod+xmyscript.py
Sui sistemi Windows, non vi alcuna nozione di "modo eseguibile". Il programma di installazione di
Python associa automaticamente l'estensione .Py con python.exe in modo che un doppio clic su un file
Python verr eseguito come uno script. L'estensione pu anche essere. PYW, in questo caso, la finestra di
console che appare normalmente viene soppressa.

2.2.3. Codifica del codice sorgente.

Per impostazione predefinita, i file sorgenti Python vengono trattati come codificati in UTF-8. Con tale
codifica, possibile rappresentare la maggior parte delle lingue del mondo. Essi possono essere utilizzati
contemporaneamente nelle stringhe letterali come identificatori e commenti. Si consiglia comunque di
utilizzare solo caratteri ASCII per gli identificatori, ed buona norma utilizzare solo questo tipo di
caratteri se vogliamo che il nostro codice sia veramente portabile e di utilizzare UTF-8 solo per stringhe
di testo per i messaggi nella specifica lingua. Comunque per visualizzare correttamente tutti i caratteri, il
vostro editor deve riconoscere che il file UTF-8, e deve utilizzare un font che supporta tutti i caratteri
utilizzati dal file. anche possibile specificare una codifica differente per i file sorgente. Per fare questo,
mettere ancora una riga di commento speciale subito dopo la linea #! per definire la codifica del file di

origine:
#*coding:encoding*
Con questa dichiarazione, tutto nel file sorgente verr considerata come avente la codifica encoding
invece di UTF-8. L'elenco dei possibili codifiche pu essere trovata nella Python Library Reference, nella
sezione codecs. Ad esempio, se il vostro editor preferito non supporta file codificati UTF-8 e insiste
sull'utilizzo di qualche altra codifica, possibile per esempio scrivere Windows-1252, per ottenere il
risultato:
#*coding:cp1252*
Ci utilizzer tutti i caratteri di caratteri nei file sorgente in Windows-1252. Il commento speciale
codifica deve essere nella prima riga se da solo o nella seconda linea se presente quella di path
all'interno del file.

2.2.4. Il File Di Avvio In Modalit Interattiva.

Quando si usa Python interattivamente, spesso comodo che alcuni comandi standard vengano eseguiti
ogni volta che l'interprete viene avviato. possibile farlo impostando una variabile di ambiente
denominata PYTHONSTARTUP essa pu contenere il nome di un file contenente i comandi di start-up.
Questo simile alla funzione .profile delle shell di Unix/Linux.
Questo file viene letto solo nelle sessioni interattive, non quando Python legge comandi da uno script, e
non quando /dev/tty impostata come sorgente dei comandi (altrimenti si comporterebbe come una
sessione interattiva). Esso viene eseguito nello stesso spazio dei nomi in cui vengono eseguiti i comandi
interattivi, cosicch gli oggetti che definisce o importa possono essere utilizzati senza riserve nella
sessione interattiva. inoltre possibile modificare in questo filele istruzioni sys.ps1 e sys.ps2 che
permettono di cambiare i prompt di Python.
Se volete leggere un file di avvio addizionale dalla directory corrente, possibile programmare questo nel
file globale di avvio utilizzando il codice tipo os.path.isfile('.pythonrc.py'):
exec(open('.pythonrc.py').read()). Se si desidera utilizzare il file di avvio in uno script,
deve essere necessariamente nello script:
importos
filename=os.environ.get('PYTHONSTARTUP')
iffilenameandos.path.isfile(filename):
exec(open(filename).read())

Queste impostazioni possono essere utili ma non necessario che le approfondiate adesso.

2.2.5. La Personalizzazione Dei Moduli.

Python fornisce due modi che consentono di personalizzarli: sitecustomize e usercustomize.
Per vedere come funziona, necessario prima di trovare il percorso della directory site-packages utente.

Avviare Python ed eseguire questo codice:

>>>importsite
>>>site.getusersitepackages()
'/home/user/.local/lib/python3.4/sitepackages'
Ora possibile creare un file denominato usercustomize.py in quella directory e mettere tutto
quello che volete in essa. Essa interesser ogni invocazione di Python, a meno che non venga avviato con
l'opzione -s per disattivare l'importazione automatica. sitecustomize funziona allo stesso modo, ma
viene in genere creato da un amministratore del computer nella directory globale site-packages,
usercustomize se esiste, e viene importata per prima. Vedere la documentazione del modulo site
per maggiori dettagli.
1] Su Unix/Linux, l'interprete Python 3.x, non installato di default ma viene installata ad oggi la
versione 2.x in quanto numerosi programmi e script la utilizzano. Inoltre digitando semplicemente
python, si avvia la versione 2.x. Per far avviare la versione 3.x bisogne digitare se installato
python3. Questo a causa di alcune incompatibilit dovute ai miglioramenti apportati alla versione
3.x rispetto alla 2,x.
[2] Un problema con il pacchetto GNU Readline pu impedire questo.

3. Un' Informale Introduzione A Python.

Nei seguenti esempi, input e output si distinguono per la presenza o l'assenza di richieste (>>> e ...):
per ripetere l'esempio, necessario digitare tutto dopo il prompt, quando esso appare. Righe che non
iniziano con un prompt sono output dell'interprete. Si noti che un prompt secondario su una riga in un
esempio significa che necessario digitare una riga vuota, questo usato per terminare un comando
multi-linea.
Molti degli esempi in questa guida, anche quelli immessi al prompt interattivo, includono commenti. In
Python i commenti iniziano con il carattere cancelletto, # e si estendono fino alla fine fisica della linea.
Un commento pu comparire all'inizio di una riga o in seguito al codice, ma non all'interno di una stringa
letterale. Un carattere hash (#)all'interno di una stringa letterale solo un carattere qualsiasi e viene
rappresentato cos com' cio privo di valore. Dal momento che i commenti servono per chiarire il codice
e non sono interpretati da Python, possono essere omessi durante la digitazione negli esempi.
Qualche esempio:
#Questoilprimocommento.
spam=1#equestoilsecondo
#...eorailterzo
text="#Questononuncommentoperchinseritoinunastringa."

3.1. Usare Python Come Un Calcolatore.

Proviamo con qualche semplice comando Python. Avviare l'interprete e attendere il prompt primario,
>>>. (Non dovrebbe impiegarci troppo tempo)

3.1.1. Numeri.
L'interprete si comporta come una semplice calcolatrice: si pu digitare un'espressione ed esso fornir il
risultato. La sintassi delle espressioni semplice: gli operatori +, -, * e / funzionano come nella maggior
parte degli altri linguaggi (ad esempio, Pascal o C); parentesi anche nidificate (()) possono essere
utilizzati per il raggruppamento e la risoluzione. Per esempio:
>>>2+2
4
>>>505*6
20
>>>(505*6)/4
5.0
>>>8/5#ladivisionerestituiscesempreunnumeroinvirgola
mobile(diversamentedaPython2.x)
1.6
I numeri interi (es. 2, 4, 20) sono di tipo int, quelli con una parte frazionaria (es. 5.0, 1.6) sono di
tipo float. Vedremo di pi su tipi numerici pi avanti nella guida.

Divisione (/) restituisce sempre un float. Per ottenere un risultato intero (scartando qualsiasi risultato
frazionario) possibile utilizzare l'operatore // vedere floor division, per calcolare il resto possibile
utilizzare %:

>>>17/3#classicadivisionerestituisceunnumeroinvirgola
mobile
5.666666666666667
>>>
>>>17//3#divisionechescartalapartedecimale
5
>>>17%3#l'operatore%invecerestituiscelarimanenzadella
divisione
2
>>>5*3+2
17
Con Python possibile usare l'operatore ** per calcolare la potenza di un numero [1]:
>>>5**2#5ilquadrato
25
>>>2**7#2elevatoallapotenzadi7
128
Il segno di uguale (=) viene utilizzato per assegnare un valore a una variabile e non come operatore di
confronto (==). Successivamente, nessun risultato viene visualizzato prima del successivo prompt
interattivo:

>>>altezza=20
>>>larghezza=5*9
>>>altezza*larghezza
900
Se si cercher di utilizzare una variabile a cui non si sia precedentemente assegnato un valore, si generer
un'errore.
>>>n#variabilesenzaassegnazione
Traceback(mostrecentcalllast):
File"<stdin>",line1,in<module>
NameError:name'n'isnotdefined
Python ha un potente supporto per i dati in virgola mobile e operatori di tipo con operandi misti,
convertono l' operando intero a virgola mobile:
>>>3*3.75/1.5
7.5
>>>7.0/2
3.5
In modo interattivo, l'ultima espressione stampata viene assegnata alla variabile _. Ci significa che
quando si utilizza Python come una calcolatrice da tavolo, un po 'pi facile continuare calcoli, ad
esempio:
>>>tassa=12.5/100
>>>prezzo=100.50
>>>prezzo*tassa
12.5625
>>>prezzo+_
113.0625
>>>round(_,2)
113.06
Questa variabile deve essere considerata come a sola lettura da parte dell'utente. Non assegnare
esplicitamente un valore ad essa per utilizzare il suo contenuto, bisogna creare una variabile locale
indipendente per mascherare la variabile precostituita con il suo comportamento magico.
Oltre a int e float, Python supporta altri tipi di numeri, come Decimal e Fraction. Python ha
anche il supporto integrato per i numeri complessi complex numbers, e utilizza il suffisso j o J per
indicare la parte immaginaria (es. 3+5j).

3.1.2. Le Stringhe.
Oltre ai numeri, Python pu anche manipolare stringhe, che possono essere espresse in vari modi. Esse
possono essere racchiuse tra singoli apici ('...') o doppi apici ("...") con lo stesso risultato [2]. il

carattere '\' Pu essere usato per rappresentare le virgolette all'interno di una stringa:
>>>'spamuova'#virgolettesingole
'spamuova'
>>>'all\'ariaaperta'#\permetterelastampadell'apice.
"all'ariaaperta"
>>>"all'ariaaperta"#...oppureutilizzandolevirgolettedoppie
"all'ariaaperta"
>>>'"Si,"hadettosi.'
'"Si,"hadettosi.'
>>>"\"Si,\"hadettosi."
'"Si,"hadettosi.'

Nel interprete interattivo, la stringa di output racchiusa tra virgolette e caratteri speciali sono stampati
usando la barra rovesciata o backslashes. Anche se questo potrebbe talvolta portare un' aspetto diverso per
l' input (le virgolette che racchiudono potrebbero cambiare), le due stringhe sono equivalenti. La stringa
racchiusa tra virgolette doppie se la stringa contiene una singola senza virgolette, altrimenti viene
racchiuso tra virgolette singole. La funzione print() produce un output pi leggibile, omettendo le
virgolette che racchiudono la stringa evitando i caratteri speciali:
>>>print('"Si,"hadettosi.')
"Si,"hadettosi.
>>>s='lineauno.\nlineadue.'#\nsignificanuovalinea
>>>s#senzaprint(),\nvienestampata
'lineauno.\nlineadue.'
>>>print(s)#quiproduceunanuovalinea
lineauno.
lineadue.
Se non si desidera che i caratteri preceduti da \ siano interpretati come caratteri speciali, possibile
utilizzare il raw strings aggiungendo una r prima delle virgolette con questo sistema, l'interprete non
valuter nessuna elaborazione ma semplicemente presenta il tutto cos com':
>>>print('C:\some\nome')#qui\nsignificaunanuovalinea!
C:\some
ome
>>>print(r'C:\some\nome')#notarelarprimadellavirgoletta
C:\some\nome
I letterali stringa possono estendersi su pi righe. Un modo per farlo, usare le triple
virgolette:"""...""" . I fine linea vengono inclusi automaticamente nella stringa, ma possibile
impedire questo comportamento aggiungendo un \ alla fine della prima riga. In questo esempio, viene
prodotto il seguente output :
print("""\

Usare:Queste[OPZIONI]
Visualizzaquesterighe
h...
Hhostname...
""")

Le stringhe possono essere concatenate (incollate assieme sequenzialmente) con l'operatore +, e ripetuto
con *:
>>>#3volte'Pippo',seguitoda'si!'
>>>3*'Pippo'+'si!'
'PippoPippoPipposi!'
Due o pi stringhe letterali (cio quelle racchiuse tra virgolette) l'una accanto all'altra vengono
automaticamente concatenate.
>>>'Py''thon'
'Python'
Questo funziona solo con i letterali ma non con le variabili o espressioni:
>>>prefix='Py'
>>>prefix'thon'#nonpossibileconcatenareunavariabileconuna
stringa.
...
SyntaxError:invalidsyntax
>>>('un'*3)'ium'
...
SyntaxError:invalidsyntax
Se lo scopo quello di concatenare due variabili, allora dovete usare il segno +:
>>>prefix='thon'
'Python'
Questa caratteristica e spesso usata quando si cerca di spezzare stringhe troppo lunghe:
>>>text=('Metterepistringheall'internodi'
'parentesiperunirle.')
>>>text
'Metterepistringheall'internodiparentesiperunirle.'
Le stringhe possono essere indicizzate per cui il primo carattere ha come indice lo 0. Non vi alcuna
distinzione fra caratteri! Semplicemente ognuno rappresenta se stesso:

>>>word='Python'
>>>word[0]#carattereallaposizione0
'P'
>>>word[5]#carattereallaposizione5
'n'
Gli indici possono essere anche numeri negativi, in questo caso il conteggio inizia da destra:
>>>word[1]#l'ultimocarattere
'n'
>>>word[2]#penultimocarattere
'o'
>>>word[6]#ilprimocarattere
'P'
Si noti che poich -0 lo stesso di 0, gli indici negativi partono da -1.
Oltre all'indicizzazione, supportato anche la divisione o slicing (letteralmente 'affettamento'). Mentre
l'indicizzazione viene utilizzata per ottenere singoli caratteri, la divisione viene utilizzata per ottenere
delle sotto stringhe:
>>>word[0:2]#caratteridallaposizione0alla2incluse
'Py'
>>>word[2:5]#caratteridallaposizione0inclusaa5esclusa
'tho'
Si noti come l'inizio sempre incluso, e la fine sempre esclusa. Questo fa in modo che s [: i] + s [i:]
sempre uguale a s:
>>>word[:2]+word[2:]
'Python'
>>>word[:4]+word[4:]
'Python'
Gli indici delle sotto stringhe, hanno valori predefiniti utili; se omesso il primo indice uguale a zero,
cos se omesso il secondo, viene definito dalla lunghezza della sotto stringa.
>>>word[:2]#caratteredall'inizioallaposizione2
'Py'
>>>word[4:]#caratteredallaposizione4allafine
'on'
>>>word[2:]#caratteredallapenultimaposizioneallafine
'on'
Indici fuori intervallo, sono trattati ignorandoli evitando cos errori inutili:
>>>word[4:42]

'on'
>>>word[42:]
''
Le stringhe in Python non possono essere modificate, sono di tipo immutable cio immutabili. Pertanto,
l'assegnamento ad un indice di una stringa costituisce un errore:
>>>word[0]='J'
...
TypeError:'str'objectdoesnotsupportitemassignment
>>>word[2:]='py'
...
TypeError:'str'objectdoesnotsupportitemassignment
Se la modifica di una stringa, si rende necessaria, dovete crearne una nuova:
>>>'J'+word[1:]
'Jython'
>>>word[:2]+'py'
'Pypy'
La funzione precostituita len() restituisce la lunghezza della stringa passatagli:
>>>s='supercalifragilistiespiralitoso'
>>>len(s)
31

Vedere anche:
Text Sequence Type str
Esempi di sequenza di tipi sulle stringhe, supportano le comuni operazioni supportate da tali tipi.
String Methods
Stringhe supportano un gran numero di metodi per le trasformazioni di base e la ricerca.
String Formatting
Informazioni sulla formattazione delle stringhe con str.format() .
printf-style String Formatting
Le vecchie operazioni di formattazione invocate con le stringhe Unicode utilizzano l'operando % alla sua
sinistra. Sono qui descritte in maggiore dettaglio.

3.1.3. Le Liste.
Python possiede un certo numero di tipi di dati composti molto potenti, usati per raggruppare altri valori
fra cui Il pi versatile la lista, che pu essere scritta come un elenco di valori separati da virgole
(articoli) tra parentesi quadre. Le liste possono contenere elementi di tipo diverso, ma di solito gli
elementi sono tutti lo stesso tipo.

>>>quadrati=[1,2,4,9,16,25]
>>>quadrati
[1,2,4,9,16,25]
Come per le stringhe (e tutti gli altri tipi di sequenze precostituite), le liste possono essere indicizzate e
suddivise:
>>>quadrati[0]#restituisceilprimoelemento
1
>>>quadrati[1]
25
>>>quadrati[3:]#suddivideglielementiinunanuovalista
[9,16,25]
Tutte le operazioni di suddivisione, restituiscono un nuovo elenco contenente gli elementi richiesti. Ci
significa che la seguente suddivisione restituisce una nuova (superficiale) copia della lista:
>>>quadrati[:]
[1,2,4,9,16,25]
Le liste supportano anche le operazioni di concatenamento:
>>>quadrati+[36,49,64,81,100]
[1,2,4,9,16,25,36,49,64,81,100]

Diversamente dalle stringhe, che sono immutabili, liste sono un tipo mutabile, cio possibile modificare
il loro contenuto:
>>>cubi=[1,8,27,65,125]#quic'qualcosachenonva
>>>4**3#ilcubodi464,non65!
64
>>>cubi[3]=64#sostituisceilvaloreerrato
>>>cubi
[1,8,27,64,125]
inoltre possibile aggiungere nuovi elementi alla fine della lista, utilizzando il metodo append()
(vedremo di pi sui metodi in seguito):
>>>cubi.append(216)#aggiungeilcubodi6
>>>cubi.append(7**3)#eilcubodi7
>>>cubi
[1,8,27,64,125,216,343]

E' anche possibile l'assegnamento a sotto liste. Questo pu

cancellarla interamente:

cambiare la dimensione della lista o

>>>lettere=['a','b','c','d','e','f','g']
>>>lettere
['a','b','c','d','e','f','g']
>>>#sostituiscealcunivalori
>>>lettere[2:5]=['C','D','E']
>>>lettere
['a','b','C','D','E','f','g']
>>>#oranerimuovealcuni
>>>lettere[2:5]=[]
>>>lettere
['a','b','f','g']
>>>#cancellalalistasostituendolaconunavuota
>>>lettere[:]=[]
>>>lettere
[]
La funzione precostituita len() applicata anche alle liste:
>>>lettere=['a','b','c','d']
>>>len(lettere)
4
E' inoltre possibile nidificarle creare cio delle liste al cui interno sono presenti altre liste e non solo per
esempio:
>>>a=['a','b','c']
>>>n=[1,2,3]
>>>x=[a,n]
>>>x
[['a','b','c'],[1,2,3]]
>>>x[0]
['a','b','c']
>>>x[0][1]
'b'

3.2. Primi Passi Di Programmazione.

Naturalmente, possiamo usare Python per compiti pi complessi piuttosto che aggiungere due pi due. Ad
esempio, possiamo scrivere una sub-sequenza iniziale della serie di Fibonacci come segue:

>>>#seriediFibonacci:
...#lasommadidueelementi,definiscel'elementosuccessivo

...a,b=0,1
>>>whileb<10:
...print(b)
...a,b=b,a+b
...
1
1
2
3
5
8
Quest'esempio, introduce nuove ed importanti caratteristiche.

La prima riga utile contiene un assegnamento multiplo: le variabili a e b, ottengono

contemporaneamente i valori 0 e 1. Lo stesso dicasi per l'ultima riga, a dimostrazione che le
espressioni sul lato destro vengono tutte valutate prima di un' assegnazione. Le espressioni laterali
vengono valutate da sinistra a destra.

Il ciclo while viene eseguito fino a quando la condizione (qui: b < 10) rimane vera. In Python,
come in C, qualsiasi valore intero non-zero vero, nulla falso. La condizione pu anche essere
un valore stringa o una lista, di fatto qualsiasi sequenza, qualsiasi cosa con una lunghezza diversa
da zero vero, le sequenze vuote sono false. Il test utilizzato nell'esempio un semplice confronto.
Gli operatori standard di confronto sono scritti come in C: < (minore di), > (maggiore di), ==
(uguale a), <= (minore o uguale a), >= (maggiore o uguale a) e != (non uguale a).

Il corpo del ciclo indentato: l'identazione il modo con cui Python raggruppa le istruzioni. A
differenza di altri linguaggi, Python non utilizza parentesi graffe {} come in C o marcatori di
blocco come in Pascal. Ma usa gli spazi. Al prompt interattivo, necessario digitare una
tabulazione o uno spazio per ogni linea identata cio costituita da 2 so pi spazi. In pratica se non
si possiede un editor di testo con autoidentazione, la possibilit di errori aumenta in quanto il
solo modo con cui Python riconosce le diverse righe di codice. La cosa positiva che non richiede
caratteri terminatori come negli altri linguaggi tipo la virgola il punto e virgola, il ritorno del
carrello ecc. Inoltre costringe il programmatore ad uniformarsi a quello stile piacente o non
piacente a beneficio di chiunque legga il programma. Quando viene immessa in modo interattivo
un'istruzione composta, deve essere seguita da una riga vuota per indicare il suo completamento
(dato che il parser (l'analizzatore di linee di programma) non pu sapere quando si digitato
l'ultima riga). Si noti che ogni riga all'interno di un blocco di base deve essere rientrata nello
stesso modo.

La funzione print() scrive il valore dell'argomento/i dati. Si differenzia dal semplice scrivere
l'espressione che volete (come abbiamo fatto in precedenza negli esempi calcolatrice) nel modo in
cui gestisce pi argomenti, numeri e stringhe. Le stringhe vengono stampate senza virgolette, e
viene inserito uno spazio tra gli elementi, in modo da presentare gli elementi in modo ordinato,
come questo esempio:

>>>i=256*256
>>>print('Ilvaloredii',i)
Ilvaloredii65536

La parola chiave end pu essere usata per evitare la nuova riga dopo l'output, o terminare l'output
con una stringa differente:
>>>a,b=0,1
>>>whileb<1000:
...print(b,end=',')
...a,b=b,a+b
...
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
Note:
[1] Poich ** ha precedenza maggiore rispetto a -3**2 saranno interpretati come (3**2) e quindi
produrre il risultato di -9. Per evitare questo ed ottenere 9, possibile usare (-3)**2.
[2] A differenza di altri linguaggi, caratteri speciali come \n hanno lo stesso significato sia con singoli
('...') e doppi ("...") apici. L'unica differenza tra i due che tra singoli apici non c' bisogno di
usare il carattere di escape \ e viceversa.

4. Strumenti Per Controllare il Flusso.

Oltre all'istruzione while appena introdotta, Python riconosce le solite istruzioni di controllo del flusso
che possiedono anche altri linguaggi, con alcune migliorie.

4.1. L'Istruzione if.

E' forse il tipo di istruzione pi conosciuta. Per esempio:
>>>x=int(input("immettiunintero:"))
immettiunintero:42
>>>ifx<0:
...x=0
...print('Negativocambiatoinzero')
...elifx==0:
...print('Zero')
...elifx==1:
...print('Singolo')
...else:
...print('Altro')
...
Altro
Ci possono essere o nessuna o pi elif, la parte else opzionale. La parola chiave 'elif' la
contrazione di 'else if', ed utile essendo pi corta per evitare un' eccessiva identazione. Una sequenza di
... elif ... elif ...if un sostituto per l' istruzione switch o case che si trova in altri linguaggi.

4.2. L'Istruzione for.

L'istruzione for in Python differisce un po 'da quello che si pu essere abituati in C o Pascal. Piuttosto
che iterare sempre su una progressione aritmetica di numeri (come in Pascal), o dare all'utente la
possibilit di definire sia il passo di iterazione e la condizione di arresto (come C), l'istruzione for di
Python, itera sugli elementi di una sequenza tipo una lista o una stringa, nell'ordine in cui appaiono nella
sequenza. Ad esempio:
>>>#Misuralalunghezzadialcunestringheinunalista:
...parole=['gatto','finestra','defenestrato']
>>>forwinparole:
...print(w,len(w))
...
gatto5
finestra8
defenestrato12
Notare la notevole semplicit e compattezza dell'istruzione. Se necessario modificare la sequenza di
iterazione all'interno del ciclo (ad esempio per duplicare gli oggetti selezionati), si consiglia di eseguire
una copia. L'iterazione di una sequenza non implicita il fare una copia. La notazione slice lo rende
particolarmente conveniente:
>>>forwinparole[:]:#Ciclasullalistaelaricopiasopra.
...iflen(w)>8:
...parole.insert(0,w)
...
>>>parole
['defenestrato','gatto','finestra','defenestrato']

4.3. La Funzione range().

Se si necessita d'iterare su una sequenza di numeri, la funzione precostituita range(), viene in aiuto.
Essa genera progressioni aritmetiche:
>>>foriinrange(5):
...print(i)
...
0
1
2
3
4
Notare anche in questo caso, la compattezza del codice.

Il dato finale non mai parte della sequenza generata; range(10) genera 10 valori, gli indici leciti per
gli elementi di una sequenza di lunghezza 10. E' possibile partire da un altro numero, o specificare un
incremento diverso (persino negativo, a volte questo chiamato il ' passo '):
range(5,10)
5verso9
range(0,10,3)
0,3,6,9
range(10,100,30)
10,40,70
Per scorrere gli indici di una sequenza, possibile combinare range() e len() come segue:
>>>a=['Maria','ha','un','piccolo','agnello']
>>>foriinrange(len(a)):
...print(i,a[i])
...
0Maria
1ha
2un
3piccolo
4agnello
Nella maggior parte dei casi, tuttavia, conveniente utilizzare la funzione enumerate(), vedere
Tecniche dei cicli Looping Techniques.
Una cosa strana succede solo se si stampa un intervallo:
>>>print(range(10))
range(0,10)
In molti casi l'oggetto restituito da range() si comporta come se fosse una lista, ma in realt non lo . E'
un oggetto che restituisce gli elementi successivi nella sequenza desiderata quando si scorre su di esso, ma
in realt non fa realmente una lista, risparmiando cos spazio in quanto non conservato in memoria.
Diciamo un tale oggetto iterabile, cio, adatto come obiettivo per le funzioni e costrutti che si aspettano
qualcosa in cui si possono ottenere elementi successivi fino ad esaurimento dei dati. Abbiamo visto che
l'istruzione for un iteratore. La funzione list() ne un' altro, crea liste di iterabili:
>>>list(range(5))
[0,1,2,3,4]
Pi avanti vedremo altre funzioni che restituiscono iterabili e prendono iterabili come argomento.

4.4. L'Istruzione break e continue e La Clausola else Sui

Cicli.
L'istruzione break, come in C, esce dal ciclo for o while che lo contiene. Istruzioni di ciclo possono
avere una clausola else, che viene eseguita quando il ciclo termina per esaurimento della lista (con for)
o quando la condizione diventa falsa (con while), ma non quando il ciclo terminato da un'istruzione
break. Ci esemplificato nel ciclo seguente, che ricerca numeri primi:
>>>forninrange(2,10):
...forxinrange(2,n):
...ifn%x==0:
...print(n,'uguale',x,'*',n//x)
...break
...else:
...#ilcicloterminasenzaavertrovatounfattore
...print(n,'unnumeroprimo')
...
2unnumeroprimo
3unnumeroprimo
4uguale2*2
5unnumeroprimo
6uguale2*3
7unnumeroprimo
8uguale2*4
9uguale3*3
S, questo il codice corretto guardate con attenzione... La clausola else appartiene al ciclo for, non
l'istruzione if).
Quando viene utilizzato con un ciclo, la clausola else assomiglia pi alla clausola else di un'istruzione
try di quanto non faccia quella dell'istruzione if: La clausola else di un'istruzione try viene eseguita
quando non si verifica alcuna eccezione, e la clausola else di un ciclo viene eseguita quando si verifica
nessun break . Per maggiori informazioni su try e le eccezioni, vedere:
Handling Exceptions.
La dichiarazione continue, anch'essa presa in prestito dal C, continua con la prossima iterazione del
ciclo:
>>>fornuminrange(2,10):
...ifnum%2==0:
...print("Trovatounnumeropari",num)
...continue
...print("Trovatounnumero",num)
Trovatounnumeronumeropari2
Trovatounnumero3
Trovatounnumeronumeropari4
Trovatounnumero5
Trovatounnumeronumeropari6
Trovatounnumero7
Trovatounnumeronumeropari8

Trovatounnumero9

4.5. L'Istruzione pass.

L'istruzione pass non fa nulla. Pu essere utilizzata quando richiesta una dichiarazione sintatticamente
corretta ma il programma non richiede alcuna azione. Per esempio:
>>>whileTrue:
...pass#Entrainuncicloinfinitodainterromperecon
(Ctrl+C)
...
Questa istruzione, viene usata tipicamente per creare classi minimali da gestire successivamente:
>>>classMiaClasseVuota:
...pass
...
Un altro modo di utilizzare pass, come segnaposto per una funzione o di un blocco condizionale
quando si lavora su del nuovo codice, che consente di gestire il codice pensando ad un livello pi astratto.
L'istruzione pass viene ignorata senza generare alcun che:
>>>deflog_iniziale(*args):
...pass#Ricordarsid'implementarequalcosaqui!
...

4.6. Definizioni Di Funzioni.

Abbiamo visto precedentemente come implementare del codice per ottenere una sequenza di Fibonacci.
Possiamo ora invece creare una funzione fino ad un limite arbitrario da poter utilizzare ovunque possa
servire senza dover riscriverla:
>>>deffib(n):#scriveunasequenzaFibonaccifinoan
..."""stampaunalistacontenentelaserieFibonaccifinoan"""
...a,b=0,1
...whilea<n:
...print(a,end='')
...a,b=b,a+b
...print()
...
>>>#Orachiamiamolanostrafunzione:
...fib(2000)
011235813213455891442333776109871597

La parola chiave def introduce una definizione di funzione. Essa deve essere seguita dal nome della
funzione e l'elenco tra parentesi dei parametri formali che se sono in numero maggiore di uno, devono
essere separati da virgole.. Le dichiarazioni che formano il corpo della funzione iniziano alla riga
successiva, e devono essere identate.
La prima istruzione del corpo della funzione pu opzionalmente essere una stringa letterale, questa stringa
la stringa di documentazione della funzione o docstring. (Ulteriori informazioni su docstring si trovano
nella documentazione Documentation Strings). Python possiede degli strumenti per la creazione di
documentazione che usano le docstring per produrre automaticamente documentazione in linea o
stampata, o per permettere all'utente una navigazione interattiva attraverso il codice: buona pratica
includere docstring nel codice che si scrive, in modo da prendere l'abitudine ad usarla.
L'esecuzione di una funzione introduce ad una nuova classificazione delle variabili in questo caso locali
alla funzione. Pi precisamente, tutte le assegnazioni di variabili della funzione, vengono memorizzate in
una tabella locale propria della funzione dei simboli locali; quando ci si riferisce ad una variabile, Python
prima guarda dentro questa tabella, poi nelle tabelle dei simboli locali di funzioni che la racchiudono a
sua volte (se esiste), poi nella tabella dei simboli globale, e infine nella tabella di nomi precostituiti.
Pertanto, le variabili globali non possono essere assegnate direttamente ad un valore all'interno di una
funzione (a meno che non denominato in una dichiarazione globale), anche se possono essere referenziate.
I parametri (argomenti) di una chiamata a una funzione vengono introdotti nella tabella dei simboli locale
della funzione chiamata quando essa viene invocata, quindi, gli argomenti sono passati usando una
chiamata per valore (dove il valore sempre un riferimento a un oggetto, non il valore dell'oggetto). [1]
Quando una funzione chiama un'altra funzione, viene creata una nuova tabella locale dei simboli per tale
chiamata e via via cos.
Una definizione di funzione introduce il nome della funzione nella tabella dei simboli corrente. Il valore
del nome della funzione ha un tipo riconosciuto dall'interprete come funzione definita dall'utente. Questo
valore pu essere assegnato ad un altro nome che pu quindi essere utilizzato come funzione. Questo
serve come un meccanismo generale di ridenominazione:
>>>fib
<functionfibat10042ed0>
>>>f=fib
>>>f(100)
01123581321345589
Provenendo da altri linguaggi,, si potrebbe obiettare che fib non una funzione, ma una procedura in
quanto non restituisce un valore. Va ricordato che Python sinteticamente semplifica la stesura del codice
eliminando molti degli orpelli che altri linguaggi hanno! In realt, anche le funzioni senza istruzione
return restituiscono un valore. Questo valore chiamato None ( un nome predefinito). La scrittura
del valore None di norma soppressa dall'interprete se fosse l'unico valore scritto. Lo si pu vedere se
davvero si vuole usando print():
>>>fib(0)
>>>print(fib(0))
None

E 'semplice scrivere una funzione che restituisce un elenco dei numeri della serie di Fibonacci, invece di
stamparli:
>>>deffib2(n):#scriveunasequenzaFibonaccifinoan
..."""stampaunalistacontenentelaserieFibonaccifinoan"""
...risultato=[]
...a,b=0,1
...whilea<n:
...risultato.append(a)#vedisotto
...a,b=b,a+b
...returnrisultato
...
>>>f100=fib2(100)#lachiama
>>>f100#scriveilrisultato
[0,1,1,2,3,5,8,13,21,34,55,89]
Questo esempio, come al solito, mette in luce alcune nuove funzionalit di Python:

L'istruzione return restituisce un valore da una funzione. return senza argomenti espressione,
restituisce None. Anche il fallimento di una funzione restituisce None.

L'istruzione risultato.append(a) chiama un metodo dall'elenco dell'oggetto

risultato. Un metodo una funzione che 'appartiene' ad un oggetto ed denominato
obj.NomeMetodo, dove obj un qualche oggetto (pu essere un'espressione), e
NomeMetodo il nome di un metodo che viene definito dal tipo di oggetto. Diversi tipi
definiscono metodi diversi. Metodi di tipi diversi possono avere lo stesso nome senza causare
ambiguit. (E 'possibile definire i propri tipi e metodi degli oggetti, utilizzando le classi, vedere
Classes) Il metodo append() mostrato nell'esempio definito per gli oggetti lista, aggiunge un
nuovo elemento alla fine della lista. In questo esempio equivalente a risultato =
risultato + [a], ma pi efficiente.

4.7. Ancora Sulla Definizione Di Funzioni.

E 'anche possibile definire funzioni con un numero variabile di argomenti. Ci sono tre forme, che possono
essere combinate:

4.7.1. Valori Argomenti Predefiniti.

La forma pi utile specificare un valore predefinito per uno o pi argomenti. Questo crea una funzione
che pu essere chiamata con un numero di argomenti definiti per interagire con essa. Per esempio:
defquesito(prompt,tentativi=4,conferma='Siono,prego!'):
whileTrue:
ok=input(prompt)
ifokin('S','Si','s','si'):
returnTrue
ifokin('n','no','N','NO'):
returnFalse

tentativi=tentativi1
iftentativi<0:
raiseIOError('refusenikuser')
print(conferma)
Questa funzione pu essere richiamata in diversi modi:
dando solo l'argomento obbligatorio: quesito('Vuoi davvero uscire?')
dando uno degli argomenti opzionali: quesito('? OK per sovrascrivere il file', 2)
o anche dando tutti gli argomenti: quesito('? OK per sovrascrivere il file', 2, 'Ok, solo s o no')
Questo esempio introduce anche la parola chiave in. Questa verifica se una sequenza contiene un certo
valore.
I valori predefiniti vengono valutati al momento della definizione nella funzione nell'ambito definito, in
modo che:
i=5
deff(arg=i):
print(arg)
i=6
f()
Stamper5.
Avvertenza importante: Il valore predefinito, viene valutato solo una volta. Questo fa differenza quando
il valore predefinito un oggetto mutabile come una lista, un dizionario o istanze nella maggior parte
delle classi. Ad esempio, la seguente funzione accumula gli argomenti ad essa passati in chiamate
successive:
deff(a,L=[]):
L.append(a)
returnL
print(f(1))
print(f(2))
print(f(3))
Verrstampatoquesto:
[1]
[1,2]
[1,2,3]
Se non si desidera che il valore predefinito sia condiviso tra chiamate successive, possibile scrivere la
funzione in questo modo:
deff(a,L=None):
ifLisNone:
L=[]
L.append(a)

returnL

4.7.2. Argomenti Chiave.

Le funzioni possono essere chiamate anche usando keyword arguments cio gli argomenti chiave nella
forma ArgChiave=valore. Per esempio, la seguente funzione :
defmotore(volts,stato='fermo',azione='gira',tipo='sincrono'):
print(questomotorenonfarebbe,azione,end='')
print(Seimmetti,volts,aimorsetti.)
print(nonmoltousatoilmotore,tipo)
print(,stato,!)
accetta un argomento obbligatorio (volts) e tre argomenti opzionali (stato, azione, e tipo).
Questa funzione pu essere chiamata in uno dei seguenti modi:
motore(1000)
#1argomentoposizionale
motore(volts=1000)
#1chiaveconargomento
motore(volts=1000000,azione='brucia') #2chiaviconargomento
motore(azione='brucia',volts=1000000) #2chiaviconargomento
motore('unmilione','morto','fermo')#3argomentiposizionali
motore('mille',stato='fuma')
#1posizionale,1chiave
invece tutte queste chiamate non sarebbero valide:
motore()
motore(volts=75.0,'morto')
motore(110,volts=220)
motore(colore='giallo')

#argomentorichiestoomesso
#argomentosenzachiave
#valoreargomentoduplicato
#argomentochiaveinesistente

In una chiamata alle funzioni, gli argomenti chiave devono seguire argomenti posizionali. Tutti gli
argomenti chiave passati, devono corrispondere ad uno degli argomenti accettati dalla funzione e il loro
ordine non importante ad esempio, colore non un argomento valido per la funzione motore.
Questo include anche argomenti non opzionali. Nessun argomento pu ricevere pi di un valore alla volta.
Ecco un esempio che non funziona a causa di questa restrizione:
>>>deffunction(a):
...pass
...
>>>function(0,a=0)
Traceback(mostrecentcalllast):
File"<stdin>",line1,in?
TypeError:function()gotmultiplevaluesforkeywordargument'a'
Quando un parametro formale finale nella forma **nome presente, esso riceve un dizionario (vedere
Mapping Types dict) contenente tutti gli argomenti-chiave, ad eccezione di quelle corrispondenti al
parametro formale. Questo pu essere combinato con un parametro nella forma *nome (descritto nella
prossima sezione) che riceve una tupla contenente gli argomenti posizionali oltre la lista dei parametri

formali. (*nome deve venire prima di **nome) Ad esempio, se si definisce una funzione come questa:
defformaggi(tipo,*argomenti,**chiavi):
print(Avetedel,tipo,?)
print(Midispiace,finitoil,tipo)
forarginargomenti:
print(arg)
print(*40)
chiavi=sorted(chiavi.keys())
forChinkeys:
print(Ch,:,chiavi[Ch])

Si potrebbe definire cos:

formaggi(Limburger,veramentecremoso,signore.,
veramente,veramentecremoso,signore.,
negoziante=Filippo,
cliente=Arturo
scena=Negoziodiformaggi)
che stamperebbe:
AvetedelLimburger?
Midispiace,finitoilLimburger
veramentecremoso,signore.
veramente,veramentecremoso,signore.

cliente:Arturo
negoziante:Filippo
scena:Negoziodiformaggi
Si noti che l'elenco dei nomi degli argomenti-chiave, viene creato ordinando il risultato con il metodo
sorted(). Se questo metodo non viene utilizzato,il suo contenuto, sar restituito in modo indefinito.

4.7.3. Liste di argomenti arbitrari.

Infine, l'opzione utilizzata meno frequentemente quella di specificare che una funzione pu essere
chiamata con un numero arbitrario di argomenti. Questi argomenti dovranno essere incapsulati in una
tupla (vedi Tuples and Sequences). Prima del numero variabile di argomenti, possono esservi o nessuno
o pi argomenti normali.
defscrittura_argomenti_multipli(file,separatore,*args):
file.write(separatore.join(args))
Normalmente, questo tipo di argomenti variabili saranno gli ultimi nella lista dei parametri formali,
perch vanno in profondit nidificata su tutti gli argomenti di input rimanenti che vengono passati alla
funzione. Tutti i parametri formali che si verificano dopo il parametro *args sono solo argomenti passati
come parole-chiave , il che significa che possono essere usati solo come parole chiave piuttosto che

argomenti posizionali.
>>>defconcatena(*args,sep="/"):
...returnsep.join(args)
...
>>>concatena("terra","marte","venere")
'terra/marte/venere'
>>>concatena("terra","marte","venere",sep=".")
'terra.marte.venere'

4.7.4. Scompattamento degli elenchi di argomenti.

La situazione inversa si verifica quando gli argomenti sono gi in una lista o in una tupla, ma hanno
bisogno di essere estratti per una chiamata di funzione che richiede argomenti posizionali separati. Per
esempio, la funzione range() si aspetta start e stop come argomenti separati. Se non sono disponibili
separatamente, scrivete la chiamata di funzione con l'operatore * per scompattare gli argomenti di una
lista o di una tupla:
>>>list(range(3,6))#normalechiamataconargomentiseparati
[3,4,5]
>>>args=[3,6]
>>>list(range(*args))#chiamataconargomentiscompattatidalista
[3,4,5]
Allo stesso modo, i dizionari sono in grado di fornire argomenti chiave con l'operatore **:
defmotore(volts,stato='fermo',azione='morto',tipo='sincrono'):
...print("Questomotorenonfarebbe",azione,end='')
...print("seimmetti",volts,"volts.",end='')
...print("sarebbe",stato,"!")
...
>>>d={"volts":"quattromila","stato":"morto","azione":"VOOM"}
>>>motore(**d)
QuestomotorenonfarebbeVOOMseimmettiquattromilavolts.
Sarebbemorto!

4.7.5. Espressioni Lambda.

Delle piccole funzioni anonime possono essere create con la parola chiave lambda. Questa funzionalit,
restituisce la somma dei suoi due argomenti: lambda a, b: a+b. Le funzioni lambda possono essere
usate ovunque siano richiesti dalle funzioni sugli oggetti. Esse sono sintatticamente limitate ad una
singola espressione. Semanticamente, sono solo zucchero sintattico per una definizione di funzione
normale. Come le definizioni di funzioni annidate, le funzioni lambda possono riferirsi a variabili il cui
campo contenuto:
>>>defincrementatore(n):
...returnlambdax:x+n

...
>>>f=incrementatore(42)
>>>f(0)
42
>>>f(1)
43
C precedente utilizza un'espressione lambda per restituire una funzione. Un altro utilizzo quello di
passare una piccola funzione come argomento:
>>>coppia=[(1,'uno'),(2,'due'),(3,'tre'),(4,'quattro')]
>>>coppia.sort(key=lambdacoppia:coppia[1])
>>>coppia
[(2,'due'),(3,'tre'),(4,'quattro'),(1,'uno')]
Nota del traduttore:
Questo argomento, non trattato in modo esaustivo e/o chiaro nella guida originale. Per cui non essendo
in grado di tradurla e spiegarla in maniera ampia, mi rimetto alla mera traduzione. Comunque in una
eventuale prossima release di questa guida, mi riservo di spiegarlo in modo pi chiaro aggiungendovi
concetti ed esempi.

4.7.6. Stringhe di documentazione.

In questo paragrafo, tratteremo un' argomento gi accennato all'inizio della guida e cio la
documentazione. Questa che pu sembrare una cosa di scarso valore pratico (infatti spesso trascurata dal
programmatore), invece una risorsa preziosa in quanto permette a chiunque di capire cosa stato fatto,
ma soprattutto permette a noi stessi di capire cosa abbiamo scritto magari solo alcuni mesi fa. A chi non
capitato di avere difficolt a leggere il nostro stesso codice? Inoltre questa pratica, se ben fatta consente di
avere praticamente una guida del programma da consultare. Passiamo ora a le convenzioni usate.

La prima riga deve sempre essere una orientata alla finalit dell'oggetto. Per brevit, si intende che
non deve indicare esplicitamente il nome o il tipo di oggetto, dal momento che queste informazioni
sono disponibili con altri mezzi (tranne se il nome sembra essere un verbo che descrive il
funzionamento di una funzione). Questa linea dovrebbe iniziare con una lettera maiuscola e
terminare con un punto.
Se vi sono pi righe nella stringa documentazione, la seconda dovrebbe essere vuota, per separare
visivamente il sommario dal resto della descrizione.
Le seguenti righe devono essere uno o pi paragrafi che descrivono le convenzioni di chiamata
dell'oggetto, i suoi effetti collaterali, e quant'altro.

Il parser di Python cio quello strumento facente parte dell'interprete che si occupa di capire cosa
abbiamo scritto e se lo abbiamo scritto bene, non toglie le identazioni dalle stringhe letterali, in modo che
gli strumenti che si occupano della documentazione possano o meno identare a seconda che lo si desideri
o no. Questo viene reso possibile utilizzando la seguente convenzione:

La prima riga non vuota dopo la prima riga della stringa determina la quantit di rientro per
l'intera stringa di documentazione. (Non possiamo usare la prima linea dal momento che

generalmente adiacente all'apertura delle virgolette della stringa per cui il suo rientro non sarebbe
evidente.) Gli spazi "equivalenti" a tale indentazione vengono poi tolti dall'inizio di tutte le linee
della stringa.
Linee non identate correttamente, non dovrebbero esserci, ma se ci si verificasse, tutti i loro spazi
principali dovrebbero essere tolti.
L'equivalenza degli spazi dovrebbe essere testata dopo l'applicazione delle tabulazioni (a 8 spazi,
normalmente).

Ecco un' esempio di documentazione multi linea:

>>>defmia_funzione():
..."""Nonfanulla,madocumentata.
...
...No,nonfanulladavvero!
..."""
...pass
...
>>>print(mia_funzione.__doc__)
Nonfanulla,madocumentata
No,nonfanulladavvero!

4.7.7. Annotazioni di Funzioni.

Le annotazioni sulle funzioni (Function annotations), sono cose per pignoli. I meta-dati definiti
dall'utente sono completamente opzionali e di carattere arbitrario. N Python al suo interno, n librerie
esistenti usano per le annotazioni funzionali come uno standard per qualsiasi uso. Questa sezione ne
mostra solo la sintassi, per cui progetti sviluppati di altre persone sono liberi di utilizzare annotazioni alle
funzioni per la propria documentazione come meglio credono.
Le annotazioni di una funzione, sono memorizzate nel attributo __annotations__ come un
dizionario e non hanno nessun effetto operativo sulla funzione. I parametri di annotazione, sono definiti
da due punti dopo il nome del parametro, seguito da una valutazione di espressione per il valore
dell'annotazione. Esse sono definite da un letterale ' ->' seguita da un'espressione tra la lista dei parametri
e i due punti che denota la fine dell'istruzione def(). L'esempio seguente ha un argomento posizionale,
un argomento chiave, e il valore di ritorno annotato con cose senza senso:
>>>deff(prosciutto:42,uova:int='spam')>"Nientedavedere
qui":
...print("Annotazioni:",f.__annotations__)
...print("Argomenti:",prosciutto,uova)
...
>>>f('Stupendo')
Annotazioni:{'prosciutto':42,'return':'Nientedavederequi',
'uova':<class'int'>}
Argomenti:Stupendospam

4.8. Intermezzo: Stile di Codifica.

Ora che siamo pronti per la scrittura di codice serio e quindi pi lungo, giunto il momento di parlare di
stili di codifica. La maggior parte dei linguaggi permettono una codifica del codice abbastanza arbitraria
per cui il risultato quello di una moltitudine di stili pi o meno eleganti, pi o meno leggibili ma
comunque personalizzati. Questo produce diversi modi di codificare e addirittura diverse scuole di
pensiero. Rendere pi facile la lettura del codice agli altri e anche a se stessi sempre una buona idea!
Quindi l'adozione di un buon stile di codifica, indispensabile in quanto aiuta moltissimo.
Per Python, dal documento PEP 8 emerso come sia importante aderire allo stile di guida nella maggior
parte dei progetti al fine di promuove uno stile di codifica molto leggibile e piacevole per gli occhi. Ogni
sviluppatore Python ad un certo punto deve leggere il suo o l'altrui codice. Qui di seguito ci sono gli stili
pi importanti estratti per voi:

Usare un' identazione di 4 spazi senza l'uso del tabulatore.

4 spazi sono un buon compromesso tra la piccola identazione (2 spazi) che consente maggiore
profondit di annidamento) e la grande identazione (8 spazi) pi facile da leggere. La tabulazione,
introduce solo confusione, meglio non adoperarla.
Incapsulare le linee in modo che non superino 79 caratteri.
Questo aiuta gli utenti che hanno display di piccole dimensioni e viceversa consente di avere pi
file di codice a chi possiede schermi pi grandi.
Utilizzare righe vuote per separare le funzioni e le classi e grossi blocchi di codice all'interno di
funzioni.
Quando possibile, inserire commenti su una linea propria.
Utilizzare docstrings.
Usare spazi fra gli operatori e dopo le virgole, ma non direttamente all'interno di costrutti fra
parentesi: a = f(1,2) + g(3,4).
Date un nome coerente alle vostre classi e funzioni, la convenzione quella di utilizzare la cosi
detta 'CamelCase' per le classi e lettere_minuscole_con_sottolineatura per
funzioni e metodi. Utilizzare sempre s stesso come nome per il primo argomento del metodo
(vedere A First Look at Classes ).
Non utilizzare codifiche fantasiose se il codice pensato per essere utilizzato in ambienti
internazionali. In maniera predefinita Python, usa UTF-8, ma la codifica ASCII va bene in ogni
caso ed pi capibile.
Per lo stesso motivo, non utilizzare caratteri non-ASCII in identificatori. Se chi dovr leggere il
codice appartiene ad un'altra lingua non avr difficolt a leggerlo e a modificarlo.

Note:
[1] In realt, la chiamata per riferimento all'oggetto sarebbe una descrizione migliore, dato che se viene
passato un oggetto mutabile, il chiamante vedr le eventuali modifiche fatte ad esso (gli elementi
inseriti in una lista).

5. Strutture di Dati.
Questo capitolo descrive alcune cose che sono gi state affrontate precedentemente ma in modo pi
dettagliato, e aggiunge anche alcune nuove cose.

5.1. Approfondimento Sulle Liste.

Il tipo di dati lista ha alcuni altri metodi oltre a quelli gi visti. Ecco tutti i metodi degli oggetti lista:
list.append(x)
Aggiunge un' elemento alla fine della lista. Equivale a: a[len(a):] = [x].
list.extend(L)
Amplia la lista aggiungendo tutti gli elementi della lista data. Equivale a a[len(a):] = L.
list.insert(i,x)
Inserisce un oggetto in una data posizione. Il primo argomento l'indice dell'elemento davanti al
quale inserire, cos che a.insert(0,x) inserisce nella parte anteriore della lista, e
a.insert(len(a),x). Equivale a a.append(x).
list.remove(x)
Rimuovere il primo elemento della lista il cui elemento x. Nel caso in cui vi siano pi elementi identici,
viene rimosso il primo. Si ha un'errore se non tale elemento non esiste..
list.pop([i])
Rimuovere la voce nella lista nella posizione indicata, e lo restituisce. Se non viene specificato alcun
indice, a.pop() rimuove e restituisce l'ultimo elemento della lista. (Le parentesi quadre intorno la i
nell'esempio su fatto, indicano che il parametro opzionale, non che necessario digitare le
parentesi quadre in quella posizione). Vedrete questa notazione frequentemente nella Python Library
Reference).
list.clear()
Rimuove tutti gli elementi dalla lista. Equivale a del a[:].
list.index(x)
Restituisce l'indice nella lista del primo elemento il cui valore x. Se l'elemento specificato in x non esiste
allora viene generato un'errore.
list.count(x)
Restituisce il numero di volte che x compare nella lista.
list.sort()

Ordina gli elementi della lista.

list.reverse()
Rovescia l'ordine degli elementi della lista.
list.copy()
Restituisce una copia superficiale della lista. Equivale a a[:].
Ecco un' esempio che utilizza la maggior parte dei metodi delle liste:
>>>a=[66.25,333,333,1,1234.5]
>>>print(a.count(333),a.count(66.25),a.count('x'))
210
>>>a.insert(2,1)
>>>a.append(333)
>>>a
[66.25,333,1,333,1,1234.5,333]
>>>a.index(333)
1
>>>a.remove(333)
>>>a
[66.25,1,333,1,1234.5,333]
>>>a.reverse()
>>>a
[333,1234.5,1,333,1,66.25]
>>>a.sort()
>>>a
[1,1,66.25,333,333,1234.5]
Potreste aver notato che metodi tipo insert, remove o sort non restituiscono valori ma solo None
[1] Questo un principio di progettazione per tutte le strutture dati mutabili in Python.

5.1.1. Utilizzo Delle Liste Come Pile.

I metodi delle liste rendono molto facile utilizzare una lista come una pila, dove l'ultimo elemento
aggiunto il primo elemento recuperato ("last-in, first-out"). Per aggiungere un elemento in fondo alla
pila, utilizzare append(). Per recuperare un elemento dal fondo della pila, utilizzare pop() senza un
indice esplicito. Per esempio:
>>>stack=[3,4,5]
>>>stack.append(6)
>>>stack.append(7)
>>>stack
[3,4,5,6,7]
>>>stack.pop()
7
>>>stack
[3,4,5,6]

>>>stack.pop()
6
>>>stack.pop()
5
>>>stack
[3,4]

5.1.2. Uso Delle Liste e Delle Code.

anche possibile utilizzare un elenco come coda, dove il primo elemento aggiunto il primo ad essere
prelevato ("first-in, first-out"), tuttavia, le liste non sono efficaci per questo scopo. Mentre l'accodamento
e il prelevamento dal basso sono veloci, fare inserimenti o prelevamenti dall'inizio di una lista risulta
lento perch tutti gli altri elementi devono essere spostati uno ad uno.
Per implementare una coda, possibile usare collections.deque che stato progettato per avere
accodamenti e prelevamenti veloci da entrambe le estremit. Per esempio:
>>>fromcollectionsimportdeque
>>>coda=deque(["Enrico","Gianni","Michele"])
>>>coda.append("Aldo")#Aldoaggiunto
>>>coda.append("Stefano")#Stefanoaggiunto
>>>coda.popleft()#ilprimooraesce
'Enrico'
>>>coda.popleft()#oraesceilsecondo
'Gianni'
>>>coda#chirimaneinordinearrivo
deque(['Michele','Aldo','Stefano'])

5.1.3. Comprensioni Di Lista.

Le comprensioni di lista forniscono un modo conciso per creare liste. Le applicazioni pi comuni sono per
fare nuovi elenchi in cui ogni elemento il risultato di alcune operazioni applicate a ciascun membro di
un'altra sequenza o iterabile, o per creare una sotto sequenza di quegli elementi che soddisfano una
determinata condizione.
Ad esempio, supponiamo di voler creare un elenco di quadrati come:
>>>quadrati=[]
>>>forxinrange(10):
...quadrati.append(x**2)
...
>>>quadrati
[0,1,4,9,16,25,36,49,64,81]
E' possibile ottenere lo stesso risultato con:
quadrati=[x**2forxinrange(10)]

Che ' anche l'equivalente di quadrati = list(map(lambda x: x**2, range(10))), ma

pi conciso e pi leggibile.
Un comprensione di lista, compone i tasselli che contengono un'espressione seguita da una clausola for,
quindi nessuna o pi clausole for o if. Il risultato sar un nuovo elenco risultante dalla valutazione
dell'espressione nel contesto delle clausole for e if che seguono. Ad esempio, questo esempio, combina
gli elementi di due liste se non sono uguali:
>>>[(x,y)forxin[1,2,3]foryin[3,1,4]ifx!=y]
[(1,3),(1,4),(2,3),(2,1),(2,4),(3,1),(3,4)]
Ed esso equivalente a:
>>>combs=[]
>>>forxin[1,2,3]:
...foryin[3,1,4]:
...ifx!=y:
...combs.append((x,y))
...
>>>combs
[(1,3),(1,4),(2,3),(2,1),(2,4),(3,1),(3,4)]
Notate come l'ordine dei for e dell' if sia lo stesso in entrambi gli esempi.
Se l'espressione una tupla (ad esempio (x, y) nell'esempio precedente), esso deve essere racchiuso fra
parentesi.
>>>vec=[4,2,0,2,4]
>>>#creaunanuovalistaconivaloriraddoppiati.
>>>[x*2forxinvec]
[8,4,0,4,8]
>>>#Filtralalistaperescludereivalorinegativi.
>>>[xforxinvecifx>=0]
[0,2,4]
>>>#assegnaallafunzionetuttiglielementi.
>>>[abs(x)forxinvec]
[4,2,0,2,4]
>>>#chiamaunmetodoperognielemento.
>>>fruttafresca=['banana','more','passiflora']
>>>[weapon.strip()forweaponinfruttafresca]
['banana','more','passiflora']
>>>#creaunalistadi2tuplestipo(numero,quadrato).
>>>[(x,x**2)forxinrange(6)]
[(0,0),(1,1),(2,4),(3,9),(4,16),(5,25)]
>>>#letuple,devonoesserefraparentesi,altrimentisihaerrore.
>>>[x,x**2forxinrange(6)]
File"<stdin>",line1,in?
[x,x**2forxinrange(6)]
^
SyntaxError:invalidsyntax

>>>#flattenalistusingalistcompwithtwo'for'
>>>vec=[[1,2,3],[4,5,6],[7,8,9]]
>>>[numforeleminvecfornuminelem]
[1,2,3,4,5,6,7,8,9]
Una comprensione di lista, pu contenere espressioni complesse e funzioni nidificate:
>>>frommathimportpi
>>>[str(round(pi,i))foriinrange(1,6)]
['3.1','3.14','3.142','3.1416','3.14159']

5.1.4. Comprensioni Di Lista Nidificate.

L'espressione iniziale in un elenco di comprensione pu essere qualsiasi espressione arbitraria, tra cui un
altro elenco di comprensione.
Si consideri il seguente esempio di una matrice 3x4 implementato come una lista di 3 liste di lunghezza 4:
>>>matrice=[
...[1,2,3,4],
...[5,6,7,8],
...[9,10,11,12],
...]
La seguente lista di comprensione trasporr righe e colonne:
>>>[[riga[i]forrigainmatrice]foriinintervallo(4)]
[[1,5,9],[2,6,10],[3,7,11],[4,8,12]]
Come abbiamo visto nella sezione precedente, la lista di comprensione nidificata viene valutata nel
contesto del for che lo segue, quindi questo esempio equivalente a:
>>>trasposto=[]
>>>foriinintervallo(4):
...trasposto.append([riga[i]forrigainmatrice])
...
>>>trasposto
[[1,5,9],[2,6,10],[3,7,11],[4,8,12]]
Che a sua volta equivale a:
>>>trasposto=[]
>>>foriinintervallo(4):
...#le3lineeseguentiimplementanolalistcompnidificata
...trasposto_riga=[]
...forrigainmatrice:

...trasposto_riga.append(riga[i])
...trasposto.append(trasposto_riga)
...
>>>trasposto
[[1,5,9],[2,6,10],[3,7,11],[4,8,12]]
Nella pratica, si dovrebbero preferire funzioni precostituite per situazioni complesse. La funzione zip()
per esempio fa un grande lavoro in questa situazione riducendo inoltre la possibilit di errore:
>>>list(zip(*matrice))
[(1,5,9),(2,6,10),(3,7,11),(4,8,12)]
vedere anche Unpacking Argument Lists per maggiori dettagli sull'asterisco della prima linea.

5.2. L'Istruzione del.

C' un modo per rimuovere un elemento da un elenco dato il suo indice invece del suo valore: usando
l'istruzione del . Questa differisce dal metodo pop(), che restituisce un valore. L'istruzione del pu
anche essere usata per rimuovere gruppi da un elenco o cancellare l'intero elenco (che precedentemente
abbiamo ottenuto assegnando una lista vuota al gruppo). Per esempio:
>>>a=[1,1,66.25,333,333,1234.5]
>>>dela[0]
>>>a
[1,66.25,333,333,1234.5]
>>>dela[2:4]
>>>a
[1,66.25,1234.5]
>>>dela[:]
>>>a
[]
del inoltre, pu essere usata per cancellare intere variabili:
>>>dela
Riferirsi ad a se a non esiste genera un'errore (almeno fino a quando un altro valore viene assegnato ad
esso). Troveremo altri usi di del successivamente.

5.3. Tuple e Sequenze.

Abbiamo visto come le liste e le stringhe hanno molte caratteristiche comuni, come le operazioni di
indicizzazione e suddivisione che sono due esempi sui tipi di dati sequenziali (vedere Sequence Types
list, tuple, range). Dal momento che Python un linguaggio in evoluzione, possono essere aggiunti altri
tipi di dati sequenziali. Ma a completare la richiesta, esiste un' altro tipo di dati sequenziale: la tupla. Essa
condivide le caratteristiche tipiche delle liste e delle stringhe, ma a differenza di loro la tupla non pu
essere modificata.

Per instanziare una tupla, basta assegnare una serie di valori separati da una virgola:
>>>t=12345,54321,'salve!'
>>>t[0]
12345
>>>t
(12345,54321,'salve!')
>>>#letuplepossonoesserenidificate:
...u=t,(1,2,3,4,5)
>>>u
((12345,54321,'salve!'),(1,2,3,4,5))
>>>#letuplesonoimmutabili:
...t[0]=88888
Traceback(mostrecentcalllast):
File"<stdin>",line1,in<module>
TypeError:'tuple'objectdoesnotsupportitemassignment
>>>#buttheycancontainmutableobjects:
...v=([1,2,3],[3,2,1])
>>>v
([1,2,3],[3,2,1])
Come si pu notare, la stampa delle tuple viene sempre rappresentata fra parentesi tonde, questo per fare
in modo che si possano interpretare meglio eventuali tuple annidate. Le tuple possono essere create anche
senza le parentesi tonde anche se spesso sono necessarie in processi pi complessi. Non possibile fare
assegnamenti ai singoli elementi di una tupla, tuttavia possibile creare tuple che contengono oggetti
mutabili, come le liste (veramente potente).
Sebbene le tuple possono sembrare simili alle liste, sono spesso utilizzate in situazioni diverse e per scopi
diversi. Le tuple sono immutable (immutabili), e di solito contengono una sequenza eterogenea di
elementi a cui si accede tramite l'estrazione (vedere pi avanti in questa sezione) o d'indicizzazione (o
anche l'attributo nel caso di namedtuples). Le liste sono mutable (mutabili), e i loro elementi di solito
sono omogenei e sono accessibili scorrendo l'elenco.
Un problema particolare la costruzione di tuple contenenti 0 o 1 elementi: la sintassi contiene alcune
stranezze. Tuple vuote vengono costruite usando una coppia vuota di parentesi; una tupla con un elemento
costruita seguendo un valore con una virgola (non sufficiente a racchiudere un singolo valore tra
parentesi). Brutto, ma efficace. Per esempio:
>>>vuota=()
>>>singola='salve',#notarelavirgolaalseguito.
>>>len(vuota)
0
>>>len(singola)
1
>>>singola
('salve',)#riportataancheinfasedistampa.

L'istruzione t = 12345, 54321, 'ciao!' un esempio di impacchettamento di una tupla: i valori

'12345, 54321, 'ciao!'sono riuniti nella tupla. E' anche possibile l'operazione inversa:
>>>x,y,z=t
Questo si chiama, in modo abbastanza appropriato, sequenza di spacchettamento e funziona per qualsiasi
sequenza sul lato destro. La sequenza di spacchettamento, richiede che vi siano altrttante variabili sul lato
sinistro del segno uguale (=) per gli elementi della sequenza. Si noti che l'assegnazione multipla in realt
solo una combinazione di impacchettamento su tupla e una sequenza di spacchettamento. La mancanza di
uno o pi elementi a sinistra per lo spacchettamento, provoca un'errore.

5.4. Insiemi o Sets.

Python include anche un tipo di dati per gli insiemi o sets. Un insieme, un gruppo di elementi non
ordinato senza duplicati. Utulizzi di base includono il test per impedire gli elementi duplicati. Gli insiemi
di oggetti supportano anche operazioni matematiche come l'unione, l'intersezione, la differenza, e la
differenza simmetrica.
Le parentesi graffe o la funzione set() possono essere usati per creare insiemi. Nota: per creare un
insieme vuoto si deve usare set(), non {}; quest'ultima crea un dizionario vuoto, una struttura di dati
che discuteremo nella prossima sezione.
Questa una breve dimostrazione:
>>>cestino={'mela','arancia','mela','pera','arancia',
'banana'}
>>>print(cestino)#notarel'assenzadeiduplicati.
{'arancia','banana','pera','mela'}
>>>'arancia'incestino#testvelocedell'elemento.
True
>>>'fragole'incestino
False
>>>#Dimostrazionedell'usodiset().
...
>>>a=set('abracadabra')
>>>b=set('alacazam')
>>>a#lettereunicheina.
{'a','r','b','c','d'}
>>>ab#lettereinamanoninb.
{'r','d','b'}
>>>a|b#letteresiainacheinb.
{'a','c','r','d','b','m','z','l'}
>>>a&b#letteresoloinaeb.
{'a','c'}
>>>a^b#lettereinaobmanonentrambe
{'r','d','b','m','z','l'}
Analogamente alle comprensioni di lista ( list comprehensions)
comprensioni:

sono supportati anche set di

>>>a={xforxin'abracadabra'ifxnotin'abc'}
>>>a
{'r','d'}

5.5. Dizionari.
Un altro tipo di dati molto utile integrato in Python il dizionario (vedere Mapping Types dict). I
dizionari si trovano a volte in altri linguaggi come "memorie associative" o "array associativi". A
differenza delle sequenze, che sono indicizzate da una serie di numeri, i dizionari sono indicizzati da
chiavi, che possono essere di qualsiasi tipo immutabile compreso stringhe e numeri. Le tuple possono
essere usate come chiavi se contengono solo stringhe, numeri o tuple; se una tupla contiene un
qualsivoglia oggetto mutabile direttamente o indirettamente, non pu essere giustamente utilizzato come
una chiave. Non possibile utilizzare le liste come chiavi, dal momento che esse possono essere
modificate usando le assegnazioni a indice, assegnazioni suddivisioni, o metodi come append() e
extend().
E 'meglio pensare a un dizionario come un insieme non ordinato di coppie chiave:valore, con il requisito
che le chiavi sono uniche (all'interno di un dizionario). Una coppia di parentesi graffe crea un dizionario
vuoto: {}. L'inserimento di un elenco di coppie chiave:valore all'interno delle parentesi graffe, viene
effettuato separando i valori usando delle virgole. Questo anche il modo in cui i dizionari sono
visualizzati sullo schermo.
Le operazioni principali su un dizionario sono la memorizzazione di un valore con una qualche chiave e
l'estrazione del valore per mezzo della stessa. E 'anche possibile eliminare una chiave:valore con del. Se
si memorizza un valore utilizzando una chiave gi in uso, il vecchio valore associato a tale chiave viene
sostituito. Cercare di estrarre un valore utilizzando una chiave inesistente, genera un'errore.
Utilizzare list(d.keys()) su un dizionario, restituisce un elenco di tutte le chiavi usate nel
dizionario, in ordine arbitrario (se invece volete averlo ordinato, basta usare sorted(d.keys())). [2]
Per verificare se una singola chiave presente nel dizionario, utilizzare la parola chiave in.
Ecco un piccolo esempio sull'uso dei dizionari:
>>>tel={'gigi':4098,'nino':4139}
>>>tel['guido']=4127
>>>tel
{'nino':4139,'guido':4127,'gigi':4098}
>>>tel['gigi']
4098
>>>deltel['nino']
>>>tel['ugo']=4127
>>>tel
{'guido':4127,'ugo':4127,'gigi':4098}
>>>list(tel.keys())
['ugo','guido','gigi']
>>>sorted(tel.keys())
['guido','ugo','gigi']

>>>'guido'intel
True
>>>'gigi'notintel
False
L'istruzione dict() costruisce dizionari direttamente da sequenze di coppie chiave-valore:
>>>dict([('nino',4139),('guido',4127),('giacomo',4098)])
{'nino':4139,'giacomo':4098,'guido':4127}
Inoltre, dict comprehensions possono essere usati per creare dizionari da chiavi arbitrarie e valore d'
espressioni:
>>>{x:x**2forxin(2,4,6)}
{2:4,4:16,6:36}
Quando le chiavi sono semplici stringhe, pi facile specificare le coppie che utilizzano argomenti
chiave:
>>>dict(ale=4139,guido=4127,gianni=4098)
{'ale':4139,'gianni':4098,'guido':4127}

5.6. Tecniche di Ciclo.

Il metodo items(), viene utilizzato con un ciclo per scorrere un dizionario per recuperare gli elementi
presenti.
>>>cavalieri={'gallahad':'ilpuro','robin':'ilcoraggioso'}
>>>fork,vincavalieri.items():
...print(k,v)
...
gallahadilpuro
robinilcoraggioso
Iterando in una sequenza, l'indice di posizione e il valore corrispondente possono essere richiamati allo
stesso tempo utilizzando la funzione enumerate().
>>>fori,vinenumerate(['tic','tac','toe']):
...print(i,v)
...
0tic
1tac
2toe
Per un ciclo su due o pi sequenze contemporaneamente, le voci possono essere accoppiate con la

funzione zip().
>>>domanda=['nome','obiettivo','colorepreferito']
>>>risposta=['lancillotto','ilsacrogral','blu']
>>>forq,ainzip(domanda,risposta):
...print('ilvostro{0}?{1}.'.format(q,a))
...
ilvostronome?lancillotto.
ilvostroobiettivo?ilsacrogral.
ilvostrocolorepreferito?blu.
Per un ciclo su una sequenza in senso inverso, prima specificare la sequenza in avanti e poi chiamare la
funzionereversed().
>>>foriinreversed(range(1,10,2)):
...print(i)
...
9
7
5
3
1
Per ordinare con un ciclo una sequenza di dati, utilizzare la funzione sorted(), che restituisce una
nuova lista ordinata lasciando inalterata l'originale.
>>>cestino=['mela','fragole','pera','arancia']
>>>forfinsorted(set(cestino)):
...print(f)
...
arancia
fragole
mela
pera
Per modificare una sequenza si effettua l'iterazione all'interno del ciclo (ad esempio per duplicare alcune
voci), si consiglia di eseguire una copia preventiva. Iterare su una sequenza non implica una copia. La
notazione slice cio suddivisione la rende particolarmente conveniente:
>>>voci=['gatto','finestra','defenestrato']
>>>forwinvoci[:]:#Ciclasuunacopiaslicedell'interalista.
...iflen(w)>6:
...voci.insert(0,w)
...
>>>voci
['defenestrato','finestra','gatto','finestra','defenestrato']

5.7. Approfondimento sulle condizioni.

Le condizioni utilizzate con le dichiarazioni while ed if , possono contenere tutti gli operatori, non
solo quelli di confronto. Gli operatori di confronto in e not, testano se un valore che viene rilevato o no
in una sequenza. Gli operatori is e is not, confrontano se due oggetti sono o no in realt lo stesso
oggetto; questo vale solo per oggetti mutabili, come le liste. Tutti gli operatori di confronto hanno la stessa
priorit, che inferiore a quella di tutti gli operatori numerici.
I confronti possono essere anche concatenati. Ad esempio, a < b == c a minore di b ed inoltre
b sia uguale c.
I confronti possono essere combinati utilizzando gli operatori booleani and e or, e il risultato di un
confronto (o di qualsiasi altra espressione booleana) possono essere negativi con not. Questi hanno
priorit inferiore rispetto a operatori di confronto, tra loro, not ha la priorit pi alta e or la pi bassa,
in modo che A and not B or C equivalente a (A and (not B)) or C. Come sempre,
l'utilizzo di parentesi, consente di ottenere la priorit desiderata.
Gli operatori booleani and e or sono cosiddetti operatori di cortocircuito: i loro argomenti vengono
valutati da sinistra a destra, e la valutazione termina non appena il risultato determinato. Ad esempio, se
A e C sono vere, ma B falsa, A and B and C non sar valutata l'espressione C. Quando viene usato
un valore generale e non uno booleano, il valore di ritorno di un operatore di corto circuito l'ultimo
argomento valutato.
possibile assegnare il risultato di un confronto di altre espressioni booleane a una variabile. Per
esempio:
>>>stringa1,stringa2,stringa3='','Roma','nuovaDely'
>>>no_null=string1orstring2orstring3
>>>no_null
'roma'
Si noti che in Python, a differenza del C, l'assegnazione non pu avvenire all'interno di espressioni. I
programmatori C potrebbero lamentarsi di questo, ma questo evita quel tipo di problemi incontrati nei
programmi in C tipo: digitando = in un'espressione quando invece s'intendeva == .

5.8. Confronto Di Sequenze e Altri Tipi.

Le sequenze di oggetti, possono essere confrontate con altri oggetti con lo stesso tipo di sequenza. Il
confronto utilizza un ordinamento lessicografico: prima i primi due elementi vengono confrontati, e se
questi differiscono ci determina il risultato del confronto, se sono uguali, vengono confrontati i due
elementi successivi, e cos via, fino a quando la sequenza si esaurisce. Se due elementi da confrontare
sono essi stessi sequenze dello stesso tipo, il confronto lessicografico viene effettuato ricorsivamente. Se
tutti gli elementi di due sequenze risultano uguali, le sequenze sono considerate uguali. Se una sequenza
una sotto sequenza iniziale dell'altra, la sequenza pi breve la pi piccola (minore) di uno.
L'ordinamento lessicografico per le stringhe utilizza la codifica Unicode per ordinare i singoli caratteri.
Ecco alcuni esempi di confronti tra sequenze dello stesso tipo:

(1,2,3)<(1,2,4)
[1,2,3]<[1,2,4]
'ABC'<'C'<'Pascal'<'Python'
(1,2,3,4)<(1,2,4)
(1,2)<(1,2,1)
(1,2,3)==(1.0,2.0,3.0)
(1,2,('aa','ab'))<(1,2,('abc','a'),4)
Si noti che il confronto oggetti di diversi tipi con < or > ammesso a condizione che gli oggetti abbiano
adeguati metodi di confronto. Ad esempio, i tipi numerici misti vengono confrontati in base al loro valore
numerico, cos 0 uguale a 0.0, ecc Altrimenti, piuttosto che fornire un ordinamento arbitrario,
l'interprete sollever un'eccezione TypeError.
Note:
[1] Altri linguaggi, possono restituire l'oggetto mutato, che permette il metodo del concatenamento, come
inserire d->insert("a")->remove("b")->sort().
[2] Chiamare d.keys() restituir una vista dell'oggetto dizionario. Esso supporta operazioni come
prova l'adesione e iterazione, ma il suo contenuto non indipendente dal dizionario originale - solo
una vista.

6. Moduli.
Se si esce dall'interprete Python e poi vi si rientra, le definizioni introdotte (funzioni e variabili) vengono
perse. Pertanto, se si vuole scrivere un programma pi lungo, meglio usare un editor di testo per gestire
l'input per l'interprete passandogli il file da eseguire invece dell'input diretto. Questo noto come la
creazione di uno script. Inoltre se il programma si allunga, consigliabile dividerlo in pi file per
facilitarne la manutenzione. Se hai scritto una funzione comoda da utilizzare in pi programmi, si
consiglia di salvarla per poi utilizzarla invece che copiarla ogni volta.
Per fare in modo che ci possa essere fatto, Python ha un modo per gestire il tutto. Da la possibilit di
mettere tutto in un file da richiamarlo poi sia in modo interattivo che all'interno di altri file. Tale file si
chiamano moduli. Le definizioni di un modulo possono essere importate in altri moduli o nel modulo
principale (l'insieme di variabili di cui si ha accesso a in uno script eseguito al livello superiore e in
modalit calcolatrice).
Un modulo praticamente non altro che un file contenente definizioni e istruzioni Python. Il nome del
file il nome del modulo con aggiunto il suffisso .py. All'interno di un modulo, il nome del modulo
(come una stringa) disponibile come valore nella variabile globale __name__. Per esempio, usare il
vostro editor di testo preferito per creare un file chiamato fibo.py nella directory corrente con i
seguenti contenuti e salvatelo:
#ModulonumeridiFibonacci.
deffib(n):#seriedinumeriFibonaccifinoadnstampati.
a,b=0,1
whileb<n:

print(b,end='')
a,b=b,a+b
print()
deffib2(n):#seriedinumeriFibonaccifinoadnrestituiti.
risultato=[]
a,b=0,1
whileb<n:
risultato.append(b)
a,b=b,a+b
returnrisultato
Ora immette dall'interprete Python il seguente comando:
>>>importfibo
Questo non immette i nomi delle funzioni definite in fibo direttamente nella tabella dei simboli
corrente, immette solo il riferimento al modulo fibo. Facendo riferimento a questo modulo, possibile
usare la funzione in esso contenuta.
>>>fibo.fib(1000)
1123581321345589144233377610987
>>>fibo.fib2(100)
[1,1,2,3,5,8,13,21,34,55,89]
>>>fibo.__name__
'fibo'
Notare che la funzione fib, viene richiamata dal modulo fibo con la notazione del punto
(fibo.fib). In effetti il modulo viene tratto in Python come una classe a tutti gli effetti, anzi per essere
pi precisi come un'oggetto. Questo argomento verr ripreso pi avanti in questa guida.
Se avete intenzione di usare spesso una funzione possibile assegnargli un nome locale:
>>>fib=fibo.fib
>>>fib(500)
1123581321345589144233377

6.1. Ancora Sui Moduli.

Un modulo pu contenere istruzioni eseguibili cos come la definizioni di funzione . Queste dichiarazioni
hanno lo scopo di inizializzare il modulo. Esso viene caricato solo all'occorrenza e cio quando un
riferimento ad esso viene esplicitamente richiamato altrimenti c' solo un riferimento ad esso per il suo
eventuale uso. [1] Sono inoltre eseguiti se il file viene eseguito come uno script cio lanciato
direttamente.
Ogni modulo ha la sua tabella dei simboli privata , che usata come tabella dei simboli globale da tutte le
funzioni definite nel modulo . Cos, l'autore di un modulo pu utilizzare le variabili globali nel modulo
senza preoccuparsi di conflitti accidentali con le variabili globali di un' altro utente . D'altra parte , se si sa
cosa si sta facendo possibile gestire le variabili globali di un modulo con la stessa notazione usata per

riferirsi alle sue funzioni, nome_modulo.nome_voce.

.
I moduli possono importare altri moduli. E' una consuetudine, ma non indispensabile mettere tutte le
istruzioni import all'inizio di un modulo (o script per questo contesto). I nomi dei moduli importati
vengono inseriti nella tabella dei simboli globale del modulo di importazione. C' una variante
dell'istruzione import che importa nomi da un modulo direttamente nella tabella dei simboli del modulo di
importazione. Per esempio :
>>>fromfiboimportfib,fib2
>>>fib(500)
1123581321345589144233377
Questo non introduce il nome del modulo dal quale vengono importati nella tabella dei simboli locali
(cos nell'esempio, fibo non definito), ma solo la funzione richiesta. C' inoltre anche una variante per
importare tutti i nomi definiti in un modulo:
>>>fromfiboimport*
>>>fib(500)
1123581321345589144233377
Questo importa tutti i nomi tranne quelli che iniziano con un carattere di sottolineatura (underscore (_)).
Nella maggior parte dei casi i programmatori Python non utilizzano questo strumento in quanto introduce
un insieme sconosciuto di nomi nell'interprete e di probabile non utilizzo nascondendo alcune cose che
sono gi state definite.
Si noti che in generale la pratica di importare con * da un modulo o un pacchetto malvista, dato che
spesso comporta poca leggibilit del codice. Tuttavia, bene usarla per risparmiare digitazioni eccessive
in sessioni interattive.
Note:
Per ragioni di efficienza, ogni modulo viene importato solo una volta per sessione interprete. Pertanto, se
si cambiano i moduli, necessario riavviare l'interprete o se solo un modulo che si desidera testare in
modo interattivo, utilizzare imp.reload(), ad esempio:
import imp; imp.reload(nome_modulo).

6.1.1. Eseguire Moduli Come Script.

Basta avviare Python da linea di comando, associandogli un file con estensione .py in questo modo:
pythonfibo.py<argomentiopzionali>
Il codice presente nel modulo sar eseguito, come se si fosse importato, ma con il __name__ impostato
su __main__. Questo significa l'aggiunta di questo codice alla fine del modulo:
if__name__=="__main__":
importsys
fib(int(sys.argv[1]))

 possibile rendere il file utilizzabile come un script cos anche come un modulo importabile, questo
perch il codice che analizza la riga di comando viene eseguito solo se nel file modulo viene eseguito
"main":
verifichiamolo meglio con una prova. In questo caso il modulo viene eseguito.
$pythonfibo.py50
112358132134
Se il modulo importato, in questo caso il codice non viene eseguito:
>>>importfibo
>>>
Questo spesso utilizzato sia per fornire una comoda interfaccia utente per un modulo, o per scopi di test
(che eseguono il modulo come uno script esegue una serie di test).

6.1.2. Il Modulo Ricerca Path.

Quando un modulo per esempio di nome prova.py viene importato, l'interprete prima ricerca un
modulo esistente che abbia quel nome, se non lo trova, allora lo cerca in una lista di directory contenuta
nella variabile sys.path, la quale viene inizializzata da queste posizioni:

La directory contenente lo script ingresso (o la directory corrente).

PYTHONPATH (una variabile ambiente contenete i percorsi in cui cercare, con la stessa sintassi
PATH variabile utilizzata dalla shell ).
Nell'installazione dipendente predefinita.

Dopo l'inizializzazione, i programmi Python possono modificare sys.path. La directory contenente lo

script sar messa all'inizio del percorso di ricerca, all'inizio del percorso di libreria standard. Questo
significa che verranno caricati gli script in quella directory, invece che moduli dello stesso nome nella
directory di libreria. Questo un errore almeno che la tale sostituzione non sia desiderata. Vedere la
sezione Moduli standard Standard Modules per ulteriori informazioni.

6.1.3. Files Python Compilati.

Per accelerare l'esecuzione dei moduli, Python memorizza nella cache la versione compilata di ciascun
modulo nella directory __pycache__ sotto il nome module.version.pyc, dove version
codifica il formato del file compilato, che contiene in genere il numero di versione di Python.
Ad esempio, in CPython rilascio 3.3 la versione compilata di prova.py sarebbe memorizzata nella cache
cio il luogo dove Python conserva molte informazioni come __pycache__/prova.cpython33.pyc. Questa convenzione di denominazione consente a moduli compilati da versioni diverse e
diverse versioni di Python di coesistere senza conflitti.
Python controlla la data di modifica del file sorgente con la versione compilata per vedere se immutato
oppure deve essere ricompilato. Questo processo completamente automatico. Inoltre, i moduli compilati
sono indipendenti dalla piattaforma, in modo che la stessa libreria possa essere condivisa tra sistemi con
differenti architetture.

Python non controlla la cache in due circostanze.

Quando ricompila il modulo che viene caricato direttamente dalla riga di comando.
Quando c' il modulo di origine.

Per il supporto a una distribuzione senza sorgente (solo compilato), il modulo compilato deve essere nella
directory dei sorgenti, e non ci deve essere un modulo di origine.
Alcuni consigli per i pi esperti:

possibile utilizzare l'opzione -O o -OO per attivare il comando Python che riduce le
dimensioni di un modulo compilato ottimizzando le risorse. L'opzione -O rimuove tutte le
affermazioni proprie delle dichiarazioni, L'opzione -OO rimuove sia le affermazioni delle
dichiarazioni che la documentazione togliendo le stringhe __doc__. Poich alcuni
programmi possono fare assegnamento sulla loro disposizione, si consiglia di utilizzare
questa opzione solo se si sa cosa si sta facendo. I moduli "ottimizzati", hanno un
suffisso . Pyo invece che . Pyc e di solito sono pi piccoli. Le versioni future potrebbero
cambiare il modo con cui viene eseguita l'ottimizzazione.

Un programma non viene eseguito pi velocemente quando viene letto da un file pyo o pyc
rispetto a quando viene letto da un file py. L'unica cosa che pi veloce su pyc o pyo la
velocit con cui sono caricati i files. Questa possibilit va usata solo per programmi di
dimensione veramente grande. Questo pu tornare utile quando si lavora in rete, mentre in
stand alone con la velocit delle attuali macchine il tutto perde di senso.

Il modulo compileall (compila tutto) pu creare file con estensione .Pyc (o .Pyo file
quando viene usato -O o -OO) per tutti i moduli in una directory.
Per maggiori dettagli su questo processo, compreso un diagramma di flusso delle decisioni,
dare un'occhiata a PEP 3147.

6.2. Moduli Standard.

Python viene fornito con una libreria di moduli standard, descritti in un documento separato, la Python
Library Reference (di seguito "Libreria di riferimento"). Alcuni moduli sono parte integrata
dell'interprete che possiamo definire come indispensabili, questi forniscono l'accesso a operazioni che non
fanno parte del nucleo del linguaggio ma cionondimeno sono interne, per garantire efficienza o per
fornire accesso alle primitive del sistema operativo come ad esempio le chiamate di sistema. L'insieme di
tali moduli un'opzione di configurazione che dipende anche dalla piattaforma sottostante. Ad esempio, il
modulo winreg viene fornito solo su sistemi Windows. Un modulo particolare che merita una certa
attenzione sys, che specifico in ogni interprete Python che dipende appunto dalla piattaforma
sottostante. Le variabili sys.ps1 e sys.ps2 definiscono le stringhe utilizzate come prompt primario e
secondario >>> e ...:
>>>importsys
>>>sys.ps1
'>>>'
>>>sys.ps2
'...'

>>>sys.ps1='MioPrompt:'
MioPromptprint('Yuck!')
Yuck!
MioPrompt:
Queste due variabili sono funzionali all'interprete solo in modalit interattiva (in altri contesti sarebbe un
non senso).
La variabile sys.path una lista di stringhe che determina il percorso di ricerca dei moduli. Questa
viene inizializzata ad un percorso predefinito facendo riferimento alla variabile d'ambiente
PYTHONPATH, o da una precostituita se PYTHONPATH non impostata. possibile apportare
modifiche usando le operazioni standard permesse con le liste:
>>>importsys
>>>sys.path.append('/usr/pippo/lib/python')

6.3. La Funzione dir().

La funzione precostituita dir() , usata per vedere quali nomi un modulo fornisce restituiti sotto forma
di una lista ordinata di stringhe:
>>>importfibo,sys
>>>dir(fibo)
['__name__','fib','fib2']
>>>dir(sys)
['__displayhook__','__doc__','__egginsert','__excepthook__',
'__loader__','__name__','__package__','__plen','__stderr__',
'__stdin__','__stdout__','_clear_type_cache','_current_frames',
'_debugmallocstats','_getframe','_home','_mercurial',
'_xoptions',
'abiflags','api_version','argv','base_exec_prefix',
'base_prefix',
'builtin_module_names','byteorder','call_tracing','callstats',
'copyright','displayhook','dont_write_bytecode','exc_info',
'excepthook','exec_prefix','executable','exit','flags',
'float_info',
'float_repr_style','getcheckinterval','getdefaultencoding',
'getdlopenflags','getfilesystemencoding','getobjects',
'getprofile',
'getrecursionlimit','getrefcount','getsizeof',
'getswitchinterval',
'gettotalrefcount','gettrace','hash_info','hexversion',
'implementation','int_info','intern','maxsize','maxunicode',
'meta_path','modules','path','path_hooks','path_importer_cache',
'platform','prefix','ps1','setcheckinterval','setdlopenflags',
'setprofile','setrecursionlimit','setswitchinterval','settrace',
'stderr','stdin','stdout','thread_info','version',
'version_info',
'warnoptions']

Senza argomenti, dir() visualizza una lista di nomi attualmente definita:

>>>importfibo
>>>fib=fibo.fib
>>>dir()
['__builtins__','__name__','a','fib','fibo','sys']
Notate che nella lista, sono presenti tutti i tipi di nomi: Variabili, funzioni, moduli ecc.
dir() non produce una lista delle variabili e delle funzioni precostituite. Per ottenere questo, bisogna
utilizzare il modulo standard builtins:
>>>dir(builtins)
['ArithmeticError','AssertionError','AttributeError',
'BaseException',
'BlockingIOError','BrokenPipeError','BufferError','BytesWarning',
'ChildProcessError','ConnectionAbortedError','ConnectionError',
'ConnectionRefusedError','ConnectionResetError',
'DeprecationWarning',
'EOFError','Ellipsis','EnvironmentError','Exception','False',
'FileExistsError','FileNotFoundError','FloatingPointError',
'FutureWarning','GeneratorExit','IOError','ImportError',
'ImportWarning','IndentationError','IndexError',
'InterruptedError',
'IsADirectoryError','KeyError','KeyboardInterrupt','LookupError',
'MemoryError','NameError','None','NotADirectoryError',
'NotImplemented',
'NotImplementedError','OSError','OverflowError',
'PendingDeprecationWarning','PermissionError',
'ProcessLookupError',
'ReferenceError','ResourceWarning','RuntimeError',
'RuntimeWarning',
'StopIteration','SyntaxError','SyntaxWarning','SystemError',
'SystemExit','TabError','TimeoutError','True','TypeError',
'UnboundLocalError','UnicodeDecodeError','UnicodeEncodeError',
'UnicodeError','UnicodeTranslateError','UnicodeWarning',
'UserWarning',
'ValueError','Warning','ZeroDivisionError','_',
'__build_class__',
'__debug__','__doc__','__import__','__name__','__package__',
'abs',
'all','any','ascii','bin','bool','bytearray','bytes',
'callable',
'chr','classmethod','compile','complex','copyright','credits',
'delattr','dict','dir','divmod','enumerate','eval','exec',
'exit',
'filter','float','format','frozenset','getattr','globals',
'hasattr',
'hash','help','hex','id','input','int','isinstance',
'issubclass',
'iter','len','license','list','locals','map','max',
'memoryview',

'min','next','object','oct','open','ord','pow','print',
'property',
'quit','range','repr','reversed','round','set','setattr',
'slice',
'sorted','staticmethod','str','sum','super','tuple','type',
'vars',
'zip']

6.4. I Packages (o pacchetti).

I packages (pacchetti) sono un modo per strutturare gli namespace (spazio dei nome riguardanti le
variabili) nei moduli di Python utilizzando "i nomi dei moduli con punteggiatura". Ad esempio, il nome
del modulo A.B designa un sotto-modulo chiamato B in un pacchetto chiamato A. L'uso di nomi di
modulo punteggiati esime gli autori di pacchetti multi-modulo, tipo NumPy o PythonImagingLibrary o
qualsiasi altro modulo per esempio di doversi preoccupare che le proprie variabili possano entrare in
conflitto con altre di altri moduli.
si supponga di voler progettare una collezione di moduli (cio un package) per la gestione uniforme dei
file audio e dati audio. Ci sono molti diversi formati di file audio (di solito riconoscibili dalla loro
estensione, per esempio: .wav, .aiff, .au), quindi un package potrebbe essere necessario per creare e
mantenere una collezione crescente di moduli per la conversione tra i vari formati di file. Ci sono anche
molte operazioni che si potrebbe voler effettuare sui dati (quali il mixaggio, l'aggiunta di eco, applicare
una funzione di equalizzazione, creare un effetto stereo artificiale), quindi in aggiunta, potreste scrivere un
quantitativo notevole di moduli per eseguire queste operazioni. Ecco una possibile struttura per il
pacchetto (espresso in termini di file system gerarchico):

sound/livelloaltodelpackage
__init__.pyInizializzazionedelpackagesound
formats/Sottopackageperifilediconversione
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
effects/Sottopackageperglieffettisuono
__init__.py
echo.py
surround.py
reverse.py
...
filters/Sottopackageperifiltri
__init__.py
equalizer.py
vocoder.py

karaoke.py
...
Quando si importa un package, Python cerca attraverso le directory in sys.path le sotto directory del
package. I file __init__.py permettono a Python di trattare le directory come contenitori di packages,
questo viene fatto per evitare che directory con un nome stringa in comune, nascondano
involontariamente moduli validi che si verificano in seguito nel percorso di ricerca del modulo. Nel caso
pi semplice, __init__.py pu essere solo un file vuoto, ma pu anche eseguire codice di
inizializzazione per il pacchetto o impostare la variabile __all__ come descritto pi avanti.
Gli utenti del package possono importare singoli moduli del package, per esempio:
importSound.Effects.echo
Questo carica il modulo Sound.Effects.echo che deve essere referenziato con il suo nome completo.
sound.effects.echo.echofilter(input,output,delay=0.7,atten=4)
Un modo alternativo per importare il sotto-modulo :
fromSound.Effectsimportecho
Questo comando, carica il sotto-modulo echo, e lo rende disponibile senza il prefisso del pacchetto, in
modo che possa essere utilizzato come segue:
echo.echofilter(input,output,delay=0.7,atten=4)
Ancora un'altra variante quella di importare la funzione o la variabile desiderata direttamente:
fromSound.Effects.echoechofilterimport
Di nuovo, questo carica il sotto-modulo echo, ma rende la sua funzione echofilter () direttamente
disponibile:
echofilter(input,output,delay=0.7,atten=4)
Come si vede, Python mette a disposizione molte strade per ottenere la stessa cosa! Questo fa di Python
un linguaggio potente, semplice e personalizzabile. Cosa chiedere di pi.
Si noti che quando si usa from package import voce, l'elemento pu essere o un modulo (sub
package del pacchetto), o qualche altro nome definito nel package, come una funzione, una classe o una
variabile. I primi test sulle istruzione import vengono fatti per verificare se l'elemento definito
all'interno del pacchetto, se cos non , allora si presuppone che sia un modulo e tenta di caricarlo. Se non
riesce a trovarlo, un'eccezione ImportError viene sollevata.
Al contrario, quando si usa una sintassi del tipo import voce.sottovoce.sottosottovoce,
ogni elemento eccetto l'ultimo deve essere un pacchetto, l'ultimo elemento pu essere un modulo o un
package ma non pu essere una classe o una funzione o una variabile definita nel punto precedente .

6.4.1. Importazione * From Da Un Package.

Ora, cosa succede quando l'utente scrive from sound.effects import *? Idealmente, si
potrebbe sperare che questo in qualche modo va al file system, per constatare che siano presenti nel
pacchetto dei sotto-moduli, e li importa tutti. Questo potrebbe richiedere molto tempo inoltre
l'importazione di sotto-moduli potrebbe avere effetti collaterali indesiderati che possono accadere solo

quando il sotto-modulo esplicitamente importato.

L'unica soluzione che l'autore del pacchetto fornisca un indice esplicito del pacchetto. L'istruzione
import utilizza la seguente convenzione: se il codice __init__.py di un pacchetto definisce una lista
di nome__all__, esso viene considerato come l'elenco dei nomi di moduli che devono essere importati
quando from package import * viene richiesto. Spetta all'autore del pacchetto mantenere questo
elenco aggiornato qualora una nuova versione del pacchetto venga rilasciata. Gli autori dei packages
possono anche decidere di non sostenere questa pratica se non vedono l'utilit di importare con * dal loro
package. Ad esempio, il file sound/effects/__init__.py potrebbe contenere il seguente codice:
__all__=["echo","surround","reverse"]
Ci significa che from sound.effects import * importerebbe i tre sotto-moduli sopracitati del
package sound.
Se__all__ non definito, l'istruzione from sound.effects import * non importa tutti i sotto
moduli del package sound.effects nel namespace (spazio dei nomi) corrente, ma si assicura solo
che il package sound.effects sia stato importato (possibilmente l'esecuzione con qualsiasi codice di
inizializzazione in __init__.py) e quindi importa qualunque nome sia definito nel pacchetto. Ci
include qualsiasi nome definito (e i sotto moduli esplicitamente caricati) in __init__.py. Esso
comprende anche eventuali sotto moduli del packages che siano stati esplicitamente caricati da precedenti
istruzioni. Considerate questo codice:
importsound.effects.echo
importsound.effects.surround
fromsound.effectsimport*
In questo esempio, i moduli echo e surround sono importati nello spazio dei nomi corrente poich
vengono definiti nel package sound.effects quando viene eseguita l'istruzione from...import
*. (Questo funziona anche quando __all__ definita.)
Sebbene alcuni moduli siano progettati per esportare solo nomi che seguono certi schemi quando si
utilizza import *, essa ancora considerata una cattiva pratica nel codice di produzione.
Ricordate,
non
c'
niente
di
sbagliato
utilizzare
from
Package
import
specifico_sottomodulo! In realt, questa la notazione consigliata, a meno che il modulo
importatore debba usare dei sotto moduli con lo stesso nome da packages differenti.

6.4.2. Referenze Intra-package.

Quando i pacchetti sono strutturati in sotto-package (come con il pacchetto sound nell'esempio),
possibile utilizzare l' import assoluto per riferirsi a sotto-moduli di packages fratelli. Ad esempio, se il
modulo sound.filters.vocoder deve utilizzare il modulo echo nel pacchetto
sound.effects, si pu usare from sound.effects import echo.
Si possono scrivere anche import relativi, con il from module import nome di dichiarazioni di
importazione. Questi import utilizzano dei punti per indicare i packages attuali e i packages di levello

superiore coinvolti nell'importazione. Dal modulo surround per esempio, possibile utilizzare:
from.importecho
from..importformats
from..filtersimportequalizer
Si noti che le relative import, si basano sul nome del modulo corrente. Poich il nome del modulo
principale sempre "__main__", moduli, impiegati come il modulo principale di una applicazione
Python devono sempre utilizzare import assoluti.

6.4.3. Packages in Directory Multiple.

I packages, supportano un altro attributo speciale, __path__. Questo viene inizializzato per ottenere una
lista contenente il nome della directory che contiene tutti i packages __init__.py prima che il codice
in quel file venga eseguito. Questa variabile pu essere modificata, cos facendo influenza le future
ricerche i moduli e i sotto-packages contenuti nel pacchetto.
Mentre questa caratteristica non spesso necessaria, pu essere utilizzata per estendere l'insieme dei
moduli trovati in un package.
Note:
[1] In realt le definizioni di funzione sono anche "dichiarazioni" che vengono 'eseguite; l'esecuzione di
una definizione di funzione a livello di modulo entra con il nome nella tabella dei simboli globali del
modulo.

7. Input e Output.
Esistono diversi modi per mostrare l'output di un programma; i dati possono essere stampati in una forma
leggibile, o scritti in un file per un uso futuro. Questo capitolo tratter alcune possibilit.

7.1. Formattazione Avanzata dell'Output.

Finora abbiamo incontrato due modi di scrivere valori: le dichiarazioni di espressioni e la funzione
print(). Un terzo modo usare il metodo write() dell'oggetto file, il file di output standard ha come
riferimento lo sys.stdout (Vedere la Library Reference per ulteriori informazioni in proposito).
Spesso si desidera avere un maggiore controllo sulla formattazione dell'output invece che stampare
semplicemente dei valori separati da spazio. Ci sono due modi per formattare l'output:

il primo modo quello di fare tutto con la gestione delle stringhe; tramite operazioni di divisione
e di concatenazione con ci possibile creare qualsiasi presentazione che si possa immaginare. Il
tipo stringa ha alcuni metodi che eseguono operazioni utili per la formattazione in considerazione
di una determinata larghezza di colonna, che saranno discusse a breve.

Il secondo modo quello di utilizzare il modulo string che contiene il metodo

str.format() e una classe modello (Template) che offre un modo diverso per sostituire i
valori nelle stringhe.

Una questione rimane, naturalmente: come si fa a convertire i valori in stringhe? Fortunatamente, Python

ha un modo per convertire qualsiasi valore in una stringa, passando alle funzioni repr() o str() Il
controllo dell'output.
La funzione str() concepita per restituire una rappresentazione dei valori che sono abbastanza
leggibili, mentre repr() destinata a generare rappresentazioni che possono essere lette dall'interprete
(che provocano l'eccezione Syntax Error se non c' una sintassi equivalente). Per gli oggetti che non
hanno una rappresentazione particolare per il contesto, str() restituir lo stesso valore di repr().
Molti valori, come numeri strutture o liste e dizionari, mostrano la stessa rappresentazione utilizzando la
funzione Strings, in particolare, hanno due distinte rappresentazioni.
Ecco alcuni esempi:
>>>s='Ciaomondo.'
>>>str(s)
'Ciaomondo.'
>>>repr(s)
"'Ciaomondo.'"
>>>str(1/7)
'0.14285714285714285'
>>>x=10*3.25
>>>y=200*200
>>>s='Ilvaloredix'+repr(x)+',ediy'+repr(y)+
'...'
>>>print(s)
Ilvaloredix32.5,ediy40000...
>>>#repr()aggiungeallastringalevirgoletteelabarrarovescia
...hello='Ciaomondo\n'
>>>hellos=repr(hello)
>>>print(hellos)
'Ciaomondo\n'
>>>#L'argomentodirepr()puessereunoggettoPython
...repr((x,y,('spam','uova')))
"(32.5,40000,('spam','uova'))"
Questi sono due modi per scrivere un tabella di quadrati e cubi:
1 modo
>>>forxinrange(1,11):
...print(repr(x).rjust(2),repr(x*x).rjust(3),end='')
...#Notarel'usodi'end'sullaprecedentelinea
...print(repr(x*x*x).rjust(4))
...
111
248
3927
41664
525125
636216
749343
864512

981729
101001000
2 modo
>>>forxinrange(1,11):
...print('{0:2d}{1:3d}{2:4d}'.format(x,x*x,x*x*x))
...
111
248
3927
41664
525125
636216
749343
864512
981729
101001000
Si noti che nel primo esempio, che uno spazio tra ogni colonna che stata aggiunto dal metodo print()
il quale, aggiunge sempre gli spazi tra i suoi argomenti.)
Questo esempio illustra il metodo str.rjust() per gli oggetti stringa, che giustifica a destra una
stringa in un campo di una data ampiezza riempiendola di spazi a sinistra. Esistono metodi complementari
str.ljust() e str.center(). Questi metodi non scrivono nulla, ma restituiscono una nuova
stringa formattata. Se la stringa di input troppo lunga, non viene troncata ma restituita intatta; questa
scelta permette di non perdere dati a scapito di una formattazione che potrebbe non avere senso. Ma se lo
scopo quello di troncare comunque, sempre possibile utilizzate la funzione di divisione del tipo
x.ljust(n)[:n].C' un altro metodo, str.zfill(), che formatta una stringa numerica sulla
sinistra con zeri. La si capisce in merito a segni pi e meno:
>>>'12'.zfill(5)InputeOutput
'00012'
>>>'3.14'.zfill(7)
'003.14'
>>>'3.14159265359'.zfill(5)
'3.14159265359'
L'aspetto nell'uso base del metodo str.format() si presenta cos:
>>>print('Noisiamoi{}chedicono"{}!"'.format('cavalieri',
'Ni'))
Noisiamoicavalierichedicono"Ni!"
Le parentesi e i caratteri al loro interno (chiamati campi di formato) vengono sostituiti con gli oggetti
passati nel metodo str.format(). Un numero tra parentesi graffe pu essere usato per riferirsi alla
posizione dell'oggetto passato al metodo str.format().

>>>print('{0}e{1}'.format('pancetta','uova'))
pancettaeuova
>>>print('{1}e{0}'.format('pancetta','uova'))
uovaepancetta
Se argomenti di parole chiave vengono utilizzati nel metodo str.format(), i loro valori sono indicati
utilizzando il nome dell'argomento.
>>>print('Questo{bevanda}{aggettivo}.'.format(
...bevanda='vino',aggettivo='veramentebuono'))
Questovinoveramentebuono.
Argomenti posizionali e parole-chiave possono essere combinati in modo arbitrario.
>>>print('Lavitadi{0},{1},e{altro}.'.format('Gianni',
'Alfredo',altro='Giorgio'))
LavitadiGianni,AlfredoeGiorgio.
Le seguenti forme contratte, possono essere utilizzate per convertire i valori prima della formattazione;
'!a' (applica ascii()), '!s' (applica str()) e '!r' (applica repr()) possono essere usati per
convertire il valore prima della formattazione:
>>>importmath
>>>print('IlvalorediPIapprossimato{}.'.format(math.pi))
IlvalorediPIapprossimato3.14159265359.
>>>print('IlvalorediPIapprossimato{!r}.'.format(math.pi))
IlvalorediPIapprossimato3.141592653589793.
Un ':' opzionale seguito da una formattazione specifica, permette un maggiore controllo sul modo in
cui il valore formattato. L'esempio seguente arrotonda Pi a tre cifre dopo la virgola.
>>>importmath
>>>print('IlvalorediPIapprossimativamente
{0:.3f}.'.format(math.pi))
IlvalorediPIapprossimativamente3.142.
Passando un intero dopo il ':'far s che il campo sia un numero minimo di caratteri estesi. Questo
utile per fare tabelle ben formattate.
>>tabella={'Alfredo':4127,'Gianni':4098,'Andrea':7678}
>>>fornome,telefonointabella.items():
...print('{0:10}==>{1:10d}'.format(nome,telefono))
...
Gianni==>4098
Andrea==>7678
Alfredo==>4127

Se si ha una stringa di formato davvero lunga che non si vuole dividere, sarebbe bello se si potesse fare
riferimento alle variabili da formattare per nome invece che per posizione. Questo pu essere fatto
semplicemente passando il dizionario e utilizzando le parentesi quadre '[]' per accedere alle chiavi.
>>>tabella={'Alfredo':4127,'Gianni':4098,'Andrea':8637678}
>>>print('Gianni:{0[Gianni]:d};Alfredo:{0[Alfredo]:d};'
...'Andrea:{0[Andrea]:d}'.format(tabella)
Gianni:4098;Alfredo:4127;Andrea:8637678
Ci potrebbe essere fatto anche passando la tabella come argomenti chiave con la notazione '**'.
>>>tabella={'Alfredo':4127,'Gianni':4098,'Andrea':8637678}
>>>print('Gianni:{Gianni:d};Alfredo:{Alfredo:d};Andrea:
{Andrea:d}'.format(**table))
Gianni:4098;Alfredo:4127;Andrea:8637678
Ci particolarmente utile in combinazione con la funzione precostituita vars(), che restituisce un
dizionario contenente tutte le variabili locali.
Come si potuto notare, Python possiede una capacit di formattazione dell'output veramente notevole
che permette buoni risultati estetici con poca fatica. Tutto questo utile per formattazioni su schermo a
linea di comando oppure per la scrittura su file, ma perdere un po' di valore quando Python viene
utilizzato con interfacce grafiche le quali si occupano in prima persona della formattazione dei vari
campi.
Per una panoramica completa sulla formattazione delle stringhe usando str.format() , fare
riferimento a Format String Syntax.

7.1.1. Formattazione Stringhe Classica.

L'operatore % pu essere utilizzato anch'esso per la formattazione di una stringa. Esso interpreta
l'argomento di sinistra come la stringa di formato sprintf(), e restituisce la stringa formattata da
questa operazione. Ma vediamolo meglio con un' esempio:
>>>importmath
>>>print('IlvaloreapprossimatodiPI%5.3f.'%math.pi)
IlvaloreapprossimatodiPI3.142.
Ulteriori informazioni possono essere trovate nella sezione printf-style String Formatting .

7.2. Lettura e Scrittura File.

open() restituisce un oggetto di tipo file (file object), ed comunemente usato usando due argomenti:
open(nome_del_file, modalita):
>>>f=open('file_interessato','w')
Il primo argomento una stringa contenente il nome del file da utilizzare ed il suo eventuale percorso. Il
secondo argomento un'altra stringa contenente alcuni caratteri che descrivono il modo in cui verr

utilizzato il file. Per cui modalita pu essere:

'r'- Il file sar aperto in modalit testo solo in lettura. Questa la modalit predefinita se
nessuna modalit viene specificata.
'w'- Il file sar aperto nella sola modalit testo solo in scrittura. Se esiste un file con lo stesso
nome, esso sar sovrascritto.
'a'- Il file sar aperto in modalit testo aggiungendo alla fine tutto ci che verr scritto.
'r+'- Il file sar aperto in modalit lettura/scrittura.
'modalita' + 'b'- Se aggiunta alle altre modalit descritte, l'opzione 'b', aprir il file in
modalit binaria, in questo caso i dati vengono letti e scritti sotto forma di oggetti byte. Questa
modalit dovrebbe essere utilizzata per tutti i file che non contengono testo.

Siccome il marcatore di fine file cambia in base alla piattaforma (\n su Unix/Linux \ r \ n su Windows)
Python apre i file in lettura e usa come marcatore di fine file quello di Unix/Linux cio \n . Quando il file
invece viene scritto, Python converte il carattere di fine file nella piattaforma specifica in modo
automatico. Quindi se un file viene letto e scritto sotto Windows quando verr chiuso il terminatore di
file ritorner \ r \ n . Questo modo di gestire il terminatore di file garantisce la portabilit sulle
piattaforme ma pone un potenziale rischio e cio: il rischio di corrompere file di tipo non testo cio
JPEG, EXE ed altri di tipo binario per esempio. State molto attenti a utilizzare la modalit binaria
durante la lettura e la scrittura di questi file.

7.2.1. Metodi dell' Oggetto File.

Gli esempi che proporremo in questa sezione presuppongono che un oggetto file chiamato f sia gi stato
creato.
Per leggere il contenuto di un file, chiamare f.read((opz)dimensione), che legge una certa
quantit di dati e li restituisce come una stringa o un oggetto byte. La dimensione un argomento
numerico facoltativo. Se dimensione viene omesso o negativa, l'intero contenuto del file verr letto e
restituito, se dimensione viene specificata allora viene restituita quella specifica quantit . E' un
problema del programmatore gestire il fatto che un file possa essere pi grande della memoria disponibile
sul computer. Se stata raggiunta la fine del file, f.read() restituisce una stringa vuota ('').

>>>f.read()
'Questol'interofile.\n'
>>>f.read()
''
L'istruzione f.readline(), legge una singola riga del file comprensiva del carattere (\n) che viene
lasciato alla fine della stringa, e viene omesso solo nell'ultima riga del file se il file non termina con un
ritorno a capo. Questo disambigua il valore restituito, infatti se f.readline() restituisce una stringa
vuota, significa che la fine del file stata raggiunta, mentre se una riga bianca rappresentata da ' \n',
cio una stringa contenente un solo '\n'.
>>>f.readline()
'Questalaprimalineadelfile.\n'

>>>f.readline()
'Secondalineadelfile\n'
>>>f.readline()
''
Per leggere delle linee da un file, si pu eseguire un ciclo sull'oggetto file. Questa tecnica veloce utilizza
in mode efficiente la memoria e richiede poco codice esempio:
>>>forlineinf:
...print(line,end='')
...
Questalaprimalineadelfile.
Secondalineadelfile
Se volete leggere tutte le linee del file in una lista potete usare anche list(f) o f.readlines().
La funzione f.write(stringa)scrive tutto il contenuto di stringa sul file e restituisce il numero
di caratteri scritto.
>>>f.write('Questountest\n')
16
Notare che il valore restituito, non comprensivo del marcatore di fine linea. Per scrivere qualcosa di
diverso da una stringa, deve essere prima convertito in una stringa:
>>>valore=('unarisposta',42)
>>>s=str(valore)
>>>f.write(s)
20
Notare che il valore restituito, comprensivo di tutto anche delle parentesi tonde. f.tell() restituisce
un intero che fornisce il numero di byte dell'oggetto file misurati dall'inizio del file.
Per variare la posizione dell'oggetto file si usi f.seek(offset, da_cosa). La posizione viene
calcolata aggiungendo ad offset un punto di riferimento, selezionato tramite l'argomento da_cosa. Un
valore di da_cosa pari a 0 effettua la misura dall'inizio del file, 1 utilizza come punto di riferimento la
posizione attuale, 2 usa la fine del file. da_cosa pu essere omesso ed il suo valore predefinito pari a
0, viene quindi usato come punto di riferimento l'inizio del file.
>>>f=open('mio_file','rb+')
>>>f.write(b'0123456789abcdef')
16
>>>f.seek(5)#Vaal6bytedelfile.
5
>>>f.read(1)
b'5'
>>>f.seek(3,2)#Vaal3byteprimadellafine.
13
>>>f.read(1)
b'd'

I file di testo (quelli aperti, senza la b nella stringa di modalit) ammettono solo ricerche relative
dall'inizio del file (ad eccezione di cercare dalla fine di file con seek(0, 2)), e gli unici valori validi
sono quelli restituiti da f.tell(). Qualsiasi altro valore di scostamento produce un comportamento
indefinito. Quando si finisce di lavorare con un file, bisogna chiamare f.close() per chiudere il file e
scrivere i dati eventualmente presenti nel buffer di memoria su disco, e liberare le risorse. Ogni successivo
tentativo di lavorare con esso generer un'eccezione.
>>>f.close()
>>>f.read()
Traceback(mostrecentcalllast):
File"<stdin>",line1,in?
ValueError:I/Ooperationonclosedfile
Quando si lavora con i file, un buon sistema l'utilizzo del metodo with. Questo ha il vantaggio che il
file verr chiuso correttamente dopo aver finito il suo lavoro anche nel caso in cui nel frattempo si generi
un'eccezione. La scrittura del suo codice inoltre molto pi compatta rispetto all'equivalente del blocco
try-finally.
>>>withopen('file_lavoro','r')asf:
...dati_letti=f.read()
>>>f.closed
True
Gli oggetti file hanno alcuni metodi addizionali, come isatty() e truncate(), che sono utilizzati
meno frequentemente, consultare la Reference Library per una guida completa agli oggetti file.

7.2.2. Salvare strutture di dati con json.

Da un file, possono essere lette o scritte delle stringhe. Ottenere dei numeri invece richiede qualche sforzo
in pi. Dal momento che il metodo read() restituisce solo stringhe, per ottenere dei numeri esse
dovranno essere passate ad una funzione tipo int() , tanto per fare un' esempio prendendo una stringa
tipo '123' la funzione int() restituisce il relativo valore numerico 123. Se si desidera salvare tipi di dati
pi complessi, come le liste nidificate e i dizionari, analizzare e serializzare a mano i dati diventa assai
complicato.
Al fine di evitare che molti programmatori siano costantemente impegnati nella scrittura di codice per
risolvere la questione con inevitabile ricorso al debug, Python consente di utilizzare il popolare formato di
interscambio dati chiamato JSON (JavaScript Object Notation). Questo modulo standard
pu prendere le gerarchie di dati Python, e convertirle in rappresentazioni sotto forma di stringa, questo
processo chiamato serializzazione. Ricostruire i dati dalla rappresentazione dal formato stringa
chiamato deserializzazione. Tra serializzazione e deserializzazione, la stringa che rappresenta l'oggetto
pu essere memorizzata in un file di dati, o inviati tramite una connessione di rete ad una macchina
remota.
Note:
Il formato JSON oggi comunemente usato nelle moderne applicazioni che permettono l'interscambio di
dati. Alcuni programmatori, hanno gi familiarizzato con questo formato, facendone un'ottima scelta per
l'interoperabilit.

Se avete un' oggetto X per esempio, potete vedere in una stringa il contenuto con una semplice linea di
codice:
>>>json.dumps([1,'semplice','lista'])
'[1,"semplice","lista"]'
Una variante della funzione dumps() chiamata dump(), semplicemente serializza l'oggetto
codificandolo in un file di testo( text file). Quindi se f un file oggetto di testo, aprendolo in scrittura
possibile fare questo:
json.dump(x,f)
Per decodificare nuovamente l'oggetto, se f un oggetto file di testo che stato aperto per la lettura:
x=json.load(f)
Questa semplice tecnica di serializzazione in grado di gestire liste e dizionari, ma la serializzazione di
istanze di classi arbitrarie in JSON richiede uno sforzo in pi. Riferimenti al modulo json contengono
una spiegazione a questo.
Il modulo pickle , contrariamente a JSON, un protocollo che consente la serializzazione di oggetti
Python arbitrariamente complessi. Come tale, specifico solo per Python e non pu essere utilizzato per
comunicare con applicazioni scritte in altri linguaggi. E 'anche insicuro per definizione! Deserializzare
dati pickle provenienti da una fonte non attendibile pu eseguire pericolosamente codice arbitrario, se i
dati sono stati realizzati da un cracker esperto.

8. Errori ed Eccezioni.
Fino ad ora i messaggi di errore sono stati solo accennati, ma se avete provato gli esempi probabilmente
ne avrete fatti alcuni. Ci sono (almeno) due tipi di errori: errori di sintassi e di logica.

8.1. Errori di sintassi.

Gli errori di sintassi, noti anche come errori di analisi, sono forse il tipo pi comune commessi quando si
sta imparando un linguaggio di programmazione. Python non fa eccezione a questa regola.
>>>whileTrueprint('Ciaomondo')
^
SyntaxError:invalidsyntax
Il parser cio l'analizzatore del codice introdotto, mostra la linea incriminata e con una freccia cerca di
puntare all'errore rilevato. L'errore causato (o quantomeno rilevato in) dal pezzo che precede la freccia
nell'esempio, in questo caso si riferisce non alla funzione print(), ma ai due punti (':') mancanti
prima di essa. L'esecuzione del codice corretto di cui sopra, genera la stampa infinita di 'Ciao mondo'
interrompibile solo con un CTRL-C.

8.2. Eccezioni.
Anche se una dichiarazione o un'espressione sono sintatticamente corrette, pu avvenire un errore quando

si tenta di eseguirla. Gli errori rilevati durante l'esecuzione sono chiamati eccezioni e sono spesso errori
di logica, ma potrebbero riferirsi anche all'esaurimento della memoria o lo spazio su disco ecc. A volte
sono fatali terminando senza troppi complimenti il programma o addirittura bloccare il calcolatore.
Fortunatamente impareremo a gestirli al meglio. Tuttavia la maggior parte delle eccezioni sono gestite dal
programma e possono produrre messaggi di errore come illustrato di seguito:
>>>10*(1/0)
Traceback(mostrecentcalllast):
File"<stdin>",line1,in?
ZeroDivisionError:divisionbyzero
>>>4+spam*3
Traceback(mostrecentcalllast):
File"<stdin>",line1,in?
NameError:name'spam'isnotdefined
>>>'2'+2
Traceback(mostrecentcalllast):
File"<stdin>",line1,in?
TypeError:Can'tconvert'int'objecttostrimplicitly
L'ultima riga del messaggio di errore indica che cosa accaduto. Le eccezioni sono di diversi tipi, e il tipo
viene stampato come parte del messaggio: i tipi nell'esempio sono ZeroDivisionError,
NameError e TypeError. Questo vero per tutte le eccezioni precostituite, ma non lo per le
eccezioni definite dall'utente (anche se una convenzione utile). I nomi delle eccezioni standard sono
identificatori predefiniti. Non sono parole riservate. Il resto della linea fornisce dettagli in base al tipo di
eccezione e che cosa l'ha causata.
La parte antecedente del messaggio di errore mostra il contesto in cui avvenuta l'eccezione, nella forma
di una traccia dello stack. In generale, esso contiene una traccia che elenca le linee del sorgente, tuttavia,
non visualizzer le linee lette dallo standard input.
Note:
Built-in Exceptions elenca le eccezioni precostituite e il loro significato.

8.3. Trattamento delle Eccezioni.

E 'possibile scrivere programmi che gestiscono le eccezioni selezionate. Il seguente esempio, continua a
chiedere all'utente di immettere un valore fino a che esso sia un' intero valido, ma permette all'utente di
interrompere il programma (usando CTRL-C o qualunque altra combinazione di tasti che il sistema
operativo ospite supporta), notare che in questo caso, un'interruzione generata dall'utente viene segnalata
sollevando l'eccezione KeyboardInterrupt.
>>>whileTrue:
...try:

...x=int(input("Immettiunnumerointero:"))
...break
...exceptValueError:
...print("Uhm!Questononunnumerovalido.Ritenta...")
...
L'istruzione try lavora come segue.
1: try facente parte del blocco try e except.
2: Se non si verificano errori la clausola except non viene eseguita e il programma prosegue
oltre terminando il test di try .
3: Se un'eccezione viene sollevata durante l'esecuzione di try, le rimanenti istruzione nel blocco
vengono saltate. Se l'eccezione coincide con except, allora except viene eseguita e poi
l'esecuzione continua dopo l'istruzione try.
4: Se si verifica un'eccezione che non corrisponde a quella citata nella clausola except, si passa a
istruzioni try pi esterne, cio per esempio alla funzione di un blocco chiamante e se non viene
trovato alcun gestore, la gestione passa a Python e l'esecuzione si ferma visualizzando un
messaggio come mostrato sopra terminando il programma.
Un'istruzione try pu avere pi di una clausola except, per specificare pi gestori per diverse eccezioni,
ma solo uno di essi verr eseguito. I gestori si occupano solo delle eccezioni che si verificano nella
clausola try corrispondente, non in altri gestori della stessa istruzione try. Una clausola di eccezione pu
nominare pi di un'eccezione come fosse un tupla tra parentesi. Per esempio:
...except(RuntimeError,TypeError,NameError):
...pass
Nell'ultima clausola except si pu omettere il nome o i nomi utilizzandola come come caratteri jolly nel
contesto. Questa pratica, da utilizzare con estrema cautela in quanto facile mascherare un errore di
programmazione vero e proprio in questo modo! Pu anche essere utilizzato per stampare un messaggio di
errore e quindi risollevare l'eccezione (permettendo ad una procedura chiamante di gestire l'eccezione):
Una buona pratica di programmazione anche se un po' tediosa, quella di creare un file di Log su cui
scrivere il tipo di errore avvenuto e in che parte del programma. Questo permette la rapida correzione
dello stesso su programmi distribuiti.
importsys
try:
f=open('mio_file.txt')
s=f.readline()
i=int(s.strip())
exceptIOErroraserr:
print("erroreI/O:{0}".format(err))
exceptValueError:
print("Impossibileconvertireildatoinunintero.")

except:
print("Erroreinaspettato:",sys.exc_info()[0])
raise
Con il blocco try ... except , possibile utilizzare anche la clausola opzionale else, che, quando
presente, deve seguire la clausola except. E' utile quando il codice che deve essere eseguito non
soggetto ad una nuova eccezione sollevata da try. Per esempio:

forarginsys.argv[1:]:
try:
f=open(arg,'r')
exceptIOError:
print('impossibileaprire.',arg)
else:
print(arg,'has',len(f.readlines()),'lines')
f.close()
L'uso della clausola else preferibile all'aggiunta di codice supplementare alla clausola try poich evita
l'intercettazione accidentale di un'eccezione che non stata sollevata dal codice protetto dal blocco try ...
except.
Un'eccezione, pu avere un valore associato, conosciuto anche come argomento dell'eccezione. La
presenza e il tipo dell'argomento dipendono dal tipo di eccezione.
La clausola except, pu specificare una variabile dopo il suo nome. Questa variabile legata all'istanza
dell'eccezione con argomenti memorizzati in instance.args. Per comodit, l'eccezione definisce
__str__() in modo che gli argomenti possono essere stampati direttamente senza dover fare
riferimento ad .args. Se si desidera, anche possibile lanciare un'eccezione con l'istruzione raise
aggiungendo gli attributi desiderati.
>>>try:
...raiseException('fagioli','uova')
...exceptExceptionastipo:
...print(type(tipo))#L'istanzadell'eccezione.
...print(tipo.args)#Gliargomenticontenutiin.args.
...print(tipo)#__str__permettelastampadiargs.
...#mapuesseresovrascrittoinexception.
...x,y=tipo.args#scompattaargs.
...print('x=',x)
...print('y=',y)
...
<class'Exception'>
('fagioli','uova')
('fagioli','uova')
x=pancetta
y=uova

Se un'eccezione ha argomenti, questi vengono stampati come ultima parte ('il dettaglio') del messaggio
per le eccezioni non gestite.
I gestori delle eccezioni non si occupano solo delle eccezioni gestite dal blocco try ... except, ma anche
di tutti quegli errori che si possono verificare in qualsiasi parte del programma in quanto Python che
utilizzando il blocco try ... except al suo interno, li gestisce al meglio anche in quelle funzioni che
vengono chiamate indirettamente. Per esempio:
>>>defquesta_fallisce():
...x=1/0
...
>>>try:
...questa_fallisce()
...exceptZeroDivisionErroraserrore:
...print('Gestioneerrorediesecuzione:',errore)
...
Gestioneerrorediesecuzione:intdivisionormodulobyzero

8.4. Lancio delle Eccezioni.

L'istruzione raise , permette al programmatore di forzare all'occorrenza un'eccezione specifica. Per
esempio:
>>>raiseNameError('Questoerrore')
Traceback(mostrecentcalllast):
File"<stdin>",line1,in?
NameError:Questoerrore
L'unico argomento che raise ha, indica l'eccezione da sollevare. Questo deve essere un'istanza di
exception o una classe exception (cio una classe che deriva da Exception).
Se avete bisogno di determinare se un eccezione stata sollevata, ma non avete intenzione di gestirla, una
forma semplice della dichiarazione raise permette di risollevare l'eccezione:
>>>try:
...raiseNameError('Questoerrore')
...exceptNameError:
...print('Un'eccezionesisollevata!')
...raise
...
Un'eccezionesisollevata!
Traceback(mostrecentcalllast):
File"<stdin>",line2,in?
NameError:Questoerrore

8.5.Eccezioni Definite Dall'Utente.

I programmatori possono creare le proprie eccezioni definendo una nuova classe di eccezione (vedere

Classes per saperne di pi sulle classi Python). Le eccezioni dovrebbero normalmente essere derivate
dalla classe Exception, direttamente o indirettamente. Per esempio:
>>>classMioErrore(Exception):
...def__init__(self,value):
...self.value=value
...def__str__(self):
...returnrepr(self.value)
...
>>>try:
...raiseMioErrore(2*2)
...exceptMioErrorease:
...print('Lamiaeccezione,valore:',e.value)
...
Lamiaeccezione,valore:4
>>>raiseMioErrore('oops!')
Traceback(mostrecentcalllast):
File"<stdin>",line1,in?
__main__.MioErrore:'oops!'
In questo esempio, i valori predefiniti di __init__() e Exception sono stati sovrascritti, per cui il
nuovo comportamento crea semplicemente l'attributo value. Questo sostituisce il comportamento
predefinito di args.
Classi di eccezioni possono essere definite come si pu fare con una qualsiasi altra classe, ma solitamente
esse vengono mantenute semplici. Spesso esse offrono solo una serie di attributi che permettono di
conoscere la natura dell'errore. Quando si crea un modulo che pu sollevare diversi errori distinti, una
pratica comune quello di creare una classe base per le eccezioni definite da quel modulo, e una
sottoclasse per creare specifiche classi di eccezioni per condizioni di errore diverse.
classError(Exception):
"""Classebasepereccezioniinquestomodulo."""
pass
classInputError(Error):
"""Eccezionelanciatasuerrorediinput.
Attributi:
espressioneinputespressionediqualeerroreavvenuto.
MessaggioSpiegazionedell'errore.
"""
def__init__(self,espressione,messaggio):
self.espressione=espressione
self.messaggio=messaggio
classErroreTransizione(Error):
"""Lanciataquandoun'operazionetentaunatransizionechenon
permessa.

Attributi:
precedenteStatoall'iniziodellatransizione.
successivatentativonuovostato.
messaggioSpiegazioneperchlaspecificanonconsentita.
"""
def__init__(self,precedente,successiva,messaggio):
self.precedente=precedente
self.successiva=successiva
self.messaggio=messaggio
La maggior parte delle eccezioni vengono definite con nomi che terminano in "Error" simile alla
denominazione delle eccezioni standard, questo facilita e accellera la comprensione.
Molti moduli standard e non, definiscono le proprie eccezioni per riportare errori che possono verificarsi
nelle funzioni che definiscono. Ulteriori informazioni sulle classi saranno presentate nelle capitolo
Classi .

8.6. Definizione dell'Azione di Pulizia (Clean-up).

L'istruzione try ha un'altra clausola facoltativa che mira a definire azioni di pulizia che deve esserci in
tutte le circostanze. Per esempio:
>>>try:
...raiseKeyboardInterrupt
...finally:
...print('Arrivedercimondo!')
...
Arrivedercimondo!
KeyboardInterrupt
Una clausola finally viene sempre eseguita prima di lasciare l'istruzione try, sia che si sia verificata
o no un'eccezione. Se si verifica un'eccezione nella clausola try e nessuna gestione stata prevista con
except, (o si verificato in except o else), allora viene eseguita l'istruzione finally. La clausola
finally viene eseguita anche all'uscita del blocco quando un'altra clausola di try viene lasciata
tramite break, continue o return. Un esempio pi complesso:
>>>defdivide(x,y):
...try:
...risultato=x/y
...exceptZeroDivisionError:
...print("divisioneperzero!")
...else:
...print("ilrisultato",risultato)
...finally:
...print("eseguelaclausolafinally")
...
>>>divide(2,1)
ilrisultato2.0
eseguelaclausolafinally

>>>divide(2,0)
divisioneperzero!
eseguelaclausolafinally
>>>divide("2","1")
eseguelaclausolafinally
Traceback(mostrecentcalllast):
File"<stdin>",line1,in?
File"<stdin>",line3,individe
TypeError:unsupportedoperandtype(s)for/:'str'and'str'
Come potete vedere, la clausola finally viene eseguita in ogni caso. Il TypeError sollevato
dividendo due stringhe non viene gestito dalla clausola except e quindi viene rilanciato dopo che la
clausola finally stata eseguita.
Nelle applicazioni del mondo reale, la clausola finally utile per liberare risorse esterne (ad esempio
file, connessioni di rete ecc.), indipendentemente dal fatto che l'uso della risorsa abbia avuto successo.

8.7. Azioni Predefinite di Pulizia (Clean-up).

Alcuni oggetti definiscono azioni di pulizia standard da intraprendere quando l'oggetto non pi
necessario a prescindere dal fatto che l'oggetto sia stato utilizzato o meno. Guardate il seguente esempio,
che cerca di aprire un file e stampare il contenuto sullo schermo.
forlineinopen("mio_file.txt"):
print(line,end="")
Tutto bene, ma il problema con questo codice che lascia il file aperto per un periodo di tempo
indeterminato anche quando il codice ha terminato l'esecuzione. Questo non un problema in semplici
script, ma pu essere un problema per le applicazioni pi grandi o multiutente. Utilizzando invece al suo
posto l'istruzione with la quale permette a oggetti come i file di essere utilizzati in un modo tale da
garantire che siano sempre prontamente e correttamente rilasciati.
withopen("mio_file.txt")asf:
forlineinf:
print(line,end="")
Nell'esempio sopra, dopo che viene eseguita l'istruzione, il file fviene letto ed immediatamente chiuso
anche se si verifica un problema durante l'elaborazione delle linee. Oggetti come i file, prevedono il
clean-up nella loro documentazione.

9. Classi.
Premesso che l'argomento richiederebbe un trattato a se stante, vista la complessit, lo tratteremo qui in
modo sintetico e peculiare a Python. Rispetto ad altri linguaggi di programmazione, il meccanismo delle
classi di Python permette di aggiunge nuove classi con una sintassi e semantica minimi. Si tratta di una
miscela di meccanismi per la manipolazione delle classi che si trovano in C++ e Modula-3 che forniscono
Python di tutte le caratteristiche standard della OOP (Object Oriented Programming). Il meccanismo

dell'ereditariet permette classi di base multiple, e una classe derivata pu sovrascrivere tutti i metodi
della sua classe o della classe da cui deriva, e un metodo pu chiamare il metodo di una classe base con lo
stesso nome. Gli oggetti possono contenere quantit arbitrarie di tipi e dati. Cos come i moduli, le classi
partecipano alla natura dinamica di Python: vengono create in fase di esecuzione, e possono essere
ulteriormente modificate dopo la creazione.
Nella terminologia C++, normalmente i membri di classe (inclusi i membri dati) sono pubblici (tranne le
variabili private (Private Variables) (vedi sotto)), e tutti membri delle funzioni sono virtuali. Le funzioni
virtuali sono il meccanismo con cui si realizza in C++ il polimorfismo, che una delle pi importanti
caratteristiche dei linguaggi orientati agli oggetti, che permette ad oggetti simili di rispondere in modo
diverso agli stessi comandi. Come in Modula-3, non ci sono scorciatoie per riferirsi ai membri
dell'oggetto dai suoi metodi. La funzione di metodo viene dichiarata con un' esplicito primo argomento
che rappresenta l'oggetto, che viene fornito in modo implicito dalla chiamata. Come in Smalltalk, le classi
stesse sono oggetti. Ci fornisce una semantica per l'importazione e la ridenominazione. A differenza di
C++ e Modula-3, tipi precostituiti possono essere utilizzati come classi base per essere estese dall'utente.
Inoltre, sempre come in C + +, operatori precostituiti (operatori aritmetici, indicizzazioni, ecc), possono
essere utilizzati con una sintassi speciale che pu essere ridefinita per istanziare nuove classe.
La mancanza di una terminologia universalmente accettata per parlare di classi, ci porta a paragonare
Python ad altri linguaggi per meglio comprendere ci che viene detto. Questo non significa che Python
non abbia pari potenzialit anzi! Questo si rende necessario perch la programmazione ad oggetti pur
essendo oramai in uso da anni, rimane ostica ai pi specialmente ai neofiti. Quindi paragoni ed esempi si
rendono indispensabili.

9.1. Considerazioni Circa i Nomi e Gli Oggetti.

Gli oggetti hanno una propria vita, e pi nomi (in pi ambiti) possono essere associati allo stesso oggetto.
Questo noto come aliasing cio la situazione che si verifica quando pi simboli in un programma
referenziano la stessa zona di memoria. Questo non generalmente apprezzato di primo acchito da Python
infatti pu essere tranquillamente ignorato quando si tratta di tipi immutabili di base (numeri, stringhe,
tuple). Tuttavia, l'aliasing ha un effetto forse sorprendente sulla semantica del codice Python che
coinvolgono oggetti mutabili come liste, dizionari, e molti altri tipi. Questo viene usato a beneficio del
programma dato che gli alias si comportano come puntatori per alcuni aspetti. Ad esempio, passando un
oggetto conveniente che solo un puntatore venga passato al momento dalla realizzazione, e se una
funzione modifica un oggetto passato come argomento, il chiamante vedr il cambiamento, questo elimina
la necessit di due meccanismi diversi (per riferimento e per valore) per passare gli argomenti come
avviene in Pascal .

9.2. Spazio dei Nomi e Visibilit in Python.

Prima di introdurre il meccanismo delle classi in Python, va detto qualcosa circa le regole di visibilit che
Python usa. Le definizioni di classe giocano con alcuni trucchetti con gli spazi dei nomi, ed necessario
sapere come gli ambiti e gli spazi dei nomi lavorano per comprendere appieno cosa sta succedendo.
Cominciamo con alcune definizioni:
Un namespace (uno spazio dei nome) una mappatura di nomi agli oggetti. La maggior parte degli spazi
dei nomi vengono attualmente implementati come dizionari Python, ma che non sono normalmente
visibili in alcun modo (tranne che per le prestazioni), e potrebbero cambiare in futuro. Esempi di spazi dei

nomi sono: l'insieme dei nomi precostituiti (contenenti funzioni come abs () e i nomi delle eccezioni
precostituite), i nomi globali in un modulo, e i nomi locali in una funzione chiamata. In un certo senso
l'insieme degli attributi di un oggetto contribuisce a formare uno spazio dei nomi. La cosa importante da
sapere sugli spazi dei nomi che non c' assolutamente nessuna relazione tra i nomi in diversi spazi dei
nomi, per esempio, due moduli diversi potrebbero entrambi definire una funzione con lo stesso nome
senza confusione, questo possibile anteponendo al nome della funzione il nome del modulo con la
notazione del punto tipo mioModulo.miaFunzione.
A proposito sempre a causa di una mancanza di specifiche precise sulle classi, io uso la parola attributo
per qualsiasi nome che segua un punto per esempio nel z.real, real un attributo dell'oggetto z. A rigor
di termini, i riferimenti a nomi nei moduli sono riferimenti ad attributi come gi detto nel paragrafo
precedente.
Gli attributi, possono essere a sola lettura o scrivibili. In quest'ultimo caso, l'assegnazione di attributi
possibile.
Gli attributi dei moduli sono scrivibili: si pu scrivere nomemodulo.risposta = 42. Gli attributi
scrivibili possono anche essere cancellati con l'istruzione del.
Ad esempio, del nomemodulo.risposta rimuover l' attributo risposta dall'oggetto nominato
nomemodulo.
Gli spazi dei nomi vengono creati in momenti diversi e hanno diverse vite. Lo spazio dei nomi che
contiene i nomi precostituiti viene creato quando l'interprete Python si avvia, e non viene mai eliminato.
Lo spazio dei nomi globale riferiti a un modulo vengono creati quando la definizione del modulo viene
letta; normalmente, gli spazi dei nomi del modulo durano fino a quando l'interprete si chiude. Le
istruzioni eseguite dall'invocazione di livello superiore dell'interprete, lette da un file di script o
interattivamente, sono considerate parte di un modulo chiamato __main__, in modo da avere il proprio
spazio dei nomi globale. (I nomi precostituiti in realt vivono anche in un modulo che si chiama
builtins.)
Lo spazio dei nomi locale per una funzione viene creato quando la funzione viene chiamata, e cancellati
quando la funzione restituisce il suo valore o solleva un'eccezione non gestita all'interno della funzione.
(In realt, la dimenticanza sarebbe uno modo sporco per descrivere meglio ci che effettivamente accade.)
Naturalmente, invocazioni ricorsive hanno ciascuna il proprio spazio dei nomi locale (memoria
permettendo).
Un' ambito, una visibilit che una regione testuale di un programma Python possiede dove uno spazio
accessibile direttamente. "Direttamente accessibile" qui significa che un riferimento qualificato ad un
nome cerca di trovare il nome nello spazio dei nomi opportuno.
Anche se gli ambiti sono determinati staticamente cio che non possono essere modificati, essi sono
utilizzati in modo dinamico. In qualsiasi momento durante l'esecuzione ci sono almeno tre visibilit
annidate cui i spazi sono direttamente accessibili:

L'area pi interna, quella che viene ricercata per prima e contiene i nomi locali.
La visibilit di tutte le funzioni viene ispezionata cercando nello spazio dei nomi pi vicino
contenente il simbolo cercato, fino ad espandere la ricerca verso simboli non locali, ma anche
verso simboli non globali.
l'ambito next-to-last contiene i nomi dei moduli globali attuali.
l'ambito pi esterno (l'ultimo) lo spazio dei nomi che contiene i nomi precostituiti.

Ecco una rappresentazione grafica sullo spazio dei nomi:

Se un nome viene dichiarato globale, allora tutti i riferimenti e le assegnazioni vanno direttamente al
campo centrale che contiene i nomi globali del modulo. Per ricollegare le variabili presenti al di fuori del
proprio ambito, pu essere utilizzata la dichiarazione nonlocal, se non dichiarate non locale, quelle
variabili sono in sola lettura (un tentativo di scrivere su tale variabile sar sufficiente per creare una nuova
variabile locale nel campo di applicazione pi interno, lasciando il nome identico della variabile esterna
invariato).
Di solito, l'ambito locale fa riferimento a nomi locali della (testualmente) funzione corrente. Al di fuori
delle funzioni, l'ambito locale fa riferimento allo stesso spazio dei nomi dell'ambito globale del modulo.
Le definizioni di classe pone un altro spazio dei nomi nell'ambito locale.
E 'importante rendersi conto che gli ambiti sono determinati testualmente: la visibilit globale di una
funzione definita in un modulo lo spazio dei nomi di quel modulo, non importa da dove o da che alias la
funzione viene chiamata. D'altra parte, la ricerca effettiva dei nomi viene fatta dinamicamente in fase di
esecuzione tuttavia, la definizione del linguaggio si sta evolvendo verso la risoluzione dei nomi statici, in
fase di "compilazione", quindi non si basano sulla risoluzione dei nomi dinamici! (In effetti, variabili
locali sono gi determinate staticamente.)
Un cavillo particolare di Python che se nessuna dichiarazione globale ( global ) in essere, le
assegnazioni ai nomi vanno sempre nel perimetro pi interno. Le assegnazioni non copiano dati, ma
creano solo i nomi agli oggetti. Lo stesso vale per le cancellazioni: l'istruzione del x rimuove
l'associazione di x dallo spazio dei nomi a cui fa riferimento l'ambito locale. In realt tutte le operazioni

che introducono nuovi nomi usano l'ambito locale e in particolare, le dichiarazioni di importazione (
import) e le definizioni di funzioni legano il modulo o nome di funzione all'ambito locale.
L'istruzione global pu essere utilizzata per indicare che particolari variabili vivono in ambito globale e
l dovrebbero essere riferite, l'istruzione nonlocal indica che particolari variabili vivono in un ambito
di inclusione e l dovrebbero essere riferite.

9.2.1. Esempi di Ambiti e Spazio Dei Nomi.

Questo esempio, dimostra come il riferimento a diversi ambiti e spazi dei nomi e in che modo global e
nonlocal, influenzano il collegamento alla variabile.
deftest_visibilita():
defdo_local():
spam="localspam"
defdo_nonlocal():
nonlocalspam
spam="nonlocalspam"
defdo_global():
globalspam
spam="globalspam"
spam="testspam"
do_local()
print("Dopol'assegnamentolocale:",spam)
do_nonlocal()
print("Dopol'assegnamentononlocale:",spam)
do_global()
print("Dopol'assegnamentoglobale:",spam)
test_visibilita()
print("Invisibilitglobale:",spam)
Dopol'assegnamentolocale:testspam
Dopol'assegnamentononlocale:nonlocalspam
Dopol'assegnamentoglobale:nonlocalspam
Invisibilitglobale:globalspam
Si noti come l'assegnazione local (che di default) non ha cambiato il legame di spam su test_visibilita.
L'assegnazione nonlocal cambia il legame di spam su test_visibilita, e l'assegnazione global ha
cambiato il legame a livello di modulo.
Si pu anche vedere che non c'era nessun precedente vincolante per spam prima dell'assegnamento
global.

9.3. Un Primo Sguardo alle Classi.

Le classi introducono un po' di sintassi nuova, tre nuovi tipi di oggetti e nuova semantica.

9.3.1. Sintassi nella Definizione di Classe.

La forma pi semplice di definizione di una classe questo:
classNomeClasse:
<istruzione1>
.
.
.
<istruzionen>
Le definizioni di classe, similarmente alle definizioni di funzione (istruzione def) devono essere eseguite
prima di avere alcun effetto. (Si potrebbe concettualmente, inserire una definizione di classe in un ramo di
un'istruzione if, o all'interno di una funzione.)
In pratica, le dichiarazioni all'interno di una definizione di classe saranno di solito le definizioni di
funzioni, ma altre dichiarazioni sono consentite e talvolta utili, torneremo pi avanti su questo tema. Le
definizioni di funzione all'interno di una classe normalmente hanno una peculiare forma di elenco di
argomenti, dettata dalle convenzioni di chiamata per i metodi anche questo sar spiegato pi avanti.
Quando si accede in una nuova definizione di classe, un nuovo spazio dei nomi viene creato e utilizzato
come l'ambito locale, pertanto tutte le assegnazioni a variabili locali finiscono in questo nuovo spazio dei
nomi. In particolare, le definizioni di funzione legano qui il nome della nuova funzione.
Quando una definizione di classe esiste, viene creato un oggetto di classe. Questo fondamentalmente un
a locazione di memoria che si pu paragonare ad un guscio variabile al cui interno, vengono creati gli
spazi dei nomi definiti con la classe. Nelle sezioni successive, impareremo di pi su oggetti e classi.
L'ambito locale originale (quello in vigore poco prima che la definizione di classe fosse inserita) viene
ridefinito, e l'oggetto della classe tenuto qui al suo interno, e il nome della classe indicata
nell'intestazione della definizione di classe ( NomeClasse nell'esempio).

9.3.2. Oggetti Classe.

Gli oggetti classe supportano due tipi di operazioni: i riferimenti ad attributi e l' istanziazione.

Attributi riferimenti: Utilizzano la sintassi standard utilizzata per tutti i riferimenti attributi
in Python; oggetto.nome. Per nomi di attributi validi s'intende tutti i nomi che sono
nello spazio dei nomi della classe quando l'oggetto classe stato creato. Quindi, se la
definizione di classe si presentava cos:

classMiaClasse:
"""Unsempliceesempiodiclasse"""
i=12345
deff(self):
return'Ciaomondo'
Allora MiaClasse.i e MiaClasse.f sono riferimenti validi ai suoi attributi, che
restituiscono rispettivamente un intero ed un oggetto funzione. Gli attributi di classe
possono inoltre essere assegnati in modo da poter cambiare il valore di MiaClasse.i
per assegnamento. __doc__ anch'esso un attributo valido, restituendo la stringa di
documentazione appartenente alla classe, cio "Un semplice esempio di classe".

L'istanzazione di una classe, viene fatta con la notazione delle funzioni. Basta far finta che
l'oggetto di classe una funzione senza parametri per avere una nuova istanza della classe.
Ad esempio (supponendo la precedente classe ad esempio):
x=MiaClasse()
Crea una nuova istanza della classe assegnata all'oggetto x in una variabile locale.

L'operazione di istanziazione crea un oggetto vuoto. Molte classi creano oggetti personalizzati per uno
specifico stato iniziale. Una classe infine pu definire un metodo speciale chiamato__init__() come
questo:
def__init__(self):
self.data=[]
Quando una classe viene definita con il metodo __init__(), l'istanziazione della classe, invoca
automaticamente __init__() per la nuova istanza di classe creata. Per cui in questo esempio, una
nuova istanziazione di classe pu essere ottenuta cos:
x=MiaClasse()
Naturalmente, il metodo __init__() pu avere argomenti, per una maggiore flessibilit. In tal caso, gli
argomenti forniti alla classe vengono passati a__init__(). Per esempio:
>>>classComplessa:
...def__init__(self,partereale,parteimmaginaria):
...self.r=partreale
...self.i=partimmaginaria
...
>>>x=Complessa(3.0,4.5)
>>>x.r,x.i
(3.0,4.5)

9.3.3. Instanze di Oggetti.

Ora cosa possiamo fare con un'istanza di oggetti? Le uniche operazioni conosciute dagli oggetti istanza
sono i riferimenti ai suoi attributi. Ci sono due tipi di attributi validi, gli attributi dei dati e gli attributi dei
metodi. Per capire meglio la differenza fra le due entit e poterli distinguere al volo, basta ricordarsi che:

I Dati corrispondono a delle propriet e possono essere associati al verbo ESSERE.

I metodi corrispondono a delle elaborazioni e possono essere associati al verbo FARE.

Quindi:
Gli attributi di dati, corrispondono alle "variabili d'istanza" in Smalltalk, e ai "dati membro" in C + +. Gli
attributi di dati non necessitano di essere dichiarati come le variabili locali, essi cominciano ad esistere
quando viene fatta la prima assegnazione. Ad esempio, se x l'istanza di MiaClasse creata in
precedenza, il seguente pezzo di codice stamper il valore 16, senza lasciare traccia (notare che x un
valore e quindi va associata al verbo ESSERE):

x.contatore=1
whilex.contatore<10:
x.contatore=x.contatore*2
print(x.contatore)
delx.contatore
L'altro tipo d'attributo d'istanza si riferisce ai metodi. Un metodo una funzione che "appartiene a" un
oggetto. (In Python, il termine metodo non unico a istanze di classi: altri tipi di oggetti possono avere
dei metodi, ad esempio, oggetti lista hanno metodi chiamati append, insert, remove, sort (notare
che tutti fanno qualcosa e quindi vanno associati al verbo FARE) e cos via, detto ci, nella discussione
che segue, useremo il termine metodo esclusivamente per indicare i metodi degli oggetti d'istanza di
classe, se non diversamente specificato.)
Nomi validi per metodi di un'istanza d'oggetto, dipendono dalla sua classe. Per definizione, tutti gli
attributi di una classe che sono oggetti funzionali definiscono metodi corrispondenti alle sue istanze.
Quindi, nel nostro esempio, x.f un riferimento valido ad un metodo, dal momento che MiaClasse.f
una funzione, ma x.i non , in quanto MiaClasse.i non lo . Ma x.f non la stessa cosa di
MiaClasse.f , un oggetto metodo, non un oggetto funzione.

9.3.4. Metodi degli Oggetti.

Di solito, un metodo viene chiamato subito dopo che stato creato:
x.f()
Nell'esempio MiaClasse, questo restituir la stringa 'Ciao mondo'. Tuttavia, non necessario
chiamare un metodo in modo immediato: x.f un oggetto metodo, e pu essere riposto e chiamato in un
secondo momento. Per esempio:
xf=x.f
whileTrue:
print(xf())
Che continuer a stampare 'Ciaomondo'all'infinito.
Che cosa succede esattamente quando un metodo viene chiamato? Avrete notato che x.f() di cui sopra
stato chiamato senza argomenti, anche se la definizione della funzione di f() specifica un argomento.
Che fine ha fatto l'argomento? Sicuramente Python solleva un'eccezione quando una funzione che
richiede un argomento viene chiamata senza, anche se l'argomento non viene effettivamente utilizzato
In realt, ci si pu gi immaginare la risposta: la particolarit dei metodi che l'oggetto viene passato
come primo argomento della funzione. Nel nostro esempio, la chiamata x.f() esattamente equivalente
a MiaClasse.f(x). In generale, chiamando un metodo con una lista di n argomenti equivalente a
chiamare la corrispondente funzione con una lista di argomenti creata inserendo i metodi dell'oggetto
prima che il primo argomento.
Se non si capisce ancora come i metodi lavorino, uno sguardo alle loro implementazioni pu forse servire
a chiarire le cose. Quando viene fatto riferimento ad un attributo di istanza che non un attributo di dati,
viene ricercata la sua classe. Quando un metodo dell'oggetto viene chiamato con una lista di argomenti,
una nuova lista di argomenti viene creata nell'istanza dell'oggetto e la funzione viene chiamata con questa

nuova lista di argomenti.

9.4. Note Casuali.

I dati con lo stesso nome dei metodi, prevalgono su di essi per evitare conflitti accidentali, che possono
causare malfunzionamenti difficili da trovare specialmente in programmi di grandi dimensioni, quindi
consigliabile utilizzare una sorta di convenzione che riduce al minimo il rischio di conflitti. Alcune
convenzioni possibili, includono la capitalizzazione del nomi nei metodi, anteponendo ai nomi dati agli
attributi con una piccola stringa univoca (per esempio un carattere di sottolineatura), oppure utilizzando
verbi per i metodi e sostantivi per i dati.
Attributi di dati possono essere referenziati dai metodi come anche dagli utenti di un oggetto. In altre
parole, le classi non sono utilizzabili per implementare tipi di dati astratti e puri. In realt, nulla in Python
permette l'offuscamento dei dati, tutto si basa unicamente sulle convenzioni. D'altra parte,
l'implementazione di Python, scritta in C, pu nascondere completamente i dettagli dell'implementazione
e se necessario controllare l'accesso a un oggetto, che pu essere utilizzato da estensioni a Python scritte
in C.
Gli utenti, dovrebbero usare gli attributi dato con cura, essi possono rovinare invariabilmente dati
conservati dai metodi sovrascrivendoli. Si noti che gli utenti possono aggiungere attributi dato propri ad
un'istanza d'oggetto senza intaccare la validit dei metodi, purch vengano evitati conflitti con i nomi .
Ancora una volta, una convenzione sulla denominazione dei nomi, pu risparmiare un sacco di mal di
testa.
Non esistono scorciatoie per referenziare attributi di dati (o altri metodi!) dall'interno dei metodi. Trovo
che questo in realt aumenta la leggibilit dei metodi: non c' possibilit di confondere le variabili locali e
le variabili di istanza guardando un metodo.
Spesso, il primo argomento di un metodo viene chiamato self. Questa non altro che una convenzione:
il nome self non ha assolutamente alcun significato speciale per Python. Si noti, tuttavia, che, non
seguendo questa convenzione il codice potrebbe essere meno leggibile da altri programmatori Python, ed
anche concepibile che un programma scritto per visualizzare le classi per esempio, possa essere scritto
in base a tali convenzioni.
Quello delle convenzioni, potrebbe sembrare a prima vista un problema di poco conto. Pensate a due
persone che interloquiscono fra loro parlando la stessa lingua, se ad un certo punto uno dei due,
sostituisce parole note con altre provenienti da un linguaggio sconosciuto all'altro, esso avrebbe quanto
meno difficolt nel comprendere il senso del discorso. Di contro Python non infarcisce il suo lessico con
quantitativi di parole chiave come avviene in altri linguaggi, con i suoi pro e i suoi contro. Concludendo
quindi, meglio attenersi allo standard proposto da Python.
Qualsiasi funzione di un' oggetto essendo un' attributo di classe, definisce un metodo per le istanze della
classe stessa. Non necessario che la definizione della funzione sia inclusa nella definizione della classe.
E' possibile anche assegnare una funzione a una variabile locale nella classe. Per esempio:
#Funzionedefinitaaldifuoridellaclasse.
deffunzione_esterna(self,x,y):
returnmin(x,x+y)

classC:
f=funzione_esterna
defg(self):
return'helloworld'
h=g
Ora f, g e h sono tutti attributi della classe C che si riferiscono ad oggetti funzione, e di conseguenza
sono tutti metodi delle istanze di C essendo h esattamente equivalente a g. Questa pratica, viene di solito
usata per rendere pi difficile la comprensione di un sorgente ad altri programmatori.
I metodi possono chiamare altri metodi usando gli attributi metodo con l'argomento self:
classBag:
def__init__(self):
self.data=[]
defadd(self,x):
self.data.append(x)
defaddtwice(self,x):
self.add(x)
self.add(x)
I metodi possono referenziare nomi globali allo stesso modo come le funzioni ordinarie. La visibilit
globale associata a un metodo il modulo che contiene la sua definizione (Una classe non viene mai usata
con visibilit globale). Mentre non ci sono dei buoni motivi per usare dati globali in un metodo, ci sono
molti usi legittimi della visibilit globale: per dirne una, funzioni e moduli importati in ambito globale
possono essere utilizzati dai metodi, nonch funzioni e classi definite in esso. Di solito, la classe che
contiene il metodo ed essa stessa definita in questo ambito globale. Nella prossima sezione vedremo
alcune buone ragioni per cui un metodo potrebbe voler referenziare la propria classe.
Ogni valore un oggetto, e quindi ha una classe (chiamato anche tipo) e viene memorizzato come
object.__class__.

9.5. L'Ereditariet.
Naturalmente, un linguaggio che supporta le classi senza ereditariet non sarebbe degno di attenzione. La
sintassi per la definizione di una classe derivata (l'ereditariet appunto) si ottiene pi o meno cos:
classNomeClasseDerivata(NomeClasseBase):
<istruzione1>
.
.
.
<istruzionen>
Il nome NomeClasseBase deve essere definito in un ambito che contiene la definizione della classe
derivata. Al posto di un nome di classe base, sono ammesse anche altre espressioni arbitrarie. Ci pu
essere utile, per esempio, quando la classe base definita in un altro modulo:
classe NomeClasseDerivata (nomemodulo.NomeClasseBase)

Esecuzione di una definizione di classe derivata procede nello stesso modo di una classe base. Quando
l'oggetto di classe viene costruito, la classe base viene ricordata. Questo meccanismo viene utilizzato per
risolvere i riferimenti ad attributi: se un attributo richiesto non viene trovato nella classe, la ricerca
procede fino a guardare nella classe base. Questa regola viene applicata ricorsivamente se la classe base a
sua volta derivata da un'altra classe.
Non c' niente di speciale creazione di classi derivate: NomeClasseDerivata() crea una nuova
istanza della classe. I riferimenti ai metodi vengono risolti come segue: l'attributo classe corrispondente
viene cercato, salendo lungo la catena di classi base, se necessario, e il riferimento al metodo valido se
questo produce un oggetto funzione.
Le classi derivate possono sovrascrivere i metodi delle loro classi base. Poich i metodi non hanno
privilegi speciali quando chiamano altri metodi dello stesso oggetto, un metodo di una classe base che
chiama un altro metodo definito nella stessa classe base pu finire per chiamare un metodo di una classe
derivata che lo sovrascrive. (Per i programmatori C + +: tutti i metodi in Python sono effettivamente
virtual (virtuali)).
Generalmente la sovrascrittura di un metodo in una classe derivata, ha lo scopo di estenderne le
funzionalit piuttosto che sostituirlo in toto. Infatti a rigore di logica se a un metodo manca una
funzionalit, lo si sovrascrive aggiungendocela, se invece diverso, se ne crea uno nuovo anche se non
sempre cos. C' un modo semplice per chiamare direttamente il metodo della classe base: basta
chiamare NomeClasseBase.nomemetodo(self, argomenti). Questo talvolta risulta il suo
utilizzo (va detto che questo funziona solo se la classe base accessibile come NomeClasseBase in
ambito globale.)
Python dispone di due funzioni precostituite che funzionano con l'ereditariet:

isinstance() utilizzata per verificare il tipo di istanza: isinstance(oggetto, int)

sar vero solo se oggetto.__class__ di tipo int o di qualche classe derivata da int.

issubclass() utilizzata per verificare l'ereditariet della classe: issubclass(bool,

int) True in quanto bool una sottoclasse di int. Ma per esempio,
issubclass(float, int) risulta False in quanto float non una sottoclasse di
int.

9.5.1. Ereditariet Multipla.

Python supporta pure una forma di ereditariet multipla. Una definizione di classe con pi classi base che
assomiglia a questo:
classNomeClasseDerivata(ClasseBase1,ClasseBase2,ClasseBase3):
<istruzione1>
.
.
.
<istruzionen>
Per la maggior parte degli utilizzi, nei casi pi semplici, si pu pensare che la ricerca per gli attributi

ereditati da una classe genitore venga cercata scalando in profondit, da sinistra a destra, non cercando
due volte nella stessa classe in cui vi una sovrapposizione nella gerarchia. Cos, se un attributo non
viene trovato in NomeClasseDerivata, la ricerca avviene in ClasseBase1, poi (ricorsivamente)
nelle classi base di ClasseBase2, e se non stato trovato, si cerca in ClasseBase3, e cos via.
In verit, la cosa leggermente pi complessa. La risoluzione dell'ordine di un metodo cambia
dinamicamente per supportare chiamate cooperative a super(). Questo approccio noto in alcune altri
linguaggi con ereditariet multipla come call-next-method ed pi potente della chiamata super
presente in altri linguaggi a ereditariet singola.
L'ordinamento dinamico necessario in quanto tutti i casi di ereditariet multipla mostrano uno o pi
diamond relationships (cio una specie di relazionamento superiore) in cui almeno una delle classi
genitore pu accedere attraverso percorsi multipli della classe pi in basso. Ad esempio, tutte le classi
ereditano da object, cos che qualsiasi caso di ereditariet multipla fornisca pi di un percorso per
arrivare all'oggetto. Per mantenere le classi di base da cui si accede pi di una volta, l'algoritmo dinamico
linearizza l'ordine di ricerca in modo da preservare l'ordinamento da sinistra a destra specificato in ogni
classe, che chiama ciascun genitore solo una volta, e che monotona (cio una classe pu essere
sottoclasse senza influenzare l'ordine di precedenza dei suoi genitori). Nel loro insieme, queste
caratteristiche rendono possibile progettare classi affidabili ed estensibile con ereditariet multipla. Per
una spiegazione pi dettagliata e approfondita, vedere:
http://www.python.org/download/releases/2.3/mro/.

9.6. Variabili Private.

Le variabili d'istanza definite "Private" a cui non possibile accedere se non da all'interno di un oggetto
semplicemente non esistono in Python. Tuttavia, vi una convenzione che viene seguita dalla maggior
parte del codice Python: un nome preceduto da un carattere di sottolineatura (ad esempio _spam)
dovrebbe essere trattato come una parte non pubblica delle API (se si tratta di una funzione, un metodo o
un membro dati) . Dovrebbe essere considerato un dettaglio di implementazione e sono soggetti a
modifiche senza preavviso.
Poich esistono casi d'uso validi per i membri per classi-private (per evitare conflitti di nome con nomi
definiti dalle sottoclassi), c' un supporto limitato per un tale meccanismo, chiamato name mangling
(alterazione dei nomi). Qualsiasi identificatore nella forma __spam (con almeno due sottolineature
all'inizio e al massimo una sottolineatura finale) testualmente sostituita con _nomeclasse__spam,
dove nomeclasse il nome della classe corrente con la sottolineatura tolta. Questa ricomposizione
viene eseguita a prescindere dalla posizione sintattica dell'identificatore, fintanto che si verifica nella
notazione di una classe.
La ricomposizione dei nomi utile per fare in modo che sottoclassi sostituiscono i metodi senza rompere
le chiamate interclasse di metodo. Per esempio:
def__init__(self,iterable):
self.items_list=[]
self.__update(iterable)
defupdate(self,iterable):
foriteminiterable:
self.items_list.append(item)

__update=update#copiaprivatadelmetodooriginaleupdate()
classMappingSubclass(Mapping):
defupdate(self,keys,values):
#fornisceunanuovafirmaperupdate()
#manoninterrompe__init__()
foriteminzip(keys,values):
self.items_list.append(item)
Si noti che le regole di ricomposizione sono pensate principalmente per evitare incidenti, ancora
possibile accedere o modificare una variabile considerata privata questo pu anche rivrlarsi utile in
circostanze particolari, come nel debugging.
Notare che il codice passato a exec() o eval() non considera il nome della classe chiamante come
classe corrente, questo effetto simile all'istruzione global, il cui effetto ristretto in modo simile al
codice byte che viene compilato assieme. La stessa limitazione si applica a getattr(), setattr() e
delattr(), cos come quando si fa riferimento direttamente a __dict__.

9.7. Varie.
A volte utile avere un tipo di dati simile al "record" di Pascal o C tipo "struct", associare alcuni elementi
di dati denominati. Una definizione di classe vuota lo far bene:
classImpiegati:
pass
Marco=Impiegati()#Creaunrecordvuotoditipoimpiegati.
#Riempieicampidelrecord.
Marco.Soprannome='Marcol'incredibile'
Marco.Qualifica='Tecnicocomputer'
Marco.Stipendio=1000
Un pezzo di codice Python che prevede un particolare tipo di dato astratto pu essere invece passato a una
classe che emula i metodi di questo tipo di dati. Ad esempio, se si dispone di una funzione che formatta
alcuni dati da un oggetto file, possibile definire una classe con metodi read() e readline() che
ottenga invece i dati da un buffer di stringa, e passarlo come argomento.
L'istanza di metodi di oggetto, possiede anche degli attributi tipo: m.__self__ che l'oggetto istanza
con il metodo m(), e m.__func__ la funzione oggetto corrispondente al metodo.

9.8. Le Eccezioni Possono Essere Anche Classi.

Eccezioni definite dall'utente vengono identificate da classi pure. Utilizzando questo meccanismo
possibile creare gerarchie estendibili di eccezioni.

Ci sono due nuove forme (semantiche) valide per l'istruzione raise:

raiseClass
raiseInstance
Nella prima forma, Class deve essere un'istanza di type o di una classe derivata da essa. La prima
forma una scorciatoia per:
raiseClass()
Una clausola except in una classe compatibile con un'eccezione se si tratta della stessa classe o di una
classe base della stessa (ma non viceversa, una clausola except che riporti una classe derivata non
compatibile con una classe base). Ad esempio, il codice seguente stamper B, C, D in questo ordine:
classB(Exception):
pass
classC(B):
pass
classD(C):
pass
forclsin[B,C,D]:
try:
raisecls()
exceptD:
print("D")
exceptC:
print("C")
exceptB:
print("B")
Si noti che se la clausola except fosse state invertita (con except B per prima), sarebbe stato stampato
B, B, B - la prima clausola except verrebbe stata attivata.
Quando un messaggio di errore viene stampato per un'eccezione non gestita, prima viene stampato il
nome della classe seguito da due punti, poi uno spazio, e infine l'istanza convertita in una stringa
utilizzando la funzione precostituita str().

9.9. Iteratori.
Ormai probabilmente avete notato che la maggior parte degli oggetti possono essere iterati utilizzando
l'istruzione for:
forelementoin[1,2,3]:
print(elemento)
forelementoin(1,2,3):
print(elemento)
forchiavein{'uno':1,'due':2}:

print(chiave)
forstringain"123":
print(stringa)
forlineeinopen("miofile.txt"):
print(linee)
Questo codice, chiaro, conciso e conveniente. L'uso degli iteratori pervade e unifica Python. Dietro le
quinte, l'istruzione for chiama iter() sull'oggetto contenitore. La funzione restituisce un oggetto
iteratore che definisce il metodo__next__() che accede agli elementi nel contenitore uno alla volta.
Quando non ci sono pi elementi, __next__() solleva un'eccezione StopIteration che sancisce la
fine del ciclo for. possibile chiamare il metodo__next__() utilizzando la funzione precostituita
next(), questo esempio mostra come funziona il tutto:
>>>s='abc'
>>>prova=iter(s)
>>>prova
<provaiteratorobjectat0x00A1DB50>
>>>next(prova)
'a'
>>>next(prova)
'b'
>>>next(prova)
'c'
>>>next(prova)
Traceback(mostrecentcalllast):
File"<stdin>",line1,in?
next(prova)
StopIteration
Dopo aver visto i meccanismi alla base del protocollo iteratore, facile aggiungere un comportamento
iteratore alle vostre classi. Definire un metodo __iter__(), che restituisce un oggetto con un metodo
__next__(). Se la classe definisce __next__(), allora __iter__() pu semplicemente restituire
self:
classRovescia:
"""Ciclasuunasequenzarovesciata."""
def__init__(self,data):
self.data=data
self.index=len(data)
def__iter__(self):
returnself
def__next__(self):
ifself.index==0:
raiseStopIteration
self.index=self.index1
returnself.data[self.index]
>>>rovescia=Rovescia('spam')
>>>iter(rovescia)
<__main__.Rovesciaobjectat0x00A1DB50>
>>>forcarattereinrovescia:
...print(carattere)

...
m
a
p
s

9.10. Generatori.
I generatori (Generators) sono uno strumento semplice e potente per la creazione di iteratori. Sono scritti
come funzioni regolari, ma usano l'istruzione yield ogni volta che devono restituire i dati. Ogni volta
che next() viene chiamato su di esso, il generatore riprende da dove si era fermato (si ricorda tutti i
valori dei dati e l'ultima espressione eseguita). Un esempio mostra che i generatori possono essere
banalmente facili da creare:
defrovescia(dati):
forindiceinrange(len(dati)1,1,1):
yielddati[indice]
>>>forcarattereinrovescia('golf'):
...print(carattere)
...
f
l
o
g

Tutto ci che pu essere fatto con i generatori pu essere fatto anche con classi base iteratori come
descritto nella sezione precedente. Ci che rende i generatori cos compatti che i metodi __iter__()
e __next__() , vengono creati automaticamente.
Un'altra caratteristica fondamentale che le variabili locali ed il loro stato di esecuzione vengono salvati
automaticamente tra le chiamate. Questo ha reso la funzione pi facile da scrivere e molto pi chiara che
con un' approccio usando variabili di istanza come self.index e self.data.
Oltre alla creazione automatica del metodo e del salvataggio dello stato del programma, quando i
generatori terminano, sollevano automaticamente StopIteration. In combinazione, queste
caratteristiche rendono facile creare gli iteratori rispetto ad una funzione classica.

9.11. Generatore di Espressioni.

Alcuni generatori di espressioni semplici possono essere codificati in modo succinto utilizzando una
sintassi simile a quella lista di comprensione (comprehensions) ma con parentesi quadre ([ ]) invece di
parentesi tonde (( )). Queste espressioni sono progettate per situazioni in cui il generatore utilizza subito
una funzione inclusa. Esso pi compatto, ma meno versatile delle funzioni complete e tendono a
consumare pi memoria di un'equivalente lista di comprensione. Esempio:
>>>sum(i*iforiinrange(10))#sommadiquadrati
285

>>>xvec=[10,20,30]
>>>yvec=[7,5,3]
>>>sum(x*yforx,yinzip(xvec,yvec))#prodottoscalare
260
>>>frommathimportpi,sin
>>>sine_table={x:sin(x*pi/180)forxinrange(0,91)}
>>>parole_uniche=set(wordforlineinpageforwordin
line.split())
>>>graduatoria=max((student.gpa,student.name)forstudentin
graduates)
>>>data='golf'
>>>list(data[i]foriinrange(len(data)1,1,1))
['f','l','o','g']
[1] Tranne che per una cosa. Oggetti modulo hanno un attributo di sola lettura chiamato __dict__ che
restituisce il dizionario usato per implementare lo spazio dei nomi (namespace) del modulo nascosto,
il nome __dict__ un attributo ma non un nome globale. Ovviamente, questo vola (nel senso di
profanazione e non del colore) l'astrazione dell'implementazione dello spazio dei nomi, e dovrebbe
essere limitato a cose come i debugger post-mortem.

10. Panoramica Sulle Librerie Standard.

10.1. Interfaccia al Sistema Operativo.
Il modulo os fornisce molte funzioni per interagire con il sistema operativo:
>>>importos
>>>os.getcwd()#Restituiscelacartelladilavoroattuale.
'C:\\Python33'#MacchineWindows
'/home/utente'#macchineLinux
>>>os.chdir('/server/accesslogs')#Cambiacartella.
>>>os.system('mkdirtoday')#Lanciailcomandomkdirnellashell.
0
Accertatevi di utilizzare import os invece che from os import *. questo garantir l'utilizzo di
os.open() invece della funzione precostituita open() che opera in modo molto diverso.
Le funzioni precostituite dir() e help() sono utili per lavorare con moduli di grandi dimensioni come
os:
>>>importos
>>>dir(os)

<Restituiscelalistadituttiimodulifunzione>
>>>help(os)
<Restituisceunmanualecompletocreatodalmodulodocstrings>
Per la gestione di file e directory, il modulo shutil fornisce un'interfaccia di pi alto livello pi facile da
usare:
>>>importshutil
>>>shutil.copyfile('miei_dati.db','salvataggio_miei_dati.db')
>>>shutil.move('/build/executables','installdir')

10.2. File Jolly.

Il modulo glob fornisce una funzione per fare liste di file da directory e ricerche con i caratteri jolly:
>>>importglob
>>>glob.glob('*.py')
['primes.py','random.py','quote.py']

10.3. Argomenti della Linea di Comando.

Gli script di utilit spesso hanno bisogno di elaborare degli argomenti della riga di comando. Questi
argomenti vengono memorizzati nella attributi argv del modulo sys come un elenco. Per esempio il
comando python demo.py uno due tre produce i seguenti risultati:
>>>importsys
>>>print(sys.argv)
['demo.py','uno','due','tre']
Il modulo getopt processa sys.argv usando le convenzioni della funzione Unix getopt(). Per
un'elaborazione della riga di comando pi potente e flessibile, utilizzare le funzioni fornite dal modulo
argparse.

10.4. Reidirizzamento Output degli Errori e Terminazione

Programma.
Il modulo sys ha anche attributi per stdin, stdout, and stderr, cio l'input standard, l'uscita standard, e
l'output per gli errori. Quest'ultimo utile per l'emissione di avvisi e messaggi di errore per renderli
visibili anche quando stdout viene rediretto:
>>>sys.stderr.write('Avviso!Filelognontrovatoapertouno
nuovo.\n')
Avviso!Filelognontrovatoapertounonuovo.
Il modo pi diretto per terminare uno script usare sys.exit().

10.5. Corrispondenza di Stringhe.

Il modulo re fornisce gli strumenti per le espressioni regolari per processare le stringhe. Per la
corrispondenza complessa e la manipolazione, le espressioni regolari offrono soluzioni ottimizzate e
compatte:
>>>importre
>>>re.findall(r'\bf[az]*','unafotofattaconamicifuoriporta')
['foto','fatta','fuori']
>>>re.sub(r'(\b[az]+)\1',r'\1','gattonelsacco')
'gattonelsacco'
>>>'Fidounbelgatto'.replace('gatto','cane')
'Fidounbelcane'
Va notato che quando sono necessarie funzionalit semplici, i metodi di stringa sono preferiti perch sono
pi facili da leggere ed eseguire per il debug:

10.6. Matematica.
Il modulo di matematica math d accesso alle funzioni di libreria sottostanti C per la matematica in
virgola mobile:
>>>importmath
>>>math.cos(math.pi/4)
0.70710678118654757
>>>math.log(1024,2)
10.0
Il modulo random , fornisce strumenti per fare delle selezioni casuali:
>>>importrandom
>>>random.choice(['mela','pera','banana'])
'mela'
>>>random.sample(range(100),8)#campionamentosenzasostituzione
[30,83,16,4,8,81,41,50]
>>>random.random()#virgolamobilecasuale
0.17970987693706186
>>>random.randrange(6)#interocasualesu6numeri
4
Il progetto SciPy ha molti altri moduli per calcoli numerici vedere <http://scipy.org>.

10.7. Accesso a Internet.

Ci sono ovviamente anche una serie di moduli per l'accesso a Internet e per l'elaborazione dei protocolli
Internet. Due dei pi semplici sono urllib.request per il recupero dei dati da un' URL e smtplib
per l'invio di posta elettronica:

>>>fromurllib.requestimporturlopen
>>>forrigainurlopen('http://tycho.usno.navy.mil/cgi
bin/timer.pl'):
...righe=righe.decode('utf8')#Dadatibinariatesto
...if'EST'inrigheor'EDT'inrighe:#cercailTimeZone
...print(righe)
<BR>Nov.25,09:43:32PMEST

>>>importsmtplib
>>>server=smtplib.SMTP('localhost')
>>>server.sendmail('[email protected]','[email protected]',
..."""To:[email protected]
...From:[email protected]
...
...Rispondialpipresto.
...""")
>>>server.quit()
(Notare che nel secondo esempio, necessario che il server di posta attivo sia in localhost.)

10.8. Date e Tempo.

Il modulo datetime fornisce classi per manipolare date e orari in modo sia semplici che complesso.
Esso supporta la matematica sulle date e sugli orari, ma l'ottica dell'implementazione concentrata
sull'estrazione, la formattazione e la manipolazione degli elementi. Il modulo supporta anche oggetti per il
fuso orario.
>>>#Ledatesonofacilmentegestibili.
>>>fromdatetimeimportdate
>>>oggi=date.today()
>>>oggi
datetime.date(2014,1,25)
>>>oggi.strftime("%m%d%y.%d%b%Yisa%Aonthe%ddayof%B.")
'120203.25jan2014isaSaturdayonthe25dayofJanuary.'
>>>#Lafunzionesupportal'aritmeticadelledate.
>>>compleanno=date(1964,7,31)
>>>anni=nowcompleanno
>>>anni.days
14368

10.9. Compressione Dati.

La compressione dati per l'archiviazione viene supportata dai relativi moduli tra cui: zlib, gzip, bz2,
lzma, zipfile e tarfile.

>>>importzlib
>>>s=b'Nelmezzodelcamindinostravita......'
>>>len(s)
41
>>>t=zlib.compress(s)
>>>len(t)
37
>>>zlib.decompress(t)
b'Nelmezzodelcamindinostravita......'
>>>zlib.crc32(s)
3044838932

10.10. Misurazione delle Prestazioni.

Alcuni utilizzatori di Python sono incuriositi dall'efficienza del codice sviluppato a prescindere dal
problema. Quale sar il codice pi veloce? Python fornisce uno strumento di misura che risponde
immediatamente a queste domande.
Ad esempio, si pu essere tentati di utilizzare l'impacchettamento e lo spacchettamento di una tupla
caratteristica, invece del tradizionale approccio dello scambio di argomenti. Il modulo timeit, riesce a
dimostrare anche i pi piccoli vantaggi di prestazioni:
>>>fromtimeitimportTimer
>>>Timer('t=a;a=b;b=t','a=1;b=2').timeit()
0.57535828626024577
>>>Timer('a,b=b,a','a=1;b=2').timeit()
0.54962537085770791

In contrasto con timeit per il buon livello di granuralit, i moduli profile e pstats, forniscono
strumenti per identificare sezioni critiche su grandi blocchi di codice.

10.11. Controllo Qualit.

Un approccio per sviluppare software di alta qualit scrivere dei test per ogni funzione sviluppata ed
eseguire prove frequenti durante il processo di sviluppo.
Il modulo doctest fornisce uno strumento per la scansione di un modulo e la convalida di test inseriti
nella documentazione (docstring) del programma. La costruzione semplice come il taglio copia e incolla
e permette di inserire nella documentazione (docstring ) oltre al codice, anche i risultati riportati da un'
esempio per fare in modo che il tutto risulti pi chiaro. Questo migliora la documentazione da fornire
all'utente che con un semplice esempio, permette al modulo doctest di convalidare la documentazione:
defmedia(valori):
"""Calcolalamediaaritmeticadiunalistadinumeri.

>>>print(media([20,30,70]))
40.0
"""
returnsum(valori)/len(valori)
importdoctest
doctest.testmod()#Convalidaautomaticamenteitestintegrati.

Il modulo unittest non pi piacevole del modulo doctest, ma permette una serie pi completa e
capibile di test da essere mantenuto in un file separato:
importunittest
classTestStatisticalFunctions(unittest.TestCase):
deftest_average(self):
self.assertEqual(average([20,30,70]),40.0)
self.assertEqual(round(average([1,5,7]),1),4.3)
withself.assertRaises(ZeroDivisionError):
average([])
withself.assertRaises(TypeError):
average(20,30,70)
unittest.main()#Chiamatodallalineadicomando,chelanciatuttii
test

10.12. Tutto compreso.

Python ha una filosofia "tutto compreso". Questo si nota meglio attraverso le sofisticate e robuste
caratteristiche dei dei suoi pacchetti pi grandi. Per esempio:
I moduli xmlrpc.client e xmlrpc.server implementano chiamate a procedure remote
con un' utilizzo quasi banale. Nonostante i nomi dei moduli lo farebbero pensare, non necessaria
alcuna conoscenza diretta della gestione di XML.
Il package per la gestione delle email una libreria che comprende i MIME e altri messaggi di
documenti RFC basati su 2822. A differenza di smtplib e poplib che in realt inviano e
ricevono messaggi, il package email ha un set di strumenti completo per la costruzione o la
decodifica di complesse strutture di messaggi (allegati inclusi) per attuare la codifica internet e i
protocolli di intestazione.
I pacchetti xml.dom e xml.sax forniscono un robusto supporto per l'analisi e l'interscambio di
questo popolare formato di dati. Allo stesso modo, il modulo csv supporta la lettura e scrittura
diretta di un formato DataBase. L'insieme, questi moduli e pacchetti semplificano notevolmente lo
scambio di dati tra applicazioni Python e altri strumenti.
L'internazionalizzazione supportata da una serie di moduli, inclusi tra cui gettext, locale,
e il pacchetto di codecs.

11. Panoramica Sulle Librerie Standard Parte II.

Questa seconda panoramica copre i moduli pi avanzati che danno supporto alle esigenze di
programmazione professionali. Questi moduli raramente s'incontrano in piccoli script.

11.1. Output Formattato

Il modulo reprlib fornisce una versione di repr() su misura per i display piccoli o di grandi
dimensioni con molteplici nidificazioni di codice:
>>>importreprlib
>>>reprlib.repr(set('supercalifragilisticoespiralitoso'))
"set(['a','c','d','e','f','g',...])"
Il modulo di pprint (la p come prefisso a print, sta a pretty cio graziosa) offre un controllo pi
sofisticato su stampa sia precostituita che in oggetti definiti dall'utente in un modo che sia leggibile
dall'interprete. Quando il risultato pi lungo di una riga, la "stampa graziosa", aggiunge interruzioni di
riga e rientro per formattare pi chiaramente struttura dei dati rendendola pi intelleggibile per quanto
possibile:
>>>importpprint
>>>t=[[[['nero','ciano'],'bianco',['verde','rosso']],
[['magenta',
...'giallo'],'blu']]]
...
>>>pprint.pprint(t,width=30)
[[[['nero','ciano'],
'bianco',
['verde','rosso']],
[['magenta','giallo'],
'blu']]]
Il modulo textwrap formatta paragrafi di testo per adattarla ad una determinata larghezza dello
schermo:
>>>importtextwrap
>>>documento="""Ilmetodowrap()propriocomefill()eccettoche
restituisce
...unalistadistringheconcaratteridinuovalineainvecediuna
grossastringaunica."""
...
>>>print(textwrap.fill(documento,width=40))
Ilmetodowrap()propriocomefill()
eccettocherestituisceunalistadi
stringheconcaratteridinuovalinea
invecediunagrossastringaunica.
Il modulo locale accede ad un database specifico per le convezioni culturali per i formati di dati in uso

nei vari paesi in cui vengono utilizzati. L'attributo di raggruppamento della funzione format di locale
fornisce un modo diretto per la formattazione dei numeri con separatori di gruppo:
>>>importlocale
>>>locale.setlocale(locale.LC_ALL,'Inglese_StatiUniti.1252')
'Inglese_StatiUniti.1252'
>>>conv=locale.localeconv()#Acquisisceunamappaconvenzionale
>>>x=1234567.8
>>>locale.format("%d",x,grouping=True)
'1,234,567'
>>>locale.format_string("%s%.*f",(conv['currency_symbol'],
...conv['frac_digits'],x),grouping=True)
'$1,234,567.80'

11.2. Modellazione.
Il modulo string include una classe versatile Template (modello) con una sintassi semplificata
adatta alla modifica da parte di utenti finali. Questo permette di personalizzare le proprie applicazioni
senza dover modificare l'applicazione.
Il formato utilizza dei simboli come segnaposto formate da $ ed altri identificatori validi di Python
(caratteri alfanumerici e di sottolineatura) i quali all'interno di parentesi graffe, permettono la sostituzione
di blocchi di testo in modo dinamico. Scrivendo $ $ crea un unico $ altrimenti non rappresentabile:
>>>fromstringimportTemplate
>>>t=Template('${citt}quartiere110per$causale.')
>>>t.substitute(citt='Roma',causale='accessomusei')
'Romaquartiere110peraccessomusei.'
Il metodo substitute() solleva un KeyError quando un segnaposto non viene fornito in un
dizionario o in un' argomento chiave. Per le applicazioni in stile mail-merge, i dati degli utenti forniti
possono essere incompleti e il metodo safe_substitute() pu essere pi appropriato lasciando cos
il segnaposto invariato se mancano i dati non sollevando errori:
>>>t=Template('Restituisce$oggettoa$proprietario.')
>>>d=dict(item='bicicletta')
>>>t.substitute(d)
Traceback(mostrecentcalllast):
...
KeyError:'proprietario'
>>>t.safe_substitute(d)
'Restituiscebiciclettaa$proprietario.'
Modelli di sottoclassi, possono specificare un delimitatore personalizzato. Ad esempio, un lotto
ridenominato utilit per un visualizzatore di foto pu scegliere di utilizzare segni di percentuale per i
segnaposto come il formato di data corrente, numero di sequenza di immagini, o file:

>>>importtime,os.path
>>>FileFoto=['img_1074.jpg','img_1076.jpg','img_1077.jpg']
>>>classBatchRename(Modello):
...separatore='%'
>>>tmp=input('Stileformato(%ddate%nseqnum%fformat):')
Stileformato(%ddate%nseqnum%fformat):Marco_%n%f
>>>t=BatchRename(tmp)
>>>date=time.strftime('%d%b%y')
>>>fori,NomeFileinenumerate(FileFoto):
...base,ext=os.path.splitext(NomeFile)
...NuovoNome=t.substitute(d=date,n=i,f=ext)
...print('{0}>{1}'.format(NomeFile,NuovoNome))
img_1074.jpg>Marco_0.jpg
img_1076.jpg>Marco_1.jpg
img_1077.jpg>Marco_2.jpg
Un'altra applicazione di modellazione presente nella logica dei dettagli nei programmi in molteplici
formati di output. Ci rende possibile sostituire modelli personalizzati per i file XML, rapporti di testo, e i
rapporti web HTML.

11.3. Lavorare con i Data Record Layouts Binari.

Il modulo struct munito delle funzioni pack() e unpack() per lavorare con formati di record
binari di lunghezza variabili. L'esempio seguente mostra come scorrere le informazioni sull'intestazione
in un file ZIP senza utilizzare il modulo zipfile. I codici "H" e "I" rappresentano rispettivamente
numeri di due e quattro byte senza segno. '"<" indica che sono di dimensioni standard e l'ordine dei byte
di tipo little-endian:
importstruct
withopen('miofile.zip','rb')asf:
mieidati=f.read()
inizio=0
foriinrange(3):#mostraiprimi3file.
headers
inizio+=14
fields=struct.unpack('<IIIHH',mieidati[inizio:inizio+16])
crc32,comp_size,uncomp_size,filenamesize,extra_size=fields
inizio+=16
filename=mieidati[inizio:inizio+filenamesize]
inizio+=filenamesize
extra=mieidati[inizio:inizio+extra_size]
print(filename,hex(crc32),comp_size,uncomp_size)
inizio+=extra_size+comp_size#passaallaintestazionedopo

11.4. Multi-threading.
Il Threading una tecnica per il disaccoppiamento dei processi che non sono sequenzialmente dipendenti
e che vengono eseguiti in modo indipendente. I threads (i singoli processi) possono essere utilizzati per
migliorare la reattivit delle applicazioni che accettano input dell'utente mentre altre elaborazioni possono
essere eseguite in background (sottofondo). Un caso d'uso, pu essere quello relativo in funzione di I / O
in parallelo con i calcoli in un altro processo, oppure la scrittura di un file mentre si in attesa di un input
da tastiera.
Il seguente codice, mostra come il modulo di alto livello threading pu essere elaborato in
background mentre il programma principale continua a fare altre cose:
importthreading,zipfile#Importaiduemodulinecessari
classAsincrona(threading.Thread):
def__init__(self,infile,outfile):
threading.Thread.__init__(self)
self.infile=infile
self.outfile=outfile
defrun(self):
f=zipfile.ZipFile(self.outfile,'w',zipfile.ZIP_DEFLATED)
f.write(self.infile)
f.close()
print('Finishedbackgroundzipof:',self.infile)
background=Asincrona('mieidata.txt','mioarchivio.zip')
background.start()
print('Ilprogrammaprincipalesempreinprimopiano.')
background.join()#Aspettacheilprocessoinsecondopianotermini
print('Ilprogrammaprincipale,aspettacheilprocessotermini.')
Il principale problema che le applicazioni multi-threaded pongono, sta nella condivisione dei dati con
altre risorse. A tal fine, il modulo threading fornisce una serie di primitive di sincronizzazione, tra cui
blocchi, eventi, variabili di condizione, e semafori.
Con questi potenti strumenti, anche i minimi errori di progettazione, possono causare problemi difficili da
individuare. Quindi, l'approccio preferito per il coordinamento, quello di concentrare tutto l'accesso a
una risorsa in un singolo thread e di utilizzare quindi il modulo queue per alimentare il flusso con
richieste da altri thread. Le applicazioni che utilizzano oggetti queue per la comunicazione inter-thread
per il coordinamento sono pi facili da progettare, pi leggibili e pi affidabili.

11.5. Logging.
Il modulo logging offre un completo sistema di registrazione caratteristico e flessibile. Nel caso pi
semplice, i messaggi di log vengono inviati ad un file o al sys.stderr:

importlogging
logging.debug('Informazionedidebugging')
logging.info('Messaggio')
logging.warning('Attenzione:fileconfig%snontrovato',
'server.conf')
logging.error('Errore!')
logging.critical('Errorecriticouscita')
Che produce il seguente output:
WARNING:root:Attenzione:fileconfigfileserver.confnontrovato
ERROR:root:Errore!
CRITICAL:root:Errorecriticouscita
Per impostazione predefinita, i messaggi informativi e di debug sono soppressi e l'uscita viene inviata su
standard error. Altre opzioni di output includono l'instradamento dei messaggi tramite e-mail, datagrams,
sockets, o ad un server HTTP. Nuovi filtri possono scegliere un' instradamento diverso in base alla priorit
del messaggio: DEBUG, INFO, WARNING, ERROR, e CRITICAL.
Il sistema di registrazione pu essere configurato direttamente da Python o pu essere caricato da un file
di configurazione editabile dall'utente per la registrazione personalizzata senza modificare l'applicazione.

11.6. Referimenti deboli

Python fa una gestione automatica della memoria (il conteggio dei riferimenti per la maggior parte degli
oggetti e la garbage collection (pulizia della memoria) per eliminare cicli). La memoria viene liberata
appena l'ultimo riferimento ad essa stato eliminato.
Questo meccanismo funziona bene per la maggior parte delle applicazioni ma occasionalmente vi la
necessit di tenere traccia degli oggetti solo finch sono utilizzati da qualcos'altro. Purtroppo, proprio il
loro mantenimento crea di fatto un riferimento che li rende permanenti. Il modulo weakref fornisce gli
strumenti per il monitoraggio di oggetti senza creare un punto di riferimento. Quando l'oggetto non pi
necessario, viene rimosso automaticamente da una tabella del modulo weakref e una chiamata viene
attivata per gli oggetti. Le applicazioni tipiche comprendono oggetti di caching che sono costose da
creare:
>>>importweakref,gc
>>>classA:
...def__init__(self,value):
...self.value=value
...def__repr__(self):
...returnstr(self.value)
...
>>>a=A(10)#creaunareferenza
>>>d=weakref.WeakValueDictionary()
>>>d['primario']=a#noncreaunareferenza
>>>d['primario']#Recuperal'oggettoseattivo
10
>>>dela#rimuovel'unicareferenza
>>>gc.collect()#esegueilgarbagecollectionsubito
0
>>>d['primario']#statorimossoautomaticamente

Traceback(mostrecentcalllast):
File"<stdin>",line1,in<module>
d['primario']#statorimossoautomaticamente
File"C:/python33/lib/weakref.py",line46,in__getitem__
o=self.data[key]()
KeyError:'primario'

11.7. Strumenti per Lavorare con le Liste.

Molte strutture dati, si possono gestire con funzioni precostituite proprie, tuttavia, a volte vi la necessit
di implementazioni alternative con differenti prestazioni e compromessi.
Il modulo array (matrice) fornisce un' oggetto array() che come una lista che memorizza solo i
dati omogenei e li memorizza in modo pi compatto. L'esempio seguente mostra un array di numeri
memorizzati come due byte di numeri binari senza segno (typecode "H") anzich i soliti 16 byte per voce
per le liste regolari di oggetti tipo int di Python:
>>>fromarrayimportarray
>>>a=array('H',[4000,10,700,22222])
>>>sum(a)
26932
>>>a[1:3]
array('H',[10,700])
Il modulo collections fornisce un' oggetto deque() che come una lista con accodamento ma pi
veloce dal lato sinistro, ma con ricerche pi lente nel mezzo. Questi oggetti sono adatti per effettuare
code e grandi ricerche su strutture ad albero:
>>>fromcollectionsimportdeque
>>>d=deque(["compito1","compito2","compito3"])
>>>d.append("compito4")
>>>print("Collegamento",d.popleft())
Collegamentocompito1
noncercato=deque([nodo_partenza])
defampiezza_prima_ricerca(noncercato):
nodo=noncercato.popleft()
formingen_moves(nodo):
ifis_goal(m):
returnm
noncercato.append(m)
In aggiunta alla lista delle implementazioni, la libreria offre in alternativa anche altri strumenti come il
modulo bisect con funzioni per manipolare elenchi ordinati:
>>>importbisect
>>>punti=[(100,'perl'),(200,'tcl'),(400,'lua'),(500,

'python')]
>>>bisect.insort(punti,(300,'ruby'))
>>>punti
[(100,'perl'),(200,'tcl'),(300,'ruby'),(400,'lua'),(500,
'python')]
Il modulo heapq fornisce funzioni per l'attuazione di pile sulla base di liste regolari. La voce pi bassa
del valore sempre mantenuta in posizione zero. Questo utile per applicazioni che accedono
ripetutamente l'elemento di valore pi in basso, ma che non vogliono scorrere l'elenco completo ordinato:
>>>fromheapqimportheapify,heappop,heappush
>>>dati=[1,3,5,7,9,2,4,6,8,0]
>>>heapify(dati)#riarrangialalistanellapila
>>>heappush(dati,5)#aggiungeunnuovovalore
>>>[heappop(dati)foriinrange(3)]#estraeitrepipiccoli
[5,0,1]

11.8. Aritmetica Decimale in Virgola Mobile.

Il modulo decimal offre un tipo di dati Decimal per l'aritmetica decimale in virgola mobile. Rispetto
all'implementazione della funzione precostituita float questa classe specializzata viene in aiuto per:

Applicazioni finanziarie e altri usi che richiedono una rappresentazione decimale esatta.
Un controllo sulla precisione.
Un controllo sull' arrotondamento per soddisfare i requisiti legali o regolamentari.
Il monitoraggio di importanti cifre decimali.
Applicazioni in cui l'utente si aspetta che i risultati corrispondano ai calcoli fatti a mano.

Ad esempio, calcolare una tassa del 5% su una tariffa telefonica 70 centesimi d risultati diversi in virgola
mobile decimale rispetto al binario in virgola mobile. La differenza diventa significativa se i risultati sono
arrotondati al centesimo pi vicino:
>>>fromdecimalimport*
>>>round(Decimal('0.70')*Decimal('1.05'),2)
Decimal('0.74')
>>>round(.70*1.05,2)
0.73
A causa dei limiti hardware di ogni calcolatore, la precisione restituita dai numeri in virgola mobile
seppur precisa, sempre approssimativa quindi non adatta per certi usi. Decimal invece come gi
accennato sopra, permette di superare questo limite a prezzo di una minore velocit di calcolo. Decimal
permette di definire la precisione in termini di decimali dopo la virgola specificando quanti decimali ci
occorrono con risultati accurati la dove necessitano.
E' possibile inoltre con il modulo decimal definire la precisione dei numeri per tutto il programma o
parte di esso rendendoli come predefiniti.

>>>Decimal('1.00')%Decimal('.10')
Decimal('0.00')
>>>1.00%0.10
0.09999999999999995
>>>sum([Decimal('0.1')]*10)==Decimal('1.0')
True
>>>sum([0.1]*10)==1.0
False

>>>getcontext().prec=36
>>>Decimal(1)/Decimal(7)
Decimal('0.142857142857142857142857142857142857')

12. E Adesso?
La lettura di questa guida probabilmente ha suscitato l'interesse as utilizzare Python per risolvere i
problemi del mondo reale. Cosa si deve fare per saperne di pi?
Questa guida, parte di un gruppo di documentazione Python, altra documentazione possibile trovarla a
questi indirizzi:
The Python Standard Library:
Si consiglia di sfogliare questo manuale, che d un completo (anche se terse) riferimento materiale
sui tipi, funzioni e moduli della libreria standard. La distribuzione standard di Python comprende
un sacco di codice aggiuntivo. Ci sono moduli per leggere caselle di posta Unix, recuperare i
documenti via HTTP, generare numeri casuali, analizzare le opzioni della riga di comando,
scrivere programmi CGI, comprimere i dati, e molti altri compiti. Sfogliando il Reference Library
avrete un'idea di ci che disponibile.
Installing Python Modules spiega come installare moduli esterni scritti da altri utenti Python.
The Python Language Reference: Spiega in modo dettagliato la sintassi e la semantica di Python.
E una lettura un po' pesante, ma utile come una guida completa al linguaggio.
Ancora altre risorse:
http://www.python.org: Il principale sito web di Python. Esso contiene il codice, documentazione
e puntatori a pagine su Python in tutto il web. Questo sito Web si riflette in vari siti del mondo,
come Europa, Giappone e Australia, con una visibilit che pu essere pi veloce rispetto al sito
principale, a seconda della posizione geografica.
http://docs.python.org: L'accesso veloce alla documentazione di Python.
http://pypi.python.org: L'indice dei Packages Python, in precedenza anche soprannominato Cheese
Shop, un indice di moduli Python creati dagli utenti disponibili per il download. Una volta che si
inizia a scrivere del codice utile, puoi registrarti qui e mettere a disposizione degli altri dei moduli
tuoi in modo che possano essere scaricati.
http://aspn.activestate.com/ASPN/Python/Cookbook/: Il Python Cookbook un posto con una

raccolta considerevole di esempi di codice, di moduli pi grandi, e utili script. Contributi

particolarmente importanti sono raccolti anche in un libro intitolato Python Cookbook (O'Reilly
& Associates, ISBN 0-596-00797-3.)
http://scipy.org: Il progetto scientifico di Python che include i moduli per calcoli di matrice veloci
e manipolazioni, pi una serie di pacchetti per cose come l'algebra lineare, trasformate di Fourier,
solutori non lineari, le distribuzioni di numeri casuali, analisi statistica e simili.
Per domande correlate a Python e segnalazioni di problemi, possibile postare il comp.lang.python
newsgroup, o inviarli alla mailing list a [email protected]. Il newsgroup e mailing list sono
gatewayed, quindi i messaggi inviati ad uno verranno automaticamente inoltrati all'altro. Ci sono circa 120
messaggi al giorno (con punte fino a diverse centinaia), chiedendo (e rispondendo) alle domande,
suggerendo nuove funzionalit, e annunci di nuovi moduli. Prima di postare, assicurati di controllare la
lista delle domande pi frequenti (chiamate FAQ). Archivi delle mailing list sono disponibili a
http://mail.python.org/pipermail/. Le FAQ rispondono a molte delle domande che si susseguono, dove
potrebbe esserci la soluzione al vostro problema.

13. Input ed Editing Interattivo Sostituzioni e

Cronologia.
Alcune versioni di Python supportano l'editing della riga di input corrente e la sostituzione con la
cronologia, simili agli editor presenti nella shell Korn e la shell GNU Bash. Questo implementato
utilizzando la libreria GNU GNU Readline, che supporta lo stile Emacs e l'editing in stile vi. Questa
libreria ha la propria documentazione che non voglio duplicare qui, tuttavia, le basi sono facilmente
spiegabili. L'editing interattivo e la cronologia qui descritta sono disponibili a scelta nelle versioni Unix e
Cygwin dell'interprete.
Questo capitolo non documenta i servizi di editing del pacchetto PythonWin di Mark Hammond o
l'ambiente IDLE basato su Tk distribuito con Python. Il richiamo alla storia della riga di comando che
opera all'interno delle finestre DOS su NT e alcuni altri ricordi DOS e Windows sono un'altra bestia.

13.1. Editare le Linee.

Se supportato, l'editing della riga di input attivo ogni volta che l'interprete stampa un prompt primario o
secondario. L'attuale linea pu essere modificata usando i caratteri di controllo convenzionali di Emacs.
I pi importanti sono (CTRL sta per Control + tasto specifico):

CTRL-A sposta il cursore all'inizio della riga.

CTRL-E sposta il cursore alla fine.
CTRL-B lo muove di una posizione a sinistra.
CTRL-F lo muove di una posizione a destra.
BackSpace cancella il carattere a sinistra del cursore.
CTRL-D cancella il carattere alla sua destra.
CTRL-K elimina il resto della riga alla destra del cursore.
CTRL-Y ripristina l'ultima stringa eliminata.
CTRL-_ (sottolineatura) annulla l'ultima modifica effettuata, pu essere ripetuto per effetto
cumulativo.

13.2. Sostituzione cronologica.

La sostituzione cronologica funziona come segue. Tutte le linee di ingresso non vuote immesse vengono
salvati in una memoria storica sequenziale, e quando viene dato un nuovo prompt si posiziona su una
nuova riga in fondo a questa memoria. Quindi:

CTRL-P sposta di una riga verso l'alto (indietro) nella memoria storica.
CTRL-N si muove su una riga sotto (se esiste).
CTRL-S avvia una ricerca in avanti.

Ogni linea nella memoria storica, pu essere modificata. Premendo il tasto INVIO si passa la riga
corrente all'interprete.

13.3. Tasti Collegati.

Le associazioni dei tasti e alcuni altri parametri della libreria readline possono essere personalizzati
inserendo i comandi in un file di inizializzazione chiamato ~/.inputrc. Le associazioni dei tasti hanno
la seguente forma:
keyname:nomefunzione
oppure:
"stringa":nomefunzione
pi opzioni possono essere impostate con:
setnomeopzionevalore
Per esempio:
#Achipreferiscelostiledell'editorvi:
seteditingmodevi
#Editareusandounalineasingola:
sethorizontalscrollmodeOn
#Ridefinireilcollegamentodialcunitasti:
Metah:backwardkillword
"\Cu":universalargument
"\Cx\Cr":rereadinitfile
Si noti che l'associazione per il Tab in Python predefinito ad inserire un carattere di tabulazione invece
di una funzione di completamento di Readline. Volendo, possibile ignorare questo comportamento
immettendo:
Tab:complete
nel file vostro file ~/.inputrc. (Naturalmente, questo rende pi difficile le righe di continuazione
indentate se siete abituati ad usare Tab per tale scopo.)

Il completamento automatico dei nomi delle variabili e dei moduli disponibile come optional. Per
abilitarlo in modalit interattiva dell'interprete, aggiungere quanto segue al file di avvio: [1]
importrlcompleter,readline
readline.parse_and_bind('tab:complete')
La seconda riga, associa il tasto Tab per la funzione di completamento, questo premendo due volte il
tasto Tab.
Un file di impostazioni d'avvio evoluto, potrebbe essere simile a questo esempio. Si noti che questo
cancella i nomi che crea una volta che non sono pi necessari, questo viene fatto in quanto il file di avvio
viene eseguito nello stesso spazio dei nomi dei comandi interattivi, e la rimozione dei nomi evita effetti
collaterali per l'ambiente interattivo. Pu essere utile mantenere alcuni moduli importati, come os, che
risultano essere necessari nella maggior parte delle sessioni dell'interprete.

#Aggiungel'autocompletamentoeunfileperlacronologiacomandi.
#Vieneattivatoautocomplete.
#Settailtasto'Esc'comepredefinito(sipucambiare
#vederealdocumentazionereadline).
#Salvanelfile~/.pystartup,eimpostaunavariabileambiente
#acuipuntare.Che:"exportPYTHONSTARTUP=~/.pystartup"conbash.
importatexit
importos
importreadline
importrlcompleter
historyPath=os.path.expanduser("~/.pyhistory")
defsave_history(historyPath=historyPath):
importreadline
readline.write_history_file(historyPath)
ifos.path.exists(historyPath):
readline.read_history_file(historyPath)
atexit.register(save_history)
delos,atexit,readline,rlcompleter,save_history,historyPath

13.4. Alternative all'Interprete Interattivo Predefinito.

Le funzionalit di questo nuovo interprete, un enorme passo in avanti rispetto alle precedenti versioni
tuttavia, alcuni cose lasciano ancora a desiderare: Sarebbe bello se la corretta indentazione fosse possibile
su linee successive, magari aggiungendo un trattino di sottolineatura presente in altri linguaggi! (il parser
saprebbe distinguerlo). Poi il meccanismo di completamento potrebbe usare la tabella dei simboli
dell'interprete. Ancora un comando per controllare (o anche suggerire) le corrispondenze tra parentesi, le
citazioni, ecc, tutto ci, sarebbe molto utile. In effetti l'interprete standard cos com' non si preoccupa

molto dell'utente, presuppone un' utilizzatore che abbia grande dimestichezza con editor a linea di
comando del tipo vi ed un grande allenamento digitale.
Un'alternativa valida all'interprete interattivo IPython, che dispone del completamento automatico,
l'esplorazione degli oggetti e la gestione avanzata della cronologia. Inoltre esso, pu anche essere
accuratamente adattato e incorporato in altre applicazioni. Un ambiente interattivo avanzato simile
bpython. Un' altro editor molto utilizzato presente su tutte le piattaforme IDLE.
Note:
[1] Python eseguir i contenuti di un file identificato dalla variabile di ambiente PYTHONSTARTUP
quando si avvia l'interprete interattivo. Per personalizzare Python anche per la modalit noninterattiva, fare riferimento a The Customization Modules.

14. Aritmetica in Virgola Mobile: Problemi e

Limiti.
I numeri in virgola mobile sono rappresentati nell'hardware del computer in base due (binari). Ad
esempio, la frazione decimale:
0.125
Ha come valore 1/10 + 2/100 + 5/1000.
Allo stesso modo la frazione binaria:
0.001
Il cui valore 0/2 + 0/4 + 1/8, rappresenta lo stesso valore, l'unica vera differenza che il primo scritto
in notazione frazionaria base 10, e il secondo in base 2 (binaria).
Purtroppo, la maggior parte delle frazioni decimali non possono essere rappresentati esattamente come le
frazioni binarie. Una conseguenza che, in generale, i decimali numeri a virgola mobile inseriti sono solo
delle approssimazioni ai numeri in virgola mobile binari effettivamente memorizzati nella macchina.
Il problema pi facile da capire prima in base 10. Si consideri la frazione 1/3. Si pu approssimare che
come una frazione base 10:
0.3
o ancora pi preciso:
0.33
ancora pi preciso:
0.333
E cos via. Non importa quante cifre siete disposti a scrivere, il risultato non sar mai esattamente 1/3, ma
sar un sempre un'approssimazione di 1/3 al meglio.

Allo stesso modo, non importa quanti bit su base 2 siete disposti a utilizzare, il valore decimale 0.1 non
pu essere rappresentato esattamente come frazione in base 2. In base 2, 1/10 una frazione che si ripete
all'infinito.
0.0001100110011001100110011001100110011001100110011...
Risulta evidente che sia necessario uno stop all'approssimazione dei decimali in funzione di ci che si
vuole ottenere. Su molte macchine oggi, i numeri in virgola mobile, sono approssimati utilizzando una
frazione binaria con il numeratore che utilizza i primi 53 bit a partire dal bit pi significativo e con il
denominatore come una potenza di due. Nel caso di 1/10, la frazione binaria 3602879701896397 /
2 ** 55 che simile ma non esattamente uguale al valore reale di 1/10.
Molti utenti non sono consapevoli di questa approssimazione a causa del modo in cui vengono visualizzati
i valori. Python stampa solo una approssimazione decimale al valore decimale che l' approssimativo pi
vicino all'hardware della macchina su cui Python viene eseguito. Sulla maggior parte delle macchine, se
Python dovesse stampare il valore decimale vale per il ravvicinamento binario memorizzato per 0.1,
stamperebbe:
>>>0.1
0.1000000000000000055511151231257827021181583404541015625
Che ha cifre pi che sufficienti per la maggior parte degli utilizzatori, quindi Python mantiene il numero
di cifre ad alta approssimazione visualizzando per un valore arrotondato che pi umano.
>>>1/10
0.1
interessante notare che ci sono molti numeri decimali diversi che condividono la stessa vicina frazione
binaria approssimativa.
Ad esempio i numeri:
0.1
0.10000000000000001
0.1000000000000000055511151231257827021181583404541015625
sono tutti approssimati da 3602879701896397 / 2 ** 55. Dal momento che tutti questi valori decimali
condividono la stessa approssimazione, ognuno di loro potrebbe essere visualizzato utilizzando
eval(repr(x)) == x.
Storicamente, la funzione Python precostituita repr() dovrebbe scegliere quella con 17 cifre
significative 0.10000000000000001. Ma a partire da Python 3.1, sulla maggior parte dei sistemi ora in
grado di scegliere la pi breve rappresentazione e visualizzare semplicemente 0.1.
Si noti che questo nella natura stessa del binario in virgola mobile, non un bug in Python, e non un
bug generato dal codice. Vedrete la stessa cosa in tutti i linguaggi che supportano aritmetica in virgola
mobile sul vostro hardware (anche se in alcuni linguaggi potrebbero non visualizzare la differenza per
impostazione predefinita, o in tutte le modalit di uscita).

Per un' output pi piacevole, si potrebbe desiderare di utilizzare i numeri sotto forma di stringhe
formattate per visualizzare solo i decimali voluti.
>>>format(math.pi,'.12g')#Da12decimalisignificativi.
'3.14159265359'
>>>format(math.pi,'.2f')#Da2decimalisignificativi.
'3.14'
>>>repr(math.pi)
'3.141592653589793'
E 'importante rendersi conto che questa solo un' illusione. Si sta semplicemente arrotondando la
visualizzazione del vero valore per la propria macchina. Una illusione pu generarne un' altra. Per
esempio, dal 0.1 non corrisponde esattamente a 1/10, sommando tre valori di 0.1 non si pu produrre
esattamente 0.3, cio:
>>>.1+.1+.1==.3
False
Infatti la vera somma :
0.30000000000000004
Inoltre, dato che il 0.1 non pu ottenere il valore esatto di 1/10 e 0.3 non pu ottenere il valore esatto pi
vicino a 3/10, la funzione round(), ci pu venire in aiuto con un pre-arrotondamento:
>>>round(.1,1)+round(.1,1)+round(.1,1)==round(.3,1)
False
Anche se i numeri non possono essere resi pi vicini ai loro valori esatti previsti, la funzione round()
pu essere utile per il post-arrotondamento in modo che i risultati con i valori esatti diventino
confrontabili tra di loro:
>>>round(.1+.1+.1,10)==round(.3,10)
True
L'aritmetica binaria in virgola mobile riserva molte sorprese come questa. Il problema con "0.1"
spiegato qui sotto in modo pi dettagliato, nella sezione "Errori di rappresentazione". Vedere The Perils of
Floating Point (I pericoli della virgola mobile) per un resoconto pi completo ed altre sorprese.
Come che dice per finire, "non ci sono risposte facili." Comunque, non bisogna drammatizzare ed essere
eccessivamente cauti con i numeri in virgola mobile! Gli errori nelle operazioni che Python fa, vengono
ereditate dall'hardware sottostante, e sulla maggior parte delle macchine sono dell'ordine di non pi di 1
su 2 ** 53 per operazione. Questo pi che sufficiente per la maggior parte delle attivit, anche se va
tenuto conto che ad ogni operazione in virgola mobile pu subire un nuovo errore di arrotondamento,
infatti gli errori si sommano sempre non si sottraggono mai.
Mentre esistono casi patologici, nella maggior parte dell'uso occasionale in virgola mobile avrete il
risultato che vi aspettavate, semplicemente con il numero di cifre decimali che ci si aspetta. La funzione

str() di solito basta, mentre per un controllo pi preciso fare riferimento al metodo str.format()
meglio specificato in Format String Syntax.
Per i casi d'uso che richiedono una rappresentazione decimale pi esatta, provare a utilizzare il modulo
decimal che implementa l'aritmetica decimale adatto per applicazioni di contabilit e applicazioni di
alta precisione.
Un'altra forma di aritmetica esatta supportata dal modulo fractions che implementa aritmetica
basata sui numeri razionali (cos che i numeri 1/3 possono essere rappresentati esattamente).
Se sei un utente che fa uso pesante della virgola mobile, dai un'occhiata al pacchetto Numerical Python
Packagee ed in molti altri pacchetti per le operazioni matematiche e statistiche fornite dal progetto SciPy.
Vedere <http://scipy.org>.
Python fornisce strumenti che possono aiutare in quelle rare occasioni in cui davvero si vuole conoscere il
valore esatto di un numero in virgola mobile. Il metodo float.as_integer_ratio() esprime il
valore in virgola mobile come frazione:
>>>x=3.14159
>>>x.as_integer_ratio()
(3537115888337719,1125899906842624)
Poich il rapporto esatto, pu essere utilizzato per ricreare senza perdite il valore originale:
>>>x==3537115888337719/1125899906842624
True
Il metodo float.hex() rappresenta un valore in virgola mobile in esadecimale (base 16), anche in
questo caso il valore esatto quello memorizzato dal computer:
>>>x.hex()
'0x1.921f9f01b866ep+1'
Questa rappresentazione esadecimale precisa pu essere utilizzata per ricostruire esattamente il valore in
virgola mobile.
>>>x==float.fromhex('0x1.921f9f01b866ep+1')
True
Dal momento che la rappresentazione esatta, questa tecnica utile per scambiare in modo affidabile
valori tra le diverse versioni di Python (indipendenti dalla piattaforma) e lo scambio di dati con altri
linguaggi che supportano lo stesso formato (come Java e C99).
Un altro strumento utile la funzione math.fsum(), che consente di ridurre la perdita di precisione
durante la sommatoria. Essa tiene traccia delle cifre perdute negli arrotondamenti per poi recuperarle nel
finale. Questo pu fare la differenza nella precisione complessiva modo che gli errori non si accumulano
in modo significativo tali da inficiare il risultato finale.
>>>sum([0.1]*10)==1.0
False

>>>math.fsum([0.1]*10)==1.0
True

14.1. Errori di Rappresentazione.

Questa sezione illustra l'esempio "0.1" nel dettaglio, e mostra come possibile eseguire un'analisi esatta
in casi come questo da soli. Si assume che si abbia una certa familiarit con la rappresentazione in virgola
mobile.

Errori di rappresentazione si riferisce al fatto che alcune (la maggior parte, in realt), frazioni decimali
non possono essere rappresentate esattamente come nel formato binario (base 2). Questa la ragione
principale per cui Python (o Perl, C, C + +, Java, Fortran, e molti altri), spesso non visualizzano il numero
decimale esatto che ci si aspetta.
Ma perch cos? Perch 1/10 non esattamente rappresentabile come frazione binaria? Quasi tutte le
macchine di oggi utilizzano lo standard IEEE-754 per l'aritmetica in virgola mobile, e quasi tutte le
piattaforme di Python utilizzano IEEE-754 in "doppia precisione". Esso utilizza 53 bit di precisione, per
cui a comando il computer si sforza di convertire 0.1 alla frazione pi vicina che pu della forma J / 2 **
N dove J un intero contenente esattamente 53 bit. Scrivendo
1/10~=J/(2**N)

J~=2**N/10
ricordando che J ha esattamente 53 bit ( > = 2 ** 52 ma < 2 ** 53), il miglior valore per N 56:
>>>2**52<=2**56//10<2**53
True
Cio, il 56 l'unico valore per N che lascia J con esattamente 53 bit. Il valore migliore possibile per J
allora con quoziente arrotondato:
>>>q,r=divmod(2**56,10)
>>>r
6
Poich il resto pi della met di 10, la migliore approssimazione si ottiene arrotondando:
>>>q+1
7205759403792794
Pertanto la migliore approssimazione di 1/10 in 754 doppia precisione :
7205759403792794/2**56

Dividendo sia il numeratore che il denominatore per due riduce la frazione a:

3602879701896397/2**55
Si noti che da quando abbiamo arrotondato, questo in realt un po 'pi grande di 1/10; ma se non
avessimo arrotondato, il quoziente sarebbe stato un po' pi piccolo di 1/10. Ma in nessun caso pu essere
esattamente 1/10!
Cos il computer non "vede" 1/10, ma ci che vede la frazione esatta di cui sopra, con la miglior doppia
approssimazione che lo standard 754 pu ottenere:
>>>0.1*2**55
3602879701896397.0
Se moltiplichiamo la frazione per 10 ** 55, possiamo vedere il valore a 55 cifre decimali:
>>>3602879701896397*10**55//2**55
1000000000000000055511151231257827021181583404541015625
il che significa che il numero esatto memorizzato nel computer uguale al valore decimale
0.1000000000000000055511151231257827021181583404541015625. Invece di visualizzare il valore
decimale pieno, molti linguaggi (comprese le vecchie versioni di Python), arrotondano il risultato a 17
cifre significative:
>>>format(0.1,'.17f')
'0.10000000000000001'
I moduli fractions e decimal, permettono una facile gestione dei decimali:
>>>fromdecimalimportDecimal
>>>fromfractionsimportFraction
>>>Fraction.from_float(0.1)
Fraction(3602879701896397,36028797018963968)
>>>(0.1).as_integer_ratio()
(3602879701896397,36028797018963968)
>>>Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>>format(Decimal.from_float(0.1),'.17')
'0.10000000000000001'