python redis操作(五个基本类型、集群、管道、池、远程连接)

一、redis基本介绍

1、介绍

Redis：REmote DIctionary Server（远程字典服务器），是完全开源免费的，用C语言编写的，遵守BSD协议，是一个高性能的（Key/Value）分布式内存数据库，基于内存运行，并支持持久化的NoSQL数据库，是当前最热门的NoSQL数据库之一，也被人们称为数据结构服务器。
Redis与其他key-value缓存产品有以下三个特点：

• Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。
• Redis不仅仅支持简单的 key-value 类型的数据，同时还提供list、set、zset、hash等数据结构的存储。
• Redis支持数据的备份，即master-slave模式的数据备份。

2、使用原因及场景

（1）redis使用原因

• 解决应用服务器的cpu和内存压力
• 减少io的读操作，减轻io的压力
• 关系型数据库的扩展性不强，难以改变表结构

（2）适用场景

• 数据高并发的读写
• 海量数据的读写
• 对扩展性要求高的数据

（3）使用场景

• 配合关系型数据库做高速缓存 ，缓存高频次访问的数据，降低数据库io， 分布式架构，做session共享
• 可以持久化特定数据。利用zset类型可以存储排行榜 利用list的自然时间排序存储最新n个数据

二、python 远程连接redis(阿里云ECS)

本文接下来的实验都是远程连接阿里云ECS里安装的redis，下面介绍一下，云服务器中redis如何设置才能远程访问。

开启redis的命令这里不再细说，各位可以自行查找命令，设置连接密码等，这里建议开启6379端口，一定设置redis连接密码，防止被病毒攻击。

（1）首先，需要修改redis配置文件，进入redis.conf，将绑定的ip改为0.0.0.0，port为6379，然后重启redis server。

 （2）然后，进入云服务器管理控制台，找到安全组，点击进入。

（3） 进入安全组之后，可以手动添加端口，假设redis服务开启的6379端口，添加如下。

 之后就可以进行远程连接了，可以按照如下测试代码进行测试。

# 测试远程连接是否成功
# redis 提供两个类 Redis 和 StrictRedis, StrictRedis 用于实现大部分官方的命令，Redis 是 StrictRedis 的子类
def test_install():
    # 连接redis数据库，其中db表示数据库0，decode_response表示将取出结果改成字符串类型
    r = redis.StrictRedis(host='1.1.1.1', port=6379, db=0, decode_responses=True, password='111111')
    # 向redis数据库添加k-v
    r.set('key1', 'value1')
    # 从redis中取出值
    print(r.get('key1'))
    # 清空redis数据库0
    r.flushdb()

测试结果如下，成功连接。 

三、python 连接池和管道

1、连接池

redis是基于内存的数据库，效率非常高，所以每次进行连接比真正使用消耗的资源和时间还多。所以为了节省资源，减少多次连接损耗，连接池的作用相当于缓存了多个客户端与redis服务端的连接，当有新的客户端来进行连接时，此时，只需要去连接池获取一个连接即可，实际上连接池就是把一个连接共享给多个客户端。所以redis-py 使用 connection pool 来管理对一个 redis server 的所有连接，避免每次建立、释放连接的开销。

def link_poll():
    # 建立连接池
    conn_pool = redis.ConnectionPool(host='1.1.1.1', port=6379, db=1, decode_responses=True, password='111111')
    # 客户端0连接数据库
    r0 = redis.StrictRedis(connection_pool=conn_pool)
    r0.set('key1', 'value1')
    print(r0.get('key1'))

    # 客户端2连接数据库
    r1 = redis.StrictRedis(connection_pool=conn_pool)
    r1.set('key2', 'value2')
    print(r1.get('key2'))
    r0.flushdb()
    r1.flushdb()

2、管道

如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。管道（pipeline）是redis在提供单个请求中缓冲多条服务器命令的基类的子类。它通过减少服务器-客户端之间反复的TCP数据库包，从而大大提高了执行批量命令的功能。

