redis基本使用

╰+哭是因爲堅強的太久メ 2021-06-24 13:58 416阅读 0赞

### redis基本使用 ###

*  Redis简介
 *   *  Redis 优点
 *  Redis的安装和配置
 *   *  Redis 的配置
 *  Redis持久化
 *   *  RDB
     *  AOF
 *  Redis的服务器和客户端
 *  redis基本命令
 *  字符串
 *   *  SET
     *  GET
     *  SETNX
     *  SETEX
     *  MSET
     *  MGET
     *  STRLEN
     *  INCR
     *  INCRBY
     *  DECR
     *  DECRBY
 *  哈希表
 *   *  HSET
     *  HGET
     *  HMSET
     *  HMGET
     *  HKEYS
     *  HVALS
     *  HGETALL
     *  HDEL
 *  列表
 *   *  LPUSH
     *  RPUSH
     *  LPUSHX
     *  LPOP
     *  RPOP
     *  LRANGE
     *  LINDEX
     *  LLEN
     *  LSET
 *  集合
 *   *  SADD
     *  SISMEMBER
     *  SPOP
     *  SRANDMEMBER
     *  SMEMBERS
     *  SUNION
     *  SDIFF
 *  python操作redis

# Redis简介 #

Redis 是一种基于键值对的NoSQL数据库，它提供了对多种数据类型（字符串、哈希、列表、集合、有序集合、位图等）的支持，能够满足很多应用场景的需求。Redis将数据放在内存中，因此读写性能是非常惊人的。与此同时，Redis也提供了持久化机制，能够将内存中的数据保存到硬盘上，在发生意外状况时数据也不会丢掉。此外，Redis还支持键过期、地理信息运算、发布订阅、事务、管道、Lua脚本扩展等功能，总而言之，Redis的功能和性能都非常强大，如果项目中要实现高速缓存和消息队列这样的服务，直接交给Redis就可以了

## Redis 优点 ##

edis的读写性能极高，并且有丰富的特性（发布/订阅、事务、通知等）。
    
    Redis支持数据的持久化（RDB和AOF两种方式），可以将内存中的数据保存在磁盘
    中，重启的时候可以再次加载进行使用。
    
    Redis支持多种数据类型，包括：string、hash、list、set，zset、bitmap、
    hyperloglog等。
    
    Redis支持主从复制（实现读写分离）以及哨兵模式（监控master是否宕机并自动调
    整配置）
    。
    Redis支持分布式集群，可以很容易的通过水平扩展来提升系统的整体性能
    
    Redis基于TCP提供的可靠传输服务进行通信，很多编程语言都提供了Redis客户端支
    持。

# Redis的安装和配置 #

1.可以使用apt或者yum在线安装
    
    2. 
    wget https://download.redis.io/releases/redis-6.0.10.tar.gz
    tar xzf redis-6.0.10.tar.gz
    cd redis-6.0.10
    make

## Redis 的配置 ##

在 redis 源代码目录下有一个名为redis.conf的配置文件，我们可以先查看一下该文件: vim redis.conf

配置将 Redis 服务绑定到指定的IP地址和端口

bind 127.0.0.1 #只允许本机登录
    port 6379  #端口号

设置后台运行 (以守护进程方式运行)

daemonize yes

设置日志级别, 可选值: (debug: 调试, verbose: 详细, notice: 通知, warning: 警告)

loglevel warning

配置数据库的数量, 默认为 16 个

databases 16

配置数据写入规则

save 900 1     # 900 秒 (15 分钟) 内修改过 1 个 key, , 写入一次数据库
    save 300 10    # 300 秒 (5 分钟) 内修改过 10 个 key, 写入一次数据库
    save 60 10000  # 60 秒 (1 分钟) 内修改过 10000 个 key, 写入一次数据库

配置慢查询

slowlog-log-slower-than 10000  # 一次操作超过 10000 毫秒被视作一次慢查询
    slowlog-max-len 128            # 最多纪录 128 次满查询

