blocks|key|293110|text|您应该使用df.iterrows()。虽然逐行迭代并不是特别有效，因为必须创建Series对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|293111|entityMap|0|LINK|mutability|MUTABLE|url|http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.iterrows.html^0|5|D|13|6|5|D|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

You should use <a href="http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.iterrows.html" rel="noreferrer"><code>df.iterrows()</code></a>. Though iterating row-by-row is not especially efficient since <code>Series</code> objects have to be created.

blocks|key|294102|text|DataFrame.iterrows是一个生成器，它同时生成索引和行(作为一个系列)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|294103|import+pandas+as+pd

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

for+index,+row+in+df.iterrows():
++++print(row['c1'],+row['c2'])|code-block|syntax|javascript|294104|10+100
11+110
12+120|294105|entityMap|0|LINK|mutability|MUTABLE|url|https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iterrows.html#pandas-dataframe-iterrows^0|0|I|0|I|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

<a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iterrows.html#pandas-dataframe-iterrows" rel="noreferrer"><code>DataFrame.iterrows</code></a> is a generator which yields both the index and row (as a Series):
<pre><code>import pandas as pd

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

for index, row in df.iterrows():
 print(row['c1'], row['c2'])
</code></pre>

<pre><code>10 100
11 110
12 120
</code></pre>

blocks|key|294119|text|您还可以使用df.apply()来迭代一个函数的行和访问多个列。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|294120|docs:+DataFrame.apply()|294121|def+valuation_formula(x,+y):
++++return+x+*+y+*+0.5

df['price']+=+df.apply(lambda+row:+valuation_formula(row['x'],+row['y']),+axis=1)|code-block|syntax|javascript|294122|entityMap|0|LINK|mutability|MUTABLE|url|http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.apply.html^0|6|A|0|0|N|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

You can also use <code>df.apply()</code> to iterate over rows and access multiple columns for a function.

<a href="http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.apply.html">docs: DataFrame.apply()</a>

<pre><code>def valuation_formula(x, y):
 return x * y * 0.5

df['price'] = df.apply(lambda row: valuation_formula(row['x'], row['y']), axis=1)
</code></pre>

blocks|key|1434180|text|虽然iterrows()是一个很好的选择，但有时itertuples()可能要快得多：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1434181|df+=+pd.DataFrame({'a':+randn(1000),+'b':+randn(1000),'N':+randint(100,+1000,+(1000)),+'x':+'x'})

%25timeit+[row.a+*+2+for+idx,+row+in+df.iterrows()]
#+=>+10+loops,+best+of+3:+50.3+ms+per+loop

%25timeit+[row[1]+*+2+for+row+in+df.itertuples()]
#+=>+1000+loops,+best+of+3:+541+µs+per+loop|code-block|syntax|javascript|1434182|entityMap^0|2|A|O|C|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

While <code>iterrows()</code> is a good option, sometimes <code>itertuples()</code> can be much faster:

<pre><code>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()]
# =&gt; 10 loops, best of 3: 50.3 ms per loop

%timeit [row[1] * 2 for row in df.itertuples()]
# =&gt; 1000 loops, best of 3: 541 µs per loop
</code></pre>

blocks|key|3347586|text|您可以按如下方式使用df.iloc函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3347587|for+i+in+range(0,+len(df)):
++++print+df.iloc[i]['c1'],+df.iloc[i]['c2']|code-block|syntax|javascript|3347588|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use the df.iloc function as follows:

<pre><code>for i in range(0, len(df)):
 print df.iloc[i]['c1'], df.iloc[i]['c2']
</code></pre>

blocks|key|1222396|text|首先，考虑是否确实需要遍历DataFrame中的行。有关替代方案，请参见this+answer。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1222397|如果你仍然需要遍历行，你可以使用下面的方法。请注意中的一些重要注意事项，它们在任何其他答案中都没有提到。|style|BOLD|1222398|1222399|DataFrame.iterrows()|unordered-list-item|1222400|1222401|对于索引，df.iterrows()中的行:print(行“c1”，行“c2”)|1222402|1222403|DataFrame.itertuples()|1222404|1222405|对于df.itertuples(index=True，name=‘Pandas’)中的行:+print(row.c1，row.c2)|1222406|itertuples()应该比iterrows()快|CODE|1222407|但请注意，根据文档(目前为熊猫0.24.2+)：|1222408|1222409|+dtype：行与行之间的|1222410|可能不匹配|1222411|1222412|因为iterrows为每一行返回一个序列，所以它不跨行保留数据类型(对于DataFrames，跨列保留数据类型)。要在迭代行时保留数据类型，最好使用itertuples()，它返回值的命名元组，并且通常比iterrows()快得多|blockquote|1222413|1222414|1222415|1222416|iterrows:+Do+not+modify+rows|1222417|1222418|你不应该修改你正在迭代的东西，|1222419|+。这并不能保证在所有情况下都能工作。根据数据类型的不同，迭代器返回的是副本而不是视图，写入该副本将没有任何效果。|1222420|1222421|1222422|请改用DataFrame.apply()：|1222423|++++new_df+=+df.apply(lambda+x:+x+*+2)|code-block|syntax|javascript|1222424|1222425|itertuples:|1222426|1222427|如果|1222428|标识符无效、重复或以下划线开头，则列名称将重命名为位置名称。对于大量的列(>255)，将返回常规元组。|1222429|1222430|1222431|有关更多详细信息，请参阅pandas+docs+on+iteration。|1222432|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/55557758/3844376|1|http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.iterrows.html|2|http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.itertuples.html|3|http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.apply.html|4|https://pandas.pydata.org/docs/user_guide/basics.html#iteration^0|10|B|0|0|T|N|0|0|0|K|0|K|1|0|0|0|14|0|0|0|M|0|M|2|0|0|0|1U|0|0|Q|0|C|F|A|0|0|O|0|0|1|C|1|5|0|0|5|0|0|0|37|0|0|0|0|0|S|0|0|0|F|0|1|1K|0|0|0|0|L|3|H|3|0|0|0|0|B|0|0|0|2|0|0|1F|0|0|0|0|11|C|O|4|0^^$0|@$1|2|3|4|5|6|7|2J|8|@]|9|@$A|2K|B|2L|1|2M]]|C|$]]|$1|D|3|E|5|6|7|2N|8|@$A|2O|B|2P|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|2Q|8|@]|9|@]|C|$]]|$1|I|3|J|5|K|7|2R|8|@$A|2S|B|2T|F|G]]|9|@$A|2U|B|2V|1|2W]]|C|$]]|$1|L|3|-4|5|6|7|2X|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|2Y|8|@$A|2Z|B|30|F|G]]|9|@]|C|$]]|$1|O|3|-4|5|6|7|31|8|@]|9|@]|C|$]]|$1|P|3|Q|5|K|7|32|8|@$A|33|B|34|F|G]]|9|@$A|35|B|36|1|37]]|C|$]]|$1|R|3|-4|5|6|7|38|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|39|8|@$A|3A|B|3B|F|G]]|9|@]|C|$]]|$1|U|3|V|5|6|7|3C|8|@$A|3D|B|3E|F|G]|$A|3F|B|3G|F|W]|$A|3H|B|3I|F|W]]|9|@]|C|$]]|$1|X|3|Y|5|6|7|3J|8|@$A|3K|B|3L|F|G]]|9|@]|C|$]]|$1|Z|3|-4|5|6|7|3M|8|@]|9|@]|C|$]]|$1|10|3|11|5|K|7|3N|8|@$A|3O|B|3P|F|G]|$A|3Q|B|3R|F|W]]|9|@]|C|$]]|$1|12|3|13|5|6|7|3S|8|@$A|3T|B|3U|F|G]]|9|@]|C|$]]|$1|14|3|-4|5|6|7|3V|8|@]|9|@]|C|$]]|$1|15|3|16|5|17|7|3W|8|@$A|3X|B|3Y|F|G]]|9|@]|C|$]]|$1|18|3|-4|5|6|7|3Z|8|@]|9|@]|C|$]]|$1|19|3|-4|5|6|7|40|8|@]|9|@]|C|$]]|$1|1A|3|-4|5|6|7|41|8|@]|9|@]|C|$]]|$1|1B|3|1C|5|K|7|42|8|@$A|43|B|44|F|G]]|9|@]|C|$]]|$1|1D|3|-4|5|6|7|45|8|@]|9|@]|C|$]]|$1|1E|3|1F|5|6|7|46|8|@$A|47|B|48|F|G]]|9|@]|C|$]]|$1|1G|3|1H|5|17|7|49|8|@$A|4A|B|4B|F|G]]|9|@]|C|$]]|$1|1I|3|-4|5|6|7|4C|8|@]|9|@]|C|$]]|$1|1J|3|-4|5|6|7|4D|8|@]|9|@]|C|$]]|$1|1K|3|1L|5|6|7|4E|8|@$A|4F|B|4G|F|G]]|9|@$A|4H|B|4I|1|4J]]|C|$]]|$1|1M|3|1N|5|1O|7|4K|8|@]|9|@]|C|$1P|1Q]]|$1|1R|3|-4|5|6|7|4L|8|@]|9|@]|C|$]]|$1|1S|3|1T|5|K|7|4M|8|@$A|4N|B|4O|F|G]]|9|@]|C|$]]|$1|1U|3|-4|5|6|7|4P|8|@]|9|@]|C|$]]|$1|1V|3|1W|5|6|7|4Q|8|@$A|4R|B|4S|F|G]]|9|@]|C|$]]|$1|1X|3|1Y|5|17|7|4T|8|@$A|4U|B|4V|F|G]]|9|@]|C|$]]|$1|1Z|3|-4|5|6|7|4W|8|@]|9|@]|C|$]]|$1|20|3|-4|5|6|7|4X|8|@]|9|@]|C|$]]|$1|21|3|22|5|6|7|4Y|8|@$A|4Z|B|50|F|G]]|9|@$A|51|B|52|1|53]]|C|$]]|$1|23|3|-4|5|6|7|54|8|@]|9|@]|C|$]]]|24|$25|$5|26|27|28|C|$29|2A]]|2B|$5|26|27|28|C|$29|2C]]|2D|$5|26|27|28|C|$29|2E]]|2F|$5|26|27|28|C|$29|2G]]|2H|$5|26|27|28|C|$29|2I]]]]

