Redis-Python交互：数据类型操作

String操作

redis中的String在在内存中按照name：value来存储的。

• set(self, name, value, ex=None, px=None, nx=False, xx=False):
  get(self, name):获取key的值
  getset(self, name, value):将给定 key 的值设为 value ，并返回 key 的旧值(old value)

# 参数：
# ex，过期时间（秒）
# px，过期时间（毫秒）
# nx，如果设置为True，则只有name不存在时，当前set操作才执行
# xx，如果设置为True，则只有name存在时，岗前set操作才执行
r.set('name', 'redis', ex=60, nx=True)
print(r.get('name'))
# 结果：
# b'redis'
ret = r.getset('name', 'new value')
print(ret)
# b'redis'
print(r.get('name'))
# b'new value'

• setnx(self, name, value)设置值，只有name不存在时，执行设置操作（添加）：

r.setnx('num', 123)
print(r.get('num'))
# 结果：
# b'123'

• setex(self, name, time, value)设置name的value和过期时间（秒或timedelta对象）：
  psetex(name,time_ms,value) 过期时间为毫秒或timedelta对象

# time，过期时间（数字秒 或 timedelta对象）
r.setex('ex', 20, 'guoqi')
print(r.get('ex'))
r.psetex('pex', 20000, 'weimiao')
print(r.get('ex'))
# 结果：
# b'guoqi'
# b'guoqi'
# 20s后 ex、pex消失

• mset(self, mapping):批量设置值 ，redis-py3.0后参数改为mapping对象，不在使用(*args, **kwargs)了
  msetnx(self, mapping):如果所有的key都未设置就会进行设置

tom = {'name': 'Tom', 'age': 20, 'id': 1}
r.mset(tom)
print(f"name:{r.get('name')}\n'age':{r.get('age')}\n'id':{r.get('id')}")
# 结果
# name:b'Tom'
# 'age':b'20'
# 'id':b'1'

• getrange(self, key, start, end):获取字符串的子序列，包括起始、结束
  setrange(self, name, offset, value):用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始

r.set('num', '0123456')
ret = r.getrange('num', 1, 4)
print(ret)
# b'1234'
r.setrange('num', 4, 'adcde')
print(r.get('num'))
# b'0123adcde'

• setbit(self, name, offset, value)：对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)
  getbit(self, name, offset)：对 key 所储存的字符串值，获取指定偏移量上的位(bit)

r.set('bit', '012345')
# 012345 ascii = 30 31 32 33 34 35
# = 00110000 00110001 00110010 ...
# 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)
r.setbit('bit', 1, 1)  # 00110000 -> 01110000=70=p
print(r.get('bit'))
# b'p12345'
print(r.getbit('bit', 2))
# 1

• bitcount(key,start=None,end=None)：获取name对应的值的二进制表示中 1 的个数，区间[start, end]

r.set('bit', '1')  # 1 = 31 = 00110001
print(r.bitcount('bit', 0, -1))
# 3

• bitop(operation,dest,*keys):获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值:

# bit 操作 与 或 亦或 非
# dest, 新的Redis的name
# *keys,要查找的Redis的name
r.set('a', 0x11)  # 17 = 31 37 = 00110001 00110111
r.set('b', 0x22)  # 34 = 33 34 = 00110011 00110100
r.bitop('AND', 'yu', 'a', 'b') # 00110001 00110100 = 31 34 = 14
r.bitop('OR', 'huo', 'a', 'b') # 00110011 00110111 = 33 37 = 37
r.bitop('XOR', 'yihuo', 'a', 'b') # 00000010 00000011 = 02 03
r.bitop('NOT', 'fei', 'a') # 11001110 11001000 = ce c8
print(r.get('yu'))
# b'14'
print(r.get('huo'))
# b'37'
print(r.get('yihuo'))
# b'\x02\x03'
print(r.get('fei'))
# b'\xce\xc8'

• strlen(self, name): 返回 key 所储存的字符串值的长度

r.set('len', '012345678')
ret = r.strlen('len')
print(ret)
# 9

• incr(self, name, amount=1):将 key 中储存的数字值增一。
  incrby(self, name, amount=1):将 key 所储存的值加上给定的增量值，默认1
  incrbyfloat(self, name, amount=1.0):将 key 所储存的值加上给定的浮点增量值， 默认1.0

