redis操作

import redis
from redis import ConnectionPool, StrictRedis

REDIS_HOST = "10.133.3.26"
REDIS_POST = 6379
REDIS_DATABASE = 3
REDIS_PASSWORD = ''

conn = redis.Redis(host=REDIS_HOST, port=REDIS_POST, password=REDIS_PASSWORD, db=REDIS_DATABASE)
pool = ConnectionPool(host=REDIS_HOST, port=REDIS_POST, db=REDIS_DATABASE, password=REDIS_PASSWORD)
conn = StrictRedis(connection_pool=pool)

-------------------------------- key -----------------------------------------------

1. delete DEL 命令用于删除已存在的键。不存在的 key 会被忽略

print(conn.set('1', '4028b2883d3f5a8b013d57228d760a93'))  # set 设置指定 key 的值， 如果设置正确返回 True
print(conn.get('1'))  # 得到 键为1 的值    4028b2883d3f5a8b013d57228d760a93
print(conn.delete('1'))  # 删除 键为1 的值
print(conn.get('1'))  # 因为上面已经把键为1 的值删除掉，所以返回的是None

2. exists

# 设定键为2的值是  4028b2883d3f5a8b013d57228d760a93
conn.set('2', '4028b2883d3f5a8b013d57228d760a93')
# 存在就返回True 不存在就返回False
print(conn.exists('2'))  # 返回True
print(conn.exists('33'))  # 返回False

3. Expire 命令用于设置 key 的过期时间。key 过期后将不再可用。

conn.set('2', '4028b2883d3f5a8b013d57228d760a93')
# 成功就返回True 失败就返回False，下面的20表示是20秒
print(conn.expire('2', 20))
# 如果时间没事失效我们能得到键为2的值，否者是None
print(conn.get('2'))

4.Expireat 命令用于以 UNIX 时间戳(unix timestamp))格式设置 key 的过期时间。key 过期后将不再可用。主意:时间精确到秒，时间戳是10为数字

conn.set('2', '4028b2883d3f5a8b013d57228d760a93')
# 成功就返回True 失败就返回False，下面的1598033936表示是在2020-08-22 02:18:56 键2 过期
print(conn.expireat('2', 1598033936))
print(conn.get('2'))

5.PEXPIREAT 命令用于设置 key 的过期时间，已毫秒技。key 过期后将不再可用。主意:时间精确到毫秒，时间戳是13位数字

conn.set('2', '4028b2883d3f5a8b013d57228d760a93')
# 成功就返回True 失败就返回False。
print(conn.expireat('2', 1598033936000))
print(conn.get('2'))

6. Keys 命令用于查找所有符合给定模式 pattern 的 key 。

print(conn.set('111', '11'))
print(conn.set('122', '12'))
print(conn.set('113', '13'))
print(conn.keys(pattern='11*'))
# 输出的结果是 ['113', '111'] 因为键122不和 11* 匹配

7. MOVE 命令用于将当前数据库的 key 移动到给定的数据库 db 当中,select可以设定当前的数据库，如有需要请看select命令因为我们默认使用的数据库是db0，我们可以使用下面的命令键 2 移动到数据库 1 中去

conn.move(2, 1)

8. PERSIST 命令用于移除给定 key 的过期时间，使得 key 永不过期

# 设定键为 1 的值为11
print(conn.set('1', '11'))
# 设定键 1 过期时间为100秒
print(conn.expire(1, 100))
# 查看键 1 的过期时间还剩下多少
print(conn.ttl('1'))
# 目的是13秒后移除键 1 的过期时间
import time
time.sleep(3)
# 查看键 1 的过期时间还剩下多少
print(conn.ttl('1'))
# 移除键 1 的过期时间
conn.persist(1)
# 查看键 1 的过期时间还剩下多少  输出的结果是 None，我们可以通过redis desktop manager 查看键 1 的过期时间
print(conn.ttl('1'))

9.Pttl 命令以毫秒为单位返回 key 的剩余过期时间。

# 当 key 不存在时，返回 -2 。 当 key 存在但没有设置剩余生存时间时，返回 -1 。 否则，以毫秒为单位，返回 key 的剩余生存时间。
# 设定键为 1 的值为11
print(conn.set('1', '11'))
# 设定键 1 过期时间为100秒
print(conn.expire(1, 100))
import time
time.sleep(3)
# 返回的结果是 96994 ，运行的结果不是固定的，大于是97秒钟，主意是为了展示出返回的结果是毫秒，一秒等于1000毫秒
print(conn.pttl('1'))

10.TTL 命令以秒为单位返回 key 的剩余过期时间。

# 当 key 不存在时，返回 -2 。 当 key 存在但没有设置剩余生存时间时，返回 -1 。 否则，以毫秒为单位，返回 key 的剩余生存时间。
# 设定键为 1 的值为11
print(conn.set('1', '11'))
print(conn.expire(1, 100))  # 设定键 1 过期时间为100秒
import time
time.sleep(3)
print(conn.ttl('1'))  # 返回的结果是 97
print(conn.ttl('123'))  # 因为键 123 不存在  所以返回的结果是None

11.RANDOMKEY 命令从当前数据库中随机返回一个 key。当数据库不为空时，返回一个 key 。当数据库为空时，返回 nil 。

print(conn.randomkey())  # 数据库返回的是默认的数据库 key

12 .Rename 命令用于修改 key 的名称。改名成功时提示 OK ，失败时候返回一个错误。

print(conn.rename(1, 1111))  # 修改成功返回 True
print(conn.rename(222, 1111))  # 如果key 不存在 修改失败返回 redis.exceptions.ResponseError: no such key

13. Renamenx 命令用于在新的 key 不存在时修改 key 的名称。

print(conn.exists(123123))  # 返回false
print(conn.renamenx(1111, 123123))  # 成功返回True
print(conn.renamenx(1111, 123123))  # 失败返回    redis.exceptions.ResponseError: no such key

14. Type 命令用于返回 key 所储存的值的类型

# 返回 key 的数据类型，数据类型有：none (key不存在))，string (字符串))，list (列表))，set (集合))，zset (有序集))，hash (哈希表))，
print(conn.set('1', "111111111"))
print(conn.type('1'))  # 返回的结果是string
print(conn.sadd('2', '222222222222'))
print(conn.type('2'))  # 返回的结果是set
print(conn.lpush('3', '33333333'))
print(conn.type('3'))  # 返回的结果是list

------------------------------ string -----------------------------------------------

1.SET 命令用于设置给定 key 的值。如果 key 已经存储其他值， SET 就覆写旧值，且无视类型。

print(conn.set('123', '123'))  # 插入成功后返回True
print(conn.set('123', '[123,dffd]'))  # 插入成功后返回True

2. Get 命令用于获取指定 key 的值。如果 key 不存在，返回 None 。如果key 储存的值不是字符串类型，返回一个错误。

print(conn.get('123'))  # 返回的结果是[123,dffd]
print(conn.get('1234'))  # 返回的结果是 None

3. Getrange 命令用于获取存储在指定 key 中字符串的子字符串。字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内))。

print(conn.set('getrange', 'wo shi hao ren '))
print(conn.getrange('getrange', 2, 4))  # 返回的结果是sh
print(conn.getrange('getrange', 2, 6))  # 返回的结果是shi
print(conn.getrange('getrange', 2, 10))  # 返回的结果是shi hao

4.Getset 命令用于设置指定 key 的值，并返回 key 旧的值，当 key 存在但不是字符串类型时，返回一个错误。

print(conn.getset('getrange', 'hello word'))  # 返回的结果是wo shi hao ren
print(conn.getset('getrange11', 'hello word'))  # 当键不存在的时候，返回的结果是None

5.Getbit 命令用于对 key 所储存的字符串值，获取指定偏移量上的位(bit))字符串值指定偏移量上的位(bit))。当偏移量 getrange 比字符串值的长度大，或者 key 不存在时，返回 0。

