Merge branch 'master' into bug-is_matching_na

Author: jbrockmendel

doc/source/user_guide/style.ipynb

@@ -140,9 +140,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "s = df.style.set_table_attributes('class=\"table-cls\"')\n",
-    "cls = pd.DataFrame(data=[['cls1', None], ['cls3', 'cls2 cls3']], index=[0,2], columns=['A', 'C'])\n",
-    "s.set_td_classes(cls)"
+    "css_classes = pd.DataFrame(data=[['cls1', None], ['cls3', 'cls2 cls3']], index=[0,2], columns=['A', 'C'])\n",
+    "df.style.\\\n",
+    "    set_table_attributes('class=\"table-cls\"').\\\n",
+    "    set_td_classes(css_classes)"
    ]
   },
   {
@@ -314,13 +315,10 @@
    "outputs": [],
    "source": [
     "def color_negative_red(val):\n",
-    "    \"\"\"\n",
-    "    Takes a scalar and returns a string with\n",
-    "    the css property `'color: red'` for negative\n",
-    "    strings, black otherwise.\n",
-    "    \"\"\"\n",
-    "    color = 'red' if val < 0 else 'black'\n",
-    "    return 'color: %s' % color"
+    "    \"\"\"Color negative scalars red.\"\"\"\n",
+    "    css = 'color: red;'\n",
+    "    if val < 0: return css\n",
+    "    return None"
    ]
   },
   {
@@ -368,11 +366,9 @@
    "outputs": [],
    "source": [
     "def highlight_max(s):\n",
-    "    '''\n",
-    "    highlight the maximum in a Series yellow.\n",
-    "    '''\n",
-    "    is_max = s == s.max()\n",
-    "    return ['background-color: yellow' if v else '' for v in is_max]"
+    "    \"\"\"Highlight the maximum in a Series bold-orange.\"\"\"\n",
+    "    css = 'background-color: orange; font-weight: bold;'\n",
+    "    return np.where(s == np.nanmax(s.values), css, None)"
    ]
   },
   {
@@ -384,11 +380,20 @@
     "df.style.apply(highlight_max)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.style.apply(highlight_max, axis=1)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In this case the input is a `Series`, one column at a time.\n",
+    "In this case the input is a `Series`, one column (or row) at a time.\n",
     "Notice that the output shape of `highlight_max` matches the input shape, an array with `len(s)` items."
    ]
   },
@@ -406,8 +411,8 @@
    "outputs": [],
    "source": [
     "def compare_col(s, comparator=None):\n",
-    "    attr = 'background-color: #00BFFF;'\n",
-    "    return np.where(s < comparator, attr, '')"
+    "    css = 'background-color: #00BFFF;'\n",
+    "    return np.where(s < comparator, css, None)"
    ]
   },
   {
@@ -442,41 +447,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Above we used `Styler.apply` to pass in each column one at a time.\n",
+    "Above we used `Styler.apply` to pass in each column (or row) one at a time.\n",
     "\n",
     "<span style=\"background-color: #DEDEBE\">*Debugging Tip*: If you're having trouble writing your style function, try just passing it into <code style=\"background-color: #DEDEBE\">DataFrame.apply</code>. Internally, <code style=\"background-color: #DEDEBE\">Styler.apply</code> uses <code style=\"background-color: #DEDEBE\">DataFrame.apply</code> so the result should be the same.</span>\n",
     "\n",
     "What if you wanted to highlight just the maximum value in the entire table?\n",
-    "Use `.apply(function, axis=None)` to indicate that your function wants the entire table, not one column or row at a time. Let's try that next.\n",
-    "\n",
-    "We'll rewrite our `highlight-max` to handle either Series (from `.apply(axis=0 or 1)`) or DataFrames (from `.apply(axis=None)`). We'll also allow the color to be adjustable, to demonstrate that `.apply`, and `.applymap` pass along keyword arguments."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def highlight_max(data, color='yellow'):\n",
-    "    '''\n",
-    "    highlight the maximum in a Series or DataFrame\n",
-    "    '''\n",
-    "    attr = 'background-color: {}'.format(color)\n",
-    "    if data.ndim == 1:  # Series from .apply(axis=0) or axis=1\n",
-    "        is_max = data == data.max()\n",
-    "        return [attr if v else '' for v in is_max]\n",
-    "    else:  # from .apply(axis=None)\n",
-    "        is_max = data == data.max().max()\n",
-    "        return pd.DataFrame(np.where(is_max, attr, ''),\n",
-    "                            index=data.index, columns=data.columns)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "When using ``Styler.apply(func, axis=None)``, the function must return a DataFrame with the same index and column labels."
+    "Use `.apply(function, axis=None)` to indicate that your function wants the entire table, not one column or row at a time. In this case the return must be a DataFrame or ndarray of the same shape as the input. Let's try that next. "
    ]
   },
   {
@@ -485,7 +461,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "s = df.style.apply(highlight_max, color='darkorange', axis=None)\n",
+    "s = df.style.apply(highlight_max, axis=None)\n",
     "s"
    ]
   },