r.set('num', 1)
r.incr('num')
print(r.get('num'))
# b'2'
r.incrby('num', 3)
print(r.get('num'))
# b'5'
r.incrbyfloat('num', 2.1)
print(r.get('num'))
# b'7.1'

• decr(self, name, amount=1)：将 key 中储存的数字值减一
  decrby(self, name, amount=1):key 所储存的值减去给定的减量值
  key和amount都要为整数

# 减
r.set('num', 10)
r.decr('num')
print(r.get('num'))
# b'9'
r.decrby('num', 4)
print(r.get('num'))
# b'5'

• append(self, key, value): 如果 key 已经存在并且是一个字符串， APPEND 命令将指定的 value 追加到该 key 原来值（value）的末尾。

# 追加
r.set('code', 'abcdefg')
r.append('code', 'hijk')
print(r.get('code'))
b'abcdefghijk'

Hash操作

Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。Redis 中每个 hash 可以存储 2³² - 1 键值对（40多亿）。

• hset(self, name, key, value):将哈希表 name 中的字段 key 的值设为 value ;
  hsetnx(self, name, key, value):只有在字段key不存在时，设置哈希表字段的值;
  hmset(self, name, mapping):同时将多个key-value对设置到表name，格式为映射
• hget(self, name, key):获取存储在哈希表中指定字段的值
  hgetall(self, name):获取在哈希表中指定 name的所有字段和值
  hmget(self, name, keys, *args):获取所有给定字段的值

r.hset('t1', 'name', 'jack')
print(r.hget('t1', 'name'))
# b'jack'
r.hsetnx('t1', 'name', 'ulysses')
print(r.hget('t1', 'name'))
# b'jack'
d1 = {'name': 'Jack', 'id': 1, 'location': 'US'}
r.hmset('t1', d1)
print(r.hgetall('t1'))
{b'name': b'Jack', b'id': b'1', b'location': b'US'}
keys = ['name', 'location']
print(r.hmget('t1', keys, 'id'))
[b'Jack', b'US', b'1']

• hvals(self, name):获取哈希表中所有值
  hkeys(self, name):获取所有哈希表中的字段
  hlen(self, name):获取哈希表中字段的数量

d2 = {'date': str(datetime.now().date()), 'name': 'Akali', 'age': '16', 'id': 2}
r.hmset('t2', d2)
print(r.hlen('t2'))
# 4
print(r.hkeys('t2'))
# [b'date', b'name', b'age', b'id']
print(r.hvals('t2'))
# [b'2018-11-25', b'Akali', b'16', b'2']

• hexists(self, name, key)：查看哈希表 key 中，指定的字段是否存在
  hdel(self, name, *keys):删除一个或多个哈希表字段

print(r.hgetall('t1'))
# {b'name': b'Jack', b'id': b'1', b'location': b'US'}
if r.hexists('t1', 'name'):
    r.hdel('t1', 'name')
print(r.hgetall('t1'))
# {b'id': b'1', b'location': b'US'}

• hincrby(self, name, key, amount=1):为哈希表 key 中的指定字段的整数值加上增量
  hincrbyfloat(self, name, key, amount=1.0):为哈希表 key 中的指定字段的浮点数值加上增量

print(r.hget('t2', 'id'))
# b'2'
if r.hexists('t2', 'id'):
    r.hincrby('t2', 'id', 25)
    print(r.hget('t2', 'id'))
    # b'27'
    r.hincrbyfloat('t2', 'id', 3.14)
    print(r.hget('t2', 'id'))
    # b'30.14'

列表操作

Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

• lpop(self, name):移出并获取列表的第一个元素
  lpush(self, name, *values):将一个或多个值插入到列表头部
  lpushx(self, name, value):将一个值插入到已存在的列表头部
  lrange(self, name, start, end)：获取列表指定范围内的元素
  rpop, rpush和rpushx操作列表最后一个元素

