redis

redis介绍

redis是一款非关系型数据库(nosql:not only sql)，内存存储，速度非常快，可以持久化(数据从内存同步到硬盘)

数据库类型丰富，有5大数据类型：字符串、列表、哈希(字典)、集合、有序集合

存储方式是：key-value形式存储，没有表的结构，相当于python的字典

redis为什么这么快

• 高性能的网络模型：IO多路复用的epoll模型，承载住非常高的并发量
• 纯内存操作，避免了很多io
• 单线程架构，避免了线程间切换的消耗

注意：redis的单线程架构在6.x之前：单线程，单进程；6.x以后，多线程架构，数据操作还是使用单线程，别的线程做数据持久化，其他操作

Redis应用场景

1. 当缓存数据库使用，接口缓存，提高接口响应速度

django+mysql项目执行流程

1. 路径匹配成功后，请求进入到视图中
2. 然后回去访问数据库：多表查询，去硬盘取数据，速度较慢，将数据转成json格式字符串
3. 返回给前端

django+redis项目执行流程

1. 路径匹配成功后，请求进入到视图中
2. 去redis中拿，取json格式字符串
3. 返回给前端

2. 做计数器：单线程，不存在并发安全问题

统计网站访问量，个人站点浏览量，文章阅读量

3. 去重操作：集合

4. 排行榜：有序集合

阅读排行榜，游戏金币排行榜

5. 布隆过滤器

6. 抽奖

7. 消息队列

redis安装

redis是一款开源软件，使用c语言写的，编译型语言，在操作系统运行，要编译成可执行文件，由于采用了IO多路复用的epoll模型，所以它不支持windows，只有linux操作系统支持epoll

官网：https://redis.io/

下载完是源代码：c语言源码，https://redis.io/download/#redis-stack-downloads

最稳定：6.x

最新：7.x

中文网：http://redis.cn/download.ht(上面只更新到5.x)

win版本下载地址

最新5.x版本：https://github.com/tporadowski/redis/releases/

最新3.x版本：https://github.com/microsoftarchive/redis/releases

下载完一路下一步即可，具体可参考博客：https://www.cnblogs.com/liuqingzheng/p/9831331.html

图形化工具：redis-destop-management

python操作redis

下载redis模块

pip install redis

简单使用

from redis import Redis
redis=Redis()
redis.set('name','kevin')
print(redis.get('name'))
redis.close()

redis连接池

新建一个POOL.py文件

import redis
# 创建一个连接池对象
pool= redis.ConnectionPool(max_connections=5)

import redis
from POOL import pool  
from threading import Thread

import time

def run(): # 创建一个连接池，保证它是单例，全局只有一个pool对象：使用模块导入方式实现单例
  redis=redis.Redis(connection_pool=pool)  # 每执行一次会从池中取一个连接，如果没有，等待
    print(redis.get('name'))
    redis.close()

for i in range(100):
    thread = Thread(target=run)
    thread.start()

time.sleep(1)

django中是不带连接池

可以下载别人写好的插件：因为django的并发可能还没mysql高，哈哈

pip install django-db-connection-pool

修改django的配置文件

# change django.db.backends.mysql to dj_db_conn_pool.backends.mysql:
DATABASES = {
    'default': {
        ...
        'ENGINE': 'dj_db_conn_pool.backends.mysql'
        ...
    }
}

连接池选项

# 方式一：
DATABASES = {
    'default': {
        ...
        'POOL_OPTIONS' : {
            'POOL_SIZE': 10,
            'MAX_OVERFLOW': 10
        }
        ...
     }
 }
# 方式二：
import dj_db_conn_pool
dj_db_conn_pool.setup(pool_size=100, max_overflow=50)

redis字符串操作

String操作，redis中的String在内存中按照一个name对应一个value来存储。如图：

设置值

set(name,value,ex=None,px=None,nx=False,xx=False)

在redis中设置值，默认，不存在则新建，存在则修改，参数解释：

• ex，过期时间(秒)，过期后数据就没了
• px，过期时间(毫秒)
• nx，如果设置为True，则只有name不存在时，当前set操作才会执行，值存在，则修改不了，执行没效果
• xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值

setnx(name,value)

设置值，只有name不存在时，执行设置操作(添加)，如果存在，不会修改

setex(name,value,time)

设置值
参数：time是过期时间(数字秒或者timedelta对象)

psetex(name,time_ms,value)

设置值   # 本质就是 set px设置时间
参数：
time_ms,过期时间(数字毫秒或timedelta对象)

mset(*args,**kwargs)

批量字典设置值 
如：
  mset(k1='v1',k2='v2')
  或：conn.mset({'k1':'v1','k2':'v2'})

get(name)

获取值

mget(keys,*args)

批量获取
如：
  mget('k1','k2')
  或
  mget(['k1','k2'])

getset(name,value)

