首页 / PYTHON / redis之pythonApi操作

redis之pythonApi操作

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了redis之pythonApi操作，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含17633字，纯文字阅读大概需要26分钟。

内容图文

01 redis入门

1 redis介绍

1.1 什么是redis?

redis是一款键值型内存数据库软件，它没有表默认有0-15号仓库

是存储数据的软件，跟语言无关，纯内存数据库（所有数据都放在内存中）

速度非常快，支持的数据类型多样（5 大数据类型：字符串，列表，字典，集合，有序集合）

1.2Memcached和redis比较

? redis是单线程，单进程，数据类型丰富（只针对于 redis 6.0以下）
? memcache多线程多进程，数据类型单一，

1.2redis为什么单线程，单进程速度这么快？

官方说redis有10w的并发量，实际生产当作redis有6W左右的高并发
纯内存数据库
io多路复用，epoll模型（linux上支持），windows上支持select
单线程单进程，避免了线程间切换

redis：开源软件，c语言写的，早起版本2w3千行，对windows不支持 6.0.6
-在不同平台编译---》可执行文件---》执行
-windows官方：又有大神把源码，在windows上编译--》可以允许在windows上（3.x）

2 redis在windows安装和配置

2.1：下载

下载window版本的redis,然后下一步下一步即可，这个redis版本比较老了，这个是因为redis用的是

epoll模型，window系统不支持，它只支持select模型

redis 的默认端口是6379

2.2：启动服务的两种形式

        redis-server # 使用的默认的配置文件

        reids-server redis.conf # 使用配置文件

安装好后redis所在自动加入了环境变量中，且自动加入到服务当中，你可设置开机自启，还是手动启动，配置文件也在该目录下

2.3：命令连接redis服务

        reids -h host -p port -a password

2.4：图形化连接redis服务

下载连接现在收费了你可以下载我的，安装下一步下一步

技术分享图片

3 普通连接和连接池(使用Python语言客户端建立连接)

3.1：安装

        pip install redis

3.2连接数据库

        import redis
client = redis.Redis(
    host=‘localhost‘,  # 数据库地址
    port=6379,  # 数据库端口
    password=‘123456‘ # 数据库密码
    )

client.set(‘nginx‘,"{‘name‘:‘nginx‘,‘age‘:18,‘gender‘:‘男‘}") # 这个是在redis数据库中添加了一个值
res = client.get(‘nginx‘) # 获取值
print(res.decode(‘utf-8‘))  
client.close() # 关闭数据连接

技术分享图片

3.3：使用池子连接

        import redis

pool = redis.ConnectionPool(
    max_connections=10, # 池最大连接数
    host=‘localhost‘,  #主机地址
    password=123456,  # 数据库密码
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)  # 连接连接池 
res = client.get(‘nginx‘)  # 获取可以‘nginx’的值
print(res.decode(‘utf-8‘)) # 打印值

3.4：对连接池进行性能优化（使用单例模式)

使用单例可以防止连接池重复创建

con_pool.py

        import redis
pool = redis.ConnectionPool(
    max_connections=10,
    port=6379,
    password=123456,
    host=‘localhost‘)

client.py

        import redis
from con_pool import pool  # 导入连接池

client = redis.Redis(connection_pool=pool)  # 连接连接池 
res = client.get(‘nginx‘)  # 获取key为‘nginx’的值
print(res.decode(‘utf-8‘)) # 打印值

4：操作string数据类型(使用python Api连接redis)

下述查询结果都是bytes类型

4.0:连接数据库

        import redis


pool = redis.ConnectionPool(
    max_connections=10,
    host=‘localhost‘,
    password=123456,
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)  # 连接连接池

4.1 set

        def set(self, name, value,
        ex=None, px=None, nx=False, xx=False, keepttl=False):
    pass
name: key的值
values: values的值
ex: 表示过期时间,默认时间为秒
px:表示过期时间为毫秒
nx:如果为True,表示name不存在则可以设值
xx:如果为True,表示name存在，则可以更新

        client.set(‘name‘,18)  # 设置一个k:name,v:18
