名称 | 属性 |
---|---|
set | ex:过期时间(秒) px:过期时间(毫秒) nx:如果设置为True,则只有name不存在时,当前set操作才执行,值存在,就修改不了,执行没效果 xx:如果设置为True,则只有name存在时,当前set操作才执行,值存在才能修改,值不存在,不会设置新值 |
setnx | name,value 设置值 只有name不存在时执行设置操作(添加),如果存在不会修改 |
psetex | name,time_ms,value time_ms过期时间(数字毫秒或timedelta对象) |
mset | *args,**kwargs 批量设置值 mset(k1=‘v1’, k2=‘v2’) 或mget({‘k1’: ‘v1’, ‘k2’: ‘v2’}) |
get | value 获取值 |
mget | keys,*args 批量获取 mget(‘k1’, ‘k2’) |
getset | name value 设置新值并获取原来的值 |
getrange | key, start, end获取子序列(根据字节获取,非字符)name,Redis 的 name,start,起始位置(字节)end,结束位置(字节) 如:“彭于晏”, 0-3表示“彭” |
setrange | name, offset, value修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加) offset:字符串的索引,字节(一个汉字三个字节)value:要设置的值 |
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结束位置 |
strlen | name返回name对应值的字节长度(一个汉字3个字节) |
incr | self, name, amount=1自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。 |
incrbyfloat | self, name, amount=1.0自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。 |
decr | self, name, amount=1自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减。 |
append | key, value在redis name对应的值后面追加内容key, redis的name,value, 要追加的字符串 |
import redis
conn = redis.Redis()
# 1 set(name, value, ex=None, px=None, nx=False, xx=False)
# ex,过期时间(秒)
# px,过期时间(毫秒)
# nx,如果设置为True,则只有name不存在时,当前set操作才执行,值存在,就修改不了,执行没效果
# xx,如果设置为True,则只有name存在时,当前set操作才执行,值存在才能修改,值不存在,不会设置新值
# conn.set('name','lqz') # value 只能是字符串或byte格式
# conn.set('name','lqz',ex=3) # ex 是过期时间,到3s过期,数据就没了
# conn.set('name','lqz',px=3000) # px 是过期时间,到3s过期,数据就没了
# conn.set('age',25,nx=True) # redis 实现分布式锁:https://zhuanlan.zhihu.com/p/489305763
# conn.set('hobby', '足球', xx=False)
# 2 setnx(name, value) 就是:set nx=True
# conn.setnx('hobby1','橄榄球')
# 3 psetex(name, time_ms, value) 本质就是 set px设置时间
# conn.psetex('name',3000,'lqz')
# 4 mset(*args, **kwargs) 传字典批量设置
# conn.mset({'name':'xxx','age':19})
# 5 get(name) 获取值,取到是bytes格式 ,指定:decode_responses=True,就完成转换
# print(conn.get('name'))
# print(str(conn.get('name')[:3],encoding='utf-8'))
# 5 mget(keys, *args) #批量获取
# res=conn.mget('name','age')
# res=conn.mget(['name','age'])
# print(res)
# 6 getset(name, value) # 先获取,再设置
# res=conn.getset('name','lqz')
# print(res)
# 7 getrange(key, start, end) # 取的是字节,前闭后闭区间
# res=conn.getrange('name',0,1)
# print(res)
# 8 setrange(name, offset, value) # 从某个起始位置开始替换字符串
# conn.setrange('name', 1, 'xxx')
# 9 setbit(name, offset, value)
# conn.setbit('name',1,0) #lqz 00000000 00000000 00000000
# res=conn.get('name')
# print(res)
# 10 getbit(name, offset)
# res=conn.getbit('name',1)
# print(res)
# 11 bitcount(key, start=None, end=None)
# print(conn.bitcount('name',0,3)) # 3 指的是3个字符
# 12 strlen(name) # 统计字节长度
# print(conn.strlen('name'))
# print(len('lqz政')) # len 统计字符长度
# 13 incr(self, name, amount=1) # 计数器
# conn.incr('age',amount=3)
# 14 incrbyfloat(self, name, amount=1.0)
# 15 decr(self, name, amount=1)
# conn.decr('age')
# 16 append(key, value)
conn.append('name','nb')
conn.close()
名称 | 属性 |
---|---|
hset | name, key, value,name对应的hash中设置一个键值对(不存在,则创建;否则,修改) name,redis的name,key,name对应的hash中的key,value,name对应的hash中的value |
hmset | name, mapping,在name对应的hash中批量设置键值对,如:r.hmset(‘xx’, {‘k1’:‘v1’, ‘k2’: ‘v2’}) |
hget | name,key 在name对应的hash中获取根据key获取value |
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 *key 将name对应的hash中指定key的键值对删除 如:print(re.hdel(‘xxx’,‘sex’,‘name’)) |
hincrby | name key amount=1 自增name对应的hash中的指定key的值,不存在则创建key=amount |
hincrbyfloat | name, key, amount=1.0 自增name对应的hash中的指定key的值,不存在则创建key=amount |
hscan | name, cursor=0, match=None, count=None增量式迭代获取,对于数据大的数据非常有用,hscan 可以实现分片的获取数据,并非一次性将数据全部获取完,从而放置内存被撑爆 cursor:游标(基于游标分批取获取数据),match:匹配指定key,默认None 表示所有的key,count:每次分片最少获取个数,默认None表示采用Redis的默认分片个数,直到返回值cursor的值为0时,表示数据已经通过分片获取完毕 |
hscan_iter | name, match=None, count=None,利用yield封装hscan创建生成器,实现分批去redis中获取数据 match:匹配指定key,默认None 表示所有的key,count:每次分片最少获取个数,默认None表示采用Redis的默认分片个数 如:for item in r.hscan_iter(‘xx’):print(item) |
### redis 只支持一层的5大数据类型
import redis
conn = redis.Redis(decode_responses=True)
# 1 hset(name, key, value)
# conn.hset('userinfo', 'name', '彭于晏')
# conn.hset('userinfo', 'age', '32')
# conn.hset('xx',mapping={'name':'xxx','hobby':'篮球'})
# 2 hmset(name, mapping) 弃用了
# conn.hmset('yy',{'a':'a','b':'b'})
# 3 hget(name,key)
# res=conn.hget('userinfo','age')
# print(res)
# 4 hmget(name, keys, *args)
# res=conn.hmget('userinfo',['name','age'])
# print(res)
# 5 hgetall(name) 慎用,可能会造成 阻塞 尽量不要在生产代码中执行它
# res=conn.hgetall('userinfo')
# print(res)
# 6 hlen(name)
# res=conn.hlen('userinfo')
# print(res)
# 7 hkeys(name)
# res=conn.hkeys('userinfo')
# print(res)
# 8 hvals(name)
# res=conn.hvals('userinfo')
# print(res)
# 9 hexists(name, key)
# res=conn.hexists('userinfo','name')
# print(res)
# 10 hdel(name,*keys)
# conn.hdel('userinfo','age')
# 11 hincrby(name, key, amount=1)
# conn.hincrby('userinfo','age')
# 12 hincrbyfloat(name, key, amount=1.0)
# conn.hincrbyfloat('userinfo','age',5.44)
## 联合起来讲:不建议使用hgetall,分片取值
# 分批获取 生成器应用在哪了?
# 13 hscan(name, cursor=0, match=None, count=None)
# hash类型没有顺序---》python字典 之前没有顺序,3.6后有序了 python字段的底层实现
# for i in range(1000):
# conn.hset('test_hash','key_%s'%i,'鸡蛋%s号'%i)
# count 是要取的条数,但是不准确,有点上下浮动
# 它一般步单独用
# res=conn.hscan('test_hash',cursor=0,count=19)
# print(res)
# print(res[0])
# print(res[1])
# print(len(res[1]))
# res=conn.hscan('test_hash',cursor=res[0],count=19)
# print(res)
# print(res[0])
# print(res[1])
# print(len(res[1]))
# 咱么用它比较多,它内部封装了hscan,做成了生成器,分批取hash类型所有数据
# 14 hscan_iter(name, match=None, count=None) 获取所有hash的数据
res = conn.hscan_iter('test_hash',count=100)
print(res) # 生成器
for item in res:
print(item)
conn.close()
名称 | 属性 |
---|---|
lpush | name,values,在name对应的list中添加元素,每个新的元素都添加到列表的最左边 如:r.lpush(‘oo’, 11,22,33)保存顺序是33,22,11 |
lpushx | name,value,在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边 |
rpushx | name,value,在name对应的list中添加元素,只有name已经存在时,值添加到列表的最右边 |
llen | name, name对应的list元素的个数 |
linsert | name,where,refvalue,value在name对应的列表的某一个值前或后插入一个新值 name>redis的name,where>BEFORE或AFTER(小写也可以),refvalue>标杆值,即:在它前后插入数据(如果存在多个标杆值,以找到的第一个为准),value>要插入的数据 |
lset | name, index, value对name对应的list中的某一个索引位置重新赋值 name>redis的name,index>list的索引位置,value>要设置的值 |
lrem | name,value,num在name对应的list中删除指定值 name>redis的name,value>要删除的值,num0表示所有,2表示从前往后删除2个,-2表示从后往前删除2个 |
lpop | name在name对应的列表的左侧获取第一个元素并在列表中移除,返回值则是第一个元素 |
lindex | name,index在name对应的列表中根据索引获取列表元素 |
lrange | name,start,end在name对应的列表分片获取数据如:print(re.lrange(‘aa’,0,re.llen(‘aa’))) |
ltrim | name,start,end在name对应的列表中移除没有在start-end索引之间的值 |
rpoplpush | src,dst,从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边 |
blpop | keys,timeout将多个列表排列,按照从左到右去pop对应列表的元素,kews表示redis中name的集合 timeout,超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞 |
brpoplpush | src,dst,timeout=0从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧 |
自定义增量迭代
由于redis类库中没有提供对列表元素的增量迭代,如果想要循环name对应的列表的所有元素,那么就需要:
import redis
conn=redis.Redis(host='127.0.0.1',port=6379)
# conn.lpush('test',*[1,2,3,4,45,5,6,7,7,8,43,5,6,768,89,9,65,4,23,54,6757,8,68])
# conn.flushall()
def scan_list(name,count=2):
index=0
while True:
data_list=conn.lrange(name,index,count+index-1)
if not data_list:
return
index+=count
for item in data_list:
yield item
print(conn.lrange('test',0,100))
for item in scan_list('test',5):
print('---')
print(item)
关于管道在市面上有问多问题例如:Redis数据库,是否支持事务?
Redis-py默认在执行每次请求都会创建(连接池申请连接)和断开(归还连接池)一次连接操作,如果想要在一次请求中指定多个命令,则可以使用pipline实现一次请求指定多个命令,并且默认情况下一次pipline 是原子性操作。
Redis事务机制可以保证一致性和隔离性,无法保证持久性,但是对于redis而言,本身是内存数据库,所以持久化不是必须属性。原子性需要自己进行检查,尽可能保证
Redis 不像mysql一样,支持强事务,事务的四大特性不能全部满足,但是能满足一部分,通过redis的管道实现的(redis本身不支持事务,但是可以通过管道,实现部分事务)
Redis 通过管道,来保证命令要么都成功,要么都失败,完成事务的一致性,但是管道只能用在单实例,集群环境中,不支持pipline
import redis
conn = redis.Redis()
pipline = conn.pipeline(transaction=True)
pipline.decr('a', 2) # a减2
raise Exception('我崩了')
pipline.incr('b', 2) # b加2
pipline.execute() # 保持了事物的一致性 a-2 b没成功!所以都没修改
conn.close()
名称 | 属性 |
---|---|
delete | name根据删除redis中的任意数据类型 |
exists | name检测redis中的name是否存在 |
keys | pattern=* 根据模型获取redis的name |
expire | name,time为某个redis的某个name设置超时时间 |
rename | src,dst, 对redis的name重命名为 |
move | name,db,将redis的某个值移动到指定的db下 |
randomkey | 随机获取一个redis的name(不删除) |
type | name获取name对应值的类型 |
# 集合,有序集合 --- redis模块提供的方法API
# 通用操作:无论是5大类型的那种,都支持
import redis
conn = redis.Redis()
# 1 delete(*names)
# conn.delete('age', 'name')
# 2 exists(name)
# res=conn.exists('xx')
# print(res) # 0
# 3 keys(pattern='*')
# res=conn.keys('*o*')
# res=conn.keys('?o*')
# print(res)
# 4 expire(name ,time)
# conn.expire('test_hash',3)
# 5 rename(src, dst) # 对redis的name重命名为
# conn.rename('xx','xxx')
# 6 move(name, db) # 将redis的某个值移动到指定的db下
# 默认操作都是0 库,总共默认有16个库
# conn.move('xxx',2)
# 7 randomkey() 随机获取一个redis的name(不删除)
# res=conn.randomkey()
# print(res)
# 8 type(name) 查看类型
# res = conn.type('aa') # list hash set
# print(res)
conn.close()
方式一:直接使用
from script.POOL import pool
import redis
def index(request):
conn = redis.Redis(connection_pool=pool)
conn.incr('page_view')
res = conn.get('page_view')
return HttpResponse('被你Look Me %s次了' % res)
pool = redis.ConnectionPool(max_connections=100, host='127.0.0.1', port=6379)
方式二:使用第三方模块:django-redis
配置文件配置
CACHES = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/0",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
"CONNECTION_POOL_KWARGS": {"max_connections": 100}
# "PASSWORD": "123",
}
}
}
from django_redis import get_redis_connection
def index(request):
conn = get_redis_connection(alias="default") # 每次从池中取一个链接
conn.incr('page_view')
res = conn.get('page_view')
return HttpResponse('被你看了%s次' % res)
方式三:借助于django的缓存使用redis
-如果配置文件中配置了 CACHES ,以后django的缓存,数据直接放在redis中
-以后直接使用cache.set 设置值,可以传过期时间
-使用cache.get 获取值
-强大之处在于,可以直接缓存任意的python对象,底层使用pickle实现的
Celery翻译过来叫芹菜 它是一个分布式的异步任务 框架
Celery有什么用?
架构
技术小白记录学习过程,有错误或不解的地方请指出,如果这篇文章对你有所帮助请
点点赞收藏+关注谢谢支持
!!!