Python使用Redis：五类数据类型操作

1、String（字符串）

1.1- set(name, value, ex=None, px=None, nx=False, xx=False)
-- 在redis中设置name对应的值。不存在则创建，存在则修改
-- ex，过期时间（秒）
-- px，过期时间（毫秒）
-- nx，如果设置为True，则只有name不存在时，当前set方法才执行
-- xx，如果设置为True，则只有name存在时，当前set方法才执行

1.2- setnx(name, value)
-- 在redis中设置name对应的值。只有name不存在时，才执行添加

1.3- setex(name, value, time)
-- 在redis中设置name对应的值
-- time，过期时间（数字秒或 timedelta对象）

1.4- psetex(name, value, time_ms)
-- 在redis中设置name对应的值
-- time_ms，过期时间（数字毫秒或 timedelta对象）

1.5- mset(*args, **kwargs)
-- 在redis中批量设置值
-- eg：mset(k1='v1', k2='v2') 或 mget({'k1': 'v1', 'k2': 'v2'})

1.6- get(name)
-- 获取redis中name对应的值

1.7- mget(keys, *args)
-- 批量获取redis中name对应的值
-- keys，redis的name
-- eg：mget('cn-zh', 'chinese') 或 mget(['cn-zh', 'chinese'])

1.8- getset(name, value)
-- 在redis中设置name对应的值并获取原来的值

1.9- getrange(name, start, end)
-- 在redis中截取获得子序列（根据字节获取，非字符）
-- start，字符串中字节的起始位置
-- end，字符串中字节的结束位置
-- eg："文艺青年"，0-3表示 “文”

1.10- setrange(key, offset, value)
-- 修改redis中name对应的字符串内容，从指定字符串索引开始向后替换（新值太长则向后添加）
-- offset，字符串的索引。字节（一个汉字为三个字节）
-- value，要修改的值

1.11- setbit(name, offset, value)
-- 对redis中name对应值的二进制表示位数进行操作
-- offset，二进制位的索引（将值变换成二进制后在进行索引）
-- value，值只能是0或1
-- eg：n1 = "foo" 二进制表示为：01100110 01101111 01101111
所以setbit('n1', 7, 1)表示将二进制后的n1的第7位修改为1，即：01100111 01101111 01101111。转化为字符串则是"goo"

1.12- getbit(name, offset)
-- 获取在redis中name对应的值的二进制表示中的某位的值(0或1)

1.13- bitcount(key, start=None, end=None)
-- 获取在redis中name对应值的二进制表示中 1 的个数
-- keys，redis的name
-- start，位的起始位置
-- end，位的结束位置

1.14- bitop(operation, dest, *keys)
-- 获取多个值，并做位运算，将最后结果保存至新的name对应的值
-- operation，AND(并)、OR(或)、NOT(非)、XOR(异或)
-- dest，新的redis的name
-- *keys，要查找的redis的name
-- eg：bitop("AND", 'new_name', 'n1', 'n2', 'n3')表示获取redis中n1,n2,n3对应的值，所有值做位运算(求并集)，然后将结果保存到new_name对应的值中

1.15- strlen(name)
-- 返回name对应值的字节长度（一个汉字为三个字节）

1.16- incr(name, amount=1)
-- 自增name的对应值，当name不存在时创建name=amount，否则自增
-- amount，自增数(int)

1.17- incrbyfloat(name, amount=1.0)
-- 自增name的对应值，当name不存在时创建name=amount，否则自增
-- amount，自增数(float)

1.18- decr(name, amount=1)
-- 自减name的对应值，当name不存在时创建name=amount，否则自减
-- amount，自减数(int)

1.19- append(key, value)
-- 在redis中name对应值后面追加内容
-- key，redis的name
-- value，要追加的字符串

2、List（列表）

（redis的list在内存中按照一个name对应一个列表来存储）

-- 在name对应的list中从左到右添加新元素
-- ps：rpush(name, values)表示从右到左添加
-- eg：conn.lpush('en', 80,90,10) # 保存顺序：10, 90, 80

2.2- lpushx(name, value)
-- 在name对应的list中添加元素，只当name存在才把元素添加到list最左边
-- ps：rpushx(name, value)表示从右到左添加

2.3- llen(name)
-- name对应的list中元素的个数

2.4- linsert(name, where, refvalue, value)
-- 在name对应的list中的某个元素前或后插入一个新的元素
-- where，前或后
-- refvalue，标识元素。在它前后插入
-- value，要插入的元素

2.5- r.lset(name, index, value)
-- 对name对应的list中的某个索引位置重新赋值
-- index，list中的索引值
-- value，要改变的值

2.6- r.lrem(name, value, num)
-- 在name对应的list中删除指定元素
-- value，要删除的元素
-- num，num=0，删除list中所有指定元素；num=2，从前往后删除2个；num=-2，从后往前删除2个