print(client.get(‘name‘)) # b‘18‘

client.set(‘age‘,‘alex‘)
print(client.get(‘age‘))  # b‘alex‘

client.set(‘name‘,‘nginx‘,nx=True)
print(client.get(‘name‘)) # b‘alex‘

client.set(‘salary‘,1999,ex=10)
import time
print(client.get(‘salary‘))  # b‘1999‘
time.sleep(11)
print(client.get(‘salary‘)) # None


client.set(‘nginx‘,‘1.19‘,px=2000)
print(client.get(‘nginx‘)) # b‘1.19‘
import time
time.sleep(2)
print(client.get(‘nginx‘)) # None

4.2 get

        # 表示获取key对应的values
client.set(‘name‘,‘nbplus‘)
print(client.get(‘name‘))  # b‘nbplus‘

4.3 `setnx`

        # 等同于上面的set中参数nx=True,表示不存在则可以设值，存在不能更新

client.setnx(‘age‘,18)
print(client.get(‘age‘)) # b‘18‘
client.setnx(‘age‘,22)
print(client.get(‘age‘)) # b‘18‘

4.4 `setex`

        # 等同于上面的set中参数ex=1,表示过期时间为多少秒
client.setex(‘name‘,3,‘nginx‘)
print(client.get(‘name‘))  # b‘nginx‘
import time
time.sleep(3.1)
print(client.get(‘name‘))

4.5mset

        client.mset({‘name‘:"alex","age":18})
print(client.get(‘name‘)) # b‘alex‘

4.6mget

        res = client.mget(‘name‘,‘age‘) # 
print(res) # [b‘alex‘, b‘18‘]

4.7 `getset`

        # 先把旧值给取出来，然后再更新一个新值，一次网络io，完成了取值和设置
res = client.getset(‘name‘,‘alex111‘)
print(res) # b‘alex‘
print(client.get(‘name‘)) b‘alex111‘

4.8 getrange

        print(client.get(‘name‘))  # b‘alex111‘
res = client.getrange(‘name‘,1,2)  # 左闭右开
print(res)

4.9 setrange

        print(client.get(‘name‘))  # b‘alex111‘
client.setrange(‘name‘,1,‘zq‘) 
print(client.get(‘name‘)) # b‘azqx111‘

4.10 `setbit`

        # conn.set(‘n1‘,‘foo‘)
#那么字符串foo的二进制表示为：01100110 01101111 01101111
# conn.setbit(‘n1‘,7,1)
# #那么字符串foo的二进制表示为：01100111 01101111 01101111
# res=conn.get(‘n1‘)

4.11 `getbit`

        # getbit(name, offset)
# 获取bit位的第几个位置，看是1还是0
# res=conn.getbit(‘n1‘,7)
# print(res)

4.12 `bitcount`

        # bitcount(key, start=None, end=None)
# end:指的是bytes，前闭后闭区间
# res=conn.bitcount(‘n1‘,0,1)
# print(res)

4.13 incr

        print(client.get(‘age‘))
print(client.incr(‘age‘)) # 默认自增1

4.14 decr

        print(client.get(‘age‘)) 
print(client.decr(‘age‘))  # 默认自减1

4.14 append

        client.append(‘age‘,‘18‘) #后面追加1
print(client.get(‘age‘))

5：hash操作

5.0 连接

        import redis

pool = redis.ConnectionPool(max_connections=10, host=‘localhost‘, password=123456, port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)  # 连接连接池

5.1 hset

        # 设置字典中的k,v
client.hset(‘userinfo1‘,‘name‘,3.14159261) # 设hash值
print(client.hget(‘userinfo1‘,‘name‘))  # b‘3.14159261‘

技术分享图片

5.2 hmset

        # 在hash中一次设置多个k,v
client.hmset(‘web‘,{‘nginx‘:1.18,‘tomcat‘:3.6,‘uwsgi‘: 1.0})
print(client.hget(‘web‘,‘nginx‘))  # b‘1.18‘
print(client.hget(‘web‘,‘tomcat‘))  # b‘3.6‘
print(client.hget(‘web‘,‘uwsgi‘))   # b‘1.0‘

