Transcription
Pensare in PythonCome pensare da InformaticoSeconda Edizione, Versione 2.2.23
Pensare in PythonCome pensare da InformaticoSeconda Edizione, Versione 2.2.23Allen DowneyGreen Tea PressNeedham, Massachusetts
Copyright 2015 Allen Downey.Green Tea Press9 Washburn AveNeedham MA 02492È concessa l’autorizzazione a copiare, distribuire e/o modificare questo documento sotto i terminidella Creative Commons Attribution-NonCommercial 3.0 Unported License, che è scaricabile dalsito http://creativecommons.org/licenses/by-nc/3.0/.La forma originale di questo libro è in codice sorgente LATEX . La compilazione del sorgente LATEX hal’effetto di generare una rappresentazione di un testo indipendente dal dispositivo, che può esseresuccessivamente convertito in altri formati e stampato.Il codice sorgente LATEX di questo libro è disponibile all’indirizzo http://www.thinkpython2.com.Titolo originale: Think Python: How to Think Like a Computer Scientist.Traduzione di Andrea Zanella.
PrefazioneLa strana storia di questo libroNel gennaio 1999 mi stavo preparando a tenere un corso introduttivo di programmazionein Java. Lo avevo tenuto già tre volte, ma ne stavo diventando sempre più insoddisfatto.Il tasso di insuccesso nel corso era troppo elevato, e anche per gli studenti che venivanopromossi, il livello globale di apprendimento era troppo basso.Uno dei problemi che avevo individuato erano i libri. Troppo grandi, con troppi dettaglinon necessari su Java e privi di una guida di alto livello su come programmare. E tutti soffrivano dell’ “effetto botola”: cominciavano in modo semplice, procedevano gradualmentee poi, verso il Capitolo 5, mancava il pavimento sotto i piedi. Gli studenti si trovavanocon troppo nuovo materiale e troppo velocemente, e io passavo il resto del semestre araccogliere i cocci.Due settimane prima dell’inizio delle lezioni, decisi allora di scrivere un libro tutto mio. Imiei obiettivi erano: Mantenerlo breve. Gli studenti preferiscono leggere 10 pagine piuttosto che 50. Prestare attenzione ai vocaboli. Cercai di ridurre al minimo i termini gergali e dispiegare ciascun termine la prima volta che veniva usato. Costruire gradualmente. Per evitare le “botole”, presi gli argomenti più osticisuddividendoli in una serie di piccoli passi. Focalizzare sulla programmazione, non sul linguaggio di programmazione. Inclusila minima parte necessaria di Java e tralasciai il resto.Mi serviva un titolo, così d’istinto scelsi Come pensare da Informatico.La prima versione era grezza, ma funzionò. Gli studenti lo lessero, e capirono abbastanzada permettermi di impiegare il tempo della lezione per gli argomenti più difficili, per quelliinteressanti e (cosa più importante) per la parte pratica.Pubblicai il libro sotto la GNU Free Documentation License, che permette ai fruitori dicopiare, modificare, e distribuire il libro.Ma il bello venne dopo. Jeff Elkner, insegnante di liceo in Virginia, utilizzò il mio libroadattandolo per Python. Mi mandò una copia della sua versione, e io ebbi la insolita esperienza di imparare Python leggendo il mio stesso libro. Con la Green Tea Press, pubblicaila prima versione Python nel 2001.
viCapitolo 0. PrefazioneNel 2003 cominciai a lavorare all’Olin College, ed ottenni di insegnare Python per la primavolta. Il contrasto con Java fu abissale. Gli studenti dovettero faticare meno, impararonodi più, lavorarono su progetti più interessanti, e in generale si divertirono di più.Da allora, ho continuato a sviluppare il libro, correggendo errori, migliorando alcuniesempi e aggiungendo nuovo materiale, soprattutto esercizi.Il risultato è questo libro, che ora ha il meno grandioso titolo Pensare in Python. Ecco alcunenovità: Ho aggiunto un paragrafo sul debug alla fine di ciascun capitolo. Questi paragrafipresentano le tecniche generali per scovare ed evitare gli errori, e le avvertenze suitrabocchetti di Python. Ho aggiunto altri esercizi, da brevi test di apprendimento ad alcuni progettisostanziosi. Per la maggior parte di essi, c’è un collegamento web alla soluzione. Ho aggiunto una serie di esercitazioni - esempi più articolati con esercizi, soluzioni ediscussione. Ho ampliato la trattazione sui metodi di sviluppo di un programma e sugli schemifondamentali di progettazione. Ho aggiunto delle appendici sul debug e l’analisi degli algoritmi.Novità di questa seconda edizione: Il libro e tutto il codice di supporto sono stati aggiornati a Python 3. Ho aggiunto alcuni paragrafi, con ulteriori dettagli sul web, per aiutare i meno esperti ad iniziare a usare Python in un browser, in modo da non doverne affrontarel’installazione fino a quando non si sentiranno pronti. Per il capitolo 4, al posto del mio pacchetto grafico basato su turtle graphics, chiamatoSwampy, ho adottato il modulo turtle di Python, più standard, potente e facile dainstallare. Ho inserito un nuovo capitolo chiamato “Ulteriori strumenti”, che presenta alcunefunzionalità aggiuntive di Python non indispensabili, ma che possono tornare utili.Spero che troviate piacevole utilizzare questo libro, e che vi aiuti, almeno un pochino, adimparare a programmare e a pensare da informatici.Allen B. DowneyOlin CollegeRingraziamentiGrazie infinite a Jeff Elkner, che ha adattato a Python il mio libro su Java, ha dato inizioa questo progetto e mi ha introdotto in quello che poi è diventato il mio linguaggio diprogrammazione preferito.
viiGrazie anche a Chris Meyers, che ha contribuito ad alcuni paragrafi di How to Think Like aComputer Scientist.Grazie alla Free Software Foundation per aver sviluppato la GNU Free Documentation License, che ha aiutato a rendere possibile la mia collaborazione con Jeff e Chris, e a CreativeCommons per la licenza che uso attualmente.Grazie ai redattori di Lulu che hanno lavorato a How to Think Like a Computer Scientist.Grazie ai redattori di O’Reilly Media che hanno lavorato a Think Python.Grazie a tutti gli studenti che hanno usato le versioni precedenti di questo libro e a tutticoloro (elencati di seguito) che hanno contribuito inviando correzioni e suggerimenti.Elenco dei collaboratoriPiù di 100 lettori premurosi e dalla vista aguzza hanno inviato suggerimenti e correzioni negli anni passati. Il loro contributo e l’entusiasmo per questo progetto, sono stati dienorme aiuto.Se volete proporre suggerimenti o correzioni,inviate una email afeedback@thinkpython.com. Se farò delle modifiche in seguito al vostro contributo,sarete aggiunti all’elenco dei collaboratori (a meno che non chiediate di non comparire).Se includete almeno parte della frase in cui si trova l’errore, mi faciliterete la ricerca. Vannobene anche numeri di pagina e di paragrafo, ma sono meno agevoli da trattare. Grazie! Lloyd Hugh Allen ha inviato una correzione al Paragrafo 8.4. Yvon Boulianne ha inviato una correzione a un errore di semantica nel Capitolo 5. Fred Bremmer ha inviato una correzione al Paragrafo 2.1. Jonah Cohen ha scritto gli script Perl per convertire i sorgenti LaTeX di questo libro in unmeraviglioso HTML. Michael Conlon ha inviato una correzione grammaticale nel Capitolo 2 e un miglioramentodello stile nel Capitolo 1, e ha iniziato la discussione sugli aspetti tecnici degli interpreti. Benoit Girard ha inviato una correzione ad un umoristico errore nel Paragrafo 5.6. Courtney Gleason e Katherine Smith hanno scritto horsebet.py, che veniva usato come esercitazione in una versione precedente del libro. Ora il loro programma si può trovare sul sitoweb. Lee Harr ha sottoposto più correzioni di quelle che è possibile elencare in questo spazio, epertanto andrebbe considerato come uno dei principali revisori del testo. James Kaylin è uno studente che ha usato il libro. Ha sottoposto numerose correzioni. David Kershaw ha sistemato la funzione errata catTwice nel Paragrafo 3.10. Eddie Lam ha mandato molte correzioni ai Capitoli 1, 2, e 3. Ha anche sistemato il Makefilein modo che crei un indice alla prima esecuzione e ha aiutato nell’impostazione dello schemadelle versioni. Man-Yong Lee ha inviato una correzione al codice di esempio nel Paragrafo 2.4.
viiiCapitolo 0. Prefazione David Mayo ha puntualizzato che la parola “inconsciamente’ nel Capitolo 1 doveva esserecambiata in “subconsciamente”. Chris McAloon ha inviato alcune correzioni ai Paragrafi 3.9 e 3.10. Matthew J. Moelter è un collaboratore di lunga data che ha inviato numerose correzioni esuggerimenti al libro. Simon Dicon Montford ha comunicato una definizione di funzione mancante e alcuni errori dibattitura nel Capitolo 3. Ha anche trovato un errore nella funzione incremento nel Capitolo13. John Ouzts ha corretto la definizione di “valore di ritorno” nel Capitolo 3. Kevin Parks ha inviato preziosi commenti e suggerimenti su come migliorare la distribuzionedel libro. David Pool ha inviato un errore di battitura nel glossario del Capitolo 1, e gentili parole diincoraggiamento. Michael Schmitt ha inviato correzioni al capitolo sui file e le eccezioni. Robin Shaw ha evidenziato un errore nel Paragrafo 13.1 dove la funzione printTime venivausata in un esempio senza essere definita. Paul Sleigh ha trovato un errore nel Capitolo 7 e un bug nello script Perl di Jonah Cohen chegenera HTML a partire da LaTeX. Craig T. Snydal sta provando il testo in un corso presso la Drew University. Ha contribuito conalcuni preziosi consigli e correzioni. Ian Thomas e i suoi studenti stanno usando il testo in un corso di programmazione. Sono i primi a collaudare i capitoli della seconda metà del libro, e hanno apportato numerose correzionie suggerimenti. Keith Verheyden ha inviato una correzione al Capitolo 3. Peter Winstanley ci ha portato a conoscenza di un annoso errore nel nostro carattere latin nelCapitolo 3. Chris Wrobel ha apportato correzioni al codice nel capitolo su file I/O ed eccezioni. Moshe Zadka ha dato un inestimabile contributo a questo progetto. Oltre a scrivere la primabozza del capitolo sui Dizionari, è stato una continua fonte di indicazioni nei primi abbozzi diquesto libro. Christoph Zwerschke ha inviato alcune correzioni e suggerimenti pedagogici, e ha spiegato ladifferenza tra gleich e selbe. James Mayer ci ha mandato correzioni a un sacco di errori di battitura e di dizione, compresidue nell’elenco dei collaboratori. Hayden McAfee ha colto una incongruenza, fonte di probabile confusione, tra due esempi. Angel Arnal fa parte del gruppo internazionale di traduttori e lavora sulla versione spagnola.Ha trovato anche alcuni errori nella versione inglese. Tauhidul Hoque e Lex Berezhny hanno creato le illustrazioni del Capitolo 1 e migliorato moltedelle altre.
ix Il Dr. Michele Alzetta ha colto un errore nel Capitolo 8 e inviato alcuni interessanti commentipedagogici su Fibonacci e Old Maid. Andy Mitchell ha trovato un errore di battitura nel Capitolo1 e un esempio non funzionantenel Capitolo 2. Kalin Harvey ha suggerito un chiarimento nel Capitolo 7 e ha trovato alcuni errori di battitura. Christopher P. Smith ha trovato alcuni errori di battitura e ci ha aiutato ad aggiornare il libro aPython 2.2 . David Hutchins ha trovato un errore di battitura nella Premessa. Gregor Lingl insegna Python in un liceo di Vienna, in Austria. Sta lavorando alla traduzionetedesca del libro e ha trovato un paio di brutti errori nel Capitolo 5. Julie Peters ha trovato un errore di battitura nella Premessa. Florin Oprina ha inviato un miglioramento in makeTime, una correzione in printTime, e unsimpatico errore di battitura. D. J. Webre ha suggerito un chiarimento nel Capitolo 3. Ken ha trovato una manciata di errori nei Capitoli 8, 9 e 11. Ivo Wever ha trovato un errore di battitura nel Capitolo 5 e ha suggerito un chiarimento nelCapitolo 3. Curtis Yanko ha suggerito un chiarimento nel Capitolo 2. Ben Logan ha evidenziato alcuni errori di battitura e dei problemi nella trasposizione del libroin HTML. Jason Armstrong ha notato una parola mancante nel Capitolo 2. Louis Cordier ha notato un punto del Capitolo 16 dove il codice non corrispondeva al testo. Brian Cain ha suggerito dei chiarimenti nei Capitoli 2 e 3. Rob Black ha inviato un’ampia raccolta di correzioni, inclusi alcuni cambiamenti per Python2.2. Jean-Philippe Rey dell’Ecole Centrale di Parigi ha inviato un buon numero di correzioni,inclusi degli aggiornamenti per Python 2.2 e altri preziosi miglioramenti. Jason Mader della George Washington University ha dato parecchi utili suggerimenti ecorrezioni. Jan Gundtofte-Bruun ci ha ricordato che “a error” è un errore. Abel David e Alexis Dinno ci hanno ricordato che il plurale di “matrix” è “matrices”, non“matrixes”. Questo errore è rimasto nel libro per anni, ma due lettori con le stesse iniziali lohanno segnalato nello stesso giorno. Curioso. Charles Thayer ci ha spronati a sbarazzarci dei due punti che avevamo messo alla fine di alcuneistruzioni, e a fare un uso più appropriato di “argomenti” e “parametri”. Roger Sperberg ha indicato un brano dalla logica contorta nel Capitolo 3. Sam Bull ha evidenziato un paragrafo confuso nel Capitolo 2. Andrew Cheung ha evidenziato due istanze di “uso prima di def.”
xCapitolo 0. Prefazione C. Corey Capel ha notato una parola mancante nel Terzo Teorema del Debugging e un erroredi battitura nel Capitolo 4. Alessandra ha aiutato a sistemare un po’ di confusione nelle Tartarughe. Wim Champagne ha trovato un errore in un esempio di dizionario. Douglas Wright ha trovato un problema con la divisione intera in arco. Jared Spindor ha trovato alcuni scarti alla fine di una frase. Lin Peiheng ha inviato una serie di suggerimenti molto utili. Ray Hagtvedt ha sottoposto due errori e un non-abbastanza-errore. Torsten Hübsch ha evidenziato un’incongruenza in Swampy. Inga Petuhhov ha corretto un esempio nel Capitolo 14. Arne Babenhauserheide ha inviato alcune utili correzioni. Mark E. Casida è bravo bravo a trovare parole ripetute. Scott Tyler ha inserito una che mancava. E ha poi inviato una pila di correzioni. Gordon Shephard ha inviato alcune correzioni, tutte in email separate. Andrew Turner ha trovato un errore nel Capitolo 8. Adam Hobart ha sistemato un problema con la divisione intera in arco. Daryl Hammond e Sarah Zimmerman hanno osservato che ho servito math.pi troppo presto.E Zim ha trovato un errore di battitura. George Sass ha trovato un bug in un Paragrafo sul Debug. Brian Bingham ha suggerito l’Esercizio 11.5. Leah Engelbert-Fenton ha osservato che avevo usate tuple come nome di variabile, contro lemie stesse affermazioni. E poi ha trovato una manciata di errori di battitura e un “uso primadi def.” Joe Funke ha trovato un errore di battitura. Chao-chao Chen ha trovato un’incoerenza nell’esempio su Fibonacci. Jeff Paine conosce la differenza tra space e spam. Lubos Pintes ha corretto un errore di battitura. Gregg Lind e Abigail Heithoff hanno suggerito l’Esercizio 14.3. Max Hailperin ha inviato parecchie correzioni e suggerimenti. Max è uno degli autori dellostraordinario Concrete Abstractions, che potreste prendere in considerazione dopo aver lettoquesto libro. Chotipat Pornavalai ha trovato un errore in un messaggio di errore. Stanislaw Antol ha mandato un elenco di suggerimenti molto utili. Eric Pashman ha inviato parecchie correzioni ai Capitoli 4–11. Miguel Azevedo ha trovato alcuni errori di battitura.
xi Jianhua Liu ha inviato un lungo elenco di correzioni. Nick King ha trovato una parola mancante. Martin Zuther ha inviato un lungo elenco di suggerimenti. Adam Zimmerman ha trovato un’incongruenza nella mia istanza di un’ “istanza” e qualchealtro errore. Ratnakar Tiwari ha suggerito una nota a pié di pagina per spiegare i triangoli degeneri. Anurag Goel ha suggerito un’altra soluzione per alfabetica e alcune altre correzioni. E sacome si scrive Jane Austen. Kelli Kratzer ha evidenziato un errore di battitura. Mark Griffiths ha osservato un esempio poco chiaro nel Capitolo 3. Roydan Ongie ha trovato un errore nel mio metodo di Newton. Patryk Wolowiec mi ha aiutato a risolvere un problema con la versione HTML. Mark Chonofsky mi ha riferito di una nuova parola riservata in Python 3. Russell Coleman mi ha aiutato con la geometria. Nam Nguyen ha trovato un errore di battitura e ha osservato che avevo usato uno schema diDecoratore senza farne menzione. Stéphane Morin ha inviato alcune correzioni e suggerimenti. Paul Stoop ha corretto un errore di battitura in usa solo. Eric Bronner ha notato un po’ di confusione nella discussione dell’ordine delle operazioni. Alexandros Gezerlis ha fissato un nuovo standard per il numero e la qualità dei suoisuggerimenti. Gli siamo profondamente grati! Gray Thomas distingue la sua destra dalla sua sinistra. Giovanni Escobar Sosa ha inviato un lungo elenco di correzioni e suggerimenti. Daniel Neilson ha corretto un errore nell’ordine delle operazioni. Will McGinnis ha evidenziato che polilinea era definita in modo diverso in due punti. Frank Hecker ha osservato un esercizio non ben spiegato e alcuni collegamenti nonfunzionanti. Animesh B mi ha aiutato a spiegare meglio un esempio poco chiaro. Martin Caspersen ha trovato due errori di arrotondamento. Gregor Ulm ha inviato alcune correzioni e suggerimenti. Dimitrios Tsirigkas ha suggerito di chiarire meglio un esercizio. Carlos Tafur ha inviato una pagina di correzioni e suggerimenti. Martin Nordsletten ha trovato un bug nella soluzione di un esercizio. Sven Hoexter ha osservato che una variabile di nome input oscura una funzione predefinita. Stephen Gregory ha evidenziato il problema di cmp in Python 3.
xiiCapitolo 0. Prefazione Ishwar Bhat ha corretto la mia formulazione dell’ultimo teorema di Fermat. Andrea Zanella ha tradotto il libro in italiano e, strada facendo, ha inviato alcune correzioni. Mille grazie a Melissa Lewis e a Luciano Ramalho per gli eccellenti commenti e suggerimentialla seconda edizione. Grazie a Harry Percival di PythonAnywhere per il suo aiuto a chi vuole iniziare ad usarePython in un web browser. Xavier Van Aubel ha prodotto alcune utili correzioni alla seconda edizione. William Murray ha puntualizzato la mia definizione di divisione intera. Per Starbäck mi ha aggiornato sui ritorni a capo universali in Python 3.Hanno inoltre segnalato errori di stampa o indicato correzioni: Czeslaw Czapla, Dale Wilson,Francesco Carlo Cimini, Richard Fursa, Brian McGhie, Lokesh Kumar Makani, Matthew Shultz, Viet Le, Victor Simeone, Lars O.D. Christensen, Swarup Sahoo, Alix Etienne, Kuang He,Wei Huang, Karen Barber, e Eric Ransom.
IndicePrefazionev1Lo scopo del programma11.1Che cos’è un programma? . . . . . . . . . . . . . . . . . . . . . . . . . . . .11.2Avviare Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .21.3Il primo programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .31.4Operatori aritmetici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .31.5Valori e tipi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .41.6Linguaggi formali e linguaggi naturali . . . . . . . . . . . . . . . . . . . . .51.7Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61.8Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71.9Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .82Variabili, espressioni ed istruzioni92.1Istruzioni di assegnazione . . . . . . . . . . . . . . . . . . . . . . . . . . . .92.2Nomi delle variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92.3Espressioni e istruzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102.4Modalità script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .112.5Ordine delle operazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . .122.6Operazioni sulle stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . .122.7Commenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .132.8Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .142.9Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .142.10Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15
xiv34IndiceFunzioni173.1Chiamate di funzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .173.2Funzioni matematiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .183.3Composizione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .193.4Aggiungere nuove funzioni . . . . . . . . . . . . . . . . . . . . . . . . . . .193.5Definizioni e loro utilizzo . . . . . . . . . . . . . . . . . . . . . . . . . . . .213.6Flusso di esecuzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .213.7Parametri e argomenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .223.8Variabili e parametri sono locali . . . . . . . . . . . . . . . . . . . . . . . . .233.9Diagrammi di stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .233.10Funzioni “produttive” e funzioni “vuote” . . . . . . . . . . . . . . . . . . .243.11Perché usare le funzioni? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .253.12Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .253.13Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .263.14Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27Esercitazione: Progettazione dell’interfaccia294.1Il modulo turtle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .294.2Ripetizione semplice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .304.3Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .314.4Incapsulamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .324.5Generalizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .324.6Progettazione dell’interfaccia . . . . . . . . . . . . . . . . . . . . . . . . . .334.7Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .344.8Tecnica di sviluppo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .354.9Stringa di documentazione . . . . . . . . . . . . . . . . . . . . . . . . . . . .364.10Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .364.11Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374.12Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37
Indicexv5Istruzioni condizionali e ricorsione395.1Divisione intera e modulo . . . . . . . . . . . . . . . . . . . . . . . . . . . .395.2Espressioni booleane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .405.3Operatori logici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .405.4Esecuzione condizionale . . . . . . . . . . . . . . . . . . . . . . . . . . . . .415.5Esecuzione alternativa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .415.6Condizioni in serie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .425.7Condizioni nidificate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .425.8Ricorsione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .435.9Diagrammi di stack delle funzioni ricorsive . . . . . . . . . . . . . . . . . .445.10Ricorsione infinita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .455.11Input da tastiera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .455.12Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .465.13Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .475.14Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .486Funzioni produttive516.1Valori di ritorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .516.2Sviluppo incrementale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .526.3Composizione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .546.4Funzioni booleane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .556.5Altro sulla ricorsione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .556.6Salto sulla fiducia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .576.7Un altro esempio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .586.8Controllo dei tipi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .586.9Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .596.10Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .606.11Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61
xvi789IndiceIterazione637.1Riassegnazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .637.2Aggiornare le variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .647.3L’istruzione while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .647.4break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .667.5Radici quadrate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .667.6Algoritmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .687.7Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .687.8Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .697.9Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .69Stringhe718.1Una stringa è una sequenza . . . . . . . . . . . . . . . . . . . . . . . . . . .718.2len . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .728.3Attraversamento con un ciclo for . . . . . . . . . . . . . . . . . . . . . . . .728.4Slicing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .738.5Le stringhe sono immutabili . . . . . . . . . . . . . . . . . . . . . . . . . . .748.6Ricerca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .758.7Cicli e contatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .758.8Metodi delle stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .768.9L’operatore in . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .778.10Confronto di stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .778.11Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .788.12Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .798.13Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .80Esercitazione: Giochi con le parole839.1Leggere elenchi di parole . . . . . . . . . . . . . . . . . . . . . . . . . . . . .839.2Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .849.3Ricerca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .859.4Cicli con gli indici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .869.5Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .879.6Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .889.7Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88
Indicexvii10 Liste9110.1Una lista è una sequenza . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9110.2Le liste sono mutabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9210.3Attraversamento di una lista . . . . . . . . . . . . . . . . . . . . . . . . . . .9310.4Operazioni sulle liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9310.5Slicing delle liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9410.6Metodi delle liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9410.7Mappare, filtrare e ridurre . . . . . . . . . . . . . . . . . . . . . . . . . . . .9510.8Cancellare elementi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9610.9Liste e stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9610.10 Oggetti e valori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9710.11 Alias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9810.12 Liste come argomenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9910.13 Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10010.14 Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10210.15 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10211 Dizionari10511.1Un dizionario è una mappatura . . . . . . . . . . . . . . . . . . . . . . . . .10511.2Il dizionario come raccolta di contatori . . . . . . . . . . . . . . . . . . . . . 10611.3Cicli e dizionari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10811.4Lookup inverso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10811.5Dizionari e liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10911.6Memoizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11111.7Variabili globali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11211.8Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11311.9Glossario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11411.10 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .115
xviiiIndice12 T
Grazie ai redattori di Lulu che hanno lavorato a How to Think Like a Computer Scientist. Grazie ai redattori di O'Reilly Media che hanno lavorato a Think Python. Grazie a tutti gli studenti che hanno usato le versioni precedenti di questo libro e a tutti coloro (elencati di seguito) che hanno contribuito inviando correzioni e suggerimenti.
