26.3. doctest - 测试交互式Python示例

源代码： Lib / doctest.py

doctest模块会搜索看起来像交互式Python会话的文本片段，然后执行这些会话以验证它们是否按照所示正常工作。有几种常用的方法来使用doctest：

• 通过验证所有交互式示例是否仍按照记录工作，来检查模块的文档字符串是否是最新的。
• 通过验证测试文件或测试对象的交互式示例是否按预期工作，执行回归测试。
• 编写软件包的教程文档，用输入输出示例解释。根据示例或说明文本是否被强调，这具有“文化测试”或“可执行文档”的风格。

首先来看一个完整但简单的示例模块：

"""
This is the "example" module.

The example module supplies one function, factorial().  For example,

>>> factorial(5)
120
"""

def factorial(n):
    """Return the factorial of n, an exact integer >= 0.

    >>> [factorial(n) for n in range(6)]
    [1, 1, 2, 6, 24, 120]
    >>> factorial(30)
    265252859812191058636308480000000
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n must be >= 0

    Factorials of floats are OK, but the float must be an exact integer:
    >>> factorial(30.1)
    Traceback (most recent call last):
        ...
    ValueError: n must be exact integer
    >>> factorial(30.0)
    265252859812191058636308480000000

    It must also not be ridiculously large:
    >>> factorial(1e100)
    Traceback (most recent call last):
        ...
    OverflowError: n too large
    """

    import math
    if not n >= 0:
        raise ValueError("n must be >= 0")
    if math.floor(n) != n:
        raise ValueError("n must be exact integer")
    if n+1 == n:  # catch a value like 1e300
        raise OverflowError("n too large")
    result = 1
    factor = 2
    while factor <= n:
        result *= factor
        factor += 1
    return result


if __name__ == "__main__":
    import doctest
    doctest.testmod()

如果直接从命令行运行example.py，doctest的作用就是：

$ python example.py
$

没有输出！这是正常的，它代表所有的示例正常工作。将-v传递给脚本，可以获得doctest的详细日志，并打印摘要：

$ python example.py -v
Trying:
    factorial(5)
Expecting:
    120
ok
Trying:
    [factorial(n) for n in range(6)]
Expecting:
    [1, 1, 2, 6, 24, 120]
ok

以此类推。结尾是：

Trying:
    factorial(1e100)
Expecting:
    Traceback (most recent call last):
        ...
    OverflowError: n too large
ok
2 items passed all tests:
   1 tests in __main__
   8 tests in __main__.factorial
9 tests in 2 items.
9 passed and 0 failed.
Test passed.
$

知道这些就够了，开始体验高效的doctest吧！当然可以更深入了解这个模块。以下部分提供了详细信息。注意，在标准Python测试套件和库中有很多doctest的例子。特别有用的示例可以在标准测试文件Lib/test/test_doctest.py中找到。

26.3.1. 简单的用法：检测文档字符串中的示例

使用doctest最简单的（但不是唯一的）方式就是在模块M结尾添加：

if __name__ == "__main__":
    import doctest
    doctest.testmod()

doctest将会检测模块M中的文档字符串。

当模块作为脚本运行时，文档字符串中的示例将被执行和验证：

python M.py

如果示例被验证正确，将不会显示任何内容。如果出现错误，错误的示例和错误的原因将打印到stdout。输出的最后一行是***Test Failed*** N failures.，其中N是失败的示例个数。

使用-v参数运行：

python M.py -v

将会打印详细的示例调用信息，以及末尾的分类摘要。

您可以通过传递verbose=True到testmod()来强制详细模式，或通过传递verbose=False来禁止它。在任何一种情况下，sys.argv都不会被testmod()检查（因此传递-v或者没有效果）。

还有一个命令行快捷方式，用于运行testmod()。您可以指示Python解释器直接从标准库运行doctest模块，并在命令行中传递模块名称：

python -m doctest -v example.py

这将导入example.py作为独立模块，并对其运行testmod()。请注意，如果文件是包的一部分并且从该包导入其他子模块，则这可能无法正常工作。

有关testmod()的详细信息，请参阅Basic API一节。

26.3.2. 简单的用法：通过文本文件检测示例

doctest的另一个简单应用是在文本文件中测试交互示例。这可以使用testfile()函数来完成：

import doctest
doctest.testfile("example.txt")

该短脚本执行并验证文件example.txt中包含的任何交互式Python示例。文件内容被视为一个巨大的文档字符串。该文件不需要包含Python程序！例如，或许example.txt包含这个：

The ``example`` module
======================

Using ``factorial``
-------------------

This is an example text file in reStructuredText format.  First import
``factorial`` from the ``example`` module:

    >>> from example import factorial

Now use it:

    >>> factorial(6)
    120

运行doctest.testfile("example.txt")然后在本文档中找到错误：

File "./example.txt", line 14, in example.txt
Failed example:
    factorial(6)
Expected:
    120
Got:
    720

与testmod()一样，testfile()不会显示任何内容，除非示例失败。如果示例失败，则使用与testmod()相同的格式将失败示例和失败原因打印到stdout。

默认情况下，testfile()在调用模块的目录中查找文件。有关可选参数的说明，请参阅Basic API一节，以便让它在其他位置查找文件。

Like testmod(), testfile()‘s verbosity can be set with the -v command-line switch or with the optional keyword argument verbose.

还有一个命令行快捷方式，用于运行testfile()。您可以指示Python解释器直接从标准库运行doctest模块，并在命令行上传递文件名：

python -m doctest -v example.txt

因为文件名不以.py结尾，doctest推断必须使用testfile()，而不是testmod()。

有关testfile()的详细信息，请参阅Basic API一节。

26.3.3. How It Works

本节详细检查doctest是如何工作的：它的文档字符串，它如何找到交互式示例，它使用的执行上下文，它如何处理异常，以及如何使用选项标志来控制其行为。这是你需要知道的信息，写doctest示例；有关在这些示例上实际运行doctest的信息，请参阅以下各节。

26.3.3.1. Which Docstrings Are Examined?

将搜索模块docstring，以及所有函数，类和方法文档字符串。不会搜索导入到模块中的对象。

此外，如果M.__test__存在且为“true”，则必须是dict，并且每个条目将（字符串）名称映射到函数对象，类对象或字符串。从M.__test__中找到的函数和类对象文档字符串被搜索，字符串被视为是docstrings。在输出中，出现M.__test__中的键K

<name of M>.__test__.K

发现的任何类都是类似地递归搜索，以测试其所包含的方法和嵌套类中的docstrings。

CPython实现细节：在版本3.4之前，用C语言编写的扩展模块没有被doctest完全搜索。

26.3.3.2. How are Docstring Examples Recognized?

在大多数情况下，交互式控制台会话的复制和粘贴工作正常，但doctest并不试图对任何特定的Python shell进行精确仿真。

>>> # comments are ignored
>>> x = 12
>>> x
12
>>> if x == 13:
...     print("yes")
... else:
...     print("no")
...     print("NO")
...     print("NO!!!")
...
no
NO
NO!!!
>>>

Any expected output must immediately follow the final '>>> ' or '... ' line containing the code, and the expected output (if any) extends to the next '>>> ' or all-whitespace line.

精细打印：

• 预期输出不能包含全空白行，因为这样的行被用来表示预期输出的结束。如果预期输出一定要包含空行，请在您的doctest示例中将<BLANKLINE>放在每个空白行。

• 所有Tab字符将会被扩展为空格，使用8列制表符。测试代码生成的输出中的标签不会被修改。Because any hard tabs in the sample output are expanded, this means that if the code output includes hard tabs, the only way the doctest can pass is if the NORMALIZE_WHITESPACE option or directive is in effect. 或者，可以重写测试以捕获输出并将其与期望值作为测试的一部分进行比较。这种对源代码中的选项卡的处理是通过反复试验得到的，并且已被证明是处理它们的最小错误的方式。通过编写自定义DocTestParser类，可以使用不同的算法来处理制表符。

• 输出到stdout被捕获，但不输出到stderr（异常跟踪通过不同的方法捕获）。

• 如果您在交互式会话中通过反斜杠继续一行，或者出于任何其他原因使用反斜杠，那么您应该使用原始的docstring，这将在您输入时完全保留反斜杠：

  >>> def f(x):
  ...     r'''Backslashes in a raw docstring: m\n'''
  >>> print(f.__doc__)
  Backslashes in a raw docstring: m\n
  

  否则，反斜杠将被解释为字符串的一部分。例如，上面的\n将被解释为换行符。或者，您可以将doctest版本中的每个反斜杠加倍（而不是使用原始字符串）：

  >>> def f(x):
  ...     '''Backslashes in a raw docstring: m\\n'''
  >>> print(f.__doc__)
  Backslashes in a raw docstring: m\n
  

• 起始列无所谓：

  >>> assert "Easy!"
        >>> import math
            >>> math.floor(1.9)
            1
  

  并且从初始'>＆gt；>＆gt； '行中出现的预期输出中删除了许多前导空白字符例。

26.3.3.3. What’s the Execution Context?

默认情况下，每次doctest找到要测试的文档字符串时，它会使用M的全局变量的浅拷贝 t更改模块的实际全局变量，并且使得M中的一个测试不能留下碎屑，这意外允许另一个测试工作。这意味着示例可以自由地使用在M中在顶层定义的任何名称，以及在运行的docstring中定义的名称。示例不能看到在其他docstrings中定义的名称。

通过将globs=your_dict传递到testmod()或testfile()，您可以强制使用自己的dict作为执行上下文。

26.3.3.4. 如何处理异常？

没有问题，只要跟踪是该示例生成的唯一输出：只需粘贴在追溯中。[1]由于跟踪包含可能快速更改的详细信息（例如，精确的文件路径和行号），这是一种情况，其中doctest努力在其接受的灵活性。

简单示例：

>>> [1, 2, 3].remove(42)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: list.remove(x): x not in list

如果ValueError与list.remove（x）： x 不是 在 列表中显示详细信息。

异常的预期输出必须以traceback标头开头，可以是以下两行，缩进与示例的第一行相同：

Traceback (most recent call last):
Traceback (innermost last):

跟踪头之后是可选的跟踪堆栈，其内容被doctest忽略。回溯栈通常被省略，或从交互式会话中逐字复制。

跟踪堆栈后面是最有趣的部分：包含异常类型和细节的行。这通常是追溯的最后一行，但如果异常具有多行详细信息，则可以跨多行扩展：

>>> raise ValueError('multi\n    line\ndetail')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: multi
    line
detail

最后三行（从ValueError开始）与异常的类型和详细信息进行比较，其余的行将被忽略。

最佳实践是省略追溯堆栈，除非它为示例添加了重要的文档值。所以最后一个例子可能更好：

>>> raise ValueError('multi\n    line\ndetail')
Traceback (most recent call last):
    ...
ValueError: multi
    line
detail

注意，回溯被非常特殊地处理。特别地，在重写的示例中，使用...独立于doctest的ELLIPSIS选项。在该示例中的省略号可以被省略，或者也可以是三（或三百）个逗号或数字，或蒙蒂Python skit的缩进抄本。

一些细节你应该读一次，但不需要记住：

• Doctest无法猜测您的预期输出是来自异常跟踪还是来自普通打印。因此，例如，期望ValueError： 42 的示例是 prime是否实际引发了ValueError，或者示例是否仅打印该跟踪文本。在实践中，普通输出很少从回溯头行开始，所以这不会产生真正的问题。

• 追溯堆栈的每一行（如果存在）必须比示例的第一行缩进得更远，或以非字母数字字符开头。跟随在回溯标题之后的第一行缩进相同，并以字母数字开始被视为异常细节的开始。当然，这对正确的追溯是正确的。

• 当指定IGNORE_EXCEPTION_DETAIL doctest选项时，忽略最左冒号之后的所有内容以及异常名称中的任何模块信息。

• 交互式shell省略某些SyntaxError的跟踪头标行。但是doctest使用traceback头行来区分异常和非异常。因此，在需要测试省略traceback标头的SyntaxError的罕见情况下，您需要手动将追溯标题行添加到测试示例中。

• 对于某些SyntaxError s，Python使用^标记显示语法错误的字符位置：

  >>> 1 1
    File "<stdin>", line 1
      1 1
        ^
  SyntaxError: invalid syntax
  

  由于显示错误位置的行在异常类型和详细信息之前，因此不会被doctest检查。例如，以下测试将通过，即使它将^标记放置在错误的位置：

  >>> 1 1
    File "<stdin>", line 1
      1 1
      ^
  SyntaxError: invalid syntax
  

26.3.3.5. Option Flags

一些选项可以用于控制doctest行为。标志的符号名称作为模块常量提供，可以组合在一起并传递给各种函数。这些名称也可以在doctest directives中使用，并且可以通过-o选项传递到doctest命令行界面。

版本3.4中的新功能： -o命令行选项。