5.3 hget

        # 在hash中获取一个k对应的v
print(client.hget(‘web‘,‘uwsgi‘)) # b‘1.0‘

5.4 hmget

        # 在hash中一次性获取多个k,对应的v
res = client.hmget(‘web‘,‘nginx‘,‘tomcat‘,‘uwsgi‘)
print(res)  # [b‘1.18‘, b‘3.6‘, b‘1.0‘]

res = client.hmget(‘web‘,[‘nginx‘,‘tomcat‘,‘uwsgi‘])
print(res) # [b‘1.18‘, b‘3.6‘, b‘1.0‘]

5.5 hgetall

        #在hash中一次性获取所有，如果值够多，会挤爆内存，稍微注意一点
print(client.hgetall(‘web‘)) # {b‘nginx‘: b‘1.18‘, b‘tomcat‘: b‘3.6‘, b‘uwsgi‘: b‘1.0‘}

5.6`hlen`

        # 统计字典长度
print(client.hlen(‘web‘)) # 3

5.7 `hkeys`

        # 获取hash中的key
print(client.hkeys(‘web‘)) # [b‘nginx‘, b‘tomcat‘, b‘uwsgi‘]

5.8 `hvals`

        # 获取hash中的val
print(client.hvals(‘web‘)) # [b‘1.18‘, b‘3.6‘, b‘1.0‘]

5.9 hexists

        # 判断hash中的key是否存在
print(client.hexists(‘web‘,‘alex‘)) # False

print(client.hexists(‘web‘,‘nginx‘))  # True

5.10 hdel

        # 删除字典中的key对应的val
print(client.hgetall(‘web‘))
client.hdel(‘web‘,‘nginx‘)
print(client.hgetall(‘web‘))

5.11 hincrby

        # 在hash中的k所对应的v默认自增1
res = client.hset(‘test‘,‘num‘,1)
print(res) # 1
print(client.hincrby(‘test‘,‘num‘)) # 2

5.12 `hscan`

批量插入值

        dic = {}
for i in range(1001):
    dic.update({‘%s‘%i:‘test%s‘%i})
client.hmset(‘test01‘,dic)

        res = client.hscan(‘test01‘,cursor=1,count=10) # cursor是redis内部维护的一个随机的值，count一次性取10条
print(res)

5.13 hscan_iter

        res = client.hscan_iter(‘test01‘,match=None,count=10) # 生成器，节省内存,count一次性取多少个值，match匹配的是hash中的key 
print(res)
for i in res:
    print(i)

6：list

6.0连接数据库

        import redis


pool = redis.ConnectionPool(
    max_connections=10,
    host=‘localhost‘,
    password=123456,
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)  # 连接连接池

6.1 `lpush`

        client.lpush(‘list1‘,1,2,3,4,5,6)

技术分享图片

6.2 `lpushx`

        client.lpushx(‘list2‘,‘a‘,) # 存在就往list中添加值，值的位置在最左边

        client.lpushx(‘list1‘,‘a‘,)

技术分享图片

6.3`llen`

        # 统计list的长度
print(client.llen(‘list1‘))

6.4 `linsert`

        def linsert(self, name, where, refvalue, value):
    pass
name: redis的name
where:BEFORE或AFTER(小写也可以)
refvalue:标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
value:要插入的数据

        client.linsert(‘list1‘,‘after‘,‘a‘,‘after1‘)

技术分享图片

        client.linsert(‘list1‘,‘before‘,‘a‘,‘after2‘)

技术分享图片

6.5 `lset`

        client.lset(‘list1‘,1,‘nginx‘) # 索引从0开始，左闭右闭

技术分享图片

6.6 `lrem`

        def lrem(self, name, value, num=0):
    pass
# name，redis的name
# value，要删除的值
# num，  num=0，删除列表中所有的指定值；
    # num=2,从前到后，删除2个；
    # num=-2,从后向前，删除2个

        client.lrem(‘list1‘,‘after2‘,num=2)

技术分享图片

6.7`lpop`

技术分享图片

        # 把list表最左边边的值弹出来
