Python'da, kullanarak bir yorumlayıcı oturumuna X modülünü içe import Xaktardığımda ve modül dışarıdan değiştiğinde, modülü ile yeniden yükleyebilirim reload(X). Değişiklikler daha sonra tercüman oturumumda kullanılabilir hale gelir.

Bunu kullanarak X modülünden bir Y bileşenini içe aktardığımda bunun da mümkün olup olmadığını merak ediyorum from X import Y.

reload YY bir modülün kendisi olmadığından, sadece bir modülün içindeki bir bileşen (bu durumda bir sınıf) olduğu için ifade çalışmaz.

Yorumlayıcı oturumundan çıkmadan (veya tüm modülü içe aktarmadan) bir modülün tek tek bileşenlerini yeniden yüklemek mümkün müdür?

DÜZENLE:

Açıklık getirmek gerekirse, soru, X modülünden bir Y sınıfını veya işlevini içe aktarmak ve bir X paketinden bir Y modülünü değil, bir değişikliği yeniden yüklemekle ilgilidir.

Y bir modül ise (ve X bir paket) iyi reload(Y)olacaktır - aksi takdirde, iyi Python stil kılavuzlarının (işverenim gibi) neden bir modül dışında hiçbir şeyi içe aktarmamayı söylediğini göreceksiniz (bu, birçok harika nedenden biridir) - yine de insanlar, bunun iyi bir fikir olmadığını ne kadar açıklasam da, fonksiyonları ve sınıfları doğrudan aktarmaya devam ediyor ;-).

Cevap

Testlerimden basit bir öneren işaretli cevap reload(X)işe yaramıyor.

Doğru cevabı söyleyebileceğim kadarıyla:

from importlib import reload # python 2.7 does not require this
import X
reload( X )
from X import Y

Ölçek

Testim şuydu (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

Öncelikle, önleyebiliyorsanız, yeniden yüklemeyi hiç kullanmamalısınız. Ama nedenleriniz olduğunu varsayalım (yani, IDLE içinde hata ayıklama).

Kitaplığı yeniden yüklemek, adları modülün ad alanına geri getirmez. Bunu yapmak için, sadece değişkenleri yeniden atayın:

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

Bunu birkaç farklı şekilde yapabilirsiniz. Yerel ad alanını arayarak ve söz konusu modüldeki herhangi bir şeyi yeniden atayarak süreci otomatikleştirebilirsiniz, ancak bence yeterince kötü davranıyoruz.

Bunu yapmak istiyorsanız:

from mymodule import myobject

Bunun yerine şunu yapın:

import mymodule
myobject=mymodule.myobject

Artık myobject'i planladığınız gibi kullanabilirsiniz (her yerde yorucu okunamayan mymodül referansları olmadan).

Etkileşimli olarak çalışıyorsanız ve nesnemi mymodule'den yeniden yüklemek istiyorsanız, şimdi şunları kullanabilirsiniz:

reload(mymodule)
myobject=mymodule.myobject

Kullandığınızı varsayarsak from X import Y, iki seçeneğiniz vardır:

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

veya

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

birkaç önemli nokta:

A. içe aktarma kapsamı modül çapında değilse (e, g: bir işlevde içe aktarma) - ikinci sürümü kullanmalısınız.

B. Y başka bir modülden (Z) X'e aktarılırsa - X'i yeniden yüklemek yerine Z'yi yeniden yüklemelisiniz ve modülünüzü yeniden yüklemek yerine, tüm modüllerinizi yeniden yüklemek (e, g: kullanarak [ reload(mod) for mod in sys.modules.values() if type(mod) == type(sys) ]) bile Z'yi yeniden yüklemeden önce X'i yeniden yükleyebilir - ve daha sonra Y'nin değerini yenilemeyin.

1. reload()modül X,
2. reload()ithal modülü Ydan X.

Yeniden yüklemenin, diğer ad alanlarına bağlı önceden oluşturulmuş nesneleri değiştirmeyeceğini unutmayın (Alex'ten stil kılavuzunu takip etseniz bile).

Jüpiter bir ortamda çalışıyorsanız ve zaten sahipseniz from module import functionsihirli işlevi şu şekilde kullanabilirsiniz autoreload:

%load_ext autoreload
%autoreload
from module import function

autoreloadIPython'daki giriş burada verilmiştir .

Sadece AlexMartelli'nin ve Catskul'un cevaplarını takip etmek için reload, en azından Python 2'de kafa karıştırıcı görünen gerçekten basit ama kötü vakalar var .

Aşağıdaki kaynak ağacına sahip olduğumu varsayalım:

- foo
  - __init__.py
  - bar.py

aşağıdaki içeriğe sahip:

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)

Bu, kullanmadan gayet iyi çalışıyor reload:

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

Ancak yeniden yüklemeyi deneyin ve bunun ya bir etkisi olmaz ya da bazı şeyleri bozar:

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

Alt barmodülün yeniden yüklendiğinden emin olabilmemin tek yolu reload(foo.bar); Yeniden yüklenen Quuxsınıfa erişmemin tek yolu , onu yeniden yüklenen alt modülden almak ve almaktır; ancak foomodülün kendisi orijinal Quuxsınıf nesnesini tutmaya devam etti , muhtemelen kullandığı için from bar import Bar, Quux( import baronu takip etmek yerine Quux = bar.Quux); dahası Quuxsınıf kendisiyle uyumsuz hale geldi, bu çok tuhaf.