print(conn.get('getrange'))  # 返回的结果是    hello word
print(conn.getbit('getrange', 1))  # 返回的结果是    1
print(conn.getbit('getrange', 3))  # 返回的结果是    0
print(conn.getbit('getr22222ange', 3))  # 字符串的键不存在的时候返回的结果是    0
print(conn.getbit('getrange', 300))  # 偏移量超过字符串长度，返回的结果是  0

6.Mget 命令返回所有(一个或多个))给定 key 的值。如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 None

print(conn.set('1', '1'))  # 返回的结果是    True
print(conn.set('11', '11'))  # 返回的结果是   True
print(conn.set('111', '111'))  # 返回的结果是  True
print(conn.mget('1', '11', '111'))  # 返回的结果是    ['1', '11', '111']
print(conn.mget('1', '11', '222222'))  # 因为键222222不存在，返回的结果是   ['1', '11', None]

7.Setbit 命令用于对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit))。

print(conn.get('getrange'))  # 返回的结果是    hello word
print(conn.setbit('getrange', 4, 10086))  # 返回的结果是    1
print(conn.getbit('getrange', 10086))  # 返回的结果是    0
print(conn.setbit('getrange', 5, 100861))  # 返回的结果是    0
print(conn.getbit('getrange', 100861))  # 返回的结果是    0

8.Setex 命令为指定的 key 设置值及其过期时间。如果 key 已经存在， SETEX 命令将会替换旧的值。

print(conn.setex('1', '123', 10))  # 返回的结果是    True
import time
time.sleep(5)
print(conn.ttl('1'))  # 返回的结果是    4
print(conn.get('1'))  # 返回的结果是    123
time.sleep(6)
print(conn.get('1'))  # 返回的结果是    None

9.Setnx（SET if Not eXists）命令在指定的 key 不存在时，为 key 设置指定的值。设置成功，返回 1 。设置失败，返回 0 。

print(conn.exists('22'))  # 返回的结果是    False
print(conn.setnx('22', '2222222'))  # 返回的结果是    True
print(conn.setnx('22', '123456'))  # 返回的结果是    False
print(conn.get('22'))  # 返回的结果是    2222222

10.Setrange 命令用指定的字符串覆盖给定 key 所储存的字符串值，覆盖的位置从偏移量 offset 开始。

print(conn.set('11', 'hello world'))  # 返回的结果是    True
print(conn.setrange('11', 6, "redis"))  # 返回的结果是    11
print(conn.get('11'))  # 返回的结果是    hello redis

11.Strlen 命令用于获取指定 key 所储存的字符串值的长度。当 key 储存的不是字符串值时，返回一个错误。

print(conn.get('11'))  # 返回的结果是    hello redis
print(conn.strlen('11'))  # 返回的结果是   11
print(conn.strlen('121'))  # 当key不存在的时候，返回的结果是   0

12.Mset 命令用于同时设置一个或多个 key-value 对。

# 第一种方法
print(conn.mset(name1="1", name2='2'))  # 返回的结果是   True
# 第二种方法
print(conn.mset({"name3": '3', "name4": '4'}))  # 返回的结果是   True
print(conn.get('name1'))  # 返回的结果是   1
print(conn.get('name2'))  # 返回的结果是   2
print(conn.get('name3'))  # 返回的结果是   3
print(conn.get('name4'))  # 返回的结果是   4

13. Msetnx 命令用于所有给定 key 都不存在时，同时设置一个或多个 key-value 对。当所有 key 都成功设置，返回 1 。如果所有给定 key 都设置失败(至少有一个 key 已经存在))，那么返回 0 。

print(conn.msetnx(name5="5", name6='6'))  # 返回的结果是  True
print(conn.msetnx(name5="55", name7='7'))  # 返回的结果是   False
print(conn.get('name5'))  # 返回的结果是   5
print(conn.get('name6'))  # 返回的结果是   6
print(conn.get('name7'))  # 返回的结果是  None

14. Psetex 命令以毫秒为单位设置 key 的生存时间。主意：SETEX 命令那样，以秒为单位。

print(conn.psetex('name8', 1000, "nihao"))  # 返回的结果是   True
print(conn.pttl('name8'))  # 返回的结果是  690
print(conn.get('name8'))  # 返回的结果是   nihao   时间过期后返回的是  None

15.Incr 命令将 key 中储存的数字值增一如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。本操作的值限制在 64 位(bit))有符号数字表示之内。

print(conn.set('11', 20))  # 返回的结果是  True
print(conn.incr('11'))  # 返回的结果是  21
print(conn.get('11'))  # 返回的结果是  21
print(conn.incr('11', amount=2))  # 返回的结果是  23
print(conn.get('11'))  # 返回的结果是  23
print(conn.incr('21', amount=2))  # 返回的结果是  2
print(conn.incr('22'))  # 返回的结果是  1

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

print(conn.set("13", 13))  # 返回的结果是  True
print(conn.incrby('13', 12))  # 返回的结果是  25
print(conn.incrby('15', 12))  # 返回的结果是  12
print(conn.incrby('15', 12))  # 返回的结果是  24

17.Redis Incrbyfloat 命令为 key 中所储存的值加上指定的浮点数增量值。如果 key 不存在，那么 INCRBYFLOAT 会先将 key 的值设为 0 ，再执行加法操作。

print(conn.set('1', 1.1))  # 返回的结果是  True
print(conn.incrbyfloat('1', 2.32))  # 返回的结果是  3.42
print(conn.get('1'))  # 返回的结果是  3.42
print(conn.incrbyfloat('1', amount=1.2))  # 返回的结果是  4.62

18.Redis Decr 命令将 key 中储存的数字值减一。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。本操作的值限制在 64 位(bit))有符号数字表示之内。

print(conn.decr('22'))  # 如果 key  22 不存在，返回的结果是  -1
print(conn.set('bb', 20))  # 返回的结果是 True
print(conn.decr('bb', amount=2))  # 返回的结果是  18
print(conn.decr('cc'))  # 返回的结果是  -1

19. Redis Append 命令用于为指定的 key 追加值。如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。

print(conn.set("11", 12))  # 返回的结果是 True
print(conn.append('11', 12))  # 返回的结果是 4
print(conn.append('11', 1))  # 返回的结果是 5
print(conn.append('11', 2))  # 返回的结果是 6
print(conn.get('11'))  # 返回的结果是 121212
print(conn.exists('14'))  # 返回的结果是 False
print(conn.append('14', 'hello world'))  # 返回的结果是 11
print(conn.get('14'))  # 返回的结果是 hello world

--------------------------------- hash ----------------------------------------

1. Hset 命令用于为哈希表中的字段赋值。如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。如果字段已经存在于哈希表中，旧值将被覆盖。如果字段是哈希表中的一个新建字段，并且值设置成功，返回 1 。如果哈希表中域字段已经存在且旧值已被新值覆盖，返回 0 。

print(conn.hset(name="name", key="key1", value="value"))  # 返回的结果是 1
print(conn.hget(name="name", key="key1"))  # 返回的结果是 value
print(conn.hset(name="name", key="key1", value="hello world"))  # 返回的结果是 0,原因是哈希表中域字段已经存在且旧值已被新值覆盖
print(conn.hget(name="name", key="key1"))  # 返回的结果是 hello world

2.Hdel 命令用于删除哈希表 key 中的一个或多个指定字段，不存在的字段将被忽略。

print(conn.hset(name="1", key="1", value="1"))  # 返回的结果是 1
print(conn.delete(1))  # 删除成功后 返回的结果是 1
print(conn.delete(1))  # 因为上一步已经删除，删除失败后 返回的结果是 0

3. Hexists 命令用于查看哈希表的指定字段是否存在。如果哈希表含有给定字段，返回 True 。如果哈希表不含有给定字段，或 key 不存在，返回False 。

