Merge branch 'pandas-dev:main' into strict-fix

Author: Unkwn1

ci/code_checks.sh

@@ -79,6 +79,8 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.api.typing.DataFrameGroupBy.plot PR02" \
         -i "pandas.api.typing.SeriesGroupBy.plot PR02" \
         -i "pandas.api.typing.Resampler.quantile PR01,PR07" \
+        -i "pandas.StringDtype.storage SA01" \
+        -i "pandas.StringDtype.na_value SA01" \
         -i "pandas.tseries.offsets.BDay PR02,SA01" \
         -i "pandas.tseries.offsets.BHalfYearBegin.is_on_offset GL08" \
         -i "pandas.tseries.offsets.BHalfYearBegin.n GL08" \

doc/source/reference/arrays.rst

@@ -637,6 +637,8 @@ with a bool :class:`numpy.ndarray`.
       DatetimeTZDtype.tz
       PeriodDtype.freq
       IntervalDtype.subtype
+      StringDtype.storage
+      StringDtype.na_value
 
 *********
 Utilities

doc/source/user_guide/indexing.rst

@@ -431,6 +431,36 @@ an error will be raised. For instance, in the above example, ``s.loc[2:5]`` woul
 For more information about duplicate labels, see
 :ref:`Duplicate Labels <duplicates>`.
 
