redis之pythonApi操作

01 redis入门

1 redis介绍

1.1 什么是redis?

redis是一款键值型内存数据库软件，它没有表默认有0-15号仓库

是存储数据的软件，跟语言无关，纯内存数据库（所有数据都放在内存中）

速度非常快，支持的数据类型多样（5 大数据类型：字符串，列表，字典，集合，有序集合）

1.2Memcached和redis比较

​ redis是单线程，单进程，数据类型丰富（只针对于 redis 6.0以下）
​ memcache多线程多进程，数据类型单一，

1.2redis为什么单线程，单进程速度这么快？

官方说redis有10w的并发量，实际生产当作redis有6W左右的高并发
纯内存数据库
io多路复用，epoll模型（linux上支持），windows上支持select
单线程单进程，避免了线程间切换

redis：开源软件，c语言写的，早起版本2w3千行，对windows不支持 6.0.6
-在不同平台编译---》可执行文件---》执行
-windows官方：又有大神把源码，在windows上编译--》可以允许在windows上（3.x）

2 redis在windows安装和配置

2.1：下载

下载window版本的redis,然后下一步下一步即可，这个redis版本比较老了，这个是因为redis用的是

epoll模型，window系统不支持，它只支持select模型

redis 的默认端口是6379

2.2：启动服务的两种形式

redis-server # 使用的默认的配置文件

reids-server redis.conf # 使用配置文件

安装好后redis所在自动加入了环境变量中，且自动加入到服务当中，你可设置开机自启，还是手动启动，配置文件也在该目录下

2.3：命令连接redis服务

reids -h host -p port -a password

2.4：图形化连接redis服务

下载连接现在收费了你可以下载我的，安装下一步下一步

3 普通连接和连接池(使用Python语言客户端建立连接)

3.1：安装

pip install redis

3.2连接数据库

import redis
client = redis.Redis(
    host='localhost',  # 数据库地址
    port=6379,  # 数据库端口
    password='123456' # 数据库密码
    )

client.set('nginx',"{'name':'nginx','age':18,'gender':'男'}") # 这个是在redis数据库中添加了一个值
res = client.get('nginx') # 获取值
print(res.decode('utf-8'))  
client.close() # 关闭数据连接

3.3：使用池子连接

import redis

pool = redis.ConnectionPool(
    max_connections=10, # 池最大连接数
    host='localhost',  #主机地址
    password=123456,  # 数据库密码
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)  # 连接连接池 
res = client.get('nginx')  # 获取可以'nginx’的值
print(res.decode('utf-8')) # 打印值

3.4：对连接池进行性能优化（使用单例模式)

使用单例可以防止连接池重复创建

con_pool.py

import redis
pool = redis.ConnectionPool(
    max_connections=10,
    port=6379,
    password=123456,
    host='localhost')

client.py

import redis
from con_pool import pool  # 导入连接池

client = redis.Redis(connection_pool=pool)  # 连接连接池 
res = client.get('nginx')  # 获取key为'nginx’的值
print(res.decode('utf-8')) # 打印值

4：操作string数据类型(使用python Api连接redis)

下述查询结果都是bytes类型

4.0:连接数据库

import redis


pool = redis.ConnectionPool(
    max_connections=10,
    host='localhost',
    password=123456,
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)  # 连接连接池

4.1 set

def set(self, name, value,
        ex=None, px=None, nx=False, xx=False, keepttl=False):
    pass
name: key的值
values: values的值
ex: 表示过期时间,默认时间为秒
px:表示过期时间为毫秒
nx:如果为True,表示name不存在则可以设值
xx:如果为True,表示name存在，则可以更新
 

client.set('name',18)  # 设置一个k:name,v:18
print(client.get('name')) # b'18'

client.set('age','alex')
print(client.get('age'))  # b'alex'

client.set('name','nginx',nx=True)
print(client.get('name')) # b'alex'

client.set('salary',1999,ex=10)
import time
print(client.get('salary'))  # b'1999'
time.sleep(11)
print(client.get('salary')) # None


client.set('nginx','1.19',px=2000)
print(client.get('nginx')) # b'1.19'
import time
time.sleep(2)
print(client.get('nginx')) # None

