Redis06_python操作redis

本章节出处：https://www.jianshu.com/p/2639549bedc8
我将他的每处地方都实现过一遍

redis连接

redis提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。

redis连接实例是线程安全的，可以直接将redis连接实例设置为一个全局变量，直接使用。如果需要另一个Redis实例（or Redis数据库）时，就需要重新创建redis连接实例来获取一个新的连接。同理，python的redis没有实现select命令。

安装redis

pip install redis

连接redis，加上decode_responses=True，写入的键值对中的value为str类型，不加这个参数写入的则为字节类型。

import redis  # 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库

# host是redis主机，需要redis服务端和客户端都启动 redis默认端口是6379
r = redis.Redis(host='192.168.1.101', port=6379, decode_responses=True)
# print(r.ping) # 测试连通性的函数
# key是"foo" value是"bar" 将键值对存入redis缓存
r.set('name', 'yaowy')
print(r['name'])
print(r.get('name')) # 取出键name对应的值
print(type(r.get('name')))

打印结果

yaowy
yaowy
<class 'str'>

连接池

redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。
可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池

连接池

import redis

pool = redis.ConnectionPool(host='192.168.1.101',
                            port=6379,
                            decode_responses=True)
r = redis.Redis(connection_pool=pool)
# print(r.ping)
r.set('gender','male')
print(r.get('gender'))

redis基本命令 String

set(name, value, ex=None, px=None, nx=False, xx=False)

在Redis中设置值，默认，不存在则创建，存在则修改
参数：
ex，过期时间（秒）
px，过期时间（毫秒）
nx，如果设置为True，则只有name不存在时，当前set操作才执行
xx，如果设置为True，则只有name存在时，当前set操作才执行

1.ex，过期时间（秒） 这里过期时间是3秒，3秒后p，键food的值就变成None

# print(r.ping)
r.set('food', 'mutton', ex=3)    # key是"food" value是"mutton" 将键值对存入redis缓存
print(r.get('food'))  # mutton 取出键food对应的值

time.sleep(4)
print(r.get('food'))  # mutton 取出键food对应的值

# 输出
mutton
None

2.px，过期时间（豪秒） 这里过期时间是3豪秒，3毫秒后，键foo的值就变成None

# print(r.ping)
r.set('food', 'mutton', px=3)    # key是"food" value是"mutton" 将键值对存入redis缓存
print(r.get('food'))  # mutton 取出键food对应的值

time.sleep(1)
print(r.get('food'))  # mutton 取出键food对应的值

# 输出
mutton
None

3.nx，如果设置为True，则只有name不存在时，当前set操作才执行 （新建）

print(r.set('name','yaowy',nx=True)) # name存在
print(r.set('hobby','read',nx=True)) # hobby不存在

# 输出
None
True

4.xx，如果设置为True，则只有name存在时，当前set操作才执行 （修改）

print(r.set('name', 'yaowy', xx=True))  # name存在
print(r.set('age', '26', xx=True))  # hobby不存在

# 输出
True
None

5.setnx(name, value)
设置值，只有name不存在时，执行设置操作（添加）

print(r.setnx('fruit','banana')) # 不存在
print(r.setnx('name','yaowy001')) # 存在

# 输出
True
False

6.setex(name, time, value)
设置值
参数：
time，过期时间（数字秒 或 timedelta对象）

r.setex("fruit2",3,"orange")
print(r.get("fruit2"))
time.sleep(4)
print(r.get("fruit2"))


# 输出
orange
None

7.psetex(name, time_ms, value)
设置值
参数：
time_ms，过期时间（数字毫秒 或 timedelta对象）

r.psetex("fruit3", 5000, "apple")
print(r.get('fruit3'))
time.sleep(5)
print(r.get('fruit3'))  # 5000毫秒后，取值就从apple变成None

# 输出
apple
None

8.mset(*args, **kwargs)
批量设置值
如：

r.mset({'k1': 'v1', 'k2': 'v2'})
print(r.mget("k1", "k2"))   # 一次取出多个键对应的值
print(r.mget("k1"))

