Python对Redis增删改查

ゞ浴缸里的玫瑰 2022-10-13 12:50 229阅读 0赞

#  #

### pip install redis ###

import redis
    
    #   连接redis
    #   几个常用默认参数：
    #   host='localhost', port=6379, db=0, decode_responses=False, password=None
    con_redis = redis.StrictRedis(decode_responses=True)

## [五大数据类型使用][Link 1] ##

### String类型 ###

#   增加数据：set key value（如果key存在，则修改为新的value）
    print(con_redis.set('str_type', 'str_value'))  # 打印True
    #   追加数据：append key value
    print(con_redis.append('str_type', '_new'))  # 打印13，字符长度
    #   查看数据：get key
    print(con_redis.get('str_type'))

### List类型 ###

#   在插入数据时，如果该键并不存在，Redis将为该键创建一个
    #   在末尾添加数据（列表右边）
    con_redis.rpush('list_type', '2', 'xy', 'li_val_end')
    #   在头部添加数据（列表左边）
    con_redis.lpush('list_type', '1', 'xy', 'li_val_start')
    
    #   查看数据
    #   数据为：['li_val_start', 'xy', '1', '2', 'xy', 'li_val_end']
    #   下标范围：lrange key start stop
    print(con_redis.lrange('list_type', 0, 10))
    #   指定下标：lindex key index
    print(con_redis.lindex('list_type', -1))
    
    #   删除数据
    #   从末尾删除（列表右边）：rpop key
    print(con_redis.rpop('list_type'))  # 打印删除的值
    #   从头部删除（列表左边）：lpop key
    print(con_redis.lpop('list_type'))  # 打印删除的值
    #   指定值删除：lrem key count(可以存在多个重复的值，指定value删除的次数) value
    print(con_redis.lrem('list_type', 2, 'xy'))  # 打印成功删除的个数

### Hash类型 ###

#   hash类型的值是一个键值对集合，如：h_test : { field1:value1, field2:value2,...}
    #   添加数据：hset key field value
    print(con_redis.hset('hash_type', 'filed', 'value'))  # 打印成功添加数据的条数
    #   查看域值：hget key field
    print(con_redis.hget('hash_type', 'filed'))
    #   查看所有的field：hkeys key
    print(con_redis.hkeys('hash_type'))
    #   查看所有的value：hvals key
    print(con_redis.hvals('hash_type'))
    #   查看所有的键值对：hgetall key
    print(con_redis.hgetall('hash_type'))

### Set类型 ###

#   Set类型为无序的字符集合，元素具有唯一性， 不重复(自动去重)
    #   添加数据：sadd key member1 [member2 ...]
    print(con_redis.sadd('set_type', 'va', 'vb', 'vc', 'vd'))  # 打印成功添加数据的条数
    #   查看数据：smembers key
    print(con_redis.smembers('set_type'))
    #   随机删除：spop key
    print(con_redis.spop('set_type'))  # 打印删除的值
    #   指定删除：srem key member1 [member2 ...]
    print(con_redis.srem('set_type', 'va', 'vb'))  # 打印成功删除的个数

### Zset类型 ###

#   每一个成员都会有一个分数(score)与之关联
    #   成员是唯一的，但是分数(score)却是可以重复的
    #   比如把一个班级的学生分成几组
    
    #   添加数据： zadd key score member [score2 member2 …]
    #   打印成功添加数据的条数
    print(con_redis.zadd('zset_type',
                         1, 'val1', 1, 'val2', 1, 'val3',
                         4, 'val4', 4, 'val5',
                         8, 'val6'
                         ))
    
    #   查看数据
    #   根据索引：zrange key start stop
    print(con_redis.zrange('zset_type', 0, 3))
    #   根据score：zrangebyscore key min max
    #   查看 score 1 到 2 的值
    print(con_redis.zrangebyscore('zset_type', 1, 2))
    
    #   删除数据
    #   根据值：zrem key member [member …]
    print(con_redis.zrem('zset_type', 'val3', 'val4'))  # 打印成功删除的个数
    #   根据索引：zremrangebyrank key start stop
    print(con_redis.zremrangebyrank('zset_type', 2, 4))  # 打印成功删除的个数
    #   根据score：zremrangebyscore key min max
    print(con_redis.zremrangebyscore('zset_type', 1, 7))  # 打印成功删除的个数

