Dizionari: chiavi e valori

Bentornato.

Nella lezione precedente hai imparato le liste.

I tuoi programmi hanno imparato a salvare molti valori in una sola variabile.

Hai scritto cose come:

products = ["Keyboard", "Mouse", "Notebook"]

Molto bene.

Le liste sono utili quando hai bisogno di molti valori.

Ma a volte una lista non basta.

Guarda questo:

user = ["Anna", 25, "Rome"]

Funziona.

Ma cosa significa?

Anna probabilmente è il nome.
25 probabilmente è l’età.
Rome probabilmente è la città.

Probabilmente.

E “probabilmente” non è una buona strategia per progettare dati.

Neanche per vivere, a dirla tutta.

Un modo migliore è salvare i dati con nomi.

Così:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

Ora i dati sono chiari.

"name" punta a "Anna".

"age" punta a 25.

"city" punta a "Rome".

Questo è un dizionario.

I dizionari sono molto importanti in Python.

Molto utili.

Molto comuni.

Molto vicini a come funzionano i dati reali in API, JSON, database, impostazioni, utenti, prodotti, ordini e tante altre cose.

In altre parole:

benvenuto nei dati strutturati.

Molto elegante.

Molto pratico.

Molto Python.

Cosa imparerai

In questa lezione imparerai:

• cos’è un dizionario;
• come funzionano chiavi e valori;
• come creare un dizionario;
• come accedere ai valori tramite chiave;
• come aggiornare valori;
• come aggiungere nuove coppie chiave-valore;
• come rimuovere elementi;
• come usare in;
• come usare get();
• come scorrere dizionari con i cicli;
• come scorrere chiavi e valori;
• come salvare dizionari dentro liste;
• come salvare liste dentro dizionari;
• errori comuni dei principianti;
• come costruire piccoli programmi basati sui dizionari.

Alla fine di questa lezione i tuoi programmi potranno lavorare con dati strutturati.

Questo è un passo enorme.

Perché le applicazioni reali sono piene di dati strutturati.

Gli utenti hanno nomi.

I prodotti hanno prezzi.

Gli ordini hanno totali.

I task hanno stati.

I post del blog hanno titoli.

E ogni capo ha “una piccola modifica”.

Anche quella è strutturata.

Anche quella è pericolosa.

Cos’è un dizionario?

Un dizionario salva dati come coppie chiave-valore.

Esempio:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

Questo dizionario ha tre chiavi:

name
age
city

E tre valori:

Anna
25
Rome

La chiave è come un’etichetta.

Il valore è il dato.

Quindi:

"name": "Anna"

significa:

La chiave "name" ha il valore "Anna".

Un dizionario usa le parentesi graffe:

{}

Ogni elemento ha questa forma:

chiave: valore

Gli elementi sono separati da virgole.

Un dizionario è come una piccola scheda informativa.

Molto organizzata.

Molto utile.

Molto meno misteriosa di user[1].

Questo è progresso.

Il tuo primo dizionario

Crea un file:

dictionaries.py

Scrivi:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

print(user)

Eseguilo:

python dictionaries.py

oppure:

python3 dictionaries.py

Output:

{'name': 'Anna', 'age': 25, 'city': 'Rome'}

Python stampa tutto il dizionario.

Nota:

parentesi graffe
chiavi
valori
due punti
virgole

Questa è la struttura del dizionario.

Può sembrare un po’ più pesante di una lista.

Ma è molto più chiaro per dati strutturati.

Una lista dice:

Ecco i valori.
Buona fortuna.

Un dizionario dice:

Ecco i valori con etichette.
Prego.

Molto educato.

Molto Python.

Chiavi e valori

Guarda ancora:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

Chiavi:

"name"
"age"
"city"

Valori:

"Anna"
25
"Rome"

Ogni chiave punta a un valore.

Puoi immaginarlo così:

name -> Anna
age  -> 25
city -> Rome

Ecco perché i dizionari sono ottimi per dati che hanno significato.

Esempio prodotto:

product = {
    "name": "Keyboard",
    "price": 70.00,
    "available": True
}

