如何在 Pandas 中迭代 DataFrame 中的行

Question

我有一個 pandas dataframe， df ：

   c1   c2
0  10  100
1  11  110
2  12  120

如何迭代此 dataframe 的行？ 對於每一行，我希望能夠通過列名訪問其元素（單元格中的值）。 例如：

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

---

我發現了一個類似的問題，建議使用以下任何一種：

for date, row in df.T.iteritems():

for row in df.iterrows():

但我不明白 object row是什么以及如何使用它。

Answer 1

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

Answer 2

如何在 Pandas 中遍歷 DataFrame 中的行？

答案：不要^* ！

Pandas 中的迭代是一種反模式，只有在用盡所有其他選項時才應該這樣做。 您不應該使用名稱中帶有“ iter ”的任何函數超過幾千行，否則您將不得不習慣大量等待。

你想打印一個DataFrame嗎？ 使用DataFrame.to_string() 。

你想計算一些東西嗎？ 在這種情況下，按此順序搜索方法（從此處修改的列表）：

1. 矢量化
2. Cython例程
3. 列表理解（vanilla for循環）
4. DataFrame.apply() ：i）可以在 Cython 中執行的縮減，ii）Python 空間中的迭代
5. DataFrame.itertuples()和iteritems()
6. DataFrame.iterrows()

iterrows和itertuples （在這個問題的答案中都獲得了很多投票）應該在非常罕見的情況下使用，例如為順序處理生成行對象/nametuples，這實際上是這些函數唯一有用的東西。

向當局上訴

迭代的文檔頁面有一個巨大的紅色警告框，上面寫着：

遍歷 pandas 對象通常很慢。 在許多情況下，不需要手動迭代行 [...]。

_{* 它實際上比“不要”要復雜一些。 df.iterrows()是這個問題的正確答案，但“矢量化你的操作”是更好的答案。 我承認在某些情況下無法避免迭代（例如，某些操作的結果取決於為前一行計算的值）。 但是，需要對庫有一定的了解才能知道何時。 如果您不確定是否需要迭代解決方案，您可能不需要。 PS：要了解更多關於我寫這個答案的理由，請跳到最底部。}

---

比循環更快： 矢量化， Cython

大量的基本操作和計算由 pandas“矢量化”（通過 NumPy 或通過 Cythonized 函數）。 這包括算術、比較、（大多數）歸約、重塑（例如旋轉）、連接和 groupby 操作。 查看有關基本基本功能的文檔，為您的問題找到合適的矢量化方法。

如果不存在，請隨意使用自定義Cython 擴展編寫自己的。

---

下一個最好的事情： 列出理解^*

如果 1) 沒有可用的矢量化解決方案，列表推導應該是您的下一個停靠點，2) 性能很重要，但還不足以解決對代碼進行 cythonizing 的麻煩，以及 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'])]

如果您可以將業務邏輯封裝到函數中，則可以使用調用它的列表推導。 您可以通過原始 Python 代碼的簡單性和速度使任意復雜的事情工作。

注意事項

列表推導假設您的數據易於使用 - 這意味着您的數據類型是一致的並且您沒有 NaN，但這並不總是得到保證。

1. 第一個更明顯，但是在處理 NaN 時，如果存在內置的 pandas 方法（因為它們具有更好的極端情況處理邏輯），則更喜歡它們，或者確保您的業務邏輯包含適當的 NaN 處理邏輯。
2. 在處理混合數據類型時，您應該迭代zip(df['A'], df['B'], ...)而不是df[['A', 'B']].to_numpy()作為后者隱式地將數據向上轉換為最常見的類型。 例如，如果 A 是數字而 B 是字符串， to_numpy()會將整個數組轉換為字符串，這可能不是您想要的。 幸運的是，將您的列zip在一起是最直接的解決方法。

_{*您的里程可能會因上述注意事項部分中列出的原因而有所不同。}

---

一個明顯的例子

讓我們通過添加兩個 pandas 列A + B的簡單示例來演示差異。 這是一個可向量化的操作，因此很容易對比上述方法的性能。

基准代碼，供您參考。 底部的行測量了一個用 numpandas 編寫的函數，這是一種與 NumPy 大量混合以擠出最大性能的 Pandas 風格。 除非您知道自己在做什么，否則應避免編寫 numpandas 代碼。 盡可能堅持使用 API（即，更喜歡vec而不是vec_numpy ）。

