這篇文章主要講解了“Python怎么導(dǎo)入模塊”，文中的講解內(nèi)容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Python怎么導(dǎo)入模塊”吧！

成都創(chuàng)新互聯(lián)主營朗縣網(wǎng)站建設(shè)的網(wǎng)絡(luò)公司,主營網(wǎng)站建設(shè)方案,成都APP應(yīng)用開發(fā),朗縣h5重慶小程序開發(fā)搭建,朗縣網(wǎng)站營銷推廣歡迎朗縣等地區(qū)企業(yè)咨詢

常規(guī)導(dǎo)入

常規(guī)導(dǎo)入應(yīng)該是最常使用的導(dǎo)入方式，大概是這樣的：

import  sys

你只需要使用 import一詞，然后指定你希望導(dǎo)入的模塊或包即可。通過這種方式導(dǎo)入的好處是可以一次性導(dǎo)入多個包或模塊：

import  os, sys, time

雖然這節(jié)省了空間，但是卻違背了Python風格指南。Python風格指南建議將每個導(dǎo)入語句單獨成行。

有時在導(dǎo)入模塊時，你想要重命名這個模塊。這個功能很容易實現(xiàn)：

import  sys  as  system print (system.platform)

上面的代碼將我們導(dǎo)入的 sys模塊重命名為  system。我們可以按照和以前一樣的方式調(diào)用模塊的方法，但是可以用一個新的模塊名。也有某些子模塊必須要使用點標記法才能導(dǎo)入。

import  urllib.error

這個情況不常見，但是對此有所了解總是沒有壞處的。

使用from語句導(dǎo)入

很多時候你只想要導(dǎo)入一個模塊或庫中的某個部分。我們來看看在Python中如何實現(xiàn)這點：

from  functools  import  lru_cache

上面這行代碼可以讓你直接調(diào)用 lru_cache。如果你按常規(guī)方式導(dǎo)入 functools，那么你就必須像這樣調(diào)用 lru_cache：

functools.lru_cache(*args)

根據(jù)你實際的使用場景，上面的做法可能是更好的。在復(fù)雜的代碼庫中，能夠看出某個函數(shù)是從哪里導(dǎo)入的這點很有用的。不過，如果你的代碼維護的很好，模塊化程度高，那么只從某個模塊中導(dǎo)入一部分內(nèi)容也是非常方便和簡潔的。

當然，你還可以使用from方法導(dǎo)入模塊的全部內(nèi)容，就像這樣：

from  os  import  *

這種做法在少數(shù)情況下是挺方便的，但是這樣也會打亂你的命名空間。問題在于，你可能定義了一個與導(dǎo)入模塊中名稱相同的變量或函數(shù)，這時如果你試圖使用  os模塊中的同名變量或函數(shù)，實際使用的將是你自己定義的內(nèi)容。因此，你最后可能會碰到一個相當讓人困惑的邏輯錯誤。標準庫中我唯一推薦全盤導(dǎo)入的模塊只有Tkinter。

如果你正好要寫自己的模塊或包，有人會建議你在  __init__.py文件中導(dǎo)入所有內(nèi)容，讓模塊或者包使用起來更方便。我個人更喜歡顯示地導(dǎo)入，而非隱式地導(dǎo)入。

你也可以采取折中方案，從一個包中導(dǎo)入多個項：

from  os  import  path, walk, unlink from  os  import  uname, remove

在上述代碼中，我們從  os模塊中導(dǎo)入了5個函數(shù)。你可能注意到了，我們是通過多次從同一個模塊中導(dǎo)入實現(xiàn)的。當然，如果你愿意的話，你也可以使用圓括號一次性導(dǎo)入多個項：

from  os  import  (path, walk, unlink, uname,   remove, rename)

這是一個有用的技巧，不過你也可以換一種方式：

from  os  import  path, walk, unlink, uname, \  remove, rename

上面的反斜杠是Python中的續(xù)行符，告訴解釋器這行代碼延續(xù)至下一行。

相對導(dǎo)入

PEP  328介紹了引入相對導(dǎo)入的原因，以及選擇了哪種語法。具體來說，是使用句點來決定如何相對導(dǎo)入其他包或模塊。這么做的原因是為了避免偶然情況下導(dǎo)入標準庫中的模塊產(chǎn)生沖突。這里我們以PEP  328中給出的文件夾結(jié)構(gòu)為例，看看相對導(dǎo)入是如何工作的：

my_package/  __init__.py  subpackage1/  __init__.py  module_x.py  module_y.py  subpackage2/  __init__.py  module_z.py  module_a.py

