谁说Python性能差的？

[转载请注明出处]

最近看到网上有人对比Python，Shell脚本， C++，主要是拿Python性能说事，个人觉得意义不大。
一个语言有什么性能问题呢，是背后的实现（标准库，编译器）决定着一切，就像总有人想对比c++和c的效率一样。
还有就是，Python总被人叫做是脚本语言，其实脚本更多指的是批处理命令文件，是shell命令的集合，和python完全
不是一个层次。不同的工具所在层次不同，适用的问题也不同。把不同层次上的东西拉到一起做比较，什么问题也说明不了。
另外，shell就知道fork，你说他还能干嘛？:-)。

下面先乱侃一通，再以实例探讨下Python的性能问题。

首先，Python是一门动态编程语言，主要亮点是可以提高开发应用的效率。 他是和Java，perl，Ruby等语言同类的。
是做系统集成，Web应用等系统的利器，最近在科学计算领域也是大方光彩（numpy, scipy, sci-kit learn）。
和C/Cplusplus基本不是一个层次的开发工具，他们是做底层系统（基础库，os，ecos就是c++写的，还是用在嵌入式系统中）的，
很多库提供的功能也很基础。但，你可以为Python写c或cpp的模块，提高你的Python系统的整体性能。

其次，Python的主要解释器CPython是用C语言实现的，不同类型（dict，list）和函数实现的算法很不同。如果你的系统对性能很敏感，
那必须了解一些内幕，一个函数输入不同的参数，性能可能相差很大。另外，Python解释器执行Python代码时候，大概经历如下几个阶段：
1) 加载代码文件 2)翻译成AST 3)生成bytecode 4)在PVM（python virtual machine)上执行bytecode，PVM实际是一个基于栈的虚拟机。
其中，前3个阶段看文件代码量，一般就ms级别的消耗，如果你不想浪费，可以使用python -O -m py_compile xx.py命令，
将xx.py先编译为xx.pyo的字节码，然后在调用python xx.pyo执行. PVM你可以简单的想象为一个C语言写的函数，里面有一个非常大的switch，
根据不同的bytecode内容，执行不同的动作。比如遇到一个打开文件指令，这个函数就会调用libc的库函数，执行c语言的打开文件操作。
其实很多操作python bytecode和c语言之间的性能差异很小的，因为Python的很多功能模块就是直接执行C库的。

再次，随着Python的广泛应用，CPython解释器的性能问题确实越来越严重，特别是数据挖掘，机器学习领域的日趋火热，其中很多优秀工具的实现
都是用Python来做的。为了解决这个问题，Python社区提出了多种不同的解释器，比如针对数值计算的numba，用python实现的python解释器pypy等。
他们的主要目的就是给Python加速，用到的技术有JIT，LLVM。比如numba为python提供了新的decorator，让python函数能在运行时
通过llvm库被翻译成machine code。而CPython的现在主要的目的就变为一个Python解释器的范本，就是提供一个稳定可靠的功能最全的解释器实现参考。
另外，如果某个用Python实现的功能模块的性能很关键，你可以把这个模块先用Cython翻译成C语言代码，然后在编译为可执行程序。当然用Cython，
你也可以在python中更加方便的调用外部C库，保证整个系统的性能。所以，很多Python系统的执行会越来越快，但并不是Python快了，而是后面的支持
越来越强大了。

最后，Python就是和Java类似的一门语言，不要把他理解为是一种脚本。刚开始把他理解为脚本，可能是因为python提供了一个命令行工具，让人可以输入
python代码，并立刻见到结果。其实，这只不过python给你提供的一个优秀的工具之一而已。Python在各个领域的使用越来越广泛，开源资源也越来越多：
1. 大规模分布式计算disco，提供和hadoop类似的mapreduce模型 http://discoproject.org/
2. 科学计算/可视化 numpy,scipy, matplotlib
3. 数据挖掘orange, sci-kit learn scikit-learn.sourceforge.net
4. Web开发 django project
所有IT领域，基本都能找到Python的痕迹。

说了这么多，举一个文本处理的例子，就是计算文本中第3列数据的和，来看看Python的功力，特别是性能方面的问题，
对比参考就是awk神器，其实拿awk做对比不是很公平，毕竟awk是优化再优化的工具（没动力看他的实现，我猜的：）），
应该自己写个c语言版本的。

