我们有多种选择来做同样的事情，很多人都分享了他们的答案。

我发现以下两种方法既简单又有效：

DataFrame.iterrows（）DataFrame.itertuples（）

例子：

 import pandas as pd
 inp = [{'c1':10, 'c2':100}, {'c1':11,'c2':110}, {'c1':12,'c2':120}]
 df = pd.DataFrame(inp)
 print (df)

 # With the iterrows method

 for index, row in df.iterrows():
     print(row["c1"], row["c2"])

 # With the itertuples method

 for row in df.itertuples(index=True, name='Pandas'):
     print(row.c1, row.c2)

注意：itertples（）应该比iterrows（）快

您应该使用df.iterrows（）。虽然逐行迭代不是特别有效，因为必须创建Series对象。

DataFrame.iterrows是一个生成索引和行（作为一个系列）的生成器：

import pandas as pd

df = pd.DataFrame({'c1': [10, 11, 12], 'c2': [100, 110, 120]})
df = df.reset_index()  # make sure indexes pair with number of rows

for index, row in df.iterrows():
    print(row['c1'], row['c2'])

10 100
11 110
12 120

在Pandas数据帧中有很多方法可以迭代行。一种非常简单直观的方法是：

df = pd.DataFrame({'A':[1, 2, 3], 'B':[4, 5, 6], 'C':[7, 8, 9]})
print(df)
for i in range(df.shape[0]):
    # For printing the second column
    print(df.iloc[i, 1])

    # For printing more than one columns
    print(df.iloc[i, [0, 2]])

为了循环数据帧中的所有行并方便地使用每行的值，可以将命名元组转换为ndarray。例如：

df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]}, index=['a', 'b'])

在行上循环：

for row in df.itertuples(index=False, name='Pandas'):
    print np.asarray(row)

结果是：

[ 1.   0.1]
[ 2.   0.2]

请注意，如果index=True，则将索引添加为元组的第一个元素，这对于某些应用程序来说可能是不可取的。

有时循环确实比矢量化代码更好

正如这里的许多答案正确指出的那样，Pandas中的默认计划应该是编写矢量化代码（带有隐式循环），而不是自己尝试显式循环。但问题仍然是你是否应该在Pandas中编写循环，如果是的话，在这些情况下最好的循环方式是什么。

我认为，至少有一种情况下循环是合适的：当您需要以某种复杂的方式计算依赖于其他行中的值的函数时。在这种情况下，循环代码通常比矢量化代码更简单、更可读、更不易出错。

循环代码甚至可能更快，正如您将在下面看到的那样，所以在速度至关重要的情况下，循环可能是有意义的。但实际上，这些只是一些情况的子集，您可能应该首先使用numpy/numa（而不是Pandas），因为优化的numpy/noma几乎总是比Pandas更快。

让我们用一个例子来说明这一点。假设您希望获取一列的累积和，但每当其他列等于零时，将其重置：

import pandas as pd
import numpy as np

df = pd.DataFrame( { 'x':[1,2,3,4,5,6], 'y':[1,1,1,0,1,1]  } )

#   x  y  desired_result
#0  1  1               1
#1  2  1               3
#2  3  1               6
#3  4  0               4
#4  5  1               9
#5  6  1              15

这是一个很好的例子，你当然可以写一行Pandas来实现这一点，尽管它不是特别可读，特别是如果你还没有对Pandas有足够的经验：

df.groupby( (df.y==0).cumsum() )['x'].cumsum()

对于大多数情况来说，这将足够快，尽管您也可以通过避免groupby来编写更快的代码，但它可能更不可读。

或者，如果我们把它写成一个循环呢？您可以使用NumPy执行以下操作：

import numba as nb

@nb.jit(nopython=True)  # Optional
def custom_sum(x,y):
    x_sum = x.copy()
    for i in range(1,len(df)):
        if y[i] > 0: x_sum[i] = x_sum[i-1] + x[i]
    return x_sum

df['desired_result'] = custom_sum( df.x.to_numpy(), df.y.to_numpy() )

诚然，将DataFrame列转换为NumPy数组需要一些开销，但核心代码只有一行代码，即使您对Pandas或NumPy一无所知，也可以阅读：

if y[i] > 0: x_sum[i] = x_sum[i-1] + x[i]

这段代码实际上比矢量化代码更快。在一些具有100000行的快速测试中，上述方法比groupby方法快大约10倍。注意，速度的一个关键是numba，这是可选的。如果没有“@nb.jit”行，循环代码实际上比groupby方法慢大约10倍。

显然，这个示例非常简单，您可能更喜欢一行panda，而不是编写一个带有相关开销的循环。然而，对于这个问题，有更复杂的版本，NumPy/numa循环方法的可读性或速度可能是有意义的。