Discussion :

[Supral]

Bonjour à tous,
comme vous avez certainement pu le lire dans le titre je cherche à sauvegarder des variable car je réalise un projet de jeux de plateau et je souhaite ainsi offrir la possibilité au joueur de sauvegarder une partie pour pouvoir la recharger ensuite, j'utilise le module pickle mais je n'arrive pas à enregistrer toutes les variables de types différent (liste de liste, entier etc...) dans un fichier (pour la sauvegarde) et ensuite pouvoir recharger(charger partie) ce fichier pour pouvoir continuer une partie.

J'avais pour idée de créer deux fonction différentes simple:
- sauvegarde de partie
- chargement de partie

j'avais fait ça mais cela me renvoie une erreur.

Code :

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

1
2
 
_pickle.PicklingError: Can't pickle <class 'tkapp'>: attribute lookup builtins.tkapp failed

Voici mon code

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
 
## Exemple de données que je souhaite pouvoir sauvegarde puis recharger
nb=10
c=60## Tailles des cases d'un damier en 10*10
x0,y0=0,0
 
pionsNoirs=[   [0,1],[0,3],[0,5],[0,7],[0,9],
                   [1,0],[1,2],[1,4],[1,6],[1,8],
                   [2,1],[2,3],[2,5],[2,7],[2,9],
                   [3,0],[3,2],[3,4],[3,6],[3,8]]
 
 
def sauvegarderPartie():
    p=open("f", "w") # le fichier de sauvegarde s'appelle “f”
    pickle.dump((dimension_case, sizeDamier, rangee_pions,damier,nb,c,x0,y0,casesNoires,pionsNoirs,pionsBlancs,casesDamier,provisoireBlancsdroit,provisoireBlancsgauche,provisoireNoirsgauche,provisoireNoirsdroit),p)
    p.close()
 
def chargerPartie(f):
    p=open(f,"r")
    truc= pickle.load(p)
    placepions()
    p.close()
    return truc

Si vous avez une idée, un conseil ou autre je suis preneur, je vous remercie d'avance.
Cordialement.

[VinsS]

Salut,

Si tu veux sauvegarder une configuration d'application, commence d'abord par en créer un dictionnaire.
config = {'dimension_case': xy, 'sizeDamier': yz, 'rangee_pions': etc}

Ensuite tu pourras dumper ton dictionnaire sans problème.

D'où sort ce message d'erreur:

Code :

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

1
2
 
_pickle.PicklingError: Can't pickle <class 'tkapp'>: attribute lookup builtins.tkapp failed

Jamais vu cette syntaxe.

[Supral]

Je te remercie je vais faire ça tout de suite.
Cependant à quoi correspond les xy ou encore xz dans ton dictionnaire je n'ai fait que très peu de dictionnaire et ne comprend donc pas cette notation.
Quant au message d'erreur c'est celui que j'ai obtenu après avoir utilisé la fonction sauvegarderPartie dans mon précédent message.

Cordialement.

[Supral]

Après avoir réussis à écrire dans le fichier puis l'avoir lu je n'arrive pas à réutiliser les donnée dans les variables.
je m'explique :

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
 
config = {'dimension_case', 'sizeDamier', 'rangee_pions','damier','nb','c','x0','y0','casesNoires','pionsNoirs','pionsBlancs','casesDamier','provisoireBlancsdroit','provisoireBlancsgauche','provisoireNoirsgauche','provisoireNoirsdroit'}
 
 
def sauvegarderPartie():
    p=open("fichierSauvegarde.txt", "wb") # le fichier de sauvegarde s'appelle “fichiersauvegarde”
    pickle.dump(config,p) # Je dump le dico config 
    print(config) # je print config qui  me renvoie un dico de string
    p.close()
 
def chargerPartie():
    p=open("fichierSauvegarde.txt","rb") 
    truc= pickle.load(p)
    print(config) # Le dico config est printé 
    placepions() # je refait le placement des pions avec les valeurs des variables enregistrés
    p.close()
 
    return truc

Voila comme tu dois le voir mon placement de pions ne fait absolument rien et ne change rien sur mon plateau de jeu, cela vient il du fait que ce sont des strings ?

Si tu pouvais m'expliquer comment faire pour récupérer les valeurs des variables enregistrés dans le dico à un moment donné.

Si je me suis mal exprimé n'hésites surtout pas

[psyphi]

C'est normal, une fois que tu as récupéré le contenu de pickle.load dans truc, tu dois donner truc à placepions, sinon comment cette fonction est sensée connaitre le contenu de truc.

[Supral]

Qu'entends tu par donner truc à pions en code ça signifie quoi je n'arrive pas à visualiser ce que tu m'explique, je comprend l'idée mais ne vois pas la manière.

[psyphi]

Donne le code entier de ton programme, qu'on puisse t'expliquer un peu mieux, car par bride de fonction ce n'est pas évident.

[Supral]

voila mon code, je sais pas si tu vas réussir à tout lire. Les fonctions principales sont :
damier8, damier10,pionsBlack,pionsWhite, generateDamier, placePions, sauvegarderPartie, chargerPartie

