Svogliati
🐍

Pythonper Svogliati

Il linguaggio che si legge come pseudocodice, gira ovunque e ha una libreria per tutto. Lento? Sì. Ma tu lo finisci prima, e spesso è l'unica velocità che conta.

"import antigravity" — e in effetti si vola. Fino al giorno in cui devi installare una dipendenza sul server di produzione.

↓
01 / 15

Come è nato (colpa delle vacanze di Natale)

Un programmatore olandese, un ufficio chiuso per le feste e la voglia di un linguaggio di scripting meno noioso della shell e meno faticoso del C.

💡 Il progetto per passare le feste

Dicembre 1989, Amsterdam. Guido van Rossum lavora al CWI, il centro di ricerca olandese di matematica e informatica. L'ufficio è chiuso per Natale e lui cerca, parole sue, "un progetto hobby per tenermi occupato durante la settimana di Natale". Decide di scrivere un interprete per un linguaggio nuovo, erede di ABC, un linguaggio didattico su cui aveva lavorato e che gli piaceva a metà. Il nome? Non viene dal serpente: viene dal Monty Python's Flying Circus, di cui era fan. Il serpente è arrivato dopo, sulle copertine dei libri, e ormai è tardi per lamentarsi.

Dicembre 1989

Il progetto hobby

Van Rossum inizia l'interprete. Gli serviva anche per il lavoro: un linguaggio di scripting per Amoeba, il sistema operativo distribuito su cui lavorava al CWI.

Febbraio 1991

Python 0.9.0

Pubblicato su Usenet, nel gruppo alt.sources. Ha già classi con ereditarietà, eccezioni, funzioni e i tipi base list, dict e str. E l'indentazione al posto delle graffe, che fa discutere da allora.

1994

Python 1.0

Arrivano lambda, map, filter e reduce, regalo di un fan del Lisp. Van Rossum non le ha mai amate e anni dopo ha provato a toglierle. lambda è sopravvissuta.

2000

Python 2.0

List comprehension, un garbage collector per i riferimenti circolari e lo sviluppo che si sposta su un modello più aperto. Nel 2001 nasce la Python Software Foundation, che da allora detiene i diritti sul linguaggio.

Dicembre 2008

Python 3.0, la grande rottura

Una versione volutamente incompatibile per sistemare gli errori di gioventù: print diventa una funzione, le stringhe sono Unicode di default, la divisione 3 / 2 fa 1.5. Il passaggio richiederà più di dieci anni. Dieci. Anni.

Luglio 2018

Il dittatore si dimette

Van Rossum era il BDFL, "Benevolent Dictator For Life". Dopo una discussione feroce sull'operatore := (PEP 572) lascia il ruolo. Dal 2019 il linguaggio è guidato da uno Steering Council di cinque persone, eletto dagli sviluppatori.

1 gennaio 2020

Fine di Python 2

Python 2.7 smette di ricevere aggiornamenti, dopo una proroga di cinque anni. Da qualche parte un server aziendale lo esegue ancora. Forse il tuo.

2021-2022

Primo in classifica, e finalmente più veloce

Da ottobre 2021 Python è primo nell'indice TIOBE. Python 3.11 (ottobre 2022) è il primo frutto del progetto Faster CPython: in media circa il 25% più veloce della 3.10, senza cambiare una riga del tuo codice.

2024-2025

Via il GIL (piano piano)

Python 3.13 introduce una build sperimentale senza GIL e un compilatore JIT sperimentale. Con la 3.14 (ottobre 2025, inevitabilmente chiamata "Pi-thon") la build senza GIL diventa supportata ufficialmente, anche se non è ancora quella di default.

Oggi

Ovunque, soprattutto dove non lo vedi

Una nuova versione ogni ottobre, ognuna supportata per cinque anni. Dentro Ansible, OpenStack, Salt, certbot, gli installer di molte distribuzioni, Instagram, YouTube, Dropbox, e praticamente ogni progetto di machine learning del pianeta.

🧘 Lo Zen di PythonScrivi import this nell'interprete e ottieni 19 aforismi di Tim Peters (PEP 20). I più citati: "Beautiful is better than ugly", "Readability counts", "There should be one — and preferably only one — obvious way to do it". Sul terzo, chi ha provato a impacchettare un progetto Python avrebbe qualcosa da dire.
02 / 15

Perché esiste

Il tempo del programmatore costa più del tempo della CPU. Python ottimizza il primo e lascia al secondo il conto.

📖 Il codice si legge molte più volte di quante si scrivaÈ l'idea su cui è costruito tutto il linguaggio. Per questo l'indentazione è obbligatoria, la sintassi è scarna e le parole chiave sono parole inglesi (and, or, not, in, is) invece di simboli.

✍️ Veloce da scrivere

  • Niente compilazione: scrivi, lanci, vedi il risultato
  • Tipizzazione dinamica: non dichiari i tipi (ma puoi, vedi capitolo 11)
  • Un interprete interattivo per provare le cose al volo
  • Gestione della memoria automatica

🔋 Batterie incluse

  • Libreria standard enorme: JSON, CSV, HTTP, SQLite, regex, zip, email, socket
  • PyPI: più di mezzo milione di pacchetti per tutto il resto
  • Preinstallato su quasi ogni distribuzione Linux
  • Lo stesso script gira su Linux, macOS e Windows
🧪

Il REPL

Scrivi python3 e hai una calcolatrice programmabile. Dalla 3.13 ha anche colori, modifica multiriga e cronologia decente.

🧩

Linguaggio colla

Le librerie pesanti (numpy, PyTorch, cryptography) sono scritte in C, C++ o Rust. Python le incolla insieme con una sintassi umana.

🎓

Si impara in fretta

È il primo linguaggio in moltissime università. Un sistemista che sa bash scrive il suo primo script utile in un pomeriggio.

🌍

Fa di tutto

Automazione, web, dati, IA, test, GUI, giochi. Non sempre è il migliore, ma quasi sempre è abbastanza buono.

🐢 Sì, ma è lento

