Redis学习知识总结

朴灿烈づ我的快乐病毒、 2022-11-22 00:02 219阅读 0赞

# Redis #

### Redis学习知识总结 ###

*  Redis
 *   *  1.redis连接
     *   *  1.1直接连接
         *  1.2连接池
     *  2.基本数据类型
     *   *  2.2字符串型 String
         *  2.2列表类型List
         *  2.3哈希类型Hash
         *  2.4集合类型Set
         *  2.5有序集合类型 sorted set
     *  其他常用操作
     *   *  \*\*1.删除\*\*
         *  \*\*2.检查名字是否存在\*\*
         *  \*\*3.模糊匹配\*\*
         *  \*\*4.设置超时时间\*\*
         *  \*\*5.重命名\*\*
         *  \*\*6.随机获取name\*\*
         *  \*\*7.获取类型\*\*
         *  \*\*8.查看所有元素\*\*
     *  
     *   *  \*\*9.查看所有元素--迭代器\*\*
     *  
     *   *  \*\*管道（pipeline）\*\*
     *

## 1.redis连接 ##

### 1.1直接连接 ###

import redis   # 导入redis 模块
    ## decode_responses=True 解决的是值类型是 bytes 字节的问题
    r = redis.Redis(host='localhost', port=6379,password="123456",db=0,decode_responses=True)

### 1.2连接池 ###

redis-py 使用 connection pool 来管理对一个 redis server 的所有连接，避免每次建立、释放连接的开销。

默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数 Redis，这样就可以实现多个 Redis 实例共享一个连接池。

import redis    # 导入redis 模块
    
    pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
    r = redis.Redis(host='localhost', port=6379, decode_responses=True)  
    r.set('name', 'runoob')  # 设置 name 对应的值
    print(r.get('name'))  # 取出键 name 对应的值

## 2.基本数据类型 ##

### 2.2字符串型 String ###

set(name, value, ex=None, px=None, nx=False, xx=False)

在 Redis 中设置值，默认，不存在则创建，存在则修改。

参数：

*  ex - 过期时间（秒）
 *  px - 过期时间（毫秒）
 *  nx - 如果设置为True，则只有name不存在时，当前set操作才执行
 *  xx - 如果设置为True，则只有name存在时，当前set操作才执行

1.ex - 过期时间（秒） 这里过期时间是3秒，3秒后p，键food的值就变成None

import redis
    
    pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
    r = redis.Redis(connection_pool=pool)
    r.set('food', 'mutton', ex=3)    # key是"food" value是"mutton" 将键值对存入redis缓存
    print(r.get('food'))  # mutton 取出键food对应的值

2.nx - 如果设置为True，则只有name不存在时，当前set操作才执行 （新建）

import redis
    
    pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
    r = redis.Redis(connection_pool=pool)
    print(r.set('fruit', 'watermelon', nx=True))    # True--不存在
    # 如果键fruit不存在，那么输出是True；如果键fruit已经存在，输出是None

3.xx - 如果设置为True，则只有name存在时，当前set操作才执行 （修改）

print((r.set('fruit', 'watermelon', xx=True)))   # True--已经存在
    # 如果键fruit已经存在，那么输出是True；如果键fruit不存在，输出是None

4.**setnx(name, value)**

设置值，只有name不存在时，执行设置操作（添加）

print(r.setnx('fruit1', 'banana'))  # fruit1不存在，输出为True

5.**setex(name, time, value)**

设置值

参数：

time - 过期时间（数字秒 或 timedelta对象）

**psetex(name, time\_ms, value)** time\_ms - 过期时间（数字毫秒 或 timedelta对象）

import redis
    import time
    
    pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
    r = redis.Redis(connection_pool=pool)
    r.setex("fruit2", 5, "orange")
    time.sleep(5)
    print(r.get('fruit2'))  # 5秒后，取值就从orange变成None

6.\**mset(\*args, \*kwargs)*

批量设置值