en gros la fonctions sauvegarde sauvegarde toutes les variables de damier8 ou damier 10 suivant laquelle est lancé

et ce que je veux c'est pouvoir replacer les pions sur le damier avec toutes ces variables.

[psyphi]

Aïe, pas facile de s'y retrouver.

1. Evite la surutilisation de global, ça rend très difficile la compréhension du programme c'est difficile de connaitre l'état de chaque variable globale.
2. La fonction placepions ne sert à rien, elle appelle juste generateDamier.

Ta fonction sauvegarderPartie sauvegarde des chaines de caractères et non pas le contenu des variables que tu crois. Comme dit plus haut, tu dois créer un dictionnaire (couple clef/valeur). Relis la doc python sur le type dict: http://docs.python.org/3/library/std...ight=dict#dict. Une fois que ton dictionnaire sera correct alors tu pourras le "dumper" avec pickle.

Ta fonction chargerPartie retourne la variable "truc" qui n'est ensuite jamais lue.
generateDamier fait toujours la même action sans tenir compte de la valeur retour de chargerPartie. Il faut que tu te débrouilles pour que la fonction generateDamier récupère la valeur de retour de chargerPartie. De préférence avec un paramètre de fonction, tu as bien assez de valeurs globales comme ça

[Supral]

je te remercie je vais faire ça tout de suite et aller me documenter pour les dictionnaires, merci beaucoup pour ton aide.
A plus.

[tyrtamos]

Bonjour,

Le fait de vouloir conserver des données du programme en exécution pour s'en servir à la session suivante est un problème courant.

En ce qui me concerne, j'utilise 2 méthodes:

- si je veux pouvoir intervenir avec un éditeur de texte pour consulter ou modifier les valeurs stockées, j'utilise le module configparser (fichiers 'ini' de Windows)

- si ce n'est pas nécessaire, j'utilise le module shelve

Ce dernier module est assez peu connu, et c'est dommage: je le trouve très pratique. Il utilise le module pickle, mais permet de manipuler des dictionnaires.

Voilà un exemple d'utilisation du module shelve. Il fonctionnera en Python 2.7 et 3, à condition de retirer le 'u' de L6 en Python 3:

Code de sauvegarde:

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/python
# -*- coding: utf-8 -*-
 
import shelve
 
# variables à sauvegarder sur disque
L0 = True
L1 = 123
L2 = 4567890123456789 # type long en Python 2 et int en Python 3
L3 = 1.789e5
L4 = complex(1, 2) # nombre complexe (1+2j)
L5 = "ABC" # chaine de type str
L6 = u"DEF" # retirer le 'u' en Python 3
L7 = [L0, L1, L2, L3, L4, L5, L6] # liste de variables de types divers
L8 = (L0, L1, L2, L3, L4, L5, L6) # tuple de variables de types divers
L9 = {'L0':L0,'L1':L1,'L2':L2,'L3':L3,'L4':L4,'L5':L5,'L6':L6} # dictionnaire
LA = set([1, 2, 3])
 
# sauvegarde des variables
d = shelve.open('sauvegardevar.shv') # l'extension peut être quelconque
d['L0'] = L0
d['L1'] = L1
d['L2'] = L2
d['L3'] = L3
d['L4'] = L4
d['L5'] = L5
d['L6'] = L6
d['L7'] = L7
d['L8'] = L8
d['L9'] = L9
d['LA'] = LA
d.close()

Code de restauration:

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
33
34
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import shelve
 
# restoration des variables
d = shelve.open('sauvegardevar.shv')
L0 = d['L0']
L1 = d['L1']
L2 = d['L2']
L3 = d['L3']
L4 = d['L4']
L5 = d['L5']
L6 = d['L6']
L7 = d['L7']
L8 = d['L8']
L9 = d['L9']
LA = d['LA']
d.close()
 
# impression des variables
print("objets Lecuperes par shelve:") 
print(L0, type(L0))
print(L1, type(L1))
print(L2, type(L2))
print(L3, type(L3))
print(L4, type(L4))
print(L5, type(L5))
print(L6, type(L6))
print(L7, type(L7))
print(L8, type(L8))
print(L9, type(L9))
print(LA, type(LA))
print()

Ce code de restauration affichera les données suivantes:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
objets recuperes par shelve:
True <class 'bool'>
123 <class 'int'>
4567890123456789 <class 'int'>
178900.0 <class 'float'>
(1+2j) <class 'complex'>
ABC <class 'str'>
DEF <class 'str'>
[True, 123, 4567890123456789, 178900.0, (1+2j), 'ABC', 'DEF'] <class 'list'>
(True, 123, 4567890123456789, 178900.0, (1+2j), 'ABC', 'DEF') <class 'tuple'>
{'L6': 'DEF', 'L4': (1+2j), 'L5': 'ABC', 'L2': 4567890123456789, 'L3': 178900.0, 'L0': True, 'L1': 123} <class 'dict'>
{1, 2, 3} <class 'set'>

