Redis 总结 —— 2022/2/6

存储操作：Set/Sorted Set

Set 类型（无序集合）

# 将二进制集合转换对应的集合
def Iterate_Set(value):
    if isinstance(value, set):
        set_latest = set()
        for i in value:
            set_latest.add(i.decode())
        return set_latest

def Set_operation():
    # 创建连接池及连接对象
    redis_pool = redis.ConnectionPool(host='localhost', port=6379, db=5)
    redis_coon = redis.Redis(connection_pool=redis_pool)
    redis_coon.flushall()

    """
    特点：集合中的元素不具有重复性(自动去重功能)
    命令1：sadd(name,values)
          name:集合名
          values:元素
    命令2：scard(name)
          name:集合名
          返回值：集合中的元素个数
    命令3：smembers(name)
          查看集合中的元素
          返回值：是一个集合
    命令4：sdiff(keys, *args)
          差集！第一个集合 - 第二个集合
          返回值：是一个集合
    命令5：sdiffstore(dest, keys, *args)
          dest:将差集加入到dest集合中(如果集合存在则会覆盖/不存在则会创建)
          keys:第一个集合和第二个集合
    命令6：sinter(keys, *args)
          交集！ 
    命令7：sinterstore(dest, keys, *args)
          dest:将交集加入到dest集合中(如果集合存在则会覆盖/不存在则会创建)
          keys:第一个集合和第二个集合
    命令8：sunion(keys, *args)
          并集！
    命令9：sunionstore(dest,keys, *args)
          dest:将交集加入到dest集合中(如果集合存在则会覆盖/不存在则会创建)
          keys:第一个集合和第二个集合
    """
    redis_coon.sadd('my_set_1', 1, 1, 2, 3, 4)
    redis_coon.sadd('my_set_2', 2, 3)

    print(redis_coon.scard('my_set_1'))  # 4
    print(Iterate_Set(redis_coon.smembers('my_set_1')))  # {'4', '1', '2', '3'}

    print(Iterate_Set(redis_coon.sdiff('my_set_1', 'my_set_2')))  # {'4', '1'}
    redis_coon.sdiffstore('my_set_3', 'my_set_1', 'my_set_2')
    print(Iterate_Set(redis_coon.smembers('my_set_3')))  # {'1', '4'}

    # my_set_1:{'1', '2', '3', '4'} —— my_set_2:{'2', '3'} —— my_set_3:{'1', '4'}
    print(Iterate_Set(redis_coon.sinter('my_set_1', 'my_set_2')))  # {'2', '3'}
    redis_coon.sinterstore('my_set_4', 'my_set_1', 'my_set_2')
    print(Iterate_Set(redis_coon.smembers('my_set_4')))  # {'2', '3'}

    # my_set_4:{'2', '3'}
    print(Iterate_Set(redis_coon.sunion('my_set_3', 'my_set_4')))  # {'2', '3', '1', '4'}
    redis_coon.sunionstore('my_set_5', 'my_set_3', 'my_set_4')
    print(Iterate_Set(redis_coon.smembers('my_set_5')))  # {'2', '3', '1', '4'}

    """
    命令10：sismember(name, value)
           检查value是不是集合name中的元素
           返回值：布尔值
    命令11：smove(src, dst, value)
           将某个成员从src集合移动到dst集合
    命令12：spop(name)
           从集合中随机移出一个元素并返回
    命令13：srandmember(name, numbers)
           从集合name中随机获取numbers个元素
           返回值：是一个列表
    命令14：srem(name, values)
           从集合name中删除元素values
    """

    """
    my_set_1:{'1', '2', '3', '4'}
    my_set_2:{'2', '3'}
    my_set_3:{'1', '4'}
    my_set_4:{'2', '3'}
    my_set_5:{'2', '3', '1', '4'}
    """
    print(redis_coon.sismember('my_set_5', 3))  # True
    redis_coon.smove('my_set_3', 'my_set_4', 4)
    print(Iterate_Set(redis_coon.smembers('my_set_4')))  # {'4', '2', '3'}
    print(Iterate_Set(redis_coon.smembers('my_set_3')))  # {'1'}

    print(redis_coon.spop('my_set_1').decode())  # 2
    print(Iterate_Set(redis_coon.smembers('my_set_1')))  # {'3', '4', '1'}
    print(Iterate_ListOrDict(redis_coon.srandmember('my_set_5', number=2)))  # ['3', '2']

    redis_coon.srem('my_set_5', 1)
    print(Iterate_Set(redis_coon.smembers('my_set_5')))  # {'2', '3', '4'}


Set_operation()

Sorted Set 类型（有序集合）

# 将二进制字典or列表转换成对应的字典or列表
def Iterate_ListOrDict(value):
    if isinstance(value, list):
        list_latest = []
        for i in value:
            list_latest.append(i.decode())
        return list_latest
    elif isinstance(value, dict):
        dict_latest = {}
        for i in value:
            dict_latest.setdefault(i.decode(), value[i].decode())
        return dict_latest

# 将列表(里面元素项为元组)转换成一个字典
def Iterate_TupleInList_To_Dict(value):
    dict_latest = {}
    for i in value:
        dict_latest.setdefault(i[0].decode(), i[1])
    return dict_latest

