Discussion :

[niepoc]

bonjour
débutant sous python

je souhaiterais faire un tableau à partir d'un fichier.txt de cette forme

0 120 0 120 0.25 0 0.25
120 0 240 0 240 0.25 120 0.25
240 0 360 0 360 0.25 240 0.25
0 0.25 40 0.25 40 0.5 0 0.5
40 0.25 80 0.25 80 0.5 40 0.5
80 0.25 120 0.25 120 0.5 80 0.5
120 0.25 160 0.25 160 0.5 120 0.5
160 0.25 200 0.25 200 0.5 160 0.5
200 0.25 240 0.25 240 0.5 200 0.5
240 0.25 280 0.25 280 0.5 240 0.5
280 0.25 320 0.25 320 0.5 280 0.5
320 0.25 360 0.25 360 0.5 320 0.5
0 0.5 22.5 0.5 22.5 0.75 0 0.75
22.5 0.5 45 0.5 45 0.75 22.5 0.75
45 0.5 67.5 0.5 67.5 0.75 45 0.75
67.5 0.5 90 0.5 90 0.75 67.5 0.75
90 0.5 112.5 0.5 112.5 0.75 90 0.75
112.5 0.5 135 0.5 135 0.75 112.5 0.75
135 0.5 157.5 0.5 157.5 0.75 135 0.75

en fait je voudrais récupérer ces données, chacune séparées de deux espaces et les mettre dans un tableau de même forme. ça me donnerait un tableau, dans mon cas de 600000 lignes et 8 colonnes.

voilà le début de mon code mais je bloque, erreur pour le split, je pense qu'aprés il faut faire une boucle pour remplir le tableau.

merci pour l'aide

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#! /usr/bin/env /DATA/LIENS/exploit/bin/python
# -*- coding: utf-8 -*-
 
# -*- coding: latin-1 -*-
 
file_coord='/home/thomas/depot/MT/SSMI_EMIS/cells_boundaries.txt'
file_data='/home/thomas/depot/MT/SSMI_EMIS/SSMI_EMISMEAN_01.dat'
 
from numpy import *
 
# ouverture du fichier texte 
f=open(file_coord,'r')
lignes =f.readlines().split("  ")
f.close()

pour info, je bosse sur une plate forme linux

[Gamal le Celte]

Peut être en faisant :

Code :

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

lignes =f.readlines().split(None,8)

ou None est sans séparateur alors c'est espace par défaut et 8 le nombre de mots a compter. Si il y a plus de mots (ici 8) tout le reste est monté.

Ca doit marcher, je pense.

[eyquem]

readlines() est une méthode de fichier qui produit une liste.
split() est une méthode de chaine qui produit une liste

split() ne peut pas s'appliquer à la liste que produit f.readlines()

readline() produit une chaîne
Mais il faudra mettre une boucle
Au lieu d'une bête boucle, une list comprehension sera mieux

PS
Pardon, je précise: pour utiliser une list comprehension , il faut itérer dans le fichier comme un itérateur, sans la fonction readline()

[niepoc]

merci pour ces réponses mais je ne vois pas comment utiliser une liste dans mon cas

je me penche dessus, je vous tiens au courant

[niepoc]

j'ai essayé avec cette ligne de commande

Code :

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

lignes =f.read().split("  ")

j'obtiens une en fait une succession de caracrtères mais pas de la forme que je veux

'0', '0', '120', '0', '120', '0.25', '0', '0.25\n120', '0', '240', '0', '240', '0.25',

j'ai le /n qui correspond à un changement de lignes et surtout les données se suivent et ne sont pas en colonnes (ici normalement 8 colonnes.

merci pour l'aide

[eyquem]

Je n'utilisais pas numpy jusqu'à présent mais le peu que j'en savais me faisait penser que l'obtention de ton tableau passait par la création d'une liste de 19 (= nombre de lignes dans le fichier que tu donnes) sous-listes de 8 nombres, puis la création du tableau à partir de cette liste.

Pour obtenir la liste, je pensais que tu voulais faire

Code :

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

1
2
3
4
5
6
7
8
9
f = open('valeurs.txt')
li = []
while 1:
    ln = f.readline().split()
    if ln:
        li.append(ln)
    else:
        break
