Come leggere un file riga per riga in Python

Python offre diversi modi per leggere i file riga per riga e, a prima vista, possono sembrare tutti intercambiabili. In pratica, però, la scelta influisce sull’uso di memoria, sulle prestazioni e perfino sulla leggibilità del codice. Alcuni approcci scalano bene su file grandi, mentre altri introducono problemi senza renderlo evidente.

In questo tutorial imparerai il modo consigliato per leggere un file riga per riga in Python e perché, di solito, dovrebbe essere la tua scelta predefinita. Vedremo anche alcune alternative, spiegheremo quando hanno senso e segnaleremo gli errori comuni in cui si inciampa spesso. Alla fine saprai leggere i file in modo sicuro ed efficiente, che tu stia scrivendo uno script veloce o qualcosa di più complesso.

Il modo consigliato per leggere un file riga per riga in Python

Se devi ricordare un solo schema da questo articolo, che sia questo. Nella maggior parte delle situazioni, iterare direttamente su un oggetto file è il modo più semplice, sicuro ed efficiente per leggere un file riga per riga, ed è l’approccio che vedrai più spesso nel codice Python reale.

A un livello di base, un oggetto file in Python è già un iteratore. Significa che puoi ciclare direttamente su di esso e ottenere una riga alla volta:

with open("example.txt", "r", encoding="utf-8") as file:
    for line in file:
        print(line)

Fa esattamente quello che sembra. Python apre il file e fornisce ogni riga una alla volta mentre il loop gira. Niente indicizzazione manuale, nessuna chiamata di funzione extra, nessuna complessità nascosta.

Uno dei maggiori vantaggi di questo approccio è l’efficienza in memoria. Python non carica l’intero file in memoria. Invece legge una singola riga, la elabora e passa alla successiva. Questo rende lo schema sicuro anche per file molto grandi, come log o esportazioni di dati grezzi.

È anche la soluzione più “pythonic”. Iterare direttamente su un oggetto file è chiaro, leggibile e immediatamente comprensibile a chiunque conosca Python. Questo conta man mano che gli script crescono o quando altre persone devono leggere il tuo codice in seguito.

Per questi motivi, questa dovrebbe essere la tua scelta predefinita a meno che tu non abbia una ragione molto specifica per fare altro. Gestisce automaticamente i file grandi, scala bene con l’aumentare delle dimensioni e evita sprechi di memoria, il tutto senza aggiungere complessità.

Gestire newline e spazi bianchi quando leggi righe in Python

Se ti è capitato di stampare righe da un file e notare righe vuote inaspettate o ti sei chiesto perché le stringhe non sembrano del tutto giuste, ti sei imbattuto nel comportamento dei newline in Python. È uno dei punti dolenti più comuni per chi inizia ed è utile capirlo presto. 

Quando Python legge un file riga per riga, ogni riga di solito termina con un carattere di newline (\n). Quel newline fa parte della riga stessa, non qualcosa che Python aggiunge dopo. 

Per esempio, un file che appare così:

apple
banana
cherry

viene in realtà letto come: 

apple\n, banana\n e cherry\n.

Questo comportamento preserva la struttura originale del file, cosa importante quando il formato conta. Ma quando stai elaborando testo—probabilmente confrontando valori, facendo parsing dei dati o ripulendo input—spesso vuoi rimuovere quello spazio bianco extra.

Pulire le righe per l’elaborazione

La soluzione più comune è rimuovere gli spazi bianchi prima di usare ogni riga:

with open("data.txt", encoding="utf-8") as file:
    for line in file:
        clean_line = line.strip()
        print(clean_line)

Il metodo strip() rimuove gli spazi bianchi iniziali e finali, inclusi spazi, tab e caratteri di newline. Di solito è quello che vuoi quando:

• Confronti le righe con valori attesi
• Converti stringhe in numeri
• Costruisci dati strutturati dai contenuti del file

Pattern comuni di spazi bianchi

A seconda del caso d’uso, metodi più mirati possono essere migliori:

• line.strip() rimuove gli spazi bianchi da entrambe le estremità

• line.rstrip() rimuove gli spazi bianchi a destra

• line.rstrip("\n") rimuove solo il carattere di newline

Per esempio, se l’indentazione conta ma i newline finali no:

clean_line = line.rstrip("\n")

Quando non rimuovere le righe

È altrettanto importante sapere quando non rimuovere gli spazi bianchi. Se lavori con:

• Testo preformattato
• File a larghezza fissa
• Log in cui la spaziatura è importante
• Markdown o snippet di codice

Rimuovere gli spazi bianchi può rompere la struttura dei dati. In questi casi, lavora con le righe grezze e gestisci il formato in modo intenzionale.

