SoFunction
Updated on 2025-03-02

Python uses Redis as cache operation method

How to use Redis as cache in Python

1. Introduction

In modern web applications and data-intensive services,performanceandResponse speedis a crucial factor. When an application needs to frequently access the same data, it will take a lot of time and resources to obtain data directly from the database. Therefore, the cache system has become one of the important technologies to improve performance. The cache can temporarily store data in memory, thereby avoiding repeated database queries.

RedisIt is an open source, in-memory data structure storage system that can be used as a cache system to improve application response speed. Redis supports a variety of data structures (such as strings, hashes, lists, collections, etc.), and is characterized by high performance, persistence and simplicity. In Python, we can use the Redis library to easily integrate Redis into our applications to store and retrieve cached data.

This article will help beginners understand how to use Redis as cache in a simple and easy-to-understand way, and combine Python to implement related functions. We will first introduce the basics and installation of Redis, and then explain in detail how to connect Redis and implement caching using Python.

2. What is Redis?

RedisIt is a memory-based high-performance key-value storage system that supports rich data types (such as strings, hashes, lists, collections, etc.) and can be used as databases, caches, and message middleware. Because Redis runs in memory, it reads and writes very quickly and is ideal for use as a cache system. Additionally, Redis provides a persistence mechanism that allows data to be saved to disk, ensuring that data is not lost due to system restarts or crashes.

The main features of Redis include:

  • high performance: Since data is stored in memory, Redis reads and writes are very fast, suitable for application scenarios that require fast response.
  • Multiple data structures: Supports a variety of data structures, such as strings, hashs, lists, collections, ordered collections, etc., which are suitable for a variety of scenarios.
  • Persistence: Although Redis runs primarily in memory, it supports persisting data to disk to ensure data security.
  • Distributed support:Redis supports master-slave replication and cluster mode, and can be well expanded to cope with large-scale usage scenarios.

3. The advantages of Redis as a cache

Using Redis as a cache system has the following advantages:

  • Improve performance: Cache frequently accessed data into memory, reducing the number of times you read from the database, thereby significantly improving the response speed of your application.
  • Reduce database pressure: Cache reduces the load on the database and avoids the pressure on the database caused by frequent read operations.
  • Flexible expiration strategy:Redis supports setting expiration time for cached data, automatically cleaning out expired data, ensuring that the cache does not grow unlimitedly.
  • Supports complex data types: Compared with simple key-value pair cache, Redis supports a variety of complex data structures and can cache rich data formats.

4. Install Redis and Python Redis libraries

Before using Redis, we need to make sure that the Redis server is installed and run on a local or remote server. Python's Redis library is also required to be installed in order to interact with Redis.

4.1 Install Redis

The method of installing Redis is different in different operating systems. The following are common platforms installation methods:

Install Redis on macOS:

Redis can be installed through Homebrew:

brew install redis

Start the Redis service:

brew services start redis

Install Redis on Ubuntu:

Install Redis using the apt package manager:

sudo apt update
sudo apt install redis-server

Start the Redis service:

sudo systemctl start redis-server

Install Redis on Windows:

Redis does not provide Windows versions, but Redis can be installed through third-party tools, such as usingMemurai, or install Redis through Docker.

4.2 Installing the Python Redis library

The most commonly used libraries in Python to interact with Redis areredis-py, can be passedpipInstall:

pip install redis

After the installation is complete, we can use Redis in Python for cache operations.

5. Connect to Redis using Python

5.1 Create a Redis connection

In Python, we can useclass to connect to the Redis server. Here is the basic connection code:

import redis
# Create a Redis connectionr = (host='localhost', port=6379, db=0)
# Test connection('name', 'Alice')
print(('name'))  # Output b'Alice'

In the above code, we passA client object is created that connects to the local Redis server and a key-value pair is written and read to Redis.

Parameter description：

  • host: The address of the Redis server, usuallylocalhost(local) or server IP address.
  • port: The port of the Redis server, the default is 6379.
  • db: Redis provides multiple databases (16 by default),db=0Indicates the use of the first database.

5.2 Using Redis to implement caching