4.2 get

# 表示获取key对应的values
client.set('name','nbplus')
print(client.get('name'))  # b'nbplus'

4.3 setnx

# 等同于上面的set中参数nx=True,表示不存在则可以设值，存在不能更新

client.setnx('age',18)
print(client.get('age')) # b'18'
client.setnx('age',22)
print(client.get('age')) # b'18'

4.4 setex

# 等同于上面的set中参数ex=1,表示过期时间为多少秒
client.setex('name',3,'nginx')
print(client.get('name'))  # b'nginx'
import time
time.sleep(3.1)
print(client.get('name'))

4.5mset

client.mset({'name':"alex","age":18})
print(client.get('name')) # b'alex'

4.6mget

res = client.mget('name','age') # 
print(res) # [b'alex', b'18']

4.7 getset

# 先把旧值给取出来，然后再更新一个新值，一次网络io，完成了取值和设置
res = client.getset('name','alex111')
print(res) # b'alex'
print(client.get('name')) b'alex111'

4.8 getrange

print(client.get('name'))  # b'alex111'
res = client.getrange('name',1,2)  # 左闭右开
print(res)

4.9 setrange

print(client.get('name'))  # b'alex111'
client.setrange('name',1,'zq') 
print(client.get('name')) # b'azqx111'

4.10 setbit

# conn.set('n1','foo')
#那么字符串foo的二进制表示为：01100110 01101111 01101111
# conn.setbit('n1',7,1)
# #那么字符串foo的二进制表示为：01100111 01101111 01101111
# res=conn.get('n1')

4.11 getbit

# getbit(name, offset)
# 获取bit位的第几个位置，看是1还是0
# res=conn.getbit('n1',7)
# print(res)

4.12 bitcount

# bitcount(key, start=None, end=None)
# end:指的是bytes，前闭后闭区间
# res=conn.bitcount('n1',0,1)
# print(res)

4.13 incr

print(client.get('age'))
print(client.incr('age')) # 默认自增1

4.14 decr

print(client.get('age')) 
print(client.decr('age'))  # 默认自减1

4.14 append

client.append('age','18') #后面追加1
print(client.get('age'))

5：hash操作

5.0 连接

import redis

pool = redis.ConnectionPool(max_connections=10, host='localhost', password=123456, port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)  # 连接连接池

5.1 hset

# 设置字典中的k,v
client.hset('userinfo1','name',3.14159261) # 设hash值
print(client.hget('userinfo1','name'))  # b'3.14159261'

5.2 hmset

# 在hash中一次设置多个k,v
client.hmset('web',{'nginx':1.18,'tomcat':3.6,'uwsgi': 1.0})
print(client.hget('web','nginx'))  # b'1.18'
print(client.hget('web','tomcat'))  # b'3.6'
print(client.hget('web','uwsgi'))   # b'1.0'

5.3 hget

# 在hash中获取一个k对应的v
print(client.hget('web','uwsgi')) # b'1.0'

5.4 hmget

# 在hash中一次性获取多个k,对应的v
res = client.hmget('web','nginx','tomcat','uwsgi')
print(res)  # [b'1.18', b'3.6', b'1.0']

res = client.hmget('web',['nginx','tomcat','uwsgi'])
print(res) # [b'1.18', b'3.6', b'1.0']

5.5 hgetall

#在hash中一次性获取所有，如果值够多，会挤爆内存，稍微注意一点
print(client.hgetall('web')) # {b'nginx': b'1.18', b'tomcat': b'3.6', b'uwsgi': b'1.0'}

5.6hlen

# 统计字典长度
print(client.hlen('web')) # 3

5.7 hkeys

# 获取hash中的key
print(client.hkeys('web')) # [b'nginx', b'tomcat', b'uwsgi']

5.8 hvals

# 获取hash中的val
print(client.hvals('web')) # [b'1.18', b'3.6', b'1.0']

5.9 hexists

# 判断hash中的key是否存在
print(client.hexists('web','alex')) # False

print(client.hexists('web','nginx'))  # True

5.10 hdel

