Как повторно импортировать обновленный пакет в Python Interpreter?

Ответ 1

"Перезагрузка больше не является функцией в Python 3. Вместо этого используйте imp.reload(), скопированную из комментариев

Используйте встроенную функцию reload:

https://docs.python.org/2/library/functions.html#reload

Когда выполняется reload(module):

• Код модулей Python перекомпилируется и код модуля обновляется, определяя новый набор объектов, привязанных к именам в словаре модулей. Функция init модулей расширения не вызывается второй раз.
• Как и все другие объекты на Python, старые объекты восстанавливаются только после того, как их отсчеты ссылок упадут до нуля.
• Имена в пространстве имен модулей обновляются, чтобы указывать на любые новые или измененные объекты.
• Другие ссылки на старые объекты (например, имена, внешние по отношению к модулю) не восстанавливаются, чтобы ссылаться на новые объекты и должны обновляться в каждом пространстве имен, где они возникают, если это необходимо.

Пример:

# Make a simple function that prints "version 1"
shell1$ echo 'def x(): print "version 1"' > mymodule.py

# Run the module
shell2$ python
>>> import mymodule
>>> mymodule.x()
version 1

# Change mymodule to print "version 2" (without exiting the python REPL)
shell2$ echo 'def x(): print "version 2"' > mymodule.py

# Back in that same python session
>>> reload(mymodule)
<module 'mymodule' from 'mymodule.pyc'>
>>> mymodule.x()
version 2

Ответ 2

Все ответы выше о reload() или imp.reload() устарели.

reload() больше не является встроенной функцией в python 3 и imp.reload() отмечен устаревшим (см. справку (imp)).

Лучше использовать importlib.reload() вместо этого.

Ответ 3

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

Да, просто говоря import снова дает вам существующую копию модуля из sys.modules.

Вы можете сказать reload(module) обновить sys.modules и получить новую копию этого единственного модуля, но если какие-либо другие модули имеют ссылку на исходный модуль или любой объект из исходного модуля, они сохранят свои старые ссылки и очень запутанные вещи произойдут.

Итак, если у вас есть модуль a, который зависит от изменений модуля b и b, вам необходимо перезагрузить b, а затем перезагрузить a. Если у вас есть два модуля, которые зависят друг от друга, что чрезвычайно распространено, когда эти модули являются частью одного и того же пакета, вы не можете перезагрузить их оба: если вы перезагрузите p.a, он получит ссылку на старый p.b и наоборот. Единственный способ сделать это - выгрузить их обоих сразу, удалив их элементы из sys.modules, прежде чем импортировать их снова. Это нехорошо и имеет некоторые практические ошибки, связанные с тем, что записи модулей являются None как маркер с несоответствующим значением.

И если у вас есть модуль, который передает ссылки на его объекты на системные модули - например, он регистрирует кодек или добавляет обработчик предупреждений - вы застряли; вы не можете перезагрузить системный модуль, не запутав остальную среду Python.

В заключение: для всех, кроме простейшего случая, когда один автономный модуль загружается одним автономным script, reload() очень сложно получить право; если, как вы подразумеваете, вы используете "пакет", вам, вероятно, будет лучше продолжать цикл перевода.

Ответ 4

В Python 3 поведение меняется.

>>> import my_stuff

... сделайте что-нибудь с my_stuff, а затем:

>>>> import imp
>>>> imp.reload(my_stuff)

и вы получите новый, перезагруженный my_stuff.

Ответ 5

Независимо от того, сколько раз вы импортируете модуль, вы получите ту же самую копию модуля из sys.modules, которая была загружена сначала import mymodule

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

Использование встроенной функции:

Для Python 2.x - используйте встроенную reload(mymodule) функцию.

Для Python 3.x - используйте imp.reload(mymodule).

Для Python 3.4 - в Python 3.4 imp устарел в пользу importlib т.е. importlib.reload(mymodule)

