Python 程序的運行原理

簡單的例子

先從一個簡單的例子說起，包含了兩個文件 foo.py 和 demo.py

[foo.py]def add(a, b): return a + bprint("被import後執行")if __name__ == "__main__": print("被import引入後主函數中的代碼也不會運行",add(1,2))

[demo.py]import fooa = [1, "python"]a = "a string"def func(): a = 1 b = 257 print(a + b)print(a)if __name__ == "__main__": func() print(foo.add(1, 2))

運行結果如下：

被import後執行a string2583

同時，該文件目錄多出一個 foo.pyc 文件

運行原理

執行 python demo.py 後，將會啟動 Python 的解釋器，然後將 demo.py 編譯成一個位元組碼對象 PyCodeObject。

有的人可能會很好奇，編譯的結果不應是 pyc 文件嗎，就像 Java 的 class 文件，那為什麼是一個對象呢，這裡稍微解釋一下。

在 Python 的世界中，一切都是對象，函數也是對象，類型也是對象，類也是對象（類屬於自定義的類型，在 Python 2.2 之前，int, dict 這些內置類型與類是存在不同的，在之後才統一起來，全部繼承自 object），甚至連編譯出來的位元組碼也是對象，.pyc 文件是位元組碼對象（PyCodeObject）在硬碟上的表現形式。

在運行期間，編譯結果也就是 PyCodeObject 對象，只會存在於內存中，而當這個模塊的 Python 代碼執行完後，就會將編譯結果保存到了 pyc 文件中，這樣下次就不用編譯，直接載入到內存中。pyc 文件只是 PyCodeObject 對象在硬碟上的表現形式。

這個 PyCodeObject 對象包含了 Python 源代碼中的字元串，常量值，以及通過語法解析後編譯生成的位元組碼指令。PyCodeObject 對象還會存儲這些位元組碼指令與原始代碼行號的對應關係，這樣當出現異常時，就能指明位於哪一行的代碼。

pyc 文件

一個 pyc 文件包含了三部分信息：Python 的 magic number、pyc 文件創建的時間信息，以及 PyCodeObject 對象。

magic number 是 Python 定義的一個整數值。一般來說，不同版本的 Python 實現都會定義不同的 magic number，這個值是用來保證 Python 兼容性的。比如要限制由低版本編譯的 pyc 文件不能讓高版本的 Python 程序來執行，只需要檢查 magic number 不同就可以了。由於不同版本的 Python 定義的位元組碼指令可能會不同，如果不做檢查，執行的時候就可能出錯。

下面所示的代碼可以來創建 pyc 文件，使用方法

python generate_pyc.py module_name

例如

python generate_pyc.py demo

[generate_pyc.pyc]

import impimport sysdef generate_pyc(name): fp, pathname, description = imp.find_module(name) try: imp.load_module(name, fp, pathname, description) finally: if fp: fp.close()if __name__ == __main__: generate_pyc(sys.argv[1])

位元組碼指令

為什麼 pyc 文件也稱作位元組碼文件？因為這些文件存儲的都是一些二進位的位元組數據，而不是能讓人直觀查看的文本數據。

Python 標準庫提供了用來生成代碼對應位元組碼的工具 dis。dis 提供一個名為 dis 的方法，這個方法接收一個 code 對象，然後會輸出 code 對象里的位元組碼指令信息。

s = open(demo.py).read()co = compile(s, demo.py, exec)import disdis.dis(co)

執行上面這段代碼可以輸出 demo.py 編譯後的位元組碼指令

1 0 LOAD_CONST 0 (-1) 3 LOAD_CONST 1 (None) 6 IMPORT_NAME 0 (foo) 9 STORE_NAME 0 (foo) 3 12 LOAD_CONST 2 (1) 15 LOAD_CONST 3 (upython) 18 BUILD_LIST 2 21 STORE_NAME 1 (a) 4 24 LOAD_CONST 4 (ua string) 27 STORE_NAME 1 (a) 6 30 LOAD_CONST 5 (<code object func at 00D97650, file "demo.py", line 6>) 33 MAKE_FUNCTION 0 36 STORE_NAME 2 (func) 11 39 LOAD_NAME 1 (a) 42 PRINT_ITEM 43 PRINT_NEWLINE 13 44 LOAD_NAME 3 (__name__) 47 LOAD_CONST 6 (u__main__) 50 COMPARE_OP 2 (==) 53 POP_JUMP_IF_FALSE 82 14 56 LOAD_NAME 2 (func) 59 CALL_FUNCTION 0 62 POP_TOP 15 63 LOAD_NAME 0 (foo) 66 LOAD_ATTR 4 (add) 69 LOAD_CONST 2 (1) 72 LOAD_CONST 7 (2) 75 CALL_FUNCTION 2 78 POP_TOP 79 JUMP_FORWARD 0 (to 82) >> 82 LOAD_CONST 1 (None) 85 RETURN_VALUE

