Discussion :

[silverboy33]

Bonjour a toutes et a tous,

Je suis en train de me créer un petit programme grâce a Python, mais, fasse à ma méconnaissance de cette outil, je rencontre quelques difficultés...

Voici mes problèmes.

1) Je dois lire certaines valeurs bien précise dans un fichier .DAT, mais mon soucis est que ce fichier va évoluer au cours du temps, ce qui fait que je ne peux pas sélectionner ces valeurs uniquement en les appelant par octet (ce que j'ai déjà essayer pour voir si ça marchait).
Ce que je cherche donc a faire c'est plutôt de lancer une sorte de "recherche" par mots clés dans ce fichier, de définir la ligne contenant ce mot clé comme référence, et de commencer a compter les octets a partir de ce point.

2) je dois également remplir un fichier .dat avec mes résultats.
Je voudrais donc savoir comment faire pour ajouter une ligne, sans effacer ce qu'il y avait avant (faire un simple rajoute d'une ligne a chaque itérations).

pourriez-vous m'aider?

merci d'avance

silverboy33

[Zavonen]

Je ne suis pas sûr d'avoir tout compris, mais enfin il s'agit d'ajouter des données dans un fichier texte, mais pas nécessairement à la fin.
Dans ce cas je te recommande d'ouvrir un fichier vierge en écriture, de recopier les parties à conserver du fichier source, d'ajouter à la volée des commentaires ou de nouvelles données.
A la fin, fermer le fichier ouvert en écriture, le renommer en écrasant l'ancien.

[silverboy33]

En réalité, je dois faire une sorte de boucle nécessitant 2 programme différents. Et j'ai besoin des résultats de l'un pour faire tourner l'autre et vice-versa.

Mon premier programme me fournir un fichier résultat comme suit:

"blablablablablablablablablablabla
blablablablablablablablablablablablabla
blablablablablablablablablablablabla

--------------------------------------
contraintes dans la plaques:
--------------------------------------
sigma: tau:
362 120
236 215
123 356
"

mon problème est que mes ligne de "bla bla" vont etre plus ou moins longue suivants les itérations, ce qui fait que les résultats dont j'ai besoin (ici sigma et tau) ne seront plus exactement a la même place d'une itération à l'autre.
je voudrais donc faire quelques chose du genre:

">lis moi le fichier résultat.dat
>recherche le mots "contraintes"
>a partir de là compte les octets grace a la commande:
f.seek(125)
J11=float(f.read (3))
"

Pour ce qui est du votre réponse, il s'agit de mon second problème, qui viens à une autre étape que le précédent.
Python va me sortir en résultats, des coordonnées de points, qui me sont nécessaire pour relancer mon premier programme et faire une seconde itération. Seulement j'ai besoin de tous mon historique de point pour que tous fonctionne. Si j'ai 12 itérations, il me faut mes 12 points, l'un a la suite de l'autre, se qui fait que ce fichier texte doit se remplir étape par étape.

Je ne sais pas si tout cela est plus clair, je me prend la tête dessus depuis trop de temps, alors cela dois ce ressentir dans mon argumentation.

[eyquem]

J’adore ce problème de modification d’un fichier sur place, sans avoir à le recopier et l’effacer.

J’ai commis quelques posts sur ce sujet, mais pour un tel traitement de fichiers TEXTE, car je connais fort mal les fichiers binaires.

Or je lis sur un site

Un fichier DAT Un fichier .dat est un fichier de données (.DAT signifie data). En général, il s'agit d'un fichier binaire, créé par un programme et utilisable uniquement par ce programme, ce qui signifie qu'il n'est pas censé être ouvert ou consulté directement.

Tes fichiers sont-ils bien tous les deux des fichiers TEXTE ? Si c’est le cas, je pense pouvoir t’aider pour le point 2.




Concernant le point 1, j’ai la vague impression que tu envisages les choses de façon plus compliquée qu’elles ne le réclament.
Pourquoi veux-tu compter des octets aprés ton mot clé ?
des traitements de chaîne ou l’utilisation d’expressions régulières ne seraient pas possibles ?
D’ailleurs pourquoi parles-tu d’octets au lieu de caractères ?

[eyquem]

Voilà un bout de code pour t’aider à commencer.

Il est fait pour analyser un texte comme le suivant:

"blablablablablablablablablablabla
blablablablablablablablablablablablabla
blablablablablablablablablablablabla

--------------------------------------
contraintes dans la plaques:
--------------------------------------
sigma: tau:
362 120
236 215
123 356

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import re
 
f = open('sigmatau.txt')
ch = f.read()
f.close()
 
x = ch.find('contraintes dans la plaque')
y = ch[x+26:].find('sigma: tau:\n')
print ch[x+26:]
if y+1:
    lignes = ch[x+26+y+13:].splitlines()
    print 'lignes =',lignes
    for ln in lignes:
        print ln.strip().split()

y vaut -1 si 'sigma: tau:\n' n'est pas trouvé
donc y+1 vaut 0 dans ce cas.
Comme 0 est False et 1 est True, c'est un moyen d'arrêter le programme.

[silverboy33]

merci pour ta reponse rapide =)

C'est exactement ça que je souhaite faire!
Je ne manipule pas exactement des fichier texte dans le sens ou ce ne sont pas des .txt, mais c'est exactement la même chose avec mes .dat. Pour simplifier on va dire que se sont des .txt.

En tout cas un GRAND MERCI a toi pour ce code, sa marche au poil!!!!!!!!!!!!!!

Je vais profiter donc de t'avoir pour savoir si tu aurais une idée concernant mon autre problème?

meeeeeeeeerci encore!!

[eyquem]

De rien, de rien. Tu sais, ce n’est pas grand chose. Dans une semaine, tu feras la même chose en 2 minutes. Ce qui m’embète le plus, bien souvent, c’est de ne pas trouver suffisamment de description des problèmes dans les questions.

si tu aurais une idée concernant mon autre problème?

Bien sûr. A priori, il ne devrait pas y avoir de difficulté particulière, sauf celle d’être minutieux.

J’ai commencé à explorer l’historique de mes posts pour retrouver ceux que j’ai consacrés à ce sujet d’écriture en mode a+ mais je n’ai pas eu le temps de mener à bien. Certains sont mauvais, mais d’autres sont assez corrects je crois pour bien débroussailler les idées à acquérir. Il est donc préférable que je les retrouve.

Tu peux commencer à te renseigner sur les différents modes possibles d’ouverture de fichier: r, r+, w, w+, a, a+.

[silverboy33]

Je crois bien que c'est un "a+" qu'il faut que je rajoute.

J'ai une petite question concernant mon premier problème.
Comment faire, par la méthode que tu m'a donnée, une sélection de caractère.
Par exemple sélectionner juste une seule des valeurs, pour ensuite la rentrer dans une variable?

[eyquem]

Pour pb2:

Je suis en train de retrouver mes posts.

Il faut que je sélectionne car certains sont mauvais: ils comportent des explications à un stade où j’avais insuffisamment compris et appris certaines choses. Inutile que tu lises du baratin stérilement.

Je cherche les posts qui peuvent amener directement à une compréhension que je crois assez bonne des choses.





Pour pb1:

Il faut être plus précis. Tu veux quelle valeur ? Nom de la variable ? Autant de variables que de lignes ou peut-on réutiliser la même variable à chaque ligne ?



