Python中數(shù)值比較的效率

更新時間：2023年01月28日 15:33:21 作者：風(fēng)華明遠

這篇文章主要介紹了Python中數(shù)值比較的效率，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教

Python數(shù)值比較的效率

Python 數(shù)值比較運算效率：>,<,==,!=,>=和<=

python數(shù)值比較運算有6種，分別為>,<,==,!=,>=和 <=。他們的運算效率如何？采用哪種方式最高效？本文通過使用timeit來測試比較運算的效率。

程序如下：

import timeit                                                       
                                                                    
def func1():                                                        
    for i in range(100000):                                         
        if i > 0:                                                   
            k = 2                                                   
                                                                    
def func2():                                                        
    for i in range(100000):                                         
        if i < 0:                                                   
            k = 2                                                   
                                                                    
def func3():                                                        
    for i in range(100000):                                         
        if i == 0:                                                  
            k = 2                                                   
                                                                    
def func4():                                                        
    for i in range(100000):                                         
        if i != 0:                                                  
            k = 2                                                   
                                                                    
def func5():                                                        
    for i in range(100000):                                         
        if i >= 0:                                                  
            k = 2                                                   
                                                                    
def func6():                                                        
    for i in range(100000):                                         
        if i <= 0:                                                  
            k = 2                                                   
                                                                    
                                                                    
                                                                    
if __name__ == '__main__':                                          
    func1()                                                         
    func=[func1,func2,func3,func4,func5,func6]                      
    op = [">","<","==","!=",">=","<="]                              
    for j in range(6):                                              
        v = 0                                                       
        timer = timeit.Timer(func[j])                               
        v+= timer.timeit(number=1000)                               
        print(op[j],":",v)

這是只有if語句的情況，結(jié)果如下：

比較運算	所用時間
>	3.2038074
<	2.7034741
==	2.6940471000000006
!=	3.285996800000001
>=	3.205210300000001
<=	2.6961838999999994

加上else語句則：

比較運算	所用時間
>	3.2270024
<	3.2400326
==	3.2511219999999996
!=	3.1877201999999993
>=	3.2120345000000015
<=	3.2339978999999985

一般情況下，第一個分支比較節(jié)省時間。第二個分支會耗時稍微多一些。

不同python實現(xiàn)的效率比較

1.取出內(nèi)層容器的多個值

如果要從嵌套的列表中獲取內(nèi)層列表每個索引對應(yīng)的最大(或最小值)，有兩種方法：

import time
import random
a = [[random.randint(0, 1000) for i in range(10)] for j in range(100000)]

def method_x(a):
?? ?"""每個索引位置一個生成器表達式"""
? ? begin = time.time()
? ? b = min(i[0] for i in a)
? ? c = min(i[1] for i in a)
? ? d = min(i[2] for i in a)
? ? e = min(i[3] for i in a)
? ? f = min(i[4] for i in a)
? ? g = min(i[5] for i in a)
? ? h = min(i[6] for i in a)
? ? i = min(i[7] for i in a)
? ? j = min(i[8] for i in a)
? ? k = min(i[9] for i in a)
? ? print(time.time()-begin)

def method_y(a):
?? ?"""只循環(huán)一次算出各個索引對應(yīng)的值"""
? ? begin = time.time()
? ? b,c,d,e,f,g,h,i,j,k = 100,100,100,100,100,100,100,100,100,100
? ? for t in a:
? ? ? ? b = min(t[0], b)
? ? ? ? c = min(t[1], c)
? ? ? ? d = min(t[2], d)
? ? ? ? e = min(t[3], e)
? ? ? ? f = min(t[4], f)
? ? ? ? g = min(t[5], g)
? ? ? ? h = min(t[6], h)
? ? ? ? i = min(t[7], i)
? ? ? ? j = min(t[8], j)
? ? ? ? k = min(t[9], k)
? ? print(time.time()-begin)

結(jié)果

>>> method_x(a*10)
1.1728243827819824
>>> method_y(a*10)
2.1234960556030273

2.字符串去掉結(jié)尾(開頭)字符

去除字符串結(jié)尾字符，批量操作的話，一般使用 rstrip() 函數(shù)，但是這個函數(shù)效率不如直接索引快。

import random
import time
# a為10萬個長度是11位的字符串列表；b為10萬長度為9位的字符串列表；
a = [f'{random.randint(10,100)}xxxyyyzzz' for i in range(100000)]
b = [f'{random.randint(100000,110000)}xyz' for i in range(100000)]
def test1(a, str_cut):?? ?# replace
? ? b = time.time()
? ? c = [i.replace(str_cut, '') for i in a]
? ? print(time.time()-b)

def test2(a, str_cut):?? ?# rstrip()
? ? b = time.time()
? ? c = [i.rstrip(str_cut) for i in a]
? ? print(time.time()-b)

def test3(a, str_cut):?? ?# 索引
? ? b = time.time()
? ? x =len(str_cut)
? ? c = [i[:-x] for i in a]
? ? print(time.time()-b)

結(jié)果比較，當(dāng)想去掉字符長度大于保留的長度的時候，rstrip() 效率趨近于 replace() , 想去掉的字符長度小于保留部分時，rstrip() 趨近于直接索引。

>>> test1(a*10, 'xxxyyyzzz')
0.2882061004638672
>>> test2(a*10, 'xxxyyyzzz')
0.2662053108215332
>>> test3(a*10, 'xxxyyyzzz')
0.16613411903381348

>>> test1(b*10, 'xyz')
0.2721879482269287
>>> test2(b*10, 'xyz')
0.1911303997039795
>>> test3(b*10, 'xyz')
0.1501011848449707

3. in 操作要用集合

按一樣的邏輯寫了兩版程序，運行時間確差了好多，一步一步找，發(fā)現(xiàn)是 in 判斷后面用的容器類型不一樣。

a = range(0, 100000)
b = list(a)
c = set(a)

def test(a):
? ? t = time.time()
? ? c = 0
? ? for i in range(0, 100000, 13):
? ? ? ? if i in a:
? ? ? ? ? ? c += 1
? ? print(c)
? ? print(time.time()-t)

測試時間，差距極大：

>>> test(b)
7693
5.649996280670166
>>> test(a)
7693
0.0019681453704833984

每次判斷之前把列表轉(zhuǎn)換為集合，能改進運行的效率：

def test(a):
? ? t = time.time()
? ? c = 0
? ? a = set(a)
? ? for i in range(0, 100000, 13):
? ? ? ? if i in a:
? ? ? ? ? ? c += 1
? ? print(c)
? ? print(time.time()-t)

>>> test(b)
7693
0.005988359451293945

4. 內(nèi)置的max()效率低

def getmax(a, b):
?? ?if a >= b:
?? ??? ?return a
?? ?return b

定義一個求最大值的函數(shù)，再用random模塊提前創(chuàng)造一個長度100的data_list用于測試(random本身耗時高，會讓比較效果不明顯)。

def main():
? ? t = time.time()
? ? for a, b in data_list*10000:
? ? ? ? max(a, b)
? ? print(time.time()-t)


def main2():
? ? t = time.time()
? ? for a, b in data_list*10000:
? ? ? ? getmax(a, b)
? ? print(time.time()-t)

自定義的函數(shù)比使用內(nèi)置的max()快了近一倍。