首先，我们可以使用快速然而粗糙的工具：古老的unix工具time，来为我们的代码检测运行时间。
1$ time python yourprogram.py
2
3real0m1.028s
4user0m0.001s
5sys 0m0.003s
上面三个输入变量的意义在文章 stackoverflow article 中有详细介绍。简单的说：
real - 表示实际的程序运行时间
user - 表示程序在用户态的cpu总时间
sys - 表示在内核态的cpu总时间
通过sys和user时间的求和，你可以直观的得到系统上没有其他程序运行时你的程序运行所需要的CPU周期。
若sys和user时间之和远远少于real时间，那么你可以猜测你的程序的主要性能问题很可能与IO等待相关。
使用计时上下文管理器进行细粒度计时
我们的下一个技术涉及访问细粒度计时信息的直接代码指令。这是一小段代码，我发现使用专门的计时测量是非常重要的：
timer.py
01import time
02
03class Timer(object):
04def __init__(self, verbose=False):
05self.verbose = verbose
06
07def __enter__(self):
08self.start = time.time()
09return self
10
11def __exit__(self, *args):
12self.end = time.time()
13self.secs = self.end - self.start
14self.msecs = self.secs * 1000 # millisecs
15if self.verbose:
16print 'elapsed time: %f ms' % self.msecs
为了使用它，你需要用Python的with关键字和Timer上下文管理器包装想要计时的代码块。它将会在你的代码块开始执行的时候启动计时器，在你的代码块结束的时候停止计时器。
这是一个使用上述代码片段的例子：
01from timer import Timer
02from redis import Redis
03rdb = Redis()
04
05with Timer() as t:
06rdb.lpush("foo", "bar")
07print "=>elasped lpush: %s s" % t.secs
08
09with Timer as t:
10rdb.lpop("foo")
11print "=>elasped lpop: %s s" % t.secs
我经常将这些计时器的输出记录到文件中，这样就可以观察我的程序的性能如何随着时间进化。
使用分析器逐行统计时间和执行频率
Robert Kern有一个称作line_profiler的不错的项目，我经常使用它查看我的脚步中每行代码多快多频繁的被执行。
想要使用它，你需要通过pip安装该python包：
1$ pip install line_profiler
一旦安装完成，你将会使用一个称做“line_profiler”的新模组和一个“kernprof.py”可执行脚本。
想要使用该工具，首先修改你的源代码，在想要测量的函数上装饰@profile装饰器。不要担心，你不需要导入任何模组。kernprof.py脚本将会在执行的时候将它自动地注入到你的脚步的运行时。
primes.py
01@profile
02def primes(n):
03if n==2:
04return [2]
05elif n<2:
06return []
07s=range(3,n+1,2)
08mroot = n ** 0.5
09half=(n+1)/2-1
10i=0
11m=3
12while m <= mroot:
13if s[i]:
14j=(m*m-3)/2
15s[j]=0
16while j
17s[j]=0
18j+=m
19i=i+1
20m=2*i+3
21return [2]+[x for x in s if x]
22primes(100)
一旦你已经设置好了@profile装饰器，使用kernprof.py执行你的脚步。
1$ kernprof.py -l -v fib.py
-l选项通知kernprof注入@profile装饰器到你的脚步的内建函数，-v选项通知kernprof在脚本执行完毕的时候显示计时信息。上述脚本的输出看起来像这样：
01Wrote profile results to primes.py.lprof
02Timer unit: 1e-06 s
03
04File: primes.py
05Function: primes at line 2
06Total time: 0.00019 s
07
08Line # Hits Time Per Hit % Time Line Contents
09==============================================================
10 2 @profile
11 3 def primes(n):
12 4 12 2.0 1.1 if n==2:
13 5 return [2]
14 6 11 1.0 0.5 elif n<2:
15 7 return []
16 8 14 4.0 2.1 s=range(3,n+1,2)
17 9 1 10 10.0 5.3 mroot = n ** 0.5
1810 12 2.0 1.1 half=(n+1)/2-1
1911 11 1.0 0.5 i=0
2012 11 1.0 0.5 m=3
2113 57 1.4 3.7 while m <= mroot:
2214 44 1.0 2.1 if s[i]:
2315 34 1.3 2.1 j=(m*m-3)/2
2416 34 1.3 2.1 s[j]=0
251731 31 1.0 16.3 while j
261828 28 1.0 14.7 s[j]=0
271928 29 1.0 15.3 j+=m
2820 44 1.0 2.1 i=i+1
2921 44 1.0 2.1 m=2*i+3
302250 54 1.1 28.4 return [2]+[x for x in s if x]
寻找具有高Hits值或高Time值的行。这些就是可以通过优化带来最大改善的地方。
程序使用了多少内存？
现在我们对计时有了较好的理解，那么让我们继续弄清楚程序使用了多少内存。我们很幸运，Fabian Pedregosa模仿Robert Kern的line_profiler实现了一个不错的内存分析器。
首先使用pip安装:
1$ pip install -U memory_profiler
2$ pip install psutil
（这里建议安装psutil包，因为它可以大大改善memory_profiler的性能）。
就像line_profiler，memory_profiler也需要在感兴趣的函数上面装饰@profile装饰器：
1@profile
2def primes(n):
3...
4...
想要观察你的函数使用了多少内存，像下面这样执行：
1$ python -m memory_profiler primes.py
一旦程序退出，你将会看到看起来像这样的输出：
01Filename: primes.py
02
03Line #Mem usage Increment Line Contents
04==============================================
05 2 @profile
06 37.9219 MB 0.0000 MB def primes(n):
07 47.9219 MB 0.0000 MB if n==2:
08 5 return [2]
09 67.9219 MB 0.0000 MB elif n<2:
10 7 return []
11 87.9219 MB 0.0000 MB s=range(3,n+1,2)
12 97.9258 MB 0.0039 MB mroot = n ** 0.5
13107.9258 MB 0.0000 MB half=(n+1)/2-1
14117.9258 MB 0.0000 MB i=0
15127.9258 MB 0.0000 MB m=3
16137.9297 MB 0.0039 MB while m <= mroot:
17147.9297 MB 0.0000 MB if s[i]:
18157.9297 MB 0.0000 MB j=(m*m-3)/2
19167.9258 MB -0.0039 MB s[j]=0
20177.9297 MB 0.0039 MB while j
21187.9297 MB 0.0000 MB s[j]=0
22197.9297 MB 0.0000 MB j+=m
23207.9297 MB 0.0000 MB i=i+1
24217.9297 MB 0.0000 MB m=2*i+3
25227.9297 MB 0.0000 MB return [2]+[x for x in s if x]
line_profiler和memory_profiler的IPython快捷方式
memory_profiler和line_profiler有一个鲜为人知的小窍门，两者都有在IPython中的快捷命令。你需要做的就是在IPython会话中输入以下内容：
1%load_ext memory_profiler
2%load_ext line_profiler
在这样做的时候你需要访问魔法命令%lprun和%mprun，它们的行为类似于他们的命令行形式。主要区别是你不需要使用@profiledecorator来修饰你要分析的函数。只需要在IPython会话中像先前一样直接运行分析：
1In [1]: from primes import primes
2In [2]: %mprun -f primes primes(1000)
3In [3]: %lprun -f primes primes(1000)
这样可以节省你很多时间和精力，因为你的源代码不需要为使用这些分析命令而进行修改。
内存泄漏在哪里？
cPython解释器使用引用计数做为记录内存使用的主要方法。这意味着每个对象包含一个计数器，当某处对该对象的引用被存储时计数器增加，当引用被删除时计数器递减。当计数器到达零时，cPython解释器就知道该对象不再被使用，所以删除对象，释放占用的内存。
如果程序中不再被使用的对象的引用一直被占有，那么就经常发生内存泄漏。
查找这种“内存泄漏”最快的方式是使用Marius Gedminas编写的objgraph，这是一个极好的工具。该工具允许你查看内存中对象的数量，定位含有该对象的引用的所有代码的位置。
Python中提供了很多接口方便我们能够灵活进行性能分析，包括cProfile模块中的Profile类和pstat模块中的Stats类。
--cprofile是一种确定性分析器，只测量CPU时间，并不关心内存的消耗情况和其他与内存相关联的信息
--它是基于Isprof的用C语言实现的扩展应用，运行开销比较合理，适合分析运行时间较长的程序
--enable(): 开始进行性能分析并收集数据
--disableI(): 停止性能分析
--create_stats(): 停止收集数据，并为已经收集的数据创建stats对象
--print_stats():创建stats对象并打印分析结果
--dump_stats(filename): 把当前性能分析的内容写入文件filename中
--runcall(func, *args, **kwargs): 收集被调用函数func的性能分析信息
--用来分析cProfile输出的文件内容
--pstas模块为开发者提供了Stats类，可以读取和操作stats文件
（Stats类可以接受stats文件名，也可以直接接受cProfile.Profile对象作为数据源。）
--strip_dirs(): 删除报告中所有函数文件名的路径信息
--dump_stats(filename): 把stats中的分析数据写入文件（也可以写成cProfile.Profile.dump_stats()）
--sort_stats(*keys): 对报告列表进行排序，函数会一次按照传入的参数排序
--reverse_order(): 逆反当前的排序
--print_stats(*restrictions): 把信息打印到标准输出。*restrictions用于控制打印结果的形式，比如（10,1.0，".*.py.*")表示打印所有py文件的信息的前10行结果
--第一行表示运行这个函数一共使用0.043秒，执行了845次函数调用
--第二行表示结果是按什么顺序排列的（这里表示按照调用次数来进行排列的）
--ncalls: 表示函数调用的次数（有两个数值表示有递归调用，总调用次数/原生调用次数）
--tottime: 函数内部调用时间（不包括他自己调用的其他函数时间）
--percall: tottime/ncalls
--cumtime: 表示累计调用时间（函数执行玩的总时间），它包含了函数自己内部调用的函数时间
--filename:lineno(function): 函数所在的文件，行号，函数名称
上面的函数do_cProfile(do=False, order='tottime')是一个带参数的装饰器，通过do的值来进行性能分析的开关控制，通过order的值来选择输出结果按照什么方式进行排序。
比如我们对函数A和函数B进行性能分析
如果不给装饰器传入参数的话就是默认的False和tottime
https://zhuanlan.zhihu.com/p/24495603
https://blog.csdn.net/weixin_40304570/article/details/79459811
我用python执行时间23秒，用pypy执行时间1.54秒，用numba加速为1.5秒，c语言在本机macos上执行时间1.3秒,java运行速度1.45秒（jre8）,详细见图片，可见引入jit编译后，性能直逼c语言，而写python比写c容易太多,比java简洁，写代码速度也是非常非常重要。由于历史原因，很多python库用的c语言库，如pandas（pandas的矩阵计算用numpy优化过非常快，可能比手写c语言循环还要快），可以通过设计来分离c语言加速后的python代码和pure python，分别用不同的加速方法，如numba可以单独加速一个函数，把需要大量计算的放在一个函数用numba加速（numbapro支持显卡加速但是商业版的）。所以只适当设计一下，python在一般计算问题下有这些解决方案下性能不是问题，实在不行，你还可以用boost::python来写个c/c++调用库来解决性能问题。
下面的测试说明，对于性能，原生python比较慢，在windows下python比linux,macos要快，用pypy后相当于java,c#速度，pypy,c#在windows下受益msvc表现较快，,go语言速度表现比较稳定，c语言理论上是最快，但受环境和编译器影响较大。对c#,java可能在GC垃圾回收时会表现不稳定，因为在oop中有大量计算后可能要回收垃圾内存对象，这个没有用到oop，只是纯计算，理论上还是c/c++语言最快。
python和java比，运行速度比java慢，java强大于改进n次的强大jre，但python在很多领域能调用很多现成的开源库，在数据分析中有优势，pyhton的代码比java要简洁，容易入门和使用。在优化的计算库帮助下,如numpy numba，pandas，scikit-learn，python的实际问题运算性能并不低于java。java主要是框架太多，相对复杂，java主要用于业务程序开发，符合软件工程理论，可伸缩性强,强类型有利于对程序的静态检查分析。java随着安卓,hadoop,spark的兴起，加入java语言的公司很多，性能也可以通过优化解决很多问题。很多服务器如ubuntu server,centos都默认支持python，而java虚拟机需要安装配置，python的安装使用也相对简单。python的库有开箱即用感，很多业务领域，你可能还在用oop写代码，考虑设计模式，用锄头挖沟时，而python调用挖掘机api已经炒菜完工开饭了，缺点是油耗比较大。
