Detailed explanation of the from..import absolute import statement in Python

Relative or absolute import
More complex parts have been implemented since python2.5: importing a module can specify the use of absolute or package-relative imports. The plan is to move to the detail of making absolute imports the default in other versions of Python.
Let's assume you have a package directory like this:

pkg/
pkg/__init__.py
pkg/main.py
pkg/string.py

The above defines a package called pkg that contains two submodules: pkg.main and pkg.string. Considering the code in 'main.py', what will happen if we execute the statement import string in python2.4 or earlier? It will query the package directory to perform a relative import, find pkg/string.py, and import the contents of the file as the pkg.string module. The boundary name of this module is the namespace of 'string' in the pkg.main module.
This is great if pkg.string is what you want. But what if all you want is python’s basic string module?
There is no clear way to ignore pkg.string and find the underlying module; normally you have to look at the contents of sys.modules, which is a little unclear. Holger Krekel's py.std package provides a neat way to perform imports from the base library, import py;py.std.string.jion(), but that package is not available during the Python installation process.

Reading the code is also not clear enough in terms of relative imports, because readers may confuse the use of string and pkg.string modules. Python users can immediately tell that there are different names between the base library and their own package modules, but you cannot protect your own submodule names in a new version of Python.

From python2.5, you can turn on the import behavior and go directly to absolute import using from __future__ import absolute_import . This absolute import behavior will become a default detail in future versions of Python. Once absolute imports are defaulted, import string will always look for the base library. It is recommended that users use absolute imports as much as possible, so it is appropriate to use from pkg import string in your code. Required in python2.* versions:

from __future__ import absolute_import

Example 1:
Example: Code in module A.B.C:

from . import D     # 导入A.B.D
from .. import E    # 导入A.E
from ..F import G    # 导入A.F.G，.. 和 F是连着的，中间没有空格

. represents the current directory, .. represents the upper directory, and ... represents the upper directory.

Example 2:

Directory structure:

package/
 __init__.py
 subpackage1/
  __init__.py
  moduleX.py
  moduleY.py
 subpackage2/
  __init__.py
  moduleZ.py
 moduleA.py

You can import module in subpackage1/moduleX.py or subpackage1/__init__.py like this:

from .moduleY import spam
from .moduleY import spam as ham
from . import moduleY
from ..subpackage1 import moduleY
from ..subpackage2.moduleZ import eggs
from ..moduleA import foo
from ...package import bar
from ...sys import path

Note that from ...sys import path is legal, but not recommended. Just directly from sys import path.