ENH: Rename DataFrame._append to _append_internal (#62137)

Author: whyvineet

pandas/core/frame.py

@@ -3721,7 +3721,7 @@ def memory_usage(self, index: bool = True, deep: bool = False) -> Series:
             index_memory_usage = self._constructor_sliced(
                 self.index.memory_usage(deep=deep), index=["Index"]
             )
-            result = index_memory_usage._append(result)
+            result = index_memory_usage._append_internal(result)
         return result
 
     def transpose(
@@ -10882,7 +10882,7 @@ def infer(x):
     # ----------------------------------------------------------------------
     # Merging / joining methods
 
-    def _append(
+    def _append_internal(
         self,
         other,
         ignore_index: bool = False,
@@ -11745,7 +11745,7 @@ def c(x):
             idx_diff = result_index.difference(correl.index)
 
             if len(idx_diff) > 0:
-                correl = correl._append(
+                correl = correl._append_internal(
                     Series([np.nan] * len(idx_diff), index=idx_diff)
                 )
 

pandas/core/indexing.py

@@ -2323,7 +2323,7 @@ def _setitem_with_indexer_missing(self, indexer, value):
                     df = df.infer_objects()
                 self.obj._mgr = df._mgr
             else:
-                self.obj._mgr = self.obj._append(value)._mgr
+                self.obj._mgr = self.obj._append_internal(value)._mgr
 
     def _ensure_iterable_column_indexer(self, column_indexer):
         """

pandas/core/reshape/pivot.py

@@ -450,7 +450,9 @@ def _add_margins(
     if not values and isinstance(table, ABCSeries):
         # If there are no values and the table is a series, then there is only
         # one column in the data. Compute grand margin and return it.
-        return table._append(table._constructor({key: grand_margin[margins_name]}))
+        return table._append_internal(
+            table._constructor({key: grand_margin[margins_name]})
+        )
 
     elif values:
         marginal_result_set = _generate_marginal_results(
@@ -502,7 +504,7 @@ def _add_margins(
         margin_dummy[cols] = margin_dummy[cols].apply(
             maybe_downcast_to_dtype, args=(dtype,)
         )
-    result = result._append(margin_dummy)
+    result = result._append_internal(margin_dummy)
     result.index.names = row_names
 
     return result
@@ -1185,7 +1187,7 @@ def _normalize(
 
         elif normalize == "index":
             index_margin = index_margin / index_margin.sum()
-            table = table._append(index_margin, ignore_index=True)
+            table = table._append_internal(index_margin, ignore_index=True)
             table = table.fillna(0)
             table.index = table_index
 
@@ -1194,7 +1196,7 @@ def _normalize(
             index_margin = index_margin / index_margin.sum()
             index_margin.loc[margins_name] = 1
             table = concat([table, column_margin], axis=1)
-            table = table._append(index_margin, ignore_index=True)
+            table = table._append_internal(index_margin, ignore_index=True)
 
             table = table.fillna(0)
             table.index = table_index

pandas/core/series.py

@@ -2988,7 +2988,7 @@ def searchsorted(  # type: ignore[override]
     # -------------------------------------------------------------------
     # Combination
 
-    def _append(
+    def _append_internal(
         self, to_append, ignore_index: bool = False, verify_integrity: bool = False
     ):
         from pandas.core.reshape.concat import concat

pandas/tests/reshape/concat/test_append.py

@@ -28,23 +28,23 @@ def test_append(self, sort, float_frame):
         begin_frame = float_frame.reindex(begin_index)
         end_frame = float_frame.reindex(end_index)
 
-        appended = begin_frame._append(end_frame)
+        appended = begin_frame._append_internal(end_frame)
         tm.assert_almost_equal(appended["A"], float_frame["A"])
 
         del end_frame["A"]
-        partial_appended = begin_frame._append(end_frame, sort=sort)
+        partial_appended = begin_frame._append_internal(end_frame, sort=sort)
         assert "A" in partial_appended
 
-        partial_appended = end_frame._append(begin_frame, sort=sort)
+        partial_appended = end_frame._append_internal(begin_frame, sort=sort)
         assert "A" in partial_appended
 
         # mixed type handling
-        appended = mixed_frame[:5]._append(mixed_frame[5:])
+        appended = mixed_frame[:5]._append_internal(mixed_frame[5:])
         tm.assert_frame_equal(appended, mixed_frame)
 
         # what to test here
-        mixed_appended = mixed_frame[:5]._append(float_frame[5:], sort=sort)
-        mixed_appended2 = float_frame[:5]._append(mixed_frame[5:], sort=sort)
+        mixed_appended = mixed_frame[:5]._append_internal(float_frame[5:], sort=sort)
+        mixed_appended2 = float_frame[:5]._append_internal(mixed_frame[5:], sort=sort)
 
         # all equal except 'foo' column
         tm.assert_frame_equal(
@@ -55,18 +55,18 @@ def test_append(self, sort, float_frame):
     def test_append_empty(self, float_frame):
         empty = DataFrame()
 
-        appended = float_frame._append(empty)
+        appended = float_frame._append_internal(empty)
         tm.assert_frame_equal(float_frame, appended)
         assert appended is not float_frame
 
-        appended = empty._append(float_frame)
+        appended = empty._append_internal(float_frame)
         tm.assert_frame_equal(float_frame, appended)
         assert appended is not float_frame
 
     def test_append_overlap_raises(self, float_frame):
         msg = "Indexes have overlapping values"
         with pytest.raises(ValueError, match=msg):
-            float_frame._append(float_frame, verify_integrity=True)
+            float_frame._append_internal(float_frame, verify_integrity=True)
 
     def test_append_new_columns(self):
         # see gh-6129: new columns
@@ -79,13 +79,13 @@ def test_append_new_columns(self):
                 "c": {"z": 7},
             }
         )
-        result = df._append(row)
+        result = df._append_internal(row)
         tm.assert_frame_equal(result, expected)
 
     def test_append_length0_frame(self, sort):
         df = DataFrame(columns=["A", "B", "C"])
         df3 = DataFrame(index=[0, 1], columns=["A", "B"])
-        df5 = df._append(df3, sort=sort)
+        df5 = df._append_internal(df3, sort=sort)
 
         expected = DataFrame(index=[0, 1], columns=["A", "B", "C"])
         tm.assert_frame_equal(df5, expected)
@@ -100,7 +100,7 @@ def test_append_records(self):
         df1 = DataFrame(arr1)
         df2 = DataFrame(arr2)
 
-        result = df1._append(df2, ignore_index=True)
+        result = df1._append_internal(df2, ignore_index=True)
         expected = DataFrame(np.concatenate((arr1, arr2)))
         tm.assert_frame_equal(result, expected)
 
@@ -109,7 +109,7 @@ def test_append_sorts(self, sort):
         df1 = DataFrame({"a": [1, 2], "b": [1, 2]}, columns=["b", "a"])
         df2 = DataFrame({"a": [1, 2], "c": [3, 4]}, index=[2, 3])
 
-        result = df1._append(df2, sort=sort)
+        result = df1._append_internal(df2, sort=sort)
 
         # for None / True
         expected = DataFrame(
@@ -133,7 +133,7 @@ def test_append_different_columns(self, sort):
         a = df[:5].loc[:, ["bools", "ints", "floats"]]
         b = df[5:].loc[:, ["strings", "ints", "floats"]]
 
-        appended = a._append(b, sort=sort)
+        appended = a._append_internal(b, sort=sort)
         assert isna(appended["strings"][0:4]).all()
         assert isna(appended["bools"][5:]).all()
 
@@ -145,12 +145,12 @@ def test_append_many(self, sort, float_frame):
             float_frame[15:],
         ]
 
-        result = chunks[0]._append(chunks[1:])
+        result = chunks[0]._append_internal(chunks[1:])
         tm.assert_frame_equal(result, float_frame)
 
         chunks[-1] = chunks[-1].copy()
         chunks[-1]["foo"] = "bar"
-        result = chunks[0]._append(chunks[1:], sort=sort)
+        result = chunks[0]._append_internal(chunks[1:], sort=sort)
         tm.assert_frame_equal(result.loc[:, float_frame.columns], float_frame)
         assert (result["foo"][15:] == "bar").all()
         assert result["foo"][:15].isna().all()
@@ -162,7 +162,7 @@ def test_append_preserve_index_name(self):
         df2 = DataFrame(data=[[1, 4, 7], [2, 5, 8], [3, 6, 9]], columns=["A", "B", "C"])
         df2 = df2.set_index(["A"])
 
-        result = df1._append(df2)
+        result = df1._append_internal(df2)
         assert result.index.name == "A"
 
     indexes_can_append = [
@@ -193,7 +193,7 @@ def test_append_same_columns_type(self, index):
         df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=index)
         ser_index = index[:2]
         ser = Series([7, 8], index=ser_index, name=2)
-        result = df._append(ser)
+        result = df._append_internal(ser)
         expected = DataFrame(
             [[1, 2, 3.0], [4, 5, 6], [7, 8, np.nan]], index=[0, 1, 2], columns=index
         )
@@ -208,7 +208,7 @@ def test_append_same_columns_type(self, index):
         index = index[:2]
         df = DataFrame([[1, 2], [4, 5]], columns=index)
         ser = Series([7, 8, 9], index=ser_index, name=2)
-        result = df._append(ser)
+        result = df._append_internal(ser)
         expected = DataFrame(
             [[1, 2, np.nan], [4, 5, np.nan], [7, 8, 9]],
             index=[0, 1, 2],
@@ -229,7 +229,7 @@ def test_append_different_columns_types(self, df_columns, series_index):
         df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=df_columns)
         ser = Series([7, 8, 9], index=series_index, name=2)
 
-        result = df._append(ser)
+        result = df._append_internal(ser)
         idx_diff = ser.index.difference(df_columns)
         combined_columns = Index(df_columns.tolist()).append(idx_diff)
         expected = DataFrame(
@@ -285,7 +285,7 @@ def test_append_dtype_coerce(self, sort):
             axis=1,
             sort=sort,
         )
-        result = df1._append(df2, ignore_index=True, sort=sort)
+        result = df1._append_internal(df2, ignore_index=True, sort=sort)
         if sort:
             expected = expected[["end_time", "start_time"]]
         else:
@@ -297,7 +297,7 @@ def test_append_missing_column_proper_upcast(self, sort):
         df1 = DataFrame({"A": np.array([1, 2, 3, 4], dtype="i8")})
         df2 = DataFrame({"B": np.array([True, False, True, False], dtype=bool)})
 
-        appended = df1._append(df2, ignore_index=True, sort=sort)
+        appended = df1._append_internal(df2, ignore_index=True, sort=sort)
         assert appended["A"].dtype == "f8"
         assert appended["B"].dtype == "O"
 
@@ -306,7 +306,7 @@ def test_append_empty_frame_to_series_with_dateutil_tz(self):
         date = Timestamp("2018-10-24 07:30:00", tz=dateutil.tz.tzutc())
         ser = Series({"a": 1.0, "b": 2.0, "date": date})
         df = DataFrame(columns=["c", "d"])
-        result_a = df._append(ser, ignore_index=True)
+        result_a = df._append_internal(ser, ignore_index=True)
         expected = DataFrame(
             [[np.nan, np.nan, 1.0, 2.0, date]], columns=["c", "d", "a", "b", "date"]
         )
@@ -320,30 +320,30 @@ def test_append_empty_frame_to_series_with_dateutil_tz(self):
         )
         expected["c"] = expected["c"].astype(object)
         expected["d"] = expected["d"].astype(object)
-        result_b = result_a._append(ser, ignore_index=True)
+        result_b = result_a._append_internal(ser, ignore_index=True)
         tm.assert_frame_equal(result_b, expected)
 
-        result = df._append([ser, ser], ignore_index=True)
+        result = df._append_internal([ser, ser], ignore_index=True)
         tm.assert_frame_equal(result, expected)
 
     def test_append_empty_tz_frame_with_datetime64ns(self):
         # https://github.com/pandas-dev/pandas/issues/35460
         df = DataFrame(columns=["a"]).astype("datetime64[ns, UTC]")
 
         # pd.NaT gets inferred as tz-naive, so append result is tz-naive
-        result = df._append({"a": pd.NaT}, ignore_index=True)
+        result = df._append_internal({"a": pd.NaT}, ignore_index=True)
         expected = DataFrame({"a": [pd.NaT]}, dtype=object)
         tm.assert_frame_equal(result, expected)
 
         # also test with typed value to append
         df = DataFrame(columns=["a"]).astype("datetime64[ns, UTC]")
         other = Series({"a": pd.NaT}, dtype="datetime64[ns]")
-        result = df._append(other, ignore_index=True)
+        result = df._append_internal(other, ignore_index=True)
         tm.assert_frame_equal(result, expected)
 
         # mismatched tz
         other = Series({"a": pd.NaT}, dtype="datetime64[ns, US/Pacific]")
-        result = df._append(other, ignore_index=True)
+        result = df._append_internal(other, ignore_index=True)
         expected = DataFrame({"a": [pd.NaT]}).astype(object)
         tm.assert_frame_equal(result, expected)
 
@@ -356,7 +356,7 @@ def test_append_empty_frame_with_timedelta64ns_nat(self, dtype_str, val):
         df = DataFrame(columns=["a"]).astype(dtype_str)
 
         other = DataFrame({"a": [np.timedelta64(val, "ns")]})
-        result = df._append(other, ignore_index=True)
+        result = df._append_internal(other, ignore_index=True)
 
         expected = other.astype(object)
         tm.assert_frame_equal(result, expected)
@@ -370,7 +370,7 @@ def test_append_frame_with_timedelta64ns_nat(self, dtype_str, val):
         df = DataFrame({"a": pd.array([1], dtype=dtype_str)})
 
         other = DataFrame({"a": [np.timedelta64(val, "ns")]})
-        result = df._append(other, ignore_index=True)
+        result = df._append_internal(other, ignore_index=True)
 
         expected = DataFrame({"a": [df.iloc[0, 0], other.iloc[0, 0]]}, dtype=object)
         tm.assert_frame_equal(result, expected)