Detailed explanation of relative import and absolute import in Python

Preface

Python relative import and absolute import, these two concepts are relative to the import in the package. In-package import means that modules within the package import modules within the package.

Search path for Python import

Search for the module in the current directory

Search in sequence in the path list specified in the environment variable PYTHONPATH

Search in the lib library of the Python installation path

Python import steps

Python All loaded module information is stored in the sys.modules structure. When importing a module, It will be carried out as follows

If it is import A, check whether there is already A in sys.modules. If there is, it will not be loaded. If not, create a module object for A and load A

If it is from A import B, first create a module object for A, then parse A, find B from it and fill it into A's __dict__

Relative import and absolute import

The format of absolute import is import A.B or from A import B, the relative import format is from . import B or from ..A import B, . represents the current module, .. represents the upper module, ... represents the upper module, in order analogy.

Relative import can avoid maintenance problems caused by hard coding. For example, if we change the name of a top-level package, then all imports of its sub-packages will no longer be available. However, modules with relative import statements cannot be run directly, otherwise there will be an exception:

ValueError: Attempted relative import in non-package

What is the reason for this? We need to first understand some rules when importing modules:

When the package structure is not explicitly specified, Python determines the structure of a module in the package based on __name__. If it is __main__, then it itself It is a top-level module with no package structure. If it is an A.B.C structure, then the top-level module is A. Basically follow this principle:

If it is an absolute import, a module can only import its own submodules or modules and their submodules at the same level as its top-level module

If it is a relative import Import, a module must have a package structure and can only import modules inside its top-level module

If a module is run directly, it itself is the top-level module and there is no hierarchy, so it cannot be found Relative path to other.

Python2.x defaults to relative path import, and Python3.x defaults to absolute path import. Absolute import can avoid importing subpackages from overwriting standard library modules (conflicts due to the same name). If you want to use absolute import by default in Python2. Treated as an absolute import, which means disabling implicit relative import (implicit relative import), but not disabling explicit relative import (display relative import).

So what is an implicit relative import and what is an explicit relative import? Let's look at an example, assuming the following package structure:

from __future__ import absolute_import

Then if you reference bench in the tool, there are several ways:

thing
├── books
│ ├── adventure.py
│ ├── history.py
│ ├── horror.py
│ ├── __init__.py
│ └── lovestory.py
├── furniture
│ ├── armchair.py
│ ├── bench.py
│ ├── __init__.py
│ ├── screen.py
│ └── stool.py
└── __init__.py

Implicit relative means that the interpreter is not told about the relative To whom, but the default is relative to the current module; and explicit relative clearly tells the interpreter relative to whom to import. The third import method above is officially recommended. The first method is strongly not recommended by the official. It has been abandoned in Python3. This method can only be used to import modules in path.

Relative and absolute are only for imports within the package

Finally, it is emphasized again that relative imports and absolute imports are only for imports within the package, otherwise the content discussed in this article It just doesn't make sense. The so-called package is the directory containing the __init__.py file. This file will be executed first when the package is imported. The file can be empty, or any legal Python code can be added to it.

Relative import can avoid hard coding and is friendly to package maintenance. Absolute import can avoid naming conflicts with the standard library. In fact, it is not recommended that custom modules have the same commands as the standard library.

As mentioned earlier, modules containing relative imports cannot be run directly. In fact, modules containing absolute imports cannot be run directly. ImportError will appear:

import bench     # 此为 implicit relative import
from . import bench   # 此为 explicit relative import
from furniture import bench # 此为 absolute import

This is the same as when absolutely imported. s reason. To run modules in a package that contain absolute and relative imports, you can tell the interpreter the module hierarchy with python -m A.B.C .

Someone may ask: If there are two modules a.py and b.py placed in the same directory, why can you import a in b.py?

This is because the directory where these two files are located is not a package, so each python file is an independent module that can be directly imported by other modules, just like you import the standard library, they do not There are issues with relative imports and absolute imports. Relative imports and absolute imports are only used inside packages.

Summary

The above is the entire content of this article. I hope the content of this article can be helpful to everyone in learning or using python. If you have any questions, you can leave a message to communicate.

For more detailed explanations of relative imports and absolute imports in Python, please pay attention to the PHP Chinese website!