res = client.lpop(‘list1‘)
print(res) # b‘6‘

技术分享图片

6.8`lindex`

        # 根据索引取值
res = client.lindex(‘list1‘,0)
print(res) #  b‘5‘

6.9`lrange`

        # list中范围的值
res = client.lrange(‘list1‘,0,2)
print(res) # [b‘5‘, b‘4‘, b‘3‘]

6.10`ltrim`

        res = client.ltrim(‘list1‘,0,2)  # 删除list中不在这范围种的值，左闭右闭
print(res) # 返回bool值

技术分享图片

6.11`rpoplpush`

技术分享图片

        client.lpush(‘list2‘,‘a‘,‘b‘,‘c‘) # 创建一个list

技术分享图片

        # 把源list中最右边的值弹出来，放到目标list的左边边，可以同时对一个list操作
client.rpoplpush(‘list1‘,list2)

6.12 `blpop`

技术分享图片

        # 这个是阻塞式弹出值，如果list为空，取值会阻塞，只有取值时，list不为空，则不阻塞
res = client.blpop(‘list1‘)
print(res) # (b‘list1‘, b‘5‘)

技术分享图片

6.13`brpoplpush`

        # 这个是阻塞式取值，如果源list中的值为空时，如果取值那么就会阻塞住，否则就去把最右边的值，取出来，放到目标list中的最右边

        res = client.rpoplpush(‘list1‘,‘list2‘)

6.14:封装一个可迭代取值的功能

实验数据

        import redis

pool = redis.ConnectionPool(
    max_connections=10,
    host=‘localhost‘,
    password=123456,
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)

lis = []
for i in range(10000):
    lis.append(‘test%s‘ %i)
client.lpush(‘test_list‘,*lis)

封装可迭代取值

        def list_scan_iter(name, con, count=10):
    """
    :param name: 这个是key的名称
    :param con:  这个是redis连接
    :param count:  # 这个是每一次取得范围
    :return: 
    """
    # 索引从0开始
    start = 0
    while True:
        # 每一次去的范围是list[start,(count + start -1)]
        data = con.lrange(name, start, (count + start) - 1)
        # 当数据为空时，自动退出循环
        if data:
            for item in data:
                # 使用yield关键字，可以挂起保存状态
                yield item
            # start每一次加10
            start += 10
        else:
            break


for i in list_scan_iter(‘test_list‘,client):
    print(i)

7：set操作

set操作，set集合就是不允许重复的列表

7.0：建立连接

        import redis

pool = redis.ConnectionPool(
    max_connections=10,
    host=‘localhost‘,
    password=123456,
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)

7.1 `sadd`

        # name对应的集合中添加元素
client.sadd(‘setname‘,1,2,3,4)

7.2 `scard`

        # 获取name对应的集合中元素个数
print(client.scard(‘setname‘)) # 4

7.3 `sdiff`

        # 在第一个name对应的集合中且不在其他name对应的集合的元素集合

        client.sadd(‘setname1‘,3,4)

技术分享图片

        print(client.sdiff(‘setname‘,‘setname1‘)) # {b‘1‘, b‘2‘}

7.4`sdiffstore`

技术分享图片

        #  获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中

        print(client.sdiffstore(‘dset‘,‘setname1‘,‘setname‘))

技术分享图片

7.5`sinter`

        # 获取多一个name对应集合的并集

        print(client.sinter(‘setname‘,‘setname1‘)) # {b‘4‘, b‘3‘}

7.6`sinterstore`

        # 获取多一个name对应集合的并集，再讲其加入到dest对应的集合中

        print(client.sinterstore(‘setname4‘,‘setname1‘,‘setname‘))

技术分享图片

7.7`sismember`

        # 检查value是否是name对应的集合的成员

        print(client.sismember(‘setname‘,3)) # True
# 返回bool值

7.8`smembers`

        # 获取name对应的集合的所有成员

        print(client.smembers(‘setname‘)) # {b‘4‘, b‘2‘, b‘3‘, b‘1‘}

7.9`smove`

        # 将某个成员从一个集合中移动到另外一个集合