Vero. Un ciclo in Python puro è spesso 30-100 volte più lento dello stesso ciclo in C o Rust. Ma in uno script tipico il programma passa la maggior parte del tempo ad aspettare: il disco, la rete, il database, te. E quando serve davvero velocità sui numeri, il lavoro lo fanno le librerie in C: numpy moltiplica matrici alla velocità del C, Python decide solo quali matrici.

03 / 15

Quando usarlo (e quando lasciar perdere)

Python è la seconda scelta migliore per quasi tutto. Il trucco è riconoscere quando serve la prima.

Python è una buona idea per

  • Script di automazione appena bash diventa illeggibile
  • Strumenti interni, report, conversioni di file, chiamate ad API
  • Backend web e API (Django, FastAPI, Flask)
  • Analisi dati, notebook, grafici
  • Machine learning e IA: non c'è partita
  • Test automatici, anche di software scritto in altri linguaggi
  • Prototipi da mostrare domani
  • Moduli Ansible, plugin, script di monitoraggio

Meglio altro per

  • Una pipeline di tre comandi: resta in bash
  • Calcolo pesante in puro Python, senza librerie in C
  • Tool da distribuire come binario unico: Go o Rust
  • Software di sistema, driver, embedded serio
  • App mobile native
  • Frontend nel browser: lì regna JavaScript
  • Servizi dove ogni millisecondo e ogni MB di RAM costano
ConfrontoScegli Python se...Scegli l'altro se...
vs BashCi sono strutture dati, gestione degli errori, più di una schermata di codiceStai solo incollando comandi uno dopo l'altro
vs GoConta la velocità di scrittura, o ti servono librerie per dati e IAVuoi un binario unico, concorrenza semplice e consumi bassi
vs RustLo script deve esistere entro seraContano prestazioni, sicurezza della memoria e anni di manutenzione
vs JavaScript/NodeBackend, dati, automazione di sistemaIl codice gira nel browser, o vuoi un solo linguaggio fra frontend e backend
vs Java/C#Team piccolo, progetto agile, meno cerimonieEcosistema enterprise già in piedi, codebase enorme con tanti sviluppatori
📦 Il vero prezzo da pagareNon è la lentezza: è la distribuzione. Un programma Python ha bisogno dell'interprete giusto e delle dipendenze giuste sulla macchina giusta. Per anni è stato un incubo (c'è una vignetta di xkcd, la 1987, che lo riassume con un groviglio di frecce). Oggi con uv è quasi un problema risolto: lo vediamo nel capitolo 5.
04 / 15

Nomi, oggetti e mutabilità

Il modello mentale che evita metà dei bug di Python. Capito questo, il resto è sintassi.

💡 L'analogia dei post-it

In C una variabile è una scatola: metti dentro un valore. In Python una variabile è un post-it attaccato a un oggetto che sta da qualche parte in memoria. a = [1, 2] crea una lista e ci attacca il post-it "a". b = a non copia la lista: attacca un secondo post-it, "b", sulla stessa lista. Se scrivi sulla lista usando "b", la vedi cambiata anche guardando "a". Quando un oggetto non ha più post-it attaccati, Python lo butta via.

REGOLA 1

Tutto è un oggetto

Numeri, stringhe, funzioni, classi, moduli, perfino None. Ogni oggetto ha un tipo (type(x)) e un'identità (id(x)).

REGOLA 2

Le variabili sono etichette

L'assegnazione = non copia mai niente: lega un nome a un oggetto. Anche passare un argomento a una funzione lega un nuovo nome allo stesso oggetto.

REGOLA 3

Mutabile o immutabile

int, float, str, tuple, frozenset non cambiano mai. list, dict, set e i tuoi oggetti sì. Il problema nasce solo con i secondi.

🏷️ Due post-it, una lista

python
a = [1, 2, 3]
b = a                  # stesso oggetto, due nomi
b.append(4)
print(a)               # [1, 2, 3, 4]  sorpresa!

c = a.copy()           # copia (superficiale): oggetto nuovo
c.append(5)
print(a)               # [1, 2, 3, 4]  a non cambia

import copy
d = copy.deepcopy(dati)  # copia anche le liste dentro le liste

x = 10
y = x
y += 1                 # gli int sono immutabili: y ora punta a un NUOVO oggetto 11
print(x)               # 10

Con gli immutabili non te ne accorgi mai, perché ogni "modifica" crea un oggetto nuovo. Con liste e dizionari, invece, la stessa modifica si vede da tutti i nomi che puntano lì.

⚖️ == contro is

python
a = [1, 2]
b = [1, 2]
a == b        # True: stesso contenuto
a is b        # False: oggetti diversi

if risultato is None:      # giusto: None è unico, si confronta con is
    ...
if risultato == None:      # funziona, ma i linter ti sgridano
    ...

Regola pratica: is solo con None, True e False. Per tutto il resto ==. Usare is con numeri o stringhe a volte "funziona" per un dettaglio di implementazione, e poi smette di funzionare in produzione.

♻️ Chi libera la memoria

CPython, l'interprete standard, conta quanti riferimenti punta a ogni oggetto (reference counting): quando arriva a zero, l'oggetto viene liberato subito. Per i riferimenti circolari (A punta a B, B punta ad A) interviene un garbage collector periodico. del x non distrugge l'oggetto: stacca il post-it "x". Se era l'ultimo, allora sì.

🔒 E il GIL?Per tenere coerente quel contatore fra thread, CPython ha storicamente un Global Interpreter Lock: un solo thread alla volta esegue bytecode Python. È il motivo per cui i thread non accelerano il calcolo puro. Ne parliamo nel capitolo 12, insieme alla build senza GIL della 3.14.
05 / 15

Installare Python, ambienti virtuali e uv

La parte dove storicamente la gente si arrendeva. Oggi è un comando.

🚫 Il Python di sistema non è tuoSu Linux il python3 in /usr/bin serve al sistema operativo: ci girano pezzi del gestore pacchetti, firewall-cmd, cloud-init e altro. Se ci installi pacchetti con sudo pip install puoi rompere la distribuzione. Per questo Debian 12, Ubuntu 23.04 e successive rispondono con error: externally-managed-environment (PEP 668). Non è un bug: è il sistema che si difende da te.

📦 L'ambiente virtuale, alla vecchia maniera

