luffy-(9)

内容概览

• redis图形化客户端
• redis字符串操作
• redis hash操作
• redis列表操作
• redis管道
• redis其他操作
• django中集成redis
• celery介绍

redis图形化客户端

安装图形化客户端redis-desktop-manager
新版本收费，可以使用老版本
QT平台：可以写图形化界面
python：pyqt5写图形化界面 GUI开发

redis字符串操作

redis有五大数据类型：字符串，hash，列表，集合，有序集合

最常用的：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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

redis hash操作

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'))  # 生成器 
for i in conn.hscan_iter('h3'):
    print(i)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

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实现的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

celery介绍

# celery：翻译过来叫芹菜，它是一个  分布式的异步任务   框架
# celery有什么用？
	1 完成异步任务：可以提高项目的并发量，之前开启线程做，现在使用celery做
    2 完成延迟任务
    3 完成定时任务
    
# 架构
    -消息中间件：broker 提交的任务（函数）都放在这里，celery本身不提供消息中间件，需要借助于第三方：redis，rabbitmq
    -任务执行单元：worker，真正执行任务的地方，一个个进程，执行函数
    -结果存储：backend，函数return的结果存储在这里，celery本身不提供结果存储，借助于第三方：redis，数据库，rabbitmq
    
1
2
3
4
5
6
7
8
9
10
11

练习

# 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15