B Y0d @sdZddlmZddlmZddlZddlmZddlZddl m Z m Z m Z m Z ddlZddlZddlmZddlmZmZmZmZmZmZdd lmZdd lmZddlZdd lm Z m!Z!dd l"m#Z#dd l$m%Z%ddl&m'm(Z)ddl*m+Z+m,Z,ddl-m.Z.ddl/m0Z0edddZ1ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9y ddl:m;Z;ddldZ?Wne@k r|dZ?dZAYnXeddddZBGddde5ZCdd d!d"d#d$d%d&ZDd8d)d)d)d*d*d+d,d-d.d/ZEd9d"d d0d0d1d#d2d3d4ZFd"d d d#d5d6d7ZGdS):zF Module for applying conditional formatting to DataFrames and Series. ) annotations)contextmanagerN)partial)AnyCallableHashableSequence) get_option)AxisFilePathOrBuffer FrameOrSeriesFrameOrSeriesUnion IndexLabelScalar)import_optional_dependency)doc) IndexSlice RangeIndex) is_list_like)generic) DataFrameSeries)NDFrame)save_to_bufferjinja2z DataFrame.style requires jinja2.)extra) CSSProperties CSSStylesStylerRendererSubsetTooltipsmaybe_convert_css_to_tuplesnon_reducing_slice)colorsTFz{0} requires matplotlib.r)funcccs$trttfVntt|jdS)N)has_mplpltr# ImportErrorno_mpl_messageformat__name__)r$r+I/var/www/html/venv/lib/python3.7/site-packages/pandas/io/formats/style.py_mplGs r-cseZdZdZddddd d d d d d d d d d fdd Zd dddZdddd dddZdddd ddddZee j de j dddd d d d#d$d d%d d d d d d d d&d'd(d)d*Z ddddd+ddddd,d-d+dd+d. d/d d d d d d ddd d d d d d0d1d2Z ddddd+d+d3d/d d d d d d4d5d6Zddd7d8d9Zdd'd:d;d<Zdd dd=d>d?Zddd@dAZdddBdCZd'ddDdEZddFdGdHddIdJdKZddFdGdHddIdLdMZddNdHddOdPdQZddNdHddOdRdSZddNd d dHddTdUdVZd dWdXdYdZZd dd[d\d]Zd^dd_d`Zd^ddadbdcZd ddddedfZdgddhdidjZddkddlddmdndoZ ddpd d ddqdrdsZ!d dWdtdudvZ"ddHddwdxdyZ#ddHddwdzd{Z$ed|d}d~dd dddddGdHdddddd ddZ%ee%d}d|ddddddddGdHdddddddZ&ddHddwddZ'e(dd dddddddZ)ddHdGdd ddddddZ*dd dHd ddddZ+ddHd dGd ddddZ,ddHd dGd ddddZ-ddHd dGddd d ddddZ.ddHd dGddd d d dd ddZ/e0dd d dddZ1dNdddZ2Z3S)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 Precision to round floats to, defaults to pd.options.display.precision. 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 ```` 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__row_col`` where ```` is the unique identifier, ```` is the row number and ```` is the column number. na_rep : str, optional Representation for missing values. If ``na_rep`` is None, no special formatting is applied. .. versionadded:: 1.0.0 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]. .. versionadded:: 1.2.0 decimal : str, default "." Character used as decimal separator for floats, complex and integers .. versionadded:: 1.3.0 thousands : str, optional, default None Character used as thousands separator for floats, complex and integers .. 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. .. versionadded:: 1.3.0 Attributes ---------- env : Jinja2 jinja2.Environment template : 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.applymap``. 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.render to get the generated HTML. CSS classes are attached to the generated HTML * Index and Column names include ``index_name`` and ``level`` where `k` is its level in a MultiIndex * Index label cells include * ``row_heading`` * ``row`` where `n` is the numeric position of the row * ``level`` where `k` is the level in a MultiIndex * Column label cells include * ``col_heading`` * ``col`` where `n` is the numeric position of the column * ``level`` where `k` is the level in a MultiIndex * Blank cells include ``blank`` * Data cells include ``data`` NT.r z int | NonezCSSStyles | Nonez str | Nonezstr | tuple | Noneboolintstr) data precision table_stylesuuidcaptiontable_attributescell_idsna_repuuid_lendecimal thousandsescapec s@tj||| ||||d||_||_|jd||| | | ddS)N)r4r7r<r6r9r8r:) formatterr5r;r?r=r>)super__init__r5r;r)) selfr4r5r6r7r8r9r:r;r<r=r>r?) __class__r+r,rBs"zStyler.__init__)returncCs|S)zB Hooks into Jupyter notebook rich display system. )render)rCr+r+r, _repr_html_szStyler._repr_html_z bool | None) sparse_indexsparse_columnsrEcKs0|dkrtd}|dkr td}|j||f|S)am Render the ``Styler`` including all applied styles to HTML. Parameters ---------- 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 row. Defaults to ``pandas.options.styler.sparse.columns`` value. **kwargs Any additional keyword arguments are passed through to ``self.template.render``. This is useful when you need to provide additional variables for a custom template. Returns ------- rendered : str The rendered HTML. Notes ----- Styler objects have defined the ``_repr_html_`` method which automatically calls ``self.render()`` when it's the last item in a Notebook cell. When calling ``Styler.render()`` directly, wrap the result in ``IPython.display.HTML`` to view the rendered HTML in the notebook. Pandas uses the following keys in render. Arguments passed in ``**kwargs`` take precedence, so think carefully if you want to override them: * head * cellstyle * body * uuid * table_styles * caption * table_attributes Nzstyler.sparse.indexzstyler.sparse.columns)r Z _render_html)rCrHrIkwargsr+r+r,rFs 2z Styler.renderrzCSSProperties | None)ttipsprops css_classrEcCs\|jstd|jjr|jjs&td|jdkr8t|_||j_|rL||j_ |rX||j_ |S)a Set the DataFrame of strings on ``Styler`` generating ``:hover`` tooltips. These string based tooltips are only applicable to ``
`` 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 ------- self : Styler Notes ----- Tooltips are created by adding `` 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).render() Optionally controlling the tooltip visual display >>> df.style.set_tooltips(ttips, css_class='tt-add', props=[ ... ('visibility', 'hidden'), ... ('position', 'absolute'), ... ('z-index', 1)]) >>> df.style.set_tooltips(ttips, css_class='tt-add', ... props='visibility:hidden; position:absolute; z-index:1;') z1Tooltips can only render with 'cell_ids' is True.z=Tooltips render only if `ttips` has unique index and columns.N) r:NotImplementedErrorindex is_uniquecolumnsKeyErrortooltipsr Ztt_dataZclass_properties class_name)rCrKrLrMr+r+r, set_tooltipssK zStyler.set_tooltipsstorage_options)klassrVSheet1rinfzSequence[Hashable] | NonezSequence[Hashable] | boolzIndexLabel | Noneztuple[int, int] | NoneNone) sheet_namer; float_formatrQheaderrO index_labelstartrowstartcolengine merge_cellsencodinginf_repverbose freeze_panesrEc Cs@ddlm}||||||||| |d }|j||| | || ddS)Nr)ExcelFormatter)r;colsr^r]rOr_rcre)r\r`rargrb)Zpandas.io.formats.excelrhwrite)rCZ excel_writerr\r;r]rQr^rOr_r`rarbrcrdrerfrgrhr@r+r+r,to_excelqs$ zStyler.to_excelFcr) column_formatpositionposition_floathruleslabelr8rHrImultirow_alignmulticol_alignsiunitxrd convert_csszFilePathOrBuffer[str] | None)bufrnrorprqrrr8rHrIrsrtrurdrvc Cs|jdd}|jdk r&dd|jDng}|dk rP|jdd|dgd d nd|krZn|jj}tt|jjd |j_|jj}||j_|j rd n d |jj j }x>t |jjD].\}}||j kr|||kr| sdqdnd 7}qW|jdd|dgd d |r&|jdd|dgd d |rb|dkrFtd|d|jdd|dgd d |r|jdddddddddgd d |r|jdd|ddddgd d |r|||dkrtd}| dkrtd } |j|| | | |d!}t||| d"S)#u4 Write Styler to a file, buffer or string in LaTeX format. .. versionadded:: 1.3.0 Parameters ---------- buf : str, Path, or StringIO-like, optional, default None Buffer to write to. If ``None``, the output is returned as a string. column_format : str, optional The LaTeX column specification placed in location: \\begin{tabular}{} 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_float : {"centering", "raggedleft", "raggedright"}, optional The LaTeX float command placed in location: \\begin{table}[] \\ hrules : bool, default False Set to `True` to add \\toprule, \\midrule and \\bottomrule from the {booktabs} LaTeX package. label : str, optional The LaTeX label included as: \\label{
}. If tuple, i.e ("full caption", "short caption"), the caption included as: \\caption[]{}. 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 row. Defaults to ``pandas.options.styler.sparse.columns`` value. multirow_align : {"c", "t", "b"} If sparsifying hierarchical MultiIndexes whether to align text centrally, at the top or bottom. multicol_align : {"r", "c", "l"} If sparsifying hierarchical MultiIndex columns whether to align text at the left, centrally, or at the right. siunitx : bool, default False Set to ``True`` to structure LaTeX compatible with the {siunitx} package. encoding : str, default "utf-8" Character encoding setting. 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})* ===================== ========================================================== **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 ``(, )`` pair (see `Table Visualization <../../user_guide/style.ipynb>`_), and this should be replaced by a LaTeX ``(, )`` 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.render() The equivalent using LaTeX only commands is the following: >>> s = df.style.highlight_max(axis=None, ... props='cellcolor:{red}; bfseries: ;') >>> s.to_latex() Internally these structured LaTeX ``(, )`` pairs are translated to the ``display_value`` with the default structure: ``\ ``. Where there are multiple commands the latter is nested recursively, so that the above example highlighed 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 ````, within the tuple, to result in different positions of required braces (the **default** being the same as ``--nowrap``): =================================== ============================================ Tuple Format Output Structure =================================== ============================================ (,) \\ (, ``--nowrap``) \\ (, ``--rwrap``) \\{} (, ``--wrap``) {\\ } (, ``--lwrap``) {\\} (, ``--dwrap``) {\\}{} =================================== ============================================ 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{}``. 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() .. 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" ... ) .. 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_index` or :meth:`Styler.hide_columns`, for example: >>> s.clear() >>> s.table_styles = [] >>> s.caption = None >>> s.format({ ... ("Numeric", "Integers"): '\${}', ... ("Numeric", "Floats"): '{:.3f}', ... ("Non-Numeric", "Strings"): str.upper ... }) >>> s.to_latex() \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) \begin{tabular}{lr} {} & {0} \\ 0 & {\bfseries}{\Huge{1}} \\ \end{tabular} T)deepcopyNcSsg|] }|dqS)selectorr+).0styler+r+r, sz#Styler.to_latex..rn:)ryrLF) overwrite)stoprYlrmSro)Z raggedrightZ raggedleftZ centeringzR`position_float` should be one of 'raggedright', 'raggedleft', 'centering', got: ''rpZtoprulez:topruleZmidrulez:midruleZ bottomrulez :bottomrulerrz:{§}zstyler.sparse.indexzstyler.sparse.columns)rHrIrsrtrv)rwrd)_copyr6set_table_stylesr4rQrlenZ_get_numeric_dataZto_list hide_index_rOnlevels enumeratehidden_columns ValueErrorreplace set_captionr Z _render_latexr)rCrwrnrorprqrrr8rHrIrsrtrurdrvobjZtable_selectorsZ_original_columnsZ numeric_colsci_latexr+r+r,to_latexsr*        zStyler.to_latex) table_uuidr9rd doctype_htmlexclude_styles)rwrr9rdrrcCsN|r|||r|||j||r*|nd|d}t|||dk rF|nddS)aU Write Styler to a file, buffer or string in HTML-CSS format. .. versionadded:: 1.3.0 Parameters ---------- buf : str, Path, or StringIO-like, optional, default None Buffer to write to. If ``None``, the output is returned as a string. table_uuid : str, optional Id attribute assigned to the HTML element in the format: ``
`` If not given uses Styler's initially assigned value. table_attributes : str, optional Attributes to assign within the `
` HTML element in the format: ``
>`` If not given defaults to Styler's preexisting value. encoding : str, optional Character encoding setting for file output, and HTML meta tags, defaults to "utf-8" if None. doctype_html : bool, default False Whether to output a fully structured HTML file including all HTML elements, or just the core ``' '
' ' ' ' ' ' ' ' ' ' ' ' ' '
0
1
' z>Classes render only if `classes` has unique index and columns.NrY) rOrPrQrR reindex_liker4r itertuplespdisnar3 cell_context)rCrrmZrow_tuprlvaluer+r+r,set_td_classesas? zStyler.set_td_classes)attrsrEcCs|jjr|jjstdxf|jD]\}xV||gD]D\}}|sBq4t|}|j||j|}}|j||f|q4Wq WdS)a Update the state of the ``Styler`` for data cells. Collects a mapping of {index_label: [('', ''), ..]}. Parameters ---------- attrs : DataFrame should contain strings of ': ;: ' Whitespace shouldn't matter and the final trailing ';' shouldn't matter. zS`Styler.apply` and `.applymap` are not compatible with non-unique index or columns.N) rOrPrQrRrr!Zget_locctxextend)rCrZcnZrnrlZcss_listijr+r+r, _update_ctxs  zStyler._update_ctx)rxrEcCst|j|jd}dddddg}ddd d d d d dg}x|D]}t||t||q8Wx0|D](}t||}t|||rzt|n|qXW|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 Non-data dependent attributes [copied and exported]: - hidden index state and hidden columns state (.hide_index_, .hide_columns_) - table_attributes - table_styles - applied styles (_todo) )r<r hide_columns_r9r:r8Z_display_funcs hidden_rowsrrr_todor6rS)r.r4r<setattrgetattrcopyrx)rCrxZstylerZshallowdeepattrvalr+r+r,rs,    z Styler._copycCs |jddS)NF)rx)r)rCr+r+r,__copy__szStyler.__copy__cCs |jddS)NT)rx)r)rCmemor+r+r, __deepcopy__szStyler.__deepcopy__cCs4|jd|_|j|jd|_g|_dS)zf Reset the ``Styler``, removing any previously applied styles. Returns None. NF)rclearrSrrrr)rCr+r+r,rs    z Styler.clearzCallable[..., Styler]z Axis | Nonez Subset | None)r$axissubsetrEcKs8|dkrtdn|}t|}|jj|}|dk rR|j|f|dd|}|j|_n||f|}t|tst|tj st dt |d|j |j kst dt |d|j d|j t||j|jd}n0|j|jr|j|jst dt |d |j |j kr*t dt |d |j d |j |||S) Nexpand)rZ result_typez 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: )rOrQz Result of z3 must have identical index and columns as the inputz- returned the wrong shape. Result has shape: z Expected shape: )slicer"r4locapplyrQ isinstancernpndarray TypeErrorreprshaperrOequalsr)rCr$rrrJr4resultr+r+r,_applys.         z Styler._applycKs |jdd|||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 an object of same length, also with identical index if the object is a Series. ``func`` should take a DataFrame if ``axis`` is ``None`` and return either an ndarray with the same shape or a DataFrame with identical columns and index. .. versionchanged:: 1.3.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 : label, array-like, IndexSlice, optional A valid 2d input to `DataFrame.loc[]`, or, in the case of a 1d input or single key, to `DataFrame.loc[:, ]` where the columns are prioritised, to limit ``data`` to *before* applying the function. **kwargs : dict Pass along to ``func``. Returns ------- self : Styler See Also -------- Styler.applymap: 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') >>> df.style.apply(highlight_max, color='blue', axis=1) >>> df.style.apply(highlight_max, color='green', axis=None) Using ``subset`` to restrict application to a single column or multiple columns >>> df.style.apply(highlight_max, color='red', subset="A") >>> df.style.apply(highlight_max, color='red', subset=["A", "B"]) 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)) >>> df.style.apply(highlight_max, color='red', subset=(slice(0,5,2), "A") cSs t|dS)Nr)r)instancer+r+r,zStyler.apply..)rappend)rCr$rrrJr+r+r,rAsGz Styler.applyr)r$rrEcKsHt|f|}|dkr tdd}t|}|jj||}|||S)N)rrr"r4rapplymapr)rCr$rrJrr+r+r, _applymaps   zStyler._applymapcKs|jdd||f|f|S)a Apply a CSS-styling function elementwise. Updates the HTML representation with the result. Parameters ---------- func : function ``func`` should take a scalar and return a scalar. subset : label, array-like, IndexSlice, optional A valid 2d input to `DataFrame.loc[]`, or, in the case of a 1d input or single key, to `DataFrame.loc[:, ]` where the columns are prioritised, to limit ``data`` to *before* applying the function. **kwargs : dict Pass along to ``func``. Returns ------- self : Styler See Also -------- 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.applymap(color_negative, color='red') Using ``subset`` to restrict application to a single column or multiple columns >>> df.style.applymap(color_negative, color='red', subset="A") >>> df.style.applymap(color_negative, color='red', subset=["A", "B"]) Using a 2d input to ``subset`` to select rows in addition to columns >>> df.style.applymap(color_negative, color='red', subset=([0,1,2], slice(None)) >>> df.style.applymap(color_negative, color='red', subset=(slice(0,5,2), "A") cSs t|dS)Nr)r)rr+r+r,rrz!Styler.applymap..)rr)rCr$rrJr+r+r,rs2zStyler.applymap)condrotherrrEc s8tjdtdddkrd|jfdd|dS) a' Apply CSS-styles based on a conditional function elementwise. .. deprecated:: 1.3.0 Updates the HTML representation with a style which is selected in accordance with the return value of a function. Parameters ---------- cond : callable ``cond`` should take a scalar, and optional keyword arguments, and return a boolean. value : str Applied when ``cond`` returns true. other : str Applied when ``cond`` returns false. subset : label, array-like, IndexSlice, optional A valid 2d input to `DataFrame.loc[]`, or, in the case of a 1d input or single key, to `DataFrame.loc[:, ]` where the columns are prioritised, to limit ``data`` to *before* applying the function. **kwargs : dict Pass along to ``cond``. Returns ------- self : Styler See Also -------- Styler.applymap: Apply a CSS-styling function elementwise. Styler.apply: Apply a CSS-styling function column-wise, row-wise, or table-wise. Notes ----- This method is deprecated. This method is a convenience wrapper for :meth:`Styler.applymap`, which we recommend using instead. The example: >>> df = pd.DataFrame([[1, 2], [3, 4]]) >>> def cond(v, limit=4): ... return v > 1 and v != limit >>> df.style.where(cond, value='color:green;', other='color:red;') should be refactored to: >>> def style_func(v, value, other, limit=4): ... cond = v > 1 and v != limit ... return value if cond else other >>> df.style.applymap(style_func, value='color:green;', other='color:red;') z:this method is deprecated in favour of `Styler.applymap()`) stacklevelNrYcs|frSS)Nr+)r)rrJrrr+r,rrzStyler.where..)r)warningswarn FutureWarningr)rCrrrrrJr+)rrJrrr,wheres>z Styler.wherer)r5rEcCs&tjdtdd||_|j||jdS)a$ Set the precision used to display values. .. deprecated:: 1.3.0 Parameters ---------- precision : int Returns ------- self : Styler Notes ----- This method is deprecated see `Styler.format`. zDthis method is deprecated in favour of `Styler.format(precision=..)`r)r)r5r;)rrrr5r)r;)rCr5r+r+r, set_precisions zStyler.set_precision) attributesrEcCs ||_|S)a Set the table attributes added to the ```` HTML element. These are items in addition to automatic (by default) ``id`` attribute. Parameters ---------- attributes : str Returns ------- self : Styler See Also -------- Styler.set_table_styles: Set the table styles included within the ``