def cmd_pipeline():
    conn_pool = redis.ConnectionPool(host='1.1.1.1', port=6379, db=0, decode_responses=True, password='111111')
    r0 = redis.StrictRedis(connection_pool=conn_pool)
    # pipe = r.pipeline(transaction=False)
    # 默认的情况下，管道里执行的命令可以保证执行的原子性，执行pipe = r.pipeline(transaction=False)可以禁用这一特性。
    # pipe = r.pipeline(transaction=True)
    pipe = r0.pipeline()  # 创建一个管道
    pipe.set('name', 'jack')
    pipe.set('role', 'sb')
    pipe.sadd('faz', 'baz')
    pipe.incr('num')  # 如果num不存在则vaule为1，如果存在，则value自增1
    pipe.execute()
    print(r0.get("name"))
    print(r0.get("role"))
    print(r0.get("num"))

四、python redis 五大基本类型操作

1、string

# redis 基本命令 string
def cmd_string():
    conn_pool = redis.ConnectionPool(host='1.1.1.1', port=6379, db=0, decode_responses=True, passwoed='111111')
    r0 = redis.StrictRedis(connection_pool=conn_pool)
    # ex：过期时间(秒)，px：过期时间(毫秒)  设置过期时间后，键值在时间结束后就清除
    r0.set('key1', 'value1', ex=3)
    r0.set('key2', 'value2', px=4)
    # nx：nx为True，则只有key不存在时，操作才会执行
    # xx：xx为True，则只有key存在时，操作才会执行
    r0.set('key1', 'value1', nx=True)
    r0.set('key2', 'value2', xx=True)
    # 对应的 setnx(key, value) 只有key不存在时，操作才会执行
    # 对应的 setex(key, time, value) time - 过期时间(秒)
    # 对应的 psetex(key, time_ms, value) time_ms - 过期时间(毫秒)
    r0.setnx('key3', 'value3')
    r0.setex('key4', 3, 'value4')
    time.sleep(3)
    print(r0.get('key4'))
    # mset 批量设置值；mget 批量获取值
    keydict = {}
    keydict['key5'] = 'value5'
    keydict['key6'] = 'value6'
    r0.mset(keydict)
    print(r0.mget('key5', 'key6'))
    # setrange(key, start, end) 修改字符串内容，从指定字符串索引开始向后替换
    # getrange(key, start, end) 获取子序列（根据字节获取，非字符）
    r0.setrange('key6', 2, '222')
    print(r0.get('key6'))
    print(r0.getrange('key5', 1, 3))
    # strlen(key) 返回key对应值的字节长度（一个汉字3个字节）
    print(r0.strlen('key5'))
    # incr(self, key, amount=1) 自增 key 对应的值，当 key 不存在时，则创建 key＝amount，否则，则自增
    r0.set('key7', 1)
    r0.incr('key7', amount=1)
    print(r0.get('key7'))
    # decr(self, key, amount=1) 自减 key 对应的值，当 key 不存在时，则创建 key＝amount，否则，则自减。
    r0.decr('key7', amount=1)
    print(r0.get('key7'))
    # append(key, value) 在redis key对应的值后面追加内容
    r0.append('key6', '5454')
    print(r0.get('key6'))
    # 删除键
    r0.delete('key6')
    print(r0.get('key6'))
    r0.flushdb()

2、hash

# redis 基本命令 hash
def cmd_hash():
    conn_pool = redis.ConnectionPool(host='1.1.1.1', port=6379, db=0, decode_responses=True)
    r0 = redis.StrictRedis(connection_pool=conn_pool)
    # hset(name, key, value) name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
    r0.hset("hash1", "k1", "v1")
    r0.hset("hash1", "k2", "v2")
    print(r0.hkeys("hash1"))  # 取hash中所有的key
    print(r0.hget("hash1", "k1"))  # 单个取hash的key对应的值
    print(r0.hmget("hash1", "k1", "k2"))  # 多个取hash的key对应的值
    r0.hsetnx("hash1", "k2", "v3")  # 只能新建, 只有key不存在时，操作才会执行
    print(r0.hget("hash1", "k2"))
    # hmset(name, mapping) 批量增加，在name对应的hash中批量设置键值对
    r0.hmset('hash2', {'k1': 'v1', 'k2': 'v2'})
    # hmget(name, keys, *args) 在name对应的hash中获取多个key的值
    print(r0.hmget('hash2', 'k1', 'k2'))
    # hgetall(name) 取出所有的键值对
    print(r0.hgetall('hash1'))
    # hlen(name) 得到所有键值对的格式 hash长度
    print(r0.hlen('hash1'))
    # hkeys(name) 得到所有的keys（类似字典的取所有keys）
    print(r0.hkeys('hash1'))
    # hvals(name) 得到所有的value（类似字典的取所有value）
    print(r0.hvals('hash1'))
    # hexists(name, key) 判断成员是否存在（类似字典的in
    print(r0.hexists("hash1", "k4"))  # False 不存在
    print(r0.hexists("hash1", "k1"))  # True 存在
    # hdel(name,*keys) 删除键值对
    r0.hdel('hash1', 'k1', 'v1')
    print(r0.hget('hash', 'k1'))
    # hincrby(name, key, amount=1) 自增自减整数(将key对应的value--整数 自增1或者2，或者别的整数 负数就是自减)
    r0.hset('hash1', 'k3', 1)
    r0.hincrby('hash1', 'k3', amount=5)
    print(r0.hget('hash1', 'k3'))
    r0.flushdb()

