性能分析：

1.种类：

基于事件的性能分析
    通过收集程序执行过程中的具体事件进行工作，每个调用都会触发，输出数据量大，精度高
    def profiler(frame, event, arg):
        print 'PROFILER: %r %r' % (event, arg)
    sys.setprofile(profiler)        # 此后的所有调用都会触发函数
统计式性能分析
    以固定的时间间隔对程序计数器（program counter）进行抽样统计，掌握目标程序在每个函数上消耗的时间
    优点：
        分析的数据更少
        对性能造成的影响更小
    如statprof

2.瓶颈

沉重的I/O操作，比如读取和分析大文件，长时间执行数据库查询，调用外部服务（比如HTTP请求），等等。
出现了内存泄漏，消耗了所有的内存，导致后面的程序没有内存来正常执行。
未经优化的代码被频繁地执行。
密集的操作在可以缓存时没有缓存，占用了大量资源。

3.运行时间

常数时间
    如字典查找
线性时间
    遍历序列
对数时间
    随着输入数量的增加，对数函数开始增长很快，然后慢慢减速
    如二分查找
线性对数时间
    如一些高级排序法
阶乘时间
    暴力破解法
平分时间
    冒泡排序，遍历二维数组，插入排序
# 运行包括最好情况、正常情况和最差情况，也与输入数据有关

4.性能测试套件

建立回归测试套件，预处理数据，对数据进行可视化

性能分析器：

1.cProfile：

概述：

2.5以后版本，pypy没有

作用：

统计每个函数消耗的CPU时间。同时它还提供了其他细节，比如函数被调用的次数。
只测量CPU时间，并不关心内存消耗和其他与内存相关的信息统计

示例：

import cProfile
cProfile.run('fib_seq(2)')

15 function calls (11 primitive calls) in 0.000 seconds                    # 11个原生调用
ncalls  tottime  percall  cumtime  percall filename:lineno(function)    
1      0.000    0.000    0.000    0.000 <string>:1(<module>)
5/3    0.000    0.000    0.000    0.000 test1.py:14(fib)

ncalls 表示函数调用的次数，两个数值时，总调用次数/原生调用的次数，数值过大时表示bug或者需内联函数扩展的位置(即不回调函数，而是直接写)
tottime是函数内部消耗的总时间，不包括调用其他函数的时间
percall是tottime除以ncalls，表示一个函数每次调用的平均消耗时间
cumtime是之前所有子函数消耗时间的累计和（也包含递归调用时间），可以整体式识别性能，如算法选择错误
另一个percall是用cumtime除以原生调用的数量，表示到该函数调用时，每个原生调用的平均消耗时间
filename:lineno(function)显示了被分析函数所在的文件名、行号、函数名。

命令行测试：

对源代码干扰更少，不需要增加任何代码，运行脚本时需要添加参数
python -m cProfile your_script.py -o your_script.profile

局限：

测试时，会影响实际性能
代码内部时钟有一个精度范围，小于该精度的测量会测不出来

方法：

run(command, filename=None, sort=-1)
    内部执行exec(command, __main__.__dict__, __main__.__dict__)
runctx(command, globals, locals, filename=None)        # 能在函数内运行，能识别内部导入的模块
    内部执行exec(command, globals, locals)
Profile(timer=None, timeunit=0.0,subcalls=True,builtins=True)方
    返回类的其他方法：
        enable()：表示开始收集性能分析数据。
        disable()：表示停止收集性能分析数据。
        create_stats()：表示停止收集数据，并为已收集的数据创建stats对象。
        print_stats(sort=-1)：创建一个stats对象，打印分析结果。
        dump_stats(filename)：把当前性能分析的内容写进一个文件。
        run(cmd)：和之前介绍过的run函数相同。
        runctx(cmd, globals, locals)：和之前介绍过的runctx函数相同。
        runcall(func, *args, **kwargs)：收集被调用函数func的性能分析信息。
    示例：
        prof = cProfile.Profile()
        prof.enable()
        xx
        prof.create_stats()
        prof.print_stats()

Stats类：

概述：