# 输出
['v1', 'v2']
['v1']

9.getset(name, value)
设置新值并获取原来的值

print(r.get("name"))
print(r.getset("name", "ljt"))  # 设置的新值是barbecue 设置前的值是beef
print(r.get("name"))

# 输出
yaowy
yaowy
ljt

10.getrange(key, start, end)
获取子序列（根据字节获取，非字符）
参数：
name，Redis 的 name
start，起始位置（字节）
end，结束位置（字节）
如： "斯达迪派森" ，0-3表示 "斯"

print(r.set('name','斯达迪派森'))
print(r.getrange("name", 0, 2))   # 取索引号是0-2 前3位的字节 斯 切片操作 （一个汉字3个字节 1个字母一个字节 每个字节8bit）
print(r.getrange("name", 0, -1))  # 取所有的字节 斯达迪派森 切片操作
r.set("name","studey python") # 字母
print(r.getrange("name", 0, 2))  # 取索引号是0-2 前3位的字节 stu 切片操作 （一个汉字3个字节 1个字母一个字节 每个字节8bit）
print(r.getrange("name", 0, -1)) # 取所有的字节 studey python 切片操作

# 输出
True
斯
斯达迪派森
stu
studey python

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

print(r.set('name', '斯达迪派森'))
print(r.setrange("name", 0, '爪哇岛'))  #从0开始替换
print(r.get('name'))

# 输出
True
15
爪哇岛派森

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

print(r.set('name', '斯达迪派森'))
print(r.strlen('name'))

# 输出
True
15

13.incr(self, name, amount=1)
自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
参数：
name,Redis的name
amount,自增数（必须是整数）
注：同incrby

r.set('index',10)
r.incr('index')
print(r.get('index'))

# 输出
11

应用场景 – 页面点击数
假定我们对一系列页面需要记录点击次数。例如论坛的每个帖子都要记录点击次数，而点击次数比回帖的次数的多得多。如果使用关系数据库来存储点击，可能存在大量的行级锁争用。所以，点击数的增加使用redis的INCR命令最好不过了。
当redis服务器启动时，可以从关系数据库读入点击数的初始值（12306这个页面被访问了34634次）

r.set("visit:12306:totals", 34634)
print(r.get("visit:12306:totals"))

每当有一个页面点击，则使用INCR增加点击数即可。

r.incr("visit:12306:totals")
r.incr("visit:12306:totals")

页面载入的时候则可直接获取这个值

print(r.get("visit:12306:totals"))

14.incrbyfloat(self, name, amount=1.0)
自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
参数：
name,Redis的name
amount,自增数（浮点型）

r.set('index_float','10.2')
r.incrbyfloat('index_float',amount=1.2)
print(r.get('index_float'))

# 输出
11.4

15.decr(self, name, amount=1)
自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
参数：
name,Redis的name
amount,自减数（整数)

r.set('index',10)
r.decr('index')
print(r.get('index'))

# 输出
9

16.append(key, value)
在redis name对应的值后面追加内容
参数：
key, redis的name
value, 要追加的字符串

r.set('name','斯达迪派森')
r.append('name','斯达迪爪哇')
print(r.get('name'))

# 输出
斯达迪派森斯达迪爪哇

redis基本命令 hash

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时则创建（相当于添加）

r.hset("hash1", "k1", "v1")
r.hset("hash1", "k2", "v2")
print(r.hkeys("hash1")) # 取hash中所有的key
print(r.hget("hash1", "k1"))    # 单个取hash的key对应的值
print(r.hmget("hash1", "k1", "k2")) # 多个取hash的key对应的值
r.hsetnx("hash1", "k2", "v3") # 只能新建
print(r.hget("hash1", "k2"))

# 输出
['k1', 'k2']
v1
['v1', 'v2']
v2

2 批量增加（取出）
hmset(name, mapping)
在name对应的hash中批量设置键值对
参数：
name，redis的name
mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
如：

