redis基本使用

redis安装和启动

python操作redis---普通连接

• 安装第三方包

pip install redis

• python中简单使用

# 导入
from redis import Redis
# 创建连接对象
conn = Redis(host='127.0.0.1',port=6379)
# 通过连接对象设置redis缓存
ret = conn.set('name','zhy')
print(conn.get('name')) # zhy

python操作REDIS---连接池

连接池对象(pool)必须是单例的。

import redis
class Pool:
    _instance = None
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = redis.ConnectionPool(host='127.0.0.1',port=6379,max_connections=100)
        return cls._instance
    
    
# 生成连接池对象 
pool = Pool()
# 生成连接对象
conn = redis.Redis(connection_pool=pool)

redis---string操作

设置值

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

ex:设置过期时间
nx:默认是False,如果设置为True的话，表示如果当前key有值的话无法修改当前key对应的value,如果key不存在，则创建新的键值对保存在redis中
xx:默认是False,如果设置为True的话，表示如果key不存在，不会创建新的，如果key存在则更新redis中key对应的数据

ret = conn.set('age',18,ex=10)
ret = conn.set('name1','lxx',nx=True)
ret = conn.set('name1','guigui',xx=True)

• setnx（name,value）:用法与set(key,value,nx=True)相同
• setex(name,time,value) :设置过期时间，如果键存在则修改值，不存在创建值

# name3不存在，就会创建，如果存在则会修改对应的值
ret = conn.setex('name3',10,'xxx')

• psetex(name,time_ms,value)

设置值及过期时间（单位是毫秒）

• mset(*args,**kwargs)：批量设置值

ret = conn.mset({'name':'lx','name2':'doushabao','name3':'haha'})

获取值

• get(name)：通过key获取对应的值

ret = conn.get('name')

• mget( keys, *args):根据key批量获取对应的值

ret = conn.mget('name','name1')

• getset(name,value):设置新值，获取旧值

ret = conn.getset('name','qqq')

• getrange(key, start, end):

根据字节获取子序列，key是redis中设置的key,start是起始位置，end是结束位置

ret = conn.getrange('name',0,1)
# name对应的是qqqq
print(ret)  # qq

• setrange(name, offset, value)

修改字符串内容，从指定字符串索引开始向后替换（新值太长则向后添加）

ret = conn.setrange('name',1,'iiiiiiiiiii')

• strlen(name)

返回name对应值的字节长度

ret = conn.strlen('name')

其他方法

• incr(self, name, amount=1)

key对应的值必须是数字，如果是字符串会报错

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（必须是整数）

• decr(self, name, amount=1)

# 自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
 
# 参数：
    # name,Redis的name
    # amount,自减数（整数

• append(key,vakue)

# 在redis name对应的值后面追加内容
 
# 参数：
    key, redis的name
    value, 要追加的字符串

ret = conn.append('name','00000')

了解方法

• setbit(name, offset, value)

# 对name对应值的二进制表示的位进行操作
 
# 参数：
    # name，redis的name
    # offset，位的索引（将值变换成二进制后再进行索引）
    # value，值只能是 1 或 0
 
# 注：如果在Redis中有一个对应： n1 = "foo"，
        那么字符串foo的二进制表示为：01100110 01101111 01101111
    所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，
        那么最终二进制则变成 01100111 01101111 01101111，即："goo"

• getbit(name,offset)

# 获取name对应的值的二进制表示中的某位的值 （0或1）

• bitcount(key, start=None, end=None)

# 获取name对应的值的二进制表示中 1 的个数
# 参数：
    # key，Redis的name
    # start，位起始位置
    # end，位结束位置

• bittop(key, start=None, end=None)

# 获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
 
# 参数：
    # operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
    # dest, 新的Redis的name
    # *keys,要查找的Redis的name
 
# 如：
    bitop("AND", 'new_name', 'n1', 'n2', 'n3')
    # 获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中

• incrbyfloat(self, name, amount=1.0)

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（浮点型）

redis---hash操作

Hash操作，redis中Hash在内存中的存储格式如下图：

重点掌握

• hset(name,key,value)

name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
 参数：
name，redis的name
   key，name对应的hash中的key
   value，name对应的hash中的value，只能是字符串 整型 浮点型 或者是bytes类型
   注：
 hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）

ret = conn.hset('gae','age',19)

• hmset(name,mapping):在python3.8中被弃用，使用hset即可

在name对应的 hash中批量设置键值对

ret = conn.hmset('xxxxx',{'k1':'v1','k2':'v2'})

• hget(name,mapping)

在name对应的hash中根据key获取value

ret = conn.hget('xxxxx','k1')

• hmget(name,keys,*args)

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

