redis -【基础】

目录

Redis 基础

1 Redis介绍与安装

1.1 介绍

Redis是缓存数据库，不仅仅可以做缓存，是【非关系型数据库NoSQL】，区别于MySQL【关系型数据】【表，外键，关系】

作用：用来存储数据，数据是存储在内存中的，取值和放值速度非常快，速度达到10w qps，也可以提高数据的并发量

# 版本
	最新： 7.x
    公司里 5.x比较多
# 安装
	-mac   源码编译安装
    -linux 源码编译安装
    -win   微软自己，基于源码，改动，编译成安装包

1.2 安装

"""
1、官网下载：安装包或是绿色面安装
2、安装并配置环境变量
 
# 官网：https://redis.io/
	-下载完是源代码：c语言源码 ：https://redis.io/download/#redis-stack-downloads
    -最稳定：6.x
    -最新7.x
 
# 中文网：http://redis.cn/download.html
	-上面最新只到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
  
"""

2 Redis普通连接和连接池

通过python连接redis，首先要下载模块redis

2.1 建立连接池的目的

当多个django进程可能会导致redis连接数较高，影响redis的性能，使用连接池可以优化Redis数据库的连接和请求处理。

它允许多个客户端在需要时共享已经建立的数据库连接，而不是每次请求都需要重新建立连接，这可以显著提高Redis的性能和可伸缩性。

连接池中的连接被维护在一个连接池中，每个连接都可以被多个客户端重用。当客户端需要与Redis交互时，它可以从连接池中获取一个连接，使用它完成请求后，将连接归还给连接池，以供其他客户端使用。

补充Mysql：django 中操作mysql，没有连接池的，一个请求就是一个mysql连接

使用django连接池：

https://blog.51cto.com/liangdongchang/5140039

  • python连接redis
# 安装redis模块
 
# 第1步：导入模块redis
from redis import Redis
 
# 第2步：实例化得到对象
conn = Redis(host='127.0.0.1', port=6379)
 
# 第3步：使用conn，操作redis
# 获取name的值
res = conn.get('name') # 返回的数据是bytes格式
print(res)  # b'duoduo'
 
# 第4步：
conn.set('desc', 'handsome boy')
 
conn.close()

2.2 django中开100个线程来操作redis

# 传统方案 开100个线程来操作
 
from threading import Thread
from redis import Redis
 
def task():
    # 第2步：实例化得到对象
    conn = Redis(host='127.0.0.1', port=6379)
    # 第3步：使用conn，操作redis
    # 获取name的值
    res = conn.get('name')  # 返回的数据是bytes格式
    print(res)  # b'duoduo'
 
for i in range(100):
    t = Thread(target=task)
    t.start()

2.3 连接池方案

" 连接池"
import redis
 
# 第1步：创建连接数为10的连接池
POOL = redis.ConnectionPool(max_connections=10, host='127.0.0.1', port=6379)
 
# 第2步：从连接池中拿到一个连接
conn = redis.Redis(connection_pool=POOL)
 
# 第3步：使用半连接池
print(conn.get('desc'))
 
# 第4步：关闭
conn.close()

2.4 多线程测试连接池

要注意建立的连接池的位置，要将池子的位置设置在全局中。否则，有可能在每个线程中创建了一个池，而每个池子拿一个连接，性能会更低

import redis
from threading import Thread
 
# 第1步：创建连接数为10的连接池
POOL = redis.ConnectionPool(max_connections=10, host='127.0.0.1', port=6379)
 
 
def task():
    # 第2步：实例化得到对象
    conn = redis.Redis(connection_pool=POOL)
 
    # 第3步：使用conn，操作redis
    # 获取name的值
    res = conn.get('name')  # 返回的数据是bytes格式
    print(res)  # b'duoduo'
 
# 当开了线程多语池子的连接数量，则会报错
for i in range(10):
    t = Thread(target=task)
    t.start()

2.5 单例模式

将新建的连接池单独放在文件中

使用时，从模块中导入，这样即使导入放在任务中，也不会开启多个连接池，因为导入的是模块

(1)新建single_pool.py

import redis
 