doc/source/whatsnew/index.rst

@@ -24,6 +24,7 @@ Version 1.2
 .. toctree::
    :maxdepth: 2
 
+   v1.2.3
    v1.2.2
    v1.2.1
    v1.2.0

doc/source/whatsnew/v1.2.2.rst

@@ -46,4 +46,4 @@ Bug fixes
 Contributors
 ~~~~~~~~~~~~
 
-.. contributors:: v1.2.1..v1.2.2|HEAD
+.. contributors:: v1.2.1..v1.2.2

doc/source/whatsnew/v1.2.3.rst

@@ -0,0 +1,48 @@
+.. _whatsnew_123:
+
+What's new in 1.2.3 (March ??, 2021)
+------------------------------------
+
+These are the changes in pandas 1.2.3. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_123.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+
+-
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_123.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+
+-
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_123.other:
+
+Other
+~~~~~
+
+-
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_123.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.2.2..v1.2.3|HEAD

doc/source/whatsnew/v1.3.0.rst

@@ -53,8 +53,9 @@ Other enhancements
 - :meth:`DataFrame.apply` can now accept non-callable DataFrame properties as strings, e.g. ``df.apply("size")``, which was already the case for :meth:`Series.apply` (:issue:`39116`)
 - :meth:`Series.apply` can now accept list-like or dictionary-like arguments that aren't lists or dictionaries, e.g. ``ser.apply(np.array(["sum", "mean"]))``, which was already the case for :meth:`DataFrame.apply` (:issue:`39140`)
 - :meth:`DataFrame.plot.scatter` can now accept a categorical column as the argument to ``c`` (:issue:`12380`, :issue:`31357`)
-- :meth:`.Styler.set_tooltips` allows on hover tooltips to be added to styled HTML dataframes (:issue:`35643`)
+- :meth:`.Styler.set_tooltips` allows on hover tooltips to be added to styled HTML dataframes (:issue:`35643`, :issue:`21266`, :issue:`39317`)
 - :meth:`.Styler.set_tooltips_class` and :meth:`.Styler.set_table_styles` amended to optionally allow certain css-string input arguments (:issue:`39564`)
+- :meth:`.Styler.apply` now more consistently accepts ndarray function returns, i.e. in all cases for ``axis`` is ``0, 1 or None``. (:issue:`39359`)
 - :meth:`Series.loc.__getitem__` and :meth:`Series.loc.__setitem__` with :class:`MultiIndex` now raising helpful error message when indexer has too many dimensions (:issue:`35349`)
 - :meth:`pandas.read_stata` and :class:`StataReader` support reading data from compressed files.
 

environment.yml

@@ -114,4 +114,4 @@ dependencies:
   - natsort  # DataFrame.sort_values
   - pip:
     - git+https://github.com/pandas-dev/pydata-sphinx-theme.git@2488b7defbd3d753dd5fcfc890fc4a7e79d25103
