redis

redis介绍安装

# 0 数据库
    -存数据的软件
# 1 关系型数据库
    -PostgreSQL（后面安装了解看看），mysql，sqlserver，oracle。。。
    -sql语句，通用
# 2 非关系型数据库
    -redis，mongod，clickhouse，infludb，elasticsearch。。。
# 3 非关系型数据库：no sql 
　　-c语言写的 服务（监听端口），
　　-用来存储数据的，数据是存储在内存中，取值，放值速度非常快， 10w qps　

# 4 redis：
    1 开源使用c编写的cs架构软件
        -c:客户端：命令创建，桌面软件resp，Navicat，Python代码，Go，Java，Node
        -s：服务端:一台服务器，一直运行，监听 6379端口
    2 key-value形式存储
    3 vaule有5种数据类型
        -字符串
        -列表
        -hash
        -集合
        -有序集合
    4 纯内存存储：速度非常快--》适合用于高并发场景
    5 可以持久化：永久保存
    6 数据操作-》单进程，单线程架构--》没有锁
    7 使用了IO多路复用的模型：并发量高
    
    
# 5 redis版本 最新：7.x  win上 5.x
    -https://redis.io/downloads/
    -Redis Stack downloads：编译过后的软件，不提供win版本
    -redis：源码，需要编译
    -不支持：微软，基于源码修改--》能在win上编译
# 6 win安装redis 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
    
    
# 7 一路下一步，安装成功
    1 C:\Program Files\Redis 有两个可执行文件
        redis-cli---》mysql  客户端
        redis-server--》mysqld 服务端
        
    2 自动在服务中，做一个redis服务，以后通过服务启动和停止
    
    
    
# 8 redis客户端
    -1 cmd命令中的reids-cli
        -redis-cli  # 默认链本地的6379
        -redis-cli -h 地址 -p 端口
        
    -2 软件：rdm,resp：老版本免费，新版本收费
        -输入地址和端口，连接即可
        
        
    -3 软件：navicat：收费
        -输入地址和端口，连接即可
        
        
        
# 9 redis服务启动和停止
    
    -1 使用服务--》点击启动，停止即可
        -net start redis
        -net stop redis
         
    -2 使用命令：（启动server）
        -redis-server 配置文件启动
        -redis-server ./redis.windows-service.conf
        -ctrl c
        
    -3 关闭：在客户端
        shutdown ：友好关闭

8.cmd操作

 

 。

resp操作

 。

navicat操作

。

。

。

python操作redis

普通链接

1 模块，redis
# pip install redis

# 2 使用 redis链接redis
import redis

conn = redis.Redis(
    host="localhost",
    port=6379,
    db=0,
    password=None)
print(conn)
conn.set('name', 'jh')
conn.close()

连接池链接

连接池是什么，作用是什么

 

python链接redis使用连接池

import redis

# 1 做一个连接池,POOL 对象，应该是单例的，全局只有这一个对象
POOL = redis.ConnectionPool(max_connections=10, host='127.0.0.1', port=6379, decode_responses=True)

### 使用####
# from pool import POOL  # python 的模块导入，是天然单例

# 2 从池中拿链接
conn = redis.Redis(connection_pool=POOL)
# 3 使用链接操作redis
res = conn.get('name')
print(res)
# 4 关闭,把连接放回池中
conn.close()

# 补充：
	-django--》连接数据库---》有没有连接池？
    -django--》连接mysql--》如何使用连接池？
    
# python如何实现单例
	-6种
    	-以模块导入

redis字符串操作

import redis

conn = redis.Redis()
# 1 set(name, value, ex=None, px=None, nx=False, xx=False)
# 1.1 基本使用
conn.set('age', 18)
# 1.2 ex使用:10s后过期，被清理掉
conn.set('hobby', '篮球', ex=10)
# 1.3 nx，如果设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果
conn.set('name', '666', nx=True)  # name存在，不会修改了
# 1.4 xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值
conn.set('name', '666', xx=True)  # name存在，会修改了，name不存在，不会新建
conn.set('hobby', '篮球', xx=True)  # name存在，会修改了，name不存在，不会新建

# redis实现分布式锁底层使用nx xx实现
# 2 setnx(name, value)  等同于 conn.set('name','666',nx=True)
# 设置值，只有name不存在时，执行设置操作（添加）,如果存在，不会修改

# 3 setex(name, value, time) 设置过期时间过期时间秒
conn.setex('hobby', 4, '足球')

