Redis基础到进阶

技术2023-08-27 133

文章目录

1. Redis基本操作2. Redis主从复制3. Redis多实例配置4. Python连接Redis5. Python操作Redis6. pipline的使用7. Redis发布和订阅我的网站： https://pythoneers.cn

1. Redis基本操作

Redis的配置：

# 找到redis配置文件，然后修改这个配置文件 [root@master redis]# vim redis.conf protected-mode yes # 打开保护模式 port 6380 # 生产环境中端口不要使用默认的6379，使用其它端口，如6380等。 requirepass xxx # 找到requirepass，设置redis的启动密码，xxx是自定义的密码 bind 0.0.0.0 # 如果想让外部计算机也连接redis，可以设置绑定的ip。

设置好配置文件后要指定这个配置文件启动 redis：

[root@master redis]# redis-server redis.conf 27615:C 10 Oct 2019 08:39:39.974 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo 27615:C 10 Oct 2019 08:39:39.974 # Redis version=5.0.5, bits=64, commit=00000000, modified=0, pid=27615, just started 27615:C 10 Oct 2019 08:39:39.974 # Configuration loaded [root@master redis]# ps -ef |grep redis root 27616 1 0 08:39 ? 00:00:00 redis-server 0.0.0.0:6380 root 27659 26530 0 08:40 pts/0 00:00:00 grep --color=auto redis # 注意如果redis可以在多个端口开启多个进程，只需按不同的配置文件(配置不同的端口)启动即可 [root@master redis]# ps -ef |grep redis root 27616 1 0 08:39 ? 00:00:00 redis-server 0.0.0.0:6380 root 28016 1 0 08:46 ? 00:00:00 redis-server 0.0.0.0:6390 root 28029 26530 0 08:46 pts/0 00:00:00 grep --color=auto redis

如果你的 redis 在本地，使用客户端命令连接 redis 的时候，只需要指定端口。如果你的 redis 在服务器中，打开客户端的时候记得要指定端口指定主机地址：

thanlon@plus-book:~$ redis-cli -p 6380 -h 106.12.115.136 106.12.115.136:6380>

如果你开始操作数据库，这个时候 redis 会要求让你输入启动密码：

thanlon@plus-book:~$ redis-cli -p 6380 -h 106.12.115.136 106.12.115.136:6380> set username thanlon (error) NOAUTH Authentication required. 106.12.115.136:6380> auth redis # 密码错误 (error) ERR invalid password 106.12.115.136:6380> auth redis # 密码正确 OK # 也可以在连接redis服务端的时候指定redis启动密码，使用-a参数。但是，不建议，因为直接暴露了密码，redis也会提示你这样可能是不安全的。 thanlon@plus-book:~$ redis-cli -p 6380 -h 106.12.115.136 -a redis Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe. 106.12.115.136:6380>

关闭 redis 可以直接杀死进程，但这样可能会造成数据丢失。建议使用客户端发起关闭redis服务的，着属于正常关闭redis，可以数据的安全：

# 设置了启动密码，所以被拒绝关闭 thanlon@plus-book:~$ redis-cli -p 6380 -h 106.12.115.136 shutdown (error) NOAUTH Authentication required. # 我们带上密码来关闭，这样就成功关闭了 thanlon@plus-book:~$ redis-cli -p 6380 -h 106.12.115.136 -a redis shutdown Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe. thanlon@plus-book:~$ # 再到服务器确定关闭与否(redis已经被成功关闭) [root@master ~]# ps -ef |grep redis root 28786 28722 0 08:57 pts/1 00:00:00 grep --color=auto redis

2. Redis主从复制

Redis集群中数据库的复制是通过主从同步来实现的；主节点(Master)把数据分发给从节点(Slave)；主从同步的好处在于高可用，redis节点有冗余设计。

准备两台机器，我这里使用的是VMware虚拟化两台cetnos机器，ip分别是10.0.0.2和10.0.0.3，跟别作为主、从数据库。就使用这两台机器来做redis的主从同步。另外，为了方便使用，我使用XShell软件来连接我的这两台linux机器。

（1）准备两台机器都安装上安装Redis

（2）配置主(Master)数据库的配置文件

