comment stocker un objet complexe dans le redis (à l'aide de redis-py)

La hmset fonction peut définir la valeur de chaque champ, mais j'ai trouvé que si la valeur elle-même est une structure complexe, l'objet, la valeur de retour de hget est une chaîne sérialisée, pas l'objet d'origine

e.g

images= [{'type':'big', 'url':'....'},
     {'type':'big', 'url':'....'},
     {'type':'big', 'url':'....'}]   

redis = Redis()
redis.hset('photo:1', 'images', images)

i = redis.hget('photo:1', 'images')
print type(i)

le type de i est une chaîne de caractères, pas un objet python, est-il un moyen de résoudre ce problème d'ailleurs manuellement analyser chaque champs?

InformationsquelleAutor yuan | 2013-03-05

python redis

46

Vous ne pouvez pas créer de structures imbriquées dans le Redis, ce qui signifie que vous ne pouvez pas (par exemple) pour stocker un natif redis liste à l'intérieur d'un natif redis hachage carte.

Si vous avez vraiment besoin de structures imbriquées, vous pouvez stocker un JSON-goutte (ou quelque chose de similaire) à la place. Une autre option est de conserver un "id"/clé à un autre redis objet que la valeur de la carte de clé, mais qui nécessite de multiples appels vers le serveur pour obtenir l'intégralité de l'objet.
- Oh, et encore une chose; Il pourrait être possible de faire un étrange composé-requête à l'aide de la fonction EVAL (côté serveur ruby script): redis.io/commandes/eval
InformationsquelleAutor Jonatan Hedborg
78

En fait, vous pouvez stocker des objets python dans le redis en utilisant le module intégré cornichon.

Ici est un exemple.
```
import pickle
import redis

r = redis.StrictRedis(host='localhost', port=6379, db=0)
obj = ExampleObject()
pickled_object = pickle.dumps(obj)
r.set('some_key', pickled_object)
unpacked_object = pickle.loads(r.get('some_key'))
obj == unpacked_object
```
- C'est dangereux: unpickling peut exécuter du code. Le JSON solution est plus robuste.
- pouvez-vous elborate plus loin sur ce point? pourquoi l'exécution de code une mauvaise chose?
- Je voulais dire que le décapage permet l'exécution de non fiable code, ce qui est préférable d'éviter, étant donné que le code en question peuvent être malveillants (il peut effacer des fichiers, etc.).
- je ne pense pas que votre redis est source non fiable. Vous ne pouvez pas empêcher les gens de se tirant dans le pied
- OK, assez juste, puisque la question initiale, en effet, se connecte localement. Pas downvote de moi. Le local Redis peut être une copie locale d'une source non fiable, je vais donc laisser mon commentaire ci-dessus, il ne peut pas faire de mal. 🙂
- Il est préférable d'utiliser cPickle que pickle, parce que cPickle a une meilleure performance.
- Il me semble JSON est préférable lorsque cela est possible, mais il y a un grand nombre d'objets qui ne peuvent pas être sérialisé en JSON.
- Bon point: ce serait principalement mon critère pour l'utilisation de cornichon au lieu de JSON, dans le cas de la question d'origine (l'autre critère serait de savoir si la source est fiable). Cela dit, il est souvent possible de faire des objets JSON-sérialisable, mais il s'agit généralement de l'écriture personnalisée JSON d'écriture/lecture de code, ce qui n'est pas aussi pratique que l'utilisation de cornichon, en effet.
- A titre d'exemples struct_time n'est pas la sérialisation json, mais c'est sérialisable par la saumure.
- Si vous déboguer dans le redis bibliothèque, je crois qu'il cornichons vos données avant de les mettre dans le redis. Au moins à l'aide flask_caching qui, je crois, appelle le sous-jacent redis code de mise en cache. En fait j'ai été à la recherche pour voir si il y avait une option pour modifier ce comportement ou à l'utilisation d'un plus sûr cornichon comme le serpent.
- csv? première ligne peut être l'en-tête et le reste peut être super compressé par rapport à json
- Je viens de tester avec quelques objets. Le décapant est plus lent que Json blob. Pour les deux de vidage et de la charge.
InformationsquelleAutor Kyrylo Perevozchikov

JSON Exemple:

import json
import redis

r = redis.StrictRedis(host='localhost', port=6379, db=0)

images= [
    {'type':'big', 'url':'....'},
    {'type':'big', 'url':'....'},
    {'type':'big', 'url':'....'},
]

json_images = json.dumps(images)
r.set('images', json_images)
unpacked_images = json.loads(r.get('images'))
images == unpacked_images

python 3:

unpacked_images = json.loads(r.get('images').decode('utf-8'))
images == unpacked_images

est-il normal de se btyes objet de redis.get()? j'ai eu b'['something']' en python 3
Ressemble json.loads() ne pas jouer gentil avec bytes objets en python3. Vous aurez besoin de décoder le bytes résultat de redis.get() en python3 str. Voir la nouvelle édition.

InformationsquelleAutor CivFan

5

J'ai créé une bibliothèque, SubRedis, qui vous permet de créer beaucoup plus complexe structures et hiérarchies dans le redis. Si vous lui donnez un redis instance et d'un préfixe, il vous donne un peu près entièrement indépendant et capable redis instance.
```
redis = Redis()
photoRedis = SubRedis("photo:%s" % photoId, redis)
photoRedis.hmset('image0', images[0])
photoRedis.hmset('image1', images[1])
...
```
SubRedis se termine juste en haut ajoutant la chaîne de caractères passée en elle comme un préfixe sur le plat redis structure de données. Pour moi c'est une pratique de l'enveloppe pour un patron que j'ai finit par faire beaucoup dans le redis -- ajoutant quelques id de nid de certaines données.

InformationsquelleAutor Doug T.

Vous pouvez utiliser RedisWorks bibliothèque.

pip install redisworks

>>> from redisworks import Root
>>> root = Root()
>>> root.something = {1:"a", "b": {2: 2}}  # saves it as Hash
>>> print(root.something)  # loads it from Redis
{'b': {2: 2}, 1: 'a'}
>>> root.something['b'][2]
2

Il convertit python les types de Redis types et vice-versa.

>>> root.sides = [10, [1, 2]]  # saves it as list in Redis.
>>> print(root.sides)  # loads it from Redis
[10, [1, 2]]
>>> type(root.sides[1])
<class 'list'>

Avertissement: j'ai écrit de la bibliothèque. Voici le code: https://github.com/seperman/redisworks

InformationsquelleAutor Seperman

Ici est un simple wrapper autour de Redis qui cornichons/unpickles structures de données:

from redis import Redis
from collections import MutableMapping
from pickle import loads, dumps
class RedisStore(MutableMapping):
def __init__(self, engine):
self._store = Redis.from_url(engine)
def __getitem__(self, key):
return loads(self._store[dumps(key)])
def __setitem__(self, key, value):
self._store[dumps(key)] = dumps(value)
def __delitem__(self, key):
del self._store[dumps(key)]
def __iter__(self):
return iter(self.keys())
def __len__(self):
return len(self._store.keys())
def keys(self):
return [loads(x) for x in self._store.keys()]
def clear(self):
self._store.flushdb()
d = RedisStore('redis://localhost:6379/0')
d['a'] = {'b': 1, 'c': 10}
print repr(d.items())
# this will not work: (it updates a temporary copy and not the real data)
d['a']['b'] = 2
print repr(d.items())
# this is how to update sub-structures:
t = d['a']
t['b'] = 2
d['a'] = t
print repr(d.items())
del d['a']
# Here is another way to implement dict-of-dict eg d['a']['b']
d[('a', 'b')] = 1
d[('a', 'b')] = 2
print repr(d.items())
# Hopefully you do not need the equivalent of d['a']
print repr([{x[0][1]: x[1]} for x in d.items() if x[0][0] == 'a'])
del d[('a', 'b')]
del d[('a', 'c')]

Si vous préférez-en-clair de données lisibles dans le redis (pickle stocke une version binaire), vous pouvez remplacer les cornichons.décharges avec des repr et cornichons.charges avec l'ast.literal_eval. Pour json, l'utilisation de json.décharges et json.les charges.

Si vous utilisez toujours les touches qui sont une simple chaîne de caractères, vous pouvez supprimer le décapage de la clé.

InformationsquelleAutor Curtis Yallop

-1

Vous pouvez stocker tout votre structure et à faire un 'eval' pour convertir de la Chaîne de l'Objet:

images= [{'type':'big', 'url':'....'},
{'type':'big', 'url':'....'},
{'type':'big', 'url':'....'}]   
redis = Redis()
redis.hset('photo:1', 'images', images)
i = eval(redis.hget('photo:1', 'images'))
print type(i) #type of i should be list instead of string now

C'est inutilement dangereux: arbitraire de code Python est évalué par le biais de eval(). Le JSON approche ne souffre pas de cette.

InformationsquelleAutor fruitJuice

Vous devez vous connecter pour publier un commentaire.