Redis

Redis：6379
redis是一个key-value存储系统：
    通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高动态、数据库驱动网站的速度

支持存储的value类型：
    String: 字符串
    Hash: 散列
    List: 列表
    Set: 集合
    Sorted Set: 有序集合

Redis操作：
    redis的本质就是是大字典
    Redis={
            key:value
        }
        
    String操作:一个key对应一个value
        设置值:set
            1.set(name,value,ex=None,px=None,nx=False, xx=False)
                不存在则创建,存在则修改
                ex,过期时间(秒) px 毫秒 nx=True 只有name不存在时,才执行
                                        xx=True 只有name存在时,才执行
                子操作：
                    setnx(name, value) name不存在时,才执行
                    setex(name, value, time) time过期时间(秒)
                    psetnx(name,time_ms,value) time_ms过期时间(毫秒)
            2.mset(*args,**kwargs)批量设置
                mset(k1="v1",k2="v2")或mset({'k1': 'v1', 'k2': 'v2'})
        获取值:get
            1.get(name)
            2.mget(keys)批量获取mget('jerd',"jerry") mget(['jerd',"jerry"])
            3.getset(name,value) 设置新值并获取原来的值
            4.strlen(name) 返回name对应值的字节长度
            5.append(key,value) 在name对应的值后面追加内容
    Hash操作：
        redis中Hash在内存中的存储格式
            Redis={
                    name--->hash
                    name:{key:value}
                }
        以h开头的操作均是对hash的操作,用hash操作,数据均以bytes存储
        {
            shopping_car_key：{b'title': b'Python\xe5\x85\xa8\xe6',
                    }
        }
        1.添加:hset
            1.hset(name,key,value)
                不存在就创建,存在就修改
                 r.hmset('zhao','k1','v1')
            2.hmset(name,maping) 在name对应的hash中批量设置键值对
                 r.hmset('zhao', {'k1':'v1', 'k2': 'v2'})
        2.查看：
            1.hget(name,key) 在name对应的hash中获取根据key获取value
            2.hmget(name,key,*args)
                获取多个key的值 r.mget("zhao",['k1','k2']
                                r.hmget("zhao","k1,"k2")
            3.hgetall(name) 获取name对应hash的所有值
            4.hkeys(name) 获取对应的所有key值
            5.hvals(name) 获取对应的所有value值
            6.hexits:
                1.exists(name) 判断是否存在当前传入的key
                    if not r.exists('zhao'):
                2.hexists(name,key) 判断name对应的hash是否存在当前传入的key
                    if not r.exists('zhao','k1'):
            7.hscan_iter 
                利用yield封装hscan创建生成器，实现分批去redis中获取数据
                name模糊匹配查看时使用scan_iter 
                redis={
                    zhao_1_1：{key：value},
                    zhao_1_2：{key：value},
                }
                for i in conn.scan_iter("zhao_1_*"):
                  print(i)   zhao_1_1
                             zhao_1_2
        3.删除:
            1.删除name对应的值：
                hdel(name,*keys) 将name对应的hash中指定key的键值对删除
                r.hdel('zhao','k1')
            2.删除name对应的整条数据
                1.逐个删除
                    r.delete("zhao_1_1")
                    r.delete("zhao_1_2")
                2.删除
                    conn.delete(*["zhao_1_1","zhao_1_2"])
                3.全部删除
                    r.flushall()            
    List操作：
        Redis={
                    name--->list
                    name:[v1,v2]
                }
    1.添加：
        1.lpush(name,values)
            每个新的元素都添加到列表的最左边
            r.lpush("zhao",11,55,88) lsit的值为[88,55,11]
        2.llen(name) name对应的list元素的个数
        3.linsert(name,where,refvalue,value)
            在name对应的列表的某一个值前或后插入一个新值
            r.linsert("zhao",before,55,22) 在55前添加22
    2.删除：
        r.lrem(name, value, num)
            在name对应的list中删除指定的值,num表示删除的个数
        lpop(name)获取对一个元素删除
    3.修改：
        r.lset(name, index, value) 
            对name对应的list中的某一个索引位置重新赋值
    4.查：
    1.lindex(name,index) 根据索引获取列表元素
    2.lrange(name, start, end) 根据列表分片获取数据
    
        
在python中使用redis：
    redis单线程,单进程的处理
    pip install redis
    1.每次建立：Redis
        import redis
        r=redis.Redis(host='10.211.55.4', port=6379)
        r.set(key,value)
    2.使用连接池：
        本质:维护一个已经和服务端连接成功的socket,以后再次发送数据,
             直接获取一个socket,直接send数据
        1.每个Redis实例都会维护一个自己的连接池
        2.使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销
        3.直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池
        import redis
        pool=redis.ConnectionPool(host='10.211.55.4', port=6379)
        r=redis.Redis(connection_pool=pool)
        r.set(key,value)
在django中使用redis
    1.pip install django-redis
    2.在stting中配置CACHES
        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": "密码",
                }
            }
        }
    3.调用
        from django_redis import get_redis_connection
        conn = get_redis_connection("default")    
        
管道:pipline    
    每次请求都会创建和断开一次连接操作,如果想在一次请求中指定多个命令
    使用pipline来实现
        import redis
        pool=redis.ConnectionPool(host='10.211.55.4', port=6379)
        r=redis.Redis(connection_pool=pool)
        pipe=r.pipline(transaction=True)
        pipe.multi()
        pipe.set("name","zhao")
        pipe.set("age",18)
        pipe.excute()
        
使用Redis的好处：
    1.速度快。数据都存在内存中
    2.支持多种数据类型：String,list,set,zset,hash
    3.支持事务,操作都是原子性的    
Redis 与其他 key - value 缓存产品有以下三个特点：
    1.Redis支持数据的持久化，可以将内存中的数据保存在磁盘中,重启的时候可以再次加载进行使用。
        持久化的方式：AOF和RDB
    2.Redis不仅仅支持简单的key-value类型的数据，同时还提供多种数据类型
    3.Redis支持数据的备份，即master-slave模式的数据备份。
redis的淘汰策略：
    MySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据？edis 内存数据集大小上升到一定大小的时候，就会施行数据淘汰策略。
    redis 提供 6种数据淘汰策略：
        1.从已设置过期时间的数据集里选择：
            1.volatile-lru：挑选最近最少使用的数据淘汰
            2.volatile-ttl：挑选即将过期的数据淘汰
            3.volatile-random：任意选择数据淘汰
        2.从数据集中选择
            1.allkeys-lru：从数据集中选最少使用的数据淘汰
            2.allkeys-random:从数据集中任意选择数据淘汰
            3.no-enviction：禁止驱逐数据
如果redis中有100w条数据,请打印所有的数据
    不使用hgetall的原因：从redis中取到数据之后,服务器的内存无法承受
    使用hscan_iter,可设置每次取100条数据,返回的结果是生成器
    ret=conn.hscan_iter("k1",100)
    for item in ret:pass
Memcache与Redis的区别都有哪些？
    1.存储方式
        Memecache把数据全部存在内存之中,数据不能超过内存大小
        Redis有部份存在硬盘上，这样能保证数据的持久性
    2.数据支持类型：
        Memcache对数据类型支持相对简单。
        Redis有复杂的数据类型。
    3.value大小
        redis最大可以达到1GB，而memcache只有1MB