在本地磁盤上找個地方創(chuàng)建上述文件和文件夾。在頂層的 __init__.py文件中，輸入以下代碼：

from  .  import  subpackage1 from  .  import  subpackage2

接下來進入 subpackage1文件夾，編輯其中的 __init__.py文件，輸入以下代碼：

from  .  import  module_x from  .  import  module_y

現(xiàn)在編輯 module_x.py文件，輸入以下代碼：

from  .module_y  import  spam  as  ham def  main():  ham()

最后編輯 module_y.py文件，輸入以下代碼：

def  spam():   print ( 'spam '  *  3 )

打開終端， cd至 my_package包所在的文件夾，但不要進入  my_package。在這個文件夾下運行Python解釋器。我使用的是IPython，因為它的自動補全功能非常方便：

In  [ 1 ]:  import  my_package In  [ 2 ]: my_package.subpackage1.module_x Out [ 2 ]: < module   'my_package.subpackage1.module_x'   from   'my_package/subpackage1/module_x.py' > In  [ 3 ]: my_package.subpackage1.module_x.main() spam spam spam

相對導(dǎo)入適用于你最終要放入包中的代碼。如果你編寫了很多相關(guān)性強的代碼，那么應(yīng)該采用這種導(dǎo)入方式。你會發(fā)現(xiàn)PyPI上有很多流行的包也是采用了相對導(dǎo)入。還要注意一點，如果你想要跨越多個文件層級進行導(dǎo)入，只需要使用多個句點即可。不過，PEP  328建議相對導(dǎo)入的層級不要超過兩層。

還要注意一點，如果你往 module_x.py文件中添加了  if__name__==‘__main__’，然后試圖運行這個文件，你會碰到一個很難理解的錯誤。編輯一下文件，試試看吧!

from  . module_y  import  spam  as  ham def  main():  ham() if  __name__ ==  '__main__' :   # This won't work!  main()

現(xiàn)在從終端進入 subpackage1文件夾，執(zhí)行以下命令：

python module_x.py

如果你使用的是Python 2，你應(yīng)該會看到下面的錯誤信息：

Traceback  (most recent call  last ):   File   "module_x.py" , line  1 ,  in      from  . module_y  import  spam  as  ham ValueError :  Attempted  relative  import   in  non- package

如果你使用的是Python 3，錯誤信息大概是這樣的：

Traceback  (most recent call  last ):   File   "module_x.py" , line  1 ,  in      from  . module_y  import  spam  as  ham SystemError :  Parent   module   ''   not  loaded, cannot perform relative  import

這指的是， module_x.py是某個包中的一個模塊，而你試圖以腳本模式執(zhí)行，但是這種模式不支持相對導(dǎo)入。

如果你想在自己的代碼中使用這個模塊，那么你必須將其添加至Python的導(dǎo)入檢索路徑(import search path)。最簡單的做法如下：

import  sys sys.path.append( '/path/to/folder/containing/my_package' ) import  my_package

注意，你需要添加的是 my_package的上一層文件夾路徑，而不是 my_package本身。原因是  my_package就是我們想要使用的包，所以如果你添加它的路徑，那么將無法使用這個包。

我們接下來談?wù)効蛇x導(dǎo)入。

可選導(dǎo)入(Optional imports)

如果你希望優(yōu)先使用某個模塊或包，但是同時也想在沒有這個模塊或包的情況下有備選，你就可以使用可選導(dǎo)入這種方式。這樣做可以導(dǎo)入支持某個軟件的多種版本或者實現(xiàn)性能提升。以github2包中的代碼為例：

try :   # For Python 3   from  http.client  import  responses except   ImportError :  # For Python 2.5-2.7   try :   from  httplib  import  responses  # NOQA   except   ImportError :  # For Python 2.4   from   BaseHTTPServer   import   BaseHTTPRequestHandler   as  _BHRH  responses = dict([(k, v[ 0 ])  for  k, v  in  _BHRH.responses.items()]

lxml包也有使用可選導(dǎo)入方式：

try :   from  urlparse  import  urljoin   from  urllib2  import  urlopen except   ImportError :   # Python 3   from  urllib.parse  import  urljoin   from  urllib.request  import  urlopen

正如以上示例所示，可選導(dǎo)入的使用很常見，是一個值得掌握的技巧。

局部導(dǎo)入