r.mget({ 'k1': 'v1', 'k2': 'v2'})
    r.mset(k1="v1", k2="v2") # 这里k1 和k2 不能带引号 一次设置对个键值对
    print(r.mget("k1", "k2"))   # 一次取出多个键对应的值
    print(r.mget("k1"))

7.**mget(keys, \*args)**

批量获取

print(r.mget('k1', 'k2'))
    print(r.mget(['k1', 'k2']))
    print(r.mget("fruit", "fruit1", "fruit2", "k1", "k2"))  # 将目前redis缓存中的键对应的值批量取出来

8.**getrange(key, start, end)**

获取子序列（根据字节获取，非字符）

参数：

*  name - Redis 的 name
 *  start - 起始位置（字节）
 *  end - 结束位置（字节）

如： “君惜大大” ，0-3表示 “君”

r.set("cn_name", "君惜大大") # 汉字
    print(r.getrange("cn_name", 0, 2))   # 取索引号是0-2 前3位的字节 君 切片操作 （一个汉字3个字节 1个字母一个字节 每个字节8bit）
    print(r.getrange("cn_name", 0, -1))  # 取所有的字节 君惜大大 切片操作
    r.set("en_name","junxi") # 字母
    print(r.getrange("en_name", 0, 2))  # 取索引号是0-2 前3位的字节 jun 切片操作 （一个汉字3个字节 1个字母一个字节 每个字节8bit）
    print(r.getrange("en_name", 0, -1)) # 取所有的字节 junxi 切片操作

9.**setrange(name, offset, value)**

修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）

参数：

*  offset - 字符串的索引，字节（一个汉字三个字节）
 *  value - 要设置的值
    
        r.setrange("en_name", 1, "ccc")
        print(r.get("en_name"))    # jccci 原始值是junxi 从索引号是1开始替换成ccc 变成 jccci

10.setbit(name, offset, value)

对 name 对应值的二进制表示的位进行操作

参数：

*  name - redis的name
 *  offset - 位的索引（将值变换成二进制后再进行索引）
 *  value - 值只能是 1 或 0

注：如果在Redis中有一个对应： n1 = “foo”，

那么字符串foo的二进制表示为：01100110 01101111 01101111

所以，如果执行 setbit(‘n1’, 7, 1)，则就会将第7位设置为1，

那么最终二进制则变成 01100111 01101111 01101111，即：“goo”

扩展，转换二进制表示：

source = "陈思维"
    source = "foo"
    for i in source:
    num = ord(i)
    print bin(num).replace('b','')

**特别的，如果source是汉字 "陈思维"怎么办？**

答：对于utf-8，每一个汉字占 3 个字节，那么 “陈思维” 则有 9个字节 对于汉字，for循环时候会按照 字节 迭代，那么在迭代时，将每一个字节转换 十进制数，然后再将十进制数转换成二进制 11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

11.**getbit(name, offset)**

获取name对应的值的二进制表示中的某位的值 （0或1）

print(r.getbit("foo1", 0)) # 0 foo1 对应的二进制 4个字节 32位 第0位是0还是1

12.**bitcount(key, start=None, end=None)**

获取name对应的值的二进制表示中 1 的个数

参数：

*  key - Redis的name
 *  start - 字节起始位置
 *  end - 字节结束位置

13.**bitop(operation, dest, \*keys)**

获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值

参数：

*  operation - AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
 *  dest - 新的Redis的name
 *  \*keys - 要查找的Redis的name

bitop("AND", 'new_name', 'n1', 'n2', 'n3')

获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new\_name 对应的值中

r.set("foo","1")  # 0110001
    r.set("foo1","2")  # 0110010
    print(r.mget("foo","foo1"))  # ['goo1', 'baaanew']
    print(r.bitop("AND","new","foo","foo1"))  # "new" 0 0110000
    print(r.mget("foo","foo1","new"))
    
    source = "12"
    for i in source:
    num = ord(i)
    print(num)  # 打印每个字母字符或者汉字字符对应的ascii码值 f-102-0b100111-01100111
    print(bin(num))  # 打印每个10进制ascii码值转换成二进制的值 0b1100110（0b表示二进制）
    print bin(num).replace('b','')  # 将二进制0b1100110替换成01100110