# conn.getset('name', 'kafka')
设置新值并获取原来的值,即获取改变之前的值

getrange(key,start,end)

获取子序列，根据字节获取，非字符
参数：
	key,redis中的key值
  start，起始位置(字节)
  end，结束位置(字节)
 # conn.getrange('name', 0, 4) 从redis中查找k为name，并显示4个字节，取的是字节，前闭后闭区间

setrange(name,offset,value)

修改字符串内容，从指定字符串所有开始向后替换(新值太长时，则想后添加)  # 从某个起始位置开始替换字符串
参数：
  offset，字符串的索引，字节(如果是中文则占三个字节)
  value，要设置的值
  
print(conn.get('name')) # b'kamylove'
print(conn.setrange('name', 2, 'mysweetboby'))
print(conn.get('name')) # b'kamysweetboby'

setbit(name,offset,value)

对name对应值的二进制表示的位进行操作
参数：
  name，redis中的name
  offset，位的索引(将值变换成二进制后再进行索引)
  value，值只能是1或0

注：如果在redis中有一个对应：n1="foo",
   name字符串foo的二进制表示为：01100110 01101111 01101111
   所以，如果执行setbit('n1',7,1),则就会讲第七位设置为1
   name最终二进制则变成：01100111 01101111 01101111 即：'goo'

getbit(name,offset)

获取name对应的值的二进制表示中的某位的值(0或1)

bitcount(key,start=None,end=None)

获取name对应的值的二进制表示中1的个数
参数：
  key，redis中name
  start，位起始位置
  end，位结束位置

bitop(operation,dest,*keys)

获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
参数：
  operation:AND(并)、OR(或)、NOT(非)、XOR(异或)
  dest：新的Redis的name
  *keys：要查找的redis的name
  
如：conn.bitop('AND', 'new_name', 'n1', 'n2')
获取redis中n1,n2对应的值，然后讲所有的值做位运算(求并集)，然后将结果保存到new_name对应的值中

strlen(name)

返回name对应的值的字节长度(一个汉字3个字节)

如：
  conn.strlen('name')

incr(self，name,amount=1)

自增name对应的值，当name不存在时，则创建name=amount，负责，则自增  # 计数器

参数：
  name:redis的name
  amount：自增数(浮点型)

decr(self,name,amount=1)

自减 name对应的值，当name不存在时，则创建nameamount，否则，则自增

参数：
  name：redis的name
  amount：自减数(整数)

append(key,value)

在redis的key对应的值后面追加内容
参数
key，redis的name
value，要追加的字符串

如：
conn.append('name','nb')

注意：在使用get('name')获取值的时候，取到的是bytes格式，指定：decode_responses=True，就完成转换中文转码显示

操作之Hash操作

Hash操作，redis中Hash在内存中的存储格式如下图

hset(name,key,value)

name对应的hash中设置一个键值对(不存在，则创建；否则，修改)

参数：
  name，redis的name
  key，name对应的hash中的key
  value，name对应的hash中的value
  
注：conn.hsetnx(name,key,value),当name对应的hash中不存在当前key时则创建(相当于添加)

hmset(name,mapping)，后面版本要删除

在name对应的hash中批量设置键值对
参数：
    name，redis的name
    mapping，字典，如：{'k1':'v1','k2':'v2'}

如：
    conn.hmset('xx',{'k1':'v1','k2':'v2'})

hmget(name,keys,*args)

在name对应的hash中获取多个key的值

参数：
  name，redis对应的name
  keys，要获取key的集合，如：['k1','k2','k3']
  *args,要获取的key，如：k1,k2,k3

如：
  conn.mget('xx',['k1','k2'])
  conn.hmget('xx','k1','k2')

hgetall(name)

获取name对应hash的所有键值
conn.hset('user','name','xunfei')
conn.hset('user','age',20)
# conn.hgetall('user')

hlen(name)

获取name对应的hash中键值对的个数

hvals(name)

获取name对应的hash中所有的value的值

hexists(name,key)

检查name对应的hash是否存在当前传入的key

hdel(name,*keys)

将name对应的hash中指定key的键值对删除

hincrby(name,key,amount=1)

自增name对应的hash中指定key的值，不存在则创建key=amount
参数：
  name:redis中的name
  key:hash对应的key
  amount:自增数(整数)

hincrbyfloat(name,key,amount=1.0)

自增name对应的hash中指定key的值，不存在则创建key=amount
参数：
  name，redis中的name
  key，hash对应的key
  amount，自增数(浮点型)
  
自增name对应的hash中指定的key的值，不存在则创建key=amount

hscan(name,cursor=0,match=None,count=None)

增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性讲数据全部获取完，从而防止内存被撑爆

参数:
  name:redis的name
  curosr:游标(基于游标分批获取数据)
  match:匹配指定key，默认None，表示所有的key
  count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
  
