C，Java和Python之间的性能比较-c语言python和java推荐学哪个

这是我用所有三种语言运行矩阵乘法时发生的情况

在过去的两年中，我为C语言做了大量的实现工作。我之所以选择C语言而不是其他语言，是因为人们普遍认为C代码比其他流行的编程语言(例如Java和Python)运行得更快。但是，即使我一直对C的速度(或C实际上最快)感到好奇，我自己也没有做任何实验来证实这一说法。最后，我决定进行一些实验，以比较C，Java和Python的性能。本文是关于我进行的实验和获得的结果的文章。

本实验

我决定使用所有三种语言进行矩阵乘法。矩阵的大小为2048 x 2048(即每个矩阵的乘法和加法运算为8,589,934,592)，我为它们填充了0.0到1.0之间的随机值(使用随机值而不是对所有三种语言使用完全相同的矩阵的影响可以忽略不计)。我将每个实验运行了五次，并计算了平均运行时间。

C代码

#include <stdlib.h> 
#include <stdio.h> 
#include <time.h> 
 
#define n 2048 
 
double A[n][n]; 
double B[n][n]; 
double C[n][n]; 
 
int main() { 
 
    //populate the matrices with random values between 0.0 and 1.0 
    for (int i = 0; i < n; i++) { 
        for (int j = 0; j < n; j++) { 
 
            A[i][j] = (double) rand() / (double) RAND_MAX; 
            B[i][j] = (double) rand() / (double) RAND_MAX; 
            C[i][j] = 0; 
        } 
    } 
 
    struct timespec start, end; 
    double time_spent; 
 
    //matrix multiplication 
    clock_gettime(CLOCK_REALTIME, &start); 
    for (int i = 0; i < n; i++) { 
        for (int j = 0; j < n; j++) { 
            for (int k = 0; k < n; k++) { 
                C[i][j] += A[i][k] * B[k][j]; 
            } 
        } 
    } 
    clock_gettime(CLOCK_REALTIME, &end); 
    time_spent = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1000000000.0; 
    printf("Elapsed time in seconds: %f \n", time_spent); 
    return 0; 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.

Java代码

import java.util.Random; 
 
public class MatrixMultiplication { 
    static int n = 2048; 
    static double[][] A = new double[n][n]; 
    static double[][] B = new double[n][n]; 
    static double[][] C = new double[n][n]; 
 
    public static void main(String[] args) { 
        //populate the matrices with random values between 0.0 and 1.0 
        Random r = new Random(); 
        for (int i = 0; i < n; i++) { 
            for (int j = 0; j < n; j++) { 
                A[i][j] = r.nextDouble(); 
                B[i][j] = r.nextDouble(); 
                C[i][j] = 0; 
            } 
        } 
 
        long start = System.nanoTime(); 
        //matrix multiplication 
        for (int i = 0; i < n; i++) { 
            for (int j = 0; j < n; j++) { 
                for (int k = 0; k < n; k++) { 
                    C[i][j] += A[i][k] * B[k][j]; 
                } 
            } 
        } 
 
        long stop = System.nanoTime(); 
        double timeDiff = (stop - start) * 1e-9; 
        System.out.println("Elapsed time in seconds: " + timeDiff); 
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.

Python代码

import random 
import time 
 
n = 2048 
 
#populate the matrices with random values between 0.0 and 1.0 
A = [[random.random() for row in range(n)] for col in range(n)] 
B = [[random.random() for row in range(n)] for col in range(n)] 
C = [[0 for row in range(n)] for col in range(n)] 
 
start = time.time() 
#matrix multiplication 
for i in range(n): 
    for j in range(n): 
        for k in range(n): 
            C[i][j] += A[i][k] * B[k][j] 
 
end = time.time() 
print("Elapsed time in seconds %0.6f" % (end-start)) 
如何编译和运行 
#C 
gcc MatrixMultiplication.c -o matrix 
./matrix 
 
#Java 
javac MatrixMultiplication.java 
java MatrixMultiplication 
 
#Python 
python MatrixMultiplication.py 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.

如何编译和运行

#C 
gcc MatrixMultiplication.c -o matrix 
./matrix 
 
#Java 
javac MatrixMultiplication.java 
java MatrixMultiplication 
 
#Python 
python MatrixMultiplication.py 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

运行时间

根据这些结果，C比Java慢2.34倍，Python比Java慢33.34倍。

等待!!! C应该不是最快的吗???

实际上，这是不公平的比较。当我们编译Java程序时，即使没有任何优化标志，Java JIT(即时)编译器也会自动执行优化。但是，对于GCC(编译C程序)，情况并非如此，我们必须显式设置优化标志。

因此，我在编译C程序时使用了-O2和-O3优化标志，并再次进行了实验。

gcc -O2 MatrixMultiplication.c -o matrix./matrixgcc -O3 MatrixMultiplication.c -o matrix./matrix

新的经过时间

现在，Java代码比C [-O3]慢1.69倍，而Python代码慢56倍。我做出了正确的决定(或者很幸运：-))，选择了C而不是其他编程语言。

总结结果

讨论结果

Python相对非常慢，因为C是经过编译的，而Python是被解释的。编译器一次将C代码转换为机器代码。另一方面，解释器必须读取，解释和执行每一行代码，并更新机器状态(这会增加很多开销)。将程序编译为机器代码时，CPU可以直接执行它。但是，当涉及到解释器时，CPU将运行解释器，并且解释器本身将执行程序。 (如果您对编译器和解释器感兴趣，请阅读Vaidehi Joshi撰写的精彩文章)
这就是使Python非常灵活的原因。 Python牺牲了一点性能来提供更多的灵活性/高级编程功能(如果不使用C语言指定数据类型，则不能将变量初始化为n = 100，但是可以在Python中进行初始化)。
JIT(Java编译器)位于C和Python之间。首次执行代码时，将对其进行解释。但是，当一段代码频繁执行时，它会实时编译为机器代码，并且进一步的执行将使用编译后的版本。

本文的灵感来自Charles E. Leiserson教授关于性能工程的演讲，我修改了他使用的源代码以满足我的要求。