我还想补充一点。如果遇到循环导入，了解Python如何将导入的模块作为属性处理可能会很有用。

我有以下结构:

mod/
    __init__.py
    main.py
    a.py
    b.py
    c.py
    d.py

我将使用不同的导入方法从main.py导入其他模块

main.py:

import mod.a
import mod.b as b
from mod import c
import d

Dis.dis显示了两者的区别(注意模块名，a b c d):

  1           0 LOAD_CONST               0 (-1)
              3 LOAD_CONST               1 (None)
              6 IMPORT_NAME              0 (mod.a)
              9 STORE_NAME               1 (mod)

  2          12 LOAD_CONST               0 (-1)
             15 LOAD_CONST               1 (None)
             18 IMPORT_NAME              2 (b)
             21 STORE_NAME               2 (b)

  3          24 LOAD_CONST               0 (-1)
             27 LOAD_CONST               2 (('c',))
             30 IMPORT_NAME              1 (mod)
             33 IMPORT_FROM              3 (c)
             36 STORE_NAME               3 (c)
             39 POP_TOP

  4          40 LOAD_CONST               0 (-1)
             43 LOAD_CONST               1 (None)
             46 IMPORT_NAME              4 (mod.d)
             49 LOAD_ATTR                5 (d)
             52 STORE_NAME               5 (d)
             55 LOAD_CONST               1 (None)

最后它们看起来是一样的(STORE_NAME在每个例子中都是result)，但如果你需要考虑以下四个循环导入，这是值得注意的:

例二

foo/
   __init__.py
   a.py
   b.py

a.py:
import foo.b 

b.py:
import foo.a

>>> import foo.a
>>>

这是

example2

bar/
   __init__.py
   a.py
   b.py

a.py:
import bar.b as b

b.py:
import bar.a as a

>>> import bar.a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "bar\a.py", line 1, in <module>
    import bar.b as b
  File "bar\b.py", line 1, in <module>
    import bar.a as a
AttributeError: 'module' object has no attribute 'a'

没说

青年们

baz/
   __init__.py
   a.py
   b.py

a.py:
from baz import b

b.py:
from baz import a

>>> import baz.a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "baz\a.py", line 1, in <module>
    from baz import b
  File "baz\b.py", line 1, in <module>
    from baz import a
ImportError: cannot import name a

类似的问题……但显然，从x导入y并不等于从y导入x

example4

qux/
   __init__.py
   a.py
   b.py

a.py:
import b 

b.py:
import a

>>> import qux.a
>>>

这个也可以

我发现的一个显著区别是，令人惊讶的是，没有人讨论过使用纯导入，你可以从导入的模块中访问私有变量和私有函数，这是from-import语句无法实现的。

图像中的代码:

setting.py

public_variable = 42
_private_variable = 141
def public_function():
    print("I'm a public function! yay!")
def _private_function():
    print("Ain't nobody accessing me from another module...usually")

plain_importer.py

import settings
print (settings._private_variable)
print (settings.public_variable)
settings.public_function()
settings._private_function()

# Prints:
# 141
# 42
# I'm a public function! yay!
# Ain't nobody accessing me from another module...usually

from_importer.py

from settings import *
#print (_private_variable) #doesn't work
print (public_variable)
public_function()
#_private_function()   #doesn't work

因为我也是初学者，我将尝试用一种简单的方式解释这一点: 在Python中，我们有三种类型的import语句，分别是:

1. 一般进口:

import math

这种类型的导入是我个人最喜欢的，这种导入技术的唯一缺点是，如果你需要使用任何模块的函数，你必须使用以下语法:

math.sqrt(4)

当然，它增加了输入工作，但作为初学者，它将帮助您跟踪与之相关的模块和函数(一个好的文本编辑器将大大减少输入工作，推荐使用)。

输入工作可以通过使用import语句进一步减少:

import math as m

现在，您可以使用m.s rt()而不是math.sqrt()。

2. 功能导入:

from math import sqrt

如果您的代码只需要访问模块中的单个或少数函数，则这种类型的导入最适合，但如果要使用模块中的任何新项，则必须更新import语句。

3.普遍的进口:

from math import * 

虽然它大大减少了输入工作量，但不推荐，因为它将用模块中的各种函数填充代码，并且它们的名称可能与用户定义函数的名称冲突。 例子:

如果你有一个自己命名为sqrt的函数，并且你导入了math，你的函数是安全的:这是你的sqrt，这是math.sqrt。但是，如果从math import *执行，则会遇到一个问题:即，两个不同的函数具有完全相同的名称。来源:“

我正在回答一个类似的问题，但在我发布之前，发帖者删除了它。这里有一个例子来说明这些区别。

Python库可以有一个或多个文件(模块)。为例子,

package1
  |-- __init__.py

or

package2
  |-- __init__.py
  |-- module1.py
  |-- module2.py

我们可以在任何基于设计需求的文件中定义python函数或类。

让我们来定义

在mylibrary1下的__init__.py中的Func1 () mylibrary2下的module2.py中的Foo()。

我们可以使用这些方法之一访问func1()

import package1

package1.func1()

or

import package1 as my

my.func1()

or

from package1 import func1

func1()

or

from package1 import *

func1()

我们可以使用以下方法之一来访问foo():

import package2.module2

package2.module2.foo()

or

import package2.module2 as mod2

mod2.foo()

or

from package2 import module2

module2.foo()

or

from package2 import module2 as mod2

mod2.foo()

or

from package2.module2 import *

foo()

支持这两种方法是有原因的:有时一种比另一种更合适。

导入模块:当你从模块中使用很多位的时候很好。缺点是需要用模块名限定每个引用。 从模块导入…:导入的项目可以直接使用，不需要模块名前缀。缺点是必须列出所使用的每一个东西，并且在代码中不清楚某些东西是从哪里来的。

使用哪种方法取决于哪种方法使代码清晰易读，并且与个人喜好有很大关系。我通常倾向于导入模块，因为在代码中，对象或函数的来源非常清楚。我使用from module import…当我在代码中经常使用一些对象/函数时。

import module和from module import foo之间的区别主要是主观的。选择一个你最喜欢的，并始终如一地使用它。这里有几点可以帮助你做决定。

导入模块

优点: 更少地维护您的导入语句。不需要添加任何额外的导入就可以开始使用模块中的另一个项 缺点: 输入模块。Foo在你的代码中可能是乏味和冗余的(单调可以通过使用import module作为mo然后输入mo. Foo来最小化)

从模块导入foo

优点: 使用foo时输入更少 对可以访问模块的哪些项有更多的控制 缺点: 要使用模块中的新项，必须更新import语句 你失去了关于foo的上下文。例如，与math.ceil()相比，ceil()的作用就不太清楚了。

这两种方法都可以，但不要使用from module import *。

对于任何合理的大型代码集，如果您导入*，则可能会将其固化到模块中，无法删除。这是因为很难确定代码中使用的哪些项来自'module'，这很容易让你认为你不再使用导入，但很难确定。