关于python:Python-Redis数据库新玩法从零到高手掌握操作技巧

Redis（Remote Dictionary Server）是一种高性能的开源内存数据库，它反对多种数据结构，如字符串、哈希、列表、汇合、有序汇合等，并提供了丰盛的操作命令。Redis 具备疾速、牢靠和灵便的特点，广泛应用于缓存、音讯队列、会话存储、计数器等场景。本文将从入门到精通地介绍 Python 中操作 Redis 数据库的办法，带你把握应用 Redis 进行数据存储和读取的技巧。

装置和导入
连贯 Redis 数据库
字符串操作
哈希操作
列表操作
汇合操作
有序汇合操作
公布订阅模式
事务操作
过期工夫和长久化
性能优化
分布式锁
Redis 主从复制
Redis 哨兵
Redis 集群
总结

首先，咱们须要装置 Redis 数据库。能够从 Redis 官网下载安装包进行装置，或者应用包管理工具进行装置。
装置实现后，咱们须要在 Python 中导入 redis 模块来操作 Redis 数据库：

import redis

在应用 Redis 之前，咱们须要先建设与 Redis 服务器的连贯。能够应用 redis.Redis() 办法创立一个 Redis 客户端对象，而后通过该对象进行数据的存储和读取。

import redis

# 建设与本地 Redis 服务器的连贯
client = redis.Redis(host='localhost', port=6379, db=0)

# 存储数据
client.set('name', 'Alice')

# 读取数据
value = client.get('name')
print(value.decode())

在上述代码中，咱们应用 redis.Redis() 办法创立了一个与本地 Redis 服务器的连贯，并应用 client.set() 办法存储了一个键值对，而后应用 client.get() 办法读取了数据，并通过 decode() 办法将二进制数据转换为字符串输入。

Redis 的字符串数据结构是最根本的数据类型，能够用来存储字符串、整数、浮点数等。

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储字符串
client.set('name', 'Alice')

# 读取字符串
value = client.get('name')
print(value.decode())

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储整数
client.set('counter', 10)

# 减少整数
client.incr('counter', 5)

# 读取整数
value = client.get('counter')
print(int(value))

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储字符串，并设置过期工夫为 10 秒
client.setex('name', 10, 'Alice')

# 读取字符串
value = client.get('name')
print(value.decode())

# 期待 11 秒后，再次读取数据
import time
time.sleep(11)
value = client.get('name')
print(value)  # 过期后返回 None

在上述代码中，咱们应用 client.setex() 办法存储了一个带有过期工夫的键值对，过期工夫为 10 秒。期待 11 秒后，再次读取数据，发现键曾经过期，返回了 None。

哈希是一种键值对的汇合，适宜存储对象。

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储哈希
client.hset('user', 'name', 'Alice')
client.hset('user', 'age', 30)

# 读取哈希
name = client.hget('user', 'name')
age = client.hget('user', 'age')
print(name.decode(), age.decode())

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储哈希
client.hset('user', 'name', 'Alice')
client.hset('user', 'age', 30)

# 获取所有键值对
data = client.hgetall('user')
for key, value in data.items():
    print(key.decode(), value.decode())

列表是一种有序的字符串列表，能够存储反复的值。

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储列表
client.lpush('fruits', 'apple', 'orange', 'banana')

# 读取列表
fruits = client.lrange('fruits', 0, -1)
for fruit in fruits:
    print(fruit.decode())

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储列表
client.lpush('fruits', 'apple', 'orange', 'banana')

# 获取列表长度
length = client.llen('fruits')
print(length)

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储列表
client.lpush('fruits', 'apple', 'orange', 'banana')

# 弹出元素
fruit = client.lpop('fruits')
print(fruit.decode())

# 再次读取列表
fruits = client.lrange('fruits', 0, -1)
for fruit in fruits:
    print(fruit.decode())

汇合是一种无序的、不反复的字符串汇合。

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储汇合
client.sadd('fruits', 'apple', 'orange', 'banana')

# 读取汇合
fruits = client.smembers('fruits')
for fruit in fruits:
    print(fruit.decode())

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储汇合
client.sadd('fruits', 'apple', 'orange', 'banana')

# 获取汇合大小
size = client.scard('fruits')
print(size)

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储汇合
client.sadd('fruits', 'apple', 'orange', 'banana')

# 判断元素是否在汇合中
print(client.sismember('fruits', 'apple'))
print(client.sismember('fruits', 'watermelon'))

有序汇合是一种有序的、不反复的字符串汇合，每个元素都有一个分数，能够依据分数进行排序。

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储有序汇合
client.zadd('fruits', {'apple': 1, 'orange': 2, 'banana': 3})

# 读取有序汇合
fruits = client.zrange('fruits', 0, -1, withscores=True)
for fruit, score in fruits:
    print(fruit.decode(), score)

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储有序汇合
client.zadd('fruits', {'apple': 1, 'orange': 2, 'banana': 3})

# 获取元素排名和分数
rank = client.zrank('fruits', 'banana')
score = client.zscore('fruits', 'banana')
print(rank, score)

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储有序汇合
client.zadd('fruits', {'apple': 1, 'orange': 2, 'banana': 3})

