python 操作redis数据库
一、安装redis-py：
首先要有一台启动的redis服务器，接下来进入本机的虚拟环境，可以使用命令进行安装：
-
使用：
pip install redis命令进行安装
1.1：redis连接：
StrictRedis跟Redis的区别在于，StrictRedis用于实现大部分官方命令，并使用官方的语法和命令，Redis是StrictRedis的子类，兼容一些老版本。
Redis连接实例是线程安全的，可以直接将redis连接实例设置为一个全局变量，直接使用。
-
举个栗子：
import redis # 导入安装的redis包 r = redis . StrictRedis ( host = '127.0.0.1' , port = 6379 , db = 0 ) # 指定 IP 地址、端口、指定存放数据库 # 如果指定一些其他参数，可以看源码，将需要的参数进行指定。import redis r = redis . Redis ( host = 'localhost' , port = 6379 , db = 0 )
1.2：连接池：
redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。每个redis实例都会维护一个自己的连接池。
可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。
-
举个栗子：
# 导入redis模块 import redis pool = redis . ConnectionPool ( host = 'localhost' , port = 6379 , decode_responses = True ) r = redis . Redis ( connection_pool = pool )
二、字符串(String)相关操作：
| 方法 | 简介 |
|---|---|
| set() | 设置键值 |
| setnx() | name不存在才会执行 |
| setex() | 设置值过期时间(秒) |
| psetex() | 设置值过期时间(毫秒) |
| strlen() | 获取name对应值的字节长度 |
| get() | 获取值 |
| getset() | 更新值 |
| mset() | 设置多个值 |
| mget() | 获取多个值 |
| getrange() | 获取子序列 |
| setrange() | 修改字符串内容 |
| incr() | value(整数)自增 |
| incrbyfloat() | value(浮点数)自增 |
| decr() | value(整数)自减 |
| append() | 追加字符串 |
2.1、set()：
result
=
r
.
set
(
'key'
,
'value: hello redis'
)
# key 代表是键 value
:
hello redis 代表是值
print result # 打印结果：True 说明设置成功
字符串操作，redis中的String再内存中按照一个
name对应一个value
来存储。
set(name, value, ex=None, px=None, nx=False, xx=False)
-
再Redis中设置值，不存在则创建、存在即修改
-
参数：
ex：过期时间(秒)
px：过期时间(毫秒)
nx：如果为True，当name不存在时，当前set操作会执行
xx：如果为True，当name存在时，当前set操作会执行
2.1.1：ex-过期时间(单位:秒)：
# ex
:
设置过期时间
(
单位
:
秒
)
'name'
为Key
'fe_cow'
为value
r
.
set
(
'name'
,
'fe_couw'
,
ex
=
3
)
# 输出结果：fe_cow 但是
3
秒后 输出结果：None
print r
.
get
(
'name'
)
2.1.2：px-过期时间(单位:毫秒)
# px
:
设置过期时间
(
单位
:
豪秒
)
'name'
为Key
'fe_cow'
为value
r
.
set
(
'name'
,
'fe_couw'
,
ex
=
3
)
# 输出结果：fe_cow 但是
3
豪秒后 输出结果：None
print r
.
get
(
'name'
)
2.1.3：nx：
’name’不存在，set才会执行
# 若Redis数据库中没有name
=
'name'
print r
.
set
(
'name'
,
'fe_cow'
,
nx
=
True
)
# 输出结果： True 说明
set
设置成功
# 若再执行一次
,
因redis数据库中已经存在name
=
'name'
print r
.
set
(
'name'
,
'fe_cow'
,
nx
=
True
)
# 输出结果：None 说明
set
设置失败
,
没有重复添加
2.1.4：xx:
’name’存在，set才会执行
# 若redis数据库中存在name
=
'name'
print r
.
set
(
'name'
,
'fe_cow'
,
xx
=
True
)
# 输出结果：True 设置成功
,
看到数据库中有追加一条相同信息
# 若redis数据库中不存在name
=
'nickname'
print r
.
set
(
'nickname'
,
'fe_cow'
,
xx
=
True
)
# 输出结果
:
None 说明
set
失败
2.2、setnx(name, value)：
name不存在才会执行
# 若redis数据库中不存在name
=
'nickname'
print r
.
setnx
(
'nickname'
,
'fecow'
)
# 输出结果： True 添加成功
2.3、setex(name, time, value)：
设置值与过期时间
# name
=
'age'
5
代表过期时间
(
单位：秒
)
value
=
'18'
r
.
setex
(
'age'
,
5
,
'18'
)
# 输出结果：
'18'
5
秒过后 输出结果： None
print r
.
get
(
'age'
)
2.4、psetex(name, time_ms, value)：
设置值与过期时间(毫秒)
# name
=
'mobile'
value
=
'130xxxxxx'
50
代表过期时间
(
单位毫秒
)
r
.
psetex
(
'mobile'
,
50
,
'130xxxxxx'
)
# 输出结果：
'130xxxxxx'
50
毫秒过后输出结果为
:
None
print r
.
get
(
'mobile'
)
2.5、strlen(name):
获取name对应值的字节长度
# 获取name
=
'title'
所对应的value
(
gold
)
长度
print r
.
strlen
(
'title'
)
# 输出结果
:
4
# 获取name
=
'detail'
,
所对应的value
(
'详情信息'
)
长度
print r
.
strlen
(
'detail'
)
# 输出结果：
12
一个汉字
=
3
个字节
2.6、get-获取值：
result
=
r
.
get
(
'key'
)
# 获取键的名字
print result # 打印结果：value
:
hello redis 是键对应的值
2.7、getset(name, value)：
设置新值并获取原来的值：
# 找到redis 数据库中name
=
'mobile'
将它的value 替换成
'131xxxxx'
，相当于update
(
)
操作
r
.
getset
(
'mobile'
,
'131xxxxx'
)
print r
.
get
(
'mobile'
)
# 输出结果：
131
xxxxx
2.8、mset(**kw):
设置多个键值：
# 可以准备一个字典
,
每个键对应的值，进行批量添加
mset_dict
=
{
'key1'
:
'value1'
,
'key2'
:
'value2'
}
result
=
r
.
mset
(
mset_dict
)
print result # 打印结果：True 设置多个键值成功
2.9、mget(**kw)
获取多个键值
# mget接收的参数
,
是多个key；如：
'key1'
,
'key2'
mget_list
=
[
'key1'
,
'key2'
]
result
=
r
.
mget
(
mget_list
)
print result # 打印结果：
[
'value1'
,
'value2'
]
是每个键所对应的值，返回一个列表
2.10、getrange(key, start, end):
获取子序列(根据字节获取,非字符)
一个汉字3个字节 1个字母一个字节 每个字节8bit
-
参数：
name：redis的name
start：起始位置(字节)
end：结束位置(字节)
-
举个汉字栗子：
r . set ( 'detail' , '详情信息' ) # 取索引号是 0 - 2 前 3 位字节 print r . getrange ( 'detail' , 0 , 2 ) # 输出结果：详 # 取所有的信息 print r . getrange ( 'detail' , 0 , - 1 ) # 输出结果：详情信息 -
举个字母栗子：
r . set ( 'title' , 'good' ) print r . getrange ( 'title' , 0 , 2 ) # 输出结果：goo print r . getrange ( 'title' , 0 , - 1 ) # 输出结果：good
2.11、setrange(name, offset, value):
修改字符串内容，从指定字符串索引开始向后替换(新值过长时，向后添加)
-
参数：
offset：字符串索引
value：要设置的值
# 原 'title' 所对应的值： 'good' ，将索引位置 1 开始 , 替换成 'old' r . setrange ( 'title' , 1 , 'old' ) # 输出结果： 'gold' print r . get ( 'title' )
2.12、incr(name, amount=1)：
自增name对应的值，当name不存在时，创建name=amount，存在则自增
-
参数：
name：redis的name
amount：自增数(必须是整数)
# 自增name = 'incr' 每次自增 + 1 r . incr ( 'incr' , amount = 1 ) print r . get ( 'incr' ) # 输出结果： + 1 -
应用场景：记录页面的点击次数。
2.13、incrbyfloat(name, amount=1.0):
自增name对应得值，当name不存在时，创建name=amount，存在则自增
-
参数：
name：redis的name
amount：自然数(浮点数)
# 设置name = 'num' r . set ( 'num' , '0.00' ) print r . get ( 'num' ) # 输出结果： 0.00 # 自增浮点数 r . incrbyfloat ( 'num' , amount = 1.0 )
2.14、decr(name, amout=1):
自减name对应的值，当name不存在时，创建name=amount，存在则自增
-
参数：
name：redis的name
amount：自减数(整数)
# 先查询name = 'num' 是否存在 , 若存在 将对应的value 自减 1 ，不存在创建 r . decr ( 'num' , amount = 1 ) print r . get ( 'num' ) # 输出结果： - 1
2.15、append(key, value):
再redis name对应的值后面追加内容
-
参数：
key：redis的name
value：追加的字符串
# 原name = 'name' 对应的value = 'fe_cow' r . append ( 'name' , 'au_cow' ) print r . mget ( 'name' ) # 输出结果： [ 'fe_cowau_cow' ] 将value 拼接再一起
三、列表(List)相关操作：
| 方法 | 简介 |
|---|---|
| lpush() | 增加（从左边新加，不存在就新建） |
| rpush() | 增加（从右边新增加，不存在就新建） |
| llen() | 获取列表长度 |
| lpushx() | 已经有的name的列表的左边添加元素，没有的话无法创建 |
| rpushx() | 已经有的name的列表的右边添加元素，没有的话无法创建 |
| linsert() | 新增（固定索引号位置插入元素） |
| lset() | 修改（指定索引号进行修改） |
| lrem() | 删除（指定值进行删除） |
| lpop()/rpop() | 删除并返回 |
| ltrim() | 删除索引之外的值 |
| lindex() | 取值（根据索引号取值 ） |
| brpoplpush() | 移动 （元素从一个列表移动到另外一个列表 可以设置超时 ） |
3.1、lpush(name, values):
从左边新增加，不存在就新建
# 往name
=
'list'
中从左添加value
=
[
11
,
22
,
33
]
r
.
lpush
(
'list'
,
11
,
22
,
33
)
print r
.
lrange
(
'list'
,
0
,
-
1
)
# 输出结果：
[
'33'
,
'22'
,
'11'
]
保存顺序为
33
，
22
，
11
3.2、rpush(name, values):
从右边新增加，不存在就新建
# name
=
'list1'
中从右添加value
=
[
66
,
55
,
44
]
r
.
rpush
(
'list1'
,
66
,
55
,
44
)
print r
.
lrange
(
'list1'
,
0
,
-
1
)
# 输出结果：
[
'66'
,
'55'
,
'44'
]
3.3、llen(name):
获取列表长度
# 获取name
=
'list1'
列表中的长度 value
=
[
66
,
55
,
44
]
print r
.
llen
(
'list1'
)
# 输出结果：
3
3.4、lpushx(name, value):
往已经有的name的列表的左边添加元素，没有的话无法创建
# 首先redis数据库中没有name
=
'list2'
r
.
lpushx
(
'list2'
,
10
)
print r
.
lrange
(
'list2'
,
0
,
-
1
)
# 输出结果：
[
]
3.5、rpushx(name, value):
往已经有的name的列表的右边添加元素，没有的话无法创建
# 首先redis数据库中没有name
=
'list2'
r
.
rpushx
(
'list2'
,
10
)
print r
.
lrange
(
'list2'
,
0
,
-
1
)
# 输出结果：
[
]
3.6、linsert(name, where, refvalue, value):
在name对应的列表的某一个值前或后插入一个新值
-
参数：
name：redis的name
where：BEFORE或AFTER
refvalue：标杆值 (以它为基础, 前后插入新值)
value：要插入的数据
# 往列表中左边第一个出现的元素 "66" 前插入元素 "77" , 若name不存在 , 不会新创建 , 会返回 [ ] r . linsert ( 'list1' , 'before' , '66' , '77' ) # 目前数据库list1 = [ 66 , 55 , 44 ] print r . lrange ( 'list1' , 0 , - 1 ) # 输出结果： [ '77' , '66' , '55' , '44' ]
3.7、lset(name, index, value)：
对name对应的list中的某一个索引位置重新赋值
-
参数：
name：redis的name
index：list的索引位置
value：要设置的新值
# 将list1中索引为 3 , 替换成 '33' , list1 = [ '77' , '66' , '55' , '44' ] r . lset ( 'list1' , 3 , '33' ) print r . lrange ( 'list1' , 0 , - 1 ) # 输出结果 : [ '77' , '66' , '55' , '33' ]
3.8、lrem(name, value, num):
name对应的list中删除指定的值
-
参数：
name：redis的name
value：要删除得值
num：num=0，删除列表中所有的值
num=2，从前向后，删除2个；
num=-2， 从后向前，删除2个；
# list1 = [ '77' , '66' , '55' , '33' ] # 从左向右 , 找到value = '66' 删除一个 r . lrem ( "list1" , 1 , "66" ) print r . lrange ( 'list1' , 0 , - 1 ) # 输出结果： [ '77' , '55' , '33' ] # list1 = [ '77' , '55' , '33' ] # 从右向左 , 找到value = '55' , 删除一个 r . lrem ( 'list1' , - 1 , '55' ) print r . lrange ( 'list1' , 0 , - 1 ) # 输出结果： [ '77' , '33' ] # list1 = [ '77' , '77' , '33' ] # 删除name = 'list1' 中 value = '77' 的所有值 r . lrem ( 'list1' , 0 , '77' ) print r . lrange ( 'list1' , 0 , - 1 ) # 输出结果：
3.9、lpop(name) 、rpop(name):
在name对应的列表的左侧/右侧获取第一个元素并在列表中移除，返回值则是第一个元素
# list1
=
[
'77'
,
'66'
,
'55'
]
result
=
r
.
lpop
(
'list1'
)
print result # 输出结果：
77
print r
.
lrange
(
'list1'
,
0
,
-
1
)
# 输出结果：
[
'66'
,
'55'
]
# list1
=
[
'66'
,
'55'
]
result
=
r
.
rpop
(
'list1'
)
print result # 输出结果：
55
print r
.
lrange
(
'list1'
,
0
,
-
1
)
# 输出结果：
[
'66'
]
3.10、ltrim(name, start, end):
name对应的列表中移除没有在start-end索引之间的值
-
参数：
name：redis的name
start：索引的起始位置
end：索引的结束位置
# list1 = [ '77' , '66' , '55' , '44' , '33' ] # 删除name = 'list1' 中 , 不包含索引 0 - 2 的value r . ltrim ( 'list1' , 0 , 2 ) print r . lrange ( 'list1' , 0 , - 1 ) # 输出结果： [ '77' , '66' , '55' ]
3.11、lindex(name, index):
在name对应的列表中根据索引获取列表元素
# list1
=
[
'77'
,
'66'
,
'55'
]
# 取出name
=
'list1'
中索引为
1
的值
print r
.
lindex
(
'list1'
,
1
)
# 输出结果：
66
3.12、brpoplpush(src, dst, timeout=0):
从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
-
参数：
src：取出并要移除元素的列表对应的name
dst：要插入元素的列表对应的name
timeout：当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
# list = [ '33' , '22' , '11' ] # list1 = [ '77' , '66' , '55' ] # 将name = 'list1' 中的Value 全部插入到name = 'list' 中 r . brpoplpush ( 'list1' , 'list' , timeout = 2 ) print r . lrange ( 'list' , 0 , - 1 ) # 输出结果： [ '77' , '66' , '55' , '33' , '22' , '11' ]
四、集合(Set)相关操作：
| 方法 | 简介 |
|---|---|
| sadd() | 新增 |
| scard() | 获取元素个数 |
| smembers() | 获取集合中所有成员 |
| sscan() | 获取集合中所有成员(元组形式) |
| sscan_iter() | 获取集合中所有成员(迭代器的方式) |
| sdiff() | 差集 |
| sdiffstore() | 差集–差集存在一个新的集合中 |
| sinter() | 交集 |
| sinterstore() | 交集–交集存在一个新的集合中 |
| sunion() | 并集 |
| sunionstore() | 并集–并集存在一个新的集合 |
| sismember() | 判断value是否存在name中 |
| smove() | 移动 |
| spop() | 删除–随机删除并且返回被删除值 |
| srem() | 删除–指定值删除 |
4.1、sadd(name, values)：
name对应的集合中添加元素
# 往集合中添加元素 name
=
'set1'
r
.
sadd
(
'set1'
,
1
,
2
,
3
,
4
,
5
,
6
)
print r
.
smembers
(
'set1'
)
# 输出结果
:
set
(
[
'1'
,
'3'
,
'2'
,
'5'
,
'4'
,
'6'
]
)
4.2、scard(name):
name对应集合中元素个数
#
'set1'
=
set
(
[
'1'
,
'3'
,
'2'
,
'5'
,
'4'
,
'6'
]
)
print r
.
scard
(
'set1'
)
# 输出结果：
6
4.3、smembers(name):
name对应的集合所有成员
# 获取name
=
'set1'
中的所有values值
print r
.
smembers
(
'set1'
)
# 输出结果
:
set
(
[
'1'
,
'3'
,
'2'
,
'5'
,
'4'
,
'6'
]
)
4.4、sscan(name, cursor=0, match=None, count=None):
name对应集合所有成员(元组形式)
print r
.
sscan
(
'set1'
)
#
输出结果：
(
0
L
,
[
'1'
,
'2'
,
'3'
,
'4'
,
'5'
,
'6'
]
)
4.5、sscan_iter(name, match=None, count=None):
name对应集合所有成员(迭代器的方式)
for
item
in
r
.
sscan_iter
(
'set1'
)
:
print item
# 输出结果如下：
1
2
3
4
5
6
4.6、sdiff(key, *args)：
求集合中的差集
# name是set1、set2中values的值
# set1
=
set
(
[
'1'
,
'3'
,
'2'
,
'5'
,
'4'
,
'6'
]
)
# set2
=
set
(
[
'8'
,
'5'
,
'7'
,
'6'
]
)
# 在集合set1中但是不在集合set2中的values值
print r
.
sdiff
(
'set1'
,
'set2'
)
# 输出结果
:
set
(
[
'1'
,
'3'
,
'2'
,
'4'
]
)
# 在集合set2中但是不在集合set1中的values值
print r
.
sdiff
(
'set2'
,
'set1'
)
# 输出结果：
set
(
[
'8'
,
'7'
]
)
4.7、sdiffstore(dest, keys, *args)：
将两个集合中的差集，存储到第三个集合中
# 在集合set1但是不再集合set3中的values值
,
存储到set3集合中
r
.
sdiffstore
(
'set3'
,
'set1'
,
'set2'
)
print r
.
smembers
(
'set3'
)
# 输出结果：
set
(
[
'1'
,
'3'
,
'2'
,
'4'
]
)
4.8、sinter(keys，*args)：
获取两个集合中的交集
# set1
=
set
(
[
'3'
,
'5'
,
'6'
]
)
# set2
=
set
(
[
'8'
,
'5'
,
'4'
,
'7'
,
'6'
]
)
# 求集合set1与set2的交集
print r
.
sinter
(
'set1'
,
'set2'
)
# 输出结果：
set
(
[
'5'
,
'6'
]
)
4.9、sinterstore(dest, keys, *args)：
将两个集合中的交集，存储到第三个集合中
# 将set1与set2的交集，存储到set3中
print r
.
sinterstore
(
'set3'
,
'set1'
,
'set2'
)
# 输出结果：
2
说明存储进去两个
print r
.
smembers
(
'set3'
)
# 输出结果：
set
(
[
'5'
,
'6'
]
)
4.10、sunion(keys, *args):
获取多个name对应的集合并集
# 获取set1与set2集合中的并集
print r
.
sunion
(
'set1'
,
'set2'
)
# 输出结果：
set
(
[
'1'
,
'3'
,
'2'
,
'5'
,
'4'
,
'7'
,
'6'
,
'8'
]
)
4.11、sunionstore(dest, keys, *args)：
将两个集合中的并集，存储到第三个集合中
# 将set1与set2集合中的并集
,
存储到set3中
print r
.
sunionstore
(
'set3'
,
'set1'
,
'set2'
)
print r
.
smembers
(
'set3'
)
# 输出结果：
set
(
[
'1'
,
'3'
,
'2'
,
'5'
,
'4'
,
'7'
,
'6'
,
'8'
]
)
4.12、sismember(name, value):
判断是否是集合的成员
# 校验value
=
3
是否在name
=
set1集合中
print r
.
sismember
(
'set1'
,
3
)
# 输出结果：True表示在集合中
print r
.
sismember
(
'set1'
,
33
)
# 输出结果： False表示不在集合中
4.13、smove(src, dst, value):
将某个成员从一个集合中移动到另外一个集合
# 目前集合set1、set2中的元素
# set1
=
set
(
[
'1'
,
'3'
,
'2'
,
'5'
,
'4'
,
'6'
]
)
# set2
=
set
(
[
'8'
,
'5'
,
'7'
,
'6'
]
)
# 将set1中的value
=
4
的元素
,
移动到set2集合中
r
.
smove
(
'set1'
,
'set2'
,
4
)
print r
.
smembers
(
'set1'
)
# 输出结果：
set
(
[
'1'
,
'3'
,
'2'
,
'5'
,
'6'
]
)
print r
.
smembers
(
'set2'
)
# 输出结果：
set
(
[
'8'
,
'5'
,
'4'
,
'7'
,
'6'
]
)
4.14、spop(name):
从集合移除一个成员, 并将其返回(集合是无序的，所有移除也是随机的)
# 目前set1集合中元素 set1
=
set
(
[
'1'
,
'3'
,
'2'
,
'5'
,
'6'
]
)
# 随机删除
'set1'
中的Value值
print r
.
spop
(
'set1'
)
# 输出结果：
1
说明删除的个数
print r
.
smembers
(
'set1'
)
# 输出结果：
set
(
[
'3'
,
'2'
,
'5'
,
'6'
]
)
4.15、srem(name, values):
在name对应的集合中删除某些值
# 目前set1
=
set
(
[
'3'
,
'2'
,
'5'
,
'6'
]
)
print r
.
srem
(
'set1'
,
2
)
# 输出结果：
1
print r
.
smembers
(
'set1'
)
# 输出结果：
set
(
[
'3'
,
'5'
,
'6'
]
)
五、有序集合(Set)相关操作：
| 方法 | 简介 |
|---|---|
| zadd() | 新增 |
| zcard() | 获取有序集合元素个数 |
| zrange() | 获取有序集合的所有元素 |
| zrevrange() | 从大到小排序(同zrange，集合是从大到小排序的) |
| zscan() | 获取所有元素–默认按照分数顺序排序 |
| zscan_iter() | 获取所有元素–迭代器 |
| zcount() | name对应的有序集合中分数 在 [min,max] 之间的个数 |
| zincrby () | 自增 |
| zrank() | 获取值的索引号 |
| zrem() | 删除–指定值删除 |
| zremrangebyscore() | 删除–根据分数范围删除 |
| zscore() | 获取值对应的分数 |
-
Set操作，Set集合就是不允许重复的列表，本身是无序的。 -
有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较， 所以，
对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。
5.1、zadd(name, *args, **kwargs)：
在name对应的有序集合中添加元素
# 新建有序集合 name
=
'zset1'
value
=
'n1'
,
'n2'
score
=
'11'
,
'22'
r
.
zadd
(
'zset1'
,
n1
=
11
,
n2
=
22
)
print r
.
zrange
(
'zset1'
,
0
,
-
1
)
# 输出结果：
[
'n1'
,
'n2'
]
显示的是value值
# 新建有序集合 name
=
'zset2'
,
value
=
'm1'
,
'm2'
score
=
'22'
,
'33'
r
.
zadd
(
'zset2'
,
m1
=
22
,
m2
=
33
)
# withscores
=
True 获取有序集合中所有元素和分数
print r
.
zrange
(
'zset2'
,
0
,
-
1
,
withscores
=
True
)
# 输出结果：
[
(
'm1'
,
22.0
)
,
(
'm2'
,
33.0
)
]
5.2、zcard(name):
获取name对应的有序集合元素的数量
# zset2
=
[
(
'm1'
,
22.0
)
,
(
'm2'
,
33.0
)
]
# 获取name
=
'zset2'
中value的个数
print r
.
zcard
(
'zset2'
)
# 输出结果：
2
5.3、zrange( name, start, end, desc=False, withscores=False, score_cast_func=float):
按照索引范围获取name对应的有序集合的元素
-
参数：
name：redis的name
start：有序集合索引起始位置（非分数）
end：有序集合索引结束位置（非分数）
desc：排序规则，默认按照分数从小到大排序
withscores：是否获取元素的分数，默认只获取元素的值
score_cast_func：对分数进行数据转换的函数
5.3.1：zrevrange(name, start, end, withscores=False, score_cast_func=float):
从大到小排序(同zrange，集合是从大到小排序的)
# 仅获取元素、不显示分数
,
分数倒序
print r
.
zrevrange
(
'zset2'
,
0
,
-
1
)
# 输出结果：
[
'm2'
,
'm1'
]
# 获取有序集合中所有元素和分数
,
分数倒序
print r
.
zrevrange
(
'zset2'
,
0
,
-
1
,
withscores
=
True
)
# 输出结果：
[
(
'm2'
,
33.0
)
,
(
'm1'
,
22.0
)
]
5.4、zscan(name, cursor=0, match=None, count=None, score_cast_func=float)：
获取所有元素–默认按照分数顺序排序
# 获取name
=
zset2所有的元素
,
按照分数顺序排序
print r
.
zscan
(
'zset2'
)
#
输出结果：
(
0
L
,
[
(
'm1'
,
22.0
)
,
(
'm2'
,
33.0
)
]
)
5.5、zscan_iter(name, match=None, count=None,score_cast_func=float):
获取所有元素–迭代器
# 遍历迭代器
for
item
in
r
.
zscan_iter
(
'zset2'
)
:
print item
#
输出结果如下：
(
'm1'
,
22.0
)
(
'm2'
,
33.0
)
5.6、zcount(name, min, max)：
获取name对应的有序集合中分数 在 [min,max] 之间的个数
print r
.
zrange
(
'zset2'
,
0
,
-
1
,
withscores
=
True
)
# 输出结果：
[
(
'm1'
,
22.0
)
,
(
'm2'
,
33.0
)
]
print r
.
zcount
(
'zset2'
,
22
,
33
)
# 输出结果：
2
5.7、zincrby(name, value, amount)：
自增name对应的有序集合的name对应分数
# 每次将value
=
'm2'
的分数自增
2
r
.
zincrby
(
'zset2'
,
'm2'
,
amount
=
2
)
print r
.
zrange
(
'zset2'
,
0
,
-
1
,
withscores
=
True
)
# 输出结果：
[
(
'm1'
,
22.0
)
,
(
'm2'
,
39.0
(
m2所对应的分数每次执行
+
2
)
)
]
5.8、zrank(name, value)：
获取某个值在 name对应的有序集合中的索引（从 0 开始）
# name
=
[
(
'm1'
,
22.0
)
,
(
'm2'
,
39.0
)
]
,
value
=
'm2'
所对应的索引是多少
print r
.
zrank
(
'zset2'
,
'm2'
)
# 输出结果：
1
5.9、zrem(name, values)：
删除name对应的有序集合中值是values的成员
# 删除有序集合
'zset2'
中 value
=
'm2'
r
.
zrem
(
'zset2'
,
'm2'
)
print r
.
zrange
(
'zset2'
,
0
,
-
1
,
withscores
=
True
)
# 输出结果：
[
(
'm1'
,
22.0
)
]
5.10、zremrangebyscore(name, min, max)：
根据分数范围删除
# zset1
=
[
(
'n1'
,
11.0
)
,
(
'n2'
,
22.0
)
,
(
'n3'
,
33.0
)
,
(
'n4'
,
44.0
)
,
(
'n5'
,
55.0
)
]
# 删除有序集合
'zset1'
中
,
value范围在
33
-
44
间的值
r
.
zremrangebyscore
(
'zset1'
,
33
,
44
)
print r
.
zrange
(
'zset1'
,
0
,
-
1
,
withscores
=
True
)
# 输出结果：
[
(
'n1'
,
11.0
)
,
(
'n2'
,
22.0
)
,
(
'n5'
,
55.0
)
]
5.11、zscore(name, value)：
获取name对应有序集合中 value 对应的分数
# zset
=
[
(
'n1'
,
11.0
)
,
(
'n2'
,
22.0
)
,
(
'n5'
,
55.0
)
]
# 获取name
=
'zset1'
中value
=
'n1'
所对应的分数
print r
.
zscore
(
'zset1'
,
'n1'
)
# 输出结果：
11.0
六、散列(Hash)相关操作：
| 方法 | 简介 |
|---|---|
| hset() | 修改(单个取出)–没有就新增，有的话就修改 |
| hmset() | 批量增加 |
| hmget() | 批量获取 |
| hgetall() | 取出所有的键值对 |
| hlen() | 得到所有键值对的格式 hash长度 |
| hkeys() | 得到所有的keys |
| hvals() | 得到所有的value |
| hexists() | 判断成员是否存在 |
| hdel() | 删除键值对 |
| hincrby() | 自增自减整数 |
| hscan_iter() | 取值查看–分片读取 |
6.1、hset(name, key, value)：
name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
-
参数：
name：redis的name
key：name对应的hash中的key
value：name对应的hash中的value
# 设置 name = 'hash1' key = 'k1' value = 'v1' r . hset ( 'hash1' , 'k1' , 'v1' ) # 设置 name = 'hash1' key = 'k2' value = 'v2' r . hset ( 'hash1' , 'k2' , 'v2' ) print r . hget ( 'hash1' , 'k1' ) # 输出结果：v1 print r . hget ( 'hash1' , 'k2' ) # 输出结果：v2
6.2、hmset(name, mapping) ：
在name对应的hash中批量设置键值对
-
参数：
name：redis的name
mapping：字段：如{‘k1’: ‘v1’, ‘k2’: ‘v2’}
# 批量设置hash create_k = { 'k2' : 'v2' , 'k3' : 'v3' } r . hmset ( 'hash2' , create_k )
6.3、hmget(name, keys, *args):
在name对应的hash中获取多个key的值
-
参数：
name：redis的name
keys：要获取key集合，如：[‘k1’, ‘k2’, ‘k3’]
*args：要获取key集合，如：‘k1’, ‘k2’, ‘k3’
print r . hmget ( 'hash2' , 'k2' ) # 单个取出 'hash2' 输出结果： [ 'v2' ] print r . hmget ( 'hash2' , 'k2' , 'k3' ) # 批量取出 'hash2' , 输出结果： [ 'v2' , 'v3' ] print r . hmget ( 'hash2' , [ 'k2' , 'k3' ] ) # 批量取出 'hash2' , 输出结果： [ 'v2' , 'v3' ]
6.4、hgetall(name)：
获取name对应hash的所有键值
# 获取name
=
'hash2'
全部key
,
value
print r
.
hgetall
(
'hash2'
)
# 输出结果：
{
'k3'
:
'v3'
,
'k2'
:
'v2'
}
6.5、hlen(name) :
获取name对应的hash中键值对的个数
#
'hash2'
=
{
'k3'
:
'v3'
,
'k2'
:
'v2'
}
print r
.
hlen
(
'hash2'
)
# 输出结果：
2
6.6、hkeys(name):
获取name对应的hash中所有的key的值
# 仅获取name
=
'hash2'
取出key的值
print r
.
hkeys
(
'hash2'
)
# 输出结果：
[
'k3'
,
'k2'
]
6.7、hvals(name):
获取name对应的hash中所有的value的值
# 仅获取name
=
'hash2'
,
取出value的值
print r
.
hvals
(
'hash2'
)
# 输出结果：
[
'v3'
,
'v2'
]
6.8、hexists(name, key)：
检查name对应的hash是否存在当前传入的key
print r
.
hexists
(
'hash2'
,
'k4'
)
# 输出结果：False
print r
.
hexists
(
'hash2'
,
'k2'
)
# 输出结果：True
6.9、hdel(name,*keys):
将name对应的hash中指定key的键值对删除
# hash2
=
{
'k3'
:
'v3'
,
'k2'
:
'v2'
}
# 将name
=
'hahs2'
key
=
'k3'
删除
r
.
hdel
(
'hash2'
,
'k3'
)
print r
.
hgetall
(
'hash2'
)
# 输出结果：
{
'k2'
:
'v2'
}
6.10、hincrby(name, key, amount=1):
自增name对应的hash中的指定key的值，不存在则创建key=amount
-
参数：
name：redis的name
key：hash对应的key
amount：自然数(整数)
r . hincrby ( 'hash2' , 'k4' , amount = 1 ) print r . hgetall ( 'hash2' ) # 输出结果： { 'k2' : 'v2' , 'k4' : '2' ( + 1 ) } 如果key不存在 , value默认就是 1
6.11、hscan_iter(name, match=None, count=None):
利用yield封装hscan创建生成器，实现分批去redis中获取数据
-
参数：
match，匹配指定key，默认None 表示所有的key
count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
for item in r . hscan_iter ( 'hash2' ) : print item # 输出结果： # ( 'k2' , 'v2' ) # ( 'k5' , '4' ) # ( 'k4' , '2' ) print r . hscan_iter ( 'hash2' ) # 生成器内存地址 # 输出结果： < generator object hscan_iter at 0x000000000389B2D0 >
七、其他常规操作：
| 方法 | 简介 |
|---|---|
| delete() | 删除 |
| exists() | 检查名字是否存在 |
| expire() | 设置超时时间 |
| rename() | 重命名 |
| type() | 获取类型 |
7.1、delete(*names) :
根据删除redis中的任意数据类型（string、hash、list、set、有序set）
r
.
delete
(
'hash1'
)
# 删除key为
'hash1'
的键值对
7.2、exists(name)：
检测redis的name是否存在，存在就是True，False 不存在
print r
.
exists
(
'hash1'
)
# 输出结果：False 说明key 不存在
print r
.
exists
(
'set1'
)
# 输出结果：True 说明key存在
7.3、expire(name ,time) :
为某个redis的某个name设置超时时间
r
.
lpush
(
'list5'
,
11
,
22
)
r
.
expire
(
'list5'
,
time
=
3
)
print r
.
lrange
(
'list5'
,
0
,
-
1
)
# 输出结果：
[
'22'
,
'11'
]
import
time
time
.
sleep
(
3
)
print r
.
lrange
(
'list5'
,
0
,
-
1
)
# 输出结果：
[
]
7.4、rename(src, dst) ：
对redis的name重命名
r
.
lpush
(
'list5'
,
11
,
22
)
print r
.
rename
(
'list5'
,
'list-5'
)
# 输出结果： True 说明重命名成功
7.5、type(name) :
获取name对应值的类型
print r
.
type
(
'set1'
)
# 输出结果：zset
print r
.
type
(
'zset2'
)
# 输出结果：zset
print r
.
type
(
'list-5'
)
# 输出结果：list
7.6、查看所有元素：
print
(
r
.
hscan
(
"hash"
)
)
print
(
r
.
sscan
(
"set"
)
)
print
(
r
.
zscan
(
"zset"
)
)
print
(
r
.
getrange
(
"string"
,
0
,
-
1
)
)
print
(
r
.
lrange
(
"list"
,
0
,
-
1
)
)
print
(
r
.
smembers
(
"set3"
)
)
print
(
r
.
zrange
(
"zset3"
,
0
,
-
1
)
)
print
(
r
.
hgetall
(
"hash1"
)
)