ret = conn.hmget('xxxxx','k1','k2')
ret = conn.hmget('xxxxx',['k1','k2'])

• hincrby(self,name,key,value,amount)

name:redis中设置的name

key:hash中指定key的值

amount:自增数，默认是1

ret1 = conn.hincrby('xxxxx','number',6)

• hscan_iter(name, match=None, count=None)

# 利用yield封装hscan创建生成器，实现分批去redis中获取数据
 
# 参数：
    # match，匹配指定key，默认None 表示所有的key
    # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数

ret = conn.hscan_iter('xxxxx',count=2)
# ret得到的是一个生成器
for i in ret:
    print('------')
    print(i)

了解方法

• hgetall(name)

# 获取name对应hash的所有键值
print(re.hgetall('xxx').get(b'name'))

• 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的键值对删除
print(re.hdel('xxx','sex','name'))

• hincrbyfloat(name, key, amount=1.0)

# 自增name对应的hash中的指定key的值，不存在则创建key=amount
 
# 参数：
    # name，redis中的name
    # key， hash对应的key
    # amount，自增数（浮点数）
 
# 自增name对应的hash中的指定key的值，不存在则创建key=amount

• hscan(name, cursor=0, match=None, count=None)

# 增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆
 
# 参数：
    # name，redis的name
    # cursor，游标（基于游标分批取获取数据）
    # match，匹配指定key，默认None 表示所有的key
    # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
 
# 如：
    # 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
    # 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
    # ...
    # 直到返回值cursor的值为0时，表示数据已经通过分片获取完毕

redis---list操作

List操作，redis中的List在在内存中按照一个name对应一个List来存储。如图：

重要方法

• lpush(self,name,values)

# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
# 如：
    # r.lpush('oo', 11,22,33)
    # 保存顺序为: 33,22,11 
扩展：
    # rpush(name, values) 表示从右向左操作

ret1 = conn.lpush('name',5,6)

• lpushx(name,value)

# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
 
# 更多：
    # rpushx(name, value) 表示从右向左操作

ret = conn.lpushx('name','ooo')

• lpop

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

ret = conn.lpop('name')

• blpop(keys,timeout=0)

keys:可以放name列表，会删除第一个非空的name中列表中的数据，如果timeout=0清空后继续删除name列表中的第二个列表中的数据，以此类推，如果全部为空就会原地阻塞

ret = conn.blpop(['name1','name'], timeout=0)

• lrange

# 在name对应的列表分片获取数据
# 参数：
    # name，redis的name
    # start，索引的起始位置
    # end，索引结束位置  print(re.lrange('aa',0,re.llen('aa')))

ret = conn.lrange('name',0,3)

• llen

name对应的list元素的个数

ret = conn.llen('name')

了解方法

• linsert(name, where, refvalue, value)

# 在name对应的列表的某一个值前或后插入一个新值
 
# 参数：
    # name，redis的name
    # where，BEFORE或AFTER(小写也可以)
    # refvalue，标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
    # value，要插入的数据

• r.lset(name,index,value)

# 对name对应的list中的某一个索引位置重新赋值
 
# 参数：
    # name，redis的name
    # index，list的索引位置
    # value，要设置的值

• r.lrem(name.value,num)

# 在name对应的list中删除指定的值
 
# 参数：
    # name，redis的name
    # value，要删除的值
    # num，  num=0，删除列表中所有的指定值；
           # num=2,从前到后，删除2个；
           # num=-2,从后向前，删除2个

• lindex(name,start,end)

在name对应的列表中根据索引获取列表元素

• ltrim(name.start,end)

# 在name对应的列表中移除没有在start-end索引之间的值
# 参数：
    # name，redis的name
    # start，索引的起始位置
    # end，索引结束位置（大于列表长度，则代表不移除任何）

自定义分批获取链表的数据

def scan_list(name,count=2):
    index = 0
    while True:
        data_list = conn.lrange(name,index,count+index)
        if not data_list:
            return        # 循环完毕，结束
        # 因为lrange是前闭后闭区间
        index += count+1  # 更新取值区间的起点
        for item in data_list:
            yield item   # 每次切片的列表通过生成器依次返回

# 使用
for i in scan_list('name',count=3):
    print(i)

redis其他使用

• delete(name)

conn.delete('name1')
# 删除redis中name对应的所有数据

• exists(name)

conn.exists('name1')

• keys(pattern='*')

ret = conn.keys('name*')
# 查询以name开头的所有的key的名字

• expire(name,time)：为redis中的key设置过期时间

# name:redis中的key
# time:过期时间
ret = conn.expire('name',10)

• type(name):查看redis中key中存储的类型

ret = conn.type('name1')

redis快的原因

• 基于内存
• IO多路复用
• 采用单线程，避免了不必要的上下文切换