Aprenda Manipulação de Arquivos Grandes | Aperfeiçoando o Desempenho com Ferramentas Integradas

Processamento eficiente de arquivos grandes é essencial ao trabalhar com conjuntos de dados grandes demais para caber na memória. O Python oferece ferramentas como open() e map(), que permitem processar arquivos de forma preguiçosa, economizando memória e melhorando o desempenho.

O que são Iteradores?

Antes de prosseguir com a função open(), é importante compreender o que é um iterador. Um iterador é um objeto que representa um fluxo de dados, permitindo acessar um item por vez. Iteradores implementam dois métodos:

__iter__(): retorna o próprio objeto iterador;
__next__(): retorna o próximo item do fluxo e lança uma exceção StopIteration quando não há mais itens.

Suponha que exista um iterador chamado iterator_object. É possível iterar sobre ele utilizando um laço for comum:

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

Na verdade, internamente, ocorre o seguinte (a função next() chama internamente o método __next__() do iterador):

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

Diferente das coleções padrão, iteradores são caracterizados por avaliação preguiçosa, ou seja, eles geram ou buscam dados apenas quando necessário, em vez de carregar tudo na memória de uma vez. Essa abordagem os torna altamente eficientes em termos de memória, especialmente ao lidar com grandes conjuntos de dados.

Objetos de Arquivo como Iteradores

A função open() retorna um objeto de arquivo, que é um iterador. Isso permite:

Iterar sobre um arquivo linha por linha usando um laço for;
Ler uma linha por vez na memória, tornando-o adequado para arquivos grandes (desde que as linhas individuais caibam na memória).

Por exemplo, se um arquivo de log com 1,000,000 linhas inclui mensagens INFO e ERROR, ainda é possível contar ocorrências de ERROR iterando pelo arquivo linha por linha, mesmo que o arquivo não caiba inteiro na memória (o que ocorrerá se adicionarmos muito mais logs a ele).


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

Transformando Linhas de Arquivo com map()

Como mencionado no capítulo anterior, map() retorna um iterador, aplicando uma função de transformação de forma preguiçosa a cada linha de um arquivo. Semelhante aos objetos de arquivo, map() processa os dados um item por vez sem carregar tudo na memória, tornando-se uma opção eficiente para manipulação de arquivos grandes.

Por exemplo, considere a criação de um arquivo contendo 1000000 endereços de e-mail, alguns dos quais incluem letras maiúsculas. O objetivo é converter todos os e-mails para minúsculas e salvar os resultados normalizados em um novo arquivo ('normalized_emails.txt'). Utilizaremos map() para alcançar esse objetivo, garantindo que o script permaneça eficiente e adequado para processar arquivos ainda maiores.


              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. É necessário converter todos os endereços de e-mail em um arquivo para letras minúsculas e salvá-los em um novo arquivo sem carregar tudo na memória. Qual abordagem é mais eficiente?

2. Qual das seguintes afirmações sobre objetos de arquivo está correta?

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 2

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Awesome!

Completion rate improved to 7.69

Deslize para mostrar o menu