Python | Redis工具类

一、需求

• 自动连接Redis数据库，通过连接池处理数据
• 对输出结果进行Log打印并保存到文件

二、代码

• Utils.redisUtils.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import redis
from Utils.logger import log

"""
Redis数据格式
    (1) 字符串 | 存储形式: key - value:str
        - 存储二进制数据 : 可以存储任意类型的数据，包括文本、数字、二进制数据等
        - 键值对存储 : 每个字符串有键（key）和对应的值（value）
        - 支持设置过期时间 : 可设置过期时间，到期后自动删除
    
    (2) 哈希 | 存储形式: key - { field:value, field:value ...}
        - 键值对存储 : 存储多个键值对，每个键对应一个值
        - 不可重复 : 每个key的field字段唯一，不可重复
        - 高效查找 : 通过键可以快速查找对应的值，时间复杂度为O(1)
        - 支持添加、删除、修改键值对，以及获取指定键的值
        
    (3) 列表 | 存储形式: key - [value , value ...]
        - 可重复 : 同一个元素可以出现多次
        - 元素有序 : 列表中的元素按照插入顺序排列，保持有序性
        - 支持在列表两端进行元素的插入、删除操作
    
    (4) 集合 | 存储形式: key - [member , member ...]
        - 不可重复 : 成员唯一，不能重复
        - 元素无序：没有固定的顺序，每次获取的元素顺序可能不同
        
    (5) 有序集合 | 存储形式: key - [member:score , member:score ...]
        - 不可重复 : 成员唯一，不能重复
        - 成员按照分数的大小顺序排列，相同分数的成员按照字典序排列
"""