print(conn.hset(name="1", key="1", value="1"))  # 返回的结果是 1
print(conn.hexists(name="1", key="1"))  # 返回的结果是 True
print(conn.hexists(name="1", key="2"))  # 返回的结果是 False
print(conn.hexists(name="2", key="2"))  # 返回的结果是 False
print(conn.hexists(name="2", key="1"))  # 返回的结果是 False

4.Hget 命令用于返回哈希表中指定字段的值。返回给定字段的值。如果给定的字段或 key 不存在时，返回 None 。

print(conn.hset(name="1", key="1", value="1"))  # 返回的结果是 1
print(conn.hget("1", "1"))  # 返回的结果是 1
print(conn.hget("2", "1"))  # 因为字段2不存在。所以返回的结果是 None
print(conn.hget("1", "2"))  # 因为key 2 不存在。所以返回的结果是 None
print(conn.hget("2", "2"))  # 因为key和字段都不存在，所以返回的结果是 None

5.Hgetall 命令用于返回哈希表中，所有的字段和值。在返回值里，紧跟每个字段名(field name))之后是字段的值(value))，所以返回值的长度是哈希表大小的两倍。

print(conn.hset(name="1", key="1", value="1"))  # 返回的结果是 1
print(conn.hset(name="1", key="3", value="2"))  # 返回的结果是 1
print(conn.hset(name="1", key="2", value="3"))  # 返回的结果是 1
print(conn.hset(name="1", key="2", value="4"))  # 返回的结果是 0   如果不知道为什么返回的结果是0，请看hset
print(conn.hgetall("1"))  # 返回的结果是 {'1': '1', '3': '2', '2': '4'}  主意返回的数据格式
print(conn.hgetall("2"))  # 因为字典名2 不存在，所以返回的结果是 {}

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

print(conn.hset(name="1", key="1", value="1"))  # 返回的结果是 1
print(conn.hincrby(name="1", key="1", amount=2))  # 返回的结果是 3
print(conn.hget(name="1", key="1"))  # 返回的结果是 3
print(conn.hincrby(name="2", key="2", value="3"))  # 字段不存在，返回的结果是 TypeError: hincrby()) got an unexpected keyword argument 'value'
print(conn.hincrby(name="1", key="2", amount=4))  # 这步是因为key为2不存在，返回的结果是 4，说明哈希表的 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令
print(conn.hget(name="1", key="2"))  # 返回的结果是 4

7. Hincrbyfloat 命令用于为哈希表中的字段值加上指定浮点数增量值。如果指定的字段不存在，那么在执行命令前，字段的值被初始化为 0 。

print(conn.hset(name="1", key="1", value="1"))  # 返回的结果是 1
print(conn.hincrbyfloat(name="1", key="1", amount="1.2"))  # 返回的结果是 2.2
print(conn.hget("1", "1"))  # 返回的结果是 2.2
print(conn.hincrbyfloat(name="2", key="1", amount="1.2"))  # 指定的字段2不存在，返回的结果是 1.2，说明如果指定的字段不存在，那么在执行命令前，字段的值被初始化为 0

8.Hkeys 命令用于获取哈希表中的所有字段名。包含哈希表中所有字段的列表。当 key 不存在时，返回一个空列表。

print(conn.hset(name="1", key="1", value="1"))  # 返回的结果是 1
print(conn.hset(name="1", key="1", value="2"))  # 返回的结果是 0
print(conn.hset(name="1", key="2", value="2"))  # 返回的结果是 1
print(conn.hset(name="1", key="3", value="2"))  # 返回的结果是 1
print(conn.hkeys(1))  # 返回的结果是 ['1', '2', '3']
print(conn.hkeys(2))  # 因为指定的字段名不存在，所以返回的结果是 []

9. Hlen 命令用于获取哈希表中字段的数量。哈希表中字段的数量。当 key 不存在时，返回 0 。

print(conn.hset(name="1", key="1", value="1"))  # 返回的结果是 1
print(conn.hset(name="1", key="2", value="2"))  # 返回的结果是 1
print(conn.hlen(1))  # 返回的结果是 2
print(conn.hset(name="1", key="4", value="3"))  # 返回的结果是 1
print(conn.hset(name="1", key="3", value="2"))  # 返回的结果是 1
print(conn.hlen(1))  # 返回的结果是 4

10. Hmget 命令用于返回哈希表中，一个或多个给定字段的值。如果指定的字段不存在于哈希表，那么返回一个 nil 值。一个包含多个给定字段关联值的表，表值的排列顺序和指定字段的请求顺序一样。

print(conn.hset(name="1", key="1", value="1"))  # 返回的结果是 1
print(conn.hset(name="1", key="2", value="2"))  # 返回的结果是 1
print(conn.hmget(name="1", keys="1"))  # 返回的结果是 ['1']
print(conn.hmget(name="1", keys="2"))  # 返回的结果是['2']
print(conn.hmget(name="2", keys="1"))  # 返回的结果是 [None]

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

aa = {"a": "a", "b": "b"}  # 返回的结果是 ['1']
print(conn.hmset("name", aa))  # 返回的结果是 True
print(conn.hget(name="name", key="a"))  # 返回的结果是 a
print(conn.hget(name="name", key="b"))  # 返回的结果是 b

12. Hsetnx 命令用于为哈希表中不存在的的字段赋值。如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。如果字段已经存在于哈希表中，操作无效。如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令。设置成功，返回 1 。如果给定字段已经存在且没有操作被执行，返回 0 。

print(conn.hsetnx(name="1", key="1", value="1"))  # 返回的结果是 1
print(conn.hsetnx(name="1", key="1", value="2"))  # 返回的结果是 0
print(conn.hsetnx(name="2", key="1", value="2"))  # 返回的结果是 0

13 Hvals 命令返回哈希表所有字段的值。一个包含哈希表中所有值的表。当 key 不存在时，返回一个空表。

print(conn.hset(name="1", key="1", value="11"))  # 返回的结果是 1
print(conn.hset(name="1", key="2", value="22"))  # 返回的结果是 1
print(conn.hset(name="1", key="3", value="33"))  # 返回的结果是 1
print(conn.hset(name="1", key="4", value="44"))  # 返回的结果是 1
print(conn.hvals("1"))  # 返回的结果是 ['11', '22', '33', '44']
print(conn.hvals("2"))  # 返回的结果是 []

-------------------------------------- list ----------------------------------------------------

1. Lpush 命令将一个或多个值插入到列表头部。如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。执行 LPUSH 命令后，列表的长度。

print(conn.lpush("1", 1))  # 输出的结果是1
print(conn.lpush("1", 1))  # 输出的结果是2
print(conn.lpush("1", 2, 3, 4))  # 输出的结果是5
print(conn.set("2", 1))  # 输出的结果是 True
print(conn.lpush("2", 2))  # 输出的结果是 redis.exceptions.ResponseError: WRONGTYPE Operation against a key holding the wrong kind of value,原因是键 2 是字符串类型，我们用list中的lpush给他添加元素

2.Rpush 命令用于将一个或多个值插入到列表的尾部(最右边))。如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。当列表存在但不是列表类型时，返回一个错误。执行 RPUSH 操作后，列表的长度。

print(conn.rpush("2", 1))  # 输出的结果是1
print(conn.rpush("2", 2, 3))  # 输出的结果是3
print(conn.rpush("2", 4, 5))  # 输出的结果是5

3.Blpop 命令移出并获取列表的第一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。如果列表为空，返回一个 None 。否则，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。

print(conn.rpush("3", 1, 2, 3, 4, 5, 6, ))  # 输出的结果是6
print(conn.blpop("3"))  # 输出的结果是('3', '1'))
print(conn.blpop("3"))  # 输出的结果是('3', '2'))
print(conn.blpop("3"))  # 输出的结果是('3', '3'))
print(conn.blpop("4", timeout=2))  # 因为键 4 不存在，所以2秒后输出的结果是None

