Discussion :

[Antwan76ers]

Bonjour,
Je vais tenter d'expliciter mon problème clairement.
J'élabore un script qui dans une boucle me fournis une liste.
Cette liste à un nombre variable d'éléments mais certains points sont constant; le premier est toujours un identifiant, les autres éléments sont de 5 types;
Soit un caractère suivis d'un espace et d'un nombre (ex: A 12) soit 2 caractères/espace/nombre (AP 45) ...soit 5 caractères/espace/nombre
(ex: APLKS 4)
Parfois dans la liste je vais avoir 2 éléments à un seul caractère, parfois j'en aurais aucun à un caractère mais un/plusieurs à 2 (ou plus) caractères.
Ce que je veux c'est que mon ensemble de liste issue de la boucle et écrite dans un fichier ai le même nombre d'éléments; le premier pour l'ID, le second pour le ou les éléments à un caractère le 5eme pour le ou les éléments à 5 caractères.
J'ai donc tenté dans tout les sens des boucles avec "liste[i].startswith("\w\w\s")

Ou bien faire 5 motifs de ce type; motif1="(\w\s{1}\\1{1,})"
motif2="(\w...

et boucler avec re.search(motif1;liste[i]) mais rien n'y fait;j'ai tester les motifs avec ce que je connaissais; les "." les "\w" les "\s" je n'ai pas réussi à obtenir ce que je veux, soit tout les éléments match avec le motif1 soit aucun ne match.

Voilà je débute, donc je pense qu'il s'agit juste d'un soucis de syntaxe dans mes motifs mais je n'y arrive vraiment pas donc si quelqu'un à une piste pour me débloquer sa serait bien aimable.

Merci à vous et si vous avez besoins de précisions n'hésitez pas!

[eyquem]

Hello, bienvenue sur le forum Python,



Ça commence bien et malheureusement je ne comprends plus a partir de

Ce que je veux c'est que mon ensemble de liste issue de la boucle et écrite dans un fichier ai le même nombre d'éléments; le premier pour l'ID, le second pour le ou les éléments à un caractère le 5eme pour le ou les éléments à 5 caractères.

Jusqu’à cet endroit, je pensais qu’il n’y avait qu’une seule liste, produite par plusieurs tours d’une boucle exécutée une seule fois (utilisation de append ou extend à chaque tour, boucle = série de plusieurs append ou extend)



Y a-t-il en fait plusieurs listes ?

Soit produites par plusieurs exécutions de la même boucle (répétitions de séries de plusieurs append ou extend),

soit chaque liste produite par un seul tour (procédé à préciser) ?





Pour moi, «un ensemble doit avoir le même nombre» ne signifie rien. Ce doit être suivi de «que» et d’un deuxième terme qui précise avec quel autre ensemble est comparé le premier.







startswith() est une méthode de chaîne, pas de liste



les fonctions de regex ont aussi des arguments chaînes
Dans re.search(motif1,x) x doit être une chaîne. Et un point-virgule






Tu veux obtenir 5 listes dont chacune ne comporte des éléments que d’un seul type ?

Précise stp.

[Antwan76ers]

Ok je précise tout sa

Je parcours un fichier texte
J'ai une boucle for qui remplie une liste, une fois que la boucle est terminé et la liste complète elle est inscrite dans un autre fichier, la boucle reprend et la liste est remplis avec de nouvelles donnée (il y a donc une seule liste qui est formée puis réinitialiser à liste vide a chaque passage dans la boucle)

