python操作Redis

最新推荐文章于 2024-06-28 15:05:01 发布
最新推荐文章于 2024-06-28 15:05:01 发布
阅读量536 收藏 3
点赞数
分类专栏： python Redis 分布式 文章标签： redis 数据库 python 爬虫 分布式
原文链接：https://blog.csdn.net/ltf201834/article/details/84975724
版权
python 同时被 3 个专栏收录
17 篇文章 1 订阅
订阅专栏
Redis
1 篇文章 0 订阅
订阅专栏
分布式
1 篇文章 0 订阅
订阅专栏

redis是一个基于内存的高效的键值型非关系数据库，接下来我们就来看看这些操作是如何具体使用的吧

数据库连接操作

from redis import StrictRedis
 
#数据库连接方式 因为就算我自己使用的，所有没有设置密码
redis=StrictRedis(host='localhost',port=6379,db=0,password=None)
#redis.set('age',20)
print(redis.get('name'))
 
print(redis.exists('name')) #是否存在name这个键
 
print(redis.type('name'))  #判断name的类型
 
print(redis.keys('n*'))  #获取所有以n开头的键
 
print(redis.randomkey())  #获取随机一个键
 
print(redis.dbsize()) #获取当前数据库中的键的数目

结果如下：

接下来看字符串操作：

from redis import StrictRedis,ConnectionPool
 
#另一种连接方式
pool=ConnectionPool(host='localhost',port=6379,db=0,password=None)
redis=StrictRedis(connection_pool=pool)
 
#redis.set('name','Bob')
print(redis.get('name'))
 
#print(redis.getset('name','Mike'))  #赋值name为Mike并返回上一次的value
 
print(redis.mget(['name','age']))   #输出name键和age键的value
 
#print(redis.setnx('newname','james'))  #如果键值不存在，则赋值
 
#print(redis.mset({'name1':'smith','name2':'curry'}))  #批量赋值
 
#print(redis.msetnx({'name3':'ltf','name4':'lsq'}))    #不存在才批量赋值
 
#print(redis.incr('age',1))   #age对应的value 加1
#print(redis.decr('age',5))   #age对应的value 减5
 
#print(redis.append('name4','is a sb'))   #在name4的value后追加 is a sb 返回字符串长度
 
print(redis.substr('name',1,4))   #截取键 name
print(redis.getrange('name',0,-1))  #截取键 name

结果如下：

接下来看列表操作

from redis import StrictRedis
 
redis=StrictRedis(host='localhost',port=6379,db=0,password=None)
 
#print(redis.rpush('list',1,2,3)) #向键名为list的列表尾部添加1,2,3 返回长度
 
#print(redis.lpush('list',0))   #向键名为list的列表头部添加0 返回长度
 
print(redis.llen('list'))   #返回列表的长度
 
print(redis.lrange('list',1,3))  #返回起始索引为1 终止索引为3的索引范围对应的列表
 
print(redis.lindex('list',1))   #返回索引为1的元素-value
 
#print(redis.lset('list',1,5))  #将list的列表索引为1的重新赋值为5
 
#print(redis.lpop('list'))  #删除list第一个元素
 
#print(redis.rpop('list'))   #删除list最后一个元素
 
#print(redis.blpop('list'))   #删除list第一个元素
 
#print(redis.brpop('list'))    #删除最后一个元素
 
print(redis.rpoplpush('list','list1'))   #删除list的尾元素并将其添加到list1的头部

运行结果如下：

接下来看集合操作：

from redis import StrictRedis,ConnectionPool
 
pool=ConnectionPool(host='localhost',port=6379,db=0,password=None)
redis=StrictRedis(connection_pool=pool)
 
#print(redis.sadd('tags','Book','Tea','Coffee'))  #返回集合长度 3
 
#print(redis.srem('tags','Book'))  返回删除的数据个数
 
#print(redis.spop('tags'))   #随机删除并返回该元素
 
#print(redis.smove('tags','tags1','Coffee'))
 
print(redis.scard('tags'))  #获取tags集合的元素个数
 
print(redis.sismember('tags','Book'))   #判断Book是否在tags的集合中
 
print(redis.sinter('tags','tags1'))    #返回集合tags和集合tags1的交集
 
print(redis.sunion('tags','tags1'))    #返回集合tags和集合tags1的并集
 
print(redis.sdiff('tags','tags1'))     #返回集合tags和集合tags1的差集
 
print(redis.smembers('tags'))     #返回集合tags的所有元素
 
print(redis.srandmember('tags'))   #返回tags的一个随机元素

运行结果如下：

接下来看哈希表操作：