# 查看配置文件有用的信息行 [root@slave redis]# grep -v '#|^$' /usr/local/redis/redis.conf # 编辑配置文件 [root@master redis]# vim redis.conf # 修改下面几行为 bind 10.0.0.2 # 绑定本机的ip地址。外网情况下，不要绑定端口，直接bind 0.0.0.0 daemonize yes # 设置后台进程方式运行 requirepass redis # 为主redis设置密码 # 查看redis是否设置密码 10.0.0.2:6379> config get requirepass 1) "requirepass" # 关键字 2) "redis" # 密码 # 可以更改密码 10.0.0.2:6379> config set requirepass "redis" OK # 指定此配置文件启动redis [root@master redis]# redis-server redis.conf

（3）配置从(Slave)数据库的配置文件

# 查看配置文件有用的信息行 [root@slave redis]# grep -v '#|^$' /usr/local/redis/redis.conf # 编辑从数据库配置文件 [root@master redis]# vim redis.conf # 修改下面几行为 bind 10.0.0.3 # 绑定本机的ip地址。外网情况下，不要绑定端口，直接bind 0.0.0.0 replicaof 10.0.0.2 6379 # Master的ip和端口 masterauth redis # Master的密码 # 指定此配置文件启动redis [root@slave redis]# redis-server redis.conf

（4）主从同步的验证，主服务器的操作：

# 登录主redis [root@master redis]# redis-cli -h 10.0.0.2 # 输入主redis密码 10.0.0.2:6379> auth redis OK # 向主redis中添加数据 10.0.0.2:6379> set username thanlon OK # 查看主redis中的已经添加的数据 10.0.0.2:6379> keys * 1) "username"

从服务器的操作：

# 登录从redis [root@slave redis]# redis-cli -h 10.0.0.3 # 查看从redis的数据(从redis中一开始没有数据) 10.0.0.3:6379> keys * 1) "username" # 如果操作(例如删除)从主redis中同步的数据，就会提示数据是只读的 10.0.0.3:6379> del username (error) READONLY You can't write against a read only replica.

注意：如果两个redis链接不成功，要排查redis是不是同一个版本、是不是都是源码安装或yum安装的。

3. Redis多实例配置

Redis 支持多实例的用法，也就是一个服务器可以运行多个 Redis 服务端。我们这里把只用 Master 一台服务器就可以了。

# 查看redis下的文件(redis.conf是从源码包中拷贝过来的) [root@master redis]# ls bin dump.rdb redis.conf # 修改该配置文件 [root@master redis]# mv redis.conf redis-6379.conf # 将该配置文件备份(备份与否都可以，此步可忽略) [root@master redis]# cp redis-6379.conf redis-6379.conf.bak # 再复制一个redis-6379.conf并命名为redis-6380.conf作为另一个实例 [root@master redis]# cp redis-6379.conf redis-6380.conf # 修改redis-6379.conf配置文件中的参数 bind 10.0.0.2 port 6379 daemonize yes pidfile /var/run/redis_6379.pid # 修改redis-6380.conf配置文件中的参数 bind 10.0.0.2 port 6380 daemonize yes pidfile /var/run/redis_6380.pid # 查看redis的运行状态 [root@master redis]# ps -ef |grep redis root 6436 1 0 Oct09 ? 00:00:17 redis-server 10.0.0.2:6379 root 6485 1 0 00:55 ? 00:00:00 redis-server 10.0.0.2:6380 root 6498 6402 0 00:56 pts/1 00:00:00 grep --color=auto redis

上面的操作表示两个 Redis 实例的配置已经完成，下面我们将这两个实例做主从同步：

# 修改“从数据库”的配置文件redis_6379.conf [root@master redis]# vim redis-6379.conf # 找到replicaof参数修改如下，表示从10.0.0.2的6379端口同步 replicaof 10.0.0.2 6379 # 开始两个实例服务 [root@master redis]# redis-server redis-6379.conf [root@master redis]# redis-server redis-6380.conf # 客户端连接这两个端口的redis服务 [root@master redis]# redis-cli -p 6379 -h 10.0.0.2 [root@master redis]# redis-cli -p 6380 -h 10.0.0.2 # 6379端口所在的redis客户端进行添加数据操作 10.0.0.2:6379> set username thanlon OK # 查看6380端口所在的redis客户端的数据，至此配置成功 10.0.0.2:6380> keys * 1) "username"

4. Python连接Redis

第一种方式使用的是普通的连接：

# -*- coding: utf-8 -*- import redis conn = redis.Redis(host='106.12.115.133', port=6379,password='xxx') conn.set('name', 'kiku') print(conn.get('name'))

