Python: перезагрузить компонент Y, импортированный с 'из X import Y'?
В Python, как только я импортировал модуль X в сеансе интерпретатора, используя import Xи модуль меняется снаружи, я могу перезагрузить модуль с reload(X), Затем изменения становятся доступными в моем сеансе переводчика.
Мне интересно, если это также возможно, когда я импортирую компонент Y из модуля X с помощью from X import Y,
Заявление reload Y не работает, так как Y не сам модуль, а только компонент (в данном случае класс) внутри модуля.
Можно ли вообще перезагрузить отдельные компоненты модуля, не выходя из сеанса переводчика (или не импортируя весь модуль)?
РЕДАКТИРОВАТЬ:
Для пояснения, речь идет об импорте класса или функции Y из модуля X и перезагрузке при изменении, а не модуля Y из пакета X.
8 ответов
Если Y является модулем (а X является пакетом) reload(Y) все будет хорошо - в противном случае вы поймете, почему в хороших руководствах по стилю Python (таких как мой работодатель) говорится, что никогда не импортируйте ничего, кроме модуля (это одна из многих веских причин), хотя люди все еще продолжают импортировать функции и классы напрямую, как бы я ни объяснял, это не очень хорошая идея;-).
Ответ
Из моих тестов. Отмеченный ответ, который предлагает простой reload(X), не работает.
Из того, что я могу сказать, правильный ответ:
import X
reload( X )
from X import Y
Тестовое задание
Мой тест был следующим (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
from modulename import func
import sys
reload(sys.modules['modulename'])
from modulename import func
Во-первых, вам вообще не следует использовать перезагрузку, если вы можете избежать этого. Но давайте предположим, что у вас есть свои причины (т.е. отладка внутри 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
Вы можете сделать это несколькими другими способами. Вы можете автоматизировать этот процесс, выполняя поиск в локальном пространстве имен и переназначая все, что было от рассматриваемого модуля, но я думаю, что мы достаточно злы.
If you're working in a jupyter environment, and you already have from module import function can use the magic function, autoreload by
%load_ext autoreload
%autoreload
from module import function
The introduction of the autoreload in IPython is given here.
Если вы хотите сделать это:
from mymodule import myobject
Сделайте это вместо этого:
import mymodule
myobject=mymodule.myobject
Теперь вы можете использовать myobject таким же образом, как планировали (без утомительных нечитаемых ссылок на mymodule повсюду).
Если вы работаете в интерактивном режиме и хотите перезагрузить myobject из mymodule, теперь вы можете использовать:
reload(mymodule)
myobject=mymodule.myobject
При условии, что вы использовали 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 и затем перезагрузить свой модуль, даже перезагрузив все свои модули (например, используя: [ reload(mod) for mod in sys.modules.values() if type(mod) == type(sys) ]) может перезагрузить X перед перезагрузкой Z - и затем не обновить значение Y.
reload()модульX,reload()модуль импортаYотX,
Обратите внимание, что перезагрузка не изменит уже созданные объекты, связанные в других пространствах имен (даже если вы следуете руководству по стилю от Алекса).
Просто чтобы проконтролировать ответы 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 класс вышел из себя, что просто странно.