lecture d'un fichier texte de 1Go

Bonjour,

j'ai un fichier de 1.5 Go à lire. Je ne peux pas l'ouvrir avec un logiciel classique (wordpad, bloc note etc...).
Donc je cherche un faire un script python qui le lit par morceaux et copie chaque morceau dans un nouveau fichier texte.
Donc en gros, je fais des readline en boucle pour avancer dadns le fichier, mais au bout d'un moment il m'affiche des MemoryError.
J'ai donc cherché des infos sur les garbage collector en pensant libérer de la memoire au fur et à mesure de l'avancée dans le fichier. Mais j'ai aps trouvé la solution.
Quelqu'un peut il m'aider ? Est ce un probleme de gestion de memoire ? Cette aspect gestion de memoire m'interesse beaucoup pour d'autres codes de calculs scientifiques.

merci d'avance !
le_voisin

bonsoir,

je me trompe peut être mais le seul fait de lire le fichier (aussi gros soit il) ne le charge pas intégralement en mémoire, seule une petite partie du fichier est mise dans un tampon. Le tampon sert uniquement à optimiser la lecture en espaçant les accès disques.

d'un autre côté, si tu stockes de ton côté l'information contenue dans le fichier, tu peux tout à fait dépasser la limite mémoire.

de ce fait, il vaut mieux faire un traitement en même temps que la lecture plutôt que charger toutes les données et les traiter ensuite.

bien entendu, tout dépend du traitement, tu seras peut être obligé d'utiliser un fichier pour stocker des résultats intermédiaires (dans un base de données par exemple si la donnée s'y prête).

difficile d'en dire plus sans avoir vu le code :)

par expérience, une fuite mémoire est souvent crée par une référence circulaire mal (ou pas du tout ?) détectée par le garbage collector.

la nature "typage dynamique" de python fait aussi qu'une liste de 100000 entiers occupera plus de mémoire qu'un tableau (numpy) du même nombre d'entiers.

l'instanciation multiple (plusieurs centaine de milliers) d'une classe, même simple, consomme aussi beaucoup de mémoire, l'utilisation des __slots__ peut alors être salvatrice :)

ensuite, il reste les possibilité d'interopérabilité avec du c, du c++ ou du fortran afin d'utiliser des langages à typage statique pour économiser un peu de mémoire.

vaste sujet :aie:

Bonsoir,

Je suis d'accord avec kango, le traitement des fichiers ne garde en mémoire qu'une petite quantité d'information et... il faudrait vraiment regarder le code de plus près pour voir ce qui empêche le garbage collector de libérer la mémoire.

Sauf si l'exercice est d'apprendre à programmer avec Python, plein (trop?) d'utilitaires font déjà cela. Google: split large files retourne une sélection de technobuzz

Bon courage
- W

Bonjour,

Il faut en dire plus sur ce que tu veux faire.

- Si tu veux simplement recopier un gros fichier texte à l'identique, il faut le faire en binaire et non avec readline. Et il vaut mieux utiliser le module shutil qui fait ça très bien. Je recopie avec ça des fichiers de 4Go sans pb.

- Si tu as un traitement "texte" à faire qui nécessite readline, il faut vérifier que ton code "relache" bien les chaines devenues inutiles, de sorte que la mémoire correspondante puisse être libérées par le ramasse-miette. Il y a un "compteur de référence" sur chaque objet python, et ces objets ne sont traités par le ramasse-miette que s'il est à zéro. Une programmation maladroite peut empêcher cela.

- Pour débugger ton code, tu peux utiliser le module gc qui est une interface avec le ramasse-miette de Python. Ce module permet d'examiner son fonctionnement, et même de déclencher le ramassage à un moment qui te convient (gc.collect()).

Si ça ne te suffit pas, essaye de donner une version simplifiée de ton code.

Tyrtamos

Bonjour,

voici mon code:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

count = 65000 starting_line = 130000   source_name = 'specimen.dat'   print 'source file: ', source_name   source = open(source_name,'r') destination = open(source_name+'_'+str(starting_line)+'.dat','w')   loop=0 while 1: line = source.readline() if line=="": break if (loop>starting_line): for i in range(count): destination.write(line) line = source.readline() break loop=loop+1   source.close destination.close   print 'done'

---

et voici le message d'erreur :

Code:

---

1 2 3 4

Traceback (most recent call last): File "fichier_division.py", line 23, in <module> line = source.readline() MemoryError

---

j'ai effectivement essaye d'utiliser le ramasse miette, mais j'ai pas bein compris le fonctionnement et j'ai trouvé assez d'infos la dessus. Donc je suis TRES preneur d'infos concernant cela et la gestionde memoire. Ca m'interesse vraiment beaucoup.

