专栏首页素质云笔记pyRedis - 操作指南:增/删/改/查、管道与发布订阅功能

pyRedis - 操作指南:增/删/改/查、管道与发布订阅功能

文章目录

  • 1 redis docker 部署与安装
  • 2 py - redis的使用
    • 2.1 redis的连接
    • 2.2 常规属性查看
      • 2.2.2 关于删除
    • 2.3 STRING 字符串的操作
    • 2.4 Hash 操作
    • 2.5 List 操作
    • 2.6 Set 操作
    • 2.7 有序集合 zset
  • 3 管道
    • 3.1 相关案例
    • 3.2 管道与连接池
  • 4 发布与订阅
  • 5 参考文献

1 redis docker 部署与安装

参考:一文教你如何通过 Docker 快速搭建各种测试环境

首先拉取 Redis 镜像, 这里我选择的是 redis:alpine 轻量级镜像版本:

docker pull redis:alpine

下载完成后,通过 docker images 确认镜像是否已经下载到本地:

运行 Redis 容器:

docker run -p 6379:6379 --name redis \
-v /etc/localtime:/etc/localtime:ro \
-v /home/docker/redis/redis.conf:/etc/redis/redis.conf \
-v /home/docker/redis/data:/data \
-d redis:alpine redis-server /etc/redis/redis.conf \
--appendonly yes

命令说明:

  • -p 6379:6379: 将容器的 6379 端口映射到宿主机的 6379 端口;
  • -v /usr/local/docker/redis/data:/data:将容器中的 /data 数据存储目录,挂载到宿主机中 /usr/local/docker/redis/data 目录下;
  • -v /usr/local/docker/redis/redis.conf:/etc/redis/redis.conf:将容器中 /etc/redis/redis.conf 配置文件,挂载到宿主机的 /usr/local/docker/redis/redis.conf 文件上;
  • redis-server --appendonly yes:在容器执行 redis-server 启动命令,并打开 Redis 持久化配置。

命令运行完成后,查看容器是否启动成功:

连接刚刚创建的容器:

docker run -it redis:alpine redis-cli -h http://47.100.111.104

2 py - redis的使用

!pip3 install --pre redis -i https://pypi.tuna.tsinghua.edu.cn/simple 

在python中,安装redis库。

2.1 redis的连接

import redis
host = '47.100.111.104'
port = 6379
r = redis.Redis(host=host,port=port)

另外一种是:

    # 连接池:为了节约资源,减少多次连接带来的消耗。
    # # 默认设置的值和取得的值都是bytes类型,如果想改为str类型,可以添加decode_responses=True
    pool=redis.ConnectionPool(host='47.100.111.104',port=6379,decode_responses=True)

关系型数据库都有一个连接池的概念:对于大量redis连接来说,如果使用直接连接redis的方式的话,将会造成大量的TCP的重复连接,所以,就引入连接池来解决这个问题。在使用连接池连接上redis之后,可以从该连接池里面生成连接,调用完成之后,该链接将会返还给连接池,供其他连接请求调用,这样将减少大量redis连接的执行时间。

简单的使用例子:

# 1 常规的连接
r.set('foo','bar')
print(r.get('foo'))
>>> b'bar'

#2 连接池:
r1 = redis.Redis(connection_pool=pool)
r2 = redis.Redis(connection_pool=pool)

r1.set('name','jack')
print(r1.get('name'))
r2.set('age',18)
print(r2.get('age'))

print(r1.client_list())
print(r2.client_list())
>>>jack
18
[{'id': '3', 'name': '', 'age': '227', 'multi': '-1', 'fd': '9', 'psub': '0', 'qbuf-free': '0', 'sub': '0', 'qbuf': '0', 'events': 'r', 'addr': '47.100.111.104:39250', 'cmd': 'get', 'oll': '0', 'omem': '0', 'idle': '227', 'flags': 'N', 'obl': '0', 'db': '0'}, {'id': '4', 'name': '', 'age': '0', 'multi': '-1', 'fd': '10', 'psub': '0', 'qbuf-free': '32742', 'sub': '0', 'qbuf': '26', 'events': 'r', 'addr': '47.100.111.104:39252', 'cmd': 'client', 'oll': '0', 'omem': '0', 'idle': '0', 'flags': 'N', 'obl': '0', 'db': '0'}]
[{'id': '3', 'name': '', 'age': '227', 'multi': '-1', 'fd': '9', 'psub': '0', 'qbuf-free': '0', 'sub': '0', 'qbuf': '0', 'events': 'r', 'addr': '47.100.111.104:39250', 'cmd': 'get', 'oll': '0', 'omem': '0', 'idle': '227', 'flags': 'N', 'obl': '0', 'db': '0'}, {'id': '4', 'name': '', 'age': '0', 'multi': '-1', 'fd': '10', 'psub': '0', 'qbuf-free': '32742', 'sub': '0', 'qbuf': '26', 'events': 'r', 'addr': '47.100.111.104:39252', 'cmd': 'client', 'oll': '0', 'omem': '0', 'idle': '0', 'flags': 'N', 'obl': '0', 'db': '0'}]

2.2 常规属性查看

方法

作用

参数说明

示例

示例说明

示例结果

exists(name)

判断一个键是否存在

name:键名

redis.exists(‘name’)

是否存在name这个键

TRUE

delete(name)

删除一个键

name:键名

redis.delete(‘name’)

删除name这个键

1

type(name)

判断键类型

name:键名

redis.type(‘name’)

判断name这个键类型

b’string’

keys(pattern)

获取所有符合规则的键

pattern:匹配规则

redis.keys(‘n*’)

获取所有以n开头的键

[b’name’]

randomkey()

获取随机的一个键

randomkey()

获取随机的一个键

b’name’

rename(src, dst)

重命名键

src:原键名;dst:新键名

redis.rename(‘name’, ‘nickname’)

将name重命名为nickname

TRUE

dbsize()