Un ambiente virtuale (venv) è una cartella con un Python e i suoi pacchetti, separata da tutto il resto. Un progetto, un venv.

shell
python3 -m venv .venv            # crea l'ambiente nella cartella .venv
source .venv/bin/activate       # lo attiva (Windows: .venv\Scripts\activate)
python -m pip install requests  # installa DENTRO il venv
python -m pip freeze > requirements.txt
deactivate

Funziona ovunque ed è nella libreria standard. Il difetto: la versione di Python la devi installare tu, il lock delle versioni è approssimativo e pip è lento.

⚡ uv: tutto in uno, e veloce

uv (di Astral, scritto in Rust) gestisce le versioni di Python, gli ambienti virtuali, le dipendenze e il file di lock. Sostituisce pip, venv, pip-tools, pipx e pyenv, ed è da 10 a 100 volte più veloce di pip.

shell
# installazione (Linux / macOS); su Windows c'è l'equivalente PowerShell su docs.astral.sh/uv
curl -LsSf https://astral.sh/uv/install.sh | sh

uv init rapporto              # nuovo progetto con pyproject.toml
cd rapporto
uv add httpx rich             # aggiunge dipendenze e aggiorna uv.lock
uv add --dev pytest ruff      # dipendenze solo per sviluppo
uv run main.py                # crea il venv se manca, sincronizza, lancia
uv sync                       # su un'altra macchina: ricrea l'ambiente identico

uv python install 3.14       # scarica una versione di Python, senza toccare quella di sistema
uv tool install ruff         # tool da riga di comando isolato (al posto di pipx)
uvx pycowsay ciao              # lancia un tool al volo senza installarlo
struttura
rapporto/
├── pyproject.toml    # nome, versione, Python richiesto, dipendenze
├── uv.lock           # versioni esatte risolte (committalo)
├── .python-version   # la versione di Python del progetto
├── main.py
└── .venv/            # l'ambiente (nel .gitignore, si ricrea con uv sync)
pyproject.toml
[project]
name = "rapporto"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
    "httpx>=0.27",
    "rich>=13",
]

[dependency-groups]
dev = ["pytest>=8", "ruff>=0.6"]

[tool.ruff]
line-length = 100

📜 Lo script singolo con le sue dipendenze

Il caso tipico del sistemista: un file solo, che però ha bisogno di una libreria. Le dipendenze si dichiarano in un commento in testa allo script (PEP 723) e uv run pensa al resto.

controlla_cert.py
#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.12"
# dependencies = ["httpx"]
# ///
import httpx

r = httpx.get("https://example.org")
print(r.status_code)

chmod +x controlla_cert.py e lo lanci come un qualsiasi comando: al primo avvio uv prepara un ambiente in cache, dal secondo parte subito. Niente venv da ricordare, niente requirements.txt da portarsi dietro.

💡 Trucco da svogliatoSe devi per forza usare pip, scrivi sempre python -m pip e mai pip da solo. Così installi nel Python che stai davvero usando, e non in uno dei tre che hai sul sistema senza saperlo.
06 / 15

Le basi: variabili, tipi, funzioni, cicli

La parte che somiglia agli altri linguaggi. Con l'indentazione al posto delle graffe.

📐 L'indentazione è sintassi

python
if spazio_libero < 10:
    print("disco quasi pieno")      # 4 spazi = dentro l'if
    avvisa_admin()
print("controllo finito")          # fuori dall'if

Niente graffe, niente end, niente fi: il blocco è quello che è indentato. La convenzione (PEP 8) è 4 spazi. Mai mescolare tab e spazi: Python 3 si rifiuta di indovinare.

🔢 Tipi di base

TipoEsempiNote
Intero42, -7, 1_000_000, 0xffPrecisione illimitata: 2 ** 1000 funziona. Niente overflow, mai
Virgola mobile3.14, 1e-6A 64 bit: 0.1 + 0.2 fa 0.30000000000000004. Per i soldi c'è decimal
BooleanoTrue, FalseCon la maiuscola. E sono interi: True + True == 2
Stringa'ciao', "ciao", """su più righe"""Unicode, immutabile
Byteb'\x00\xff'Dati binari: socket, file, crittografia
NienteNoneL'unico valore del suo tipo. Il null di Python
➗ Due divisioni7 / 2 fa 3.5, sempre. 7 // 2 fa 3 (divisione intera, arrotonda verso il basso: -7 // 2 fa -4). 7 % 2 è il resto, 2 ** 10 la potenza.
🎭 Verità e falsitàIn un if sono "falsi" 0, 0.0, "", [], {}, set() e None. Tutto il resto è vero. Per questo si scrive if lista: invece di if len(lista) > 0:.

🧵 Stringhe e f-string

python
host = "web01"
uso = 0.8734

print(f"{host}: disco al {uso:.1%}")        # web01: disco al 87.3%
print(f"{host:<10}|")                    # allineato a sinistra su 10 caratteri
print(f"{uso=}")                           # uso=0.8734  (comodissimo per il debug)

riga = "  root:x:0:0:root:/root:/bin/bash\n"
campi = riga.strip().split(":")             # ['root', 'x', '0', ...]
",".join(["a", "b", "c"])                     # 'a,b,c'
"errore" in riga                              # contiene?
riga.startswith("#"), riga.replace("x", "*"), riga.upper()

percorso = r"C:\nuova\cartella"               # r = raw: le \ restano \ (utile per le regex)

🔧 Funzioni

python
def saluta(nome, saluto="Ciao"):
    """Restituisce un saluto. Questa è la docstring."""
    return f"{saluto}, {nome}!"

saluta("Renzo")                     # 'Ciao, Renzo!'
saluta("Renzo", saluto="Salve")     # argomento per nome

# * raccoglie gli argomenti posizionali in una tupla, ** quelli per nome in un dict
def log(livello, *messaggi, **extra):
    print(livello, messaggi, extra)

log("INFO", "avvio", "porta 8080", host="web01")
# INFO ('avvio', 'porta 8080') {'host': 'web01'}

# dopo * solo per nome, prima di / solo per posizione
def connetti(host, /, *, porta=22, timeout=5):
    ...