f.close()

Ce qui peut aussi s'écrire en utilisant un itérateur sur le fichier

Code :

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

1
2
3
4
5
f = open('valeurs.txt')
li = []
for ln in f:
    li.append(ln.split())
f.close()

Et j'ai suggéré d'utiliser une list comprehension

Code :

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

1
2
3
f = open('valeurs.txt')
li = [ ln.split() for ln in f ]
f.close()

Je me suis mis à numpy pour vérifier qu'ensuite la création du tableau est sans encombre

Code :

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

1
2
3
4
5
from numpy import *
f = open('valeurs.txt')
li = [ ln.split() for ln in f ]
f.close()
tableau = array(li)

Si on aime la concision:

Code :

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

1
2
3
4
from __future__ import with_statement 
from numpy import *
with open('valeurs.txt') as f:
    tableau = array([ln.split() for ln in f])

Notas:

- La première ligne du fichier que tu donnes a 7 valeurs et non pas 8.
J'en ai rajouté une pour que tous ces codes tournent bien.


- J'avais commencé à écrire un premier code

Code :

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

1
2
3
4
5
6
7
8
9
from numpy import *
f = open('valeurs.txt')
li = []
ln = 'go'
while ln:
    ln = f.readline().split()
    li.append(ln)
f.close()
tableau= array(li)

mais j'obtenais l'erreur

ValueError: setting an array element with a sequence

parce qu'à la fin de l'itération ln prenait la valeur "", ce qui ajoutait une liste vide comme dernier élément de li. Quand array tombait sur cette dernière sous-liste vide, différente en longueur des précédentes sous-listes , il bloquait.


PS

S'il est possible de créer l'array sans passer par la création préalable de la liste li, ça m'intéresse de savoir comment il faut faire.

[Gamal le Celte]

Voici un code d'expemple simple qui marche.
C'est peut être une idée à voir......

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
 file_coord='C:\Le chemin du fichier\LeFichier.txt'
 
        donnee = ''
 
        f=open(file_coord,'r')
        lignes =f.readlines()
        f.close()
 
        nbrec = len(lignes)
 
        for rec in range(nbrec):
            laligne = lignes[rec].split(None,8)
            for rec2 in range(8):
                donnee = donnee + ';' + str(laligne[rec2])
            donnee = donnee + '\n'
 
        print donnee

[niepoc]

merci pour la réponse

voilà le code

Code :

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

1
2
3
4
5
6
7
8
fc=open(file_coord,'r')
 
#boucle pour créer le tableau
for ligne in fc:
    tab.append(ligne.split())
fc.close()
 
tab=array(tab)

j'obtiens, une partie de la réponse

['0' '0' '120' '0' '120' '0.25' '0' '0.25']
['120' '0' '240' '0' '240' '0.25' '120' '0.25']
['240' '0' '360' '0' '360' '0.25' '240' '0.25']
['0' '0.25' '40' '0.25' '40' '0.5' '0' '0.5']
['40' '0.25' '80' '0.25' '80' '0.5' '40' '0.5']
['80' '0.25' '120' '0.25' '120' '0.5' '80' '0.5']
['120' '0.25' '160' '0.25' '160' '0.5' '120' '0.5']
['160' '0.25' '200' '0.25' '200' '0.5' '160' '0.5']

novice sur python, est ce que c'est une chaine de caractères ou d'entiers.

je souhaiterais avoir des entiers pour effectuer des opérations. comment dois je m'y prendre pour les transformer?

merci par avance

[eyquem]

À propos de ton message #5:

split( s[, sep[, maxsplit]])

«If the optional second argument sep is absent or None, the words are separated by arbitrary strings of whitespace characters (space, tab, newline, return, formfeed). If the second argument sep is present and not None, it specifies a string to be used as the word separator.»
http://www.python.org/doc/2.5.2/lib/node42.html#l2h-376

Ce qui veut dire que quand il n'y a pas d'argument sep, les mots sont distingués par toute suite de longueur arbitraire de caractères appartenant à l'ensemble "whitespace characters":
blanc " ", tab '\t', newline '\n', return '\r' , formfeed '\f'
Et que par contre, quand il y a l'argument sep, la séparation des mots se fait uniquement sur la base de ce séparateur précis, y compris sa longueur.