然而，我應該提一下，它並不總是這么干脆利落的。 有時，“什么是最佳操作方法”的答案是“這取決於您的數據”。 我的建議是在確定一種方法之前對您的數據測試不同的方法。

---

我的個人意見^*

對 iter 系列的各種替代方案進行的大多數分析都是從性能的角度進行的。 但是，在大多數情況下，您通常會處理大小合理的數據集（不超過幾千或 100K 行），性能將僅次於解決方案的簡單性/可讀性。

這是我在選擇用於解決問題的方法時的個人偏好。

對於新手：

矢量化（如果可能） ； apply() ； 列出理解； itertuples() / iteritems() ; iterrows() ; 賽通

對於更有經驗的人：

矢量化（如果可能） ； apply() ； 列出理解； 賽通； itertuples() / iteritems() ; iterrows()

對於可以向量化的任何問題，向量化是最慣用的方法。 始終尋求矢量化！ 如有疑問，請查閱文檔，或在 Stack Overflow 上查看有關您的特定任務的現有問題。

在我的很多帖子中，我確實傾向於繼續談論apply有多糟糕，但我確實承認，初學者更容易理解它在做什么。 此外，在我的這篇文章中解釋了很多apply的用例。

Cython 在列表中排名較低，因為它需要更多的時間和精力才能正確完成。 您通常永遠不需要使用 pandas 編寫需要這種性能水平的代碼，即使是列表推導也無法滿足。

_{*與任何個人意見一樣，請多加鹽！}

---

延伸閱讀

• 10 分鍾了解 pandas和基本基本功能- 向您介紹 Pandas 及其矢量化*/cythonized 函數庫的有用鏈接。

• 增強性能- 增強標准 Pandas 操作的文檔入門

• pandas 中的 for 循環真的很糟糕嗎？ 我什么時候應該關心？ - 我對列表理解及其對各種操作的適用性（主要是涉及非數字數據的操作）的詳細說明

• 我什么時候應該（不）想在我的代碼中使用 pandas apply()？ - apply很慢（但不像iter*系列那么慢。但是，在某些情況下可以（或應該）考慮apply作為一種重要的替代方案，尤其是在某些GroupBy操作中）。

_{* Pandas 字符串方法是“矢量化的”，因為它們是在系列上指定的，但對每個元素都進行操作。 底層機制仍然是迭代的，因為字符串操作本質上很難向量化。}

---

為什么我寫這個答案

我從新用戶那里注意到的一個常見趨勢是提出“如何迭代我的 df 以執行 X？”形式的問題。 顯示在for循環中執行某些操作時調用iterrows()的代碼。 這就是為什么。 一個沒有被引入向量化概念的庫的新用戶可能會將解決他們問題的代碼設想為迭代他們的數據來做某事。 不知道如何迭代 DataFrame，他們做的第一件事就是用谷歌搜索它，然后在這個問題上結束。 然后，他們看到接受的答案告訴他們如何去做，然后他們閉上眼睛運行這段代碼，而不會首先質疑迭代是否是正確的做法。

這個答案的目的是幫助新用戶理解迭代不一定是所有問題的解決方案，並且可能存在更好、更快和更慣用的解決方案，值得花時間去探索它們。 我並不是要開始一場迭代與矢量化的戰爭，但我希望新用戶在為他們的這個庫的問題開發解決方案時被告知。

Answer 3

首先考慮是否真的需要遍歷DataFrame 中的行。 有關替代方案，請參見此答案。

如果您仍然需要遍歷行，可以使用下面的方法。 請注意一些其他答案中未提及的重要警告。

• DataFrame.iterrows()

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

• DataFrame.itertuples()

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

itertuples()應該比iterrows()快

但請注意，根據文檔（目前為 pandas 0.24.2）：

• iterrows： dtype可能與行不匹配

因為 iterrows 為每一行返回一個 Series，所以它不會跨行保留dtypes（dtypes 在 DataFrames 的列中保留）。 要在遍歷行時保留 dtypes，最好使用 itertuples()，它返回值的命名元組，通常比 iterrows() 快得多

• iterrows：不修改行

你永遠不應該修改你正在迭代的東西。 這不能保證在所有情況下都有效。 根據數據類型，迭代器返回一個副本而不是一個視圖，寫入它不會有任何效果。

