1. Primi passi con Python

Benvenuto nel tuo percorso nella programmazione con Python! Questo capitolo ti guiderà attraverso i primi passi essenziali: capire che cos'è Python, installarlo sul tuo computer ed eseguire il tuo primo codice Python. Alla fine di questo capitolo ti sentirai a tuo agio nell'usare la shell interattiva di Python, nel creare ed eseguire file di script e nel comprendere i messaggi di errore di base che Python ti mostra.

1.1) Che cos’è un programma e cosa fa Python?

Prima di entrare nello specifico di Python, è utile capire che cos'è un programma e quale ruolo ha Python nella creazione di programmi.

1.1.1) Comprendere i programmi

Un programma è un insieme di istruzioni che dice a un computer cosa fare. Così come una ricetta ti dice passo dopo passo come preparare una torta, un programma dice a un computer passo dopo passo come eseguire un compito. Questi compiti possono andare da semplici calcoli a operazioni complesse come visualizzare pagine web, elaborare immagini o controllare robot.

I computer non comprendono direttamente le lingue umane come l’inglese o lo spagnolo. Capiscono solo il codice macchina: sequenze di numeri binari (0 e 1) che rappresentano operazioni molto basilari. Scrivere programmi direttamente in codice macchina sarebbe estremamente difficile e soggetto a errori per gli esseri umani.

Qui entrano in gioco i linguaggi di programmazione. Un linguaggio di programmazione è un modo leggibile dagli esseri umani per scrivere istruzioni che possono essere tradotte in codice macchina. Python è uno di questi linguaggi di programmazione, progettato per essere particolarmente facile da leggere e scrivere per le persone.

1.1.2) Cosa rende speciale Python

Python è un linguaggio di programmazione di alto livello, il che significa che astrae molti dei dettagli complessi che dovresti gestire in linguaggi di livello più basso. Ecco cosa rende Python particolarmente interessante sia per i principianti sia per i professionisti:

Sintassi leggibile: il codice Python si legge quasi come l’inglese. Per esempio, per stampare "Hello, World!" in Python, scrivi:

# hello_simple.py
print("Hello, World!")

Output:

Hello, World!

Confrontalo con linguaggi come C o Java, che richiedono più codice "boilerplate" per lo stesso compito.

Linguaggio interpretato: Python è un linguaggio interpretato. Questo significa che non devi compilare il tuo codice in codice macchina prima di eseguirlo. Invece, un programma chiamato interprete Python legge il tuo codice e lo esegue riga per riga. Questo rende lo sviluppo più rapido perché puoi vedere immediatamente i risultati delle modifiche al tuo codice.

Versatile e potente: pur essendo adatto ai principianti, Python è usato in contesti professionali per:

• Sviluppo web (siti e applicazioni web)
• Analisi e visualizzazione dei dati
• Machine learning e intelligenza artificiale
• Calcolo scientifico
• Automazione e scripting
• Sviluppo di videogiochi
• E molto altro

Ampia comunità e librerie: Python ha una comunità di utenti enorme e migliaia di librerie di codice pre-scritto che ne estendono le capacità. Questo significa che le soluzioni ai problemi comuni spesso sono a portata di import di una libreria.

1.1.3) Come Python esegue il tuo codice

Quando scrivi del codice Python e lo esegui, dietro le quinte accade quanto segue:

1. Scrivi il codice: crei un file contenente istruzioni Python oppure le digiti direttamente nella shell interattiva di Python.

2. L’interprete legge il tuo codice: l’interprete Python controlla il tuo codice alla ricerca di errori di sintassi (errori nel modo in cui hai scritto il codice).

3. Traduzione in bytecode: se non ci sono errori di sintassi, Python traduce il tuo codice in una forma intermedia chiamata bytecode. Il bytecode è una forma intermedia del tuo codice: una traduzione in un linguaggio a metà strada tra Python e il codice macchina. È più semplice da eseguire per il computer rispetto a Python, ma più astratto del puro codice macchina.

4. Esecuzione: la Python Virtual Machine (PVM) esegue il bytecode, svolgendo le operazioni che hai specificato.

5. Output: vedi i risultati del tuo programma, che si tratti di testo stampato sullo schermo, di un file creato o di qualsiasi altra azione.

La bellezza di questo processo è che non devi preoccuparti della maggior parte di questi passaggi. Scrivi il codice, lo esegui e vedi i risultati. L’interprete si occupa del resto.

1.2) Installare Python ed eseguire l’interprete

Per iniziare a programmare in Python, devi prima installare Python sul tuo computer. Questa sezione ti guiderà nel processo di installazione e ti aiuterà a verificare che tutto funzioni correttamente.

1.2.1) Verificare se Python è già installato

Alcuni sistemi operativi includono Python preinstallato. Prima di scaricare qualcosa, verifichiamo se Python è già presente sul tuo sistema.

Su Windows:

1. Apri il Prompt dei comandi:

   • Premi Windows + R per aprire la finestra Esegui
   • Digita cmd e premi Invio

2. Digita il seguente comando e premi Invio:

python --version

Se Python è installato, vedrai un output simile a:

Python 3.11.5

Se vedi un messaggio di errore come 'python' is not recognized as an internal or external command, Python non è installato oppure non è nel PATH di sistema.

Su macOS:

1. Apri l’applicazione Terminale:

   • Premi Command + Space per aprire Spotlight
   • Digita Terminal e premi Invio

2. Digita il seguente comando e premi Invio:

python3 --version

Nota: su macOS, in genere si usa python3 invece di python perché python potrebbe riferirsi a Python 2, che è obsoleto.

Se Python 3 è installato, vedrai un output simile a:

Python 3.11.5

Su Linux:

1. Apri il tuo terminale (varia a seconda della distribuzione)

2. Digita il seguente comando e premi Invio:

python3 --version

La maggior parte delle moderne distribuzioni Linux include Python 3 preinstallato.

1.2.2) Scaricare e installare Python

Se Python non è installato o hai una versione molto vecchia, segui questi passaggi per installare l’ultima versione.

Installazione su Windows:

1. Visita il sito ufficiale di Python: https://www.python.org/downloads/

2. Clicca sul pulsante "Download Python" (mostrerà l’ultima versione, ad esempio "Download Python 3.11.5")

3. Esegui il programma di installazione scaricato (file .exe)

