What’s new in 3.0.0 (Month XX, 2024)

These are the changes in pandas 3.0.0. See Release notes for a full changelog including other versions of pandas.

Enhancements

enhancement1

enhancement2

Other enhancements

• pandas.api.typing.FrozenList is available for typing the outputs of MultiIndex.names, MultiIndex.codes and MultiIndex.levels (GH 58237)

• pandas.api.typing.SASReader is available for typing the output of read_sas() (GH 55689)

• DataFrame.to_excel() now raises an UserWarning when the character count in a cell exceeds Excel’s limitation of 32767 characters (GH 56954)

• read_stata() now returns datetime64 resolutions better matching those natively stored in the stata format (GH 55642)

• Styler.set_tooltips() provides alternative method to storing tooltips by using title attribute of td elements. (GH 56981)

• Allow dictionaries to be passed to pandas.Series.str.replace() via pat parameter (GH 51748)

• Support passing a Series input to json_normalize() that retains the Series Index (GH 51452)

• Support reading value labels from Stata 108-format (Stata 6) and earlier files (GH 58154)

• Users can globally disable any PerformanceWarning by setting the option mode.performance_warnings to False (GH 56920)

• Styler.format_index_names() can now be used to format the index and column names (GH 48936 and GH 47489)

• errors.DtypeWarning improved to include column names when mixed data types are detected (GH 58174)

• DataFrame.cummin(), DataFrame.cummax(), DataFrame.cumprod() and DataFrame.cumsum() methods now have a numeric_only parameter (GH 53072)

• DataFrame.fillna() and Series.fillna() can now accept value=None; for non-object dtype the corresponding NA value will be used (GH 57723)

• Series.cummin() and Series.cummax() now supports CategoricalDtype (GH 52335)

Notable bug fixes

These are bug fixes that might have notable behavior changes.

Improved behavior in groupby for observed=False

A number of bugs have been fixed due to improved handling of unobserved groups (GH 55738). All remarks in this section equally impact SeriesGroupBy.

In previous versions of pandas, a single grouping with DataFrameGroupBy.apply() or DataFrameGroupBy.agg() would pass the unobserved groups to the provided function, resulting in 0 below.

In [1]: df = pd.DataFrame(
   ...:     {
   ...:         "key1": pd.Categorical(list("aabb"), categories=list("abc")),
   ...:         "key2": [1, 1, 1, 2],
   ...:         "values": [1, 2, 3, 4],
   ...:     }
   ...: )
   ...: 

In [2]: df
Out[2]: 
  key1  key2  values
0    a     1       1
1    a     1       2
2    b     1       3
3    b     2       4

In [3]: gb = df.groupby("key1", observed=False)

In [4]: gb[["values"]].apply(lambda x: x.sum())
Out[4]: 
      values
key1        
a          3
b          7
c          0

However this was not the case when using multiple groupings, resulting in NaN below.

In [1]: gb = df.groupby(["key1", "key2"], observed=False)
In [2]: gb[["values"]].apply(lambda x: x.sum())
Out[2]:
           values
key1 key2
a    1        3.0
     2        NaN
b    1        3.0
     2        4.0
c    1        NaN
     2        NaN

Now using multiple groupings will also pass the unobserved groups to the provided function.

In [5]: gb = df.groupby(["key1", "key2"], observed=False)

In [6]: gb[["values"]].apply(lambda x: x.sum())
Out[6]: 
           values
key1 key2        
a    1          3
     2          0
b    1          3
     2          4
c    1          0
     2          0

Similarly:

• In previous versions of pandas the method DataFrameGroupBy.sum() would result in 0 for unobserved groups, but DataFrameGroupBy.prod(), DataFrameGroupBy.all(), and DataFrameGroupBy.any() would all result in NA values. Now these methods result in 1, True, and False respectively.

• DataFrameGroupBy.groups() did not include unobserved groups and now does.

These improvements also fixed certain bugs in groupby:

• DataFrameGroupBy.agg() would fail when there are multiple groupings, unobserved groups, and as_index=False (GH 36698)

• DataFrameGroupBy.groups() with sort=False would sort groups; they now occur in the order they are observed (GH 56966)