样本文件有1000万行，格式如下：
data.txt:
d0 sp 0
d1 sp 1
d2 sp 2
d3 sp 3
d4 sp 4
d5 sp 5
d6 sp 6
d7 sp 7
d8 sp 8
d9 sp 9

先看awk的结果：
$ time cat data.txt |awk '{ sum+=$3} END {print sum}'
49976634308700

real 0m3.662s
user 0m3.576s
sys 0m0.240s

1000万行3秒，效率果真高。

再看Python的，我做了四个版本。
Python代码版本（1）：

import sys

def data_sum():
        datasum = 0
        for line in sys.stdin:
                raw = line.split()
                datasum += int(raw[2],10)
        print datasum

if __name__ == "__main__":
        data_sum()

 

Python代码版本（2）：

import sys

def data_sum():
        datasum = 0
        for line in sys.stdin:
                raw = line.split()
                datasum += int(raw[2])
        print datasum

if __name__ == "__main__":
        data_sum()
~                        

 

Python代码版本（3）：

def data_sum():
 datasum = 0
 for line in sys.stdin:
   datasum += int(‘2’，10)
print datasum

if __name__ == "__main__":
 data_sum()

 

Python代码版本（4）：

import sys

def data_sum():
 datasum = 0
 for line in sys.stdin:
  raw = line.split()
 print datasum

if __name__ == "__main__":
 data_sum()

 

版本（1）执行结果：
首先将python代码编译成字节码，运行看看
$python -O -m py_compile datasum.py
$ time cat data.txt |python datasum.pyo
49976634308700

real 0m7.151s
user 0m7.088s
sys 0m0.192s

再试试直接运行python代码
$ time cat data.txt |python datasum.py
49976634308700

real 0m7.323s
user 0m7.228s
sys 0m0.212s

两种方法大概有个毫秒级别的差异，主要消耗在cpython把python代码翻译成ast阶段，感兴趣可以自己编译一个cpython验证下。

还有pypy，看看他的JIT和stackless效果如何。
$ time cat data.txt | pypy-c datasum.py
49976634308700

real 0m4.649s
user 0m4.556s
sys 0m0.224s

怎样？比awk版本就慢了1秒钟。我已经非常满意了。下面再试试其他版本，顺便看看到底Python慢在了哪里。

版本（2）：
$ time cat data.txt |python datasum.py
49976634308700

real 0m9.111s
user 0m9.025s
sys 0m0.220s

$ time cat data.txt | pypy-c datasum.py
49976634308700

real 0m4.694s
user 0m4.588s
sys 0m0.248s

版本（2）直接就比版本（1）慢了2秒。就差了一个base参数而已，原因看下Cpython的代码就清楚了（Python/bltinmodule.c）。

加了base的，直接调用： x = PyOS_strtol(s, &end, base);

不加base的，要通过PyNumber_Int等一列内部类型处理函数，最后到达PyOS_strtol。

版本（3）：
$ time cat data.txt |python datasum.py
20000000

real 0m3.127s
user 0m3.044s
sys 0m0.188s

$ time cat data.txt | pypy-c datasum.py
20000000

real 0m2.393s
user 0m2.320s
sys 0m0.196s

版本（4）：
$ time cat data.txt |python datasum.py
0

real 0m3.920s
user 0m3.852s
sys 0m0.180s

$ time cat data.txt | pypy-c datasum.py
0

real 0m3.324s
user 0m3.208s
sys 0m0.252s

通过对比版本（3）和版本（4）可以发现，Python主要慢在了split函数这里，也就是提取第3列这个动作上。
初步想想，用C语言确实可以做到速度更快，但用Python没想到什么好办法，正则表达式会更慢。

上面都是用Python的解释器来执行代码的，下面把版本（1）用Cython编译成C语言，看看效果如何：
$ cython --embed -o datasum.c datasum.py
$ gcc -o datasum datasum.c -I/usr/include/python2.7 -lpython2.7
$ time cat data.txt |./datasum
49976634308700

real 0m6.332s
user 0m6.272s
sys 0m0.192s

比pypy还是慢了一些，pypy在代码生成上有些优化，cython基本就是translate。

总结下就是：
Python是快速原型开发的利器，如果你对性能有要求，那么就用他的各种优化他，Python不会辜负你的。
当你的领导/客户给你很大的deadline压力时候，Python就是你的救命草，呵呵。
当然，某些简单功能，比如本文的例子，用awk就可以了嘛，干嘛费力气优化python，:-)。