# for i in range(1000):                           
# hash类型没有顺序，python字典，之前没有顺序，3.6后有序了              
#      conn.hset('test_hash','key_%s'%i,'鸡蛋%s号'%i)
# print(conn.hgetall('test_hash'))                
# count是要取的条数，但是不准确，有点上下浮动                        
res=conn.hscan('test_hash',cursor=990,count=1)    
print(res)                                        

hscan_iter(name,match=None,count=None)

利用yield封装hascan创建生成器，实现分批去redis中获取数据

参数
  match：匹配指定key，默认None，表示所有的key
  count：每次分片最少获取个数，默认None表示采用redis的默认分片个数
  
  # 咱么用它比较多，它内部封装了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)

操作之List操作

List操作，redis中的list在内存中按照一个name对应的一个list来存储，如图：

lpush(name,values)

# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
 
# 如：
    # r.lpush('oo', 11,22,33)
    # 保存顺序为: 33,22,11
 
# 扩展：
    # rpush(name, values) 表示从右向左操作

lpushx(name,value)

# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
 
# 更多：
    # rpushx(name, value) 表示从右向左操作

llen(name)

# name对应的list元素的个数

linsert(name, where, refvalue, value))

# 在name对应的列表的某一个值前或后插入一个新值
 
# 参数：
    # name，redis的name
    # where，BEFORE或AFTER(小写也可以)
    # refvalue，标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
    # value，要插入的数据

r.lset(name, index, value)

# 对name对应的list中的某一个索引位置重新赋值
 
# 参数：
    # name，redis的name
    # index，list的索引位置
    # value，要设置的值

r.lrem(name, value, num)

# 在name对应的list中删除指定的值
 
# 参数：
    # name，redis的name
    # value，要删除的值
    # num，  num=0，删除列表中所有的指定值；
           # num=2,从前到后，删除2个；
           # num=-2,从后向前，删除2个

lpop(name)

# 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
 
# 更多：
    # rpop(name) 表示从右向左操作

lindex(name, index)

在name对应的列表中根据索引获取列表元素

lrange(name, start, end)

# 在name对应的列表分片获取数据
# 参数：
    # name，redis的name
    # start，索引的起始位置
    # end，索引结束位置  print(re.lrange('aa',0,re.llen('aa')))

ltrim(name, start, end)

# 在name对应的列表中移除没有在start-end索引之间的值
# 参数：
    # name，redis的name
    # start，索引的起始位置
    # end，索引结束位置（大于列表长度，则代表不移除任何）

rpoplpush(src, dst)

# 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
# 参数：
    # src，要取数据的列表的name
    # dst，要添加数据的列表的name

blpop(keys, timeout)

# 将多个列表排列，按照从左到右去pop对应列表的元素
 
# 参数：
    # keys，redis的name的集合
    # timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
 
# 更多：
    # r.brpop(keys, timeout)，从右向左获取数据爬虫实现简单分布式：多个url放到列表里，往里不停放URL，程序循环取值，但是只能一台机器运行取值，可以把url放到redis中，多台机器从redis中取值，爬取数据，实现简单分布式

brpoplpush(src, dst, timeout=0)

# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
 
# 参数：
    # src，取出并要移除元素的列表对应的name
    # dst，要插入元素的列表对应的name
    # timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞

自定义增量迭代

# 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
    # 1、获取name对应的所有列表
    # 2、循环列表
# 但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：
import redis
conn=redis.Redis(host='127.0.0.1',port=6379)
# 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])
# conn.flushall()
def scan_list(name,count=2):
    index=0
    while True:
        data_list=conn.lrange(name,index,count+index-1)
        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)

redis管道

mysql事务具有四大特新，以及事物的隔离级别，mysql5.7默认的隔离级别是：可重复读

但是在redis中，是否支持事务呢？

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

redis不像mysql一样，支持强事务，事务的四大特性不能全部满足，但是能满足一部分，通过redis的管道实现事务,redis本身不支持事务，但是可以通过管道，实现部分事务

redis通过管道，来保证命令要么都成功，要么都市白，完成事物的一致性，但是管道只能用在单实例中，集群环境中不支持pipline

import redis

conn = redis.Redis()
pipline = conn.pipeline(transaction=True)
# 往管道放代码
pipline.decr('a', 2)  # a减2
raise Exception('我崩了')
pipline.incr('b', 2)  # b加2
pipline.execute()  # 执行管道里的代码
conn.close() 

redis其他操作

# 集合，有序集合 --- redis模块提供的方法API
# 通用操作：无论是5大类型的那种，都支持

import redis

conn = redis.Redis()
# 1 delete(*names)
# conn.delete('age', 'name')

# 2 exists(name)
# res=conn.exists('xx')
# print(res)  # 0


# 3 keys(pattern='*')
# res=conn.keys('*o*')
# 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()

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)



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