Python操作Redis

Python操作Redis

一、string 操作

1、说明

redis中的String在在内存中按照一个name对应一个value来存储

2、set()

1. 说明

   添加字符串类型的值

2. 方法

   set(name, value, ex=None, px=None, nx=False, xx=False)
   

3. 参数

   • ex

     过期时间（秒）

   • px

     过期时间（毫秒）

   • nx

     如果设置为True，则只有name不存在时，当前set操作才执行,同setnx(name, value)

   • xx

     如果设置为True，则只有name存在时，当前set操作才执行

4. 返回值

   返回True或者False True表示操作成功,False表示操作失败

5. 举个栗子

   import redis
   import time
   
   HOST = '118.25.176.213'
   PORT = 6379
   
   cp = redis.ConnectionPool(host=HOST, port=PORT, decode_responses=True)
   rds = redis.Redis(connection_pool=cp)
   
   rds.set('name', 'xm', px=1000)
   rds.set('name1', 'xm1', ex=3)
   # 等同于
   # 设置过期时间（秒）
   #rds.setex('name', 'xm', 3)
   # 设置过期时间（豪秒
   # rds.psetex('name1', 1000, 'xm1')
   # 睡眠1秒
   time.sleep(1)
   print(rds.get('name'))  # None
   print(rds.get('name1'))  # b'xm1'
   

3、mset

1. 说明

   批量设置值

2. 方法

   mset(*args, **kwargs)
   

3. 参数说明

   • *args

     字典类型

   • **kwargs

     关键字参数

4. 举个栗子

   rds.mset(name='xm', password='123456')
   #或
   rds.mget({"name":'xm', "password":'123456'})
   

4、get

1. 说明

   通过key获取值

2. 方法

   get(key)
   

3. 参数

   • key

     存储的key

4. 返回

   值

5. 举个栗子

5、mget

1. 说明

   批量或者值

2. 方法

   mget(keys, *args)
   

3. 参数

   • keys

     列表类型

   • *args

     可变参数

4. 返回值

   列表

5. 举个栗子

   li = rds.mget('name','passwd')
   #或者
   keys= ['name','passwd']
   li = rds.mget(keys)
   

6、getset

1. 说明

   设置新值，返回原值

2. 方法

   getset(name, value)
   

3. 参数

   • name

     键

   • value

     新的值

4. 返回值

   如果存在返回旧的值,否则返回None

5. 举个栗子

   old_str = rds.getset('name', '小红')
   print(old_str) # None
   new_str = rds.get('name')
   print(new_str) # 小红
   

7、setrange

1. 说明

   修改字符串内容，从指定字符串索引开始向后替换，如果新值太长时，则向后添加

2. 方法

   setrange(name, offset, value)
   

3. 参数

   • name

     键

   • offset

     开始替换的字符串所有位置

   • value

     要替换的新值

4. 返回值

   返回替换后的值的长度

5. 举个栗子

   rds.setrange('k1', 0, 'python') # python
   
   rds.set('k2','hello')
   rds.setrange('k1', 5, 'world') #"helloworld" 
   
   

getrange(key, start, end)、

1. 说明

   根据字节获取子序列

2. 方法

   getrange(key, start, end)
   

3. 参数

   • key

     键

   • start

     要截取的开始的索引, 负值取反

   • end

     结束的索引位置 负值取反

4. 返回值

   截取的字符串

5. 举个栗子

   rds.set('k1', 'hello world')
   rds.getrange('k1', 1,2) # el
   rds.getrange('k1', -1,-2) # ld
   

8、setbit

1. 说明

   对二进制表示位进行操作,将值对应的ASCII码变换成二进制后再进行索引

2. 方法

   setbit(name, offset, value)
   

3. 参数

   • name

     键

   • offset

     偏移量,也就是位的索引（将值对应的ASCII码变换成二进制后再进行索引）

   • value

     值只能是 1 或 0

4. 返回值

   返回被替换的值 0 或者 1