l1 = [0, 1, 2, 3, 4, 5, 6, 7]
r.lpush('l1', *l1)
print(r.lrange('l1', 0, -1))
# [b'7', b'6', b'5', b'4', b'3', b'2', b'1', b'0']
r.lpush('l1', 'a')
r.lpushx('l1', 'b')
ret = r.lpop('l1')
print(ret)
# b'b'
print(r.lrange('l1', 2, 5))
# [b'6', b'5', b'4', b'3']
print(r.lrange('l1', 10, 15))
# []
print(r.lrange('l1', 4, 1))
# []

• lindex(self, name, index):通过索引获取列表中的元素
• linsert(self, name, where, refvalue, value):在列表的元素前或者后插入元素
• llen(self, name):获取列表长度

if r.exists('l2'):
    r.delete('l2')
l2 = ['a', 'b', 'c', 'd', 'e']
r.rpush('l2', *l2)
print(r.lrange('l2', 0, -1))
# [b'a', b'b', b'c', b'd', b'e']
r.linsert('l2', 'before', 'b', '0')
r.linsert('l2', 'after', 'd', '1')
print(r.lrange('l2', 0, -1))
# [b'a', b'0', b'b', b'c', b'd', b'1', b'e']
print(r.llen('l2'))
# 7
print(r.lindex('l2', 1))
# b'0'
print(r.lindex('l2', 4))
# b'd'

• lset(self, name, index, value):通过索引设置列表元素的值
  lrem(self, name, count, value):移除列表元素
  ltrim(self, name, start, end):对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除

if r.exists('l3'):
    r.delete('l3')
l3 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
r.rpush('l3', *l3)
r.lset('l3', 1, 1)
r.lset('l3', 3, 1)
print(r.lrange('l3', 0, -1))
# [b'a', b'1', b'c', b'1', b'e', b'f', b'g', b'h']
# count > 0: Remove elements equal to value moving from head to tail.
# count < 0: Remove elements equal to value moving from tail to head.
# count = 0: Remove all elements equal to value.
r.lrem('l3', 2, 1)
print(r.lrange('l3', 0, -1))
# [b'a', b'c', b'e', b'f', b'g', b'h']
r.ltrim('l3', 1, 4)
print(r.lrange('l3', 0, -1))
# [b'c', b'e', b'f', b'g']

• rpoplpush(self, src, dst):移除列表的最后一个元素，并将该元素添加到另一个列表的头部并返回：

if r.exists('l4'):
    r.delete('l4')
if r.exists('l5'):
    r.delete('l5')
l4 = ['US', 'CN', 'JP', 'FR', 'UK']
l5 = ['baidu', 'google', 'facebook', 'twitter']
r.rpush('l4', *l4)
r.rpush('l5', *l5)
r.rpoplpush('l4', 'l5')
print(r.lrange('l4', 0, -1))
# [b'US', b'CN', b'JP', b'FR']
print(r.lrange('l5', 0, -1))
# [b'UK', b'baidu', b'google', b'facebook', b'twitter']

• blpop(self, keys, timeout=0):移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
  brpop(self, keys, timeout=0):移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
  brpoplpush(self, src, dst, timeout=0):从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止

先运行①

ret1 = r.blpop('l6', timeout=10)
ret2 = r.brpop('l7', timeout=10)
print(ret1)
print(ret2)

再运行②

if r.exists('l6'):
    r.delete('l6')
if r.exists('l7'):
    r.delete('l7')
l6 = [1, 2, 3, 4, 5, 6]
l7 = ['a', 'b', 'c', 'd']
# ret1 = r.blpop('l6', timeout=10)
# ret2 = r.brpop('l7', timeout=10)
r.rpush('l6', *l6)
r.rpush('l7', *l7)
print(r.lrange('l6', 0, -1))
print(r.lrange('l7', 0, -1))

①的结果：

(b'l6', b'1')
(b'l7', b'd')

②的结果：

[b'2', b'3', b'4', b'5', b'6']
[b'a', b'b', b'c']

集合

Redis 的 Set 是 String 类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。

• sadd(self, name, *values):向集合添加一个或多个成员
  scard(self, name):获取集合的成员数
  sismember(self, name, value):判断 value 元素是否是集合 name 的成员
  smembers(self, name):返回集合中的所有成员
  srem(self, name, *values):移除集合中一个或多个成员

if r.exists('s1'):
    r.delete('s1')
