性能分析：
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)
p.print_stats(10,1.0,'.*.py.*')
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
注意事项：
时间问题，在性能分析函数调用另一个函数时，没有把每一行消耗的时间增加到总时间上：
列表综合（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 =
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循环里，数值是一个一个增加的，用到三个指令；列表综合只用了一个简单且已经经过优化的指令
生成器：
只能遍历一次
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:
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会实时优化代码
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)
tracemalloc.take_snapshot()
snapshot.statistics('lineno')
snapshot2.compare_to(snapshot1, 'lineno')
stat.traceback.format()
tracemalloc.clear_traces()
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
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)