5. 举个栗子

      def bindigits(n, bits):
     s = bin(n & int("1" * bits, 2))[2:]
     return ("{0:0>%s}" % bits).format(s)   
   s = 'hello'
      for i in s:
          print('当前的字母是:%s, 对应的ASC码是: %s, 对应的二进制数据是: %s' % (i, ord(i), bindigits(ord(i), 8)))
          
      """
      当前的字母是:h, 对应的ASC码是: 104, 对应的二进制数据是: 01101000
      当前的字母是:e, 对应的ASC码是: 101, 对应的二进制数据是: 01100101
      当前的字母是:l, 对应的ASC码是: 108, 对应的二进制数据是: 01101100
      当前的字母是:l, 对应的ASC码是: 108, 对应的二进制数据是: 01101100
      当前的字母是:o, 对应的ASC码是: 111, 对应的二进制数据是: 01101111
      """    
      rds.set('k1', s)
      rds.setbit('k1', 21, 0)  # 将第三个l变成h
      print(rds.get('k1')) # hehlo
   

9、getbit

1. 说明

   获取key对应值的二进制中某位的值(0或1)

2. 方法

   getbit(name, offset)
   

3. 参数

4. 返回值

5. 举个栗子

   """
   hello
   01101000|[8]01[10]100101|01101100|01101100|01101111
   """  
   print(rds.getbit('k1', 8)) # 0 
   print(rds.getbit('k1', 10)) # 1
   

10、bitcount

1. 说明

   获取对应二进制中1的个数

2. 方法

   bitcount(key, start=None, end=None)
   

3. 参数

   • key

     键

   • start

     字节起始位置

   • end

     字节结束位置

4. 返回值

   获取对应二进制中1的个数

5. 举个栗子

   import redis
   
   r = redis.Redis(host='118.25.176.213', port=6379, db=0, decode_responses=True)
   
   '''
   理解：
   A用户 100010001000001  //活跃了4天
   B用户 111111111111111  //每日签到
   '''
   # 模拟A用户 ,一年中 每三天登录一次。
   for i in range(2, 365, 2):
       r.setbit('ua', i, 1)
       
   # 模拟B用户,一年中 每60天登录一次。
   for i in range(1, 365, 30):
       r.setbit('ub', i, 1)
   
   users = r.keys('u*')
   # 用户列表
   print(users)
   
   # 存放活跃用户列表
   active_list = []
   # 存放非活跃用户列表
   no_active_list = []
   
   for u in users:
       # 计算登录次数
       login_count = r.bitcount(u)
       if login_count > 100:
           # 列表添加元组 ()对象
           active_list.append((u, login_count))
       else:
           no_active_list.append((u, login_count))
   
   for active in active_list:
       print(active[0] + ' 是活跃用户. 登陆' + str(active[1]) + '天')
   
   for no_active in no_active_list:
       print(no_active[0] + ' 是非活跃用户. 登陆' + str(no_active[1]) + '天')
   

11、strlen

1. 说明

   获取key对应值的字节长度（一个汉字3个字节）

2. 方法

   strlen(name)
   

3. 参数

   • name

     键

4. 返回值

   对应值的字节长度

5. 举个栗子

   r.set("name","xm")
   print(r.strlen("name")) #输出:2
   

12、incr

1. 说明

   自增mount对应的值，当mount不存在时，则创建mount＝amount，否则，则自增,amount为自增数(整数)

2. 方法

   incr(name, amount=1)
   

3. 参数

   • name

     键

   • amount

     当mount不存在时，则创建mount＝amount 默认1，否则，则自增,amount为自增数(整数)

4. 返回值

   返回一个整数，增加后键的值

5. 举个栗子

   rds.incr('count1')
   rds.incr('count2', 2)
   print(rds.get('count1'))
   print(rds.get('count2'))
   

13、incrbyfloat

1. 说明

   浮点数自增

2. 方法

   rds.incrbyfloat('count', 1.1)
   print(rds.get('count'))
   

14、decr(name, amount=1)

1. 说明

   自减name对应的值,当name不存在时,则创建name＝amount，否则，则自减，amount为自增数(整数)

