Это действительно имеет несколько недостатков.

Тестирование

На всякий случай Вы хотите протестировать свой модуль посредством модификации во время выполнения, это может сделать это более трудным. Вместо того, чтобы делать

import mymodule
mymodule.othermodule = module_stub

необходимо будет сделать

import othermodule
othermodule.foo = foo_stub

, Это означает, что необходимо будет исправить othermodule глобально, в противоположность просто изменению, на что указывает ссылка в mymodule.

Зависимость, Отслеживающая

, Это делает это неочевидным, от каких модулей Ваш модуль зависит. Это является особенно раздражающим, если Вы пользуетесь многими сторонними библиотеками или реорганизовываете код.

я должен был поддержать некоторый унаследованный код, который использовал импорт, встроенный повсеместно, он сделал код чрезвычайно трудным осуществить рефакторинг или повторно упаковать.

Примечания По Производительности

из-за пути модули кэшей Python, нет хита производительности. На самом деле, так как модуль находится в локальном пространстве имен, существует небольшой выигрыш в производительности к импорту модулей в функции.

Главный Импорт

import random

def f():
    L = []
    for i in xrange(1000):
        L.append(random.random())

for i in xrange(10000):
    f()


$ time python test.py 

real   0m1.569s
user   0m1.560s
sys    0m0.010s

Импорт в Теле функции

def f():
    import random
    L = []
    for i in xrange(1000):
        L.append(random.random())

for i in xrange(10000):
    f()

$ time python test2.py

real    0m1.385s
user    0m1.380s
sys     0m0.000s

Несколько проблем с этим подходом:

• Это не сразу очевидно при открытии файла, от каких модулей это зависит.
• Это перепутает программы, которые должны проанализировать зависимости, такой как py2exe, py2app и т.д.
• Что относительно модулей, которые Вы используете во многих функциях? Вы или закончите с большим избыточным импортом, или у Вас должны будут быть некоторые наверху файла и некоторых внутренних функций.

, Таким образом... предпочтительный путь состоит в том, чтобы поместить весь импорт наверху файла. Я нашел, что, если бы мой импорт становится трудным отслеживать, это обычно означает, что у меня есть слишком много кода, что я был бы более обеспеченным разделением его в два или больше файла.

Некоторые ситуации, где я имею найденный импорт в функциях, чтобы быть полезным:

• Для контакта с круговыми зависимостями (если Вы действительно действительно не можете избежать их)
• Платформа определенный код

Также: помещение импорта в каждой функции на самом деле не заметно медленнее, чем наверху файла. В первый раз, когда каждый модуль загружается, он помещается в sys.modules, и каждый последующий импорт стоит только времени для поиска модуля, который довольно быстр (он не перезагружается).

Другая полезная вещь отметить состоит в том, что from module import * синтаксис в функции был удален в Python 3.0.

существует краткое упоминание о нем под "Удаленным Синтаксисом" здесь:

http://docs.python.org/3.0/whatsnew/3.0.html

Я предложил бы, чтобы Вы старались избегать from foo import bar импорт. Я только использую их в пакетах, где разделение на модули является деталью реализации и не будет многих из них так или иначе.

Во всех других местах, куда Вы импортируете пакет, просто использование import foo и затем ссылаетесь на него полным именем foo.bar. Таким образом, можно всегда говорить, куда определенный элемент прибывает из и не должен вести список импортированных элементов (в действительности, это всегда устареет и не импортировать больше используемые элементы).

, Если foo действительно длинное имя, можно упростить его с import foo as f и затем записать f.bar. Это все еще намного более удобно и явно, чем поддержание весь from импорт.

Люди объяснили очень хорошо, почему избежать встроенного импорта, но не действительно альтернативных рабочих процессов для обращения к причинам, Вы хотите их во-первых.

мне нелегко вычищать вверх и вниз по исходным файлам для выяснения то, что импорт модуля доступен и т.д

Для проверки на неиспользованный импорт, который я использую pylint. Это делает статичный (выход) - анализ кода Python и один из (много), вещами, на которые это проверяет, является неиспользованный импорт. Например, следующий сценарий..

import urllib
import urllib2

urllib.urlopen("http://stackoverflow.com")

.. сгенерировал бы следующее сообщение:

example.py:2 [W0611] Unused import urllib2

Что касается проверки доступного импорта, я обычно полагаюсь на (довольно упрощенное) завершение TextMate - когда Вы нажимаете Esc, это завершает текущее слово с другими в документе. Если я сделал import urllib, urll[Esc] расширится до urllib, если не я перейду к запуску файла и добавлю импорт.

С точки зрения производительности Вы видите это: операторы импорта Python должны всегда быть наверху модуля?

В целом, я только использую локальный импорт для повреждения циклов зависимости.

Вы могли бы хотеть смотреть на оператор Import наверху в Python Wiki. Короче говоря: если модуль был уже загружен (взгляд sys.modules), Ваш код будет работать медленнее. Если Ваш модуль еще не был загружен, и будет foo только загружаться при необходимости, который может быть нулевыми временами, то общая производительность будет лучше.

Я полагаю, что это - рекомендуемый подход в некоторых случаях/сценариях. Например, в ленивой загрузке Google App Engine большие модули рекомендуются, так как она минимизирует стоимость прогрева инстанцирования нового Python VMs/interpreters. Взгляните на Инженер Google презентация, описывающая это. Однако имейте в виду, что это не делает средний, Вы должны ленивая загрузка все Ваши модули.