redis数据库操作

一、String（字符串）操作

String在redis中的存储是按照key-value的形式存储

1、SET key value [EX seconds] [PX milliseconds] [NX|XX]

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

可选参数

• EX second ：设置键的过期时间为 second 秒。 
• PX millisecond ：设置键的过期时间为 millisecond 毫秒。
• NX ：只在键不存在时，才对键进行设置操作。
• XX ：只在键已经存在时，才对键进行设置操作

实例：

#对不存在的键赋值
127.0.0.1:6379> set name "bright"
OK

127.0.0.1:6379> get name
 "bright"

# 对已存在的键进行设置
127.0.0.1:6379> set name "alvin"
OK
127.0.0.1:6379> get name
"alvin"

# 使用 EX 选项
127.0.0.1:6379> set age 13 EX 10
OK

127.0.0.1:6379> GET age
(nil)

# 使用 PX 选项
127.0.0.1:6379> set gender "male" PX 100
OK
127.0.0.1:6379> get gender
(nil)

# 使用 NX 选项
127.0.0.1:6379> set hobby "basketball" NX
OK    # 键不存在，设置成功
127.0.0.1:6379> get hobby
"basketball"
127.0.0.1:6379> set hobby "ping-pong" NX
(nil)   # 键已经存在，设置失败
127.0.0.1:6379> get hobby
"basketball"  # 维持原值不变

# 使用 XX 选项
127.0.0.1:6379> set sing_type "popular" XX
(nil)   # 因为键不存在，设置失败
127.0.0.1:6379> set sing_type "popular"
OK     # 先给键设置一个值
127.0.0.1:6379> set sing_type "classical" XX
OK    # 设置新值成功
127.0.0.1:6379> get sing_type
"classical"

 2、SETEX key seconds value

• 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。
• 如果 key 已经存在， SETEX 命令将覆写旧值。

实例：

# 在 key 不存在时进行 SETEX
127.0.0.1:6379> setex user 10 "root"
OK
127.0.0.1:6379> get user
(nil)

# key 已经存在时，SETEX 覆盖旧值
127.0.0.1:6379> set role "manager"
OK
127.0.0.1:6379> setex role 10 "producer"
OK
127.0.0.1:6379> get role
"producer"
127.0.0.1:6379> get role
"producer"
127.0.0.1:6379> get role
(nil)

3、SETNX key value

• 将 key 的值设为 value ，当且仅当 key 不存在。
• 若给定的 key 已经存在，则 SETNX 不做任何动作。

实例：

127.0.0.1:6379> exists job
(integer) 0     # job 不存在
127.0.0.1:6379> setnx job "manager"
(integer) 1     # job 设置成功
127.0.0.1:6379> setnx job "producer"
(integer) 0     # 尝试覆盖 job ，失败
127.0.0.1:6379> get job
"manager"   # 没有被覆盖

 4、PSETEX key milliseconds value

这个命令和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，而不是像 SETEX 命令那样，以秒为单位。
设置成功时返回 OK 。

实例：

127.0.0.1:6379> psetex book 5000 "english"  
OK   #设置值，超时为5000ms

127.0.0.1:6379> get book
"english"  #获取值
127.0.0.1:6379> get book
(nil)

5、GET key

返回 key 所关联的字符串值。
如果 key 不存在那么返回特殊值 nil 。
假如 key 储存的值不是字符串类型，返回一个错误，因为 GET 只能用于处理字符串值。

实例：

# 对不存在的 key 或字符串类型 key 进行 GET
127.0.0.1:6379> get cat
(nil)

6、MSET key value [key value ...]

同时设置一个或多个 key-value 对。
如果某个给定 key 已经存在，那么 MSET 会用新值覆盖原来的旧值。
总是返回 OK (因为 MSET 不可能失败)

实例：

#设置多个值以及获取多个值
127.0.0.1:6379> mset date "2019.2.1" time "200"
OK
127.0.0.1:6379> mget date time
1) "2019.2.1"
2) "200"
127.0.0.1:6379> 

#覆盖旧值
127.0.0.1:6379> set date "2018.3.10"
OK
127.0.0.1:6379> get date
"2018.3.10"
127.0.0.1:6379> 

7、MGET key [key ...]

返回所有(一个或多个)给定 key 的值（是一个列表）。
如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil 。因此，该命令永不失败。

实例参考：MSET 

8、SETRANGE key offset value

修改value的值，从指定的位置开始向后
不存在的 key 当作空白字符串处理
如果value长度比偏移量小(比如字符串只有 5 个字符长，但你设置的 offset 是 10 )，那么原字符和偏移量之间的空白将用零字节(zerobytes, "x00" )来填充。
返回值是修改之后，字符串的长度。

实例：

#对非空字符串替换
127.0.0.1:6379> set food "meet"
OK
127.0.0.1:6379> setrange food 2 at  #2表示索引，从0开始
(integer) 4
127.0.0.1:6379> get food
"meat"
127.0.0.1:6379> 

#对空字符串/不存在的 key 进行 SETRANGE
127.0.0.1:6379> exists flowers
(integer) 0
127.0.0.1:6379> setrange flowers 3 "sh"
(integer) 5
127.0.0.1:6379> get flowers
"x00x00x00sh"
127.0.0.1:6379> 

9、GETRANGE key start end

