Consistency with groupby as_index

[hayd]

Checklist:

• head and tail act like filter
• nth act like filter
• nth on Series should dropna? (discuss?)
• something subtle with some functions in agg/apply (again)
• go through other methods to see if as_index acts correctly
• cythonized vs with apply BUG/TST: verify that groupby apply with a column aggregation does not return the column #7002
• get_group with as_index=False, BUG: Applying function on column of Groupby object with as_index=False does not select column #5764
• returned group for a DataFrame.groupby.cumsum(), cumsum sums the groupby column #5614 / jreback@371a7bf / just need to test for transformers (that they ignore as_index)

I've had this half-written for a while, but I wasn't sure actually explain it. I'm still not sure, but here goes.

Would be intersting to discuss what peoples views on the correctness of these was.

I think there's scope for cleaning up some possible inconsistencies (unfortunately this would mean breaking the API):

In [2]: df = pd.DataFrame([[1, 2], [1, 4], [5, 6]], columns=['A', 'B'])

In [3]: g = df.groupby('A', )

In [4]: g1 = df.groupby('A', as_index=False)

In [5]: g.head(1)   # I did a dirty hack to get the index like this!
Out[5]: 
     A  B
A        
1 0  1  2
5 2  5  6

In [6]: g1.head(1)
Out[6]: 
   A  B
0  1  2
2  5  6

In [7]: g.nth(0)
Out[7]: 
   B
A   
1  2
5  6

In [8]: g1.nth(0)  # the index doesn't match the original
Out[8]: 
   A  B
0  1  2
1  5  6

In [9]: g.filter(lambda x: x.B>0)
Out[9]: 
   A  B
0  1  2
1  1  4
2  5  6

In [10]: g1.filter(lambda x: x.B>0)
Out[10]: 
   A  B
0  1  2
1  1  4
2  5  6

In [13]: g.apply(lambda x: x.sum()) 
Out[13]: 
   A  B
A      
1  2  6
5  5  6

In [14]: g1.apply(lambda x: x.sum())  # but as_index=False
Out[14]: 
   A  B
A      
1  2  6
5  5  6

In [15]: g.apply(lambda x: x)  # no index ?
Out[15]: 
   A  B
0  1  2
1  1  4
2  5  6

In [16]: g1.apply(lambda x: x) 
Out[16]: 
   A  B
0  1  2
1  1  4
2  5  6

In [18]: g.agg(lambda x: x.sum())
Out[18]: 
   B
A   
1  6
5  6

In [19]: g1.agg(lambda x: x.sum())  # Note: A is not summed
Out[19]: 
   A  B
0  1  6
1  5  6

My opinion is that head/tail/nth should act like filter (i.e. both ignore the as_index).

The docstring says:

        as_index : boolean, default True
            For aggregated output, return object with group labels as the
            index. Only relevant for DataFrame input. as_index=False is
            effectively "SQL-style" grouped output

So the contract on the index depends on the definition of what constitutes "aggregated output".
I'm guessing it means the ufuncs like sum. in which case nth should ignore as_index.

But that's a pretty strange design choice, I'd expect the result of a groupby to be a
single definite thing and all operations on it should behave as if they operated on that result.
In other words, if you use sum() and it behaves as if the groups had some set of indices
and when you use head() it behaves as if the groups had different indices, that's weird, and
I can't think of a reason why it makes sense.

By either definition though, nth seems baroquely broken. no idea. Since t's undocumented
I guess it's correct for some definition out there.

This looks like >=3 seperate issues to me.

[hayd]

Just to link #5552 on nth groupby.

Not sure what a good way to fix/break the current behaviour is (for 0.14)...

[jreback]

bumping to 0.15 / this is a more complete #7002 so going to add my example at the top

[hayd]

a couple of PRs doing atm tick off some of this as well as previous (checked) stuff

I think I'll tweak the top description later to reflect the change (this was not changed in 0.13.1) so maybe will see some people confused here

[jreback]

gr8!

[jreback]

as an aside,

I think we need to make clear, maybe in the filter section of groupby that

head/tail/nth are REALLY filtration methods (and so return the grouper)

as compared to first/last/sum/mean/describe etc (which DON't return the grouper)

yes?

[jreback]

I added a bullet point at the end of here: #6944

[jorisvandenbossche]

Maybe more appropriate here than in #7000, so repeating:

Looking at this discussion with a lot of Aaarghs (and also seeing some of the other issues with groupby), I was thinking: should we try to write down some 'design document' where we try to describe the 'rules'.

Eg the "we regard head as a filtering-like function (no aggregation), and those always ignore as_index/return the grouped values in their original column"-rule as used above.

This could maybe clarify some things for ourselves, and can be used as a reference for future PRs. (Or could it also turn out as a rabbit hole ..)

And I mean a rather detailed description for devs (and maybe simpler version in the docs, as added now to #6944)

[jreback]

just going to do that, I think a nice Note at the beginning of the aggregation/transform/filter secition should do it?

clear, reminding you that these functions return or don't return the grouped indices