+When using a slice with a step, such as ``.loc[start:stop:step]``, note that
+*start* and *stop* are interpreted as **labels**, while *step* is applied over
+the **positional index** within that label range. This means a stepped slice
+will behave differently than using the labels ``range(start, stop, step)`` when
+the index is not contiguous integers.
+
+For example, in a ``Series`` with a non-contiguous integer index:
+
+.. ipython:: python
+
+    s = pd.Series(range(10), index=[0, 5, 10, 15, 20, 25, 30, 35, 40, 45])
+    s.loc[10:50:5]              # (10), then skip 3 positions → 35 only
+    s.loc[[10, 15, 20, 25]]     # explicit label selection
+
+The first applies *step* across **positional locations** between the start/stop
+labels. The second selects each label directly.
+
+Similarly, with a string-based index, the behavior is identical:
+
+.. ipython:: python
+
+    s = pd.Series(range(10), index=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'])
+    s.loc['b':'i':2]            # Start at 'b' (position 1), stop at 'i' (position 8), step 2 positions → 'b', 'd', 'f', 'h'
+    s.loc[['b', 'd', 'f', 'h']] # explicit label selection
+
+In both cases, *start* and *stop* determine the label boundaries (inclusive),
+while *step* skips positions within that range, regardless of the index type.
+
+
+
 .. _indexing.integer:
 
 Selection by position

doc/source/user_guide/migration-3-strings.rst

@@ -20,6 +20,14 @@ enable it with:
 
 This allows you to test your code before the final 3.0 release.
 
+.. note::
+
+   This migration guide focuses on the changes and migration steps needed when
+   you are currently using ``object`` dtype for string data, which is used by
+   default in pandas < 3.0. If you are already using one of the opt-in string
+   dtypes, you can continue to do so without change.
+   See :ref:`string_migration_guide-for_existing_users` for more details.
+
 Background
 ----------
 
@@ -457,7 +465,23 @@ raise an error regardless of the number of strings:
    ...
    TypeError: Cannot perform reduction 'prod' with string dtype
 
-.. For existing users of the nullable ``StringDtype``
-.. --------------------------------------------------
 
-.. TODO
+.. _string_migration_guide-for_existing_users:
+
+For existing users of the nullable ``StringDtype``
+--------------------------------------------------
+
+While pandas 3.0 introduces a new _default_ string data type, pandas had an
+opt-in nullable string data type since pandas 1.0, which can be specified using
+``dtype="string"``. This nullable string dtype uses ``pd.NA`` as the missing
+value indicator. In addition, also through :class:`ArrowDtype` (by using
+``dtypes_backend="pyarrow"``) since pandas 1.5, one could already make use of
+a dedicated string dtype.
+
+If you are already using one of the nullable string dtypes, for example by
+specifying ``dtype="string"``, by using :meth:`~DataFrame.convert_dtypes`, or
+by specifying the ``dtype_backend`` argument in IO functions, you can continue
+to do so without change.
+
+The migration guide above applies to code that is currently (< 3.0) using object
+dtype for string data.

doc/source/user_guide/text.rst

@@ -753,7 +753,10 @@ Differences in behavior will be primarily due to the kind of NA value.
 The four :class:`StringDtype` variants
 ======================================
 
-There are four :class:`StringDtype` variants that are available to users.
+There are four :class:`StringDtype` variants that are available to users,
+controlled by the ``storage`` and ``na_value`` parameters of :class:`StringDtype`.
+At runtime, these can be checked via the :attr:`StringDtype.storage`
+and :attr:`StringDtype.na_value` attributes.
 
 Python storage with ``np.nan`` values
 -------------------------------------

doc/source/whatsnew/v3.0.0.rst

@@ -6,6 +6,14 @@ What's new in 3.0.0 (Month XX, 2025)
 These are the changes in pandas 3.0.0. See :ref:`release` for a full changelog
 including other versions of pandas.
 
+.. note::
+
+    The pandas 3.0 release removed a lot of functionality that was deprecated
+    in previous releases (see :ref:`below <whatsnew_300.prior_deprecations>`
+    for an overview). It is recommended to first upgrade to pandas 2.3 and to
+    ensure your code is working without warnings, before upgrading to pandas
+    3.0.
+
 {{ header }}
 
 .. ---------------------------------------------------------------------------

pandas/core/arrays/string_.py

@@ -119,7 +119,8 @@ class StringDtype(StorageExtensionDtype):
 
     Attributes
     ----------
-    None
+    storage
+    na_value
 
     Methods
     -------
@@ -149,8 +150,40 @@ def name(self) -> str:  # type: ignore[override]
     # follows NumPy semantics, which uses nan.
     @property
     def na_value(self) -> libmissing.NAType | float:  # type: ignore[override]
+        """
+        The missing value representation for this dtype.
+
+        This value indicates which missing value semantics are used by this dtype.
+        Returns ``np.nan`` for the default string dtype with NumPy semantics,
+        and ``pd.NA`` for the opt-in string dtype with pandas NA semantics.
+
+        Examples
+        --------
+        >>> ser = pd.Series(["a", "b"])
+        >>> ser.dtype
+        <StringDtype(na_value=nan)>
+        >>> ser.dtype.na_value
+        nan
+        """
         return self._na_value
 
+    @property
+    def storage(self) -> str:
+        """
+        The storage backend for this dtype.
+
+        Can be either "pyarrow" or "python".
+
+        Examples
+        --------
+        >>> ser = pd.Series(["a", "b"])
+        >>> ser.dtype
+        <StringDtype(na_value=nan)>
+        >>> ser.dtype.storage
+        'pyarrow'
+        """
+        return self._storage
+
     _metadata = ("storage", "_na_value")  # type: ignore[assignment]
 
     def __init__(
@@ -185,7 +218,7 @@ def __init__(
         elif na_value is not libmissing.NA:
             raise ValueError(f"'na_value' must be np.nan or pd.NA, got {na_value}")
 
-        self.storage = cast(str, storage)
+        self._storage = cast(str, storage)
         self._na_value = na_value
 
     def __repr__(self) -> str:
@@ -211,7 +244,7 @@ def __eq__(self, other: object) -> bool:
 
     def __setstate__(self, state: MutableMapping[str, Any]) -> None:
         # back-compat for pandas < 2.3, where na_value did not yet exist
-        self.storage = state.pop("storage", "python")
+        self._storage = state.pop("storage", "python")
         self._na_value = state.pop("_na_value", libmissing.NA)
 
     def __hash__(self) -> int:
@@ -306,7 +339,7 @@ def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
             # if both python and pyarrow storage -> priority to pyarrow
             storage = "pyarrow"
         else:
-            storage = next(iter(storages))  # type: ignore[assignment]
+            storage = next(iter(storages))
 
         na_value: libmissing.NAType | float
         if len(na_values) == 2:

pandas/core/col.py

@@ -37,6 +37,12 @@
     "__lt__": "<",
     "__eq__": "==",
     "__ne__": "!=",
+    "__and__": "&",
+    "__rand__": "&",
+    "__or__": "|",
+    "__ror__": "|",
+    "__xor__": "^",
+    "__rxor__": "^",
 }
 
 
@@ -157,6 +163,28 @@ def __mod__(self, other: Any) -> Expression:
     def __rmod__(self, other: Any) -> Expression:
         return self._with_binary_op("__rmod__", other)
 
+    # Logical ops
+    def __and__(self, other: Any) -> Expression:
+        return self._with_binary_op("__and__", other)
+
+    def __rand__(self, other: Any) -> Expression:
+        return self._with_binary_op("__rand__", other)
+
+    def __or__(self, other: Any) -> Expression:
+        return self._with_binary_op("__or__", other)
+
+    def __ror__(self, other: Any) -> Expression:
+        return self._with_binary_op("__ror__", other)
+
+    def __xor__(self, other: Any) -> Expression:
+        return self._with_binary_op("__xor__", other)
+
+    def __rxor__(self, other: Any) -> Expression:
+        return self._with_binary_op("__rxor__", other)
+
+    def __invert__(self) -> Expression:
+        return Expression(lambda df: ~self(df), f"(~{self._repr_str})")
+
     def __array_ufunc__(
         self, ufunc: Callable[..., Any], method: str, *inputs: Any, **kwargs: Any
     ) -> Expression:

pandas/core/dtypes/base.py

@@ -457,8 +457,8 @@ class StorageExtensionDtype(ExtensionDtype):
     name: str
     _metadata = ("storage",)
 
-    def __init__(self, storage: str | None = None) -> None:
-        self.storage = storage
+    def __init__(self, storage: str) -> None:
+        self._storage = storage
 
     def __repr__(self) -> str:
         return f"{self.name}[{self.storage}]"
@@ -479,6 +479,10 @@ def __hash__(self) -> int:
     def na_value(self) -> libmissing.NAType:
         return libmissing.NA
 
+    @property
+    def storage(self) -> str:
+        return self._storage
+
 
 @set_module("pandas.api.extensions")
 def register_extension_dtype(cls: type_t[ExtensionDtypeT]) -> type_t[ExtensionDtypeT]:

pandas/core/series.py

@@ -265,8 +265,14 @@ class Series(base.IndexOpsMixin, NDFrame):  # type: ignore[misc]
         See the :ref:`user guide <basics.dtypes>` for more usages.
     name : Hashable, default None
         The name to give to the Series.
-    copy : bool, default False
-        Copy input data. Only affects Series or 1d ndarray input. See examples.
+    copy : bool, default None
+        Whether to copy input data, only relevant for array, Series, and Index
+        inputs (for other input, e.g. a list, a new array is created anyway).
+        Defaults to True for array input and False for Index/Series.
+        Even when False for Index/Series, a shallow copy of the data is made.
+        Set to False to avoid copying array input at your own risk (if you
+        know the input data won't be modified elsewhere).
+        Set to True to force copying Series/Index input up front.
 
     See Also
     --------