First consider if you really need to iterate over rows in a DataFrame. See <a href="https://stackoverflow.com/a/55557758/3844376">this answer</a> for alternatives.
If you still need to iterate over rows, you can use methods below. Note some important caveats which are not mentioned in any of the other answers.
<ul>
<li><a href="http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.iterrows.html" rel="noreferrer">DataFrame.iterrows()</a>
<pre><code> for index, row in df.iterrows():
 print(row[&quot;c1&quot;], row[&quot;c2&quot;])
</code></pre>
</li>
<li><a href="http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.itertuples.html" rel="noreferrer">DataFrame.itertuples()</a>
<pre><code> for row in df.itertuples(index=True, name='Pandas'):
 print(row.c1, row.c2)
</code></pre>
</li>
</ul>
<code>itertuples()</code> is supposed to be faster than <code>iterrows()</code>
But be aware, according to the docs (pandas 0.24.2 at the moment):
<ul>
<li>iterrows: <code>dtype</code> might not match from row to row</li>
</ul>
<blockquote>
Because iterrows returns a Series for each row, it does not preserve dtypes across the rows (dtypes are preserved across columns for DataFrames). To preserve dtypes while iterating over the rows, it is better to use itertuples() which returns namedtuples of the values and which is generally much faster than iterrows()
</blockquote>
<ul>
<li>iterrows: Do not modify rows</li>
</ul>
<blockquote>
You should never modify something you are iterating over. This is not guaranteed to work in all cases. Depending on the data types, the iterator returns a copy and not a view, and writing to it will have no effect.
</blockquote>
Use <a href="http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.apply.html" rel="noreferrer">DataFrame.apply()</a> instead:
<pre><code> new_df = df.apply(lambda x: x * 2)
</code></pre>
<ul>
<li>itertuples:</li>
</ul>
<blockquote>
The column names will be renamed to positional names if they are invalid Python identifiers, repeated, or start with an underscore. With a large number of columns (&gt;255), regular tuples are returned.
</blockquote>
See <a href="https://pandas.pydata.org/docs/user_guide/basics.html#iteration" rel="noreferrer">pandas docs on iteration</a> for more details.

blocks|key|294189|text|要循环dataframe中的所有行，您可以使用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|294190|for+x+in+range(len(date_example.index)):
++++print+date_example['Date'].iloc[x]|code-block|syntax|javascript|294191|entityMap^0|3|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

To loop all rows in a <code>dataframe</code> you can use:

<pre><code>for x in range(len(date_example.index)):
 print date_example['Date'].iloc[x]
</code></pre>

blocks|key|3347679|text|+for+ind+in+df.index:
+++++print+df['c1'][ind],+df['c2'][ind]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3347680|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> for ind in df.index:
 print df['c1'][ind], df['c2'][ind]
</code></pre>

blocks|key|1222571|text|您可以编写自己的迭代器来实现namedtuple|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1222572|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)|code-block|syntax|javascript|1222573|这可以直接与pd.DataFrame.itertuples相媲美。我的目标是以更高的效率完成同样的任务。|1222574|1222575|对于使用我的函数的给定数据帧：|1222576|list(myiter(df))

[MyTuple(c1=10,+c2=100),+MyTuple(c1=11,+c2=110),+MyTuple(c1=12,+c2=120)]|1222577|或使用pd.DataFrame.itertuples|1222578|list(df.itertuples(index=False))

[Pandas(c1=10,+c2=100),+Pandas(c1=11,+c2=110),+Pandas(c1=12,+c2=120)]|1222579|1222580|A综合测试|BOLD|1222581|我们测试使所有列可用并设置列的子集。|1222582|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);|1222583|​|1222584|📷|atomic|1222585|1222586|1222587|1222588|1222589|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/9f16e34666c3c719aea6509b8101c252.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/ced2b2a7e1ce1486bf1c5590da655b6a.png^0|E|A|0|0|6|N|0|0|0|0|3|N|0|0|0|0|5|0|0|0|0|0|1|0|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1Q|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1V|8|@]|D|@]|E|$]]|$1|P|3|Q|5|H|7|1W|8|@]|D|@]|E|$I|J]]|$1|R|3|S|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|T|3|U|5|H|7|20|8|@]|D|@]|E|$I|J]]|$1|V|3|-4|5|6|7|21|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|22|8|@$9|23|A|24|B|Y]]|D|@]|E|$]]|$1|Z|3|10|5|6|7|25|8|@]|D|@]|E|$]]|$1|11|3|12|5|H|7|26|8|@]|D|@]|E|$I|J]]|$1|13|3|14|5|6|7|27|8|@]|D|@]|E|$]]|$1|15|3|16|5|17|7|28|8|@]|D|@$9|29|A|2A|1|2B]]|E|$]]|$1|18|3|14|5|6|7|2C|8|@]|D|@]|E|$]]|$1|19|3|14|5|6|7|2D|8|@]|D|@]|E|$]]|$1|1A|3|16|5|17|7|2E|8|@]|D|@$9|2F|A|2G|1|2H]]|E|$]]|$1|1B|3|14|5|6|7|2I|8|@]|D|@]|E|$]]|$1|1C|3|-4|5|6|7|2J|8|@]|D|@]|E|$]]]|1D|$1E|$5|1F|1G|1H|E|$1I|1J|1K|-4]]|1L|$5|1F|1G|1H|E|$1I|1M|1K|-4]]]]

