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"

SET

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)

SETEX

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"   # 没有被覆盖

SETNX

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)

PSETEX

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 ""
OK
127.0.0.1:6379> mget date time
1) "2019.2.1"
2) ""
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> 

MSET

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
"\x00\x00\x00sh"
127.0.0.1:6379> 

SETRANGE

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就是在此基础上进行操作的，

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> 

STRLEN

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
""     # 数字值在 Redis 中以字符串的形式保存
127.0.0.1:6379> 

INCR

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
""

#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
""

#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> 

INCRBY

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"

INCRBYFLOAT

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

CR

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

DECRBY

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
""

APPEND

二、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> 

HSET

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> 

HSETNX

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)

HGET

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"

HGETALL

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

HLEN

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
""

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

HINCRBY

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"

HINCRBYFLOAT

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> 

HMSET

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) ""
2) "boy"

HMGET

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)

HDEL

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

HEXISTS

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"

HVALS

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"

HKEYS

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) ""
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) ""
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) ""
2) 1) "xiaoming"
   2) "name"
   3) "name2"
127.0.0.1:6379> 

SCAN

三、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

LPUSH

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

LPUSHX

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

LINSERT

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"

LRANGE

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

LTRIM

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) ""
2) "dog"
3) ""
4) ""
127.0.0.1:6379> lindex l3 1 #索引在返回内
"dog"
127.0.0.1:6379> lindex l3 10 #索引超出范围
(nil)

LINDEX

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)

LPOP

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

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

LREM

9、LSET key index value

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

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

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

实例：

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

LSET

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

LLEN

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) "" #弹出元素的值

###参数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

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

BLPOP

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

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"

SADD

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

SCARD

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

SDIFF

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

SDIFFSTORE

5、SINTER key [key ...]

返回交集成员的列表。

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

实例：

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

SINTER

6、SINTERSTORE destination key [key ...]

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

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

destination 可以是 key 本身。

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

实例：

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

SINTERSTORE

7、SISMEMBER key member

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

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

实例：

127.0.0.1:6379> smembers s4
1) ""
2) ""
3) ""
4) ""
#元素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> 

SISMEMBER

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) ""
2) ""
3) ""
4) ""

SMEMBERS

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) ""
2) ""
3) ""
4) ""
127.0.0.1:6379> smembers s5
1) ""
2) ""
3) ""
4) ""
#将s4中的元素6移动到s5中，s4中的元素被移除
127.0.0.1:6379> smove s4 s5 6
(integer) 1
127.0.0.1:6379> smembers s4
1) ""
2) ""
3) ""
127.0.0.1:6379> smembers s5
1) ""
2) ""
3) ""
4) ""
5) ""

SMOVE

10、SPOP key [COUNT]

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

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

实例：

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

SPOP

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) ""
2) ""
3) ""
127.0.0.1:6379> smembers s7
1) ""
2) ""
3) ""
4) ""
5) ""
6) ""

SRANDMEMBER

12、SREM key member [member ...]

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

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

实例：

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

SREM

13、SUNION key [key ...]

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

不存在的 key 被视为空集。

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

实例：

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

SUNION

14、SUNIONSTORE destination key [key ...]

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

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

destination 可以是 key 本身。

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

实例：

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

SUNIONSTORE

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) ""
3) "apple"
4) ""
5) "straw"
6) ""

ZADD

2、ZCARD key

返回有序集 key 的基数。

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

ZCARD

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) ""
3) "apple"
4) ""
5) "straw"
6) ""
127.0.0.1:6379> zcount z1 3 6 #计算权重在3-6（包括3和6）的元素
(integer) 2

ZCOUNT

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) ""
3) "apple"
4) ""
5) "straw"
6) ""

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

ZINCRBY

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) ""
3) "straw"
4) ""
5) "apple"
6) ""

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

ZRANGE

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) ""
3) "straw"
4) ""
5) "apple"
6) ""
#数据是在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) ""
3) "straw"
4) ""
5) "apple"
6) ""

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

ZRANGEBYSCORE

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) ""
3) "straw"
4) ""
5) "apple"
6) ""
#获取排名，排名是从0开始的
127.0.0.1:6379> zrank z1 apple
(integer) 2

ZRANK

8、ZREM key member [member ...]

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

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

ZREM

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

ZREMRANGEBYRANK

10、ZREMRANGEBYSCORE key min max

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

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

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

ZREMRANGEBYSCORE

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

ZREVRANGE

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

ZREVRANGEBYSCORE

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) ""
3) "apple"
4) ""
5) "peach"
6) ""
7) "straw"
8) ""
127.0.0.1:6379> zrevrank z1 peach
(integer) 1

ZREVRANK

14、ZSCORE key member

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

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

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

ZSCORE

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) ""
3) "c"
4) ""
5) "b"
6) ""
7) "d"
8) ""
127.0.0.1:6379> 

ZUNIONSTORE

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) ""
3) "b"
4) ""

127.0.0.1:6379> zrange z3 0 -1 withscores
1) "c"
2) ""
3) "d"
4) ""
5) "b"
6) ""
#将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) ""

ZINTERSTORE

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

RedisHelper

调用以上写好类的方法：

在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/