4.Brpop 命令移出并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。假如在指定时间内没有任何元素被弹出，则返回一个None 和等待时长。反之，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。

print(conn.rpush("4", 1, 2, 3, 4, 5, 6, ))  # 输出的结果是6
print(conn.brpop("4"))  # 输出的结果是('4', '6'))
print(conn.brpop("4"))  # 输出的结果是('4', '5'))
print(conn.brpop("4"))  # 输出的结果是('4', '4'))
print(conn.brpop("5", timeout=2))  # 因为键 4 不存在，所以2秒后输出的结果是None

5.Brpoplpush 命令从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它；如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。假如在指定时间内没有任何元素被弹出，则返回一个 None 和等待时长。反之，返回一个含有两个元素的列表，第一个元素是被弹出元素的值，第二个元素是等待时长。

print(conn.rpush("11", 1, 2, 3))  # 输出的结果是3
print(conn.rpush("22", 4, 5, 6, ))  # 输出的结果是3
print(conn.brpoplpush(src="11", dst="22", timeout=2))  # 输出的结果是3
print(conn.brpoplpush(src="44", dst="22", timeout=2))  # 键44 不存在，输出的结果是None

6.Lindex 命令用于通过索引获取列表中的元素。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

print(conn.rpush("6", 1, 2, 3))  # 输出的结果是3
print(conn.lindex("6", 1))  # 输出的结果是2
print(conn.lindex("6", 2))  # 输出的结果是3
print(conn.lindex("6", 3))  # 输出的结果是None
print(conn.lindex("6", 4))  # 输出的结果是None
print(conn.lindex("6", -1))  # 输出的结果是3

7.Linsert 命令用于在列表的元素前或者后插入元素。

print(conn.rpush("7", 1))  # 输出的结果是1
print(conn.rpush("7", 2))  # 输出的结果是2
print(conn.linsert("7", "BEFORE", "2", 12))  # 输出的结果是2

8.Llen 命令用于返回列表的长度。如果列表 key 不存在，则 key 被解释为一个空列表，返回 0 。如果 key 不是列表类型，返回一个错误。

print(conn.llen("8"))  # key 不存在，输出的结果是0
print(conn.rpush("8", 1))  # 输出的结果是1
print(conn.llen("8"))  # 输出的结果是1
print(conn.rpush("8", 2, 3))  # 输出的结果是3
print(conn.llen("8"))  # 输出的结果是3

9.Lpop 命令用于移除并返回列表的第一个元素。列表的第一个元素。当列表 key 不存在时，返回 None 。

print(conn.lpop("9"))  # 输出的结果是None
print(conn.rpush("9", 1))  # 输出的结果是1
print(conn.rpush("9", 2))  # 输出的结果是2
print(conn.lpop("9"))  # 输出的结果是1

10.Lpushx 将一个或多个值插入到已存在的列表头部，列表不存在时操作无效。

print(conn.rpush("10", 1))  # 输出的结果是1
print(conn.rpushx("10", 2))  # 输出的结果是2
print(conn.rpushx("10", 3))  # 输出的结果是3
print(conn.rpushx("11", 3))  # 输出的结果是5
print(conn.lrange("10", 0, -1))  # 输出的结果是['1', '2', '3']
print(conn.lrange("11", 0, -1))  # 输出的结果是['1', '2', '1', '2', '3']

11.Lrange 返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

print(conn.rpush("11", 1, 2))  # 输出的结果是2
print(conn.rpush("11", 3, 4))  # 输出的结果是4
print(conn.lrange("11", 0, -1))  # 输出的结果是['1', '2', '3', '4']
print(conn.lrange("11", 1, 2))  # 输出的结果是['2', '3']

12.Lrem 根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素。COUNT 的值可以是以下几种：count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。count = 0 : 移除表中所有与 VALUE 相等的值。被移除元素的数量。列表不存在时返回 0 。

print(conn.rpush("12", 1))  # 输出的结果是1
print(conn.rpush("12", 1))  # 输出的结果是2
print(conn.rpush("12", 2))  # 输出的结果是3
print(conn.rpush("12", 1))  # 输出的结果是4
print(conn.lrem("12", 1, -2))  # 输出的结果是2
print(conn.lrange("12", 0, -1))  # 输出的结果是['1', '2']

13.Lset 通过索引来设置元素的值。当索引参数超出范围，或对一个空列表进行 LSET 时，返回一个错误操作成功返回 True ，否则返回错误信息。

print(conn.rpush("13", 1, 2, 3, 4))  # 输出的结果是4
print(conn.lset("13", 1, 5))  # 输出的结果是True
print(conn.lrange("13", 0, -1))  # 输出的结果是['1', '5', '3', '4']

14.Ltrim 对一个列表进行修剪(trim))，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。下标 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

print(conn.rpush("14", 1, 2, 3, 4))  # 输出的结果是4
print(conn.ltrim("14", 1, -2))  # 输出的结果是True
print(conn.lrange("14", 0, -1))  # 输出的结果是['2', '3']

15.Rpop 命令用于移除并返回列表的最后一个元素。列表的最后一个元素。当列表不存在时，返回 None 。

print(conn.rpush("15", 1, 2, 3, 4))  # 输出的结果是4
print(conn.rpop("15"))  # 输出的结果是4
print(conn.lrange("15", 0, -1))  # 输出的结果是['1', '2', '3']

16.Rpoplpush 命令用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回。

print(conn.rpush("16", 1, 2, 3, 4))  # 输出的结果是4
print(conn.rpush("17", 1, 2, 3, 4))  # 输出的结果是4
print(conn.rpoplpush("16", "17"))  # 输出的结果是4
print(conn.lrange("16", 0, -1))  # 输出的结果是['1', '2', '3']
print(conn.lrange("17", 0, -1))  # 输出的结果是['4', '1', '2', '3', '4']

17.Rpushx 命令用于将一个或多个值插入到已存在的列表尾部(最右边))。如果列表不存在，操作无效。

print(conn.rpushx("18", 1))  # 因为键18 不存在，所以插入失败，输出的结果是0
print(conn.rpush("18", 2))  # 输出的结果是1
print(conn.rpushx("18", 3))  # 输出的结果是2
print(conn.lrange("18", 0, -1))  # 输出的结果是['2', '3']

-------------------------------------- set ----------------------------------------------------

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

print(conn.sadd("1", 1))  # 输出的结果是1
print(conn.sadd("1", 2))  # 输出的结果是1
print(conn.sadd("1", 2))  # 因为2已经存在，不能再次田间，所以输出的结果是0
print(conn.sadd("1", 3, 4))  # 输出的结果是2
print(conn.sinter("1"))  # 输出的结果是set(['1', '3', '2', '4']))

2.Scard 命令返回集合中元素的数量。集合的数量。当集合 key 不存在时，返回 0 。

print(conn.sadd("2", 1))  # 输出的结果是1
print(conn.sadd("2", 2, 3, 4, 5))  # 输出的结果是1
print(conn.scard("2"))  # 输出的结果是5

3.Sdiff 命令返回给定集合之间的差集。不存在的集合 key 将视为空集。

print(conn.sadd("31", 1, 2, 3, 4, 5, 6))  # 输出的结果是6
print(conn.sadd("32", 4, 5, 6, 7, 8, 9))  # 输出的结果是6
print(conn.sdiff(31, 32))  # 输出的结果是set(['1', '3', '2']))
print(conn.sdiff(32, 31))  # 输出的结果是set(['9', '8', '7']))
print(conn.sdiff(31, 31))  # 输出的结果是set([]))

4.Sdiffstore 命令将给定集合之间的差集存储在指定的集合中。如果指定的集合 key 已存在，则会被覆盖。

