File: salvare e leggere dati

Bentornato.

Nella lezione precedente hai imparato le funzioni.

I tuoi programmi hanno imparato a organizzare il codice in blocchi riutilizzabili.

Hai scritto cose come:

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

Molto bene.

Le funzioni hanno reso il tuo codice più pulito.

Meno ripetizione.

Meno caos da copia-incolla.

Meno “perché ho scritto questa stessa cosa sette volte?”

Ottimo progresso.

Ma ora abbiamo un altro problema.

Il tuo programma può salvare dati nelle variabili.

Il tuo programma può salvare liste.

Il tuo programma può salvare dizionari.

Ma quando il programma si ferma, tutto sparisce.

Molto triste.

Molto temporaneo.

Esempio:

tasks = ["Buy milk", "Study Python", "Drink coffee"]

Questa lista esiste mentre il programma è in esecuzione.

Ma quando il programma finisce?

Sparita.

Come la motivazione dopo aver letto un errore di 300 righe.

I file risolvono questo problema.

I file permettono al tuo programma di salvare dati.

Poi il programma può leggere quei dati più tardi.

Questo è un grande passo.

I programmi diventano molto più utili quando possono ricordare le cose.

Task.

Note.

Contatti.

Impostazioni.

Report.

Log.

Piccole memorie.

Molto utili.

Molto Python.

Cosa imparerai

In questa lezione imparerai:

• perché i file sono utili;
• come scrivere testo in un file;
• come leggere testo da un file;
• come usare open();
• perché with open() è importante;
• come funzionano le modalità dei file;
• come scrivere più righe;
• come leggere riga per riga;
• come aggiungere dati a un file;
• come salvare una lista;
• come caricare una lista da un file;
• come costruire un piccolo task manager che ricorda i task;
• errori comuni dei principianti con i file.

Alla fine di questa lezione i tuoi programmi non dimenticheranno più tutto immediatamente.

Potranno salvare dati.

Leggere dati.

Aggiungere dati.

Caricare dati.

Molto potente.

Molto pratico.

Molto “ora questo programma sta diventando utile”.

Perché i file sono importanti

Le variabili vivono in memoria.

I file vivono sul disco.

Una variabile è temporanea:

name = "Anna"

Quando il programma finisce, la variabile sparisce.

Un file può restare anche dopo la fine del programma.

Per esempio:

notes.txt
tasks.txt
contacts.txt
report.txt

Il tuo programma può scrivere dati in un file.

Più tardi, il programma può aprire il file e leggere i dati.

Questo è importante per molti programmi reali.

Esempi:

Un task manager salva task.
Un’app di note salva note.
Una calcolatrice salva la cronologia.
Un gioco salva i progressi.
Un sito web scrive log.
Uno script scrive un report.

Senza file, il tuo programma ha una memoria molto corta.

Come un pesce rosso con una tastiera.

Carino.

Non molto utile.

Scrivere in un file

Crea un file:

write_file.py

Scrivi:

file = open("message.txt", "w")

file.write("Hello from Python!")

file.close()

Eseguilo:

python write_file.py

oppure:

python3 write_file.py

Python crea un file chiamato:

message.txt

Dentro il file dovresti vedere:

Hello from Python!

Questa riga apre il file:

file = open("message.txt", "w")

Questa riga scrive testo:

file.write("Hello from Python!")

Questa riga chiude il file:

file.close()

Molto importante:

Chiudi sempre i file se li apri manualmente.

Ma Python ha un modo migliore.

Perché Python ha visto gli esseri umani dimenticare le cose e ha detto:

Va bene, vi aiuto io.

Usare with open()

Il modo migliore è usare with open().

Esempio:

with open("message.txt", "w") as file:
    file.write("Hello from Python!")

Fa la stessa cosa.

Ma chiude automaticamente il file.

Molto meglio.

Molto più sicuro.

Molto meno “ops, ho dimenticato close()”.

Crea un file:

write_file_with.py

Scrivi:

with open("message.txt", "w") as file:
    file.write("Hello from Python with with open()!")

Eseguilo.

Apri message.txt.

Dovresti vedere:

Hello from Python with with open()!

Da ora in poi usa:

with open(...)

Questo è lo stile consigliato.

Più pulito.

Più sicuro.

Più professionale.

Meno probabilità di far sospirare Python.

Modalità dei file

Quando apri un file, scegli una modalità.

La modalità dice a Python cosa vuoi fare.

Modalità comuni:

