Redis基础

"""
1）绑定的ip地址，多个ip用空格隔开
bind 127.0.0.1

2）端口，默认6379，一般不做修改
port 6379

3）是否以守护进程启动，默认为no，一般改为yes代表后台启动（windows系统不支持）
daemonize no

4）定义日志级别，默认值为notice，有如下4种取值：
    debug（记录大量日志信息，适用于开发、测试阶段）
    verbose（较多日志信息）
    notice（适量日志信息，使用于生产环境）
    warning（仅有部分重要、关键信息才会被记录）
loglevel notice

5）配置日志文件保持地址，默认打印在命令行终端的窗口上
    如果填写 "./redis.log" 就会在启动redis服务的终端所在目录下，用redis.log记录redis日志
logfile ""

eg）终端首先切断到log文件夹所在目录(一般就可以采用redis的安装目录，也可以自定义)，再启动reids服务
logfile "./log/redis.log"

6）数据库个数，默认是16个，没特殊情况，不建议修改
databases 16

7）数据持久化
save 900 1  # 超过900秒有1个键值对操作，会自动调用save完成数据持久化
save 300 10  # 超过300秒有10个键值对操作，会自动调用save完成数据持久化
save 60 10000  # 超过60秒有10000个键值对操作，会自动调用save完成数据持久化

8）数据库持久化到硬盘失败，redis会立即停止接收用户数据，让用户知道redis持久化异常，避免数据灾难发生(重启redis即可)，默认为yes，不能做修改
stop-writes-on-bgsave-error yes

9）消耗cpu来压缩数据进行持久化，数据量小，但会消耗cpu性能，根据实际情况可以做调整
rdbcompression yes
10）增持cpu 10%性能销毁来完成持久化数据的校验，可以取消掉
rdbchecksum yes

11）持久化存储的文件名称
dbfilename dump.rdb

12）持久化存储文件的路径，默认是启动服务的终端所在目录
dir ./

13）reids数据库密码
requirepass 密码
"""

"""
windows系统
1）前台启动
    i）打开终端切换到redis安装目录
    >: cd C:\Apps\Redis
    
    ii）启动服务
    >: redis-server redis.windows.conf

2）后台启动
    i）打开终端切换到redis安装目录
    >: cd C:\Apps\Redis
    
    ii）启动服务（后面的配置文件可以省略）
    >: redis-server --service-start redis.windows-service.conf
"""

"""
1）默认连接：-h默认127.0.0.1，-p默认6379，-n默认0，-a默认无
>: redis-cli

2）完整连接：
>: redis-cli -h ip地址 -p 端口号 -n 数据库编号 -a 密码

3）先连接，后输入密码
>: redis-cli -h ip地址 -p 端口号 -n 数据库编号
>: auth 密码
"""

"""
1）提倡在配置文件中配置，采用配置文件启动
requirepass 密码

2）当服务启动后，并且连入数据库（redis数据库不能轻易重启），可以再改当前服务的密码(服务重启，密码重置)
config set requirepass 新密码

3）已连入数据库，可以查看当前数据库服务密码
config get requirepass
"""

1、切换数据库：
>: select 数据库编号
    
2、关闭服务（前提是数据库已连接）
>: shutdown
# 直接连接数据库并关闭redis服务
>: redis-cli -h ip地址 -p 端口号 -n 数据库编号 -a 密码 shutdown

3、清空redis数据库(前提数据库已连接)
>: flushall
    
4、数据持久化：
1）配置文件默认配置
>: save 900 1  # 超过900秒有1个键值对操作，会自动调用save完成数据持久化
>: save 300 10  # 超过300秒有10个键值对操作，会自动调用save完成数据持久化
>: save 60 10000  # 超过60秒有10000个键值对操作，会自动调用save完成数据持久化

2）安全机制
# 当redis服务不可控宕机，会默认调用一下save完成数据持久化（如果数据量过大，也可能存在部分数据丢失）

3）主动持久化
>: save  # 连入数据库时，主动调用save完成数据持久化

注：数据持久化默认保存文件 dump.rdb，保存路径默认为启动redis服务的当前路径

1、导入依赖库
>: pip3 install redis
2、使用；
import redis
#decode_response=True 得到的结果会自动解码(不是二进制数据)
conn=redis.Redis(host=‘127.0.0.1‘,port=6379,db=1,password=密码，decode_responses=True)
#连接池：
pool=redis.ConnectionPool(host=‘127.0.0.1‘,port=6379,db=1,max_connections=100,password=密码,decode_responses=True)
conn_pool=redis.Redis(conncetion_pool=pool)