print(conn.sadd("41", 1, 2, 3, 4, 5, 6))  # 输出的结果是6
print(conn.sadd("42", 4, 5, 6, 7, 8, 9))  # 输出的结果是6
print(conn.sadd("43", 0))  # 输出的结果是1
print(conn.sdiffstore("43", "41", "42"))  # 输出的结果是3
print(conn.sinter("43"))  # 输出的结果是 set(['1', '3', '2']))

5.Sinter 命令返回给定所有给定集合的交集。不存在的集合 key 被视为空集。当给定集合当中有一个空集时，结果也为空集(根据集合运算定律))。

print(conn.sadd("51", 3, 4, 5, 6))  # 输出的结果是4
print(conn.sadd("52", 1, 2, 3, 4))  # 输出的结果是4
print(conn.sinter(51, 52))  # 输出的结果是set(['3', '4']))
print(conn.sadd("53", 1, 2, 3, 4, 5, 6))  # 输出的结果是6
print(conn.sadd("54", 3, 4, 5, 6, 7, 8, 9))  # 输出的结果是7
print(conn.sinter(53, 54))  # 输出的结果是set(['3', '5', '4', '6']))
print(conn.sinter(53, 56))  # 输出的结果是set([]))

6.Sinterstore 命令将给定集合之间的交集存储在指定的集合中。如果指定的集合已经存在，则将其覆盖。

print(conn.sadd("61", 3, 4, 5, 6))  # 输出的结果是4
print(conn.sadd("62", 1, 2, 3, 4))  # 输出的结果是4
print(conn.sadd("63", 0))  # 输出的结果是1
print(conn.sinterstore(63, 61, 62))  # 输出的结果是2
print(conn.sinter(63))  # 输出的结果是set(['3', '4']))

7.Sismember 命令判断成员元素是否是集合的成员。如果成员元素是集合的成员，返回 1 。如果成员元素不是集合的成员，或 key 不存在，返回 0 。

print(conn.sadd("71", 1, 2, 3, 4, 5, 6))  # 输出的结果是6
print(conn.sismember("71", 1))  # 输出的结果是True
print(conn.sismember("71", 2))  # 输出的结果是True
print(conn.sismember("71", 7))  # 输出的结果是False
print(conn.sismember("71", 8))  # 输出的结果是False

8.Smembers 命令返回集合中的所有的成员。不存在的集合 key 被视为空集合。

print(conn.sadd("81", 1, 2, 3, 4, 5, 6))  # 输出的结果是6
print(conn.smembers(81))  # 输出的结果是set(['1', '3', '2', '5', '4', '6']))
print(conn.smembers(82))  # 输出的结果是set([]))

9.Smove 命令将指定成员 member 元素从 source 集合移动到 destination 集合。SMOVE 是原子性操作。如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 False 。否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。当 source 或 destination 不是集合类型时，返回一个错误。如果成员元素被成功移除，返回 True。如果成员元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 False

print(conn.sadd("91", 1, 2, ))  # 输出的结果是2
print(conn.sadd("92", 3, 4, ))  # 输出的结果是2
print(conn.smove(91, 92, 1))  # 把91中的1移动到92中去，输出的结果是True
print(conn.smembers("91"))  # 输出的结果是set(['2']))
print(conn.smembers("92"))  # 输出的结果是set(['1', '3', '4']))
print(conn.smove(91, 92, 5))  # 91不存在5，输出的结果是False
print(conn.smembers("91"))  # 输出的结果是set(['2']))
print(conn.smembers("92"))  # 输出的结果是set(['1', '3', '4']))

10. Spop 命令用于移除并返回集合中的一个随机元素。

print(conn.sadd("10", 1, 2, 3, 4, 5, 6))  # 输出的结果是6
print(conn.spop("10"))  # 输出的结果是3
print(conn.smembers("10"))  # 输出的结果是set(['1', '2', '5', '4', '6']))
print(conn.spop("10"))  # 输出的结果是1
print(conn.smembers("10"))  # 输出的结果是set(['2', '5', '4', '6']))

11.Srandmember 命令用于返回集合中的一个随机元素。从 Redis 2.6 版本开始， Srandmember 命令接受可选的 count 参数：如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 Srandmember 则仅仅返回随机元素，而不对集合进行任何改动。

print(conn.sadd("11", 1, 2, 3, 4, 5, 6))  # 输出的结果是6
print(conn.srandmember(11))  # 输出的结果是4
print(conn.smembers(11))  # 输出的结果是set(['1', '3', '2', '5', '4', '6']))
print(conn.srandmember(11, 3))  # 输出的结果是['6', '3', '1']
print(conn.smembers(11))  # 输出的结果是set(['1', '3', '2', '5', '4', '6']))

12.Srem 命令用于移除集合中的一个或多个成员元素，不存在的成员元素会被忽略。当 key 不是集合类型，返回一个错误。被成功移除的元素的数量，不包括被忽略的元素。

print(conn.sadd("12", 1, 2, 3, 4, 5, 6, 7))  # 输出的结果是7
print(conn.srem("12", 1))  # 输出的结果是1
print(conn.smembers("12"))  # 输出的结果是set(['3', '2', '5', '4', '7', '6']))
print(conn.srem("12", 8))  # 输出的结果是0
print(conn.smembers("12"))  # 输出的结果是set(['3', '2', '5', '4', '7', '6']))

13.Sunion 命令返回给定集合的并集。不存在的集合 key 被视为空集。

print(conn.sadd("131", 1, 2, 3, 4, 5, 6, 7))  # 输出的结果是7
print(conn.sadd("132", 0, 1, 2, 7, 8, 9))  # 输出的结果是6
print(conn.sunion(131, 132))  # 输出的结果是set(['1', '0', '3', '2', '5', '4', '7', '6', '9', '8']))
print(conn.sunion(131, 134))  # 输出的结果是set(['1', '3', '2', '5', '4', '7', '6']))

14.Sunionstore 命令将给定集合的并集存储在指定的集合 destination 中。

print(conn.sadd("141", 1, 2, 3, 4, 5, 6, 7))  # 输出的结果是7
print(conn.sadd("142", 0, 1, 2, 3, 4))  # 输出的结果是5
print(conn.sunionstore(143, 141, 142))  # 输出的结果是8
print(conn.smembers(143))  # 输出的结果是set(['1', '0', '3', '2', '5', '4', '7', '6']))

15.Sscan 命令用于迭代集合键中的元素。

print(conn.sadd("151", 1, 2, 3, 4, 5, 6, 7))  # 输出的结果是7
print(conn.sscan(151, cursor=2, match=1, count=1))  # 输出的结果是 (0L, ['1']))

-------------------------------------- zset ----------------------------------------------------

1.Zadd 命令用于将一个或多个成员元素及其分数值加入到有序集当中。如果某个成员已经是有序集的成员，那么更新这个成员的分数值，并通过重新插入这个成员元素，来保证该成员在正确的位置上。分数值可以是整数值或双精度浮点数。如果有序集合 key 不存在，则创建一个空的有序集并执行 ZADD 操作。当 key 存在但不是有序集类型时，返回一个错误。

print(conn.zadd("1", "1", 2, "3", 3))  # 输出的结果是2
print(conn.zadd("1", "2", 2))  # 输出的结果是1
print(conn.zadd("1", "1", 1))  # 输出的结果是0
print(conn.zadd("1", "3", 4))  # 输出的结果是0
print(conn.zrange("1", 0, -1))  # 输出的结果是 ['1', '2', '3']

2.Zcard 命令用于计算集合中元素的数量。当 key 存在且是有序集类型时，返回有序集的基数。当 key 不存在时，返回 0 。

print(conn.zadd("1", "1", 1, "3", 3))  # 输出的结果是2
print(conn.zadd("1", "2", 2))  # 输出的结果是1
print(conn.zadd("1", "2", 4))  # 输出的结果是1
print(conn.zcard(1))  # 输出的结果是3
print(conn.zcard(2))  # 输出的结果是0