第一组选项定义测试语义，控制doctest如何决定实际输出是否与示例的预期输出匹配：

doctest.DONT_ACCEPT_TRUE_FOR_1

默认情况下，如果预期输出块只包含1，则只包含1或只是True的实际输出块被视为匹配，对于0与False类似。当指定DONT_ACCEPT_TRUE_FOR_1时，不允许替换。默认行为适用于Python将许多函数的返回类型从integer更改为boolean；期望“小整数”输出的doctests在这些情况下仍然有效。这个选项可能会消失，但不是几年。

doctest.DONT_ACCEPT_BLANKLINE

默认情况下，如果预期输出块包含只包含字符串<BLANKLINE>的行，则该行将与实际输出中的空白行匹配。因为真正的空白行界定了预期的输出，这是唯一的沟通方式，预期空白行。当指定DONT_ACCEPT_BLANKLINE时，不允许进行此替换。

doctest.NORMALIZE_WHITESPACE

指定时，所有空格（空格和换行符）的序列都被视为相等。预期输出内的任何空格序列将匹配实际输出内的任何空格序列。默认情况下，空格必须完全匹配。NORMALIZE_WHITESPACE在预期输出行非常长，并且想要在源中的多行包装时特别有用。

doctest.ELLIPSIS

指定时，预期输出中的省略号标记（...）可以匹配实际输出中的任何子字符串。这包括跨越行边界的子字符串和空子字符串，因此最好保持使用这个简单的。复杂的用法可能导致相同种类的“哎呀，它匹配太多了！”意外的是，.*在正则表达式中容易出现。

doctest.IGNORE_EXCEPTION_DETAIL

如果指定这个选项，那么当引发的异常的类型与期望的异常类型相同就可以通过的，不会检测异常的详细信息。例如，如果实际引发的异常为ValueError：，则期望ValueError： 42 3 * 14，但是会失败，例如，如果出现TypeError。

它还将忽略Python 3 doctest报告中使用的模块名称。因此，无论测试是在Python 2.7或Python 3.2（或更高版本）下运行，这两个变体都将与指定的标志一起使用：

>>> raise CustomError('message')
Traceback (most recent call last):
CustomError: message

>>> raise CustomError('message')
Traceback (most recent call last):
my_module.CustomError: message

请注意，ELLIPSIS也可用于忽略异常消息的详细信息，但是此类测试可能仍然失败，这取决于模块详细信息是否作为异常名称的一部分打印。Using IGNORE_EXCEPTION_DETAIL and the details from Python 2.3 is also the only clear way to write a doctest that doesn’t care about the exception detail yet continues to pass under Python 2.3 or earlier (those releases do not support doctest directives and ignore them as irrelevant comments). 例如：

>>> (1, 2)[3] = 'moo'
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment

在Python 2.3和更高版本下传递带有指定标志的Python版本，即使Python 2.4中的细节更改为“不”而不是“不”。

在版本3.2中更改： IGNORE_EXCEPTION_DETAIL现在也忽略与包含测试异常的模块相关的任何信息。

doctest.SKIP

指定时，不要运行示例。这在doctest示例同时作为文档和测试用例的上下文中非常有用，并且应该包括一个示例用于文档目的，但不应该检查。例如，示例的输出可能是随机的；或者示例可能取决于测试驱动程序不可用的资源。

SKIP标志也可以用于临时“注释”示例。

doctest.COMPARISON_FLAGS

位掩码或者将所有比较标志放在一起。

第二组选项控制如何报告测试失败：

doctest.REPORT_UDIFF

当指定时，涉及多行预期和实际输出的故障将使用统一差异显示。

doctest.REPORT_CDIFF

指定时，将使用上下文差异显示涉及多行预期和实际输出的故障。

doctest.REPORT_NDIFF

指定时，difflib.Differ使用与流行的ndiff.py实用程序相同的算法计算差异。这是标记线内以及线之间的差异的唯一方法。例如，如果预期输出行包含数字1，其中实际输出包含字母l，则插入带有插入符号的标记不匹配列位置的行。

doctest.REPORT_ONLY_FIRST_FAILURE

当指定时，在每个doctest中显示第一个失败的示例，但抑制所有剩余示例的输出。这将防止doctest报告由于早期故障而破裂的正确示例；但它也可能隐藏不正确的示例，独立于第一个故障失败。当指定REPORT_ONLY_FIRST_FAILURE时，剩余的示例仍然运行，仍然计入报告的故障总数；只有输出被抑制。

doctest.FAIL_FAST

指定时，在第一个失败示例后退出，而不尝试运行其余示例。因此，报告的故障数最多为1。此标志在调试期间可能有用，因为第一次故障后的示例甚至不会生成调试输出。

doctest命令行接受选项-f作为-o FAIL_FAST的缩写。

版本3.4中的新功能。

doctest.REPORTING_FLAGS

位掩码或者将所有报告标志放在一起。

还有一种方法来注册新的选项标志名称，虽然这是没有用的，除非你打算通过子类化扩展doctest内部：

doctest.register_optionflag(name)

创建具有给定名称的新选项标志，并返回新标志的整数值。当子类化OutputChecker或DocTestRunner以创建子类支持的新选项时，可以使用register_optionflag()register_optionflag()应始终使用以下idiom调用：

MY_FLAG = register_optionflag('MY_FLAG')

26.3.3.6. Directives

对于单个示例，可以使用Doctest伪指令修改option flags。Doctest伪指令是遵循示例源代码的特殊Python注释：

directive             ::=  "#" "doctest:" directive_options
directive_options     ::=  directive_option ("," directive_option)\*
directive_option      ::=  on_or_off directive_option_name
on_or_off             ::=  "+" \| "-"
directive_option_name ::=  "DONT_ACCEPT_BLANKLINE" \| "NORMALIZE_WHITESPACE" \| ...

在+或-和指令选项名称之间不允许有空格。指令选项名称可以是上述任何选项标志名称。

示例的doctest指令修改了该单个示例的doctest的行为。使用+启用命名行为，或-禁用它。

例如，此测试通过：

>>> print(list(range(20))) # doctest: +NORMALIZE_WHITESPACE
[0,   1,  2,  3,  4,  5,  6,  7,  8,  9,
10,  11, 12, 13, 14, 15, 16, 17, 18, 19]

没有指令，它会失败，因为实际输出在单数列表元素之前没有两个空格，并且因为实际输出在一行上。这个测试也通过，还需要一个指令：