Donc puisque tu utilises split(" ") les caractères '\n' ne sont pas considérés comme séparateurs.

Remarque: ton fichier doit avoir des séparateurs qui sont deux blancs " ", mais dans le fichier que tu donnes dans le premier message, le séparateur est UN seul blanc " ".



Pour répondre à ta question:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
from numpy import *
 
fc=open(file_coord,'r')
tab = []
for ligne in fc:
    tab.append(ligne.split())
fc.close()
 
tab=array(tab)
print tab.ravel()[0:12]
for x in tab.ravel()[0:12]:
    print type(x)

montre que les éléments du tab final (parce que le tab initial est une liste) sont des chaînes

ravel() est une méthode de numpy qui aplatit un tableau et en fait une liste unidimensionnelle.
J'ai mis [0:12] pour ne pas imprimer les 19x8 éléments

«je souhaiterais avoir des entiers»

Des réels tu veux dire ? Sinon je ne vois pas ce qu'il faut faire.





Pour obtenir ce que tu veux 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
fc=open(file_coord,'r')
tab = []
for ligne in fc:
    ln = ligne.split()
    lnum = [ float(x) for x in ln]
    tab.append(lnum)
fc.close()
print tab
print tab
 
tab=array(tab)
print tab.ravel()[0:12]
for x in tab.ravel()[0:12]:
    print type(x)

Nota:

une list comprehension est une manière de définir une liste non pas en y incluant ses éléments les uns apreés les autres mais en donnant une expression à partir de laquelle le programme se débrouille pour la construire tout seul.
C'est un procédé absolument essentiel en Python. Au début on se gratte un peu le crâne devant mais on s'y fait vite et on en goûte rapidement l'intérêt (rapidité, concision).
Tu devrais t'y mettre.
Dans le code ci-dessous il y a deux list comprehension imbriquées.


Le with_statement est une simplification des opérations sur les fichiers: il ferme un fichier après l'avoir exploité sans qu'on ait à écrire un f.close()
C'est disponible sans importation dans Python 2.6
Je suis sous 2.5, c'est pour ça que je suis obligé de mettre from __futur__ import with_statement en toute première (position obligtoire) ligne.


Le plus concis qui soit

Code :

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

1
2
3
with open('vals.txt') as f:
    li = [ [float(x) for x in ln.split()] for ln in f]
tab = array(li)

[niepoc]

merci pour cette réponse

j'ai la même chose à faire avec un fichier binaire

je m'y mets, je vais m'inspirer de cette aide

[niepoc]

dans un premier temps désolé pour la signature j'arrive pas à la changer

je bosse sur une plateforme linux avec python 2.4.2

sinon je bloque pour les fichiers binaires, j'en ai jamais manipulé

je sais que j'ai 8 floats par ligne, le khexedit me signale que c'est du 32 bits signés (déjà je bloque là) et pour la lecture, je dois donc obtenir 8 colonnes et là ça bug

l'algo me semble être
ouvrir le fichier
le lire
le mettre en forme sur huit colonnes et convertir en float

j'ai tapé un début de code mias ça bug au read et je sais pas si c'est la bonne conversion avec la ligne suivante

Code :

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

1
2
3
4
5
6
fd=open(file_data,'rb')
for ligne in fd:
	car =(ligne.read()) 
	val =[binascii.b2a_hex(x) for x in car]
	tabdata.append(val)
fd.close()

merci pour l'aide je continue à chercher

[dividee]

je sais que j'ai 8 floats par ligne, le khexedit me signale que c'est du 32 bits signés (déjà je bloque là) et pour la lecture, je dois donc obtenir 8 colonnes et là ça bug

Il n'y a pas de notion de lignes dans un fichier binaire; le concept de lignes est propre aux fichiers textes. Et ne te fie pas à ce que te dit khexedit, il n'a aucun moyen de connaître le format de ton fichier, c'est à toi de le connaître.

Si les éléments du tableau sont enregistrées en un bloc contigu, le constructeur ndarray de numpy permet une initialisation facile.

