Discussion :

[sir_nebuchadnezzar]

Bonjour à tous !
J'ai déjà posté un mail avec mon problème sur un topic sur lequel je pensais trouver ma réponse, mais, en tant que très jeune novice sur python, je pense que peut être, certain aurait de l'inspiration face à mon problème.

Je m'explique...

Je dois écrire des lignes identifiables par un numéro unique à partir d'un fichier externe (source externe). Avant d'écrire une ligne (et le numéro unique correspondant), je recherche si la ligne du fichier txt n'a pas été écrite. Pour cela, j'ouvre mon fichier txt en mode read (r) et j'utilise readlines() pour lire toutes les lignes du fichier txt. Si la ligne (et le numéro unique n'existe pas, j'ouvre le fichier en mode écriture (a) et j'écris ma ligne.

Je peux réaliser ce travail sans problème, mais je dois traiter un très grand nombre de données si bien que au fur et à mesure de l'écriture, le temps d'écriture augmente de façon exponentiel !
Je pense (dites moi si je me trompe) que le fait d'ouvrir et de fermer mon fichier provoque la lenteur de mon script Python !

Ma question est donc de savoir s'il n'y a pas un mode d'ouverture qui me permette à la fois de lire et d'écriture (de façon simultané).


Une autre façon de faire (mais la je suis vraiment trop novice pour pouvoir le faire, même pour savoir si c'est possible) serait de creer des matrices dans lesquelles je stockerais mes lignes uniques avant de les écrire toutes ensembles.
Mais alors là, c'est vraiment le flou...

Bon voilà, si quelqu'un a des idées là dessus...

Merci d'avance...

Etienne

[dividee]

A mon avis ce qui prend du temps c'est surtout la lecture de tout le fichier, qui devient de plus en plus gros, à chaque fois.

Si je comprends bien, tout ce que tu as besoin de vérifier, c'est le numéro unique. Pourquoi ne pas les garder en mémoire au lieu de tout relire à chaque fois ?

[fred1599]

Tu peux essayer avec mmap par exemple

[sir_nebuchadnezzar]

merci pour vos réponses.

@dividee: oui je dois juste vérifier que le numéro en bien unique avant de l'écrire (lui et les infos associés). Donc en fait, pour éviter ma procédure, il suffit que je stocke ça dans une liste par exemple, c'est ça ? Et que j'utilise ensuite seek() ?

Bon il faudra que je regarde ça de plus près mais c'est vrai que ça a l'air pas mal comme ça. Mais est ce que ça résoudra mes problèmes de vitesse de script ? Ca c'est la question.

@fred1599: l'outil à l'air intéressant aussi, je vais creuser de ce côté aussi, ça a l'air d'être de la grosse patate ce truc !

Merci. Je vous tiens au courant.

Etienne

En fait ma question, c'est savoir ce qu'il se passe dans la mémoire tampon lorsqu'on ouvre un fichier txt à la fois en lecture et en écriture. Par curiosité, qui sait ?
Y a-t-il un mode "magique" pour que l'outil readlines() par exemple soit capable de prendre en compte les écritures sans pour autant passer par une fermeture du fichier.

[alexdevl]

Bonjour,
Voici un exemple pour illustrer la solution de dividee
J'ai supposé que le "nombre unique" est de la forme n1 n2...
A voir si cela t'inspire.

Salutations
Alex

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
34
35
36
37
 
fw=open("test.txt","w")
fw.write("n1 texte de la ligne 1\n")
fw.write("n2 texte de la ligne 2\n")
fw.write("n3 texte de la ligne 3\n")
fw.close()
 
class MajTxt:
    def __init__(self,nom_fichier):
        self.nom_fichier=nom_fichier
        self.maj_num_uniques()
 
    def aff_num_uniques(self):
        print ",".join(self.num_uniques)
 
    def ajoute_ligne(self,ligne):
        if ligne[0:2] not in self.num_uniques:
            fw=open(self.nom_fichier,"a")
            fw.write(ligne+"\n")
            fw.close()
            self.num_uniques.append(ligne[0:2])
 
    def maj_num_uniques(self):
        fr=open(self.nom_fichier,"r")
        self.num_uniques=[]
        for l in fr :
            self.num_uniques.append(l[0:2])
        self.num_uniques=list(set(self.num_uniques))
        fr.close()
 
t=MajTxt("test.txt")
t.aff_num_uniques() #n1,n2,n3
 
t.ajoute_ligne("n1 texte de la ligne 4")
t.aff_num_uniques() #n1,n2,n3
t.ajoute_ligne("n5 texte de la ligne 5")
t.aff_num_uniques() #n1,n2,n3,n5

[PauseKawa]

Bonjour,

Comme le dit dividee c'est les accès disque le plus long.
A partir de la os.path.getmtime(nom_fichier) donne la dernière modification. Il est donc possible de garder le fichier ouvert en écriture en mémoire (self.open_fic = open(nom_fichier, 'a')) et de ne le recharger (lecture) que s'il a été modifier.
Après chaque écriture on mets à jour une variable (self.wstats = os.path.getmtime(nom_fichier)).
Si os.path.getmtime(nom_fichier) == self.wstats c'est que rien n'as écrit dans le fichier entre temps donc .write() sans le relire et maj de self.wstats.
Sinon relecture (self.open_fic.close()) du fichier et maj self.wstats/self.num_uniques avant de repasser en append.

@+

Edit: Note : atexit au cas ou pour fermer le fichier en cas de souci ?