PNL | Almacenamiento de un diccionario ordenado en Redis

Un diccionario ordenado es como un dictado normal, pero las teclas están ordenadas por una función de ordenación. En el caso de Redis, admite diccionarios ordenados cuyas claves son strings y cuyos valores son puntuaciones de punto flotante. Esta estructura puede ser útil en los casos en que se debe calcular la ganancia de información y se deben almacenar todas las palabras y puntajes para su uso posterior.
La clase RedisOrderedDict en rediscollections.py amplía las colecciones. MutableMapping para obtener una serie de métodos compatibles con dict de forma gratuita. Luego, implementa todos los métodos clave que requieren comandos de conjunto ordenado de Redis (también conocido como Zset ):
Código: almacenar una distribución de frecuencia en Redis.

class RedisOrderedDict(collections.MutableMapping):
      
    def __init__(self, r, name):
        self._r = r
        self._name = encode_key(name)
          
    def __iter__(self):
        return iter(self.items())
      
    def __len__(self):
        return self._r.zcard(self._name)
      
    def __getitem__(self, key):
        return self._r.zscore(self._name, encode_key(key))
     
    def __setitem__(self, key, score):
        self._r.zadd(self._name, encode_key(key), score)
      
    def __delitem__(self, key):
        self._r.zrem(self._name, encode_key(key))
     
    def keys(self, start = 0, end =-1):
        # we use zrevrange to get keys sorted
        # by high value instead of by
        lowest
        return self._r.zrevrange(self._name, start, end)
      
    def values(self, start = 0, end =-1):
        return [v for (k, v) in self.items(start = start, end = end)]
      
    def items(self, start = 0, end =-1):
        return self._r.zrevrange(self._name, start, end, withscores = True)
      
    def get(self, key, default = 0):
        return self[key] or default
      
    def iteritems(self):
        return iter(self)
      
    def clear(self):
        self._r.delete(self._name)

Código: crear una instancia de RedisOrderedDict pasando una conexión Redis y un nombre único

from redis import Redis
from rediscollections import RedisOrderedDict
  
r = Redis()
rod = RedisOrderedDict(r, 'test')
rod.get('bar')
  
rod['bar'] = 5.2
print (rod['bar'])
  
print (len(rod))
  
print (rod.items()) 
  
rod.clear()

Producción:

0
5.2000000000000002
1
[(b'bar', 5.2)]

Gran parte del código puede parecerse a RedisHashMap, lo cual es de esperar ya que ambos amplían collections.MutableMapping . La principal diferencia aquí es que RedisOrderedSet ordena las claves por valores de punto flotante, por lo que no es adecuado para el almacenamiento arbitrario de valores clave como RedisHashMap .
Esquema que explica cada método clave y cómo funcionan con Redis:

• __len__(): Esto usa el comando zcard para obtener el número de elementos en el conjunto ordenado.
• __getitem__(): utiliza el comando zscore para obtener la puntuación de una clave y devuelve 0 si la clave no existe.
• __setitem__(): Esto usa el comando zadd para agregar una clave al conjunto ordenado con el puntaje dado, o actualiza el puntaje si la clave ya existe.
• __delitem__(): utiliza el comando zrem para eliminar una clave del conjunto ordenado.
• keys(): utiliza el comando zrevrange para obtener todas las claves del conjunto ordenado, ordenadas por la puntuación más alta. Se necesitan dos argumentos de palabra clave opcionales, inicio y fin, para obtener de manera más eficiente una porción de las claves ordenadas.