Moi je voudrais avant d'inscrire dans mon fichier de sortie ma liste qui sort de la boucle, la remanier.
Et je veux que toute les listes qui sortent (que j'inscrit dans mon fichier de sortie) possèdent le même nombre d'éléments c'est à dire 6: le premier liste[0] c'est l'identifiant, liste[1] c'est le ou les éléments du type un caractère/espace/nombre (si il y'en a plusieurs je les met à la suite c'est pas grave il faut que sa soit dans le même élément) ainsi de suite jusqu'à liste[5]. Si jamais il n'y a pas dans la liste d'élément du type 2 caractère/espace/nombre et bien liste[2] sera malgrès tout présent avec une chaine de caractère du style "inexistant" dedans.

La boucle qui me sort les listes (dans mon fichier texte) fonctionne parfaitement j'ai juste un souci au niveau du remaniement de la liste avant de finir le passage dans la boucle pour l'écrire dans mon fichier de sortie avec mon histoire de motif

(J'utilise startswith et re.search au sein d'une nouvelle boucle avec les liste[i] qui sont des chaines de caractères.)


Exemple; a la fin de ma boucle ma liste est sous cette forme:
liste=['Identifiant', 'A 45', 'P 12', 'AA 74', 'MLKJO 2','K 30']
Je veux la remanier pour pouvoir l'inscrire dans mon fichier sous cette forme:
liste=['Identifiant', 'A45 P 12 K 30', 'AA 74', 'Inexistant', 'Inexistant', 'MLKJO 2']

[ulysse_31]

Si tu nous donne pas ta boucle, on pourra pas être beaucoup plus précis

A la mano, j'obtiens a priori le résultat attendu (j'ai pas tout compris en fait !)

Code :

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

1
2
3
4
5
6
7
8
9
10
 
liste=['Identifiant', 'A 45', 'P 12', 'AA 74', 'MLKJO 2','K 30']
liste_temp = []
liste_temp.append(liste[0])
liste_temp.append(liste[1].replace(' ','') + " " + liste[2] + " " + liste[-1])
liste_temp.append(liste[3])
liste_temp.append("inexistant")
liste_temp.append("inexistant")
liste_temp.append(liste[-2])
print liste_temp

Je suis ravi d'avoir essayé de t'aider
Bienvenue parmi nous

[Antwan76ers]

Oui sa marche pour l'exemple, mais il faut que je trouve un moyen pour réarrangé la liste de manière automatique après qu'elle soient généré par la boucle. Lors du passage suivant dans la boucle j'obtiendrais une liste différente (y'aura pas d'élément à un caractère par exemple), donc il faut je pense définir des motif qui vont matché avec chaque liste[i]

Je vais avoir dans mon fichier de sortie un millier de ligne (à la louche, on va pas chipoter) sur chaque ligne sera écrit la liste qui a fait son passage dans la boucle, chacune sera différente mais il faut qu'elle ai toute le même format pour que je puisse faire quelque chose du fichier de sortie. (Base de donnée et tout le bazar )

Je crains que si je vous montre le code monstrueux sa ne vous embrouille encore plus (si si je vous assure )

[ulysse_31]

Je crains que si je vous montre le code monstrueux sa ne vous embrouille encore plus (si si je vous assure )

Aller courage mets le ton code

[Antwan76ers]

Ok bin j'aurais prévenu, attention sa pique les yeux

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
dumpsql=open(Destinationfichier,"w")
    listalacon=[]
    for i,j in enumerate(file):
 
        if file[i].startswith(">"):
            z=file[i+1]
            listalacon.append(j)
            listalacon.append(z)
            if file[i]==file[i+2]:
                z=file[i+3]
                listalacon.append(z)
            else:
                listclean=[]
                for dsq in listalacon:
                    dsq=dsq.replace(">","")
                    dsq=dsq.replace("\n","")
                    if dsq in listclean:
                        pass
                    else:
                        listclean.append(dsq)
 
 
                #id=listclean[0]
                motif1="\w\s"
                motif2="\w\w\s"
                motif3="\w\w\w\s"
                motif4="\w\w\w\w\s"
                motif5="\w\w\ww\w\s"
 
                for i in range(1,len(listclean)):
                    if re.search(motif1,listclean[i]):
                        listclean[1]=listclean[1]+" "+listclean[i]   
                    elif re.search(motif2,listclean[i]):
                        listclean[2]=listclean[2]+" "+listclean[i]    
                    elif re.search(motif3,listclean[i]):
                        listclean[3]=listclean[3]+" "+listclean[i]
                    elif re.search(motif4,listclean[i]):
                        listclean[4]=listclean[4]+" "+listclean[i]
                    else:
                        listclean[5]=listclean[5]+" "+listclean[i]
                print listclean
                dumpsql.write("%s"%(listclean)+"\n")
                listalacon=[]        
        elif file[i].startswith("n"):
            break
        else:
            continue
 
    dumpsql.close()

