有时，有用的模式是：

# Borrowing @KutalmisB df example
df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]}, index=['a', 'b'])
# The to_dict call results in a list of dicts
# where each row_dict is a dictionary with k:v pairs of columns:value for that row
for row_dict in df.to_dict(orient='records'):
    print(row_dict)

结果是：

{'col1':1.0, 'col2':0.1}
{'col1':2.0, 'col2':0.2}

首先考虑是否真的需要迭代DataFrame中的行。请参阅此答案以了解备选方案。

如果仍然需要迭代行，可以使用以下方法。请注意其他答案中未提及的一些重要注意事项。

DataFrame.iterrows（）对于索引，df.iterrows（）中的行：打印（行[“c1”]，行[“c2”]）DataFrame.itertuples（）对于df.itertuples中的行（索引=True，名称=“标准”）：打印（第c1行，第c2行）

itertples（）应该比iterrows（）快

但请注意，根据文件（熊猫目前为0.24.2）：

iterrows:dtype可能在行与行之间不匹配

因为iterrows为每一行返回一个Series，所以它不会跨行保留数据类型（数据帧的数据类型跨列保留）。为了在遍历行时保留数据类型，最好使用itertples（），它返回值的namedtuples，通常比iterrows（）快得多

iterrows：不修改行

您不应该修改正在迭代的内容。这并不能保证在所有情况下都有效。根据数据类型的不同，迭代器返回的是副本而不是视图，写入它不会产生任何影响。

请改用DataFrame.apply（）：

    new_df = df.apply(lambda x: x * 2, axis = 1)

迭代：

如果列名是无效的Python标识符、重复或以下划线开头，则将重命名为位置名。对于大量列（>255），将返回常规元组。

有关详细信息，请参阅panda迭代文档。

可以按如下方式使用df.iloc函数：

for i in range(0, len(df)):
    print(df.iloc[i]['c1'], df.iloc[i]['c2'])

虽然iterrows（）是一个很好的选项，但有时itertples（）会快得多：

df = pd.DataFrame({'a': randn(1000), 'b': randn(1000),'N': randint(100, 1000, (1000)), 'x': 'x'})

%timeit [row.a * 2 for idx, row in df.iterrows()]
# => 10 loops, best of 3: 50.3 ms per loop

%timeit [row[1] * 2 for row in df.itertuples()]
# => 1000 loops, best of 3: 541 µs per loop

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

正如这里的许多答案正确指出的那样，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循环方法的可读性或速度可能是有意义的。

对于查看和修改值，我将使用iterrows（）。在for循环中，通过使用元组解包（参见示例：i，row），我使用行仅查看值，并在需要修改值时使用i和loc方法。正如前面的回答所述，这里您不应该修改正在迭代的内容。

for i, row in df.iterrows():
    df_column_A = df.loc[i, 'A']
    if df_column_A == 'Old_Value':
        df_column_A = 'New_value'  

在这里，循环中的行是该行的副本，而不是它的视图。因此，您不应该编写类似于行['a']='New_Value'的内容，它不会修改DataFrame。但是，您可以使用i和loc并指定DataFrame来完成这项工作。