迭代vs向量化，如何提升Pandas性能？
在本文中，我們將探討幾種通過迭代和向量化技術來提高Pandas代碼性能的方法。
迭代是遍歷數(shù)據(jù)結構元素的過程，而向量化是將操作同時應用于整個數(shù)組或數(shù)據(jù)系列的一種方法，利用底層優(yōu)化來提高效率。
通過有效地使用這些技術，我們可以加速數(shù)據(jù)分析任務并提高代碼的效率。
理解迭代和向量化的區(qū)別
在這個例子中，我們將使用NumPy比較迭代和向量化的性能。
首先，導入所需的庫并創(chuàng)建一個隨機數(shù)據(jù)集。
import numpy as np
import time
# 創(chuàng)建一個包含1000萬個數(shù)據(jù)點的隨機數(shù)據(jù)集
data = np.random.rand(10000000)
data.shape(10000000,)
現(xiàn)在，使用for循環(huán)（迭代）來計算數(shù)據(jù)集中各元素的總和。
start_time = time.time()
sum_iter = 0
for i in data:
sum_iter += i
end_time = time.time()
print("Iteration - Sum:", sum_iter)
Print("Iteration - Time taken:", end_time - start_time, "seconds")(‘Iteration — Time taken:’, 3.507000207901001, ‘seconds’)
接下來，使用NumPy的內(nèi)置函數(shù)（向量化）來計算數(shù)據(jù)集中各元素的總和。
start_time = time.time()
sum_vec = np.sum(data)
end_time = time.time()
print("Vectorization - Sum:", sum_vec)
print("Vectorization - Time taken:", end_time - start_time, "seconds")(‘Vectorization — Time taken:’, 0.006000041961669922, ‘seconds’)
通過比較兩種方法所需的時間，可以觀察到向量化所實現(xiàn)的性能提升。
使用向量化函數(shù)加速操作
在這個例子中，我們將演示如何使用向量化函數(shù)來加速Python中的操作。我們將比較使用for循環(huán)和向量化函數(shù)執(zhí)行操作所需的時間。
首先，導入必要的庫并創(chuàng)建一個包含隨機數(shù)的數(shù)組。
import numpy as np
import time
# 創(chuàng)建一個包含100萬個隨機數(shù)的數(shù)組
data = np.random.rand(1000000)
data.shape(1000000,)
現(xiàn)在，使用for循環(huán)執(zhí)行操作，并計算出所需的時間。
使用for循環(huán)
start_time = time.time()
result = []
for value in data:
result.append(value * 2)
end_time = time.time()
for_loop_time = end_time - start_time
print("Time taken using a for loop: ", for_loop_time)(‘Time taken using a for loop: ‘, 0.3400001525878906)
接下來，使用向量化函數(shù)執(zhí)行相同的操作，并計算出所需的時間。
使用向量化函數(shù)
start_time = time.time()
result = data * 2
end_time = time.time()
vectorized_time = end_time - start_time
print("Time taken using a vectorized function: ", vectorized_time)(‘Time taken using a vectorized function: ‘, 0.059999942779541016)
最后，比較一下兩種方法所需的時間。
print("Speedup factor: ", for_loop_time / vectorized_time)(‘Speedup factor: ‘, 5.6666746139602155)
正如在示例中所看到的那樣，向量化函數(shù)比for循環(huán)快得多。這是因為向量化函數(shù)利用了底層優(yōu)化和硬件能力，使它們更加高效地處理大型數(shù)據(jù)集上的操作。
使用NumPy向量化優(yōu)化代碼
向量化是將一個逐個處理元素的算法轉換為一個等效的同時處理多個元素的算法的過程。
這可以帶來顯著的性能提升，特別是在處理大型數(shù)據(jù)集時。
讓我們從創(chuàng)建一個簡單的NumPy數(shù)組并使用迭代和向量化進行加法運算開始。
首先，導入所需的庫并創(chuàng)建一個NumPy數(shù)組。
import numpy as np
import time
# 創(chuàng)建一個包含1000萬個元素的NumPy數(shù)組
arr = np.arange(1, 10000001)
arrarray([ 1, 2, 3, …, 9999998, 9999999, 10000000])
現(xiàn)在，使用迭代（for循環(huán)）執(zhí)行加法運算。
# 使用for循環(huán)進行迭代
start_time = time.time()
result = np.zeros(len(arr))
for i in range(len(arr)):
result[i] = arr[i] + 1
print("Time taken for iteration: {} seconds".format(time.time() - start_time))Time taken for iteration: 7.158999681472778 seconds
接下來，使用NumPy向量化執(zhí)行相同的加法運算。
# 使用NumPy進行向量化
start_time = time.time()
result_vectorized = arr + 1
print("Time taken for vectorization: {} seconds".format(time.time() - start_time))Time taken for vectorization: 0.01999974250793457 seconds
你會注意到向量化所需的時間明顯低于迭代所需的時間。這展示了NumPy向量化在優(yōu)化代碼性能方面的強大作用。
現(xiàn)在，看另一個使用更復雜的操作的例子——計算兩組點之間的歐幾里得距離。
# 創(chuàng)建兩組點
points_a = np.random.random((1000000, 2))
points_b = np.random.random((1000000, 2))首先，使用迭代法計算歐幾里得距離。
def euclidean_distance_iterative(points_a, points_b):
num_points = len(points_a)
distances = np.zeros(num_points)
for i in range(num_points):
distances[i] = np.sqrt(np.sum((points_a[i] - points_b[i])**2))
return distancesstart_time = time.time()
result_iterative = euclidean_distance_iterative(points_a, points_b)
print("Time taken for iterative Euclidean distance: {} seconds".format(time.time() - start_time))Time taken for iterative Euclidean distance: 7.052000045776367 seconds
現(xiàn)在，使用NumPy向量化計算歐幾里得距離。
def euclidean_distance_vectorized(points_a, points_b):
return np.sqrt(np.sum((points_a - points_b)**2, axis=1))start_time = time.time()
result_vectorized = euclidean_distance_vectorized(points_a, points_b)
print("Time taken for vectorized Euclidean distance: {} seconds".format(time.time() - start_time))Time taken for vectorized Euclidean distance: 0.03600001335144043 seconds
同樣，你會注意到向量化方法所需的時間要比迭代方法低得多。
總之，使用NumPy的向量化可以極大地提高代碼性能，特別是在處理大型數(shù)據(jù)集時。在處理數(shù)值運算時，可以考慮向量化你的代碼，從而獲得更好的性能。