获取当前数据库中键的数目

dbsize()

获取当前数据库中键的数目

100

expire(name, time)

设定键的过期时间,单位为秒

name:键名;time:秒数

redis.expire(‘name’, 2)

将name键的过期时间设置为2秒

TRUE

ttl(name)

获取键的过期时间,单位为秒,-1表示永久不过期

name:键名

redis.ttl(‘name’)

获取name这个键的过期时间

-1

move(name, db)

将键移动到其他数据库

name:键名;db:数据库代号

move(‘name’, 2)

将name移动到2号数据库

TRUE

flushdb()

删除当前选择数据库中的所有键

flushdb()

删除当前选择数据库中的所有键

TRUE

flushall()

删除所有数据库中的所有键

flushall()

删除所有数据库中的所有键

TRUE

其中具体:

  1. delete(*names) 根据name删除redis中的任意数据类型
	#根据name删除redis中的任意数据类型
  1. exists(name) 检测redis的name是否存在
#检测redis的name是否存在
  1. keys(pattern=’’) 根据 ?等通配符匹配获取redis的name
#根据* ?等通配符匹配获取redis的name
  1. expire(name ,time) 为某个name设置超时时间
# 为某个name设置超时时间
  1. rename(src, dst) 重命名
  2. move(name, db)) 将redis的某个值移动到指定的db下
# 将redis的某个值移动到指定的db下
  1. randomkey() 随机获取一个redis的name(不删除)
#随机获取一个redis的name(不删除)
  1. type(name) 获取name对应值的类型
# 获取name对应值的类型

2.2.2 关于删除

py-redis中有个delete接口,既可以删除单个key,也可以全删除key,如果要删除几个key,用法是:r.delete('age')r.delete('sex', 'age'),如果要全删除,那就是

keys = r.keys()
r.delete(*keys)

执行之后的效果等于flushall。

redis里默认情况下是不支持通配符的,那么要批量删除key怎么做呢?答案就是搭配xargs,比如要删除掉所有2018-03-开头的key: redis-cli -hredis地址 -a密码 keys "2018-03-*"|xargs redis-cli -hredis地址 -a密码 del

2.3 STRING 字符串的操作

redis中的String在在内存中按照一个name对应一个value来存储。如图:

方法

作用

参数说明

示例

示例说明

示例结果

set(name, value)

给数据库中键为name的string赋予值value

name: 键名;value: 值

redis.set(‘name’, ‘Bob’)

给name这个键的value赋值为Bob

TRUE

get(name)

返回数据库中键为name的string的value

name:键名

redis.get(‘name’)

返回name这个键的value

b’Bob’

getset(name, value)

给数据库中键为name的string赋予值value并返回上次的value

name:键名;value:新值

redis.getset(‘name’, ‘Mike’)

赋值name为Mike并得到上次的value

b’Bob’

mget(keys, *args)

返回多个键对应的value

keys:键的列表

redis.mget([‘name’, ‘nickname’])

返回name和nickname的value

[b’Mike’, b’Miker’]

setnx(name, value)

如果不存在这个键值对,则更新value,否则不变

name:键名

redis.setnx(‘newname’, ‘James’)

如果newname这个键不存在,则设置值为James

第一次运行结果是True,第二次运行结果是False

setex(name, time, value)

设置可以对应的值为string类型的value,并指定此键值对应的有效期

name: 键名;time: 有效期; value:值

redis.setex(‘name’, 1, ‘James’)

将name这个键的值设为James,有效期为1秒

TRUE

setrange(name, offset, value)

设置指定键的value值的子字符串

name:键名;offset:偏移量;value:值

redis.set(‘name’, ‘Hello’) redis.setrange(‘name’, 6, ‘World’)

设置name为Hello字符串,并在index为6的位置补World

11,修改后的字符串长度

mset(mapping)

批量赋值

mapping:字典

redis.mset({‘name1’: ‘Durant’, ‘name2’: ‘James’})

将name1设为Durant,name2设为James

TRUE

msetnx(mapping)

键均不存在时才批量赋值

mapping:字典

redis.msetnx({‘name3’: ‘Smith’, ‘name4’: ‘Curry’})

在name3和name4均不存在的情况下才设置二者值

TRUE

incr(name, amount=1)

键为name的value增值操作,默认为1,键不存在则被创建并设为amount

name:键名;amount:增长的值

redis.incr(‘age’, 1)

age对应的值增1,若不存在,则会创建并设置为1

1,即修改后的值

decr(name, amount=1)

键为name的value减值操作,默认为1,键不存在则被创建并将value设置为-amount

name:键名; amount:减少的值

redis.decr(‘age’, 1)

age对应的值减1,若不存在,则会创建并设置为-1

-1,即修改后的值

append(key, value)

键为name的string的值附加value

key:键名

redis.append(‘nickname’, ‘OK’)

向键为nickname的值后追加OK

13,即修改后的字符串长度

substr(name, start, end=-1)

返回键为name的string的子串

name:键名;start:起始索引;end:终止索引,默认为-1,表示截取到末尾

redis.substr(‘name’, 1, 4)

返回键为name的值的字符串,截取索引为1~4的字符

b’ello’

getrange(key, start, end)

获取键的value值从start到end的子字符串

key:键名;start:起始索引;end:终止索引

redis.getrange(‘name’, 1, 4)

返回键为name的值的字符串,截取索引为1~4的字符

b’ello’

  1. r.set 设置值
#在Redis中设置值,默认不存在则创建,存在则修改
r.set('name', 'zhangsan')
'''参数:
set(name, value, ex=None, px=None, nx=False, xx=False)
ex,过期时间(秒)
px,过期时间(毫秒)
nx,如果设置为True,则只有name不存在时,当前set操作才执行,同setnx(name, value)
xx,如果设置为True,则只有name存在时,当前set操作才执行'''
  1. r.get 获取值
r.get('name')
  1. mset 批量设置值
