Python: перезагрузить компонент Y, импортированный с 'из X import Y'?

Question

В Python, как только я импортировал модуль X в сеансе интерпретатора, используя import X, и модуль изменился снаружи, я могу перезагрузить модуль с помощью reload(X). Затем изменения станут доступны в сеансе моего переводчика.

Мне интересно, возможно ли это также при импорте компонента Y из модуля X с использованием from X import Y.

Оператор reload Y не работает, поскольку Y не сам модуль, а только компонент (в данном случае класс) внутри модуля.

Можно ли вообще перезагрузить отдельные компоненты модуля, не выходя из сеанса интерпретатора (или не импортируя весь модуль)?

EDIT:

Для пояснения возникает вопрос об импорте класса или функции Y из модуля X и перезагрузке при изменении, а не модуля Y из пакета X.

Answer 1

Ответ

Из моих тестов. Отмеченный ответ, который предлагает простой reload(X), не работает.

Из того, что я могу сказать, правильный ответ таков:

# python3.x would require
# from importlib import reload
import X
reload( X )
from X import Y

---

Test

Мой тест был следующим (Python 2.6.5 + bpython 0.9.5.2)

X.py:

def Y():
    print "Test 1"

bpython:

>>> from X import Y
>>> print Y()
Test 1
>>> # Edit X.py to say "Test 2"
>>> print Y()
Test 1
>>> reload( X )  # doesn't work because X not imported yet
Traceback (most recent call last):
  File "<input>", line 1, in <module>
NameError: name 'X' is not defined
>>> import X
>>> print Y()
Test 1
>>> print X.Y()
Test 1
>>> reload( X ) # No effect on previous "from" statements
>>> print Y()
Test 1
>>> print X.Y() # first one that indicates refresh
Test 2
>>> from X import Y
>>> print Y()
Test 2 
>>> # Finally get what we were after

Answer 2

Если Y - это модуль (а X - пакет), то reload(Y) будет в порядке - в противном случае вы поймете, почему хорошие руководства по стилю Python (такие как мой работодатель) говорят никогда что-либо импортировать кроме модуля (это одна из многих веских причин - тем не менее, люди все еще продолжают импортировать функции и классы напрямую, независимо от того, насколько я объясняю, что не хорошая идея; - ).

Answer 3

from modulename import func

import sys
reload(sys.modules['modulename'])
from modulename import func

Answer 4

Во-первых, вам вообще не следует использовать перезагрузку, если вы можете избежать этого. Но давайте предположим, что у вас есть свои причины (т.е. отладка внутри IDLE).

Перезагрузка библиотеки не возвращает имена обратно в пространство имен модуля. Для этого просто переназначим переменные:

f = open('zoo.py', 'w')
f.write("snakes = ['viper','anaconda']\n")
f.close()

from zoo import snakes
print snakes

f = open('zoo.py', 'w')
f.write("snakes = ['black-adder','boa constrictor']\n")
f.close()

import zoo
reload(zoo)
snakes = zoo.snakes # the variable 'snakes' is now reloaded

print snakes

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

Answer 5

Если вы хотите сделать это:

from mymodule import myobject

Сделайте это вместо:

import mymodule
myobject=mymodule.myobject

Теперь вы можете использовать myobject таким же образом, как планировали (без утомительных и нечитаемых ссылок на мой модуль).

Если вы работаете в интерактивном режиме и хотите перезагрузить myobject из mymodule, теперь вы можете использовать:

reload(mymodule)
myobject=mymodule.myobject

Answer 6

при условии, что вы использовали from X import Y, у вас есть два варианта:

reload(sys.modules['X'])
reload(sys.modules[__name__]) # or explicitly name your module

или

Y=reload(sys.modules['X']).Y

несколько соображений:

A. если область импорта не распространяется на весь модуль (например, g: import в функции) - вы должны использовать вторую версию.

B. если Y импортирован в X из другого модуля (Z) - вы должны перезагрузить Z, затем перезагрузить X и затем перезагрузить свой модуль, даже перезагрузка всех ваших модулей (например, g: использование [ reload(mod) for mod in sys.modules.values() if type(mod) == type(sys) ]) может перезагрузить X перед перезагрузкой Z - и чем не обновить значение Y.

Answer 7

1. reload() модуль X,
2. reload() модуль импорта Y из X.

Обратите внимание, что перезагрузка не изменит уже созданные объекты, связанные в других пространствах имен (даже если вы следуете руководству по стилю от Алекса).

Answer 8

Если вы работаете в среде jupyter, и у вас уже есть from module import function, вы можете использовать магическую функцию, autoreload от

%load_ext autoreload
%autoreload
from module import function

Введение autoreload в IPython дано здесь .

Answer 9

Просто чтобы ответить на ответы AlexMartelli и Catskul , есть несколько действительно простых, но неприятных случаев, которые кажутся смешанными reload, по крайней мере, в Python 2.

Предположим, у меня есть следующее дерево исходных текстов:

- foo
  - __init__.py
  - bar.py

со следующим содержанием:

init.py:

from bar import Bar, Quux

bar.py:

print "Loading bar"

class Bar(object):
  @property
  def x(self):
     return 42

class Quux(Bar):
  object_count = 0
  def __init__(self):
     self.count = self.object_count
     self.__class__.object_count += 1
  @property
  def x(self):
     return super(Quux,self).x + 1
  def __repr__(self):
     return 'Quux[%d, x=%d]' % (self.count, self.x)

Это прекрасно работает без использования reload:

>>> from foo import Quux
Loading bar
>>> Quux()
Quux[0, x=43]
>>> Quux()
Quux[1, x=43]
>>> Quux()
Quux[2, x=43]

Но попробуйте перезагрузить компьютер, и он либо не даст эффекта, либо испортит вещи:

>>> import foo
Loading bar
>>> from foo import Quux
>>> Quux()
Quux[0, x=43]
>>> Quux()
Quux[1, x=43]
>>> reload(foo)
<module 'foo' from 'foo\__init__.pyc'>
>>> Quux()
Quux[2, x=43]
>>> from foo import Quux
>>> Quux()
Quux[3, x=43]
>>> reload(foo.bar)
Loading bar
<module 'foo.bar' from 'foo\bar.pyc'>
>>> Quux()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "foo\bar.py", line 17, in __repr__
    return 'Quux[%d, x=%d]' % (self.count, self.x)
  File "foo\bar.py", line 15, in x
    return super(Quux,self).x + 1
TypeError: super(type, obj): obj must be an instance or subtype of type
>>> Quux().count
5
>>> Quux().count
6
>>> Quux = foo.bar.Quux
>>> Quux()
Quux[0, x=43]
>>> foo.Quux()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "foo\bar.py", line 17, in __repr__
    return 'Quux[%d, x=%d]' % (self.count, self.x)
  File "foo\bar.py", line 15, in x
    return super(Quux,self).x + 1
TypeError: super(type, obj): obj must be an instance or subtype of type
>>> foo.Quux().count
8

Единственный способ обеспечить перезагрузку подмодуля bar - reload(foo.bar); единственный способ получить доступ к перезагруженному классу Quux - получить доступ к нему и загрузить его из перезагруженного подмодуля; но сам модуль foo продолжал удерживать исходный объект класса Quux, предположительно потому, что он использует from bar import Bar, Quux (вместо import bar, за которым следует Quux = bar.Quux); кроме того, класс Quux вышел из себя синхронно, что просто странно.