Discussion :

[Ladgalen]

Bonjour

J'ai très peu de notion de python. Je voudrais simplement savoir lire ou écrire un fichier de ce genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
& titre
     1.00 12.560234
      2.00 12.436092
      3.00 12.376956
      4.00 12.548028
      5.00 12.494829
      6.00 12.534889
      7.00 12.507017
      8.00 12.422158
      9.00 12.265425
     10.00 12.367968
     11.00 12.140560

Je sais quand même ouvrir un fichier et le fermer

Code :

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

1
2
3
4
 
fichier = open( "monfichier", "r")
 
fichier.close()

Je connais aussi readline ou readlines, mais je ne sais pas stocker les valeurs dans des fichiers ou alors écrire le comptenu de variables numériques dans des fichiers.

Merci de votre aide

[KINENVEU]

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
 
fichier = open( "monfichier.txt", "w") # ouverture en ecriture (ecrasement)
a = [1.23, 4] # donnees
print "a:", a
fichier.write(str(a[0])+";"+str(a[1])+"\n") # ecriture d'une ligne de donnees (choix arbitraire du format)
fichier.close()
 
fichier = open( "monfichier.txt", "r") # ouverture en lecture
txt = fichier.read()
fichier.close()
b = []
line = txt.split("\n")[0] # 1ere ligne de donnees
line = line.split(";") # le separateur utilise a l'ecriture
b.append(float(line[0]))
b.append(int(line[1]))
print "b:", b

c'est juste un exemple vite fait pour te donner des pistes.

[alexdevl]

Voila d'autres façons de faire (le sujet est plutot ouvert..)

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
#!/usr/bin/env python
#coding=utf-8
import decimal
 
f_entree = open( "fichier.txt", "r")
f_sortie = open( "fichier_sortie.txt", "w")
f_sortie_de_nombres = open( "fichier_sortie_de_nombres.txt", "w")
for ligne in f_entree:
    # ligne="     11.00 12.140560\n"
    ligne_textes=ligne.split()
    # ligne_textes=['11.00', '12.140560']
    f_sortie.write(ligne_textes[0]+","+ligne_textes[1]+"\n") # ==> Création du fichier à partir du texte
    if ligne_textes==['&', 'titre']:
        print "nouveau titre"
    else:
        ligne_nombres=[decimal.Decimal(t) for t in  ligne_textes]
        # Transformation en decimal pour maitriser les arrondis
        # Exemple ligne_nombres=[Decimal("11.00"), Decimal("12.140560")]
        ligne_nombres[0]+=100 # Calcul sur les valeurs
        f_sortie_de_nombres.write(str(ligne_nombres[0])+","+str(ligne_nombres[1])+"\n")
            # ==> Création du fichier à partir de nombre calculés
 
 
f_entree.close()
f_sortie.close()
f_sortie_de_nombres.close()

[Ladgalen]

Merci à vous, je pense que je préfère la seconde version ... mais les gout et les couleurs ...

J'ai quand même l'impression que python n'est pas fait pour ce genre de petit script ! C'est utilisé pour le calcul scientifique ?

Un petit code C ou fortran serait peut être plus simple à écrire.

[pacificator]

Bonjour,

en utilisant les listes en intentions, on peut faire:

en lecture:

Code :

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

1
2
3
4
5
6
7
8
liste = []
for line in open('monfichier.txt'):
    try:
        tmp = [float(x) for x in line.split() if x]
        if tmp:
            liste.append(tmp)
    except:
        pass

en ecriture:

Code :

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

1
2
3
4
fichier = (monfichier.txt, 'w')
fichier.write('mon titre\n')
fichier.write('\n     '.join(['%.02f  %.06f' % (a, b) for a,b in liste]))
fichier.close()

[valAa]

Salut,
tu peux aussi utiliser le module csv http://docs.python.org/library/csv.html, ça revient au même, mais ça prend moins de place dans le code.

[oiffrig]

Si tu utilises numpy, pour la lecture il y a numpy.loadtxt, et numpy.savetxt pour l'écriture.

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
>>> import numpy as np
>>> x = np.arange(10)
>>> y = np.sin(np.pi*x/10)
>>> x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> y
array([ 0.        ,  0.30901699,  0.58778525,  0.80901699,  0.95105652,
        1.        ,  0.95105652,  0.80901699,  0.58778525,  0.30901699])