Немного оговорок:

• Обычно не очень полезно перезагружать встроенные или динамически загруженных модулей. Перезагрузка sys, __main__, builtins и другой ключ модули не рекомендуется.
• Во многих случаях модули расширения не предназначенные для инициализации более одного раза и могут способы перезагрузки. Если модуль импортирует объекты из другого модуля используя from... import..., вызывающий reload() для другого модуля не переопределять объекты, импортированные из него - один из способов - это повторите выполнение оператора from, другой - использовать import и квалифицированный имена (module.name).
• Если модуль создает экземпляры класс, перезагрузка модуля, который определяет класс, не влияет определения методов экземпляров - они продолжают использовать старое определение класса. То же самое верно для производных классов.

Внешние пакеты:

reimport - Reimport в настоящее время поддерживает Python с 2.4 по 2.7.

xreload - Это работает, выполняя модуль в пространстве имен царапин, а затем исправления классов, методов и функций. Это позволяет избежать необходимо исправлять экземпляры. Новые объекты копируются в целевую Пространство имен.

livecoding - Перезагрузка кода позволяет запущенному приложению изменять свое поведение в ответ на изменения в скриптах Python, которые он использует. Когда библиотека обнаруживает, что Python script был изменен, он перезагружает этот script и заменяет объекты, которые он ранее сделал доступными для использования с новыми перезагруженными версиями. В качестве инструмента он позволяет программисту избежать прерывания рабочего процесса и соответствующей потери фокуса. Это позволяет им оставаться в состоянии потока. Если раньше им потребовалось перезапустить приложение для внесения измененного кода, эти изменения могут быть применены немедленно.

Ответ 6

В основном reload, как в allyourcode asnwer. Но это не изменит базовый код уже созданного объекта или ссылочных функций. Продолжая свой ответ:

#Make a simple function that prints "version 1"
shell1$ echo 'def x(): print "version 1"' > mymodule.py

# Run the module
shell2$ python
>>> import mymodule
>>> mymodule.x()
version 1
>>> x = mymodule.x
>>> x()
version 1
>>> x is mymodule.x
True


# Change mymodule to print "version 2" (without exiting the python REPL)
shell2$ echo 'def x(): print "version 2"' > mymodule.py

# Back in that same python session
>>> reload(mymodule)
<module 'mymodule' from 'mymodule.pyc'>
>>> mymodule.x()
version 2
>>> x()
version 1
>>> x is mymodule.x
False

Ответ 7

Короткий ответ:

попробуйте использовать reimport: полная функция перезагрузки для Python.

Дольше ответ:

Похоже, что этот вопрос был задан/до того, как был выпущен reimport, который выписывает себя как "полнофункциональная перезагрузка для Python":

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

Reimport в настоящее время поддерживает Python с 2.4 по 2.6.

По самой своей природе это не вполне разрешимая проблема. Цель этого модуля - сделать работу с наиболее распространенными типами обновлений. Он также позволяет отдельным модулям и пакетам помогать в этом процессе. Более подробное описание того, что происходит, находится на странице обзора.

Примечание. Хотя reimport явно поддерживает Python с 2.4 по 2.6, я пробовал его на 2,7, и, похоже, он работает нормально.

Ответ 8

Не уверен, что это все ожидаемые вещи, но вы можете сделать так:

>>> del mymodule
>>> import mymodule

Ответ 9

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

http://pyunit.sourceforge.net/notes/reloading.html

Путь решил решить, чтобы отслеживать зависимые модули, переопределяя __import__, а затем удалять каждый из них из sys.modules и повторно импортировать. Возможно, они, возможно, просто перезагрузили их.

Ответ 10

import sys
del sys.modules['module_name']

Ответ 11

Ответ стрелочки работал у меня (python 3.4.3).

import sys
del sys.modules['module_name']

Вот решение более низкого уровня:

exec(open("MyClass.py").read(), globals())