[ulysse_31]

Oula jregarderai ca ce soir a la maison
Et donne moi une version de ton fichier ( quelques lignes completes !! )

[Antwan76ers]

le fichier de base est sous cette forme:

>identifiant1
TA 13
>identifiant1
JKLM 6
>identifiant3
P 10
>identifiant4
C 16
>identifiant4
FH 8
>identifiant4
ADXC 4
>identifiant4
S 3
>identifiant5
KL 10
>identifiant5
GOU 5
>identifiant6
H 10
>identifiant7
D 12
...
...

Comme vous pouvez constatez il peut y'avoir plusieurs éléments relatif à un identifiant (répétition de identifiant4 sur plusieurs lignes)
Le bout de code que j'ai fournis me renvoi à chaque passage dans la boucle une liste avec pour premier élément un identifiant (par exemple identifant4) et tout les données qui s'y rapportent(C 16, FH 8, ADXC 4, S 3 etc.)
liste=["identifiant4","C 16", "FH 18", "ADXC 4", "S 3"]

Je part de ce fichier brut et j'injecte les résultats de mon fichier de sortie dans une base de données c'est pourquoi j'ai besoin de remanier la liste en sortie de boucle pour que tout soit sous un même format dans mon fichier de sortie.

Mais avant de modifier les résultats en requetes sql j'ai d'autre soucis à régler

[denis2]

bonjour

je ne suis pas certain d'avoir tout compris
mais au cas ou , peut être que ça peut t'aider.
c'est un exemple.

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
 
liste=['Identifiant', 'A 45', 'P 12', 'AA 74', 'MLKJO 2','K 30']
stop = len(liste)
dico = {}
cptr = 1
 
while cptr < stop:
    n = len(liste[cptr])
    if n not in dico:
        dico[n] = cptr
    else:
        if dico[n] != cptr:
            liste[dico[n]] += ' '+liste[cptr]
            liste[cptr] = 'inexistant'
    cptr+=1 
 
print liste

[eyquem]

Il ne faut pas faire comme tu fais. Tu séries les problèmes et les résouds indépendamment l’un de l’autre. Je sais bien que dans un autre post, c’est ce que je conseille de faire. Mais dans ton cas, il ne faut pas. IL faut plutôt penser globalement le code.

Autrement dit, il ne faut pas se dire “d’abord j’obtiens la liste“, et ensuite “maintenant, je la trie“.

Mais il faut te débrouiller dans la boucle pour construire un objet dont tu pourras obtenir facilement la liste triée.




Il te faut pour cela des dictionnaires dont les clés seront les nombres de lettres des items ","C 16", "FH 18", "ADXC 4" . Tu enregistres les valeurs , c’est à dire les 'A 45' , 'MLKJO 2' dans le dictionnaire au fur et à mesure que la boucle tourne en fonction de leur nombre de lettres

Et à la fin de la boucle, tous les éléments de même nombre de lettres sont rassemblés dans une même valeur.

Je rappelle qu’une valeur de dictionnaire peut être une liste. C’est pour ça que tu peux rassembler dans une même liste plusieurs éléments de même caractéristique repérée par une seule clé.







Maintenant, quand je regarde ton code, ce que je vois dans ton code ne correspond pas à ce que tu en dis.



D’abord, après
dumpsql=open(Destinationfichier,"w")
il y a une indentation incompréhensible.



Ensuite, je ne vois pas une boucle qui reprend. Je vois une seule boucle en i,j et il faut que file[i].startswith(">") soit toujours vraie sinon la boucle s’arrête de tourner.
Quand elle s’arrète , rien ne la relance, elle n’a tourné qu’un seule fois.





