Suite de la discussion d'ici.

Bonjour, je me suis interesse a cet exercice du tutoriel de Swinnen :

Citation : G. Swinnen

Écrivez des fonctions qui effectuent le même travail que celles du module pickle (voir
page 121). Ces fonctions doivent permettre l’enregistrement de variables diverses dans
un fichier texte, en les accompagnant systématiquement d’informations concernant
leur format exact.

En gros, pour moi l'exercice est de faire entrer des valeurs a l'utilisateur, les enregistrer avec leur type, et les restituer avec leur type.
Seulement, je trouve mon code assez complique pour l'exercice donne, et je suppose qu'il existe des methodes plus simples pour arriver au meme resultat.
Je demande donc votre avis.
Voici le code :

import os
os.chdir('C:\Documents and Settings\Propriétaire\Mes documents')

def save(liste):
    fic = open('fichier.txt', 'a')
    n = 0
    taille = len(liste)
    while n < taille:
        gender = str(type(liste[n]))
        fic.write('#'+str(liste[n])+'@'+gender)
        n += 1
    fic.close()

def load():
    fic = open('fichier.txt', 'r')
    here = fic.read(1)
    while 1:
        if here != '':
	    if here == '':
                break
            if here == '#':
                print('Valeur : ', end='')
                while here != '@':
                    here = fic.read(1)
                    if here == '@':
                        continue
                    else:
                        print(here, end='')
                print('\nType : ', end='')
                while here != '#':
                    here = fic.read(1)
                    if here == '#':
                        continue
                    else:
                        print(here, end='')
                print('\n\n')
        else:
            fic.close()
            break

user = ' '
tab = []

print('Entrez des valeurs et quand vous avez fini appuyez juste sur <Enter>')

while user != '':
    user = input('Valeurs : ')
    if user != '':
        try:
            int(user)
            user = int(user)
            tab.append(user)
        except:
            try:
                float(user)
                user = float(user)
                tab.append(user)
            except:
                tab.append(user)
                
save(tab)
load()

Je pense que ma fonction 'save' est assez concise.
En revanche, ma fonction 'load' me semble un peu trop 'grosse' ; de plus, je ne sais pas si il y a d'autres methodes pour determiner la type d'une variable que celle que j'ai utilisee avec les 'try' et 'except' imbriques.

Merci d'avance pour vos avis/conseils, Lecureuil.

Citation : Lecureuil

EMC1 : 'l aurait du permettre d'enregistrer des données de types divers dans un fichier et de récupérer précisément ces données' => Je suis d'accord, il suffit alors de refaire des 'try...except'.

A vrai dire non, et c'est pour ça qu'il est précisé d'enregistré les informations sur le type avec la valeur.
D'ailleurs l'exercice ne demande que de fournir les fonctions save et load; mieux aurait valu éviter de demander à l'utilisateur d'entrer des valeurs avec "input" : tu dois après utiliser bloc de try /except très laid et ca n'a pas d'intérêt.

import os
os.chdir('C:\Documents and Settings\Propriétaire\Mes documents')


dict={"i":int,"f":float,"s":str} #types basiques que l'on traitera

def save(liste): #Il serait plus logique que la fonction save ne prenne qu'une seule valeur
                #d'un des 3 types de notre dictionnaire
    with open('fichier.txt', 'a') as fic:
        for e in liste:
            t = str(type(e)).split("'")[1][:1] #On récupère la première lettre du nom
                    #du type. C'est moche, mais court.
            fic.write(str(e)+t+"\n") #Retour à la ligne rend plus facile load
            
def load():
    res=[]
    with open('fichier.txt', 'r') as fic:
        for ligne in fic:
            t,valeur=ligne[-2],ligne[:-2] #-2 pour ne pas prendre le retour à la ligne
            res.append(dict[t](valeur))

    return res

Edit :
Exemple d'utilisation en console:

>>> save([20,59.5,"hello"])
>>> print load()
[20, 59.5, 'hello']

Contenu du fichier correspodant:

20i
59.5f
hellos

Merci pour ta reponse, ca me ridiculise un peu vu la taille de mon code !
Le seul soucis avec ton code est l'utilisation de dictionnaires, je n'ai pas encore vu cela !
Et le mot cle 'with' avec 'as', je ne connais pas non plus.

Les dictionnaires sont des données composites non séquencées qui associe simplement des clés à des valeurs.
On accède au valeur par la syntaxe valeur=dictionnaire[clé].
Tu verras sans doute ça plus en détail dans le cours.

En ce qui concerne la structure with ... as, elle permet dans le cas des fichiers une utilisation plus simple en se chargeant de refermer celui ouvert automatiquement à la fin du bloc.
(En réalité ces mots clés sont surchargeables pour n'importe quel objet et appel au début et à la fin du bloc respectivement les méthodes spéciales __enter__ et __exit__ de l'objet).

J'ai pas tout compris, mais j'ai compris le principal.
('données composites non séquencées' et 'ces mots clés sont surchargeables pour n'importe quel objet et appel au début et à la fin du bloc').

A Lecureuil :

Un résumé synthétique mais intéressante des propriétés des dictionnaires Ici

Tu peux retenir qu'un dictionnaire est un moyen simple et rapide de lier une séquence de références (par exemple des options rentrées par l'utilisateur) à une séquence de données (par exemple des fonctions à exécuter). Les références et données pouvant vraiment être n'importe quoi (variables, fonctions, objets de classe, etc).

A EMC1 : ouaip, mea culpa, le tuple n'avait pas besoin d'être décomposé...j'ai écrit explicitement les données à rentrer c'est une habitude perso.

Merci pour les infos sur les dictionnaires !

Bonsoir, pour en revenir au code de Lecureuil, les lignes 19 et 20 sont superflus:

while 1:
        if here != '':
            if here == '': # ici
                break # ici

Ou plutôt il faudrait désindenter ces deux ligne d'un cran.