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

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

有很多答案，但没有一个提到测试(使用unittest或pytest)。

博士tl;

对外部模块使用import foo来简化测试。

艰难的方式

从模块中单独导入类/函数(从foo import bar中)会使红绿重构周期变得冗长乏味。例如，如果我的文件看起来像

# my_module.py

from foo import bar


class Thing:
    def do_thing(self):
        bar('do a thing')

我的测试是

# test_my_module.py

from unittest.mock import patch
import my_module


patch.object(my_module, 'bar')
def test_do_thing(mock_bar):
    my_module.Thing().do_thing()
    mock_bar.assert_called_with('do a thing')

乍一看，这似乎很棒。但是如果我想在不同的文件中实现Thing类会发生什么呢?我的结构将不得不像这样改变……

# my_module.py

from tools import Thing


def do_thing():
    Thing().do_thing()


# tools.py

from foo import bar


class Thing:
    def do_thing(self):
        bar('do a thing')


# test_my_module.py

from unittest.mock import patch
import my_module
import tools  # Had to import implementation file...


patch.object(tools, 'bar')  # Changed patch
def test_do_thing(mock_bar):
    my_module.do_thing()  # Changed test (expected)
    mock_bar.assert_called_with('do a thing')

不幸的是，由于我使用from foo import bar，我需要更新我的补丁来引用工具模块。从本质上讲，由于我的测试对实现了解太多，因此要进行这个重构，需要更改的内容要比预期的多得多。

更好的方法

使用import foo，我的测试可以忽略模块是如何实现的，而只是对整个模块打补丁。

# my_module.py

from tools import Thing


def do_thing():
    Thing().do_thing()


# tools.py

import foo


class Thing:
    def do_thing(self):
        foo.bar('do a thing')  # Specify 'bar' is from 'foo' module


# test_my_module.py

from unittest.mock import patch
import my_module


patch('foo')  # Patch entire foo module
def test_do_thing(mock_foo):
    my_module.do_thing()  # Changed test (expected)
    mock_foo.bar.assert_called_with('do a thing')

测试知道的实现细节越少越好。这样，如果您提出了更好的解决方案(使用类而不是函数，使用额外的文件来分离思想，等等)，那么在您的测试中需要更改的内容就会更少，以适应重构。

@ahfx已经提到了这些导入的一个关键方面，即加载模块过程的内部。如果你的系统需要使用循环导入(例如，你想在一些流行的http框架中使用依赖注入)，就会弹出这个窗口。在这种情况下，from {module} import {function}对于加载过程如何进行的要求显得更加激进。让我们举个例子:

#m1.py:
print('--start-m1--')
from m2 import *    # form does not matter; just need to force import of m2
print('--mid-m1--')

def do1(x):
    print(x)

print('--end-m1--')

进口

#m2.py
print('--start-m2--')

# from m1 import *      # A
# from m1 import do1    # B
# import m1             # C
                        # D -- no import of "do1" at all
                        
print('--mid-m2--')

def do2(x):
    m1.do1(x)

print('--end-m2--')

通过运行

#main.py:
from m1 import do1
do1('ok')

在m2.py (A,B,C,D)中的所有导入选项中，from {module} import {function}是唯一会导致加载过程崩溃的选项，导致臭名昭著的(CPython 3.10.6)

ImportError: cannot import name 'do1' from partially initialized module 'm1' 
(most likely due to a circular import)

虽然我不能说为什么会发生这种情况，但似乎从……进口…语句对有问题的模块已经处于初始化过程的“多远”提出了更严格的要求。

简单地说，这都是为了方便程序员。在核心级别，它们只是导入模块的所有功能。

import module:当你使用import module时，你必须写module.method()来使用这个模块的方法。每次使用任何方法或属性时，都必须引用模块。

from module import all:当你使用from module import all而不是使用该模块的方法时，你只需要编写method()而不引用该模块。

这里还有另一个细节，没有提到，与写入模块有关。虽然这可能不太常见，但我时不时地需要它。

由于Python中引用和名称绑定的工作方式，如果你想更新模块中的某个符号，请输入foo。Bar，从模块外部，并有其他导入代码“看到”的变化，你必须以某种方式导入foo。例如:

模块foo:

bar = "apples"

模块一:

import foo
foo.bar = "oranges"   # update bar inside foo module object

模块2:

import foo           
print foo.bar        # if executed after a's "foo.bar" assignment, will print "oranges"

但是，如果你导入的是符号名而不是模块名，这就行不通了。

例如，如果我在模块a中这样做:

from foo import bar
bar = "oranges"

没有代码在一个外部将看到bar作为“橙子”，因为我的bar设置只是影响模块a中的名称“bar”，它没有“到达”foo模块对象并更新它的bar。