3.Zcount 命令用于计算有序集合中指定分数区间的成员数量。分数值在 min 和 max 之间的成员的数量。

print(conn.zadd("2", "1", 1, "3", 3))  # 输出的结果是2
print(conn.zadd("2", "2", 2))  # 输出的结果是1
print(conn.zadd("2", "1", 4))  # 输出的结果是0
print(conn.zcount("2", min=0, max=5))  # 输出的结果是3
print(conn.zcount("2", min=0, max=3))  # 输出的结果是2
print(conn.zcount("2", min=1, max=3))  # 输出的结果是2

4.Zincrby 命令对有序集合中指定成员的分数加上增量 increment可以通过传递一个负数值 increment ，让分数减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。当 key 不存在，或分数不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。当 key 不是有序集类型时，返回一个错误。分数值可以是整数值或双精度浮点数。member 成员的新分数值，以字符串形式表示。

print(conn.zadd("4", "1", 1, "2", 2, "3", 3, "4", 4))  # 输出的结果是4
print(conn.zincrby(name=4, value=1, amount=5))  # 输出的结果是6.0
print(conn.zincrby(name=4, value=2, amount=55))  # 输出的结果是57.0
print(conn.zrange(name=4, start=0, end=-1, withscores=False))  # 输出的结果是['1', '3', '2', '4']

5.Zinterstore 命令计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集))储存到 destination 。默认情况下，结果集中某个成员的分数值是所有给定集下该成员分数值之和。

print(conn.zadd("41", "a1", 6, "a2", 2, "a3", 5))  # 输出的结果是3
print(conn.zadd('42', a1=7, b1=10, b2=5))  # 输出的结果是3
# 获取两个有序集合的交集并放入dest集合，如果遇到相同值不同分数，则按照aggregate进行操作
# aggregate的值为: SUM  MIN  MAX
print(conn.zinterstore("43", ("42", "41")), aggregate="MAX")  # 输出的结果是4
print(conn.zscan("43"))  # 输出的结果是(0L, [('a1', 7.0))]))

6. Zlexcount 命令在计算有序集合中指定字典区间内成员数量。

print(conn.zadd("6", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zlexcount(name=6, min="-", max="+"))  # 输出的结果是3
print(conn.zadd("6", "e", 4, "f", 5, "d", 6))  # 输出的结果是3
print(conn.zlexcount(name=6, min="-", max="+"))  # 输出的结果是6
print(conn.zlexcount(name=6, min="[a", max="[b"))  # 输出的结果是2
print(conn.zlexcount(name=6, min="[a", max="[f"))  # 输出的结果是6
print(conn.zlexcount(name=6, min="[a", max="[e"))  # 输出的结果是4

7.Zrange 返回有序集中，指定区间内的成员。其中成员的位置按分数值递增(从小到大))来排序。具有相同分数值的成员按字典序(lexicographical order ))来排列。如果你需要成员按值递减(从大到小))来排列，请使用 ZREVRANGE 命令。下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

print(conn.zadd("7", "1", 1, "2", 2, "3", 3, "4", 4, "5", 5))  # 输出的结果是5
print(conn.zrange("7", start=0, end=-1, desc=False))  # 输出的结果是['1', '2', '3', '4', '5']
print(conn.zrange("7", start=0, end=2, desc=False))  # 输出的结果是['1', '2', '3']

8.Zrangebylex 通过字典区间返回有序集合的成员。当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的值（lexicographical ordering）来进行排序，而这个命令则可以返回给定的有序集合键 key 中，元素的值介于 min 和 max 之间的成员对集合中的每个成员进行逐个字节的对比（byte-by-byte compare），并按照从低到高的顺序，返回排序后的集合成员。如果两个字符串有一部分内容是相同的话，那么命令会认为较长的字符串比较短的字符串要大

print(conn.zadd("8", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zrangebylex(name="8", min="-", max="[c"))  # 输出的结果是 ['a', 'b', 'c']
print(conn.zrangebylex(name="8", min="-", max="(c"))  # 输出的结果是 ['a', 'b']
print(conn.zadd("8", "e", 4, "f", 5, "d", 6))  # 输出的结果是3
print(conn.zrangebylex(name=8, min="[b", max="[f"))  # 输出的结果是 ['b', 'c', 'e', 'f', 'd']
print(conn.zrangebylex(name=8, min="(b", max="[f"))  # 输出的结果是 ['c', 'e', 'f', 'd']

9.Zrangebyscore 返回有序集合中指定分数区间的成员列表。有序集成员按分数值递增(从小到大))次序排列。具有相同分数值的成员按字典序来排列(该属性是有序集提供的，不需要额外的计算))。默认情况下，区间的取值使用闭区间 (小于等于或大于等于))，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于))。

print(conn.zadd("9", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zrangebyscore("9", "1", "6"))  # 输出的结果是['a', 'b', 'c']
print(conn.zadd("9", "c", 11, "d", 21, "e", 32))  # 输出的结果是3
print(conn.zrangebyscore("9", "3", "16"))  # 输出的结果是['c']
print(conn.zrangebyscore("9", "3", "36"))  # 输出的结果是['c', 'd', 'e']

10.Zrank 返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大))顺序排列。如果成员是有序集 key 的成员，返回 member 的排名。如果成员不是有序集 key 的成员，返回 None 。

print(conn.zadd("10", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zadd("10", "f", 11, "d", 21, "e", 32))  # 输出的结果是3
print(conn.zrank("10", "a"))  # 输出的结果是0
print(conn.zrank("10", "b"))  # 输出的结果是1
print(conn.zrank("10", "e"))  # 输出的结果是5
print(conn.zrank("10", "d"))  # 输出的结果是4
print(conn.zrank("10", "h"))  # 输出的结果是None

11.Zrem 命令用于移除有序集中的一个或多个成员，不存在的成员将被忽略。当 key 存在但不是有序集类型时，返回一个错误。

print(conn.zadd("11", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zadd("11", "f", 11, "d", 21, "e", 32))  # 输出的结果是3
print(conn.zrem("11", "a"))  # 输出的结果是1
print(conn.zrem("11", "f"))  # 输出的结果是1
print(conn.zrem("11", "h"))  # 输出的结果是0
print(conn.zrange("11", start=0, end=32))  # 输出的结果是['b', 'c', 'd', 'e'], 其中  a f 已经移除掉
print(conn.zrange("11", start=2, end=32))  # 输出的结果是['d', 'e'], 其中  a f 已经移除掉，d  e  没有被包涵

12.Zremrangebylex 命令用于移除有序集合中给定的字典区间的所有成员。被成功移除的成员的数量，不包括被忽略的成员。

print(conn.zadd("12", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zadd("12", "d", 11, "e", 21, "f", 32))  # 输出的结果是3
print(conn.zremrangebylex("12", min="[a", max="[c"))  # 输出的结果是3
print(conn.zrange("12", 0, -1))  # 输出的结果是 ['d', 'e', 'f']  因为  a，b，c已经被移除

13. Zremrangebyrank 命令用于移除有序集中，指定排名(rank))区间内的所有成员。

print(conn.zadd("13", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zadd("13", "d", 8, "e", 21, "f", 32))  # 输出的结果是3
print(conn.zremrangebyrank(name=13, min=1, max=3))  # 输出的结果是3
print(conn.zrange("13", "0", "-1"))  # 输出的结果是['a', 'e', 'f']  因为删除了 b，c，d

15.Zrevrange 命令返回有序集中，指定区间内的成员。其中成员的位置按分数值递减(从大到小))来排列。具有相同分数值的成员按字典序的逆序(reverse lexicographical order))排列。除了成员按分数值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一样。

print(conn.zadd("15", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zadd("15", "d", 8, "e", 21, "f", 32))  # 输出的结果是3
print(conn.zrevrange(name="15", start=0, end=-1))  # 输出的结果是['f', 'e', 'd', 'c', 'b', 'a']
print(conn.zrevrange(name="15", start=1, end=21))  # 输出的结果是['e', 'd', 'c', 'b', 'a']
print(conn.zrevrange(name="15", start=3, end=21))  # 输出的结果是['c', 'b', 'a']

16.Zrevrangebyscore 返回有序集中指定分数区间内的所有的成员。有序集成员按分数值递减(从大到小))的次序排列。具有相同分数值的成员按字典序的逆序(reverse lexicographical order ))排列。除了成员按分数值递减的次序排列这一点外， ZREVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE 命令一样。

