[Python知识库]redis——列表操作、事务（管道）、其他操作、django集成redis、celery介绍安装、celery快速使用

系列文章目录

一、列表操作

1.python操作列表

from redis import Redis

redis = Redis()
# 列表新增元素默认从左边进入列表
# 1 lpush(name,values)
# 新增列表值，从左侧进入
redis.lpush('list1', 'bbc', 'apper')

# 2 lpushx(name,value)
# 当name存在时，向左侧新增元素
redis.lpushx('list1', 'beef')

# 3 rpushx(name, value) 表示从右向左操作
# 当name存在时向右侧新增元素
redis.rpushx('list1', 'down')

# 4 llen(name)
# 获取列表长度
print(redis.llen('list1'))

# 5 linsert(name, where, refvalue, value))
# 向列表的某个元素的位置插入元素，where为插入在该元素之前还是之后，refvalue为目标元素，value为插入的值
redis.linsert('list1', 'before', 'beef', 'www')
redis.linsert('list1', 'after', 'beef', 'html')

# 6 lset(name, index, value)
# 修改指定位置元素
redis.lset('list1', 0, 'ppp')

# 7 lrem(name, num, value)
# 删除指定个数的value，num为整数从左往右，负数从右往左
redis.lrem('list1', 1, 'ppp')
redis.lrem('list1', -1, 'ppp')

# 8 lpop(name)
# 获取最左侧的元素，获取后删除该元素
print(redis.lpop('list1'))

# 9 lindex(name, index)
# 获取对应位置的元素
print(redis.lindex('list1', 1))

# 10 lrange(name, start, end)
# 获取对应位置上的元素，闭区间
print(redis.lrange('list1', 0, 1))

# 11 ltrim(name, start, end)
# 保留开始位置到结束位置的元素，其余元素删除
print(redis.ltrim('list1', 3, 3))

# 12 rpoplpush(src, dst)
# 将src右侧的元素提取一个加入到dst左侧
redis.rpoplpush('list2', 'list1')

# 13 blpop(keys, timeout)
# 弹出keys中的每个列表的值，如果没有值了便会阻塞timeout秒或直到keys中的列表有值，再次弹出值，timeout为0就会无限阻塞
print(redis.blpop(['list1','list2']), 5)

# 14 brpoplpush(src, dst, timeout=0)
# 弹出src的元素加入到dst中，当list1没有元素后会阻塞timeout秒或直到src中有值，timeout为0就会无限阻塞
redis.brpoplpush('list1', 'list2', 5)

# 15 自定义增量迭代
# 通过迭代整个列表将其中的数字循环增量
redis.lpush('test', *['a', 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, num):
    len = redis.llen(name)
    for i in range(len):
        str = redis.lindex(name, i)
        try:
            oldvalue = int(str.decode('utf-8'))
            redis.lset(name, i, oldvalue + num)
        except:
            continue
    return redis.lrange(name, 0, len)


for item in scan_list('test', 1):
    print('---')
    print(item)

redis.close()

2.redis操作列表

二、事务（管道）

Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：

批量操作在发送 EXEC 命令前被放入队列缓存。
收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。
一个事务从开始到执行会经历以下三个阶段：

1. 开始事务 使用 MULTI
2. 命令入队。 redis指令
3. 执行事务。使用EXEC

1.redis事务（管道）

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set str2 name
QUEUED
127.0.0.1:6379> get str2
QUEUED
127.0.0.1:6379> set str2 sex
QUEUED
127.0.0.1:6379> get str2
QUEUED
127.0.0.1:6379> EXEC
1) OK
2) "name"
3) OK
4) "sex"
127.0.0.1:6379>

2.python事务（管道）

from redis import Redis

# 第一步创建一个redis对象
redis = Redis()

# 第二步将redis对象设置为管道
pipe = redis.pipeline(transaction=True)
# 使用multi开启管道
pipe.multi()
pipe.set('str', 'bbc')
print(pipe.get('str'))
pipe.set('str', 'hb')
print(pipe.get('str'))
# 使用execute执行管道中的所有命令
pipe.execute()

