用熊猫遍历数据帧的最有效方法是什么？

Date,Open,High,Low,Close,Volume,Adj Close
2011-10-19,27.37,27.47,27.01,27.13,42880000,27.13
2011-10-18,26.94,27.40,26.80,27.31,52487900,27.31
2011-10-17,27.11,27.42,26.85,26.98,39433400,26.98
2011-10-14,27.31,27.50,27.02,27.27,50947700,27.27

....

#!/usr/bin/env python
from pandas import *

df = read_csv('table.csv')

for i, row in enumerate(df.values):
    date = df.index[i]
    open, high, low, close, adjclose = row
    #now perform analysis on open/close based on date, etc..

#1 楼

熊猫的最新版本现在包括用于遍历行的内置函数。

for index, row in df.iterrows():

    # do some logic here

或者，如果您希望更快地使用itertuples()

但是，unutbu建议使用numpy函数以避免对行进行迭代将产生最快的代码。

#2 楼

Pandas基于NumPy数组。
加快NumPy数组速度的关键是一次对整个数组执行操作，而不是逐行或逐项执行。

例如，如果close是一维数组，并且您想要逐日变化百分比，

pct_change = close[1:]/close[:-1]

这将计算整个变化数组作为一个语句，而不是

pct_change = []
for row in close:
    pct_change.append(...)

，所以请尝试完全避免Python循环for i, row in enumerate(...)，并且
考虑如何在整个操作中执行计算整个数组（或数据框），而不是逐行。

#3 楼

就像之前提到的那样，pandas对象在一次处理整个数组时效率最高。但是对于像我这样真正需要遍历pandas DataFrame来执行某些操作的人，我发现至少有三种方法可以做到这一点。我做了一个简短的测试，看看这三个时间中哪一个最省时。

t = pd.DataFrame({'a': range(0, 10000), 'b': range(10000, 20000)})
B = []
C = []
A = time.time()
for i,r in t.iterrows():
    C.append((r['a'], r['b']))
B.append(time.time()-A)

C = []
A = time.time()
for ir in t.itertuples():
    C.append((ir[1], ir[2]))    
B.append(time.time()-A)

C = []
A = time.time()
for r in zip(t['a'], t['b']):
    C.append((r[0], r[1]))
B.append(time.time()-A)

print B

结果：消耗，但对我来说是快速的。
恕我直言，这里有一些优点和缺点： （）：比.iterrows（）快，但是返回索引和行项目，ir [0]是索引。
zip：最快，但无法访问该行的索引。

EDIT 2020/11/10
值得一提的是，这里提供了一些其他替代产品的更新基准（使用MacBookPro 2,4 GHz Intel Core i9 8核32 Go 2667 MHz DDR4的性能）
=“ lang-py prettyprint-override”> import sys import tqdm import time import pandas as pd B = [] t = pd.DataFrame({'a': range(0, 10000), 'b': range(10000, 20000)}) for _ in tqdm.tqdm(range(10)): C = [] A = time.time() for i,r in t.iterrows(): C.append((r['a'], r['b'])) B.append({"method": "iterrows", "time": time.time()-A}) C = [] A = time.time() for ir in t.itertuples(): C.append((ir[1], ir[2])) B.append({"method": "itertuples", "time": time.time()-A}) C = [] A = time.time() for r in zip(t['a'], t['b']): C.append((r[0], r[1])) B.append({"method": "zip", "time": time.time()-A}) C = [] A = time.time() for r in zip(*t.to_dict("list").values()): C.append((r[0], r[1])) B.append({"method": "zip + to_dict('list')", "time": time.time()-A}) C = [] A = time.time() for r in t.to_dict("records"): C.append((r["a"], r["b"])) B.append({"method": "to_dict('records')", "time": time.time()-A}) A = time.time() t.agg(tuple, axis=1).tolist() B.append({"method": "agg", "time": time.time()-A}) A = time.time() t.apply(tuple, axis=1).tolist() B.append({"method": "apply", "time": time.time()-A}) print(f'Python {sys.version} on {sys.platform}') print(f"Pandas version {pd.__version__}") print( pd.DataFrame(B).groupby("method").agg(["mean", "std"]).xs("time", axis=1).sort_values("mean") ) ## Output Python 3.7.9 (default, Oct 13 2020, 10:58:24) [Clang 12.0.0 (clang-1200.0.32.2)] on darwin Pandas version 1.1.4 mean std method zip + to_dict('list') 0.002353 0.000168 zip 0.003381 0.000250 itertuples 0.007659 0.000728 to_dict('records') 0.025838 0.001458 agg 0.066391 0.007044 apply 0.067753 0.006997 iterrows 0.647215 0.019600

#4 楼

您可以通过转置然后调用迭代项来遍历各行：

为了在迭代算法中获得最佳性能，您可能想探索用Cython编写代码，因此可以执行以下操作：

for date, row in df.T.iteritems():
   # do some logic here

我建议编写首先，请使用纯Python编写该算法，并确保它能够运行并观察其运行速度-如果运行速度不够快，只需花费最少的工作即可将其转换为Cython，从而获得与手工编码的C / C ++差不多的速度。

#5 楼

您有以下三种选择：

按索引（最简单）：

