#LyX 1.1 created this file. For more info see http://www.lyx.org/
\lyxformat 2.16
\textclass linuxdoc
\language italian
\inputencoding latin1
\fontscheme default
\graphics default
\paperfontsize 12
\spacing onehalf 
\papersize a4paper
\paperpackage a4
\use_geometry 0
\use_amsmath 0
\paperorientation portrait
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\defskip medskip
\quotes_language english
\quotes_times 2
\papercolumns 1
\papersides 1
\paperpagestyle default

\layout Title
\added_space_top vfill \added_space_bottom vfill 
Python: facile, pulito, potente
\layout Author

Magnus Lie Hetland e Alex Martelli
\layout Section

Cos'è Python? 
\layout Standard

Python é un linguaggio interpretato, interattivo, orientato agli oggetti;
 può essere, per vari aspetti, paragonato a linguaggi come Tcl, Perl, e
 Java.
 
\layout Standard

Python combina una potenza notevole con una sintassi particolarmente limpida;
 la sua implementazione, estremamente portatile, é disponibile per tanti
 tipi di Unix, Linux, Windows, DOS, OS/2, Mac, Amiga...
 nella versione Jython, in particolare, Python può appoggiarsi a una macchina
 virtuale Java, e quindi girare dovunque Java sia disponibile (ad esempio,
 come applet all'interno di un browser).
 
\layout Standard

É un linguaggio solido e stabile: il suo sviluppo, iniziato dall'autore
 Guido van Rossum nel 1990 presso il CWI di Amsterdam, continuó poi al CNRI
 di Reston, Virginia, successivamente presso i PythonLabs della BeOpen Inc.,
 e oggi presso l'azienda Digital Creations.
 Tutte le varie implementazioni e le librerie di Python sono Open Source.
\layout Standard

Vari siti Web come 
\begin_inset LatexCommand \url{http://www.python.org}

\end_inset 

, 
\begin_inset LatexCommand \url{http://www.pythonware.com/daily/}

\end_inset 

, 
\begin_inset LatexCommand \url{http://www.vex.net/~x/parnassus/}

\end_inset 

 (e, in italiano, il sito 
\begin_inset LatexCommand \url{http://web.tiscalinet.it/python}

\end_inset 

) contengono molto materiale utile sul linguaggio, e una dovizia di puntatori
 ad altri materiali.
\layout Section

Interpretato o compilato? 
\layout Standard

Python, come Java o Perl, é in realtà entrambe le cose -- sia compilato,
 sia interpretato.
\layout Standard

Il compilatore Python trasforma il testo (codice sorgente) dei nostri programmi
 in un codice intermedio, detto byte-code, che può essere visto come "codice-mac
china" per una macchina "virtuale" studiata apposta per eseguire programmi
 Python; l'interprete Python vero e proprio é una implementazione in software
 di questa macchina virtuale.
 Come in Perl, e a differenza che in Java, si può richiedere direttamente
 l'esecuzione dei file-sorgente (normalmente con estensione .py), senza necessità
 di un esplicito passaggio di compilazione; come in Java, e a differenza
 che in Perl, il byte-code non viene solo preparato "al volo" in memoria,
 ma viene anche salvato su disco (con estensione .pyc), cosí che in esecuzioni
 successive non occorrerà compilarlo nuovamente (la compilazione é però
 automaticamente ri-eseguita se il file sorgente é piú aggiornato di quello
 contenente il byte-code).
\layout Standard

Esistono compilatori Python che producono codice per altre macchine virtuali:
 Jython produce bytecode per una JVM (file .class), Python.NET produce il
 codice-intermedio MSIL tipico della nuova piattaforma .NET (file .msil).
 La 
\begin_inset Quotes eld
\end_inset 

versione-base
\begin_inset Quotes erd
\end_inset 

 di Python, essendo scritta in C (sia il compilatore, sia la macchina virtuale),
 è anche denominata C-Python ove occorra distinguerla da Jython e Python.NET;
 è sul classico C-Python che ci concentreremo in questo articolo (non che
 le altre versioni ne differiscano molto!).
\layout Section

Per cosa si usa Python? 
\layout Standard

Come altri linguaggi di scripting, come Tcl e Perl, Python é particolarmente
 adatto per compiti come le operazioni di Web (server-side, sotto forma
 di script CGI, ovvero con architetture piú moderne, come FastCGI, mod_python,
 etc; client-side, "entro il browser", opzione per cui Python offre varie
 possibilità -- JPython permette di usare Python per scrivere applet al
 posto di Java, Active Scripting permette di usare Python al posto, ad esempio,
 di Javascript -- esiste anche un browser, detto Grail, scritto interamente
 in Python).
\layout Standard

Lo scripting (Python in particolare) é poi ideale per vari compiti di gestione
 di sistema (al posto dei deboli, scomodi shell-script), come colla fra
 componenti scritti in altri linguaggi (ad esempio, Python é ampiamente
 usato a questo scopo nell'ambito del calcolo scientifico), e, facilmente
 incorporato in applicazioni (magari ricche e complesse), per la personalizzazio
ne e automatizzazione delle applicazioni stesse.
\layout Standard

Ma, per Python, questo é solo l'inizio.
\layout Standard

La sua unica combinazione di potenza, semplicità, e pulizia, lo rendono
 ideale per compiti di prototipazione (sviluppo esplorativo di componenti
 che, se occorre, possono poi eventualmente essere reimplementati ad esempio
 in C) e anche per la scrittura di interi, complessi sistemi (Zope, 
\begin_inset LatexCommand \url{http://www.zope.org}

\end_inset 

, é ad esempio interamente in Python, e lo stesso può dirsi per molta dell'infra
struttura di popolari servizi disponibili in rete, come eGroups, Google,
 Infoseek, Yahoo, ...).
\layout Standard

Sempre a titolo di esempio, segnaliamo anche un semplice DBMS relazionale
 SQL (transazionale, con la possibilità di uso client/server in TCP/IP),
 
\emph on 
Gadfly
\emph default 
, interamente scritto in Python -- vedi 
\begin_inset LatexCommand \url{http://www.chordate.com/kwParsing/gadfly.html}

\end_inset 

 (le sue prestazioni su database grossi possono essere 
\emph on 
sostanzialmente
\emph default 
 migliorate usando, per i bassissimi livelli, il modulo scritto in C 'kjBuckets'
; e anche questo è tipico: una volta che l'intera architettura di un sistema,
 sviluppata in Python, permette di individuare i 
\emph on 
colli di bottiglia
\emph default 
 computazionali, un'ultima ottimizzazione può compiersi codificando in C
 o C++ i 
\emph on 
bassissimi livelli
\emph default 
 di questi colli di bottiglia).
 Anche Gadfly è liberamente e gratuitamente scaricabile ed utilizzabile,
 secondo il modello Open Source.
\layout Section

Da dove comincio?
\layout Standard

Scarica e installa l'ultima versione di Python dal sito 
\begin_inset LatexCommand \url{http://www.python.org/}

\end_inset 


\begin_float footnote 
\layout Standard

Gli esempi che seguono si riferiscono a Python versione 2.0 o superiore.
\end_float 
 (puoi trovare il tarball dei sorgenti o il pacchetto RPM direttamente da
 installare, oltre alle versioni di altri sistemi operativi e la documentazione
 da leggere on-line o da stampare).
 Accertati che la directory d'installazione sia nel 
\family typewriter 
\lang american
PATH
\family default 
\lang italian
 (automatico se installi da RPM).
 Hai ora a disposizione un ambiente integrato di sviluppo (si chiama 
\family typewriter 
\lang american
idle
\family default 
\lang italian
, e comprende editor specializzato, interprete interattivo, debugger, class
 browser, documentazione...) e un piú semplice programma chiamato 
\family typewriter 
\lang american
python
\family default 
\lang italian
, meno ricco e potente ma piú facile da imparare ad usare -- ci concentriamo
 su quest'ultimo, ma conviene sicuramente anche esplorare 
\family typewriter 
\lang american
idle
\family default 
\lang italian
, che alla lunga può offrire notevoli comodità.
 Eseguendo 
\family typewriter 
\lang american
python
\family default 
\lang italian
 senza argomenti da qualsiasi shell, otterrai una risposta del tipo:
\layout Verbatim

Python 2.0b2 (#6, Sep 26 2000, 14:59:21) [gcc 2.9.37 (Intel)] on linux 
\layout Verbatim

Type "copyright", "credits" or "license" for more information.
 
\layout Verbatim

>>> 
\layout Standard

e puoi immettere interattivamente codice Python al prompt '
\family typewriter 
\lang american
>>>
\family default 
\lang italian
' -- verrà eseguito immediatamente, il che é comodo per provare.
 Ad esempio, immettendo la riga di codice: 
\layout Verbatim


\lang american
print "Hello, world!"
\layout Standard

il messaggio verrà visualizzato.
 Alla fine, premerai 
\family typewriter 
\lang american
Ctrl-D
\family default 
\lang italian
 per terminare la sessione interattiva di Python.
 Per programmare "davvero", scriverai il codice Python, con qualsiasi editor
 di testi (ad esempio, 
\family typewriter 
\lang american
vim
\family default 
\lang italian
), in un file di testo (chiamato, ad esempio, 
\family typewriter 
\lang american
hello.py
\family default 
\lang italian
), e lo eseguirai (da una shell) col comando: 
\layout Verbatim


\lang american
python hello.py
\layout Standard

se 
\family typewriter 
\lang american
hello.py
\family default 
\lang italian
 contiene la stessa, unica riga 
\family typewriter 
\lang american
print "Hello, world!"
\family default 
\lang italian
, anche questo mostrerà lo stesso messaggio.
 Esistono inoltre altri modi di rendere direttamente eseguibile un file
 di testo contenente un programma (
\emph on 
script
\emph default 
) Python: su Linux, basta renderlo eseguibile con il comando 
\family typewriter 
\lang american
chmod +x
\family default 
\lang italian
 e assicurarsi che inizi con una prima riga del tipo:
\layout Verbatim


\lang american
#!/usr/bin/env python
\lang italian
 
\layout Standard

Il programma 
\family typewriter 
\lang american
hello.py
\family default 
\lang italian
 potrà ora venire eseguito direttamente digitandone il nome (ed eventualmente
 il directory, come per qualsiasi altro programma) da qualsiasi shell.
\layout Section

Com'é fatto Python?
\layout Standard

Python é praticamente 
\emph on 
pseudo-codice eseguibile
\emph default 
.
 Una variabile non ha tipo e non viene dichiarata: appare quando le si assegna
 qualcosa, sparisce quando non la si usa piú.
 L'assegnazione si ottiene con l'operatore 
\family typewriter 
\lang american
=
\family default 
\lang italian
 ; l'eguaglianza si controlla con l'operatore 
\family typewriter 
\lang american
==
\family default 
\lang italian
.
 Si possono assegnare molteplici variabili simultaneamente: 
\layout Itemize


\family typewriter 
\lang american
x,y,z = 1,2,3
\family default 
\lang italian
 
\layout Itemize


\family typewriter 
\lang american
prima, seconda = seconda, prima
\family default 
\lang italian
 
\layout Itemize


\family typewriter 
\lang american
a = b = 123
\layout Standard

I blocchi sono indicati dall'indentazione, e solo dall'indentazione (niente
 
\family typewriter 
\lang american
BEGIN/END
\family default 
\lang italian
, niente parentesi graffe).
 Una struttura di controllo fondamentale é 
\family typewriter 
\lang american
if
\family default 
\lang italian
 (questi due esempi sono equivalenti) : 
\layout Verbatim

if x < 5 or (x > 10 and x < 20): 
\layout Verbatim


\lang american
    print "Il valore é OK."   # qui siamo dentro il blocco if
\layout Verbatim


\lang american
# qui siamo fuori dal blocco if
\layout Verbatim

\layout Verbatim

if x < 5 or 10 < x < 20: 
\layout Verbatim

    print " Il valore é OK."
\layout Standard

Ci sono poi i cicli: 
\layout Verbatim

for i in [1,2,3,4,5]: 
\layout Verbatim

    print "Iterazione numero", i
\layout Verbatim

\layout Verbatim

x = 10 
\layout Verbatim

while x >= 0: 
\layout Verbatim

    print "x non é ancora negativo"
\layout Verbatim

    x = x-1
\layout Standard

La variabile-indice del ciclo 
\family typewriter 
\lang american
for
\family default 
\lang italian
 itera sugli elementi di una lista (una costante lista può essere scritta
 con parentesi quadre e virgole, come nell'esempio).
 Per fare un "normale" ciclo di 
\family typewriter 
\lang american
for
\family default 
\lang italian
 (cioè uno in cui la variabile indice itera su di una sequenza di numeri),
 si può usare la funzione intrinseca 
\family typewriter 
\lang american
range()
\family default 
\lang italian
: 
\layout Verbatim


\lang american
# Stampa i numeri da 0 a 99 inclusi 
\layout Verbatim


\lang american
for value in range(100): 
\layout Verbatim


\lang american
    print value 
\layout Standard

(La riga che inizia con 
\family typewriter 
\lang american
#
\family default 
\lang italian
 é un commento, e viene quindi ignorata da Python).
 Attenzione: Python (come Java, C, C++,...) é case-sensitive -- 
\family typewriter 
\lang american
x
\family default 
\lang italian
 e 
\family typewriter 
\lang american
X
\family default 
\lang italian
 sono due variabili differenti...
 non é un problema, ma attenzione che questo non provochi errori!
\layout Section

I/O in Python
\layout Standard

Quanto visto finora basta (in teoria) per implementare qualsiasi algoritmo
 in Python ed emettere i risultati su standard output.
 Aggiungiamo alcuni fondamenti di input/output.
 Per avere input dall'utente tramite un prompt di testo, si usa la funzione
 intrinseca 
\family typewriter 
\lang american
input
\family default 
\lang italian
: 
\layout Verbatim


\lang american
x = input("Immetti un numero: ") 
\layout Verbatim


\lang american
print "Il quadrato di", x, "é", x*x
\layout Standard

La funzione 
\family typewriter 
\lang american
input
\family default 
\lang italian
 mostra il prompt passatole (che può essere vuoto) e aspetta che l'utente
 immetta una qualsiasi espressione Python.
 In questo caso ci serve un numero -- se viene immesso qualcosa d'altro,
 tipo una stringa, il programma va in errore (queste eccezioni possono essere
 gestite, ma qui non ce ne occuperemo).
\layout Standard

Se si desidera che l'input dell'utente sia mantenuto alla lettera come stringa
 (stringa, allora, del tutto arbitraria), si userà invece la funzione intrinseca
 
\family typewriter 
\lang american
raw_input
\family default 
\lang italian
 (per convertire una stringa 
\family typewriter 
\lang american
s
\family default 
\lang italian
 ad intero, si potrà poi usare 
\family typewriter 
\lang american
int(s)
\family default 
\lang italian
).
\begin_float footnote 
\layout Standard

Per immettere una stringa in risposta ad input, l'utente dovrá usare le
 virgolette (le stringhe Python possono essere racchiuse fra virgolette
 semplici o doppie, non fa alcuna differenza).
\end_float 
 Spesso si vogliono leggere e scrivere file di testo; anche questo é facile
 -- ad esempio, per copiare "
\family typewriter 
\lang american
fin.txt
\family default 
\lang italian
" su "
\family typewriter 
\lang american
fou.txt
\family default 
\lang italian
" si può scrivere (leggendo subito tutte le righe, poi eseguendo un ciclo
 su tutto l'insieme delle righe lette): 
\layout Verbatim


\lang american
fou=open("fou.txt","w")
\layout Verbatim


\lang american
for line in open("fin.txt").readlines():
\layout Verbatim


\lang american
    fou.write(line)
\layout Standard

In alternativa, e in modo del tutto equivalente, si puó leggere una sola
 riga alla volta: 
\layout Verbatim

fou=open("fou.txt","w")
\layout Verbatim

fin=open("fin.txt","r")
\layout Verbatim

while 1:
\layout Verbatim

    line = fin.readline()
\layout Verbatim

    if not line:
\layout Verbatim

        break
\layout Verbatim

    fou.write(line)
\layout Standard

(
\family typewriter 
\lang american
break
\family default 
\lang italian
 interrompe il ciclo corrente).
 
\layout Standard

Il secondo argomento della funzione intrinseca 
\family typewriter 
\lang american
open
\family default 
\lang italian
 dice se stiamo aprendo il file in lettura o in scrittura; é facoltativo,
 e il default é la lettura.
 
\family typewriter 
\lang american
readlines
\family default 
\lang italian
 restituisce tutte le righe, in sequenza, pronte ad esempio per un'interazione
 con 
\family typewriter 
\lang american
for
\family default 
\lang italian
; 
\family typewriter 
\lang american
readline
\family default 
\lang italian
 (al singolare, cioè senza la 
\family typewriter 
\lang american
s
\family default 
\lang italian
 finale) restituisce solo 
\emph on 
la prossima riga
\emph default 
 ogni volta che viene chiamata (ovvero, un valore falso, se non vi sono
 piú righe da restituire).
 Un'altra possibilità molto comoda per la lettura di file di testo é offerta
 dal modulo 
\family typewriter 
\lang american
fileinput
\family default 
\lang italian
, che illustreremo fra breve.
\layout Standard

A volte, si vogliono formattare dei dati ottenendo una stringa (ad esempio
 per emetterla); questo si può fare con l'operatore 
\family typewriter 
\lang american
%
\family default 
\lang italian
, che prende sulla sinistra una stringa di formato (molto simile alla stringa
 di formato di una 
\family typewriter 
\lang american
printf
\family default 
\lang italian
 del C) e sulla destra una sequenza di valori, e restituisce una stringa.
 Ad esempio, per numerare le righe emesse, il ciclo potrebbe essere modificato
 nel modo seguente : 
\layout Verbatim

fou=open("fou.txt","w")
\layout Verbatim

fin=open("fin.txt","r")
\layout Verbatim

i=0
\layout Verbatim

while 1:
\layout Verbatim

    line = fin.readline()
\layout Verbatim

    if not line:
\layout Verbatim

        break
\layout Verbatim

    i=i+1
\layout Verbatim

    fou.write("%d: %s" % i, line)
\layout Section

Liste
\layout Standard

Sinora, abbiamo illustrato le strutture di controllo e l'input/output --
 ora, ci servono delle belle strutture dati.
 Le piú importanti sono liste e dizionari.
 Le liste si scrivono con parentesi quadre e virgole, e (naturalmente) possono
 anche essere annidate:
\layout Verbatim

name = ["Cleese", "John"]
\layout Verbatim

x = [ [1,2,3], [y,z], [ [ [ ] ] ] ]
\layout Standard

Data una lista, se ne possono accedere gli elementi separatamente o a gruppi,
 con i costrutti di indexing e slicing.
 L'indexing si ottiene (come in molti altri linguaggi) giustapponendo l'indice
 fra parentesi quadre alla lista (il primo elemento ha indice 
\family typewriter 
\lang american
0
\family default 
\lang italian
): 
\layout Verbatim

>>> print name[1],name[0]
\layout Verbatim

John Cleese
\layout Verbatim

>>> name[0] = "Smith"
\layout Standard

Lo slicing (alla lettera, 
\emph on 
affettamento
\emph default 
) é quasi come l'indexing, eccetto che si scrivono sia l'indice iniziale
 sia quello finale del risultato, con un carattere di due-punti ("
\family typewriter 
\lang american
:
\family default 
\lang italian
") per separarli: 
\layout Verbatim

>>> x=['spam','spam','spam','spam','spam','eggs','and','spam']
\layout Verbatim

>>> print x[5:7]
\layout Verbatim

['eggs','and']
\layout Standard

Notiamo che la fine é non-compresa.
 Se manca uno degli indici nello slicing, si prende 
\begin_inset Quotes eld
\end_inset 

tutto in quella direzione
\begin_inset Quotes erd
\end_inset 

.
 Ad esempio, 
\family typewriter 
\lang american
list[:3]
\family default 
\lang italian
 significa "ogni elemento dall'inizio di list sino all'elemento 3, non compreso"
, cioè i primi 3 elementi, esattamente come 
\family typewriter 
\lang american
list[0:3]
\family default 
\lang italian
.
 Invece, 
\family typewriter 
\lang american
list[3:]
\family default 
\lang italian
 significa "ogni elemento di 
\family typewriter 
\lang american
list
\family default 
\lang italian
 a partire dall'elemento 3 (compreso) sino all'ultimo (compreso)".
 
\layout Standard

Sia nell'indexing, sia nello slicing, si possono usare anche indici negativi,
 che indicano di 
\begin_inset Quotes eld
\end_inset 

contare dalla fine
\begin_inset Quotes erd
\end_inset 

 : 
\family typewriter 
\lang american
list[-3]
\family default 
\lang italian
, ad esempio, indica il terzo elemento dalla fine della lista.
\layout Standard

Si puó anche assegnare una lista di qualsiasi lunghezza ad una slice di
 una lista: 
\layout Verbatim

y = ["fee","fie","foo","fum"] 
\layout Verbatim

y[1:-1] = ["bar","baz","bat"] 
\layout Standard

mette in 
\family typewriter 
\lang american
y
\family default 
\lang italian
 la lista 
\family typewriter 
\lang american
['fee', 'bar', 'baz', 'bat', 'fum']
\family default 
\lang italian
: infatti, la "slice" escludeva solo il primo e l'ultimo elemento (quindi,
 si trattava dei due elementi 
\family typewriter 
\lang american
"fie"
\family default 
\lang italian
 e 
\family typewriter 
\lang american
"foo"
\family default 
\lang italian
), ed é stata sostituita, dall'istruzione di assegnamento, con i tre elementi
 elencati.
 La funzione intrinseca 
\family typewriter 
\lang american
len
\family default 
\lang italian
 dà la lunghezza di una lista; ad esempio, per qualsiasi lista 
\family typewriter 
\lang american
a
\family default 
\lang italian
, 
\family typewriter 
\lang american
a[len(a)-1]
\family default 
\lang italian
 é sempre esattamente equivalente ad 
\family typewriter 
\lang american
a[-1]
\family default 
\lang italian
 (l'ultimo elemento della lista).
\layout Standard

Tutto questo funziona anche con le stringhe:
\layout Verbatim


\lang american
s="internazionalizzazione" 
\layout Verbatim


\lang american
print s[5:7] # emette la stringa "na" 
\layout Standard

eccetto che, per le stringhe, non si possono fare assegnamenti ai risultati
 di slicing e indexing, perché le stringhe, a differenza delle liste, sono
 
\emph on 
immutabili
\emph default 
.
 Le liste hanno anche altri metodi di mutazione (non applicabili alle stringhe,
 per la stessa ragione), come 
\family typewriter 
\lang american
mylist.append(value)
\family default 
\lang italian
, che aggiunge un valore alla fine della lista (allungandola quindi di un
 elemento), e 
\family typewriter 
\lang american
mylist.sort()
\family default 
\lang italian
, che permuta gli elementi della lista per assicurare che essa sia ordinata.
 Le liste (e le stringhe) possono essere concatenate usando l'operatore
 
\family typewriter 
\lang american
+
\family default 
\lang italian
, e replicate un certo numero di volte usando l'operatore 
\family typewriter 
\lang american
*
\family default 
\lang italian
:
\layout Verbatim

l = ['a', 'b'] + ['c', 'd'] * 3 
\layout Verbatim

# l diventa ['a','b','c','d','c','d','c','d']
\layout Section

Dizionari
\layout Standard

I dizionari sono simili alle liste, ma i loro contenuti non sono in sequenza.
 Per indicizzarli, si usa invece il fatto che ogni elemento é associato
 a una chiave, o "nome", che viene usato per reperire l'elemento, proprio
 come in un vero dizionario.
 Un paio di esempi: 
\layout Verbatim

telefoni = {"Alice":23452532,"Boris":252336,"Clarice":2352525,"Doris":23624643}
 
\layout Verbatim

persona = {'nome':"Robin",'cognome':"Hood",'professione':"Fuorilegge"}
\layout Standard

Per avere la professione della persona, useremo l'espressione 
\family typewriter 
\lang american
persona["professione"]
\family default 
\lang italian
.
 Per cambiare il cognome, potremmo scrivere: 
\layout Verbatim

persona['cognome'] = "di Locksley" 
\layout Standard

e, identicamente, per aggiungere al dizionario un elemento non già presente:
 
\layout Verbatim

persona['specialità'] = "Arciere" 
\layout Standard

Piuttosto semplice.
 Notiamo che, come le liste, i dizionari possono contenere altri dizionari
 (o liste -- e naturalmente, anche le liste possono contenere dizionari;
 si possono facilmente comporre strutture dati piuttosto avanzate).
 A partire da un dizionario 
\family typewriter 
\lang american
dict
\family default 
\lang italian
, si può avere la sequenza delle sue chiavi (ad esempio, per iterarci con
 un for) chiamando 
\family typewriter 
\lang american
dict.keys()
\family default 
\lang italian
: 
\layout Verbatim

for key in dict.keys(): 
\layout Verbatim

    print key,dict[key] 
\layout Standard

Questo é un idioma molto comune, quindi c'é un'alternativa:
\layout Verbatim


\lang american
for key,value in dict.items(): 
\layout Verbatim


\lang american
    print key,value
\layout Standard

Questo svolge lo stesso compito, poichè 
\family typewriter 
\lang american
dict.items()
\family default 
\lang italian
 restituisce una lista di coppie chiave/valore.
 Inoltre, 
\family typewriter 
\lang american
dict.values()
\family default 
\lang italian
 restituisce la lista dei valori (comodo se non interessano le relative
 chiavi); 
\family typewriter 
\lang american
dict.has_key(key)
\family default 
\lang italian
 restituisce un valore vero se la chiave é fra quelle attualmente presenti
 nel dizionario, altrimenti un valore falso.
\layout Standard

L'operatore di formato, 
\family typewriter 
\lang american
%
\family default 
\lang italian
, può accettare un dizionario come argomento di destra, e in questo caso
 la stringa di formato comprenderà anche i nomi (chiavi nel dizionario)
 da usare:
\layout Verbatim


\lang american
>>> "%(nome)s %(cognome)s é un %(professione)s" % persona
\layout Verbatim


\lang american
'Robin Hood é un Fuorilegge'
\layout Standard

La funzione intrinseca 
\family typewriter 
\lang american
locals()
\family default 
\lang italian
 restituisce un dizionario le cui coppie chiave/valore sono i nomi e i valori
 delle variabili locali, e similmente 
\family typewriter 
\lang american
globals()
\family default 
\lang italian
, mentre 
\family typewriter 
\lang american
vars()
\family default 
\lang italian
 li fonde entrambi (con priorità alle variabili locali in caso di sovrapposizion
e, che é la normale [e piuttosto intuitiva...] regola del Python); sono molto
 comodi, ad esempio, per l'uso con l'operatore di formato 
\family typewriter 
\lang american
%
\family default 
\lang italian
, per ottenere l'effetto della cosiddetta 
\emph on 
interpolazione di variabili
\emph default 
 di altri linguaggi (con un controllo assai piú preciso di quello permesso
 da questi altri linguaggi): 
\layout Verbatim


\lang american
"x=%(x)s, y=%(y)s, e z= %(z)s" % vars()
\layout Standard

é un modo comodo di emettere i valori attuali delle variabili x, y e z,
 ciascuno con la propria identificazione.
\layout Section

Stringhe
\layout Standard

Abbiamo già usato sin dall'inizio le stringhe di Python, che in effetti
 si prestano ad un uso elementare assai intuitivo, ma é il caso di notare
 che, come un po' tutto in Python, anche le stringhe sono oggetti, dotate
 dei loro metodi; ad esempio, come già accennato, possono sempre essere
 usate come sequenze (immutabili) di caratteri, con indexing e slicing,
 uso in for, ecc.
 Hanno inoltre metodi particolari come 
\family typewriter 
\lang american
lower
\family default 
\lang italian
 (che restituisce la versione in minuscole della stringa) e 
\family typewriter 
\lang american
split
\family default 
\lang italian
 (che restituisce la lista delle varie parole presenti nella stringa, nell'ordin
e).
\layout Standard

Per esempio, creiamo un 
\emph on 
indice analitico
\emph default 
 per un grosso file di testo 
\family typewriter 
\lang american
big.txt
\family default 
\lang italian
: una lista alfabetica delle parole che contiene, una per riga, ciascuna
 seguita dai numeri delle righe in cui si trova.
 
\layout Verbatim

fin=open("big.txt")
\layout Verbatim

numero_riga=0
\layout Verbatim

indice={ } # un dizionario vuoto
\layout Verbatim

while 1:
\layout Verbatim

    # ciclo input primario (righe in ingresso)
\layout Verbatim

    riga=fin.readline()
\layout Verbatim

    if not riga:
\layout Verbatim

        break
\layout Verbatim

    numero_riga=numero_riga+1
\layout Verbatim

    parole=riga.lower().split() # lista delle parole, in minuscolo 
\layout Verbatim

    for parola in parole:
\layout Verbatim

        # ciclo input secondario (parole della riga) 
\layout Verbatim

        if indice.has_key(parola): 
\layout Verbatim

            indice[parola].append(numero_riga) # aggiunge 1 elemento 
\layout Verbatim

        else: 
\layout Verbatim

            indice[parola]=[numero_riga] # lista di 1 solo elemento
\layout Verbatim

parole=indice.keys() 
\layout Verbatim

parole.sort() 
\layout Verbatim

for parola in parole:
\layout Verbatim

    # ciclo output primario (sulle parole riscontrate) 
\layout Verbatim

    print parola,": ",
\layout Verbatim

    for numero_riga in indice[parola]: 
\layout Verbatim

        # ciclo output secondario (numeri riga) 
\layout Verbatim

        print numero_riga,
\layout Verbatim

    print 
\layout Standard

L'istruzione 
\family typewriter 
\lang american
print
\family default 
\lang italian
 normalmente termina la riga di testo che emette, ma qui la usiamo con una
 virgola alla fine, il che elimina questa caratteristica e richiede invece
 un separatore "spazio"; in questo modo, la parola e i numeri delle righe
 che la contengono vengono emessi sulla stessa riga, separati da spazi.
\layout Section

Moduli
\layout Standard

Python offre una discreta funzionalità attraverso caratteristiche intrinseche
 (tipi di dati, operatori, funzioni), ma la maggior parte della sua potenza
 è messa a disposizione dai moduli -- pacchetti separati di funzionalità,
 che vanno esplicitamente importati alla bisogna.
 I moduli a loro volta possono essere intrinseci (Python ne ha parecchi),
 possono essere file scritti da noi (qualsiasi file 
\family typewriter 
\lang american
.py
\family default 
\lang italian
 può essere importato come modulo, e si possono anche scrivere altri moduli
 in C o C++), o li si può ottenere da terze parti ed installarseli (c'è
 un enorme numero di meravigliosi moduli Python disponibili per il download
 gratuito dalla rete, naturalmente).
\layout Standard

Per esempio, un modulo intrinseco che potrebbe fare comodo per lo stesso
 compito del paragrafo precedente è 
\family typewriter 
\lang american
fileinput
\family default 
\lang italian
, che permette di leggere uno o piú file di testo in sequenza, tenendo conto
 del numero di linea e con varie piccole comodità.
 Usandolo, il ciclo principale diventa assai piú semplice (visto che sfruttiamo
 la possibilità di iterare con 
\family typewriter 
\lang american
for
\family default 
\lang italian
, e la funzione 
\family typewriter 
\lang american
lineno()
\family default 
\lang italian
 che tiene già traccia del numero progressivo di riga):
\layout Verbatim

import fileinput
\layout Verbatim

filein=fileinput.input("big.txt")
\layout Verbatim

indice={ }
\layout Verbatim

# un dizionario vuoto
\layout Verbatim

for riga in filein:
\layout Verbatim

    # ciclo input primario (righe in ingresso) 
\layout Verbatim

    parole=riga.lower().split()  # lista delle parole, in minuscolo 
\layout Verbatim

    for parola in parole:
\layout Verbatim

        # ciclo input secondario (parole della riga) 
\layout Verbatim

        if indice.has_key(parola): 
\layout Verbatim

            indice[parola].append(filein.lineno()) # aggiunge un elemento
\layout Verbatim

        else: 
\layout Verbatim

            indice[parola]=[filein.lineno()] # lista di 1 solo elemento
\layout Standard

seguito, naturalmente, dallo stesso ciclo di uscita già usato all'esempio
 precedente.
 Le ultime quattro righe si potrebbero, alternativamente, riassumere in
 una sola, usando un metodo piú avanzato dell'oggetto-dizionario cui fa
 riferimento la variabile indice :
\layout Verbatim

indice.setdefault(parola,[]).append(filein.lineno())
\layout Standard

Python lascia queste scelte di stile (concisione e massima potenza, ovvero
 espressione dettagliata di massima semplicità elementare) all'apprezzamento
 del programmatore!
\layout Section

Funzioni
\layout Standard

Per costruire dei moduli (e non solo per questo), abbiamo chiaramente bisogno
 di definire noi stessi delle funzioni (o procedure che dir si voglia),
 cioè dei brani di codice, con un nome, che possono essere chiamati con
 dei parametri.
 A questo scopo Python utilizza la parola-chiave 
\family typewriter 
\lang american
def
\family default 
\lang italian
: 
\layout Verbatim

def quadrato(x): 
\layout Verbatim

    return x*x
\layout Verbatim

print quadrato(2) 
\layout Verbatim

# Emette 4 
\layout Standard

La parola-chiave 
\family typewriter 
\lang american
return
\family default 
\lang italian
 termina l'esecuzione della funzione, e ritorna come suo risultato il valore
 dell'espressione passatale (in mancanza, il valore speciale 
\family typewriter 
\lang american
None
\family default 
\lang italian
, che è l'
\emph on 
oggetto nullo
\emph default 
 del Python).
\layout Standard

Se scriviamo queste due righe che definiscono la funzione quadrato in un
 file di testo chiamato 
\family typewriter 
\lang american
matematica.py
\family default 
\lang italian
 (e lo poniamo nel directory corrente, o in un directory elencato nella
 variabile d'ambiente 
\family typewriter 
\lang american
PYTHONPATH
\family default 
\lang italian
), da qualsiasi altro programma Python potremo poi scrivere: 
\layout Verbatim

import matematica
\layout Verbatim

print matematica.quadrato(2) 
\layout Verbatim

# Emette 4
\layout Standard

oppure, se vogliamo incorporare solo le funzioni del modulo (non il modulo):
\layout Verbatim

from matematica import *
\layout Verbatim

print quadrato(2) 
\layout Verbatim

# Emette 4
\layout Standard

Tutti i parametri in Python sono passati 
\emph on 
per riferimento
\emph default 
 (come, ad esempio, in Java, e per ragioni simili, cioè che tutto funziona
 per riferimento in Python, come in Java; ci torneremo piú avanti) e possono
 avere valori di default (come in C++, ma anche con un nome, come in Visual
 Basic): 
\layout Verbatim

def cat(s1, s2, rep1=1, rep2=1): 
\layout Verbatim

    return s1*rep1+s2*rep2
\layout Verbatim

\layout Verbatim

cat('fee','fie')
\layout Verbatim

# ok, vale 'feefie' -- rep1 e rep2 entrambi da default 
\layout Verbatim

\layout Verbatim

cat('fee')
\layout Verbatim

# errore -- s2 non ha default, quindi è obbligatorio 
\layout Verbatim

\layout Verbatim

cat('foo','bar',3) 
\layout Verbatim

# restituisce 'foofoofoobar' 
\layout Verbatim

\layout Verbatim

cat('foo','bar',rep2=3) 
\layout Verbatim

# restituisce 'foobarbarbar'
\layout Standard

Per chiamare una funzione, anche senza argomenti, bisogna sempre usare le
 parentesi, perchè se una funzione è nominata senza parentesi, si ha come
 risultato la funzione stessa; le funzioni sono valori di prima classe in
 Python...! Possiamo avere liste o dizionari contenenti funzioni, passare funzioni
 come argomenti e restituirle come risultati di altre funzioni, e anche
 semplicemente definire e usare dei sinonimi per esse, come ad esempio:
 
\layout Verbatim

join=cat  # join diventa un "sinonimo" della funzione cat
\layout Verbatim

join('a','b',3,2)
\layout Verbatim

# restituisce 'aaabb'
\layout Section

Oggetti e riferimenti
\layout Standard

Abbiamo già usato gli oggetti, piú che altro perchè ogni elemento di dati
 in Python è un oggetto...
 oltre ad avere (o 
\emph on 
essere
\emph default 
) dati, ha dei metodi -- funzioni che si possono chiamare con la sintassi,
 tipica appunto della 
\emph on 
programmazione ad oggetti
\emph default 
, 
\family typewriter 
\lang american
oggetto.funzione(argomenti)
\family default 
\lang italian
.
 
\layout Standard

Per esempio, abbiamo già visto che, data una lista in una variabile denominata
 
\family typewriter 
\lang american
L
\family default 
\lang italian
, chiamare 
\family typewriter 
\lang american
L.sort()
\family default 
\lang italian
 modifica la lista cosí che divenga ordinata; dato un dizionario in una
 variabile denominata 
\family typewriter 
\lang american
D
\family default 
\lang italian
, chiamare 
\family typewriter 
\lang american
D.values()
\family default 
\lang italian
 restituisce una lista dei valori attualmente contenuti nel dizionario;
 e cosí via.
 Inoltre, parlando di I/O, abbiamo nominato la funzione intrinseca 
\family typewriter 
\lang american
open
\family default 
\lang italian
, che ritorna un oggetto 
\emph on 
file
\emph default 
, su cui possiamo chiamare metodi come 
\family typewriter 
\lang american
readline
\family default 
\lang italian
 e 
\family typewriter 
\lang american
write
\family default 
\lang italian
.
\layout Standard

Naturalmente, Python ci permette di creare dei nostri oggetti e determinare
 i loro metodi; linguaggio 
\emph on 
profondamente ad oggetti
\emph default 
, ci mancherebbe altro che non rendesse perfettamente agevole definirne
 dei nuovi! Ma in questo articolo, per mancanza di spazio, non parleremo
 della facilità con cui Python permette di svolgere questi compiti; ci sono
 aspetti che vanno ben capiti prima di indirizzarsi a questi, e, in particolare,
 dobbiamo chiarire il concetto di 
\emph on 
riferimento
\emph default 
.
 Ogni variabile Python, in qualsiasi momento, contiene un riferimento a
 un qualche oggetto; cosí pure ogni elemento di una lista, e ogni chiave
 e ogni valore di un dizionario.
 Spesso, questo aspetto non ha importanza, perchè il riferimento è a un
 oggetto immutabile -- qualsiasi numero è immutabile, e cosí pure qualsiasi
 stringa (le chiavi di un dizionario, in particolare, devono essere riferimenti
 a oggetti immutabili -- a questo scopo, c'è anche una specie di 
\emph on 
lista immutabile
\emph default 
, detta 
\family typewriter 
\lang american
tuple
\family default 
\lang italian
, che, sintatticamente, differisce dalla lista quasi solo nel fatto che
 le costanti che sono 
\family typewriter 
\lang american
tuple
\family default 
\lang italian
 si scrivono con parentesi tonde, invece delle parentesi quadre che sono
 usate per le costanti che sono liste).
 Ma, se abbiamo riferimenti a un oggetto mutabile, allora, se l'oggetto
 cambia, tutti i riferimenti implicitamente indicano il nuovo oggetto dopo
 il cambiamento: 
\layout Verbatim

>>> x=['a','b','c'] 
\layout Verbatim

>>> y=x 
\layout Verbatim

>>> x[1]='r' 
\layout Verbatim

>>> print y 
\layout Verbatim

['a','r','c'] 
\layout Standard


\family typewriter 
\lang american
y
\family default 
\lang italian
 si riferisce allo stesso oggetto cui si riferisce 
\family typewriter 
\lang american
x
\family default 
\lang italian
, e questo oggetto è cambiato.
 Questo è spesso ciò che si desidera; quando non lo è, invece di aggiungere
 semplicemente un riferimento, come fa l'istruzione di assegnamento 
\family typewriter 
\lang american
y=x
\family default 
\lang italian
, dobbiamo fare una copia, per esempio cambiando l'istruzione di assegnamento
 a: 
\layout Verbatim

y=x[:]
\layout Standard

Questo idioma di 
\emph on 
slice dall'inizio alla fine
\emph default 
 genera un nuovo oggetto, una copia di quello cui fa riferimento 
\family typewriter 
\lang american
x
\family default 
\lang italian
, ed è alla copia che fa riferimento 
\family typewriter 
\lang american
y
\family default 
\lang italian
.
 Di conseguenza, futuri cambiamenti della lista cui fa riferimento 
\family typewriter 
\lang american
x
\family default 
\lang italian
 non avranno nessun effetto sull'oggetto cui fa riferimento 
\family typewriter 
\lang american
y
\family default 
\lang italian
, e viceversa.
\layout Standard

Python fornisce anche un comodo modulo 
\family typewriter 
\lang american
copy
\family default 
\lang italian
 che gestisce per noi queste considerazioni: 
\layout Verbatim

import copy 
\layout Verbatim

y=copy.copy(x) 
\layout Standard

esegue un'operazione simile a y=x[:], ma lo fa polimorficamente (cioè, a
 qualsiasi cosa 
\family typewriter 
\lang american
x
\family default 
\lang italian
 faccia riferimento, che sia una lista, un dizionario, una stringa, una
 tupla, ...) cosí che noi non dobbiamo preoccuparci dei dettagli; e 
\family typewriter 
\lang american
y=copy.deepcopy(x)
\family default 
\lang italian
 si spinge anche piú a fondo, copiando ricorsivamente anche ciò a cui gli
 elementi di 
\family typewriter 
\lang american
x
\family default 
\lang italian
 fanno a loro volta riferimento.
\layout Section

Altri tipi intrinseci
\layout Standard

Oltre a numeri (interi e reali), stringhe, liste, dizionari, funzioni, e
 vari altri tipi la cui esistenza è stata già implicata (come gli oggetti-file
 restituiti dalla funzione 
\family typewriter 
\lang american
open
\family default 
\lang italian
), Python offre vari altri tipi intrinseci, comodi e potenti nelle applicazioni
 in cui servono.
\layout Standard

Ad esempio, i numeri complessi, indicati posponendo una 
\family typewriter 
\lang american
j
\family default 
\lang italian
 alla loro parte immaginaria: 
\layout Verbatim

>>> x=2+2j 
\layout Verbatim

>>> x*(1-1j) 
\layout Verbatim

(4+0j) 
\layout Verbatim

>>> x.real 
\layout Verbatim

2.0 
\layout Verbatim

>>> x.imag 
\layout Verbatim

2.0 
\layout Standard

col relativo complemento di funzioni matematiche, ottenute con 
\family typewriter 
\lang american
import cmath
\family default 
\lang italian
 cosí come quelle sui numeri reali si ottengono con 
\family typewriter 
\lang american
import math
\family default 
\lang italian
: 
\layout Verbatim

>>> import cmath
\layout Verbatim

>>> cmath.sqrt(-1)
\layout Verbatim

1j
\layout Verbatim

>>> cmath.sin(1j)
\layout Verbatim

1.17520119364j 
\layout Standard

I numeri complessi, naturalmente, sono utili solo per certi particolari
 compiti matematici.
\layout Standard

Per altri compiti, come quelli di aritmetica combinatoria, tornano invece
 utili gli interi 
\emph on 
lunghi
\emph default 
 (cioè con precisione illimitata), indicati posponendo una 
\family typewriter 
\lang american
L
\family default 
\lang italian
 alle loro cifre...: 
\layout Verbatim

def fact(x):
\layout Verbatim

    if x<=1:
\layout Verbatim

        return 1L 
\layout Verbatim

    else: 
\layout Verbatim

        return x*fact(x-1) 
\layout Standard

Questo ci permette di calcolare facilmente in quanti diversi modi può essere
 mescolato un normale mazzo di carte: 
\layout Verbatim

>>> fact(52)
\layout Verbatim

80658175170943878571660636856403766975289505440883277824000000000000L
\layout Standard

o quale sia la probabilità, ad esempio, che una mano di 13 carte (su 52)
 abbia esattamente cinque carte di picche (sulle 13 picche del mazzo): 
\layout Verbatim

def comb(m,n): 
\layout Verbatim

    return fact(m)/(fact(n)*fact(m-n))
\layout Verbatim

\layout Verbatim

>>> comb(52,13) 
\layout Verbatim

635013559600L
\layout Standard

questo è il numero di diverse mani di 13 carte su 52,
\layout Verbatim


\lang american
>>> comb(13,5)*comb(39,8)
\layout Verbatim


\lang american
79181063676L
\layout Standard

questo è il numero di mani con esattamente 5 picche e 8 non-picche,
\layout Verbatim


\lang american
>>> comb(13,5)*comb(39,8)/float(comb(52,13))
\layout Verbatim


\lang american
0.12469192583206691
\layout Standard

e quindi questa è la probabilità che cercavamo (circa il 12.47%).
\layout Standard

Utili per scopi di "internazionalizzazione" dei programmi sono le stringhe
 Unicode, con gli stessi metodi delle stringhe "normali" e un'amplissima
 gamma di codifica/decodifica:
\layout Verbatim


\lang american
>>> u"Cioé".encode("iso-8859-1") 
\layout Verbatim


\lang american
'Cio
\backslash 
351' 
\layout Verbatim


\lang american
>>> u"Cioè".encode("utf-8") 
\layout Verbatim


\lang american
'Cio
\backslash 
303
\backslash 
251'
\layout Standard

Gli altri tipi intrinseci sono forniti da moduli pure intrinseci, tramite
 un esplicito 
\family typewriter 
\lang american
import
\family default 
\lang italian
; gli esempi sono numerosi, come le regular expressions nel modulo 
\family typewriter 
\lang american
re
\family default 
\lang italian
, gli array nel modulo 
\family typewriter 
\lang american
array
\family default 
\lang italian
, gli interpreti interattivi nel modulo 
\family typewriter 
\lang american
cmd
\family default 
\lang italian
, ecc.
\the_end