Eliminer des doublons dans un fichier

**fennec62** · 04/01/2009, 10h59

Salut

Voilà je logue en continu et je stock dans un fichier

Le logue chope 3 trames a chaque fois

Mais il ya souvent des lots de 3 trames identiques

j'aiemrais éliminer les trames identiques

voici un exemple

Code :

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

Comment enlever un groupe d' identique

J'arrive à le faire quand seulement il y a seulement 1 ligne avec un list et set

mais en groupant 3 lignes ?

Merci

**eyquem** · 04/01/2009, 12h55

Bonjour,

Qu'est ce que ça veut dire «je logue en continu» s'il te plait ? Tu emploies loguer au sens de "faire un relevé d'activité" ?

Je vois des séries de 3 nombres.
Chaque nombre est il toujours seul sur une ligne ?
Les nombres ne sont ils que des nombres à 2 chiffres ?
Le fichier est-il ouvert pour écrire une série de 3 nombres puis refermé avec close() , ou bien est-il ouvert en permanence ?
À quel moment veut tu éliminer les doublons ? Après l'activité de log ou pendant ? Ou éviter d'écrire une série qui se trouve déjà dans le fichier ?

En ayant un peu plus de ces renseignements, ce devrait être facile de résoudre ton problème.

**fennec62** · 04/01/2009, 18h12

Merci de ton aide

je log 150 lignes à la fois j'analyse les 150 lignes

si je trouve les trames qui me correspondent je le stock dans un fichier puis je le ferme une fois fermé j'aimerais enlever les doublons

les trames sont toujours par 2 ou 3 il y a de tout comme caracteres c'est des trames en hexa et de longueur différente

voici un exemple concret

on remarque qu'il y a plusieurs fois 2 trames identiques

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
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF

en faites mes trames reviennent j'aimerais juste stocker les différentes

Merci

**eyquem** · 04/01/2009, 20h03

Tu écris
«les trames sont toujours par 2 ou 3»
Veux tu dire: au moment où tu les captes et les inscris dans le fichier ?

Parce que je ne comprends pas s'il s'agit d'enlever des lignes identiques quelles que soient leurs positions dans le fichier et même si elles sont répétées plusieurs fois

ou s'il s'agit de les considérer par séries de 2 ou 3 groupées pour faire les comparaisons avant de faire l'élimination.

Dans le premier cas il suffit de faire ce qui suit, mais c'est tellement simple que je m'attends à ce que tu dises que c'est plus compliqué. Auquel cas, il faudra être plus précis.

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
38
39
40
41
42
43
ch = """
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF"""
 
li = ch.split()
print li
 
print '\n'
lo = []
for y in li:
    if y not in lo:
        lo.append(y)
print lo

Ce code marche bien s'il y a peu de lignes uniques, c'est à dire beaucoup de doublons, parce que la liste lo ne grandit pas vite et donc la condition if y not in lo peut être examinée rapidement par le programme.

Sinon, si les doublons sont rares, lo va grandir très rapidement et le programme va passer un temps fou à réexaminer sans cesse de façon exhaustive quasiment l'ensemble de la liste lo pour chaque nouvel élément y de li considéré. Dans ce cas, il faut un autre code avec une astuce pour éviter tous ce travail.

**fennec62** · 04/01/2009, 23h59

il faut absolument marcher par serie

je controle les trames 2 par 2 ou 3 par 3 toujours par couple

et le couple ne doit etre present qu'une seul fois

le fichier non ne va pas grandir il y aura au final qu'une 10ene de trame en tout

**eyquem** · 05/01/2009, 01h46

Mais le problème est alors:
comment reconnaît on les séries de 2 ou 3 dans un fichier de log?
C'est à dire:
pour une ligne donnée du fichier, comment reconnaît on qu'elle appartient
- à une série de 2 avec soit la précédente soit la suivante,
- ou à une série de 3 avec soit les deux précédentes, soit les deux suivantes, soit les deux de part et d'autre d'elle ?