#批量设置值
r.mset(name1='zhangsan', name2='lisi')
#或
r.mget({"name1":'zhangsan', "name2":'lisi'})
  1. mset 批量设置值
#批量设置值
r.mset(name1='zhangsan', name2='lisi')
#或
r.mget({"name1":'zhangsan', "name2":'lisi'})
  1. getset 设置新值,打印原值
#设置新值,打印原值
getset(name, value)  

print(r.getset("name1","wangwu")) #输出:zhangsan
print(r.get("name1")) #输出:wangwu
  1. mget(keys, *args) 批量获取
#批量获取
print(r.mget("name1","name2"))
#或
li=["name1","name2"]
print(r.mget(li))

7 setrange 修改字符串内容,从指定字符串索引开始向后替换,如果新值太长时,则向后添加

#修改字符串内容,从指定字符串索引开始向后替换,如果新值太长时,则向后添加
setrange(name, offset, value) 

r.set("name","zhangsan")
r.setrange("name",1,"z")
print(r.get("name")) #输出:zzangsan
r.setrange("name",6,"zzzzzzz")
print(r.get("name")) #输出:zzangszzzzzzz
  1. getset 设置新值,打印原值
#设置新值,打印原值
getset(name, value)  
print(r.getset("name1","wangwu")) #输出:zhangsan
print(r.get("name1")) #输出:wangwu
  1. getrange 根据字节获取子序列
    #根据字节获取子序列
    getrange(key, start, end) 
    r.set("name","zhangsan")
    print(r.getrange("name",0,3))#输出:zhan
  1. append 在name对应的值后面追加内容
#在name对应的值后面追加内容
append(name, value)

r.set("name","zhangsan")
print(r.get("name"))    #输出:'zhangsan
r.append("name","lisi")
print(r.get("name"))    #输出:zhangsanlisi
  1. setrange 修改字符串内容,从指定字符串索引开始向后替换,如果新值太长时,则向后添加 #修改字符串内容,从指定字符串索引开始向后替换,如果新值太长时,则向后添加
setrange(name, offset, value) 
r.set("name","zhangsan")
r.setrange("name",1,"z")
print(r.get("name")) #输出:zzangsan
r.setrange("name",6,"zzzzzzz")
print(r.get("name")) #输出:zzangszzzzzzz
  1. strlen(name) 返回name对应值的字节长度
#返回name对应值的字节长度(一个汉字3个字节)
r.set("name","zhangsan")
print(r.strlen("name")) #输出:8
  1. incr 值的累加 amount为累加的值
#自增mount对应的值,当mount不存在时,则创建mount=amount,否则,则自增,amount为自增数(整数)
incr(self, name, amount=1) 
print(r.incr("mount",amount=2))#输出:2
print(r.incr("mount"))#输出:3
print(r.incr("mount",amount=3))#输出:6
print(r.incr("mount",amount=6))#输出:12
print(r.get("mount")) #输出:12
  1. append 在name对应的值后面追加内容
#在name对应的值后面追加内容
append(name, value)
r.set("name","zhangsan")
print(r.get("name"))    #输出:'zhangsan
r.append("name","lisi")
print(r.get("name"))    #输出:zhangsanlisi

15.type 查看类型

r.type(name)	

来看一个案例:页面点击数

假定我们对一系列页面需要记录点击次数。例如论坛的每个帖子都要记录点击次数,而点击次数比回帖的次数的多得多。如果使用关系数据库来存储点击,可能存在大量的行级锁争用。所以,点击数的增加使用redis的INCR命令最好不过了。

​ 当redis服务器启动时,可以从关系数据库读入点击数的初始值(1237这个页面被访问了34634次)

r.set("visit:1237:totals",34634)
# 每当有一个页面点击,则使用INCR增加点击数即可。
r.incr("visit:1237:totals")
#@页面载入的时候则可直接获取这个值

r.get ("visit:1237:totals")

2.4 Hash 操作

redis中的Hash 在内存中类似于一个name对应一个dic来存储。

方法

作用

参数说明

示例

示例说明

示例结果

hset(name, key, value)

向键为name的散列表中添加映射

name:键名;key:映射键名;value:映射键值

hset(‘price’, ‘cake’, 5)

向键为price的散列表中添加映射关系,cake的值为5

1,即添加的映射个数

hsetnx(name, key, value)

如果映射键名不存在,则向键为name的散列表中添加映射

name:键名;key:映射键名;value:映射键值

hsetnx(‘price’, ‘book’, 6)

向键为price的散列表中添加映射关系,book的值为6

1,即添加的映射个数

hget(name, key)

返回键为name的散列表中key对应的值

name:键名;key:映射键名

redis.hget(‘price’, ‘cake’)

获取键为price的散列表中键名为cake的值

5

hmget(name, keys, *args)

返回键为name的散列表中各个键对应的值

name:键名;keys:映射键名列表

redis.hmget(‘price’, [‘apple’, ‘orange’])

获取键为price的散列表中apple和orange的值

[b’3’, b’7’]

hmset(name, mapping)

向键为name的散列表中批量添加映射

name:键名;mapping:映射字典

redis.hmset(‘price’, {‘banana’: 2, ‘pear’: 6})

向键为price的散列表中批量添加映射

TRUE

hincrby(name, key, amount=1)

将键为name的散列表中映射的值增加amount

name:键名;key:映射键名;amount:增长量

redis.hincrby(‘price’, ‘apple’, 3)

key为price的散列表中apple的值增加3

6,修改后的值

hexists(name, key)

键为name的散列表中是否存在键名为键的映射

name:键名;key:映射键名

redis.hexists(‘price’, ‘banana’)

键为price的散列表中banana的值是否存在

TRUE

hdel(name, *keys)

在键为name的散列表中,删除键名为键的映射

name:键名;keys:映射键名

redis.hdel(‘price’, ‘banana’)

从键为price的散列表中删除键名为banana的映射

TRUE