4. Importante: nella prima schermata del programma di installazione, seleziona la casella "Add Python to PATH". Questo è cruciale: permette di eseguire Python da qualsiasi prompt dei comandi.

   Cosa succede se te ne dimentichi: se non selezioni "Add Python to PATH", non potrai eseguire Python dalla riga di comando e vedrai un errore come 'python' is not recognized as an internal or external command. In tal caso dovrai reinstallare Python (selezionando la casella questa volta) oppure aggiungere Python al PATH manualmente, operazione più complessa per chi inizia.

5. Clicca su "Install Now" e attendi il completamento dell’installazione.

6. Verifica l’installazione aprendo un nuovo Prompt dei comandi e digitando:

python --version

Dovresti vedere il numero di versione che hai appena installato.

Installazione su macOS:

1. Visita https://www.python.org/downloads/

2. Clicca sul pulsante "Download Python" per l’ultima versione

3. Apri il file .pkg scaricato e segui la procedura guidata

4. Verifica l’installazione aprendo Terminale e digitando:

python3 --version

Installazione su Linux:

La maggior parte delle distribuzioni Linux include Python 3, ma se hai bisogno di installarlo o aggiornarlo:

Per sistemi basati su Ubuntu/Debian:

sudo apt update
sudo apt install python3

Per sistemi basati su Fedora/Red Hat:

sudo dnf install python3

Verifica con:

python3 --version

1.2.3) Eseguire l’interprete Python

Una volta installato Python, puoi eseguire l’interprete Python direttamente dalla riga di comando o dal terminale. L’interprete è il programma che esegue il codice Python. Eseguire direttamente l’interprete apre la shell interattiva (REPL), che esploreremo in dettaglio nella prossima sezione. Questo è diverso dall’esecuzione di un file di script, che vedremo nella Sezione 1.4.

Su Windows:

Apri il Prompt dei comandi e digita:

python

Su macOS e Linux:

Apri il Terminale e digita:

python3

Dovresti vedere qualcosa di simile:

Python 3.11.5 (main, Sep 11 2023, 13:54:46) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Il prompt >>> indica che Python è pronto a ricevere i tuoi comandi. Questa è chiamata shell interattiva di Python o REPL (Read-Eval-Print Loop), che esploreremo in dettaglio nella prossima sezione.

Per uscire dall’interprete puoi:

• Digitare exit() e premere Invio
• Digitare quit() e premere Invio
• Premere Ctrl + D (su macOS/Linux) oppure Ctrl + Z seguito da Invio (su Windows)

Congratulazioni! Hai installato correttamente Python e verificato che l’interprete funzioni. Ora sei pronto per iniziare a scrivere codice Python.

1.3) Usare la shell interattiva di Python (REPL)

La shell interattiva di Python, comunemente chiamata REPL (Read-Eval-Print Loop), è una delle funzionalità più utili di Python per l’apprendimento e la sperimentazione. Ti permette di digitare codice Python e vedere immediatamente i risultati, rendendola perfetta per provare nuovi concetti, testare piccoli frammenti di codice ed esplorare le capacità di Python.

1.3.1) Che cos’è il REPL?

La shell interattiva di Python, comunemente chiamata REPL (Read-Eval-Print Loop), è una delle funzionalità più utili di Python per l’apprendimento e la sperimentazione. Il REPL è chiamato anche shell interattiva di Python o semplicemente interprete interattivo: tutti questi termini si riferiscono alla stessa cosa, il prompt >>> dove puoi digitare codice Python e vedere risultati immediati.

REPL significa:

• Read: Python legge il codice che digiti
• Eval: Python valuta (esegue) quel codice
• Print: Python stampa il risultato
• Loop: Python torna a leggere altro codice

Questo ciclo continua finché non esci dal REPL. È come avere una conversazione con Python: gli dai un’istruzione, lui risponde e puoi subito dare un’altra istruzione basandoti su quella risposta.

1.3.2) Avviare e usare il REPL

Per avviare il REPL, apri la riga di comando o il terminale e digita python (Windows) o python3 (macOS/Linux), come abbiamo fatto nella sezione precedente.

Quando vedi il prompt >>>, puoi iniziare a digitare codice Python. Proviamo alcuni esempi di base.

Aritmetica semplice:

>>> 5 + 3
8
>>> 10 * 2
20
>>> 15 / 3
5.0

Nota che non hai bisogno di usare print() nel REPL: Python mostra automaticamente il risultato di ogni espressione. Questa è una delle comodità del REPL.

Lavorare con il testo:

>>> "Hello, World!"
'Hello, World!'
>>> "Python" + " is " + "great"
'Python is great'

Quando digiti semplicemente una stringa (testo tra virgolette), Python la mostra con le virgolette: è il modo in cui Python rappresenta la stringa. Se vuoi visualizzare il testo senza virgolette, usa la funzione print():

>>> print("Hello, World!")
Hello, World!

Nota la differenza: digitare solo la stringa la mostra con le virgolette (la rappresentazione di Python), mentre print() la visualizza senza virgolette (il testo vero e proprio).

Memorizzare valori in variabili:

Sebbene digitare valori direttamente sia utile per test rapidi, spesso vorrai memorizzare valori in variabili: contenitori con un nome che tengono dati che puoi riutilizzare nel tuo programma.

>>> name = "Alice"
>>> name
'Alice'
>>> age = 25
>>> age
25

Quando assegni un valore a una variabile (come name = "Alice"), Python non stampa nulla. Ma quando digiti solo il nome della variabile, Python ne mostra il valore.

Usare Python come calcolatrice:

>>> 2 + 2
4
>>> (10 + 5) * 2
30
>>> 100 / 4
25.0
>>> 7 % 3
1

Il REPL è eccellente per calcoli veloci e per testare espressioni matematiche.

1.3.3) Input su più righe nel REPL

A volte hai bisogno di scrivere codice che occupa più righe, come le definizioni di funzione. Il REPL gestisce questa situazione cambiando il prompt. Quando inizi un’istruzione su più righe, il prompt cambia da >>> a ... per indicare che Python sta aspettando che tu completi l’istruzione.

Ecco un esempio semplice che usa una funzione (Nota: impareremo le funzioni in dettaglio nel Capitolo 19. Questo esempio mostra soltanto come il REPL gestisce l’input su più righe con il prompt di continuazione ...):

>>> def greet():
...     print("Hello!")
...
>>> greet()
Hello!

Dopo aver digitato la prima riga e premuto Invio, il prompt diventa .... Digiti la riga indentata, premi Invio, poi premi ancora Invio su una riga vuota per eseguire il codice.

