python 模块Redis模块，连接Redis数据库_windows python redis.asyncio

Redis window安装教程
Redis超全语法大全

一、安装

官网：https://redis-py.readthedocs.io/en/stable/

 pip install redis
1

二、连接数据库

1. 同步连接

   import redis
   connect = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
   connect.set('test','哈哈哈哈')
   print(connect.get('test'))
   1
   2
   3
   4

2. 异步连接

   import asyncio
   import redis.asyncio as redis
   
   async def run():
       async with redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) as connect:
           await connect.set('test','我是异步')
           result = await connect.get('test')
           print(result)
   
   asyncio.run(run())
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

三、连接数据库函数

1. redis.Redis 连接数据库

   redis.Redis(
       host='localhost', #ip地址
       port=6379, #端口
       db=0, #数据库，默认 0
       password=None, #密码
       single_connection_client=False, #True，不使用连接池
       connection_pool=None, #连接池
       decode_responses=False, #True时，将返回结果decode，即将bytes类型改为默认utf-8
       socket_timeout=None, #响应的时间
       socket_connect_timeout=None, #建立连接超时时间
       retry_on_timeout=False, #True时, 命令超时后,将会重试一次, 重试成功则正常返回; 失败则抛出timeout异常；False时直接抛出异常
       retry_on_error=None, #重试错误列表
       max_connections=None, #最大连接数
   )
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

2. redis.asyncio.Redis() 异步连接数据库

   import redis.asyncio as redis
   
   redis.Redis(
       host='localhost', #ip地址
       port=6379, #端口
       db=0, #数据库，默认 0
       password=None, #密码
       single_connection_client=False, #True，不使用连接池
       connection_pool=None, #连接池
       decode_responses=False, #True时，将返回结果decode，即将bytes类型改为默认utf-8
       socket_timeout=None, #响应的时间
       socket_connect_timeout=None, #建立连接超时时间
       retry_on_timeout=False, #True时, 命令超时后,将会重试一次, 重试成功则正常返回; 失败则抛出timeout异常；False时直接抛出异常
       retry_on_error=None, #重试错误列表
       max_connections=None, #最大连接数
   )
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16

四、字符串操作，异步需要使用async await

1. connect.set(name,value,ex=None, px=None, nx=False, xx=False) 设置值

   '''
   设置键和值(字符串类型)
   ex - 过期时间（秒）
   px - 过期时间（毫秒）
   nx - 如果设置为True，则只有name不存在时，当前set操作才执行
   xx - 如果设置为True，则只有name存在时，当前set操作才执行
   '''
   
   connect.set('test','哈哈哈哈')
   1
   2
   3
   4
   5
   6
   7
   8
   9

2. connect.setnx(name,value) 设置值，只有name不存在时，执行设置操作
3. connect.setex(name, time, value)) 设置值，time过期时间（秒）
4. connect.psetex(name, time_ms, value) 设置值，time_ms过期时间（毫秒）
5. connect.mset({name1:value1,name2:value2,name3:value3,…}) 批量设置值
6. connect.get(name) 获取值
7. connect.mget(name1,name2,name3,…) 批量获取值
8. connect.getrange(name, start, end) 获取部分值

   '''
   name：键值名
   start：开始index
   end：结束index，不包含结束index的字符
   '''
   
   connect.set('test','哈哈哈哈')
   print(connect.getrange('test', 0, 2))
   1
   2
   3
   4
   5
   6
   7
   8

9. connect.getset(name,value) 设置新值，并获取旧值
10. connect.setrange(name, offset, value) 从指定字符串索引offset开始，替换字符串
11. connect.append(name,value) 在原有字符基础上追加字符
12. connect.strlen(name) 返回name对应值的字节长度（一个汉字3个字节）
13. connect.incr(name, amount=1) 自增 name 对应的值，当 name 不存在时，则创建 name＝amount，否则，则自增
14. connect.decr(name, amount=1) 自减 name 对应的值，当 name 不存在时，则创建 name＝amount，否则，则自减
15. connect.incrby(name, amount=1) 在原有数值基础上加上一定的数值，当 name 不存在时，则创建 name＝amount
16. connect.decrby(name, amount=1) 在原有数值基础上减去一定的数值，当 name 不存在时，则创建 name＝amount
17. connect.incrbyfloat( name, amount=1.0) 自增 name 对应的值，当 name 不存在时，则创建 name＝amount，否则，则自增。
18. connect.setbit(name, offset, value) 对 name 对应值的二进制表示的位进行操作
19. connect.getbit(name,offset) 获取name对应的值的二进制表示中的某位的值 （0或1）
20. connect.bitcount(key, start=None, end=None) 获取name对应的值的二进制表示中 1 的个数

五、列表操作，异步需要使用async await

