内容概览
- redis图形化客户端
- redis字符串操作
- redis hash操作
- redis列表操作
- redis管道
- redis其他操作
- django中集成redis
- celery介绍
redis图形化客户端
安装图形化客户端redis-desktop-manager
新版本收费，可以使用老版本
QT平台：可以写图形化界面
python：pyqt5写图形化界面 GUI开发
redis字符串操作
redis有五大数据类型：字符串，hash，列表，集合，有序集合
| 方法 | 说明 |
|---|---|
| set(name, value, ex=None, px=None, nx=False, xx=False) | 设置值 |
| setnx(name, value) | 设置带有过期时间的值(s) |
| psetex(name, time_ms, value) | 设置带有过期时间的值(ms) |
| mset(*args, **kwargs) | 批量设置值 |
| get(name) | 获取值 |
| mget(keys, *args) | 批量获取值 |
| getset(name, value) | 获取并设置值 |
| getrange(key, start, end) | 获取子序列（根据字节获取，非字符） |
| setrange(name, offset, value) | 修改字符串内容，从指定字符串索引开始向后替换 |
| setbit(name, offset, value) | 对name对应值的二进制表示的位进行操作 |
| getbit(name, offset) | 获取name对应的值的二进制表示中的某位的值 |
| bitcount(key, start=None, end=None) | 获取name对应的值的二进制表示中 1 的个数 |
| bitop(operation, dest, *keys) | 获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值 |
| strlen(name) | 返回name对应值的字节长度 |
| incr(self, name, amount=1) | 自增整数 |
| incrbyfloat(self, name, amount=1.0) | 自增浮点数 |
| decr(self, name, amount=1) | 自减 |
| append(key, value) | 追加 |
最常用的：get、set、strlen
import redis
conn = redis.Redis()
"""String操作"""
# set(name, value, ex=None, px=None, nx=False, xx=False)
conn.set('name', 'yyy', ex=3) # 3秒后过期
conn.set('name', 'yyy', px=3000) # 3000毫秒后过期
conn.set('name', 'xxx', nx=True) # True表示当name不存在时创建;存在不会修改
conn.set('age', '18', xx=True) # True表示当age存在时修改;不存在不会新增
# setnx(name, value)
conn.setnx('name', 'yyyy') # 等同于conn.setnx('name', 'yyyy', nx=True)
# setex(name, value, time)
conn.setex('name', 3, 'zzz') # 等同于conn.set('name', 'zzz', ex=3)
# psetex(name, time_ms, value)
conn.psetex('name', 3000, 'xxx') # 等同于conn.set('name', 'xxx', px=3000)
# mset(*args, **kwargs)
conn.mset({'k1': 'v1', 'k2': 'v2'}) # 批量设置值
# get(name)
print(conn.get('k1')) # 获取值
# mget(keys, *args)
print(conn.mget('k1', 'k2')) # 批量获取值
print(conn.mget(['k1', 'k2'])) # 批量获取值
# getset(name, value)
print(conn.getset('k1', 'v11')) # 获取原来的值并设置为新的值
# getrange(key, start, end)
print(conn.getrange('k1', 0, 2)) # 按照字节获取,start是起始位置,end是终止位置;左闭右闭
# 中文为三个字节;可以在实例化得到对象时设置属性Redis(decode_responses=True)显示中文
# setrange(name, offset, value)
conn.setrange('k1', 1, 'xxx') # 修改字符串内容,从第二个字节的位置向后替换
# setbit(name, offset, value)
# name，redis的name
# offset，位的索引（将值变换成二进制后再进行索引）
# value，值只能是 1 或 0
conn.setbit('k1', 4, 1) # 将k1的值转换为二进制,将二进制索引为4的数字修改为1
# getbit(name, offset)
print(conn.getbit('k1', 4)) # 将k1的值转换为二进制,获取位索引为4的值(0或1)
# bitcount(key, start=None, end=None)
print(conn.bitcount('k1', 0, 0)) # 获取k1指定范围中二进制表示中1的个数;起始位置与终止位置以字符为单位
# bitop(operation, dest, *keys)
# 获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
# 参数：
# operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
# dest, 新的Redis的name
# *keys,要查找的Redis的name
conn.bitop("AND", 'new_name', 'n1', 'n2', 'n3') # 获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中
# strlen(name)
print(conn.strlen('k1')) # 返回k1对应值的字节长度
# incr(self, name, amount=1)
conn.incr('c1', 2) # 自增2,amount不填默认为自增1;当c1不存在时,则创建name=amount
# incrbyfloat(self, name, amount=1.0)
conn.incrbyfloat('c1', 5.2) # 自增5.2,amount默认为1.0;当c1不存在时,则创建name=amount;可能会出现精度问题
# decr(self, name, amount=1)
conn.decr('c2', 3) # 自减3,amount不填默认为自减1;当c2不存在时,则创建name=amount
# append(key, value)
conn.append('k2', 'asdfas') # 在k2对应的值后面追加内容;当k2不存在时,则创建key=value
conn.close()
redis hash操作
| 方法 | 说明 |
|---|---|
| hset(name, key, value) | 设置键值对 |
| hmset(name, mapping) | 批量设置键值对 |
| hget(name,key) | 获取键对应的值 |
| hmget(name, keys, *args) | 获取多个键的值 |
| hgetall(name) | 获取所有键值对 |
| hlen(name) | 获取键值对个数 |
| hkeys(name) | 获取所有键 |
| hvals(name) | 获取所有值 |
| hexists(name, key) | 判断是否有指定key |
| hdel(name,*keys) | 删除指定键值对 |
| hincrby(name, key, amount=1) | 整数自增 |
| hincrbyfloat(name, key, amount=1.0) | 浮点数自增 |
| hscan(name, cursor=0, match=None, count=None) | 增量式迭代获取 |
| hscan_iter(name, match=None, count=None) | 利用yield封装hscan创建生成器 |
import redis
conn = redis.Redis()
# hset(name, key, value) name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
conn.hset('h1', 'x1', 'y1')
conn.hset('h1', mapping={'x1': 'y1'})
# hmset(name, mapping) 在name对应的hash中批量设置键值对
conn.hmset('h1', {'x2': 'y2', 'x3': 'y3'}) # 弃用了
# hget(name,key) 在name对应的hash中获取根据key获取value
print(conn.hget('h1', 'x1'))
# hmget(name, keys, *args) 在name对应的hash中获取多个key的值
print(conn.hmget('h1', ['x1', 'x2']))
# hgetall(name) 获取name对应hash的所有键值
print(conn.hgetall('h1'))
# hlen(name) 获取name对应的hash中键值对的个数
print(conn.hlen('h1'))
# hkeys(name) 获取name对应的hash中所有的key的值
print(conn.hkeys('h1'))
# hvals(name) 获取name对应的hash中所有的value的值
print(conn.hvals('h1'))
# hexists(name, key) 检查name对应的hash是否存在当前传入的key
print(conn.exists('h1', 'x1')) # 存在返回1,不存在返回0
# hdel(name,*keys) 将name对应的hash中指定key的键值对删除
conn.hdel('h1', 'x1')
# hincrby(name, key, amount=1) 自增name对应的hash中的指定key的值，不存在则创建key=amount，name不存在也会创建
conn.hincrby('h2', 'k1', 2)
# hincrbyfloat(name, key, amount=1.0) 自增name对应的hash中的指定key的值，不存在则创建key=amount
conn.hincrbyfloat('h2', 'k2', 2.2)
# hscan(name, cursor=0, match=None, count=None) 增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而防止内存被撑爆
# name，redis的name; cursor，游标（基于游标分批取获取数据）; match，匹配指定key，默认None 表示所有的key; count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
# count 是要取的条数，但是不准确，有点上下浮动
# for i in range(1000):
# conn.hset('h3', f'k{i}', f'v{i}')
print(conn.hscan('h3', 0))
# hscan_iter(name, match=None, count=None) 利用yield封装hscan创建生成器，实现分批去redis中获取数据
print(conn.hscan_iter('h3')) # 生成器 <generator object ScanCommands.hscan_iter at 0x00000204EC875120>
for i in conn.hscan_iter('h3'):
print(i)
redis列表操作
import redis
conn = redis.Redis()
# lpush(name,values) 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
conn.lpush('l1', '11', '22', '33')
conn.rpush('l1', '00') # 从右往左操作
# lpushx(name,value) 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
conn.lpushx('l1', '44')
conn.lpushx('l2', '11') # l2不存在,不会新增
conn.rpushx('l1', 'rpushx') # 表示从右向左操作
# llen(name) name对应的list元素的个数
print(conn.llen('l1'))
# linsert(name, where, refvalue, value))在name对应的列表的某一个值前或后插入一个新值
# where:before/after; refvalue:标杆值,在它的前后插入数据; value:要插入的数据
conn.linsert('l1', 'after', '22', 'linsert') # 在22后边插入linsert
# lset(name, index, value) 对name对应的list中的某一个索引位置重新赋值
conn.lset('l1', 0, 66) # 将索引为0的44改为66
# lrem(name, num, value) 在name对应的list中删除指定的值
conn.lrem('l1', 1, '33') # num表示删除多少个;1表示从左到右删除一个,-1表示从右到左删除一个,0表示删除所有
# lpop(name) 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
print(conn.lpop('l1'))
print(conn.rpop('l1')) # 获取右侧第一个元素并在列表中移除
# lindex(name, index) 在name对应的列表中根据索引获取列表元素
print(conn.lindex('l1', 2))
# lrange(name, start, end) 在name对应的列表分片获取数据
print(conn.lrange('l1', 0, 1)) # 左闭右闭
# ltrim(name, start, end) 在name对应的列表中移除没有在start-end索引之间的值
conn.ltrim('l1', 0, 2)
# rpoplpush(src, dst) 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
conn.rpoplpush('l1', 'l2')
# blpop(keys, timeout) 从左往右去pop对应列表的元素,如果列表为空会阻塞,直到列表中被添加了值或超时
print(conn.blpop('l1', 3))
# brpoplpush(src, dst, timeout=0) 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧,如果列表为空会阻塞,直到列表中被添加了值或超时
conn.brpoplpush('l1', 'l2', 3)
# 自定义增量迭代
# 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
# 1、获取name对应的所有列表
# 2、循环列表
# 但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：
# 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])
def scan_list(name,count=2):
index=0
while True:
data_list=conn.lrange(name,index,count+index-1) # 根据count取出指定个数的数据
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默认隔离级别:可重复读repeatable read
redis：redis数据库，是否支持事务？
redis事务机制可以保证一致性和隔离性，无法保证持久性，但是对于redis而言，本身是内存数据库，所以持久化不是必须属性。原子性需要自己进行检查，尽可能保证
redis 不像mysql一样，支持强事务，事务的四大特性不能全部满足，但是能满足一部分，通过redis的管道实现的
redis本身不支持事务，但是可以通过管道，实现部分事务
redis 通过管道，来保证命令要么都成功，要么都失败，完成事务的一致性，但是管道只能用在单实例，集群环境中，不支持pipline
"""
import redis
conn = redis.Redis()
pipeline = conn.pipeline(transaction=True)
pipeline.decr('a', 2) # a的值减2
# raise Exception('raise')
pipeline.incr('b', 2) # b的值加2
pipeline.execute() # 真正执行
conn.close()
redis其他操作
"""通用操作:五大类型都可以使用"""
import redis
conn = redis.Redis()
# 1 delete(*names)
conn.delete('age', 'name') # 按key值从数据库中删除
# 2 exists(name)
res=conn.exists('xx') # 判断是否存在
print(res) # 0
# 3 keys(pattern='*')
res=conn.keys('*o*') # *代表任意个数的任意字符
print(res)
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') # 每次访问自增1
res = conn.get('page_view')
return HttpResponse('被访问了%s次' % res)
# 方式二:使用第三方模块:django-redis
1. 下载
pip install django-redis
2. settings配置文件配置
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",
}
}
}
3. 使用
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
练习
# redis集成到django中，使用cache实现
-轮播图，访问如果缓存中有，直接从缓存中取出返回，如果没有去数据库查询，放到缓存中再返回
from django.core.cache import cache
class CommonListModelMixin(ListModelMixin):
def list(self, request, *args, **kwargs):
res = cache.get('banner')
if not res:
res = super().list(request, *args, **kwargs)
cache.set('banner', res.data)
return APIResponse(result=res.data)
return APIResponse(result=res)
扫一扫
316
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