# 删除字典中的key对应的val
print(client.hgetall('web'))
client.hdel('web','nginx')
print(client.hgetall('web'))

5.11 hincrby

# 在hash中的k所对应的v默认自增1
res = client.hset('test','num',1)
print(res) # 1
print(client.hincrby('test','num')) # 2

5.12 hscan

批量插入值

dic = {}
for i in range(1001):
    dic.update({'%s'%i:'test%s'%i})
client.hmset('test01',dic)

res = client.hscan('test01',cursor=1,count=10) # cursor是redis内部维护的一个随机的值，count一次性取10条
print(res) 

5.13 hscan_iter

res = client.hscan_iter('test01',match=None,count=10) # 生成器，节省内存,count一次性取多少个值，match匹配的是hash中的key 
print(res)
for i in res:
    print(i) 

6：list

6.0连接数据库

import redis


pool = redis.ConnectionPool(
    max_connections=10,
    host='localhost',
    password=123456,
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)  # 连接连接池

6.1 lpush

client.lpush('list1',1,2,3,4,5,6)

6.2 lpushx

client.lpushx('list2','a',) # 存在就往list中添加值，值的位置在最左边

client.lpushx('list1','a',)

6.3llen

# 统计list的长度
print(client.llen('list1'))

6.4 linsert

def linsert(self, name, where, refvalue, value):
    pass
name: redis的name
where:BEFORE或AFTER(小写也可以)
refvalue:标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
value:要插入的数据

client.linsert('list1','after','a','after1')

client.linsert('list1','before','a','after2')

6.5 lset

client.lset('list1',1,'nginx') # 索引从0开始，左闭右闭

6.6 lrem

def lrem(self, name, value, num=0):
    pass
# name，redis的name
# value，要删除的值
# num，  num=0，删除列表中所有的指定值；
    # num=2,从前到后，删除2个；
    # num=-2,从后向前，删除2个

client.lrem('list1','after2',num=2)

6.7lpop

# 把list表最左边边的值弹出来
res = client.lpop('list1')
print(res) # b'6'

6.8lindex

# 根据索引取值
res = client.lindex('list1',0)
print(res) #  b'5'

6.9lrange

# list中范围的值
res = client.lrange('list1',0,2)
print(res) # [b'5', b'4', b'3']

6.10ltrim

res = client.ltrim('list1',0,2)  # 删除list中不在这范围种的值，左闭右闭
print(res) # 返回bool值

6.11rpoplpush

client.lpush('list2','a','b','c') # 创建一个list

# 把源list中最右边的值弹出来，放到目标list的左边边，可以同时对一个list操作
client.rpoplpush('list1',list2)

6.12 blpop

# 这个是阻塞式弹出值，如果list为空，取值会阻塞，只有取值时，list不为空，则不阻塞
res = client.blpop('list1')
print(res) # (b'list1', b'5')

6.13brpoplpush

# 这个是阻塞式取值，如果源list中的值为空时，如果取值那么就会阻塞住，否则就去把最右边的值，取出来，放到目标list中的最右边

res = client.rpoplpush('list1','list2')

6.14:封装一个可迭代取值的功能

实验数据

import redis

pool = redis.ConnectionPool(
    max_connections=10,
    host='localhost',
    password=123456,
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)

lis = []
for i in range(10000):
    lis.append('test%s' %i)
client.lpush('test_list',*lis)

封装可迭代取值

def list_scan_iter(name, con, count=10):
    """
    :param name: 这个是key的名称
    :param con:  这个是redis连接
    :param count:  # 这个是每一次取得范围
    :return: 
    """
    # 索引从0开始
    start = 0
    while True:
        # 每一次去的范围是list[start,(count + start -1)]
        data = con.lrange(name, start, (count + start) - 1)
        # 当数据为空时，自动退出循环
        if data:
            for item in data:
                # 使用yield关键字，可以挂起保存状态
                yield item
            # start每一次加10
            start += 10
        else:
            break


for i in list_scan_iter('test_list',client):
    print(i)

7：set操作

set操作，set集合就是不允许重复的列表

7.0：建立连接

import redis