"r"  leggere
"w"  scrivere
"a"  aggiungere

Esempio:

open("file.txt", "r")

significa:

Apri il file per leggere.

Esempio:

open("file.txt", "w")

significa:

Apri il file per scrivere.

Esempio:

open("file.txt", "a")

significa:

Apri il file per aggiungere alla fine.

Avviso importante:

"w" sovrascrive il file.

Se il file ha già contenuto, "w" lo sostituisce.

Nessuna pietà.

Nessun dramma.

Semplicemente sparito.

Python con modalità "w" è tipo:

Nuovo file. Nuova vita. Vecchio contenuto? Addio.

Fai attenzione.

Scrivere più righe

Puoi scrivere più righe usando \n.

Esempio:

with open("notes.txt", "w") as file:
    file.write("First line\n")
    file.write("Second line\n")
    file.write("Third line\n")

\n significa:

nuova riga

Dopo aver eseguito il programma, notes.txt conterrà:

First line
Second line
Third line

Senza \n, tutto resta su una sola riga.

Esempio:

file.write("First")
file.write("Second")

Risultato:

FirstSecond

Non bello.

Non leggibile.

Tutto appiccicato.

Usa \n quando vuoi una nuova riga.

Piccolo simbolo.

Grande potere di formattazione.

Leggere un file

Crea un file chiamato:

message.txt

Metti dentro questo testo:

Hello from a file!

Ora crea un file Python:

read_file.py

Scrivi:

with open("message.txt", "r") as file:
    content = file.read()

print(content)

Eseguilo.

Output:

Hello from a file!

Questa riga apre il file in lettura:

with open("message.txt", "r") as file:

Questa riga legge tutto il file:

content = file.read()

Poi lo stampiamo:

print(content)

Molto semplice.

Molto utile.

Il tuo programma ha appena letto dati dal disco.

Piccolo momento.

Grande potere.

Leggere tutto il file o leggere righe

read() legge tutto il file.

Esempio:

with open("notes.txt", "r") as file:
    content = file.read()

Va bene per file piccoli.

Ma a volte vuoi leggere riga per riga.

Esempio:

with open("notes.txt", "r") as file:
    for line in file:
        print(line)

Se notes.txt contiene:

First line
Second line
Third line

L’output potrebbe apparire così:

First line

Second line

Third line

Perché ci sono righe vuote in più?

Perché ogni riga ha già un carattere di nuova riga alla fine.

E print() aggiunge un’altra nuova riga.

Molto generoso.

Troppo generoso.

Possiamo sistemare con .strip().

Usare strip()

.strip() rimuove gli spazi extra all’inizio e alla fine di una stringa.

Rimuove anche i caratteri di nuova riga.

Esempio:

text = "Hello\n"
clean_text = text.strip()

print(clean_text)

Output:

Hello

Usalo quando leggi righe:

with open("notes.txt", "r") as file:
    for line in file:
        print(line.strip())

Ora l’output è più pulito:

First line
Second line
Third line

.strip() è molto utile quando leggi file.

I file spesso contengono nuove righe.

Gli esseri umani spesso non vogliono vedere spaziature strane.

Python ti dà .strip().

Piccolo strumento.

Grande sollievo.

Aggiungere dati a un file

La modalità "w" sovrascrive un file.

La modalità "a" aggiunge alla fine.

Crea un file:

append_file.py

Scrivi:

with open("notes.txt", "a") as file:
    file.write("New note\n")

Eseguilo più volte.

Ogni volta, Python aggiunge:

New note

alla fine del file.

Questo è utile per:

log
note
task
cronologia
report

La modalità append è più sicura quando non vuoi cancellare il contenuto vecchio.

Ricorda:

"w" scrive da zero.
"a" aggiunge alla fine.

Molto importante.

Molto sopravvivenza dei file.

Scrivere input utente in un file

Crea un file:

save_note.py

Scrivi:

note = input("Write a note: ")

with open("notes.txt", "a") as file:
    file.write(note + "\n")

print("Note saved.")

Esempio:

Write a note: Study Python files

Il programma salva la nota in:

notes.txt

Se lo esegui di nuovo, aggiunge un’altra nota.

Questo è già utile.

Un minuscolo salvatore di note.

Non elegante.

Non cloud-based.

Non in abbonamento.

Solo un file.

Bellissimo.

Leggere note salvate

Crea un file:

show_notes.py

Scrivi:

with open("notes.txt", "r") as file:
    for line in file:
        print(f"- {line.strip()}")