connetti("db01", porta=5432)        # ok
connetti("db01", 5432)              # TypeError: takes 1 positional argument but 2 were given

# più valori di ritorno = una tupla, che si "spacchetta"
def min_max(valori):
    return min(valori), max(valori)

basso, alto = min_max([3, 9, 1])

Una funzione senza return restituisce None. Ricordatelo: è l'origine del celebre 'NoneType' object is not subscriptable.

🔁 Condizioni e cicli

python
if codice == 200:
    stato = "ok"
elif 500 <= codice < 600:             # confronti concatenati, come in matematica
    stato = "server rotto"
else:
    stato = "boh"

etichetta = "pari" if n % 2 == 0 else "dispari"   # if in una riga

for i in range(5): ...                  # 0,1,2,3,4
for i in range(10, 0, -2): ...          # 10,8,6,4,2

servizi = ["arx", "nomina", "missus"]
for i, nome in enumerate(servizi, start=1):
    print(f"{i}. {nome}")

for host, ip in zip(nomi, indirizzi):     # due liste in parallelo
    ...

while tentativi < 3:
    tentativi += 1                       # niente ++ in Python

# for ... else: l'else parte solo se il ciclo NON è uscito con break
for host in server:
    if risponde(host):
        break
else:
    print("nessun server risponde")

# walrus := assegna e usa nello stesso momento
while (riga := f.readline()):
    elabora(riga)
07 / 15

Liste, dizionari, set e comprehension

Quattro strutture dati coprono il 95% dei casi. Il restante 5% sta nel modulo collections.

TipoSintassiMutabileQuando
list[1, 2, 3]sìSequenza ordinata che cresce e cambia
tuple(1, 2, 3)noRecord fisso: coordinate, righe di un database, chiavi di un dict
dict{"host": "web01"}sìChiave → valore. Mantiene l'ordine di inserimento
set{1, 2, 3}sìElementi unici, test di appartenenza velocissimo

📋 Liste e slicing

python
porte = [22, 80, 443]
porte.append(8080)             # aggiunge in fondo
porte.extend([3306, 5432])    # aggiunge più elementi
porte.remove(80)               # toglie per valore
ultima = porte.pop()           # toglie e restituisce l'ultimo
porte.sort()                   # ordina SUL POSTO e restituisce None
ordinate = sorted(porte, reverse=True)   # nuova lista ordinata

# slicing: [inizio:fine:passo], la fine è esclusa
v = [0, 1, 2, 3, 4, 5]
v[0]       # 0
v[-1]      # 5  (gli indici negativi contano dalla fine)
v[1:4]     # [1, 2, 3]
v[:3]      # [0, 1, 2]
v[::2]     # [0, 2, 4]
v[::-1]    # [5, 4, 3, 2, 1, 0]  (al contrario)

# unpacking
primo, *resto = v              # primo=0, resto=[1, 2, 3, 4, 5]
a, b = b, a                    # scambio senza variabile temporanea

📒 Dizionari

python
server = {"nome": "web01", "ip": "10.0.0.5", "porte": [22, 443]}

server["nome"]                    # 'web01'
server["ram"]                     # KeyError: 'ram'
server.get("ram")                 # None, senza errori
server.get("ram", "4G")           # valore di default
server["ram"] = "8G"              # aggiunge o sovrascrive
del server["porte"]

for chiave, valore in server.items():
    print(f"{chiave} = {valore}")

"ip" in server                     # True: cerca fra le chiavi
unito = base | personalizzato      # unisce due dict (a destra vince)

🎯 Set

python
aperte = {22, 80, 443, 3306}
permesse = {22, 80, 443}

aperte - permesse          # {3306}  porte aperte che non dovrebbero esserlo
aperte & permesse          # intersezione
aperte | permesse          # unione
set(lista_con_doppioni)    # toglie i duplicati
vuoto = set()              # attenzione: {} è un dict vuoto, non un set

🧪 Comprehension: cicli in una riga

python
# [espressione for elemento in sequenza if condizione]
quadrati = [x * x for x in range(10)]
errori = [r for r in righe if "ERROR" in r]
ip_per_host = {s["nome"]: s["ip"] for s in server}     # dict comprehension
utenti = {r.split(":")[0] for r in righe}              # set comprehension

# con le tonde è un generatore: calcola un elemento alla volta, senza lista in memoria
totale = sum(len(r) for r in open("/var/log/syslog"))

Leggibili finché stanno in una riga. Se ti servono due for annidati e tre if, scrivi il ciclo normale: nessuno ti dà un premio per la riga più densa.

🧰 Il modulo collections

python
from collections import Counter, defaultdict, deque

# contare: gli IP che compaiono di più in un log
conteggio = Counter(riga.split()[0] for riga in open("access.log"))
conteggio.most_common(5)

# raggruppare senza controllare se la chiave esiste
per_stato = defaultdict(list)
for s in server:
    per_stato[s.stato].append(s.nome)

# coda con le ultime N righe (come tail -n 100)
ultime = deque(open("app.log"), maxlen=100)
08 / 15

Eccezioni e context manager

In Python gli errori si lanciano e si prendono. E i file si chiudono da soli, se glielo chiedi bene.

🥅 try, except, else, finally

python
try:
    with open("/etc/app/config.json") as f:
        config = json.load(f)
except FileNotFoundError:
    config = DEFAULT                       # errore previsto: gestito
except json.JSONDecodeError as e:
    sys.exit(f"config non valida alla riga {e.lineno}")
else:
    print("config caricata")            # solo se NON c'è stato errore
finally:
    print("questo gira sempre")          # errore o no

# lanciare un errore
if porta not in range(1, 65536):
    raise ValueError(f"porta non valida: {porta}")

Così sì

  • Prendi solo le eccezioni che sai gestire: except FileNotFoundError
  • Tieni il blocco try più corto possibile
  • Rilancia con contesto: raise ConfigError(...) from e
  • Lascia arrivare in cima gli errori che non sai gestire: il traceback è un regalo

Così no

  • except: nudo, che prende perfino il Ctrl+C
  • except Exception: pass, il buco nero dei bug
  • Usare le eccezioni per il flusso normale di ogni riga
  • Stampare l'errore e continuare come se niente fosse

