Discussion :

[tazgero]

Bonjour,

J'ai un paquet de fichiers de résultats à traiter qui ont tous la même structure et sur lesquels je vais réaliser les mêmes opérations. Ayant été formé sur Matlab, je me demandais qu'elle était la structure idéale de fichier pour stocker des informations en Python. Le premier déclic qu'il me vient quand je pense au problème est les structures Matlab du type:

Code :

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

1
2
3
4
5
for i in range (0,len(list_files))
   # Lecture du fichier list_files(i) et stockage dans la donnée Data(i).Original
   Data(i).Original=list_files(i)
   Data(i).Max=Data(i).Original.max()
   Data(i).Amplitude=Data(i).Original.ptp()

On se balade ensuite juste la variable Data que l'on peut promener partout. Je voulais savoir qu'elle était le meilleur moyen de faire cela en Python. J'ai essayé le dictionnaire, mais je suis pas convaincu. La liste peut être aussi mais ca me semble pas adapté aussi. Bref vous avez quelques idées?

Merci !!!

[Matthieu Brucher]

Si tu connais la structure a priori, autant créer une classe sur ce principe

[alexdevl]

Bonjour,
Je propose d'utiliser numpy :

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
 
#!/usr/bin/env python
#coding=utf-8
import numpy as np
class Data:
    def __init__(self,nom_list_fichiers):
        """ Lecture des fichiers et création objet numpy"""
        nom_fichiers=open(nom_list_fichiers, "r")
        for i,nom_fichier in enumerate(nom_fichiers):
            nom_fichier=nom_fichier.rstrip()
            array_encours=[np.loadtxt(nom_fichier)] # Importation du fichier
            if i==0 :
                self.data=array_encours
            else :
                self.data=np.append(self.data,array_encours,axis=0)
        nom_fichiers.close()
 
    def stat_2_file(self,nom_fichier_sortie):
        """ Création du fichier de sortie"""
        fichier_sortie_obj=open(nom_fichier_sortie, "w")
        fichier_sortie_obj.write("max\ttotal\t"+str(self.data.max())+"\n")
        for ligne in range(self.data.shape[0]): # .shape[0]=Nombre de lignes
            max_ligne=str(self.data[ligne].max())
            fichier_sortie_obj.write("max_ligne\t"+str(ligne)+"\t"+max_ligne+"\n")
        fichier_sortie_obj.close()
 
 
dat1=Data("nom_fichiers.txt")
print dat1.data
print dat1.data[0].max()
print dat1.data.max()
dat1.stat_2_file("sorties.txt")

Fichiers et exemples

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
 
fichier1.txt
10
20
 
fichier2.txt
40
61
 
nom_fichiers.txt
fichier1.txt
fichier2.txt
 
sorties.txt
max	        total	61.0
max_ligne	0	20.0
max_ligne	1	61.0
 
sorties écran:
[[ 10.  20.]
 [ 40.  61.]]
20.0
61.0

[tazgero]

Si tu connais la structure a priori, autant créer une classe sur ce principe

Bonsoir,

En faites je voudrais éviter de faire une classe, car je post-traite des données expérimentales qui sont pas forcément identiques identiques. Remarque la classe est solution sexy, mais ca ressemble à sortir un canon à mouche...

[tazgero]

Merci alexdevl pour ce code. Ca reprend l'idée de la classe qui a l'air l'unique soution finalement. Ce qui me dérange en faites c'est surtout que je sois obligé de mettre à chaque des dat1="toto.txt", dat2="titi.txt" Je voudrais faire un dat avec un indice et qui regroupe toutes les données de chaque fichier texte sous l'indice du genre dat(1) qui me sorte tout ce qui rapport à toto.txt et le post-processing que j'ai fais et ainsi de suite...

[alexdevl]

Bonjour,

un dat avec un indice et qui regroupe toutes les données de chaque fichier texte

Le code est dans ce sens :
En fait "nom_fichiers.txt" est une liste de fichier comportant :
fichier1.txt et fichier2.txt
Ainsi
print dat1.data[0].max() cherche le max de la ligne de fichier1.txt
print dat1.data.max() cherche le max de l'ensemble fichier1.txt et fichier2.txt

Après on peux éviter la classe en faisant comme ceci :
(J'ai appelé la variable data pour qu'il n'y ai pas d'équivoque)

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
#!/usr/bin/env python
#coding=utf-8
import numpy as np
 
def list_fich_2_np(nom_list_fichiers):
    nom_fichiers=open(nom_list_fichiers, "r")
    for i,nom_fichier in enumerate(nom_fichiers):
        nom_fichier=nom_fichier.rstrip()
        array_encours=[np.loadtxt(nom_fichier)]
        if i==0 :
            data=array_encours
        else :
            data=np.append(data,array_encours,axis=0)
    nom_fichiers.close()
    return data
 
data=list_fich_2_np("nom_fichiers.txt")
print data
print data[0].max()
print data[1].max()
print data.max()

[tazgero]

Bonjour,

Merci pour tout ca, je teste et je vous dis quoi! Avant de mettre le résolu

[tazgero]

Hello,

Fichiers et exemples

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
 
fichier1.txt
10
20
 
fichier2.txt
40
61
 
nom_fichiers.txt
fichier1.txt
fichier2.txt
 
sorties.txt
max	        total	61.0
max_ligne	0	20.0
max_ligne	1	61.0
 
sorties écran:
[[ 10.  20.]
 [ 40.  61.]]
20.0
61.0