第二种方式使用的是连接池连接(与线程池是一样的，可以防止重复的连接节省开销，建议使用这种方式)：

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.133', port=6379, max_connections=1000,password='xxx') # max_connections最大连接数 conn = redis.Redis(connection_pool=pool) conn.set('name', 'thanlon')

5. Python操作Redis

① String操作，Redis 中的 String 在内存中按照一个 name 对应一个 value 来存储

（1）set(name, value, ex=None, px=None, nx=False, xx=False)：在redis中设置值，默认不存在则创建存在则修改

ex：过期时间(秒) px：过期时间(毫秒) nx：如果设置为True，只有name不存在时，当前set操作才执行(添加) xx：如果设置为True，只有name存在时，当前set才执行操作(修改) import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) print(conn.get('name')) # b'thanlon'

（2）setnx(name,value)：设置值，只有name不存在时，执行设置操作（3）setex(name,value,time)：设置值，time是过期时间(数字秒或timedelta对象) （4）psetex(name,time_ms,value)：设置值，time_ms是过期时间(数字秒或timedelta对象) （5）mset(*args,**keargs)：批量设置值，如：

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.mset({'name':'thanlon','age':23})

（6）get(name)：获取值（7）mget(keys,*args)：批量获取值，如：

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.mget('name', 'age')) # [b'thanlon', b'23'] print(conn.mget(['name', 'age'])) # 与上一行等价

（8）getset(name,value)：设置新值并获取原来的值

（9）getrange(key,start,end)：获取子序列（根据字节获取，非字符），start表示起始位置（字节）；end表示结束位置（字节)，Python2中代表的是字符。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.getrange('name', 0, 2)) # 三个字符：b'kik' conn.set('name', '奈何先生') print(conn.getrange('name', 0, 2)) # 以中文字节形式获取中文呢：b'\xe5\xa5\x88'

（10）setrange(name,offset,value)：修改字符串内容，从指定字符串索引开始后替换(新值太长时，则向后添加)。offset表示字符串索引，字节(一个汉字三个字节)；value是要设置的值。

（11）setbit(name,offset,value)：对name对应的值的二进制表示的位进行操作，修改二进制位。name是redis中的name，offseet是位的索引(将值变换成二进制后再进行索引)，value的值只能是1或0。

（12）getbit(name,offset)：获取name对应的值的二进制表示中的某位的值，可用来判断获取的是0还是1

（13）bitcount(key,start=None,end=None)：获取二进制数中有多少个1

（14）bitop(operation,dest,*keys)：获取多个值，并将值作做位运算，将最后的结果保存至新的name对应的值

参数： operation--------AND(并)，OR(或)，NOT(非)，XOR(异或) dest---------------新的redisd的name *keys------------- 要查找的redis的name 例如：获取n1,n2,n3对应的值，然后将所有的值做位运算(求并集)，然后将结果保存在new_name对应的值中 bitop('AND','new_name','n1','n2','n3')

（15）strlen(name)：返回name对应值的字节长度(一个汉字3个字节)

（16）incr(self,name,amount=1)：自增，name对应的值，当name不存在时，则创建name=amount，否则则自增。同incrby(self,name,amount=1)

（17）decr(self,name,amount=1)：自减，name对应的值，当name不存在时，则创建name=amount，否则则自减。同decrby(self,name,amount=1)。

（18）incrbyfloat(self,name,amount=1.0)：自增，只不过可以自增浮点数，如果amount的值是负的，则表示自减，注意没有decrbyfloat(self,name,amount=1.0)。

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.get('no')) # None conn.incrbyfloat('no') print(conn.get('no')) # b'1' conn.incrbyfloat('no', 0.1) print(conn.get('no')) # b'1.1'

（19）append(key,value)：在name对应的值后面追加内容

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.set('name', 'thanlon') print(conn.get('name')) # b'thanlon' conn.append('name', ' love kiku') print(conn.get('name')) # b'thanlon love kiku'

② hash操作 redis中的hash类型可以看成具有String key和String Value的map容器。所以，该类型非常适合于存储值对象的信息，如：username，password，age，sex等。我们可以使用redis的hash来存储session。

（1）hset(name,key,value)：name对应的hash中设置一个键值对，参数name是redis的name，key是name对应的hash中的key，value是name对应的hash中的value。hsetnx(name,key,value)表示当name对应的hash中不存在当前key时则创建(相当于添加)