>>> for index in df.index:
...     print ("df[" + str(index) + "]['B']=" + str(df['B'][index]))

具有迭代次数（最常用）：

>>> for index, row in df.iterrows():
...     print ("df[" + str(index) + "]['B']=" + str(row['B']))

使用itupuples（最快）：

>>> for row in df.itertuples():
...     print ("df[" + str(row.Index) + "]['B']=" + str(row.B))

三个选项显示如下：

df[0]['B']=125
df[1]['B']=415
df[2]['B']=23
df[3]['B']=456
df[4]['B']=189
df[5]['B']=456
df[6]['B']=12

来源：Neuro-networks.io

#6 楼

在注意到尼克·克劳福德的答案后，我检查了iterrows，但发现它产生了（索引，系列）元组。不确定哪种方法最适合您，但是我最终对问题使用了itertuples方法，该方法产生了（index，row_value1 ...）元组。 ，系列）元组。

#7 楼

只是一个很小的补充，如果您具有应用于单个列的复杂功能，则也可以执行应用：
generate / pandas.DataFrame.apply.html

df[b] = df[a].apply(lambda col: do stuff with col here)

#8 楼

正如@joris指出的那样，iterrows比itertuples慢得多，而itertuples比iterrows慢100倍左右，我在使用5027505的DataFrame中测试了这两种方法的速度，结果是iterrows的结果是1200it / s，而itertuples是120000it / s。

如果使用itertuples，请注意，for循环中的每个元素都是一个namedtuple，因此要获取每一列中的值，可以参考以下示例代码

>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]},
                      index=['a', 'b'])
>>> df
   col1  col2
a     1   0.1
b     2   0.2
>>> for row in df.itertuples():
...     print(row.col1, row.col2)
...
1, 0.1
2, 0.2

#9 楼

当然，迭代数据帧的最快方法是通过df.values（如您所做的那样）或分别访问df.column_name.values来访问基础的numpy ndarray。由于您也想访问索引，因此可以使用df.index.values。

index = df.index.values
column_of_interest1 = df.column_name1.values
...
column_of_interestk = df.column_namek.values

for i in range(df.shape[0]):
   index_value = index[i]
   ...
   column_value_k = column_of_interest_k[i]

不是pythonic吗？当然。但是很快。

如果您想从循环中挤出更多果汁，您将需要使用cython。 Cython将使您获得巨大的加速（想想10倍至100倍）。为了获得最佳性能，请检查cython的内存视图。

#10 楼

另一个建议是，如果行的子集共享特征，则可以将groupby与矢量化计算结合使用。

#11 楼

我相信遍历DataFrames的最简单，最有效的方法是使用numpy和numba。在这种情况下，在许多情况下，循环的速度可以与向量化操作差不多。如果不是numba，则简单的numpy可能是次佳选择。正如很多次提到的那样，您的默认值应该是向量化，但是由于任何原因，只要给出决定循环，此答案仅考虑有效循环。
对于测试用例，让我们使用@DSM的计算示例百分比变化。这是一种非常简单的情况，实际上，您不会编写循环来计算它，但是这样可以为时序矢量化方法与循环提供合理的基线。 ，我们将它们计时在下面的更大数据集上。

import pandas as pd
import numpy as np
import numba as nb

df = pd.DataFrame( { 'close':[100,105,95,105] } )

pandas_vectorized = df.close.pct_change()[1:]

x = df.close.to_numpy()
numpy_vectorized = ( x[1:] - x[:-1] ) / x[:-1]
        
def test_numpy(x):
    pct_chng = np.zeros(len(x))
    for i in range(1,len(x)):
        pct_chng[i] = ( x[i] - x[i-1] ) / x[i-1]
    return pct_chng

numpy_loop = test_numpy(df.close.to_numpy())[1:]

@nb.jit(nopython=True)
def test_numba(x):
    pct_chng = np.zeros(len(x))
    for i in range(1,len(x)):
        pct_chng[i] = ( x[i] - x[i-1] ) / x[i-1]
    return pct_chng
    
numba_loop = test_numba(df.close.to_numpy())[1:]

这是具有100,000行的DataFrame上的计时（使用Jupyter的%timeit函数执行的计时，为了便于阅读而折叠到汇总表中）：

pandas/vectorized   1,130 micro-seconds
numpy/vectorized      382 micro-seconds
numpy/looped       72,800 micro-seconds
numba/looped          455 micro-seconds

总结：对于像这样的简单情况，您可以使用（矢量化的）pandas来简化操作和提高可读性，并使用（矢量化的）numpy来提高速度。如果您确实需要使用循环，请在numpy中进行。如果可用numba，请将其与numpy结合使用以提高速度。在这种情况下，numpy + numba几乎与矢量化numpy代码一样快。
其他详细信息：

未显示各种选项，例如iterrows，itetuples等，它们的数量级要慢一些，
这里的时间非常典型：numpy比pandas快，vectorized比循环快，但是将numba添加到numpy通常会大大加快numpy的速度。
除pandas选项之外的所有内容需要将DataFrame列转换为numpy数组。该转换包含在计时中。
定时中不包括定义/编译numpy / numba函数的时间，但是对于任何大型数据帧，时间通常可以忽略不计。