Se notes.txt contiene:

Study Python files
Drink coffee
Build something useful

Output:

- Study Python files
- Drink coffee
- Build something useful

Ora hai due programmi:

save_note.py
show_notes.py

Uno salva note.

Uno legge note.

Sistema minuscolo.

Molto umile.

Molto utile.

L’inizio del software.

Con meno form di login.

Per ora.

File Not Found Error

Se provi a leggere un file che non esiste, Python dà un errore.

Esempio:

with open("missing.txt", "r") as file:
    content = file.read()

Errore:

FileNotFoundError

Perché?

Perché "missing.txt" non esiste.

Python non può leggere un file che non c’è.

Molto logico.

Molto fastidioso.

Un modo semplice è creare prima il file.

Un altro modo è gestire l’errore.

Impareremo la gestione degli errori più avanti.

Per ora ricorda:

Leggere richiede che il file esista.
Scrivere può creare un file.
Append può creare un file se non esiste.

Questo è importante.

Molto pratico.

Molto “perché il mio script è crashato?” pratico.

Salvare una lista in un file

Immagina di avere una lista:

tasks = ["Buy milk", "Study Python", "Clean desk"]

Possiamo salvare ogni elemento su una riga separata.

Esempio:

tasks = ["Buy milk", "Study Python", "Clean desk"]

with open("tasks.txt", "w") as file:
    for task in tasks:
        file.write(task + "\n")

Il file tasks.txt conterrà:

Buy milk
Study Python
Clean desk

È semplice e utile.

Ogni task diventa una riga.

Una lista in Python diventa righe in un file.

Molto chiaro.

Molto adatto ai principianti.

Molto pratico.

Caricare una lista da un file

Ora possiamo leggere il file e ricostruire la lista.

Esempio:

tasks = []

with open("tasks.txt", "r") as file:
    for line in file:
        tasks.append(line.strip())

print(tasks)

Output:

['Buy milk', 'Study Python', 'Clean desk']

Cosa succede?

Inizia con una lista vuota.
Apri il file.
Leggi ogni riga.
Rimuovi la nuova riga con strip().
Aggiungi il testo pulito alla lista.

Ora il file è diventato di nuovo una lista Python.

Questo è molto importante.

È così che il tuo programma può ricordare dati tra diverse esecuzioni.

Salva lista.

Chiudi programma.

Apri programma più tardi.

Carica lista.

Memoria ottenuta.

Piccola vittoria.

Costruire funzioni di supporto

Conosciamo già le funzioni.

Quindi possiamo organizzare la logica dei file in funzioni.

Esempio:

def save_tasks(tasks):
    with open("tasks.txt", "w") as file:
        for task in tasks:
            file.write(task + "\n")

E:

def load_tasks():
    tasks = []

    with open("tasks.txt", "r") as file:
        for line in file:
            tasks.append(line.strip())

    return tasks

Ora il programma principale può usare:

tasks = load_tasks()
save_tasks(tasks)

Questo è più pulito.

Funzioni e file lavorano bene insieme.

Le funzioni organizzano il comportamento.

I file salvano i dati.

Molto bello.

Energia da software reale.

Gestire semplicemente un file mancante

Se il file non esiste, load_tasks() fallirà.

Possiamo gestirlo con try e except.

Niente panico.

Questa è solo una versione semplice.

Esempio:

def load_tasks():
    tasks = []

    try:
        with open("tasks.txt", "r") as file:
            for line in file:
                tasks.append(line.strip())
    except FileNotFoundError:
        pass

    return tasks

Cosa succede?

Prova ad aprire tasks.txt.
Se esiste, carica i task.
Se non esiste, ignora l’errore.
Restituisce una lista vuota.

Questo è utile.

La prima volta che esegui il programma, il file potrebbe non esistere ancora.

È normale.

Il programma non dovrebbe esplodere in modo teatrale.

Questo try e except lo mantiene calmo.

Come yoga per Python.

Più o meno.

Mini programma: salvare un task

Crea un file:

save_task.py

Scrivi:

task = input("Task: ")

with open("tasks.txt", "a") as file:
    file.write(task + "\n")

print("Task saved.")

Eseguilo.

Esempio:

Task: Study Python files

Eseguilo di nuovo.

Esempio:

Task: Build a small app

Ora tasks.txt contiene:

Study Python files
Build a small app

È già un piccolo script utile.

Piccolo.

Semplice.

Ma ricorda.

E ricordare è potente.

A meno che ricordi nomi di variabili imbarazzanti.