J'ai implémenté la petite moulinette que tu avais commencé à programmer. Et j'ai un petit soucis. Dans les exemples tu as des fichiers avec uniquement un vecteur. Dans mon cas j'ai des matrices et du coup de la concatenation de la matrice, c'est un peu plus difficile de s'y retrouver vu que l'indice 2 ne correspond pas aux données du fichier fichier2.txt mais à la deuxième ligne du fichier1.txt.

Voila la manière dont j'ai implémenté la classe comme suit:

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
class Camera_Data:
    def __init__(self,path_files,files_list,nb_column):
		self.nb_files=len(files_list)									# Saving the file list
		self.files_list=files_list										# Saving the file list
		for i,file_name in enumerate(files_list):						# Iterating over the files lits
		# Reading the Data-File
			f=open(path_files+file_name,"r")							# Opening the file file_name
			flines=f.readlines()										# Reading the file lines
			f.close()													# Closing the file file_name
			M_file=numpy.zeros((len(flines)-3,nb_column))				# Initialization of the data matrix. Here -3 lines due to the file-headers
			for j in range(3,len(flines)):								# Iterating over all lines
				if (flines[i]!=''):										# Line not empty
					words=flines[j].split()                         	# Split a line into words spaced with a blank space
					for k in range(0,len(words)):						# Iterating over all words
						M_file[j-3,k]=float(words[k].replace(',','.'))	# Converts string into float and replace , to . for decimal point
			if (i==0):
				self.data=M_file
			else :
				self.data=numpy.append(self.data,M_file,axis=0)

Peut être en créant des matrices avec des plans (i,j,k), non?

[tazgero]

Finalement, je suis parti sur une liste qui permet de stocker tout ca. Je pouvais pas utiliser les matrices plans, car j'avais des longueurs de fichiers différentes. Du coup, ca ressemble à ca:

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
class Camera_Data:
    def __init__(self,path_files,files_list,nb_column):
		self.nb_files=len(files_list)										# Saving the files number
		self.files_list=files_list											# Saving the file list
		self.Freq_Data=numpy.zeros((self.nb_files))							# Initialization of the excitation frequency vector
		self.Raw_Data=[]													# Initialization of the camera list
		for i,file_name in enumerate(files_list):							# Iterating over the files lits
		# Reading the file name to extract the Excitation Frequency
			words=file_name.split('_')										# Splitting the file_name into words separated with a underscore
			self.Freq_Data[i]=float(words[0][:-2].replace('-','.'))			# Extracting the excitation frequency
 
		# Reading the Data-File to extract the Camera Data
			f=open(path_files+file_name,"r")								# Opening the file file_name
			flines=f.readlines()											# Reading the file lines
			f.close()														# Closing the file file_name
			M_file=numpy.zeros((len(flines)-3,nb_column))					# Initialization of the data matrix. Here -3 lines due to the file-headers
			for j in range(3,len(flines)):									# Iterating over all lines
				if (flines[i]!=''):											# Line not empty
					words=flines[j].split()                         		# Split a line into words spaced with a blank space
					for k in range(0,len(words)):							# Iterating over all words
						M_file[j-3,k]=float(words[k].replace(',','.'))		# Converts string into float and replace , to . for decimal point
 
			self.Raw_Data.append(M_file)

Je pense que ca résoud le problème que j'avais. Merci de votre aide

[tazgero]

En continuant à développer mon programme, je dois trier ma liste crée en utilisant un vecteur de permutation que j'obtiens ailleurs mon prog. Le problème est que cela ne marche pas et que je suis donc obligé de passer par une petite boucle que je trouve inutile:

Code :

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

1
2
3
4
5
6
7
8
9
		# Sorting the Frequency Data
		Perm_Vector=self.Freq_Data.argsort()
 
		# Sorting the Raw_Data array
		Temp=[]
		for i in range(0,self.nb_files-1):
			Temp.append(self.Raw_Data[Perm_Vector[i]])
 
self.Raw_Data=Temp

Alors qu'un petit bout de code du genre Raw_Data[Perm_Vector] serait nettement plus sympathique. Est ce que cela vient de mon appel qui est pas bon ou il y a-t-il quelque chose de plus subtil?

[Matthieu Brucher]

Avec Numpy, ça ira plus vite (tu peux lui passer directement le vecteur des nouveaux indexes)

[tazgero]

Avec Numpy, ça ira plus vite (tu peux lui passer directement le vecteur des nouveaux indexes)

Maw!! C'est quoi cette fonction magique, car je suis bien d'accord que cette boucle sert pas à grand chose ..

[Matthieu Brucher]

Si self.Raw_Data est un tableau numpy, ta solution est directement self.Raw_Data[Perm_Vector]

[tazgero]

Si self.Raw_Data est un tableau numpy, ta solution est directement self.Raw_Data[Perm_Vector]

Arf malheureusement c'est une liste classique car je pouvais pas l'initialiser correctement, vu que mes fichiers textes ont pas forcément le même nombre de lignes... Du coup je peux pas utiliser de matrices à trois dimensions me semble-t-il.

[Matthieu Brucher]

Tu peux aussi utiliser un tableau 1D d'objets, ça peut le faire.

[tazgero]

Tu peux aussi utiliser un tableau 1D d'objets, ça peut le faire.

Ca se présente comment alors ca? L'ensemble de mon script fonctionne nickel, mais le maniement des matrices cachés dans les listes est pas des plus faciles quand même, alors s'il y a possibilité d'améliorer tout ca, je suis preneur

[Matthieu Brucher]

Quand tu crées ton tableaux Numpy, indique que tu vas avoir des objets dedans (je crois que c'est dtype=numpy.object, mais à vérifier). Par la suite, tu l'utilises comme une liste optimisée.