# 4 psetex(name, time_ms, value)  过期时间毫秒
conn.psetex('hobby', 5000, 'sss')

# 5 mset(*args, **kwargs)  批量设置
conn.mset({'name': 'xxx', 'age': 19, 'height': 183, 'weight': 140})

# 6 get(name)  获取之
print(conn.get('weight'))

# 7 mget(keys, *args) 值放列表里面
res = conn.mget('name', 'age')
# res=conn.mget(['name','hobby','height'])
print(res)

# 8 getset(name, value)  获取值然后设置新值
res = conn.getset('name', 'sdsaf')
print(res)

# 9 getrange(key, start, end)  # 获取起始和结束位置的字符串 前闭后闭  取字节
res = conn.getrange('name', 0, 1)
print(res)

# 10 setrange(name, offset, value)
conn.setrange('name', 4, 'xxss')

# 操作比特位--后面讲
# 11 setbit(name, offset, value)
# 12 getbit(name, offset)
# 13 bitcount(key, start=None, end=None)
# 14 bitop(operation, dest, *keys)


# 15 strlen(name)  统计字节长度
print(conn.strlen('name'))

# 15 incr(self, name, amount=1)  # 自增，做计数器，性能高,单线程，没有并发安全问题，不会错错乱
conn.incr('age')
conn.incrby('age', 2)

# 16 incrbyfloat(self, name, amount=1.0)
# 17 decr(self, name, amount=1)
conn.decrby('age', 3)
# 18 append(key, value)
conn.append('name', 'ddd')
conn.close()

。

redis hash操作

import redis

conn = redis.Redis(decode_responses=True)
# 1 hset(name, key, value)
# user-info-01 存用户id为1的用户信息
conn.hset('user-info-01', 'name', '吉吉国王')
conn.hset('user-info-01', 'age', 8)
conn.hset('user-info-01', 'hobby', '篮球')

# 2 hmset(name, mapping)  -->变成了hset，批量设置
conn.hset('user-info-02', mapping={'name': '猪猪侠', 'age': 18})

# 3 hget(name,key) 获取用户信息值
print(conn.hget('user-info-01', 'name'))

# 4 hmget(name, keys, *args) 批量获取值
print(conn.hmget('user-info-01', 'name', 'age', 'hobby'))
print(conn.hmget('user-info-01', ['name', 'age', 'hobby']))

# 5 hgetall(name) 拿到所有值
print(conn.hgetall('user-info-02'))

# 6 hlen(name) 统计字典的大小
print(conn.hlen('user-info-01'))

# 7 hkeys(name) 获取所有的key
print(conn.hkeys('user-info-01'))

# 8 hvals(name) 获取所有的value
print(conn.hvals('user-info-01'))

# 9 hexists(name, key) 判断key是否存在
print(conn.hexists('user-info-02', 'hobby'))

# 10 hdel(name,*keys) 删除key
conn.hdel('user-info-01', 'hobby', 'age')

# 11 hincrby(name, key, amount=1)
conn.hincrby('user-info-01', 'age')  # 有会自增，没有会创建并自增

# 12 hincrbyfloat(name, key, amount=1.0)
# 如果hash寸的数据量很大，不能使用hgetall一次性全取回来---》分批取值
# hash 类型无序，不会按key排序--》python 的字典有序

# 13 hscan(name, cursor=0, match=None, count=None) 
for i in range(1000):
    conn.hset('map_demo', i, '鸡蛋_%s' % i)

# 一次性取出来
res = conn.hgetall("map_demo")
print(res)

# 分批取 hscan 不单独用  ,count 是取的条数，但是有时候上下会差一点点
res = conn.hscan('map_demo', count=11)
print(res)
print(len(res[1]))
print(res[1])
res = conn.hscan('map_demo', cursor=64, count=10)
print(res)

# 14 hscan_iter(name, match=None, count=None)--取出所有值，但是分批取
for item in conn.hscan_iter('map_demo', count=10):
    print(item)

conn.close()

。

。

redis list操作

# 作用
# 1 跨进程间通信  ---》消息队列
# 2 实现分布式
# 3 队列和栈

import redis

conn = redis.Redis(decode_responses=True)
# 1 lpush(name, values) 表示从左向右操作
conn.lpush('girls', '刘亦菲')
conn.lpush('girls', '迪丽热巴')
conn.lpush('girls', '小红')

# 2 rpush(name, values) 表示从右向左操作
conn.rpush('girls', '小紫')

# 3 lpushx(name, value)  在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
conn.lpushx('girls', '古力娜扎')