# Redis持久化 #

Redis在运行时，所有的数据都保存在内存里，进程结束以后，会将数据写入到硬盘
    中。启动时，会读取硬盘里的内容，并将内容全部加载到内存中(会大量的占用内
    存)。
    
    Redis的持久化有两种形式:RDB和AOF

## RDB ##

默认的持久化方式，是对内存中的数据进行镜像，并以二进制的形式保存到dump.rdb文件中。会根据配置文件的时间节点对文件进行持久化。

save 900 1
    save 300 10
    save 60 10000

优点:速度快，直接镜像内存里的数据，文件小。

缺点:数据有可能会丢失，在两次保存间隔内的数据，有可能会丢失。

## AOF ##

AOF(Append only file)持久化，将修改的每一条指令记录进appendonly.aof中，需要修改配置文件，来打开aof功能。

appendfsync always：每次有新命令追加到aof文件时就执行一个持久化，非常慢但是安全
    
    appendfsync everysec：每秒执行一次持久化，足够快（和使用rdb持久化差不多）并且在故障时只会丢失1秒钟的数据
    
    appendfsync no：从不持久化，将数据交给操作系统来处理。redis处理命令速度加快但是不安全。

优点:适合保存增量数据，数据不丢失。

缺点:文件体积大，恢复时间长

# Redis的服务器和客户端 #

接下来启动 Redis 服务器，下面的方式将以指定的配置文件启动 Redis 服务。

redis-server redis.conf

接下来用 Redis 客户端去连接服务器。

redis-cli -h localhost -p 6379

注意如果是6.0的版本开启客户端的时候要 先输入密码，否则会报错，

(error) NOAUTH Authentication required.

输入密码

auth 密码

# redis基本命令 #

[redis参考命令][redis]

# 字符串 #

## SET ##

SET key value [EX seconds] [PX milliseconds] [NX|XX]
    
    将字符串值 value 关联到 key 。
    
    如果 key 已经持有其他值， SET 就覆写旧值， 无视类型。
    
    当 SET 命令对一个带有生存时间（TTL）的键进行设置之后， 该键原有的 TTL 将被清除。
    
    EX代表秒 PX代表毫秒
    EX seconds ： 将键的过期时间设置为 seconds 秒
    PX milliseconds ： 将键的过期时间设置为 milliseconds 毫秒

redis> SET name dyk
    OK
    
    redis> GET name
    "dyk"

redis> SET name cb ex 10
    OK
    
    redis> ttl name
    (integer) 8   #还剩8秒
    
    redis> GET name
    "dyk"
    
    redis> GET name
    (nil)  #到期

## GET ##

返回与键 key 相关联的字符串值

GET key
    
    如果键 key 不存在， 那么返回特殊值 nil ； 否则， 返回键 key 的值。
    
    如果键 key 的值并非字符串类型， 那么返回一个错误， 因为 GET 命令只能用于字符串值。

对不存在的键 key 或是字符串类型的键 key 执行 GET 命令：

redis> GET db
    (nil)
    
    redis> SET db redis
    OK
    
    redis> GET db
    "redis"

## SETNX ##

SETNX key value
    
    只在键 key 不存在的情况下， 将键 key 的值设置为 value 。
    
    若键 key 已经存在， 则 SETNX 命令不做任何动作。
    
    SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写
    
    返回值
    命令在设置成功时返回 1 ， 设置失败时返回 0

redis> EXISTS job                # job 不存在
    (integer) 0
    
    redis> SETNX job "programmer"    # job 设置成功
    (integer) 1
    
    redis> SETNX job "code-farmer"   # 尝试覆盖 job ，失败
    (integer) 0
    
    redis> GET job                   # 没有被覆盖
    "programmer"

## SETEX ##

