pandas/numpy/pure python - 向量加法性能

Question

我比較了在pandas / numpy /pure python 中添加兩個向量需要多長時間，並得到了一些令人驚訝的（對我來說）結果。

在 python3.6.9、Ubuntu 18.04、numpy=1.18.1、pandas==1.1.3 上測試。

代碼

import pandas as pd                                                             
import numpy as np                                                              
import random                                                                   
from timeit import timeit                                                       
                                                                                
repeat = 1000                                                                   
max_exp =7                                                                      
                                                                                
def time_all(a, b):                                                             
    sa = pd.Series(a)                                                           
    sb = pd.Series(b)                                                           
                                                                                
    na = np.array(a)                                                            
    nb = np.array(b)                                                            
                                                                                
    py_sum = lambda: [x + y for x, y in zip(a, b)]                              
    pd_sum = lambda: sa + sb                                                    
    np_sum = lambda: na + nb                                                    
                                                                                
    py_time = timeit(py_sum, number=repeat)                                     
    pd_time = timeit(pd_sum, number=repeat)                                     
    np_time = timeit(np_sum, number=repeat)                                     
                                                                                
    return py_time, pd_time, np_time                                            
                                                                                
for i in range(2, max_exp):                                                     
    size = 10 ** i                                                              
                                                                                
    a = [random.randint(0, 100) for x in range(0, size)]                        
    b = [random.randint(0, 100) for x in range(0, size)]                        
                                                                                
    py_time, pd_time, np_time = time_all(a, b)                                  
    py_pd = round(py_time / pd_time, 4)                                         
    py_np = round(py_time / np_time, 4)                                         
    pd_np = round(pd_time / np_time, 4)    
                                     
    print('''                                                                   
ARRAY SIZE: {}                                                                  
    PY/PD: {}                                                                   
    PY/NP: {}                                                                   
    PD/NP: {}'''.format(size, py_pd, py_np, pd_np)) 

結果

ARRAY SIZE: 100
    PY/PD: 0.0357
    PY/NP: 8.656
    PD/NP: 242.1978

ARRAY SIZE: 1000
    PY/PD: 0.3286
    PY/NP: 44.3758
    PD/NP: 135.05

ARRAY SIZE: 10000
    PY/PD: 2.8774
    PY/NP: 69.2828
    PD/NP: 24.0785

ARRAY SIZE: 100000
    PY/PD: 11.7784
    PY/NP: 76.5296
    PD/NP: 6.4974

ARRAY SIZE: 1000000
    PY/PD: 26.2985
    PY/NP: 33.1973
    PD/NP: 1.2623

問題

1. 對於小型 arrays（最多約 5k 個元素）python 比 pandas 更有效，因為非常小的差異很大。 有什么一般規則在純 python 上的操作比 pandas 有更好的性能嗎？ 諸如“對於少於 100 行的 pandas，無論您做什么，都會慢一個數量級”？
2. 據我了解，pandas 內部使用 numpy。 這些性能是否僅因為 pd.Series 和 np.array 之間的轉換時間而不同？ 如果是，有沒有辦法在創建 Series 時強制轉換？
3. （最不重要，但最令人驚訝）對於 10^6 陣列純 python 比 numpy 慢約 77 倍，但對於 10^7，比率僅為 33。為什么？

Answer 1

無論如何，這段代碼可以用矢量算法編寫，在這種情況下，numpy 將為您提供超過 1000> 的大量數據加速。