Discussion :

[Invité]

Bonjour,

J'ai un petit projet de classement par comparaison avec l'aide du classement elo.
Pour stocker les « données » du classement j'ai pensé à utiliser un dictionnaire de dictionnaire de ce type :
[nomdufichier : [score_elo:X ; victoire:X;defaite:X]]

Jusqu’à là pas de pb, j'arrive à initialiser ma base de données et à y faire des modifications.

Mais, j'ai un problème concernant le stockage de cette base…

J'ai trouver plusieurs façon de faire mais selon vous qu'est ce qui serait le « plus adapté » ?

j'ai trouver Utiliser la méthode : shelve, pickle, utiliser un code de ce type :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
# 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()

ou alors abandonner cette façon de faire à utiliser une base de donnée (SQLlite par exemple) ?

______

l'idée d'un stockage sans base de donnée vient du mode de stockage du Shaarli de SebSauvage. Lui il fait ca en php, mais j'avoue que j'ai pas vraiment compris comment il fait.



Pour ce qui est de l'utilisation du classement elo …. : facematch (le projet premier projet de Marck Zukenberg avant FB).

Pour se qui shelve et le type de code voir : ici


Merci de votre aide.

[Sve@r]

J'ai trouver plusieurs façon de faire mais selon vous qu'est ce qui serait le « plus adapté » ?

Bonjour

Ta question est mal posée. Il faudrait que tu dises "plus adapté à quelque chose en particulier". Parce que sans ça, il n'y a pas de réponse magique.

C'est logique. S'il existait un sytème plus adapté "à tout", c'est lui qu'on utiliserait !!!

Donc la bdd est pratique question redondances (séparation des informations en tables reliées par des champs spécifiques) et aussi pour l'interrogation (langage de requêtage puissant) accessible par plusieurs users en parallèle. Le fichier est pratique quand on a juste besoin d'un stockage longue durée (la bdd est possible là aussi mais sera alors sous-employée). On arrive ensuite dans un mix bdd/fichier avec sqlite qui évite d'installer un (lourd?) serveur bdd et qui offre alors certains avantages bdd (requêtage) dans un simple fichier. Pickle sera pratique pour convertir des objets complexes Python en chaine ascii qui seront ensuite éventuellement stockées (dans un fichier ou une bdd). Et shelve je sais pas ce que c'est mais j'imagine volontiers qu'il ne sera utile que pour un certain besoin.
Donc tout dépend de ton besoin. Certains outils seront "plus adaptés" pour un cas X mais pas pour un cas Y...

[tyrtamos]

Bonjour,

shelve et pickle sont utiles dès qu'on souhaite stocker et récupérer des variables Python et pas seulement des données. De ce fait, ce qui est stocké l'est sous forme binaire.

shelve utilise pickle et permet de stocker des variables Python sous forme d'un dictionnaire. Pour moi, je considère shelve comme une manière simple d'utiliser pickle.

Prenons 2 exemples avec shelve (Python 3):

1- stockage et récupération d'une liste:

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 shelve
 
maliste = [1,2,3]
 
# sauvegarde de la variable maliste sous le nom "maliste" dans le fichier "varsav"
with shelve.open('varsav') as d:
    d["maliste"] = maliste
 
# chargement de la variable maliste stockée dans le fichier "varsav"
with shelve.open('varsav') as d2:
    maliste2 = d2["maliste"]
 
print(maliste2, type(maliste2))
[1, 2, 3] <class 'list'>

On voit bien que la variable a été récupérée dans son type (ici list) et dans sa valeur.

Pour en revenir au problème posé: aucun problème pour stocker et récupérer de la même façon un "dictionnaire de dictionnaires" avec shelve. C'est même, à mon avis, la manière la plus simple de le faire.

Par contre, par rapport à une base de données, shelve stocke et charge la totalité du dictionnaire à chaque fois: on ne peut pas modifier une des valeurs séparément.

2- stockage et récupération d'une instance de classe:

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
import shelve
 
class Maclasse(object):
 
    def __init__(self, x):
        self.x = x
 
    def affiche(self):
        print(self.x)    
 
maclasse = Maclasse("toto")
 
# sauvegarde de la variable maclasse sous le nom "maclasse" dans le fichier "varsav"
with shelve.open('varsav') as d:
    d["maclasse"] = maclasse
 
# chargement de la variable stockée dans le fichier "varsav" sous le nom "maclasse"
with shelve.open('varsav') as d2:
    maclasse2 = d2["maclasse"]
 
maclasse2.affiche()
toto

On voit bien ici que l'instance de classe a été stockée et récupérée avec sa valeur et son type. Mais, bien sûr, quand on charge l'instance de classe, il faut que la classe elle-même ait été définie dans le même code!

Une limite de shelve et pickle par rapport à un serveur de base de données: les accès concurrents ne sont pas supportés.

A noter qu'il existe une autre méthode non citée pour conserver des données d'une cession à l'autre d'un programme: les fichiers de type "ini" (module "configparser"). L'avantage est que les données sont stockées "en clair", et qu'on peut donc les modifier avec un simple éditeur de texte entre 2 cessions. Cette méthode est surtout utilisée pour conserver les données de configuration d'un programme.

[Invité]

Merci de m'avoir répondu.

Pour tout vous dire, je n'avait pas du tout dans l'idée d'utilisé une base de données, mais quand vous regarder les exemple de code du type Face-Match, la plus part (voir tous) utilisent une base de données. D'où mon hésitation lors de mon choix de la méthode de stockage.

Donc au vue de vos explications, dans mon cas, il serait "mieux" d'utiliser shelve. En effet, je cherche à stocker un nombre relativement petit de données que je peux stocker en mémoire lors de leurs utilisation. (de plus il n'y aura qu'un seul utilisateur).
shelve me servira à les sauvegarder entre deux utilisations du programme que je veux faire.

[wiztricks]

Salut,

En effet, je cherche à stocker un nombre relativement petit de données que je peux stocker en mémoire lors de leurs utilisation. (de plus il n'y aura qu'un seul utilisateur).

Dans ce cas, vous pourriez regarder le format json. Il est capable de sauvegarder les types simples dans des hiérarchies composites (list, dict,...) et à le mérite d'être "révisable" (vous pouvez vérifier et modifier ce qui a été écrit avec un éditeur).

- W