3、list

# redis 基本命令 list
def cmd_list():
    conn_pool = redis.ConnectionPool(host='1.1.1.1', port=6379, db=0, decode_responses=True, password='111111')
    r0 = redis.StrictRedis(connection_pool=conn_pool)
    # lpush(name,values) 增加（类似于list的append，只是这里是从左边新增加）--没有就新建
    r0.lpush('list1', 1, 2, 3)
    # lrange(name, start, end) 取出元素
    print(r0.lrange('list1', 0, -1))  # 取出列表全部元素
    # rpush(name,values) 增加（从右边增加）--没有就新建
    r0.rpush('list2', 1, 2, 3)
    print(r0.lrange('list2', 0, -1))
    # lpushx(name,value) 往已经有的name的列表的左边添加元素，没有的话无法创建
    r0.lpushx("list2", 77)
    print(r0.lrange('list2', 0, -1))
    # rpushx(name,value) 往已经有的name的列表的右边添加元素，没有的话无法创建
    r0.rpushx("list2", 66)
    print(r0.lrange('list2', 0, -1))
    # linsert(name, where, refvalue, value)) 新增（固定索引号位置插入元素）
    # 参数：where - BEFORE或AFTER; refvalue - 标杆值，即：在它前后插入数据; value - 要插入的数据
    r0.linsert("list2", "before", "66", "00")  # 往列表中左边第一个出现的元素"66"前插入元素"00"
    print(r0.lrange("list2", 0, -1))
    # r.lset(name, index, value) 修改（指定索引号进行修改）
    r0.lset('list2', 0, 101)  # 把索引号是0的元素修改成101
    print(r0.lrange("list2", 0, -1))
    # r.lrem(name, value, num) 删除（指定值进行删除）
    # 参数：value - 要删除的值; num=0，删除列表中所有的指定值; num=2 - 从前到后，删除2个, num=1,从前到后，删除左边第1个; num=-2 - 从后向前，删除2个
    r0.lrem("list2", "66", 1)  # 将列表中左边第一次出现的"11"删除
    print(r0.lrange("list2", 0, -1))
    r0.lrem("list2", "99", -1)  # 将列表中右边第一次出现的"99"删除
    print(r0.lrange("list2", 0, -1))
    r0.lrem("list2", "22", 0)  # 将列表中所有的"22"删除
    print(r0.lrange("list2", 0, -1))
    # lpop(name) 删除并返回; rpop(name) 表示从右向左操作
    print(r0.lpop('list1'))
    # ltrim(name, start, end) 删除索引之外的值
    r0.ltrim('list2', 0, 1)
    print(r0.lpop('list2'))
    # lindex(name, index) 取值（根据索引号取值）
    print(r0.lindex("list2", 0))  # 取出索引号是0的值
    # rpoplpush(src, dst) 移动 元素从一个列表移动到另外一个列表
    r0.rpoplpush('list1', 'list2')
    print(r0.lrange("list2", 0, -1))
    r0.flushdb()

4、set

