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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Perché esiste
Il tempo del programmatore costa più del tempo della CPU. Python ottimizza il primo e lascia al secondo il conto.
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.
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
| Confronto | Scegli Python se... | Scegli l'altro se... |
|---|---|---|
| vs Bash | Ci sono strutture dati, gestione degli errori, più di una schermata di codice | Stai solo incollando comandi uno dopo l'altro |
| vs Go | Conta la velocità di scrittura, o ti servono librerie per dati e IA | Vuoi un binario unico, concorrenza semplice e consumi bassi |
| vs Rust | Lo script deve esistere entro sera | Contano prestazioni, sicurezza della memoria e anni di manutenzione |
| vs JavaScript/Node | Backend, dati, automazione di sistema | Il codice gira nel browser, o vuoi un solo linguaggio fra frontend e backend |
| vs Java/C# | Team piccolo, progetto agile, meno cerimonie | Ecosistema enterprise già in piedi, codebase enorme con tanti sviluppatori |
uv è quasi un problema risolto: lo vediamo nel capitolo 5.
Nomi, oggetti e mutabilità
Il modello mentale che evita metà dei bug di Python. Capito questo, il resto è sintassi.
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.
Tutto è un oggetto
Numeri, stringhe, funzioni, classi, moduli, perfino None. Ogni oggetto ha un tipo (type(x)) e un'identità (id(x)).
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.
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
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
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ì.
Installare Python, ambienti virtuali e uv
La parte dove storicamente la gente si arrendeva. Oggi è un comando.
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.
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.
# 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
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)
[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.
#!/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.
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.
Le basi: variabili, tipi, funzioni, cicli
La parte che somiglia agli altri linguaggi. Con l'indentazione al posto delle graffe.
📐 L'indentazione è sintassi
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
| Tipo | Esempi | Note |
|---|---|---|
| Intero | 42, -7, 1_000_000, 0xff | Precisione illimitata: 2 ** 1000 funziona. Niente overflow, mai |
| Virgola mobile | 3.14, 1e-6 | A 64 bit: 0.1 + 0.2 fa 0.30000000000000004. Per i soldi c'è decimal |
| Booleano | True, False | Con la maiuscola. E sono interi: True + True == 2 |
| Stringa | 'ciao', "ciao", """su più righe""" | Unicode, immutabile |
| Byte | b'\x00\xff' | Dati binari: socket, file, crittografia |
| Niente | None | L'unico valore del suo tipo. Il null di Python |
7 / 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.
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
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
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
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)
Liste, dizionari, set e comprehension
Quattro strutture dati coprono il 95% dei casi. Il restante 5% sta nel modulo collections.
| Tipo | Sintassi | Mutabile | Quando |
|---|---|---|---|
| list | [1, 2, 3] | sì | Sequenza ordinata che cresce e cambia |
| tuple | (1, 2, 3) | no | Record 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
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
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
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
# [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
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)
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
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
trypiù 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+Cexcept 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
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.
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()
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.
Classi, dataclass e match
Gli oggetti in Python sono semplici. A volte fin troppo: niente è davvero privato, tutto è per convenzione.
🧱 Una classe
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
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
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
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.
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.
Lambda, decoratori e generatori
Le funzioni in Python sono oggetti: si passano, si restituiscono, si avvolgono in altre funzioni.
λ Lambda e funzioni come valori
# 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).
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.
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
| Funzione | Cosa 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 |
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
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)
disco_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.
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.
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.
Thread, processi e asyncio
Tre modi di fare più cose insieme. La scelta giusta dipende da cosa stai aspettando.
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.
| Strumento | Adatto a | Esempio |
|---|---|---|
threading / ThreadPoolExecutor | I/O-bound, poche decine o centinaia di operazioni | Controllare 50 server via SSH o HTTP |
multiprocessing / ProcessPoolExecutor | CPU-bound: usa tutti i core | Comprimere file, calcolare hash, elaborare immagini |
| asyncio | I/O-bound con migliaia di connessioni | Un server web, un crawler, un bot |
🧵 concurrent.futures: il modo semplice
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.
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())
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).
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.
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.
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
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
| Modulo | Al posto di | Esempio |
|---|---|---|
pathlib | os.path, find | Path("/var/log").glob("*.log"), p.read_text(), p.stat().st_size |
subprocess | os.system | subprocess.run(["systemctl", "is-active", "nginx"], capture_output=True, text=True) |
shutil | cp, mv, rm -r, df | shutil.copytree(), shutil.disk_usage("/"), shutil.which("rsync") |
argparse | getopts | Opzioni, sottocomandi e --help generato |
logging | print sparsi | Livelli, formato, file, syslog |
json, csv, tomllib | jq, awk | Lettura e scrittura in due righe |
re | grep -E, sed | re.search(r"(\d+\.){3}\d+", riga) |
socket, ipaddress | nc, ipcalc | ipaddress.ip_network("10.0.0.0/24").hosts() |
sqlite3 | un file di testo con i dati | Un database vero, in un file, senza server |
datetime, zoneinfo | date | datetime.now(ZoneInfo("Europe/Rome")) |
["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
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
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.
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 pezzo esatto dell'espressione che ha fallito.
| Errore | Cosa vuol dire | Come se ne esce |
|---|---|---|
IndentationError / TabError | Indentazione incoerente, spesso tab mescolati a spazi | Configura l'editor: 4 spazi, sempre. ruff format sistema tutto |
NameError: name 'x' is not defined | Nome mai assegnato, scritto male o import dimenticato | Controlla maiuscole e import |
TypeError: 'NoneType' object is not subscriptable | Stai usando come lista il risultato di una funzione che ha restituito None | Classico: 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 None | Controlla if m: prima di usare il risultato |
KeyError: 'porta' | La chiave non c'è nel dizionario | d.get("porta", 22), oppure capisci perché manca |
ModuleNotFoundError: No module named 'requests' | Il pacchetto è installato, ma in un altro Python o in un altro venv | which python, attiva il venv giusto, o usa uv run |
error: externally-managed-environment | Stai installando nel Python di sistema | venv, 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 prima | Passala 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 stesso | Rinomina il file e cancella __pycache__ |
UnicodeDecodeError: 'utf-8' codec can't decode | Il file non è UTF-8, o è binario | open(f, encoding="latin-1") o errors="replace" |
RecursionError: maximum recursion depth exceeded | Una 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
# 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 ruffepytestprima di ogni commit- Type hint almeno sulle funzioni pubbliche
withper file, lock e connessionipathlibinvece di concatenare stringhe di percorsilogginginvece diprintnegli script che girano da soliencoding="utf-8"esplicito quando apri file di testo
Classici da evitare
sudo pip install: rompi il sistemaexcept: pass, il nascondiglio di tutti i bugfrom modulo import *eval()opickle.load()su dati che arrivano da fuoriyaml.load()al posto diyaml.safe_load()- Password e token scritti nel codice: variabili d'ambiente
- Script da 800 righe senza una funzione
Da dove continuare
Il materiale gratuito su Python è infinito. Il problema è sceglierne poco e farlo bene.
🗺️ Un percorso in quattro tappe
- Settimana 1: il tutorial ufficiale su docs.python.org, con l'interprete aperto accanto. Prova ogni esempio.
- 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,subprocesselogging. - Mese 2: un progetto con
uv, test conpytest, type hint eruff. Poi una piccola API con FastAPI, o un tool che parla con un'API vera (Proxmox, Cloudflare, il tuo monitoraggio). - Dopo: Fluent Python per capire come funziona davvero il linguaggio, e codice altrui ben scritto: la libreria standard stessa è un buon punto di partenza.
| Risorsa | Cos'è |
|---|---|
| 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 Python | Al Sweigart, gratuito online. Il libro perfetto per uno svogliato: automatizzare le cose noiose |
| Fluent Python | Luciano Ramalho. Il libro per passare da "lo uso" a "lo capisco" |
| Real Python | Tutorial pratici su quasi ogni argomento |
| PEP 8 | La 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
| Esigenza | Pacchetto |
|---|---|
| Client HTTP | httpx (sincrono e async), requests (il classico) |
| Riga di comando | argparse (standard), typer, click |
| Output colorato, tabelle, barre di avanzamento | rich |
| Server web e API | fastapi, django, flask |
| Validazione dati e configurazione | pydantic, pydantic-settings |
| Database | sqlalchemy, psycopg (PostgreSQL), sqlite3 (standard) |
| SSH e automazione | paramiko, fabric, ansible (scritto in Python) |
| YAML | pyyaml (sempre safe_load), ruamel.yaml (conserva i commenti) |
| Dati e tabelle | pandas, polars (più veloce, scritto in Rust) |
| Test | pytest, hypothesis (genera i casi di test per te) |
| Browser automatico e scraping | playwright, beautifulsoup4 |