Allora meno potente.

Mini programma: mostrare task

Crea un file:

show_tasks.py

Scrivi:

try:
    with open("tasks.txt", "r") as file:
        print("Tasks:")

        for line in file:
            print(f"- {line.strip()}")
except FileNotFoundError:
    print("No tasks found.")

Se il file esiste, mostra i task.

Se il file non esiste, stampa:

No tasks found.

Questo è meglio che crashare.

Crashare è educativo.

Ma non sempre amichevole.

Un buon programma gestisce i problemi semplici.

Un file mancante è un problema semplice.

Più o meno.

Mini programma: task manager con file

Ora costruiamo un task manager che ricorda i task.

Crea un file:

task_manager_files.py

Scrivi:

FILE_NAME = "tasks.txt"

def load_tasks():
    tasks = []

    try:
        with open(FILE_NAME, "r") as file:
            for line in file:
                tasks.append(line.strip())
    except FileNotFoundError:
        pass

    return tasks

def save_tasks(tasks):
    with open(FILE_NAME, "w") as file:
        for task in tasks:
            file.write(task + "\n")

def show_menu():
    print("----- Task Manager -----")
    print("1. Add task")
    print("2. Show tasks")
    print("q. Quit")

def add_task(tasks):
    task = input("Task: ")
    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 task in tasks:
            print(f"- {task}")

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 == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

Questo è un vero miglioramento.

Prima, il tuo task manager dimenticava tutto.

Ora salva i task in un file.

Quando il programma parte, carica i task dal file.

Quando aggiungi un task, salva di nuovo la lista.

Questo è comportamento da programma reale.

Molto bene.

Molto pratico.

Molto “il mio codice ora ha memoria”.

Come funziona il task manager

Il nome del file è salvato qui:

FILE_NAME = "tasks.txt"

Questa funzione carica i task:

def load_tasks():

Questa funzione salva i task:

def save_tasks(tasks):

Questa funzione aggiunge un task:

def add_task(tasks):

Dentro add_task, facciamo questo:

tasks.append(task)
save_tasks(tasks)

Significa:

Aggiungi task alla lista.
Salva la lista aggiornata nel file.

L’idea importante è:

La lista viene usata mentre il programma gira.
Il file salva i dati tra una esecuzione e l’altra.

Questo è un pattern molto importante nella programmazione.

Memoria in RAM.

Archiviazione su disco.

Il tuo programma ora usa entrambe.

Molto serio.

Molto utile.

Scrivere vs aggiungere nel task manager

In save_tasks, usiamo "w":

with open(FILE_NAME, "w") as file:

Perché non "a"?

Perché vogliamo salvare tutta la lista attuale.

Se usassimo "a", i task potrebbero duplicarsi ogni volta che salviamo.

Esempio:

Buy milk
Study Python
Buy milk
Study Python

Non bene.

Quindi, per salvare lo stato completo, usa "w".

Per aggiungere direttamente una sola riga nuova, usa "a".

Regola semplice:

Usa "w" quando salvi tutto lo stato attuale.
Usa "a" quando aggiungi un nuovo elemento alla fine.

Questo è molto importante.

Piccola lettera di modalità.

Grande differenza.

Errore comune: dimenticare di chiudere il file

Modo manuale:

file = open("notes.txt", "w")
file.write("Hello")

Qui manca:

file.close()

Meglio:

with open("notes.txt", "w") as file:
    file.write("Hello")

Usa with open().

Chiude il file automaticamente.

Questo è lo stile che dovresti usare quasi sempre.

Pulito.

Sicuro.

Professionale.

Nessun file aperto dimenticato in giro come capre smarrite.

Errore comune: usare w e cancellare dati vecchi

Questo può essere pericoloso:

with open("notes.txt", "w") as file:
    file.write("New note\n")

Se notes.txt aveva già contenuto, viene sostituito.

Sparito.

Se vuoi aggiungere al file, usa "a":

with open("notes.txt", "a") as file:
    file.write("New note\n")

Ricorda:

"w" sovrascrive.
"a" aggiunge.

Questa è una delle lezioni più importanti sui file.

Non impararla nel modo doloroso.

Il modo doloroso è molto efficace.

Ma molto doloroso.

Errore comune: dimenticare la nuova riga

Sbagliato:

with open("tasks.txt", "a") as file:
    file.write("Buy milk")
    file.write("Study Python")

Risultato nel file:

Buy milkStudy Python

Corretto:

with open("tasks.txt", "a") as file:
    file.write("Buy milk\n")
    file.write("Study Python\n")

Risultato nel file:

Buy milk
Study Python

Usa \n quando ogni elemento deve stare su una nuova riga.

Le nuove righe sono piccole.

Ma senza di loro, il testo diventa pasta.

Non pasta buona.

Pasta bug.

Errore comune: leggere un file mancante

Sbagliato:

with open("tasks.txt", "r") as file:
    content = file.read()

Questo fallisce se tasks.txt non esiste.

Più sicuro:

try:
    with open("tasks.txt", "r") as file:
        content = file.read()
except FileNotFoundError:
    content = ""

Ora il programma non crasha.

Usa contenuto vuoto se il file manca.

Questo è utile quando il file verrà creato dopo.

Molti programmi principianti con file falliscono al primo avvio.

Perché?

Perché il file non esiste ancora.

Classico.

Molto classico.

Errore comune: non usare strip()

Quando leggi righe, potresti ottenere caratteri di nuova riga.

Esempio:

tasks = []

with open("tasks.txt", "r") as file:
    for line in file:
        tasks.append(line)

Questo potrebbe salvare:

["Buy milk\n", "Study Python\n"]

Meglio:

tasks.append(line.strip())

Ora ottieni:

["Buy milk", "Study Python"]

Usa .strip() quando vuoi testo pulito.

Specialmente quando leggi riga per riga.

Il tuo output futuro sarà più bello.

E meno infestato.

Errore comune: confusione con i percorsi

Questo:

with open("tasks.txt", "r") as file:

cerca tasks.txt nella directory corrente.

Questo significa:

la cartella da cui esegui il comando Python

Se Python dice che il file manca, magari il file esiste in un’altra cartella.

Esempio:

python scripts/task_manager.py

La directory corrente potrebbe non essere la stessa cartella dello script.

Questo può confondere i principianti.

Molto normale.

Per ora tieni il file Python e il file di testo nella stessa cartella.

Esegui il comando da quella cartella.

Semplice.

Meno dramma con i percorsi.

Il dramma dei percorsi è reale.

E a volte piccante.

Pratica

Crea un file:

practice_files.py

Scrivi un programma che:

• chiede all’utente un nome;
• chiede all’utente una città;
• salva entrambi i valori in profile.txt;
• legge profile.txt;
• stampa il profilo salvato.

Soluzione esempio:

name = input("Name: ")
city = input("City: ")

with open("profile.txt", "w") as file:
    file.write(name + "\n")
    file.write(city + "\n")

with open("profile.txt", "r") as file:
    lines = []

    for line in file:
        lines.append(line.strip())

print("----- Profile -----")
print(f"Name: {lines[0]}")
print(f"City: {lines[1]}")

Esempio:

Name: Anna
City: Rome

Output:

----- Profile -----
Name: Anna
City: Rome

Questo programma scrive dati.

Poi legge dati.

Poi usa i dati caricati.

Pattern molto importante.

Salva.

Carica.

Usa.

Questa è la gestione dei file in poche parole.

Un piccolo guscio di noce.

Con Python dentro.

Mini sfida

Crea un file:

notes_app.py

Il tuo programma deve:

• usare un file chiamato notes.txt;
• mostrare un menu;
• permettere all’utente di aggiungere una nota;
• permettere all’utente di mostrare tutte le note;
• permettere all’utente di uscire;
• mantenere le note salvate tra diverse esecuzioni del programma.

Menu:

1. Add note
2. Show notes
q. Quit

Soluzione esempio:

FILE_NAME = "notes.txt"

def show_menu():
    print("----- Notes App -----")
    print("1. Add note")
    print("2. Show notes")
    print("q. Quit")

def add_note():
    note = input("Note: ")

    with open(FILE_NAME, "a") as file:
        file.write(note + "\n")

    print("Note saved.")

def show_notes():
    try:
        with open(FILE_NAME, "r") as file:
            print("Notes:")

            has_notes = False

            for line in file:
                print(f"- {line.strip()}")
                has_notes = True

            if not has_notes:
                print("No notes yet.")
    except FileNotFoundError:
        print("No notes yet.")

while True:
    show_menu()

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

    if choice == "1":
        add_note()
    elif choice == "2":
        show_notes()
    elif choice == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

Questa è una vera mini applicazione.

Usa:

• file;
• funzioni;
• cicli;
• condizioni;
• input utente;
• modalità append;
• lettura riga per riga;
• gestione dell’errore per file mancante.