🏷️ Eccezioni tue

python
class BackupError(Exception):
    """Qualcosa è andato storto durante il backup."""

class SpazioInsufficiente(BackupError):
    def __init__(self, servono, liberi):
        super().__init__(f"servono {servono} GB, liberi {liberi}")
        self.servono = servono
        self.liberi = liberi

try:
    esegui_backup()
except SpazioInsufficiente as e:
    pulisci_vecchi(e.servono - e.liberi)
except BackupError:
    avvisa_admin()                         # prende tutte le altre sottoclassi

🚪 with: il context manager

with garantisce che una risorsa venga chiusa all'uscita del blocco, anche se nel mezzo esplode un'eccezione. File, connessioni, lock, transazioni.

python
with open("report.txt", "w", encoding="utf-8") as f:
    f.write("tutto ok\n")
# qui il file è già chiuso

with lock:                                # threading.Lock: acquisito e rilasciato
    contatore += 1

# scriverne uno tuo con un generatore
from contextlib import contextmanager
import time

@contextmanager
def cronometro(nome):
    inizio = time.perf_counter()
    try:
        yield
    finally:
        print(f"{nome}: {time.perf_counter() - inizio:.2f}s")

with cronometro("backup"):
    esegui_backup()
🤷 EAFP: chiedere scusa invece del permessoLo stile tipico di Python è "Easier to Ask Forgiveness than Permission": invece di controllare if os.path.exists(f) e poi aprire, apri direttamente e prendi FileNotFoundError. Oltre a essere più corto, evita la corsa in cui il file sparisce fra il controllo e l'apertura.
09 / 15

Classi, dataclass e match

Gli oggetti in Python sono semplici. A volte fin troppo: niente è davvero privato, tutto è per convenzione.

🧱 Una classe

python
class Server:
    porta_ssh = 22                          # attributo di classe, condiviso

    def __init__(self, nome, ip):          # il "costruttore"
        self.nome = nome                    # attributi dell'istanza
        self.ip = ip
        self._tentativi = 0                 # _ = "interno, non toccare" (per convenzione)

    def ping(self):                         # self è l'istanza, sempre esplicito
        self._tentativi += 1
        return True

    def __repr__(self):                     # come appare in print e nel debugger
        return f"Server({self.nome!r}, {self.ip!r})"

web = Server("web01", "10.0.0.5")            # niente new
web.ping()

🧬 Ereditarietà, property e metodi speciali

python
class Database(Server):
    def __init__(self, nome, ip, motore="postgres"):
        super().__init__(nome, ip)            # chiama il genitore
        self.motore = motore

    @property
    def porta(self):                      # si legge come un attributo: db.porta
        return 5432 if self.motore == "postgres" else 3306

    @classmethod
    def da_riga(cls, riga):                 # costruttore alternativo
        nome, ip, motore = riga.split(",")
        return cls(nome, ip, motore)

    @staticmethod
    def porta_valida(p):                   # funzione qualsiasi, messa qui per ordine
        return 0 < p < 65536

db = Database.da_riga("db01,10.0.0.9,mysql")
db.porta                                    # 3306

I metodi con il doppio trattino basso (dunder) collegano la tua classe alla sintassi del linguaggio: __len__ per len(x), __eq__ per ==, __lt__ per < e quindi per sorted, __iter__ per il for, __getitem__ per x[i], __enter__/__exit__ per il with.

📦 dataclass: classi senza fatica

python
from dataclasses import dataclass, field

@dataclass
class Utente:
    login: str
    uid: int
    shell: str = "/bin/bash"
    gruppi: list[str] = field(default_factory=list)   # mai = [] (vedi capitolo 14)

u = Utente("renzo.panocia", 1000)
print(u)          # Utente(login='renzo.panocia', uid=1000, shell='/bin/bash', gruppi=[])
u == Utente("renzo.panocia", 1000)        # True: __eq__ generato in automatico

@dataclass(frozen=True)                     # immutabile, quindi usabile come chiave di un dict
class Punto:
    x: float
    y: float

__init__, __repr__ e __eq__ scritti per te. Per il 90% delle classi che "contengono dati" è tutto quello che serve.

🎨 Enum

python
from enum import Enum

class Stato(Enum):
    ATTIVO = "attivo"
    MANUTENZIONE = "manutenzione"
    SPENTO = "spento"

s = Stato("attivo")       # Stato.ATTIVO, da una stringa letta da un file
s is Stato.ATTIVO          # True

🔍 match: il pattern matching (dalla 3.10)

Non è solo uno switch: guarda dentro la struttura dei dati e ne estrae i pezzi.

python
match comando.split():
    case ["start", servizio]:
        avvia(servizio)
    case ["stop", servizio, "--force"]:
        ferma(servizio, forza=True)
    case ["restart", *servizi]:
        for s in servizi: riavvia(s)
    case ["quit" | "exit"]:
        sys.exit()
    case _:
        print("comando sconosciuto")

# funziona anche su dict e oggetti
match evento:
    case {"tipo": "login", "utente": u, "esito": "fallito"}:
        conta_tentativo(u)
    case Utente(uid=0):
        print("root, occhio")
    case Punto(x=x, y=y) if x == y:          # con una condizione (guard)
        print("sulla diagonale")

case _ prende tutto il resto. A differenza di Rust, Python non ti obbliga a coprire tutti i casi: se nessun case corrisponde, semplicemente non succede niente.

10 / 15

Lambda, decoratori e generatori

Le funzioni in Python sono oggetti: si passano, si restituiscono, si avvolgono in altre funzioni.

λ Lambda e funzioni come valori

python
# una lambda è una funzione anonima di UNA sola espressione
server.sort(key=lambda s: s.carico)                 # ordina per carico
max(server, key=lambda s: s.disco_usato)            # il più pieno

# closure: una funzione che si ricorda le variabili di dove è nata
def soglia(limite):
    def supera(valore):
        return valore > limite
    return supera

critico = soglia(90)
critico(95)                                            # True

from functools import partial
connetti_db = partial(connetti, porta=5432, timeout=10)  # argomenti già fissati

🎀 Decoratori

