Discussion :

[le_voisin]

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

[kango]

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

[wiztricks]

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

[tyrtamos]

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

[le_voisin]

Bonjour,

voici mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[wiztricks]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[le_voisin]

Bonjour,

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


le_voisin

[tyrtamos]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[le_voisin]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[tyrtamos]

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

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

[kango]

bonjour,

peux tu essayer avec ceci ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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'

[wiztricks]

Bonsoir

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

[tyrtamos]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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:

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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[le_voisin]

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 ?

[tyrtamos]

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