Python 虛擬機

demo.py 被編譯後，接下來的工作就交由 Python 虛擬機來執行位元組碼指令了。Python 虛擬機會從編譯得到的 PyCodeObject 對象中依次讀入每一條位元組碼指令，並在當前的上下文環境中執行這條位元組碼指令。我們的程序就是通過這樣循環往複的過程才得以執行。

import 指令

demo.py 的第一行代碼是 import foo。import 指令用來載入一個模塊，另外一個載入模塊的方法是 from xx import yy。用 from 語句的好處是，可以只複製需要的符號變數到當前的命名空間中（關於命名空間將在後面介紹）。

前文提到，當已經存在 pyc 文件時，就可以直接載入而省去編譯過程。但是代碼文件的內容會更新，如何保證更新後能重新編譯而不入舊的 pyc 文件呢。答案就在 pyc 文件中存儲的創建時間信息。當執行 import 指令的時候，如果已存在 pyc 文件，Python 會檢查創建時間是否晚於代碼文件的修改時間，這樣就能判斷是否需要重新編譯，還是直接載入了。如果不存在 pyc 文件，就會先將 py 文件編譯。

絕對引入和相對引入

前文已經介紹了 import foo 這行代碼。這裡隱含了一個問題，就是 foo 是什麼，如何找到 foo。這就屬於 Python 的模塊引入規則

賦值語句

接下來，執行到 a = [1, python]，這是一條賦值語句，定義了一個變數 a，它對應的值是 [1, python]。這裡要解釋一下，變數是什麼呢？

變數實際上是一個字元串的符號，用來關聯一個存儲在內存中的對象。在 Python 中，會使用 dict（就是 Python 的 dict 對象）來存儲變數符號（字元串）與一個對象的映射。

那麼賦值語句實際上就是用來建立這種關聯，在這個例子中是將符號 a 與一個列表對象 [1, python] 建立映射。

緊接著的代碼執行了 a = a string，這條指令則將符號 a 與另外一個字元串對象 a string 建立了映射。今後對變數 a 的操作，將反應到字元串對象 a string 上。

def 指令

我們的 Python 代碼繼續往下運行，這裡執行到一條 def func()，從位元組碼指令中也可以看出端倪 MAKE_FUNCTION。沒錯這條指令是用來創建函數的。Python 是動態語言，def 實際上是執行一條指令，用來創建函數（class 則是創建類的指令），而不僅僅是個語法關鍵字。函數並不是事先創建好的，而是執行到的時候才創建的。

def func() 將會創建一個名稱為 func 的函數對象。實際上是先創建一個函數對象，然後將 func 這個名稱符號綁定到這個函數上。

Python 中是無法實現 C 和 Java 中的重載的，因為重載要求函數名要相同，而參數的類型或數量不同，但是 Python 是通過變數符號（如這裡的 func）來關聯一個函數，當我們用 def 語句再次創建一個同名的函數時，這個變數名就綁定到新的函數對象上了。

動態類型

繼續看函數 func 裡面的代碼，這時又有一條賦值語句 a = 1。變數 a 現在已經變成了第三種類型，它現在是一個整數了。那麼 Python 是怎麼實現動態類型的呢？答案就藏在具體存儲的對象上。變數 a 僅僅只是一個符號（實際上是一個字元串對象），類型信息是存儲在對象上的。在 Python 中，對象機制的核心是類型信息和引用計數（引用計數屬於垃圾回收的部分）。

b = 257 跳過，我們直接來看看 print(a + b)，print 是輸出函數，這裡略過。這裡想要探究的是 a + b。

因為 a 和 b 並不存儲類型信息，因此當執行 a + b 的時候就必須先檢查類型，比如 1 + 2 和 "1" + "2" 的結果是不一樣的。