>>> print(list(range(20))) # doctest: +ELLIPSIS
[0, 1, ..., 18, 19]

多个指令可以在单个物理行上使用，用逗号分隔：

>>> print(list(range(20))) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
[0,    1, ...,   18,    19]

如果多个指令注释用于单个示例，则它们被组合：

>>> print(list(range(20))) # doctest: +ELLIPSIS
...                        # doctest: +NORMALIZE_WHITESPACE
[0,    1, ...,   18,    19]

如上例所示，您可以向仅包含指令的示例中添加...行。当示例对于指令舒适地适合在同一行上而言太长时，这可能是有用的：

>>> print(list(range(5)) + list(range(10, 20)) + list(range(30, 40)))
... # doctest: +ELLIPSIS
[0, ..., 4, 10, ..., 19, 30, ..., 39]

注意，由于默认情况下禁用所有选项，并且指令仅适用于它们出现的示例，因此启用选项（通过指令中的+）通常是唯一有意义的选择。但是，选项标志也可以传递到运行doctests的函数，建立不同的默认值。在这种情况下，在指令中通过-禁用选项可能很有用。

26.3.3.7. Warnings

doctest严重需要在预期输出中完全匹配。如果即使一个字符不匹配，测试也会失败。这可能会让你惊讶几次，因为你知道什么Python做和不保证输出。例如，当打印一个dict时，Python不保证键值对将以任何特定的顺序打印，因此一个测试

>>> foo()
{"Hermione": "hippogryph", "Harry": "broomstick"}

是脆弱的！一个解决方法是做

>>> foo() == {"Hermione": "hippogryph", "Harry": "broomstick"}
True

代替。另一个是做

>>> d = sorted(foo().items())
>>> d
[('Harry', 'broomstick'), ('Hermione', 'hippogryph')]

还有其他的，但你得到的想法。

另一个坏的想法是打印嵌入对象地址的东西，比如

>>> id(1.0) # certain to fail some of the time
7948648
>>> class C: pass
>>> C()   # the default repr() for instances embeds an address
<__main__.C instance at 0x00AC18F0>

ELLIPSIS指令为最后一个示例提供了一个很好的方法：

>>> C() #doctest: +ELLIPSIS
<__main__.C instance at 0x...>

浮点数也受到跨平台的小输出变化的影响，因为Python延伸到平台C库用于浮点格式化，并且C库在这里的质量差异很大。

>>> 1./7  # risky
0.14285714285714285
>>> print(1./7) # safer
0.142857142857
>>> print(round(1./7, 6)) # much safer
0.142857

形式I/2.**J的数字在所有平台上都是安全的，我经常设计doctest例子来生成这种形式的数字：

>>> 3./4  # utterly safe
0.75

简单的分数也更容易让人理解，这使得更好的文档。

26.3.4. Basic API

函数testmod()和testfile()为doctest提供了一个简单的接口，足以满足大多数基本用途。有关这两个函数的不太正式的介绍，请参阅Simple Usage: Checking Examples in Docstrings和Simple Usage: Checking Examples in a Text File。

doctest.testfile(filename, module_relative=True, name=None, package=None, globs=None, verbose=None, report=True, optionflags=0, extraglobs=None, raise_on_error=False, parser=DocTestParser(), encoding=None)

除filename之外的所有参数都是可选的，应以关键字形式指定。

在名为filename的文件中测试示例。返回（failure_count， test_count）。

可选参数module_relative指定应如何解释文件名：

• 如果module_relative是True（默认值），则filename指定与操作系统无关的模块相对路径。默认情况下，此路径相对于调用模块的目录；但如果指定了包参数，那么它是相对于该包。为了确保操作系统无关性，filename应使用/字符来分隔路径段，并且可能不是绝对路径（即，它不能以/
• 如果module_relative为False，则filename指定特定于OS的路径。路径可以是绝对路径或相对路径；相对路径相对于当前工作目录被解析。

可选参数name给出测试的名称；默认情况下，或者如果使用None，os.path.basename(filename)

可选参数package是一个Python包或一个Python包的名称，其目录应用作模块的基本目录相对文件名。如果未指定软件包，则调用模块的目录将用作模块相关文件名的基本目录。如果module_relative为False，则指定包是错误的。

可选参数globs给出了在执行示例时要用作全局变量的dict。这个dict的新的浅拷贝是为doctest创建的，所以它的例子从一个干净的slate开始。默认情况下，或None，使用新的空字符串。

可选参数extraglobs给出了合并到用于执行示例的全局变量的dict。这与dict.update()：if globs和extraglobs有一个公共密钥，extraglobs t5 >出现在组合字典中。默认情况下，或None，不使用额外的全局变量。这是一个高级功能，允许doctests的参数化。例如，可以为基类编写doctest，使用该类的通用名称，然后通过将extraglobs dict映射通用名称到子类来重复使用以测试任意数量的子类测试。

可选参数verbose如果为true则输出大量的东西，如果为false，则只打印失败；默认情况下，或者如果None，当且仅当'-v'在sys.argv中时才是真的。

可选参数report在true时打印摘要，否则在结尾处不打印。在详细模式下，摘要是详细的，否则摘要非常简短（实际上，如果所有测试通过，则为空）。

可选参数optionflags（默认值0）采用按位或选项标志。请参见Option Flags一节。

可选参数raise_on_error默认为false。如果为true，则会在示例中的第一个失败或意外异常时引发异常。这允许故障进行事后调试。默认行为是继续运行示例。

可选参数parser指定应用于从文件中提取测试的DocTestParser（或子类）。它默认为普通解析器（即DocTestParser()）。

可选参数encoding指定应用于将文件转换为unicode的编码。

doctest.testmod(m=None, name=None, globs=None, verbose=None, report=True, optionflags=0, extraglobs=None, raise_on_error=False, exclude_empty=False)

所有参数都是可选的，除m之外的所有参数都应以关键字形式指定。

Test examples in docstrings in functions and classes reachable from module m (or module __main__ if m is not supplied or is None), starting with m.__doc__.

此外，测试示例可以从dict m.__test__找到，如果它存在并且不是None。m.__test__将名称（字符串）映射到函数，类和字符串；函数和类文档字符串搜索示例；直接搜索字符串，就好像它们是docstrings。

只搜索附加到属于模块m的对象的docstrings。

返回（failure_count， test_count）。

可选参数name给出模块的名称；默认情况下，或None，使用m.__name__。