>>> data = np.array([x, y]).transpose()
>>> data
array([[ 0.        ,  0.        ],
       [ 1.        ,  0.30901699],
       [ 2.        ,  0.58778525],
       [ 3.        ,  0.80901699],
       [ 4.        ,  0.95105652],
       [ 5.        ,  1.        ],
       [ 6.        ,  0.95105652],
       [ 7.        ,  0.80901699],
       [ 8.        ,  0.58778525],
       [ 9.        ,  0.30901699]])
>>> np.savetxt('tmp/test.dat', data)
>>> np.loadtxt('tmp/test.dat')
array([[ 0.        ,  0.        ],
       [ 1.        ,  0.30901699],
       [ 2.        ,  0.58778525],
       [ 3.        ,  0.80901699],
       [ 4.        ,  0.95105652],
       [ 5.        ,  1.        ],
       [ 6.        ,  0.95105652],
       [ 7.        ,  0.80901699],
       [ 8.        ,  0.58778525],
       [ 9.        ,  0.30901699]])

Il y a peut-être une solution un peu plus propre pour l'enregistrement, à vérifier.

[alexdevl]

J'ai quand même l'impression que python n'est pas fait pour ce genre de petit script

Il me semble, au contraire, que python est exactement ce qu'il faut pour faire ce type de conversions.
Sur le critère du nombre d'instructions c'est plutôt compact non ?

Code :

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

1
2
3
f=open("fichier.txt","w")
f.write("...")
f.close()

[KINENVEU]

Il me semble, au contraire, que python est exactement ce qu'il faut pour faire ce type de conversions.
Sur le critère du nombre d'instructions c'est plutôt compact non ?

je suis tout a fait d'accord avec toi
python c'est bon.
particulierement pour le calcul scientifique.

[eyquem]

S’il s’agit d’écrire et de lire des nombres enregistrés sous forme texte, alors on peut utiliser un fichier .txt en effet.
Si ce n’est pas sous forme texte, on pense à un fichier binaire, ou à pickle, ou à numpy comme le propose oiffrig.
Mais la question est sommaire et on ne sait pas précisément ce qui est visé.

À question sommaire, conclusion hâtive:

J'ai quand même l'impression que python n'est pas fait pour ce genre de petit script.

En quoi les codes de Kinenveu et alexdevl montrent que Python n’est pas idoine pour ce problème ?
De quelles capacités un langage doit-il disposer pour être adéquat à ce problème ?

C'est utilisé pour le calcul scientifique ?

Pour les calculs sophistiqué, ce n’est pas Python directement qui est impliqué, il y a des bibliothéques spécialisées.
Mais plus largement, Python est très propice à une utilisation scientifique.
Cf sur ces sujets l’excellent article de Gaël Varoquaux dans le Linux Mag Hors-série No 40 de Janvier-Février 2009 dont voici un extrait de l’introduction:

De façon générale, un problème de recherche et développement se présente comme un modèle que l’on veut étudier et comprendre.

(...)

L’informatique scientifique a pour but premier de faciliter cette exploration du problème.
Ses outils, que le scientifique doit apprendre à maîtriser, ne sont que des barrières pour l’utilisateur entre son problème et lui-même.
Par ailleurs, dans le domaine de la recherche, il est inévitable que les problèmes soient souvent mal posés, et changent en permanence au fur et à mesure que l’on progresse.
C’est pourquoi il faut que les solutions utilisées soient aussi souples et agiles que possibles.

Pour répondre aux exigences d’interactivité et de souplese de développement, les outils de l’informatique scientifique se sont éloignés des langages compilés utilisés traditionnelllement, pour s’orienter vers des environnements interactifs spécialisés dotés de leur propre langage interprété, comme Matlab ou Mathematica.
Cependant la limite de ces outils est qu’ils sont spécialisés.

(...)

Mon expérience a montré que les environnements scientifiques spécialisés ne sont pas satisfaisants du tout pour la création d’interfaces graphiques, la gestion des couches réseau ou le controle du matériel scientifique..

Les langages généralistes et bas niveau comme le C peuvent se révéler désastreux dans les labos, car ils forcent l’utilisateur à s’occuper de problèmes qui ne l’intéressent pas, comme la gestion de mémoire, et ne proposent pas de façon transparente les outils standards dont le scientifique a besoin pour faire ses calsculs, traiter ses données et visualiser les résultats.

(...)

Finalement, Python n’est pas un langage spécialisé, ce qui lui permet de bénéficier d’une grosse masse de développeurs, et d’excellentes bibliothèques pour les tâches non spécifiquement scientifiques, par exemple pour coupler les résultats d’une expérience à une base de données.