POOL = redis.ConnectionPool(max_connections=10, host='127.0.0.1', port=6379)

(2)在多线程中导入

import redis
from threading import Thread
 
def task():
		# 第1步:从模块中导入，即使放在任务中，也不会开启多个连接池，因为导入的是模块
from single_pool import POOL
    # 第2步：实例化得到对象
    conn = redis.Redis(connection_pool=POOL)
 
    # 第3步：使用conn，操作redis
    # 获取name的值
    res = conn.get('name')  # 返回的数据是bytes格式
    print(res)  # b'duoduo'
 
# 当开了线程多语池子的连接数量，则会报错
for i in range(10):
    t = Thread(target=task)
    t.start()

3 Redis的数据类型

redis的数据是以key-value形式，存储在内存中的，如果断电数据会丢失，所以需要有持久化方案【也就是将数据存储到硬盘上】

  • 持久化的方案：

①

②

  • 5种数据类型：

① 字符串

用的最多，做缓存，redis没有并发安全的问题，所以适合做计数器

Redis没有锁的概念，任务操作数据的时候都是单进程单线程架构，所以没有数据安全的问题

Mysql中使用了锁的概念，行锁。。等使得一些涉及安全的数据在操作的时候，可以从并行编程串行，保护了安全，但是牺牲了性能。

② 列表

做简单的消息队列，程序A存入，程序B读取

③ 字典（hash类型）

④ 集合

⑤ 有序集合

(1) 字符串类型

String操作，redis中的String在内存中按照一个name对应一个value来存储，value的形式可以有多种

image-20230309162128603 
'''
1 set(name, value, ex=None, px=None, nx=False, xx=False)
2 setnx(name, value)
3 setex(name, value, time)
4 psetex(name, time_ms, value)
5 mset(*args, **kwargs)
6 get(name)
7 mget(keys, *args)
8 getset(name, value)
9 getrange(key, start, end)
10 setrange(name, offset, value)
11 setbit(name, offset, value)
12 getbit(name, offset)
13 bitcount(key, start=None, end=None)
14 bitop(operation, dest, *keys)
15 strlen(name)
16 incr(self, name, amount=1)
# incrby
17 incrbyfloat(self, name, amount=1.0)
18 decr(self, name, amount=1)
19 append(key, value)
'''

演示：

  • 注意：获取到值是bytes类型
1 设置值 set(name, value, ex=None, px=None, nx=False, xx=False)
 
ex:过期时间，单位为秒 
px:过期时间，单位为毫秒
nx:如果设置为True，则只有name不存在时，当前set操作才执行, 值存在，就修改不了，执行没效果
xx:如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值
"实现分布式锁，底层基于nx实现的"
 
conn.set('person_name', '球球', 3)
 
2 setnx(name, value)
等同于：conn.set('person_name1', 'luka',nx=True)
只有name不存在时候，才能执行；如果存在，则无法修改
 
conn.setnx('person_name1', 'luka')
 
3 setex(name, time, value)
等同于：conn.set('person_name1', 'luka',ex=3)
 
conn.setex('person_name1', 3, 'luka')
 
 
4 psetex(name, time_ms, value)
time_ms:单位为毫秒
 
conn.psetex('person_name1', 3000, 'luka')
 
 
5 mset(*args, **kwargs)
批量设置值，传入字典
 
conn.mset({'pet_name': '球球', 'type': 'dog'})
 
 
 
6 get(name)
获取值，
print(str(conn.get('pet_name'), encoding='utf-8'))
 
7 mget(keys, *args)
批量获取，得到的结果放在一个列表中
print(conn.mget(['pet_name', 'type']))
print(conn.mget('pet_name', 'type'))
---
[b'\xe7\x90\x83\xe7\x90\x83', b'dog']
[b'\xe7\x90\x83\xe7\x90\x83', b'dog']
 
8 getset(name, value)
设置新值并获取原来的值，【只通过了一次网络就回来了，比先get，再set效率高】
 
 
print(str(conn.getset('pet_name', 'qiuqiu'), encoding='utf8'))
 
 
9 getrange(key, start, end)
获取子序列（根据字节获取，非字符）
参数：
    name，Redis 的 name
    start，起始位置（字节）
    end，结束位置（字节）
 
