<!DOCTYPE BOOK PUBLIC "-//Davenport//DTD DocBook V3.0//EN">


<BOOK id=book lang="it">
<BOOKINFO>
  <BOOKBIBLIO>
    <TITLE>Tutorial per newbies con Python</TITLE>
    <AUTHORGROUP>
      <AUTHOR>
        <SURNAME>Cogliati</SURNAME>
        <FIRSTNAME>Josh</FIRSTNAME>
      </AUTHOR>

    </AUTHORGROUP>
<PUBDATE>20 novembre 2001</PUBDATE>
  </BOOKBIBLIO>
  <LEGALNOTICE>
    <PARA>Copyright &copy; 1999-2001 Josh Cogliati</PARA>
   <PARA>
   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
   distrubutor grants the recipient permission for further redistribution
   as permitted by this notice.
   </PARA>
   <PARA>
   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.
   </PARA>
   <PARA>
   All example python source code in this tutorial is granted to the public
   domain. Therefore you may modify it and relicence it under any
   license you please.
   </PARA>
   <PARA> Josh Cogliati:
   <ULINK url="http://www.honors.montana.edu/~jjc/easytut/easytut/"></ULINK>
   <EMAIL>jjc@honors.montana.edu</EMAIL></PARA>

   <PARA></PARA><PARA>
	Versione in lingua Italiana del "Non-Programmers Tutorial For Python" a
	cura di Nicholas Wieland e Ferdinando Ferranti.</PARA><PARA>
	Per quanto riguarda eventuali aggiornamenti della versione Italiana
	rivolgersi a:
	<EMAIL>gregorsamsa@email.it</EMAIL> o
	<EMAIL>zappagalattica@inwind.it</EMAIL>, i
	successivi aggiornamenti di questa traduzione dovrebbero essere
	reperibili o raggiungibili dal sito locale di Python:
	<ULINK url="http://www.python.it"></ULINK>
   </PARA>
   <PARA>
	<REVHISTORY>
	<REVISION>
	<REVNUMBER>1.0</REVNUMBER>
		<DATE>25 agosto 2002</DATE>
		<AUTHORINITIALS>Nicholas W. e Ferdinando F.</AUTHORINITIALS>
	</REVISION>
	</REVHISTORY></PARA>
   </LEGALNOTICE>
</BOOKINFO>


<DEDICATION>
<PARA>
Dedicato a <EMPHASIS>Elizabeth Cogliati</EMPHASIS>.
</PARA>
</DEDICATION>


<PREFACE>
   <TITLE>Prefazione</TITLE>
	<PARA>
	"Tutorial di Python per newbies" è un tutorial pensato per essere una
	introduzione alla programmazione in Python, è destinato infatti a chi non ha
	esperienze con la programmazione.
	</PARA><PARA>
	Se qualcuno di voi ha già programmato con altri linguaggi vi raccomando il
	Python Tutorial scritto da Guido van Rossum.
	</PARA><PARA>
	Se qualcuno di voi ha domande o commenti mi contatti al mio indirizzo
	<EMAIL>jjc@iname.com</EMAIL>, (<EMAIL>gregorsamsa@email.it</EMAIL> per
	la presente versione tradotta) commenti e suggerimenti riguardo
	questo documento sono i benvenuti. Proverò a rispondere a qualsiasi
	domanda poniate meglio che potrò.
	</PARA><PARA>
	I ringraziamenti vanno a James A. Brown per aver scritto la maggior parte della
	sezione dedicata all'installazione sotto Windows. Grazie anche a Joe Oppergaard
	per aver scritto tutti gli esercizi. Grazie anche a tutti quelli che ho
	dimenticato.
	</PARA>
</PREFACE>











<CHAPTER ID="C1">
<TITLE>Introduzione</TITLE>


<SECT1 ID="C1.1" XREFLABEL="1.1">
<TITLE>La prima cosa</TITLE>
<PARA>
	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, leggere codice - scrivere codice e io ve ne farò leggere e
	scrivere tantissimo. Per questo dovrete <COMMAND>sempre </COMMAND>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:
	<BLOCKQUOTE><SCREEN><FILENAME>
##Python is easy to learn
print "Hello, World!"
	</FILENAME></SCREEN></BLOCKQUOTE>
	Facile da distinguere dal resto del testo no ?
	Appunto per confondervi scriverò
	così anche gli outputs del computer :=)
</PARA><PARA>
	Un'altra cosa importante: per programmare in Python vi serve il Python. Se non
	avete ancora il software necessario dirigetevi verso
	http://www.python.org/download. Andate alla versione 2.0 o superiore e
	scaricatevi la versione adatta alla vostra piattaforma, leggete le istruzioni e
	installatela.
</PARA>

</SECT1>


<SECT1 ID="C1.2" XREFLABEL="1.2">
<TITLE>Installare Python</TITLE>
<PARA>
	Innanzitutto scaricatevi il file appropriato: il Windows Installer nel caso
	usiate Windows o i sorgenti da compilare se avete un sistema Unix.
</PARA><PARA>
	Scaricando il Windows Installer avrete un file che basterà doppiocliccare per
	iniziare la procedura di installazione.
</PARA><PARA>
	Scaricando i sorgenti Unix assicuratevi di compilare con l'estensione Tk per
	usare IDLE.
</PARA>

</SECT1>

<SECT1 ID="C1.3" XREFLABEL="1.3">
<TITLE>Modo interattivo</TITLE>
<PARA>
	Aprite IDLE, la GUI di Python. Dovreste vedere una finestra di questo tipo:
	<BLOCKQUOTE><SCREEN><FILENAME>
Python 2.2b1 (#1, Nov  4 2001, 01:38:44)
[GCC 2.95.4 20011006 (Debian prerelease)] on linux2
Type "copyright", "credits" or "license" for more information.
IDLE 0.8 -- press F1 for help
>>></FILENAME></SCREEN></BLOCKQUOTE>
	>>> è il modo che ha Python per informarvi che siete in modo interattivo, dove
	i comandi digitati sono immediatamente eseguiti. Provate a digitare 1+1 e
	Python vi risponderà immediatamente 2. In questa modalità potete provare e
	vedere come reagisce Python ai vari comandi. Usatela quando sentirete il
	bisogno di prendere confidenza con i comandi Python.
</PARA>

</SECT1>




<SECT1 ID="C1.4" XREFLABEL="1.4">
<TITLE>Creare ed eseguire programmi</TITLE>
<PARA>
	Andate in modo interattivo se non ci siete già. Selezionate File dal menu
	dopodiché selezionate New Window.
</PARA>
<PARA>
	Digitate nella nuova finestra il seguente testo (codice):
<BLOCKQUOTE><SCREEN><FILENAME>
print "Hello, World!"
</FILENAME></SCREEN></BLOCKQUOTE>

	Innanzitutto salvate il programma sempre selezionando dal menu
	<FILENAME>File</FILENAME> e poi <FILENAME>Save</FILENAME>.
	Salvatelo come "hello.py" nella directory di default o nella directory
	che preferite. Ora che avete salvato potete eseguire il programma. Selezionate
	dal menu la voce <FILENAME>edit</FILENAME> e poi
	<FILENAME>Run script</FILENAME>. Questa azione vi restituirà
	l'output richiesto dal programma hello.py nella finestra
	<FILENAME>*Python Shell*</FILENAME> che saluterà allegramente
	con un: <FILENAME>Hello, World!</FILENAME>.

</PARA>
</SECT1>


<SECT1 ID="C1.5" XREFLABEL="1.5">
<TITLE>Usare Python dalla linea di comando</TITLE>
<PARA>
	Se preferite non utilizzare Python dalla linea di comando non
	siete obbligati, usate IDLE.
</PARA><PARA>
	Per entrare in modo interattivo dalla linea di comando dovete semplicemente
	digitare python mentre se volete eseguire un programma scritto con un editor
	di testo (ad esempio Emacs è un ottimo editor per Python) non dovete fare altro
	che usare la sintassi <FILENAME>python program name</FILENAME>.
</PARA>

</SECT1>

</CHAPTER>










<CHAPTER ID="C2">
<TITLE>Hello, World</TITLE>


<SECT1 ID="C2.1" XREFLABEL="2.1">
<TITLE>Cosa dovresti già sapere</TITLE>
<PARA>
	Dovresti sapere come visualizzare un programma in un editor di testo, salvarlo
	su disco (floppy o disco fisso) ed eseguirlo una volta salvato.
</PARA>

</SECT1>


<SECT1 ID="C2.2" XREFLABEL="2.2">
<TITLE>Stampare</TITLE>
<PARA>
	Sin dall'inizio dei tempi i tutorials sono sempre iniziati con un semplice
	programma chiamato 'Hello World'. Eccolo:

<BLOCKQUOTE><SCREEN><FILENAME>

print "Hello, World!"

</FILENAME></SCREEN></BLOCKQUOTE>
	Se state usando la linea di comando per eseguire i programmi inserite la linea
	di testo in un editor e salvate come 'hello.py', eseguite il file appena
	salvato con il comando <EMPHASIS>'python hello.py'</EMPHASIS>.
</PARA><PARA>
	Altrimenti entrate in IDLE, aprite una nuova finestra (New window) e create il
	programma come spiegato nella sezione <XRef Linkend="C1.3">.
</PARA><PARA>
	Ecco cosa stampa sullo schermo 'hello.py' quando viene eseguito:

<BLOCKQUOTE><SCREEN><FILENAME>
Hello, World!
</FILENAME></SCREEN></BLOCKQUOTE>

	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 ...
</PARA><PARA>
	Tentiamo un programma un po' più complicato:
<BLOCKQUOTE><SCREEN><FILENAME>
print "Jack and Jill went up a hill"
print "to fetch a pail of water;"
print "Jack fell down, and broke is crown,"
print "and Jill came tumbling after."
</FILENAME></SCREEN></BLOCKQUOTE>
	Quando eseguirete il programma l'output sul monitor sarà questo:
<BLOCKQUOTE><SCREEN><FILENAME>
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.
</FILENAME></SCREEN></BLOCKQUOTE>
	Quando il computer esegue questo programma vede innanzitutto la prima riga:

<BLOCKQUOTE><SCREEN><FILENAME>
print "Jack and Jill went up a hill"
</FILENAME></SCREEN></BLOCKQUOTE>

	Ed esegue l'ordine, ovvero stampa:

<BLOCKQUOTE><SCREEN><FILENAME>
Jack and Jill went up a hill
</FILENAME></SCREEN></BLOCKQUOTE>

	Dopodiché il computer prosegue a leggere il codice e passa alla seconda
	linea:

<BLOCKQUOTE><SCREEN><FILENAME>
	print "to fetch a pail of water;"
</FILENAME></SCREEN></BLOCKQUOTE>

	Il risultato è la stampa di:

<BLOCKQUOTE><SCREEN><FILENAME>
to fetch a pail of water;
</FILENAME></SCREEN></BLOCKQUOTE>

	Capito il meccanismo? 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.
</PARA>

</SECT1>




<SECT1 ID="C2.3" XREFLABEL="2.3">
<TITLE>Espressioni</TITLE>
<PARA>
	Ecco qui un'altro programma:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

	E qui l'output che questo programma produce:

<BLOCKQUOTE><SCREEN><FILENAME>
2 + 2 is 4
3 * 4 is 12
99 = 100 - 1
(33 + 2) / 5 + 11.5 =  18.5
</FILENAME></SCREEN></BLOCKQUOTE>

	Come puoi vedere Python può trasformare il vostro costosissimo computer in una
	normale calcolatrice :-)
</PARA><PARA>
	Python ha 6 operatori basilari:
<TABLE>
	<TITLE></TITLE>
	<TGROUP cols="3" align="center">
	<THEAD>
	<ROW>
		<ENTRY>Operazione</ENTRY>
		<ENTRY>Simbolo</ENTRY>
		<ENTRY>Esempio</ENTRY>
	</ROW>
	</THEAD>
	<TBODY>
	<ROW>
		<ENTRY>Elevamento a potenza</ENTRY>
		<ENTRY>**</ENTRY>
		<ENTRY>5 ** 2 = 25</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>Moltiplicazione</ENTRY>
		<ENTRY>*</ENTRY>
		<ENTRY>2 * 3 == 6</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>Divisione</ENTRY>
		<ENTRY>/</ENTRY>
		<ENTRY>14 / 3 == 4</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>Resto</ENTRY>
		<ENTRY>%</ENTRY>
		<ENTRY>14 % 3 == 2</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>Addizione</ENTRY>
		<ENTRY>+</ENTRY>
		<ENTRY>1 + 2 == 3</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>Sottrazione</ENTRY>
		<ENTRY>-</ENTRY>
		<ENTRY>4 - 3 == 1</ENTRY>
	</ROW>
	</TBODY>
	</TGROUP>
	</TABLE>

	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).
</PARA><PARA>
Il seguente programma dimostra la regola appena enunciata:
<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>
	Con l'output:
<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>
	Python da risposte differenti in base alla presenza o meno
	di numeri decimale.
</PARA><PARA>
	L'ordine delle operazioni è lo stesso che nella matematica:

<ORDEREDLIST numeration="arabic">
	<LISTITEM>
	<PARA>parentesi ()</PARA>
	</LISTITEM>
	<LISTITEM>
	<PARA>potenza **</PARA>
	</LISTITEM>
	<LISTITEM>
	<PARA>moltiplicazione *, divisione / e resto %</PARA>
	</LISTITEM>
	<LISTITEM>
	<PARA>addizione + e sottrazione -</PARA>
	</LISTITEM>