You can write your own iterator that implements <code>namedtuple</code>

<pre><code>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)
</code></pre>

This is directly comparable to <code>pd.DataFrame.itertuples</code>. I'm aiming at performing the same task with more efficiency.

<hr>

For the given dataframe with my function:

<pre><code>list(myiter(df))

[MyTuple(c1=10, c2=100), MyTuple(c1=11, c2=110), MyTuple(c1=12, c2=120)]
</code></pre>

Or with <code>pd.DataFrame.itertuples</code>:

<pre><code>list(df.itertuples(index=False))

[Pandas(c1=10, c2=100), Pandas(c1=11, c2=110), Pandas(c1=12, c2=120)]
</code></pre>

<hr>

A comprehensive test 
We test making all columns available and subsetting the columns. 

<pre><code>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);
</code></pre>

<a href="https://i.stack.imgur.com/rt88e.png" rel="noreferrer"><img src="https://i.stack.imgur.com/rt88e.png" alt="enter image description here"></a>

<a href="https://i.stack.imgur.com/azbOF.png" rel="noreferrer"><img src="https://i.stack.imgur.com/azbOF.png" alt="enter image description here"></a>

blocks|key|3347898|text|您还可以对NumPy进行索引，以获得更大的速度。它并不是真正的迭代，但对于某些应用程序来说，它比迭代要好得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3347899|subset+=+row['c1'][0:5]
all+=+row['c1'][:]|code-block|syntax|javascript|3347900|您可能还希望将其转换为数组。这些索引/选择应该已经像NumPy数组一样工作了，但我遇到了问题，需要强制转换|3347901|np.asarray(all)
imgs[:]+=+cv2.resize(imgs[:],+(224,224)+)+#+Resize+every+image+in+an+hdf5+file|3347902|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can also do NumPy indexing for even greater speed ups. It's not really iterating but works much better than iteration for certain applications.

<pre><code>subset = row['c1'][0:5]
all = row['c1'][:]
</code></pre>

You may also want to cast it to an array. These indexes/selections are supposed to act like NumPy arrays already, but I ran into issues and needed to cast

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

blocks|key|294342|text|我正在寻找如何在行和列上迭代，并在这里结束，所以:How+to+iterate+on+rows++columns：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|294343|for+i,+row+in+df.iterrows():
++++for+j,+column+in+row.iteritems():
++++++++print(column)|code-block|syntax|javascript|294344|entityMap^0|1D|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I was looking for How to iterate on rows and columns and ended here so:

<pre><code>for i, row in df.iterrows():
 for j, column in row.iteritems():
 print(column)
</code></pre>

blocks|key|3347983|text|要循环dataframe和中的所有行，可以方便地使用每行的值，namedtuples可以转换为ndarrays。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|3347984|df+=+pd.DataFrame({'col1':+[1,+2],+'col2':+[0.1,+0.2]},+index=['a',+'b'])|code-block|syntax|javascript|3347985|遍历各行：|3347986|for+row+in+df.itertuples(index=False,+name='Pandas'):
++++print+np.asarray(row)|3347987|结果如下：|3347988|[+1.+++0.1]
[+2.+++0.2]|3347989|请注意，如果为index=True，则将索引添加为元组的第一个元素，这对于某些应用程序可能并不可取。|3347990|entityMap^0|3|9|V|B|1B|7|D|G|0|0|0|0|0|0|7|A|I|9|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|16|8|@]|E|@]|F|$J|K]]|$1|L|3|M|5|6|7|17|8|@]|E|@]|F|$]]|$1|N|3|O|5|I|7|18|8|@]|E|@]|F|$J|K]]|$1|P|3|Q|5|6|7|19|8|@]|E|@]|F|$]]|$1|R|3|S|5|I|7|1A|8|@]|E|@]|F|$J|K]]|$1|T|3|U|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|D]]|E|@]|F|$]]|$1|V|3|-4|5|6|7|1G|8|@]|E|@]|F|$]]]|W|$]]

To loop all rows in a <code>dataframe</code> and use values of each row conveniently, <code>namedtuples</code> can be converted to <code>ndarray</code>s. For example:

<pre><code>df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]}, index=['a', 'b'])
</code></pre>

Iterating over the rows:

<pre><code>for row in df.itertuples(index=False, name='Pandas'):
 print np.asarray(row)
</code></pre>

results in:

<pre><code>[ 1. 0.1]
[ 2. 0.2]
</code></pre>

Please note that if <code>index=True</code>, the index is added as the first element of the tuple, which may be undesirable for some applications.

blocks|key|293408|text|有时一个有用的模式是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|293409|#+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)|code-block|syntax|javascript|293410|这会导致：|293411|{'col1':1.0,+'col2':0.1}
{'col1':2.0,+'col2':0.2}|293412|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Sometimes a useful pattern is:

<pre><code># 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)
</code></pre>

Which results in:

<pre><code>{'col1':1.0, 'col2':0.1}
{'col1':2.0, 'col2':0.2}
</code></pre>

blocks|key|1222838|text|有很多方法可以迭代Pandas+dataframe中的行。一种非常简单直观的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1222839|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]])|code-block|syntax|javascript|1222840|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There are so many ways to iterate over the rows in Pandas dataframe. One very simple and intuitive way is:

<pre><code>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]])
</code></pre>

blocks|key|3348107|text|对于查看和修改值，我都会使用iterrows()。在for循环中，通过使用元组解包(参见示例：i,+row)，我使用row仅用于查看值，当我想要修改值时，使用带有loc方法的i。正如在前面的回答中所说的，这里你不应该修改你正在迭代的东西。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3348108|for+i,+row+in+df.iterrows():
++++df_column_A+=+df.loc[i,+'A']
++++if+df_column_A+==+'Old_Value':
++++++++df_column_A+=+'New_value'++|code-block|syntax|javascript|3348109|在这里，循环中的row是该行的副本，而不是该行的视图。因此，您不应该编写类似row['A']+=+'New_Value'的代码，它不会修改DataFrame。但是，您可以使用i和loc并指定DataFrame来完成这项工作。|3348110|entityMap^0|E|A|1B|6|1M|3|29|3|2F|1|0|0|8|3|12|M|2F|1|2H|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|N|$]]

For both viewing and modifying values, I would use <code>iterrows()</code>. In a for loop and by using tuple unpacking (see the example: <code>i, row</code>), I use the <code>row</code> for only viewing the value and use <code>i</code> with the <code>loc</code> method when I want to modify values. As stated in previous answers, here you should not modify something you are iterating over.

<pre><code>for i, row in df.iterrows():
 df_column_A = df.loc[i, 'A']
 if df_column_A == 'Old_Value':
 df_column_A = 'New_value' 
</code></pre>

Here the <code>row</code> in the loop is a copy of that row, and not a view of it. Therefore, you should NOT write something like <code>row['A'] = 'New_Value'</code>, it will not modify the DataFrame. However, you can use <code>i</code> and <code>loc</code> and specify the DataFrame to do the work.

blocks|key|1437045|text|此示例使用iloc来隔离数据帧中的每个数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1437046|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])|code-block|syntax|javascript|1437047|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This example uses iloc to isolate each digit in the data frame. 

<pre><code>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])
</code></pre>

blocks|key|293502|text|有一种方法可以迭代抛出行，同时返回一个DataFrame，而不是一个序列。我没有看到任何人提到您可以将索引作为列表传递给要作为DataFrame返回的行：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|293503|for+i+in+range(len(df)):
++++row+=+df.iloc[[i]]|code-block|syntax|javascript|293504|请注意双括号的用法。这将返回一个只有一行的DataFrame。|293505|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

There is a way to iterate throw rows while getting a DataFrame in return, and not a Series. I don't see anyone mentioning that you can pass index as a list for the row to be returned as a DataFrame:

<pre><code>for i in range(len(df)):
 row = df.iloc[[i]]
</code></pre>

