Python: recharger la composante Y importés "de X à l'importation Y'?

Si Y est un module (et X un paquet) reload(Y) va être bien -- dans le cas contraire, vous verrez pourquoi bien Python guides de style (comme mon employeur) dire à jamais importer quoi que ce soit sauf un module (c'est l'une des nombreuses bonnes raisons -- pourtant, les gens gardent encore l'importation de fonctions et de classes directement, n'importe comment beaucoup je précise que c'est pas une bonne idée;-).

Tout d'abord, vous ne devriez pas être à l'aide de recharger à tout, si vous pouvez l'éviter. Mais supposons que vous avez vos raisons (c'est à dire de débogage à l'intérieur d'INACTIVITÉ).

Le rechargement de la bibliothèque ne sera pas obtenir les noms de retour dans le module de l'espace de noms. Pour ce faire, il suffit de réaffecter les variables:

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

Vous pourriez faire un peu de d'autres façons. Vous pouvez automatiser le processus par la recherche à travers l'espace de noms local, et la réaffectation des rien de ce qui a été à partir du module en question, mais je pense que nous sommes assez mal.

Si vous voulez faire ceci:

from mymodule import myobject

Faire ceci à la place:

import mymodule
myobject=mymodule.myobject

Vous pouvez maintenant utiliser myobject de la même manière que vous avez été la planification (sans la fastidieuse illisible mymodule références partout).

Si vous travaillez de manière interactive et souhaitez recharger myobject de mymodule maintenant, vous pouvez à l'aide de:

reload(mymodule)
myobject=mymodule.myobject

1. reload() module X,
2. reload() module d'importation de Y de X.

Noter que le rechargement ne changera pas déjà créé des objets liés à d'autres espaces de noms (même si vous suivez guide de style de la part d'Alex).

Juste pour suivre AlexMartelli de l' et Catskul de l' réponses, il y a vraiment simple, mais méchant cas qui semblent confondre reload, au moins en Python 2.

Supposons que j'ai la suite de l'arborescence source:

- foo
  - __init__.py
  - bar.py

avec le contenu suivant:

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)

Cela fonctionne très bien sans l'aide de reload:

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

Mais essayez de recharger et elle n'a aucun effet ou corrompt les choses:

>>> 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

La seule façon que je pouvais assurer la bar sous-module a été rechargé était de reload(foo.bar); la seule façon que je accéder à la rechargée Quux classe est d'atteindre et saisir à partir de la reloaded sous-module; mais la foo module lui-même gardé maintenant sur l'origine Quux objet de classe, sans doute parce qu'il utilise from bar import Bar, Quux (plutôt que import bar suivie par Quux = bar.Quux); en outre, le Quux la classe a obtenu hors de synchronisation avec elle-même, ce qui est tout à fait étrange.