返回 key 中字符串值的子字符串，字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)。
负数偏移量表示从字符串最后开始计数， -1 表示最后一个字符， -2 表示倒数第二个，以此类推。
GETRANGE 通过保证子字符串的值域(range)不超过实际字符串的值域来处理超出范围的值域请求。

实例：

127.0.0.1:6379> set flowers "rose"
OK
127.0.0.1:6379> getrange flowers 0 2
"ros"

127.0.0.1:6379> getrange flowers -3 -1
"ose"
127.0.0.1:6379> getrange flowers -6 -1 #如果超过字符串的长度就是全取
"rose"

10、SETBIT key offset value

对key对应值的二进制表示的位进行操作
 
参数：
    key，redis的key
    offset，位的索引（将值变换成二进制后再进行索引）
    value，值只能是 1 或 0

实例：

#转换二进制方式
>>> str= "rose"
>>> for i in str:
...     num = ord(i) 
...     print(bin(num)) #转成二进制位
...
0b1110010
0b1101111
0b1110011
0b1100101

#setbit就是在此基础上进行操作的，

11、GETBIT key offset

对 key 所储存的字符串值，获取指定偏移量上的位(bit)值（0或者1）。
当 offset 比字符串值的长度大，或者 key 不存在时，返回 0 。

12、BITCOUNT key [start] [end]

计算给定字符串中，value二进制中被设置为 1 的比特位的数量。
start 和 end 参数指的是起始和结束的位置（二进制）
start 和 end 参数的设置和 GETRANGE 命令类似，都可以使用负数值：比如 -1 表示最后一个位，而 -2 表示倒数第二个位，以此类推。
不存在的 key 被当成是空字符串来处理，因此对一个不存在的 key 进行 BITCOUNT 操作，结果为 0 。

#可用于统计用于上线次数

13、STRLEN key

返回 key 所储存的字符串值的长度。
当 key 不存在时，返回 0 。

实例：

127.0.0.1:6379> set school "xadx"
OK
127.0.0.1:6379> strlen school
(integer) 4  ## 获取字符串的长度

127.0.0.1:6379> strlen kfkk
(integer) 0  ## 不存在的 key 长度为 0
127.0.0.1:6379> 

14、INCR key

将 key 中储存的数字值增一。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。

#可应用于web程序，用户在一年中每天的点击量，只要将用户 ID 以及相关的日期信息作为键，并在每次用户点击页面时，执行一次自增操作即可。
#比如用户名是 sandy，点击时间是 2019 年 4 月 21 日，那么执行命令 INCR sandy::2019.4.21。

实例：

127.0.0.1:6379> set num 10
OK
127.0.0.1:6379> incr num
(integer) 11
127.0.0.1:6379> get num
"11"     # 数字值在 Redis 中以字符串的形式保存
127.0.0.1:6379> 

15、INCRBY key increment

将 key 所储存的值加上增量 increment ，返回的是加上 increment 之后， key 的值。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。

实例：

#key存在且是数字
127.0.0.1:6379> set n1 10
OK
127.0.0.1:6379> incrby n1 12
(integer) 22
127.0.0.1:6379> get n1
"22"

#key不存在但是数字
127.0.0.1:6379> exists n2
(integer) 0
127.0.0.1:6379> incrby n2 10
(integer) 10
127.0.0.1:6379> get n2
"10"

#key不是数字
127.0.0.1:6379> set author "anbo"
OK
127.0.0.1:6379> incrby author 20
(error) ERR value is not an integer or out of range
127.0.0.1:6379> 

16、INCRBYFLOAT key increment

为 key 中所储存的值加上浮点数增量 increment 。
如果 key 不存在，那么 INCRBYFLOAT 会先将 key 的值设为 0 ，再执行加法操作。
如果命令执行成功，那么 key 的值会被更新为（执行加法之后的）新值，并且新值会以字符串的形式返回给调用者

127.0.0.1:6379> set n3 11
OK
127.0.0.1:6379> incrbyfloat n3 0.5
"11.5"
127.0.0.1:6379> get n3
"11.5"

17、DECR key

将 key 中储存的数字值减一。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。

DE

#对存在的数字值 key 进行 DECR
127.0.0.1:6379> set time 21
OK
127.0.0.1:6379> decr time
(integer) 20
127.0.0.1:6379> get time

# 对不存在的 key 值进行 DECR
127.0.0.1:6379> exists time1
(integer) 0
127.0.0.1:6379> decr time1
(integer) -1

#对存在不是数值的进行DECR
127.0.0.1:6379> decr flowers
(error) ERR value is not an integer or out of range

18、DECRBY key decrement

将 key 所储存的值减去减量 decrement ，返回值为减去 decrement 之后， key 的值。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。

#对存在的key
127.0.0.1:6379> decrby num1 20
(integer) 0
127.0.0.1:6379> set num1 20
OK

#对不存在的key
127.0.0.1:6379> exists num4 
(integer) 0
127.0.0.1:6379> decrby num4 10
(integer) -10

19、APPEND key value

如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
返回值为追加 value 之后， key 中字符串的长度。

#对已经存在的key
127.0.0.1:6379> set description "abc"
OK
127.0.0.1:6379> append description 123
(integer) 6
127.0.0.1:6379> get description
"abc123"