• DataFrameGroupBy.nunique() would fail when there are multiple groupings, unobserved groups, and as_index=False (GH 52848)

• DataFrameGroupBy.sum() would have incorrect values when there are multiple groupings, unobserved groups, and non-numeric data (GH 43891)

• DataFrameGroupBy.value_counts() would produce incorrect results when used with some categorical and some non-categorical groupings and observed=False (GH 56016)

notable_bug_fix2

Backwards incompatible API changes

Increased minimum versions for dependencies

Some minimum supported versions of dependencies were updated. If installed, we now require:

Package	Minimum Version	Required	Changed
numpy	1.23.5	X	X

For optional libraries the general recommendation is to use the latest version. The following table lists the lowest version per library that is currently being tested throughout the development of pandas. Optional libraries below the lowest tested version may still work, but are not considered supported.

Package	New Minimum Version
fastparquet	2023.10.0
adbc-driver-postgresql	0.10.0
mypy (dev)	1.9.0

See Dependencies and Optional dependencies for more.

Other API changes

• 3rd party py.path objects are no longer explicitly supported in IO methods. Use pathlib.Path objects instead (GH 57091)

• read_table()’s parse_dates argument defaults to None to improve consistency with read_csv() (GH 57476)

• Made dtype a required argument in ExtensionArray._from_sequence_of_strings() (GH 56519)

• Updated DataFrame.to_excel() so that the output spreadsheet has no styling. Custom styling can still be done using Styler.to_excel() (GH 54154)

• pickle and HDF (.h5) files created with Python 2 are no longer explicitly supported (GH 57387)

• pickled objects from pandas version less than 1.0.0 are no longer supported (GH 57155)

• when comparing the indexes in testing.assert_series_equal(), check_exact defaults to True if an Index is of integer dtypes. (GH 57386)

Deprecations

Copy keyword

The copy keyword argument in the following methods is deprecated and will be removed in a future version:

• DataFrame.truncate() / Series.truncate()

• DataFrame.tz_convert() / Series.tz_convert()

• DataFrame.tz_localize() / Series.tz_localize()

• DataFrame.infer_objects() / Series.infer_objects()

• DataFrame.align() / Series.align()

• DataFrame.astype() / Series.astype()

• DataFrame.reindex() / Series.reindex()

• DataFrame.reindex_like() / Series.reindex_like()

• DataFrame.set_axis() / Series.set_axis()

• DataFrame.to_period() / Series.to_period()

• DataFrame.to_timestamp() / Series.to_timestamp()

• DataFrame.rename() / Series.rename()

• DataFrame.transpose()

• DataFrame.swaplevel()

• DataFrame.merge() / pd.merge()

Copy-on-Write utilizes a lazy copy mechanism that defers copying the data until necessary. Use .copy to trigger an eager copy. The copy keyword has no effect starting with 3.0, so it can be safely removed from your code.

Other Deprecations

• Deprecated Timestamp.utcfromtimestamp(), use Timestamp.fromtimestamp(ts, "UTC") instead (GH 56680)

• Deprecated Timestamp.utcnow(), use Timestamp.now("UTC") instead (GH 56680)

• Deprecated allowing non-keyword arguments in DataFrame.all(), DataFrame.min(), DataFrame.max(), DataFrame.sum(), DataFrame.prod(), DataFrame.mean(), DataFrame.median(), DataFrame.sem(), DataFrame.var(), DataFrame.std(), DataFrame.skew(), DataFrame.kurt(), Series.all(), Series.min(), Series.max(), Series.sum(), Series.prod(), Series.mean(), Series.median(), Series.sem(), Series.var(), Series.std(), Series.skew(), and Series.kurt(). (GH 57087)

• Deprecated allowing non-keyword arguments in Series.to_markdown() except buf. (GH 57280)

• Deprecated allowing non-keyword arguments in Series.to_string() except buf. (GH 57280)

• Deprecated behavior of Series.dt.to_pytimedelta(), in a future version this will return a Series containing python datetime.timedelta objects instead of an ndarray of timedelta; this matches the behavior of other Series.dt() properties. (GH 57463)

