Python: Test si l'entrée du dictionnaire (dict) a été modifiée

Question

J'ai écrit un petit wrapper pour la classe intégrée dict qui charge les entrées (valeurs) d'un dictionnaire depuis cPickle d fichiers dès que la clé correspondante est accédée pour la première fois . Lorsque le dictionnaire est détruit, toutes les entrées chargées sont réécrites sur le disque.

Maintenant, il serait pratique que je vérifie si l'une des valeurs a été modifiée et n'écris que celles qui l'ont été. Ma question est donc la suivante: un dictionnaire sait-il si une valeur a été modifiée? Ou y a-t-il un moyen intelligent d'implémenter cela de manière transparente?

Pour être complet, je joins le code que j'utilise. Il est appelé avec le chemin où les fichiers sont stockés (les clés sont utilisées comme noms de fichiers) et avec une liste de clés pour lesquelles des fichiers existent.

import cPickle 

class DictDB(dict): 

    def __init__(self, path, folders): 
    self.picklepath  = path # path to files on disk 
    self.folders  = folders # available folders 
    self.loaded_folders = {} 

    def has_key(self, key): 
    return key in self.folders 

    def get(self, key): 
    if not key in self.loaded_folders.keys(): 
     if not key in self.folders: 
     raise KeyError("Folder "+key+" not available") 
     # load from disk 
     self.loaded_folders[key] = cPickle.load(file(self.picklepath + key + ".cpickle2")) 
    return self.loaded_folders[key] 

    def __getitem__(self, key): 
    return self.get(key) 

    def close(self): 
    for folder in self.loaded_folders.keys(): 
     # write back 
     cPickle.dump(self.loaded_folders[folder], file(picklepath + folder + '.cpickle2', 'w'), 2) 

    def __del__(self): 
    self.close() 

Answer 1

Je pourrais l'approcher avec une sorte de modèle de publication-abonnement, où le dictionnaire contenant souscrit à chacun des sous-dictionnaires (ou d'autres valeurs). Puis, quand l'un d'entre eux est édité, il avertit tous les dictionnaires qui le contiennent. Si vous ne voulez pas qu'ils traitent tous du câblage pour cela et acceptent que le dictionnaire contenant ne vérifie que les changements d'accès ou à des intervalles définis, vous pouvez faire en sorte que chaque objet contenu garde une trace d'un numéro version . Ensuite, lorsque le dictionnaire contenant est prêt, il vérifie simplement si ce numéro de version a changé.

Une dernière possibilité serait d'avoir un moyen de calculer de façon fiable des valeurs de hachage pour les objets contenus en place. Cela vous permettrait d'écrire une fonction externe et de supprimer le besoin pour les objets de suivre leurs propres versions, mais a ses propres complexités puisque vous devrez soit surcharger __hash__ sur chacun d'eux ou écrire une autre forme de la fonction hash() qui peut identifier l'objet et en tirer une sorte de valeur hachée intelligente

Answer 2

Je pense que vous pouvez remplacer la méthode __setitem__() de garder une trace des changements des valeurs, stockant les valeurs modifiées dans une liste, et utiliser cette liste pour choisir les valeurs correctes pour écrire.

Answer 3

Vous pouvez stocker deux copies de chaque valeur: état d'origine et état éventuellement modifié. Ensuite, il suffit de les comparer avec != pour choisir lequel écrire.

Answer 4

Si la mémoire le permet, vous pouvez conserver une copie des valeurs d'origine lues à partir du disque et, dans la méthode close(), comparer les valeurs actuelles aux valeurs d'origine, en n'écrivant que les modifications.

Cette méthode donne plus de liberté dans ce qui peut être mis dans le dictionnaire, puisque les éléments n'ont pas besoin de garder trace des changements qui leur sont apportés.