14.**strlen(name)**

返回name对应值的字节长度（一个汉字3个字节

15.**incr(self, name, amount=1)**

自增 name 对应的值，当 name 不存在时，则创建 name＝amount，否则，则自增。

参数：

*  name - Redis的name
 *  amount - 自增数（必须是整数）

r.set("foo", 123)
    print(r.mget("foo", "foo1", "foo2", "k1", "k2"))
    r.incr("foo", amount=1)
    print(r.mget("foo", "foo1", "foo2", "k1", "k2"))

**应用场景 – 页面点击数**

假定我们对一系列页面需要记录点击次数。例如论坛的每个帖子都要记录点击次数，而点击次数比回帖的次数的多得多。如果使用关系数据库来存储点击，可能存在大量的行级锁争用。所以，点击数的增加使用redis的INCR命令最好不过了。

当redis服务器启动时，可以从关系数据库读入点击数的初始值（12306这个页面被访问了34634次）

r.set("visit:12306:totals", 34634)
    **print**(r.get("visit:12306:totals"))

每当有一个页面点击，则使用INCR增加点击数即可。

r.incr("visit:12306:totals")
    r.incr("visit:12306:totals")

页面载入的时候则可直接获取这个值

print(r.get("visit:12306:totals"))

16.incrbyfloat(self, name, amount=1.0)\*

自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。

参数：

*  name - Redis的name
 *  amount - 自增数（浮点型）
    
    自增为1.0 、2.0、 3.0

17.**ecr(self, name, amount=1)**

自减 name 对应的值，当 name 不存在时，则创建 name＝amount，否则，则自减。

参数：

*  name - Redis的name
 *  amount - 自减数（整数)

18.**append(key, value)**

在redis name对应的值后面追加内容

参数：

*  key - redis的name
 *  value - 要追加的字符串

r.append("name", "haha")    # 在name对应的值junxi后面追加字符串haha
    print(r.mget("name"))

### 2.2列表类型List ###

### 2.3哈希类型Hash ###

1、单个增加–修改(单个取出)–没有就新增，有的话就修改

hset(name, key, value)

name对应的hash中设置一个键值对（不存在，则创建；否则，修改）

参数：

*  name - redis的name
 *  key - name对应的hash中的key
 *  value - name对应的hash中的value

注：hsetnx(name, key, value) 当name对应的hash中不存在当前key时则创建（相当于添加）

import redis
    import time
    
    pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
    r = redis.Redis(connection_pool=pool)
    
    r.hset("hash1", "k1", "v1")
    r.hset("hash1", "k2", "v2")
    print(r.hkeys("hash1")) # 取hash中所有的key
    print(r.hget("hash1", "k1"))    # 单个取hash的key对应的值
    print(r.hmget("hash1", "k1", "k2")) # 多个取hash的key对应的值
    r.hsetnx("hash1", "k2", "v3") # 只能新建
    print(r.hget("hash1", "k2"))

2、批量增加（取出）

hmset(name, mapping)

在name对应的hash中批量设置键值对

参数：

*  name - redis的name
 *  mapping - 字典，如：\{‘k1’:‘v1’, ‘k2’: ‘v2’\}

r.hmset("hash2", { "k2": "v2", "k3": "v3"})
    hget(name,key)

在name对应的hash中获取根据key获取value

hmget(name, keys, *args)

在name对应的hash中获取多个key的值

参数：

*  name - reids对应的name
 *  keys - 要获取key集合，如：\[‘k1’, ‘k2’, ‘k3’\]
 *  \*args - 要获取的key，如：k1,k2,k3