class RedisUtils:
    def __init__(self, host='localhost', port=6379, db=0, password=''):
        """
            初始化Redis连接池
        :param host: 主机名
        :param port: 端口
        :param db: 数据库
        :param password: 密码
        """
        pool = redis.ConnectionPool(host=host, port=port, db=db, password=password, max_connections=None)
        self.rdb = redis.Redis(connection_pool=pool)
        self.logger = log()
        self.ListLeft = 0
        self.ListRight = 1

    def __del__(self):
        """ 程序结束后，自动关闭连接，释放资源 """
        self.rdb.connection_pool.disconnect()

    def flush_all_data(self):
        """
            清除数据库所有数据
        :return: 是否清除成功
        """
        result = self.rdb.flushdb()
        self.logger.debug("[Redis] Database cleared successfully") \
            if result else self.logger.error("[Redis] Failed to clear the database")
        return result

    def print_all_data(self):
        """ 遍历数据库所有键值对 """
        for key in self.rdb.scan_iter(match='*'):
            key_type = self.rdb.type(key).decode('utf-8')

            if key_type == 'string':
                value = self.rdb.get(key).decode('utf-8')
            elif key_type == 'hash':
                value = self.rdb.hgetall(key)
            elif key_type == 'list':
                value = self.rdb.lrange(key, 0, -1)
            elif key_type == 'set':
                value = self.rdb.smembers(key)
            elif key_type == 'zset':
                value = self.rdb.zrange(key, 0, -1, withscores=True)
            else:
                value = "Unsupported type"

            print(f'{key_type} -> {key.decode("utf-8")} : {value}')

    def get_keyType(self, key):
        """
            获取指定key的类型
        :param key: 键
        :return: 类型（字符串格式）
        """
        return self.rdb.type(key)

    def isExists_key(self, key):
        """
            判断是否存在指定key
        :param key: 键
        :return: 布尔值
        """
        return False if self.rdb.exists(key) == 0 else True

    def delete_key(self, key):
        """
            删除指定key的成员
        :param key: 键
        :return: 成功删除的个数
        """
        return self.rdb.delete(key)

    def rename_key(self, old, new):
        """
            重命名指定key
        :param old: 旧key值
        :param new: 新key值
        :return:
        """
        if self.isExists_key(old):
            return self.rdb.rename(old, new)

    def set_expire_by_second(self, key, second=60 * 60 * 24 * 7):
        """
            以秒为单位设置过期时间
        :param key: 键
        :param second: 默认7天
        :return:
        """
        return self.rdb.expire(key, time=second)

    def remove_expire(self, key):
        """
            移除key的过期时间，持久保持
        :param key: 键
        :return:
        """
        return self.rdb.persist(key)

    def get_expire_by_second(self, key):
        """
            以秒为单位返回key的剩余过期时间
        :param key: 键
        :return:
        """
        return self.rdb.ttl(key)

    def add_str(self, key: str, value: str):
        """
            添加字符串类型键值对 
        :param key: 键
        :param value: 字符串值
        :return: 是否添加成功
        """
        result = self.rdb.set(key, value)
        self.logger.debug(f"[Redis] Successfully added <{key}:{value}>") \
            if result else self.logger.error(f"[Redis] Failed added <{key}:{value}>")
        return result

    def get_str(self, key):
        """
            获取指定key的value，若不存在key，返回 None
        :param key: 键
        :return: 值
        """
        return self.rdb.get(key)

    def append_str(self, key, append_str: str):
        """
            追加指定key的value,若不存在key，新建键值对 
        :param key: 键
        :param append_str: 追加字符串值
        :return: 追加后值的长度
        """
        return self.rdb.append(key, append_str)

    def add_list(self, key, *value, direction=0):
        """
            列表添加数据
        :param key: 键
        :param value: 列表值
        :param direction: 添加方向（左边ListLeft /右边ListRight）
        :return:
        """
        if direction == self.ListLeft:
            self.rdb.lpush(key, *value)
        elif direction == self.ListRight:
            self.rdb.rpush(key, *value)
        else:
            self.logger.error("[Redis] Unrecognized type of direction")

    def get_list_by_range(self, key, start=0, end=-1):
        """
            获取列表指定索引范围的列表值
        :param key: 键
        :param start: 起始索引位置
        :param end: 结束索引位置
        :return: 索引范围内的列表值
        """
        return self.rdb.lrange(key, start, end)

    def get_list_by_index(self, key, index):
        """
            获取列表指定下标的列表值
        :param key: 键
        :param index: 指定索引
        :return: 索引对应列表值
        """
        return self.rdb.lindex(key, index)

    def pop_list_by_direction(self, key, direction=0):
        """
            根据删除方向删除列表数据
        :param key: 键
        :param direction: 删除方向（左边ListLeft /右边ListRight）
        :return:
        """
        if direction == self.ListLeft:
            self.rdb.lpop(key)
        elif direction == self.ListRight:
            self.rdb.rpop(key)
        else:
            self.logger.error("[Redis] Unrecognized type of direction")

    def pop_list_by_value(self, key, value, count=1):
        """
            根据指定列表值删除列表数据
        :param key: 键
        :param value:指定列表值
        :param count:若存在多个，删除指定个数
        :return: 成功删除的个数
        """
        result = self.rdb.lrem(key, count, value)
        self.logger.debug(f"[Redis] List delete {result} values:{value}")
        return result

    def add_hash(self, key, field, value):
        """
            哈希添加数据
        :param key: 键
        :param field: filed域
        :param value: value域
        :return: 成功添加数据的条数
        """
        _value = self.rdb.hget(key, field)
        msg = f"[Redis] Hash add {key} = {{{field} : {value}}}" \
            if _value is None else f"[Redis] Set replace {key} = {{{field} : {_value} -> {value}}}"
        self.logger.debug(msg)
        return self.rdb.hset(key, field, value)

    def get_hash_by_field(self, key, field):
        """
            获取哈希指定key、field的value值
        :param key: 键
        :param field: filed值
        :return: value值
        """
        return self.rdb.hget(key, field)

    def get_hash_all_filed(self, key):
        """
            获取所有的field值
        :param key: 键
        :return: 列表 [field,field ...]
        """
        return self.rdb.hkeys(key)

    def get_hash_all_value(self, key):
        """
            获取所有的value值
        :param key: 键
        :return: 列表 [value,value ...]
        """
        return self.rdb.hvals(key)

    def get_hash_all_KeyValue(self, key):
        """
            获取所有的键值对 
        :param key: 键
        :return: 字典 {field:value,field:value ...}
        """
        return self.rdb.hgetall(key)

    def add_set(self, key, *values):
        """
            集合添加数据
        :param key: 键
        :param values: 值（可以多个）
        :return: 添加到集合中的新成员的数量
        """
        return self.rdb.sadd(key, *values)

    def get_set(self, key):
        """
            获取集合指定key的value列表
        :param key: 键
        :return: 列表 [value,value ...]
        """
        return self.rdb.smembers(key)

    def delete_set_random(self, key):
        """
            移除指定key的随机value值
        :param key: 键
        :return: 删除的值
        """
        return self.rdb.spop(key)

    def delete_set_assign(self, key, *values):
        """
            移除指定key的指定value值
        :param key: 键
        :param values: 指定value值
        :return: 删除成功的个数
        """
        return self.rdb.srem(key, *values)

    def add_sortSet(self, key, mapping):
        """
            有序集合添加数据，若已存在member，则更新分数score
        :param key: 键
        :param mapping: 值 {member:score , member:score ...}
        :return: 成功添加到有序集合中的新成员的数量
        """
        return self.rdb.zadd(key, mapping)

    def get_sortSet_by_indexRange(self, key, start=0, end=-1, with_score=True):
        """
            获取指定下标index范围内(start,end)的成员及分数
        :param key: 键
        :param start: 起始索引值
        :param end: 结束索引值
        :param with_score: 返回结果是否包含分数scores
        :return: 列表 [(member, scores), (member, scores) ...] 或 [member, member ...]

        """
        return self.rdb.zrange(key, start, end, withscores=with_score)

    def get_sortSet_by_scoreRange(self, key, min, max):
        """
            获取指定分数score范围内(min,max)的成员及分数
        :param key: 键
        :param min: 最小分数值
        :param max: 最大分数值
        :return: 列表 [member, member ...]
        """
        return self.rdb.zrangebyscore(key, min, max)

    def delete_sortSet_by_member(self, key, *members):
        """
            删除指定member的成员
        :param key: 键
        :param members: 指定member值
        :return: 成功移除的成员数量
        """
        return self.rdb.zrem(key, *members)

    def delete_sortSet_by_indexRange(self, key, start=0, end=-1):
        """
            删除指定下标index范围内(start,end)的成员及分数
        :param key: 键
        :param start: 起始索引值
        :param end: 结束索引值
        :return: 成功移除的成员数量
        """
        return self.rdb.zremrangebyrank(key, start, end)

    def delete_sortSet_by_scoreRange(self, key, min, max):
        """
            删除指定分数score范围内(min,max)的成员及分数
        :param key: 键
        :param min: 最小分数值
        :param max: 最大分数值
        :return: 成功移除的成员数量
        """
        return self.rdb.zremrangebyscore(key, min, max)