• Deprecated using epoch date format in DataFrame.to_json() and Series.to_json(), use iso instead. (GH 57063)

Removal of prior version deprecations/changes

• DataFrameGroupBy.idxmin, DataFrameGroupBy.idxmax, SeriesGroupBy.idxmin, and SeriesGroupBy.idxmax will now raise a ValueError when used with skipna=False and an NA value is encountered (GH 10694)

• concat() no longer ignores empty objects when determining output dtypes (GH 39122)

• concat() with all-NA entries no longer ignores the dtype of those entries when determining the result dtype (GH 40893)

• read_excel(), read_json(), read_html(), and read_xml() no longer accept raw string or byte representation of the data. That type of data must be wrapped in a StringIO or BytesIO (GH 53767)

• to_datetime() with a unit specified no longer parses strings into floats, instead parses them the same way as without unit (GH 50735)

• DataFrame.groupby() with as_index=False and aggregation methods will no longer exclude from the result the groupings that do not arise from the input (GH 49519)

• Series.dt.to_pydatetime() now returns a Series of datetime.datetime objects (GH 52459)

• SeriesGroupBy.agg() no longer pins the name of the group to the input passed to the provided func (GH 51703)

• All arguments except name in Index.rename() are now keyword only (GH 56493)

• All arguments except the first path-like argument in IO writers are now keyword only (GH 54229)

• Disallow allowing logical operations (||, &, ^) between pandas objects and dtype-less sequences (e.g. list, tuple); wrap the objects in Series, Index, or np.array first instead (GH 52264)

• Disallow automatic casting to object in Series logical operations (&, ^, ||) between series with mismatched indexes and dtypes other than object or bool (GH 52538)

• Disallow calling Series.replace() or DataFrame.replace() without a value and with non-dict-like to_replace (GH 33302)

• Disallow constructing a arrays.SparseArray with scalar data (GH 53039)

• Disallow indexing an Index with a boolean indexer of length zero, it now raises ValueError (GH 55820)

• Disallow non-standard (np.ndarray, Index, ExtensionArray, or Series) to isin(), unique(), factorize() (GH 52986)

• Disallow passing a pandas type to Index.view() (GH 55709)

• Disallow units other than “s”, “ms”, “us”, “ns” for datetime64 and timedelta64 dtypes in array() (GH 53817)

• Removed “freq” keyword from PeriodArray constructor, use “dtype” instead (GH 52462)

• Removed ‘fastpath’ keyword in Categorical constructor (GH 20110)

• Removed ‘kind’ keyword in Series.resample() and DataFrame.resample() (GH 58125)

• Removed alias arrays.PandasArray for arrays.NumpyExtensionArray (GH 53694)

• Removed deprecated “method” and “limit” keywords from Series.replace() and DataFrame.replace() (GH 53492)

• Removed extension test classes BaseNoReduceTests, BaseNumericReduceTests, BaseBooleanReduceTests (GH 54663)

• Removed the “closed” and “normalize” keywords in DatetimeIndex.__new__() (GH 52628)

• Require SparseDtype.fill_value() to be a valid value for the SparseDtype.subtype() (GH 53043)

• Stopped performing dtype inference with in Index.insert() with object-dtype index; this often affects the index/columns that result when setting new entries into an empty Series or DataFrame (GH 51363)

• Removed the “closed” and “unit” keywords in TimedeltaIndex.__new__() (GH 52628, GH 55499)

• All arguments in Index.sort_values() are now keyword only (GH 56493)

• All arguments in Series.to_dict() are now keyword only (GH 56493)

• Changed the default value of observed in DataFrame.groupby() and Series.groupby() to True (GH 51811)

• Enforce deprecation in testing.assert_series_equal() and testing.assert_frame_equal() with object dtype and mismatched null-like values, which are now considered not-equal (GH 18463)

• Enforced deprecation all and any reductions with datetime64, DatetimeTZDtype, and PeriodDtype dtypes (GH 58029)

• Enforced deprecation disallowing float “periods” in date_range(), period_range(), timedelta_range(), interval_range(), (GH 56036)

