Redis

类

import redis
from typing import Union, List, Dict, Tuple

class RedisHelper:
    def __init__(self, host: str, port: int, password: str = None, db: int = 0):
        """
        初始化 RedisHelper 类

        Args:
            host (str): Redis 主机名
            port (int): Redis 端口号
            password (str, optional): Redis 密码，默认为 None
            db (int, optional): Redis 数据库，默认为 0
        """
        self.host = host
        self.port = port
        self.password = password
        self.db = db
        self.connection = None

    def connect(self):
        """
        连接到 Redis 数据库
        """
        self.connection = redis.Redis(
            host=self.host,
            port=self.port,
            password=self.password,
            db=self.db
        )

    def disconnect(self):
        """
        断开与 Redis 数据库的连接
        """
        if self.connection:
            self.connection.close()

    # String 类型操作
    def get(self, key: str) -> Union[str, None]:
        """
        获取 Redis 中指定 key 的值

        Args:
            key (str): Redis 键名

        Returns:
            Union[str, None]: Redis 键值
        """
        return self.connection.get(key)

    def set(self, key: str, value: str) -> bool:
        """
        设置 Redis 中指定 key 的值

        Args:
            key (str): Redis 键名
            value (str): Redis 键值

        Returns:
            bool: 设置是否成功
        """
        return self.connection.set(key, value)

    # Hash 类型操作
    def hget(self, key: str, field: str) -> Union[str, None]:
        """
        获取 Redis 中指定 key 的哈希字段的值

        Args:
            key (str): Redis 键名
            field (str): 哈希字段名

        Returns:
            Union[str, None]: 哈希字段值
        """
        return self.connection.hget(key, field)

    def hset(self, key: str, field: str, value: str) -> bool:
        """
        设置 Redis 中指定 key 的哈希字段的值

        Args:
            key (str): Redis 键名
            field (str): 哈希字段名
            value (str): 哈希字段值

        Returns:
            bool: 设置是否成功
        """
        return self.connection.hset(key, field, value)

    # List 类型操作
    def lrange(self, key: str, start: int, end: int) -> List[str]:
        """
        获取 Redis 中指定 key 的列表范围内的元素

        Args:
            key (str): Redis 键名
            start (int): 起始索引
            end (int): 结束索引

        Returns:
            List[str]: 列表元素列表
        """
        return self.connection.lrange(key, start, end)

    def lpush(self, key: str, values: Union[str, List[str]]) -> int:
        """
        将一个或多个值插入 Redis 列表的开头

        Args:
            key (str): Redis 键名
            values (Union[str, List[str]]): 要插入的值或值列表

        Returns:
            int: 插入后列表的长度
        """
        if isinstance(values, str):
            values = [values]
        return self.connection.lpush(key, *values)

    # Set 类型操作
    def smembers(self, key: str) -> set:
        """
        获取 Redis 中指定 key 的集合所有成员

        Args:
            key (str): Redis 键名

        Returns:
            set: 集合成员集合
        """
        return self.connection.smembers(key)

    def sadd(self, key: str, members: Union[str, List[str]]) -> int:
        """
        将一个或多个成员添加到 Redis 集合中

        Args:
            key (str): Redis 键名
            members (Union[str, List[str]]): 要添加的成员或成员列表

        Returns:
            int: 添加的成员数量
        """
        if isinstance(members, str):
            members = [members]
        return self.connection.sadd(key, *members)

    # Sorted Set 类型操作
    def zrange(self, key: str, start: int, end: int) -> List[str]:
        """
        获取 Redis 中指定 key 的有序集合范围内的元素

        Args:
            key (str): Redis 键名
            start (int): 起始索引
            end (int): 结束索引

        Returns:
            List[str]: 有序集合元素列表
        """
        return self.connection.zrange(key, start, end)

    def zadd(self, key: str, members_with_scores: Dict[str, float]) -> int:
        """
        将一个或多个成员添加到 Redis 有序集合中

        Args:
            key (str): Redis 键名
            members_with_scores (Dict[str, float]): 要添加的成员和分数字典

        Returns:
            int: 添加的成员数量
        """
        return self.connection.zadd(key, members_with_scores)

使用示例

# 使用示例
# 初始化 RedisHelper
redis_helper = RedisHelper("localhost", 6379)

# 连接到 Redis
redis_helper.connect()

# 设置字符串键值对
redis_helper.set("name", "John")
redis_helper.set("age", "25")

# 获取字符串键值对
name = redis_helper.get("name")
age = redis_helper.get("age")
print(f"Name: {name}")
print(f"Age: {age}")

# 设置哈希字段值
redis_helper.hset("user", "name", "John")
redis_helper.hset("user", "age", "25")

# 获取哈希字段值
user_name = redis_helper.hget("user", "name")
user_age = redis_helper.hget("user", "age")
print(f"User Name: {user_name}")
print(f"User Age: {user_age}")

# 插入列表值
redis_helper.lpush("numbers", ["1", "2", "3"])

# 获取列表值
numbers = redis_helper.lrange("numbers", 0, -1)
print(f"Numbers: {numbers}")

# 添加集合成员
redis_helper.sadd("fruits", ["apple", "banana", "orange"])

# 获取集合成员
fruits = redis_helper.smembers("fruits")
print(f"Fruits: {fruits}")

# 添加有序集合成员
members_with_scores = {
    "John": 100,
    "Alice": 90,
    "Bob": 80
}
redis_helper.zadd("scores", members_with_scores)

# 获取有序集合成员
scores = redis_helper.zrange("scores", 0, -1)
print(f"Scores: {scores}")

# 断开与 Redis 的连接
redis_helper.disconnect()