BUG: DataFrameGroupBy.transform unnecessarily coerces dtype

[rhshadrach]

Comparing

df = pd.DataFrame({'a' : [1], 'b' : [2.], 'c' : ['3']})
res = df.groupby([0]).transform(lambda x: x.max() - x.min())
print(res)

df = pd.DataFrame({'a' : [1], 'b' : [2.]})
res = df.groupby([0]).transform(lambda x: x.max() - x.min())
print(res)

gives

   a    b
0  0  0.0
     a    b
0  0.0  0.0

Note that in the first result, the dtype of a starts and ends as integer, whereas in the 2nd, the dtype starts as integer and ends as float.

When the object column (c) is on the frame, we call _transform_item_by_item which operates on each column individually, giving the expected dtype in the result. Without the object column, we take the slowpath calling apply. apply returns a Series whose index is ['a', 'b'] with values [0.0, 0.0], where the dtype of column b coerces the dtype of column a into the final result of all floats.

The first example above is deprecated (will raise in a future version), but the second example will still be valid and result in the wrong dtype.

[rhshadrach]

Thinking about this more, if the user could control what input was being given to the transform function (i.e. column-by-column vs entire frame), we could default to the fastpath and then allow them to utilize the slowpath if they so desired. By having arguments control the input (and hence, output), the result above would no longer be surprising. It would also mean cleaner code paths internally (as opposed to try A fallback to B).

[michael-michelotti]

@rhshadrach I was working on a tangentially related issue and had a similar idea. See writeup here:
#26840

I thought there were a couple of other things it might be worth looking at regarding the _choose_path method as well.