我有一个Pandas数据框，df：
c1 c2
0 10 100
1 11 110
2 12 120
for row in df.rows:
print(row['c1'], row['c2'])
我找到了一个类似的问题，建议使用以下任一方法：
对于日期和行数据，使用df.T.iteritems()进行循环：
使用df.iterrows()进行循环：
但我不理解 row 对象是什么以及如何使用它。
DataFrame.iterrows是一个生成器，它同时产生索引和行（作为Series）：
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对象通常很慢。在许多情况下，不需要手动遍历行，可以通过以下方法之一避免：
- 寻找矢量化解决方案：许多操作可以使用内置方法或NumPy函数（布尔）索引等进行。
- 当您有一个无法一次处理完整DataFrame/Series的函数时，最好使用apply()而不是迭代值。请参阅有关函数应用的文档。
- 如果您需要对值进行迭代操作但性能很重要，请考虑使用cython或numba编写内部循环。有关此方法的示例，请参阅提高性能部分。
如果您想了解更多关于iter*函数的替代方案的深入内容，请查看本主题中的其他答案。
431341610650 被读取成了 4.31E+11。是否有一种方法可以保留数据类型而不出现这种情况？ - Aziz Altoitertuples函数来完成操作。也可以参考http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.itertuples.html。 - Axel如何在Pandas中迭代DataFrame的行
Pandas中的迭代是一种反模式，只有在耗尽其他选项时才应该使用。您不应该对带有“iter”名称的任何函数使用超过几千行，否则您将不得不习惯于等待很长时间。
您想要打印DataFrame吗？请使用DataFrame.to_string()。
您想要计算某些东西吗？在这种情况下，请按以下顺序搜索方法（列表修改自此处）：
for循环）DataFrame.apply()：i) 可在Cython中执行的归约操作，ii) 在Python空间中进行迭代。items() iteritems()DataFrame.itertuples()DataFrame.iterrows()iterrows和itertuples（在回答此问题时都获得了很多票）应该用于非常罕见的情况，例如为连续处理生成行对象/命名元组，这实际上是这些函数唯一有用的事情。
权威性呼吁
迭代页面上有一个巨大的红色警告框，其中写道：
遍历 pandas 对象通常很慢。在许多情况下，不需要手动遍历行 [...].
*实际情况比“不要”的复杂一些。df.iterrows()是这个问题的正确答案，但“向量化您的操作”才是更好的答案。我会承认有些情况下无法避免迭代（例如某些操作结果依赖于计算上一行的值）。但是，需要熟悉该库才能知道何时使用。如果您不确定是否需要迭代解决方案，则可能不需要。PS：要了解我编写此答案的基本原理，请跳到最底部。
许多基本操作和计算都被pandas“向量化”（通过NumPy或Cython化的函数）。这包括算术运算、比较、（大多数）缩减、重塑（如透视）、连接和分组操作。请查看基本功能文档，找到适合您问题的向量化方法。
如果没有适合的方法，可以使用自定义Cython扩展编写自己的方法。
如果1）没有可用的向量化解决方案，2）性能很重要，但不重要到需要将代码进行Cython优化的程度，以及3）您正在尝试对代码执行逐元素转换，则列表推导式应该是您的下一个选择。有足够的证据表明，对于许多常见的Pandas任务，列表推导式足够快（甚至有时更快）。
公式很简单，
# Iterating over one column - `f` is some function that processes your data
result = [f(x) for x in df['col']]
# Iterating over two columns, use `zip`
result = [f(x, y) for x, y in zip(df['col1'], df['col2'])]
# Iterating over multiple columns - same data type
result = [f(row[0], ..., row[n]) for row in df[['col1', ...,'coln']].to_numpy()]
# Iterating over multiple columns - differing data type
result = [f(row[0], ..., row[n]) for row in zip(df['col1'], ..., df['coln'])]
让我们通过一个简单的例子来演示添加两个pandas列A + B的差异。这是一种可向量化的操作，因此很容易对比上述方法的性能。
参考代码基准测试。底部的行测量了一个使用numpandas编写的函数，这是一种将Pandas与NumPy混合使用以获得最大性能的风格。除非您知道自己在做什么，否则应避免编写numpandas代码。尽可能使用API（即优先使用vec而不是vec_numpy）。
然而，我必须提到的是，并不总是如此明确。有时，“哪种操作方法最佳”这个问题的答案是“取决于您的数据”。我的建议是，在选择一种方法之前，请在您的数据上尝试不同的方法。
对于iter家族的各种替代方案进行的大多数分析都是从性能的角度来看的。然而，在大多数情况下，您通常会处理一个相当大小的数据集（不超过几千或100K行），性能将排在解决方案的简单性/可读性之后。
以下是我在选择解决问题的方法时的个人偏好。
对于新手：
向量化（如果可能）；
apply()；列表推导式；itertuples()/iteritems()；iterrows()；Cython
对于更有经验的人：
向量化（如果可能）；
apply()；列表推导式；Cython；itertuples()/iteritems()；iterrows()
向量化是任何可以向量化的问题最惯用的方法。始终寻求向量化！如果有疑问，请查阅文档，或在Stack Overflow上查找与您特定任务相关的现有问题。
我在很多帖子中经常抱怨apply有多糟糕，但我承认对于初学者来说更容易理解它正在做什么。此外，在我的这篇文章中解释了相当多的apply用例。
Cython排名较低，因为正确地处理它需要更多的时间和精力。您通常永远不需要编写需要比列表理解更高性能的Pandas代码。
* 如同任何个人意见一样，请充分考虑！
10分钟入门Pandas和基本功能介绍 - 有用的链接，介绍了Pandas及其向量化/ Cython化函数库。
提高性能 - 来自文档的入门指南，介绍了如何提高标准Pandas操作的性能。
Pandas中的for循环真的很糟糕吗？我什么时候应该关心？ - 我撰写的一篇详细文章，介绍了列表推导式及其在各种操作（主要涉及非数字数据的操作）中的适用性。
我何时（不）想在我的代码中使用pandas apply()函数？ - apply函数速度较慢（但不像iter*系列那样慢）。然而，在某些GroupBy操作中，有时可以（或应该）将apply作为一个严肃的替代方案考虑。
* Pandas字符串方法是“向量化”的，因为它们在系列上指定但对每个元素进行操作。底层机制仍然是迭代的，因为字符串操作本质上很难向量化。
我注意到新用户的一个常见趋势是询问以下形式的问题：“如何迭代我的df以执行X？”。展示调用iterrows()的代码，同时在for循环内部执行某些操作。这就是原因。对于尚未介绍向量化概念的库的新用户，可能会将解决其问题的代码想象为迭代其数据以执行某些操作。不知道如何迭代DataFrame，他们所做的第一件事就是谷歌并最终在这里，即此问题。然后，他们看到被接受的答案告诉他们如何做，他们闭上眼睛并运行此代码，而没有首先质疑是否迭代是正确的做法。
此答案旨在帮助新用户了解迭代不一定是每个问题的解决方案，并且更好、更快和更成语化的解决方案可能存在，并且值得投资时间进行探索。我不想发起迭代与向量化之争，但我希望新用户在开发使用此库解决其问题的解决方案时能够得到信息。
最后……一个TLDR来总结这篇文章。
zip(df['A'], df['B'])而不是df.iterrows()。 - Imperishable NightDataFrame.values将会把每一列转换为相同的数据类型。DataFrame.to_numpy()也是如此。幸运的是我们可以使用zip来处理任意数量的列。 - David Wassermanfor index, row in df.iterrows():
print(row["c1"], row["c2"])
for row in df.itertuples(index=True, name='Pandas'):
print(row.c1, row.c2)
itertuples() 比 iterrows() 应该更快。
但是请注意，根据文档（目前是 pandas 0.24.2）：
dtype 可能不匹配
因为 iterrows 对每一行返回一个 Series，它不会保留行之间的 dtype（对于 DataFrame，列之间的 dtype 会被保留）。为了在迭代行时保留 dtype，最好使用 itertuples()，它返回值的命名元组，并且通常比 iterrows() 快得多。
iterrows: 不要修改行
在迭代过程中，您绝对不应该修改正在迭代的内容。这并不保证在所有情况下都能正常工作。根据数据类型的不同，迭代器返回的是副本而不是视图，对其进行写入操作将不会产生任何效果。
new_df = df.apply(lambda x: x * 2, axis=1)
itertuples:
如果列名无效的Python标识符、重复或以下划线开头，它们将被重命名为位置名称。如果列数较多（>255），则返回常规元组。
for row in df[['c1','c2']].itertuples(index=True, name=None):，以在行迭代器中仅包括某些列。 - Brian Burnsrow.c1 代替 getattr(row, "c1")。 - viraptor你应该使用 df.iterrows()。虽然逐行迭代不是特别高效，因为需要创建Series对象。
虽然 iterrows() 是一个不错的选择，但有时候 itertuples() 可以更快：
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
for a,b,c in izip(df["a"],df["b"],df["c"]: 几乎同样快速。 - harbuniterrows()方法将数据的每一行包装成一个Series对象，而itertuples()方法则不会。 - miradulodf是从一个字典创建的，所以row[1]可能指任意一列。不过事实证明，整数列和浮点数列的时间大致相同。 - Brian Burnsdf.iloc函数：for i in range(0, len(df)):
print(df.iloc[i]['c1'], df.iloc[i]['c2'])
itertuples 会保留数据类型，但会删除任何不喜欢的名称。iterrows 则相反。 - Ken Williamsfor i in range(df.shape[0]) 可以稍微加快这种方法的速度，但对于我的应用程序来说，它仍然比上面的 iterrows() 方法慢了大约 3.5 倍。 - Kim Millermy_iter = df.itertuples()需要双倍的内存，并且复制它需要很长时间。对于iterrows()也是如此。 - Bastiaandf.apply()来迭代行并为一个函数访问多列。
docs: DataFrame.apply()
def valuation_formula(x, y):
return x * y * 0.5
df['price'] = df.apply(lambda row: valuation_formula(row['x'], row['y']), axis=1)
axis=1与axis='columns'是相同的，它用于将函数应用于每一行而不是每一列。如果未指定，默认行为是将函数应用于每一列。apply不会对行进行迭代，而是将函数逐行应用。如果您确实需要迭代和索引，例如在比较不同行的值时（在这种情况下，您只能进行迭代），则上面的代码将无法正常工作。 - gented如果你真的需要迭代一个Pandas数据框，你可能想要避免使用iterrows()。有不同的方法，通常的iterrows()远非最佳选择。itertuples()可以快100倍。
简而言之：
df.itertuples(name=None)。特别是当你有固定数量的列且少于255列时。 见点(3)df.itertuples()，除非你的列具有特殊字符，例如空格或'-'。 见点(2)itertuples()，使用最后一个示例。 见点(4)iterrows()。 见点(1)生成一个有一百万行和4列的随机数据框：
df = pd.DataFrame(np.random.randint(0, 100, size=(1000000, 4)), columns=list('ABCD'))
print(df)
1) 通常的iterrows()很方便，但是速度非常慢：
start_time = time.clock()
result = 0
for _, row in df.iterrows():
result += max(row['B'], row['C'])
total_elapsed_time = round(time.clock() - start_time, 2)
print("1. Iterrows done in {} seconds, result = {}".format(total_elapsed_time, result))
2) 默认的itertuples()已经快得多，但它不能处理列名重复或者列名不能简单转换为Python变量名的情况，比如 My Col-Name is very Strange（如果您的列是重复的或者有某些列名不能简单转换为Python变量名，您应该避免使用这种方法）。:
start_time = time.clock()
result = 0
for row in df.itertuples(index=False):
result += max(row.B, row.C)
total_elapsed_time = round(time.clock() - start_time, 2)
print("2. Named Itertuples done in {} seconds, result = {}".format(total_elapsed_time, result))
3) 默认的itertuples()使用name=None更快，但不太方便，因为您必须为每个列定义一个变量。
start_time = time.clock()
result = 0
for(_, col1, col2, col3, col4) in df.itertuples(name=None):
result += max(col2, col3)
total_elapsed_time = round(time.clock() - start_time, 2)
print("3. Itertuples done in {} seconds, result = {}".format(total_elapsed_time, result))
4) 最后，命名为itertuples()的方法比前面的方法慢，但是您不必为每列定义一个变量，并且它可以使用列名称，例如My Col-Name is very Strange。
start_time = time.clock()
result = 0
for row in df.itertuples(index=False):
result += max(row[df.columns.get_loc('B')], row[df.columns.get_loc('C')])
total_elapsed_time = round(time.clock() - start_time, 2)
print("4. Polyvalent Itertuples working even with special characters in the column name done in {} seconds, result = {}".format(total_elapsed_time, result))
输出：
A B C D
0 41 63 42 23
1 54 9 24 65
2 15 34 10 9
3 39 94 82 97
4 4 88 79 54
... .. .. .. ..
999995 48 27 4 25
999996 16 51 34 28
999997 1 39 61 14
999998 66 51 27 70
999999 51 53 47 99
[1000000 rows x 4 columns]
1. Iterrows done in 104.96 seconds, result = 66151519
2. Named Itertuples done in 1.26 seconds, result = 66151519
3. Itertuples done in 0.94 seconds, result = 66151519
4. Polyvalent Itertuples working even with special characters in the column name done in 2.94 seconds, result = 66151519
我正在寻找如何迭代行和列，最后来到了这里：
如下所示：
for i, row in df.iterrows():
for j, column in row.iteritems():
print(column)
我们有多种方法可以完成同样的任务，许多人分享了他们的答案。
我发现以下两种方法易于操作并且高效：
示例：
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)
注意：itertuples()应该比iterrows()更快。
pandas也是读取csv文件的首选。使用API来操作数据更加易于编程。 - F.S.