改用DataFrame.apply() ：

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

• 迭代：

如果列名是無效的 Python 標識符、重復或以下划線開頭，它們將被重命名為位置名稱。 對於大量列 (>255)，將返回常規元組。

有關更多詳細信息，請參閱關於迭代的 pandas 文檔。

Answer 4

您應該使用df.iterrows() 。 盡管逐行迭代並不是特別有效，因為必須創建Series對象。

Answer 5

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

Answer 6

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

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

Answer 7

您還可以使用df.apply()遍歷行並訪問函數的多個列。

文檔：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)

Answer 8

如何高效迭代

如果您真的必須迭代 Pandas 數據框，您可能希望避免使用 iterrows() 。 有不同的方法，通常的iterrows()遠不是最好的。 itertuples() 可以快 100 倍。

簡而言之：

• 作為一般規則，使用df.itertuples(name=None) 。 特別是當您有固定數量的列且少於 255 列時。 見第 (3) 點
• 否則，請使用df.itertuples() ，除非您的列有特殊字符，例如空格或“-”。 見點（2）
• 通過使用最后一個示例，即使您的數據框有奇怪的列，也可以使用itertuples() 。 見第 (4) 點
• 如果您不能使用以前的解決方案，請僅使用iterrows() 。 見點（1）

遍歷 Pandas 數據框中的行的不同方法：

生成具有一百萬行和 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()已經快得多了，但是它不適用於列名，例如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) 使用 name=None 的默認itertuples()更快，但不是很方便，因為您必須為每列定義一個變量。

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

這篇文章是 iterrows 和 itertuples 之間的一個非常有趣的比較

Answer 9

我一直在尋找如何迭代行和列並在這里結束：

for i, row in df.iterrows():
    for j, column in row.iteritems():
        print(column)

Answer 10

您可以編寫自己的實現namedtuple的迭代器

from collections import namedtuple

def myiter(d, cols=None):
    if cols is None:
        v = d.values.tolist()
        cols = d.columns.values.tolist()
    else:
        j = [d.columns.get_loc(c) for c in cols]
        v = d.values[:, j].tolist()

    n = namedtuple('MyTuple', cols)

    for line in iter(v):
        yield n(*line)

這與pd.DataFrame.itertuples直接相當。 我的目標是更高效地執行相同的任務。

---

對於具有我的功能的給定數據框：

list(myiter(df))

[MyTuple(c1=10, c2=100), MyTuple(c1=11, c2=110), MyTuple(c1=12, c2=120)]

或使用pd.DataFrame.itertuples ：

list(df.itertuples(index=False))

[Pandas(c1=10, c2=100), Pandas(c1=11, c2=110), Pandas(c1=12, c2=120)]

---

全面的測試
我們測試使所有列可用並對列進行子集化。

def iterfullA(d):
    return list(myiter(d))

def iterfullB(d):
    return list(d.itertuples(index=False))

def itersubA(d):
    return list(myiter(d, ['col3', 'col4', 'col5', 'col6', 'col7']))

def itersubB(d):
    return list(d[['col3', 'col4', 'col5', 'col6', 'col7']].itertuples(index=False))

res = pd.DataFrame(
    index=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
    columns='iterfullA iterfullB itersubA itersubB'.split(),
    dtype=float
)

for i in res.index:
    d = pd.DataFrame(np.random.randint(10, size=(i, 10))).add_prefix('col')
    for j in res.columns:
        stmt = '{}(d)'.format(j)
        setp = 'from __main__ import d, {}'.format(j)
        res.at[i, j] = timeit(stmt, setp, number=100)

res.groupby(res.columns.str[4:-1], axis=1).plot(loglog=True);

Answer 11

要循環dataframe的所有行，您可以使用：

for x in range(len(date_example.index)):
    print date_example['Date'].iloc[x]

Answer 12

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

Answer 13

我們有多種選擇來做同樣的事情，很多人都分享了他們的答案。

我發現以下兩種方法既簡單又有效：

1. DataFrame.iterrows()
2. 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 iterrows method 

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

 #With itertuples method

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

注意： itertuples() 應該比 iterrows() 快

Answer 14

有時有用的模式是：

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

Answer 15

更新：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]

Answer 16

