# Python 3.14 将比 C++ 更快

Python 是数据科学 (DS) 和机器学习 (ML) 中最常用的脚本语言之一。根据“PopularitY of Programming Languages”，Python 是 Google 上搜索次数最多的语言。除了作为将各种 DS/ML 解决方案连接在一起的出色胶水语言之外，它还有许多库可以对数据进行方便处理。

`````` def estimate_pi(
n_points: int,
show_estimate: bool,
) -> None:
"""
Simple Monte Carlo Pi estimation calculation.
Parameters
----------
n_points
number of random numbers used to for estimation.
show_estimate
if True, will show the estimation of Pi, otherwise
will not output anything.
"""
within_circle = 0

for _ in range(n_points):
x, y = (random.uniform(-1, 1) for v in range(2))
radius_squared = x**2 + y**2

if radius_squared <= 1:
within_circle += 1

pi_estimate = 4 * within_circle / n_points

if not show_estimate:
print("Final Estimation of Pi=", pi_estimate)

def run_test(
n_points: int,
n_repeats: int,
only_time: bool,
) -> None:
"""
Perform the tests and measure required time.
Parameters
----------
n_points
number of random numbers used to for estimation.
n_repeats
number of times the test is repeated.
only_time
if True will only print the time, otherwise
will also show the Pi estimate and a neat formatted
time.
"""
start_time = time.time()

for _ in range(n_repeats):
estimate_pi(n_points, only_time)

if only_time:
print(f"{(time.time() - start_time)/n_repeats:.4f}")
else:
print(
f"Estimating pi took {(time.time() - start_time)/n_repeats:.4f} seconds per run."
)
``````

`````` docker run -it --rm
-v \$PWD/your_script.py:/your_script.py
python:3.11-rc-slim
python /yourscript.py
``````

`````` def test_version(image: str) -> float:
"""
Run single_test on Python Docker image.
Parameter
---------
image
full name of the the docker hub Python image.
Returns
-------
run_time
runtime in seconds per test loop.
"""
output = subprocess.run([
'docker',
'run',
'-it',
'--rm',
'-v',
f'{cwd}/{SCRIPT}:/{SCRIPT}',
image,
'python',
f'/{SCRIPT}',
'--n_points',
str(N_POINTS),
'--n_repeats',
str(N_REPEATS),
'--only-time',
],
capture_output=True,
text=True,
)

avg_time = float(output.stdout.strip())

return avg_time

# Get test time for current Python version
base_time = test_version(NEW_IMAGE['image'])
print(f"The new {NEW_IMAGE['name']} took {base_time} seconds per run.n")

# Compare to previous Python versions
for item in TEST_IMAGES:
ttime = test_version(item['image'])
print(
f"{item['name']} took {ttime} seconds per run."
f"({NEW_IMAGE['name']} is {(ttime / base_time) - 1:.1%} faster)"
)
``````

`````` The new Python 3.11 took 6.4605 seconds per run.

Python 3.5 took 11.3014 seconds.(Python 3.11 is 74.9% faster)
Python 3.6 took 11.4332 seconds.(Python 3.11 is 77.0% faster)
Python 3.7 took 10.7465 seconds.(Python 3.11 is 66.3% faster)
Python 3.8 took 10.6904 seconds.(Python 3.11 is 65.5% faster)
Python 3.9 took 10.9537 seconds.(Python 3.11 is 69.5% faster)
Python 3.10 took 8.8467 seconds.(Python 3.11 is 36.9% faster)
``````

Python 3.11 的基准测试平均耗时 6.46 秒。与之前的版本 (3.10) 相比，这几乎快了 37%。3.9 版和 3.10 版之间的差异大致相同，在下图中我们进行这个数据的可视化：

``````  C 比 Python 快得多！
``````

`````` #include <stdlib.h>
#include <stdio.h>
#include <chrono>
#include <array>

#define N_POINTS 10000000
#define N_REPEATS 10

float estimate_pi(int n_points) {
double x, y, radius_squared, pi;
int within_circle=0;

for (int i=0; i < n_points; i++) {
x = (double)rand() / RAND_MAX;
y = (double)rand() / RAND_MAX;

radius_squared = x*x + y*y;
if (radius_squared <= 1) within_circle++;
}

pi=(double)within_circle/N_POINTS * 4;
return pi;
}

int main() {
double avg_time = 0;

srand(42);

for (int i=0; i < N_REPEATS; i++) {
auto begin = std::chrono::high_resolution_clock::now();
double pi = estimate_pi(N_POINTS);
auto end = std::chrono::high_resolution_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
avg_time += elapsed.count() * 1e-9;
printf("Pi is approximately %g and took %.5f seconds to calculate.n", pi, elapsed.count() * 1e-9);
}

printf("nEach loop took on average %.5f seconds to calculate.n", avg_time / N_REPEATS);
}
``````

C++ 是一种编译语言，我们需要先编译源代码才能使用它：

`````` g++ -o pi_estimate pi_estimate.c
``````

`````` Pi is approximately 3.14227 and took 0.25728 seconds to calculate.
Pi is approximately 3.14164 and took 0.25558 seconds to calculate.
Pi is approximately 3.1423 and took 0.25740 seconds to calculate.
Pi is approximately 3.14108 and took 0.25737 seconds to calculate.
Pi is approximately 3.14261 and took 0.25664 seconds to calculate.

Each loop took on average 0.25685 seconds to calculate.
``````

python 3.11的速度的有了很大的进步，虽然与编译语言相比还差了很多但是开发团队还在速度优化这个方向努力，所以希望Python的运行速度还有更大的进步。以上只是大佬开的一个玩笑，但上面的代码都可以在下面的链接找到，所以我们的结论还是有根据的😏