1.3.4) Accedere ai comandi precedenti

Il REPL mantiene una cronologia dei comandi che hai digitato. Puoi usare le frecce su e giù per scorrere la cronologia:

• Freccia su: mostra il comando precedente
• Freccia giù: mostra il comando successivo (se sei tornato indietro prima)

Questo è molto utile quando vuoi modificare e rieseguire un comando, o quando vuoi ricordare cosa hai digitato in precedenza.

1.3.5) Ottenere aiuto nel REPL

Il REPL di Python include funzioni di aiuto integrate. Puoi ottenere informazioni su oggetti, funzioni e moduli Python direttamente.

Queste funzioni di aiuto sono particolarmente utili quando stai esplorando Python e vuoi scoprire cosa è disponibile. Per esempio, se stai lavorando con le stringhe e ti chiedi quali metodi esistano, dir(str) ti mostra tutte le opzioni. Man mano che procedi con questo libro, troverai questi strumenti sempre più utili per l’esplorazione autonoma.

>>> help()

Questo comando apre il sistema di aiuto. Puoi poi digitare il nome di qualcosa di cui vuoi aiuto, oppure digitare quit per uscire dal sistema di aiuto.

Puoi anche ottenere aiuto direttamente su elementi specifici:

>>> help(print)

Questo mostra la documentazione per la funzione print(). Premi q per uscire dalla visualizzazione dell’aiuto.

Un’altra funzione utile è dir(), che elenca gli attributi e i metodi disponibili su un oggetto. (Nota: attributi e metodi sono caratteristiche e azioni disponibili su un oggetto; ne parleremo meglio nel Capitolo 43. Impareremo anche a importare moduli nel Capitolo 22. Questo esempio mostra come il REPL aiuti a esplorare le capacità di Python.)

>>> dir(str)

Questo mostra tutti i metodi disponibili per gli oggetti stringa.

1.3.6) Quando il REPL è più utile

Il REPL è particolarmente efficace per:

1. Apprendimento ed esplorazione: quando impari un nuovo concetto, il REPL ti permette di sperimentare subito senza creare file.

2. Testare piccoli frammenti di codice: prima di aggiungere del codice al tuo programma, puoi provarlo nel REPL per assicurarti che funzioni come previsto.

3. Calcoli veloci: il REPL è una potente calcolatrice sempre disponibile.

4. Debug: quando il tuo programma non funziona, puoi usare il REPL per testare singole parti del codice in isolamento.

5. Esplorare librerie: quando impari una nuova libreria, puoi importarla nel REPL e provare le sue funzioni in modo interattivo.

Tuttavia, il REPL ha dei limiti. Il codice che scrivi nel REPL scompare quando lo chiudi: non c’è modo di salvare una sessione REPL come programma. Per qualsiasi codice che vuoi conservare ed eseguire più volte, dovrai creare file di script, che vedremo nella prossima sezione.

1.3.7) Uscire dal REPL

Quando hai finito di usare il REPL, puoi uscirne in vari modi:

>>> exit()

Oppure:

>>> quit()

Oppure usando le scorciatoie da tastiera:

• Windows: premi Ctrl + Z, poi Invio
• macOS/Linux: premi Ctrl + D

Dopo l’uscita, tornerai al normale prompt della riga di comando o del terminale.

1.4) Creare ed eseguire file di script Python

Il REPL è eccellente per la sperimentazione e i test rapidi, ma cosa succede se vuoi salvare il tuo codice e rieseguirlo in seguito? E se vuoi scrivere un programma più lungo con decine o centinaia di righe? Per queste situazioni ti servono i file di script: file permanenti che contengono codice Python che puoi modificare, salvare ed eseguire più volte.

Sebbene il REPL sia eccellente per la sperimentazione, la maggior parte della programmazione in Python consiste nello scrivere file di script: file di testo contenenti codice Python che possono essere salvati, modificati ed eseguiti ripetutamente. In questa sezione imparerai a creare il tuo primo script Python ed eseguirlo dalla riga di comando.

1.4.1) Che cos’è uno script Python?

Uno script Python è semplicemente un file di testo contenente codice Python, salvato con estensione .py. A differenza del codice digitato nel REPL, i file di script:

• Sono permanenti: puoi salvarli ed eseguirli in seguito
• Possono essere modificati facilmente
• Possono contenere tutto il codice di cui hai bisogno
• Possono essere condivisi con altri
• Possono essere eseguiti automaticamente o a orari programmati

Pensa a un file di script come a una ricetta che scrivi su carta, mentre il REPL è come cucinare inventando la ricetta sul momento. Entrambi hanno il loro posto, ma per qualsiasi cosa sostanziale vorrai usare un file di script.

1.4.2) Scegliere un editor di testo

Per creare script Python, ti serve un editor di testo. Non usare elaboratori di testo come Microsoft Word o Google Docs: aggiungono formattazione che Python non può interpretare.

Buone opzioni per principianti:

1. IDLE: fornito insieme a Python. Semplice e pensato per l’apprendimento.

   • Su Windows: cerca "IDLE" nel menu Start
   • Su macOS/Linux: digita idle3 nel terminale

2. Visual Studio Code (VS Code): gratuito, potente e ampiamente usato dai professionisti. Ottimo supporto a Python tramite estensioni.

   • Scarica da: https://code.visualstudio.com/

3. PyCharm Community Edition: un IDE (Integrated Development Environment) completo specifico per Python.

   • Scarica da: https://www.jetbrains.com/pycharm/

4. Notepad++ (solo Windows): leggero e semplice.

   • Scarica da: https://notepad-plus-plus.org/

5. Sublime Text: veloce ed elegante, con buon supporto per Python.

   • Scarica da: https://www.sublimetext.com/

In questo libro useremo esempi semplici che funzionano con qualsiasi editor di testo. Scegli l’editor che ti sembra più comodo.

1.4.3) Creare il tuo primo script Python

Creiamo un semplice script Python che stampa messaggi di saluto.

Passo 1: crea un nuovo file

Apri l’editor di testo che hai scelto e crea un nuovo file. Salvalo come hello.py in una posizione che ricorderai (ad esempio il Desktop o una cartella dedicata ai progetti Python).

Importante: l’estensione .py è fondamentale. Indica al sistema operativo e all’editor che si tratta di un file Python.

Passo 2: scrivi il tuo codice

Digita il seguente codice nel file:

# hello.py
# My first Python script
 
print("Hello, World!")
print("Welcome to Python programming!")

Le righe che iniziano con # sono commenti: note per gli esseri umani che leggono il codice. Python le ignora completamente. I commenti ti aiutano a ricordare cosa fa il codice e aiutano gli altri a capire il tuo lavoro. Esploreremo i commenti più in dettaglio nel Capitolo 2.

Passo 3: salva il file

Salva il file. Assicurati che sia salvato come hello.py, non hello.py.txt o con un’altra estensione.

Capiremo ora cosa fa questo codice:

• print("Hello, World!") dice a Python di visualizzare il testo "Hello, World!" sullo schermo.
• print("Welcome to Python programming!") visualizza un altro messaggio.

1.4.4) Eseguire lo script dalla riga di comando

Ora che hai creato il tuo script, eseguiamolo.

Passo 1: apri la riga di comando/il terminale

• Windows: apri il Prompt dei comandi
• macOS/Linux: apri il Terminale

Passo 2: vai nella cartella in cui si trova lo script

Usa il comando cd (change directory) per spostarti nella cartella dove hai salvato hello.py. Per esempio, se lo hai salvato sul Desktop:

Windows:

cd Desktop

macOS/Linux:

cd ~/Desktop

Se ottieni un errore tipo "No such file or directory" quando provi a eseguire lo script, probabilmente non ti trovi nella cartella giusta. Usa il comando cd per spostarti nella cartella in cui hai salvato lo script.

Per verificare di essere nel posto giusto, puoi elencare i file:

Windows:

dir

macOS/Linux:

ls

Dovresti vedere hello.py nell’elenco.

Passo 3: esegui lo script

Windows:

python hello.py

macOS/Linux:

python3 hello.py

Dovresti vedere l’output:

Hello, World!
Welcome to Python programming!

Congratulazioni! Hai appena creato ed eseguito il tuo primo script Python.

1.4.5) Capire l’esecuzione di uno script

Quando esegui uno script Python, succede questo:

1. Digiti il comando per eseguire lo script.
2. Il sistema operativo avvia l’interprete Python.
3. L’interprete legge l’intero file di script.
4. Controlla la presenza di errori di sintassi (errori nel modo in cui hai scritto il codice).
5. Se trova errori, mostra un messaggio di errore e si ferma.
6. Se non ci sono errori, esegue il codice riga per riga, dall’alto verso il basso.
7. Qualsiasi output (dalle istruzioni print()) viene visualizzato.
8. Quando lo script termina, il controllo torna alla riga di comando.

1.4.6) Un esempio più complesso

Creiamo uno script leggermente più complesso che dimostri più concetti. Per prima cosa, aggiungiamo un esempio intermedio che introduce le variabili in modo più graduale:

# simple_variable.py
# Using a variable for the first time
 
message = "Hello, Python!"
print(message)

Output:

Hello, Python!

Ora guardiamo uno script con più variabili:

# student_info.py
# A script that uses variables and multiple print statements
 
name = "Alice"
age = 25
city = "New York"
 
print("Student Information")
print("-------------------")
print("Name:", name)
print("Age:", age)
print("City:", city)

Salvalo come student_info.py ed eseguilo:

Windows:

python student_info.py

macOS/Linux:

python3 student_info.py

Output:

Student Information
-------------------
Name: Alice
Age: 25
City: New York

Questo script mostra:

• Come creare variabili (ne parleremo meglio nel Capitolo 3)
• L’uso di più istruzioni print()
• Come stampare sia testo letterale sia valori di variabili

1.4.7) Buone pratiche per i file di script

Anche in questa fase iniziale, è utile prendere alcune buone abitudini:

1. Usa nomi di file descrittivi: dai ai tuoi file nomi legati a ciò che fanno. student_info.py è meglio di test.py o program1.py perché ti ricorderai cosa fa quando lo vedrai in un elenco di file tra sei mesi.

2. Tieni gli script organizzati: crea una cartella dedicata ai tuoi progetti Python. Non spargere script in giro per il computer. Questo rende più facile trovare il tuo lavoro e mantiene i file in ordine.

3. Aggiungi commenti: inizia ogni script con un commento che spiega cosa fa. Questo ti aiuta a ricordare in seguito e aiuta gli altri a capire il tuo codice.

4. Uno script, uno scopo principale: ogni script dovrebbe svolgere un compito principale. Non cercare di stipare molte attività non correlate nello stesso file. Questo rende il codice più facile da capire e da mantenere.

5. Testa spesso: esegui lo script frequentemente mentre lo scrivi. Non aspettare di aver scritto 100 righe per fare un test: prova dopo ogni poche righe. Questo ti aiuta a trovare gli errori presto, quando sono più facili da correggere.

1.5) Una prima occhiata agli errori e ai traceback

Gli errori sono una parte naturale della programmazione. Ogni programmatore, dai principianti agli esperti, incontra errori regolarmente. Imparare a leggere e capire i messaggi di errore è una competenza fondamentale che ti aiuterà a risolvere i problemi rapidamente e a diventare più sicuro.

1.5.1) Tipi di errori

Python distingue due categorie principali di errori:

Errori di sintassi (Syntax Errors): errori nel modo in cui hai scritto il codice, violazioni delle regole grammaticali di Python. Python rileva questi errori prima di eseguire il codice. Puoi pensarli come errori grammaticali nella scrittura: Python non riesce neppure a capire cosa stai cercando di dire.

Eccezioni (Exceptions): errori che si verificano mentre il codice è in esecuzione. La sintassi è corretta, ma qualcosa va storto durante l’esecuzione. Le eccezioni sono come problemi a runtime: Python capisce le istruzioni ma non riesce a eseguirle.

Esploriamo entrambi i tipi con alcuni esempi.

1.5.2) Errori di sintassi

Un errore di sintassi si verifica quando scrivi codice che non segue le regole di Python. Python non può nemmeno iniziare a eseguire il codice perché non capisce ciò che hai scritto.

Esempio 1: due punti mancanti

Crea un file chiamato syntax_error1.py:

# syntax_error1.py
# This code has a syntax error
 
if 5 > 3
    print("Five is greater than three")

Quando provi a eseguirlo:

python syntax_error1.py

Vedrai:

  File "syntax_error1.py", line 4
    if 5 > 3
            ^
SyntaxError: expected ':'

Python ti sta dicendo diverse cose:

• Quale file contiene il problema: syntax_error1.py
• Quale riga contiene il problema: riga 4
• Dove su quella riga si trova il problema: il simbolo ^ indica la posizione
• Che tipo di errore: SyntaxError
• Una descrizione utile: expected ':'

Il problema è che le istruzioni if in Python devono terminare con due punti (:). Il codice corretto è:

# syntax_error1_fixed.py
# Fixed version
 
if 5 > 3:
    print("Five is greater than three")

Output:

Five is greater than three

Esempio 2: virgolette non corrispondenti

# syntax_error2.py
# Another syntax error example
 
message = "Hello, World!'
print(message)

Eseguendo questo codice ottieni:

  File "syntax_error2.py", line 4
    message = "Hello, World!'
              ^
SyntaxError: unterminated string literal (detected at line 4)

Il problema è che la stringa inizia con virgolette doppie (") ma termina con virgolette singole ('). Python richiede virgolette corrispondenti. Correggi usando virgolette abbinate:

# syntax_error2_fixed.py
# Fixed version
 
message = "Hello, World!"
print(message)

Output:

Hello, World!

1.5.3) Eccezioni a runtime

Le eccezioni a runtime (o semplicemente "eccezioni") si verificano quando il tuo codice è sintatticamente corretto, ma qualcosa va storto durante l’esecuzione.

Esempio 1: NameError

# name_error.py
# This code will cause a NameError
 
print(greeting)

Quando esegui:

python name_error.py

Vedrai:

Traceback (most recent call last):
  File "name_error.py", line 4, in <module>
    print(greeting)
          ^^^^^^^^
NameError: name 'greeting' is not defined

Questo è chiamato traceback. Analizziamolo:

• "Traceback (most recent call last):" indica che ciò che segue è un traceback che mostra dove si è verificato l’errore.
• Informazioni su file e riga: File "name_error.py", line 4, in <module> ti dice quale file e quale riga hanno causato l’errore.
• Il codice problematico: print(greeting) mostra la riga che ha fallito.
• Tipo di errore: NameError indica il tipo di errore.
• Descrizione dell’errore: name 'greeting' is not defined spiega il problema: stai cercando di usare una variabile che non esiste.

Per risolvere il problema, devi definire la variabile prima di usarla:

# name_error_fixed.py
# Fixed version
 
greeting = "Hello!"
print(greeting)

Output:

Hello!

Esempio 2: TypeError

# type_error.py
# This code will cause a TypeError
 
number = 5
text = "The number is "
result = text + number
print(result)

Eseguendo questo codice ottieni:

Traceback (most recent call last):
  File "type_error.py", line 6, in <module>
    result = text + number
             ~~~~~^~~~~~~~
TypeError: can only concatenate str (not "int") to str

Il messaggio di errore ti dice che non puoi sommare (concatenare) direttamente una stringa e un intero. Python non sa se vuoi fare un’addizione matematica o una concatenazione di stringhe.

Per correggerlo, converti il numero in stringa:

# type_error_fixed.py
# Fixed version
 
number = 5
text = "The number is "
result = text + str(number)
print(result)

Output:

The number is 5

Esempio 3: ZeroDivisionError

Cosa succede se provi a dividere per zero?

# zero_division.py
# This code will cause a ZeroDivisionError
 
result = 10 / 0
print(result)

Eseguendo questo codice ottieni:

Traceback (most recent call last):
  File "zero_division.py", line 4, in <module>
    result = 10 / 0
             ~~~^~~
ZeroDivisionError: division by zero

Questo errore è autoesplicativo: non puoi dividere per zero. È matematicamente indefinito, quindi Python solleva un’eccezione.

1.5.4) Leggere i traceback in modo efficace

Quando incontri un traceback, leggilo dal basso verso l’alto. Leggiamo dal basso verso l’alto perché l’ultima riga mostra cosa è andato storto (il tipo di errore e il messaggio), mentre le righe sopra mostrano la sequenza di chiamate di funzione che ha portato all’errore. Per programmi semplici come i nostri, l’ultima riga ti dice tutto ciò che ti serve.

1. Parti dal basso: guarda prima il tipo di errore e il messaggio.
2. Comprendi l’errore: cosa ti sta dicendo Python che è andato storto?
3. Trova la posizione: guarda il file e il numero di riga dove si è verificato l’errore.
4. Esamina il codice: guarda quella riga nel tuo file.
5. Ripercorri all’indietro se necessario: a volte il problema è in realtà sulla riga precedente a quella indicata da Python.

1.5.5) Errori comuni per chi inizia

Ecco alcuni errori che probabilmente incontrerai mentre impari Python:

Errori di indentazione:

Python usa l’indentazione (spazi o tab all’inizio delle righe) per definire i blocchi di codice. Un’indentazione errata causa errori:

# indentation_error.py
# Incorrect indentation
 
print("First line")
    print("Second line")  # This line is incorrectly indented

Errore:

  File "indentation_error.py", line 5
    print("Second line")
    ^
IndentationError: unexpected indent

Errori di ortografia:

Python distingue tra maiuscole e minuscole. Print non è la stessa cosa di print:

# spelling_error.py
# Incorrect capitalization
 
Print("Hello")  # Should be print, not Print

Errore:

Traceback (most recent call last):
  File "spelling_error.py", line 4, in <module>
    Print("Hello")
    ^^^^^
NameError: name 'Print' is not defined

Parentesi mancanti:

In Python 3, print richiede le parentesi:

# missing_parentheses.py
# Missing parentheses
 
print "Hello"  # Should be print("Hello")

Errore:

  File "missing_parentheses.py", line 4
    print "Hello"
          ^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?

Nota quanto è utile il messaggio di errore di Python in questo caso: suggerisce persino la correzione!

1.5.6) Strategie per affrontare gli errori

Quando incontri un errore:

1. Non andare nel panico: gli errori sono normali. Ogni programmatore li vede continuamente.

2. Leggi attentamente il messaggio di errore: i messaggi di errore di Python sono di solito utili. Ti dicono cosa è andato storto e dove.

3. Controlla il numero di riga: vai alla riga indicata da Python e cerca il problema.

4. Guarda le righe vicine: a volte l’errore è in realtà sulla riga prima di quella indicata.

5. Controlla gli errori comuni: due punti mancanti, virgolette non corrispondenti, indentazione errata e errori di battitura sono molto comuni.

6. Prova piccole modifiche: correggi una cosa alla volta e testa il codice dopo ogni cambiamento.