print(r.hget("hash2", "k2"))  # 单个取出"hash2"的key-k2对应的value
    print(r.hmget("hash2", "k2", "k3"))  # 批量取出"hash2"的key-k2 k3对应的value --方式1
    print(r.hmget("hash2", ["k2", "k3"]))  # 批量取出"hash2"的key-k2 k3对应的value --方式2

### 2.4集合类型Set ###

1.新增

sadd(name,values)

name - 对应的集合中添加元素

r.sadd("set1", 33, 44, 55, 66)  # 往集合中添加元素
    print(r.scard("set1"))  # 集合的长度是4
    print(r.smembers("set1"))   # 获取集合中所有的成员

2.获取元素个数 类似于len

scard(name) #获取name对应的集合中元素个数

3.获取集合中所有的成员

smembers(name)  #获取name对应的集合的所有成员

获取集合中所有的成员–元组形式

sscan(name, cursor=0, match=None, count=None)

print(r.sscan("set1"))

获取集合中所有的成员–迭代器的方式

sscan_iter(name, match=None, count=None)

同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大

for i in r.sscan_iter("set1"):
        print(i)

4.**.差集**

sdiff(keys, *args)

在第一个name对应的集合中且不在其他name对应的集合的元素集合

r.sadd("set2", 11, 22, 33)
    print(r.smembers("set1"))   # 获取集合中所有的成员
    print(r.smembers("set2"))
    print(r.sdiff("set1", "set2"))   # 在集合set1但是不在集合set2中
    print(r.sdiff("set2", "set1"))   # 在集合set2但是不在集合set1中

5.差集–差集存在一个新的集合中

sdiffstore(dest, keys, *args)

获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中

r.sdiffstore("set3", "set1", "set2")    # 在集合set1但是不在集合set2中
    print(r.smembers("set3"))   # 获取集合3中所有的成员

6.交集

sinter(keys, *args)

获取多一个name对应集合的交集

print(r.sinter("set1", "set2")) # 取2个集合的交集

7.交集–交集存在一个新的集合中

sinterstore(dest, keys, *args)

获取多一个name对应集合的并集，再将其加入到dest对应的集合中

print(r.sinterstore("set3", "set1", "set2")) # 取2个集合的交集
    print(r.smembers("set3"))

8.并集

sunion(keys, *args)

获取多个name对应的集合的并集

print(r.sunion("set1", "set2")) # 取2个集合的并集

9.并集–并集存在一个新的集合

sunionstore(dest,keys, *args)

获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中

print(r.sunionstore("set3", "set1", "set2")) # 取2个集合的并集
    print(r.smembers("set3"))

10.判断是否是集合的成员 类似in

sismember(name, value)

检查value是否是name对应的集合的成员，结果为True和False

print(r.sismember("set1", 33))  # 33是集合的成员
    print(r.sismember("set1", 23))  # 23不是集合的成员

11.**移动**

smove(src, dst, value)

将某个成员从一个集合中移动到另外一个集合

r.smove("set1", "set2", 44)
    print(r.smembers("set1"))
    print(r.smembers("set2"))

12.删除–随机删除并且返回被删除值

pop(name)

从集合移除一个成员，并将其返回,说明一下，集合是无序的，所有是随机删除的

print(r.spop("set2"))   # 这个删除的值是随机删除的，集合是无序的
    print(r.smembers("set2"))

13.删除–指定值删除

srem(name, values)

在name对应的集合中删除某些值

print(r.srem("set2", 11))   # 从集合中删除指定值 11
    print(r.smembers("set2"))

### 2.5有序集合类型 sorted set ###

Set操作，Set集合就是不允许重复的列表，本身是无序的。

有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。

**1.新增**

zadd(name, *args, **kwargs)

在name对应的有序集合中添加元素

import redis
    import time
    
    pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
    r = redis.Redis(connection_pool=pool)
    
    r.zadd("zset1", n1=11, n2=22)
    r.zadd("zset2", 'm1', 22, 'm2', 44)
    **print**(r.zcard("zset1")) # 集合长度
    **print**(r.zcard("zset2")) # 集合长度
    **print**(r.zrange("zset1", 0, -1))  # 获取有序集合中所有元素
    **print**(r.zrange("zset2", 0, -1, withscores=True))  # 获取有序集合中所有元素和分数

