Styler.pipe(func, *args, **kwargs)[source]#

Apply func(self, *args, **kwargs), and return the result.


Function to apply to the Styler. Alternatively, a (callable, keyword) tuple where keyword is a string indicating the keyword of callable that expects the Styler.


Arguments passed to func.


A dictionary of keyword arguments passed into func.


The value returned by func.

See also


Analogous method for DataFrame.


Apply a CSS-styling function column-wise, row-wise, or table-wise.


Like DataFrame.pipe(), this method can simplify the application of several user-defined functions to a styler. Instead of writing:

f(g(, arg1=a), arg2=b, arg3=c)

users can write:

   .pipe(g, arg1=a)
   .pipe(f, arg2=b, arg3=c))

In particular, this allows users to define functions that take a styler object, along with other parameters, and return the styler after making styling changes (such as calling Styler.apply() or Styler.set_properties()).


Common Use

A common usage pattern is to pre-define styling operations which can be easily applied to a generic styler in a single pipe call.

>>> def some_highlights(styler, min_color="red", max_color="blue"):
...      styler.highlight_min(color=min_color, axis=None)
...      styler.highlight_max(color=max_color, axis=None)
...      styler.highlight_null()
...      return styler
>>> df = pd.DataFrame([[1, 2, 3, pd.NA], [pd.NA, 4, 5, 6]], dtype="Int64")
>>>, min_color="green")  

Since the method returns a Styler object it can be chained with other methods as if applying the underlying highlighters directly.

>>> ("{:.1f}")
...         .pipe(some_highlights, min_color="green")
...         .highlight_between(left=2, right=5))  

Advanced Use

Sometimes it may be necessary to pre-define styling functions, but in the case where those functions rely on the styler, data or context. Since Styler.use and Styler.export are designed to be non-data dependent, they cannot be used for this purpose. Additionally the Styler.apply and Styler.format type methods are not context aware, so a solution is to use pipe to dynamically wrap this functionality.

Suppose we want to code a generic styling function that highlights the final level of a MultiIndex. The number of levels in the Index is dynamic so we need the Styler context to define the level.

>>> def highlight_last_level(styler):
...     return styler.apply_index(
...         lambda v: "background-color: pink; color: yellow", axis="columns",
...         level=styler.columns.nlevels-1
...     )  
>>> df.columns = pd.MultiIndex.from_product([["A", "B"], ["X", "Y"]])

Additionally suppose we want to highlight a column header if there is any missing data in that column. In this case we need the data object itself to determine the effect on the column headers.

>>> def highlight_header_missing(styler, level):
...     def dynamic_highlight(s):
...         return np.where(
...   , "background-color: red;", ""
...         )
...     return styler.apply_index(dynamic_highlight, axis=1, level=level)
>>>, level=1)