# 获取分数在范畴内的元素
fruits = client.zrangebyscore('fruits', 1, 2, withscores=True)
for fruit, score in fruits:
    print(fruit.decode(), score)

Redis 反对公布订阅模式，能够将音讯公布给多个订阅者。

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 公布音讯
client.publish('channel', 'Hello, subscribers!')

import redis

class Subscriber(redis.client.PubSub):

    def on_message(self, message):
        print('Received message:', message['data'].decode())

client = redis.Redis(host='localhost', port=6379, db=0)
subscriber = Subscriber()

# 订阅音讯
subscriber.subscribe('channel')
client.publish('channel', 'Hello, subscribers!')  # 这里将收到音讯

Redis 反对事务操作，能够将多个命令放在一个事务中进行执行。

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 开启事务
with client.pipeline() as pipe:
    try:
        # 监听键值变动
        pipe.watch('counter')

        # 事务开始
        pipe.multi()

        # 执行多个命令
        pipe.incr('counter')
        pipe.incr('counter')
        pipe.incr('counter')

        # 执行事务
        pipe.execute()
    except redis.exceptions.WatchError:
        print('Counter value changed during transaction, transaction aborted.')

在上述代码中，咱们应用 client.pipeline() 创立了一个事务管道，并应用 pipe.watch() 办法监听了一个键，而后在 pipe.multi() 和 pipe.execute() 之间执行了多个命令。如果在事务执行期间，被监听的键的值产生了变动，redis.exceptions.WatchError 异样将会被抛出，示意事务被停止。

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 存储字符串，并设置过期工夫为 10 秒
client.setex('name', 10, 'Alice')

Redis 反对将数据长久化到磁盘中，以避免数据失落。

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 执行保留操作
client.save()

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 执行保留操作
client.bgsave()

在大规模应用 Redis 时，须要思考性能优化的问题。

import redis

# 建设与本地 Redis 服务器的连接池
pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
client = redis.Redis(connection_pool=pool)

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 应用管道执行多个命令
with client.pipeline() as pipe:
    pipe.set('name', 'Alice')
    pipe.get('name')
    results = pipe.execute()
    print(results)

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 应用批量操作
client.mset({'name': 'Alice', 'age': 30})
data = client.mget('name', 'age')
print(data)

分布式锁是在分布式系统中实现并发管制的一种机制。

import redis

client = redis.Redis(host='localhost', port=6379, db=0)

# 获取锁
lock = client.lock('my_lock')

# 阻塞形式获取锁
with lock:
    print('Lock acquired.')

    # 非阻塞形式获取锁
if lock.acquire(blocking=False):
    print('Lock acquired.')
else:
    print('Failed to acquire lock.')

Redis 反对主从复制，能够将主节点的数据复制到从节点。

import redis

# 创立主节点连贯
master = redis.Redis(host='localhost', port=6379, db=0)

# 创立从节点连贯
slave = master.slaveof()

# 查看从节点信息
info = slave.info()
print(info)

Redis 哨兵用于监控 Redis 主从复制的状态，以实现高可用性。

import redis

# 创立哨兵连贯
sentinel = redis.StrictRedis(host='localhost', port=26379, db=0)

# 获取主节点连贯
master = sentinel.sentinel_get_master_addr_by_name('mymaster')
print(master)

Redis 反对集群模式，能够将数据分布在多个节点上。

from rediscluster import StrictRedisCluster

# 创立集群节点连贯
startup_nodes = [{'host': 'localhost', 'port': '7000'}, {'host': 'localhost', 'port': '7001'}]
client = StrictRedisCluster(startup_nodes=startup_nodes)

# 存储数据
client.set('name', 'Alice')

# 读取数据
value = client.get('name')
print(value.decode())

本文介绍了 Python 中操作 Redis 数据库的办法，包含连贯 Redis 数据库、字符串操作、哈希操作、列表操作、汇合操作、有序汇合操作、公布订阅模式、事务操作、过期工夫和长久化、性能优化、分布式锁、Redis 主从复制、Redis 哨兵和 Redis 集群。把握这些常识，你将可能灵活运用 Redis 数据库来解决数据，进步零碎的性能和可靠性。心愿本文能帮忙你学习和应用 Redis，在理论我的项目中施展更大的作用。

介绍

目录

1. 装置和导入

2. 连贯 Redis 数据库

3. 字符串操作

存储和读取字符串

减少和缩小整数

设置过期工夫

4. 哈希操作

存储和读取哈希

获取所有键值对

5. 列表操作

存储和读取列表

获取列表长度

弹出元素

6. 汇合操作

存储和读取汇合

获取汇合大小

判断元素是否在汇合中

7. 有序汇合操作

存储和读取有序汇合

获取元素排名和分数

获取分数在范畴内的元素

8. 公布订阅模式

公布音讯

订阅音讯

9. 事务操作

10. 过期工夫和长久化

设置过期工夫

长久化

RDB 长久化

AOF 长久化

11. 性能优化

应用连接池

应用管道

应用批量操作

12. 分布式锁

13. Redis 主从复制

14. Redis 哨兵

15. Redis 集群

16. 总结