看到這裡，我們就可以想像一下執行一句簡單的 a + b，Python 虛擬機需要做多少繁瑣的事情了。首先需要分別檢查 a 和 b 所對應對象的類型，還要匹配類型是否一致（1 + "2" 將會出現異常），然後根據對象的類型調用正確的 + 函數（例如數值的 + 或字元串的 +），而 CPU 對於上面這條語句只需要執行 ADD 指令（還需要先將變數 MOV 到寄存器）。

命名空間 (namespace)

在介紹上面的這些代碼時，還漏掉了一個關鍵的信息就是命名空間。在 Python 中，類、函數、module 都對應著一個獨立的命名空間。而一個獨立的命名空間會對應一個 PyCodeObject 對象，所以上面的 demo.py 文件編譯後會生成兩個 PyCodeObject，只是在 demo.py 這個 module 層的 PyCodeObject 中通過一個變數符號 func 嵌套了一個函數的 PyCodeObject。

命名空間的意義，就是用來確定一個變數符號到底對應什麼對象。命名空間可以一個套一個地形成一條命名空間鏈，Python 虛擬機在執行的過程中，會有很大一部分時間消耗在從這條命名空間鏈中確定一個符號所對應的對象是什麼。

在 Python中，命名空間是由一個 dict 對象實現的，它維護了（name，obj）這樣的關聯關係。

說到這裡，再補充一下 import foo 這行代碼會在 demo.py 這個模塊的命名空間中，創建一個新的變數名 foo，foo 將綁定到一個 PyCodeObject 對象，也就是 foo.py 的編譯結果。

dir 函數

Python 的內置函數 dir 可以用來查看一個命名空間下的所有名字元號。一個用處是查看一個命名空間的所有屬性和方法（這裡的命名空間就是指類、函數、module）。

比如，查看當前的命名空間，可以使用 dir()，查看 sys 模塊，可以使用 dir(sys)。

LEGB 規則

Python 使用 LEGB 的順序來查找一個符號對應的對象

locals -> enclosing function -> globals -> builtins

locals，當前所在命名空間（如函數、模塊），函數的參數也屬於命名空間內的變數

enclosing，外部嵌套函數的命名空間（閉包中常見）

def fun1(a): def fun2(): # a 位於外部嵌套函數的命名空間 print(a)

globals，全局變數，函數定義所在模塊的命名空間

a = 1def fun(): # 需要通過 global 指令來聲明全局變數 global a # 修改全局變數，而不是創建一個新的 local 變數 a = 2

builtins，內置模塊的命名空間。Python 在啟動的時候會自動為我們載入很多內置的函數、類，比如 dict，list，type，print，這些都位於 __builtins__ 模塊中，可以使用 dir(__builtins__) 來查看。這也是為什麼我們在沒有 import 任何模塊的情況下，就能使用這麼多豐富的函數和功能了。

內置屬性 __name__

現在到了解釋 if __name__ == __main__ 這行代碼的時候了。當 Python 程序啟動後，Python 會自動為每個模塊設置一個屬性 __name__ 通常使用的是模塊的名字，也就是文件名，但唯一的例外是主模塊，主模塊將會被設置為 __main__。利用這一特性，就可以做一些特別的事。比如當該模塊以主模塊來運行的時候，可以運行測試用例。而當被其他模塊 import 時，則只是乖乖的，提供函數和功能就好。

pyc 文件

Python 只會對那些以後可能繼續被使用和載入的模塊才會生成 pyc 文件，Python 認為使用了 import 指令的模塊，屬於這種類型，因此會生成 pyc 文件。而對於只是臨時用一次的模塊，並不會生成 pyc 文件，Python 將主模塊當成了這種類型的文件。這就解釋了為什麼 python demo.py 執行完後，只會生成一個 foo.pyc 文件。

如果要問 pyc 文件什麼時候生成，答案就是在執行了 import 指令之後，from xx import yy 同樣屬於 import 指令。

小整數對象池

在 demo.py 這裡例子中，所用的整數特意用了一個 257，這是為了介紹小整數對象池的。整數在程序中的使用非常廣泛，Python 為了優化速度，使用了小整數對象池，避免為整數頻繁申請和銷毀內存空間。