r.sadd('s1', *s1)
print(r.scard('s1'))
# 10
if r.sismember('s1', 'US'):
    r.srem('s1', 'US')
print(r.smembers('s1'))
# {b'3', b'Tom', b'2', b'b', b'a', b'Jack', b'1', b'CN', b'z'}

• spop(self, name, count=None):移除并返回集合中的一个随机元素
  srandmember(self, name, number=None):返回集合中一个或多个随机数，不会移除元素

s2 = ['baidu', 'google', 'sina', 'sohu', 'twitter']
if r.exists('s2'):
    r.delete('s2')
r.sadd('s2', *s2)
ret = r.spop('s2')
print(ret)
# b'sohu'
print(r.smembers('s2'))
# {b'google', b'sina', b'twitter', b'baidu'}
ret = r.srandmember('s2', 3)
print(ret)
# [b'twitter', b'baidu', b'google']
print(r.smembers('s2'))
# {b'google', b'sina', b'twitter', b'baidu'}

• smove(self, src, dst, value)：将value 元素从src移动到dst
  sdiff(self, keys, *args):返回给定所有集合的差集
  sdiffstore(self, dest, keys, *args):返回给定所有集合的差集并存储在 dest 中
  sinter(self, keys, *args):：返会给定集合的交集
  sinterstore(self, dest, keys, *args):返回给定所有集合的交集并存储在dest
  sunion(self, keys, *args):返回所有给定集合的并集
  sunionstore(self, dest, keys, *args):所有给定集合的并集存储在 dest集合中

s3 = ['baidu', 'google', 'sina', 'sohu', 'twitter', 1, 2, 3, 'a', 'b']
s4 = ['a', 'b', 'c', 1, 2, 'google']
if r.exists('s3'):
    r.delete('s3')
if r.exists('s4'):
    r.delete('s4')
r.sadd('s3', *s3)
r.sadd('s4', *s4)

diff = r.sdiff('s3', 's4')
r.sdiffstore('s_diff', 's3', 's4')
print(diff)
print(r.smembers('s_diff'))
# {b'3', b'sina', b'sohu', b'baidu', b'twitter'}

inter = r.sinter('s3', 's4')
r.sinterstore('s_inter', 's3', 's4')
print(inter)
print(r.smembers('s_inter'))
# {b'google', b'b', b'2', b'a', b'1'}

union = r.sunion('s3', 's4')
r.sunionstore('s_union', 's3', 's4')
print(union)
print(r.smembers('s_union'))
# {b'3', b'google', b'sina', b'sohu', b'baidu', b'c', b'b', b'twitter', b'2', b'a', b'1'}

r.smove('s3', 's4', 'sina')
print(r.smembers('s3'))
# {b'3', b'google', b'sohu', b'baidu', b'b', b'twitter', b'2', b'a', b'1'}
print(r.smembers('s4'))
# {b'google', b'sina', b'c', b'b', b'2', b'a', b'1'}

有序集合sorted set

Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。有序集合的成员是唯一的,但分数(score)却可以重复。

• zadd(self, name, mapping, nx=False, xx=False, ch=False, incr=False):向有序集合添加一个或多个成员，或者更新已存在成员的分数
  1. nx: 仅创建新元素而不更新已存在元素的分数。
  2. xx: 只更新已存在元素的分数，不添加新元素
  3. ch：将返回值修改为更改的元素数。更改的元素包括添加的新元素和分数更改的元素。
  4. incr： 将ZADD变为类似ZINCRBY
• zcard(self, name):获取有序集合的成员数
• zcount(self, name, min, max):计算在有序集合中指定区间分数的成员数
• zscore(self, name, value):返回有序集中，成员的分数值
• zrange(self, name, start, end, desc=False, withscores=False,
  score_cast_func=float):通过索引区间返回有序集合成指定区间内的成员：
  1. desc：反序
  2. withscores：返回(value, score)对
  3. score_cast_func：对返回的score进行处理的函数
• zrevrange(self, name, start, end, withscores=False,
  score_cast_func=float):返回有序集中指定区间内的成员，通过索引，分数从高到底

if r.exists('zs1'):
    r.delete('zs1')