2. 方法

   decr(name, amount=1)
   

3. 返回值

   返回name对象的值

4. 举个栗子

   rds.decr('num', amount=1)
   

15、append

1. 说明

   在name对应的值后面追加内容

2. 方法

   append(name, value)
   

3. 参数

   • name

     键

   • value

     值

4. 返回值

   返回字符串的拼接内容

5. 举个栗子

   rds.set("name","python")
   print(rds.get("name"))    #输出:'python
   rds.append("name","3.6")
   print(rds.get("name"))    #输出:python3.6
   

附表

命令	操作
set	存储给定键的值
get	获取给定键的值
del	删除给定键的值
incr	给键存储的值加1
decr	给键存储的值减1
incrby	给键存储的值加指定的大小
decrby	给键存储的值减去特定的大小
incrbyfloat	给键存储的值加指定的浮点数大小（Redis版本必须大于2.6）
append	将值追加到给定键的末尾
setrange	将一个偏移量为start开始的设置为给定值
getrange	获取一个偏移量在start到end所有字符组成的子串
getbit	获取二进制的值
setbit	设置一个位串的二进制的值
bitcount	统计二进制位串里面值位1的数量，可以给定偏移量
bittop	统计二进制位串里面值位1的数量，可以给定偏移量

二、hash 操作

1、说明

name对应一个dict来存储

2、hset

1. 说明

   name对应的hash中设置一个键值对（不存在，则创建，否则，修改）

2. 方法

   hset(name, key, value)
   

3. 参数

   • name

     redis的name

   • key

     name对应的hash中的key

   • value

     name对应的hash中的value

4. 返回值

   返回0或者1，1表示插入成功，0表示保存失败

5. 举个栗子

   print(rds.hset("user", "name", "小红"))
   print(rds.hset("user", 'password', '123'))
   print(rds.hget('user', "name"))
   print(rds.hget('user', "password"))
   

3、hget

1. 说明

   在name对应的hash中根据key获取value

2. 方法

   hget(name,key)
   

3. 参数

   • name

     redis的name

   • index

     list的索引位置

   • value

     要设置的值

4. 返回值

   在name对应的字典中key对应的值

5. 举个栗子

   见上
   

4、hgetall

1. 说明

   获取name对应hash的所有键值

2. 方法

   hgetall(name)
   

3. 参数

   • name

     存储hash的name

4. 返回值

   字典

5. 举个栗子

   print(rds.hget('user')) # {'name': '小红', 'passwd': '123'}
   

5、hmset

1. 说明

   批量增加

2. 方法

   hmset(name, mapping)
   

3. 参数

   • name，

     redis的name

   • mapping，

     字典，如：{‘k1’:‘v1’, ‘k2’: ‘v2’}

4. 返回值

   返回True或者False

5. 举个栗子

   values = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}
   rds.hmset('k', values)
   

6、hmget

1. 说明

   批量取出

2. 方法

   hmget(name, keys, *args)
   

3. 参数

   • name

     reids对应的name

   • keys

     要获取key集合

   • *args，

     要获取的key，如：k1,k2,k3

4. 返回值

   在name对应的hash中获取多个key的值

5. 举个栗子

   print(rds.hmget('k', ['k1', 'k2'])) # ['v1', 'v2']
   # 或者
   print(rds.hmget('k', 'k1', 'k2')) #['v1', 'v2']
   

7、hlen

1. 说明

   获取name对象的字典的长度

2. 方法

   hlen(name)
   

3. 参数

   • name

4. 返回值

   name对应的hash中键值对的个数

5. 举个栗子

   print(rds.hlen('k')) # 4
   

8、hkeys

1. 说明

   得到所有的keys

2. 方法

   hkeys(name)
   

3. 参数

   • name

4. 返回值

   list 所有的keys

5. 举个栗子

   print(rds.hkeys('k')) # ['k1', 'k2', 'k3', 'k4']
   

9、hvals

1. 说明

   得到对应name所有的值

2. 方法

   hvals(name)
   

