python中的import機制

1. 標準 import

       Python 中所有加載到內存的模塊都放在 sys.modules 。當 import 一個模塊時首先會在這個列表中查找是否已經加載了此模塊，如果加載了則只是將模塊的名字加入到正在調用 import 的模塊的 Local 名字空間中。如果沒有加載則從 sys.path 目錄中按照模塊名稱查找模塊文件，模塊可以是py、pyc、pyd，找到後將模塊載入內存，並加到 sys.modules 中，並將名稱導入到當前的 Local 名字空間。

       一個模塊不會重複載入。多個不同的模塊都可以用 import 引入同一個模塊到自己的 Local 名字空間，其實背後的 PyModuleObject 對象只有一個。說一個容易忽略的問題：import 只能導入模塊，不能導入模塊中的對象（類、函數、變量等）。例如：模塊 A（A.py）中有個函數 getName，另一個模塊不能通過 import A.getName 將 getName導入到本模塊，只能用 from A import getName。

2. 嵌套 import

      1）順序嵌套

       例如：本模塊導入 A 模塊（import A），A 中又 import B，B 模塊又可以 import 其他模塊……

       這中嵌套比較容易理解，需要注意的一點就是各個模塊的 Local 名字空間是獨立的。對於上面的例子，本模塊 import A 之後本模塊只能訪問模塊 A，不能訪問模塊 B 及其他模塊。雖然模塊 B 已經加載到內存了，如果訪問還要再明確的在本模塊中 import B。

       2）循環嵌套

        例如：文件[ A.py ]

                   from B import D

                   class C:pass

                   文件[ B.py ]

                   from A import C

                   class D:pass

        爲什麼執行 A 的時候不能加載 D 呢？

        如果將 A.py 改爲：import B 就可以了。

        這是怎麼回事呢？

        RobertChen：這跟Python內部 import 的機制是有關的，具體到 from B import D，Python 內部會分成幾個步驟：

        （1）在 sys.modules 中查找符號 “B”

        （2）如果符號 B 存在，則獲得符號 B 對應的 module 對象。

                從 <modult B> 的 __dict__ 中獲得符號 “D” 對應的對象，如果 “D” 不存在，則拋出異常。

        （3）如果符號 B 不存在，則創建一個新的 module 對象 <module B>，注意，此時，module 對象的 __dict__ 爲空。

                執行 B.py 中的表達式，填充 <module B> 的 __dict__。

                從  <module B> 的 __dict__ 中獲得 “D” 對應的對象，如果 “D” 不存在，則拋出異常。

          所以這個例子的執行順序如下：

          1、執行 A.py 中的 from B import D 由於是執行的 python A.py，所以在 sys.modules 中並沒有 <module B> 存在， 首先爲 B.py 創建一個 module 對象 (<module B>) ， 注意，這時創建的這個 module 對象是空的，裏邊啥也沒有， 在 Python 內部創建了這個 module 對象之後，就會解析執行 B.py，其目的是填充 <module B> 這個 __dict__。 

          2、執行 B.py中的from A import C 在執行B.py的過程中，會碰到這一句， 首先檢查sys.modules這個module緩存中是否已經存在<module A>了， 由於這時緩存還沒有緩存<module A>， 所以類似的，Python內部會爲A.py創建一個module對象(<module A>)， 然後，同樣地，執行A.py中的語句

          3、再次執行A.py中的from B import D 這時，由於在第1步時，創建的<module B>對象已經緩存在了sys.modules中， 所以直接就得到了<module B>， 但是，注意，從整個過程來看，我們知道，這時<module B>還是一個空的對象，裏面啥也沒有， 所以從這個module中獲得符號"D"的操作就會拋出異常。 如果這裏只是import B，由於"B"這個符號在sys.modules中已經存在，所以是不會拋出異常的。
ZQ:圖解

啄木鳥社區《import 迷宮》：http://wiki.woodpecker.org.cn/moin/MiscItems/2008-11-25

3. 包 import
       只要一個文件夾下面有個 __init__.py 文件，那麼這個文件夾就可以看做是一個包。包導入的過程和模塊的基本一致，只是導入包的時候會執行此包目錄下的 __init__.py 而不是模塊裏面的語句了。另外，如果只是單純的導入包，而包的 __init__.py 中又沒有明確的其他初始化操作，那麼此包下面的模塊是不會自動導入的。
        例如：
                有下面的包結構：
                PA
                |---- __init__.py
                |---- wave.py
                |---- PB1
                      |---- __init__.py
                      |---- pb1_m.py
                |---- PB2
                      |---- __init__.py
                      |---- pb2_m.py 
                有如下程序：
                import sys
                import PA.wave                             #1
                import PA.PB1                               #2
                import PA.PB1.pb1_m as m1        #3
                import PA.PB2.pb2_m                   #4
               
                PA.wave.getName()                      #5
                m1.getName()                               #6
                PA.PB.pb2_m.getName()              #7

                1) 當執行 #1 後，sys.modules 會同時存在 PA、PA.wave 兩個模塊，此時可以調用 PA.wave 的任何類或函數了。但不能調用 PA.PB1(2) 下的任何模塊。當前 Local 中有了 PA 名字。
                2) 當執行 #2 後，只是將 PA.PB1 載入內存，sys.modules 中會有 PA、 PA.wave、PA.PB1 三個模塊，但是 PA.PB1 下的任何模塊都沒有自動載入內存，此時如果直接執行 PA.PB1.pb1_m.getName() 則會出錯，因爲 PA.PB1 中並沒有 pb1_m 。當前 Local 中還是隻有 PA 名字，並沒有 PA.PB1 名 字。
                3) 當執行 #3 後，會將 PA.PB1 下的 pb1_m 載入內存，sys.modules 中會有 PA、PA.wave、PA.PB1、PA.PB1.pb1_m 四個模塊，此時可以執行 PA.PB1.pb1_m.getName() 了。由於使用了 as，當前 Local中除了 PA 名字，另外添加了 m1 作爲 PA.PB1.pb1_m 的別名。
                4) 當執行 #4 後，會將 PA.PB2、PA.PB2.pb2_m 載入內存，sys.modules 中會有 PA、PA.wave、PA.PB1、PA.PB1.pb1_m、PA.PB2、PA.PB2.pb2_m 六個模塊。當前 Local 中還是隻有 PA、m1。