Comment lire des fichiers volumineux en utilisant Python

Cet article présente principalement comment utiliser Python pour lire des fichiers volumineux. Les amis qui en ont besoin peuvent s'y référer

Contexte

Récemment. Lors du traitement d'un document texte (le fichier fait environ 2 Go), une erreur de mémoire et une lecture trop lente du fichier se sont produites. Plus tard, j'ai trouvé deux méthodes de lecture de fichiers volumineux plus rapides. Cet article présentera ces deux méthodes de lecture.

Préparation

Quand on parle de "traitement de texte", on entend généralement ce qui est en cours de traitement. Python facilite la lecture du contenu d'un fichier texte dans une variable chaîne pouvant être manipulée. Les objets fichier fournissent trois méthodes de « lecture » : .read(), .readline() et .readlines(). Chaque méthode peut accepter une variable pour limiter la quantité de données lues à chaque fois, mais elle n'utilise généralement pas de variables. .read() lit le fichier entier à la fois, il est généralement utilisé pour placer le contenu du fichier dans une variable chaîne. Cependant, .read() génère la représentation sous forme de chaîne la plus directe du contenu du fichier, mais cela n'est pas nécessaire pour un traitement continu orienté ligne, et un tel traitement n'est pas possible si le fichier est plus volumineux que la mémoire disponible. Voici un exemple de la méthode read() :

try:
f = open('/path/to/file', 'r')
print f.read()
finally:
if f:
f.close()

L'appel de read() lira tout le contenu du fichier en une seule fois. Le fichier fait 10 Go, la mémoire sera éclatée, donc pour être sûr, vous pouvez appeler la méthode read(size) à plusieurs reprises et lire jusqu'à la taille des octets à chaque fois. De plus, appeler readline() peut lire une ligne de contenu à la fois, et appeler readlines() peut lire tout le contenu en même temps et renvoyer la liste ligne par ligne. Par conséquent, vous devez décider comment l'appeler en fonction de vos besoins.

Si le fichier est très petit, il est plus pratique de le lire une fois avec read(); si la taille du fichier ne peut pas être déterminée, il est plus sûr d'appeler read(size) à plusieurs reprises ; un fichier de configuration, il est plus pratique d'appeler readlines() :

for line in f.readlines():
process(line) #

　

Lecture bloquée

Il est facile de penser au traitement de gros fichiers en divisant le gros fichier en plusieurs petits fichiers pour le traitement, et en libérant cette partie de la mémoire après avoir traité chaque petit fichier. Iter et rendement sont utilisés ici :

def read_in_chunks(filePath, chunk_size=1024*1024):
"""
Lazy function (generator) to read a file piece by piece.
Default chunk size: 1M
You can set your own chunk size
"""
file_object = open(filePath)
while True:
chunk_data = file_object.read(chunk_size)
if not chunk_data:
break
yield chunk_data
if __name__ == "__main__":
filePath = './path/filename'
for chunk in read_in_chunks(filePath):
process(chunk) # <do something with chunk>

Utiliser avec open()

with ouvre et ferme le fichier, y compris en lançant une exception de bloc interne. pour la ligne dans f, l'objet fichier f est traité comme un itérateur et utilise automatiquement la gestion des E/S et de la mémoire tampon, vous n'avez donc pas à vous soucier des fichiers volumineux.

Le code est le suivant :

#If the file is line based
with open(...) as f:
　　for line in f:
　　　　process(line) # <do something with line>

Optimiser

face Il n'y a aucun problème à utiliser open pour des données volumineuses avec des millions de lignes, mais les différents paramètres conduiront également à des efficacités différentes. Après test, l'efficacité lorsque le premier paramètre est « rb » est 6 fois supérieure à celle de « r ». On constate que la lecture binaire reste le mode le plus rapide.

with open(filename,"rb") as f: 
  for fLine in f: 
  　　pass

Résultats des tests : la méthode rb est la plus rapide, parcourant 1 million de lignes en 2,9 secondes. Il peut essentiellement répondre aux besoins d’efficacité du traitement des fichiers de taille moyenne et grande. Si la lecture de rb (lecture du système secondaire) est modifiée en r (mode de lecture), elle sera 5 à 6 fois plus lente.

Conclusion

Lorsque vous utilisez Python pour lire des fichiers volumineux, vous devez laisser le système le gérer, de la manière la plus simple, Laisser à l'interprète et occupez-vous simplement de votre propre travail. Dans le même temps, différents paramètres de lecture peuvent être sélectionnés en fonction de différents besoins pour obtenir des performances plus élevées.

Recommandations associées :

Explication détaillée de la façon dont Python lit les données texte et les convertit au format DataFrame

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!