Est-ce que dans un fichier donné, il n'y a soit que des séries de 2, soit que des séries de 3 ?
J'espère, parce que pour le moment je ne vois pas comment la succession des séries est connue.

Et je ne comprends pas ceci:
«je controle les trames 2 par 2 ou 3 par 3 toujours par couple»
Mais ça va sans doute s'éclairer avec ta réponse aux questions au dessus.

**fennec62** · 05/01/2009, 07h33

je pense qu'il faut passer par une autre liste

mon couple commence toujours par la 1er ligne + 2eme voir 3 eme

pour cela
a=[]
i=0
j=1

for ligne in liste
a.append((liste[i],liste[j]))
i=i+2
j=j+2

j'obtiens donc une liste ou j'ai groupé tout mes couples si je veux grouper par 3 je rajoute une variable et ajoute 3 au lieu de 2

Ma liste que j'obtiens je dois comparer chaque éléments pour qu'il soit unique

enfin un truc dans ce genre

**eyquem** · 05/01/2009, 10h47

Je ne pense pas qu'il y ait de difficulté particulière pour écrire un code qui fera ce que tu veux faire.
Le seul problème pour le moment, c'est que je ne comprends toujours pas ce que tu veux faire.

Quand je lis les phrases
«je controle les trames 2 par 2 ou 3 par 3 toujours par couple»
«mon couple commence toujours par la 1er ligne + 2eme voir 3 eme»,
mon esprit logique est en effet perturbé de lire qu'il est question de couple pouvant avoir 3 éléments.
De plus, lire «MON couple commence...» qui donne l'impression que tu as déjà parlé d'un couple, alors que tu n'as pas défini ce que tu appelles couple et pourquoi il doit être question de couple, ça me perturbe aussi.

Mais bon, d'après le bout de code que tu as donné, il semble que tu envisages de prendre les lignes par groupes successifs de 2 lignes, constituant ainsi une liste d'éléments qui seront des couples en effet et de comparer ces couples,
mais aussi de pouvoir prendre les lignes par groupes successifs de 3 lignes, constituant ainsi une liste d'éléments qui seront des triplets et de comparer ces triplets....

...et pourquoi pas de grouper les lignes par 4, constituant ainsi une liste de quadruplets etc...

En fait, il semble que tu veuilles créer une liste de tuples et comparer ces tuples 2 par 2. Je ne vois pas comment on compare des choses 3 par 3 («je controle les trames 2 par 2 ou 3 par 3»)

Bref. Ceci étant, je te propose le code suivant pour un traitement du fichier par couples de lignes. Pour un traitement par triplet ou autre tuple, ce peut être facilement adapté.
Si ce code te va, on pourra le modifier aussi pour faire un peu différemment.

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
a = []
f = open('fifi','r')
while 1:
    rd1 = f.readline()
    if not rd1:
        break
    else:
        rd2 = f.readline()
        if not rd2:
            print "Il y a un problème: les lignes ne sont pas en nombre pair."
            print "La dernière ligne n'est pas prise en compte dans la liste constituée."
        else:
            a.append((rd1[:-1],rd2[:-1]))
f.close()
 
 
b = []
for couple in a:
    if couple not in b:
        b.append(couple)
 
for x,y in b:
    print x,'\n',y,'\n'

Avec le fichier que tu as donné:

CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF
CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF

le résultat est:

>>>
CAF00001229E200F2220C20038120430F00006A0241340080508300C0842C5B3910C8C02098B86
CA1801011dA9113A213A4320000000000000000000000000F0088311D313DD595FEF

CAF00001229E202FA528C25F689E1D100B9784303643A868153FF8AC9FF8CFF37F7E04D2C17FEC
CA18010120A9143A213A4302000000000000000000000000000000F0082F861C538897ECD8

>>>