Now we will show how to implement a simple caching function using Redis. The basic idea of ​​caching is: first check whether the data is in the cache, and if it exists, it will be returned directly. Otherwise, query the data from the database and store it in the cache for quick access next time.

Here is a simple cache example:

import redis
import time
# Create a Redis connectionr = (host='localhost', port=6379, db=0)
# Simulate functions that get data from databasedef get_data_from_db(key):
    print(f"Query database acquisition {key} Value of...")
    (2)  # Simulate database query time    return f"value_of_{key}"
# Functions that get data from cache or databasedef get_data(key):
    # Try to get data from cache    cached_value = (key)
    if cached_value:
        print(f"Get from cache {key} Value of...")
        return cached_value.decode()  # Redis stores data of byte type and needs to be decoded    # No data in the cache, query the database    value = get_data_from_db(key)
    # Write data to cache and set the expiration time to 10 seconds    (key, 10, value)
    return value
# Test the cache functionprint(get_data('user:1'))  # The first time you will get data from the databaseprint(get_data('user:1'))  # The second time will be fetched from the cache

In this example:

  • get_data_from_db()It is a function that simulates data fetching from a database, which delays by 2 seconds to simulate real database query operations.
  • get_data()The function first tries to get cached data from Redis, and returns directly if the cache hits. Otherwise, the data is obtained from the database and cache, setting the cache expiration time to 10 seconds.

Example of run result:

Query the database to get the value of user:1...
value_of_user:1
Get the value of user:1 from the cache...
value_of_user:1

It can be seen that the data is obtained from the "database" during the first query, and the data is read directly from the cache during the second query, avoiding time-consuming database query operations.

6. Common cache operations in Redis

In practical applications, Redis supports a variety of cache operations. The following will introduce some commonly used Redis operations.

6.1 Setting key-value pairs

useset()Methods can store data in Redis,get()Methods are used to obtain data:

# Set key-value pairs('key1', 'value1')
# Get key-value pairsprint(('key1').decode())  # Output: value1

6.2 Set expiration time

usesetex()Methods can specify the expiration time (units: seconds) while setting the data:

# Set key-value pairs with expiration time('key2', 10, 'value2')  # The key is in 10 Expired in seconds

Can be passedttl()Method query key remaining survival time:

print(('key2'))  # Output the remaining expiration time

6.3 Delete key

usedelete()Methods can delete the specified key:

('key1')

6.4 Batch operation

Redis also supports batch acquisition or setting key-value pairs:

# Set key-value pairs in batches({'key3': 'value3', 'key4': 'value4'})
# Get key-value pairs in batchesprint((['key3', 'key4']))  # Output: [b'value3', b'value4']

6.5 Using hash storage cache

Redis supports hash type data structures, which can store multiple fields of an object in a hash key:

# Set hash value('user:2', mapping={'name': 'Bob', 'age': 25})
# Get itHope value
print(('user:2', 'name').decode())  # Output: Bobprint(('user:2'))  # Output all fields and values

7. Redis Caching Policy

In practical applications, it is crucial to design a caching strategy rationally. Here are several common caching strategies:

  • LRU（Least Recently Used）: The longest unused policy, when the cache space is insufficient, delete the longest unused data.
  • TTL（Time To Live）: Set the survival time for cached data and automatically delete it after it expires.
  • Active update: Fresh the cached data regularly to ensure the timeliness of the data.

8. Summary

Redis, as a cache system, can greatly improve application performance and responsiveness. In Python, useredis-pyThe library can easily interact with Redis to implement caching. By rationally designing caching strategies, applications can reduce the number of database accesses and reduce server pressure.

Redis can also be used as a database and message queue in addition to being a cache. Mastering the basic use of Redis can help developers improve application performance in a variety of scenarios. In actual projects, when designing caching strategies, you need to consider the consistency and real-time data, and set appropriate expiration time and cache space according to actual needs.

Through the introduction of this article, I hope that readers can have a clear understanding of how to use Redis as a cache in Python and can apply it to actual development.

This is the end of this article about how to use Redis as cache in Python. For more related Python Redis cache content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!