SETEX key seconds value
    
    将键 key 的值设置为 value ， 并将键 key 的生存时间设置为 seconds 秒钟。
    
    如果键 key 已经存在， 那么 SETEX 命令将覆盖已有的值。
    
    SETEX 命令的效果和以下两个命令的效果类似：
    SET key value
    EXPIRE key seconds  # 设置生存时间
    
    SETEX 和这两个命令的不同之处在于 SETEX 是一个原子（atomic）操作， 它可以在
    同一时间内完成设置值和设置过期时间这两个操作， 因此 SETEX 命令在储存缓存的
    时候非常实用
    
    如果不设置剩余时间默认是(integer) -1，表示永远不会过期
    
    返回值
    命令在设置成功时返回 OK 。 
    当 seconds 参数不合法时， 命令将返回一个错误

在键 key 不存在的情况下执行 SETEX ：

redis> SETEX cache_user_id 60 10086
    OK
    
    redis> GET cache_user_id  # 值
    "10086"
    
    redis> TTL cache_user_id  # 剩余生存时间
    (integer) 49

键 key 已经存在， 使用 SETEX 覆盖旧值：

redis> SET cd "timeless"
    OK
    
    redis> SETEX cd 3000 "goodbye my love"
    OK
    
    redis> GET cd
    "goodbye my love"
    
    redis> TTL cd
    (integer) 2997

## MSET ##

同时为多个键设置值

MSET key value [key value …]
    
    如果某个给定键已经存在， 那么 MSET 将使用新值去覆盖旧值， 如果这不是你所希
    望的效果， 请考虑使用 MSETNX 命令， 这个命令只会在所有给定键都不存在的情况
    下进行设置
    
    MSET 是一个原子性(atomic)操作， 所有给定键都会在同一时间内被设置， 不会出
    现某些键被设置了但是另一些键没有被设置的情况。
    
    返回值
    MSET 命令总是返回 OK

同时对多个键进行设置：

redis> MSET name "dyk" age 18 
    OK
    
    redis> MGET  name age
    1) "dyk"
    2) "18"

覆盖已有的值：

redis> MGET  name age
    1) "dyk"
    2) "18"
    
    redis> mset name cb age 20
    OK
    redis> mget name age
    1) "cb"
    2) "20"

## MGET ##

返回给定的一个或多个字符串键的值。

MGET key [key …]
    
    如果给定的字符串键里面， 有某个键不存在， 那么这个键的值将以特殊值 nil 表
    示
    
    返回值
    MGET 命令将返回一个列表， 列表中包含了所有给定键的值

## STRLEN ##

返回键 key 储存的字符串值的长度

返回值
    STRLEN 命令返回字符串值的长度。
    
    当键 key 不存在时， 命令返回 0 。
    
    当 key 储存的不是字符串值时， 返回一个错误

获取字符串值的长度：

redis> SET name dyk
    OK
    
    redis> GET name
    "dyk"
    
    redis> STRLEN name
    (integer) 3

不存在的键的长度为 0

redis> STRLEN height #height 不存在
    (integer) 0

## INCR ##

为键 key 储存的数字值加上一

INCR key
    
    如果键 key 不存在， 那么它的值会先被初始化为 0 ， 然后再执行 INCR 命令。
    
    如果键 key 储存的值不能被解释为数字， 那么 INCR 命令将返回一个错误。
    
    本操作的值限制在 64 位(bit)有符号数字表示之内。
    
    返回值
    INCR 命令会返回键 key 在执行加一操作之后的值

redis> SET a 10
    OK
    
    redis> INCR a
    (integer) 11
    
    redis> GET a   # 数字值在 Redis 中以字符串的形式保存
    "11"

## INCRBY ##

INCRBY key increment
    
    为键 key 储存的数字值加上增量 increment 。
    
    如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 INCRBY 命令。
    
    如果键 key 储存的值不能被解释为数字， 那么 INCRBY 命令将返回一个错误。
    
    返回值
    在加上增量 increment 之后， 键 key 当前的值。

键存在，并且值为数字：

redis> SET rank 50
    OK
    
    redis> INCRBY rank 20
    (integer) 70
    
    redis> GET rank
    "70"