**eyquem** · 05/01/2009, 15h56

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
f = open('fifi','r')
li = f.read().splitlines()
f.close()
 
b = []
if len(li)%2:
    print "Il y a un problème: les lignes du fichier ne sont pas en nombre pair."
else:
    [ b.append((li[k],li[k+1])) for k in xrange(0,len(li),2) if (li[k],li[k+1]) not in b ]
 
for x,y in b:
    print x,'\n',y,'\n'
 
print '---------------'
 
f = open('fifi','r')
li = f.read().splitlines()
f.close()
 
b = []
if len(li)%2:
    print "Il y a un problème: les lignes du fichier ne sont pas en nombre pair."
else:
    [ b.append(u) for u in zip(li[0::2],li[1::2]) if u not in b ]
 
for x,y in b:
    print x,'\n',y,'\n'
 
print '---------------'
 
f = open('fifi','r')
if len(f.readlines())%2:
    print "Il y a un problème: les lignes du fichier ne sont pas en nombre pair."
else:
    f.seek(0)
    ch,x = f.readline()+f.readline(),1
    while x:
        x = f.readline()+f.readline()
        if x not in ch:  ch+=x  
    f.close()
 
    b = ch.splitlines()
    for u in b:
        print u
f.close()
 
print '---------------'
 
f = open('fifi','r')
li = f.readlines()
if len(li)%2:
    print "Il y a un problème: les lignes du fichier ne sont pas en nombre pair."
else:
    liter = li.__iter__( )
    ch = liter.next() + liter.next()
    while 1:
        try:
            x = liter.next() + liter.next()
            if x not in ch:  ch+=x
        except:
            break
 
    b = ch.splitlines()
    for u in b:
        print u
f.close()

Il faut améliorer le test des lignes: pas seulement tester si elles sont en nombre pair mais aussi si elles ne sont pas remplies uniquement de blancs.

Rappel:
readlines() est une méthode de fichier
tandis que splitlines() est une méthode de chaine qui fournit une liste des lignes contenues dans une chaine, sans garder les retour de lignes '\n'
splitlines(True) fait la même chose mais avec les '\n' en bout de lignes.

**eyquem** · 06/01/2009, 16h23

J'ai amélioré le 3ième code de mon message précédent:
- enlevé le f.readlines() au début qui était destiné à pouvoir compter les nombre de lignes
- séparation des 2 lectures f.readline() pour pouvoir introduire un test sur chaque ligne
- arrèt du programme si une ligne vide est rencontrée
- les lignes non répétées sont conservées dans une chaine ch et non pas une liste.
Ça évite le déploiement de liste
b=[]
[b.extend(u) for u in li]
à la fin qui est long à faire comme le montre les tests de vitesse qui suivent.

Par contre si on utilise ch en gardant une liste auxiliaire pour déterminer si des lignes ont déjà été rencontrées (2ième code), cela va légèrement plus vite.

Avec les codes 1 et 2, le fichier 'fifi' peut se terminer soit par '\n' soit sans ces caractères, le résultat n'en est pas affecté.
Par contre avec le code 3 , si absence de '\n' à la fin du fichier aloirs dernier test [x,y] not in li est toujours False.

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
from timeit import Timer
 
def f():
    # code 1
    f = open('fifi','r')
    ch,x = '',f.readline()
    while x:
        y = f.readline()
        if x=='\n' or y=='\n':
            print "Exécution stoppée: le fichier contient une ligne vide"
            break
        if not y:
            print "Il y a un problème: les lignes du fichier ne sont pas en nombre pair."
        if x+y not in ch:
            ch+=x+y
        x = f.readline()
    f.close()
    b = ch.splitlines()
    return b
 