**2.获取有序集合元素个数 类似于len**

zcard(name)

获取name对应的有序集合元素的数量

print(r.zcard("zset1")) # 集合长度

**3.获取有序集合的所有元素**

r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)

按照索引范围获取name对应的有序集合的元素

参数：

*  name - redis的name
 *  start - 有序集合索引起始位置（非分数）
 *  end - 有序集合索引结束位置（非分数）
 *  desc - 排序规则，默认按照分数从小到大排序
 *  withscores - 是否获取元素的分数，默认只获取元素的值
 *  score\_cast\_func - 对分数进行数据转换的函数

3-1 从大到小排序(同zrange，集合是从大到小排序的)

zrevrange(name, start, end, withscores=False, score_cast_func=float)

print(r.zrevrange("zset1", 0, -1))    # 只获取元素，不显示分数
    print(r.zrevrange("zset1", 0, -1, withscores=True)) # 获取有序集合中所有元素和分数,分数倒序

3-2 按照分数范围获取name对应的有序集合的元素

zrangebyscore(name, min, max, start=None, num=None, withscores=False, score\_cast\_func=float)

for i in range(1, 30):
      element = 'n' + str(i)
      r.zadd("zset3", element, i)
    print(r.zrangebyscore("zset3", 15, 25)) # # 在分数是15-25之间，取出符合条件的元素
    print(r.zrangebyscore("zset3", 12, 22, withscores=True))   # 在分数是12-22之间，取出符合条件的元素（带分数）

3-3 按照分数范围获取有序集合的元素并排序（默认从大到小排序）

zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

print(r.zrevrangebyscore("zset3", 22, 11, withscores=True)) # 在分数是22-11之间，取出符合条件的元素 按照

分数倒序

3-4 获取所有元素–默认按照分数顺序排序

zscan(name, cursor=0, match=None, count=None, score_cast_func=float)

print(r.zscan("zset3"))

3-5 获取所有元素–迭代器

zscan_iter(name, match=None, count=None,score_cast_func=float)

for i in r.zscan_iter("zset3"): # 遍历迭代器
        print(i)

**4.zcount(name, min, max)**

获取name对应的有序集合中分数 在 \[min,max\] 之间的个数

print(r.zrange("zset3", 0, -1, withscores=True))
    print(r.zcount("zset3", 11, 22))

**5.自增**

zincrby(name, value, amount)

自增name对应的有序集合的 name 对应的分数

r.zincrby("zset3", "n2", amount=2)    # 每次将n2的分数自增2
    print(r.zrange("zset3", 0, -1, withscores=True))

**6.获取值的索引号**

zrank(name, value)

获取某个值在 name对应的有序集合中的索引（从 0 开始）

zrevrank(name, value)，从大到小排序。

print(r.zrank("zset3", "n1"))  # n1的索引号是0 这里按照分数顺序（从小到大）
    
    print(r.zrank("zset3", "n6"))  # n6的索引号是1
    
    print(r.zrevrank("zset3", "n1"))   # n1的索引号是29 这里安照分数倒序（从大到小）

**7.删除–指定值删除**

zrem(name, values)

删除name对应的有序集合中值是values的成员

r.zrem("zset3", "n3")   # 删除有序集合中的元素n3 删除单个
    print(r.zrange("zset3", 0, -1))

**8.删除–根据排行范围删除，按照索引号来删除**

zremrangebyrank(name, min, max)

根据排行范围删除

r.zremrangebyrank("zset3", 0, 1)  # 删除有序集合中的索引号是0, 1的元素
    print(r.zrange("zset3", 0, -1))

**9.删除–根据分数范围删除**

zremrangebyscore(name, min, max)

根据分数范围删除