from redis import StrictRedis,ConnectionPool
 
pool=ConnectionPool(host='localhost',port=6379,db=0,password=None)
redis=StrictRedis(connection_pool=pool)
 
#print(redis.hset('price','cake',5))  # 向键名为price的散列表添加映射关系，返回1 即添加的映射个数
 
#print(redis.hsetnx('price','book',6)) # 向键名为price的散列表添加映射关系，返回1 即添加的映射个数
 
print(redis.hget('price','cake'))  #获取键名为cake的值 返回5
 
#print(redis.hmset('price',{'banana':2,'apple':3,'pear':6,'orange':7}))   #批量添加映射
 
print(redis.hmget('price',['apple','orange']))   #查询apple和orange的值 输出 b'3',b'7'
 
#print(redis.hincrby('price','apple',3))   #apple映射加3 为6
 
print(redis.hexists('price','banana'))    #在price中banana是否存在  返回True
 
#print(redis.hdel('price','banana'))    #从price中删除banana 返回1
 
print(redis.hlen('price'))   #输出price的长度
 
print(redis.hkeys('price'))  #输出所有的映射键名
 
print(redis.hvals('price'))  #输出所有的映射键值
 
print(redis.hgetall('price'))  #输出所有的映射键对

运行结果如下：

 

Python 操作redis有序集合(sorted set)

#coding:utf8
import redis
r =redis.Redis(host="23.226.74.190",port=63279,password="66666666666")

注意：

python操作redis报错：redis.exceptions.DataError: ZADD allows either 'nx' or 'xx', not both解决方案

一、问题描述

sorted set操作执行：print(connect.zadd('grade', 'bob', 98, 'mike' ,100))时报错redis.exceptions.DataError: ZADD allows either 'nx' or 'xx', not both

二、出现该问题原因

上面的connect.zadd('key','value1','score1','value2','score2')写法是redis-py 3.0之前的版本

在redis-py 3.0版本之后，写法变为：connect.zadd('grade', {'bob':100, 'mike':99, 'lucy':87})这种写法了，所以会报错

三、解决方案

更改写法为：connect.zadd('key',{'value1':'score1','value2':'scote2',.....})

1.Zadd

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

print r.zadd("1","1",2,"3",3) #输出的结果是2
print r.zadd("1","2",2)     #输出的结果是1
print r.zadd("1","1",1)     #输出的结果是0
print r.zadd("1","3",4)     #输出的结果是0
print r.zrange("1",0,-1)    #输出的结果是 ['1', '2', '3']

 

2.Zcard

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

print r.zadd("1","1",1,"3",3) #输出的结果是2
print r.zadd("1","2",2)     #输出的结果是1
print r.zadd("1","2",4)     #输出的结果是1
print r.zcard(1)            #输出的结果是3
print r.zcard(2)            #输出的结果是0
 

3.Zcount

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

print r.zadd("2","1",1,"3",3) #输出的结果是2
print r.zadd("2","2",2)     #输出的结果是1
print r.zadd("2","1",4)     #输出的结果是0
print r.zcount("2",min=0,max=5)     #输出的结果是3
print r.zcount("2",min=0,max=3)     #输出的结果是2
print r.zcount("2",min=1,max=3)     #输出的结果是2
 

4.Zincrby

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

print r.zadd("4","1",1,"2",2,"3",3,"4",4)   #输出的结果是4
print r.zincrby(name=4,value=1,amount=5)    #输出的结果是6.0
print r.zincrby(name=4,value=2,amount=55)    #输出的结果是57.0
print r.zrange(name=4,start=0,end=-1,withscores=False)       #输出的结果是['1', '3', '2', '4']

 

5.Zinterstore

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

print r.zadd("41", "a1", 6, "a2", 2,"a3",5)     #输出的结果是3
print r.zadd('42', a1=7,b1=10, b2=5)            #输出的结果是3
# 获取两个有序集合的交集并放入dest集合，如果遇到相同值不同分数，则按照aggregate进行操作
# aggregate的值为: SUM  MIN  MAX
print r.zinterstore("43",("42","41"),aggregate="MAX")       #输出的结果是4
print(r.zscan("43"))                                        #输出的结果是(0L, [('a1', 7.0)])
 

6.Zlexcount

Zlexcount 命令在计算有序集合中指定字典区间内成员数量。