print(str(conn.getrange('pet_name',0,2), encoding='utf8'))
---
qiu
 
 
 
10 setrange(name, offset, value)
 
修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
 
参数：
  offset，字符串的索引，字节（一个汉字三个字节）
  value，要设置的值
返回值是整个数据的字节长度
 
print(conn.setrange('pet_name', 2, 'aaa'))
    
----比特位操作----  
11 setbit(name, offset, value)  
12 getbit(name, offset)
13 bitcount(key, start=None, end=None)
14 bitop(operation, dest, *keys)
----  ----  
 
 
15 strlen(name)   
返回name对应值的字节长度（一个汉字3个字节）
print(conn.strlen('pet_name'))
---
pet_name：qiu
3
 
16 incr(self, name, amount=1)
 
   同：incrby
   自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
  
   自增,不会出并发安全问题，单线程架构，并发量高
    
    参数：
       name,Redis的name
       amount,自增数（必须是整数）
       
conn.incr('size', amount=22)
---
每次调用自增22
 
 
 
17 incrbyfloat(self, name, amount=1.0)
自增小数
 
conn.incrbyfloat('size', 1.2)
---
每次调用自增 1.2
 
 
18 decr(self, name, amount=1)
 
自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
 
参数：
    name,Redis的name
    amount,自减数（整数）
      
    
19 append(name, value)
在redis name对应的值后面追加内容
 
conn.append('size', 'ssssss')

(2) 列表类型

img

'''
1 lpush(name, values)
2 rpush(name, values) 表示从右向左操作
3 lpushx(name, value)
4 rpushx(name, value) 表示从右向左操作
5 llen(name)
6 linsert(name, where, refvalue, value))
7 r.lset(name, index, value)
8 r.lrem(name, value, num)
9 lpop(name)
10 rpop(name) 表示从右向左操作
11 lindex(name, index)
12 lrange(name, start, end)
13 ltrim(name, start, end)
14 rpoplpush(src, dst)
15 blpop(keys, timeout)
16 r.brpop(keys, timeout)，从右向左获取数据
17 brpoplpush(src, dst, timeout=0)
 
'''

演示：

1 lpush(name, values)
在name对应的list中添加元素，每个新的元素都添加到列表的最左边，
 
conn.lpush('boys','陈星旭','宋威龙')
conn.lpush('boys', '王子奇')
 
2 rpush(name, values) 表示从右向左操作
 
conn.rpush('boys', 'tom')
conn.rpush('boys', 'jerry')
conn.rpush('boys', 'duo')
conn.rpush('boys', 'qiuqiu')
conn.rpush('boys', 'luka')
 
 
3 lpushx(name, value)
 
在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
更多：
rpushx(name, value) 表示从右向左操作
conn.lpushx('girls', 'mary')
 
 
4 rpushx(name, value) 
 
表示从右向左操作，只有name已经存在时，值添加到列表的最右边
 
5 llen(name)
 
name对应的list元素的个数
print(conn.llen('boys'))
 
6 linsert(name, where, refvalue, value))
在name对应的列表的某一个值前或后插入一个新值
conn.linsert('boys','before','陈星旭','qiuqiu')
conn.linsert('boys','after','陈星旭','zak')
 
 
7 lset(name, index, value)
对name对应的list中的某一个索引位置重新赋值，索引从0开始
conn.lset('boys', 5, 'jerry')
 
8 lrem(name, num, value)
在name对应的list中 删除指定个数的值，包括自身
conn.lrem('boys', 1, 'qiuqiu') # 从左侧开始，删除一个
conn.lrem('boys', -1, 'zak') # 从右侧开始，删除一个
conn.lrem('boys', 0, 'luck') # 从左侧开始，全部删除
 
 
9 lpop(name)
在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
res=conn.lpop('boys')
print(res)
 
 
10 rpop(name) 表示从右向左操作
res=conn.rpop('boys')  # 右侧第一个
print(res)
 
 
11 lindex(name, index)
在name对应的列表中根据索引获取列表元素
res = conn.lindex('boys', 2)
print(str(res, encoding='utf-8'))
 
 
12 lrange(name, start, end)
在name对应的列表分片获取数据
res = conn.lrange('boys', 2, 4)
 