簡而言之

• 盡可能使用矢量化
• 如果一個操作不能向量化 - 使用列表推導
• 如果您需要代表整行的單個對象 - 使用 itertuples
• 如果上述速度太慢 - 嘗試swifter.apply
• 如果它仍然太慢 - 嘗試Cython例程

基准

Answer 17

為了循環數據namedtuples的所有行並方便地使用每行的值，可以將dataframe轉換為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 ，則將索引添加為 tuple 的第一個元素，這對於某些應用程序可能是不可取的。

Answer 18

有一種方法可以在獲取 DataFrame 而不是 Series 的同時迭代 throw 行。 我沒有看到有人提到您可以將索引作為列表傳遞給要作為 DataFrame 返回的行：

for i in range(len(df)):
    row = df.iloc[[i]]

注意雙括號的使用。 這將返回具有單行的 DataFrame。

Answer 19

對於查看和修改值，我會使用iterrows() 。 在 for 循環中並通過使用元組解包（參見示例： i, row ），我使用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'  

這里循環中的row是該行的副本，而不是它的視圖。 因此，你不應該寫類似row['A'] = 'New_Value' ，它不會修改 DataFrame。 但是，您可以使用i和loc並指定 DataFrame 來完成這項工作。

Answer 20

有很多方法可以遍歷 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]])

Answer 21

最簡單的方法，使用apply函數

def print_row(row):
   print row['c1'], row['c2']

df.apply(lambda row: print_row(row), axis=1)

Answer 22

正如這里的許多答案正確而清楚地指出的那樣，您通常不應該嘗試在 Pandas 中循環，而應該編寫矢量化代碼。 但是問題仍然存在，您是否應該在 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]

而且這段代碼實際上比矢量化代碼更快。 在一些 100,000 行的快速測試中，上述方法比groupby方法快 10 倍左右。 請注意，速度的一鍵是numba，這是可選的。 如果沒有“@nb.jit”行，循環代碼實際上比groupby方法慢 10 倍。

很明顯，這個例子很簡單，你可能更喜歡用 pandas 的一行來編寫一個帶有相關開銷的循環。 然而，這個問題有更復雜的版本，NumPy/numba 循環方法的可讀性或速度可能是有意義的。

Answer 23

df.iterrows()返回tuple(a, b)其中a是index ， b是row 。

Answer 24

您還可以執行 NumPy 索引以獲得更大的速度提升。 它並不是真正的迭代，但對於某些應用程序來說比迭代好得多。

subset = row['c1'][0:5]
all = row['c1'][:]

您可能還想將其轉換為數組。 這些索引/選擇應該已經像 NumPy 數組一樣，但是我遇到了問題並且需要強制轉換

np.asarray(all)
imgs[:] = cv2.resize(imgs[:], (224,224) ) # Resize every image in an hdf5 file

Answer 25

免責聲明：雖然這里有很多答案建議不要使用迭代（循環）方法（我大多同意），但對於以下情況，我仍然認為它是一種合理的方法：

使用來自 API 的數據擴展數據框

假設您有一個包含不完整用戶數據的大型數據框。 現在您必須使用其他列擴展此數據，例如用戶的age和gender 。

這兩個值都必須從后端 API 中獲取。 我假設 API 不提供“批處理”端點（可以一次接受多個用戶 ID）。 否則，您應該只調用一次 API。

網絡請求的成本（等待時間）遠遠超過了數據幀的迭代。 我們談論的是數百毫秒的網絡往返時間，而使用替代迭代方法的收益微不足道。

每行 1 個昂貴的網絡請求

所以在這種情況下，我絕對更喜歡使用迭代方法。 盡管網絡請求很昂貴，但可以保證數據幀中的每一行只觸發一次。 這是使用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')

Answer 26

此示例使用 iloc 隔離數據幀中的每個數字。

import pandas as pd

 a = [1, 2, 3, 4]
 b = [5, 6, 7, 8]

 mjr = pd.DataFrame({'a':a, 'b':b})

 size = mjr.shape

 for i in range(size[0]):
     for j in range(size[1]):
         print(mjr.iloc[i, j])

Answer 27

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

Answer 28

除了這篇文章中的好答案，我將提出分而治之的方法，我寫這個答案並不是為了廢除其他好的答案，而是用另一種對我有效的方法來實現它們。 它有splitting和merging pandas 數據框的兩個步驟：