Le potentiel scientifique de Python a été perçu depuis longtemps. Dès le milieu des années 90, des pionniers développaient des modules de calcul scientifique. Ces dernières années ont vu l’utilisation scientifique de Python s’accélérer grandement et de nombreux modules scientifiques sont maintenant disponibles.

Python est un langage doté de vastes possibilités propres, que ce soit en calcul ou en d’autres domaines.

Ce que je retire de l’article, c’est que Python et aussi apte à jouer un rôle d’entremetteur-agent de liaison-controleur-chef d’orchestre entre des processus divers et éventuellement hétérogènes.

Que demander de plus ?









Pour ce qui est du problème posé, voici ce que je propose:

je pars de l’idée que les données numériques intéressantes ont été placées en amont dans une liste, soit en les entrant à la main soit comme résultats d’un programme quelconque qui les a stockées dans la liste.

Une fois cette liste à disposition, pour l’écriture des données numériques selon le canevas montré:

Code :

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

1
2
3
4
5
6
7
li = [12.560234, 12.436092, 12.376956, 12.548028, 12.494829, 12.534889,\
      12.507017, 12.422158, 12.265425, 12.367968, 12.140560]
 
k = len(str(len(li)))
entete = '\n& ' + raw_input('Donnez un titre au fichier : ')
li_data = [ '\n '+str(i+1).rjust(k)+'.00 '+str(x) for i,x in enumerate(li) ]
open('fichier.txt','w').write(entete + ''.join(li_data))

J’ai notamment respecté l’alignement à droite des valeurs 1.00 2.00 ..... 9.00 10.00




Pour la lecture, les expressions régulières font cela avec facilité et concision.

Code :

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

1
2
3
4
5
6
7
8
ch = open('fichier.txt','r').read()
import re
m = re.search('&(.+)?\n',ch)
titre = m.group(1).strip()
data_couples = re.findall('\s([\d.]+) ([\d.]+)',ch[m.end():])
 
print 'titre =',titre
print 'data_couples =',data_couples

En absence de données dans le fichier, data_couples serait vide; mais m.group(1) donnerait une erreur. Il est possible d’ajouter une vérification sur m.

Est-il possible de faire aussi concis dans les autres langages ?

[tyrtamos]

Bonjour,

On peut aussi sauvegarder sur disque l'objet lui-même (=la liste) en utilisant le module shelve:

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
 
import shelve
li = [12.560234, 12.436092, 12.376956, 12.548028, 12.494829, 12.534889,
      12.507017, 12.422158, 12.265425, 12.367968, 12.140560]
 
# sauvegarde de la liste li
d = shelve.open('testsav')
d['li'] = li
d.close()
 
# récupération de la liste li
d = shelve.open('testsav')
li2 = d['li']
d.close()
 
print li2, type(li2)

Et on retrouve dans li2 la liste initiale à l'identique (et c'est bien une liste).

C'est très concis et ça marche très bien. Le seul défaut que je trouve à shelve, c'est que le fichier est stocké sous forme binaire, ce qui interdit une récupération facile hors Python.


Voilà une autre méthode plus classique qui n'a pas cet inconvénient (on utilise en entrée la même liste li):

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 os
 
# sauvegarde de la liste li
f = open("testsav", 'w')
f.write(repr(li) + os.linesep)
f.close()
 
# récupération de la liste li
f = open("testsav", 'r')
li2 = eval(f.readline().rstrip('\r\n'))
f.close()
 
print li2, type(li2)

On obtient, bien entendu, le même résultat, mais le fichier est cette fois un fichier texte, et donc récupérable facilement hors Python.

Les 2 méthodes sont utilisables pour stocker les autres types d'objets de base python, y compris dictionnaires.

D'autres exemples ici: http://python.jpvweb.com/mesrecettes...e_recup_objets.

Tyrtamos

[eyquem]

Oh ! que c’est astucieux, ça, Tyrtamos.

Mais je pense qu’il doit y avoir des restrictions dans le recours à cette méthode, car s’il existe plusieurs autres modules qui font de la persistance de data, c’est que l’existence de ces modules se justifie.
Je creuserai le sujet plus tard, comme les 30 ou 40 autres que je voudrais creuser....



Je pense notamment qu’il ne faut pas utiliser repr() les yeux fermés selon le type de donnée qu’on lui soumet:

repr()
For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to eval() , otherwise the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object. A class can control what this function returns for its instances by defining a __repr__() method.

http://www.python.org/doc/2.6.2/libr...ions.html#repr