Ora sappiamo cosa significa ogni valore.

Niente indovinelli.

Niente numeri di indice misteriosi.

Niente “aspetta, la posizione 2 era il prezzo o la città?”

Bellissimo.

Accedere ai valori tramite chiave

Per accedere a un valore, usa la chiave dentro parentesi quadre.

Esempio:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

print(user["name"])
print(user["age"])
print(user["city"])

Output:

Anna
25
Rome

Questo è molto importante.

Con le liste accedi tramite indice:

products[0]

Con i dizionari accedi tramite chiave:

user["name"]

La chiave dice a Python quale valore vuoi.

Molto leggibile.

Molto utile.

Molto “finalmente il codice si spiega da solo”.

Le chiavi devono essere esatte

Le chiavi devono corrispondere esattamente.

Esempio:

user = {
    "name": "Anna",
    "age": 25
}

print(user["name"])

Output:

Anna

Ma questo è sbagliato:

print(user["Name"])

Python dà errore:

KeyError

Perché?

Perché "Name" e "name" sono chiavi diverse.

Le maiuscole contano.

Gli spazi contano.

Tutto conta.

Python non indovina.

Python non è tua zia che cerca di ricordare la tua password.

Ha bisogno della chiave esatta.

Molto severo.

Molto utile.

A volte fastidioso.

Aggiornare valori

Puoi cambiare un valore assegnando un nuovo valore a una chiave esistente.

Esempio:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

user["age"] = 26

print(user)

Output:

{'name': 'Anna', 'age': 26, 'city': 'Rome'}

Abbiamo cambiato:

age da 25 a 26

Questo è molto comune.

Esempio:

product = {
    "name": "Keyboard",
    "price": 70.00
}

product["price"] = 65.00

print(product)

Output:

{'name': 'Keyboard', 'price': 65.0}

Il prezzo del prodotto è cambiato.

Il negozio è felice.

Il cliente è felice.

Il commercialista è sospettoso.

Normale.

Aggiungere nuove coppie chiave-valore

Puoi aggiungere una nuova coppia chiave-valore assegnando un valore a una nuova chiave.

Esempio:

user = {
    "name": "Anna",
    "age": 25
}

user["city"] = "Rome"

print(user)

Output:

{'name': 'Anna', 'age': 25, 'city': 'Rome'}

Prima il dizionario aveva:

name
age

Dopo ha anche:

city

Questo è utile quando costruisci dati passo dopo passo.

Esempio:

product = {}

product["name"] = "Mouse"
product["price"] = 25.00
product["available"] = True

print(product)

Output:

{'name': 'Mouse', 'price': 25.0, 'available': True}

Un dizionario vuoto inizia così:

product = {}

Poi puoi aggiungere dati dopo.

Come un form.

Ma meno irritante.

Rimuovere elementi con del

Puoi rimuovere una coppia chiave-valore con del.

Esempio:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

del user["city"]

print(user)

Output:

{'name': 'Anna', 'age': 25}

La chiave "city" e il suo valore sono stati rimossi.

Importante:

del user["city"]

rimuove tutta la coppia chiave-valore.

Non solo il valore.

Anche la chiave sparisce.

Molto diretto.

Molto potente.

Usalo con attenzione.

del non chiede:

Sei sicuro?

Python si fida di te.

Coraggioso.

Forse troppo.

Rimuovere elementi con pop()

Puoi anche rimuovere un elemento con pop().

Esempio:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

city = user.pop("city")

print(city)
print(user)

Output:

Rome
{'name': 'Anna', 'age': 25}

pop() rimuove l’elemento e ti restituisce il valore rimosso.

Quindi:

city = user.pop("city")

significa:

Rimuovi "city" dal dizionario e salva il suo valore in city.

Questo è utile quando ti serve ancora il valore rimosso.

del rimuove.

pop() rimuove e restituisce.

Piccola differenza.

Grande utilità.

Controllare se una chiave esiste

Usa in per controllare se una chiave esiste in un dizionario.

Esempio:

user = {
    "name": "Anna",
    "age": 25
}

if "name" in user:
    print("Name exists.")
else:
    print("Name is missing.")

Output:

Name exists.

Importante:

"name" in user

controlla le chiavi.

Non i valori.

Esempio:

user = {
    "name": "Anna",
    "age": 25
}

print("Anna" in user)

Output:

False

Perché?

Perché "Anna" è un valore, non una chiave.

Le chiavi sono:

name
age

Questa è una confusione comune per i principianti.

Quando usi in con un dizionario, Python controlla le chiavi di default.

Molto importante.

Tatuatelo nel cervello del debugging.

Magari non letteralmente.

Evitare KeyError con get()

Se accedi a una chiave mancante con parentesi quadre, Python dà KeyError.

Esempio:

user = {
    "name": "Anna",
    "age": 25
}

print(user["city"])

Errore:

KeyError

Perché "city" non esiste.

Un modo più sicuro è get().

Esempio:

user = {
    "name": "Anna",
    "age": 25
}

print(user.get("city"))

Output:

None

None significa:

nessun valore

Puoi anche fornire un valore di default:

print(user.get("city", "Unknown"))

Output:

Unknown

Questo è molto utile.

get() aiuta a evitare errori quando una chiave potrebbe mancare.

Molto pratico.

Molto reale.

Perché i dati reali sono spesso incompleti.

Come i form.

E le persone.

Parentesi quadre vs get()

Entrambi possono accedere ai valori.

Esempio:

user = {
    "name": "Anna"
}

print(user["name"])
print(user.get("name"))

Output:

Anna
Anna

Differenza:

user["city"]

dà errore se "city" non esiste.

Ma:

user.get("city")

restituisce None.

E:

user.get("city", "Unknown")

restituisce "Unknown".

Regola semplice:

Usa [] quando la chiave deve esistere.
Usa get() quando la chiave potrebbe mancare.

Questo non è solo un consiglio per principianti.

È vero consiglio di programmazione.

Quello che ti salva dai bug che appaiono venerdì sera.

La specie peggiore.

Scorrere le chiavi di un dizionario

Puoi scorrere un dizionario con un ciclo.

Esempio:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

for key in user:
    print(key)

Output:

name
age
city

Di default, scorrere un dizionario restituisce le chiavi.

Questo:

for key in user:

significa:

Per ogni chiave nel dizionario...

Poi puoi accedere al valore:

for key in user:
    print(user[key])

Output:

Anna
25
Rome

Molto utile.

Le chiavi aprono le porte.

I valori sono dietro le porte.

I dizionari sono piccoli hotel.

A quanto pare.

Scorrere chiavi e valori

Un modo più bello è usare .items().

Esempio:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

for key, value in user.items():
    print(f"{key}: {value}")

Output:

name: Anna
age: 25
city: Rome

Questo è molto comune.

.items() restituisce sia la chiave sia il valore.

Il ciclo:

for key, value in user.items():

significa:

Per ogni coppia chiave-valore nel dizionario...

Questo è uno degli schemi più importanti con i dizionari.

Imparalo bene.

Tornerà.

Come i punti e virgola in SQL.

Ma più gentile.

Scorrere solo i valori

Puoi usare .values() se vuoi solo i valori.

Esempio:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

for value in user.values():
    print(value)

Output:

Anna
25
Rome

Puoi usare .keys() se vuoi solo le chiavi:

for key in user.keys():
    print(key)

Output:

name
age
city

Ma ricorda:

for key in user:

scorre già le chiavi.

Quindi .keys() è opzionale nella maggior parte dei casi.

Python dà scelte.

Le scelte sono belle.

Finché non diventano troppe.

Poi benvenuto nella programmazione.

Dizionario con input utente

Crea un file:

user_profile.py

Scrivi:

user = {}

user["name"] = input("Name: ")
user["age"] = int(input("Age: "))
user["city"] = input("City: ")

print("User profile:")

for key, value in user.items():
    print(f"{key}: {value}")

Esempio:

Name: Anna
Age: 25
City: Rome

Output:

User profile:
name: Anna
age: 25
city: Rome

Questo programma costruisce un dizionario da input utente.

Le chiavi sono fisse.

I valori arrivano dall’utente.

Questo è molto vicino ai form reali.

Un utente compila campi.

Il programma salva dati strutturati.

Molto reale.

Molto utile.

Molto “questo potrebbe diventare un form web”.

Pensiero pericoloso.

Dizionario prodotto

Crea un dizionario prodotto:

product = {
    "name": "Keyboard",
    "price": 70.00,
    "available": True
}

print(f"Product: {product['name']}")
print(f"Price: {product['price']:.2f}")

if product["available"]:
    print("Available")
else:
    print("Not available")

Output:

Product: Keyboard
Price: 70.00
Available

Questa è un’idea molto comune.

I prodotti hanno:

name
price
availability

Gli utenti hanno:

name
email
age
city

I task hanno:

title
status
priority

I dizionari sono perfetti per questo.

Danno significato ai dati.

Il significato è buono.

Senza significato, stai solo guardando numeri e sperando.

Quella non è ingegneria.

È astrologia con passaggi extra.

Liste di dizionari

Ora le cose diventano più interessanti.

Puoi salvare dizionari dentro una lista.

Esempio:

products = [
    {"name": "Keyboard", "price": 70.00},
    {"name": "Mouse", "price": 25.00},
    {"name": "Notebook", "price": 5.50}
]

Questa è una lista.

Dentro la lista, ogni elemento è un dizionario.

Questo è molto comune nelle applicazioni reali.

Perché?

Perché spesso hai molti oggetti strutturati.

Molti prodotti.

Molti utenti.

Molti ordini.

Molti task.

Una lista salva molti elementi.

Un dizionario descrive ogni elemento.

Insieme sono potenti.

Molto potenti.

Molto normali.

Molto vicini a JSON e API.

Il backend sta sorridendo.

Scorrere una lista di dizionari

Esempio:

products = [
    {"name": "Keyboard", "price": 70.00},
    {"name": "Mouse", "price": 25.00},
    {"name": "Notebook", "price": 5.50}
]

for product in products:
    print(f"{product['name']}: {product['price']:.2f}")

Output:

Keyboard: 70.00
Mouse: 25.00
Notebook: 5.50

Cosa succede?

products è una lista.
Ogni product è un dizionario.
Il ciclo prende un dizionario alla volta.
Poi leggiamo product["name"] e product["price"].

Questo schema è ovunque.

Se lavori con API, lo vedrai continuamente.

Una risposta spesso assomiglia a:

lista di dizionari

Oppure, nel linguaggio JSON:

array di oggetti

Stessa idea.

Vestiti diversi.

Calcolare il totale da una lista di dizionari

Puoi calcolare un totale.

Esempio:

products = [
    {"name": "Keyboard", "price": 70.00},
    {"name": "Mouse", "price": 25.00},
    {"name": "Notebook", "price": 5.50}
]

total = 0

for product in products:
    total += product["price"]

print(f"Total: {total:.2f}")

Output:

Total: 100.50

Questo combina:

lista
dizionario
ciclo
numero
totale

Molto forte.

Molto realistico.

Molti sistemi reali fanno questo.

Carrelli.

Fatture.

Riepiloghi ordine.

Report.

E poi tasse.

Di nuovo.

Il mostro fiscale non dorme mai.

Dizionari con liste dentro

Un dizionario può contenere anche una lista.

Esempio:

course = {
    "title": "Python Course",
    "lessons": ["Variables", "Input", "Conditions", "Loops", "Lists"]
}

print(course["title"])

for lesson in course["lessons"]:
    print(f"- {lesson}")

Output:

Python Course
- Variables
- Input
- Conditions
- Loops
- Lists

Qui:

course["lessons"]

è una lista.

Questo è molto utile quando un oggetto ha molti valori collegati.

Esempio:

utente con molte skill
corso con molte lezioni
ordine con molti prodotti
post del blog con molti tag

Dizionari e liste lavorano benissimo insieme.

Come pasta e sugo.