Note the usage of double brackets. This returns a DataFrame with a single row.

blocks|key|3348232|text|有些库(例如，我使用的Java+interop库)要求每次在一行中传递值，例如，如果是流数据。为了复制流的性质，我一个接一个地“流”我的数据帧值，我写了下面的内容，它有时会派上用场。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3348233|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+%2B=+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)+%2B+1+for+k+in+key]
++++++++else:
++++++++++++ix+=+self._columns.index(key)+%2B+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|code-block|syntax|javascript|3348234|它可以使用：|3348235|for+row+in+DataFrameReader(df):
++print(row.my_column_name)
++print(row.to_dict())
++print(row['my_column_name'])
++print(row.tolist())|3348236|并保留正被迭代的行的值/名称映射。显然，这比使用apply和Cython慢得多，但在某些情况下是必要的。|3348237|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Some libraries (e.g. a Java interop library that I use) require values to be passed in a row at a time, for example, if streaming data. To replicate the streaming nature, I 'stream' my dataframe values one by one, I wrote the below, which comes in handy from time to time.

<pre><code>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) -&gt; 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) -&gt; 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) -&gt; List[object]:
 return [self.__getitem__(c) for c in cols]

 def row(self, columns: List[str] = None) -&gt; 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) -&gt; 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) -&gt; 'DataFrameReader':
 if self.read():
 return self
 else:
 raise StopIteration

 def __iter__(self) -&gt; 'DataFrameReader':
 return self
</code></pre>

Which can be used:

<pre><code>for row in DataFrameReader(df):
 print(row.my_column_name)
 print(row.to_dict())
 print(row['my_column_name'])
 print(row.tolist())
</code></pre>

And preserves the values/ name mapping for the rows being iterated. Obviously, is a lot slower than using apply and Cython as indicated above, but is necessary in some circumstances.

blocks|key|3348312|text|如何高效地迭代|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3348313|如果你真的需要迭代一个Pandas数据帧，你可能会想要避免使用()。有不同的方法，通常的iterrows()远不是最好的。itertuples()可以快100倍。|offset|length|style|BOLD|CODE|3348314|简写：|3348315|3348316|作为一般规则，请使用df.itertuples(name=None)。特别是当你有固定的列数和少于255列的时候。请参见point+(3)|unordered-list-item|3348317|Otherwise，use+df.itertuples()，除非您的列包含特殊字符，如空格或'-‘。参见第(2)点|3348318|通过使用最后一个示例，即使您的数据帧有奇怪的列，也可以使用itertuples()。请参见第(4)点:如果您不能使用前面的解决方案，则|3348319|仅使用iterrows()。请参阅第(1)点|3348320|3348321|在Pandas数据帧中迭代行的不同方法：|3348322|生成一个百万行4列的随机数据帧：|3348323|++++df+=+pd.DataFrame(np.random.randint(0,+100,+size=(1000000,+4)),+columns=list('ABCD'))
++++print(df)|code-block|syntax|javascript|3348324|1)通常的iterrows()很方便，但是非常慢：|3348325|start_time+=+time.clock()
result+=+0
for+_,+row+in+df.iterrows():
++++result+%2B=+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))|3348326|2)默认的itertuples()已经快得多了，但是它不适用于诸如My+Col-Name+is+very+Strange之类的列名(如果您的列是重复的，或者如果列名不能简单地转换为Python变量名，则应该避免使用此方法)：|3348327|start_time+=+time.clock()
result+=+0
for+row+in+df.itertuples(index=False):
++++result+%2B=+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))|3348328|3)使用name=None的默认itertuples()更快，但不是很方便，因为您必须为每个列定义一个变量。|3348329|start_time+=+time.clock()
result+=+0
for(_,+col1,+col2,+col3,+col4)+in+df.itertuples(name=None):
++++result+%2B=+max(col2,+col3)

total_elapsed_time+=+round(time.clock()+-+start_time,+2)
print("3.+Itertuples+done+in+{}+seconds,+result+=+{}".format(total_elapsed_time,+result))|3348330|4)最后，命名的itertuples()比前面的要慢，但是您不必为每个列定义一个变量，它可以使用诸如My+Col-Name+is+very+Strange之类的列名。|3348331|start_time+=+time.clock()
result+=+0
for+row+in+df.itertuples(index=False):
++++result+%2B=+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))|3348332|输出：|3348333|+++++++++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|3348334|This+article+is+a+very+interesting+comparison+between+iterrows+and+itertuples|3348335|entityMap|0|LINK|mutability|MUTABLE|url|https://medium.com/swlh/why-pandas-itertuples-is-faster-than-iterrows-and-how-to-make-it-even-faster-bc50c0edd30d^0|0|V|2|1P|K|18|A|0|0|3|0|0|A|O|0|E|F|0|T|C|0|3|A|0|0|0|0|0|5|A|0|0|5|C|X|R|0|0|G|C|0|0|8|C|1E|R|0|0|0|0|0|25|0|0^^$0|@$1|2|3|4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Z|8|@$D|20|E|21|F|G]|$D|22|E|23|F|G]|$D|24|E|25|F|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|26|8|@$D|27|E|28|F|G]]|9|@]|A|$]]|$1|K|3|-4|5|6|7|29|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|2A|8|@$D|2B|E|2C|F|H]]|9|@]|A|$]]|$1|O|3|P|5|N|7|2D|8|@$D|2E|E|2F|F|H]]|9|@]|A|$]]|$1|Q|3|R|5|N|7|2G|8|@$D|2H|E|2I|F|H]]|9|@]|A|$]]|$1|S|3|T|5|N|7|2J|8|@$D|2K|E|2L|F|H]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|2M|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|2N|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|2O|8|@]|9|@]|A|$]]|$1|Z|3|10|5|11|7|2P|8|@]|9|@]|A|$12|13]]|$1|14|3|15|5|6|7|2Q|8|@$D|2R|E|2S|F|H]]|9|@]|A|$]]|$1|16|3|17|5|11|7|2T|8|@]|9|@]|A|$12|13]]|$1|18|3|19|5|6|7|2U|8|@$D|2V|E|2W|F|H]|$D|2X|E|2Y|F|H]]|9|@]|A|$]]|$1|1A|3|1B|5|11|7|2Z|8|@]|9|@]|A|$12|13]]|$1|1C|3|1D|5|6|7|30|8|@$D|31|E|32|F|H]]|9|@]|A|$]]|$1|1E|3|1F|5|11|7|33|8|@]|9|@]|A|$12|13]]|$1|1G|3|1H|5|6|7|34|8|@$D|35|E|36|F|H]|$D|37|E|38|F|H]]|9|@]|A|$]]|$1|1I|3|1J|5|11|7|39|8|@]|9|@]|A|$12|13]]|$1|1K|3|1L|5|6|7|3A|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|11|7|3B|8|@]|9|@]|A|$12|13]]|$1|1O|3|1P|5|6|7|3C|8|@]|9|@$D|3D|E|3E|1|3F]]|A|$]]|$1|1Q|3|-4|5|6|7|3G|8|@]|9|@]|A|$]]]|1R|$1S|$5|1T|1U|1V|A|$1W|1X]]]]

<h1>How to iterate efficiently</h1>

If you really have to iterate a Pandas dataframe, you will probably want to avoid using iterrows(). There are different methods and the usual <code>iterrows()</code> is far from being the best. itertuples() can be 100 times faster.

In short:

<ul>
<li>As a general rule, use <code>df.itertuples(name=None)</code>. In particular, when you have a fixed number columns and less than 255 columns. See point (3)</li>
<li>Otherwise, use <code>df.itertuples()</code> except if your columns have special characters such as spaces or '-'. See point (2)</li>
<li>It is possible to use <code>itertuples()</code> even if your dataframe has strange columns by using the last example. See point (4)</li>
<li>Only use <code>iterrows()</code> if you cannot the previous solutions. See point (1)</li>
</ul>

