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()
当前回答
可读性
除了启动性能外，本地化import语句还需要考虑可读性。例如，在我目前的第一个python项目中使用python行号1283到1296:
listdata.append(['tk font version', font_version])
listdata.append(['Gtk version', str(Gtk.get_major_version())+"."+
str(Gtk.get_minor_version())+"."+
str(Gtk.get_micro_version())])
import xml.etree.ElementTree as ET
xmltree = ET.parse('/usr/share/gnome/gnome-version.xml')
xmlroot = xmltree.getroot()
result = []
for child in xmlroot:
result.append(child.text)
listdata.append(['Gnome version', result[0]+"."+result[1]+"."+
result[2]+" "+result[3]])
如果import语句在文件的顶部，我将不得不向上滚动很长一段距离，或按Home键，以找出ET是什么。然后我将不得不返回到第1283行继续阅读代码。
实际上，即使import语句像许多人那样位于函数(或类)的顶部，也需要向上和向下分页。
很少会显示Gnome版本号，因此在文件顶部导入会引入不必要的启动延迟。
其他回答
当函数被调用0次或1次时，第一种变体确实比第二种更有效。然而，对于第二次和后续调用，“导入每个调用”方法实际上效率较低。请参阅此链接，了解一种通过“惰性导入”将两种方法的优点结合起来的惰性加载技术。
但除了效率之外，还有其他原因可以解释为什么你会更喜欢其中一种。一种方法是让阅读代码的人更清楚地了解这个模块所具有的依赖关系。它们也有非常不同的失败特征——如果没有“datetime”模块，第一个将在加载时失败，而第二个直到方法被调用才会失败。
补充说明:在IronPython中，导入可能比在CPython中要昂贵一些，因为代码基本上是在导入时被编译的。
我想提一下我的一个用例，与@John Millikin和@ v.k.提到的用例非常相似:
可选的进口
我使用Jupyter Notebook进行数据分析，我使用相同的IPython Notebook作为所有分析的模板。在某些情况下，我需要导入Tensorflow来做一些快速的模型运行，但有时我工作的地方，Tensorflow没有设置/导入很慢。在这些情况下，我将依赖于tensorflow的操作封装在一个helper函数中，在该函数中导入tensorflow，并将其绑定到一个按钮。
这样，我就可以“重新启动并运行全部”，而不必等待导入，也不必在导入失败时恢复其余的单元格。
这是一个只有程序员才能决定的权衡。
Case 1在需要时才导入datetime模块(并进行任何可能需要的初始化)，从而节省了一些内存和启动时间。请注意，“仅在被调用时”导入也意味着“每次被调用时”导入，因此第一次调用之后的每个调用仍然会产生执行导入的额外开销。
情况2通过提前导入datetime来节省一些执行时间和延迟，这样在调用not_often_called()时就会更快地返回，而且也不会在每次调用时都产生导入的开销。
除了效率，如果import语句是…前面。将它们隐藏在代码中会使查找某个组件所依赖的模块变得更加困难。
就我个人而言，我通常遵循PEP，除了单元测试之类的东西，我不希望总是加载这些东西，因为我知道除了测试代码之外，它们不会被使用。
我很惊讶没有看到重复负载检查的实际成本数字，尽管有很多很好的解释。
如果你在顶部导入，不管发生什么，你都要加载命中。这非常小，但通常是毫秒级，而不是纳秒级。
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
为了完成老谋子的回答和最初的问题:
当我们不得不处理循环依赖关系时，我们可以做一些“技巧”。假设我们正在处理模块a.py和b.py，它们分别包含x()和b.y()。然后:
我们可以移动模块底部的from导入之一。 我们可以将其中一个from导入移动到实际需要导入的函数或方法中(这并不总是可行的，因为您可能从多个地方使用它)。 我们可以把其中一个import改成import，就像import a
总结一下。如果您没有处理循环依赖关系，也没有使用某种技巧来避免它们，那么最好将所有导入放在顶部，因为原因已经在这个问题的其他答案中解释过了。请在做这些“技巧”时附上评论，这总是受欢迎的!：）
