Discussion :

[silverboy33]

re,

tu as dis que tu n'avais pas eu de soucis lorsque tu as utilisé ces codes pour le test.txt?

moi j'ai une erreur pour

Code :

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

 m = patJJKKS.match(ln)

il me met

Code :

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

1
2
3
file "donnee.py", line 12, in <module>
   m = patJJKKS.match(ln)
TypeError: can't use a string pattern on a bytes-like object

"donnee.py" étant mon fichier contenant mon prg.




d'un autre coté, j'ai tenté de developper ce que je t'ai poster juste au dessus ac l'image.


en fait le résultat que j'obtiens donne une sorte deliste dans une liste.

en gros:

Code :

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

1
2
3
4
 [[1000    2     0.851894E-01  -0.183440E-01   0.133047E+03   0.112562E+02  -0.945390E+01],
 [1000    3     0.852888E-01  -0.190759E-01   0.133142E+03   0.111593E+02  -0.937005E+01],
 [1000    4     0.851888E-01  -0.190821E-01   0.133000E+03   0.111910E+02  -0.940493E+01],
 [1000    5     0.851954E-01  -0.194251E-01   0.133027E+03   0.112153E+02  -0.942259E+01]]

j'arrive donc maintenant a extraire les grosses lignes, comme pour une liste classique, et je voulais refaire l'opération pour faire de même avec les valeur contenu dans les lignes, mais il me dis que cela n'est pas possible:

Code :

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

1
2
3
NotType is not subscriptable
ou
'NotType' object has no attribute ...

et là je sèche complètement.
si cela peux t'aider voila ma banque:

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
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)
t=str([re.split(":? ", entry, 20) for entry in entries])
print (t)
 
#------------------------------------------------------------------------------------------------------------------------------------------------------------
u=list(eval(t))
print (u)
print (type(u))
o=print (u[3])
print (o)

[silverboy33]

En fait je pense que ton idée de dictionnaire était la meilleur des solutions.

Mais sa ne marche pas chez moi

bonne soirée

[eyquem]

J’ai du mal à te comprendre.



-

faire un comptage classique avec le module io et un seek() après avoir fait une recherche

Qu’est ce que tu entends exactement par là ? Qu’est ce que tu entends par comptage ?



- [QUOTE] Ton code du message #18 est cafouilleux.

Code :

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

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

donne la position, dans la chaîne ch, du premier caractère (ici il s’agit du blanc qui se trouve devant le F de FISS) de la chaîne en argument
ch[x+12] est la position juste après le ’N’ de ’RAYON’



ch[x+12:] est donc la chaîne

Code :

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

1
2
3
apres_rayon == “       J(1)           J(2)           KI             KII         SIH(DEG.)\n
 ---------------------------------------------------------------------------------------\n
 1000    2     0.851894E-01  -0.183440E-01   0.133047E+03   0.112562E+02  -0.945390E+01\n“

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')

