Sindbad~EG File Manager
�
Mٜg�` � � � d Z ddlmZ ddlmZ ddlZddlmZ ddlZddl m
Z
m Z m Z m
Z
ddlZddlZddlmZ ddlmZ dd lmZmZ dd
lmZ ddlZdd lm Z m Z ddl m c m Z! dd l"m#Z#m$Z$ dd
l%m&Z& ddl'm(Z( ddl)m*Z* edd�� Z+ddl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 e
r0ddl7m8Z8m9Z9m:Z: ddl;m<Z< ddl=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZH ddlmIZI ddlJZKddlLmMZN dZOed'd�� ZQdZRd ZSd ZTd ZUd ZV G d � d!e0� ZW d(d"�ZX d) d*d#�ZY d+ d,d$�ZZd-d%�Z[ d.d&�Z\y# eP$ r dZOY �w xY w)/zF
Module for applying conditional formatting to DataFrames and Series.
� )� annotations)�contextmanagerN)�partial)�
TYPE_CHECKING�Any�Callable�overload)�
get_option)�import_optional_dependency)� Substitution�doc)�find_stack_level)�
IndexSlice�
RangeIndex)� DataFrame�Series)�NDFrame)� _shared_docs)�save_to_buffer�jinja2z DataFrame.style requires jinja2.)�extra)
�
CSSProperties� CSSStyles� ExtFormatter�StylerRenderer�Subset�Tooltips�format_table_styles�maybe_convert_css_to_tuples�non_reducing_slice�refactor_levels)� Generator�Hashable�Sequence)�Colormap) �Axis�AxisInt�FilePath�
IndexLabel�IntervalClosedType�Level�QuantileInterpolation�Scalar�StorageOptions� WriteBuffer�WriteExcelBuffer)� ExcelWriterTFc # �d K � t rt t f�� y t | j � d�� ��w)Nz requires matplotlib.)�has_mpl�plt�mpl� ImportError�__name__)�funcs �B/usr/local/lib/python3.12/site-packages/pandas/io/formats/style.py�_mplr: ] s) � �� ���3�h���T�]�]�O�+@�A�B�B�s �.0a( subset : label, array-like, IndexSlice, optional
A valid 2d input to `DataFrame.loc[<subset>]`, or, in the case of a 1d input
or single key, to `DataFrame.loc[:, <subset>]` where the columns are
prioritised, to limit ``data`` to *before* applying the function.z�props : str, default None
CSS properties to use for highlighting. If ``props`` is given, ``color``
is not used.zUcolor : str, default '{default}'
Background color to use for highlighting.z�buf : str, path object, file-like object, optional
String, path object (implementing ``os.PathLike[str]``), or file-like
object implementing a string ``write()`` function. If ``None``, the result is
returned as a string.z�encoding : str, optional
Character encoding setting for file output (and meta tags if available).
Defaults to ``pandas.options.styler.render.encoding`` value of "utf-8".c �
� � e Zd ZdZ db dc� fd�
Zddd�Zded�Zded�Z df dgd�Z e e
j d e d d �
� dh did �� Z e
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d� djd�� Ze
dkd
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d� dld�� Z dmdddddddddddddddd� dnd�Ze
d
d
d
d
d
d
d
d
d
d
d
d� dod�� Ze
dkd
d
d
d
d
d
d
d
d
d
d
d� dpd�� Z eee�� dmdddddddddddd� dqd�� Ze
d
d
d
d
d
d
d� drd�� Ze
dkd
d
d
d
d
d
d� dsd�� Z eee�� dmddddddd� dtd �� Zdud �Zdvd �Zdwd �Zdxdyd �Zdzd!�Zdzd"�Zd{d#�Z d| d}d$�Z ee �%� d| d}d&�� Z d~ dd(�Z e d'd)d*d+d,d-d.d/d0d1�2�
d| d�d3�� Z e e d*d+d'd)d4d5d6d7d8d9�2� d| d�d:�� Z d| d�d;�Z!dmd�d<�Z" ee �%� dmd�d=�� Z# ee �%� dm d�d>�� Z$d�d?�Z%d�d@�Z&d�dA�Z'd�dB�Z(d�dC�Z) d� d�dD�Z* d� d�dE�Z+ d� d�dF�Z,dG� Z- e dHdIdJdK�L� ee �%� d� d�dM�� � Z. e e.dIdHdNd �L� d� d�dO�� Z/ ee �%� dmd�dP�� Z0 ee �%� d�dddQdQdRdddSdT� d�dU�� Z1 ee e2e3ji dV�W� �X� d� d�dY�� Z5 ee e3ji dZ�W� e2�[� d� d�d\�� Z6 ee e3ji dZ�W� e2�[� d� d�d]�� Z7 ee e3ji dZ�W� e2�[� d� d�d^�� Z8 ee e3ji dZ�W� e2�[� d� d�d_�� Z9e: df d�d`�� Z;d�da�Z<� xZ=S )��Stylera�
Helps style a DataFrame or Series according to the data with HTML and CSS.
Parameters
----------
data : Series or DataFrame
Data to be styled - either a Series or DataFrame.
precision : int, optional
Precision to round floats to. If not given defaults to
``pandas.options.styler.format.precision``.
.. versionchanged:: 1.4.0
table_styles : list-like, default None
List of {selector: (attr, value)} dicts; see Notes.
uuid : str, default None
A unique identifier to avoid CSS collisions; generated automatically.
caption : str, tuple, default None
String caption to attach to the table. Tuple only used for LaTeX dual captions.
table_attributes : str, default None
Items that show up in the opening ``<table>`` tag
in addition to automatic (by default) id.
cell_ids : bool, default True
If True, each cell will have an ``id`` attribute in their HTML tag.
The ``id`` takes the form ``T_<uuid>_row<num_row>_col<num_col>``
where ``<uuid>`` is the unique identifier, ``<num_row>`` is the row
number and ``<num_col>`` is the column number.
na_rep : str, optional
Representation for missing values.
If ``na_rep`` is None, no special formatting is applied, and falls back to
``pandas.options.styler.format.na_rep``.
uuid_len : int, default 5
If ``uuid`` is not specified, the length of the ``uuid`` to randomly generate
expressed in hex characters, in range [0, 32].
decimal : str, optional
Character used as decimal separator for floats, complex and integers. If not
given uses ``pandas.options.styler.format.decimal``.
.. versionadded:: 1.3.0
thousands : str, optional, default None
Character used as thousands separator for floats, complex and integers. If not
given uses ``pandas.options.styler.format.thousands``.
.. versionadded:: 1.3.0
escape : str, optional
Use 'html' to replace the characters ``&``, ``<``, ``>``, ``'``, and ``"``
in cell display string with HTML-safe sequences.
Use 'latex' to replace the characters ``&``, ``%``, ``$``, ``#``, ``_``,
``{``, ``}``, ``~``, ``^``, and ``\`` in the cell display string with
LaTeX-safe sequences. Use 'latex-math' to replace the characters
the same way as in 'latex' mode, except for math substrings,
which either are surrounded by two characters ``$`` or start with
the character ``\(`` and end with ``\)``.
If not given uses ``pandas.options.styler.format.escape``.
.. versionadded:: 1.3.0
formatter : str, callable, dict, optional
Object to define how values are displayed. See ``Styler.format``. If not given
uses ``pandas.options.styler.format.formatter``.
.. versionadded:: 1.4.0
Attributes
----------
env : Jinja2 jinja2.Environment
template_html : Jinja2 Template
template_html_table : Jinja2 Template
template_html_style : Jinja2 Template
template_latex : Jinja2 Template
loader : Jinja2 Loader
See Also
--------
DataFrame.style : Return a Styler object containing methods for building
a styled HTML representation for the DataFrame.
Notes
-----
Most styling will be done by passing style functions into
``Styler.apply`` or ``Styler.map``. Style functions should
return values with strings containing CSS ``'attr: value'`` that will
be applied to the indicated cells.
If using in the Jupyter notebook, Styler has defined a ``_repr_html_``
to automatically render itself. Otherwise call Styler.to_html to get
the generated HTML.
CSS classes are attached to the generated HTML
* Index and Column names include ``index_name`` and ``level<k>``
where `k` is its level in a MultiIndex
* Index label cells include
* ``row_heading``
* ``row<n>`` where `n` is the numeric position of the row
* ``level<k>`` where `k` is the level in a MultiIndex
* Column label cells include
* ``col_heading``
* ``col<n>`` where `n` is the numeric position of the column
* ``level<k>`` where `k` is the level in a MultiIndex
* Blank cells include ``blank``
* Data cells include ``data``
* Trimmed cells include ``col_trim`` or ``row_trim``.
Any, or all, or these classes can be renamed by using the ``css_class_names``
argument in ``Styler.set_table_classes``, giving a value such as
*{"row": "MY_ROW_CLASS", "col_trim": "", "row_trim": ""}*.
Examples
--------
>>> df = pd.DataFrame([[1.0, 2.0, 3.0], [4, 5, 6]], index=['a', 'b'],
... columns=['A', 'B', 'C'])
>>> pd.io.formats.style.Styler(df, precision=2,
... caption="My table") # doctest: +SKIP
Please see:
`Table Visualization <../../user_guide/style.ipynb>`_ for more examples.
Nc
� �� t �| � ||| |||||�� | xs t d� } |
xs t d� }
|xs t d� }| xs t d� } |
xs t d� }
| j |
||| |
| �� y )N)�data�uuid�uuid_len� table_styles�table_attributes�caption�cell_ids� precisionzstyler.format.thousandszstyler.format.decimalzstyler.format.na_repzstyler.format.escapezstyler.format.formatter)� formatterrE �na_rep�escape�decimal� thousands)�super�__init__r
�format)�selfr> rE rA r? rC rB rD rG r@ rI rJ rH rF � __class__s �r9 rL zStyler.__init__� s� �� � ����� �%� -�� � � �
� �F��,E�!F� ��@�Z�(?� @���=�:�&<�=���=�:�&<�=�� �F��,E�!F� �
� � � � ���� �
�
� c � � t |t � s t d� �| j j j |j j � s t
d� �| j j j |j j j k( s t
d� �| j j |� | S )a�
Append another Styler to combine the output into a single table.
.. versionadded:: 1.5.0
Parameters
----------
other : Styler
The other Styler object which has already been styled and formatted. The
data for this Styler must have the same columns as the original, and the
number of index levels must also be the same to render correctly.
Returns
-------
Styler
Notes
-----
The purpose of this method is to extend existing styled dataframes with other
metrics that may be useful but may not conform to the original's structure.
For example adding a sub total row, or displaying metrics such as means,
variance or counts.
Styles that are applied using the ``apply``, ``map``, ``apply_index``
and ``map_index``, and formatting applied with ``format`` and
``format_index`` will be preserved.
.. warning::
Only the output methods ``to_html``, ``to_string`` and ``to_latex``
currently work with concatenated Stylers.
Other output methods, including ``to_excel``, **do not** work with
concatenated Stylers.
The following should be noted:
- ``table_styles``, ``table_attributes``, ``caption`` and ``uuid`` are all
inherited from the original Styler and not ``other``.
- hidden columns and hidden index levels will be inherited from the
original Styler
- ``css`` will be inherited from the original Styler, and the value of
keys ``data``, ``row_heading`` and ``row`` will be prepended with
``foot0_``. If more concats are chained, their styles will be prepended
with ``foot1_``, ''foot_2'', etc., and if a concatenated style have
another concatanated style, the second style will be prepended with
``foot{parent}_foot{child}_``.
A common use case is to concatenate user defined functions with
``DataFrame.agg`` or with described statistics via ``DataFrame.describe``.
See examples.
Examples
--------
A common use case is adding totals rows, or otherwise, via methods calculated
in ``DataFrame.agg``.
>>> df = pd.DataFrame([[4, 6], [1, 9], [3, 4], [5, 5], [9, 6]],
... columns=["Mike", "Jim"],
... index=["Mon", "Tue", "Wed", "Thurs", "Fri"])
>>> styler = df.style.concat(df.agg(["sum"]).style) # doctest: +SKIP
.. figure:: ../../_static/style/footer_simple.png
Since the concatenated object is a Styler the existing functionality can be
used to conditionally format it as well as the original.
>>> descriptors = df.agg(["sum", "mean", lambda s: s.dtype])
>>> descriptors.index = ["Total", "Average", "dtype"]
>>> other = (descriptors.style
... .highlight_max(axis=1, subset=(["Total", "Average"], slice(None)))
... .format(subset=("Average", slice(None)), precision=2, decimal=",")
... .map(lambda v: "font-weight: bold;"))
>>> styler = (df.style
... .highlight_max(color="salmon")
... .set_table_styles([{"selector": ".foot_row0",
... "props": "border-top: 1px solid black;"}]))
>>> styler.concat(other) # doctest: +SKIP
.. figure:: ../../_static/style/footer_extended.png
When ``other`` has fewer index levels than the original Styler it is possible
to extend the index in ``other``, with placeholder levels.
>>> df = pd.DataFrame([[1], [2]],
... index=pd.MultiIndex.from_product([[0], [1, 2]]))
>>> descriptors = df.agg(["sum"])
>>> descriptors.index = pd.MultiIndex.from_product([[""], descriptors.index])
>>> df.style.concat(descriptors.style) # doctest: +SKIP
z `other` must be of type `Styler`z4`other.data` must have same columns as `Styler.data`zanumber of index levels must be same in `other` as in `Styler`. See documentation for suggestions.) �
isinstancer< � TypeErrorr> �columns�equals�
ValueError�index�nlevels� concatenated�append)rN �others r9 �concatz
Styler.concat) s� � �t �%��(�� >�?� ?��y�y� � �'�'��
�
�(:�(:�;� � S�T� T��y�y���&�&�%�*�*�*:�*:�*B�*B�B� �E��
�
��� � ��'�� rP c �@ � t d� dk( r| j � S y)z�
Hooks into Jupyter notebook rich display system, which calls _repr_html_ by
default if an object is returned at the end of a cell.
�styler.render.repr�htmlN)r
�to_html�rN s r9 � _repr_html_zStyler._repr_html_� s! � �
�*� +�v� 5��<�<�>� !�rP c �@ � t d� dk( r| j � S y )Nr^ �latex)r
�to_latexra s r9 � _repr_latex_zStyler._repr_latex_� s � � �*� +�w� 6��=�=�?� "�rP c �F � | j s t d� �|j j r|j j s t d� �| j �t � | _ || j _ |r|| j _ |r|| j _
| S )a�
Set the DataFrame of strings on ``Styler`` generating ``:hover`` tooltips.
These string based tooltips are only applicable to ``<td>`` HTML elements,
and cannot be used for column or index headers.
.. versionadded:: 1.3.0
Parameters
----------
ttips : DataFrame
DataFrame containing strings that will be translated to tooltips, mapped
by identical column and index values that must exist on the underlying
Styler data. None, NaN values, and empty strings will be ignored and
not affect the rendered HTML.
props : list-like or str, optional
List of (attr, value) tuples or a valid CSS string. If ``None`` adopts
the internal default values described in notes.
css_class : str, optional
Name of the tooltip class used in CSS, should conform to HTML standards.
Only useful if integrating tooltips with external CSS. If ``None`` uses the
internal default value 'pd-t'.
Returns
-------
Styler
Notes
-----
Tooltips are created by adding `<span class="pd-t"></span>` to each data cell
and then manipulating the table level CSS to attach pseudo hover and pseudo
after selectors to produce the required the results.
The default properties for the tooltip CSS class are:
- visibility: hidden
- position: absolute
- z-index: 1
- background-color: black
- color: white
- transform: translate(-20px, -20px)
The property 'visibility: hidden;' is a key prerequisite to the hover
functionality, and should always be included in any manual properties
specification, using the ``props`` argument.
Tooltips are not designed to be efficient, and can add large amounts of
additional HTML for larger tables, since they also require that ``cell_ids``
is forced to `True`.
Examples
--------
Basic application
>>> df = pd.DataFrame(data=[[0, 1], [2, 3]])
>>> ttips = pd.DataFrame(
... data=[["Min", ""], [np.nan, "Max"]], columns=df.columns, index=df.index
... )
>>> s = df.style.set_tooltips(ttips).to_html()
Optionally controlling the tooltip visual display
>>> df.style.set_tooltips(ttips, css_class='tt-add', props=[
... ('visibility', 'hidden'),
... ('position', 'absolute'),
... ('z-index', 1)]) # doctest: +SKIP
>>> df.style.set_tooltips(ttips, css_class='tt-add',
... props='visibility:hidden; position:absolute; z-index:1;')
... # doctest: +SKIP
z1Tooltips can only render with 'cell_ids' is True.z=Tooltips render only if `ttips` has unique index and columns.) rD �NotImplementedErrorrW � is_uniquerT �KeyError�tooltipsr �tt_data�class_properties�
class_name)rN �ttips�props� css_classs r9 � set_tooltipszStyler.set_tooltips� s� � �X �}�}� &�C��
� �{�{�$�$�E�M�M�,C�,C��O��
� �=�=� � $�J�D�M� %��
�
� � �-2�D�M�M� *� �'0�D�M�M� $�� rP �storage_optionsz1.5.0)�klassrs � storage_options_versionadded� c �b � ddl m} || ||||||| |�� }|j ||| |
|| |�� y )Nr )�ExcelFormatter)rG �cols�header� float_formatrW � index_label� merge_cells�inf_rep)�
sheet_name�startrow�startcol� freeze_panes�enginers )�pandas.io.formats.excelrx �write)rN � excel_writerr rG r{ rT rz rW r| r� r� r� r} �encodingr~ �verboser� rs rx rF s r9 �to_excelzStyler.to_excel� sT � �4 ;�"� ����%��#�#��
� � ��� �!� � �%�� +� �
rP .)�
column_format�position�position_float�hrules�clines�labelrC � sparse_index�sparse_columns�multirow_align�multicol_align�siunitx� environmentr� � convert_cssc � � y �N� �rN �bufr� r� r� r� r� r� rC r� r� r� r� r� r� r� r� s r9 re zStyler.to_latex. � � �* rP c � � y r� r� r� s r9 re zStyler.to_latexE r� rP Fc
�� � | j d�� }| j � | j D �cg c] }|d �� c}ng }|� |j dd|� �d�gd�� �n2d|v r�n,| j j }t t
| j j � � � | j _ | j j � j j � }|| j _ d
}t | j j � D ] }|| j | rd
nd z
}� t | j j � D ]# \ }}|| j vs�|||v r|
sd nd
nd z
}�% |j dd|� �d�gd�� |r|j dd|� �d�gd�� |r=|dk( r t d� �|dvrt d|� d�� �|j dd|� �d�gd�� |� t! d� n|}|r |j ddd�ddd�ddd�gd�� |r+|j d d |j# dd � � d �d�gd�� |r|j% |� | � t! d � } |
� t! d!� }
|xs t! d"� }| xs t! d#� } | xs t! d$� } |j' | |
| | |||
|�%� }t) |t* � r|xs
t! d&� n|}t- |||�'� S c c}w )(u;V
Write Styler to a file, buffer or string in LaTeX format.
.. versionadded:: 1.3.0
Parameters
----------
buf : str, path object, file-like object, or None, default None
String, path object (implementing ``os.PathLike[str]``), or file-like
object implementing a string ``write()`` function. If None, the result is
returned as a string.
column_format : str, optional
The LaTeX column specification placed in location:
\\begin{tabular}{<column_format>}
Defaults to 'l' for index and
non-numeric data columns, and, for numeric data columns,
to 'r' by default, or 'S' if ``siunitx`` is ``True``.
position : str, optional
The LaTeX positional argument (e.g. 'h!') for tables, placed in location:
``\\begin{table}[<position>]``.
position_float : {"centering", "raggedleft", "raggedright"}, optional
The LaTeX float command placed in location:
\\begin{table}[<position>]
\\<position_float>
Cannot be used if ``environment`` is "longtable".
hrules : bool
Set to `True` to add \\toprule, \\midrule and \\bottomrule from the
{booktabs} LaTeX package.
Defaults to ``pandas.options.styler.latex.hrules``, which is `False`.
.. versionchanged:: 1.4.0
clines : str, optional
Use to control adding \\cline commands for the index labels separation.
Possible values are:
- `None`: no cline commands are added (default).
- `"all;data"`: a cline is added for every index value extending the
width of the table, including data entries.
- `"all;index"`: as above with lines extending only the width of the
index entries.
- `"skip-last;data"`: a cline is added for each index value except the
last level (which is never sparsified), extending the widtn of the
table.
- `"skip-last;index"`: as above with lines extending only the width of the
index entries.
.. versionadded:: 1.4.0
label : str, optional
The LaTeX label included as: \\label{<label>}.
This is used with \\ref{<label>} in the main .tex file.
caption : str, tuple, optional
If string, the LaTeX table caption included as: \\caption{<caption>}.
If tuple, i.e ("full caption", "short caption"), the caption included
as: \\caption[<caption[1]>]{<caption[0]>}.
sparse_index : bool, optional
Whether to sparsify the display of a hierarchical index. Setting to False
will display each explicit level element in a hierarchical key for each row.
Defaults to ``pandas.options.styler.sparse.index``, which is `True`.
sparse_columns : bool, optional
Whether to sparsify the display of a hierarchical index. Setting to False
will display each explicit level element in a hierarchical key for each
column. Defaults to ``pandas.options.styler.sparse.columns``, which
is `True`.
multirow_align : {"c", "t", "b", "naive"}, optional
If sparsifying hierarchical MultiIndexes whether to align text centrally,
at the top or bottom using the multirow package. If not given defaults to
``pandas.options.styler.latex.multirow_align``, which is `"c"`.
If "naive" is given renders without multirow.
.. versionchanged:: 1.4.0
multicol_align : {"r", "c", "l", "naive-l", "naive-r"}, optional
If sparsifying hierarchical MultiIndex columns whether to align text at
the left, centrally, or at the right. If not given defaults to
``pandas.options.styler.latex.multicol_align``, which is "r".
If a naive option is given renders without multicol.
Pipe decorators can also be added to non-naive values to draw vertical
rules, e.g. "\|r" will draw a rule on the left side of right aligned merged
cells.
.. versionchanged:: 1.4.0
siunitx : bool, default False
Set to ``True`` to structure LaTeX compatible with the {siunitx} package.
environment : str, optional
If given, the environment that will replace 'table' in ``\\begin{table}``.
If 'longtable' is specified then a more suitable template is
rendered. If not given defaults to
``pandas.options.styler.latex.environment``, which is `None`.
.. versionadded:: 1.4.0
encoding : str, optional
Character encoding setting. Defaults
to ``pandas.options.styler.render.encoding``, which is "utf-8".
convert_css : bool, default False
Convert simple cell-styles from CSS to LaTeX format. Any CSS not found in
conversion table is dropped. A style can be forced by adding option
`--latex`. See notes.
Returns
-------
str or None
If `buf` is None, returns the result as a string. Otherwise returns `None`.
See Also
--------
Styler.format: Format the text display value of cells.
Notes
-----
**Latex Packages**
For the following features we recommend the following LaTeX inclusions:
===================== ==========================================================
Feature Inclusion
===================== ==========================================================
sparse columns none: included within default {tabular} environment
sparse rows \\usepackage{multirow}
hrules \\usepackage{booktabs}
colors \\usepackage[table]{xcolor}
siunitx \\usepackage{siunitx}
bold (with siunitx) | \\usepackage{etoolbox}
| \\robustify\\bfseries
| \\sisetup{detect-all = true} *(within {document})*
italic (with siunitx) | \\usepackage{etoolbox}
| \\robustify\\itshape
| \\sisetup{detect-all = true} *(within {document})*
environment \\usepackage{longtable} if arg is "longtable"
| or any other relevant environment package
hyperlinks \\usepackage{hyperref}
===================== ==========================================================
**Cell Styles**
LaTeX styling can only be rendered if the accompanying styling functions have
been constructed with appropriate LaTeX commands. All styling
functionality is built around the concept of a CSS ``(<attribute>, <value>)``
pair (see `Table Visualization <../../user_guide/style.ipynb>`_), and this
should be replaced by a LaTeX
``(<command>, <options>)`` approach. Each cell will be styled individually
using nested LaTeX commands with their accompanied options.
For example the following code will highlight and bold a cell in HTML-CSS:
>>> df = pd.DataFrame([[1,2], [3,4]])
>>> s = df.style.highlight_max(axis=None,
... props='background-color:red; font-weight:bold;')
>>> s.to_html() # doctest: +SKIP
The equivalent using LaTeX only commands is the following:
>>> s = df.style.highlight_max(axis=None,
... props='cellcolor:{red}; bfseries: ;')
>>> s.to_latex() # doctest: +SKIP
Internally these structured LaTeX ``(<command>, <options>)`` pairs
are translated to the
``display_value`` with the default structure:
``\<command><options> <display_value>``.
Where there are multiple commands the latter is nested recursively, so that
the above example highlighted cell is rendered as
``\cellcolor{red} \bfseries 4``.
Occasionally this format does not suit the applied command, or
combination of LaTeX packages that is in use, so additional flags can be
added to the ``<options>``, within the tuple, to result in different
positions of required braces (the **default** being the same as ``--nowrap``):
=================================== ============================================
Tuple Format Output Structure
=================================== ============================================
(<command>,<options>) \\<command><options> <display_value>
(<command>,<options> ``--nowrap``) \\<command><options> <display_value>
(<command>,<options> ``--rwrap``) \\<command><options>{<display_value>}
(<command>,<options> ``--wrap``) {\\<command><options> <display_value>}
(<command>,<options> ``--lwrap``) {\\<command><options>} <display_value>
(<command>,<options> ``--dwrap``) {\\<command><options>}{<display_value>}
=================================== ============================================
For example the `textbf` command for font-weight
should always be used with `--rwrap` so ``('textbf', '--rwrap')`` will render a
working cell, wrapped with braces, as ``\textbf{<display_value>}``.
A more comprehensive example is as follows:
>>> df = pd.DataFrame([[1, 2.2, "dogs"], [3, 4.4, "cats"], [2, 6.6, "cows"]],
... index=["ix1", "ix2", "ix3"],
... columns=["Integers", "Floats", "Strings"])
>>> s = df.style.highlight_max(
... props='cellcolor:[HTML]{FFFF00}; color:{red};'
... 'textit:--rwrap; textbf:--rwrap;'
... )
>>> s.to_latex() # doctest: +SKIP
.. figure:: ../../_static/style/latex_1.png
**Table Styles**
Internally Styler uses its ``table_styles`` object to parse the
``column_format``, ``position``, ``position_float``, and ``label``
input arguments. These arguments are added to table styles in the format:
.. code-block:: python
set_table_styles([
{"selector": "column_format", "props": f":{column_format};"},
{"selector": "position", "props": f":{position};"},
{"selector": "position_float", "props": f":{position_float};"},
{"selector": "label", "props": f":{{{label.replace(':','§')}}};"}
], overwrite=False)
Exception is made for the ``hrules`` argument which, in fact, controls all three
commands: ``toprule``, ``bottomrule`` and ``midrule`` simultaneously. Instead of
setting ``hrules`` to ``True``, it is also possible to set each
individual rule definition, by manually setting the ``table_styles``,
for example below we set a regular ``toprule``, set an ``hline`` for
``bottomrule`` and exclude the ``midrule``:
.. code-block:: python
set_table_styles([
{'selector': 'toprule', 'props': ':toprule;'},
{'selector': 'bottomrule', 'props': ':hline;'},
], overwrite=False)
If other ``commands`` are added to table styles they will be detected, and
positioned immediately above the '\\begin{tabular}' command. For example to
add odd and even row coloring, from the {colortbl} package, in format
``\rowcolors{1}{pink}{red}``, use:
.. code-block:: python
set_table_styles([
{'selector': 'rowcolors', 'props': ':{1}{pink}{red};'}
], overwrite=False)
A more comprehensive example using these arguments is as follows:
>>> df.columns = pd.MultiIndex.from_tuples([
... ("Numeric", "Integers"),
... ("Numeric", "Floats"),
... ("Non-Numeric", "Strings")
... ])
>>> df.index = pd.MultiIndex.from_tuples([
... ("L0", "ix1"), ("L0", "ix2"), ("L1", "ix3")
... ])
>>> s = df.style.highlight_max(
... props='cellcolor:[HTML]{FFFF00}; color:{red}; itshape:; bfseries:;'
... )
>>> s.to_latex(
... column_format="rrrrr", position="h", position_float="centering",
... hrules=True, label="table:5", caption="Styled LaTeX Table",
... multirow_align="t", multicol_align="r"
... ) # doctest: +SKIP
.. figure:: ../../_static/style/latex_2.png
**Formatting**
To format values :meth:`Styler.format` should be used prior to calling
`Styler.to_latex`, as well as other methods such as :meth:`Styler.hide`
for example:
>>> s.clear()
>>> s.table_styles = []
>>> s.caption = None
>>> s.format({
... ("Numeric", "Integers"): '\${}',
... ("Numeric", "Floats"): '{:.3f}',
... ("Non-Numeric", "Strings"): str.upper
... }) # doctest: +SKIP
Numeric Non-Numeric
Integers Floats Strings
L0 ix1 $1 2.200 DOGS
ix2 $3 4.400 CATS
L1 ix3 $2 6.600 COWS
>>> s.to_latex() # doctest: +SKIP
\begin{tabular}{llrrl}
{} & {} & \multicolumn{2}{r}{Numeric} & {Non-Numeric} \\
{} & {} & {Integers} & {Floats} & {Strings} \\
\multirow[c]{2}{*}{L0} & ix1 & \\$1 & 2.200 & DOGS \\
& ix2 & \$3 & 4.400 & CATS \\
L1 & ix3 & \$2 & 6.600 & COWS \\
\end{tabular}
**CSS Conversion**
This method can convert a Styler constructured with HTML-CSS to LaTeX using
the following limited conversions.
================== ==================== ============= ==========================
CSS Attribute CSS value LaTeX Command LaTeX Options
================== ==================== ============= ==========================
font-weight | bold | bfseries
| bolder | bfseries
font-style | italic | itshape
| oblique | slshape
background-color | red cellcolor | {red}--lwrap
| #fe01ea | [HTML]{FE01EA}--lwrap
| #f0e | [HTML]{FF00EE}--lwrap
| rgb(128,255,0) | [rgb]{0.5,1,0}--lwrap
| rgba(128,0,0,0.5) | [rgb]{0.5,0,0}--lwrap
| rgb(25%,255,50%) | [rgb]{0.25,1,0.5}--lwrap
color | red color | {red}
| #fe01ea | [HTML]{FE01EA}
| #f0e | [HTML]{FF00EE}
| rgb(128,255,0) | [rgb]{0.5,1,0}
| rgba(128,0,0,0.5) | [rgb]{0.5,0,0}
| rgb(25%,255,50%) | [rgb]{0.25,1,0.5}
================== ==================== ============= ==========================
It is also possible to add user-defined LaTeX only styles to a HTML-CSS Styler
using the ``--latex`` flag, and to add LaTeX parsing options that the
converter will detect within a CSS-comment.
>>> df = pd.DataFrame([[1]])
>>> df.style.set_properties(
... **{"font-weight": "bold /* --dwrap */", "Huge": "--latex--rwrap"}
... ).to_latex(convert_css=True) # doctest: +SKIP
\begin{tabular}{lr}
{} & {0} \\
0 & {\bfseries}{\Huge{1}} \\
\end{tabular}
Examples
--------
Below we give a complete step by step example adding some advanced features
and noting some common gotchas.
First we create the DataFrame and Styler as usual, including MultiIndex rows
and columns, which allow for more advanced formatting options:
>>> cidx = pd.MultiIndex.from_arrays([
... ["Equity", "Equity", "Equity", "Equity",
... "Stats", "Stats", "Stats", "Stats", "Rating"],
... ["Energy", "Energy", "Consumer", "Consumer", "", "", "", "", ""],
... ["BP", "Shell", "H&M", "Unilever",
... "Std Dev", "Variance", "52w High", "52w Low", ""]
... ])
>>> iidx = pd.MultiIndex.from_arrays([
... ["Equity", "Equity", "Equity", "Equity"],
... ["Energy", "Energy", "Consumer", "Consumer"],
... ["BP", "Shell", "H&M", "Unilever"]
... ])
>>> styler = pd.DataFrame([
... [1, 0.8, 0.66, 0.72, 32.1678, 32.1678**2, 335.12, 240.89, "Buy"],
... [0.8, 1.0, 0.69, 0.79, 1.876, 1.876**2, 14.12, 19.78, "Hold"],
... [0.66, 0.69, 1.0, 0.86, 7, 7**2, 210.9, 140.6, "Buy"],
... [0.72, 0.79, 0.86, 1.0, 213.76, 213.76**2, 2807, 3678, "Sell"],
... ], columns=cidx, index=iidx).style
Second we will format the display and, since our table is quite wide, will
hide the repeated level-0 of the index:
>>> (styler.format(subset="Equity", precision=2)
... .format(subset="Stats", precision=1, thousands=",")
... .format(subset="Rating", formatter=str.upper)
... .format_index(escape="latex", axis=1)
... .format_index(escape="latex", axis=0)
... .hide(level=0, axis=0)) # doctest: +SKIP
Note that one of the string entries of the index and column headers is "H&M".
Without applying the `escape="latex"` option to the `format_index` method the
resultant LaTeX will fail to render, and the error returned is quite
difficult to debug. Using the appropriate escape the "&" is converted to "\\&".
Thirdly we will apply some (CSS-HTML) styles to our object. We will use a
builtin method and also define our own method to highlight the stock
recommendation:
>>> def rating_color(v):
... if v == "Buy": color = "#33ff85"
... elif v == "Sell": color = "#ff5933"
... else: color = "#ffdd33"
... return f"color: {color}; font-weight: bold;"
>>> (styler.background_gradient(cmap="inferno", subset="Equity", vmin=0, vmax=1)
... .map(rating_color, subset="Rating")) # doctest: +SKIP
All the above styles will work with HTML (see below) and LaTeX upon conversion:
.. figure:: ../../_static/style/latex_stocks_html.png
However, we finally want to add one LaTeX only style
(from the {graphicx} package), that is not easy to convert from CSS and
pandas does not support it. Notice the `--latex` flag used here,
as well as `--rwrap` to ensure this is formatted correctly and
not ignored upon conversion.
>>> styler.map_index(
... lambda v: "rotatebox:{45}--rwrap--latex;", level=2, axis=1
... ) # doctest: +SKIP
Finally we render our LaTeX adding in other options as required:
>>> styler.to_latex(
... caption="Selected stock correlation and simple statistics.",
... clines="skip-last;data",
... convert_css=True,
... position_float="centering",
... multicol_align="|c|",
... hrules=True,
... ) # doctest: +SKIP
\begin{table}
\centering
\caption{Selected stock correlation and simple statistics.}
\begin{tabular}{llrrrrrrrrl}
\toprule
& & \multicolumn{4}{|c|}{Equity} & \multicolumn{4}{|c|}{Stats} & Rating \\
& & \multicolumn{2}{|c|}{Energy} & \multicolumn{2}{|c|}{Consumer} &
\multicolumn{4}{|c|}{} & \\
& & \rotatebox{45}{BP} & \rotatebox{45}{Shell} & \rotatebox{45}{H\&M} &
\rotatebox{45}{Unilever} & \rotatebox{45}{Std Dev} & \rotatebox{45}{Variance} &
\rotatebox{45}{52w High} & \rotatebox{45}{52w Low} & \rotatebox{45}{} \\
\midrule
\multirow[c]{2}{*}{Energy} & BP & {\cellcolor[HTML]{FCFFA4}}
\color[HTML]{000000} 1.00 & {\cellcolor[HTML]{FCA50A}} \color[HTML]{000000}
0.80 & {\cellcolor[HTML]{EB6628}} \color[HTML]{F1F1F1} 0.66 &
{\cellcolor[HTML]{F68013}} \color[HTML]{F1F1F1} 0.72 & 32.2 & 1,034.8 & 335.1
& 240.9 & \color[HTML]{33FF85} \bfseries BUY \\
& Shell & {\cellcolor[HTML]{FCA50A}} \color[HTML]{000000} 0.80 &
{\cellcolor[HTML]{FCFFA4}} \color[HTML]{000000} 1.00 &
{\cellcolor[HTML]{F1731D}} \color[HTML]{F1F1F1} 0.69 &
{\cellcolor[HTML]{FCA108}} \color[HTML]{000000} 0.79 & 1.9 & 3.5 & 14.1 &
19.8 & \color[HTML]{FFDD33} \bfseries HOLD \\
\cline{1-11}
\multirow[c]{2}{*}{Consumer} & H\&M & {\cellcolor[HTML]{EB6628}}
\color[HTML]{F1F1F1} 0.66 & {\cellcolor[HTML]{F1731D}} \color[HTML]{F1F1F1}
0.69 & {\cellcolor[HTML]{FCFFA4}} \color[HTML]{000000} 1.00 &
{\cellcolor[HTML]{FAC42A}} \color[HTML]{000000} 0.86 & 7.0 & 49.0 & 210.9 &
140.6 & \color[HTML]{33FF85} \bfseries BUY \\
& Unilever & {\cellcolor[HTML]{F68013}} \color[HTML]{F1F1F1} 0.72 &
{\cellcolor[HTML]{FCA108}} \color[HTML]{000000} 0.79 &
{\cellcolor[HTML]{FAC42A}} \color[HTML]{000000} 0.86 &
{\cellcolor[HTML]{FCFFA4}} \color[HTML]{000000} 1.00 & 213.8 & 45,693.3 &
2,807.0 & 3,678.0 & \color[HTML]{FF5933} \bfseries SELL \\
\cline{1-11}
\bottomrule
\end{tabular}
\end{table}
.. figure:: ../../_static/style/latex_stocks.png
T��deepcopy�selectorr� �:�r� rp F�� overwrite)�stoprv �l�r�Sr� � longtablez<`position_float` cannot be used in 'longtable' `environment`)� raggedright�
raggedleft� centeringzR`position_float` should be one of 'raggedright', 'raggedleft', 'centering', got: '�'r� zstyler.latex.hrules�toprulez:toprule�midrulez:midrule�
bottomrulez :bottomruler� z:{� §�}�styler.sparse.index�styler.sparse.columnszstyler.latex.environmentzstyler.latex.multicol_alignzstyler.latex.multirow_align)r� r� r� r� r� r� r� r� �styler.render.encoding�r� r� )�_copyrA �set_table_stylesr> rT r �len�_get_numeric_data�to_list�rangerW rX � hide_index_� enumerate�hidden_columnsrV r
�replace� set_caption�
_render_latexrR �strr )rN r� r� r� r� r� r� r� rC r� r� r� r� r� r� r� r� �obj�style�table_selectors�_original_columns� numeric_cols�level�ci�_rd s r9 re zStyler.to_latex\ s~ � �h �j�j�$�j�'�� � � �,� -1�,=�,=� >�,=�5�U�:�
�,=� >�� � � $� � � � -�!�M�?�8K�L�M� �
!�
� ��
/� � !%� � � 1� 1� � *��D�I�I�4E�4E�0F� G�D�I�I� � �9�9�6�6�8�@�@�H�H�J�L� 1�D�I�I� � �M� �t�z�z� 1� 1�2�� �t�'7�'7��'>��C�G�
� 3�"�4�9�9�#4�#4�5���A��T� 0� 0�0�!�9;�|�9K�G���QT��M� 6�
� � � -�!�M�?�8K�L�M� �
!�
�
� � � � (�Q�x�j�>�B�C� �
!�
�
��k�)� �R�� � �%O�O� � � +� ,�A�/�� �
� � � .�1�^�<L�9M�N�O� �
!�
�
7=�n�� 1�2�&�� � � � �!*�Z�@�!*�Z�@�!-�
�F��
�
!�
� � � � � %�#�e�m�m�C��6N�5O�r�0R�S�T� �
!�
�
� �O�O�G� $� � �%�&;�<�L� � !� '�(?� @�N�!�K�Z�0J�%K� �'�T�:�6S�+T��'�T�:�6S�+T���!�!�%�)�)�)�#�#��� "�
�� �#�s�#� �
=��$<�=�� �
�e��x�@�@��C
?s � K() �
table_uuidrB r� r� � bold_headersrC �max_rows� max_columnsr� � doctype_html�exclude_stylesc � � y r� r� �rN r� r� rB r� r� r� rC r� r� r� r� r� �kwargss r9 r` zStyler.to_html� � � �$ rP c � � y r� r� r� s r9 r` zStyler.to_html� r� rP r� c �z � | j d�� }|r|j |� |r|j |� |� t d� }|� t d� }|r|j ddd�gd �
� |�|j |� |j d|||| | |
xs t d � | d �|
��}t |||�|
�
� S d�
� S )a�
Write Styler to a file, buffer or string in HTML-CSS format.
.. versionadded:: 1.3.0
Parameters
----------
%(buf)s
table_uuid : str, optional
Id attribute assigned to the <table> HTML element in the format:
``<table id="T_<table_uuid>" ..>``
If not given uses Styler's initially assigned value.
table_attributes : str, optional
Attributes to assign within the `<table>` HTML element in the format:
``<table .. <table_attributes> >``
If not given defaults to Styler's preexisting value.
sparse_index : bool, optional
Whether to sparsify the display of a hierarchical index. Setting to False
will display each explicit level element in a hierarchical key for each row.
Defaults to ``pandas.options.styler.sparse.index`` value.
.. versionadded:: 1.4.0
sparse_columns : bool, optional
Whether to sparsify the display of a hierarchical index. Setting to False
will display each explicit level element in a hierarchical key for each
column. Defaults to ``pandas.options.styler.sparse.columns`` value.
.. versionadded:: 1.4.0
bold_headers : bool, optional
Adds "font-weight: bold;" as a CSS property to table style header cells.
.. versionadded:: 1.4.0
caption : str, optional
Set, or overwrite, the caption on Styler before rendering.
.. versionadded:: 1.4.0
max_rows : int, optional
The maximum number of rows that will be rendered. Defaults to
``pandas.options.styler.render.max_rows/max_columns``.
.. versionadded:: 1.4.0
max_columns : int, optional
The maximum number of columns that will be rendered. Defaults to
``pandas.options.styler.render.max_columns``, which is None.
Rows and columns may be reduced if the number of total elements is
large. This value is set to ``pandas.options.styler.render.max_elements``,
which is 262144 (18 bit browser rendering).
.. versionadded:: 1.4.0
%(encoding)s
doctype_html : bool, default False
Whether to output a fully structured HTML file including all
HTML elements, or just the core ``<style>`` and ``<table>`` elements.
exclude_styles : bool, default False
Whether to include the ``<style>`` element and all associated element
``class`` and ``id`` identifiers, or solely the ``<table>`` element without
styling identifiers.
**kwargs
Any additional keyword arguments are passed through to the jinja2
``self.template.render`` process. This is useful when you need to provide
additional variables for a custom template.
Returns
-------
str or None
If `buf` is None, returns the result as a string. Otherwise returns `None`.
See Also
--------
DataFrame.to_html: Write a DataFrame to a file, buffer or string in HTML format.
Examples
--------
>>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
>>> print(df.style.to_html()) # doctest: +SKIP
<style type="text/css">
</style>
<table id="T_1e78e">
<thead>
<tr>
<th class="blank level0" > </th>
<th id="T_1e78e_level0_col0" class="col_heading level0 col0" >A</th>
<th id="T_1e78e_level0_col1" class="col_heading level0 col1" >B</th>
</tr>
...
Tr� Nr� r� �thzfont-weight: bold;r� Fr� r� )r� r� r� �max_colsr� r� r� r� r� )r� �set_uuid�set_table_attributesr
r� r� � _render_htmlr )rN r� r� rB r� r� r� rC r� r� r� r� r� r� r� r_ s r9 r` zStyler.to_html� s� � �Z �j�j�$�j�'�� � �L�L�� $� � � $� $�%5� 6� � �%�&;�<�L� � !� '�(?� @�N� � � � � "�-A�B�C�u�
!�
� � � �O�O�G� $� �s� � �
�%�)� � �)� �E��,D�!E�%�
� �
�� � �c�� �X�
�
�FJ�
�
rP )r� r� r� r� r� � delimiterc � � y r� r� �rN r� r� r� r� r� r� r� s r9 � to_stringzStyler.to_stringP � � � rP c � � y r� r� r� s r9 r� zStyler.to_string^ r� rP � c � � | j d�� }|� t d� }|� t d� }|j |||||�� } t | ||�|�� S d�� S )a�
Write Styler to a file, buffer or string in text format.
.. versionadded:: 1.5.0
Parameters
----------
%(buf)s
%(encoding)s
sparse_index : bool, optional
Whether to sparsify the display of a hierarchical index. Setting to False
will display each explicit level element in a hierarchical key for each row.
Defaults to ``pandas.options.styler.sparse.index`` value.
sparse_columns : bool, optional
Whether to sparsify the display of a hierarchical index. Setting to False
will display each explicit level element in a hierarchical key for each
column. Defaults to ``pandas.options.styler.sparse.columns`` value.
max_rows : int, optional
The maximum number of rows that will be rendered. Defaults to
``pandas.options.styler.render.max_rows``, which is None.
max_columns : int, optional
The maximum number of columns that will be rendered. Defaults to
``pandas.options.styler.render.max_columns``, which is None.
Rows and columns may be reduced if the number of total elements is
large. This value is set to ``pandas.options.styler.render.max_elements``,
which is 262144 (18 bit browser rendering).
delimiter : str, default single space
The separator between data elements.
Returns
-------
str or None
If `buf` is None, returns the result as a string. Otherwise returns `None`.
Examples
--------
>>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
>>> df.style.to_string()
' A B\n0 1 3\n1 2 4\n'
Tr� Nr� r� )r� r� r� r� r� r� )r� r
�_render_stringr )
rN r� r� r� r� r� r� r� r� �texts
r9 r� zStyler.to_stringl s� � �j �j�j�$�j�'�� � �%�&;�<�L� � !� '�(?� @�N��!�!�)�%� � � � "�
�� � �c�� �X�
�
�FJ�
�
rP c � � |j j r|j j s t d� �|j | j
� }t
|j � � D ]Q \ }}t
|dd � D ]; \ }}t j |� r� |dk( r�"t |� | j ||f< �= �S | S )a#
Set the ``class`` attribute of ``<td>`` HTML elements.
Parameters
----------
classes : DataFrame
DataFrame containing strings that will be translated to CSS classes,
mapped by identical column and index key values that must exist on the
underlying Styler data. None, NaN values, and empty strings will
be ignored and not affect the rendered HTML.
Returns
-------
Styler
See Also
--------
Styler.set_table_styles: Set the table styles included within the ``<style>``
HTML element.
Styler.set_table_attributes: Set the table attributes added to the ``<table>``
HTML element.
Notes
-----
Can be used in combination with ``Styler.set_table_styles`` to define an
internal CSS solution without reference to external CSS files.
Examples
--------
>>> df = pd.DataFrame(data=[[1, 2, 3], [4, 5, 6]], columns=["A", "B", "C"])
>>> classes = pd.DataFrame([
... ["min-val red", "", "blue"],
... ["red", None, "blue max-val"]
... ], index=df.index, columns=df.columns)
>>> df.style.set_td_classes(classes) # doctest: +SKIP
Using `MultiIndex` columns and a `classes` `DataFrame` as a subset of the
underlying,
>>> df = pd.DataFrame([[1,2],[3,4]], index=["a", "b"],
... columns=[["level0", "level0"], ["level1a", "level1b"]])
>>> classes = pd.DataFrame(["min-val"], index=["a"],
... columns=[["level0"],["level1a"]])
>>> df.style.set_td_classes(classes) # doctest: +SKIP
Form of the output with new additional css classes,
>>> from pandas.io.formats.style import Styler
>>> df = pd.DataFrame([[1]])
>>> css = pd.DataFrame([["other-class"]])
>>> s = Styler(df, uuid="_", cell_ids=False).set_td_classes(css)
>>> s.hide(axis=0).to_html() # doctest: +SKIP
'<style type="text/css"></style>'
'<table id="T__">'
' <thead>'
' <tr><th class="col_heading level0 col0" >0</th></tr>'
' </thead>'
' <tbody>'
' <tr><td class="data row0 col0 other-class" >1</td></tr>'
' </tbody>'
'</table>'
z>Classes render only if `classes` has unique index and columns.� Nrv ) rW ri rT rj � reindex_liker> r� �
itertuples�pd�isnar� � cell_context)rN �classesr� �row_tup�c�values r9 �set_td_classeszStyler.set_td_classes� s� � �~ �}�}�&�&�g�o�o�.G�.G��P��
� �&�&�t�y�y�1��#�G�$6�$6�$8�9�J�A�w� %�g�a�b�k� 2���5������%�2�+�03�E�
�D�%�%�q�!�f�-� 3� :�
� rP c � � | j j r| j j s t d� �|j D ]� }| j j |� }|| }|j � D ]c \ }}|rt
j |� r� t |� }| j j |� }| j ||f j |� �e �� y)a�
Update the state of the ``Styler`` for data cells.
Collects a mapping of {index_label: [('<property>', '<value>'), ..]}.
Parameters
----------
attrs : DataFrame
should contain strings of '<property>: <value>;<prop2>: <val2>'
Whitespace shouldn't matter and the final trailing ';' shouldn't
matter.
zN`Styler.apply` and `.map` are not compatible with non-unique index or columns.N) rW ri rT rj �get_loc�itemsr� r� r �ctx�extend) rN �attrs�cn�j�ser�rnr� �css_list�is r9 � _update_ctxzStyler._update_ctx� s� � � �z�z�#�#�4�<�<�+A�+A��4��
�
�-�-�B�� � �$�$�R�(�A���)�C� ������A��B�G�G�A�J� �6�q�9���J�J�&�&�r�*�����!�Q�� �'�'��1� %� rP c � � |j D ]s }|| }|j � D ]Y \ }}|s� t |� }|dk( r!| j ||f j |� �:| j
||f j |� �[ �u y)a
Update the state of the ``Styler`` for header 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
r N)rT r� r � ctx_indexr� � ctx_columns)rN r� �axisr� r� r� r� r� s r9 �_update_ctx_headerzStyler._update_ctx_header s~ � � � � �A���(�C�� � � ���1�� �6�q�9���1�9��N�N�A�q�6�*�1�1�(�;��$�$�a��V�,�3�3�H�=� $� rP c � � t | � | j � }g d�}g d�}|D ] }t ||t | |� � � |D ]2 }t | |� }t |||rt j
|� n|� �4 |S )a
Copies a Styler, allowing for deepcopy or shallow copy
Copying a Styler aims to recreate a new Styler object which contains the same
data and styles as the original.
Data dependent attributes [copied and NOT exported]:
- formatting (._display_funcs)
- hidden index values or column values (.hidden_rows, .hidden_columns)
- tooltips
- cell_context (cell css classes)
- ctx (cell css styles)
- caption
- concatenated stylers
Non-data dependent attributes [copied and exported]:
- css
- hidden index state and hidden columns state (.hide_index_, .hide_columns_)
- table_attributes
- table_styles
- applied styles (_todo)
)
r� �
hide_columns_�hide_column_names�hide_index_namesrB rD rC r? r@ �template_latex�template_html_style�template_html_table�
template_html)�cssrY �_display_funcs�_display_funcs_index�_display_funcs_columns� hidden_rowsr� r� r r r� �_todorA rk )�typer> �setattr�getattr�copyr� )rN r� �styler�shallow�deep�attr�vals r9 r� z Styler._copy7 s� � �2 ��d�� �I�I�
��
��
��" �D� �F�D�'�$��"5� 6� � �D��$��%�C� �F�D��$�-�-��"4�c� J� � �
rP c �& � | j d�� S )NFr� �r� ra s r9 �__copy__zStyler.__copy__| s � ��z�z�5�z�)�)rP c �& � | j d�� S )NTr� r )rN �memos r9 � __deepcopy__zStyler.__deepcopy__ s � ��z�z�4�z�(�(rP c � � t | j | j �� }|j D �cg c] }t |� r�|�� }}| j D �cg c] }t |� r�|�� }}|D ] }t | |t
||� � � t |� j |� D ] }t | |� � yc c}w c c}w )a�
Reset the ``Styler``, removing any previously applied styles.
Returns None.
Examples
--------
>>> df = pd.DataFrame({'A': [1, 2], 'B': [3, np.nan]})
After any added style:
>>> df.style.highlight_null(color='yellow') # doctest: +SKIP
Remove it with:
>>> df.style.clear() # doctest: +SKIP
Please see:
`Table Visualization <../../user_guide/style.ipynb>`_ for more examples.
�r? N)
r< r> r? �__dict__�callabler r �set�
difference�delattr)rN �
clean_copy�a� clean_attrs�
self_attrsr s r9 �clearz Styler.clear� s� � �, �D�I�I�D�I�I�6�
�",�"5�"5�I�"5�Q�X�a�[�q�"5� �I�!%� � �B� �A�h�q�k�a� �
�B� �D� �D�$��
�D� 9� :� ��
�O�.�.�{�;�D� �D�$� � <�� J��Bs �B6�B6�B;�&B;c �4 � |� t d � n|}t |� }| j j | }|j r t � }�n|�� ||fi |��}t
|t
� s�t
|t j � st dt |� � d�� �|j |j k7 r1t dt |� � d|j � d|j � �� �t ||j |j �� }n_| j j |� }|dk( r |j |fddi|��}n) |j" j |fddi|��j" }t
|t$ � rt dt |� � d�� �dt |� � d |�d
nd � d �}t' |j j) |j � � sDt |j+ d
|j j |j j � � �t' |j j) |j � � sDt |j+ d|j j |j j � � �| j- |� | S )Nz Function zP must return a DataFrame or ndarray when passed to `Styler.apply` with axis=Nonez6 returned ndarray with wrong shape.
Result has shape: z
Expected shape: �rW rT r r z� resulted in the apply method collapsing to a Series.
Usually, this is the result of the function returning a single value, instead of list-like.zU created invalid {0} labels.
Usually, this is the result of the function returning a r r z� which contains invalid labels, or returning an incorrectly shaped, list-like object which cannot be mapped to labels, possibly due to applying the function along the wrong axis.
Result {0} has shape: {1}
Expected {0} shape: {2}rW rT )�slicer r> �loc�emptyr rR �np�ndarrayrS �repr�shaperV rW rT �_get_axis_number�apply�Tr �all�isinrM r )rN r8 r �subsetr� r> �result�msgs r9 �_applyz
Styler._apply� sM � � !'���t��F��#�F�+���y�y�}�}�V�$�� �:�:� �[�F�
�\��$�)�&�)�F� �f�i�0�!�&�"�*�*�5�#�#�D��J�<� 0G� H�� � �:�:�� � �-�$�#�D��J�<� 0-�-3�\�\�N� ;+�+/�:�:�,�8�� �
#�6����T�\�\�R���9�9�-�-�d�3�D��q�y�#����D�;�q�;�F�;��%���� � �d�=��=�f�=�?�?�� �f�f� %� ��D��J�<� (6� 7��
� ��T�
�|� $6� �+�x��=� >,�
-� � �6�<�<�$�$�T�Z�Z�0�1� �S�Z�Z��� � �1C�1C�T�Z�Z�EU�EU� V�W� W��6�>�>�&�&�t�|�|�4�5� ��
�
�9�f�n�n�&:�&:�D�L�L�<N�<N�O��
�
���� �� rP �r= c �J � | j j d� |||f|f� | S )a'
Apply a CSS-styling function column-wise, row-wise, or table-wise.
Updates the HTML representation with the result.
Parameters
----------
func : function
``func`` should take a Series if ``axis`` in [0,1] and return a list-like
object of same length, or a Series, not necessarily of same length, with
valid index labels considering ``subset``.
``func`` should take a DataFrame if ``axis`` is ``None`` and return either
an ndarray with the same shape or a DataFrame, not necessarily of the same
shape, with valid index and columns labels considering ``subset``.
.. versionchanged:: 1.3.0
.. versionchanged:: 1.4.0
axis : {0 or 'index', 1 or 'columns', None}, default 0
Apply to each column (``axis=0`` or ``'index'``), to each row
(``axis=1`` or ``'columns'``), or to the entire DataFrame at once
with ``axis=None``.
%(subset)s
**kwargs : dict
Pass along to ``func``.
Returns
-------
Styler
See Also
--------
Styler.map_index: Apply a CSS-styling function to headers elementwise.
Styler.apply_index: Apply a CSS-styling function to headers level-wise.
Styler.map: Apply a CSS-styling function elementwise.
Notes
-----
The elements of the output of ``func`` should be CSS styles as strings, in the
format 'attribute: value; attribute2: value2; ...' or,
if nothing is to be applied to that element, an empty string or ``None``.
This is similar to ``DataFrame.apply``, except that ``axis=None``
applies the function to the entire DataFrame at once,
rather than column-wise or row-wise.
Examples
--------
>>> def highlight_max(x, color):
... return np.where(x == np.nanmax(x.to_numpy()), f"color: {color};", None)
>>> df = pd.DataFrame(np.random.randn(5, 2), columns=["A", "B"])
>>> df.style.apply(highlight_max, color='red') # doctest: +SKIP
>>> df.style.apply(highlight_max, color='blue', axis=1) # doctest: +SKIP
>>> df.style.apply(highlight_max, color='green', axis=None) # doctest: +SKIP
Using ``subset`` to restrict application to a single column or multiple columns
>>> df.style.apply(highlight_max, color='red', subset="A")
... # doctest: +SKIP
>>> df.style.apply(highlight_max, color='red', subset=["A", "B"])
... # doctest: +SKIP
Using a 2d input to ``subset`` to select rows in addition to columns
>>> df.style.apply(highlight_max, color='red', subset=([0, 1, 2], slice(None)))
... # doctest: +SKIP
>>> df.style.apply(highlight_max, color='red', subset=(slice(0, 5, 2), "A"))
... # doctest: +SKIP
Using a function which returns a Series / DataFrame of unequal length but
containing valid index labels
>>> df = pd.DataFrame([[1, 2], [3, 4], [4, 6]], index=["A1", "A2", "Total"])
>>> total_style = pd.Series("font-weight: bold;", index=["Total"])
>>> df.style.apply(lambda s: total_style) # doctest: +SKIP
See `Table Visualization <../../user_guide/style.ipynb>`_ user guide for
more details.
c � � t | d� S )Nr@ �r ��instances r9 �<lambda>z Styler.apply.<locals>.<lambda>4 s � �g�h�� 9rP �r rZ )rN r8 r r= r� s r9 r9 z Styler.apply� s0 � �p
�
�
���
9�D�$��;O�QW� X�
� � rP r9 c �l � | j j |� }|dk( r | j n | j }t ||� }t |j
� � j d d �|f }|dk( r |j |fddi|��} n|dk( r |j |fi |��} | j |� | S )Nr r9 r �map) r> r8 rW rT r! r r� r2 r9 rJ r )
rN r8 r r� �methodr� r� �levels_r> r> s
r9 � _apply_indexzStyler._apply_index8 s� � � �y�y�)�)�$�/�� �A�I�d�j�j�4�<�<��!�%��-������ �'�+�+�A�w�J�7�� �W� � �T�Z�Z��7�1�7��7�F�
�u�_� �T�X�X�d�-�f�-�F� � � ���-�� rP z
level-wiserJ � elementwisez:take a Series and return a string array of the same lengthz>the index as a Series, if an Index, or a level of a MultiIndexz3an identically sized array of CSS styles as strings�sz3np.where(s == "B", "background-color: yellow;", "")z<["background-color: yellow;" if "x" in v else "" for v in s])
�this�wise�alt�altwiser8 �
input_note� output_note�var�ret�ret2c �L � | j j d� |||df|f� | S )a
Apply a CSS-styling function to the index or column headers, {wise}.
Updates the HTML representation with the result.
.. versionadded:: 1.4.0
.. versionadded:: 2.1.0
Styler.applymap_index was deprecated and renamed to Styler.map_index.
Parameters
----------
func : function
``func`` should {func}.
axis : {{0, 1, "index", "columns"}}
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.
**kwargs : dict
Pass along to ``func``.
Returns
-------
Styler
See Also
--------
Styler.{alt}_index: Apply a CSS-styling function to headers {altwise}.
Styler.apply: Apply a CSS-styling function column-wise, row-wise, or table-wise.
Styler.map: Apply a CSS-styling function elementwise.
Notes
-----
Each input to ``func`` will be {input_note}. The output of ``func`` should be
{output_note}, in the format 'attribute: value; attribute2: value2; ...'
or, if nothing is to be applied to that element, an empty string or ``None``.
Examples
--------
Basic usage to conditionally highlight values in the index.
>>> df = pd.DataFrame([[1,2], [3,4]], index=["A", "B"])
>>> def color_b(s):
... return {ret}
>>> df.style.{this}_index(color_b) # doctest: +SKIP
.. figure:: ../../_static/style/appmaphead1.png
Selectively applying to specific levels of MultiIndex columns.
>>> midx = pd.MultiIndex.from_product([['ix', 'jy'], [0, 1], ['x3', 'z4']])
>>> df = pd.DataFrame([np.arange(8)], columns=midx)
>>> def highlight_x({var}):
... return {ret2}
>>> df.style.{this}_index(highlight_x, axis="columns", level=[0, 2])
... # doctest: +SKIP
.. figure:: ../../_static/style/appmaphead2.png
c � � t | d� S �NrM rD rE s r9 rG z$Styler.apply_index.<locals>.<lambda>� � � ���>�!BrP r9 rH �rN r8 r r� r� s r9 � apply_indexzStyler.apply_indexN s5 � �\
�
�
���B��t�U�G�,��
�
� � rP z!take a scalar and return a stringz=an index value, if an Index, or a level value of a MultiIndexzCSS styles as a string�vz1"background-color: yellow;" if v == "B" else Nonez1"background-color: yellow;" if "x" in v else Nonec �L � | j j d� |||df|f� | S )Nc � � t | d� S r[ rD rE s r9 rG z"Styler.map_index.<locals>.<lambda>� r\ rP rJ rH r] s r9 � map_indexzStyler.map_index� s4 � �(
�
�
���B��t�U�E�*��
�
� � rP c �t � t j dt t � �� | j |||fi |��S )a�
Apply a CSS-styling function to the index or column headers, elementwise.
.. deprecated:: 2.1.0
Styler.applymap_index has been deprecated. Use Styler.map_index instead.
Parameters
----------
func : function
``func`` should take a scalar and return a string.
axis : {{0, 1, "index", "columns"}}
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.
**kwargs : dict
Pass along to ``func``.
Returns
-------
Styler
zHStyler.applymap_index has been deprecated. Use Styler.map_index instead.��
stacklevel)�warnings�warn�
FutureWarningr rb r] s r9 �applymap_indexzStyler.applymap_index� s8 � �: �
�
� V� �'�)�
�
�t�~�~�d�D�%�:�6�:�:rP c � � t |fi |��}|� t d d }t |� }| j j | j |� }| j
|� | S r� )r r r r> r2 rJ r )rN r8 r= r� r> s r9 �_mapz Styler._map� sY � ��t�&�v�&�� �>� ��]�F�#�F�+����� � �v�&�*�*�4�0�� ���� �� rP c �H � | j j d� ||f|f� | S )ai
Apply a CSS-styling function elementwise.
Updates the HTML representation with the result.
Parameters
----------
func : function
``func`` should take a scalar and return a string.
%(subset)s
**kwargs : dict
Pass along to ``func``.
Returns
-------
Styler
See Also
--------
Styler.map_index: Apply a CSS-styling function to headers elementwise.
Styler.apply_index: Apply a CSS-styling function to headers level-wise.
Styler.apply: Apply a CSS-styling function column-wise, row-wise, or table-wise.
Notes
-----
The elements of the output of ``func`` should be CSS styles as strings, in the
format 'attribute: value; attribute2: value2; ...' or,
if nothing is to be applied to that element, an empty string or ``None``.
Examples
--------
>>> def color_negative(v, color):
... return f"color: {color};" if v < 0 else None
>>> df = pd.DataFrame(np.random.randn(5, 2), columns=["A", "B"])
>>> df.style.map(color_negative, color='red') # doctest: +SKIP
Using ``subset`` to restrict application to a single column or multiple columns
>>> df.style.map(color_negative, color='red', subset="A")
... # doctest: +SKIP
>>> df.style.map(color_negative, color='red', subset=["A", "B"])
... # doctest: +SKIP
Using a 2d input to ``subset`` to select rows in addition to columns
>>> df.style.map(color_negative, color='red',
... subset=([0,1,2], slice(None))) # doctest: +SKIP
>>> df.style.map(color_negative, color='red', subset=(slice(0,5,2), "A"))
... # doctest: +SKIP
See `Table Visualization <../../user_guide/style.ipynb>`_ user guide for
more details.
c � � t | d� S )Nrk rD rE s r9 rG z Styler.map.<locals>.<lambda>' s � �g�h�� 7rP rH �rN r8 r= r� s r9 rJ z
Styler.map� s, � �n
�
�
���
7�$�� �� P�
� � rP c �r � t j dt t � �� | j ||fi |��S )a�
Apply a CSS-styling function elementwise.
.. deprecated:: 2.1.0
Styler.applymap has been deprecated. Use Styler.map instead.
Parameters
----------
func : function
``func`` should take a scalar and return a string.
%(subset)s
**kwargs : dict
Pass along to ``func``.
Returns
-------
Styler
z<Styler.applymap has been deprecated. Use Styler.map instead.rd )rf rg rh r rJ rn s r9 �applymapzStyler.applymap+ s6 � �. �
�
� J� �'�)�
�
�t�x�x��f�/��/�/rP c � � || _ | S )a
Set the table attributes added to the ``<table>`` HTML element.
These are items in addition to automatic (by default) ``id`` attribute.
Parameters
----------
attributes : str
Returns
-------
Styler
See Also
--------
Styler.set_table_styles: Set the table styles included within the ``<style>``
HTML element.
Styler.set_td_classes: Set the DataFrame of strings added to the ``class``
attribute of ``<td>`` HTML elements.
Examples
--------
>>> df = pd.DataFrame(np.random.randn(10, 4))
>>> df.style.set_table_attributes('class="pure-table"') # doctest: +SKIP
# ... <table class="pure-table"> ...
)rB )rN �
attributess r9 r� zStyler.set_table_attributesI s � �6 !+�� �� rP c
�N � t j | j � | j t j | j � t | j
� t | j � | j | j t j | j � d�S )a�
Export the styles applied to the current Styler.
Can be applied to a second Styler with ``Styler.use``.
Returns
-------
dict
See Also
--------
Styler.use: Set the styles on the current Styler.
Styler.copy: Create a copy of the current Styler.
Notes
-----
This method is designed to copy non-data dependent attributes of
one Styler to another. It differs from ``Styler.copy`` where data and
data dependent attributes are also copied.
The following items are exported since they are not generally data dependent:
- Styling functions added by the ``apply`` and ``map``
- Whether axes and names are hidden from the display, if unambiguous.
- Table attributes
- Table styles
The following attributes are considered data dependent and therefore not
exported:
- Caption
- UUID
- Tooltips
- Any hidden rows or columns identified by Index labels
- Any formatting applied using ``Styler.format``
- Any CSS classes added using ``Styler.set_td_classes``
Examples
--------
>>> styler = pd.DataFrame([[1, 2], [3, 4]]).style
>>> styler2 = pd.DataFrame([[9, 9, 9]]).style
>>> styler.hide(axis=0).highlight_max(axis=1) # doctest: +SKIP
>>> export = styler.export()
>>> styler2.use(export) # doctest: +SKIP
)r9 rB rA �
hide_index� hide_columnsr r r )
r r rB rA r; r� r r r r ra s r9 �exportz
Styler.exportg sx � �` �Y�Y�t�z�z�*� $� 5� 5� �I�I�d�&7�&7� 8� �d� .� .�/� �� 2� 2� 3� $� 5� 5�!%�!7�!7��9�9�T�X�X�&�
�
rP c � � | j j |j dg � � | j xs d}|j d� �dnt |j d� � }| j |dz |z j
� � |j d� r"| j |j d� d�� dD ]j }|j d |z � }|��t |t � r.t | |� j }t | d |z d
z |g|z � �Xt | d |z d
z |� �l |j d d� | _
|j d d� | _ |j d
� r|j d
� | _ | S )a4
Set the styles on the current Styler.
Possibly uses styles from ``Styler.export``.
Parameters
----------
styles : dict(str, Any)
List of attributes to add to Styler. Dict keys should contain only:
- "apply": list of styler functions, typically added with ``apply`` or
``map``.
- "table_attributes": HTML attributes, typically added with
``set_table_attributes``.
- "table_styles": CSS selectors and properties, typically added with
``set_table_styles``.
- "hide_index": whether the index is hidden, typically added with
``hide_index``, or a boolean list for hidden levels.
- "hide_columns": whether column headers are hidden, typically added with
``hide_columns``, or a boolean list for hidden levels.
- "hide_index_names": whether index names are hidden.
- "hide_column_names": whether column header names are hidden.
- "css": the css class names used.
Returns
-------
Styler
See Also
--------
Styler.export : Export the non data dependent attributes to the current Styler.
Examples
--------
>>> styler = pd.DataFrame([[1, 2], [3, 4]]).style
>>> styler2 = pd.DataFrame([[9, 9, 9]]).style
>>> styler.hide(axis=0).highlight_max(axis=1) # doctest: +SKIP
>>> export = styler.export()
>>> styler2.use(export) # doctest: +SKIP
r9 rv rB r� rA Fr� r0 �hide_r� r r r )r r� �getrB r� r� �stripr� rR �boolr rX r r r r )rN �stylesrB �obj_table_attsr� �hide_obj�ns r9 �usez
Styler.use� sf � �R
�
�
���&�*�*�W�b�1�2� $� 5� 5� ;��� �z�z�,�-�5�
��V�Z�Z� 2�3�4� �
�!�!�#3�c�#9�N�#J�"Q�"Q�"S�T� �:�:�n� %� � !� !�&�*�*�^�"<�� !� N�'�C� �z�z�'�C�-�0�H��#� �h��-� ��c�*�2�2�A��D�'�C�-�#�"5��z�A�~�F��D�'�C�-�#�"5�x�@� (� !'�
�
�+=�u� E�� �!'���,?��!G�� � �:�:�e� � �z�z�%�(�D�H�� rP c � � || _ | S )a�
Set the uuid applied to ``id`` attributes of HTML elements.
Parameters
----------
uuid : str
Returns
-------
Styler
Notes
-----
Almost all HTML elements within the table, and including the ``<table>`` element
are assigned ``id`` attributes. The format is ``T_uuid_<extra>`` where
``<extra>`` is typically a more specific identifier, such as ``row1_col2``.
Examples
--------
>>> df = pd.DataFrame([[1, 2], [3, 4]], index=['A', 'B'], columns=['c1', 'c2'])
You can get the `id` attributes with the following:
>>> print((df).style.to_html()) # doctest: +SKIP
To add a title to column `c1`, its `id` is T_20a7d_level0_col0:
>>> df.style.set_uuid("T_20a7d_level0_col0")
... .set_caption("Test") # doctest: +SKIP
Please see:
`Table visualization <../../user_guide/style.ipynb>`_ for more examples.
r$ )rN r? s r9 r� zStyler.set_uuid� s � �D �� �� rP c � � d}t |t t f� r?t |� dk7 s&t |d t � rt |d t � s&t |� �t |t � s t |� �|| _ | S )a�
Set the text added to a ``<caption>`` HTML element.
Parameters
----------
caption : str, tuple, list
For HTML output either the string input is used or the first element of the
tuple. For LaTeX the string input provides a caption and the additional
tuple input allows for full captions and short captions, in that order.
Returns
-------
Styler
Examples
--------
>>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
>>> df.style.set_caption("test") # doctest: +SKIP
Please see:
`Table Visualization <../../user_guide/style.ipynb>`_ for more examples.
z8`caption` must be either a string or 2-tuple of strings.� r r� )rR �list�tupler� r� rV rC )rN rC r? s r9 r� zStyler.set_caption sj � �. I�� �g��e�}� -��G� ��!�!�'�!�*�c�2�!�'�!�*�c�2� ��o�%��G�S�)� �S�/� !� �� �� rP c
�> � | j j |� }|dk( r| j j n| j j }|s |dk( rdndn|}d}t |t
j � si|dk( rRd|dz d�g}| j j d ��n|d |� d
�z |d d < |j d |d
|� d|� d�z d�� �n?d|dz d�d|dz d�g}�n-t t |j � � }|r t ||� n|}t |� }|dk( r�g }t |� D ]- \ } }
|j d|
dz � d�|d
| |z � d|� d�z d�� �/ t d� | j j D � � s�|j d|j dz � d�|d
t! |� |z � d|� d�z d�� nPg }t |� D ]@ \ } }
|d| |z � d|� d|� d�z } |j# d |
dz � d �| d z d�d |
� �| d z d�g� �B | j% |d!�"� S )#aI
Add CSS to permanently display the index or column headers in a scrolling frame.
Parameters
----------
axis : {0 or 'index', 1 or 'columns'}, default 0
Whether to make the index or column headers sticky.
pixel_size : int, optional
Required to configure the width of index cells or the height of column
header cells when sticking a MultiIndex (or with a named Index).
Defaults to 75 and 25 respectively.
levels : int, str, list, optional
If ``axis`` is a MultiIndex the specific levels to stick. If ``None`` will
stick all levels.
Returns
-------
Styler
Notes
-----
This method uses the CSS 'position: sticky;' property to display. It is
designed to work with visible axes, therefore both:
- `styler.set_sticky(axis="index").hide(axis="index")`
- `styler.set_sticky(axis="columns").hide(axis="columns")`
may produce strange behaviour due to CSS controls with missing elements.
Examples
--------
>>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
>>> df.style.set_sticky(axis="index") # doctest: +SKIP
Please see:
`Table Visualization <../../user_guide/style.ipynb>`_ for more examples.
r �K � z*position:sticky; background-color:inherit;r� zthead tr:nth-child(1) thztop:0px; z-index:2;r� ztop:0px; z-index:2; height:zpx;rp zthead tr:nth-child(2) thztop:zpx; z-index:2; height:zpx; zthead tr th:nth-child(1)z left:0px; z-index:3 !important;ztbody tr th:nth-child(1)zleft:0px; z-index:1;zthead tr:nth-child(z) thz px; height:zpx; z-index:2;c 3 �$ K � | ] }|d u �� �
y �wr� r� )�.0�names r9 � <genexpr>z$Styler.set_sticky.<locals>.<genexpr>� s � �� �E�4D�D�4�4�<�4D�s �zleft:zpx; min-width:zpx; max-width:zthead tr th:nth-child(�)zz-index:3 !important;ztbody tr th.levelz
z-index:1;Fr� )r> r8 rW rT rR r� �
MultiIndex�namesrZ r� r� rX r! �sortedr� r; r� r� r� ) rN r �
pixel_size�levelsr� rp r| � range_idxrL r� r� �props_s r9 �
set_stickyzStyler.set_sticky- s� � �V �y�y�)�)�$�/��!%���d�i�i�o�o�� � �0A�0A��6@�D�A�I�b�2�j�
�<���#�r�}�}�-� �q�y�
%?�!&�)>�!>��%�� �:�:�#�#�A�&�2� �"=�j�\�� M�M� �1�I�g�&� �M�M�(B�%*� $�Z�L�0F�z�l�RV� W�&X��� %?�!&�)J�!J��
%?�!&�)?�!?�� �� �U�3�;�;� /�0�I�AG� ���!=�Y�G� �W�o�G��q�y��� )�'� 2�H�A�u��M�M�*=�e�A�g�Y�d�(K�%*�"&�q�:�~�&6�k�*� � N-� !-�& �� � !3� �E�D�J�J�4D�4D�E�E��M�M�*=�c�k�k�!�m�_�D�(Q�%*�"&��G� �
�'B�&C� D*�*4� �^�!E�& �� � �� )�'� 2�H�A�u� "� ��J�� /� 0%�%/�L� 1%�%/�L��6� �F�
�M�M� /E�U�1�W�I�Q�,O�)/�2I�)I� �
/@��w�,G�)/�,�)>� � � �
!3�& �$�$�V�u�$�=�=rP c
� � |�i | j �|�| _ |�| S t |t � r�| j j |� }|dk( r| j j
n| j j }|dk( rd| j d � �nd| j d � �}|j � D ��� �
cg c]X \ }}|j |g� D ]> } t |� D ]. }
t |
d � |z t | � z t |
d � d���0 �@ �Z }} }}}
n!|D �
cg c] }
|
d t |
d � d��� }}
|s)| j � | j j |� | S || _ | S c c}
} }}w c c}
w )am
Set the table styles included within the ``<style>`` HTML element.
This function can be used to style the entire table, columns, rows or
specific HTML selectors.
Parameters
----------
table_styles : list or dict
If supplying a list, each individual table_style should be a
dictionary with ``selector`` and ``props`` keys. ``selector``
should be a CSS selector that the style will be applied to
(automatically prefixed by the table's UUID) and ``props``
should be a list of tuples with ``(attribute, value)``.
If supplying a dict, the dict keys should correspond to
column names or index values, depending upon the specified
`axis` argument. These will be mapped to row or col CSS
selectors. MultiIndex values as dict keys should be
in their respective tuple form. The dict values should be
a list as specified in the form with CSS selectors and
props that will be applied to the specified row or column.
axis : {0 or 'index', 1 or 'columns', None}, default 0
Apply to each column (``axis=0`` or ``'index'``), to each row
(``axis=1`` or ``'columns'``). Only used if `table_styles` is
dict.
overwrite : bool, default True
Styles are replaced if `True`, or extended if `False`. CSS
rules are preserved so most recent styles set will dominate
if selectors intersect.
css_class_names : dict, optional
A dict of strings used to replace the default CSS classes described below.
.. versionadded:: 1.4.0
Returns
-------
Styler
See Also
--------
Styler.set_td_classes: Set the DataFrame of strings added to the ``class``
attribute of ``<td>`` HTML elements.
Styler.set_table_attributes: Set the table attributes added to the ``<table>``
HTML element.
Notes
-----
The default CSS classes dict, whose values can be replaced is as follows:
.. code-block:: python
css_class_names = {"row_heading": "row_heading",
"col_heading": "col_heading",
"index_name": "index_name",
"col": "col",
"row": "row",
"col_trim": "col_trim",
"row_trim": "row_trim",
"level": "level",
"data": "data",
"blank": "blank",
"foot": "foot"}
Examples
--------
>>> df = pd.DataFrame(np.random.randn(10, 4),
... columns=['A', 'B', 'C', 'D'])
>>> df.style.set_table_styles(
... [{'selector': 'tr:hover',
... 'props': [('background-color', 'yellow')]}]
... ) # doctest: +SKIP
Or with CSS strings
>>> df.style.set_table_styles(
... [{'selector': 'tr:hover',
... 'props': 'background-color: yellow; font-size: 1em;'}]
... ) # doctest: +SKIP
Adding column styling by name
>>> df.style.set_table_styles({
... 'A': [{'selector': '',
... 'props': [('color', 'red')]}],
... 'B': [{'selector': 'td',
... 'props': 'color: blue;'}]
... }, overwrite=False) # doctest: +SKIP
Adding row styling
>>> df.style.set_table_styles({
... 0: [{'selector': 'td:hover',
... 'props': [('font-size', '25px')]}]
... }, axis=1, overwrite=False) # doctest: +SKIP
See `Table Visualization <../../user_guide/style.ipynb>`_ user guide for
more details.
r� �.�row�colr� rp r� )r rR �dictr> r8 rW rT r� �get_indexer_forr r� r rA r� ) rN rA r r� �css_class_namesr� �idf�keyr| �idxrO s r9 r� zStyler.set_table_styles� s� � �R � &�6�$�(�(�6�o�6�D�H� � ��K�
� �d�
+��9�9�-�-�d�3�D�%)�Q�Y�$�)�)�/�/�D�I�I�4E�4E�C�+/�1�9�A�d�h�h�u�o�&�'�A�d�h�h�u�o�=N�:O�C� $0�#5�#5�#7� �
$8�K�C�� �.�.��u�5�C�,�V�4�A� !$�A�j�M� 2�S� 8�3�s�8� C� 8��7�� D�� 5�
�
6� � $8�
� � &� �
&�A� !"�*�
� 8��7�� D�� &�
� � �T� .� .� :� � � � $� $�\� 2� � � !-�D� �� ��- �� s
�6A E.
� E6c
�| � | j j |� }|dk( rd\ }}}nd\ }}}|�
|� t d� �|�l|�|rt | d|� d�d� | S t |t | |� � }t | d|� d �t
t | |� j � D � cg c] } | |v �� c} � ny|dk( rt |dd�f }
n
t dd�|f }
t |
� }| j j | } t | |� j t | |� � } t | d
|� �| � |rt | d|� d�d� | S c c} w ) a�
Hide the entire index / column headers, or specific rows / columns from display.
.. versionadded:: 1.4.0
Parameters
----------
subset : label, array-like, IndexSlice, optional
A valid 1d input or single key along the axis within
`DataFrame.loc[<subset>, :]` or `DataFrame.loc[:, <subset>]` depending
upon ``axis``, to limit ``data`` to select hidden rows / columns.
axis : {"index", 0, "columns", 1}
Apply to the index or columns.
level : int, str, list
The level(s) to hide in a MultiIndex if hiding the entire index / column
headers. Cannot be used simultaneously with ``subset``.
names : bool
Whether to hide the level name(s) of the index / columns headers in the case
it (or at least one the levels) remains visible.
Returns
-------
Styler
Notes
-----
.. warning::
This method only works with the output methods ``to_html``, ``to_string``
and ``to_latex``.
Other output methods, including ``to_excel``, ignore this hiding method
and will display all data.
This method has multiple functionality depending upon the combination
of the ``subset``, ``level`` and ``names`` arguments (see examples). The
``axis`` argument is used only to control whether the method is applied to row
or column headers:
.. list-table:: Argument combinations
:widths: 10 20 10 60
:header-rows: 1
* - ``subset``
- ``level``
- ``names``
- Effect
* - None
- None
- False
- The axis-Index is hidden entirely.
* - None
- None
- True
- Only the axis-Index names are hidden.
* - None
- Int, Str, List
- False
- Specified axis-MultiIndex levels are hidden entirely.
* - None
- Int, Str, List
- True
- Specified axis-MultiIndex levels are hidden entirely and the names of
remaining axis-MultiIndex levels.
* - Subset
- None
- False
- The specified data rows/columns are hidden, but the axis-Index itself,
and names, remain unchanged.
* - Subset
- None
- True
- The specified data rows/columns and axis-Index names are hidden, but
the axis-Index itself remains unchanged.
* - Subset
- Int, Str, List
- Boolean
- ValueError: cannot supply ``subset`` and ``level`` simultaneously.
Note this method only hides the identified elements so can be chained to hide
multiple elements in sequence.
Examples
--------
Simple application hiding specific rows:
>>> df = pd.DataFrame([[1,2], [3,4], [5,6]], index=["a", "b", "c"])
>>> df.style.hide(["a", "b"]) # doctest: +SKIP
0 1
c 5 6
Hide the index and retain the data values:
>>> midx = pd.MultiIndex.from_product([["x", "y"], ["a", "b", "c"]])
>>> df = pd.DataFrame(np.random.randn(6,6), index=midx, columns=midx)
>>> df.style.format("{:.1f}").hide() # doctest: +SKIP
x y
a b c a b c
0.1 0.0 0.4 1.3 0.6 -1.4
0.7 1.0 1.3 1.5 -0.0 -0.2
1.4 -0.8 1.6 -0.2 -0.4 -0.3
0.4 1.0 -0.2 -0.8 -1.2 1.1
-0.6 1.2 1.8 1.9 0.3 0.3
0.8 0.5 -0.3 1.2 2.2 -0.8
Hide specific rows in a MultiIndex but retain the index:
>>> df.style.format("{:.1f}").hide(subset=(slice(None), ["a", "c"]))
... # doctest: +SKIP
x y
a b c a b c
x b 0.7 1.0 1.3 1.5 -0.0 -0.2
y b -0.6 1.2 1.8 1.9 0.3 0.3
Hide specific rows and the index through chaining:
>>> df.style.format("{:.1f}").hide(subset=(slice(None), ["a", "c"])).hide()
... # doctest: +SKIP
x y
a b c a b c
0.7 1.0 1.3 1.5 -0.0 -0.2
-0.6 1.2 1.8 1.9 0.3 0.3
Hide a specific level:
>>> df.style.format("{:,.1f}").hide(level=1) # doctest: +SKIP
x y
a b c a b c
x 0.1 0.0 0.4 1.3 0.6 -1.4
0.7 1.0 1.3 1.5 -0.0 -0.2
1.4 -0.8 1.6 -0.2 -0.4 -0.3
y 0.4 1.0 -0.2 -0.8 -1.2 1.1
-0.6 1.2 1.8 1.9 0.3 0.3
0.8 0.5 -0.3 1.2 2.2 -0.8
Hiding just the index level names:
>>> df.index.names = ["lev0", "lev1"]
>>> df.style.format("{:,.1f}").hide(names=True) # doctest: +SKIP
x y
a b c a b c
x a 0.1 0.0 0.4 1.3 0.6 -1.4
b 0.7 1.0 1.3 1.5 -0.0 -0.2
c 1.4 -0.8 1.6 -0.2 -0.4 -0.3
y a 0.4 1.0 -0.2 -0.8 -1.2 1.1
b -0.6 1.2 1.8 1.9 0.3 0.3
c 0.8 0.5 -0.3 1.2 2.2 -0.8
Examples all produce equivalently transposed effects with ``axis="columns"``.
r )rW rW �rows)�columnrT rT Nz4`subset` and `level` cannot be passed simultaneouslyrx �_namesTr� �hidden_) r> r8 rV r r! r r� rX r r r2 r� )
rN r= r r� r� r� �objsrR rL �lev�subset_�hide�h_elss
r9 r� z Styler.hideD
sZ � �x �y�y�)�)�$�/�� �1�9� 5�N�C��s� ;�N�C��s� � ��!3� � S�T� T� �>��}�����c�U�&� 1�4�8�� �%�e�W�T�4�-@�A�G� ����v�Q��+0���t�1D�1L�1L�+M�N�+M�C��� �+M�N�
� �q�y�$�V�Q�Y�/��$�Q��Y�/��'��0�F��9�9�=�=��(�D��D�$�'�7�7���d�8K�L�E� �D�G�C�5�/�5� 1� � �D�E�#��f�-�t� 4�� �� Os � D9 c � � | j j j | j j t j
�� � S )N)�include)r> rT r< �
select_dtypesr4 �numberra s r9 �_get_numeric_subset_defaultz"Styler._get_numeric_subset_default s5 � � �y�y� � �%�%�d�i�i�&=�&=�b�i�i�&=�&P�Q�QrP �
backgroundr� �bgz�text_color_threshold : float or int
Luminance threshold for determining text color in [0, 1]. Facilitates text
visibility across varying background colors. All text is dark if 0, and
light if 1, defaults to 0.408.)r� rR � image_prefix�text_thresholdc
�l � |�| �| j � }| j t ||||||||| ��
| S )a�
Color the {name} in a gradient style.
The {name} color is determined according
to the data in each column, row or frame, or by a given
gradient map. Requires matplotlib.
Parameters
----------
cmap : str or colormap
Matplotlib colormap.
low : float
Compress the color range at the low end. This is a multiple of the data
range to extend below the minimum; good values usually in [0, 1],
defaults to 0.
high : float
Compress the color range at the high end. This is a multiple of the data
range to extend above the maximum; good values usually in [0, 1],
defaults to 0.
axis : {{0, 1, "index", "columns", None}}, default 0
Apply to each column (``axis=0`` or ``'index'``), to each row
(``axis=1`` or ``'columns'``), or to the entire DataFrame at once
with ``axis=None``.
%(subset)s
{text_threshold}
vmin : float, optional
Minimum data value that corresponds to colormap minimum value.
If not specified the minimum value of the data (or gmap) will be used.
vmax : float, optional
Maximum data value that corresponds to colormap maximum value.
If not specified the maximum value of the data (or gmap) will be used.
gmap : array-like, optional
Gradient map for determining the {name} colors. If not supplied
will use the underlying data from rows, columns or frame. If given as an
ndarray or list-like must be an identical shape to the underlying data
considering ``axis`` and ``subset``. If given as DataFrame or Series must
have same index and column labels considering ``axis`` and ``subset``.
If supplied, ``vmin`` and ``vmax`` should be given relative to this
gradient map.
.. versionadded:: 1.3.0
Returns
-------
Styler
See Also
--------
Styler.{alt}_gradient: Color the {alt} in a gradient style.
Notes
-----
When using ``low`` and ``high`` the range
of the gradient, given by the data if ``gmap`` is not given or by ``gmap``,
is extended at the low end effectively by
`map.min - low * map.range` and at the high end by
`map.max + high * map.range` before the colors are normalized and determined.
If combining with ``vmin`` and ``vmax`` the `map.min`, `map.max` and
`map.range` are replaced by values according to the values derived from
``vmin`` and ``vmax``.
This method will preselect numeric columns and ignore non-numeric columns
unless a ``gmap`` is supplied in which case no preselection occurs.
Examples
--------
>>> df = pd.DataFrame(columns=["City", "Temp (c)", "Rain (mm)", "Wind (m/s)"],
... data=[["Stockholm", 21.6, 5.0, 3.2],
... ["Oslo", 22.4, 13.3, 3.1],
... ["Copenhagen", 24.5, 0.0, 6.7]])
Shading the values column-wise, with ``axis=0``, preselecting numeric columns
>>> df.style.{name}_gradient(axis=0) # doctest: +SKIP
.. figure:: ../../_static/style/{image_prefix}_ax0.png
Shading all values collectively using ``axis=None``
>>> df.style.{name}_gradient(axis=None) # doctest: +SKIP
.. figure:: ../../_static/style/{image_prefix}_axNone.png
Compress the color map from the both ``low`` and ``high`` ends
>>> df.style.{name}_gradient(axis=None, low=0.75, high=1.0) # doctest: +SKIP
.. figure:: ../../_static/style/{image_prefix}_axNone_lowhigh.png
Manually setting ``vmin`` and ``vmax`` gradient thresholds
>>> df.style.{name}_gradient(axis=None, vmin=6.7, vmax=21.6) # doctest: +SKIP
.. figure:: ../../_static/style/{image_prefix}_axNone_vminvmax.png
Setting a ``gmap`` and applying to all columns with another ``cmap``
>>> df.style.{name}_gradient(axis=0, gmap=df['Temp (c)'], cmap='YlOrRd')
... # doctest: +SKIP
.. figure:: ../../_static/style/{image_prefix}_gmap.png
Setting the gradient map for a dataframe (i.e. ``axis=None``), we need to
explicitly state ``subset`` to match the ``gmap`` shape
>>> gmap = np.array([[1,2,3], [2,3,4], [3,4,5]])
>>> df.style.{name}_gradient(axis=None, gmap=gmap,
... cmap='YlOrRd', subset=['Temp (c)', 'Rain (mm)', 'Wind (m/s)']
... ) # doctest: +SKIP
.. figure:: ../../_static/style/{image_prefix}_axNone_gmap.png
) �cmapr= r �low�high�text_color_threshold�vmin�vmax�gmap�r� r9 �_background_gradient)
rN r� r� r� r r= r� r� r� r� s
r9 �background_gradientzStyler.background_gradient
sR � �N �>�d�l��5�5�7�F� �
�
� ������!5���� �
� � rP �tgc �h � |�|�| j � }| j t ||||||||d��
S )NT) r� r= r r� r� r� r� r� � text_onlyr� ) rN r� r� r� r r= r� r� r� s r9 �
text_gradientzStyler.text_gradient� sO � �$ �>�d�l��5�5�7�F��z�z� ���������� �
�
rP c
� �� dj |j � D ��cg c]
\ }}|� d|� d��� c}}� �| j �fd�|�� S c c}}w )aS
Set defined CSS-properties to each ``<td>`` HTML element for the given subset.
Parameters
----------
%(subset)s
**kwargs : dict
A dictionary of property, value pairs to be set for each cell.
Returns
-------
Styler
Notes
-----
This is a convenience methods which wraps the :meth:`Styler.map` calling a
function returning the CSS-properties independently of the data.
Examples
--------
>>> df = pd.DataFrame(np.random.randn(10, 4))
>>> df.style.set_properties(color="white", align="right") # doctest: +SKIP
>>> df.style.set_properties(**{'background-color': 'yellow'}) # doctest: +SKIP
See `Table Visualization <../../user_guide/style.ipynb>`_ user guide for
more details.
rv z: �;c � �� �S r� r� )�x�valuess �r9 rG z'Styler.set_properties.<locals>.<lambda>� s �� �&rP rA )�joinr� rJ )rN r= r� �pr_ r� s @r9 �set_propertieszStyler.set_properties� sR �� �: ���6�<�<�>�B�>�4�1�a�Q�C�r�!��A�,�>�B�C���x�x�(��x�8�8�� Cs �A
�d �midz width: 10em;)�colorr� �width�height�alignr� r� rp c
� � |�|�d}n[|�
|� t d� �|�Jt |t t f� rt |� dkD st |t
t t f� s t d� �d|cxk rdk sn t d|� �� �d|cxk rdk sn t d|� �� �|�| j
� }| j t ||||||dz |dz || |
� � | S )
a�
Draw bar chart in the cell backgrounds.
.. versionchanged:: 1.4.0
Parameters
----------
%(subset)s
axis : {0 or 'index', 1 or 'columns', None}, default 0
Apply to each column (``axis=0`` or ``'index'``), to each row
(``axis=1`` or ``'columns'``), or to the entire DataFrame at once
with ``axis=None``.
color : str or 2-tuple/list
If a str is passed, the color is the same for both
negative and positive numbers. If 2-tuple/list is used, the
first element is the color_negative and the second is the
color_positive (eg: ['#d65f5f', '#5fba7d']).
cmap : str, matplotlib.cm.ColorMap
A string name of a matplotlib Colormap, or a Colormap object. Cannot be
used together with ``color``.
.. versionadded:: 1.4.0
width : float, default 100
The percentage of the cell, measured from the left, in which to draw the
bars, in [0, 100].
height : float, default 100
The percentage height of the bar in the cell, centrally aligned, in [0,100].
.. versionadded:: 1.4.0
align : str, int, float, callable, default 'mid'
How to align the bars within the cells relative to a width adjusted center.
If string must be one of:
- 'left' : bars are drawn rightwards from the minimum data value.
- 'right' : bars are drawn leftwards from the maximum data value.
- 'zero' : a value of zero is located at the center of the cell.
- 'mid' : a value of (max-min)/2 is located at the center of the cell,
or if all values are negative (positive) the zero is
aligned at the right (left) of the cell.
- 'mean' : the mean value of the data is located at the center of the cell.
If a float or integer is given this will indicate the center of the cell.
If a callable should take a 1d or 2d array and return a scalar.
.. versionchanged:: 1.4.0
vmin : float, optional
Minimum bar value, defining the left hand limit
of the bar drawing range, lower values are clipped to `vmin`.
When None (default): the minimum value of the data will be used.
vmax : float, optional
Maximum bar value, defining the right hand limit
of the bar drawing range, higher values are clipped to `vmax`.
When None (default): the maximum value of the data will be used.
props : str, optional
The base CSS of the cell that is extended to add the bar chart. Defaults to
`"width: 10em;"`.
.. versionadded:: 1.4.0
Returns
-------
Styler
Notes
-----
This section of the user guide:
`Table Visualization <../../user_guide/style.ipynb>`_ gives
a number of examples for different settings and color coordination.
Examples
--------
>>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})
>>> df.style.bar(subset=['A'], color='gray') # doctest: +SKIP
z#d65f5fz'`color` and `cmap` cannot both be givenr� zW`color` must be string or list or tuple of 2 strings,(eg: color=['#d65f5f', '#5fba7d'])r r� z)`width` must be a value in [0, 100], got z*`height` must be a value in [0, 100], got )
r= r r� �colorsr� r� r� r� r� �base_css) rV rR r� r� r� r� r� r9 �_bar) rN r= r r� r� r� r� r� r� r� rp s r9 �barz
Styler.bar� s � �v �=�T�\� �E�
�
�4�#3� � F�G� G�
�
��5�4��-�0�S��Z�!�^�J���T�5�)�M� !�9�� �
�E� �S� � � H��� P�Q� Q��F�!�c�!� � I�&�� R�S� S� �>��5�5�7�F� �
�
� �������#�+��C�<���� �
� � rP �red)�default)r= rp r� c �D � dd�}|�d|� d�}| j |d||�� S )ai
Highlight missing values with a style.
Parameters
----------
%(color)s
.. versionadded:: 1.5.0
%(subset)s
%(props)s
.. versionadded:: 1.3.0
Returns
-------
Styler
See Also
--------
Styler.highlight_max: Highlight the maximum with a style.
Styler.highlight_min: Highlight the minimum with a style.
Styler.highlight_between: Highlight a defined range with a style.
Styler.highlight_quantile: Highlight values defined by a quantile with a style.
Examples
--------
>>> df = pd.DataFrame({'A': [1, 2], 'B': [3, np.nan]})
>>> df.style.highlight_null(color='yellow') # doctest: +SKIP
Please see:
`Table Visualization <../../user_guide/style.ipynb>`_ for more examples.
c �r � t j t j | � j � |d� S )Nrv )r4 �wherer� r� �to_numpy)r> rp s r9 �fz Styler.highlight_null.<locals>.f� s& � ��8�8�B�G�G�D�M� 2� 2� 4�e�R�@� @rP N�background-color: r� �r r= rp )r> r rp r� �return�
np.ndarray)r9 )rN r� r= rp r� s r9 �highlight_nullzStyler.highlight_nullg s5 � �\ A� �=�(���q�1�E��z�z�!�$�v�U�z�C�CrP �yellow)r= r� rp c �Z � |�d|� d�}| j t t d�� |||�� S )a4
Highlight the maximum with a style.
Parameters
----------
%(subset)s
%(color)s
axis : {0 or 'index', 1 or 'columns', None}, default 0
Apply to each column (``axis=0`` or ``'index'``), to each row
(``axis=1`` or ``'columns'``), or to the entire DataFrame at once
with ``axis=None``.
%(props)s
.. versionadded:: 1.3.0
Returns
-------
Styler
See Also
--------
Styler.highlight_null: Highlight missing values with a style.
Styler.highlight_min: Highlight the minimum with a style.
Styler.highlight_between: Highlight a defined range with a style.
Styler.highlight_quantile: Highlight values defined by a quantile with a style.
Examples
--------
>>> df = pd.DataFrame({'A': [2, 1], 'B': [3, 4]})
>>> df.style.highlight_max(color='yellow') # doctest: +SKIP
Please see:
`Table Visualization <../../user_guide/style.ipynb>`_ for more examples.
r� r� �max��opr� �r9 r �_highlight_value�rN r= r� r rp s r9 �
highlight_maxzStyler.highlight_max� �B � �^ �=�(���q�1�E��z�z� �$�� /���� �
�
rP c �Z � |�d|� d�}| j t t d�� |||�� S )a4
Highlight the minimum with a style.
Parameters
----------
%(subset)s
%(color)s
axis : {0 or 'index', 1 or 'columns', None}, default 0
Apply to each column (``axis=0`` or ``'index'``), to each row
(``axis=1`` or ``'columns'``), or to the entire DataFrame at once
with ``axis=None``.
%(props)s
.. versionadded:: 1.3.0
Returns
-------
Styler
See Also
--------
Styler.highlight_null: Highlight missing values with a style.
Styler.highlight_max: Highlight the maximum with a style.
Styler.highlight_between: Highlight a defined range with a style.
Styler.highlight_quantile: Highlight values defined by a quantile with a style.
Examples
--------
>>> df = pd.DataFrame({'A': [2, 1], 'B': [3, 4]})
>>> df.style.highlight_min(color='yellow') # doctest: +SKIP
Please see:
`Table Visualization <../../user_guide/style.ipynb>`_ for more examples.
r� r� �minr� r� r� r� s r9 �
highlight_minzStyler.highlight_min� r� rP c �J � |�d|� d�}| j t ||||||�� S )a:
Highlight a defined range with a style.
.. versionadded:: 1.3.0
Parameters
----------
%(subset)s
%(color)s
axis : {0 or 'index', 1 or 'columns', None}, default 0
If ``left`` or ``right`` given as sequence, axis along which to apply those
boundaries. See examples.
left : scalar or datetime-like, or sequence or array-like, default None
Left bound for defining the range.
right : scalar or datetime-like, or sequence or array-like, default None
Right bound for defining the range.
inclusive : {'both', 'neither', 'left', 'right'}
Identify whether bounds are closed or open.
%(props)s
Returns
-------
Styler
See Also
--------
Styler.highlight_null: Highlight missing values with a style.
Styler.highlight_max: Highlight the maximum with a style.
Styler.highlight_min: Highlight the minimum with a style.
Styler.highlight_quantile: Highlight values defined by a quantile with a style.
Notes
-----
If ``left`` is ``None`` only the right bound is applied.
If ``right`` is ``None`` only the left bound is applied. If both are ``None``
all values are highlighted.
``axis`` is only needed if ``left`` or ``right`` are provided as a sequence or
an array-like object for aligning the shapes. If ``left`` and ``right`` are
both scalars then all ``axis`` inputs will give the same result.
This function only works with compatible ``dtypes``. For example a datetime-like
region can only use equivalent datetime-like ``left`` and ``right`` arguments.
Use ``subset`` to control regions which have multiple ``dtypes``.
Examples
--------
Basic usage
>>> df = pd.DataFrame({
... 'One': [1.2, 1.6, 1.5],
... 'Two': [2.9, 2.1, 2.5],
... 'Three': [3.1, 3.2, 3.8],
... })
>>> df.style.highlight_between(left=2.1, right=2.9) # doctest: +SKIP
.. figure:: ../../_static/style/hbetw_basic.png
Using a range input sequence along an ``axis``, in this case setting a ``left``
and ``right`` for each column individually
>>> df.style.highlight_between(left=[1.4, 2.4, 3.4], right=[1.6, 2.6, 3.6],
... axis=1, color="#fffd75") # doctest: +SKIP
.. figure:: ../../_static/style/hbetw_seq.png
Using ``axis=None`` and providing the ``left`` argument as an array that
matches the input DataFrame, with a constant ``right``
>>> df.style.highlight_between(left=[[2,2,3],[2,2,3],[3,3,3]], right=3.5,
... axis=None, color="#fffd75") # doctest: +SKIP
.. figure:: ../../_static/style/hbetw_axNone.png
Using ``props`` instead of default background coloring
>>> df.style.highlight_between(left=1.5, right=3.5,
... props='font-weight:bold;color:#e83e8c') # doctest: +SKIP
.. figure:: ../../_static/style/hbetw_props.png
r� r� �r r= rp �left�right� inclusive)r9 �_highlight_between)rN r= r� r r� r� r� rp s r9 �highlight_betweenzStyler.highlight_between
sC � �@ �=�(���q�1�E��z�z� ������ � �
�
rP c �� � |� t d� n|} t | � } | j j | }
||g} |�;t |
j � j
� � j | |�� } d}
n5| j j |� }|
j |d| |�� } d|z
}
|�d|� d�}| j t |
||| j d | j d |� � S )
a�
Highlight values defined by a quantile with a style.
.. versionadded:: 1.3.0
Parameters
----------
%(subset)s
%(color)s
axis : {0 or 'index', 1 or 'columns', None}, default 0
Axis along which to determine and highlight quantiles. If ``None`` quantiles
are measured over the entire DataFrame. See examples.
q_left : float, default 0
Left bound, in [0, q_right), for the target quantile range.
q_right : float, default 1
Right bound, in (q_left, 1], for the target quantile range.
interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
Argument passed to ``Series.quantile`` or ``DataFrame.quantile`` for
quantile estimation.
inclusive : {'both', 'neither', 'left', 'right'}
Identify whether quantile bounds are closed or open.
%(props)s
Returns
-------
Styler
See Also
--------
Styler.highlight_null: Highlight missing values with a style.
Styler.highlight_max: Highlight the maximum with a style.
Styler.highlight_min: Highlight the minimum with a style.
Styler.highlight_between: Highlight a defined range with a style.
Notes
-----
This function does not work with ``str`` dtypes.
Examples
--------
Using ``axis=None`` and apply a quantile to all collective data
>>> df = pd.DataFrame(np.arange(10).reshape(2,5) + 1)
>>> df.style.highlight_quantile(axis=None, q_left=0.8, color="#fffd75")
... # doctest: +SKIP
.. figure:: ../../_static/style/hq_axNone.png
Or highlight quantiles row-wise or column-wise, in this case by row-wise
>>> df.style.highlight_quantile(axis=1, q_left=0.8, color="#fffd75")
... # doctest: +SKIP
.. figure:: ../../_static/style/hq_ax1.png
Use ``props`` instead of default background coloring
>>> df.style.highlight_quantile(axis=None, q_left=0.2, q_right=0.8,
... props='font-weight:bold;color:#e83e8c') # doctest: +SKIP
.. figure:: ../../_static/style/hq_props.png
N)�q�
interpolationF)r � numeric_onlyr� r� r� r� r� r r� ) r1 r r> r2 r r� �ravel�quantiler8 r9 r� �iloc)rN r= r� r �q_left�q_rightr� r� rp r� r> � quantilesr� �
axis_applys r9 �highlight_quantilezStyler.highlight_quantilex
s� � �\ "(� �%��+�V��$�W�-���y�y�}�}�W�%�� �W�%� � �<��t�}�}��,�,�.�/�8�8��=� 9� �A� &*�J��9�9�-�-�d�3�D��
�
����-� � �A� �T��J� �=�(���q�1�E��z�z� ����������&�&��)� � �
�
rP c � ���� t j t j |� | j g� � G ���fd�d| � }|S )a
Factory function for creating a subclass of ``Styler``.
Uses custom templates and Jinja environment.
.. versionchanged:: 1.3.0
Parameters
----------
searchpath : str or list
Path or paths of directories containing the templates.
html_table : str
Name of your custom template to replace the html_table template.
.. versionadded:: 1.3.0
html_style : str
Name of your custom template to replace the html_style template.
.. versionadded:: 1.3.0
Returns
-------
MyStyler : subclass of Styler
Has the correct ``env``,``template_html``, ``template_html_table`` and
``template_html_style`` class attributes set.
Examples
--------
>>> from pandas.io.formats.style import Styler
>>> EasyStyler = Styler.from_custom_template("path/to/template",
... "template.tpl",
... ) # doctest: +SKIP
>>> df = pd.DataFrame({"A": [1, 2]})
>>> EasyStyler(df) # doctest: +SKIP
Please see:
`Table Visualization <../../user_guide/style.ipynb>`_ for more examples.
c � �� e Zd Zej W ��� ZW �rej
W �� ZW � rej
W � � Zyy)�-Styler.from_custom_template.<locals>.MyStyler)�loaderN) r7 �
__module__� __qualname__r � Environment�env� get_templater r )�
html_style�
html_tabler s ���r9 �MyStylerr sC �� ��$�$�F�$�3�C��&)�&6�&6�z�&B�#��&)�&6�&6�z�&B�#� rP r )r � ChoiceLoader�FileSystemLoaderr )�cls�
searchpathr r
r r s `` @r9 �from_custom_templatezStyler.from_custom_template�
sE �� �\ �$�$�f�&=�&=�j�&I�3�:�:�%V�W��
C� C�s� C� �rP c �6 � t j | |g|��i |��S )a�
Apply ``func(self, *args, **kwargs)``, and return the result.
Parameters
----------
func : function
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.
*args : optional
Arguments passed to `func`.
**kwargs : optional
A dictionary of keyword arguments passed into ``func``.
Returns
-------
object :
The value returned by ``func``.
See Also
--------
DataFrame.pipe : Analogous method for DataFrame.
Styler.apply : Apply a CSS-styling function column-wise, row-wise, or
table-wise.
Notes
-----
Like :meth:`DataFrame.pipe`, this method can simplify the
application of several user-defined functions to a styler. Instead
of writing:
.. code-block:: python
f(g(df.style.format(precision=3), arg1=a), arg2=b, arg3=c)
users can write:
.. code-block:: python
(df.style.format(precision=3)
.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 :meth:`Styler.apply` or
:meth:`Styler.set_properties`).
Examples
--------
**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")
>>> df.style.pipe(some_highlights, min_color="green") # doctest: +SKIP
.. figure:: ../../_static/style/df_pipe_hl.png
Since the method returns a ``Styler`` object it can be chained with other
methods as if applying the underlying highlighters directly.
>>> (df.style.format("{:.1f}")
... .pipe(some_highlights, min_color="green")
... .highlight_between(left=2, right=5)) # doctest: +SKIP
.. figure:: ../../_static/style/df_pipe_hl2.png
**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
... ) # doctest: +SKIP
>>> df.columns = pd.MultiIndex.from_product([["A", "B"], ["X", "Y"]])
>>> df.style.pipe(highlight_last_level) # doctest: +SKIP
.. figure:: ../../_static/style/df_pipe_applymap.png
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(
... styler.data.isna().any(), "background-color: red;", ""
... )
... return styler.apply_index(dynamic_highlight, axis=1, level=level)
>>> df.style.pipe(highlight_header_missing, level=1) # doctest: +SKIP
.. figure:: ../../_static/style/df_pipe_applydata.png
)�com�pipe)rN r8 �argsr� s r9 r z Styler.pipe! s � �d �x�x��d�4�T�4�V�4�4rP ) NNNNNTN� NNNN) r> �DataFrame | SeriesrE �
int | NonerA zCSSStyles | Noner? �
str | NonerC zstr | tuple | list | NonerB r rD r{ rG r r@ �intrI r rJ r rH r rF zExtFormatter | Noner� �None)r[ r< r� r< )r� r )NN)ro r rp zCSSProperties | Nonerq r r� r< )�Sheet1rv NNTTNr r NTN�infTNN)$r� z)FilePath | WriteExcelBuffer | ExcelWriterr r� rG r� r{ r rT zSequence[Hashable] | Nonerz zSequence[Hashable] | boolrW r{ r| zIndexLabel | Noner� r r� r r� r r} r{ r� r r~ r� r� r{ r� ztuple[int, int] | Noners zStorageOptions | Noner� r )"r� �FilePath | WriteBuffer[str]r� r r� r r� r r� � bool | Noner� r r� r rC �str | tuple | Noner� r r� r r� r r� r r� r{ r� r r� r r� r{ r� r ).)"r� r r� r r� r r� r r� r r� r r� r rC r r� r r� r r� r r� r r� r{ r� r r� r r� r{ r� r� r� )"r� �"FilePath | WriteBuffer[str] | Noner� r r� r r� r r� r r� r r� r rC r r� r r� r r� r r� r r� r{ r� r r� r r� r{ r� r )r� r r� r rB r r� r r� r r� r{ rC r r� r r� r r� r r� r{ r� r{ r� r )r� r r� r rB r r� r r� r r� r{ rC r r� r r� r r� r r� r{ r� r{ r� r� )r� r! r� r rB r r� r r� r r� r{ rC r r� r r� r r� r r� r{ r� r{ r� r )r� r r� r r� r r� r r� r r� r r� r� r� r )r� r r� r r� r r� r r� r r� r r� r� r� r� )r� r! r� r r� r r� r r� r r� r r� r� r� r )r� r r� r< )r� r r� r )r� r r r' r� r )F)r� r{ r� r< )r� r< )r� r )r N)r8 r r � Axis | Noner= �
Subset | Noner� r< )r Nr9 )
r8 r r r& r� �Level | list[Level] | NonerK r� r� r< )r8 r r z
AxisInt | strr� r$ r� r< )r8 r r= r# r� r< )rr r� r� r< )r� �dict[str, Any])r| r% r� r< )r? r� r� r< )rC zstr | tuple | listr� r< )r NN)r r& r� r r� r$ r� r< )Nr TN)
rA z'dict[Any, CSSStyles] | CSSStyles | Noner r' r� r{ r� zdict[str, str] | Noner� r< )Nr NF)
r= r# r r& r� r$ r� r{ r� r< ) �PuBur r r N��&1� �?NNN)r� �str | Colormapr� �floatr� r) r r" r= r# r� r) r� � float | Noner� r* r� �Sequence | Noner� r< )r& r r r NNNN)r� r( r� r) r� r) r r" r= r# r� r* r� r* r� r+ r� r< )r= r# r� r< )Nr )r= r# r r" r� zstr | list | tuple | Noner� �
Any | Noner� r) r� r) r� �str | float | Callabler� r* r� r* rp r� r� r< )r� NN)r� r� r= r# rp r r� r< )Nr� r N)
r= r# r� r� r r" rp r r� r< )Nr� r NN�bothN)r= r# r� r� r r" r� �Scalar | Sequence | Noner� r/ r� r* rp r r� r< )Nr� r g g �?�linearr. N)r= r# r� r� r r" r� r) r� r) r� r, r� r* rp r r� r< )r z
Sequence[str]r r r
r r� z type[Styler])r8 r )>r7 r r �__doc__rL r\ rb rf rr r
r r� r r re r` r �buffering_args�
encoding_argsr� r� r r r� r r" r. r@ � subset_argsr9 rM r^ rb ri rk rJ rp r� rv r� r� r� r� r� r� r� r� r� r� r� �properties_args�
coloring_argsrM r� r� r� r� r � classmethodr r �
__classcell__)rO s @r9 r< r< � s/ �� �y�| !%�)-� �-1�'+� � !�� "� $� !�)-� *
� �*
� �*
� '� *
�
� *
� +�
*
� %�*
� �*
� �*
� �*
� �*
� �*
� �*
� '� *
�
� *
�Xd�L�� '+� $� ^��^� $�^� � ^�
� ^�@ �����$�%6�7�%,� � #��#'�-1�,0��)-��� !� � #� � �/3�15�%)
�?�)
� �)
� � )
�
!� )
� +�
)
� *�)
� �)
� '�)
� �)
� �)
� �)
� �)
� � )
� � )
� �!)
�" -�#)
�$ /�%)
�&
�')
�
� )
�V �
%(� "�%(� !� � �&)�$'�&)�%(�%(��"%� "� �% �
(� � "� �
� � #�
� � � � � � � $� � "� � $� � #� � #� � � � �! �" �# �$ �% �&
�' � � �, � � � %(� "�%(� !� � �&)�$'�&)�%(�%(��"%� "� �% �
� � "� �
� � #�
� � � � � � � $� � "� � $� � #� � #� � � � �! �" �# �$ �% �&
�' � � �0 37�xA� %)� #�%)� "� !� �&*�$(�&*�%)�%)� �"&� #� !�%xA�
/�xA� "� xA�
� xA� #�
xA� �xA� �xA� �xA� $�xA� "�xA� $�xA� #�xA� #� xA� � xA� �!xA�" �#xA�$ �%xA�&
�'xA�t �
"%�'*�$'�&)� � !� "�"%� "� � "� �
(� � � �
%� � "�
� $� � � � � � � � � � � � � � � �
�! � � �& � � � "%�'*�$'�&)� � !� "�"%� "� � "� �
� � � �
%� � "�
� $� � � � � � � � � � � � � � � �
�! � � �& �n�}�=� 37�O
� "&�'+�$(�&*� "� "� #�"&� #� "� $� O
�
/�O
� � O
�
%� O
� "�
O
� $�O
� �O
� �O
� �O
� �O
� �O
� �O
� � O
�
�!O
� >�O
�b �
#�$'�&)� "�"%� � �
(� � � �
"� � $�
� � � � � � �
� � � � � � � #�$'�&)� "�"%� � �
� � � �
"� � $�
� � � � � � �
� � � � �n�}�=� 37�D
� $�$(�&*� #�"&� �D
�
/�D
� � D
�
"� D
� $�
D
� �D
� �D
� �D
�
�D
� >�D
�LJ�X2�:>�6C�J*�)� �B � $� 9��9� �9� � 9�
�
9�v ��%� � $� Z��Z� �Z� � Z�
�
Z� &�Z�~ �,0� � ��� �� *� �
� �
��, �
�
� � �
I�S�I� � A�
K� � �,0� I��I� �I� *� I�
�
I� �I�V ��
�
� � �
0�R�,� � ?�
@� � �,0� ��� �� *� �
�
� ��& �,0� ";��";� �";� *� ";�
�
";�H� ��%�9� &�9�v ��%�6:�0� �0�&3�0� �0� &�0�: �<8
�tA�F#�J"�L �!%�-1� J>��J>� �J>� +� J>�
� J>�\ AE�� �15� I�=�I� �I� � I�
/� I�
�
I�Z !%��,0�� }� �}� �}� *� }�
� }�
�
}�FR� �
� ��.� � ��%� &��� � $�&+� !� !� $�L� �L� �L� � L�
� L� �
L� $�L� �L� �L� �L�
�L� &��L�\ ��
� ��� � &��� � $� !� !� $�
� �
� �
� �
�
�
� �
� �
� �
� �
�
�
��
�6 ��%� 9� &� 9�> ��%� !%� �}�
,0� ���(-� !� !�#�}� �}� �}�
)� }� �
}� �}� �}� &�}� �}� �}� �}�
�}� &�}�~ �� ��"�"�5�"�1�� � $� � .D��.D� �.D� � .D�
� .D� �
.D�` ���"�"�8�"�4� �� !%� � � � 1
� �1
� �1
� � 1
�
� 1
�
�
1
� �
1
�f ���"�"�8�"�4� �� !%� � � � 1
� �1
� �1
� � 1
�
� 1
�
�
1
� �
1
�f ���"�"�8�"�4� �� !%� � �)-�*.�(.� �e
� �e
� �e
� � e
�
'� e
� (�
e
� &�e
� �e
�
�e
� �
e
�N ���"�"�8�"�4� �� !%� � �� �/7�(.� �f
� �f
� �f
� � f
�
� f
� �
f
� -�f
� &�f
� �f
�
�f
� �
f
�P � "&�!%� 9�!�9� �9� � 9�
� 9� �9�vr5rP r< c �. � |rd|ini }t | t � r t |t � rt d|� d�� �t | t � r t |t � rt d|� d�� �t | t t f� r% | j |d�� j
d
i |��} | S t
j | fi |��} t | t j � sJ �| j |j k7 r(t d|� d| j � d |j � �� �| S ) a�
For the apply-type methods, ``axis=None`` creates ``data`` as DataFrame, and for
``axis=[1,0]`` it creates a Series. Where ``arg`` is expected as an element
of some operator with ``data`` we must make sure that the two are compatible shapes,
or raise.
Parameters
----------
arg : sequence, Series or DataFrame
the user input arg
arg_name : string
name of the arg for use in error messages
dtype : numpy dtype, optional
forced numpy dtype if given
data : Series or DataFrame
underling subset of Styler data on which operations are performed
Returns
-------
ndarray
�dtyper� zQ' is a Series but underlying data for operations is a DataFrame since 'axis=None'zT' is a DataFrame but underlying data for operations is a Series with 'axis in [0,1]'N)rK z
supplied 'z:' is not correct shape for data over selected 'axis': got z , expected r� )
rR r r rV r� r� r4 �asarrayr5 r7 )�arg�arg_namer: r> s r9 �_validate_apply_axis_argr> � s( � �6 !&�W�e� �2�E��#�v� �:�d�I�#>����z� /�
0�
�
� �#�y�!�j��v�&>����z� :�
;�
�
� �#�� �*�+�:�c� � �t�D� �1�:�:�C�U�C�� �J� �j�j��&��&���#�r�z�z�*�*�*� �9�9��
�
� "� � �X�J� '(�(+� � �{� 3 � �J�J�<�)��
�
�JrP c �f ���� |�&| j t t j �� }nt |dt | � }t t j � 5 \ } �|�t j |� n|}
|�t j |� n|} | |
z
} �j j |
| |z z
| | |z z � }
|�) �j �j d |
|� � }n' �j j |� |
|� � }d d��d
���fd� }| j dk( r |D �cg c] } |||� ��
c}cddd� S t! |D ��cg c] }|D �cg c] } |||� ��
c}�� c}}| j" | j$ �� cddd� S c c}w c c}w c c}}w # 1 sw Y yxY w) zM
Color background in a range according to the data or a gradient map
N)r: �na_valuer� z
image.cmapc �D � d� | dd D � \ }}}d|z d|z z d|z z S )a�
Calculate relative luminance of a color.
The calculation adheres to the W3C standards
(https://www.w3.org/WAI/GL/wiki/Relative_luminance)
Parameters
----------
color : rgb or rgba tuple
Returns
-------
float
The relative luminance as a value from 0 to 1
c 3 �F K � | ] }|d k r|dz n
|dz dz dz �� � y�w)g?�ܵ�?gףp=
�)@g)\��(�?g�z�G��?g333333@Nr� )r� r� s r9 r� zC_background_gradient.<locals>.relative_luminance.<locals>.<genexpr>� s5 � �� � �!�A� �'�\��E� ��U��e�0C��/K�K�!�s � !N� g���z6�?g�,C ���?g]m��{�?r� )�rgbar� �g�bs r9 �relative_luminancez0_background_gradient.<locals>.relative_luminance� s; � � � �b�q���G�A�q�!� �A�:���
�*�V�a�Z�7� 7rP c � �� |s3 �| � �k }|rdnd}d�j j | � � d|� d�S d�j j | � � d�S )Nz#f1f1f1z#000000r� z;color: r� zcolor: )r� �rgb2hex)rD r� �dark�
text_color� _matplotlibrG r� s ���r9 r z!_background_gradient.<locals>.css sr �� � �)�$�/�2F�F��*.�Y�I�
�(��);�);�)C�)C�D�)I�(J� K � (�\��,��
!��!3�!3�!;�!;�D�!A� B�!�D�DrP r� r0 )r� r) )r� r� )r� r) r4 �nanr> r: r< r� �nanmin�nanmaxr� � Normalize� colormaps�rcParams�get_cmap�ndimr rW rT )r> r� r� r� r� r� r� r� r� r� �smin�smax�rng�norm�rgbasr rD r� rL rG s ` @@r9 r� r� � s� �� � �|��}�}�5�2�6�6�}�:��'��f�e�T�B��
�f�(�(� )�-=�a��"&�,�r�y�y���D��"&�,�r�y�y���D���T�k���!�!�+�+�D�C�#�I�,>���d�
�@S�T�� �<�M�K�)�)�+�*>�*>�|�*L�M��T�
��E� 9�K�)�)�2�2�4�8��d��D�E� 8�, E� �9�9��>�5:�;�U�T�C��i�(�U�;�a
*� )�d �CH�I�5�C�3�7�3�4�#�d�I�&�3�7�5�I��j�j� � � ��e
*� )��` <�� 8��I�g
*� )�sI �CF'�+F�;F'�
F'� F! �F �*F! �/ F'�F'� F! �!F'�'F0c �
� t j |� r t |t � st |dd| � }t j |� r t |t � st |dd| � }|dk( r!t
j t
j f}n�|dk( r!t
j t
j f}nZ|dk( r!t
j t
j f}n4|dk( r!t
j t
j f}nt d|� �� �|� |d | |� n%t j | j dt � � }t |t t f� r%|j! t# j$ |� d
� }|� |d | |� n%t j | j dt � � }t |t t f� r%|j! t# j$ |� d
� }t j ||z |d � S )
z\
Return an array of css props based on condition of data values within given range.
r� Nr� r. �neitherzD'inclusive' values can be 'both', 'left', 'right', or 'neither' got r T)r: Fr� rv )r4 �iterablerR r� r> �operator�ge�le�gt�ltrV �fullr7 r{ r r r� r� �notna)r> rp r� r� r� �ops�g_left�l_rights r9 r� r� s� � �
�{�{�4���D�#�!6�'��f�d�D�A�� �{�{�5��*�U�C�"8�(����t�D�� �F���{�{�H�K�K�(�� �i� ��{�{�H�K�K�(�� �f� ��{�{�H�K�K�(�� �g� ��{�{�H�K�K�(���� �+�
�
�
� � � ��A��t�T��
�W�W�T�Z�Z��T�
2� � �&�9�f�-�.�� � �b�h�h�v� .��6�� � � ��A��t�U��
�W�W�T�Z�Z��T�
2� � �'�I�v�.�/��-�-����� 1�5�9��
�8�8�F�W�$�e�R� 0�0rP c �� � t | |� d�� }t | t � r t ||� d�� }| |k( }|j t j
|� d� }t
j ||d� S )zY
Return an array of css strings based on the condition of values matching an op.
T��skipnaFrv )r rR r r� r� rc r4 )r> r� rp r� �conds r9 r� r� O sh � �
�G�D�"� �T� *�E��$� �"�"���r�"�$�/�� �5�=�D� �:�:�b�h�h�t�n�e� ,�D�
�8�8�D�%�� $�$rP c � ����� d�fd� �d����fd� } | j � }
|�%t j | j d�� � n|} |�%t j | j d�� � n|} d}
|d k( r | dk\ r d|�dn|} }nt| dk rod|�dn|} }nf|d
k( rt j |
� d }}
nIt |� r ||
� d }}
n3t |t t f� rt |� d }}
n|d vr t d
� �d}|��t t j � 5 \ }}t |t � r|j | n|}|j" j% | | � } | ||
� � }| j& dk( r)|D �cg c] }|j" j) |� �� }}n8|D ��cg c]+ }|D �cg c] }|j" j) |� �� c}��- }}}ddd� t |t � sJ �| j& dk( r8t+ |
� D ��cg c]! \ }} | ||
z
| |
z
| |
z
||�|n|| � ��# c}}S t j, t+ |
� D ����cg c]@ \ }}t+ |� D ��cg c]$ \ }} | ||
z
| |
z
| |
z
||�|n|| | � ��& c}}��B c}}}}� S c c}w c c}w c c}}w # 1 sw Y ��xY wc c}}w c c}}w c c}}}}w )a�
Draw bar chart in data cells using HTML CSS linear gradient.
Parameters
----------
data : Series or DataFrame
Underling subset of Styler data on which operations are performed.
align : str in {"left", "right", "mid", "zero", "mean"}, int, float, callable
Method for how bars are structured or scalar value of centre point.
colors : list-like of str
Two listed colors as string in valid CSS.
width : float in [0,1]
The percentage of the cell, measured from left, where drawn bars will reside.
height : float in [0,1]
The percentage of the cell's height where drawn bars will reside, centrally
aligned.
vmin : float, optional
Overwrite the minimum value of the window.
vmax : float, optional
Overwrite the maximum value of the window.
base_css : str
Additional CSS that is included in the cell before bars are drawn.
c � �� �}|| kD r8|dz
}| dkD r|d| dz d�d|� d| dz d�d�z
}|d|� d|dz d�d |dz d�d
�z
}|S ) a
Generate CSS code to draw a bar from start to end in a table cell.
Uses linear-gradient.
Parameters
----------
start : float
Relative positional start of bar coloring in [0,1]
end : float
Relative positional end of the bar coloring in [0,1]
color : str
CSS valid color to apply.
Returns
-------
str : The CSS applicable to the cell.
Notes
-----
Uses ``base_css`` from outer scope.
z"background: linear-gradient(90deg,r z
transparent r� �.1fz%, r� z%,z%, transparent z%)r� )�start�endr� �cell_cssr� s �r9 �css_barz_bar.<locals>.css_bar~ s� �� �. �� ��;� �<� <�H��q�y��m�E�#�I�c�?�#�e�W�A�e�C�i�PS�_�TV� W�W�� �!�E�7�!�C��G�C�=���C���}�B�O� O�H��rP r� r� c �D �� t j | � r� S t |t t f� r| dk r|d n|d }t |t
� sJ �| |k r|n| } | |kD r|n| } d}d}|dk( r | |z
||z
z }n�|dk( r | |z
||z
z }nrd}|dk( r$t
t |� t |� � }| |}}n'|dk( r"||z dz } | dk r | ||z
z dz n| ||z
z }| dk r| |z
||z
z |}}n
|| |z
||z
z }} � |�z |�z |� }
�
dk rd |
v r
|
d
�
d z d �d
�z S |
S )a�
Return the correct CSS for bar placement based on calculated values.
Parameters
----------
x : float
Value which determines the bar placement.
left : float
Value marking the left side of calculation, usually minimum of data.
right : float
Value marking the right side of the calculation, usually maximum of data
(left < right).
align : {"left", "right", "zero", "mid"}
How the bars will be positioned.
"left", "right", "zero" can be used with any values for ``left``, ``right``.
"mid" can only be used where ``left <= 0`` and ``right >= 0``.
"zero" is used to specify a center when all values ``x``, ``left``,
``right`` are translated, e.g. by say a mean or median.
Returns
-------
str : Resultant CSS with linear gradient.
Notes
-----
Uses ``colors``, ``width`` and ``height`` from outer scope.
r r� r� r� g �?�zeror� r� z background: linear-gradient(z) no-repeat center; background-size: 100% r� rm z%;)r� r� rR r� r� r� r� �abs)r� r� r� r� r� rn ro �z_frac�limitr� rW r� rq r� r� s ����r9 �css_calcz_bar.<locals>.css_calc� s� �� �8 �7�7�1�:��O� �e�d�E�]� +� !�A��E�!�H�5��8�E��%��%�%�%���H�D�!����Y�E�A������ �F�?��t�8��� �-�C�
�g�
���X�%�$�,�/�E� �F���� "�3�t�9�c�%�j� 9�� $�f�e�e���%� � "�U�l�a� /��36��7�S�D�E�D�L�)�C�/����QU� �@V� � �1�u� �$�h�5�4�<� 8�&�s�� #�a�$�h�5�4�<�%@�s���e�e�m�S�5�[�%�8�� �A�:�8�C�?��A�&�3�,�s�AS�SU�V�V�
� �JrP NTrh r r� �meanrs )r� r� rs z�`align` should be in {'left', 'right', 'mid', 'mean', 'zero'} or be a value defining the center line or a callable that returns a floatr� )rn r) ro r) r� r� r� r� )r� r) r� r) r� r� r� �str | list | tuple)r� r4 rN r� rO r� �nanmeanr& rR r) r rV r: r< r� r� rQ r� rP rT rI r� �array)r> r� r� r� r� r� r� r� r� rw r� r� r� �zrY r� rL rX rD r� r� r� r� rq s `` ` @r9 r� r� [ s �� �F �>I� I�V �]�]�_�F�/3�|�2�9�9�T�X�X�T�X�*� +��D�04� �B�I�I�d�h�h�d�h�+� ,�$�E��A� ��~� �1�9� �t�|�!��4�E�
�a�Z�"�� �A�4�5�E� �&� ��:�:�f�%�v�5�� �%� ���=�&�5�� �E�E�3�<� (���<��5�� �/� /��
P�
�
�
�E� ��
�&�*�*�
�!1�!�[� �d�C�(� �%�%�d�+��
�
�%�%�/�/��e�<�D���f� �&�E��y�y�A�~�FK�L�e�d��+�+�3�3�D�9�e��L� SX��RW�3�#�F�#�$�[�'�'�/�/��5�#�F�RW� � � � �e�S� !�!� !� �y�y�A�~�
"�&�)�
� *���1�
��A��t�a�x����E�U�]�6�PU�VW�PX�
� *�
�
� �x�x� (�� /�
� 0�F�A�s� !*�#�� � !/���1� ��A�� �q�� �� � �"'�-��U�1�X�a�[� � !/� � 0�
�
�
�� M�� G��� �
��"
�� ��
sa � A"J:�>"J*� J:�( J4�1"J/�J4�J:�&K�K�1)K �K�*J:�/J4�4J:�:K� K)r8 r r� z&Generator[tuple[Any, Any], None, None])
r< z NDFrame | Sequence | np.ndarrayr= r� r: r, r> r r� r� )r& r r r' NNNF)r� r( r� r) r� r) r� r) r� r* r� r* r� z1Sequence | np.ndarray | DataFrame | Series | Noner� r{ )NNT) r> r rp r� r� �/Scalar | Sequence | np.ndarray | NDFrame | Noner� r} r� z
bool | strr� r� )r> r r� r� rp r� r� r� )r> r r� r- r� ry r� r r� r) r� r) r� r* r� r* r� r� )]r1 �
__future__r �
contextlibr r � functoolsr r] �typingr r r r rf �numpyr4 �pandas._configr
�pandas.compat._optionalr �pandas.util._decoratorsr r
�pandas.util._exceptionsr �pandasr� r r �pandas.core.common�core�commonr �pandas.core.framer r �pandas.core.genericr �pandas.core.shared_docsr �pandas.io.formats.formatr r � pandas.io.formats.style_renderr r r r r r r r r r! �collections.abcr" r# r$ �matplotlib.colorsr% �pandas._typingr& r' r( r) r* r+ r, r- r. r/ r0 r1 �
matplotlibr5 �matplotlib.pyplot�pyplotr4 r3 r6 r: r4 r5 r6 r2 r3 r< r> r� r� r� r� r� rP r9 �<module>r� sx ��� #� %� � � �� � � � %� >�� 5� �� !� �� (� 0� 3� #�H�4V� W�� � � � �� � +� � � � � #�� �#��G�
�C� �C�Q� �
��8�
�"��
Y�
�R85�^� R85�jp2� (�2��2� �2� � 2�
� 2�n "���"'� � �>B��I�
�I�
�I� � I�
� I� �
I� �I� <�I� �I�^ =A�=A� � 51�
�51� �51� :�51� ;� 51�
� 51� �
51�p %�M
�
�M
� !�M
�
�M
� � M
�
� M
�
�
M
� �M
� �M
� �M
��Ex � ��G��s � E �E�E
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists