对于开发者来说，最实用的帮助莫过于帮助他们编写代码文档了。pydoc模块可以根据源代码中的docstrings为任何可导入模块生成格式良好的文档。Python包含了两个测试框架来自动测试代码以及验证代码的正确性：1）doctest模块，该模块可以从源代码或独立文件的例子中抽取出测试用例。2）unittest模块，该模块是一个全功能的自动化测试框架，该框架提供了对测试准备(test fixtures), 预定义测试集(predefined test suite)以及测试发现(test discovery)的支持。
trace模块可以监控Python执行程序的方式，同时生成一个报表来显示程序的每一行执行的次数。这些信息可以用来发现未被自动化测试集所覆盖的程序执行路径，也可以用来研究程序调用图，进而发现模块之间的依赖关系。编写并执行测试可以发现绝大多数程序中的问题，Python使得debug工作变得更加简单，这是因为在大部分情况下，Python都能够将未被处理的错误打印到控制台中，我们称这些错误信息为traceback。如果程序不是在文本控制台中运行的，traceback也能够将错误信息输出到日志文件或是消息对话框中。当标准的traceback无法提供足够的信息时，可以使用cgitb 模块来查看各级栈和源代码上下文中的详细信息，比如局部变量。cgitb模块还能够将这些跟踪信息以HTML的形式输出，用来报告web应用中的错误。
一旦发现了问题出在哪里后，就需要使用到交互式调试器进入到代码中进行调试工作了，pdb模块能够很好地胜任这项工作。该模块可以显示出程序在错误产生时的执行路径，同时可以动态地调整对象和代码进行调试。当程序通过测试并调试后，下一步就是要将注意力放到性能上了。开发者可以使用profile以及timit模块来测试程序的速度，找出程序中到底是哪里很慢，进而对这部分代码独立出来进行调优的工作。Python程序是通过解释器执行的，解释器的输入是原有程序的字节码编译版本。这个字节码编译版本可以在程序执行时动态地生成，也可以在程序打包的时候就生成。compileall模块可以处理程序打包的事宜，它暴露出了打包相关的接口，该接口能够被安装程序和打包工具用来生成包含模块字节码的文件。同时，在开发环境中，compileall模块也可以用来验证源文件是否包含了语法错误。
在源代码级别，pyclbr模块提供了一个类查看器，方便文本编辑器或是其他程序对Python程序中有意思的字符进行扫描，比如函数或者是类。在提供了类查看器以后，就无需引入代码，这样就避免了潜在的副作用影响。
文档字符串与doctest模块
如果函数，类或者是模块的第一行是一个字符串，那么这个字符串就是一个文档字符串。可以认为包含文档字符串是一个良好的编程习惯，这是因为这些字符串可以给Python程序开发工具提供一些信息。比如，help()命令能够检测文档字符串，Python相关的IDE也能够进行检测文档字符串的工作。由于程序员倾向于在交互式shell中查看文档字符串，所以最好将这些字符串写的简短一些。例如
# mult.py
class Test:
"""
>>> a=Test(5)
>>> a.multiply_by_2()
10
"""
def __init__(self, number):
self._number=number
def multiply_by_2(self):
return self._number*2# testmult.py
import mult, doctest
doctest.testmod(mult, verbose=True)
在这段代码中，doctest.testmod(module)会执行特定模块的测试，并且返回测试失败的个数以及测试的总数目。如果所有的测试都通过了，那么不会产生任何输出。否则的话，你将会看到一个失败报告，用来显示期望值和实际值之间的差别。如果你想看到测试的详细输出，你可以使用testmod(module, verbose=True).
如果不想新建一个单独的测试文件的话，那么另一种选择就是在文件末尾包含相应的测试代码：
if __name__ == '__main__':
import doctest
doctest.testmod()python -m doctest -v mult.py单元测试与unittest模块
如果想更加彻底地对程序进行测试，我们可以使用unittest模块。通过单元测试，开发者可以为构成程序的每一个元素（例如，独立的函数，方法，类以及模块）编写一系列独立的测试用例。当测试更大的程序时，这些测试就可以作为基石来验证程序的正确性。当我们的程序变得越来越大的时候，对不同构件的单元测试就可以组合起来成为更大的测试框架以及测试工具。这能够极大地简化软件测试的工作，为找到并解决软件问题提供了便利。
# splitter.py
import unittest
def split(line, types=None, delimiter=None):
"""
Splits a line of text and optionally performs type conversion.
"""
fields = line.split(delimiter)
if types:
fields = [ ty(val) for ty,val in zip(types,fields) ]
return fields
class TestSplitFunction(unittest.TestCase):
def setUp(self):
# Perform set up actions (if any)
pass
def tearDown(self):
# Perform clean-up actions (if any)
pass
def testsimplestring(self):
r = split('GOOG 100 490.50')
self.assertEqual(r,['GOOG','100','490.50'])
def testtypeconvert(self):
r = split('GOOG 100 490.50',[str, int, float])
self.assertEqual(r,['GOOG', 100, 490.5])
def testdelimiter(self):
r = split('GOOG,100,490.50',delimiter=',')
self.assertEqual(r,['GOOG','100','490.50'])
# Run the unittests
if __name__ == '__main__':
unittest.main()qixuan@ubuntu:~/qixuan02$ python splitter.py
...
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
Python调试器与pdb模块
Python在pdb模块中包含了一个简单的基于命令行的调试器。pdb模块支持事后调试，栈帧探查，断点，单步调试以及代码审查。能够在程序中调用调试器，或是在交互式的Python终端中进行调试工作。在所有启动调试器的函数中，函数set_trace()也许是最简易实用的了。如果在复杂程序中发现了问题，可以在代码中插入set_trace()函数，并运行程序。当执行到set_trace()函数时，这就会暂停程序的执行并直接跳转到调试器中，这时候你就可以大展手脚开始检查运行时环境了。当退出调试器时，调试器会自动恢复程序的执行。
假设你的程序有问题，你想找到一个简单的方法来对它进行调试。
如果你的程序崩溃时报了一个异常错误，那么你可以用python3 -i someprogram.py这个命令来运行你的程序，这能够很好地发现问题所在。-i选项表明只要程序终结就立即启动一个交互式shell。在这个交互式shell中，你就可以很好地探查到底发生了什么导致程序的错误。例如，如果你有以下代码：
def function(n):
return n + 10
function("Hello")qixuan@ubuntu:~/qixuan02$ python3 -i sample.py
Traceback (most recent call last):
File "sample.py", line 4, in <module>
function("Hello")
File "sample.py", line 2, in function
return n + 10
TypeError: Can't convert 'int' object to str implicitly>>> import pdb
>>> pdb.pm()
> /home/qixuan/qixuan02/sample.py(2)function()
-> return n + 10
(Pdb) w
/home/qixuan/qixuan02/sample.py(4)<module>()
-> function("Hello")
> /home/qixuan/qixuan02/sample.py(2)function()
-> return n + 10
(Pdb) print (n)
Hello
(Pdb) q
程序分析
profile模块和cProfile模块可以用来分析程序。它们的工作原理都一样，唯一的区别是，cProfile模块是以C扩展的方式实现的，如此一来运行的速度也快了很多，也显得比较流行。这两个模块都可以用来收集覆盖信息（比如，有多少函数被执行了），也能够收集性能数据。对一个程序进行分析的最简单的方法就是运行这个命令：python -m cProfile someprogram.py
此外，也可以使用profile模块中的run函数：run(command [, filename])
qixuan@ubuntu:~/qixuan02$ python3 -m cProfile splitter.py
----------------------------------------------------------------------
Ran 0 tests in 0.000s
OK
12340 function calls (12059 primitive calls) in 0.208 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
22 0.000 0.000 0.000 0.000 <frozen importlib._bootstrap>:1000(__init__)
20 0.000 0.000 0.002 0.000 <frozen importlib._bootstrap>:1019(init_module_attrs)
20 0.000 0.000 0.003 0.000 <frozen importlib._bootstrap>:1099(create)
20/1 0.000 0.000 0.197 0.197 <frozen importlib._bootstrap>:1122(_exec)
2 0.000 0.000 0.000 0.000 <frozen importlib._bootstrap>:1156(_load_backward_compatible)
22/1 0.001 0.000 0.197 0.197 <frozen importlib._bootstrap>:1186(_load_unlocked)
22 0.000 0.000 0.000 0.000 <frozen importlib._bootstrap>:1243(find_spec)
2 0.000 0.000 0.000 0.000 <frozen importlib._bootstrap>:1264(load_module)当输出中的第一列包含了两个数字时（比如，121/1），后者是元调用(primitive call)的次数，前者是实际调用的次数（译者注：只有在递归情况下，实际调用的次数才会大于元调用的次数，其他情况下两者都相等）。对于绝大部分的应用程序来讲使用该模块所产生的的分析报告就已经足够了，比如，你只是想简单地看一下你的程序花费了多少时间。然后，如果你还想将这些数据保存下来，并在将来对其进行分析，你可以使用pstats模块。
假设你想知道你的程序究竟在哪里花费了多少时间。如果你只是想简单地给你的整个程序计时的话，使用Unix中的time命令就已经完全能够应付了。例如：
qixuan@ubuntu:~/qixuan02$ time python3 splitter.py
...
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
real 0m0.379s
user 0m0.216s
sys 0m0.076sqixuan@ubuntu:~/qixuan02$ python3
Python 3.4.0 (default, Jun 19 2015, 14:20:21)
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import time
>>> from functools import wraps
>>>
... def timethis(func):
... @wraps(func)
... def wrapper(*args, **kwargs):
... start = time.perf_counter()
... r = func(*args, **kwargs)
... end = time.perf_counter()
... print('{}.{} : {}'.format(func.__module__, func.__name__, end - start))
... return r
... return wrapper
...
>>> @timethis
... def countdown(n):
... while n > 0:
... n -= 1
...
>>> countdown(1000000)
__main__.countdown : 0.24070458200003486如果想要分析一个语句块的话，你可以定义一个上下文管理器。接下来是如何使用上下文管理器的例子
>>> import time
>>> from contextlib import contextmanager
>>>
... @contextmanager
... def timeblock(label):
... start = time.perf_counter()
... try:
... yield
... finally:
... end = time.perf_counter()
... print('{} : {}'.format(label, end - start))
...
>>> with timeblock('counting'):
... n = 1000000
... while n > 0:
... n -= 1
...
counting : 0.4405263909993664
>>> from timeit import timeit
>>> timeit('math.sqrt(2)', 'import math')
0.46812720200068725>>> timeit('math.sqrt(2)', 'import math', number=10000000)
4.001195195000037
import time
from functools import wraps
def timethis(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time.process_time()
r = func(*args, **kwargs)
end = time.process_time()
print('{}.{} : {}'.format(func.__module__, func.__name__, end - start))
return r
return wrapper
import profile
def fib(n):
# from literateprograms.org
# http://bit.ly/hlOQ5m
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
def fib_seq(n):
seq = []
if n > 0:
seq.extend(fib_seq(n-1))
seq.append(fib(n))
return seq
profile.run('print(fib_seq(20)); print')qixuan@ubuntu:~/qixuan02$ python3 abc.py
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
57358 function calls (68 primitive calls) in 0.418 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
21 0.000 0.000 0.000 0.000 :0(append)
1 0.000 0.000 0.375 0.375 :0(exec)
20 0.000 0.000 0.000 0.000 :0(extend)
1 0.000 0.000 0.000 0.000 :0(print)
1 0.043 0.043 0.043 0.043 :0(setprofile)
1 0.000 0.000 0.374 0.374 <string>:1(<module>)
21/1 0.000 0.000 0.374 0.374 abc.py:14(fib_seq)
57291/21 0.374 0.000 0.374 0.018 abc.py:2(fib)
1 0.000 0.000 0.418 0.418 profile:0(print(fib_seq(20)); print)
0 0.000 0.000 profile:0(profiler)
805
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
