redis的使用

Posted 2020-12-18

1 python操作Redis普通链接

# 1 先安装
pip3 install redis
# 简单使用
from redis import Redis
# conn=Redis()
# 连接对象
conn=Redis(host=\'127.0.0.1\', port=6379)
# 往里面存值
conn.set(\'name\',\'nb\')

2 Python操作Redis之连接池

2.1先造一个池子

#redis连接池
import redis
#pool必须是单例的
POOL = redis.ConnectionPool(host=\'127.0.0.1\', port=6379,max_connections=100)  # 造一个池子,最多能放100个连接

2.2 连接

import redis
from t_redis_pool import POOL  
r = redis.Redis(connection_pool=POOL)  
# 只要执行这一句话，就是从池中拿出一个连接
ret=r.get(\'name\') # 这样就拿到了我们刚刚放的值

3 string操作

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

set的用法

conn.set(\'name\',\'dsb\') 最基本的使用方法
conn.set(\'name\',\'dsb\',ex=3) 三秒钟过期时间
conn.set(\'name\',\'dsb\',px=3000) 三千毫秒过期时间
conn.set(\'name\',\'dsb\'，nx=True) name不在时可操作，存在就不可操作
conn.set(\'name\',\'dsb\'，xx=True) name在时可操作，不在就不可操作

mset(*args, **kwargs)

批量设置值

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

mget(keys, *args)

批量获取
如：
    mget(\'k1\', \'k2\')
    或
    r.mget([\'k3\', \'k4\'])

getset(name, value)

设置新值并获取原来的值

getrange(key, start, end)

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

setrange(name, offset, value)

# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
# 参数：
    # offset，字符串的索引，字节（一个汉字三个字节）
    # value，要设置的值

incr(self, name, amount=1)

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（必须是整数）
conn.incr(\'number\')  # 只要一执行，数字加1
conn.incr(\'number\'，3)  # 只要一执行，数字加3
conn.incr(\'number\'，-2)  # 只要一执行，数字减2
# 注：同incrby

append(key, value)

# 在redis name对应的值后面追加内容
 
# 参数：
    key, redis的name
    value, 要追加的字符串
conn.append(\'name\',\'nb\')

string小结

常用的几个
#set :很多参数
#get
#mset
#mget
#incr
#decr
#append

4 Hash操作

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

hset(name, key, value)

# name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
 
# 参数：
    # name，redis的name
    # key，name对应的hash中的key
    # value，name对应的hash中的value
 
# 注：
    # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）

hmset(name, mapping)

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

hget(name,key)

# 在name对应的hash中获取根据key获取value

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\')

hgetall(name)

# 获取name对应hash的所有键值
print(re.hgetall(\'xxx\').get(b\'name\'))
ps：一次性取所有，最好不用

hlen(name)

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

hkeys(name)

# 获取name对应的hash中所有的key的值

hvals(name)

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

hexists(name, key)

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

hdel(name,*keys)

# 将name对应的hash中指定key的键值对删除
print(re.hdel(\'xxx\',\'sex\',\'name\'))

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
    # 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

# 以后想取出hash类型内所有的数据，不建议用hgetall，建议用hscan_iter
# 一次性先取一部分回来（假设有1w条，先取回100条，把这100条做成了生成器）
ret=conn.hscan_iter(\'hash1\')
print(ret)
for i in ret:
    print(i)

hash小结

# 重点掌握
# hset
# hget
#hmset
#hmget
# hincrby
# 区分hgetall和hscan_iter

5 List操作

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

lpush(name,values)

# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
 
# 如：
    # r.lpush(\'list1\', 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，要插入的数据

# 在第三条数据前面插入一条77777777
ret=conn.linsert(\'list1\',\'before\',\'3\',\'77777777\')
# 在第三条后面插入一条66666666
ret=conn.linsert(\'list1\',\'after\',\'3\',\'66666666\')

r.lset(name, index, value)

# 对name对应的list中的某一个索引位置重新赋值
 
# 参数：
    # name，redis的name
    # index，list的索引位置
    # value，要设置的值
    
# 将第四条数据设置为22222
ret=conn.lset(\'list1\',3,\'22222\')  #从0开始计数

r.lrem(name, value, num)

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

ret=conn.lrem(\'list1\',2,\'5\')  # 从前往后删除两个5
ret=conn.lrem(\'list1\',-1,\'5\') # 从后往前删除1个5
ret=conn.lrem(\'list1\',0,\'5\')   # 删除所有5

pop(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\')))
# 列表切片
ret=conn.lrange(\'list1\',0,2)  # 前闭后闭

ltrim(name, start, end)

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

blpop(keys, timeout) （*********）

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

自定义一个分批获取列表的数据

# 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)

list小结

# 重点常用
lpush
lpop
blpop
lrange
llen

6 管道

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

import redis
 
pool = redis.ConnectionPool(host=\'10.211.55.4\', port=6379)
 
r = redis.Redis(connection_pool=pool)
 
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
pipe.multi()
# 这里不会执行 
pipe.set(\'name\', \'jake\')
pipe.set(\'age\', \'22\')

#这句话才是真的去执行
pipe.execute()

7 江狗中使用redis

安装django-redis模块

pip3 install django-redis

setting里配置：

# 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",
        }
    }
}

视图函数中：

from django_redis import get_redis_connection
conn = get_redis_connection(\'default\')
print(conn.hgetall(\'xxx\'))

7.1 其他框架通用方法：

新建一个pool文件

import redis
POOL = redis.ConnectionPool(host=\'127.0.0.1\', port=6379,password=\'1234\',max_connections=1000)

在视图中使用：

import redis
from django.shortcuts import render,HttpResponse
from utils.redis_pool import POOL

def index(request):
    conn = redis.Redis(connection_pool=POOL)
    conn.hset(\'kkk\',\'age\',18)

    return HttpResponse(\'设置成功\')
def order(request):
    conn = redis.Redis(connection_pool=POOL)
    conn.hget(\'kkk\',\'age\')

    return HttpResponse(\'获取成功\')