print(client.smove(‘setname‘,‘setname1‘,‘1‘)) # True
#结果是bool值

7.10`spop`

        # 从集合的右侧（尾部）移除一个成员，并将其返回
print(client.spop(‘setname‘))

7.11`srandmember`

        # 从name对应的集合中随机获取 numbers 个元素
print(client.srandmember(‘setname‘,1)) # numbers个随机值 [b‘4‘]

7.12`srem`

        # 在name对应的集合中删除某些值
print(client.srem(‘setname‘,‘3‘)) # 返回0or1 # 成功返回1，否者反之

7.13`sunion`

        # 获取多一个name对应的集合的并集
print(client.sunion(‘setname1‘,‘setname2‘)) # {b‘4‘, b‘3‘, b‘1‘}

7.14`sunionstore`

        # 获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中
client.sunionstore(‘testset‘,‘setname1‘,‘setname2‘)

技术分享图片

7.15`sscan`

        # 获取name的所有元素
print(client.sscan(‘setname1‘,count=10))

7.16`sscan_iter`

        # 同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大
client.sscan_iter(‘setname1‘,count=10)  # 生成器

8:有序集合

有序集合，在集合的基础上，为每元素排序；

元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序

8.1 `zadd`

Zadd 命令用于将一个或多个成员元素及其分数值加入到有序集当中。
如果某个成员已经是有序集的成员，那么更新这个成员的分数值，并通过重新插入这个成员元素，来保证该成员在正确的位置上。
分数值可以是整数值或双精度浮点数。
如果有序集合 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
当 key 存在但不是有序集类型时，返回一个错误。

        # 在name对应的有序集合中添加元素
# 如：
     # zadd(‘zz‘, ‘n1‘, 1, ‘n2‘, 2)
     # 或
     # zadd(‘zz‘, n1=11, n2=22)

        client.zadd(‘zset1‘,n1,1,n2,2)
client.zadd(‘zset1‘,n1=1,n2=2)

技术分享图片

8.2 `zcard`

Zcard 命令用于计算集合中元素的数量。
当 key 存在且是有序集类型时，返回有序集的基数。当 key 不存在时，返回 0 。

        # 获取name对应的有序集合元素的数量

        client.zcard(‘zset1‘) # 2

8.3`zcount`

Zcount 命令用于计算有序集合中指定分数区间的成员数量。分数值在 min 和 max 之间的成员的数量。

        # 获取name对应的有序集合中分数 在 [min,max] 之间的个数
print(client.zcount(‘zset1‘,0,2)) # 2

8.4`zincrby`

Zincrby 命令对有序集合中指定成员的分数加上增量 increment

可以通过传递一个负数值 increment ，让分数减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。
当 key 不存在，或分数不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。
当 key 不是有序集类型时，返回一个错误。
分数值可以是整数值或双精度浮点数。
member 成员的新分数值，以字符串形式表示。

        # 自增name对应的有序集合的 name 对应的分数
print(client.zincrby(‘zset1‘,‘n1‘)) # 2.0

8.5`[r]zrange`

Zrange 返回有序集中，指定区间内的成员。
其中成员的位置按分数值递增(从小到大)来排序。
具有相同分数值的成员按字典序(lexicographical order )来排列。
如果你需要成员按值递减(从大到小)来排列，请使用 ZREVRANGE 命令。
下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。
你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

        # 按照索引范围获取name对应的有序集合的元素
 
# 参数：
    # name，redis的name
    # start，有序集合索引起始位置（非分数）
    # end，有序集合索引结束位置（非分数）
    # desc，排序规则，默认按照分数从小到大排序
    # withscores，是否获取元素的分数，默认只获取元素的值
    # score_cast_func，对分数进行数据转换的函数
 
# 更多：
    # 从大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)
 
    # 按照分数范围获取name对应的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 从大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

        print client.zadd("7", "1", 1, "2", 2,"3",3,"4",4,"5",5)     #输出的结果是5
print client.zrange("7",start=0,end=-1,desc=False)           #输出的结果是[‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘]
print client.zrange("7",start=0,end=2,desc=False)            #输出的结果是[‘1‘, ‘2‘, ‘3‘]