# -*- coding: utf-8 -*- # -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) conn.hset('admin','name','thanlon') conn.hset('admin','age',23)

（2）hmset(name,mapping)：在name对应的hash中批量设置键值对

（3）hget(name,key)：在name对应的hash中获取key的值value

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.hset('admin','name','thanlon') conn.hset('admin','age',23) print(conn.hget('admin','name')) print(conn.hget('admin','age'))

（4）hmget(name,keys,*args)：在name对应hash中获取多个key的值value

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) conn.hmset('admin', {'name': 'thanlon', 'age': 23, 'sex': '男'}) print(conn.hmget('admin', 'name', 'age', 'sex')) # [b'thanlon', b'23', b'\xe7\x94\xb7']

（5）hgetall(name)：获取name对应的hash的所有键值，以字典类型返回

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) print(conn.hgetall('admin')) # {b'name': b'thanlon', b'age': b'23', b'sex': b'\xe7\x94\xb7'}

（6）hlen(name)：获取name对应的hash中键值对的个数

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) print(conn.hlen('admin')) # 3

（7）hkeys(name)：获取name对应的hash中所有key的值，列表形式返回

（8）hvals(name)：获取name对应的hash中所有value值

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) print(conn.hvals('admin'))#[b'thanlon', b'23', b'\xe7\x94\xb7']

（9）hexits(name,key)：检查name对应的hash是否存在当前输入的key

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) print(conn.hexists('admin', 'age')) # True

（10）hdel(name,*keys)：将name对应的hash中的指定key的键值对删除

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) print(conn.hdel('admin', 'sex', 'age')) # 2

（11）hincrby(name,key,amount=1)：自增name对应的hash值中的指定key值，不存在则创建key=mount

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) conn.hincrby('admin',1,amount=2) print(conn.hget('admin', 1)) # b'2'

（12）hincrbyfloat(name,key,amount=1.0)：

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) conn.hincrbyfloat('admin', 2, amount=0.1) print(conn.hget('admin', 2)) # b'1.1'

（13）hscan(name,cursor=0,match=None,count=None)：增量式迭代获取，对于数据大的数据非常有用。hscan可以实现分片地获取数据，并非一次性将数据全部获取完放置内存被撑爆。name是redis中的name，cursor是游标(基于游标分批获取数据)，match是匹配指定的key，默认None，表示所有key，count是每次分片最少获取的个数，默认是None表示采用redis的默认分片个数。如：

# 第一次： cursor1,data1 = conn.hscan('xxx',cursor=0,match=None,count=None) # 第二次： cursor2,data2 = conn.hscan('xxx',cursor=cursor1,match=None,count=None) …… 直到返回值cursor的值为0时，表示数据已经通过分片获取完毕。

（14）hscan_iter(name,match=None,count=None)：利用yield封装hscan创建生成器，实现分批去redis中获取数据

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.101', port=6379, password='xxx') conn = redis.Redis(connection_pool=pool) for item in conn.hscan_iter('admin'): print(item) # (b'name', b'thanlon') # (b'sex', b'man') # (b'age', b'23')

③ List操作

（1） lpush(name,values)：在name对应的list中添加元素，每个新的元素添加到列表的最左边

（2）lpushx(name,value)：在name对应的list中添加元素，只有name存在时，值添加到列表的最左边

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.lpushx('names', '奈何先生')

（3）llen(name)：name对应的list元素的个数

（4）linsert(name,where,refvalue,value)：在name对应的列表的某一个值前或后插入一个新值。where只能写两个值一个是BEFORE，一个是AFTER。refvalue是标杆值，即：在它的前后插入数据，value是要插入的数据。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.lrange('names', 0, -1)) # [b'kiku', b'thanlon'] conn.linsert('names', 'after', 'thanlon', 'john') conn.linsert('names', 'before', 'thanlon', 'Tom') print(conn.lrange('names', 0, -1)) # [b'kiku',b'Tom', b'thanlon', b'john']

（5）lset(name,index,value)：对name对应的list中某一个索引位置重新赋值，index是list的索引位置，value是要设置的值。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.lrange('names', 0, -1)) # [b'kiku', b'thanlon'] conn.lset('names', 0, 'Tom') print(conn.lrange('names', 0, -1)) # [b'Tom', b'john']