3. 参数

   • name 键

4. 返回值

   获取name对应的hash中所有的value的值

5. 举个栗子

   user_dict={"name":"小红","age":18}
   rds.hmset("user",user_dict)
   
   #hlen(name) 获取hash中键值对的个数
   print(r.hlen("user"))
   
   #hkeys(name) 获取hash中所有的key的值
   print(r.hkeys("user"))
   
   #hvals(name) 获取hash中所有的value的值
   print(r.hvals("user"))
   

10、hexists

1. 说明

   判断成员是否存在（类似字典的in）

2. 方法

   hexists(name, key)
   

3. 参数

   • name
   • key

4. 返回值

   返回True或者False

5. 举个栗子

   print(rds.hexists('k', 'k2')) # True
   print(rds.hexists('k', 'k5')) # False
   

11、hdel

1. 说明

   删除键值对, name对应的hash中指定key的键值对删除

2. 方法

   hdel(name,*keys)
   

3. 参数

   • name
   • *keys

4. 返回值

   返回0或者1 1表示成功 0表示key不存在

5. 举个栗子

   print(rds.hdel('k', 'k2','k5')) # 1
   print(rds.hdel('k', 'k5')) #0
   

12、hincrby

1. 说明

2. 方法

   hincrby(name, key, amount=1)
   

3. 参数

   • name

     redis中的name

   • key

     hash对应的key

   • amount，

     自增数（整数）

4. 返回值

   返回value的值

5. 举个栗子

   print(rds.hset("k", "k1", 1)) # 0
   print(rds.hincrby("k", "k1", amount=1)) # 2
   print(rds.hincrby("k", "k1", amount=-2)) # 0
   

13、hincrbyfloat

1. 说明

   自增自减浮点数

2. 方法

   print(rds.hset("k", "k1", 1)) # 0
   print(rds.hincrby("k", "k1", amount=1)) # 2
   print(rds.hincrby("k", "k1", amount=-2)) # 0
   

3. 参数

   • name

     redis中的name

   • key

     hash对应的key

   • amount

     自增数（浮点数）

4. 举个栗子

   print(rds.hset("k", "k1", 1.0)) # 0
   print(rds.hincrby("k", "k1", amount=1.2)) # 2
   print(rds.hincrby("k", "k1", amount=-1.2)) # 0
   

附表

命令	操作
hget	hmget的单参数版本 一次操作一个值
hset	hmset的单参数版本 一次操作一个值
hmget	hmget key-name key [key…]从散列里面获取一个或者多个键的值
hmset	hmset key-name key value [key value…] 为散列里面一个或者多个键设置值
hdel	hdel key-name key [key…] 删除给定键的值
hlen	获取散列包含键值的数量
hexists	hexists key-name key 检查给定键是否存在散列里面
hkeys	获取所有的键
hvals	获取所有的值
hgetall	获取所有的键和值
hincrby	将某个键的值加上一个incrment
hincrbyfloat	将某个键的值加上一个incrment（float类型）redis 2.6以上 support

三、list 操作

1、lpush

1. 说明

   在name对应的list中添加元素，每个新的元素都添加到列表的最左边

2. 方法

   rds.lpush(kye,values)
   

3. 参数

   • key

     键

   • values

     要添加的值

4. 返回值

   值的长度

5. 举个栗子

   rds.lpush("li",2,3,4,5)
   

2、rpush

1. 说明

   同lpush，但每个新的元素都添加到列表的最右边

3、lpushx

1. 说明

   在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边

   用法同上

2. 方法

   lpushx(name,value)
   

4、rpushx

1. 说明

   在name对应的list中添加元素，只有name已经存在时，值添加到列表的最右边

   用法同上

5、llen

1. 说明

   name对应的list元素的个数
   

2. 示例代码

   print(r.llen("li"))
   

6、linsert

1. 说明

   在name对应的列表的某一个值前或后插入一个新值

2. 方法

    linsert(name, where, refvalue, value))
   