r.hmset("hash2", {"k2": "v2", "k3": "v3"})

hget(name,key)
在name对应的hash中获取根据key获取value
hmget(name, keys, *args)
在name对应的hash中获取多个key的值
参数：
name，reids对应的name
keys，要获取key集合，如：['k1', 'k2', 'k3']
*args，要获取的key，如：k1,k2,k3
如：

r.hmset("hash2", {"k2": "v2", "k3": "v3"})
print(r.hget("hash2", "k2"))  # 单个取出"hash2"的key-k2对应的value
print(r.hmget("hash2", "k2", "k3"))  # 批量取出"hash2"的key-k2 k3对应的value --方式1
print(r.hmget("hash2", ["k2", "k3"]))  # 批量取出"hash2"的key-k2 k3对应的value --方式2

# 输出
v2
['v2', 'v3']
['v2', 'v3']

3.取出所有的键值对
hgetall(name)
获取name对应hash的所有键值

print(r.hgetall("hash1"))

# 输出
{'k1': 'v1', 'k2': 'v2'}

4.得到所有键值对的格式 hash长度
hlen(name)
获取name对应的hash中键值对的个数

print(r.hlen("hash1"))

# 输出
2

5.得到所有的keys（类似字典的取所有keys）
hkeys(name)
获取name对应的hash中所有的key的值

print(r.hkeys("hash1"))

# 输出
['k1', 'k2']

6.得到所有的value（类似字典的取所有value）
hvals(name)
获取name对应的hash中所有的value的值

print(r.hvals("hash1"))

# 输出
['v1', 'v2']

7.判断成员是否存在（类似字典的in）
hexists(name, key)
检查name对应的hash是否存在当前传入的key

print(r.hexists("hash1", "k4"))  # False 不存在
print(r.hexists("hash1", "k1"))  # True 存在

# 输出
False
True

8.删除键值对
hdel(name,*keys)
将name对应的hash中指定key的键值对删除

print(r.hgetall("hash1"))
r.hset("hash1", "k2", "v222")   # 修改已有的key k2
r.hset("hash1", "k11", "v1")   # 新增键值对 k11
r.hdel("hash1", "k1")    # 删除一个键值对
print(r.hgetall("hash1"))

# 输出
{'k1': 'v1', 'k2': 'v2'}
{'k2': 'v222', 'k11': 'v1'}

9.自增自减整数(将key对应的value--整数 自增1或者2，或者别的整数 负数就是自减)
hincrby(name, key, amount=1)
自增name对应的hash中的指定key的值，不存在则创建key=amount
参数：
name，redis中的name
key， hash对应的key
amount，自增数（整数）

r.hset("hash1", "k3", 123)
r.hincrby("hash1", "k3", amount=-1)
print(r.hgetall("hash1"))
r.hincrby("hash1", "k4", amount=1)  # 不存在的话，value默认就是1
print(r.hgetall("hash1"))

# 输出
{'k2': 'v222', 'k11': 'v1', 'k3': '122'}
{'k2': 'v222', 'k11': 'v1', 'k3': '122', 'k4': '1'}

10.自增自减浮点数(将key对应的value--浮点数 自增1.0或者2.0，或者别的浮点数 负数就是自减)
hincrbyfloat(name, key, amount=1.0)
自增name对应的hash中的指定key的值，不存在则创建key=amount
参数：
name，redis中的name
key， hash对应的key
amount，自增数（浮点数）
自增name对应的hash中的指定key的值，不存在则创建key=amount

r.hset("hash1", "k5", "1.0")
r.hincrbyfloat("hash1", "k5", amount=-1.0)    # 已经存在，递减-1.0
print(r.hgetall("hash1"))
r.hincrbyfloat("hash1", "k6", amount=-1.0)    # 不存在，value初始值是-1.0 每次递减1.0
print(r.hgetall("hash1"))

# 输出
{'k2': 'v222', 'k11': 'v1', 'k3': '122', 'k4': '1', 'k5': '0'}
{'k2': 'v222', 'k11': 'v1', 'k3': '122', 'k4': '1', 'k5': '0', 'k6': '-1'}