On voit bien que toutes les données ont été récupérées en valeur et en type.

L'utilisation de shelve est vraiment très simple. En fait, la seule contrainte est de créer la chaine qui servira de clé au dictionnaire pour chaque variable à stocker (exemple: 'L0' pour la variable L0).

Il reste un problème non abordé: à quel endroit du disque mettre ce fichier shelve? Le placer au même endroit que le programme n'est pas une bonne idée pour 2 raisons:

- plusieurs utilisateurs du PC ayant des comptes différents devront partager ce fichier?

- pour des raisons de sécurité, il est de plus en plus interdit aux utilisateur d'écrire à l'endroit où le programme est installé (si le programme a été installé!).

Il y a dans ce cas une solution universelle très simple: trouver le 'home' de l'utilisateur. Cela permettra de répondre aux 2 problèmes ci-dessus: on sera sûr que l'utilisateur aura le droit d'écrire à cet endroit, et plusieurs utilisateurs du même programme utiliseront leurs données personnelles. Y compris simultanément pour des OS multi-utilisateurs (et pas seulement multi-tâches comme Windows).

Voilà comment on fait:

Code :

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

1
2
3
4
home = os.path.expanduser('~')
fichier = os.path.join(home, 'monprogramme_sauvegardevar.shv')
print fichier
C:\Users\tyrtamos\monprogramme_sauvegardevar.shv

Ce nom de fichier peut même commencer par un point pour faire partie des "fichiers cachés" sous Linux.

On pourrait, bien sûr, créer un nom de répertoire spécifique au programme pour stocker d'autres données.

[psyphi]

Le module configparser comme son nom l'indique doit être utiliser pour sauvegarder les données de configuration du programme pas pour autre chose.

[tyrtamos]

Le module configparser comme son nom l'indique doit être utiliser pour sauvegarder les données de configuration du programme pas pour autre chose.

C'est couramment utilisé pour la configuration, mais rien ne s'oppose à ce qu'on l'utilise à chaque fois que c'est utile pour n'importe quelle autre utilisation... Le principal intérêt étant que, contrairement au stockage binaire, on peut intervenir entre 2 sessions pour consulter ou modifier les données. Par contre, cette utilisation limite les données à ce qui est affichable dans un fichier texte. Et il faut gérer à part les types de données.

[psyphi]

mais rien ne s'oppose à ce qu'on l'utilise à chaque fois que c'est utile pour n'importe quelle autre utilisation...

Les fichiers de configuration servent à stocker la configuration d'un programme et ne doivent pas être utilisé pour autre chose (même si c'est possible). Si un autre développeur qui ne connait pas le code arrive sur ton projet et qu'il voit un fichier de config il va pensé que ce dernier est utilisé pour configurer le programme à son ouverture pas pour sauvegarder l'état d'un objet ou autre. Si tu te retrouve à devoir implémenter une telle solution, alors il a une erreur dans la spécification d'architecture (voir même un niveau au dessus, dans le fonctionnel).

Si tu as besoin d'un format texte, alors tu as plein d'autre choix: csv, xml, json...

Le principal intérêt étant que, contrairement au stockage binaire, on peut intervenir entre 2 sessions pour consulter ou modifier les données

Je suis en désaccord avec deux points:
- Avec du stockage binaire tu peux aussi consulter les données si ces dernières ne sont pas chiffrées. Il te suffit de connaitre le codage utilisé et l'outil adéquat.
- Sauf cas très spécifiques, tu ne devrait pas avoir à modifier les données créer par un programme avant de relancer ce dernier. Si c'est le cas c'est soit qu'il manque qqch dans ces dernières et que le programme n'est pas complet (missing feature) ou bien que les données générer sont fausses et donc qu'il y a un bug dans le programme.

[tyrtamos]

@ psyphi:

Concernant les fichiers de type ini (configparser): que ce soit "normal" ou pas, c'est une solution très simple, qui marche très bien et qui est très souvent utilisée.

Mais ce n'est pas ce que j'ai proposé au PO.

[psyphi]

Hmm, je n'ai pas du être assez clair ou mon vocabulaire était peut être mal choisi.
Mais non il ne s'agit pas d'une solution pour le problème dans le cas présent. Au mieux, c'est un hack, un workaround temporaire, qui ne dois jamais partir en production. La mésutilisation courante d'une libraire n'en fait pas une solution.
Pour faire plus imagé, il est toujours possible d'utiliser un tourne vis à la place d'une pelle pour creuser un trou, mais cela n'en fait pas une solution sensée. De plus personne ne comprendra pourquoi tu as fait cela.

[tyrtamos]

Mais non il ne s'agit pas d'une solution pour le problème dans le cas présent

Et ce n'est pas ça que j'ai proposé.

De plus personne ne comprendra pourquoi tu as fait cela.

Manifestement, on n'utilise pas les mêmes programmes...

Je ne suis pas intéressé par ce genre de polémique: Essaie plutôt de répondre aux questions du PO!