def g():
    # code 2
    f = open('fifi','r')
    ch,li,x = '',[],f.readline()
    while x:
        y = f.readline()
        if x=='\n' or y=='\n':
            print "Exécution stoppée: le fichier contient une ligne vide"
            break
        if not y:
            print "Il y a un problème: les lignes du fichier ne sont pas en nombre pair."
        if x+y not in li:
            ch+=x+y
            li.append(x+y)
        x = f.readline()
    f.close()
    b = ch.splitlines()
    return b
 
def h():
    # code 3
    f = open('fifi','r')
    li,x = [],f.readline()
    while x:
        y = f.readline()
        if x=='\n' or y=='\n':
            print "Exécution stoppée: le fichier contient une ligne vide"
            break
        if not y:
            print "Il y a un problème: les lignes du fichier ne sont pas en nombre pair."
        if not y.endswith('\n'):
            y = y + '\n'
        if [x,y] not in li:
            li.append([x,y])
        x = f.readline()
    f.close()
    b=[]
    [b.extend(u) for u in li]
    return b
 
 
 
 
iterations = 1000
tf = Timer('f()','from __main__ import f').timeit(iterations)
tg = Timer('g()','from __main__ import g').timeit(iterations)
th = Timer('h()','from __main__ import h').timeit(iterations)
 
print "timeit unique d'execution de f :",tf
print "timeit unique d'execution de g :",tg
print "timeit unique d'execution de h :",th
 
 
repet = 8
litf = Timer('f()','from __main__ import f').repeat(repet,iterations)
litg = Timer('g()','from __main__ import g').repeat(repet,iterations)
lith = Timer('h()','from __main__ import h').repeat(repet,iterations)
 
print "\n\ntemps d'execution de f"
s = 0
for y in litf:
    print y
    s = s+y
print "temps moyen d'execution de f : ",s/repet
 
 
print "\n\ntemps d'execution de g"
s = 0
for y in litg:
    print y
    s = s+y
print "temps moyen d'execution de g : ",s/repet
 
 
 
print "\n\ntemps d'execution de h"
s = 0
for y in lith:
    print y
    s = s+y
print "temps moyen d'execution de h : ",s/repet

>>>
timeit unique d'execution de f : 2.31940986913
timeit unique d'execution de g : 2.18783392861
timeit unique d'execution de h : 2.5832285947

temps d'execution de f
2.4062415754
2.22227042822
2.40653015956
2.22427682848
2.40518278161
2.21995141841
2.40410275608
2.24749709809
temps moyen d'execution de f : 2.31700663073

temps d'execution de g
2.13564014421
2.16847644044
1.98872314777
2.16628621794
1.988370589
2.13453888693
2.01357602712
1.98088891186
temps moyen d'execution de g : 2.07206254566

temps d'execution de h
2.73539961084
2.74592804393
2.74532154226
2.56029467432
2.76729724029
2.56616581158
2.74215354186
2.55545579117
temps moyen d'execution de h : 2.67725203203
>>>

**fennec62** · 06/01/2009, 18h25

Et bien merci

je test tout cela

Chapo !

**eyquem** · 06/01/2009, 23h27

Merci. Mais je ne sais toujours pas si ces codes répondent véritablement à ce que tu cherches à faire.

----------------

Je suis intrigué par une chose:
pourquoi veux tu comparer les lignes groupées en séries de 2, ou 3, ou etc ?
Si par exemple ton fichier de log est:

CA12345
CAetfyy
DE000
GH766
SS77777777
PPrteeeeee
DE000
GH766
WY109uu
CAetfyy
DE000
GH766

ton algorithme, ou du moins ce que j'en ai compris et qui se trouve dans mes codes, va garder le 5ième groupe de 2 lignes (WY109uu et CAetfyy) alors que la 10ième ligne CAetfyy est identique à la 2ième ligne.
La liste obtenue va donc comporter 2 fois cette ligne:
['CA12345', 'CAetfyy', 'DE000', 'GH766', 'SS77777777', 'PPrteeeeee', 'WY109uu', 'CAetfyy']
Est-ce bien ce que tu veux obtenir ? Quel intérêt de garder 2 fois des lignes ?