pool = redis.ConnectionPool(
    max_connections=10,
    host='localhost',
    password=123456,
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)

7.1 sadd

# name对应的集合中添加元素
client.sadd('setname',1,2,3,4)

7.2 scard

# 获取name对应的集合中元素个数
print(client.scard('setname')) # 4

7.3 sdiff

# 在第一个name对应的集合中且不在其他name对应的集合的元素集合

client.sadd('setname1',3,4)

print(client.sdiff('setname','setname1')) # {b'1', b'2'}

7.4sdiffstore

#  获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中

print(client.sdiffstore('dset','setname1','setname'))

7.5sinter

# 获取多一个name对应集合的并集

print(client.sinter('setname','setname1')) # {b'4', b'3'}

7.6sinterstore

# 获取多一个name对应集合的并集，再讲其加入到dest对应的集合中

print(client.sinterstore('setname4','setname1','setname'))

7.7sismember

# 检查value是否是name对应的集合的成员

print(client.sismember('setname',3)) # True
# 返回bool值

7.8smembers

# 获取name对应的集合的所有成员

print(client.smembers('setname')) # {b'4', b'2', b'3', b'1'}

7.9smove

# 将某个成员从一个集合中移动到另外一个集合
print(client.smove('setname','setname1','1')) # True
#结果是bool值

7.10spop

# 从集合的右侧（尾部）移除一个成员，并将其返回
print(client.spop('setname'))

7.11srandmember

# 从name对应的集合中随机获取 numbers 个元素
print(client.srandmember('setname',1)) # numbers个随机值 [b'4']

7.12srem

# 在name对应的集合中删除某些值
print(client.srem('setname','3')) # 返回0or1 # 成功返回1，否者反之

7.13sunion

# 获取多一个name对应的集合的并集
print(client.sunion('setname1','setname2')) # {b'4', b'3', b'1'}

7.14sunionstore

# 获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中
client.sunionstore('testset','setname1','setname2')

7.15sscan

# 获取name的所有元素
print(client.sscan('setname1',count=10))

7.16sscan_iter

# 同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大
client.sscan_iter('setname1',count=10)  # 生成器

8:有序集合

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

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

8.1 zadd

Zadd 命令用于将一个或多个成员元素及其分数值加入到有序集当中。
如果某个成员已经是有序集的成员，那么更新这个成员的分数值，并通过重新插入这个成员元素，来保证该成员在正确的位置上。
分数值可以是整数值或双精度浮点数。
如果有序集合 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
当 key 存在但不是有序集类型时，返回一个错误。

# 在name对应的有序集合中添加元素
# 如：
     # zadd('zz', 'n1', 1, 'n2', 2)
     # 或
     # zadd('zz', n1=11, n2=22)

client.zadd('zset1',n1,1,n2,2)
client.zadd('zset1',n1=1,n2=2)

8.2 zcard

Zcard 命令用于计算集合中元素的数量。
当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0 。

# 获取name对应的有序集合元素的数量

client.zcard('zset1') # 2

8.3zcount

Zcount 命令用于计算有序集合中指定分数区间的成员数量。分数值在 min 和 max 之间的成员的数量。

# 获取name对应的有序集合中分数 在 [min,max] 之间的个数
print(client.zcount('zset1',0,2)) # 2

8.4zincrby

Zincrby 命令对有序集合中指定成员的分数加上增量 increment

可以通过传递一个负数值 increment ，让分数减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。
当 key 不存在，或分数不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。
当 key 不是有序集类型时，返回一个错误。
分数值可以是整数值或双精度浮点数。
member 成员的新分数值，以字符串形式表示。

# 自增name对应的有序集合的 name 对应的分数
print(client.zincrby('zset1','n1')) # 2.0

8.5[r]zrange

Zrange 返回有序集中，指定区间内的成员。
其中成员的位置按分数值递增(从小到大)来排序。
具有相同分数值的成员按字典序(lexicographical order )来排列。
如果你需要成员按值递减(从大到小)来排列，请使用 ZREVRANGE 命令。
下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。
你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

# 按照索引范围获取name对应的有序集合的元素
 