8.6`zrank`

Zrank 返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大)顺序排列。

如果成员是有序集 key 的成员，返回 member 的排名。如果成员不是有序集 key 的成员，返回 None 。

技术分享图片

        # 获取某个值在 name对应的有序集合中的排行（从 0 开始）
 
# 更多：
    # zrevrank(name, value)，从大到小排序

        print(client.zrank(‘zset1‘,‘n1‘)) # 1

        print client.zadd("10", "a", 1, "b", 2, "c", 3)  # 输出的结果是3
print client.zadd("10", "f", 11, "d", 21,"e",32)    #输出的结果是3
print client.zrank("10","a")                     #输出的结果是0
print client.zrank("10","b")                     #输出的结果是1
print client.zrank("10","e")                     #输出的结果是5
print client.zrank("10","d")                     #输出的结果是4
print client.zrank("10","h")                     #输出的结果是None

8.7`zrangebylex`

        # 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值 （lexicographical ordering）来进行排序，而这个命令则可以返回给定的有序集合键 key 中， 元素的值介于 min 和 max 之间的成员
# 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大
 
# 参数：
    # name，redis的name
    # min，左区间（值）。 + 表示正无限； - 表示负无限； ( 表示开区间； [ 则表示闭区间
    # min，右区间（值）
    # start，对结果进行分片处理，索引位置
    # num，对结果进行分片处理，索引后面的num个元素
 
# 如：
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex(‘myzset‘, "-", "[ca") 结果为：[‘aa‘, ‘ba‘, ‘ca‘]
 
# 更多：
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

8.8`zrem`

Zrem 命令用于移除有序集中的一个或多个成员，不存在的成员将被忽略。

当 key 存在但不是有序集类型时，返回一个错误。

        # 删除name对应的有序集合中值是values的成员
 
# 如：zrem(‘zz‘, [‘s1‘, ‘s2‘])

        print(client.zrem(‘zset1‘,‘n1‘))

技术分享图片

8.9`zremrangebyrank`

Zremrangebylex 命令用于移除有序集合中给定的字典区间的所有成员。
被成功移除的成员的数量，不包括被忽略的成员。

技术分享图片

        # 根据排行范围删除

        print(client.zremrangebyrank(‘zset1‘,1,3)) # 3

技术分享图片

        print client.zadd("12", "a", 1, "b", 2, "c", 3)         # 输出的结果是3
print client.zadd("12", "d", 11, "e", 21,"f",32)        #输出的结果是3
print client.zremrangebylex("12",min="[a",max="[c")    #输出的结果是3
print client.zrange("12",0,-1)                         #输出的结果是 [‘d‘, ‘e‘, ‘f‘]  因为  a，b，c已经被移除

8.10`zremrangebyscore`

Zremrangebyscore 命令用于移除有序集中，指定分数（score）区间内的所有成员。

        # 根据分数范围删除

技术分享图片

        client.zremrangebyscore(‘zset1‘,2,4)

技术分享图片

        # print client.zadd("13", "a", 1, "b", 2, "c", 3)         # 输出的结果是3
# print client.zadd("13", "d", 8, "e", 21,"f",32)        #输出的结果是3
# print client.zremrangebyrank(name=13,min=1,max=3)       #输出的结果是3
# print client.zrange("13","0","-1")                      #输出的结果是[‘a‘, ‘e‘, ‘f‘]  因为删除了 b，c，d

8.11`zremrangebylex`

Zremrangebylex 命令用于移除有序集合中给定的字典区间的所有成员。
被成功移除的成员的数量，不包括被忽略的成员。

        # 根据值返回删除

        print client.zadd("12", "a", 1, "b", 2, "c", 3)         # 输出的结果是3
print client.zadd("12", "d", 11, "e", 21,"f",32)        #输出的结果是3
print client.zremrangebylex("12",min="[a",max="[c")    #输出的结果是3
print client.zrange("12",0,-1)                         #输出的结果是 [‘d‘, ‘e‘, ‘f‘]  因为  a，b，c已经被移除

