'''
lpush(name,values)
rpush(name, values) 表示从右向左操作
lpushx(name,value)
rpushx(name, value) 表示从右向左操作
llen(name)
linsert(name, where, refvalue, value))
lset(name, index, value)
lrem(name, value, num)
lpop(name)
rpop(name) 表示从右向左操作
lindex(name, index)
lrange(name, start, end)
ltrim(name, start, end)
rpoplpush(src, dst)
blpop(keys, timeout)
brpoplpush(src, dst, timeout=0)
自定义增量迭代
'''

import redis
conn = redis.Redis(decode_responses=True)

# lpush(name,values)
'''在name对应的list中添加元素，添加在最左边'''
# conn.lpush('hobby','篮球')

# rpush(name, values) 表示从右向左操作
# conn.rpush('hobby','排球')

# lpushx(name,value)
'''值存在时 添加在最左侧 不存在时不会添加'''
# conn.lpushx('hobby','乒乓球')

# rpushx(name, value) 表示从右向左操作
'''同上'''

# llen(name)
'''对应的list元素的个数'''
# res = conn.llen('hobby')
# print(res)

# linsert(name, where, refvalue, value))
"""
参数：
    where：可以是before或after
    refvalue：在当前值前或后插入
    value：插入的数据
"""
# conn.linsert('hobby','before','足球','羽毛球')

# lset(name, index, value)
'''在相对应的索引位置设置值'''
# conn.lset('hobby',2,'橄榄球')

# lrem(name, count, value)
"""
参数：
    count=0 删除列表中所有的指定值
    count=1 从前往后，删除1个
    count=-1 从后往前，删除1个
"""
# conn.lrem('hobby',0,'篮球')
# conn.lrem('hobby',1,'排球')
# conn.lrem('hobby',-1,'排球')

# lpop(name)
'''弹出左侧第一个元素'''
# res = conn.lpop('hobby')
# print(res)

# rpop(name) 表示从右向左操作
'''操作同上 弹出右侧'''

# lindex(name, index)
# res = conn.lindex('hobby',1)
# print(res)

# lrange(name, start, end)
'''列表分片获取数据'''
# res = conn.lrange('hobby',1,2)
# print(res)

# ltrim(name, start, end)
'''移除索引start和end之外的值'''
# conn.ltrim('hobby',1,3)

# rpoplpush(src, dst)
"""
从一个列表取出最右边的元素，同时添加到另一个列表的最左边
参数：
    src：要取数据的列表的name
    dst：要添加的列表的name
"""

# blpop(keys, timeout)  这个就是简单的消息队列，可以实现分布式的程序----》生产者消费者模型
# 只要列表中没有值，就会阻塞，有值才会继续运行
# res = conn.blpop('hobby')
# print(res)

# brpoplpush(src, dst, timeout=0)

# 自定义增量迭代
# 一次性把列表中所有数据取出来
# 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_list(name,count=10):
    num = 0
    while True:
        print('-----------')
        res = conn.lrange(name,num,num+count-1)
        num += count
        if res:
            for item in res:
                yield item
        else:
            break

for item in l_scan_list('eggs',20):
    print(item)

conn.close()

# 重点记忆
lpush lpop linsert lset llen lrange


"""
delete(*names)
exists(name)
keys(pattern='*')
expire(name ,time)
rename(src, dst)
move(name, db))
randomkey()
type(name)
"""

import redis
conn = redis.Redis()

# delete(*names) # 根据name删除数据
# conn.delete('age','height')

# exists(name) # 有是1 没有是0
# res = conn.exists('eggs')
# print(res)

# keys(pattern='*')  # 获取所有的键
# res = conn.keys('*')
# print(res)
'''问号表示一个字节'''
# res = conn.keys('nam?')
# print(res)

# expire(name ,time)
'''给redis的键设置超时时间 超时则删除'''
# conn.expire('name',5)

# rename(src, dst)
'''重命名'''
# conn.rename('hobby','hobby1')

# move(name, db))
'''将某个值移动到指定的db下'''
conn.move('hobby1',db=1)

# randomkey()
'''随机获取一个name'''
# res = conn.randomkey()
# print(res)

# type(name)
'''获取数据类型'''
res = conn.type('userinfo')
print(res)

conn.close()


# 事务四大特性
    原子性：要么都成功，要么都失败
    一致性：数据前后要一致
    隔离性：多个事务之间相互不影响
    持久性：事务一旦完成，数据永久改变

# redis 有没有事务？支持事务
    redis要支持事务，要完成事务的几大特性，需要使用管道来支持
    单实例redis是支持管道的
    集群模式下，不支持管道，就不支持事务

# redis通过管道实现事务
    import redis
    conn = redis.Redis()
    pipeline = conn.pipeline(transaction=True)

    pipeline.decrby('a1',10)  # 没有真正执行，把命令先放到管道中
    raise Exception('出错了')
    pipeline.incrby('a2',10)

    pipeline.execute()  # 把管道中的命令，一次性执行
    conn.close()


# 两种方式
    方式一：自定义的通用方案(跟框架无关)
        写一个py文件：redis_pool.py
            import redis
            POOL=redis.ConnectionPool(max_connections=10)
        在使用的位置导入直接使用
            conn = redis.Redis(connection_pool=POOL)
            conn.incrby('a1')
    方式二：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 MyRedisView(APIView):
                def get(self,request):
                    conn = get_redis_connection()  # 从连接池中拿出一个链接
                    conn.incrby('a1')
                    conn.set('name','XxMa')
                    return APIResponse()


# django 是大而全的框架，内置了很多web开发需要的东西，缓存内置了

# 缓存：可以把django中的一个变量(数据)，存放到某个位置，下次还可以取出来

# 之前用过：默认放在：内存中，其实可以放在文件中，数据库，redis。。。。
from django.core.cache import cache
cache.set('key','value',5) # 存放值
res=cache.get('key') # 取值

# 通过配置，控制存放在哪，只要如下写，就会放在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",
           }
       }
   }

# django缓存最强大之处在于，只要是python的变量，任意类型都可以，尽管使用set设置值
    l = [1, 'lqz', [1, 3, 4, 5, 6], '彭于晏']
    cache.set('ll1', l)
# 以后再django中往redis放数据，就用cache即可

# redis的5大数据类型，只支持一层 不能嵌套

# 可以参考这篇文章：https://www.cnblogs.com/liuqingzheng/articles/9803351.html


#序列化
    -json序列化---》得到字符串
        json不能序列化对象(自定义的类的对象)
            -数据结构：数据的组织形式跟下面不一样
        能序列化： 数字，字符串，布尔，列表，字典  时间对象
    -pickle序列化
        -python独有的，二进制形式
        -python可以序列化所有对象---》二进制形式
        -二进制---》返序列化回来---》对象：属性，有方法


# 项目中如果想用
    异步任务       （开启线程，不好管理）
    定时任务
    延迟任务        

# 借助于第三方框架，celery：芹菜，吉祥物，可以实现上面的三个功能
    http://www.celeryproject.org/

# 分布式的异步任务框架 celery