因为我也是初学者，我将尝试用一种简单的方式解释这一点: 在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如何将导入的模块作为属性处理可能会很有用。

我有以下结构:

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
>>>

这个也可以

因为我也是初学者，我将尝试用一种简单的方式解释这一点: 在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 *执行，则会遇到一个问题:即，两个不同的函数具有完全相同的名称。来源:“

有一些内置模块主要包含裸函数(base64, math, os, shutil, sys, time，…)，将这些裸函数绑定到某个名称空间绝对是一个很好的实践，从而提高代码的可读性。想想看，如果没有命名空间，要理解这些函数的含义是多么困难:

copysign(foo, bar)
monotonic()
copystat(foo, bar)

当它们被绑定到某个模块时:

math.copysign(foo, bar)
time.monotonic()
shutil.copystat(foo, bar)

有时你甚至需要命名空间来避免不同模块之间的冲突(json. xml)。Load vs. pickle.load) 另一方面，有些模块包含大部分类(configparser, datetime, tempfile, zipfile，…)，其中许多模块的类名不言自明:

configparser.RawConfigParser()
datetime.DateTime()
email.message.EmailMessage()
tempfile.NamedTemporaryFile()
zipfile.ZipFile()

因此，在代码中使用这些类和额外的模块名称空间是增加了一些新信息还是只是延长了代码，可能会有争论。

补充一下人们关于from x import *的说法:除了使名称的来源更加困难之外，这还会使Pylint等代码检查器无法使用。它们将报告这些名称为未定义的变量。

我自己的答案主要取决于首先，我将使用多少不同的模块。如果我只打算用一两个，我会经常用from…import，因为它在文件的其余部分减少了击键，但如果我要使用许多不同的模块，我更喜欢只使用import，因为这意味着每个模块引用都是自文档化的。我可以看到每个符号的来源，而不需要到处寻找。

通常我更喜欢简单导入的自文档风格，只更改from..当我必须输入模块名的次数增加到10到20次时，即使只有一个模块被导入。