Python per tutti - PDF

Python per tutti Esplorare dati con Python 3 Charles R. Severance Crediti Supporto editoriale: Elliott Hauser, Sue Blumenberg Cover Design: Aimee Andrion Cronologia di stampa 05 Luglio 2016 Prima versione completa di Python 3.0 20 Dicembre 2015 Conversione iniziale approssimativa verso Python 3.0 Dettagli sul copyright Copyright ~2009- Charles Severance. Quest’opera è rilasciata sotto licenza Creative Common Attribution-Non Commercial-Share Alike 3.0 Unported. Questa licenza è disponibile all’indirizzo: http://creativecommons.org/licenses/by-nc-sa/3.0/ La definizione di ciò che l’autore considera uso commerciale e non-commerciale di questo materiale così come le esenzioni alla licenza sono disponibili nell’Appendice intitolata Dettagli sul Copyright. iii Prefazione Il remix di un Open Book È abbastanza naturale per gli accademici, che si sentono dire continuamente “pub- blica o muori”, voler sempre creare dal nulla qualcosa che sia una loro nuova crea- zione. Questo libro è un esperimento: non partire da zero, ma invece “remixare” il libro dal titolo “Think Python: How to Think Like a Computer Scientist” scritto da Allen B. Downey, Jeff Elkner ed altri. Nel dicembre del 2009 mi stavo preparando a tenere il corso “SI502 - Networked Programming” presso l’Università del Michigan per il quinto semestre consecutivo e ho deciso che era tempo di scrivere un libro di testo su Python che si concentrasse sull’esplorazione dei dati invece che sulla comprensione di algoritmi ed astrazioni. Il mio obiettivo, nel SI502, era quello di insegnare le tecniche fondamentali di analisi dei dati utilizzando Python. Pochi dei miei studenti avevano in progetto di diventare programmatori professionisti, altri pianificavano di diventare bibliotecari, manager, avvocati, biologi, economisti o altro e desideravano imparare ad utilizzare abilmente le tecnologie nei rispettivi campi professionali. Non avendo mai trovato un libro su Python che fosse perfettamente orientato alla gestione dei dati per il mio corso, decisi di scriverne uno. Fortunatamente, tre settimane prima che iniziassi a lavorarci approfittando delle vacanze, in una riunione di facoltà, il Dr. Atul Prakash mi mostrò il libro “Think Python” che lui stesso aveva usato per il suo corso. Si tratta di un testo di Informatica ben scritto, focalizzato su brevi spiegazioni dirette che facilitano l’apprendimento. La struttura complessiva del libro è stata modificata per arrivare a gestire i proble- mi di analisi dei dati il più rapidamente possibile e per fornire una serie di esercizi ed esempi sull’analisi dei dati fin dall’inizio. I capitoli 2-10 sono simili al libro Think Python nonostante siano state fatte im- portanti modifiche. Gli esempi e gli esercizi orientati alla gestione di numeri sono stati sostituiti con esercitazioni orientate ai dati. Gli argomenti sono presentati in un ordine tale da fornire soluzioni di analisi dei dati via via sempre più sofisticate. Alcuni argomenti come “try” e “except” sono stati anticipati e presentati come parte del capitolo sull’esecuzione condizionale. Piuttosto che essere trattate già dall’inizio in maniera astratta, le funzioni sono state trattate più superficialmente sino al momento in cui sono diventate necessarie per gestire la complessità dei pro- grammi. Quasi tutte le funzioni definibili dall’utente sono state rimosse dai codici di esempio ed esercitazione al di fuori del Capitolo 4. La parola “ricorsivo”1 non viene mai utilizzata in alcuna parte del libro. Tutto il materiale nei capitoli 1 e 11-16 è nuovo di zecca, ed è focalizzato sull’uso di Python in applicazioni del mondo reale e fornisce semplici esempi per l’analisi dei dati, comprendendo espressioni regolari per la ricerca e l’analisi, l’automatizzazione delle attività sul computer, il recupero dei dati attraverso la rete, il prelievo di dati da pagine web, l’utilizzo di servizi web, l’analisi di dati in formato XML e JSON, la creazione e l’utilizzo di database utilizzando lo Structured Query Language e la rappresentazione di dati. 1 Ad eccezione, ovviamente, di questa riga. iv L’obiettivo finale di tutti questi cambiamenti è quello di includere in un corso di primo livello solo quegli argomenti che potranno tornare utili anche a coloro che non sceglieranno di diventare programmatori professionisti. Gli studenti che troveranno questo libro interessante e che vogliano esplorare ul- teriormente l’argomento, dovrebbero considerare il libro Think Python di Allen B. Downey. Date le molte sovrapposizioni tra i due libri, gli studenti saranno in grado di acquisire rapidamente alcune ulteriori competenze nelle ulteriori aree della tec- nica di programmazione e del pensiero algoritmico che sono parte di Think Python. Inoltre, dato che i due libri hanno uno stile di scrittura simile, per loro sarà facile muoversi all’interno di Think Python. Come detentore del copyright su Think Python, Allen mi ha dato il permesso di cambiare la licenza del materiale dal suo libro che viene incluso in questo libro, da GNU Free Documentation License alla più recente Creative Commons Attri- bution — Share Alike license. Questo segue il generale cambiamento nelle licenze di documentazione aperta che si stanno spostando da GFDL a CC BY-SA (vedi Wikipedia). L’utilizzo della licenza CC BY-SA indica ai fruitori dell’opera che essa può essere utilizzata, diffusa e anche modificata liberamente, pur nel rispetto di alcune condizioni essenziali e rende ancora più semplice ai nuovi autori riutilizzare questo materiale. Ritengo che questo libro sia un esempio del perché i materiali aperti siano così importanti per il futuro della formazione. Voglio ringraziare Allen B. Downey e la Cambridge University Press per la loro decisione lungimirante nel rendere il libro disponibile sotto un open Copyright. Spero che siano soddisfatti dei risultati del nostro impegno collettivo e mi auguro lo siate anche voi lettori. Vorrei ringraziare Allen B. Downey e Lauren Cowles per il loro aiuto, la pazienza, e la guida nell’affrontare e risolvere i problemi di copyright riguardanti questo libro. Charles Severance www.dr-chuck.com Ann Arbor, MI, USA 9 settembre 2013 Charles Severance è Clinical Associate Professor presso l’Università del Michigan - School of Information. Indice 1 Perché dovresti imparare a programmare? 1 1.1 Creatività e motivazione........................ 2 1.2 Architettura hardware del computer................. 3 1.3 Capire la Programmazione....................... 4 1.4 Parole e frasi.............................. 5 1.5 Conversare con Python......................... 6 1.6 Terminologia: interprete e compilatore................ 8 1.7 Scrivere un programma........................ 10 1.8 Cos’è un programma?......................... 11 1.9 I blocchi per costruire i programmi.................. 12 1.10 Cosa potrebbe andare storto?..................... 13 1.11 Il percorso di studio.......................... 14 1.12 Glossario................................ 15 1.13 Esercizi................................. 16 2 Variabili, espressioni ed istruzioni 19 2.1 Valori e tipi............................... 19 2.2 Variabili................................. 20 2.3 Nomi delle variabili e parole chiavi.................. 21 2.4 Istruzioni................................ 21 2.5 Operatori e operandi.......................... 22 2.6 Espressioni............................... 23 2.7 Ordine delle operazioni......................... 23 2.8 Operatore modulo........................... 24 2.9 Operazioni con le stringhe....................... 24 2.10 Chiedere un valore in input all’utente................ 24 v vi INDICE 2.11 Commenti................................ 26 2.12 Scegliere nomi mnemonici delle variabili............... 26 2.13 Debug.................................. 28 2.14 Glossario................................ 29 2.15 Esercizi................................. 29 3 Esecuzione condizionale 31 3.1 Espressioni booleane.......................... 31 3.2 Operatori logici............................. 32 3.3 Esecuzione condizionale........................ 32 3.4 Esecuzione alternativa......................... 33 3.5 Condizioni concatenate......................... 34 3.6 Condizioni nidificate.......................... 35 3.7 Gestione delle eccezioni usando try ed except............ 36 3.8 Valutazione di un cortocircuito di espressioni logiche........ 38 3.9 Debug.................................. 39 3.10 Glossario................................ 40 3.11 Esercizi................................. 40 4 Funzioni 43 4.1 Chiamate di funzione.......................... 43 4.2 Funzioni integrate........................... 43 4.3 Funzioni di conversione dei tipi di dato................ 44 4.4 Funzioni matematiche......................... 45 4.5 Numeri casuali............................. 46 4.6 Aggiungere nuove funzioni....................... 47 4.7 Definizioni e usi............................. 48 4.8 Flusso di esecuzione.......................... 49 4.9 Parametri e argomenti......................... 50 4.10 Funzioni produttive e funzioni vuote................. 51 4.11 Perché le funzioni?........................... 52 4.12 Debug.................................. 53 4.13 Glossario................................ 53 4.14 Esercizi................................. 54 INDICE vii 5 Iterazione 57 5.1 Aggiornamento delle variabili..................... 57 5.2 L’istruzione while........................... 57 5.3 Cicli infiniti............................... 58 5.4 “Cicli infiniti” e break......................... 58 5.5 Fermare le iterazioni con continue.................. 59 5.6 Cicli definiti con l’uso di for..................... 60 5.7 Schemi di ciclo............................. 61 5.7.1 Cicli per contare e sommare.................. 61 5.7.2 Cicli di massimo e minimo................... 62 5.8 Debug.................................. 63 5.9 Glossario................................ 64 5.10 Esercizi................................. 64 6 Stringhe 65 6.1 Una stringa è una sequenza...................... 65 6.2 Ottenere la lunghezza di una stringa usando len.......... 66 6.3 Scorrere una stringa con un ciclo................... 66 6.4 Segmenti di stringhe.......................... 67 6.5 Le stringhe sono immutabili...................... 68 6.6 Cicli e conteggi............................. 68 6.7 L’operatore in............................. 69 6.8 Comparazione di stringhe....................... 69 6.9 Metodi delle stringhe......................... 69 6.10 Analisi delle stringhe.......................... 72 6.11 Operatore di formato.......................... 72 6.12 Debug.................................. 73 6.13 Glossario................................ 74 6.14 Esercizi................................. 75 7 File 77 7.1 Persistenza............................... 77 7.2 Aprire i file............................... 77 7.3 File di testo e righe........................... 79 7.4 Lettura dei file............................. 80 viii INDICE 7.5 Ricerche in un file........................... 81 7.6 Far scegliere all’utente il nome del file................ 83 7.7 Utilizzare try, except e open.................... 84 7.8 Scrivere file............................... 85 7.9 Debug.................................. 86 7.10 Glossario................................ 87 7.11 Esercizi................................. 87 8 Elenchi 89 8.1 Un elenco è una sequenza....................... 89 8.2 Gli elenchi sono mutabili........................ 90 8.3 Scorrere un elenco........................... 90 8.4 Operazioni sugli elenchi........................ 91 8.5 Slicing degli elenchi........................... 92 8.6 Metodi degli elenchi.......................... 92 8.7 Eliminazione di elementi........................ 93 8.8 Elenchi e funzioni............................ 94 8.9 Elenchi e stringhe............................ 95 8.10 Analisi di righe............................. 96 8.11 Oggetti e valori............................. 97 8.12 Alias................................... 98 8.13 Elenchi come argomenti........................ 98 8.14 Debug.................................. 100 8.15 Glossario................................ 103 8.16 Esercizi................................. 104 9 Dizionari 107 9.1 Dizionario come insieme di contatori................. 109 9.2 Dizionari e file............................. 110 9.3 Cicli e dizionari............................. 111 9.4 Analisi avanzata del testo....................... 113 9.5 Debug.................................. 114 9.6 Glossario................................ 115 9.7 Esercizi................................. 115 INDICE ix 10 Tuple 117 10.1 Le tuple sono immutabili....................... 117 10.2 Confronto tra tuple........................... 119 10.3 Assegnazione di tupla......................... 120 10.4 Dizionari e tuple............................ 121 10.5 Assegnazione multipla con dizionari.................. 122 10.6 Le parole più comuni.......................... 123 10.7 Usare tuple come chiavi nei dizionari................. 124 10.8 Sequenze: stringhe, elenchi e tuple - Oh cavolo!........... 124 10.9 Debug.................................. 125 10.10Glossario................................ 126 10.11Esercizi................................. 127 11 Espressioni regolari 129 11.1 Confronto di caratteri nelle espressioni regolari........... 130 11.2 Estrazione dei dati utilizzando le espressioni regolari........ 131 11.3 Combinare ricerca ed estrazione.................... 134 11.4 Carattere Escape............................ 137 11.5 Sommario................................ 138 11.6 Sezione bonus per utenti Unix/Linux................. 139 11.7 Debug.................................. 139 11.8 Glossario................................ 140 11.9 Esercizi................................. 141 12 Programmi per Internet 143 12.1 HyperText Transfer Protocol - HTTP................ 143 12.2 Il browser Web più semplice del mondo............... 144 12.3 Recupero di un’immagine tramite HTTP.............. 145 12.4 Recupero di pagine Web con urllib................. 148 12.5 Analisi dell’HTML e raccolta dati dal Web.............. 149 12.6 Analisi dell’HTML utilizzando le espressioni regolari........ 149 12.7 Analisi dell’HTML con BeautifulSoup................ 150 12.8 Leggere file binari tramite urllib.................... 153 12.9 Glossario................................ 154 12.10Esercizi................................. 154 x INDICE 13 Utilizzo di servizi Web 157 13.1 eXtensible Markup Language - XML................. 157 13.2 Analizzare XML............................ 158 13.3 Cicli con i nodi degli XML....................... 159 13.4 JavaScript Object Notation - JSON.................. 159 13.5 Analizzare codice JSON........................ 160 13.6 Interfacce per la programmazione di applicazioni.......... 162 13.7 Servizio web di geocodifica di Google................. 163 13.8 Sicurezza e utilizzo delle API..................... 165 13.9 Glossario................................ 170 13.10Esercizi................................. 170 14 Programmazione ad oggetti 171 14.1 Gestione di programmi più grandi.................. 171 14.2 Come Iniziare.............................. 172 14.3 Utilizzare gli oggetti.......................... 172 14.4 I primi script.............................. 173 14.5 Suddividere un problema - l’incapsulamento............. 175 14.6 Il nostro primo oggetto Python.................... 176 14.7 Le classi come tipi........................... 178 14.8 Ciclo di vita dell’oggetto........................ 179 14.9 Molte istanze.............................. 180 14.10Ereditarietà............................... 181 14.11Sommario................................ 183 14.12Glossario................................ 184 15 Utilizzo dei database e SQL 185 15.1 Cos’è un database?........................... 185 15.2 Fondamenti sui database........................ 185 15.3 Browser di database per SQLite.................... 186 15.4 Creazione di una tabella........................ 186 15.5 Riepilogo dello Structured Query Language............. 189 15.6 Uno spider su Twitter utilizzando un database........... 191 15.7 Modellazione elementare dei dati................... 196 15.8 Programmazione con più tabelle................... 197 INDICE xi 15.8.1 Vincoli nelle tabelle del database............... 200 15.8.2 Recuperare e/o inserire un record............... 201 15.8.3 Memorizzare la relazione di amicizia............. 202 15.9 Tre tipi di chiavi............................ 203 15.10Utilizzare JOIN per recuperare dati................. 204 15.11Riassunto................................ 206 15.12Debug.................................. 207 15.13Glossario................................ 207 16 Come visualizzare dati 209 16.1 Costruire una Google map partendo da dati geocodificati..... 209 16.2 Visualizzare reti e interconnessioni.................. 212 16.3 Visualizzazione dei dati della posta elettronica............ 214 A Contributi 221 A.1 Elenco dei collaboratori di Python for Everybody.......... 221 A.2 Elenco dei Traduttori di Python per tutti.............. 221 A.3 Elenco dei collaboratori per Python for Informatics......... 221 A.4 Prefazione per “Think Python”.................... 222 A.4.1 La strana storia di “Think Python”............. 222 A.4.2 Ringraziamenti per “Think Python”............. 223 A.5 Elenco dei collaboratori di “Think Python”............. 223 B Dettagli sul copyright 225 xii INDICE Capitolo 1 Perché dovresti imparare a programmare? Scrivere programmi (o programmare) è un’attività molto creativa e gratificante. Puoi scrivere programmi per molte ragioni, per guadagnarti da vivere, per effet- tuare complesse analisi dei dati, per divertimento o per aiutare qualcun altro a risolvere un problema. Questo libro presuppone che tutti abbiano bisogno di saper programmare e che, una volta appreso come programmare, sappiano cosa fare con le nuove capacità acquisite. Ogni giorno siamo circondati da computer che vanno dai portatili agli smartphone. Possiamo pensare a questi computer come ad una sorta di “assistenti personali” che si prendono cura di molti aspetti della nostra vita. L’hardware degli elaboratori moderni è essenzialmente costruito per porci continuamente la domanda: “Cosa vorresti che faccia dopo?” I programmatori hanno affiancato all’hardware un sistema operativo e una serie di applicazioni che hanno permesso di ottenere un assistente personale digitale che si è dimostrato utile e capace di aiutarci svolgendo compiti diversi. I computer sono dotati di velocità oltre che di una grande quantità di memoria e potrebbero esserci estramente utili se solo conoscessimo la lingua per spiegare loro quello che vorremmo fosse “fatto dopo”. Se così fosse, potremmo dire al computer di svolgere compiti ripetitivi al nostro posto. Va tenuto a mente che il tipo di attività che i computer possono fare meglio sono spesso il genere di cose che noi umani troviamo più noiose e logoranti. What What What Next? Next? Next? What What What Next? Next? Next? Figura 1.1: Assistente Digitale Personale 1 2 CAPITOLO 1. PERCHÉ DOVRESTI IMPARARE A PROGRAMMARE? Pick Pick Pick Me! Me! Me! Pick Pick Buy Me! Me! Me :) Figura 1.2: I Programmatori ti parlano Per esempio leggere i primi tre paragrafi di questo capitolo ed individuare quante volte venga ripetuta la parola più comune. Anche se sei in grado di leggere e capire le parole in pochi secondi, contarle è piuttosto difficoltoso in quanto non è il tipo di problema per cui la nostra mente è stata concepita. Per un computer è l’opposto: leggere e capire il testo è difficoltoso mentre è molto più semplice contare le parole e indicarci quante volte è ripetuta la parola più usata. python words.py Enter file:words.txt to 16 Il nostro “assistente personale per l’analisi delle informazioni” ci ha rapidamente detto che la parola “to” è stata usata sedici volte nei primi tre paragrafi di questo capitolo. Il fatto che i computer siano bravi in attività in cui gli umani non lo sono, è il motivo per cui è necessario che tu diventi abile nel parlare un “linguaggio informatico”. Una volta che avrai imparato questa nuova lingua, potrai delegare al tuo partner (il computer) i compiti banali, ritagliandoti più tempo per le attività per cui sei più portato. In altre parole, tu apporti a questa collaborazione creatività, intuizione ed invettiva. 1.1 Creatività e motivazione Sebbene questo libro non sia destinato a programmatori professionisti, la program- mazione può essere un lavoro molto gratificante sia dal punto di vista finanziario sia da quello personale. Scrivere programmi utili, eleganti e intelligenti affinché possano essere utilizzati da altri è un’attività molto creativa. Il tuo computer o il tuo Assistente Personale Digitale (PDA) di solito ha al suo interno molti pro- grammi scritti da svariati team di sviluppatori, ciascuno dei quali in competizione per conquistare la tua attenzione ed interesse. Fanno del loro meglio per soddisfa- re le tue esigenze e fornirti, nel contempo, una meravigliosa esperienza d’uso. In alcune situazioni, quando si sceglie uno specifico software, i programmatori sono direttamente gratificati dalla tua scelta. Se pensiamo ai programmi come alla produzione creativa di team di programmatori, probabilmente la seguente immagine è una visione più ragionevole del nostro PDA: Per ora, la nostra motivazione principale non è guadagnare soldi o soddisfare altri utenti, ma piuttosto essere più efficienti nella gestione di dati e informazioni che incontreremo. In un primo momento, sarai sia lo sviluppatore sia l’utente finale 1.2. ARCHITETTURA HARDWARE DEL COMPUTER 3 What Software Next? Periferiche Central di input e Processing Rete di output Unit Memoria Memoria principale secondaria Figura 1.3: Architettura dell’hardware dei tuoi programmi. Appena migliorerai le tue capacità come programmatore e la programmazione ti sembrerà più creativa, potrai iniziare a pensare allo sviluppo di programmi per conto di terzi. 1.2 Architettura hardware del computer Prima di iniziare a imparare la lingua che useremo per sviluppare software, abbia- mo bisogno di memorizzare un piccolo numero di nozioni su cosa costituisca un computer. Se smonti il tuo computer o il tuo cellulare e ci guardi dentro, troverai le seguenti parti: Le definizioni di alto livello di quelle parti sono le seguenti: La Central Processing Unit (o CPU) è la parte del computer che è stata progettata per essere ossessionata dalla domanda “qual è la prossima istru- zione?”. Ad esempio se il tuo computer ha una frequenza di 3.0 Gigahertz, significa che la CPU si chiederà “qual è la prossima istruzione?” tre miliardi di volte al secondo. Avrai bisogno di imparare come parlare velocemente per poter stare al passo con la CPU. La Memoria principale viene utilizzata per memorizzare le informazioni di cui la CPU ha bisogno nel minore tempo possibile. La memoria principale è veloce quasi quanto la CPU ma le informazioni vengono memorizzate solo fino allo spegnimento del computer. Anche la Memoria secondaria è utilizzata per conservare informazioni ma è molto più lenta di quella principale. Il vantaggio della memoria secondaria è che può conservare le informazioni anche quando il computer è spento. Esem- pi di memorie secondarie sono i dischi rigidi o le memorie flash (generalmente pennette USB e lettori multimediali portatili). I Dispositivi di Input ed Output sono lo schermo, la tastiera, il mouse, il microfono, gli altoparlanti, il touchpad, ecc.. in altre parole tutti i dispositivi con cui interagisci per comunicare con il computer. Ormai la maggior parte dei computer ha anche una Connessione di rete uti- lizzata per scambiare informazioni con altri computer. Possiamo pensare alla 4 CAPITOLO 1. PERCHÉ DOVRESTI IMPARARE A PROGRAMMARE? What Software Next? Periferiche Central di input e Processing Rete di output Unit Memoria principale Memoria secondaria Figura 1.4: Dove sei? rete come ad una sorta di supporto molto lento per archiviare e recuperare dati che potrebbe non essere sempre disponibile. Quindi, in un certo senso, la rete è un tipo più lento e talvolta inaffidabile di memoria secondaria. Anche se è meglio lasciare ai costruttori di computer la maggior parte dei dettagli sul funzionamento di questi componenti, è utile conoscere un po’ di terminologia in modo da poterci riferire a questi diversi componenti mentre scriviamo i nostri programmi. Come sviluppatore, il tuo compito è quello di utilizzare e armonizzare ciascuna di queste risorse per risolvere problemi e analizzare i dati ottenuti. Come sviluppatore “parlerai” per lo più con la CPU indicandole cosa fare dopo. A volte dirai alla CPU di usare la memoria principale, la memoria secondaria, la rete o i dispositivi di input/output. Dovrai essere colui che risponderà alla domanda posta dalla CPU: “Quale è la prossima istruzione?”. Ma diciamocelo: sarebbe molto scomodo rimpicciolirsi a 5 mm di altezza e introdursi nel computer solo per poter dare comandi tre miliardi di volte al secondo. È più semplice scrivere in anticipo le istruzioni. Chiamiamo pro- gramma queste istruzioni memorizzate e programmazione l’atto di scrivere queste istruzioni e fare in modo che siano corrette. 1.3 Capire la Programmazione Nel resto di questo libro, cercherò di trasformarti in una persona esperta nell’arte della programmazione. Alla fine diventerai programmatore, forse non un program- matore professionista, ma almeno avrai le capacità per esaminare un problema relativo all’analisi di dati/informazioni e sviluppare un programma che lo risolva. In un certo senso, avrai bisogno di due abilità per diventare un programmatore: Per prima cosa, dovrai conoscere il linguaggio di programmazione (Python) di cui avrai bisogno di padroneggiare vocabolario e grammatica. Dovrai essere in grado di scrivere correntemente le parole e sapere come costruire frasi “ben strutturate”. In secondo luogo, avrai bisogno di “raccontare una storia”. Per scrivere una storia, devi combinare parole e frasi allo scopo di trasmettere un’idea al lettore. L’abilità 1.4. PAROLE E FRASI 5 nella produzione di storie è una capacità che si migliora scrivendo e ottenendo feedback. Nell’ambito della programmazione il nostro programma è la “storia” e il problema che stai cercando di risolvere è “l’idea”. Una volta che avrai imparato un linguaggio di programmazione come Python, sarà molto più facile impararne un secondo come JavaScript o C++. Sebbene il nuovo linguaggio di programmazione abbia un vocabolario ed una grammatica molto diversi rispetto a Python, la modalità di affrontare un problema è la medesima in tutti i linguaggi di programmazione. Imparai il “vocabolario” e le “frasi” di Python molto velocemente. Sarà, però, necessario un tempo maggiore per essere in grado di scrivere un programma che sia adatto a risolvere un problema nuovo. Si insegna a programmare in modo simile a come si insegna a scrivere: Inizieremo con il leggere e comprendere i programmi, quindi ne scriveremo alcuni semplici, in seguito scriveremo programmi sempre più complessi. Ad un certo punto “troverai la tua ispirazione” e riuscirai a vedere da solo lo schema e sarà più naturale affrontare un problema scrivendo un programma che lo risolva. Arrivati a questo punto, programmare diventerà un processo molto piacevole e creativo. Iniziamo intanto con il vocabolario e la struttura dei programmi in Python. Sii paziente: questi esempi semplici ti ricorderanno quando hai iniziato a leggere per la prima volta. 1.4 Parole e frasi A differenza della nostra lingua, il vocabolario di Python è in realtà piuttosto limitato. Chiameremo questo “vocabolario” parole riservate. Queste sono parole che hanno un significato molto speciale per Python. Quando le incontra in un suo script, per Python hanno un solo ed unico significato. Più tardi, quando scriverai codice, avrai la possibilità di creare altre parole cui assegnare un preciso significato: le variabili. Avrai una grande libertà nello scegliere i nomi per le variabili, ma comunque non potrai usare nessuna delle parole riservate come nome per una variabile. Nell’addestramento di un cane, vengono utilizzate parole speciali come “seduto”, “resta”, “porta”, ecc. Quando parli con un cane e non utilizzi nessuna delle parole riservate, ti guarderà in faccia con uno sguardo interrogativo fino a quando non sentirà una parola riservata. Ad esempio, se dici “Ogni giorno Luigi fa una passeg- giata per almeno due chilometri”, la maggior parte dei cani probabilmente capirà solo “bla bla bla passeggiata bla bla bla bla.” Questo perché solo “passeggiata” è una parola riservata nel linguaggio del cane. D’altro conto molti suggeriscono che il linguaggio tra umani e gatti non abbia parole riservate1. Tornando a Python, le parole riservate includono: and class elif for in nonlocal raise with as continue else from import not return yield assert def except global is or try break del finally if lambda pass while 1 http://xkcd.com/231/ 6 CAPITOLO 1. PERCHÉ DOVRESTI IMPARARE A PROGRAMMARE? Cioè, a differenza di un cane, Python è già stato completamente addestrato. Quan- do dici “try” (prova), Python proverà ogni volta senza fallire un colpo. A tempo debito impareremo l’utilizzo di queste parole riservate. Per ora ci concen- treremo sull’equivalente in Python di “parlare” (in linguaggio uomo-cane). Il bello di dire a Python di parlare è che possiamo persino indicargli cosa dire includendo un messaggio tra virgolette: print('Hello World!') Abbiamo persino scritto il nostro primo comando Python sintatticamente corretto. La frase inizia con la funzione print seguita da una stringa di testo a nostra scelta racchiusa tra virgolette singole. Le stringhe nelle istruzioni di stampa sono rac- chiuse tra le virgolette. Le virgolette singole e le virgolette doppie hanno la stessa funzione; la maggior parte delle persone utilizza le virgolette singole tranne in casi come questo in cui una virgoletta singola (che è anche un apostrofo) appare nella stringa. 1.5 Conversare con Python Ora che conosciamo una parola e una frase semplice in Python, abbiamo bisogno di sapere come avviare una conversazione con Python per testare le nostre nuove abilità linguistiche. Prima di poter dialogare con Python, dovresti installare il software Python nel tuo computer e imparare come avviarlo. Questa procedura è troppo dettagliata per essere inclusa in questo capitolo, quindi ti suggerisco di consultare [www.py4e.com] (http://www.py4e.com) dove ho scritto istruzioni dettagliate e screencast dell’in- stallazione e dell’avvio di Python su sistemi Macintosh e Windows. Ad un certo punto, potrai aprire un terminale o una finestra di comando e, digitando python, si avvierà l’interprete Python in modalità interattiva e verrà visualizzato qualcosa del genere: Python 3.5.1 (v3.5.1:37a07cee5969, Dec 6 2015, 01:54:25) [MSC v.1900 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> Python è pronto per conversare con voi: il prompt >>> è il modo di chiedere “Cosa vuoi che faccia dopo?” dell’interprete Python. Tutto quello che devi sapere è come comunicare in Python. Supponiamo, per esempio, che tu non sappia nemmeno le più basilari parole o frasi del linguaggio Python. Potresti voler utilizzare le linee guida che usano gli astronauti quando, atterrati su un pianeta lontano, vogliano comunicare con gli autoctoni: >>> I come in peace, please take me to your leader File "", line 1 1.5. CONVERSARE CON PYTHON 7 I come in peace, please take me to your leader ˆ SyntaxError: invalid syntax >>> Non sta andando molto bene: a meno che tu non pensi qualcosa velocemente, è probabile che gli abitanti del pianeta ti pugnalino con le loro lance, ti mettano su uno spiedo, ti arrostiscano sopra un fuoco e ti trasformino nel piatto principale della cena. Fortunatamente hai portato con te una copia di questo libro e hai il dito fermo in questa pagina. Riprova: >>> print('Hello world!') Hello world! Questo è molto più chiaro, quindi prova a comunicare ancora: >>> print('You must be the legendary god that comes from the sky') You must be the legendary god that comes from the sky >>> print('We have been waiting for you for a long time') We have been waiting for you for a long time >>> print('Our legend says you will be very tasty with mustard') Our legend says you will be very tasty with mustard >>> print 'We will have a feast tonight unless you say File "", line 1 print 'We will have a feast tonight unless you say ˆ SyntaxError: Missing parentheses in call to 'print' >>> La conversazione stava andando così bene, poi quando hai fatto l’errore più piccolo che si possa fare usando il linguaggio Python, “lui” ha tirato nuovamente fuori gli artigli. A questo punto, dovresti esserti reso conto che anche se Python è incredibilmente complesso, potente e schizzinoso sulla sintassi da utilizzare per comunicare con “lui”, non è affatto intelligente. In realtà stai solo avendo una conversazione con te stesso, ma usando una sintassi corretta. In un certo senso, quando utilizzi un programma scritto da qualcun altro, la con- versazione si realizza tra te e gli altri sviluppatori, con Python come intermediario. Per chi scrive codice Python è solo un modo di esprimere come dovrebbe procedere la conversazione. In soli pochi altri capitoli, sarai uno di quei programmatori che parlano agli utenti tramite il programma Python. Prima di lasciare la nostra prima conversazione con l’interprete Python, dovresti probabilmente conoscere il modo corretto per dire “arrivederci” alla fine di una conversazione con gli abitanti del Pianeta Python: >>> good-bye Traceback (most recent call last): 8 CAPITOLO 1. PERCHÉ DOVRESTI IMPARARE A PROGRAMMARE? File "", line 1, in NameError: name 'good' is not defined >>> if you don't mind, I need to leave File "", line 1 if you don't mind, I need to leave ˆ SyntaxError: invalid syntax >>> quit () Noterete che, nei due tentativi errati precedenti, l’errore è diverso. Nel secondo caso, if è una parola riservata e Python, vedendo la parola riservata, pensava che stessimo cercando di dirgli qualcosa, utilizzando una sintassi errata. Il modo corretto per dire “arrivederci” a Python è digitare quit() al prompt inte- rattivo >>>. Credo che ti ci sarebbe voluto un po’ per indovinarlo, quindi avere un libro sull’argomento a portata di mano probabilmente si rivelerà utile. 1.6 Terminologia: interprete e compilatore Python è un linguaggio di alto livello destinato a essere relativamente semplice da leggere e scrivere per gli umani e altrettanto semplice da leggere ed elaborare per i computer. Altri linguaggi di alto livello sono Java, C ++, PHP, Ruby, Basic, Perl, JavaScript ecc. Purtroppo l’attuale architettura della Central Processing Unit (CPU) non è in grado di capire nessuno di questi linguaggi di alto livello. La CPU comprende solo quello che chiamiamo linguaggio macchina. Il linguag- gio macchina è molto basilare e francamente molto stancante da scrivere poiché composto esclusivamente da zeri e uno: 001010001110100100101010000001111 11100110000011101010010101101101... Il linguaggio macchina a prima vista sembra abbastanza semplice, dato che ci sono solo zeri e uno, ma la sua sintassi è molto più complessa e molto più intricata di quella del Python. Pertanto pochissimi programmatori scrivono in linguaggio macchina. Piuttosto si preferisce utilizzare vari “traduttori” per consentire agli sviluppatori di scrivere in linguaggi di alto livello come Python o JavaScript e lasciare agli interpreti la conversione in linguaggio macchina per l’esecuzione da parte della CPU. Dato che il linguaggio macchina è legato all’hardware del computer, tale linguaggio non è trasferibile tra diversi tipi di hardware. Contrariamente i programmi scritti in linguaggi di alto livello possono essere spostati su architetture diverse utilizzando l’interprete presente sulla nuova macchina o ricompilando il codice per creare una versione in linguaggio macchina del programma adatta al nuovo sistema. Questi traduttori di linguaggi di programmazione si dividono in due categorie generali: (1) interpreti e (2) compilatori. Un interprete legge il codice sorgente del programma così come è stato scritto dal programmatore: analizza il codice sorgente e interpreta le istruzioni al volo. 1.6. TERMINOLOGIA: INTERPRETE E COMPILATORE 9 Python è un interprete, quando lo avviamo in modalità interattiva, digitiamo una riga (una frase) e Python la elabora immediatamente, rimanendo poi in attesa della successiva riga di Python. Alcune delle righe di Python avvisano Python che vuoi che lui ricordi un valo- re per un secondo momento. Va quindi scelto un nome per quel valore da ri- cordare e da utilizzare per recuperarlo in un secondo momento. Con il termine variabile facciamo riferimento alle etichette che usiamo per riferirci a questi dati memorizzati. >>> x = 6 >>> print(x) 6 >>> y = x * 7 >>> print(y) 42 >>> In questo esempio, stiamo chiedendo a Python di: - memorizzare il valore 6 e di adottare l’etichetta x per poter recuperare il valore in un secondo momento. - Poi, tramite il comando “Print”, verifichiamo che Python abbia effettivamente registra- to il valore assegnato alla variabile x. - Poi chiediamo a Python di recuperare x, moltiplicarlo per 7 e assegnare il nuovo risultato a y. - Infine chiediamo a Python di stampare il valore attualmente contenuto in y. Anche se stiamo digitando questi comandi una riga alla volta, Python li tratta come una sequenza ordinata di istruzioni permettendo alle successive istruzioni di essere in grado di recuperare i dati creati precedentemente. Noi abbiamo scritto il nostro primo semplice paragrafo composto di quattro frasi in un ordine logico e che abbia un significato. L’instaurare una conversazione interattiva simile alla precedente è nella natura di un interprete. Un compilatore invece necessita di avere l’intero codice sorgente di alto livello prima di avviare il processo di traduzione e successivo salvataggio in un file eseguibile per l’esecuzione. Nel sistema Windows, spesso questi eseguibili hanno un suffisso “.exe” o “.dll” che indicano rispettivamente “eseguibile” o libreria DLL. In Linux e MacOsx, non esiste un suffisso che contrassegni in modo univoco un file come eseguibile. Se aprissimo un file eseguibile con un editor di testo, il contenuto ci sembrerà completamente folle ed illeggibile: ^?ELF^A^A^A^@^@^@^@^@^@^@^@^@^B^@^C^@^A^@^@^@\xa0\x82 ^D^H4^@^@^@\x90^]^@^@^@^@^@^@4^@ ^@^G^@(^@$^@!^@^F^@ ^@^@4^@^@^@4\x80^D^H4\x80^D^H\xe0^@^@^@\xe0^@^@^@^E ^@^@^@^D^@^@^@^C^@^@^@^T^A^@^@^T\x81^D^H^T\x81^D^H^S ^@^@^@^S^@^@^@^D^@^@^@^A^@^@^@^A\^D^HQVhT\x83^D^H\xe8.... Non è semplice leggere o scrivere in linguaggio macchina, quindi è utile che si possa disporre di interpreti e compilatori che permettano di scrivere in linguaggi di alto livello come Python o C. 10 CAPITOLO 1. PERCHÉ DOVRESTI IMPARARE A PROGRAMMARE? Ora, a questo punto della nostra discussione su compilatori e interpreti, ti starai chiedendo qualcosa sull’interprete di Python. In che linguaggio è stato scritto? È scritto in un linguaggio compilato? Cosa succede esattamente quando digitiamo “Python”? L’interprete di Python è scritto in un linguaggio di alto livello chiamato “C”. Puoi dare un’occhiata all’attuale codice sorgente dell’interprete andando nel si- to [www.python.org] (http://www.python.org), nella sezione dedicata al codice sorgente. Quindi Python è esso stesso un programma compilato in linguaggio mac- china. Quando hai installato Python nel tuo computer (o se è stato installato dal venditore), hai copiato una versione in linguaggio macchina adatta per il tuo sistema. In Windows, il linguaggio macchina eseguibile per lo stesso Python è probabilmente in un file con un nome simile a: C:\Python35\python.exe Questo è più di quanto tu abbia davvero bisogno di sapere per essere un program- matore Python, ma a volte è utile rispondere subito a quelle piccole fastidiose domande. 1.7 Scrivere un programma Digitare comandi nell’interprete di Python è un ottimo modo per sperimenta- re le funzionalità di Python, ma non è consigliabile per risolvere i problemi più complessi. Quando vogliamo scrivere un programma, possiamo utilizzare un editor di testo per scrivere le istruzioni Python in un file chiamato script. Per convenzione, gli script Python terminano con l’estensione.py. Per eseguire uno script, devi indicare all’interprete Python il nome del file. Ad esempio in una finestra di comando di Unix o Windows, puoi digitare python hello.py come nel codice sottostante: csev$ cat hello.py print('Hello world!') csev$ python hello.py Hello world! csev$ Il “csev$” è il prompt del sistema operativo e “cat hello.py” mostra che il file “hello.py” ha una riga di codice Python per stampare una stringa. Avvia l’interprete di Python dicendogli di leggere il codice sorgente dal file “hel- lo.py” invece di chiederti in modo interattivo linee di codice. Noterai che non è stato necessario inserire quit() alla fine del programma Python. Quando Python legge il tuo codice sorgente da un file, sa di doversi fermare quando raggiunge la fine del file. 1.8. COS’È UN PROGRAMMA? 11 1.8 Cos’è un programma? Si potrebbe definire il termine programma nella sua accezione più basilare come una sequenza di istruzioni Python scritte per eseguire un’azione. Anche il tuo semplice script hello.py è un programma: è composto da una sola riga non particolarmente utile ma, nella definizione più rigorosa, rimane un programma Python. Per meglio capire cosa sia un programma potrebbe essere più facile pensare ad un problema e, di conseguenza, cercando un programma che possa risolvere tale problema. Diciamo che stai facendo ricerche di Social Computing su alcuni post di Facebook e ti interessa la parola più frequentemente usata in una serie di post. Potresti stampare il flusso dei post di Facebook e scorrere il testo per cercare la parola più comune, ma tale operazione ti richiederebbe molto tempo e sarebbe soggetta a molti errori. Sarebbe meglio scrivere un programma in Python per gestire l’attività in modo rapido e preciso, in modo da poter trascorrere il fine settimana facendo qualcosa di divertente. Ad esempio, considera il seguente testo riguardante un clown e una macchina. Guarda il testo e cerca di capire quale sia la parola più comune e quante volte si ripete. the clown ran after the car and the car ran into the tent and the tent fell down on the clown and the car Quindi immagina di svolgere questo compito guardando milioni di righe di testo. Onestamente, è più rapido imparare Python e scrivere un programma per contare le parole, di quanto non sia fare la scansione manuale delle parole. La notizia ancora migliore è che ho già creato un semplice programma per trovare la parola più comune in un file di testo. L’ho scritto, l’ho testato e adesso te lo sto dando per usarlo e risparmiare un po’ di tempo. name = input('Enter file:') handle = open(name, 'r') counts = dict() for line in handle: words = line.split() for word in words: counts[word] = counts.get(word, 0) + 1 bigcount = None bigword = None for word, count in list(counts.items()): if bigcount is None or count > bigcount: bigword = word bigcount = count print(bigword, bigcount) # Code: http://www.py4e.com/code3/words.py 12 CAPITOLO 1. PERCHÉ DOVRESTI IMPARARE A PROGRAMMARE? Non hai nemmeno bisogno di conoscere Python per utilizzare questo script. Hai bisogno di completare il Capitolo 10 di questo libro per comprendere appieno le fantastiche tecniche utilizzate per realizzare il programma. Tu sei l’utente finale, usa semplicemente il programma e stupisciti della sua utilità e di come ti abbia risparmiato così tanto lavoro manuale. Basta digitare il codice in un file chiamato words.py oppure scaricare il codice sorgente da http://www.py4e.com/code3/ ed eseguirlo. Questo è un buon esempio di come Python e il linguaggio Python agiscano come intermediario tra te (l’utente finale) e me (lo sviluppatore). Python è un modo per scambiare sequenze di istruzioni utili (es. programmi) in un linguaggio comune che possa essere utilizzato da chiunque installi Python sul proprio computer. Nessuno di noi sta quindi parlando a Python, piuttosto comunichiamo con altri attraverso Python. 1.9 I blocchi per costruire i programmi Nei prossimi capitoli approfondiremo maggiormente il vocabolario, la struttura delle frasi e dei paragrafi e la storia di Python. Impareremo inoltre a conoscere le potenti funzionalità di Python e come unirle per creare programmi utili. Esistono alcuni modelli concettuali di basso livello che usiamo per progettare pro- grammi. Questi costrutti non si limitano solo agli script Python ma sono applicabili ad ogni altro linguaggio di programmazione, dal linguaggio macchina fino a quelli di alto livello. input Ottieni dati dal “mondo esterno”: Potrebbe trattarsi della lettura di dati contenuti in un file, oppure direttamente da un sensore come un microfo- no o un GPS. Nei nostri programmi iniziali, il nostro input verrà inserito direttamente dall’utente tramite tastiera. output Visualizza i risultati su schermo o li memorizza in un file o magari li invia ad un dispositivo come un altoparlante per riprodurre musica o leggere del testo. esecuzione sequenziale Esegui le istruzioni una dopo l’altra nell’ordine in cui sono state scritte nel codice. esecuzione condizionale Verifica le condizioni previste ed esegui, o salta, una sequenza di istruzioni. esecuzione ripetuta Esegui ripetutamente alcune istruzioni, spesso con alcune variazioni. riutilizzo Scrivi una volta una serie di istruzioni e dà loro un nome per poi, even- tualmente, riutilizzare quelle istruzioni durante l’esecuzione del programma. Sembra quasi troppo semplice per essere vero? Ovviamente non è mai così semplice. Sarebbe come dire che camminare è semplicemente “mettere un piede davanti all’altro”. L’“arte” di scrivere un programma è il comporre ed unire molte volte questi elementi di base per produrre un qualcosa che sia utile ai propri utenti. Ad esempio, il precedente script per il conteggio delle parole utilizza quasi tutti questi modelli. 1.10. COSA POTREBBE ANDARE STORTO? 13 1.10 Cosa potrebbe andare storto? Come abbiamo visto nelle nostre precedenti conversazioni con Python, dobbiamo comunicare in modo molto preciso quando scriviamo il codice. La più piccola deviazione o errore farà sì che Python smetta di leggere il programma. I programmatori alle prime armi spesso citano il fatto che Python non lasci spazio ad errori come prova che Python sia cattivo, odioso e crudele. Anche se sembra collaborare con tutti gli altri, Python riconosce i principianti e porta loro ranco- re. A causa di questo rancore, Python prende i nostri script scritti in maniera impeccabile e li rigetta come “inadatti” solo per tormentarci. >>> primt 'Hello world!' File "", line 1 primt 'Hello world!' ˆ SyntaxError: invalid syntax >>> primt ('Hello world') Traceback (most recent call last): File "", line 1, in NameError: name 'primt' is not defined >>> I hate you Python! File "", line 1 I hate you Python! ˆ SyntaxError: invalid syntax >>> if you come out of there, I would teach you a lesson File "", line 1 if you come out of there, I would teach you a lesson ˆ SyntaxError: invalid syntax >>> Si ottiene poco discutendo con Python: è solo uno strumento, non ha emozioni ed è pronto a servirti ogni volta che tu ne abbia bisogno. I suoi messaggi di errore sono inclementi, ma rappresentano solo la richiesta di aiuto di Python: ha esaminato ciò che hai digitato e semplicemente non riesce a capire cosa tu voglia da lui. Python è molto più simile a un cane, che amandovi incondizionatamente e cono- scendo poche parole chiave, ti guarda dolcemente (>>>), aspettando che tu dica qualcosa che sia in grado di capire. Quando Python visualizza “SyntaxError: in- valid syntax”, sta dicendo, scodinzolando, “Mi sembra che tu abbia detto qualcosa ma non ne capisco il significato; per favore continua a parlarmi (>>>).” Man mano che i tuoi programmi diventeranno più sofisticati, potresti incappare in queste tre tipologie di errore: Errori di sintassi Questi sono i primi errori che farai e sono i più facili da correg- gere. Un errore di sintassi indica che hai violato le regole della “grammatica” di Python. Python farà del suo meglio per puntare direttamente alla riga e 14 CAPITOLO 1. PERCHÉ DOVRESTI IMPARARE A PROGRAMMARE? al carattere in cui ha rilevato un errore. L’unico inconveniente degli errori di sintassi è che a volte l’errore che deve essere corretto è in realtà in una fase precedente del programma rispetto al punto in cui Python si è accorto di essere confuso. Quindi la riga e il carattere in cui Python indica la presenza di un errore di sintassi potrebbe rappresentare solo il punto di partenza della tua ricerca. Errori di logica: Un errore logico si verifica quando il tuo programma ha una buona sintassi ma c’è un errore nell’ordine delle istruzioni o forse un errore nel come queste si relazionino l’una all’altra. Un buon esempio di errore di logica potrebbe essere: “bevi un sorso dalla tua bottiglia d’acqua, mettila nel tuo zaino, cammina fino alla biblioteca e poi rimetti il tappo alla bottiglia”. Errori di Semantica Un errore semantico si verifica quando la descrizione dei passaggi da eseguire è sintatticamente perfetta e nel giusto ordine, ma c’è un errore nel programma. Il programma è completamente corretto ma non fa ciò che intendi fargli fare. Un semplice esempio potrebbe essere il dare ad una persona le indicazioni per un ristorante dicendo: “... quando raggiungi l’incrocio con la stazione di benzina, gira a sinistra e procedi per 1 km. Il ristorante è l’edificio rosso sulla sinistra.” Il tuo amico è molto in ritardo e ti chiama per dirti di trovarsi in una fattoria e che si sta aggirando dietro un granaio, senza trovare alcuna traccia del ristorante. “Ma hai girato a sinistra o a destra alla stazione di servizio?” e lui risponde “ho seguito le tue indicazioni alla lettera, le ho perfino annotate: dicono di girare a sinistra dal distributore di benzina e procedere per un km.” “Mi dispiace molto, perché nonostante le mie istruzioni fossero sintatticamente corrette, purtroppo contenevano un piccolo errore semantico non rilevato”. Ribadisco che in tutte e tre le tipologie di errori, Python sta semplicemente facendo del suo meglio per fare esattamente quello che gli hai chiesto. 1.11 Il percorso di studio Mentre prosegui nella lettura di questo libro, non aver paura se i concetti non sembrano amalgamarsi bene l’uno all’altro sin da subito. Quando stavi imparando a parlare, non è stato un problema se hai passato i primi anni producendo solo dei dolci gorgoglii. Non c’erano problemi se ci sono voluti sei mesi per passare da un vocabolario limitato a semplici frasi, se ci sono voluti 5 o 6 anni in più per passare da frasi a paragrafi e ancora qualche anno per essere in grado di scrivere un avvincente racconto breve. Poiché vorremmo che tu possa imparare Python rapidamente, ti insegneremo tutto nei prossimi capitoli. Sarà come imparare un nuovo linguaggio che richiede tem- po per essere assorbito e compreso prima che diventi naturale. Ciò causerà una certa confusione mentre vedremo e rivedremo argomenti cercando di farti vedere il quadro generale definendo i piccoli frammenti che lo compongono. Nonostante il libro sia scritto in modo lineare, ed anche se stai seguendo un corso che proseguirà linearmente, non esitare ad essere molto non-lineare nel modo in cui ti approcci ai contenuti. Sbircia avanti e indietro e leggi ciò che ti pare. Sfogliando il mate- riale più avanzato senza comprenderne appieno i dettagli, potresti capire meglio il “perché?” della programmazione. Rivedendo il materiale precedente o rifacen- 1.12. GLOSSARIO 15 do gli esercizi precedenti, realizzerai che in realtà hai imparato molto anche se il materiale che stai fissando ora sembra un po’ imperscrutabile. Capita spesso che quando stai imparando il tuo primo linguaggio di programma- zione, ci siano alcuni meravigliosi momenti di stupore in cui, mentre sei intento a scalfire la tua pietra con martello e scalpello, puoi alzare lo sguardo e cominciare a vedere che stai davvero realizzando una bellissima scultura. Di solito è inutile restare svegli tutta la notte a fissare qualcosa che sembra particolarmente difficile. Fai una pausa, fai un pisolino, mangia uno spuntino, spiega a qualcuno in cosa stai avendo problemi (magari solo al tuo cane), così da ritornare al problema con occhi nuovi. Ti assicuriamo che una volta acquisiti i rudimenti della programmazione descritti nel libro, ti guarderai indietro e vedrai che tutto è stato molto semplice ed elegante e ti ha solo richiesto un po’ di tempo per assimilarlo. 1.12 Glossario Bug Un errore in un programma. Central processing unit Chiamato anche “CPU” o “processore”. È il cuore di qualsiasi computer ed è ciò che gestisce il codice che scriviamo. Compilare Tradurre completamente in una sola volta un programma scritto in un linguaggio di alto livello in un linguaggio di basso livello, in preparazione per l’esecuzione successiva. Linguaggio di alto livello Un linguaggio di programmazione come Python pro- gettato per essere facilmente letto e scritto dagli umani. Modalità interattiva Un modo di utilizzare l’interprete Python digitando sin- goli comandi e espressioni al prompt. Interprete Eseguire un programma scritto in un linguaggio di alto livello tradu- cendo una riga alla volta. Linguaggio di basso livello Un linguaggio di programmazione progettato per essere eseguito da un computer; è chiamato anche “codice macchina” o “linguaggio assembly”. Codice macchina Il linguaggio di livello più basso, è il linguaggio che viene eseguito direttamente dall’unità di elaborazione centrale (CPU). Memoria principale Conserva programmi e dati. La memoria principale perde le sue informazioni memorizzate quando il computer viene spento. Analizzare Esaminare un programma e analizzare la struttura sintattica. Portabilità Proprietà di un programma che gli permette di essere eseguito su più di un tipo di computer. Funzione di stampa Istruzione che fa in modo che l’interprete Python visualizzi un valore su schermo. Risoluzione dei problemi Il processo composto da formulare un problema, ri- cercare una soluzione e fornire la soluzione. Programma Un set di istruzioni che specifica un calcolo. Prompt Si verifica quando un programma visualizza un messaggio a schermo e si interrompe affinché l’utente possa digitare un input destinato al programma. Memoria secondaria Generalmente più lenta della memoria principale, memo- rizza programmi e dati e ne conserva le informazioni anche quando viene tolta l’alimentazione. Esempi includono l’unità disco o la memoria flash nelle chiavette USB. 16 CAPITOLO 1. PERCHÉ DOVRESTI IMPARARE A PROGRAMMARE? Semantica Il significato di un programma. Errore semantico Errore in un programma che gli fa fare qualcosa di diverso da quello previsto dallo sviluppatore. Codice sorgente Un programma scritto in un linguaggio di alto livello. 1.13 Esercizi Esercizio 1: Quale è la funzione della memoria secondaria in un computer? a) Esegue tutto il calcolo e la logica del programma b) Recupera pagine Web da Internet c) Conserva le informazioni a lungo termine, anche oltre un ciclo di alimentazione d) Accetta input dall’utente Esercizio 2: Che cos’è un programma? Esercizio 3: Quale è la differenza tra un compilatore e un interprete? Esercizio 4: Quale delle seguenti alternative contiene “codice macchina”? a) L’interprete di Python b) La tastiera c) Un file sorgente di Python d) Un documento di elaborazione di testo Esercizio 5: Cosa c’è di errato nel codice seguente?: >>> primt 'Hello world!' File "", line 1 primt 'Hello world!' ˆ SyntaxError: invalid syntax >>> Esercizio 6: Dove viene memorizzata una variabile “x” simile a quella scritta dopo la seguente linea Python? x = 123 a) Unità di elaborazione centrale b) Memoria Principale c) Memoria Secondaria d) Dispositivi di input e) Dispositivi di output Esercizio 7: Cosa verrà visualizzato dal questo programma?: x = 43 x = x + 1 print(x) 1.13. ESERCIZI 17 a) 43 b) 44 c) x + 1 d) Errore perché x = x + 1 non è matematicamente possibile Esercizio 8: Illustra ognuno dei seguenti esempi facendo dei paragoni con una capacità degli uomini: (1) Unità centrale di elaborazione, (2) Memoria principale, (3) Memoria secondaria, (4) Dispositivo di input e (5) Dispositivo di Output. Ad esempio, “Qual è l’equivalente nell’uomo di una”Unità di elaborazione centrale"? Esercizio 9: Come si corregge un “Syntax Error”? 18 CAPITOLO 1. PERCHÉ DOVRESTI IMPARARE A PROGRAMMARE? Capitolo 2 Variabili, espressioni ed istruzioni 2.1 Valori e tipi Un valore, come una lettera o un numero, è un elemento basilare che permette ad un programma di funzionare. I valori che abbiamo visto finora sono 1, 2 e “Hello, World!”. Questi valori appartengono a diversi tipi: 2 è un numero intero mentre “Hello, World!” è una stringa, così chiamata perché composta da una “stringa” di lettere. Tu (insieme all’interprete) puoi identificare le stringhe poiché racchiuse tra virgolette. L’istruzione print funziona anche con i numeri interi, tramite il comando python è possibile avviare l’interprete. python >>> print(4) 4 Se non sei sicuro a quale tipo appartenga uno specifico valore, puoi consultare l’interprete. >>> type('Hello, World!') >>> type(17) Non c’è da sorprendersi se le stringhe appartengono al tipo str e i numeri interi appartengono al tipo int. È meno ovvio che i numeri con un punto decimale appartengano al tipo chiamato float. Ciò è dovuto al fatto che questi numeri siano rappresentati in un formato chiamato a virgola mobile. >>> type(3.2) 19 20 CAPITOLO 2. VARIABILI, ESPRESSIONI ED ISTRUZIONI E per quanto riguarda valori come “17” e “3.2”? Pur sembrando numeri sono racchiusi tra virgolette come le stringhe. >>> type('17') >>> type('3.2') In realtà sono stringhe vere e proprie. Quando inserisci un numero intero di gran- di dimensioni, come “1,000,000”, potresti essere tentato di utilizzare le virgole a gruppi di tre cifre. Questo non è un numero intero consentito in Python, anche se sembra scritto correttamente: >>> print(1,000,000) 1 0 0 Beh, non è per niente quello che ci aspettavamo! Python interpreta 1,000,000 come se fosse una sequenza di numeri interi separati da virgole, che visualizza inserendo uno spazio in corrispondenza della virgola. Questo è il primo esempio di errore semantico che vediamo: il codice viene eseguito senza visualizzare messaggi di errore ma non fa l’operazione per la quale pensavamo di averlo progettato. 2.2 Variabili Una delle più potenti funzionalità di un linguaggio di programmazione è la capacità di manipolare variabili. Una variabile è un nome assegnato ad un valore. Tramite un’istruzione di assegnazione hai la capacità di creare nuove variabili ed assegnare loro un valore: >>> message = 'And now for something completely different' >>> n = 17 >>> pi = 3.1415926535897931 In questo esempio vengono fatte tre assegnazioni: la prima assegna una stringa ad una nuova variabile chiamata message, la seconda assegna il numero intero 17 alla variabile n, la terza assegna il valore (approssimativo) di π a pi. È possibile usare l’istruzione print per visualizzare il valore di una variabile: >>> print(n) 17 >>> print(pi) 3.141592653589793 Il tipo di una variabile è il tipo di valore a cui essa è collegata. >>> type(message) >>> type(n) >>> type(pi) 2.3. NOMI DELLE VARIABILI E PAROLE CHIAVI 21 2.3 Nomi delle variabili e parole chiavi Normalmente i programmatori scelgono nomi per le loro variabili che siano signifi- cativi e documentino l’utilizzo della variabile. Questi nomi, di lunghezza arbitraria, possono contenere sia lettere sia numeri ma non possono iniziare con un numero. Anche se è possibile utilizzare lettere maiuscole, è preferibile iniziare i nomi delle variabili con una lettera minuscola (in seguito ne vedremo il motivo). Il carattere underscore (_) appare nel nome di una variabile ed è spesso utilizzato in nomi composti da più parole, come my_name o airspeed_of_unladen_swallow. I nomi delle variabili possono iniziare con il carattere underscore, ma generalmente evi- tiamo di farlo a meno che il codice che stiamo scrivendo sia contenuto in librerie che verranno utilizzate da altri. Se assegni ad una variabile un nome non valido, provocherai un errore di sintassi: >>> 76trombones = 'big parade' SyntaxError: invalid syntax >>> more@ = 1000000 SyntaxError: invalid syntax >>> class = 'Advanced Theoretical Zymurgy' SyntaxError: invalid syntax Il nome 76trombones non è valido perché inizia con un numero, more@, invece, perché contiene il carattere non ammesso ‘@’. Ma cosa c’è di errato in class? Risulta che class è una delle parole riservate di Python. L’interprete utilizza queste parole per riconoscere la struttura del programma, quindi non possono essere assegnate alle variabili. Python si riserva 33 parole chiave: and del from None True as elif global nonlocal try assert else if not while break except import or with class False in pass yield continue finally is raise def for lambda return E’ meglio tenere questo elenco a portata di mano: se l’interprete si lamenta del nome di una delle tue variabili e non ne capisci il motivo, verifica se questa sia presente nella lista. 2.4 Istruzioni L’istruzione è un’unità minima di codice che può essere eseguita dall’interprete di Python. Abbiamo visto due tipi di istruzioni: Print utilizzato sia come istruzione di un’espressione sia come un’assegnazione. Quando digiti un’istruzione in moda- lità interattiva, l’interprete la esegue e, nel caso esista, ne visualizza il risultato. Generalmente uno script contiene una sequenza di istruzioni. Se c’è più di un’istru- zione i risultati vengono visualizzati uno alla volta mano a mano che le istruzioni vengono eseguite. Ad esempio: 22 CAPITOLO 2. VARIABILI, ESPRESSIONI ED ISTRUZIONI print(1) x = 2 print(x) produce l’output 1 2 Ricorda che le istruzioni di assegnazione non producono output. 2.5 Operatori e operandi Gli operatori sono simboli speciali che rappresentano calcoli come l’addizione e la moltiplicazione. I valori a cui è applicato l’operatore sono chiamati operandi. Gli operatori +, -, *, /, e ** eseguono rispettivamente le operazioni di addizione, sottrazione, moltiplicazione, divisione, ed elevamento a potenza, come illustrato negli esempi seguenti: 20+32 hour-1 hour*60+minute minute/60 5**2 (5+9)*(15-7) Nel passaggio tra Python 2.x e Python 3.x è stato modificato l’operatore della divisione: ora il risultato viene rappresentato in virgola mobile: >>> minute = 59 >>> minute/60 0.9833333333333333 In Python 2.x l’operatore avrebbe diviso i due interi e troncato il risultato resti- tuendo un valore intero: >>> minute = 59 >>> minute/60 0 Per ottenere lo stesso risultato in Python 3.x, bisogna utilizzare la divisione intera (// intero). >>> minute = 59 >>> minute//60 0 In Python 3.x la divisione integer funziona molto più similmente a come ci si aspetterebbe se si inserisse l’espressione su una calcolatrice. 2.6. ESPRESSIONI 23 2.6 Espressioni L’espressione è una combinazione di valori, variabili e operatori. Sia un unico valore o una variabile sono considerati un’espressione. Pertanto le seguenti sono tutte espressioni corrette (posto che sia stato assegnato un valore alla variabile x) 17 x x + 17 Se digiti un’espressione in modalità interattiva, l’interprete la calcolerà e ne visua- lizzerà il risultato: >>> 1 + 1 2 Una cosa che crea spesso confusione tra i principianti è un’espressione presente in uno script, da sola non restituisce alcun risultato. Esercizio 1: Digita le seguenti istruzioni nell’interprete Python ed osserva il loro comportamento: 5 x = 5 x + 1 2.7 Ordine delle operazioni Quando appare più di un operatore in un’espressione, l’ordine di calcolo è regolato dalle regole di precedenza. Per quanto riguarda gli operatori matematici, Python segue le convenzioni matematiche. L’acronimo PEMDAS è utile per ricordare le regole: Parentesi: hanno la precedenza più alta e possono essere utilizzate per co- stringere il computer a svolgere un’espressione nell’ordine desiderato. Poiché le espressioni tra parentesi vengono valutate per prime: 2 * (3-1) è uguale a 4 e (1 + 1) ** (5-2) a 8. Puoi anche utilizzare le parentesi per rende- re l’espressione più leggibile, come in (minuto * 100) / 60, senza che ciò cambi il risultato. L’Elevamento a potenza ha il livello di precedenza immediatamente succes- sivo, pertanto 2 ** 1 + 1 è pari a 3 e non a 4, e 3 * 1 ** 3 è uguale a 3 e non 27. Le M oltiplicazioni e le Divisioni hanno la stessa precedenza, superiore alle Addizioni e alle Sottrazioni, che posseggono lo stesso livello di precedenza. Quindi 2 * 3-1 darà come risultato 5, non 4, e 6 + 4 / 2 darà 8.0 e non 5. Gli operatori con la stessa precedenza vengono calcolati da sinistra a destra: L’espressione 5-3-1 ha come risultato 1 e non 3, perché 5-3 viene svolta per prima e solo dopo viene sottratto 1 da 2. In caso di dubbio, utilizza sempre le parentesi nelle tue espressioni, per essere sicuro che i calcoli siano eseguiti nell’ordine desiderato. 24 CAPITOLO 2. VARIABILI, ESPRESSIONI ED ISTRUZIONI 2.8 Operatore modulo L’operatore modulo viene applicato a numeri interi e fornisce come risultato il resto di quando il primo operando viene diviso per il secondo. In Python, l’operatore modulo è il carattere percentuale (%). La sintassi è la stessa degli altri operatori: >>> quotient = 7 // 3 >>> print(quotient) 2 >>> remainder = 7 % 3 >>> print(remainder) 1 Quindi 7 diviso per 3 fa 2 con il resto di 1. L’operatore modulo si può rivelare sor- prendentemente utile. Per esempio, è possibile verificare se un numero è divisibile per un altro: se x%y fa zero, allora x è divisibile per y. È inoltre possibile ricavare da un numero quale sia il valore della cifra o delle cifre più a destra. Per esempio, x % 10 restituisce la cifra più a destra di x (in base 10). In modo simile, x% 100 restituisce le ultime due cifre. 2.9 Operazioni con le stringhe L’operatore + opera con le stringhe, senza essere un’addizione in senso stretta- mente matematico. Esegue invece una concatenazione: unisce insieme le stringhe collegando la seconda dopo l’ultimo carattere della prima. Per esempio: >>> first = 10 >>> second = 15 >>> print(first+second) 25 >>> first = '100' >>> second = '150' >>> print(first + second) 100150 L’output di questo script è 100150. L’operatore * lavora anche con le stringhe moltiplicando il contenuto di una stringa per un numero intero. Per esempio: >>> first = 'Test ' >>> second = 3 >>> print(first * second) Test Test Test 2.10 Chiedere un valore in input all’utente A volte potrebbe essere necessario richiedere all’utente di inserire il valore di una variabile. Python è dotato di una funzione chiamata input in grado di ricevere 2.10. CHIEDERE UN VALORE IN INPUT ALL’UTENTE 25 input dalla tastiera1. Quando si utilizza questa funzione il programma si arresta in attesa che l’utente digiti qualcosa. Quando l’utente preme Invio o Enter, l’ese- cuzione del programma riprende e input restituisce come stringa ciò che l’utente ha digitato. >>> inp = input() Some silly stuff >>> print(inp) Some silly stuff Prima di ricevere input dall’utente, è solitamente una buona idea visualizzare un prompt che informi l’utente sul cosa inserire. È possibile indicare una stringa alla funzione input affinché venga visualizzata prima della pausa d’attesa dell’input: >>> name = input('What is your name?\n') What is your name? Chuck >>> print(name) Chuck La sequenza \n alla fine del prompt indica un andare a capo ed è un carattere speciale che causa l’interruzione della linea. Ecco perché l’input dell’utente appare sotto il prompt. Se ti aspetti che l’utente digiti un intero, è possibile provare a convertire il valore restituito in int usando la funzione int(). >>> prompt = 'What...is the airspeed velocity of an unladen swallow?\n' >>> speed = input(prompt) What...is the airspeed velocity of an unladen swallow? 17 >>> int(speed) 17 >>> int(speed) + 5 22 Ma se l’utente inserisce qualcosa di diverso da una stringa composta da cifre, viene visualizzato un messaggio d’errore: >>> speed = input(prompt) What...is the airspeed velocity of an unladen swallow? What do you mean, an African or a European swallow? >>> int(speed) ValueError: invalid literal for int() with base 10: Vedremo in seguito come gestire questo tipo di errore. 1 In Python 2.0, questa funzione era raw_input. 26 CAPITOLO 2. VARIABILI, ESPRESSIONI ED ISTRUZIONI 2.11 Commenti Man mano che i programmi diventano più grandi e complessi, questi diventano più difficili da leggere. I linguaggi formali sono condensati ed è spesso difficile esaminare un pezzo di codice e capire cosa o perché faccia qualcosa. Per questo motivo, è una buona idea aggiungere alcune note ai vostri programmi per spiegare in linguaggio naturale cosa stia facendo il programma. Queste note, che in Python iniziano con il simbolo #, sono chiamate commenti: # compute the percentage of the hour that has elapsed percentage = (minute * 100) / 60 In questo caso, il commento appare da solo su una riga. Potete anche inserire commenti alla fine di una riga: percentage = (minute * 100) / 60 # percentage of an hour Tutto ciò che è compreso tra “#” e la fine della riga viene ignorato e non ha alcun effetto sul programma. I commenti sono ancor più utili quando documentano funzionalità del codice non così evidenti. Anche se è ragionevole presumere che chi legge il codice possa capire cosa questo faccia, è molto più utile spiegarne il perché. Questo commento al codice è superfluo ed inutile: v = 5 # assign 5 to v Questo commento, invece, contiene informazioni utili che non sono comprese nel codice: v = 5 # velocity in meters/second. Assegnare nomi adeguati alle variabili può ridurre la necessità di commenti, ma i nomi lunghi possono rendere difficili da leggere le espressioni complesse, pertanto esiste un compromesso. 2.12 Scegliere nomi mnemonici delle variabili Finché seguirai le semplici regole di denominazione delle variabili evitando le parole riservate, avrai ampia libertà d’azione nella scelta del loro nome. All’inizio questa scelta può essere fonte di confusione quando leggi o scrivi un programma. Ad esempio, i tre script seguenti seppur identici in termini di funzionalità, sembrano molto diversi quando li leggi e provi a capirne il funzionamento. a = 35.0 b = 12.50 c = a * b print(c) 2.12. SCEGLIERE NOMI MNEMONICI DELLE VARIABILI 27 hours = 35.0 rate = 12.50 pay = hours * rate print(pay) x1q3z9ahd = 35.0 x1q3z9afd = 12.50 x1q3p9afd = x1q3z9ahd * x1q3z9afd print(x1q3p9afd) Python interpreta tutti e tre esattamente allo stesso modo mentre noi umani leg- giamo e comprendiamo questi programmi in modo abbastanza diverso. Si capisce velocemente lo scopo del secondo esempio poiché lo sviluppatore ha scelto il no- me delle variabili pensando a quali dati saranno memorizzati in ciascuna di esse. Chiamiamo questi nomi di variabili così saggiamente scelti “nomi mnemonici delle variabili”. La parola mnemonico2 significa letteralmente “aiuto per la memoria”. Scegliamo nomi mnemonici per le variabili principalmente per aiutarci a ricordare il perché le abbiamo create. Mentre tutto ciò sembra grandioso, i nomi delle va- riabili mnemonici possono essere d’intralcio alla capacità di uno sviluppatore alle prime armi di analizzare e comprendere un codice. Questo perché gli sviluppatori principianti non hanno ancora memorizzato le parole riservate (ce ne sono solo 33) e talvolta variabili con nomi troppo descrittivi iniziano a sembrare parte del lin- guaggio e non solo nomi di variabili ben scelti. Dai una rapida occhiata al seguente codice esempio di Python che viene eseguito ripetutamente (in loop) su alcuni dati. Affronteremo presto i loop, ma per ora cerca di capire che cosa significhi: for word in words: print(word) Cosa sta succedendo? Quali parole (for, word, in, ecc.) sono parole riservate e quali sono solo variabili? Python riesce a capire a livello fondamentale la nozione di parole? I programmatori principianti hanno difficoltà a distinguere quali parti del codice debbano restare invariate, come in questo esempio, e quali parti del codice siano semplicemente scelte fatte dallo sviluppatore. Il seguente codice equivale al precedente: for slice in pizza: print(slice) Per il programmatore alle prime armi è più facile leggere questo script per sapere quali parti siano parole riservate di Python e quali parti siano semplicemente va- riabili. È abbastanza chiaro che Python non conosce la nozione di pizza e trancio (slice) e che una pizza sia composta da un insieme di uno o più tranci. Ma se il nostro programma riguarda veramente la lettura di dati e la ricerca di parole nei dati, pizza e slice non sono per niente nomi mnemonici di variabili. Sceglierli come nomi di variabili ci distrae dallo scopo del programma. Dopo un breve perio- do di tempo, conoscerai le più comuni parole riservate e inizieranno a saltarti agli occhi: 2 Vedi http://www.treccani.it/vocabolario/mnemonico/ per un’estesa descrizione della parola “mnemonico”. 28 CAPITOLO 2. VARIABILI, ESPRESSIONI ED ISTRUZIONI Le parti del codice definite da Python (for, in, print, e :) sono in grassetto, contrariamente alle variabili scelte dallo sviluppatore (word e words). Molti editor di testo riconoscono la sintassi di Python e colorano le parole riservate in modo diverso mettendole in evidenza rispetto alle variabili. Dopo un po’ di pratica nel leggere Python sarai in grado di capire rapidamente quale sia una variabile e quale una parola riservata. 2.13 Debug A questo punto, l’errore di sintassi più probabile che tu possa fare è scegliere un nome di variabile non consentito, come class e yield, che sono parole chiave, o odd~job eUS$, che contengono caratteri non consentiti. Se inserisci uno spazio nel nome di variabile, Python riterrà che si tratti di due operandi senza un operatore: >>> bad name = 5 SyntaxError: invalid syntax >>> month = 09 File "", line 1 month = 09 ˆ SyntaxError: invalid token Per quanto riguarda gli errori di sintassi, bisogna dire che i messaggi di errore non sono di grande aiuto. I messaggi più comuni, SyntaxError: invalid syntax e SyntaxError: invalid token, sono entrambi poco esplicativi. L’errore di runti- me più comune è “use before def;”: cioè l’utilizzo di una variabile prima di averle assegnato un valore. Questo può verificarsi se viene scritta una variabile in modo errato: >>> principal = 327.68 >>> interest = principle * rate NameError: name 'principle' is not defined I nomi delle variabili sono case-sensitive: LaTeX non è lo stesso di latex. A questo punto la causa più probabile di un errore semantico è l’ordine delle operazioni. Ad esempio, per calcolare 1/2π, potresti essere tentato di scrivere: >>> 1.0 / 2.0 * pi Dato che la divisione viene effettuata per prima, otterrai π/2 che non è la stessa cosa! Poiché Python non ha modo di sapere cosa volessi realmente scrivere, non riceverai un messaggio di errore ma solo un risultato errato. 2.14. GLOSSARIO 29 2.14 Glossario Istruzione Istruzione che assegna un valore a una variabile. Concatenare Unire due operandi tra di loro. Commento Informazione in un programma destinato ad altri programmatori (o a chiunque stia leggendo il codice sorgente) e non ha alcun effetto sull’esecu- zione del programma. Calcolare Semplificare un’espressione eseguendo le operazioni in modo da ottene- re un unico valore. Espressione Combinazione di variabili, operatori e valori che fornisce un singolo valore come risultato. Virgola mobile Tipo di dato composto da numeri con le parti frazionarie. Interi Tipo di dato composto da numeri interi. Parola chiave o riservata Una parola riservata che viene utilizzata dal compila- tore per analizzare un programma; non potete utilizzare parole chiave come if, def e while come nomi di variabili. Mnemonico Un aiuto mnemonico: spesso diamo alle variabili nomi mnemonici per aiutarci a ricordare cosa è memorizzato nella variabile. Operatore modulo Un operatore, rappresentato con il segno di percentuale (%), che funziona con numeri interi e restituisce il resto quando un numero è diviso per un altro. Operando Uno dei valori su cui viene applicato un operatore. Operatore Simbolo speciale che rappresenta un semplice calcolo come addizioni, moltiplicazioni o concatenazioni di stringhe. Regole di precedenza Insieme di regole che disciplinano l’ordine in cui vengono calcolate le espressioni che coinvolgono molteplici operatori e operandi. Istruzione Una sezione di codice che rappresenta un comando o un’azione. Finora le istruzioni che abbiamo visto sono assegnazioni e istruzioni di stampa. Stringa Un tipo di dato composto da una sequenza di caratteri. Tipo Una categoria di valori. I tipi visti fino ad ora sono gli interi (tipo int), i numeri a virgola mobile (tipo float) e le stringhe (tipo str). Valore Una delle unità di base dei dati, come numeri o stringhe, che possono essere manipolate da un programma. Variabile Un nome assegnato ad un valore. 2.15 Esercizi Esercizio 2: Scrivi un programma che usi input per chiedere all’utente il proprio nome e poi dia loro il benvenuto. Enter your name: Chuck Hello Chuck Esercizio 3: Scrivi un programma per richiedere all’utente ore di lavoro e tariffe orarie per calcolare la retribuzione lorda. Enter Hours: 35 Enter Rate: 2.75 Pay: 96.25 30 CAPITOLO 2. VARIABILI, ESPRESSIONI ED ISTRUZIONI Per ora non ci preoccuperemo di assicurarci che la paga abbia esattamente due cifre dopo la virgola. Se vuoi, puoi giocare con la funzione round di Python per arrotondare correttamente la retribuzione risultante a due cifre decimali. Esercizio 4: Supponiamo di eseguire le seguenti istruzioni di assegnazione: width = 17 height = 12.0 Per ciascuna delle seguenti espressioni, scrivi il valore dell’espressione e il tipo di dato (del valore dell’espressione). 1. width//2 2. width/2.0 3. height/3 >>> print(1,000,000) 1 0 0 Utilizza l’interprete Python per verificare le tue risposte. Esercizio 5: Scrivi un programma che, richiesta all’utente una temperatura in gradi Celsius, la converta in Fahrenheit e poi la visualizzi. Capitolo 3 Esecuzione condizionale 3.1 Espressioni booleane Un’espressione booleana è un’espressione che può assumere solo i valori vero o falso. Negli esempi seguenti l’operatore == viene utilizzato per la comparazione di due operandi e produrrà True nel caso siano uguali o False in caso contrario: >>> 5 == 5 True >>> 5 == 6 False {} True e False non sono considerati stringhe ma sono valori speciali appartenenti al tipo bool: >>> type(True) >>> type(False) L’operatore == è uno degli operatori di comparazione; gli altri sono: x != y # x is not equal to y x > y # x is greater than y x < y # x is less than y x >= y # x is greater than or equal to y x. 31 32 CAPITOLO 3. ESECUZIONE CONDIZIONALE Yes x>0 print(‘x is positive’) Figura 3.1: Logica If 3.2 Operatori logici Esistono tre operatori logici: and, or e not. La semantica (significato) di questi operatori è simile al loro significato nella lingua inglese. Ad esempio: x> 0 and x y) è true se x > y è false; cioè, se x è minore o uguale a y. In pratica, gli operandi degli operatori logici dovrebbero essere espressioni booleane, anche Python non è molto rigoroso in merito. Qualsiasi numero diverso da zero viene interpretato come “true”: >>> 17 and True True Seppure questa flessibilità possa tornare utile, ci sono alcuni dettagli che potreb- bero creare confusione. A meno che non si sappia cosa si stia facendo, è il caso di evitare un evento del genere. 3.3 Esecuzione condizionale Per scrivere programmi utili, abbiamo quasi sempre bisogno di verificare le condi- zioni e modificare di conseguenza il comportamento del programma. Le istruzioni condizionali ci danno questa capacità. La forma più semplice è l’istruzione if: if x > 0 : print('x is positive') L’espressione booleana dopo l’istruzione if è chiamata condizione. Al termine dell’istruzione if va posto il carattere due punti (:), la linea/linee di codice seguenti devono essere indentate (rientrate). Se la condizione logica è vera verrà eseguita l’istruzione indentata. Se la condizione logica è falsa, questa verrà saltata. 3.4. ESECUZIONE ALTERNATIVA 33 Le istruzioni if hanno la stessa struttura delle definizioni di funzione o dei cicli for1. L’istruzione è composta da una riga di intestazione che termina con i due punti (:) seguita da un blocco indentato. Istruzioni come questa sono definite composte perché si estendono su più righe. Pur non essendoci alcun limite al numero di istruzioni che possono apparire nel blocco, deve esserne presente almeno una. Ad esempio, è utile avere un blocco senza istruzioni (sempre come segnaposto per codice non ancora scritto). In tal caso, puoi usare l’istruzione pass, che non produce alcun effetto. if x < 0 : pass # need to handle negative values! Se immetti un’istruzione if nell’interprete Python, il prompt cambierà da tre chevron a tre punti per segnalare che ci si trova nel mezzo di un blocco di istruzioni, come mostrato di seguito: >>> x = 3 >>> if x < 10:... print('Small')... Small >>> Quando utilizzi l’interprete Python, è necessario lasciare una riga vuota alla fine di un blocco, in caso contrario Python restituirà un errore: >>> x = 3 >>> if x < 10:... print('Small')... print('Done') File "", line 3 print('Done') ˆ SyntaxError: invalid syntax Durante la scrittura e l’esecuzione di uno script non è necessaria una riga vuota alla fine di un blocco di istruzioni, anche se questa può migliorare la leggibilità del codice. 3.4 Esecuzione alternativa Una seconda forma dell’istruzione if è l’esecuzione alternativa in cui sono state previste due possibilità e la condizione determina quale debba essere eseguita. La sintassi ha questo aspetto: 1 Impareremo a conoscere funzioni e cicli rispettivamente nel Capitolo 4 e 5. 34 CAPITOLO 3. ESECUZIONE CONDIZIONALE No Yes x%2 == 0 print(‘x is odd’) print(‘x is even’) Figura 3.2: Logica If-Then-Else if x%2 == 0 : print('x is even') else : print('x is odd') Nell’operazione x diviso 2, se il resto è 0, sappiamo che x è pari e il programma visualizza un messaggio in tal senso. Se la condizione è false, viene eseguita la seconda serie di istruzioni. Poiché questa condizione deve necessariamente essere vera o falsa, verrà eseguita una delle alternative. Le alternative sono chiamate branches perché sono come rami nel flusso di esecuzione. 3.5 Condizioni concatenate A volte è necessario prevedere più di due possibilità e di conseguenza occorre inserire più di due branche. Un modo per esprimere un simile calcolo è utilizzare le condizioni concatenate: if x < y: print('x is less than y') elif x > y: print('x is greater than y') else: print('x and y are equal') elif è l’abbreviazione di “else if”. Anche stavolta verrà eseguito un solo ramo. Non c’è limite al numero di istruzioni elif. Possono essere utilizzate svariate condizioni else, purché siano inserite alla fine. if choice == 'a': print('Bad guess') elif choice == 'b': print('Good guess') elif choice == 'c': print('Close, but not correct') 3.6. CONDIZIONI NIDIFICATE 35 Yes xy print (‘greater’) print(‘equal’) Figura 3.3: Logica If-Then-ElseIf Ogni condizione viene controllata in ordine. Se la prima condizione è falsa, verrà controllata la successiva e così via. Se una tra queste condizioni risulta vera, verrà eseguito il branch corrispondente e l’istruzione sarà terminata. Anche se più di una condizione è vera, verrà eseguito solo il primo branch vero. 3.6 Condizioni nidificate Una condizione può anche essere annidata all’interno di un’altra. Avremmo potuto scrivere l’esempio a tre branch anche in questo modo: if x == y: print('x and y are equal') else: if x < y: print('x is less than y') else: print('x is greater than y') La condizione esterna contiene due branch. Il primo contiene una semplice istru- zione. Il secondo branch contiene un’istruzione if, composta da due branch propri. Questi due branch sono entrambi semplici istruzioni, sebbene possano essere anche istruzioni condizionali. Nonostante l’indentazione delle istruzioni renda la struttura visivamente più intui- tiva, le condizioni nidificate diventano molto rapidamente difficili da comprendere. In generale, è meglio evitarle quando possibile. Gli operatori logici forniscono spesso un modo per semplificare le istruzioni nidificate. Ad esempio, possiamo riscrivere lo script seguente usando una singola condizione: if 0 < x: if x < 10: print('x is a positive single-digit number.') 36 CAPITOLO 3. ESECUZIONE CONDIZIONALE Yes No x == y Yes No x>> prompt = "What...is the airspeed velocity of an unladen swallow?\n" >>> speed = input(prompt) What...is the airspeed velocity of an unladen swallow? What do you mean, an African or a European swallow? >>> int(speed) ValueError: invalid literal for int() with base 10: >>> Quando l’interprete Python esegue queste istruzioni, verrà visualizzato un nuovo prompt, come se Python avesse pensato “oops” e fosse passato all’istruzione succes- siva. Tuttavia, se inserisci questo codice in uno script Python e si verifica questo errore, lo script si ferma immediatamente visualizzando un traceback, rifiutandosi di eseguire l’istruzione successiva. Questo è uno script di esempio per convertire una temperatura da Fahrenheit a Celsius: inp = input('Enter Fahrenheit Temperature: ') fahr = float(inp) cel = (fahr - 32.0) * 5.0 / 9.0 print(cel) 3.7. GESTIONE DELLE ECCEZIONI USANDO TRY ED EXCEPT 37 # Code: http://www.py4e.com/code3/fahren.py Se eseguiamo questo codice e gli forniamo valori non validi, fallirà semplicemente mostrando un messaggio di errore poco amichevole: python fahren.py Enter Fahrenheit Temperature:72 22.22222222222222 python fahren.py Enter Fahrenheit Temperature:fred Traceback (most recent call last): File "fahren.py", line 2, in fahr = float(inp) ValueError: could not convert string to float: 'fred' Per gestire questi tipi di errori previsti e inaspettati esiste una funzione condizio- nale incorporata in Python chiamata “try/except”. La finalità di try e except è collegata al sapere in anticipo che alcune sequenze di istruzioni potrebbero in- contrare problemi. Pertanto si possono aggiungere alcune istruzioni alternative da eseguire in caso di errore. Queste istruzioni aggiuntive (il blocco except) verranno ignorate se non si verificano errori. Potresti pensare alla funzione try e except in Python come ad una “polizza assicurativa” su una sequenza di istruzioni. Ad esempio, possiamo riscrivere il codice del nostro convertitore di temperatura come segue: inp = input('Enter Fahrenheit Temperature:') try: fahr = float(inp) cel = (fahr - 32.0) * 5.0 / 9.0 print(cel) except: print('Please enter a number') # Code: http://www.py4e.com/code3/fahren2.py Python dopo l’inserimento di un valore esegue la sequenza di istruzioni nel blocco try. Se non rileva errori, salta il blocco except e procede. Se si verifica un’eccezio- ne nel blocco try, Python blocca l’esecuzione try ed esegue le istruzioni presenti nel blocco except. python fahren2.py Enter Fahrenheit Temperature:72 22.22222222222222 python fahren2.py Enter Fahrenheit Temperature:fred Please enter a number 38 CAPITOLO 3. ESECUZIONE CONDIZIONALE Gestire un’eccezione con un’istruzione try è definito “catching di un’eccezione”. In questo esempio, la condizione except mostra un messaggio di errore. In generale, il catching di un’eccezione ti dà la possibilità di risolvere il problema o di riprovare, o almeno di terminare il programma elegantemente. 3.8 Valutazione di un cortocircuito di espressioni logiche Quando Python sta elaborando un’espressione logica come x >= 2 and (x/y) > 2, calcola l’espressione da sinistra a destra. A causa della definizione di and, se x è minore di 2, l’espressione x >= 2 è False e quindi l’intera espressione è False indipendentemente dal fatto che (x/y) > 2 restituisca True o False. Quando Python rileva che non c’è nulla da guadagnare valutando il resto di un’espressione logica, interrompe la valutazione senza eseguire i calcoli rimanenti. Questo caso viene chiamato “cortocircuito della valutazione”. Anche se ciò ti potrà sembrare una sottigliezza, il comportamento di cortocircuito porta a una tecnica intelligente chiamata schema del guardiano. Considera la seguente sequenza di codice: >>> x = 6 >>> y = 2 >>> x >= 2 and (x/y) > 2 True >>> x = 1 >>> y = 0 >>> x >= 2 and (x/y) > 2 False >>> x = 6 >>> y = 0 >>> x >= 2 and (x/y) > 2 Traceback (most recent call last): File "", line 1, in ZeroDivisionError: division by zero >>> Il terzo esempio ha dato errore perché Python, nel calcolare (x/y) dove y è zero, è incappato in un errore di runtime. Il secondo esempio non è fallito perché, essendo la prima parte dell’espressione x >= 2 calcolata come False, (x/y) non è mai stato eseguito a causa della regola del cortocircuito. Possiamo utilizzare questa logica per posizionare strategicamente uno schema del guardiano appena prima del calcolo che potrebbe causare un errore, come nell’esempio seguente: >>> x = 1 >>> y = 0 >>> x >= 2 and y != 0 and (x/y) > 2 False >>> x = 6 3.9. DEBUG 39 >>> y = 0 >>> x >= 2 and y != 0 and (x/y) > 2 False >>> x >= 2 and (x/y) > 2 and y !

Python per tutti - PDF

Document Details

Tags

Related

Summary

Full Transcript