Redis的安装和使用

一,redis 和Memcached

redis可以持久化(可以把数据持久化到硬盘),支持五大数据类型,单线程

​ -str
-列表
-字典(hash)
-set
-zset(有序集合)

Memcached 不能持久化,一断电,就没了,只支持一种数据类型,只支持str

二,Redis的安装

(一)windows

1、要安装Redis，首先要获取安装包。Windows的Redis安装包需要到以下GitHub链接找到。链接：https://github.com/MSOpenTech/redis。打开网站后，找到Release，点击前往下载页面。

2、在下载网页中，找到最后发行的版本（此处是3.2.100）。找到Redis-x64-3.2.100.msi和Redis-x64-3.2.100.zip，点击下载。这里说明一下，第一个是msi微软格式的安装包，第二个是压缩包。

3、双击刚下载好的msi格式的安装包（Redis-x64-3.2.100.msi）开始安装。 (直接下一操作就好)

4,开启redis服务

直接启动 进入redis根目录，执行命令: #加上‘&’号使redis以后台程序方式运行

./redis-server &

5,开启rdis客户端

redis-cli

三,redis操作(存的都是bytes类型)

redis支持5大数据类型,只支持第一层,也就是说字典的value值,必须是字符串,如果value想存字典格式,必须用json转换成字符串

(一)普通链接

import redis

conn = redis.Redis(host='127.0.0.1', port=6379)
conn.set('foo', 'Bar')
print(r.get('foo'))

(二)连接池

import redis
# 新建链接池,Ip,端口,连接池的数目(默认2**31)
pool = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connection=100)
r = redis.Redis(connection_pool=pool)
r.set('foo', 'Bar')
print(r.get('foo'))

(三)字符串的操作

import redis
# 拿到一个redis 的链接
conn=redis.Redis('127.0.0.1',6379)

1,增加set方法:set(name, value, ex=None, px=None, nx=False, xx=False)

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

2,取值get方法get(name)

conn.get('k1')

3,批量设置值mset(**args, *kwargs )

如：
    mset(k1='v1', k2='v2')
    或
    mget({'k1': 'v1', 'k2': 'v2'}

4,批量获取mget:mget(keys, *args)

如：
    mget('k1', 'k2')
    或
    r.mget(['k3', 'k4'])

5, 追加字符append:append(key, value)

参数：
    key, redis的name
    value, 要追加的字符串

6,自增incr:incr(self, name, amount=1)

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（必须是整数）默认是1,可以不填
 
# 注：同incrby

7,key对应的字符长度:strlen(name)

# 返回name对应值的字节长度（一个汉字3个字节）

8,获取子序列,getrange(key, start, end) 起始位置都是闭区间

# 获取子序列（根据字节获取，非字符）
# 参数：
    # name，Redis 的 name
    # start，起始位置（字节）
    # end，结束位置（字节）

(四),字典操作hash

redis中Hash存储格式如下(字典套字典的格式)

1,hash存入数据:hset(name, key, value)

# name对应的hash中设置一个键值对（key不存在，则创建；否则，修改）
# 参数：
    # name，redis的name
    # key，name对应的hash中的key
    # value，name对应的hash中的value

2,取数据:hget(name,key)

3,批量存入数据:hmset(name, mapping)

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

4,批量取出数据:hmget(name, keys, *args)

# 在name对应的hash中获取多个key的值
 
# 参数：
    # name，reids对应的name
    # keys，要获取key集合，如：['k1', 'k2', 'k3']
    # *args，要获取的key，如：k1,k2,k3
 
# 如：
    # r.mget('xx', ['k1', 'k2'])
    # 或
    # print r.hmget('xx', 'k1', 'k2')

5,获取全部:hgetall(name)

6,hash中键值对的个数:hlen(name)

7,name中所有key值:hkeys(name)

8,name中所有value值:hvals(name)

9,检查name中是否存在响应的Key:hexists(name, key)

10,将name对应的hash中指定的键删除:hdel(name,*keys)

re.hdel('xxx','sex','name')

11,自增name对应的hash中的指定key的值，不存在则创建key=amount

hincrby(name, key, amount=1)   # 整数
hincrbyfloat(name, key, amount=1.0)    # 小数

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

# 增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆
 
# 参数：
    # name，redis的name
    # cursor，游标（基于游标分批取获取数据）
    # match，匹配指定key，默认None 表示所有的key
    # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
 
# 如：
    # 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
    # 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
    # ...
    # 直到返回值cursor的值为0时，表示数据已经通过分片获取完毕

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

# 利用yield封装hscan创建生成器，实现分批去redis中获取数据
 
# 参数：
    # match，匹配指定key，默认None 表示所有的key
    # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
 
# 如：
    # for item in r.hscan_iter('xx'):
    #     print item

# 添加数据到redis
for i in range(1000):
     conn.hset('m2','key%s'%i,'value%s'%i)
# 指定每次取10条,直到取完
ret=conn.hscan_iter('m2',count=100)
# 生成器
print(ret)
# 下面一个一个的取出值
print(next(ret))
print(next(ret))
print(next(ret))
for i in ret:
    print(i)

13 extend

# 把dic打散,然后放在列表l1中
ll=[1,2]
s='hello'
dic={'name':'lqz','age':18}
ll.extend(dic)
print(ll)

(五)列表操作

从左边开始添加一条数据:lpush(name,values)

# 如：
    # r.lpush('oo', 11,22,33)
    # 保存顺序为: 33,22,11
 
# 扩展：
    # rpush(name, values) 表示从右向左操作

lpushx(name,value) :# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边

rpushx(name, value) 表示从右向左操作

name对应的list元素的个数:llen(name)

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) 表示从右向左操作