print r.zadd("6", "a", 1, "b", 2,"c",3)     #输出的结果是3
print r.zlexcount(name=6,min="-",max="+")   #输出的结果是3
print r.zadd("6", "e", 4, "f", 5,"d",6)     #输出的结果是3
print r.zlexcount(name=6,min="-",max="+")   #输出的结果是6
print r.zlexcount(name=6,min="[a",max="[b")   #输出的结果是2
print r.zlexcount(name=6,min="[a",max="[f")   #输出的结果是6
print r.zlexcount(name=6,min="[a",max="[e")   #输出的结果是4
 

7.Zrange

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

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

 

8. Zrangebylex

Zrangebylex 通过字典区间返回有序集合的成员。

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值 （lexicographical ordering）来进行排序，而这个命令则可以返回给定的有序集合键 key 中， 元素的值介于 min 和 max 之间的成员
对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大

print r.zadd("8", "a", 1, "b", 2,"c",3)     #输出的结果是3
print r.zrangebylex(name="8",min="-",max="[c")   #输出的结果是 ['a', 'b', 'c']
print r.zrangebylex(name="8",min="-",max="(c")   #输出的结果是 ['a', 'b']
print r.zadd("8", "e", 4, "f", 5,"d",6)     #输出的结果是3
print r.zrangebylex(name=8,min="[b",max="[f")   #输出的结果是 ['b', 'c', 'e', 'f', 'd']
print r.zrangebylex(name=8,min="(b",max="[f")   #输出的结果是 ['c', 'e', 'f', 'd']

9.Zrangebyscore

Zrangebyscore 返回有序集合中指定分数区间的成员列表。

有序集成员按分数值递增(从小到大)次序排列。 具有相同分数值的成员按字典序来排列(该属性是有序集提供的，不需要额外的计算)。 默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。

print r.zadd("9", "a", 1, "b", 2,"c",3)     #输出的结果是3
print r.zrangebyscore("9","1","6")  #输出的结果是['a', 'b', 'c']
print r.zadd("9", "c", 11, "d", 21,"e",32)     #输出的结果是3
print r.zrangebyscore("9","3","16")  #输出的结果是['c']
print r.zrangebyscore("9","3","36")  #输出的结果是['c', 'd', 'e']

 

10.Zrank

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

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

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

11. Zrem

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

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

print r.zadd("11", "a", 1, "b", 2, "c", 3)  # 输出的结果是3
print r.zadd("11", "f", 11, "d", 21,"e",32) #输出的结果是3
print r.zrem("11","a")                      #输出的结果是1
print r.zrem("11","f")                      #输出的结果是1
print r.zrem("11","h")                      #输出的结果是0
print r.zrange("11",start=0,end=32)         #输出的结果是['b', 'c', 'd', 'e'], 其中  a f 已经移除掉
print r.zrange("11",start=2,end=32)         #输出的结果是['d', 'e'], 其中  a f 已经移除掉，d  e  没有被包涵
 

12.Zremrangebylex

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

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

13. Zremrangebyrank

Zremrangebyrank 命令用于移除有序集中，指定排名(rank)区间内的所有成员。

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

 

14.Zremrangebyscore

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

print r.zadd("14", "a", 1, "b", 2, "c", 3)          #输出的结果是3
print r.zadd("14", "d", 8, "e", 21,"f",32)          #输出的结果是3
print r.zremrangebyscore(name="14",min="1",max="8")       #输出的结果是4,删除的a，b，c，d
print r.zrange(name="14",start=0,end=-1)            #输出的结果是 ['e', 'f']

 

15.Zrevrange

Zrevrange 命令返回有序集中，指定区间内的成员。

其中成员的位置按分数值递减(从大到小)来排列。
具有相同分数值的成员按字典序的逆序(reverse lexicographical order)排列。
除了成员按分数值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一样。

print r.zadd("15", "a", 1, "b", 2, "c", 3)          #输出的结果是3
print r.zadd("15", "d", 8, "e", 21,"f",32)          #输出的结果是3
print r.zrevrange(name="15",start=0,end=-1)         #输出的结果是['f', 'e', 'd', 'c', 'b', 'a']
print r.zrevrange(name="15",start=1,end=21)         #输出的结果是['e', 'd', 'c', 'b', 'a']
print r.zrevrange(name="15",start=3,end=21)         #输出的结果是['c', 'b', 'a']

 

16.Zrevrangebyscore

Zrevrangebyscore 返回有序集中指定分数区间内的所有的成员。有序集成员按分数值递减(从大到小)的次序排列。

具有相同分数值的成员按字典序的逆序(reverse lexicographical order )排列。
除了成员按分数值递减的次序排列这一点外， ZREVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE 命令一样。