8.12`zscore`

Zscore 命令返回有序集中，成员的分数值。如果成员元素不是有序集 key 的成员，或 key 不存在，返回 None 。

        # 获取name对应有序集合中 value 对应的分数

        print(client.zscore(‘zset1‘,‘n3‘)) # 3

8.13`zinterstore`

Zinterstore 命令计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。默认情况下，结果集中某个成员的分数值是所有给定集下该成员分数值之和。

        # 获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

        client.zadd(‘t1‘,"n1",11,"n2",13,"n3",15)
client.zadd(‘t2‘,"n1",11,"n2",13,"n3",20)

技术分享图片

        print(client.zinterstore(‘dset‘,(‘t1‘,‘t2‘),aggregate=‘SUM‘))

技术分享图片

8.14`zunionstore`

Zunionstore 命令计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。

默认情况下，结果集中某个成员的分数值是所有给定集下该成员分数值之和。
保存到 destination 的结果集的成员数量。

与上一样，几乎没有区别

        # 获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

8.15`zscan`

Zscan 命令用于迭代有序集合中的元素（包括元素成员和元素分值）返回的每个元素都是一个有序集合元素，一个有序集合元素由一个成员（member）和一个分值（score）组成。

测试数据

        dic = {}
for i in range(1000):
    dic.update({‘n%s‘%i:i})
client.zadd(‘test_set‘,**dic)

        print(client.zscan(‘test_set‘,count=10)) # 游标从0开始，一次获取10条数据

8.16`zscan_iter`

        # 迭代取值，每一次取值10条数据
for i in client.zscan_iter(‘test_set‘,count=10):
    print(i)

9:其它操作

9.1`delete`

        # 根据删除redis中的任意数据类型

        print(client.delete(‘test‘))

9.2`exists`

        # 检测redis的name是否存在

        print(client.exists(‘test‘,‘1‘)) # True,返回结果是bool值，

9.3`keys`

        # 根据模型获取redis的name
 
# 更多：
    # KEYS * 匹配数据库中所有 key 。
    # KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
    # KEYS h*llo 匹配 hllo 和 heeeeello 等。
    # KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

        print(client.keys()) # [b‘t1‘, b‘dset‘, b‘test_set‘, b‘t2‘]

9.4`expire`

        # 为某个redis的某个name设置超时时间

        print(client.expire(‘t1‘,3)) # 执行成功为True，返回的是bool值

9.5`rename`

        # 对redis的name重命名为

        print(client.rename(‘t1‘,‘tt‘)) # 执行成功为True，返回值是bool值

9.6`move`

        # 将redis的某个值移动到指定的db下

        print(client.move(‘tt‘,3))  # 执行成功为True，返回值是bool值

9.7`randomkey`

        # 随机获取一个redis的name（不删除）

        print(client.randomkey())

9.8`type`

        # 获取name对应值的类型

        print(type(client.randomkey())) # 基本上是5大数据类型

9.9`scan`

        一次只获取指定数量的值

9.10`scan_iter`

        每一只是获取指定数量的值，直到值全部获取完

10:管道

redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，

如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。

        import redis

pool = redis.ConnectionPool(
    max_connections=10,
    host=‘localhost‘,
    password=123456,
    port=6379)  # 示例化一个连接池
client = redis.Redis(connection_pool=pool)
p = client.pipeline()
p.set(‘name‘,1)
p.getset(‘name‘,‘error‘)
p.execute() #这是提交

11:django中使用redis

方式一

创建一个文件

        import redis
POOL = redis.ConnectionPool(
    host=‘127.0.0.1‘, 
    port=6379,
    password=‘1234‘,
    max_connections=1000)

视图函数中使用连接池

首先导入连接池

        import redis
from django.shortcuts import render,HttpResponse
from utils.redis_pool import POOL

def index(request):
    conn = redis.Redis(connection_pool=POOL)
    conn.hset(‘kkk‘,‘age‘,18)

    return HttpResponse(‘设置成功‘)
