Apprendre Gestion des Fichiers Volumineux | Amélioration des Performances avec les Outils Intégrés

Traiter efficacement de gros fichiers est essentiel lors de la manipulation de jeux de données trop volumineux pour tenir en mémoire. Python propose des outils tels que open() et map(), qui permettent de traiter les fichiers de manière paresseuse, économisant ainsi la mémoire et améliorant les performances.

Que sont les itérateurs ?

Avant d'aborder la fonction open(), il convient de comprendre ce qu'est un itérateur. Un itérateur est un objet qui représente un flux de données, permettant d'accéder à un élément à la fois. Les itérateurs implémentent deux méthodes :

__iter__() : retourne l'objet itérateur lui-même ;
__next__() : retourne l'élément suivant du flux et lève une exception StopIteration lorsqu'il n'y a plus d'éléments.

Supposons que nous ayons un itérateur nommé iterator_object. Nous pouvons itérer dessus à l'aide d'une boucle for classique :

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

En réalité, en arrière-plan, le processus suivant se produit (la fonction next() appelle en interne la méthode __next__() de l'itérateur) :

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

Contrairement aux collections standard, les itérateurs se caractérisent par une évaluation paresseuse, c'est-à-dire qu'ils génèrent ou récupèrent les données uniquement lorsque cela est nécessaire, au lieu de tout charger en mémoire d'un coup. Cette approche les rend très efficaces en termes de mémoire, en particulier lors du traitement de grands ensembles de données.

Objets fichiers comme itérateurs

La fonction open() retourne un objet fichier, qui est un itérateur. Cela permet de :

Parcourir un fichier ligne par ligne à l'aide d'une boucle for ;
Lire une ligne à la fois en mémoire, ce qui le rend adapté aux gros fichiers (tant que chaque ligne individuelle tient en mémoire).

Par exemple, si un fichier journal contenant 1,000,000 lignes inclut à la fois des messages INFO et ERROR, il est toujours possible de compter les occurrences de ERROR en parcourant le fichier ligne par ligne, même si le fichier ne peut pas tenir entièrement en mémoire (ce qui sera le cas si l'on y ajoute beaucoup plus de journaux).


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

Transformation des lignes de fichier avec map()

Comme mentionné dans le chapitre précédent, map() retourne un itérateur, appliquant une fonction de transformation de manière paresseuse à chaque ligne d’un fichier. À l’instar des objets fichier, map() traite les données un élément à la fois sans tout charger en mémoire, ce qui en fait une option efficace pour la gestion de fichiers volumineux.

Par exemple, créons un fichier contenant 1000000 adresses e-mail, dont certaines comportent des lettres majuscules. L’objectif est de convertir toutes les adresses e-mail en minuscules et d’enregistrer les résultats normalisés dans un nouveau fichier ('normalized_emails.txt'). Nous utiliserons map() pour cela, garantissant ainsi que le script reste efficace et adapté au traitement de fichiers encore plus volumineux.


              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. Vous devez convertir toutes les adresses e-mail d’un fichier en minuscules et les enregistrer dans un nouveau fichier sans tout charger en mémoire. Quelle approche est la plus efficace ?

2. Laquelle des affirmations suivantes concernant les objets fichier est correcte ?

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 2

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

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

Glissez pour afficher le menu