可选参数exclude_empty默认为false。如果为true，那么没有找到任何doctests的对象将被排除在考虑之外。默认值是向后兼容性hack，因此仍然使用doctest.master.summarize()和testmod()的代码继续获取没有测试的对象的输出。较新的DocTestFinder构造函数的exclude_empty参数默认为true。

可选参数extraglobs，详细，报告，optionflags，raise_on_error和 globs与上面的函数testfile()相同，除了globs默认为m.__dict__。

doctest.run_docstring_examples(f, globs, verbose=False, name="NoName", compileflags=None, optionflags=0)

与对象f相关联的测试示例；例如，f可以是字符串，模块，函数或类对象。

字典参数globs的浅表副本用于执行上下文。

可选参数名称用于故障消息，默认为"NoName"。

如果可选参数verbose为true，则即使没有失败也会生成输出。默认情况下，只有在出现示例失败的情况下才会生成输出。

可选参数compileflags提供了运行示例时应由Python编译器使用的一组标志。默认情况下，或者如果None，则会根据globs中找到的一组未来功能推断出标记。

可选参数optionflags适用于上面的函数testfile()。

26.3.5. Unittest API

当你的容器的doctest模块增长，你会想要一种方法来系统地运行所有的doctests。doctest提供了两个函数，可用于从包含doctest的模块和文本文件创建unittest测试套件。要集成unittest测试发现，请在测试模块中包含load_tests()函数：

import unittest
import doctest
import my_module_with_doctests

def load_tests(loader, tests, ignore):
    tests.addTests(doctest.DocTestSuite(my_module_with_doctests))
    return tests

从文本文件和模块使用doctests创建unittest.TestSuite实例有两个主要功能：

doctest.DocFileSuite(*paths, module_relative=True, package=None, setUp=None, tearDown=None, globs=None, optionflags=0, parser=DocTestParser(), encoding=None)

将doctest测试从一个或多个文本文件转换为unittest.TestSuite。

返回的unittest.TestSuite由unittest框架运行，并在每个文件中运行交互示例。如果任何文件中的示例失败，那么合成单元测试失败，并会出现一个failureException异常，显示包含测试的文件的名称和一个（有时是近似的）行号。

将一个或多个路径（作为字符串）传递到要检查的文本文件。

可以提供选项作为关键字参数：

可选参数module_relative指定如何解释路径中的文件名：

• 如果module_relative是True（默认值），则paths中的每个文件名指定与操作系统无关的模块相对路径。默认情况下，此路径相对于调用模块的目录；但如果指定了包参数，那么它是相对于该包。为了确保OS独立性，每个文件名应使用/字符来分隔路径段，并且可能不是绝对路径（即，它不能以/开头）。
• 如果module_relative是False，则paths中的每个文件名都指定一个特定于操作系统的路径。路径可以是绝对路径或相对路径；相对路径相对于当前工作目录被解析。

可选参数package是一个Python包或一个Python包的名称，该包的目录应该用作路径中模块相关文件名的基本目录。如果未指定软件包，则调用模块的目录将用作模块相关文件名的基本目录。如果module_relative为False，则指定包是错误的。

可选参数setUp指定测试套件的设置函数。这在每个文件中运行测试之前调用。setUp函数将传递DocTest对象。setUp函数可以通过测试的globs属性访问测试全局变量。

可选参数tearDown指定测试套件的拆分函数。这在每个文件中运行测试后调用。tearDown函数将传递DocTest对象。setUp函数可以通过测试的globs属性访问测试全局变量。

可选参数globs是包含测试的初始全局变量的字典。为每个测试创建此字典的新副本。默认情况下，globs是一个新的空字典。

可选参数optionflags指定测试的默认doctest选项，这些选项是通过将各个选项标志一起或合并而创建的。请参见Option Flags一节。有关更好地设置报告选项的方法，请参阅下面的函数set_unittest_reportflags()。

可选参数parser指定应用于从文件中提取测试的DocTestParser（或子类）。它默认为普通解析器（即DocTestParser()）。

可选参数encoding指定应用于将文件转换为unicode的编码。

全局__file__被添加到使用DocFileSuite()从文本文件加载的doctests提供的全局变量。

doctest.DocTestSuite(module=None, globs=None, extraglobs=None, test_finder=None, setUp=None, tearDown=None, checker=None)

将模块的doctest测试转换为unittest.TestSuite。

返回的unittest.TestSuite由unittest框架运行，并在模块中运行每个doctest。如果任何doctests失败，那么合成单元测试失败，并且出现failureException异常，显示包含测试的文件的名称和（有时是近似的）行号。

可选参数模块提供要测试的模块。它可以是模块对象或（可能是点线）模块名称。如果未指定，则使用调用此函数的模块。

可选参数globs是包含测试的初始全局变量的字典。为每个测试创建此字典的新副本。默认情况下，globs是一个新的空字典。

可选参数extraglobs指定一组额外的全局变量，它们合并到globs中。默认情况下，不使用额外的全局变量。

可选参数test_finder是用于从模块中提取doctests的DocTestFinder对象（或插入替换）。

可选参数setUp，tearDown和optionflags与上面的函数DocFileSuite()相同。

此函数使用与testmod()相同的搜索技术。

在版本3.5中更改： DocTestSuite()返回空的unittest.TestSuite if module ValueError。

在封底下，DocTestSuite()从doctest.DocTestCase实例中创建unittest.TestSuite，并且DocTestCase unittest.TestCase的子类。DocTestCase在这里没有记录（这是一个内部细节），但是研究它的代码可以回答有关unittest集成的确切细节的问题。

类似地，DocFileSuite()创建doctest.DocFileCase实例中的unittest.TestSuite，DocFileCase的DocTestCase。

因此，创建unittest.TestSuite的两种方法都会运行DocTestCase的实例。This is important for a subtle reason: when you run doctest functions yourself, you can control the doctest options in use directly, by passing option flags to doctest functions. 但是，如果您正在编写unittest框架，则unittest最终会控制测试的运行时间和方式。框架作者通常希望控制doctest报告选项（也许，例如，由命令行选项指定），但没有办法通过unittest传递选项到doctest测试赛跑者。

因此，doctest也支持通过此功能支持unittest支持的doctest报告标志的概念：

doctest.set_unittest_reportflags(flags)

设置要使用的doctest报告标志。

参数标志采用按位或选项标志。请参见Option Flags一节。只能使用“报告标志”。

This is a module-global setting, and affects all future doctests run by module unittest: the runTest() method of DocTestCase looks at the option flags specified for the test case when the DocTestCase instance was constructed. 如果没有指定报告标志（这是典型的和预期的情况），则doctest的unittest报告标志被置入选项标志， augmented传递给为运行doctest而创建的DocTestRunner实例。如果在构建DocTestCase实例时指定了任何报告标志，则会忽略doctest的unittest报告标志。