Ma con più parentesi.

Dizionari annidati

Un dizionario può contenere un altro dizionario.

Esempio:

user = {
    "name": "Anna",
    "address": {
        "city": "Rome",
        "country": "Italy"
    }
}

print(user["name"])
print(user["address"]["city"])
print(user["address"]["country"])

Output:

Anna
Rome
Italy

Questo si chiama dato annidato.

Annidato significa:

dentro un’altra cosa

Qui:

user["address"]

è un altro dizionario.

Poi:

user["address"]["city"]

prende la città dentro il dizionario address.

All’inizio sembra un po’ spaventoso.

Ma è solo:

apri user
apri address
leggi city

Come aprire scatole.

Per favore non mettere troppe scatole dentro altre scatole.

Lì vive la follia.

E JSON.

Errore comune: chiavi senza virgolette

Sbagliato:

user = {
    name: "Anna",
    age: 25
}

Python pensa che name e age siano nomi di variabili.

Ma non sono definite.

Corretto:

user = {
    "name": "Anna",
    "age": 25
}

Le chiavi stringa hanno bisogno delle virgolette.

Questo è un errore molto comune per principianti.

Ricorda:

"name" è testo
name è una variabile

Cose diverse.

Virgolette piccole.

Grande differenza.

Classico dramma della programmazione.

Errore comune: usare = invece di :

Sbagliato:

user = {
    "name" = "Anna",
    "age" = 25
}

Corretto:

user = {
    "name": "Anna",
    "age": 25
}

Dentro i dizionari usa i due punti:

"key": value

Non l’uguale.

Il simbolo uguale serve per assegnare:

user = {}

I due punti servono per le coppie chiave-valore:

"name": "Anna"

Python è molto specifico.

Come un commercialista con regole di sintassi.

Errore comune: virgole mancanti

Sbagliato:

user = {
    "name": "Anna"
    "age": 25
}

Corretto:

user = {
    "name": "Anna",
    "age": 25
}

Gli elementi del dizionario hanno bisogno di virgole tra loro.

Senza virgole, Python si confonde.

E quando Python si confonde, dà errori.

Almeno non urla.

Di solito.

Errore comune: KeyError

Sbagliato:

user = {
    "name": "Anna"
}

print(user["city"])

Questo dà:

KeyError

Perché "city" non esiste.

Più sicuro:

print(user.get("city", "Unknown"))

Output:

Unknown

Usa get() quando la chiave potrebbe mancare.

Questo è molto importante quando lavori con dati reali.

I dati reali sono spesso incompleti.

Perché gli esseri umani compilano form.

E gli esseri umani sono creativi.

Nel modo sbagliato.

Errore comune: confondere indici di lista e chiavi di dizionario

Lista:

products = ["Keyboard", "Mouse"]

Accesso con indice:

products[0]

Dizionario:

product = {
    "name": "Keyboard",
    "price": 70.00
}

Accesso con chiave:

product["name"]

Non scrivere:

product[0]

Questo dizionario non funziona così.

Le liste usano posizioni.

I dizionari usano chiavi.

Regola semplice:

lista       indice
dizionario  chiave

Molto importante.

Molto facile da confondere all’inizio.

Molto normale.

Mini programma: scheda utente

Crea un file:

user_card.py

Scrivi:

user = {
    "name": input("Name: "),
    "age": int(input("Age: ")),
    "city": input("City: ")
}

print("----- User Card -----")
print(f"Name: {user['name']}")
print(f"Age: {user['age']}")
print(f"City: {user['city']}")

Esempio:

Name: Anna
Age: 25
City: Rome

Output:

----- User Card -----
Name: Anna
Age: 25
City: Rome

È semplice ma importante.

Raccogli dati.

Li salvi in un dizionario.

Li stampi in modo ordinato.

Questo è l’inizio dei dati utente strutturati.

Molto utile.

Molto reale.

Mini programma: product manager

Crea un file:

product_manager.py

Scrivi:

product = {}

product["name"] = input("Product name: ")
product["price"] = float(input("Price: "))
product["available"] = input("Available? yes/no: ").lower() == "yes"