（6）lrem(name,count,value)：在name对应的list中删除指定的值，count=0表示删除列表中所有指定的值，count=2表示从前到后删除2个，count=-2表示从后向前删除2个。

# -*- coding: utf-8 -*- # 删除所有指定的“Tom” import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.lrange('names', 0, -1)) # [b'Tom', b'Tom', b'Thanlon', b'kiku', b'john'] conn.lrem('names', 0, 'Tom') # 删除所有的Tom print(conn.lrange('names', 0, -1)) # [b'Thanlon', b'kiku', b'john'] # 从前到后删除2个“Tom” # -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.lrange('names', 0, -1)) # [b'Tom', b'Tom', b'Thanlon', b'kiku', b'john', b'Tom'] conn.lrem('names', 2, 'Tom') print(conn.lrange('names', 0, -1)) # [b'Thanlon', b'kiku', b'john', b'Tom']

（7）lpop(name)：在name对应的列表的最左侧获取第一个元素并删除，返回值则是第一个元素。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.lpop('names')) # b'kiku'

（8）lindex(name,index)：在name对应的列表中根据索引获取列表中的元素

（9）lrange(name,start,end)：在name对应的列表分片获取数据。

（10）ltrim(name,start,end)：在name对应的列表中移除没有在start～end索引之间的值。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.lrange('names', 0, -1)) # [b'Thanlon', b'kiku', b'john', b'Tom'] conn.ltrim('names', 0, 1) # 0～1 print(conn.lrange('names', 0, -1)) # [b'Thanlon', b'kiku']

（11）rpoplpush(src,dst)：从一个列表取出最右边的元素，同时将其添加至另外一个列表的最左边，src是要取数据的列表的name，dst是要添加数据列表name。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.lpush('developers', 'Thanlon') conn.lpush('developers', 'Kiku') conn.lpush('masters', 'John') conn.lpush('masters', 'Maria') print(conn.lrange('developers', 0, -1)) # [b'Kiku', b'Thanlon'] print(conn.lrange('masters', 0, -1)) # [ b'Maria', b'John'] conn.rpoplpush('developers', 'masters') # 将developers列表中的最右边元素添加到masters列表中元素的最左边 print(conn.lrange('developers', 0, -1)) # [b'Kiku'] print(conn.lrange('masters', 0, -1)) # [b'Thanlon', b'Maria', b'John']

（12）blpop(keys,timeout)：将多个值进行排列，按照从左到右去pop对应列表的元素。timeout是超时时间，当元素所有列表的数据获取完后，阻塞等待列表内有数据的时间(秒)，0表示永远阻塞。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.lpush('names', 'Thanlon') conn.lpush('names', 'Kiku') conn.lpush('names', 'John') conn.lpush('names', 'Maria') print(conn.lrange('names', 0, -1)) # [b'Maria', b'John', b'Kiku', b'Thanlon'] print(conn.blpop('names')) # (b'names', b'Maria') print(conn.lrange('names', 0, -1)) # [b'John', b'Kiku', b'Thanlon'] print(conn.blpop('names')) # (b'names', b'John') print(conn.lrange('names', 0, -1)) # [b'Kiku', b'Thanlon']

（13）brpoplpush(src,dst,timeout=0)：从一个列表取出最右边的元素，同时将其添加至另外一个列表的最左边。前面有介绍rpoplpush方法，这里只是可以添加超时时间。

（14）自定义增量迭代：**由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，就需要获取name对应的列表，然后循环列表。但是如果列表非常大，就有可能在获取name对应的列表时撑爆内存，所以，有必要自定义增量迭代功能。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) def list_iter(name): list_count = conn.llen(name) for index in range(0, list_count): yield conn.lindex(name, index) for item in list_iter('names'): print(item) # b'Kiku' # b'Thanlon'

④ Set操作：Set集合不允许重复的列表

（1）sadd(name,values)：对name对应的集合添加元素

（2）scard(name)：获取name对应集合中的元素个数

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.scard('employees'))

（3）sadiff(keys,*args)：在第一个name对应的集合中且不在其它name对应的集合中的元素集合

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) # employees：kiku,thanlon # bosses：Tom,John print(conn.sdiff('employees', 'bosses')) # {b'kiku', b'thanlon'}

（4）sdiffstore(dest,keys,*args)：获取在第一个name对应的集合中且不在其它name对应的集合中的元素集合，再将其新加入到dest对应的集合中。