</ORDEREDLIST>

</PARA>

</SECT1>




<SECT1 ID="C2.4" XREFLABEL="2.4">
<TITLE>Parlare agli umani (e ad altri esseri intelligenti)</TITLE>
<PARA>
	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 l'abitudine di commentare il
	vostro lavoro.
</PARA><PARA>
	Un commento è semplicemente una nota, per altri programmatori ma anche per voi
	stessi, che spiega il programma nei punti salienti. Ad esempio:

<BLOCKQUOTE><SCREEN><FILENAME>
#Not quite PI, but an incredible simulation
print 22.0 / 7.0
</FILENAME></SCREEN></BLOCKQUOTE>
	Come potete vedere il commento inizia con il simbolo #.
</PARA>

</SECT1>








<SECT1 ID="C2.5" XREFLABEL="2.5">
<TITLE>Esempi</TITLE>
<PARA>
	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
</PARA><PARA>
	Denmark.py
<BLOCKQUOTE><SCREEN><FILENAME>
print "Something's rotten in the state of Denmark."
print "                -- Shakespeare"
</FILENAME></SCREEN></BLOCKQUOTE>

	Output:

<BLOCKQUOTE><SCREEN><FILENAME>
Something's rotten in the state of Denmark.
                       -- Shakespeare
</FILENAME></SCREEN></BLOCKQUOTE>

School.py

<BLOCKQUOTE><SCREEN><FILENAME>
#This is not quite true outside of USA
# and is based on my dim memories of my younger years
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
</FILENAME></SCREEN></BLOCKQUOTE>

	Output:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>
</PARA>

</SECT1>










<SECT1 ID="C2.6" XREFLABEL="2.6">
<TITLE>Esercizi</TITLE>
<PARA>
	Scrivete un programma che stampa su schermo il vostro nome e cognome con due
	stringhe separate.
</PARA><PARA>
	Scrivete un programma che mostra l'utilizzo delle 6 operazioni matematiche.
</PARA>

</SECT1>


</CHAPTER>

























<CHAPTER ID="C3">
<TITLE>Chi va là ?</TITLE>




<SECT1 ID="C3.1" XREFLABEL="3.1">
<TITLE>Input e variabili</TITLE>
<PARA>
	Ora proviamo un programma un po' più complicato:

<BLOCKQUOTE><SCREEN><FILENAME>
print "Halt!"
s = raw_input("Who Goes there? ")
print "You may pass,", s
</FILENAME></SCREEN></BLOCKQUOTE>

	ecco l'output del programma:

<BLOCKQUOTE><SCREEN><FILENAME>
Halt!
Who Goes there? Josh
You may pass, Josh
</FILENAME></SCREEN></BLOCKQUOTE>

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

</PARA><PARA>

	Certamente 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 <FILENAME>s</FILENAME> è,
	appunto, una variabile.
	Le variabili sono come delle scatole in cui si
	possono immagazzinare dati.
	Ecco un programma che ne spiega l'utilizzo:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

	e questo è l'output:

<BLOCKQUOTE><SCREEN><FILENAME>
a + b is 555.4
first_name is Bill
Sorted Parts, After Midnight or Spam
</FILENAME></SCREEN></BLOCKQUOTE>

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

</PARA><PARA>
	Ora, abbiamo queste scatole chiamate variabili e anche dati da metterci dentro.
	Il computer vedrà una linea come <FILENAME>'first_name = Bill'</FILENAME>
	che leggerà come - metti
	la stringa <FILENAME>'Bill'</FILENAME> nella scatola (o variabile)
	<FILENAME>'first_name'</FILENAME>. Più tardi vedrà
	l'espressione <FILENAME>'c = a + b'</FILENAME> che leggerà
	come "metti <FILENAME>a+b</FILENAME>
	o 123.4 + 432 all'interno della
	variabile <FILENAME>c</FILENAME>".
</PARA><PARA>
	Ecco un'altro esempio sull'utilizzo delle variabili:


<BLOCKQUOTE><SCREEN><FILENAME>
a = 1
print a
a = a + 1
print a
a = a * 2
print a
</FILENAME></SCREEN></BLOCKQUOTE>

	E di conseguenza ecco l'output:

<BLOCKQUOTE><SCREEN><FILENAME>
1
2
4
</FILENAME></SCREEN></BLOCKQUOTE>

	Anche se in tutti i casi sopraelencati
	la variabile ha lo stesso nome il
	computer la rilegge ogni volta.
	Prima trova i dati da
	immagazzinare e poi trova dove
	immagazzinarli.

</PARA><PARA>

	Un'ultimo esempio prima di chiudere il capitolo:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

	Ecco l'output che ho ottenuto:

<BLOCKQUOTE><SCREEN><FILENAME>
Type in a Number: 12.34
Type in a String: Hello
num = 12.34
num is a  &lt;type 'float'&gt;
num * 2 = 24.68
str = Hello
str is a  &lt;type 'string'&gt;
str * 2 = HelloHello
</FILENAME></SCREEN></BLOCKQUOTE>

	Osserva il modo in cui ho ottenuto dall'utente le due
	varaibili: input per la variabile numerica e
	<FILENAME>raw_input</FILENAME> per la variabile stringa.
	Quando volete che l'utente inserisca un numero o una stringa
	utilizzate, rispettivamente, input o stringa
	<FILENAME>raw_input</FILENAME>.
	</PARA><PARA>
	La seconda parte del programma utilizza la funzione
	type che vi informa sul tipo di variabile: le
	varibili numeriche sono di tipo int (numero intero)
	o float (numero decimale), le stringhe sono di tipo 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.
	<FILENAME>str * 2 = HelloHello</FILENAME>
</PARA><PARA>







<SECT1 ID="C3.2" XREFLABEL="3.2">
<TITLE>Esempi</TITLE>




<PARA>
rate_times.py

<BLOCKQUOTE><SCREEN><FILENAME>
#This programs calculates rate and distance problems
print "Input a rate and a distance"
rate = input("Rate:")
distance = input("Distance:")
print "Time:",distance/rate
</FILENAME></SCREEN></BLOCKQUOTE>

	Esecuzione:

<BLOCKQUOTE><SCREEN><FILENAME>
&gt; python rate_times.py
Input a rate and a distance
Rate:5
Distance:10
Time: 2
> python rate_times.py
Input a rate and a distance
Rate:3.52
Distance:45.6
Time: 12.9545454545
</FILENAME></SCREEN></BLOCKQUOTE>

	area.py

<BLOCKQUOTE><SCREEN ID="AREA" XREFLABEL="3.2"><FILENAME>
#This program calculates the perimeter and area of a rectangle
print "Calculate information about a rectangle"
length = input("Length:")
width = input("Width:")
print "Area",length*width
print "Perimeter",2*length+2*width
</FILENAME></SCREEN></BLOCKQUOTE>

	Esecuzione:

<BLOCKQUOTE><SCREEN><FILENAME>
&gt; 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
</FILENAME></SCREEN></BLOCKQUOTE>

	temperature.py

<BLOCKQUOTE><SCREEN><FILENAME>
#Converts fahrenheit to celcius
temp = input("Farenheit temperature:")
print (temp-32.0)*5.0/9.0
</FILENAME></SCREEN></BLOCKQUOTE>

	Esecuzione:

<BLOCKQUOTE><SCREEN><FILENAME>
&gt; python temperature.py
Farenheit temperature:32
0.0
&gt; python temperature.py
Farenheit temperature:-40
-40.0
&gt; python temperature.py
Farenheit temperature:212
100.0
&gt; python temperature.py
Farenheit temperature:98.6
37.0
</FILENAME></SCREEN></BLOCKQUOTE>

</PARA>

</SECT1>






<SECT1 ID="C3.3" XREFLABEL="3.3">
<TITLE>Esercizi</TITLE>
<PARA>
	Scrivete un programma che prenda due variabili stringa
	e due numeriche intere dall'utente, unisca le due
	stringhe senza spazi e le visualizzi sullo
	schermo, infine moltiplichi i due numeri interi su una linea nuova.
</PARA>

</SECT1>


</CHAPTER>

















<CHAPTER ID="C4">
<TITLE>Conta da 1 a 10</TITLE>




<SECT1 ID="C4.1" XREFLABEL="4.1">
<TITLE>Cicli While </TITLE>
<PARA>

	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 '<FILENAME>while</FILENAME>':

<BLOCKQUOTE><SCREEN><FILENAME>
a = 0
while a < 10:
        a = a + 1
        print a
</FILENAME></SCREEN></BLOCKQUOTE>

	Quindi il risultato dell'esecuzione:

<BLOCKQUOTE><SCREEN><FILENAME>
1
2
3
4
5
6
7
8
9
10
</FILENAME></SCREEN></BLOCKQUOTE>

Cosa fa il programma? Prima di tutto vede la linea
<FILENAME>'a = 0' </FILENAME>e assegna il valore
zero alla variabile numerica <FILENAME>a</FILENAME>.
Dopodiché vede il comando
<FILENAME>'while a < 10:'</FILENAME> che
ordina a Python di controllare se la variabile
<FILENAME>a</FILENAME> è minore di 10: in questo caso
<FILENAME>a</FILENAME> corrisponde al valore zero quindi
è minore di 10, per questo motivo Python
eseguirà tutte le istruzioni rientrate sotto la struttura
<FILENAME>'while'</FILENAME>. In poche
parole finché la variabile numerica <FILENAME>a</FILENAME>
 è minore di dieci Python esegue tutte le
istruzioni tabulate sotto <FILENAME>while</FILENAME>.
</PARA><PARA>
	Ecco un'altro esempio dell'uso di <FILENAME>while</FILENAME>:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

	Appena eseguito questo script l'output è stato questo:

<BLOCKQUOTE><SCREEN><FILENAME>

  File "sum.py", line 3
    while a != 0
                ^
SyntaxError: invalid syntax

</FILENAME></SCREEN></BLOCKQUOTE>

	Ho dimenticato il ':' dopo il while. Python avverte dell'errore e mostra
	all'utente dov'è il problema segnando la linea di codice incriminata con un
	utile <FILENAME>^</FILENAME>. Dopo aver risolto il problema grazie
	all'aiuto di Python il programma
	funziona a meraviglia ed ecco finalmente il risultato:

<BLOCKQUOTE><SCREEN><FILENAME>

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
</FILENAME></SCREEN></BLOCKQUOTE>

	Come puoi vedere <FILENAME>'print 'Total sum =', s'</FILENAME>
	è eseguito solamente alla fine: questo
	perché la struttura di controllo <FILENAME>'while'</FILENAME>
	influisce solamente sulle istruzioni
	tabulate (rientrate, indentate). Il simbolo
	<FILENAME>!= </FILENAME>significa diverso:
	finché <FILENAME>a</FILENAME> è
	diverso da zero esegui le istruzioni tabulate sotto
	<FILENAME>while</FILENAME>.
</PARA><PARA>
	Ora che abbiamo capito la struttura di controllo
	<FILENAME>'while'</FILENAME> possiamo programmare
	uno script che venga eseguito all'infinito. Una via molto
	facile per farlo è ad esempio questa:

<BLOCKQUOTE><SCREEN><FILENAME>
while 1 == 1:
     print "Help, I'm stuck in a loop."
</FILENAME></SCREEN></BLOCKQUOTE>

	L'output di questo programma sarà una continua
	ripetizione della frase
	<FILENAME>'Help, I'm stuck in a loop !!! ' </FILENAME>
	all'infinito, a meno che non lo fermiate premendo i
	tasti '<FILENAME>Ctrl</FILENAME>' e
	'<FILENAME>C</FILENAME>' contemporaneamente. Questo
	manderà un segnale di terminazione al programma.

</PARA><PARA>
	(Nota: a volte dovrete premere Invio oltre
	a '<FILENAME>Ctrl+c</FILENAME>')
</PARA>

</SECT1>










<SECT1 ID="C4.2" XREFLABEL="4.2">
<TITLE>Esempi</TITLE>

<PARA>
	fibonacci.py

<BLOCKQUOTE><SCREEN><FILENAME>
#This program calulates the fibonnaci sequence
a = 0
b = 1
count = 0
max_count = 20
while count &lt; max_count:
    count = count + 1
    #we need to keep track of a since we change it
    old_a = a
    a = b
    b = old_a + b
    #Notice that the , at the end of a print statement keeps it
    # from switching to a new line
    print old_a,
print
</FILENAME></SCREEN></BLOCKQUOTE>

	Output:

<BLOCKQUOTE><SCREEN><FILENAME>
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
</FILENAME></SCREEN></BLOCKQUOTE>

	password.py

<BLOCKQUOTE><SCREEN><FILENAME>
# Waits until a password has been entered.  Use control-C to break out with out
# the password

password = "foobar"

#note that != means not equal
while password != "unicorn":
    password = raw_input("Password:")
print "Welcome in"
</FILENAME></SCREEN></BLOCKQUOTE>

	Esecuzione:

<BLOCKQUOTE><SCREEN><FILENAME>
Password:auo
Password:y22
Password:password
Password:open sesame
Password:unicorn
Welcome in
</FILENAME></SCREEN></BLOCKQUOTE>

</PARA>

</SECT1>

</CHAPTER>
















<CHAPTER ID="C5">
<TITLE>Decisioni</TITLE>