pstats模块为开发者提供了Stats类，可以读取和操作stats文件

方法：

strip_dirs()：删除报告中所有函数文件名的路径信息。这个方法会改变stats实例内部的顺序
add(*filenames)：这个方法将文件名对应的文件的信息加载到当前的stats对象中
dump_stats(filename)：就像cProfile.Profile类，这个方法把加载到Stats类的数据保存为一个文件。
sort_stats(*keys)：依次对所有项目进行排序，从而调整stats对象的
reverse_order()：这个方法会逆反原来参数的排序方法
print_stats(*restrictions)：这个方法是把信息打印到STDOUT。
print_callers(*restrictions)显示程序执行过程中调用的每个函数的调用次数、总时间和累计时间，以及文件名、行号和函数名的组合。
print_callees(*restrictions)方法打印一列调用其他函数的函数。

示例：

prof = cProfile.Profile()
prof.enable()        # 开始性能分析
运行函数()    
prof.create_stats()
p=pstats.Stats(prof)                # stats接收cProfile.Profile()的实例参数
p.print_stats(10,1.0,'.*.py.*')        # p.print_callers()
stats.strip_dirs().sort_stats('cumulative').print_stats()

总结：

获取每个函数的调用次数和总调用次数。
是确定性分析，即基于事件的性能分析器的另一种说法

2.line_profiler

概述：

一行一行地分析函数性能，而不是像cProfile那样做确定性性能分析。

安装：

pip install line_profiler
失败可以尝试whl安装

优点：

弥补cProfile和类似性能分析器的不足（主要关注函数调用消耗的CPU时间），
能发现发生在函数的某一行中的问题

方法：

和cProfile.Profile一样，也提供了run、runctx、runcall、enable和disable方法。
但是最后两个函数在嵌入模块统计性能时并不安全，使用时要当心。
示例：
    prof = line_profiler.LineProfiler(test) # 把函数传递到性能分析器中
    prof.enable() # 开始性能分析
    test()
    prof.disable() # 停止性能分析
    prof.print_stats(sys.stdout) # 打印性能分析结果

kernprof工具:

安装后自带。
kernprof会创建一个性能分析器实例，并把名字添加到__builtins__命名空间的profile中
使用：
    @profile
    def func(n):
    然后命令行启动：kernprof -l -v script_to_profile.py     # -v属性立刻输出结果在命令行
注意事项：
    时间问题，在性能分析函数调用另一个函数时，没有把每一行消耗的时间增加到总时间上：
    列表综合（list comprehension）表达式的Hit比它们实际消耗的要多很多

优化点：

函数结果缓存
lambda函数多次调用时事先创建函数
多余的变量声明和查询
dict和defaultdict类
字符串连接+比c语言%快

可视化性能分析：

1. KCacheGrind/pyprof2calltree

概述：

通过pyprof2calltree这个工具把cProfile的输出结果转换成KCacheGrind可以读取的形式。

安装：

pip install pyprof2calltree
sudo apt-get install kcachegrind

用法：

1.命令行形式，命令行加参数

pyprof2calltree -o [output-file-name] -i input-file.prof
-k：如果想立即运行KCacheGrind，就可以加上这个参数。
-r：如果还没有性能分析数据，可以用这个参数直接分析Python脚本文件生成最终结果。

2.在REPL（read-eval-print loop，读取-求值-输出循环）交互式编程环境里运行（也可以根据需要在性能分析的脚本中运行）

convert：会输出性能分析结果文件
visualize：直接启动KCacheGrind显示结果
示例： 
    from xml.etree import ElementTree
    from cProfile import Profile
    import pstats
    xml_content = '<a>\n' + '\t<b/><c><d>text</d></c>\n' * 100 + '</a>'
    profiler = Profile()            # 实例化
    profiler.runctx("ElementTree.fromstring(xml_content)", locals(), globals()) # 执行脚本
    from pyprof2calltree import convert, visualize      # 导入
    stats = pstats.Stats(profiler)                      # 获取stat
    visualize(stats)        # 运行kcachegrind
结果分析

1.Incl.列：这个指标表示函数的累计消耗时间。包含被它调用的函数消耗的时间