（5）sinter(keys,*args)：获取多个name对应集合的交集。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.smembers('employees')) # {b'Kiku', b'Tom'} print(conn.smembers('bosses')) # {b'John', b'Thanlon', b'Tom'} print(conn.sinter('employees', 'bosses')) # {b'Tom'}

（6）sinterstore(dest,keys,*args)：获取多一个name对应集合的交集，再将其加入到dest对应的集合中

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.smembers('employees')) # {b'Kiku', b'Tom'} print(conn.smembers('bosses')) # {b'John', b'Thanlon', b'Tom'} conn.sinterstore('dest', 'employees', 'bosses') print(conn.smembers('dest')) # {b'Tom'}

（7）sismember(name,value)：检查value是否是name对应的集合成员。

（8）smembers(name)：获取name对应集合的所有成员。

（9）smove(src,dst,value)：把某一个成员从一个集合(src)中移到另外一个集合(dst)中。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.smembers('employees')) # {b'Thanlon', b'Kiku'} print(conn.smembers('bosses')) # {b'John', b'Tom'} conn.smove('employees', 'bosses', 'Thanlon') print(conn.smembers('employees')) # {b'Thanlon', b'Kiku'} print(conn.smembers('bosses')) # {b'John', b'Tom'}

（10）spop(name)：从集合的右侧(尾部)移除一个成员，并将其返回

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.smembers('bosses')) # {b'John', b'Thanlon', b'Tom'} print(conn.spop('bosses')) # b'Thanlon' print(conn.smembers('bosses')) # {b'Tom', b'John'}

（11）srandmember(name,number)：从name对应的集合中随机获取numbers个元素

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) # 如果nmber没有指定则默认是1 print(conn.srandmember('employees')) # b'Kiku' print(conn.srandmember('employees', number=2)) # [b'Kiku', b'Tom']

（12）srem(name,values)：在name 对应的集合中删除某些值

（13）sunion(keys,*args)：获取多个name对应集合的并集

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.smembers('employees')) # {b'Kiku', b'Tom'} print(conn.smembers('bosses')) # {b'John', b'Tom'} print(conn.sunion('employees', 'bosses')) # {b'Kiku', b'John', b'Tom'}

（14）sunionstore(dest,keys,*args)：获取多个name对应集合的并集，并将结果保存到dest对应的集合中

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.smembers('employees')) # {b'Kiku', b'Tom'} print(conn.smembers('bosses')) # {b'John', b'Tom'} print(conn.sunionstore('dest', 'employees', 'bosses')) print(conn.smembers('dest')) # {b'Kiku', b'John', b'Tom'}

（15）sscan(name,cursor=0,match=None,count=None)：同字符串操作，用于迭代分批获取数据，避免内存消耗太大。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) # 第一次： cursor1, data1 = conn.sscan('employees', cursor=0, match=None, count=1) print(data1) # [b'Thanlon'] # 第二次： cursor2, data2 = conn.sscan('employees', cursor=cursor1, match=None, count=2) print(data2) # [b'John', b'Kiku', b'Tom', b'Maria']

（16）sscan_iter(name,match=None,count=None)：同字符串操作，用于迭代分批获取数据，避免内存消耗太大

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) for item in conn.sscan_iter('employees', match=None, count=None): print(item) # b'Thanlon' # b'John' # b'Kiku' # b'Tom' # b'Maria'

⑤ 有序集合：在集合的基础上，为每个元素排序。元素的排序需要根据另外一个值来进行比较，所以对于有序集合，每个元素有两个值，即值和分数，分数专门用来做排序。

（1）zdd(name,mapping,nx,xx,ch,incr)：在name对应的有序集合中添加元素(有两种方式)

（2）zcard(name)：获取name对应的有序集合元素的数量

（3）zcount(name,min,max)：获取name对应的有序集合中分数在[min,max]之间的数

（4）zincrby(name,amount,value)：自增name对应的有序集合的name对应的分数

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.zrange('zset1', 0, -1)) # [b'Tom', b'thanlon', b'kiku'] conn.zincrby('zset1', 10, 'thanlon') print(conn.zrange('zset1', 0, -1)) # [b'Tom', b'kiku', b'thanlon']

