Redis数据类型
Redis数据类型
Redis是种key—value的存储系统
Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)
# 字符串（string）
{"key": 123}
# 列表（list）
{"key":[1,2,3]}
# 集合（set）
{"key":{1,2,3}}
# 有序集合（zset）/sorted set
{"key":{("a",20),("b",15)}}
# 哈希（hash）
{"key": {"name":"bxb", "age":18}}
1. String/字符串
String 是 Redis 的基本类型
String类型是二进制的，可以包含任何数据（最大值512M），如图片或者序列化的对象
内存中按 name—value来存储：
| 常用操作 | python命令 | 备注 |
|---|---|---|
| set | set(name, value, ex=None, px=None, nx=False, xx=False) 参数： ex -设置键key的过期时间，单位秒 参数： px milliseconds -设置键key的过期时间，单位毫秒 参数：nx -只有key不存在时才设置key的值 参数：xx -只有ket存在时才设置key的值 例：rdb.set("A", "aa", ex=100) |
设置 name-value，key不存在创建， 存在修改value |
| get | get(name) 例：rdb.get('A') |
获取 name对应的 value，key不存在时返回空 |
| mset | mset(mapping) 例：rdb.mset({"age": 18, "sex": "men"}) |
批量设置值 |
| mget | mget(keys, *args) 例：rdb.mget("age", "sex") 例：rdb.mget(["age", "sex"]) |
批量获取值，输出为数组[18,"men"] |
| getset | getset(name, value) 例：rdb,getset("age", 20) |
设置新值并获取原来的值 |
| getrange | getrange(name, start, end) 例：getrange("sex", 0, 1) 注：start/end均以字节计算 |
获取 name 对应的 value[start, end]的切片, 输出为"me" |
| setrange | setrange(name, offset, value) 例：rdb.setrabfe("sex", 0, "women") 注：offset以字节计算 |
修改 name 对应的 value 值，从指定字符串索引开始向后替换（新值太长时，则覆盖向后添加） |
| getbit | getbit(name, offset) 例：rdb.getbit("sex", 5) 注：offset以字节计算 |
获取 name 对应的 value[offset] 二进制值，输出0/1 |
| setbit | setbit(name, offset, value) 例：rdb.setbit("sex", 5, 1) 注：offset以字节计算 |
修改 name 对应的 value[offset] 二进制值，value只能是0/1 |
| bitcount | bitcount(key, start=None, end=None) 注：start/end均以字节计算 |
获取 key 对应的 value[start, end] 二进制值中 1 的个数 |
| bitop | bitop(operation, dest, *keys) 参数：operation：AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或） 参数：dest：新的Redis的name 参数：*keys：要查找的Redis的name 例：bitop("AND", 'new_name', 'n1', 'n2', 'n3') 例：获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中 |
获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值 |
| strlen | strlen(name) | 返回 name 对应 value 值的字节长度 |
| incr | incr(self, name, amount=1) 参数：amount自增数，整数型 |
自增 name对应的 value 值，当name不存在时，创建name＝amount，否则，则自增。 |
| incrbyfloat | incrbyfloat(self, name, amount=1.0) 参数：amount自增数，浮点型 |
自增 name对应的 value 值，当name不存在时，创建name＝amount，否则，则自增。 |
| decr | decr(self, name, amount=1) 参数：amount自减数，整数型 |
自减 name 对应的 value 值，当name不存在时，则创建name＝amount，否则，则自减。 |
| append | append(key, value) | 在 name 对应 value 值后面追加内容 |
2. List/列表
List 是简单的字符串列表
List 最多可存储 232 - 1 元素
内存中按 key—list 来存储：
| 常用操作 | Python命令 | 备注 |
|---|---|---|
| lpush | lpush(name,values) 例：rdb.lpush("A", 1,2,3) > |
设置 name 对应的 list 中添加新元素，每个元素都会添加到最左边 |
| rpush | rpush(name,values)<b 例：rdb.rpush("B", 4,5) > |
设置 name 对应的 list 中添加新元素，每个元素都会添加到最右边 |
| lpushx(name,value) | ||
| lset | r.lset(name, index, value) 参数：index 列表索引 例：rdb.lset("A", 0, 5) |
修改 name 对应的 list 中的某一个索引位置的值 |
| llen | llen(name) 例：rdb.llen("A") |
获取 name 对应 list 的长度（元素个数） |
| linset | linsert(name, where, refvalue, value)) 参数：where BEFORE或AFTER 参数：refvalue 在它前后插入数据（如果存在多个，以找第一个为准） 例：rdb.linsert('A', 'before', 1, 5) 在[2,1]元素1之前插入5 |
在 name 对应的 list 的某一个值前或后插入一个新值 |
| lindex | lindex(name, index) 例：rdb.lindex("A", 2) |
获取 name 对应 list 中根据索引元素 |
| lpop | lpop(name) 例：rdb.lpop("A") |
获取 name 对应 list 中左侧第一个元素并在列表中移除 |
| rpoplpush | rpoplpush(src, dst) 参数：src 获取数据的name 参数：dst 添加数据的name 例：rdb("A", "B") |
将 src 对应 list 中最右边的元素，添加至 dst 对应 list 的最左边 |
| blpop | blpop(keys, timeout) 参数：keys name集合 参数：timeout 超时时间，所有元素均取完之后，阻塞等待新值，0表示永远阻塞 例：blpop(("A", "B"), 2) |
将多个 list 排列，按照从左到右去pop对应列表的元素 |
| brpop | brpop(keys, timeout) 参数：keys name集合 参数：timeout 超时时间，所有元素均取完之后，阻塞等待新值，0表示永远阻塞 例：blpop(("A", "B"), 2) |
将多个 list 排列，按照从右到左去pop对应列表的元素 |
| lrem | r.lrem(name, value, num) 参数：num 从前向后删除num个value，0代表删除所有value 例：rdb.lrem("A", 5, 3) |
删除 name对 应的 list 中指定的值 |
| ltrim | ltrim(name, start, end) 参数：statr 起始索引 参数：end 结束索引 例：rdb.ltrim("A", 0, -1) |
将 name 对应的 list 没有在start-end索引之间的值移除 |
3. Set/集合
Set 是 string 类型的无序集合
内存中按 key—set 来存储：{"key":{1,2,3}}
| 常用操作 | Python命令 | 备注 |
|---|---|---|
| sadd | sadd(name, values) 例：rdb.sadd("a_name", 7, 8, 9) |
设置 name 对应的 set 中添加元素, 每个元素都在最右边（尾） |
| scard | scard(name) 例：rdb.scard("a_name") |
获取 name 对应 set 中的元素个数 |
| sdiff | sdiff(keys, *args) 例：rdb.sdiff("a_name", "b_name") |
获取第一个 key 对应的 set 元素， 且不在其他 key 对应的 set 中的元素 |
| sdiffstore | sdiffstore(dest, keys, *args) 参数：dest 新集合key 例：rdb.sdiffstore("c_name", "b_name", "a_name") |
获取第一个 key 对应的 set 元素， 且不在其他 key 对应的 set 中的元素，将其加入到新的 dest 对应的集合中 |
| sinter | sinter(keys, *args) rdb.sinter("a_name", "b_name") |
获取多个 key 对应的 set 交集 |
| sinterstore | sinterstore(dest, keys, *args) 参数：dest 新集合key<b 例：rdb.sinterstore("d_name", "a_name", "b_name") |
获取多个 key 对应的 set 交集，将其加入到新的 dest 对应的新集合中 |
| sismember | sismember(name, value) 例：rdb.sismember("a_name", 1) |
判断 name 对用的 set 中是否有 value |
| smembers | smembers(name) 例：rdb.smembers("a_name") |
获取 name 对应 set 的所有元素 |
| smove | smove(src, dst, value) 参数：src 源集合 name 参数：dst 目标集合 name 例子：rdb.smove("a_name", "b_name", 9) |
将 src 对应 set 的中 value， 移动到 dst 对应的 set 中 |
| spop | spop(name) 例：edb.spop("a_name") |
将 name 对应 set 右边（尾）的元素移除，并返回 |
| srandmember | srandmember(name, numbers) 例子：rdb.srandmember("a_name", 5) |
从 name 对应的 set 中随机获取 numbers 个元素 |
| srem | srem(name, values) 例：rdb.srem("a_name", 7, 9) |
删除 name 对应 set 中对应的 values |
| sunion | sunion(keys, *args) 例：rdb.sunion("a_name", "b_name") |
获取多个 key 对应的 set 并集 |
| sunionstore | sunionstore(dest,keys, *args) 例：rdb.sunionstore("a_name", "b_name") |
获取多个 key 对应的 set 并集，将其加入到新的 dest 对应的新集合中 |
| sscan | sscan(name, cursor=0, match=None, count=None) 参数：name 集合键名称 参数：cursor 游标（基于游标取值） 参数：match 匹配指定key， None表示所有key 参数：count 每次且切片最少获取的个数 |
增量式迭代获取，sscan实现分片的获取数据，并非一次性将数据全部获取完，从而防止内存被撑爆 |
| sscan_iter | sscan_iter(name, match=None, count=None) 参数：name 哈希建名称 参数：match 匹配指定key，默认None 表示所有的key 参数：count 每次分片最少获取个数，默认None表示采用Redis的默认分片个数 |
利用yield封装sscan创建生成器，实现分批去redis中获取数据 |
4. zset/有序集合
zset 是 string 类型的无序集合
对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序
内存中按 key—list 来存储：{"key":{("a",20),("b",15)}}
| 命令 | Python操作 | 备注 |
|---|---|---|
| zadd | zadd(name, *args, **kwargs) 例：rdb.zadd("zset_name", {"a":1, "b":3}) |
在 name 对应的 zset 中添加元素 |
| zcard | zcard(name) 例：rdb.zcard("zset_name") |
获取 name 对应的 zset 中的元素个数 |
| zcount | zcount(name, min, max) 例:rdb.zcount("zset_name", 0, 3) |
获取 name 对应的 zset 中分数在 [min, max] 之间元素的个数 |
| zincrby | zincrby(name, amount, value) 参数：amount 自增数 例：rdb.zincrby("zset_name", 5, "a") |
自增 name 对应的 zset 中的 value 的分数 |
| zrange | zrange( name, start, end, desc=False, withscores=False, score_cast_func=float) 参数：name 有序集合键名称 参数：start 有序集合索引起始位置（非分数） 参数：end 有序集合索引结束位置（非分数） 参数：desc 排序规则，默认按照分数从小到大排序 参数：withscores 是否获取元素的分数，默认只获取元素的值 参数：score_cast_func 对分数进行数据转换的函数 例：rdb.zrange('zset_name', 4, 5, desc=False, withscores=True, score_cast_func=float) |
对 name 对应的 zset 按照 desc 规则排序分数之后获取 [start, end] 之间的值 |
| zrevrange | zrevrange(name, start, end, withscores=False, score_cast_func=float) 参数：name 有序集合键名称 参数：start 有序集合索引起始位置（非分数） 参数：end 有序集合索引结束位置（非分数） 参数：withscores 是否获取元素的分数，默认只获取元素的值 参数：score_cast_func 对分数进行数据转换的函数 例：rdb.zrevrange("zset_name", 0,1) |
对 name 对应的 zset 按照从大到小规则排序分数之后获取 [start, end] 之间的值 |
| zrangebyscore | zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float) 参数：name 有序集合键名称 参数：min 最小分数值 参数：max 最大分数值 参数：start 返回结果起始位置 参数：num 返回结果数量 参数：withscores 是否获取元素的分数，默认只获取元素的值 参数：score_cast_func 对分数进行数据转换的函数 例：rdb.zrangebyscore("zset_name", 5, 10, start=2, num=3) 注：获取 zset_name 的 zset 中分数在5~10之间，且从 索引2 开始取值，取3个 |
按照分数范围获取name对应的有序集合的元素，之后按分数从大到小排序 |
| zrevrangebyscore | zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float) 参数：name 有序集合键名称 参数：max 最大分数值 参数：min 最小分数值 参数：start 返回结果起始位置 参数：num 返回结果数量 参数：withscores 是否获取元素的分数，默认只获取元素的值 参数：score_cast_func 对分数进行数据转换的函数 |
按照分数范围获取name对应的有序集合的元素，之后按分数从小到大排序 |
| zrem | zrem(name, values) 例：rdb.zrem("zset_name", "a", "b") |
删除 name 对应 zset 中的 values 元素们 |
| zremrangebyrank | zremrangebyrank(name, min, max) | 根据排行范围删除 |
| zremrangebyscore | zremrangebyscore(name, min, max) | 根据分数范围删除 |
| zremrangebylex | zremrangebylex(name, min, max) | 根据值返回删除 |
| zscore | zscore(name, value) | 获取name对应 zset 中 value 对应的分数 |
| zinterstore | zinterstore(dest, keys, aggregate=None) 参数：aggregate的值为: SUM MIN MAX |
获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作 |
| zunionstore | zunionstore(dest, keys, aggregate=None) 参数：aggregate的值为: SUM MIN MAX |
获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作 |
| zscan | zscan(name, cursor=0, match=None, count=None, score_cast_func=float) 参数：name 哈希建名称 参数：cursor 游标（基于游标分批取获取数据） 参数：match 匹配指定key，默认None 表示所有的key 参数：count 每次分片最少获取个数，默认None表示采用Redis的默认分片个数 参数：score_cast_func 对分数进行数据转换的函数 |
增量式迭代获取，zscan实现分片的获取数据，并非一次性将数据全部获取完，从而防止内存被撑爆 |
| zscan_iter | zscan_iter(name, match=None, count=None,score_cast_func=float) 参数：name 哈希建名称 参数：match 匹配指定key，默认None 表示所有的key 参数：count 每次分片最少获取个数，默认None表示采用Redis的默认分片个数 参数：score_cast_func 对分数进行数据转换的函数 |
利用yield封装zscan创建生成器，实现分批去redis中获取数据 |
5. Hash/哈希
Hash 是一个 string 类型的 field 和 value 的映射表
内存中按 key—dict 存储：{"key": {"name":"A", "age":18}}
| 命令 | Python操作 | 备注 |
|---|---|---|
| hset | hset(name, key, value) 例：rdb.hset("h_name", "age", 18) |
name 对应的 hash中 设置一个键值对（不存在创建，存在修改） |
| hmset | hmset(name, mapping) 例：rdb.hmset("h_name", {"sex": "man"}) |
在 name 对应的 hash 中批量设置键值对 |
| hget | hget(name,key) 例：rdb.hget("h_name", "age") |
在 name 对应的 hash 中获取根据 key 获取 value |
| hmget | hmget(name, keys, *args) 例：rdb.hmget("h_name", "age", "sex") 例：rdb.hmget("h_mange", ["age", "sex"]) |
在 name 对应的 hash 中获取多个 key 的值 |
| hgetall | hgetall(name) 例：rdb.hegtall("h_name") |
获取 name 对应的 hash 中所有的键值 |
| hlen | hlen(name) 例：rdb.hlen("h_name") |
获取 name 对应的 hash 中键值对的个数 |
| hkeys | hkeys(name) 例：rdb.hkeys("h_name") |
获取 name 对应 hash 中所有 keys |
| hvals | hvals(name) 例：rdb.hvals("h_name") |
获取 name 对应 hash 中所有的 values |
| hexists | hexists(name, key) 例：rdb.hexists("h_name", "name") |
判断 name 对应 hash 中是否有 key |
| hdel | hdel(name,*keys) 例：rdb.hdel("h_name", "name", "age") |
删除 name 对应 hash 中指定的键值对 |
| hincrby | hincrby(name, key, amount=1) 参数：amount 自增数（整型） 例：rdb.hincrby("dic_name", "age", amount=10) |
自增 name 对应 hash 中， key 对应的值（不存在创建key=amoount） |
| hincrbyfloat | hincrbyfloat(name, key, amount=1.0) 参数：amount 自增数（浮点型） 例：rdb.hincrbyfloat("h_name", "age", amount=2.0) |
自增 name 对应 hash 中， key 对应的值（不存在创建key=amoount） |
| hscan | hscan(name, cursor=0, match=None, count=None) 参数：name 哈希建名称 参数：cursor 游标（基于游标分批取获取数据） 参数：match 匹配指定key，默认None 表示所有的key 参数：count 每次分片最少获取个数，默认None表示采用Redis的默认分片个数 注意：返回结果为cursor， data；当cursor为0是，表示数据获取完毕 |
增量式迭代获取，hscan实现分片的获取数据，并非一次性将数据全部获取完，从而防止内存被撑爆 |
| hscan_iter | hscan_iter(name, match=None, count=None) 参数：name 哈希建名称 参数：match 匹配指定key，默认None 表示所有的key 参数：count 每次分片最少获取个数，默认None表示采用Redis的默认分片个数 |
利用yield封装hscan创建生成器，实现分批去redis中获取数据 |