Python 對小整數的定義是 [-5, 257)，這些整數對象是提前建立好的，不會被垃圾回收。在一個 Python 的程序中，所有位於這個範圍內的整數使用的都是同一個對象

對於大整數，Python 使用的是一個大整數對象池。這句話的意思是

每當創建一個大整數的時候，都會新建一個對象，但是這個對象不再使用的時候，並不會銷毀，後面再建立的對象會復用之前已經不再使用的對象的內存空間。（這裡的不再使用指的是引用計數為0，可以被銷毀）

字元串對象緩衝池

Python 的設計者為一個位元組的字元對應的字元串對象 (PyStringObject) 也設計了這樣一個對象池。同時還有一個 intern 機制，可以將內容相同的字元串變數轉換成指向同一個字元串對象。

intern 機制的關鍵，就是在系統中有一個（key，value）映射關係的集合，集合的名稱叫做 interned。在這個集合中，記錄著被 intern 機制處理過的 PyStringObject 對象。不過 Python 始終會為字元串創建 PyStringObject 對象，即便在interned 中已經有一個與之對應的 PyStringObject 對象了，而 intern 機制是在字元串被創建後才起作用。

>>> a = a string>>> b = a string>>> a is bFalse>>> a = intern(a string) # 手動調用 intern 方法>>> b = intern(a string)>>> a is bTrue

值得說明的是，數值類型和字元串類型在 Python 中都是不可變的，這意味著你無法修改這個對象的值，每次對變數的修改，實際上是創建一個新的對象。得益於這樣的設計，才能使用對象緩衝池這種優化。

import 指令

前文提到 import 指令是用來載入 module 的，如果需要，也會順道做編譯的事。但 import 指令，還會做一件重要的事情就是把 import 的那個 module 的代碼執行一遍，這件事情很重要。Python 是解釋執行的，連函數都是執行的時候才創建的。如果不把那個 module 的代碼執行一遍，那麼 module 裡面的函數都沒法創建，更別提去調用這些函數了。

執行代碼的另外一個重要作用，就是在這個 module 的命名空間中，創建模塊內定義的函數和各種對象的符號名稱（也就是變數名），並將其綁定到對象上，這樣其他 module 才能通過變數名來引用這些對象。

Python 虛擬機還會將已經 import 過的 module 緩存起來，放到一個全局 module 集合 sys.modules 中。這樣做有一個好處，即如果程序的在另一個地方再次 import 這個模塊，Python 虛擬機只需要將全局 module 集合中緩存的那個 module 對象返回即可。

你現在一定想到了 sys.modules 是一個 dict 對象，可以通過 type(sys.modules) 來驗證

多線程

demo.py 這個例子並沒有用到多線程，但還是有必要提一下。

在提到多線程的時候，往往要關注線程如何同步，如何訪問共享資源。Python 是通過一個全局解釋器鎖 GIL（Global Interpreter Lock）來實現線程同步的。當 Python 程序只有單線程時，並不會啟用 GIL，而當用戶創建了一個 thread 時，表示要使用多線程，Python 解釋器就會自動激活 GIL，並創建所需要的上下文環境和數據結構。

Python 位元組碼解釋器的工作原理是按照指令的順序一條一條地順序執行，Python 內部維護著一個數值，這個數值就是 Python 內部的時鐘，如果這個數值為 N，則意味著 Python 在執行了 N 條指令以後應該立即啟動線程調度機制，可以通過下面的代碼獲取這個數值。

import syssys.getcheckinterval() # 100

線程調度機制將會為線程分配 GIL，獲取到 GIL 的線程就能開始執行，而其他線程則必須等待。由於 GIL 的存在，Python 的多線程性能十分低下，無法發揮多核 CPU 的優勢，性能甚至不如單線程。因此如果你想用到多核 CPU，一個建議是使用多進程。

垃圾回收

在講到垃圾回收的時候，通常會使用引用計數的模型，這是一種最直觀，最簡單的垃圾收集技術。Python 同樣也使用了引用計數，但是引用計數存在這些缺點：

• 頻繁更新引用計數會降低運行效率
• 引用計數無法解決循環引用問題

Python 在引用計數機制的基礎上，使用了主流垃圾收集技術中的標記——清除和分代收集兩種技術。

關於垃圾回收，可以參考

http://hbprotoss.github.io/posts/pythonla-ji-hui-shou-ji-zhi.html