Un decoratore è una funzione che prende una funzione e ne restituisce un'altra, di solito la stessa con qualcosa intorno. @decoratore sopra una def è solo zucchero per f = decoratore(f).

python
import functools, time

def riprova(volte=3, attesa=1):
    def decoratore(funzione):
        @functools.wraps(funzione)            # conserva nome e docstring
        def involucro(*args, **kwargs):
            for tentativo in range(1, volte + 1):
                try:
                    return funzione(*args, **kwargs)
                except ConnectionError:
                    if tentativo == volte:
                        raise
                    time.sleep(attesa)
        return involucro
    return decoratore

@riprova(volte=5)
def scarica_backup(url):
    ...

# decoratori già pronti nella libreria standard
@functools.cache                            # memorizza i risultati: la seconda chiamata è gratis
def risolvi_dns(nome): ...

Li incontri ovunque: @app.get("/") in FastAPI e Flask, @pytest.fixture nei test, @property e @dataclass che hai già visto.

🌊 Generatori e yield

Una funzione con yield non restituisce un valore: restituisce un generatore, che produce i valori uno alla volta, solo quando servono. Perfetto per file enormi e flussi infiniti.

python
def righe_di_errore(percorso):
    with open(percorso, encoding="utf-8", errors="replace") as f:
        for riga in f:                       # un file si legge già riga per riga
            if " ERROR " in riga:
                yield riga.rstrip()

# un log da 20 GB, ma in memoria c'è una riga alla volta
for errore in righe_di_errore("/var/log/app.log"):
    print(errore)

# i generatori si concatenano come le pipe della shell
import itertools
prime_10 = list(itertools.islice(righe_di_errore("app.log"), 10))   # come | head

⛓️ itertools e funzioni integrate da conoscere

FunzioneCosa fa
any(), all()Almeno uno vero, tutti veri: any(s.giu for s in server)
sum(), min(), max()Con key= per scegliere il criterio
sorted(), reversed()Nuova sequenza ordinata o al contrario
enumerate(), zip()Indice + valore, più sequenze in parallelo
itertools.chain()Più sequenze una dopo l'altra
itertools.groupby()Raggruppa elementi consecutivi (ordina prima!)
itertools.batched()A blocchi di N: batched(host, 10) (dalla 3.12)
itertools.product()Tutte le combinazioni, al posto dei for annidati
11 / 15

Type hint: i tipi, se li vuoi

Python resta dinamico, ma puoi scrivere i tipi. L'interprete li ignora, l'editor e mypy no.

🏷️ Annotare variabili e funzioni

python
def disco_libero(percorso: str, soglia: float = 0.9) -> bool:
    ...

porte: list[int] = [22, 443]
config: dict[str, str] = {}
coppia: tuple[str, int] = ("web01", 22)

def trova_utente(login: str) -> Utente | None:       # può restituire None
    ...

def porta(valore: int | str) -> int:                 # uno dei due tipi
    return int(valore)

# generici con la sintassi nuova (dalla 3.12)
def primo[T](elementi: list[T]) -> T:
    return elementi[0]

type Indirizzo = tuple[str, int]                       # alias di tipo (dalla 3.12)
⚠️ Python non controlla niente a runtimedisco_libero(42) parte lo stesso, e magari esplode tre funzioni più in là. I tipi li verifica uno strumento separato: mypy o pyright (quello dentro VS Code). Mettilo nella CI e diventa un compilatore che controlla senza rallentare niente.

🦆 Protocol: il duck typing con i tipi

"Se cammina come un'anatra e fa qua come un'anatra, è un'anatra." Python non chiede che un oggetto erediti da una classe, gli basta che abbia i metodi giusti. Protocol lo rende verificabile.

python
from typing import Protocol

class Notificatore(Protocol):
    def invia(self, testo: str) -> None: ...

class Telegram:                            # non eredita da niente
    def invia(self, testo: str) -> None:
        ...

def allarme(n: Notificatore, msg: str) -> None:
    n.invia(msg)

allarme(Telegram(), "disco pieno")        # mypy è contento: Telegram ha invia()

✅ Pydantic: i tipi che controllano davvero

Per i dati che arrivano da fuori (JSON, file di configurazione, richieste HTTP) i tipi statici non bastano: serve una verifica a runtime. Pydantic usa le stesse annotazioni per validare e convertire.

python
from pydantic import BaseModel, Field

class Config(BaseModel):
    host: str
    porta: int = Field(ge=1, le=65535)
    debug: bool = False

Config.model_validate_json('{"host": "web01", "porta": "8080"}')   # "8080" diventa 8080
Config.model_validate_json('{"host": "web01", "porta": 99999}')    # ValidationError: porta, Input should be less than or equal to 65535

È il motore dietro FastAPI: dichiari i tipi, e la validazione dell'input e la documentazione dell'API si scrivono da sole.

12 / 15

Thread, processi e asyncio

Tre modi di fare più cose insieme. La scelta giusta dipende da cosa stai aspettando.

💡 L'analogia della cucina con un solo fornello