def Sorted_Set_operation():
    # 创建连接池及连接对象
    redis_pool = redis.ConnectionPool(host='localhost', port=6379, db=5)
    redis_coon = redis.Redis(connection_pool=redis_pool)
    redis_coon.flushall()

    """
    有序集合：每一个元素有两个值(值和分数) —— 分数专门用来做排序
    命令1：zadd(name, *args, **kwargs)
          向集合中添加元素
          传递参数的方法：mapping(字典) —— {'susu': 66, 'nana': 99, 'qiqi': 55}
    命令2：zcard(name)
          获取集合中的元素数量
    命令3：zcount(name, min, max)
          获取有序集合中分数在min和max之间的元素个数
    命令4：zincrby(name, amount, value)
          增加有序集合name的字段value对应的分数
          amount:增加的值
    命令5：zrange(name, start, end, desc=False, withscores=False, score_cast_func=float)
          根据索引获取有序集合中的元素
          start:起始索引
          end:结束索引
          desc:排序规则(默认升序)
          withscores:是否显示分数(默认不显示)
              - 不显示分数时返回一个元素列表
              - 显示分数时返回一个列表(列表内的基本元素以元组的形式存在)
          score_cast_func:对分数进行数据转换的函数(默认是浮点型)
          扩展：
            分数从大到小排序：zrevrange(name, start, end, withscores=False, score_cast_func=float)
            按照分数范围获取元素(从小到大)：zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
            按照分数范围获取元素(从大到小)：zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
    """
    redis_coon.zadd('my_set_1', {'susu': 66, 'nana': 99, 'qiqi': 55})
    print(redis_coon.zcard('my_set_1'))  # 3
    print(redis_coon.zcount('my_set_1', 10, 60))  # 1
    redis_coon.zincrby('my_set_1', amount=100, value='nana')

    print(Iterate_ListOrDict(redis_coon.zrange('my_set_1', 0, -1, desc=False, withscores=False)))
    # ['qiqi', 'susu', 'nana']
    print(Iterate_TupleInList_To_Dict(redis_coon.zrange('my_set_1', 0, -1, desc=False, withscores=True, score_cast_func=float)))
    # {'qiqi': 55.0, 'susu': 66.0, 'nana': 199.0}
    print(Iterate_TupleInList_To_Dict(redis_coon.zrevrange('my_set_1', 0, -1, withscores=True, score_cast_func=float)))
    # {'nana': 199.0, 'susu': 66.0, 'qiqi': 55.0}
    print(Iterate_ListOrDict(redis_coon.zrangebyscore('my_set_1', 10, 70)))  # ['qiqi', 'susu']
    print(Iterate_ListOrDict(redis_coon.zrevrangebyscore('my_set_1', 70, 10)))  # ['susu', 'qiqi']

    """
    命令6：zrank(name, value) —— zrevrank(name, value)
          获取某个值在有序集合中的排名(从0开始)
          - 从小到大
    命令7：zrem(name, values)
          删除有序集合中的元素们
    命令8：zremrangebyrank(name, min, max)
          根据排名范围进行删除
    命令9：zremrangebyscore(name, min, max)
          根据分数范围进行删除
    命令10：zscore(name, value)
           获取有序集合value元素对应的分数
    """
    print(redis_coon.zrank('my_set_1', 'nana'))  # 2
    print(redis_coon.zrevrank('my_set_1', 'nana'))  # 0

    redis_coon.zrem('my_set_1', 'nana', 'susu')  # 删除了nana和susu
    # redis_coon.zremrangebyrank('my_set_1', 1, 2)  # 删除了nana和susu
    # redis_coon.zremrangebyscore('my_set_1', 60, 200)  # 删除了nana和susu

    print(Iterate_TupleInList_To_Dict(redis_coon.zrange('my_set_1', 0, -1, desc=False, withscores=True, score_cast_func=float)))
    # {'qiqi': 55.0}
    print(redis_coon.zscore('my_set_1', 'qiqi'))  # 55.0

    """
    命令11：zinterstore(dest, keys, aggregate=None)
           获取二个有序集合的交集(若有相同值不同分数则按照aggregate进行操作)
           dest:新的集合
           keys:原有集合(以列表的形式传入)
           aggregate:MAX/MIN/SUM 
    命令12：zunionstore(dest, keys, aggregate=None)
           获取二个有序集合的并集(若有相同值不同分数则按照aggregate进行操作)
           dest:新的集合
           keys:原有集合(以列表的形式传入)
           aggregate:MAX/MIN/SUM
    """
    redis_coon.zadd('my_set_2', {'pipi': 33, 'jiji': 88, 'qiqi': 44})

    print(Iterate_TupleInList_To_Dict(redis_coon.zrange('my_set_1', 0, -1, desc=False, withscores=True, score_cast_func=float)))
    print(Iterate_TupleInList_To_Dict(redis_coon.zrange('my_set_2', 0, -1, desc=False, withscores=True, score_cast_func=float)))
    # {'qiqi': 55.0}
    # {'pipi': 33.0, 'qiqi': 44.0, 'jiji': 88.0}

    redis_coon.zinterstore('my_set_3', ['my_set_1', 'my_set_2'], aggregate='sum')
    print(redis_coon.zscore('my_set_3', 'qiqi'))
    # 99.0

    redis_coon.zunionstore('my_set_4', ['my_set_1', 'my_set_2'], aggregate='max')
    print(Iterate_TupleInList_To_Dict(redis_coon.zrange('my_set_4', 0, -1, desc=False, withscores=True, score_cast_func=float)))
    # {'pipi': 33.0, 'qiqi': 55.0, 'jiji': 88.0}


Sorted_Set_operation()