Comme ce que tu as décrit n’est pas ce que je constate dans ton code, il faut que je complète ce que j’ai écrit plus haut.

Ce que tu appelles passage dans la boucle, moi je l’appelle tour: ça correpond à un seul couple de valeur i,j.
Quand un couple i,j a été vu, il n’est plus jamais revu, c’est ce qui me fait dire que ta boucle n’est parcourue qu’une fois, contrairement à ce que tu as dit.



Je vais décortiquer ton code pour comprendre comment il fonctionne, mais je pense que tu fais une gymnastique infernale pour arriver à capter les données dans le fichier.
On va simplifier tout ça.



En attendant que je revienne, essaie de comprendre ce que je dis avec mes dictionnaires.
Car il te faut un autre dictionnaire dans lequel les clés seront les ’identifiant1, ’identifiant2’, etc

À chacune de ces clés correspondra une valeur qui sera elle mème un dictionnaire du type que j’ai décrit plus haut avec clès = nombres de lettres.

Vois ça.




Warning: il se peut que je me trompe. Je n’ai pas examiné le problème encore assez.

[eyquem]

Ah d’accord. La ligne if file[i]==file[i+2]: est destinée à ne pas passer dans le traitement de listalacon commandé par le else: tant qu’on n’a pas épuisé toutes les lignes d’un même identifiant.

ce qui veut dire que toutes les lignes qui concernent un même identifiant sous regroupés successivement dans le fichier avant que les lignes d’un autre identifiant surviennent.

Il aurait fallu le dire tout de suite.

[eyquem]

C’est affolant: pour chaque ligne commençant par ’>’, tu enregistres dans listalacon les données concernant cette ligne (c’est à dire à la ligne suivante) et la donnée de la ligne commençant par ’>’ suivante

Bien sûr qu’après il faut faire un gros travail d’épuration avec tes expressions régulières ! Et ce n’est alors pas fini.....



Tu fais un travail de titan.

Pour résumer, tu as un algorithme très compliqué pour lequel tu obtiens un code seulement compliqué parce que tu utilises Python.

Mais c’est dommage d’utiliser Python pour rendre compliqué un problème très compliqué.

Il faut l’utilser pour résoudre simplement un problème à peine compliqué.

[eyquem]

J’ai créé un fichier ’denis.txt' avec les lignes que tu donnes dans le message #9

Je pense que dans ton code , la ligne
for i,j in enumerate(file):
lit une liste file (mauvais nom pour une liste)
obtenue par readlines()
==» comme readlines() conserve les ’\n’ dans les lignes, tu es obligé de les traiter plus tard.

C’est se faire souffrir inutilement.

Essaie le code suivant, et tu verras le truc:

Code :

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

1
2
3
4
5
li = open('denis.txt','r').readlines()
print '\n'.join(repr(u) for u in li)
print
lo = open('denis.txt','r').read().splitlines()
print '\n'.join(repr(u) for u in lo )

[eyquem]

Bon, j’ai le code.
Pour ne pas donner tout cuit, j’ai recouvert les lignes principales.
Maintenant que la structure de données adéquates est posée, compléter est facile

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
li = open('denis.txt','r').read().splitlines()
print '\n'.join(repr(u) for u in li )
 
dico = {}
 
for i in xrange(0,len(li),2):
    line = li[i]
    if line[0]==">":
        tifian = line[1:]
        if tifian not in dico:
            dico[tifian] = { 1:[], 2:[], 3:[], 4:[], 5:[] }
        ..................
        .......................................................
 
print '\n====================='
for u in dico:
    print u,dico[u]
 
print '\n---------------------'               
listes_resultats = []
for u in dico:
    ls = [u]
    for n in xrange(1,6):
        if dico[u][n]:
            ...............................
        else:
            ls.append('Inexistant')
    listes_resultats.append(ls)
 
print '\n'.join(repr(u) for u in listes_resultats)

