redis列表操作
lpush(name,values)
"""
1.在name对应的list中添加元素，每个新的元素都添加到列表的最左边
2.ps：
r.lpush('oo', 11,22,33)
保存顺序为: 33,22,11
3.扩展：
rpush(name, values) 表示从右向左操作
"""
conn.lpush('hobby','篮球')
conn.lpush('hobby','足球')
conn.lpush('hobby','网球')
ps：[网球,足球,篮球]
conn.rpush('hobby','乒乒球')
ps：[网球,足球,篮球，乒乒球]
lpushx(name,value)
"""
1.在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
2.更多：
rpushx(name, value) 表示从右向左操作
"""
# 只有key存在才能插入，从左侧插入
conn.lpushx('name','nana') # 没有反应
conn.lpushx('hobby','橄榄球')
ps：[橄榄球，网球,足球,篮球，乒乒球]
conn.rpushx('name','nana') # 没有反应
conn.rpushx('hobby','球')
ps：[橄榄球，网球,足球,篮球，乒乒球，球]
llen(name)
name对应的list元素的个数
res = conn.llen('hobby')
print(res) # 6
linsert(name, where, refvalue, value))
"""
1.在name对应的列表的某一个值前或后插入一个新值
2.参数：
name，redis的name
where，BEFORE或AFTER(小写也可以)
refvalue，标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
value，要插入的数据
"""
conn.linsert('hobby','before','篮球','排球1')
conn.linsert('hobby','after','篮球','排球2')
ps：[橄榄球，网球,足球,排球1,篮球，排球1,乒乒球，球]
r.lset(name, index, value)
"""
1.对name对应的list中的某一个索引位置重新赋值
2.参数：
name，redis的name
index，list的索引位置
value，要设置的值
"""
conn.lset('hobby',1,'球球')
ps：[橄榄球，球球,足球,排球1,篮球，排球1,乒乒球，球]
r.lrem(name, value, num)
"""
1.在name对应的list中删除指定的值
2.参数：
name，redis的name
value，要删除的值
num， num=0，删除列表中所有的指定值；
num=2,从前到后，删除2个；
num=-2,从后向前，删除2个
"""
conn.lrem('hobby',0,'橄榄球') # 0 表示全删除
conn.lrem('hobby',2,'足球') # # 正数表示从左侧删除
conn.lrem('hobby',-1,'篮球') # # 负数表示从右侧删除
lpop(name)
"""
1.在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
2.更多：
rpop(name) 表示从右向左操作
"""
res = conn.lpop('hobby')
print(res) # 篮球 弹出并删除
res = conn.rpop('hobby')
print(res) # 球
lindex(name, index)
在name对应的列表中根据索引获取列表元素
print(conn.lindex('hobby', 2)) ## 球球
lrange(name, start, end)
"""
1.在name对应的列表分片获取数据
2.参数：
name，redis的name
start，索引的起始位置
end，索引结束位置 print(re.lrange('aa',0,re.llen('aa')))
"""
res = conn.lrange('hobby',2,5) # 前闭后闭区间
print(res) # ['球球', '排球1', '排球2', '乒乒球']
ltrim(name, start, end)
"""
1.在name对应的列表中移除没有在start-end索引之间的值
2.参数：
name，redis的name
start，索引的起始位置
end，索引结束位置（大于列表长度，则代表不移除任何）
"""
conn.ltrim('hobby',2,5)
print(conn.lrange('hobby',0,1000)) # ['球球', '排球1', '排球2', '乒乒球']
rpoplpush(src, dst)
"""
1.从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
2.参数：
src，要取数据的列表的name
dst，要添加数据的列表的name
"""
res =conn.rpoplpush('name','hobby')
print(res) # 'nana'
print(conn.lrange('hobby',0,1000)) # ['nana', '球球', '排球1', '排球2', '乒乒球']
blpop(keys, timeout)
"""
1.将多个列表排列，按照从左到右去pop对应列表的元素
2.参数：
# keys，redis的name的集合
# timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
3.更多：
# r.brpop(keys, timeout)，从右向左获取数据
"""
爬虫实现简单分布式：多个url放到列表里，往里不停放URL，程序循环取值，但是只能一台机器运行取值，可以把url放到redis中，多台机器从redis中取值，爬取数据，实现简单分布式
res = conn.blpop('hobby',timeout=3)
*******************************
import redis
conn = redis.Redis()
conn.lpush('hobby','xx')
conn.close()
brpoplpush(src, dst, timeout=0)
1.从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
2.参数：
# src，取出并要移除元素的列表对应的name
# dst，要插入元素的列表对应的name
# timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
自定义增量迭代
1.由于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)
需求：一次性把列表中所有数据取出来
for i in range(1000):
conn.lpush('eggs','鸡蛋%s号'%i)
方式一：
l=conn.llen('eggs')
res = conn.lrange('eggs',0,l)
print(res)
方式二:
def l_scan_item(key,num=10):
count = 0
while True:
res = conn.lrange(key,count,count+num-1)
if res:
print('-----------')
count +=num
for item in res:
yield item
else:
break
for i in l_scan_item('eggs'):
print(i)
redis其他操作
delete(*names)
根据删除redis中的任意数据类型
conn.delete('eggs','hobby111')
exists(name)
检测redis的name是否存在
res= conn.exists('hobby')
print(res) # 0
keys(pattern='*')
"""
1.根据模型获取redis的name
2.更多：
# KEYS * 匹配数据库中所有 key 。
# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
# KEYS h*llo 匹配 hllo 和 heeeeello 等。
# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
"""
res = conn.keys('*')
print(res) # ['hobby', 'age', 'name']
expire(name ,time)
为某个redis的某个name设置超时时间
conn.expire('hobby',3)
rename(src, dst)
# 对redis的name重命名为
conn.rename('name',"name11")
move(name, db))
将redis的某个值移动到指定的db下
conn.move('name11',3)
randomkey()
随机获取一个redis的name（不删除）
print(conn.randomkey())
type(name)
获取name对应值的类型
print(conn.type('name')) # string
scan(cursor=0, match=None, count=None) scan_iter(match=None, count=None)
同字符串操作，用于增量迭代获取key
redis管道
1.事务四大特性
1.原子性：要么都成功，要么都失败
2.一致性：数据前后要一致
3.隔离性：多个事务之间相互不影响
4.持久性：事务一旦完成，数据永久改变
2.redis 有没有事务？单实例redis支持事务
1.redis要支持事务，要完成事务的几大特性，需要使用管道来支持
2.单实例redis是支持管道的
3.集群模式下，不支持管道，就不支持事务
3.redis通过管道实现事务
import redis
conn = redis.Redis()
pipline = conn.pipeline(transaction=True)
pipline.decrby('a1',10) # 没有真正执行，把命令先放到管道中
raise Exception('出错了')
pipline.incrby('a2',10)
pipline.execute() # 把管道中的命令，一次性执行
conn.close()
Django中使用redis
方式一
自定义的通用方案（跟框架无关）
1.写一个py文件：redis_pool.py
import redis
POOL=redis.ConnectionPool(max_connections=10)
2.在用的位置，导入直接使用
conn = redis.Redis(connection_pool=POOL)
conn.incrby('a1')
"""
import redis
from utils.redis_pool import POOL
class RedisTest(APIView):
def get(self,request):
conn=redis.Redis(connection_pool=POOL)
conn.incrby('a1',10)
return APIResponse()
"""
方式二
django中有个模块，django-redis，方便我们快速集成redis
1.下载：pip install django-redis
2.配置文件配置：
CACHES = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
"CONNECTION_POOL_KWARGS": {"max_connections": 100}
# "PASSWORD": "123",
}
}
}
3.在使用的地方，导入直接使用
from django_redis import get_redis_connection
class RedisTest(APIView):
def get(self,request):
conn = get_redis_connection() # # 从连接池中拿出一个链接
conn.incrby('a1')
conn.set('name', '彭于晏')
return APIResponse()
django缓存
1.django是大而全的框架，内置了很多web开发需要的东西，缓存内置了
2.缓存：可以把django中的一个变量(数据)，存放到某个位置，下次还可以取出来
3.之前用过：默认放在：内存中，其实可以放在文件中，数据库，redis
from django.core.cache import cache
class RedisTest(APIView):
def get(self,request):
cache.set('age', 11)
return APIResponse()
3.通过配置，控制存放在哪，只要如下写，就会放在redis中
CACHES = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
"CONNECTION_POOL_KWARGS": {"max_connections": 100}
# "PASSWORD": "123",
}
}
}
4.django缓存最强大之处在于，只要是python的变量，任意类型都可以，尽管使用set设置值
from django.core.cache import cache
class MyResponseView(APIView):
def get(self, request):
# cache.set('age', 19, 10) # 现在放在redis中
l = [1, 'lqz', [1, 3, 4, 5, 6], '彭于晏']
# conn = get_redis_connection()
# conn.lpush('l1',[1,2,3]) # 存放json格式字符串。要做序列化
cache.set('ll1', l)
return APIResponse()
5.以后再django中往redis放数据，就用cache即可
6.redis的5大数据类型，只支持一层
看一下这篇文章：https://www.cnblogs.com/liuqingzheng/articles/9803351.html
补充
设置缓存后娶不到的问题：要设置在redis中，才不会找不到
celery介绍
1.项目中如果想用
1.异步任务(开启线程，不好管理）
2.定时任务
3.延迟任务
2.借助于第三方框架，celery：芹菜，吉祥物，可以实现上面的三个功能
http://www.celeryproject.org/
3.分布式的异步任务框架 celery