print(conn.zadd("16", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zadd("16", "d", 8, "e", 21, "f", 32))  # 输出的结果是3
print(conn.zrevrangebyscore(name="16", max=33, min=0))  # 输出的结果是['f', 'e', 'd', 'c', 'b', 'a']
print(conn.zrevrangebyscore(name="16", max=20, min=2))  # 输出的结果是['d', 'c', 'b']

17. Zrevrank 命令返回有序集中成员的排名。其中有序集成员按分数值递减(从大到小))排序。排名以 0 为底，也就是说，分数值最大的成员排名为 0 。使用 ZRANK 命令可以获得成员按分数值递增(从小到大))排列的排名。

print(conn.zadd("17", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zadd("17", "d", 4, "e", 5, "f", 6))  # 输出的结果是3
print(conn.zrevrank(name=17, value="a"))  # 输出的结果是5
print(conn.zrevrank(name=17, value="c"))  # 输出的结果是3
print(conn.zrevrank(name=17, value="d"))  # 输出的结果是2
print(conn.zrevrank(name=17, value="h"))  # 输出的结果是None

18.Zscore 命令返回有序集中，成员的分数值。如果成员元素不是有序集 key 的成员，或 key 不存在，返回 None 。

print(conn.zadd("18", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zadd("18", "d", 4, "e", 5, "f", 6))  # 输出的结果是3
print(conn.zscore(name="18", value="a"))  # 输出的结果是1.0
print(conn.zscore(name="18", value="c"))  # 输出的结果是3.0
print(conn.zscore(name="18", value="f"))  # 输出的结果是6.0
print(conn.zscore(name="18", value="h"))  # 输出的结果是None

19.Zscan 命令用于迭代有序集合中的元素（包括元素成员和元素分值）返回的每个元素都是一个有序集合元素，一个有序集合元素由一个成员（member）和一个分值（score）组成。

print(conn.zadd("20", "a", 1, "b", 2, "c", 3))  # 输出的结果是3
print(conn.zscan(name="20"))  # 输出的结果是(0L, [('a', 1.0)), ('b', 2.0)), ('c', 3.0))]))
print(conn.zadd("20", "d", 4, "e", 5, "f", 3))  # 输出的结果是3
print(conn.zscan(name="20"))  # 输出的结果是 (0L, [('a', 1.0)), ('b', 2.0)), ('c', 3.0)), ('f', 3.0)), ('d', 4.0)), ('e', 5.0))]))

发表于 2019-12-31 11:14 守护式等待阅读(27) 评论(0) 编辑收藏举报

redis 操作

redis操作

-------------------------------- key -----------------------------------------------

1. delete DEL 命令用于删除已存在的键。不存在的 key 会被忽略

2. exists

3. Expire 命令用于设置 key 的过期时间。key 过期后将不再可用。

4.Expireat 命令用于以 UNIX 时间戳(unix timestamp))格式设置 key 的过期时间。key 过期后将不再可用。主意:时间精确到秒，时间戳是10为数字

5.PEXPIREAT 命令用于设置 key 的过期时间，已毫秒技。key 过期后将不再可用。主意:时间精确到毫秒，时间戳是13位数字

6. Keys 命令用于查找所有符合给定模式 pattern 的 key 。

7. MOVE 命令用于将当前数据库的 key 移动到给定的数据库 db 当中,select可以设定当前的数据库，如有需要请看select命令因为我们默认使用的数据库是db0，我们可以使用下面的命令键 2 移动到数据库 1 中去

8. PERSIST 命令用于移除给定 key 的过期时间，使得 key 永不过期

9.Pttl 命令以毫秒为单位返回 key 的剩余过期时间。

10.TTL 命令以秒为单位返回 key 的剩余过期时间。

11.RANDOMKEY 命令从当前数据库中随机返回一个 key。当数据库不为空时，返回一个 key 。 当数据库为空时，返回 nil 。

12 .Rename 命令用于修改 key 的名称 。改名成功时提示 OK ，失败时候返回一个错误。

13. Renamenx 命令用于在新的 key 不存在时修改 key 的名称 。

14. Type 命令用于返回 key 所储存的值的类型

------------------------------ string -----------------------------------------------

1.SET 命令用于设置给定 key 的值。如果 key 已经存储其他值， SET 就覆写旧值，且无视类型。

2. Get 命令用于获取指定 key 的值。如果 key 不存在，返回 None 。如果key 储存的值不是字符串类型，返回一个错误。

3. Getrange 命令用于获取存储在指定 key 中字符串的子字符串。字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内))。

4.Getset 命令用于设置指定 key 的值，并返回 key 旧的值，当 key 存在但不是字符串类型时，返回一个错误。

5.Getbit 命令用于对 key 所储存的字符串值，获取指定偏移量上的位(bit))字符串值指定偏移量上的位(bit))。当偏移量 getrange 比字符串值的长度大，或者 key 不存在时，返回 0。

6.Mget 命令返回所有(一个或多个))给定 key 的值。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 None

7.Setbit 命令用于对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit))。

8.Setex 命令为指定的 key 设置值及其过期时间。如果 key 已经存在， SETEX 命令将会替换旧的值。

9.Setnx（SET if Not eXists） 命令在指定的 key 不存在时，为 key 设置指定的值。设置成功，返回 1 。 设置失败，返回 0 。

10.Setrange 命令用指定的字符串覆盖给定 key 所储存的字符串值，覆盖的位置从偏移量 offset 开始。

11.Strlen 命令用于获取指定 key 所储存的字符串值的长度。当 key 储存的不是字符串值时，返回一个错误。

12.Mset 命令用于同时设置一个或多个 key-value 对。

13. Msetnx 命令用于所有给定 key 都不存在时，同时设置一个或多个 key-value 对。当所有 key 都成功设置，返回 1 。 如果所有给定 key 都设置失败(至少有一个 key 已经存在))，那么返回 0 。

14. Psetex 命令以毫秒为单位设置 key 的生存时间。主意：SETEX 命令那样，以秒为单位。

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

17.Redis Incrbyfloat 命令为 key 中所储存的值加上指定的浮点数增量值。如果 key 不存在，那么 INCRBYFLOAT 会先将 key 的值设为 0 ，再执行加法操作。

19. Redis Append 命令用于为指定的 key 追加值。如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。

--------------------------------- hash ----------------------------------------

2.Hdel 命令用于删除哈希表 key 中的一个或多个指定字段，不存在的字段将被忽略。

3. Hexists 命令用于查看哈希表的指定字段是否存在。如果哈希表含有给定字段，返回 True 。 如果哈希表不含有给定字段，或 key 不存在，返回False 。

4.Hget 命令用于返回哈希表中指定字段的值。返回给定字段的值。如果给定的字段或 key 不存在时，返回 None 。

5.Hgetall 命令用于返回哈希表中，所有的字段和值。在返回值里，紧跟每个字段名(field name))之后是字段的值(value))，所以返回值的长度是哈希表大小的两倍。

7. Hincrbyfloat 命令用于为哈希表中的字段值加上指定浮点数增量值。如果指定的字段不存在，那么在执行命令前，字段的值被初始化为 0 。

