最近在学习Python，确实感觉Python的语法很强大，但是显然论性能要和C有差距。但是具体是一个什么样的差距？求一个清楚、形象的描述

很多算法课老师的第一个问题都是：What's more important than performance? 正确性（correctness）可维护下（maintainability）扩展性（scalability）兼容性（compatibility) ... 因为我们开发软件的目的是解决问题而不是让软件跑得快，长远来看程序员的时间比计算机的时间更可贵。

宏观上：脚本语言比jit差一个数量级，jit比编译类型差一个数量级。也就是两个数量级。 python在脚本语言中比较的话，速度算是有点慢了，比不上lua等等，但也没有踮脚。 python有很多加速方式，pypy、cffi、cython、ctypes等。优化的好能和C到一个数量级。没有业务去单纯比较语言运行速度是无意义。

Python的语法确实牛，但是性能会怎么样呢

eechen

15.1k51729

发布于
2015-09-09

更新于
2015-09-09

✓ 已被采纳

BubbleSort.py

def bubble_sort(lst):
    length = len(lst)
    for i in xrange(0, length, 1):
        for j in xrange(0, length-1-i, 1):
            if lst[j] < lst[j+1]:
                temp = lst[j]
                lst[j] = lst[j+1]
                lst[j+1] = temp
    return lst
for c in xrange(1000000):
    lst = [0,1,2,3,4,5,6,7,8,9]
    lst = bubble_sort(lst)
print(lst)

BubbleSort.php

<?php
$starttime = microtime(true);
function bubble_sort($array) {
    $size = count($array);
    for ($i=0;$i<$size;$i++) {
        for ($j=0;$j<$size-1-$i;$j++) {
            if ($array[$j] < $array[$j+1]) {
                $temp = $array[$j];
                $array[$j] = $array[$j+1];
                $array[$j+1] = $temp;
            }
        }
    }
    return $array;
}
for ($c=0;$c<1000000;$c++) {
    $array = array(0,1,2,3,4,5,6,7,8,9);
    $array = bubble_sort($array);
}
print_r($array);
echo microtime(true)-$starttime."\n";

BubbleSort.js

var starttime = new Date().getTime();
function bubble_sort(array) {
    var size = array.length;
    for(var i=0;i<size;i++) {
        for(var j=0;j<size-1-i;j++) {
            if (array[j] < array[j+1]) {
                var temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
    return array;
}
for (var c=0;c<10000000;c++) {
    var array = [0,1,2,3,4,5,6,7,8,9];
    array = bubble_sort(array);
}
console.log(array);
console.log((new Date().getTime()-starttime)/1000);

BubbleSort.java

public class BubbleSort {
    public static int[] bubbleSort(int[] array) {
        int i,j,temp,size;
        size = array.length;
        for(i=0;i<size;i++) {
            for(j=0;j<size-1-i;j++) {
                if(array[j] < array[j+1]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
    public static void main(String[] args) {
        int array[] = new int[10], size = array.length, c, i;
        for (c=0;c<10000000;c++) {
            for (i=0;i<size;i++) array[i] = i;
            array = bubbleSort(array);
        }
        for (i=0;i<size;i++) System.out.print(array[i]+" ");
        System.out.println();
    }
}

BubbleSort.c

#include <stdio.h>
#include <stdlib.h>
void bubble_sort(int *array, int size) {
    int i,j,temp;
    for (i=0;i<size;i++) {
        for (j=0;j<size-1-i;j++) {
            if (array[j] < array[j+1]) {
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}
int main(int argc, char *argv[]) {
    int size=10, c, i;
    int *array = calloc(size, sizeof(int));
    for (c=0;c<10000000;c++) {
        for (i=0;i<10;i++) array[i] = i;
        bubble_sort(array, size);
    }
    for (i=0;i<size;i++) printf("%d ", array[i]);
    printf("\n");
    free(array);
    return 0;
}

Ubuntu-14.04(i5-3230M)

Python-2.7执行1百万次冒泡排序
测试: time python BubbleSort.py
耗时: 0m16.910s

PHP7 RC2执行1百万次冒泡排序
测试: time php BubbleSort.php
耗时: 0m5.770s

Node执行1千万次冒泡排序
测试: time node BubbleSort.js
耗时: 0m1.874s

Java7执行1千万次冒泡排序
编译: javac BubbleSort.java
运行: time java BubbleSort
耗时: 0m0.611s

GCC-4.8.2执行1千万次冒泡排序
编译: gcc -O3 BubbleSort.c -o BubbleSort
运行: time ./BubbleSort 结果: 10000000 次耗时0m0.481s
编译: gcc -O1 BubbleSort.c -o BubbleSort
运行: time ./BubbleSort 结果: 10000000 次耗时0m0.561s

Python要比GCC慢300多倍,PHP7则要比GCC慢100多倍.
Node因为有V8 JIT,在计算上大幅领先Python和PHP,是GCC编译的本地程序的3.5倍耗时.
Java因为拥有更加成熟的Hotspot JIT,而且预先就生成了优质的Bytecode,所以性能接近GCC通用优化O1编译的本地程序.

Java和Node.JS因为JIT,能够把大量的循环计算和函数调用优化编译为本地代码,所以计算上肯定是吊打PHP和Python的.但这不代表Java和Node.JS编写的网络应用的吞吐量就能大幅领先PHP和Python应用.

就拿PHP来说,Web应用更多的还是CRUD数据库操作和NoSQL哈希操作,然后PHP用关联数组承载这些数据,偶尔还要进行字符串的处理.而这些操作普遍都是PHP直接调用C库提供的函数进行,这些函数性能上不会有太大的问题.真正慢的是PHP的代码,所以在Web上,让PHP做一些成千上万次的循环,显然是不合适的,这样肯定会造成服务卡顿和阻塞.而JIT恰好能优化这些成千上万次的循环,不过这种场景更像是压力测试,而非真实的Web环境.所以说,就算Node.JS/HHVM凭借JIT在计算速度上明显优于PHP,但不代表真实的Web应用的吞吐量也能明显优于PHP.因为编译本来就消耗时间和CPU,所以JIT不可能即时编译每一行代码,JIT只会选择编译热点代码,比如大量的循环,频繁被调用的函数.总而言之,当你的场景不能触发JIT时,JIT优势就会荡然无存.

Node.JS只是把网络/磁盘IO卸载到了libuv线程池里,用户在回调函数里编写的代码运行在主线程,同样会造成阻塞.所以说,即使Node.JS计算快,也应该尽量避免在回调函数里执行耗时的计算导致的阻塞,毕竟Node.JS真正只有一个主线程在提供服务,一旦主线程被阻塞,异步将无从谈起.

JSP是Tomcat为Java Web应用提供的模板引擎,而PHP内置C实现的模板引擎.Tomcat是Java编写的单进程多线程HTTP应用服务器,而PHP-FPM是用C编写的多进程FastCGI网络服务,就网络而言,PHP-FPM不见得性能不如Tomcat.而且,PHP-FPM的架构和PHP的运行模式也决定了PHP Web服务更稳定,不会轻易发生内存泄露/膨胀或者服务崩溃.PHP的库函数使用C实现的,而Java的核心运行时类库rt.jar是用Java编写的.