（5）zrange(name,start,end,desc=False,withscores=False,score_cast_func=float)：按照索引获取name对应的有序集合的元素。参数：start是有序集合索引起始位置；end是有序集合索引结束位置；desc是排序规则，默认按照从小到大排序；withscores是是否获取元素的分数，默认是获取元素的值；score_cast_func是对分数进行数据转换的函数。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.zadd('name', {'Thanlon': 1, 'Kiku': 2, 'Tom': 0, 'Maria': -2}) print(conn.zrange('name', 0, 0)) # [b'Maria'] print(conn.zrange('name', 0, 0, desc=True)) # [b'Kiku'] print(conn.zrange('name', 0, 1)) # [b'Maria', b'Tom']， 0, 1只决定取的数量，不表示分数范围

（6）zrank(name,value)：获取值在name对应的有序集合中的排行(从0开始)

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.zadd('name', {'Thanlon': 1, 'Kiku': 2, 'Tom': 0, 'Maria': -2}) print(conn.zrange('name', 0, -1)) # [b'Maria', b'Tom', b'Thanlon', b'Kiku'] print(conn.zrank('name', 'Thanlon')) # 2，表示排第三位(是从0开始的)

（7）zrangebylex(self, name, min, max, start=None, num=None)：当有序集合的所有成员都具有相同的分数，有序集合的元素会根据成员的值来进行排序。对集合中的每个成员进行逐个字节的对比，并按照从低到高的顺序，返回排序后的集合成员。min是左区间，+和-分别表示正无限和负无限，(或者表示开区间，[表示闭区间；max是右区间的值；start是对结果进行分片处理的索引位置，num是对结果进行分片处理，索引后面有num个元素。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.zadd('students', {'Thanlon': 100, 'Kiku': 100, 'Maria': 100}) # # 字节转换成数字来一个一个比较 print(conn.zrange('students', 0, -1)) # [b'Kiku', b'Maria', b'Thanlon'] ret = conn.zrangebylex('students', '-', '[Maria') # [b'Kiku', b'Maria'] ret2 = conn.zrangebylex('students', '-', '(Maria')# [b'Kiku'] print(ret) print(ret2)

（8）zrem(self, name, *values)：删除name对应的有序集合值是value的成员

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.zadd('students', {'Thanlon': 100, 'Kiku': 100, 'Maria': 100}) print(conn.zrange('students', 0, -1)) # [b'Kiku', b'Maria', b'Thanlon'] conn.zrem('students', 'Thanlon') # 删除name对应有序集合中的Thanlon print(conn.zrange('students', 0, -1)) # [b'Kiku', b'Maria']

（9）zremrangebyrank(name,min,max)：根据排行来删除

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.zadd('students', {'Thanlon': 0, 'Kiku': 1, 'Maria': 2}) print(conn.zrange('students', 0, -1)) # [b'Kiku', b'Maria', b'Thanlon'] conn.zremrangebyrank('students', 0, 1) # 删除排名在第一名到第二名 print(conn.zrange('students', 0, -1)) # [b'Maria']

（10）zremrangebyscore(name, min, max)：根据分数范围删除有序集合中的元素加

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.zadd('students', {'Thanlon': 59, 'Kiku': 100, 'Maria': 100}) print(conn.zrange('students', 0, -1)) # [b'Kiku', b'Maria', b'Thanlon'] # 根据分数来删除有序集合里面的值，这里删除的是分数在0～59之间的，只有Thanlon是满足加的，所以删除它 conn.zremrangebyscore('students', 0, 59) print(conn.zrange('students', 0, -1)) # [b'Kiku', b'Maria']

（11）zremrangebylex(name, min, max)：根据指定的范围的值删除

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.zadd('students', {'Thanlon': 100, 'Kiku': 100, 'Maria': 100}) # # 字节转换成数字来一个一个比较 print(conn.zrange('students', 0, -1, withscores=True)) # [(b'Kiku', 100.0), (b'Maria', 100.0), (b'Thanlon', 100.0)] conn.zremrangebylex('students', '-', '[Maria') print(conn.zrange('students', 0, -1, withscores=True)) # [(b'Thanlon', 100.0)]

（12）zscore(name, value)：根据name对应有序集合中的value对应的分数

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.zscore('students', 'Maria')) # 100.0 zinterstore(self, dest, keys, aggregate=None)：获取两个有序集合的交集，如果遇到相同的值不同的分数，则按照aggregate进行操作，aggregate的值有SUM 、MIN和MAX，默认是SUM。使用小写sum也对，不区分大小。 # -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.zrange('bosses', 0, -1, withscores=True)) # [(b'Jack', 1.0), (b'Thanlon', 4.0)] print(conn.zrange('employees', 0, -1, withscores=True)) # [(b'thanlon', 0.0), (b'Jack', 2.0)] conn.zinterstore('dest', ['bosses', 'employees']) print(conn.zrange('dest', 0, -1, withscores=True)) # [(b'Jack', 3.0)]

（13）zunionstore( dest, keys, aggregate=None)：获取两个有序集合的并集，如果遇到相同的值不同的分数，则按照aggregate进行操作，aggregate的值有SUM 、MIN和MAX

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.zrange('bosses', 0, -1, withscores=True)) # [(b'Jack', 1.0), (b'Thanlon', 4.0)] print(conn.zrange('employees', 0, -1, withscores=True)) # [(b'thanlon', 0.0), (b'Jack', 2.0)] conn.zunionstore('dest', ['bosses', 'employees']) print(conn.zrange('dest', 0, -1, withscores=True)) # [(b'thanlon', 0.0), (b'Jack', 3.0), (b'Thanlon', 4.0)]