2.7- lpop(name)
-- 在name对应的list的最左侧获取一个元素并移除，返回该元素
-- ps：rpop(name)表示在最右侧操作执行

2.8- lindex(name, index)
-- 在name对应的list中根据索引获取元素

2.9- lrange(name, start, end)
-- 在name对应的list分片获取数据
-- start，索引起始位置
-- end，索引结束位置

2.10- ltrim(name, start, end)
-- 在name对应的list中，移除不在start到end范围的元素
-- start，索引起始位置
-- end，索引结束位置

2.11- rpoplpush(src, dst)
-- 从某个列表取出最右侧的元素，将其添加到另一个列表的最左侧
-- src，取元素的列表
-- dst，加元素的列表

2.12- brpoplpush(src, dst, timeout=0)
-- 从一个列表的右侧移除一个元素并将其添加到另一个列表左侧
-- src，取出并要移除元素的列表
-- dst，要插入元素的列表
-- timeout，当src对应的list中没有数据时，阻塞等待有数据的超时时间，0表示永远阻塞

2.13- blpop(keys, timeout)
-- 将多个列表排列，按照从左到右去取对应列表的元素
-- keys，redis的name的集合
-- timeout，超时时间，当所有列表的元素都取完后，阻塞等到列表重新有元素的时间，0表示永远阻塞
-- ps：brpop(keys, timeout)表示从右到左取元素

2.14- 自定义增量迭代
-- 由于redis类库中没有提供对列表元素的增量迭代，如果需要循环name对应的list中的所有元素，则需要满足：
-- a、获取name对应的所有列表
-- b、循环列表
-- 但如果列表过大，就应该自定义增量迭代功能

def list_iter(name):
    :param name: 要迭代name对应的list
    :return: yield返回列表元素
    list_count = conn.llen(name)
    for index in range(list_count):
        yield conn.lindex(name, index)
for iter in list_iter('txt'):
    print(item)
3、Hash（哈希）
  -- name为redis中的name

  -- mapping，字典。如：{'k1': 'v1', 'k2': 'v2'}

  -- eg：conn.hmset('cn-zh', {'k1': 'v1', 'k2': 'v2'})
3.3- hget(name, key)

  -- 在name对应的dict中根据key获取value值

  -- eg：conn.hget('cn-zh', 'k1')
3.4- hmget(name, keys, *args)

  -- 在name对应的dict中获取多个key的value值

  -- keys，要获取key集合。如：['k1', 'k2', 'k3']

  -- *args，要获取的key。如：k1, k2, k3

  -- eg：conn.hmget('cn-zh', ['k1', 'k2', 'k3']) 或 conn.hmget('cn-zh', 'k1', 'k2', 'k3')
3.5- hgetall(name)

  -- 获取name对应的dict中所有的键值
3.6- hlen(name)

  -- 获取name对应的dict中键值对的个数
3.7- hkeys(name)

  -- 获取name对应的dict中所有key的值
3.8- hvals(name)

  -- 获取name对应的dict中所有value的值
3.9- hexists(name, key)

  -- 检查name对应的dict是否存在当前传入的key
3.10- hdel(name, *keys)

  -- 把name对应的dict中指定的key的键值对删除
3.11- hincrby(name, key, amount=1)

  -- 自增name对应的hash中指定的key的值，不存在时创建key=amount

  -- key，dict对应的key

  -- amount， 自增数(int)
3.12- hincrbyfloat(name, key, amount=1.0)

  -- 自增name对应的dict中的指定 key的值，不存在时创建key=amount

  -- key，dict对应的key

  -- amount，自增数(float)
3.13- hscan(name, cursor=0, match=None, count=None)

  -- 增量式迭代获取，优势在于数据大。可实现分片的获取数据，非一次全获取完，将内存撑爆

  -- cursor，游标（基于游标分批获取数据）

  -- match，匹配指定key，默认None，表示所有的key

  -- count， 每次分片最少获取的个数，默认None，表示采用Redis的默认分片个数

  -- eg：

cursor1, data1 = conn.hscan('cn-zh', cursor=0, match=None, count=None)

cursor2, data2 = conn.hscan('cn-zh', cursor=cursor1, match=None, count=None)

直到返回值cursor的值为0时，表示数据已通过分片获取结束
3.14- hscan_iter(name, match=None, count=None)

  -- 利用yield封装hscan创建生成器，实现分批到redis中获取数据

  -- match，匹配指定key，默认None，表示所有的key

  -- count，每次分片最少获取的个数，默认None，表示采用redis的默认分片个数

  -- eg：
for item in conn.hscan_item('cn-zh'):print(item)
4、Set（集合），无序不重复
4.1- sadd(name, values)

  -- name对应的集合中添加数据
4.2- scard(name)

  -- 获取name对应集合中元素个数
4.3- sdiff(keys, *args)

  -- 在第一个name对应的集合中，且不在其他name对应的集合的元素集合