### 全局key操作 ###

#   查看所有的key：keys *
    print(con_redis.keys())
    #   查看key的类型：type key
    print(con_redis.type('set_type'))
    #   exists key 查看key是否存在
    print(con_redis.exists('abcd'))  # 不存在返回False
    
    #   改名：rename key new_key
    #   如果不存在则报错：no such key
    # print(con_redis.rename('str_type', 'str_type_new'))
    #   删除键值对：del key [key2 key3 ...]
    print(con_redis.delete('hash_type'))  # 打印成功删除的个数
    
    #   设置过期时间：expire key seconds
    print(con_redis.expire('list_type', 60))  # 返回bool
    #   persist key 删除过期时间
    print(con_redis.persist('list_type'))# 返回bool
    #   ttl key 查看时间
    #   -1：没设置过期时间      -2：不存在这个键
    print(con_redis.ttl('list_type'))

首先先看一下python3 操作redis都有哪些命令

lrange(key , start , stop)  
lpush(key , value)  
rpush(key , value)  
lpop(key)  
rpop(key)  
blpop(key)  
brpop(key)  
brpoplpush(source,destination,timeout)  
lindex(key,index)  
linsert(key,before|after,privot,value)  
llen(key)  
lpushx(key)  
lrem(key , value , count)  
lset(key , index , value)  
ltrim(key , start , stop)  
rpoplpush(source , destination)  
rpushx(key , value)  
有dalao想直接看完整代码请移步github：  
https://github.com/dangsh/pythonPra/blob/master/redisGit/redisTest.py

下面是具体例子详解和代码：  
①lrange(key , start , stop)  
返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。  
下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

import redis  
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.lpush("0",1,2,3,4)   
print(r.lrange("0" , 0 , -1))  
1  
2  
3  
4  
②lpush(key , value)  
将一个或多个值 value 插入到列表 key 的表头  
如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头  
如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作  
当 key 存在但不是列表类型时，返回一个错误

import redis  
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.lpush("1",1)   
print(r.lrange("1" , 0 , -1)) \#打印列表"1"的全部内容  
r.lpush("1",1,2,3,4)  
print(r.lrange("1" , 0 , -1))  
1  
2  
3  
4  
5  
6  
③rpush(key , value)  
将一个或多个值 value 插入到列表 key 的表尾(最右边)。  
如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾  
如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。  
当 key 存在但不是列表类型时，返回一个错误。

import redis  
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("2",1)   
print(r.lrange("2" , 0 , -1)) \#打印列表"2"的全部内容  
r.rpush("2",1,2,3,4)  
print(r.lrange("2" , 0 , -1))  
1  
2  
3  
4  
5  
6  
④lpop(key)  
移除并返回列表 key 的头元素。

import redis  
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.lpush("3",1,2,3,4)  
print(r.lrange("3" , 0 , -1)) \#打印列表"3"的全部内容  
r.lpop("3")  
print(r.lrange("3" , 0 , -1))  
1  
2  
3  
4  
5  
6  
⑤rpop(key)  
移除并返回列表 key 的尾元素。

import redis  
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.lpush("4",1,2,3,4)  
print(r.lrange("4" , 0 , -1)) \#打印列表"4"的全部内容  
r.rpop("4")  
print(r.lrange("4" , 0 , -1))  
1  
2  
3  
4  
5  
6  
⑥blpop(key)  
Blpop 命令移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。  
如果列表为空，返回一个 None 。 否则，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。

