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

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…当我在代码中经常使用一些对象/函数时。

这是我当前目录的目录结构:

. └─a └─b └─c

The import statement remembers all intermediate names. These names have to be qualified: In[1]: import a.b.c In[2]: a Out[2]: <module 'a' (namespace)> In[3]: a.b Out[3]: <module 'a.b' (namespace)> In[4]: a.b.c Out[4]: <module 'a.b.c' (namespace)> The from ... import ... statement remembers only the imported name. This name must not be qualified: In[1]: from a.b import c In[2]: a NameError: name 'a' is not defined In[2]: a.b NameError: name 'a' is not defined In[3]: a.b.c NameError: name 'a' is not defined In[4]: c Out[4]: <module 'a.b.c' (namespace)>

注意:当然，我在第1步和第2步之间重新启动了Python控制台。

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

我刚刚发现这两种方法之间还有一个微妙的区别。

如果模块foo使用以下导入:

from itertools import count

这样，模块bar就会错误地使用count，就好像它是在foo中定义的，而不是在itertools中定义的一样:

import foo
foo.count()

如果foo使用:

import itertools

这种错误仍有可能发生，但不太可能发生。酒吧需要:

import foo
foo.itertools.count()

这给我带来了一些麻烦。我有一个模块错误地从一个没有定义它的模块导入了一个异常，只从其他模块导入了它(使用from module import SomeException)。当不再需要导入并删除时，出现问题的模块就被破坏了。

有一些内置模块主要包含裸函数(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()

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