189 8069 5689
主调函数是本身固有的数，被调函数是通过其他数计算出来的
创新互联，专注为中小企业提供官网建设、营销型网站制作、响应式网站开发、展示型成都网站建设、成都网站制作等服务，帮助中小企业通过网站体现价值、有效益。帮助企业快速建站、解决网站建设与网站营销推广问题。
主调函数 调用别的函数实现功能
例如 A是主调函数 B是被调函数
void A（）
{
B();
}
本文章讲述了如何用pdb进行python调试讲解.
当手边
没有IDE,面对着python调试犯愁时,你就可以参考下本文;(pdb 命令调试)
和 (pdb)help
用pdb进行python调试,用法基本和gdb差不多,
先看一个简单的例子:
epdb1.py .# epdb1.py -- experiment with the Python debugger, pdb
a = "aaa"
b = "bbb"
c = "ccc"
final = a + b + c
print final
比如要对这个程序进行调试:
1:在文件前面加上这一句,引入调试的模块。
import pdb
2:在要开始调试的一行加上pdb.set_trace()文件变成:
# epdb1.py -- experiment with the Python debugger, pdb
import pdb
a = "aaa"
pdb.set_trace()
b = "bbb"
c = "ccc"
final = a + b + c
print final 可以运行这个程序,到断点出会停下来,和gdb类似,
可以执行命令:
直接回车是重复前一条命令!
p(print) 查看一个变量值
n(next) 下一步
s(step) 单步,可进入函数
c(continue)继续前进
l(list)看源代码
用pdb调试有多种方式可选:
1.命令行启动目标程序,加上-m参数,这样调用myscript.py的话断点就是程序的执行第一行之前
python -m pdb myscript.py
2. 在Python交互环境中启用调试
import pdb
import mymodule
pdb.run('mymodule.test()')
3.比较常用的,就是在程序中间插入一段程序,相对于在一般IDE里面打上断点然后启动debug,不过这种方式是hardcode的 if __name__ == "__main__" :
a = 1
importpdb
pdb .set_trace()
b = 2
c = a + b
print( c)
然后正常运行脚本,到了pdb.set_trace()那就会定下来,就可以看到调试的提示符(Pdb)了
常用的调试命令 h(elp),会打印当前版本Pdb可用的命令,如果要查询某个命令,可以输入 h [command],例如:"h l" - 查看list命令
l(ist),可以列出当前将要运行的代码块
(Pdb) l
497 pdb.set_trace()
498 base_data = {}
499 new_data = {}
500 try:
501 execfile(base_file_name,{},base_data)
502 - execfile(new_file_name,{},new_data)
503 except:
504 logger.writeLog("error! load result log error!")
505 print "load cmp logs error!"
506 raise Exception, "load cmp logs error!"
507断点设置
(Pdb)b10 #断点设置在本py的第10行
或(Pdb)bots.py:20 #断点设置到 ots.py第20行
删除断点(Pdb)b #查看断点编号
(Pdb)cl 2 #删除第2个断点
运行
(Pdb)n #单步运行
(Pdb)s #细点运行 也就是会下到,方法
(Pdb)c #跳到下个断点
查看
(Pdb)p param #查看当前 变量值
(Pdb)l #查看运行到某处代码
(Pdb)a #查看全部栈内变量 b(reak), 设置断点,例如 "b 77″,就是在当前脚本的77行打上断点,还能输入函数名作为参数,断点就打到具体的函数入口,如果只敲b,会显示现有的全部断点
(Pdb) b 504
Breakpoint 4 at /home/jchen/regression/regressionLogCMP.py:504 condition bpnumber [condition],设置条件断点,下面语句就是对第4个断点加上条件"a==3"
(Pdb) condition 4 a==3
(Pdb) b
Num Type Disp Enb Where
4 breakpoint keep yes at /home/jchen/regression/regressionLogCMP.py:504
stop only if a==3 cl(ear),如果后面带有参数,就是清除指定的断点(我在Python2.4上从来没成功过!!!);如果不带参数就是清除所有的断点
(Pdb) cl
Clear all breaks? y disable/enable,禁用/激活断点
(Pdb) disable 3
(Pdb) b
Num Type Disp Enb Where
3 breakpoint keep no at /home/jchen/regression/regressionLogCMP.py:505 n(ext),让程序运行下一行,如果当前语句有一个函数调用,用n是不会进入被调用的函数体中的
s(tep),跟n相似,但是如果当前有一个函数调用,那么s会进入被调用的函数体中
c(ont(inue)),让程序正常运行,直到遇到断点
j(ump),让程序跳转到指定的行数
(Pdb) j 497
/home/jchen/regression/regressionLogCMP.py(497)com pareLog()
- pdb.set_trace() a(rgs),打印当前函数的参数
(Pdb) a
_logger =
_base = ./base/MRM-8137.log
_new = ./new/MRM-8137.log
_caseid = 5550001
_toStepNum = 10
_cmpMap = {'_bcmpbinarylog': 'True', '_bcmpLog': 'True', '_bcmpresp': 'True'} p,最有用的命令之一,打印某个变量
(Pdb) p _new
u'./new/MRM-8137.log' !,感叹号后面跟着语句,可以直接改变某个变量
q(uit),退出调试
==============================================================================================
在python中使用pdb模块可以进行调试
import pdb
pdb.set_trace()
也可以使用python -m pdb mysqcript.py这样的方式
(Pdb) 会自动停在第一行，等待调试,这时你可以看看 帮助
(Pdb) h
说明下这几个关键 命令
断点设置
(Pdb)b 10 #断点设置在本py的第10行
或(Pdb)b ots.py:20 #断点设置到 ots.py第20行
删除断点（Pdb）b #查看断点编号
(Pdb)cl 2 #删除第2个断点
运行
(Pdb)n #单步运行
(Pdb)s #细点运行 也就是会下到，方法
(Pdb)c #跳到下个断点
查看
(Pdb)p param #查看当前 变量值
(Pdb)l #查看运行到某处代码
(Pdb)a #查看全部栈内变量
(Pdb)w 列出目前call stack 中的所在层。
(Pdb)d 在call stack中往下移一层
(Pdb)u 在call stack中往上移一层。如果在上移一层之后按下 n ,则会在上移之后的一层执行下一个叙述,之前的 function call 就自动返回。
(Pdb)cl 清除指定的断点。如果没有带参数,则清除所有断点。
(Pdb)disable 取消所有断点的功能,但仍然保留这些断点。
(Pdb)enable 恢复断点的功能。
(Pdb)ignore 设定断点的忽略次数。如果没指定 count,其初始 为 0。当 count 为 0 时,断点会正常动作。若有指定 count,则每次执行到该中断, count 就少 1,直到 count 数为 0。
(Pdb)condition bpnumber [condition]
(Pdb)j(ump) lineNo. 跳到某行执行。只有在 call stack 的最底部才能作用。
(Pdb)l 列出目前所在档案中的位置。连续地 l 命令会一直列到档案结尾,可以使用指定行数或范围来打印。
(Pdb)pp 和 p 命令类似,但是使用 pprint module(没用过 pprint,详情请参考 Python Library Reference)。
(Pdb)alias 以一个"别名"代替"一群除错命令",有点类似 c/c 的 macro(详情请参考 Python Library Reference)。
(Pdb)unalias 取消某个 alias。
(Pdb)[!]statement 在目前的环境(context)中执行叙述。
转载
装个Pycharm
1 添加断点
2 Debug下运行代码：
3 F8：进行下一步操作
F7 ：跳入下一个方法中
单元测试（Unit Testing）
为程序编写测试——如果做的到位——有助于减少bug的出现，并可以提高我们对程序按预期目标运行的信心。通常，测试并不能保证正确性，因为对大多数程序而言， 可能的输入范围以及可能的计算范围是如此之大，只有其中最小的一部分能被实际地进 行测试。尽管如此，通过仔细地选择测试的方法和目标，可以提高代码的质量。
大量不同类型的测试都可以进行，比如可用性测试、功能测试以及整合测试等。这里, 我们只讲单元测试一对单独的函数、类与方法进行测试，确保其符合预期的行为。
TDD的一个关键点是，当我们想添加一个功能时——比如为类添加一个方法—— 我们首次为其编写一个测试用例。当然，测试将失败，因为我们还没有实际编写该方法。现在，我们编写该方法，一旦方法通过了测试，就可以返回所有测试，确保我们新添加的代码没有任何预期外的副作用。一旦所有测试运行完毕（包括我们为新功能编写的测试），就可以对我们的代码进行检查，并有理有据地相信程序行为符合我们的期望——当然，前提是我们的测试是适当的。
比如，我们编写了一个函数，该函数在特定的索引位置插入一个字符串，可以像下面这样开始我们的TDD：
def insert_at（string, position, insert）:
"""Returns a copy of string with insert inserted at the position
string = "ABCDE"
result =[]
for i in range(-2, len(string) + 2):
... result.append(insert_at(string, i,“-”))
result[:5]
['ABC-DE', 'ABCD-E', '-ABCDE','A-BCDE', 'AB-CDE']
result[5:]
['ABC-DE', 'ABCD-E', 'ABCDE-', 'ABCDE-']
"""
return string
对不返回任何参数的函数或方法（通常返回None）,我们通常赋予其由pass构成的一个suite,对那些返回值被试用的，我们或者返回一个常数（比如0）,或者某个不变的参数——这也是我们这里所做的。（在更复杂的情况下，返回fake对象可能更有用一一对这样的类，提供mock对象的第三方模块是可用的。）
运行doctest时会失败，并列出每个预期内的字符串（'ABCD-EF'、'ABCDE-F' 等），及其实际获取的字符串（所有的都是'ABCD-EF'）。一旦确定doctest是充分的和正确的，就可以编写该函数的主体部分，在本例中只是简单的return string[:position] + insert+string[position:]。（如果我们编写的是 return string[:position] + insert,之后复制 string [:position]并将其粘贴在末尾以便减少一些输入操作，那么doctest会立即提示错误。）
Python的标准库提供了两个单元测试模块，一个是doctest,这里和前面都简单地提到过，另一个是unittest。此外，还有一些可用于Python的第三方测试工具。其中最著名的两个是nose (code.google.com/p/python-nose)与py.test (codespeak.net/py/dist/test/test.html), nose 致力于提供比标准的unittest 模块更广泛的功能，同时保持与该模块的兼容性，py.test则采用了与unittest有些不同的方法，试图尽可能消除样板测试代码。这两个第三方模块都支持测试发现，因此没必要写一个总体的测试程序——因为模块将自己搜索测试程序。这使得测试整个代码树或某一部分 (比如那些已经起作用的模块)变得很容易。那些对测试严重关切的人，在决定使用哪个测试工具之前，对这两个(以及任何其他有吸引力的)第三方模块进行研究都是值 得的。
创建doctest是直截了当的：我们在模块中编写测试、函数、类与方法的docstrings。 对于模块，我们简单地在末尾添加了 3行：
if __name__ =="__main__":
import doctest
doctest.testmod()
在程序内部使用doctest也是可能的。比如，blocks.py程序(其模块在后面)有自己函数的doctest，但以如下代码结尾：
if __name__== "__main__":
main()
这里简单地调用了程序的main()函数，并且没有执行程序的doctest。要实验程序的 doctest,有两种方法。一种是导入doctest模块，之后运行程序---比如，在控制台中输 入 python3 -m doctest blocks.py (在 Wndows 平台上，使用类似于 C:Python3 lpython.exe 这样的形式替代python3)。如果所有测试运行良好，就没有输出，因此，我们可能宁愿执行python3-m doctest blocks.py-v,因为这会列出每个执行的doctest,并在最后给出结果摘要。
另一种执行doctest的方法是使用unittest模块创建单独的测试程序。在概念上， unittest模块是根据Java的JUnit单元测试库进行建模的，并用于创建包含测试用例的测试套件。unittest模块可以基于doctests创建测试用例，而不需要知道程序或模块包含的任何事物——只要知道其包含doctest即可。因此，为给blocks.py程序制作一个测试套件，我们可以创建如下的简单程序(将其称为test_blocks.py)：
import doctest
import unittest
import blocks
suite = unittest.TestSuite()
suite.addTest(doctest.DocTestSuite(blocks))
runner = unittest.TextTestRunner()
print(runner.run(suite))
注意，如果釆用这种方法，程序的名称上会有一个隐含的约束：程序名必须是有效的模块名。因此，名为convert-incidents.py的程序的测试不能写成这样。因为import convert-incidents不是有效的，在Python标识符中，连接符是无效的（避开这一约束是可能的，但最简单的解决方案是使用总是有效模块名的程序文件名，比如，使用下划线替换连接符）。这里展示的结构（创建一个测试套件，添加一个或多个测试用例或测试套件，运行总体的测试套件，输出结果）是典型的机遇unittest的测试。运行时，这一特定实例产生如下结果：
...
.............................................................................................................
Ran 3 tests in 0.244s
OK
每次执行一个测试用例时，都会输出一个句点（因此上面的输出最前面有3个句点），之后是一行连接符，再之后是测试摘要（如果有任何一个测试失败，就会有更多的输出信息）。
如果我们尝试将测试分离开（典型情况下是要测试的每个程序和模块都有一个测试用例），就不要再使用doctests,而是直接使用unittest模块的功能——尤其是我们习惯于使用JUnit方法进行测试时ounittest模块会将测试分离于代码——对大型项目（测试编写人员与开发人员可能不一致）而言，这种方法特别有用。此外，unittest单元测试编写为独立的Python模块，因此，不会像在docstring内部编写测试用例时受到兼容性和明智性的限制。
unittest模块定义了 4个关键概念。测试夹具是一个用于描述创建测试（以及用完之后将其清理）所必需的代码的术语，典型实例是创建测试所用的一个输入文件，最后删除输入文件与结果输出文件。测试套件是一组测试用例的组合。测试用例是测试的基本单元—我们很快就会看到实例。测试运行者是执行一个或多个测试套件的对象。
典型情况下，测试套件是通过创建unittest.TestCase的子类实现的，其中每个名称 以“test”开头的方法都是一个测试用例。如果我们需要完成任何创建操作，就可以在一个名为setUp()的方法中实现；类似地，对任何清理操作，也可以实现一个名为 tearDown()的方法。在测试内部，有大量可供我们使用的unittest.TestCase方法，包括 assertTrue()、assertEqual()、assertAlmostEqual()（对于测试浮点数很有用）、assertRaises() 以及更多，还包括很多对应的逆方法，比如assertFalse()、assertNotEqual()、failIfEqual()、 failUnlessEqual ()等。
unittest模块进行了很好的归档，并且提供了大量功能，但在这里我们只是通过一 个非常简单的测试套件来感受一下该模块的使用。这里将要使用的实例,该练习要求创建一个Atomic模块，该模块可以用作一 个上下文管理器，以确保或者所有改变都应用于某个列表、集合或字典，或者所有改变都不应用。作为解决方案提供的Atomic.py模块使用30行代码来实现Atomic类， 并提供了 100行左右的模块doctest。这里，我们将创建test_Atomic.py模块，并使用 unittest测试替换doctest,以便可以删除doctest。
在编写测试模块之前，我们需要思考都需要哪些测试。我们需要测试3种不同的数据类型：列表、集合与字典。对于列表，需要测试的是插入项、删除项或修改项的值。对于集合，我们必须测试向其中添加或删除一个项。对于字典，我们必须测试的是插入一个项、修改一个项的值、删除一个项。此外，还必须要测试的是在失败的情况下，不会有任何改变实际生效。
结构上看，测试不同数据类型实质上是一样的，因此，我们将只为测试列表编写测试用例，而将其他的留作练习。test_Atomic.py模块必须导入unittest模块与要进行测试的Atomic模块。
创建unittest文件时，我们通常创建的是模块而非程序。在每个模块内部，我们定义一个或多个unittest.TestCase子类。比如，test_Atomic.py模块中仅一个单独的 unittest-TestCase子类，也就是TestAtomic (稍后将对其进行讲解)，并以如下两行结束:
if name == "__main__":
unittest.main()
这两行使得该模块可以单独运行。当然，该模块也可以被导入并从其他测试程序中运行——如果这只是多个测试套件中的一个，这一点是有意义的。
如果想要从其他测试程序中运行test_Atomic.py模块，那么可以编写一个与此类似的程序。我们习惯于使用unittest模块执行doctests,比如：
import unittest
import test_Atomic
suite = unittest.TestLoader().loadTestsFromTestCase(test_Atomic.TestAtomic)
runner = unittest.TextTestRunner()
pnnt(runner.run(suite))
这里，我们已经创建了一个单独的套件，这是通过让unittest模块读取test_Atomic 模块实现的，并且使用其每一个test*()方法(本实例中是test_list_success()、test_list_fail()，稍后很快就会看到)作为测试用例。
我们现在将查看TestAtomic类的实现。对通常的子类(不包括unittest.TestCase 子类)，不怎么常见的是，没有必要实现初始化程序。在这一案例中，我们将需要建立 一个方法，但不需要清理方法，并且我们将实现两个测试用例。
def setUp(self)：
self.original_list = list(range(10))
我们已经使用了 unittest.TestCase.setUp()方法来创建单独的测试数据片段。
def test_list_succeed(self):
items = self.original_list[:]
with Atomic.Atomic(items) as atomic:
atomic.append(1999)
atomic.insert(2, -915)
del atomic[5]
atomic[4]= -782
atomic.insert(0, -9)
self.assertEqual(items,
[-9, 0, 1, -915, 2, -782, 5, 6, 7, 8, 9, 1999])
def test_list_fail(self):
items = self.original_list[:]
with self.assertRaises(AttributeError):
with Atomic.Atomic(items) as atomic:
atomic.append(1999)
atomic.insert(2, -915)
del atomic[5]
atomic[4] = -782
atomic.poop() # Typo
self.assertListEqual(items, self.original_list)
这里，我们直接在测试方法中编写了测试代码，而不需要一个内部函数，也不再使用unittest.TestCase.assertRaised()作为上下文管理器(期望代码产生AttributeError)。 最后我们也使用了 Python 3.1 的 unittest.TestCase.assertListEqual()方法。
正如我们已经看到的，Python的测试模块易于使用，并且极为有用，在我们使用 TDD的情况下更是如此。它们还有比这里展示的要多得多的大量功能与特征——比如，跳过测试的能力，这有助于理解平台差别——并且这些都有很好的文档支持。缺失的一个功能——但nose与py.test提供了——是测试发现，尽管这一特征被期望在后续的Python版本(或许与Python 3.2—起)中出现。
性能剖析（Profiling）
如果程序运行很慢，或者消耗了比预期内要多得多的内存，那么问题通常是选择的算法或数据结构不合适，或者是以低效的方式进行实现。不管问题的原因是什么， 最好的方法都是准确地找到问题发生的地方,而不只是检査代码并试图对其进行优化。 随机优化会导致引入bug,或者对程序中本来对程序整体性能并没有实际影响的部分进行提速，而这并非解释器耗费大部分时间的地方。
在深入讨论profiling之前，注意一些易于学习和使用的Python程序设计习惯是有意义的，并且对提高程序性能不无裨益。这些技术都不是特定于某个Python版本的， 而是合理的Python程序设计风格。第一，在需要只读序列时，最好使用元组而非列表； 第二，使用生成器，而不是创建大的元组和列表并在其上进行迭代处理；第三，尽量使用Python内置的数据结构 dicts、lists、tuples 而不实现自己的自定义结构，因为内置的数据结构都是经过了高度优化的；第四，从小字符串中产生大字符串时， 不要对小字符串进行连接，而是在列表中累积，最后将字符串列表结合成为一个单独的字符串；第五，也是最后一点，如果某个对象(包括函数或方法)需要多次使用属性进行访问(比如访问模块中的某个函数)，或从某个数据结构中进行访问，那么较好的做法是创建并使用一个局部变量来访问该对象，以便提供更快的访问速度。
Python标准库提供了两个特别有用的模块，可以辅助调査代码的性能问题。一个是timeit模块——该模块可用于对一小段Python代码进行计时，并可用于诸如对两个或多个特定函数或方法的性能进行比较等场合。另一个是cProfile模块，可用于profile 程序的性能——该模块对调用计数与次数进行了详细分解，以便发现性能瓶颈所在。
为了解timeit模块，我们将查看一些小实例。假定有3个函数function_a()、 function_b()、function_c(), 3个函数执行同样的计算，但分别使用不同的算法。如果将这些函数放于同一个模块中(或分别导入)，就可以使用timeit模块对其进行运行和比较。下面给出的是模块最后使用的代码：
if __name__ == "__main__":
repeats = 1000
for function in ("function_a", "function_b", "function_c"):
t = timeit.Timer("{0}(X, Y)".format(function),"from __main__ import {0}, X, Y".format(function))
sec = t.timeit(repeats) / repeats
print("{function}() {sec:.6f} sec".format(**locals()))
赋予timeit.Timer()构造子的第一个参数是我们想要执行并计时的代码，其形式是字符串。这里，该字符串是“function_a(X,Y)”；第二个参数是可选的，还是一个待执行的字符串，这一次是在待计时的代码之前，以便提供一些建立工作。这里，我们从 __main__ (即this)模块导入了待测试的函数，还有两个作为输入数据传入的变量(X 与Y),这两个变量在该模块中是作为全局变量提供的。我们也可以很轻易地像从其他模块中导入数据一样来进行导入操作。
调用timeit.Timer对象的timeit()方法时，首先将执行构造子的第二个参数(如果有)， 之后执行构造子的第一个参数并对其执行时间进行计时。timeit.Timer.timeit()方法的返回值是以秒计数的时间，类型是float。默认情况下，timeit()方法重复100万次，并返回所 有这些执行的总秒数，但在这一特定案例中，只需要1000次反复就可以给出有用的结果, 因此对重复计数次数进行了显式指定。在对每个函数进行计时后，使用重复次数对总数进行除法操作，就得到了平均执行时间，并在控制台中打印出函数名与执行时间。
function_a() 0.001618 sec
function_b() 0.012786 sec
function_c() 0.003248 sec
在这一实例中，function_a()显然是最快的——至少对于这里使用的输入数据而言。 在有些情况下一一比如输入数据不同会对性能产生巨大影响——可能需要使用多组输入数据对每个函数进行测试，以便覆盖有代表性的测试用例，并对总执行时间或平均执行时间进行比较。
有时监控自己的代码进行计时并不是很方便，因此timeit模块提供了一种在命令行中对代码执行时间进行计时的途径。比如，要对MyModule.py模块中的函数function_a()进行计时，可以在控制台中输入如下命令：python3 -m timeit -n 1000 -s "from MyModule import function_a, X, Y" "function_a(X, Y)"(与通常所做的一样，对 Windows 环境，我们必须使用类似于C:Python3lpython.exe这样的内容来替换python3)。-m选项用于Python 解释器，使其可以加载指定的模块(这里是timeit),其他选项则由timeit模块进行处理。 -n选项指定了循环计数次数，-s选项指定了要建立，最后一个参数是要执行和计时的代码。命令完成后，会向控制台中打印运行结果，比如：
1000 loops, best of 3: 1.41 msec per loop
之后我们可以轻易地对其他两个函数进行计时，以便对其进行整体的比较。
cProfile模块(或者profile模块，这里统称为cProfile模块)也可以用于比较函数 与方法的性能。与只是提供原始计时的timeit模块不同的是，cProfile模块精确地展示 了有什么被调用以及每个调用耗费了多少时间。下面是用于比较与前面一样的3个函数的代码：
if __name__ == "__main__":
for function in ("function_a", "function_b", "function_c"):
cProfile.run("for i in ranged 1000): {0}(X, Y)".format(function))
我们必须将重复的次数放置在要传递给cProfile.run()函数的代码内部，但不需要做任何创建，因为模块函数会使用内省来寻找需要使用的函数与变量。这里没有使用显式的print()语句，因为默认情况下，cProfile.run()函数会在控制台中打印其输出。下面给出的是所有函数的相关结果(有些无关行被省略，格式也进行了稍许调整，以便与页面适应)：
1003 function calls in 1.661 CPU seconds
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.003 0.003 1.661 1.661 :1 ( )
1000 1.658 0.002 1.658 0.002 MyModule.py:21 (function_a)
1 0.000 0.000 1.661 1.661 {built-in method exec}
5132003 function calls in 22.700 CPU seconds
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.487 0.487 22.700 22.700 : 1 ( )
1000 0.011 0.000 22.213 0.022 MyModule.py:28(function_b)
5128000 7.048 0.000 7.048 0.000 MyModule.py:29( )
1000 0.00 50.000 0.005 0.000 {built-in method bisectjeft}
1 0.000 0.000 22.700 22.700 {built-in method exec}
1000 0.001 0.000 0.001 0.000 {built-in method len}
1000 15.149 0.015 22.196 0.022 {built-in method sorted}
5129003 function calls in 12.987 CPU seconds
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.205 0.205 12.987 12.987 :l ( )
1000 6.472 0.006 12.782 0.013 MyModule.py:36(function_c)
5128000 6.311 0.000 6.311 0.000 MyModule.py:37( )
1 0.000 0.000 12.987 12.987 {built-in method exec}
ncalls ("调用的次数")列列出了对指定函数(在filename:lineno(function)中列出) 的调用次数。回想一下我们重复了 1000次调用，因此必须将这个次数记住。tottime (“总的时间”)列列出了某个函数中耗费的总时间，但是排除了函数调用的其他函数内部花费的时间。第一个percall列列出了对函数的每次调用的平均时间(tottime // ncalls)。 cumtime ("累积时间")列出了在函数中耗费的时间，并且包含了函数调用的其他函数内部花费的时间。第二个percall列列出了对函数的每次调用的平均时间，包括其调用的函数耗费的时间。
这种输出信息要比timeit模块的原始计时信息富有启发意义的多。我们立即可以发现，function_b()与function_c()使用了被调用5000次以上的生成器，使得它们的速度至少要比function_a()慢10倍以上。并且，function_b()调用了更多通常意义上的函数，包括调用内置的sorted()函数，这使得其几乎比function_c()还要慢两倍。当然,timeit() 模块提供了足够的信息来查看计时上存在的这些差别，但cProfile模块允许我们了解为什么会存在这些差别。正如timeit模块允许对代码进行计时而又不需要对其监控一样，cProfile模块也可以做到这一点。然而，从命令行使用cProfile模块时，我们不能精确地指定要执行的 是什么——而只是执行给定的程序或模块，并报告所有这些的计时结果。需要使用的 命令行是python3 -m cProfile programOrModule.py,产生的输出信息与前面看到的一 样，下面给出的是输出信息样例，格式上进行了一些调整，并忽略了大多数行：
10272458 function calls (10272457 primitive calls) in 37.718 CPU secs
ncalls tottime percall cumtime percall filename:lineno(function)
10.000 0.000 37.718 37.718 :1 ( )
10.719 0.719 37.717 37.717 :12( )
1000 1.569 0.002 1.569 0.002 :20(function_a)
1000 0.011 0.000 22.560 0.023 :27(function_b)
5128000 7.078 0.000 7.078 0.000 :28( )
1000 6.510 0.007 12.825 0.013 :35(function_c)
5128000 6.316 0.000 6.316 0.000 :36( )
在cProfile术语学中，原始调用指的就是非递归的函数调用。
以这种方式使用cProfile模块对于识别值得进一步研究的区域是有用的。比如，这里 我们可以清晰地看到function_b()需要耗费更长的时间，但是我们怎样获取进一步的详细资料？我们可以使用cProfile.run("function_b()")来替换对function_b()的调用。或者可以保存完全的profile数据并使用pstats模块对其进行分析。要保存profile,就必须对命令行进行稍许修改:python3 -m cProfile -o profileDataFile programOrModule.py。 之后可以对 profile 数据进行分析，比如启动IDLE,导入pstats模块，赋予其已保存的profileDataFile,或者也可以在控制台中交互式地使用pstats。
下面给出的是一个非常短的控制台会话实例，为使其适合页面展示，进行了适当调整，我们自己的输入则以粗体展示：
$ python3 -m cProfile -o profile.dat MyModule.py
$ python3 -m pstats
Welcome to the profile statistics browser.
% read profile.dat
profile.dat% callers function_b
Random listing order was used
List reduced from 44 to 1 due to restriction
Function was called by...
ncalls tottime cumtime
:27(function_b) - 1000 0.011 22.251 :12( )
profile.dat% callees function_b
Random listing order was used
List reduced from 44 to 1 due to restriction
Function called...
ncalls tottime cumtime
:27(function_b)-
1000 0.005 0.005 built-in method bisectJeft
1000 0.001 0.001 built-in method len
1000 1 5.297 22.234 built-in method sorted
profile.dat% quit
输入help可以获取命令列表，help后面跟随命令名可以获取该命令的更多信息。比如, help stats将列出可以赋予stats命令的参数。还有其他一些可用的工具，可以提供profile数据的图形化展示形式，比如 RunSnakeRun (), 该工具需要依赖于wxPython GUI库。
使用timeit与cProfile模块，我们可以识别出我们自己代码中哪些区域会耗费超过预期的时间；使用cProfile模块，还可以准确算岀时间消耗在哪里。
以上内容部分摘自视频课程 05后端编程Python-19调试、测试和性能调优(下) ，更多实操示例请参照视频讲解。跟着张员外讲编程，学习更轻松，不花钱还能学习真本领。
目录
许多编程语言都有一个特殊的函数，当操作系统开始运行程序时会自动执行该函数。这个函数通常被命名为main()，并且依据语言标准具有特定的返回类型和参数。另一方面，Python解释器从文件顶部开始执行脚本，并且没有自动执行的特殊函数。
尽管如此，为程序的执行定义一个起始点有助于理解程序是如何运行的。Python程序员提出了几种方式对此进行实现。
本文结束时，您将了解以下内容：
Python中的基本main()函数
一些Python脚本中，包含一个函数定义和一个条件语句，如下所示：
此代码中，包含一个main()函数，在程序执行时打印Hello World!。此外，还包含一个条件（或if）语句，用于检查__name__的值并将其与字符串"__main__"进行比较。当if语句为True时，Python解释器将执行main()函数。更多关于Python条件语句的信息可以由此获得。
这种代码模式在Python文件中非常常见，它将作为脚本执行并导入另一个模块。为了帮助理解这段代码的执行方式，首先需要了解Python解释器如何根据代码的执行方式设置__name__。
Python中的执行模式
Python解释器执行代码有两种方式：
更多内容可参考如何运行Python脚本。无论采用哪种方式，Python都会定义一个名为__name__的特殊变量，该变量包含一个字符串，其值取决于代码的使用方式。
本文将如下示例文件保存为execution_methods.py，以 探索 代码如何根据上下文改变行为：
在此文件中，定义了三个对print()函数的调用。前两个打印一些介绍性短语。第三个print()会先打印短语The value __name__ is，之后将使用Python内置的repr()函数打印出__name__变量。
在Python中，repr()函数将对象转化为供解释器读取的形式。上述示例通过使用repr()函数来强调__name__的值为字符串。更多关于repr()的内容可参考Python文档。
在本文中，您将随处可见文件(file)，模块(module)和脚本(script)这三个字眼。实际上，三者之间并无太大的差别。不过，在强调代码目的时，还是存在细微的差异：
“如何运行Python脚本”一文也讨论了三者的差别。
基于命令行执行
在这类方法中，Python脚本将通过命令行来执行。
执行脚本时，无法与Python解释器正在执行的代码交互。关于如何通过命令行执行代码的详细信息对本文而言并不重要，但您可以通过展开下框阅读更多有关Windows，Linux和macOS之间命令行差异的内容。
命令行环境
不同的操作系统在使用命令行执行代码时存在细微的差异。
在Linux和macOS中，通常使用如下命令：
美元符号($)之前的内容可能有所不同，具体取决于您的用户名和计算机名称。您键入的命令位于$之后。在Linux或macOS上，Python3的可执行文件名为python3，因此可以通过输入python3 script_name.py来运行python脚本。
在Windows上，命令提示符通常如下所示：
根据您的用户名，之前的内容可能会有所不同，您输入的命令位于之后。在Windows上，Python3的可执行文件通常为python。因此可以通过输入python script_name.py来运行python脚本。
无论哪种操作系统，本文的Python脚本的输出结果都是相同的。因此本文以Linux和macOS为例。
使用命令行执行execution_methods.py，如下所示：
在这个示例中，__name__具有值'__main__'，其中引号(')表明该值为字符串类型。
请记住，在Python中，使用单引号(')和双引号(")定义的字符串没有区别。更多关于字符串的内容请参考Python的基本数据类型。
如果在脚本中包含"shebang行"并直接执行它(./execution_methods.py)，或者使用IPython或Jupyter Notebook的%run，将会获取相同的结果。
您还可以通过向命令行添加-m参数的方法实现以模块的方式执行。通常情况下，推荐如下方式pip: python3 -m pip install package_name。
添加-m参数将会运行包中__main__.py的代码。更多关于__main__.py文件的内容可参考如何将开源Python包发布到PyPI中。
在三种情况中，__name__都具有相同的值：字符串'__main__'。
技术细节：Python文档中具体定义了__name__何时取值为'__main__'。
当通过标准输入，脚本或者交互提示中读取数据时，模块的__name__将取值为'__main__'。（来源）
__name__与__doc__，__package__和其他属性一起存储在模块的全局命名空间。更多关于属性的信息可参考Python数据模型文档，特别是关于模块和包的信息，请参阅Python Import文档。
导入模块或解释器
接下来是Python解释器执行代码的第二种方式：导入。在开发模块或脚本时，可以使用import关键字导入他人已经构建的模块。
在导入过程中，Python执行指定模块中定义的语句（但仅在第一次导入模块时）。要演示导入execution_methods.py文件的结果，需要启动Python解释器，然后导入execution_methods.py文件：
在此代码输出中，Python解释器执行了三次print()函数调用。前两行由于没有变量，在输出方面与在命令行上作为脚本执行时完全相同。但是第三个输出存在差异。
当Python解释器导入代码时，__name__的值与要导入的模块的名称相同。您可以通过第三行的输出了解这一点。__name__的值为'execution_methods'，是Python导入的.py文件。
注意如果您在没有退出Python时再次导入模块，将不会有输出。
注意：更多关于导入在Python中如何工作的内容请参考官方文档和Python中的绝对和相对导入。
Main函数的最佳实践
既然您已经了解两种执行方式上的差异，那么掌握一些最佳实践方案还是很有用的。它们将适用于编写作为脚本运行的代码或者在另一个模块导入的代码。
如下是四种实践方式：
将大部分代码放入函数或类中
请记住，Python解释器在导入模块时会执行模块中的所有代码。有时如果想要实现用户可控的代码，会导致一些副作用，例如：
在这种情况下，想要实现用户控制触发此代码的执行，而不是让Python解释器在导入模块时执行代码。
因此，最佳方法是将大部分代码包含在函数或类中。这是因为当Python解释器遇到def或class关键字时，它只存储这些定义供以后使用，并且在用户通知之前不会实际执行。
将如下代码保存在best_practices.py以证明这个想法：
在此代码中，首先从time模块中导入sleep()。
在这个示例中，参数以秒的形式传入sleep()函数中，解释器将暂停一段时间再运行。随后，使用print()函数打印关于代码描述的语句。
之后，定义一个process_data()函数，执行如下五项操作：
在命令行中执行
当你将此文件作为脚本用命令行执行时会发生什么呢？
Python解释器将执行函数定义之外的from time import sleep和print()，之后将创建函数process_data()。然后，脚本将退出而不做任何进一步的操作，因为脚本没有任何执行process_data()的代码。
如下是这段脚本的执行结果：
我们在这里看到的输出是第一个print()的结果。注意，从time导入和定义process_data()函数不产生结果。具体来说，调用定义在process_data()内部的print()不会打印结果。
导入模块或解释器执行
在会话（或其他模块）中导入此文件时，Python解释器将执行相同的步骤。
Python解释器导入文件后，您可以使用已导入模块中定义的任何变量，类或函数。为了证明这一点，我们将使用可交互的Python解释器。启动解释器，然后键入import best_practices：
导入best_practices.py后唯一的输出来自process_data()函数外定义的print()。导入模块或解释器执行与基于命令行执行类似。
使用__name__控制代码的执行
如何实现基于命令行而不使用Python解释器导入文件来执行呢？
您可以使用__name__来决定执行上下文，并且当__name__等于"__main__"时才执行process_data()。在best_practices.py文件中添加如下代码：
这段代码添加了一个条件语句来检验__name__的值。当值为"__main__"时，条件为True。记住当__name__变量的特殊值为"__main__"时意味着Python解释器会执行脚本而不是将其导入。
条件语块内添加了四行代码（第12，13，14和15行）：
现在，在命令行中运行best_practices.py，并观察输出的变化：
首先，输出显示了process_data()函数外的print()的调用结果。
之后，data的值被打印。因为当Python解释器将文件作为脚本执行时，变量__name__具有值"__main__"，因此条件语句被计算为True。
接下来，脚本将调用process_data()并传入data进行修改。当process_data执行时，将输出一些状态信息。最终，将输出modified_data的值。
现在您可以验证从解释器（或其他模块）导入best_practices.py后发生的事情了。如下示例演示了这种情况：
注意，当前结果与将条件语句添加到文件末尾之前相同。因为此时__name__变量的值为"best_practices"，因此条件语句结果为False，Python将不执行process_data()。
创建名为main()的函数来包含要运行的代码
现在，您可以编写作为脚本由从命令行执行并导入且没有副作用的Python代码。接下来，您将学习如何编写代码并使其他程序员能轻松地理解其含义。
许多语言，如C，C++，Java以及其他的一些语言，都会定义一个叫做main()的函数，当编译程序时，操作系统会自动调用该函数。此函数通常被称为入口点(entry point)，因为它是程序进入执行的起始位置。
相比之下，Python没有一个特殊的函数作为脚本的入口点。实际上在Python中可以将入口点定义成任何名称。
尽管Python不要求将函数命名为main()，但是最佳的做法是将入口点函数命名为main()。这样方便其他程序员定位程序的起点。
此外，main()函数应该包含Python解释器执行文件时要运行的任何代码。这比将代码放入条件语块中更好，因为用户可以在导入模块时重复使用main()函数。
修改best_practices.py文件如下所示：
在这个示例中，定义了一个main()函数，它包含了上面的条件语句块。之后修改条件语块执行main()。如果您将此代码作为脚本运行或导入，将获得与上一节相同的输出。
在main()中调用其他函数
另一种常见的实现方式是在main()中调用其他函数，而不是直接将代码写入main()。这样做的好处在于可以实现将几个独立运行的子任务整合。
例如，某个脚本有如下功能：
如果在单独的函数中各自实现这些子任务，您（或其他用户）可以很容易地实现代码重用。之后您可以在main()函数中创建默认的工作流。
您可以根据自己的情况选择是否使用此方案。将任务拆分为多个函数会使重用更容易，但会增加他人理解代码的难度。
修改best_practices.py文件如下所示：
在此示例代码中，文件的前10行具有与之前相同的内容。第12行的第二个函数创建并返回一些示例数据，第17行的第三个函数模拟将修改后的数据写入数据库。
第21行定义了main()函数。在此示例中，对main()做出修改，它将调用数据读取，数据处理以及数据写入等功能。
首先，从read_data_from_web()中创建data。将data作为参数传入process_data()，之后将返回modified_data。最后，将modified_data传入write_data_to_database()。
脚本的最后两行是条件语块用于验证__name__，并且如果if语句为True，则执行main()。
在命令行中运行如下所示：
根据执行结果，Python解释器在执行main()函数时，将依次执行read_data_from_web()，process_data()以及write_data_to_database()。当然，您也可以导入best_practices.py文件并重用process_data()作为不同的数据输入源，如下所示：
在此示例中，导入了best_practices并且将其简写为bp。
导入过程会导致Python解释器执行best_practices.py的全部代码，因此输出显示解释文件用途的信息。
然后，从文件中存储数据而不是从Web中读取数据。之后，可以重用best_practices.py文件中的process_data()和write_data_to_database()函数。在此情况下，可以利用代码重写来取代在main()函数中实现全部的代码逻辑。
实践总结
以下是Python中main()函数的四个关键最佳实践：
结论
恭喜！您现在已经了解如何创建Python main()函数了。
本文介绍了如下内容：
现在，您可以开始编写一些非常棒的关于Python main()函数代码啦！