Dans le code que j’ai écrit, la ligne print ln.strip().split() affiche ['62', '120'] puis ['236', '215'] puis ['123', '356']
puis [] parce que j’ai une dernière ligne ’__\n’ dans mon fichier (deux blancs, j'ai mis _ sinon ca ne passe pas)

Manifestement ln.strip().split() est une liste.
Pour le vérifier, il suffit de faire afficher son type:

Code :

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

1
2
3
    for ln in lignes:
        print type(ln.strip().split())
        print ln.strip().split()

C’est la méthode split() qui produit une liste
La méthode strip() prend une chaîne, la nettoie, et renvoie une chaîne.

Sachant que c’est une chaîne, il suffit de se demander comment on obtient un éléments d’une liste. Si tu ne sais pas ça.... ben....il va te falloir peut être un peu plus d’une semaine...


Bref.
Je ne vais pas sélectionner une valeur et ENSUITE la rentrer dans une variable: on fait ça d’un coup

Code :

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

1
2
3
4
5
6
7
    for ln in lignes:
        print type(ln.strip().split())
        print ln.strip().split()
        sig = ln.strip().split()[0]
        to = ln.strip().split()[1]
        print 'sig =',sig
        print 'to =',to

Ou encore

Code :

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

1
2
3
4
5
6
    for ln in lignes:
        print type(ln.strip().split())
        print ln.strip().split()
        sig,to = tuple(ln.strip().split())
        print 'sig =',sig
        print 'to =',to

Nota: avec le fichier ’sigmatau.txt’ que j’ai écrit sur mon DD, j’obtiens une erreur à la fin avec ce code parce que la dernière ligne dans mon fichier est ’ \n’ et donc la dernière ln de n’est pas du genre '123 356\n' mais est ’ ’, ce qui donne un tuple vide, et donc une erreur
ValueError: need more than 0 values to unpack
ce qui signifie que le programme n'arrive pas à injecter deux valeurs du tuple vers deux variables parce que le tuple est vide....

Ce que je veux souligner par là, c’est que le
for ln in lignes:
que j’ai écrit dans mon code n’est valable que s’il n'y a que des lignes du genre '236 215\n’ dans toute la suite du fichier texte après la ligne “sigma: tau:\n“, sinon il y aura des erreurs de ce genre. Ce qui veut dire que tu vas devoir prévoir dans ton code une prise en charge de la façon dont se terminent ou peuvent se terminer tes fichiers.



Ou encore, si tu es sûr que les valeurs sont séparées par exactement un seul blanc

Code :

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

1
2
3
4
5
6
    for ln in lignes:
        print
        print ln.strip().partition(' ')
        sig,_,to = ln.strip().partition(' ')
        print 'sig =',sig
        print 'to =',to

Et si tu n’en es pas sûr

Code :

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

1
2
3
4
5
6
7
    for ln in lignes:
        print
        print ln.strip().partition(' ')
        sig,_,to = ln.strip().partition(' ')
        to = to.strip()
        print 'sig =',sig
        print 'to =',to

On peut faire beaucoup de choses avec Python

[silverboy33]

c'est tt bon, tout marche sur un test que j'ai fait vite fait.

Cela ne marchait pas tout a l'heure car le fichier dans lequel je lis les données est un .res (propre a un logiciel), du coup je n'avais plus mes listes...
Il ne me reste donc plus qu'a convertir ce .res en .txt (l'écriture est compatible, je le fais manuellement sans encombre), et se sera fini. Reste plus qu'a trouver la commande. =)
Enfin, de trouver un moyen de le sauver en tant que ".txt" pour ensuite le lire.

Merci

[silverboy33]

Je me rend compte que je ais de soucis en soucis...
y aurait il un moyen de faire ce changement de .res en .txt de manière a pouvoir afficher mes listes (et retrouver mes valeurs que je pourrais stocker... enfin...)

Après 3 semaines de lutte... on y arrive... (merci eyquem)

[silverboy33]

voici un bout du fichier résultat duquel je dois extraire les résultat.
En effet, il doit y avoir 200 lignes environ avant, mais non importante pour mon pb.

Tout ce que tu m'a indiqué marche au poil pour mes test, mais dès que je l'applique ce ce document g un pb... je ne comprend pas...

Ce sont toutes les valeurs des J(1), J(2), ... que je dois extraire, et ce, dans des variable séparées (dc 20 variables).

Je désespère...

[eyquem]

Je suis en train de finir d’examiner les posts que j’ai écrits qui concernent ton problème numéro 2. C’est un peu long parce que je n’ai pas pu faire que ça depuis ce matin et surtout que j’ai moi-même du mal à me reconnaître dans tout le fatras que j’ai pu écrire sur ce forum. Il y a des posts anciens qu’il ne faut surtout pas lire parce qu’ils disent des choses qui sont fausses ou incomplètes.

Je devrais avoir fini d’ici une demi-heure.



Je regarderai ton fichier dans la foulée. Avec les données précises c’est beaucoup mieux effectivement.

On va y arriver, on va y arriver.

[silverboy33]

en tout cas merci eyquem, pour ton acharnement =)

[eyquem]

Bon. Pour m’éviter de réécrire des choses, je te propose de lire ceci
http://www.developpez.net/forums/d65...chier-mode-rp/
et le post qui le suit,
en gardant à l’esprit que c’est insuffisant parce que j’ignorais alors 4 choses importantes:





- la fonction repr() permet de connaître la valeur exacte d’une chaîne. La valeur exacte n’est pas toujours égale à l’affichage qu’on en obtient. Par exemple:

Code :

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

1
2
ch = 'La duchesse de Gerolstein dite \'Gégé\' dans l\'intimité affirma pompeusement:\n"Ce tableau est bidon"'
print ch

La valeur exacte de ch est
La duchesse de Gerolstein dite \'Gégé\' dans l\'intimité affirma pompeusement:\n"Ce tableau est bidon"

Mais si on fait print ch, on obtient
La duchesse de Gerolstein dite 'Gégé' dans l'intimité affirma pompeusement:
"Ce tableau est bidon"
C’est bien ce qui est voulu.

Mais si on veut connaître la valeur exacte de ch il faut faire print repr(ch) qui donne
'La duchesse de Gerolstein dite \'G\xe9g\xe9\' dans l\'intimit\xe9 affirma pompeusement:\n"Ce tableau est bidon"'

J’ai lu cette “astuce“ dans un post d’Antoine935.
Avant de la connaître j’utilisais print [ch] pour accéder à la valeur exacte de ch. C’est ce qui se trouve dans un certain nombre de codes-exemples que j’ai écrits.



- Quand Windows écrit un texte dans un fichier sur disque dur, il ajoute des \r devant tous les \n, sans rien demander à personne.

De son coté, en mode normal c’est à dire non corrigé pour qu’il n’en soit pas ainsi, Python traduit toutes les newlines en \n , quelles que soient ces newlines \n ou \r\n ou \r

Ce qui fait que la longueur d’une chaîne obtenue par lecture en mode ’r’ d’une ligne de fichier ayant été écrit sous Windows est différente de la longueur de cette ligne dans le fichier sur le disque dur.

Si on utilise seek() dans le fichier et find() dans une chaîne sans savoir ça, on va au devant de problèmes de positionnement du pointeur qui repère la position dans un fichier et donc des difficultés à faire des updates d’un fichier. La solution prise par ceux qui sont alors confrontée à cette difficulté est de passer par un nouveau fichier actualisé et d’effacer l’ancien.
Mais moi ça m’amuse beaucoup de bidouiller les caractères précisément pour faire exactement ce qu’on veut.

Bien sûr, sous Linux il n’y a pas ce problème puisque, je crois , les newlines sont \n. Mais sous Mac c’est \r, je crois . Enfin bref, je ne connais pas tout, je sais que je m’en suis vu à cause de Windows que j’ai sur mon PC.




- Pour éviter les décalages entre find() et seek(), il faut ouvrir les fichiers en modes ’rb’ et ’wb’. J’ai appris cette astuce dans un post de pierjean.

En mode ’rb’ , Python n’élimine pas les \r s’il y en a dans le fichier. On obtient donc des chaînes (recevant la lecture des lignes d’un fichier) qui comportent tous les caractères y compris les \r, visibles grâce à repr().


Aussi une chose à savoir: si on écrit en mode ’wb’ dans un fichier sous Windows, il n’ajoute pas de \r devant les \n.



Tu trouveras des explications plus détaillées dans le post suivant
http://www.developpez.net/forums/d73...t/#post4249820







- Avec ces renseignements + les fonctions seek() tell() etc on a tout ce qu’il faut pour bien s’amuser.

Reste à savoir comment sont organisés les fichiers, parce qu’il y a des caractères cachés qui n’apparaissent pas quand on ouvre un fichier normalement.

Il faut donc commencer par comprendre comment est foutu le codage interne d’un fichier quand on veut le manipuler.

Je ne prétends pas savoir le faire, vue la diversité des formats de fichier existante. Je sais simplement que ce n’est pas évident mais qu’il faut s’en préoccuper si on veut vraiment maîtriser ce qu’on fait.

C’est pourquoi tes difficultés pour transformer un fichier d’extension .res en fichier .txt ne m’étonnent pas

Dans le post suivant, il est question de ces histoires de fichiers.

http://www.developpez.net/forums/d73...t/#post4244966



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



Mes posts sont un peu touffus et sans doute un peu pénibles à lire parfois à cause de cela. J’en suis désolé, mais je crois qu’à condition de faire le tri, on peut y glaner quelques bonnes choses sans lesquelles je ne vois pas comment on pourrait faire certains traitements.
Allez , j’en ai encore écrit plus que je ne voulais.