• Enforced deprecation disallowing parsing datetimes with mixed time zones unless user passes utc=True to to_datetime() (GH 57275)

• Enforced deprecation in Series.value_counts() and Index.value_counts() with object dtype performing dtype inference on the .index of the result (GH 56161)

• Enforced deprecation of DataFrameGroupBy.get_group() and SeriesGroupBy.get_group() allowing the name argument to be a non-tuple when grouping by a list of length 1 (GH 54155)

• Enforced deprecation of Series.interpolate() and DataFrame.interpolate() for object-dtype (GH 57820)

• Enforced deprecation of offsets.Tick.delta(), use pd.Timedelta(obj) instead (GH 55498)

• Enforced deprecation of axis=None acting the same as axis=0 in the DataFrame reductions sum, prod, std, var, and sem, passing axis=None will now reduce over both axes; this is particularly the case when doing e.g. numpy.sum(df) (GH 21597)

• Enforced deprecation of non-standard (np.ndarray, ExtensionArray, Index, or Series) argument to api.extensions.take() (GH 52981)

• Enforced deprecation of parsing system timezone strings to tzlocal, which depended on system timezone, pass the ‘tz’ keyword instead (GH 50791)

• Enforced deprecation of passing a dictionary to SeriesGroupBy.agg() (GH 52268)

• Enforced deprecation of string AS denoting frequency in YearBegin and strings AS-DEC, AS-JAN, etc. denoting annual frequencies with various fiscal year starts (GH 57793)

• Enforced deprecation of string A denoting frequency in YearEnd and strings A-DEC, A-JAN, etc. denoting annual frequencies with various fiscal year ends (GH 57699)

• Enforced deprecation of string BAS denoting frequency in BYearBegin and strings BAS-DEC, BAS-JAN, etc. denoting annual frequencies with various fiscal year starts (GH 57793)

• Enforced deprecation of string BA denoting frequency in BYearEnd and strings BA-DEC, BA-JAN, etc. denoting annual frequencies with various fiscal year ends (GH 57793)

• Enforced deprecation of strings T, L, U, and N denoting frequencies in Minute, Second, Milli, Micro, Nano (GH 57627)

• Enforced deprecation of strings T, L, U, and N denoting units in Timedelta (GH 57627)

• Enforced deprecation of the behavior of concat() when len(keys) != len(objs) would truncate to the shorter of the two. Now this raises a ValueError (GH 43485)

• Enforced deprecation of values “pad”, “ffill”, “bfill”, and “backfill” for Series.interpolate() and DataFrame.interpolate() (GH 57869)

• Enforced deprecation removing Categorical.to_list(), use obj.tolist() instead (GH 51254)

• Enforced silent-downcasting deprecation for all relevant methods (GH 54710)

• In DataFrame.stack(), the default value of future_stack is now True; specifying False will raise a FutureWarning (GH 55448)

• Iterating over a DataFrameGroupBy or SeriesGroupBy will return tuples of length 1 for the groups when grouping by level a list of length 1 (GH 50064)

• Methods apply, agg, and transform will no longer replace NumPy functions (e.g. np.sum) and built-in functions (e.g. min) with the equivalent pandas implementation; use string aliases (e.g. "sum" and "min") if you desire to use the pandas implementation (GH 53974)

• Passing both freq and fill_value in DataFrame.shift() and Series.shift() and DataFrameGroupBy.shift() now raises a ValueError (GH 54818)

• Removed DataFrameGroupBy.quantile() and SeriesGroupBy.quantile() supporting bool dtype (GH 53975)

• Removed DateOffset.is_anchored() and offsets.Tick.is_anchored() (GH 56594)

• Removed DataFrame.applymap, Styler.applymap and Styler.applymap_index (GH 52364)

• Removed DataFrame.bool and Series.bool (GH 51756)

• Removed DataFrame.first and DataFrame.last (GH 53710)

• Removed DataFrame.swapaxes and Series.swapaxes (GH 51946)

• Removed DataFrameGroupBy.grouper and SeriesGroupBy.grouper (GH 56521)