8.Hkeys 命令用于获取哈希表中的所有字段名。包含哈希表中所有字段的列表。 当 key 不存在时，返回一个空列表。

9. Hlen 命令用于获取哈希表中字段的数量。哈希表中字段的数量。 当 key 不存在时，返回 0 。

10. Hmget 命令用于返回哈希表中，一个或多个给定字段的值。如果指定的字段不存在于哈希表，那么返回一个 nil 值。一个包含多个给定字段关联值的表，表值的排列顺序和指定字段的请求顺序一样。

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

13 Hvals 命令返回哈希表所有字段的值。一个包含哈希表中所有值的表。 当 key 不存在时，返回一个空表。

-------------------------------------- list ----------------------------------------------------

1. Lpush 命令将一个或多个值插入到列表头部。 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。 当 key 存在但不是列表类型时，返回一个错误。执行 LPUSH 命令后，列表的长度。

2.Rpush 命令用于将一个或多个值插入到列表的尾部(最右边))。如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。 当列表存在但不是列表类型时，返回一个错误。执行 RPUSH 操作后，列表的长度。

6.Lindex 命令用于通过索引获取列表中的元素。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

7.Linsert 命令用于在列表的元素前或者后插入元素。

8.Llen 命令用于返回列表的长度。 如果列表 key 不存在，则 key 被解释为一个空列表，返回 0 。 如果 key 不是列表类型，返回一个错误。

9.Lpop 命令用于移除并返回列表的第一个元素。列表的第一个元素。 当列表 key 不存在时，返回 None 。

10.Lpushx 将一个或多个值插入到已存在的列表头部，列表不存在时操作无效。

13.Lset 通过索引来设置元素的值。当索引参数超出范围，或对一个空列表进行 LSET 时，返回一个错误操作成功返回 True ，否则返回错误信息。

15.Rpop 命令用于移除并返回列表的最后一个元素。列表的最后一个元素。 当列表不存在时，返回 None 。

16.Rpoplpush 命令用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回。

17.Rpushx 命令用于将一个或多个值插入到已存在的列表尾部(最右边))。如果列表不存在，操作无效。

-------------------------------------- set ----------------------------------------------------

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

2.Scard 命令返回集合中元素的数量。集合的数量。 当集合 key 不存在时，返回 0 。

3.Sdiff 命令返回给定集合之间的差集。不存在的集合 key 将视为空集。

4.Sdiffstore 命令将给定集合之间的差集存储在指定的集合中。如果指定的集合 key 已存在，则会被覆盖。

5.Sinter 命令返回给定所有给定集合的交集。 不存在的集合 key 被视为空集。 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律))。

6.Sinterstore 命令将给定集合之间的交集存储在指定的集合中。如果指定的集合已经存在，则将其覆盖。

7.Sismember 命令判断成员元素是否是集合的成员。如果成员元素是集合的成员，返回 1 。 如果成员元素不是集合的成员，或 key 不存在，返回 0 。

8.Smembers 命令返回集合中的所有的成员。 不存在的集合 key 被视为空集合。

10. Spop 命令用于移除并返回集合中的一个随机元素。

12.Srem 命令用于移除集合中的一个或多个成员元素，不存在的成员元素会被忽略。当 key 不是集合类型，返回一个错误。被成功移除的元素的数量，不包括被忽略的元素。

13.Sunion 命令返回给定集合的并集。不存在的集合 key 被视为空集。

14.Sunionstore 命令将给定集合的并集存储在指定的集合 destination 中。

15.Sscan 命令用于迭代集合键中的元素。

-------------------------------------- zset ----------------------------------------------------

2.Zcard 命令用于计算集合中元素的数量。当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0 。

3.Zcount 命令用于计算有序集合中指定分数区间的成员数量。分数值在 min 和 max 之间的成员的数量。

5.Zinterstore 命令计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集))储存到 destination 。默认情况下，结果集中某个成员的分数值是所有给定集下该成员分数值之和。

6. Zlexcount 命令在计算有序集合中指定字典区间内成员数量。

10.Zrank 返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大))顺序排列。如果成员是有序集 key 的成员，返回 member 的排名。 如果成员不是有序集 key 的成员，返回 None 。

11.Zrem 命令用于移除有序集中的一个或多个成员，不存在的成员将被忽略。当 key 存在但不是有序集类型时，返回一个错误。

12.Zremrangebylex 命令用于移除有序集合中给定的字典区间的所有成员。被成功移除的成员的数量，不包括被忽略的成员。

11.RANDOMKEY 命令从当前数据库中随机返回一个 key。当数据库不为空时，返回一个 key 。当数据库为空时，返回 nil 。

12 .Rename 命令用于修改 key 的名称。改名成功时提示 OK ，失败时候返回一个错误。

13. Renamenx 命令用于在新的 key 不存在时修改 key 的名称。

6.Mget 命令返回所有(一个或多个))给定 key 的值。如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 None

9.Setnx（SET if Not eXists）命令在指定的 key 不存在时，为 key 设置指定的值。设置成功，返回 1 。设置失败，返回 0 。

13. Msetnx 命令用于所有给定 key 都不存在时，同时设置一个或多个 key-value 对。当所有 key 都成功设置，返回 1 。如果所有给定 key 都设置失败(至少有一个 key 已经存在))，那么返回 0 。

3. Hexists 命令用于查看哈希表的指定字段是否存在。如果哈希表含有给定字段，返回 True 。如果哈希表不含有给定字段，或 key 不存在，返回False 。

8.Hkeys 命令用于获取哈希表中的所有字段名。包含哈希表中所有字段的列表。当 key 不存在时，返回一个空列表。

9. Hlen 命令用于获取哈希表中字段的数量。哈希表中字段的数量。当 key 不存在时，返回 0 。

13 Hvals 命令返回哈希表所有字段的值。一个包含哈希表中所有值的表。当 key 不存在时，返回一个空表。

1. Lpush 命令将一个或多个值插入到列表头部。如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。执行 LPUSH 命令后，列表的长度。

2.Rpush 命令用于将一个或多个值插入到列表的尾部(最右边))。如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。当列表存在但不是列表类型时，返回一个错误。执行 RPUSH 操作后，列表的长度。

8.Llen 命令用于返回列表的长度。如果列表 key 不存在，则 key 被解释为一个空列表，返回 0 。如果 key 不是列表类型，返回一个错误。

9.Lpop 命令用于移除并返回列表的第一个元素。列表的第一个元素。当列表 key 不存在时，返回 None 。

15.Rpop 命令用于移除并返回列表的最后一个元素。列表的最后一个元素。当列表不存在时，返回 None 。

2.Scard 命令返回集合中元素的数量。集合的数量。当集合 key 不存在时，返回 0 。

5.Sinter 命令返回给定所有给定集合的交集。不存在的集合 key 被视为空集。当给定集合当中有一个空集时，结果也为空集(根据集合运算定律))。

7.Sismember 命令判断成员元素是否是集合的成员。如果成员元素是集合的成员，返回 1 。如果成员元素不是集合的成员，或 key 不存在，返回 0 。

8.Smembers 命令返回集合中的所有的成员。不存在的集合 key 被视为空集合。

2.Zcard 命令用于计算集合中元素的数量。当 key 存在且是有序集类型时，返回有序集的基数。当 key 不存在时，返回 0 。

10.Zrank 返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大))顺序排列。如果成员是有序集 key 的成员，返回 member 的排名。如果成员不是有序集 key 的成员，返回 None 。

17. Zrevrank 命令返回有序集中成员的排名。其中有序集成员按分数值递减(从大到小))排序。排名以 0 为底，也就是说，分数值最大的成员排名为 0 。使用 ZRANK 命令可以获得成员按分数值递增(从小到大))排列的排名。

18.Zscore 命令返回有序集中，成员的分数值。如果成员元素不是有序集 key 的成员，或 key 不存在，返回 None 。