键不存在：

redis> EXISTS counter
    (integer) 0
    
    redis> INCRBY counter 30
    (integer) 30
    
    redis> GET counter
    "30"

键存在，但值无法被解释为数字：

redis> SET book "long long ago..."
    OK
    
    redis> INCRBY book 200
    (error) ERR value is not an integer or out of range

## DECR ##

为键 key 储存的数字值减去一

如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 DECR 操作。
    
    如果键 key 储存的值不能被解释为数字， 那么 DECR 命令将返回一个错误
    
    返回值
    DECR 命令会返回键 key 在执行减一操作之后的值。

对储存数字值的键 key 执行 DECR 命令

redis> SET a 10
    OK
    
    redis> DECR a
    (integer) 9

对不存在的键执行 DECR 命令：

redis> EXISTS count
    (integer) 0
    
    redis> DECR count
    (integer) -1

## DECRBY ##

将键 key 储存的整数值减去减量 decrement

DECRBY key decrement
    
    如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 DECRBY 命令。
    
    如果键 key 储存的值不能被解释为数字， 那么 DECRBY 命令将返回一个错误
    
    返回值
    DECRBY 命令会返回键在执行减法操作之后的值

对已经存在的键执行 DECRBY 命令

redis> SET count 100
    OK
    
    redis> DECRBY count 20
    (integer) 80

对不存在的键执行 DECRBY 命令

redis> EXISTS pages
    (integer) 0
    
    redis> DECRBY pages 10
    (integer) -10

# 哈希表 #

## HSET ##

HSET hash field value
    
    将哈希表 hash 中域 field 的值设置为 value 。
    
    如果给定的哈希表并不存在， 那么一个新的哈希表将被创建并执行 HSET 操作。
    
    如果域 field 已经存在于哈希表中， 那么它的旧值将被新值 value 覆盖。
    
    返回值
    当 HSET 命令在哈希表中新创建 field 域并成功为它设置值时， 命令返回 1 ； 
    如果域 field 已经存在于哈希表， 并且 HSET 命令成功使用新值覆盖了它的旧值，
     那么命令返回 0

设置一个新域

redis> hset student name dyk
    (integer) 1
    
    redis> hget student name
    "dyk"

对一个已存在的域进行更新：

redis> hset student name cb
    (integer) 0
    
    redis> hget student name
    "cb"

## HGET ##

返回哈希表中给定域的值。

HGET 命令在默认情况下返回给定域的值。
    
    如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil

域存在的情况：

redis> HSET homepage redis redis.com
    (integer) 1
    
    redis> HGET homepage redis
    "redis.com"

域不存在的情况：

redis> HGET site mysql
    (nil)

## HMSET ##

同时将多个 field-value (域-值)对设置到哈希表 key 中

HMSET key field value [field value …]
    
    此命令会覆盖哈希表中已存在的域。
    
    如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
    
    返回值：
    如果命令执行成功，返回 OK 。
    当 key 不是哈希表(hash)类型时，返回一个错误

redis> hmset student name "dyk" age 18 id 1
    OK
    redis> hmget student name age id
    1) "dyk"
    2) "18"
    3) "1"

## HMGET ##

HMGET key field [field …]
    
    返回哈希表 key 中，一个或多个给定域的值。
    
    如果给定的域不存在于哈希表，那么返回一个 nil 值。
    
    因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
    
    返回值：
    一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。