l1 = []
for i in list(res):
    s = str(i,encoding='utf-8')
    l1.append(s)
print(l1)
 
 
13 ltrim(name, start, end)
在name对应的列表中移除没有在start-end索引之间的值
res = conn.ltrim('boys', 0, 4)
print(res)  # True
 
 
14 rpoplpush(src, dst)
从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
参数：
src，要取数据的列表的name
dst，要添加数据的列表的name
conn.rpoplpush('boys', 'star')
 
 
15 blpop(keys, timeout)
 
将多个列表排列，按照从左到右去pop对应列表的元素
可以做消息队列使用，阻塞式弹出，如果没有，就阻塞
参数：
keys，redis的name的集合
timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
res = conn.blpop('star',0)
print(res)
(b'star', b'cc')
更多：
r.brpop(keys, timeout)，从右向左获取数据
爬虫实现简单分布式：多个url放到列表里，往里不停放URL，程序循环取值，但是只能一台机器运行取值，可以把url放到redis中，多台机器从redis中取值，爬取数据，实现简单分布式
 
 
16 r.brpop(keys, timeout)，从右向左获取数据
 
 
17 brpoplpush(src, dst, timeout=0)
从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
 
参数：
src，取出并要移除元素的列表对应的name
dst，要插入元素的列表对应的name
timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞

(3) hash类型

  • hash操作

    不可变类型都可hash

    可变类型都不可hash

    python中字典的值都必须可hash才能存储

img

演示：

import redis
 
conn = redis.Redis(host='127.0.0.1', port=6379)
 
1 hset(name, key, value)
name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
conn.hset('boys', '陈星旭','东宫')
 
2 hmset(name, mapping)
在name对应的hash中批量设置键值对，将弃用，功能与hset合并
conn.hmset('boys',{'luka':'star','cici':'actor'})
 
 
3 hget(name,key)
在name对应的hash中获取根据key获取value
res = conn.hget('boys', '陈星旭')
print(str(res, encoding='utf-8'))  # 东宫
 
4 hmget(name, keys, *args)
res = conn.hmget('boys', ['陈星旭', 'cici'])
print(res)  # [b'\xe4\xb8\x9c\xe5\xae\xab', b'actor']
 
 
5 hgetall(name)
获取name对应hash的所有键值
 
res = conn.hgetall('boys')
print(res)
res = conn.hgetall('boys').get(b'cici')
print(res)
 
 
6 hlen(name)
获取name对应的hash中键值对的个数
res = conn.hlen('boys')
print(res)
 
7 hkeys(name)
获取name对应的hash中所有的key的值
res = conn.hkeys('boys')
print(res)
 
8 hvals(name)
获取name对应的hash中所有的value的值
res = conn.hvals('boys')
print(res)
 
 
9 hexists(name, key)
检查name对应的hash是否存在当前传入的key
res = conn.hexists('boys', 'cici')
print(res)
 
10 hdel(name,*keys)
将name对应的hash中指定key的键值对删除
conn.hdel('boys', 'cici')
 
11 hincrby(name, key, amount=1)
自增name对应的hash中的指定key的值，不存在则创建key=amount
参数：
    name，redis中的name
    key， hash对应的key
    amount，自增数（整数）
conn.hincrby('boys', 'num', 10)
 
12 hincrbyfloat(name, key, amount=1.0)
自增name对应的hash中的指定key的值，不存在则创建key=amount
conn.hincrbyfloat('boys', 'num2', 1.1)
 
 
13 hscan(name, cursor=0, match=None, count=None)
增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆
它不单独使用，拿的数据，不是特别准备
conn.hscan('hash_test', cursor=0, count=5)
 
14 hscan_iter(name, match=None, count=None)
内部用了hscan,等同于hgetall 所有数据都拿出来，count的作用是，生成器，每次拿count个个数
 
 
 
15 hgetall
hgetall  会一次性全取出，效率低，可以能占内存很多
分批获取，hash类型是无序
插入一批数据

