Redis-Python

• redis 提供两个类 Redis 和 StrictRedis, StrictRedis 用于实现大部分官方的命令，Redis 是 StrictRedis 的子类，用于向后兼用旧版本。

• redis 取出的结果默认是字节，我们可以设定 decode_responses=True 改成字符串。

import redis   # 导入redis 模块

r = redis.Redis(host='localhost', port=6379, decode_responses=True)  
r.set('name', 'runoob')  # 设置 name 对应的值
print(r['name'])
print(r.get('name'))  # 取出键 name 对应的值
print(type(r.get('name')))  # 查看类型

使用连接池

• redis-py 使用 connection pool 来管理对一个 redis server 的所有连接，避免每次建立、释放连接的开销。

• 默认每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数 Redis，这样就可以实现多个 Redis 实例共享一个连接池。

import redis    # 导入redis 模块

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(host='localhost', port=6379, decode_responses=True)  
r.set('name', 'runoob')  # 设置 name 对应的值
print(r.get('name'))  # 取出键 name 对应的值

Redis基本命令–String

# 语法
set(name, value, ex=None, px=None, nx=False, xx=False)
	ex:过期时间（秒）
    px:过期时间（毫秒）
    nx:如果设置为True，则只有name不存在时，当前set操作才执行
    xx:如果设置为True，则只有name存在时，当前set操作才执行
        
setnx(name, time, value)：设置值，只有name不存在时，执行设置操作（添加）
	time:过期时间（数字秒 或 timedelta对象）
        
psetex(name, time_ms, value):
mset(*args, **kwargs)	# 批量设置
mget(keys, *args)		# 批量获取
getset(name, value)		# 设置新值并获取原来的值
getrange(key, start, end)# 获取子序列（根据字节获取，非字符）
setrange(name, offset, value)# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
setbit(name, offset, value)	# 对 name 对应值的二进制表示的位进行操作
getbit(name, offset)	# 获取name对应的值的二进制表示中的某位的值 （0或1）
bitcount(key, start=None, end=None)	# 获取name对应的值的二进制表示中 1 的个数
bitop(operation, dest, *keys)	# 获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
	operation - AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
strlen(name)	# 返回name对应值的字节长度（一个汉字3个字节）
## 应用场景 – 页面点击数
incr(self, name, amount=1)	# 自增 name 对应的值，当 name 不存在时，则创建 name＝amount，否则，则自增。
	amount:自增数（必须是整数）
incrbyfloat(self, name, amount=1.0)	# 同理
	amount - 自增数（浮点型）
decr(self, name, amount=1)	# 自减 name 对应的值
	amount:自减数（整数）
append(key, value)	# 在redis name对应的值后面追加内容

Redis基本命令–Hash

# 增
hset(name, key, value)	# name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
hmset(name, mapping)	# 在name对应的hash中批量设置键值对
	mapping:字典

# 查
hmget(name, keys, *args)	# 在name对应的hash中获取多个key的值
	keys:要获取key集合，如：['k1', 'k2', 'k3']
    *args:要获取的key，如：k1,k2,k3
hgetall(name)	# 获取name对应hash的所有键值
hlen(name)	# 获取name对应的hash中键值对的个数
hkeys(name)	# 获取name对应的hash中所有的key的值
hvals(name)	# 获取name对应的hash中所有的value的值
hexists(name, key)	# 检查 name 对应的 hash 是否存在当前传入的 key

# 删
hdel(name,*keys)	# 将name对应的hash中指定key的键值对删除
hincrby(name, key, amount=1)	# 自增name对应的hash中的指定key的值，不存在则创建key=amount
	name - redis中的name
    key - hash对应的key
	amount - 自增数（整数）
hincrbyfloat(name, key, amount=1.0)	# 同理
	amount，自增数（浮点数）

# 迭代
hscan(name, cursor=0, match=None, count=None)	# 增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆。
	name - redis的name
	cursor - 游标（基于游标分批取获取数据）
    match - 匹配指定key，默认None 表示所有的key
    count - 每次分片最少获取个数，默认None表示采用Redis的默认分片个数
hscan_iter(name, match=None, count=None)	# 利用yield封装hscan创建生成器，实现分批去redis中获取数据。
	match - 匹配指定key，默认None 表示所有的key
    count - 每次分片最少获取个数，默认None表示采用Redis的默认分片个数。

Redis基本命令–List

lpush(name,values)	# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边。--没有就新建
rpush(name,values)	# 往右同理
lpushx(name,value)	# 往已经有的name的列表的左边添加元素，没有的话无法创建
rpushx(name,value)	# 往右同理
linsert(name, where, refvalue, value)	# 在name对应的列表的某一个值前或后插入一个新值
	name - redis的name
    where - before or after
    refvalue - 标杆值，即：在它前后插入数据
    value - 要插入的数据
r.linsert("list2", "before", "11", "00")   # 往列表中左边第一个出现的元素"11"前插入元素"00"

r.lset(name, index, value)	# 对name对应的list中的某一个索引位置重新赋值
r.lrem(name, value, num)	# 在name对应的list中删除指定的值
	name - redis的name
    value - 要删除的值
    num - num=0，删除列表中所有的指定值；
    num=2 - 从前到后，删除2个, num=1,从前到后，删除左边第1个
    num=-2 - 从后向前，删除2个