import redis   
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("6",1,2,3,4,4,5,6)  
print(r.blpop("6"))  
print(r.blpop("6"))  
print(r.blpop("6"))  
print(r.blpop("100" , timeout=2))\#因为键 100 不存在，所以2秒后输出的结果是None  
print(r.lrange("6" , 0 , -1)) \#打印列表"6"的全部内容  
1  
2  
3  
4  
5  
6  
7  
8  
⑦brpop(key)  
Brpop 命令移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。  
假如在指定时间内没有任何元素被弹出，则返回一个None 和等待时长。 反之，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。

import redis   
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("7",1,2,3,4,5,6,)       
print(r.lrange("7" , 0 , -1)) \#打印列表"7"的全部内容   
print(r.brpop("7"))       
print(r.brpop("7"))       
print(r.brpop("7"))        
print(r.brpop("101",timeout=2))      \#因为键 101 不存在，所以2秒后输出的结果是None  
print(r.lrange("7" , 0 , -1)) \#打印列表"7"的全部内容   
1  
2  
3  
4  
5  
6  
7  
8  
9  
⑧brpoplpush(source,destination,timeout)  
命令从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。  
假如在指定时间内没有任何元素被弹出，则返回一个 None 和等待时长。 反之，返回一个含有两个元素的列表，第一个元素是被弹出元素的值，第二个元素是等待时长。

import redis   
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("8",1,2,3)  
r.rpush("88",4,5,6)  
print(r.lrange("8" , 0 , -1)) \#打印列表"8"的全部内容   
print(r.lrange("88" , 0 , -1)) \#打印列表"88"的全部内容   
print(r.brpoplpush(src="8",dst="88",timeout=2))  \#输出的结果是3  
print(r.brpoplpush(src="44",dst="22",timeout=2))  \#键44 不存在，输出的结果是None  
print(r.lrange("8" , 0 , -1)) \#打印列表"8"的全部内容   
print(r.lrange("88" , 0 , -1)) \#打印列表"88"的全部内容   
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
⑨lindex(key,index)

通过索引获取列表中的元素。你也可以使用负数下标，以 -1 表示列表的最后一个元素

import redis   
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("9",1,2,3)  
print(r.lrange("9" , 0 , -1)) \#打印列表"8"的全部内容   
print(r.lindex("9",0))        \#输出的结果是1  
print(r.lindex("9",1))        \#输出的结果是2  
print(r.lindex("9",2))        \#输出的结果是3  
print(r.lindex("9",3))        \#输出的结果是None  
print(r.lindex("9",-1))        \#输出的结果是3  
print(r.lrange("9" , 0 , -1)) \#打印列表"8"的全部内容   
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
⑩linsert(key,before|after,privot,value)  
用于在列表的元素前或者后插入元素。  
当指定元素不存在于列表中时，不执行任何操作。 当列表不存在时，被视为空列表，不执行任何操作。

import redis   
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("10",1,2,3)  
print(r.lrange("10" , 0 , -1)) \#打印列表"10"的全部内容   
r.linsert("10" , "BEFORE" , "2" , 10)  
print(r.lrange("10" , 0 , -1)) \#结果 \['1', '10', '2', '3'\]

r.rpush("100",1,2,3)  
r.linsert("100" , "AFTER" , "2" , 10)  
print(r.lrange("100" , 0 , -1)) \#结果 \['1', '2', '10', '3'\]  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
①①llen(key)  
返回列表的长度。 如果列表 key 不存在，则 key 被解释为一个空列表，返回 0 。 如果 key 不是列表类型，返回一个错误。

import redis   
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("11",1,2,3)  
print(r.lrange("11" , 0 , -1)) \#打印列表"11"的全部内容   
print(r.llen("11"))  \#结果是 3  
1  
2  
3  
4  
5  
①②lpushx(key)  
将一个或多个值插入到已存在的列表头部，列表不存在时操作无效。  
和lpush的区别是lpushx在列表不存在时操作无效，而lpush会创建一个列表

