How to use redis with python

Introduction.

Redis is an open-source, in-memory data structure store that is widely used for caching, real-time analytics, and managing high-performance applications. Let's explore the fundamentals of Redis and its integration with Python. Whether you are a beginner looking to learn the basics or an experienced developer seeking to leverage Redis as a powerful caching mechanism, this guide has got you covered!

What Redis is?

First, let's understand what Redis really is. Redis is a NoSQL database that stores data in key-value pairs, allowing lightning-fast read and write operations due to its in-memory nature. It offers various data structures like strings, lists, sets, sorted sets, hashes, and more, making it versatile for a wide range of use cases.

Installing Redis

Installing Redis is a straightforward process, and it can be done on various operating systems. Below, I'll guide you through the installation steps for different platforms;

Ubuntu/Linux.

Open a terminal and enter the following commands;

sudo apt update
sudo apt install redis-server

Redis will now be installed on your system. You can start the Redis server using the below command.

sudo service redis-server start

On macOS

You can install Redis on macOS using Homebrew. Make sure you install homebrew if not installed. Open a terminal and execute the following commands;

brew update
brew install redis

Windows

To install Redis on Windows, follow these steps:

Download the latest stable release of Redis for Windows from the official GitHub repository: github.com/tporadowski/redis/releases
Extract the downloaded ZIP file to a location of your choice.
Open a Command Prompt in the extracted directory.

To start the Redis server, run the following command:

redis-server.exe

NB. On Windows, the Redis server will run in the foreground by default. To run it as a Windows service, you can use third-party tools like Redis-Service or NSSM.

Docker

If you prefer to use Docker, you can install Redis as a container. Ensure you have Docker installed on your system, and then run the following command in the terminal;

docker run -d -p 6379:6379 redis

This command will pull the official Redis Docker image and start a Redis container on port 6379.

After installation, you can test if Redis is running correctly by opening a terminal and running the following command;

redis-cli ping

You should see the response "PONG," indicating that Redis is running and responding. Now that we have Redis installed let's see how we can use it for caching, storing data, and leveraging its powerful features in your Python applications.

Make sure you have python3 and above or the latest version installed on your 0S and let's dive into it.

Redis commands

Redis operates on a set of commands, each designed to perform specific operations on the data. Some common commands include SET, GET, DEL, INCR, DECR, LPUSH, RPUSH, SADD, ZADD, HSET, and more. You can read more on this commands here Commands | Redis

Basic Operations with Redis and Python

Using hands-on examples let's perform basic operations with Redis using Python. We'll cover storing and retrieving data, setting expiration times for keys, and working with various data structures like lists and sets.

Storing a list of user names and retrieving it using Redis

Example in code.
```
 # Storing a list of user names
 users = ['Alice', 'Bob', 'Charlie']
 r.lpush('users', *users)

 # Retrieving the list of user names
 users_list = r.lrange('users', 0, -1)
 print(f'User names: {[name.decode("utf-8") for name in users_list]}')
```
Explanation;
- First, We define a list users containing the names of three users: 'Alice', 'Bob', and 'Charlie'.
- We use the lpush method of the Redis client (r) to push the elements of the users list to a Redis list with the key 'users'.

The lpush command inserts the specified values at the head (left) of the list, resulting in the order of 'Charlie', 'Bob', and 'Alice' in the Redis list. So, after executing this code, the Redis list will look like: ['Charlie', 'Bob', 'Alice'].

We use the lrange method of the Redis client (r) to retrieve the elements of the Redis list with the key 'users'.
The lrange method takes two arguments: the key of the list ('users' in this case) and the start and end indices. Here, we use 0 as the start index and -1 as the end index, which means we want to retrieve all elements of the list.
The lrange method returns a list of binary strings (bytes), representing the elements in the Redis list.

To display the user names in a readable format, we use a list comprehension to decode each binary string into a UTF-8 encoded string (since Redis returns the data as bytes). We then create a list of user names [name.decode("utf-8") for name in users_list].

Finally, we use an f-string to print the list of user names with the message 'User names: ', resulting in the output: User names: ['Charlie', 'Bob', 'Alice'].

Redis as a Simple Cache

Example;

Using Redis as a cache to store API responses

 import requests
 import redis

 # Connect to Redis server
 r = redis.Redis(host='localhost', port=6379, db=0)

 def get_cached_data(url):
     # Check if the data is already cached
     cached_data = r.get(url)
     if cached_data:
         print('Retrieving data from cache...')
         return cached_data.decode('utf-8')

     # Fetch data from the API
     print('Fetching data from the API...')
     response = requests.get(url)
     data = response.json()

     # Cache the data with a 60-second expiration time
     r.setex(url, 60, data)

     return data

 # Usage example
 api_url = 'https://api.example.com/data'
 cached_data = get_cached_data(api_url)
 print(cached_data)

Explanation

Importing Libraries:
- The code starts by importing two Python libraries: requests and redis.
- requests is used for making HTTP requests to an API to fetch data.
- redis is used to interact with the Redis server and cache the fetched data.
Connecting to Redis:
- The code creates a connection to the local Redis server on the default port 6379 (the standard Redis port) and database 0.
- The Redis server is typically running on localhost for local development.
Defining the Function get_cached_data:
- This function takes a url parameter, which represents the URL of the API endpoint to fetch data from.
- The purpose of this function is to retrieve data either from the Redis cache or from the API if the data is not cached.
Checking if Data is Cached:
- The function first tries to get the data from the Redis cache using r.get(url).
- If the data is found in the cache (i.e., cached_data is not None), it means the data was previously fetched and cached.
Retrieving Data from Cache:
- If the data is found in the cache, the function prints a message indicating that the data is being retrieved from the cache.
- It then decodes the cached data (which is in bytes format) to a UTF-8 string and returns it.
Fetching Data from the API:
- If the data is not found in the cache, the function proceeds to fetch the data from the API.
- It uses the requests.get(url) method to make an HTTP GET request to the specified URL and fetches the response.
- The response is assumed to be in JSON format.
Caching the Data:
- After fetching the data from the API, the function caches the data in Redis using r.setex(url, 60, data).
- The setex method sets the data with an expiration time of 60 seconds. This means that the data will automatically expire and be removed from the cache after 60 seconds.
Returning Data:
- Finally, the function returns the fetched data, whether it was retrieved from the cache or fetched from the API.

In summary

First, we check if the data is already cached in Redis. If it is, the data is quickly retrieved from the cache, reducing the need to make frequent API requests and improving the response time of the application. Additionally, the data is set to expire after 60 seconds, ensuring that the cache remains fresh and up-to-date.

Expiration

Redis allows you to set an expiration time on keys, after which the key and its associated data will be automatically removed. Just as we've seen in the implementation above after 60 seconds data will expire and be removed.

In conclusion

Redis, paired with Python, opens up a world of possibilities for developers seeking efficient and reliable data storage solutions. As you continue your Redis journey, feel free to explore more advanced features and use cases to supercharge. Happy coding

If you enjoyed reading it as much as I enjoyed writing it let's have a chat. You can DM me on Twitter @myrajarenga. You can also connect with me on LinkedIn here Myra Jarenga . You can also support me by following me on this blog here Myra Jarenga's Blog . Thank you

Redis Basics and Python Integration

Table of contents