L'obtention de valeurs avec le bon type dans le Redis

Je suis en utilisant le redis dans mon application en python pour stocker des valeurs simples telles que les comptoirs et l'horodatage des listes, mais en essayant d'obtenir un compteur et de le comparer avec un numéro, je suis tombé sur un problème.

Si je fais:

import redis
...
myserver = redis.Redis("localhost")
myserver.set('counter', 5)

et puis essayer d'obtenir cette valeur comme ceci:

if myserver.get('counter') < 10:
     myserver.incr('counter')

puis-je obtenir un type d'erreur dans l'instruction if parce que je suis la comparaison '5' < 10, ce qui signifie je suis stocker une valeur de type entier et d'obtenir une chaîne d'un (qui peut être considéré comme une valeur différente).

Ma question est: est-ce censé fonctionner comme ça? Je veux dire, c'est une très type de base, je comprends, si je dois analyser des objets, mais un int? Semble que je suis en train de faire quelque chose de mal.

Est-il une configuration qui me manque?

Est-il possible de faire redis retourner le bon type et pas toujours une chaîne de caractères?
Je dis cela parce que c'est la même chose pour les listes et les datetimes ou même des valeurs à virgule flottante.

- Ce que cela pourrait être un problème avec le redis-py client que j'utilise et pas redis lui-même?

J'ai été déconner avec la src/redis-cli qui vient avec leur distribution. Malheureusement, il ressemble redis magasins entiers comme des chaînes de caractères, et en déduit t-il des types lors incr/decr opérations.
vous pouvez utiliser si int(monserveur.get('compteur'))<10.

InformationsquelleAutor jeruki | 2012-10-25

14

Techniquement parlant, vous avez besoin de prendre soin de ce sur votre propre.

Cependant, ont un oeil à ce lien, en particulier dans le cadre de leur README qui se réfère à des analyseurs et de la réponse des rappels, peut-être que c'est quelque chose que vous pouvez utiliser. La Question serait de savoir si cela est trop pour vous ou pas.
- merci j'ai vérifié les analyseurs mais ils semblent compliquer des choses pour ce que je veux faire, à la fin j'ai décidé d'utiliser cpickle pour gérer la sérialisation de données
InformationsquelleAutor favoretti
14

Comme @favoretti dit, la réponse rappels fera l'affaire. C'est pas compliquer du tout, juste une ligne et tout sera pris en charge.
```
In [2]: import redis
In [3]: r = redis.Redis()
In [10]: r.set_response_callback('HGET', float)
In [11]: r.hget('myhash', 'field0')
Out[11]: 4.6
```
pour hmget, elle retourne une liste de chaînes, pas une chaîne unique, vous avez besoin de construire un peu plus exhaustive de la fonction de rappel:
```
In [12]: r.set_response_callback('HMGET', lambda l: [float(i) for i in l])

In [13]: r.hmget('myhash', 'field0')
Out[13]: [4.6]
```
même pour hgetall.
- Essayé de mettre le flotteur de rappel pour les "HMGET" et "HGETALL" il échoue malheureusement. Je suppose qu'il tente de transformer la clé de hachage noms.
InformationsquelleAutor pingz
4

Semble que cela est de savoir comment redis stocke ses données:
```
redis 127.0.0.1:6379> set counter 5
OK
redis 127.0.0.1:6379> type counter
string
redis 127.0.0.1:6379> incr counter
(integer) 6
redis 127.0.0.1:6379> type counter
string
```
Si vous vraiment voulez, vous pourriez probablement monkeypatch la redis-py client pour en déduire les types de données.
- c'est apparemment j'ai juste pensé que redis-py aurait un mécanisme de travailler avec ça, merci
InformationsquelleAutor Joel Cornett
3

Vous pouvez définir decode_respone comme de Vrais
```
redis.StrictRedis(host="localhost", port=6379, db=0, decode_responses=True)
```
InformationsquelleAutor Lucas Picoloto

Bien que tirant parti de set_response_callback est très bien pour les types de données simples, si vous vous demandez à propos de la manière la plus rapide et la plus simple de l'itinéraire pour stocker des choses comme des dictionnaires, une liste de tuples – et la préservation de l'python-native types de données qu'ils peuvent-ou-peut-pas à contenir, je recommande l'utilisation de python intégré dans pickle bibliothèque:

# Imports and simplified client setup
>>> import pickle
>>> import redis
>>> client = redis.Redis()
# Store a dictionary
>>> to_store = {'a': 1, 'b': 'A string!', 'c': [1, True, False, 14.4]}
>>> client.set('TestKey', pickle.dumps(to_store))
True
# Retrieve the dictionary you just stored.
>>> retrieved = pickle.loads(client.get('TestKey'))
{'a': 1, 'b': 'A string!', 'c': [1, True, False, 14.4]}

Ici est un client simple qui permettra de réduire le pickle standard dans l'exemple ci-dessus et de vous fournir une interface propre pour stocker et récupérer des indigènes python les types de données vers et à partir de Redis:

"""Redis cache."""
import pickle
import redis

redis_host = redis.Redis()


class PythonNativeRedisClient(object):
    """A simple redis client for storing and retrieving native python datatypes."""

    def __init__(self, redis_host=redis_host):
        """Initialize client."""
        self.client = redis_host

    def set(self, key, value, **kwargs):
        """Store a value in Redis."""
        return self.client.set(key, pickle.dumps(value), **kwargs)

    def get(self, key):
        """Retrieve a value from Redis."""
        val = self.client.get(key)
        if val:
            return pickle.loads(val)
        return None

redis_client = PythonNativeRedisClient()

Utilisation:

>>> from some_module import redis_client
>>> to_store = {'a': 1, 'b': 'A string!', 'c': [1, True, False, 14.4]}
>>> redis_client.set('TestKey', to_store)
True
>>> retrieve = redis_client.get('TestKey')
{'a': 1, 'b': 'A string!', 'c': [1, True, False, 14.4]}

InformationsquelleAutor respondcreate

Voici mon test. Deux redis connexions: retourne le type int, l'autre flotteur

import redis

age_field = redis.Redis()
age_field.set_response_callback('HGET', int)
age_field.hget('foo', 'age')
# OUT: 40
a =age_field.hget('foo', 'age')
type(a)
# OUT: <type 'int'>

gpa_field = redis.Redis()
gpa_field.set_response_callback('HGET', float)
gpa_field.hget('foo', 'gpa')
# OUT: 2.5
b = gpa_field.hget('foo', 'gpa')
type(b)
# OUT: <type 'float'>

InformationsquelleAutor Jie Bao

Vous devez vous connecter pour publier un commentaire.