文章目录
python操作redis数据库需要安装一下库
pip install redis
可以通过pip list 查看是否已经安装
操作步骤
#导入包
import redis
#链接数据库
#指定IP地址、端口、指定存放数据库 这里使用的是第一个数据库，redis共16个数据库，序号0-15
conn = redis.StrictRedis(host='127.0.0.1', port=6379, db=0)
#连接池
#redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。每个redis实例都会维护一个自己的连接池。
#可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。
pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
conn = redis.Redis(connection_pool=pool)
1. 链接数据库，使用第三个数据库
import pymysql
#链接数据库decode_responses=True 表示解码可辨识中文，否则是二进制的数据
my_conn = redis.StrictRedis(host='127.0.0.1', port=6379, db=2, decode_responses=True)
2使用redis命令
string字符串操作
set()命令
字符串操作，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操作会执行
-
ex-过期时间(单位:秒)：
# ex: 设置过期时间(单位:秒) 'name'为Key 'fe_cow' 为value my_conn.set('name', 'fe_couw', ex=3) # 输出结果：fe_cow 但是3秒后 输出结果：None print(my_conn.get('name')) -
px-过期时间(单位:毫秒)
# px: 设置过期时间(单位:豪秒) 'name'为Key 'fe_cow' 为value my_conn.set('name', 'fe_couw', ex=3) # 输出结果：fe_cow 但是3豪秒后 输出结果：None print(my_conn.get('name')) -
nx：’name’不存在，set才会执行
# 若Redis数据库中没有name='name' print(my_conn.set('name', 'fe_cow', nx=True)) # 输出结果： True 说明set设置成功 # 若再执行一次, 因redis数据库中已经存在name='name' print(my_conn.set('name', 'fe_cow', nx=True)) # 输出结果：None 说明set设置失败, 没有重复添加 -
xx:’name’存在，set才会执行
# 若redis数据库中存在name='name' print(my_conn.set('name', 'fe_cow', xx=True)) # 输出结果：True 设置成功, 看到数据库中有追加一条相同信息 # 若redis数据库中不存在name='nickname' print(my_conn.set('nickname', 'fe_cow', xx=True)) # 输出结果: None 说明set 失败 -
setnx(name, value)：name不存在才会执行
# 若redis数据库中不存在name='nickname' print(my_conn.setnx('nickname', 'fecow')) # 输出结果： True 添加成功 -
setex(name, time, value)：设置值与过期时间
# name='age' 5代表过期时间(单位：秒) value='18' my_conn.setex('age', 5, '18') # 输出结果： '18' 5秒过后 输出结果： None print(my_conn.get('age')) -
psetex(name, time_ms, value)：设置值与过期时间(毫秒)
# name='mobile' value='130xxxxxx' 50代表过期时间(单位毫秒) my_conn.psetex('mobile', 50, '130xxxxxx') # 输出结果：'130xxxxxx' 50毫秒过后输出结果为: None print(my_conn.get('mobile')) -
strlen(name):获取name对应值的字节长度
# 获取name='title' 所对应的value(gold)长度 print(my_conn.strlen('title')) # 输出结果: 4 # 获取name='detail', 所对应的value('详情信息')长度 print(my_conn.strlen('detail')) # 输出结果： 12 一个汉字=3个字节get()命令
get()命令
-
get-获取值：
result = my_conn.get('key') # 获取键的名字 print(result) # 打印结果：value: hello redis 是键对应的值 -
getset(name, value)：设置新值并获取原来的值：
# 找到redis 数据库中name='mobile' 将它的value 替换成'131xxxxx'，相当于update()操作 my_conn.getset('mobile', '131xxxxx') print(my_conn.get('mobile')) # 输出结果： 131xxxxx -
mset(**kw):设置多个键值：
# mget接收的参数, 是多个key；如：'key1', 'key2' mget_list = ['key1', 'key2'] result = my_conn.mget(mget_list) print(result) # 打印结果：['value1', 'value2'] 是每个键所对应的值，返回一个列表 -
getrange(key, start, end):
获取子序列(根据字节获取,非字符)一个汉字3个字节 1个字母一个字节 每个字节8bit
参数：
name：redis的name
start：起始位置(字节)
end：结束位置(字节)
#汉子的获取 my_conn.set('detail', '详情信息') # 取索引号是0-2 前3位字节 print(my_conn.getrange('detail', 0, 2)) # 输出结果：详 # 取所有的信息 print(my_conn.getrange('detail', 0, -1)) # 输出结果：详情信息 #字母的获取 my_conn.set('title', 'good') print(my_conn.getrange('title', 0, 2)) # 输出结果：goo print(my_conn.getrange('title', 0, -1)) # 输出结果：good -
setrange(name, offset, value):
修改字符串内容，从指定字符串索引开始向后替换(新值过长时，向后添加)参数：
offset：字符串索引
value：要设置的值
# 原'title'所对应的值：'good'，将索引位置1开始, 替换成'old' my_conn.setrange('title', 1, 'old') # 输出结果：'gold' print(my_conn.get('title')) -
incr(name, amount=1)：
自增name对应的值，当name不存在时，创建name=amount，存在则自增参数：
name：redis的name
amount：自增数(必须是整数)
# 自增name='incr' 每次自增 +1 my_conn.incr('incr', amount=1) print(my_conn.get('incr')) # 输出结果：+1应用场景：记录页面的点击次数。
-
incrbyfloat(name, amount=1.0):
自增name对应得值，当name不存在时，创建name=amount，存在则自增参数：
name：redis的name
amount：自然数(浮点数)
# 设置name='num' my_conn.set('num', '0.00') print(my_conn.get('num')) # 输出结果：0.00 # 自增浮点数 my_conn.incrbyfloat('num', amount=1.0) -
decr(name, amout=1):
自减name对应的值，当name不存在时，创建name=amount，存在则自减参数：
name：redis的name
amount：自减数(整数)
# 先查询name='num' 是否存在, 若存在 将对应的value 自减 1 ，不存在创建 my_conn.decr('num', amount=1) print(my_conn.get('num')) # 输出结果： -1
append()指令
-
append(key, value):
再redis name对应的值后面追加内容参数：
key：redis的name
value：追加的字符串
# 原name='name' 对应的value='fe_cow' my_conn.append('name', 'au_cow') print(my_conn.mget('name')) # 输出结果：['fe_cowau_cow'] 将value 拼接再一起
List列表操作
| 方法 | 简介 |
|---|---|
| lpush() | 增加（从左边新加，不存在就新建） |
| rpush() | 增加（从右边新增加，不存在就新建） |
| llen() | 获取列表长度 |
| lpushx() | 已经有的name的列表的左边添加元素，没有的话无法创建 |
| rpushx() | 已经有的name的列表的右边添加元素，没有的话无法创建 |
| linsert() | 新增（固定索引号位置插入元素） |
| lset() | 修改（指定索引号进行修改） |
| lrem() | 删除（指定值进行删除） |
| lpop() | 左边删除并返回 |
| rpop() | 右边删除并返回 |
| ltrim() | 删除索引之外的值 |
| lindex() | 取值（根据索引号取值 ） |
| brpoplpush() | 移动 （元素从一个列表移动到另外一个列表 可以设置超时 ） |
-
lpush(name, values):
从左边新增加，不存在就新建# 往name='list' 中从左添加value=[11, 22, 33] my_conn.lpush('list', 11, 22, 33) print(my_conn.lrange('list', 0, -1)) # 输出结果：['33', '22', '11'] 保存顺序为 33，22，11 -
rpush(name, values):
从右边新增加，不存在就新建# name='list1' 中从右添加value=[66, 55, 44] my_conn.rpush('list1', 66, 55, 44) print(my_conn.lrange('list1', 0, -1)) # 输出结果：['66', '55', '44'] -
llen(name):
获取列表长度# 获取name='list1' 列表中的长度 value=[66, 55, 44] print(my_conn.llen('list1')) # 输出结果： 3 -
lpushx(name, value):
往已经有的name的列表的左边添加元素，没有的话无法创建# 首先redis数据库中没有name='list2' my_conn.lpushx('list2', 10) print(my_conn.lrange('list2', 0, -1)) # 输出结果： [] -
rpushx(name, value):
往已经有的name的列表的右边添加元素，没有的话无法创建# 首先redis数据库中没有name='list2' my_conn.rpushx('list2', 10) print(my_conn.lrange('list2', 0, -1)) # 输出结果： [] -
linsert(name, where, refvalue, value):
在name对应的列表的某一个值前或后插入一个新值参数：
name：redis的name
where：BEFORE或AFTER
refvalue：标杆值 (以它为基础, 前后插入新值)
value：要插入的数据
# 往列表中左边第一个出现的元素"66"前插入元素"77", 若name不存在, 不会新创建, 会返回[] my_conn.linsert('list1', 'before', '66', '77') # 目前数据库list1=[66, 55, 44] print(my_conn.lrange('list1', 0, -1)) # 输出结果： ['77', '66', '55', '44'] -
lset(name, index, value)：
对name对应的list中的某一个索引位置重新赋值参数：
name：redis的name
index：list的索引位置
value：要设置的新值
# 将list1中索引为3, 替换成'33', list1=['77', '66', '55', '44'] my_conn.lset('list1', 3, '33') print(my_conn.lrange('list1', 0, -1)) # 输出结果: ['77', '66', '55', '33'] -
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' 删除一个 my_conn.lrem("list1", 1, "66") print(my_conn.lrange('list1', 0, -1)) # 输出结果：['77', '55', '33'] # list1=['77', '55', '33'] # 从右向左, 找到value='55', 删除一个 my_conn.lrem('list1', -1, '55') print(my_conn.lrange('list1', 0, -1)) # 输出结果：['77', '33'] # list1=['77', '77', '33'] # 删除name='list1'中 value='77'的所有值 my_conn.lrem('list1', 0, '77') print(my_conn.lrange('list1', 0, -1)) # 输出结果： -
lpop(name)
在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素# list1 = ['77', '66', '55'] result = my_conn.lpop('list1') print(result) # 输出结果：77 print(my_conn.lrange('list1', 0, -1)) # 输出结果：['66', '55'] -
rpop(name):
在name对应的列表的右侧获取第一个元素并在列表中移除，返回值则是第一个元素
# list1 = ['66', '55'] result = my_conn.rpop('list1') print(result) # 输出结果：55 print(my_conn.lrange('list1', 0, -1) # 输出结果：['66']) -
ltrim(name, start, end):
name对应的列表中移除没有在start-end索引之间的值参数：
name：redis的name
start：索引的起始位置
end：索引的结束位置
# list1=['77', '66', '55', '44', '33'] # 删除name='list1'中, 不包含索引0-2的value my_conn.ltrim('list1', 0, 2) print(my_conn.lrange('list1', 0, -1)) # 输出结果：['77', '66', '55'] -
lindex(name, index):
在name对应的列表中根据索引获取列表元素
# list1=['77', '66', '55'] # 取出name='list1'中索引为1的值 print(my_conn.lindex('list1', 1) # 输出结果：66) -
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'中 my_conn.brpoplpush('list1', 'list', timeout=2) print(my_conn.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() | 删除–指定值删除 |
-
sadd(name, values)：
name对应的集合中添加元素
# 往集合中添加元素 name='set1' my_conn.sadd('set1', 1, 2, 3, 4, 5, 6) print(my_conn.smembers('set1')) # 输出结果:set(['1', '3', '2', '5', '4', '6']) -
scard(name):
name对应集合中元素个数# 'set1' = set(['1', '3', '2', '5', '4', '6']) print(my_conn.scard('set1')) # 输出结果： 6 -
smembers(name):
name对应的集合所有成员# 获取name='set1' 中的所有values值 print(my_conn.smembers('set1')) # 输出结果: set(['1', '3', '2', '5', '4', '6']) -
sscan(name, cursor=0, match=None, count=None):
name对应集合所有成员(元组形式)print(my_conn.sscan('set1')) # 输出结果：(0L, ['1', '2', '3', '4', '5', '6']) -
sscan_iter(name, match=None, count=None):
name对应集合所有成员(迭代器的方式)for item in my_conn.sscan_iter('set1'): print(item) # 输出结果如下： 1 2 3 4 5 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(my_conn.sdiff('set1', 'set2')) # 输出结果:set(['1', '3', '2', '4']) # 在集合set2中但是不在集合set1中的values值 print(my_conn.sdiff('set2', 'set1')) # 输出结果：set(['8', '7']) -
sdiffstore(dest, keys, *args)：
将两个集合中的差集，存储到第三个集合中# 在集合set1但是不再集合set3中的values值, 存储到set3集合中 my_conn.sdiffstore('set3', 'set1', 'set2') print(my_conn.smembers('set3')) # 输出结果：set(['1', '3', '2', '4']) -
sinter(keys，*args)：
获取两个集合中的交集# set1=set(['3', '5', '6']) # set2=set(['8', '5', '4', '7', '6']) # 求集合set1与set2的交集 print(my_conn.sinter('set1', 'set2')) # 输出结果：set(['5', '6']) -
sinterstore(dest, keys, *args)：
将两个集合中的交集，存储到第三个集合中# 将set1与set2的交集，存储到set3中 print(my_conn.sinterstore('set3', 'set1', 'set2')) # 输出结果： 2 说明存储进去两个 print(my_conn.smembers('set3')) # 输出结果：set(['5', '6']) -
sunion(keys, *args):
获取多个name对应的集合并集# 获取set1与set2集合中的并集 print(my_conn.sunion('set1', 'set2')) # 输出结果：set(['1', '3', '2', '5', '4', '7', '6', '8']) -
sunionstore(dest, keys, *args)：
将两个集合中的并集，存储到第三个集合中# 将set1与set2集合中的并集, 存储到set3中 print(my_conn.sunionstore('set3', 'set1', 'set2')) print my_conn.smembers('set3') # 输出结果：set(['1', '3', '2', '5', '4', '7', '6', '8']) -
sismember(name, value):
判断是否是集合的成员# 校验value=3 是否在name=set1集合中 print(my_conn.sismember('set1', 3)) # 输出结果：True表示在集合中 print(my_conn.sismember('set1', 33)) # 输出结果： False表示不在集合中 -
smove(src, dst, value):
将某个成员从一个集合中移动到另外一个集合# 目前集合set1、set2中的元素 # set1=set(['1', '3', '2', '5', '4', '6']) # set2=set(['8', '5', '7', '6']) # 将set1中的value=4的元素, 移动到set2集合中 my_conn.smove('set1', 'set2', 4) print(my_conn.smembers('set1')) # 输出结果：set(['1', '3', '2', '5', '6']) print(my_conn.smembers('set2')) # 输出结果：set(['8', '5', '4', '7', '6']) -
spop(name):
从集合移除一个成员, 并将其返回(集合是无序的，所有移除也是随机的)# 目前set1集合中元素 set1=set(['1', '3', '2', '5', '6']) # 随机删除'set1'中的Value值 print(my_conn.spop('set1')) # 输出结果：1 说明删除的个数 print(my_conn.smembers('set1')) # 输出结果：set(['3', '2', '5', '6']) -
srem(name, values):
在name对应的集合中删除某些值# 目前set1=set(['3', '2', '5', '6']) print(my_conn.srem('set1', 2)) # 输出结果：1 print(my_conn.smembers('set1')) # 输出结果：set(['3', '5', '6'])
zset有序集合操作
| 方法 | 简介 |
|---|---|
| zadd() | 新增 |
| zcard() | 获取有序集合元素个数 |
| zrange() | 获取有序集合的所有元素 |
| zrevrange() | 从大到小排序(同zrange，集合是从大到小排序的) |
| zscan() | 获取所有元素–默认按照分数顺序排序 |
| zscan_iter() | 获取所有元素–迭代器 |
| zcount() | name对应的有序集合中分数 在 [min,max] 之间的个数 |
| zincrby () | 自增 |
| zrank() | 获取值的索引号 |
| zrem() | 删除–指定值删除 |
| zremrangebyscore() | 删除–根据分数范围删除 |
| zscore() | 获取值对应的分数 |
-
Set操作，Set集合就是不允许重复的列表，本身是无序的。
-
有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较， 所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。
-
zadd(name, *args, **kwargs)：
在name对应的有序集合中添加元素# 新建有序集合 name='zset1' value='n1', 'n2' score='11', '22' my_conn.zadd('zset1', n1=11, n2=22) print(my_conn.zrange('zset1', 0, -1)) # 输出结果：['n1', 'n2'] 显示的是value值 # 新建有序集合 name='zset2', value='m1', 'm2' score='22', '33' my_conn.zadd('zset2', m1=22, m2=33) # withscores=True 获取有序集合中所有元素和分数 print(my_conn.zrange('zset2', 0, -1, withscores=True) ) # 输出结果：[('m1', 22.0), ('m2', 33.0)] -
zcard(name):
获取name对应的有序集合元素的数量# zset2=[('m1', 22.0), ('m2', 33.0)] # 获取name='zset2'中value的个数 print(my_conn.zcard('zset2')) # 输出结果：2 -
zrange( name, start, end, desc=False, withscores=False, score_cast_func=float):
按照索引范围获取name对应的有序集合的元素参数：
name：redis的name
start：有序集合索引起始位置（非分数）
end：有序集合索引结束位置（非分数）
desc：排序规则，默认按照分数从小到大排序
withscores：是否获取元素的分数，默认只获取元素的值
score_cast_func：对分数进行数据转换的函数
-
zrevrange(name, start, end, withscores=False, score_cast_func=float):
从大到小排序(同zrange，集合是从大到小排序的)# 仅获取元素、不显示分数, 分数倒序 print(my_conn.zrevrange('zset2', 0, -1)) # 输出结果：['m2', 'm1'] # 获取有序集合中所有元素和分数, 分数倒序 print(my_conn.zrevrange('zset2', 0, -1, withscores=True)) # 输出结果：[('m2', 33.0), ('m1', 22.0)] -
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)：
获取所有元素–默认按照分数顺序排序# 获取name=zset2所有的元素, 按照分数顺序排序 print(my_conn.zscan('zset2')) # 输出结果：(0L, [('m1', 22.0), ('m2', 33.0)]) -
zscan_iter(name, match=None, count=None,score_cast_func=float):
获取所有元素–迭代器# 遍历迭代器 for item in my_conn.zscan_iter('zset2'): print(item) # 输出结果如下： ('m1', 22.0) ('m2', 33.0) -
zcount(name, min, max)：
获取name对应的有序集合中分数 在 [min,max] 之间的个数print(my_conn.zrange('zset2', 0, -1, withscores=True)) # 输出结果：[('m1', 22.0), ('m2', 33.0)] print(my_conn.zcount('zset2', 22, 33)) # 输出结果：2 -
zincrby(name, value, amount)：
自增name对应的有序集合的name对应分数# 每次将value='m2' 的分数自增2 my_conn.zincrby('zset2', 'm2', amount=2) print(my_conn.zrange('zset2', 0, -1, withscores=True)) # 输出结果：[('m1', 22.0), ('m2', 39.0(m2所对应的分数每次执行+2))] -
zrank(name, value)：
获取某个值在 name对应的有序集合中的索引（从 0 开始）
# name=[('m1', 22.0), ('m2', 39.0)], value='m2' 所对应的索引是多少 print(my_conn.zrank('zset2', 'm2')) # 输出结果：1 -
zrem(name, values)：
删除name对应的有序集合中值是values的成员# 删除有序集合'zset2'中 value='m2' my_conn.zrem('zset2', 'm2') print(my_conn.zrange('zset2', 0, -1, withscores=True)) # 输出结果：[('m1', 22.0)] -
zremrangebyscore(name, min, max)：
根据分数范围删除# zset1=[('n1', 11.0), ('n2', 22.0), ('n3', 33.0), ('n4', 44.0), ('n5', 55.0)] # 删除有序集合'zset1'中, value范围在 33-44间的值 my_conn.zremrangebyscore('zset1', 33, 44) print(my_conn.zrange('zset1', 0, -1, withscores=True)) # 输出结果：[('n1', 11.0), ('n2', 22.0), ('n5', 55.0)] -
zscore(name, value)：
获取name对应有序集合中 value 对应的分数# zset=[('n1', 11.0), ('n2', 22.0), ('n5', 55.0)] # 获取name='zset1' 中value='n1'所对应的分数 print(my_conn.zscore('zset1', 'n1')) # 输出结果：11.0
Hash哈希操作
| 方法 | 简介 |
|---|---|
| hset() | 修改(单个取出)–没有就新增，有的话就修改 |
| hmset() | 批量增加 |
| hmget() | 批量获取 |
| hgetall() | 取出所有的键值对 |
| hlen() | 得到所有键值对的格式 hash长度 |
| hkeys() | 得到所有的keys |
| hvals() | 得到所有的value |
| hexists() | 判断成员是否存在 |
| hdel() | 删除键值对 |
| hincrby() | 自增自减整数 |
| hscan_iter() | 取值查看–分片读取 |
-
hset(name, key, value)：
name对应的hash中设置一个键值对（不存在，则创建；否则，修改）参数：
name：redis的name
key：name对应的hash中的key
value：name对应的hash中的value
# 设置 name='hash1' key='k1' value='v1' my_conn.hset('hash1', 'k1', 'v1') # 设置 name='hash1' key='k2' value='v2' my_conn.hset('hash1', 'k2', 'v2') print(my_conn.hget('hash1', 'k1')) # 输出结果：v1 print(my_conn.hget('hash1', 'k2')) # 输出结果：v2 -
hmset(name, mapping) ：
在name对应的hash中批量设置键值对参数：
name：redis的name
mapping：字段：如{‘k1’: ‘v1’, ‘k2’: ‘v2’}
# 批量设置hash create_k = {'k2': 'v2', 'k3': 'v3'} my_conn.hmset('hash2', create_k) -
hmget(name, keys, *args):
在name对应的hash中获取多个key的值参数：
name：redis的name
keys：要获取key集合，如：[‘k1’, ‘k2’, ‘k3’]
*args：要获取key集合，如：‘k1’, ‘k2’, ‘k3’
print(my_conn.hmget('hash2', 'k2')) # 单个取出'hash2' 输出结果：['v2'] print(my_conn.hmget('hash2', 'k2', 'k3')) # 批量取出'hash2', 输出结果：['v2', 'v3'] print(my_conn.hmget('hash2', ['k2', 'k3'])) # 批量取出'hash2', 输出结果：['v2', 'v3'] -
hgetall(name)：
获取name对应hash的所有键值# 获取name='hash2' 全部key, value print(my_conn.hgetall('hash2')) # 输出结果：{'k3': 'v3', 'k2': 'v2'} -
hlen(name) :
获取name对应的hash中键值对的个数# 'hash2'={'k3': 'v3', 'k2': 'v2'} print(my_conn.hlen('hash2')) # 输出结果：2 -
hkeys(name):
获取name对应的hash中所有的key的值# 仅获取name='hash2' 取出key的值 print(my_conn.hkeys('hash2')) # 输出结果：['k3', 'k2'] -
hvals(name):
获取name对应的hash中所有的value的值# 仅获取name='hash2', 取出value的值 print(my_conn.hvals('hash2')) # 输出结果：['v3', 'v2'] -
hexists(name, key)：
检查name对应的hash是否存在当前传入的keyprint(my_conn.hexists('hash2', 'k4')) # 输出结果：False print(my_conn.hexists('hash2', 'k2')) # 输出结果：True -
hdel(name,*keys):
将name对应的hash中指定key的键值对删除# hash2={'k3': 'v3', 'k2': 'v2'} # 将name='hahs2' key='k3' 删除 my_conn.hdel('hash2', 'k3') print(my_conn.hgetall('hash2')) # 输出结果：{'k2': 'v2'} -
hincrby(name, key, amount=1):
自增name对应的hash中的指定key的值，不存在则创建key=amount参数：
name：redis的name
key：hash对应的key
amount：自然数(整数)
my_conn.hincrby('hash2', 'k4', amount=1) print(my_conn.hgetall('hash2')) # 输出结果：{'k2': 'v2', 'k4': '2'(+1)} 如果key不存在, value默认就是1 -
hscan_iter(name, match=None, count=None):
利用yield封装hscan创建生成器，实现分批去redis中获取数据参数：
match，匹配指定key，默认None 表示所有的key
count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
for item in my_conn.hscan_iter('hash2'): print(item) # 输出结果： # ('k2', 'v2') # ('k5', '4') # ('k4', '2') print(my_conn.hscan_iter('hash2')) # 生成器内存地址 # 输出结果：<generator object hscan_iter at 0x000000000389B2D0>
3其他常规操作
| 方法 | 简介 |
|---|---|
| delete() | 删除 |
| exists() | 检查名字是否存在 |
| expire() | 设置超时时间 |
| rename() | 重命名 |
| type() | 获取类型 |
-
delete(*names) :
根据删除redis中的任意数据类型（string、hash、list、set、有序set）my_conn.delete('hash1') # 删除key为'hash1'的键值对 -
exists(name)：
检测redis的name是否存在，存在就是True，False 不存在print(my_conn.exists('hash1')) # 输出结果：False 说明key 不存在 print(my_conn.exists('set1')) # 输出结果：True 说明key存在 -
expire(name ,time) :
为某个redis的某个name设置超时时间my_conn.lpush('list5', 11, 22) my_conn.expire('list5', time=3) print(my_conn.lrange('list5', 0, -1)) # 输出结果：['22', '11'] import time time.sleep(3) print(my_conn.lrange('list5', 0, -1)) # 输出结果：[] -
rename(src, dst) ：
对redis的name重命名my_conn.lpush('list5', 11, 22) print(my_conn.rename('list5', 'list-5')) # 输出结果： True 说明重命名成功 -
type(name) :
获取name对应值的类型print(my_conn.type('set1')) # 输出结果：zset print(my_conn.type('zset2')) # 输出结果：zset print(my_conn.type('list-5')) # 输出结果：list -
查看所有元素：
print(my_conn.hscan("hash")) print(my_conn.sscan("set")) print(my_conn.zscan("zset")) print(my_conn.getrange("string", 0, -1)) print(my_conn.lrange("list", 0, -1)) print(my_conn.smembers("set3")) print(my_conn.zrange("zset3", 0, -1)) print(my_conn.hgetall("hash1"))
个人对redis的简单封装
import redis
#python操作redis
class My_redis:
def __init__(self,host,port=6379,db=0,decode_responses=True):
try:
self.my_conn = redis.StrictRedis(host,port=port,db = db,decode_responses=decode_responses)
except Exception as e:
print('redis数据库连接失败,错误提示{}'.format(e))
else:
print('redis数据库连接成功！')
#查找所有的键值
def get_allKey(self):
return self.my_conn.keys()
#str方法
#设置key
def str_set(self,dick,many=False):
try:
if not many:
#插入单条数据
self.my_conn.set(list(dick.keys())[0],list(dick.values())[0])
else:
self.my_conn.mset(dick)
except Exception as e:
print('str数据插入失败，错误提示:{}'.format(e))
else:
print('str数据插入成功！')
#查找数据
def str_get(self,keys,many=False,):
try:
if not many:
# 插入单条数据
result = self.my_conn.get(keys)
else:
# print(keys)
result = self.my_conn.mget(keys)
except Exception as e:
print('str数据查找失败，错误提示:{}'.format(e))
else:
print('str数据查找成功,查找结果为{}。'.format(result))
return result
#追加数据
def str_append(self,key,value):
try:
self.my_conn.append(key=key,value=value)
except Exception as e:
print('str数据追加失败，错误提示:{}'.format(e))
else:
print('str数据追加成功！')
# print(self.get_string(key))
#修改数据
def str_updata(self,key,value):
try:
self.my_conn.getset(key,value)
except Exception as e:
print('str数据更新失败，错误提示:{}'.format(e))
else:
print('str数据更新成功！')
#删除数据
def str_delete(self,key):
try:
self.my_conn.delete(key)
except Exception as e:
print('str数据删除失败，错误提示:{}'.format(e))
else:
print('str数据删除成功！')
#list方法
#添加数据
def list_push(self,list_key,*values,direction=False):
try:
if not direction:
self.my_conn.rpush(list_key,*values)
else:
self.my_conn.lpush(list_key,*values)
except Exception as e:
print('list数据添加失败，错误提示:{}'.format(e))
else:
print('list数据添加成功！')
#查找数据
def list_find(self,list_key,start,end=0,range=False):
try:
if not range:
result = self.my_conn.lindex(list_key,start)
else:
result = self.my_conn.lrange(list_key, start, end)
except Exception as e:
print('list数据查找失败，错误提示:{}'.format(e))
else:
print('list数据查找成功,查找的数据为{}'.format(result))
return result
#修改数据
def list_updata(self,list_key,index,value):
try:
self.my_conn.lset(list_key,index,value)
except Exception as e:
print('list数据修改失败，错误提示:{}'.format(e))
else:
print('list数据修改成功！')
#删除数据
def list_delete(self,list_key,right=False):
try:
if not right:
result = self.my_conn.lpop(list_key)
else:
result = self.my_conn.rpop(list_key)
except Exception as e:
print('list数据删除失败，错误提示:{}'.format(e))
else:
print('list数据删除成功,删除的数据为{}'.format(result))
return result
if __name__ == '__main__':
myre = My_redis('127.0.0.1',db=15)
myre.str_set({'skey5':'sk5','skey6':'sk6','skey7':'sk7'},many=True)
myre.str_get('skey1')
myre.str_get(['skey1','skey2','skey3'],many=True)
print(myre.get_allKey())
myre.str_append('skey1','aaaa')
myre.str_get('skey1')
myre.str_updata('skey1','sk1')
myre.str_get('skey1')
myre.str_delete('skey7')
myre.list_push('mylist','hello','python','world',direction=True)
myre.list_updata('mylist',3,'jiucheng')
myre.list_find('mylist',0,5,range=True)
myre.list_delete('mylist')
myre.list_find('mylist', 0, 5, range=True)
myre.list_delete('mylist',right=True)
myre.list_find('mylist', 0, 5, range=True)
1525
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