```python
    redis> hmset student name "dyk" age 18 id 1
    OK
    redis> hmget student name age id
    1) "dyk"
    2) "18"
    3) "1"

## HKEYS ##

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

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

哈希表非空

redis> hkeys student
    1) "name"
    2) "age"
    3) "id"

空哈希表/key不存在

redis> EXISTS fake_key
    (integer) 0
    
    redis> HKEYS fake_key
    (empty list or set)

## HVALS ##

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

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

非空哈希表

redis> hvals student
    1) "dyk"
    2) "18"
    3) "1"

空哈希表/不存在的key

redis> EXISTS not_exists
    (integer) 0
    
    redis> HVALS not_exists
    (empty list or set)

## HGETALL ##

HGETALL key
    
    返回哈希表 key 中，所有的域和值。
    
    在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度
    是哈希表大小的两倍。
    
    返回值：
    以列表形式返回哈希表的域和域的值。
    若 key 不存在，返回空列表

redis> hgetall student
    1) "name"  # 域
    2) "dyk"  # 值
    3) "age"
    4) "18"
    5) "id"
    6) "1"

## HDEL ##

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

HDEL key field [field …]
    
    返回值:
    被成功移除的域的数量，不包括被忽略的域

redis> hgetall student
    1) "name"  # 域
    2) "dyk"  # 值
    3) "age"
    4) "18"
    5) "id"
    6) "1"

删除单个域

redis> hdel student id
    (integer) 1

删除不存在的域

redis> HDEL abbr not-exists-field
    (integer) 0

删除多个域

redis> hdel student name age
    (integer) 2
    redis> hgetall student
    (empty array)

# 列表 #

## LPUSH ##

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

LPUSH key value [value …]
    
    如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比
    如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，
    这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 
    三个命令。
    
    如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。
    
    当 key 存在但不是列表类型时，返回一个错误。
    
    返回值
    执行 LPUSH 命令后，列表的长度

加入单个元素

redis> lpush stu dyk
    (integer) 1

加入重复元素

redis> lpush stu dyk   # 列表允许重复元素
    (integer) 2

加入多个元素

redis> lpush stu dyk lfw cb
    (integer) 5
    
    redis> lrange stu 0 -1
    1) "cb"
    2) "lfw"
    3) "dyk"
    4) "dyk"
    5) "dyk"

## RPUSH ##

将一个或多个值 value 插入到列表 key 的表尾(最右边)。
    
    如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如
    对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，等
    同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。
    
    如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。
    
    当 key 存在但不是列表类型时，返回一个错误。

## LPUSHX ##

将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。
    
    和 LPUSH key value [value …] 命令相反，当 key 不存在时， LPUSHX 命令什么也不做
    
    返回值
    LPUSHX 命令执行之后，表的长度

# 对空列表执行 LPUSHX
    
    redis> LLEN greet                       # greet 是一个空列表
    (integer) 0
    
    redis> LPUSHX greet "hello"             # 尝试 LPUSHX，失败，因为列表为空
    (integer) 0
    
    
    # 对非空列表执行 LPUSHX
    
    redis> LPUSH greet "hello"              # 先用 LPUSH 创建一个有一个元素的列表
    (integer) 1
    
    redis> LPUSHX greet "good morning"      # 这次 LPUSHX 执行成功
    (integer) 2
    
    redis> LRANGE greet 0 -1
    1) "good morning"
    2) "hello"

## LPOP ##

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

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

redis> lpop stu # 移除头元素
    "cb"

## RPOP ##

RPOP key
    移除并返回列表 key 的尾元素。
    
    返回值
    列表的尾元素。 当 key 不存在时，返回 nil 。

## LRANGE ##

LRANGE key start stop
    
    返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
    
    下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一
    个元素，以 1 表示列表的第二个元素，以此类推。
    
    你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二
    个元素，以此类推。
    
    假如你有一个包含一百个元素的列表，对该列表执行 LRANGE list 0 10 ，结果是一
    个包含11个元素的列表，这表明 stop 下标也在 LRANGE 命令的取值范围之内(闭区
    间)，这和某些语言的区间函数可能不一致，比如Ruby的 Range.new 、
     Array#slice 和Python的 range() 函数。
    
    超出范围的下标
    超出范围的下标值不会引起错误。
    
    如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，那么 LRANGE 返回一个空列表。
    
    如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。
    
    返回值
    一个列表，包含指定区间内的元素。

redis> RPUSH fp-language lisp
    (integer) 1
    
    redis> LRANGE fp-language 0 0
    1) "lisp"
    
    redis> RPUSH fp-language scheme
    (integer) 2
    
    redis> LRANGE fp-language 0 1
    1) "lisp"
    2) "scheme"

## LINDEX ##

LINDEX key index
    
    返回列表 key 中，下标为 index 的元素。
    
    下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
    
    你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
    
    如果 key 不是列表类型，返回一个错误。
    
    返回值
    列表中下标为 index 的元素。 如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。

## LLEN ##

LLEN key
    
    返回列表 key 的长度。
    
    如果 key 不存在，则 key 被解释为一个空列表，返回 0 .
    
    如果 key 不是列表类型，返回一个错误。
    
    返回值
    列表 key 的长度。

# 空列表
    
    redis> LLEN job
    (integer) 0
    
    
    # 非空列表
    
    redis> LPUSH job "cook food"
    (integer) 1
    
    redis> LPUSH job "have lunch"
    (integer) 2
    
    redis> LLEN job
    (integer) 2

## LSET ##

LSET key index value
    
    将列表 key 下标为 index 的元素的值设置为 value 。
    
    当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。
    
    关于列表下标的更多信息，请参考 LINDEX key index 命令
    
    返回值
    操作成功返回 ok ，否则返回错误信息

redis> lset stu 4 dyk123
    (error) ERR index out of range
    
    redis> lset stu 3 dyk123
    OK

# 集合 #

## SADD ##

SADD key member [member …]
    
    将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
    
    假如 key 不存在，则创建一个只包含 member 元素作成员的集合。
    
    当 key 不是集合类型时，返回一个错误。

# 添加单个元素
    
    redis> SADD bbs "discuz.net"
    (integer) 1
    
    
    # 添加重复元素
    
    redis> SADD bbs "discuz.net"
    (integer) 0
    
    
    # 添加多个元素
    
    redis> SADD bbs "tianya.cn" "groups.google.com"
    (integer) 2
    
    redis> SMEMBERS bbs
    1) "discuz.net"
    2) "groups.google.com"
    3) "tianya.cn"

## SISMEMBER ##

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

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

redis> SMEMBERS joe's_movies
    1) "hi, lady"
    2) "Fast Five"
    3) "2012"
    
    redis> SISMEMBER joe's_movies "bet man"
    (integer) 0
    
    redis> SISMEMBER joe's_movies "Fast Five"
    (integer) 1

## SPOP ##

移除并返回集合中的一个随机元素。
    
    如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER key [count] 命令。
    
    返回值
    被移除的随机元素。 当 key 不存在或 key 是空集时，返回 nil

## SRANDMEMBER ##

SRANDMEMBER key [count]
    
    如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素
    
    如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数
    组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合
    
    
    如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值
    
    返回值
    只提供 key 参数时，返回一个元素；如果集合为空，返回 nil 。 如果提供了 count 参数，那么返回一个数组；如果集合为空，返回空数组

## SMEMBERS ##

SMEMBERS key
    
    返回集合 key 中的所有成员。
    
    不存在的 key 被视为空集合
    
    返回值
    集合中的所有成员

## SUNION ##

SUNION key
    
    返回一个集合的全部成员，该集合是所有给定集合的并集。
    
    不存在的 key 被视为空集。
    
    返回值
    并集成员的列表

## SDIFF ##

SDIFF key [key …]
    返回一个集合的全部成员，该集合是所有给定集合之间的差集。
    
    不存在的 key 被视为空集。
    
    返回值
    一个包含差集成员的列表

# python操作redis #

python提供了redis模块里面可以操作redis的各种函数

pip install redis即可

import redis
    
    client=redis.Redis(host="localhost",port=6379,password="iot123456")
    client.set("name","dyk")
    print(client.get("name"))
    
    client.hset("student","name","dyk")
    client.hset("student","age",18)

[redis]: http://redisdoc.com/