[eyquem]

Moi aussi il y a des choses que je ne comprends pas.

- Il était question d’un fichier .res que tu voulais transformer en fichier .txt et tu semblais avoir des problèmes à le faire. Et maintenant tu présentes ce fichier .txt

- Il était aussi question de ’contraintes dans la plaque’ comme repère et puis là dans le fichier .txt que tu as donné, cette chaîne ne s’y trouve pas. Ce fichier est d’ailleurs complétement différent de ce que tu avais donné: sur chaque ligne, les valeurs ne sont plus séparées par un seul blanc mais par plusieurs, il y a deux colonnes FISS et RAYON en plus.



Bon enfin.... ce n’est pas grave, il suffit de faire avec ça et pour l’objectif fixé.

Pour cela je m’accorde la facilité des expressions régulières.

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
import re
 
patJJKKS = re.compile(' +\d+ +\d+ +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+)')
 
dico = {}
 
f = open('test.txt','rb')
i = 0
for ln in f:
    m = patJJKKS.match(ln)
    if m:
        print repr(ln)
        i += 1
        dico[i] = m.groups()
f.close()
 
print '\n\nContenu du dictionnaire des valeurs trouvees'
for k in dico:
    (a,b,c,d,e) = dico[k]
    print a,' # ',b,' # ',c,' # ',d,' # ',e,' # '

Les expressions (a,b,c,d,e) = dico[k]
et print a,' # ',b,' # ',c,' # ',d,' # ',e,' # '
sont destinées à montrer que tu peux avoir les valeurs individuellement en dépliant chaque tuple contenu dans le dico.
Le désavantage d’un dico: les items ne sont pas ordonnés.
Tu peux alors préférer une liste.
Ou mettre directement lors de l’exécution les valeurs trouvées dans la structure que tu souhaites.




Si tu veux que les clés du dictionnaire soient les rayons , c’est simple , il suffit d’ajouter deux parenthèses autour du second \d+

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
import re

patJJKKS = re.compile(' +\d+ +(\d+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+)')

dico = {}

f = open('test.txt','rb')
for ln in f:
    m = patJJKKS.match(ln)
    if m:
        print repr(ln)
        dico[m.group(1)] = m.groups()[1:]
f.close()

print '\n\nContenu du dictionnaire des valeurs trouvees'
for k in dico:
    (a,b,c,d,e) = dico[k]
    print 'cle =',k,' : ',a,' # ',b,' # ',c,' # ',d,' # ',e,' # '

Deux parenthèses définissent un groupe: la valeur de chaîne trouvée à cet endroit dans la chaîne explorée peut être obtenue, soit par group() soit par groups(). C’est la cuisine des regex, il faut regarder un tutoriel.

On peut envisager sur cette base de regex plein de manières de faire.
Si tu veux obtenir plutôt une liste des tuples, il faut utiliser findall().
Si tu veux indicer différemment, on peut.
Etc etc.

