%Attenzione, il carattere ~ si vede solamente nella versione 
% HTML, in funzione dell'inserimento del tipo: \url{http://....}
% Revisionato fino al Capitolo 9 compreso...

\documentclass{manual}
\usepackage[T1]{fontenc}
\usepackage[italian]{babel}

\title{Tutorial per principianti in Python}
\author{Josh Cogliati}
\newcommand{\type}[1]{``{\textsf{#1}}''}
\newcommand{\question}{{\bf Domanda: }}
\newcommand{\answer}{{\bf Risposta: }}

%\input{boilerplate}

\makeindex                      % tell \index to actually write the .idx file
%\makemodindex                  % If this contains a lot of module sections.


\begin{document}

\maketitle
\newpage

{\bf Copyright(c) 1999-2002 Josh Cogliati. }

Permission is granted to anyone to make or distribute verbatim copies of this document as received, in any medium, provided that the copyright notice and permission notice are preserved, and that the distributor grants the recipient permission for further redistribution as permitted by this notice.

Permission is granted to distribute modified versions of this document, or of portions of it, under the above conditions, provided also that they carry prominent notices stating who last altered them.

All example python source code in this tutorial is granted to the public domain.  Therefore you may modify it and relicense it under any license you please.

%%If you need to use this with normal LaTeX uncomment the next line and also
%%the end verbatim
%%\begin{verbatim}
% This makes the contents more accessible from the front page of the HTML.
\ifhtml
\chapter*{Premessa\label{front}}
\fi

%\input{copyright}

\begin{abstract}

\noindent

Il Tutorial per principianti in Python è un documento pensato per essere una
introduzione alla programmazione in Python, è destinato infatti a chi non ha
esperienze con la programmazione.

Se qualcuno di voi ha già programmato con altri linguaggi, vi raccomando il
Python Tutorial scritto da Guido van Rossum.

Questo documento è disponibile in \LaTeX, HTML, PDF e Postscript. Potete 
reperirlo in tutti i formati elencati presso 
\url{http://www.honors.montana.edu/\~{}jjc/easytut/}.

Se qualcuno di voi ha domande da pormi, contattatemi al mio indirizzo
\email{jjc@iname.com}, (\email{nicholas_wieland@yahoo.it} per la 
presente versione tradotta) commenti e suggerimenti riguardo questo 
documento sono i benvenuti. Proverò a rispondere a qualsiasi domanda 
meglio che potrò.

I ringraziamenti vanno a James A. Brown per aver scritto la maggior parte
della sezione dedicata all'installazione sotto Windows. Grazie anche ad 
Elizabeth Cogliati per le proteste :) circa la prima stesura del tutorial, 
(quasi inutilizzabile da un principiante) per averlo revisionato ed aver
fornito molte idee e commenti. Grazie anche a Joe Oppergaard per aver 
scritto tutti gli esercizi. Grazie anche a tutti quelli che ho dimenticato.

Versione in lingua italiana del "Tutorial per principianti in Python"
a cura di Nicholas Wieland e Ferdinando Ferranti.

Per quanto riguarda eventuali aggiornamenti della versione Italiana
rivolgersi a: \email{nicholas_wieland@yahoo.it} o 
\email{zappagalattica@inwind.it}, i successivi aggiornamenti di questa 
traduzione saranno reperibili presso il sito locale di Python: 
\url{http://www.python.it}.

\ifhtml

Ecco alcuni link che potreste trovare utili:

\begin{rawhtml}
<ul><li><a href="http://www.python.org">Python Home Page</a>
<li><a href="http://www.python.it">Python Home Page (italiana)</a>
<li><a href="http://www.python.org/doc/">Python Documentation</a>

<li><a href="http://www.python.org/doc/current/tut/tut.html">Python Tutorial for Programmers</a>
<li><a href="http://www.python.it/doc/tut/tut-0.html">Tutorial per programmatori (versione in italiano)</a>

<li><a href="http://www.honors.montana.edu/~jjc/easytut/">LaTeX, PDF, Postscript, e versione Zip</a>
</ul>
\end{rawhtml}
\fi

\newpage

\begin{center}
Dedicato a Elizabeth Cogliati
\end{center}

\end{abstract}
%%\end{verbatim}

\tableofcontents

\chapter{Introduzione}

\section{La prima cosa}

Se state leggendo questo tutorial non avete mai programmato in vita vostra.
Proseguite nella lettura e tenterò di insegnarvi come si programma.
Innanzitutto chiarezza: c'è una sola via da percorrere per imparare a
programmare, {\bf dovete} leggere codice - scrivere codice e io ve ne 
farò leggere e scrivere tantissimo. 
Per questo dovrete sempre scrivere il codice degli
esempi ed eseguirlo per poi vedere che cosa succede: giocate con il codice,
modificatelo come volete, la cosa peggiore che può capitarvi è che il
programma non funzioni. Per riconoscere il codice dalla normale scrittura
userò questo formato:

\begin{verbatim}
# Python è facile da imparare
print "Hello, World!"
\end{verbatim}

Facile da distinguere dal resto del testo no? Appunto per confondervi
scriverò così anche l'output del computer :=)

Un'altra cosa importante: per programmare in Python vi serve Python. Se
non avete ancora il software necessario dirigetevi verso
\url{http://www.python.org/download} e scaricatevi la versione adatta 
alla vostra piattaforma, leggete le istruzioni e installatela.


\section{Installare Python}

Innanzitutto scaricatevi il file appropriato: Python 2.2, il Windows 
Installer nel caso usiate Windows; la versione rpm o i sorgenti da 
compilare se avete un sistema Unix.

Scaricando il Windows Installer avrete un file che basterà cliccare
due volte per iniziare la procedura di installazione.

Scaricando i sorgenti Unix assicuratevi di compilare con l'estensione 
Tk per usare IDLE.




\section{Modo interattivo}

Aprite IDLE, la GUI di Python. Dovreste vedere una finestra di questo tipo:

\begin{verbatim}
Python 2.2.2 (#1, Mar 21 2003, 23:01:54)
[GCC 3.2.3 20030316 (Debian prerelease)] on linux2
Type "copyright", "credits" or "license" for more information.
IDLE 0.8 -- press F1 for help
>>> 
\end{verbatim}
Il \verb'>>>'  è il modo che ha Python per informarvi che siete in modo 
interattivo, dove i comandi digitati sono immediatamente eseguiti. 
Provate a digitare  \verb'1+1' e Python vi risponderà immediatamente 
\verb'2'. In questa modalità potete provare Python e vedere come reagisce 
ai vari comandi. Usatela quando sentirete il bisogno di prendere 
confidenza con i comandi Python.

\section{Creare ed eseguire programmi}
\label{create}

Andate in modo interattivo se non ci siete già. Selezionate \verb'File' 
dal menu dopodiché selezionate \verb'New Window'.
Digitate nella nuova finestra il seguente testo (codice):
\begin{verbatim}
print "Hello, World!"
\end{verbatim}

Innanzitutto salvate il programma sempre selezionando dal menu \verb'File' 
e poi \verb'Save'. Salvatelo come \file{hello.py} nella directory 
predefinita o nella directory che preferite. Ora che avete salvato 
potete eseguire il programma.

Selezionate dal menu la voce \verb'Edit' e poi \verb'Run script'. 
Questa azione vi restituirà l'output richiesto dal programma 
\file{hello.py} nella finestra \verb'*Python Shell*' che saluterà 
allegramente con un: \verb'Hello, World!'.

Confusi? Provate questo tutorial per l'IDLE: 
\url{http://hkn.eecs.berkeley.edu/\~{}dyoo/python/idle_intro/index.html}.


\section{Usare Python da riga di comando}

Se preferite non utilizzare Python da riga di comando non siete
obbligati, usate IDLE.  Per entrare in modo interattivo da riga
di comando dovete semplicemente digitare \verb'python'. Se volete 
eseguire un programma che avete scritto con un editor
di testo (ad esempio Emacs è un ottimo editor per Python) non dovete 
fare altro che usare la sintassi \verb'python nome programma'.

%%Now for our first lesson, what is a computer program?  A computer program is a set of very detailed instructions that tell a computer what to do.  

%%TODO add section explaining how to run python programs





\chapter{Hello, World}
\section{Cosa dovresti già sapere}

Dovresti sapere come visualizzare un programma in un editor di testo,
salvarlo, (su floppy o disco fisso) ed eseguirlo una volta salvato.

\section{Stampare}
Sin dall'inizio dei tempi i tutorial sono sempre iniziati con un 
semplice programma chiamato 'Hello World'. Eccolo:

\begin{verbatim}
print "Hello, World!"
\end{verbatim}

Se state usando la riga di comando per eseguire i programmi, inserite 
la stringa di testo in un editor e salvate il file con il nome
\file{hello.py}, eseguitelo con il comando \type{python hello.py}.


Altrimenti, entrate in IDLE, aprite una nuova finestra (New window) e 
create il programma come spiegato nella sezione \ref{create}.

Ecco cosa stampa sullo schermo il programma quando viene eseguito:

\begin{verbatim}
Hello, World!
\end{verbatim}

Non ve lo dirò ogni volta ma vi consiglio vivamente di ripetere tutti gli
esercizi che vi mostro, questo vi aiuterà a comprenderli meglio, anch'io
imparo di più quando scrivo, probabilmente anche voi ...

Tentiamo un programma un po' più complicato:

\begin{verbatim}
print "Jack and Jill went up a hill"
print "to fetch a pail of water;"
print "Jack fell down, and broke his crown,"
print "and Jill came tumbling after."
\end{verbatim}

Quando eseguirete il programma l'output sul monitor sarà questo:

\begin{verbatim}
Jack and Jill went up a hill
to fetch a pail of water;
Jack fell down, and broke his crown,
and Jill came tumbling after.
\end{verbatim}

Quando il computer esegue questo programma vede innanzitutto la prima linea:
\begin{verbatim}
print "Jack and Jill went up a hill"
\end{verbatim}
Ed esegue l'ordine, ovvero stampa:
\begin{verbatim}
Jack and Jill went up a hill
\end{verbatim}

Dopodiché il computer prosegue a leggere il codice e passa alla
linea successiva:
\begin{verbatim}
print "to fetch a pail of water;"
\end{verbatim}

Il risultato è la stampa di:
\begin{verbatim}
to fetch a pail of water;
\end{verbatim}

Il computer continua a scendere di linea in linea seguendo e svolgendo 
le istruzioni che voi stessi gli ordinate finché non raggiunge la fine 
del programma.
  

\section{Espressioni}
Ecco qui un'altro programma:
\begin{verbatim}
print "2 + 2 is", 2+2
print "3 * 4 is", 3 * 4
print 100 - 1, " = 100 - 1"
print "(33 + 2) / 5 + 11.5 = ",(33 + 2) / 5 + 11.5  
\end{verbatim}

E qui l'output che questo programma produce:

\begin{verbatim}
2 + 2 is 4
3 * 4 is 12
99  = 100 - 1
(33 + 2) / 5 + 11.5 =  18.5
\end{verbatim}

Come puoi vedere Python può trasformare il vostro costosissimo computer 
in una normale calcolatrice :-)

Python ha sei operatori basilari: 

\begin{tabular}{l | c | l}
Operatore & Simbolo & Esempio \\
\hline
Elevamento a potenza & \verb'**' & \verb'5 ** 2 == 25' \\
Moltiplicazione & \verb'*' & \verb'2 * 3 == 6' \\
Divisione & \verb'/' & \verb'14 / 3 == 4' \\
Resto & \verb'%' & \verb'14 % 3 == 2' \\
Addizione & \verb'+' & \verb'1 + 2 == 3' \\
Sottrazione & \verb'-' & \verb'4 - 3 == 1' \\
\end{tabular}

Osservate come la divisione segua la regola per cui se nel dividendo e 
nel divisore non sono presenti decimali anche il risultato non conterrà 
decimali (questo però cambierà in Python 2.3).
Il seguente programma dimostra la regola appena enunciata:
\begin{verbatim}
print "14 / 3 = ",14 / 3
print "14 % 3 = ",14 % 3
print
print "14.0 / 3.0 =",14.0 / 3.0
print "14.0 % 3.0 =",14 % 3.0
print
print "14.0 / 3 =",14.0 / 3
print "14.0 % 3 =",14.0 % 3
print
print "14 / 3.0 =",14 / 3.0
print "14 % 3.0 =",14 % 3.0
print
\end{verbatim}
Con l'output:
\begin{verbatim}
14 / 3 =  4
14 % 3 =  2

14.0 / 3.0 = 4.66666666667
14.0 % 3.0 = 2.0

14.0 / 3 = 4.66666666667
14.0 % 3 = 2.0

14 / 3.0 = 4.66666666667
14 % 3.0 = 2.0

\end{verbatim}
Python da risposte differenti in base alla presenza o meno di numeri
decimali.

L'ordine delle operazioni è lo stesso che nella matematica:
\begin{enumerate}
\item parentesi \verb'()'
\item elevamento a potenza \verb'**'
\item moltiplicazione \verb'*', divisione \verb'\' e resto \verb'%' 
\item addizione \verb'+' e sottrazione \verb'-'
\end{enumerate}

\section{Parlare agli umani (e ad altri esseri intelligenti)}

Vi capiterà sicuramente, quando sarete più esperti, di dover programmare
applicazioni molto complesse e lunghe. Difficilmente rileggendo il codice
dopo qualche tempo riuscirete a ricordarvi tutti i passaggi e tutti i
ragionamenti fatti, per questo è meglio che prendiate da subito la 
buona abitudine di commentare il vostro lavoro. 
Ad esempio:
\begin{verbatim}
# Non è esattamente pi greco, ma un'incredibile simulazione.
print 22.0/7.0
\end{verbatim}
Come potete vedere il commento inizia con il simbolo  \verb'#'.
Un commento è semplicemente una nota, per altri programmatori ma anche 
per voi stessi, che spiega il programma nei punti salienti. 

\section{Esempi}
Ogni capitolo conterrà esempi delle proprietà di programmazione introdotte
nel capitolo stesso. Dovreste almeno dare un'occhiata al codice per vedere
se riuscite a capirlo. Nel caso alcuni passaggi non fossero chiari potete
scrivere il codice ed eseguirlo, per tentare di capirlo meglio o 
addirittura apportare delle modifiche per vedere cosa succede.

\file{Denmark.py}
\begin{verbatim}
print "Something's rotten in the state of Denmark."
print "                -- Shakespeare"
\end{verbatim}

Output:
\begin{verbatim}
Something's rotten in the state of Denmark.
                -- Shakespeare
\end{verbatim}

\file{School.py}
\begin{verbatim}
# Questo non è esattamente vero al di fuori degli USA, ed è basato su
# di un vago ricordo dei miei trascorsi giovanili.
print "Firstish Grade"
print "1+1 =",1+1
print "2+4 =",2+4
print "5-2 =",5-2
print
print "Thirdish Grade"
print "243-23 =",243-23
print "12*4 =",12*4
print "12/3 =",12/3
print "13/3 =",13/3," R ",13%3
print
print "Junior High"
print "123.56-62.12 =",123.56-62.12
print "(4+3)*2 =",(4+3)*2
print "4+3*2 =",4+3*2
print "3**2 =",3**2
print
\end{verbatim}

Output:
\begin{verbatim}
Firstish Grade
1+1 = 2
2+4 = 6
5-2 = 3

Thirdish Grade
243-23 = 220
12*4 = 48
12/3 = 4
13/3 = 4  R  1

Junior High
123.56-62.12 = 61.44
(4+3)*2 = 14
4+3*2 = 10
3**2 = 9

\end{verbatim}

\section{Esercizi}

Scrivete un programma che stampa su schermo il vostro nome e cognome 
in due stringhe separate.

Scrivete un programma che mostra l'utilizzo delle 6 operazioni 
matematiche.




\chapter{ Chi va là?}
\section{Input e variabili}
Ora proviamo un programma un po' più complicato:
\begin{verbatim}
print "Halt!"
s = raw_input("Who Goes there? ")
print "You may pass,", s
\end{verbatim}

Quando {\bf io} lo eseguo, questo appare sul {\bf mio} schermo:
\begin{verbatim}
Halt!
Who Goes there? Josh
You may pass, Josh
\end{verbatim}

Ovviamente quando proverete anche voi l'esecuzione il vostro output sarà
differente, grazie all'istruzione \verb'raw_input'. Avviando il 
programma (perché lo state provando vero?) avrete notato che richiede 
l'inserimento del vostro nome e poi la pressione di Enter per continuare 
l'esecuzione; a quel punto viene visualizzato un messaggio seguito dal 
vostro nome. Questo è un esempio di input: il programma viene eseguito 
fino ad un certo punto, dopodiché attende un input di dati dall'utente.

Naturalmente un input sarebbe inutile se non avessimo nessun posto dove
mettere l'informazione ottenuta, ecco quindi che entrano in gioco le
variabili. Nel programma precedente {\tt s} è, appunto, una variabile. 
Le variabili sono come delle scatole in cui si possono immagazzinare 
dati. Ecco un programma che ne spiega l'utilizzo:
\begin{verbatim}
a = 123.4
b23 = 'Spam'
first_name = "Bill"
b = 432
c = a + b
print "a + b is", c
print "first_name is", first_name
print "Sorted Parts, After Midnight or",b23
\end{verbatim}

E questo è l'output:
\begin{verbatim}
a + b is 555.4
first_name is Bill
Sorted Parts, After Midnight or Spam
\end{verbatim}

Come ho detto: le variabili immagazzinano dati. Nel programma qui sopra ad
esempio sono {\tt a}, {\tt b23}, \verb'first_name', {\tt b} e {\tt c}. 
Le due tipologie base di variabili sono stringhe e numeri. Le stringhe 
sono sequenze di lettere, numeri e altri caratteri: nell'esempio 
{\tt b23} e \verb'first_name' sono variabili contenenti stringhe.
{\tt Spam}, {\tt Bill}, {\tt a + b is}, e \verb'first_name is' sono 
stringhe, come potete notare sono sempre racchiuse da {\tt "} o {\tt '}. 
Gli altri tipi di variabili presenti sono numeri.

Ora, abbiamo queste scatole chiamate variabili ed anche dati da metterci
dentro. Il computer vedrà una linea come \verb'first_name = "Bill"' che 
leggerà come ``Metti la stringa {\tt Bill} nella scatola (o variabile) 
\verb'first_name'''. Più tardi vedrà l'espressione {\tt c = a + b} che 
leggerà come ``Metti {\tt a + b} o  {\tt 123.4 + 432} o {\tt 555.4} 
all'interno della variabile {\tt c}''.  

Ecco un'altro esempio sull'utilizzo delle variabili:
\begin{verbatim}
a = 1
print a
a = a + 1
print a
a = a * 2
print a
\end{verbatim}

E naturalmente ecco l'output:
\begin{verbatim}
1
2
4
\end{verbatim}

Anche se in tutti i casi elencati la variabile ha lo stesso nome, il
computer la rilegge ogni volta: prima trova i dati da immagazzinare e poi
decide dove immagazzinarli.

Un'ultimo esempio prima di chiudere il capitolo:
\begin{verbatim}
num = input("Type in a Number: ")
str = raw_input("Type in a String: ")
print "num =", num
print "num is a ",type(num)
print "num * 2 =",num*2
print "str =", str
print "str is a ",type(str)
print "str * 2 =",str*2
\end{verbatim}

Ecco l'output ottenuto:
\begin{verbatim}
Type in a Number: 12.34
Type in a String: Hello
num = 12.34
num is a  <type 'float'>
num * 2 = 24.68
str = Hello
str is a  <type 'string'>
str * 2 = HelloHello
\end{verbatim}

Osserva il modo in cui ho ottenuto dall'utente le due variabili: {\tt input} 
per la variabile \verb'numerica' e \verb'raw_input' per la variabile 
\verb'stringa'. Quando volete che l'utente inserisca un numero o una 
stringa utilizzate, rispettivamente, {\tt input} o \verb'raw_input'.

La seconda parte del programma utilizza la funzione {\tt type} che vi 
informa sul tipo di variabile: le varibili numeriche sono di tipo {\tt 'int'} 
(numero 'intero') o {\tt 'float'} (numero 'decimale'), le stringhe sono di 
tipo {\tt string}. Interi e decimali possono essere utilizzati per 
operazioni matematiche, le stringhe no. Tuttavia quando una stringa viene 
moltiplicata per un intero vengono aggiunte alla stringa copie di se 
stessa: ad es. \verb'str * 2 = HelloHello'.

Le operazioni con le stringhe differiscono leggermente da
quelle con i numeri. I seguenti, sono alcuni esempi che
mostrano tali differenze.

\begin{verbatim}
>>> "This"+" "+"is"+" joined."
'This is joined.'
>>> "Ha, "*5
'Ha, Ha, Ha, Ha, Ha, '
>>> "Ha, "*5+"ha!"
'Ha, Ha, Ha, Ha, Ha, ha!'
>>> 
\end{verbatim}

Questa è una lista di alcune operazioni con le stringhe:

\begin{tabular}{l | c | l}
Operazione & Simbolo & Esempio \\
\hline
Ripetizione & \verb'*' & \verb'"i"*5 == "iiiii"' \\
Concatenazione & \verb'+' & \verb'"Hello, "+"World!" == "Hello, World!"' \\
\end{tabular}


%%n_1 = input("First Number? ")
%%n_2 = input("Second Number? ")
%%name = raw_input("Input your name:")
%%print name,", the sum of the first number and the second number is", n_1 + n_2
%%print "n_1 =",repr(n_1)
%%print "n_2 =",repr(n_2)
%%print "name =",repr(name)
%%\end{verbatim}


%%You use {\tt raw_input} when you want to get a string from the user.  You use {\tt input} when you want to get a number.  

\section{Esempi}

\file{Velocita_tempo.py}
\begin{verbatim}
# Questo programma calcola lo spazio, data velocità e tempo.
print "Input a rate and a distance"
rate = input("Rate:")
distance = input("Distance:")
print "Time:",distance/rate
\end{verbatim}

Esecuzione:
\begin{verbatim}
> python velocita_tempo.py
Input a rate and a distance
Rate:5
Distance:10
Time: 2
> python velocita_tempo.py 
Input a rate and a distance
Rate:3.52
Distance:45.6
Time: 12.9545454545
\end{verbatim}

\file{Area.py}
\label{firstarea}
\begin{verbatim}
# Questo programma calcola perimetro ed area del rettangolo.
print "Calculate information about a rectangle"
length = input("Length:")
width = input("Width:")
print "Area",length*width
print "Perimeter",2*length+2*width
\end{verbatim}

Esecuzione:
\begin{verbatim}
> python area.py
Calculate information about a rectangle
Length:4
Width:3
Area 12
Perimeter 14
> python area.py
Calculate information about a rectangle
Length:2.53
Width:5.2
Area 13.156
Perimeter 15.46
\end{verbatim}

\file{temperature.py}
\begin{verbatim}
# Converte Fahrenheit in Celsius.
temp = input("Farenheit temperature:")
print (temp-32.0)*5.0/9.0
\end{verbatim}

Esecuzione:
\begin{verbatim}
> python temperature.py
Farenheit temperature:32
0.0
> python temperature.py
Farenheit temperature:-40
-40.0
> python temperature.py
Farenheit temperature:212
100.0
> python temperature.py
Farenheit temperature:98.6
37.0
\end{verbatim}

\section{Esercizi}

Scrivete un programma che prenda due variabili stringa e due numeriche 
intere dall'utente, le concateni (unisca le due stringhe senza spazi)
e le visualizzi sullo schermo, infine moltiplichi i due numeri interi
su una nuova linea.






\chapter{Conta da 1 a 10}

\section{Cicli While}

Ecco qui finalmente la nostra prima struttura di controllo. Solitamente 
il computer legge il nostro programma cominciando dalla prima linea per 
poi scendere da lì fino alla fine del codice. Le strutture di controllo
influiscono sul programma cambiando l'ordine d'esecuzione dei comandi o
decidendo se un determinato comando verrà eseguito o meno. A voi il sorgente
di un primo esempio che utilizza la struttura di controllo while:
\begin{verbatim}
a = 0
while a < 10:
        a = a + 1
        print a
\end{verbatim}

Quindi il risultato dell'esecuzione:
\begin{verbatim}
1
2
3
4
5
6
7
8
9
10
\end{verbatim}
Cosa fa il programma? Prima di tutto vede la linea {\tt a = 0} e assegna
il valore zero alla variabile numerica a. Dopodiché vede il comando 
{\tt while a < 10:} che ordina a Python di controllare se la variabile a 
è minore di 10, in questo caso a corrisponde al valore zero quindi è 
minore di 10, per questo motivo Python eseguirà tutte le istruzioni 
rientrate sotto la struttura while. In poche parole finché la variabile 
numerica a è minore di dieci Python esegue tutte le istruzioni tabulate 
sotto while.

Ecco un'altro esempio dell'uso di {\tt while}:
\begin{verbatim}
a = 1
s = 0
print 'Enter Numbers to add to the sum.'
print 'Enter 0 to quit.'
while a != 0 :
        print 'Current Sum:',s
        a = input('Number? ')
        s = s + a
print 'Total Sum =',s
\end{verbatim}
 
Appena eseguito questo script l'output è stato questo:
\begin{verbatim}
  File "sum.py", line 3
    while a != 0 
                ^
SyntaxError: invalid syntax
\end{verbatim}
Ho dimenticato il {\tt :} dopo il while. Python avverte dell'errore 
e mostra all'utente dov'è il problema, segnando la linea di codice 
incriminata con un utile \verb"^". Dopo aver risolto il problema 
il programma funziona a meraviglia ed ecco finalmente il risultato:
\begin{verbatim}
Enter Numbers to add to the sum.
Enter 0 to quit.
Current Sum: 0
Number? 200
Current Sum: 200
Number? -15.25
Current Sum: 184.75
Number? -151.85
Current Sum: 32.9
Number? 10.00
Current Sum: 42.9
Number? 0
Total Sum = 42.9
\end{verbatim}

Come puoi vedere {\tt print 'Total Sum =',s} è eseguito solamente alla 
fine. Questo perché la struttura di controllo {\tt while} influisce 
solamente sulle istruzioni tabulate (rientrate, indentate). Il simbolo 
{\tt !=} significa diverso: {\tt while a != 0 :} finché a è diverso da 
zero, vengono eseguite le istruzioni tabulate sotto il {\tt while}.

Ora che abbiamo capito il ciclo {\tt while}, possiamo programmare uno 
script che venga eseguito all'infinito. Una via molto facile per farlo 
è, ad esempio, questa:
\begin{verbatim}
while 1 == 1:
     print "Help, I'm stuck in a loop."
\end{verbatim}

L'output di questo programma sarà una continua ripetizione della frase
{\tt Help, I'm stuck in a loop.} all'infinito, a meno che non lo 
fermiate premendo i tasti Control (o 'Ctrl') e 'c' (la lettera) 
contemporaneamente. Questo manderà un segnale di terminazione al programma 
(Nota: Talvolta è necessario premere anche enter dopo il Control-c).

\section{Esempi}

\file{Fibonacci.py}
\begin{verbatim}
# Questo programma calcola la sequenza di Fibonacci.
a = 0
b = 1
count = 0
max_count = 20
while count < max_count:
    count = count + 1
    # Occorre tenere traccia finché ci sono cambiamenti
    old_a = a
    old_b = b
    a = old_b
    b = old_a + old_b
    # Attenzione che la virgola alla fine di un istruzione print 
    # prosegue la stampa sulla stessa linea.
    print old_a,
print
\end{verbatim}

Output:
\begin{verbatim}
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
\end{verbatim}

\file{Password.py}
\begin{verbatim}
# Attende sino a quando non viene inserita la giusta password. 
# Usate Control-C per fermare il programma senza password.

# Notate che se non viene inserita la giusta password, il ciclo 
# while prosegue all'infinito.
password = "foobar"

# Notate il simbolo != (diverso).
while password != "unicorn":
    password = raw_input("Password:")
print "Welcome in"
\end{verbatim}

Esecuzione:
\begin{verbatim}Password:auo
Password:y22
Password:password
Password:open sesame
Password:unicorn
Welcome in
\end{verbatim}





\chapter{Decisioni}

\section{L'istruzione If}
Credo sia meglio iniziare il capitolo con un esempio a caldo: ecco
quindi un programma che calcola il valore assoluto di un numero:
\begin{verbatim}
n = input("Number? ")
if n < 0:
        print "The absolute value of",n,"is",-n
else:
        print "The absolute value of",n,"is",n
\end{verbatim}

Output di due esecuzioni:
\begin{verbatim}
Number? -34
The absolute value of -34 is 34

Number? 1
The absolute value of 1 is 1
\end{verbatim}

Quindi cosa fa il computer quando esegue questo codice? Prima di tutto 
chiede all'utente un numero grazie alla linea 
{\tt n = input("Number? ")} dopodiché legge la linea {\tt if n < 0:},
se {\tt n} è minore di zero, Python esegue la linea
{\tt print "The absolute value of",n,"is",-n}, altrimenti (cioè se il
numero è maggiore di zero) esegue la linea 
{\tt  print "The absolute value of",n,"is",n}.

Più semplicemente, Python decide se l'{\em affermazione} {\tt n < 0} è
vera o falsa. Un'istruzione {\tt if} è sempre seguita da un 
{\em blocco} di altre istruzioni indentate che vengono eseguite nel
caso l'affermazione sia vera. In caso contrario vengono eseguiti i
comandi indentati sotto l'istruzione {\tt else}, ovvero quando
l'affermazione {\tt if} risulta falsa.

Python presenta svariati operatori associabili al confronto di una
variabile, eccone una lista completa:

\begin{tabular}{l | l}
Operatore & Funzione \\
\hline 
\verb'<' & minore di \\
\verb'<=' & minore o uguale a \\
\verb'>' & maggiore di \\
\verb'>=' & maggiore o uguale a \\
\verb'==' & uguale \\
\verb'!=' & diverso da \\
\verb'<>' &  variante di diverso da \\
\end{tabular}

Un'altra proprietà dell'istruzione {\tt if} è la funzione {\tt elif }. \`E
un'abbreviazione di else if e significa: esegui il blocco di istruzioni
tabulato sotto elif se la condizione necessaria al primo {\tt if} è falsa e la
condizione {\tt elif} è vera. Ecco un esempio:
\begin{verbatim}
a = 0
while a < 10:
        a = a + 1
        if a > 5:
                print a," > ",5
        elif a <= 7:
                print a," <= ",7
        else:
                print "Neither test was true"
\end{verbatim}

Questo è l'output:

\begin{verbatim}
1  <=  7
2  <=  7
3  <=  7
4  <=  7
5  <=  7
6  >  5
7  >  5
8  >  5
9  >  5
10  >  5
\end{verbatim}

Osservate come la linea {\tt elif a <= 7} entri in azione solamente
quando la prima istruzione {\tt if} risulta falsa. Come potete vedere,
l'istruzione  {\tt elif} consente di effettuare test multipli
all'interno di una singola istruzione if.

\section{Esempi}

\file{High_low.py}
\label{firsthighlow}
\begin{verbatim}
# Giocate ad indovinare il numero alto-basso
# (originariamente scritto da Josh Cogliati, migliorato da Quique)

# Questo dovrebbe attualmente essere qualcosa che è semi casuale, come 
# l'ultimo carattere del tempo o qualcos'altro, ma dovrete aspettare
# i prossimi capitoli (Esercizio supplementare, modificate con random,
# come richiesto nel capitolo sull'uso dei moduli).

number = 78
guess = 0

while guess != number : 
    guess = input ("Guess a number: ")

    if guess > number :
        print "Too high"

    elif guess < number :
            print "Too low"

print "Just right" 
\end{verbatim}

Esecuzione:
\begin{verbatim}
Guess a number:100
Too high
Guess a number:50
Too low
Guess a number:75
Too low
Guess a number:87
Too high
Guess a number:81
Too high
Guess a number:78
Just right
\end{verbatim}

\file{even.py}
\begin{verbatim}
# Chiedi un numero.
# Stampa se è pari o dispari.

number = input("Tell me a number: ")
if number % 2 == 0:
    print number,"is even."
elif number % 2 == 1:
    print number,"is odd."
else:
    print number,"is very strange."
\end{verbatim}

Esecuzione:
\begin{verbatim}
Tell me a number: 3
3 is odd.

Tell me a number: 2
2 is even.

Tell me a number: 3.14159
3.14159 is very strange.
\end{verbatim}

\file{average1.py}
\begin{verbatim}
# Continua a chiedere numeri finché non viene immesso 0.
# Stampa la media dei valori.

count = 0
sum = 0.0
number = 1 # imposta un valore, altrimenti il ciclo 
           # while terminerebbe immediatamente.

print "Enter 0 to exit the loop"

while number != 0:
    number = input("Enter a number:")
    count = count + 1
    sum = sum + number

count = count - 1 # Togli un'unità all'ultimo numero.
print "The average was:",sum/count
\end{verbatim}

Esecuzione:
\begin{verbatim}
Enter 0 to exit the loop
Enter a number:3
Enter a number:5
Enter a number:0
The average was: 4.0

Enter 0 to exit the loop
Enter a number:1
Enter a number:4
Enter a number:3
Enter a number:0
The average was: 2.66666666667
\end{verbatim}

\file{average2.py}
\begin{verbatim}
# Continua a chiedere numeri finché count li richiede.
# Stampa la media dei valori.

sum = 0.0

print "This program will take several numbers than average them"
count = input("How many numbers would you like to sum:")
current_count = 0

while current_count < count:
    current_count = current_count + 1
    print "Number ",current_count
    number = input("Enter a number:")
    sum = sum + number

print "The average was:",sum/count
\end{verbatim}

Esecuzione:
\begin{verbatim}
This program will take several numbers than average them
How many numbers would you like to sum:2
Number  1
Enter a number:3
Number  2
Enter a number:5
The average was: 4.0

This program will take several numbers than average them
How many numbers would you like to sum:3
Number  1
Enter a number:1
Number  2
Enter a number:4
Number  3
Enter a number:3
The average was: 2.66666666667
\end{verbatim}

%TODO: add another example

\section{Esercizi}

Scrivete un programma che chieda all'utente di indovinare una
password, ma che dia al giocatore solamente 3 possibilità, fallite le
quali il  programma terminerà, stampando 
``\`E troppo complicato per voi''.

Scrivete un programma che chieda due numeri. Se la somma dei due
numeri supera 100, stampate ``Numero troppo grande''.

Scrivete un programma che chieda all'utente il nome. Se viene inserito
il vostro nome, il programma dovrà rispondere con un 
``Questo è un bel nome'', se il nome inserito è "John Cleese" o 
"Michel Palin" il programma dovrà rispondere con una battuta ;) mentre
in tutti gli altri casi l'output del programma sarà un semplice
``Tu hai un bel nome!''.





\chapter{Debugging}
\section{Cos'è il Debugging?}
\begin{quotation}
Poco dopo aver iniziato a programmare ci siamo accorti di come non
fosse affatto facile far fare ai programmi quello che volevamo.
Avevamo scoperto il Debugging. Posso ricordare il preciso momento in
cui ho realizzato che avrei passato buona parte della mia vita a
scoprire e correggere gli errori nei miei stessi programmi.

-- Maurice Wilkes scopre il debugging, 1949
\end{quotation}

 Se finora avete ripetuto tutti i programmi degli esempi vi sarete
certamente  accorti che a volte (spesso) il programma da voi scritto
assume comportamenti differenti da quelli che avevate previsto. \`E
molto comune.  Il Debugging è il processo grazie al quale portate il
programma a svolgere le funzioni per cui è stato scritto correggendo 
gli errori, e vi assicuro, può essere un'operazione lunga e snervante. 
Una volta ho impiegato un'intera settimana per correggere un bug
dovuto allo scambio di una {\tt x} con una {\tt y}.

Questo capitolo sarà più astratto dei precedenti. Vi prego di dirmi se
vi è sembrato utile o meno.

\section{Cosa dovrebbe fare il programma?}

La prima cosa da fare (mi sembra ovvio) è pensare a cosa dovrebbe fare 
il programma se fosse corretto. Iniziate ad eseguire qualche test per 
vedere che cosa succede. Ad esempio, diciamo che ho scritto un 
programma che calcola il perimetro di un rettangolo (la somma dei
quattro lati) e che ho intenzione di testarne il funzionamento
immettendo i seguenti casi:

\begin{tabular}{l | l | l}
Larghezza & Altezza & Perimetro\\
\hline
3 & 4 & 14\\
\hline
2 & 3 & 10\\
\hline
4 & 4 & 16\\
\hline
2 & 2 & 8\\
\hline 
5 & 1 & 12\\

\end{tabular}

Ora avvierò il mio programma ed inserirò i dati dei test per vedere se
restituisce i risultati che mi aspetto. In caso contrario dovrò
scoprire cosa sta facendo il computer.

Comunemente alcuni casi restituiranno il risultato che voglio, mentre
altri risulteranno sbagliati, quindi dovrete vedere cos'hanno in
comune i casi funzionanti. Ecco ad esempio l'output del programma che
calcola il perimetro del rettangolo:

\begin{verbatim}
Height: 3
Width: 4
perimeter =  15
\end{verbatim}
\begin{verbatim}
Height: 2
Width: 3
perimeter =  11
\end{verbatim}
\begin{verbatim}
Height: 4
Width: 4
perimeter =  16
\end{verbatim}
\begin{verbatim}
Height: 2
Width: 2
perimeter =  8
\end{verbatim}
\begin{verbatim}
Height: 5
Width: 1
perimeter =  8
\end{verbatim}

Il programma restituisce un risultato errato nei primi due casi, 
corretto nei seguenti due, per sbagliare di nuovo nell'ultimo. 
Provate ad immaginarvi cos'hanno in comune i casi funzionanti. 
Quando avrete un'idea sul motivo del malfunzionamento, trovarne 
la causa sarà più semplice. Con un vostro programma dovreste 
testare i casi che vi interessano.

\section{Cosa fa il programma?}

La prossima cosa da fare è rileggere il codice sorgente. Una delle 
cose più importanti da fare mentre si programma è leggere e rileggere 
il codice sorgente. Innanzitutto analiziamo il codice linea per 
linea, comportandoci esattamente come farebbe il programma.

Grazie alle strutture di controllo, ovvero i cicli {\tt while} e le
istruzioni {\tt if}, alcune linee di codice possono non essere
eseguite, mentre altre possono essere eseguite più di una
volta. L'importante è che immaginiate ad ogni linea il comportamento
di Python.

Iniziamo con il semplice programma per calcolare il perimetro. Non
scrivetelo, dovete leggerlo e basta. Questo è il sorgente:

\begin{verbatim}
height = input("Height: ")
width = input("Width: ")
print "perimeter = ",width+height+width+width
\end{verbatim}

\question Qual'è la prima linea che Python esegue?

\answer La prima linea è sempre la prima. In questo caso è:
        \verb'height = input("Height: ")'.

\question Qual'è il suo effetto?

\answer Stampa {\tt Height:} sullo schermo e attende l'inserimento
        di un numero da parte dell'utente per assegnarlo alla
        variabile height.

\question Qual'è la prossima linea che Python esegue?

\answer In generale, è la linea successiva, che è 
        \verb'width = input("Width: ")'.

\question Qual'è il suo effetto?

\answer Stampa {\tt Width:}, attende che l'utente inserisca un numero, 
        quindi assegna il valore alla variabile width.

\question Qual'è la prossima linea che eseguirà?

\answer La linea successiva è questa:
        \verb'print "perimeter = ",width+height+width+width'.
        Si può anche eseguire la funzione dalla corrente linea, ma lo
        vedremo meglio nel prossimo capitolo.

\question Qual'è il suo effetto?

\answer Per prima cosa stampa {\tt perimeter =} e poi stamperà 
        {\tt width+height+width+width}.

\question Questa stringa {\tt width+height+width+width} calcola il perimetro?

\answer Vediamo: il perimetro di un rettangolo si calcola sommando la
        base (width) più il lato sinistro (height), più il lato
        superiore (widht), più il lato destro (huh?). L'ultimo
        elemento, (width) dovrebbe essere il lato destro (height) e
        non la base (width).

\question \`E per questo motivo che alcune volte il perimetro risultava corretto?

\answer Certo, risultava corretto perché tutti i lati erano uguali.

Nel prossimo programma vedremo come verrà analizzato il codice,
supponendo che il programma stampi 5 punti sullo schermo. Dunque,
questo è l'output del programma:

\begin{verbatim}
. . . . 
\end{verbatim}

E questo il programma:

\begin{verbatim}
number = 5
while number > 1:
    print ".",
    number = number - 1
print
\end{verbatim}

Questo programma sarà un po' più complesso, perché, 
come potete notare, nel codice è presente una porzione 
indentata (o una struttura di controllo). Bando alle 
ciance, rimbocchiamoci le maniche e cominciamo.

\question Qual'è la prima linea ad essere eseguita?

\answer La prima linea del file: {\tt number = 5}

\question Qual'è il suo effetto?

\answer Assegna il valore 5 alla variabile number.

\question Qual'è la prossima linea?

\answer La prossima linea è: {\tt while number > 1:}

\question Qual'è il suo effetto?

\answer La struttura {\tt while} verifica che l'istruzione
        indentata che segue sia vera o falsa. Nel primo caso esegue
        il codice indentato sotto, nel secondo caso lo salta per
        passare al codice indentato al suo stesso livello.

\question Quindi in questo caso come si comporta?

\answer Se la condizione {\tt number > 1} è vera allora saranno
        eseguite le prossime due linee.

\question Allora {\tt number} è maggiore di uno?

\answer L'ultimo valore assegnato a {\tt number} è {\tt 5} e quindi 
        cinque è maggiore di uno.

\question Qual'è la prossima linea?

\answer Siccome la condizione {\tt while} è vera, la linea successiva
        sarà \verb'print ".",'.

\question Qual'è il suo effetto?

\answer Stamperà un punto, e siccome alla fine dell'istruzione compare
        una virgola ({\tt ``,''}), lo stamperà sulla stessa linea del
        precedente. 

\question Qual'è la prossima linea?

\answer \verb'number = number - 1' visto che la linea successiva non
        modifica il livello d'indentazione.

\question Qual'è il suo effetto?

\answer Calcola {\tt number - 1}, dato che il valore corrente di 
        {\tt number} è 5, gli viene sottratta una unità, creando così
        il nuovo valore. Sostanzialmente il valore di 
        {\tt number} viene modificato da 5 a 4.

\question Qual'è la prossima linea?

\answer Dato che il livello d'indentazione decrementa, dobbiamo
        pensare che tipo di struttura di controllo stiamo
        analizzando. Preso atto che è un ciclo {\tt while}, 
        dobbiamo tornare alla linea \verb'while number > 1:'

\question Qual'è il suo effetto?

\answer Occorre controllare il valore della variabile number, che è 4
        e confrontarla con 1, siccome \verb'4 > 1' il ciclo while
        prosegue.

\question Qual'è la prossima linea?

\answer Siccome il ciclo while è vero, la prossima linea sarà sempre:
        \verb'print ".",'

\question Qual'è il suo effetto?

\answer Stamperà il secondo punto sulla linea.

\question Qual'è la prossima linea?

\answer L'indentazione non è cambiata e quindi:
        \verb'number = number - 1'

\question Ed ora cosa succede?

\answer Al corrente valore di number (4), sottraiamo 1, che
       restituisce 3, quindi il nuovo valore assegnato alla variabile
       number sarà 3.

\question Qual'è la prossima linea?

\answer Siccome è verificata la condizione del ciclo while, la linea
        successiva sarà sempre \verb'print ".",'.

\question Qual'è la prossima linea?

\answer Siccome l'indentazione non è modificata, il che causerebbe
        l'interruzione del ciclo, la prossima linea sarà sempre: 
        \verb'while number > 1:'.

\question Qual'è il suo effetto?

\answer Compara il valore corrente di number (3) con 1.  \verb'3 > 1'
        perciò il ciclo while continua.

\question Qual'è la prossima linea?

\answer Siccome è verificata la condizione del ciclo while, la linea
        successiva sarà sempre \verb'print ".",'.

\question Ed ora cosa succede?

\answer Un altro punto sulla linea.

\question Qual'è la prossima linea?

\answer \`E sempre: \verb'number = number - 1'

\question Qual'è il suo effetto?

\answer Prende il valore corrente di number (3), gli sottrae 1 e
        imposta a 2 il nuovo valore.

\question E adesso cosa succede?

\answer Si ricomincia da capo: \verb'while number > 1:'

\question Qual'è il suo effetto?

\answer Confronta il valore corrente di number (2) con 1. Siccome 
        \verb'2 > 1' il ciclo while continua.

\question Qual'è la prossima linea?

\answer Il ciclo while prosegue: \verb'print ".",'

\question Qual'è il suo effetto?

\answer Scoprirete il senso della vita, l'universo sarà vostro.  Sto
        scherzando (così sono sicuro che vi sveglierete). Stampa il
        quarto punto sullo schermo.

\question Qual'è la prossima linea?

\answer \`E: \verb'number = number - 1'

\question Qual'è il suo effetto?

\answer Prende il valore corrente di number (2) gli sottrae 1 e
        imposta ad 1 il nuovo valore.

\question Qual'è la prossima linea?

\answer Torniamo al ciclo while: \verb'while number > 1:'

\question Qual'è il suo effetto?

\answer Compara il corrente valore di number (1) con 1. Siccome
        \verb'1 > 1' è falso (uno non è più grande di uno), il ciclo
        while termina.

\question Qual'è la prossima linea?

\answer Siccome la condizione del ciclo while è falsa, la prossima
        linea analizzata, dopo l'uscita dal ciclo, sarà \verb'print'.

\question Qual'è il suo effetto?

\answer Stampa sullo schermo un'altra linea, vuota.

\question Ma il programma non doveva stampare 5 punti?

\answer Il ciclo termina troppo presto e non stampa 1 punto.

\question Come posso riparare questo difetto?

\answer Creare un ciclo che termina dopo aver stampato l'ultimo punto.

\question E come posso realizzarlo?

\answer Ci sono molte possibilità. Una via è modificare il ciclo così: 
        \verb'while number > 0:'. Un'altra è questa: 
        \verb'number >= 1'. Esistono molti altri metodi.

\section{Come posso riparare ad un errore nel programma?}

Dovete capire cosa sta facendo il programma. Immaginarvi cosa
dovrebbe fare il programma, confrontare e capire le differenza dei
metodi che provate. Il Debugging si impara grazie all'esperienza. Se non
riuscite a trovare il difetto dopo un'ora o due, fate una pausa e
parlatene con qualcuno. Quando ci ritornerete sopra probabilmente
avrete nuove idee per risolvere il problema. Buona fortuna.

%%TODO:  add code walkthrough for dots.py

\chapter{Definire le Funzioni}
\section{Creare funzioni}
Inizierò questo capitolo mostrandovi, con un esempio, cosa potreste,
ma non dovreste fare (quindi non scrivete):
\begin{verbatim}
a = 23
b = -23

if a < 0:
    a = -a

if b < 0:
    b = -b

if a == b:
    print "The absolute values of", a,"and",b,"are equal"
else:
    print "The absolute values of a and b are different"
\end{verbatim}
Con questo output:
\begin{verbatim}
The absolute values of 23 and 23 are equal
\end{verbatim}
Il programma sembra un po' ripetitivo (e i programmatori odiano
ripetere le cose, altrimenti i computer a cosa
servono??). Fortunatamente Python permette di creare funzioni per
rimuovere i duplicati. Ecco l'esempio riscritto: 
\begin{verbatim}
a = 23
b = -23

def my_abs(num):
    if num < 0:
        num = -num
    return num

if my_abs(a) == my_abs(b):
    print "The absolute values of", a,"and",b,"are equal"
else:
    print "The absolute values of a and b are different"
\end{verbatim}
Con questo output:
\begin{verbatim}
The absolute values of 23 and -23 are equal
\end{verbatim}
L'elemento chiave di questo programma è l'istruzione {\tt def}. 
{\tt def} (abbreviazione di define, definisci) inizializza la
definizione di una funzione. {\tt def} è seguita dal nome della
funzione {\tt my_abs}. Poi troviamo una {\tt ``(``} seguita dal
parametro {\tt num} ({\tt num} viene passato dal programma ad ogni
chiamata di funzione). Le istruzioni dopo il {\tt :} vengono eseguite
ogni volta che la funzione viene usata dal programma e si possono
distinguere dalle normali righe di codice perché sono indentate sotto
la funzione. Quando l'indentazione torna al livello della funzione o
quando incontra l'istruzione {\tt return} la funzione
termina. L'istruzione {\tt return} ritorna il valore assunto nel punto
in cui è chiamata nella funzione.

Osservate che i valori {\tt a} e {\tt b} non sono cambiati. Le
funzioni, naturalmente, possono essere usate anche per ripetere azioni
che non ritornano alcun valore. Eccone alcuni esempi:
\begin{verbatim}
def hello():
    print "Hello"

def area(width,height):
    return width*height

def print_welcome(name):
    print "Welcome",name
    
hello()
hello()

print_welcome("Fred")
w = 4
h = 5
print "width =",w,"height =",h,"area =",area(w,h)
\end{verbatim}
Con questo output:
\begin{verbatim}
Hello
Hello
Welcome Fred
width = 4 height = 5 area = 20
\end{verbatim}
Questo esempio mostra solamente un po' più in profondità in quanti
differenti modi si possono utilizzare le funzioni. Osservate
attentamente, potete anche non dare argomenti ad una funzione, così
come potete dargliene più d'uno. Notate anche che return è opzionale.

%Functions can be used to eliminate repeat code.

\section{Variabili nelle funzioni}

Naturalmente troverete spesso variabili nel codice duplicato che
andrete ad eliminare. Queste variabili vengono trattate da Python in
modo speciale. Fino ad ora tutte le variabili che abbiamo visto erano
variabili globali. Le funzioni usano variabili particolari chiamate
variabili locali. Queste variabili esistono solamente per la durata
della funzione. Quando una variabile locale ha lo stesso nome di una
variabile globale, la variabile  locale nasconde l'altra
variabile. Siete confusi? Beh, il prossimo esempio dovrebbe chiarire
un po' le cose.

\begin{verbatim}
a_var = 10
b_var = 15
e_var = 25

def a_func(a_var):
    print "in a_func a_var = ",a_var
    b_var = 100 + a_var
    d_var = 2*a_var
    print "in a_func b_var = ",b_var
    print "in a_func d_var = ",d_var
    print "in a_func e_var = ",e_var
    return b_var + 10

c_var = a_func(b_var)

print "a_var = ",a_var
print "b_var = ",b_var
print "c_var = ",c_var
print "d_var = ",d_var
\end{verbatim}

L'output è:
\begin{verbatim}

in a_func a_var =  15
in a_func b_var =  115
in a_func d_var =  30
in a_func e_var =  25
a_var =  10
b_var =  15
c_var =  125
d_var = 
Traceback (innermost last):
  File "separate.py", line 20, in ?
    print "d_var = ",d_var
NameError: d_var
\end{verbatim}

In questo esempio le variabili {\tt a_var}, {\tt b_var} e {\tt d_var}
sono variabili locali quando sono all'interno della funzione 
{\tt a_func}. Dopo che l'istruzione {\tt return b_var + 10} viene
eseguita, non esisteranno più. La variabile {\tt a_var} è
automaticamente una variabile locale, dato che è un nome di
parametro. Le variabili {\tt b_var} e {\tt d_var} sono variabili
locali, dato che compaiono nella parte sinistra di un assegnamento,
all'interno della funzione nelle istruzioni \verb'b_var = 100 + a_var'
e \verb'd_var = 2*a_var'.

All'interno della funzione {\tt a_var} è 15 finché la funzione viene
chiamata con {\tt a_func(b_var)}. Visto che fino a quel punto 
{\tt b_var} corrisponde a 15, la chiamata alla funzione è
{\tt a_func(15)}, che di conseguenza assegna 15 ad {\tt a_var}
all'interno di {\tt a_func}.

Come potete vedere, nel momento in cui la funzione finisce di essere
eseguita, le variabili locali {\tt a_var} e {\tt b_var}, che fino a
quel momento hanno nascosto le variabili globali con lo stesso nome,
sono svanite. Quindi l'istruzione \verb'print "a_var = ",a_var'
restituisce il valore {\tt 10} piuttosto che {\tt 15}, proprio
perché la variabile locale non esiste più.

Un'altra cosa da notare è il {\tt NameError} che avviene alla
fine. Questo errore è dovuto al fatto che la variabile {\tt d_var} non
esiste più. Tutte le varibili locali vengono cancellato quando si esce
dalla {\tt a_funzione} in cui sono state definite. Se volete ritornare
un valore da una funzione dovete usare {\tt return qualcosa}. 

L'ultimo particolare è che il valore di {\tt e_var} rimane invariato
all'interno di {\tt a_func}, visto che non è un parametro e non viene
ridefinito all'interno della funzione {\tt a_func}. Quando si accede
ad una variabile globale dall'interno di una funzione, è come
accedervi dall'esterno, rimane invariata.

Le funzioni permettono alle variabili locali di esistere solo ed
unicamente all'interno della funzione stessa, e possono nascondere le
altre variabili definite all'esterno della funzione.

\section{Analizzare le funzioni}

%{\em TODO}, spostare questa sezione all'interno di un nuovo capitolo, funzioni avanzate.

Ora esamineremo il seguente programma linea per linea:
\begin{verbatim}
def mult(a,b):
    if b == 0:
        return 0
    rest = mult(a,b - 1)
    value = a + rest
    return value

print "3*2 = ",mult(3,2)
\end{verbatim}

Il programma crea una funzione che moltiplica un intero positivo (il
che è nettamente più lento rispetto alla funzione di moltiplicazione
built-in), dopodiché ne dimostra l'utilizzo.

\question Qual'è la prima cosa che fa il programma?

\answer La prima cosa che fa è definire la funzione mult() con queste linee:
\begin{verbatim}
def mult(a,b):
    if b == 0:
        return 0
    rest = mult(a,b - 1)
    value = a + rest
    return value
\end{verbatim}
Queste righe realizzano una funzione che prende due parametri e
ritornano un valore. Più tardi questa funzione sarà eseguita. 

\question Ed ora cosa succede?  

\answer Viene eseguita la linea successiva dopo la funzione,
\verb'print "3*2 = ",mult(3,2)'.

\question E cosa fa?

\answer Stampa \verb'3*2 = ' e ritorna il valore di \verb'mult(3,2)'

\question E cosa ritorna \verb'mult(3,2)'?

\answer Esaminiamo la funzione {\tt mult} passo per passo per
        scoprirlo. Alla variabile {\tt a} viene assegnato il valore 
        3 mentre alla variabile {\tt b} viene assegnato il valore 2. 

\question E poi?

\answer La linea \verb'if b == 0:' viene eseguita. Visto che {\tt b}
        ha il valore 2 la condizione è falsa e \verb' return 0'
        viene saltato. 

\question E poi?

\answer La linea \verb'rest = mult(a,b - 1)' viene eseguita. Questa
        linea assegna la variabile locale {\tt rest} al valore
        ritornato da '\verb'mult(a,b - 1)'. Il valore di {\tt a} è 3 e
        il valore di {\tt b} è 2 quindi la chiamata di funzione è 
	\verb'mult(3,1)'.

\question Quindi qual'è il valore di \verb'mult(3,1)'?

\answer Dobbiamo eseguire la funzione {\tt mult} con i parametri 3 ed 1.

\question Ovvero?

\answer Le variabili locali nella {\em nuova} esecuzione della
        funzione hanno valori differenti: {\tt a} ha il valore 3,
        mentre {\tt b} ha il valore 1. Dato che sono variabili
        locali esse non hanno  nulla a che vedere con i precedenti
        valori di {\tt a} e {\tt b}.

\question E quindi?

\answer Visto che {\tt b} ha il valore 1 la condizione if è falsa,
        quindi la linea successiva diventa \verb'rest = mult(a,b - 1)'.

\question Cosa fa questa linea?

\answer Questa linea assegnerà il valore di '{\tt mult(3,0)} a rest.

\question E qual'è il suo valore?

\answer Dobbiamo calcolare la funzione un'altra volta, questa volta con i
        valori 3 per {\tt a} e 0 per {\tt b}.

\question Cosa succede ora?

\answer La prima linea della funzione ad essere eseguita è
        \verb'if b == 0:'. {\tt b} ha il valore 0 e quindi la condizione
        risulta vera. Quindi la prossima linea da eseguire è
        \verb'return 0'. 

\question E cosa fa la linea \verb'return 0'?

\answer Ritorna il valore 0 all'esterno della funzione.

\question Quindi?

\answer Quindi ora sappiamo che il risultato di {\tt mult(3,0)} è
        0. Ora che abbiamo un valore di ritorno possiamo tornare a 
	{\tt mult(3,1)}, assegnando alla variabile rest il valore 0.

\question Che linea viene eseguita ora?

\answer La linea \verb'value = a + rest', dove \verb'a=3' e
        \verb'rest=0', quindi \verb'value=3'.

\question Cosa succede adesso?

\answer La linea \verb'return value' viene eseguita. Questa linea
        ritorna il valore 3 ed esce dalla funzione {\tt
        mult(3,1)}. Dopo che {\tt return} viene eseguito, torniamo
        alla funzione {\tt mult(3,2)}. 

\question Dove eravamo in {\tt mult(3,2)}?

\answer Avevamo le variabili \verb'a=3', \verb'b=2' e stavamo
        esaminando la linea \verb'rest = mult(a,b - 1)'.

\question Cosa succede ora?

\answer La variabile {\tt rest} assume il valore 3. La prossima
        linea \verb'value = a + rest' assegna a {\tt value} il valore
        di {\tt 3+3}, ovvero 6. 

\question E ora?

\answer La prossima linea viene eseguita, ovvero il valore 6 viene
        ritornato dalla funzione. Ora siamo tornati alla linea
        \verb'print "3*2 = ",mult(3,2)' e il risultato finale, 6, può
        essere stampato sullo schermo. 

\question Cos'è successo in definitiva?  

\answer Praticamente, dando per scontato che ogni numero moltiplicato
        per zero dia a sua volta 0, e che un numero moltiplicato per
        un'altro numero è sempre uguale al primo numero + il primo
        numero per il secondo - 1 ({\tt x * y = x + x * (y - 1)}),
        abbiamo moltiplicato due numeri. Ciò che accade è che {\tt
        3*2} viene inizialmente convertito in {\tt 3 + 3*1}. Quindi
        {\tt 3*1} è convertito in {\tt 3 + 3*0}. Sapendo che ogni
        numero moltiplicato per 0 risulta 0, siamo tornati indietro ed
        abbiamo calcolato {\tt 3 + 3*0}. Conoscendo il risultato di
        {\tt 3*1} possiamo calcolare che {\tt 3 + 3*1} è {\tt 3 + 3},
        che risulta 6. 

Questo è come si presenta il tutto:

\begin{verbatim}
3*2
3 + 3*1
3 + 3 + 3*0
3 + 3 + 0
3 + 3
6
\end{verbatim}

Queste due ultime sezioni sono state scritte di recente. Se aveste dei
commenti o riscontraste errori, siete pregati di spedirmi un'email. 
Vorrei sapere se ho passato del tempo a creare semplicemente cose
incomprensibili. Se il resto del tutorial vi sembra che abbia senso,
ma non questa sezione, è probabile che la colpa sia mia, mi piacerebbe
saperlo. 
Grazie.

\section{Esempi}

\file{factorial.py}
\begin{verbatim}
# Definisce una funzione che calcola il fattoriale.

def factorial(n):
    if n <= 1:
        return 1
    return n*factorial(n-1)

print "2! = ",factorial(2)
print "3! = ",factorial(3)
print "4! = ",factorial(4)
print "5! = ",factorial(5)
\end{verbatim}

Output:
\begin{verbatim}
2! =  2
3! =  6
4! =  24
5! =  120
\end{verbatim}

\file{temperature2.py}
\begin{verbatim}
# Converte la temperatura in Fahrenheit o Celsius.

def print_options():
    print "Options:"
    print " 'p' print options"
    print " 'c' convert from celsius"
    print " 'f' convert from fahrenheit"
    print " 'q' quit the program"

def celsius_to_fahrenheit(c_temp):
    return 9.0/5.0*c_temp+32

def fahrenheit_to_celsius(f_temp):
    return (f_temp - 32.0)*5.0/9.0

choice = "p"
while choice != "q":
    if choice == "c":
        temp = input("Celsius temperature:")
        print "Fahrenheit:",celsius_to_fahrenheit(temp)
    elif choice == "f":
        temp = input("Fahrenheit temperature:")
        print "Celsius:",fahrenheit_to_celsius(temp)
    elif choice != "q":
        print_options()
    choice = raw_input("option:")
\end{verbatim}

Semplice esecuzione:
\begin{verbatim}
> python temperature2.py
Options:
 'p' print options
 'c' convert from celsius
 'f' convert from fahrenheit
 'q' quit the program
option:c
Celsius temperature:30 
Fahrenheit: 86.0
option:f
Fahrenheit temperature:60
Celsius: 15.5555555556
option:q
\end{verbatim}

\file{area2.py}
\begin{verbatim}
# Di Amos Satterlee
print
def hello():
    print 'Hello!'

def area(width,height):
    return width*height

def print_welcome(name):
    print 'Welcome,',name

name = raw_input('Your Name: ')
hello(),
print_welcome(name)
print
print 'To find the area of a rectangle,'
print 'Enter the width and height below.'
print
w = input('Width:  ')
while w <= 0:
    print 'Must be a positive number'
    w = input('Width:  ')
h = input('Height: ')
while h <= 0:
    print 'Must be a positive number'
    h = input('Height: ')
print 'Width =',w,' Height =',h,' so Area =',area(w,h)
\end{verbatim}

Semplice esecuzione:
\begin{verbatim}

Your Name: Josh
Hello!
Welcome, Josh

To find the area of a rectangle,
Enter the width and height below.

Width:  -4
Must be a positive number
Width:  4
Height: 3
Width = 4  Height = 3  so Area = 12
\end{verbatim}

\section{Esercizi}

Riscrivete il programma \file{area.py} della sezione \ref{firstarea},
definendo funzioni separate per l'area del quadrato, del rettangolo e
del cerchio (3.14 * raggio**2). Il programma deve includere anche
un'interfaccia a menu.








\chapter{Liste}
\section{Variabili con più di un valore}
Avete già visto le variabili ordinarie che immagazzinano un singolo valore.
Tuttavia esistono altri tipi di variabili che possono contenere più di un
valore. Queste variabili vengono chiamate liste. Ecco un esempio
del'utilizzo delle liste:


\begin{verbatim}
which_one = input("What month (1-12)? ")
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',\
        'August', 'September', 'October', 'November', 'December']
if 1 <= which_one <= 12:
        print "The month is",months[which_one - 1]
\end{verbatim}
 
E questo l'output dell'esempio:
\begin{verbatim}
What month (1-12)? 3
The month is March
\end{verbatim}

In questo esempio la variabile {\tt months} è una lista. {\tt months}
è definita dalla linea 
{\tt months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',\verb'\' 'August', 'September', 'October', 'November', 'December']}
(osserva nel codice che \verb'\' permette di andare a capo quando la
linea di codice è troppo lunga). Le parentesi quadrate \verb'[' e
\verb']' iniziano e finiscono la lista e la virgola (``\verb',''')
separa un elemento della lista dall'altro. La lista qui descritta
viene usata nell'istruzione \verb'months[which_one - 1]' e consiste in
un insieme di elementi numerati partendo da 0. In altre parole, se
cercate l'elemento January dovrete utilizzare {\tt months[0]}. Ovvero,
quando assegnate ad una lista un numero, utilizzando la sintassi appena
descritta, essa ritornerà l'elemento immagazzinato nella locazione
corrispondente.

L'istruzione {\tt if 1 <= which_one <= 12:} sarà vera solo nel caso in
cui {\tt which_one} sia un numero tra 1 e 12 inclusi. In altre parole,
segue le regole dell'algebra.

Le liste possono essere pensate come una serie di scatole. Ad esempio le
scatole create da {\tt demolist = ['life',42, 'the universe', 6,'and',7]} 
sarebbero all'incirca così:

\begin{tabular}{l | c | c | c | c | c | c |}
box number & 0 & 1 & 2 & 3 & 4 & 5 \\
\hline
demolist & `life' & 42 & `the universe' & 6 & `and' & 7\\
\hline
\end{tabular}

Ogni scatola ha un numero di riferimento, cosicché l'istruzione 
{\tt demolist[0]} seleziona l'elemento {\tt 'life'} dalla lista, 
{\tt demolist[1]} l'elemento {\tt 42}, {\tt demolist[5]} l'elemento
{\tt 7}.


\section{Altre funzioni delle liste}
Il prossimo esempio vi mostrerà moltissimi altri utilizzi per le liste
(non mi aspetto che proviate ogni esempio, ma dovreste provarli finché
non vi sentite a vostro agio nell'utilizzo delle liste). Iniziamo:
\begin{verbatim}
demolist = ['life',42, 'the universe', 6,'and',7]
print 'demolist = ',demolist
demolist.append('everything')
print "after 'everything' was appended demolist is now:"
print demolist
print 'len(demolist) =', len(demolist)
print 'demolist.index(42) =',demolist.index(42)
print 'demolist[1] =', demolist[1]
# Il prossimo ciclo analizza la lista.
c = 0
while c < len(demolist):
    print 'demolist[',c,']=',demolist[c]
    c = c + 1
del demolist[2]
print "After 'the universe' was removed demolist is now:"
print demolist
if 'life' in demolist:
    print "'life' was found in demolist"
else:
    print "'life' was not found in demolist"
if 'amoeba' in demolist:
    print "'amoeba' was found in demolist"
if 'amoeba' not in demolist:
    print "'amoeba' was not found in demolist"
demolist.sort()
print 'The sorted demolist is ',demolist
\end{verbatim}

E questo è l'output:
\begin{verbatim}
demolist =  ['life', 42, 'the universe', 6, 'and', 7]
after 'everything' was appended demolist is now:
['life', 42, 'the universe', 6, 'and', 7, 'everything']
len(demolist) = 7
demolist.index(42) = 1
demolist[1] = 42
demolist[ 0 ]= life
demolist[ 1 ]= 42
demolist[ 2 ]= the universe
demolist[ 3 ]= 6
demolist[ 4 ]= and
demolist[ 5 ]= 7
demolist[ 6 ]= everything
After 'the universe' was removed demolist is now:
['life', 42, 6, 'and', 7, 'everything']
'life' was found in demolist
'amoeba' was not found in demolist
The sorted demolist is  [6, 7, 42, 'and', 'everything', 'life']
\end{verbatim}

Questo esempio utilizza moltissime nuove funzioni. Ad esempio guardate
come potete stampare ({\tt print}) un'intera lista per poi aggiungere
nuovi elementi con la funzione {\tt append}. \verb'len' serve a
contare quanti elementi sono presenti nella lista. Le entrate 
({\tt index}) valide di una lista (cioè quelle richiamabili grazie a
nome_lista [numero dell'elemento]) vanno da 0 a {\tt len - 1}. La
funzione {\tt index} serve a sapere la posizione di un elemento in una
lista. Nel caso esistano elementi con lo stesso nome ritornerà la
prima posizione dell'elemento. Osservate come l'istruzione 
\verb'demolist.index(42)' ritorni il valore 1 e l'istruzione 
\verb'demolist[1]' ritorni il valore 42. La linea 
\verb'# Il prossimo ciclo analizza la lista' è un semplice commento
usato per introdurre le prossime righe di codice:
\begin{verbatim}
c = 0
while c < len(demolist):
    print 'demolist[',c,']=',demolist[c]
    c = c + 1
\end{verbatim} 
Crea una variabile {\tt c} inizialmente di valore 0 che viene
incrementata finché non raggiunge l'ultimo elemento della lista. Nel
frattempo l'istruzione {\tt print} stampa ogni elemento della lista.

L'istruzione \verb'del' può essere usata per rimuovere un elemento
dalla lista. Le linee successive utilizzano l'operatore {\tt in} per
sapere se un elemento è presente o meno nella lista.

La funzione \verb'sort' ordina la lista ed è utile se avete bisogno di
una lista ordinata dall'elemento più piccolo a quello più grande,
oppure in ordine alfabetico. Notate che questo comporta elaborare
nuovamente la lista.

Riassumendo possiamo compiere le seguenti operazioni:

\begin{tabular}{l | l}
esempio & spiegazione\\
\hline
{\tt list[2]} & accesso all'elemento 2 dell'indice\\
{\tt list[2] = 3} & imposta a 3 l'elemento 2 dell'indice\\
{\tt del list[2] } & cancella l'elemento 2 dall'indice\\
{\tt len(list)} & restituisci la lunghezza della lista\\
{\tt "value" in list} & è vero se {\tt "value"} è un elemento della lista\\
{\tt "value" not in list} & è vero se {\tt "value"} non è un elemento della lista\\
{\tt list.sort()} & ordina la lista\\
{\tt list.index("value")} & restituisce l'indice dove viene trovata la prima occorrenza di {\tt "value"}\\
{\tt list.append("value")} & aggiunge l'elemento {\tt "value"} alla fine della lista\\
\end{tabular}


Il prossimo esempio applica queste funzioni per qualcosa di più utile:
\begin{verbatim}
menu_item = 0
list = []
while menu_item != 9:
        print "--------------------"
        print "1. Print the list"
        print "2. Add a name to the list"
        print "3. Remove a name from the list"
        print "4. Change an item in the list"
        print "9. Quit"
        menu_item = input("Pick an item from the menu: ")
        if menu_item == 1:
                current = 0
                if len(list) > 0:
                        while current < len(list):
                                print current,". ",list[current]
                                current = current + 1
                else:
                        print "List is empty"
        elif menu_item == 2:
                name = raw_input("Type in a name to add: ")
                list.append(name)
        elif menu_item == 3:
                del_name = raw_input("What name would you like to remove: ")
                if del_name in list:
                        item_number = list.index(del_name)
                        del list[item_number]
                        # Il codice precedente rimuove solamente le
                        # prime occorrenze di name. Quello successivo,
                        # da Gerald, rimuove tutto. 
                        # while del_name in list:
                        #        item_number = list.index(del_name)
                        #        del list[item_number]
                else:
                        print del_name," was not found"
        elif menu_item == 4:
                old_name = raw_input("What name would you like to change: ")
                if old_name in list:
                        item_number = list.index(old_name)
                        new_name = raw_input("What is the new name: ")
                        list[item_number] = new_name
                else:
                        print old_name," was not found"
print "Goodbye"
\end{verbatim}

Ecco una parte dell'output:

\begin{verbatim}
--------------------
1. Print the list
2. Add a name to the list
3. Remove a name from the list
4. Change an item in the list
9. Quit

Pick an item from the menu: 2
Type in a name to add: Jack

Pick an item from the menu: 2
Type in a name to add: Jill

Pick an item from the menu: 1
0 .  Jack
1 .  Jill

Pick an item from the menu: 3
What name would you like to remove: Jack

Pick an item from the menu: 4
What name would you like to change: Jill
What is the new name: Jill Peters

Pick an item from the menu: 1
0 .  Jill Peters

Pick an item from the menu: 9
Goodbye
\end{verbatim}

\`E un programma abbastanza lungo, diamo un'occhiata al codice
sorgente per capirlo meglio. La linea {\tt list = []} crea una
variabile {\tt list} senza elementi al suo interno. La prossima linea
importante è \verb'while menu_item != 9:'. Questa linea inizia un
ciclo che permette di ottenere il menu di questo programma. Le linee
seguenti del programma visualizzano un menu per permettere di decidere
quale parte del programma eseguire.

La sezione:
\begin{verbatim}
current = 0
if len(list) > 0:
        while current < len(list):
                print current,". ",list[current]
                current = current + 1
else:
        print "List is empty"
\end{verbatim}
Scorre tutta la lista e visualizza ogni suo elemento. 
\verb'len(list_name)' conta quanti elementi sono presenti 
nella lista, se {\tt len} ritorna \verb'0' significa che la lista è
vuota. 

Poche linee più sotto appare l'istruzione {\tt list.append(name)} che
aggiunge un elemento alla fine della lista. Saltate giù di un'altro
paio di linee e osservate questa sezione di codice:
\begin{verbatim}
item_number = list.index(del_name)
del list[item_number]
\end{verbatim}
Qui la funzione {\tt index} viene utilizzata per trovare l'indice
dell'elemento richiesto, per poi utilizzarlo nella sua
cancellazione. \verb'del list[item_number]' viene utilizzato appunto
per rimuovere l'elemento dalla lista.

La prossima sezione:
\begin{verbatim}
old_name = raw_input("What name would you like to change: ")
if old_name in list:
        item_number = list.index(old_name)
        new_name = raw_input("What is the new name: ")
        list[item_number] = new_name
else:
        print old_name," was not found"
\end{verbatim}
Usa {\tt index} per cercare l'elemento \verb'item_number' ed assegnare
il nuovo valore desiderato, \verb'new_name', alla variabile
\verb'old_name'.

Congratulazioni, con le liste sotto il vostro controllo, conoscete
abbastanza il linguaggio da poter compiere ogni genere di calcolo che
il computer può svolgere (questo tecnicamente sottintende la
conoscenza della macchina di Turing). Naturalmente ci sono ancora
molte altre funzionalità che vi possono rendere la vita più
semplice. %%%TODO. 

\section{Esempi}

\file{test.py}
\begin{verbatim}
## Questo programma verifica la vostra conoscenza.

true = 1
false = 0

# Prima ottieni il questionario, successivamente sarà modificato 
# per l'uso del file IO. 
def get_questions():
    # Nota come il dato viene magazzinato in una lista di liste.
    return [["What color is the daytime sky on a clear day?","blue"],\
            ["What is the answer to life, the universe and everything?","42"],\
            ["What is a three letter word for mouse trap?","cat"]]
\end{verbatim}
\begin{verbatim}

# Questo verificherà una singola domanda, restituirà vero, se l'utente
# ha scritto la risposta corretta, altrimenti restituirà falso.
def check_question(question_and_answer):
    # Estrai la domanda e la risposta dalla lista.
    question = question_and_answer[0]
    answer = question_and_answer[1]
    # Poni la domanda all'utente.
    given_answer = raw_input(question)
    # Confronta le risposte dell'utente con quelle del test.
    if answer == given_answer:
        print "Correct"
        return true
    else:
        print "Incorrect, correct was:",answer
        return false
\end{verbatim}
\begin{verbatim}

# Questa funzione effettuerà tutte le domande.
def run_test(questions):
    if len(questions) == 0:
        print "No questions were given."
        # Esce dalla funzione.
        return
    index = 0
    right = 0
    while index < len(questions):
        # Controlla la domanda.
        if check_question(questions[index]):
            right = right + 1
        # Vai alla prossima domanda.
        index = index + 1
    # Attenzione all'ordine dei conteggi, prima moltiplica, poi dividi.
    print "You got ",right*100/len(questions),"% right out of",len(questions)

# Adesso esegui la funzione sulle domande.
run_test(get_questions())
\end{verbatim}

Semplice output:
\begin{verbatim}
What color is the daytime sky on a clear day?green
Incorrect, correct was: blue
What is the answer to life, the universe and everything?42
Correct
What is a three letter word for mouse trap?cat
Correct
You got  66 % right out of 3
\end{verbatim}

\section{Esercizi}

Espandete il programma \file{test.py} in modo che abbia un menu per
selezionare le opzioni del test, visualizzi la lista delle domande
ed un'opzione per terminare l'esecuzione. Aggiungete inoltre un'altra
domanda: "What noise does a truly advanced machine make ?" la risposta
sarà "Ping".

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%








\chapter{Cicli For}
Qui il nuovo esercizio da scrivere per questo capitolo:
\begin{verbatim}
onetoten = range(1,11)
for count in onetoten:
        print count
\end{verbatim}
E qui l'onnipresente output:
\begin{verbatim}
1
2
3
4
5
6
7
8
9
10
\end{verbatim}
L'output è familiare ma il codice è diverso. La prima linea utilizza
la funzione {\tt range}, usa due argomenti, proprio come
nell'esempio: {\tt range(inizio,fine)}. {\tt inizio} è il primo
numero che viene prodotto, mentre {\tt fine} è maggiore di 1
dell'ultimo numero prodotto. Questo programma avrebbe anche potuto
essere scritto più brevemente: 
\begin{verbatim}
for count in range(1,11):
        print count
\end{verbatim}
Ecco a voi alcuni esempi per comprendere meglio il funzionamento di
{\tt range}:
\begin{verbatim}
>>> range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(-32, -20)
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> range(5,21)
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> range(21,5)
[]
\end{verbatim}
Avrete certamente notato la presenza di una nuova struttura di
controllo, \verb'for count in onetoten:', gli esempi infatti usano la
struttura {\tt for}. La sintassi della struttura di controllo 
{\tt  for} è simile a {\tt for variabile in lista:}. La {\tt lista}
viene quindi analizzata dal primo elemento sino all'ultimo. Mentre
il ciclo {\tt for} compie il suo tragitto, ogni elemento viene inserito
in una {\tt variabile}. Questo consente alla {\tt variabile} di essere
usata successivamente, in qualsiasi momento, in ogni ciclo {\tt for}
attivo. Qui un'altro esempio (non dovete scriverlo) per dimostrarlo:
\begin{verbatim}
demolist = ['life',42, 'the universe', 6,'and',7,'everything']
for item in demolist:
    print "The Current item is:",
    print item
\end{verbatim}
L'output è:
\begin{verbatim}
The Current item is: life
The Current item is: 42
The Current item is: the universe
The Current item is: 6
The Current item is: and
The Current item is: 7
The Current item is: everything
\end{verbatim}
Osservate come il ciclo {\tt for} scorra tutti gli elementi nella
lista - provate ad esempio a togliere la virgola alla fine
dell'istruzione {\tt print} o a cambiare il testo all'interno della
stessa... Quindi, a cosa serve il {\tt for}? Beh, serve a scorrere uno
ad uno tutti gli elementi di una lista e a fare qualcosa con ognuno di
essi. Questo è un esempio dove sono sommati tutti gli elementi:
\begin{verbatim}
list = [2,4,6,8]
sum = 0
for num in list:
        sum = sum + num
print "The sum is: ",sum
\end{verbatim}
Con questo semplice output:
\begin{verbatim}
The sum is:  20
\end{verbatim}
Altrimenti potreste scrivere un semplice programma per trovare i
duplicati in una lista, come in questo programma:
\begin{verbatim}
list = [4, 5, 7, 8, 9, 1,0,7,10]
list.sort()
prev = list[0]
del list[0]
for item in list:
        if prev == item:
                print "Duplicate of ",prev," Found"
        prev = item
\end{verbatim}
Il cui output è ovviamente:
\begin{verbatim}
Duplicate of  7  Found
\end{verbatim}
Va bene, allora come funziona? Scriviamo il programma in modo che
ritorni un risultato passaggio per passaggio, qualcosa di molto simile
al debugging:
\begin{verbatim}
l = [4, 5, 7, 8, 9, 1,0,7,10]
print "l = [4, 5, 7, 8, 9, 1,0,7,10]","\tl:",l
l.sort()
print "l.sort()","\tl:",l
prev = l[0]
print "prev = l[0]","\tprev:",prev
del l[0]
print "del l[0]","\tl:",l
for item in l:
        if prev == item:
                print "Duplicate of ",prev," Found"
        print "if prev == item:","\tprev:",prev,"\titem:",item
        prev = item
        print "prev = item","\t\tprev:",prev,"\titem:",item
\end{verbatim}
L'output è cambiato:
\begin{verbatim}
l = [4, 5, 7, 8, 9, 1,0,7,10]   l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort()        l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
prev = l[0]     prev: 0
del l[0]        l: [1, 4, 5, 7, 7, 8, 9, 10]
if prev == item:        prev: 0         item: 1
prev = item             prev: 1         item: 1
if prev == item:        prev: 1         item: 4
prev = item             prev: 4         item: 4
if prev == item:        prev: 4         item: 5
prev = item             prev: 5         item: 5
if prev == item:        prev: 5         item: 7
prev = item             prev: 7         item: 7
Duplicate of  7  Found
if prev == item:        prev: 7         item: 7
prev = item             prev: 7         item: 7
if prev == item:        prev: 7         item: 8
prev = item             prev: 8         item: 8
if prev == item:        prev: 8         item: 9
prev = item             prev: 9         item: 9
if prev == item:        prev: 9         item: 10
prev = item             prev: 10        item: 10
\end{verbatim}
La ragione per cui sono stati inseriti così tanti {\tt print} nel codice è che
in questo modo riusciamo a vedere il comportamento del programma linea
per linea (quindi se non riuscite ad immaginare il problema di un
programma malfunzionante tentate di mettere molti print per
individuarlo con più facilità).
Il programma inizia con la nostra solita noiosa e vecchia lista, ordinata
nella seconda linea a seconda del valore degli elementi (dal minore al
maggiore), in modo che ogni duplicato, se ce ne sono, sia vicino
all'originale da cui proviene. Dopo questi primi passi viene
inizializzata una variabile, prev(ious). Il primo elemento della lista
(0) viene cancellato perché altrimenti sarebbe incorrettamente
sembrato un duplicato della variabile prev. La linea successiva, come
potete vedere, è un ciclo {\tt for}. Ogni singolo elemento della lista viene
in questo modo testato e confrontato con il precedente per riconoscere
eventuali duplicati. Questo avviene memorizzando il valore del
precedente elemento della lista nella variabile prev e confrontando
quest'ultima con l'elemento corrente. prev viene quindi di volta in
volta (ad ogni ciclo) riassegnato, in modo che l'elemento corrente
venga sempre confrontato con quello appena precedente nella lista. 
Vengono rilevate 7 voci duplicate. Osservate anche come viene
utilizzato \verb'\t' per stampare una tabulazione. 

Un'altro modo per utilizzare un ciclo {\tt for} è ripetere la stessa azione un
determinato numero di volte. Ecco il codice per visualizzare i primi 11
numeri della serie di Fibonacci:
\begin{verbatim}
a = 1
b = 1
for c in range(1,10):
        print a,
        n = a + b
        a = b
        b = n
\end{verbatim}
Con il sorprendente output:
\begin{verbatim}
1 1 2 3 5 8 13 21 34
\end{verbatim}
Tutto quello che potete fare con i cicli {\tt for} potete farlo
anche con {\tt while} ma grazie ai cicli {\tt for} è più semplice
scorrere tra tutti gli elementi di una lista o compiere un'azione un
determinato numero di volte. 










\chapter{Espressioni booleane}
Questo è un piccolo esempio di espressioni booleane (non dovete
scriverlo):
\begin{verbatim}
a = 6
b = 7
c = 42
print 1, a == 6
print 2, a == 7
print 3,a == 6 and b == 7
print 4,a == 7 and b == 7
print 5,not a == 7 and b == 7
print 6,a == 7 or b == 7
print 7,a == 7 or b == 6
print 8,not (a == 7 and b == 6)
print 9,not a == 7 and b == 6
\end{verbatim}
Questo è l'output:
\begin{verbatim}
1 1
2 0
3 1
4 0
5 1
6 1
7 0
8 1
9 0
\end{verbatim}
Cosa succede? Il programma consiste in una serie di istruzioni 
{\tt print}. Ogni istruzione {\tt print} visualizza un numero e
un'espressione. Il numero serve a farvi capire quale istruzione viene
eseguita. Potete notare che ogni espressione consiste in uno 0 o in un
1. In Python equivalgono a falso (0) e a vero (1).

%%For example:
%%\begin{verbatim}
%%>>> if 1:
%%...     print "true"
%%... else:
%%...     print "false"
%%... 
%%true
%%>>> if 0:
%%...     print "true"
%%... else:
%%...     print "false"
%%... 
%%false
%%\end{verbatim}
Le linee:
\begin{verbatim}
print 1, a == 6
print 2, a == 7
\end{verbatim}
Restituiscono infatti vero e falso, esattamente come dovrebbero fare
finché la prima affermazione è vera e la seconda è falsa. La terza
istruzione {\tt print} è un po' diversa: print
\verb'print 3,a == 6 and b == 7'. L'operatore {\tt and} indica che se
entrambe le affermazioni prima e dopo l'operatore logico sono vere
tutta l'espressione è vera, altrimenti tutta l'espressione è
falsa. L'espressione successiva, \verb'print 4,a == 7 and b == 7',
dimostra che se una parte dell'espressione and è falsa, tutta
l'espressione sarà falsa. Il significato di and può essere riassunto come segue:

\begin{tabular}{l | l}
espressione & risultato \\
\hline  
vero and vero & vero \\
vero and falso & falso \\
falso and vero & falso \\
falso and falso & falso \\
\end{tabular}

Potete notare che se la prima espressione è falsa Python non esegue un
controllo sulla seconda espressione perché sa già che tutta
l'espressione è falsa.

La linea successiva, \verb'print 5,not a == 7 and b == 7', utilizza
l'operatore {\tt not} che restituisce semplicemente l'opposto
dell'espressione.  L'espressione può infatti essere riscritta
semplicemente come {\tt print 5,a != 7 and b == 7}. Questa è la
tabella: 

\begin{tabular}{l | l}
espressione & risultato \\
\hline
not vero & falso \\
not falso & vero \\
\end{tabular}

Le due linee seguenti, \verb'print 6,a == 7 or b == 7' e
\verb'print 7,a == 7 o b == 6', utilizzano l'operatore logico {\tt or}
che ritorna vero se una delle affermazioni (o entrambe) è vera. Questa
è la tabella: 

\begin{tabular}{l | l}
espressione & risultato \\
\hline  
vero or vero & vero \\
vero or falso & vero \\
falso or vero & vero  \\
falso or falso & falso \\
\end{tabular}

Anche qui Python non esegue il controllo sulla seconda espressione se
riconosce la prima come vera dato che anche se la seconda affermazione
risultasse falsa l'intera espressione sarebbe comunque vera. 

Le ultime due linee, \verb'print 8,not (a == 7 and b == 6)'e 
\verb'print 9,not a == 7 and b == 6', mostrano come le parentesi
possano raggruppare espressioni e forzarne l'esecuzione prima di altre
al di fuori dalle parentesi. Potete osservare infatti che le parentesi
cambiano il valore dell'espressione da falso a vero, visto che
obbligano l'operatore {\tt not} a valutare l'intera espressione
anziché solamente la porzione {\tt a == 7}. 

Ecco un esempio sull'utilizzo delle espressioni booleane:
\begin{verbatim}
list = ["Life","The Universe","Everything","Jack","Jill","Life","Jill"]

# Crea una copia della lista. Vedi il capitolo ``Ancora sulle liste''
# per una spiegazione del costrutto [:].
copy = list[:]
# Ordina la copia.
copy.sort()
prev = copy[0]
del copy[0]

count = 0

# Esamina la lista per trovare una corrispondenza.
while count < len(copy) and copy[count] != prev:
    prev = copy[count]
    count = count + 1

# Se non viene trovata una corrispondenza allora count non può essere
# < len(copy) in quel momento, quindi usciamo dal ciclo while. 
if count < len(copy):
    print "First Match: ",prev
\end{verbatim}

Ecco l'output:
\begin{verbatim}
First Match:  Jill
\end{verbatim}

Questo programma continua a scorrere la lista cercando duplicati 
({\tt while count < len(copy and copy[count]}). Quando uno dei due
{\tt contatori} è più grande dell'ultimo indice di {\tt copy} o viene
trovato un duplicato, l'operatore {\tt and} non risulta più vero e si
esce dal ciclo. {\tt if} si occupa semplicemente di accertarsi che
l'uscita dal ciclo {\tt while} sia dovuta alla presenza di un
duplicato.

Nell'esempio viene utilizzato un'altro 'trucco' dell'operatore 
{\tt and}. Se guardate la tabella di {\tt and} potete osservare che la
terza espressione è falsa senza che Python esegua un controllo sul
secondo elemento. Se {\tt count >= len(copy)} (in altre parole 
{\tt count < len(copy)} è falsa) allora {\tt copy[count]} non viene
processata. Questo avviene perché Python sa che se la prima accezione
è falsa, lo sono entrambe. Questo piccolo trucco è utile se la seconda
metà dell'{\tt and} causa un errore. Ho usato la prima espressione
({\tt count < len(copy)}) per eseguire un controllo su {\tt count} e
controllare se {\tt count} sia un indice valido (se non mi credete,
rimuovete 'Jill' e 'Life', eseguite il programma e vedete se funziona
ancora, quindi invertite l'ordine di 
{\tt count < len(copy) and copy[count] != prev} con 
{\tt copy[count] != prev and count < len(copy)}).

Le espressioni booleane possono essere usate quando avete bisogno di
verificare due o più elementi in una volta.

\section{Esempi}

\file{password1.py}
\begin{verbatim}
## Questo programma chiede ad un utente un nome ed una password,
#  poi controlla per accertarsi che gli sia consentito l'accesso.

name = raw_input("What is your name? ")
password = raw_input("What is the password? ")
if name == "Josh" and password == "Friday":
    print "Welcome Josh"
elif name == "Fred" and password == "Rock":
    print "Welcome Fred"
else:
    print "I don't know you."
\end{verbatim}

Semplice esecuzione:
\begin{verbatim}
What is your name? Josh
What is the password? Friday
Welcome Josh

What is your name? Bill
What is the password? Money
I don't know you.
\end{verbatim}

\section{Esercizi}

Scrivete un programma che spinga l'utente ad indovinare il vostro nome
dandogli solamente 3 possibilità, dopo le quali il programma termina.












\chapter{Dizionari}
Questo capitolo tratta i dizionari. I dizionari hanno chiavi e
valori. Le chiavi sono usate per trovare i valori. Ecco un esempio di
un dizionario in uso:
\begin{verbatim}
def print_menu():
    print '1. Print Phone Numbers'
    print '2. Add a Phone Number'
    print '3. Remove a Phone Number'
    print '4. Lookup a Phone Number'
    print '5. Quit'
    print
numbers = {}
menu_choice = 0
print_menu()
while menu_choice != 5:
    menu_choice = input("Type in a number (1-5):")
    if menu_choice == 1:
        print "Telephone Numbers:"
        for x in numbers.keys():
            print "Name: ",x," \tNumber: ",numbers[x]
        print
    elif menu_choice == 2:
        print "Add Name and Number"
        name = raw_input("Name:")
        phone = raw_input("Number:")
        numbers[name] = phone
    elif menu_choice == 3:
        print "Remove Name and Number"
        name = raw_input("Name:")
        if numbers.has_key(name):
            del numbers[name]
        else:
            print name," was not found"
    elif menu_choice == 4:
        print "Lookup Number"
        name = raw_input("Name:")
        if numbers.has_key(name):
            print "The number is",numbers[name]
        else:
            print name," was not found"
    elif menu_choice != 5:
        print_menu()
\end{verbatim}
E qui l'output:
\begin{verbatim}
1. Print Phone Numbers
2. Add a Phone Number
3. Remove a Phone Number
4. Lookup a Phone Number
5. Quit

Type in a number (1-5):2
Add Name and Number
Name:Joe
Number:545-4464
Type in a number (1-5):2
Add Name and Number
Name:Jill
Number:979-4654
Type in a number (1-5):2
Add Name and Number
Name:Fred
Number:132-9874
Type in a number (1-5):1
Telephone Numbers:
Name:  Jill     Number:  979-4654
Name:  Joe      Number:  545-4464
Name:  Fred     Number:  132-9874

Type in a number (1-5):4  
Lookup Number
Name:Joe
The number is 545-4464
Type in a number (1-5):3
Remove Name and Number
Name:Fred
Type in a number (1-5):1
Telephone Numbers:
Name:  Jill     Number:  979-4654
Name:  Joe      Number:  545-4464

Type in a number (1-5):5
\end{verbatim}
Questo programma è simile a quello con la lista di nomi nel capitolo
sulle liste. Ecco come funziona il programma. Innanzitutto viene
definita la funzione \verb'print_menu' che visualizza sullo schermo un
menu più volte usato nel programma. A questo punto compare la linea
{\verb'numbers = {}'} che dichiara {\tt numbers} come un
dizionario. Le linee seguenti fanno funzionare il menu:
\begin{verbatim}
for x in numbers.keys():
    print "Name: ",x," \tNumber: ",numbers[x]
\end{verbatim}
Tramite questo ciclo si possono visualizzare le informazioni contenute
nel dizionario. La funzione {\tt numbers.keys()} restituisce una lista
che viene poi utilizzata dal ciclo {\tt for}. Questa lista non ha un
ordine particolare, quindi se la volete in ordine alfabetico la
dovrete ordinare. Con la notazione {\tt numbers[x]} potete accedere
ai singoli membri del dizionario. Ovviamente in questo caso {\tt x} è
una stringa. Successivamente la linea {\tt numbers[name] = phone}
aggiunge un nome ed un numero di telefono al dizionario. Se {\tt name}
è stato già inserito nel dizionario {\tt phone}, rimpiazza il valore
precedente. Le linee successive:
\begin{verbatim}
if numbers.has_key(name):
    del numbers[name]
\end{verbatim}
Controllano se una chiave è già presente nel dizionario, in tal caso
la rimuovono. La funzione \verb'numbers.has_key(name)' ritorna vero se
{\tt name} è presente in {\tt numbers}, altrimenti ritorna falso. La
linea del {\tt del numbers[name]} rimuove la chiave {\tt name} ed il
valore ad essa associato. Le linee: 
\begin{verbatim}
if numbers.has_key(name):
    print "The number is",numbers[name]
\end{verbatim}
Controllano se nel dizionario è presente una determinata chiave, se la
trovano, stampano il numero ad essa associato. Infine, se la scelta non è
presente nel menu (quindi non è valida) il programma visualizza
nuovamente il menu.

\label{firstgrades}
Ricapitolando: i dizionari hanno chiavi e valori. Le chiavi possono
essere stringhe o numeri e puntano a valori. I valori puntati possono
essere qualsiasi tipo di variabile, anche liste di dizionari (che
possono contenere a loro volta dizionari e liste (paura eh? :=)
)). Questo è un esempio che utilizza una lista in un dizionario:
\begin{verbatim}
max_points = [25,25,50,25,100]
assignments = ['hw ch 1','hw ch 2','quiz   ','hw ch 3','test']
students = {'#Max':max_points}

def print_menu():
    print "1. Add student"
    print "2. Remove student"
    print "3. Print grades"
    print "4. Record grade"
    print "5. Print Menu"
    print "6. Exit"
\end{verbatim}
\begin{verbatim}

def print_all_grades():
        print '\t',
        for i in range(len(assignments)):
            print assignments[i],'\t',
        print
        keys = students.keys()
        keys.sort()
        for x in keys:
            print x,'\t',
            grades = students[x]
            print_grades(grades)
\end{verbatim}
\begin{verbatim}

def print_grades(grades):
    for i in range(len(grades)):
        print grades[i],'\t\t',
    print
\end{verbatim}
\begin{verbatim}

    
print_menu()
menu_choice = 0
while menu_choice != 6:
    print
    menu_choice = input("Menu Choice (1-6):")
    if menu_choice == 1:
        name = raw_input("Student to add:")
        students[name] = [0]*len(max_points)
    elif menu_choice == 2:
        name = raw_input("Student to remove:")
        if students.has_key(name):
            del students[name]
        else:
            print "Student: ",name," not found"
    elif menu_choice == 3:
        print_all_grades()
        
    elif menu_choice == 4:
        print "Record Grade"
        name = raw_input("Student:")
        if students.has_key(name):
            grades = students[name]
            print "Type in the number of the grade to record"
            print "Type a 0 (zero) to exit"
            for i in range(len(assignments)):
                print i+1,' ',assignments[i],'\t',
            print
            print_grades(grades)
            which = 1234
            while which != -1:
                which = input("Change which Grade:")
                which = which-1
                if 0 <= which < len(grades):
                    grade = input("Grade:")
                    grades[which] = grade
                elif which != -1:
                    print "Invalid Grade Number"
        else:
            print "Student not found"
    elif menu_choice != 6:
        print_menu()
\end{verbatim}
E questo è il semplice output:
\begin{verbatim}
1. Add student
2. Remove student
3. Print grades
4. Record grade
5. Print Menu
6. Exit

Menu Choice (1-6):3
        hw ch 1         hw ch 2         quiz            hw ch 3         test 
#Max    25              25              50              25              100 
\end{verbatim}
\begin{verbatim}

Menu Choice (1-6):6
1. Add student
2. Remove student
3. Print grades
4. Record grade
5. Print Menu
6. Exit

Menu Choice (1-6):1
Student to add:Bill
\end{verbatim}
\begin{verbatim}

Menu Choice (1-6):4
Record Grade
Student:Bill
Type in the number of the grade to record
Type a 0 (zero) to exit
1   hw ch 1     2   hw ch 2     3   quiz        4   hw ch 3     5   test 
0               0               0               0               0 
Change which Grade:1
Grade:25
Change which Grade:2
Grade:24
Change which Grade:3
Grade:45
Change which Grade:4
Grade:23
Change which Grade:5
Grade:95
Change which Grade:0
\end{verbatim}
\begin{verbatim}

Menu Choice (1-6):3  
        hw ch 1         hw ch 2         quiz            hw ch 3         test 
#Max    25              25              50              25              100 
Bill    25              24              45              23              95 

Menu Choice (1-6):6
\end{verbatim}
La variabile students è un dizionario le cui chiavi sono i nomi degli
studenti, i valori sono i voti degli studenti. Le prime due linee creano
semplicemente due liste. La linea successiva
\verb"students = {'#Max':max_points}" crea un nuovo dizionario la cui
chiave è {\verb'#Max'} e il valore {\tt [25,25,50,25,100]} (è il
valore di \verb'max_points' nel momento in cui il valore viene
assegnato; viene usata la chiave \verb'#Max' perché \verb'#' è sempre
ordinato sopra i caratteri alfabetici). Quindi viene definita la
funzione \verb'print_menu'. Le linee seguenti definiscono
\verb'print_all_grades'.
\begin{verbatim}
def print_all_grades():
        print '\t',
        for i in range(len(assignments)):
            print assignments[i],'\t',
        print
        keys = students.keys()
        keys.sort()
        for x in keys:
            print x,'\t',
            grades = students[x]
            print_grades(grades)
\end{verbatim}
Notate come le chiavi vengano innanzitutto estratte dal dizionario
{\tt students} con la funzione di {\tt keys} contenuta nella linea:
{\tt keys = students.keys()}. {\tt keys} è una lista, quindi possono
essere usate tutte le funzioni delle liste. Successivamente vengono
ordinate le chiavi nella linea {\tt keys.sort()} e viene utilizzato un
ciclo {\tt for} per scorrere tutte le chiavi. I voti sono
immagazzinati come una lista all'interno del dizionario, in modo che
l'assegnamento {\tt grades = students[x]} assegni a {\tt grades} la
lista immagazzinata nella chiave {\tt x}. La funzione
\verb'print_grades' visualizza semplicemente una lista ed è definita
poche linee sotto. 

Le ultime linee del programma implementano le varie opzioni del
menu. La linea \verb'students[name] = [0]*len(max_points)' aggiunge
uno studente alla chiave corrispondente al nome. La notazione
\verb'[0]*len(max_points)' crea una array di zeri della stessa
lunghezza della lista \verb'max_points'. 

La scelta {\tt remove students} cancella uno studente in modo simile
all'esempio precedente. La scelta {\tt record grades} è più
complessa. I voti vengono estratti nella linea 
{\tt grades = students[name]} che ritorna un riferimento ai voti dello
studente {\tt name}. Un voto viene quindi registrato nella linea 
{\tt grades[which] = grade}. Notate che {\tt grades} non viene
inserito nel dizionario {\tt students}. Il motivo di questa "mancanza"
è che {\tt grades} è semplicemente un altro nome per 
{\tt students[name]} quindi cambiare {\tt grades} significa cambiare
{\tt student[name]}. 

I dizionari rappresentano un modo semplice per collegare chiavi a
valori. Possono essere usati facilmente per tenere traccia dei dati
che sono attribuiti alle varie chiavi. 











\chapter{Usare i moduli}
Questo è l'esercizio del capitolo (chiamatelo \file{cal.py}):
    \footnote{Import cerca un file di nome \file{calendar.py} e lo legge. Se
      il file chiamante si chiama \file{calendar.py} e contiene 
      'import calendar' cerca di leggere in sé stesso con risultati
      quantomeno scarsi.}: 
\begin{verbatim}
import calendar

year = input("Type in the year number:")
calendar.prcal(year)
\end{verbatim}
E qui una parte dell'output:
\begin{verbatim}
Type in the year number:2001
                                  2001                                  

       January                  February                    March       
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
 1  2  3  4  5  6  7                1  2  3  4                1  2  3  4     
 8  9 10 11 12 13 14       5  6  7  8  9 10 11       5  6  7  8  9 10 11     
15 16 17 18 19 20 21      12 13 14 15 16 17 18      12 13 14 15 16 17 18     
22 23 24 25 26 27 28      19 20 21 22 23 24 25      19 20 21 22 23 24 25     
29 30 31                  26 27 28                  26 27 28 29 30 31        

\end{verbatim}
Ho saltato parte dell'output, credo vi siate fatti un'idea. Cosa fa il
programma? La prima linea {\tt import calendar} usa un nuovo comando:
{\tt import}. Il comando {\tt import} carica un modulo (in questo caso
il modulo {\tt calendar}). Per vedere i comandi disponibili nei moduli
standard cercate nella ``library reference'' (se l'avete scaricata) o
sul sito ufficiale 
{\tt http://www.python.org/doc/current/lib/lib.html}. Il modulo
calendar è descritto nel capitolo 5.9. Se leggete la documentazione vi
accorgerete di  una funzione chiamata {\tt prcal} che visualizza il
calendario di un anno. La linea {\tt calendar.prcal(year)} usa la
funzione descritta. Riassumendo, per utilizzare un modulo importatelo,
quindi usate {\tt nome\_modulo.funzione} per utilizzare le funzioni del
modulo. Un'altro modo per scrivere il programma:
\begin{verbatim}
from calendar import prcal

year = input("Type in the year number:")
prcal(year)
\end{verbatim} 
Questa versione importa una specifica funzione dal modulo. Creiamo
un'altro programma utilizzando le funzioni della Python Library
(chiamate il file \file{clock.py})(premete i tasti 'Ctrl' e 'c' per chiudere
il programma): 
\begin{verbatim}
from time import time, ctime

prev_time = ""
while(1):
    the_time = ctime(time())
    if(prev_time != the_time):
        print "The time is:",ctime(time())
        prev_time = the_time
\end{verbatim}
E questo l'output dell'esempio:
\begin{verbatim}
The time is: Sun Aug 20 13:40:04 2000
The time is: Sun Aug 20 13:40:05 2000
The time is: Sun Aug 20 13:40:06 2000
The time is: Sun Aug 20 13:40:07 2000
Traceback (innermost last):
  File "clock.py", line 5, in ?
    the_time = ctime(time())
KeyboardInterrupt
\end{verbatim}
L'output è ovviamente infinito, così l'ho interrotto (l'output
continua fino a quando non premete 'Ctrl+c'). Il programma entra
semplicemente in un cliclo infinito ed esegue un controllo per vedere
se l'orario è cambiato, nel qual caso visualizza il nuovo orario sul
monitor. Fate attenzione a come import è utilizzato nella linea 
{\tt from time import time, ctime} per richiamare più di una
funzione. 

La Python Library contiene molte funzioni utili che semplificano la
programmazione in Python.


\section{Esercizio}

Riscrivete il programma \file{high_low.py }della sezione \ref{firsthighlow}
usando le ultime due cifre della funzione {\tt time} per rendere il
numero 'random' (casuale). 












\chapter{Ancora sulle liste}
Abbiamo già esaminato le liste e come vengono utilizzate. Ora che avete un
background più corposo entrerò più in dettaglio. Innanzitutto scopriremo
altri modi per estrarre gli elementi dalle liste, quindi vedremo un
metodo per copiarle.
  

Questi sono alcuni esempi dell'utilizzo degli indici per accedere ai singoli
elementi di una lista:
\begin{verbatim}
>>> list = ['zero','one','two','three','four','five']   
>>> list[0]
'zero'
>>> list[4]
'four'
>>> list[5]
'five'
\end{verbatim}
Questi esempi dovrebbero esservi familiari. Se volete estrarre il
primo elemento di una lista dovrete richiamare l'elemento con indice
0, il secondo elemento avrà indice 1 e così via attraverso la
lista. Come fare se volete l'ultimo elemento della lista ? Una via
potrebbe essere quella di utilizzare la funzione \verb'len'
all'interno delle parentesi quadre:
\verb'list[len(list)-1]'. \verb'len' ritorna sempre l'ultimo indice
più uno. Allo stesso modo l'istruzione per avere il penultimo elemento
della lista sarà \verb'list[len(list)-2]'. Esiste una via più
semplice: in Python l'ultimo elemento è sempre indicizzato come -1, il
penultimo come -2 e così via. Ecco un'altro esempio: 
\begin{verbatim}
>>> list[len(list)-1]  
'five'
>>> list[len(list)-2]
'four'
>>> list[-1]
'five'
>>> list[-2]
'four'
>>> list[-6]
'zero'
\end{verbatim}
Così ogni elemento in una lista può essere indicizzato in due modi
differenti: dall'inizio della lista e dalla fine della lista.

Un'altro metodo molto funzionale per estrarre elementi da una lista sono
le sezioni. Ecco un'altro esempio per avere un'idea di come usarle: 
\begin{verbatim}
>>> list = [0,'Fred',2,'S.P.A.M.','Stocking',42,"Jack","Jill"]
>>> list[0]  
0
>>> list[7]
'Jill'
>>> list[0:8]
[0, 'Fred', 2, 'S.P.A.M.', 'Stocking', 42, 'Jack', 'Jill']
>>> list[2:4]
[2, 'S.P.A.M.']
>>> list[4:7]
['Stocking', 42, 'Jack']
>>> list[1:5]
['Fred', 2, 'S.P.A.M.', 'Stocking']
\end{verbatim}
Le sezioni sono utilizzate per estrarre parti di liste. La sintassi
per estrarre sezioni è \verb'list[primo_indice:ultimo_indice]'.
La sezione selezionata va da \verb'primo_indice' all'indice prima di
\verb'ultimo_indice'. \`E possibile utilizzare entrambi i metodi di
indicizzazione: 
\begin{verbatim}
>>> list[-4:-2]
['Stocking', 42]
>>> list[-4]
'Stocking'
>>> list[-4:6]
['Stocking', 42]
\end{verbatim}
Un'altro trucco con le sezioni è non specificare l'indice. Se il primo
indice non viene specificato, Python assumerà il primo indice della lista
come indice da cui partire. Se il successivo indice non è specificato,
si intenderà tutto il resto della lista. Ecco altri esempi:
\begin{verbatim}
>>> list[:2]
[0, 'Fred']
>>> list[-2:]
['Jack', 'Jill']
>>> list[:3]
[0, 'Fred', 2]
>>> list[:-5] 
[0, 'Fred', 2]
\end{verbatim}
Ancora un'altro programma d'esempio (copiate ed incollate, se volete,
la definizione di poem):
\begin{verbatim}
poem = ["<B>","Jack","and","Jill","</B>","went","up","the","hill","to","<B>",\
"fetch","a","pail","of","</B>","water.","Jack","fell","<B>","down","and",\
"broke","</B>","his","crown","and","<B>","Jill","came","</B>","tumbling",\
"after"]

def get_bolds(list):
        true = 1  
        false = 0
        ## Dichiara is_bold come falso, quindi stiamo guardando una
        ## porzione di testo non in grassetto.
        is_bold = false
        ## start_block rappresenta l'indice delle porzioni di testo in
        ## grassetto.
        start_block = 0
        for index in range(len(list)):
                ## TAG che rappresenta l'inizio del grassetto.
                if list[index] == "<B>":
                        if is_bold:
                                print "Error:  Extra Bold"
                        ##print "Not Bold:",list[start_block:index]
                        is_bold = true
                        start_block = index+1
                ## TAG che rappresenta la fine del grassetto.
                ## Ricordate che l'ultimo numero in una sezione
                ## rappresenta l'indice e dopo l'ultimo indice usato.
                if list[index] == "</B>":
                        if not is_bold:
                                print "Error: Extra Close Bold"
                        print "Bold [",start_block,":",index,"] ",\
                        list[start_block:index]
                        is_bold = false
                        start_block = index+1

get_bolds(poem)
\end{verbatim}
E questo è l'output:
\begin{verbatim}
Bold [ 1 : 4 ]  ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ]  ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ]  ['down', 'and', 'broke']
Bold [ 28 : 30 ]  ['Jill', 'came']
\end{verbatim}

La funzione \verb'get_bold' scorre una lista dividendola in parole
e chiamate. Le chiamate che cerca sono \verb'<B>' che inizia il testo
in grassetto e \verb'<\B>' che lo termina. La funzione \verb'get_bold'
ricerca l'inizio e la fine delle chiamate.

La prossima funzione delle liste è la copia. Se volete, potete provare
questo semplice esempio:
\begin{verbatim}
>>> a = [1,2,3]
>>> b = a
>>> print b
[1, 2, 3]
>>> b[1] = 10
>>> print b
[1, 10, 3]
>>> print a
[1, 10, 3]
\end{verbatim}
Probabilmente vi sorprenderà in quanto una modifica a {\tt b} modifica
anche {\tt a}. Questo grazie all'istruzione \verb'b = a' che
restituisce {\tt b} come {\em riferimento} ad {\tt a}. Significa che
{\tt b} non è altro che un'altro nome per riferirsi ad {\tt a}, il
risultato è che una modifica a {\tt b} è una modifica ad {\tt a}. Ciò
nonostante alcune tipologie di assegnamento non significano la
creazione di un doppio nome per una lista:
\begin{verbatim}
>>> a = [1,2,3]
>>> b = a*2
>>> print a
[1, 2, 3]
>>> print b
[1, 2, 3, 1, 2, 3]
>>> a[1] = 10
>>> print a
[1, 10, 3]
>>> print b
[1, 2, 3, 1, 2, 3]
\end{verbatim}

In questo caso {\tt b} non è un riferimento ad {\tt a} in quanto
l'istruzione \verb'a*2' crea una nuova lista. {\tt b} quindi si
riferisce ad \verb'a*2' e non ad {\tt a}. Tutti gli assegnamenti
creano un riferimento. Quando passate una lista come argomento ad una
funzione create un riferimento. La maggior parte delle volte non
dovrete preoccuparvi di creare un riferimento anziché una
copia. Tuttavia, quando dovete modificare una lista senza cambiarne 
un'altra, assegnata ad un nome differente, dovete assicurarvi di aver
creato una copia e non un riferimento. 

Esistono diversi modi per copiare una lista. Il modo più semplice è
usare le sezioni poiché creano sempre una nuova lista perfino se la
sezione comprende tutta la lista: 
\begin{verbatim}
>>> a = [1,2,3]
>>> b = a[:]
>>> b[1] = 10
>>> print a
[1, 2, 3]
>>> print b
[1, 10, 3]
\end{verbatim}

La sezione {\tt [:]} crea una nuova copia della lista. In questo modo
si può copiare una lista, ma qualsiasi sottolista creata in seguito si
riferirà alla rispettiva sottolista della lista originale. Potete
ovviare al problema copiando anche le sottoliste usando la funzione
{\tt deepcopy} del modulo {\tt copy}:
\begin{verbatim}
>>> import copy
>>> a = [[1,2,3],[4,5,6]]
>>> b = a[:]
>>> c = copy.deepcopy(a)
>>> b[0][1] = 10
>>> c[1][1] = 12
>>> print a
[[1, 10, 3], [4, 5, 6]]
>>> print b
[[1, 10, 3], [4, 5, 6]]
>>> print c
[[1, 2, 3], [4, 12, 6]]
\end{verbatim}
Innanzitutto notate che {\tt a} è una lista di liste. L'istruzione
\verb'b[0][1] = 10' cambia sia la lista {\tt b} che la lista {\tt a},
mentre {\tt c} rimane inalterata. Questo accade perché {\tt b}
continua ad essere un riferimento ad {\tt a} se vengono utilizzate le
sezioni; {\tt c} invece è una copia completa, ottenuta grazie alla
funzione {\tt deepcopy}. 

Perciò dovrete preoccuparvi dei riferimenti ogni volta che userete la
funzione {\tt ``=''}? La buona notizia è che dovrete occuparvi dei
riferimenti solamente quando utilizzate dizionari e liste. Numeri e
stringhe creano dei riferimenti, ma quando vengono modificati creano
una copia, quindi non potrete mai modificarli
inaspettatamente.

Adesso vi starete probabilmente chiedendo perché vengono usati i
riferimenti. La motivazione, sostanzialmente, è la loro velocità. \`E molto più
veloce fare un riferimento ad una lista di migliaia di riferimenti che
copiarli tutti. Un'altra ragione è che permettono di avere una
funzione che modifichi una lista o un dizionario. Tenete in
considerazione tutto questo se vi troverete ad avere strani errori in
relazione a dati modificati quando quest'ultimi non avrebbero dovuto
subire alcun cambiamento. 

%% On Sun, Sep 09, 2001 at 02:46:06PM +0100, Hamish Lawson wrote:
%% Hello Josh
%% 
%% I think it's great that you have undertaken to write a non-programmer's
%% tutorial on Python. However may I suggest that a different approach to
%% the discussion of variables and references may make things easier for
%% both you and the reader, and lead to less potential confusion for the
%% novice when they explore Python further?
%% 
%% Programming introductions that use a language like C or Pascal as the
%% medium often discuss variables in terms of boxes that store data. But
%% for a language like Python, I think this approach ends up making the
%% whole subject of variables and references more complicated than it need
%% be and means that the reader has a lot to unlearn later.
%%
%% Saying that "a = []" stores an empty list in 'a' and that "b = a" makes
%% 'b' a reference to 'a' makes it appear that assignment is
%% context-dependent when it isn't really. Things get even trickier when
%% you have statements like "b = f()". Instead a more coherent approach
%% might be to say that assignment to a variable stores a reference to
%% some object. The difference between "a = []" and "b = a" then lies in
%% whether it is a newly created object that you are storing a reference
%% to (as produced by '[]') or an existing object (as produced by 'a'),
%% *not* in whether or not a reference gets stored in the variable - it
%% always does. I believe this approach leads to much less confusion
%% overall and less need for special explanations.
%% 
%% Fredrik Lundh has a good explanation of objects and references in
%% Python at http://www.effbot.org/guides/python-objects.htm.
%% 
%% I hope you have found this useful.










\chapter{La rivincita delle stringhe}
%%things to talk about: chr ord float int len repr s+b s[i] s[i:j] s*n find rfind replace strip
%%Start with indexing, user chr and ord to show how to do manual int<->string
%%Repeate the <B> with slices and do actual html
%%Do some more phrasing

%%Okay here is todays typing exercise:
%%\begin{verbatim}
%%def to_string(in_int):
%%    "Converts an integer to a string"
%%    out_str = ""
%%    prefix = ""
%%    if in_int < 0:
%%        prefix = "-"
%%        in_int = -in_int        
%%    while in_int / 10 != 0:
%%        out_str = chr(ord('0')+in_int % 10) + out_str
%%        in_int = in_int / 10
%%    out_str = chr(ord('0')+in_int % 10) + out_str
%%    return prefix + out_str
%%
%%def to_int(in_str):
%%    "Converts a string to an integer"
%%    out_num = 0
%%    if in_str[0] == "-":
%%        multiplier = -1
%%        in_str = in_str[1:]
%%    else:
%%        multiplier = 1
%%    for x in range(0,len(in_str)):
%%        out_num = out_num * 10 + ord(in_str[x]) - ord('0')
%%    return out_num * multiplier
%%
%%print to_string(2)
%%print to_string(23445)
%%print to_string(-23445)
%%print to_int("14234")
%%print to_int("12345")
%%print to_int("-3512")
%%\end{verbatim}
%%The output is:
%%\begin{verbatim}
%%2
%%23445
%%-23445
%%14234
%%12345
%%-3512
%%\end{verbatim}
%%
%%So how does it work?  The first detail to notice is that it defines two different functions, one that converts a string to a number and one that converts a number to a string.  Notice that this function does string manipulation similar to how lists can be manipulated.  For example the line \verb'if in_str[0] == "-"' uses indexing to look at the first letter in the string.  Another thing that strings can do that lists can is using slices.  The line \verb'in_str = in_str[1:]' uses slices to get all but the first character of in_str (or drops the first letter).  However you cannot use slices or indexing to assign to a letter or location in a string.
%%
%%Two new things to introduced are the functions \verb'ord' and \verb'chr'.  The 
%%\verb'ord' function takes a character (a string of length one) and returns the ASCII value of the character.  The function \verb'chr' is its inverse and takes a ASCII value and returns a character.  The expression \verb"ord(in_str[x]) - ord('0')" uses the \verb'ord' function to find the value of a string.  This works since '0' through '9' have ASCII values that are all in a row.  The ASCII value of '0' is 48 and the ASCII value of '9' is 57 so when we subtract 57-48 we get 9 and this works similarly with other numbers.  The expression \verb"chr(ord('0')+in_int % 10)" works in a similar manor but in reverse.  

Ora presenteremo un trucco che può essere usato con le stringhe:
\begin{verbatim}
def shout(string):
    for character in string:
        print "Gimme a "+character
        print "'"+character+"'"

shout("Lose")

def middle(string):
    print "The middle character is:",string[len(string)/2]

middle("abcdefg")
middle("The Python Programming Language")
middle("Atlanta")
\end{verbatim}

E l'output è:
\begin{verbatim}
Gimme a L
'L'
Gimme a o
'o'
Gimme a s
's'
Gimme a e
'e'
The middle character is: d
The middle character is: r
The middle character is: a
\end{verbatim}
Questo programma dimostra che le stringhe sono per alcuni aspetti
simili alle liste. La procedura {\tt shout} dimostra che un ciclo 
{\tt for} può essere usato con le stringhe esattamente nello stesso
modo in cui veniva usato con le liste. La procedura {\tt middle}
mostra come possa essere utilizzato il {\tt len} anche con le
stringhe, così come gli indici e le sezioni. Molte funzionalità delle
liste funzionano con le stringhe. 

La prossima funzione utilizzerà alcune funzionalità specifiche delle
stringhe: 
\begin{verbatim}
def to_upper(string):
    ## Converte la stringa in maiuscolo.
    upper_case = ""
    for character in string:
        if 'a' <= character <= 'z':
            location = ord(character) - ord('a')
            new_ascii = location + ord('A')
            character = chr(new_ascii)
        upper_case = upper_case + character
    return upper_case

print to_upper("This is Text")
\end{verbatim}
Con l'output che è:
\begin{verbatim}
THIS IS TEXT
\end{verbatim}
Il motivo per cui questo codice funziona è che il computer rappresenta
i caratteri delle stringhe come numeri da 0 a 255. Python ha una
funzione chiamata {\tt ord} (abbreviazione di ordinale) che ritorna un
carattere come un numero. Esiste anche una funzione corrispondente
{\tt chr} che converte un numero in un carattere. Capito questo, il
programma dovrebbe essere chiaro. Il primo dettaglio è la linea: 
\verb$if 'a' <= character <= 'z':$ che controlla se la lettera è
minuscola. Se è così, allora prosegue alla linea successiva. La
linea: \verb$location = ord(character) - ord('a')$ converte i numeri
corrispondenti alle lettere nel codice ASCII, in numeri da 0 a 36,
quindi la  linea \verb$new_ascii = location + ord('A')$ converte la
lettera minuscola in maiuscola.

Adesso, qualche esercizio interattivo da digitare:
\begin{verbatim}
>>> # Da intero a stringa.
... 
>>> 2
2
>>> repr(2)
'2'
>>> -123
-123
>>> repr(-123)
'-123'
>>> # Da stringa a intero.
... 
>>> "23"
'23'
>>> int("23")
23
>>> "23"*2
'2323'
>>> int("23")*2
46
>>> # Da decimale a stringa.
... 
>>> 1.23
1.23
>>> repr(1.23)
'1.23'
>>> # Da decimale a intero.
... 
>>> 1.23
1.23
>>> int(1.23)
1
>>> int(-1.23)
-1
>>> # Da stringa a decimale.
... 
>>> float("1.23")
1.23
>>> "1.23" 
'1.23'
>>> float("123")
123.0
\end{verbatim}

Se non l'avete ancora indovinato, la funzione \verb'repr' converte un
intero in stringa e la funzione \verb'int' converte una stringa in
intero. La funzione {\tt float} converte una stringa in un numero in
virgola mobile. La funzione \verb'repr' ritorna una rappresentazione
stampabile di qualcosa. Ecco alcuni esempi di quanto detto:
\begin{verbatim}
>>> repr(1)
'1'
>>> repr(234.14)
'234.14'
>>> repr([4,42,10])
'[4, 42, 10]'
\end{verbatim}
La funzione \verb'int' prova a convertire una stringa (o un numero in
virgola mobile) in un intero. Esiste anche una funzione simile,
\verb'float' che converte un numero intero in numero in virgola
mobile. Un'altra funzione di Python è \verb'eval' che ritorna il tipo
di dato che viene immesso. La funzione \verb'eval' prende una stringa
e ritorna i dati che Python rileva. Per esempio: 
\begin{verbatim}
>>> v=eval('123')
>>> print v,type(v)
123 <type 'int'>
>>> v=eval('645.123')
>>> print v,type(v)
645.123 <type 'float'>
>>> v=eval('[1,2,3]')
>>> print v,type(v)
[1, 2, 3] <type 'list'>
\end{verbatim}
Se usate la funzione \verb'eval' dovete controllare il valore che
ritorna per assicurarvi che sia quello che vi aspettate.

Un'altra funzione utile in string è \verb'split'. Questo è un esempio: 
\begin{verbatim}
>>> import string
>>> string.split("This is a bunch of words")
['This', 'is', 'a', 'bunch', 'of', 'words']
>>> string.split("First batch, second batch, third, fourth",",")
['First batch', ' second batch', ' third', ' fourth']
\end{verbatim}
Notate come \verb'split' converte una stringa in una lista di
stringhe. La stringa viene divisa in corrispondenza di ogni spazio o
di un secondo argomento (in questo caso la virgola).

%%TODO add more on strings

\section{Esempi}
\begin{verbatim}
# Questo programma richiede un'eccellente conoscenza dei numeri
# decimali.

def to_string(in_int):
    "Converts an integer to a string"
    out_str = ""
    prefix = ""
    if in_int < 0:
        prefix = "-"
        in_int = -in_int        
    while in_int / 10 != 0:
        out_str = chr(ord('0')+in_int % 10) + out_str
        in_int = in_int / 10
    out_str = chr(ord('0')+in_int % 10) + out_str
    return prefix + out_str

def to_int(in_str):
    "Converts a string to an integer"
    out_num = 0
    if in_str[0] == "-":
        multiplier = -1
        in_str = in_str[1:]
    else:
        multiplier = 1
    for x in range(0,len(in_str)):
        out_num = out_num * 10 + ord(in_str[x]) - ord('0')
    return out_num * multiplier

print to_string(2)
print to_string(23445)
print to_string(-23445)
print to_int("14234")
print to_int("12345")
print to_int("-3512")
\end{verbatim}

L'output è:
\begin{verbatim}
2
23445
-23445
14234
12345
-3512
\end{verbatim}













\chapter{File IO}
Questo è un semplice esempio di File IO:
\begin{verbatim}
# Scrive un file.
out_file = open("test.txt","w")
out_file.write("This Text is going to out file\nLook at it and see\n")
out_file.close()

# Legge un file.
in_file = open("test.txt","r")
text = in_file.read()
in_file.close()

print text,
\end{verbatim}
L'output ed il contenuto del file test.txt è:
\begin{verbatim}
This Text is going to out file
Look at it and see
\end{verbatim}
Osservate come il programma scriva un file chiamato test.txt nella
directory nella quale viene eseguito. Il \verb'\n' nella stringa dice
a Python di andare a capo ({\bf n}ewline) nel punto in cui compare.

Una panoramica sul file IO:
\begin{enumerate}
\item Aprite un oggetto file con la funzione \verb'open'
\item Leggete o scrivete nell'oggetto file (a seconda di come l'avete
      aperto) 
\item Chiudetelo
\end{enumerate}

Il primo passo è usare un oggetto file grazie alla funzione
\verb'open'. La sintassi è
\verb'oggetto_file = open (nome_file, modo)' dove \verb'oggetto_file'
è la variabile contenente l'oggetto file, \verb'nome_file' la stringa
con il nome del file, e \verb'modo' la modalità di apertura del file:
\verb'"r"' in lettura ({\bf r}ead), \verb'"w"' in scrittura 
({\bf w}rite). Dopodiché potrete chiamare le funzioni dell'oggetto
file. Le due funzioni più comuni sono \verb'read' e \verb'write'. La
funzione \verb'write' aggiunge una stringa alla fine del file. La
funzione \verb'read' legge il file e ne ritorna il contenuto
sottoforma di stringa. Se non vi sono argomenti, ritorna l'intero file
(come nell'esempio).

Questa è una nuova versione dell'agenda telefonica che abbiamo scritto
precedentemente: 
\begin{verbatim}
import string

true = 1
false = 0

def print_numbers(numbers):
    print "Telephone Numbers:"
    for x in numbers.keys():
        print "Name: ",x," \tNumber: ",numbers[x]
    print

def add_number(numbers,name,number):
    numbers[name] = number

def lookup_number(numbers,name):
    if numbers.has_key(name):
        return "The number is "+numbers[name]
    else:
        return name+" was not found"

def remove_number(numbers,name):
    if numbers.has_key(name):
        del numbers[name]
    else:
        print name," was not found"


def load_numbers(numbers,filename):
    in_file = open(filename,"r")
    while true:
        in_line = in_file.readline()
        if in_line == "":
            break
        in_line = in_line[:-1]
        [name,number] = string.split(in_line,",")
        numbers[name] = number
    in_file.close()

def save_numbers(numbers,filename):
    out_file = open(filename,"w")
    for x in numbers.keys():
        out_file.write(x+","+numbers[x]+"\n")
    out_file.close()
    

def print_menu():
    print '1. Print Phone Numbers'
    print '2. Add a Phone Number'
    print '3. Remove a Phone Number'
    print '4. Lookup a Phone Number'
    print '5. Load numbers'
    print '6. Save numbers'
    print '7. Quit'
    print
\end{verbatim}
\begin{verbatim}
phone_list = {}
menu_choice = 0
print_menu()
while menu_choice != 7:
    menu_choice = input("Type in a number (1-7):")
    if menu_choice == 1:
        print_numbers(phone_list)
    elif menu_choice == 2:
        print "Add Name and Number"
        name = raw_input("Name:")
        phone = raw_input("Number:")
        add_number(phone_list,name,phone)
    elif menu_choice == 3:
        print "Remove Name and Number"
        name = raw_input("Name:")
        remove_number(phone_list,name)
    elif menu_choice == 4:
        print "Lookup Number"
        name = raw_input("Name:")
        print lookup_number(phone_list,name)
    elif menu_choice == 5:
        filename = raw_input("Filename to load:")
        load_numbers(phone_list,filename)
    elif menu_choice == 6:
        filename = raw_input("Filename to save:")
        save_numbers(phone_list,filename)
    elif menu_choice == 7:
        pass
    else:
        print_menu()
print "Goodbye"  
\end{verbatim}
Ora include anche il salvataggio e la lettura di file.  Qui una parte
dell'output dell'esecuzione ripetuta due volte:
\begin{verbatim}
> python tele2.py
1. Print Phone Numbers
2. Add a Phone Number
3. Remove a Phone Number
4. Lookup a Phone Number
5. Load numbers
6. Save numbers
7. Quit

Type in a number (1-7):2
Add Name and Number
Name:Jill
Number:1234
Type in a number (1-7):2
Add Name and Number
Name:Fred 
Number:4321
Type in a number (1-7):1
Telephone Numbers:
Name:  Jill     Number:  1234
Name:  Fred     Number:  4321

Type in a number (1-7):6
Filename to save:numbers.txt
Type in a number (1-7):7
Goodbye
\end{verbatim}
\begin{verbatim}
> python tele2.py
1. Print Phone Numbers
2. Add a Phone Number
3. Remove a Phone Number
4. Lookup a Phone Number
5. Load numbers
6. Save numbers
7. Quit

Type in a number (1-7):5
Filename to load:numbers.txt
Type in a number (1-7):1
Telephone Numbers:
Name:  Jill     Number:  1234
Name:  Fred     Number:  4321

Type in a number (1-7):7
Goodbye
\end{verbatim}

Le nuove porzioni del programma sono:
\begin{verbatim}
def load_numbers(numbers,filename):
    in_file = open(filename,"r")
    while 1:
        in_line = in_file.readline()
        if len(in_line) == 0:
            break
        in_line = in_line[:-1]
        [name,number] = string.split(in_line,",")
        numbers[name] = number
    in_file.close()

\end{verbatim}
\begin{verbatim}
def save_numbers(numbers,filename):
    out_file = open(filename,"w")
    for x in numbers.keys():
        out_file.write(x+","+numbers[x]+"\n")
    out_file.close()
\end{verbatim}

Per prima cosa osserviamo la porzione del programma che esegue il
salvataggio. Innanzitutto crea un oggetto file con il comando
\verb'open(filename,"w")', dopodiché crea una nuova linea per ognuno
dei numeri di telefono con il comando
\verb'out_file.write(x+","+numbers[x]+"\n")'. In questo modo scrive
una linea contenente il nome, una virgola ed il numero, seguito da un
'a capo' (newline).

La funzione che effettua il caricamento in memoria è un po' più
complessa. Inizia creando un oggetto file, quindi usa il ciclo
\verb'while 1:' finché non incontra un'istruzione
\verb'break'. Successivamente passa alla linea
\verb'in_line = in_file.readline()'. La funzione \verb'readline'
ritorna una stringa vuota \verb'(len(string) == 0)' quando viene raggiunta la
fine del file. L'istruzione \verb'if' esegue un controllo sul
\verb'break' e se è il caso, uscirà dal ciclo
\verb'while'. Naturalmente, se la funzione \verb'readline' non
restituisse il newline all'estremità della linea, non potremmo
stabilire se è una stringa vuota, una linea vuota o la fine del
file, per questo inseriamo il newline che \verb'readline'
restituisce, solamente dop lo elimineremo.

La linea \verb'in_line = in_line[:-1]' elimina l'ultimo carattere
della linea (il newline che farebbe andare a capo la linea). Nelle
restanti istruzioni viene trattata la stringa, dividendola in base
alla virgola, in due parti:
\verb'[name,number] = string.split(in_line,",")', nome e
numero. Infine il numero viene inserito nel dizionario
\verb'numbers'. 

\section{Esercizi}

Modificate il programma dei voti del Capitolo \ref{firstgrades} per
salvare su di un file la registrazione degli studenti.










\chapter{Occuparsi dell'imperfetto (o come gestire gli errori)}

Ora avete un programma perfetto, funziona senza crepe, ad eccezione di
un dettaglio: va in crash se l'utente inserisce un input errato. Non
abbiate paura, Python ha una speciale struttura di controllo per
eliminare questi imprevisti. Sto parlando di \verb'try'... try tenta di
fare qualcosa. Segue un esempio di un programma che contiene un
problema:
\begin{verbatim}
print "Type Control C or -1 to exit"
number = 1
while number != -1:
    number = int(raw_input("Enter a number: "))
    print "You entered: ",number

\end{verbatim}

Se tentate di inserire qualcosa come \verb'@#&' l'output sarà simile a
questo: 
\begin{verbatim}
Traceback (innermost last):
  File "try_less.py", line 4, in ?
    number = int(raw_input("Enter a number: "))
ValueError: invalid literal for int(): @#&
\end{verbatim}

Come potete vedere la funzione \verb'int' non funziona (e non deve
funzionare) con il numero \verb'@#&'. L'ultima linea mostra qual'è
l'errore: Python ha trovato un \verb'ValueError'. Come fare in modo
che il nostro programma sappia gestire anche questo valore?
Innanzitutto inserendo la parte di codice che restituisce l'errore in
un blocco \verb'try' e poi decidendo come Python debba trattare
\verb'ValueError'. Il seguente programma mostra come ottenere tale
comportamento: 
\begin{verbatim}
print "Type Control C or -1 to exit"
number = 1
while number != -1:
    try:
        number = int(raw_input("Enter a number: "))
        print "You entered: ",number
    except ValueError:
        print "That was not a number."
\end{verbatim}

Ora, quando eseguiremo il nuovo programma ed inseriremo \verb'@#&', il
programma risponderà con la frase ``That was not a number.'' per poi
continuare ciò che stava facendo prima.

Quando il vostro programma restituisce un errore che sapete come
gestire, mettete il codice in un blocco \verb'try' ed il modo per
gestire l'errore nel successivo blocco \verb'except'. 

\section{Esercizi}

Aggiornate il programma della rubrica telefonica del capitolo
precedente in modo che non si interrompa se l'utente non inserisce
dati nel menu. 


%Road map\\
%boolean expressions\\
%defining functions\\
%more on lists
%modules\\
%dictionaries
%the end\\
%%#########################################################################
%%##############        THE END OF THE BOOK           #####################
%%#########################################################################











\chapter{Fine}
Sto lavorando per aggiungere ulteriori sezioni a questo documento. Per ora
vi raccomando il "Python Tutorial" di Guido Van Rossum, ormai dovreste
essere in grado di capire la maggior parte degli argomenti.

Questo tutorial è ancora un lavoro in corso. Gradirei qualsiasi tipo
di commento e/o richiesta di argomenti da aggiungere. Le vostre e-mail
mi hanno portato ad ampliare e migliorare notevolmente il documento,
ed io ho sempre tenuto in molta considerazione ogni vostro intervento
:). 

Buona programmazione, che possa cambiare la vostra vita e il mondo.

%TODO=[ 'errors','how to make modules','more on loops','more on strings', 'file io','how to use online help','try','pickle','anything anyone suggests that I think is a good idea'] 

\chapter{FAQ}

Scherzetto ... le FAQ non sono state tradotte ;-)

Niente paura, semplicemente erano così stringate che, per ora, è stato
ritenuto più opportuno impostarle in altro modo. In due parole ...
suggerivano di usare una versione di Python 2.1 o superiori e davano
indicazioni su dove trovare la versione originale di questo tutorial ed i
formati disponibili.

In merito all'ubicazione del tutorial, per quanto riguarda la versione
originale: 

\url{http://www.honors.montana.edu/\~{}jjc/easytut/} (comprese le
soluzioni degli esercizi...) 


All'URL indicata è possibile reperire il documento in molteplici formati,
html, ps, pdf, ps e pdf Book, il make per crearli e logicamente il sorgente
in formato .tex. Come molti di voi avranno capito il sorgente è stato
scritto in LaTeX, usando però la classe "manual", presa direttamente da
quella creata dal gruppo Python per scrivere la documentazione del
linguaggio.

Inoltre è disponibile l'elenco delle versioni rilasciate dall'autore:


\begin{description}
\item[What and when was the last thing changed?] 2000-Dec-16, added error handling chapter.\\
2000-Dec-22, Removed old install procedure.\\
2001-Jan-16, Fixed bug in program, Added example and data to lists section.\\
2001-Apr-5,  Spelling, grammar, added another how to break programs, url fix for PDF version.\\
2001-May-13, Added chapter on debugging.  \\
2001-Nov-11, Added exercises, fixed grammar, spelling, and hopefully improved explanations of some things.\\
2001-Nov-19, Added password exercise, revised references section.\\
2002-Feb-23, Moved 3 times password exercise, changed l to list in list examples question.  Added a new example to Decisions chapter, added two new exercises.\\
2002-Mar-14, Changed abs to my_abs since python now defines a abs function.\\
2002-May-15, Added a faq about creating an executable.  Added a comment from 
about the list example.  Fixed typos from Axel Kleiboemer.\\
2002-Jun-14, Changed a program to use while true instead of while 1 to 
be more clear.\\
2002-Jul-5, Rewrote functions chapter.  Modified fib program to hopefully 
be clearer.\\
2003-Jan-3, Added average examples to the decisions chapter.\\
2003-Jan-19, Added comment about value of a_var.  Fixed mistake in average2.py
program.
\end{description}

Per quanto riguarda la presente versione, tradotta in italiano
potete trovare qui \url{http://www.python.it/doc/index.html} la
pagina dalla quale raggiungere tutti i formati del documento. 

A proposito del presente documento, sarebbe cosa gradita che chiunque
volesse renderlo disponibile per il download sul proprio sito,
quantomeno rilasciasse le versioni html, txt, ps, pdf e pdf Book, un
file compresso contenente una directory che racchiuda i formati
elencati ed il sorgente \LaTeX.  

%%\chapter{Command Line Install}
%%
%%This is here purely for historical reasons.  
%%
%%\section{Running Python}
%%This section is somewhat vague since I am trying to explain how to run Python in general and not on a specific machine (though I am writing from a Unix viewpoint).  If you have a Microsoft(tm) Windows machine see the next section for details.  If you have a Macintosh see http://www.python.org for other documentation.
%%
%%First you should check to see if you can run Python in interactive mode.  To do this go to a command prompt and type {\tt python}.  If everything is working you should see something like this:
%%\begin{verbatim}
%%Python 1.5.1 (#1, Dec 17 1998, 20:58:15)  [GCC 2.7.2.3] on linux2
%%Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
%%>>>
%%\end{verbatim}
%%The {\tt >>>} is Python's way of telling you it is waiting for you to type something in.  
%%
%%If you did not get the {\tt >>>} prompt then something is wrong.  Check and make sure that you properly installed Python.  Check to see that the python executable is in the path.  
%%
%%Once you got the Python interpreter running you can play around with it.  Here are some things you could try:
%%\begin{verbatim}
%%>>> 1+1
%%2
%%>>> 3*4+5 
%%17
%%>>> a=12
%%>>> a     
%%12
%%>>> "Hi"
%%'Hi'
%%>>> 
%%\end{verbatim}
%%
%%To exit try typing Ctrl+Z or Ctrl+D or if neither of those works type \verb'import sys; sys.exit(0)'.  Next, how to run Python programs.  First you need create a Python program.  To do that you should type in the following in a text editor:\footnote{A text editor is just a program that edits text.  If you are in Windows I recommend that you use Notepad or Editpad (http://www.jgsoft.com).  If you are in Unix I recommend that you use a text editor that you are comfortable with (if you haven't found one yet use pico, ae, or (x)emacs (emacs has a very nice Python mode BTW)).  }
%%\begin{verbatim}
%%print "Hello, World!"
%%\end{verbatim}
%%
%%Now save the file in some convenient location as hello.py.  Next go to directory with the file that you save the file in and type {\tt python hello.py}.  The screen should look something like this:
%%\begin{verbatim}
%%>python hello.py
%%Hello, World!
%%\end{verbatim}
%%
%%If you get some error message check to make sure you saved the file in the right place.  
%%
%%From now on I will mainly give you programs to type in that you should save and then run.  
%%%%If you didn't get that and get some error message like bad command or filename or command not found then either Python is not installed or the Python interpreter is not in your path.  With Windows you need to have the python.exe file locate in your path.  For example, if python.exe is in the directory \verb'C:\PROGRA~1\PYTHON\' then if you add \verb'PATH=C:\PROGRA~1\PYTHON\;%PATH%' to the end of your \verb'AUTOEXEC.BAT' file the next time you reboot your computer python.exe will be found in your path.  For Unix find Python with locate and add the directory to the path (or move python).
%%
%%%%There, you now should be able to type in and run a Python program.  The later chapters will show you more about how to create a Python program.
%%
%%\section{Windows}
%%First install Python.  Then go to a command line which can be done one of two ways: Click {\bf Start>>Programs>>MS-DOS Prompt}, or click {\bf Start>>Run}, then type {\bf command} and hit {\bf Enter}.
%%
%%This will open up a DOS screen with a prompt that probably looks like this:
%%
%%\begin{verbatim}
%%C:\WINDOWS>   
%%\end{verbatim}
%%
%%Type {\bf python} and hit {\bf Enter}.  If you get {\tt Bad command or file name} then either you forgot to install Python or {\tt python.exe} is not in the {\tt PATH} variable (to see what the {\tt PATH} variable has in it type {\bf PATH}).  
%%
%%To fix the problem click {\bf Start>>Find>>Files or Folders} and then look for a file {\bf Named} {\tt python.exe}.  If it is found then the problem is the {\tt PATH}, otherwise Python was not properly installed.  
%%
%%To fix the {\tt PATH} problem the directory that includes {\tt python.exe} needs to be added to {\tt PATH}.  The directory that {\tt python} is in is the folder that {\tt Find} shows to the left of the name.  If the whole name is not shown Right click on the python icon and go to {\bf Properties}.  The {\tt Properties} dialog will have a line called {\tt Location:} that shows the directory where {\tt python.exe} is at.  Next go to the command prompt and type in \verb'PATH="C:\Location of Python\";%PATH%'.  For Example:
%%\begin{verbatim}
%%C:\WINDOWS>python
%%Bad command or file name
%%
%%C:\WINDOWS>PATH="C:\Programe Files\Python";%PATH%
%%
%%C:\WINDOWS>python
%%Python 1.5.1 (#0, Apr 13 1998, 20:22:04) [MSC 32 bit (Intel)] on win32
%%Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
%%>>>
%%\end{verbatim}
%%Type Ctrl+Z to get out of interactive mode (i.e. hold down the Ctrl Key and then press down on the Z key at the same time, then release both.).
%%
%%Next type this program in a text editor (such as Notepad):
%%\begin{verbatim}
%%print "Hello, World!"
%%\end{verbatim}
%%and save it in a convenient location such as \verb'C:\python\hello.py'.
%%
%%From here you need to change the path to the Python directory where you saved your first program.  The command to do this is (Hit Enter):
%%\begin{verbatim}
%%cd \python      
%%\end{verbatim} 
%%which should give you a prompt like:
%%\begin{verbatim}
%%C:\Python>
%%\end{verbatim}
%%
%%Now you are ready to run your first program.  Just type python hello.py
%%
%%\begin{verbatim}
%%>python hello.py
%%Hello, World!
%%\end{verbatim}
%%
%%From now on in the tutorial I will assume that you know how to create and run programs.
%%
%%
%%\section{Longer Windows install}
%%%%\newcommand{\file}[1]{{\tt#1}}
%%%%\newcommand{\url}[1]{{\tt#1}}
%%
%%\subsection{Download Python}
%%
%%Download \file{py152.exe} from \url{http://www.python.org/download/download\_windows.html}   The file is located at \url{ftp://ftp.python.org/pub/python/win32/py152.exe}   Download this file and save it to your computer.
%%
%%\subsection{Install Python}
%%
%%Run \file{py152.exe} by double clicking on the executable.  This will start the Python installation process.  Use the defaults for the install.  The computer will restart after this is done.
%%
%%%%The Python installation creates a folder \file{Python 1.5}.  Go to Start$\to$ Programs$\to$ Python~1.5
%%
%%\subsection{Add Python to Path}
%%
%%The next step is to add the Python executable to the path.  The path specifies how DOS finds commands.  First you will find where the Python executable was installed.  Next create a \file{PATH} command to tell DOS where to find Python.  Lastly add the \file{PATH} command to the autoexec.bat so that it will be permanent.  The following tells how to do this.
%%
%%This is what you should do to add Python to the path. First get to an MS-DOS Prompt.  The way to get to a MS-DOS Prompt is go to Start$\to$Run.  When the Run dialog pops up type \type{command} and press Enter (Note: don't type the ``quotation marks'', just type the stuff between them)  (Note two: type Enter after everything that I put in this \type{font}).  A window titled MS-DOS Prompt should appear.  
%%
%%Type \type{cd \textbackslash{}}.  The command \type{cd} stands for change directory.  When \type{cd} is followed by a \type{\textbackslash{}} it means change to the root directory.  The \file{C:\textbackslash{}>} prompt tells you that you are in the root directory.  Once in the root directory the next task is to find Python. 
%%
%%Type \type{dir /s python.exe}  This should give you some output like:
%%\begin{verbatim}
%%
%% Volume in drive C is WIN 95
%% Volume Serial Number is 283F-12D9
%%
%%Directory of C:\Program Files\Python
%%
%%PYTHON   EXE         5,120  04-13-99 11:31a python.exe
%%         1 file(s)          5,120 bytes
%%
%%Total files listed:
%%         1 file(s)          5,120 bytes
%%         0 dir(s)     344,498,176 bytes free
%%
%%\end{verbatim}
%%The important part of this is the line:
%%\begin{verbatim}
%%Directory of C:\Program Files\Python
%%\end{verbatim} 
%%which shows the directory that \file{python.exe} is located in. This can be used to create a \file{PATH} variable that allows \file{python} to be run from anywhere on the system.  The syntax is  \type{PATH=\%PATH\%;"directory"} where directory is the directory that \file{python.exe} is in.  For this example the command is:
%%\begin{verbatim}
%%PATH=%PATH%;"C:\Program Files\Python"
%%\end{verbatim}
%%
%%Type this in at the DOS Prompt and then you should be able to run Python with the \type{python} command.  If you did everything right you should see (version numbers and dates may be different):
%%\begin{verbatim}
%%Python 1.5.2 (#4, Dec 16 1999, 18:55:39)  [GCC 2.7.2.3] on Win 95
%%Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
%%>>> 
%%\end{verbatim}
%%If you get the \file{$>>>$} prompt you have gotten into Python.  Try typing in it \type{print "Hello"}.  You should see \file{Hello} printed.  Try tying \type{print 1+1}.  You should see \file{2} printed.  Type \type{Ctrl-Z} (i.e. type z while holding down the Ctrl key) to get out of Python's interactive mode.  
%%
%%If there is some problem with the \file{PATH} then you will see something like:
%%\begin{verbatim}
%%C:\>python
%%Bad command or file name
%%\end{verbatim}
%%
%%Right now the change you made is only temporary.  To get Python to be in the \file{PATH} every time the computer starts you need to add it to the \file{autoexec.bat} file.  The \file{autoexec.bat} file is run every time the computer starts.  To do this open the \file{autoexec.bat} in a text editor like \file{notepad}.  Type the command \type{notepad c:\textbackslash{}autoexec.bat} on the DOS Prompt.  If you don't have a \file{autoexec.bat} notepad will ask you if you want to create one (say yes).  Add the line that you used above (i.e. something like: \type{PATH=\%PATH\%;"C:\textbackslash{}Program Files\textbackslash{}Python"}) to the \file{autoexec.bat}.  Add the line as close to the bottom as you can, just don't add the line after a line that tells windows to load:
%%\begin{verbatim}
%%PATH=%PATH%;"C:\Program Files\Python"
%%win
%%\end{verbatim} 
%%The \file{win} loads Windows so I added the path line above it.  If you don't see a \file{win} line add the path line to the end.  Save the \file{autoexec.bat} file, reboot your computer and it should be install.
%%
%%When your computer boots again go to the DOS Prompt and try to run \type{python} again to see if the change was successful.
%%
%%\subsection{Running Programs}
%%
%%Now that Python is set up we need to use it to run programs.  Go to a DOS Prompt (Start$\to$Run, then type \type{command}).  Change to the root directory (\type{cd \textbackslash{} }).  Now make a directory with the command \type{mkdir prg} which makes the directory \file{prg}.  Switch into that directory with the \type{cd prg} command.  Create a file there by typing the \type{notepad hello.py} command.  That will open a \file{notepad} window.  In Notepad type:
%%\begin{verbatim}
%%print "Hello, World!"
%%\end{verbatim}
%%Save the file and then go back to the DOS Prompt.  Now type \type{python hello.py} in at the DOS Prompt.  Python should reply with \file{Hello, World!} if everything is working right.  If you get the error: 
%%\begin{verbatim}
%%Bad command or file name
%%\end{verbatim}
%%check to see if the path is correct.  Also check to make sure that you spelled \file{python} correctly.  If you get the error:
%%\begin{verbatim}
%%C:\PROGRA~1\PYTHON\PYTHON.EXE: can't open file 'hello.py'
%%\end{verbatim}
%%check to see that you properly saved the \file{hello.py} file and that you are in the correct directory.
%%
%%Once you have that working create another file with the \type{notepad ask.py} command.  Put the following text in the file:
%%\begin{verbatim}
%%data = raw_input("Type something here:")
%%print "You typed:",data
%%\end{verbatim} 
%%Save and then run with the \type{python ask.py} command.  The program should ask you to type in data and after you hit Enter it will tell you what you type.  You should get something like this:
%%\begin{verbatim}
%%Type something here:Hi
%%You typed: Hi
%%\end{verbatim}
%%If you got that, congratulations, you now have a working Python environment.


%\chapter{...}

%My appendix.

%The \code{\e appendix} mark-up need not be repeated for additional
%appendices.


%
%  The ugly "%begin{latexonly}" pseudo-environments are really just to
%  keep LaTeX2HTML quiet during the \renewcommand{} macros; they're
%  not really valuable.
%
%  If you don't want the Module Index, you can remove all of this up
%  until the second \input line.
%
%begin{latexonly}
%\renewcommand{\indexname}{Module Index}
%end{latexonly}
%\input{mod\jobname.ind}                % Module Index

%begin{latexonly}
\renewcommand{\indexname}{Index}
%end{latexonly}
\input{\jobname.ind}                        % Index

\end{document}