def order(request):
    conn = redis.Redis(connection_pool=POOL)
    conn.hget(‘kkk‘,‘age‘)

    return HttpResponse(‘获取成功‘)

方式二

安装django-redis模块

        pip3 install django-reids

settings.py配置

        CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
            # "PASSWORD": "123",
        }
    }
}

视图函数

        from django_redis import get_redis_connection
conn = get_redis_connection(‘default‘)
print(conn.hgetall(‘xxx‘))

原文：https://www.cnblogs.com/wait59/p/14244926.html

内容总结

以上是互联网集市为您收集整理的redis之pythonApi操作全部内容，希望文章能够帮你解决redis之pythonApi操作所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1231232.html

来源：【匿名】

首页 / PYTHON / redis之pythonApi操作

redis之pythonApi操作

内容导读

内容图文

01 redis入门

1 redis介绍

1.1 什么是redis?

1.2Memcached和redis比较

1.2redis为什么单线程，单进程速度这么快？

2 redis在windows安装和配置

2.1：下载

2.2：启动服务的两种形式

2.3：命令连接redis服务

2.4：图形化连接redis服务

3 普通连接和连接池(使用Python语言客户端建立连接)

3.1：安装

3.2连接数据库

3.3：使用池子连接

3.4：对连接池进行性能优化（使用单例模式)

4：操作string数据类型(使用python Api连接redis)

4.0:连接数据库

4.1 set

4.2 get

4.3 setnx

4.4 setex

4.5mset

4.6mget

4.7 getset

4.8 getrange

4.9 setrange

4.10 setbit

4.11 getbit

4.12 bitcount

4.13 incr

4.14 decr

4.14 append

5：hash操作

5.0 连接

5.1 hset

5.2 hmset

5.3 hget

5.4 hmget

5.5 hgetall

5.6hlen

5.7 hkeys

5.8 hvals

5.9 hexists

5.10 hdel

5.11 hincrby

5.12 hscan

5.13 hscan_iter

6：list

6.0连接数据库

6.1 lpush

6.2 lpushx

6.3llen

6.4 linsert

6.5 lset

6.6 lrem

6.7lpop

6.8lindex

6.9lrange

6.10ltrim

6.11rpoplpush

6.12 blpop

6.13brpoplpush

6.14:封装一个可迭代取值的功能

7：set操作

7.0：建立连接

7.1 sadd

7.2 scard

7.3 sdiff

7.4sdiffstore

7.5sinter

7.6sinterstore

7.7sismember

7.8smembers

7.9smove

7.10spop

7.11srandmember

4.3 `setnx`

4.4 `setex`

4.7 `getset`

4.10 `setbit`

4.11 `getbit`

4.12 `bitcount`

5.6`hlen`

5.7 `hkeys`

5.8 `hvals`

5.12 `hscan`

6.1 `lpush`

6.2 `lpushx`

6.3`llen`

6.4 `linsert`

6.5 `lset`

6.6 `lrem`

6.7`lpop`

6.8`lindex`

6.9`lrange`

6.10`ltrim`

6.11`rpoplpush`

6.12 `blpop`

6.13`brpoplpush`

7.1 `sadd`

7.2 `scard`

7.3 `sdiff`

7.4`sdiffstore`

7.5`sinter`

7.6`sinterstore`

7.7`sismember`

7.8`smembers`

7.9`smove`

7.10`spop`

7.11`srandmember`

7.12`srem`

7.13`sunion`

7.14`sunionstore`

7.15`sscan`

7.16`sscan_iter`

8.1 `zadd`

8.2 `zcard`

8.3`zcount`

8.4`zincrby`

8.5`[r]zrange`

8.6`zrank`

8.7`zrangebylex`

8.8`zrem`

8.9`zremrangebyrank`

8.10`zremrangebyscore`

8.11`zremrangebylex`

8.12`zscore`

8.13`zinterstore`

8.14`zunionstore`

8.15`zscan`

8.16`zscan_iter`

9.1`delete`

9.2`exists`

9.3`keys`

9.4`expire`

9.5`rename`

9.6`move`

9.7`randomkey`

9.8`type`

9.9`scan`

9.10`scan_iter`