traiter des chaines de caracteres provenant d'un fichier exterieur

    bonjour, je dispose de chaines de caractere qui sont de la forme suivante :
'Acier X ma 210000 210000 0.3 79000 7800\n'

je désire mettre chacun de ces élément dans une liste en transformant les 5 derniers en reels et en enlevant le \n de fin de ligne.

pour enlever, le \n, pas de probleme.
par contre, comment faire pour obtenir une liste du type ['Acier','X','ma',210000,210000,0.3,79000,7800] ?? j'essai plein de truc, mais rien ne donne de résultat satisfaisant (en général, je fait un truc dans le genre :

res=[]
k=''
for el in liste :
    if el != ' ':
       k=k+el
    elif el == ' ':
       res.append(k)
       k=''
mais la liste obtenue est bien souvent mauvaise. soit mon premier terme devient '7800Acier' et le dernier terme (7800) disparait. soit le dernier terme n'est pas du totu dans la liste.

enfin bref, j'y arrive pô ! un conseil ?

Oui ou alors pour utiliser split il y a bien plus simple :
liste = string.split(chaine)# chaque espace créra une nouvelle entré dans la liste

liste = string.liste(chaine,"separateur") # a chaque séparateur  de la chaine , une nouvelle entré sera mi dans la liste

Ou encore le faire a la main (comme je le fesais que je ne connaisser pas l'éxistence du split)
genre :

chaine = ("blabla blabla bla bla")
seprateur = ' '
liste, decoup = [], ""
while ( i < len(chaine) ):
    if (chaine[i] == separateur ) :
       liste.append(decoupe)
       decoup = ""
    decoup += chaine[i]
    i += 1

par contre, pourquoi que quan ze convertile '0.3' en float, il devient 0.2999999.... moi ze veu pas de 0.29, ze veu 0.3. z'est mon coefficient de poisson pour mon materiaux, et za doit rezter 0.3.
mais d'où donc peu provenir zela et comment zy remédier ??!!

Bienvenu dans le monde binaire

0.3 ne peux pas être représenté en binaire avec un nombre fini de chiffre.
ça fait 0.010011001100...
Après, comme 0.3 ne peut pas être représenté de façon exacte, 0.3 va être converti de façon approchée en binaire d'une façon qui peut varier suivant le langage.
Sur ma machine, en C, il semble le convertir vers 0.3000...119
et en python, vers 0.29999...

sinon...
est-ce que ça a seulement un sens (physique) de faire une différence entre 0.3 et 0.29999 ??
Demande toi ce que représente ton coefficient, si ça a un sens physique de vouloir une précision de 10 chiffres après la virgule dessus, par rapport à sa signification, la façon dont il a été mesuré, les écarts suivant les pièces...


Dobel
[Une fois rien, c'est rien; deux fois rien, ce n'est pas beaucoup, mais pour trois fois rien, on peut déjà s'acheter quelque chose, et pour pas cher]

Convertir '3.0' en 3.0 ce fait par cette méthode :

a = '0.3'
a = eval(a)

Pas très compliqué !!
______
Aéra

enfin, entre utiliser juste float(s) et utiliser eval...
eval va quand même traiter s comme une expression python complète, donc vérifier la syntaxe, puis interprêter. c'est juste 15x plus lent qu'utiliser float

Dobel
[Une fois rien, c'est rien; deux fois rien, ce n'est pas beaucoup, mais pour trois fois rien, on peut déjà s'acheter quelque chose, et pour pas cher]

ben oui, c'est important que ce coefficient reste le meme, c'est ce qui relie le module dans le sens longitudinal de mes fibre au module dans le sens transversal ( ou ce qui relie les déformation dans la longueur aux déformation dans la largeur. c'est pareil). maintenant, vu les calculs, je peu me contenter d'un 0.299999999999999 si je suis capable d'arrondire le résultat du calcul à un ou deux chiffres (grand maximum) apres la virgule. par exemple, comme je le disais, on a la relation El/COEF lt =Et/COEF tl. en supposant que nous conessions les deux modules et le coef selon lt, si je dois calculer le coef selon tl, je ne dois pas afficher un résultat comportant plus de deux décimales (apres, ça n'a plus aucun sens).

donc, comment pouvoir faire ça ? merci.

pour arrondir un flotant, simplement round(f, n) avec n le nombre de chiffres après la virgule,
mais c'est toujours insuffisant pour l'affichage, vu que le problème de la représentation binaire du résultat s'affiche toujours :
>>> round(0.3, 2)
0.29999999999999999

Pour arrondir au moment de l'affichage, il y a une syntaxe pour formatter les chaines à la printf
>>> f=0.3
>>> print "%.2f" % f
0.30

( http://docs.python.org/lib/typesseq-strings.html#l2h-271 )

Dobel
[Une fois rien, c'est rien; deux fois rien, ce n'est pas beaucoup, mais pour trois fois rien, on peut déjà s'acheter quelque chose, et pour pas cher]