今日内容概要
- redis字符串操作
- redis hash操作
- redis列表操作
- redis其他操作
- redis管道
- django中集成redis
- celery介绍
今日内容详细
# 装了图形化客户端redis-desktop-manage
qt5:
QT平台:可以写图形化界面
python:pyqt5写图形化界面 GUI开发
redis字符串操作
redis:5大数据类型--->字符串,链表,hash,集合,有序集合
redis支持5大数据类型,只支持到一层,第二层必须是字符串
Memcached:只支持字符串,都是纯内存,断电数据丢失,redis可以持久化
# String操作,redis中的String在在内存中按照一个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', 'wjl') # value只能是字符串或byte格式
conn.set('name','wjl',ex=3) # ex 是过期时间,到3s过期,数据就没了
conn.set('name','wjl',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) # 设置值,只有name不存在时,执行设置操作(添加),如果存在,不会修改
conn.setnx('hobby', '橄榄球')
3 psetex(name, time_ms, value) # 本质就是set px设置时间
conn.psetex('name', 3000, 'wjl')
4 mset(*args, **kwargs) # 传字典批量设置
conn.mset({'name': 'wjl', 'age': 19})
5 get(name) # 获取值,取到是bytes格式,指定:decode_responses=Ture, 就完成转换
print(conn.get('name'))
print(str(conn.get('name')[:3],encoding='utf-8'))
6 mget(keys, *args) # 批量获取
res=conn.mget('name','age')
res=conn.mget(['name','age'])
print(res)
7 getset(name, value) # 先获取,再设置
res = conn.getset('name', 'wjl')
print(res)
8 getrange(key, start, end) # 获取子序列(根据字节获取,非字符)取得是字节,前闭后闭区间
res = conn.getrange('name', 0, 1)
print(res)
9 setrange(name, offset, value) # 修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加)
conn.setrange('name', 1, 'wjl')
10 setbit(name, offset, vavlue) # 对name对应值的二进制表示的位进行操作
conn.setbit('name',1,0) #wjl 00000000 00000000 00000000
res=conn.get('name')
print(res)
11 getbit(name, offset) # 获取name对应的值的二进制表示中的某位的值 (0或1)
res=conn.getbit('name', 1)
print(res)
12 bitcount(key, start=None, end=None)
print(conn.bitcount('name',0,3)) # 3 指的是3个字符
13 strlen(name) # 统计字节长度
print(conn.strlen('name'))
print(len('lqz政')) # len 统计字符长度
14 incr(self, name, amount=1) # 计数器
conn.incr('age',amount=3)
15 incrbyfloat(self, name, amount=1.0) # 自增 name对应的值,当name不存在时,则创建name=amount,否则自增。
16 decr(self, name, amount=1) # 自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减。
conn.decr('age')
17 append(key, value) # 在redis name对应的值后面追加内容
conn.append('name','nb')
conn.close()
redis hash操作
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()
redis列表操作
# List操作,redis中的List在在内存中按照一个name对应一个List来存储。
lpush(name,values)
# 在name对应的list中添加元素,每个新的元素都添加到列表的最左边
# 如:
# r.lpush('oo', 11,22,33)
# 保存顺序为: 33,22,11
# 扩展:
# rpush(name, values) 表示从右向左操作
lpushx(name,value)
# 在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边
# 更多:
# rpushx(name, value) 表示从右向左操作
llen(name)
# name对应的list元素的个数
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个
lpop(name)
# 在name对应的列表的左侧获取第一个元素并在列表中移除,返回值则是第一个元素
# 更多:
# rpop(name) 表示从右向左操作
lindex(name, index)
在name对应的列表中根据索引获取列表元素
lrange(name, start, end)
# 在name对应的列表分片获取数据
# 参数:
# name,redis的name
# start,索引的起始位置
# end,索引结束位置 print(re.lrange('aa',0,re.llen('aa')))
ltrim(name, start, end)
# 在name对应的列表中移除没有在start-end索引之间的值
# 参数:
# name,redis的name
# start,索引的起始位置
# end,索引结束位置(大于列表长度,则代表不移除任何)
rpoplpush(src, dst)
# 从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
# 参数:
# src,要取数据的列表的name
# dst,要添加数据的列表的name
blpop(keys, timeout)
# 将多个列表排列,按照从左到右去pop对应列表的元素
# 参数:
# keys,redis的name的集合
# timeout,超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞
# 更多:
# r.brpop(keys, timeout),从右向左获取数据爬虫实现简单分布式:多个url放到列表里,往里不停放URL,程序循环取值,但是只能一台机器运行取值,可以把url放到redis中,多台机器从redis中取值,爬取数据,实现简单分布式
brpoplpush(src, dst, timeout=0)
# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
# 参数:
# src,取出并要移除元素的列表对应的name
# dst,要插入元素的列表对应的name
# timeout,当src对应的列表中没有数据时,阻塞等待其有数据的超时时间(秒),0 表示永远阻塞
自定义增量迭代
# 由于redis类库中没有提供对列表元素的增量迭代,如果想要循环name对应的列表的所有元素,那么就需要:
# 1、获取name对应的所有列表
# 2、循环列表
# 但是,如果列表非常大,那么就有可能在第一步时就将程序的内容撑爆,所有有必要自定义一个增量迭代的功能:
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模块提供的方法API
# 通用操作:无论是5大类型的那种,都支持
import redis
conn = redis.Redis()
1 delete(*names) # 根据删除redis中的任意数据类型
conn.delete('age', 'name')
2 exists(name) # 检测redis的name是否存在
res=conn.exists('xx')
print(res) # 0
3 keys(pattern='*') # 根据模型获取redis的name
res=conn.keys('*o*')
res=conn.keys('?o*')
print(res)
4 expire(name ,time) # 为某个redis的某个name设置超时时间
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) # 获取name对应值的类型
res = conn.type('aa') # list hash set
print(res)
9 scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None) # 同字符串操作,用于增量迭代获取key
conn.close()
redis管道
redis:redis数据库,是否支持事务?
redis事务机制可以保证一致性和隔离性,无法保证持久性,但是对于redis而言,本身是内存数据库,所以持久化不是必须属性。原子性需要自己进行检查,尽可能保证。
redis 不像mysql一样,支持强事务,事务的四大特性不能全部满足,但是能满足一部分,通过redis的管道实现的,redis本身不支持事务,但是可以通过管道,实现部分事务。
redis通过管道,来保证命令要么都成功,要么都失败,完成事务的一致性,但是管道只能用在单实例,集群环境中,不支持管道。
import redis
conn = redis.Redis()
# 创建管道
pipline = conn.pipeline(transaction=True)
pipline.decr('a', 2) # a减2
raise Exception('我崩了')
pipline.incr('b', 2) # b加2
# 到此是往管道中放了命令,还没执行,直到下面的命令
pipe.execute() # 一次性执行管道中的所有命令
conn.close()
django中集成redis
# 方式一:直接使用
from user.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('被你看了%s次' % res)
# 方式二:使用第三方模块: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实现的
class Person:
pass
from django.core.cache import cache
def index(request):
# cache.set('pv', '10', 3) # 之前缓存在内存中,现在缓存在redis中
# 缓存强大在,可以缓存任意的python数据类型
p = Person()
p.name = 'lqz'
cache.set('p', p)
return HttpResponse('把p缓存起来了')
def test(request):
p=cache.get('p')
print(p.name)
return HttpResponse('把p取出来了')
celery介绍
# celery:翻译过来叫芹菜,它是一个 分布式的异步任务 框架
# celery有什么用?
1 完成异步任务:可以提高项目的并发量,之前开启线程做,现在使用celery做
2 完成延迟任务
3 完成定时任务
# 架构
-消息中间件:broker 提交的任务(函数)都放在这里,celery本身不提供消息中间件,需要借助于第三方:redis,rabbitmq
-任务执行单元:worker,真正执行任务的地方,一个个进程,执行函数
-结果存储:backend,函数return的结果存储在这里,celery本身不提供结果存储,借助于第三方:redis,数据库,rabbitmq