函数返回调用函数之前生效的unittest报告标志的值。

26.3.6. Advanced API

基本API是一个简单的包装器，旨在使doctest易于使用。它相当灵活，应该满足大多数用户的需求；但是，如果您需要对测试进行更细粒度的控制，或者希望扩展doctest的功能，那么您应该使用高级API。

高级API围绕两个容器类，用于存储从doctest案例中提取的交互示例：

• Example：单个Python statement，与其预期输出配对。
• DocTest：通常从单个文档字符串或文本文件中提取的Example的容器。

定义了其他处理类来查找，解析和运行，并检查doctest示例：

• DocTestFinder：查找给定模块中的所有文档字符串，并使用DocTestParser从包含交互示例的每个文档字符串创建DocTest。
• DocTestParser：从字符串（例如对象的docstring）创建DocTest对象。
• DocTestRunner：执行DocTest中的示例，并使用OutputChecker验证其输出。
• OutputChecker：将doctest示例的实际输出与预期输出进行比较，并确定它们是否匹配。

这些处理类之间的关系总结在下图中：

                            list of:
+------+                   +---------+
|module| --DocTestFinder-> | DocTest | --DocTestRunner-> results
+------+    |        ^     +---------+     |       ^    (printed)
            |        |     | Example |     |       |
            v        |     |   ...   |     v       |
           DocTestParser   | Example |   OutputChecker
                           +---------+

26.3.6.1. DocTest Objects

class doctest.DocTest(examples, globs, name, filename, lineno, docstring)

应该在单个命名空间中运行的doctest示例的容器。构造函数参数用于初始化相同名称的属性。

DocTest定义以下属性。它们由构造函数初始化，不应直接修改。

examples

列出应该由此测试运行的各个交互式Python示例的Example对象。

globs

应该运行示例的命名空间（也称为全局变量）。这是一个将名称映射到值的字典。示例（例如绑定新变量）对命名空间所做的任何更改将在运行测试后反映在globs中。

name

标识DocTest的字符串名称。通常，这是从中提取测试的对象或文件的名称。

filename

从中提取此DocTest的文件的名称；或None（如果文件名未知），或者未从文件中提取DocTest。

lineno

DocTest开始的filename中的行号，如果行号不可用，则为None。此行号相对于文件的开头是从零开始的。

docstring

提取测试的字符串，如果字符串不可用，则为“None”，或者如果没有从字符串中提取测试。

26.3.6.2. Example Objects

class doctest.Example(source, want, exc_msg=None, lineno=0, indent=0, options=None)

一个单一的交互示例，由Python语句及其预期输出组成。构造函数参数用于初始化相同名称的属性。

Example定义以下属性。它们由构造函数初始化，不应直接修改。

source

包含示例的源代码的字符串。这个源代码由单个Python语句组成，并且总是以换行符结束；构造函数在必要时添加一个换行符。

want

运行示例源代码（来自stdout或在异常情况下的跟踪）的预期输出。want以换行符结束，除非预期没有输出，在这种情况下，它是一个空字符串。构造函数在必要时添加一个换行符。

exc_msg

示例生成的异常消息，如果示例预期生成异常；或None（如果不希望生成异常）。将此异常消息与traceback.format_exception_only()的返回值进行比较。exc_msg以换行符结束，除非None。如果需要，构造函数添加一个换行符。

lineno

包含此示例的字符串中的行号，其中示例开始。该行号相对于包含字符串的开头是从零开始的。

indent

该示例在包含字符串中的缩进，即在示例的第一个提示之前的空格字符数。

options

从选项标志到True或False的字典映射，用于覆盖此示例的默认选项。此字典中未包含的任何选项标志都保留其默认值（由DocTestRunner的optionflags指定）。默认情况下，不设置任何选项。

26.3.6.3. DocTestFinder objects

class doctest.DocTestFinder(verbose=False, parser=DocTestParser(), recurse=True, exclude_empty=True)

一个处理类，用于从其docstring和其包含的对象的docstrings中提取与给定对象相关的DocTest。DocTest可以从模块，类，函数，方法，静态方法，类方法和属性中提取。

可选参数verbose可用于显示由finder搜索的对象。它默认为False（无输出）。

可选参数parser指定用于从docstrings中提取doctests的DocTestParser对象（或一个插入替换）。

如果可选参数recurse为false，则DocTestFinder.find()将仅检查给定对象，而不检查任何包含的对象。

如果可选参数exclude_empty为false，则DocTestFinder.find()将包含具有空docstring的对象的测试。

DocTestFinder定义以下方法：

find(obj[, name][, module][, globs][, extraglobs])

返回由obj的docstring定义的DocTest列表，或其任何包含的对象的docstring。

可选参数name指定对象的名称；此名称将用于为返回的DocTest构造名称。如果未指定name，则使用obj.__name__。

可选参数模块是包含给定对象的模块。如果模块未指定或为无，则测试查找器将尝试自动确定正确的模块。使用对象的模块：

• 作为默认命名空间，如果未指定globs。
• 防止DocTestFinder从从其他模块导入的对象中提取DocTests。（忽略除模块之外的模块的包含对象。）
• 找到包含对象的文件的名称。
• 帮助查找其文件中对象的行号。

如果模块为False，则不会尝试找到模块。这很模糊，主要用于测试doctest本身：如果模块是False或者是None，但不能自动找到，被认为属于（不存在的）模块，因此所有包含的对象将（递归地）搜索doctests。

The globals for each DocTest is formed by combining globs and extraglobs (bindings in extraglobs override bindings in globs). 为每个DocTest创建全新的全局字典副本。如果未指定globs，则默认为模块的__ dict __（如果指定）或{}。如果未指定extraglobs，则默认为{}。

26.3.6.4. DocTestParser objects

class doctest.DocTestParser

用于从字符串中提取交互示例并使用它们创建DocTest对象的处理类。

DocTestParser定义以下方法：

get_doctest(string, globs, name, filename, lineno)

从给定字符串中提取所有doctest示例，并将它们收集到DocTest对象中。

globs，name，filename和lineno属于新的DocTest 。有关详细信息，请参阅DocTest的文档。

get_examples(string, name='<string>')

从给定字符串中提取所有doctest示例，并将它们作为Example对象的列表返回。行号为0。可选参数name是标识此字符串的名称，仅用于错误消息。