# redis 基本命令 set
def cmd_set():
    conn_pool = redis.ConnectionPool(host='1.1.1.1', port=6379, db=0, decode_responses=True, password='111111')
    r0 = redis.StrictRedis(connection_pool=conn_pool)
    # sadd(name, values) 向redis中新增集合
    r0.sadd('set1', 1, 2, 3)
    print(r0.smembers('set1'))  # 获取集合中所有的成员
    # scard(name) 获取元素个数 类似于len
    print(r0.scard('set1'))
    # sdiff(keys, *args) 差集
    r0.sadd('set2', 1, 22, 33)
    print(r0.sdiff('set1', 'set2'))  # 在集合set1但是不在集合set2中
    print(r0.sdiff("set2", "set1"))  # 在集合set2但是不在集合set1中
    # sdiffstore(dest, keys, *args) 差集--差集存在一个新的集合中
    r0.sdiffstore("set3", "set1", "set2")  # 在集合set1但是不在集合set2中
    print(r0.smembers("set3"))  # 获取集合3中所有的成员
    # sinter(keys, *args) 交集
    print(r0.sinter('set1', 'set2'))  # 取2个集合的交集
    # sinterstore(dest, keys, *args) 交集--交集存在一个新的集合中
    r0.sinterstore('set3', 'set1', 'set2')
    print(r0.smembers('set3'))
    # sunion(keys, *args) 并集
    print(r0.sunion("set1", "set2"))  # 取2个集合的并集
    # sunionstore(dest,keys, *args) 并集--并集存在一个新的集合
    r0.sunionstore("set3", "set1", "set2")  # 取2个集合的并集
    print(r0.smembers("set3"))
    # sismember(name, value) 判断是否是集合的成员 类似in
    print(r0.sismember('set1', 88))
    print(r0.sismember('set1', 2))
    # smove(src, dst, value) 将某个成员从一个集合中移动到另外一个集合
    r0.smove("set1", "set2", 2)
    print(r0.smembers("set1"))
    print(r0.smembers("set2"))
    # spop(name) 随机删除并且返回被删除值
    print(r0.spop("set2"))  # 这个删除的值是随机删除的，集合是无序的
    print(r0.smembers("set2"))
    # srem(name, values) 指定值删除
    print(r0.srem("set1", 1))  # 从集合中删除指定值 11
    print(r0.smembers("set1"))
    r0.flushdb()

5、有序set

# redis 基本命令 有序set
def cmd_sort_set():
    conn_pool = redis.ConnectionPool(host='1.1.1.1', port=6379, db=0, decode_responses=True, password='111111')
    r0 = redis.StrictRedis(connection_pool=conn_pool)
    keydict = {}
    keydict['n1'] = 1
    keydict['n2'] = 2
    keydict['n3'] = 38
    keydict['n4'] = 15
    keydict['n5'] = 21
    keydict['n6'] = 7
    r0.zadd('zset1', keydict)
    print(r0.zrange('zset1', 0, -1))  # 获取有序集合中所有元素
    print(r0.zrange('zset1', 0, -1, withscores=True))  # 获取有序集合中所有元素和分数
    # zcard(name) 获取有序集合元素个数 类似于len
    print(r0.zcard("zset1"))  # 集合长度
    # r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float) 获取有序集合的所有元素
    # 按照索引范围获取name对应的有序集合的元素
    # name - redis的name
    # start - 有序集合索引起始位置（非分数）
    # end - 有序集合索引结束位置（非分数）
    # desc - 排序规则，默认按照分数从小到大排序
    # withscores - 是否获取元素的分数，默认只获取元素的值
    # score_cast_func - 对分数进行数据转换的函数
    print(r0.zrange('zset1', 0, -1, desc=False, withscores=True, score_cast_func=int))
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float) 按照分数范围获取name对应的有序集合的元素
    print(r0.zrangebyscore('zset1', 1, 18, withscores=True))
    # zcount(name, min, max) 获取name对应的有序集合中分数 在 [min,max] 之间的个数
    print(r0.zcount('zset1', 1, 20))
    # zincrby(name, amount, value) 自增
    r0.zincrby("zset1", amount=2.0, value='n2')  # 每次将n2的分数自增2
    print(r0.zrange("zset1", 0, -1, withscores=True))
    # zrank(name, value) 获取值的索引号
    print(r0.zrank("zset1", "n1"))  # n1的索引号是0 这里按照分数顺序（从小到大）
    print(r0.zrank("zset1", "n6"))  # n6的索引号是2
    print(r0.zrevrank("zset1", "n1"))  # n1的索引号是5 这里按照分数倒序（从大到小）
    # zrem(name, values) 指定值删除
    r0.zrem("zset1", "n3")  # 删除有序集合中的元素n3 删除单个
    print(r0.zrange("zset1", 0, -1))
    # zremrangebyrank(name, min, max) 根据排行范围删除，按照索引号来删除
    r0.zremrangebyrank('zset1', 0, 1)
    print(r0.zrange("zset1", 0, -1, withscores=True))
    # zremrangebyscore(name, min, max) 根据分数范围删除
    r0.zremrangebyscore("zset1", 3, 16)  # 删除有序集合中的分数是11-22的元素
    print(r0.zrange("zset1", 0, -1, withscores=True))
    # zscore(name, value) 获取值对应的分数
    print(r0.zscore("zset1", "n5"))  # 获取元素n27对应的分数27
    r0.flushdb()