• Removed DataFrameGroupby.fillna and SeriesGroupBy.fillna` (GH 55719)

• Removed Index.format, use Index.astype() with str or Index.map() with a formatter function instead (GH 55439)

• Removed Resample.fillna (GH 55719)

• Removed Series.__int__ and Series.__float__. Call int(Series.iloc[0]) or float(Series.iloc[0]) instead. (GH 51131)

• Removed Series.ravel (GH 56053)

• Removed Series.view (GH 56054)

• Removed StataReader.close (GH 49228)

• Removed _data from DataFrame, Series, arrays.ArrowExtensionArray (GH 52003)

• Removed axis argument from DataFrame.groupby(), Series.groupby(), DataFrame.rolling(), Series.rolling(), DataFrame.resample(), and Series.resample() (GH 51203)

• Removed axis argument from all groupby operations (GH 50405)

• Removed convert_dtype from Series.apply() (GH 52257)

• Removed method, limit fill_axis and broadcast_axis keywords from DataFrame.align() (GH 51968)

• Removed pandas.api.types.is_interval and pandas.api.types.is_period, use isinstance(obj, pd.Interval) and isinstance(obj, pd.Period) instead (GH 55264)

• Removed pandas.io.sql.execute (GH 50185)

• Removed pandas.value_counts, use Series.value_counts() instead (GH 53493)

• Removed read_gbq and DataFrame.to_gbq. Use pandas_gbq.read_gbq and pandas_gbq.to_gbq instead https://pandas-gbq.readthedocs.io/en/latest/api.html (GH 55525)

• Removed use_nullable_dtypes from read_parquet() (GH 51853)

• Removed year, month, quarter, day, hour, minute, and second keywords in the PeriodIndex constructor, use PeriodIndex.from_fields() instead (GH 55960)

• Removed argument limit from DataFrame.pct_change(), Series.pct_change(), DataFrameGroupBy.pct_change(), and SeriesGroupBy.pct_change(); the argument method must be set to None and will be removed in a future version of pandas (GH 53520)

• Removed deprecated argument obj in DataFrameGroupBy.get_group() and SeriesGroupBy.get_group() (GH 53545)

• Removed deprecated behavior of Series.agg() using Series.apply() (GH 53325)

• Removed deprecated keyword method on Series.fillna(), DataFrame.fillna() (GH 57760)

• Removed option mode.use_inf_as_na, convert inf entries to NaN before instead (GH 51684)

• Removed support for DataFrame in DataFrame.from_records`(:issue:`51697())

• Removed support for errors="ignore" in to_datetime(), to_timedelta() and to_numeric() (GH 55734)

• Removed support for slice in DataFrame.take() (GH 51539)

• Removed the ArrayManager (GH 55043)

• Removed the fastpath argument from the Series constructor (GH 55466)

• Removed the is_boolean, is_integer, is_floating, holds_integer, is_numeric, is_categorical, is_object, and is_interval attributes of Index (GH 50042)

• Removed the ordinal keyword in PeriodIndex, use PeriodIndex.from_ordinals() instead (GH 55960)

• Removed unused arguments *args and **kwargs in Resampler methods (GH 50977)

• Unrecognized timezones when parsing strings to datetimes now raises a ValueError (GH 51477)

• Removed the Grouper attributes ax, groups, indexer, and obj (GH 51206, GH 51182)

• Removed deprecated keyword verbose on read_csv() and read_table() (GH 56556)

• Removed the method keyword in ExtensionArray.fillna, implement ExtensionArray._pad_or_backfill instead (GH 53621)

• Removed the attribute dtypes from DataFrameGroupBy (GH 51997)

• Enforced deprecation of argmin, argmax, idxmin, and idxmax returning a result when skipna=False and an NA value is encountered or all values are NA values; these operations will now raise in such cases (GH 33941, GH 51276)

Performance improvements

• Categorical.categories returns a RangeIndex columns instead of an Index if the constructed values was a range. (GH 57787)

• DataFrame returns a RangeIndex columns when possible when data is a dict (GH 57943)

• Series returns a RangeIndex index when possible when data is a dict (GH 58118)

• concat() returns a RangeIndex column when possible when objs contains Series and DataFrame and axis=0 (GH 58119)

• concat() returns a RangeIndex level in the MultiIndex result when keys is a range or RangeIndex (GH 57542)

• RangeIndex.append() returns a RangeIndex instead of a Index when appending values that could continue the RangeIndex (GH 57467)

• Series.str.extract() returns a RangeIndex columns instead of an Index column when possible (GH 57542)

• Series.str.partition() with ArrowDtype returns a RangeIndex columns instead of an Index column when possible (GH 57768)

• Performance improvement in DataFrame when data is a dict and columns is specified (GH 24368)

• Performance improvement in DataFrame.join() for sorted but non-unique indexes (GH 56941)

• Performance improvement in DataFrame.join() when left and/or right are non-unique and how is "left", "right", or "inner" (GH 56817)

• Performance improvement in DataFrame.join() with how="left" or how="right" and sort=True (GH 56919)

• Performance improvement in DataFrameGroupBy.ffill(), DataFrameGroupBy.bfill(), SeriesGroupBy.ffill(), and SeriesGroupBy.bfill() (GH 56902)

• Performance improvement in Index.join() by propagating cached attributes in cases where the result matches one of the inputs (GH 57023)

• Performance improvement in Index.take() when indices is a full range indexer from zero to length of index (GH 56806)

• Performance improvement in Index.to_frame() returning a RangeIndex columns of a Index when possible. (GH 58018)

• Performance improvement in MultiIndex.equals() for equal length indexes (GH 56990)

• Performance improvement in MultiIndex.memory_usage() to ignore the index engine when it isn’t already cached. (GH 58385)

• Performance improvement in RangeIndex.__getitem__() with a boolean mask or integers returning a RangeIndex instead of a Index when possible. (GH 57588)

• Performance improvement in RangeIndex.append() when appending the same index (GH 57252)

• Performance improvement in RangeIndex.argmin() and RangeIndex.argmax() (GH 57823)

• Performance improvement in RangeIndex.insert() returning a RangeIndex instead of a Index when the RangeIndex is empty. (GH 57833)

• Performance improvement in RangeIndex.round() returning a RangeIndex instead of a Index when possible. (GH 57824)

• Performance improvement in RangeIndex.join() returning a RangeIndex instead of a Index when possible. (GH 57651, GH 57752)

• Performance improvement in RangeIndex.reindex() returning a RangeIndex instead of a Index when possible. (GH 57647, GH 57752)

• Performance improvement in RangeIndex.take() returning a RangeIndex instead of a Index when possible. (GH 57445, GH 57752)

• Performance improvement in merge() if hash-join can be used (GH 57970)

• Performance improvement in to_hdf() avoid unnecessary reopenings of the HDF5 file to speedup data addition to files with a very large number of groups . (GH 58248)

• Performance improvement in DataFrameGroupBy.__len__ and SeriesGroupBy.__len__ (GH 57595)

• Performance improvement in indexing operations for string dtypes (GH 56997)

• Performance improvement in unary methods on a RangeIndex returning a RangeIndex instead of a Index when possible. (GH 57825)

Bug fixes

Categorical

Datetimelike

• Bug in Timestamp constructor failing to raise when tz=None is explicitly specified in conjunction with timezone-aware tzinfo or data (GH 48688)

• Bug in date_range() where the last valid timestamp would sometimes not be produced (GH 56134)

• Bug in date_range() where using a negative frequency value would not include all points between the start and end values (GH 56382)

• Bug in tseries.api.guess_datetime_format() would fail to infer time format when “%Y” == “%H%M” (GH 57452)

• Bug in setting scalar values with mismatched resolution into arrays with non-nanosecond datetime64, timedelta64 or DatetimeTZDtype incorrectly truncating those scalars (GH 56410)

Timedelta

• Accuracy improvement in Timedelta.to_pytimedelta() to round microseconds consistently for large nanosecond based Timedelta (GH 57841)

• Bug in DataFrame.cumsum() which was raising IndexError if dtype is timedelta64[ns] (GH 57956)

Timezones

Numeric

• Bug in np.matmul with Index inputs raising a TypeError (GH 57079)

Conversion

• Bug in DataFrame.update() bool dtype being converted to object (GH 55509)

• Bug in Series.astype() might modify read-only array inplace when casting to a string dtype (GH 57212)

• Bug in Series.reindex() not maintaining float32 type when a reindex introduces a missing value (GH 45857)

Strings

• Bug in Series.value_counts() would not respect sort=False for series having string dtype (GH 55224)

Interval

• Bug in interval_range() where start and end numeric types were always cast to 64 bit (GH 57268)

Indexing

• Bug in DataFrame.__getitem__() returning modified columns when called with slice in Python 3.12 (GH 57500)

Missing

MultiIndex

• DataFrame.loc() with axis=0 and MultiIndex when setting a value adds extra columns (GH 58116)

I/O

• Bug in DataFrame and Series repr of collections.abc.Mapping` elements. (GH 57915)

• Bug in DataFrame.to_dict() raises unnecessary UserWarning when columns are not unique and orient='tight'. (GH 58281)

• Bug in DataFrame.to_excel() when writing empty DataFrame with MultiIndex on both axes (GH 57696)

• Bug in DataFrame.to_string() that raised StopIteration with nested DataFrames. (GH 16098)

• Bug in read_csv() raising TypeError when index_col is specified and na_values is a dict containing the key None. (GH 57547)

Period

Plotting

• Bug in DataFrameGroupBy.boxplot() failed when there were multiple groupings (GH 14701)

• Bug in DataFrame.plot() that causes a shift to the right when the frequency multiplier is greater than one. (GH 57587)

Groupby/resample/rolling

• Bug in DataFrameGroupBy.groups() and SeriesGroupby.groups() that would not respect groupby argument dropna (GH 55919)

• Bug in DataFrameGroupBy.median() where nat values gave an incorrect result. (GH 57926)

• Bug in DataFrameGroupBy.quantile() when interpolation="nearest" is inconsistent with DataFrame.quantile() (GH 47942)

• Bug in Resampler.interpolate() on a DataFrame with non-uniform sampling and/or indices not aligning with the resulting resampled index would result in wrong interpolation (GH 21351)

• Bug in DataFrame.ewm() and Series.ewm() when passed times and aggregation functions other than mean (GH 51695)

• Bug in DataFrameGroupBy.apply() that was returning a completely empty DataFrame when all return values of func were None instead of returning an empty DataFrame with the original columns and dtypes. (GH 57775)

Reshaping

• Bug in DataFrame.join() inconsistently setting result index name (GH 55815)

Sparse

• Bug in SparseDtype for equal comparison with na fill value. (GH 54770)

ExtensionArray

• Bug in api.types.is_datetime64_any_dtype() where a custom ExtensionDtype would return False for array-likes (GH 57055)

Styler

Other

• Bug in DataFrame when passing a dict with a NA scalar and columns that would always return np.nan (GH 57205)

• Bug in unique() on Index not always returning Index (GH 57043)

• Bug in DataFrame.eval() and DataFrame.query() which caused an exception when using NumPy attributes via @ notation, e.g., df.eval("@np.floor(a)"). (GH 58041)

• Bug in DataFrame.eval() and DataFrame.query() which did not allow to use tan function. (GH 55091)

• Bug in DataFrame.sort_index() when passing axis="columns" and ignore_index=True and ascending=False not returning a RangeIndex columns (GH 57293)

• Bug in DataFrame.transform() that was returning the wrong order unless the index was monotonically increasing. (GH 57069)

• Bug in DataFrame.where() where using a non-bool type array in the function would return a ValueError instead of a TypeError (GH 56330)

• Bug in Index.sort_values() when passing a key function that turns values into tuples, e.g. key=natsort.natsort_key, would raise TypeError (GH 56081)

• Bug in Series.diff() allowing non-integer values for the periods argument. (GH 56607)

• Bug in Series.rank() that doesn’t preserve missing values for nullable integers when na_option='keep'. (GH 56976)

• Bug in Series.replace() and DataFrame.replace() inconsistently replacing matching instances when regex=True and missing values are present. (GH 56599)

• Bug in Dataframe Interchange Protocol implementation was returning incorrect results for data buffers’ associated dtype, for string and datetime columns (GH 54781)

Contributors