3. 参数

   • name: redis的name
   • where: BEFORE（前）或AFTER（后）
   • refvalue: 列表内的值
   • value: 要插入的数据

4. 举个栗子

   rds.linsert("li","BEFORE",2,"111111")
   

7、lset

1. 说明

   对list中的某一个索引位置重新赋值

2. 方法

   lset(name, index, value)  
   

3. 举个栗子

   r.lset("li",0,"hehe")
   

8、lrem

1. 说明

   删除name对应的list中的指定值

2. 方法

   lrem("list_name","SS",num=0)
   

3. 参数

   • name: redis的name

   • value: 要删除的值

   • num:

     num=0 删除列表中所有的指定值；

     num=2 从前到后，删除2个

     num=-2 从后向前，删除2个

4. 举个栗子

   rds.lrem("li","SS",num=0)
   

9、lpop

1. 说明

   移除列表的左侧第一个元素，返回值则是第一个元素

2. 方法

   lpop(name)
   

3. 举个栗子

   print(rds.lpop("li"))
   

10、lindex

1. 说明

   根据索引获取列表内元素

2. 方法

     lindex(name, index)
   

3. 举个栗子

   print(r.lindex("li",1))
   

11、lrange

1. 说明

   分片获取元素

2. 方法

     lrange(name, start, end)
   

3. 参数

   • start

     起始位置 从0开始

   • end

     结束位置 负数从后取

4. 举个栗子

   rds = redis.Redis(host='127.0.0.1', port=6379, db=0)
   print(rds.lpush("li", 2, 3, 4, 5))
   print(rds.lrange("li", 0, 2)) # 5,4 3
   print(rds.lrange("li", 0, -1)) # 5,4,3,2
   

12、ltrim

1. 说明

   移除列表内没有在该索引之内的值

2. 方法

   ltrim(name, start, end)
   

3. 举个栗子

   print(rds.ltrim("li", 0, 2))
   

14、brpoplpush

1. 说明

   从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
   假如在指定时间内没有任何元素被弹出，则返回一个 None 和等待时长。 反之，返回一个含有两个元素的列表，第一个元素是被弹出元素的值，第二个元素是等待时长

2. 方法

   brpoplpush(src,dst,timeout) 
   

3. 举个栗子

   r.rpush("li2",4,5,6,)    
   r.brpoplpush(src="li1",dst="li2",timeout=2)  #输出的结果是长度3
   r.brpoplpush(src="li3",dst="li2",timeout=2)  #输出的结果 None
   

15、blpop

1. 说明

   blpop(keys, timeout)

2. 方法

   blpop(keys, timeout)
   # timeout: 超时时间，获取完所有列表的元素之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
   

3. 举个栗子

   print(rds.blpop(["li1","li2"],timeout=0))
   

16、brpop

1. 说明

   同blpop，将多个列表排列,按照从右像左去移除各个列表内的元素
   

附表

命令	操作
rpush	将一个或者多个值推入列表的右端
lpush	将一个或者多个值推入列表的端
rpop	移除最右边的元素
lpop	移除最左边的元素
lindex	查询某个偏移量的值
lrange	查找某个偏移量范围内的数据
ltrim	截取某个范围内的值，其他的没在这个范围内的数据删掉
blpop	从第一个非空列表中弹出最左端的元素，或者在timeout秒内等待可以弹出的元素出现
brpop	从第一个非空列表中弹出最右端的元素，或者在timeout秒内等待可以弹出的元素出现
rpoplpush	rpoplpush source-key dest-key 把source-key里面最右端的元素弹出加到dest-key的最左端
brpoplpush	rpoplpush source-key dest-key 把source-key里面最右端的元素弹出加到dest-key的最左端，如果source-key为空，在timeout秒内等待可以弹出的元素出现

四、set 操作

1、sadd

1. 说明

   对key添加一个value或多个value

2. 方法

   sadd(name,values)
   

3. 返回值

   被添加到集合中的新元素的数量，不包括被忽略的元素。

4. 举个栗子

   rds.sadd("sets","泉水有妹子")
   rds.sadd("sets","hehe","哈哈")
   

