私はDataFrameパンダから来ました：

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

出力：

   c1   c2
0  10  100
1  11  110
2  12  120

次に、このフレームの行を反復処理します。すべての行について、列の名前でその要素（セルの値）にアクセスできるようにしたいと思います。例えば：

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

パンダでそれを行うことは可能ですか？

私はこの同様の質問を見つけました。しかし、それは私に必要な答えを与えません。たとえば、そこで使用することをお勧めします。

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

または

for row in df.iterrows():

しかし、私はrowオブジェクトが何であるか、そしてどうやってそれを扱うことができるのか分かりません。

DataFrame.iterrowsは、インデックスと行の両方を生成するジェネレーターです。

import pandas as pd
import numpy as np

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

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

Output: 
   10 100
   11 110
   12 120

パンダのデータフレームの行を反復する方法は？

回答：しないでください^*！

パンダでの反復はアンチパターンであり、他のすべてのオプションを使い果たしたときにのみ行うべきです。iter名前に「」が含まれる関数を数千行以上使用しないでください。そうしないと、多くの待機に慣れる必要があります。

DataFrameを印刷しますか？を使用しDataFrame.to_string()ます。

何かを計算しますか？その場合は、次の順序でメソッドを検索します（ここからリストを変更します）。

1. ベクトル化
2. Cythonルーチン
3. リスト内包表記（バニラforループ）
4. DataFrame.apply()：i）cythonで実行できる削減、ii）python空間での反復
5. DataFrame.itertuples() そして iteritems()
6. DataFrame.iterrows()

iterrowsそしてitertuples（この質問への回答に多くの票を受信の両方）は、実際にこれらの機能はするのに有用である唯一のもので順次処理のために行オブジェクト/ nametuplesを生成するような非常にまれな状況で使用されるべきです。

当局へのアピール反復
のドキュメントページには、次のような巨大な赤い警告ボックスがあります。

通常、パンダオブジェクトの反復処理は低速です。多くの場合、行を手動で反復する必要はありません[...]。

_{*実際には、「しない」よりも少し複雑です。df.iterrows()はこの質問に対する正しい答えですが、「opize your ops」の方が適しています。反復を回避できない状況があることを認めます（たとえば、結果が前の行に対して計算された値に依存する操作など）。ただし、いつライブラリを使用するかを理解するには、ある程度の知識が必要です。反復的な解決策が必要かどうかわからない場合は、おそらく必要ありません。PS：この回答を書く私の理論的根拠について詳しく知るには、一番下までスキップしてください。}

ループよりも高速：ベクトル化、Cython

多数の基本的な演算と計算は、パンダによって（NumPyまたはCythonized関数のいずれかによって）「ベクトル化」されます。これには、算術、比較、（ほとんどの）削減、再形成（ピボットなど）、結合、およびgroupby操作が含まれます。Essential Basic Functionalityのドキュメントを参照して、問題に適したベクトル化された方法を見つけてください。

存在しない場合は、カスタムcython拡張機能を使用して独自に作成してください。

次善の策：リスト内包表記^*

リスト内包表記は、1）利用可能なベクトル化されたソリューションがない場合、2）パフォーマンスは重要であるが、コードをCythonizeする面倒をたどるほど重要ではない場合、および3）要素ごとの変換を実行する場合、次の呼び出しポートにする必要があります。あなたのコードに。多くの一般的なパンダのタスクでは、リスト内包表記が十分に速い（場合によってはさらに速い）ことを示唆する十分な証拠があります。

式は単純ですが、

# 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を処理するときは、組み込みのパンダメソッドが存在する場合はそれらを優先するか（コーナーケース処理ロジックがはるかに優れているため）、またはビジネスロジックに適切なNaN処理ロジックが含まれていることを確認します。
2. 混合データ型を扱う場合、後者は暗黙的にデータを最も一般的な型にアップキャストするのではzip(df['A'], df['B'], ...)なく、反復する必要がありますdf[['A', 'B']].to_numpy()。例として、Aが数値でBが文字列の場合、to_numpy()は配列全体を文字列にキャストしますが、これは希望と異なる場合があります。幸いzip、列を一緒にpingすることが、これに対する最も簡単な回避策です。

_{* YMMVに概説さの理由のために警告を上記セクション。}

明白な例

2つのパンダ列を追加する簡単な例で違いを示しましょうA + B。これはベクトル化可能な操作であるため、前述の方法のパフォーマンスと簡単に対比できます。

参考のために、ベンチマークコード。

ただし、これが常に乾燥して乾燥しているとは限りません。「操作に最適な方法は何か」に対する答えは、「データに依存する」場合があります。私のアドバイスは、データを解決する前に、データに対するさまざまなアプローチをテストすることです。

参考文献

• パンダへの10分、および基本的な基本機能 -パンダとそのベクトル化* /シトノン化関数のライブラリを紹介する便利なリンク。

• パフォーマンスの向上 -標準パンダ操作の強化に関するドキュメントの入門書

• パンダのforループは本当に悪いのですか？いつ気にすべきですか？-リスト内包表記とさまざまな操作（主に非数値データが関係する操作）への適合性についての私による詳細な説明

• コードでパンダapply（）をいつ使用したいですか？- apply遅い（ただし、iter*家族ほど遅くない。ただしapply、特に一部のGroupBy操作では、深刻な代替案として検討できる（または検討すべき）状況がある）。

_{* Pandas文字列メソッドは、シリーズで指定されているが各要素で動作するという意味で「ベクトル化」されています。文字列操作は本質的にベクトル化が難しいため、基礎となるメカニズムは依然として反復的です。}

