У Python, як тільки я імпортував модуль X у сеансі інтерпретатора import X, і модуль змінився зовні, я можу перезавантажити модуль reload(X). Потім зміни стануть доступними під час мого сеансу перекладача.

Мені цікаво, чи можливо це також, коли я імпортую компонент Y із модуля X за допомогою from X import Y.

Оператор reload Yне працює, оскільки Y не є самим модулем, а лише компонентом (в даному випадку класом) всередині модуля.

Чи можливо взагалі перезавантажити окремі компоненти модуля, не виходячи з сеансу інтерпретатора (або імпортуючи весь модуль)?

РЕДАГУВАТИ:

Для уточнення питання стосується імпорту класу або функції Y з модуля X та перезавантаження змін, а не модуля Y із пакету X.

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

Відповідь

З моїх тестів позначена відповідь, яка передбачає просту reload(X), не працює.

З того, що я можу сказати, правильна відповідь:

from importlib import reload # python 2.7 does not require this
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 importlib, sys
importlib.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

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

Якщо ви хочете зробити це:

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

кілька міркувань:

А. якщо область імпорту не є загальномодульною (e, g: import у функції) - ви повинні використовувати другу версію.

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

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

Зверніть увагу, що перезавантаження не змінить вже створених об’єктів, прив’язаних до інших просторів імен (навіть якщо ви будете слідувати керівництву стилю від Alex).

Якщо ви працюєте в середовищі jupyter, і ви вже from module import functionможете використовувати функцію магії, з autoreloadдопомогою

%load_ext autoreload
%autoreload
from module import function

Введення autoreloadв IPython подано тут .

Щоб продовжити відповіді Алекса Мартеллі та Кацкула , є кілька справді простих, але неприємних випадків, які, здається, бентежать 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клас вийшов з синхронізації із самим собою, що просто дивно.