Una buona regola pratica: rimuovi gli spazi quando stai elaborando i contenuti; preserva lo spazio bianco quando il formato conta.

Come tenere traccia dei numeri di riga in Python

Una volta che leggi i file riga per riga, è comune voler sapere a che riga sei. È particolarmente utile per log, errori di validazione e debugging di file di input disordinati.

Python lo rende semplice con la funzione integrata enumerate():

with open("data.txt", encoding="utf-8") as file:
    for line_number, line in enumerate(file, start=1):
        print(line_number, line.strip())

Ecco cosa succede:

• Il file continua a fornire una riga alla volta

• enumerate() aggiunge un contatore accanto a ogni riga

• start=1 corrisponde a come contano gli esseri umani

Questo schema resta efficiente in memoria e funziona altrettanto bene con file grandi.

Quando i numeri di riga contano

Tenere traccia dei numeri di riga è particolarmente utile per:

• Log: identificare dove è avvenuto un evento
• Validazione: indicare esattamente dove compaiono dati errati
• Debugging: tracciare i fallimenti di parsing
• Feedback all’utente: puntare a una riga specifica in un file di input

Poiché enumerate() mantiene il codice pulito e leggibile, è quasi sempre meglio che gestire un contatore manuale.

Usare readline() per leggere una riga alla volta in Python

Python fornisce anche un’opzione più manuale: readline(). Non ti servirà spesso, ma capirla ti aiuta a riconoscere quando è appropriata.

Il metodo readline() legge una singola riga ogni volta che viene chiamato. Quando il file è terminato, restituisce una stringa vuota:

with open("example.txt", encoding="utf-8") as file:
    line = file.readline()
    while line:
        print(line.strip())
        line = file.readline()

Quando ha senso usare readline()

readline() è utile quando la lettura deve essere condizionale o molto controllata, ad esempio:

• Programmi interattivi
• Interrompere non appena una condizione è soddisfatta
• Mescolare la lettura del file con logica complessa

Per esempio:

with open("log.txt", encoding="utf-8") as file:
    while True:
        line = file.readline()
        if not line or "ERROR" in line:
            break
        print(line.strip())

Perché di solito non è meglio del loop predefinito

Nella maggior parte dei casi, questo resta migliore:

for line in file:
    process(line)

È più corto, più chiaro, altrettanto efficiente e più difficile da usare male. Considera readline() come uno strumento per casi particolari, non un sostituto del loop standard.

Perché readlines() è di solito una cattiva idea per file grandi

Il metodo readlines() legge l’intero file in memoria e restituisce una lista di righe:

with open("example.txt", encoding="utf-8") as file:
    lines = file.readlines()

Funziona per file piccoli, ma non scala.

Poiché l’intero file viene caricato in una volta sola:

• L’uso di memoria cresce con la dimensione del file
• I file grandi possono rallentare il programma o farlo crashare
• I problemi spesso emergono solo in produzione

Quando readlines() è accettabile

È ragionevole quando:

• Il file è garantito essere piccolo
• Hai davvero bisogno di tutte le righe in una volta
• La dimensione è prevedibile e limitata

Altrimenti, iterare riga per riga è quasi sempre la scelta migliore.

Errori comuni quando si leggono i file riga per riga

La maggior parte dei problemi nasce da poche piccole sviste:

• Dimenticarsi di chiudere i file → Usa with

• Caricare interi file involontariamente → Evita read() e readlines()

• Ignorare le codifiche → Specifica esplicitamente UTF-8

• Confondere modalità testo e binaria → Usa "r" per il testo, "rb" per il binario

Una volta che ne sei consapevole, è facile evitarli.

Best practice per leggere file riga per riga in Python

Prima di chiudere, ecco una checklist veloce per mantenere il codice pulito e affidabile:

• Usa per default l’oggetto file come iteratore
• Rimuovi spazi bianchi in modo intenzionale, non automatico
• Evita di caricare interi file a meno che non sia necessario
• Gestisci esplicitamente le codifiche quando lavori con testo

Queste abitudini scalano dagli script veloci alle pipeline di produzione.

Conclusione

Quando si tratta di leggere un file riga per riga in Python, c’è una scelta predefinita chiara: itera direttamente sull’oggetto file. È semplice, efficiente in memoria e abbastanza espressivo da gestire tutto, dai piccoli file di testo ai log enormi.

Il design di Python rende questo schema naturale. Non ti servono utility speciali o logiche complesse perché il linguaggio gestisce le parti difficili per te. La maggior parte dei problemi non deriva da Python, ma dal complicare eccessivamente un compito che ha già una soluzione pulita.

Resta sull’approccio basato su iteratori, gestisci con intenzione spazi bianchi e codifiche, e il tuo codice per la lettura dei file rimarrà leggibile e facile da ragionare.