2.Self列：只包含函数本身消耗的时间，不包括它调用的函数需要的时间。

2. RunSnakeRun

概述：

KCacheGrind也适用于C和C++开发者，而RunSnakeRun是专门为Python开发者定制的。        

区别：

无需像KCacheGrind一样借助pyprof2calltree，本身读取和解释分析结果，只要设置好文件路径就行。

安装：

pip install wxpython
pip install SquareMap RunSnakeRun

使用：

python -m cProfile -o test.prof inverted-index.py
runsnake test.prof

优化细节：

1.函数返回值缓存和函数查询表

把函数、输入参数和返回值全部都保存起来，在函数下次被调用时直接使用存储的结果

2.使用默认参数

默认参数（default argument）可以在函数创建时就确定输入值，而不用在运行阶段才确定输入。
注：函数的接口容易造成混乱。    

3.列表综合表达式与生成器

普通for循环产生的指令集更长。
列表综合产生的指令集就像是for循环指令集的真子集，主要的差异是数值被增加到列表中的方式不同。
在for循环里，数值是一个一个增加的，用到三个指令；列表综合只用了一个简单且已经经过优化的指令
# 适合：列表推导式能替代for循环生成列表
# 如果列表的数量大，就用生成器
生成器：
    只能遍历一次

4.ctypes库

可以接入Windows系统上的kernel32.dll和msvcrt.dll动态链接库，以及Linux系统上的libc.so.6库。
使用： 
    将关键代码写成c语言，编译成一个库，然后导入Python当作模块使用。
    有时，系统的库文件已经写好了c函数，只需加载一个系统库就行

5.字符串连接

由于字符串是不可变的，每当我们要做任何改变字符串内容的操作时，其实都是创建了一个带有新内容的新字符串，我们的变量会指向新创建的字符串。
因此，处理字符串时必须小心谨慎，三思而后行。

细节：
    str = str1+str2+str3用C语言字符串的变量内插法更好，str = "%s%s%s"%(str1,str2,str3)
    或者用locals函数创建子字符串：
        document = "%(title)s%(introduction)s%(main_piece)s%(conclusion)s" % locals()

6.其他：

成员关系测试：

用set或dict比list好

使用标准库：

大都是经过优化的C语言写成，如内置数据类型，数组（array）、迭代工具（itertools）、队列（collections.deque）    
内置函数operator.add比lambda x, y: x+y好

队列collections.deque：

在pop(0)和insert(0,v)操作时比list更好        

不定义嵌套函数：

内置函数代码，虽然可能会损害代码的可读性和维护便利性

尽可能用key函数排序而不是cmp：

list1.sort(cmp=lambda a, b: cmp(a[1], b[1]))
list2.sort(key=lambda a: a[1])

1比True好：

while 1得到了优化，跳转一次就能完成，而while True并没有，因此需要跳转好几次才能完成。
多元赋值（multiple assignments）很慢但变量交换时，它比普通方法要快
因为我们不需要使用临时变量和赋值过程

推荐使用链式比较：

在比较三个变量时，不要用 x<y 和 y<z，可以用 x<y<z。

用命名元组（namedtuple）替换常规对象：

使用常规的类（class）方法创建存储数据的简单对象时，实例中会有一个字典存储属性。这个存储对属性少的对象来说是一种浪费

pypy：

概述：

分析程序运行并对那些频繁执行的部分生成本机机器码，通常可以接近C 代码的速度

安装使用：

window：

下载压缩包，解压后添加系统环境变量

linux：

wget https://bitbucket.org/pypy/pypy/downloads/pypy2.7-v7.0.0-linux64.tar.bz2
tar xf pypy2.7-v7.0.0-linux64.tar.bz2
mv pypy2.7-v7.0.0-linux64/ pypy2.7-7
ln -s ~/data/pypy2.7-7/bin/pypy /usr/bin/

使用pip安装第三方包：

pypy -m ensurepip安装未带pip的安装包
pypy -m pip install xx

问题：

1. 第三方库有些不支持，如内存检测guppy