#不存在的key
127.0.0.1:6379> exists name2
(integer) 0
127.0.0.1:6379> append name2 123
(integer) 3
127.0.0.1:6379> get name2
"123"

 二、Hash（哈希）操作

哈希类似于python中的字典

1、HSET key field value

将哈希表 key 中的域 field 的值设为 value 。
如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。
如果域 field 已经存在于哈希表中，旧值将被覆盖。

返回值：
    如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1 。
    如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。

实例：

127.0.0.1:6379> hset apple color "red"
(integer) 1  #设置新域

127.0.0.1:6379> hset apple color "green"
(integer) 0  #覆盖旧域
127.0.0.1:6379> 

2、HSETNX key field value

将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。
若域 field 已经存在，该操作无效。
如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令。

返回值：
    设置成功，返回 1 。
    如果给定域已经存在且没有操作被执行，返回 0 。

 实例：

127.0.0.1:6379> hsetnx harry gender "male"
(integer) 1
127.0.0.1:6379> hsetnx harry gender "male"
(integer) 0
127.0.0.1:6379> 

3、HGET key field

返回哈希表 key 中给定域 field 的值。
当给定域不存在或是给定 key 不存在时，返回 nil 。

实例：

#域存在
127.0.0.1:6379> hset pear color "yellow"
(integer) 1
127.0.0.1:6379> hget pear color
"yellow"

#域不存在
127.0.0.1:6379> hget pencil height
(nil)

4、HGETALL key

返回哈希表 key 中，所有的域和值，以列表形式返回哈希表的域和域的值，
若 key 不存在，返回空列表。

实例：

127.0.0.1:6379> hset cat color "white"
(integer) 1
127.0.0.1:6379> hset cat gender "male"
(integer) 1
127.0.0.1:6379> hgetall cat
1) "color"
2) "white"
3) "gender"
4) "male"

5、HLEN key

返回哈希表 key 中域的数量。

返回值：
    哈希表中域的数量。
    当 key 不存在时，返回 0 。

实例：

127.0.0.1:6379> hmset fruits apple "green" pear "yellow" 
OK
127.0.0.1:6379> hgetall fruits
1) "apple"
2) "green"
3) "pear"
4) "yellow"

127.0.0.1:6379> hlen fruits
(integer) 2

6、HINCRBY key field increment

为哈希表 key 中的域 field 的值加上增量 increment 。
增量也可以为负数，相当于对给定域进行减法操作。
如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。
如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。
对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。

返回值：
    执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。

实例：

#increment为正数
127.0.0.1:6379> hset page num 10
(integer) 1
127.0.0.1:6379> hincrby page num 2
(integer) 12
127.0.0.1:6379> hget page num
"12"

#increment为负数
127.0.0.1:6379> hset page num 3
(integer) 0
127.0.0.1:6379> hincrby page num -5
(integer) -2

7、HINCRBYFLOAT key field increment

为哈希表 key 中的域 field 加上浮点数增量 increment 。

如果哈希表中没有域 field ，那么 HINCRBYFLOAT 会先将域 field 的值设为 0 ，然后再执行加法操作。

如果键 key 不存在，那么 HINCRBYFLOAT 会先创建一个哈希表，再创建域 field ，最后再执行加法操作。

返回值：
    执行加法操作之后 field 域的值。

实例：

## 值和增量都是普通小数
127.0.0.1:6379> hset apple price 10.2
(integer) 1
127.0.0.1:6379> hincrbyfloat apple price 0.5
"10.7"
127.0.0.1:6379> hget appleprice
(error) ERR wrong number of arguments for 'hget' command
127.0.0.1:6379> hget apple price
"10.7"

#对不存在的键执行 HINCRBYFLOAT
127.0.0.1:6379> exists strw
(integer) 0
127.0.0.1:6379> hincrbyfloat strw price 2.5
"2.5"
127.0.0.1:6379> hgetall strw
1) "price"
2) "2.5"

# 对不存在的域进行 HINCRBYFLOAT
127.0.0.1:6379> hgetall apple
1) "color"
2) "green"
3) "price"
4) "10.7"
127.0.0.1:6379> hincrbyfloat apple weight 2.6 #新增域
"2.6"
127.0.0.1:6379> hgetall apple
1) "color"
2) "green"
3) "price"
4) "10.7"
5) "weight"
6) "2.6"

8、HMSET key field value [field value ...]

同时将多个 field-value (域-值)对设置到哈希表 key 中。
此命令会覆盖哈希表中已存在的域。
如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。

返回值：
    如果命令执行成功，返回 OK 。
    当 key 不是哈希表(hash)类型时，返回一个错误。

127.0.0.1:6379> hmset xiaoming height 170 gender boy
OK
127.0.0.1:6379> 

9、HMGET key field [field ...]

返回哈希表 key 中，一个或多个给定域的值。
如果给定的域不存在于哈希表，那么返回一个 nil 值。

实例：

#已经存在的哈希值
127.0.0.1:6379> hmset xiaoming height 170 gender boy
OK
127.0.0.1:6379> hmset xiaoming height 170 gender boy
OK
127.0.0.1:6379> hmget xiaoming height gender
1) "170"
2) "boy"

10、HDEL key field [field ...]

删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。

返回值:
    被成功移除的域的数量，不包括被忽略的域。

实例：

