redis/redis-py
Snapshot của redis/redis-py: 13.7k★ · Python · Backend. Redis Python client
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
Snapshot
Cộng tác viên hàng đầu
Xem cộng tác viên hàng đầu
redis-py
The Python interface to the Redis key-value store.
Installation | Usage | Advanced Topics | Contributing
How do I Redis?
Learn for free at Redis University
Try the Redis Cloud
Dive in developer tutorials
Join the Redis community
Work at Redis
Installation
Start a redis via docker (for Redis versions >= 8.0):
docker run -p 6379:6379 -it redis:latest
Start a redis via docker (for Redis versions < 8.0):
docker run -p 6379:6379 -it redis/redis-stack:latest
To install redis-py, simply:
$ pip install redis
For faster performance, install redis with hiredis support, this provides a compiled response parser, and for most cases requires zero code changes. By default, if hiredis >= 1.0 is available, redis-py will attempt to use it for response parsing.
$ pip install "redis[hiredis]"
Looking for a high-level library to handle object mapping? See redis-om-python!
Supported Redis Versions
The most recent version of this library supports Redis 7.2 and every later release, up to the latest stable Redis version. CI tests each of these Redis release lines.
The table below highlights version compatibility of the most-recent library versions and redis versions.
| Library version | Supported redis versions |
|---|---|
| 3.5.3 | <= 6.2 Family of releases |
| >= 4.5.0 | Version 5.0 to 7.0 |
| >= 5.0.0 | Version 5.0 to 7.4 |
| >= 6.0.0 | Version 7.2 to current |
Supported Python Versions
redis-py supports every CPython version that has not reached
end of life, and PyPy.
requires-python in pyproject.toml states the minimum Python version for each
release. If you are on an older Python version, use the last redis-py release
that supports it:
| Python version | Last supporting redis-py releases |
|---|---|
| 3.7 | 5.0.x |
| 3.8 | 6.1.x |
| 3.9 | 7.0.x |
| 3.10 | 8.1.x |
Usage
Basic Example
>>> import redis
>>> r = redis.Redis(host='localhost', port=6379, db=0)
>>> r.set('foo', 'bar')
True
>>> r.get('foo')
b'bar'
The above code connects to localhost on port 6379, sets a value in Redis, and retrieves it. All responses are returned as bytes in Python, to receive decoded strings, set decode_responses=True. For this, and more connection options, see these examples.
RESP3 Support
redis-py supports RESP3 starting with version 5.0. Starting with redis-py 8.0, clients use RESP3 on the wire by default while preserving legacy RESP2-compatible Python response shapes for existing applications.
When protocol is left unset, a server or proxy that rejects HELLO with
an unknown-command or NOPROTO error triggers a fallback to RESP2 and a warning.
Authentication and other server errors still propagate. Automatic fallback is
disabled when protocol=3 is explicit, client-side caching is configured, or
maintenance notifications are explicitly enabled.
Automatic fallback adapts core command response callbacks only. Module commands
(JSON, Search, TimeSeries, Bloom, and vector sets) still select their response
parsers from the configured protocol and can return incorrect results after a
fallback, including empty results from FT.SEARCH. When using these commands
with a server or proxy that does not support HELLO, set protocol=2 explicitly
when creating the client.
Set protocol=3 explicitly when your application should receive RESP3-specific response shapes or when you want the wire protocol choice to be visible in code. To force RESP2 on the wire, set protocol=2. To opt in to protocol-independent response shapes, set legacy_responses=False.
For new projects, we recommend opting out of legacy response compatibility by setting legacy_responses=False. This makes redis-py return unified Python response shapes for affected commands whether the connection uses RESP2 or RESP3. Existing applications can keep the default legacy-compatible behavior while they migrate response handling at their own pace.
>>> import redis
>>> r = redis.Redis(host='localhost', port=6379, db=0, legacy_responses=False)
See the unified responses migration guide for activation instructions and command-by-command response differences. For RESP3-specific behavior, see the RESP3 features guide.
Connection Pools
By default, redis-py uses a connection pool to manage connections. Each instance of a Redis class receives its own connection pool. You can however define your own redis.ConnectionPool.
>>> pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
>>> r = redis.Redis(connection_pool=pool)
Alternatively, you might want to look at Async connections, or Cluster connections, or even Async Cluster connections.
Cluster and Sentinel
Connect to a Redis Cluster through any of its nodes. The client discovers the rest of the cluster and routes each command to the right node.
>>> from redis import RedisCluster
>>> rc = RedisCluster(host='localhost', port=6379)
>>> rc.set('foo', 'bar')
True
Connect to a primary that Redis Sentinel monitors by naming the service and listing the sentinels.
>>> from redis import Sentinel
>>> sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)
>>> primary = sentinel.master_for('mymaster', socket_timeout=0.1)
>>> primary.set('foo', 'bar')
True
Redis Commands
There is built-in support for all of the out-of-the-box Redis commands. They are exposed using the raw Redis command names (HSET, HGETALL, etc.) except where a word (i.e. del) is reserved by the language. The complete set of commands can be found here, or the documentation.
Advanced Topics
The official Redis command documentation does a great job of explaining each command in detail. redis-py attempts to adhere to the official command syntax. There are a few exceptions:
-
MULTI/EXEC: These are implemented as part of the Pipeline class. The pipeline is wrapped with the MULTI and EXEC statements by default when it is executed, which can be disabled by specifying transaction=False. See more about Pipelines below.
-
SUBSCRIBE/LISTEN: Similar to pipelines, PubSub is implemented as a separate class as it places the underlying connection in a state where it can't execute non-pubsub commands. Calling the pubsub method from the Redis client will return a PubSub instance where you can subscribe to channels and listen for messages. You can only call PUBLISH from the Redis client (see this comment on issue #151 for details).
For more details, please see the documentation on advanced topics page.
Pipelines
The following is a basic example of a Redis pipeline, a method to optimize round-trip calls, by batching Redis commands, and receiving their results as a list.
>>> pipe = r.pipeline()
>>> pipe.set('foo', 5)
>>> pipe.set('bar', 18.5)
>>> pipe.set('blee', "hello world!")
>>> pipe.execute()
[True, True, True]
PubSub
The following example shows how to utilize Redis Pub/Sub to subscribe to specific channels.
>>> r = redis.Redis(...)
>>> p = r.pubsub()
>>> p.subscribe('my-first-channel', 'my-second-channel', ...)
>>> p.get_message()
{'pattern': None, 'type': 'subscribe', 'channel': b'my-second-channel', 'data': 1}
Redis’ search and query capabilities default dialect
Release 6.0.0 introduces a client-side default dialect for Redis’ search and query capabilities. By default, the client now overrides the server-side dialect with version 2, automatically appending DIALECT 2 to commands like FT.AGGREGATE and FT.SEARCH.
Important: Be aware that the query dialect may impact the results returned. If needed, you can revert to a different dialect version by configuring the client accordingly.
>>> from redis.commands.search.field import TextField
>>> from redis.commands.search.query import Query
>>> from redis.commands.search.index_definition import IndexDefinition
>>> import redis
>>> r = redis.Redis(host='localhost', port=6379, db=0)
>>> r.ft().create_index(
>>> (TextField("name"), TextField("lastname")),
>>> definition=IndexDefinition(prefix=["test:"]),
>>> )
>>> r.hset("test:1", "name", "James")
>>> r.hset("test:1", "lastname", "Brown")
>>> # Query with default DIALECT 2
>>> query = "@name: James Brown"
>>> q = Query(query)
>>> res = r.ft().search(q)
>>> # Query with explicit DIALECT 1
>>> query = "@name: James Brown"
>>> q = Query(query).dialect(1)
>>> res = r.ft().search(q)
You can find further details in the query dialect documentation.
Multi-database client (Active-Active)
The multi-database client allows your application to connect to multiple Redis databases, which are typically replicas of each other. It is designed to work with Redis Software and Redis Cloud Active-Active setups. The client continuously monitors database health, detects failures, and automatically fails over to the next healthy database using a configurable strategy. When the original database becomes healthy again, the client can automatically switch back to it.
This is useful when:
- You have more than one Redis deployment. This might include two independent Redis servers or two or more Redis databases replicated across multiple active-active Redis Enterprise clusters.
- You want your application to connect to one deployment at a time and to fail over to the next available deployment if the first deployment becomes unavailable.
For the complete failover configuration options and examples, see the Multi-database client docs.
Bulk hash ingestion (HIMPORT)
Redis 8.10 adds the HIMPORT command family for loading many hashes that share
the same set of field names: register the field names once with himport_prepare,
then create each hash by sending only its values. Keys written this way are regular
hashes — every hash command works on them.
r.himport_prepare("users", ["name", "email", "age"])
r.himport_set("user:1", "users", ["alice", "[email protected]", "25"])
r.himport_set("user:2", "users", ["bob", "[email protected]", "30"])
r.himport_discard("users") # => 1
Values pair positionally with the prepared fields. Hash enumeration order
(HGETALL, HKEYS) is not guaranteed to match the prepare order.
Fieldsets are connection state. A prepared fieldset lives in the server-side
session of the physical connection that prepared it: it is invisible to other
connections and destroyed by a disconnect or RESET. redis-py handles this for you —
himport_prepare records the fieldset in a client-level registry, and the PREPARE
is applied lazily on whatever pooled connection serves each himport_set (and
re-applied automatically after a reconnect, RESET, or Sentinel/cluster failover).
You declare each fieldset once per client with himport_prepare; there is no
constructor argument for it.
For the highest ingestion throughput, send the PREPARE and its SETs in one
pipeline — a single batch always executes on one connection:
with r.pipeline(transaction=False) as pipe:
pipe.himport_prepare("users", ["name", "email", "age"])
for uid, row in rows:
pipe.himport_set(f"user:{uid}", "users", row)
pipe.execute()
The automatic re-prepare applies to direct calls only, not to commands inside
pipeline/transaction blocks: a batched himport_set relies on the single
pre-flight PREPARE in that batch.
With RedisCluster, himport_prepare / himport_discard / himport_discard_all
update the client's shared, cluster-wide registry and return immediately — like the
standalone API, they perform no server I/O of their own. The server-side PREPARE
(and, after a discard, DISCARD) is applied lazily on each node's connection the
next time it serves an himport_set, and re-applied after reconnects or failover;
himport_set itself routes by the key's hash slot. A discard is therefore not
removed from every server session at once: each connection drops the fieldset on its
next himport_set (or on disconnect). With Sentinel, call
himport_prepare on the long-lived client returned by master_for(...); the fieldset
survives failover automatically. HIMPORT is not supported on the multi-database
(Active-Active) client.
The async client mirrors this exactly:
await r.himport_prepare("users", ["name", "email", "age"])
await r.himport_set("user:1", "users", ["alice", "[email protected]", "25"])
Documentation
- redis-py documentation, with the API reference and examples.
- Redis Python client guide in the Redis documentation.
- Redis command reference.
Getting Help and Contributing
- Ask questions in GitHub Discussions or on the Redis Discord server.
- Report bugs and request features in GitHub Issues.
- To contribute code or docs, read CONTRIBUTING.md.
- Report security vulnerabilities as described in SECURITY.md, not in public issues.
License
redis-py is licensed under the MIT License.
Author
redis-py is developed and maintained by Redis Inc. It can be found here, or downloaded from pypi.
Special thanks to:
- Andy McCurdy ([email protected]) the original author of redis-py.
- Ludovico Magnocavallo, author of the original Python Redis client, from which some of the socket code is still used.
- Alexander Solovyov for ideas on the generic response callback system.
- Paul Hubbard for initial packaging support.
Repo liên quan
Awesome Python is a curated list maintained at vinta/awesome-python that groups Python frameworks, libraries, tools, and other resources into 14 categories, from AI & ML to Security and Other. The README calls it an opinionated guide rather than an exhaustive one, and points readers to a companion site, awesome-python.com, for searching and filtering entries instead of scrolling the raw file.
The Algorithms - Python is an open-source collection of algorithm implementations written in Python, maintained by the TheAlgorithms organization on GitHub. The README frames the whole project as a teaching resource: the code exists to illustrate concepts, can run slower than Python's built-in equivalents, and is indexed in DIRECTORY.md for browsing. It's MIT licensed and available on GitHub.
HelloGitHub is a curated GitHub repository from 521xueweihan that publishes a monthly digest of entry-level open source projects, open source books, practical projects, and enterprise-level projects, aimed mainly at Chinese-reading developers new to open source. The README says issues go out on the 28th of each month, and the repo's own issue table runs past number 124, with reader recommendations and self-nominations accepted through a documented contribution process.
CS-Notes is a GitHub repository maintained by CyC2018 that collects Chinese-language study notes across ten topic areas: algorithms, operating systems, networking, object-oriented design, databases, Java, system design, tools, coding practice, and an afterword. It links each topic to standalone markdown files instead of writing everything inline, and the README says most of the content is original work rather than material copied from elsewhere.
Trả lời nhanh
Cùng nhóm Backend còn repo nào?
redis/redis-py thuộc nhóm Backend trên TopGit, cùng 5 topic GitHub. Trang Trending và Topics liệt kê các repo cùng số sao và cùng ngôn ngữ để so sánh.
Đọc thêm về redis/redis-py ở đâu?
Trang TopGit này là một snapshot — tab "Readme" hiển thị nguyên văn README của repo (đã bỏ link, giữ ảnh). Repo GitHub ở github.com/redis/redis-py là nguồn chính thức.
redis/redis-py có bao nhiêu sao?
redis/redis-py có 13.7k sao GitHub — tải lại trang để xem số mới nhất, hoặc xem trực tiếp github.com/redis/redis-py. TopGit phản chiếu số sao của GitHub nhưng không cam kết đến từng phút.
redis/redis-py có phải mã nguồn mở không?
Có — redis/redis-py phát hành theo license MIT, nghĩa là mã nguồn mở để đọc, fork và (tùy license) tái sử dụng. Mã: github.com/redis/redis-py.
redis/redis-py còn đang phát triển không?
Commit gần nhất trên redis/redis-py là 5 ngày trước (theo timestamp GitHub). Repo có 2.8k fork — một chỉ báo về mức độ quan tâm của cộng đồng.
redis/redis-py dùng license gì?
redis/redis-py phát hành theo license MIT. Nên mở file LICENSE trên GitHub để xác nhận — license metadata đôi khi lệch với thực tế dự án.
redis/redis-py là gì?
redis/redis-py (redis/redis-py) là dự án Python trên GitHub. Theo mô tả gốc: Redis Python client
redis/redis-py viết bằng ngôn ngữ gì?
redis/redis-py chủ yếu viết bằng Python. Trường "language" của GitHub dựa trên phần lớn byte ở nhánh mặc định.
Đọc đầy đủ README ở tab phía trên.
Chưa chắc redis-py có hợp với bạn?
Để ChatGPT, Claude hoặc Perplexity tìm hiểu giúp — bấm bên dưới và xem AI nói gì về redis-py.