python redis示例

redis有5种数据结构，分别如下：
5种数据结构

python语言对5种数据结构的增删改查

全局函数

1*|0***redis 连接**

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

redis 取出的结果默认是字节，可以设定 decode_responses=True 改成字符串
redis python操作

2*|0***一、字符串**

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.set("name", "goldsunshine")
>> True
r.get("name")
>> 'goldsunshine'
r.strlen("name")
>> 12

2*|1***创建**

1.设置单个键值对

set(name, value, ex=None, px=None, nx=False, xx=False)
ex：过期时间（秒），时间到了后redis会自动删除
px：过期时间（毫秒），时间到了后redis会自动删除。ex、px二选一即可
nx：如果设置为True，则只有name不存在时，当前set操作才执行
xx：如果设置为True，则只有name存在时，当前set操作才执行

2.设置多个值

value_dict = {'num': 123, 'str': 456}
mset(value_dict)

3.不存在键更新value，存在则不变

setnx(name, value) 

4.设置value，并添加有效期

setex(name, time, value)
r.setex('name', 1, 'James') 设置name=James，并且有效期为1s

2*|2***修改**

1.value后面追加

append(key, value)

2*|3***查询**

1.获取单个值，返回字符串

get(key)

2.获取多个值，返回列表

mget(['num', 'str'])

3.给已有的键设置新值，并返回原有的值。返回字符串

getset(name, value)

当所给的键不存在时，会设置新值，但返回值是None

4.获取value的长度，返回整型 ↓

strlen(key)

5.获取value从start到end的子字符串，返回字符串 ↓

getrange(key, start, end)

3*|0***二、列表**

redis中，一个键对应一个列表

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.rpush("arr", 1,2,3,4)
>> 4
r.lrange("arr")
>> ['1', '2', '3', '4']

3*|1***增加：**

1.在列表右边添加值。key不存在时创建一个新列表，返回列表的长度

redis.rpush(key, 1,2,3,4)

可以添加单个，可以添加多个。当有多个值时，将值依次添加到最右边

arr = [5,4,3,2,1]
r.rpush(key, *arr)

2.在列表左边添加，key不存在时创建一个新列表，返回列表的长度

r.lpush(key, 1,2,3,4)

当有多个值时，将值依次添加到最左边。

3.在列表中间插入新值

linsert(name, where, refvalue, value)

r.linsert(key, 'after', 6, 'new_value')

name：键名
where：位置，前面（BEFORE）或后面（AFTER）
refvalue：指定哪个值的前后插入
value：插入的新值

返回值：插入后列表的长度，若返回-1，则refvalue不存在

4.key存在时插入。lpushx添加到左边，rpushx添加到右边。返回列表长度 ↓

lpushx(key, value) 添加到左边
rpushx(key, value) 添加到右边

只有键存在时，才添加。若键不存在则不添加，也不新创建列表

3*|2***修改**

1.列表中通过索引赋值，返回True或False

lset(key, index, value)

3*|3***删除**

1.删除左边第一个值，返回删除的值

lpop(name)

2.删除右边第一个值，返回删除的值

rpop(name)

3.删除列表中范围之外的所有值，返回删除的值

ltrim(key, start, end)

4.删除列表中N的相同的值，返回删除的数量 ↓

lrem(name, num, value)

r.lrem('arr', 10, 'delete_name')

name：键名
value：需删除的值
num：删除的个数 整数表示从左往右 负数表示从右往左 例如：2 -2
返回值：返回删除的个数

5.删除并返回列表中首个元素，列表为空则一直阻塞 ↓

blpop(key, timeout=n)

6.删除并返回列表中尾元素，如果列表为空则一直阻塞 ↓

brpop(key, timeout=n)

3*|4***查询**

1.列表中获取一段数据，返回列表

lrange(name, start, end)

2.通过索引获取列表值，返回单个元素

lindex(key, index)

3.获取键对应列表的长度，返回数值

llen(key)

4*|0***三、字典**