127.0.0.1:6379> hgetall cat
1) "color"
2) "white"
3) "gender"
4) "male"
#删除单个域
127.0.0.1:6379> hdel cat color
(integer) 1
#删除不存在的域
127.0.0.1:6379> hdel cat color
(integer) 0
删除多个域
127.0.0.1:6379> hdel cat color gender
(integer) 1
127.0.0.1:6379> hgetall cat
(empty list or set)

11、HEXISTS key field

查看哈希表 key 中，给定域 field 是否存在。

返回值：
    如果哈希表含有给定域，返回 1 。
    如果哈希表不含有给定域，或 key 不存在，返回 0 。

实例：

#不存在给定域field值
127.0.0.1:6379> hexists cat color
(integer) 0

#存在给定域field值
127.0.0.1:6379> hexists dog color
(integer) 1

12、HVALS key

返回哈希表 key 中所有域的值。

返回值：
    一个包含哈希表中所有值的表。
    当 key 不存在时，返回一个空表。

实例：

127.0.0.1:6379> hmset fruits apple "green" pear "yellow" 
OK
127.0.0.1:6379> hvals fruits
1) "green"
2) "yellow"

13、HKEYS key

返回哈希表 key 中的所有域。

返回值：
    一个包含哈希表中所有域的表。
    当 key 不存在时，返回一个空表。

实例：

127.0.0.1:6379> hmset apple color "green" price 12 weight 10
OK
127.0.0.1:6379> hkeys apple
1) "color"
2) "price"
3) "weight"

14、HSCAN key cursor [MATCH pattern] [COUNT count]

增量式迭代获取
 
参数：
    key，redis的key
    cursor，游标（基于游标分批取获取数据）
    match，匹配指定key，默认None 表示所有的key
    count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数

实例：

###迭代获取
127.0.0.1:6379> scan 0
1) "9"
2)  1) "dog"
    2) "xiaoming"
    3) "n3"
    4) "n2"
    5) "flowers"
    6) "name"
    7) "fruits"
    8) "num2"
    9) "description"
   10) "name2"
127.0.0.1:6379> scan 9
1) "11"
2)  1) "n1"
    2) "food"
    3) "num4"
    4) "school"
    5) "time1"
    6) "author"
    7) "page"
    8) "harry"
    9) "apple"
   10) "pear"
127.0.0.1:6379> 
 第一次迭代使用 0 作为游标， 表示开始一次新的迭代。

第二次迭代使用的是第一次迭代时返回的游标， 也即是命令回复第一个元素的值 —— 9 。

从上面的示例可以看到， SCAN 命令的回复是一个包含两个元素的数组， 第一个数组元素是用于进行下一次迭代的新游标， 而第二个数组元素则是一个数组， 这个数组中包含了所有被迭代的元素。

在第二次调用 SCAN 命令时， 命令返回了游标 0 ， 这表示迭代已经结束， 整个数据集（collection）已经被完整遍历过了。

以 0 作为游标开始一次新的迭代， 一直调用 SCAN 命令， 直到命令返回游标 0 ， 我们称这个过程为一次完整遍历（full iteration）。

#进行match匹配过滤
127.0.0.1:6379> scan 0 match *a*
1) "9"
2) 1) "xiaoming"
   2) "name"
   3) "name2"
127.0.0.1:6379> 

三、List（列表）操作

列表的存储按照key-list来进行存储的

1、LPUSH key value [value ...]

将一个或多个值 value 插入到列表 key 的表头

如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头。

如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。

返回值：
    执行 LPUSH 命令后，列表的长度。

实例：

127.0.0.1:6379> lpush l1 apple pear
(integer) 2

2、LPUSHX key value

将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。

和 LPUSH 命令相反，当 key 不存在时， LPUSHX 命令什么也不做。

返回值：
　　lpushx操作后列表的长度

实例：

127.0.0.1:6379> lpush l1 apple pear
(integer) 2
127.0.0.1:6379> lpush l1 straw
(integer) 3
127.0.0.1:6379> lpushx l1 straw
(integer) 4

3、LINSERT key BEFORE|AFTER pivot value

将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。

当 pivot 不存在于列表 key 时，不执行任何操作。

当 key 不存在时， key 被视为空列表，不执行任何操作。

如果 key 不是列表类型，返回一个错误。

返回值:
    如果命令执行成功，返回插入操作完成之后，列表的长度。
    如果没有找到 pivot ，返回 -1 。
    如果 key 不存在或为空列表，返回 0 。

实例：

127.0.0.1:6379> lrange l3 0 -1
1) "7"
2) "dog"
3) "5"
4) "2"
127.0.0.1:6379> linsert l3 before dog cat #在dog之前插入cat
(integer) 5
127.0.0.1:6379> lrange l3 0 -1
1) "7"
2) "cat"
3) "dog"
4) "5"
5) "2"

4、LRANGE key start stop

返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

注意：
    stop 下标也在 LRANGE 命令的取值范围之内(闭区间)

返回值:
一个列表，包含指定区间内的元素。

实例：

#获取列表所有元素
127.0.0.1:6379> lrange l1 0 -1
1) "straw"
2) "straw"
3) "pear"
4) "apple"

5、LTRIM key start stop

列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

当 key 不是列表类型时，返回一个错误。

注意：
    区间是包括start和stop的闭区间

返回值：
    命令执行成功时，返回 ok 

实例：