<h1>Different methods to iterate over rows in a Pandas dataframe:</h1>

Generate a random dataframe with a million rows and 4 columns:

<pre><code> df = pd.DataFrame(np.random.randint(0, 100, size=(1000000, 4)), columns=list('ABCD'))
 print(df)
</code></pre>

1) The usual <code>iterrows()</code> is convenient, but damn slow:

<pre><code>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))
</code></pre>

2) The default <code>itertuples()</code> is already much faster, but it doesn't work with column names such as <code>My Col-Name is very Strange</code> (you should avoid this method if your columns are repeated or if a column name cannot be simply converted to a Python variable name).:

<pre><code>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))
</code></pre>

3) The default <code>itertuples()</code> using name=None is even faster but not really convenient as you have to define a variable per column.

<pre><code>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))
</code></pre>

4) Finally, the named <code>itertuples()</code> is slower than the previous point, but you do not have to define a variable per column and it works with column names such as <code>My Col-Name is very Strange</code>.

<pre><code>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))
</code></pre>

Output:

<pre><code> 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
</code></pre>

<a href="https://medium.com/swlh/why-pandas-itertuples-is-faster-than-iterrows-and-how-to-make-it-even-faster-bc50c0edd30d" rel="noreferrer">This article is a very interesting comparison between iterrows and itertuples</a>

blocks|key|294570|text|更新：cs95已经更新了his+answer，以包含简单的数字矢量化。你可以简单地参考他的答案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|294571|294572|cs95+shows认为，Pandas矢量化在计算数据帧方面远远优于其他Pandas方法。|294573|我想补充的是，如果首先将数据帧转换为NumPy数组，然后使用矢量化，它甚至比Pandas数据帧矢量化更快(这包括将其转换回数据帧系列的时间)。|294574|如果您将以下函数添加到CS95的基准代码中，这将变得非常明显：|294575|def+np_vectorization(df):
++++np_arr+=+df.to_numpy()
++++return+pd.Series(np_arr[:,0]+%2B+np_arr[:,1],+index=df.index)

def+just_np_vectorization(df):
++++np_arr+=+df.to_numpy()
++++return+np_arr[:,0]+%2B+np_arr[:,1]|code-block|syntax|javascript|294576|​|294577|📷|atomic|294578|294579|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/16476924/how-to-iterate-over-rows-in-a-dataframe-in-pandas/55557758#55557758|1|2|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/c650053dd44dcce948579ff239fb124b.png|imageAlt^0|0|2|C|A|0|0|0|0|A|1|0|0|0|0|0|0|1|2|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@$9|1F|A|1G|1|1H]]|E|$]]|$1|F|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]|$1|G|3|H|5|6|7|1J|8|@]|D|@$9|1K|A|1L|1|1M]]|E|$]]|$1|I|3|J|5|6|7|1N|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|1O|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|1P|8|@]|D|@]|E|$P|Q]]|$1|R|3|S|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|T|3|U|5|V|7|1R|8|@]|D|@$9|1S|A|1T|1|1U]]|E|$]]|$1|W|3|S|5|6|7|1V|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]|15|$5|10|11|12|E|$13|14]]|16|$5|17|11|18|E|$19|1A|1B|-4]]]]

Update: cs95 has updated <a href="https://stackoverflow.com/questions/16476924/how-to-iterate-over-rows-in-a-dataframe-in-pandas/55557758#55557758">his answer</a> to include plain numpy vectorization. You can simply refer to his answer.
<hr />
<a href="https://stackoverflow.com/questions/16476924/how-to-iterate-over-rows-in-a-dataframe-in-pandas/55557758#55557758">cs95 shows</a> that Pandas vectorization far outperforms other Pandas methods for computing stuff with dataframes.
I wanted to add that if you first convert the dataframe to a NumPy array and then use vectorization, it's even faster than Pandas dataframe vectorization, (and that includes the time to turn it back into a dataframe series).
If you add the following functions to cs95's benchmark code, this becomes pretty evident:
<pre class="lang-py prettyprint-override"><code>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]
</code></pre>
<a href="https://i.stack.imgur.com/L0u4A.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/L0u4A.png" alt="Enter image description here" /></a>

blocks|key|293642|text|总之|type|unstyled|depth|inlineStyleRanges|entityRanges|data|293643|如果操作不能矢量化，请尽可能使用向量化-使用列表comprehensions|293644|If您需要一个表示整个行的对象-如果上面的操作太慢，请使用swifter.apply|unordered-list-item|293645|
|293646|If+|293647|293648|293649|293650|-尝试Cython例程|offset|length|293651|293652|基准测试|293653|​|293654|📷|atomic|293655|293656|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Cython|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/6e5b948130c8d43ae5eae5d474d78efb.png|imageAlt^0|0|0|0|0|0|0|0|0|3|6|0|0|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1F|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1G|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1H|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|1I|8|@]|9|@]|A|$]]|$1|K|3|H|5|6|7|1J|8|@]|9|@]|A|$]]|$1|L|3|-4|5|F|7|1K|8|@]|9|@]|A|$]]|$1|M|3|H|5|6|7|1L|8|@]|9|@]|A|$]]|$1|N|3|O|5|F|7|1M|8|@]|9|@$P|1N|Q|1O|1|1P]]|A|$]]|$1|R|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1R|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1S|8|@]|9|@]|A|$]]|$1|W|3|X|5|Y|7|1T|8|@]|9|@$P|1U|Q|1V|1|1W]]|A|$]]|$1|Z|3|V|5|6|7|1X|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1Y|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]|18|$5|19|14|1A|A|$1B|1C|1D|-4]]]]

In short
<ul>
<li>Use vectorization if possible</li>
<li>If an operation can't be vectorized - use list comprehensions</li>
<li>If you need a single object representing the entire row - use itertuples</li>
<li>If the above is too slow - try swifter.apply</li>
<li>If it's still too slow - try a <a href="https://en.wikipedia.org/wiki/Cython" rel="noreferrer">Cython</a> routine</li>
</ul>
<h3>Benchmark</h3>
<a href="https://i.stack.imgur.com/ytaWK.png" rel="noreferrer"><img src="https://i.stack.imgur.com/ytaWK.png" alt="Benchmark of iteration over rows in a Pandas DataFrame" /></a>