pipe.close()

三、其他操作

from redis import Redis

redis = Redis()

# 1 delete(*names)
# 删除单个或者批量的字符串、列表、hash、集合、有序集合
redis.delete(*['test', 'str', 'str2'])

# 2 exists(name)
# 判断字符串、列表、hash、集合、有序集合是否存在
print(redis.exists('list1'))

# 3 keys(pattern='*')
# 查看所有键值，参数可以是模糊查询，为空参数默认*查询所有
print(redis.keys())
print(redis.keys('list?'))

# 4 dbsize
# 获取当前使用的数据库的键的数量
print(redis.dbsize())

# 5 expire(name ,time)
# 定时删除指定键
redis.expire('list2', 30)

# 6 rename(src, dst)
# 将src的内容替换到dst中，并删除src
redis.rename('list1', 'list2')

# 7 move(name, db))
# 将当前库中的键转移到对应的库中
redis.move('list2', 1)

# 8 randomkey()
# 随机获取一个redis的name（不删除）
print(redis.randomkey())

#9 type(name)
# 获取该键对应的数据类型
print(redis.type('food'))

redis.close()

四、django集成redis

1.通用方案

创建一个pool.py（名字自行设定）

import redis

redis_pool = redis.ConnectionPool(max_connections=1024, decode_responses=True)

在需要使用redis的地方创建redis对象然后查询即可

from redis import Redis
from script.pool import redis_pool
    def get(self, request):
        redis = Redis(connection_pool=redis_pool)
        res = redis.get('food')
        return Response({'code':200, 'data':res})

2.django中使用django-redis

1.安装django-redis

pip install django-redis

2.配置redis配置文件
dev.py（默认项目中为settings.py）

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": 1024} #设置最大连接数，推荐1024
                    # "PASSWORD": "123",
                }
            }
        }

3.在需要使用redis的地方使用

from django_redis import get_redis_connection
    def get(self, request):
        # get_redis_connection(alias="default")alias的名字要对应配置文件
        redis = get_redis_connection()
        res = redis.get('food')
        return Response({'code':200, 'data':res})

五、celery介绍安装

1.介绍

celery分布式异步任务框架，该框架为我们提供了异步执行、延时执行、定时执行。框架对windows适配不好，可能会出问题，但可以通过特殊方法在windows上运行。

概念：celery是独立的服务，跟其它框架无关，需要单独启动

特点：

• 可以不依赖任何服务器，通过自身命令，启动服务
• celery服务为为其他项目服务提供异步解决任务需求的

1 异步执行：解决耗时任务,将耗时操作任务提交给Celery去异步执行，比如发送短信/邮件、消息推送、音视频处理等等
2 延迟执行：解决延迟任务
3 定时执行：解决周期(周期)任务,比如每天数据统计

celery的架构：

1. 消息中间件broker——redis，rabbitmq
2. 任务执行单元worke——celery的进程
3. 结果存储（backend）：Task result store——redis，mysql，rabbitmq

2.安装

pip install celery

六、celery快速使用

celerys.py（自由定义）

# 第一步：实例化得到app对象，注册任务
import time
from celery import Celery
from django_redis import get_redis_connection
backend='redis://127.0.0.1:6379/1' # 结果存储

broker='redis://127.0.0.1:6379/2'  # 消息中间件

app=Celery('main',broker=broker,backend=backend)


#任务变成了celery的任务了
@app.task
def add(a,b):
    redis = get_redis_connection()
    time.sleep(2)
    redis.set(a, b)
    return 'add任务触发了'

对需要的任务进行提交

# 通过celery异步使用redis
    def get(self, request):
        res = add.delay('string1', 'fish') #关键对celery的任务调用.delay方法
        return Response({'code':200, 'data':'任务启动'})

使用celery 来执行任务：启动worker

win上：先安装eventlet
pip install eventlet
celery -A celery的任务所在的py文件名 worker -l info -P eventlet

linux、mac上
celery -A celery的任务所在的py文件名 worker -l info 

执行结果在之前设置的backend里对应的redis库，中间消息在broker里redis库