127.0.0.1:6379> lrange l3 0 -1
1) "7"
2) "dog"
3) "5"
4) "2"
5) "1"
127.0.0.1:6379> ltrim l3 0 3 #取出前4个元素
OK
127.0.0.1:6379> lrange l3 0 -1
1) "7"
2) "dog"
3) "5"
4) "2"

6、LINDEX key index

返回列表 key 中，下标为 index 的元素。

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

如果 key 不是列表类型，返回一个错误。

返回值：
    列表中下标为 index 的元素。
    如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。

实例：

127.0.0.1:6379> lrange l3 0 -1
1) "7"
2) "dog"
3) "5"
4) "2"
127.0.0.1:6379> lindex l3 1 #索引在返回内
"dog"
127.0.0.1:6379> lindex l3 10 #索引超出范围
(nil)

7、LPOP

移除并返回列表 key 的头元素。

返回值：
    列表的头元素。
    当 key 不存在时，返回 nil 。

实例：

127.0.0.1:6379> lrange l1 0 -1
1) "straw"
2) "straw"
3) "pear"
4) "apple"
127.0.0.1:6379> lpop l1 #key存在
"straw"
127.0.0.1:6379> lpop l2 #key不存在
(nil)

8、LREM key count value

根据参数 count 的值，移除列表中与参数 value 相等的元素。

count 的值可以是以下几种：

    count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
    count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
    count = 0 : 移除表中所有与 value 相等的值。

返回值：
    被移除元素的数量。
    因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。

实例：

127.0.0.1:6379> lpush l3 1 2 3 5 3 2 1 6 7
(integer) 9
127.0.0.1:6379> lrange l3 0 -1
1) "7"
2) "6"
3) "1"
4) "2"
5) "3"
6) "5"
7) "3"
8) "2"
9) "1"
127.0.0.1:6379> lrem l3 1 6 #移除从列表尾部到表头数字6
(integer) 1
127.0.0.1:6379> lrange l3 0 -1 
1) "7"
2) "1"
3) "2"
4) "3"
5) "5"
6) "3"
7) "2"
8) "1"

127.0.0.1:6379> lrem l3 1 2 #移除从表头到表尾为数字2
(integer) 1
127.0.0.1:6379> lrange l3 0 -1
1) "7"
2) "1"
3) "3"
4) "5"
5) "3"
6) "2"
7) "1"
127.0.0.1:6379> 

127.0.0.1:6379> lrem l3 0 3 #移除列表中所有为数字3的值
(integer) 2
127.0.0.1:6379> lrange l3 0 -1
1) "7"
2) "1"
3) "5"
4) "2"
5) "1"
127.0.0.1:6379> 

9、LSET key index value

将列表 key 下标为 index 的元素的值设置为 value 。

当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。

返回值：
    操作成功返回 ok ，否则返回错误信息。

实例：

127.0.0.1:6379> lrange l3 0 -1
1) "7"
2) "1"
3) "5"
4) "2"
5) "1"
127.0.0.1:6379> lset l3 1 dog #将索引为1对应的值设置为dog
OK
127.0.0.1:6379> lrange l3 0 -1
1) "7"
2) "dog"
3) "5"
4) "2"
5) "1"
127.0.0.1:6379> 

10、LLEN key

返回列表 key 的长度。

如果 key 不存在，则 key 被解释为一个空列表，返回 0 .

如果 key 不是列表类型，返回一个错误。

返回值：
    列表 key 的长度

实例：

127.0.0.1:6379> lrange l1 0 -1
1) "straw"
2) "pear"
3) "apple"
127.0.0.1:6379> llen l1
(integer) 3

11、BLPOP key [key ...] timeout

给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。

当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。

实例：

当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。

当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素

127.0.0.1:6379> lpush l4 1 2 3
(integer) 3
127.0.0.1:6379> lpush l5 4 5 6
(integer) 3
127.0.0.1:6379> blpop l4 l5 0 #如果l4没有元素弹出l5元素
1) "l4" #弹出元素的列表
2) "3" #弹出元素的值

###参数timeout使用

127.0.0.1:6379> del l4 #空列表l4
(integer) 1
127.0.0.1:6379> lrange l4 0 -1
(empty list or set)
127.0.0.1:6379> blpop l4 10 #等待

##重启一个客户端向列表l4加入值
127.0.0.1:6379> lrange l4 0 -1
(empty list or set)
127.0.0.1:6379> lpush l4 1 2
(integer) 2

####此时等待的地方就会获取值

列表中的其他命令是列表从右操作，与从左操作类似：

RPOP key
#移除并返回列表 key 的尾元素。

RPOPLPUSH source destination 
#将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。
#将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素

RPUSH key value [value ...]
#将一个或多个值 value 插入到列表 key 的表尾(最右边)。
#如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾，比如一个空列表list1执行RPUSH list1 1 2 3 其结果列表为 1 2 3
#如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作

RPUSHX key value
#将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。
#和 RPUSH 命令相反，当 key 不存在时， RPUSHX 命令什么也不做。

BRPOP key [key ...] timeout
#当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
#当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。

BRPOPLPUSH source destination timeout
#当列表 source 为空时， BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行 LPUSH 或 RPUSH 命令为止。
#超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。

 四、Set（集合）操作

Set集合就是不允许重复的列表

1、SADD key member [member ...]