分而治之的優點：

• 您不需要使用矢量化或任何其他方法將數據框的類型轉換為另一種類型
• 你不需要 Cythonize 你的代碼，這通常需要你額外的時間
• 在我的情況下， iterrows()和itertuples()在整個數據幀上都具有相同的性能
• 取決於您選擇的切片index ，您將能夠以指數方式加快迭代。 index越高，迭代過程越快。

分而治之的缺點：

• 您不應該依賴於相同數據幀和不同slice的迭代過程。 這意味着如果您想從其他slice讀取或寫入，可能很難做到這一點。

=================== 分而治之=================

第 1 步：分割/切片

在這一步中，我們將在整個數據幀上划分迭代。 認為您要將 csv 文件讀入 pandas df 然后對其進行迭代。 在可能的情況下，我有 5,000,000 條記錄，我將把它分成 100,000 條記錄。

注意：我需要重申本頁其他解決方案中解釋的其他運行時分析，“記錄數”在 df 上搜索時具有“運行時”的指數比例。 根據我的數據的基准，這里是結果：

Number of records | Iteration per second
========================================
100,000           | 500 it/s
500,000           | 200 it/s
1,000,000         | 50 it/s
5,000,000         | 20 it/s

第 2 步：合並

這將是一個簡單的步驟，只需將所有寫入的 csv 文件合並到一個數據幀中，然后將其寫入一個更大的 csv 文件。

這是示例代碼：

# Step 1 (Splitting/Slicing)
import pandas as pd
df_all = pd.read_csv('C:/KtV.csv')
df_index = 100000
df_len = len(df)
for i in range(df_len // df_index + 1):
    lower_bound = i * df_index 
    higher_bound = min(lower_bound + df_index, df_len)
    # splitting/slicing df (make sure to copy() otherwise it will be a view
    df = df_all[lower_bound:higher_bound].copy()
    '''
    write your iteration over the sliced df here
    using iterrows() or intertuples() or ...
    '''
    # writing into csv files
    df.to_csv('C:/KtV_prep_'+str(i)+'.csv')



# Step 2 (Merging)
filename='C:/KtV_prep_'
df = (pd.read_csv(f) for f in [filename+str(i)+'.csv' for i in range(ktv_len // ktv_index + 1)])
df_prep_all = pd.concat(df)
df_prep_all.to_csv('C:/KtV_prep_all.csv')

參考：

對數據幀進行迭代的有效方法

將 csv 文件連接成一個 Pandas 數據框

Answer 29

正如公認的答案所述，在行上應用函數的最快方法是使用向量化函數，即所謂的 NumPy ufuncs （通用函數）。

但是當你想要應用的功能還沒有在 NumPy 中實現時你應該怎么做呢？

好吧，使用來自numba的vectorize裝飾器，您可以像這樣輕松地直接在 Python 中創建 ufunc：

from numba import vectorize, float64

@vectorize([float64(float64)])
def f(x):
    #x is your line, do something with it, and return a float

這個函數的文檔在這里： 創建 NumPy 通用函數

Answer 30

可能是最優雅的解決方案（但肯定不是最有效的）：

for row in df.values:
    c2 = row[1]
    print(row)
    # ...

for c1, c2 in df.values:
    # ...

注意：

• 文檔明確建議改用.to_numpy()
• 生成的 NumPy 數組將具有適合所有列的 dtype，在最壞的情況下是object
• 首先有充分的理由不使用循環

盡管如此，我認為這個選項應該包括在這里，作為一個（人們應該認為的）微不足道的問題的直接解決方案。

Answer 31

使用df.iloc[] 。 例如，使用數據框“rows_df”：

或者

要從特定行獲取值，您可以將數據框轉換為 ndarray。

然后像這樣選擇行和列值：

Answer 32

更好的方法是使用zip將數據幀轉換為字典，創建鍵值對，然后通過鍵訪問行值。

我的回答顯示了如何使用字典作為 Pandas 的替代品。 有些人認為字典和元組更有效。 您可以輕松地將字典替換為命名元組列表。

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

 for row in inp:
     for (k, v) in zip(row.keys(), row.values()):
         print(k, v)

輸出：

c1 10
c2 100
c1 11
c2 110
c1 12
c2 120