From d7a813fc8511417278d99f2d7a32cfbe626b6b5f Mon Sep 17 00:00:00 2001 From: Vineet Kumar Date: Mon, 18 Aug 2025 11:08:11 +0530 Subject: [PATCH 1/2] ENH: Rename DataFrame._append to _append_internal (#57936) --- pandas/core/frame.py | 6 +- pandas/core/indexing.py | 2 +- pandas/core/reshape/pivot.py | 8 +- pandas/core/series.py | 2 +- pandas/tests/reshape/concat/test_append.py | 60 +++++----- .../reshape/concat/test_append_common.py | 108 +++++++++--------- .../tests/reshape/concat/test_categorical.py | 2 +- pandas/tests/reshape/concat/test_index.py | 6 +- pandas/tests/series/indexing/test_indexing.py | 4 +- 9 files changed, 99 insertions(+), 99 deletions(-) diff --git a/pandas/core/frame.py b/pandas/core/frame.py index ec8c8116e5aee..e86f7069f9137 100644 --- a/pandas/core/frame.py +++ b/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) ) diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py index 272acf4874dae..c09b5ec662f23 100644 --- a/pandas/core/indexing.py +++ b/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): """ diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py index c80ee69047ea1..3d16e0cc302b7 100644 --- a/pandas/core/reshape/pivot.py +++ b/pandas/core/reshape/pivot.py @@ -450,7 +450,7 @@ 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 +502,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 +1185,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 +1194,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 diff --git a/pandas/core/series.py b/pandas/core/series.py index 00cff09801f1a..efe52a515fd85 100644 --- a/pandas/core/series.py +++ b/pandas/core/series.py @@ -2991,7 +2991,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 diff --git a/pandas/tests/reshape/concat/test_append.py b/pandas/tests/reshape/concat/test_append.py index 6e18ccfc70e06..b237195d0350c 100644 --- a/pandas/tests/reshape/concat/test_append.py +++ b/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,10 +320,10 @@ 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): @@ -331,19 +331,19 @@ def test_append_empty_tz_frame_with_datetime64ns(self): 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) diff --git a/pandas/tests/reshape/concat/test_append_common.py b/pandas/tests/reshape/concat/test_append_common.py index d0ff950e7985f..21bb14150f1d3 100644 --- a/pandas/tests/reshape/concat/test_append_common.py +++ b/pandas/tests/reshape/concat/test_append_common.py @@ -123,7 +123,7 @@ def test_concatlike_same_dtypes(self, item): # ----- Series ----- # # series.append - res = Series(vals1)._append(Series(vals2), ignore_index=True) + res = Series(vals1)._append_internal(Series(vals2), ignore_index=True) exp = Series(exp_data) tm.assert_series_equal(res, exp, check_index_type=True) @@ -132,7 +132,7 @@ def test_concatlike_same_dtypes(self, item): tm.assert_series_equal(res, exp, check_index_type=True) # 3 elements - res = Series(vals1)._append([Series(vals2), Series(vals3)], ignore_index=True) + res = Series(vals1)._append_internal([Series(vals2), Series(vals3)], ignore_index=True) exp = Series(exp_data3) tm.assert_series_equal(res, exp) @@ -145,7 +145,7 @@ def test_concatlike_same_dtypes(self, item): # name mismatch s1 = Series(vals1, name="x") s2 = Series(vals2, name="y") - res = s1._append(s2, ignore_index=True) + res = s1._append_internal(s2, ignore_index=True) exp = Series(exp_data) tm.assert_series_equal(res, exp, check_index_type=True) @@ -155,7 +155,7 @@ def test_concatlike_same_dtypes(self, item): # name match s1 = Series(vals1, name="x") s2 = Series(vals2, name="x") - res = s1._append(s2, ignore_index=True) + res = s1._append_internal(s2, ignore_index=True) exp = Series(exp_data, name="x") tm.assert_series_equal(res, exp, check_index_type=True) @@ -168,10 +168,10 @@ def test_concatlike_same_dtypes(self, item): "only Series and DataFrame objs are valid" ) with pytest.raises(TypeError, match=msg): - Series(vals1)._append(vals2) + Series(vals1)._append_internal(vals2) with pytest.raises(TypeError, match=msg): - Series(vals1)._append([Series(vals2), vals3]) + Series(vals1)._append_internal([Series(vals2), vals3]) with pytest.raises(TypeError, match=msg): pd.concat([Series(vals1), vals2]) @@ -233,7 +233,7 @@ def test_concatlike_dtypes_coercion(self, item, item2, request): # series._append # GH#39817 - res = Series(vals1)._append(Series(vals2), ignore_index=True) + res = Series(vals1)._append_internal(Series(vals2), ignore_index=True) exp = Series(exp_data, dtype=exp_series_dtype) tm.assert_series_equal(res, exp, check_index_type=True) @@ -244,7 +244,7 @@ def test_concatlike_dtypes_coercion(self, item, item2, request): # 3 elements # GH#39817 - res = Series(vals1)._append([Series(vals2), Series(vals3)], ignore_index=True) + res = Series(vals1)._append_internal([Series(vals2), Series(vals3)], ignore_index=True) exp = Series(exp_data3, dtype=exp_series_dtype) tm.assert_series_equal(res, exp) @@ -277,7 +277,7 @@ def test_concatlike_common_coerce_to_pandas_object(self): dts = Series(dti) tds = Series(tdi) - res = dts._append(tds) + res = dts._append_internal(tds) tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1])) assert isinstance(res.iloc[0], pd.Timestamp) assert isinstance(res.iloc[-1], pd.Timedelta) @@ -302,7 +302,7 @@ def test_concatlike_datetimetz(self, tz_aware_fixture): dts1 = Series(dti1) dts2 = Series(dti2) - res = dts1._append(dts2) + res = dts1._append_internal(dts2) tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1])) res = pd.concat([dts1, dts2]) @@ -322,7 +322,7 @@ def test_concatlike_datetimetz_short(self, tz): ).as_unit("ns") exp = DataFrame(0, index=exp_idx, columns=["A", "B"]) - tm.assert_frame_equal(df1._append(df2), exp) + tm.assert_frame_equal(df1._append_internal(df2), exp) tm.assert_frame_equal(pd.concat([df1, df2]), exp) def test_concatlike_datetimetz_to_object(self, tz_aware_fixture): @@ -348,7 +348,7 @@ def test_concatlike_datetimetz_to_object(self, tz_aware_fixture): dts1 = Series(dti1) dts2 = Series(dti2) - res = dts1._append(dts2) + res = dts1._append_internal(dts2) tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1])) res = pd.concat([dts1, dts2]) @@ -373,7 +373,7 @@ def test_concatlike_datetimetz_to_object(self, tz_aware_fixture): dts1 = Series(dti1) dts3 = Series(dti3) - res = dts1._append(dts3) + res = dts1._append_internal(dts3) tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1])) res = pd.concat([dts1, dts3]) @@ -391,7 +391,7 @@ def test_concatlike_common_period(self): ps1 = Series(pi1) ps2 = Series(pi2) - res = ps1._append(ps2) + res = ps1._append_internal(ps2) tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1])) res = pd.concat([ps1, ps2]) @@ -417,7 +417,7 @@ def test_concatlike_common_period_diff_freq_to_object(self): ps1 = Series(pi1) ps2 = Series(pi2) - res = ps1._append(ps2) + res = ps1._append_internal(ps2) tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1])) res = pd.concat([ps1, ps2]) @@ -443,7 +443,7 @@ def test_concatlike_common_period_mixed_dt_to_object(self): ps1 = Series(pi1) tds = Series(tdi) - res = ps1._append(tds) + res = ps1._append_internal(tds) tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1])) res = pd.concat([ps1, tds]) @@ -465,7 +465,7 @@ def test_concatlike_common_period_mixed_dt_to_object(self): ps1 = Series(pi1) tds = Series(tdi) - res = tds._append(ps1) + res = tds._append_internal(ps1) tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1])) res = pd.concat([tds, ps1]) @@ -480,7 +480,7 @@ def test_concat_categorical(self): exp = Series([1, 2, np.nan, 2, 1, 2], dtype="category") tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) # partially different categories => not-category s1 = Series([3, 2], dtype="category") @@ -488,7 +488,7 @@ def test_concat_categorical(self): exp = Series([3, 2, 2, 1]) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) # completely different categories (same dtype) => not-category s1 = Series([10, 11, np.nan], dtype="category") @@ -496,7 +496,7 @@ def test_concat_categorical(self): exp = Series([10, 11, np.nan, np.nan, 1, 3, 2], dtype=np.float64) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) def test_union_categorical_same_categories_different_order(self): # https://github.com/pandas-dev/pandas/issues/19096 @@ -517,12 +517,12 @@ def test_concat_categorical_coercion(self): exp = Series([1, 2, np.nan, 2, 1, 2], dtype=np.float64) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) # result shouldn't be affected by 1st elem dtype exp = Series([2, 1, 2, 1, 2, np.nan], dtype=np.float64) tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp) - tm.assert_series_equal(s2._append(s1, ignore_index=True), exp) + tm.assert_series_equal(s2._append_internal(s1, ignore_index=True), exp) # all values are not in category => not-category s1 = Series([3, 2], dtype="category") @@ -530,11 +530,11 @@ def test_concat_categorical_coercion(self): exp = Series([3, 2, 2, 1]) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) exp = Series([2, 1, 3, 2]) tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp) - tm.assert_series_equal(s2._append(s1, ignore_index=True), exp) + tm.assert_series_equal(s2._append_internal(s1, ignore_index=True), exp) # completely different categories => not-category s1 = Series([10, 11, np.nan], dtype="category") @@ -542,11 +542,11 @@ def test_concat_categorical_coercion(self): exp = Series([10, 11, np.nan, 1, 3, 2], dtype=np.float64) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) exp = Series([1, 3, 2, 10, 11, np.nan], dtype=np.float64) tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp) - tm.assert_series_equal(s2._append(s1, ignore_index=True), exp) + tm.assert_series_equal(s2._append_internal(s1, ignore_index=True), exp) # different dtype => not-category s1 = Series([10, 11, np.nan], dtype="category") @@ -554,11 +554,11 @@ def test_concat_categorical_coercion(self): exp = Series([10, 11, np.nan, "a", "b", "c"]) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) exp = Series(["a", "b", "c", 10, 11, np.nan]) tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp) - tm.assert_series_equal(s2._append(s1, ignore_index=True), exp) + tm.assert_series_equal(s2._append_internal(s1, ignore_index=True), exp) # if normal series only contains NaN-likes => not-category s1 = Series([10, 11], dtype="category") @@ -566,11 +566,11 @@ def test_concat_categorical_coercion(self): exp = Series([10, 11, np.nan, np.nan, np.nan]) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) exp = Series([np.nan, np.nan, np.nan, 10, 11]) tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp) - tm.assert_series_equal(s2._append(s1, ignore_index=True), exp) + tm.assert_series_equal(s2._append_internal(s1, ignore_index=True), exp) def test_concat_categorical_3elem_coercion(self): # GH 13524 @@ -582,11 +582,11 @@ def test_concat_categorical_3elem_coercion(self): exp = Series([1, 2, np.nan, 2, 1, 2, 1, 2, 1, 2, np.nan], dtype="float") tm.assert_series_equal(pd.concat([s1, s2, s3], ignore_index=True), exp) - tm.assert_series_equal(s1._append([s2, s3], ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal([s2, s3], ignore_index=True), exp) exp = Series([1, 2, 1, 2, np.nan, 1, 2, np.nan, 2, 1, 2], dtype="float") tm.assert_series_equal(pd.concat([s3, s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s3._append([s1, s2], ignore_index=True), exp) + tm.assert_series_equal(s3._append_internal([s1, s2], ignore_index=True), exp) # values are all in either category => not-category s1 = Series([4, 5, 6], dtype="category") @@ -595,11 +595,11 @@ def test_concat_categorical_3elem_coercion(self): exp = Series([4, 5, 6, 1, 2, 3, 1, 3, 4]) tm.assert_series_equal(pd.concat([s1, s2, s3], ignore_index=True), exp) - tm.assert_series_equal(s1._append([s2, s3], ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal([s2, s3], ignore_index=True), exp) exp = Series([1, 3, 4, 4, 5, 6, 1, 2, 3]) tm.assert_series_equal(pd.concat([s3, s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s3._append([s1, s2], ignore_index=True), exp) + tm.assert_series_equal(s3._append_internal([s1, s2], ignore_index=True), exp) # values are all in either category => not-category s1 = Series([4, 5, 6], dtype="category") @@ -608,11 +608,11 @@ def test_concat_categorical_3elem_coercion(self): exp = Series([4, 5, 6, 1, 2, 3, 10, 11, 12]) tm.assert_series_equal(pd.concat([s1, s2, s3], ignore_index=True), exp) - tm.assert_series_equal(s1._append([s2, s3], ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal([s2, s3], ignore_index=True), exp) exp = Series([10, 11, 12, 4, 5, 6, 1, 2, 3]) tm.assert_series_equal(pd.concat([s3, s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s3._append([s1, s2], ignore_index=True), exp) + tm.assert_series_equal(s3._append_internal([s1, s2], ignore_index=True), exp) def test_concat_categorical_multi_coercion(self): # GH 13524 @@ -628,13 +628,13 @@ def test_concat_categorical_multi_coercion(self): exp = Series([1, 3, 3, 4, 2, 3, 2, 2, 1, np.nan, 1, 3, 2]) res = pd.concat([s1, s2, s3, s4, s5, s6], ignore_index=True) tm.assert_series_equal(res, exp) - res = s1._append([s2, s3, s4, s5, s6], ignore_index=True) + res = s1._append_internal([s2, s3, s4, s5, s6], ignore_index=True) tm.assert_series_equal(res, exp) exp = Series([1, 3, 2, 1, np.nan, 2, 2, 2, 3, 3, 4, 1, 3]) res = pd.concat([s6, s5, s4, s3, s2, s1], ignore_index=True) tm.assert_series_equal(res, exp) - res = s6._append([s5, s4, s3, s2, s1], ignore_index=True) + res = s6._append_internal([s5, s4, s3, s2, s1], ignore_index=True) tm.assert_series_equal(res, exp) def test_concat_categorical_ordered(self): @@ -645,11 +645,11 @@ def test_concat_categorical_ordered(self): exp = Series(Categorical([1, 2, np.nan, 2, 1, 2], ordered=True)) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) exp = Series(Categorical([1, 2, np.nan, 2, 1, 2, 1, 2, np.nan], ordered=True)) tm.assert_series_equal(pd.concat([s1, s2, s1], ignore_index=True), exp) - tm.assert_series_equal(s1._append([s2, s1], ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal([s2, s1], ignore_index=True), exp) def test_concat_categorical_coercion_nan(self): # GH 13524 @@ -661,14 +661,14 @@ def test_concat_categorical_coercion_nan(self): exp = Series([np.nan, np.nan, np.nan, 1]) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) s1 = Series([1, np.nan], dtype="category") s2 = Series([np.nan, np.nan]) exp = Series([1, np.nan, np.nan, np.nan], dtype="float") tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) # mixed dtype, all nan-likes => not-category s1 = Series([np.nan, np.nan], dtype="category") @@ -676,9 +676,9 @@ def test_concat_categorical_coercion_nan(self): exp = Series([np.nan, np.nan, np.nan, np.nan]) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp) - tm.assert_series_equal(s2._append(s1, ignore_index=True), exp) + tm.assert_series_equal(s2._append_internal(s1, ignore_index=True), exp) # all category nan-likes => category s1 = Series([np.nan, np.nan], dtype="category") @@ -687,7 +687,7 @@ def test_concat_categorical_coercion_nan(self): exp = Series([np.nan, np.nan, np.nan, np.nan], dtype="category") tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) def test_concat_categorical_empty(self): # GH 13524 @@ -696,35 +696,35 @@ def test_concat_categorical_empty(self): s2 = Series([1, 2], dtype="category") exp = s2.astype(object) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp) - tm.assert_series_equal(s2._append(s1, ignore_index=True), exp) + tm.assert_series_equal(s2._append_internal(s1, ignore_index=True), exp) s1 = Series([], dtype="category") s2 = Series([], dtype="category") tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), s2) - tm.assert_series_equal(s1._append(s2, ignore_index=True), s2) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), s2) s1 = Series([], dtype="category") s2 = Series([], dtype="object") # different dtype => not-category tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), s2) - tm.assert_series_equal(s1._append(s2, ignore_index=True), s2) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), s2) tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), s2) - tm.assert_series_equal(s2._append(s1, ignore_index=True), s2) + tm.assert_series_equal(s2._append_internal(s1, ignore_index=True), s2) s1 = Series([], dtype="category") s2 = Series([np.nan, np.nan]) exp = Series([np.nan, np.nan], dtype=object) tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp) - tm.assert_series_equal(s1._append(s2, ignore_index=True), exp) + tm.assert_series_equal(s1._append_internal(s2, ignore_index=True), exp) tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp) - tm.assert_series_equal(s2._append(s1, ignore_index=True), exp) + tm.assert_series_equal(s2._append_internal(s1, ignore_index=True), exp) def test_categorical_concat_append(self): cat = Categorical(["a", "b"], categories=["a", "b"]) @@ -735,7 +735,7 @@ def test_categorical_concat_append(self): exp = DataFrame({"cats": cat2, "vals": vals2}, index=Index([0, 1, 0, 1])) tm.assert_frame_equal(pd.concat([df, df]), exp) - tm.assert_frame_equal(df._append(df), exp) + tm.assert_frame_equal(df._append_internal(df), exp) # GH 13524 can concat different categories cat3 = Categorical(["a", "b"], categories=["a", "b", "c"]) @@ -746,5 +746,5 @@ def test_categorical_concat_append(self): exp = DataFrame({"cats": list("abab"), "vals": [1, 2, 1, 2]}) tm.assert_frame_equal(res, exp) - res = df._append(df_different_categories, ignore_index=True) + res = df._append_internal(df_different_categories, ignore_index=True) tm.assert_frame_equal(res, exp) diff --git a/pandas/tests/reshape/concat/test_categorical.py b/pandas/tests/reshape/concat/test_categorical.py index 8e6a14e6bfb8f..a168021d8ee4e 100644 --- a/pandas/tests/reshape/concat/test_categorical.py +++ b/pandas/tests/reshape/concat/test_categorical.py @@ -215,7 +215,7 @@ def test_categorical_concat_gh7864(self): dfx = pd.concat([df1, df2]) tm.assert_index_equal(df["grade"].cat.categories, dfx["grade"].cat.categories) - dfa = df1._append(df2) + dfa = df1._append_internal(df2) tm.assert_index_equal(df["grade"].cat.categories, dfa["grade"].cat.categories) def test_categorical_index_upcast(self): diff --git a/pandas/tests/reshape/concat/test_index.py b/pandas/tests/reshape/concat/test_index.py index 17f1a9d4ecbf1..1e34c47ddf83c 100644 --- a/pandas/tests/reshape/concat/test_index.py +++ b/pandas/tests/reshape/concat/test_index.py @@ -191,14 +191,14 @@ def test_dups_index(self): tm.assert_frame_equal(result.iloc[10:], df) # append - result = df.iloc[0:8, :]._append(df.iloc[8:]) + result = df.iloc[0:8, :]._append_internal(df.iloc[8:]) tm.assert_frame_equal(result, df) - result = df.iloc[0:8, :]._append(df.iloc[8:9])._append(df.iloc[9:10]) + result = df.iloc[0:8, :]._append_internal(df.iloc[8:9])._append_internal(df.iloc[9:10]) tm.assert_frame_equal(result, df) expected = concat([df, df], axis=0) - result = df._append(df) + result = df._append_internal(df) tm.assert_frame_equal(result, expected) diff --git a/pandas/tests/series/indexing/test_indexing.py b/pandas/tests/series/indexing/test_indexing.py index 02efd850f9640..f2a604dcc0787 100644 --- a/pandas/tests/series/indexing/test_indexing.py +++ b/pandas/tests/series/indexing/test_indexing.py @@ -117,8 +117,8 @@ def test_getitem_with_duplicates_indices(result_1, duplicate_item, expected_1): # GH 17610 result_1 = Series(result_1) duplicate_item = Series(duplicate_item) - result = result_1._append(duplicate_item) - expected = expected_1._append(duplicate_item) + result = result_1._append_internal(duplicate_item) + expected = expected_1._append_internal(duplicate_item) tm.assert_series_equal(result[1], expected) assert result[2] == result_1[2] From bc711c691f834d8f83f9ef241d44d5dad93544e0 Mon Sep 17 00:00:00 2001 From: Vineet Kumar Date: Mon, 18 Aug 2025 11:20:00 +0530 Subject: [PATCH 2/2] CLN: Format _append_internal calls for better readability --- pandas/core/reshape/pivot.py | 4 +++- pandas/tests/reshape/concat/test_append_common.py | 8 ++++++-- pandas/tests/reshape/concat/test_index.py | 6 +++++- 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py index 3d16e0cc302b7..8b7ca9f437268 100644 --- a/pandas/core/reshape/pivot.py +++ b/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_internal(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( diff --git a/pandas/tests/reshape/concat/test_append_common.py b/pandas/tests/reshape/concat/test_append_common.py index 21bb14150f1d3..06b283062f4c1 100644 --- a/pandas/tests/reshape/concat/test_append_common.py +++ b/pandas/tests/reshape/concat/test_append_common.py @@ -132,7 +132,9 @@ def test_concatlike_same_dtypes(self, item): tm.assert_series_equal(res, exp, check_index_type=True) # 3 elements - res = Series(vals1)._append_internal([Series(vals2), Series(vals3)], ignore_index=True) + res = Series(vals1)._append_internal( + [Series(vals2), Series(vals3)], ignore_index=True + ) exp = Series(exp_data3) tm.assert_series_equal(res, exp) @@ -244,7 +246,9 @@ def test_concatlike_dtypes_coercion(self, item, item2, request): # 3 elements # GH#39817 - res = Series(vals1)._append_internal([Series(vals2), Series(vals3)], ignore_index=True) + res = Series(vals1)._append_internal( + [Series(vals2), Series(vals3)], ignore_index=True + ) exp = Series(exp_data3, dtype=exp_series_dtype) tm.assert_series_equal(res, exp) diff --git a/pandas/tests/reshape/concat/test_index.py b/pandas/tests/reshape/concat/test_index.py index 1e34c47ddf83c..6de1b9bd65a3c 100644 --- a/pandas/tests/reshape/concat/test_index.py +++ b/pandas/tests/reshape/concat/test_index.py @@ -194,7 +194,11 @@ def test_dups_index(self): result = df.iloc[0:8, :]._append_internal(df.iloc[8:]) tm.assert_frame_equal(result, df) - result = df.iloc[0:8, :]._append_internal(df.iloc[8:9])._append_internal(df.iloc[9:10]) + result = ( + df.iloc[0:8, :] + ._append_internal(df.iloc[8:9]) + ._append_internal(df.iloc[9:10]) + ) tm.assert_frame_equal(result, df) expected = concat([df, df], axis=0)