Python + debugger = PDB! Poszukajmy Tych Insektów

Jarosław Piszczała
02 Apr, 2020
02 Apr, 2020
- Interpreter

Na problemy - printuj wszystko. To sposób rozwiązywania problemów znany nam wszystkim. Mnie też mimo wszystko zdarza się to robić (Gynvael Coldwind także przyznaje, że jest to dobra metoda). Jednak czasem to za mało. Ilość danych, których potrzebujemy do weryfikacji, zaczyna być coraz dłuższa. Na takie problemy mamy Python Debugger!

Python Debugger

PDB to interaktywny debugger kodu źródłowego języka Python. Pozwala nam na ustawianie w kodzie tzw. breakpoint czyli miejsc, w których chcemy sprawdzić, co się dzieje.

Użycie

Przypuśćmy, że mamy taki kod jak poniżej. Po uruchomieniu tego skryptu, w terminalu otrzymamy wyjątek AssertionError. Pojawia się, gdyż logika użyta w instrukcji assert jest niepoprawna, i w jej wyniku otrzymaliśmy False. Wstępnie wygląda na to, że nasza funkcja zwraca niepoprawną wartość.

1
    def lower_camel_case(string: str) -> str:
2
        words = string.split(" ")
3
        title_words = [w.title() for w in words]
4
        new_string = "".join(title_words)
5
        return new_string
6

7
    result = lower_camel_case("simple function name")
8
    assert result == "simpleFunctionName"

1
    Traceback (most recent call last):
2
      File "/home/jarek/Playground/blog_entry/debug.py", line 7, in <module>
3
        assert result == "simpleFunctionName"
4
    AssertionError:

W pierwszej kolejności skorzystajmy z debuggera! Aby go wywołać, musimy w naszym kodzie zostawić tzw. pułapkę. W przypadku Pythona jest to funkcja breakpoint() lub import pdb; pdb.set_trace() dla wersji pythona < 3.7. Następnie uruchamiamy skrypt ponownie tak jak wcześniej.

1
    def lower_camel_case(string: str) -> str:
2
        words = string.split(" ")
3
        title_words = [w.title() for w in words]
4
        new_string = "".join(title_words)
5
        breakpoint()
6
        return new_string
7

8
    result = lower_camel_case("simple function name")
9
    assert result == "simpleFunctionName"

Terminal się zatrzymał i nie wywołał wyjątku. Jednak to, co widać w terminalu, jest czymś innym niż to, do czego się przyzwyczailiśmy.

1
    > /home/jarek/Playground/blog_entry/debug.py(6)lower_camel_case()
2
    -> return new_string
3
    (Pdb)

W pierwszej linii dostajemy informacje o pliku, w którym jesteśmy, linii, która zostanie wywołana jako następna oraz funkcja, w której ciele się znajdujemy. Następna linia to kod, który zostanie wykonany jako kolejny. Na koniec (Pdb), które jest znakiem zachęty. System w ten sposób oczekuje na wprowadzenie danych przez użytkownika. A co takiego użytkownik może?

Komendy

Po pierwsze komendy. Po wpisaniu help otrzymamy całą tabelę komend. Dla użytkowników gdb komendy te prawdopodobnie nie będą zaskoczeniem. Aby przeczytać o komendach, możemy użyć komendy help <komenda>.

1
    (Pdb) help
2

3
    Documented commands (type help <topic>):
4
    ========================================
5
    EOF    c          d        h         list      q        rv       undisplay
6
    a      cl         debug    help      ll        quit     s        unt
7
    alias  clear      disable  ignore    longlist  r        source   until
8
    args   commands   display  interact  n         restart  step     up
9
    b      condition  down     j         next      return   tbreak   w
10
    break  cont       enable   jump      p         retval   u        whatis
11
    bt     continue   exit     l         pp        run      unalias  where
12

13
    Miscellaneous help topics:
14
    ==========================
15
    exec  pdb

Dla przykładu sprawdziliśmy, czym jest komenda pp, która pomaga prezentować skomplikowane dane w czytelniejszy sposób.

1
    (Pdb) help pp
2
    pp expression
3
            Pretty-print the value of the expression.

Python Expression

Jedna z ważniejszych rzeczy, która ma zastąpić nasze print. Dzięki temu możemy sprawdzać zmienne, ale także wykonywać jednolinijkowy kod pythonowy. Możemy podejrzeć zmienną words. Następnie sprawdzamy, co ukrywa się pod zmienną title_words. Już widzimy, gdzie jest problem, jednak szukajmy dalej. Zmienna new_string to wartość, którą zwrócimy z funkcji, i która jest niepoprawna.

1
    (Pdb) words
2
    ['simple', 'function', 'name']
3
    (Pdb) pp title_words
4
    ['Simple', 'Function', 'Name']
5
    (Pdb) new_string
6
    'SimpleFunctionName'
7
    (Pdb) words[0]
8
    'simple'
9
    (Pdb) title_words[1:]
10
    ['Function', 'Name']
11
    (Pdb) [words[0], *title_words[1:]]
12
    ['simple', 'Function', 'Name']

Ponieważ pdb pozwala nam na jednolinijkowy kod Pythonowy, to możemy zacząć projektować poprawkę. Po pierwsze spróbujmy wyciąć część listy, która jest poprawna. Następnie sklejmy je z pierwszy słowem, które nie powinno być przekształcone. Wygląda na to, że znaleźliśmy miejsce problemu oraz napisaliśmy rozwiązanie.

Interpreter

Jeżeli jednak sprawdzanie danych to dla nas mało, możemy wejść do interpretera pythona, w którym możemy operować już na zmiennych czy importować biblioteki. Do tego użyjemy komendy interact.

1
    (Pdb) interact
2
    *interactive*
3
    >>> help
4
    Type help() for interactive help, or help(object) for help about object.
5
    >>> new_string="somethingElse"
6
    >>> new_string
7
    'somethingElse'
8
    >>> exit
9
    Use exit() or Ctrl-D (i.e. EOF) to exit
10
    >>>
11
    now exiting InteractiveConsole...
12
    (Pdb) new_string
13
    'SimpleFunctionName'

Aby opuścić ten widok, należy wywołać funkcje exit() lub użyć skrótu Ctrl+D. Pamiętajmy, że zmiany w zmiennych wykonane tam, nie wpłyną na nasz skrypt.

Wyjście

Mamy dwie metody wyjścia z debuggera w zależności od tego, jak chcemy wynik osiągnąć. Użycie exit() spowoduje wygenerowanie wyjątku BdbQuit.

1
    (Pdb) exit()
2
    Traceback (most recent call last):
3
      File "/home/jarek/Playground/blog_entry/debug.py", line 8, in <module>
4
        result = lower_camel_case("simple function name")
5
      File "/home/jarek/Playground/blog_entry/debug.py", line 6, in lower_camel_case
6
        return new_string
7
      File "/home/jarek/Playground/blog_entry/debug.py", line 6, in lower_camel_case
8
        return new_string
9
      File "/home/jarek/.pyenv/versions/3.9.0a4/lib/python3.9/bdb.py", line 88, in trace_dispatch
10
        return self.dispatch_line(frame)
11
      File "/home/jarek/.pyenv/versions/3.9.0a4/lib/python3.9/bdb.py", line 113, in dispatch_line
12
        if self.quitting: raise BdbQuit
13
    bdb.BdbQuit

Aby wyjść z debuggera i kontynuować działanie naszego kodu należy użyć komendy continue. Spowoduje ona, że nasz kod będzie kontynuować działanie - w naszym przypadku wygeneruje błąd, ponieważ kod nie został poprawiony.

1
    (Pdb) continue
2
    Traceback (most recent call last):
3
      File "/home/jarek/Playground/blog_entry/debug.py", line 8, in <module>
4
        result = lower_camel_case("simple function name")
5
    AssertionError

Nawigacja

Największą siłą według mnie są komendy do nawigacji. Aby je pokazać, zmienimy miejsce, w którym uruchomimy nasz debugger.

Komendy te pozwalają poruszać się krokowo po naszym kodzie. Dzięki temu, mamy możliwość weryfikacji tego co dzieje się w środowisku po wywołaniu kolejnych linii kodu.

1
    def lower_camel_case(string: str) -> str:
2
        words = string.split(" ")
3
        title_words = [w.title() for w in words]
4
        new_string = "".join(title_words)
5
        return new_string
6

7
    breakpoint()
8
    result = lower_camel_case("simple function name")
9
    assert result == "simpleFunctionName"

Po pierwsze komenda n(ext) , która wykonuje krok w przód. W naszym przypadku breakpoint ustawiony jest przed wywołaniem funkcji. Po wykonaniu komendy next zostanie wywołana linia z przypisaniem wartości funkcji lower_camel_case do zmiennej result. Kolejny krok n przenosi nas do linii z instrukcją assert, a ta wywołuje wyjątek.

1
    > /home/jarek/Playground/blog_entry/debug.py(8)<module>()
2
    -> result = lower_camel_case("simple function name")
3
    (Pdb) next
4
    > /home/jarek/Playground/blog_entry/debug.py(9)<module>()
5
    -> assert result == "simpleFunctionName"
6
    (Pdb) n
7
    Traceback (most recent call last):

Step

W naszym przypadku przyda się inny krok. Jest to step który robi krok w przód lub do środka jeżeli kolejna komenda to funkcja. W poniższym przykładzie, gdy użyjemy tej komendy, wejdziemy do kodu funkcji lower_camel_case. Zostanie to zasygnalizowane poprzez linię --Call--, oraz zatrzymanie się na definicji funkcji. Robiąc kolejne kroki, możemy zauważyć, że debugger wszedł głębiej do list comprehension.

1
    > /home/jarek/Playground/blog_entry/debug.py(8)<module>()
2
    -> result = lower_camel_case("simple function name")
3
    (Pdb) step
4
    --Call--
5
    > /home/jarek/Playground/blog_entry/debug.py(1)lower_camel_case()
6
    -> def lower_camel_case(string: str) -> str:
7
    (Pdb) step
8
    > /home/jarek/Playground/blog_entry/debug.py(2)lower_camel_case()
9
    -> words = string.split(" ")
10
    (Pdb) step
11
    > /home/jarek/Playground/blog_entry/debug.py(3)lower_camel_case()
12
    -> title_words = [w.title() for w in words]
13
    (Pdb)
14
    --Call--
15
    > /home/jarek/Playground/blog_entry/debug.py(3)<listcomp>()
16
    -> title_words = [w.title() for w in words]
17
    (Pdb) step
18
    > /home/jarek/Playground/blog_entry/debug.py(3)<listcomp>()
19
    -> title_words = [w.title() for w in words]
20
    (Pdb) step
21
    > /home/jarek/Playground/blog_entry/debug.py(3)<listcomp>()
22
    -> title_words = [w.title() for w in words]
23
    (Pdb) step
24
    > /home/jarek/Playground/blog_entry/debug.py(3)<listcomp>()
25
    -> title_words = [w.title() for w in words]
26
    (Pdb) step
27
    > /home/jarek/Playground/blog_entry/debug.py(3)<listcomp>()
28
    -> title_words = [w.title() for w in words]
29
    (Pdb) step
30
    --Return--
31
    > /home/jarek/Playground/blog_entry/debug.py(3)<listcomp>()->['Simple', 'Function', 'Name']
32
    -> title_words = [w.title() for w in words]
33
    (Pdb) step
34
    > /home/jarek/Playground/blog_entry/debug.py(4)lower_camel_case()
35
    -> new_string = "".join(title_words)
36
    (Pdb) step
37
    > /home/jarek/Playground/blog_entry/debug.py(5)lower_camel_case()
38
    -> return new_string
39
    (Pdb) step
40
    --Return--
41
    > /home/jarek/Playground/blog_entry/debug.py(5)lower_camel_case()->'SimpleFunctionName'
42
    -> return new_string
43
    (Pdb) step
44
    > /home/jarek/Playground/blog_entry/debug.py(9)<module>()
45
    -> assert result == "simpleFunctionName"
46
    (Pdb)

Gdy step wychodzi z funkcji, zostanie to nam zasygnalizowane poprzez linię --Return-- oraz wyświetlenia co zostało zwrócone z tej funkcji. W ten sposób widzimy, że wynikiem funkcji listcomp jest ['Simple', 'Function', 'Name'], a wynikiem naszej funkcji lower_camel_case jest 'SimpleFunctionName'.

Zaplecze

Nawigując po kodzie, można się pogubić. Aby nie skakać między debuggerem a naszym edytorem, możemy kod wyświetlić bezpośrednio w debuggerze. Służy do tego komenda list. Wyświetla ona okolice linii, która jest w kolejce do wywołania.

Mimo że debugger pozwala nam na odczyt danych, są pewne komendy, które usprawniają ich odczyt. Zdążyliśmy sobie powiedzieć już o komendzie pp przydatnej gdy mamy do czynienia z dużym słownikiem. Gdy nasza funkcja przyjmuje dużą ilość argumentów, dużo wygodniej jest użyć komendy args. Wyświetli ona wszystkie argumenty funkcji, w której ciele się znajdujemy.

1
    (Pdb) list
2
      1     def lower_camel_case(string: str) -> str:
3
      2         words = string.split(" ")
4
      3         title_words = [w.title() for w in words]
5
      4         new_string = "".join(title_words)
6
      5         breakpoint()
7
      6  ->     return new_string
8
      7
9
      8     result = lower_camel_case("simple function name")
10
      9     assert result == "simpleFunctionName"
11
    [EOF]
12
    (Pdb) args
13
    string = 'simple function name'

To na tyle, poznaliśmy debugger i podstawowe komendy, z których najczęściej korzystam w pracy zawodowej. Myślę, że taki zestaw będzie wystarczający na wszystkie przypadki, gdy print to za mało. Podziel się w komentarzach komendami, z których Ty najczęściej korzystasz!

FAQ

Jak mogę uniknąć wielokrotnego wpisywania next, aby przejść do kolejnych linii ? To męczące.

