偵錯工具
在撰寫 Python 程式的時候，如果想要知道某個變數的值或是函數執行的結果，常會使用 print() 函數來印出點東西來看看。這樣雖然簡單、直覺，但當專案變複雜的時候，只靠 print() 函數抓問題的效率可能不太夠。Python 有一個內建的偵錯器叫做 pdb，可以幫助我們更有效率地找出問題。
什麼是偵錯器
偵錯器（Debugger）是一種用來找出程式碼中錯誤的工具。當我們的程式碼出現問題時，我們可以透過偵錯器在程式碼的特定位置設置「中斷點（Breakpoint）」，當 Python 程式走到中斷點時，程式就像被按暫停一樣，我們就可以趁這個機會做我們想做的事...我是指檢查變數的值、逐步執行程式碼、找出問題所在。
使用 Pdb 偵錯器
先上一段程式碼：
import math
square = lambda n: math.pow(n, 2)
def calc_numbers(numbers, fn):
data = []
for n in numbers:
data.append(fn(n))
return data
numbers = [1, 4, 5, 0, 9, 5, 2, 7]
print(calc_numbers(numbers, square))
如果各位在基礎篇都學的不錯的話，上面這段程式碼應該難不倒大家，簡單的說就是把某個串列跟函數傳給 calc_numbers() 函數，最後得到一新的串列。
之前如果我們想要知道 calc_numbers() 函數到底接了什麼參數，或是串列 data 的值是什麼，我們可能會使用 print() 函數：
def calc_numbers(numbers, fn):
data = []
print(data, members) # <-- 在這裡印出來
for n in numbers:
# ... 略...
如果使用 Debugger 的話，可以在想要停下來的地方加上 breakpoint() 函數，像這樣：
def calc_numbers(numbers, fn):
data = []
breakpoint() # <-- 在這裡設定中斷點
for n in numbers:
data.append(fn(n))
return data
這樣待會執行到這行程式的時候就會停下來，像這樣：
$ python demo.py
> /private/tmp/demo.py(8)calc_numbers()
-> for n in numbers:
(Pdb)
這裡看到的 demo.py(8) 表示目前程式停在 demo.py 這個檔案的第 7 行，然後即將執行第 8 行的 for 迴圈，而前面出現的 (Pdb) 提示字元表示目前我們正在 Debugger 的環境裡。先使用 h 或 help 指令看看在 Pdb 裡有哪些指令可以用：
(Pdb) h
Documented commands (type help <topic>):
========================================
EOF c d h list q rv undisplay
a cl debug help ll quit s unt
alias clear disable ignore longlist r source until
args commands display interact n restart step up
b condition down j next return tbreak w
break cont enable jump p retval u whatis
bt continue exit l pp run unalias where
雖然指令看起來好像有點多，但有些指令是同一個，只是完整跟簡寫的差別而已，而且其實常用的指令就只有那幾個...
觀察狀態
我們先用最簡單的 p 指令來印點東西：
(Pdb) p data
[]
(Pdb) p fn
<function <lambda>>
p 指令就是 print 的意思，表示可以把某個值印出來看看。可以看到在這個當下，串列 data 才剛剛被初始化，所以還是空的。使用 l 或 list 指令，可以看到目前所在位置附近的程式碼：
(Pdb) l
3 square = lambda n: math.pow(n, 2)
4
5 def calc_numbers(numbers, fn):
6 data = []
7 breakpoint()
8 -> for n in numbers:
9 data.append(fn(n))
10
11 return data
12
13
(Pdb) l
14 numbers = [1, 4, 5, 0, 9, 5, 2, 7]
15 print(calc_numbers(numbers, square))
[EOF]
l 指令會印出目前所在位置的前後幾行程式碼，如果再執行一次會再往下繼續印，最後一行的 [EOF] 表示已經到底了（End Of File）。如果想再回去看剛剛的程式碼，使用 l 指令的時候加上行號，例如 l 10 就會印出第 10 行附近的程式碼，除了行號也可以使用 . 印出目前所在位置的程式碼。
另一個跟 l 有點像的，是 ll 或是 longlist 指令，這會印出整個函數的程式碼：
(Pdb) ll
5 def calc_numbers(numbers, fn):
6 data = []
7 breakpoint()
8 -> for n in numbers:
9 data.append(fn(n))
10
11 return data
執行程式
Pdb 不是只能讓我們觀察狀態，我們也可以用它來執行程式碼。透過 n 或 next 指令，可以執行下一行程式碼：
(Pdb) n
> /private/tmp/demo.py(9)calc_numbers()
-> data.append(fn(n))
這表示我們剛剛執行了第 8 行的 for 迴圈，接下來準備執行第 9 行的程式碼。這時可再使用 l 指令檢視一下：
(Pdb) l
4
5 def calc_numbers(numbers, fn):
6 data = []
7 breakpoint()
8 for n in numbers:
9 -> data.append(fn(n))
10
11 return data
12
13
14 numbers = [1, 4, 5, 0, 9, 5, 2, 7]
前面的箭頭表示準備執行第 9 行，猜猜看如果印出 data 會看到什麼：
(Pdb) p data
[]
這時候的 data 是空的，因為我們還沒有執行 data.append(fn(n)) 這行程式碼。如果這時再執行一次 n 指令，會進到下一個迴圈，data 的值就會變的不一樣了：
(Pdb) n
> /private/tmp/demo.py(8)calc_numbers()
-> for n in numbers:
(Pdb) p data
[1.0]
可以看到目前 data 裡面只有一個元素，這是因為我們剛剛執行了 data.append(fn(n)) 這行程式碼，所以 data 裡面有了一個元素。
除了看到目前所在位置可以檢視的變數外，我們也可使用 u 或 up 指令，往上一層看看：
(Pdb) u
> /private/tmp/demo.py(15)<module>()
-> print(calc_numbers(numbers, square))
(Pdb) p data
*** NameError: name 'data' is not defined
因為現在往上一層了，對外面來說 data 變數是不存在的。可以往上也就可以往下一層，是使用 d 或 down 指令：
(Pdb) d
> /private/tmp/demo.py(8)calc_numbers()
-> for n in numbers:
(Pdb) p data
[1.0]
這樣就又回到原本的位置了。剛才的 n 指令是執行下一行程式碼，如果我想要看看那個 fn(n)，也就是傳進去的 square 函數在什麼的話，可使用 s 或 step 指令：
(Pdb) s
--Call--
> /private/tmp/demo.py(3)<lambda>()
-> square = lambda n: math.pow(n, 2)
可以看到現在箭頭走到 square 這個函數裡了，接著可以繼續 n：
(Pdb) n
> /private/tmp/demo.py(3)<lambda>()
-> square = lambda n: math.pow(n, 2)
(Pdb) n
--Return--
> /private/tmp/demo.py(3)<lambda>()->16.0
-> square = lambda n: math.pow(n, 2)
(Pdb) n
> /private/tmp/demo.py(8)calc_numbers()
-> for n in numbers:
n 幾次之後，會看到 --Return--，這表示我們準備要已經離開了 square 函數並且有回傳值 2，再繼續 n 就會回到原本的位置。
因為這裡是一個 for 迴圈，所以執行 n 的時候會一直在迴圈裡轉啊轉的，直到轉完為止。如果我想要快一點跳到某一行，可使用 until 指令並且在後面加上行數：
(Pdb) until 11
> /private/tmp/demo.py(11)calc_numbers()
-> return data
(Pdb) p data
[1.0, 16.0, 25.0, 0.0, 81.0, 25.0, 4.0, 49.0]
這樣 Pdb 會執行到行數大於或等於第 11 行的程式碼，這樣就可以結束這個迴圈，這時候也可以看到 data 串列裡的值也都算完了。
另外兩個常用來控制流程的指令，一個是 c 或 continue，這個指令會讓程式一直執行到下一個中斷點，不過因為我們的範例裡只有一個中斷點，所以會直接執行到程式結束為止。另一個指令是 q 或是 quit，這個指令會直接讓 Pdb 結束並且離開程式。
修改變數值
在 Pdb 中除了可以檢視資料，在程式執行過程也可以修改變數的值，這就是 print() 函數做不到的事。一樣的範例，我重新執行一次程式：
$ python demo.py
> /private/tmp/demo.py(8)calc_numbers()
-> for n in numbers:
(Pdb) p data
[]
(Pdb) data = ['Hey']
(Pdb) c
['Hey', 1.0, 16.0, 25.0, 0.0, 81.0, 25.0, 4.0, 49.0]
在 Pdb 裡可以寫任何 Python 的程式碼，也可以直接修改變數的值。這裡我把 data 的值改成 ['Hey']，然後再繼續執行 c 指令執行到程式結束，最後看到 data 的結果就會變的不一樣了。
動態設定中斷點
除了直接在程式碼裡加入 breakpoint() 函數設定中斷點外，我們也可以在 Pdb 執行的過程使用 b 或 break 指令動態加入中斷點。我再重新執行一次同樣的範例：
$ python demo.py
> /private/tmp/demo.py(8)calc_numbers()
-> for n in numbers:
(Pdb) b 11
Breakpoint 1 at /private/tmp/demo.py:11
在 b 或 break 指令後面 加上數字，表示要在第幾行設定中斷點，例如 b 9 指令就是在第 9 行設定一個中斷點。如果只執行 b 或 break 指令沒加任何數字的話，會列出目前動態加了哪些中斷點：
(Pdb) b
Num Type Disp Enb Where
1 breakpoint keep yes at /private/tmp/demo.py:11
以看到目前有哪些中斷點。如果要刪除中斷點，可以使用 cl 或 clear 指令：
(Pdb) cl 1
Deleted breakpoint 1 at /private/tmp/demo.py:11
(Pdb) cl
Clear all breaks? y
cl 1 指令就是刪除第 1 個中斷點，如果只執行 cl 或 clear 指令的話，會問你是否要刪除所有中斷點，如果輸入 y 就會刪除所有中斷點。
是說，目前的範例都是我們可以修改的，萬一遇到一個不是自己寫的程式碼，例如是第三方套件，或是我們沒有權限在程式碼裡加入 breakpoint() 函數怎麼設定中斷點？我們可以在執行程式的時候，加上 -m pdb 參數，這樣 Python 會在程式執行的時候自動進入 Pdb 模式：
$ python -m pdb demo.py
> /private/tmp/demo.py(1)<module>()
-> import math
(Pdb) l
1 -> import math
2
3 square = lambda n: math.pow(n, 2)
4
5 def calc_numbers(numbers, fn):
6 data = []
7 for n in numbers:
8 data.append(fn(n))
9
10 return data
11
可以看到程式在執行的時候自動進入 Pdb 模式，再搭配剛剛學會的 b 或 break 指令動態新增中斷點，就能追到我們想追的地方了，即使是別人寫的第三方套件或網站框架也一樣能追進去！
誰呼叫了這個函數？
一樣先上個範例：
def hi():
print("Hello Kitty")
def hey():
hi()
def hello():
hey()
hello()
hello() 函數呼叫了 hey()，hey() 呼叫了 hi()，如果想要知道 hi() 函數是被誰呼叫的，我知道以這個範例來說有點太簡單、太小看各位了，一眼直接就能看出來是誰呼叫的，但總之就當作這是一個練習吧！啟動並進入 Pdb 模式，並且在第 2 行設定一個中斷點，然後使用 c 或 continue 指令讓程式執行執行到中斷點：
$ python -m pdb demo.py
> /private/tmp/demo.py(1)<module>()
-> def hi():
(Pdb) b 2
Breakpoint 1 at /private/tmp/demo.py:2
(Pdb) c
> /private/tmp/demo.py(2)hi()
-> print("Hello Kitty")
接下來就是有趣的地方了，我們可以使用 w 或 where 指令來查看目前函數呼叫的堆疊是什麼樣子：
(Pdb) w
/Users/kaochenlong/.pyenv/versions/3.12.7/lib/python3.12/bdb.py(606)run()
-> exec(cmd, globals, locals)
<string>(1)<module>()
/private/tmp/demo.py(10)<module>()
-> hello()
/private/tmp/demo.py(8)hello()
-> hey()
/private/tmp/demo.py(5)hey()
-> hi()
> /private/tmp/demo.py(2)hi()
-> print("Hello Kitty")
在上面這個訊息的倒數第二行可以看到就是我們現在這個 hi() 函數，呼叫它的就是列在它上面的 hey() 函數，再往上是 hello() 函數，最後是全域的 <module>，這樣一路往上追，就能知道 hi() 函數是被誰呼叫的了。
常用指令整理
最後，我用表格整理一下常用的 Pdb 指令：
| 短指令 | 完整指令 | 說明 |
|---|---|---|
h | help | 顯示幫助訊息 |
p | 無 | 印出某個變數的值 |
l | list | 印出目前所在位置附近的程式碼 |
ll | longlist | 印出整個函數的程式碼 |
n | next | 執行下一行程式碼 |
s | step | 進入函數內部 |
u | up | 往上一層的函數 |
d | down | 往下一層的函數 |
unt | until | 執行到指定行數 |
c | continue | 繼續執行程式直到下一個中斷點 |
q | quit | 離開 Pdb 環境 |
b | break | 設定中斷點 |
cl | clear | 清除中斷點 |
w | where | 顯示目前的呼叫堆疊 |
不知道大家看到這裡，會認為 Debugger 比較好用嗎？還是覺得 print() 函數用的比較習慣？沒關係，Debugger 不是必需品，它只眾多偵錯工具的其中一種，如果你覺得 print() 比較好用就繼續用，我是說真的，不要因為這個章節介紹了 Debugger 就覺得這東西好棒棒，並沒有，你用的順手就好。
我常會用近視眼鏡舉例，假設你有近視，也配了一副眼鏡，你認為什麼時候會把眼鏡戴起來？如果近視度數不深或是看近的東西還算看的清楚，自然不需要戴眼鏡；但如果想要看遠方的事物，開始感覺看不清楚了，就會開始找你的眼鏡放在哪裡了。Debugger 也是一樣的道理，你現在用不到它表示你遇到的問 題可能還不夠複雜，等哪天你突然發現它好用的時候你自然就會開始用它了（我知道這很像廢話）。