zs = {'us': 1, 'cn': 2, 'jp': 2.5, 'kr': 4, 'eu': 3.5}
r.zadd('zs1', zs)
print(r.zcard('zs1'))
# 5
print(r.zcount('zs1', 2, 4))
# 4
print(r.zscore('zs1', 'jp'))
# 2.5
print(r.zrange('zs1', 0, -1, withscores=True))
# [(b'us', 1.0), (b'cn', 2.0), (b'jp', 2.5), (b'eu', 3.5), (b'kr', 4.0)]
print(r.zrevrange('zs1', 0, -1))
# [b'kr', b'eu', b'jp', b'cn', b'us']

• zincrby(self, name, amount, value):有序集合中对指定成员value的分数加上增量 amout
• zlexcount(self, name, min, max):在有序集合中计算指定字典区间内成员数量
• zrangebylex(self, name, min, max, start=None, num=None):通过字典区间返回有序集合的成员，如果指定start和num就会返回一个切片
• zrevrangebylex(self, name, max, min, start=None, num=None):返回有序集中指定区间内的成员，通过索引，分数从高到底
• zrangebyscore(self, name, min, max, start=None, num=None,withscores=False, score_cast_func=float):通过分数返回有序集合指定区间内的成员
• zrevrangebyscore(self, name, max, min, start=None, num=None,withscores=False, score_cast_func=float):返回有序集中指定分数区间内的成员，分数从高到低排序

if r.exists('zs2'):
    r.delete('zs2')
zs2 = {'a': 1, 'b': 2, 'c': 2.5, 'd': 2.2, 'e': 3.5, 'f': 0.5}
r.zadd('zs2', zs2)
r.zincrby('zs2', 2, 'c')
print(r.zscore('zs2', 'c'))
# 4.5
print(r.zlexcount(name="zs2", min="-", max="+"))
# 6
print(r.zrangebylex(name='zs2', min="-", max="+"))
# [b'f', b'a', b'b', b'd', b'e', b'c']
print(r.zrevrangebylex('zs2', "[f", "[a"))
# [b'c', b'e', b'd', b'b', b'a', b'f']
print(r.zrangebyscore('zs2', 0, 4))
# [b'f', b'a', b'b', b'd', b'e']
print(r.zrevrangebyscore('zs2', 5, 1, withscores=True))
# [(b'c', 4.5), (b'e', 3.5), (b'd', 2.2), (b'b', 2.0), (b'a', 1.0)]

• zrank(self, name, value):返回有序集合中指定成员的索引
• zrevrank(self, name, value):返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
• zrem(self, name, *values):移除有序集合中的一个或多个成员
• zremrangebylex(self, name, min, max):移除有序集合中给定的字典区间的所有成员
• zremrangebyrank(self, name, min, max):移除有序集合中给定的排名区间的所有成员
• zremrangebyscore(self, name, min, max):移除有序集合中给定的分数区间的所有成员

if r.exists('zs2'):
    r.delete('zs2')
zs3 = {'a': 1, 'b': 2, 'c': 2.5, 'd': 3.2, 'e': 3.5, 'f': 3.55, 'g': 4, 'h': 4.1,
       'i': 4.3, 'j': 4.5, 'k': 5, 'l': 5.3, 'm': 5.6, 'n': 5.8, 'o': 6}
r.zadd('zs3', zs3)
print(r.zrank('zs3', 'f'))
# 5
print(r.zrevrank('zs3', 'f'))
# 9
r.zrem('zs3', 'a')
print(r.zrange('zs3', 0, -1, withscores=True))
# [(b'b', 2.0), (b'c', 2.5), (b'd', 3.2), (b'e', 3.5), (b'f', 3.55), (b'g', 4.0), (b'h', 4.1), (b'i', 4.3), (b'j', 4.5), (b'k', 5.0), (b'l', 5.3), (b'm', 5.6), (b'n', 5.8), (b'o', 6.0)]
r.zremrangebylex('zs3', '[b', '[d')
print(r.zrange('zs3', 0, -1, withscores=True))
# [(b'e', 3.5), (b'f', 3.55), (b'g', 4.0), (b'h', 4.1), (b'i', 4.3), (b'j', 4.5), (b'k', 5.0), (b'l', 5.3), (b'm', 5.6), (b'n', 5.8), (b'o', 6.0)]
r.zremrangebyrank('zs3', '2', '4')
print(r.zrange('zs3', 0, -1, withscores=True))
# [(b'e', 3.5), (b'f', 3.55), (b'j', 4.5), (b'k', 5.0), (b'l', 5.3), (b'm', 5.6), (b'n', 5.8), (b'o', 6.0)]
r.zremrangebyscore('zs3', 3, 5)
print(r.zrange('zs3', 0, -1, withscores=True))
# [(b'l', 5.3), (b'm', 5.6), (b'n', 5.8), (b'o', 6.0)]

