Python的循環導入問題

循環導入的最好的解決方法是從架構上優化，即調整模塊和模塊成員變量的設計。一個好的原則是：可導出的成員變量，都不該該依賴於導入進來的成員變量。
可是在業務開發的過程當中，總會遇到經過架構層面解決不了的導入問題，這時候就只能經過語言層面來解決了。

目錄結構（下面的案例的目錄結構都是這樣的）：

root.py
/pack1
    __init__.py
    module_a.py
/pack2
    __init__.py
    module_b.py
module_c.py
module_d.py

循環導入例子

首先看一下什麼是循環導入和循環導入的緣由。
root.py

from pack1.module_a import class_a

module_a.py

print "start init module a"
from pack2.module_b import class_b
class class_a():
    def f(self):
        class_b
print "init module a"

module_b.py

print "start init module b"
from pack1.module_a import class_a
class class_b():
    def f(self):
        class_a
print "init module b"

會報錯：

start init module a
start init module b
Traceback (most recent call last):
  File "E:/my_demo/demo2016/bѭ������/s2/root.py", line 2, in <module>
    from pack1.module_a import class_a
  File "E:\my_demo\demo2016\bѭ������\s2\pack1\module_a.py", line 2, in <module>
    from pack2.module_b import class_b
  File "E:\my_demo\demo2016\bѭ������\s2\pack2\module_b.py", line 2, in <module>
    from pack1.module_a import class_a
ImportError: cannot import name class_a

代碼執行的流程：

1. 執行root.py的from pack1.module_a import class_a，發現須要導入模塊module_a
2. 一個空的字典會被建立，對應module_a的globals
3. module_a的代碼會被執行，當執行到from pack2.module_b import class_b時，發現須要導入模塊module_b
4. 一個空的字典會被建立，對應module_b的globals
5. module_b的代碼會被執行，當執行到from pack1.module_a import class_a時，發現須要導入模塊module_a，可是此時已經有module_a的globals了，因此直接訪問字典裏的class_a，可是因爲module_a的globals仍是空的，即裏面沒有class_a，因此拋出異常

參考文檔
因此根本緣由是：在導入的時候，module_b須要訪問module_a的變量class_a，可是class_a沒有初始化完成
因此解決方法有兩個：

1. 在導入的時候，讓module_b不要訪問module_a的變量，也就是方案一
2. class_a初始化完成後，才讓module_b訪問module_a的變量，也就是方案二和三

方案1、使用import ...代替 from...import...

root.py

import pack1.module_a

module_a.py

print "start init module a"
import pack2.module_b 
class class_a():
    def f(self):
        m_b.class_b
print "init module a"
if __name__ == '__main__':
    pass

module_b.py

print "start init module b"
import pack1.module_a 
class class_b():
    def f(self):
        pack1.module_a.class_a
print "init module b"

module_a和module_b都會被編譯，終端會輸出：

start init module a
start init module b
init module b
init module a

即首先編譯a，編譯過程當中發現須要編譯b，編譯b完成後，編譯a剩下的部分、

這個案例不使用from....import....，而使用import,這樣是能夠成功循環導入的，不過一個缺點是，每次訪問module的時候，都須要寫全路徑，例如pack1.module_a.class_a，很是繁瑣。
一個優化的方案是導入的時候，使用import....as... 例如：import pack1.module_a as m_a。可是很奇怪的是，在module_a中能夠這樣用，可是在module_b中不能夠，不然就會致使報錯。還有若是把roo.py改成import pack2.module_b,就會反過來，即module_b中能夠這樣用，可是在module_a中不能夠。因此準確點應該是在root.py導入的模塊中可使用，可是在其餘模塊不能使用。因此import....as...這個方案並很差。
注意，import...只能import到模塊，不能import模塊裏面的成員變量，例如import pack1.module_a.class_a 是不能夠的

這個方案的缺點就是訪問模塊裏面的成員變量太繁瑣

方案2、把導入放在後面

root.py

from pack1.module_a import class_a

module_a.py

print "start init module a"
#from pack2.module_b import class_b #放在這裏會報錯
class class_a():
    def f(self):
        # m_b.class_b
        pass

from pack2.module_b import class_b #放在這裏不會
class class_c():
    def f(self):
        class_b
print "init module a"

module_b.py

print "start init module b"
from pack1.module_a import class_a
class class_b():
    def f(self):
        class_a
print "init module b"

當存在相似的依賴關係：class_c依賴class_b依賴class_a，而後class_a和class_c在同一個模塊時，可使用這種方案。
把from pack2.module_b import class_b這句放在class_a後面，這樣在module_b中訪問module_a.class_a是成功的，由於class_a的定義代碼已經執行完成，並被添加到module_a的globals中。

方案3、把導入語句放在語句塊中

root.py

from pack1.module_a import func_a

print 'root start run func a'
func_a()
print 'root end run func a'

module_a.py

print "start init module a"

def func_a():
    from pack2.module_b import func_b
    func_b()
    print 'run func a'
print "init module a"

module_b.py

print "start init module b"

def func_b():
    from pack1.module_a import func_a
    print 'run func b'

print "init module b"

輸出：

start init module a
init module a
root start run func a
start init module b
init module b
run func b
run func a
root end run func a

在須要使用func_b的時候，才進行導入操做，這樣在執行module_b的時候，module_a已經初始化完成，module_a的globals已經有func_a了，因此導入不會報錯。

查看已經導入的module狀況

import sys
from pack1.module_a import func_a
print sys.modules  
# {'pack1': <module 'pack1' from 'E:\my_demo\demo2016\bѭ������\s4\pack1\__init__.pyc'>,}
print sys.modules['pack1.module_a'].__dict__
# {'func_a': <function func_a at 0x0254FB30>, '__doc__': None}
sys.modules['pack1.module_a'].func_a_tmp=sys.modules['pack1.module_a'].func_a

經過sys.modules能夠訪問全部當前已導入的模塊。
modules是一個字典，key是模塊的路徑，例如pack1.module_a,value是一個模塊對象
模塊對象中，屬性名是模塊中全局變量的名字，即sys.modules['pack1.module_a'].__dict__等於module_a裏面的globals()

因此，當在module_b中執行from pack1.module_a import class_a時，至關於執行代碼：

import sys
if 'pack1.module_a' in sys.modules:
    if hasattr(sys.modules['pack1.module_a'],"class_a"):
        sys.modules['pack2.module_b'].class_a=sys.modules['pack1.module_a'].class_a
    else:
        raise Exception(u"循環導入異常")
else:
    #執行導入pack1.module_a的操做，也就是初始化一個module對象，而後令sys.modules['pack1.module_a']=這個對象

因此解決循環導入的問題，就至關於使上面的代碼不會執行到raise Exception(u"循環導入異常")這一句，方案一和方案二都是經過這種方法解決的。

未經容許，請不要轉載