平时用零碎的时间看python的教程，难得有一块空闲时间，用来检验一下成果。

常见的使用编程语言计算π近似值的方法有蒙特卡罗法(由落在正方形内1/4扇形概率为πR2/4R2 = k/n推导 )、定积分法和泰勒级数法等，本人现采用泰勒级数法计算，原理为：

反正切泰勒级数

别紧张，我们不会直接拿这个公式计算，因为当x=1时，arctanx = π/4，上面的级数就变成了这个样子：

arctan1

以及这个样子：

最终形态

变成这样就很直观了，下面就开始着手计算吧，先上JS代码：

function unfoldPiTaylor(num){

var sum = 0,flag = true;

for(var i = 0; i < num; i++){

sum += flag?(1/(2*i+1)):(-1/(2*i+1))

flag = !flag;

}

return sum * 4;

}

console.log("π的近似值：" + unfoldPiTaylor(10000000))

接着是Python(Python3)

#! /usr/bin/env python3

def TaylorPi(k):

sum,odd = 0,True

for i in range(1,k):

sum += 1/(2*i-1) if odd==True else -1/(2*i-1)

odd = not odd

return sum*4

print("Taylor unfold value is :%f"%TaylorPi(10000000)) #print与python2不同

结果：

image.png

如果参数足够大，结果就越精确

接下来进入正题，计算二者跑函数的时间：

function unfoldPiTaylor(num){

var sum = 0,flag = true;

for(var i = 0; i < num; i++){

sum += flag?(1/(2*i+1)):(-1/(2*i+1))

flag = !flag;

}

return sum * 4;

}

function caculateRunTime(){

var timSum = 0,start = 0,term = 0;

for(var j = 0; j < 100; j++){

start = new Date().getTime()

unfoldPiTaylor(10000000);

term = new Date().getTime() - start

timSum += term

console.log("one term done , duration:" + term/1000 + "ms");

}

return "total time:" + timSum + "ms. averange:" + timSum/100 + "ms"

}

console.log(caculateRunTime())

JS运行效率(ms)

#!/usr/bin/env python3

import time #时间模块

# Caculate PI with Taylor series

def TaylorPi(k):

sum,odd = 0,True

for i in range(1,k):

sum += 1/(2*i-1) if odd==True else -1/(2*i-1)

odd = not odd

return sum*4

def caculateRunTime():

before = time.time() #生成开始时间,单位为秒

timeSum = 0

for i in range(100):

start = time.time()

TaylorPi(10000000)

term = time.time() - start #每次循环耗时

print("one term done, duration:",term)

timeSum += term #累加

return "total:%lf,averange:%lf"%(timeSum,timeSum/100)

print(caculateRunTime())

Python运行效率(s)

这下对于两者的运行速度有了直观的认识了

日后回忆：

根据这样的结果就直接评判一个脚本语言的优劣是有失偏颇的，真正的性能瓶颈并不在调用api时产生(关键的影响性能的代码写在静态语言里)，python和node近年应用面飞速扩展，也得益于各自社区环境的完善，根据业务需求与场景，选择适合的架构而非纯粹追求脚本运行速度才是一个developer更加关心的问题。