一个name对应一个字典，类似于字典名字。字典中是key->value

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.hset("Dict", "name", "goldsunshine")
>> 1
r.hgetall("Dict")
>> {'name': 'goldsunshine'}

4*|1***增加**

1.单个添加，返回添加的数量

hset(name, key, value)

key存在则修改，否则就是添加

2.批量添加，返回True或False

mapping = {'age':10, 'tel':123}
redis.hmset(name, mapping)

3.如果键不存在添加，否则不处理。返回创建字典长度

hsetnx(name, key, value)

4*|2***删除**

删除键值对,返回删除的个数

hdel(name, key)
# 可删除多个
hdel(name, *keys)

4*|3***修改**

hset(name, key, value)

key存在则修改，否则就是添加

4*|4***查询**

获取所有键值对，返回一个字典

hgetall(name)

获取所有的key，返回列表

hkeys(name)

获取所有value，返回列表 ↓

hvals(name)

获取指定key的值，返回元素 ↓

hget(name, key)

获取多个键值对，返回列表 ↓

keys = ['age', 'tel']
r.hmget(name, [keys])

获取键值对个数，返回数字 ↓

hlen(name)

查询哈希中是否有某个key，返回True或False ↓

hexists(name, key)

5*|0***四、集合**

集合中的元素不重复，一般用于过滤元素

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.sadd("Set", 1,2,3,4,5)
>> 5
r.smembers("Set")
>> {'1', '2', '3', '4', '5'}

5*|1***增，返回添加的数量**

没有key则创建集合并添加所有元素；有key则直接添加到结合中

sadd(name, value1,value2,value3)

也可以使用包裹方式一次性传入

today_vocab_ids = [1,2,3,4,5]
redis.sadd(key, *today_vocab_ids)

5*|2***删，返回删除元素的个数**

1.删除集合中一个或多个元素

srem(key,values)

srem(key, value1, value2, value3)

2.随机删除并返回集合中元素，返回元素

spop(key)

3.将一个集合移动到另一个集合

smove(src, dst, value)

5*|3***查**

1.返回集合中所有元素，返回集合

smemebers(key)

2.返回集合中元素的个数，返回个数

scard(key)

3.随机获取n个元素，返回列表

srandmember(name, number=None)

name：键名
number：一个或N个，默认返回一个。若返回N个，则返回List类型
返回值：返回一个值或一个列表

r.srandmemeber(key, number=45)

4.判断某个值是否在集合中，返回True或False ↓

sismember(key, value)

5.差集，返回集合 ↓

sdiff(key1, key2)

6.交集，返回集合 ↓

sinter(key1, key2)

7.并集，返回集合 ↓

sunion(key1, key2)

6*|0***五、有序集合**

有序集合比集合多了一个分数的字段，可对分数升序降序

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.smembers("Set")
>> {'1', '2', '3', '4', '5'}
r.zrange("order_set", 0,10)
>> ['one', 'two', 'three']

6*|1***增，返回增加元素个数**

set_dict = {'one': 1, 'two':9, 'three': 12}
r.zadd(key, set_dict)

6*|2***删，返回删除元素的个数**

1.删除有序集合中某个或多个值

zrem(key, *values)

返回删除的个数

2.根据分数范围删除有序集合，返回删除元素的个数

zremrangebyscore(name, min, max)

3.根据排名范围删除集合

zremrangebyrank(key, min, max)

6*|3***改**

增加有序集合中某个值的分数

zincrby(name, value, amount=1)

value：若存在，则增加其amount分数；若不存在，则增加新值以及对应的分数
amount：增加的值，可以为负数
返回值：增加后的分数 float类型 ；形如： -5.0 <class 'float'>

r.zincrby('Zarten', 'zhi', -5)

6*|4***查**

1.返回有序集合中元素个数，返回数字

zcard(key)

2.返回有序集合中分数范围内的元素个数，返回数字

zcount(key, min, max)

3.返回有序集合中指定某个值的分数，返回数字

zscore(key, name)

4.返回某个值在有序集合中的分数排名，返回数字 ↓

zrank(name, value)