# 参数：
    # name，redis的name
    # start，有序集合索引起始位置（非分数）
    # end，有序集合索引结束位置（非分数）
    # desc，排序规则，默认按照分数从小到大排序
    # withscores，是否获取元素的分数，默认只获取元素的值
    # score_cast_func，对分数进行数据转换的函数
 
# 更多：
    # 从大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)
 
    # 按照分数范围获取name对应的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 从大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

print client.zadd("7", "1", 1, "2", 2,"3",3,"4",4,"5",5)     #输出的结果是5
print client.zrange("7",start=0,end=-1,desc=False)           #输出的结果是['1', '2', '3', '4', '5']
print client.zrange("7",start=0,end=2,desc=False)            #输出的结果是['1', '2', '3']

8.6zrank

Zrank 返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大)顺序排列。

如果成员是有序集 key 的成员，返回 member 的排名。 如果成员不是有序集 key 的成员，返回 None 。

# 获取某个值在 name对应的有序集合中的排行（从 0 开始）
 
# 更多：
    # zrevrank(name, value)，从大到小排序

print(client.zrank('zset1','n1')) # 1

print client.zadd("10", "a", 1, "b", 2, "c", 3)  # 输出的结果是3
print client.zadd("10", "f", 11, "d", 21,"e",32)    #输出的结果是3
print client.zrank("10","a")                     #输出的结果是0
print client.zrank("10","b")                     #输出的结果是1
print client.zrank("10","e")                     #输出的结果是5
print client.zrank("10","d")                     #输出的结果是4
print client.zrank("10","h")                     #输出的结果是None

8.7zrangebylex

# 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值 （lexicographical ordering）来进行排序，而这个命令则可以返回给定的有序集合键 key 中， 元素的值介于 min 和 max 之间的成员
# 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大
 
# 参数：
    # name，redis的name
    # min，左区间（值）。 + 表示正无限； - 表示负无限； ( 表示开区间； [ 则表示闭区间
    # min，右区间（值）
    # start，对结果进行分片处理，索引位置
    # num，对结果进行分片处理，索引后面的num个元素
 
# 如：
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex('myzset', "-", "[ca") 结果为：['aa', 'ba', 'ca']
 
# 更多：
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

8.8zrem

Zrem 命令用于移除有序集中的一个或多个成员，不存在的成员将被忽略。

当 key 存在但不是有序集类型时，返回一个错误。

# 删除name对应的有序集合中值是values的成员
 
# 如：zrem('zz', ['s1', 's2'])

print(client.zrem('zset1','n1'))

8.9zremrangebyrank

Zremrangebylex 命令用于移除有序集合中给定的字典区间的所有成员。
被成功移除的成员的数量，不包括被忽略的成员。

# 根据排行范围删除

print(client.zremrangebyrank('zset1',1,3)) # 3

print client.zadd("12", "a", 1, "b", 2, "c", 3)         # 输出的结果是3
print client.zadd("12", "d", 11, "e", 21,"f",32)        #输出的结果是3
print client.zremrangebylex("12",min="[a",max="[c")    #输出的结果是3
print client.zrange("12",0,-1)                         #输出的结果是 ['d', 'e', 'f']  因为  a，b，c已经被移除

8.10zremrangebyscore

Zremrangebyscore 命令用于移除有序集中，指定分数（score）区间内的所有成员。

# 根据分数范围删除

client.zremrangebyscore('zset1',2,4)

# print client.zadd("13", "a", 1, "b", 2, "c", 3)         # 输出的结果是3
# print client.zadd("13", "d", 8, "e", 21,"f",32)        #输出的结果是3
# print client.zremrangebyrank(name=13,min=1,max=3)       #输出的结果是3
# print client.zrange("13","0","-1")                      #输出的结果是['a', 'e', 'f']  因为删除了 b，c，d

8.11zremrangebylex

Zremrangebylex 命令用于移除有序集合中给定的字典区间的所有成员。
被成功移除的成员的数量，不包括被忽略的成员。

# 根据值返回删除

