ENH: Add ability to style axis names with Styler

pandas/io/formats/style.py

@@ -214,7 +214,9 @@ class Styler(StylerRenderer):
 
  CSS classes are attached to the generated HTML
 
- * Index and Column names include ``index_name`` and ``level<k>``
+ * Index names include ``index_name`` and ``level<k>``
+ where `k` is its level in a MultiIndex
+ * Column names include ``columns_name`` and ``level<k>``
  where `k` is its level in a MultiIndex
  * Index label cells include
 
@@ -1595,7 +1597,7 @@ def _update_ctx_header(self, attrs: DataFrame, axis: AxisInt) -> None:
 
  Parameters
  ----------
- attrs : Series
+ attrs : DataFrame
  Should contain strings of '<property>: <value>;<prop2>: <val2>', and an
  integer index.
  Whitespace shouldn't matter and the final trailing ';' shouldn't
@@ -1614,6 +1616,31 @@ def _update_ctx_header(self, attrs: DataFrame, axis: AxisInt) -> None:
  else:
  self.ctx_columns[(j, i)].extend(css_list)
 
+ def _update_ctx_header_names(self, attrs: Series, axis: AxisInt) -> None:
+ """
+ Update the state of the ``Styler`` for header level name cells.
+
+ Collects a mapping of {index_label: [('<property>', '<value>'), ..]}.
+
+ Parameters
+ ----------
+ attrs : Series
+ Should contain strings of '<property>: <value>;<prop2>: <val2>', and an
+ integer index.
+ Whitespace shouldn't matter and the final trailing ';' shouldn't
+ matter.
+ axis : int
+ Identifies whether the ctx object being updated is the index or columns
+ """
+ for i, c in attrs.items():
+ if not c:
+ continue
+ css_list = maybe_convert_css_to_tuples(c)
+ if axis == 0:
+ self.ctx_index_names[(0, i)].extend(css_list)
+ else:
+ self.ctx_columns_names[(i, 0)].extend(css_list)
+
  def _copy(self, deepcopy: bool = False) -> Styler:
  """
  Copies a Styler, allowing for deepcopy or shallow copy
@@ -1668,6 +1695,8 @@ def _copy(self, deepcopy: bool = False) -> Styler:
  "ctx",
  "ctx_index",
  "ctx_columns",
+ "ctx_index_names",
+ "ctx_columns_names",
  "cell_context",
  "_todo",
  "table_styles",
@@ -1861,21 +1890,34 @@ def _apply_index(
  func: Callable,
  axis: Axis = 0,
  level: Level | list[Level] | None = None,
+ names: bool = False,
  method: str = "apply",
  **kwargs,
  ) -> Styler:
  axis = self.data._get_axis_number(axis)
  obj = self.index if axis == 0 else self.columns
 
  levels_ = refactor_levels(level, obj)
- data = DataFrame(obj.to_list()).loc[:, levels_]
+ if names:
+ level_names = obj.names
+ data = Series(level_names).loc[levels_]
 
- if method == "apply":
- result = data.apply(func, axis=0, **kwargs)
- elif method == "applymap":
- result = data.applymap(func, **kwargs)
+ if method == "apply":
+ result = data.pipe(func, **kwargs)
+ elif method == "applymap":
+ result = data.apply(func, **kwargs)
+
+ self._update_ctx_header_names(result, axis)
+ else:
+ data = DataFrame(obj.to_list()).loc[:, levels_]
+
+ if method == "apply":
+ result = data.apply(func, axis=0, **kwargs)
+ elif method == "applymap":
+ result = data.applymap(func, **kwargs)
+
+ self._update_ctx_header(result, axis)
 
- self._update_ctx_header(result, axis)
  return self
 
  @doc(
@@ -1895,6 +1937,7 @@ def apply_index(
  func: Callable,
  axis: AxisInt | str = 0,
  level: Level | list[Level] | None = None,
+ names: bool = False,
  **kwargs,
  ) -> Styler:
  """
