为何部分Python包需用from导入，部分用import？底层逻辑解析

Great question—this gets to the heart of how Python manages modules and namespaces, which is key to avoiding those frustrating moments where one import works and another doesn’t. Let’s break this down step by step.

Namespaces: The Core Difference Between Import Styles #

At its simplest, Python’s import styles differ in how they bind names to your current code’s namespace:

• When you use import module, Python creates a module object in your current namespace, named after the module. To access anything inside the module, you have to use the module as a prefix (e.g., module.function() or module.Class). This keeps the module’s internal names separate from your code’s variables, avoiding accidental name conflicts.
• When you use from module import object, Python pulls that specific object (function, class, variable) directly into your current namespace. You can use it without the module prefix (e.g., function() instead of module.function()), but you risk overwriting existing names in your code if they share the same label.

For example:

# Option 1: Import the whole module
import math
print(math.sqrt(4))  # Must use math. prefix

# Option 2: Import a specific object
from math import sqrt
print(sqrt(4))       # No prefix needed

The Underlying Import Process #

Python’s import system follows a consistent pipeline every time you import something—whether you use import, from...import, or __import__():

1. Check the module cache: First, Python looks in sys.modules (a dictionary storing all already-loaded modules). If the module is there, it reuses that existing object instead of reloading it (this is why repeated imports don’t re-run the module’s code).
2. Locate the module: If the module isn’t cached, Python searches through directories listed in sys.path (including the current working directory, standard library paths, and virtual environment paths).
3. Load and execute the module: Once found, Python reads the module’s code, compiles it to bytecode (if needed), and runs the module’s top-level code. This executes all assignments, function definitions, and class definitions, building the module’s internal namespace.
4. Bind names to your namespace: Finally, depending on your import style:
   • import module: Adds the module object to your current namespace under the name module.
   • from module import object: Retrieves the object from the module’s namespace and adds it directly to your current namespace.

Why One Import Might Work When Another Doesn’t #

There are a few common scenarios where one import style fails while the other works:

• Dynamic or conditional names: If an object is defined inside a conditional block (like if __name__ == '__main__':) or created dynamically at runtime, from module import object will fail. Those names only exist in the module’s namespace when the condition is met (e.g., when the module is run directly, not imported). Using import module lets you check if the name exists before accessing it (e.g., if hasattr(module, 'object'): module.object()).
• Submodules and package structure: If you’re working with a package, import package won’t automatically load its submodules. You’d need to use from package import submodule or import package.submodule to access submodule contents. For example, import numpy doesn’t load numpy.linalg—you have to import it explicitly.
• Circular imports: When Module A imports from Module B, and Module B imports from Module A, from...import can cause errors because it tries to pull a name before the module has finished loading. Using import module and accessing names via the module prefix often avoids this, since it delays accessing the name until later in execution.

The __import__() Function: The Low-Level Tool #

__import__(str(module)) is the underlying function that Python’s import statements use under the hood. It’s a way to dynamically import modules using a string (useful if you don’t know the module name until runtime, like in plugin systems or user-driven module loading).

For example:

# Equivalent to import math
math_module = __import__('math')
print(math_module.pi)

# Equivalent to from math import sqrt, pi
math_module = __import__('math')
sqrt = math_module.sqrt
pi = math_module.pi

You’ll rarely need to use __import__() directly for regular code, but it’s a powerful tool for dynamic workflows.

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