JSON: salvare dati strutturati
Bentornato.
Nella lezione precedente hai imparato moduli e import.
I tuoi programmi hanno imparato a dividere il codice in più file.
Hai scritto progetti tipo:
main.py
tasks.py
safe_input.py
Molto bene.
Ora il tuo codice è più organizzato.
Meno file gigante.
Meno lasagna di codice.
Meno “dove ho messo quella funzione?”
Ottimo progresso.
Ma ora abbiamo un altro problema.
Nelle lezioni precedenti abbiamo salvato dati in semplici file di testo.
Per esempio:
Anna,anna@example.com,123456
Marco,marco@example.com,987654
Funziona.
Ma non è perfetto.
Cosa succede se i dati diventano più complessi?
Cosa succede se un contatto ha più campi?
Cosa succede se vuoi salvare una lista di dizionari?
Cosa succede se l’utente scrive una virgola nel nome?
Caos.
I file di testo sono utili.
Ma per dati strutturati, JSON è meglio.
JSON ci permette di salvare dati così:
contact = {
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
}
dentro un file.
Poi possiamo caricarli di nuovo più tardi.
Questo è molto importante.
JSON è usato ovunque.
API.
Web app.
File di configurazione.
Database.
Comunicazione tra frontend e backend.
Piccoli script che per sbaglio diventano software vero.
Molto utile.
Molto pratico.
Molto amico di Python.
Cosa imparerai
In questa lezione imparerai:
- cos’è JSON;
- perché JSON è utile;
- com’è fatto JSON;
- perché JSON assomiglia a dizionari e liste Python;
- come importare il modulo
json; - come salvare dati con
json.dump(); - come caricare dati con
json.load(); - come salvare un dizionario;
- come salvare una lista di dizionari;
- come formattare JSON bene con
indent; - come gestire file JSON mancanti;
- come costruire una rubrica usando JSON;
- errori comuni dei principianti con JSON.
Alla fine di questa lezione i tuoi programmi potranno salvare dati strutturati correttamente.
Non solo semplici righe.
Dati veri.
Liste.
Dizionari.
Informazioni annidate.
Molto potente.
Molto utile.
Molto “adesso questo inizia a sembrare una vera app”.
Cos’è JSON?
JSON significa:
JavaScript Object Notation
Non andare in panico.
Anche se nel nome c’è JavaScript, JSON è usato da molti linguaggi.
Python usa JSON.
JavaScript usa JSON.
Java usa JSON.
Le API usano JSON.
Le web app usano JSON.
Tutti usano JSON.
JSON è un formato testuale per salvare e scambiare dati.
Assomiglia a questo:
{
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
}
Ti sembra familiare?
È molto simile a un dizionario Python.
Dizionario Python:
contact = {
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
}
JSON:
{
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
}
Molto simile.
Non esattamente uguale.
Ma abbastanza vicino da sembrare amichevole.
Come cugini.
Uno parla Python.
L’altro parla web.
Perché JSON è utile
JSON è utile perché può salvare dati strutturati.
Per esempio, un contatto:
{
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
}
Una lista di contatti:
[
{
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
},
{
"name": "Marco",
"email": "marco@example.com",
"phone": "987654"
}
]
Questo è molto meglio del testo semplice:
Anna,anna@example.com,123456
Marco,marco@example.com,987654
Perché?
Perché JSON mantiene la struttura.
Sa che ogni contatto ha:
name
email
phone
Può salvare liste.
Può salvare dizionari.
Può salvare dati annidati.
Il testo semplice è come scrivere tutto su un tovagliolo.
JSON è come usare un piccolo modulo organizzato.
Sempre testo.
Ma con struttura.
Molto bello.
Importare il modulo json
Python ha già un modulo integrato per JSON.
Si chiama:
json
Per usarlo, importalo:
import json
Non devi installare niente.
Python lo include già.
Molto comodo.
Molto civile.
Molto “finalmente qualcosa funziona senza installare diciassette pacchetti”.
Idea base:
import json
Poi puoi usare:
json.dump()
json.load()
Queste due funzioni sono molto importanti.
dump salva dati in un file.
load carica dati da un file.
Semplice.
Quasi troppo semplice.
Non preoccuparti.
Lo renderemo confuso più avanti.
È così che funziona la programmazione.
Salvare un dizionario in JSON
Crea un file:
save_contact.py
Scrivi:
import json
contact = {
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
}
with open("contact.json", "w") as file:
json.dump(contact, file)
Esegui:
python save_contact.py
oppure:
python3 save_contact.py
Python crea un file:
contact.json
Dentro potresti vedere:
{"name": "Anna", "email": "anna@example.com", "phone": "123456"}
Questo è JSON valido.
Non molto bello.
Ma valido.
Questa riga salva il dizionario:
json.dump(contact, file)
Importante:
json.dump(data, file)
significa:
Salva questi dati Python in questo file come JSON.
Molto utile.
Molto pulito.
Molto strutturato.
JSON bello con indent
Il JSON precedente funziona, ma è tutto su una riga.
Possiamo renderlo più bello.
Usa indent=4.
Esempio:
import json
contact = {
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
}
with open("contact.json", "w") as file:
json.dump(contact, file, indent=4)
Ora contact.json appare così:
{
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
}
Molto meglio.
Molto più leggibile.
Molto meno “spaghetti JSON”.
Usa indent=4 quando vuoi JSON leggibile dagli esseri umani.
Ai computer non importa.
Agli esseri umani sì.
E purtroppo tu sei umano.
La maggior parte dei giorni.
Caricare un dizionario da JSON
Ora leggiamo di nuovo il file JSON.
Crea un file:
load_contact.py
Scrivi:
import json
with open("contact.json", "r") as file:
contact = json.load(file)
print(contact)
print(contact["name"])
print(contact["email"])
print(contact["phone"])
Output:
{'name': 'Anna', 'email': 'anna@example.com', 'phone': '123456'}
Anna
anna@example.com
123456
Questa riga carica JSON dal file:
contact = json.load(file)
Dopo il caricamento, contact è di nuovo un dizionario Python.
Questa è la magia.
Non magia finta.
Magia utile.
Workflow:
Dizionario Python
salva come JSON
carica da JSON
di nuovo dizionario Python
Molto importante.
Molto pratico.
Molto mondo reale.
json.dump() vs json.load()
Questi due nomi sono importanti.
json.dump(data, file)
salva dati in un file.
json.load(file)
carica dati da un file.
Ricorda:
dump = salva
load = leggi
Esempio:
json.dump(contact, file)
significa:
Salva contact nel file.
Esempio:
contact = json.load(file)
significa:
Leggi JSON dal file e convertilo in dati Python.
Questa coppia si usa continuamente.
Se ricordi solo una cosa da questa lezione, ricorda:
json.dump() salva.
json.load() carica.
Questo è il cuore della gestione dei file JSON.
Cuore piccolo.
Molto utile.
Salvare una lista in JSON
JSON può salvare anche liste.
Crea:
save_tasks_json.py
Scrivi:
import json
tasks = [
"Buy milk",
"Study Python",
"Drink coffee"
]
with open("tasks.json", "w") as file:
json.dump(tasks, file, indent=4)
Il file tasks.json conterrà:
[
"Buy milk",
"Study Python",
"Drink coffee"
]
Questo è un array JSON.
In Python lo chiamiamo lista.
In JSON si chiama array.
Stessa idea.
Vocabolario diverso.
La programmazione ama dare nomi diversi alla stessa cosa.
Ci mantiene umili.
E leggermente infastiditi.
Caricare una lista da JSON
Crea:
load_tasks_json.py
Scrivi:
import json
with open("tasks.json", "r") as file:
tasks = json.load(file)
for task in tasks:
print(f"- {task}")
Output:
- Buy milk
- Study Python
- Drink coffee
L’array JSON è diventato una lista Python.
Molto utile.
Questo è meglio che leggere righe manualmente.
Con il testo semplice facevamo:
for line in file:
tasks.append(line.strip())
Con JSON, Python può caricare automaticamente tutta la struttura:
tasks = json.load(file)
Più pulito.
Più potente.
Meno chirurgia manuale sulle stringhe.
Ottimo.
Salvare una lista di dizionari
Qui JSON diventa davvero utile.
Crea:
save_contacts_json.py
Scrivi:
import json
contacts = [
{
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
},
{
"name": "Marco",
"email": "marco@example.com",
"phone": "987654"
}
]
with open("contacts.json", "w") as file:
json.dump(contacts, file, indent=4)
Il file contacts.json conterrà:
[
{
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
},
{
"name": "Marco",
"email": "marco@example.com",
"phone": "987654"
}
]
Questo è molto meglio di:
Anna,anna@example.com,123456
Marco,marco@example.com,987654
Perché la struttura è chiara.
Ogni contatto è un oggetto.
Ogni oggetto ha chiavi.
La lista contiene contatti.
Bello.
Organizzato.
Come un archivio.
Ma meno polveroso.
Caricare una lista di dizionari
Crea:
load_contacts_json.py
Scrivi:
import json
with open("contacts.json", "r") as file:
contacts = json.load(file)
for contact in contacts:
print("-----")
print(f"Name: {contact['name']}")
print(f"Email: {contact['email']}")
print(f"Phone: {contact['phone']}")
Output:
-----
Name: Anna
Email: anna@example.com
Phone: 123456
-----
Name: Marco
Email: marco@example.com
Phone: 987654
Ora puoi salvare e caricare dati strutturati dei contatti.
Questo è reale.
Questo pattern appare ovunque.
Una lista di dizionari è una delle strutture dati più comuni per principianti.
JSON la salva benissimo.
Python la carica facilmente.
Molto bello.
Molto pratico.
Molto backend-friendly.
Tipi Python e JSON
I dati Python diventano dati JSON.
Conversione base:
Python dict -> JSON object
Python list -> JSON array
Python string -> JSON string
Python int/float -> JSON number
Python True -> JSON true
Python False -> JSON false
Python None -> JSON null
Esempio Python:
data = {
"name": "Anna",
"age": 25,
"active": True,
"skills": ["Python", "HTML", "CSS"],
"address": None
}
JSON:
{
"name": "Anna",
"age": 25,
"active": true,
"skills": [
"Python",
"HTML",
"CSS"
],
"address": null
}
Nota:
True diventa true
False diventa false
None diventa null
Piccole differenze.
Differenze importanti.
JSON non è esattamente Python.
Sembra solo Python dopo aver preso un tè con JavaScript.
Regole importanti di JSON
JSON ha regole.
Regole molto severe.
Le stringhe devono usare virgolette doppie:
"name"
Non virgolette singole:
'name'
JSON corretto:
{
"name": "Anna"
}
JSON non valido:
{
'name': 'Anna'
}
Inoltre, JSON non permette virgole finali.
Corretto:
{
"name": "Anna",
"age": 25
}
Sbagliato:
{
"name": "Anna",
"age": 25,
}
I dizionari Python permettono più flessibilità.
JSON è più severo.
Molto severo.
Come un insegnante con il righello.
Ma per i dati.
Gestire file JSON mancanti
Se provi a caricare un file JSON che non esiste, Python dà:
FileNotFoundError
Esempio:
import json
with open("missing.json", "r") as file:
data = json.load(file)
Versione più sicura:
import json
try:
with open("contacts.json", "r") as file:
contacts = json.load(file)
except FileNotFoundError:
contacts = []
print(contacts)
Se il file esiste, i contatti vengono caricati.
Se non esiste, contacts diventa una lista vuota.
Questo è utile al primo avvio.
Programma nuovo.
Ancora nessun dato.
Nessun disastro.
Solo una lista vuota che aspetta vita.
Molto poetico.
Per un file.
Salvare dopo le modifiche
Quando lavori con JSON, il pattern normale è:
carica dati
modifica dati
salva dati
Esempio:
import json
try:
with open("contacts.json", "r") as file:
contacts = json.load(file)
except FileNotFoundError:
contacts = []
new_contact = {
"name": "Sofia",
"email": "sofia@example.com",
"phone": "555000"
}
contacts.append(new_contact)
with open("contacts.json", "w") as file:
json.dump(contacts, file, indent=4)
Questo fa:
Carica contatti.
Se il file manca, parte con lista vuota.
Aggiunge nuovo contatto.
Salva la lista aggiornata.
Questo pattern è estremamente importante.
Lo userai ancora e ancora.
Carica.
Modifica.
Salva.
Il triangolo sacro dei piccoli programmi con dati.
Molto utile.
Molto pratico.
Molto facile dimenticare un lato e chiedersi perché nulla si salva.
Mini programma: salvare un profilo come JSON
Crea:
profile_json.py
Scrivi:
import json
profile = {
"name": input("Name: "),
"city": input("City: "),
"job": input("Job: ")
}
with open("profile.json", "w") as file:
json.dump(profile, file, indent=4)
print("Profile saved.")
Esempio input:
Name: Anna
City: Rome
Job: Developer
File profile.json:
{
"name": "Anna",
"city": "Rome",
"job": "Developer"
}
È semplice.
Ma potente.
Hai salvato un dizionario come dati strutturati.
Puoi leggerlo più tardi.
Puoi modificarlo.
Puoi usarlo in un altro programma.
Piccolo progetto.
Idea reale.
Mini programma: caricare un profilo da JSON
Crea:
show_profile_json.py
Scrivi:
import json
try:
with open("profile.json", "r") as file:
profile = json.load(file)
print("----- Profile -----")
print(f"Name: {profile['name']}")
print(f"City: {profile['city']}")
print(f"Job: {profile['job']}")
except FileNotFoundError:
print("No profile found.")
Output:
----- Profile -----
Name: Anna
City: Rome
Job: Developer
Ora il tuo programma può caricare dati strutturati.
Questo è un grande passo.
Un profilo in testo semplice richiederebbe parsing manuale.
JSON lo rende diretto.
Niente split.
Niente virgole.
Niente chirurgia sulle stringhe.
Solo carica e usa.
Bellissimo.
Mini programma: task manager JSON
Crea:
json_task_manager.py
Scrivi:
import json
FILE_NAME = "tasks.json"
def load_tasks():
try:
with open(FILE_NAME, "r") as file:
return json.load(file)
except FileNotFoundError:
return []
def save_tasks(tasks):
with open(FILE_NAME, "w") as file:
json.dump(tasks, file, indent=4)
def show_menu():
print("----- JSON Task Manager -----")
print("1. Add task")
print("2. Show tasks")
print("3. Remove task")
print("q. Quit")
def add_task(tasks):
task = {
"title": input("Task title: "),
"done": False
}
tasks.append(task)
save_tasks(tasks)
print("Task saved.")
def show_tasks(tasks):
if len(tasks) == 0:
print("No tasks yet.")
else:
print("Tasks:")
for index, task in enumerate(tasks, start=1):
status = "done" if task["done"] else "not done"
print(f"{index}. {task['title']} - {status}")
def remove_task(tasks):
if len(tasks) == 0:
print("No tasks to remove.")
return
show_tasks(tasks)
try:
task_number = int(input("Task number to remove: "))
index = task_number - 1
if index < 0 or index >= len(tasks):
print("Invalid task number.")
return
removed_task = tasks.pop(index)
save_tasks(tasks)
print(f"Removed: {removed_task['title']}")
except ValueError:
print("Please enter a valid number.")
tasks = load_tasks()
while True:
show_menu()
choice = input("Choose an option: ").lower()
if choice == "1":
add_task(tasks)
elif choice == "2":
show_tasks(tasks)
elif choice == "3":
remove_task(tasks)
elif choice == "q":
print("Goodbye.")
break
else:
print("Unknown option.")
Questo task manager salva i task come dizionari.
Ogni task ha:
title
done
Esempio JSON:
[
{
"title": "Study Python",
"done": false
},
{
"title": "Drink coffee",
"done": false
}
]
Questo è meglio di una semplice lista di nomi dei task.
Perché ora ogni task può avere più informazioni.
Più avanti puoi aggiungere:
priority
deadline
category
created_at
JSON cresce meglio del testo semplice.
Il testo semplice va bene per dati semplici.
JSON è meglio per dati strutturati.
Mini programma: rubrica JSON
Crea:
json_contact_book.py
Scrivi:
import json
FILE_NAME = "contacts.json"
def load_contacts():
try:
with open(FILE_NAME, "r") as file:
return json.load(file)
except FileNotFoundError:
return []
def save_contacts(contacts):
with open(FILE_NAME, "w") as file:
json.dump(contacts, file, indent=4)
def show_menu():
print("----- JSON Contact Book -----")
print("1. Add contact")
print("2. Show contacts")
print("q. Quit")
def add_contact(contacts):
contact = {
"name": input("Name: "),
"email": input("Email: "),
"phone": input("Phone: ")
}
contacts.append(contact)
save_contacts(contacts)
print("Contact saved.")
def show_contacts(contacts):
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']}")
contacts = load_contacts()
while True:
show_menu()
choice = input("Choose an option: ").lower()
if choice == "1":
add_contact(contacts)
elif choice == "2":
show_contacts(contacts)
elif choice == "q":
print("Goodbye.")
break
else:
print("Unknown option.")
Questa è una vera app per principianti.
Usa:
- dizionari;
- liste;
- file;
- JSON;
- funzioni;
- cicli;
- condizioni;
- gestione degli errori.
Molto forte.
Molto utile.
Molto reale.
I tuoi dati dei contatti ora sono strutturati e salvati correttamente.
Molto meglio del testo separato da virgole.
Perché se più avanti aggiungi:
address
birthday
notes
company
JSON lo gestisce bene.
Il testo semplice inizia a sudare.
Errore comune: dimenticare import json
Sbagliato:
with open("data.json", "w") as file:
json.dump(data, file)
Se non hai scritto:
import json
Python dà:
NameError
Corretto:
import json
with open("data.json", "w") as file:
json.dump(data, file)
Importa sempre il modulo prima di usarlo.
Python è potente.
Ma non indovina automaticamente i tuoi import.
Non legge la mente.
Per fortuna.
Errore comune: usare dump e load al contrario
Sbagliato:
data = json.dump(file)
Sbagliato:
json.load(data, file)
Corretto:
json.dump(data, file)
Corretto:
data = json.load(file)
Ricorda:
dump prende data e file
load prende file e restituisce data
Piccolo trucco:
dump data into a file
load data from a file
Se sembra confuso, è normale.
I nomi sono corti.
La confusione è lunga.
La pratica aiuta.
Errore comune: provare a salvare dati non supportati
JSON può salvare tipi comuni:
dict
list
str
int
float
bool
None
Ma non tutto.
Per esempio, questo può fallire:
data = {
"numbers": {1, 2, 3}
}
Perché?
Perché {1, 2, 3} è un set.
JSON non supporta direttamente i set Python.
Se devi salvare un set, convertilo in lista:
data = {
"numbers": list({1, 2, 3})
}
Per principianti, usa:
dizionari
liste
stringhe
numeri
booleani
None
Questi funzionano bene con JSON.
Tieni semplice.
Il semplice sopravvive.
Il complicato chiede caffè.
Errore comune: file JSON non valido
Se il file JSON è rotto, json.load() può fallire.
Esempio JSON non valido:
{
"name": "Anna",
}
La virgola finale lo rende non valido.
Python può generare:
json.JSONDecodeError
Caricamento più sicuro:
import json
try:
with open("data.json", "r") as file:
data = json.load(file)
except FileNotFoundError:
data = []
except json.JSONDecodeError:
print("JSON file is broken.")
data = []
Questo gestisce:
file mancante
file JSON rotto
Molto utile.
Specialmente quando gli esseri umani modificano JSON manualmente.
Gli esseri umani e le virgole sono una combinazione pericolosa.
Molto pericolosa.
Errore comune: dimenticare di salvare dopo append
Sbagliato:
contacts = load_contacts()
contact = {
"name": "Anna",
"email": "anna@example.com",
"phone": "123456"
}
contacts.append(contact)
print("Contact added.")
Questo aggiunge il contatto solo in memoria.
Ma non lo salva nel file.
Quando il programma finisce, il nuovo contatto sparisce.
Corretto:
contacts.append(contact)
save_contacts(contacts)
Ricorda il pattern:
load
modify
save
Se modifichi i dati ma non li salvi, il file non cambia.
Python non lo salverà emotivamente.
Devi dirglielo.
Chiaramente.
Con codice.
Errore comune: aprire JSON in modalità append
Questo di solito è sbagliato:
with open("contacts.json", "a") as file:
json.dump(contact, file)
Aggiungere oggetti JSON direttamente può creare JSON non valido.
Esempio di file rotto:
{"name": "Anna"}{"name": "Marco"}
Questa non è una lista JSON valida.
Per i file JSON, di solito fai così:
carica lista esistente
aggiungi elemento alla lista
salva di nuovo tutta la lista
Esempio:
contacts = load_contacts()
contacts.append(new_contact)
save_contacts(contacts)
Questo mantiene valido il file JSON.
La modalità append è utile per log in testo semplice.
Per dati strutturati JSON, attenzione.
Molta attenzione.
JSON ama la struttura.
Non oggetti casuali incollati insieme.
Pratica
Crea:
practice_json.py
Scrivi un programma che:
- chiede all’utente il titolo di un libro;
- chiede all’utente l’autore;
- chiede all’utente l’anno;
- salva il libro come JSON in
book.json; - carica di nuovo il libro;
- stampa il libro in modo ordinato.
Soluzione esempio:
import json
book = {
"title": input("Title: "),
"author": input("Author: "),
"year": input("Year: ")
}
with open("book.json", "w") as file:
json.dump(book, file, indent=4)
with open("book.json", "r") as file:
loaded_book = json.load(file)
print("----- Book -----")
print(f"Title: {loaded_book['title']}")
print(f"Author: {loaded_book['author']}")
print(f"Year: {loaded_book['year']}")
Questa pratica insegna:
- creare un dizionario;
- salvare un dizionario come JSON;
- caricare JSON;
- usare il dizionario caricato.
Semplice.
Utile.
Molto strutturato.
Molto bene.
Mini sfida
Crea:
library_json.py
Costruisci un piccolo programma biblioteca che:
- salva libri in
books.json; - carica libri all’avvio;
- permette all’utente di aggiungere un libro;
- permette all’utente di mostrare tutti i libri;
- ogni libro ha titolo, autore e anno;
- gestisce in modo sicuro il file mancante.
Struttura esempio:
import json
FILE_NAME = "books.json"
def load_books():
try:
with open(FILE_NAME, "r") as file:
return json.load(file)
except FileNotFoundError:
return []
def save_books(books):
with open(FILE_NAME, "w") as file:
json.dump(books, file, indent=4)
def add_book(books):
book = {
"title": input("Title: "),
"author": input("Author: "),
"year": input("Year: ")
}
books.append(book)
save_books(books)
print("Book saved.")
def show_books(books):
if len(books) == 0:
print("No books yet.")
else:
print("Books:")
for book in books:
print("-----")
print(f"Title: {book['title']}")
print(f"Author: {book['author']}")
print(f"Year: {book['year']}")
def show_menu():
print("----- Library -----")
print("1. Add book")
print("2. Show books")
print("q. Quit")
books = load_books()
while True:
show_menu()
choice = input("Choose an option: ").lower()
if choice == "1":
add_book(books)
elif choice == "2":
show_books(books)
elif choice == "q":
print("Goodbye.")
break
else:
print("Unknown option.")
Questa è una vera piccola applicazione.
Usa JSON per salvare una lista di dizionari.
Questo è un pattern molto importante.
Molto utile per progetti futuri.
Puoi adattare questa struttura per:
contacts
tasks
products
students
courses
expenses
workouts
L’idea è la stessa.
Carica dati.
Modifica dati.
Salva dati.
Congratulazioni.
Stai costruendo pattern riutilizzabili.
È così che crescono gli sviluppatori.
Lentamente.
Dolorosamente.
Con snack.
Sfida extra: migliora il task manager
Prendi il task manager JSON e aggiungi una nuova opzione:
4. Mark task as done
Ogni task ha già:
"done": False
Il tuo compito:
- mostrare i task con numeri;
- chiedere quale task segnare come fatto;
- cambiare
"done"inTrue; - salvare di nuovo i task.
Suggerimento:
tasks[index]["done"] = True
save_tasks(tasks)
Questa è un’ottima sfida.
Ti insegna ad aggiornare dati strutturati.
Non solo aggiungere.
Non solo cancellare.
Aggiornare.
È quello che fanno sempre le app reali.
Create.
Read.
Update.
Delete.
Più avanti sentirai chiamare questo CRUD.
Parola molto seria.
Idea molto semplice.
Molto utile.
Checklist per principianti
Quando il codice JSON non funziona, controlla:
Ho importato json?
Sto usando json.dump(data, file)?
Sto usando data = json.load(file)?
Ho aperto il file nella modalità corretta?
Ho usato indent=4 per JSON leggibile?
Il file esiste prima di leggerlo?
Dovrei gestire FileNotFoundError?
Il file JSON è valido?
Ho lasciato per sbaglio una virgola finale?
Sto provando a salvare un tipo Python non supportato?
Ho salvato dopo aver cambiato i dati?
Sto facendo append a JSON nel modo sbagliato?
I bug JSON di solito riguardano:
file mancante
JSON non valido
uso sbagliato di dump/load
salvataggio dimenticato
struttura dati sbagliata
Sistema con calma.
Leggi il messaggio di errore.
Controlla il file.
Controlla i dati.
Bevi caffè se serve.
Ma non lanciare il laptop.
Il laptop è innocente.
Di solito.
Riassunto
Oggi hai imparato:
- JSON è un formato comune per dati strutturati;
- JSON assomiglia a dizionari e liste Python;
- Python usa il modulo integrato
json; json.dump()salva dati Python in un file JSON;json.load()carica dati JSON da un file;indent=4rende JSON leggibile;- i dizionari possono essere salvati come oggetti JSON;
- le liste possono essere salvate come array JSON;
- le liste di dizionari sono molto utili con JSON;
True,FalseeNonediventanotrue,falseenull;- JSON richiede virgolette doppie;
- JSON non permette virgole finali;
- i file JSON mancanti possono essere gestiti con
FileNotFoundError; - JSON rotto può generare
json.JSONDecodeError; - il pattern comune è carica, modifica, salva;
- JSON è meglio del testo semplice per dati strutturati.
Questo è un grande passo.
I tuoi programmi ora possono salvare dati strutturati veri.
Non solo righe di testo.
Possono salvare contatti.
Task.
Libri.
Profili.
Prodotti.
Qualsiasi cosa che entra in dizionari e liste.
Questo è il tipo di struttura dati usata nelle applicazioni reali.
I piccoli programmi da principianti stanno diventando seri.
Ancora piccoli.
Ma seri.
Come un piccolo ingegnere con una clipboard.
Prossima lezione
Nella prossima lezione impareremo virtual environments e installare pacchetti.
Finora abbiamo usato solo strumenti integrati di Python.
Ma i progetti Python reali spesso usano pacchetti esterni.
Imparerai a creare un virtual environment:
python -m venv .venv
Attivarlo.
Installare pacchetti con pip.
E tenere organizzate le dipendenze del progetto.
Questo è molto importante prima di costruire progetti più grandi.
Perché installare pacchetti globalmente è il modo in cui comincia il caos.
E abbiamo già abbastanza caos.
Molto Python.
Molto mondo reale.
Molto necessario.