4.4- sdiffstore(dest, keys, *args)

  -- 获取第一个name对应的集合中，且不在其他name对应的集合，再将其新加入到dest对应的集合中
4.5- sinter(keys, *args)

  -- 获取多一个name对应的集合的并集
4.6- sinterstore(dest, keys, *args)

  -- 获取多一个name对应集合的并集，再将其加入到dest对应的集合中
4.7- sismember(name, value)

  -- 检查value是否是name对应集合的成员
4.8- smembers(name)

  -- 获取name对应集合的所有成员
4.9- smove(src, dst, value)

  -- 将某个成员从一个集合移动到另一个集合
4.10- spop(name)

  -- 从集合的右侧移除一个成员，并将其返回
4.11- srandmember(name, numbers)

  -- 从name对应集合中随机获取numbers个元素
4.12- srem(keys, *args)

  -- 在name对应集合中删除某些值
4.13- sunion(keys, *args)

  -- 获取多一个name对应集合的并集
4.14- sunionstore(dest, keys, *args)

  -- 获取多一个name对应集合的并集，并将结果保存到dest对应集合中
4.15- sscan(name, cursor=0, match=None, count=None)

  -- 用于增量迭代获取，避免内存消耗太大
4.16- sscan_iter(name, match=None, count=None)

  -- 创建生成器，用于增量迭代分批获取，避免内存消耗太大
5、zset(sorted set：有序集合)，不允许重复
有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。
5.1- zadd(name, *args, **kwargs)

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

  -- eg：zadd('add', 'n1', 1, 'n2', 2) 或 zadd('add', n1=1, n2=2)
5.2- zcard(name)

  -- 获取name对应的有序集合元素的数量
5.3- zcount(name, min, max)

  -- 获取name对应的有序集合中分数 在 [min,max] 之间的个数
5.4- zincrby(name, value, amount)

  -- 自增name对应的有序集合的 name 对应的分数
5.5- zrange(name, start, end, desc=False, withscores=False,

score_cast_func=float)

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

  -- start，有序集合索引起始位置（非分数）

  -- end，有序集合索引结束位置（非分数）

  -- desc，排序规则，默认按照分数从小到大排序

  -- withscores，是否获取元素的分数，默认只获取元素的值

  -- score_cast_func，对分数进行数据转换的函数

  -- 从大到小排序：zrevrange(name, start, end, withscores=False, score_cast_func=float)

  -- 按照分数范围获取name对应的有序集合的元素：zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)

  -- 从大到小：zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
5.6- zrank(name, value)

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

  -- zrevrank(name, value)，从大到小排序
5.7- zrangebylex(name, min, max, start=None, num=None)

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

  -- min，左区间（值）。 + 表示正无限； - 表示负无限； ( 表示开区间； [ 则表示闭区间

  -- min，右区间（值）

  -- start，对结果进行分片处理，索引位置

  -- num，对结果进行分片处理，索引后面的num个元素

  -- eg：

# ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga

# r.zrangebylex('myzset', "-", "[ca") 结果为：['aa', 'ba', 'ca']

  -- 从大到小排序

# zrevrangebylex(name, max, min, start=None, num=None)
5.8- zrem(name, values)

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

  -- eg：zrem('zz', ['s1', 's2'])
5.9- zremrangebyrank(name, min, max)

  -- 根据排行范围删除
5.10- zremrangebyscore(name, min, max)

  -- 根据分数范围删除
5.11- zremrangebylex(name, min, max)

  -- 根据值返回删除
5.12- zscore(name, value)

  -- 获取name对应有序集合中 value 对应的分数
5.13- zinterstore(dest, keys, aggregate=None)

  -- 获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作

  -- aggregate的值为:  SUM  MIN  MAX
5.14- zunionstore(dest, keys, aggregate=None)

  -- 获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作

  -- aggregate的值为:  SUM  MIN  MAX
5.15- zscan(name, cursor=0, match=None, count=None, score_cast_func=float)

  -- 同字符串操作
5.16- zscan_iter(name, match=None, count=None,score_cast_func=float)

  -- 同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作
6、其他操作
6.1- delete(*names)

  -- 根据删除redis中的任意数据类型
6.2- exists(name)

  -- 检测redis的name是否存在
6.3- keys(pattern='')*

  -- 根据模型获取redis的name

 KEYS * 匹配数据库中所有 key 。

 KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。

 KEYS hllo 匹配 hllo 和 heeeeello 等。

 KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo*
6.4- expire(name ,time)

  -- 为某个redis的某个name设置超时时间
6.5- rename(src, dst)

  -- 对redis的name重命名为
6.6- move(name, db)

  -- 将redis的某个值移动到指定的db下
6.7- randomkey()

  -- 随机获取一个redis的name（不删除）
6.8- type(name)

  -- 获取name对应值的类型