來源：麥叔編程

作者：麥叔

Python必備核心技能 - 模塊module（內容超詳細，舉例說明很容易懂）

Python模塊和包是和變量，函數，類同等重要的基礎的基礎。因為它們是Python組織程序的方式。掌握不好，你很難學習和理解新的知識，會處處碰壁。是掌握Python必備的核心技能。

在硬核Python私教班課程中，我把所有關鍵技能總結為Python 36技，模塊和包是其中之一。如果你想快速系統的學習Python，建立辦公自動化，數據分析等實戰技能，需要有專業老師指導你解決問題，可以考慮麥叔私教課，物美價廉。有興趣咨詢maishu1024。

本文詳細講解了：

• 模塊和概念；
• 創建自己的模塊；
• Python模塊的查找路徑；
• import語句的各種用法；
• 創建模塊和核心技巧；

模塊化編程是指將編程任務分解為單獨的，較小的，更易于管理的子任務或模塊的過程。然后可以像構建模塊

一樣將各個模塊拼湊在一起以創建更大的應用程序。

程序模塊化代碼有幾個優點：

• 簡單性：模塊通常只關注問題的一個相對較小的部分，而不是關注整個問題。如果你只關注單個模塊，
• 那么只有一個更小的問題域需要處理。這使得開發更容易，更不容易出錯。
• 可維護性：分成多個小文件，修改的時候只要修改相關的文件就行了。而且可以多人協作，同時修改而不會產生沖突。
• 可重用性：單個模塊中定義的功能可以被應用程序的其他部分輕松地重用（通過適當定義的接口）。這減少了重復代碼。
• 作用域：模塊通常會定義一個單獨的命名空間，這有助于避免程序不同區域中的名字發生沖突。（Python禪的信條之一是：命名空間是一個很棒的發明）

函數，模塊和包都是Python中促進代碼模塊化的機制。

1.Python模塊：概述

在Python中定義模塊的方式有三種：

• 用Python編寫的模塊，我們寫的主要是這一類模塊
• 用C語言編寫模塊，并在運行時動態加載模塊，例如re（正則表達式）模塊。這種模塊看不到源代碼。
• 包含在解釋器中的內置模塊，比如itertools模塊。

在這三種情況下，訪問模塊內容的方式都是相同的: 使用import語句。

本文重點主要放在用Python編寫的模塊上。用Python編寫的模塊很酷的一點是，它很容易。

你所需要做的就是創建一個包含合法Python代碼的文件，然后給該文件一個后綴名為.py的名稱。就是這樣!不需要特殊的語法或魔法。你就創建了一個模塊。

例如，假設你創建了一個名為mod.py的文件，其中包含以下內容:

s = "這是我的第一個模塊，我是麥叔，喜歡請關注我." a = [100, 200, 300] def foo(arg):    

 print(f'arg = {arg}') class Foo:     pass 

mod.py中定義了幾個對象:

• s (一個字符串)
• a (一個列表)
• foo() (一個函數)
• Foo (一個類)

假設mod.py保存在你電腦上的某一個位置，這些對象可以通過如下方式導入模塊來訪問:

>>> import mod >>> print(mod.s)
這是我的第一個模塊，我是麥叔，喜歡請關注我. >>> mod.a
[100, 200, 300] >>> mod.foo(['你好', '我好', '大家好'])
arg = ['你好', '我好', '大家好'] >>> x = mod.Foo() >>> x
<mod.Foo object at 0x03C181F0>

2.模塊搜索路徑

繼續上面的例子，讓我們看看當Python執行語句時會發生什么:

import mod

當解釋器執行上面的import語句時，它會依次去下面的目錄搜索mod.py，搜索不到就報錯:

• 運行代碼的目錄，如果使用交互式Python，則為當前目錄
• 環境變量PYTHONPATH中的目錄。
• 安裝Python時配置的與安裝相關的目錄列表