在name对应的列表中根据索引获取列表元素:lindex(name, index)

在name对应的列表分片获取数据:lrange(name, start, end)

    # name，redis的name
    # start，索引的起始位置(全闭区间)
    # end，索引结束位置  print(re.lrange('aa',0,re.llen('aa')))

在name对应的列表中移除没有在start-end索引之间的值:ltrim(name, start, end)

    # name，redis的name
    # start，索引的起始位置
    # end，索引结束位置（大于列表长度，则代表不移除任何）

从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边:rpoplpush(src, dst)

    # src，要取数据的列表的name
    # dst，要添加数据的列表的name

将多个列表排列，按照从左到右去pop对应列表的元素:blpop(keys, timeout)

重点 如果列表中没有值,会一直hang住,实现简单的分布式(检测到如果有值就会直接pop掉,返回值是pop掉的)

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

(六)管道

redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。

# 管道,实现事务操作
import redis
pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
conn = redis.Redis(connection_pool=pool)
# pipe = r.pipeline(transaction=False)
# 拿到一个管道对象
pipe = conn.pipeline(transaction=True)
# 开启一次执行多条命令
pipe.multi()
pipe.set('name', 'lqz')
pipe.set('role', 'teacher')
# 直接执行上面所有命令
pipe.execute()

四Python操作redis

安装redis

pip3 install django-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": 1000}
            # "PASSWORD": "123",
        }
    }
}

第一种方式:

redis_pool中配置

import redis
POOL=redis.ConnectionPool('127.0.0.1',6379,max_connections=1000)

视图层中:

from django.shortcuts import render, HttpResponse

# Create your views here.
import redis
# from app01.redis_pool import POOL
from django_redis import get_redis_connection
print(111)

def setname(request):
    conn = redis.Redis(connection_pool=POOL)
    conn.set('name', '刘大帅比')
    return HttpResponse('设置成功')


def getname(request):
    conn = redis.Redis(connection_pool=POOL)
    name = conn.get('name').decode('utf-8')
    return HttpResponse(name)

第二种方式

设置中设置以后

在视图层:

def setname(request):
    conn=get_redis_connection()
    conn.set('name', '测试')
    return HttpResponse('设置成功')


def getname(request):
    conn = get_redis_connection()
    name = conn.get('name').decode('utf-8')
    return HttpResponse(name)


from django.views.decorators.cache import cache_page
@cache_page(5)
def test(request):
    import time
    ctime=time.time()
    return HttpResponse(str(ctime))