lpop(name)	# 在name对应的列表的左侧获取第一个元素返回并在列表中移除
ltrim(name, start, end)	# 在name对应的列表中移除没有在start-end索引之间的值
lindex(name, index)	# 在name对应的列表中根据索引获取列表元素
rpoplpush(src, dst)	# 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
	src - 要取数据的列表的 name
    dst - 要添加数据的列表的 name
brpoplpush(src, dst, timeout=0)	# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
	src - 取出并要移除元素的列表对应的name
    dst - 要插入元素的列表对应的name
    timeout - 当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
blpop(keys, timeout)	# 将多个列表排列，按照从左到右去pop对应列表的元素
	keys - redis的name的集合
    timeout - 超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
brpop(keys, timeout)	# 同理（从右向左）
# 自定义增量迭代
def list_iter(name):
    """
    自定义redis列表增量迭代
    :param name: redis中的name，即：迭代name对应的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in range(list_count):
        yield r.lindex(name, index)

# 使用
for item in list_iter('list2'): # 遍历这个列表
    print(item)
    

Redis基本命令–Set

# 增
sadd(name,values)

# 查
scard(name)	# 获取name对应的集合中元素个数
smembers(name)	# 获取name对应的集合的所有成员
sscan(name, cursor=0, match=None, count=None)	# 获取集合中所有的成员--元组形式
sscan_iter(name, match=None, count=None)	# 获取集合中所有的成员--迭代器的方式
# 用于增量迭代分批获取元素，避免内存消耗太大
for i in r.sscan_iter("set1"):
    print(i)

sdiff(keys, *args)	# 取差集（可以有多个key）
sdiffstore(dest, keys, *args)	# 取差集并存在一个新的集合中
r.sdiffstore("set3", "set1", "set2")    # 在集合set1但是不在集合set2中

sinter(keys, *args)	# 取交集（可以有多个key）
sinterstore(dest, keys, *args)	# 同理
print(r.sinterstore("set3", "set1", "set2")) # 取2个集合的交集

sunion(keys, *args)	# 取并集（可以有多个key）
sunionstore(dest,keys, *args)	# 同理

sismember(name, value)	# 判断是否是集合的成员
smove(src, dst, value)	# 将某个成员从一个集合中移动到另外一个集合
r.smove("set1", "set2", 44)

spop(name)	# 从集合移除一个成员，并将其返回
srem(name, values)	# 在name对应的集合中删除指定值

Redis基本命令–有序Set

• 有序集合，在集合的基础上，为每元素排序。

• 对于有序集合，每一个元素有两个值：值和分数，分数专门用来做排序。

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

# 查
zcard(name)	# 获取name对应的有序集合元素的数量
r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)	# 按照索引范围获取name对应的有序集合的元素（从小到大）
	name - redis的name
    start - 有序集合索引起始位置（非分数）
    end - 有序集合索引结束位置（非分数）
    desc - 排序规则，默认按照分数从小到大排序
	withscores - 是否获取元素的分数，默认只获取元素的值
	score_cast_func - 对分数进行数据转换的函数
    
zrevrange(name, start, end, withscores=False, score_cast_func=float)	# 同理（从大到小）
print(r.zrevrange("zset1", 0, -1))    # 只获取元素，不显示分数
print(r.zrevrange("zset1", 0, -1, withscores=True)) # 获取有序集合中所有元素和分数,分数倒序

# 按照分数范围获取name对应的有序集合的元素
zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)	
for i in range(1, 30):
   element = 'n' + str(i)
   r.zadd("zset3", element, i)

# 在分数是15-25之间，取出符合条件的元素
print(r.zrangebyscore("zset3", 15, 25)) 

# 在分数是12-22之间，取出符合条件的元素（带分数）
print(r.zrangebyscore("zset3", 12, 22, withscores=True))    

# 按照分数范围获取有序集合的元素并排序（默认从大到小排序）
zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)	

# 获取所有元素--默认按照分数顺序排序
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)

# 获取所有元素--迭代器
zscan_iter(name, match=None, count=None,score_cast_func=float)

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

# 自增:自增name对应的有序集合的 name 对应的分数
zincrby(name, value, amount)

# 获取某个值在 name对应的有序集合中的索引（从 0 开始）
zrank(name, value)

# 删除name对应的有序集合中值是values的成员
zrem(name, values)

# 根据排行范围删除
zremrangebyrank(name, min, max)

# 根据分数范围删除
zremrangebyscore(name, min, max)

# 获取name对应有序集合中 value 对应的分数
zscore(name, value)

其他操作

# 删除redis中的任意数据类型（string、hash、list、set、有序set）
delete(*names)

# 检查名字是否存在
exists(name)

# 模糊匹配
keys(pattern='')
	KEYS * 匹配数据库中所有 key 。
	KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
	KEYS hllo 匹配 hllo 和 heeeeello 等。
	KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

# 设置超时时间
expire(name ,time)

# 重命名
rename(src, dst)

# 随机获取name
randomkey()

# 获取类型
type(name)