<SECT1 ID="C5.1" XREFLABEL="5.1">
<TITLE>L'espressione If</TITLE>
<PARA>
Credo sia meglio partire con un esempio a caldo: ecco quindi
un programma che calcola il valore assoluto di un numero:

<BLOCKQUOTE><SCREEN><FILENAME>
n = input("Number? ")
if n < 0:
        print "The absolute value of",n,"is",-n
else:
        print "The absolute value of",n,"is",n
</FILENAME></SCREEN></BLOCKQUOTE>

Output di due esecuzioni:

<BLOCKQUOTE><SCREEN><FILENAME>
Number? -34
The absolute value of -34 is 34

Number? 1
The absolute value of 1 is 1
</FILENAME></SCREEN></BLOCKQUOTE>

	Quindi cosa fa Python quando esegue questo programma? Prima
	di tutto chiede all'utente un numero grazie alla linea
	<FILENAME>'n = input ("Number? ")'</FILENAME>
	dopodiché legge la linea <FILENAME>'if n < 0':</FILENAME> se
	<FILENAME>n</FILENAME> è minore di zero Python esegue la
	linea <FILENAME>'print "The absolute value of ",
	n, " is ", -n'</FILENAME> altrimenti, cioè se il
	numero è maggiore di zero, esegue la linea
	<FILENAME>"print "The absolute value of ", n,
	"is ", n'</FILENAME>.
</PARA><PARA>
	Più facilmente Python decide se l'affermazione
	<FILENAME>n < 0</FILENAME> è vera o falsa. Una
	espressione <FILENAME>if</FILENAME> è sempre seguita da un blocco di
	altre espressioni tabulate che
	vengono eseguite nel caso l'affermazione sia vera. In caso contrario vengono
	eseguiti i comandi tabulati sotto l'espressione
	<FILENAME>else</FILENAME>, ovvero quando
	l'affermazione <FILENAME>if</FILENAME> risulta falsa.
</PARA><PARA>
	Python presenta svariati operatori associabili al confronto di una variabile:
	eccone una lista completa:

<TABLE>
	<TITLE></TITLE>
	<TGROUP cols="2" align="center">
	<THEAD>
	<ROW>
		<ENTRY>Operatore</ENTRY>
		<ENTRY>Funzione</ENTRY>
	</ROW>
	</THEAD>
	<TBODY>
	<ROW>
		<ENTRY>&lt;</ENTRY>
		<ENTRY>minore di</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>&lt;=</ENTRY>
		<ENTRY>minore o uguale a</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>&gt;</ENTRY>
		<ENTRY>maggiore di</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>&gt;=</ENTRY>
		<ENTRY>maggiore o uguale a</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>==</ENTRY>
		<ENTRY>uguale a</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>!=</ENTRY>
		<ENTRY>diverso da</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>&lt;&gt;</ENTRY>
		<ENTRY>diverso da</ENTRY>
	</ROW>
	</TBODY>
	</TGROUP>
	</TABLE>

	Un'altra proprietà dell'espressione <FILENAME>if </FILENAME>
	è la funzione <FILENAME>elif</FILENAME>.
	<FILENAME>Elif</FILENAME> è
	un'abbreviazione di <FILENAME>else if</FILENAME> e
	significa: esegui il blocco di istruzioni
	tabulato sotto <FILENAME>elif</FILENAME> se la condizione
	necessaria al primo <FILENAME>if</FILENAME> è falsa e la
	condizione di <FILENAME>elif</FILENAME> è vera. Ecco
	un esempio:

<BLOCKQUOTE><SCREEN><FILENAME>
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"
</FILENAME></SCREEN></BLOCKQUOTE>

	Output:

<BLOCKQUOTE><SCREEN><FILENAME>
1  <=  7
2  <=  7
3  <=  7
4  <=  7
5  <=  7
6  >  5
7  >  5
8  >  5
9  >  5
10  >  5
</FILENAME></SCREEN></BLOCKQUOTE>

	Osservate come la linea <FILENAME>'elif a <= 7:'</FILENAME> entri
	in azione solamente quando la prima
	espressione <FILENAME>if</FILENAME> risulta falsa. Come potete
	vedere l'espressione <FILENAME>elif</FILENAME> permette di
	fare test multipli all'interno di una singola espressione
<FILENAME>if</FILENAME>.

</SECT1>











<SECT1 ID="C5.2" XREFLABEL="5.2">
<TITLE>Esempi</TITLE>

<PARA>
	High_low.py

<BLOCKQUOTE><SCREEN><FILENAME>
#Plays the guessing game higher or lower
# (originally written by Josh Cogliati, improved by Quique)

#This should actually be something that is semi random like the
# last digits of the time or something else, but that will have to
# wait till a later chapter.  (Extra Credit, modify it to be random
# after the Modules chapter)
number = 78
guess = 0

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

    if guess > number :
        print "Too high"

    elif guess &lt; number :
            print "Too low"

print "Just right"
</FILENAME></SCREEN></BLOCKQUOTE>

	Esecuzione:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

	even.py

<BLOCKQUOTE><SCREEN><FILENAME>
#Asks for a number.
#Prints if it is even or odd

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."
</FILENAME></SCREEN></BLOCKQUOTE>

	Esecuzione:

<BLOCKQUOTE><SCREEN><FILENAME>
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.
</FILENAME></SCREEN></BLOCKQUOTE>

</PARA>

</SECT1>








<SECT1 ID="C5.3" XREFLABEL="5.3">
<TITLE>Esercizi</TITLE>
<PARA>
	Scrivete un programma che chieda all'utente di indovinare il vostro nome, ma
	che
	dia al giocatore solamente 3 possibilità, fallite le quali il programma
	terminerà.
</PARA><PARA>
	Scrivete un programma che chieda all'utente il nome. Se viene inserito il
	vostro
	nome il programma dovrà rispondere con un apprezzamento, 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 "Che bel
	nome!"
</PARA>

</SECT1>

</CHAPTER>






















<CHAPTER ID="C6">
<TITLE>Debugging</TITLE>




<SECT1 ID="C6.1" XREFLABEL="6.1">
<TITLE>Cos'è il Debugging ?</TITLE>
<PARA></PARA>
<BLOCKQUOTE><ATTRIBUTION>Maurice Wilkes scopre il debugging, 1949</ATTRIBUTION>
<PARA>
	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.
</PARA>
</BLOCKQUOTE>

<PARA>
	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.
</PARA><PARA>
	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 x con una y...
</PARA><PARA>
Questo capitolo sarà più astratto dei precedenti. Vi prego di dirmi se
vi è sembrato utile o meno.
</PARA><PARA>





<SECT1 ID="C6.2" XREFLABEL="6.2">
<TITLE>Cosa dovrebbe fare il programma ?</TITLE>
<PARA>
	La prima cosa da fare (mi sembra ovvio) è pensare a cosa dovrebbe fare il
	programma se fosse corretto.
</PARA><PARA>
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:

<TABLE>
	<TITLE></TITLE>
	<TGROUP cols="3" align="center">
	<THEAD>
	<ROW>
		<ENTRY>Larghezza</ENTRY>
		<ENTRY>Altezza</ENTRY>
		<ENTRY>Perimetro</ENTRY>
	</ROW>
	</THEAD>
	<TBODY>
	<ROW>
		<ENTRY>3</ENTRY>
		<ENTRY>4</ENTRY>
		<ENTRY>14</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>2</ENTRY>
		<ENTRY>3</ENTRY>
		<ENTRY>10</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>4</ENTRY>
		<ENTRY>4</ENTRY>
		<ENTRY>16</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>2</ENTRY>
		<ENTRY>2</ENTRY>
		<ENTRY>8</ENTRY>
	</ROW>
	<ROW>
		<ENTRY>5</ENTRY>
		<ENTRY>1</ENTRY>
		<ENTRY>12</ENTRY>
	</ROW>
	</TBODY>
	</TGROUP>
	</TABLE>

	Ora avvio 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.
</PARA><PARA>
	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:

<BLOCKQUOTE><SCREEN><FILENAME>
Height: 3
Width: 4
perimeter =  15

Height: 2
Width: 3
perimeter =  11

Height: 4
Width: 4
perimeter =  16

Height: 2
Width: 2
perimeter =  8

Height: 5
Width: 1
perimeter =  8
</FILENAME></SCREEN></BLOCKQUOTE>
	Il programma è scorretto 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 è più facile.
</PARA>







<SECT1 ID="C6.3" XREFLABEL="6.3">
<TITLE>Cosa fa il programma ?</TITLE>
<PARA>
	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 analizziamo il codice linea per linea comportandoci
	esattamente come farebbe il programma. Grazie alle strutture di controllo
	infatti 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.
</PARA><PARA>
Iniziamo con il semplice programma per calcolare il perimetro. Non scrivetelo,
dovete leggerlo e basta:

<BLOCKQUOTE><SCREEN><FILENAME>
height = input("Height: ")
width = input("Width: ")
print "perimeter = ",width+height+width+width
</FILENAME></SCREEN></BLOCKQUOTE>

<COMMAND>Domanda: </COMMAND>Qual'è la prima linea che Python esegue ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND><FILENAME>height = input ("Height: ")</FILENAME>.
</PARA><PARA>
<COMMAND>Domanda: </COMMAND>Qual'è il suo effetto ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Stampa <FILENAME>Height:</FILENAME> sullo schermo
e attende l'inserimento di un numero da parte dell'utente per metterlo nella
variabile <FILENAME>height</FILENAME>.
</PARA><PARA>
<COMMAND>Domanda: </COMMAND>Qual'è la prossima linea che Python esegue ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>La linea sotto:
<FILENAME>width = input ("Width: ")</FILENAME>.
</PARA><PARA>
<COMMAND>Domanda: </COMMAND>Cosa provoca nel programma ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Stampa
<FILENAME>Width:</FILENAME> sullo schermo, attende
l'input e assegna il valore immesso alla variabile
<FILENAME>width</FILENAME>.
</PARA><PARA>
<COMMAND>Domanda: </COMMAND>Qual'è la prossima linea ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>
<FILENAME>print "Perimeter = ", width+height+width+width</FILENAME>.
</PARA><PARA>
<COMMAND>Domanda: </COMMAND>ma
<FILENAME>width + height + width + width</FILENAME>
calcola il perimetro correttamente?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Vediamo: il perimetro di un rettangolo si
calcola sommando i lati (uh ?). L'ultimo elemento (width) dovrebbe
essere un lato (height) non la base (width)...
</PARA><PARA>
<COMMAND>Domanda: </COMMAND>Capisci ora perché alcune volte il perimetro
 risultava corretto ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Certo, risultava corretto perché tutti i lati erano
 uguali !!

<SCREEN>
. . . .
</SCREEN>
	Ecco il codice:

<BLOCKQUOTE><SCREEN><FILENAME>
number = 5
while number > 1:
    print ".",
    number = number - 1
print
</FILENAME></SCREEN></BLOCKQUOTE>

Questo programma sarà un po' più complesso, come potete notare
nel codice è presente una struttura
<FILENAME>while</FILENAME>. Bando alle ciance,
rimbocchiamoci le maniche e cominciamo.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Qual'è la prima linea ad essere eseguita ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>La prima linea del file:
<FILENAME>'number = 5'</FILENAME>.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Cosa fa ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Assegna il valore '5' alla variabile
<FILENAME>number</FILENAME>.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Come prosegue ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>La prossima linea è:
<FILENAME>'while number &gt; 1:'</FILENAME>.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Cosa fa ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Allora: la struttura
	<FILENAME>while</FILENAME> verifica che
	l'espressione che la segue
<FILENAME>(number &gt; 1)</FILENAME> sia vera o falsa. Nel primo caso esegue
il codice tabulato sotto, nel secondo caso lo salta per passare al codice
tabulato al suo stesso livello.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Quindi in questo caso come si comporta ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Se la condizione
<FILENAME>'number &gt; 1'</FILENAME> è vera eseguirà le
due righe di codice successive.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>La variabile
<FILENAME>number</FILENAME> allora è maggiore o minore di 1 ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Il valore di
<FILENAME>number</FILENAME> è 5 quindi è maggiore di 1.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Quindi qual'è la prossima linea ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>La linea indentata appena sotto:
<FILENAME>'print ".",'</FILENAME>
finché la condizione <FILENAME>while</FILENAME>
è vera Python eseguirà questa istruzione, ovvero
stamperà un punto e dato che alla fine dell'istruzione compare una
virgola, lo stamperà sulla stessa linea del precedente.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Ed ora come continua il programma ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND><FILENAME>number = number - 1</FILENAME>
visto che è indentata sotto il
<FILENAME>while</FILENAME>.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Cosa fa ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Decrementa la variabile di 1. Quindi
number dopo questa istruzione non risulterà più 4 ma 5.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Ora come continua ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Dato che il livello di tabulazione decrementa
dobbiamo pensare che tipo di struttura di controllo stiamo applicando.
Preso atto che è un ciclo <FILENAME>while</FILENAME> dobbiamo tornare alla linea
<FILENAME>'while number > 1:'</FILENAME>.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Adesso che succede ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Semplice: dopo il riassegnamento della variabile
<FILENAME>number</FILENAME>, che è passata da un valore di 5 a un valore di 4,
bisogna rifare il confronto tra la condizione del
<FILENAME>while</FILENAME> e la variabile.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Il risultato qual'è ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>La condizione <FILENAME>'number &gt; 1'</FILENAME>
è ancora vera quindi il ciclo continua: verranno eseguite per la seconda volta
le istruzioni indentate sotto il <FILENAME>while</FILENAME>.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Ancora <FILENAME>'print ".",'</FILENAME>
e <FILENAME>' number = number - 1'</FILENAME> ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Si :-) Il risultato sarà la stampa di un'altro
 punto