将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。

假如 key 不存在，则创建一个只包含 member 元素作成员的集合。

当 key 不是集合类型时，返回一个错误。

返回值:
    被添加到集合中的新元素的数量，不包括被忽略的元素。

实例：

127.0.0.1:6379> sadd s1 a b c
(integer) 3
127.0.0.1:6379> sadd s1 a #添加重复元素
(integer) 0
127.0.0.1:6379> smembers s1 #获取所有集合中的元素
1) "b"
2) "c"
3) "a"

2、SCARD key

返回集合 key 的基数(集合中元素的数量)。

返回值：
    集合的基数。
    当 key 不存在时，返回 0 。

实例：

127.0.0.1:6379> sadd s2 a b c
(integer) 3
127.0.0.1:6379> scard s2 #集合元素的基数
(integer) 3
127.0.0.1:6379> scard s3 #集合不存在
(integer) 0

3、SDIFF key [key ...]

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

不存在的 key 被视为空集

实例：

127.0.0.1:6379> sadd s4 1 2 5 6
(integer) 4
127.0.0.1:6379> sadd s5 1 5 9 8
(integer) 4
127.0.0.1:6379> sdiff s4 s5 #返回在s4中存在且不在s5中存在的集合元素
1) "2"
2) "6"

4、SDIFFSTORE destination key [key ...]

这个命令的作用和 SDIFF 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。

如果 destination 集合已经存在，则将其覆盖。

destination 可以是 key 本身。

返回值：
    结果集中的元素数量。

实例：

127.0.0.1:6379> sadd s4 1 2 5 6
(integer) 4
127.0.0.1:6379> sadd s5 1 5 9 8
(integer) 4
#将结果存储在集合stv1中
127.0.0.1:6379> sdiffstore stv1 s4 s5
(integer) 2
127.0.0.1:6379> smembers stv1
1) "2"
2) "6"

5、SINTER key [key ...]

返回交集成员的列表。

当给定集合当中有一个空集时，结果也为空集。

实例：

127.0.0.1:6379> smembers s4
1) "1"
2) "2"
3) "5"
4) "6"
127.0.0.1:6379> smembers s5
1) "1"
2) "5"
3) "8"
4) "9"
127.0.0.1:6379> sinter s4 s5 #返回交集集合
1) "1"
2) "5"

6、SINTERSTORE destination key [key ...]

这个命令类似于 SINTER 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。

如果 destination 集合已经存在，则将其覆盖。

destination 可以是 key 本身。

返回值:
    结果集中的成员数量。

实例：

127.0.0.1:6379> smembers s4
1) "1"
2) "2"
3) "5"
4) "6"
127.0.0.1:6379> smembers s5
1) "1"
2) "5"
3) "8"
4) "9"
#将结果保存在stv2集合中
127.0.0.1:6379> sinterstore stv2 s4 s5
(integer) 2
127.0.0.1:6379> smembers stv2
1) "1"
2) "5"

7、SISMEMBER key member

判断 member 元素是否集合 key 的成员。

返回值:
    如果 member 元素是集合的成员，返回 1 。
    如果 member 元素不是集合的成员，或 key 不存在，返回 0 。

实例：

127.0.0.1:6379> smembers s4
1) "1"
2) "2"
3) "5"
4) "6"
#元素2是集合s4中的元素
127.0.0.1:6379> sismember s4 2
(integer) 1
#元素7不是集合s4中的元素
127.0.0.1:6379> sismember s4 7
(integer) 0
127.0.0.1:6379> 

8、SMEMBERS key

返回集合 key 中的所有成员。

不存在的 key 被视为空集合。

实例：

#不存在的集合，smembers为空
127.0.0.1:6379> exists s6
(integer) 0
127.0.0.1:6379> smembers s6
(empty list or set)

#存在的集合显示所有成员
127.0.0.1:6379> exists s4
(integer) 1
127.0.0.1:6379> smembers s4
1) "1"
2) "2"
3) "5"
4) "6"

9、SMOVE source destination member

将 member 元素从 source 集合移动到 destination 集合。

如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。

当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。

返回值：
    如果 member 元素被成功移除，返回 1 。
    如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 0 。

实例：

127.0.0.1:6379> smembers s4
1) "1"
2) "2"
3) "5"
4) "6"
127.0.0.1:6379> smembers s5
1) "1"
2) "5"
3) "8"
4) "9"
#将s4中的元素6移动到s5中，s4中的元素被移除
127.0.0.1:6379> smove s4 s5 6
(integer) 1
127.0.0.1:6379> smembers s4
1) "1"
2) "2"
3) "5"
127.0.0.1:6379> smembers s5
1) "1"
2) "5"
3) "6"
4) "8"
5) "9"

10、SPOP key [COUNT]

移除并返回集合中的COUNT个随机元素。

返回值:
    被移除的随机元素。
    当 key 不存在或 key 是空集时，返回 nil 。

实例：

127.0.0.1:6379> smembers s5
1) "1"
2) "5"
3) "6"
4) "8"
5) "9"
#随机移除3个元素
127.0.0.1:6379> spop s5 3
1) "6"
2) "1"
3) "9"
#查看剩余元素
127.0.0.1:6379> smembers s5 
1) "5"
2) "8"

11、SRANDMEMBER key [count]