2、smembers

1. 说明

   获取集合key的所有成员数量

2. 方法

   smembers(name)
   

3. 返回值

   集合中的所有成员 , 不存在时返回 （empty list or set）

4. 举个栗子

   rds.smembers("sets")
   

3、scard

1. 说明

   获取name对应的集合中的元素个数

2. 方法

   rds.scard(name)
   

3. 返回值

   不存在是返回0。存在时返回集合的数量

4. 举个栗子

   rds.scard("sets")
   

4、sdiff

1. 说明

   返回给定集合之间的差集。不存在的集合 key 将视为空集

2. 方法

   sdiff(keys, *args)
   

3. 举个栗子

   rds.sadd("s1",1,2,3,4,5,6)      #输出的结果是6
   rds.sadd("s2",4,5,6,7,8,9)      #输出的结果是6
   rds.sdiff('s1','s2')            #输出的结果是set(['1', '3', '2'])
   rds.sdiff('s2','s1')            #输出的结果是set(['9', '8', '7'])
   rds.sdiff('s1','s1')            #输出的结果是set([])
   

5、sdiffstore

1. 说明

   命令将给定集合之间的差集存储在指定的集合中。如果指定的集合 key 已存在，则会被覆盖

2. 方法

   sdiffstore(dest, keys, *args)
   

3. 举个栗子

   rds.sadd("s1",1,2,3,4,5,6)      #输出的结果是6
   rds.sadd("s2",4,5,6,7,8,9)      #输出的结果是6
   rds.sadd("s3",0)                #输出的结果是1
   rds.sdiffstore("s1","s2","s3")  #输出的结果是3
   

6、sinter

1. 说明

   获取多个name对应集合的并集

2. 方法

   sinter(keys, *args)
   

3. 举个栗子

   rds.sadd("s1","1","2")
   rds.sadd("s2","2","3")
   rds.sadd("s3","2","3","4")
   print(rds.sinter("s1","s2","s3")) 2
   

7、sinterstore

1. 说明

   获取多个name对应集合的并集，再讲其加入到dest对应的集合中

2. 方法

   sinterstore(dest, keys, *args)
   

3. 举个栗子

   rds.sadd("k1",3,4,5,6)      #输出的结果是4
   rds.sadd("k2",1,2,3,4)      #输出的结果是4
   rds.sadd("k3",0)            #输出的结果是1
   rds.sinterstore('k1','k2','k3')   #输出的结果是2
   

8、sismember

1. 说明

   命令判断成员元素是否是集合的成员。

2. 方法

   sismember(name, value)
   

3. 返回值

   如果成员元素是集合的成员，返回 1 。 如果成员元素不是集合的成员，或 key 不存在，返回 0
   

4. 举个栗子

   rds.sadd("s1",1,2,3,4,5,6)   #输出的结果是6
   rds.sismember("s1",1)        #输出的结果是True
   rds.sismember("s1",2)        #输出的结果是True
   rds.sismember("s1",7)        #输出的结果是False
   rds.sismember("s1",8)        #输出的结果是False
   

9、smove

1. 说明

   将某个元素从一个集合中移动到另外一个集合

2. 方法

   smove(src, dst, value)
   

3. 参数

4. 返回值

5. 举个栗子

   rds.sadd("s1",1,2,)     #输出的结果是2
   rds.sadd("s2",3,4,)     #输出的结果是2
   rds.smove('s1','s2',1)      #把91中的1移动到92中去，输出的结果是True
   rds.smembers("s1")      #输出的结果是set(['2'])
   rds.smembers("s2")      #输出的结果是set(['1', '3', '4'])
   rds.smove('s1','s2',5)      #91不存在5，输出的结果是False
   rds.smembers("s1")      #输出的结果是set(['2'])
   rds.smembers("s2")      #输出的结果是set(['1', '3', '4'])
   

10、spop

1. 说明

   用于移除并返回集合中的一个随机元素

2. 方法

   spop(name)    
   

3. 举个栗子

   rds.spop("10")            
   