# 4 rpushx(name, value) 存在则表示从右向左操作

# 5 llen(name)  统计长度
print(conn.llen('girls'))

# 6 linsert(name, where, refvalue, value)) 从哪插值
conn.linsert('girls', 'before', '刘亦菲', '上海刘亦菲')
conn.linsert('girls', 'after', '刘亦菲', '北京刘亦菲')

# 7 r.lset(name, index, value) 索引设置
conn.lset('girls', '0', 'xx')

# 8 r.lrem(name, value, num)  删除
conn.lrem('girls', 1, '刘亦菲')  # 从左侧删除一个符合条件
conn.lrem('girls', -1, '刘亦菲')  # 从右侧删除一个符合条件
conn.lrem('girls', 0, '刘亦菲')  # 删除所有符合条件

# 9 lpop(name)  表示从左向右操作 ，弹出
# 10 rpop(name) 表示从右向左操作
print(conn.lpop('girls'))

# 11 lindex(name, index)  查看索引为1的信息
print(conn.lindex('girls', 1))

# 12 lrange(name, start, end) 取从第几个到第几个的值
print(conn.lrange('girls', 0, 1))

# 13 ltrim(name, start, end) 修剪，只保留从哪到哪中间的树
conn.ltrim('girls', 1, 3)

# 14 rpoplpush(src, dst) 表示从右向左操作，从src中弹出一个值，放到dst中

# 15 blpop(keys, timeout)  block--》阻塞
res = conn.blpop('boys')
print(res)
# 16 r.brpop(keys, timeout)，从右向左获取数据
# 17 brpoplpush(src, dst, timeout=0)
conn.close()

。

。

redis其他操作

import redis

conn = redis.Redis()
# 1. 删值delete(*names)
conn.delete('name', 'user-info-01')
# 2. 看是否有值exists(name)
print(conn.exists('age1'))

# 3.取出所有keys(pattern='*')
# print(conn.keys('user*'))

# 4.设置过期时间 expire(name ,time)
conn.expire('age', 5)

# 5.改名 rename(src, dst)
conn.rename('girls', 'hobby01')

# 6.移动 move(name, db))
conn.move('hobby01', 3)

# 7.随机弹出key randomkey()
print(conn.randomkey())

conn.close()

。

。

django中使用redis

方式一：通用方式

######## 写个pool.py
import redis
POOL = redis.ConnectionPool(max_connections=10, decode_responses=True)
###### 在哪里用，导入用即可

# redis测试使用  user.view
from utils.redis_pool import POOL
import redis
class RedisView(APIView):
    def get(self, request, *args, **kargs):
        conn = redis.Redis(connection_pool=POOL)
        conn.incrby('count')
        res = conn.get('count')
        return APIResponse(msg='您是第%s个访问的' % res)

 

 

方式二：django-redis(第三方)

#1  安装
pip install django-redis

# 2 配置文件配置
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",
        }
    }
}

# 3 在使用的位置
from django_redis import get_redis_connection
class RedisView(ViewSet):
    def list(self, request):
        conn = get_redis_connection() # 从池中获取一个链接
        res= conn.get('count')
        return APIResponse(msg='您是第%s个访问的' % res)

 

方式三：django的缓存

# django内置的，可以直接操作缓存---》缓存的位置--》内存--》只要项目一重启，数据就没了
# 后期，我们要把缓存数据，放到 redis中 ，redis可以持久化，项目停止，但redis还运行，数据就不会丢

# 只要在配置文件中，如下配置，以后只要使用 cache.set  和 cache.get 通过都是去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",
        }
    }
}

# cache.set()  设置缓存
# cache.get()  获取缓存


## 以后再django中，可以直接使用
cache.set 和cache.get  操作redis，用它错缓存 ---》非常简单

## 重点：
    -优势：redis 分数据类型， 只能设置5种数据类型
       -django的缓存来讲 ，不限制类型，可以放python的任意类型
    
    -django的缓存来讲，cache.set('redis的key','不区分类型:放python的任意类型')  # person
    -cache.get('userinfo')
    -django cache 底层是基于： 把你存储的类型---》使用pickle序列化--》bytes格式---》当redis的字符串形式存到redis中
    
    
    -以后咱们做redis的操作，可以直接使用django的缓存， 不需要考虑类型

from django.core.cache import cache

class RedisView(APIView):
　　

def get(self, request, *args, **kwargs):
    cache.set('name','jh')
    return APIResponse(msg=f'接口被访问了几次')