hlen(name)

从键为name的散列表中获取映射个数

name: 键名

redis.hlen(‘price’)

从键为price的散列表中获取映射个数

6

hkeys(name)

从键为name的散列表中获取所有映射键名

name:键名

redis.hkeys(‘price’)

从键为price的散列表中获取所有映射键名

[b’cake’, b’book’, b’banana’, b’pear’]

hvals(name)

从键为name的散列表中获取所有映射键值

name:键名

redis.hvals(‘price’)

从键为price的散列表中获取所有映射键值

[b’5’, b’6’, b’2’, b’6’]

hgetall(name)

从键为name的散列表中获取所有映射键值对

name:键名

redis.hgetall(‘price’)

从键为price的散列表中获取所有映射键值对

{b’cake’: b’5’, b’book’: b’6’, b’orange’: b’7’, b’pear’: b’6’}

  1. hset name对应的hash中设置一个键值对(不存在,则创建,否则,修改)
	#name对应的hash中设置一个键值对(不存在,则创建,否则,修改)
	hset(name, key, value)
	r.hset("dic_name","a1","aa")
  1. hget 在name对应的hash中根据key获取value
r.hset("dic_name","a1","aa")
#在name对应的hash中根据key获取value
hget(name,key) 

print(r.hget("dic_name","a1"))#输出:aa
  1. hgetall 获取name对应hash的所有键值
#获取name对应hash的所有键值
hgetall(name)

print(r.hgetall("dic_name"))
  1. hmset 在name对应的hash中批量设置键值对,mapping:字典
#在name对应的hash中批量设置键值对,mapping:字典
hmset(name, mapping) 

dic={"a1":"aa","b1":"bb"}
r.hmset("dic_name",dic)
print(r.hget("dic_name","b1"))#输出:bb
  1. hmget 在name对应的hash中获取多个key的值
# 在name对应的hash中获取多个key的值
hmget(name, keys, *args) 

li=["a1","b1"]
print(r.hmget("dic_name",li))
print(r.hmget("dic_name","a1","b1"))

hlen 获取hash中键值对的个数 hkeys 获取hash中所有的key的值 hvals 获取hash中所有的value的值

dic={"a1":"aa","b1":"bb"}
r.hmset("dic_name",dic)

#hlen(name) 获取hash中键值对的个数
print(r.hlen("dic_name"))

#hkeys(name) 获取hash中所有的key的值
print(r.hkeys("dic_name"))   # ['a1','b1']

#hvals(name) 获取hash中所有的value的值
print(r.hvals("dic_name"))
  1. hexists 检查name对应的hash是否存在当前传入的key
#检查name对应的hash是否存在当前传入的key
hexists(name, key)

print(r.hexists("dic_name","a1"))#输出:True
  1. hdel 删除指定name对应的key所在的键值对
#删除指定name对应的key所在的键值对
hdel(name,*keys)    

r.hdel("dic_name","a1")
  1. hincrby 自增hash中key对应的值,不存在则创建key=amount(amount为整数)
#自增hash中key对应的值,不存在则创建key=amount(amount为整数)
hincrby(name, key, amount=1)

print(r.hincrby("demo","a",amount=2))

案例

使用hash类型保存多样化对象,类似二维表结构

当有大量类型文档的对象,文档的内容都不一样时,(即“表”没有固定的列),可以使用hash来表达。

>>> r.hset('users:jdoe',  'name', "John Doe")

1L

>>> r.hset('users:jdoe', 'email', 'John@test.com')

1L

>>> r.hset('users:jdoe',  'phone', '1555313940')

1L

>>> r.hincrby('users:jdoe', 'visits', 1)

1L

>>> r.hgetall('users:jdoe')

{'phone': '1555313940', 'name': 'John Doe', 'visits': '1', 'email': 'John@test.com'}

>>> r.hkeys('users:jdoe')

['name', 'email', 'phone', 'visits']

2.5 List 操作

redis中的List在内存中按照一个name对应一个List来存储

方法

作用

参数说明

示例

示例说明

示例结果

rpush(name, *values)

在键为name的列表末尾添加值为value的元素,可以传多个

name:键名;values:值

redis.rpush(‘list’, 1, 2, 3)

向键为list的列表尾添加1、2、3

3,列表大小

lpush(name, *values)

在键为name的列表头添加值为value的元素,可以传多个

name:键名;values:值

redis.lpush(‘list’, 0)

向键为list的列表头部添加0

4,列表大小

llen(name)

返回键为name的列表的长度

name:键名

redis.llen(‘list’)

返回键为list的列表的长度

4

lrange(name, start, end)

返回键为name的列表中start至end之间的元素

name:键名;start:起始索引;end:终止索引

redis.lrange(‘list’, 1, 3)

返回起始索引为1终止索引为3的索引范围对应的列表

[b’3’, b’2’, b’1’]

ltrim(name, start, end)

截取键为name的列表,保留索引为start到end的内容

name:键名;start:起始索引;end:终止索引

ltrim(‘list’, 1, 3)

保留键为list的索引为1到3的元素

TRUE

lindex(name, index)

返回键为name的列表中index位置的元素

name:键名;index:索引

redis.lindex(‘list’, 1)

返回键为list的列表索引为1的元素

b’2’

lset(name, index, value)

给键为name的列表中index位置的元素赋值,越界则报错

name:键名;index:索引位置;value:值

redis.lset(‘list’, 1, 5)

将键为list的列表中索引为1的位置赋值为5

TRUE

lrem(name, count, value)

删除count个键的列表中值为value的元素

name:键名;count:删除个数;value:值

redis.lrem(‘list’, 2, 3)

将键为list的列表删除两个3

1,即删除的个数

lpop(name)

返回并删除键为name的列表中的首元素

name:键名

redis.lpop(‘list’)

返回并删除名为list的列表中的第一个元素

b’5’

rpop(name)

返回并删除键为name的列表中的尾元素