1. connect.lpush(name,values) 添加列表，从左边新增加

   connect.lpush('test_list',1,2,3,4)
   1

2. connect.rpush(name,values) 添加列表，从右边新增加
3. connect.lpushx(name,value) 向已有name的列表的左边添加元素，没有的话无法创建
4. connect.rpushx(name,value) 向已有name的列表的右边添加元素，没有的话无法创建
5. connect.linsert(name, where, refvalue, value) 在name对应的列表的某一个值前或后插入一个新值

   '''
   name - redis的name
   where - BEFORE或AFTER
   refvalue - 标杆值，即：在它前后插入数据
   value - 要插入的数据
   '''
   connect.linsert('test_list','BEFORE','2','5')
   1
   2
   3
   4
   5
   6
   7

6. connect.lset(name, index, value) 指定索引位置重新赋值
7. connect.lrem(name, value, num) 删除指定的value，num为负数时从后向前删除
8. connect.lpop(name) 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
9. connect.rpop() 在name对应的列表的右侧获取第一个元素并在列表中移除，返回值则是第一个元素
10. connect.blpop(keys, timeout) 将多个列表排列，按照从左到右去pop对应列表的元素
11. connect.brpop(keys, timeout) 将多个列表排列,按照从右到左去移除各个列表内的元素

    connect.blpop(['test_list','test_list1'], timeout=2)
    1

12. connect.rpoplpush(src, dst) 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边

    '''
    src - 要取数据的列表的 name
    dst - 要添加数据的列表的 name
    '''
    connect.rpoplpush('test_list','test_list1')
    1
    2
    3
    4
    5

13. connect.brpoplpush(src, dst) 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

    '''
    src - 取出并要移除元素的列表对应的name
    dst - 要插入元素的列表对应的name
    timeout - 当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
    '''
    connect.brpoplpush('test_list','test_list1')
    1
    2
    3
    4
    5
    6

14. connect.ltrim(name, start, end) 在name对应的列表中移除没有在start-end索引之间的值
15. connect.llen(name) 获取name列表中值的数量
16. connect.lindex(index) 取值（根据索引号取值）
17. connect.lrange(name,start,end) 在name对应的列表中取出start-end索引之间的值，包含end

六、hash类型操作，异步需要使用async await

1. connect.hset(name, key, value) 增加hash类型键值
2. connect.hsetnx(name, key, value) 设置值，只有name不存在时，执行设置操作
3. connect.hget(name,key) 获取对应的key值
4. connect.hmset(name,{key1:value1,key2:value2,key3:value3,…}) 批量添加值
5. connect.hmget(name,[key1,key2,key3,…]) 批量获取值
6. connect.hgetall(name) 取出所有的值
7. connect.hkeys(name) 获取所有的key
8. connect.hvals(name) 获取所有的value
9. connect.hscan(name, cursor=0, match=None, count=None) 取值查看–分片读取

   '''
   name - redis的name
   cursor - 游标（基于游标分批取获取数据）
   match - 匹配指定key，默认None 表示所有的key
   count - 每次分片最少获取个数，默认None表示采用Redis的默认分片个数
   '''
   
   connect.hscan('test')
   1
   2
   3
   4
   5
   6
   7
   8

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

    '''
    match - 匹配指定key，默认None 表示所有的key
    count - 每次分片最少获取个数，默认None表示采用Redis的默认分片个数
    '''
    test = connect.hscan_iter('test')
    for i in test:
        print(i)
    1
    2
    3
    4
    5
    6
    7

11. connect.hlen(name) 获取hash中键值对的个数
12. connect.hstrlen(name,key) 获取指定key值的长度
13. connect.hincrby(name, key, amount=1) 自增自减数(将key对应的value–整数 自增1或者2，或者别的整数 负数就是自减)
14. connect.hincrbyfloat(name, key, amount=1.0) 自增自减浮点数(将key对应的value–浮点数 自增1.0或者2.0，或者别的浮点数 负数就是自减)
15. connect.hdel(name,keys) 删除hash中键值对

    connect.hdel('test','name') #删除一个
    connect.hdel('test',['name','age']) #删除多个
    1
    2

16. connect.hexists(name, key) 判断hash中key是否存在

七、set类型操作，异步需要使用async await

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

   connect.sadd('test_set',1,2,3,4,5)
   1

2. connect.scard(name) 获取name集合中的个数
3. connect.smembers(name) 获取name集合中的所有元素
4. connect.sscan(name, cursor=0, match=None, count=None)
5. connect.sscan_iter(name, match=None, count=None)
6. connect.srem(name, values) 在name对应的集合中删除某些值
7. connect.spop(name) 从集合移除一个成员，并将其返回,说明一下，集合是无序的，所有是随机删除的
8. connect.srandmember(namem,num) 从集合随机取出num个元素
9. connect.smove(src, dst, value) 将某个成员从一个集合中移动到另外一个集合
10. connect.sismember(name, value) 检查value是否是name对应的集合的成员，结果为True和False
11. connect.sdiff(keys) 获取多个集合的差集

    connect.sdiff(['test_set','test_set1','test_set2'])
    1

