W[c@ s$ddlmZddlmZddlmZddlZddlmZddl Z ddl Z ddl mZddlZddljZddlmZdd lmZmZdd lmZdd lmZmZmZd d dddgZde fdYZ!e"deddeddeddeddeddedded d!ed"Z#d e!fd#YZ$d e!fd$YZ%de fd%YZ&e'e'e'e'e'e'd&d'e'd(de(e'e'e'e'd)Z)e'd&e'e'd*d+d,e(e'e'e'e'e'd- Z*dS(.i(tdivision(tproduct(t LooseVersionN(tdedent(tstatsi(tutils(t color_palettet blend_palette(t string_types(tdistplottkdeplott_freedman_diaconis_binst FacetGridtPairGridt JointGridtpairplott jointplottGridcB sYeZdZeZeZdZdZddddZ dZ dZ dZ RS(s!Base class for grids of subplots.cK s(x!|jjD]}|j|q W|S(s$Set attributes on each subplot Axes.(taxestflattset(tselftkwargstax((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRscO s3|j}|jdd|jj||dS(sSave the figure.t bbox_inchesttightN(tcopyt setdefaulttfigtsavefig(RtargsR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyR!s cK s|dkr|jn|}|dkri|jdkrKt|j}qitttj|j}ntj j dddd}g|D]}|j ||^q}|dkr|j n|}ytj dd}Wntk rtj d}nX|jdd|jrz|jdt|jj||d |} | |_| j|d i|d 6t|jjd r|jj|jjjn| jj|jj} |jj\} } |jj| | | t|jjd r|jj|jjjn| jj|jj} | | | } |jrDd nd}|| |_ d|j }|jj!d|nE|j"j#d}|j||dd|}|j|d i|d 6|S(s:Draw a legend, maybe placing it outside axes and resizing the figure. Parameters ---------- legend_data : dict, optional Dictionary mapping label names to matplotlib artist handles. The default reads from ``self._legend_data``. title : string, optional Title for the legend. The default reads from ``self._hue_var``. label_order : list of labels, optional The order that the legend entries should appear in. The default reads from ``self.hue_names``. 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. talphait linewidthsaxes.labelsizeg333333?t scatterpointsitframeons center righttproptsizet get_rendererg{Gz?g{Gz?trighttloctbestN($tNonet _legend_datat hue_namestlisttkeystmapRtto_utf8tmpltpatchestPatchtgett_hue_vartrcParamst TypeErrorRt _legend_outtFalseRtlegendt_legendt set_titlethasattrtcanvastdrawR%tget_window_extenttwidthtdpitget_size_inchestset_size_inchest_margin_titlest _space_neededtsubplots_adjustRR(Rt legend_datattitlet label_orderRt blank_handletlthandlest title_sizet figlegendt legend_widtht fig_widtht fig_heightt space_neededtmarginR&Rtleg((s/lib/python2.7/site-packages/seaborn/axisgrid.pyt add_legend'sH %      cC s'|jd|jdd|_|S(s Turn off axis labels and legend.tN(t set_xlabelt set_ylabelR)tlegend_(RR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyt _clean_axis{s   cC s?|j\}}dt||D}|jj|dS(s8Extract the legend data from an axes object and save it.cS si|]\}}||qS(((t.0thRK((s/lib/python2.7/site-packages/seaborn/axisgrid.pys s N(tget_legend_handles_labelstzipR*tupdate(RRRLtlabelstdata((s/lib/python2.7/site-packages/seaborn/axisgrid.pyt_update_legend_datasc C s|dkrtdd}ntj|||}t|}|dkrtj}|t|kr|td|}qtd|}nMt|trg|D]} || ^q} t| |}nt||}t||}|S(s*Get a list of colors for the hue variable.tn_colorsithuslN(R)RRtcategorical_ordertlentget_color_cyclet isinstancetdict( RRathuet hue_ordertpaletteR+Rctcurrent_palettetcolorsR\t color_names((s/lib/python2.7/site-packages/seaborn/axisgrid.pyt _get_palettes    N(t__name__t __module__t__doc__R8RDtTrueR7RRR)RURZRbRp(((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRs  T  Ras data : DataFrame Tidy ("long-form") dataframe where each column is a variable and each row is an observation. tcol_wraps col_wrap : int, optional "Wrap" the column variable at this width, so that the column facets span multiple rows. Incompatible with a ``row`` facet. tshare_xys share{x,y} : bool, 'col', or 'row' optional If true, the facets will share y axes across columns and/or x axes across rows. theightsa height : scalar, optional Height (in inches) of each facet. See also: ``aspect``. taspects aspect : scalar, optional Aspect ratio of each facet, so that ``aspect * height`` gives the width of each facet in inches. Rls palette : palette name, list, or dict, optional 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. t legend_outs legend_out : bool, optional If ``True``, the figure size will be extended, and the legend will be drawn outside the plot on the center right. t margin_titless margin_titles : bool, optional 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. cB sgeZdZeeeeeeddeeeeeeeeeeeeeedZedje e_dZ dZ dZ dZ d Zd Zd Zd Zeed ZedZedZeedZedZeeedZedZedZedZedZedZedZRS(s7Multi-plot grid for plotting conditional relationships.iic0 C std}ttj|k}|dk rL|}d}tj|tn|}|dkrgd}ntj||| }|j ||| | }|dkrg}ntj||| }|dkrg}ntj||| }|dk r|ni}t j t |t j } |r|dkr6| n ||j}!|dkrX| n ||j}"|dkrz| n ||j}#|!|"B|#B}$n| }$|dkrdn t |}%|dkrdn t |}&|%|&|_||_|dk rJ|dk r"d}'t|'n|}%tt jt ||}&n|%|_|&|_|%|| |&|f}(|dk rt}n|dkrin |j}|dkrin |j}|dk r||dndS(Ns1.4sJThe `size` paramter has been renamed to `height`; please update your code.is)Cannot use `row` and `col_wrap` together.txlimtylimtfigsizetsqueezetsharextshareyt subplot_kwt gridspec_kws+gridspec module only available in mpl >= {}s,`gridspec_kws` ignored when using `col_wrap`i(?RR0t __version__R)twarningstwarnt UserWarningRReRptnptzerosRftbooltisnullt _n_facetst _col_wrapt ValueErrortinttceilt_ncolt_nrowR8RRitpoptformattplttsubplotsRtfiguretemptytobjectt add_subplottranget_not_bottom_axestget_xticklabelst set_visibletxaxist offsetTextt_not_left_axestget_yticklabelstyaxisRaRt row_namest col_namesR+thue_kwst_row_vart_col_varRDR4t_colorsR7R:R*t_x_vart_y_vart_dropnat_not_nat tight_layouttdespine(0RRatrowtcolRjRuRRRwRxRlt row_ordert col_orderRkRtdropnaRyRRzR{R|t subplot_kwst gridspec_kwsR$tMPL_GRIDSPEC_VERSIONtOLD_MPLtmsgthue_varR+RnRRtnone_natrow_natcol_nathue_natnot_natncoltnrowterrR}RRRtn_axestiRtlabel((s/lib/python2.7/site-packages/seaborn/axisgrid.pyt__init__s        """    "             $                        s' 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 varaible with the ``hue`` parameter, which plots different subets 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. When using seaborn functions that infer semantic mappings from a dataset, care must be taken to synchronize those mappings across facets. 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. 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. 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 ``*_order`` parameters to control the order of levels of this variable. {col_wrap} {share_xy} {height} {aspect} {palette} {{row,col,hue}}_order : lists, optional 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, optional Remove the top and right spines from the plots. {margin_titles} {{x, y}}lim: tuples, optional Limits for each of the axes on each facet (only relevant when share{{x, y}} is True. subplot_kws : dict, optional Dictionary of keyword arguments passed to matplotlib subplot(s) methods. gridspec_kws : dict, optional Dictionary of keyword arguments passed to matplotlib's ``gridspec`` module (via ``plt.subplots``). Requires matplotlib >= 1.4 and is 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`. catplot : Combine a categorical plot and a :class:`FacetGrid`. lmplot : Combine a regression plot and a :class:`FacetGrid`. Examples -------- Initialize a 2x2 grid of facets using the tips dataset: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set(style="ticks", color_codes=True) >>> tips = sns.load_dataset("tips") >>> g = sns.FacetGrid(tips, col="time", row="smoker") Draw a univariate plot on each facet: .. plot:: :context: close-figs >>> import matplotlib.pyplot as plt >>> g = sns.FacetGrid(tips, col="time", row="smoker") >>> g = g.map(plt.hist, "total_bill") (Note that it's not necessary to re-catch the returned variable; it's the same object, but doing so in the examples makes dealing with the doctests somewhat less annoying). Pass additional keyword arguments to the mapped function: .. plot:: :context: close-figs >>> import numpy as np >>> bins = np.arange(0, 65, 5) >>> g = sns.FacetGrid(tips, col="time", row="smoker") >>> g = g.map(plt.hist, "total_bill", bins=bins, color="r") Plot a bivariate function on each facet: .. plot:: :context: close-figs >>> g = sns.FacetGrid(tips, col="time", row="smoker") >>> g = g.map(plt.scatter, "total_bill", "tip", edgecolor="w") Assign one of the variables to the color of the plot elements: .. plot:: :context: close-figs >>> g = sns.FacetGrid(tips, col="time", hue="smoker") >>> g = (g.map(plt.scatter, "total_bill", "tip", edgecolor="w") ... .add_legend()) Change the height and aspect ratio of each facet: .. plot:: :context: close-figs >>> g = sns.FacetGrid(tips, col="day", height=4, aspect=.5) >>> g = g.map(plt.hist, "total_bill", bins=bins) Specify the order for plot elements: .. plot:: :context: close-figs >>> g = sns.FacetGrid(tips, col="smoker", col_order=["Yes", "No"]) >>> g = g.map(plt.hist, "total_bill", bins=bins, color="m") Use a different color palette: .. plot:: :context: close-figs >>> kws = dict(s=50, linewidth=.5, edgecolor="w") >>> g = sns.FacetGrid(tips, col="sex", hue="time", palette="Set1", ... hue_order=["Dinner", "Lunch"]) >>> g = (g.map(plt.scatter, "total_bill", "tip", **kws) ... .add_legend()) Use a dictionary mapping hue levels to colors: .. plot:: :context: close-figs >>> pal = dict(Lunch="seagreen", Dinner="gray") >>> g = sns.FacetGrid(tips, col="sex", hue="time", palette=pal, ... hue_order=["Dinner", "Lunch"]) >>> g = (g.map(plt.scatter, "total_bill", "tip", **kws) ... .add_legend()) Additionally use a different marker for the hue levels: .. plot:: :context: close-figs >>> g = sns.FacetGrid(tips, col="sex", hue="time", palette=pal, ... hue_order=["Dinner", "Lunch"], ... hue_kws=dict(marker=["^", "v"])) >>> g = (g.map(plt.scatter, "total_bill", "tip", **kws) ... .add_legend()) "Wrap" a column variable with many levels into the rows: .. plot:: :context: close-figs >>> att = sns.load_dataset("attention") >>> g = sns.FacetGrid(att, col="subject", col_wrap=5, height=1.5) >>> g = g.map(plt.plot, "solutions", "score", marker=".") Define a custom bivariate function to map onto the grid: .. plot:: :context: close-figs >>> from scipy import stats >>> def qqplot(x, y, **kwargs): ... _, xr = stats.probplot(x, fit=False) ... _, yr = stats.probplot(y, fit=False) ... plt.scatter(xr, yr, **kwargs) >>> g = sns.FacetGrid(tips, col="smoker", hue="sex") >>> g = (g.map(qqplot, "total_bill", "tip", **kws) ... .add_legend()) Define a custom function that uses a ``DataFrame`` object and accepts column names as positional variables: .. plot:: :context: close-figs >>> import pandas as pd >>> df = pd.DataFrame( ... data=np.random.randn(90, 4), ... columns=pd.Series(list("ABCD"), name="walk"), ... index=pd.date_range("2015-01-01", "2015-03-31", ... name="date")) >>> df = df.cumsum(axis=0).stack().reset_index(name="val") >>> def dateplot(x, y, **kwargs): ... ax = plt.gca() ... data = kwargs.pop("data") ... data.plot(x=x, y=y, ax=ax, grid=False, **kwargs) >>> g = sns.FacetGrid(df, col="walk", col_wrap=2, height=3.5) >>> g = g.map_dataframe(dateplot, "date", "val") Use different axes labels after plotting: .. plot:: :context: close-figs >>> g = sns.FacetGrid(tips, col="smoker", row="sex") >>> g = (g.map(plt.scatter, "total_bill", "tip", color="g", **kws) ... .set_axis_labels("Total bill (US Dollars)", "Tip")) Set other attributes that are shared across the facetes: .. plot:: :context: close-figs >>> g = sns.FacetGrid(tips, col="smoker", row="sex") >>> g = (g.map(plt.scatter, "total_bill", "tip", color="r", **kws) ... .set(xlim=(0, 60), ylim=(0, 12), ... xticks=[10, 30, 50], yticks=[2, 6, 10])) Use a different template for the facet titles: .. plot:: :context: close-figs >>> g = sns.FacetGrid(tips, col="size", col_wrap=3) >>> g = (g.map(plt.hist, "tip", bins=np.arange(0, 13), color="c") ... .set_titles("{{col_name}} diners")) Tighten the facets: .. plot:: :context: close-figs >>> g = sns.FacetGrid(tips, col="smoker", row="sex", ... margin_titles=True) >>> g = (g.map(plt.scatter, "total_bill", "tip", color="m", **kws) ... .set(xlim=(0, 60), ylim=(0, 12), ... xticks=[10, 30, 50], yticks=[2, 6, 10]) ... .fig.subplots_adjust(wspace=.05, hspace=.05)) c c s}|j}|jr>g|jD]}||j|k^q}ntjtt|jg}|jrg|jD]}||j|k^qo}ntjtt|jg}|j rg|j D]}||j |k^q}ntjtt|jg}xtt t |t |t |D]N\\}}\}} \} } ||| @| @|j @} ||| f| fVq'WdS(sGenerator 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. N(RaRRRtrepeatRtRfRRR+R4Rt enumerateR( RRatnt row_maskst col_maskst hue_masksRRtjRtkRjtdata_ijk((s/lib/python2.7/site-packages/seaborn/axisgrid.pyt facet_data~s  , , , .cO s|jdd }t|dr3t|j}nd}|dkrd|krsdj|j}tj|nt |dkrd|krd j|j}tj|qnxH|j D]:\\}}} } | j j sqn|j ||} |j| ||d    "  %c O s|jdd}x|jD]\\}}}}|jjsFqn|j||} |j|||dSet axis labels on the left column and bottom row of the grid.N(R)Rt set_xlabelsRt set_ylabels(Rtx_varty_var((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRds    cK s@|dkr|j}nx!|jD]}|j||q"W|S(s/Label the x axis on the bottom row of the grid.N(R)Rt _bottom_axesRW(RRRR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRns   cK s@|dkr|j}nx!|jD]}|j||q"W|S(s0Label the y axis on the left column of the grid.N(R)Rt _left_axesRX(RRRR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRvs   cK sx|jjD]}|dkrg|jD]}|j^q,}|dk r|jdd|}|dd|}|j|qn|j||q W|S(s5Set x axis tick labels on the bottom row of the grid.N(RRR)Rtget_textt get_xtickst set_xtickstset_xticklabels(RR`tstepRRRKtxticks((s/lib/python2.7/site-packages/seaborn/axisgrid.pyR~s % cK s_xX|jjD]J}|dkrGg|jD]}|j^q,}n|j||q W|S(s6Set y axis tick labels on the left column of the grid.N(RRR)RRtset_yticklabels(RR`RRRK((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRs  (c K std|jd|j}|jdtjd|d<|dkrMd}n|dkrbd}n|dkr|jdkr|}q|jdkr|}qdj||g}ntj |}tj |}tj |}|j r|j dk rxt |j D]\}}|j |df}|jtd ||j|} |jj} |j| d dd dddddddd| |q Wn|jdk r xbt |jD]N\} } |jtd| |j|} |j d| fj| |qWn|S|jdk r|jdk rxt |j D]t\}}xet |jD]T\} } |jtd |d| |j|} |j || fj| |q[Wq?Wn|j dk r=t|j r=xt |j D]N\}}|jtd ||j|} |j |dfj| |qWn|jdk rt|jrx_t |jD]K\}} |jtd| |j|} |j j|j| |qkWn|S(sDraw 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. trow_vartcol_varR$saxes.labelsizes{row_var} = {row_name}s{col_var} = {col_name}s | itrow_nametxygRQ?g?txycoordss axes fractiontrotationithatlefttvatcentertbackgroundcolortcol_nameiN(gRQ?g?(RiRRRR0R5R)tjoinRR/RDRRRR_RRt get_facecolortannotateRR;RfR( Rttemplatet row_templatet col_templateRRRRRRHtbgcolorRR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRs`        $($!cC s3|jjdkr|jdSd}t|dS(sEasy access to single axes.iisOYou must use the `.axes` attribute (an array) when there is more than one plot.N(ii(ii(RtshapetAttributeError(RR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRs cC s|jdkr/|jddddfjSg}|j|j|j}xxt|jD]g\}}||jo||j|jdko||j|jd|k}|r\|j|q\q\Wt j |t jSdS(s&Return a flat array of the inner axes.Nii( RR)RRRRRRtappendRtarrayR(RRtn_emptyRRR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyt _inner_axess  cC s|jdkr)|jdddfjSg}x:t|jD])\}}||js?|j|q?q?Wtj|t jSdS(s/Return a flat array of the left column of axes.Ni( RR)RRRRRRRR(RRRR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRs cC s|jdkr/|jddddfjSg}x:t|jD])\}}||jrE|j|qEqEWtj|t jSdS(s;Return a flat array of axes that aren't on the left column.Ni( RR)RRRRRRRR(RRRR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyR s  cC s|jdkr)|jdddfjSg}|j|j|j}xkt|jD]Z\}}||j|jdkp||j|jd|k}|rV|j|qVqVWt j |t jSdS(s.Return a flat array of the bottom row of axes.iNi( RR)RRRRRRRRRR(RRRRRR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRscC s|jdkr/|jddddfjSg}|j|j|j}xkt|jD]Z\}}||j|jdko||j|jd|k}|r\|j|q\q\Wt j |t jSdS(s:Return a flat array of axes that aren't on the bottom row.Nii( RR)RRRRRRRRRR(RRRRRR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyR's (RqRrRsR)RtR8RRRt _facet_docsRR.RRRRRRRRRRRRtpropertyRRRRRR(((s/lib/python2.7/site-packages/seaborn/axisgrid.pyR s<     ( S B      T   cB s}eZdZd d d d d d d eddeed d ZdZdZdZdZ dZ d Z d Z RS( sNSubplot grid for plotting pairwise relationships in a dataset. This class 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 the marginal distribution of each variable can be shown on the diagonal. It can also represent an additional level of conditionalization with the ``hue`` parameter, which plots different subets 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. See the :ref:`tutorial ` for more information. g@ic C s|d k r.|} d}tjt|n|d k rUt|}t|}n]|d k sm|d k r|d ks|d krtdqn|j|}|}|}tj|r|g}ntj|r|g}nt||_ t||_ |j |j k|_ t || | t || f}t jt |t |d|dddddt\}}||_||_||_| |_d |_|j||_|d krd g|_tjd gt |d |j|_nMtj|||}| r5tttj|}n||_|||_|d k r]|ni|_ |j!|||||_"i|_#| rtj$d |n|j%d S( shInitialize 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), optional 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. 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). vars : list of variable names, optional Variables within ``data`` to use, otherwise use every column with a numeric datatype. {x, y}_vars : lists of variable names, optional Variables within ``data`` to use separately for the rows and columns of the figure; i.e. to make a non-square plot. height : scalar, optional Height (in inches) of each facet. aspect : scalar, optional Aspect * height gives the width (in inches) of each facet. despine : boolean, optional Remove the top and right spines from the plots. dropna : boolean, optional 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 -------- Draw a scatterplot for each pairwise relationship: .. plot:: :context: close-figs >>> import matplotlib.pyplot as plt >>> import seaborn as sns; sns.set() >>> iris = sns.load_dataset("iris") >>> g = sns.PairGrid(iris) >>> g = g.map(plt.scatter) Show a univariate distribution on the diagonal: .. plot:: :context: close-figs >>> g = sns.PairGrid(iris) >>> g = g.map_diag(plt.hist) >>> g = g.map_offdiag(plt.scatter) (It's not actually necessary to catch the return value every time, as it is the same object, but it makes it easier to deal with the doctests). Color the points using a categorical variable: .. plot:: :context: close-figs >>> g = sns.PairGrid(iris, hue="species") >>> g = g.map_diag(plt.hist) >>> g = g.map_offdiag(plt.scatter) >>> g = g.add_legend() Use a different style to show multiple histograms: .. plot:: :context: close-figs >>> g = sns.PairGrid(iris, hue="species") >>> g = g.map_diag(plt.hist, histtype="step", linewidth=3) >>> g = g.map_offdiag(plt.scatter) >>> g = g.add_legend() Plot a subset of variables .. plot:: :context: close-figs >>> g = sns.PairGrid(iris, vars=["sepal_length", "sepal_width"]) >>> g = g.map(plt.scatter) Pass additional keyword arguments to the functions .. plot:: :context: close-figs >>> g = sns.PairGrid(iris) >>> g = g.map_diag(plt.hist, edgecolor="w") >>> g = g.map_offdiag(plt.scatter, edgecolor="w", s=40) Use different variables for the rows and columns: .. plot:: :context: close-figs >>> g = sns.PairGrid(iris, ... x_vars=["sepal_length", "sepal_width"], ... y_vars=["petal_length", "petal_width"]) >>> g = g.map(plt.scatter) Use different functions on the upper and lower triangles: .. plot:: :context: close-figs >>> g = sns.PairGrid(iris) >>> g = g.map_upper(plt.scatter) >>> g = g.map_lower(sns.kdeplot, cmap="Blues_d") >>> g = g.map_diag(sns.kdeplot, lw=3, legend=False) Use different colors and markers for each categorical level: .. plot:: :context: close-figs >>> g = sns.PairGrid(iris, hue="species", palette="Set2", ... hue_kws={"marker": ["o", "s", "D"]}) >>> g = g.map(plt.scatter, linewidths=1, edgecolor="w", s=40) >>> g = g.add_legend() sJThe `size` paramter has been renamed to `height`; please update your code.s"Must specify `x_vars` and `y_vars`R}RRRRR~t _nolegend_tindexRN(&R)RRRR,Rt_find_numeric_colsRtisscalartx_varsty_varst square_gridRfRRR8RRRat diag_shareyt diag_axest_add_axis_labelsR4R+tpdtSeriesRthue_valsRRetfiltertnotnullRRpRlR*RR(RRaRjRkRlRtvarsRRRRwRxRRR$Rt numeric_colsR}RRR+((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRJs^     $             c K s|jdd}xet|jD]T\}}xEt|jD]4\}}|jj|j}xt|jD]\} } y|j | } Wn2t k rt j d|jj dtj} nX|j||f} tj| x+|jjD]\} }|| || Wq"W|dk r||dR R(((s/lib/python2.7/site-packages/seaborn/axisgrid.pyR 7s    , 7 . /  c B sweZdZd ddded d d dZd dZdZdZd d dd Z d d d Z d Z RS(sAGrid for drawing a bivariate plot with marginal univariate plots.iig?c C s| dk r+| }d} tj| tntjd||f} tj|d|d} | j| ddddf}| j| dddfd|}| j| dddfd|}| |_||_ ||_ ||_ tj |j d ttj |jd ttj |jjd ttj |jjd ttj |jjd ttj |jjd ttj |jd ttj |j d t|jjt|jjt|dk r|j||}|j||}nxA||gD]3}t|tr$d j|}t|q$q$Wt|d r|j}|j|nt|d r|j}|j|ntj|}tj|}|rt j!|t j!|@}||}||}n||_"||_#|dk r0|j$|n| dk rL|j%| nt&j'| t&j'd |d t(t&j'd |dt(| j)| j*d|d|dS(s2Set up the grid of subplots. Parameters ---------- x, y : strings or vectors Data or names of variables in ``data``. data : DataFrame, optional DataFrame when ``x`` and ``y`` are variable names. height : numeric Size of each side of the figure in inches (it will be square). ratio : numeric Ratio of joint axes size to marginal axes height. space : numeric, optional Space between the joint and marginal axes dropna : bool, optional If True, remove observations that are missing from `x` and `y`. {x, y}lim : two-tuples, optional Axis limits to set before plotting. See Also -------- jointplot : High-level interface for drawing bivariate plots with several different default plot kinds. Examples -------- Initialize the figure but don't draw any plots onto it: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set(style="ticks", color_codes=True) >>> tips = sns.load_dataset("tips") >>> g = sns.JointGrid(x="total_bill", y="tip", data=tips) Add plots using default parameters: .. plot:: :context: close-figs >>> g = sns.JointGrid(x="total_bill", y="tip", data=tips) >>> g = g.plot(sns.regplot, sns.distplot) Draw the join and marginal plots separately, which allows finer-level control other parameters: .. plot:: :context: close-figs >>> import matplotlib.pyplot as plt >>> g = sns.JointGrid(x="total_bill", y="tip", data=tips) >>> g = g.plot_joint(plt.scatter, color=".5", edgecolor="white") >>> g = g.plot_marginals(sns.distplot, kde=False, color=".5") Draw the two marginal plots separately: .. plot:: :context: close-figs >>> import numpy as np >>> g = sns.JointGrid(x="total_bill", y="tip", data=tips) >>> g = g.plot_joint(plt.scatter, color="m", edgecolor="white") >>> _ = g.ax_marg_x.hist(tips["total_bill"], color="b", alpha=.6, ... bins=np.arange(0, 60, 5)) >>> _ = g.ax_marg_y.hist(tips["tip"], color="r", alpha=.6, ... orientation="horizontal", ... bins=np.arange(0, 12, 1)) Add an annotation with a statistic summarizing the bivariate relationship: .. plot:: :context: close-figs >>> from scipy import stats >>> g = sns.JointGrid(x="total_bill", y="tip", data=tips) >>> g = g.plot_joint(plt.scatter, ... color="g", s=40, edgecolor="white") >>> g = g.plot_marginals(sns.distplot, kde=False, color="g") >>> g = g.annotate(stats.pearsonr) Use a custom function and formatting for the annotation .. plot:: :context: close-figs >>> g = sns.JointGrid(x="total_bill", y="tip", data=tips) >>> g = g.plot_joint(plt.scatter, ... color="g", s=40, edgecolor="white") >>> g = g.plot_marginals(sns.distplot, kde=False, color="g") >>> rsquare = lambda a, b: stats.pearsonr(a, b)[0] ** 2 >>> g = g.annotate(rsquare, template="{stat}: {val:.2f}", ... stat="$R^2$", loc="upper left", fontsize=12) Remove the space between the joint and marginal axes: .. plot:: :context: close-figs >>> g = sns.JointGrid(x="total_bill", y="tip", data=tips, space=0) >>> g = g.plot_joint(sns.kdeplot, cmap="Blues_d") >>> g = g.plot_marginals(sns.kdeplot, shade=True) Draw a smaller plot with relatively larger marginal axes: .. plot:: :context: close-figs >>> g = sns.JointGrid(x="total_bill", y="tip", data=tips, ... height=5, ratio=2) >>> g = g.plot_joint(sns.kdeplot, cmap="Reds_d") >>> g = g.plot_marginals(sns.kdeplot, color="r", shade=True) Set limits on the axes: .. plot:: :context: close-figs >>> g = sns.JointGrid(x="total_bill", y="tip", data=tips, ... xlim=(0, 50), ylim=(0, 8)) >>> g = g.plot_joint(sns.kdeplot, cmap="Purples_d") >>> g = g.plot_marginals(sns.kdeplot, color="m", shade=True) sKThe `size` parameter has been renamed to `height`; pleaes update your code.R}iNiiRRtvisiblesCould not interpret input '{}'tnameRRtbottomthspacetwspace(+R)RRRRRtGridSpecRRtax_jointt ax_marg_xt ax_marg_ytsetpRR8RRtget_majorticklinestget_minorticklinesRtgridR3RhRRRR<RARWRXRR5R!R%txtytset_xlimtset_ylimRRRtRRF(RRMRNRaRwtratiotspaceRR{R|R$RtftgsRFRGRHR6Rtxlabeltylabeltx_arrayty_arrayR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRsj %%%               cC s:|j||j||dk r6|j|n|S(shShortcut to draw the full plot. Use `plot_joint` and `plot_marginals` directly for more control. Parameters ---------- joint_func, marginal_func: callables Functions to draw the bivariate and univariate plots. Returns ------- self : JointGrid instance Returns `self`. N(tplot_marginalst plot_jointR)R (Rt joint_funct marginal_funct annot_func((s/lib/python2.7/site-packages/seaborn/axisgrid.pytplots    cK s*tj|j||j|j||S(sDraw a bivariate plot of `x` and `y`. Parameters ---------- func : plotting callable This must take two 1d arrays of data as the first two positional arguments, and it must plot on the "current" axes. kwargs : key, value mappings Keyword argument are passed to the plotting function. Returns ------- self : JointGrid instance Returns `self`. (RRRFRMRN(RRR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRZscK sXt|d>> import seaborn as sns; sns.set(style="ticks", color_codes=True) >>> iris = sns.load_dataset("iris") >>> g = sns.pairplot(iris) Show different levels of a categorical variable by the color of plot elements: .. plot:: :context: close-figs >>> g = sns.pairplot(iris, hue="species") Use a different color palette: .. plot:: :context: close-figs >>> g = sns.pairplot(iris, hue="species", palette="husl") Use different markers for each level of the hue variable: .. plot:: :context: close-figs >>> g = sns.pairplot(iris, hue="species", markers=["o", "s", "D"]) Plot a subset of variables: .. plot:: :context: close-figs >>> g = sns.pairplot(iris, vars=["sepal_width", "sepal_length"]) Draw larger plots: .. plot:: :context: close-figs >>> g = sns.pairplot(iris, height=3, ... vars=["sepal_width", "sepal_length"]) Plot different variables in the rows and columns: .. plot:: :context: close-figs >>> g = sns.pairplot(iris, ... x_vars=["sepal_width", "sepal_length"], ... y_vars=["petal_width", "petal_length"]) Use kernel density estimates for univariate plots: .. plot:: :context: close-figs >>> g = sns.pairplot(iris, diag_kind="kde") Fit linear regression models to the scatter plots: .. plot:: :context: close-figs >>> g = sns.pairplot(iris, kind="reg") Pass keyword arguments down to the underlying functions (it may be easier to use :class:`PairGrid` directly): .. plot:: :context: close-figs >>> g = sns.pairplot(iris, diag_kind="kde", markers="+", ... plot_kws=dict(s=50, edgecolor="b", linewidth=1), ... diag_kws=dict(shade=True)) sKThe `size` parameter has been renamed to `height`; pleaes update your code.s8'data' must be pandas DataFrame object, not: {typefound}t typefoundthistR&RRRjRkRlRRwRxRisSmarkers must be a singleton or a list of markers for each level of the hue variabletmarkerRmtkdetshadeR9Rl(t scatterplottreg(tregplotN( R)RRRRhR!R-R6RttypeR R+RfR,RRRRR9RRoRRtR8R R>R.t relationalRst regressionRuRU(RaRjRkRlR&RRtkindt diag_kindtmarkersRwRxRtplot_kwstdiag_kwstgrid_kwsR$RRRLt n_markerstplotterRsRu((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRusd         !               iig?cK sd|kr4|jd}d}tj|tn| dkrIi} n| j|| dkrki} n|dkri}n|dkrtd}ntjj j |}gt j dddD]}t j|d|^q}t|dt}t|||d| d |d |d |d | d | }|dkr| jd||jtj| | jdt| jd||jt| nh|jdrRtt|jd}tt|jd}tt j||g}| jd|| jd||jtj | | jdt| jd||jt| n|jdr| jdt| jd||jt!| | jdt| jd||jt!| n6|jdr&ddl"m#}| jd||jt| | jd||j|| n|jdrddl"m$}| jd||j|| |j%j&dj'j(\}}| jd|| jdtt|d|j)| t|dtdt*j+d|j,| d}nd}t-||dk r|j.||n|S(sDraw 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 ---------- x, y : strings or vectors Data or names of variables in ``data``. data : DataFrame, optional DataFrame when ``x`` and ``y`` are variable names. kind : { "scatter" | "reg" | "resid" | "kde" | "hex" }, optional Kind of plot to draw. stat_func : callable or None, optional *Deprecated* color : matplotlib color, optional Color used for the plot elements. height : numeric, optional Size of the figure (it will be square). ratio : numeric, optional Ratio of joint axes height to marginal axes height. space : numeric, optional Space between the joint and marginal axes dropna : bool, optional If True, remove observations that are missing from ``x`` and ``y``. {x, y}lim : two-tuples, optional Axis limits to set before plotting. {joint, marginal, annot}_kws : dicts, optional Additional keyword arguments for the plot components. kwargs : key, value pairings 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 ------- grid : :class:`JointGrid` :class:`JointGrid` object with the plot on it. See Also -------- JointGrid : The Grid class used for drawing this plot. Use it directly if you need more flexibility. Examples -------- Draw a scatterplot with marginal histograms: .. plot:: :context: close-figs >>> import numpy as np, pandas as pd; np.random.seed(0) >>> import seaborn as sns; sns.set(style="white", color_codes=True) >>> tips = sns.load_dataset("tips") >>> g = sns.jointplot(x="total_bill", y="tip", data=tips) Add regression and kernel density fits: .. plot:: :context: close-figs >>> g = sns.jointplot("total_bill", "tip", data=tips, kind="reg") Replace the scatterplot with a joint histogram using hexagonal bins: .. plot:: :context: close-figs >>> g = sns.jointplot("total_bill", "tip", data=tips, kind="hex") Replace the scatterplots and histograms with density estimates and align the marginal Axes tightly with the joint Axes: .. plot:: :context: close-figs >>> iris = sns.load_dataset("iris") >>> g = sns.jointplot("sepal_width", "petal_length", data=iris, ... kind="kde", space=0, color="g") Draw a scatterplot, then add a joint density estimate: .. plot:: :context: close-figs >>> g = (sns.jointplot("sepal_length", "sepal_width", ... data=iris, color="k") ... .plot_joint(sns.kdeplot, zorder=0, n_levels=6)) Pass vectors in directly without using Pandas, then name the axes: .. plot:: :context: close-figs >>> x, y = np.random.randn(2, 300) >>> g = (sns.jointplot(x, y, kind="hex") ... .set_axis_labels("x", "y")) Draw a smaller figure with more space devoted to the marginal plots: .. plot:: :context: close-figs >>> g = sns.jointplot("total_bill", "tip", data=tips, ... height=5, ratio=3, color="g") Pass keyword arguments down to the underlying plots: .. plot:: :context: close-figs >>> g = sns.jointplot("petal_length", "sepal_length", data=iris, ... marginal_kws=dict(bins=15, rug=True), ... annot_kws=dict(stat="r"), ... s=40, edgecolor="w", linewidth=1) R$sJThe `size` paramter has been renamed to `height`; please update your code.iii RKtas_cmapRRwRQRRR{R|RlRRqthexi2tgridsizetcmapRrRt(Rutresid(t residplotRR_tfits>kind must be either 'scatter', 'reg', 'resid', 'kde', or 'hex'N(/RRRRR)R_RR0RntcolorConvertertto_rgbRtlinspaceRtset_hls_valuesRRtRRRZRRlR8RYR RtminR RMRNRtmeanthexbinR RxRuRRFt collectionst get_offsetstTRGRtnormRHRR (RMRNRaRyt stat_funcRRwRQRRRR{R|t joint_kwst marginal_kwst annot_kwsRRt color_rgbRKRnRRLtx_binsty_binsRRuR((s/lib/python2.7/site-packages/seaborn/axisgrid.pyRUs}         4    (+t __future__Rt itertoolsRtdistutils.versionRRttextwrapRtnumpyRtpandasR!tscipyRRR0tmatplotlib.pyplottpyplotRRVRtpalettesRRt external.sixRt distributionsR R R t__all__RRRiRR R RR)RtRR(((s/lib/python2.7/site-packages/seaborn/axisgrid.pytsb            eu