2. 内存比普通的python高，如跑id level持续高 # python也会存在该问题，貌似pypy速度快，内存上升快

解决方法：

开较少uid的进程，运行完该范围就关闭进程，重新开启进程，尝试过，速度貌似提升不明显，有可能瓶颈不在计算上

3.内存回收好像有问题

原因：可能在于pypy的优化理念与cpython不一样，例如字符串+拼接在pypy很慢

4.pypy的回收机制不同，尝试设置环境变量还是不行

os.environ['PYPY_GC_MAX'] = "1GB"
os.environ['PYPY_GC_MAX'] = "0.5GB"
os.environ['PYPY_GC_GROWTH'] = "1.2"

JIT优化：

1.针对函数的优化

JIT可以分析函数热度，即判断哪个函数比其他函数“更热”（hotter，执行次数更多），从而做出优化
# 可能会比直接内联要更快，所以反复调用函数的代码可以利用JIT优化
JIT会实时优化代码

2.考虑用cStringIO连接字符串

想把大量的字符串连接成一个对象，用cStringIO模块

3.禁止JIT的操作

# 执行下面操作时通过sys模块JIT会禁用
_getframe：这个方法会从callstack返回一个frame对象，也可以接受一个从callstack发出的带深度参数的callstack对象作为参数。
        这么做性能损失非常大，非万不得已最好别用，比如系统调试的时候
exc_info：这个方法会返回一个三元素的元组，提供待处理异常的相关信息。三个元素分别是type、value和traceback，具体解释如下。
        type：待处理的异常类型。
        value：异常参数。
        traceback：跟踪traceback对象，当异常被抛出时，里面会封装一个callstack对象。
settrace：这个方法可以设置跟踪函数。它能让你从Python内部跟踪Python代码。
    就像前面提到的，这个方法也是万不得已时才用，因为它在执行时会禁止JIT。

Cython：

概述：

直接将Python代码编译成C语言（CPython不会这么做）
其实是一个转换器，可以简单看成一个软件，它可以把源代码从一种语言翻译成另一种语言

作用：

用Python代码调用原生C/C++
用静态类型声明把Python代码优化成C语言的性能

静态类型：

静态类型是Cython这个翻译器产生优化的C语言代码的主要特征，可以把Python的动态特性转变成静态且更快的代码（有时候可以达到几个数量级）。
坏处是变得更啰嗦

安装：

pip install cython

使用：

将代码中变量和参数改成C语言类型，然后用cython编译成.c文件，然后变成.o 

限制：

1.生成器表达式

由于表达式计算范围（evaluation scope）的限定有问题，因此不能在生成器表达式内部使用可迭代对象    
在处理生成器表达式内部使用可迭代对象时，Cython会在生成器内部计算可迭代对象。而CPython是在生成器外部计算。
CPython的生成器具有一些属性可以让用户查看。但是Cython的生成器的这类属性还不够全面。

2.对比char*常量

字节字符串比较是通过指针实现的，并不是字符串的真实值

3.元组作为函数参数

4.栈帧

数据处理：

1.Numba

能够（通过装饰器）控制Python解释器把函数转变成机器码
只是针对数组操作进行优化，它非常适合配合NumPy使用
安装： 
    pip install numba
作用： 
    即时代码生成（On-the-fly code generation）
    CPU和GPU原生代码生成
    与具有NumPy依赖的Python科学计算软件配合使用
使用： 
    使用@jit装饰器。加上它就表示要用Numba的JIT编译器对函数进行优化。
    1.函数接收类型
        @jit(int32(int32, int32))
    2.没有GIL
        @jit(nogil=True)，用多线程运行Python代码
    3.无python模式
        @jit(nopython=True)
        只有一部分函数和方法可以使用。

2.pandas

提供了一系列高性能的数据结构和分析工具。    

3.Parakeet