blocks|key|1223339|text|除了这篇文章中的伟大答案，我将提出Divide++Conquer方法，我写这个答案并不是为了废除其他伟大的答案，而是为了用另一种对我有效的方法来实现它们。它有两个步骤：splitting和merging+the+pandas+dataframe：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|1223340|分而治之的优势：|1223341|你不需要使用矢量化或任何其他方法来将你的数据帧的类型转换为另一种类型，你不需要对你的代码进行Cythonize，这通常会占用你额外的时间，在我的例子中，iterrows()和itertuples()在你选择的切片index上，在整个dataframe|1223342|Depends上都有相同的性能，你将能够指数级地加速迭代。index越高，迭代过程越快。|unordered-list-item|1223343|1223344|分而治之的缺点：|1223345|1223346|你不应该依赖于相同的数据帧和不同的切片的迭代过程。这意味着如果您想从其他切片读取或写入，可能很难做到。|1223347|1223348|===================分而治之的方法=================|1223349|第1步:拆分/切片|1223350|在这一步中，我们将在整个数据帧上划分迭代。假设您要将csv文件读取到pandas+df中，然后对其进行迭代。在5月份，我有5,000,000条记录，我将把它拆分为100,000条记录。|1223351|注意:我需要重申一下，正如本页其他解决方案中解释的其他运行时分析一样，在df上进行搜索时，“记录数量”与“运行时”的比例是指数级的。基于我的数据的基准测试结果如下：|1223352|Number+of+records+%7C+Iteration+per+second
========================================
100,000+++++++++++%7C+500+it/s
500,000+++++++++++%7C+200+it/s
1,000,000+++++++++%7C+50+it/s
5,000,000+++++++++%7C+20+it/s|code-block|syntax|javascript|1223353|第2步:合并|1223354|这将是一个简单的步骤，只需将所有写入的csv文件合并到一个数据帧中，并将其写入一个更大的csv文件。|1223355|以下是示例代码：|1223356|#+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+%2B+1):
++++lower_bound+=+i+*+df_index+
++++higher_bound+=+min(lower_bound+%2B+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_'%2Bstr(i)%2B'.csv')



#+Step+2+(Merging)
filename='C:/KtV_prep_'
df+=+(pd.read_csv(f)+for+f+in+[filename%2Bstr(i)%2B'.csv'+for+i+in+range(ktv_len+//+ktv_index+%2B+1)])
df_prep_all+=+pd.concat(df)
df_prep_all.to_csv('C:/KtV_prep_all.csv')|1223357|参考：|1223358|Efficient+way+of+iteration+over+datafreame|1223359|Concatenate+csv+files+into+one+Pandas+Dataframe|1223360|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/7837722/what-is-the-most-efficient-way-to-loop-through-dataframes-with-pandas|1|https://stackoverflow.com/questions/20906474/import-multiple-csv-files-into-pandas-and-concatenate-into-one-dataframe^0|H|2Y|2C|9|2M|7|0|0|8|0|0|3H|24|A|2F|C|2Y|5|0|0|18|T|5|0|0|0|8|0|0|0|1F|0|0|0|17|0|0|9|0|0|2K|0|0|2A|0|0|0|6|0|0|1E|0|0|8|0|0|0|3|0|0|16|0|16|0|0|0|1B|0|1B|1|0^^$0|@$1|2|3|4|5|6|7|1V|8|@$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|D]|$9|20|A|21|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|22|8|@$9|23|A|24|B|C]]|E|@]|F|$]]|$1|I|3|J|5|6|7|25|8|@$9|26|A|27|B|C]|$9|28|A|29|B|D]|$9|2A|A|2B|B|D]|$9|2C|A|2D|B|D]]|E|@]|F|$]]|$1|K|3|L|5|M|7|2E|8|@$9|2F|A|2G|B|C]|$9|2H|A|2I|B|D]]|E|@]|F|$]]|$1|N|3|-4|5|6|7|2J|8|@]|E|@]|F|$]]|$1|O|3|P|5|6|7|2K|8|@$9|2L|A|2M|B|C]]|E|@]|F|$]]|$1|Q|3|-4|5|6|7|2N|8|@]|E|@]|F|$]]|$1|R|3|S|5|M|7|2O|8|@$9|2P|A|2Q|B|C]]|E|@]|F|$]]|$1|T|3|-4|5|6|7|2R|8|@]|E|@]|F|$]]|$1|U|3|V|5|6|7|2S|8|@$9|2T|A|2U|B|C]]|E|@]|F|$]]|$1|W|3|X|5|6|7|2V|8|@$9|2W|A|2X|B|C]]|E|@]|F|$]]|$1|Y|3|Z|5|6|7|2Y|8|@$9|2Z|A|30|B|C]]|E|@]|F|$]]|$1|10|3|11|5|6|7|31|8|@$9|32|A|33|B|C]]|E|@]|F|$]]|$1|12|3|13|5|14|7|34|8|@]|E|@]|F|$15|16]]|$1|17|3|18|5|6|7|35|8|@$9|36|A|37|B|C]]|E|@]|F|$]]|$1|19|3|1A|5|6|7|38|8|@$9|39|A|3A|B|C]]|E|@]|F|$]]|$1|1B|3|1C|5|6|7|3B|8|@$9|3C|A|3D|B|C]]|E|@]|F|$]]|$1|1D|3|1E|5|14|7|3E|8|@]|E|@]|F|$15|16]]|$1|1F|3|1G|5|6|7|3F|8|@$9|3G|A|3H|B|C]]|E|@]|F|$]]|$1|1H|3|1I|5|6|7|3I|8|@$9|3J|A|3K|B|C]]|E|@$9|3L|A|3M|1|3N]]|F|$]]|$1|1J|3|1K|5|6|7|3O|8|@$9|3P|A|3Q|B|C]]|E|@$9|3R|A|3S|1|3T]]|F|$]]|$1|1L|3|-4|5|6|7|3U|8|@]|E|@]|F|$]]]|1M|$1N|$5|1O|1P|1Q|F|$1R|1S]]|1T|$5|1O|1P|1Q|F|$1R|1U]]]]

Along with the great answers in this post I am going to propose Divide and Conquer approach, I am not writing this answer to abolish the other great answers but to fulfill them with another approach which was working efficiently for me. It has two steps of <code>splitting</code> and <code>merging</code> the pandas dataframe:
PROS of Divide and Conquer:
<ul>
<li>You don't need to use vectorization or any other methods to cast the type of your dataframe into another type</li>
<li>You don't need to Cythonize your code which normally takes extra time from you</li>
<li>Both <code>iterrows()</code> and <code>itertuples()</code> in my case were having the same performance over entire dataframe</li>
<li>Depends on your choice of slicing <code>index</code>, you will be able to exponentially quicken the iteration. The higher <code>index</code>, the quicker your iteration process.</li>
</ul>
CONS of Divide and Conquer:
<ul>
<li>You shouldn't have dependency over the iteration process to the same dataframe and different slice. Meaning if you want to read or write from other slice, it maybe difficult to do that.</li>
</ul>
=================== Divide and Conquer Approach =================
Step 1: Splitting/Slicing
In this step, we are going to divide the iteration over the entire dataframe. Think that you are going to read a csv file into pandas df then iterate over it. In may case I have 5,000,000 records and I am going to split it into 100,000 records.
NOTE: I need to reiterate as other runtime analysis explained in the other solutions in this page, &quot;number of records&quot; has exponential proportion of &quot;runtime&quot; on search on the df. Based on the benchmark on my data here are the results:
<pre><code>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
</code></pre>
Step 2: Merging
This is going to be an easy step, just merge all the written csv files into one dataframe and write it into a bigger csv file.
Here is the sample code:
<pre><code># 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')
</code></pre>
Reference:
<a href="https://stackoverflow.com/questions/7837722/what-is-the-most-efficient-way-to-loop-through-dataframes-with-pandas">Efficient way of iteration over datafreame</a>
<a href="https://stackoverflow.com/questions/20906474/import-multiple-csv-files-into-pandas-and-concatenate-into-one-dataframe">Concatenate csv files into one Pandas Dataframe</a>

blocks|key|293693|text|最简单的方法是使用apply函数|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|293694|def+print_row(row):
+++print+row['c1'],+row['c2']

df.apply(lambda+row:+print_row(row),+axis=1)|code-block|syntax|javascript|293695|entityMap^0|9|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

The easiest way, use the <code>apply</code> function
<pre class="lang-py prettyprint-override"><code>def print_row(row):
 print row['c1'], row['c2']

df.apply(lambda row: print_row(row), axis=1)
</code></pre>

blocks|key|1223447|text|正如这里的许多答案正确而明确地指出的那样，您通常不应该尝试在Pandas中循环，而应该编写向量化的代码。但问题仍然存在，你是否应该在Pandas中编写循环，如果是这样，在这些情况下循环的最好方法是什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1223448|我相信至少有一种一般情况下循环是合适的:当你需要以某种复杂的方式计算一些依赖于行中的值的函数时。在这种情况下，循环代码通常比向量化代码更简单、更具可读性、更不容易出错。循环代码甚至可能更快。|offset|length|style|BOLD|1223449|我将尝试用一个例子来说明这一点。假设您想要对一列进行累加求和，但每当其他列等于零时将其重置：|1223450|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|code-block|syntax|javascript|1223451|这是一个很好的例子，你当然可以编写一行Pandas来实现这一点，尽管它的可读性并不是特别好，特别是如果你还没有足够的Pandas经验：|1223452|df.groupby(+(df.y==0).cumsum()+)['x'].cumsum()|1223453|对于大多数情况，这已经足够快了，尽管您也可以通过避免使用groupby来编写更快的代码，但它的可读性可能会更差。|CODE|1223454|或者，如果我们把它写成一个循环呢？您可以使用NumPy执行类似以下操作：|1223455|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]+%2B+x[i]
++++return+x_sum

df['desired_result']+=+custom_sum(+df.x.to_numpy(),+df.y.to_numpy()+)|1223456|诚然，将DataFrame列转换为NumPy数组需要一些开销，但核心代码只有一行代码，即使您对Pandas或NumPy一无所知也能读懂：|1223457|if+y[i]+>+0:+x_sum[i]+=+x_sum[i-1]+%2B+x[i]|1223458|这段代码实际上比矢量化的代码更快。在一些包含100,000行的快速测试中，上述方法比groupby方法快10倍左右。请注意，速度的一个关键是numba，它是可选的。如果没有"@nb.jit“行，循环代码实际上比groupby方法慢10倍。|1223459|显然，这个示例足够简单，您可能更喜欢一行pandas，而不是编写一个带有相关开销的循环。然而，这个问题还有更复杂的版本，对于这个问题，NumPy/numba循环方法的可读性或速度可能是有意义的。|1223460|entityMap^0|0|0|2C|0|0|0|0|0|S|7|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1A|8|@$D|1B|E|1C|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1D|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1E|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1F|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1G|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1H|8|@$D|1I|E|1J|F|U]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1K|8|@]|9|@]|A|$]]|$1|X|3|Y|5|L|7|1L|8|@]|9|@]|A|$M|N]]|$1|Z|3|10|5|6|7|1M|8|@]|9|@]|A|$]]|$1|11|3|12|5|L|7|1N|8|@]|9|@]|A|$M|N]]|$1|13|3|14|5|6|7|1O|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|1P|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|18|$]]

As many answers here correctly and clearly point out, you should not generally attempt to loop in Pandas, but rather should write vectorized code. But the question remains if you should ever write loops in Pandas, and if so the best way to loop in those situations.
I believe there is at least one general situation where loops are appropriate: when you need to calculate some function that depends on values in other rows in a somewhat complex manner. In this case, the looping code is often simpler, more readable, and less error prone than vectorized code. The looping code might even be faster, too.
I will attempt to show this with an example. Suppose you want to take a cumulative sum of a column, but reset it whenever some other column equals zero:
<pre><code>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
</code></pre>
This is a good example where you could certainly write one line of Pandas to achieve this, although it's not especially readable, especially if you aren't fairly experienced with Pandas already:
<pre><code>df.groupby( (df.y==0).cumsum() )['x'].cumsum()
</code></pre>
That's going to be fast enough for most situations, although you could also write faster code by avoiding the <code>groupby</code>, but it will likely be even less readable.
Alternatively, what if we write this as a loop? You could do something like the following with NumPy:
<pre><code>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] &gt; 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() )
</code></pre>
Admittedly, there's a bit of overhead there required to convert DataFrame columns to NumPy arrays, but the core piece of code is just one line of code that you could read even if you didn't know anything about Pandas or NumPy:
<pre><code>if y[i] &gt; 0: x_sum[i] = x_sum[i-1] + x[i]
</code></pre>
And this code is actually faster than the vectorized code. In some quick tests with 100,000 rows, the above is about 10x faster than the groupby approach. Note that one key to the speed there is numba, which is optional. Without the &quot;@nb.jit&quot; line, the looping code is actually about 10x slower than the groupby approach.
Clearly this example is simple enough that you would likely prefer the one line of pandas to writing a loop with its associated overhead. However, there are more complex versions of this problem for which the readability or speed of the NumPy/numba loop approach likely makes sense.

blocks|key|1223577|text|使用df.iloc[]。例如，使用dataframe‘row_df’：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1223578|​|1223579|📷|atomic|1223580|1223581|或|1223582|要从特定行获取值，可以将dataframe转换为ndarray。|1223583|然后选择行和列值，如下所示：|1223584|1223585|1223586|1223587|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/9e7682a353dc278e0816b1ff39c7e0b4.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/a86f87a649ac19aea87c9b1e1687c4dd.png^0|2|9|0|0|0|1|0|0|0|0|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|18|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|K|3|G|5|6|7|1D|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1E|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1F|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1G|8|@]|D|@]|E|$]]|$1|R|3|G|5|6|7|1H|8|@]|D|@]|E|$]]|$1|S|3|I|5|J|7|1I|8|@]|D|@$9|1J|A|1K|1|1L]]|E|$]]|$1|T|3|G|5|6|7|1M|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11|12|-4]]|13|$5|X|Y|Z|E|$10|14|12|-4]]]]

