luffy学习-09

一、图形化redis-desktop-manage

qt5

• QT平台：可以写图形化界面
• 用python开发：pyqt5写图形化界面  GUI开发
• 一路一步安装就行
• 服务里把redis启动——连接——名字——端口6379——测试连接——连接成功——自带16个库

二、redis字符串操作

redis有5大数据类型——》字符串、hash、列表、集合、有序集合

主要的api：操作字符串的方法

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

set

nx里有实现分布式锁，详情看：https://zhuanlan.zhihu.com/p/489305763

# 1  set(name, value, ex=None, px=None, nx=False, xx=False)
#      ex，过期时间（秒）
#      px，过期时间（毫秒）
#      nx，如果设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果
#      xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值
# conn.set('name', 'kobe')  # value 只能是字符串或bytes格式
# conn.set('name','james',ex=4)  # ex是过期时间，到4秒过期，数据就没了
# conn.set('name','james',px=4000)  # px是过期时间，到4秒过期，数据就没了
# conn.set('age',20,nx=True) # redis 实现分布式锁
# conn.set('hobby','篮球',nx=False)

import redis

# 2 setnx(name, value)   就是：set nx=True
# conn.setnx('hobby1','羽毛球')


# 3 psetex(name, time_ms, value)  本质就是 set px设置时间
# conn.psetex('name',3000,'kj')

# 4 mset(*args, **kwargs)  传字典批量设置
# conn.mset({'name':'xxx','age':99})

# 5 get(name)  获取值，取到是bytes格式 可以指定：decode_responses=True，就完成转换变成字符串了
# print(conn.get('name'))
# print(str(conn.get('name')[:3],encoding='utf-8'))

# 5 mget(keys, *args)  #批量获取
# res=conn.mget('name','age')
# res=conn.mget(['name','age'])
# print(res)

# 6 getset(name, value)  # 先获取，再设置
# res=conn.getset('name','lqz')
# print(res)


# 7 getrange(key, start, end) # 取的是字节，前闭后闭区间
# res=conn.getrange('name',0,1)
# print(res)

# 8 setrange(name, offset, value)  # 从某个起始位置开始替换字符串
# conn.setrange('name', 1, 'xxx')

# 9 setbit(name, offset, value)  比特位 取出来的是二进制转成的字母
# conn.setbit('name',1,0)   #jay  00000000   00000000   00000000
# res=conn.get('name')
# print(res)


# 10 getbit(name, offset)  获取第几个比特位是0还是1  1个bytes=8个比特位
# res=conn.getbit('name',1)
# print(res)


# 11 bitcount(key, start=None, end=None)  取出有多少个比特位有多少个1
# print(conn.bitcount('name',0,3))  # 3 指的是3个字符

# 12 strlen(name)  # 统计字节长度
# print(conn.strlen('name'))
# print(len('lqz政'))  # len 统计字符长度

# 13 incr(self, name, amount=1)  # 计数器
# conn.incr('age',amount=3)


# 14 incrbyfloat(self, name, amount=1.0)

# 15 decr(self, name, amount=1)
# conn.decr('age')

# 16 append(key, value)
conn.append('name', 'abc')

conn.close()

三、redis之hash操作

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

1	hset(name, key, value)  name对应的hash中设置一个键值对（不存在，则创建；否则，修改） 参数：     name，redis的name     key，name对应的hash中的key     value，name对应的hash中的value
2	hlen(name) 获取name对应的hash中键值对的个数
3	hget(name,key) 在name对应的hash中获取根据key获取value
4	hexists(name, key) 检查name对应的hash是否存在当前传入的key
5	hincrby(name, key, amount=1) 自增name对应的hash中的指定key的值，不存在则创建key=amount 参数：     name，redis中的name     key， hash对应的key     amount，自增数（整数）
6	hmset(name, mapping)
7	hkeys(name)
8	hvals(name)
9	hmget(name, keys, *args)
10	hdel(name,*keys)
11	hgetall(name)
12	hincrbyfloat(name, key, amount=1.0)
13	hscan(name, cursor=0, match=None, count=None)
14	hscan_iter(name, match=None, count=None)

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