该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 SRANDMEMBER 则仅仅返回随机元素，而不对集合进行任何改动。

实例：

127.0.0.1:6379> sadd s7 1 2 3 4 5 6
(integer) 6

#返回随机三个元素，但集合并没有修改
127.0.0.1:6379> srandmember s7 3
1) "3"
2) "5"
3) "6"
127.0.0.1:6379> smembers s7
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"

12、SREM key member [member ...]

移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。

返回值:
    被成功移除的元素的数量，不包括被忽略的元素。

实例：

127.0.0.1:6379> smembers s7
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
#移除单个或者多个元素
127.0.0.1:6379> srem s7 3 4
(integer) 2
#移除不存在的元素，返回0
127.0.0.1:6379> srem s7 10
(integer) 0

13、SUNION key [key ...]

返回一个集合的全部成员，该集合是所有给定集合的并集。

不存在的 key 被视为空集。

返回值:
    并集成员的列表。

实例：

127.0.0.1:6379> smembers s7
1) "1"
2) "2"
3) "5"
4) "6"
127.0.0.1:6379> smembers s5 
1) "5"
2) "8"
#返回两个集合的并集
127.0.0.1:6379> sunion s7 s5
1) "1"
2) "2"
3) "5"
4) "6"
5) "8"

14、SUNIONSTORE destination key [key ...]

这个命令类似于 SUNION 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。

如果 destination 已经存在，则将其覆盖。

destination 可以是 key 本身。

返回值:
    结果集中的元素数量。

实例：

127.0.0.1:6379> smembers s7
1) "1"
2) "2"
3) "5"
4) "6"
127.0.0.1:6379> smembers s5 
1) "5"
2) "8"
#将并集的元素存储到stv3集合中
127.0.0.1:6379> sunionstore stv3 s5 s7
(integer) 5
127.0.0.1:6379> smembers stv3
1) "1"
2) "2"
3) "5"
4) "6"
5) "8"

15、SSCAN key cursor [MATCH pattern] [COUNT count]

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

五、SortedSet（有序集合）操作

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

1、ZADD key score member [[score member] [score member] ...]

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。

#添加多个元素
127.0.0.1:6379> zadd z1  2 pear 6 straw 3 apple 
(integer) 3
127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "apple"
4) "3"
5) "straw"
6) "6"

2、ZCARD key

返回有序集 key 的基数。

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "apple"
4) "3"
5) "straw"
6) "6"
127.0.0.1:6379> zcard z1
(integer) 3

3、ZCOUNT key min max

返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。

返回值：
　　score 值在 min 和 max 之间的成员的数量。

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "apple"
4) "3"
5) "straw"
6) "6"
127.0.0.1:6379> zcount z1 3 6 #计算权重在3-6（包括3和6）的元素
(integer) 2

4、ZINCRBY key increment member

为有序集 key 的成员 member 的 score 值加上增量 increment 。

increment可以为负数、浮点数

当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。

返回值：
    member 成员的新 score 值，以字符串形式表示。

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "apple"
4) "3"
5) "straw"
6) "6"

#给权重加值
127.0.0.1:6379> zincrby z1 4 apple
"7"
#重新进行排序
127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "straw"
4) "6"
5) "apple"
6) "7"

5、ZRANGE key start stop [WITHSCORES]

返回有序集 key 中，指定区间内的成员。

其中成员的位置按 score 值递增(从小到大)来排序。

参数：
　　start：表示下标，从0开始，表示第一个元素
　　stop:表示下标
　　也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "straw"
4) "6"
5) "apple"
6) "7"

127.0.0.1:6379> zrange z1 1 3
1) "straw"
2) "apple"

6、ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。

LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "straw"
4) "6"
5) "apple"
6) "7"
#数据是在score [6,7]范围内
127.0.0.1:6379> zrangebyscore z1 6 7 
1) "straw"
2) "apple"
#小于score=6的所有元素
127.0.0.1:6379> zrangebyscore z1 -inf 6
1) "pear"
2) "straw"

#limit是对结果的筛选，limit是从结果集索引位置向后取值
127.0.0.1:6379> zrangebyscore z1 2 7 withscores
1) "pear"
2) "2"
3) "straw"
4) "6"
5) "apple"
6) "7"

127.0.0.1:6379> zrangebyscore z1 2 7 withscores limit 1 1
1) "straw"
2) "6"
127.0.0.1:6379> zrangebyscore z1 2 7 withscores limit 0 1
1) "pear"
2) "2"
127.0.0.1:6379> zrangebyscore z1 2 7 withscores limit 0 2
1) "pear"
2) "2"
3) "straw"
4) "6"

7、ZRANK key member

返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。

排名以 0 为底，也就是说， score 值最小的成员排名为 0 。

返回值：
    如果 member 是有序集 key 的成员，返回 member 的排名。
    如果 member 不是有序集 key 的成员，返回 nil 。

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "straw"
4) "6"
5) "apple"
6) "7"
#获取排名，排名是从0开始的
127.0.0.1:6379> zrank z1 apple
(integer) 2

8、ZREM key member [member ...]

移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "straw"
4) "6"
5) "apple"
6) "7"
127.0.0.1:6379> zrem z1 apple #移除元素
(integer) 1
127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "straw"
4) "6"

9、ZREMRANGEBYRANK key start stop

移除有序集 key 中，指定排名(rank)区间内的所有成员。