print("----- Product -----")
print(f"Name: {product['name']}")
print(f"Price: {product['price']:.2f}")

if product["available"]:
    print("Status: available")
else:
    print("Status: not available")

Esempio:

Product name: Keyboard
Price: 70
Available? yes/no: yes

Output:

----- Product -----
Name: Keyboard
Price: 70.00
Status: available

Questo programma usa:

• dizionario vuoto;
• input;
• conversione float;
• espressione booleana;
• condizioni;
• output formattato.

Ottima pratica.

E sì, questo inizia a sembrare dati prodotto in un negozio.

Piccolo negozio.

Piccolo Python.

Grande futuro.

Mini programma: lista prodotti

Crea un file:

product_list_dictionaries.py

Scrivi:

products = []

product_count = int(input("How many products? "))

for number in range(1, product_count + 1):
    print(f"Product {number}")

    product = {
        "name": input("Name: "),
        "price": float(input("Price: "))
    }

    products.append(product)

print("----- Products -----")

for product in products:
    print(f"{product['name']}: {product['price']:.2f}")

Esempio:

How many products? 2
Product 1
Name: Keyboard
Price: 70
Product 2
Name: Mouse
Price: 25

Output:

----- Products -----
Keyboard: 70.00
Mouse: 25.00

Questo è potente.

Stai costruendo una lista di dizionari.

Questa è una struttura dati molto reale.

Non è solo pratica da principianti.

È così che molti programmi reali organizzano i dati.

Passo molto forte.

Pratica

Crea un file:

practice_dictionaries.py

Scrivi un programma che:

• crea un dizionario vuoto chiamato book;
• chiede all’utente un titolo;
• chiede all’utente un autore;
• chiede all’utente un anno;
• salva tutti i valori nel dizionario;
• stampa le informazioni del libro;
• controlla se l’anno è prima del 2000.

Soluzione esempio:

book = {}

book["title"] = input("Title: ")
book["author"] = input("Author: ")
book["year"] = int(input("Year: "))

print("----- Book -----")

for key, value in book.items():
    print(f"{key}: {value}")

if book["year"] < 2000:
    print("This book was published before 2000.")
else:
    print("This book was published in 2000 or later.")

Questo programma combina:

• dizionari;
• input;
• conversione di tipo;
• ciclo con .items();
• condizioni.

Molto utile.

Molto pulito.

Molto strutturato.

Come un piccolo sistema bibliotecario.

Senza multe per il ritardo.

Per ora.

Mini sfida

Crea un file:

contact_book.py

Il tuo programma deve:

• iniziare con una lista vuota chiamata contacts;
• mostrare ripetutamente un menu;
• permettere all’utente di aggiungere un contatto;
• permettere all’utente di mostrare tutti i contatti;
• permettere all’utente di uscire.

Ogni contatto deve essere un dizionario con:

name
email
phone

Menu:

1. Add contact
2. Show contacts
q. Quit

Soluzione esempio:

contacts = []

while True:
    print("----- Contact Book -----")
    print("1. Add contact")
    print("2. Show contacts")
    print("q. Quit")

    choice = input("Choose an option: ").lower()

    if choice == "1":
        contact = {
            "name": input("Name: "),
            "email": input("Email: "),
            "phone": input("Phone: ")
        }

        contacts.append(contact)
        print("Contact added.")
    elif choice == "2":
        if len(contacts) == 0:
            print("No contacts yet.")
        else:
            print("Contacts:")

            for contact in contacts:
                print("-----")
                print(f"Name: {contact['name']}")
                print(f"Email: {contact['email']}")
                print(f"Phone: {contact['phone']}")
    elif choice == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

Questa è una vera mini applicazione.

Usa:

• lista di dizionari;
• ciclo menu;
• input;
• condizioni;
• append();
• len();
• accesso al dizionario;
• break.

Questo è un progetto serio per principianti.

Piccolo, sì.

Ma serio.

Una rubrica contatti è logica software reale.

Non stai più solo stampando “Hello”.