r.zremrangebyscore("zset3", 11, 22)   # 删除有序集合中的分数是11-22的元素
    print(r.zrange("zset3", 0, -1))

**10.获取值对应的分数**

zscore(name, value)

获取name对应有序集合中 value 对应的分数

print(r.zscore("zset3", "n27"))   # 获取元素n27对应的分数27

## 其他常用操作 ##

### **1.删除** ###

delete(*names)

根据删除redis中的任意数据类型（string、hash、list、set、有序set）

r.delete("gender")  # 删除key为gender的键值对

### **2.检查名字是否存在** ###

exists(name)

检测redis的name是否存在，存在就是True，False 不存在

print(r.exists("zset1"))

### **3.模糊匹配** ###

keys(pattern='')

根据模型获取redis的name

*  KEYS \* 匹配数据库中所有 key 。
 *  KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
 *  KEYS hllo 匹配 hllo 和 heeeeello 等。
 *  KEYS h\[ae\]llo 匹配 hello 和 hallo ，但不匹配 hillo

print(r.keys("foo*"))

### **4.设置超时时间** ###

expire(name ,time)

为某个redis的某个name设置超时时间

r.lpush("list5", 11, 22)
    r.expire("list5", time=3)
    print(r.lrange("list5", 0, -1))
    time.sleep(3)
    print(r.lrange("list5", 0, -1))

### **5.重命名** ###

rename(src, dst)

对redis的name重命名

r.lpush("list5", 11, 22)
    r.rename("list5", "list5-1")

### **6.随机获取name** ###

randomkey()

随机获取一个redis的name（不删除）

print(r.randomkey())

### **7.获取类型** ###

type(name)

获取name对应值的类型

print(r.type("set1"))
    print(r.type("hash2"))

### **8.查看所有元素** ###

##  ##

scan(cursor=0, match=None, count=None)

**print**(r.hscan("hash2"))
    **print**(r.sscan("set3"))
    **print**(r.zscan("zset2"))
    **print**(r.getrange("foo1", 0, -1))
    **print**(r.lrange("list2", 0, -1))
    **print**(r.smembers("set3"))
    **print**(r.zrange("zset3", 0, -1))
    **print**(r.hgetall("hash1"))

### **9.查看所有元素–迭代器** ###

##  ##

scan\_iter(match=None, count=None)

for i in r.hscan_iter("hash1"):
      print(i)
    
    for i in r.sscan_iter("set3"):
      print(i)
    
    for i in r.zscan_iter("zset3"):
      print(i)

other 方法

print(r.get('name'))   # 查询key为name的值
    r.delete("gender") # 删除key为gender的键值对
    print(r.keys()) # 查询所有的Key
    print(r.dbsize())  # 当前redis包含多少条数据
    r.save()   # 执行"检查点"操作，将数据写回磁盘。保存时阻塞
    r.flushdb()     # 清空r中的所有数据

### **管道（pipeline）** ###

redis默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。

管道（pipeline）是redis在提供单个请求中缓冲多条服务器命令的基类的子类。它通过减少服务器-客户端之间反复的TCP数据库包，从而大大提高了执行批量命令的功能。

##  ##

import redis
    import time
    
    pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
    r = redis.Redis(connection_pool=pool)
    
    
    
    # pipe = r.pipeline(transaction=False) # 默认的情况下，管道里执行的命令可以保证执行的原子性，执行pipe = r.pipeline(transaction=False)可以禁用这一特性。
    
    pipe.set('name', 'jack')
    pipe.set('role', 'sb')
    pipe.sadd('faz', 'baz')
    pipe.incr('num')   # 如果num不存在则vaule为1，如果存在，则value自增1
    pipe.execute()
    
    print(r.get("name"))
    print(r.get("role"))
    print(r.get("num"))

管道的命令可以写在一起，如：

pipe.set('hello', 'redis').sadd('faz', 'baz').incr('num').execute()
    print(r.get("name"))
    print(r.get("role"))
    print(r.get("num"))