consiste à chercher la même chaîne que dans x=ch.find(' FISS RAYON etc etc“ mais dans apres_rayon. Ça ne s’y trouve pas donc la variable y va prendre la valeur -1.

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

Ben moi non plus. Je n’ai écrit aucune des deux lignes ci-dessus donnant x et y dans mes codes.



y.seek(192)

La méthode seek d'un objet-fichier permet de se déplacer dans le fichier ouvert. Le deuxième paramètre précise ce que le premier signifie : 0 pour un déplacement à une position absolue (en partant du début du fichier), 1 pour une position relative (en partant de la position actuelle) et 2 pour une position relative à la fin du fichier. Puisque les balises MP3 que nous recherchons sont stockés à la fin du fichier, nous utilisons 2 et nous déplaçons à 128 octets de la fin du fichier.

http://python.developpez.com/cours/D...le_objects.php

seek() est donc une méthode d’un objet-fichier c’est à dire que ça permet de déplacer le pointeur du fichier dans un fichier (en s’exprimant de façon raccourcie, parce que le fait qu’il s’agisse d’un OBJET-fichier me donne à penser que c’est moins simpliste que ça, mais je ne sais pas exactement ce que ça signifie. J’en reste donc avec mon image mentale d’un pointeur dans le fichier, puisqu’elle permet de s’y reconnaître correctement.)

Tout ceci pour dire qu’il n’y a pas de sens à vouoir appliquer seek() à une chaîne et encore moins à y qui est de par sa définition un entier. D’ailleurs l’instruction y.seek(192) me sort une erreur:

Code :

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

1
2
    y.seek(192)
AttributeError: 'int' object has no attribute 'seek'

- - Dans ton code du message #19:


À mon avis, appeler une variable input n’est pas à faire. Dans mon Python 2.5, ce mot apparaît en violet. Ce ne semble pas être un mot réservé, et il y a peut être quelque chose que je ne sais pas, mais à mon avis il vaudrait mieux éviter de donner ce nom à une variable.


Dans entries = re.split("\n+", input)
re.split() ne fait pas autre chose que splitlines()
entries = input.splitlines() renvoie la liste du fractionnement de input par les newlines, quelles soient d’ailleurs ’\n’ ou ’\r\n’ ou ’\r’.


Je ne comprends pas l’instruction t=[re.split(": ? ", entry, 20) for entry in entries]Qu’est-elle censée faire ? Surtout avec le motif “: ? “ qui ne se trouve pas dans le fichier et le nombre 20 comme argument........


Je ne comprends pas cette ligne ? Elle fait quoi dans le code ? :
#m = re.match(r"(\d+).(\d+).(\d+).(\d+)", input)
La RE qui s’y trouve ne permet pas d’attraper des nombres dans des lignes telles que celle-ci:

Code :

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

 1000    2     0.851894E-01  -0.183440E-01   0.133047E+03   0.112562E+02  -0.945390E+01

De plus un point dans une RE signifie “nimporte quel caractère sauf newline“. Si le point n’est pas suivi de + ou *, il signifie “UN SEUL caractère sauf newline“
Les \d+ ne permettent pas d’attraper des nombres écrits avec leurs signe + ou - et une forme exposant comportant E.


p=.groups(2) a une erreur d’écriture


Je ne vois pas comment ce code te permet d’obtenir les listes dont tu parles.


D’ailleurs je n’arrive pas à lire le fichier resultat.jpg que tu as mis en lien







- Message #21 et #19:

tu as dis que tu n'avais pas eu de soucis lorsque tu as utilisé ces codes pour le test.txt?

En effet. J’ai téléchargé et sauvegardé le fichier test.txt en lien dans ton message #12.

Mon premier code du message #16 sort

Code :

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

1
2
3
4
5
6
7
8
9
10
11
' 1000    2     0.851894E-01  -0.183440E-01   0.133047E+03   0.112562E+02  -0.945390E+01\r\n'
' 1000    3     0.852888E-01  -0.190759E-01   0.133142E+03   0.111593E+02  -0.937005E+01\r\n'
' 1000    4     0.851888E-01  -0.190821E-01   0.133000E+03   0.111910E+02  -0.940493E+01\r\n'
' 1000    5     0.851954E-01  -0.194251E-01   0.133027E+03   0.112153E+02  -0.942259E+01\r\n'
 
 
Contenu du dictionnaire des valeurs trouvees
0.851894E-01  #  -0.183440E-01  #  0.133047E+03  #  0.112562E+02  #  -0.945390E+01  # 
0.852888E-01  #  -0.190759E-01  #  0.133142E+03  #  0.111593E+02  #  -0.937005E+01  # 
0.851888E-01  #  -0.190821E-01  #  0.133000E+03  #  0.111910E+02  #  -0.940493E+01  # 
0.851954E-01  #  -0.194251E-01  #  0.133027E+03  #  0.112153E+02  #  -0.942259E+01  #

Le second et le troisième code du message #16 ainsi que le code du message #17 sortent tous la même chose:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
' 1000    2     0.851894E-01  -0.183440E-01   0.133047E+03   0.112562E+02  -0.945390E+01\r\n'
' 1000    3     0.852888E-01  -0.190759E-01   0.133142E+03   0.111593E+02  -0.937005E+01\r\n'
' 1000    4     0.851888E-01  -0.190821E-01   0.133000E+03   0.111910E+02  -0.940493E+01\r\n'
' 1000    5     0.851954E-01  -0.194251E-01   0.133027E+03   0.112153E+02  -0.942259E+01\r\n'
 
 
Contenu du dictionnaire des valeurs trouvees
cle = 3  :  0.852888E-01  #  -0.190759E-01  #  0.133142E+03  #  0.111593E+02  #  -0.937005E+01  # 
cle = 2  :  0.851894E-01  #  -0.183440E-01  #  0.133047E+03  #  0.112562E+02  #  -0.945390E+01  # 
cle = 5  :  0.851954E-01  #  -0.194251E-01  #  0.133027E+03  #  0.112153E+02  #  -0.942259E+01  # 
cle = 4  :  0.851888E-01  #  -0.190821E-01  #  0.133000E+03  #  0.111910E+02  #  -0.940493E+01  #

Comme on le voit dans les codes, je fait ouvrir le fichier en mode ’rb’.







- Ceci dit, j’avoue que je ne comprends pas grand chose à tes explications sur le fichier .res et le fichier .txt correspondant dans le message #19.

Je ne sais pas quel fichier tu fais ouvrir à tes codes, quelle est sa nature.

Pour ma part, j’ai fait, ouverture en mode ’r' et 'rb'

Code :

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

1
2
3
4
5
6
7
8
9
f = open('test.txt',’r’)
for ln in f:
    print ln
f.close()
 
et f = open('test.txt',’r’)
for ln in f:
    print repr(ln)
f.close()

Il n’y a pas eu de difficulté de lecture du fichier, ce qui montre que le fichier que j’ai sauvegardé n’est pas binaire, au sens qu’il ne contient pas d’octets non-interprétables comme caractères (c’est ce que je crois avoir compris comme différence entre un fichier binaire et un fichier non-binaire. Manière de parler parce que tous les fichiers sont binaires au sens qu’ils sont faits d’octets.)



Pour ce qui est du fichier que tu utilises, je ne sais pas par contre ce qu’il est exactement.
L’erreur que tu obtiens

Code :

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

TypeError: can't use a string pattern on a bytes-like object

et que je ne comprends pas exactement , me fait penser à un problème lié à la nature du fichier (des octets non caractères). Mais comme ton code indique une ouverture en ’r’ et non pas ’rb’, je ne comprends pas vraiment.

Note bien que j’ai de très vague notions sur l’encodage et que je ne comprends pas grand chose à ces questions. Jusqu’à présent je savais faire des bidouilles sur les fichiers avec des seek() des tell() et des find() en ouvrant en mode ’rb’ . Maintenant s’il y a quelque chose de plus particulier dans ton problème, je ne vais pas pouvoir t’aider sans devoir comprendre moi- même préalablement.


De plus comme tu importes le module io et que tu écris les print avec des parenthèses, cela me fait penser que tu dois utiliser soit Python 2.6, soit Python 3.x. Et comme dans ce dernier le traitement des chaînes et des input/output a bien changé, je suis encore plus perdu.







Je ne vais pas baisser les bras, mais il faudrait arriver à prendre les choses dans le bon ordre.

- Tu utilises 2.6 , 2.7 ou 3.x ?

- Quel est le nom du fichier que tu utilises ? C’est un .res ou un .txt finalement ? Je n’y comprends rien à la fin.

-

moi j'ai une erreur pour

Code :
m = patJJKKS.match(ln)il me met


Code :
file "donnee.py", line 12, in <module>
m = patJJKKS.match(ln)
TypeError: can't use a string pattern on a bytes-like object"donnee.py" étant mon fichier contenant mon prg.

Mais quel programme ? Quel code ? Étant donné que tu parles de plusieurs codes, je ne sais pas de quoi tu parles, d’autant que les codes que tu as donnés n’ont pas de sens.



- Veux-tu bien stp faire tourner le code suivant sur ton (ou tes fichiers) et mettre en copié-collé l’intégralité du résultat obtenu.
Indique aussi le nom précis du fichier avec son extension.

Code :

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

1
2
3
4
f = open('test.txt','rb')
ch = f.read()
f.close()
print repr(ch)

Merci.



Désolé mais je n’ai pas eu une minute, hier.

[silverboy33]

voila ce que tu voulais.

pour résumer mes fichiers:
test.txt contient les résultat que je veux extraire
donnee.py contient mon programme servant a extraire ces valeur.

je vais retester ce matin les commande pour voir ce qu'il n'allait pas

merci

[silverboy33]

et au fait oui, j'ai la version 3.1 de python

[silverboy33]

petite question de passage.

lorsque l'on print tout une liste de valeur ou blabla, sait tu si on peux dire a python "au bout du 14ième octets tu arrêtes d'afficher"?

en sachant que

Code :

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

1
2
f.seek(192)
  J11=f.read (14)

ne marchent pas ici

[silverboy33]

ou plutot, non, pas de selectionner au print mais plutot, quand tu me disais:

Code :

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

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

(il m'affiche TOUT le tableau)
et lui dire "je ne veux que les 10 premiers octets", par exemple (mais dans la commande ci dessus)

et ensuite de faire un print du resultat.

------------------------------------------------------------------------
je teste cette façon car ma version ne doit pas etre compatible avec les codes qui marchent chez toi car lorsque je lance le script message #17, il me sors une erreur pour

Code :

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

x = ch.find('SIH(DEG.)')

et me dit

Code :

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

typeerror: expected an object with the buffer interface

et je vois pas ce qu'il me veux :S

[silverboy33]

bon, désolé pour cette quantité de message, mais une info de première importance est tombé!!

C'est tout bon, le dictionnaire marche, le problème était tout simplement que sa marchait pas en 'rb' et qu'il fallait juste mettre 'r'

un grand merci a toi!!!!!!

[silverboy33]

je te tiens au courant quand a l'implantation de cette partie dans mon gros programme =)

mais merci en tt cas pour ton aide ton temps et ta patience!

[eyquem]

Quand je lis en ’rb’ le fichier “test.txt“ de ton message #12 que j’ai téléchargé et sauvegardé,
et que je l’affiche avec repr(ch),
j’obtiens quelque chose qui se termine de la même manière que dans ton fichier “ce que tu m'as demandé.pdf “:

les débuts avant “1.4. CALCUL DES INTEGRALES J“ sont différents (cela correspond aux 200 lignes environs que tu veux sauter),
et les fins à partir de cette ligne “1.4. CALCUL DES INTEGRALES J“ sont identiques, y compris le newlines que je vois être ’\r\n’.

Voilà au moins une chose d’établie.

Sinon, je suis désolé de dire ça, mais tu as une façon assez spéciale de décrire les choses: il y a des choses dans ce que tu écris, on ne sait pas d’où elles sortent, et d’autres on ne sait pas où elles passent. Et ça m’est assez difficile de m’y retrouver.

Par exemple, où as-tu vu que j’aurais écrit
y = ch[x+175+118:].find(' FISS RAYON J(1) etc ?
Ce que tu as appelé ton problème 2, c’est passé où ?

Je ne m’en offusque pas outre mesure mais c’est assez décevant parce que je n’arrive pas à comprendre ce qui ne va pas dans tes codes quand c’est le cas, et je me demande si tu comprends réellement ce qui se passe quand ça marche.



Quand tu me dis que ça marche avec ’rb’ et pas avec ’r’, ça me laisse vraiment pantois puisque ton fichier “ce que tu m'as demandé.pdf “ ne prouve pas seulement que sa fin est identique au fichier que j’ai téléchargé, mais aussi et surtout que tu arrives bien à ouvrir et lire ton fichier en ’rb’. Donc si ça ne marche ensuite pas, ce n'est pas a cause du mode d'ouverture mais parce qu'il y a un boulon mal vissé dans le code utilisé et il serait bon de comprendre quel est le boulon. Personnellement, j’aime bien comprendre réellement.



Je crains en effet qu’il y ait un petit twist à saisir mais que tu ne perçois pas, qui n’est pas déterminant cette fois-ci, mais qui te posera de toutes façons problème dans un futur plus ou moins proche.

Car ’r’ ou ’rb’, ce n’est vraiment pas la même chose si on est sous Windows, ou si on n'est pas sous Windows mais que le fichier vient d’une machine qui l’a écrit sous Windows.
Le code suivant le montre, quel que soit le SO sous lequel on est parce que j'ai mis des '\r' dans le texte à écrire.

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
f = open('orleans','w')
f.write('CHLOE'\
        '\r\ndavid'\
        '\r\nGWENN'\
        '\r\npaule'\
        '\r\nROSIE'\
        '\r\nthais')
f.close()
 
#########################################
 
 
f = open('orleans','r')
 
ch = f.read()
print 'chaine du fichier:',repr(ch)
x = ch.find('paule')
print "position de 'paule' dans la chaine du fichier:",x
 
print
f.seek(x)
print 'fin du fichier a partir de la position',x,':',repr(f.read())
 
f.close()
 
 
print '\n=================================\n'
 
 
f = open('orleans','r')
rd = f.readline()
print '1ere ligne:',repr(rd)
rd = f.readline()
print '2ieme ligne:',repr(rd)
rd = f.readline()
print '3ieme ligne:',repr(rd)
t =  f.tell()
print 'position de la 4ieme ligne: t =',t
fin = f.read()
print 'fin a partir de t:',repr(fin)
 
print
f.seek(0)
ch = f.read()
print 'ch[t:] =',repr(ch[t:])
 
f.close()

Les résultats de ce code sont incohérents.
Ça tient au fait qu’en mode d'ouverture ’r’, find() ne trouve pas des positions (déterminées dans des chaînes) qui soient identiques aux positions du pointeur dans le fichier telles que tell() les donne.



Quand on met des instructions

Code :

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

1
2
3
ch = f.read()
x = ch.find('SIH(DEG.)')
f.seek(x)

on positionne le pointeur du fichier juste devant la lettre ’S’ dans le fichier, à condition d’avoir ouvert en ’rb’.

Si on a ouvert le fichier en ’r’, le pointeur ne sera pas amené exactement à cette place mais à un certain nombre de caractères en avant de cette position. La valeur de ce certain nombre est celle du nombre de ’r’ dans le fichier avant cette position: s’il n’y en a pas, fort bien, le pointeur sera à l’endroit voulu, mais il le sera sans qu’on sache pourquoi.

S’il y a des ’\r’ dans le fichier, mais qu’on ne veuille pas écrire à une position donnée, mais faire autre chose qui ne dépend pas de la position précise: fort bien encore, ça ne portera pas à conséquence. C’est le cas de la recherche avec des regex: on se place plus ou moins loin en avant de ce motif 'SIH(DEG.)' et on lance re.search ou autre, qui va grignoter des caractères avant de tomber sur ceux qu’on veut détecter.

Mais si on veut faire quelque chose de précis, ça n’ira plus, et on ne comprendra pas pourquoi. C’est ce qui risque d’arriver pour ton problème 2, s’il tient encore, parce que je ne sais pas où il est passé.....

J'attends la suite des problèmes.

Cordialement.

[silverboy33]

de retour,
désolé, je suis pas mal en mouvement en ce moment.

Bon, en ce qui concerne le programme, tout à l'air de fonctionner comme il devrait... sauf sur un point, tout autre que les précédent.

comme tu l'as surement compris, je fais un programme avec des itérations.
a la fin de chaque itération, il me calcul des coordonnées, qu'il faut que je conserve.

j'ai donc écrit ceci

Code :

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

1
2
3
4
5
  import io 
 
  i=open("new_points.dat","a+")
  i.write(".poi i %d x %d y %d\n" % (10000+n+2, xct, yct))
  i.close()

le soucis que j'ai, c'est qu'il faut que j'écrive un 'return' a la dernière ligne a chaque du fichier dans lequel les coordonnées son stoquées, et si j' écris:

Code :

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

1
2
3
4
5
6
7
8
9
n=0
while n<3:
 i=open("new_points.dat","a+")
 i.write(".poi i %d x %d y %d\n" % (10000+n+2, 65, 45))
 i.close()
 i=open("new_points.dat","a")
 i.write("return\n")
 i.close()
 n=n+1

il m'affiche

Code :

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

1
2
3
4
5
6
7
 
.poi i 10002 x 65 y 45
return
.poi i 10003 x 65 y 45
return
.poi i 10004 x 65 y 45
return

et je ne veux pas tout ces 'return' au milieu, je n'en veux qu'a la fin....


vois tu mon problème?
aurais tu une solution magique? =)

cordialement,

[eyquem]

Je pense que ta question est mal posée. Mais comme je n’ai pas envie de chercher la bonne question avant de donner la bonne réponse que tu attends, je fais dans la facilité: je réponds à ta question, telle qu’elle est posée, tout en prévoyant que cette réponse ne répondra pas à ton attente de résolution. Ça t’obligera à poser le problème correctement.

Donc à ton problème tel qu’il est exposé, on doit répondre qu’il suffit de sortir i.write("return\n") de la boucle.

Code :

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

1
2
3
4
5
6
7
8
9
10
n=0
while n<3:
    i=open("new_points.dat","a+")
    i.write(".poi i %d x %d y %d\n" % (10000+n+2, 65, 45))
    i.close()
    n=n+1
 
i=open("new_points.dat","a")
i.write("return\n")
i.close()

Mais je pense que ni le code que tu as écrit , ni celui que je viens d’écrire ne correspondent à ce que tu veux vraiment faire et qu’il y aura une question suivante. Si je l’anticipe bien, la réponse pourrait être l'extrait suivant d’un de mes posts que j’avais sélectionné en te conseillant de les lire:

* quand un fichier est ouvert en mode 'a' ou 'a+', toutes les opérations d'écriture s'effectuent à la fin du fichier. Même si le pointeur a été déplacé dans le fichier avec seek(), il est toujours ramené à la fin du fichier avant qu'une quelconque opération d'écriture soit effectuée. Ainsi, les data existantes ne peuvent pas être écrasées.

Ce qui signifie que ce n'est pas en 'a' ou 'a+' ni même en ’ab’ ou ’ab+’ que tu dois ouvrir ton fichier mais en 'rb+' pour y pouvoir y écrire à partir de n’importe quelle position que tu voudras dans le fichier.

[silverboy33]

si je me met en 'rb+', le shell m'affiche une erreur me disant qu'il ne peut pas écrire sur mon fichier car ce son des 'str' et non des bytes ou des buffer dans le commandes file.write.

Désolé pour ma non clarté dans mes explications
je reprend donc.
a la fin de chaque itération je dois ecrire la ligne: .poi i 10002 x 65 y 45, avec les nombre qui vont changer a chacunes d'entre elles.
j'ai donc écris le script suivant:

Code :

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

1
2
3
4
5
6
7
8
9
import io
n=0
 
while n<3:
 file=open("new_points.dat","rb+")
 file.write(".poi i %d x %d y %d\n" % (10000+n+2, 65, 45))
 file.write("return\n")
 file.close()
 n=n+1

le problème est le suivant.
pour que e fichier new_points.dat soit lisible, il me faux un return à la toute dernière ligne, et uniquement sur cette ligne.
je voudrai donc qu'il m'affiche:
iteration 1:

Code :

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

1
2
.poi i 10002 x 65 y 45
return

iteration 2:

Code :

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

1
2
3
.poi i 10002 x 65 y 45
.poi i 10003 x 65 y 45
return

itération 3:

Code :

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

1
2
3
4
.poi i 10002 x 65 y 45
.poi i 10003 x 65 y 45
.poi i 10004 x 65 y 45
return

...

je ne sais pas si on peux réécrire par dessus, ou le supprimer d'abord et écrire ensuite...
mais vois tu mon soucis?


Je vais aller re re lire tes posts pour tenter de trouver le pourquoi de mon pb avec 'rb'.

merci,

[eyquem]

mais vois tu mon soucis?

Pas tout à fait. (au fait, il n’y a pas de s à souci au singulier)
Ton problème de return est bien celui avec lequel je prévoyais que tu allais revenir.
Mais quelque chose reste peu clair.

Tu écris

pour que le fichier new_points.dat soit lisible, il me faux un return à la toute dernière ligne, et uniquement sur cette ligne.

Mais à quel moment le fichier doit-il être lisible, c’est à dire est-il lu ?
Parce que tant qu’on ne cherche pas à lire un fichier illisible, il n’y a pas de problème.
Si donc la lisibilité était nécessaire après tout un traitement de plusieurs tours de boucle, il suffirait de faire ce qu’il faut à la fin du fichier (mettre un return) après le traitement (dans ton cas une itération) pour qu’il soit lisible ensuite.
Mais ceci est ma réponse précédente et elle ne convient pas, ce à quoi je m’attendais.



Cependant dans le code de ton message précédent (#33) il n’y a toujours pas d’instruction file.read(....) qui permettrait de voir à quel stade de l’algorithme ton fichier est lu.

Je suppose qu’en fait tu expurges ton code de tout le traitement de données pour alléger l’exposition de ton problème, mais qu’un traitement intervient bien entre les instructions

Code :

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

1
2
3
file=open("new_points.dat","rb+")
#et
file.write(".poi i %d x %d y %d\n" % (10000+n+2, 65, 45))

et que c’est lors de ce traitement qu’il y a lecture du fichier.

D’où je déduis que c’est lorsque tu écris après le traitement d'une boucle, en étant obligé de ne laisser qu’un return dans le fichier exclusivement à la dernière ligne, que tu es obligé d’écrire soit réécrivant par dessus le return soit en supprimant d’abord le return existant pour écrire ensuite.

Dès lors les affichages que tu souhaites obtenir ne sont que des affichages de vérification que tu souhaites placer à la fin de chaque tour d’itération.

Je trouve un tel algorithme un peu particulier: ouvrir un fichier à chaque tour de boucle, le lire à condition qu’il n’y ait qu’un return à sa fin, faire le traitement, écrire à la fin du fichier avec un nouveau return à la fin en se débarrassant d’abord du précédent, et on referme le fichier.
je pense que si on regardait de près ton algorithme, il serait sans doute possible de proposer un autre déroulement.

Enfin bon, c’est comme ça, on peut aussi penser que tu es obligé de procéder ainsi. Mais c’est parce que je trouve un peu particulier que je souhaitais obtenir confirmation que le programme procède bien ainsi que je viens de le décrire.
Peux-tu me confirmer ?







Ceci étant, “supprimer d’abord le return précédent“, c’est plus simple à écrire que de le faire concrètement.

D’ailleurs, qu’est ce que ça voudrait dire concrètement, “supprimer d’abord le return précédent“ ?

Peut être cela pourrait-il se faire en déplaçant le EOF (end of file) de sa position après le return à une position avant le return.
Mais je ne sais pas en quoi consiste exactement le EOF en réalité. Et de toutes façon, faire ainsi consisterait tout de même à détecter où se trouve le return terminal, à positionner le pointeur du fichier devant lui , à écrire le EOF nouveau, puis peut être refermerait-on le fichier et le réouvrirait-on en ’a’ ou ’a+’.
Mais pour déplacer le EOF (si tant est que ça veuille dire quelque chose), il faudrait de toutes façons se mettre en mode ’rb+’.





Donc,
je ne vois qu’une solution, et c’est bien ce que je voyais se profiler, il faut ouvrir ton fichier en ’rb+’, se déplacer dedans à volonté et écrire où l’on veut, c’est à dire à partir de devant le return pour l’écraser.

Dès lors, le seul problème est le suivant:

le shell m'affiche une erreur me disant qu'il ne peut pas écrire sur mon fichier car ce son des 'str' et non des bytes ou des buffer dans le commandes file.write.

Et là je cale, je ne vois pas pourquoi cela se passe ainsi. Je ne comprends même pas le type d’erreur.

Est-ce le type de ton fichier, lié son extension, qui pose problème et impose des bytes comme fluxs entrant et sortant du fichier ?
(je sais y a pas de s à fluxs en fait ).
Mais qu’est ce que ça veut dire un flux de bytes ?
Est-ce qu’il s’agirait de refiler à ton fichier des “C structs “ ? Je lis ça dans la Library Reference sur le module struct
http://www.python.org/doc/2.5.2/lib/module-struct.html
Mais là je ne suis pas du tout compétent.

Le fichier que tu cherches à ouvrir en ’rb+’ est-il celui que tu as mis en lien ce que tu m'as demandé.pdf dans le message #24 ?

[silverboy33]

bon on va schématiser un peu tout se qu'il se passe

script python----->ouvre mon seconde programme (de calcul de structure)
---------------------->mon programme tourne grâce a un script.dat (faisant lui même appel a un second script: new_point.dat celui dont on parle) indépendant
-------------------------->mon programme se ferme grace a python
----------------------------->mon programme me créer un .res (résultat du calul)
--------------------------------> python va chercher et lire ce fichier et en stocker les valeur (le dictionnaire que tu as écris précédemment)
----------------------------------->python fait un rapide calcul pour me donnée des coordonnée de points
-------------------------------------->il me stocke ces coordonnée dans new_point.dat
-----------------------------------------> fin de la première itération

problème:

le script indépendant de mon programme de calcul de structure, script.dat, fait donc appel a new_point.dat.
Lorsque ce dernier est appelé par script.dat, il faut que je puisse le fermer, pour que script.dat puisse finir, que l'on reparte au script python et boucler la boucle.

Cette opération de fermeture se fait en ajoutant return en dernière ligne de new_point.dat.

autre précision

dans new_point.dat je veux le résultat de toute mes itération les unes a la suite des autres, et non a la place de la précédente (d'où la 'a+', que j'avais écris).

voici new_point.dat:

Code :

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

1
2
3
4
5
6
  import io 
 
  i=open("new_points.dat","a+")
  i.write(".poi i %d x %d y %d\n" % (10000+n+2, xct, yct))
  i.write("return\n")
  i.close()

je pensais donc supprimer le 'return' de l'itération précédente pour écrire par dessus,



est ce plus clair?, ou non

[eyquem]

On progresse.


Préalable:

Pour moi, comme pour les définitions que j’ai consultées, une itération est la répétition mutiple de quelque chose. Une itération est donc composée de plusieurs étapes, chaque étape étant le processus unitaire d'une répétition , avec une petite chose qui change à chaque étape.

Dans un programme, une itération se fait au moyen d’une boucle: soit for, soit while.
Une boucle est composée de plusieurs tours.
Quand j’emploie le terme tour de boucle, cela désigne ce que tu appelles toi une itération.






Je résume ce que j’ai compris:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
n = 0
while n<3:
    file=open("new_points.dat","rb+")
    ...instructions: lecture de données...
    file.write(“return\n“) # A
    file.close()

    ...instructions : crée .res, Python lit .res, calcul des coordonnées....

    i=open("new_points.dat","rb+")
    i.write(".poi i %d x %d y %d\n" % (10000+n+2, xct, yct))
    i.write("return\n")  # B
    i.close()

A : Il ya nécessairement cette instruction file.write(“return\n“) ici puisque tu dis:

Lorsque ce dernier [new_point.dat] est appelé par script.dat, il faut que je puisse le fermer, pour que script.dat puisse finir, que l'on reparte au script python et boucler la boucle.

Cette opération de fermeture se fait en ajoutant return en dernière ligne de new_point.dat.

Il y a donc non pas une seule, mais deux instructions .write(“return\n“) dans new_point.dat, ou alors je n’ai rien compris.

C’est donc à deux endroit dans chaque tour de boucle qu’il faut procéder à une écriture dans new_point.dat:
- une première fois il ne s’agit que d’écrire ’return\n’ : A
- une deuxième fois il s’agit d’écrire (".poi i %d x %d y %d\n" % (10000+n+2, xct, yct) et ’return\n’ : B

Dans les deux cas, il faut se débrouiller pour écrire de façon que le fichier new_point.dat résultant après écriture n’ait bien toujours qu’un seul ’return\n’ en dernière ligne.







Bon. Une fois ou deux fois par boucle, ça ne change rien de fondamental.

Il faut a mon avis
- ouvrir en mode ’rb+’
- déterminer la position de ’return\n’, c’est à dire la position de la première lettre de ’return\n’
- placer le pointeur du fichier à cette position
- lancer l’écriture
- et faire close()

Le mode ’r+’ est obligatoire, d’après moi.
Car
- les modes ’a’ et ’a+’ ne permettent que d’écrire en fin de fichier, pas au milieu.
- les modes ’w’ et ’w+’ ne permettent que d’écrire en début de fichier, c’est à dire qu’on écrase tous les bytes qui se trouvent au début et comme on termine par un EOF, ça revient en fait à écraser complétement le fichier. Je ne vois pas la différence entre ’w’ et ’w+’


Le mode ’b’ permet de se déplacer de façon précise dans le fichier sans se casser la tête.







Finalement on est ramené au problème de départ

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.

puisque tu as écrit

si je me met en 'rb+', le shell m'affiche une erreur me disant qu'il ne peut pas écrire sur mon fichier car ce son des 'str' et non des bytes ou des buffer dans le commandes file.write.

À condition qu’il soit bien question de new_point.dat dans cet extrait.

Il faut que tu arrives à trouver comment écrire dans un fichier .DAT, à mon avis.


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



Sinon tu en seras réduit à réécrire un nouveau fichier new_point.dat pour chaque ecriture, càd non seulement à chaque tour de boucle mais à chacune des deux écritures dans new_point.dat dans chaque tour de boucle.


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



Ou alors, si c'est le fait d'ouvrir en 'b' qui pose probleme, tu peux essayer d'ouvrir en 'r+' seulement et, si la fin de fichier est bien toujours proprement 'return\n', faire:

Code :

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

1
2
3
4
5
6
7
while n<3:
 file=open("new_points.dat","rb+")
 file.seek(-7,2)
 file.write(".poi i %d x %d y %d\n" % (10000+n+2, 65, 45))
 file.write("return\n")
 file.close()
 n=n+1

[silverboy33]

j'ai déjà tenter cette petite astuce:

Code :

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

1
2
3
4
5
6
7
8
9
import io
n=0
while n<3:
 file=open("new_points.dat","r+")
 file.seek(-7,2)
 file.write(".poi i %d x %d y %d\n" % (10000+n+2, 65, 45))
 file.write("return\n")
 file.close()
 n=n+1

mais il me met l'erreur suivante:

Code :

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

1
2
file.seek(-7,2)
IOError: can't do nonzero end-relative seeks

il n'aime pas le '2' à la fin, pourtant je sais que c'est ce qu'il faut mettre pour partir de la fin de la ligne. et si je ne le met pas, là c'est la la valeur négative qu'il n'aime pas du tout.

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

sinon, concernant le 'rb', ou 'r', je ne sais pas, il me met:

Code :

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

TypeError: write() argument 1 must be bytes or buffer, not str

il n'y a que en 'a' et 'a+' que ça marche, je sais pas trop pourquoi

[eyquem]

Tu utilises Python 3.1. Or

Dans Python 3.1, il a été décidé d'écrire à nouveau toute la couche I/O de Python 3.0 en C tout en gardant la même interface et le même comportement que la version Python.

Je suis donc allé voir sur la doc officielle 3.1 si quelque chose n’aurait pas changé dans la fonction write().
Je n’en ai pas l’impression.
Cependant je vois

file.write(str)
Write a string to the file.

Ça pose un problème, parce que l’erreur est

TypeError: write() argument 1 must be bytes or buffer, not str

Il ne faut pas que ce soit un string......

Que veut dire cette erreur ? Elle concerne la fonction write(), ou ce qu’est habilité à recevoir le fichier comme écriture ?



Sinon, dans le même lien que ci-dessus, ça continue par:

Notons tout de même que l'implémentation Python de la couche I/O a été conservée en parallèle dans le module _pyio pour permettre de vérifier le comportement de la couche C et faciliter l'évolution du module (on peut tester sur la version Python puis recoder en C ensuite).

Tu devrais essayer d’importer _pyio au lieu de io . Va savoir.

[eyquem]

J’ai trouvé ce que signifie “déplacer le EOF“

C’est réalisable en utilisant la fonction truncate(). Elle est disponible dans 2.5 , aussi ai-je pu essayer.

J’ai fait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
f = open('bru.txt','r+')
print repr(f.read())
f.seek(-4,2)
x = f.tell()
f.truncate(x)
f.close()
 
print '--------------'
 
f = open('bru.txt','r')
print repr(f.read())
f.close()

Et ça marche !

'lkjhsjdhf asdj 98y98475 hgwuyhdfihtrASdfert'
--------------
'lkjhsjdhf asdj 98y98475 hgwuyhdfihtrASd'

Peut être peux-tu arriver à sectionner l’extrémité de ton fichier 7 caractères avant la fin, avant de le réouvrir en ’a’ ou ’a+’ afin de le compléter.

Mais pour faire truncate() il faut l’ouvrir en ’r+’ aussi. Ce qui va peut être donner le même problème sur ton fichier, à savoir qu’il va y avoir refus de le faire.

[silverboy33]

grande nouvelle!!

j'ai trouver la solution pour faire ce que je voulais.
C'est surement pas très beau, mais bon sa à l'ère de fonctionner
voici le code:

Code :

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

1
2
3
4
5
6
7
8
9
10
import io
n=0
while n<10:
 file=open("new_points.dat","r+")
 file.seek(24*n)
 s=(".poi i %d x %d y %d\nreturn\n" % (10000+n+2, 65, 45))
 print (s)
 file.write(s)
 file.close()
 n=n+1

on y arrive! =)

merci!!!


je vais maintenant si le tout marche ensemble