Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Il progetto2. Le entitàp. 47

Le entità, la palestra

Sette esercizi da scaricare, con i test

  • 60–90 minuti di lavoro

Sette esercizi, dal ★ al ★★★. Questa volta non scrivi né query né un'app: ragioni sulle cose del riquadro 6, come farai per il tuo progetto, ma con piccole funzioni Python che applicano le regole del capitolo. Così un test può dirti subito se hai ragione.

Gli esercizi da scaricare

Una cartella con i file da completare e i test già pronti. Come si usa: la guida in cinque passi.

progetto-le-entita.zip12 KB

Prima di iniziare

Scompatta lo zip e segui il README.md che c'è dentro: venv, pip install, code .. Se è la prima volta, la pagina Come si usa un esercizio lo fa con te, un comando alla volta.

Ogni esercizio, sempre gli stessi quattro passi:

  1. Apri il file in palestra/. In alto: la storia, cosa fai, come provi.
  2. Al posto di pass scrivi il codice. La docstring ha gli esempi di cosa deve uscire.
  3. pytest palestra/test_<nome>.py -v, oppure la provetta di VS Code.
  4. Rosso? Leggi l'ultima riga del messaggio. Bloccato da 15 minuti? Apri il primo aiutino, non la soluzione.
#EsercizioCosa decidiDifficoltà
1Il dopolavoroquante sono le entità: poche, giuste, troppe★
2La mensa del personalela prova: entità, attributo, valore o fuori★★
3I turni di puliziache relazione c'è tra due cose★
4La navetta del depositodove va la chiave esterna★★
5La lavanderia a gettoniquale cosa manca, leggendo le azioni★★
6Il nido aziendalequante tabelle serviranno★★
7La scuola di musicalo schema in miniatura: tabelle e frecce★★★

1 · Il dopolavoro ★

palestra/quante_entita.py

Il dopolavoro dei ferrovieri vuole un'app per il torneo di bocce. La regola: da 3 a 6 entità. Meno di 3 sono «poche», più di 6 sono «troppe».

Python
giudizio_entita(["squadre", "partite"])                  # "poche"
giudizio_entita(["squadre", "giocatori", "partite"])     # "giuste"

Come provi: pytest palestra/test_quante_entita.py -v

Aiutino 1
Ti serve il numero di elementi della lista: len(...). Poi tre risposte possibili.
Aiutino 2
I limiti sono compresi: con 3 o con 6 entità la risposta è «giuste». Scrivi i due confronti con < e <= e prova 2, 3, 6 e 7.

2 · La mensa del personale ★★

palestra/classifica.py

Per ogni nome del riquadro 6 hai già risposto alla prova delle quattro domande: la risposta è una «scheda», un dizionario di vero/falso. Dai il verdetto: "entità", "attributo", "valore" o "fuori". Le regole, in ordine, sono scritte in cima al file; la scheda ha le chiavi serve, tante, distinte, cose_sue e gruppo_fisso.

Python
piatti = {"serve": True, "tante": True, "distinte": True, "cose_sue": True, "gruppo_fisso": False}
turno  = {"serve": True, "tante": False, "distinte": False, "cose_sue": False, "gruppo_fisso": True}
classifica(piatti)    # "entità"
classifica(turno)     # "valore"

Come provi: pytest palestra/test_classifica.py -v

Aiutino 1
Il verdetto si decide in quattro if messi in ordine. Il primo, quello che toglie di mezzo ciò che l'app non usa, deve venire prima di tutti gli altri.
Aiutino 2
Un'entità vuole tre risposte vere insieme: tante, distinte e cose_sue. Basta che una sia falsa per non esserlo. Poi: gruppo_fisso vero → "valore"; altrimenti "attributo".

3 · I turni di pulizia ★

palestra/relazione.py

Nel condominio di via dei Tigli i turni di pulizia delle scale sono su un foglio al portone. Per ogni coppia di cose (A, B) le due domande danno «uno» o «molti». Restituisci il nome della relazione, letta nell'ordine A, B.

Python
relazione("molti", "uno")     # "uno a molti"   (un condomino ha molti turni, un turno ha un condomino)
relazione("uno", "molti")     # "molti a uno"
relazione("molti", "molti")   # "molti a molti"
relazione("uno", "uno")       # "uno a uno"

I due argomenti sono, nell'ordine: quanti B ha un A, quanti A ha un B.

Come provi: pytest palestra/test_relazione.py -v

Aiutino 1
Quattro combinazioni, quattro risposte: puoi scriverle con quattro if, una combinazione per volta.
Aiutino 2
Occhio alla direzione. «Uno a molti» vuol dire: un A ha molti B (primo argomento "molti") e ogni B ha un solo A (secondo argomento "uno"). Il nome si legge con A a sinistra.

4 · La navetta del deposito ★★

palestra/dove_va_la_chiave.py

Una relazione tra due tabelle a e b: quale tabella porta la chiave esterna? La risposta è il nome della tabella, oppure "ponte" se serve una tabella in mezzo. Per l'uno a uno, la chiave va in quella che nasce dopo, e te lo dice l'argomento nasce_dopo.

