什么时候重置索引？ loc 与 iloc 的索引差距？ 最佳实践？

Question

I discovered a very subtle bug in my code. I frequently delete rows from a dataframe in my analysis. Because this will leave gaps in the index, I try to end all functions by resetting the index at the end with

df0 = df0.reset_index (drop = True)

Then I continue in the next function with

for row in xrange (df0.shape [0]):
    print df0.loc [row]
    print df0.iloc [row]

However, if I dont reset the index correctly, the first row might have an index of 192. The index of 192 is not the same as the row number of 0. This leads to the problem that df0.loc[row] accesses the row with index 0, and df0.iloc[row] are accessing the row with index 192. This has caused a very strange bug, in that I try to update row 0, but index 192 gets updated instead. Or vice versa.

But in reality, I dont use any df0.loc() or df0.iloc() functions because they are too slow. My code is riddled with df0.get_value(...) and df0.set_value(...) functions because they are the fastest functions when accessing values.

And it seems that some of the functions are accessed by index, and other are accessed by row numbers? I am confused. Can someone explain to me? What are the best practices? Are some functions using index to access values, and other are using row numbers? Have I misunderstood something? Should I always reset_index() as often I can? Or never do that?

EDIT: To recap: I manually merge some rows in functions so there will be gaps in the indicies. In other functions I iterate over each row and do calculations. However, if I have reset the index I get other calculation results than if I don't reset the index. Why? That is my problem.

Answer 1

.loc[] looks at index labels , which may or may not be integer-valued.

• If your index is [0, 1, 3] (a non-sequential integer index), .loc[2] won't find anything, because there is no index label 2 .
• Similarly, if your index is ['a', 'b', 'c'] (a non-integer index), .loc[2] will come up empty.

.iloc[] looks at index positions , which will always be integer-valued.

• If your index is [0, 1, 3] , .loc[2] will return the row corresponding to 3 .
• If your index is ['a', 'b', 'c'] , .loc[2] will return the row corresponding to 'c' .

That's not a bug, that's just how those indexers are designed. Whether one fits your purpose depends on the structure of your data and what you're trying to accomplish. It's hard to make a recommendation without knowing more.

That said, it does sound like your code is getting kind of thorny. Having to perform reset_index() in a bunch of different places and keep constant track of which row you're trying to update suggest that you may not be taking advantage of Pandas' ability to perform vector-based calculations across many rows and columns at once. Maybe the task you want to accomplish makes this inevitable. But it's worth taking some time to consider whether you can't vectorize some of what you're doing, so that you can apply it to the whole dataframe or a subset of the dataframe, rather than operating on individual cells one at a time.