python 操作redis数据库

最新推荐文章于 2024-08-09 15:10:03 发布
最新推荐文章于 2024-08-09 15:10:03 发布
阅读量1.4k 收藏 6
点赞数 1
分类专栏： Redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fe_cow/article/details/90212622
版权

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')
# 输出结果： 131xxxxx
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')
# 输出结果：(0L, ['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')
# 输出结果：(0L, [('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"))
Fe_cow丿
关注
专栏目录
python操作redis数据库的三种方法
09-14
Python操作Redis数据库是常见的数据存储和缓存策略，尤其在处理高并发和大数据量的场景中。本文将详细介绍三种在Python中与Redis交互的方法：直接使用、使用连接池以及通过Django缓存系统。 首先，要进行Python操作...
【redis】set后value出现空格
mjl0219的博客
04-02 2470
【redis】set后value出现空格问题描述解决方案总结 问题描述 第三方接口需要获取一个token进行请求，该token有效期为5分钟，因此获取一次token后利用redis进行缓存，减少多次获取token的开销。但是在测试中发现，获取token正确，存入redis后再取出原token中会多出很多空格。如下 [2019-03-18 11:48:57,838] - source:{"token...
Python_Redis使用
十一姐的博客
04-10 1710
Redis存储(import redis) Redis是一个基于内存的高效的键值型非关系型数据库，存储效率极高，而且支持多种存储数据结构。 1、准备工作 安装Redis，python之redis库 2、连接Reids，键操作，字符串操作，列表操作，集合操作，有序集合操作，散列操作， （1）连接Redis from redis import StrictRedis #声明StrictRe...
Redis超详细教程
m0_74293254的博客
07-26 4740
字符串（String）：最基本的数据类型，可以存储字符串、整数或者浮点数。哈希表（Hash）：Redis 的哈希表是一个键值对集合，适合存储对象。每个哈希表可以存储多个字段和值之间的映射。列表（List）：双向链表实现的列表，支持在两端插入和删除元素，适合用于实现队列或者栈。集合（Set）：无序集合，可以存储多个不重复的字符串元素，支持集合间的交集、并集和差集等操作。有序集合（Sorted Set）：和普通集合类似，但每个成员都关联了一个分数（score），根据分数排序。
python数据库——redis
m0_65995252的博客
09-28 485
Redis是一个开源的、基于内存的数据结构存储系统，可以用作数据库、缓存和消息中间件。它支持多种数据结构，包括字符串、哈希表、列表、集合和有序集合等。Redis的特点包括高性能、持久化、支持事务和发布/订阅等功能。它通常被用于解决高并发、高性能读写的场景，如缓存、排行榜、实时统计等。
Python之Redis操作方法
专注于Python编程技术的分享与交流，致力于帮助开发者提升编程技能，解决实际问题，探索Python的无限可能。
06-21 1万+
Redis（Remote Dictionary Server）是一个高性能的键值存储数据库，它支持各种数据结构，如字符串、哈希表、列表、集合和有序集合。Redis 通常被用作缓存、消息队列、实时统计等场景。本教程介绍了使用 Python 操作 Redis 的基本操作，包括键值对、哈希表、列表、集合、有序集合和发布/订阅等数据操作，以及事务操作、过期时间、持久化、分布式锁、缓存和性能优化等高级功能和用例。
Python常用模块 之 redis：连接和操作redis数据库
热门推荐
孤寒者的博客
08-27 6万+
python操作Redis数据库—redis库（可直接使用的模板通用操作）
python的redis数据库连接与使用
08-17
Python 的 Redis 数据库连接与使用是指通过 Python 语言对 Redis 数据库进行连接和操作的过程。Redis 是一个基于内存的 key-value 存储系统，可以存储多种数据类型，包括字符串、链表、集合、有序集合和哈希类型等。...
Python读写Redis数据库操作示例
09-10
在Python中，Redis数据库的交互通常通过Python的redis模块实现，这是一个非常强大的库，提供了丰富的API来操作Redis的各种数据结构。下面将详细讲解如何使用Python读写Redis数据库，并结合给出的示例代码进行分析。 ...
使用 Python 操作 Redis 数据库
很酷的站长的博客
01-30 2777
redis 是 python 访问 Redis 数据库的模块。在第 5 行，使用方法 hdel(‘person’, ‘gender’) 删除哈希表 ‘person’ 中的键 ‘gender’在第 6 行，redis 数据库返回的是字节对象 b’ZhangSan’，而不是字符串 ‘ZhangSan’在第 1 行，使用方法 sismember(‘set’, ‘b’) 检查集合 ‘set’ 是否包含 ‘b’在第 3 行，使用方法 sismember(‘set’, ‘d’) 检查集合 ‘set’ 是否包含 ‘d’
如何在Python中操作Redis数据库
这家伙很懒，什么都没有留下
11-29 2060
Redis是一个功能强大的内存数据存储系统，提供了丰富的数据类型和操作命令，可以满足各种数据处理需求。在使用过程中，需要根据具体的业务场景和需求来选择合适的Redis数据类型和操作命令，并进行合理的配置和优化。同时，还需要注意Redis的安全性和可靠性，采取相应的措施来保护数据的安全性和完整性。总之，Redis是一个强大的工具，可以帮助我们更好地处理和管理数据，提高系统的性能和可用性。
【python】Python操作Redis数据库的详细教程与应用实战
最新发布
景天科技苑
08-09 1813
Redis是一个高性能的键值存储数据库，支持多种类型的数据结构，如字符串、哈希表、列表、集合和有序集合等。由于其高效的读写速度和丰富的数据类型支持，Redis被广泛应用于缓存、消息队列、会话管理等多种场景。在Python中，通过redis-py库可以方便地操作Redis数据库。
Redis - Python 客户端基本使用指南
墨鸦的博客
10-24 7559
Redis - Python 客户端基本使用指南
(六)python实战——使用Redis库完成redis基本数据类型数据的操作案例
厉害哥哥的博客
07-04 676
本节内容主要介绍一下在python环境下，使用Redis库实现redis基本数据类型String、List、Set、Zset、Hash等数据的操作，通过案例的演示，学习python环境下，redis缓存数据库的基本使用和操作。
【Python】Redis数据库
Cerulea_n的博客
06-17 1185
Redis基础学习
Python连接Redis数据库进行增删改查（附带常用方法）
皮皮鱼哟
01-15 3055
Python连接Redis数据库进行增删改查 """Redis数据类型: 1. <set key value> 类型 : String(字符串) 简介: 二进制安全 特性 : 可以包含任何数据,比如jpg图片或者序列化的对象,一个键最大能存储512M 场景: / 2. <hset major_key key value>...
【redis】Redis的数据类型和数据操作
冰冷的希望的博客
08-24 1985
先通过redis-cli连接数据库并且查询要删除的key，然后通过管道传给xargs，依次调用redis-cli执行。键操作：keys、exists、type、del、expire、ttl。但是Windows系统没有xargs命名，那可以借助Python脚本。修改数据其实就是重新赋值，与上面的语法一样。匹配到的key，下面两种写法都行，但推荐。如果是Linux系统，可以借助。例如，删除第3号库的。
python爬虫之redis安装及使用示例
naer_chongya的博客
06-07 1478
在这篇文章中，我们讨论了Redis在Python爬虫中的应用，并提供了缓存机制的具体实例。Redis的数据结构非常强大，例如支持Hash、String、Set和List等数据类型，而且能够使用Lua脚本进行批量操作，因此在Python爬虫工具中被广泛应用。为了加快爬虫效率，可以将已经爬取到的数据缓存起来，下次再次请求时从缓存中获取，避免了重复请求和浪费时间和带宽。同样的URL将导致相同的结果，因此我们可以将URL用作Redis缓存数据的键，并使用Redis的List数据类型将其保存为。
跟我一起从零开始学python（五）数据库编程：Redis数据库
ch950401的博客
07-10 811
1.跟我一起从零开始学python（一）编程语法必修2.跟我一起从零开始学python（二）网络编程3.跟我一起从零开始学python（三）多线程/多进程/协程4.跟我一起从零开始学python（四）数据库编程：MySQL数据库本篇讲：python数据库编程：Redis数据库关注公众号：python技术训练营，学习进阶一步到位适用于零基础学习和进阶人群的python资源：① 腾讯认证python完整项目实战教程笔记PDF② 十几个大厂python面试专题PDF。
python连接redis数据库
05-17
连接成功后，可以使用Redis对象的方法来操作Redis数据库。例如，可以使用set方法设置一个键值对，代码如下： ```python # 设置一个键值对 r.set('name', 'Alice') ``` 如果需要获取该键对应的值，则可以使用get...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值