12. connect.sdiffstore(dest, keys) 获取多个集合的差集，并存进一个新的集合

    connect.sdiffstore('new_test_set',['test_set','test_set1','test_set2'])
    1

13. connect.sinter(keys) 获取多个集合的交集
14. connect.sinterstore(dest, keys) 获取多个集合的差集，并存进一个新的集合
15. connect.sunion(keys) 获取多个集合的并集
16. connect.sunionstore(dest, keys) 获取多个集合的并集，并存进一个新的集合

八、有序集合类型，异步需要使用async await

1. connect.zadd(name,mapping,nx= False,xx= False,ch= False,incr= False,gt= False,lt= False) 对应的集合中添加元素

   '''
   name - redis的name
   mapping - 添加到集合的键值对
   nx - 强制ZADD只创建新元素而不更新已经存在的元素的分数。
   xx - 强制ZADD只更新已经存在的元素的分数存在。不会添加新元素。
   ch - 将返回值修改为已更改的元素数。更改的元素包括添加的新元素和元素谁的分数变了。
   incr - 修改ZADD的行为像ZINCRBY。在这种模式下，只有a可以指定单个元素/分数对，分数是数量现有的分数将增加到。使用此模式时ZADD的返回值将是元素的新分数。
   LT - 仅在新分数小于时更新现有元素当前分数。这个标志不会阻止添加新元素。
   GT - 仅在新分数大于时更新现有元素当前分数。这个标志不会阻止添加新元素。
   '''
   connect.zadd('test',{'key1': 20,'key2': 10})
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11

2. connect.zcard(name) 获取元素集合中的个数
3. connect.zrange(name, start, end, desc=False, withscores=False, score_cast_func=float) 按照索引范围获取name对应的有序集合的元素

   '''
   name - redis的name
   start - 有序集合索引起始位置（非分数）
   end - 有序集合索引结束位置（非分数）
   desc - 排序规则，默认按照分数从小到大排序
   withscores - 是否获取元素的分数，默认只获取元素的值
   score_cast_func - 对分数进行数据转换的函数
   '''
   connect.zrange('test',0,1,withscores=True)
   1
   2
   3
   4
   5
   6
   7
   8
   9

4. connect.zrevrange(name, start, end, withscores=False, score_cast_func=float) 从大到小排序(同zrange默认排序，集合是从大到小排序的)
5. connect.zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float) 按照分数范围获取name对应的有序集合的元素

   '''
   name - redis的name
   min - 最小值
   max - 最大值
   start - 有序集合索引起始位置（非分数）
   num - 获取数量
   withscores - 是否获取元素的分数，默认只获取元素的值
   score_cast_func - 对分数进行数据转换的函数
   '''
   connect.zrangebyscore('test',min=0,max=10,start=0,num=1,withscores=True)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

6. connect.zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float) 按照分数范围获取有序集合的元素并排序（默认从大到小排序）
7. connect.zscan(name, cursor=0, match=None, count=None, score_cast_func=float) 获取所有元素
8. connect.zscan_iter(name, match=None, count=None, score_cast_func=float) 获取所有元素–迭代器
9. connect.zcount(name, min, max) 获取name对应的有序集合中分数 在 [min,max] 之间的个数
10. connect.zincrby(name, value, amount) 自增
11. connect.zrank(name, value) 获取索引，按照分数顺序（从小到大）
12. connect.zrevrank(name, value) 获取索引，按照倒序（从大到小）
13. connect.zrem(name, value1,value2,…) 删除name对应的有序集合中值是values的成员
14. connect.zremrangebyrank(name, min, max) 根据索引范围删除
15. connect.zremrangebyscore(name, min, max) 根据分数范围删除
16. connect.zscore(name, value) 获取对应值的分数

九、其他函数，异步需要使用async await