redis基本命令 list

1.增加（类似于list的append，只是这里是从左边新增加）--没有就新建
lpush(name,values)
在name对应的list中添加元素，每个新的元素都添加到列表的最左边
如：

r.lpush("list1", 11, 22, 33)
print(r.lrange('list1', 0, -1))

# 输出
['33', '22', '11']

保存顺序为: 33,22,11

扩展：

r.rpush("list2", 11, 22, 33)  # 表示从右向左操作
print(r.llen("list2"))  # 列表长度
print(r.lrange("list2", 0, 3))  # 切片取出值，范围是索引号0-3

# 输出
['11', '22', '33']

2.往已经有的name的列表的左边添加元素，没有的话无法创建
lpushx(name,value)
在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
更多：

r.lpushx("list10", 10)   # 这里list10不存在
print(r.llen("list10"))  # 0
print(r.lrange("list10", 0, -1))  # []

r.lpushx("list2", 77)   # 这里"list2"之前已经存在，往列表最左边添加一个元素，一次只能添加一个
print(r.llen("list2"))  # 列表长度
print(r.lrange("list2", 0, -1)) # 切片取出值，范围是索引号0到-1(最后一个元素

# 输出
0
[]
4
['77', '11', '22', '33']

3.往已经有的name的列表的右边添加元素，没有的话无法创建

r.rpushx("list2", 99)   # 这里"foo_list1"之前已经存在，往列表最右边添加一个元素，一次只能添加一个
print(r.llen("list2"))  # 列表长度
print(r.lrange("list2", 0, -1)) # 切片取出值，范围是索引号0到-1(最后一个元素)

# 输出
5
['77', '11', '22', '33', '99']

4.新增（固定索引号位置插入元素）
linsert(name, where, refvalue, value))
在name对应的列表的某一个值前或后插入一个新值
参数：
name，redis的name
where，BEFORE或AFTER
refvalue，标杆值，即：在它前后插入数据
value，要插入的数据

r.linsert("list2", "before", "11", "00")   # 往列表中左边第一个出现的元素"11"前插入元素"00"
print(r.lrange("list2", 0, -1))   # 切片取出值，范围是索引号0-最后一个元素

# 输出
['77', '00', '11', '22', '33', '99']

5.修改（指定索引号进行修改）
r.lset(name, index, value)
对name对应的list中的某一个索引位置重新赋值
参数：
name，redis的name
index，list的索引位置
value，要设置的值

r.lset("list2", 0, -11)    # 把索引号是0的元素修改成-11
print(r.lrange("list2", 0, -1))

# 输出
['-11', '00', '11', '22', '33', '99']

6.删除（指定值进行删除）
r.lrem(name, value, num)
在name对应的list中删除指定的值
参数：
name，redis的name
value，要删除的值
num， num=0，删除列表中所有的指定值；
num=2,从前到后，删除2个； num=1,从前到后，删除左边第1个
num=-2,从后向前，删除2个

r.lrem("list2", 1, "11")    # 将列表中左边第一次出现的"11"删除
print(r.lrange("list2", 0, -1))
r.lrem("list2", -1, "99")    # 将列表中右边第一次出现的"99"删除
print(r.lrange("list2", 0, -1))
r.lrem("list2", 0, "22")    # 将列表中所有的"22"删除
print(r.lrange("list2", 0, -1))

# 输出
['-11', '00', '22', '33', '99']
['-11', '00', '22', '33']
['-11', '00', '33']

注意：原博客这里错误

7.删除并返回
lpop(name)
在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
更多：
rpop(name) 表示从右向左操作

print(r.lrange("list2", 0, -1))
r.lpop("list2")    # 删除列表最左边的元素，并且返回删除的元素
print(r.lrange("list2", 0, -1))
r.rpop("list2")    # 删除列表最右边的元素，并且返回删除的元素
print(r.lrange("list2", 0, -1))

# 输出
['-11', '00', '33']
['00', '33']
['00']

