Impara Gestione di File di Grandi Dimensioni | Ottimizzazione delle Prestazioni con Strumenti Integrati

Elaborare file di grandi dimensioni in modo efficiente è fondamentale quando si lavora con dataset troppo grandi per essere caricati interamente in memoria. Python mette a disposizione strumenti come open() e map(), che consentono di processare i file in modo lazy, risparmiando memoria e migliorando le prestazioni.

Cosa sono gli iteratori?

Prima di procedere con la funzione open(), è necessario comprendere cosa sia un iteratore. Un iteratore è un oggetto che rappresenta un flusso di dati, permettendo di accedere a un elemento alla volta. Gli iteratori implementano due metodi:

__iter__(): restituisce l'oggetto iteratore stesso;
__next__(): restituisce l'elemento successivo nel flusso e solleva un'eccezione StopIteration quando non ci sono più elementi.

Supponiamo di avere un iteratore chiamato iterator_object. È possibile iterare su di esso utilizzando un normale ciclo for:

for element in iterator_object:
    ...  # Process the element

In realtà, internamente, avviene quanto segue (la funzione next() richiama internamente il metodo __next__() dell'iteratore):

while True:
    try:
        element = next(iterator_object)
        ...  # Process the element
    except StopIteration:
        break

A differenza delle collezioni standard, gli iteratori sono caratterizzati da valutazione lazy, il che significa che generano o recuperano i dati solo quando necessario, invece di caricare tutto in memoria contemporaneamente. Questo approccio li rende estremamente efficienti dal punto di vista della memoria, in particolare quando si lavora con grandi dataset.

Oggetti file come iteratori

La funzione open() restituisce un oggetto file, che è un iteratore. Questo permette di:

Iterare su un file riga per riga utilizzando un ciclo for;
Leggere una riga alla volta in memoria, rendendo l'approccio adatto a file di grandi dimensioni (purché le singole righe possano essere caricate in memoria).

Ad esempio, se un file di log con 1,000,000 righe contiene sia messaggi INFO che ERROR, è comunque possibile contare le occorrenze di ERROR iterando nel file riga per riga, anche se il file non può essere caricato interamente in memoria (cosa che accadrebbe aggiungendo molti più log al file).


              1234567891011
            
log_lines = [f"INFO: Log entry {i}" if i % 100 != 0 else f"ERROR: Critical issue {i}" for i in range(1, 1000001)]
with open("large_log.txt", "w") as log_file:
    log_file.write("\n".join(log_lines))

# Process the file to count error entries
error_count = 0
for line in open("large_log.txt"):
    if "ERROR" in line:
        error_count += 1

print(f"Total error entries: {error_count}")

Trasformazione delle righe di file con map()

Come menzionato nel capitolo precedente, map() restituisce un iteratore, applicando una funzione di trasformazione in modo lazy a ciascuna riga di un file. Analogamente agli oggetti file, map() elabora i dati un elemento alla volta senza caricare tutto in memoria, risultando un'opzione efficiente per la gestione di file di grandi dimensioni.

Ad esempio, si può creare un file contenente 1000000 indirizzi email, alcuni dei quali includono lettere maiuscole. L'obiettivo è convertire tutte le email in minuscolo e salvare i risultati normalizzati in un nuovo file ('normalized_emails.txt'). Si utilizza map() per ottenere questo risultato, garantendo che lo script rimanga efficiente e adatto anche per l'elaborazione di file ancora più grandi.


              12345678910111213141516171819202122
            
# Create a file with mixed-case email addresses
email_lines = [
    "John.Doe@example.com",
    "Jane.SMITH@domain.org",
    "BOB.brown@anotherexample.net",
    "ALICE.williams@sample.com"
] * 250000  # Repeat to simulate a large file

with open("email_list.txt", "w") as email_file:
    email_file.write("\n".join(email_lines))

# Process the file to standardize email addresses (convert to lowercase)
with open("email_list.txt") as input_file, open("normalized_emails.txt", "w") as output_file:
    # Use map() to convert each email to lowercase
    lowercase_emails = map(str.lower, input_file)
    for email in lowercase_emails:
        output_file.write(email)
      
    # Print the last email to verify the results
    print(email)

print('Done')

1. È necessario convertire tutti gli indirizzi email in un file in minuscolo e salvarli in un nuovo file senza caricare tutto in memoria. Quale approccio è il più efficiente?

2. Quale delle seguenti affermazioni sugli oggetti file è corretta?

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 2

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Awesome!

Completion rate improved to 7.69

Scorri per mostrare il menu