print r.zadd("16", "a", 1, "b", 2, "c", 3)          #输出的结果是3
print r.zadd("16", "d", 8, "e", 21,"f",32)          #输出的结果是3
print r.zrevrangebyscore(name="16",max=33,min=0)    #输出的结果是['f', 'e', 'd', 'c', 'b', 'a']
print r.zrevrangebyscore(name="16",max=20,min=2)    #输出的结果是['d', 'c', 'b']
 

17. Zrevrank

Zrevrank 命令返回有序集中成员的排名。其中有序集成员按分数值递减(从大到小)排序。

排名以 0 为底，也就是说， 分数值最大的成员排名为 0 。
使用 ZRANK 命令可以获得成员按分数值递增(从小到大)排列的排名。

print r.zadd("17", "a", 1, "b", 2, "c", 3)          #输出的结果是3
print r.zadd("17", "d", 4, "e", 5,"f",6)            #输出的结果是3
print r.zrevrank(name=17,value="a")                 #输出的结果是5
print r.zrevrank(name=17,value="c")                 #输出的结果是3
print r.zrevrank(name=17,value="d")                 #输出的结果是2
print r.zrevrank(name=17,value="h")                 #输出的结果是None
 

18.Zscore

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

print r.zadd("18", "a", 1, "b", 2, "c", 3)   #输出的结果是3
print r.zadd("18", "d", 4, "e", 5,"f",6)     #输出的结果是3
print r.zscore(name="18",value="a")          #输出的结果是1.0
print r.zscore(name="18",value="c")          #输出的结果是3.0
print r.zscore(name="18",value="f")          #输出的结果是6.0
print r.zscore(name="18",value="h")          #输出的结果是None
 

19.Zunionstore

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

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

20.Zscan

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

print r.zadd("20", "a", 1, "b", 2, "c", 3)   #输出的结果是3
print r.zscan(name="20")                     #输出的结果是(0L, [('a', 1.0), ('b', 2.0), ('c', 3.0)])
print r.zadd("20", "d", 4, "e", 5,"f",3)     #输出的结果是3
print r.zscan(name="20")                     #输出的结果是 (0L, [('a', 1.0), ('b', 2.0), ('c', 3.0), ('f', 3.0), ('d', 4.0), ('e', 5.0)])
 