Molto forte.

Molto utile.

Progetto da principianti, ma già reale.

Una piccola app di note che ricorda le note.

Non male per niente.

Sfida extra: salvare contatti

Crea un file:

contacts_file.py

Costruisci un programma che:

• permette all’utente di aggiungere contatti;
• salva i contatti in contacts.txt;
• mostra tutti i contatti;
• ogni contatto ha nome, email e telefono.

Formato semplice del file:

Anna,anna@example.com,123456
Marco,marco@example.com,987654

Idea esempio:

FILE_NAME = "contacts.txt"

def add_contact():
    name = input("Name: ")
    email = input("Email: ")
    phone = input("Phone: ")

    with open(FILE_NAME, "a") as file:
        file.write(f"{name},{email},{phone}\n")

    print("Contact saved.")

def show_contacts():
    try:
        with open(FILE_NAME, "r") as file:
            print("Contacts:")

            for line in file:
                parts = line.strip().split(",")

                if len(parts) == 3:
                    name = parts[0]
                    email = parts[1]
                    phone = parts[2]

                    print("-----")
                    print(f"Name: {name}")
                    print(f"Email: {email}")
                    print(f"Phone: {phone}")
    except FileNotFoundError:
        print("No contacts yet.")

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":
        add_contact()
    elif choice == "2":
        show_contacts()
    elif choice == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

Questo programma salva dati strutturati in un semplice formato testuale.

Importante:

line.strip().split(",")

Questo prende una riga come:

Anna,anna@example.com,123456

e la trasforma in:

["Anna", "anna@example.com", "123456"]

Questa è un’idea molto utile.

Più avanti potrai imparare formati migliori come JSON.

Ma per ora i file di testo semplici bastano.

Un passo alla volta.

Non serve ancora evocare il drago JSON.

Checklist per principianti

Quando il codice con i file non funziona, controlla:

Ho usato with open()?
Ho scelto la modalità corretta?
Ho usato per sbaglio "w" invece di "a"?
Ho aggiunto "\n" per le nuove righe?
Il file esiste prima di leggerlo?
Dovrei gestire FileNotFoundError?
Ho usato strip() quando leggo righe?
Sto eseguendo Python dalla cartella corretta?
Ho scritto correttamente il nome del file?
Ho salvato il file dopo aver scritto il codice?

I bug con i file sono spesso semplici.

Ma fastidiosi.

Specialmente i problemi di percorso.

Se Python dice:

FileNotFoundError

non andare in panico.

Controlla:

nome del file
cartella
modalità
directory corrente

La maggior parte delle volte il file semplicemente non è dove Python lo sta cercando.

Python è severo.

Non cerca tutto il tuo computer emotivamente.

Cerca dove gli hai detto di cercare.

Molto letterale.

Molto Python.

Riassunto

Oggi hai imparato:

• le variabili sono temporanee;
• i file possono salvare dati dopo la fine del programma;
• open() apre file;
• with open() chiude automaticamente i file;
• "r" significa leggere;
• "w" significa scrivere e sovrascrivere;
• "a" significa aggiungere;
• write() scrive testo in un file;
• read() legge tutto il file;
• i cicli possono leggere file riga per riga;
• \n crea una nuova riga;
• .strip() rimuove spazi extra e nuove righe;
• FileNotFoundError succede quando leggi un file mancante;
• le liste possono essere salvate riga per riga;
• le liste possono essere caricate dai file;
• le funzioni possono organizzare la logica dei file;
• un task manager può ricordare i task usando un file.

Questo è un passo enorme.

I tuoi programmi ora possono ricordare le cose.

Possono salvare dati.

Possono caricare dati.

Possono diventare più utili.

Qui i piccoli script iniziano a sembrare applicazioni reali.

Un programma con memoria è molto più potente di un programma che dimentica tutto.

Anche se la memoria è solo un piccolo tasks.txt.

Piccolo file.

Grande upgrade.

Prossima lezione

Nella prossima lezione impareremo la gestione base degli errori.

I tuoi programmi impareranno a sopravvivere ai problemi in modo più elegante.

Per esempio:

l’utente inserisce testo invece di un numero
il file non esiste
divisione per zero
scelta menu sbagliata
dati mancanti

Invece di crashare in modo teatrale, il programma potrà rispondere con calma.

Molto utile.

Molto adulto.

Molto Python.

Perché gli utenti reali fanno cose strane.

E a volte l’utente reale sei tu.

Specialmente di notte.