name:键名

redis.rpop(‘list’)

返回并删除名为list的列表中的最后一个元素

b’2’

blpop(keys, timeout=0)

返回并删除名称在keys中的list中的首个元素,如果列表为空,则会一直阻塞等待

keys:键列表;timeout: 超时等待时间,0为一直等待

redis.blpop(‘list’)

返回并删除键为list的列表中的第一个元素

[b’5’]

brpop(keys, timeout=0)

返回并删除键为name的列表中的尾元素,如果list为空,则会一直阻塞等待

keys:键列表;timeout:超时等待时间,0为一直等待

redis.brpop(‘list’)

返回并删除名为list的列表中的最后一个元素

[b’2’]

rpoplpush(src, dst)

返回并删除名称为src的列表的尾元素,并将该元素添加到名称为dst的列表头部

src:源列表的键;dst:目标列表的key

redis.rpoplpush(‘list’, ‘list2’)

将键为list的列表尾元素删除并将其添加到键为list2的列表头部,然后返回

b’2’

  1. lpush 在name对应的list中添加元素,每个新的元素都添加到列表的最左边
# 在name对应的list中添加元素,每个新的元素都添加到列表的最左边
lpush(name,values)

r.lpush("list_name",2)
r.lpush("list_name",3,4,5)#保存在列表中的顺序为5,4,3,2

2.rpush 同lpush,但每个新的元素都添加到列表的最右边

#同lpush,但每个新的元素都添加到列表的最右边
rpush(name,values)
  1. lpushx 在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边
#在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边
 lpushx(name,value)
  1. rpushx 在name对应的list中添加元素,只有name已经存在时,值添加到列表的最右边
#在name对应的list中添加元素,只有name已经存在时,值添加到列表的最右边
 rpushx(name,value)
  1. llen name对应的list元素的个数
# name对应的list元素的个数
llen(name)

print(r.llen("list_name"))
  1. linsert 在name对应的列表的某一个值前或后插入一个新值
# 在name对应的列表的某一个值前或后插入一个新值
 linsert(name, where, refvalue, value))
r.linsert("list_name","BEFORE","2","SS")#在列表内找到第一个元素2,在它前面插入SS

'''参数:
     name: redis的name
     where: BEFORE(前)或AFTER(后)
     refvalue: 列表内的值
     value: 要插入的数据'''
  1. r.lset 对list中的某一个索引位置重新赋值
#对list中的某一个索引位置重新赋值
r.lset(name, index, varlue)

r.lset("list_name",0,"bbb")
  1. r.lrem 删除name对应的list中的指定值
#删除name对应的list中的指定值
r.lrem(name, value, num=0) 
r.lrem("list_name",'ssss',2)

''' 参数:
    name:  redis的name
    value: 要删除的值
    num:   num=0 删除列表中所有的指定值;
           num=2 从前到后,删除2个;
           num=-2 从后向前,删除2个'''
  1. lpop 移除列表的左侧第一个元素,返回值则是第一个元素
#移除列表的左侧第一个元素,返回值则是第一个元素
lpop(name) 

print(r.lpop("list_name"))
  1. lindex 根据索引获取列表内元素
#根据索引获取列表内元素
lindex(name, index)

print(r.lindex("list_name",1))
  1. lrange 分片获取元素
#分片获取元素
lrange(name, start, end)

print(r.lrange("list_name",0,-1))
  1. ltrim 移除列表内没有在该索引之内的值(裁剪)
#移除列表内没有在该索引之内的值
ltrim(name, start, end)

r.ltrim("list_name",0,2)
  1. rpoplpush(src, dst) 从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
# 从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
#src 要取数据的列表
#dst 要添加数据的列表

2.6 Set 操作

Set集合就是不允许重复的列表

方法

作用

参数说明

示例

示例说明

示例结果

sadd(name, *values)

向键为name的集合中添加元素

name:键名;values:值,可为多个

redis.sadd(‘tags’, ‘Book’, ‘Tea’, ‘Coffee’)

向键为tags的集合中添加Book、Tea和Coffee这3个内容

3,即插入的数据个数

srem(name, *values)

从键为name的集合中删除元素

name:键名;values:值,可为多个

redis.srem(‘tags’, ‘Book’)

从键为tags的集合中删除Book

1,即删除的数据个数

spop(name)

随机返回并删除键为name的集合中的一个元素

name:键名

redis.spop(‘tags’)

从键为tags的集合中随机删除并返回该元素

b’Tea’

smove(src, dst, value)

从src对应的集合中移除元素并将其添加到dst对应的集合中

src:源集合;dst:目标集合;value:元素值

redis.smove(‘tags’, ‘tags2’, ‘Coffee’)

从键为tags的集合中删除元素Coffee并将其添加到键为tags2的集合

TRUE

scard(name)

返回键为name的集合的元素个数

name:键名

redis.scard(‘tags’)

获取键为tags的集合中的元素个数

3

sismember(name, value)

测试member是否是键为name的集合的元素

name:键值

redis.sismember(‘tags’, ‘Book’)

判断Book是否是键为tags的集合元素

TRUE

sinter(keys, *args)

返回所有给定键的集合的交集

keys:键列表

redis.sinter([‘tags’, ‘tags2’])

返回键为tags的集合和键为tags2的集合的交集

{b’Coffee’}

sinterstore(dest, keys, *args)

求交集并将交集保存到dest的集合

dest:结果集合;keys:键列表

redis.sinterstore(‘inttag’, [‘tags’, ‘tags2’])

求键为tags的集合和键为tags2的集合的交集并将其保存为inttag

1

sunion(keys, *args)

返回所有给定键的集合的并集

keys:键列表

redis.sunion([‘tags’, ‘tags2’])

返回键为tags的集合和键为tags2的集合的并集

{b’Coffee’, b’Book’, b’Pen’}

sunionstore(dest, keys, *args)

求并集并将并集保存到dest的集合