‘‘‘
ex：过期时间 （单位：秒）
px: 过期时间 （单位：毫秒)
nx：如果设置为True,则只有name不存在时，set操作才执行，如果name存在，则修改不了，执行没有效果
xx: 如果设置为True,则只有name存在是，set操作才执行，name值存在才能修改，不存在，不会设置新值
‘‘‘
conn.set(‘height‘,‘180‘,ex=1)
conn.set(‘height‘,180,px=1)
conn.set(‘height‘,‘100‘,nx=True)
# height结果：height=180
conn.set(‘height‘,‘100‘,xx=True)
# height结果：height=100
conn.set(‘height1‘,‘102‘,xx=True)
# height1结果：None

‘‘‘
setnx：只用当key不存在的时候，才会执行，存在，则不会执行 等价于set(‘height‘,‘100‘,nx=True)
setex(name，time,value) 等价于 set(‘height‘,‘180‘,ex=1)
psetex(name,time_ms,value) 等价于 conn.set(‘height‘,180,px=1)
‘‘‘
conn.set(‘height‘, ‘180‘)
conn.setnx(‘height‘, ‘100‘)
# 此时height 还是 180
conn.setex(‘height1‘,1,‘120‘)
# 等价于set(‘height‘,180,px=1)
conn.psetex(‘height‘, 1, ‘110‘)
# print(conn.get(‘height‘))
print(conn.get(‘height1‘))
‘‘‘
mset：以字典的形式插入多个
mget: 返回列表的形式
getset: 设置一个值，并返回一个原来的旧值
‘‘‘
# conn.mset({‘k1‘: ‘hello‘, ‘k2‘: ‘world‘})
conn.mget([‘k1‘, ‘k2‘])
# 结果：[b‘hello‘,b‘world‘]
re = conn.getset(‘k1‘, ‘111‘)
# 结果：返回的是k1旧值 ：hello