这是一种用Python子集为科学计算设计的运行时编译器。它非常适合处理科学计算问题。
只支持一小部分Python和NumPy组合的数据类型
限制：
    支持的数据类型包括Python的数字、元组、列表和NumPy的数组。
    Parakeet会自动对数据类型执行向上转换，就是说，无论何时遇到两种不同类型的数据，都会被强制向上转换成统一类型。
    Parakeet里面不能捕捉和处理异常，这是因为Parakeet是用SSA结构展示程序的
    数组传播（array broadcasting，NumPy的特性）是通过对数组参数类型显式地映射操作实现的。
            这种实现方式的限制是它不能实现多维数组传播（比如8×2×3和7×2数组）。
    只实现了一小部分Python和NumPy的内置函数。
    列表综合表达式作为数组综合表达式处理。
使用： 
    在函数上使用一个装饰器，from parakeet import jit

内存泄漏：

1.guppy模块（linux专用）

from guppy import hpy
h = hpy()
heap = h.heap()                # 显示内存占用最多的类型
byrcs = h.heap().byrcs        # 稍微具体的信息

2.tracemalloc

python3.4后版本引入
示例：
    tracemalloc.start(25)
    snapshot = tracemalloc.take_snapshot()
    top_stats = snapshot.statistics('lineno')
    for stat in top_stats[:10]:
        print(stat)
方法： 
    tracemalloc.start(25)           # Store 25 frames
    tracemalloc.take_snapshot()     
    snapshot.statistics('lineno')
    snapshot2.compare_to(snapshot1, 'lineno')
    stat.traceback.format()
    tracemalloc.clear_traces()      # Clear traces of memory blocks allocated by Python.

3.gc模块

gc.enable(); gc.disable(); gc.isenabled()
    开启gc（默认情况下是开启的）；关闭gc；判断gc是否开启
gc.collect(generation=None)　
    执行一次垃圾回收，不管gc是否处于开启状态都能使用。专门针对循环引用（正常的垃圾回收机制不适用）
    没参数进行完全回收
gc.set_threshold(t0, t1, t2); gc.get_threshold()
    设置垃圾回收阈值； 获得当前的垃圾回收阈值，gc.set_threshold(0)也有禁用gc的效果
gc.get_objects()
    返回所有被垃圾回收器（collector）管理的对象。这个函数非常基础！只要python解释器运行起来，就有大量的对象被collector管理，
    因此，该函数的调用比较耗时！
gc.get_referents(*obj)
    返回obj对象直接指向的对象
gc.get_referrers(*obj)
    返回所有直接指向obj的对象
gc.set_debug(flags)            
    进行检测，打印log      # gc.set_debug(gc.DEBUG_COLLECTABLE | gc.DEBUG_UNCOLLECTABLE | gc.DEBUG_SAVEALL)

4.objgraph

调用了gc的这几个函数：gc.get_objects(), gc.get_referents(), gc.get_referers()，然后构造出对象之间的引用关系。
def count(typename)
    返回该类型对象的数目，其实就是通过gc.get_objects()拿到所用的对象，然后统计指定类型的数目。
def by_type(typename)
    返回该类型的对象列表。线上项目，可以用这个函数很方便找到一个单例对象
def show_most_common_types(limits = 10)
    打印实例最多的前N（limits）个对象，这个函数非常有用。该函数能发现可以用slots进行内存优化的对象
def show_growth()
    统计自上次调用以来增加得最多的对象,这个函数非常有利于发现潜在的内存泄露。
    函数内部调用了gc.collect()，因此即使有循环引用也不会对判断造成影响。
def show_backrefs()
    生产一张有关objs的引用图，看出对象为什么不释放，后面会利用这个API来查内存泄露。
    层数限制(max_depth)、宽度限制(too_many)、输出格式控制(filename output)、节点过滤(filter, extra_ignore)
def find_backref_chain(obj, predicate, max_depth=20, extra_ignore=()):
    找到一条指向obj对象的最短路径，且路径的头部节点需要满足predicate函数 （返回值为True）
    可以快捷、清晰指出对象的被引用的情况
def show_chain():
    将find_backref_chain 找到的路径画出来, 该函数事实上调用show_backrefs，只是排除了所有不在路径中的节点。

5.pyrasite

6.memory_profiler

安装：

pip install memory_profiler

使用：

from memory_profiler import profile
为函数添加装饰器@profile(precision=6)