有些库（例如我使用的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慢得多，但在某些情况下是必要的。

更新：cs95更新了他的答案，包括简单的numpy矢量化。你可以简单地参考他的答案。

cs95表明，Pandas矢量化在使用数据帧计算数据方面远远优于其他Pandas方法。

我想补充一点，如果您首先将数据帧转换为NumPy数组，然后使用矢量化，它甚至比Pandas数据帧矢量化更快（这包括将其转换回数据帧序列的时间）。

如果您将以下函数添加到cs95的基准代码中，这将变得非常明显：

def np_vectorization(df):
    np_arr = df.to_numpy()
    return pd.Series(np_arr[:,0] + np_arr[:,1], index=df.index)

def just_np_vectorization(df):
    np_arr = df.to_numpy()
    return np_arr[:,0] + np_arr[:,1]

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

虽然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

首先考虑是否真的需要迭代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迭代文档。

对于查看和修改值，我将使用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来完成这项工作。