8.删除索引之外的值
ltrim(name, start, end)
在name对应的列表中移除没有在start-end索引之间的值
参数：
name，redis的name
start，索引的起始位置
end，索引结束位置

r.rpush('list2',11,22,33,44,55,66,77) # 前面的操作把list2删干净了，先塞点进去
print(r.lrange("list2", 0, -1))
r.ltrim('list2',0,3)
print(r.lrange("list2", 0, -1))

# 输出
['00', '11', '22', '33', '44', '55', '66', '77']
['00', '11', '22', '33']

9.取值（根据索引号取值）
lindex(name, index)
在name对应的列表中根据索引获取列表元素

print(r.lindex("list2", 0))  # 取出索引号是0的值

# 输出
00

10.移动 元素从一个列表移动到另外一个列表
rpoplpush(src, dst)
从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
参数：
src，要取数据的列表的name
dst，要添加数据的列表的name

# 运行前先先清空一下然后重建方便观察现象
r.ltrim("list1",1,0)
r.ltrim("list2",1,0)
r.rpush("list1",1,2,3,4)
r.rpush("list2",5,6,7,8)
print("执行前：list1",r.lrange("list1", 0, -1))
print("执行前：list2",r.lrange("list2", 0, -1))
r.rpoplpush("list1", "list2")
print("执行后：list1",r.lrange("list1", 0, -1))
print("执行后：list2",r.lrange("list2", 0, -1))

# 输出
执行前：list1 ['1', '2', '3', '4']
执行前：list2 ['5', '6', '7', '8']
执行后：list1 ['1', '2', '3']
执行后：list2 ['4', '5', '6', '7', '8']

11.移动 元素从一个列表移动到另外一个列表 可以设置超时
brpoplpush(src, dst, timeout=0)
从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
参数：
src，取出并要移除元素的列表对应的name
dst，要插入元素的列表对应的name
timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞

# 运行前先先清空一下然后重建方便观察现象
r.ltrim("list1",1,0)
r.ltrim("list2",1,0)
r.rpush("list1",1,2,3,4)
r.rpush("list2",5,6,7,8)
print("执行前：list1",r.lrange("list1", 0, -1))
print("执行前：list2",r.lrange("list2", 0, -1))
r.brpoplpush("list1", "list2", timeout=2)
print("执行后：list1",r.lrange("list1", 0, -1))
print("执行后：list2",r.lrange("list2", 0, -1))

# 输出
执行前：list1 ['1', '2', '3', '4']
执行前：list2 ['5', '6', '7', '8']
执行后：list1 ['1', '2', '3']
执行后：list2 ['4', '5', '6', '7', '8']

12.一次移除多个列表
blpop(keys, timeout)
当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。
参数：
keys，redis的name的集合
timeout，超时时间，当给出的所有列表中都没有元素，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
更多：
r.brpop(keys, timeout) 同blpop，将多个列表排列,按照从右像左去移除各个列表内的元素

# 运行前先先清空一下然后重建方便观察现象
r.ltrim("list1",1,0)
r.ltrim("list2",1,0)
r.rpush("list1",1,2,3,4)
r.rpush("list2",5,6,7,8)
print("执行前：list1",r.lrange("list1", 0, -1))
print("执行前：list2",r.lrange("list2", 0, -1))
r.blpop(['list1','list2'],timeout=2)
print("执行后：list1",r.lrange("list1", 0, -1))
print("执行后：list2",r.lrange("list2", 0, -1))
print('--------------------------------------------')
# 清空列表1
r.ltrim("list1",1,0)
print("执行前：list1",r.lrange("list1", 0, -1))
print("执行前：list2",r.lrange("list2", 0, -1))
r.blpop(['list1','list2'],timeout=2)
print("执行后：list1",r.lrange("list1", 0, -1))
print("执行后：list2",r.lrange("list2", 0, -1))