Python
dove_va_la_chiave("autisti", "corse", "uno a molti")           # "corse"
dove_va_la_chiave("corse", "autisti", "molti a uno")           # "corse"
dove_va_la_chiave("autisti", "badge", "uno a uno", "badge")    # "badge"
dove_va_la_chiave("corse", "fermate", "molti a molti")         # "ponte"

Come provi: pytest palestra/test_dove_va_la_chiave.py -v

Aiutino 1
La regola da ricordare: la chiave sta dalla parte del molti. Nell'uno a molti il molti è b; nel molti a uno è a.
Aiutino 2
Quattro casi, quattro if sul tipo. Nell'uno a uno non devi decidere niente: restituisci nasce_dopo.

5 · La lavanderia a gettoni ★★

palestra/cose_senza_tabella.py

Una lavanderia a gettoni ha un'app per prenotare le lavatrici. Hai le entità (riquadro 6) e le azioni (riquadro 7): ogni azione dice quali cose legge e quali scrive. Trova le cose nominate dalle azioni che non sono tra le entità: sono tabelle che mancano.

Python
entita = ["lavatrici", "clienti"]
azioni = [{"azione": "prenoto", "legge": ["lavatrici"], "scrive": ["prenotazioni"]}]
cose_senza_tabella(entita, azioni)     # ["prenotazioni"]

Si scorrono le azioni nell'ordine, in ognuna prima legge e poi scrive; ogni cosa mancante compare una volta sola, nell'ordine in cui la incontri.

Come provi: pytest palestra/test_cose_senza_tabella.py -v

Aiutino 1
Una lista vuota mancano, un for sulle azioni, un secondo for sulle cose di quell'azione. Le cose di un'azione sono azione["legge"] + azione["scrive"]: due liste che si sommano.
Aiutino 2
Aggiungi la cosa solo se non è tra le entità e non è già in mancano. Non ordinare la lista: l'ordine che serve è quello in cui le trovi.

6 · Il nido aziendale ★★

palestra/quante_tabelle.py

Il nido della centrale vuole un'app per le presenze dei bambini. Quante tabelle ci saranno? Una per ogni entità, più una tabella ponte per ogni relazione molti a molti. Le entità della lista non comprendono i ponti: li aggiungi tu.

Python
entita = ["bambini", "educatori", "stanze"]
relazioni = [("stanze", "bambini", "uno a molti"), ("educatori", "stanze", "molti a molti")]
quante_tabelle(entita, relazioni)      # 4

Una relazione è una tupla (a, b, tipo).

Come provi: pytest palestra/test_quante_tabelle.py -v

Aiutino 1
Parti da len(entita). Poi conta solo le relazioni il cui tipo è "molti a molti": gli altri tipi non aggiungono tabelle.
Aiutino 2
Un contatore ponti = 0 e un for a, b, tipo in relazioni: che lo aumenta di uno quando serve. Il risultato è len(entita) + ponti.

7 · La scuola di musica ★★★

palestra/le_tabelle.py

L'ultimo passo del capitolo: lo schema in miniatura. Date le entità e le relazioni, restituisci un dizionario: per ogni tabella (le entità e i ponti) la lista, in ordine alfabetico, delle tabelle a cui punta con una chiave esterna.

Python
entita = ["insegnanti", "corsi", "allievi"]
relazioni = [
    {"a": "insegnanti", "b": "corsi", "tipo": "uno a molti"},
    {"a": "allievi", "b": "corsi", "tipo": "molti a molti"},
]
le_tabelle(entita, relazioni)
# {"insegnanti": [], "corsi": ["insegnanti"], "allievi": [], "allievi_corsi": ["allievi", "corsi"]}

Le regole sono quelle dell'esercizio 4. Una relazione "uno a uno" ha anche la chiave "nasce_dopo". Il ponte si chiama «a_b», con i due nomi nell'ordine della relazione, e punta a tutte e due.

Come provi: pytest palestra/test_le_tabelle.py -v

Aiutino 1
Parti da un dizionario con tutte le entità e una lista vuota ciascuna: {nome: [] for nome in entita}. Poi scorri le relazioni e riempi le liste.
Aiutino 2
Per ogni relazione decidi quale tabella porta la chiave (come nell'esercizio 4) e aggiungi l'altra alla sua lista. Nel molti a molti crei una chiave nuova, f"{a}_{b}", con due elementi. Alla fine ordina ogni lista con sorted.

Per il tuo progetto

Questi sette esercizi allenano la mano. Il lavoro vero è il tuo: apri il canvas del tuo progetto e riempi la prima metà del riquadro 6.

  1. Sottolinea i nomi nei riquadri 4, 5 e 7.
  2. Fai la prova delle quattro domande a ognuno, e scrivi il verdetto.
  3. Per ogni coppia di entità collegata da un'azione, le due domande delle relazioni.
  4. Conta: da 3 a 6 entità? Rileggi con la domanda 8 delle dieci domande.

Poi fai controllare tutto a un compagno: deve saperti dire perché la tua entità è un'entità.

Le soluzioni, con le trappole più probabili, sono nella pagina Le soluzioni.