Je peux t’expliquer la RE (regular expression: la chaîne qui est donnée à re.compile() si des points te paraissent obscurs. Mais avec le tutoriel, ça devrait être clair:
http://www.python.org/doc/2.5.2/lib/re-syntax.html



Je n’ai pas rencontré de difficulté à traiter ton fichier test.txt avec ces codes.



Ceci dit, les regex présentent le désavantage d’être la plupart du temps plus lente que les traitements de chaîne.

Quand on le peut, il est bon de faire un petit préalable pour s'avancer jusqu'au début ou à proximité des lignes qui contiennent les données voulues. Par exemple dans le cas du fichier que tu as soumis, on peut faire:

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
import re
 
patJJKKS = re.compile(' +\d+ +(\d+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+)')
 
dico = {}
 
f = open('test.txt','rb')
ch = f.read()
f.close()
 
 
x = ch.find('SIH(DEG.)')
lignes = ch[x:].splitlines()
for ln in lignes:
    m = patJJKKS.match(ln)
    if m:
        print repr(ln)
        dico[m.group(1)] = m.groups()[1:]
 
print '\n\nContenu du dictionnaire des valeurs trouvees'
for k in dico:
    (a,b,c,d,e) = dico[k]
    print 'cle =',k,' : ',a,' # ',b,' # ',c,' # ',d,' # ',e,' # '

PS: comment fait-on pour poster dans un message un fichier comme tu l’as fait ? Personnellement je ne sais pas faire.

[eyquem]

Créer lignes = ch[x:].splitlines() en mémoire peut être lourd si le fichier est très gros.

On peut l’éviter en continuant à itérer directement dans le fichier. On peut le faire en ouvrant en mode ’rb’ et utilisant seek() (voilà le rapport avec tous mes précédentes explications)

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
import re
 
patJJKKS = re.compile(' +\d+ +(\d+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+) +([-\d.+E]+)')
 
dico = {}
 
f = open('test.txt','rb')
ch = f.read()
x = ch.find('SIH(DEG.)')
f.seek(x)
for ln in f:
    m = patJJKKS.match(ln)
    if m:
        print repr(ln)
        dico[m.group(1)] = m.groups()[1:]
f.close()
 
print '\n\nContenu du dictionnaire des valeurs trouvees'
for k in dico:
    (a,b,c,d,e) = dico[k]
    print 'cle =',k,' : ',a,' # ',b,' # ',c,' # ',d,' # ',e,' # '

[silverboy33]

Merci pour ces post,

désolé du retard mais j'ai eu un soucis avec mon pc tout hier, du coup je t'ai pas répondu.
je relirais en détail ce que tu m'a mis aujourd'hui et demain, histoire de tout assimiler et de voir ce qui va me débloquer.

Sinon, juste une petite question au passage: pourquoi je ne peux pas faire un comptage classique avec le module io et un seek() après avoir fais une recherche grace a ce que tu m'a envoyé?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
import re
import io
 
f = open('test.txt')
 
ch = f.read()
f.close()
x=ch.find(' FISS  RAYON       J(1)           J(2)           KI             KII         SIH(DEG.)')
 
y = ch[x+12:].find(' FISS  RAYON       J(1)           J(2)           KI             KII         SIH(DEG.)\n')
print (ch[x+12:])
y.seek(192)
J11=float(f.read (14))

et aussi, le premier

Code :

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

x=ch.find(' FISS  RAYON       J(1)           J(2)           KI             KII         SIH(DEG.)')

sert a faire la recherche
mais,

Code :

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

y = ch[x+12:].find(' FISS  RAYON       J(1)           J(2)           KI             KII         SIH(DEG.)\n')

a quoi sert il? je ne vois pas son utilité?

merci encore pour tte ton aide

[silverboy33]

re,

désolé je n'avais pas vu tes dernières réponse.
POur l'histoir du .res et du .txt, ce n'est juste qu'un malentendu.
Si tu veux mon prog me fournir un .res (pour résultat) mais il ne contient que du texte.
Et les code que tu m'envoyais ne marchais pas avec ce .res et c'est pour ça que je t'ai envoyé un message te demandant comment on faisait pour passer AUTOMATIQUEMENT en .txt.
Certe je te l'ai envoyé au format .txt, mais je l'avais fais manuellement.

Bref de tte façon cela n'a pas d'importance car en faite c t qu'une erreur de manip, du coup .res=.txt (pour mon pb, en tt cas).

sinon, j'ai decouvert une autre façon (je ne sais pas ce qu'elle vaut mais bon):

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
import re
import io
 
f = open('test.txt')
 
ch = f.read()
f.close()
x=ch.find(' FISS  RAYON       J(1)           J(2)           KI             KII         SIH(DEG.)')
 
y = ch[x+175:].find(' FISS  RAYON       J(1)           J(2)           KI             KII         SIH(DEG.)\n')
print (ch[x+175:])
input = ch[x+175:]
entries = re.split("\n+", input)
print (entries)
t=[re.split(":? ", entry, 20) for entry in entries]
print (t)
#m = re.match(r"(\d+).(\d+).(\d+).(\d+)", input)
p=.groups(2)
print (p)

et là il m'affiche mes listes (voir image).

Dans ce cas il ne resterai plus qu'a les selectionner, non?


PS: pour envoyer des fichier c'est comme pour tes mail en pièce jointe (petit trombonne)

[silverboy33]

et oui, pour ta réponse, je préfère avoir mes résultats en liste, car il faut que je sache exactement quelle variable appliquer a quelle valeur.