• zinterstore(self, dest, keys, aggregate=None):计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合，默认分数为相加后的值
• zunionstore(self, dest, keys, aggregate=None):计算给定的一个或多个有序集的并集，并存储在新的有序集合中，默认分数为相加后的值

if r.exists('zs4'):
    r.delete('zs4')
if r.exists('zs5'):
    r.delete('zs5')
zs4 = {'baidu': 1, 'google': 2, 'sina': 4, 'twitter': 3, 'facebook': 3.54}
zs5 = {'taobao': 1, 'youtube': 2, 'twitch': 4, 'google': 5, 'sina': 5.5}
r.zadd('zs4', zs4)
r.zadd('zs5', zs5)
r.zinterstore('zs_inter', ('zs4', 'zs5'))
r.zunionstore('zs_union', ('zs4', 'zs5'))
print(r.zrange('zs_inter', 0, -1, withscores=True))
# [(b'google', 7.0), (b'sina', 9.5)]
print(r.zrange('zs_union', 0, -1, withscores=True))
# [(b'baidu', 1.0), (b'taobao', 1.0), (b'youtube', 2.0), (b'twitter', 3.0), (b'facebook', 3.54), (b'twitch', 4.0), (b'google', 7.0), (b'sina', 9.5)]

redis-5.0版本新内容

• zpopmax(self, name, count=None):移除集合中分数最大的值，数量为count（默认1个）
• zpopmin(self, name, count=None):移除集合中分数最小的值，数量为count（默认1个）
• bzpopmax(self, keys, timeout=0):与zpopmax类似，阻塞操作
• bzpopmin(self, keys, timeout=0):与zpopmin类似，阻塞操作

if r.exists('zs6'):
    r.delete('zs6')
zs6 = {'a': 1, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5}
r.zadd('zs6', zs6)
print(r.zpopmax('zs6', 2))
# [(b'f', 5.0), (b'e', 4.0)]
print(r.zpopmin('zs6', 2))
# [(b'a', 1.0), (b'b', 1.0)]
print(r.zrange('zs6', 0, -1))
# [b'c', b'd']

*SCAN操作

Redis 2.8中引入的* SCAN命令使用起来很麻烦。 虽然完全支持这些命令，但redis-py还公开了以下返回Python迭代器的方法：scan_iter，hscan_iter，sscan_iter和zscan_iter。

• scan：

for key, value in (('A', '1'), ('B', '2'), ('C', '3')):
    r.set(key, value)
for key in r.scan_iter():
    print(key, r.get(key))

# b'C' b'3'
# b'B' b'2'
# b'A' b'1

• sscan：

s1 = [1, 2, 3, 4, 'white', 'black']
s2 = ['a', 'b', 'c', 'Jack']
r.sadd('s1', *s1)
r.sadd('s2', *s2)
for member in r.sscan_iter('s1'):
    print(member)
print('---------')
for member in r.sscan_iter('s2'):
    print(member)
# b'2'
# b'3'
# b'black'
# b'4'
# b'white'
# b'1'
# ---------
# b'Jack'
# b'b'
# b'a'
# b'c'

• hsacn：

d1 = {'name': 'Jack', 'id': 1, 'location': 'US'}
r.hmset('h1', d1)
for field in r.hscan_iter('h1'):
    print(field)
# (b'name', b'Jack')
# (b'id', b'1')
# (b'location', b'US')

• zscan：

zs = {'a1': 1, 'a2': 2, 'a3': 2.5, 'b1': 4, 'b2': 3.5}
r.zadd('zs1', zs)
for field in r.zscan_iter('zs1', match='a*'):
    print(field)
(b'a1', 1.0)
(b'a2', 2.0)
(b'a3', 2.5)