當你在局部作用域中導(dǎo)入模塊時，你執(zhí)行的就是局部導(dǎo)入。如果你在Python腳本文件的頂部導(dǎo)入一個模塊，那么你就是在將該模塊導(dǎo)入至全局作用域，這意味著之后的任何函數(shù)或方法都可能訪問該模塊。例如：

import  sys  # global scope def  square_root(a):   # This import is into the square_root functions local scope   import  math   return  math.sqrt(a) def  my_pow(base_num, power):   return  math.pow(base_num, power) if  __name__ ==  '__main__' :   print (square_root( 49 ))   print (my_pow( 2 ,  3 ))

這里，我們將 sys模塊導(dǎo)入至全局作用域，但我們并沒有使用這個模塊。然后，在 square_root函數(shù)中，我們將  math模塊導(dǎo)入至該函數(shù)的局部作用域，這意味著 math模塊只能在 square_root函數(shù)內(nèi)部使用。如果我們試圖在 my_pow函數(shù)中使用 math，會引發(fā)  NameError。試著執(zhí)行這個腳本，看看會發(fā)生什么。

使用局部作用域的好處之一，是你使用的模塊可能需要很長時間才能導(dǎo)入，如果是這樣的話，將其放在某個不經(jīng)常調(diào)用的函數(shù)中或許更加合理，而不是直接在全局作用域中導(dǎo)入。老實說，我?guī)缀鯊臎]有使用過局部導(dǎo)入，主要是因為如果模塊內(nèi)部到處都有導(dǎo)入語句，會很難分辨出這樣做的原因和用途。根據(jù)約定，所有的導(dǎo)入語句都應(yīng)該位于模塊的頂部。

導(dǎo)入注意事項

在導(dǎo)入模塊方面，有幾個程序員常犯的錯誤。這里我們介紹兩個。

• 循環(huán)導(dǎo)入(circular imports)

• 覆蓋導(dǎo)入(Shadowed imports，暫時翻譯為覆蓋導(dǎo)入)

先來看看循環(huán)導(dǎo)入。

循環(huán)導(dǎo)入

如果你創(chuàng)建兩個模塊，二者相互導(dǎo)入對方，那么就會出現(xiàn)循環(huán)導(dǎo)入。例如：

# a.py import  b def  a_test():   print ( "in a_test" )  b.b_test() a_test()

然后在同個文件夾中創(chuàng)建另一個模塊，將其命名為 b.py。

import  a def  b_test():   print ( 'In test_b"' )  a.a_test() b_test()

如果你運行任意一個模塊，都會引發(fā) AttributeError。這是因為這兩個模塊都在試圖導(dǎo)入對方。簡單來說，模塊 a想要導(dǎo)入模塊 b，但是因為模塊  b也在試圖導(dǎo)入模塊 a(這時正在執(zhí)行)，模塊 a將無法完成模塊  b的導(dǎo)入。我看過一些解決這個問題的破解方法(hack)，但是一般來說，你應(yīng)該做的是重構(gòu)代碼，避免發(fā)生這種情況。

覆蓋導(dǎo)入

當你創(chuàng)建的模塊與標準庫中的模塊同名時，如果你導(dǎo)入這個模塊，就會出現(xiàn)覆蓋導(dǎo)入。舉個例子，創(chuàng)建一個名叫 math.py的文件，在其中寫入如下代碼：

import  math def  square_root(number):   return  math.sqrt(number) square_root( 72 )

現(xiàn)在打開終端，試著運行這個文件，你會得到以下回溯信息(traceback)：

Traceback  (most recent call  last ):   File   "math.py" , line  1 ,  in      import  math   File   "/Users/michael/Desktop/math.py" , line  6 ,  in     square_root( 72 )   File   "/Users/michael/Desktop/math.py" , line  4 ,  in  square_root   return  math.sqrt(number) AttributeError :  module   'math'  has  no  attribute  'sqrt'

這到底是怎么回事?其實，你運行這個文件的時候，Python解釋器首先在當前運行腳本所處的的文件夾中查找名叫  math的模塊。在這個例子中，解釋器找到了我們正在執(zhí)行的模塊，試圖導(dǎo)入它。但是我們的模塊中并沒有叫 sqrt的函數(shù)或?qū)傩?，所以就拋出? AttributeError。

感謝各位的閱讀，以上就是“Python怎么導(dǎo)入模塊”的內(nèi)容了，經(jīng)過本文的學習后，相信大家對Python怎么導(dǎo)入模塊這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是創(chuàng)新互聯(lián)，小編將為大家推送更多相關(guān)知識點的文章，歡迎關(guān)注！