import redis   
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("12" , 1,2,3)  
r.rpush("122" , 1,2,3)  
print(r.lrange("12" , 0 , -1)) \#结果为 \['1', '2', '3'\]  
print(r.lrange("122" , 0 , -1)) \#结果为 \['1', '2', '3'\]  
r.lpush("123" , 1)  
r.lpushx("1223" , 1)  
print(r.lrange("123" , 0 , -1)) \#结果为 \['1'\]  
print(r.lrange("1223" , 0 , -1)) \#结果为 \[\]  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
①③lrem(key , value , count)  
根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素。  
COUNT 的值可以是以下几种：  
count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。  
count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。  
count = 0 : 移除表中所有与 VALUE 相等的值。  
返回被移除元素的数量。 列表不存在时返回 0 。

import redis   
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("13" , 'a','b','b','c','d','b')  
print(r.lrange("13" , 0 , -1)) \#结果为\['a', 'b', 'b', 'c', 'd', 'b'\]  
r.lrem("13" , "b" , 2)  
print(r.lrange("13" , 0 , -1)) \#结果为\['a', 'c', 'd', 'b'\]

r.rpush("133" , 'a','b','b','c','d','b')  
print(r.lrange("133" , 0 , -1)) \#结果为\['a', 'b', 'b', 'c', 'd', 'b'\]   
r.lrem("133" , "b" , -2)  
print(r.lrange("133" , 0 , -1)) \#结果为\['a', 'b', 'c', 'd'\]  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
①④lset(key , index , value)  
将列表 key 下标为 index 的元素的值设置为 value 。  
当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。

import redis  
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("14" , 1,2,3,4)  
print(r.lrange("14" , 0 , -1)) \#打印列表"14"的全部内容  
r.lset("14",1,9)  
print(r.lrange("14" , 0 , -1)) \#结果为 \['1', '9', '3', '4'\]  
1  
2  
3  
4  
5  
6  
①⑤ltrim(key , start , stop)  
对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。  
举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。  
下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。  
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。  
当 key 不是列表类型时，返回一个错误。

import redis  
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("15" , 1,2,3,4)  
print(r.lrange("15" , 0 , -1)) \#打印列表"14"的全部内容  
r.ltrim("15",0,1)  
print(r.lrange("15" , 0 , -1)) \#结果为 \['1', '2'\]  
1  
2  
3  
4  
5  
6  
①⑥rpoplpush(source , destination)  
将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。  
将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。

import redis   
r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode\_responses=True)  
r.rpush("16",1,2,3)  
r.rpush("166",4,5,6)  
print(r.lrange("16" , 0 , -1)) \# \['1', '2', '3'\]   
print(r.lrange("166" , 0 , -1)) \# \['4', '5', '6'\]   
print(r.rpoplpush(src="16",dst="166"))  \#输出的结果是3  
print(r.lrange("16" , 0 , -1)) \# \['1', '2'\]   
print(r.lrange("166" , 0 , -1)) \# \['3', '4', '5', '6'\]  
  
①⑦rpushx(key , value)  
将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。  
和 RPUSH 命令相反，当 key 不存在时， RPUSHX 命令什么也不做。

import redis 
    r = redis.Redis(host='localhost' , port='6379' , db=6 ,decode_responses=True)
    # for i in range(10):
    #     r.lpop("17")
    #     r.lpop("177")
    #     r.lpop("1777")
    r.rpush("17" , 1,2,3)
    r.rpush("177" , 1,2,3)
    print(r.lrange("17" , 0 , -1)) #结果为 ['1', '2', '3']
    print(r.lrange("177" , 0 , -1)) #结果为 ['1', '2', '3']
    r.rpush("177" , 4)
    r.rpushx("1777" , 4)
    print(r.lrange("177" , 0 , -1)) #结果为 ['1', '2', '3', '4']
    print(r.lrange("1777" , 0 , -1)) #结果为 []

https://github.com/dangsh/pythonPra/blob/master/redisGit/redisTest.py  
  
原文链接：https://blog.csdn.net/dangsh\_/article/details/79221328

[Link 1]: https://www.cnblogs.com/jiyu-hlzy/p/11886395.html