parse(string, name='<string>')

将给定的字符串划分为示例和中间文本，并将它们作为交替的Example和字符串的列表返回。Example的行号为0。可选参数name是标识此字符串的名称，仅用于错误消息。

26.3.6.5. DocTestRunner objects

class doctest.DocTestRunner(checker=None, verbose=None, optionflags=0)

用于在DocTest中执行和验证互动示例的处理类。

预期输出和实际输出之间的比较由OutputChecker完成。该比较可以用多个选项标志来定制；有关详细信息，请参阅Option Flags一节。如果选项标志不足，那么也可以通过将OutputChecker的子类传递给构造函数来定制比较。

测试跑步者的显示输出可以通过两种方式控制。首先，输出函数可以传递给TestRunner.run()；此函数将使用应显示的字符串进行调用。它默认为sys.stdout.write。如果捕获输出不足，则还可以通过对DocTestRunner进行子类化并重写方法report_start()，report_success()，report_unexpected_exception()和report_failure()。

可选的关键字参数checker指定应用于将预期输出与doctest示例的实际输出进行比较的OutputChecker对象（或插入替换）。

可选的关键字参数verbose控制DocTestRunner的详细程度。如果verbose是True，则会在每个示例运行时打印相关信息。如果verbose是False，则只打印失败。如果verbose未指定，或None，则使用详细输出，如果使用命令行开关-v

可选的关键字参数optionflags可用于控制测试运行器如何将预期输出与实际输出进行比较，以及如何显示故障。有关详细信息，请参见Option Flags一节。

DocTestParser定义以下方法：

report_start(out, test, example)

报告测试运行器将要处理给定的示例。提供此方法以允许DocTestRunner的子类自定义其输出；它不应该直接调用。

示例是要处理的示例。test是包含示例的测试。out是传递到DocTestRunner.run()的输出函数。

report_success(out, test, example, got)

报告给定示例成功运行。提供此方法以允许DocTestRunner的子类自定义其输出；它不应该直接调用。

示例是要处理的示例。got是示例的实际输出。test是包含示例的测试。out是传递到DocTestRunner.run()的输出函数。

report_failure(out, test, example, got)

报告给定的示例失败。提供此方法以允许DocTestRunner的子类自定义其输出；它不应该直接调用。

示例是要处理的示例。got是示例的实际输出。test是包含示例的测试。out是传递到DocTestRunner.run()的输出函数。

report_unexpected_exception(out, test, example, exc_info)

报告给定的示例引发了意外的异常。提供此方法以允许DocTestRunner的子类自定义其输出；它不应该直接调用。

示例是要处理的示例。exc_info是包含有关意外异常（由sys.exc_info()返回的）的信息的元组。test是包含示例的测试。out是传递到DocTestRunner.run()的输出函数。

run(test, compileflags=None, out=None, clear_globs=True)

在test（DocTest对象）中运行示例，并使用writer函数out显示结果。

示例在命名空间test.globs中运行。如果clear_globs为true（默认值），则此命名空间将在测试运行后清除，以帮助垃圾容器。如果您想在测试完成后检查命名空间，请使用clear_globs = False。

compileflags提供了运行示例时应由Python编译器使用的一组标志。如果未指定，则它将默认为适用于globs的future-import标志集。

使用DocTestRunner的输出检查程序检查每个示例的输出，并通过DocTestRunner.report_*()方法对结果进行格式化。

summarize(verbose=None)

打印此DocTestRunner运行的所有测试用例的摘要，并返回named tuple TestResults（失败， 已尝试） t4 >。

可选的verbose参数控制摘要的详细程度。如果未指定详细程度，则使用DocTestRunner的详细程度。

26.3.6.6. OutputChecker objects

class doctest.OutputChecker

用于检查doctest示例的实际输出是否与预期输出匹配的类。OutputChecker定义两个方法：check_output()，比较给定的输出对，如果匹配则返回true；和output_difference()，它返回一个描述两个输出之间的差异的字符串。

OutputChecker定义以下方法：

check_output(want, got, optionflags)

如果示例（已获得）的实际输出与预期输出（想）匹配，则返回True。这些字符串总是被认为是匹配的，如果它们是相同的；但是根据测试运行程序正在使用的选项标志，几种非精确匹配类型也是可能的。有关选项标志的更多信息，请参阅Option Flags一节。

output_difference(example, got, optionflags)

返回描述给定示例（示例）的预期输出与实际输出（得到）之间的差异的字符串。optionflags是用于比较想要和得到的选项标志集。

26.3.7. Debugging

Doctest提供了几种调试doctest示例的机制：

• 几个函数将doctest转换为可执行的Python程序，可以在Python调试器pdb下运行。

• DebugRunner类是DocTestRunner的子类，引发第一个失败示例的异常，包含有关该示例的信息。此信息可用于对示例执行事后调试。

• DocTestSuite()生成的unittest案例支持unittest.TestCase定义的debug()方法。

• 您可以在doctest示例中添加对pdb.set_trace()的调用，并在执行该行时放入Python调试器。然后可以检查变量的当前值，等等。例如，假设a.py仅包含此模块docstring：

  """
  >>> def f(x):
  ...     g(x*2)
  >>> def g(x):
  ...     print(x+3)
  ...     import pdb; pdb.set_trace()
  >>> f(3)
  9
  """
  

  然后，交互式Python会话可能如下所示：

  >>> import a, doctest
  >>> doctest.testmod(a)
  --Return--
  > <doctest a[1]>(3)g()->None
  -> import pdb; pdb.set_trace()
  (Pdb) list
    1     def g(x):
    2         print(x+3)
    3  ->     import pdb; pdb.set_trace()
  [EOF]
  (Pdb) p x
  6
  (Pdb) step
  --Return--
  > <doctest a[0]>(2)f()->None
  -> g(x*2)
  (Pdb) list
    1     def f(x):
    2  ->     g(x*2)
  [EOF]
  (Pdb) p x
  3
  (Pdb) step
  --Return--
  > <doctest a[2]>(1)?()->None
  -> f(3)
  (Pdb) cont
  (0, 3)
  >>>
  

将doctest转换为Python代码的函数，并且可能在调试器下运行合成代码：

doctest.script_from_examples(s)

将文本与示例转换为脚本。

参数s是一个包含doctest示例的字符串。该字符串将转换为Python脚本，其中s中的doctest示例将转换为常规代码，其他所有内容将转换为Python注释。生成的脚本作为字符串返回。例如，

