B W0d@s@dZddlmZddlmZmZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZddlZddlZddlmZmZdd lmZmZmZmZdd lmZm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*dd l+m,Z,m-Z-dd l.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:m;Z<ddl=m>Z>ddl?m@Z@ddlAmBZBddlCmDZDddlEmFZFmGZGmHZHmIZImJZJddlKmLZLmMZMmNZNddlOmPZPddlQmRZRddlSmTZTedddgZUeeVe de ffZWedZXdd d!d"d#ZYd d$d%d&d'ZZeZePeDj[Gd(d)d)eFePZ\eZe@eDj]Gd*d+d+eFe@Z^dS),z Define the SeriesGroupBy and DataFrameGroupBy classes that hold the groupby interfaces (and some implementations). These are user facing as the result of the ``df.groupby(...)`` operations, which here returns a DataFrameGroupBy object. ) annotations)abc namedtuple)partial)dedent)AnyCallableHashableIterableMappingTypeVarUnionN)lib reduction) ArrayLike FrameOrSeriesFrameOrSeriesUnion Manager2D)Appender Substitutiondoc) ensure_int64is_boolis_categorical_dtype is_dict_likeis_integer_dtypeis_interval_dtypeis_numeric_dtype is_scalar)isnanotna) algorithmsnanops)maybe_mangle_lambdasreconstruct_funcvalidate_func_kwargs) GroupByApply)SpecificationError)!create_series_with_explicit_dtype) DataFrame)NDFrame)base)GroupBy _agg_template _apply_docs_transform_templategroup_selection_context)Index MultiIndexall_indexes_same)Series)maybe_use_numba)boxplot_frame_groupbyNamedAggcolumnZaggfunc. ScalarResultstrztype[FrameOrSeries])nameklasscs0fdd}t|}|jpd|_|_t|S)z Create a property for a GroupBy subclass to dispatch to DataFrame/Series. Parameters ---------- name : str klass : {DataFrame, Series} Returns ------- property cs |S)N)Z _make_wrapper)self)r;M/var/www/html/venv/lib/python3.7/site-packages/pandas/core/groupby/generic.pyproptszgenerate_property..prop)getattr__doc____name__property)r;r<r@Z parent_methodr>)r;r?generate_propertyfs    rFzfrozenset[str])r< allowlistcsfdd}|S)a Create GroupBy member defs for DataFrame/Series names in a allowlist. Parameters ---------- klass : DataFrame or Series class class where members are defined. allowlist : frozenset[str] Set of names of klass methods to be constructed Returns ------- class decorator Notes ----- Since we don't want to override methods explicitly defined in the base class, any such name is skipped. cs4x.D]&}t||rqt|}t|||qW|S)N)hasattrrFsetattr)clsr;r@)rGr<r>r?pinners    z*pin_allowlisted_properties..pinnerr>)r<rGrKr>)rGr<r?pin_allowlisted_properties}s rLcseZdZejZddddZedZe e dj de dd fd d Z e eed d dMdddddZeZddddZdNdddddddZdd ddd Zdd dd!d"ZdOd d$d%dd&d'd(d)Zd*d+Zed d,e edddd-d.ZdPdddd1d2d3Zdd d4d5d6Zddd7d8Zd d d9d:d;ZdQdd<d=d>ZdRdd d?d@dAZe e j!dBdCZ!dSdddddDdEdFZ"d ddGdHZ#dTdKdLZ$Z%S)U SeriesGroupByzIterable[Series])returnccs |jVdS)N) _selected_obj)r=r>r>r?_iterate_slicesszSeriesGroupBy._iterate_slicesa Examples -------- >>> s = pd.Series([1, 2, 3, 4]) >>> s 0 1 1 2 2 3 3 4 dtype: int64 >>> s.groupby([1, 1, 2, 2]).min() 1 1 2 3 dtype: int64 >>> s.groupby([1, 1, 2, 2]).agg('min') 1 1 2 3 dtype: int64 >>> s.groupby([1, 1, 2, 2]).agg(['min', 'max']) min max 1 1 2 2 3 4 The output column names can be controlled by passing the desired column names and aggregations as keyword arguments. >>> s.groupby([1, 1, 2, 2]).agg( ... minimum='min', ... maximum='max', ... ) minimum maximum 1 1 2 2 3 4 .. versionchanged:: 1.3.0 The resulting dtype will reflect the return value of the aggregating function. >>> s.groupby([1, 1, 2, 2]).agg(lambda x: x.astype(float).min()) 1 1.0 2 3.0 dtype: float64templateZseriesZseries_examples)inputexamplescstj|f||S)N)superapply)r=funcargskwargs) __class__r>r?rUszSeriesGroupBy.applyr4)rSr<N)engine engine_kwargsc Osht|r^t| |j}WdQRX|j||f|d|i|\}}|jj|||jdS|dk} d} | r~t |\} }i}t |t rt ||||St |t jrt|}||} | r| | _| St|} | r|s|st || S|jjdkr|j|f||Sy|j|f||Stk rb|j|f||}tt||jjdd}t||tdSXdS)Nr[)indexr;r)r;)r\dtype_if_empty)r5r0rO_aggregate_with_numbaZto_frameobj _constructorZravelr;r% isinstancer:rBrr r#_aggregate_multiple_funcscolumnscomZget_cython_funcgroupernkeys_python_agg_generalKeyError_aggregate_namedr1sortednamesr(object) r=rVrZr[rWrXdataresultr\ relabelingrdretZcyfuncr>r>r? aggregates>         zSeriesGroupBy.aggregater)c Cs6t|trtdn^tdd|DrBdd|D}tt|}n0g}x |D]}|t|p`|qLWt||}i}x4t |D](\}\}}t j ||d}| |||<qWtdd| Drdd lm} | | d d d|Dd } | Sd d|D} |jj| dd} tdd|D| _|| } | S)Nznested renamer is not supportedcss|]}t|ttfVqdS)N)rbtuplelist).0xr>r>r? sz:SeriesGroupBy._aggregate_multiple_funcs..cSs&g|]}t|ttfs||fn|qSr>)rbrsrt)rurvr>r>r? sz;SeriesGroupBy._aggregate_multiple_funcs..)labelpositioncss|]}t|tVqdS)N)rbr))rurvr>r>r?rw1sr)concatr]cSsg|] }|jqSr>)ry)rukeyr>r>r?rx5s)axiskeyscSsi|]\}}||jqSr>)rz)rur|valr>r>r? ;sz;SeriesGroupBy._aggregate_multiple_funcs..)r\css|] }|jVqdS)N)ry)rur|r>r>r?rw=s)rbdictr'anynextzipappendreZget_callable_name enumerater+Z OutputKeyrrvaluesZpandasr{r~itemsr`_constructor_expanddimr1rd_reindex_output) r=argrdfresultsidxr;rVr|r{res_dfindexed_outputoutputr>r>r?rcs.      z'SeriesGroupBy._aggregate_multiple_funcsr:rboolint)howalt numeric_only min_countc sj}|j}|j|r:t|js:ttjdddddfdd }||}jj |j j |j d}  | S)N.z! does not implement numeric_only.r)rrNcsLy jjd|jdd}Wn&tk rFj|jd}YnX|S)Nrrr])r}r)ndimr)rf_cython_operationrNotImplementedError_agg_py_fallback)rro)rrnrrr=r>r? array_funcRs z5SeriesGroupBy._cython_agg_general..array_func)r\r;)rO_values_mgrrdtypertyperDr`rarf result_indexr;r) r=rrrrr`Zobjvalsrroserr>)rrnrrr=r?_cython_agg_generalBsz!SeriesGroupBy._cython_agg_generalz+Mapping[base.OutputKey, Series | ArrayLike])rrNcCsLt|dkst|jj}|jj}tt|}|jj |||d}| |S)a Wraps the output of a SeriesGroupBy aggregation into the expected result. Parameters ---------- output : Mapping[base.OutputKey, Union[Series, ArrayLike]] Data to wrap. Returns ------- Series Notes ----- In the vast majority of cases output will only contain one element. The exception is operations that expand dimensions, like ohlc. r])r\r;) lenAssertionErrorr`r;rfrriterrrar)r=rr;r\rror>r>r?_wrap_aggregated_outputgs z%SeriesGroupBy._wrap_aggregated_outputcCsPt|dkst|jj}tt|}|jj||jj|d}t |t sLt|S)a Wraps the output of a SeriesGroupBy aggregation into the expected result. Parameters ---------- output : dict[base.OutputKey, Union[Series, np.ndarray, ExtensionArray]] Dict with a sole key of 0 and a value of the result values. Returns ------- Series Notes ----- output should always contain one element. It is specified as a dict for consistency with DataFrame methods and _wrap_aggregated_output. r])r\r;) rrr`r;rrrrar\rbr4)r=rr;rror>r>r?_wrap_transformed_outputs z&SeriesGroupBy._wrap_transformed_outputFr1zlist[Any] | Noner)rnr~rnot_indexed_samerNc stdkr*jjgjjjj|jdS|dk s6tddfdd }t|dt r|}jj ||d} |}|j j d }jj|_|St|dttfrj||d Sjj||jjd }  | SdS) a Wrap the output of SeriesGroupBy.apply into the expected result. Parameters ---------- data : Series Input data for groupby operation. keys : Index Keys of groups that Series was grouped by. values : Optional[List[Any]] Applied output for each group. not_indexed_same : bool, default False Whether the applied outputs are not indexed the same as the group axes. Returns ------- DataFrame or Series r)r;r\rNr1)rNcs8jjdkr tjjjd}ntjjdd}|S)Nr])rlr)r;)rfrgr2 from_tuplesrlr1)r\)r~r=r>r? _get_indexs z6SeriesGroupBy._wrap_applied_output.._get_index)r\)dropna)r)rnr\r;)rr`rar;rfrrrrbrrrstackobservedr4r)_concat_objects) r=rnr~rrrr\rZres_serror>)r~r=r?_wrap_applied_outputs(     z"SeriesGroupBy._wrap_applied_outputc Osdi}d}xV|D]N\}}t|d|||f||}t|}|sTt||jd}|||<qW|S)NFr;T)rm __setattr__ libreductionZextract_resultZcheck_result_arrayr) r=rVrWrXroZ initializedr;grouprr>r>r?rjs  zSeriesGroupBy._aggregate_named)r<cOs|j|f|||d|S)N)rZr[) _transform)r=rVrZr[rWrXr>r>r? transformszSeriesGroupBy.transformTr)rrr}c Ks|dks t|j}y|jjd|j||f|}Wn:tk rh}zt|d|jd|Wdd}~XYnX|j||j j |j dS)Nrrz is not supported for z dtype)r\r;) rrOrfrrr TypeErrorrrar`r\r;)r=rrr}rXr`roerrr>r>r?_cython_transforms *zSeriesGroupBy._cython_transform)rVrNc Ost|s tt|j}g}xB|D]:\}}t|d|||f||}||||jdq W|rddlm } | |} | | } n|jj t j d} |jj| _| S)z2 Transform with a callable func`. r;)r\r)r{)r)callablerrr`rmrrr\pandas.core.reshape.concatr{_set_result_index_orderedranpZfloat64r;) r=rVrWrXr<rr;rresr{ concatenatedror>r>r?_transform_general s     z SeriesGroupBy._transform_generalcCsdS)NTr>)r=ror>r>r?_can_use_transform_fast*sz%SeriesGroupBy._can_use_transform_fast)rorNcCsH|jj\}}}|j|jjdd}t|j|}|jj||jj |jj dS)zf fast version of transform, only applicable to builtin/cythonizable functions F)copy)r\r;) rf group_inforeindexrr!Ztake_ndrr`rar\r;)r=roids_outr>r>r?_wrap_transform_fast_result-sz)SeriesGroupBy._wrap_transform_fast_result)rc sttrfddnfddddfdd yfdd D}Wn0ttfk r}ztd |Wd d }~XYnX||}|S) ao Return a copy of a Series excluding elements from groups that do not satisfy the boolean criterion specified by func. Parameters ---------- func : function To apply to each group. Should return True or False. dropna : Drop groups that do not pass the filter. True by default; if False, groups that evaluate False are filled with NaNs. Notes ----- Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See :ref:`gotchas.udf-mutation` for more details. Examples -------- >>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar', ... 'foo', 'bar'], ... 'B' : [1, 2, 3, 4, 5, 6], ... 'C' : [2.0, 5., 8., 1., 2., 9.]}) >>> grouped = df.groupby('A') >>> df.groupby('A').B.filter(lambda x: x.mean() > 3.) 1 2 3 4 5 6 Name: B, dtype: int64 Returns ------- filtered : Series cst|S)N)rB)rv)rWrVrXr>r?[z&SeriesGroupBy.filter..cs|fS)Nr>)rv)rWrVrXr>r?r]rr)rNcs|}|ot|S)N)r )rvb)wrapperr>r?true_and_notna`sz,SeriesGroupBy.filter..true_and_notnacs"g|]\}}|r|qSr>)r)rur;r)r=rr>r?rxfsz(SeriesGroupBy.filter..z'the filter must return a boolean resultN)rbr: ValueErrorr _apply_filter)r=rVrrWrXindicesrfilteredr>)rWrVrXr=rrr?filter7s#  zSeriesGroupBy.filter)rrNc Cs|jj\}}}|jj}tj|dd\}}t||f}||}||}tjddt |dd|ddkdf}tjd|dd|ddkf}|dk} |rd||<d|| <n&d|| tjd| ddf@<d||<tj ||j ddd} t |r.|ddkr(| dd} |t|}n| } n | dd} |jj} t | t | krztjt | | jd | } } | | ||<|jj| | |jjd } |j| dd S) z Return number of unique elements in the group. Returns ------- Series Number of unique values within each group. F)sortrr]Nrint64)r)r)r\r;) fill_value)rfrr`rr! factorizerlexsortr_nonzeroaddreduceatastyperZ flatnonzerorzerosrrar;r)r=rrrrcodessorterrincmaskrrriror>r>r?nuniquens6 0"     zSeriesGroupBy.nuniquec s*|fdd}|jdkr"|jS|S)Ncs |jfS)N)describe)rv)rXr>r?rrz(SeriesGroupBy.describe..r])rUr}TZunstack)r=rXror>)rXr?rs zSeriesGroupBy.describe) normalizer ascendingrc!sddlm}ddlm}jj\}} } jj}  fdd} dk r\t sl| Snt | j rl| S|dk|| }} dkrt j | dd\} } d d }n8|t| dd } | jj} | j| jjd| jd } d d }t| j rt| j| j|f}nt| |f}||| |}} dt|dd|ddkd}tjd|f}t|sf|}|| tdd|| tddk}tjd|f}t| s|}d||<tttj|dfd}ttjtj ||djj!}fdd|D|| |g}ddjj"D| g}jj#jj$g}|rn|ddk%rRd}n|fdd|D}}r|&d}ttj|t|f}|r|| dk}tj'||d|}n|}||} r4dkr4|r||n||}tr|n| |f}|||d|}|d<dk rtj(t|ddx<|ddD],}tjd|dd|ddkfOq^W)t|d}tt*|t+t*|g},d|dg}|||ddd\} }t-|dk||d} rDtr|n| |df}|||d|}|d<dddfdd fdd|ddD}|.|dt/|||dd} t0|j rt1|}jj2|| jj$d S)!Nr)get_join_indexers)cutcsjtjdS)N)rrrbins)rUr4 value_countsr>)rrrr=rr>r?apply_series_value_countss z=SeriesGroupBy.value_counts..apply_series_value_countsrT)rcSs||S)Nr>)labrr>r>r?rrz,SeriesGroupBy.value_counts..)Zinclude_lowest)Z allow_fillrcSs||jjdS)Nr)Z _multiindexr)rrr>r>r?rrr])Zrepeatscsg|] }|qSr>r>)ru level_codes)repr>r?rxsz.SeriesGroupBy.value_counts..cSsg|] }|jqSr>)Z group_index)ruZpingr>r>r?rxsFcsg|] }|qSr>r>)rur)rr>r?rx sfloatr)rleft)rrz np.ndarray) lev_codesrNcst|S)N)rrepeat)r)diffnbinr>r? build_codes4sz/SeriesGroupBy.value_counts..build_codescsg|] }|qSr>r>)rur)rr>r?rx7s)levelsrrlverify_integrity)r\r;)3Zpandas.core.reshape.mergerZpandas.core.reshape.tilerrfrr`rriterablerrr!rr4cat categoriestakerZ _na_valuerrrrightrrrslicerrrrrZreconstructed_codes groupingsrlr;allratrsumZarangeZtileZcumsumwhererr2rrra)!r=rrrrrrrrrrrrlevZllabrZ idchangesrZlchangesrrrrrldmaccrrZncatrrmir>) rrrrrrrrr=rr?rs        &        ,$ zSeriesGroupBy.value_countsc Csl|jj\}}}|jj}|dkt|@}|p.d}tj|||d}|jj||jj|jj dd}|j |ddS)z Compute count of group, excluding missing values. Returns ------- Series Count of values within each group. rr) minlengthr)r\r;r)r) rfrr`rrrZbincountrarr;r) r=rrngroupsrrr rror>r>r?count@s zSeriesGroupBy.countr]padcsdr|fddSdkr,ddt|d}||jj}|jd}||dS) z=Calculate pct_change of each value to previous entry in groupcs|jdS)N)periods fill_methodlimitfreq) pct_change)rv)rrrrr>r?r]sz*SeriesGroupBy.pct_change..Nr r)r)rrr])rUrBgroupbyrfrshift)r=rrrrZfilledZfill_grpZshiftedr>)rrrrr?rXszSeriesGroupBy.pct_change)N)r)F)Tr)T)T)FTFNT)r]r NN)&rD __module__ __qualname__r+series_apply_allowlist_apply_allowlistrPr_agg_examples_docrr.formatrUrr-rraggrcrrrrrjrr/rrrrrrrr4rrr r __classcell__r>r>)rYr?rMsD. 2-$#8 75 rMcseZdZejZedZee eddd^dddddZ e Z dd d d Z d_d dddddddZ dd ddZdd ddZd`ddZddddddZdad dddd"d#d$Zd%d&Zedd'eedddd(d)Zdd d*d+Zddd,d-d.Zd/d0Zdddd1d2d3Zddd4d5d6Zdbd7d8Zd9d fd:d; Zdcdd<d=d>Zd?d d@dAZ ddBd,dCdDZ!dEddFdGdHZ"dEddFdIdJZ#d?ddKdLdMZ$dNdOdPdQZ%dNdd4dRdSZ&dd dTdUZ'dddddVdWdXZ(ee)j*j+deddYdZd[Z*ee)j,j+dfddYd\d]Z,e-Z.Z/S)gDataFrameGroupBya  Examples -------- >>> df = pd.DataFrame( ... { ... "A": [1, 1, 2, 2], ... "B": [1, 2, 3, 4], ... "C": [0.362838, 0.227877, 1.267767, -0.562860], ... } ... ) >>> df A B C 0 1 1 0.362838 1 1 2 0.227877 2 2 3 1.267767 3 2 4 -0.562860 The aggregation is for each column. >>> df.groupby('A').agg('min') B C A 1 1 0.227877 2 3 -0.562860 Multiple aggregations >>> df.groupby('A').agg(['min', 'max']) B C min max min max A 1 1 2 0.227877 0.362838 2 3 4 -0.562860 1.267767 Select a column for aggregation >>> df.groupby('A').B.agg(['min', 'max']) min max A 1 1 2 2 3 4 Different aggregations per column >>> df.groupby('A').agg({'B': ['min', 'max'], 'C': 'sum'}) B C min max sum A 1 1 2 0.590715 2 3 4 0.704907 To control the output names with different aggregations per column, pandas supports "named aggregation" >>> df.groupby("A").agg( ... b_min=pd.NamedAgg(column="B", aggfunc="min"), ... c_sum=pd.NamedAgg(column="C", aggfunc="sum")) b_min c_sum A 1 1 0.590715 2 3 0.704907 - The keywords are the *output* column names - The values are tuples whose first element is the column to select and the second element is the aggregation to apply to that column. Pandas provides the ``pandas.NamedAgg`` namedtuple with the fields ``['column', 'aggfunc']`` to make it clearer what the arguments are. As usual, the aggregation can be a callable or a string alias. See :ref:`groupby.aggregate.named` for more. .. versionchanged:: 1.3.0 The resulting dtype will reflect the return value of the aggregating function. >>> df.groupby("A")[["B"]].agg(lambda x: x.astype(float).min()) B A 1 1.0 2 3.0r))rSr<N)rZr[c Ost|rVt| |j}WdQRX|j||f|d|i|\}}|jj|||jdSt|f|\} }} } t|}t ||||} | }t |s|dk r|S| r|dk r|j dd| f}| |_|dkr|j jdkr|j|f||S|s|r|j|f||}n|jdkr ||}|St ||gdid} y | }Wn>tk r|}zdt|krb||}Wdd}~XYnRX|j}t|tr|jj|_n.|jj|jjtt|jjd|jd|_|js||t tt!||_"|j#d d S) Nr[)r\rdr]r>)rWrXz no results)levelrT)datetime)$r5r0rOr_r`rardr$r#r&rrilocrfrgrh_aggregate_framer}rr:rbr4_obj_with_exclusionsr _set_namesrlrtrangenlevelsZ droplevelas_index_insert_inaxis_grouper_inplacer1rr\_convert)r=rVrZr[rWrXrnror\rprdorderopZgbarZsobjr>r>r?rrsP          zDataFrameGroupBy.aggregatezIterable[Series])rNccs`|j}|jdkr|j}t|tr4|j|jkr4|Vn(x&|D]\}}||jkrRq>|Vq>WdS)Nr])rOr}rrbr4r; exclusionsr)r=r`ryrr>r>r?rPs  z DataFrameGroupBy._iterate_slicesrr:rrr)rrrrrNcs|rjdddddfdd }j|dd}t|tkr|tjd tjd d d td d |S)NF)rr)rrNcsLy jjd|jdd}Wn&tk rFj|jd}YnX|S)Nrrr])r}r)rr)rfrrrr)rro)rrnrrr=r>r?r*s z8DataFrameGroupBy._cython_agg_general..array_funcT)ignore_failureszDropping invalid columns in rzQ is deprecated. In a future version, a TypeError will be raised. Before calling .z=, select only columns which should be valid for the function.) stacklevel) _get_data_to_aggregateget_numeric_datagrouped_reducerwarningswarnrrD FutureWarning_wrap_agged_manager)r=rrrrrnew_mgrr>)rrnrrr=r?r s z$DataFrameGroupBy._cython_agg_generalc Os|jjdkrtd|j}i}|jdkrTx`|D] \}}||f||}|||<q.Wn6x4|jD]*}|j||d} || f||}|||<q\W|jj} |jd|j} |j j || | d} |jdkr| j } | S)Nr]zNumber of keys must be 1r)r`)r\rd) rfrgrr"r}rZ get_groupraxesr`rar) r=rVrWrXr`ror;rnZfresZgrp_dfrZother_axrr>r>r?r!Hs$     z!DataFrameGroupBy._aggregate_framec Ost|j}i}xPt|D]D\}}|jdd|f}t|||j|jd} | j|f||||<qW|j|} |j | _ | S)N) selectionrfr+) r"rr rMrfr+rrr`rard) r=rVrWrXr`roiitemrZcolgrr>r>r?_aggregate_item_by_itemcs z(DataFrameGroupBy._aggregate_item_by_itemFcCst|dkr:|jj|jj|jd}|j|jdd}|St t j |d}|dkr\|jSt |t rv|j|||dS|jr|jjnd}t |tjtfr|jj|||jdSt |ts|jr|jj||dS|jj|||jgd}|||Sn||||||SdS)Nr)r\rdF)r)r)r\r;)r\)rr`rarfrrdrZdtypesto_dictrreZnot_nonerbr)rr&rZndarrayr1_constructor_slicedZ _selectionr4r'_wrap_applied_output_series)r=rnr~rrrofirst_not_none key_indexr>r>r?rws.     z%DataFrameGroupBy._wrap_applied_outputz list[Series]r)rrrNcsn|}tfdti|fdd|D}tdd|D}|jr|j|j}t|dkof|j dk} | r|d|d_ |j |||dS|rdd l m } | |S|s|j ||d dStd d|D} |jdkr|} |j} | j dkr,d d |D}t|dkr,t|d| _ n|j} |} | j} | jtkr@| } |jj| | | d}|jsd||||S)Nr^csg|]}|dk r|nqS)Nr>)rurv)backupr>r?rxsz@DataFrameGroupBy._wrap_applied_output_series..css|] }|jVqdS)N)r\)rurvr>r>r?rwsz?DataFrameGroupBy._wrap_applied_output_series..r]r)r)r{TcSsg|]}t|qSr>)rZasarray)ruvr>r>r?rxscSsh|] }|jqSr>)r;)rurBr>r>r? sz?DataFrameGroupBy._wrap_applied_output_series..)r\rd)Z_construct_axes_dictr(rmr3squeezerO _get_axisr}rr%r;rrr{rZvstackr\rrtrrtolistr`rar&r'r)r=r~rrr?r@rXZall_indexed_sameZ applied_indexZsingular_seriesr{Zstacked_valuesr\rdrlror>)rAr?r>sB        z,DataFrameGroupBy._wrap_applied_output_seriesTr)rrr}rNc  s|dks t}|r$|jdd}dddfdd }|j|dd }|d |jd t|t|krtjd t j d d dt ddj |}jd kr|j}|S)NrF)rr)bvaluesrNcsjjd|dfS)Nrr])rfr)rG)rrXr=r>r?arr_funcsz4DataFrameGroupBy._cython_transform..arr_funcT)r,r]zDropping invalid columns in rzQ is deprecated. In a future version, a TypeError will be raised. Before calling .zJ, select only columns which should be valid for the transforming function.r-)r.)rr/r0r1set_axisr7rr2r3rrDr4r`rar}r) r=rrr}rXmgrrHZres_mgrrr>)rrXr=r?rs     z"DataFrameGroupBy._cython_transformc Osddlm}g}|j}|jj||jd}|j|f||\}} x |D]\} } t| d| y| || | \} } WnJt k r| ||St k r}zd}t ||Wdd}~XYnXt | trTt| jsqFnl| j|jr|| gt| jdd}| j|_| j|_n2|jjt| jgt| j| j| j| jd}||qF|| qFW|jdkrt|jn|j}|jdkrdnd}|||jdd }|j||dd }||S) Nr)r{)r}r;z3transform must return a scalar value for each groupr])rdr\F)r}r)r}r)rr{r"rf get_iteratorr} _define_pathsrmr _choose_pathr_transform_item_by_itemrrbr4rprodshaper\is_rrdr`raZ concatenaterreshaperrr)r=rVrWrXr{Zappliedr`gen fast_path slow_pathr;rpathrrmsgrZ concat_indexZ other_axisrr>r>r?rsB       z#DataFrameGroupBy._transform_general)r<cOs|j|f|||d|S)N)rZr[)r)r=rVrZr[rWrXr>r>r?rJszDataFrameGroupBy.transformcCst|to|j|jjS)N)rbr)rdequalsr")r=ror>r>r?rQsz(DataFrameGroupBy._can_use_transform_fast)rorNcCs@|j}|jj\}}}|j|jjdd}|j|dd}|j|_|S)z6 Fast transform path for aggregations F)rr)r})r"rfrrrrr\)r=ror`rrrr>r>r?rVs z,DataFrameGroupBy._wrap_transform_fast_resultcsXttr.fdd}fdd}n"fdd}fdd}||fS)Ncst|S)N)rB)r)rWrVrXr>r?rerz0DataFrameGroupBy._define_paths..cs|jfddjdS)Ncst|S)N)rB)rv)rWrVrXr>r?rgrzBDataFrameGroupBy._define_paths....)r})rUr})r)rWrVrXr=r>r?rfscs|fS)Nr>)r)rWrVrXr>r?rjrcs|jfddjdS)Ncs|fS)Nr>)rv)rWrVrXr>r?rlrzBDataFrameGroupBy._define_paths....)r})rUr})r)rWrVrXr=r>r?rks)rbr:)r=rVrWrXrTrUr>)rWrVrXr=r?rLcs  zDataFrameGroupBy._define_paths)rTrUrcCs|}||}y ||}Wn,tk r.Yntk rD||fSXt|tsX||fS|j|jsn||fS||r||}||fS)N)r Exceptionrbr)rdrY)r=rTrUrrVrZres_fastr>r>r?rMps    zDataFrameGroupBy._choose_path)r`rNc Csi}g}xt|D]~\}}|jdd|f}t|||j|jd}y||||<Wn2tk rtjdt |j dt ddYqX| |qW|std|j |} |jj||jd} | | _ | S)N)r8rfr+zDropping invalid columns in z.transform is deprecated. In a future version, a TypeError will be raised. Before calling .transform, select only columns which should be valid for the transforming function.)r.z)Transform function invalid for data types)r\)rr rMrfr+rrr2r3rrDr4rrdrr`rar\) r=r`rrZindsr9colsubsetsgbrdror>r>r?rNs.  z(DataFrameGroupBy._transform_item_by_itemc Osg}|j}|jj||jd}x|D]\}} t| d||| f||} y | } Wntk rhYnXt| st | rt | r| rt | r| | |q"tdt| jdq"W|||S)a1 Return a copy of a DataFrame excluding filtered elements. Elements from groups are filtered if they do not satisfy the boolean criterion specified by func. Parameters ---------- func : function Function to apply to each subframe. Should return True or False. dropna : Drop groups that do not pass the filter. True by default; If False, groups that evaluate False are filled with NaNs. Returns ------- filtered : DataFrame Notes ----- Each subframe is endowed the attribute 'name' in case you need to know which group you are working on. Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See :ref:`gotchas.udf-mutation` for more details. Examples -------- >>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar', ... 'foo', 'bar'], ... 'B' : [1, 2, 3, 4, 5, 6], ... 'C' : [2.0, 5., 8., 1., 2., 9.]}) >>> grouped = df.groupby('A') >>> grouped.filter(lambda x: x['B'].mean() > 3.) A B C 1 bar 2 5.0 3 bar 4 1.0 5 bar 6 9.0 )r}r;zfilter function returned a z, but expected a scalar bool)rOrfrKr}rmrrDAttributeErrorrrrr rrrrrDr) r=rVrrWrXrr`rSr;rrr>r>r?rs (  zDataFrameGroupBy.filterz DataFrameGroupBy | SeriesGroupBycsD|jdkrtdt|tr8t|dkr8tjdtddt |S)Nr]z'Cannot subset columns when using axis=1zmIndexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.)r.) r}rrbrsrr2r3r4rT __getitem__)r=r|)rYr>r?ras zDataFrameGroupBy.__getitem__)rcCs|dkrR|dkr|j}t||j|j|j|j|j||j|j|j|j |j |j |j dS|dkr|dkrl|j|}t ||j|j||j|j|j |j |j d StddS)a sub-classes to define return a sliced object Parameters ---------- key : string / list of selections ndim : {1, 2} requested ndim of result subset : object, default None subset to act on r`N) r}rrfr+r8r&r group_keysrDrmutatedrr])rrfr8rrbrDrrzinvalid ndim for _gotitem)r`rrfr}rr+r&rrbrDrrcrrMr)r=r|rr]r>r>r?_gotitems@    zDataFrameGroupBy._gotitemrcCs"|j}|jdkr|jjS|jSdS)Nr])r"r}rr)r=r`r>r>r?r/5s z'DataFrameGroupBy._get_data_to_aggregateNonecCsd|j}xXtt|jjt|jtdd|jjDD]$\}}}|r8||kr8|d||q8WdS)NcSsg|] }|jqSr>)in_axis)rugrpr>r>r?rxBszCDataFrameGroupBy._insert_inaxis_grouper_inplace..r)rdrreversedrfrlZget_group_levelsrinsert)r=rordr;rrfr>r>r?r'<s  " z/DataFrameGroupBy._insert_inaxis_grouper_inplacez+Mapping[base.OutputKey, Series | ArrayLike])rrNcCsdd|D}tdd|D}||jd|jj|j|}||_ |j sj| || }n |j j|_|jdkr|j}|j|jjr|jj|_||S)a Wraps the output of DataFrameGroupBy aggregations into the expected result. Parameters ---------- output : Mapping[base.OutputKey, Union[Series, np.ndarray]] Data to wrap. Returns ------- DataFrame cSsi|]\}}||jqSr>)rz)rur|rr>r>r?rYsz.cSsg|] }|jqSr>)ry)rur|r>r>r?rxZsz.r])rr1r#r"rEr}rlr`rardr&r' _consolidaterfrr\rrYrr)r=rrrdror>r>r?rIs     z(DataFrameGroupBy._wrap_aggregated_outputcCszdd|D}|j|}|jdkr:|j}|jj|_n2tdd|D}||jd|jj ||_|jj |_ |S)a( Wraps the output of DataFrameGroupBy transformations into the expected result. Parameters ---------- output : Mapping[base.OutputKey, Union[Series, np.ndarray, ExtensionArray]] Data to wrap. Returns ------- DataFrame cSsi|]\}}||jqSr>)rz)rur|rr>r>r?r~sz=DataFrameGroupBy._wrap_transformed_output..r]css|] }|jVqdS)N)ry)rur|r>r>r?rwsz.) rr`rar}rrdr1r#rErlr\)r=rrrordr>r>r?ros    z)DataFrameGroupBy._wrap_transformed_output)rJrNcCs|jsZ|jddkr|jdnd}tt|}|d||j|}|||}n |j j }|d||j|}|j dkr|j }| |jddS)Nrr]T)r)r&rPr1r$rIr`rar'rjrfrr}rrr()r=rJrowsr\ror>r>r?r5s        z$DataFrameGroupBy._wrap_agged_managerr)r`ccsDx>t|jD]0\}}|t|jdd|f||j|jdfVq WdS)N)r8rfr+)rrdrMr rfr+)r=r`r9Zcolnamer>r>r?_iterate_column_groupbyss z)DataFrameGroupBy._iterate_column_groupbyscsVddlm}|j}fdd||D}t|sDtg||jjdS|||ddSdS)Nr)r{csg|]\}}|qSr>r>)rurZ col_groupby)rVr>r?rxsz>DataFrameGroupBy._apply_to_column_groupbys..)rdr\r])r~r})rr{rdrlrr)rfr)r=rVr`r{rdrr>)rVr?_apply_to_column_groupbyss  z*DataFrameGroupBy._apply_to_column_groupbysc sr|}|jj\}dkdddfdd }||}t|dd||}WdQRX|j|d d S) z Compute count of group, excluding missing values. Returns ------- DataFrame Count of values within each group. rr)rGrNcsF|jdkr"t|dd@}nt|@}tj|dd}|S)Nr]r)labelsZmax_binr})rrrRrZcount_level_2d)rGZmaskedZcounted)rrr r>r?hfuncs  z%DataFrameGroupBy.count..hfuncrTNr)r)r/rfrr1reZ temp_setattrr5r)r=rnrror6ror>)rrr r?r s  zDataFrameGroupBy.count)rrNcs^|jdkr|fddS|j}|jfdd|d}|jsZttt||_| ||S)a Return DataFrame with counts of unique elements in each position. Parameters ---------- dropna : bool, default True Don't include NaN in the counts. Returns ------- nunique: DataFrame Examples -------- >>> df = pd.DataFrame({'id': ['spam', 'egg', 'egg', 'spam', ... 'ham', 'ham'], ... 'value1': [1, 5, 5, 2, 5, 5], ... 'value2': list('abbaxy')}) >>> df id value1 value2 0 spam 1 a 1 egg 5 b 2 egg 5 b 3 spam 2 a 4 ham 5 x 5 ham 5 y >>> df.groupby('id').nunique() value1 value2 id egg 1 1 ham 1 2 spam 2 1 Check for rows with the same id but conflicting values: >>> df.groupby('id').filter(lambda g: (g.nunique() > 1).any()) id value1 value2 0 spam 1 a 3 spam 2 a 4 ham 5 x 5 ham 5 y rcs |S)N)r)r^)rr>r?r rz*DataFrameGroupBy.nunique..cs |S)N)r)r^)rr>r?r r)r`) r}rhr"rmr&r1r$rr\r')r=rr`rr>)rr?rs-  zDataFrameGroupBy.nunique)skipnacs8tdkrdndfdd}|||jS)NrFcsH|jtjdd}|j}|fdd|D}|j||jdS)NZargmax)r}rprcs"g|]}|dkr|ntjqS)r)rnan)rur9)r\r>r?rx&sz9DataFrameGroupBy.idxmax..func..)r\)_reducer"Z nanargmaxrrEr=r\)dfrrro)r}rrp)r\r?rVs z%DataFrameGroupBy.idxmax..func)r)_get_axis_number_python_apply_generalr")r=r}rprVr>)r}rrpr?idxmaxs zDataFrameGroupBy.idxmaxcs8tdkrdndfdd}|||jS)NrFcsH|jtjdd}|j}|fdd|D}|j||jdS)NZargmin)r}rprcs"g|]}|dkr|ntjqS)r)rrq)rur9)r\r>r?rx;sz9DataFrameGroupBy.idxmin..func..)r\)rrr"Z nanargminrrEr=r\)rsrrro)r}rrp)r\r?rV0s z%DataFrameGroupBy.idxmin..func)r)rtrur")r=r}rprVr>)r}rrpr?idxmin+s zDataFrameGroupBy.idxmin)N)r)F)Tr)T)N)T)rT)rT)0rDrrr+dataframe_apply_allowlistrrrrr-rrrrPrr!r;rr>rrrrr/rrrrLrMrNrrardr/r'rrr5rlrmr rr)rvrCrwr6Zboxplotrr>r>)rYr?rksNQ J' .L'2  % D1 & "<  r)_rC __future__r collectionsrr functoolsrtextwraprtypingrrr r r r r r2numpyrZ pandas._libsrrrZpandas._typingrrrrZpandas.util._decoratorsrrrZpandas.core.dtypes.commonrrrrrrrrZpandas.core.dtypes.missingrr Z pandas.corer!r"Zpandas.core.aggregationr#r$r%Zpandas.core.applyr&Zpandas.core.baser'Zpandas.core.commoncorecommonreZpandas.core.constructionr(Zpandas.core.framer)Zpandas.core.genericr*Zpandas.core.groupbyr+Zpandas.core.groupby.groupbyr,r-r.r/r0Zpandas.core.indexes.apir1r2r3Zpandas.core.seriesr4Zpandas.core.util.numba_r5Zpandas.plottingr6r7r:Z AggScalarr9rFrLrrMrxrr>r>r>r?sP   $ (          $ N