luffy商城项目第九天
- redis简介
-
redis字符串操作
-
redis hash操作
-
redis列表操作
-
redis管道
-
redis其他操作
-
django中集成redis
-
celery介绍
redis简介
redis有五大数据类型：字符串，列表，hash，集合，有序集合
图形化客户端：redis-desktop-manage
redis字符串操作
主要的api：操作字符串的方法
记住的：get set strlen
1 set(name, value, ex=None, px=None, nx=False, xx=False)
2 setnx(name, value)
3 psetex(name, time_ms, value)
4 mset(*args, **kwargs)
5 get(name)
6 mget(keys, *args)
7 getset(name, value)
8 getrange(key, start, end)
9 setrange(name, offset, value)
10 setbit(name, offset, value)
11 getbit(name, offset)
12 bitcount(key, start=None, end=None)
13 strlen(name)
14 incr(self, name, amount=1)
15 incrbyfloat(self, name, amount=1.0)
16 decr(self, name, amount=1)
17 append(key, value)1 set(name, value, ex=None, px=None, nx=False, xx=False)
ex=过期时间（秒）
px=过期时间（毫秒）
nx=如果为True，内存中有数据则不执行该操作
xx=如果为True，内存中有数据则执行该操作
# 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'))6 mget(keys, *args)
批量获取
# res=conn.mget('name','age')
# res=conn.mget(['name','age'])
# print(res)7 getset(name, value)
先获取，再设置
# res=conn.getset('name','lqz')
# print(res)8 getrange(key, start, end)
取的是字节，前闭后闭区间
# res=conn.getrange('name',0,1)
# print(res)9 setrange(name, offset, value)
从某个起始位置开始替换字符串
# conn.setrange('name', 1, 'xxx')10 setbit(name, offset, value)
对应值的二进制表示的位进行操作
# conn.setbit('name',1,0) #lqz 00000000 00000000 00000000
# res=conn.get('name')
# print(res)
注：如果在Redis中有一个对应： n1 = "foo"，
那么字符串foo的二进制表示为：01100110 01101111 01101111
所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，
那么最终二进制则变成 01100111 01101111 01101111，即："goo"11 getbit(name, offset)
获取name对应的值的二进制表示中的某位的值 （0或1）
# res=conn.getbit('name',1)
# print(res)12 bitcount(key, start=None, end=None)
获取name对应的值的二进制表示中 1 的个数
# 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操作
记住：hset hget hexists hincrby hlen
1 hset(name, key, value)
2 hmset(name, mapping)
3 hget(name,key)
4 hmget(name, keys, *args)
5 hgetall(name)
6 hlen(name)
7 hkeys(name)
8 hvals(name)
9 hexists(name, key)
10 hdel(name,*keys)
11 hincrby(name, key, amount=1)
12 hincrbyfloat(name, key, amount=1.0)
13 hscan(name, cursor=0, match=None, count=None)
14 hscan_iter(name, match=None, count=None)### redis 只支持一层的5大数据类型
import redis
conn = redis.Redis(decode_responses=True)1 hset(name, key, value)
name对应的hash中设置一个键值对（不存在，则创建，否则修改）
# conn.hset('userinfo', 'name', '彭于晏')
# conn.hset('userinfo', 'age', '32')
# conn.hset('xx',mapping={'name':'xxx','hobby':'篮球'})2 hmset(name,mapping)
在name对应的hash中批量设置键值对
# conn.hmset('yy',{'a':'a','b':'b'})3 hget(name,key)
在name对应的hash中获取根据key获取value
# res=conn.hget('userinfo','age')
# print(res)4 hmget(name,keys,*args)
在name对应的hash中获取多个key的值
# res=conn.hmget('userinfo',['name','age'])
# print(res)5 hgetall(name)
获取name对应hash的所有键值
print(re.hgetall('xxx').get(b'name'))6 hlen(name)
获取name对应的hash中键值对的个数
# res=conn.hlen('userinfo')
# print(res)7 hkeys(name)
获取name对应的hash中所有的key的值
# res=conn.hkeys('userinfo')
# print(res)8 hvals(name)
获取name对应的hash中所有的value的值
# res=conn.hvals('userinfo')
# print(res)9 hexists(name,key)
检查name对应的hash是否存在当前传入的key
# res=conn.hexists('userinfo','name')
# print(res)10 hdel(name,*key)
将name对应的hash中指定key的键值对删除
# conn.hdel('userinfo','age')11 hincrby(name,key,amount=1)
自增name对应的hash中的指定key的值，不存在则创建key=amount
# conn.hincrby('userinfo','age'，amount=自增数)12 hincrbyfloat(name,key,amount=1.0)
自增name对应的hash中的指定key的值，不存在则创建key=amount(小数)
# conn.hincrbyfloat('userinfo','age',5.44)13 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时，表示数据已经通过分片获取完毕14 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
## 联合起来讲：不建议使用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列表操作
1 lpush(name,values)
2 lpushx(name,value)
3 rpushx(name, value) 表示从右向左操作
4 llen(name)
5 linsert(name, where, refvalue, value))
6 lset(name, index, value)
7 lrem(name, value, num)
8 lpop(name)
9 lindex(name, index)
10 lrange(name, start, end)
11 ltrim(name, start, end)
12 rpoplpush(src, dst)
13 blpop(keys, timeout)
14 brpoplpush(src, dst, timeout=0)
15 自定义增量迭代1 lpush(name,values)
在name对应的list中添加元素，每个新的元素都添加在列表的最左边
# r.lpush('oo', 11,22,33)
# 保存顺序为: 33,22,11
# rpush(name, values) 表示从右向左操作2 lpushx(name,value)
在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
# rpushx(name, value) 表示从右向左操作3 llen(name)
name对应的list元素的个数
4 linsert(name,where,refvalue,value)
在name对应的列表的某一个值前或后插入一个新值
# 参数：
# name，redis的name
# where，BEFORE或AFTER(小写也可以)
# refvalue，标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
# value，要插入的数据5 r.lset(name,index,value)
对name对应的list中的某一个索引位置重写赋值
# 参数：
# name，redis的name
# index，list的索引位置
# value，要设置的值6 r.lrem(name,value,num)
在name对应的list中删除指定的值
# 参数：
# name，redis的name
# value，要删除的值
# num， num=0，删除列表中所有的指定值；
# num=2,从前到后，删除2个；
# num=-2,从后向前，删除2个7 lpop(name)
在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
# rpop(name) 表示从右向左操作8 lindex(name,index)
在name对应的列表中根据索引获取列表元素
9 lrange(name.start,end)
在name对应的列表分片获取数据
# 参数：
# name，redis的name
# start，索引的起始位置
# end，索引结束位置 print(re.lrange('aa',0,re.llen('aa')))10 ltrim(name,start,end)
在name对应的列表中移除没有在start-end索引之间的值
# 参数：
# name，redis的name
# start，索引的起始位置
# end，索引结束位置（大于列表长度，则代表不移除任何）11 rpoplpush(src,dst)
从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
# 参数：
# src，要取数据的列表的name
# dst，要添加数据的列表的name12 blpop(src,dst)
将多个列表排列，按照从左往右取pop对应列表的元素
# 参数：
# keys，redis的name的集合
# timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
# 更多：
# r.brpop(keys, timeout)，从右向左获取数据
爬虫实现简单分布式：多个url放到列表里，往里不停放URL，程序循环取值，但是只能一台机器运行取值，可以把url放到redis中，多台机器从redis中取值，爬取数据，实现简单分布式13 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管道
# mysql事务：四大特性 事务的隔离级别 mysql5.7 默认的隔离级别是什么
# redis：redis数据库，是否支持事务？
-支持
-不支持
# 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()
conn.close()redis其他操作
# 集合，有序集合 --- 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()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实现的celery介绍
# celery：翻译过来叫芹菜，它是一个 分布式的异步任务 框架
# celery有什么用？
1 完成异步任务：可以提高项目的并发量，之前开启线程做，现在使用celery做
2 完成延迟任务
3 完成定时任务
# 架构
-消息中间件：broker 提交的任务（函数）都放在这里，celery本身不提供消息中间件，需要借助于第三方：redis，rabbitmq
-任务执行单元：worker，真正执行任务的地方，一个个进程，执行函数
-结果存储：backend，函数return的结果存储在这里，celery本身不提供结果存储，借助于第三方：redis，数据库，rabbitmq
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）