Właśnie dlatego, w kodzie możemy użyć wielu pułapek, i zostawiać je w miejscach, które nas interesują. Gdy użyjemy komendy c lub continue to kod będzie się wykonywał bez naszej kontroli do czasu, aż trafi na kolejną pułapkę.

Są dwa sposoby na ich stawianie. Jednym z nich jest użycie komendy break <numer linii>. Dzięki temu postawimy pułapki, będąc już w debuggerze. Użycie komendy break bez podania numeru, pozwoli wyświetlić wszystkie dotąd postawione pułapki (pułapki postawione w kodzie poprzez breakpoint() nie zostaną tutaj doliczone). Jeżeli chcielibyśmy usunąć nasze pułapki, należy użyć komendy clear.

1
    > /home/jarek/Playground/akademia_python_code/2020-04/debug.py(14)<module>()
2
    -> result = lower_camel_case("simple function name")
3
    (Pdb) break 9
4
    Breakpoint 1 at /home/jarek/Playground/akademia_python_code/2020-04/debug.py:9
5
    (Pdb) c
6
    > /home/jarek/Playground/akademia_python_code/2020-04/debug.py(9)lower_camel_case()
7
    -> new_string = "".join(title_words)
8
    (Pdb) title_words
9
    ['Simple', 'Function', 'Name']
10
    (Pdb) break
11
    Num Type         Disp Enb   Where
12
    1   breakpoint   keep yes   at /home/jarek/Playground/akademia_python_code/2020-04/debug.py:9
13
            breakpoint already hit 1 time
14
    (Pdb) clear
15
    Clear all breaks? y
16
    Deleted breakpoint 1 at /home/jarek/Playground/akademia_python_code/2020-04/debug.py:9

Drugi sposób, to wstawienie w naszym kodzie pułapek w kilku miejscach, tam gdzie chcemy. Należy pamiętać, aby je później usunąć, ale zdecydowanie pomaga to gdy robimy poprawki i uruchamiamy kilka razy nasz debugger. W przypadku komendy break musielibyśmy za każdym razem wpisywać na nowo nasze pułapki!

1
    def lower_camel_case(string: str) -> str:
2
        words = string.split(" ")
3
        title_words = [w.title() for w in words]
4
        new_string = "".join(title_words)
5
        breakpoint()
6
        return new_string
7

8

9
    breakpoint()
10
    result = lower_camel_case("simple function name")
11
    assert result == "simpleFunctionName"

1
    > /home/jarek/Playground/akademia_python_code/2020-04/debug.py(15)<module>()
2
    -> result = lower_camel_case("simple function name")
3
    (Pdb) c
4
    > /home/jarek/Playground/akademia_python_code/2020-04/debug.py(11)lower_camel_case()
5
    -> return new_string
6
    (Pdb) c
7
    Traceback (most recent call last):
8
      File "/home/jarek/Playground/akademia_python_code/2020-04/debug.py", line 15, in <module>
9
        result = lower_camel_case("simple function name")
10
    AssertionError

Jak wyjść z debugera gdy mam breakpoint w pętli, a exit() nie chce działać?

W sytuacji kryzysowej możemy skorzystać z os._exit, które spowoduje nagłe zakończenie działania skryptu:

1
    (Pdb) exit()
2
    Traceback (most recent call last):
3
      File "/home/jarek/Playground/blog_entry/debug.py", line 8, in <module>
4
        result = lower_camel_case("simple function name")
5
      File "/home/jarek/Playground/blog_entry/debug.py", line 6, in lower_camel_case
6
        return new_string
7
      File "/home/jarek/Playground/blog_entry/debug.py", line 6, in lower_camel_case
8
        return new_string
9
      File "/home/jarek/.pyenv/versions/3.9.0a4/lib/python3.9/bdb.py", line 88, in trace_dispatch
10
        return self.dispatch_line(frame)
11
      File "/home/jarek/.pyenv/versions/3.9.0a4/lib/python3.9/bdb.py", line 113, in dispatch_line
12
        if self.quitting: raise BdbQuit
13
    bdb.BdbQuit
14
    > /home/jarek/Playground/blog_entry/debug.py(6)lower_camel_case()
15
    -> return new_string
16
    (Pdb) import os; os._exit(0)

Python + debugger = PDB! Poszukajmy Tych Insektów

Python Debugger

Użycie

Komendy

Python Expression

Interpreter

Wyjście

Nawigacja

Next

Step

Zaplecze

FAQ

Similar Posts

Interpreter Python – Podstawy Których Możesz Nie Znać

Czytanie Tracebacków – Czy To Piekło Kiedyś Się Kończy?

O Obsłudze Wyjątków i Wyjątkach Słów Kilka