import doctest
print(doctest.script_from_examples(r"""
    Set x and y to 1 and 2.
    >>> x, y = 1, 2

    Print their sum:
    >>> print(x+y)
    3
"""))

显示：

# Set x and y to 1 and 2.
x, y = 1, 2
#
# Print their sum:
print(x+y)
# Expected:
## 3

这个函数在内部被其他函数使用（见下文），但是当你想将一个交互式Python会话转换为一个Python脚本时，也是有用的。

doctest.testsource(module, name)

将对象的doctest转换为脚本。

参数模块是模块对象或模块的点名，其中包含感兴趣的对象的对象。参数名称是具有感兴趣doctests的对象的名称（在模块内）。结果是一个字符串，包含对象的docstring转换为Python脚本，如上对script_from_examples()所述。例如，如果模块a.py包含顶层函数f()，则

import a, doctest
print(doctest.testsource(a, "a.f"))

打印函数f()的docstring的脚本版本，将doctests转换为代码，其余的放在注释中。

doctest.debug(module, name, pm=False)

调试对象的doctests。

模块和名称参数与上面的函数testsource()相同。命名对象的docstring的合成Python脚本被写入一个临时文件，然后该文件在Python调试器pdb的控制下运行。

module.__dict__的浅拷贝用于局部和全局执行上下文。

可选参数pm控制是否使用事后调试。如果pm具有真值，则脚本文件将直接运行，调试器仅在脚本通过提高未处理的异常而终止时才会涉及。如果是，则通过pdb.post_mortem()调用事后调试，从未处理的异常传递traceback对象。If pm is not specified, or is false, the script is run under the debugger from the start, via passing an appropriate exec() call to pdb.run().

doctest.debug_src(src, pm=False, globs=None)

在字符串中调试doctests。

这就像上面的函数debug()，除了通过src参数直接指定包含doctest示例的字符串。

可选参数pm与上述函数debug()中含义相同。

可选参数globs给出一个字典，用作局部和全局执行上下文。如果未指定，或None，则使用空字典。如果指定，则使用字典的浅拷贝。

DebugRunner类及其可能引发的特殊例外是测试框架作者最感兴趣的，并且只会在这里草拟。查看源代码，尤其是DebugRunner的docstring（这是一个doctest！）更多细节：

class doctest.DebugRunner(checker=None, verbose=None, optionflags=0)

遇到失败时引发异常的DocTestRunner子类。如果发生意外异常，则会引发UnexpectedException异常，其中包含测试，示例和原始异常。如果输出不匹配，则会引发DocTestFailure异常，包含测试，示例和实际输出。

有关构造函数参数和方法的信息，请参阅Advanced API部分中DocTestRunner的文档。

有DebugRunner实例可能会引发两个异常：

exception doctest.DocTestFailure(test, example, got)

由DocTestRunner引发的异常表示doctest示例的实际输出与其预期输出不匹配。构造函数参数用于初始化相同名称的属性。

DocTestFailure定义以下属性：

DocTestFailure.test

示例失败时运行的DocTest对象。

DocTestFailure.example

Example失败。

DocTestFailure.got

示例的实际输出。

exception doctest.UnexpectedException(test, example, exc_info)

由DocTestRunner引发的异常表示doctest示例引发了意外异常。构造函数参数用于初始化相同名称的属性。

UnexpectedException定义以下属性：

UnexpectedException.test

示例失败时运行的DocTest对象。

UnexpectedException.example

Example失败。

UnexpectedException.exc_info

包含由sys.exc_info()返回的意外异常的信息的元组。

26.3.8. Soapbox

如介绍中所述，doctest已经发展为具有三个主要用途：

1. 检查docstrings中的示例。
2. 回归测试。
3. 可执行文档/识字测试。

这些用途具有不同的要求，并且区分它们是重要的。特别是，用不明确的测试用例填充你的文档字符串会导致坏的文档。

当写docstring时，请谨慎选择docstring示例。有一件艺术，这需要学习 - 这可能不是很自然的开始。示例应该为文档增加真正的价值。一个很好的例子常常值得许多话。如果小心的话，这些例子对于你的用户将是无价的，并且将花费多少时间来收集它们的时间，因为随着时间的推移和事情的变化。我仍然惊讶于我的doctest示例在“无害”更改后停止工作的频率。

Doctest也是回归测试的一个很好的工具，特别是如果你不解释文本。通过交叉散文和示例，跟踪实际测试的内容变得更容易，为什么。当测试失败时，好的散文可以使得更容易找出问题是什么，以及如何修复它。这是真的，你可以在基于代码的测试中编写广泛的评论，但很少有程序员。许多人发现，使用doctest方法会导致更清晰的测试。也许这只是因为doctest使写散文比编写代码更容易，而在代码中写评论有点困难。我认为它深入的不仅仅是：在写一个基于doctest的测试的自然态度是，你想解释你的软件的精细点，并用例子说明。这反过来自然导致测试文件从最简单的功能开始，并在逻辑上进展到并发症和边缘情况。一个连贯的叙述是结果，而不是一个孤立的功能的容器，测试孤立的功能看起来随机的位。这是一种不同的态度，并产生不同的结果，模糊测试和解释之间的区别。

回归测试最好仅限于专用对象或文件。有几个组织测试的选项：

• 将包含测试用例的文本文件作为交互示例，并使用testfile()或DocFileSuite()测试文件。这是推荐，虽然是最容易做的新项目，设计从开始使用doctest。
• 定义名为_regrtest_topic的函数，它由单个文档字符串组成，包含命名主题的测试用例。这些功能可以包含在与模块相同的文件中，或者分离到单独的测试文件中。
• 定义从回归测试主题到包含测试用例的文档字符串的__test__字典映射。

当您将测试放在模块中时，模块本身可以是测试运行器。当测试失败时，您可以安排测试运行器在调试问题时仅重新运行失败的doctest。这里是这样的测试运行器的最小示例：

if __name__ == '__main__':
    import doctest
    flags = doctest.REPORT_NDIFF|doctest.FAIL_FAST
    if len(sys.argv) > 1:
        name = sys.argv[1]
        if name in globals():
            obj = globals()[name]
        else:
            obj = __test__[name]
        doctest.run_docstring_examples(obj, globals(), name=name,
                                       optionflags=flags)
    else:
        fail, total = doctest.testmod(optionflags=flags)
        print("{} failures out of {} tests".format(fail, total))

脚注

[1]	不支持包含预期输出和异常的示例。试图猜测一个结束和另一个开始是太容易出错，这也是一个混乱的测试。