可以通過sys.path來得到所有搜索路徑。

>>> import sys >>> sys.path
['', 'C:\Users\maishu\Documents\Python\doc', 'C:\Python36\Lib\idlelib', 'C:\Python36\python36.zip',

 'C:\Python36\DLLs', 'C:\Python36\lib', 'C:\Python36', 'C:\Python36\lib\site-packages']

注意:sys.path 和你的python環境有關。上面的代碼在你的電腦上看起來會有些許不同。

因此，要確保找到你的模塊，你需要執行以下操作之一:

• 如果是交互環境，把mod.py保存到執行命令的當前目錄
• 將mod.py所在目錄放到PYTHONPATH環境變量中
• 或者:把mod.py文件放到已經存在PYTHONPATH中的某一個目錄
• 把mod.py放在python安裝相關的目錄中

實際上還有一個額外的選項:你可以將模塊文件放在你選擇的任何目錄中，然后臨時修改sys.path，以便包含該目錄。例如，

在這種情況下，你可以把mod.py放在目錄C:Usersmaishu中，然后使用以下代碼:

>>> sys.path.append(r'C:Usersmaishu')
>>> sys.path
['', 'C:\Users\maishu\Documents\Python\doc', 'C:\Python36\Lib\idlelib', 'C:\Python36\python36.zip',

 'C:\Python36\DLLs', 'C:\Python36\lib', 'C:\Python36', 'C:\Python36\lib\site-packages', 'C:\Users\maishu']
>>> import mod

一旦模塊被導入，你就可以通過模塊的__file__屬性來確定它被找到的位置:

>>> import mod >>> mod.__file__ 'C:\Users\maishu\mod.py' >>> import re >>> re.__file__ 'C:\Python36\lib\re.py' 

3.import語句

最簡單的形式是上面所示的:

import <module_name>

請注意，這種簡單的形式只是引用了模塊本身，模塊內的東西并沒有直接引入，不能直接用名字訪問，而要通過模塊.變量的形式。

模塊會創建一個單獨的名稱空間，防止和別的模塊發生沖突。這樣就能以模塊名作為前綴，通過點訪問模塊內的東西，如下所示。

在下列import語句之后，mod被引入到本文件中。因此，可以引用mod:

>>> import mod >>> mod
<module 'mod' from 'C:\Users\maishu\Documents\Python\doc\mod.py'> 

但是s和foo仍然在屬于mod內部的變量和函數，不能直接使用:

>>> s NameError: name 's' is not defined >>> foo('quux') NameError: name 'foo' is not defined 

必須加上mod前綴才可以:

>>> mod.s 'If Comrade Napoleon says it, it must be right.' >>> mod.foo('quux')
arg = quux

幾個用逗號分隔的模塊可以在一個import語句中指定:

import <module_name>[, <module_name> ...]

from <module_name> import <name(s)>

import語句的另一種形式允許將模塊中的單個對象直接導入:

from <module_name> import <name(s)>

執行上面的語句后， 可以在不使用前綴的調用者環境中被引用:

>>> from mod import s, foo >>> s '這是我的第一個模塊，我是麥叔，喜歡請關注我.' >>> foo('你好')
arg = 你好 >>> from mod import Foo >>> x = Foo() >>> x
<mod.Foo object at 0x02E3AD50>

因為這種形式的導入將對象名稱直接引入當前文件，任何已經存在的具有相同名稱的對象都將被覆蓋:

>>> a = ['foo', 'bar', 'baz'] >>> a
['foo', 'bar', 'baz'] >>> from mod import a >>> a
[100, 200, 300]

甚至可以一下子不加區別地從一個模塊中導入所有內容:

from <module_name> import *

這將把模塊中的所有對象的名稱引入當前文件，但不包括以下劃線(_)開頭的內容。

例如:

>>> from mod import *
>>> s '這是我的第一個模塊，我是麥叔，喜歡請關注我.' >>> a
[100, 200, 300] >>> foo
<function foo at 0x03B449C0> >>> Foo
<class 'mod.Foo'> 

在大規模的項目中并不推薦這樣做。這有一點危險，因為這會在引入全部名稱。除非你對它們都很了解，并且確信不會有沖突，

否則你很有可能會無意中覆蓋現有的變量。然而，當你只是為了測試或學習目的而使用交互式解釋器時，此語法非常方便，

因為它可以讓你快速訪問模塊所提供的所有內容，而無需大量輸入。

from <module_name> importas <alt_name>

也可以導入單獨的對象，并且給它設置一個別名:

from <module_name> import <name> as <alt_name>[, <name> as <alt_name> …]

這使得可以直接將名稱引入，但避免與之前存在的名稱沖突:

>>> s = 'foo' >>> a = ['foo', 'bar', 'baz'] >>> from mod import s as string, a as alist >>> s 'foo' >>> 

string '這是我的第一個模塊，我是麥叔，喜歡請關注我.' >>> a
['foo', 'bar', 'baz'] >>> alist
[100, 200, 300]

import <module_name> as <alt_name>

你也可以用這種方式導入整個模塊:

import <module_name> as <alt_name>

>>> import mod as my_module >>> my_module.a
[100, 200, 300] >>> my_module.foo('qux')
arg = qux

模塊內容也可以從函數中導入。在這種情況下，模塊只有在函數被調用才會被導入:

>>> def bar():
...     from mod import foo
...     foo('corge')
... >>> bar()
arg = corge

然而，Python3不允許從函數內部使用import *:

>>> def bar():
...     from mod import *
... SyntaxError: import * only allowed at module level 

最后，帶有except ImportError子句的try語句可以用來防止失敗的導入嘗試:

>>> try:
...     # Non-existent module ...     import baz
... except ImportError:
...     print('Module not found')
...

Module not found

>>> try:
...     # Existing module, but non-existent object ...     from mod import baz
... except ImportError:
...     print('Object not found in module')
...

Object not found in module

4.dir()函數

內置函數dir()返回一個模塊中定義的所有名稱列表（函數，全局變量等）。如果沒有參數，它會在當前局部符號表中生成一個按字母排序的名稱列表:

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__'] >>> qux = [1, 2, 3, 4, 5] >>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'qux'] >>> class Bar(): ...     pass
... >>> x = Bar() >>> dir()
['Bar', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'qux', 'x']

請注意上面對dir()的第一次調用是如何列出幾個已經在命名空間中的名稱的。當定義了新的名稱(qux, Bar, x)時，它們會出現在后續的dir()調用中。

這對于確定import語句到底給命名空間添加了什么是很有用的:

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__'] >>> import mod >>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'mod'] >>> mod.s 'If 

Comrade Napoleon says it, it must be right.' >>> mod.foo([1, 2, 3])
arg = [1, 2, 3] >>> from mod import a, Foo >>> dir()
['Foo', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'mod'] >>> a
[100, 200, 300] >>> x = Foo() >>> x
<mod.Foo object at 0x002EAD50> >>> from mod import s as string >>> dir()
['Foo', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'mod', 

'string', 'x'] >>> string 'If Comrade Napoleon says it, it must be right.' 

當給dir()一個模塊名的參數時，dir()列出在該模塊中定義的名稱:

>>> import mod >>> dir(mod)
['Foo', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'foo', 's']

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__'] >>> from mod import *
>>> dir()
['Foo', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'foo', 's']

5.將模塊作為腳本執行

任何包含模塊的.py文件本質上也是一個Python腳本，沒有任何理由不能像Python腳本那樣執行它。

下面是mod.py的定義:

mod.py

s = "If Comrade Napoleon says it, it must be right." a = [100, 200, 300] def foo(arg):     print(f'arg = {arg}') class Foo:     pass 

這可以作為一個腳本運行:

C:UsersmaishuDocuments>python mod.py C:UsersmaishuDocuments>

沒有錯誤，所以它顯然是有效的。當然，這不是很有趣。就像它寫的那樣，它只定義對象。它不會對它們做任何事情，也不會生成任何輸出。

讓我們修改一下上面的Python模塊，這樣當它作為腳本運行時就會生成一些輸出:

mod.py

s = "If Comrade Napoleon says it, it must be right." a = [100, 200, 300] def foo(arg): 

    print(f'arg = {arg}') class Foo:     pass print(s)
print(a)
foo('quux')
x = Foo()
print(x)

現在應該更有趣了:

C:UsersmaishuDocuments>python mod.py If Comrade Napoleon says it, it must be right.

 [100, 200, 300] arg = quux <__main__.Foo object at 0x02F101D0> 

不幸的是，現在它也會在作為模塊導入時生成輸出:

>>> import mod If Comrade Napoleon says it, it must be right.
[100, 200, 300] arg = quux
<mod.Foo object at 0x0169AD50>

這可能不是你想要的。模塊在導入時通常不會生成輸出。

如果能夠區分文件是作為模塊加載的，還是作為獨立腳本運行的，不是很好嗎?

這當然是可以做到的！

當.py文件作為模塊導入時，Python將特殊的變量__name__設置為模塊的名稱。但是，如果一個文件作為一個獨立的腳本運行，

__name__被設置為字符串'__main__'?；谶@個，你可以辨別哪種情況是在運行時發生的，并相應地改變行為:

mod.py

s = "If Comrade Napoleon says it, it must be right." a = [100, 200, 300] def foo(arg):

     print(f'arg = {arg}') class Foo:     pass if (__name__ == '__main__'):
    print('Executing as standalone script')
    print(s)
    print(a)
    foo('quux')
    x = Foo()
    print(x)

現在，如果你作為一個腳本運行，你會得到輸出:

C:UsersmaishuDocuments>python mod.py
Executing as standalone script
If Comrade Napoleon says it, it must be right.
[100, 200, 300]
arg = quux
<__main__.Foo object at 0x03450690>

但如果你以模塊的形式導入，不會有輸出:

>>> import mod >>> mod.foo('grault')
arg = grault

為了測試模塊中包含的功能，模塊通常被設計為能夠作為獨立的腳本運行。這被稱為單元測試。例如，

假設你已經創建了一個包含階乘函數的模塊fact.py，如下所示:

fact.py

def fact(n):     return 1 if n == 1 else n * fact(n-1) if (__name__ == '__main__'):
    import sys
    if len(sys.argv) > 1:
        print(fact(int(sys.argv[1])))

可以將該文件視為一個模塊，并導入fact()函數:

>>> from fact import fact >>> fact(6) 720 

但它也可以通過在命令行中傳遞一個整數參數來獨立運行，以進行測試:

C:UsersmaishuDocuments>python fact.py 6 720 

6.重新加載模塊

為了提高效率，一個模塊在每次解釋器會話中只加載一次。這對于函數和類定義來說很好，它們通常構成模塊內容的大部分。

但是模塊也可以包含可執行語句，通常用于初始化。請注意，這些語句只會在第一次導入模塊時執行。

考慮下面的mod.py文件:

mod.py

a = [100, 200, 300] print('a =', a)

>>> import mod
a = [100, 200, 300] >>> import mod >>> import mod >>> mod.a
[100, 200, 300]

print()只有在第一次導入模塊時執行，不會在后續導入中執行。

如果你對模塊做了更改并需要重新加載它，你需要重新啟動解釋器或使用模塊importlib中的重載函數: reload()

>>> import mod
a = [100, 200, 300] >>> import mod >>> import importlib >>> importlib.reload(mod)
a = [100, 200, 300]
<module 'mod' from 'C:\Users\maishu\Documents\Python\doc\mod.py'>