CRUD su un dizionario, esercizi spiegati
Cinque esempi, una mossa alla volta
- 30 minuti di lettura
Cinque esempi, dal più semplice. Ognuno ha lo stesso ritmo:
- Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
- In italiano: cosa fa il programma, a parole.
- Passo per passo: cosa c'è nelle scatole a ogni mossa.
- Cosa portiamo a casa: la cosa da ricordare.
Per provarli: crea una cartella prove dentro quella dello zip della palestra, e salva in prove/ i file di questa pagina. Poi, con il venv acceso, python3 prove/nome_del_file.py. Non serve nessun server: gli esempi chiamano l'API con il TestClient, che la raggiunge senza accenderla (come fanno i test).
Gli esempi B–E usano la stessa piccola API, gli ascensori della Linea Menta. Salvala come prove/ascensori.py: sono gli stessi cinque pezzi della teoria, con le parole cambiate.
from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel
app = FastAPI(title="Gli ascensori della Linea Menta")
class AscensoreNuovo(BaseModel):
codice: str
stazione_id: int
funziona: bool
class Ascensore(AscensoreNuovo):
id: int
# Gli ascensori: id -> Ascensore. Il 3 è stato demolito: gli id sono 1, 2 e 4.
ascensori: dict[int, Ascensore] = {
1: Ascensore(id=1, codice="L1", stazione_id=1, funziona=True),
2: Ascensore(id=2, codice="L2", stazione_id=3, funziona=False),
4: Ascensore(id=4, codice="L4", stazione_id=5, funziona=True),
}
def prossimo_id(dizionario: dict) -> int:
return max(dizionario, default=0) + 1
def trova_ascensore(ascensore_id: int) -> Ascensore:
ascensore = ascensori.get(ascensore_id)
if ascensore is None:
raise HTTPException(status_code=404, detail="Ascensore non trovato")
return ascensore
def codice_gia_usato(codice: str, tranne_id: int | None = None) -> bool:
for altro in ascensori.values():
if altro.codice == codice and altro.id != tranne_id:
return True
return False
@app.get("/ascensori/{ascensore_id}")
def leggi_ascensore(ascensore_id: int) -> Ascensore:
return trova_ascensore(ascensore_id)
@app.post("/ascensori", status_code=status.HTTP_201_CREATED)
def nuovo_ascensore(dati: AscensoreNuovo) -> Ascensore:
if codice_gia_usato(dati.codice):
raise HTTPException(status_code=409, detail="Codice già usato da un altro ascensore")
ascensore = Ascensore(id=prossimo_id(ascensori), codice=dati.codice, stazione_id=dati.stazione_id, funziona=dati.funziona)
ascensori[ascensore.id] = ascensore
return ascensore
@app.put("/ascensori/{ascensore_id}")
def sostituisci_ascensore(ascensore_id: int, dati: AscensoreNuovo) -> Ascensore:
trova_ascensore(ascensore_id)
if codice_gia_usato(dati.codice, tranne_id=ascensore_id):
raise HTTPException(status_code=409, detail="Codice già usato da un altro ascensore")
ascensore = Ascensore(id=ascensore_id, codice=dati.codice, stazione_id=dati.stazione_id, funziona=dati.funziona)
ascensori[ascensore_id] = ascensore
return ascensore
@app.delete("/ascensori/{ascensore_id}", status_code=status.HTTP_204_NO_CONTENT)
def togli_ascensore(ascensore_id: int) -> None:
trova_ascensore(ascensore_id)
del ascensori[ascensore_id]A · Il setaccio, un giro alla volta
Prima di metterlo in una rotta, il setaccio da solo. Gli ascensori sono un dizionario di dizionari; Marta Villa vuole quelli della stazione 3 (Largo Lista).
ascensori = {
1: {"stazione_id": 1, "funziona": True},
2: {"stazione_id": 3, "funziona": False},
3: {"stazione_id": 3, "funziona": True},
}
stazione_id = 3
trovati = []
for id, ascensore in ascensori.items():
print("giro", id, "->", ascensore)
if ascensore["stazione_id"] == stazione_id:
trovati.append(id)
print(" trovati:", trovati)
print("fine:", trovati)
# Con un filtro che non trova niente
nessuno = []
for id, ascensore in ascensori.items():
if ascensore["stazione_id"] == 9:
nessuno.append(id)
print(nessuno)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
giro 1 -> {'stazione_id': 1, 'funziona': True}
trovati: []
giro 2 -> {'stazione_id': 3, 'funziona': False}
trovati: [2]
giro 3 -> {'stazione_id': 3, 'funziona': True}
trovati: [2, 3]
fine: [2, 3]
[]- Il
forguarda un ascensore alla volta. L'ifdecide se passa;appendlo fa passare. - Al giro 1 la stazione è la 1: l'
ifè falso,trovatiresta vuota. - Ai giri 2 e 3 l'
ifè vero:trovaticresce. - Con il filtro 9 nessun ascensore passa, e il risultato è
[]: una lista vuota, non un errore.
Il disegno.
In italiano.
- Parto da una lista vuota.
- Guardo gli ascensori uno per uno.
- Se è nella stazione cercata, lo metto nella lista.
- Alla fine restituisco la lista: piena, o vuota.
Il disegno.
Passo per passo.
| Giro | id | stazione_id dell'ascensore | È uguale a 3? | trovati dopo il giro |
|---|---|---|---|---|
| 1 | 1 | 1 | no | [] |
| 2 | 2 | 3 | sì | [2] |
| 3 | 3 | 3 | sì | [2, 3] |
Cosa portiamo a casa. Il setaccio è sempre lo stesso: lista vuota, for, if, append, return fuori dal for. Se nessuno passa, la risposta è la lista vuota (nell'API: 200 e []). E il caso «nessun filtro» si scrive prima del for, con is None.
B · Le quadre, get e il 404
L'ascensore 3 è stato demolito, ma qualcuno lo chiede lo stesso. Tre modi di chiederlo.
from fastapi.testclient import TestClient
import ascensori
print(ascensori.ascensori.get(3))
print(ascensori.ascensori.get(3) is None)
client = TestClient(ascensori.app)
print(client.get("/ascensori/2").status_code)
risposta = client.get("/ascensori/3")
print(risposta.status_code, risposta.json())
print(ascensori.ascensori[3])Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
None
True
200
404 {'detail': 'Ascensore non trovato'}
Traceback (most recent call last):
File "~/corso/http-crud-su-un-dizionario/prove/b2_get.py", line 13, in <module>
print(ascensori.ascensori[3])
~~~~~~~~~~~~~~~~~~~^^^
KeyError: 3get(3)non si arrabbia: dàNone, eis Nonelo conferma.GET /ascensori/2è un ascensore che c'è: 200.GET /ascensori/3non c'è: la rotta lancia il 404, e ilTestClientce lo fa vedere come una risposta, con ildetaildentro un JSON.- Le quadre sull'id 3 fermano il programma con un
KeyError. È l'ultima riga, e si legge dal basso (come in Leggere un traceback).
(Se il file si chiama diversamente da b2_get.py, nella riga del traceback c'è il tuo nome: tutto il resto è uguale.)
In italiano. La rotta non legge con le quadre: chiede con get, e guarda se la risposta è None. Se è None, lancia il 404 con raise. Se no, restituisce l'ascensore.
Il disegno.
Passo per passo. GET /ascensori/3:
- FastAPI prende il
3dal percorso e chiamaleggi_ascensore(3). leggi_ascensorechiamatrova_ascensore(3).ascensori.get(3)dàNone.ascensore is Noneè vero:raise HTTPException(…). La funzione esce qui, senza arrivare alreturn.- FastAPI prende l'eccezione e risponde 404, con
{"detail": "Ascensore non trovato"}.
Cosa portiamo a casa. Le quadre quando la chiave deve esserci, get quando può mancare. Un id che arriva dal client può sempre mancare: quindi get, poi is None, poi il 404. Un KeyError in una rotta diventa un 500, e il 500 è colpa tua.
C · L'id nuovo, e il buco negli id
Gli ascensori hanno gli id 1, 2 e 4 (il 3 non c'è). Un tecnico ne monta uno nuovo, e la POST deve dargli un id. Proviamo due modi: il primo sbagliato, a mano; il secondo giusto, con la POST vera.
from fastapi.testclient import TestClient
import ascensori
from ascensori import Ascensore
archivio = ascensori.ascensori
# Il modo sbagliato: «quanti sono, più uno».
sbagliato = len(archivio) + 1
print("id scelto con len + 1:", sbagliato)
print("c'era già qualcuno? ", sbagliato in archivio)
archivio[sbagliato] = Ascensore(id=sbagliato, codice="L9", stazione_id=2, funziona=True)
print("ora gli id sono: ", list(archivio))
print("e l'ascensore 4 è: ", archivio[4].codice)
# Il modo giusto, con la POST vera.
ascensori.ascensori.clear()
ascensori.ascensori.update({
1: Ascensore(id=1, codice="L1", stazione_id=1, funziona=True),
2: Ascensore(id=2, codice="L2", stazione_id=3, funziona=False),
4: Ascensore(id=4, codice="L4", stazione_id=5, funziona=True),
})
client = TestClient(ascensori.app)
risposta = client.post("/ascensori", json={"codice": "L9", "stazione_id": 2, "funziona": True})
print(risposta.status_code, risposta.json())
print("gli id sono: ", list(archivio))Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
id scelto con len + 1: 4
c'era già qualcuno? True
ora gli id sono: [1, 2, 4]
e l'ascensore 4 è: L9
201 {'codice': 'L9', 'stazione_id': 2, 'funziona': True, 'id': 5}
gli id sono: [1, 2, 4, 5]- Gli ascensori sono tre, e tre più uno fa 4. Ma il 4 c'è già.
- Scrivere
archivio[4] = …non aggiunge: sostituisce. Gli id restano tre, e l'ascensore L4 è sparito senza un errore: al suo posto c'è L9. - Con
prossimo_id(il più grande id, più uno) il nuovo ascensore prende il 5: nessuno viene sovrascritto, e il server risponde 201.
Il disegno.
(La parte centrale del file svuota e riempie il dizionario con clear e update, per tornare ai tre ascensori di partenza. Svuota e riempie lo stesso dizionario: l'etichetta ascensori.ascensori resta attaccata alla stessa scatola, e la rotta lo vede. Un ascensori.ascensori = {…} attaccherebbe l'etichetta a una scatola nuova, e la rotta continuerebbe a usare quella vecchia: è il tema di Etichette e scatole.)
In italiano. Il nuovo id deve essere un numero che nel dizionario non c'è. Il più grande id esistente, più uno, non c'è mai. Il numero degli ascensori non dice niente su quali id sono già presi, se ce n'è uno tolto.
Passo per passo. Il dizionario, con le chiavi:
| Mossa | Chiavi | Cosa succede |
|---|---|---|
| Partenza | 1, 2, 4 | tre ascensori |
len + 1 | 1, 2, 4 | archivio[4] = …: la scatola del 4 è sostituita, le chiavi sono le stesse |
prossimo_id | 1, 2, 4, 5 | max di 1, 2, 4 è 4; più uno: 5. Una chiave nuova, una scatola nuova |
Cosa portiamo a casa. L'id lo sceglie il server, e lo sceglie con prossimo_id. Contare gli elementi sembra uguale e funziona finché non si toglie qualcosa: è il bug che passa i test «con tre elementi» e rompe l'archivio vero. I test del capitolo hanno apposta un buco negli id.
D · La scatola nuova, e il del
Un ascensore riparato: PUT. Poi demolito: DELETE. Poi qualcuno prova a rifare tutte e due.
from fastapi.testclient import TestClient
import ascensori
client = TestClient(ascensori.app)
print("PUT ", client.put("/ascensori/2", json={"codice": "L2", "stazione_id": 3, "funziona": True}).json())
print("DELETE", client.delete("/ascensori/2").status_code)
risposta = client.delete("/ascensori/2")
print("DELETE", risposta.status_code, risposta.json())
risposta = client.put("/ascensori/2", json={"codice": "L2", "stazione_id": 3, "funziona": True})
print("PUT ", risposta.status_code, risposta.json())
print(list(ascensori.ascensori))Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
PUT {'codice': 'L2', 'stazione_id': 3, 'funziona': True, 'id': 2}
DELETE 204
DELETE 404 {'detail': 'Ascensore non trovato'}
PUT 404 {'detail': 'Ascensore non trovato'}
[1, 4]- La prima PUT sostituisce l'ascensore 2 con quello nuovo (
funzionapassa daFalseaTrue) e risponde con il nuovo. - La prima DELETE toglie la chiave 2 e risponde 204, senza corpo (per questo il programma stampa solo il numero).
- La seconda DELETE trova il 2 già tolto: 404.
- La PUT sul 2, dopo la DELETE, è un 404 anche lei: la PUT non crea, cambia solo quello che c'è. Così l'ascensore demolito non risuscita.
- Alla fine nel dizionario restano il 1 e il 4.
Il disegno.
In italiano. Tutte e due le rotte cominciano con la stessa domanda: «questo id c'è?». Se non c'è: 404. Se c'è, la PUT mette una scatola nuova alla stessa chiave; la DELETE toglie chiave e scatola.
Passo per passo. Le chiavi del dizionario, a ogni richiesta:
| Richiesta | Chiavi dopo | Risposta |
|---|---|---|
| (partenza) | 1, 2, 4 | |
PUT /ascensori/2 | 1, 2, 4 (la scatola del 2 è nuova) | 200 e l'ascensore nuovo |
DELETE /ascensori/2 | 1, 4 | 204, niente corpo |
DELETE /ascensori/2 | 1, 4 | 404 |
PUT /ascensori/2 | 1, 4 | 404 |
Cosa portiamo a casa. «Prima il 404, poi il lavoro»: in tutte le rotte con un id, la prima mossa è trova_ascensore. Un del su una chiave che manca dà KeyError, e una PUT senza controllo creerebbe l'ascensore 2 dal niente. Il 204 non ha corpo: la funzione non restituisce niente.
E · Il 409, e «tranne sé stesso»
Ogni ascensore ha un codice (L1, L2, L4) scritto sulla porta. Due ascensori con lo stesso codice non vanno bene: la POST e la PUT devono rifiutare con un 409.
from fastapi.testclient import TestClient
import ascensori
client = TestClient(ascensori.app)
# L4 è già dell'ascensore 4.
risposta = client.post("/ascensori", json={"codice": "L4", "stazione_id": 2, "funziona": True})
print("POST L4 ", risposta.status_code, risposta.json())
risposta = client.put("/ascensori/4", json={"codice": "L4", "stazione_id": 5, "funziona": False})
print("PUT 4 con L4 ", risposta.status_code, risposta.json())
risposta = client.put("/ascensori/4", json={"codice": "L1", "stazione_id": 5, "funziona": False})
print("PUT 4 con L1 ", risposta.status_code, risposta.json())Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
POST L4 409 {'detail': 'Codice già usato da un altro ascensore'}
PUT 4 con L4 200 {'codice': 'L4', 'stazione_id': 5, 'funziona': False, 'id': 4}
PUT 4 con L1 409 {'detail': 'Codice già usato da un altro ascensore'}- La POST con
L4: il codice è già di un ascensore (il 4), e il nuovo non ha niente a che fare con lui. 409. - La PUT sul 4 con
L4: il codice è già usato, ma dall'ascensore 4 stesso, che è proprio quello che si sta sostituendo. Non è un conflitto: 200. - La PUT sul 4 con
L1: il codiceL1è dell'ascensore 1, un altro. 409.
In italiano.
- Nella POST: «c'è qualcuno con questo codice?». Se sì, 409.
- Nella PUT: «c'è qualcuno diverso da me con questo codice?». Se sì, 409.
Il disegno.
Passo per passo. Dentro codice_gia_usato, per codice="L4" e tranne_id=4:
| Giro | altro | altro.codice == "L4"? | altro.id != 4? | Tutte e due vere? |
|---|---|---|---|---|
| 1 | ascensore 1 (L1) | no | sì | no |
| 2 | ascensore 2 (L2) | no | sì | no |
| 3 | ascensore 4 (L4) | sì | no | no |
Nessun giro è «sì e sì»: il for finisce senza return True, e la funzione risponde False. Con tranne_id=None (la POST) il terzo giro sarebbe «sì e sì»: True, e il 409.
Cosa portiamo a casa. Il 409 è un conflitto tra la richiesta e i dati che ci sono già. Nella PUT il controllo ha un pezzo in più, «tranne sé stesso»: senza, nessun ascensore potrebbe mai essere riscritto con il suo stesso codice. L'if che lo scrive controlla due cose con and.
Cosa hai imparato
| Esempio | Cosa hai visto |
|---|---|
| A | Il setaccio: lista vuota, for, if, append. Nessun risultato è [] |
| B | Le quadre rischiano un KeyError. get e is None, poi il 404 |
| C | prossimo_id e non len + 1: i buchi negli id esistono |
| D | PUT: scatola nuova, stessa chiave. DELETE: via chiave e scatola. Prima il 404 |
| E | Il 409, e perché nella PUT serve tranne_id |
Ora tocca a te: la palestra ha sette rotte da scrivere. Quando un test resta rosso e non capisci perché, apri Se qualcosa va storto.