print client.zadd("12", "a", 1, "b", 2, "c", 3)         # 输出的结果是3
print client.zadd("12", "d", 11, "e", 21,"f",32)        #输出的结果是3
print client.zremrangebylex("12",min="[a",max="[c")    #输出的结果是3
print client.zrange("12",0,-1)                         #输出的结果是 ['d', 'e', 'f']  因为  a，b，c已经被移除

8.12zscore

Zscore 命令返回有序集中，成员的分数值。 如果成员元素不是有序集 key 的成员，或 key 不存在，返回 None 。

# 获取name对应有序集合中 value 对应的分数

print(client.zscore('zset1','n3')) # 3

8.13zinterstore

Zinterstore 命令计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。 默认情况下，结果集中某个成员的分数值是所有给定集下该成员分数值之和。

# 获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

client.zadd('t1',"n1",11,"n2",13,"n3",15)
client.zadd('t2',"n1",11,"n2",13,"n3",20)

print(client.zinterstore('dset',('t1','t2'),aggregate='SUM'))

8.14zunionstore

Zunionstore 命令计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。

默认情况下，结果集中某个成员的分数值是所有给定集下该成员分数值之和 。
保存到 destination 的结果集的成员数量。

与上一样，几乎没有区别

# 获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

8.15zscan

Zscan 命令用于迭代有序集合中的元素（包括元素成员和元素分值）返回的每个元素都是一个有序集合元素，一个有序集合元素由一个成员（member）和一个分值（score）组成。

测试数据

dic = {}
for i in range(1000):
    dic.update({'n%s'%i:i})
client.zadd('test_set',**dic)

print(client.zscan('test_set',count=10)) # 游标从0开始，一次获取10条数据

8.16zscan_iter

# 迭代取值，每一次取值10条数据
for i in client.zscan_iter('test_set',count=10):
    print(i)

9:其它操作

9.1delete

# 根据删除redis中的任意数据类型

print(client.delete('test'))

9.2exists

# 检测redis的name是否存在

print(client.exists('test','1')) # True,返回结果是bool值，

9.3keys

# 根据模型获取redis的name
 
# 更多：
    # KEYS * 匹配数据库中所有 key 。
    # KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
    # KEYS h*llo 匹配 hllo 和 heeeeello 等。
    # KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 

print(client.keys()) # [b't1', b'dset', b'test_set', b't2']

9.4expire

# 为某个redis的某个name设置超时时间

print(client.expire('t1',3)) # 执行成功为True，返回的是bool值

9.5rename

# 对redis的name重命名为

print(client.rename('t1','tt')) # 执行成功为True，返回值是bool值

9.6move

# 将redis的某个值移动到指定的db下

print(client.move('tt',3))  # 执行成功为True，返回值是bool值

9.7randomkey

# 随机获取一个redis的name（不删除）

print(client.randomkey()) 

9.8type

# 获取name对应值的类型

print(type(client.randomkey())) # 基本上是5大数据类型

9.9scan

一次只获取指定数量的值

9.10scan_iter

每一只是获取指定数量的值，直到值全部获取完

10:管道

redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，

如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。

import redis

pool = redis.ConnectionPool(
    max_connections=10,
    host='localhost',
    password=123456,
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)
p = client.pipeline()
p.set('name',1)
p.getset('name','error')
p.execute() #这是提交

11:django中使用redis

方式一

创建一个文件

import redis
POOL = redis.ConnectionPool(
    host='127.0.0.1', 
    port=6379,
    password='1234',
    max_connections=1000)

视图函数中使用连接池

首先导入连接池

import redis
from django.shortcuts import render,HttpResponse
from utils.redis_pool import POOL

def index(request):
    conn = redis.Redis(connection_pool=POOL)
    conn.hset('kkk','age',18)

    return HttpResponse('设置成功')
def order(request):
    conn = redis.Redis(connection_pool=POOL)
    conn.hget('kkk','age')

    return HttpResponse('获取成功')

方式二

安装django-redis模块

pip3 install django-reids

settings.py配置

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
            # "PASSWORD": "123",
        }
    }
}

视图函数

from django_redis import get_redis_connection
conn = get_redis_connection('default')
print(conn.hgetall('xxx'))