L'objectif du code est en fait de recopier une partie d'un fichier texte (*.dat) dans un autre fichier texte. la partie est defini par la variable "starting_line" et à partir de cette ligne je veux copier le nombre de ligne corresponda tà "count".

J'attend votre aide !!!
Merci

Salut,

Que se passe-t-il si vous n'écrivez pas? i.e. mettre en commentaire destination.write(line) et voir si ça vole mieux.
Si c'est le cas, aidez le GC avec la modification suivante.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

loop=0 while 1: line = source.readline() if line=="": break if (loop>starting_line): for i in range(count): destination.write(line) line = None #? est ce que ca aide GC? line = source.readline() break loop=loop+1   source.close destination.close   print 'done'

---

Pour le reste, il y aurait des tas de choses à dire sur votre code mais pour l'instant essayons de comprendre ce qui se passe.
- W

Bonjour,

j'ai déjà essayé de faire ça, mais j'ai exactement le même message d'erreur !


le_voisin

Bonjour,

Essaie d'insérer dans ta boucle le code suivant (après importation de gc):

Code:

---

1 2	if i % 10000 == 0: gc.collect()

---

i étant le compteur de boucle.

Tu peux l'insérer à 2 endroits: pendant l'attente (après loop += 1 et avec loop comme compteur de boucle) et pendant la boucle de lecture-écriture (après l'écriture).

C'est censé déclencher le ramasse-miette, mais je ne sais pas si ça marche.

Tyrtamos

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import gc   count = 400000 starting_line = 0   source_name = 'specimen.dat'   print 'source file: ', source_name   source = open(source_name,'r') destination = open(source_name+'_'+str(starting_line)+'.dat','w')   loop=0 while 1: line = source.readline() if loop % 10000 == 0: gc.collect() if line=="": break if (loop>starting_line): for i in range(count): destination.write(line) del(line) line = source.readline() if i % 10000 == 0: gc.collect() break loop=loop+1   source.close destination.close   print 'done'

---

ca ne marche toujours pas !!

quel etait l'objectif ? que signigie gc.collect() ?

le voisin

L'objectif était comme je l'ai dit:

Citation:

---

Envoyé par tyrtamos

C'est censé déclencher le ramasse-miette, mais je ne sais pas si ça marche.

---

Mais manifestement, ça ne marche pas...

Désolé, mais je ne trouve pas d'autres idées.

Tyrtamos

bonjour,

peux tu essayer avec ceci ?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

count = 65000 starting_line = 130000   source_name = 'specimen.dat'   print 'source file: ', source_name   source = open(source_name,'r') destination = open(source_name+'_'+str(starting_line)+'.dat','w')   loop=0 while 1: line = source.next() if line=="": break if (loop>starting_line): for i in xrange(count): destination.write(line) line = source.next() break loop=loop+1   source.close destination.close   print 'done'

---

Bonsoir

Citation:

---

Envoyé par le_voisin

Bonjour,
j'ai déjà essayé de faire ça, mais j'ai exactement le même message d'erreur !
le_voisin

---

Essayons d'être plus précis:
étape 1
- vous avez mis en commentaire "destination.write(line)"
- l'exécution donne le meme message d'erreur ====> cas A
- ou pas de message d'erreur gogo étape 2
étape 2
- on met line = None après le "write" => ca plante ===> cas B

ou cas C, vous avez sauté l'étape 1 et obtenez cas B.

- W

Bonjour,

Finalement je te propose une solution plutôt inhabituelle mais qui devrait marcher.

Dans ton code, tu lis ligne par ligne. Comme les lignes n'ont pas la même longueur, Python ne réutilise pas pour les nouvelles lectures les zones mémoires déjà utilisées. Elles devraient en principe être rendues à la mémoire disponible, mais on a vu que ça ne marche pas aussi bien que ça. Peut-être est-ce dû au fait que la mémoire disponible est suffisante, mais qu'elle est devenue trop morcelée pour être utilisable.

Alors, je te propose de chercher le début de ta copie (ligne starting_line) en lisant par buffer binaire et en comptant les fins de ligne. On peut voir en affichant id(buf) que buf prend toujours la même adresse mémoire. Voilà ce que ça donne:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

def debligne(nf, n, fdl='\n', tbuf=1024): """renvoie l'adresse du début de la ligne d'indice n""" if n == 0: return 0 # l'adresse de la ligne 0 est 0 f = open(nf, 'rb') c = 0 # compteur de fins de ligne fdl while True: buf = None buf = f.read(tbuf) # print id(buf) # pour vérifier que buf reprend la même adresse mémoire if len(buf)==0: # la ligne n n'a pas été trouvée avant la fin du fichier f.close() return -1 i = -1 # indice de caractères dans le buffer buf while True: i += 1 i = buf.find(fdl, i) # recherche du fin de ligne suivant à partir de i if i<0: # pas trouvé: il faut essayer avec le buffer suivant break else: # on a trouvé un nouveau caractère de fin de ligne c += 1 # on incrémente le compteur des fins de ligne if c == n: # on a trouvé! t = f.tell()-tbuf+i+1 f.close() return t

---

Cette fonction retourne le numéro d'octet dans le fichier sur disque qui est le début de la ligne n.

Voilà comment on utilise. Imaginons que j'ai fabriqué un fichier texte de 200000 lignes comme suit:

Code:

---

1 2 3 4 5 6 7

nf = 'specimen.dat' f = open(nf, 'w') for i in xrange(0,200000): x = "%d" % (i) f.write(x + '\n') f.close

---

Voilà comment je vais trouver à lire la ligne n=130000:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

n = 130000 t = debligne(nf, n) if t>=0: f = open(nf, 'r') f.seek(t) ch = f.readline().rstrip() print u"La ligne numéro", n , u"commence à l'octet", t, u"et contient: ", '"'+ch'"' f.close() else: print u'numéro de ligne trop grand'

---

Ce qui affichera:

Citation:

---

La ligne numéro 130000 commence à l'octet 928890 et contient: "130000"

---

On voit que la lecture de la ligne cherchée commence à l'octet numéro t grâce à f.seek(t). On peut, bien entendu, lire les lignes de texte suivantes par readline.

Si le numéro de la ligne cherchée est trop grand pour le fichier (par exemple ici si n=300000), la fonction renvoie -1.

Grâce à cette astuce, la lecture des 129999 premières lignes ne prendra en mémoire que la taille d'un seul buffer. On peut ensuite lire les 65000 lignes suivantes pour les copier avec des readline().

Si ça ne marche toujours pas, on peut aller plus loin en copiant les 65000 lignes de texte par buffer binaire. En effet, la fonction debligne() peut donner aussi l'adresse de la ligne 130000 + 65000. Il suffit donc de copier les octets par lecture/écriture binaire entre l'adresse de la ligne 130000 et l'adresse 130000+65000 par bloc. Si tu n'y arrives pas, dis-le!

Tyrtamos

Petit complément à mon message précédent: comment faire une copie partielle d'un fichier texte en utilisant des blocs binaires?

On définit une fonction de copie (copiebloc()) qui utilise comme argument la 1ère ligne à copier ainsi que la dernière (non inclue). On calcule le numéro de l'octet de la 1ère ligne et celui de la dernière avec la fonction précédente debligne(), et on copie par bloc tous les octets entre les 2 limites.

Voici le code:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

import os   def copiebloc(nf1, nf2, n1=0, n2=None, fdl='\n', tbuf=16384): """Copie tout ou partie d'un fichier texte par bloc binaire""" t1 = debligne(nf1, n1, fdl, tbuf) if n2==None: t2 = os.path.getsize() else: t2 = debligne(nf1, n2, fdl, tbuf) tt = t2-t1 f1 = open(nf1, 'rb') f1.seek(t1) # on met le curseur de lecture au début de la 1ère ligne à lire f2 = open(nf2, 'wb') while tt>0: buf = None buf = f1.read(tbuf) lbuf = len(buf) if lbuf>0: if lbuf>tt: buf = buf[:tt] lbuf = tt f2.write(buf) tt -= lbuf f2.flush() f1.close() f2.close()

---

A noter que si on ne précise pas les numéros de ligne à copier, c'est tout le fichier texte qui est copié par bloc.

Alors, la copie des 65000 lignes à partir de la ligne 130000 devient très simple, en plus d'être très rapide:

Code:

---

1 2 3 4 5 6 7 8

count = 65000 starting_line = 130000   source_name = 'specimen.dat' destination_name = source_name+'_'+str(starting_line)+'.dat'   copiebloc(source_name, destination_name, starting_line, starting_line+count)

---

Ok?

Tyrtamos

ok, j'ai (enfin un copain dans l'informatique) résolu le problème.
Le problème venait d'une ligne qui etait enorme !!!
Le probleme a été résolu avec une fonction split dans unix.
Merci à tous pour votre aide.
Où est ce que je peux trouver des infos sur la gestion de memoire dans python ?

Bonjour,

Dommage que tu n'aies pas considéré ma solution. Mais bon.

Au cas où ça en intéresserait d'autres, et pour la retrouver plus facilement, j'en ai fait un tuto: http://python.jpvweb.com/mesrecettes...partielle_bloc.

Et tant qu'à faire, j'ai fait aussi un petit code pour calculer le nombre de lignes d'un fichier texte sans lire toutes les lignes: http://python.jpvweb.com/mesrecettes...lignes_fichier.

La limite de ce genre de technique (lecture binaire d'un texte) est l'encodage unicode, si certaines parties de cet encodage peuvent être confondues avec la fin de ligne.

Tyrtamos