DataFrame.reset_index(inplace=True) does not return self, harming composability

[wesm]

Code Sample, a copy-pastable example if possible

df = pd.DataFrame({'foo': [1, 2, 3, 4]},
                   index=pd.Index(['a', 'b', 'c', 'd'], name='names'))
df.reset_index(inplace=True)

returns None

Expected Output

Same as output of

df.reset_index()

output of pd.show_versions()

This is on trunk. Caused by the lines in DataFrame.reset_index

        if not inplace:
            return new_obj

[wesm]

This is technically an API change -- any user which has reset_index(inplace=True) on the last line of a IPython/Jupyter cell could hypothetically have GC issues

[chris-b1]

This is also the case for most anything else that accepts the inplace kwarg (drop, set_index, rename, etc).

[jreback]

I recall a long discussion about this, resulting in: #3212

Personally I would remove all inplace arguments.

• They are not more performant (except in very very few cases)
• Syntactically they make code much harder to read, you have to then (as a user) be aware of mutation; chaining these would be a disaster

However, if these remain, then these should for sure return None (as does in-place python mutation,)
e.g.

In [1]: l = []

In [2]: l.append('foo')

So if keeping them it should not be inconsistent with python.

[wesm]

As soon as we have copy-on-write then I agree this becomes largely moot.

The composability issue has to do with transforming temporaries that have not yet been assigned. For example:

result = (data.groupby([k1, k2])
          .agg(functions)
          .mutate(**mutations)
          .reset_index(inplace=True))

If you have COW then there is no need for the in place operation because you do not need to copy the memory as you do with pandas currently. If the result set is large, then doubling the data in memory may be problematic.

[jorisvandenbossche]

Given that we are going to improve the internals, I think inplace should start working in more cases / be more predictable?
Certainly the example of reset_index (which is just adding a column), should be easy to do inplace without copying when there is no consolidation. And you could want to do this in a method chain.

[wesm]

The behavior of inplace is not uniform, e.g. DataFrame.rename_axis('new_name', inplace=True) return self

[toobaz]

DataFrame.rename_axis('new_name', inplace=True) return self

I think this is no more true, and I think we now agree that, regardless of implementation/efficiency concerns, inplace=True implies "return None". So my impression is that we can close this.

@wesm ?