区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。

下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。也可以使用负数下标，以 -1 表示最后一个成员， 
-2 表示倒数第二个成员，以此类推。

返回值：
    被移除成员的数量。

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "apple"
4) "3"
5) "peach"
6) "5"
7) "straw"
8) "6"
127.0.0.1:6379> zremrangebyrank z1 -3 -1 #删除指定索引区间的元素
(integer) 3
127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"

10、ZREMRANGEBYSCORE key min max

移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。

返回值：
    被移除成员的数量。

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "apple"
4) "3"
5) "peach"
6) "5"
7) "straw"
8) "6"
127.0.0.1:6379> zremrangebyscore z1 3 5 #删除指定权重区间（包括两段）的集合元素
(integer) 2
127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "straw"
4) "6"

11、ZREVRANGE key start stop [WITHSCORES]

返回有序集 key 中，指定区间内的成员。

其中成员的位置按 score 值递减(从大到小)来排列。

参数：
　　start,stop表示有序集合中元素的索引值，正数是从0开始，负数是从-1开始

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "apple"
4) "3"
5) "peach"
6) "5"
7) "straw"
8) "6"
127.0.0.1:6379> zrevrange z1 0 3 #获取对应索引区间的元素值
1) "straw"
2) "peach"
3) "apple"
4) "pear"

12、ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]

返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。

返回值:
    指定区间内，带有 score 值(可选)的有序集成员的列表。

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "apple"
4) "3"
5) "peach"
6) "5"
7) "straw"
8) "6"
#返回相应权重范围的元素
127.0.0.1:6379> zrevrangebyscore z1 5 2 withscores
1) "peach"
2) "5"
3) "apple"
4) "3"
5) "pear"
6) "2"

13、ZREVRANK key member

返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。

排名以 0 为底，也就是说， score 值最大的成员排名为 0 。

返回值:
    如果 member 是有序集 key 的成员，返回 member 的排名。
    如果 member 不是有序集 key 的成员，返回 nil 。

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "apple"
4) "3"
5) "peach"
6) "5"
7) "straw"
8) "6"
127.0.0.1:6379> zrevrank z1 peach
(integer) 1

14、ZSCORE key member

返回有序集 key 中，成员 member 的 score 值。

如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。

127.0.0.1:6379> zrange z1 0 -1 withscores
1) "pear"
2) "2"
3) "apple"
4) "3"
5) "peach"
6) "5"
7) "straw"
8) "6"
127.0.0.1:6379> zscore z1 apple
"3"

15、ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。

默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。

参数：
　　WEIGHTS:每一个集合元素权重score的乘法因子,如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。
　　AGGREGATE :并集的结果集的聚合方式,默认使用的参数 SUM 

返回值:
    保存到 destination 的结果集的基数。

127.0.0.1:6379> zadd z2 2 a 5 b
(integer) 2
127.0.0.1:6379> zadd z3 1 c 6 d
(integer) 2

#将两个有序集合并集的结果存储到zstov1中，并且将z2的weights乘以1，z3的weights乘以2
127.0.0.1:6379> zunionstore zstov1 2 z2 z3 weights 1 2 
(integer) 4

127.0.0.1:6379> zrange zstov1 0 -1 withscores
1) "a"
2) "2"
3) "c"
4) "2"
5) "b"
6) "5"
7) "d"
8) "12"
127.0.0.1:6379> 

16、ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。

默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.

127.0.0.1:6379> zrange z2 0 -1 withscores
1) "a"
2) "2"
3) "b"
4) "5"

127.0.0.1:6379> zrange z3 0 -1 withscores
1) "c"
2) "1"
3) "d"
4) "6"
5) "b"
6) "7"
#将z2 z3交集的元素进行存储到zstore2中
127.0.0.1:6379> zinterstore zstov2 2 z2 z3 
(integer) 1

127.0.0.1:6379> zrange zstov2 0 -1 withscores
1) "b"
2) "12"

17、ZSCAN key cursor [MATCH pattern] [COUNT count]

参考redis的字符串操作的scan方法

 六、发布/订阅

发送者（发送信息的客户端）不是将信息直接发送给特定的接收者（接收信息的客户端）， 而是将信息发送给频道（channel）， 然后由频道将信息转发给所有对这个频道感兴趣的订阅者。

发送者无须知道任何关于订阅者的信息， 而订阅者也无须知道是那个客户端给它发送信息， 它只要关注自己感兴趣的频道即可。

当有客户端发送信息到这些频道时， Redis 会将传入的信息推送到所有订阅这些频道的客户端里面。

import redis


class RedisHelper:
    def __init__(self):
        self.__conn = redis.Redis(host='192.168.0.104',password="bright123")#连接redis
        self.chan_sub = 'fm96.5' #接受者接收频道
        self.chan_pub = 'fm96.5' #发布者指定的频道

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg)#将信息发送到指定的频道
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()
        pub.subscribe(self.chan_sub)#订阅频道
        pub.parse_response()
        return pub

调用以上写好类的方法：

在public.py文件中

from RedisHelper import RedisHelper

obj = RedisHelper()
obj.public('publish success!') #向指定频道发送消息

在scbscribe.py文件中

from RedisHelper import RedisHelper

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response() #接收对应频道中的消息
    print(msg)

参考：http://doc.redisfans.com/