redis介绍与安装
# 1 redis 什么
-数据库就是个存数据的地方：只是不同数据库数据组织，存放形式不一样
-mysql 关系型数据库（oracle，sqlserver，postgrasql）
-非关系型数据(no sql)：redis，mongodb，clickhouse，infludb，elasticsearch，hadoop。。。
-没有sql：没有sql语句
-not olny sql 不仅仅是sql
-redis：一款纯内存存储的非关系型数据库（数据都在内存），速度非常快
# 2 redis特点：https://www.cnblogs.com/liuqingzheng/articles/9833534.html
-redis是一个key-value存储系统
-数据类型丰富，支持5大数据类型：字符串，列表，hash(字典),集合，有序集合
-纯内存操作
-可以持久化：能都把内存数据，保存到硬盘上永久存储
# 3 redis为什么这快
-1 纯内存，减少io
-2 使用了 io多路复用的 epoll 网络模型
-3 数据操作是单线程，避免了线程间切换
-多个客户端同时操作，不会存在并发安全问题
# 4 安装
-redis：最新是7， 公司里5,6比较多
-redis：开源软件，免费的，他们不支持win
-epoll模型不支持win
-微软官方：基于源码修改---》编译成可执行文件
-第三方：https://github.com/tporadowski/redis/releases/
-win：下载安装包，一路下一步
-安装目录在环境变量中：任意路径敲 redis-server reidis-cli 都能找到
-把redis做成了服务，以后通过服务启动即可
-mac：官网下载，解压即可
-win，mac：两个可执行文件：
redis-server ：等同于 mysqld
reidis-cli ：等同于mysql
# 5 启动，连接
# 5.1 启动方式
-使用服务启动
redis-server redis.windows-service.conf
-使用命令启动
redis-server
# 5.2 连接
redis-cli
redis-cli -h 地址 -p 端口（默认端口6379）
# 5.3 图形化客户端（Navicate）
-resp：后来收费了
-连接上发现有16个库
# 6 放值
使用resp放入值
# 7 取值
cmd中 连接：get key
Redis普通连接和连接池
在python中使用Redis
pip install redis
普通连接
from redis import Redis
def index():
coon = Redis(host="127.0.0.1", port=6379, db=0, decode_responses=True)
coon.set("name", "迪丽热巴") # 添加值：name:"name",value:"迪丽热巴"
res = coon.get("name") # 查看值
print(res)
coon.close() # 关闭
if __name__ == '__main__':
index()
连接池
设置连接池：
# 把池写成单例---->整个项目中，只有这一个实例(对象)
import redis
POOL = redis.ConnectionPool(host="127.0.0.1", port=6379, db=0, max_connections=5)
########################################################################
import redis
from pool import POOL
from threading import Thread
def index():
coon = redis.Redis(connection_pool=POOL)
print(coon.get("name"))
coon.close()
if __name__ == '__main__':
for i in range(10): # 因为我的连接池最大连接数是5个，多出来就会报错
t = Thread(target=index)
t.start()
index()
##################################################################################
python中实现单例的5种方式：
-1、使用模块级别的变量：Python的模块在程序中只会被导入一次，因此可以将需要实现单例的类定义为模块级别的变量。这样，每次导入该模块时都会使用同一个实例
# singleton.py
class SingletonClass:
pass
singleton_instance = SingletonClass()
# main.py
from singleton import singleton_instance
instance1 = singleton_instance
instance2 = singleton_instance
print(instance1 is instance2) # 输出: True
-2、使用装饰器：可以使用装饰器将类包装成单例。装饰器可以在每次创建实例时检查是否已经存在实例。
def singleton(cls):
instances = {}
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper
@singleton
class SingletonClass:
pass
instance1 = SingletonClass()
instance2 = SingletonClass()
print(instance1 is instance2) # 输出: True
-3、使用元类：元类是用于创建类的类。可以定义一个元类，在创建类时检查是否已经存在实例。
class SingletonMeta(type):
instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls.instances:
cls.instances[cls] = super().__call__(*args, **kwargs)
return cls.instances[cls]
class SingletonClass(metaclass=SingletonMeta):
pass
instance1 = SingletonClass()
instance2 = SingletonClass()
print(instance1 is instance2) # 输出: True
-4、使用基类：可以定义一个基类，将需要实现单例的类继承自该基类。基类在创建实例时会检查是否已经存在实例。
class SingletonBase:
_instance = None
@classmethod
def instance(cls):
if not cls._instance:
cls._instance = cls()
return cls._instance
class SingletonClass(SingletonBase):
pass
instance1 = SingletonClass.instance()
instance2 = SingletonClass.instance()
print(instance1 is instance2) # 输出: True
-5、使用线程安全的单例：如果需要在多线程环境下使用单例，可以使用线程安全的方式实现。可以使用线程锁来确保只有一个线程可以创建实例。
import threading
class SingletonClass:
_instance = None
_lock = threading.Lock()
@classmethod
def instance(cls):
if not cls._instance:
with cls._lock:
if not cls._instance:
cls._instance = cls()
return cls._instance
instance1 = SingletonClass.instance()
instance2 = SingletonClass.instance()
print(instance1 is instance2) # 输出: True
Redis字符串类型
'''
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)
'''
import redis
from pool import POOL
set：
coon = redis.Redis(connection_pool=POOL)
# 1 set(name, value, ex=None, px=None, nx=False, xx=False)
coon.set("name", "彭于晏") # 没有就添加有就修改
coon.set("age", "18", ex=5) # ex是设置过期时间，以秒为单位
coon.set("hobby", "篮球", px=5000) # px也是设置过期时间，以毫秒为单位
coon.set("name", "yfh", nx=True) # 只要nx设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果
coon.set("name", "yfh", xx=True)
ex、px、nx、xx的简写
# 2 setnx(name, value)
coon.setnx("name", "彭于晏")
# 3 setex(name, value, time)
coon.setex("age", 5, "18")
# 4 psetex(name, time_ms, value)
coon.psetex("hobby", 5000, "篮球")
# 5 mset(*args, **kwargs) # 批量设置
coon.mset({"name": "迪丽热巴", "age": 19, "hobby": "唱歌"})
get：
# 6 get(name)
print(coon.get("name")) # 迪丽热巴
# 7 mget(keys, *args) # 批量查看
print(coon.mget(["name", "sge", "hobby"])) # ['迪丽热巴', '19', '唱歌']
print(coon.mget(("name", "sge", "hobby"))) # ['迪丽热巴', '19', '唱歌']
# 8 getset(name, value) # # 等同于 get set
print(coon.getset("gender", "男")) # 男
# 9 getrange(key, start, end)
print(coon.getrange("name", 1, 3)) # fhf 索引第1个位置到第3个位置包括第三个
# 10 setrange(name, offset, value)
print(coon.setrange("name", 0, "oooo")) # 把索引第0个位置的修改为oooo
操作比特位：
# 11 setbit(name, offset, value)
# conn.setbit('name',7,1) # l=[1 1 0 0 0 1 0 0 ]
# 12 getbit(name, offset)
# 13 bitcount(key, start=None, end=None)
# 14 bitop(operation, dest, *keys)
其他了解：
# 15 strlen(name) 长度
print(coon.strlen("name")) # 12
# 16 incr(self, name, amount=1)自加1，单线程，没有并发安全，数据不会错乱，天然适合计数器 计数器
coon.incr("age", 100)
# 17 incrbyfloat(self, name, amount=1.0)
coon.incrbyfloat('age', 1.1)
# 18 decr(self, name, amount=1)
coon.decr("sge", 2) # 计数减一
# 19 append(key, value)
coon.append("name", "pppppp")
coon.close()
常用：
'''
set、get、getrange、strlen
'''
redis hash类型
'''
1 hset(name, key, value)
2 hmset(name, mapping)
3 hget(name,key)
4 hmget(name, keys, *args)
5 hgetall(name)
6 hlen(name)
7 hkeys(name)
8 hvals(name)
9 hexists(name, key)
10 hdel(name,*keys)
11 hincrby(name, key, amount=1)
12 hincrbyfloat(name, key, amount=1.0)
13 hscan(name, cursor=0, match=None, count=None)
14 hscan_iter(name, match=None, count=None)
'''
内部的生成器：
def hscan_iter(self,name,match= None,count= None):
cursor = "0"
while cursor != 0:
cursor, data = self.hscan(name, cursor=cursor, match=match, count=count)
yield from data.items()
''' hash 类型，就是咱们python中的字典类型， 数据结构：数据的组织形式,底层存储 数组--->根据key值使用hash函数得到结构，存到数组中
字典的key值必须可hash
字典的key值必须是不可变数据类型
hash 类型无序，跟放的先后顺序无关的
python 的字典是 有序的 字典+列表
'''
import redis
conn = redis.Redis(decode_responses=True)
# 1 hset(name, key, value) # 增加
conn.hset("userinfo", "name", "qqq")
conn.hset("userinfo", "age", "18")
# 2 hmset(name, mapping) 弃用了，统一用hset
# 3 hget(name,key) # 查看
print(conn.hget("userinfo", "name"))
print(conn.hget("userinfo", "age"))
# 4 hmget(name, keys, *args)
conn.hmget("userinfo", ["name", "age"])
# 5 hgetall(name) # 获取全部
print(conn.hgetall("userinfo"))
# 6 hlen(name) 长度
print(conn.hlen("userinfo"))
# 7 hkeys(name) 获取所有keys值
print(conn.hkeys("userinfo"))
# 8 hvals(name) 获取所有的value
print(conn.hvals("userinfo"))
# 9 hexists(name, key)判断我userinfo中有没有hobby这个key值
print(conn.hexists("userinfo", "hobby"))
# 10 hdel(name,*keys) 报错，待定
conn.hdel('userinfo', ['name', 'age'])
# 11 hincrby(name, key, amount=1)
# 12 hincrbyfloat(name, key, amount=1.0)
# 13 hscan(name, cursor=0, match=None, count=None) 批量造数据
for i in range(1000):
conn.hset('hash2', 'egg_%s' % i, '鸡蛋%s号' % i)
count 数字是大致的 大小，如果拿了10 ，可能是9 可能是11
res=conn.hscan('hash2',cursor=0,count=10) # 无序，所以不是从egg_0开始的
print(len(res[1]))
# 14 hscan_iter(name, match=None, count=None) # 替代hgetall，一次性全取出值，如果占内存很大，会有风险 , 使用hscan_iter 分批获取值，内存占用很小
for item in conn.hscan_iter('hash2',count=10):
print(item)
conn.close()
常用的：
"""hset、hget、hlen、hexists、hincrby、hscan_iter"""
redis列表类型
'''
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)
'''
import redis
conn = redis.Redis(decode_responses=True)
# 1 lpush(name, values) 从左边插入一条
conn.lpush('girls', '刘亦菲', '迪丽热巴')
# 2 rpush(name, values) 从右边插入一条
conn.rpush("girls", "小红")
# 3 lpushx(name, value) 存在则从左边插入一条
conn.lpushx("girls", "小绿")
# 4 rpushx(name, value) 存在则从右边插入一条
conn.rpush("girls", "小紫")
# 5 llen(name) 查看长度
print(conn.llen("girls"))
# 6 linsert(name, where, refvalue, value)) 在girls中在小紫之前插入一条哈哈哈
conn.linsert("girls", "before", "小紫", "哈哈哈")
# 7 lset(name, index, value)
conn.lset('girls', 0, 'oooo') # 按索引修改某个位置值
# 8 lrem(name, value, num)
conn.lrem('girls', 1, '刘亦菲') # 从左侧删一个
conn.lrem('girls', -1, '刘亦菲') # 从右侧删一个
conn.lrem('girls', 0, '刘亦菲') # 全删除
# 9 lpop(name)
print(conn.lpop('girls')) # 左侧弹出一个
# 10 rpop(name) 表示从右向左操作
print(conn.rpop('girls')) # 右侧弹出
# 11 lindex(name, index)
print(conn.lindex('girls', 0)) # 按照索引取值
# 12 lrange(name, start, end)
print(conn.lrange('girls', 1, 10000)) # 前闭后闭
# 13 ltrim(name, start, end)
conn.ltrim('girls', 2, 4)
# 14 rpoplpush(src, dst)
conn.rpoplpush('girls', 'girls')
# 15 blpop(keys, timeout) # block:阻塞 实现分布式的系统 消息队列
res = conn.blpop('girls', timeout=5)
print(res)
# 16 r.brpop(keys, timeout)，从右向左获取数据
# 17 brpoplpush(src, dst, timeout=0)
conn.close()
# 列表：lrang，把所有值都拿回来 lrang(key,0,-1)
-使用生成器，写一个分批获取列表所有值的生成器