11、srem

1. 说明

   删除name对应的集合中的某些值

2. 方法

   srem(name, values)
   

3. 举个栗子

   print(r.srem("s2","aaa","bbb"))
   

12、sunion

1. 说明

   获取多个name对应的集合的并集

2. 方法

   sunion(keys, *args)
   

3. 举个栗子

   rds.sunion("s1","s2","s3")
   

附表

五、有序集合操作

1、zadd

1. 说明

   向指定的sorteset中添加1个或多个元素

2. 举个栗子

   rds.zadd("zset_name", "a1", 6, "a2", 2,"a3",5)
   #或
   rds.zadd('zset_name1', b1=10, b2=5)
   

2、zrem

1. 说明

2. 方法

   #删除name对应的有序集合中值是values的成员
   r.zrem("zset_name","a1","a2")
   

3. 参数

4. 返回值

5. 举个栗子

3、zcount

1. 说明

   获取有序集合中分数在[min,max]之间的个数

2. 方法

   zcount(name, min, max)
   

3. 举个栗子

   rds.zadd("2","1",1,"3",3) #输出的结果是2
   rds.zadd("2","2",2)     #输出的结果是1
   rds.zadd("2","1",4)     #输出的结果是0
   rds.zcount("2",min=0,max=5)     #输出的结果是3
   rds.zcount("2",min=0,max=3)     #输出的结果是2
   rds.zcount("2",min=1,max=3)     #输出的结果是2
   

4、zcard

1. 说明

   用于计算集合中元素的数量
   

2. 方法

   zcard(name)
   

3. 返回值

    当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0 。
   

4. 举个栗子

   rds.zadd("10", "a", 1, "b", 2, "c", 3)  # 返回的结果是3
   rds.zadd("10", "f", 11, "d", 21,"e",32) #返回的结果是3
   rds.zrank("10","a")                     #返回的结果是0
   rds.zrank("10","b")                     #返回的结果是1
   rds.zrank("10","e")                     #返回的结果是5
   rds.zrank("10","d")                     #返回的结果是4
   rds.zrank("10","h")                     #返回的结果是None
   

5、zincrby

1. 说明

    命令对有序集合中指定成员的分数加上增量
   

2. 方法

   zincrby(name, value, amount)
   

3. 参数

   • amount
     可以通过传递一个负数值 amount ，让分数减去相应的值，
     当 key 不存在，或分数不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key amount
     当 key 不是有序集类型时，返回一个错误。
     分数值可以是整数值或双精度浮点数。

4. 返回值

   返回一个新分数值，以字符串形式表示

5. 举个栗子

   rds.zincrby("zs1","a1",amount=2) #自增zs1对应的有序集合里a1对应的分数
   

6、zrange

1. 说明

2. 方法

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

3. 参数

   • name redis的name

   • start 有序集合索引起始位置

   • end 有序集合索引结束位置

   • desc 排序规则，默认按照分数从小到大排序

   • withscores 是否获取元素的分数，默认只获取元素的值

4. 举个栗子

   aa=r.zrange("zs1",0,1,desc=False,withscores=True,score_cast_func=int)
   

7、zrevrange

1. 说明

   同zrange，集合是从大到小排序的

2. 方法

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

8、zrank

3. 说明

   返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大)顺序排列。

   如果成员是有序集 key 的成员，返回 member 的排名。 如果成员不是有序集 key 的成员，返回 None

4. 方法

   zrank(name, value)
   #
   zrevrank(name, value)
   

5. 举个栗子

   print(r.zrank("zs1", "a2"))
   print(r.zrevrank("zs1", "a2"))#从大到小排序
   

附表

命令	操作
zadd	将带有一定分值的成员添加到有序集合里面
zrem	移除成员，返回移除的数量
zcard	返回有序集合包含的成员数量
zincrby	将某个成员加上一定的分值
zcount	查询分值在min 和 max区域之间的数量
zrank	返回某个成员的排名
zscore	返回某个成员的分值
zrange	查询给定start和stop分值之间的成员