Stai salvando dati strutturati.

Rispetto.

Molto rispetto Python.

Sfida extra: cercare contatti

Migliora contact_book.py.

Aggiungi un’opzione al menu:

3. Search contact

Chiedi all’utente un nome.

Poi cerca il contatto per nome.

Idea esempio:

elif choice == "3":
    search_name = input("Name to search: ")

    found = False

    for contact in contacts:
        if contact["name"] == search_name:
            print("Contact found:")
            print(f"Name: {contact['name']}")
            print(f"Email: {contact['email']}")
            print(f"Phone: {contact['phone']}")
            found = True

    if not found:
        print("Contact not found.")

Questo aggiunge:

• ricerca;
• flag booleano;
• ciclo su lista di dizionari;
• condizione dentro il ciclo.

Molto utile.

Molto reale.

È così che iniziano molti piccoli sistemi di dati.

Aggiungi dati.

Mostra dati.

Cerca dati.

Poi un giorno qualcuno dice:

Can we save it to a database?

E PostgreSQL entra nella stanza con gli occhiali da sole.

Checklist per principianti

Quando il tuo programma con dizionari non funziona, controlla:

Ho usato parentesi graffe?
Ho usato "key": value?
Ho separato gli elementi con virgole?
Ho messo le chiavi stringa tra virgolette?
Ho usato : dentro il dizionario, non =?
La chiave esiste?
Ho scritto la chiave correttamente?
Ho usato le stesse maiuscole?
Dovrei usare get() invece di []?
Sto confondendo indici di lista con chiavi di dizionario?
Sto scorrendo chiavi, valori o items?

I dizionari sono potenti.

Ma i nomi delle chiavi devono essere esatti.

La maggior parte dei bug iniziali con i dizionari viene da:

chiave sbagliata
chiave mancante
virgolette mancanti
virgola mancante
uso di = invece di :

La buona notizia:

questi errori sono normali.

La notizia migliore:

diventano più facili da vedere.

La brutta notizia:

li farai ancora.

Benvenuto nella programmazione.

Riassunto

Oggi hai imparato:

• i dizionari salvano coppie chiave-valore;
• i dizionari usano parentesi graffe;
• chiavi e valori sono separati da due punti;
• gli elementi sono separati da virgole;
• i valori si leggono tramite chiavi;
• le chiavi devono corrispondere esattamente;
• i valori possono essere aggiornati;
• nuove coppie chiave-valore possono essere aggiunte;
• del rimuove un elemento;
• pop() rimuove un elemento e restituisce il suo valore;
• in controlla se una chiave esiste;
• get() legge valori in modo sicuro quando una chiave potrebbe mancare;
• i cicli possono attraversare le chiavi di un dizionario;
• .items() dà chiavi e valori;
• .values() dà i valori;
• le liste possono contenere dizionari;
• i dizionari possono contenere liste;
• i dizionari possono contenere altri dizionari;
• i dizionari sono molto utili per dati strutturati.

Questo è un passo enorme.

Ora i tuoi programmi possono salvare dati significativi.

Non solo valori.

Valori etichettati.

Valori strutturati.

Dati che assomigliano ai dati delle vere applicazioni.

Utenti.

Prodotti.

Contatti.

Libri.

Task.

Ordini.

Profili.

Ti stai avvicinando molto al software reale.

Progresso molto forte.

Molto Python.

Prossima lezione

Nella prossima lezione impareremo le funzioni.

Le funzioni ti permettono di riutilizzare codice.

Invece di scrivere la stessa logica ancora e ancora, creerai i tuoi comandi.

Così:

def greet_user(name):
    print(f"Hello, {name}!")

Poi potrai chiamare:

greet_user("Anna")
greet_user("Marco")
greet_user("Sofia")

Le funzioni sono uno dei passaggi più grandi nella programmazione.

Aiutano a organizzare il codice.

Riducono la ripetizione.

Rendono i programmi più facili da leggere.

E fanno sembrare il codice meno spaghetti.

Molto importante.

Molto Python.

Molto livello successivo.