5.返回有序结合分数排序后的一段数据，返回列表 ↓

zrange(name, start, end, desc=False, withscores=False, score_cast_func=float)

name：redis的name
start：有序集合索引起始位置（非分数）
end：有序集合索引结束位置（非分数）
desc：排序规则，默认按照分数从小到大排序
withscores：是否获取元素的分数，默认只获取元素的值
score_cast_func：对分数进行数据转换的函数

7*|0***六、全局函数**

全局函数对任何数据结构都适用

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.zadd("order_set", {"one":1, "two":9, "three":12})
>> 3

r.zrange("order_set", 1,100)
>> ['two', 'three']

r.zrange("order_set", 0,10)
>> ['one', 'two', 'three']

r.delete("order_set")
>> 1

r.exists("Set")
>> 1

r.expire("Set", 60*60)
>> True

r.rename("Set", "Set_newname")
>> True

r.type("name")
>> 'string'

r.ttl("name")
>> -1

1.删除一个或多个键的所有数据

r.delete(*names)

2.判断redis中是否存在某个键

r.exists(key)

3.重命名redis中建名

r.rename(key, new_key)

4.移动某个键所有数据到某一个db中

r.move(key, db_name)

5.随机获取redis中某个键名 ↓

r.randonkey()

6.查看某个键数据结构类型 ↓

r.type(key)

返回值：字符串（字节形式） 形如： b'hash'

none (key不存在)
string (字符串)
list (列表)
set (集合)
zset (有序集)
hash (哈希表)

7.设置过期时间 ↓

r.expire(key, time)

8.获取键的过期时间 ↓

r.ttl(name)

9.获取所有符合规则的键 ↓

keys(pattern)
r.keys('n*') 获取所有以n开头的键

Redis是一个基于内存的高性能键值对（key-value）存储系统，同时也支持丰富的数据结构，如字符串、哈希表、列表、集合、有序集合等。在Python中，我们通常使用redis-py这个第三方库来连接和操作Redis。

以下是一个基本的使用步骤以及各种数据结构操作的示例：

1. 安装redis-py库

pip install redis

2. 连接Redis服务器

import redis

# 创建一个Redis连接对象，可以指定主机、端口、密码等信息
r = redis.Redis(host='localhost', port=6379, db=0, password=None, decode_responses=True)  # decode_responses参数决定是否将返回值自动解码为字符串

# 若使用连接池
pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

3. 数据结构操作示例

(a) 字符串（String）

• 设置键值对：

r.set('my-key', 'Hello, Redis!')

• 获取键值：

value = r.get('my-key')
print(value)  # 输出: Hello, Redis!

(b) 列表（List）

• 添加元素到列表尾部：

r.rpush('my-list', 'item1')
r.rpush('my-list', 'item2')

• 从列表头部弹出元素：

popped_item = r.lpop('my-list')
print(popped_item)  # 输出: 'item1'

(c) 集合（Set）

• 添加成员到集合：

r.sadd('my-set', 'member1')
r.sadd('my-set', 'member2')

• 获取集合的所有成员：

members = r.smembers('my-set')
for member in members:
    print(member)

(d) 哈希表（Hash）

• 向哈希表中添加字段与值：

r.hset('my-hash', 'field1', 'value1')
r.hset('my-hash', 'field2', 'value2')

• 获取哈希表中的所有字段及其对应的值：

hash_data = r.hgetall('my-hash')
for field, value in hash_data.items():
    print(f'Field: {field}, Value: {value}')

(e) 有序集合（Sorted Set）

• 添加带有分数的成员到有序集合：

r.zadd('my-zset', {'member1': 1, 'member2': 2})

• 范围查询有序集合中的成员：

sorted_members = r.zrange('my-zset', 0, -1, withscores=True)
for member, score in sorted_members:
    print(f'Member: {member}, Score: {score}')

以上只是简单展示了Python操作Redis的部分功能，实际应用中可以根据需求调用更多Redis命令进行更复杂的数据操作和管理。
参考--https://www.cnblogs.com/goldsunshine/p/15345710.html