为何Python鲜少将import语句置于函数内部？及包依赖兼容问题咨询

Great question! Let's break this down clearly, covering both your robustness problem and the broader import convention question.

Fixing Robustness: Isolate Dependencies to Specific Functions #

The root issue here is that global imports execute when the module is first loaded, not when a function is called. So even if lala() doesn't need numpy, missing numpy will crash the entire module load—blocking access to all functions, even independent ones.

The simple fix is to move the import into the function that actually requires it. Here's how to adjust your code:

def lala(in_val):
    out = max(in_val)
    return out

def fufu(in_val):
    import numpy as np
    out = np.mean(in_val)
    return out

Now, lala() will work perfectly even if numpy isn't installed. The import only triggers when someone calls fufu()—if numpy is missing, only that function fails (with an ImportError), not the whole module.

For a friendlier user experience, wrap the import in an exception handler to give clear feedback:

def fufu(in_val):
    try:
        import numpy as np
    except ImportError:
        raise RuntimeError(
            "The 'fufu' function requires numpy to run. "
            "Install it with `pip install numpy` first."
        ) from None
    out = np.mean(in_val)
    return out

This replaces a generic import error with a message that tells users exactly what they need to do.

Why In-Function Imports Are Uncommon in Python #

While in-function imports solve your robustness problem, they're not the standard approach—and there are practical reasons for that:

• Readability & Transparency: Top-level imports let anyone reading your code immediately see all dependencies. With in-function imports, you have to dig through every function to find hidden dependencies, which makes maintenance harder, especially for large projects.
• Static Tooling Compatibility: Most IDEs, linters (like pylint), and type checkers (like mypy) rely on top-level imports to provide code hints, error checking, and auto-completion. Imports inside functions can confuse these tools, leading to missing suggestions or false positive errors.
• Perceived Performance Worries: Many developers think importing inside a function reloads the module every time the function runs. In reality, Python caches imported modules in sys.modules—the first import loads the module, and subsequent imports just fetch the cached version. The performance hit is negligible, but the misconception sticks around.
• Code Convention: PEP8 (Python's style guide) recommends placing all imports at the top of the file, right after module docstrings. Following community conventions makes your code more familiar and approachable to other Python developers.
• Hidden Circular Dependencies: While circular imports are a problem either way, they become more difficult to debug when imports are scattered across functions. Tracking down why a module fails to load gets much trickier when dependencies aren't upfront.

Final Thought #

In-function imports are a totally valid strategy for handling optional dependencies and boosting your package's robustness—especially if you want users to access core features without installing every optional library. Just be mindful of the tradeoffs in readability and tooling support, and document optional dependencies clearly so users know what they need for specific functions.

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