W[c:@ sddlmZddlmZddlZddlZddlmZddl Z ddl Z ddl mZddljZddljZddlZddlmZddlmZdd lmZdd lmZmZmZdd lm Z dd l!m"Z"m#Z#m$Z$m%Z%dd l&m'Z'm(Z(dddddddddddg Z)de*fdYZ+de+fdYZ,de+fdYZ-de+fd YZ.d!e.fd"YZ/d#e.fd$YZ0d%e+fd&YZ1d'e1fd(YZ2d)e1fd*YZ3d+e+fd,YZ4e5d-ed.d/ed0d1ed2d3ed4d5ed6d7ed8d9ed:d;ed<d=ed>d?ed@dAedBdCedDdEedFdGedHdIedJdKedLdMedNdOedPdQedRdedSdedTdedUdedVdedWdedXdedYdedZded[Z6e6j7e(e8e8e8e8e8e8e8e8e8d\d]e9d^e8d_e:e8d`Z;edaj<e6e;_=e8e8e8e8e8e8dbdcdde9ded]dfe:e9e8e8e8e8d\e8dgZ>edhj<e6e>_=diZ?e8e8e8e8e8e8e8e8e8d\d]e9dje8dke8e8dlZ@edmj<e6e@_=e8e8e8e8e8e8e9e:e8e8e8d^dndoe8dpZAedqj<e6eA_=e8e8e8e8e8e8e:e8e8e8d^dndoe8drZBedsj<e6eB_=e8e8e8e8e8e8ejCdtdue8e8e8e8d\dve8e8e9e8dwZDedxj<e6eD_=e8e8e8e8e8e8ejCdtdue8dydze:e9de8e8e8e8e8e8d{ZEed|j<e6eE_=e8e8e8e8e8e8e8e8e8d\e9e8d} ZFed~j<e6eF_=dZGe8e8e8e8e8e8e8ejCdtdue8e8e8e8e8dd^de8e8e8e9e9e9e9e:e8dZHedj<e6eH_=dS(i(tdivision(tdedentN(tstats(tPatchCollectioni(t string_types(trange(tutils(tiqrtcategorical_ordert remove_na(t bootstrap(t color_palettet husl_palettet light_palettet dark_palette(t FacetGridt _facet_docstcatplott factorplott stripplott swarmplottboxplott violinplott boxenplottlvplott pointplottbarplott countplott_CategoricalPlotterc B seZdZdZd d d d d d d d dZdZdZd dZe dZ e dZ dZ d Z RS( g?tlightc C sZ|dkr|dkr|dk r9d} t| nd} d} d} d} d}d}t|tjr'|dkrg}xJ|D]?}y%||jtj|j|Wqtk rqXqWn||}|}|j j }|j }g|D]!\}}tj |tj^q}n|dk rHd} t| nt |dr/t|jdkrtj|dr|g}q,t|}qlt|jdkr|j\}}|dks|dkr|jg}q,gt|D]}|dd|f^q}qld} t| n=|dkrGgg}n%tj|drf|g}n|}g|D]}tj |tj^qs}ttt|}t|jd rd nd }n5|dk r'|j||}|j||}|j||}|j||}nxG||||gD]3}t|tr:d j|}t|q:q:W|j|||}|dks|dkr|dkr|n|}tj |g}t |d r|j }nd}d}d}g}d} d} d} d} n|d kr2||}}n ||}}d}t |d r`|j }nt||}|j|||\}}|dkrd} d} d} n*t||} |j|||\} } |dkrd} n|j|||\} }||_||_||_||_||_ | |_!| |_"| |_#| |_$dS( s9Convert input specification into a common representation.s#Cannot use `hue` without `x` or `y`s-Input data must be a pandas object to reordertshapeiiiNs/Input `data` can have no more than 2 dimensionsthtvsCould not interpret input '{}'tname(%tNonet ValueErrort isinstancetpdt DataFrametastypetnptfloattappendtcolumnsR!t iteritemstasarraythasattrtlenRtisscalartlisttravelRtstrt startswithtgetRtformatt infer_orientRt_group_longformtorientt plot_datat group_labelt value_labelt group_namest plot_huest hue_titlet hue_namest plot_units(tselftxtythuetdataR9tordert hue_ordertunitsterrorR>R?R@RAR<R;tcolR:R=t iter_datatktstnrtnctitdtinputterrtvalstgroupst_((s2lib/python2.7/site-packages/seaborn/categorical.pytestablish_variables$s        1  2   ($                     c C st|tjs$tj|}n|j|}g}xZ|D]R}ytj|j|}Wn tk rtjg}nX|j |q@W|j }||fS(s9Group a long-form variable by another with correct order.( R$R%tSeriestgroupbyR(R-t get_grouptKeyErrortarrayR*R!( RBRUtgrouperRGt grouped_valstout_datatgtg_valstlabel((s2lib/python2.7/site-packages/seaborn/categorical.pyR8s   cC s|jd kr!t|j}nt|j}|d kr|d krtj}|t|krxtd|}qkt|dd}n|d kr |jd kr|g|}qk|jdkrt ||}qk|jdkrt ||}qkt dnbt |t r\|jd kr3|j}n |j}g|D]}||^qC}nt||}|dkrt|d|}nt|} g| D]} tj| d^q} t| d } tjj| | | f} | |_| |_d S( s9Get a list of colors for the main component of the plots.tn_colorstlgffffff?RtdarksNo default palette specifieditdesatg333333?N(R@R"R/R:Rtget_color_cycleR R tdefault_paletteR Rt RuntimeErrorR$tdictR=tcolorsyst rgb_to_hlstmintmpltcolorstrgb2hextgray(RBtcolortpalettet saturationRdtcurrent_paletteRptlevelsRet rgb_colorstct light_valstlumRr((s2lib/python2.7/site-packages/seaborn/categorical.pytestablish_colorss<       & cC st|}d}d}d}|jdr7dS|jdrJdS|dkrZdS|dkrjdS||r||rt|qdSn2||r||rt|qdSndSdS(s<Determine how the plot should be oriented based on the data.cS sgy?ytjjj|SWn!tk r=tjjj|SXWn!tk rbt|jdkSXdS(Nt categorical( R%tapittypestis_categorical_dtypetAttributeErrortcoretcommonR3tdtype(RN((s2lib/python2.7/site-packages/seaborn/categorical.pytis_categoricalFs  cS s3ytj|dtjWntk r.tSXtS(NR(R(R-R)R#tTruetFalse(RN((s2lib/python2.7/site-packages/seaborn/categorical.pytis_not_numericQs  s7Neither the `x` nor `y` variable appears to be numeric.R RN(R3R4R"R#(RBRCRDR9RRt no_numeric((s2lib/python2.7/site-packages/seaborn/categorical.pyR7Bs*        cC sgt|j}|jrT|j|}tjd|j||}||j8}ntj|}|S(s>A list of center positions for plots when hue nesting is used.i(R/R@tdodgetwidthR(tlinspacetmeantzeros(RBtn_levelst each_widthtoffsets((s2lib/python2.7/site-packages/seaborn/categorical.pyt hue_offsetsos  cC s3|jr&|jt|jd}n |j}|S(sAA float with the width of plot elements when hue nesting is used.g\(\?(RRR/R@(RBR((s2lib/python2.7/site-packages/seaborn/categorical.pyt nested_width|s  cC s|jdkr%|j|j}}n|j|j}}|d k rT|j|n|d k rp|j|n|jdkr|jtjt |j |j |j n/|j tjt |j |j|j |jdkr%|jjt|jdt |j ddd n3|jjt|jdt |j ddd |jd k r|jdd}|jd k r|j|jytjdd}Wntk rtjd}nXtjjd |}|jjj |qnd S( s)Add descriptive labels to an Axes object.R gg?tautotloctbestsaxes.labelsizeg333333?tsizeN(!R9R;R<R"t set_xlabelt set_ylabelt set_xticksR(tarangeR/R:tset_xticklabelsR=t set_ytickstset_yticklabelstxaxistgridRtset_xlimtyaxistset_ylimR@tlegendR?t set_titleRotrcParamst TypeErrort font_managertFontPropertiest_legend_title_boxt_texttset_font_properties(RBtaxtxlabeltylabeltlegt title_sizetprop((s2lib/python2.7/site-packages/seaborn/categorical.pyt annotate_axess6  &# c C sNtjddgddd|jdd|jd|d|}|j|dS(s3Add a dummy patch object so we can get legend data.it linewidthit edgecolort facecolorRcN(tpltt RectangleRRrt add_patch(RBRRsRctrect((s2lib/python2.7/site-packages/seaborn/categorical.pytadd_legend_datas    N(t__name__t __module__RRiR"RXR8R|R7tpropertyRRRR(((s2lib/python2.7/site-packages/seaborn/categorical.pyRs    ; -  )t _BoxPlottercB s,eZdZdZdZdZRS(cC sv|j||||||||j|| | | |_| |_| |_|dkritjd}n||_dS(Nslines.linewidth( RXR|RRt fliersizeR"RoRR(RBRCRDRERFRGRHR9RsRtRuRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyt__init__s    c C s|jdk}i}x7dddddgD] }|j|di||R"RR RRRRptrestyle_boxplotRR@RR(RBRtkwsRRtobjRQt group_datatbox_datat artist_dictRsRtjt hue_levelthue_masktcenter((s2lib/python2.7/site-packages/seaborn/categorical.pyt draw_boxplotsJ         c C sxQ|dD]E}|jtd|ddd|jd|j|j|dq WxK|dD]?}|jtd |jd|jd d |j|d q_WxE|d D]9}|jtd |jd|j|j|dqWxE|dD]9}|jtd |jd|j|j|dqWxT|dD]H}|jtd|jddd|jd|j|j|dq=WdS(s6Take a drawn matplotlib boxplot and make it look nice.tboxesRtzorderg?RRRtwhiskersRst linestylet-RtcapsRtmediansRtflierstmarkerfacecolortmarkerRRtmarkeredgecolort markersizeRN(tupdateRkRrRR( RBRRsRRtwhiskRtmedtfly((s2lib/python2.7/site-packages/seaborn/categorical.pyRs2        cC s=|j|||j||jdkr9|jndS(sMake the plot.RN(RRR9t invert_yaxis(RBRt boxplot_kws((s2lib/python2.7/site-packages/seaborn/categorical.pytplot#s (RRRRRR(((s2lib/python2.7/site-packages/seaborn/categorical.pyRs  > t_ViolinPlottercB seZdZdZdZdZdZdZdZe dZ dZ d Z d Z ed Zd Zed ZdZdZRS(cC sI|j||||||||j||||j||| | | | |_| |_||_| dk rt| jd| jd| jd| jdgsdj | }t |qn| |_ |r|j dk rt |j dkrd}t |n||_|dkr<tjd}n||_dS( NtquartRtsticktpointsInner style '{}' not recognizedis5There must be exactly two hue levels to use `split`.'slines.linewidth(RXR|testimate_densitiestgridsizeRRR"tanyR4R6R#tinnerR@R/tsplitRoRR(RBRCRDRERFRGRHtbwtcuttscalet scale_hueRRRRRR9RRsRtRuRTtmsg((s2lib/python2.7/site-packages/seaborn/categorical.pyR-s*       *  cC s|jdkrNg}g}tjt|j}tjt|j} ntg|jD] } g^qX}g|jD] } g^qt}t|jt|jf} tj| }tj| } x~t|jD]m\} } |jdkr+t | }|j dkrQ|j tj g|j tj dgd|| R RR*R]tuniquetfit_kdet kde_supporttevaluatetmaxt scale_areat scale_widtht scale_countR#R6tsupporttdensity(RBRRRRRRRtcountst max_densityRWRRQRtkde_datatkdetbw_usedt support_it density_iRRRt support_ijt density_ij((s2lib/python2.7/site-packages/seaborn/categorical.pyRLs               cC sytj||}WnEtk r]tj|}|dkr^d}tj|tq^nX|j}||jdd}||fS(s<Estimate a KDE for a vector of data with flexible bandwidth.tscottsMIgnoring bandwidth choice, please upgrade scipy to use a different bandwidth.tddofi(Rt gaussian_kdeRtwarningstwarnt UserWarningtfactortstd(RBRCRR RR ((s2lib/python2.7/site-packages/seaborn/categorical.pyRs   cC s;|j||}|j||}tj|||S(s(Define a grid of support for the violin.(RnRR(R(RBRCRRRt support_mint support_max((s2lib/python2.7/site-packages/seaborn/categorical.pyRscC s|jdkrEx|D](}|jdkr||j}qqWnoxlt|D]^\}}xO|D]G}|r||j}n |j}|jdkre||}qeqeWqRWdS(sScale the relative area under the KDE curve. This essentially preserves the "standard" KDE scaling, but the resulting maximum density will be 1 so that the curve can be properly multiplied by the violin width. iN(R@R"RRR(RBRRRRRRQtgroupR((s2lib/python2.7/site-packages/seaborn/categorical.pyRs   cC si|jdkr3xS|D]}||j}qWn2x/|D]'}x|D]}||j}qGWq:WdS(s,Scale each density curve to the same height.N(R@R"R(RBRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyRs    c C s%|jdkrq|jdkr*d}q!xt||D]0\}}||j}|||j9}q:Wnxt|D]\}}xt|D]\}}||jdkrd}q|||f}|r|||j} n||j} ||j}|| 9}qWq~WdS(s7Scale each density curve by the number of observations.iN(R@R"RtzipR( RBRRRRRRRQRRtscaler((s2lib/python2.7/site-packages/seaborn/categorical.pyRs   cC sT|jdks|j r$|jdS|jr8|jdS|jdt|jSdS(Ni(R@R"RRRR/(RB((s2lib/python2.7/site-packages/seaborn/categorical.pytdwidths    c C s|jdkr|jn|j}xt|jD]\}}td|jd|j}|jdkr|j ||j |}}|j dkrq1nI|j dkrt j|}t j|} |j|||| q1nt j|j|} ||| ||j| ||jd|j|||jdkrAq1nt|} |jjdr{|j|| |||q|jjdr|j|| |||q|jjd r|j|| |||q|jjd r|j|| |qq1|j} xt|jD]\} }|j || |j || }}|j| |d<|s~|j||j| |n|j dkrqnm|j dkrt j|}t j|} |jr| d } n|| | }|j|||| qn|jrt j|j|} | rF||| | ||j|n||| ||j| ||jdkryqn|j||k}t||} |jjdr|j|| |||d d g| n;|jjd r|j|| |||d d g| n| sqnt|} |jjdrX|j|| |||q|jjd r|j|| |qqt j|j|| | } ||| ||j| ||j||jdkrqn|j||k}t||} |jjdr8|j|| |||| | q|jjdrn|j|| |||| | q|jjd r|j|| |||| | q|jjd r|j|| || | qqWq1WdS(sDraw the violins onto `ax`.R RRiiRRRRRitlefttrightN(R9t fill_betweenxt fill_betweenRR:RkRrRR>R"RRRR(tasscalartdraw_single_observationtonesRRRpRR R4tdraw_box_linestdraw_quartilestdraw_stick_linest draw_pointsRR@RR(RBRt fill_funcRQRRRRtvalRRRt violin_dataRRRtat_groupR((s2lib/python2.7/site-packages/seaborn/categorical.pyt draw_violins's!   #             cC s||j}|jdkrU|j||||g||gd|jd|jn6|j||g||||gd|jd|jdS(s)Draw a line to mark a single observation.R RsRN(RR9RRrR(RBRR+tat_quantRtd_width((s2lib/python2.7/site-packages/seaborn/categorical.pyR"s     c C stj|dddg\}}}dt|} tj|||| k} tj|||| k} |jdkr|j||g| | gd|jd|j|j||g||gd|jdd|j|j ||d ddd d |jd tj |jd n|j| | g||gd|jd|j|j||g||gd|jdd|j|j ||d ddd d |jd tj |jd dS(s2Draw boxplot information at center of the density.ii2iKg?R RRsiRtwhiteRRNiN( R(t percentileRRnRR9RRRrtscattertsquare( RBRRFRRRtq25tq50tq75t whisker_limth1th2((s2lib/python2.7/site-packages/seaborn/categorical.pyR$s6$          c C stj|dddg\}}} |j||||||d|jd|jdgd|j||||||d|jd|jdgd|j||| |||d|jd|jdgdd S( s0Draw the quartiles as lines at width of density.ii2iKRtdashesg?iiN(R(R0tdraw_to_densityR( RBRRFRRRRR3R4R5((s2lib/python2.7/site-packages/seaborn/categorical.pyR% s$   cC stdtj|jdd|jd|j}tjt||}|jdkro|j|||n|j|||dS(s?Draw individual observations as points at middle of the violin.RNiRsRR N( RkR(R2RRrR#R/R9R1(RBRRFRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyR's  c C s>x7|D]/}|j||||||d|jdqWdS(s;Draw individual observations as sticks at width of density.Rg?N(R:R(RBRRFRRRRR)((s2lib/python2.7/site-packages/seaborn/categorical.pyR&$s c K sjtjtj||}|j||d} |j|d<|jdkr|dkr|j|| |g||g|qf|dkr|j||| g||g|qf|j|| || g||g|n|dkr |j||g|| |g|nY|dkr?|j||g||| g|n'|j||g|| || g|dS(s=Draw a line orthogonal to the value axis at width of density.gGz?RsR RRN(R(targmintabsRRrR9R( RBRRR)RRRRtidxR((s2lib/python2.7/site-packages/seaborn/categorical.pyR:+s  & &* & &cC s:|j||j||jdkr6|jndS(sMake the violin plot.RN(R,RR9R(RBR((s2lib/python2.7/site-packages/seaborn/categorical.pyRAs  (RRRRRRRRRRRR,R"R$RR%R'R&R:R(((s2lib/python2.7/site-packages/seaborn/categorical.pyR+s   }      "    t_CategoricalScatterPlottercB s&eZdZedZdZRS(Rfc C sg}xt|jD]\}}tj|jdf}|jdkr`|j|}||(nPxMt|jD]<\}}|j|}|jrp|||j||kR"RpR@R*( RBRpRQRt group_colorst group_colorRtlevelt hue_color((s2lib/python2.7/site-packages/seaborn/categorical.pyt point_colorsMs    c C sj|jdk rfxTt|j|jD]:\}}|jggdtjj|d|ddq%WndS(s9Add empty scatterplot artists with labels for the legend.RsRcRNi<N(R@R"RRpR1RoRq(RBRtrgbRc((s2lib/python2.7/site-packages/seaborn/categorical.pyRhs "(RRRiRRDR(((s2lib/python2.7/site-packages/seaborn/categorical.pyR>Ist _StripPlottercB s)eZdZdZdZdZRS(s.1-d scatterplot with categorical organization.c C s|j||||| |||j| | d||_d|_|dkrYd} n t|} |jdk r|r| t|j} ntj | | dj |_ dS(sInitialize the plotter.ig?g?iN( RXR|RRR)R@R"R/Rtuniformtrvstjitterer( RBRCRDRERFRGRHtjitterRR9RsRttjlim((s2lib/python2.7/site-packages/seaborn/categorical.pyRts     c C sxt|jD]\}}|jdks5|j r&|jdkr_tj|jtj }n8tj g|j|D]}||jk^qstj }||}tj|j|}||j t |7}|j d|j|||jdkr|j|||q|j|||q|j} xt|jD]\} } |j|| k}||}|| | } tj|j| }||j t |7}|j d|j|||jdkr|j|||q?|j|||q?WqWdS(sDraw the points onto `ax`.RyR N(RR:R>R"RR@R(R#RtboolR]RIR/RRDR9R1R( RBRRRQRRRt strip_datatcat_posRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pytdraw_stripplots0 /   cC sJ|j|||j||j||jdkrF|jndS(sMake the plot.RN(RORRR9R(RBRR((s2lib/python2.7/site-packages/seaborn/categorical.pyRs   (RRt__doc__RROR(((s2lib/python2.7/site-packages/seaborn/categorical.pyRFrs  *t _SwarmPlottercB sYeZdZdZdZdZdZdZdZdZ dZ RS( c C sH|j||||||||j| | d||_d|_dS(sInitialize the plotter.ig?N(RXR|RR( RBRCRDRERFRGRHRR9RsRt((s2lib/python2.7/site-packages/seaborn/categorical.pyRs c C so|\}}g}xAt|D]3}|\}}|||krQ|j|qPqWtjtt|S(sReturn a list of all swarm points that could overlap with target. Assumes that swarm is a sorted list of all points below xy_i. (treversedR*R(R]R1( RBtxy_itswarmRRRWty_it neighborstxy_jty_j((s2lib/python2.7/site-packages/seaborn/categorical.pyt could_overlaps  cC s|g}|\}}t}x|D]\}} || } tj|d| dd} || |f|| |f} } |r| | g}n | | g}|j|| }q"Wtj|S(s8Return a list of (x, y) coordinates that might be valid.ig?(RR(tsqrttextendR](RBRSRVRRt candidatestx_iRUt left_firsttx_jRXtdytdxtcltcrtnew_candidates((s2lib/python2.7/site-packages/seaborn/categorical.pytposition_candidatess   !   cC st|dkr|dS|dddf}|dddf}|d}xo|D]g}|\}} ||} || } tj| dtj| d} tj| |k} | rW|SqWWtddS(s?Remove candidates from the list if they overlap with the swarm.iNiig@s<No non-overlapping candidates found. This should not happen.(R/R(tpowertallt Exception(RBR\RVRRt neighbors_xt neighbors_ytd_squareRSR]RURaR`t sq_distancestgood_candidate((s2lib/python2.7/site-packages/seaborn/categorical.pytfirst_non_overlapping_candidates     "c C s|d}|dg}x|dD]}|j|||}|j|||}tj|dddf|}|tj|}|j|||} |j| q"Wtj|S(s.Adjust x position of points to avoid overlaps.iiN(ii(RYReR(R<targsortRnR*R]( RBtorig_xyRRtmidlineRTRSRVR\Rtnew_xy_i((s2lib/python2.7/site-packages/seaborn/categorical.pytbeeswarms  #  c C sl|d}||}||k}|jr9|||R"RRR@R(R#RRLR]RoRDRR1R*RRRRR(RBRRRNtcenterstswarmsRQRRRRt swarm_datatsorterRDRNRtRRRRRT((s2lib/python2.7/site-packages/seaborn/categorical.pytdraw_swarmplotWsV   /        cC sJ|j|||j||j||jdkrF|jndS(sMake the full plot.RN(RRRR9R(RBRR((s2lib/python2.7/site-packages/seaborn/categorical.pyRs   ( RRRRYReRnRsRzRRR(((s2lib/python2.7/site-packages/seaborn/categorical.pyRQs   " ! " Mt_CategoricalStatPlottercB s/eZedZdZdddZRS(cC s/|jr"|jt|j}n |j}|S(sAA float with the width of plot elements when hue nesting is used.(RRR/R@(RBR((s2lib/python2.7/site-packages/seaborn/categorical.pyRs  c C s|jdkrg}g}n8g|jD] }g^q(}g|jD] }g^qD}xt|jD]q\}}|jdkr|jdkrt|} d} nI|j|} tjt j || fj dd} || } | | } | j s |j t jn|j || |dk r| j dkrW|j t jt jgqfn|dkr|| } t j| } |j | | | | fqt| d|d|d| }|j tj||qqfxt|jD]\}}|j|j sK||j t j|dk r||j t jt jfqqn|j||k}|jdkrt||} d} nQ|j|}tjt j ||fj dd} ||| @} ||| @} | j s||j t jn||j || |dk r| j dkrL||j t jt jgqn|dkr|| } t j| } ||j | | | | fqt| d|d|d| }||j tj||qqWqfWt j||_t j||_dS(Ntaxisiitsdtfunctn_bootRI(R@R"R:RR>RAR R%tnotnullR(RRgRR*tnanRR RtciR]t statistictconfint(RBt estimatorRRRRRWRQRt stat_datat unit_datathavetestimateRtbootsRRRt group_units((s2lib/python2.7/site-packages/seaborn/categorical.pytestimate_statistics|    (                " (c K s|dk r|jd|n|jdtjddxwt|||D]c\}\} } } |jdkr|j||g| | gd| ||dk r|j||d||dg| | gd| ||j||d||dg| | gd| |qqM|j| | g||gd| ||dk rM|j| | g||d||dgd| ||j| | g||d||dgd| |qMqMWdS(NR{slines.linewidthg?R Rsi(R"t setdefaultRoRRR9R( RBRR+RRpterrwidthtcapsizeRtattci_lowtci_highRs((s2lib/python2.7/site-packages/seaborn/categorical.pyt draw_confints!s*  % %  N(RRRRRR"R(((s2lib/python2.7/site-packages/seaborn/categorical.pyRs jt _BarPlottercB s)eZdZdZdZdZRS(s8Show point estimates and confidence intervals with bars.c C sp|j||||| ||| |j| | ||j||| ||_||_||_||_dS(sInitialize the plotter.N(RXR|RRterrcolorRR(RBRCRDRERFRGRHRRRRIR9RsRtRuRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyRAs    c C s|jdkr|jn|j}tjt|j}|jdkr|||j|j d|j dd||j gt|}|j |||j ||j|jnxt|jD]\}}||j|}|||jdd|f|jd|j |ddd|||j jr|j dd|f} |j gt|}|j ||| ||j|jqqWdS(sDraw the bars onto `ax`.R RstalignRNRc(R9tbartbarhR(RR/RR>R"RRpRRRRRRR@RRR( RBRRtbarfunctbarpost errcolorsRRtoffposR((s2lib/python2.7/site-packages/seaborn/categorical.pyt draw_barsQs4!  %   cC s=|j|||j||jdkr9|jndS(sMake the plot.RN(RRR9R(RBRtbar_kws((s2lib/python2.7/site-packages/seaborn/categorical.pyR{s (RRRPRRR(((s2lib/python2.7/site-packages/seaborn/categorical.pyR>s  *t _PointPlottercB s>eZdZdddZedZdZdZRS(Rfc C st|j|||||||| |j||d|j||| |dkr|dkr|dkrtdgt|j|_n|dkr|dk rt}n| tkr|j dk rdt|j } nt | t r | gt|j} n| |_ t | t r:| gt|j} n| |_ | |_||_||_||_||_dS(sInitialize the plotter.iig?N(RXR|RR"R R/RpRRR@R$Rtmarkerst linestylesRtjoinRRR(RBRCRDRERFRGRHRRRRIRRRRRR9RsRtRR((s2lib/python2.7/site-packages/seaborn/categorical.pyRs* $#       cC sY|jr=tjd|jt|j}||j8}ntjt|j}|S(s;Offsets relative to the center position for each hue level.i(RR(RR/R@RR(RBtoffset((s2lib/python2.7/site-packages/seaborn/categorical.pyRs  !cC stjt|j}tjdd|j}|d}tjtj|d}|j dkr|j r|j d}|j d}|jdkr|j|j|d|d|d |q|j||jd|d|d |n|j|||j|j |j|j|jd}g|j D]} tj j| ^q$} |jdkrd|j|} } n||j} } |j| | d |d |d |d | d| n:|j} x.t|jD]\}}|jdd|f}|| |}|d}|j r|j |}|j |}|jdkrX|j||d|d|d|d |q|j||d|d|d|d |n|jjr|jdd|f}|j |gt|}|j|||||j|jd|ntt|}|j|}tj j|j |}|rMgt|D] }|^q8}n|}|jdkrr||} } n ||} } tt|sgg} } n|j| | d|d |d|d |d |d |d|qWdS(s*Draw the main data components of the plot.slines.linewidthg?g?iiRRstlsR{RRRNRyRNiRRc(R(RR/RRoRRtpiR2R>R"RRpRR9RRRRRRRqR1RRR@RR R(RBRtpointposR{tmewRRsRRRyt hex_colorsRCRDRRRRRtzRRtn_pointst hex_colorRWRD((s2lib/python2.7/site-packages/seaborn/categorical.pyR'sr     (        "  cC s:|j||j||jdkr6|jndS(sMake the plot.RN(R'RR9R(RBR((s2lib/python2.7/site-packages/seaborn/categorical.pyRs  N( RRRiR"RRRR'R(((s2lib/python2.7/site-packages/seaborn/categorical.pyRs $ Xt _LVPlottercB skeZdZdddZdZdZdddged dddd d Zd Z d Z RS(cC s| dkrd} n| |_| |_| dkr<d} n| |_| dkrZd} n| |_|dkrtjd}n||_|dkrd}n||_||_ |j ||||||||j || | dS(Ng?g?t proportionslines.linewidtht exponential( R"RRRutk_depthRoRRRt outlier_propRXR|(RBRCRDRERFRGRHR9RsRtRuRRRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyRs&                RcC stj|}|tj|}t|}|s=d}n-|dksU|dkrdtdn|}itj|ttj||dd6tj|dd6tj|tjd tjj d|d dd 6}||}yt|}Wntk rd}nX|dkr1d}ngt |d d D]}d dd |d ^qD} gt |d d D]}d d |d ^qy} gt | | D]\}} || f^q} g| D]} tj || ^q}||fS(sQGet the number of data points and calculate `depth` of letter-value plot.gy&1|?g?gs!outlier_prop not in range [0, 1]!iRittukeyit trustworthyiidg?( R(R-tisfiniteR/R#tlog2tintRtnormtppfRRR0(RBRURRtntptk_dictRMRQtuppertlowerRtpercentile_endstqtbox_ends((s2lib/python2.7/site-packages/seaborn/categorical.pyt _lv_box_ends;s0  . 0     51.%cC sdd|dddd|df}tj||}|tj||dkd}|tj||dkd}tj||fS(s2Find the outliers based on the letter value depth.idg?iii(R(R0twheret concatenate(RBRURMt perc_endstedgest lower_outt upper_out((s2lib/python2.7/site-packages/seaborn/categorical.pyt _lv_outliers`s (!!cC s,idd6dd6dd6}||S(NcS s |d|S(Ng?((RRQRM((s2lib/python2.7/site-packages/seaborn/categorical.pytjstlinearcS sd| |dS(Nii((RRQRM((s2lib/python2.7/site-packages/seaborn/categorical.pyRksRcS sdd| |d|S(Nii((RRQRM((s2lib/python2.7/site-packages/seaborn/categorical.pyRlsR((RBt width_functwidth_functions((s2lib/python2.7/site-packages/seaborn/categorical.pyt_width_functionshs   go@gp@g g@giRc  s|d} tj|}t|dkr| ji|jd6dd6|d|dg} | d| dg} |r| | }}n | | }}|j||| n|j|d|d|\}}|j| }d fd }fd }tjgt |D]$\}}||||^q"}|tj |}tj |}|j ||}|rLgt t ||D],\}}|| |d|||d^q}|j| d| dg||gd d dd| |jtj| t||ddd tjj|| ngt t ||D],\}}|| |d|||d^qb}|j||g| d| dgd d dd| |j|tj| t|ddd || dddgt|g}tjjjd|}t|d|}|jtjtjddt||j|dS(NiiRsRRiRRcS s|d|dS(Nii((tb((s2lib/python2.7/site-packages/seaborn/categorical.pytheightsc s?tj||d|df||dt}|S(Niitfill(tPatchesRR(RCRRQRMtwR(RR(s2lib/python2.7/site-packages/seaborn/categorical.pyt vert_perc_boxsc s?tj|d||df||dt}|S(NiiR(RRR(RCRRQRMRR(RR(s2lib/python2.7/site-packages/seaborn/categorical.pyt horz_perc_boxs Rys.15talphag?RRRtnew_maptcmap(R(R-R/RRrRRRR]RRRRRR1trepeatRoRpRqR1tLinearSegmentedColormapt from_listRt set_arrayRtadd_collection(RBRRRsRRRRRRRRCtystxstxxtyyRRMRRRRQRtw_areaRDtoutliersRRERt collection((RRs2lib/python2.7/site-packages/seaborn/categorical.pyt_lvplotosN    7E+!E+!+c C s|jdk}xt|jD]\}}|jd kr|jdkrOqnt|}|jdkrpqn|j|}|j|d|gd|d|d|j d|j d|d |j d |j |q|j }xt|jD]\} } |s|j||j| | n|jdkr,qn|j|| k} t|| }|jdkrdqn|j| }||| } |j|d| gd|d|d|jd|j d|d |j d |j |qWqWd S( s6Use matplotlib to draw a letter value plot on an Axes.R iRRsRRRRRRN(R9RR:R>R"RR RpRRRRRRR@RR( RBRRRRQRRRsRRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pytdraw_letter_value_plotsR               cC s=|j|||j||jdkr9|jndS(sMake the plot.RN(RRR9R(RBRR((s2lib/python2.7/site-packages/seaborn/categorical.pyR s Ng?g ?( RRRR"RRRRRRR(((s2lib/python2.7/site-packages/seaborn/categorical.pyRs %    V Btcategorical_narratives This function always treats one of the variables as categorical and draws data at ordinal positions (0, 1, ... n) on the relevant axis, even when the data has a numeric or date type. See the :ref:`tutorial ` for more information. tmain_api_narratives Input data can be passed in a variety of formats, including: - Vectors of data represented as lists, numpy arrays, or pandas Series objects passed directly to the ``x``, ``y``, and/or ``hue`` parameters. - A "long-form" DataFrame, in which case the ``x``, ``y``, and ``hue`` variables will determine how the data are plotted. - A "wide-form" DataFrame, such that each numeric column will be plotted. - An array or list of vectors. In most cases, it is possible to use numpy or Python objects, but pandas objects are preferable because the associated names will be used to annotate the axes. Additionally, you can use Categorical types for the grouping variables to control the order of plot elements. t input_paramss x, y, hue : names of variables in ``data`` or vector data, optional Inputs for plotting long-form data. See examples for interpretation. tstring_input_paramss x, y, hue : names of variables in ``data`` Inputs for plotting long-form data. See examples for interpretation. tcategorical_datas data : DataFrame, array, or list of arrays, optional Dataset for plotting. If ``x`` and ``y`` are absent, this is interpreted as wide-form. Otherwise it is expected to be long-form. tlong_form_datas data : DataFrame Long-form (tidy) dataset for plotting. Each column should correspond to a variable, and each row should correspond to an observation. t order_varss order, hue_order : lists of strings, optional Order to plot the categorical levels in, otherwise the levels are inferred from the data objects. tstat_api_paramss estimator : callable that maps vector -> scalar, optional Statistical function to estimate within each categorical bin. ci : float or "sd" or None, optional Size of confidence intervals to draw around estimated values. If "sd", skip bootstrapping and draw the standard deviation of the observations. If ``None``, no bootstrapping will be performed, and error bars will not be drawn. n_boot : int, optional Number of bootstrap iterations to use when computing confidence intervals. units : name of variable in ``data`` or vector data, optional Identifier of sampling units, which will be used to perform a multilevel bootstrap and account for repeated measures design. R9s orient : "v" | "h", optional Orientation of the plot (vertical or horizontal). This is usually inferred from the dtype of the input variables, but can be used to specify when the "categorical" variable is a numeric or when plotting wide-form data. Rssq color : matplotlib color, optional Color for all of the elements, or seed for a gradient palette. Rts palette : palette name, list, or dict, optional Color palette that maps either the grouping variable or the hue variable. If the palette is a dictionary, keys should be names of levels and values should be matplotlib colors. Rus saturation : float, optional Proportion of the original saturation to draw colors at. Large patches often look better with slightly desaturated colors, but set this to ``1`` if you want the plot colors to perfectly match the input color spec. Rs\ capsize : float, optional Width of the "caps" on error bars. Rsb errwidth : float, optional Thickness of error bar lines (and caps). Rs width : float, optional Width of a full element when not using hue nesting, or width of all the elements for one level of the major grouping variable. Rs dodge : bool, optional When hue nesting is used, whether elements should be shifted along the categorical axis. Rsa linewidth : float, optional Width of the gray lines that frame the plot elements. 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. sH boxplot : A traditional box-and-whisker plot with a similar API. sL violinplot : A combination of boxplot and kernel density estimation. s stripplot : A scatterplot where one variable is categorical. Can be used in conjunction with other plots to show each observation. s swarmplot : A categorical scatterplot where the points do not overlap. Can be used with other plots to show each observation. sK barplot : Show point estimates and confidence intervals using bars. sL countplot : Show the counts of observations in each categorical bin. sk pointplot : Show point estimates and confidence intervals using scatterplot glyphs. sF catplot : Combine a categorical plot with a class:`FacetGrid`. s< boxenplot : An enhanced boxplot for larger datasets. g?g?ig?cK s~t|||||||||| | | | | }|dkrNtj}n|jtd|d||j|||S(Ntwhistnotch(RR"RtgcaRRkR(RCRDRERFRGRHR9RsRtRuRRRRRRRtkwargstplotter((s2lib/python2.7/site-packages/seaborn/categorical.pyRs  s Draw a box plot to show distributions with respect to categories. A box plot (or box-and-whisker plot) shows the distribution of quantitative data in a way that facilitates comparisons between variables or across levels of a categorical variable. The box shows the quartiles of the dataset while the whiskers extend to show the rest of the distribution, except for points that are determined to be "outliers" using a method that is a function of the inter-quartile range. {main_api_narrative} {categorical_narrative} Parameters ---------- {input_params} {categorical_data} {order_vars} {orient} {color} {palette} {saturation} {width} {dodge} fliersize : float, optional Size of the markers used to indicate outlier observations. {linewidth} whis : float, optional Proportion of the IQR past the low and high quartiles to extend the plot whiskers. Points outside this range will be identified as outliers. notch : boolean, optional Whether to "notch" the box to indicate a confidence interval for the median. There are several other parameters that can control how the notches are drawn; see the ``plt.boxplot`` help for more information on them. {ax_in} kwargs : key, value mappings Other keyword arguments are passed through to ``plt.boxplot`` at draw time. Returns ------- {ax_out} See Also -------- {violinplot} {stripplot} {swarmplot} Examples -------- Draw a single horizontal boxplot: .. plot:: :context: close-figs >>> import seaborn as sns >>> sns.set(style="whitegrid") >>> tips = sns.load_dataset("tips") >>> ax = sns.boxplot(x=tips["total_bill"]) Draw a vertical boxplot grouped by a categorical variable: .. plot:: :context: close-figs >>> ax = sns.boxplot(x="day", y="total_bill", data=tips) Draw a boxplot with nested grouping by two categorical variables: .. plot:: :context: close-figs >>> ax = sns.boxplot(x="day", y="total_bill", hue="smoker", ... data=tips, palette="Set3") Draw a boxplot with nested grouping when some bins are empty: .. plot:: :context: close-figs >>> ax = sns.boxplot(x="day", y="total_bill", hue="time", ... data=tips, linewidth=2.5) Control box order by passing an explicit order: .. plot:: :context: close-figs >>> ax = sns.boxplot(x="time", y="tip", data=tips, ... order=["Dinner", "Lunch"]) Draw a boxplot for each numeric variable in a DataFrame: .. plot:: :context: close-figs >>> iris = sns.load_dataset("iris") >>> ax = sns.boxplot(data=iris, orient="h", palette="Set2") Use ``hue`` without changing box position or width: .. plot:: :context: close-figs >>> tips["weekend"] = tips["day"].isin(["Sat", "Sun"]) >>> ax = sns.boxplot(x="day", y="total_bill", hue="weekend", ... data=tips, dodge=False) Use :func:`swarmplot` to show the datapoints on top of the boxes: .. plot:: :context: close-figs >>> ax = sns.boxplot(x="day", y="total_bill", data=tips) >>> ax = sns.swarmplot(x="day", y="total_bill", data=tips, color=".25") Use :func:`catplot` to combine a :func:`pointplot` and a :class:`FacetGrid`. This allows grouping within additional categorical variables. Using :func:`catplot` is safer than using :class:`FacetGrid` directly, as it ensures synchronization of variable order across facets: .. plot:: :context: close-figs >>> g = sns.catplot(x="sex", y="total_bill", ... hue="smoker", col="time", ... data=tips, kind="box", ... height=4, aspect=.7); RiRidRcK sqt|||||||||| | | | | ||||||}|dkr`tj}n|j||S(N(RR"RRR(RCRDRERFRGRHRRRRRRRRRR9RRsRtRuRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyRJ s  s Draw a combination of boxplot and kernel density estimate. A violin plot plays a similar role as a box and whisker plot. It shows the distribution of quantitative data across several levels of one (or more) categorical variables such that those distributions can be compared. Unlike a box plot, in which all of the plot components correspond to actual datapoints, the violin plot features a kernel density estimation of the underlying distribution. This can be an effective and attractive way to show multiple distributions of data at once, but keep in mind that the estimation procedure is influenced by the sample size, and violins for relatively small samples might look misleadingly smooth. {main_api_narrative} {categorical_narrative} Parameters ---------- {input_params} {categorical_data} {order_vars} bw : {{'scott', 'silverman', float}}, optional Either the name of a reference rule or the scale factor to use when computing the kernel bandwidth. The actual kernel size will be determined by multiplying the scale factor by the standard deviation of the data within each bin. cut : float, optional Distance, in units of bandwidth size, to extend the density past the extreme datapoints. Set to 0 to limit the violin range within the range of the observed data (i.e., to have the same effect as ``trim=True`` in ``ggplot``. scale : {{"area", "count", "width"}}, optional The method used to scale the width of each violin. If ``area``, each violin will have the same area. If ``count``, the width of the violins will be scaled by the number of observations in that bin. If ``width``, each violin will have the same width. scale_hue : bool, optional When nesting violins using a ``hue`` variable, this parameter determines whether the scaling is computed within each level of the major grouping variable (``scale_hue=True``) or across all the violins on the plot (``scale_hue=False``). gridsize : int, optional Number of points in the discrete grid used to compute the kernel density estimate. {width} inner : {{"box", "quartile", "point", "stick", None}}, optional Representation of the datapoints in the violin interior. If ``box``, draw a miniature boxplot. If ``quartiles``, draw the quartiles of the distribution. If ``point`` or ``stick``, show each underlying datapoint. Using ``None`` will draw unadorned violins. split : bool, optional When using hue nesting with a variable that takes two levels, setting ``split`` to True will draw half of a violin for each level. This can make it easier to directly compare the distributions. {dodge} {orient} {linewidth} {color} {palette} {saturation} {ax_in} Returns ------- {ax_out} See Also -------- {boxplot} {stripplot} {swarmplot} Examples -------- Draw a single horizontal violinplot: .. plot:: :context: close-figs >>> import seaborn as sns >>> sns.set(style="whitegrid") >>> tips = sns.load_dataset("tips") >>> ax = sns.violinplot(x=tips["total_bill"]) Draw a vertical violinplot grouped by a categorical variable: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="day", y="total_bill", data=tips) Draw a violinplot with nested grouping by two categorical variables: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="day", y="total_bill", hue="smoker", ... data=tips, palette="muted") Draw split violins to compare the across the hue variable: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="day", y="total_bill", hue="smoker", ... data=tips, palette="muted", split=True) Control violin order by passing an explicit order: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="time", y="tip", data=tips, ... order=["Dinner", "Lunch"]) Scale the violin width by the number of observations in each bin: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="day", y="total_bill", hue="sex", ... data=tips, palette="Set2", split=True, ... scale="count") Draw the quartiles as horizontal lines instead of a mini-box: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="day", y="total_bill", hue="sex", ... data=tips, palette="Set2", split=True, ... scale="count", inner="quartile") Show each observation with a stick inside the violin: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="day", y="total_bill", hue="sex", ... data=tips, palette="Set2", split=True, ... scale="count", inner="stick") Scale the density relative to the counts across all bins: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="day", y="total_bill", hue="sex", ... data=tips, palette="Set2", split=True, ... scale="count", inner="stick", scale_hue=False) Use a narrow bandwidth to reduce the amount of smoothing: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="day", y="total_bill", hue="sex", ... data=tips, palette="Set2", split=True, ... scale="count", inner="stick", ... scale_hue=False, bw=.2) Draw horizontal violins: .. plot:: :context: close-figs >>> planets = sns.load_dataset("planets") >>> ax = sns.violinplot(x="orbital_period", y="method", ... data=planets[planets.orbital_period < 1000], ... scale="width", palette="Set3") Don't let density extend past extreme values in the data: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="orbital_period", y="method", ... data=planets[planets.orbital_period < 1000], ... cut=0, scale="width", palette="Set3") Use ``hue`` without changing violin position or width: .. plot:: :context: close-figs >>> tips["weekend"] = tips["day"].isin(["Sat", "Sun"]) >>> ax = sns.violinplot(x="day", y="total_bill", hue="weekend", ... data=tips, dodge=False) Use :func:`catplot` to combine a :func:`violinplot` and a :class:`FacetGrid`. This allows grouping within additional categorical variables. Using :func:`catplot` is safer than using :class:`FacetGrid` directly, as it ensures synchronization of variable order across facets: .. plot:: :context: close-figs >>> g = sns.catplot(x="sex", y="total_bill", ... hue="smoker", col="time", ... data=tips, kind="violin", split=True, ... height=4, aspect=.7); cO s d}tj|t||S(s#Deprecated; please use `boxenplot`.sThe `lvplot` function has been renamed to `boxenplot`. The original name will be removed in a future release. Please update your code. (RRR(targsRR((s2lib/python2.7/site-packages/seaborn/categorical.pyR- s RRcK sht|||||||||| | | | | ||}|dkrTtj}n|j|||S(N(RR"RRR(RCRDRERFRGRHR9RsRtRuRRRRRRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyR9 s   s Draw an enhanced box plot for larger datasets. This style of plot was originally named a "letter value" plot because it shows a large number of quantiles that are defined as "letter values". It is similar to a box plot in plotting a nonparametric representation of a distribution in which all features correspond to actual observations. By plotting more quantiles, it provides more information about the shape of the distribution, particularly in the tails. For a more extensive explanation, you can read the paper that introduced the plot: https://vita.had.co.nz/papers/letter-value-plot.html {main_api_narrative} {categorical_narrative} Parameters ---------- {input_params} {categorical_data} {order_vars} {orient} {color} {palette} {saturation} {width} {dodge} k_depth : "proportion" | "tukey" | "trustworthy", optional The number of boxes, and by extension number of percentiles, to draw. All methods are detailed in Wickham's paper. Each makes different assumptions about the number of outliers and leverages different statistical properties. {linewidth} scale : "linear" | "exponential" | "area" Method to use for the width of the letter value boxes. All give similar results visually. "linear" reduces the width by a constant linear factor, "exponential" uses the proportion of data not covered, "area" is proportional to the percentage of data covered. outlier_prop : float, optional Proportion of data believed to be outliers. Used in conjunction with k_depth to determine the number of percentiles to draw. Defaults to 0.007 as a proportion of outliers. Should be in range [0, 1]. {ax_in} kwargs : key, value mappings Other keyword arguments are passed through to ``plt.plot`` and ``plt.scatter`` at draw time. Returns ------- {ax_out} See Also -------- {violinplot} {boxplot} Examples -------- Draw a single horizontal boxen plot: .. plot:: :context: close-figs >>> import seaborn as sns >>> sns.set(style="whitegrid") >>> tips = sns.load_dataset("tips") >>> ax = sns.boxenplot(x=tips["total_bill"]) Draw a vertical boxen plot grouped by a categorical variable: .. plot:: :context: close-figs >>> ax = sns.boxenplot(x="day", y="total_bill", data=tips) Draw a letter value plot with nested grouping by two categorical variables: .. plot:: :context: close-figs >>> ax = sns.boxenplot(x="day", y="total_bill", hue="smoker", ... data=tips, palette="Set3") Draw a boxen plot with nested grouping when some bins are empty: .. plot:: :context: close-figs >>> ax = sns.boxenplot(x="day", y="total_bill", hue="time", ... data=tips, linewidth=2.5) Control box order by passing an explicit order: .. plot:: :context: close-figs >>> ax = sns.boxenplot(x="time", y="tip", data=tips, ... order=["Dinner", "Lunch"]) Draw a boxen plot for each numeric variable in a DataFrame: .. plot:: :context: close-figs >>> iris = sns.load_dataset("iris") >>> ax = sns.boxenplot(data=iris, orient="h", palette="Set2") Use :func:`stripplot` to show the datapoints on top of the boxes: .. plot:: :context: close-figs >>> ax = sns.boxenplot(x="day", y="total_bill", data=tips) >>> ax = sns.stripplot(x="day", y="total_bill", data=tips, ... size=4, jitter=True, color="gray") Use :func:`catplot` to combine :func:`boxenplot` and a :class:`FacetGrid`. This allows grouping within additional categorical variables. Using :func:`catplot` is safer than using :class:`FacetGrid` directly, as it ensures synchronization of variable order across facets: .. plot:: :context: close-figs >>> g = sns.catplot(x="sex", y="total_bill", ... hue="smoker", col="time", ... data=tips, kind="boxen", ... height=4, aspect=.7); Rric K sd|kr4|jd}d}tj|tnt|||||||||| | }|dkrytj}n|jdd|j d| } | dkr| d} n| dkr|j } n|j t d| dd | d | |j |||S( NRs2The `split` parameter has been renamed to `dodge`.RiRNi RriRR(RRRRRFR"RRRR5RrRRkR(RCRDRERFRGRHRJRR9RsRtRRRRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyR s&       sK Draw a scatterplot where one variable is categorical. A strip plot can be drawn on its own, but it is also a good complement to a box or violin plot in cases where you want to show all observations along with some representation of the underlying distribution. {main_api_narrative} {categorical_narrative} Parameters ---------- {input_params} {categorical_data} {order_vars} jitter : float, ``True``/``1`` is special-cased, optional Amount of jitter (only along the categorical axis) to apply. This can be useful when you have many points and they overlap, so that it is easier to see the distribution. You can specify the amount of jitter (half the width of the uniform random variable support), or just use ``True`` for a good default. dodge : bool, optional When using ``hue`` nesting, setting this to ``True`` will separate the strips for different hue levels along the categorical axis. Otherwise, the points for each level will be plotted on top of each other. {orient} {color} {palette} size : float, optional Diameter of the markers, in points. (Although ``plt.scatter`` is used to draw the points, the ``size`` argument here takes a "normal" markersize and not size^2 like ``plt.scatter``. edgecolor : matplotlib color, "gray" is special-cased, optional Color of the lines around each point. If you pass ``"gray"``, the brightness is determined by the color palette used for the body of the points. {linewidth} {ax_in} Returns ------- {ax_out} See Also -------- {swarmplot} {boxplot} {violinplot} Examples -------- Draw a single horizontal strip plot: .. plot:: :context: close-figs >>> import seaborn as sns >>> sns.set(style="whitegrid") >>> tips = sns.load_dataset("tips") >>> ax = sns.stripplot(x=tips["total_bill"]) Group the strips by a categorical variable: .. plot:: :context: close-figs >>> ax = sns.stripplot(x="day", y="total_bill", data=tips) Add jitter to bring out the distribution of values: .. plot:: :context: close-figs >>> ax = sns.stripplot(x="day", y="total_bill", data=tips, jitter=True) Use a smaller amount of jitter: .. plot:: :context: close-figs >>> ax = sns.stripplot(x="day", y="total_bill", data=tips, jitter=0.05) Draw horizontal strips: .. plot:: :context: close-figs >>> ax = sns.stripplot(x="total_bill", y="day", data=tips, ... jitter=True) Draw outlines around the points: .. plot:: :context: close-figs >>> ax = sns.stripplot(x="total_bill", y="day", data=tips, ... jitter=True, linewidth=1) Nest the strips within a second categorical variable: .. plot:: :context: close-figs >>> ax = sns.stripplot(x="sex", y="total_bill", hue="day", ... data=tips, jitter=True) Draw each level of the ``hue`` variable at different locations on the major categorical axis: .. plot:: :context: close-figs >>> ax = sns.stripplot(x="day", y="total_bill", hue="smoker", ... data=tips, jitter=True, ... palette="Set2", dodge=True) Control strip order by passing an explicit order: .. plot:: :context: close-figs >>> ax = sns.stripplot(x="time", y="tip", data=tips, ... order=["Dinner", "Lunch"]) Draw strips with large points and different aesthetics: .. plot:: :context: close-figs >>> ax = sns.stripplot("day", "total_bill", "smoker", data=tips, ... palette="Set2", size=20, marker="D", ... edgecolor="gray", alpha=.25) Draw strips of observations on top of a box plot: .. plot:: :context: close-figs >>> ax = sns.boxplot(x="tip", y="day", data=tips, whis=np.inf) >>> ax = sns.stripplot(x="tip", y="day", data=tips, ... jitter=True, color=".3") Draw strips of observations on top of a violin plot: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="day", y="total_bill", data=tips, ... inner=None, color=".8") >>> ax = sns.stripplot(x="day", y="total_bill", data=tips, jitter=True) Use :func:`catplot` to combine a :func:`stripplot` and a :class:`FacetGrid`. This allows grouping within additional categorical variables. Using :func:`catplot` is safer than using :class:`FacetGrid` directly, as it ensures synchronization of variable order across facets: .. plot:: :context: close-figs >>> g = sns.catplot(x="sex", y="total_bill", ... hue="smoker", col="time", ... data=tips, kind="strip", ... jitter=True, ... height=4, aspect=.7); c K sd|kr4|jd}d}tj|tnt|||||||||| }| dkrvtj} n|jdd|j d| } | dkr| d} n| dkr|j } n|j t d| dd | d | |j | || S( NRs2The `split` parameter has been renamed to `dodge`.RiRNi RriRR(RRRRRQR"RRRR5RrRRkR(RCRDRERFRGRHRR9RsRtRRRRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyR s&       s Draw a categorical scatterplot with non-overlapping points. This function is similar to :func:`stripplot`, but the points are adjusted (only along the categorical axis) so that they don't overlap. This gives a better representation of the distribution of values, but it does not scale well to large numbers of observations. This style of plot is sometimes called a "beeswarm". A swarm plot can be drawn on its own, but it is also a good complement to a box or violin plot in cases where you want to show all observations along with some representation of the underlying distribution. Arranging the points properly requires an accurate transformation between data and point coordinates. This means that non-default axis limits must be set *before* drawing the plot. {main_api_narrative} {categorical_narrative} Parameters ---------- {input_params} {categorical_data} {order_vars} dodge : bool, optional When using ``hue`` nesting, setting this to ``True`` will separate the strips for different hue levels along the categorical axis. Otherwise, the points for each level will be plotted in one swarm. {orient} {color} {palette} size : float, optional Diameter of the markers, in points. (Although ``plt.scatter`` is used to draw the points, the ``size`` argument here takes a "normal" markersize and not size^2 like ``plt.scatter``. edgecolor : matplotlib color, "gray" is special-cased, optional Color of the lines around each point. If you pass ``"gray"``, the brightness is determined by the color palette used for the body of the points. {linewidth} {ax_in} Returns ------- {ax_out} See Also -------- {boxplot} {violinplot} {stripplot} {catplot} Examples -------- Draw a single horizontal swarm plot: .. plot:: :context: close-figs >>> import seaborn as sns >>> sns.set(style="whitegrid") >>> tips = sns.load_dataset("tips") >>> ax = sns.swarmplot(x=tips["total_bill"]) Group the swarms by a categorical variable: .. plot:: :context: close-figs >>> ax = sns.swarmplot(x="day", y="total_bill", data=tips) Draw horizontal swarms: .. plot:: :context: close-figs >>> ax = sns.swarmplot(x="total_bill", y="day", data=tips) Color the points using a second categorical variable: .. plot:: :context: close-figs >>> ax = sns.swarmplot(x="day", y="total_bill", hue="sex", data=tips) Split each level of the ``hue`` variable along the categorical axis: .. plot:: :context: close-figs >>> ax = sns.swarmplot(x="day", y="total_bill", hue="smoker", ... data=tips, palette="Set2", dodge=True) Control swarm order by passing an explicit order: .. plot:: :context: close-figs >>> ax = sns.swarmplot(x="time", y="tip", data=tips, ... order=["Dinner", "Lunch"]) Plot using larger points: .. plot:: :context: close-figs >>> ax = sns.swarmplot(x="time", y="tip", data=tips, size=6) Draw swarms of observations on top of a box plot: .. plot:: :context: close-figs >>> ax = sns.boxplot(x="tip", y="day", data=tips, whis=np.inf) >>> ax = sns.swarmplot(x="tip", y="day", data=tips, color=".2") Draw swarms of observations on top of a violin plot: .. plot:: :context: close-figs >>> ax = sns.violinplot(x="day", y="total_bill", data=tips, inner=None) >>> ax = sns.swarmplot(x="day", y="total_bill", data=tips, ... color="white", edgecolor="gray") Use :func:`catplot` to combine a :func:`swarmplot` and a :class:`FacetGrid`. This allows grouping within additional categorical variables. Using :func:`catplot` is safer than using :class:`FacetGrid` directly, as it ensures synchronization of variable order across facets: .. plot:: :context: close-figs >>> g = sns.catplot(x="sex", y="total_bill", ... hue="smoker", col="time", ... data=tips, kind="swarm", ... height=4, aspect=.7); i_is.26cK snt|||||||||| | | | | ||||}|dkrZtj}n|j|||S(N(RR"RRR(RCRDRERFRGRHRRRRIR9RsRtRuRRRRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyRD s   s} Show point estimates and confidence intervals as rectangular bars. A bar plot represents an estimate of central tendency for a numeric variable with the height of each rectangle and provides some indication of the uncertainty around that estimate using error bars. Bar plots include 0 in the quantitative axis range, and they are a good choice when 0 is a meaningful value for the quantitative variable, and you want to make comparisons against it. For datasets where 0 is not a meaningful value, a point plot will allow you to focus on differences between levels of one or more categorical variables. It is also important to keep in mind that a bar plot shows only the mean (or other estimator) value, but in many cases it may be more informative to show the distribution of values at each level of the categorical variables. In that case, other approaches such as a box or violin plot may be more appropriate. {main_api_narrative} {categorical_narrative} Parameters ---------- {input_params} {categorical_data} {order_vars} {stat_api_params} {orient} {color} {palette} {saturation} errcolor : matplotlib color Color for the lines that represent the confidence interval. {errwidth} {capsize} {dodge} {ax_in} kwargs : key, value mappings Other keyword arguments are passed through to ``plt.bar`` at draw time. Returns ------- {ax_out} See Also -------- {countplot} {pointplot} {catplot} Examples -------- Draw a set of vertical bar plots grouped by a categorical variable: .. plot:: :context: close-figs >>> import seaborn as sns >>> sns.set(style="whitegrid") >>> tips = sns.load_dataset("tips") >>> ax = sns.barplot(x="day", y="total_bill", data=tips) Draw a set of vertical bars with nested grouping by a two variables: .. plot:: :context: close-figs >>> ax = sns.barplot(x="day", y="total_bill", hue="sex", data=tips) Draw a set of horizontal bars: .. plot:: :context: close-figs >>> ax = sns.barplot(x="tip", y="day", data=tips) Control bar order by passing an explicit order: .. plot:: :context: close-figs >>> ax = sns.barplot(x="time", y="tip", data=tips, ... order=["Dinner", "Lunch"]) Use median as the estimate of central tendency: .. plot:: :context: close-figs >>> from numpy import median >>> ax = sns.barplot(x="day", y="tip", data=tips, estimator=median) Show the standard error of the mean with the error bars: .. plot:: :context: close-figs >>> ax = sns.barplot(x="day", y="tip", data=tips, ci=68) Show standard deviation of observations instead of a confidence interval: .. plot:: :context: close-figs >>> ax = sns.barplot(x="day", y="tip", data=tips, ci="sd") Add "caps" to the error bars: .. plot:: :context: close-figs >>> ax = sns.barplot(x="day", y="tip", data=tips, capsize=.2) Use a different color palette for the bars: .. plot:: :context: close-figs >>> ax = sns.barplot("size", y="total_bill", data=tips, ... palette="Blues_d") Use ``hue`` without changing bar position or width: .. plot:: :context: close-figs >>> tips["weekend"] = tips["day"].isin(["Sat", "Sun"]) >>> ax = sns.barplot(x="day", y="total_bill", hue="weekend", ... data=tips, dodge=False) Plot all bars in a single color: .. plot:: :context: close-figs >>> ax = sns.barplot("size", y="total_bill", data=tips, ... color="salmon", saturation=.5) Use ``plt.bar`` keyword arguments to further change the aesthetic: .. plot:: :context: close-figs >>> ax = sns.barplot("day", "total_bill", data=tips, ... linewidth=2.5, facecolor=(1, 1, 1, 0), ... errcolor=".2", edgecolor=".2") Use :func:`catplot` to combine a :func:`barplot` and a :class:`FacetGrid`. This allows grouping within additional categorical variables. Using :func:`catplot` is safer than using :class:`FacetGrid` directly, as it ensures synchronization of variable order across facets: .. plot:: :context: close-figs >>> g = sns.catplot(x="sex", y="total_bill", ... hue="smoker", col="time", ... data=tips, kind="bar", ... height=4, aspect=.7); toRcK sqt|||||||||| | | | | ||||||}|dkr`tj}n|j||S(N(RR"RRR(RCRDRERFRGRHRRRRIRRRRRR9RsRtRRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyR s   sy Show point estimates and confidence intervals using scatter plot glyphs. A point plot represents an estimate of central tendency for a numeric variable by the position of scatter plot points and provides some indication of the uncertainty around that estimate using error bars. Point plots can be more useful than bar plots for focusing comparisons between different levels of one or more categorical variables. They are particularly adept at showing interactions: how the relationship between levels of one categorical variable changes across levels of a second categorical variable. The lines that join each point from the same ``hue`` level allow interactions to be judged by differences in slope, which is easier for the eyes than comparing the heights of several groups of points or bars. It is important to keep in mind that a point plot shows only the mean (or other estimator) value, but in many cases it may be more informative to show the distribution of values at each level of the categorical variables. In that case, other approaches such as a box or violin plot may be more appropriate. {main_api_narrative} {categorical_narrative} Parameters ---------- {input_params} {categorical_data} {order_vars} {stat_api_params} markers : string or list of strings, optional Markers to use for each of the ``hue`` levels. linestyles : string or list of strings, optional Line styles to use for each of the ``hue`` levels. dodge : bool or float, optional Amount to separate the points for each level of the ``hue`` variable along the categorical axis. join : bool, optional If ``True``, lines will be drawn between point estimates at the same ``hue`` level. scale : float, optional Scale factor for the plot elements. {orient} {color} {palette} {errwidth} {capsize} {ax_in} Returns ------- {ax_out} See Also -------- {barplot} {catplot} Examples -------- Draw a set of vertical point plots grouped by a categorical variable: .. plot:: :context: close-figs >>> import seaborn as sns >>> sns.set(style="darkgrid") >>> tips = sns.load_dataset("tips") >>> ax = sns.pointplot(x="time", y="total_bill", data=tips) Draw a set of vertical points with nested grouping by a two variables: .. plot:: :context: close-figs >>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker", ... data=tips) Separate the points for different hue levels along the categorical axis: .. plot:: :context: close-figs >>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker", ... data=tips, dodge=True) Use a different marker and line style for the hue levels: .. plot:: :context: close-figs >>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker", ... data=tips, ... markers=["o", "x"], ... linestyles=["-", "--"]) Draw a set of horizontal points: .. plot:: :context: close-figs >>> ax = sns.pointplot(x="tip", y="day", data=tips) Don't draw a line connecting each point: .. plot:: :context: close-figs >>> ax = sns.pointplot(x="tip", y="day", data=tips, join=False) Use a different color for a single-layer plot: .. plot:: :context: close-figs >>> ax = sns.pointplot("time", y="total_bill", data=tips, ... color="#bb3f3f") Use a different color palette for the points: .. plot:: :context: close-figs >>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker", ... data=tips, palette="Set2") Control point order by passing an explicit order: .. plot:: :context: close-figs >>> ax = sns.pointplot(x="time", y="tip", data=tips, ... order=["Dinner", "Lunch"]) Use median as the estimate of central tendency: .. plot:: :context: close-figs >>> from numpy import median >>> ax = sns.pointplot(x="day", y="tip", data=tips, estimator=median) Show the standard error of the mean with the error bars: .. plot:: :context: close-figs >>> ax = sns.pointplot(x="day", y="tip", data=tips, ci=68) Show standard deviation of observations instead of a confidence interval: .. plot:: :context: close-figs >>> ax = sns.pointplot(x="day", y="tip", data=tips, ci="sd") Add "caps" to the error bars: .. plot:: :context: close-figs >>> ax = sns.pointplot(x="day", y="tip", data=tips, capsize=.2) Use :func:`catplot` to combine a :func:`barplot` and a :class:`FacetGrid`. This allows grouping within additional categorical variables. Using :func:`catplot` is safer than using :class:`FacetGrid` directly, as it ensures synchronization of variable order across facets: .. plot:: :context: close-figs >>> g = sns.catplot(x="sex", y="total_bill", ... hue="smoker", col="time", ... data=tips, kind="point", ... dodge=True, ... height=4, aspect=.7); c K s"t} d}d}d}d}d}d}|dkrQ|dk rQd}|}nZ|dkrx|dk rxd}|}n3|dk r|dk rtdn tdt||||||| ||||||| |||| }d|_| dkrtj} n|j| | | S(NiRR s'Cannot pass values for both `x` and `y`s&Must pass values for either `x` or `y`R(R/R"RRR<RRR(RCRDRERFRGRHR9RsRtRuRRRRRRRIRRRR((s2lib/python2.7/site-packages/seaborn/categorical.pyR s2       s Show the counts of observations in each categorical bin using bars. A count plot can be thought of as a histogram across a categorical, instead of quantitative, variable. The basic API and options are identical to those for :func:`barplot`, so you can compare counts across nested variables. {main_api_narrative} {categorical_narrative} Parameters ---------- {input_params} {categorical_data} {order_vars} {orient} {color} {palette} {saturation} {dodge} {ax_in} kwargs : key, value mappings Other keyword arguments are passed to ``plt.bar``. Returns ------- {ax_out} See Also -------- {barplot} {catplot} Examples -------- Show value counts for a single categorical variable: .. plot:: :context: close-figs >>> import seaborn as sns >>> sns.set(style="darkgrid") >>> titanic = sns.load_dataset("titanic") >>> ax = sns.countplot(x="class", data=titanic) Show value counts for two categorical variables: .. plot:: :context: close-figs >>> ax = sns.countplot(x="class", hue="who", data=titanic) Plot the bars horizontally: .. plot:: :context: close-figs >>> ax = sns.countplot(y="class", hue="who", data=titanic) Use a different color palette: .. plot:: :context: close-figs >>> ax = sns.countplot(x="who", data=titanic, palette="Set3") Use ``plt.bar`` keyword arguments for a different look: .. plot:: :context: close-figs >>> ax = sns.countplot(x="who", data=titanic, ... facecolor=(0, 0, 0, 0), ... linewidth=5, ... edgecolor=sns.color_palette("dark", 3)) Use :func:`catplot` to combine a :func:`countplot` and a :class:`FacetGrid`. This allows grouping within additional categorical variables. Using :func:`catplot` is safer than using :class:`FacetGrid` directly, as it ensures synchronization of variable order across facets: .. plot:: :context: close-figs >>> g = sns.catplot(x="class", hue="who", col="survived", ... data=titanic, kind="count", ... height=4, aspect=.7); cO shd}tj|d|krK|jd|d>> import seaborn as sns >>> sns.set(style="ticks") >>> exercise = sns.load_dataset("exercise") >>> g = sns.catplot(x="time", y="pulse", hue="kind", data=exercise) Use a different plot kind to visualize the same data: .. plot:: :context: close-figs >>> g = sns.catplot(x="time", y="pulse", hue="kind", ... data=exercise, kind="violin") Facet along the columns to show a third categorical variable: .. plot:: :context: close-figs >>> g = sns.catplot(x="time", y="pulse", hue="kind", ... col="diet", data=exercise) Use a different height and aspect ratio for the facets: .. plot:: :context: close-figs >>> g = sns.catplot(x="time", y="pulse", hue="kind", ... col="diet", data=exercise, ... height=5, aspect=.8) Make many column facets and wrap them into the rows of the grid: .. plot:: :context: close-figs >>> titanic = sns.load_dataset("titanic") >>> g = sns.catplot("alive", col="deck", col_wrap=4, ... data=titanic[titanic.deck.notnull()], ... kind="count", height=2.5, aspect=.8) Plot horizontally and pass other keyword arguments to the plot function: .. plot:: :context: close-figs >>> g = sns.catplot(x="age", y="embark_town", ... hue="sex", row="class", ... data=titanic[titanic.embark_town.notnull()], ... orient="h", height=2, aspect=3, palette="Set3", ... kind="violin", dodge=True, cut=0, bw=.2) Use methods on the returned :class:`FacetGrid` to tweak the presentation: .. plot:: :context: close-figs >>> g = sns.catplot(x="who", y="survived", col="class", ... data=titanic, saturation=.5, ... kind="bar", ci=None, aspect=.6) >>> (g.set_axis_labels("", "Survival Rate") ... .set_xticklabels(["Men", "Women", "Children"]) ... .set_titles("{{col_name}} {{col_var}}") ... .set(ylim=(0, 1)) ... .despine(left=True)) #doctest: +ELLIPSIS (It __future__RttextwrapRRltnumpyR(tscipyRtpandasR%t matplotlibRotmatplotlib.collectionsRtmatplotlib.patchestpatchesRtmatplotlib.pyplottpyplotRRt external.sixRtexternal.six.movesRtRRRR t algorithmsR tpalettesR R R RtaxisgridRRt__all__tobjectRRRR>RFRQRRRRRkt_categorical_docsRR"RRRR6RPRRRRRRRRRRR(((s2lib/python2.7/site-packages/seaborn/categorical.pyts.     " s )GE                                          #Z     V