PEP 8规定:
导入总是放在文件的顶部，就在任何模块注释和文档字符串之后，在模块全局变量和常量之前。
然而，如果我导入的类/方法/函数只在很少的情况下使用，那么在需要时进行导入肯定会更有效吗?
这不是:
class SomeClass(object):
def not_often_called(self)
from datetime import datetime
self.datetime = datetime.now()
比这更有效率?
from datetime import datetime
class SomeClass(object):
def not_often_called(self)
self.datetime = datetime.now()
当前回答
我很惊讶没有看到重复负载检查的实际成本数字，尽管有很多很好的解释。
如果你在顶部导入，不管发生什么，你都要加载命中。这非常小，但通常是毫秒级，而不是纳秒级。
If you import within a function(s), then you only take the hit for loading if and when one of those functions is first called. As many have pointed out, if that doesn't happen at all, you save the load time. But if the function(s) get called a lot, you take a repeated though much smaller hit (for checking that it has been loaded; not for actually re-loading). On the other hand, as @aaronasterling pointed out you also save a little because importing within a function lets the function use slightly-faster local variable lookups to identify the name later (http://stackoverflow.com/questions/477096/python-import-coding-style/4789963#4789963).
下面是一个简单测试的结果，该测试从函数内部导入了一些内容。报告的时间(在2.3 GHz Intel Core i7上的Python 2.7.14中)如下所示(第2个调用比后面的调用多似乎是一致的，尽管我不知道为什么)。
0 foo: 14429.0924 µs
1 foo: 63.8962 µs
2 foo: 10.0136 µs
3 foo: 7.1526 µs
4 foo: 7.8678 µs
0 bar: 9.0599 µs
1 bar: 6.9141 µs
2 bar: 7.1526 µs
3 bar: 7.8678 µs
4 bar: 7.1526 µs
代码:
from __future__ import print_function
from time import time
def foo():
import collections
import re
import string
import math
import subprocess
return
def bar():
import collections
import re
import string
import math
import subprocess
return
t0 = time()
for i in xrange(5):
foo()
t1 = time()
print(" %2d foo: %12.4f \xC2\xB5s" % (i, (t1-t0)*1E6))
t0 = t1
for i in xrange(5):
bar()
t1 = time()
print(" %2d bar: %12.4f \xC2\xB5s" % (i, (t1-t0)*1E6))
t0 = t1
其他回答
我采用了将所有导入放在使用它们的函数中，而不是放在模块的顶部的做法。
这样做的好处是能够更可靠地进行重构。当我将一个函数从一个模块移动到另一个模块时，我知道该函数将继续工作，并且保留所有遗留的测试。如果我将导入放在模块的顶部，当我移动一个函数时，我发现我最终要花费大量时间来完成新模块的导入并使其最小化。重构IDE可能会让这一点变得无关紧要。
正如在其他地方提到的那样，有一个速度惩罚。我在我的应用程序中测量了这一点，发现它对我的目的来说是微不足道的。
不需要搜索(例如grep)就能看到所有模块依赖关系也是很好的。然而，我关心模块依赖关系的原因通常是因为我正在安装、重构或移动由多个文件组成的整个系统，而不仅仅是单个模块。在这种情况下，我无论如何都要执行全局搜索，以确保具有系统级依赖关系。因此，我还没有找到全局导入来帮助我在实践中理解一个系统。
我通常把sys的导入放在if __name__=='__main__'检查中，然后将参数(如sys.argv[1:])传递给main()函数。这允许我在sys未被导入的上下文中使用main。
这就像许多其他优化一样——你牺牲了一些可读性来换取速度。正如John提到的，如果您已经完成了分析作业，并且发现这是一个非常有用的更改，并且您需要额外的速度，那么就去做吧。最好把所有其他的导入都放在一起:
from foo import bar
from baz import qux
# Note: datetime is imported in SomeClass below
我不太担心预先加载模块的效率。模块占用的内存不会很大(假设它足够模块化)，启动成本可以忽略不计。
在大多数情况下，您希望在源文件的顶部加载模块。对于阅读代码的人来说，它可以更容易地区分哪个函数或对象来自哪个模块。
在代码的其他地方导入模块的一个很好的理由是，如果它在调试语句中使用。
例如:
do_something_with_x(x)
我可以用:
from pprint import pprint
pprint(x)
do_something_with_x(x)
当然，在代码的其他地方导入模块的另一个原因是，如果您需要动态导入它们。这是因为你几乎没有任何选择。
我不太担心预先加载模块的效率。模块占用的内存不会很大(假设它足够模块化)，启动成本可以忽略不计。
有趣的是，到目前为止，没有一个回答提到并行处理，当序列化的函数代码被推到其他核心时，可能需要将导入放在函数中，例如在ipyparallel的情况下。
下面是一个示例，其中所有导入都位于最顶部(这是我唯一一次需要这样做)。我希望能够在Un*x和Windows上终止子进程。
import os
# ...
try:
kill = os.kill # will raise AttributeError on Windows
from signal import SIGTERM
def terminate(process):
kill(process.pid, SIGTERM)
except (AttributeError, ImportError):
try:
from win32api import TerminateProcess # use win32api if available
def terminate(process):
TerminateProcess(int(process._handle), -1)
except ImportError:
def terminate(process):
raise NotImplementedError # define a dummy function
(回顾:约翰·米利金所说。)