@@ -1912,6 +1955,9 @@ def apply_index(
  The headers over which to apply the function.
  level : int, str, list, optional
  If index is MultiIndex the level(s) over which to apply the function.
+ names : bool, optional
+ Whether to apply the styles to the index/column level names (if True) or
+ to the index/column values (if False, default).
  **kwargs : dict
  Pass along to ``func``.
 
@@ -1956,7 +2002,7 @@ def apply_index(
  self._todo.append(
  (
  lambda instance: getattr(instance, "_apply_index"),
- (func, axis, level, "apply"),
+ (func, axis, level, names, "apply"),
  kwargs,
  )
  )
@@ -1980,12 +2026,13 @@ def applymap_index(
  func: Callable,
  axis: AxisInt | str = 0,
  level: Level | list[Level] | None = None,
+ names: bool = False,
  **kwargs,
  ) -> Styler:
  self._todo.append(
  (
  lambda instance: getattr(instance, "_apply_index"),
- (func, axis, level, "applymap"),
+ (func, axis, level, names, "applymap"),
  kwargs,
  )
  )
@@ -2572,6 +2619,7 @@ def set_table_styles(
  css_class_names = {"row_heading": "row_heading",
  "col_heading": "col_heading",
  "index_name": "index_name",
+ "columns_name": "columns_name",
  "col": "col",
  "row": "row",
  "col_trim": "col_trim",

pandas/io/formats/style_render.py

@@ -63,6 +63,10 @@ class CSSDict(TypedDict):
 
 CSSStyles = List[CSSDict]
 Subset = Union[slice, Sequence, Index]
+# Maps styles to list of cell element id's that have that style
+CellMapStyles = DefaultDict[Tuple[CSSPair, ...], List[str]]
+# Maps cell positions to CSS styles
+CSSCellMap = DefaultDict[Tuple[int, int], CSSList]
 
 
 class StylerRenderer:
@@ -110,6 +114,7 @@ def __init__(
  "row_heading": "row_heading",
  "col_heading": "col_heading",
  "index_name": "index_name",
+ "columns_name": "columns_name",
  "col": "col",
  "row": "row",
  "col_trim": "col_trim",
@@ -127,9 +132,11 @@ def __init__(
  self.hide_columns_: list = [False] * self.columns.nlevels
  self.hidden_rows: Sequence[int] = [] # sequence for specific hidden rows/cols
  self.hidden_columns: Sequence[int] = []
- self.ctx: DefaultDict[tuple[int, int], CSSList] = defaultdict(list)
- self.ctx_index: DefaultDict[tuple[int, int], CSSList] = defaultdict(list)
- self.ctx_columns: DefaultDict[tuple[int, int], CSSList] = defaultdict(list)
+ self.ctx: CSSCellMap = defaultdict(list)
+ self.ctx_index: CSSCellMap = defaultdict(list)
+ self.ctx_columns: CSSCellMap = defaultdict(list)
+ self.ctx_index_names: CSSCellMap = defaultdict(list)
+ self.ctx_columns_names: CSSCellMap = defaultdict(list)
  self.cell_context: DefaultDict[tuple[int, int], str] = defaultdict(str)
  self._todo: list[tuple[Callable, tuple, dict]] = []
  self.tooltips: Tooltips | None = None
@@ -307,9 +314,9 @@ def _translate(
  max_cols,
  )
 
- self.cellstyle_map_columns: DefaultDict[
-  tuple[CSSPair, ...], list[str]
- ] = defaultdict(list)
+ self.cellstyle_map_columns: CellMapStyles = defaultdict(list)
+ self.cellstyle_map_columns_names: CellMapStyles = defaultdict(list)
+ self.cellstyle_map_index_names: CellMapStyles = defaultdict(list)
  head = self._translate_header(sparse_cols, max_cols)
  d.update({"head": head})
 
@@ -319,19 +326,17 @@ def _translate(
  )
  d.update({"index_lengths": idx_lengths})
 
- self.cellstyle_map: DefaultDict[tuple[CSSPair, ...], list[str]] = defaultdict(
- list
- )
- self.cellstyle_map_index: DefaultDict[
- tuple[CSSPair, ...], list[str]
- ] = defaultdict(list)
+ self.cellstyle_map: CellMapStyles = defaultdict(list)
+ self.cellstyle_map_index: CellMapStyles = defaultdict(list)
  body: list = self._translate_body(idx_lengths, max_rows, max_cols)
  d.update({"body": body})
 
  ctx_maps = {
  "cellstyle": "cellstyle_map",
  "cellstyle_index": "cellstyle_map_index",
  "cellstyle_columns": "cellstyle_map_columns",
+ "cellstyle_index_names": "cellstyle_map_index_names",
+ "cellstyle_columns_names": "cellstyle_map_columns_names",
  } # add the cell_ids styles map to the render dictionary in right format
  for k, attr in ctx_maps.items():
  map = [
@@ -455,7 +460,7 @@ def _generate_col_header_row(self, iter: tuple, max_cols: int, col_lengths: dict
  (
  f"{self.css['blank']} {self.css['level']}{r}"
  if name is None
- else f"{self.css['index_name']} {self.css['level']}{r}"
+ else f"{self.css['columns_name']} {self.css['level']}{r}"
  ),
  name
  if (name is not None and not self.hide_column_names)
@@ -464,6 +469,16 @@ def _generate_col_header_row(self, iter: tuple, max_cols: int, col_lengths: dict
  )
  ]
 
+ if (
+ not all(self.hide_index_)
+ and (r, 0) in self.ctx_columns_names
+ and self.ctx_columns_names[r, 0]
+ ):
+ column_name[0]["id"] = f"{self.css['columns_name']}_{self.css['level']}{r}"
+ self.cellstyle_map_columns_names[
+ tuple(self.ctx_columns_names[r, 0])
+ ].append(f"{self.css['columns_name']}_{self.css['level']}{r}")
+
  column_headers: list = []
  visible_col_count: int = 0
  for c, value in enumerate(clabels[r]):
@@ -534,15 +549,26 @@ def _generate_index_names_row(self, iter: tuple, max_cols: int, col_lengths: dic
 
  clabels = iter
 
- index_names = [
- _element(
+ index_names = []
+ for c, name in enumerate(self.data.index.names):
+ index_name_element = _element(
  "th",
  f"{self.css['index_name']} {self.css['level']}{c}",
  self.css["blank_value"] if name is None else name,
  not self.hide_index_[c],
  )
- for c, name in enumerate(self.data.index.names)
- ]
+
+ if (
+ not self.hide_index_[c]
+ and (0, c) in self.ctx_index_names
+ and self.ctx_index_names[0, c]
+ ):
+ element_id = f"{self.css['index_name']}_{self.css['level']}{c}"
+ index_name_element["id"] = element_id
+ self.cellstyle_map_index_names[
+ tuple(self.ctx_index_names[0, c])
+ ].append(element_id)
+ index_names.append(index_name_element)
 
  column_blanks: list = []
  visible_col_count: int = 0

pandas/io/formats/templates/html_style.tpl

@@ -12,7 +12,7 @@
 {% endblock table_styles %}
 {% block before_cellstyle %}{% endblock before_cellstyle %}
 {% block cellstyle %}
-{% for cs in [cellstyle, cellstyle_index, cellstyle_columns] %}
+{% for cs in [cellstyle, cellstyle_index, cellstyle_columns, cellstyle_index_names, cellstyle_columns_names] %}
 {% for s in cs %}
 {% for selector in s.selectors %}{% if not loop.first %}, {% endif %}#T_{{uuid}}_{{selector}}{% endfor %} {
 {% for p,val in s.props %}