Par exemple, si les éléments du tableau sont des floats au format IEEE 32 bits, rangés de façon contigue en row-major order, et le tableau fait 600000 lignes et 8 colonnes, cela devrait être:

Code :

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

1
2
3
4
5
from numpy import *
f = open(file_data,'rb')
data = f.read()
f.close()
tab = ndarray(shape=(600000,8), buffer=data, dtype=float32, order='C')

[niepoc]

merci pour cette réponse

j'ai lancé le programme mais une erreur est intervenue

File "test.py", line 36, in <module>
tabdata = ndarray(shape=(660066,8), buffer=data, dtype=float32, order='C')
TypeError: buffer is too small for requested array

je vais me pencher dessus, si quelqu'un a des explications et une idée je suis preneur

merci d'avance

[niepoc]

je pense que j'ai trouvé la solution

en fait j'ai calculé la longueur de mon

Code :

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

data = fd.read()

j'obtiens 9725856

pour savoir mon nombre de lignes je l'ai divisé par 32 pour 32 bits en fait je me demande si c'est le bon raisonnement vu que j'ai jamais manipulé du binaire

voilà le code

Code :

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

1
2
3
4
5
 
fd=open(file_data,'rb')
data = fd.read()
fd.close()
tabdata = ndarray(shape=(303933,8), buffer=data, dtype=float32, order='C')

ça semble correct je vérifie et je vous tiens au courant

merci pour l'aide et pour les commentaires à venir

[dividee]

Il faut effectivement diviser par 32, mais le raisonnement n'est pas celui-là; chaque nombre réel est codée sur 32 bits, soit 4 octets. Il y a 8 nombres par lignes, cela donne donc 8x4 = 32 octets par lignes; en divisant la taille du buffer par 32 tu obtiens bien le nombre de lignes.
Mais cela ne reste qu'une possibilité, je ne peux pas deviner le format réel de ton fichier. Les réels peuvent aussi être codés en IEEE 64 bits, ou dans un format autre (point fixe?); il peut y avoir un en-tête en début de fichier, des contraintes d'alignements, ...

[niepoc]

j'ai deux questions techniques

comment fait t on pour obtenir à partir d'une liste, en forme vectuer, un tableau d'une colonne?

[60.0, 180.0, 300.0, 20.0, 60.0, 100.0, 140.0, 180.0, 220.0, 260.0]

et comment fait on pour concatener deux tableaux d'une colonne pour obtenir deux colonnes sachant qu'ils ont le même nombre de lignes.

Merci d'avance

[Antoine_935]

<coupé>

Au temps pour moi, je n'avais pas vu qu'on parlait d'array.
Quoi qu'il en soit, pour mettre deux colonnes ensemble, il suffit de créer une liste qui regroupe ces colonnes.

Mais bon, la notion de ligne / colonne c'est très très vague... ça dépend de la manière dont on voit un tableau.

[eyquem]

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
from numpy import *
 
li = [60.0, 180.0, 300.0, 20.0, 60.0, 100.0, 140.0, 180.0, 220.0, 260.0]
lx = [45.0, 200.0, 100.0, 10.0, 20.0, 100.0, 120.0, 100.0, 200.0, 400.0]
ly = [85.0, 208.0, 180.0, 80.0, 28.0, 188.0, 880.0, 800.0, 500.0, 350.0]
 
ndi  = array([ [x] for x in li ])
 
ndx = array(lx)
ndx.resize((len(lx),1))
 
ndy  = array([ [x] for x in ly ])
 
ndh = hstack((ndi,ndx,ndy))
 
print ndi,'\n\n',ndx,'\n\n',ndy,'\n\n',ndh

http://numpy.scipy.org/numpybook.pdf
reshape() et resize() page 60
vstack(seq) , , row stack (seq) , column stack(seq) , dstack (seq) page 99


Concernant ta question initiale («je souhaiterais faire un tableau à partir d'un fichier.txt»), il y a la fonction fromfile (file=, dtype=int, count=-1, sep=”) pour créer un tableau à partir d'un fichier:
http://numpy.scipy.org/numpybook.pdf
page 88
mais je n'ai pas réussi à l'utiliser correctement et je ne peux pas t'en dire plus.