‘‘‘
getrange(key,start,end)；截取value的长度，类似切片，截取超过本身长度则只取本身
setrange(key,offset,value): 在value的offset起始位置插入value值
getbit(‘key,offset)：截取value的二进制中指定位置的值（0或者1）
setbit(key,offset,value): 将key对应的值的二进制表示的位进行操作，注意value值只能是1或者0
incr(‘key‘，amount=1): 只要执行该语句，value数字就会加amount的值，一般用于访问量统计
incrbyfloat(key,amount=1.0): 同incr一样，自增数是浮点型
decr(‘key‘,amount=1): 只要执行该语句，value数字就会减1
append(‘key‘,insert_value)：原来value+insert_value。
bitop(operation,dest,*keys):
    operations: AND(并）、OR(或）、NOT(非）、XOR(异或）
    dest：新的Redis的key
    *key: 要查找的Redis的name
bitcount(key,start=None,end=None): 获取key对应值的二进制中的某位的值
strlen(key): 返回key对应值的字节长度（一个汉字3个字节）
‘‘‘
ret=conn.getrange(‘k1‘,0,3)
# 原来k1 = 11111,执行后得到结果是 111,
conn.setrange(‘k4‘,2,1)
# 原来k4=8888 现在变成 k4=88188
print(conn.get(‘k4‘))
ret=conn.getbit(‘k4‘,3)
#结果：ret=1
conn.set(‘k5‘,1)
conn.incr(‘k5‘,2)
conn.incr(‘k5‘)
print(conn.get(‘k5‘))
# 结果：k5=4
conn.decr(‘k5‘)
print(conn.get(‘k5‘))
# 结果：k5=2
conn.append(‘k5‘,‘oo‘)
# 结果 k5=200
conn.bitop(‘AND‘,‘k6‘,‘k1‘,‘k2‘,‘k3‘)

‘‘‘
在对应的hash中设置一个键值对（不存在，则创建，否则，修改）
hset(name,key,value):
    name:redis的name
    key：字典关键字
    value:字典关键字对应的值

hget(name,key): 获取name对应的hash中key对应的值
‘‘‘
conn.hset(‘hash1‘,‘h1‘,11)
conn.hset(‘hash1‘,‘h2‘,22)
conn.hset(‘hash1‘,‘h1‘,333)
ret=conn.hget(‘hash1‘,‘h1‘)
# >: 333
‘‘‘
在对应的hash中批量设置键值对
hmset(name,mapping):
    name: redis的name
    mapping: 字典

hmget(name,keys,*args):
    keys：要获取key集合
    *args: 要获取的key
‘‘‘
conn.hmset(‘hash2‘,{‘k1‘:1,‘k2‘:2,‘k3‘:3})
ret=conn.hmget(‘hash2‘,‘k1‘,‘k2‘,‘k3‘)
#两者等价
ret=conn.hmget(‘hash2‘,[‘k1‘,‘k2‘,‘k3‘])
# >：结果都是 [‘1‘,‘2‘,‘3‘]

‘‘‘
hgetall(name): 获取name对应hash的所有键值，以字典的形式返回
‘‘‘
ret=conn.hgetall(‘hash2‘)
# >: {‘k1‘: ‘1‘, ‘k2‘: ‘2‘, ‘k3‘: ‘3‘}

‘‘‘
hlen(name): 获取name对应的hash中键值对的个数
hkeys(name): 获取name对应的hash中所有key的值,以列表形式返回
hvals(name): 获取name对应hash中所有value的值，以列表形式返回
hexists(name,key): 判断当前hash中是否存在key
hdel(name,*keys): 删除hash中指定的key的键值对
‘‘‘
ret=conn.hlen(‘hash2‘)
# >: 3
ret=conn.hkeys(‘hash2‘)
# >: [‘k1‘, ‘k2‘, ‘k3‘]
ret=conn.hvals(‘hash2‘)
# >: [‘1‘, ‘2‘, ‘3‘]
ret=conn.hexists(‘hash2‘,‘k1‘)
# >: True
conn.hdel(‘hash2‘,‘k1‘,‘k2‘)
# >: 2

‘‘‘
自增name对应的hash中指定key的值，不存在则创建key=amount
hincrby(name,key,amount=1):
       amount: 是自增数（整数）
hincrbyfloat(name,key,amount=1.0) 同hincrby一样，只不过是自增数是浮点类型
‘‘‘
conn.hincrby(‘hash2‘,‘k1‘,amount=1)
conn.hincrby(‘hash2‘,‘k1‘,amount=1)
conn.hincrbyfloat(‘hash2‘,‘k2‘,amount=1.1)
conn.hincrbyfloat(‘hash2‘,‘k2‘,amount=1.1)
# >: hahs2所有键值对：{‘k3‘: ‘3‘, ‘k1‘: ‘2‘, ‘k2‘: ‘2.2‘}

‘‘‘
hscan(name,cursor=0,match=None,count=None):
      cursor: 游标（基于游标分批获取数据）
      match: 匹配指定key，默认None 表示所有的key
      count: 每次分片最少获取个数，默认None表示采用Redis的默认分片个数
‘‘‘
#eg:
# 第一次：cursor1, data1 = r.hscan(‘xx‘, cursor=0, match=None, count=None)
# 第二次：cursor2, data1 = r.hscan(‘xx‘, cursor=cursor1, match=None, count=None)
# ...
# 直到返回值cursor的值为0时，表示数据已经通过分片获取完毕
cursor1,data1=conn.hscan(‘hash2‘,cursor=0,match=None,count=None)
# >:0 ,{‘k3‘: ‘3‘, ‘k1‘: ‘2‘, ‘k2‘: ‘2.2‘}

‘‘‘
# 利用yield封装hscan创建生成器，实现分批去redis中获取数据
hscan_iter(name,match=None,count=None):
# 参数：
    # match，匹配指定key，默认None 表示所有的key
    # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
‘‘‘
for item in conn.hscan_iter(‘hash2‘):
    print(item)
# >: (‘k3‘, ‘3‘)
# >: (‘k1‘, ‘2‘)
# >: (‘k2‘, ‘2.2‘)

‘‘‘
lpush(name,values): 在对应的list中添加元素，每个新元素都是添加在列表的最左边
rpush(name,values)则是添加在列表的右边
‘‘‘
conn.lpush(‘l1‘,11,22,33)
# >: 33,22,11
‘‘‘
lpushx(name,value): 跟lpush一样，也是添加元素，
但是，只有当name存在是才会添加，当name不存在时，则不会添加
注意: rpushx则是添加在列表右边
‘‘‘
conn.lpushx(‘l2‘,1)
conn.lpushx(‘l1‘,1)
‘‘‘
llen(name): 获取name对应的list元素的个数
‘‘‘
conn.llen(‘l1‘)
# >: 19
‘‘‘
linsert(name,where,refvalue,value):
 参数：
     name，redis的name
     where，BEFORE或AFTER(小写也可以)
     refvalue，标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
     value，要插入的数据
‘‘‘
conn.linsert(‘l1‘,where=‘before‘,refvalue=1,value=22222)

‘‘‘
lset(name,index,value): 在list的某个位置插入一个值
    index: list的索引位置
    value: 要设置的值
    
lrem(name,count,value): 删除name对应list中指定的值
    value: 要删除的值
    count:  count=0，删除列表中所有的指定值；
          count=2,从前到后，删除2个；
          count=-2,从后向前，删除2个
          
lpop(name): 删除name对应list的左侧第一个元素，并返回该元素
rpop：则是右侧第一个元素
‘‘‘
conn.lset(‘l1‘,2,‘1111111111‘)
conn.lrem(‘l1‘,value=11,count=0)
l=conn.lpop(‘l1‘)
# >: 22222

‘‘‘
lindex(name,index): 返回索引对应的元素
lrange(name,start,end): 跟列表切片一致
ltrim(name,start,end): 在name对应的列表中移除没有在start-end索引之间的值
‘‘‘
l= conn.lindex(‘l1‘,2)
# >: 22
l=conn.lrange(‘l1‘,1,10)
# >: [‘1111111111‘, ‘22‘, ‘33‘, ‘22‘, ‘33‘, ‘22‘, ‘33‘, ‘22‘, ‘33‘, ‘22‘]
conn.ltrim(‘l1‘,1,9)
‘‘‘
从一个列表取出最右边的元素，同时，将取出来的元素添加至另一个列表的最左边
rpoplpush(src,dst):
     src: 要取数据的列表name
     dst: 要添加数据的列表name
     
同rpoplpush一样，只不过，如果src这个列表没有数据的话，会进入阻塞状态。
brpoplpush(src,dst,timeout=0):
     timeout: 超时时间，0表示永远阻塞
‘‘‘
conn.rpoplpush(‘l1‘,‘l2‘)
‘‘‘
获取并移除列表第一个元素，如果列表没有元素，则会计入阻塞，直到发现可弹出元素或者等待超时为止
blpop(keys,timeout)：
    keys: redis的name的元素集合
    timeout: 超时时间，默认是0，表示永远阻塞
‘‘‘
conn.blpop((‘l2‘,‘l1‘),timeout=2)
# >: (‘l1‘,‘33‘)

#自定义增量迭代
# 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
    # 1、获取name对应的所有列表
    # 2、循环列表
# 但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：
import redis
conn=redis.Redis(host=‘127.0.0.1‘,port=6379)
# 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)

# sadd(name,values) 添加元素,可以添加一个或多个
conn.sadd(‘s1‘, 111, 222)

# scard(name) 获取name对应的集合中元素个数
conn.scard(‘s1‘)
# >:2
conn.sadd(‘s2‘, 111, 333,444,555,666,777)
‘‘‘
smembers(name) 获取集合中所有元素
sismember(name,value) 检测value是否是name集合的元素
‘‘‘
conn.smembers(‘s1‘)
# >:{‘111‘, ‘222‘}

conn.sismember(‘s1‘, ‘111‘)
# >: True

‘‘‘
sdiff(keys,*args) 差集
sdiffstore(dest,keys,*args),将差集存在一个新的集合中
   参数 dest: 是新集合的name
‘‘‘
conn.sdiff(‘s1‘, ‘s2‘)  # 在集合s1中但是不在集合s2中的元素
# >: {‘222‘}
conn.sdiffstore(‘s3‘,‘s1‘,‘s2‘)
# >: s3={‘222‘}

‘‘‘
sinter(keys,*args) 交集
sinterstore(dest,keys,*args) 将交集结果存在dest中
‘‘‘
conn.sinter(‘s1‘, ‘s2‘)
conn.sinterstore(‘s3‘, ‘s1‘, ‘s2‘)
# >: {‘111‘}
‘‘‘
并集：
sunion(keys,*args)
sunionstore(dest,keys,*args) 并集结果存于dest这个新集合中
‘‘‘
conn.sunion(‘s1‘,‘s2‘)
conn.sunionstore(‘s3‘,‘s1‘,‘s2‘)

‘‘‘
smove(src,dst,value):将src集合中的valuse移动到dst集合中
spop(name): 从集合的右侧移除一个成员并将其返回
‘‘‘
conn.smove(‘s1‘,‘s2‘,‘222‘)

# srandmember(name,numbers)：从集合随机获取 numbers个元素
conn.srandmember(‘s2‘, 2)
# >:[‘111‘, ‘333‘]

# srem(name,values) 删除集合中某些值
conn.srem(‘s2‘,111,333)

‘‘‘
通哈希类型的hscan一样
sscan(name,cursor=0,match=None,count=None):
      cursor: 游标（基于游标分批获取数据）
      match: 匹配指定key，默认None 表示所有的key
      count: 每次分片最少获取个数，默认None表示采用Redis的默认分片个数
‘‘‘
# eg:
# 第一次：cursor1, data1 = r.sscan(‘xx‘, cursor=0, match=None, count=None)
# 第二次：cursor2, data1 = r.sscan(‘xx‘, cursor=cursor1, match=None, count=None)
# ...
# 直到返回值cursor的值为0时，表示数据已经通过分片获取完毕
conn.sscan(‘s2‘, cursor=0, match=None, count=2)
# >: (2, [‘555‘, ‘111‘])

‘‘‘
# 利用yield封装sscan创建生成器，实现分批去redis中获取数据
sscan_iter(name,match=None,count=None):
# 参数：
    # match，匹配指定key，默认None 表示所有的key
    # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
‘‘‘
for item in conn.sscan_iter(‘s2‘,match=None,count=None):
    print(item)
# >:555
# >:111
# >: 333
# ...

‘‘‘
有序集合添加元素
zadd(self, name, mapping, nx=False, xx=False, ch=False, incr=False):
参数：
    mapping: 字典
    nx：如果设置为True,则只有name不存在时，set操作才执行，如果name存在，则修改不了，执行没有效果
    xx: 如果设置为True,则只有name存在是，set操作才执行，name值存在才能修改，不存在，不会设置新值
    ch: 如果为True,返回值返回的是修改的元素数。修改的元素包括添加的新元素和分数更改的元素。false则默认返回0
    incr:设置为True时，当集合元素不存在时，则没有影响，若集合元素（比如：n1）存在，则会把原来的元素对应的value值，加新的value值。
‘‘‘
conn.zadd(‘zs1‘,{‘n1‘:1,‘n2‘:2,‘n3‘:3,‘n4‘:5,‘n5‘:4})
conn.zadd(‘zs1‘,{‘n1‘:6},incr=True)
# >: n1=7
‘‘‘
name有序集合元素的数量
zcard(name)
‘‘‘
conn.zcard(‘zs1‘)
# >: 5
‘‘‘
 获取name对应的有序集合分数（value) 在[min,max]之间的个数
 zcount(name,min,max):
‘‘‘
conn.zcount(‘zs1‘,2,5)
# >: 4
‘‘‘
有序集合结构：(name,value,score)
 zincrby(name, amount, value):
‘‘‘
conn.zincrby(‘zs1‘,amount=4,value=‘n1‘)
# >: n1 对应的score 从2 变成6
‘‘‘
conn.zrange(name, start, end, desc=False, withscores=False,score_cast_func=float)
 参数：
    name，redis的name
    start，有序集合索引起始位置（非分数）
    end，有序集合索引结束位置（非分数）
    desc，排序规则，默认按照分数从小到大排序
    withscores，是否获取元素的分数，默认只获取元素的值
    score_cast_func，对分数进行数据转换的函数
# 更多：
    # 从大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)
 
    # 按照分数范围获取name对应的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 从大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
‘‘‘
conn.zrange(‘zs1‘,1,5)
# >: [‘n3‘, ‘n5‘, ‘n4‘, ‘n1‘]
conn.zrange(‘zs1‘,1,5,withscores=True)
# >: [(‘n3‘, 3.0), (‘n5‘, 4.0), (‘n4‘, 5.0), (‘n1‘, 6.0)]

‘‘‘
 获取name有序集合中的value的排行位置(本质就是位置，是从0开始计）
 zrank(name,value)
 更多：
    # zrevrank(name, value)，从大到小排序
‘‘‘
conn.zrank(‘zs1‘,‘n1‘)
# >: 4
conn.zrevrank(‘zs1‘,‘n1‘)
# >: 0

‘‘‘
 conn.zrangebylex(name, min, max, start=None, num=None)
 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值 
 （lexicographical ordering）来进行排序，而这个命令则可以返回给定的有序集合键 key 中，
 元素的值介于 min 和 max 之间的成员
 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 
 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大
# 参数：
    # name，redis的name
    # min，左区间（值）。 + 表示正无限； - 表示负无限； ( 表示开区间； [ 则表示闭区间
    # min，右区间（值）
    # start，对结果进行分片处理，索引位置
    # num，对结果进行分片处理，索引后面的num个元素
# 如：
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex(‘myzset‘, "-", "[ca") 结果为：[‘aa‘, ‘ba‘, ‘ca‘]
# 更多：
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)
‘‘‘
conn.zrangebylex(‘zs1‘,‘[n1‘,‘+‘)
# >: [‘n2‘, ‘n3‘, ‘n5‘, ‘n4‘, ‘n1‘]

‘‘‘
zrem(name,values) 删除name集合中values的值
zremrangebyrank(name,min,max): 根据value范围删除
zremrangebyscore(name,min,max): 根据分数范围删除
zremrangebylex(name, min, max)：根据值返回删除
‘‘‘
conn.zrem(‘zs1‘,[‘n5‘,‘n4‘])
conn.zremrangebyrank(‘zs1‘,2,3)
conn.zremrangebyscore(‘zs1‘,7,9)
‘‘‘
获取两个有序集合的交集，存在一个新的集合，如遇到相同值不同分数，则按照aggregate进行操作
zinterstore(dest,keys,aggregate=None)
获取两个有序集合的并集，存在一个新的集合，如遇到相同值不同分数，则按照aggregate进行操作
zunionstore(dest, keys, aggregate=None)
 aggregate的值为:  SUM  MIN  MAX
‘‘‘
# zs1={n1:1,n2:2,..} zs2={n1:4,b1:1,..}
conn.zinterstore(‘zs3‘,(‘zs1‘,‘zs2‘),aggregate=‘MAX‘)
# >: zs3={n1:4}
‘‘‘
跟字符串的相似
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)
    score_casst_func：是用来处理分数的
‘‘‘

#delete(*names) #删除redis中的任意数据类型
conn.delete(‘k4‘,‘k5‘)
exists(name) #判断name是否存在
‘‘‘
keys(pattern=‘*‘) 获取redis的name
# 更多：
    pattern = * 匹配数据库中所有 key 。
    pattern = h?llo 匹配 hello ， hallo 和 hxllo 等。
    pattern = h*llo 匹配 hllo 和 heeeeello 等。
    pattern = h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 
‘‘‘
conn.keys(pattern=‘*‘)
# [‘s1‘, ‘zs1‘, ‘zs2‘, ‘s3‘, ‘s2‘, ‘hash1‘, ‘k1‘, ‘k3‘, ‘hash2‘, ‘name‘, ‘k2‘, ‘zs3‘, ‘l1‘]

expire(name ,time) # 为某个redis的某个name设置超时时间
rename(src, dst) # 对redis的name(src)重命名为dst
move(name, db)  # 将redis的某个值移动到指定的db下
randomkey() # 随机获取一个redis的name（不删除）
type(name) # 获取name对应值的类型
scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None) # 同字符串操作，用于增量迭代获取key

# -*-coding:utf-8 -*-
import redis

pool=redis.ConnectionPool(host=‘127.0.0.1‘,port=6379,password=12345)
r=redis.Redis(connection_pool=pool)

#transaction=True 开启事务，注意，该事务没有回滚
pip=r.pipeline(transaction=True)
pip.multi() #
pip.set(‘k4‘,‘111‘)
pip.set(‘k5‘,‘5555‘)
pip.execute() #执行

import redis
POOl=redis.ConnectionPool(host=‘127.0.0.1‘,port=6379,password=‘12345‘,max_connections=1000)

import redis

from luffy.utils.redis_pool import POOl
def index(request):
    conn=redis.Redis(connection_pool=POOl)
    conn.hset(‘kkk‘,‘age‘,11)
    ...

# redis配置
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/2",
        "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‘))