1.String(字符串)

在任何一种编程语言中，字符串都是最基础的数据结构，在Redis中String是可以修改的称之为：动态字符串(简称SDS)

Redis的内存分配机制：

        - 当字符串的长度小于1MB时，每次扩容都是加倍现有的空间

        - 如果字符串长度超过1MB时，每次扩容时只会扩展1MB空间

ps：这样既保证了内存空间够用，也不会造成内存的浪费，字符串最大长度为512MB

import redisconn = redis.Redis()
# 1  set(name, value, ex=None, px=None, nx=False, xx=False)
#      ex，过期时间（秒）
#      px，过期时间（毫秒）
#      nx，如果设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果
#      xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值# conn.set('name','abc') # value 只能是字符串或byte格式
# conn.set('name','abc',ex=3) # ex 是过期时间，到3s过期，数据就没了
# conn.set('name','abc',px=3000) # px 是过期时间，到3s过期，数据就没了
# conn.set('age',18,nx=True) # redis 实现分布式锁
# conn.set('hobby', '足球', xx=False) # hobby存在操作# 2 setnx(name, value)   就是：set nx=True
# conn.setnx('hobby1','橄榄球')# 3 psetex(name, time_ms, value)  本质就是 set px设置时间
# conn.psetex('name',3000,'abc')# 4 mset(*args, **kwargs)  传字典批量设置
# conn.mset({'name':'xxx','age':19})# 5 get(name)  获取值，取到是bytes格式   ,指定：decode_responses=True，就完成转换
# print(conn.get('name'))
# print(str(conn.get('name')[:3],encoding='utf-8'))# 5 mget(keys, *args)  #批量获取
# res=conn.mget('name','age')
# res=conn.mget(['name','age'])
# print(res)# 6 getset(name, value)  # 先获取，再设置
# res=conn.getset('name','cba')
# print(res)# 7 getrange(key, start, end) # 取的是字节，前闭后闭区间
# res=conn.getrange('name',0,1)
# print(res)# 8 setrange(name, offset, value)  # 从某个起始位置开始替换字符串
# conn.setrange('name', 1, 'xxx')# 9 setbit(name, offset, value)
# conn.setbit('name',1,0)   #  00000000   00000000   00000000
# res=conn.get('name')
# print(res)# 10 getbit(name, offset)
# res=conn.getbit('name',1)
# print(res)# 11 bitcount(key, start=None, end=None)
# print(conn.bitcount('name',0,3))  # 3 指的是3个字符# 12 strlen(name)  # 统计字节长度
# print(conn.strlen('name'))
# print(len('abc胡'))  # len 统计字符长度# 13 incr(self, name, amount=1)  # 计数器
# conn.incr('age',amount=3)# 14 incrbyfloat(self, name, amount=1.0)# 15 decr(self, name, amount=1)
# conn.decr('age')# 16 append(key, value) # 在后面追加
# conn.append('name','nb')
conn.close()

2.list(列表)

Redis的list和java中的LinkedLIst很像，底层都是一种链表结构，list的插入和删除操作非常快，时间复杂度为0(1)，不像数组结构插入、删除操作需要移动数据

当数据量较少的时候它的底层存储结构为一块连续内存，称之为ziplist(压缩列表)，它将所有的元素紧挨着存储，分配的是一块连续的内存；当数据量较多的时候将会变成quicklist(快速链表)结构

redis3.2之后就改用ziplist+链表的混合结构，称之为quicklist(快速链表)

 list应用场景它是按照插入顺序排序的列表：

        - 消息队列：lpop和rpush或者lpush和rpop能实现队列的功能

        - 朋友圈的点赞列表、评论列表、排行榜：lpush命令和lrange命令能实现最新列表的功能，每一次通过push命令往列表里插入新的元素，然后通过lrange命令读取最新的元素列表

import redisconn = redis.Redis(decode_responses=True)# 1 lpush(name,values)   从左侧插入  [小明 小红 小张 小鹏]
# conn.lpush('girls','小红')
# conn.lpush('girls','小明')
# conn.rpush('girls','小张') # 从右侧插入
# conn.rpush('girls','小鹏')  # 2 lpushx(name,value) 只有name已经存在时，值添加到列表的最左边
# conn.lpushx('girls','小丽')
# conn.lpushx('boys','小刚')# 3 rpushx(name, value) 表示从右向左操作# 4 llen(name)
# res=conn.llen('girls')
# print(res)# 5 linsert(name, where, refvalue, value))
# conn.linsert('girls', where='after', refvalue='小红', value='李清照')
# conn.linsert('girls', where='before', refvalue='小红', value='李清照')# 6 lset(name, index, value)
# conn.lset('girls',0,'xx')# 7 lrem(name,count ,value)  # count放数字，可以写负数，表示从右往前删除  0 表示全删
# conn.lrem('girls',0,'李清照')# 8 lpop(name)
# res=conn.lpop('girls')
# res=conn.rpop('girls')
# print(res)# 9 lindex(name, index)
# res=conn.lindex('girls',2)
# print(res)# 10 lrange(name, start, end)  前闭后闭
# res=conn.lrange('girls',0,2)
# print(res)# 11 ltrim(name, start, end)  修建
# res=conn.ltrim('girls',1,2)# 12 rpoplpush(src, dst)
# conn.rpoplpush('girls','boys')# 13 blpop(keys, timeout)  阻塞式弹出，如果列表中没有值，会阻塞在这，直到有值，再弹出，它可以做消息队列，做分布式的系统
# res=conn.blpop('boys',timeout=3)
# print(res)# 14 brpoplpush(src, dst, timeout=0)# 15 自定义增量迭代
# res=conn.lrange('girls',0,conn.llen('girls'))
# print(res)conn.close()

