有些库（例如我使用的Java互操作库）要求一次在一行中传递值，例如，如果是流数据。为了复制流式传输的特性，我将数据帧值逐一“流式传输”，我写了以下内容，这些内容不时会派上用场。

class DataFrameReader:
  def __init__(self, df):
    self._df = df
    self._row = None
    self._columns = df.columns.tolist()
    self.reset()
    self.row_index = 0

  def __getattr__(self, key):
    return self.__getitem__(key)

  def read(self) -> bool:
    self._row = next(self._iterator, None)
    self.row_index += 1
    return self._row is not None

  def columns(self):
    return self._columns

  def reset(self) -> None:
    self._iterator = self._df.itertuples()

  def get_index(self):
    return self._row[0]

  def index(self):
    return self._row[0]

  def to_dict(self, columns: List[str] = None):
    return self.row(columns=columns)

  def tolist(self, cols) -> List[object]:
    return [self.__getitem__(c) for c in cols]

  def row(self, columns: List[str] = None) -> Dict[str, object]:
    cols = set(self._columns if columns is None else columns)
    return {c : self.__getitem__(c) for c in self._columns if c in cols}

  def __getitem__(self, key) -> object:
    # the df index of the row is at index 0
    try:
        if type(key) is list:
            ix = [self._columns.index(key) + 1 for k in key]
        else:
            ix = self._columns.index(key) + 1
        return self._row[ix]
    except BaseException as e:
        return None

  def __next__(self) -> 'DataFrameReader':
    if self.read():
        return self
    else:
        raise StopIteration

  def __iter__(self) -> 'DataFrameReader':
    return self

可用于：

for row in DataFrameReader(df):
  print(row.my_column_name)
  print(row.to_dict())
  print(row['my_column_name'])
  print(row.tolist())

并保留正在迭代的行的值/名称映射。显然，它比上面提到的使用apply和Cython慢得多，但在某些情况下是必要的。

您还可以使用df.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)

免责声明：尽管这里有很多答案建议不要使用迭代（循环）方法（我基本同意），但我仍然认为这是一种适用于以下情况的合理方法：

使用API中的数据扩展数据帧

假设您有一个包含不完整用户数据的大型数据帧。现在，您必须使用其他列来扩展此数据，例如，用户的年龄和性别。

这两个值都必须从后端API获取。我假设API不提供“批处理”端点（一次接受多个用户ID）。否则，您应该只调用一次API。

网络请求的成本（等待时间）远远超过了数据帧的迭代。我们讨论的是数百毫秒的网络往返时间，相比之下，使用迭代的替代方法可以忽略不计的小增益。

每行一个昂贵的网络请求

所以在这种情况下，我绝对倾向于使用迭代方法。尽管网络请求很昂贵，但可以保证对数据帧中的每一行只触发一次。以下是使用DataFrame.iterrows的示例：

实例

for index, row in users_df.iterrows():
  user_id = row['user_id']

  # Trigger expensive network request once for each row
  response_dict = backend_api.get(f'/api/user-data/{user_id}')

  # Extend dataframe with multiple data from response
  users_df.at[index, 'age'] = response_dict.get('age')
  users_df.at[index, 'gender'] = response_dict.get('gender')

 for ind in df.index:
     print df['c1'][ind], df['c2'][ind]

有时，有用的模式是：

# 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}

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

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