なぜこの答えを書いたのか

私が新しいユーザーから気づく一般的な傾向は、「どのようにしてdfを反復してXを実行できるか？」という形式の質問をすることです。iterrows()forループ内で何かを実行中に呼び出すコードを示しています。これが理由です。ベクトル化の概念を紹介されていないライブラリの新しいユーザーは、データを繰り返し処理して何かを行うときに問題を解決するコードを想定している可能性があります。DataFrameを反復する方法がわからないため、彼らが最初に行うことは、それをGoogleにして、この質問でここに到達することです。次に、受け入れられた回答を見て方法を伝え、反復を行うことが適切でないかどうかを最初に確認することなく、目を閉じてこのコードを実行します。

この回答の目的は、反復が必ずしもすべての問題の解決策であるとは限らず、より優れた、より速く、より慣用的な解決策が存在する可能性があること、およびそれらを探索することに時間を費やす価値があることを新しいユーザーが理解できるようにすることです。私はイテレーションとベクトル化の戦争を始めようとはしていませんが、このライブラリーに関する問題の解決策を開発するときに、新しいユーザーに知らせたいと思います。

あなたが本当にする必要があるかどうか最初に検討してください 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()

ただし、ドキュメントによれば（現時点ではパンダ0.24.2）、注意してください。

• iterrows：dtype行ごとに一致しない可能性があります

  iterrowsは各行のSeriesを返すため、行全体のdtypeは保持されません（dtypeはデータフレームの列全体で保持されます）。行を反復するときにdtypeを保持するには、値の名前付きタプルを返し、一般にiterrows（）よりも高速なitertuples（）を使用することをお勧めします。

• iterrows：行を変更しないでください

  反復しているものを変更してはいけません。これは、すべての場合で機能するとは限りません。データ型に応じて、イテレータはビューではなくコピーを返し、そこへの書き込みは効果がありません。

  代わりにDataFrame.apply（）を使用してください：

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

• イタプル：

  列名は、それらが無効なPython識別子であるか、繰り返されるか、アンダースコアで始まる場合、位置名に名前変更されます。列数が多い（> 255）と、通常のタプルが返されます。

詳細については、繰り返しに関するパンダのドキュメントを参照してください。

使用する必要があります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

あなたも使うことができます 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)

次のようにdf.iloc関数を使用できます。

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

行と列を反復する方法を探していて、ここで終了しました：

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

実装する独自のイテレータを書くことができます 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);

効率的に反復する方法は？

pandasデータフレームを本当に反復する必要がある場合は、おそらくiterrows（）の使用を避けたいでしょう。さまざまな方法があり、通常の方法iterrows()が最善とはほど遠い。itertuples（）は100倍高速にできます。

要するに：

• 原則として、を使用してくださいdf.itertuples(name=None)。特に、固定数の列があり、255列未満の場合。ポイント（3）を参照
• それdf.itertuples()以外の場合は、列にスペースや '-'などの特殊文字がある場合を除き、使用してください。ポイント（2）を参照
• itertuples()最後の例を使用すると、データフレームに奇妙な列がある場合でも使用できます。ポイント（4）を参照
• iterrows()以前のソリューションを使用できない場合にのみ使用してください。ポイント（1）を参照

パンダデータフレームの行を反復処理するさまざまな方法：

100万行、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）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）最後に、named 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の非常に興味深い比較です

のすべての行をループするには、dataframe次を使用できます。

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

 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}

ループへのすべての行dataframeと利用各行の値が便利、namedtuplesに変換することができるndarrayS。例えば：

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、インデックスはタプルの最初の要素として追加されます。これは、一部のアプリケーションでは望ましくない場合があります。

シリーズではなく、DataFrameを取得するときに、throw行を反復する方法があります。DataFrameとして返される行のリストとしてインデックスを渡すことができると言及している人はいないでしょう。

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

二重括弧の使用に注意してください。これは、単一行のDataFrameを返します。

値の表示と変更の両方に、を使用しますiterrows()。forループでタプルのアンパック（例を参照i, row）を使用しrowて、値を表示するためだけにforを使用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を変更することはありません。ただし、DataFrameを使用iしlocて指定し、作業を行うことができます。

応答パーティに遅れていることはわかっていますが、@ cs95の回答に追加したかっただけです。彼の回答では、パンダのベクトル化が、データフレームを使ってデータを計算する他のパンダの方法よりもはるかに優れていることを示しています。

最初にデータフレームを派手な配列に変換してからベクトル化を使用すると、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]

また、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

パンダのデータフレームの行を反復する方法はたくさんあります。非常にシンプルで直感的な方法の1つは次のとおりです。

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]])

この例では、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])

一部のライブラリ（たとえば、私が使用するJava相互運用ライブラリ）では、データをストリーミングする場合など、値を一度に1行ずつ渡す必要があります。ストリーミングの性質を再現するために、データフレーム値を1つずつ「ストリーミング」します。以下のように記述しました。これは時々役に立ちます。

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を使用するよりも明らかに遅いですが、状況によっては必要です。

要するに

• 可能であればベクトル化を使用する
• 操作をベクトル化できない場合-リスト内包表記を使用
• 行全体を表す単一のオブジェクトが必要な場合-itertuplesを使用します
• 上記が遅すぎる場合-swifter.applyを試してください
• それでも遅すぎる場合-Cythonルーチンを試してください

詳細 このビデオの

基準