7. Usa il REPL: se hai dubbi su qualcosa, provala prima nel REPL.

8. Cerca l’errore: se non capisci un messaggio di errore, cercalo online. Spesso troverai spiegazioni e soluzioni.

1.5.7) Un esempio completo con errore e correzione

Vediamo uno script con più errori e correggiamoli passo dopo passo. Questo programma è pensato per mostrare informazioni su uno studente e calcolare la sua età tra 10 anni:

Versione originale (con errori):

# buggy_student.py
# This program has several errors
 
student_name = "Alice
student_age = 25
 
print("Name:", student_name)
print("Age:" student_age)
print("In 10 years, you will be", student_age + "10")

Eseguendo questo script, vengono prodotti vari errori. Correggiamoli uno per uno:

Errore 1: stringa non terminata

  File "buggy_student.py", line 4
    student_name = "Alice
                   ^
SyntaxError: unterminated string literal (detected at line 4)

Correzione: aggiungi la virgoletta di chiusura:

student_name = "Alice"

Dopo aver corretto l’Errore 1, otteniamo l’Errore 2: virgola mancante

  File "buggy_student.py", line 8
    print("Age:" student_age)
                 ^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

Correzione: aggiungi una virgola tra la stringa e la variabile:

print("Age:", student_age)

Dopo aver corretto l’Errore 2, otteniamo l’Errore 3: errore di tipo

Traceback (most recent call last):
  File "buggy_student.py", line 9, in <module>
    print("In 10 years, you will be", student_age + "10")
                                      ~~~~~~~~~~~~^~~~~~
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Correzione: converti "10" in intero:

print("In 10 years, you will be", student_age + 10)

Versione finale corretta:

# buggy_student_fixed.py
# Fixed version of the program
 
student_name = "Alice"
student_age = 25
 
print("Name:", student_name)
print("Age:", student_age)
print("In 10 years, you will be", student_age + 10)

Output:

Name: Alice
Age: 25
In 10 years, you will be 35

Questo esempio mostra che correggere gli errori è spesso un processo iterativo. Correggi un errore, esegui di nuovo il codice e scopri il prossimo errore. È perfettamente normale.

1.6) Quando usare la shell interattiva e quando i file di script

Ora che hai imparato sia a usare il REPL sia a creare file di script, potresti chiederti quando usare l’uno o l’altro. Entrambi sono strumenti preziosi, e i programmatori Python esperti li usano regolarmente. Capire quando usare ciascuno ti renderà più efficiente.

1.6.1) Usa la shell interattiva (REPL) quando:

1. Impari nuovi concetti

Quando stai imparando qualcosa di nuovo, il REPL ti fornisce un feedback immediato:

>>> # Testing string methods
>>> text = "hello world"
>>> text.upper()
'HELLO WORLD'
>>> text.title()
'Hello World'
>>> text.capitalize()
'Hello world'

Puoi sperimentare con metodi diversi e vedere i risultati all’istante senza creare file.

2. Testi piccoli frammenti di codice

Prima di aggiungere codice al tuo programma, provalo nel REPL:

>>> # Testing a calculation
>>> price = 19.99
>>> quantity = 3
>>> total = price * quantity
>>> total
59.97
>>> # Looks good, now I can add this to my script

3. Fai calcoli veloci

Il REPL è sempre disponibile come calcolatrice:

>>> # How many seconds in a day?
>>> 24 * 60 * 60
86400
>>> # What's 15% of 250?
>>> 250 * 0.15
37.5

4. Fai debug

Quando il tuo script non funziona, usa il REPL per testare singole parti:

>>> # My script isn't working. Let me test this part:
>>> numbers = [1, 2, 3, 4, 5]
>>> sum(numbers) / len(numbers)
3.0
>>> # This works, so the problem must be elsewhere

Nota: impareremo le liste nel Capitolo 13. Questo esempio mostra come il REPL aiuti a testare frammenti di codice.

1.6.2) Usa i file di script quando:

1. Scrivi programmi che vuoi conservare

Qualsiasi cosa tu voglia salvare e rieseguire dovrebbe stare in un file di script:

# temperature_converter.py
# A program to convert Fahrenheit to Celsius
 
fahrenheit = 98.6
celsius = (fahrenheit - 32) * 5/9
print("Temperature:", fahrenheit, "°F is", round(celsius, 1), "°C")

Output:

Temperature: 98.6 °F is 37.0 °C

Puoi eseguire questo script ogni volta che ti serve e modificarlo in seguito.

2. Scrivi programmi su più righe

Sebbene tu possa scrivere codice su più righe nel REPL, diventa scomodo per qualcosa di sostanziale. Usa un file di script:

# grade_calculator.py
# Calculate final grade from multiple scores
 
homework = 85
midterm = 78
final = 92
 
# Calculate weighted average
final_grade = (homework * 0.3) + (midterm * 0.3) + (final * 0.4)
 
print("Final Grade:", final_grade)

Output:

Final Grade: 85.3

3. Condividi il codice con altri

I file di script sono facili da condividere, mentre le sessioni REPL no:

# greeting.py
# A simple greeting program
 
name = input("What is your name? ")
print("Hello,", name + "! Welcome to Python.")

Nota: impareremo la funzione input() nel Capitolo 2. Questo esempio mostra come gli script possano essere condivisi.

Puoi inviare questo file a qualcun altro e quella persona potrà eseguirlo sul proprio computer.

4. Costruisci strumenti riutilizzabili

Se stai creando qualcosa che userai ripetutamente, trasformalo in uno script:

# file_counter.py
# Count files in a directory
 
import os
 
directory = "."  # Current directory
files = [f for f in os.listdir(directory) if os.path.isfile(f)]
print("Number of files:", len(files))

Nota: impareremo a importare moduli nel Capitolo 22 e le list comprehensions nel Capitolo 34. Questo esempio mostra come gli script possano diventare strumenti riutilizzabili.

5. Sviluppi logica complessa

Per qualsiasi cosa con più funzioni, classi o logica complessa, usa file di script:

# password_checker.py
# Check password strength
 
def check_password_strength(password):
    """Check if a password meets basic requirements."""
    if len(password) < 8:
        return "Too short"
    if not any(c.isupper() for c in password):
        return "Needs uppercase letter"
    if not any(c.isdigit() for c in password):
        return "Needs number"
    return "Strong password"
 
# Test the function
test_password = "MyPass123"
result = check_password_strength(test_password)
print("Password '" + test_password + "':", result)