-    - git+https://github.com/numpy/numpydoc
+    - numpydoc < 1.2  # 2021-02-09 1.2dev breaking CI

pandas/core/indexes/base.py

@@ -3398,7 +3398,7 @@ def _get_fill_indexer(
         else:
             indexer = self._get_fill_indexer_searchsorted(target, method, limit)
         if tolerance is not None and len(self):
-            indexer = self._filter_indexer_tolerance(target._values, indexer, tolerance)
+            indexer = self._filter_indexer_tolerance(target_values, indexer, tolerance)
         return indexer
 
     @final
@@ -3448,15 +3448,10 @@ def _get_nearest_indexer(self, target: Index, limit, tolerance) -> np.ndarray:
         left_indexer = self.get_indexer(target, "pad", limit=limit)
         right_indexer = self.get_indexer(target, "backfill", limit=limit)
 
-        target_values = target._values
-        # error: Unsupported left operand type for - ("ExtensionArray")
-        left_distances = np.abs(
-            self._values[left_indexer] - target_values  # type: ignore[operator]
-        )
-        # error: Unsupported left operand type for - ("ExtensionArray")
-        right_distances = np.abs(
-            self._values[right_indexer] - target_values  # type: ignore[operator]
-        )
+        target_values = target._get_engine_target()
+        own_values = self._get_engine_target()
+        left_distances = np.abs(own_values[left_indexer] - target_values)
+        right_distances = np.abs(own_values[right_indexer] - target_values)
 
         op = operator.lt if self.is_monotonic_increasing else operator.le
         indexer = np.where(
@@ -3475,8 +3470,8 @@ def _filter_indexer_tolerance(
         indexer: np.ndarray,
         tolerance,
     ) -> np.ndarray:
-        # error: Unsupported left operand type for - ("ExtensionArray")
-        distance = abs(self._values[indexer] - target)  # type: ignore[operator]
+        own_values = self._get_engine_target()
+        distance = abs(own_values[indexer] - target)
         return np.where(distance <= tolerance, indexer, -1)
 
     # --------------------------------------------------------------------

pandas/core/indexes/datetimelike.py

@@ -231,10 +231,7 @@ def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
 
     def _convert_tolerance(self, tolerance, target):
         tolerance = np.asarray(to_timedelta(tolerance).to_numpy())
-
-        if target.size != tolerance.size and tolerance.size > 1:
-            raise ValueError("list-like tolerance size must match target index size")
-        return tolerance
+        return super()._convert_tolerance(tolerance, target)
 
     def tolist(self) -> List:
         """

pandas/core/indexes/numeric.py

@@ -119,9 +119,8 @@ def _shallow_copy(self, values, name: Hashable = lib.no_default):
         return super()._shallow_copy(values=values, name=name)
 
     def _convert_tolerance(self, tolerance, target):
-        tolerance = np.asarray(tolerance)
-        if target.size != tolerance.size and tolerance.size > 1:
-            raise ValueError("list-like tolerance size must match target index size")
+        tolerance = super()._convert_tolerance(tolerance, target)
+
         if not np.issubdtype(tolerance.dtype, np.number):
             if tolerance.ndim > 0:
                 raise ValueError(

pandas/core/indexes/period.py

@@ -11,7 +11,7 @@
 from pandas._libs.tslibs.parsing import DateParseError, parse_time_string
 from pandas._typing import Dtype, DtypeObj
 from pandas.errors import InvalidIndexError
-from pandas.util._decorators import cache_readonly, doc
+from pandas.util._decorators import doc
 
 from pandas.core.dtypes.common import (
     is_bool_dtype,
@@ -324,10 +324,6 @@ def __contains__(self, key: Any) -> bool:
             except KeyError:
                 return False
 
-    @cache_readonly
-    def _int64index(self) -> Int64Index:
-        return Int64Index._simple_new(self.asi8, name=self.name)
-
     # ------------------------------------------------------------------------
     # Index Methods
 
@@ -424,24 +420,18 @@ def inferred_type(self) -> str:
     # ------------------------------------------------------------------------
     # Indexing Methods
 
-    def _get_indexer(self, target: Index, method=None, limit=None, tolerance=None):
-
-        if not self._should_compare(target):
-            return self._get_indexer_non_comparable(target, method, unique=True)
-
-        if isinstance(target, PeriodIndex):
-            target = target._int64index  # i.e. target.asi8
-            self_index = self._int64index
-        else:
-            self_index = self
+    def _convert_tolerance(self, tolerance, target):
+        # Returned tolerance must be in dtype/units so that
+        #  `|self._get_engine_target() - target._engine_target()| <= tolerance`
+        #  is meaningful.  Since PeriodIndex returns int64 for engine_target,
+        #  we may need to convert timedelta64 tolerance to int64.
+        tolerance = super()._convert_tolerance(tolerance, target)
 
-        if tolerance is not None:
-            tolerance = self._convert_tolerance(tolerance, target)
-            if self_index is not self:
-                # convert tolerance to i8
-                tolerance = self._maybe_convert_timedelta(tolerance)
+        if self.dtype == target.dtype:
+            # convert tolerance to i8
+            tolerance = self._maybe_convert_timedelta(tolerance)
 
-        return Index._get_indexer(self_index, target, method, limit, tolerance)
+        return tolerance
 
     def get_loc(self, key, method=None, tolerance=None):
         """
@@ -579,14 +569,6 @@ def _get_string_slice(self, key: str):
         except KeyError as err:
             raise KeyError(key) from err
 
-    # ------------------------------------------------------------------------
-
-    def memory_usage(self, deep: bool = False) -> int:
-        result = super().memory_usage(deep=deep)
-        if hasattr(self, "_cache") and "_int64index" in self._cache:
-            result += self._int64index.memory_usage(deep=deep)
-        return result
-
 
 def period_range(
     start=None, end=None, periods: Optional[int] = None, freq=None, name=None

pandas/core/indexes/range.py

@@ -3,7 +3,7 @@
 from datetime import timedelta
 import operator
 from sys import getsizeof
-from typing import Any, Hashable, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Hashable, List, Optional, Tuple
 import warnings
 
 import numpy as np
@@ -20,7 +20,6 @@
     ensure_python_int,
     is_float,
     is_integer,
-    is_list_like,
     is_scalar,
     is_signed_integer_dtype,
     is_timedelta64_dtype,
@@ -35,6 +34,9 @@
 from pandas.core.indexes.numeric import Float64Index, Int64Index
 from pandas.core.ops.common import unpack_zerodim_and_defer
 
+if TYPE_CHECKING:
+    from pandas import Index
+
 _empty_range = range(0)
 
 
@@ -368,8 +370,8 @@ def get_loc(self, key, method=None, tolerance=None):
             raise KeyError(key)
         return super().get_loc(key, method=method, tolerance=tolerance)
 
-    def _get_indexer(self, target, method=None, limit=None, tolerance=None):
-        if com.any_not_none(method, tolerance, limit) or not is_list_like(target):
+    def _get_indexer(self, target: Index, method=None, limit=None, tolerance=None):
+        if com.any_not_none(method, tolerance, limit):
             return super()._get_indexer(
                 target, method=method, tolerance=tolerance, limit=limit
             )
@@ -381,11 +383,11 @@ def _get_indexer(self, target, method=None, limit=None, tolerance=None):
             reverse = self._range[::-1]
             start, stop, step = reverse.start, reverse.stop, reverse.step
 
-        target_array = np.asarray(target)
-        if not (is_signed_integer_dtype(target_array) and target_array.ndim == 1):
+        if not is_signed_integer_dtype(target):
             # checks/conversions/roundings are delegated to general method
             return super()._get_indexer(target, method=method, tolerance=tolerance)
 
+        target_array = np.asarray(target)
         locs = target_array - start
         valid = (locs % step == 0) & (locs >= 0) & (target_array < stop)
         locs[~valid] = -1