（14）zscan(name, cursor=0, match=None, count=None,score_cast_func=float)：

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.zadd('students', {'Thanlon': 59, 'Kiku': 100, 'Maria': 100}) cursor1, data1 = conn.zscan('students', cursor=0, match=None, count=None, score_cast_func=float) print(data1) # [(b'Thanlon', 59.0), (b'Kiku', 100.0), (b'Maria', 100.0)]

（15）scan_iter(name, match=None, count=None,score_cast_func=float)：

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.zadd('students', {'Thanlon': 59, 'Kiku': 100, 'Maria': 100}) for item in conn.zscan_iter('students', score_cast_func=float): print(item) # (b'Thanlon', 59.0) # (b'Kiku', 100.0) # (b'Maria', 100.0)

⑥ 其它常用操作

（1）delete(*names)：删除redis任意一种数据类型

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.delete('teachers')

（2）exists(*names)：检查redis中的name是否存在

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.exists('students')) # 1表示存在

（3）keys(pattern=’*’)：默认是所有的keys

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.keys()) # [b'bosses', b'dest_tmp', b'students'] print(conn.keys('bo?ses')) # [b'bosses'] print(conn.keys('b*s')) # [b'bosses'] print(conn.keys('b[ao]sses')) # [b'bosses']，要么匹配bosses，否则匹配basses

（4）expire(name, time)：为某个redis的name设置超时时间，redis中设置超时时间的粒度比较小，只能对name对应的数据的整体做超时时间。比如，hash中一个name对应多个key-value，我们只能对这多个key-value整体设置超时时间，不可以对key-value做超时时间。

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) conn.expire('students', time=100) # 超时时间必须是integer类型的

（5）rename(src, dst)：

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.keys()) # [b'employees', b'dest_tmp'] conn.rename('employees', 'bosses') print(conn.keys()) # [b'bosses', b'dest_tmp']

（6）move(name, db)：

（7）randomkey()：随机获取redis中的name

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.randomkey())#b'dest_tmp'

（8）type(name)：获取redis中name的数据类型

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.type('dest_tmp')) # b'set'

（9）scan(cursor=0, match=None, count=None)：

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) print(conn.scan()) # (0, [b'dest_tmp'])

（10）scan_iter(match=None, count=None):

import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) for item in conn.scan_iter(): print(item) # b'dest_tmp'

6. pipline的使用

管道是用来做事务的，python连接redis在执行每次请求都会创建(连接池申请连接)和断开(归还连接池)一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline是原子性操作。

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) pipe = conn.pipeline(transaction=True) pipe.set('name', 'thanlon') pipe.set('name', 'kiku') pipe.execute() # 整体提交，如果一条发生错误，整个就不会生效

7. Redis发布和订阅

发布者：

接收者1：

# -*- coding: utf-8 -*- import redis pool = redis.ConnectionPool(host='106.12.115.136', port=6390, password='redis6390') conn = redis.Redis(connection_pool=pool) pb = conn.pubsub() pb.subscribe('news') while True: print(pb.parse_response()) # [b'message', b'news', b'Pay Attention To!']

接收者2：

分享一个好用的Python学习网站：https://pythoneers.cn/

Processed: 0.010, SQL: 9