<address id="tl19n"></address>
      <address id="tl19n"><nobr id="tl19n"></nobr></address>

        <address id="tl19n"></address>

          <address id="tl19n"></address>
          <form id="tl19n"></form>

              首頁 > 上網技巧 > Python 包內的導入問題 絕對導入和相對導入

              Python 包內的導入問題 絕對導入和相對導入

              時間:2022-01-18 13:07 作者:QQ地帶 我要評論

              基本概念
               
              Python 中的包,即包含 __init__.py 文件的文件夾。
               
              對于 Python 的包內導入,即包內模塊導入包內模塊,存在絕對導入和相對導入問題。
               
              普通 Python 模塊的搜索路徑
               
              1. 在當前模塊所在路徑中搜索導入模塊
               
              2. 在環境變量 PYTHONPATH 指定的路徑列表中搜索導入模塊
               
              3. 在 sys.path 指定的路徑列表中搜索導入模塊
               
              Python import 的步驟
               
               Python 所有加載的模塊信息都存放在 sys.modules 字典結構中,當 import 一個模塊時,會按如下步驟來進行
               
              1. 如果 import A,檢查 sys.modules 中是否已經有 A,如果有則不加載,如果沒有則為 A 創建 module 對象,并加載 A,即可以重復導入,但只加載一次。
              2. 如果 from A import B,先為 A 創建 module 對象,再解析 A,從中尋找 B 并填充到 A 的 __dict__ 中。
               
              相對導入與絕對導入
               
              絕對導入的格式為 import A.B 或 from A import B,相對導入格式為 from .A import B 或 from ..X import Y,. 代表當前模塊,.. 代表上層模塊,... 代表上上層模塊,依次類推。
               
              相對導入對于包的維護優勢
               
              相對導入可以避免硬編碼帶來的包維護問題,例如我們改了某一層包的名稱,那么其它模塊對于其子包的所有絕對導入就不能用了,但是采用相對導入語句的模塊,就會避免這個問題。
               
              需要注意:存在相對導入語句的模塊,是不能直接運行的。 例如,對于如下層次結構的 Digital.py 文件,
               
              復制代碼
              #!/usr/bin/env python
              # -*- coding: utf-8 -*-
              ##############################################################################
              # Purpose: to demo underlayer import upperlayer.
              ##############################################################################
              #
              #      \PHONE
              #      │  common_util.py   -> setup()
              #      │  __init__.py
              #      │
              #      ├─Fax
              #      │      G3.py        -> bar()
              #      │      __init__.py
              #      │
              #      ├─Mobile
              #      │      Analog.py    -> foo()
              #      │      Digital.py
              #      │      __init__.py
              #      │
              #      ├─Pager
              #      │      Page.py
              #      │      __init__.py
              #      │
              #      └─Voice
              #              Isdn.py
              #              __init__.py
              #
              ##############################################################################
               
              from .Analog import foo          # ValueError: Attempted relative import in non-package
              from ..common_util import setup  # ValueError: Attempted relative import in non-package
              from ..Fax.G3 import bar         # ValueError: Attempted relative import in non-package
               
              if __name__ == '__main__':
               
                  foo()
                  setup()
                  bar()
              復制代碼
              如果上述代碼直接運行,將導致 ValueError 異常,
               
              ValueError: Attempted relative import in non-package
              這是因為:一個模塊直接運行,Python 認為這個模塊就是頂層模塊,不存在層次結構,所以找不到其它的相對路徑。
               
              而要正確運行,就要顯式的指定路徑,如下,
               
              C:\workspace\X_python>python -m Phone.Mobile.Digital
              This is foo() from Phone.Mobile.Analog
              This is setup() from Phone.common_util
              This is bar() from Phone.Fax.G3
              當然,我們一般不會直接運行包內的某個模塊,這里只是做個說明。
               
              絕對導入對于包維護的劣勢
               
              例如,對于如下層次結構的 Digital.py 文件,
               
              復制代碼
              #!/usr/bin/env python
              # -*- coding: utf-8 -*-
              ##############################################################################
              # Purpose: to demo underlayer import upperlayer.
              ##############################################################################
              #
              #      \PHONE
              #      │  common_util.py   -> setup()
              #      │  __init__.py
              #      │
              #      ├─Fax
              #      │      G3.py        -> bar()
              #      │      __init__.py
              #      │
              #      ├─Mobile
              #      │      Analog.py    -> foo()
              #      │      Digital.py
              #      │      __init__.py
              #      │
              #      ├─Pager
              #      │      Page.py
              #      │      __init__.py
              #      │
              #      └─Voice
              #              Isdn.py
              #              __init__.py
              #
              ##############################################################################
               
              # from .Analog import foo          # ValueError: Attempted relative import in non-package
              # from ..common_util import setup  # ValueError: Attempted relative import in non-package
              # from ..Fax.G3 import bar         # ValueError: Attempted relative import in non-package
               
              from Phone.Mobile.Analog import foo
              from Phone.common_util import setup
              from Phone.Fax.G3 import bar
               
              if __name__ == '__main__':
               
                  foo()
                  setup()
                  bar()
              復制代碼
              上述代碼可以直接運行。
              但是,絕對導入的硬編碼模式,如果在包中存在很多 Digital.py 類似模塊,都采用了 from Phone.common_util import setup 的語句,如果有一天要更改 common_util 包(文件夾)的名字,那么會影響所有相關的代碼。而采用相對導入就沒有這個問題。
               
              不過,絕對導入更清晰,如果包不是特別復雜,不是特別易變,那么還是建議采用絕對導入。(個人觀點,僅供參考)
               
               
               
              再舉一個包內導入的例子,目錄結構為,
               
              復制代碼
              #   myabc/
              #   ├── abc.py
              #   ├── __init__.py
              #   └── xyz.py
               
              # abc.py
               
              def foo():
                  print("This is foo from local abc module!")
               
              # xyz.py
               
              ##########################################
              #import .abc                  # invalid (due to abc is not a package, so cannot import directly)
              #import . abc                 # invalid (reason as above)
              ##########################################
               
              #from .abc import foo          # valid
              from . abc import foo          # valid
               
              def bar():
                  print('bar - ', end='')
                  foo()
              復制代碼
              外部使用 myabc 包,
               
              復制代碼
              >>> import myabc.xyz
              >>> myabc.xyz.bar()
              bar - This is foo from local abc module!
              >>> 
              >>> from myabc import xyz
              >>> xyz.bar()
              bar - This is foo from local abc module!
              >>> 
              >>> 
              >>> import myabc.abc
              >>> myabc.abc.foo()
              This is foo from local abc module!
              >>> 
              >>> from myabc import abc
              >>> abc.foo()
              This is foo from local abc module!
              復制代碼
               
               
              再舉個例子, 
               
              復制代碼
              #    myfact/
              #    ├── factory.py
              #    ├── __init__.py
              #    └── xyz.py
               
              # factory.py 
              def foo():
                  print("This is foo from local factory module!")
               
               
              # xyz.py 
               
              #from myfact import factory          # Valid, absolute
              #from myfact.factory import foo      # Valid, absolute
               
              #from factory import foo             # Invalid! ModuleNotFoundError: No module named 'factory'
              #from .factory import foo            # Valud, relative
              from . factory import foo            # Valud, relative
              def bar(): 
                  print('bar - ', end='') 
                  foo()
              復制代碼
              外部使用 myfact 包,
               
              >>> import myfact.xyz
              >>> 
              >>> myfact.xyz.bar()
              bar - This is foo from local factory module!
               
               
               
               
              (完)
               

              標簽: Python
              頂一下
              (0)
              0%
              踩一下
              (0)
              0%

              Google提供的廣告

              国产古代一级a毛片,国产成人午夜在线直播,write.as 当众老师
                <address id="tl19n"></address>
                  <address id="tl19n"><nobr id="tl19n"></nobr></address>

                    <address id="tl19n"></address>

                      <address id="tl19n"></address>
                      <form id="tl19n"></form>