Le résultat est

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
'>identifiant1'
'TA 13'
'>identifiant1'
'JKLM 6'
'>identifiant3'
'P 10'
'>identifiant4'
'C 16'
'>identifiant4'
'FH 8'
'>identifiant4'
'ADXC 4'
'>identifiant4'
'S 3'
'>identifiant5'
'KL 10'
'>identifiant5'
'GOU 5'
'>identifiant6'
'H 10'
'>identifiant7'
'D 12'
'n'
 
=====================
identifiant1 {1: [], 2: ['TA 13'], 3: [], 4: ['JKLM 6'], 5: []}
identifiant3 {1: ['P 10'], 2: [], 3: [], 4: [], 5: []}
identifiant5 {1: [], 2: ['KL 10'], 3: ['GOU 5'], 4: [], 5: []}
identifiant4 {1: ['C 16', 'S 3'], 2: ['FH 8'], 3: [], 4: ['ADXC 4'], 5: []}
identifiant7 {1: ['D 12'], 2: [], 3: [], 4: [], 5: []}
identifiant6 {1: ['H 10'], 2: [], 3: [], 4: [], 5: []}
 
---------------------
['identifiant1', 'Inexistant', 'TA 13', 'Inexistant', 'JKLM 6', 'Inexistant']
['identifiant3', 'P 10', 'Inexistant', 'Inexistant', 'Inexistant', 'Inexistant']
['identifiant5', 'Inexistant', 'KL 10', 'GOU 5', 'Inexistant', 'Inexistant']
['identifiant4', 'C 16 S 3', 'FH 8', 'Inexistant', 'ADXC 4', 'Inexistant']
['identifiant7', 'D 12', 'Inexistant', 'Inexistant', 'Inexistant', 'Inexistant']
['identifiant6', 'H 10', 'Inexistant', 'Inexistant', 'Inexistant', 'Inexistant']

[Antwan76ers]

Tout d'abord merci pour vos aides cela m'est très précieux.

