调试和分析Python脚本程序

调试技术和分析技术在Python开发中发挥着重要作用。调试器可以设置条件断点，帮助程序员分析所有代码。而分析器可以运行程序，并提供运行时的详细信息，同时也能找出程序中的性能瓶颈。在本章中，我们将学习Python调试器常用的pdb、cProfile模块和用于计算Python程序运行时间的timeit模块。

本章将介绍以下主题。

• Python调试技术。
• 错误处理（异常处理）。
• 调试工具。
• 调试基本的程序崩溃。
• 分析程序并计时。
• 使程序运行得更快。

1.1　什么是调试

调试（debugging）是暂停正在运行的程序，并解决程序中出现的问题的过程。调试Python程序非常简单，Python调试器会设置条件断点，并一次执行一行代码。接下来我们将使用Python标准库中的pdb模块调试Python程序。

Python调试技术

我们可以使用多种方法调试Python程序，以下是调试Python程序的4种方法。

• print语句：这是了解程序运行时状况的一种简单方法，它可以检查程序执行的过程。
• 日志（logging）：这类似于print语句，但可以输出更多上下文信息，所以我们十分有必要学习它。
• pdb调试器：这是一种常用的调试技术。pdb的优点是使用非常方便，只需要一个Python解释器，一段Python程序，就可以在命令行使用pdb了。
• IDE调试器：IDE集成了调试器，它可以让我们执行其编写的代码，并在需要时检查正在运行的程序。

2.2　错误处理（异常处理）

本节我们将学习如何处理Python的异常。首先，什么是异常？异常是指程序执行期间发生的错误。每当发生错误时，Python都会生成一个异常。异常将会被try...except语句块处理。如果程序无法处理某些异常，就会输出错误消息。现在我们来看一些异常示例。

打开终端，启动Python3交互式控制台，以下是一些异常示例。

student@ubuntu:~$ python3
Python 3.5.2 (default, Nov 23 2017, 16:37:01)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> 50 / 0


Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>>
>>> 6 + abc*5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'abc' is not defined
>>>
>>> 'abc' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly
>>>
>>> import abcd
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named 'abcd'
>>>

下面我们学习如何处理异常。

每当Python程序中发生错误时，都会抛出异常。我们也可以使用raise关键字强制抛出异常。

try...except语句块可以用来处理异常。在try语句块中，编写可能抛出异常的代码，而在except语句块中，则为该异常编写一个解决方案。

try...except语句块的语法如下所示。

try:
            statement(s)
except:
            statement(s)

一个try语句块可以对应多个except语句块。我们也可以通过在except关键字后面输入异常的名称来处理特定的异常。处理特定的异常的语法如下所示。

try:
            statement(s)
except exception_name:
            statement(s)

现在创建一个脚本，命名为exception_example.py，该脚本将捕获ZeroDivisionError异常。在脚本中添加如下代码。

a = 35
b = 57
try:
            c = a + b
            print("The value of c is: ", c) 
            d = b / 0
            print("The value of d is: ", d)
except:
            print("Division by zero is not possible")

print("Out of try...except block")

运行该脚本，输出的信息如下所示。

student@ubuntu:~$ python3 exception_example.py
The value of c is:  92
Division by zero is not possible
Out of try...except block

12.3　调试工具

Python拥有许多调试工具，如下所示。

• winpdb。
• pydev。
• pydb。
• pdb。
• gdb。
• pydebug。

在本节中，我们将学习如何使用Python的pdb调试器。pdb模块是Python标准库的一部分，我们可以直接使用。

1.3.1　pdb调试器

Python程序使用pdb交互式源代码调试器来调试程序。pdb调试器可以设置程序断点并检查栈帧，同时列出源代码。

现在我们将了解如何使用pdb调试器。以下3种方法均可使用此调试器。

• 在解释器中运行。
• 在命令行中运行。
• 在Python脚本中使用。

现在创建一个脚本，命名为pdb_example.py，在该脚本中添加以下代码。

class Student:
            def __init__(self, std):
                        self.count = std
            def print_std(self):
                        for i in range(self.count):
                                    print(i)
                        return
if __name__ == '__main__':
            Student(5).print_std()

后面以此脚本为例学习Python调试，现在我们来看如何启动调试器。

1.3.2　在解释器中运行

使用run()函数或runeval()函数从Python交互式控制台中启动调试器。

启动Python3交互式控制台，运行以下命令即可。

$ python3

首先导入pdb_example脚本的名称和pdb模块。然后输入run()函数，并传递一个字符串表达式作为参数，该参数是传给Python解释器本身的，由Python解释器运行。

student@ubuntu:~$ python3
Python 3.5.2 (default, Nov 23 2017, 16:37:01)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> import pdb_example
>>> import pdb
>>> pdb.run('pdb_example.Student(5).print_std()')
> <string>(1)<module>()
(Pdb)

如果要继续调试，请在（Pdb）提示符后输入continue，然后按Enter键。如果想知道此处可以输入的选项，那么就在（Pdb）提示符后按两次Tab键。

输入continue后，就会得到以下输出。

student@ubuntu:~$ python3
Python 3.5.2 (default, Nov 23 2017, 16:37:01)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> import pdb_example
>>> import pdb
>>> pdb.run('pdb_example.Student(5).print_std()')
> <string>(1)<module>()
(Pdb) Continue
0
1
2
3
4
>>>

1.3.3　在命令行中运行

启动调试器最简单、最直接的方法是从命令行运行。此时脚本程序将作为调试器的输入。从命令行启动调试器的方法如下所示。

$ python3 -m pdb pdb_example.py

从命令行启动调试器时，源代码会被加载，然后停止在第一行代码。输入continue可以继续调试。输出的信息如下所示。

student@ubuntu:~$ python3 -m pdb pdb_example.py
> /home/student/pdb_example.py(1)<module>()
-> class Student:
(Pdb) continue
0
1
2
3
4
The program finished and will be restarted
> /home/student/pdb_example.py(1)<module>()
-> class Student:
(Pdb)

1.3.4　在Python脚本中使用

前两种方法会在Python程序开始时启动调试器，适合较短的脚本程序，但第三种方法比较适合非常长的脚本程序，即在脚本中使用set_trace()启动调试器。

现在我们修改pdb_example.py脚本，如下所示。

import pdb
class Student:
            def __init__(self, std):
                        self.count = std

            def print_std(self):
                        for i in range(self.count):
                                    pdb.set_trace()
                                    print(i)
                        return

if __name__ == '__main__':
            Student(5).print_std()

运行脚本程序，如下所示。

student@ubuntu:~$ python3 pdb_example.py
> /home/student/pdb_example.py(10)print_std()
-> print(i)
(Pdb) continue
0
> /home/student/pdb_example.py(9)print_std()
-> pdb.set_trace()
(Pdb)

set_trace()是一个Python函数，我们可以在程序中的任何位置调用它。

这就是使用调试器的3种方法。

1.4　调试基本程序崩溃的方法

本节我们将学习跟踪模块，跟踪模块可以跟踪程序的执行。每当Python程序崩溃时，我们可以查看崩溃的位置，并通过将其导入脚本，或从命令行启动来使用跟踪模块。

现在我们创建一个脚本，命名为trace_example.py，并添加以下代码。

class Student:
            def __init__(self, std):
                        self.count = std

            def go(self):
                        for i in range(self.count):
                                    print(i)
                        return
if __name__ == '__main__':
            Student(5).go()

运行脚本程序，如下所示。

student@ubuntu:~$ python3 -m trace --trace trace_example.py
 --- modulename: trace_example, funcname: <module>
trace_example.py(1): class Student:
 --- modulename: trace_example, funcname: Student
trace_example.py(1): class Student:
trace_example.py(2):   def __init__(self, std):
trace_example.py(5):   def go(self):
trace_example.py(10): if __name__ == '__main__':
trace_example.py(11):            Student(5).go()
 --- modulename: trace_example, funcname: init
trace_example.py(3):               self.count = std
 --- modulename: trace_example, funcname: go
trace_example.py(6):               for i in range(self.count):
trace_example.py(7):                           print(i)
0
trace_example.py(6):               for i in range(self.count):
trace_example.py(7):                           print(i)
1
trace_example.py(6):               for i in range(self.count):
trace_example.py(7):                           print(i)
2
trace_example.py(6):               for i in range(self.count):
trace_example.py(7):                           print(i)
3
trace_example.py(6):               for i in range(self.count):
trace_example.py(7):                           print(i)
4

因此，通过在命令行中使用trace --trace，我们就可以逐行跟踪程序。当程序崩溃时，我们就会了解崩溃时的信息。

1.5　分析程序并计时

分析程序意味着测量程序的运行时间，具体来说就是测量每个函数所花费的时间。Python的cProfile模块可以用来分析程序。

1.5.1　cProfile模块

如前所述，分析程序意味着测量程序的运行时间。现在我们使用Python的cProfile模块来分析程序。

我们创建一个脚本，命名为cprof_example.py，并在脚本中添加以下代码。

mul_value = 0
def mul_numbers( num1, num2 ):
            mul_value = num1 * num2
            print ("Local Value: ", mul_value)
            return mul_value
mul_numbers( 58, 77 )
print ("Global Value: ", mul_value)

运行脚本程序，如下所示。

student@ubuntu:~$ python3 -m cProfile cprof_example.py
Local Value:  4466
Global Value:  0
         6 function calls in 0.000 seconds
   Ordered by: standard name
    
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.000    0.000 cprof_example.py:1(<module>)
        1    0.000    0.000    0.000    0.000 cprof_example.py:2(mul_numbers)
        1    0.000    0.000    0.000    0.000 {built-in method builtins.exec}
        2    0.000    0.000    0.000    0.000 {built-in method builtins.print}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

如上，使用cProfile横线可以输出所有被调用函数所花费的时间。现在我们来看输出表格中列标题的含义。

• ncalls：调用次数。
• tottime：该函数花费的总时间。
• percall：该函数单次调用花费的平均时间，即tottime除以ncalls。
• cumtime：该函数和所有子函数花费的累计时间。
• percall：该函数单次调用包括其子函数花费的平均时间，即 cumtime 除以ncalls。
• filename:lineno（function）：每个函数调用的相关信息。

1.5.2　timeit模块

timeit也是一个Python模块，它可以为其中一部分Python脚本计时。我们可以从命令行调用timeit模块，也可以将timeit模块导入到脚本中。现在我们编写一个脚本来为一段代码计时。创建一个脚本，命名为timeit_example.py，并添加以下代码。

import timeit
prg_setup = "from math import sqrt"
prg_code = '''
def timeit_example():
            list1 = []
            for x in range(50):
                        list1.append(sqrt(x))
'''
#时间声明
print(timeit.timeit(setup = prg_setup, stmt = prg_code, number = 10000))

我们可以使用timeit模块去测量特定代码的性能，也可以使用该模块轻松编写测试代码，并应用到需要单独测试的代码段上。被测试的代码默认运行100万次，而测试代码只运行1次。

1.6　使程序运行得更快

有多种方法可以使Python程序运行得更快，以下是一些常用方法。

• 分析代码，并找出其瓶颈。
• 尽量使用内置函数和库，减少循环的使用，以降低解释器的开销。
• 尽量避免使用全局变量，因为Python访问全局变量非常慢。
• 尽量使用已有的程序包和模块。

1.7　总结

在本章中，我们了解了调试程序和分析程序的重要性，也学习了各种调试程序的技术，包括使用pdb调试器处理Python的异常。在分析程序并实现计时功能时，学习了如何使用Python的cProfile和timeit模块。最后还学习了如何使程序运行得更快。

在第3章中，我们将学习Python的单元测试，即如何创建和使用单元测试。

1.8　问题

1．通常使用哪个模块调试Python程序？

2．学习如何使用ipython的所有别名和魔术函数。

3．什么是全局解释器锁（GIL）？

4．环境变量PYTHONSTARTUP、PYTHONCASEOK和PYTHONHOME的用途是什么？

5．以下代码的输出是什么？

    def foo(k):
        k = [1]
    q = [0]
    foo(q)
    print(q)

a）[0]

b）[1]

c）[1,0]

d）[0,1]

6．以下哪项是无效的变量名？

a）my_string_1

b）1st_string

c）foo

d）_