python redis详解(七)ZSET有序集合

我不是女神ヾ 2021-12-10 11:39 902阅读 0赞

redis有序集合：

Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。

不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

zset的成员是唯一的,但分数(score)却可以重复。

python redis提供的方法与命令行基本一致， 具体的函数及含义可以参考给定的命令行来使用， 对应的函数名称与命令名称基本一致

首先了解官方的命令， 目前有25个命令， 具体如下：

--------------------

##### 官方命令列表： #####

1 `ZADD key score1 member1 [score2 member2]` 向有序集合添加一个或多个成员，或者更新已存在成员的分数  
2 `ZCARD key` 获取有序集合的成员数  
3 `ZCOUNT key min max` 计算在有序集合中指定区间分数的成员数  
4 `ZINCRBY key increment member` 有序集合中对指定成员的分数加上增量 increment  
5 `ZINTERSTORE destination numkeys key [key ...]` 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中  
6 `ZLEXCOUNT key min max` 在有序集合中计算指定字典区间内成员数量  
7 `ZRANGE key start stop [WITHSCORES]` 通过索引区间返回有序集合成指定区间内的成员  
8 `ZRANGEBYLEX key min max [LIMIT offset count]` 通过字典区间返回有序集合的成员  
9 `ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]` 通过分数返回有序集合指定区间内的成员  
10 `ZRANK key member` 返回有序集合中指定成员的索引  
11 `ZREM key member [member ...]` 移除有序集合中的一个或多个成员  
12 `ZREMRANGEBYLEX key min max` 移除有序集合中给定的字典区间的所有成员  
13 `ZREMRANGEBYRANK key start stop` 移除有序集合中给定的排名区间的所有成员  
14 `ZREMRANGEBYSCORE key min max` 移除有序集合中给定的分数区间的所有成员  
15 `ZREVRANGE key start stop [WITHSCORES]` 返回有序集中指定区间内的成员，通过索引，分数从高到底  
16 `ZREVRANGEBYSCORE key max min [WITHSCORES]` 返回有序集中指定分数区间内的成员，分数从高到低排序  
17 `ZREVRANK key member` 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序  
18 `ZSCORE key member` 返回有序集中，成员的分数值  
19 `ZUNIONSTORE destination numkeys key [key ...]` 计算给定的一个或多个有序集的并集，并存储在新的 key 中  
20 `ZSCAN key cursor [MATCH pattern] [COUNT count]` 迭代有序集合中的元素（包括元素成员和元素分值）  
21 `BZPOPMAX kes timeout` BZPOPMAX是有序集ZPOPMAX原语的阻塞变体。 当没有任何成员从任何给定的有序集中弹出时，  
它会阻止连接 timeout 为阻塞的超时时间，防止一直阻塞 例如： `BZPOPMAX zset1 zset2 0`  
22 `BZPOPMIN` 阻塞抛出最小值  
23 `ZPOPMAX` 抛出最大值  
24 `ZPOPMIN` 抛出最小值  
25 `ZREVRANGEBYLEX` 当排序集中的所有元素都插入相同的分数时，为了强制执行词典排序，此命令将返回排序集中的所有元素，其key值为max和之间min  
例如：

