BhVSSKJr SSKJr SSKJr SSKrSSKJr SSK r SSK r SSK rSSKJr SSKJrJrJr SSKJr SS KJrJr SS KJr SS KJrJrJrJ r J!r! SS K"J#r#J$r$ SS K%J&r&J'r' /SQr(\&RR"\'SS9r*"SS5r+"SS\+5r,\-"\"S5\"S5\"S5\"S5\"S5\"S5\"S5\"S5\"S5\"S5\"S5S 9 r."S!S"\,5r/"S#S$\,5r0"S%S&\+5r1S'Re\*\'S(S)9\1Rfl4SSSSSSS*S+SS,SS-S-SSSSS..S/jr5S8SSSS*S0S1S2S-SSSSSSS-SSS3.S4jjr6S5Re\*\'S6\'S(S79\6l4g)9) annotations)product) signatureN)dedent) VectorPlotter variable_typecategorical_order)handle_data_source) share_axisget_legend_handles)utils)adjust_legend_subtitlesset_hls_values_check_argument _draw_figure_disable_autolayout) color_palette blend_palette)DocstringComponents _core_docs) FacetGridPairGrid JointGridpairplot jointplotparams)corecP\rSrSrSrSr\S5r\S5rSr Sr Sr S r g ) _BaseGrid%z!Base class for grids of subplots.c nURRHnUcMUR"S0UD6 M U$)z$Set attributes on each subplot Axes.)axesflatset)selfkwargsaxs cC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\seaborn/axisgrid.pyr& _BaseGrid.set(s/))..B~  ! cUR$)z)DEPRECATED: prefer the `figure` property._figurer's r*fig _BaseGrid.fig/s||r,cUR$)zHAccess the :class:`matplotlib.figure.Figure` object underlying the grid.r.r0s r*figure_BaseGrid.figure8s||r,cU"U/UQ70UD6 U$)a@ 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#r'funcargsr(s r*apply_BaseGrid.apply=s T#D#F# r,cU"U/UQ70UD6$)aO 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#r7s r*pipe_BaseGrid.pipeLsD*4*6**r,cUR5nURSS5 URR"U0UD6 g)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 setdefaultr4savefigr'r9r(s r*rD_BaseGrid.savefigZs6-1 T,V,r,r#N) __name__ __module__ __qualname____firstlineno____doc__r&propertyr1r4r:r=rD__static_attributes__r#r,r*r r %sA+  + -r,r c`\rSrSrSrSrSrSrSrSSjr S r S r \ S 5r SS jrS rg)Gridgz>A grid that can have multiple subplots and an external legend.FTc2/SQUlSUlSUlg)N)rrrrF)_tight_layout_rect_tight_layout_pad_extract_legend_handlesr0s r*__init__ Grid.__init__ls".!%(-$r,cUR5nURSUR5 URbURSUR5 URR "U0UD6 U$)z:Call fig.tight_layout within rect that exclude the legend.rectpad)rBrCrRrSr/ tight_layoutrEs r*rZGrid.tight_layoutusa&$"9"9:  ! ! -   eT%;%; < !!4262 r,Nc PUc URnUcTURc[UR55nO-[[ [ R UR55n[RRSSS9nUVs/sHoqRXv5PM nnUc UROUn[RSn /n UH0n [U [5(aU upOU n U RU 5 M2 UR!SS5 UR"(GaUR!SS5 UR!SS 5 UR$R&"X40UD6nXlUR+US U 0S 9 U(a [-U5 [/UR$5 UR15R2UR$R4- nUR$R75unnUR$R9UU-U5 [/UR$5 UR15R2UR$R4- nUUU-- nUR:(aS OS nUU-UlSUR<- nUR$R?US9 UUR@S'U$URBRDSnUR!SS5 UR&"X40UD6nUR+US U 0S 9 UUlU(a [-U5 U$s snf)acDraw 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. r)alpha linewidthzlegend.title_fontsize scatterpointsrframeonFlocz center rightsize)propg{Gz?{Gz?)rightbest)# _legend_data hue_nameslistkeysmaprto_utf8mplpatchesPatchget_hue_varrcParams isinstancetupleappendrC _legend_outr/legend_legend set_titlerrget_window_extentwidthdpiget_size_inchesset_size_inches_margin_titles _space_neededsubplots_adjustrRr$r%)r' legend_datatitle label_orderadjust_subtitlesr( blank_handlelabhandles title_sizelabelsentry_label figlegend legend_width fig_width fig_height space_neededmarginrer)legs r* add_legendGrid.add_legend~s:  ++K  ~~%";#3#3#56 "3u}}dnn#EF {{((qA(> ALM#??35M!& E\\"9:  E%'' 5 MM% ! /1-       i /   e^ 4 ++GFvFI$L   VZ,@  A' 2  &%668>>AQAQQL$(LL$@$@$B !Iz LL ( (\)A: N  &%668>>AQAQQL'9|+CDL //SSF!',!6D ***E LL ( (u ( 5).D # #A & "B   eV ,))G6v6C MM%vz&:M ;DL', ANs L#c0nURbUR(aw[UR5nURRVs/sHoDR 5PM nnUR [ X55VVs0sHupgXv_M snn5 UR5up5UR [ X55VVs0sHupgXv_M snn5 URR U5 SUlgs snfs snnfs snnf)z8Extract the legend data from an axes object and save it.N) legend_rTr textsget_textupdatezipget_legend_handles_labelsrh)r'r)datartrhandlers r*_update_legend_dataGrid._update_legend_datas :: !d&B&B(4G,.JJ,<,<=,QNsC<D D cpUc [SS9nU$[XU5n[U5nUc;[R"5nU[U5:a [SU5nOJ[US9nO@[ U[ 5(a UV s/sHoU PM n n [X5nO [XF5n[X5nU$s sn f)z*Get a list of colors for the hue variable.r)n_colorshusl)rr lenrget_color_cyclertdict) r'rhue hue_orderpaletterircurrent_palettecolorsh color_namess r* _get_paletteGrid._get_palettes ;#Q/G2-*$)Y?I9~H"'"7"7"9c/22*68s?B3c<UR$![a gf=f)z9The :class:`matplotlib.legend.Legend` object, if present.N)ryAttributeErrorr0s r*rx Grid.legends# <<   s  c hURRHnUR"SSU0UD6 M U$)aNModify 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. axisr#)r4r$ tick_params)r'rr(r)s r*rGrid.tick_paramss1"++""B NN / / /# r,)rTryrrSrR)NNNF)both)rGrHrIrJrKrrwrUrZrrrrLrxrrMr#r,r*rOrOgsMHNK-DH$)fP&<r,rOz 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`. ) rrowcol rowcol_ordercol_wrapshare_xyheightaspectr legend_out margin_titles facet_kwsc^\rSrSrSrSSSSSSSSSSSSSSSSSSSSSS.U4S jjr\"S 5R"S&0\D6\lS r S r S r Sr Sr SrS'SjrSrS(SjrS)SjrS)SjrS*SjrS+SjrS,SjrSSSSS.Sjr\S5r\S5r\S5r\S 5r\S!5r\S"5r\S#5r\S$5r S%r!U=r"$)-ripz7Multi-plot grid for plotting conditional relationships.NTrF)rowcolrrsharexshareyrrr row_order col_orderrhue_kwsdropnardespinerxlimylim subplot_kws gridspec_kwsc >[T.U]5 [U5nUnUcSnO[XU 5nUR XX5nUc/nO[XU 5nUc/nO[XU 5nUbUO0n[ R "[U5[5nU(aOUcUOXR5nUcUOXR5nUcUOXR5nUU-U-)n OU)n UcSO [U5n!UcSO [U5n"U!U"-Ul XPl Ub=Ub Sn#[U#5eUn![[ R"[U5U- 55n"U!UlU"UlU!U-U -U"U-4n$UbSnUc0OUR#5nUc0OUR#5nUbUUS'UbUUS'[%5 [&R("U$S9n%SSS5 Uc[+SXgUUS9n&W%R,"U"U!40U&D6n'UcUc0n(GO/Uc![+[/UU'R055n(GO Uc [+[/UU'R055n(O[3UU5n)[+[/U)U'R055n(OU(a[4R6"S5 [U5n*[ R8"U*[:5n'W%R<"U"U!S40UD6U'S 'U(aU'S US 'U(aU'S US '[?SU*5Hn+U%R<"U"U!U+S-40UD6U'U+'M [+[/UU'55n(U%Ul U'Ul!U(Ul"SUl#Xl$UUl%UUl&UUl'Xl(U"UlX l)U!UlX0l*UUl+/Ul,XPl UUl-UUl.UUl/0Ul0SUl1SUl2X`l3Xpl4Xl5U Ul6URo5 URq5 U(aURs5 US ;aURtHun,U,Rw5Hn-U-RyS5 M U,RzR|RyS5 U,RzR~RyS5 Mw US ;aURHun,U,R5Hn-U-RyS5 M U,RR|RyS5 U,RR~RyS5 Mw gg!,(df  GNh=f)Nrz)Cannot use `row` and `col_wrap` together.Frrfigsize)squeezerr subplot_kw gridspec_kwz,`gridspec_kws` ignored when using `col_wrap`rrr)Tr)Tr)CsuperrUr r rnpzerosrboolisnull _n_facets _col_wrap ValueErrorintceil_ncol_nrowrBrpltr4rsubplotsrr%rwarningswarnemptyobject add_subplotranger/_axes _axes_dictryr row_names col_namesrir_row_var_col_varr_margin_titles_textsrr_colorsrwrh_x_var_y_var_sharex_sharey_dropna_not_na set_titlesrZr_not_bottom_axesget_xticklabels set_visiblexaxis offsetTextr_not_left_axesget_yticklabelsyaxis)/r'rrrrrrrrrrrrrrrrrrrrrrhue_varrirrrnone_narow_nacol_nahue_nanot_nancolnrowerrrr1r(r$ axes_dict facet_productn_axesir)r __class__s/ r*rUFacetGrid.__init__ss !$' ;I)$)Y?I""4iA ;I)$)Y?I ;I)$)Y?I%0'b((3t9d+  # W1A1A1CF # W1A1A1CF # W1A1A1CF/0FXFKqS^KqS^!  A o%Drwws9~89:D  &=6)4&=9  !M(/b[5E5E5G )1r|7H7H7J  "&K   "&K ! "**W-C#  %!'%0&24F <<d5f5D{s{  Y !:;  Y !:; ' 9 =  ]DII!>?  LM^F88FF+DoodD!C{CDG(,Q H%(,Q H%1f%//$a!eK{KQ&SD12I   #  """     +$&!!  %          LLN ] "++//1E%%e,2##//6**51 , ] "))//1E%%e,2##//6**51 * #y# "s T99 Ua? 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#b# URnUR(a,URVs/sHo!URU:HPM nnO+[R"S[ UR55/nUR (a,UR Vs/sHo!URU:HPM nnO+[R"S[ UR55/nUR(a,URVs/sHo!URU:HPM nnO+[R"S[ UR55/n[[U5[U5[U55H,uupgupupXU -U -UR-n XhU 4U 4v M. gs snfs snfs snf7f)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. TN) rrrrrepeatrrrrirrr enumerater) r'rn row_masks col_masks hue_masksrrjrkrdata_ijks r* facet_dataFacetGrid.facet_datasayy >>;?>>J>admm,1>IJI4TYY89I >>;?>>J>admm,1>IJI4TYY89I >>;?>>J>admm,1>IJI4TYY89I-4Ii4H4=i4H4=i4H-J (HQhq#IOdll:;H)X% % -J#K K Ks+,F/F  A F/F%1A F/>F*BF/crURSS5n[[USS55nUS:Xa}SU;a1SRUR5n[ R "U5 [U5S:Xa7S U;a1S RUR5n[ R "U5 UR5GHWuupxpU RR(dM&URS 5(+n URXxU 5n URX5US'URR5H upXX='M UR b&["R$"UR&U 5US 'U [)U5nUR*(aUR-5nUR5VVs/sHunnUPM nnnURS 5(aUVs/sHnURPM nnUR/XUU5 GMZ UR1USS5 U$s snnfs snf)aApply a plotting function to each facet's subset of the data. Parameters ---------- func : callable A plotting function that takes data and keyword arguments. It 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. colorNrHzseaborn.categoricalorderzXUsing the {} function without specifying `order` is likely to produce an incorrect plot.rrz\Using the {} function without specifying `hue_order` is likely to produce an incorrect plot.seabornr matplotlibrf)popstrgetattrformatrGrrrrvaluesrb startswith facet_axis _facet_colorritemsrrrrmrirjrr _facet_plot_finalize_grid)r'r8r9r(kw_color func_modulewarningrow_icol_jhue_kr modify_stater)kwval_list plot_datarv plot_argss r*rl FacetGrid.maps0::gt,'$ b9:  / /f$##)6$--#8 g&4yA~+V";##)6$--#8 g&04/@ + !U5??'' +55i@@L|>yIIL|zz#t,fjjd.CD Ra)FA N* K( r,c6URUnUbU$UbU$gN)r)r' hue_indexr0r s r*r,FacetGrid._facet_colorDs+ Y'  O  Lr,c[UR5RS5(a2UR5n/SQn[ XS5H upgXtU'M /nX$S'U"U0UD6 UR U5 g)Nr#)r>r?rrbstyler))r&rHr*rBrr)r'r8r)r; plot_kwargs semanticskeyrAs r*r.FacetGrid._facet_plotLst t  * *9 5 5%**,K:I 5#&C 6I "  i';'   $r,cBUR"U6 UR5 g)z$Finalize the annotations and layout.N)set_axis_labelsrZ)r'axlabelss r*r/FacetGrid._finalize_grid[s h' r,cURbURRUnOURX4nU(a[R"U5 U$)z?Make the axis identified by these indices active and return it.)rr$r%rsca)r'r3r4r6r)s r*r+FacetGrid.facet_axis`sE >> %&B5<(B  GGBK r,c H[R"UR40UD6 U$)z#Remove axis spines from the facets.)rrr/)r'r(s r*rFacetGrid.despinens dll-f- r,c ~UbXlUR"U4SU0UD6 UbX lUR"U4SU0UD6 U$)z>Set axis labels on the left column and bottom row of the grid. clear_inner)r set_xlabelsr set_ylabels)r'x_vary_varrXr(s r*rOFacetGrid.set_axis_labelsssM  K   U F Fv F  K   U F Fv F r,c Uc URnURHnUR"U40UD6 M U(a$URHnURS5 M U$)z/Label the x axis on the bottom row of the grid.r!)r _bottom_axes set_xlabelrr'rrXr(r)s r*rYFacetGrid.set_xlabels~sU =KKE##B MM% *6 *$ ++ b!, r,c Uc URnURHnUR"U40UD6 M U(a$URHnURS5 M U$)z0Label the y axis on the left column of the grid.r!)r _left_axes set_ylabelrras r*rZFacetGrid.set_ylabelssS =KKE//B MM% *6 *" )) b!* r,c URRHnUR5nURU5 UctUR 5Vs/sHofR 5PM nnUb/UR5SSU2nUSSU2nURU5 UR "U40UD6 MUR "U40UD6 M U$s snf)z#Set x axis tick labels of the grid.N)r$r% get_xticks set_xticksrrset_xticklabels) r'rstepr(r) curr_ticksr curr_labelsxtickss r*rjFacetGrid.set_xticklabelss))..BJ MM* %~=?=O=O=QR=QE~~/=Q R#]]_VtV4F"-ff"5KMM&)"";9&9""64V4! SsC c <URRH|nUR5nURU5 UcBUR 5Vs/sHoUR 5PM nnUR "U40UD6 MiUR "U40UD6 M~ U$s snf)z6Set y axis tick labels on the left column of the grid.)r$r% get_yticks set_yticksrrset_yticklabels)r'rr(r)rlrrms r*rsFacetGrid.set_yticklabelss))..BJ MM* %~=?=O=O=QR=QE~~/=Q R"";9&9""64V4! SsBc [URURS9nURS[R S5US'UcSnUcSnUc2URcUnO"URcUnOSR X#/5n[R"U5n[R"U5n[R"U5nUR(Ga=URHnUR5 M /Ul URb[UR5HtupxURUS4n UR[US95 UR "S0UD6n U R""U 4S S S S S S.UD6nURR%U5 Mv UR&bj[UR&5HQupUR[U S95 UR "S0UD6n URSU 4R("U 40UD6 MS U$URbURb[UR5Hnupx[UR&5HPupUR[XS95 UR "S0UD6n URX{4R("U 40UD6 MR Mp U$URb[+UR5(al[UR5HQupxUR[US95 UR "S0UD6n URUS4R("U 40UD6 MS U$UR&b[+UR&5(ar[UR&5HYup|UR[U S95 UR "S0UD6n URR,UR("U 40UD6 M[ U$)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 column variable when titles are drawn on the grid margins. Must have {col_var} and {col_name} formatting keys. Returns ------- self: object Returns self. )row_varcol_varrbzaxes.labelsizez{row_var} = {row_name}z{col_var} = {col_name}z | )row_name)gRQ??z axes fractionileftcenter)xyxycoordsrotationhava)col_namer)ryrr#)rrrr%rnrsjoinrrmrrremoverrr$rr(annotatervrrzrr%) r'template row_template col_templater(r9textrryr)rrrs r*rFacetGrid.set_titlessR,DMM4==AFCLL9I,JKv  3L  3L  }}$'&' ::|&BC}}\2 }}\2 ==*    11 2(*D %~~)#,T^^#v>$= K MM %DMM,E(8 #,T^^#v>$= 9  ^^ 'C,?,?(8  D(34 /$/ !Q$))%:6: 9 ^^ 'C,?,?(8  D(34 /$/ q!++Er?r  linestylec X5S'XES'Ub#UR"[R4SU0UD6 Ub#UR"[R4SU0UD6 U$)auAdd 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. r rr>r?)rlraxvlineaxhline)r'r>r?r rline_kwss r*reflineFacetGrid.refline sW." ) = HHS[[ 2A 2 2 = HHS[[ 2A 2 2 r,cUR$)zBAn array of the :class:`matplotlib.axes.Axes` objects in the grid.)rr0s r*r$FacetGrid.axes/szzr,cnURRS:XaURS$Sn[U5e)zJThe :class:`matplotlib.axes.Axes` when no faceting variables are assigned.)rr)rrz> !99SbS!"W%** *Djj4::->G"499- NFZZ4::>:;FZZ4::>:WDE 6KKO.88D&).. .r,c,URcURSS2S4R$/n[UR5H+up#X R-(aMUR U5 M- [ R"U[5R$)z/Return a flat array of the left column of axes.Nr rr$r%rrrvrrrr'r$rr)s r*rdFacetGrid._left_axes^so >> !99QT?'' 'D"499-::~~KKO.88D&).. .r,c0URcURSS2SS24R$/n[UR5H+up#X R-(dMUR U5 M- [ R"U[5R$)z;Return a flat array of axes that aren't on the left column.Nrrrs r*rFacetGrid._not_left_axesjsr >> !99QU#(( (D"499-zz>>KKO.88D&).. .r,cURcURSSS24R$/nURUR-UR - n[ UR5Heup4X0RURS- -:=(d! X0RURS- -U- :nU(dMTURU5 Mg [R"U[5R$)z.Return a flat array of the bottom row of axes.Nrxrrrs r*r_FacetGrid._bottom_axesvs >> !99RU#(( (Djj4::->G"499-** Q78FZZ4::>:WDE6KKO .88D&).. .r,cURcURSS2SS24R$/nURUR-UR - n[ UR5Heup4X0RURS- -:=(a! X0RURS- -U- :nU(dMTURU5 Mg [R"U[5R$)z:Return a flat array of axes that aren't on the bottom row.Nrxrrrs r*rFacetGrid._not_bottom_axess >> !99SbS!V$)) )Djj4::->G"499-tzzA~67FZZ4::>:WDE6KKO .88D&).. .r,)rrrrrrr/rrryrhrwrrrrrrrrrrrrrrrirr#)T)NNT)NT)NNrE)NNN)#rGrHrIrJrKrUrr( _facet_docsrrlrBr,r.r/r+rrOrYrZrjrsrrrLr$r)r rrdrr_rrM __classcell__rs@r*rrps|A dtD1d$$t$Ttr2r2hZ Z tVuZZ#t"uZ#Hx&&PPdEN %     Yv 4tt H&&//" / / / /// //r,rc^\rSrSrSrSSSSSSSSSSSSSSS .U4S jjrS rS rS rSr Sr Sr Sr Sr SrSrSrSrU=r$)ria)Subplot 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@rrz)rvarsx_varsy_varsrrrcorner diag_shareyrr layout_padrrc>[TU]5 [U5nURU5nUU;aUR U5 Ub[ U5n[ U5nUcUnUcUn[ R"U5(aU/n[ R"U5(aU/n[ U5=Uln[ U5=Ul nURUR:HUl U(d [S5eU(d [S5e[U5U -U -[U5U -4n[5 [R"US9nSSS5 WR![U5[U5SSSS9nXlU (aE[ R$"US 5n['U6H"unnUUU4R 5 SUUU4'M$ UUlUUlXlXlSUlSUlXlUR75 X lUc<S /=Uln[<R>"S /[U5-UR@S 9Ul!OJ[EXU5=nnU(a#[ [G[<RHU55nUUlXUl!UbUO0Ul%Xpl&X`l'URQXXg5Ul)0Ul*USS 2SS24RVHznUcMURY5HnUR[S5 M UR\R^R[S5 UR\R`R[S5 M| USS2S S24RVHznUcMURc5HnUR[S5 M URdR^R[S5 URdR`R[S5 M| /S QUl3Xl4Xl5U(a[lRn"US9 URqU S9 g!,(df  GN=f)aInitialize 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_)indexrx)rdrdGz?r)r1)rY)9rrUr _find_numeric_colsrrjrisscalarrr square_gridrrrrr4r_cornertriu_indices_fromrr/r$rr diag_vars diag_axesr_add_axis_labelsrrripdSeriesrhue_valsr filternotnullr _orig_palette _hue_orderrrrhr%rrrrrrrrRrS_despinerrrZ)r'rrrrrrrrrrrrrrr numeric_colsrr1r$ hide_indicesrrrir)rrs r*rUPairGrid.__init__sp !$'..t4 ,     $  $ZF$ZF >!F >!F ;;v  XF ;;v  XF#F|+ f#F|+ f;;$++5CD D@A Af+&/Vv1EE "**W-C#||CKV#($)+ //a8L\*1QT !!#!QT +   '   ;*6 7DNYII|ns4y&@,0JJ8DM%6di$K KI   I!>? &DN IDM#*"5w2 $#((IG ssAv,##Bz++-!!%(. HH   + +E 2 HHNN & &u - $q!"u+""Bz++-!!%(. HH   + +E 2 HHNN & &u - ##7!+  MMc " j)k# "s 1P.. P=c [R"URR5up4[ UR UR 5nUR "X40UD6 U$)aPlot 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``. )rindicesr$rrr%_map_bivariate)r'r8r( row_indices col_indicesrs r*rl PairGrid.mapVsM$&::diioo#> k&& (8(89 D4V4 r,c z[[R"URS56nUR"X40UD6 U$)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``. rx)rrtril_indices_fromr$rr'r8r(rs r* map_lowerPairGrid.map_lowergs7r++DIIr:; D4V4 r,c z[[R"URS56nUR"X40UD6 U$)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)rrrr$rrs r* map_upperPairGrid.map_uppervs7r++DIIq9: D4V4 r,c nUR(a9UR"U40UD6 UR(dUR"U40UD6 U$/n[ UR 5H<upE[ UR 5HupgXu:wdM URXF45 M M> UR"X40UD6 U$)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``. ) rrrrrrrrvr)r'r8r(rrr\rr[s r* map_offdiagPairGrid.map_offdiags    NN4 *6 *<<t.v. G' 4 "+DKK"8JA~v.#95    8 8 r,c fURGc/n/n[UR5GH2upV[UR5GHupxX:XdM UR U5 UR XW4n U R 5n U R5 UR U 5 [RRSS5(d8U RRHn U RRS5 M UR(dMU RRS5 UR (dM["R$"U SS9 GM GM5 UR&(a#U(aUSSHn [)USU S5 M X0lX@lS [-U5R.;aUR0"U40UD6$[3UR*UR5GH1upUR55n [7UR85R;S 5(aXS 'O[R<"U 5 UR>U nUR@bUR>UR@nOSnURB(a3URE5nUbUURE5-nUUnUbUUnU RGS U5 U RGS URH5 U RGS URJ5 U"SSU0U D6 SU l&GM4 URO5 U$)a!Plot 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?rr#r)rrr>r#)(rrrrrvr$twinx set_axis_offrrsrqr majorTicks tick1linerrrrrrr rr parameters_map_diag_iter_huerrBr&rHr*rSrrrrnotnarCrrrr)r'r8r(rrrr\rr[r)diag_axtickvarrJvectorrr s r*map_diagPairGrid.map_diags >> !II%dkk2 )$++ 6HA~"((/!YYqt_"$((*,,.!((1 #||// dCC(*(;(; $ : :5 A)< <<<HH007#}}} % $ ?)!732I#AB-By|R5('N&N  $22 2**4:6: :4>>4>>:GC ++-K4??#..y99$&D! YYs^F}}(ii .||?ciik)F?f+C  " "5# .  " "; @  " "9d.@.@ A  )6 )[ )BJ5;8  r,c BURSS5n[URUR5GH.upEURUR UR SS9nUR5n[UR5RS5(aXWS'O[R"U5 [UR5HupURU 5n UcUR(Un OUn UR*(a[,R."U 5n [UR5RS5(a U"S XU S.UD6 MU"U 4XS .UD6 M GM1 UR15 U$![ a ["R$"/[&S9n Nf=f) zrr )rr r#)r%rrrrgroupbyrrBr&rHr*rrSrr get_groupKeyErrorrrfloatrrr remove_nar) r'r8r( fixed_colorrr) hue_groupedrJrlabel_kdata_kr s r*rPairGrid._map_diag_iter_huesSjj$/ 4>>4>>:GC))C.000NK ++-K4??#..y99$&D! '8 8(227;F& LLOE'E<<"__V4Ft'229==M6MMKwK{K'9;<  % 8YYr7F8sE88#FFc ~SSKJnJn XLdXLaSUlUR 5nUHLupxUR Un UR Un URXx4n U cM8UR"XX40UD6 MN UR5 S[U5R;a[UR5Ulgg)z,Draw a bivariate plot on the indicated axes.rhistplotkdeplotTNr) distributionsrrrTrBrrr$_plot_bivariaterrrrjrhri) r'r8rr(rrkwsrrr[r\r)s r*rPairGrid._map_bivariates 5  t+/D (kkmDAKKNEKKNE14Bz  r ?3 ?   IdO.. .!$"3"34DN /r,c S[U5R;aUR"XX440UD6 gUR5n[ UR 5R S5(aX5S'O[R"U5 X:XaU/nOX/nURb+URU;aURUR5 URUnUR(aUR5nXqnXrn URcSn OURUR5n SU;a(URXR UR"S.5 U"SXS.UD6 UR%U5 g)z,Draw a bivariate plot on the specified axes.rNr#r))rrrr>r?r#)rr_plot_bivariate_iter_huerBr&rHr*rrSrrrvrrrrqrrrr) r'r[r\r)r8r( axes_varsrr>r?rs r*rPairGrid._plot_bivariate,s4  $22 2  ) )% KF K  t  * *9 5 54L GGBK >II == $i)G   T]] +yy# <<;;=D K K == C((4==)C   MMTEWEW   q     $r,c UR5n[UR5RS5(aX5S'O[R "U5 X:XaU/nOX/nUR RURSS9n[UR5HupUR5n URU 5n UR (aXR#5n Xn Xn UR$R'5H upXX'M U R)SUR*U5 UR,bXS'[UR5RS5(a U"S XS .U D6 MU"X40U D6 M UR/U5 g![a [R"U[S9n Nf=f) z7Draw a bivariate plot while iterating over hue subsets.r#r)Tr)columnsrr Nrrr#)rBr&rHr*rrSrrrrrrrr DataFramerrrrr-rCrrrr)r'r[r\r)r8r(rrrrrrr>r?r7r8s r*r!PairGrid._plot_bivariate_iter_hueSsz t  * *9 5 54L GGBK >IIii'' 'E #DOO4JA++-C 3$..w7 ||*113 A A $ 2 2 4 "+!5 NN7DLLO 4}}(&G 4??#..y99%q%%Q!S!558   $+ 3i,13 3s0F#F?>F?c[URSSS24UR5HupURU5 M [URSS2S4UR5HupUR U5 M g)z'Add labels to the left and bottom Axes.rxNr)rr$rr`rre)r'r)rs r*rPairGrid._add_axis_labelssaTYYr1u-t{{;IB MM% <TYYq!t_dkk:IB MM% ;r,cd/nUH'n[X5S:XdMURU5 M) U$)z0Find which variables in a DataFrame are numeric.numeric)r rv)r'rrrs r*rPairGrid._find_numeric_colss6 CTY'94##C(r,)rrrrTr/rrrrhrrSrRr$rrrrrrirrrrr)rGrHrIrJrKrUrlrrrrrrrrrrrMrrs@r*rrsw  d4d5d1T%m*m*^"  0Pd%N5,%%N*%X!r,rc~\rSrSrSrSSSSSSSSSSSSSSS. S jjrS rS rS rS r SSSSSSS.Sjr SSjr Sr g)rizGrid for drawing a bivariate plot with marginal univariate plots. Many plots can be drawn by using the figure-level interface :func:`jointplot`. Use this class directly when you need more flexibility. N皙?F) r>r?rrratiospacerrhue_normrrrmarginal_ticksc ^^[R"XU4S9n[R"US-US-5nURUSS2SS245nURUSSS24US9nURUSS2S4US9nXlUUlUUlUUl[R"UR5SS9 [R"UR5SS9 [R"URS S 9SS9 [R"URS S 9SS9 U(Gdt[R"URR5SS9 [R"URR5SS9 [R"URR5SS9 [R"URR5SS9 [R"UR5SS9 [R"UR5SS9 [R"URS S 9SS9 [R"URS S 9SS9 URRS5 URRS5 [!U[#X#US 9S 9mTR$R&SS2TR$R)5R+54mU (aTR-5mUU4S jnU"S5UlU"S5UlU"S5UlSH:nTR4R7US5nUcM$[9USUS35"U5 M< U bUR;U 5 U bUR=U 5 [#XU S9Ul[@RB"U5 U(d*[@RB"US S9 [@RB"US S9 UU4H=nURUR4HnURDRGS5 M M? URI5 URKXwS9 g)Nrrrxr)r)rF)visibleT)minor)r>r?r)r variablesc>TRUS5nUb+URTRRUS55nU$rE)rqrenamer)rrpr9s r*get_var#JointGrid.__init__..get_vars;]]3-F!q{{sD'ABMr,r>r?rr}set_r)rrrr)r)bottom)hspacewspace)&rr4GridSpecrr/ax_joint ax_marg_x ax_marg_ysetprrrget_majorticklinesget_minorticklinesrgridrrr9raranyrr>r?rrrqr'set_xlimset_ylim _hue_paramsrrrrrZr)r'rr>r?rrrrrrrrrrrfgsr(r)r*r!rnamer$r r9s @@r*rUJointGrid.__init__sw JJ/ 0 \\%!)UQY /==ABG-MM"QV*XM> MM"QRV*XM>    "" **,e< **,e< ***6F ***6F HHY__7795 I HHY__7795 I HHY__7795 I HHY__7795 I HHY..0% @ HHY..0% @ HHY..T.:E J HHY..T.:E J OO  ' OO  ' tta#/F GKKOOAq{{'8'8':'>'>'@$@A  !((*I  5>D;;??4.DDe"45d;     d #     d # xX  a MMYT 2 MMYt 4 *DTZZ0 &&u-1+  5r,c[U5RnUR5HupVXT;dM URXV5 M g)z/Add params to kws if they are accepted by func.N)rrr-rC)r'r8rr func_paramsrLrAs r*_inject_kwargsJointGrid._inject_kwargss5o00  HC!s('r,c RUR"U40UD6 UR"U40UD6 U$)aDraw 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)r' joint_func marginal_funcr(s r*plotJointGrid.plots-, M4V4  -f- r,c UR5n[UR5RS5(aURUS'O [ R "UR5 URb+URUS'URXUR5 [UR5RS5(a!U"SURURS.UD6 U$U"URUR40UD6 U$)a;Draw 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. r#r)rrr#) rBr&rHr*r(rrSrr9r2r>r?)r'r8r(s r*r=JointGrid.plot_joint s( t  * *9 5 5==F4L GGDMM " 88  HHF5M   d.>.> ? t  * *9 5 5  .466TVV .v .   *6 * r,c [UR5RS5=(a URS:X+n[ U5R nUR 5nURb+URUS'URXUR5 SU;aURSS5 SU;a SS0nSS0nOSU;aSS0nSS 0nU(a U"S URURS .UD6 O5[R"UR5 U"UR40WDUD6 U(a U"S URUR S .UD6 O5[R"UR 5 U"UR40WDUD6 URR"R%5R'S5 UR R(R%5R'S5 U$) 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. r#distplotrrxF orientationvertical horizontalT)r>r))r?r)r#)r&rHr*rGrrrBrr9r2rCr>r)rrSr?r*r get_labelrr)r'r8r( seaborn_funcr8 orient_kw_x orient_kw_ys r*r<JointGrid.plot_marginals.s,  + +I 6 0MMZ/   o00  88  HHF5M   d.>.> ? { "   h . K '(*5K(,7K ; &%u-K%t,K   7466dnn 7 7 GGDNN #  1; 1& 1   7466dnn 7 7 GGDNN #  1; 1& 1 &&(44U; &&(44U; r,Trr)r>r?jointmarginalr rc BXWS'XgS'UbHU(aURR"U40UD6 U(aURR"U40UD6 UbHU(aURR"U40UD6 U(aURR"U40UD6 U$)aAdd 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. r r)r(rr)rr*)r'r>r?rNrOr rrs r*rJointGrid.reflineks6" ) = %%a484&&q5H5 = %%a484&&q5H5 r,c zURR"U40UD6 URR"U40UD6 U$)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. )r(r`re)r'xlabelylabelr(s r*rOJointGrid.set_axis_labelss7&   262   262 r,)r/r2r(r)r*rr>r?rE)r!r!) rGrHrIrJrKrUr9r@r=r<rrOrMr#r,r*rrshP6 $Dt4d5 P6d)4"H;|4tdd*Xr,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 seealso)rrVscatterautorF)rrrrrrkind diag_kindmarkersrrrrplot_kwsdiag_kwsgrid_kwsrbcHSSKJnJn UbUn Sn[R"U[ 5 [ U[R5(d[S[U535eUc0OUR5nUc0OUR5nUc0OUR5nUS:XaUc US:XaSOSnO US:XaSOSnURSUS:H5 [U4XEXaX#U XU S . UD6nU bUS :XadURcSnO[UR5n[ U [ 5(dU /U-n [U 5U:wa [#S 5eS U 0UlO.US :Xa([ U [&5(aXS 'OUb XUS'XS'UR5nURSS5 US:XaUR("U40UD6 O=US:Xa7URSS5 URSS5 UR("U40UD6 Ub UR*nO UR,nUS :XaSSKJn U"U40UD6 OSUS :XaSSKJn U"U40UD6 O=US:Xa"SSKJn URSS5 U"U40UD6 OUS:XaSSKJn U"U40UD6 UbUR75 UR95 U$)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 rrzKThe `size` parameter has been renamed to `height`; please update your code.z-'data' must be pandas DataFrame object, not: rXkdehistr) rrrrrrrrrrregzSmarkers must be a singleton or a list of markers for each level of the hue variablemarkerrWrIr[rxFfillT warn_singular scatterplot)regplot)r)r)rrrrr UserWarningrtrr  TypeErrortyperBrCrrirrjrrr&rrrl relationalrg regressionrhrrZ)rrrrrrrrYrZr[rrrrr\r]r^rbrrmsgr. n_markersplotterrgrhs r*rrsf1 * c;' dBLL ) );DJ< HJ J%r8==?H%r8==?H%r8==?HF ;!%FI"&&.eI  yF':; D Mt6'! MCK MD  5=~~% / gt,,")i/7|y( "NOO$g.DL Y '3''%,"$(I!&-#}}H %(F h+(+ e FD)OU3 g**""(( y+ (x( '$8$ *OU3$8$ +%H%   Kr,rrr)r>r?rrYrrrrrrr rrrr joint_kws marginal_kwsc l SSKJn SSKJnJn SSKJnJnJn URSS5bSn[R"U[SS9 Uc0OUR5nURU5 Uc0OUR5n/S Qn/nUH-nUU;dM URU5 URU5 M/ U(aAUS :wa;S R!S R#U55n[R"U[5 /S Qn[%SUU5 UbUS;aSUS3n['U5eU cSn [(R*R,R/U 5n[0R2"SSS5Vs/sH n[5UUS9PM n n[7U SS9n!US:XaSn[9XX#XUXXgXUS9n"U"R:bUR=SS5 UR?S5(aUR=SU 5 U"R@"U40UD6 U"R:cUn#O&Un#UR=SS5 UR=SS5 UR=SU 5 U"RB"U#40UD6 GOUR?S 5(aUR=SU 5 U"R@"U40UD6 UR=S S5 UR=SU 5 UR5n$UR5n%S!n&U&HUn[EURGU5[H5(dM)UUun'n(U$R=UU'5 U%R=UU(5 MW U"S+XUS".U$DSU"RJ0D6 U"S+XUS#.U%DSU"RL0D6 GOUR?S 5(ayUR=SU 5 UR=SS5 U"R@"U40UD6 UR=SU 5 SU;aUR=SUS5 U"RB"U40UD6 GO UR?S5(a[OU"U"RP5S$5n)[OU"U"RR5S$5n*[U[0RV"U)U*/55n+UR=S%U+5 UR=S&U!5 U"R@"[XRZ40UD6 UR=S S5 UR=SU 5 U"RB"U40UD6 GOUR?S'5(a]UR=SU 5 UR=S S5 U"RB"U40UD6 UR=SU 5 U"R@"U40UD6 OUR?S(5(aUR=SU 5 U"R@"U40UD6 U"R\R^SRa5RbupUR=SU 5 U"S+XU"RJS).UD6 U"S+X#U"RLS*.UD6 [XRd"U"R\5 U"$s snf),Nrrf)rh residplot)rr_freedman_diaconis_binsr)z4Ignoring `ax`; jointplot is a figure-level function.rf) stacklevel)rugfithist_kwsnorm_histhist_kwsrug_kwsr`znThe marginal plotting function has changed to `histplot`, which does not accept the following argument(s): {}.z, )rWrahexr`rbresidrY)r|rbr}zUse of `hue` with `kind='z'` is not currently supported.C0r )lT)as_cmapr|)rr>r?rrrrrrrrrrrrxFrWr rerdra)binsbinwidthbinrange)rr>r)rr?r2gridsizecmaprbr})r>rr))r?rr)r#)3rlrgrmrhrtrrrrur%rrrirBrrvr(rrrrnrcolorConverterto_rgbrlinspacerrrrrCr*r=r<rtrqrur)r*minr>r?rmeanrhexbinr( collections get_offsetsTrS),rr>r?rrYrrrrrrr rrrrrqrrr(rgrhrtrrrurn distplot_keys unused_keysrL plot_kinds color_rgbrArrr. marg_func marg_x_kws marg_y_kws pair_keysx_valy_valx_binsy_binsrs, r*rrs(.II zz$)D c;15 'Y^^-=I V%-2<3D3D3FLMK ,    s #   S !tu} D &;' (   c;'CJFJ- 4#::)$/MNo } ))007I:<++aB:O P:O3nY#.:OF P  .D u}  !xE ^  D xx%0 y!!We,  1y1 88  II  # #OU ;  # #FD 1/ I66  We, .I.u-/!&&( !&&( 2 C)--,e44(~ u%%c51%%c51  JdSJJJ4>>JJdSJJJ4>>J   We,_e4 -9-/ Y   # #FIf,= > G4|4   ,TVV4b9,TVV4b9rww/01Z2VT*  0i0u-/ H5 5   /t, H5 5We, -9-  ! !We,  /Y/}}((+779;;/A1$..ALAA1$..ALAGGDMM KUQs7X1aDraw 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} 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 returns)rrrVrE)7 __future__r itertoolsrinspectrrtextwraprnumpyrpandasrr$rnmatplotlib.pyplotpyplotr_baserr r _core.datar _compatr r r!rrrrrrpalettesrr _docstringsrr__all__from_nested_components _param_docsr rOrrrrrr(rUrKrrr#r,r*rs*"BB*33 J"88 H  ?-?-DK9K\             i8 vf /f /Rstsl] ]@ %J F  y ! K Z d d4 fd qu D4d k^ ]Dd ARDt tE ]@5j F  y ! y ! k r,