Use <code>df.iloc[]</code>. For example, using dataframe 'rows_df':
<a href="https://i.stack.imgur.com/eRESg.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/eRESg.png" alt="Enter image description here" /></a>
Or
To get values from a specific row, you can convert the dataframe into ndarray.
Then select the row and column values like this:
<a href="https://i.stack.imgur.com/7iMUn.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/7iMUn.png" alt="Enter image description here" /></a>

blocks|key|1434845|text|补充一下我的两点意见，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1434846|正如公认的答案所述，在行上应用函数的最快方法是使用矢量化函数，即所谓的numpy+ufuncs+(通用函数)。|offset|length|style|BOLD|CODE|1434847|但是，如果要应用的函数尚未在numpy中实现，该怎么办呢|1434848|使用来自numba的vectorize装饰器，您可以很容易地直接在Python中创建ufuncs，如下所示：|1434849|from+numba+import+vectorize,+float64

@vectorize([float64(float64)])
def+f(x):
++++#x+is+your+line,+do+something+with+it,+and+return+a+float|code-block|syntax|javascript|1434850|此函数的文档在此处：https://numba.pydata.org/numba-doc/latest/user/vectorize.html|1434851|entityMap|0|LINK|mutability|MUTABLE|url|https://numba.pydata.org/numba-doc/latest/user/vectorize.html^0|0|P|5|15|6|0|E|5|0|4|5|A|9|0|0|A|1P|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@$D|13|E|14|F|G]|$D|15|E|16|F|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|17|8|@$D|18|E|19|F|H]]|9|@]|A|$]]|$1|K|3|L|5|6|7|1A|8|@$D|1B|E|1C|F|H]|$D|1D|E|1E|F|H]]|9|@]|A|$]]|$1|M|3|N|5|O|7|1F|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|1G|8|@]|9|@$D|1H|E|1I|1|1J]]|A|$]]|$1|T|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

Just adding my two cents,
As the accepted answer states, the fastest way to apply a function over rows is to use a vectorized function, the so-called numpy <code>ufuncs</code> (universal functions)
But what should you do when the function you want to apply isn't already implemented in <code>numpy</code>?
Well using the <code>vectorize</code> decorator from <code>numba</code>, you can easily create ufuncs directly in Python like this:
<pre class="lang-py prettyprint-override"><code>from numba import vectorize, float64

@vectorize([float64(float64)])
def f(x):
 #x is your line, do something with it, and return a float
</code></pre>
The documentation for this function is here: <a href="https://numba.pydata.org/numba-doc/latest/user/vectorize.html" rel="nofollow noreferrer">https://numba.pydata.org/numba-doc/latest/user/vectorize.html</a>

blocks|key|1437418|text|df.iterrows()返回元组(a，b)，其中a是索引，b是行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1437419|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

df.iterrows() return tuple(a,b) where a is index and b is row.

blocks|key|1437426|text|可能是最优雅的解决方案(但肯定不是最有效的)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1437427|for+row+in+df.values:
++++c2+=+row[1]
++++print(row)
++++#+...