Output:

Password 'MyPass123': Strong password

Nota: impareremo le funzioni nel Capitolo 19. Questo esempio mostra come gli script gestiscano logica complessa.

6. Automatizzi compiti

Gli script sono perfetti per l’automazione:

# backup_reminder.py
# Remind user to backup files
 
import datetime
 
today = datetime.date.today()
day_of_week = today.strftime("%A")
 
if day_of_week == "Friday":
    print("Don't forget to backup your files!")
else:
    print("Backup reminder: Next backup on Friday")

Nota: impareremo il modulo datetime nel Capitolo 39. Questo esempio mostra come gli script possano automatizzare compiti.

1.6.3) Un flusso di lavoro pratico

I programmatori Python professionisti usano tipicamente sia il REPL sia i file di script in modo complementare:

Esempio di flusso di lavoro:

1. Esplora nel REPL: prova un nuovo concetto o testa un calcolo.
2. Crea un prototipo nel REPL: costruisci una piccola versione funzionante.
3. Passa a uno script: quando funziona, spostalo in un file di script.
4. Espandi nello script: aggiungi funzionalità, gestione degli errori, ecc.
5. Fai debug con il REPL: se qualcosa si rompe, testa le singole parti nel REPL.
6. Finalizza lo script: completa, testa e salva il programma.

1.6.4) Un esempio concreto

Vediamo questo flusso di lavoro in azione. Supponiamo che tu voglia scrivere un programma che calcoli l’area di un cerchio.

Passo 1: esplorazione nel REPL

>>> # What's the formula? Area = π * r²
>>> # Let me use a simple approximation for π
>>> 3.14159 * 5 * 5
78.53975
>>> # Looks right!

Passo 2: crea uno script

Ora che sai che funziona, crea circle_area.py:

# circle_area.py
# Calculate the area of a circle
 
radius = 5
pi = 3.14159
area = pi * radius * radius
 
print("Radius:", radius)
print("Area:", area)

Output:

Radius: 5
Area: 78.53975

Passo 3: migliora lo script

Fallo funzionare con raggi diversi:

# circle_area_enhanced.py
# Calculate area for multiple circles
 
radii = [3, 5, 7, 10]
pi = 3.14159
 
for radius in radii:
    area = pi * radius * radius
    print("Circle with radius", radius, "has area", round(area, 2))

Output:

Circle with radius 3 has area 28.27
Circle with radius 5 has area 78.54
Circle with radius 7 has area 153.94
Circle with radius 10 has area 314.16

Nota: impareremo i cicli for nel Capitolo 11. Nel Capitolo 2 impareremo come rendere questo script interattivo usando l’input dell’utente.

Questo flusso di lavoro — sperimentare nel REPL, poi formalizzare in uno script — è il modo in cui vengono sviluppati molti programmi Python.

1.6.5) Punti chiave

Punti di forza del REPL:

• Feedback immediato
• Ottimo per imparare
• Perfetto per test rapidi
• Eccellente per l’esplorazione
• Nessuna gestione di file necessaria

Limiti del REPL:

• Il codice non è salvato
• Scomodo per codice su più righe
• Difficile da condividere
• Non adatto a programmi complessi

Punti di forza dei file di script:

• Il codice è salvato in modo permanente
• Facile da modificare e aggiornare
• Può essere condiviso con altri
• Adatto a programmi complessi
• Può essere eseguito ripetutamente
• Può essere automatizzato

Limiti dei file di script:

• Richiedono la creazione e gestione dei file
• Devi eseguirli per vedere i risultati
• Più "overhead" per test rapidi

Il miglior approccio è usare entrambi: il REPL per imparare, testare ed esplorare, e i file di script per qualsiasi cosa tu voglia conservare, condividere o eseguire ripetutamente.

1.7) Quale versione di Python usa questo libro (e perché è importante)

Python è cambiato significativamente nel corso degli anni, e versioni diverse possono comportarsi in modo diverso. Capire le versioni di Python ti aiuterà a evitare confusione e a garantire che il tuo codice funzioni come previsto.

Potresti chiederti perché stiamo dedicando tempo alle versioni di Python. Il motivo è semplice: incontrerai codice Python online, in tutorial e nella documentazione. Capire le versioni ti aiuta a riconoscere quando il codice è obsoleto ed evitare confusione quando qualcosa non funziona come ti aspetti.

1.7.1) Python 2 vs Python 3

La divisione più significativa nella storia di Python è tra Python 2 e Python 3.

Python 2 è stato rilasciato nel 2000 ed è stato la versione dominante per molti anni. Tuttavia, presentava alcuni problemi di progettazione che non potevano essere risolti senza rompere il codice esistente.

Python 3 è stato rilasciato nel 2008 come una grande riprogettazione che risolveva questi problemi. Tuttavia, non è retrocompatibile con Python 2, il che significa che il codice scritto per Python 2 spesso non funziona in Python 3 senza modifiche.

Per molti anni le due versioni sono convissute. Tuttavia, Python 2 ha raggiunto la fine del ciclo di vita il 1° gennaio 2020. Questo significa:

• Nessun aggiornamento o patch di sicurezza per Python 2
• Tutto il nuovo sviluppo in Python usa Python 3
• Tutte le principali librerie sono passate a Python 3
• Non è consigliato imparare Python 2 oggi

Questo libro usa esclusivamente Python 3. Tutti gli esempi di codice sono scritti per Python 3 e potrebbero non funzionare in Python 2.

1.7.2) Versioni minori di Python 3

All’interno di Python 3 esistono versioni minori (3.6, 3.7, 3.8, 3.9, 3.10, 3.11, 3.12, ecc.). Ogni versione minore aggiunge nuove funzionalità e miglioramenti mantenendo la compatibilità all’indietro con le versioni precedenti di Python 3.

Questo libro è scritto per Python 3.11 e successivi, ma la maggior parte degli esempi funzionerà su Python 3.8 e versioni successive.

Per verificare la tua versione di Python:

python --version  # Windows
python3 --version  # macOS/Linux

Dovresti vedere qualcosa come:

Python 3.11.5

Se vedi:

Python 2.7.18

Stai usando Python 2, che è obsoleto. Installa Python 3 seguendo le istruzioni nella Sezione 1.2.

1.7.3) Differenze chiave che potresti incontrare

Se leggi vecchi tutorial o codice Python online (soprattutto tutorial datati e risposte su Stack Overflow precedenti al 2020), potresti vedere sintassi che non funziona in Python 3. Ecco le differenze più comuni:

1. L’istruzione print vs la funzione print

Python 2:

print "Hello, World!"  # No parentheses

Python 3:

print("Hello, World!")  # Parentheses required

In Python 3, print è una funzione e richiede le parentesi. Questa è la differenza più evidente.

2. Comportamento della divisione

Questi cambiamenti sono stati introdotti per rendere Python più coerente e sicuro. Per esempio, trasformare print in una funzione permette di usarla come tutte le altre funzioni, e far sì che / faccia sempre la divisione con virgola mobile elimina una fonte comune di bug.

Python 2:

>>> 5 / 2
2  # Integer division
>>> 5.0 / 2
2.5  # Float division

Python 3:

>>> 5 / 2
2.5  # Always float division
>>> 5 // 2
2  # Integer division (floor division)

In Python 3, / esegue sempre la divisione con risultato float. Usa // per la divisione intera.

3. Funzione input()

Python 2:

name = raw_input("Enter your name: ")  # Returns string
age = input("Enter your age: ")  # Evaluates input as Python code (dangerous!)

Python 3:

name = input("Enter your name: ")  # Always returns string
age = int(input("Enter your age: "))  # Convert to int if needed

In Python 3, input() restituisce sempre una stringa, cosa più sicura e coerente.

4. Stringhe e Unicode

Python 3 gestisce il testo (Unicode) molto meglio di Python 2. Tutte le stringhe in Python 3 sono Unicode per impostazione predefinita, rendendo molto più semplice la gestione del testo internazionale.

1.7.4) Funzionalità per versione di Python 3

Le diverse versioni di Python 3 hanno introdotto funzionalità differenti. Ecco cosa ti serve sapere:

Python 3.6 (dicembre 2016):

• f-strings per la formattazione delle stringhe (le useremo ampiamente)

# f_string_example.py
name = "Alice"
print(f"Hello, {name}!")

Output:

Hello, Alice!

Nota: impareremo le f-strings nel Capitolo 6.

Python 3.8 (ottobre 2019):

• Operatore walrus (:=) per le espressioni di assegnazione (lo vedremo nel Capitolo 40)

Python 3.10 (ottobre 2021):

• Pattern matching strutturale con match e case (ne parleremo nel Capitolo 12)

Python 3.11 (ottobre 2022):

• Messaggi di errore significativamente migliorati
• Migliori prestazioni
• Gestione delle eccezioni potenziata

Python 3.12 (ottobre 2023):

• Ulteriori miglioramenti di prestazioni
• Nuove funzionalità per le annotazioni di tipo
• Sintassi delle f-string migliorata

1.7.5) Quale versione dovresti usare?

Raccomandazione: usa Python 3.11 o successivo se possibile. Ecco perché:

1. Messaggi di errore migliori: Python 3.11 ha messaggi di errore molto più chiari, più utili per chi inizia.

2. Prestazioni migliori: Python 3.11 è più veloce delle versioni precedenti.

3. Funzionalità moderne: avrai accesso a tutte le ultime funzionalità di Python.

4. Più longevo: il codice scritto per Python 3.11 funzionerà nelle versioni future.

Tuttavia, qualsiasi versione Python dalla 3.8 in su andrà bene per imparare da questo libro. I concetti fondamentali restano gli stessi.

1.7.6) Verificare la disponibilità delle funzionalità

Se usi una versione di Python più vecchia e incontri codice che non funziona, puoi verificare quale versione ha introdotto una certa funzionalità.

Per esempio, se stai usando Python 3.5 o precedente, potresti dover usare una formattazione delle stringhe più vecchia:

# format_example.py
# Works in all Python 3 versions
name = "Alice"
print("Hello, {}!".format(name))

Output:

Hello, Alice!

1.7.7) Restare aggiornati

Python rilascia una nuova versione minore circa una volta l’anno. Non è necessario aggiornare immediatamente, ma è una buona idea restare ragionevolmente aggiornati:

• Controlla gli aggiornamenti ogni pochi mesi.
• Leggi le note di rilascio per conoscere le nuove funzionalità.
• Aggiorna quando è conveniente, soprattutto per aggiornamenti di sicurezza.
• Testa il tuo codice dopo l’aggiornamento per assicurarti che sia compatibile.

Puoi trovare le versioni di Python e la documentazione su https://www.python.org/.

1.7.8) Compatibilità di versione in questo libro

In tutto il libro:

• Tutti gli esempi di codice funzionano su Python 3.11+
• La maggior parte degli esempi funziona su Python 3.8+
• Le funzionalità specifiche di versione sono chiaramente indicate (ad esempio, "Richiede Python 3.10+")
• Sono fornite alternative quando opportuno per le versioni più vecchie

Quando vedi del codice in questo libro, puoi tranquillamente digitarlo in Python 3.11 o successivo e aspettarti che funzioni esattamente come mostrato.

1.7.9) Una nota sul codice Python 2 che potresti trovare online

Se cerchi aiuto su Python online, potresti imbatterti in codice Python 2. Ecco come riconoscerlo:

Segnali di codice Python 2:

• print senza parentesi: print "Hello"
• Funzione raw_input()
• Divisione che produce interi: 5 / 2 uguale a 2
• Vecchia formattazione delle stringhe: "Hello %s" % name
• Commenti che indicano "Python 2" o che menzionano la versione 2.x

Cosa fare:

• Cerca alternative per Python 3.
• Aggiungi "python 3" alle tue ricerche.
• Controlla la data: qualsiasi cosa precedente al 2020 potrebbe essere Python 2.
• Usa la documentazione ufficiale di Python 3: https://docs.python.org/3/.

Congratulazioni! Hai completato il Capitolo 1 e hai mosso i tuoi primi passi con Python. Ora sai:

• Che cos’è Python e come funziona
• Come installare Python ed eseguire l’interprete
• Come usare la shell interattiva di Python (REPL) per sperimentare
• Come creare ed eseguire file di script Python
• Come leggere e capire i messaggi di errore e i traceback
• Quando usare il REPL e quando usare i file di script
• Quale versione di Python usare e perché è importante

Ora sei pronto per passare al Capitolo 2, dove scriverai i tuoi primi programmi Python completi, imparerai la funzione print() in dettaglio e inizierai a lavorare con l’input dell’utente. Le basi che hai costruito in questo capitolo sosterranno tutto ciò che imparerai in seguito.