4 Redis通用操作

不指定类型，所有类型都支持

import redis
 
conn = redis.Redis(host='127.0.0.1', port=6379)
 
1 delete(*names)
根据删除redis中的任意数据类型
 
conn.delete('pet_name', 'size')
conn.delete(['name', 'userinfo2'])  # 不能用它，因为位置传参，会把列表放在第一个
conn.delete(*['name', 'userinfo2'])  # 可以用它，先打散列表，再将列表中的传进去
 
 
2 exists(name)
检测redis的name是否存在，返回值是0和1
 
res = conn.exists('boys')
print(res)  # 返回值是1，表示True
res = conn.exists('pet_name')
print(res)  # 返回值是0，False
 
 
3 keys(pattern='*')
根据模型获取redis的name
 
res = conn.keys('bo?s')  # ？表示一个字符，   * 表示多个字符
print(res)  # [b'boys']
res = conn.keys('*e')  # ？表示一个字符，   * 表示多个字符
print(res)  # [b'person_name', b'type']
 
 
4 expire(name ,time)
为某个redis的某个name设置超时时间
conn.expire('star', 3)
 
5 rename(src, dst)
对redis的name重命名为
conn.rename('person_name','dog_name')
 
6 move(name, db)
将redis的某个值移动到指定的db下
conn.move('dog_name',8)
 
 
7 randomkey()
随机获取一个redis的name（不删除）
res = conn.randomkey()
print(res)
 
8 type(name)
获取name对应值的类型
print(conn.type('boys'))
----
b'hash'

5 管道

5.1 事务的四大特性：ACID

原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）

  1. 原子性（Atomicity）：事务是一个原子操作，即事务中的所有操作要么全部完成，要么全部不完成，不会出现部分完成的情况。如果事务的任何一个操作失败，则整个事务都会被回滚（Rollback）到事务开始之前的状态。
  2. 一致性（Consistency）：事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。在事务执行前后，数据库的完整性约束没有被破坏。
  3. 隔离性（Isolation）：多个事务同时执行时，每个事务都应该被隔离开来，彼此不会干扰。也就是说，每个事务都必须感觉不到其他事务的存在。
  4. 持久性（Durability）：事务完成后，它对数据库所做的更改必须被永久保存到数据库中，即使系统出现故障也不会丢失。

5.2 redis支持事务

redis通过单实例才支持所谓的事物，支持事务是基于管道的pipline支持事务

Redis 事务的实现方式是将所有的命令都放入一个队列中，直到 EXEC 命令被调用时才一次性执行。如果在执行事务过程中发生错误，整个事务将被回滚。事务中的每个命令都是原子操作，要么全部执行成功，要么全部失败。

import redis
conn = redis.Redis()
pipe = conn.pipeline(transaction=True)
pipe.multi()
pipe.decr('qiuqiu_tr',100)
raise Exception('取消')
pipe.incr('自增', 100)
 
 
pipe.execute()
conn.close()

6 django中使用redis

(1) 自定义包方案

import redis
 
# 第一步：建立一个连接池
POOL = redis.ConnectionPool(max_connections=100)
 
# 第二步：直接导入使用连接池生成实例
conn = redis.Redis(connection_pool=POOL)
 
# 第三步：操作redis数据库
conn.incr('count')
res = conn.get('count')
print(res)  # b'2'

(2) django 方案

① 方法1：django的缓存使用redis【推荐】

  • settings.py 中配置
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",
                }
            }
        }

  • 在使用redis的地方：cache.set('count', res+1)

  • pickle序列化后，存入的

② 方法2：第三方django-redis模块

from django_redis import get_redis_connection
        def test_redis(request):
            conn=get_redis_connection()
            print(conn.get('count'))
            return JsonResponse({'count': '今天这个接口被访问的次数为：%s'}, json_dumps_params={'ensure_ascii': False})
posted @   Duosg  阅读(34)  评论(0)  编辑  收藏  举报
相关博文：
· redis高级【汇总】
· 面试题集合1
· redis基础
· redis
· Redis相关操作
阅读排行：
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
点击右上角即可分享
微信分享提示