sulla stessa linea del precedente e il decremento di una unità della variabile
<FILENAME>number</FILENAME> che assumerà il valore di 3.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>A questo punto quale sarà la prossima linea ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>finché non ci sarà un cambio di indentazione
causato dalla fine del ciclo la linea sarà sempre
<FILENAME>'while number > 1:'</FILENAME>.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Si ricomincia da capo allora ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Già. Verrà aggiunto un'altro punto sulla
stessa linea dei precedenti e la variabile <FILENAME>number</FILENAME>
verrà decrementata di nuovo. Queste istruzioni verranno eseguite finché
la condizione del <FILENAME>while</FILENAME> non risulterà falsa.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Riassumendo quindi, alla fine di questo
ennesimo ciclo i punti saranno 3 e il valore della variabile
<FILENAME>number</FILENAME> sarà 2.
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Esattamente.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Continuiamo? Se non sbaglio ora dobbiamo
tornare a <FILENAME>'while number &gt; 1:'</FILENAME>.
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Si, dobbiamo tornare ancora alla linea che
inizia il ciclo <FILENAME>while</FILENAME> per confrontare ancora
una volta variabile e condizione del ciclo: dato che 2 è maggiore
di 1 eseguiremo ancora le istruzioni indentate sotto. Alla variabile
<FILENAME>number</FILENAME> verrà assegnato il valore di 1 e i punti
sulla nostra linea diventeranno 4.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Aspetta un secondo: i 4 punti sono il risultato
finale del programma. Cosa significa ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Significa che probabilmente l'errore è qui :-)
Ricominciamo il ciclo: <FILENAME>'while number > 1:'</FILENAME>, ovvero finché
la variabile <FILENAME>number</FILENAME> (che ora corrisponde a 1) è
maggiore di 1... Ecco l'errore! Il ciclo si interrompe qui visto che 1
non è maggiore di 1.
</PARA><PARA>

<COMMAND>Domanda: </COMMAND>Come posso riparare ?
</PARA><PARA>
<COMMAND>Risposta: </COMMAND>Dato che lo scopo del programma è stampare
5 punti e non 4 dobbiamo semplicemente cambiare la condizione del ciclo
<FILENAME>while</FILENAME> sostituendo
<FILENAME>'while number > 1:'</FILENAME> con
<FILENAME>'while number >= 1:'</FILENAME> Questo non è l'unico modo per
eseguire il fix del programma.
</PARA><PARA>

<SECT1 ID="C6.4" XREFLABEL="6.4">
<TITLE>Come riparo il programma ?</TITLE>
<PARA>
Devi capire cosa sta facendo il programma, devi pensare a cosa dovrebbe fare il
programma, confrontare e capire la differenza. Il Debugging si impara grazie
all'esperienza: se non riuscite a trovare dopo un'ora o due il difetto, fate una
pausa e parlatene con qualcuno, quando ci ritornerete sopra avrete nuove idee.
</PARA>


</SECT1>


</CHAPTER>
























<CHAPTER ID="C7">
<TITLE>Le funzioni </TITLE>





<SECT1 ID="C7.1" XREFLABEL="7.1">
<TITLE>Creare funzioni</TITLE>
<PARA>
	Inizierò questo capitolo mostrandovi cosa potreste ma non
	dovreste fare (quindi non scrivete):

<BLOCKQUOTE><SCREEN><FILENAME>
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"
</FILENAME></SCREEN></BLOCKQUOTE>

	L'output sarebbe:

<BLOCKQUOTE><SCREEN><FILENAME>
The absolute values of 23 and 23 are equal
</FILENAME></SCREEN></BLOCKQUOTE>

	Il programma sembra un po' ripetitivo (e i programmatori odiano ripetere le
	cose, i computer servono a quello no ??). Fortunatamente Python permette di
	creare funzioni per rimuovere i duplicati. Ecco l'esempio riscritto:

<BLOCKQUOTE><SCREEN><FILENAME>
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"
</FILENAME></SCREEN></BLOCKQUOTE>

	l'output è:

<BLOCKQUOTE><SCREEN><FILENAME>
The absolute values of 23 and -23 are equal
</FILENAME></SCREEN></BLOCKQUOTE>

	L'elemento chiave di questo programma è l'istruzione
	<FILENAME>def. def</FILENAME> (abbreviazione di
	define, definisci) inizializza la definizione di una funzione.
	<FILENAME>def</FILENAME> è seguita
	dal nome della funzione <FILENAME>abs</FILENAME>. Poi troviamo una
	"(" seguita dal parametro <FILENAME>num</FILENAME> (che
	viene passato dal programma ad ogni chiamata di funzione). Le istruzioni
	dopo il ":" 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. Essa, infatti, finisce quando la
	tabulazione torna al suo livello o quando incontra <FILENAME>return</FILENAME>.
	L'istruzione <FILENAME>return</FILENAME> ritorna un valore dove è stata
	chiamata la funzione.
</PARA><PARA>
	Osservate che i valori <FILENAME>a</FILENAME> e <FILENAME>b</FILENAME>
	non sono cambiati. Le funzioni ovviamente possono
	essere usate anche per ripetere azioni che non ritornano alcun valore.
</PARA><PARA>

Ecco qualche esempio:

<BLOCKQUOTE><SCREEN><FILENAME>
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)
</FILENAME></SCREEN></BLOCKQUOTE>

	L'output è:

<BLOCKQUOTE><SCREEN><FILENAME>
Hello
Hello
Welcome Fred
width = 4 height = 5 area = 20
</FILENAME></SCREEN></BLOCKQUOTE>

</PARA><PARA>
	Questo esempio mostra solamente un po' più in profondità
	in quanti differenti modi si possono applicare le funzioni.
	Osservate attentamente, potete anche non dare argomenti
	ad una funzione così come potete dargliene più d'uno.
	Osservate anche che <FILENAME>return</FILENAME> è opzionale.
</PARA><PARA>
	Le funzioni possono essere usate per eliminare le ripetizioni di codice.
</PARA>

</SECT1>








<SECT1 ID="C7.2" XREFLABEL="7.2">
<TITLE>Esempi</TITLE>
<PARA>
	factorial.py

<BLOCKQUOTE><SCREEN><FILENAME>
#defines a function that calculates the factorial

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)
</FILENAME></SCREEN></BLOCKQUOTE>

	Output:

<BLOCKQUOTE><SCREEN><FILENAME>
2! =  2
3! =  6
4! =  24
5! =  120
</FILENAME></SCREEN></BLOCKQUOTE>

	temperature2.py

<BLOCKQUOTE><SCREEN><FILENAME>
#converts temperature to fahrenheit or 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:")
</FILENAME></SCREEN></BLOCKQUOTE>

	Esecuzione:

<BLOCKQUOTE><SCREEN><FILENAME>
&gt; 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
</FILENAME></SCREEN></BLOCKQUOTE>

	area2.py

<BLOCKQUOTE><SCREEN><FILENAME>
#By 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)
</FILENAME></SCREEN></BLOCKQUOTE>

	Esecuzione:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

</PARA>

</SECT1>








<SECT1 ID="C7.3" XREFLABEL="7.3">
<TITLE>Esercizi</TITLE>
<PARA>
Riscrivete il programma area.py della
sezione <XRef Linkend="AREA"> definendo funzioni separate per l'area del
quadrato, del rettangolo e del cerchio (3.14 * raggio**2).
Create anche un'interfaccia a menu.
</PARA>

</SECT1>


</CHAPTER>


















<CHAPTER ID="C8">
<TITLE>Liste</TITLE>


<SECT1 ID="C8.1" XREFLABEL="8.1">
<TITLE>Variabili con più di un valore</TITLE>
<PARA>
	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:

<BLOCKQUOTE><SCREEN><FILENAME>
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]
</FILENAME></SCREEN></BLOCKQUOTE>

	L'output sarà questo:

<BLOCKQUOTE><SCREEN><FILENAME>
What month (1-12)? 3
The month is March
</FILENAME></SCREEN></BLOCKQUOTE>

	In questo esempio la variabile <FILENAME>months</FILENAME> è una
	<FILENAME>lista</FILENAME>. <FILENAME>months</FILENAME>
	è definita dalla linea
	<FILENAME>
	months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',
	'August', 'September', 'October', 'November', 'December' ] </FILENAME>
	(osserva nel codice
	che \ permette di andare a capo quando la linea di codice è troppo lunga). Le
	parentesi quadrate "[" e "]" iniziano e finiscono la lista e la virgola
	separa un elemento della lista dall'altro. La lista qui descritta viene
	usata nell'istruzione <FILENAME>months [which_one - 1]</FILENAME>
	e consiste in un insieme di elementi
	numerati partendo da 0. In altre parole se volete
	l'elemento <FILENAME>'January'</FILENAME> della
	lista <FILENAME>months</FILENAME> dovete usare
	<FILENAME>months [0]</FILENAME>. Ovvero quando assegnate a una lista un
	numero utilizzando la sintassi appena descritta essa ritornerà l'elemento
	immagazzinato nella locazione corrispondente.
</PARA><PARA>
	L'istruzione <FILENAME>'if 1 <= wich_month <= 12:'</FILENAME>
	sarà vera solo nel caso in cui
	<FILENAME>which_one</FILENAME> sia un numero tra 1 e 12 inclusi.
</PARA><PARA>
	Le liste possono essere pensate come una serie di scatole. Ad esempio le
	scatole
	create da
	<FILENAME>demolist = ['life', 42, 'the universe', 6, 'and', 7]</FILENAME>
	sarebbero all'incirca così:

<TABLE>
	<TITLE></TITLE>
	<TGROUP cols="7" align="left">
 	<THEAD>
	<ROW>
		<ENTRY> box number </ENTRY>
		<ENTRY> 0 </ENTRY>
		<ENTRY> 1 </ENTRY>
		<ENTRY> 2 </ENTRY>
		<ENTRY> 3 </ENTRY>
		<ENTRY> 4 </ENTRY>
		<ENTRY> 5 </ENTRY>
	</ROW>
	</THEAD>
	<TBODY>
	<ROW>
		<ENTRY> demolist </ENTRY>
		<ENTRY> `life' </ENTRY>
		<ENTRY> 42 </ENTRY>
		<ENTRY> `the universe' </ENTRY>
		<ENTRY> 6 </ENTRY>
		<ENTRY> `and' </ENTRY>
		<ENTRY> 7 </ENTRY>
	</ROW>
	</TBODY>
	</TGROUP>
</TABLE>

	Ogni scatola ha un numero di riferimento cosicchè l'istruzione
	<FILENAME>demolist [0]</FILENAME>
	seleziona l'elemento <FILENAME>'life'</FILENAME>
	dalla lista, <FILENAME>demolist [1]</FILENAME>
	l'elemento 42, <FILENAME>demolist[5]</FILENAME>
	l'elemento 7.
</PARA>

</SECT1>







<SECT1 ID="C8.2" XREFLABEL="8.2">
<TITLE>Altre funzioni delle liste</TITLE>
<PARA>
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:

<BLOCKQUOTE><SCREEN><FILENAME>
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]
#Next we will loop through the list
c = 0
while c &lt; 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
</FILENAME></SCREEN></BLOCKQUOTE>

	E questo è l'output:

<BLOCKQUOTE><SCREEN><FILENAME>
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']
</FILENAME></SCREEN></BLOCKQUOTE>

	Questo esempio utilizza moltissime nuove funzioni. Ad esempio
	guardate come potete stampare un'intera lista per poi aggiungere
	nuovi elementi con la funzione
	<FILENAME>append</FILENAME>. <FILENAME>len</FILENAME>
	serve a contare quanti
	elementi sono presenti nella lista: le entrate
	(index) valide di una lista (cioè quelle richiamabili grazie
	a <FILENAME>nome_lista</FILENAME> [numero dell'elemento])
	vanno da 0 a <FILENAME>len - 1</FILENAME>. La funzione
	<FILENAME>index</FILENAME> 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 <FILENAME>demolist.index (42)</FILENAME>
	ritorni il valore 1 e l'istruzione <FILENAME>demolist [1]</FILENAME>
	ritorni il valore 42. La linea <FILENAME>#Next we will loop
	through the list</FILENAME> è un semplice commento usato
	per introdurre le prossime righe di codice:

<BLOCKQUOTE><SCREEN><FILENAME>

c = 0
while c &lt; len(demolist):
    print 'demolist[',c,']=',demolist[c]
    c = c + 1
</FILENAME></SCREEN></BLOCKQUOTE>

	crea una variabile <FILENAME>c</FILENAME>
	inizialmente di valore 0
	che viene incrementata finché non raggiunge l'ultimo
	elemento della lista. Nel frattempo l'istruzione
	<FILENAME>print</FILENAME> stampa ogni elemento della lista.
</PARA><PARA>
	L'istruzione <FILENAME>del</FILENAME> può essere usata per rimuovere
	un elemento dalla lista. Le linee successive utilizzano l'operatore
	<FILENAME>index</FILENAME> per sapere se un elemento è presente o meno nella
	lista.
</PARA><PARA>
	La funzione <FILENAME>sort</FILENAME> ordina la lista ed è utile se avete
	bisogno di una lista ordinata dall'elemento più piccolo a quello più
	grande oppure in ordine alfabetico.
</PARA><PARA>
	Riassumendo possiamo compiere le seguenti operazioni:

<TABLE>
	<TITLE></TITLE>
	<TGROUP cols="2" align="left">
 	<THEAD>
	<ROW>
		<ENTRY> esempio </ENTRY>
		<ENTRY> spiegazione </ENTRY>
	</ROW>
	</THEAD>
	<TBODY>
	<ROW>
		<ENTRY><FILENAME> list[2] </FILENAME></ENTRY>
		<ENTRY> accesso all'elemento 2 dell'indice </ENTRY>
	</ROW>
	<ROW>
		<ENTRY><FILENAME> list[2] = 3 </FILENAME></ENTRY>
		<ENTRY> imposta a 3 l'elemento 2 dell'indice </ENTRY>
	</ROW>
	<ROW>
		<ENTRY><FILENAME> del list[2] </FILENAME></ENTRY>
		<ENTRY> cancella l'elemento 2 dell'indice </ENTRY>
	</ROW>
	<ROW>
		<ENTRY><FILENAME> len(list) </FILENAME></ENTRY>
		<ENTRY> restituisci la lunghezza della lista </ENTRY>
	</ROW>
	<ROW>
		<ENTRY><FILENAME> "value" in list </FILENAME></ENTRY>
		<ENTRY> è vero se "value" è un elemento della lista </ENTRY>
	</ROW>
	<ROW>
		<ENTRY><FILENAME> "value" not in list </FILENAME></ENTRY>
		<ENTRY> è vero se "value" non è un elemento della lista </ENTRY>
	</ROW>
	<ROW>
		<ENTRY><FILENAME> list.sort() </FILENAME></ENTRY>
		<ENTRY> ordina la lista </ENTRY>
	</ROW>
	<ROW>
		<ENTRY><FILENAME> list.index("value") </FILENAME></ENTRY>
		<ENTRY> restituisce l'indice dove viene trovata
		       la prima occorrenza di "value" </ENTRY>
	</ROW>
	<ROW>
		<ENTRY><FILENAME> list.append("value") </FILENAME></ENTRY>
		<ENTRY> aggiunge l'elemento "value" alla fine della lista </ENTRY>
	</ROW>
	</TBODY>
	</TGROUP>
	</TABLE>

	Il prossimo esempio applica queste funzioni per qualcosa di più utile:

<BLOCKQUOTE><SCREEN><FILENAME>
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) &gt; 0:
                        while current &lt; 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]
                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"
</FILENAME></SCREEN></BLOCKQUOTE>

	Ecco una parte dell'output:

<BLOCKQUOTE><SCREEN><FILENAME>
--------------------
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
</FILENAME></SCREEN></BLOCKQUOTE>

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

<BLOCKQUOTE><SCREEN><FILENAME>
current = 0
if len(list) &gt; 0:
        while current &lt; len(list):
                print current,". ",list[current]
                current = current + 1
else:
        print "List is empty"
</FILENAME></SCREEN></BLOCKQUOTE>

	Scorre tutta la lista e visualizza ogni suo elemento.
	<FILENAME>len(list)</FILENAME> conta quanti elementi sono presenti
	nella lista, se ritorna 0 la lista è vuota.
</PARA><PARA>
	Poche linee più sotto appare l'istruzione
	<FILENAME>list.append(name)</FILENAME> che aggiunge un
	elemento alla fine della lista. Saltate giù di un'altro paio di linee
	e osservate questa sezione di codice:

<BLOCKQUOTE><SCREEN><FILENAME>
item_number = list.index(del_name)
del list[item_number]
</FILENAME></SCREEN></BLOCKQUOTE>

	Qui la funzione <FILENAME>index</FILENAME> viene utilizzata
	per trovare l'indice dell'elemento richiesto per poi utilizzarlo
	nella sua cancellazione. <FILENAME>del list [item_number]</FILENAME>
	viene utilizzato appunto per rimuovere l'elemento.
</PARA><PARA>
	La prossima sezione:

<BLOCKQUOTE><SCREEN><FILENAME>
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"
</FILENAME></SCREEN></BLOCKQUOTE>

	Usa index per trovare l'elemento da modificare e sostituire il vecchio
	valore <FILENAME>(old_name)</FILENAME> con il nuovo
	valore desiderato <FILENAME>(new_name)</FILENAME>.
</PARA>

</SECT1>









<SECT1 ID="C8.3" XREFLABEL="8.3">
<TITLE>Esempi</TITLE>



<PARA>
	test.py

<BLOCKQUOTE><SCREEN><FILENAME>
## This program runs a test of knowledge

true = 1
false = 0

# First get the test questions
# Later this will be modified to use file io.
def get_questions():
    # notice how the data is stored as a list of lists
    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"]]


# This will test a single question
# it takes a single question in
# it returns true if the user typed the correct answer, otherwise false
def check_question(question_and_answer):
    #extract the question and the answer from the list
    question = question_and_answer[0]
    answer = question_and_answer[1]
    # give the question to the user
    given_answer = raw_input(question)
    # compare the user's answer to the testers answer
    if answer == given_answer:
        print "Correct"
        return true
    else:
        print "Incorrect, correct was:",answer
        return false


# This will run through all the questions
def run_test(questions):
    if len(questions) == 0:
        print "No questions were given."
        # the return exits the function
        return
    index = 0
    right = 0
    while index &lt; len(questions):
        #Check the question
        if check_question(questions[index]):
            right = right + 1
        #go to the next question
        index = index + 1
    #notice the order of the computation, first multiply, then divide
    print "You got ",right*100/len(questions),"% right out of",len(questions)

#now lets run the questions
run_test(get_questions())
</FILENAME></SCREEN></BLOCKQUOTE>

	Output:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

</PARA>


</SECT1>











<SECT1 ID="C8.4" XREFLABEL="8.4">
<TITLE>Esercizi</TITLE>
<PARA>
Espandete il programma test.py in modo che abbia un menu
per selezionare le opzioni del test, la lista delle domande e
un'opzione per terminare l'esecuzione. Aggiungete inoltre
un'altra domanda: "What noise does a truly
advanced machine make ?" la risposta sarà "Ping".
</PARA>

</SECT1>



</CHAPTER>































<CHAPTER ID="C9">
<TITLE>Cicli For</TITLE>

<PARA>
	Niente paragrafi, partiamo subito con un esercizio che ovviamente
	dovete provare sui vostri computer :=) :

<BLOCKQUOTE><SCREEN><FILENAME>
onetoten = range(1,11)
for count in onetoten:
        print count
</FILENAME></SCREEN></BLOCKQUOTE>

	L'onnipresente output:

<BLOCKQUOTE><SCREEN><FILENAME>
1
2
3
4
5
6
7
8
9
10
</FILENAME></SCREEN></BLOCKQUOTE>

	L'output è familiare ma il codice è diverso. La prima
	linea utilizza la funzione <FILENAME>range</FILENAME>
	che richiede due argomenti, proprio come nell'esempio:
	<FILENAME>range (inizio, fine)</FILENAME>. inizio è il
	primo numero che viene prodotto mentre fine è maggiore
	di 1 dell'ultimo numero prodotto. Questo programma avrebbe
	anche potuto essere scritto più brevemente:

<BLOCKQUOTE><SCREEN><FILENAME>
for count in range(1,11):
        print count
</FILENAME></SCREEN></BLOCKQUOTE>

	Ecco a voi alcuni esempi per capire meglio il
	funzionamento di <FILENAME>range</FILENAME>:

<BLOCKQUOTE><SCREEN><FILENAME>
&gt;&gt;&gt; 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)
[]
</FILENAME></SCREEN></BLOCKQUOTE>

	Avrete certamente notato la presenza di una nuova struttura
	di controllo, gli esempi infatti usano la struttura
	<FILENAME>for</FILENAME>. La sintassi del controllo
	<FILENAME>for</FILENAME> è: <FILENAME>for variabile nella lista:</FILENAME>.
	La lista viene quindi attraversata dal primo elemento
	all'ultimo e mentre il ciclo <FILENAME>for</FILENAME> compie
	il suo tragitto ogni elemento viene inserito in una variabile.
</PARA><PARA>
	Ecco un'altra dimostrazione:

<BLOCKQUOTE><SCREEN><FILENAME>
demolist = ['life',42, 'the universe', 6,'and',7,'everything']
for item in demolist:
    print "The Current item is:",
    print item
</FILENAME></SCREEN></BLOCKQUOTE>

	Output:

<BLOCKQUOTE><SCREEN><FILENAME>
The output is:
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
</FILENAME></SCREEN></BLOCKQUOTE>

	Osservate come il ciclo <FILENAME>for</FILENAME> scorra tutti
	gli elementi nella lista. (Provate ad esempio a togliere la
	virgola alla fine dell'istruzione <FILENAME>print</FILENAME>
	o a cambiare il testo all'interno della stessa... smanettateci
	un po' insomma :=) ). Quindi, a cosa serve? Beh, serve a
	scorrere uno ad uno tutti gli elementi di una lista e a fare
	qualcosa con ognuno di essi. Per esempio potete sommare
	tutti gli elementi:

<BLOCKQUOTE><SCREEN><FILENAME>
list = [2,4,6,8]
sum = 0
for num in list:
        sum = sum + num
print "The sum is: ",sum
</FILENAME></SCREEN></BLOCKQUOTE>

	L'output sarà semplicemente:

<BLOCKQUOTE><SCREEN><FILENAME>
The sum is: 20
</FILENAME></SCREEN></BLOCKQUOTE>

	Altrimenti potreste scrivere un semplice programma
	per trovare i duplicati in una lista. Ad esempio:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

	Il cui output è ovviamente:

<BLOCKQUOTE><SCREEN><FILENAME>
Duplicate of 7 found
</FILENAME></SCREEN></BLOCKQUOTE>

	Va bene, allora come funziona? Scriviamo il programma in
	modo che ritorni un risultato passaggio per
	passaggio, qualcosa di molto simile al debugging:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

	l'output è cambiato:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

	La ragione per cui ho inserito così
	tanti <FILENAME>print</FILENAME> nel codice è che
	in questo modo riuscite 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
	<FILENAME>print</FILENAME> per individuarlo con più facilità).
</PARA><PARA>
	Il programma inizia con la nostra solita noiosa e vecchia
	lista che ordina 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". Dopo
	questi primi passi viene inizializzata una variabile
	<FILENAME>prev(ious)</FILENAME>. Il primo elemento della
	<FILENAME>lista (0)</FILENAME> viene cancellato perché
	altrimenti sarebbe incorrettamente sembrato un duplicato
	della variabile <FILENAME>prev</FILENAME>. La linea
	successiva, come potete vedere, è un ciclo
	<FILENAME>for</FILENAME>. 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
	<FILENAME>prev</FILENAME> e confrontando quest'ultima con
	l'elemento corrente. <FILENAME>prev</FILENAME> 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.
</PARA><PARA>
	Osservate anche come viene utilizzato /t per
	stampare una tabulazione.
</PARA><PARA>
	Un'altro modo per utilizzare un ciclo
	<FILENAME>for</FILENAME> è ripetere la
	stessa azione un deterninato numero di
	volte. Ecco il codice per visualizzare
	i primi 11 numeri della serie di Fibonacci:

<BLOCKQUOTE><SCREEN><FILENAME>
a = 1
b = 1
for c in range(1,10):
        print a,
        n = a + b
        a = b
        b = n
</FILENAME></SCREEN></BLOCKQUOTE>

	con il sorprendente output:
</PARA><PARA>
	1 1 2 3 5 8 13 21 34
</PARA><PARA>
	Tutto quello che potete fare con i cicli
	<FILENAME>for</FILENAME> potete farlo anche con
	<FILENAME>while</FILENAME> ma grazie ai cicli
	<FILENAME>for</FILENAME> è più semplice scorrere
	tra tutti gli elementi di una lista o compiere
	un'azione un determinato numero di volte.
</PARA>


</CHAPTER>



















<CHAPTER ID="C10">
<TITLE>Espressioni Booleane</TITLE>




<PARA>
	Ecco un piccolo esempio di espressioni booleane (non dovete scriverli):

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

	Questo l'immancabile output:

<BLOCKQUOTE><SCREEN><FILENAME>
1 1
2 0
3 1
4 0
5 1
6 1
7 0
8 1
9 0
</FILENAME></SCREEN></BLOCKQUOTE>

	Cosa succede ? Il programma consiste in una serie di istruzioni
	<FILENAME>print</FILENAME>; ogni istruzione
	<FILENAME>print</FILENAME> 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). Le linee:

<BLOCKQUOTE><SCREEN><FILENAME>
print 1, a == 6
print 2, a == 7
</FILENAME></SCREEN></BLOCKQUOTE>

	restituiscono infatti vero e falso, esattamente come
	dovrebbero fare finché la prima affermazione è vera e
	la seconda è falsa. La terza istruzione
	<FILENAME>print</FILENAME> è un po' diversa:
	<FILENAME>print 3, a == 6 and b == 7</FILENAME>. L'operatore
	<FILENAME>and</FILENAME> significa se entrambe le affermazioni
	prima e dopo l'operatore logico <FILENAME>and</FILENAME>
	sono vere tutta l'espressione è vera altrimenti tutta
	l'espressione è falsa. L'espressione successiva,
	<FILENAME>print 4, a == 7 and b == 7</FILENAME>, dimostra
	che se una parte dell'espressione <FILENAME>and</FILENAME> è
	falsa tutta l'espressione sarà falsa. Il significato di
	<FILENAME>and</FILENAME> può essere riassunto come segue:

<TABLE>
	<TITLE></TITLE>
	<TGROUP cols="2" align="left">
	<THEAD>
	<ROW>
		<ENTRY> espressione</ENTRY>
		<ENTRY> risultato</ENTRY>
	</ROW>
	</THEAD>
	<TBODY>
	<ROW>
		<ENTRY> vero<FILENAME> and </FILENAME>vero       </ENTRY>
		<ENTRY> vero </ENTRY>
	</ROW>
	<ROW>
		<ENTRY> vero<FILENAME> and </FILENAME>falso</ENTRY>
		<ENTRY> falso </ENTRY>
	</ROW>
	<ROW>
		<ENTRY> falso<FILENAME> and </FILENAME>vero</ENTRY>
		<ENTRY> falso</ENTRY>
	</ROW>
	<ROW>
		<ENTRY> falso<FILENAME> and </FILENAME>falso</ENTRY>
		<ENTRY> falso</ENTRY>
	</ROW>
	</TBODY>
	</TGROUP>
	</TABLE>

	Potete notare che se la prima espressione è falsa Python
	non esegue un check sulla seconda espressione perché
	sa già che tutta l'espressione è falsa.
</PARA><PARA>
	La linea successiva,
	<FILENAME>print 5, not a == 7 and b == 7</FILENAME>,
	utilizza l'operatore <FILENAME>not</FILENAME>
	che restituisce semplicemente
	l'opposto dell'espressione.
</PARA><PARA>
	L'espressione può infatti essere riscritta semplicemente
	come <FILENAME>print 5, a != 7 and b == 7</FILENAME>.
	Questa è la tabella:

<TABLE>
	<TITLE></TITLE>
	<TGROUP cols="2" align="left">
	<THEAD>
	<ROW>
		<ENTRY> espressione</ENTRY>
		<ENTRY> risultato</ENTRY>
	</ROW>
	</THEAD>
	<TBODY>
	<ROW>
		<ENTRY><FILENAME> not </FILENAME>vero</ENTRY>
		<ENTRY> falso</ENTRY>
	</ROW>
	<ROW>
		<ENTRY><FILENAME> not </FILENAME>falso</ENTRY>
		<ENTRY> vero</ENTRY>
	</ROW>
	</TBODY>
	</TGROUP>
	</TABLE>

	Le due linee seguenti,
	<FILENAME>print 6, a == 7 or b == 7</FILENAME> e
	<FILENAME>print 7, a == 7 or b == 6</FILENAME>,
	utilizzano l'operatore logico <FILENAME>or</FILENAME>
	che ritorna vero se una delle
	affermazioni (o entrambe) è vera.

<TABLE>
	<TITLE></TITLE>
	<TGROUP cols="2" align="left">
	<THEAD>
	<ROW>
		<ENTRY> espressione</ENTRY>
		<ENTRY> risultato</ENTRY>
	</ROW>
	</THEAD>
	<TBODY>
	<ROW>
		<ENTRY> vero<FILENAME> or </FILENAME>vero</ENTRY>
		<ENTRY> vero</ENTRY>
	</ROW>
	<ROW>
		<ENTRY> vero<FILENAME> or </FILENAME>falso</ENTRY>
		<ENTRY> vero</ENTRY>
	</ROW>
	<ROW>
		<ENTRY> falso<FILENAME> or </FILENAME>vero</ENTRY>
		<ENTRY> vero</ENTRY>
	</ROW>
	<ROW>
		<ENTRY> falso<FILENAME> or </FILENAME>falso</ENTRY>
		<ENTRY> falso</ENTRY>
	</ROW>
	</TBODY>
	</TGROUP>
	</TABLE>

	Anche qui Python non esegue il check sulla seconda espressione
	se riconosce la prima come vera dato che anche se la seconda
	affermazione risultasse falsa l'intera espressione sarebbe comunque vera.
</PARA><PARA>
	Le ultime due linee,
	<FILENAME>print 8, not (a == 7 and b == 6)</FILENAME> e
	<FILENAME>print 9, not a == 7 and b == 6</FILENAME>,
	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
	<FILENAME>not</FILENAME> a valutare l'intera
	espressione anziché solamente <FILENAME>a == 7</FILENAME>.
</PARA><PARA>
	Ecco un esempio dell'utilizzo delle espressioni booleane:

<BLOCKQUOTE><SCREEN><FILENAME>
list = ["Life","The Universe","Everything","Jack","Jill","Life","Jill"]

#make a copy of the list
copy = list[:]
#sort the copy
copy.sort()
prev = copy[0]
del copy[0]

count = 0

#go through the list searching for a match
while count &lt; len(copy) and copy[count] != prev:
    prev = copy[count]
    count = count + 1

#If a match was not found then count can't be &lt; len
#since the while loop continues while count is &lt; len
#and no match is found
if count &lt; len(copy):
    print "First Match: ",prev
</FILENAME></SCREEN></BLOCKQUOTE>

	Ecco l'output:

<BLOCKQUOTE><SCREEN><FILENAME>
First Match:  Jill
</FILENAME></SCREEN></BLOCKQUOTE>

	Questo programma continua a scorrere la lista cercando duplicati
	<FILENAME>while count &lt; (len (copy) and copy [count])</FILENAME>.
	Quando uno dei due contatori è più grande dell'ultimo indice di
	<FILENAME>copy</FILENAME> o viene trovato un duplicato, l'operatore
	<FILENAME>and</FILENAME> non risulta più vero e si esce dal ciclo.
	<FILENAME>if</FILENAME> si occupa semplicemente di accertarsi che
	l'uscita dal ciclo sia dovuta alla presenza di un duplicato.
</PARA><PARA>
	Nell'esempio viene utilizzato un'altro 'trucco' dell'operatore
	<FILENAME>and</FILENAME>. Se guardate la tabella di
	<FILENAME>and</FILENAME> potete osservare che la terza
	espressione è falsa senza che Python esegua un check
	sul secondo elemento.
	Se <FILENAME>count >= len (copy)</FILENAME>
	(in altre parole <FILENAME>count &lt; len (copy)</FILENAME>
	è falsa) allora
	<FILENAME>copy[count]</FILENAME> 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'<FILENAME>and</FILENAME> causa un errore.
	Ho usato la prima espressione
	<FILENAME>(count &lt; len(copy))</FILENAME> per
	eseguire un check su <FILENAME>count</FILENAME> e
	controllare se <FILENAME>count</FILENAME> 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
	<FILENAME>count &lt; len(copy) and copy[count] !=
	prev con copy[count] != prev and count &lt; len(copy))</FILENAME>.
</PARA><PARA>
	Le espressioni booleane possono essere usate quando
	avete bisogno di verificare due
	o più elementi in una volta.
</PARA>




<SECT1 ID="C10.1" XREFLABEL="10.1">
<TITLE>Esempi</TITLE>
<PARA>
	password1.py

<BLOCKQUOTE><SCREEN><FILENAME>
## Questo programma chiede all'utente uno username e una password
#  dopodiché verifica se l'utente è autenticato

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."
</FILENAME></SCREEN></BLOCKQUOTE>

	Semplice esecuzione:

<BLOCKQUOTE><SCREEN><FILENAME>
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.
</FILENAME></SCREEN></BLOCKQUOTE>

</PARA>

</SECT1>









<SECT1 ID="C10.2" XREFLABEL="10.2">
<TITLE>Esercizi</TITLE>
<PARA>

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

</PARA>

</SECT1>



</CHAPTER>




















<CHAPTER ID="C11">
<TITLE>Dizionari</TITLE>


<PARA>
	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:

<BLOCKQUOTE><SCREEN><FILENAME>
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()
</FILENAME></SCREEN></BLOCKQUOTE>

	Ecco l'output:

<BLOCKQUOTE><SCREEN><FILENAME>
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:  Fred     Number:  132-9874
Name:  Joe      Number:  545-4464
Name:  Jill     Number:  979-4654

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:  Joe      Number:  545-4464
Name:  Jill     Number:  979-4654

Type in a number (1-5):5
</FILENAME></SCREEN></BLOCKQUOTE>

	Questo programma è simile a quello con la lista di nomi nel capitolo sulle
	liste. Ecco come funziona il programma.
	Innanzitutto viene definita la funzione <FILENAME>print_menu</FILENAME>
	che visualizza sullo schermo
	un menu più volte usato nel programma.
	A questo punto compare la linea <FILENAME>numbers = {}</FILENAME>
	che dichiara <FILENAME>numbers</FILENAME> come un
	dizionario. Le linee seguenti fanno funzionare
	il menu:

<BLOCKQUOTE><SCREEN><FILENAME>
for x in numbers.keys():
    print "Name: ",x," \tNumber: ",numbers[x]
</FILENAME></SCREEN></BLOCKQUOTE>

	Grazie a questo ciclo si possono visualizzare le informazioni
	contenute nel dizionario. La funzione
	<FILENAME>number.keys()</FILENAME> restituisce
	una lista che viene poi utilizzata dal ciclo
	<FILENAME>for</FILENAME>. Questa lista non è in nessun
	ordine particolare quindi se la volete in
	ordine alfabetico essa deve essere ordinata. Con la notazione
	<FILENAME>numbers[x]</FILENAME> possiamo accedere ai
	singoli membri del dizionario:
	ovviamente in questo caso <FILENAME>x</FILENAME>
	è una stringa. Successivamente la linea
	<FILENAME>numbers[name] = phone</FILENAME>
	aggiunge un nome e un numero di telefono
	al dizionario. Se <FILENAME>name</FILENAME>
	è stato già inserito nel dizionario
	<FILENAME>phone</FILENAME>, rimpiazza il
	valore precedente.
	Le linee:

<BLOCKQUOTE><SCREEN><FILENAME>
if numbers.has_key(name):
    del numbers[name]
</FILENAME></SCREEN></BLOCKQUOTE>

	Controllano se una chiave è già presente nel dizionario, in tal caso la
	rimuovono. La funzione <FILENAME>numbers.has_key(name)</FILENAME>
	ritorna vero
	se <FILENAME>name</FILENAME> è presente in
	<FILENAME>numbers</FILENAME> altrimenti ritorna falso. La linea 
	<FILENAME>del numbers[name]</FILENAME> rimuove la chiave
	<FILENAME>[name]</FILENAME> e il valore ad essa
	associato.
	Le linee:

<BLOCKQUOTE><SCREEN><FILENAME>
if numbers.has_key(name):
    print "The number is",numbers[name]
</FILENAME></SCREEN></BLOCKQUOTE>

	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 rivisualizza il menu.

</PARA><PARA>

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 (i quali
possono contenere a loro volta dizionari e liste
(paura eh? :=) )). Questo è un esempio che utilizza una lista in un dizionario:

<BLOCKQUOTE><SCREEN><FILENAME>
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"


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)


def print_grades(grades):
    for i in range(len(grades)):
        print grades[i],'\t\t',
    print



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 &lt;= which &lt; 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()
</FILENAME></SCREEN></BLOCKQUOTE>

E questo è l'output:

<BLOCKQUOTE><SCREEN><FILENAME>
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


Menu Choice (1-6):1
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


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


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
</FILENAME></SCREEN></BLOCKQUOTE>

La variabile <FILENAME>students</FILENAME>
è un dizionario le cui chiavi sono i nomi degli studenti e
i valori, i voti degli studenti. Le prime due linee
creano semplicemente due liste. La linea successiva
<FILENAME>students = {'#Max':max_points}</FILENAME>
crea un nuovo dizionario la cui chiave è
<FILENAME>#Max</FILENAME>
e il valore [25,25,50,25,100] (è il valore di
<FILENAME>max_points</FILENAME> nel momento in cui il
valore viene assegnato; viene usata la chiave
<FILENAME>#Max</FILENAME> perché " # " è
sempre ordinato sopra i caratteri alfabetici).
Quindi viene definita la funzione
<FILENAME>print_menu</FILENAME>.
Le linee:

<BLOCKQUOTE><SCREEN><FILENAME>
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)
</FILENAME></SCREEN></BLOCKQUOTE>

	definiscono la funzione
	<FILENAME>print_all_grades</FILENAME>.

</PARA><PARA>
Notate come le chiavi vengano innanzitutto estratte dal dizionario
<FILENAME>students</FILENAME> con
la funzione di <FILENAME>keys</FILENAME> contenuta nella linea:
<FILENAME>keys = students.keys()</FILENAME> . <FILENAME>keys</FILENAME>
è una lista, quindi possono essere usate tutte le funzioni
delle liste. Successivamente vengono ordinate le chiavi nella
linea <FILENAME>keys.sort()</FILENAME> e viene utilizzato
un ciclo <FILENAME>for</FILENAME> per scorrere tutte le chiavi.
I voti sono immagazzinati come una lista all'interno
del dizionario in modo che l'assegnamento
<FILENAME>grades = students[x]</FILENAME> assegni a
<FILENAME>grades</FILENAME>
la lista immagazzinata nella chiave <FILENAME>x</FILENAME>. La funzione
<FILENAME>print_grades</FILENAME> visualizza semplicemente una lista ed
è definita poche linee sotto.

</PARA><PARA>

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

</PARA><PARA>

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

</PARA>



</CHAPTER>



















<CHAPTER ID="C12">
<TITLE>Usare i moduli</TITLE>

<PARA>
Questo è l'esercizio del capitolo (chiamatelo cal.py): <FOOTNOTE>

<PARA>

	Import cerca un file di nome
	<FILENAME>calendar.py</FILENAME> e lo legge.
	Se il file chiamante si chiama
	<FILENAME>calendar.py</FILENAME> e contiene
	<FILENAME>'import calendar'</FILENAME>  cerca di
	leggere in se stesso con risultati quantomeno scarsi.

</PARA>
</FOOTNOTE>

<BLOCKQUOTE><SCREEN><FILENAME>
import calendar

year = input("Type in the year number:")
calendar.prcal(year)
 And here is part of the output I got:
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
</FILENAME></SCREEN></BLOCKQUOTE>

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

<BLOCKQUOTE><SCREEN><FILENAME>
from calendar import prcal

year = input("Type in the year number:")
prcal(year)
</FILENAME></SCREEN></BLOCKQUOTE>

Questa versione importa una specifica funzione dal modulo.
Creiamo un'altro programma utilizzando le funzioni della Python Library (chiamate il file
<FILENAME>clock.py</FILENAME>)(premete 'ctrl' e 'c' per chiudere il programma):

<BLOCKQUOTE><SCREEN><FILENAME>
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
 With some output being:
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
</FILENAME></SCREEN></BLOCKQUOTE>

	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 <FILENAME>'from time import
	time, ctime'</FILENAME> per richiamare più di una funzione.

</PARA><PARA>
	La Python Library contiene molte funzioni utili
	che semplificano la  programmazione in Python.
</PARA><PARA>




<SECT1 ID="C12.1" XREFLABEL="12.1">
<TITLE>Esercizio</TITLE>
<PARA>
	Riscrivete il programma <FILENAME>high_low.py</FILENAME>
	della sezione <XRef Linkend="C5.2"> usando le ultime due
	cifre della funzione time per rendere il numero 'random'
	(casuale).
</PARA>


</CHAPTER>


















<CHAPTER ID="C13">
<TITLE>Ancora sulle liste</TITLE>

<PARA>
	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 analizzeremo
	un metodo per copiarle.
</PARA><PARA>
	Questi sono alcuni esempi dell'utilizzo degli
	indici per accedere ai singoli elementi di una
	lista:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> list = ['zero','one','two','three','four','five']
>>> list[0]
'zero'
>>> list[4]
'four'
>>> list[5]
'five'
</FILENAME></SCREEN></BLOCKQUOTE>
	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
	<FILENAME>len</FILENAME>
	all'interno delle parentesi quadre:
	<FILENAME>list[len(list)-1]</FILENAME>.
	<FILENAME>len</FILENAME>
	ritorna sempre l'ultimo indice + 1. Nello
	stesso modo l'istruzione
	per avere il penultimo elemento della lista sarà
	<FILENAME>list[len(list)-2]</FILENAME>.
	Esiste una via più
	semplice: in Python l'ultimo elemento è sempre
	indicizzato come -1, il penultimo come -2 e
	così via. Ecco un'esempio:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> list[len(list)-1]
'five'
>>> list[len(list)-2]
'four'
>>> list[-1]
'five'
>>> list[-2]
'four'
>>> list[-6]
'zero'
</FILENAME></SCREEN></BLOCKQUOTE>
	Così ogni elemento in una lista può essere
	indicizzato in due modi differenti, dall'inizio
	della lista e dalla fine della lista.
</PARA><PARA>
	Un'altra via molto utile per estrarre elementi
	da una lista sono le sezioni. Ecco un'altro
	esempio:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> 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']
</FILENAME></SCREEN></BLOCKQUOTE>

	Le sezioni sono utilizzate per estrarre parti di
	liste. La sintassi per estrarre sezioni è
	<FILENAME>list[primo_indice:ultimo_indice]</FILENAME>.
	La sezione selezionata va da
	<FILENAME>primo_indice</FILENAME> all'indice prima
	di <FILENAME>ultimo_indice</FILENAME>.
	E' possibile utilizzare entrambi i
	metodi di indicizzazione:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> list[-4:-2]
['Stocking', 42]
>>> list[-4]
'Stocking'
>>> list[-4:6]
['Stocking', 42]
</FILENAME></SCREEN></BLOCKQUOTE>

	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:
	Ecco un'altro esempio:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> list[:2]
[0, 'Fred']
>>> list[-2:]
['Jack', 'Jill']
>>> list[:3]
[0, 'Fred', 2]
>>> list[:-5]
[0, 'Fred', 2]
</FILENAME></SCREEN></BLOCKQUOTE>

	Ancora un'altro programma d'esempio:

<BLOCKQUOTE><SCREEN><FILENAME>
poem = \
["&lt;B>","Jack","and","Jill","&lt;/B>","went","up","the","hill","to","&lt;B>",\
"fetch","a","pail","of","&lt;/B>","water.","Jack","fell","&lt;B>","down","and",\
"broke","&lt;/B>","his","crown","and","&lt;B>","Jill","came","&lt;/B>","tumbling",\
"after"]

def get_bolds(list):
        true = 1
        false = 0
        ## is_bold tells whether or not the we are currently looking at
        ## a bold section of text.
        is_bold = false
        ## start_block is the index of the start of either an unbolded
        ## segment of text or a bolded segment.
        start_block = 0
        for index in range(len(list)):
                ##Handle a starting of bold text
                if list[index] == "&lt;B>":
                        if is_bold:
                                print "Error:  Extra Bold"
                        ##print "Not Bold:",list[start_block:index]
                        is_bold = true
                        start_block = index+1
                ##Handle end of bold text
                if list[index] == "&lt;/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)
</FILENAME></SCREEN></BLOCKQUOTE>

	E questo è l'output:

<BLOCKQUOTE><SCREEN><FILENAME>
Bold [ 1 : 4 ]  ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ]  ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ]  ['down', 'and', 'broke']
Bold [ 28 : 30 ]  ['Jill', 'came']
</FILENAME></SCREEN></BLOCKQUOTE>

	La funzione <FILENAME>get_bold</FILENAME>
	scorre per una lista dividendola
	in parole e chiamate. Le chiamate che
	cerca sono <FILENAME>&lt;B></FILENAME>
	che inizia il testo in
	grassetto e <FILENAME>&lt;\B></FILENAME>
	che lo termina.

</PARA><PARA>
La prossima funzione delle liste è copiarle:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> a = [1,2,3]
>>> b = a
>>> print b
[1, 2, 3]
>>> b[1] = 10
>>> print b
[1, 10, 3]
>>> print a
[1, 10, 3]
</FILENAME></SCREEN></BLOCKQUOTE>

	Questo è probabilmente sorprendente in quanto una modifica a
	<FILENAME>b</FILENAME> modifica anche <FILENAME>a</FILENAME>.
	Questo grazie all'istruzione <FILENAME>b = a</FILENAME>
	che restituisce <FILENAME>b</FILENAME> come
	<EMPHASIS>riferimento</EMPHASIS> ad
	<FILENAME>a</FILENAME>. Significa che
	<FILENAME>b</FILENAME> non è
	altro che un'altro nome per riferirsi ad <FILENAME>a</FILENAME>,
	il risultato è che una modifica a <FILENAME>b</FILENAME> è una
	modifica ad <FILENAME>a</FILENAME>.
	Ciò nonostante alcune tipologie di assegnamento non
	significano la creazione di un doppio riferimento:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> 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]
</FILENAME></SCREEN></BLOCKQUOTE>

	In questo caso <FILENAME>b</FILENAME> non è un riferimento ad
	<FILENAME>a</FILENAME> in quanto l'istruzione
	<FILENAME>a*2</FILENAME> crea una nuova lista;
	<FILENAME>b</FILENAME>
	quindi si riferisce ad <FILENAME>a*2</FILENAME>
	e non ad <FILENAME>a</FILENAME>.
	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.
	Ciò nonostante, 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:


<BLOCKQUOTE><SCREEN><FILENAME>
>>> a = [1,2,3]
>>> b = a[:]
>>> b[1] = 10
>>> print a
[1, 2, 3]
>>> print b
[1, 10, 3]
</FILENAME></SCREEN></BLOCKQUOTE>

	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
	<FILENAME>deepcopy</FILENAME> del
	modulo <FILENAME>copy</FILENAME> :

<BLOCKQUOTE><SCREEN><FILENAME>
>>> 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]]
</FILENAME></SCREEN></BLOCKQUOTE>

	Innanzitutto notate che <FILENAME>a</FILENAME>
	è una lista di liste.
	L'istruzione <FILENAME>b[0][1] = 10</FILENAME>
	cambia sia la lista
	<FILENAME>b</FILENAME> che la lista
	<FILENAME>a</FILENAME>, <FILENAME>c</FILENAME>
	invece resta uguale. Questo accade perché
	<FILENAME>b</FILENAME> continua ad essere un
	riferimento ad <FILENAME>a</FILENAME>
	se vengono utilizzate le sezioni;
	<FILENAME>c</FILENAME> invece è una copia
	ottenuta grazie alla funzione
	<FILENAME>deepcopy</FILENAME>.


<PARA>

	Dovrete preoccuparvi 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.

</PARA><PARA>

	Adesso vi starete probabilmente chiedendo
	perché vengono usati i riferimenti. La ragione
	basilare è per la loro velocità. E' molto più veloce
	fare un riferimento a 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.
	Tenetene quindi conto se vi troverete ad avere strani
	errori in relazione a dati modificati
	quando quest'ultimi non avrebbero dovuto
	subire alcun cambiamento.

</PARA>

</CHAPTER>


















<CHAPTER ID="C14">
<TITLE>La vendetta delle stringhe</TITLE>

<PARA>
	Ora presenteremo un trucco che può
	essere usato con le stringhe:

<BLOCKQUOTE><SCREEN><FILENAME>
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")
</FILENAME></SCREEN></BLOCKQUOTE>

Ecco l'output:

<BLOCKQUOTE><SCREEN><FILENAME>
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
</FILENAME></SCREEN></BLOCKQUOTE>

	Questo programma dimostra che le stringhe sono per alcuni
	aspetti simili alle liste. La procedura
	<FILENAME>shout</FILENAME> dimostra che
	un ciclo <FILENAME>for</FILENAME> può essere usato con le
	stringhe esattamente
	nello stesso modo in cui veniva usato con le liste. La
	procedura <FILENAME>middle</FILENAME> mostra come possa
	essere utilizzata la
	funzione <FILENAME>len</FILENAME> anche con le stringhe,
	così come gli indici e le slice. Molte funzioni delle liste
	funzionano con le stringhe.

</PARA><PARA>

	La prossima funzione utilizzerà alcune
	funzioni specifiche delle stringhe:

<BLOCKQUOTE><SCREEN><FILENAME>
def to_upper(string):
    ## Converts a string to upper case
    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")
</FILENAME></SCREEN></BLOCKQUOTE>

Con l'output:

<BLOCKQUOTE><SCREEN><FILENAME>
THIS IS TEXT
</FILENAME></SCREEN></BLOCKQUOTE>

	Il motivo per cui questo codice funziona è che il computer
	"vede" le lettere come numeri da 0 a 255. Python ha una
	funzione <FILENAME>ord</FILENAME> (abbreviazione di
	ordinale) che ritorna un
	carattere come un numero. Esiste anche una funzione
	corrispondente <FILENAME>chr</FILENAME> che converte
	un numero in un carattere.
	Imparate queste funzioni, il programma dovrebbe essere
	chiaro. Il primo dettaglio è la linea:
	<FILENAME>if 'a' <= character <= 'z':</FILENAME> che
	controlla se la lettera è minuscola. La linea:
	<FILENAME>location = ord(character) - ord('a')</FILENAME>
	converte i numeri corrispondenti alle lettere nel codice
	ASCII in numeri da 0 a 36 quindi la linea
	<FILENAME>new_ascii = location + ord('A')</FILENAME>
	converte la lettera minuscola in maiuscola.

</PARA><PARA>
	Un'altro esercizio:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> #Integer to String
...
>>> 2
2
>>> repr(2)
'2'
>>> -123
-123
>>> repr(-123)
'-123'
>>> #String to Integer
...
>>> "23"
'23'
>>> int("23")
23
>>> "23"*2
'2323'
>>> int("23")*2
46
>>> #Float to String
...
>>> 1.23
1.23
>>> repr(1.23)
'1.23'
>>> #Float to Integer
...
>>> 1.23
1.23
>>> int(1.23)
1
>>> int(-1.23)
-1
>>> #String to Float
...
>>> float("1.23")
1.23
>>> "1.23"
'1.23'
>>> float("123")
123.0
</FILENAME></SCREEN></BLOCKQUOTE>

	Se non l'avete ancora indovinato la funzione
	<FILENAME>repr</FILENAME> converte un intero
	in stringa e la funzione <FILENAME>int</FILENAME>
	converte una stringa in intero. La funzione
	<FILENAME>float</FILENAME> converte una stringa
	in un numero in virgola mobile. La funzione
	<FILENAME>repr</FILENAME> ritorna una rappresentazione
	stampabile di qualcosa. Ecco alcuni esempi:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> repr(1)
'1'
>>> repr(234.14)
'234.14'
>>> repr([4,42,10])
'[4, 42, 10]'
</FILENAME></SCREEN></BLOCKQUOTE>

	La funzione <FILENAME>int</FILENAME> prova a convertire
	una stringa (o un numero in virgola mobile) in un intero.
	Esiste anche una funzione simile <FILENAME>float</FILENAME>
	che converte un numero intero in numero in virgola mobile.
	Un'altra funzione di Python è <FILENAME>eval</FILENAME>
	che ritorna il tipo di dato che viene immesso. Per esempio:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> v=eval('123')
>>> print v,type(v)
123 &lt;type 'int'>
>>> v=eval('645.123')
>>> print v,type(v)
645.123 &lt;type 'float'>
>>> v=eval('[1,2,3]')
>>> print v,type(v)
[1, 2, 3] &lt;type 'list'>
</FILENAME></SCREEN></BLOCKQUOTE>

	Se usate la funzione <FILENAME>eval</FILENAME> dovete
	controllare il valore che ritorna per
	assicurarvi che sia quello che vi aspettate.

</PARA><PARA>

	Un'altra funzione utile in <FILENAME>string</FILENAME> è
	la funzione <FILENAME>split</FILENAME>. Questo è un esempio:

<BLOCKQUOTE><SCREEN><FILENAME>
>>> 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']
</FILENAME></SCREEN></BLOCKQUOTE>

	Notate come <FILENAME>split</FILENAME> 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).

</PARA>









<SECT1 ID="C14.1" XREFLABEL="14.1">
<TITLE>Esempi</TITLE>
<PARA>

<BLOCKQUOTE><SCREEN><FILENAME>
#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")
</FILENAME></SCREEN></BLOCKQUOTE>

Ecco l'output:

<BLOCKQUOTE><SCREEN><FILENAME>
2
23445
-23445
14234
12345
-3512
</FILENAME></SCREEN></BLOCKQUOTE>

</PARA>

</SECT1>


</CHAPTER>



















<CHAPTER ID="C15">
<TITLE>File IO</TITLE>

<PARA>
      Questo è un semplice esempio di File IO:

<BLOCKQUOTE><SCREEN><FILENAME>
#Write a 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()

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

print text,
</FILENAME></SCREEN></BLOCKQUOTE>

      L'output e i contenuti del file test.txt sono:


<BLOCKQUOTE><SCREEN><FILENAME>
This Text is going to out file
Look at it and see
</FILENAME></SCREEN></BLOCKQUOTE>
      Osservate come il programma scriva un file chiamato
      <FILENAME>test.txt</FILENAME> nella directory nella
      quale viene eseguito.
      Il <FILENAME>"\n"</FILENAME> nella stringa dice a 
      Python di andare a capo nel punto in cui compare.

<PARA>

      Una panoramica sul file IO:

</PARA>

<ORDEREDLIST numeration="arabic">
	<LISTITEM>
	<PARA>	Aprite un oggetto file con la funzione
		<FILENAME>open </FILENAME></PARA>
	</LISTITEM>
	<LISTITEM>
	<PARA>	Leggete o scrivete nell'oggetto file
		(dipendentemente da come l'avete aperto)</PARA>
	</LISTITEM>
	<LISTITEM>
	<PARA>	Chiudetelo</PARA>
	</LISTITEM>
</ORDEREDLIST>
<PARA>

      Il primo passo è usare un oggetto file grazie alla funzione
      <FILENAME>open</FILENAME>. La sintassi è
      <FILENAME>oggetto_file = open (nome_file, modo) </FILENAME>
      dove <FILENAME>oggetto_file</FILENAME> è la variabile
      contenente l'oggetto file,
      <FILENAME>nome_file</FILENAME> la stringa con il nome
      del file, e <FILENAME>modo</FILENAME> la modalità di 
      apertura del file: 
      <FILENAME>"r"</FILENAME> in lettura, 
      <FILENAME>"w"</FILENAME> in scrittura. Dopodiché 
      potrete chiamare le funzioni dell'oggetto file. Le due 
      funzioni più comuni sono <FILENAME>read</FILENAME> e 
      <FILENAME>write</FILENAME>: la funzione 
      <FILENAME>read</FILENAME> legge 
      il file e ne ritorna il contenuto sottoforma di stringa, la 
      funzione <FILENAME>write</FILENAME> aggiunge una stringa alla 
      fine del file.

</PARA><PARA>

      Questa è una nuova versione dell'agenda telefonica che abbiamo 
      scritto precedentemente:

<BLOCKQUOTE><SCREEN><FILENAME>
import string

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 1:
        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


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"
</FILENAME></SCREEN></BLOCKQUOTE>

      Ora include anche il salvataggio e la lettura di files.

<PARA>

      Output:

</PARA>


<BLOCKQUOTE><SCREEN><FILENAME>
> 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


> 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
</FILENAME></SCREEN></BLOCKQUOTE>
<PARA>
    Le nuove porzioni del programma sono:
</PARA>
<BLOCKQUOTE><SCREEN><FILENAME>
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()


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()
</FILENAME></SCREEN></BLOCKQUOTE>
<PARA>
      Analiziamo la funzione 
      <FILENAME>save_numbers</FILENAME> del programma.
      Innanzitutto crea un oggetto file con il comando
      <FILENAME>open(filename, "w")</FILENAME> dopodiché
      crea una nuova linea per ognuno dei
      numeri di telefono con il comando
      <FILENAME>out_file.write(x+","+nombers[x]+"\n")</FILENAME>. 
      In questo modo scrive una linea contenente il nome, 
      una virgola ed il numero, seguito da un 'a capo'
      (newline).

</PARA><PARA>
      La funzione <FILENAME>load_numbers</FILENAME> 
      è un po' più complessa. 
      Inizia creando un oggetto file quindi usa un ciclo
      <FILENAME>while</FILENAME> per scorrere il file e 
      leggere le linee con 
      l'istruzione 
      <FILENAME>in_line = in_file.readline()</FILENAME>
      finché non incontra un <FILENAME>break</FILENAME>. 
      L'istruzione <FILENAME>if</FILENAME> esegue un 
      controllo e uscirà dal ciclo
      <FILENAME>while</FILENAME> con una istruzione 
      <FILENAME>break</FILENAME> nel momento in cui 
      incontrerà  la fine del 
      <FILENAME>file (len(in_line) == 0)</FILENAME> .

</PARA>
<PARA>

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

</PARA>





<SECT1 ID="C15.1" XREFLABEL="15.1">
<TITLE>Esercizi</TITLE>
<PARA>
	Modificate il programma dei voti del
	<XRef Linkend="C11"> per salvare su di un
	file la registrazione degli studenti.

</PARA>

</SECT1>


</CHAPTER>




















<CHAPTER ID="C16">
<TITLE>Occuparsi dell'imperfetto (o come gestire gli errori)</TITLE>

<PARA>
	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
	<FILENAME>try</FILENAME>: <FILENAME>try</FILENAME>
	 tenta di fare qualcosa. Segue un esempio di un
	programma che contiene un problema:

<BLOCKQUOTE><SCREEN><FILENAME>
print "Type Control C or -1 to exit"
number = 1
while number != -1:
    number = int(raw_input("Enter a number: "))
    print "You entered: ",number
</FILENAME></SCREEN></BLOCKQUOTE>

	Se tentate di inserire qualcosa come
	<FILENAME>#@&</FILENAME> l'output
	sarà simile a questo:

<BLOCKQUOTE><SCREEN><FILENAME>
Traceback (innermost last):
  File "try_less.py", line 4, in ?
    number = int(raw_input("Enter a number: "))
ValueError: invalid literal for int(): @#&
</FILENAME></SCREEN></BLOCKQUOTE>

	Come potete vedere la funzione
	<FILENAME>int()</FILENAME>
	non funziona (e non deve funzionare)
	con il 'numero' <FILENAME>#@&</FILENAME>.
	L'ultima linea mostra qual'è l'errore:
	Python ha trovato un
	<FILENAME>ValueError</FILENAME>.
	Come fare in modo che il nostro
	programma sappia gestire anche questo
	valore ?
	Innanzitutto mettendo la parte di
	codice che restituisce l'errore in
	un blocco <FILENAME>try</FILENAME> e
	poi decidendo come Python
	debba trattare
	<FILENAME>ValueError</FILENAME>.
	Il seguente programma mostra come ottenere
	tale comportamento:

<BLOCKQUOTE><SCREEN><FILENAME>
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."
</FILENAME></SCREEN></BLOCKQUOTE>

	Ora, quando eseguiremo il nuovo programma
	ed inseriremo <FILENAME>#@&</FILENAME> il
	programma risponderà con la frase
	<FILENAME>"That was not a number."</FILENAME>
	per poi continuare ciò che stava facendo prima.

</PARA><PARA>

	Quando il vostro programma restituisce
	un errore che sapete come gestire, mettete
	il codice in un blocco
	<FILENAME>try</FILENAME> e il modo per
	gestire l'errore nel successivo blocco
	<FILENAME>except</FILENAME>.

</PARA>








<SECT1 ID="C16.1" XREFLABEL="16.1">
<TITLE>Esercizi</TITLE>
<PARA>

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

</PARA>

</SECT1>


</CHAPTER>





















<CHAPTER ID="C17">
<TITLE>Fine</TITLE>

<PARA>
	Sto lavorando per aggiungere ulteriori
	sezioni a questo documento. Per ora vi
	raccomando il "Python Tutorial" di Guido
	Van Rossum, dovreste essere in grado di
	capire la maggior parte degli argomenti.

</PARA><PARA>

	Questo tutorial è ancora un lavoro in
	corso. Gradirei ogni commento e ogni
	richiesta di argomenti da aggiungere.
	Le vostre e-mail mi hanno portato ad
	ampliare e migliorare notevolmente il
	documento, ascoltando sempre molto
	attentamente ogni vostro commento :).

</PARA><PARA>

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

</PARA>

</CHAPTER>












<!-- Correggi -->



<CHAPTER ID="C18">
<TITLE>FAQ</TITLE>

<PARA>
	Scherzetto ... le FAQ non sono
	state tradotte ;-)
</PARA>
<PARA>

	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.

</PARA>
<PARA>

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

<PARA>

<ULINK url="http://www.honors.montana.edu/~jjc/easytut/"></ULINK>

</PARA>
<PARA>

	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.
</PARA>
<PARA>
	Inoltre è disponibile l'elenco delle versioni rilasciate
	dall'autore:
</PARA>

<VARIABLELIST>

<VARLISTENTRY>
	<TERM>

	</TERM>
<LISTITEM><LITERALLAYOUT>

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.
</LITERALLAYOUT></LISTITEM>
</VARLISTENTRY>

</VARIABLELIST>

<PARA>

	Per quanto riguarda la presente versione, tradotta
	in Italiano, c'è poco da dire ... in questo momento
	ancora non c'è un singolo, univoco sito dove si
	può dire che potrà essere sicuramente trovato
	questo documento, anche se molto probabilmente sarà
	disponibile sul sito Italiano di Python:
</PARA>
<PARA>
	<ULINK url="http://www.python.it"></ULINK>
</PARA>
<PARA>

	Per quanto riguarda le caratteristiche del
	documento la traduzione è avvenuta piuttosto
	fedelmente ma altrettanto non si può dire per il
	software utilizzato per la stesura vera e propria.
	Difatti, invece di usare LaTeX è stato usato il più
	comune SGML con DocBook. Quindi il risultato è un
	semplice file sgml che potrà essere convertito
	agevolmente in ogni formato disponibile.
</PARA>
<PARA>

	A questo proposito sarebbe cosa gradita che chiunque
	volesse rendere disponibile il presente tutorial
	sul proprio sito, quantomeno rilasciasse le versioni
	html formato DocBook, html in unica pagina, txt, ps,
	ps bookshleet, pdf, un file compresso contenente una
	directory che racchiuda i formati elencati ed
	il sorgente sgml. Per semplificare il procedimento
	è stato realizzato un Makefile che converte nei formati
	elencati e contiene semplici istruzioni per utilizzare
	al meglio il bookshleet.ps permettendo la creazione 
	distinta delle pagine pari e di quelle dispari destinate
	alla stampa.

</PARA>





</CHAPTER>


















<!--

</PARA><PARA>

</PARA><PARA>

<BLOCKQUOTE><SCREEN><FILENAME>

</FILENAME></SCREEN></BLOCKQUOTE>

</PARA><PARA>


<SECT1 ID="C2." XREFLABEL="2.">
<TITLE></TITLE>
<PARA>

</PARA>

</SECT1>


</CHAPTER>

<PARA>
<COMMAND></COMMAND>
</PARA>
<BLOCKQUOTE>
<PARA>

</PARA>
</BLOCKQUOTE>



<TABLE>
	<TITLE></TITLE>
	<TGROUP cols="2" align="left">
	<THEAD>
	<ROW>
		<ENTRY></ENTRY>
		<ENTRY></ENTRY>
	</ROW>
	</THEAD>
	<TBODY>
	<ROW>
		<ENTRY><FILENAME></FILENAME></ENTRY>
		<ENTRY></ENTRY>
	</ROW>
	<ROW>
		<ENTRY><FILENAME></FILENAME></ENTRY>
		<ENTRY></ENTRY>
	</ROW>
	</TBODY>
	</TGROUP>
	</TABLE>
</PARA><PARA>


-->

</BOOK>
