Redis 总结 —— 202224

Redis 总结 —— 2022/2/4

Python *** 作 Redis

连接方式：单次连接/连接池存储 *** 作：String/Hash/List/Set/Sorted Set

连接方式：单次连接/连接池

import redis

def Once_connect():
    """
    此种连接为单次连接，耗资源
    :return:设置的name值
    """
    # 创建 Redis连接对象
    redis_coon = redis.Redis(host='localhost', port=6379, db=5)

    # 字符串类型设置单个值
    redis_coon.set('name', 'susu')

    return redis_coon.get('name').decode('utf-8')

def Twice_connect():
    """
    当程序创建数据源实例时，系统会一次性创建多个数据库连接，并把这些数据库连接保存在连接池中，
    当程序需要进行数据库访问时，无需重新新建数据库连接，而是从连接池中取出一个空闲的数据库连接
    :return:设置的age值
    """
    # 创建连接池
    redis_pool = redis.ConnectionPool(host='localhost', port=6379, db=5)

    # 从连接池中挑出空闲的连接对象
    redis_coon = redis.Redis(connection_pool=redis_pool)

    # 字符串类型设置单个值
    redis_coon.set('age', '20')

    return redis_coon.get('age').decode('utf-8')


print(Once_connect())  # susu
print(Twice_connect())  # 20

存储 *** 作：String/Hash/List/Set/Sorted Set

String 类型（字符串）

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

    """
    命令1：get(name)
          用于获取值
    命令2：set(name, value, ex=None, px=None, nx=False, xx=False)
          ex:设置过期时间(单位：s) —— 对应setex
          px:设置过期时间(单位：ms) —— 对应psetex
          nx:如果设置为True,则只有当name不存在时才能执行 —— 对应setnx
          xx:如果设置为True,则只有当name存在时才能执行
    """
    redis_coon.set('name', 'susu', ex=60, nx=False, xx=False)
    redis_coon.set('age', '20', px=1000 * 60, nx=True, xx=False)
    redis_coon.set('sex', 'man', px=1000 * 60, nx=False, xx=False)
    susu_dict = {}
    susu_dict.setdefault('name', redis_coon.get('name').decode('utf-8'))
    susu_dict.setdefault('age', redis_coon.get('age').decode('utf-8'))
    susu_dict.setdefault('sex', redis_coon.get('sex').decode('utf-8'))
    print(susu_dict)  # {'name': 'susu', 'age': '20', 'sex': 'man'}

    """
    命令3：setex(name, time, value)
          time 过期时间单位为秒
    命令4：psetex(name, time_ms, value)
          time_ms 过期时间单位为毫秒
    """
    fruit_dict = {}
    redis_coon.setex('red', 60, 'apple')
    redis_coon.psetex('yellow', 60 * 1000, 'banana')
    redis_coon.psetex('green', 60 * 1000, 'cucumber')
    fruit_dict.setdefault('red', redis_coon.get('red').decode('utf-8'))
    fruit_dict.setdefault('yellow', redis_coon.get('yellow').decode('utf-8'))
    fruit_dict.setdefault('green', redis_coon.get('green').decode('utf-8'))
    print(fruit_dict)  # {'red': 'apple', 'yellow': 'banana', 'green': 'cucumber'}

    """
    命令5：setnx(name, value)
          只有当name不存在时才执行
    命令6：mset(*args, **kwargs)
          以关键字形式传递参数
          or 传入字典 —— {'name': 'nana', 'age': 20, 'sex': 'woman'}
    命令7：mget(*args, **kwargs)
          以传入字符串形式获取值(返回值是一个列表) —— 获取的是二进制格式(需要利用.decode()进行转换)
    """
    redis_coon.setnx('sweet', 'milk')
    nana_dict = {'name': 'nana', 'age': 20, 'sex': 'woman'}
    redis_coon.mset(nana_dict)
    name, age, sex, sweet = redis_coon.mget('name', 'age', 'sex', 'sweet')
    new_nana_dict = {'name': name.decode(), 'age': age.decode(), 'sex': sex.decode(), 'like': sweet.decode()}
    print(new_nana_dict)  # {'name': 'nana', 'age': '20', 'sex': 'woman', 'like': 'milk'}

    """
    命令8：getset(name, value)
    命令9：getrange(key, start, end)
    命令10：setrange(name, offset, value)
    """


String_operation()

Hash 类型（哈希）

# 将二进制字典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 Hash_operation():
    # 创建连接池及连接对象
    redis_pool = redis.ConnectionPool(host='localhost', port=6379, db=5)
    redis_coon = redis.Redis(connection_pool=redis_pool)
    redis_coon.flushall()

    """
    如下命令中的name代表一个哈希表
    命令1：hset(name, key, value)
          key:哈希表中对应的键
          value:哈希表中对应的值
    命令2：hmset(name, mapping)
          重点：新版本的hmset不被维护！(此处也是)
          mapping:字典
    命令3：hget(name,key)
          key:哈希表中对应的键值
    命令4：hmget(name, keys, *args)
          keys:以字符串的形式传入多个键值
          return:返回值为一个二进制列表
    命令5：hgetall(name) 
          返回值为一个二进制字典
    """
    redis_coon.hset('myhash', 'name', 'susu')
    redis_coon.hset('myhash', 'age', 20)
    redis_coon.hset('myhash', 'sex', 'man')
    print(redis_coon.hget('myhash', 'age').decode())  # 20
    name, sex = redis_coon.hmget('myhash', 'name', 'sex')
    susu_dict = {'name': name.decode(), 'age': 20, 'sex': sex.decode()}
    print(susu_dict)  # {'name': 'susu', 'age': 20, 'sex': 'man'}
    print(Iterate_ListOrDict(redis_coon.hgetall('myhash')))  # {'name': 'susu', 'age': '20', 'sex': 'man'}

    """
    命令6：hlen(name)
          获取哈希表中共有键值对的总数
    命令7：hkeys(name)
          获取哈希表中所有的键，返回值是一个列表
    命令8：hvals(name)
          获取哈希表中所有的值，返回值是一个列表
    命令9：hexists(name, key)
          判断某键是否存在于哈希表，返回值是布尔值
    命令10：hdel(name,*keys)
          删除哈希表中相对应的键值对
    """
    print(redis_coon.hlen('myhash'))  # 3
    print(Iterate_ListOrDict(redis_coon.hkeys('myhash')))  # ['name', 'age', 'sex']
    print(Iterate_ListOrDict(redis_coon.hvals('myhash')))  # ['susu', '20', 'man']
    print(redis_coon.hexists('myhash', '1'))  # False
    redis_coon.hdel('myhash', 'name', 'sex')
    print(Iterate_ListOrDict(redis_coon.hgetall('myhash')))  # {'age': '20'}

    """
    命令11：hincrby(name, key, amount=1)
           指定哈希表中的键对应的值(整数)自增amount
    命令12：hincrbyfloat(name, key, amount=1.0)
           指定哈希表中的键对应的值(数字)自增amount
    """
    redis_coon.hincrby('myhash', 'age')
    print(redis_coon.hget('myhash', 'age').decode())  # 21
    redis_coon.hincrbyfloat('myhash', 'age', amount=2.5)
    print(redis_coon.hget('myhash', 'age').decode())  # 23.5

    """
    命令13：hscan(name, cursor=0, match=None, count=None)
    命令14：hscan_iter(name, match=None, count=None)
    """


Hash_operation()

List 类型（列表）

Set 类型（无序集合）

Sorted Set 类型（有序集合）