Lære Håndtering af Store Filer | Forbedring af Ydeevne med Indbyggede Værktøjer

Effektiv behandling af store filer er afgørende, når der arbejdes med datasæt, der er for store til at kunne være i hukommelsen. Python tilbyder værktøjer som open() og map(), der gør det muligt at behandle filer "lazy", hvilket sparer hukommelse og forbedrer ydeevnen.

Hvad er iteratorer?

Før vi går videre med open()-funktionen, bør vi først forstå, hvad en iterator er. En iterator er et objekt, der repræsenterer en datastrøm og giver adgang til ét element ad gangen. Iteratorer implementerer to metoder:

__iter__(): returnerer selve iterator-objektet;
__next__(): returnerer det næste element i strømmen og udløser en StopIteration-undtagelse, når der ikke er flere elementer tilbage.

Antag, at vi har en iterator kaldet iterator_object. Vi kan iterere over den med en almindelig for-løkke:

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

Faktisk sker følgende i baggrunden (funktionen next() kalder internt iteratorens __next__()-metode):

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

I modsætning til standardkollektioner er iteratorer karakteriseret ved lazy evaluation, hvilket betyder, at de genererer eller henter data kun når det er nødvendigt, i stedet for at indlæse alt i hukommelsen på én gang. Denne tilgang gør dem meget hukommelseseffektive, især ved arbejde med store datasæt.

Filobjekter som iteratorer

Funktionen open() returnerer et filobjekt, som er en iterator. Dette gør det muligt at:

Iterere over en fil linje for linje med en for-løkke;
Læse én linje ad gangen ind i hukommelsen, hvilket gør det velegnet til store filer (så længe de enkelte linjer kan være i hukommelsen).

Hvis for eksempel en logfil med 1,000,000 linjer indeholder både INFO og ERROR-meddelelser, kan vi stadig tælle forekomster af ERROR ved at iterere gennem filen linje for linje, selvom filen ikke kan være helt i hukommelsen (hvilket vil være tilfældet, hvis vi tilføjer mange flere logs til den).


              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}")

Transformering af fil-linjer med map()

Som nævnt i det foregående kapitel returnerer map() en iterator, der anvender en transformeringsfunktion "lazy" på hver linje i en fil. Ligesom filobjekter behandler map() data én post ad gangen uden at indlæse alt i hukommelsen, hvilket gør det til en effektiv mulighed for håndtering af store filer.

For eksempel kan der oprettes en fil med 1000000 e-mailadresser, hvor nogle indeholder store bogstaver. Målet er at konvertere alle e-mails til små bogstaver og gemme de normaliserede resultater i en ny fil ('normalized_emails.txt'). Her anvendes map() for at sikre, at scriptet forbliver effektivt og egnet til behandling af endnu større filer.


              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. Du skal konvertere alle e-mailadresser i en fil til små bogstaver og gemme dem i en ny fil uden at indlæse alt i hukommelsen. Hvilken tilgang er mest effektiv?

2. Hvilket af følgende udsagn om filobjekter er korrekt?

Var alt klart?

Tak for dine kommentarer!

Sektion 3. Kapitel 2

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Suggested prompts:

Can you explain more about how map() works with file objects?

What are some other ways to process large files efficiently in Python?

Why is lazy evaluation important when working with big datasets?

Awesome!

Completion rate improved to 7.69

Stryg for at vise menuen