3.hash(字典)

Redis中的Hash和Java的HashMap更加相似，都是数组+链表的结构，当发送hash碰撞时将会把元素追加到链表上，要注意的是在Redis的Hash中value只能是字符串

Hash和String都可以用来存储用户信息，但不同的是Hash可以对用户信息的每个字典单独存储；

String存的是用户全部信息经过序列化后的字符串，如果想要修改某个用户字段必须将用户信息字符串全部查询出来，解析成响应的用户信息对象，修改完后在序列化成字符串存入

Hash可以只对某个字段修改，从而节约网络流量但是hash内存占用要大于String

 应用场景：

        - 购物车：hset[key] [field] [value]，可以实现以用户id为field，商品数量为value，恰好构成了购物车的三要素

        - 存储对象：hash类型的(key,field,value)的结构与对象的(对象id，属性，值)的结构相似，也可以用来存储对象

import redisconn = redis.Redis(decode_responses=True)
# 1 hset(name, key, value)
# conn.hset('userinfo', 'name', '彭于晏')
# conn.hset('userinfo', 'age', '32')
# conn.hset('xx',mapping={'name':'xxx','hobby':'篮球'})# 2 hmset(name, mapping)   弃用了
# conn.hmset('yy',{'a':'a','b':'b'})# 3 hget(name,key)
# res=conn.hget('userinfo','age')
# print(res)# 4 hmget(name, keys, *args)
# res=conn.hmget('userinfo',['name','age'])
# print(res)# 5 hgetall(name)    慎用，可能会造成 阻塞 尽量不要在生产代码中执行它
# res=conn.hgetall('userinfo')
# print(res)# 6 hlen(name)
# res=conn.hlen('userinfo')
# print(res)# 7 hkeys(name)
# res=conn.hkeys('userinfo')
# print(res)
# 8 hvals(name)
# res=conn.hvals('userinfo')
# print(res)# 9 hexists(name, key)
# res=conn.hexists('userinfo','name')
# print(res)# 10 hdel(name,*keys)
# conn.hdel('userinfo','age')# 11 hincrby(name, key, amount=1)
# conn.hincrby('userinfo','age')# 12 hincrbyfloat(name, key, amount=1.0)
# conn.hincrbyfloat('userinfo','age',5.44)## 联合起来讲：不建议使用hgetall，分片取值
# 分批获取               生成器应用在哪了？
# 13 hscan(name, cursor=0, match=None, count=None)
# hash类型没有顺序---》python字典 之前没有顺序，3.6后有序了    python字段的底层实现
# for i in range(1000):
#     conn.hset('test_hash','key_%s'%i,'鸡蛋%s号'%i)# count 是要取的条数，但是不准确，有点上下浮动
# 它一般步单独用
# res=conn.hscan('test_hash',cursor=0,count=19)
# print(res)
# print(res[0])
# print(res[1])
# print(len(res[1]))
# res=conn.hscan('test_hash',cursor=res[0],count=19)
# print(res)
# print(res[0])
# print(res[1])
# print(len(res[1]))# 咱么用它比较多，它内部封装了hscan，做成了生成器，分批取hash类型所有数据
# 14 hscan_iter(name, match=None, count=None)  获取所有hash的数据
# res = conn.hscan_iter('test_hash',count=100)
# print(res)  # 生成器
# for item in res:
#     print(item)conn.close()

4.set(集合)

Redis中的set和java中的HashSet有些类似，它内部的键值对是无序的、唯一的，他的内部实现相当于一个特殊的字典，字典中所有的value都是一个值NULL，当集合中最后一个元素被移除之后数据结构被自动删除，内存被释放

 应用场景：

        - sinter命令可以获得A和B两个用户的共同好友

        - sismenber命令可以判断A是否是B的好友

        - scard命令可以获取好友数量

 redis是否支持事物

redis可以说支持事务也可以说不支持，redis事务机制可以保证一致性和隔离性，但是无法保证持久性，但是对于redis而言，本身是内存数据库，所以持久性不是必须属性，原子性需要自己进行检查，尽可能保证。

redis不像mysql一样事务的四大特性不能全部满足，但是能满足一部分，通过redis的管道实现的

redis本身不支持事务，但是可以通过管道实现部分事务

redis可以通过管道来保证命令要么都成功，要么都失败，完成事务的一致性，但是管道只能用在单实例，集群中不支持管道

 django中集成redis

方式一：直接使用

from user.POOL import pool
import redis
def index(request):conn = redis.Redis(connection_pool=pool)conn.incr('page_view')res = conn.get('page_view')return HttpResponse('被你看了%s次' % res)

方式二：使用第三方模块

# 下载第三方模块：django-redis
# 配置文件中配置
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",}}}
# 使用方式
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)

方式三：借助于dango的缓存使用

-如果配置文件中配置了 CACHES  ，以后django的缓存，数据直接放在redis中
-以后直接使用cache.set 设置值，可以传过期时间
-使用cache.get 获取值
-强大之处在于，可以直接缓存任意的python对象，底层使用pickle实现的