五、python 操作redis集群

1、redis构建集群(一主二从、哨兵模式)

redis的基本操作这里不再详细叙述，本节直接记录redis如何构建集群，为了演示方便，本集群配置在一台服务器下配置一主二从的集群模式，并使用哨兵监视。

（1）首先，需要配置redis.conf文件，构建redis6379.conf、redis6380.conf、redis6381.conf三个文件分别对应，端口为6379、6380、6381三个redis，并通过这三个文件开启集群。对于每个文件内容需要进行一些更改。步骤如下：

创建多个redis文件：

root@ymumu-server1:/home/redis-6.2.5# cp redis.conf redis6379.conf
root@ymumu-server1:/home/redis-6.2.5# cp redis.conf redis6380.conf
root@ymumu-server1:/home/redis-6.2.5# cp redis.conf redis6381.conf

分别进入各个文件进行内容修改：
1、指定端口 6379，其他两文件依次类推6380、6381
3、开启daemonize yes
4、Pid文件名字 pidfile /var/run/redis_6379.pid , 依次类推
5、Log文件名字 logfile "6379.log" , 依次类推
6、Dump.rdb 名字 dbfilename dump6379.rdb , 依次类推

三个文件都配置完成后，需要服务开启，分别对应三个文件，命令如下：

root@ymumu-server1:/usr/local/bin# redis-server /home/redis-6.2.5/redis6379.conf
root@ymumu-server1:/usr/local/bin# redis-server /home/redis-6.2.5/redis6380.conf
root@ymumu-server1:/usr/local/bin# redis-server /home/redis-6.2.5/redis6381.conf
root@ymumu-server1:/usr/local/bin# ps -ef | grep redis
root       83555   83441  0 11:03 pts/0    00:00:00 vim redis6379.conf
root       83577       1  0 11:15 ?        00:00:00 redis-server 0.0.0.0:6379
root       83584       1  0 11:15 ?        00:00:00 redis-server 0.0.0.0:6380
root       83590       1  0 11:15 ?        00:00:00 redis-server 0.0.0.0:6381
root       83596   83489  0 11:15 pts/1    00:00:00 grep --color=auto redis

准备环境搭建完成，接下来需要进行主从配置，并开启哨兵模式。
默认情况下，开启的三个redis都是主节点，用命令info replication查看，如下所示。

接下来的主从配置 配置为6379为Master 其余两个为Slave，命令如下：

127.0.0.1:6380> SLAVEOF 127.0.0.1 6379
OK

接下来，配置哨兵模式：

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。Redis从2.8开始正式提供了Sentinel（哨兵） 架构来解决这个问题。
哨兵有两个作用：

• 通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
• 当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。

配置步骤如下：

1、redis 目录下sentinel.conf 文件
3、配置哨兵，填写内容
sentinel monitor 被监控主机名字 127.0.0.1 6379 1
上面最后一个数字1，表示主机挂掉后slave投票看让谁接替成为主机，得票数多少后成为主机
4、启动哨兵
Redis-sentinel /redis-6.2.5/sentinel.conf
上述目录依照各自的实际情况配置，可能目录不同

接下来，启动哨兵：

root@ymumu-server1:/usr/local/bin# redis-sentinel /home/redis-6.2.5/sentinel.conf

 2、python操作redis集群

首先需要安装：pip3 install redis-py-cluster

from rediscluster import RedisCluster

# python 操作redis集群
def cmd_cluster():
    try:
        startup_nodes = [
            {"host": "1.1.1.1", "port": 6379},
            {"host": "1.1.1.1", "port": 6380},
            {"host": "1.1.1.1", "port": 6381}
        ]

        # 连接redis集群
        redis_conn = RedisCluster(startup_nodes=startup_nodes, password='111111').connection

        if not redis_conn:
            print("连接redis集群失败")
            exit()
        else:
            print("连接redis集群成功")
    except Exception as e:
        print(e)
        print("错误,连接redis 集群失败")