Redis Within Python

1 基本概念

Redis：Remote Dictionary Server，是一款开源的、基于内存的 NoSql 数据库。由于 Redis 性能远超其他数据库，并且支持集群、分布式及主从同步等优势，所以经常用于缓存数据、高速读写等场景。

各平台安装方法参考网络教程，安装完成后，修改 Redis 配置文件，打开远程连接，设置连接密码

# vim /etc/redis.conf
# 1、bind从127.0.0.1修改为:0.0.0.0，开放远程连接
bind 0.0.0.0 

# 2、设置密码
requirepass 123456

为了保证云服务器数据安全，Redis 开放远程访问的时候，一定要加强密码。接着，启动 Redis 服务，开启防火墙和端口，配置云服务器安全组。默认情况下，Redis 服务使用的端口号是 6379。另外，需要在云服务器安全组进行配置，保证 Redis 数据库能正常连接

# 启动Redis服务，默认redis端口号是6379
systemctl start redis 

# 打开防火墙
systemctl start firewalld.service

# 开放6379端口
firewall-cmd --zone=public --add-port=6379/tcp --permanent   

# 配置立即生效
firewall-cmd --reload

# 安装Python库，便于操作redis
pip3 install redis

启动 redis 数据库

# Windows
redis-server.exe redis.windows.conf
# 启动 Redis CLI
redis-cli.exe -h 127.0.0.1 -p 6379

# Linux
sudo server redis start
sudo server redis stop
sudo server redis restart

# 启动 Redis CLI
redis-cli

# 加载指定的redis配置启动
sudo redis-server /etc/redis/redis.conf
# 查看redis进程
ps-ef | grep redis

2 Python Redis 基本使用

import redis


connection = redis.ConnectionPool(
            host="127.0.0.1",
            port=6379,
            password="密码",
            decode_responses=True
        )
redis_conn = redis.StrictRedis(connection_pool=connection)


class RedisString:
    def __init__(self):
        self.rds = redis_conn

    def save(self, data=None, ex=None, px=None,
             nx=False, xx=False, keepttl=False):
        data_length = len(data)
        if isinstance(data, (tuple, list)) and data_length == 2:
            ret = self.rds.set(
                data[0], data[1], ex=ex, px=px,
                nx=nx, xx=xx, keepttl=keepttl
            )
        elif isinstance(data, dict):
            ret = self.rds.mset(data)
        else:
            raise Exception('Not a valid redis string action')
        return ret

    def query(self, keys):
        if isinstance(keys, str):
            ret = self.rds.get(keys)
        elif isinstance(keys, (tuple, list)):
            ret = self.rds.mget(*keys)
        else:
            raise Exception('Not a valid redis string action')
        return ret

    def delete(self, keys):
        if isinstance(keys, str):
            ret = self.rds.delete(keys)
        elif isinstance(keys, (tuple, list)):
            ret = self.rds.delete(*keys)
        else:
            raise Exception('Not a valid redis string action')
        return ret


class RedisList:
    def __init__(self):
        self.rds = redis_conn

    def save(self, key, value, ref, where='a'):
        if where == 'a':
            where = 'after'
        else:
            where = 'before'
        self.rds.linsert(key, where, ref, value)

    def replace(self, key, value, index=None):
        if index is None:
            index = self.length(key) - 1
        return self.rds.lset(key, index, value)

    def save_first(self, key, values):
        return self.rds.lpush(key, *values)

    def save_last(self, key, values):
        return self.rds.rpush(key, *values)

    def length(self, key):
        return self.rds.llen(key)

    def query(self, key, start=0, end=None):
        if end is None:
            end = self.length(key)
        return self.rds.lrange(key, start, end)

    def del_first(self, key):
        return self.rds.lpop(key)

    def del_last(self, key):
        return self.rds.rpop(key)


class RedisSet:
    def __init__(self):
        self.rds = redis_conn

    def save(self, key, value):
        self.rds.sadd(key, *value)

    def length(self, key):
        return self.rds.scard(key)

    def query(self, key):
        return self.rds.smembers(key)

    def exist(self, key, value):
        return self.rds.sismember(key, value)

    def delete(self, key, values):
        return self.rds.srem(key, *values)


class RedisSortedSet:
    def __init__(self):
        self.rds = redis_conn

    def save(self, key, data, nx=False,
             xx=False, ch=False, incr=False):
        return self.rds.zadd(
            key, data, nx=nx,
            xx=xx, ch=ch, incr=incr
        )

    def query(self, key, start, end=-1, desc=False,
              withscores=False, score_cast=float):
        return self.rds.zrange(
            key, start, end, desc=desc,
            withscores=withscores,
            score_cast_func=score_cast
        )

    def range_count(self, key, low, high):
        return self.rds.zcount(key, low, high)

    def score(self, key, value):
        return self.rds.zscore(key, value)

    def length(self, key):
        return self.rds.zcard(key)

    def delete(self, key, values):
        return self.rds.zrem(key, *values)


class RedisHash:
    def __init__(self):
        self.rds = redis_conn

    def save(self, name, data):
        return self.rds.hset(name, mapping=data)

    def query(self, name, keys, with_keys=False):
        if isinstance(keys, str):
            ret = self.rds.hget(name, keys)
            if with_keys:
                ret = {keys: ret}
        elif isinstance(keys, (tuple, list)):
            ret = self.rds.hmget(name, keys)
            if with_keys:
                ret = {k: v for k, v in zip(keys, ret)}
        else:
            raise Exception('Not a valid redis hash key')
        return ret

    def get_all(self, name, k=True, v=True):
        if k and v:
            ret = self.rds.hgetall(name)
        elif k:
            ret = self.rds.hkeys(name)
        elif v:
            ret = self.rds.hvals(name)
        else:
            raise Exception('Make sure either k or v is True')
        return ret

    def exist(self, name, key):
        return self.rds.hexists(name, key)

    def length(self, name):
        return self.rds.hlen(name)

    def delete(self, name, keys):
        if isinstance(keys, str):
            ret = self.rds.hdel(name, keys)
        elif isinstance(keys, (tuple, list)):
            ret = self.rds.hdel(name, *keys)
        else:
            raise Exception('Not a valid redis hash key')
        return ret


if __name__ == '__main__':
    # rd = RedisString()
    # rd = RedisList()
    # rd = RedisSet()
    # rd = RedisSortedSet()
    rd = RedisHash()
    res = rd.get_all('myht')
    print(res)

3 参考文档

Redis 命令集