# 输出
执行前：list1 ['1', '2', '3', '4']
执行前：list2 ['5', '6', '7', '8']
执行后：list1 ['2', '3', '4']
执行后：list2 ['5', '6', '7', '8']
--------------------------------------------
执行前：list1 []
执行前：list2 ['5', '6', '7', '8']
执行后：list1 []
执行后：list2 ['6', '7', '8']

注意：原博客这里有误，仔细数字我这里横线上下的输出，有何不同，他是从左往右开始寻找第一个不为空的列表剔除一个元素，记住，只剔除依次，如果前面的列表为空，则往后寻找，直至遇到第一个不为空的列表，假如所有的列表都为空，将会等待，知道所有的列表加起来，有元素为止

redis基本命令 set

1.新增
sadd(name,values)
name对应的集合中添加元素

r.sadd("set1", 33, 44, 55, 66)  # 往集合中添加元素
print(r.scard("set1"))  # 集合的长度是4
print(r.smembers("set1"))   # 获取集合中所有的成员

# 输出
4
{'33', '66', '55', '44'}

2.获取元素个数 类似于len
scard(name)
获取name对应的集合中元素个数

print(r.scard("set1"))  # 集合的长度是4

# 输出
4

3.获取集合中所有的成员
smembers(name)
获取name对应的集合的所有成员

print(r.smembers("set1"))   # 获取集合中所有的成员

# 输出
{'33', '66', '55', '44'}

获取集合中所有的成员--元组形式
sscan(name, cursor=0, match=None, count=None)

print(r.sscan("set1"))

# 输出
(0, ['33', '44', '55', '66'])

获取集合中所有的成员--迭代器的方式
sscan_iter(name, match=None, count=None)
同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大

for i in r.sscan_iter("set1"):
    print(i)

# 输出
33
44
55
66

4.差集
sdiff(keys, *args)
在第一个name对应的集合中且不在其他name对应的集合的元素集合

r.sadd("set2", 11, 22, 33)
print('set1：',r.smembers("set1"))   # 获取集合中所有的成员
print('set2：',r.smembers("set2"))
print('在集合set1但是不在集合set2中:',r.sdiff("set1", "set2"))   # 在集合set1但是不在集合set2中
print('在集合set2但是不在集合set1中:',r.sdiff("set2", "set1"))   # 在集合set2但是不在集合set1中

# 输出
set1： {'33', '55', '66', '44'}
set2： {'33', '11', '22'}
在集合set1但是不在集合set2中: {'55', '66', '44'}
在集合set2但是不在集合set1中: {'11', '22'}

5.差集--差集存在一个新的集合中
sdiffstore(dest, keys, *args)
获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中

r.sdiffstore("set3", "set1", "set2")    # 在集合set1但是不在集合set2中
print(r.smembers("set3"))   # 获取集合3中所有的成员

# 输出
{'44', '66', '55'}

6.交集
sinter(keys, *args)
获取多一个name对应集合的交集

print(r.sinter("set1", "set2")) # 取2个集合的交集

# 输出
{'33'}

7.交集--交集存在一个新的集合中
sinterstore(dest, keys, *args)
获取多一个name对应集合的并集，再将其加入到dest对应的集合中

print(r.sinterstore("set4", "set1", "set2")) # 取2个集合的交集
print(r.smembers("set4"))

# 输出
{'33'}

8.并集
sunion(keys, *args)
获取多个name对应的集合的并集

print(r.sunion("set1", "set2")) # 取2个集合的并集

# 输出
{'11', '44', '66', '33', '55', '22'}

9.并集--并集存在一个新的集合
sunionstore(dest,keys, *args)
获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中

print(r.sunionstore("set3", "set1", "set2")) # 取2个集合的并集
print(r.smembers("set3"))

# 输出
{'11', '44', '66', '33', '55', '22'}

10.判断是否是集合的成员 类似in
sismember(name, value)
检查value是否是name对应的集合的成员，结果为True和False

print(r.sismember("set1", 33))  # 33是集合的成员
print(r.sismember("set1", 23))  # 23不是集合的成员

# 输出
True
False