NealHuiwen
关注
专栏目录
有序集合使用与内部实现原理
磊哥聊Java
10-28 652
有序集合类型 (Sorted Set) 相比于集合类型多了一个排序属性 score（分值），对于有序集合 ZSet 来说，每个存储元素相当于有两个值组成的，一个是有序结合的元素值，一个是排序值。有序集合的存储元素值也是不能重复的，但分值是可以重复的。 当我们把学生的成绩存储在有序集合中时，它的存储结构如下图所示： 下面我们先从有序集合的使用开始说起。 1 基础使用 1）添加一个或多个元素 语法：...
python操作redis取出list_Python操作Redis大全
weixin_39815286的博客
12-18 2172
命令太多记不住可以参考Redis中文网，强烈建议收藏一、字符串 stringsPython操作Redis的redis模块对字符串(string)的主要操作函数包括：SET、GET、GETSET、SETEX、SETNX、MSET、MSETNX、INCR(INCRBY,DECR,DECRBY在python中庸同一个函数incr实现)、APPEND、SETRANGE、STRLEN。函数说明如下：SET：...
Python脚本之操作Redis【二】
zyooooxie的博客
02-09 468
Redis实例、Redis 命令、操作Redis-Hash、List、Set
Python 操作redis有序集合(sorted set)
aobian2884的博客
09-16 739
#coding:utf8 import redis r =redis.Redis(host="23.226.74.190",port=63279,password="66666666666") 1.Zadd Zadd 命令用于将一个或多个成员元素及其分数值加入到有序集当中。如果某个成员已经是有序集的成员，那么更新这个成员的分数值，并通过重新插入这个成员元素，来保证该成员在...
python_day10のPython操作 RabbitMQ、Redis、Memcache
weixin_34228617的博客
10-13 166
MemcachedMemcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程（daemon ）是用C写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。Mem...
python redis命令zadd_python 操作redis之——有序集合(sorted set) （七）
weixin_39769091的博客
11-28 241
#coding:utf8importredisr=redis.Redis(host="23.226.74.190",port=63279,password="66666666666")1.Zadd 命令用于将一个或多个成员元素及其分数值加入到有序集当中。如果某个成员已经是有序集的成员，那么更新这个成员的分数值，并通过重新插入这个成员元素，来保证该成员在正确的位置上。分数值可以是整数值或双精度浮点数...
python数据库去重_python redis连接 有序集合去重的代码
weixin_39841136的博客
11-24 141
python redis连接 有序集合去重的代码如下所述：# -*- coding: utf-8 -*-import redisfrom constant import redis_ip, redis_db, redis_pw, redis_zset_namepool = redis.ConnectionPool(host=redis_ip, db=redis_db, password=redis...
Python操作redis和mongoDB的方法
12-23
一、操作redis redis是一个key-value存储系统，value的类型包括string(字符串)，list(链表)，set(集合)，zset(有序集合)，hash(哈希类型)。为了保证效率，数据都是缓冲在内存中，在处理大规模数据读写的场景下运用...
Python操作redis 哈希(Hash)
最新发布
Shinobi_Jack的博客
06-28 459
参考：Python操作redis系列以 哈希(Hash)命令详解（四）
Python操作Redis之设置key的过期时间实例代码
09-09
在Python中操作Redis数据库时，有时我们需要为存储的数据设置一个过期时间，以确保数据在一段时间后自动清除，释放存储空间。Redis提供了多种方法来设置key的过期时间，这在处理临时或缓存数据时非常有用。本文将...
python redis连接 有序集合去重的代码
09-09
主要介绍了python redis连接 有序集合去重的代码，代码简单易懂，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下
python使用redis有序集合_Python--Redis实战：第三章：Redis命令：第五节：有序集合...
weixin_31448343的博客
01-13 412
和散列存储着键与值之间的映射类似，有序集合也存储着成员与分值之间的映射，并且提供了分值处理命令，已经根据分值大小有序的获取(fetch)和扫描(scan)成员和分值的命令。本书曾在第一章使用有序集合实现过基于发布时间排序的文章列表和基于投票数量排序的文章列表，还在第二章使用有序集合存储过cookie的过期时间。这些分值在Redis中以IEEE754双精度点数的格式存储。本节将对操作有序集合的命令进...
python 操作redis之——有序集合(sorted set) （七）
aini4568的博客
06-30 187
#coding:utf8 import redis r =redis.Redis(host="23.226.74.190",port=63279,password="66666666666") 1.Zadd 命令用于将一个或多个成员元素及其分数值加入到有序集当中。如果某个成员已经是有序集的成员，那么更新这个成员的分数值，并通过重新插入这个成员元素，来保证该成员在正确的位置上...
python redis list_python redis list操作
weixin_39590472的博客
11-28 221
LPUSH list_name value [value ...]Prepend one or multiple values to a list从左侧插入值，最早插入的值在最右边LPUSHX list_name valuePrepend a value to a list, only if the list exists判断列表是否存在，如果存在就插入值，不存在就不插入值，只能插入一次，从左边插...
Redis五（其他操作命令）
afftl7302的博客
05-13 130
其他常用操作 delete(*names) # 根据删除redis中的任意数据类型 exists(name) # 检测redis的name是否存在 keys(pattern='*') # 根据模型获取redis的name # 更多： # KEYS * 匹配数据库中所有 key 。 # KEYS h?llo 匹配 hello ...
Python操作Redis之五：有序集合
LI4836的博客
12-25 843
5. 有序集合     在集合的基础上，为每元素排序，元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。 zadd(name, *args, **kwargs) #在name对应的有序集合中添加元素 r.zadd("zset_name", "a1", 6, "a2", 2,"a3",5) #或 ...
Redis 集合 有序集合 python操作集合
热门推荐
weixin_45185267的博客
06-16 1万+
集合数据类型（set） 文章目录集合数据类型（set）基本命令案例: 新浪微博的共同关注python操作set有序集合sortedset特点有序集合常用命令python操作sorted set 特点 1、无序、去重 2、元素是字符串类型 3、最多包含2^32-1个元素 基本命令 # 1、增加一个或者多个元素,自动去重；返回值为成功插入到集合的元素个数 SADD key member1 member2 # 2、查看集合中所有元素 SMEMBERS key # 3、删除一个或者多个元素，元素不存
Python&Redis 无序集合set、有序集合zset操作
haeasringnar的博客
10-07 2930
1、Redis控制台操作无序集合set 无序集合 元素为string类型 元素具有唯一性，不重复 redis操作： 设置 添加元素 SADD key member [member ...] 获取 返回key集合所有的元素 SMEMBERS key 返回集合元素个数 SCARD key 其它 求多个集合的交集 SINTER key [key ...] 求某集合与其它集合的差集 SDIFF key [...
python操作redis
06-07
Python可以通过redis-py这个第三方库来操作Redis数据库。可以通过以下步骤来安装： 1. 安装redis-py库：`pip install redis` 2. 导入redis库：`import redis` 3. 连接Redis数据库：`r = redis.Redis(host='...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值