------------------------------------

D'autre part, je me suis aperçu avoir écrit quelque chose d'inexact.

Le test if x+y not in li: se trouve aussi bien dans le code 2 que dans le code 3.
Or si le fichier lu ne se termine pas par '\n', la dernière valeur de x+y à être examinée ne se terminera pas par '\n'. Donc cette denière valeur de x+y ne sera certainement pas déjà présente dans la liste li et le test x+y not in li: sera toujours True, ce qui fera que le dernier groupe de 2 lignes sera toujours additionné à la liste li par le code 2, alors que le contenu "hors \n" de ces lignes pourra y être déjà,
aussi bien avec le code 2 qu'avec le code 3.
Comme dans l'exemple suivant:

Avec un fichier 'fifi' contenant :
'CA12345\nCAetfyy\nDE000\nGH766\nSS77777777\nPPrteeeeee\nDE000\nGH766\nWY109uu\nCAetfyy\nDE000\nGH766'

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
38
39
# code 1
f = open('fifi','r')
ch,x = '',f.readline()
while x:
    y = f.readline()
    if x=='\n' or y=='\n':
        print "Exécution stoppée: le fichier contient une ligne vide"
        break
    if not y:
        print "Il y a un problème: les lignes du fichier ne sont pas en nombre pair."
    if x+y not in ch:
        ch+=x+y
    x = f.readline()
f.close()
b = ch.splitlines()
print 'Code 1 retient :\n'
for u in b:
    print u
 
print 
# code 2
f = open('fifi','r')
ch,li,x = '',[],f.readline()
while x:
    y = f.readline()
    if x=='\n' or y=='\n':
        print "Exécution stoppée: le fichier contient une ligne vide"
        break
    if not y:
        print "Il y a un problème: les lignes du fichier ne sont pas en nombre pair."
    if x+y not in li:
        ch+=x+y
        li.append(x+y)
    x = f.readline()
f.close()
b = ch.splitlines()
print 'Code 2 retient :\n'
for u in b:
    print u

donne

>>>
Code 1 retient :

CA12345
CAetfyy
DE000
GH766
SS77777777
PPrteeeeee
WY109uu
CAetfyy

Code 2 retient :

CA12345
CAetfyy
DE000
GH766
SS77777777
PPrteeeeee
WY109uu
CAetfyy
DE000
GH766
>>>

----------------

Je me suis aussi aperçu du problème suivant dans le cas où le fichier 'fifi' ne se termine pas par '\n':
si la dernière ligne est un raccourci d'une ligne précédente, elle ne sera pas enregistrée par le code 1 qui teste x+y in ch: , alors qu'elle devrait l'être.
Exemple:

Avec un fichier 'fifi' contenant :
'CA12345\nCAetfyy\nDE000\nGH766\nSS77777777\nPPrteeeeee\nDE000\nGH766\nWY109uu\nCAetfyy\nDE000\nGH7'

les mêmes deux codes 1 et 2 donnent:

>>>
Code 1 retient :

CA12345
CAetfyy
DE000
GH766
SS77777777
PPrteeeeee
WY109uu
CAetfyy

Code 2 retient :

CA12345
CAetfyy
DE000
GH766
SS77777777
PPrteeeeee
WY109uu
CAetfyy
DE000
GH7
>>>

===
Donc, si le fichier 'fifi' ne se termine pas par '\n', les 3 codes peuvent produire une erreur dans certains cas.
Pour éviter cette éventualité, il faut rajouter une vérification. Je préfère la mettre en préalable.

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
from os import path
 
tay = path.getsize('fifi')
print '\ntaille du fichier avant la vérification de sa fin =',tay
f = open('fifi','r+')
f.seek(tay-2)
rd = f.read()
if rd!='\n':
    f.seek(tay)
    f.write('\n')
    #f.flush()
    #fsync(f.fileno())
