答案：Python操作Redis和Memcached需使用redis-py和python-memcached库，通过连接池、管道、序列化优化性能，Redis适合复杂数据结构与持久化场景，Memcached适用于高性能键值缓存，高可用需结合哨兵、集群或客户端分片。
在Python中操作Redis和Memcached，主要依赖各自成熟的客户端库。对于Redis，我们通常会使用
redis-py
python-memcached
要使用Python操作Redis或Memcached，你需要先安装对应的客户端库。
操作Redis：
安装redis-py
立即学习“Python免费学习笔记（深入）”；
pip install redis
基本使用示例：
redis-py
Redis
StrictRedis
StrictRedis
import redis
# 连接到Redis服务器
# 默认连接到localhost:6379，db=0
# 如果Redis有密码，可以这样连接：
# r = redis.StrictRedis(host='localhost', port=6379, db=0, password='your_password')
try:
r = redis.StrictRedis(host='localhost', port=6379, db=0, decode_responses=True)
# decode_responses=True 会自动将Redis返回的字节流解码为UTF-8字符串，省去手动解码的麻烦
# 字符串操作
r.set('mykey', 'Hello Redis!')
value = r.get('mykey')
print(f"Key 'mykey': {value}") # 输出: Key 'mykey': Hello Redis!
r.setex('temp_key', 10, 'This will expire in 10 seconds') # 设置带过期时间的键
# 哈希操作
r.hset('user:100', mapping={'name': 'Alice', 'age': 30, 'city': 'New York'})
user_info = r.hgetall('user:100')
print(f"User 100 info: {user_info}") # 输出: User 100 info: {'name': 'Alice', 'age': '30', 'city': 'New York'}
# 列表操作
r.rpush('mylist', 'item1', 'item2', 'item3')
list_items = r.lrange('mylist', 0, -1)
print(f"List 'mylist': {list_items}") # 输出: List 'mylist': ['item1', 'item2', 'item3']
# 集合操作
r.sadd('myset', 'apple', 'banana', 'apple') # 'apple'只会被添加一次
set_members = r.smembers('myset')
print(f"Set 'myset': {set_members}") # 输出: Set 'myset': {'apple', 'banana'}
# 有序集合操作
r.zadd('myzset', {'member1': 10, 'member2': 5, 'member3': 15})
sorted_members = r.zrange('myzset', 0, -1, withscores=True)
print(f"Sorted Set 'myzset': {sorted_members}") # 输出: Sorted Set 'myzset': [('member2', 5.0), ('member1', 10.0), ('member3', 15.0)]
# 删除键
r.delete('mykey', 'user:100', 'mylist', 'myset', 'myzset', 'temp_key')
print("Keys deleted.")
except redis.exceptions.ConnectionError as e:
print(f"无法连接到Redis服务器: {e}")
except Exception as e:
print(f"发生错误: {e}")操作Memcached：
安装python-memcached
pip install python-memcached
基本使用示例： Memcached的API相对简单，主要就是
set
get
delete
import memcache
# 连接到Memcached服务器
# 可以传入一个服务器地址列表，实现客户端分片
mc = memcache.Client(['127.0.0.1:11211'], debug=0) # debug=0 关闭调试信息
try:
# 设置键值对
# set(key, value, time=0)
# time参数是过期时间，单位秒。0表示永不过期。
mc.set('my_mem_key', 'Hello Memcached!', time=60) # 键会在60秒后过期
print("Set 'my_mem_key'.")
# 获取键值对
value = mc.get('my_mem_key')
if value:
print(f"Key 'my_mem_key': {value}") # 输出: Key 'my_mem_key': Hello Memcached!
else:
print("Key 'my_mem_key' not found or expired.")
# 添加键值对（如果键不存在则添加）
mc.add('new_key', 'This is a new value', time=30)
print(f"Added 'new_key': {mc.get('new_key')}")
# 替换键值对（如果键存在则替换）
mc.replace('new_key', 'This is a replaced value', time=30)
print(f"Replaced 'new_key': {mc.get('new_key')}")
# 删除键
mc.delete('my_mem_key')
print("Deleted 'my_mem_key'.")
print(f"After deletion, 'my_mem_key': {mc.get('my_mem_key')}") # 输出: After deletion, 'my_mem_key': None
except Exception as e:
print(f"操作Memcached时发生错误: {e}")在使用Python与Redis交互时，我个人觉得，虽然
redis-py
首先，连接管理是重中之重。你可能觉得每次操作都创建一个新的Redis连接没什么大不了，但实际上，建立和关闭TCP连接的开销是显著的。在并发量大的应用中，这会导致大量的
TIME_WAIT
Too many open files
redis-py
redis.ConnectionPool
import redis
# 创建一个连接池
pool = redis.ConnectionPool(host='localhost', port=6379, db=0, decode_responses=True)
r = redis.StrictRedis(connection_pool=pool)
# 之后所有的r操作都会从连接池中获取和释放连接
r.set('foo', 'bar')
print(r.get('foo'))其次，减少网络往返时间（RTT）。Redis是单线程的，但它通过多路复用I/O模型实现高并发。然而，如果你的Python应用频繁地向Redis发送单个命令，即使Redis处理速度再快，网络延迟也会成为瓶颈。这时候，管道（Pipeline）就显得尤为重要了。管道允许你一次性发送多个命令给Redis，Redis会按顺序执行它们，然后一次性返回所有结果。这就像你一次性把购物清单交给店员，而不是每拿一件商品就跑去结账一次。
# 使用管道
pipe = r.pipeline()
pipe.set('key1', 'value1')
pipe.set('key2', 'value2')
pipe.get('key1')
pipe.get('key2')
results = pipe.execute()
print(f"Pipeline results: {results}") # 输出: Pipeline results: [True, True, 'value1', 'value2']对于需要原子性执行一系列命令的场景，管道结合
MULTI
EXEC
再者，数据序列化。Redis存储的是字节串，当你需要存储Python对象（如字典、列表或自定义对象）时，就需要进行序列化。最常见的方式是使用JSON或
pickle
pickle
pickle
import json
import pickle
data = {'name': 'Charlie', 'age': 25, 'interests': ['coding', 'reading']}
# JSON序列化
r.set('user:json', json.dumps(data))
retrieved_json = json.loads(r.get('user:json'))
print(f"JSON data: {retrieved_json}")
# Pickle序列化 (注意decode_responses=True可能会影响pickle的直接使用，因为它会先尝试解码)
# 如果使用pickle，通常会关闭decode_responses，手动处理字节
r_bytes = redis.StrictRedis(connection_pool=pool, decode_responses=False)
r_bytes.set('user:pickle', pickle.dumps(data))
retrieved_pickle = pickle.loads(r_bytes.get('user:pickle'))
print(f"Pickle data: {retrieved_pickle}")最后，键名设计和过期策略也值得一提。清晰的键名设计（比如
user:{id}:profile选择Memcached还是Redis，这在我看来，就像选择一把锋利的菜刀还是一把瑞士军刀。两者都能切东西，但功能和适用场景却大相径庭。在Python应用中，我通常会根据项目的具体需求来做判断。
Memcached的适用场景：
Memcached就像那把锋利的菜刀，它的设计哲学就是纯粹、简单、极致的键值缓存。它不提供复杂的数据结构，不支持数据持久化，也没有Pub/Sub、事务这些高级功能。它的优势在于：
python-memcached
我个人觉得，如果你的需求仅仅是“快速地存取一些简单的、可以丢失的键值对”，并且对内存占用有较高要求，那么Memcached无疑是更轻量、更直接的选择。它就像一个高效的内存字典，用起来没什么负担。
Redis的适用场景：
Redis则更像那把瑞士军刀，它不仅能做缓存，还能做更多的事情。它的核心优势在于：
我通常会倾向于在项目中使用Redis，即使初期需求只是简单的键值缓存。因为随着项目的发展，很可能你会发现需要列表、集合或者持久化等功能，这时候如果一开始就用了Redis，后续的扩展会平滑得多。Memcached虽然快，但它的功能边界非常清晰，一旦超出这个边界，你就需要引入其他组件来弥补，这反而增加了系统的复杂性。当然，这也不是绝对的，对于流量极其庞大、对纯粹键值性能有极致追求的场景，Memcached仍然是不可替代的。
确保缓存服务的稳定性和高可用性，对于任何生产环境的Python应用来说都是至关重要的。毕竟，缓存一旦失效或服务中断，很可能导致数据库压力骤增，甚至拖垮整个系统。我在这方面有一些思考，觉得不光要关注缓存服务本身，还得从应用层面做好防护。
对于Redis：
Redis提供了多种机制来保证高可用性，而Python客户端库也很好地支持了这些机制。
哨兵模式（Sentinel）： 这是我个人觉得最常用、也是最成熟的Redis高可用方案之一。Sentinel集群负责监控主从Redis实例，当主节点失效时，它会自动进行故障转移，将一个从节点提升为新的主节点。在Python应用中，你需要使用
redis.Sentinel
from redis.sentinel import Sentinel
sentinels = [('localhost', 26379), ('localhost', 26380), ('localhost', 26381)]
# 'mymaster'是你在Sentinel配置中定义的主节点名称
sentinel = Sentinel(sentinels, socket_timeout=0.1)
# 获取主节点连接
master = sentinel.master_for('mymaster', decode_responses=True)
master.set('mykey', 'Hello from Sentinel master!')
print(f"Master: {master.get('mykey')}")
# 获取从节点连接（用于读操作）
slave = sentinel.slave_for('mymaster', decode_responses=True)
print(f"Slave: {slave.get('mykey')}")集群模式（Cluster）： 对于需要处理海量数据和更高并发的场景，Redis Cluster提供了数据分片（sharding）和高可用性。数据被分散存储在多个主节点上，每个主节点可以有自己的从节点。Python客户端（如
redis-py-cluster
redis-py
主从复制（Replication）： 这是Redis高可用的基础。主节点负责写操作，从节点复制主节点的数据，可以用于读操作分流和数据冗余。虽然主从复制本身不提供自动故障转移，但它是Sentinel和Cluster模式的基石。在Python应用中，你可以直接连接到主节点进行写操作，连接到从节点进行读操作（但需要自行管理读写分离逻辑）。
对于Memcached：
Memcached本身没有内置的高可用性机制（如主从、集群）。它的高可用性主要依赖于客户端的分片和应用的容错能力。
客户端分片/一致性哈希：
python-memcached
import memcache # 客户端会根据键的哈希值，将请求路由到这些服务器 # 如果其中一个服务器宕机，客户端会自动跳过 mc = memcache.Client(['10.0.0.1:11211', '10.0.0.2:11211', '10.0.0.3:11211'])
应用层容错： 由于Memcached是纯粹的缓存，它的数据被认为是“可丢失的”。这意味着，如果Memcached服务完全不可用，你的应用应该能够优雅地降级，例如直接从数据库获取数据，而不是直接报错。这种“缓存穿透”到数据库的行为，虽然会增加数据库压力，但至少保证了服务的可用性。
通用的稳定性和高可用性策略（适用于Redis和Memcached）：
以上就是如何使用Python操作Redis/Memcached？的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
904
收藏
