redis-py实例是否需设为全局变量？函数取值返回None问题咨询

Question 1: Do redis-py objects need to be global to use in functions? #

Nope, they absolutely don't have to be global—global is just a common (and convenient) pattern because it lets you reuse a single connection pool across your code, avoiding the overhead of creating new Redis connections every time you need to interact with the database.

Instead of globals, you have a few better options:

• Pass the Redis client as a parameter: This is great for testability and keeps your functions decoupled. You can initialize the client once (say, in your app setup) and pass it around where needed.
• Use a module-level client: Define the client in a dedicated config/utility module, then import it into other modules that need it. This acts like a "shared" instance without polluting the global namespace of every file.
• Dependency injection: If you're using a framework (like Flask or Django), you can inject the Redis client into functions or classes using the framework's DI tools.

The only downside to creating a new client inside a function is that it'll spin up a new connection pool each time, which can be inefficient if the function is called frequently. So stick to reusing a single client instance, but you don't have to make it global to do that.

Question 2: Why does restore_object return None in another function, and do I need a global object? #

First off—no, you don't need to make the restored object global (that defeats the purpose of using Redis as a shared data store!). Let's figure out why this is happening and fix it.

What's likely going wrong #

Your code uses a global r client, which works when you call restore_object globally, but fails in another function. Here are the most common culprits:

1. The Redis client in your function's scope isn't the same global instance: Maybe you've redefined r somewhere else (like inside the function or another module), or you're importing a different r variable by accident.
2. Data wasn't actually stored successfully: Even if you called store_object globally, maybe the set operation failed silently (though redis-py usually raises exceptions for connection issues).
3. Multi-process/threading quirk: If your function is running in a separate process (e.g., with multiprocessing), the global r in the child process might be a new instance that doesn't share state with the parent's client (though Redis itself is shared—this is less likely, but worth checking).

How to debug and fix it #

First, add some debug prints to narrow down the issue:

def restore_object(key):
    data = r.get(key)
    print(f"Raw data from Redis for key '{key}': {data}")  # Check if data is None here
    if data is None:
        return None
    return pickle.loads(data)

If data is None, run redis-cli GET model directly in your terminal to confirm if the key exists in Redis. If it doesn't, check your store_object function:

def store_object(key, obj):
    var = pickle.dumps(obj)
    result = r.set(key, var)
    print(f"Store result for key '{key}': {result}")  # Should print True if successful

If result is False or throws an error, you have a connection or serialization issue.

Better code (no globals needed) #

To avoid global variable confusion entirely, refactor your functions to accept the Redis client as a parameter. This makes your code cleaner and avoids scope issues:

import redis
import pickle

def store_object(redis_client, key, obj):
    serialized_obj = pickle.dumps(obj)
    redis_client.set(key, serialized_obj)

def restore_object(redis_client, key):
    serialized_data = redis_client.get(key)
    if serialized_data is None:
        # Optionally raise an error here if missing keys are unexpected
        return None
    return pickle.loads(serialized_data)

# Initialize your client once (e.g., in your app entry point)
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)

# Store the object
store_object(redis_client, 'model', Object())

def my_function():
    # Pass the client to the restore function
    restored_obj = restore_object(redis_client, 'model')
    if restored_obj:
        print("Object restored successfully!")
    else:
        print("Object not found in Redis.")

This way, you're explicitly passing the same Redis client instance everywhere, so there's no ambiguity about which client you're using.

Final notes #

• Make sure your Redis server is running and accessible from the same host/port/db in all parts of your code.
• If you're working with complex objects, double-check that pickle can serialize them correctly (some objects like sockets or file handles can't be pickled).

内容的提问来源于stack exchange，提问作者Sterling Butters