f.close()
print 'taille du fichier après la vérification =',path.getsize('fifi')
 
print 
# code 2
f = open('fifi','r')
ch,li,x = '',[],f.readline()
while x:
    y = f.readline()
    if x=='\n' or y=='\n':
        print "Exécution stoppée: le fichier contient une ligne vide"
        break
    if not y:
        print "Il y a un problème: les lignes du fichier ne sont pas en nombre pair."
    if x+y not in li:
        ch+=x+y
        li.append(x+y)
    x = f.readline()
f.close()
b = ch.splitlines()
print 'Code 2 retient :\n'
for u in b:
    print u

Pour bien voir que ça marche:
faire tourner deux fois le code 2 sur un fichier contenant

'CA12345\nCAetfyy\nDE000\nGH766\nSS77777777\nPPrteeeeee\nDE000\nGH766\nWY109uu\nCAetfyy\nDE000\nGH7'

une fois avant, une fois après la partie de code

Code :

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

1
2
3
4
5
6
7
tay = path.getsize('fifi')
print '\ntaille du fichier avant la vérification de sa fin =',tay
f = open('fifi','r+')
f.seek(tay-2)
...etc...
f.close()
print 'taille du fichier après la vérification =',path.getsize('fifi')

Le resultat est

>>>
Code 2 retient :

CA12345
CAetfyy
DE000
GH766
SS77777777
PPrteeeeee
WY109uu
CAetfyy
DE000
GH766

taille du fichier avant la vérification de sa fin = 100
taille du fichier après la vérification = 102

Code 2 retient :

CA12345
CAetfyy
DE000
GH766
SS77777777
PPrteeeeee
WY109uu
CAetfyy
>>>

Les instructions

Code :

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

1
2
#f.flush()
#fsync(f.fileno())

forcent l'écriture effective de ce qui vient d'être commandé par l'instruction f.write('\n'). Normalement ces instructions ne sont pas nécessaires car la fermeture du fichier qui suit force le vidage du buffer. Mais je les indique en commentaires au cas où...

**eyquem** · 07/01/2009, 18h35

À partir des 2 derniers codes du messages #9 je me suis obstiné à considérer plus astucieux de concaténer les lignes à garder pour pouvoir écrire b = ch.splitlines() à la fin et éviter de créer une liste au départ.
C'est en fait idiot car ça entraine la complication due à cette histoire de fin de fichier égal à '\n' ou non.

Pour s'affranchir de ce problème, et vu que la taille de fichier traité n'est pas importante, il faut évidemment commencer par li = f.read().splitlines() comme je l'ai fait dans les 2 premiers codes du messages #9.
L'utilisation de zip dans le second code est encore superflue.
Quant à la répétition de couples avec des indices dans le premier, cela ne me plaisait pas. J'ai erré comme un idiot dans les docs à la recherche d'une méthode pour lire une liste par groupes de deux items à la fois alors qu'il suffit de faire du slicing !

En ne cherchant pas à y écrire absolument une list comprehension, ce premier code du message #9 devient alors aussi simple que voici et ce n'est pas la peine d'aller chercher midi à 14 heures.

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
f = open('fifi','r')
li = f.read().splitlines()
f.close()
 
if '' in li:
    print "Exécution stoppée: le fichier contient une ligne vide avant sa fin."
elif len(li)%2:
    print "Exécution stoppée: le fichier contient un nombre impair de lignes."
else:
    litri = []
    for n in xrange(0,len(li),2):
        x = li[n:n+2]
        if x not in litri:  litri.append(x)
    print 'Couples de lignes retenus:'
    for c in litri:  print c

**fennec62** · 11/01/2009, 11h40

Merci beaucoup

Je suis sure que le log a toujours une série de 2 lignes car c moi qui le cree a partir d'un autre log

Eliminer des doublons dans un fichier

Python

Discussions similaires

Partager

Partager