Il GIL è un fornello solo per tutta la cucina: tanti cuochi (thread), ma uno alla volta cucina. Se i cuochi passano il tempo ad aspettare (che l'acqua bolla, che arrivi il fornitore), il fornello unico non è un problema: mentre uno aspetta, l'altro cucina. È il lavoro I/O-bound: rete, disco, database. Se invece tutti devono cucinare senza sosta (calcolo puro, CPU-bound), servono più cucine: più processi, ognuno con il suo fornello.

StrumentoAdatto aEsempio
threading / ThreadPoolExecutorI/O-bound, poche decine o centinaia di operazioniControllare 50 server via SSH o HTTP
multiprocessing / ProcessPoolExecutorCPU-bound: usa tutti i coreComprimere file, calcolare hash, elaborare immagini
asyncioI/O-bound con migliaia di connessioniUn server web, un crawler, un bot

🧵 concurrent.futures: il modo semplice

python
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import socket

def porta_aperta(host: str, porta: int = 22) -> tuple[str, bool]:
    try:
        with socket.create_connection((host, porta), timeout=2):
            return host, True
    except OSError:
        return host, False

host = [f"10.0.0.{i}" for i in range(1, 255)]

# I/O: 254 controlli con 50 thread, qualche secondo invece di minuti
with ThreadPoolExecutor(max_workers=50) as pool:
    for h, aperta in pool.map(porta_aperta, host):
        if aperta:
            print(h)

# CPU: stesso schema, ma con i processi
if __name__ == "__main__":                # obbligatorio con i processi su macOS e Windows
    with ProcessPoolExecutor() as pool:     # un processo per core
        hash_file = list(pool.map(calcola_sha256, file_grandi))

⚡ async/await con asyncio

Un solo thread che salta da un'operazione all'altra ogni volta che una si mette ad aspettare (await). Leggero: diecimila connessioni aperte non sono un problema.

python
import asyncio
import httpx

async def controlla(client: httpx.AsyncClient, url: str) -> tuple[str, int]:
    r = await client.get(url, timeout=5)     # qui cede il turno agli altri
    return url, r.status_code

async def main() -> None:
    siti = ["https://example.org", "https://example.com", "https://example.net"]
    async with httpx.AsyncClient() as client:
        risultati = await asyncio.gather(*(controlla(client, s) for s in siti))
    for url, codice in risultati:
        print(url, codice)

asyncio.run(main())
🧊 Il peccato capitale di asyncioChiamare codice bloccante dentro una funzione async: time.sleep(), requests.get(), una query con un driver non asincrono. Blocca tutto il programma, non solo quella funzione. Usa await asyncio.sleep(), librerie async (httpx, asyncpg) oppure await asyncio.to_thread(funzione_bloccante).
🔓 Python senza GILDalla 3.13 esiste una build "free-threaded" (python3.14t, con uv: uv python install 3.14t) dove i thread girano davvero in parallelo anche sul calcolo. Con la 3.14 è supportata ufficialmente ma non è ancora quella di default: il codice Python puro è un po' più lento in un thread solo, e alcune estensioni in C non sono ancora pronte. È il futuro, non ancora il presente dei tuoi server.
13 / 15

Moduli, libreria standard e test

Come si organizza il codice, cosa trovi già pronto, e come ti accorgi che lo hai rotto prima che se ne accorgano gli utenti.

📁 Moduli e pacchetti

Ogni file .py è un modulo. Una cartella di moduli è un pacchetto.

struttura
rapporto/
├── pyproject.toml
├── src/
│   └── rapporto/
│       ├── __init__.py     # rende la cartella un pacchetto (può essere vuoto)
│       ├── __main__.py     # eseguito con: python -m rapporto
│       ├── dischi.py
│       └── notifiche.py
└── tests/
    └── test_dischi.py
python
import os                                  # tutto il modulo: os.getcwd()
from pathlib import Path                     # solo un nome
from rapporto.dischi import spazio_libero    # dal tuo pacchetto
from .notifiche import invia                 # import relativo, dentro il pacchetto
import numpy as np                          # con un alias
from os import *                            # no: non sai più da dove arriva cosa

def main() -> None:
    ...

if __name__ == "__main__":                  # vero solo se lanci QUESTO file,
    main()                                  # falso se qualcuno lo importa

🔋 La libreria standard per sistemisti

ModuloAl posto diEsempio
pathlibos.path, findPath("/var/log").glob("*.log"), p.read_text(), p.stat().st_size
subprocessos.systemsubprocess.run(["systemctl", "is-active", "nginx"], capture_output=True, text=True)
shutilcp, mv, rm -r, dfshutil.copytree(), shutil.disk_usage("/"), shutil.which("rsync")
argparsegetoptsOpzioni, sottocomandi e --help generato
loggingprint sparsiLivelli, formato, file, syslog
json, csv, tomllibjq, awkLettura e scrittura in due righe
regrep -E, sedre.search(r"(\d+\.){3}\d+", riga)
socket, ipaddressnc, ipcalcipaddress.ip_network("10.0.0.0/24").hosts()
sqlite3un file di testo con i datiUn database vero, in un file, senza server
datetime, zoneinfodatedatetime.now(ZoneInfo("Europe/Rome"))
💉 subprocess senza shell=TruePassa il comando come lista di argomenti: ["rsync", "-a", sorgente, dest]. Con shell=True e una stringa costruita da input esterno, un nome file come x; rm -rf / diventa un comando. E aggiungi check=True, così un errore del comando diventa un'eccezione invece di passare in silenzio.

🧪 Test con pytest

tests/test_dischi.py
import pytest
from rapporto.dischi import percentuale, leggi_soglia

def test_percentuale():
    assert percentuale(50, 200) == 25.0           # un assert normale, niente assertEqual

def test_totale_zero():
    with pytest.raises(ZeroDivisionError):
        percentuale(1, 0)

@pytest.mark.parametrize("testo, atteso", [
    ("90", 90),
    (" 75 ", 75),
    ("", 80),                                  # default
])
def test_leggi_soglia(tmp_path, testo, atteso):   # tmp_path: cartella temporanea gratis
    f = tmp_path / "soglia"
    f.write_text(testo)
    assert leggi_soglia(f) == atteso
shell
uv run pytest                 # trova da solo i file test_*.py
uv run pytest -x -k soglia    # fermati al primo errore, solo i test con "soglia" nel nome
uv run ruff check --fix       # linter: centinaia di regole, corregge da solo dove può
uv run ruff format            # formatta tutto il codice (come black, ma più veloce)
uv run mypy src               # controlla i tipi

Quando un assert fallisce, pytest ti mostra i valori di entrambi i lati e la differenza. Per questo nessuno usa più unittest per i progetti nuovi, anche se è nella libreria standard.

14 / 15

Le trappole (e i traceback tradotti)

Python non ha un compilatore che ti ferma prima. Ti ferma dopo, con un traceback. Ecco come leggerli.

📖 Il traceback si legge dal bassoL'ultima riga dice cosa è successo, quella appena sopra dove. Le righe più in alto sono la catena di chiamate che ti ha portato lì. Dalla 3.11 Python sottolinea con ^^^^ il pezzo esatto dell'espressione che ha fallito.
ErroreCosa vuol direCome se ne esce
IndentationError / TabErrorIndentazione incoerente, spesso tab mescolati a spaziConfigura l'editor: 4 spazi, sempre. ruff format sistema tutto
NameError: name 'x' is not definedNome mai assegnato, scritto male o import dimenticatoControlla maiuscole e import
TypeError: 'NoneType' object is not subscriptableStai usando come lista il risultato di una funzione che ha restituito NoneClassico: v = v.sort(). sort() ordina sul posto e restituisce None: usa sorted(v)
AttributeError: 'NoneType' object has no attribute 'group're.match non ha trovato niente e ha restituito NoneControlla if m: prima di usare il risultato
KeyError: 'porta'La chiave non c'è nel dizionariod.get("porta", 22), oppure capisci perché manca
ModuleNotFoundError: No module named 'requests'Il pacchetto è installato, ma in un altro Python o in un altro venvwhich python, attiva il venv giusto, o usa uv run
error: externally-managed-environmentStai installando nel Python di sistemavenv, uv, o uv tool install per i comandi. Non --break-system-packages
UnboundLocalError: cannot access local variable 'x'Assegni x dentro la funzione, quindi per Python è locale, ma la leggi primaPassala come parametro e restituiscila. global solo se proprio devi
AttributeError: partially initialized module 'random'Hai chiamato il tuo file random.py (o json.py, requests.py): importi te stessoRinomina il file e cancella __pycache__
UnicodeDecodeError: 'utf-8' codec can't decodeIl file non è UTF-8, o è binarioopen(f, encoding="latin-1") o errors="replace"
RecursionError: maximum recursion depth exceededUna funzione che chiama sé stessa senza fermarsi (limite: circa 1000 livelli)Controlla il caso base, o riscrivi con un ciclo

🪤 Le tre trappole che prendono tutti

python
# 1. il default mutabile: viene creato UNA volta sola, quando definisci la funzione
def aggiungi(voce, lista=[]):              # sbagliato
    lista.append(voce)
    return lista

aggiungi("a")    # ['a']
aggiungi("b")    # ['a', 'b']   la stessa lista di prima!

def aggiungi(voce, lista=None):            # giusto
    if lista is None:
        lista = []
    lista.append(voce)
    return lista

# 2. la lista di liste che è sempre la stessa lista
griglia = [[0] * 3] * 3                      # tre post-it sulla STESSA riga
griglia[0][0] = 1                            # [[1,0,0], [1,0,0], [1,0,0]]
griglia = [[0] * 3 for _ in range(3)]       # giusto: tre righe distinte

# 3. le lambda nel ciclo leggono la variabile alla fine, non quando le crei
funzioni = [lambda: i for i in range(3)]
[f() for f in funzioni]                      # [2, 2, 2]  e non [0, 1, 2]
funzioni = [lambda i=i: i for i in range(3)]  # giusto: il valore viene fissato subito

Buone abitudini

  • Un venv (o uv) per ogni progetto, sempre
  • ruff e pytest prima di ogni commit
  • Type hint almeno sulle funzioni pubbliche
  • with per file, lock e connessioni
  • pathlib invece di concatenare stringhe di percorsi
  • logging invece di print negli script che girano da soli
  • encoding="utf-8" esplicito quando apri file di testo

Classici da evitare

  • sudo pip install: rompi il sistema
  • except: pass, il nascondiglio di tutti i bug
  • from modulo import *
  • eval() o pickle.load() su dati che arrivano da fuori
  • yaml.load() al posto di yaml.safe_load()
  • Password e token scritti nel codice: variabili d'ambiente
  • Script da 800 righe senza una funzione
15 / 15

Da dove continuare

Il materiale gratuito su Python è infinito. Il problema è sceglierne poco e farlo bene.

🗺️ Un percorso in quattro tappe

  1. Settimana 1: il tutorial ufficiale su docs.python.org, con l'interprete aperto accanto. Prova ogni esempio.
  2. Settimana 2-3: riscrivi in Python uno script bash che usi davvero: un backup, una pulizia dei log, un controllo dei certificati in scadenza. Con argparse, pathlib, subprocess e logging.
  3. Mese 2: un progetto con uv, test con pytest, type hint e ruff. Poi una piccola API con FastAPI, o un tool che parla con un'API vera (Proxmox, Cloudflare, il tuo monitoraggio).
  4. Dopo: Fluent Python per capire come funziona davvero il linguaggio, e codice altrui ben scritto: la libreria standard stessa è un buon punto di partenza.
RisorsaCos'è
Tutorial ufficiale (docs.python.org/3/tutorial)Gratuito, aggiornato, scritto da chi fa il linguaggio. Si parte da qui
Documentazione della libreria standard (docs.python.org/3/library)Sottovalutata: prima di installare un pacchetto, controlla se c'è già
Automate the Boring Stuff with PythonAl Sweigart, gratuito online. Il libro perfetto per uno svogliato: automatizzare le cose noiose
Fluent PythonLuciano Ramalho. Il libro per passare da "lo uso" a "lo capisco"
Real PythonTutorial pratici su quasi ogni argomento
PEP 8La guida di stile ufficiale. Ruff la applica per te
Documentazione di uv (docs.astral.sh/uv)Per chiudere per sempre la questione ambienti virtuali

📦 I pacchetti che userai di sicuro

EsigenzaPacchetto
Client HTTPhttpx (sincrono e async), requests (il classico)
Riga di comandoargparse (standard), typer, click
Output colorato, tabelle, barre di avanzamentorich
Server web e APIfastapi, django, flask
Validazione dati e configurazionepydantic, pydantic-settings
Databasesqlalchemy, psycopg (PostgreSQL), sqlite3 (standard)
SSH e automazioneparamiko, fabric, ansible (scritto in Python)
YAMLpyyaml (sempre safe_load), ruamel.yaml (conserva i commenti)
Dati e tabellepandas, polars (più veloce, scritto in Rust)
Testpytest, hypothesis (genera i casi di test per te)
Browser automatico e scrapingplaywright, beautifulsoup4
🐍 L'ultimo consiglio da svogliatoIl miglior script Python è quello che puoi rileggere fra sei mesi senza maledire chi l'ha scritto. Cioè te. Nomi chiari, funzioni corte, un venv, un test. Il resto lo imparerai sbagliando, che in Python è veloce ed economico.