• Utils.logger.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import inspect
import logging
import platform
from pathlib import Path
from colorlog import ColoredFormatter
from logging.handlers import RotatingFileHandler

RES_LOG_PATH = "输出log文件路径"

def log(name: str = None) -> logging.Logger:
    """
    设置并返回到记录器
    :param name: 如果需要新的记录器，输入logger名字
    :return: logger
    """
    # 重置 根logger 处理程序
    root_logger = logging.getLogger()
    root_logger.handlers = []

    if not name:
        absolute_path = Path(inspect.stack()[1].filename).resolve()
        relative_path = str(absolute_path.relative_to(Path(__file__).resolve().parent.parent))
        spliter = (lambda sys: "\\" if sys == "Windows" else "/" if sys == "Linux" else Exception("Incompatible systems"))(platform.system())
        name = ".".join([str(n) for n in os.path.splitext(relative_path)[0].split(spliter) if n])

    # 检查 logger 是否存在，如果存在则返回，否则创建
    logger = logging.getLogger(name)
    if logger.hasHandlers():
        return logger
    else:
        # 创建 logger 对象
        logger = logging.getLogger(str(name.split(".")[0]))
        logger.setLevel(logging.DEBUG)

        # 定义 Handler 对象
        file_handler = RotatingFileHandler(os.path.join(RES_LOG_PATH, "x_log.log"), maxBytes=1048576, backupCount=10)
        console_handler = logging.StreamHandler()

        # 设置日志级别
        file_handler.setLevel(logging.DEBUG)
        console_handler.setLevel(logging.DEBUG)

        # 设置输出格式化程序
        file_fmt = "%(asctime)s - %(levelname)s [%(name)s] %(message)s"
        color_fmt = f"%(log_color)s{file_fmt}%(reset)s"
        date_fmt = "%Y-%m-%d %H:%M:%S"

        file_formatter = logging.Formatter(file_fmt)
        console_formatter = ColoredFormatter(
            color_fmt, datefmt=date_fmt, reset=True,
            log_colors={
                "DEBUG": "cyan", "INFO": "green",
                "WARNING": "yellow", "ERROR": "red",
                "CRITICAL": "red",
            },
        )
        file_handler.setFormatter(file_formatter)
        console_handler.setFormatter(console_formatter)

        # 将 handler 添加到 logger
        logger.addHandler(file_handler)
        logger.addHandler(console_handler)

        logger.debug(f"Initialize logger {name}")
        return logging.getLogger(name)