Outils pour utilisateurs

Outils du site


sauve_recup_objets

Ceci est une ancienne révision du document !


Sauvegarder et recharger des objets Python de base

Quelques essais de sauvegarde et de récupération d'objets Python m'ont montré que cela n'était pas aussi évident que cela.

L'objectif étant, bien sûr, de récupérer un objet identique en valeur et en type! Par exemple, on sauvegarde un entier, et on veut récupérer un entier et pas une chaîne de caractère!

Sauvegarde et recharge d'objets Python avec le module shelve

Le module shelve, qui fait partie du domaine de la “persistance des données”, est très puissant, et donne un code très simple.

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
# objets a sauvegarder sur disque et à recuperer
L0=True
L1=123
L2=456L
L3=1.789e5
L4=complex(1,2)
L5="ABC"
L6='DEF'
L7=[L0,L1,L2,L3,L4,L5,L6]
L8=(L0,L1,L2,L3,L4,L5,L6)
L9={'L0':L0,'L1':L1,'L2':L2,'L3':L3,'L4':L4,'L5':L5,'L6':L6}
 
print "objets a sauvegarder:" 
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
 
#########################################################################
# Sauvegarde et récupération d'objets Python avec le module 'shelve'
# attention: la sauvegarde dans le fichier 'historiquedbm' est binaire!
 
import shelve
 
d = shelve.open('historiquedbm')
 
# sauvegarde des objets
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.close()
 
d = shelve.open('historiquedbm')
 
# récupération des objets sauvegardés
R0 = d['L0']
R1 = d['L1']
R2 = d['L2']
R3 = d['L3']
R4 = d['L4']
R5 = d['L5']
R6 = d['L6']
R7 = d['L7']
R8 = d['L8']
R9 = d['L9']
d.close()
 
print "objets recuperes par shelve:" 
print R0, type(R0)
print R1, type(R1)
print R2, type(R2)
print R3, type(R3)
print R4, type(R4)
print R5, type(R5)
print R6, type(R6)
print R7, type(R7)
print R8, type(R8)
print R9, type(R9)
print

Résultat de l'exécution:

objets a sauvegarder:
True <type 'bool'>
123 <type 'int'>
456 <type 'long'>
178900.0 <type 'float'>
(1+2j) <type 'complex'>
ABC <type 'str'>
DEF <type 'str'>
[True, 123, 456L, 178900.0, (1+2j), 'ABC', 'DEF'] <type 'list'>
(True, 123, 456L, 178900.0, (1+2j), 'ABC', 'DEF') <type 'tuple'>
{'L6': 'DEF', 'L4': (1+2j), 'L5': 'ABC', 'L2': 456L, 'L3': 178900.0, 'L0': True, 'L1': 123} <type 'dict'>
 
objets recuperes par shelve:
True <type 'bool'>
123 <type 'int'>
456 <type 'long'>
178900.0 <type 'float'>
(1+2j) <type 'complex'>
ABC <type 'str'>
DEF <type 'str'>
[True, 123, 456L, 178900.0, (1+2j), 'ABC', 'DEF'] <type 'list'>
(True, 123, 456L, 178900.0, (1+2j), 'ABC', 'DEF') <type 'tuple'>
{'L6': 'DEF', 'L4': (1+2j), 'L5': 'ABC', 'L2': 456L, 'L3': 178900.0, 'L0': True, 'L1': 123} <type 'dict'>

Vous voyez que les objets récupérés sont identiques en valeur et en type avec les données de départ.

Sauvegarde et recharge d'objets Python avec la méthode traditionnelle adaptée

On utilise ici la méthode traditionnelle avec ouverture de fichier par open, écriture par write, lecture par readline, etc…

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
# objets a sauvegarder sur disque et à recuperer
L0=True
L1=123
L2=456L
L3=1.789e5
L4=complex(1,2)
L5="ABC"
L6='DEF'
L7=[L0,L1,L2,L3,L4,L5,L6]
L8=(L0,L1,L2,L3,L4,L5,L6)
L9={'L0':L0,'L1':L1,'L2':L2,'L3':L3,'L4':L4,'L5':L5,'L6':L6}
 
print "objets a sauvegarder:" 
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
 
#########################################################################
# Sauvegarde et récupération d'objets Python avec la méthode traditionnelle
# le contenu du fichier de sauvegarde est éditable avec un éditeur de texte
 
f = open("historique", 'w')
 
# sauvegardes des objets
f.write(repr(L0)+'\r\n')
f.write(repr(L1)+'\r\n')
f.write(repr(L2)+'\r\n')
f.write(repr(L3)+'\r\n')
f.write(repr(L4)+'\r\n')
f.write(repr(L5)+'\r\n')
f.write(repr(L6)+'\r\n')
f.write(repr(L7)+'\r\n')
f.write(repr(L8)+'\r\n')
f.write(repr(L9)+'\r\n')
f.close()
 
f = open("historique", 'r')
 
# récupération des objets sauvegardés
R0 = eval(f.readline().rstrip('\r\n'))
R1 = eval(f.readline().rstrip('\r\n'))
R2 = eval(f.readline().rstrip('\r\n'))
R3 = eval(f.readline().rstrip('\r\n'))
R4 = eval(f.readline().rstrip('\r\n'))
R5 = eval(f.readline().rstrip('\r\n'))
R6 = eval(f.readline().rstrip('\r\n'))
R7 = eval(f.readline().rstrip('\r\n'))
R8 = eval(f.readline().rstrip('\r\n'))
R9 = eval(f.readline().rstrip('\r\n'))
f.close()
 
print "objets recuperes par open:" 
print R0, type(R0)
print R1, type(R1)
print R2, type(R2)
print R3, type(R3)
print R4, type(R4)
print R5, type(R5)
print R6, type(R6)
print R7, type(R7)
print R8, type(R8)
print R9, type(R9)
print

Ce qui donne comme résultat d'exécution:

objets a sauvegarder:
True <type 'bool'>
123 <type 'int'>
456 <type 'long'>
178900.0 <type 'float'>
(1+2j) <type 'complex'>
ABC <type 'str'>
DEF <type 'str'>
[True, 123, 456L, 178900.0, (1+2j), 'ABC', 'DEF'] <type 'list'>
(True, 123, 456L, 178900.0, (1+2j), 'ABC', 'DEF') <type 'tuple'>
{'L6': 'DEF', 'L4': (1+2j), 'L5': 'ABC', 'L2': 456L, 'L3': 178900.0, 'L0': True, 'L1': 123} <type 'dict'>
 
objets recuperes par open:
True <type 'bool'>
123 <type 'int'>
456 <type 'long'>
178900.0 <type 'float'>
(1+2j) <type 'complex'>
ABC <type 'str'>
DEF <type 'str'>
[True, 123, 456L, 178900.0, (1+2j), 'ABC', 'DEF'] <type 'list'>
(True, 123, 456L, 178900.0, (1+2j), 'ABC', 'DEF') <type 'tuple'>
{'L6': 'DEF', 'L4': (1+2j), 'L5': 'ABC', 'L2': 456L, 'L3': 178900.0, 'L0': True, 'L1': 123} <type 'dict'>

Vous voyez que les objets récupérés sont identiques en valeur et en type avec les données de départ. Il sont aussi identiques aux résultats de shelve, à part que le fichier de sauvegarde est consultable et éditable avec un simple éditeur de texte.

sauve_recup_objets.1207982729.txt.gz · Dernière modification: 2008/04/12 08:45 de tyrtamos

Outils de la page