11.移动
smove(src, dst, value)
将某个成员从一个集合中移动到另外一个集合

print('移动前', r.smembers("set1"))  # 33是集合的成员
print('移动前', r.smembers("set2"))  # 23不是集合的成员

r.smove("set1", "set2", 44)

print('移动后', r.smembers("set1"))  # 33是集合的成员
print('移动后', r.smembers("set2"))  # 23不是集合的成员

# 输出
移动前 {'55', '44', '33', '66'}
移动前 {'22', '33', '11'}
移动后 {'55', '66', '33'}
移动后 {'22', '44', '33', '11'}

12.删除--随机删除并且返回被删除值
spop(name)
从集合移除一个成员，并将其返回,说明一下，集合是无序的，所有是随机删除的

print(r.smembers("set2"))
print(r.spop("set2"))   # 这个删除的值是随机删除的，集合是无序的
print(r.smembers("set2"))

# 输出
{'44', '33', '11', '22'}
11
{'33', '44', '22'}

13.删除--指定值删除
srem(name, values)
在name对应的集合中删除某些值

print(r.smembers("set2"))
print(r.srem("set2", 22))   # 从集合中删除指定值 11
print(r.smembers("set2"))

# 输出
{'44', '22', '33'}
1
{'44', '33'}

redis基本命令 有序set

Set操作，Set集合就是不允许重复的列表，本身是无序的
有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，
所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。

---

注意：从这里开始，都是我自己写的内容，因为原博客我已经发现了不止四处错误了，对我影响有点大，原本是不想敲代码，才照着他的写，看来还是要靠自己

---

1.新增
zadd(name, *args, **kwargs)
在name对应的有序集合中添加元素

可以看到zadd函数接收的是一个map

r.zadd('zset1', {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5})
map2 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
r.zadd('zset2', map2)
print(r.zrange('zset1', 0, 3))
print(r.zrange('zset2', 0, 4))

# 输出
['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd', 'e']

2.zrange
返回有序集 key 中，下标在之间的元素，带WITHSCORES，可以让分数一起和值返回到结果集。

print(r.zrange('zset1', 0, 2, withscores=True))

# 输出
[('a', 1.0), ('b', 2.0), ('c', 3.0)]

3.zrangebyscore
返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。

print(r.zrangebyscore ('zset1',1.0,4.0))
print(r.zrangebyscore ('zset1',1.0,4.0,withscores=True))

# 输出
['a', 'b', 'c', 'd']
[('a', 1.0), ('b', 2.0), ('c', 3.0), ('d', 4.0)]

4.zrevrangebyscore
同上，改为从大到小排列。

5.zincrby
为元素的score加上增量

print(r.zrange('zset1', 0, -1, withscores=True))
r.zincrby('zset1', 2.0, 'a')
print(r.zrange('zset1', 0, -1, withscores=True))

# 输出
[('a', 1.0), ('b', 2.0), ('c', 3.0), ('d', 4.0), ('e', 5.0)]
[('b', 2.0), ('a', 3.0), ('c', 3.0), ('d', 4.0), ('e', 5.0)]

6.zrem
删除该集合下，指定值的一个或多个值

print(r.zrange('zset1', 0, -1, withscores=True))
r.zrem('zset1', 'a', 'b')
print(r.zrange('zset1', 0, -1, withscores=True))

# 输出
[('b', 2.0), ('a', 3.0), ('c', 3.0), ('d', 4.0), ('e', 5.0)]
[('c', 3.0), ('d', 4.0), ('e', 5.0)]

7.zcount
统计该集合，分数区间内的元素个数

print(r.zrange('zset1', 0, -1, withscores=True))
print(r.zcount('zset1', 2, 4))

# 输出
[('c', 3.0), ('d', 4.0), ('e', 5.0)]
2

8.zrank
返回该值在集合中的排名，从0开始。

print(r.zrange('zset1', 0, -1, withscores=True))
print(r.zrank('zset1','d'))

# 输出
[('c', 3.0), ('d', 4.0), ('e', 5.0)]
1