W[c'@ sddlmZddlmZddlmZddlmZddlZ ddl Z ddl Z ddljZddlmZddlmZdd lmZmZmZmZmZdd lmZdd lmZmZmZdd l m!Z!m"Z"d ddgZ#de$fdYZ%de%fdYZ&de%fdYZ'e(deddeddeddeddedd ed!d"ed#d$ed%d&ed'd(ed)d*ed+d,ed-d.ed/d0ed1d2ed3d4ed5d6ed7d8ed9d:d;Z)e)j*e"e+e+e+e+e+e+e+e+e+e+e+e+e,e+e+e+d<d=d>e,d?e+d@e+dAZ-edBj.e)e-_/e+e+e+e+e+e+e+e+e+e+e+e+e,e+e+e+e+e+d=d>dCe+e+d@e+dDZ0edEj.e)e0_/e+e+e+e+e+e+e+e+e+e+e+e+e+e+e+e+e+e+e+e+d@dFdGde+dHZ1edIj.e)e1_/dS(Ji(tdivision(tproduct(tdedent(t LooseVersionNi(t string_types(tutils(tcategorical_ordertget_color_cyclet ci_to_errsizetsort_dft remove_na(t bootstrap(t color_palettetcubehelix_palettet_parse_cubehelix_args(t FacetGridt _facet_docstrelplott scatterplottlineplott_RelationalPlotterc B seZeejdkr<ddddddddgZnddddddgZd ddd d!d"gZd#d#d#d#d#d#d#dZdZ dZ dZ dZ dZ dZdZdZdZdZdZdZdZRS($s2.0totXtstPtDt^tvtptig?iiiic C sd}} } } } |dkr|dkrd|_t|tjry|jtjWn#tk rd} t| nX|j }|j |j dddfstvisiblecs s|]}|jVqdS(N(R(RR((s1lib/python2.7/site-packages/seaborn/relational.pys sN(RFR,REtget_xticklabelst set_xlabelRGtget_yticklabelst set_ylabel(RMtaxt x_visiblet y_visible((s1lib/python2.7/site-packages/seaborn/relational.pyt label_axess c  s|j}|dkr*d}t|nigtddddddd d d d }fd }|dkr|jd krt|jtjjrtj j dd}ntj j dd}|j |j j|jdj}n |j}|jdk r.||jdf|j|nxB|D]:}|dk r5|j|} ||j|d| q5q5W|dkr|jd krt|jtjjrtj j dd}ntj j dd}|j |jj|jdj} n |j} |jdk r2||jdf|j|nxH| D]@}|dk r9|j|} ||j|d| d| q9q9W|jdk r||jdf|j|nxZ|jD]O}|dk r||j|d |jj|d d |jj|d qqWt ||j!} i} g}xD]}|\}}|}|j"ddi}x5|j#dgD]#}||krp||||Add labeled artists to represent the different plot semantics.tbrieftfulls*`legend` must be 'brief', 'full', or FalsetcolortwRit linewidthtmarkerRRc sM||f}|kr,|j|nj|t||   "    , ,6 )   N(RRRRR,RR(((s1lib/python2.7/site-packages/seaborn/relational.pyR<Ds      tmain_api_narratives The relationship between ``x`` and ``y`` can be shown for different subsets of the data using the ``hue``, ``size``, and ``style`` parameters. These parameters control what visual semantics are used to identify the different subsets. It is possible to show up to three dimensions independently by using all three semantic types, but this style of plot can be hard to interpret and is often ineffective. Using redundant semantics (i.e. both ``hue`` and ``style`` for the same variable) can be helpful for making graphics more accessible. See the :ref:`tutorial ` for more information. t data_varss x, y : names of variables in ``data`` or vector data, optional Input data variables; must be numeric. Can pass data directly or reference columns in ``data``. RNs data : DataFrame, array, or list of arrays, optional Input data structure. If ``x`` and ``y`` are specified as names, this should be a "long-form" DataFrame containing those columns. Otherwise it is treated as "wide-form" data and grouping variables are ignored. See the examples for the various ways this parameter can be specified and the different effects of each. R\sp palette : string, list, dict, or matplotlib colormap An object that determines how colors are chosen when ``hue`` is used. It can be the name of a seaborn palette or matplotlib colormap, a list of colors (anything matplotlib understands), a dict mapping levels of the ``hue`` variable to colors, or a matplotlib colormap object. Rs hue_order : list, optional Specified order for the appearance of the ``hue`` variable levels, otherwise they are determined from the data. Not relevant when the ``hue`` variable is numeric. Rys hue_norm : tuple or Normalize object, optional Normalization in data units for colormap applied to the ``hue`` variable when it is numeric. Not relevant if it is categorical. Rs sizes : list, dict, or tuple, optional An object that determines how sizes are chosen when ``size`` is used. It can always be a list of size values or a dict mapping levels of the ``size`` variable to sizes. When ``size`` is numeric, it can also be a tuple specifying the minimum and maximum size to use such that other values are normalized within this range. Rs size_order : list, optional Specified order for appearance of the ``size`` variable levels, otherwise they are determined from the data. Not relevant when the ``size`` variable is numeric. Rs size_norm : tuple or Normalize object, optional Normalization in data units for scaling plot objects when the ``size`` variable is numeric. Rs markers : boolean, list, or dictionary, optional Object determining how to draw the markers for different levels of the ``style`` variable. Setting to ``True`` will use default markers, or you can pass a list of markers or a dictionary mapping levels of the ``style`` variable to markers. Setting to ``False`` will draw marker-less lines. Markers are specified as in matplotlib. Rs style_order : list, optional Specified order for appearance of the ``style`` variable levels otherwise they are determined from the data. Not relevant when the ``style`` variable is numeric. R+sE units : {long_form_var} Grouping variable identifying sampling units. When used, a separate line will be drawn for each unit with appropriate semantics, but no legend entry will be added. Useful for showing distribution of experimental replicates when exact identities are not needed. Rs estimator : name of pandas method or callable or None, optional Method for aggregating across multiple observations of the ``y`` variable at the same ``x`` level. If ``None``, all observations will be drawn. Rs ci : int or "sd" or None, optional Size of the confidence interval to draw when aggregating with an estimator. "sd" means to draw the standard deviation of the data. Setting to ``None`` will skip bootstrapping. Rsi n_boot : int, optional Number of bootstraps to use for computing the confidence interval. RsP legend : "brief", "full", or False, optional How to draw the legend. If "brief", numeric ``hue`` and ``size`` variables will be represented with a sample of evenly spaced values. If "full", every group will get an entry in the legend. If ``False``, no legend data is added and no legend is drawn. tax_insr ax : matplotlib Axes, optional Axes object to draw the plot onto, otherwise uses the current Axes. tax_outsY ax : matplotlib Axes Returns the Axes object with the plot drawn onto it. t long_form_vars6name of variables in ``data`` or vector data, optionaltmeani_iRRc/K std|d|d|d|d|d|d|d|d |d | d | d | d | d| d|d|d|d|d|d|d|d|d|}|dkrtj}n|j|||S(NRR#R!R)R$RNR\RRyRRRRRRR+RRRRcRRR(RR,tplttgcaR(RR#R!R)R$RNR\RRyRRRRRRR+RRRRcRRRRRtR((s1lib/python2.7/site-packages/seaborn/relational.pyR(s$ s4 Draw a line plot with possibility of several semantic groupings. {main_api_narrative} By default, the plot aggregates over multiple ``y`` values at each value of ``x`` and shows an estimate of the central tendency and a confidence interval for that estimate. Parameters ---------- {data_vars} hue : {long_form_var} Grouping variable that will produce lines with different colors. Can be either categorical or numeric, although color mapping will behave differently in latter case. size : {long_form_var} Grouping variable that will produce lines with different widths. Can be either categorical or numeric, although size mapping will behave differently in latter case. style : {long_form_var} Grouping variable that will produce lines with different dashes and/or markers. Can have a numeric dtype but will always be treated as categorical. {data} {palette} {hue_order} {hue_norm} {sizes} {size_order} {size_norm} dashes : boolean, list, or dictionary, optional Object determining how to draw the lines for different levels of the ``style`` variable. Setting to ``True`` will use default dash codes, or you can pass a list of dash codes or a dictionary mapping levels of the ``style`` variable to dash codes. Setting to ``False`` will use solid lines for all subsets. Dashes are specified as in matplotlib: a tuple of ``(segment, gap)`` lengths, or an empty string to draw a solid line. {markers} {style_order} {units} {estimator} {ci} {n_boot} sort : boolean, optional If True, the data will be sorted by the x and y variables, otherwise lines will connect points in the order they appear in the dataset. err_style : "band" or "bars", optional Whether to draw the confidence intervals with translucent error bands or discrete error bars. err_band : dict of keyword arguments Additional paramters to control the aesthetics of the error bars. The kwargs are passed either to ``ax.fill_between`` or ``ax.errorbar``, depending on the ``err_style``. {legend} {ax_in} kwargs : key, value mappings Other keyword arguments are passed down to ``plt.plot`` at draw time. Returns ------- {ax_out} See Also -------- scatterplot : Show the relationship between two variables without emphasizing continuity of the ``x`` variable. pointplot : Show the relationship between two variables when one is categorical. Examples -------- Draw a single line plot with error bands showing a confidence interval: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set() >>> import matplotlib.pyplot as plt >>> fmri = sns.load_dataset("fmri") >>> ax = sns.lineplot(x="timepoint", y="signal", data=fmri) Group by another variable and show the groups with different colors: .. plot:: :context: close-figs >>> ax = sns.lineplot(x="timepoint", y="signal", hue="event", ... data=fmri) Show the grouping variable with both color and line dashing: .. plot:: :context: close-figs >>> ax = sns.lineplot(x="timepoint", y="signal", ... hue="event", style="event", data=fmri) Use color and line dashing to represent two different grouping variables: .. plot:: :context: close-figs >>> ax = sns.lineplot(x="timepoint", y="signal", ... hue="region", style="event", data=fmri) Use markers instead of the dashes to identify groups: .. plot:: :context: close-figs >>> ax = sns.lineplot(x="timepoint", y="signal", ... hue="event", style="event", ... markers=True, dashes=False, data=fmri) Show error bars instead of error bands and plot the standard error: .. plot:: :context: close-figs >>> ax = sns.lineplot(x="timepoint", y="signal", hue="event", ... err_style="bars", ci=68, data=fmri) Show experimental replicates instead of aggregating: .. plot:: :context: close-figs >>> ax = sns.lineplot(x="timepoint", y="signal", hue="event", ... units="subject", estimator=None, lw=1, ... data=fmri.query("region == 'frontal'")) Use a quantitative color mapping: .. plot:: :context: close-figs >>> dots = sns.load_dataset("dots").query("align == 'dots'") >>> ax = sns.lineplot(x="time", y="firing_rate", ... hue="coherence", style="choice", ... data=dots) Use a different normalization for the colormap: .. plot:: :context: close-figs >>> from matplotlib.colors import LogNorm >>> ax = sns.lineplot(x="time", y="firing_rate", ... hue="coherence", style="choice", ... hue_norm=LogNorm(), data=dots) Use a different color palette: .. plot:: :context: close-figs >>> ax = sns.lineplot(x="time", y="firing_rate", ... hue="coherence", style="choice", ... palette="ch:2.5,.25", data=dots) Use specific color values, treating the hue variable as categorical: .. plot:: :context: close-figs >>> palette = sns.color_palette("mako_r", 6) >>> ax = sns.lineplot(x="time", y="firing_rate", ... hue="coherence", style="choice", ... palette=palette, data=dots) Change the width of the lines with a quantitative variable: .. plot:: :context: close-figs >>> ax = sns.lineplot(x="time", y="firing_rate", ... size="coherence", hue="choice", ... legend="full", data=dots) Change the range of line widths used to normalize the size variable: .. plot:: :context: close-figs >>> ax = sns.lineplot(x="time", y="firing_rate", ... size="coherence", hue="choice", ... sizes=(.25, 2.5), data=dots) Plot from a wide-form DataFrame: .. plot:: :context: close-figs >>> import numpy as np, pandas as pd; plt.close("all") >>> index = pd.date_range("1 1 2000", periods=100, ... freq="m", name="date") >>> data = np.random.randn(100, 4).cumsum(axis=0) >>> wide_df = pd.DataFrame(data, index, ["a", "b", "c", "d"]) >>> ax = sns.lineplot(data=wide_df) Plot from a list of Series: .. plot:: :context: close-figs >>> list_data = [wide_df.loc[:"2005", "a"], wide_df.loc["2003":, "b"]] >>> ax = sns.lineplot(data=list_data) Plot a single Series, pass kwargs to ``plt.plot``: .. plot:: :context: close-figs >>> ax = sns.lineplot(data=wide_df["a"], color="coral", label="line") Draw lines at points as they appear in the dataset: .. plot:: :context: close-figs >>> x, y = np.random.randn(2, 5000).cumsum(axis=1) >>> ax = sns.lineplot(x=x, y=y, sort=False, lw=1) REc/K std|d|d|d|d|d|d|d|d |d | d | d | d | d| d|d|d|d|d|d|d|d|d|}|dkrtj}n|j|||S(NRR#R!R$R)RNR\RRyRRRRRR?R@RRRRRARBR(R<R,RQRRR(RR#R!R$R)RNR\RRyRRRRRR?R@R+RRRRRARBRRRtR((s1lib/python2.7/site-packages/seaborn/relational.pyR's $   s Draw a scatter plot with possibility of several semantic groupings. {main_api_narrative} Parameters ---------- {data_vars} hue : {long_form_var} Grouping variable that will produce points with different colors. Can be either categorical or numeric, although color mapping will behave differently in latter case. size : {long_form_var} Grouping variable that will produce points with different sizes. Can be either categorical or numeric, although size mapping will behave differently in latter case. style : {long_form_var} Grouping variable that will produce points with different markers. Can have a numeric dtype but will always be treated as categorical. {data} {palette} {hue_order} {hue_norm} {sizes} {size_order} {size_norm} {markers} {style_order} {{x,y}}_bins : lists or arrays or functions *Currently non-functional.* {units} *Currently non-functional.* {estimator} *Currently non-functional.* {ci} *Currently non-functional.* {n_boot} *Currently non-functional.* alpha : float Proportional opacity of the points. {{x,y}}_jitter : booleans or floats *Currently non-functional.* {legend} {ax_in} kwargs : key, value mappings Other keyword arguments are passed down to ``plt.scatter`` at draw time. Returns ------- {ax_out} See Also -------- lineplot : Show the relationship between two variables connected with lines to emphasize continuity. swarmplot : Draw a scatter plot with one categorical variable, arranging the points to show the distribution of values. Examples -------- Draw a simple scatter plot between two variables: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set() >>> import matplotlib.pyplot as plt >>> tips = sns.load_dataset("tips") >>> ax = sns.scatterplot(x="total_bill", y="tip", data=tips) Group by another variable and show the groups with different colors: .. plot:: :context: close-figs >>> ax = sns.scatterplot(x="total_bill", y="tip", hue="time", ... data=tips) Show the grouping variable by varying both color and marker: .. plot:: :context: close-figs >>> ax = sns.scatterplot(x="total_bill", y="tip", ... hue="time", style="time", data=tips) Vary colors and markers to show two different grouping variables: .. plot:: :context: close-figs >>> ax = sns.scatterplot(x="total_bill", y="tip", ... hue="day", style="time", data=tips) Show a quantitative variable by varying the size of the points: .. plot:: :context: close-figs >>> ax = sns.scatterplot(x="total_bill", y="tip", size="size", ... data=tips) Also show the quantitative variable by also using continuous colors: .. plot:: :context: close-figs >>> ax = sns.scatterplot(x="total_bill", y="tip", ... hue="size", size="size", ... data=tips) Use a different continuous color map: .. plot:: :context: close-figs >>> cmap = sns.cubehelix_palette(dark=.3, light=.8, as_cmap=True) >>> ax = sns.scatterplot(x="total_bill", y="tip", ... hue="size", size="size", ... palette=cmap, ... data=tips) Change the minimum and maximum point size and show all sizes in legend: .. plot:: :context: close-figs >>> cmap = sns.cubehelix_palette(dark=.3, light=.8, as_cmap=True) >>> ax = sns.scatterplot(x="total_bill", y="tip", ... hue="size", size="size", ... sizes=(20, 200), palette=cmap, ... legend="full", data=tips) Use a narrower range of color map intensities: .. plot:: :context: close-figs >>> cmap = sns.cubehelix_palette(dark=.3, light=.8, as_cmap=True) >>> ax = sns.scatterplot(x="total_bill", y="tip", ... hue="size", size="size", ... sizes=(20, 200), hue_norm=(0, 7), ... legend="full", data=tips) Vary the size with a categorical variable, and use a different palette: .. plot:: :context: close-figs >>> cmap = sns.cubehelix_palette(dark=.3, light=.8, as_cmap=True) >>> ax = sns.scatterplot(x="total_bill", y="tip", ... hue="day", size="smoker", ... palette="Set2", ... data=tips) Use a specific set of markers: .. plot:: :context: close-figs >>> markers = {{"Lunch": "s", "Dinner": "X"}} >>> ax = sns.scatterplot(x="total_bill", y="tip", style="time", ... markers=markers, ... data=tips) Control plot attributes using matplotlib parameters: .. plot:: :context: close-figs >>> ax = sns.scatterplot(x="total_bill", y="tip", ... s=100, color=".2", marker="+", ... data=tips) Pass data vectors instead of names in a data frame: .. plot:: :context: close-figs >>> iris = sns.load_dataset("iris") >>> ax = sns.scatterplot(x=iris.sepal_length, y=iris.sepal_width, ... hue=iris.species, style=iris.species) Pass a wide-form dataset and plot against its index: .. plot:: :context: close-figs >>> import numpy as np, pandas as pd; plt.close("all") >>> index = pd.date_range("1 1 2000", periods=100, ... freq="m", name="date") >>> data = np.random.randn(100, 4).cumsum(axis=0) >>> wide_df = pd.DataFrame(data, index, ["a", "b", "c", "d"]) >>> ax = sns.scatterplot(data=wide_df) R=ic !K s"|dkr3t}t}|dkr*tn|}nN|dkrft}t}|dkr]tn|}ndj|}t||d|d|d|d|d|d |d | d | d | d |d|d|d|d|d|d|}|jr|jnd} t |j r|j nd} |j dk r8|j nd} |j rP|j nd}t |j rn|j nd}|jdk r|jnd}|jr|jnd}|jr|jnd}t |jr|jnd}td | d | d |j d |d|d|jd|d|d|dt }|j||dkrT|jdn|dkrfin|}td |d|d|d|d| d| d|d|dt| }|j|||d|d|d|||r|j|jjd|jr|jd|jd|jqn|S(NR=R3sPlot kind {} not recognizedRR#R!R)R$RNR\RRyRRRRRRRtrowtcoltcol_wrapt row_ordert col_ordertheighttaspectRpiRt label_order(R<RR,RiRRRCR4R\RERRyRRRRRRR=tFalseRR Rt map_dataframeRtaxestflatRt add_legendR( RR#R!R)R$RNRSRTRURVRWR\RRyRRRRRRRtkindRXRYt facet_kwsRttplotterRRORtplot_kwstg((s1lib/python2.7/site-packages/seaborn/relational.pyR s`   $       s Figure-level interface for drawing relational plots onto a FacetGrid. This function provides access to several different axes-level functions that show the relationship between two variables with semantic mappings of subsets. The ``kind`` parameter selects the underlying axes-level function to use: - :func:`scatterplot` (with ``kind="scatter"``; the default) - :func:`lineplot` (with ``kind="line"``) Extra keyword arguments are passed to the underlying function, so you should refer to the documentation for each to see kind-specific options. {main_api_narrative} After plotting, the :class:`FacetGrid` with the plot is returned and can be used directly to tweak supporting plot details or add other layers. Note that, unlike when using the underlying plotting functions directly, data must be passed in a long-form DataFrame with variables specified by passing strings to ``x``, ``y``, and other parameters. Parameters ---------- x, y : names of variables in ``data`` Input data variables; must be numeric. hue : name in ``data``, optional Grouping variable that will produce elements with different colors. Can be either categorical or numeric, although color mapping will behave differently in latter case. size : name in ``data``, optional Grouping variable that will produce elements with different sizes. Can be either categorical or numeric, although size mapping will behave differently in latter case. style : name in ``data``, optional Grouping variable that will produce elements with different styles. Can have a numeric dtype but will always be treated as categorical. {data} row, col : names of variables in ``data``, optional Categorical variables that will determine the faceting of the grid. {col_wrap} row_order, col_order : lists of strings, optional Order to organize the rows and/or columns of the grid in, otherwise the orders are inferred from the data objects. {palette} {hue_order} {hue_norm} {sizes} {size_order} {size_norm} {legend} kind : string, optional Kind of plot to draw, corresponding to a seaborn relational plot. Options are {{``scatter`` and ``line``}}. {height} {aspect} facet_kws : dict, optional Dictionary of other keyword arguments to pass to :class:`FacetGrid`. kwargs : key, value pairings Other keyword arguments are passed through to the underlying plotting function. Returns ------- g : :class:`FacetGrid` Returns the :class:`FacetGrid` object with the plot on it for further tweaking. Examples -------- Draw a single facet to use the :class:`FacetGrid` legend placement: .. plot:: :context: close-figs >>> import seaborn as sns >>> sns.set(style="ticks") >>> tips = sns.load_dataset("tips") >>> g = sns.relplot(x="total_bill", y="tip", hue="day", data=tips) Facet on the columns with another variable: .. plot:: :context: close-figs >>> g = sns.relplot(x="total_bill", y="tip", ... hue="day", col="time", data=tips) Facet on the columns and rows: .. plot:: :context: close-figs >>> g = sns.relplot(x="total_bill", y="tip", hue="day", ... col="time", row="sex", data=tips) "Wrap" many column facets into multiple rows: .. plot:: :context: close-figs >>> g = sns.relplot(x="total_bill", y="tip", hue="time", ... col="day", col_wrap=2, data=tips) Use multiple semantic variables on each facet with specified attributes: .. plot:: :context: close-figs >>> g = sns.relplot(x="total_bill", y="tip", hue="time", size="size", ... palette=["b", "r"], sizes=(10, 100), ... col="time", data=tips) Use a different kind of plot: .. plot:: :context: close-figs >>> fmri = sns.load_dataset("fmri") >>> g = sns.relplot(x="timepoint", y="signal", ... hue="event", style="event", col="region", ... kind="line", data=fmri) Change the size of each facet: .. plot:: :context: close-figs >>> g = sns.relplot(x="timepoint", y="signal", ... hue="event", style="event", col="region", ... height=5, aspect=.7, kind="line", data=fmri) (2t __future__Rt itertoolsRttextwrapRtdistutils.versionRtnumpyR2tpandasR/t matplotlibRetmatplotlib.pyplottpyplotRQt external.sixRRRRRRR R t algorithmsR tpalettesR R RtaxisgridRRt__all__tobjectRRR<R=t_relational_docsRR,RiRRCt__doc__RR(((s1lib/python2.7/site-packages/seaborn/relational.pyts   (sc                                I