for+c1,+c2+in+df.values:
++++#+...|code-block|syntax|javascript|1437428|请注意：|1437429|1437430|+documentation明确建议使用.to_numpy()而不是|unordered-list-item|offset|length|style|CODE|1437431|生成的NumPy数组将具有适合所有列的数据类型，在最坏的情况下，请不要在good+reasons+|1437432|中使用循环|1437433|尽管如此，我认为这个选项应该包含在这里，作为一个(人们应该考虑的)微不足道的问题的直接解决方案。|1437434|entityMap|0|LINK|mutability|MUTABLE|url|https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.values.html|1|https://stackoverflow.com/a/55557758/4248897^0|0|0|0|0|K|B|1|D|0|0|10|C|1|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1A|8|@$M|1B|N|1C|O|P]]|9|@$M|1D|N|1E|1|1F]]|A|$]]|$1|Q|3|R|5|L|7|1G|8|@]|9|@$M|1H|N|1I|1|1J]]|A|$]]|$1|S|3|T|5|6|7|1K|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]]]

Probably the most elegant solution (but certainly not the most efficient):
<pre><code>for row in df.values:
 c2 = row[1]
 print(row)
 # ...

for c1, c2 in df.values:
 # ...
</code></pre>
Note that:
<ul>
<li>the <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.values.html" rel="nofollow noreferrer">documentation</a> explicitly recommends to use <code>.to_numpy()</code> instead</li>
<li>the produced NumPy array will have a dtype that fits all columns, in the worst case <code>object</code></li>
<li>there are <a href="https://stackoverflow.com/a/55557758/4248897">good reasons</a> not to use a loop in the first place</li>
</ul>
Still, I think this option should be included here, as a straight-forward solution to a (one should think) trivial problem.

blocks|key|294838|text|更好的方法是使用zip将数据帧转换为字典，创建键值对，然后按键访问行值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|294839|我的答案是如何使用字典作为Pandas的替代品。有些人认为字典和元组更有效。您可以轻松地将字典替换为命名元组列表。|294840|+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)|code-block|syntax|javascript|294841|输出：|294842|c1+10
c2+100
c1+11
c2+110
c1+12
c2+120|294843|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

A better way is to convert the dataframe into a dictionary by using zip, creating a key value pairing, and then access the row values by key.
My answer shows how to use a dictionary as an alternative to Pandas. Some people think dictionaries and tuples are more efficient. You can easily replace the dictionary with a namedtuple list.
<pre><code> 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)
</code></pre>
Output:
<pre class="lang-none prettyprint-override"><code>c1 10
c2 100
c1 11
c2 110
c1 12
c2 120
</code></pre>

blocks|key|3349000|text|我们有多种选择来做同样的事情，很多人已经分享了他们的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3349001|我发现下面两种方法既简单又高效：|3349002|3349003|DataFrame.iterrows()|ordered-list-item|offset|length|3349004|DataFrame.itertuples()|3349005|3349006|示例：|3349007|+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)|code-block|syntax|javascript|3349008|注意:+itertuples()应该比iterrows()快|3349009|entityMap|0|LINK|mutability|MUTABLE|url|http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.iterrows.html|1|http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.itertuples.html^0|0|0|0|0|K|0|0|0|M|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|18|8|@]|9|@$H|19|I|1A|1|1B]]|A|$]]|$1|J|3|K|5|G|7|1C|8|@]|9|@$H|1D|I|1E|1|1F]]|A|$]]|$1|L|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1I|8|@]|9|@]|A|$R|S]]|$1|T|3|U|5|6|7|1J|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]|13|$5|Y|Z|10|A|$11|14]]]]

We have multiple options to do the same, lots of folks have shared their answers.
I found below two methods easy and efficient to do :
<ol>
<li><a href="http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.iterrows.html" rel="noreferrer">DataFrame.iterrows()</a></li>
<li><a href="http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.itertuples.html" rel="noreferrer">DataFrame.itertuples()</a></li>
</ol>
Example:
<pre><code> 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[&quot;c1&quot;], row[&quot;c2&quot;])

 #With itertuples method

 for row in df.itertuples(index=True, name='Pandas'):
 print(row.c1, row.c2)
</code></pre>
Note: itertuples() is supposed to be faster than iterrows()

blocks|key|293884|text|免责声明：尽管有这么多的答案建议使用迭代(循环)方法的而不是(我基本上同意)，但我仍然认为对于以下情况，它是一个合理的方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|293885|使用来自网络请求的数据扩展数据帧|293886|假设您有一个包含不完整用户数据的大型数据帧。现在，您必须使用其他列来扩展此数据，例如用户的age和gender。|CODE|293887|这两个值都必须从后端API获取。网络请求的开销(等待时间)远远超过了数据帧的迭代。我们谈论的是数百毫秒的网络往返时间，而不是使用替代方法进行迭代的微不足道的收益。|293888|每行1个昂贵的网络请求|293889|因此，在这种情况下，我绝对更喜欢使用迭代方法。尽管网络请求的开销很大，但可以保证对数据帧中的每一行只触发一次。下面是一个使用DataFrame.iterrows的示例|293890|示例|293891|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')|code-block|syntax|javascript|293892|entityMap|0|LINK|mutability|MUTABLE|url|https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iterrows.html#pandas-dataframe-iterrows^0|0|5|R|3|0|0|19|3|1D|6|0|0|0|1Q|I|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1B|8|@$9|1C|A|1D|B|J]|$9|1E|A|1F|B|J]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1G|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1H|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1I|8|@]|D|@$9|1J|A|1K|1|1L]]|E|$]]|$1|Q|3|R|5|6|7|1M|8|@]|D|@]|E|$]]|$1|S|3|T|5|U|7|1N|8|@]|D|@]|E|$V|W]]|$1|X|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]]]

Disclaimer: Although here are so many answers which recommend not using an iterative (loop) approach (and I mostly agree), I would still see it as a reasonable approach for the following situation:
<h2>Extend dataframe with data from network request</h2>
Let's say you have a large dataframe which contains incomplete user data. Now you have to extend this data with additional columns, for example the user's <code>age</code> and <code>gender</code>.
Both values have to be fetched from a backend API. The costs (waiting time) for the network request surpass the iteration of the dataframe by far. We're talking about network roundtrip times of hundreds of milliseconds compared to the negligibly small gains in using alternative approaches to iterations.
<h2>1 expensive network request for each row</h2>
So in this case, I would absolutely prefer using an iterative approach. Although the network request is expensive, it is guaranteed being triggered only once for each row in the dataframe. Here is an example using <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iterrows.html#pandas-dataframe-iterrows" rel="nofollow noreferrer">DataFrame.iterrows</a>:
<h2>Example</h2>
<pre class="lang-py prettyprint-override"><code>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')
</code></pre>

I have a <code>DataFrame</code> from Pandas:

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

Output:

<pre><code> c1 c2
0 10 100
1 11 110
2 12 120
</code></pre>

Now I want to iterate over the rows of this frame. For every row I want to be able to access its elements (values in cells) by the name of the columns. For example:

<pre><code>for row in df.rows:
 print row['c1'], row['c2']
</code></pre>

Is it possible to do that in Pandas?

I found this <a href="https://stackoverflow.com/questions/7837722/what-is-the-most-efficient-way-to-loop-through-dataframes-with-pandas">similar question</a>. But it does not give me the answer I need. For example, it is suggested there to use:

<pre><code>for date, row in df.T.iteritems():
</code></pre>

or

<pre><code>for row in df.iterrows():
</code></pre>

But I do not understand what the <code>row</code> object is and how I can work with it.

How to iterate over rows in a DataFrame in Pandas

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个来自熊猫的DataFrame：import pandas as pdinp = [{'c1':10, 'c2':100}, {'c1':11,'c2':110}, {'c1':12,'c2':120}]df = pd.DataFrame(inp)print df输出：   c1   c20  10  1001 ...

问如何在Pandas中遍历DataFrame中的行
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Pandas中遍历DataFrame中的行EN