J'ai bien conscience que mon script est cochon et que la manière de faire n'est certainement pas optimale (loin de là ).
Je débute le python et je fait un peu comme je peux. De plus la destiné de ces données brutes à évolué dans leur devenir final ce qui fait que je dois améliorer leur rendu (avant le simple regroupement des valeurs correspondant aux identifiants était suffisant donc même crassou sa tournais plutôt pas mal donc je m'en contentais).
Et donc je part d'un script que j'ai fait il y a pas longtemps et je le complète (enfin je le complexifie serait plus juste ) pour arriver aux résultats voulus.
Je n'ai donc pas une vision globale du problème qui permet de le résoudre plus efficacement.

D’abord, après
dumpsql=open(Destinationfichier,"w")
il y a une indentation incompréhensible.

Exact, étourderie

Tu fais un travail de titan.

Pour résumer, tu as un algorithme très compliqué pour lequel tu obtiens un code seulement compliqué parce que tu utilises Python.

Mais c’est dommage d’utiliser Python pour rendre compliqué un problème très compliqué.

Il faut l’utilser pour résoudre simplement un problème à peine compliqué.

Je sais bien, simplement comme je l'ai dit je fait comme je peux et je suis limitée par mes compétences en la matière. C'est pourquoi je suis là

Je me remet dedans demain, encore merci pour l'aide .

PS: Denis c'est le nom de quelqu'un qui est gentiment venu apporter son aide, moi c'est antwan

[Antwan76ers]

En tout cas ton code est parfait, le résultat est pile ce qu'il faut, cependant moi j'ai toujours un souci (là ou il faut compléter facilement )
J'ai bien saisi l'initialisation des dictionnaires en fonction des identifiant le for i in xrange(0,len(li),2) ressort les identifiants et l'on défini un dictionnaire pour chaque ID différents (tifian).

Sa coince toujours à peu près au même endroit pour moi; pour entrer les item correspondants ('A 45', 'KLM 4' etc.) je n'arrive pas à définir le motif (le nombre de lettres) pour les placer correctement (au bon endroit) dans le dictionnaire relatif à l'ID.

Tu à dis dans un post d'avant faire une boucle qui en fonction du nombre de lettres des item les places correctement est ce que sa fonctionne toujours comme sa?

[eyquem]

Tu as dit dans un post d'avant: faire une boucle qui en fonction du nombre de lettres des item les place correctement
Est ce que ça fonctionne toujours comme ça?

Bien sûr. Mais pourquoi poses-tu cette question ? :

- la boucle y est , il s’agit de
for i in xrange(0,len(li),2):

- Ce qui manque c’est de placer les items en fonction de leur longueur. Et tu as bien décomposé le problème:

pour entrer les items (...) définir le motif (le nombre de lettres) pour les placer correctement (au bon endroit) dans le dictionnaire relatif à l'ID.

C’est à dire , pour les placer :
1- il faut savoir dans quoi les placer
2- il faut trouver le moyen de déterminer le nombre de lettres d’un item

1- dans quoi placer ?
il n’y a pas 36 solutions s’il faut

placer (...) dans le dictionnaire relatif à l'ID.

2- comment trouver le nombre de lettres ? –> il faut chercher quelles fonctions de Python vont te permettre de faire ça.




Note que quand j’ai écrit

Il te faut pour cela des dictionnaires dont les clés seront les nombres de lettres des items ","C 16", "FH 18", "ADXC 4" . Tu enregistres les valeurs , c’est à dire les 'A 45' , 'MLKJO 2' dans le dictionnaire au fur et à mesure que la boucle tourne en fonction de leur nombre de lettres

Car il te faut un autre dictionnaire dans lequel les clés seront les ’identifiant1, ’identifiant2’, etc
À chacune de ces clés correspondra une valeur qui sera elle mème un dictionnaire du type que j’ai décrit plus haut avec clès = nombres de lettres.

il s’agissait du même dictionnaire (-> c’est dico)



Par contre, dans

Je rappelle qu’une valeur de dictionnaire peut être une liste. C’est pour ça que tu peux rassembler dans une même liste plusieurs éléments de même caractéristique repérée par une seule clé.

il s’agit des dictionnaires qui sont valeurs de dico et dont les items sont (nombre de lettres , liste)


C’était un peu mal écrit parce que j’ai fait vite.



Je ne vois pas quoi ajouter sans donner la solution.


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

J'ai bien conscience que mon script est cochon

Je ne trouve pas le code cochon mais l’algorithme compliqué.

et que la manière de faire n'est certainement pas optimale

Mais d’un autre coté , écrire un code aussi compliqué demande d’en être capable...


Ce que j’ai voulu dire en fait , c’est qu’il faut avoir le réflexe à un moment de se dire: « en employant Python, ce n’est pas possible que ce soit aussi compliqué à faire que ce que je suis en train de développer. Il y a certainement plus simple. Il faut que je revois l’algorithme »

[eyquem]

Ah si , je peux ajouter quelque chose.



Un procédé très pythonien est l’itération sur les objets:

au lieu de faire

Code :

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

1
2
3
li = [12,34,87,’jkl’,23]
for i in xrange(len(li)):
    print li[i]

on fait plutôt

Code :

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

1
2
3
li = [12,34,87,’jkl’,23]
for x in li:
    print x

Alors pourquoi ai-je écrit dans mon code

Code :

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

1
2
for i in xrange(0,len(li),2):
    line = li[i]

au lieu de

Code :

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

for line in li:

??


C’est parce qu’il y a une possibilité offerte en itérant sur l’indice qu’on n’a pas si on itère sur les lignes (ligne = élément de li)
Trouver cette possibilité , c’est trouver la suite
Trouver cette possibilité , c’est trouver la suite

[Antwan76ers]

Merci pour ces réponses, il est d'autant plus intéressant que tu ne fournisse pas le code entièrement ce qui me permet réellement de progresser.

J'ai presque reussi à faire exactement ce que je veux, cependant lorsque deux motifs d'un caractère sont présent le second "écrase le premier", mais c'est un détail qui devrait se regler tout prochainement.

Encore merci, je placerais les bornes résolus sur le topic avec mon code dès qu'il est totalement fonctionnel