dest:结果集合;keys:键列表

redis.sunionstore(‘inttag’, [‘tags’, ‘tags2’])

求键为tags的集合和键为tags2的集合的并集并将其保存为inttag

3

sdiff(keys, *args)

返回所有给定键的集合的差集

keys:键列表

redis.sdiff([‘tags’, ‘tags2’])

返回键为tags的集合和键为tags2的集合的差集

{b’Book’, b’Pen’}

sdiffstore(dest, keys, *args)

求差集并将差集保存到dest集合

dest:结果集合;keys:键列表

redis.sdiffstore(‘inttag’, [‘tags’, ‘tags2’])

求键为tags的集合和键为tags2的集合的差集并将其保存为inttag`

3

smembers(name)

返回键为name的集合的所有元素

name:键名

redis.smembers(‘tags’)

返回键为tags的集合的所有元素

{b’Pen’, b’Book’, b’Coffee’}

srandmember(name)

随机返回键为name的集合中的一个元素,但不删除元素

name:键值

redis.srandmember(‘tags’)

随机返回键为tags的集合中的一个元素

  1. sadd(name,values) 给name对应的集合中添加元素
#给name对应的集合中添加元素
r.sadd("set_name","aa")
r.sadd("set_name","aa","bb")
  1. smembers(name) 获取name对应的集合的所有成员
#获取name对应的集合的所有成员
  1. scard(name) 获取name对应的集合中的元素个数
#获取name对应的集合中的元素个数
r.scard("set_name")
  1. sdiff(keys, *args) 在第一个name对应的集合中且不在其他name对应的集合的元素集合
#在第一个name对应的集合中且不在其他name对应的集合的元素集合
r.sadd("set_name","aa","bb")
r.sadd("set_name1","bb","cc")
r.sadd("set_name2","bb","cc","dd")

print(r.sdiff("set_name","set_name1","set_name2"))#输出:{aa}
  1. sinter(keys, *args) 获取多个name对应集合的并集
# 获取多个name对应集合的并集
r.sadd("set_name","aa","bb")
r.sadd("set_name1","bb","cc")
r.sadd("set_name2","bb","cc","dd")

print(r.sinter("set_name","set_name1","set_name2"))#输出:{bb}

8.sismember 检查value是否是name对应的集合内的元素

#检查value是否是name对应的集合内的元素
sismember(name, value)
  1. smove(src, dst, value) 将某个元素从一个集合中移动到另外一个集合
#将某个元素从一个集合中移动到另外一个集合
  1. spop(name) 从集合的右侧移除一个元素,并将其返回
#从集合的右侧移除一个元素,并将其返回
  1. srandmember(name, numbers) 从name对应的集合中随机获取numbers个元素
# 从name对应的集合中随机获取numbers个元素
print(r.srandmember("set_name2",2))
  1. srem(name, values) 删除name对应的集合中的某些值
#删除name对应的集合中的某些值
print(r.srem("set_name2","bb","dd"))
  1. sunion(keys, *args) 获取多个name对应的集合的并集
#获取多个name对应的集合的并集
r.sunion("set_name","set_name1","set_name2")
  1. sunionstore(dest,keys, *args) 获取多个name对应的集合的并集,并将结果保存到dest对应的集合中
#获取多个name对应的集合的并集,并将结果保存到dest对应的集合中

案例

社交圈子数据

在社交网站中,每一个圈子(circle)都有自己的用户群。通过圈子可以找到有共同特征(比如某一体育活动、游戏、电影等爱好者)的人。当一个用户加入一个或几个圈子后,系统可以向这个用户推荐圈子中的人。 ​ 我们定义这样两个圈子,并加入一些圈子成员。

>>> r.sadd('circle:game:lol','user:debugo')
1
>>> r.sadd('circle:game:lol','user:leo')
1
>>> r.sadd('circle:game:lol','user:Guo')
1
>>> r.sadd('circle:soccer:InterMilan','user:Guo')
1
>>> r.sadd('circle:soccer:InterMilan','user:Levis')
1
>>> r.sadd('circle:soccer:InterMilan','user:leo')
1
获取一个圈子的成员

>>> r.smembers('circle:game:lol')
set(['user:Guo', 'user:debugo', 'user:leo'])
可以使用集合运算来得到几个圈子的共同成员:

>>> r.sinter('circle:game:lol', 'circle:soccer:InterMilan')
set(['user:Guo', 'user:leo'])
>>> r.sunion('circle:game:lol', 'circle:soccer:InterMilan')
set(['user:Levis', 'user:Guo', 'user:debugo', 'user:leo'])

2.7 有序集合 zset

有序集合:   在集合的基础上,为每元素排序,元素的排序需要根据另外一个值来进行比较,所以,对于有序集合,每一个元素有两个值,即:值和分数,分数专门用来做排序。

方法

作用

参数说明

示例

示例说明

示例结果

zadd(name, *args, **kwargs)

向键为name的zset中添加元素member,score用于排序。如果该元素存在,则更新其顺序

name: 键名;args:可变参数

redis.zadd(‘grade’, 100, ‘Bob’, 98, ‘Mike’)

向键为grade的zset中添加Bob(其score为100),并添加Mike(其score为98)

2,即添加的元素个数

zrem(name, *values)

删除键为name的zset中的元素

name:键名;values:元素

redis.zrem(‘grade’, ‘Mike’)

从键为grade的zset中删除Mike

1,即删除的元素个数

zincrby(name, value, amount=1)

如果在键为name的zset中已经存在元素value,则将该元素的score增加amount;否则向该集合中添加该元素,其score的值为amount

name:key名;value:元素;amount:增长的score值

redis.zincrby(‘grade’, ‘Bob’, -2)

键为grade的zset中Bob的score减2

98.0,即修改后的值

zrank(name, value)

返回键为name的zset中元素的排名,按score从小到大排序,即名次

name:键名;value:元素值

redis.zrank(‘grade’, ‘Amy’)

得到键为grade的zset中Amy的排名

1

zrevrank(name, value)

返回键为name的zset中元素的倒数排名(按score从大到小排序),即名次

name:键名;value:元素值

redis.zrevrank(‘grade’, ‘Amy’)

得到键为grade的zset中Amy的倒数排名

2

zrevrange(name, start, end, withscores=False)

返回键为name的zset(按score从大到小排序)中index从start到end的所有元素

name:键值;start:开始索引;end:结束索引;withscores:是否带score

redis.zrevrange(‘grade’, 0, 3)

返回键为grade的zset中前四名元素

[b’Bob’, b’Mike’, b’Amy’, b’James’]

zrangebyscore(name, min, max, start=None, num=None, withscores=False)

返回键为name的zset中score在给定区间的元素

name:键名;min:最低score;max:最高score; start:起始索引;num:个数;withscores:是否带score

redis.zrangebyscore(‘grade’, 80, 95)

返回键为grade的zset中score在80和95之间的元素

[b’Bob’, b’Mike’, b’Amy’, b’James’]

zcount(name, min, max)

返回键为name的zset中score在给定区间的数量

name:键名;min:最低score;max:最高score

redis.zcount(‘grade’, 80, 95)

返回键为grade的zset中score在80到95的元素个数

2

zcard(name)

返回键为name的zset的元素个数

name:键名

redis.zcard(‘grade’)

获取键为grade的zset中元素的个数

3

zremrangebyrank(name, min, max)

删除键为name的zset中排名在给定区间的元素

name:键名;min:最低位次;max:最高位次

redis.zremrangebyrank(‘grade’, 0, 0)

删除键为grade的zset中排名第一的元素

1,即删除的元素个数

zremrangebyscore(name, min, max)

删除键为name的zset中score在给定区间的元素

name:键名;min:最低score;max:最高score

redis.zremrangebyscore(‘grade’, 80, 90)

删除score在80到90之间的元素

1,即删除的元素个数

  1. zadd(name, args, *kwargs)
# 在name对应的有序集合中添加元素
r.zadd("zset_name", 6,"a1", 2, "a2", 5,"a3")
#或
r.zadd('zset_name1', b1=10, b2=5)
  1. zcard(name) 获取有序集合内元素的数量
#获取有序集合内元素的数量
  1. zcount(name, min, max) 获取有序集合中分数在[min,max]之间的个数
#获取有序集合中分数在[min,max]之间的个数
print(r.zcount("zset_name",1,5))
  1. zincrby(name, value, amount) 自增有序集合内value对应的分数
#自增有序集合内value对应的分数
r.zincrby("zset_name","a1",amount=2)#自增zset_name对应的有序集合里a1对应的分数

r.zincrby("zset_name","a1") # 如果不指定a1 则自动创建a1,并将score设为1,再次执行则a1的score变为2,以此类推
  1. zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
# 按照索引范围获取name对应的有序集合的元素
aa=r.zrange("zset_name",0,1,desc=False,withscores=True,score_cast_func=int)
print(aa)
'''参数:
    name    redis的name
    start   有序集合索引起始位置
    end     有序集合索引结束位置
    desc    排序规则,默认按照分数从小到大排序
    withscores  是否获取元素的分数,默认只获取元素的值
    score_cast_func 对分数进行数据转换的函数'''
  1. zrevrange(name, start, end, withscores=False, score_cast_func=float)
#同zrange,集合是从大到小排序的
[(value1, score1),(value2, score2)..]
  1. zrank(name, value)、zrevrank(name, value)
#获取value值在name对应的有序集合中的排行位置(从0开始)
print(r.zrank("zset_name", "a2"))

print(r.zrevrank("zset_name", "a2"))#从大到小排序
  1. zscore(name, value) 获取name对应有序集合中 value 对应的分数
#获取name对应有序集合中 value 对应的分数
print(r.zscore("zset_name","a1"))
  1. zrem(name, values) 删除name对应的有序集合中值是values的成员
#删除name对应的有序集合中值是values的成员
r.zrem("zset_name","a1","a2")
  1. zremrangebyrank(name, min, max) 根据排行范围删除
#根据排行范围删除
  1. zremrangebyscore(name, min, max) 根据分数范围删除
#根据分数范围删除
  1. zinterstore(dest, keys, aggregate=None)
r.zadd("zset_name", "a1", 6, "a2", 2,"a3",5)
r.zadd('zset_name1', a1=7,b1=10, b2=5)

# 获取两个有序集合的交集并放入dest集合,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为: SUM  MIN  MAX
r.zinterstore("zset_name2",("zset_name1","zset_name"),aggregate="MAX")
print(r.zscan("zset_name2"))
  1. zunionstore(dest, keys, aggregate=None)
#获取两个有序集合的并集并放入dest集合,其他同zinterstore,

3 管道

redis-py默认在执行每次请求都会创建(连接池申请连接)和断开(归还连接池)一次连接操作,如果想要在一次请求中指定多个命令,则可以使用pipline实现一次请求指定多个命令,并且默认情况下一次pipline 是原子性操作。

3.1 相关案例

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import redis
 
pool = redis.ConnectionPool(host='192.168.22.132', port=6379)
r = redis.Redis(connection_pool=pool)

# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)

pipe.set('name', 'root')
pipe.set('role', 'root')

pipe.execute()
>>> ['Alin', 'Lnda', 'Tony']

其中:

# 事务:python可以使用管道来代替事务
import redis,time
import redis.exceptions
r = redis.Redis(host=host,port=port,decode_responses=True)
pipe = r.pipeline()
print(r.get('name1'))

try:
    pipe.multi()
    pipe.set('age1',22)
    pipe.set('age2',23)
    pipe.set('age3',24)
    time.sleep(5)
    pipe.execute()
    print(r.mget('age1','age2','age3'))
except redis.exceptions.WatchError as e:
    print('Error')

3.2 管道与连接池

或者使用pipeline(管道),通过缓冲多条命令,然后一次性执行的方法减少服务器-客户端之间TCP数据库包,从而提高效率,方法如下:

pool = redis.ConnectionPool(host=host, port=6379, password=password)
r = redis.StrictRedis(connection_pool=pool

接上文
pipe = r.pipeline()
#插入数据
>>> pipe.hset("hash_key","leizhu900516",8)
Pipeline<ConnectionPool<Connection<host=192.168.8.176,port=6379,db=0>>>
>>> pipe.hset("hash_key","chenhuachao",9)
Pipeline<ConnectionPool<Connection<host=192.168.8.176,port=6379,db=0>>>
>>> pipe.hset("hash_key","wanger",10)
Pipeline<ConnectionPool<Connection<host=192.168.8.176,port=6379,db=0>>>
>>> pipe.execute()
[1L, 1L, 1L]

批量读取数据的方法如下:

>>> pipe.hget("hash_key","leizhu900516")
Pipeline<ConnectionPool<Connection<host=192.168.8.176,port=6379,db=0>>>
>>> pipe.hget("hash_key","chenhuachao")
Pipeline<ConnectionPool<Connection<host=192.168.8.176,port=6379,db=0>>>
>>> pipe.hget("hash_key","wanger")
Pipeline<ConnectionPool<Connection<host=192.168.8.176,port=6379,db=0>>>
>>> result = pipe.execute()
>>> print result
['8', '9', '10']   #有序的列表

pipeline的命令可以写在一起,如p.set('hello','redis').sadd('faz','baz').incr('num').execute(),其实它的意思等同于是:

>>> p.set('hello','redis')
>>> p.sadd('faz','baz')
>>> p.incr('num')
>>> p.execute()
[True, 1, 1]

利用pipeline取值3500条数据,大约需要900ms,如果配合线程or协程来使用,每秒返回1W数据是没有问题的,基本能满足大部分业务。


4 发布与订阅

案例一:

#!/usr/bin/env python
# -*- coding:utf8 -*-

import redis

class RedisHelper(object):

    def __init__(self):
        self.__conn = redis.Redis(host='localhost')   #连接本机,ip不用写
        self.chan_sub = 'fm104.5'
        self.chan_pub = 'fm86'  #这个频道没用到啊...

    def public(self,msg):
        self.__conn.publish(self.chan_sub,msg)
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()
        pub.subscribe(self.chan_sub)  #订阅的频道
        pub.parse_response()  #准备好监听(再调用一次就是开始监听)
        return pub

其中: redis订阅:

#!/usr/bin/env python
# -*- coding:utf8 -*-

from redis_helper import RedisHelper

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response()
    print(msg)   #[b'message', b'fm104.5', b'who are you?']
    # print(msg[2].decode('utf8'))

redis发布:

#!/usr/bin/env python
# -*- coding:utf8 -*-

'''
发布与订阅是不同于存值取值,存值取值不需要同步,发布与订阅是需要同步的
'''
'''
#这样是可以的,为了配套,使用下面的
import redis

obj = redis.Redis(password='helloworld')
obj.publish('fm104.5','hello')

'''

from redis_helper import RedisHelper

obj = RedisHelper()
obj.public('hello')

案例二:最简收、发方

#发布方:

import redis

r = redis.Redis(host=host,port=port,decode_responses=True)

while True:
    msg = input('echo>>:')
    if len(msg) == 0:
        continue
    elif msg == 'quit':
        r.publish('cctv1',msg)
        break
    else:
        r.publish('cctv1',msg)
# 订阅方:
chan = r.pubsub() #返回一个发布订阅对象
msg_reciver = chan.subscribe('cctv1') #订阅

msg = chan.parse_response()  # 返回一个确认
print(msg)
print('订阅成功,开始接收...')

while True:
    msg = chan.parse_response()  #接收消息
    if msg[2] == 'quit':  #格式:类型,频道,消息
        break
    else:
        print('>>:', msg[2])

5 参考文献

python操作redis python – redis连接与使用 使用python调用redis的基本操作 Python操作Redis,你要的都在这了!

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • neo4j︱图数据库基本概念、操作罗列与整理(一)

    版权声明:博主原创文章,微信公众号:素质云笔记,转载请注明来源“素质云博客”,谢谢合作!! ...

    素质
  • 近邻模块︱apple.Turicreate中相似判定Nearest Neighbors(四)

    也是目前求相似解决方案很赞的一个。 官方地址:https://apple.github.io/turicreate/docs/api/turicreate....

    素质
  • neo4j︱与python结合的py2neo使用教程(四)

    版权声明:博主原创文章,微信公众号:素质云笔记,转载请注明来源“素质云博客”,谢谢合作!! ...

    素质
  • 【Python基础】函数的返回

    很多时候,函数并非直接输出,相反,它可以处理一些数据,并返回一个值或者一组值,称之为返回值。

    DataScience
  • python通过配置文件共享全局变量

    在使用Python编写的应用的过程中,有时会遇到多个文件之间传递同一个全局变量的情况,此时通过配置文件定义全局变量是一个比较好的选择。

    十四君
  • Oracle通过substr,instr,translate函数的组合获取日期分割表

    写这一篇文章也是因为项目从SQL数据库导入Oracle数据库中遇到的问题,主要是我们要导入的数据有年月的分割表的查询。

    Vaccae
  • [python]父类、子类、子类实例属性

    py3study
  • redis缓存数据库

    NoSQL(NoSQL = Not Only SQL ),意即“不仅仅是SQL”,泛指非关系型的数据库,随着互联网web2.0网站的兴起,传统的关系数据库在应...

    菲宇
  • python操作数据库

    pip install redispy 参考:https://www.cnblogs.com/john-xiong/p/12089103.html

    sofu456
  • Python操作Redis的最佳实践

    致码DevOps

扫码关注云+社区

领取腾讯云代金券