a SicU@sddlmZddlmZddlmZddlZddlmZddl Z ddl Z ddl ZddlmZddlmZmZmZddlmZdd lmZdd lmZmZmZmZdd lmZm Z dd l!m"Z"m#Z#gd Z$e"j%e#ddZ&GdddZ'Gddde'Z(e)edededededededededededd Z*Gd d!d!e(Z+Gd"d#d#e(Z,Gd$d%d%e'Z-d&j.e&e#d'e#d(d)e-j/_0ddddddd*d+dd,dd-d-ddddd.d/d0Z1d8dddd*d1d2d3d-ddddddd-ddd4d5d6Z2d7j.e&e#d'e#d(d)e2_0dS)9) annotations)product) signatureN)dedent) VectorPlotter variable_typecategorical_order) share_axis)utils)adjust_legend_subtitles_check_argument _draw_figure_disable_autolayout) color_palette blend_palette)DocstringComponents _core_docs) FacetGridPairGrid JointGridpairplot jointplotparams)corec@sHeZdZdZddZeddZeddZdd Zd d Z d d Z dS) _BaseGridz!Base class for grids of subplots.cKs*|jjD]}|dur|jfi|q|S)z$Set attributes on each subplot Axes.N)axesflatset)selfkwargsaxr"L/var/www/html/django/DPS/env/lib/python3.9/site-packages/seaborn/axisgrid.pyr#s z _BaseGrid.setcCs|jS)z)DEPRECATED: prefer the `figure` property._figurerr"r"r#fig*sz _BaseGrid.figcCs|jS)zHAccess the :class:`matplotlib.figure.Figure` object underlying the grid.r$r&r"r"r#figure3sz_BaseGrid.figurecOs||g|Ri||S)ax Pass the grid to a user-supplied function and return self. The `func` must accept an object of this type for its first positional argument. Additional arguments are passed through. The return value of `func` is ignored; this method returns self. See the `pipe` method if you want the return value. Added in v0.12.0. r"rfuncargsr r"r"r#apply8s z_BaseGrid.applycOs||g|Ri|S)a Pass the grid to a user-supplied function and return its value. The `func` must accept an object of this type for its first positional argument. Additional arguments are passed through. The return value of `func` becomes the return value of this method. See the `apply` method if you want to return self instead. Added in v0.12.0. r"r)r"r"r#pipeGs z_BaseGrid.pipecOs*|}|dd|jj|i|dS)z Save an image of the plot. This wraps :meth:`matplotlib.figure.Figure.savefig`, using bbox_inches="tight" by default. Parameters are passed through to the matplotlib function. bbox_inchestightN)copy setdefaultr(savefigrr+r r"r"r#r2Us z_BaseGrid.savefigN) __name__ __module__ __qualname____doc__rpropertyr'r(r,r-r2r"r"r"r#r s  rc@sXeZdZdZdZdZddZddZdd d Zd d Z d dZ e ddZ dddZ dS)Gridz>A grid that can have multiple subplots and an external legend.FTcCsgd|_d|_d|_dS)N)rrrrF)_tight_layout_rect_tight_layout_pad_extract_legend_handlesr&r"r"r#__init__gs z Grid.__init__cOsD|}|d|j|jdur.|d|j|jj|i||S)z:Call fig.tight_layout within rect that exclude the legend.rectNpad)r0r1r:r;r% tight_layoutr3r"r"r#r@ps  zGrid.tight_layoutNc sdur|j|dur@|jdur.t}ntttj|j}tjj dddfdd|D}|durr|j n|}tj d}g}|D]&} t | t r| \} } n| } || q|dd|jr|d d |d d |jj||fi|} | |_| j|d |id|rt| t|j| j|jj} |j\}}|j|| |t|j| j|jj} | || }|jrdnd}|||_d|j}|jj|d||jd<nR|j j!d}|d d|j||fi|}|j|d |id||_|r t||S)aDraw a legend, maybe placing it outside axes and resizing the figure. Parameters ---------- legend_data : dict Dictionary mapping label names (or two-element tuples where the second element is a label name) to matplotlib artist handles. The default reads from ``self._legend_data``. title : string Title for the legend. The default reads from ``self._hue_var``. label_order : list of labels The order that the legend entries should appear in. The default reads from ``self.hue_names``. adjust_subtitles : bool If True, modify entries with invisible artists to left-align the labels and set the font size to that of a title. kwargs : key, value pairings Other keyword arguments are passed to the underlying legend methods on the Figure or Axes object. Returns ------- self : Grid instance Returns self for easy chaining. Nr)alpha linewidthcsg|]}|qSr")get.0lZ blank_handle legend_datar"r# z#Grid.add_legend..zlegend.title_fontsize scatterpointsrframeonFlocz center rightsize)propg{Gz?{Gz?)rightbest)" _legend_data hue_nameslistkeysmapr to_utf8mplpatchesPatch_hue_varrcParams isinstancetupleappendr1 _legend_outr%legend_legend set_titler rget_window_extentwidthdpiget_size_inchesset_size_inches_margin_titlesZ _space_neededsubplots_adjustr:rr)rrHtitle label_orderadjust_subtitlesr handlesZ title_sizelabelsentry_label figlegendZ legend_widthZ fig_width fig_heightZ space_neededmarginrQr!legr"rGr# add_legendysZ                zGrid.add_legendcCsi}|jdurH|jrH|jj}dd|jjD}|ddt||D|\}}|ddt||D|j|d|_dS)z8Extract the legend data from an axes object and save it.NcSsg|] }|qSr"get_text)rEtr"r"r#rIrJz,Grid._update_legend_data..cSsi|]\}}||qSr"r"rEhrFr"r"r# rJz,Grid._update_legend_data..cSsi|]\}}||qSr"r"r}r"r"r#rrJ)legend_r< legendHandlestextsupdatezipget_legend_handles_labelsrT)rr!datarprqr"r"r#_update_legend_datas  zGrid._update_legend_datac s|durtddnt|||}t|}dur^t}|t|krRtd|}qt|d}n2ttrfdd|D} t| |}n t|}t||S)z*Get a list of colors for the hue variable.Nr)n_colorshuslcsg|] }|qSr"r")rEr~paletter"r#rIrJz%Grid._get_palette..)rr lenr get_color_cycler_dict) rrhue hue_orderrrUrZcurrent_palettecolors color_namesr"rr# _get_palettes        zGrid._get_palettecCs"z|jWStyYdS0dS)z9The :class:`matplotlib.legend.Legend` object, if present.N)rdAttributeErrorr&r"r"r#rcs z Grid.legendbothcKs&|jjD]}|jfd|i|q|S)aModify the ticks, tick labels, and gridlines. Parameters ---------- axis : {'x', 'y', 'both'} The axis on which to apply the formatting. kwargs : keyword arguments Additional keyword arguments to pass to :meth:`matplotlib.axes.Axes.tick_params`. Returns ------- self : Grid instance Returns self for easy chaining. axis)r(r tick_params)rrr r!r"r"r#rs zGrid.tick_params)NNNF)r)r4r5r6r7rkrbr=r@ryrrr8rcrr"r"r"r#r9bs   h r9z data : DataFrame Tidy ("long-form") dataframe where each column is a variable and each row is an observation. zq row, col : vectors or keys in ``data`` Variables that define subsets to plot on different facets. z {row,col}_order : vector of strings Specify the order in which levels of the ``row`` and/or ``col`` variables appear in the grid of subplots. z col_wrap : int "Wrap" the column variable at this width, so that the column facets span multiple rows. Incompatible with a ``row`` facet. z share{x,y} : bool, 'col', or 'row' optional If true, the facets will share y axes across columns and/or x axes across rows. zW height : scalar Height (in inches) of each facet. See also: ``aspect``. z aspect : scalar Aspect ratio of each facet, so that ``aspect * height`` gives the width of each facet in inches. a palette : palette name, list, or dict Colors to use for the different levels of the ``hue`` variable. Should be something that can be interpreted by :func:`color_palette`, or a dictionary mapping hue levels to matplotlib colors. z legend_out : bool If ``True``, the figure size will be extended, and the legend will be drawn outside the plot on the center right. z margin_titles : bool If ``True``, the titles for the row variable are drawn to the right of the last column. This option is experimental and may not work in all cases. zU facet_kws : dict Additional parameters passed to :class:`FacetGrid`. ) rrowcolZ rowcol_ordercol_wrapZshare_xyheightaspectr legend_out margin_titles facet_kwscsVeZdZdZddddddddddddddddddddddfdd Zed jfiee_d d Zd dZ ddZ ddZ ddZ ddZ dddZd?dd Zd@d!d"ZdAd#d$ZdBd%d&Zddd'd(d)d*d+Zed,d-Zed.d/Zed0d1Zed2d3Zed4d5Zed6d7Zed8d9Zed:d;ZZ S)Crz7Multi-plot grid for plotting conditional relationships.NTrF)rowcolrrsharexshareyrrr row_order col_orderrhue_kwsdropnardespinerxlimylim subplot_kws gridspec_kwsc.st|}|durd}nt||| }|||| | }|durHg}nt||| }|durdg}nt||| }|dur~|ni}tt|t}|r|dur|n ||}|dur|n ||}|dur|n ||}||B|B} n|} |durdnt|}!|durdnt|}"|!|"|_ ||_ |durj|durPd}#t |#|}!t t t||}"|!|_|"|_|!|| |"|f}$|durd}|durin|}|durin|}|dur||d<|dur||d<ttj|$d}%Wdn1s0Y|durtd||||d}&|%j|"|!fi|&}'|durf|durfi}(nR|durtt||'j}(n6|durtt||'j}(nt||})tt|)|'j}(n|rtdt|}*t|*t}'|%j|"|!dfi||'d <|r |'d |d <|r|'d |d <td|*D]$}+|%j|"|!|+dfi||'|+<q&tt||'}(|%|_|'|_ |(|_!d|_"||_#||_$||_%||_&||_'|"|_||_(|!|_||_)||_*g|_+||_ ||_,||_-||_.i|_/d|_0d|_1||_2||_3||_4| |_5|6|7|r|8|d vrb|j9D]<},|,:D]}-|-;dq0|,j;dq$|d vr|j?D]<},|,@D]}-|-;dq~|,jAj=;d|,jAj>;dqrdS)Nrz)Cannot use `row` and `col_wrap` together.Frrfigsize)squeezerr subplot_kw gridspec_kwz,`gridspec_kws` ignored when using `col_wrap`rrr)Tr)Tr)Bsuperr=r rnpzerosrboolisnull _n_facets _col_wrap ValueErrorintceil_ncol_nrowr0rpltr(rsubplotsrrrwarningswarnemptyobject add_subplotranger%_axes _axes_dictrdr row_names col_namesrUr_row_var_col_varrk_margin_titles_textsr]_colorsrbrT_x_var_y_var_sharex_sharey_dropna_not_na set_titlesr@r_not_bottom_axesget_xticklabels set_visiblexaxis offsetTextrt_not_left_axesget_yticklabelsyaxis).rrrrrrrrrrrrrrrrrrrrrrrZhue_varrUrrrZnone_naZrow_naZcol_naZhue_nanot_nancolnrowerrrr'r r axes_dictZ facet_productZn_axesir!rt __class__r"r#r=ns       ,        "      zFacetGrid.__init__a? Initialize the matplotlib figure and FacetGrid object. This class maps a dataset onto multiple axes arrayed in a grid of rows and columns that correspond to *levels* of variables in the dataset. The plots it produces are often called "lattice", "trellis", or "small-multiple" graphics. It can also represent levels of a third variable with the ``hue`` parameter, which plots different subsets of data in different colors. This uses color to resolve elements on a third dimension, but only draws subsets on top of each other and will not tailor the ``hue`` parameter for the specific visualization the way that axes-level functions that accept ``hue`` will. The basic workflow is to initialize the :class:`FacetGrid` object with the dataset and the variables that are used to structure the grid. Then one or more plotting functions can be applied to each subset by calling :meth:`FacetGrid.map` or :meth:`FacetGrid.map_dataframe`. Finally, the plot can be tweaked with other methods to do things like change the axis labels, use different ticks, or add a legend. See the detailed code examples below for more information. .. warning:: When using seaborn functions that infer semantic mappings from a dataset, care must be taken to synchronize those mappings across facets (e.g., by defining the ``hue`` mapping with a palette dict or setting the data type of the variables to ``category``). In most cases, it will be better to use a figure-level function (e.g. :func:`relplot` or :func:`catplot`) than to use :class:`FacetGrid` directly. See the :ref:`tutorial ` for more information. Parameters ---------- {data} row, col, hue : strings Variables that define subsets of the data, which will be drawn on separate facets in the grid. See the ``{{var}}_order`` parameters to control the order of levels of this variable. {col_wrap} {share_xy} {height} {aspect} {palette} {{row,col,hue}}_order : lists Order for the levels of the faceting variables. By default, this will be the order that the levels appear in ``data`` or, if the variables are pandas categoricals, the category order. hue_kws : dictionary of param -> list of values mapping Other keyword arguments to insert into the plotting call to let other plot attributes vary across levels of the hue variable (e.g. the markers in a scatterplot). {legend_out} despine : boolean Remove the top and right spines from the plots. {margin_titles} {{x, y}}lim: tuples Limits for each of the axes on each facet (only relevant when share{{x, y}} is True). subplot_kws : dict Dictionary of keyword arguments passed to matplotlib subplot(s) methods. gridspec_kws : dict Dictionary of keyword arguments passed to :class:`matplotlib.gridspec.GridSpec` (via :meth:`matplotlib.figure.Figure.subplots`). Ignored if ``col_wrap`` is not ``None``. See Also -------- PairGrid : Subplot grid for plotting pairwise relationships relplot : Combine a relational plot and a :class:`FacetGrid` displot : Combine a distribution plot and a :class:`FacetGrid` catplot : Combine a categorical plot and a :class:`FacetGrid` lmplot : Combine a regression plot and a :class:`FacetGrid` Examples -------- .. note:: These examples use seaborn functions to demonstrate some of the advanced features of the class, but in most cases you will want to use figue-level functions (e.g. :func:`displot`, :func:`relplot`) to make the plots shown here. .. include:: ../docstrings/FacetGrid.rst c #sjjr$fddjD}ntdtjg}jrVfddjD}ntdtjg}jrfddjD}ntdtjg}tt|t|t|D]<\\}}\}}\}} ||@| @j @} |||f| fVqdS)aGenerator for name indices and data subsets for each facet. Yields ------ (i, j, k), data_ijk : tuple of ints, DataFrame The ints provide an index into the {row, col, hue}_names attribute, and the dataframe contains a subset of the full data corresponding to each facet. The generator yields subsets that correspond with the self.axes.flat iterator, or self.axes[i, j] when `col_wrap` is None. csg|]}j|kqSr")rrEnrrr"r#rIrJz(FacetGrid.facet_data..Tcsg|]}j|kqSr")rrrr"r#rIrJcsg|]}j|kqSr")r]rrr"r#rIrJN) rrrrepeatrrrUr enumerater) rZ row_masksZ col_masksZ hue_masksrrjrkrdata_ijkr"rr# facet_data}s zFacetGrid.facet_datacOsd|dd}tt|dd}|dkrld|vrBd|j}t|t|dkrld |vrld |j}t||D]\\}}} } | j j sqt| d  } | ||| } | | ||d<|jD]\} }|| || <q|jdurt|j| |d <| t|}|jr|}d d|D}| dr. matplotlibcSsg|] }|jqSr")values)rErr"r"r#rIrJrR)popstrgetattrformatr4rrrrrrN startswith facet_axis _facet_colorritemsr]r rYrUrVrr _facet_plot_finalize_grid)rr*r+r kw_colorZ func_modulewarningrow_icol_jhue_kr modify_stater!kwval_list plot_data plot_argsr"r"r#rXs@       z FacetGrid.mapcOs|dd}|D]\\}}}}|jjs,qt|jd } |||| } ||||d<|j D]\} } | ||| <qf|j dur|j ||d<|j r|}||d<||| ||q|dd|ddg} t|ddD]\}}|| |<q|| |S) atLike ``.map`` but passes args as strings and inserts data in kwargs. This method is suitable for plotting with functions that accept a long-form DataFrame as a `data` keyword argument and access the data in that DataFrame using string variable names. Parameters ---------- func : callable A plotting function that takes data and keyword arguments. Unlike the `map` method, a function used here must "understand" Pandas objects. It also must plot to the currently active matplotlib Axes and take a `color` keyword argument. If faceting on the `hue` dimension, it must also take a `label` keyword argument. args : strings Column names in self.data that identify variables with data to plot. The data for each variable is passed to `func` in the order the variables are specified in the call. kwargs : keyword arguments All keyword arguments are passed to the plotting function. Returns ------- self : object Returns self. rNrrtrxyrR)rrrrNrr5rrrrrr]rUrrrrCrr)rr*r+r rrrrrrr!rr axis_labelsrvalr"r"r# map_dataframes(    zFacetGrid.map_dataframecCs&|j|}|dur|S|dur"|SdSN)r)rZ hue_indexrrr"r"r#r>s  zFacetGrid._facet_colorcCsdt|jdrH|}gd}t||D]\}}|||<q*g}||d<||i|||dS)Nr)r r rrNstyler!)rr5rr0rr)rr*r!r plot_kwargs semanticskeyr r"r"r#rFs zFacetGrid._facet_plotcCs|j||dS)z$Finalize the annotations and layout.N)set_axis_labelsr@)rZaxlabelsr"r"r#rUs zFacetGrid._finalize_gridcCs8|jdur|jj|}n|j||f}|r4t||S)z?Make the axis identified by these indices active and return it.N)rrrrsca)rrrrr!r"r"r#rZs   zFacetGrid.facet_axiscKstj|jfi||S)z#Remove axis spines from the facets.)r rr%)rr r"r"r#rhszFacetGrid.despinecKsL|dur$||_|j|fd|i||durH||_|j|fd|i||S)z>Set axis labels on the left column and bottom row of the grid.N clear_inner)r set_xlabelsr set_ylabels)rx_vary_varrr r"r"r#rmszFacetGrid.set_axis_labelscKsJ|dur|j}|jD]}|j|fi|q|rF|jD]}|dq6|S)z/Label the x axis on the bottom row of the grid.Nr)r _bottom_axes set_xlabelrrrtrr r!r"r"r#rxs   zFacetGrid.set_xlabelscKsJ|dur|j}|jD]}|j|fi|q|rF|jD]}|dq6|S)z0Label the y axis on the left column of the grid.Nr)r _left_axes set_ylabelrrr"r"r#rs   zFacetGrid.set_ylabelscKs|jjD]}|}|||dur~dd|D}|durj|dd|}|dd|}|||j|fi|q|j|fi|q|S)z#Set x axis tick labels of the grid.NcSsg|] }|qSr"rzrDr"r"r#rIrJz-FacetGrid.set_xticklabels..)rr get_xticks set_xticksrset_xticklabels)rrqstepr r! curr_ticks curr_labelsxticksr"r"r#r!s   zFacetGrid.set_xticklabelscKsd|jjD]V}|}|||durLdd|D}|j|fi|q|j|fi|q|S)z6Set y axis tick labels on the left column of the grid.NcSsg|] }|qSr"rzrDr"r"r#rIrJz-FacetGrid.set_yticklabels..)rr get_yticks set_yticksrset_yticklabels)rrqr r!r#r$r"r"r#r(s  zFacetGrid.set_yticklabelsc Kst|j|jd}|dtjd|d<|dur2d}|dur>d}|durt|jdurV|}n|jdurf|}nd||g}t|}t|}t|}|j r|j D] }| qg|_ |j dur,t |j D]`\}}|j|df} |t|d |jfi|} | j| fd d d d dd|}|j |q|jdurt |jD]F\} } |t| d|jfi|} |jd| fj| fi|qB|S|jdur|jdurt |j D]^\}}t |jD]H\} } |t|| d|jfi|} |j|| fj| fi|qqn|j dur~t|j r~t |j D]F\}}|t|d |jfi|} |j|dfj| fi|q4nh|jdurt|jrt |jD]D\}} |t| d|jfi|} |jj|j| fi|q|S)aDraw titles either above each facet or on the grid margins. Parameters ---------- template : string Template for all titles with the formatting keys {col_var} and {col_name} (if using a `col` faceting variable) and/or {row_var} and {row_name} (if using a `row` faceting variable). row_template: Template for the row variable when titles are drawn on the grid margins. Must have {row_var} and {row_name} formatting keys. col_template: Template for the row variable when titles are drawn on the grid margins. Must have {col_var} and {col_name} formatting keys. Returns ------- self: object Returns self. )Zrow_varZcol_varrNzaxes.labelsizeNz{row_var} = {row_name}z{col_var} = {col_name}z | )row_name)gRQ??z axes fractionileftcenter)xyxycoordsrotationhava)col_namer)r*r3)rrrrrZr^joinr rYrkrremoverrrrrannotaterarrerr) rtemplateZ row_templateZ col_templater r+textrr*r!rmrr3r"r"r#rsp          &"zFacetGrid.set_titles.5--)r r r linestylecKsT||d<||d<|dur0|jtjfd|i||durP|jtjfd|i||S)aAdd a reference line(s) to each facet. Parameters ---------- x, y : numeric Value(s) to draw the line(s) at. color : :mod:`matplotlib color ` Specifies the color of the reference line(s). Pass ``color=None`` to use ``hue`` mapping. linestyle : str Specifies the style of the reference line(s). line_kws : key, value mappings Other keyword arguments are passed to :meth:`matplotlib.axes.Axes.axvline` when ``x`` is not None and :meth:`matplotlib.axes.Axes.axhline` when ``y`` is not None. Returns ------- :class:`FacetGrid` instance Returns ``self`` for easy method chaining. rr;Nr r )rXraxvlineaxhline)rr r rr;line_kwsr"r"r#reflineszFacetGrid.reflinecCs|jS)zBAn array of the :class:`matplotlib.axes.Axes` objects in the grid.)rr&r"r"r#r*szFacetGrid.axescCs&|jjdkr|jdSd}t|dS)zJThe :class:`matplotlib.axes.Axes` when no faceting variables are assigned.)rr)rrz||q>t |t jSdS)z.Return a flat array of the bottom row of axes.Nr)rrArCr"r"r#rqs  zFacetGrid._bottom_axescCs|jdur"|jddddfjSg}|j|j|j}t|jD]B\}}||j|jdkot||j|jd|k}|rB||qBt |t jSdS)z:Return a flat array of axes that aren't on the bottom row.Nr)rrArCr"r"r#rs  zFacetGrid._not_bottom_axes)T)NNT)NT)NT)NN)N)NNN)!r4r5r6r7r=rr _facet_docsrrXr rrrrrrrrr!r(rr?r8rr!rrDrrrr __classcell__r"r"rr#rksV 4 Z\(RG   \$       rcseZdZdZdddddddddddddddfd d Zd d Zd dZddZddZddZ ddZ ddZ ddZ ddZ ddZdd ZZS)!raISubplot grid for plotting pairwise relationships in a dataset. This object maps each variable in a dataset onto a column and row in a grid of multiple axes. Different axes-level plotting functions can be used to draw bivariate plots in the upper and lower triangles, and the marginal distribution of each variable can be shown on the diagonal. Several different common plots can be generated in a single line using :func:`pairplot`. Use :class:`PairGrid` when you need more flexibility. See the :ref:`tutorial ` for more information. NFT@rr+)rvarsx_varsy_varsrrrcorner diag_shareyrr layout_padrrcsBt||}||vr&|||dur>t|}t|}|durJ|}|durV|}t|rf|g}t|rv|g}t||_}t||_}|j|jk|_ |st d|st dt || | t || f}t t j|d}Wdn1s0Y|jt |t |dddd}| |_| rjt|d }t|D]&\}}|||fd|||f<qB||_||_||_| |_d|_d|_||_|||_|durd g|_}tjd gt ||jd |_ n8t!|||}}|rtt"tj#|}||_|||_ |dur|ni|_$||_%||_&|'|||||_(i|_)|dd ddfj*D]J}|durnq\|+D]}|,dqv|j-j.,d|j-j/,dq\|ddd dfj*D]J}|durАq|0D]}|,dq|j1j.,d|j1j/,dqgd |_2| |_3||_4|r2t5j6|d|j7| ddS)acInitialize the plot figure and PairGrid object. Parameters ---------- data : DataFrame Tidy (long-form) dataframe where each column is a variable and each row is an observation. hue : string (variable name) Variable in ``data`` to map plot aspects to different colors. This variable will be excluded from the default x and y variables. vars : list of variable names Variables within ``data`` to use, otherwise use every column with a numeric datatype. {x, y}_vars : lists of variable names Variables within ``data`` to use separately for the rows and columns of the figure; i.e. to make a non-square plot. hue_order : list of strings Order for the levels of the hue variable in the palette palette : dict or seaborn color palette Set of colors for mapping the ``hue`` variable. If a dict, keys should be values in the ``hue`` variable. hue_kws : dictionary of param -> list of values mapping Other keyword arguments to insert into the plotting call to let other plot attributes vary across levels of the hue variable (e.g. the markers in a scatterplot). corner : bool If True, don't add axes to the upper (off-diagonal) triangle of the grid, making this a "corner" plot. height : scalar Height (in inches) of each facet. aspect : scalar Aspect * height gives the width (in inches) of each facet. layout_pad : scalar Padding between axes; passed to ``fig.tight_layout``. despine : boolean Remove the top and right spines from the plots. dropna : boolean Drop missing values from the data before plotting. See Also -------- pairplot : Easily drawing common uses of :class:`PairGrid`. FacetGrid : Subplot grid for plotting conditional relationships. Examples -------- .. include:: ../docstrings/PairGrid.rst Nz$No variables found for grid columns.z!No variables found for grid rows.rrrF)rrrr _nolegend_)indexr))rPrPGz?rR)r')r?)8rr=_find_numeric_colsr5rVrisscalarrKrL square_gridrrrrr(r_cornertriu_indices_fromrr%rrrN diag_vars diag_axesr_add_axis_labelsr]rUpdSeriesrQhue_valsr filternotnullr _orig_palette _hue_orderrrrTrrrrrrtrrr:r;_despiner rr@)rrrrJrKrLrrrrMrNrrrOrr numeric_colsrr'rZ hide_indicesrrrUr!rtrr"r#r=s8     *            zPairGrid.__init__cKs8t|jj\}}t|j|j}|j||fi||S)aMPlot with the same function in every subplot. Parameters ---------- func : callable plotting function Must take x, y arrays as positional arguments and draw onto the "currently active" matplotlib Axes. Also needs to accept kwargs called ``color`` and ``label``. )rindicesrr@rr_map_bivariate)rr*r row_indices col_indicesrdr"r"r#rXPs z PairGrid.mapcKs*tt|jd}|j||fi||S)a^Plot with a bivariate function on the lower diagonal subplots. Parameters ---------- func : callable plotting function Must take x, y arrays as positional arguments and draw onto the "currently active" matplotlib Axes. Also needs to accept kwargs called ``color`` and ``label``. r))rrtril_indices_fromrrerr*r rdr"r"r# map_loweras zPairGrid.map_lowercKs*tt|jd}|j||fi||S)a^Plot with a bivariate function on the upper diagonal subplots. Parameters ---------- func : callable plotting function Must take x, y arrays as positional arguments and draw onto the "currently active" matplotlib Axes. Also needs to accept kwargs called ``color`` and ``label``. r)rrrWrrerir"r"r# map_upperps zPairGrid.map_uppercKs|jr2|j|fi||js|j|fi|nVg}t|jD]2\}}t|jD]\}}||krR|||fqRq@|j||fi||S)a\Plot with a bivariate function on the off-diagonal subplots. Parameters ---------- func : callable plotting function Must take x, y arrays as positional arguments and draw onto the "currently active" matplotlib Axes. Also needs to accept kwargs called ``color`` and ``label``. ) rUrjrVrkrrLrKrare)rr*r rdrrrrr"r"r# map_offdiags zPairGrid.map_offdiagcKs.|jdurg}g}t|jD]\}}t|jD]\}}||kr0|||j||f} | } | || tj dds| j j D]} | j dq|jr0| j d|jr0tj| ddq0q|jr|r|ddD]} t|d| dqt|tj|_t|tj|_d t|jvr2|j|fi|St|j|jD]\} } |} t|j d rl| | d <n t!| |j"| }|j#dur|j"|j#}nd}|j$r|%}|dur||%M}||}|dur||}| &d || &d |j'| &d |j(|fd|i| d| _)q@|*|S)aYPlot with a univariate function on each diagonal subplot. Parameters ---------- func : callable plotting function Must take an x array as a positional argument and draw onto the "currently active" matplotlib Axes. Also needs to accept kwargs called ``color`` and ``label``. Nz ytick.leftTFr!r,rrr rrr!rrr )+rYrrLrKrartwinx set_axis_offrr^rCr majorTicks tick1linerrVrbr rrNr rrBobject_rXr parameters_map_diag_iter_huerr0rr5rrrr]rnotnar1rar`rrZ)rr*r rXrYrrrrr!Zdiag_axtickvarrvectorrrr"r"r#map_diags`               zPairGrid.map_diagc Ks|dd}t|j|jD]\}}|j||j}|}t|j  drV||d<n t |t |jD]\}} z|| } Wn tytjgtd} Yn0|dur|j|} n|} |jrt| } t|j  dr|f| | | d|qj|| f| | d|qjq||S)z.get_varr r rr.set_rt)rrrrm)r!bottom)hspacewspace)&rr(GridSpecrr%ax_joint ax_marg_x ax_marg_ysetprrrget_majorticklinesget_minorticklinesrgridrrrrMruanyrr r rrrCrset_xlimset_ylim _hue_paramsr rrtrr@rl)rrr r rrrrrrrrrrrfgsrrrrrnamerr"rr#r=sd             zJointGrid.__init__cCs4t|j}|D]\}}||vr|||qdS)z/Add params to kws if they are accepted by func.N)rrsrr1)rr*rr func_paramsrr r"r"r#_inject_kwargss zJointGrid._inject_kwargscKs(|j|fi||j|fi||S)a Draw the plot by passing functions for joint and marginal axes. This method passes the ``kwargs`` dictionary to both functions. If you need more control, call :meth:`JointGrid.plot_joint` and :meth:`JointGrid.plot_marginals` directly with specific parameters. Parameters ---------- joint_func, marginal_func : callables Functions to draw the bivariate and univariate plots. See methods referenced above for information about the required characteristics of these functions. kwargs Additional keyword arguments are passed to both functions. Returns ------- :class:`JointGrid` instance Returns ``self`` for easy method chaining. )plot_marginals plot_joint)rZ joint_funcZ marginal_funcr r"r"r#plotszJointGrid.plotcKs|}t|jdr$|j|d<n t|j|jdurT|j|d<||||j t|jdr~|f|j |j d|n||j |j fi||S)aDraw a bivariate plot on the joint axes of the grid. Parameters ---------- func : plotting callable If a seaborn function, it should accept ``x`` and ``y``. Otherwise, it must accept ``x`` and ``y`` vectors of data as the first two positional arguments, and it must plot on the "current" axes. If ``hue`` was defined in the class constructor, the function must accept ``hue`` as a parameter. kwargs Keyword argument are passed to the plotting function. Returns ------- :class:`JointGrid` instance Returns ``self`` for easy method chaining. rr!Nrr) r0rr5rrrrrrrr r )rr*r r"r"r#rs    zJointGrid.plot_jointcKs@t|jdo|jdk }t|j}|}|jdurR|j|d<||||j d|vrf| ddd|vrddi}dd i}nd|vrddi}dd i}|r|f|j |j d |n"t |j ||j fi|||r|f|j|jd |n"t |j||jfi|||j jd|jjd|S) aDraw univariate plots on each marginal axes. Parameters ---------- func : plotting callable If a seaborn function, it should accept ``x`` and ``y`` and plot when only one of them is defined. Otherwise, it must accept a vector of data as the first positional argument and determine its orientation using the ``vertical`` parameter, and it must plot on the "current" axes. If ``hue`` was defined in the class constructor, it must accept ``hue`` as a parameter. kwargs Keyword argument are passed to the plotting function. Returns ------- :class:`JointGrid` instance Returns ``self`` for easy method chaining. rZdistplotNrrcF orientationvertical horizontalT)r r!)r r!)rr5rr4rrsr0rrrr1r rrrr rr get_labelrr)rr*r Z seaborn_funcrZ orient_kw_xZ orient_kw_yr"r"r#r(s6        zJointGrid.plot_marginalsTr9r:)r r jointmarginalrr;cKs||d<||d<|durH|r0|jj|fi||rH|jj|fi||dur|rh|jj|fi||r|jj|fi||S)aJAdd a reference line(s) to joint and/or marginal axes. Parameters ---------- x, y : numeric Value(s) to draw the line(s) at. joint, marginal : bools Whether to add the reference line(s) to the joint/marginal axes. color : :mod:`matplotlib color ` Specifies the color of the reference line(s). linestyle : str Specifies the style of the reference line(s). line_kws : key, value mappings Other keyword arguments are passed to :meth:`matplotlib.axes.Axes.axvline` when ``x`` is not None and :meth:`matplotlib.axes.Axes.axhline` when ``y`` is not None. Returns ------- :class:`JointGrid` instance Returns ``self`` for easy method chaining. rr;N)rr<rr=r)rr r rrrr;r>r"r"r#r?eszJointGrid.reflinercKs,|jj|fi||jj|fi||S)aSet axis labels on the bivariate axes. Parameters ---------- xlabel, ylabel : strings Label names for the x and y variables. kwargs : key, value mappings Other keyword arguments are passed to the following functions: - :meth:`matplotlib.axes.Axes.set_xlabel` - :meth:`matplotlib.axes.Axes.set_ylabel` Returns ------- :class:`JointGrid` instance Returns ``self`` for easy method chaining. )rrr)rxlabelylabelr r"r"r#rszJointGrid.set_axis_labels)N)rr) r4r5r6r7r=rrrrr?rr"r"r"r#rs  R$> ,raSet up the grid of subplots and store data internally for easy plotting. Parameters ---------- {params.core.data} {params.core.xy} height : number Size of each side of the figure in inches (it will be square). ratio : number Ratio of joint axes height to marginal axes height. space : number Space between the joint and marginal axes dropna : bool If True, remove missing observations before plotting. {{x, y}}lim : pairs of numbers Set axis limits to these values before plotting. marginal_ticks : bool If False, suppress ticks on the count/density axis of the marginal plots. {params.core.hue} Note: unlike in :class:`FacetGrid` or :class:`PairGrid`, the axes-level functions must support ``hue`` to use it in :class:`JointGrid`. {params.core.palette} {params.core.hue_order} {params.core.hue_norm} See Also -------- {seealso.jointplot} {seealso.pairgrid} {seealso.pairplot} Examples -------- .. include:: ../docstrings/JointGrid.rst returnsseealso)rrrscatterautorIF)rrrrJrKrLkind diag_kindmarkersrrrMrplot_kwsdiag_kwsgrid_kwsrNc Csddlm}m}|dur,|} d}t|tt|tjsJt dt ||durVin| }|durjin| }|dur~in| }|dkr|dur|dkrdnd}n|dkrdnd}| d |dkt |f||||||| | | | d |}| dur|d krV|jdurd}n t|j}t| ts4| g|} t| |krJtd d | i|_n>|dkrt| trv| |d <n|dur|||d<| |d<| }| dd|dkr|j|fi|n4|dkr| dd| dd|j|fi||dur |j}n|j}|dkr:ddlm}||fi|n|d krbddlm}||fi|nZ|dkrddlm}| dd||fi|n&|dkrddlm}||fi||dur|||S)aY Plot pairwise relationships in a dataset. By default, this function will create a grid of Axes such that each numeric variable in ``data`` will by shared across the y-axes across a single row and the x-axes across a single column. The diagonal plots are treated differently: a univariate distribution plot is drawn to show the marginal distribution of the data in each column. It is also possible to show a subset of variables or plot different variables on the rows and columns. This is a high-level interface for :class:`PairGrid` that is intended to make it easy to draw a few common styles. You should use :class:`PairGrid` directly if you need more flexibility. Parameters ---------- data : `pandas.DataFrame` Tidy (long-form) dataframe where each column is a variable and each row is an observation. hue : name of variable in ``data`` Variable in ``data`` to map plot aspects to different colors. hue_order : list of strings Order for the levels of the hue variable in the palette palette : dict or seaborn color palette Set of colors for mapping the ``hue`` variable. If a dict, keys should be values in the ``hue`` variable. vars : list of variable names Variables within ``data`` to use, otherwise use every column with a numeric datatype. {x, y}_vars : lists of variable names Variables within ``data`` to use separately for the rows and columns of the figure; i.e. to make a non-square plot. kind : {'scatter', 'kde', 'hist', 'reg'} Kind of plot to make. diag_kind : {'auto', 'hist', 'kde', None} Kind of plot for the diagonal subplots. If 'auto', choose based on whether or not ``hue`` is used. markers : single matplotlib marker code or list Either the marker to use for all scatterplot points or a list of markers with a length the same as the number of levels in the hue variable so that differently colored points will also have different scatterplot markers. height : scalar Height (in inches) of each facet. aspect : scalar Aspect * height gives the width (in inches) of each facet. corner : bool If True, don't add axes to the upper (off-diagonal) triangle of the grid, making this a "corner" plot. dropna : boolean Drop missing values from the data before plotting. {plot, diag, grid}_kws : dicts Dictionaries of keyword arguments. ``plot_kws`` are passed to the bivariate plotting function, ``diag_kws`` are passed to the univariate plotting function, and ``grid_kws`` are passed to the :class:`PairGrid` constructor. Returns ------- grid : :class:`PairGrid` Returns the underlying :class:`PairGrid` instance for further tweaking. See Also -------- PairGrid : Subplot grid for more flexible plotting of pairwise relationships. JointGrid : Grid for plotting joint and marginal distributions of two variables. Examples -------- .. include:: ../docstrings/pairplot.rst rrNzKThe `size` parameter has been renamed to `height`; please update your code.z-'data' must be pandas DataFrame object, not: rkdehistrN) rJrKrLrrrrMrrrregzSmarkers must be a singleton or a list of markers for each level of the hue variablemarkerrrrrcFfillT warn_singular scatterplot)regplot)r)r)rrrrr UserWarningr_r[r TypeErrortyper0r1rrUrrVrrrryrlrX relationalr regressionrryr@)rrrrrJrKrLrrrrrrMrrrrrNrrmsgrZ n_markersplotterrrr"r"r#rsS                               rrrr)r r rrrrrrrrrrrrr joint_kws marginal_kwsc* sddlm}ddlm}m}ddlm}m}m}| dddurTd}t j |t dd|dur`in| }|||dur~in| }gd }g}|D] }||vr||| |q|r|d krd d |}t |t gd }td|||dur|dvrd|d}t|| dur*d} tjj| fddtdddD}t|dd}|dkrnd}t||||| | |||||| | |d} | jdur|dd|dr$|d| | j|fi|| jdur|}!n|}!|dd|d d|d| | j |!fi|n|d!r|d| | j|fi||d d|d| | }"| }#d"}$|$D]<}t!|"|t#r~||\}%}&|"||%|#||&q~|f|||d#|"d| j$i|f|||d$|#d| j%in|d rr|d| |dd| j|fi||d| d |vr\|d |d | j |fi|nh|drt&|| j'd%}'t&|| j(d%}(t)t*|'|(g})|d&|)|d'|| jt+j,fi||d d|d| | j |fi|n|d(r^|d| |d d| j |fi||d| | j|fi|n||d)r|d| | j|fi|| j-j.d/j0\}}|d| |f||| j$d*||f||| j%d+|t+1| j-| S),Nrr)r residplot)rr_freedman_diaconis_binsr!z4Ignoring `ax`; jointplot is a figure-level function.rR) stacklevel)ZrugfitZhist_kwsZnorm_histhist_kwsZrug_kwsrznThe marginal plotting function has changed to `histplot`, which does not accept the following argument(s): {}.z, )rrhexrrresidr)rrrzUse of `hue` with `kind='z'` is not currently supported.C0csg|]}tj|dqS))rF)r set_hls_valuesrDZ color_rgbr"r#rIszjointplot..r T)as_cmapr)rr r rrrrrrrrrrrrcFrrrrr)binsbinwidthbinrange)rr r)rr r2gridsizecmaprr)r rr!)r rr!)2rrrrrrrrrrrrrr0rrarr4r rrZrcolorConverterto_rgbrlinspacerrrr1rrrr_rCr`rrminr r rmeanrhexbinr collections get_offsetsTr)*rr r rrrrrrrrrrrrrrrr rrrrrrrZ distplot_keysZ unused_keysrZ plot_kindsrrrZ marg_funcZ marg_x_kwsZ marg_y_kwsZ pair_keysZx_valZy_valZx_binsZy_binsrr"rr#rs                            $                  ra4Draw a plot of two variables with bivariate and univariate graphs. This function provides a convenient interface to the :class:`JointGrid` class, with several canned plot kinds. This is intended to be a fairly lightweight wrapper; if you need more flexibility, you should use :class:`JointGrid` directly. Parameters ---------- {params.core.data} {params.core.xy} {params.core.hue} Semantic variable that is mapped to determine the color of plot elements. kind : {{ "scatter" | "kde" | "hist" | "hex" | "reg" | "resid" }} Kind of plot to draw. See the examples for references to the underlying functions. height : numeric Size of the figure (it will be square). ratio : numeric Ratio of joint axes height to marginal axes height. space : numeric Space between the joint and marginal axes dropna : bool If True, remove observations that are missing from ``x`` and ``y``. {{x, y}}lim : pairs of numbers Axis limits to set before plotting. {params.core.color} {params.core.palette} {params.core.hue_order} {params.core.hue_norm} marginal_ticks : bool If False, suppress ticks on the count/density axis of the marginal plots. {{joint, marginal}}_kws : dicts Additional keyword arguments for the plot components. kwargs Additional keyword arguments are passed to the function used to draw the plot on the joint Axes, superseding items in the ``joint_kws`` dictionary. Returns ------- {returns.jointgrid} See Also -------- {seealso.jointgrid} {seealso.pairgrid} {seealso.pairplot} Examples -------- .. include:: ../docstrings/jointplot.rst )N)3 __future__r itertoolsrinspectrrtextwraprnumpyrpandasr[rrZmatplotlib.pyplotpyplotr_oldcorerrr _compatr rr r r rrpalettesrr _docstringsrr__all__from_nested_components _param_docsrr9rrGrrrrr=r7rrr"r"r"r#s       BO;/x"& . 0   $7