### redis 只支持一层的5大数据类型
import redis

conn = redis.Redis(decode_responses=True)
# 1 hset(name, key, value)
# conn.hset('userinfo', 'name', '小张')
# conn.hset('userinfo', 'age', '23')
# conn.hset('xx',mapping={'name':'xxx','hobby':'篮球'})


# 2 hmset(name, mapping)   弃用了
# conn.hmset('yy',{'a':'a','b':'b'})


# 3 hget(name,key)
# res=conn.hget('userinfo','age')
# print(res)

# 4 hmget(name, keys, *args)
# res=conn.hmget('userinfo',['name','age'])
# print(res)

# 5 hgetall(name)    慎用，可能会造成 阻塞 尽量不要在生产代码中执行它
# res=conn.hgetall('userinfo')
# print(res)


# 6 hlen(name)
# res=conn.hlen('userinfo')
# print(res)


# 7 hkeys(name)
# res=conn.hkeys('userinfo')
# print(res)
# 8 hvals(name)
# res=conn.hvals('userinfo')
# print(res)

# 9 hexists(name, key)
# res=conn.hexists('userinfo','name')
# print(res)

# 10 hdel(name,*keys)
# conn.hdel('userinfo','age')


# 11 hincrby(name, key, amount=1)
# conn.hincrby('userinfo','age')

# 12 hincrbyfloat(name, key, amount=1.0)
# conn.hincrbyfloat('userinfo','age',5.44)

## 联合起来讲：不建议使用hgetall，分片取值
# 分批获取               生成器应用在哪了？
# 13 hscan(name, cursor=0, match=None, count=None)
# hash类型没有顺序---》python字典 之前没有顺序，3.6后有序了    python字段的底层实现
# for i in range(1000):
#     conn.hset('test_hash','key_%s'%i,'鸡蛋%s号'%i)

# count 是要取的条数，但是不准确，有点上下浮动
# 它一般步单独用
# res=conn.hscan('test_hash',cursor=0,count=19)
# print(res)
# print(res[0])
# print(res[1])
# print(len(res[1]))
# res=conn.hscan('test_hash',cursor=res[0],count=19)
# print(res)
# print(res[0])
# print(res[1])
# print(len(res[1]))


# 咱么用它比较多，它内部封装了hscan，做成了生成器，分批取hash类型所有数据
# 14 hscan_iter(name, match=None, count=None)  获取所有hash的数据
res = conn.hscan_iter('test_hash',count=100)
print(res)  # 生成器
for item in res:
    print(item)

conn.close()

四、redis列表操作

Redis_list.py

# Redis列表操作

'''
1 lpush(name,values)
2 lpushx(name,value)
3 rpushx(name, value) 表示从右向左操作
4 llen(name)
5 linsert(name, where, refvalue, value))
6 lset(name, index, value)
7 lrem(name, value, num)
8 lpop(name)
9 lindex(name, index)
10 lrange(name, start, end)
11 ltrim(name, start, end)
12 rpoplpush(src, dst)
13 blpop(keys, timeout)
14 brpoplpush(src, dst, timeout=0)
15 自定义增量迭代
'''

import redis

connent = redis.Redis()

1. lpush(name,values)  # 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
connent.lpush('xx', 11,22,33)

2. lpushx(name,value)  # 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
connent.rpush('xx', 44)

3. rpushx(name, value)
connent.lpushx('yy', 55)  # 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边

4. llen(name)
info = connent.llen('xx')  # name对应的list元素的个数
print(info)

5. linsert(name, where, refvalue, value)
connent.linsert('xx', where='after', refvalue='22', value='66')  # 在name对应的列表的某一个值前或后插入一个新值
connent.linsert('xx', where='before', refvalue='22', value='66')

6. lset(name, index, value)
connent.lset('xx', 0, '77')  # 对name对应的list中的某一个索引位置重新赋值

7. lrem(name, value, num)
connent.lrem('xx', 1, '66')  # 在name对应的list中删除指定的值

8. lpop(name)
info = connent.lpop('yy', count=1)  # 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
info1 = connent.rpop('yy', count=1)  # 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
print(info)
print(info1)

9. lindex(name, index)
connent.lindex('xx', 0)  # 在name对应的列表中根据索引获取列表元素

10. lrange(name, start, end)
connent.lrange('xx', 0, 2)  # 在name对应的列表分片获取数据

11. ltrim(name, start, end)
info = connent.ltrim('xx', 1, 3)  # 在name对应的列表中移除没有在start-end索引之间的值
print(info)

12. rpoplpush(src, dst)
connent.rpoplpush('xx', 'yy')  # 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边

13. blpop(keys, timeout)
info = connent.blpop('yy')  # 阻塞式弹出，如果列表中有值，会造成阻塞，直到有值，它可以做消息对了，将多个列表排列，按照从左到右去pop对应列表的元素
print(info)

14. brpoplpush(src, dst, timeout=0)
info = connent.brpoplpush('yy', timeout=3)  # 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
print(info)

15. 自定义增量迭代
info = connent.lrange('yy', 0, 999)
# 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
# 1、获取name对应的所有列表
# 2、循环列表
print(info)


# 关闭连接
connent.close()

自定义生成器

import redis
conn = redis.Redis(host='127.0.0.1', port=6379)
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)

 五、redis管道操作

redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，
如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
redis事务机制可以保证一致性和隔离性，无法保证持久性，
但是对于redis而言，本身是内存数据库，所以持久化不是必须属性。
原子性需要自己进行检查，尽可能保证
它不像mysql一样，支持强事务，事务的四大特性不能全部满足，但是能满足一部分，
通过redis的管道实现的，redis本身不支持事务，
但是可以通过管道，实现部分事务
redis 通过管道，来保证命令要么都成功，要么都失败，
完成事务的一致性，但是管道只能用在单实例，集群环境中，不支持pipline

import redis

connent = redis.Redis()
pipline = connent.pipeline(transaction=True)
pipline.decr('x', 2)  # x减2
raise Exception('无法接收')
pipline.incr('y', 2)  # y加2
pipline.execute()

# 关闭连接
conn.close()

六、redis其他操作

# 通用操作：无论是5大类型的那种，都支持

import redis

connent = redis.Redis()

1. delete(*names)  # 根据删除redis中的任意数据类型
conn.delete('age', 'name')

2. exists(name)  # 检测redis的name是否存在
info=conn.exists('xx')
print(info)  # 0


3. keys(pattern='*')  # 根据模型获取redis的name
info=conn.keys('*o*')
info=conn.keys('?o*')
print(info)

4. expire(name ,time)  # 为某个redis的某个name设置超时时间
connent.expire('test_hash',3)

5. rename(src, dst)  # 对redis的name重命名
connent.rename('xx','xxx')


6. move(name, db)  # 将redis的某个值移动到指定的db下
# 默认操作都是0 库，总共默认有16个库
connent.move('xxx',2)


7. randomkey()  # 随机获取一个redis的name（不删除）
info = connent.randomkey()
print(info)

8. type(name)  # 获取name对应值的类型
info = conn.type('aa') 
print(info)

# 关闭连接
connent.close()

七、Django集成Redis

方式一

# utils文件夹下，建立redis_pool.py 

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('获取成功')

方式二

# 安装django-redis模块

pip3 install django-redis

# setting里配置：
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'))

方式三

如果配置文件中配置了 CACHES  ，以后django的缓存，数据直接放在redis中
以后直接使用cache.set 设置值，可以传过期时间
使用cache.get 获取值
强大之处在于，可以直接缓存任意的python对象，底层使用pickle实现的