1. connect.close() 关闭Redis连接
2. connect.select(index) 切换数据库
3. connect.ping() 判断服务器是否连接成功
4. connect.echo(str) 从服务器输出字符串
5. connect.dbsize() 返回服务器中的键数
6. connect.keys(pattern) 返回匹配’ ’ pattern ’ '的键列表，不传返回全部
7. connect.scan_iter(match，count) 返回匹配match键迭代器，不传返回全部
8. connect.time() 返回服务器时间为包含两个元素的int元组
9. connect.lastsave()返回一个Python datetime对象，表示对象最后一次使用的时间
10. connect.save() 保存数据
11. connect.bgsave() 异步保存数据
12. connect.shutdonw(save= False,nosave = False,now = False,force = False,abort = False,) 如果Redis配置了持久化，数据将在关机前被刷新

    '''
    save - 也会强制执行DB保存操作
    nosave - 将阻止数据库保存操作，即使有一个或多个保存点配置
    now - 跳过等待滞后副本，即它绕过了第一步关机顺序
    force - 忽略任何通常会阻止服务器退出的错误
    abort - 取消正在进行的关机，不能与其他标志结合使用
    '''
    1
    2
    3
    4
    5
    6
    7

13. connect.move(name,db) 将键name移动到另一个数据库 db
14. connect.flushall(asynchronous = False) 删除当前主机上所有数据库中的所有键，asynchronous 是否异步
15. connect.flushdb(asynchronous = False) 删除当前数据库中的所有键，asynchronous 是否异步
16. connect.dump(name) 返回存储在指定键处的值的序列化版本
17. connect.type(name) 返回键类型
18. connect.rename(src,dst) 重命名键src为dst
19. connect.renamex(src,dst) 如果dst不存在，则将src重命名为dst
20. connect.delete(names) 删除一个或多个由names指定的键
21. connect.exists(names) 一个或多个由’names指定的键是是否存在
22. connect.expire(name,time,nx = False,xx= False,gt = False,lt = False) 使用给定在键name上为time秒设置一个过期标志

    '''
    name - redis的name
    time - 过期时间
    nx - 仅当密钥没有过期时设置过期
    xx - 仅当密钥已存在过期时才设置过期
    gt - 仅当新过期时间大于当前过期时间时设置过期时间
    lt - 仅在新到期时间小于当前到期时间时设置到期时间
    '''
    1
    2
    3
    4
    5
    6
    7
    8

23. connect.expireat(name,when,nx = False,xx= False,gt = False,lt = False) 使用给定的“选项”在键name上设置一个过期标志

    '''
    name - redis的name
    when - 可以表示为整数表示unix时间或Python datetime对象
    nx - 仅当密钥没有过期时设置过期
    xx - 仅当密钥已存在过期时才设置过期
    gt - 仅当新过期时间大于当前过期时间时设置过期时间
    lt - 仅在新到期时间小于当前到期时间时设置到期时间
    '''
    1
    2
    3
    4
    5
    6
    7
    8

24. connect.pexpire(name,time,nx = False,xx= False,gt = False,lt = False) 使用给定在键name上为timeh毫秒设置一个过期标志

    '''
    name - redis的name
    time - 过期时间
    nx - 仅当密钥没有过期时设置过期
    xx - 仅当密钥已存在过期时才设置过期
    gt - 仅当新过期时间大于当前过期时间时设置过期时间
    lt - 仅在新到期时间小于当前到期时间时设置到期时间
    '''
    1
    2
    3
    4
    5
    6
    7
    8

25. connect.pexpireat(name,when,nx = False,xx= False,gt = False,lt = False) 使用给定的“选项”在键name上设置一个过期标志

    '''
    name - redis的name
    when - 可以表示为整数表示unix时间或Python datetime对象
    nx - 仅当密钥没有过期时设置过期
    xx - 仅当密钥已存在过期时才设置过期
    gt - 仅当新过期时间大于当前过期时间时设置过期时间
    lt - 仅在新到期时间小于当前到期时间时设置到期时间
    '''
    1
    2
    3
    4
    5
    6
    7
    8

26. connect.ttl(name) 返回键name到期前的秒数
27. connect.pttl(name) 返回键name到期前的毫秒数
28. connect.persist(name) 删除name的过期

十、连接池，异步需要使用async await

1. redis.ConnectionPool(option) option参数大部分和redis.Redis一致
   连接池的原理是, 通过预先创建多个连接, 当进行redis操作时, 直接获取已经创建的连接进行操作, 而且操作完成后, 不会释放, 用于后续的其他redis操作，这样就达到了避免频繁的redis连接创建和释放的目的, 从而提高性能。redis模块采用ConnectionPool来管理对redis server的所有连接

   import redis
   
   pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True)
   
   connect = redis.Redis(connection_pool=pool)
   connect.set('name','数据库0')
   
   print(connect.get('name'))
   1
   2
   3
   4
   5
   6
   7
   8

2. redis.BlockingConnectionPool(option) option参数大部分和redis.Redis一致
   BlockingConnectionPool和ConnectionPool功能是一样的，但是是线程安全的，在多线程的环境下，建议用BlockingConnectionPool，比如gunicorn使用了多线程的worker。同时，当所有连接都在使用时，获取可用连接不会抛异常，而是可以设置等待时间。