如何让Python的.py文件共享变量与常量？（类比C++头文件机制）

Great question! I totally get where you’re coming from—when I switched from C++ to Python, I missed the simplicity of shared headers for global objects too. The good news is Python has straightforward ways to share variables and constants across files, even if the mechanism works a bit differently from C++ headers. Let’s break it down:

1. Module-Level Variables (The Direct Equivalent) #

Python modules (.py files) act as natural containers for shared state. When you import a module, Python creates a single instance of it—so any variables defined at the top level are accessible and modifiable across all files that import the module.

Example Setup: #

First, create a file (let’s call it shared_state.py) to hold your shared variables and constants:

# Constants (by convention, we use UPPER_CASE for these)
MAX_USERS = 50
DEFAULT_LOG_LEVEL = "INFO"

# Shared variables (can be modified across files)
current_session_id = None
active_users = []

Now, in any other .py file (e.g., main.py), you can import and use these values:

import shared_state

# Access constants
print(f"Maximum allowed users: {shared_state.MAX_USERS}")

# Modify shared variables
shared_state.current_session_id = "abc123"
shared_state.active_users.append("john_doe")

And in another file (e.g., utils.py), you’ll see the updated values:

import shared_state

print(f"Current session: {shared_state.current_session_id}")  # Outputs "abc123"
print(f"Active users: {shared_state.active_users}")  # Outputs ["john_doe"]

Key Notes: #

• Immutable vs Mutable Values: For immutable types (like int, str, tuple), don’t try to reassign them directly without referencing the module—doing current_session_id = "def456" in utils.py would create a local variable instead of modifying the shared one. Always use shared_state.current_session_id = "def456".
• Module Singleton: Python only loads the module once, so all imports point to the same instance of the variables. This is why changes propagate across files.

2. Encapsulated Shared State (For Better Structure) #

If you want to avoid "raw" global variables (which can get messy in large projects), you can use a class to encapsulate your shared constants and state. This is similar to using a static class in C++.

Example: #

Create app_config.py:

class AppConfig:
    # Constants
    API_TIMEOUT = 10
    DB_CONNECTION_STRING = "sqlite:///app.db"
    
    # Private shared state (use underscore to signal it's not for direct access)
    _current_user = None
    
    # Class methods to safely modify/access state
    @classmethod
    def set_current_user(cls, user):
        cls._current_user = user
    
    @classmethod
    def get_current_user(cls):
        return cls._current_user or "Guest"

Then use it in other files:

from app_config import AppConfig

# Access constants
print(f"API Timeout: {AppConfig.API_TIMEOUT}")

# Update and retrieve state
AppConfig.set_current_user("jane_smith")
print(f"Current user: {AppConfig.get_current_user()}")  # Outputs "jane_smith"

This approach keeps your shared state organized and prevents accidental modifications (since you control access via methods).

How This Compares to C++ Shared Headers #

In C++, headers are a compile-time mechanism for declaring symbols that get linked across translation units. In Python, modules are runtime objects—when you import a module, you’re referencing a live object in memory. The end result is the same (shared access to values), but Python’s approach is more dynamic.

A Word of Caution #

Shared variables are handy, but be careful with them in multi-threaded or multi-process code—you might run into race conditions if multiple threads modify the same variable at once. For those cases, you’ll need to use locks (like threading.Lock) to synchronize access.

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