Je pense aussi qu’il doit y avoir une question de vitesse. La méthode avec repr() et eval() doit être plus lente que les méthodes dédiées à la persistnace de données. AMHA, mais je n’ai pas envie de tester ça pour le moment.





Pour une liste on peut faire plus simplement

Code :

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

1
2
3
4
5
6
li = [12.560234, 12.436092, 12.376956, 12.548028, 12.494829, 12.534889,
      12.507017, 12.422158, 12.265425, 12.367968, 12.140560]
 
open("testsav", 'w').write('\n'.join(str(x) for x in li))
 
li2 = open("testsav", 'r').read().splitlines()

Mais on s'éloigne de la question qui a été posée.

[Matthieu Brucher]

repr() donne généralement une chaîne qui avec eval() permet de retrouver l'objet original, mais ça ne marche pas toujours. Les tableaux Numpy ne suivent pas cette recommandation par exemple.

[tyrtamos]

Effectivement, ma 2ème solution ne marche que pour les types de base: ceux pour lesquels eval(repr()) a un sens. Ce n'est pas le cas pour, par exemple la fonction toto(), car repr(toto) renvoie quelque chose comme <function toto at 0x02A72CF0> ce qui donne une erreur dans eval.

Mais pour les données courantes comme: int, float, complex, str, tuple, liste, dict, ça marche très bien et ça peut rendre des services.


Petit prolongement amusant de mon message précédent: voilà une classe qui imite shelve, tout en utilisant la 2ème méthode, celle avec eval(repr()). Cela permet en fait de charger/manipuler/sauver un dictionnaire de variables.

On crée une classe dérivée par héritage d'un type dict:

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 os
 
class Dicovar(dict):
    def __init__(self, nf, dicinit=None):
        self.nf = nf
        if os.path.exists(nf) and os.path.isfile(nf) and os.access(nf, os.R_OK) and dicinit==None:
            f = open(nf, 'r')
            dict.__init__(self, eval(f.readline().rstrip('\r\n')))
            f.close()
        else:
            if dicinit==None:
                dicinit = {}
            dict.__init__(self, dicinit)
 
    def enregistre(self):
        f =  open(self.nf, 'w')
        f.write(repr(self) + os.linesep)
        f.close()

Bon. C'est un codage rapide. Il faudrait ajouter les exceptions, etc...

Utilisation:

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
 
# sauvegarde des variables v1 à v7 dans le fichier 'testdicovar'
s = Dicovar('testdicovar')
s['v1'] = 123
s['v2'] = 0.123456
s['v3'] = (1,2,3,4)
s['v4'] = [5,6,7]
s['v5'] = {'a':8, 'b':9}
s['v6'] = complex(20,30)
s['v7'] = "c'est une chaine"
s.enregistre()
 
# recuperation des variables de v1 à v7 à partir du fichier 'testdicovar'
s = Dicovar('testdicovar')
v1 = s['v1']
v2 = s['v2']
v3 = s['v3']
v4 = s['v4']
v5 = s['v5']
v6 = s['v6']
v7 = s['v7']
 
# vérification:
print v1, type(v1) # affiche:  123 <type 'int'>
print v2, type(v2) # affiche:  0.123456 <type 'float'>
print v3, type(v3) # affiche:  (1, 2, 3, 4) <type 'tuple'>
print v4, type(v4) # affiche:  [5, 6, 7] <type 'list'>
print v5, type(v5) # affiche:  {'a': 8, 'b': 9} <type 'dict'>
print v6, type(v6) # affiche:  (20+30j) <type 'complex'>
print v7, type(v7) # affiche:  c'est une chaine <type 'str'>

Le paramètre dicinit permet d'initialiser le dictionnaire à autre chose que le contenu du fichier.

Et à part l'initialisation et l'enregistrement, grâce à l'héritage, on a droit à toutes les méthodes des dictionnaires (keys, clear, ...). Par exemple, pour remettre le dictionnaire à vide sur le fichier, on peut faire:

Code :

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

1
2
3
4
 
s = Dicovar('testdicovar')
s.clear()
s.enregistre

Etc...

Le principal avantage de cette méthode, c'est de stocker les données en fichier texte.

Un autre avantage par rapport à des méthodes plus simples (boucles), c'est qu'on peut stocker d'un seul coup un arbre complet (liste de liste de liste...) quelque soit sa profondeur, et composé de données hétérogènes.

En contrepartie, c'est limité aux types de base, et je ne sais pas ce que ça vaut en rapidité par rapport aux méthodes binaires.

Mais c'était amusant à faire

Tyrtamos