redis>  ZREVRANGEBYLEX myzset（g [aaa
    1）“f”
    2）“e”
    3）“d”
    4）“c”
    5）“b”

--------------------

##### PYTHON REDIS #####

python-redis提供了对应的25种命令支持， 对应的名称与命令行基本一致

如下为一些函数的用法：

`def zadd(self, name, mapping, nx=False, xx=False, ch=False, incr=False)`  
在name对应的有序集合中添加元素

rediscli.zadd("me1", mapping={"x1": 1, "x2": 3})

`def zcard(self, name)`  
获取有序集合的成员数

rediscli.zcard("me1")

`def zcount(self, name, min, max)`  
获取name对应的有序集合中分数 在 \[min,max\] 之间的个数

rediscli.zcount("me1", 0, 5)

`def zincrby(self, name, amount, value)`  
有序集合name中对指定成员的分数加上增量 increment

`def zinterstore(self, dest, keys, aggregate=None)`  
计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中

`def zlexcount(self, name, min, max)`  
在有序集合中计算指定字典区间内成员数量

rediscli.zlexcount('me1', "[a", "[v")

`def zpopmax(self, name, count=None)`  
抛出最大值

`def zpopmin(self, name, count=None)`  
抛出最小值

`def bzpopmax(self, keys, timeout=0)`  
抛出最大值

`def bzpopmin(self, keys, timeout=0)`

`def zrange(self, name, start, end, desc=False, withscores=False, score_cast_func=float)`

按照索引范围获取name对应的有序集合的元素

参数：  
name，redis的name  
start，有序集合索引起始位置（非分数）  
end，有序集合索引结束位置（非分数）  
desc，排序规则，默认按照分数从小到大排序  
withscores，是否获取元素的分数，默认只获取元素的值  
score\_cast\_func，对分数进行数据转换的函数

rediscli.zrange('me1', 0, 5)
    
    输出： ['x1', 'x2']
    rediscli.zrange('me1', 0, 5, withscores=True)
    输出：
    [('x1', 1.0), ('x2', 3.0)]

`def zrangebylex(self, name, min, max, start=None, num=None)`

通过字典区间返回有序集合的成员

参数：  
name，redis的name  
min，左区间（值）。 + 表示正无限； - 表示负无限； ( 表示开区间； \[ 则表示闭区间  
min，右区间（值）  
start，对结果进行分片处理，索引位置  
num，对结果进行分片处理，索引后面的num个元素

zrangebylex('me1', '-', '(x')

`def zrevrangebylex(self, name, max, min, start=None, num=None)`

`def zrangebyscore(self, name, min, max, start=None, num=None, withscores=False, score_cast_func=float)`

rediscli.zrangebyscore('me1', 2, 5)

`def zrank(self, name, value)`  
获取某个值在 name对应的有序集合中的排行（从 0 开始）

`def zrem(self, name, *values)`  
删除name对应的有序集合中值是values的成员

`def zremrangebylex(self, name, min, max)`

`def zremrangebyrank(self, name, min, max)`  
根据排行范围删除

`def zremrangebyscore(self, name, min, max)`  
根据分数范围删除

`def zrevrange(self, name, start, end, withscores=False, score_cast_func=float)`

`def zrevrangebyscore(self, name, max, min, start=None, num=None, withscores=False, score_cast_func=float)`

`def zrevrank(self, name, value)`

`def zscore(self, name, value)`

`zscan(name, cursor=0, match=None, count=None, score_cast_func=float)`

rediscli.scan()
    
    输出： (0L, ['me1', 'm1', 'name', 'm2'])

`zscan_iter(name, match=None, count=None,score_cast_func=float)`

列出所有键， 生成器的形式，相较于字符串新增score\_cast\_func，用来对分数进行操作

`def zinterstore(dest, keys, aggregate=None)`

获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作  
aggregate的值为: SUM MIN MAX

`def zunionstore(dest, keys, aggregate=None)`

获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作  
aggregate的值为: SUM MIN MAX

--------------------

#### 示例程序： ####

# coding:utf-8
    
    import redis
    
    rediscli = redis.Redis(host='127.0.0.1', port=8888, db=13)
    
    print rediscli.zadd("me1", mapping={"x1": 1, "x2": 3})
    print rediscli.zadd("me2", mapping={"x1": 1, "x3": 5, "x4": 3})
    
    print rediscli.zcard("me1")
    print rediscli.zcount("me1", 0, 5)
    print rediscli.zrange('me1', 0, 5, withscores=False)
    print rediscli.zrange('me1', 0, 5, withscores=True)
    print rediscli.zincrby("me1", amount=1, value="x1")
    
    print rediscli.zinterstore(dest="me3", keys=['me1', 'me2'])
    print rediscli.zrange('me3', 0, 5, withscores=True)
    
    print rediscli.zlexcount('me1', "[a", "[v")
    print rediscli.zrangebylex('me1', '-', '(x')
    print rediscli.zrangebyscore('me1', 2, 5)
    
    print rediscli.zrank('me1', 'x1')
    print rediscli.zscore('me1', 'x1')
    
    print rediscli.zadd('me1', mapping={"x4": 4})
    print rediscli.zrem('me1', 'x4')
    print  rediscli.zremrangebyrank('me1', 7, 10)
    print rediscli.zremrangebyscore('me1', 11, 15)
    
    print rediscli.zrevrangebyscore('me1', 8, 3)
    print rediscli.zrevrange('me1', 0, -1, withscores=True)
    print rediscli.zrange('me1', 0, -1, withscores=True)
    
    print rediscli.scan()

输出结果：

2
    3
    2
    2
    ['x1', 'x2']
    [('x1', 1.0), ('x2', 3.0)]
    2.0
    1
    [('x1', 3.0)]
    0
    []
    ['x1', 'x2']
    0
    2.0
    1
    1
    0
    0
    ['x2']
    [('x2', 3.0), ('x1', 2.0)]
    [('x1', 2.0), ('x2', 3.0)]
    (0L, ['me3', 'me2', 'me1'])