Ë
|
nñúhuz ã ó´ d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m
|
Z
|
m Z m Z m Z mZmZmZmZ ddlZddlZddlmZmZ dd lmZ dd
|
lmZ dd l m Z m Z m Z dd l m!Z! dd l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) ddl*m+Z+m,Z, ddl-m.Z. ddl/m0Z0m1Z1 ddl2m3Z3 ddl4m5Z5m6Z6m7Z7m8Z8m9Z9 ddl:m;c m<Z= ddl>m?Z? ddl@mAZAmBZB ddlCmDZDmEZEmFZFmGZGmHZHmIZI ddlJmKZKmLZLmMZMmNZN ddlOmPZP ddlQmRZR ddlSmTZT ddlUmVZV e
|
r.ddlWmXZXmYZYmZZZ dd l[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZe dd lfmgZg dd lhmiZi eeje d e f f Zk ed « Zl G d! d"e« Zm G d# d$eDeP « Zn G d% d&eDe? « Zo d(d'Zpy))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)Úpartial)Údedent)Ú TYPE_CHECKINGÚAnyÚCallableÚLiteralÚ
|
NamedTupleÚTypeVarÚUnionÚcastN)ÚIntervalÚlib)Ú
|
duplicated)ÚSpecificationError)ÚAppenderÚ SubstitutionÚdoc)Úfind_stack_level)Ú ensure_int64Úis_boolÚ is_dict_likeÚis_integer_dtypeÚ is_list_likeÚis_numeric_dtypeÚ is_scalar)ÚCategoricalDtypeÚ IntervalDtype)Ú is_hashable)ÚisnaÚnotna)Ú
|
algorithms)Ú GroupByApplyÚmaybe_mangle_lambdasÚreconstruct_funcÚvalidate_func_kwargsÚwarn_alias_replacement)Ú DataFrame)ÚbaseÚops)ÚGroupByÚ GroupByPlotÚ_agg_template_frameÚ_agg_template_seriesÚ _apply_docsÚ_transform_template)ÚIndexÚ
|
MultiIndexÚall_indexes_sameÚ default_index)ÚSeries)Úget_group_index)Úmaybe_use_numba)Úboxplot_frame_groupby)ÚHashableÚMappingÚSequence)
|
Ú ArrayLikeÚAxisÚAxisIntÚCorrelationMethodÚ FillnaOptionsÚ
|
IndexLabelÚManagerÚ Manager2DÚ SingleManagerÚ TakeIndexer)Ú Categorical)ÚNDFrame.Ú ScalarResultc ó& e Zd ZU dZded< ded< y)ÚNamedAggaó
|
Helper for column specific aggregation with control over output column names.
|
|
Subclass of typing.NamedTuple.
|
|
Parameters
|
----------
|
column : Hashable
|
Column label in the DataFrame to apply aggfunc.
|
aggfunc : function or str
|
Function to apply to the provided column. If string, the name of a built-in
|
pandas function.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({"key": [1, 1, 2], "a": [-1, 0, 1], 1: [10, 11, 12]})
|
>>> agg_a = pd.NamedAgg(column="a", aggfunc="min")
|
>>> agg_1 = pd.NamedAgg(column=1, aggfunc=lambda x: np.mean(x))
|
>>> df.groupby("key").agg(result_a=agg_a, result_1=agg_1)
|
result_a result_1
|
key
|
1 -1 10.5
|
2 1 12.0
|
r: ÚcolumnÚ AggScalarÚaggfuncN)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__© ó úNH:\Change_password\venv_build\Lib\site-packages\pandas/core/groupby/generic.pyrK rK | s
ñð2 ÓØ ÔrU rK c ó e Zd Zd-dZddd d.dZ ed« Z eed j d ed
|
¬ « « d/ fd « Z
|
e e ed¬ « d0dddd« Z e Zd Zd1dZ d2 d3dZd Z ed« Z ede¬« ee« dddd« « Z d4 d5dZ d6dZd7d8dZd7d9dZ e ej8 « d:d/ fd « Z d; d<d Z dde j> dde j> f d=d Z e j> f d>d Z!e j> ddf d?d Z"e# e ejH jJ « d@d!« « Z$ e ejL jJ « dA dBd"« Z& e ejN jJ « dA dBd#« Z' e ejP jJ « e j> df dCd$« Z( e ejR jJ « e j> df dCd%« Z) e ejT jJ « dD dEd&« Z* e ejV jJ « dF dGd'« Z+e#d/d(« Z,e#d/d)« Z- e ej\ jJ « dH dId*« Z.e# e ej^ jJ « d/d+« « Z/d/d,Z0 xZ1S )JÚ SeriesGroupByr6 c ó | j j ||j ¬« }| j j |_ |S ©N©Úaxes)ÚobjÚ_constructor_from_mgrr\ ÚnameÚ_name)ÚselfÚmgrÚouts rV Ú_wrap_agged_managerz!SeriesGroupBy._wrap_agged_manager s3 Øhh×,Ñ,¨S°s·x±xÐ,Ó@ØHHMM Ø
|
rU FN©Ú numeric_onlyr_ c ó¸ | j }|j }|r?t |j « s*d}t d| dt | « j d| d« |S )Nrf z Cannot use z =True with ú.z and non-numeric dtypes.)Ú_obj_with_exclusionsÚ_mgrr ÚdtypeÚ TypeErrorÚtyperO )ra rf r_ ÚserÚsingleÚkwd_names rV Ú_get_data_to_aggregatez$SeriesGroupBy._get_data_to_aggregate sh ð ×'Ñ'ØÙ Ô 0°·±Ô ;à%HÜØ hZ {Ü:×&Ñ&Ð' q¨¨Ð.FðHóð ð rU a§
|
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: float64
|
ÚtemplateÚseriesÚseries_examples)ÚinputÚexamplesc ó* t | |g|¢i |¤S ©N)ÚsuperÚapply)ra ÚfuncÚargsÚkwargsÚ __class__s rV rz zSeriesGroupBy.applyà s ø ô w}TÐ3 DÒ3¨FÑ3Ð3rU ©rv Úklass©ÚengineÚ engine_kwargsc óÌ |d u }d }|rt |« \ }}i }t |t « r+t |« r|||d< |||d< t | |« |i |¤S t |t
|
j « rVt |« }||d< ||d< | j |g|¢i |¤}|r |J ||_ | j s|j « }|S t j |« } | r"|s |s t | || « t | | « « S t |« r | j |g|¢d|i|¤S | j dk( r]| j" }
|
| j$ j' g | j$ j( | j* j, |
|
j. ¬« S | j* j0 dkD r | j2 |g|¢i |¤S | j2 |g|¢i |¤S # t4 $ r | j6 |g|¢i |¤} t9 j: dt= | « j> dt@ tC « ¬« tE | | j* j, ¬ « } | jG | « } | cY S w xY w)
|
Nr r r ©r_ Úindexrk é z)Pinning the groupby key to each group in z¯.agg is deprecated, and cases that relied on it will raise in a future version. If your operation requires utilizing the groupby keys, iterate over the groupby object instead.©Ú
|
stacklevel©r )$r' Ú
|
isinstanceÚstrr8 Úgetattrr ÚIterabler% Ú_aggregate_multiple_funcsÚcolumnsÚas_indexÚ reset_indexÚcomÚget_cython_funcr( Ú_aggregate_with_numbaÚngroupsri r] Ú _constructorr_ Ú_grouperÚ result_indexrk ÚnkeysÚ_python_agg_generalÚKeyErrorÚ_aggregate_namedÚwarningsÚwarnrm rO Ú FutureWarningr r6 Ú_wrap_aggregated_output) ra r{ r r r| r} Ú
|
relabelingr ÚretÚcyfuncr] Úresults rV Ú aggregatezSeriesGroupBy.aggregateè s àT\
|
ØÙ Ü 0°Ó 8MGTØFä dCÔ Ü vÔ&¨6Ð+=ð
|
$*xÑ Ø Ð(Ø*7Ñ'Ø&74 Ó&¨Ð7°Ñ7Ð 7ä cllÔ +ô (¨Ó-DØ %F8Ñ Ø&3F?Ñ #Ø0$×0Ñ0°ÐG¸ÒGÀÑGCÙà Ð*Ð*Ð*Ø % Ø==ØooÓ'ØJô ×(Ñ(¨Ó.FÙd©6Ü& t¨T°6Ô:Ø,wt VÓ,Ó.Ð.ä vÔ&Ø1t×1Ñ1ØðØ òØ/<ðØ@Fñð ð ||qÒ ð
|
×/Ñ/Øxx×,Ñ,ØØ Ø --×4Ñ4Ø ))ð -ó ð ð }}×"Ñ" QÒ&Ø/t×/Ñ/°ÐF°tÒF¸vÑFÐFð Ø/t×/Ñ/°ÐF°tÒF¸vÑFÐFøÜò ð /×.Ñ.¨tÐE°dÒE¸fÑEä Ø?ÜDz×*Ñ*Ð+ð ,?ð?ô
|
"Ü /Ó 1õô ¨d¯m©m×.HÑ.HÔIØ ×5Ñ5°fÓ=Ø ð' ús Æ<G ÇBI#É"I#c ó: }t j « |k7 r t j }t | ||« fd}| j }| j
|
j ||« }|j ||j ¬« } | j | « S )Nc ó | g¢i ¤S rx rT ©Úxr| r{ r} s rV ú<lambda>z3SeriesGroupBy._python_agg_general.<locals>.<lambda>D ó ø d1Ð.tÒ. vÑ. rU )r_ )
|
r Úis_builtin_funcÚ_builtin_table_aliasr( ri r Ú
|
agg_seriesr r_ r¡ )
|
ra r{ r| r} Ú orig_funcÚaliasÚfr] r¥ Úress
|
``` rV r z!SeriesGroupBy._python_agg_general> s ú Ø Ü×"Ñ" 4Ó(Ø Ò Ü×,Ñ,¨TÑ2EÜ " 4¨°EÔ :Ý .à×'Ñ'Ø ×)Ñ)¨#¨qÓ1Ø× Ñ v¨C¯H©HÐ Ó5Ø×+Ñ+¨CÓ0Ð0rU c óô t |t « rW| j r t d« d}t j
|
|t t « ¬« t |j « « }nQt d |D « « r*|D cg c] }t |t t f« s||fn| }}nd |D « }t ||« }i }t j | dd« 5 t |« D ]8 \ }\ } }
|
t! j" | |¬« } | j$ |
|
g|¢i |¤|| < : d d d « t d |j' « D « « r9d
|
d lm} | |j' « d |D cg c] } | j, c} ¬ « } | S |j « D ci c] \ } }| j. | }} }| j0 j3 |d ¬« }t5 d |D « « |_ |S c c}w # 1 sw Y ÊxY wc c} w c c}} w )Nz nested renamer is not supportedzPassing a dictionary to SeriesGroupBy.agg is deprecated and will raise in a future version of pandas. Pass a list of aggregations instead.)ÚmessageÚcategoryr c 3 óH K | ] }t |t t f« y wrx )r ÚtupleÚlist©Ú.0rª s rV ú <genexpr>z:SeriesGroupBy._aggregate_multiple_funcs.<locals>.<genexpr>] s è ø Ò;°!A¤¤t}×-Ñ;ùs "c 3 óN K | ] }t j |« xs | y wrx )r Úget_callable_name)r» r² s rV r¼ z:SeriesGroupBy._aggregate_multiple_funcs.<locals>.<genexpr>a s# è ø ÒB¸s×,Ñ,¨QÓ/Ò4°1Ó4ÑBùs #%r T)ÚlabelÚpositionc 3 ó< K | ] }t |t « y wrx )r r) rº s rV r¼ z:SeriesGroupBy._aggregate_multiple_funcs.<locals>.<genexpr>l s è ø ÒB¨Az!Y×'ÑBùs r ©Úconcatr )ÚaxisÚkeysr c 3 ó4 K | ] }|j y wrx )r¿ )r» Úkeys rV r¼ z:SeriesGroupBy._aggregate_multiple_funcs.<locals>.<genexpr>v s è ø Ò <¨SsyyÑ <ùó ) r Údictr r r r r r r¹ ÚitemsÚanyr¸ Úzipr Ú temp_setattrÚ enumerater* Ú OutputKeyr¦ ÚvaluesÚpandasrà r¿ rÀ r] Ú_constructor_expanddimr2 r )ra Úargr| r} Úmsgrª r ÚresultsÚidxr_ r{ rÇ rà Úres_dfÚvalÚindexed_outputÚoutputs rV r z'SeriesGroupBy._aggregate_multiple_funcsK sÒ Ü c4Ô Ø}}ä(Ð)JÓKÐKð/ð ô
|
Ø Ü *Ü /Ó 1õô
|
399;Ó'Ü Ñ;°sÔ;Ô ;ØNQÖRȤ¨A´´t¨}Ô!=Aq6À1ÑDÐRCÑRñ C¸cÔBGÜgsÓ#Cà<>Ü × Ñ d J°Ó 5ñ Eô &/¨s£^ò EÑ!\dDÜnn¨4¸#Ô>Ø -t~~¨dÐ D°TÒ D¸VÑ D ñ E÷ Eô ÑB°· ± Ó1AÔBÔ BÝ %áØÓ qÀWÖ/M¸c°· ³ Ò/MôFð Mà<C¿M¹M»O×L±°°S#,,¨Ñ+ÐLÑLØ×0Ñ0° ÀtÐ0ÓLÜ Ñ <°GÔ <Ó<à ùò5 S÷ Eð Eüò 0Nùó Ms Á>#G ÃAG#Å G/ ÆG4Ç#G,c ó4 t |« dk( rb|r |j }n| j j }| j j g | j j ||j ¬« S |J t |d t « rs| j j }| j j ||¬« }| j |« }|j d¬« }| j j |_ |S t |d t t f« ry| j |||¬« } t | t « r| j j | _ | j s,|r*| j# | « } t% t | « « | _ | S | j j || j j | j j ¬« } | j s*| j# | « } t% t | « « | _ | j | « S )aÃ
|
Wrap the output of SeriesGroupBy.apply into the expected result.
|
|
Parameters
|
----------
|
data : Series
|
Input data for groupby operation.
|
values : 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 T)Ú future_stack©Únot_indexed_sameÚ is_transform)Údatar r_ )Úlenr r r r] r r_ rk r rÉ rÒ Ú_reindex_outputÚstackr6 r) Ú_concat_objectsr Ú_insert_inaxis_grouperr5 )
|
ra rà rÐ rÞ rß Ú res_indexr r× Úres_serr¥ s
|
rV Ú_wrap_applied_outputz"SeriesGroupBy._wrap_applied_outputz s ô. v;!Ò áà JJ à MM× 6Ñ 6 à88×(Ñ(ØØXX]]Ø Øjjð )ó ð ð Ð!Ð!Ð!ä fQi¤Ô &àMM×.Ñ.EØXX×4Ñ4°VÀ5Ð4ÓIFØ×)Ñ)¨&Ó1Fð ll°lÓ5GØ 88==GLØNÜ q ¤F¬IÐ#6Ô 7Ø×)Ñ)ØØ!1Ø )ð *ó Fô
|
&¤&Ô)Ø "hhmm Ø==Ñ%5Ø ×4Ñ4°VÓ<Ü ,¬S°«[Ó 9 ØMð XX×*Ñ*Ø 4§=¡=×#=Ñ#=ÀDÇHÁHÇMÁMð +ó Fð ==Ø ×4Ñ4°VÓ<Ü ,¬S°«[Ó 9 Ø×'Ñ'¨Ó/Ð /rU c óB i }d}| j j | j | j ¬« D ]f \ }}t j |d|« ||g|¢i |¤}t j |« }|s"t j ||j « d}|||< h |S )NF©rÄ r_ T)
|
r Ú get_iteratorri rÄ ÚobjectÚ __setattr__r+ Úextract_resultÚcheck_result_arrayrk ) ra r{ r| r} r¥ Ú initializedr_ ÚgrouprÚ s rV r z SeriesGroupBy._aggregate_namedÁ s¨ ð Ø à ==×5Ñ5Ø × %Ñ %¨D¯I©Ið 6ó
|
ò "KD%ô × Ñ u f¨dÔ 3á%Ð1 $Ò1¨&Ñ1FÜ×'Ñ'¨Ó/FÙ ä×&Ñ& v¨u¯{©{Ô;Ø " Ø!F4Lð "ð rU a7
|
>>> ser = pd.Series([390.0, 350.0, 30.0, 20.0],
|
... index=["Falcon", "Falcon", "Parrot", "Parrot"],
|
... name="Max Speed")
|
>>> grouped = ser.groupby([1, 1, 2, 2])
|
>>> grouped.transform(lambda x: (x - x.mean()) / x.std())
|
Falcon 0.707107
|
Falcon -0.707107
|
Parrot 0.707107
|
Parrot -0.707107
|
Name: Max Speed, dtype: float64
|
|
Broadcast result of the transformation
|
|
>>> grouped.transform(lambda x: x.max() - x.min())
|
Falcon 40.0
|
Falcon 40.0
|
Parrot 10.0
|
Parrot 10.0
|
Name: Max Speed, dtype: float64
|
|
>>> grouped.transform("mean")
|
Falcon 370.0
|
Falcon 370.0
|
Parrot 25.0
|
Parrot 25.0
|
Name: Max Speed, dtype: float64
|
|
.. versionchanged:: 1.3.0
|
|
The resulting dtype will reflect the return value of the passed ``func``,
|
for example:
|
|
>>> grouped.transform(lambda x: x.astype(int).max())
|
Falcon 390
|
Falcon 390
|
Parrot 30
|
Parrot 30
|
Name: Max Speed, dtype: int64
|
©r Úexamplec ó4 | j |g|¢||d|¤S ©Nr ©Ú
|
_transform©ra r{ r r r| r} s rV Ú transformzSeriesGroupBy.transform ó4 ð tØ ð
|
Øñ
|
Ø &°mñ
|
ØGMñ
|
ð
|
rU c ó< |dk( sJ | j } | j j d|j ||fi |¤}|j || j j |j ¬« S # t $ r!}t | d|j d« |d }~ww xY w)Nr rù z is not supported for z dtype©r r_ ) ri r Ú_cython_operationÚ_valuesÚNotImplementedErrorrl rk r r] r r_ )ra Úhowrf rÄ r} r] r¥ Úerrs rV Ú_cython_transformz SeriesGroupBy._cython_transform s¦ ð qyÐyà×'Ñ'ð VØ4T]]×4Ñ4ØS[[¨#¨tñØ7=ñFð × Ñ ¨d¯h©h¯n©nÀ3Ç8Á8Ð ÓLÐLøô #ò VäseÐ#9¸#¿)¹)¸ÀFÐ KÓLÐRUÐ Uûð Vús *A1 Á1 BÁ: BÂBc ó` t |« r | j |g|¢d|i|¤S t |« sJ t | j « }g }| j
|
j | j | j ¬« D ]K \ }} t j | d|« || g|¢i |¤}
|
|j ||
|
| j ¬« « M |r ddl m} | |« } | j | « } n*| j j! t" j$ ¬« } | j j& | _ | S )z3
|
Transform with a callable `func`.
|
r rê r_ r r r ©rk )r8 Ú_transform_with_numbaÚcallablerm r] r rë ri rÄ rì rí Úappendr Úpandas.core.reshape.concatrà Ú_set_result_index_orderedr ÚnpÚfloat64r_ )ra r{ r r r| r} r rÕ r_ rñ r³ rÃ Ú concatenatedr¥ s rV Ú_transform_generalz SeriesGroupBy._transform_general s! ô 6Ô "Ø-4×-Ñ-ØðØòØ+8ðØ<Bñð ô ~Ð ~ÜTXXàØ ==×5Ñ5Ø × %Ñ %¨D¯I©Ið 6ó
|
ò :KD%ô × Ñ u f¨dÔ 3ÙuÐ.tÒ. vÑ.Cà NN5 ¨E¯K©KÔ8Õ 9ð :ñ Ý 9á! '?LØ×3Ñ3°LÓAFàXX×*Ñ*´·±Ð*Ó<Fàhhmm Ø rU Tc ó t t « rfd nfd d fd } | j j | j | j
|
¬« D cg c] \ }} ||« r| j |« }}}| j ||« }
|
|
|
S c c}}w # t t f$ r} t d« | d} ~ ww xY w)a°
|
Filter elements from groups that don't satisfy a criterion.
|
|
Elements from groups are filtered if they do not satisfy the
|
boolean criterion specified by func.
|
|
Parameters
|
----------
|
func : function
|
Criterion to apply to each group. Should return True or False.
|
dropna : bool
|
Drop groups that do not pass the filter. True by default; if False,
|
groups that evaluate False are filled with NaNs.
|
|
Returns
|
-------
|
Series
|
|
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
|
c ó( t | « i ¤S rx ©r r© s rV r« z&SeriesGroupBy.filter.<locals>.<lambda>d s ø Ð 0¤¨¨4Ó 0°$Ð A¸&Ñ A rU c ó | g¢i ¤S rx rT r© s rV r« z&SeriesGroupBy.filter.<locals>.<lambda>f s ø ¡ QÐ 8¨Ò 8°Ñ 8 rU c ó2 | « }t |« xr |S rx )r" )rª ÚbÚwrappers rV Útrue_and_notnaz,SeriesGroupBy.filter.<locals>.true_and_notnai s ø Ù
|
AÜ8> Ð !rU rê z'the filter must return a boolean resultN)ÚreturnÚbool)
|
r r r rë ri rÄ Ú
|
_get_indexÚ
|
ValueErrorrl Ú _apply_filter) ra r{ Údropnar| r} r r_ rñ Úindicesr Úfilteredr s ` `` @rV ÚfilterzSeriesGroupBy.filter= sà û ôL dCÔ ÝAGå8Gõ "ð Pð $(§=¡=×#=Ñ#=Ø×-Ñ-°D·I±Ið $>ó $÷á D%ñ " %Ô(ð Õ%ðGñ ð ×%Ñ% g¨vÓ6Øùóøô IÐ&ò PÜÐ EÓFÈCÐ Oûð Pús) «4B Á #BÂB ÂB  B?Â. B:Â:B?c óä | j j \ }}}| j j }t j
|
||d¬« \ }}| j j r|dk\ }|| }|| }t ||g|t |« fd|¬« } |r | dk\ }| j « r
|
|| }| | } t | d« }t j || |¬« }
|
t |
|
« }
|
| j j } | j j |
|
| | j j ¬« } | j" s*| j% | « } t' t | « « | _ | j+ | d¬« S ) a°
|
Return number of unique elements in the group.
|
|
Returns
|
-------
|
Series
|
Number of unique values within each group.
|
|
Examples
|
--------
|
For SeriesGroupby:
|
|
>>> lst = ['a', 'a', 'b', 'b']
|
>>> ser = pd.Series([1, 2, 3, 3], index=lst)
|
>>> ser
|
a 1
|
a 2
|
b 3
|
b 3
|
dtype: int64
|
>>> ser.groupby(level=0).nunique()
|
a 2
|
b 1
|
dtype: int64
|
|
For Resampler:
|
|
>>> ser = pd.Series([1, 2, 3, 3], index=pd.DatetimeIndex(
|
... ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
|
>>> ser
|
2023-01-01 1
|
2023-01-15 2
|
2023-02-01 3
|
2023-02-15 3
|
dtype: int64
|
>>> ser.resample('MS').nunique()
|
2023-01-01 2
|
2023-02-01 1
|
Freq: MS, dtype: int64
|
F)Úuse_na_sentinelÚsortr )ÚlabelsÚshaper! ÚxnullÚfirst)Ú minlengthrü )Ú
|
fill_value)r Ú
|
group_infor] rþ r# Ú factorizeÚhas_dropped_nar7 rá rË r r
|
Úbincountr r r r_ r rå r5 r râ ) ra r ÚidsÚ_r rØ ÚcodesÚuniquesÚmaskÚ group_indexr³ Úrir¥ s rV ÚnuniquezSeriesGroupBy.nunique{ s\ ðR --×2Ñ2QØhh× Ñ Ü#×-Ñ-¨cÀ6ÐPUÔVwà ==× 'Ò 'Ø!8DØd)CØ$KEä%Ø<ØC LÐ)ØØô
|
ñ Ø !Ñ#DØ{{}Ø$iØ )¨$Ñ / ä+ wÓ/Ükk#te*°Ô8Ü3Ó à ]]× 'Ñ 'Ø%)§X¡X×%:Ñ%:Ø r §¡§ ¡ ð &;ó &
|
ð }}Ø×0Ñ0°Ó8FÜ(¬¨V«Ó5FLØ×#Ñ# F°qÐ#Ó9Ð9rU c ó( t | |||¬« S )N)Ú percentilesÚincludeÚexclude)ry Údescribe)ra r5 r6 r7 r~ s rV r8 zSeriesGroupBy.describeÇ s! ø äwÑ Ø#¨W¸gð ó
|
ð
|
rU c óÊ +, |rdnd}| | j ||||¬« }||_ |S ddlm} ddlm} | j j \ }
|
} } | j j } | j j | j j gz } t | j t « s|St j |« s>| j! t" j$ ||||¬« }||_ | |j& _
|
|S |
|
dk7 }|
|
| | | } }
|
| t) j* | d ¬
|
« \ }}d }nc | t# | d ¬ « |d ¬« }t- d|j « }|j. }|j1 |j2 d |j4 ¬« }d }t |j t6 « r=t- t8 |« }t j: |j< |j> |
|
f« }nt j: ||
|
f« }|
|
| || }}
|
dt j@ |
|
dd |
|
d d k7 « d z }t jB d|f }tE |
|
« s|} ||tG dd « « ||tG d d« « k7 }t jB d |f }tE | « s|}d ||< t jH t j@ t jB |d f « d « }tK t jL t jN jQ ||« ¬« } | j jR } | D cg c]
|
} | | « c} |||« gz } | j jT D cg c] } | jV c} |gz } |r2| d dk7 }|jY « rd }n|| | D cg c] } | | } } }|r|j[ d« }t jH t jB |tE |
|
« f « }!|r5|
|
|dk( }"t jN j] |!|"d« | |!« | }#n | |!« }#||#z }|r>|<|r|
|
| | n|
|
| }$t j: |r|n| |$f« }|| | d | c}| d< |gt j^ tE |« d¬« +| d d D ]# } +t jB d | dd | d d k7 f z +% +ja « tE | d « c}%,t jL t jb |%« ,« t jd t jb ,« |%« g}&+jg « dz
|
| d g}' ||&|'d d¬« \ } }| t jh |dk7 || d« }|r0t j: |r|n| |&d f« }|| |&d | c}|&d< d +,fd }(| d d D )cg c]
|
}) |(|)« } })| jk |&d « tm | | | d ¬« }*to |j « r tq |« }| j js ||*|¬« }| jt s|jw « }|S c c} w c c} w c c} w c c})w ) NÚ
|
proportionÚcount)Ú normalizer! Ú ascendingr r )Úget_join_indexers)Úcut)r< r! r= ÚbinséÿÿÿÿT)r! c ó | | S rx rT ©ÚlabÚincs rV r« z,SeriesGroupBy.value_counts.<locals>.<lambda>þ s
|
C¨¡H rU F©Úcopy)Úinclude_lowestrG )Ú
|
allow_fillr' c ó: | | j j d S )NrA )Ú _multiindexr. rC s rV r« z,SeriesGroupBy.value_counts.<locals>.<lambda> s C¨¡H×$8Ñ$8×$>Ñ$>¸rÑ$B rU r )ÚrepeatsÚfloatr r Úleft)r! r c ó6 t j | « S rx )r
|
Úrepeat)Ú lev_codesÚdiffÚnbins rV Ú build_codesz/SeriesGroupBy.value_counts.<locals>.build_codes] s ø Üyy ¨4¡ °$Ó7Ð7rU )Úlevelsr. ÚnamesÚverify_integrityrü )rQ ú
|
np.ndarrayr rX )<Ú _value_countsr_ Úpandas.core.reshape.merger> Úpandas.core.reshape.tiler? r r( r] rþ rV r rk r r
|
Úiterablerz r6 Ú value_countsr r# r) r Ú
|
categoriesÚtaker. Ú _na_valuer r ÚlexsortrN ÚrightÚnonzeroÚr_rá ÚslicerR r rP ÚaddÚreduceatÚreconstructed_codesÚ groupingsÚ _group_indexÚallÚastypeÚatÚzerosÚsumÚarangeÚtileÚcumsumÚwherer r3 r r r r r )-ra r< r! r= r@ r r_ r¥ r> r? r, r- rØ Ú index_namesrn r0 rD ÚlevÚllabÚcat_serÚcat_objÚ lab_intervalÚsorterÚ idchangesrÖ ÚlchangesrE rc Úrepr. Ú level_codesÚpingrU ÚdÚmÚaccÚcatÚncatrN rb rT rQ ÚmirR rS s- @@rV r] zSeriesGroupBy.value_countsÍ s ù ñ )|¨gà <Ø×'Ñ'Ø#¨$¸)ÈFð (ó Fð FKØMå?Ý0àMM×,Ñ, QØhh× Ñ àmm×)Ñ)¨T¯X©X¯]©]¨OÑ; ä ciiÔ!1Ô 2Ø Ð ¤R§[¡[°Ô%6ð
|
**Ü×#Ñ#Ø#ØØ#Øð ó Cð CHØ )CIIOØJð byØt9c $iSð <Ü!×+Ñ+¨C°dÔ;HCÙ,Dñ & ¨5Ô1°4ÈÔMGÜ=¨'¯/©/Ó:GØ×$Ñ$CØ((Ø Ø Ø ==ð ó Cñ
|
CDä cii¤ Ô /ä ¤¨#Ó.LäZZ ×!2Ñ!2°L×4FÑ4FÈÐ LÓMFäZZ c
|
Ó+Fàv; F¡ Sð
|
|
3 q r 7¨c°#°2¨hÑ#6Ó7¸Ñ:Ñ: ÜeeAyLÑ!Ü3xØCñ U 1 d^Ó,±°S¼%ÀÀb»/Ó0JÑJÜeeD(NÑ#Ü3xØCØCÜggbjj¤§¡ s¨D yÑ!1Ó2°1Ñ5Ó6ô bii¬¯©¯ © ¸¸cÓ)BÔCð ×1Ñ1Ø5:Ö; k[Õ!Ò;¹tÀCÈ»~Ð>NÑNØ04· ± ×0GÑ0GÖH¨$×#Ó#ÒHÈCÈ5ÑPá Ø9 ?DØxxzØ à YÈeÖ(T¸{¨°TÓ):Ð(TUÐ(Tá Ø**WÓ%CÜc¤3 s£8mÑ,Ó-AÙØr NÜ !Q Ô#Ù!fTlá!fØ 3JCá DLÙ$*#c(4.°°C±CÜZZ© ¡¸°t¸SÐ AÓBFØ [¨%°©)°FÑ*;NCrà Ñ ô 88C H¨FÔ3DØ $ S bzò I Ød K°° O°{À3ÀBÐ7GÑ$GÐ GÑHÑHð Ið ¤S¨°©£_JD$äIIbii¨o¨tÓ4´b·g±g¼b¿i¹iÈ»oÈtÓ6TÐUDà[[] QÑ&¨¨b© Ð2Eñ
|
'Øe %¨VôFAsð Ühhs by¨#¨c©(°AÓ6áÜ©I¡S¸C¸4ÀÀaÁÐ$IÓJØ # F¡ ¨T°"©X°fÑ-= T"Xö 8ð >CÀ3ÀB¸ZÖH° [ Õ+ÐHEÐHØ LLbÔ "ä Ø ¨kÈEô
|
ô CIIÔ &Ü sÓ#CØ×&Ñ& s°"¸4Ð&Ó@Ø}}Ø×'Ñ'Ó)FØ ùòI <ùÚHùò )Uùò` Is Ì1YÍ&YÎ% Y×Y c óê t j t | « j dt | j « j dt
|
t « ¬« | j d||||||¬« }|S )a
|
Fill NA/NaN values using the specified method within groups.
|
|
.. deprecated:: 2.2.0
|
This method is deprecated and will be removed in a future version.
|
Use the :meth:`.SeriesGroupBy.ffill` or :meth:`.SeriesGroupBy.bfill`
|
for forward or backward filling instead. If you want to fill with a
|
single value, use :meth:`Series.fillna` instead.
|
|
Parameters
|
----------
|
value : scalar, dict, Series, or DataFrame
|
Value to use to fill holes (e.g. 0), alternately a
|
dict/Series/DataFrame of values specifying which value to use for
|
each index (for a Series) or column (for a DataFrame). Values not
|
in the dict/Series/DataFrame will not be filled. This value cannot
|
be a list. Users wanting to use the ``value`` argument and not ``method``
|
should prefer :meth:`.Series.fillna` as this
|
will produce the same result and be more performant.
|
method : {{'bfill', 'ffill', None}}, default None
|
Method to use for filling holes. ``'ffill'`` will propagate
|
the last valid observation forward within a group.
|
``'bfill'`` will use next valid observation to fill the gap.
|
axis : {0 or 'index', 1 or 'columns'}
|
Unused, only for compatibility with :meth:`DataFrameGroupBy.fillna`.
|
inplace : bool, default False
|
Broken. Do not set to True.
|
limit : int, default None
|
If method is specified, this is the maximum number of consecutive
|
NaN values to forward/backward fill within a group. In other words,
|
if there is a gap with more than this number of consecutive NaNs,
|
it will only be partially filled. If method is not specified, this is the
|
maximum number of entries along the entire axis where NaNs will be
|
filled. Must be greater than 0 if not None.
|
downcast : dict, default is None
|
A dict of item->dtype of what to downcast if possible,
|
or the string 'infer' which will try to downcast to an appropriate
|
equal type (e.g. float64 to int64 if possible).
|
|
Returns
|
-------
|
Series
|
Object with missing values filled within groups.
|
|
See Also
|
--------
|
ffill : Forward fill values within a group.
|
bfill : Backward fill values within a group.
|
|
Examples
|
--------
|
For SeriesGroupBy:
|
|
>>> lst = ['cat', 'cat', 'cat', 'mouse', 'mouse']
|
>>> ser = pd.Series([1, None, None, 2, None], index=lst)
|
>>> ser
|
cat 1.0
|
cat NaN
|
cat NaN
|
mouse 2.0
|
mouse NaN
|
dtype: float64
|
>>> ser.groupby(level=0).fillna(0, limit=1)
|
cat 1.0
|
cat 0.0
|
cat NaN
|
mouse 2.0
|
mouse 0.0
|
dtype: float64
|
ú´.fillna is deprecated and will be removed in a future version. Use obj.ffill() or obj.bfill() for forward or backward filling instead. If you want to fill with a single value, use ú.fillna insteadr Úfillna©ÚvalueÚmethodrÄ ÚinplaceÚlimitÚdowncast©r r rm rO r] r r Ú _op_via_apply©ra r r rÄ r r r r¥ s rV r zSeriesGroupBy.fillnan s ô^ ÜDz×"Ñ"Ð#ð $!ô "& d§h¡h£ ×!8Ñ!8Ð 9¸ ð Jô Ü'Ó)õ
|
ð ×#Ñ#Ø ØØØØØØ ð $ó
|
ð rU c ó0 | j d||d|¤}|S )a¢
|
Return the elements in the given *positional* indices in each group.
|
|
This means that we are not indexing according to actual values in
|
the index attribute of the object. We are indexing according to the
|
actual position of the element in the object.
|
|
If a requested index does not exist for some group, this method will raise.
|
To get similar behavior that ignores indices that don't exist, see
|
:meth:`.SeriesGroupBy.nth`.
|
|
Parameters
|
----------
|
indices : array-like
|
An array of ints indicating which positions to take in each group.
|
axis : {0 or 'index', 1 or 'columns', None}, default 0
|
The axis on which to select elements. ``0`` means that we are
|
selecting rows, ``1`` means that we are selecting columns.
|
For `SeriesGroupBy` this parameter is unused and defaults to 0.
|
|
.. deprecated:: 2.1.0
|
For axis=1, operate on the underlying object instead. Otherwise
|
the axis keyword is not necessary.
|
|
**kwargs
|
For compatibility with :meth:`numpy.take`. Has no effect on the
|
output.
|
|
Returns
|
-------
|
Series
|
A Series containing the elements taken from each group.
|
|
See Also
|
--------
|
Series.take : Take elements from a Series along an axis.
|
Series.loc : Select a subset of a DataFrame by labels.
|
Series.iloc : Select a subset of a DataFrame by positions.
|
numpy.take : Take elements from an array along an axis.
|
SeriesGroupBy.nth : Similar to take, won't raise if indices don't exist.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([('falcon', 'bird', 389.0),
|
... ('parrot', 'bird', 24.0),
|
... ('lion', 'mammal', 80.5),
|
... ('monkey', 'mammal', np.nan),
|
... ('rabbit', 'mammal', 15.0)],
|
... columns=['name', 'class', 'max_speed'],
|
... index=[4, 3, 2, 1, 0])
|
>>> df
|
name class max_speed
|
4 falcon bird 389.0
|
3 parrot bird 24.0
|
2 lion mammal 80.5
|
1 monkey mammal NaN
|
0 rabbit mammal 15.0
|
>>> gb = df["name"].groupby([1, 1, 2, 2, 2])
|
|
Take elements at positions 0 and 1 along the axis 0 in each group (default).
|
|
>>> gb.take([0, 1])
|
1 4 falcon
|
3 parrot
|
2 2 lion
|
1 monkey
|
Name: name, dtype: object
|
|
We may take elements using negative integers for positive indices,
|
starting from the end of the object, just like with Python lists.
|
|
>>> gb.take([-1, -2])
|
1 3 parrot
|
4 falcon
|
2 0 rabbit
|
1 monkey
|
Name: name, dtype: object
|
©r rÄ ©r_ ©r ©ra r rÄ r} r¥ s rV r_ zSeriesGroupBy.takeÐ s& ðh $×#Ñ#ÐQ°GÀ$ÑQÈ&ÑQØ rU c ó |t j u rd}|dk7 r | j d|||d|¤}|S d } | j d|||d|¤S )aÎ
|
Return unbiased skew within groups.
|
|
Normalized by N-1.
|
|
Parameters
|
----------
|
axis : {0 or 'index', 1 or 'columns', None}, default 0
|
Axis for the function to be applied on.
|
This parameter is only for compatibility with DataFrame and is unused.
|
|
.. deprecated:: 2.1.0
|
For axis=1, operate on the underlying object instead. Otherwise
|
the axis keyword is not necessary.
|
|
skipna : bool, default True
|
Exclude NA/null values when computing the result.
|
|
numeric_only : bool, default False
|
Include only float, int, boolean columns. Not implemented for Series.
|
|
**kwargs
|
Additional keyword arguments to be passed to the function.
|
|
Returns
|
-------
|
Series
|
|
See Also
|
--------
|
Series.skew : Return unbiased skew over requested axis.
|
|
Examples
|
--------
|
>>> ser = pd.Series([390., 350., 357., np.nan, 22., 20., 30.],
|
... index=['Falcon', 'Falcon', 'Falcon', 'Falcon',
|
... 'Parrot', 'Parrot', 'Parrot'],
|
... name="Max Speed")
|
>>> ser
|
Falcon 390.0
|
Falcon 350.0
|
Falcon 357.0
|
Falcon NaN
|
Parrot 22.0
|
Parrot 20.0
|
Parrot 30.0
|
Name: Max Speed, dtype: float64
|
>>> ser.groupby(level=0).skew()
|
Falcon 1.525174
|
Parrot 1.457863
|
Name: Max Speed, dtype: float64
|
>>> ser.groupby(level=0).skew(skipna=False)
|
Falcon NaN
|
Parrot 1.457863
|
Name: Max Speed, dtype: float64
|
r ©rÄ Úskipnarf c ó2 t d| j « ©Nz"'skew' is not supported for dtype=©rl rk ©r] s rV Úaltz SeriesGroupBy.skew.<locals>.alts ó ô Ð @ÀÇÁÀ Ð LÓMÐ MrU ©r r rf ©Úskew©r Ú
|
no_defaultr Ú_cython_agg_general©ra rÄ r rf r} r¥ r s rV r£ zSeriesGroupBy.skew' s
ð~ 3>>Ñ !ØDà 19Ø'T×'Ñ'ØðàØ Ø )ñ ð
|
ñ Fð Mò Nð
|
(t×'Ñ'Ø ð
|
Ø F¸ ñ
|
ØIOñ
|
ð
|
rU c ó t | « }|S rx ©r- ©ra r¥ s rV ÚplotzSeriesGroupBy.plot| ó ô TÓ"Ø rU c ó~ t t j ||¬« }| j }| j ||d¬« }|S ©N)ÚnÚkeepT)rÞ )r r6 Únlargestri Ú_python_apply_general©ra r¯ r° r² rà r¥ s rV r± zSeriesGroupBy.nlargest s? ô FOO q¨tÔ 4Ø×(Ñ(ð ×+Ñ+¨A¨tÀdÐ+ÓKØ rU c ó~ t t j ||¬« }| j }| j ||d¬« }|S r® )r r6 Ú nsmallestri r² r³ s rV rµ zSeriesGroupBy.nsmallest sA ô F×$Ñ$¨°Ô 5Ø×(Ñ(ð ×+Ñ+¨A¨tÀdÐ+ÓKØ rU c ó* | j d||¬« S )NÚidxmin©rÄ r ©Ú_idxmax_idxmin©ra rÄ r s rV r· zSeriesGroupBy.idxmin ó ð ×"Ñ" 8°$¸vÐ"ÓFÐFrU c ó* | j d||¬« S )NÚidxmaxr¸ r¹ r» s rV r¾ zSeriesGroupBy.idxmax r¼ rU c ó0 | j d|||¬« }|S )NÚcorr)Úotherr Ú min_periodsr )ra rÁ r r r¥ s rV rÀ zSeriesGroupBy.corr¤ s) ð ×#Ñ#Ø %¨¸Kð $ó
|
ð rU c ó0 | j d|||¬« }|S )NÚcov)rÁ r Úddofr )ra rÁ r rÅ r¥ s rV rÄ zSeriesGroupBy.cov° s) ð ×#Ñ#Ø ¨K¸dð $ó
|
ð rU c ó& | j d « S )ax
|
Return whether each group's values are monotonically increasing.
|
|
Returns
|
-------
|
Series
|
|
Examples
|
--------
|
>>> s = pd.Series([2, 1, 3, 4], index=['Falcon', 'Falcon', 'Parrot', 'Parrot'])
|
>>> s.groupby(level=0).is_monotonic_increasing
|
Falcon False
|
Parrot True
|
dtype: bool
|
c ó | j S rx )Úis_monotonic_increasing©rn s rV r« z7SeriesGroupBy.is_monotonic_increasing.<locals>.<lambda>Ê ó c×&AÑ&A rU ©rz ©ra s rV rÈ z%SeriesGroupBy.is_monotonic_increasing¹ ó ð" zzÑAÓBÐBrU c ó& | j d « S )ax
|
Return whether each group's values are monotonically decreasing.
|
|
Returns
|
-------
|
Series
|
|
Examples
|
--------
|
>>> s = pd.Series([2, 1, 3, 4], index=['Falcon', 'Falcon', 'Parrot', 'Parrot'])
|
>>> s.groupby(level=0).is_monotonic_decreasing
|
Falcon True
|
Parrot False
|
dtype: bool
|
c ó | j S rx )Úis_monotonic_decreasingrÉ s rV r« z7SeriesGroupBy.is_monotonic_decreasing.<locals>.<lambda>Ý rÊ rU rË rÌ s rV rÐ z%SeriesGroupBy.is_monotonic_decreasingÌ rÍ rU c óD | j d||||||||| |
|
| d | ¤} | S )N) ÚbyÚaxÚgridÚ
|
xlabelsizeÚxrotÚ
|
ylabelsizeÚyrotÚfigsizer@ ÚbackendÚlegend©Úhistr )ra rÒ rÓ rÔ rÕ rÖ r× rØ rÙ r@ rÚ rÛ r} r¥ s rV rÝ zSeriesGroupBy.histß sP ð $×#Ñ#Ø ð
|
àØØØ!ØØ!ØØØØØñ
|
ð ñ
|
ð rU c ó& | j d « S )Nc ó | j S rx r rÉ s rV r« z%SeriesGroupBy.dtype.<locals>.<lambda> s
|
c§i¡i rU rË rÌ s rV rk zSeriesGroupBy.dtype s ð zzÑ/Ó0Ð0rU c ó( | j d« }|S )ac
|
Return unique values for each group.
|
|
It returns unique values for each of the grouped values. Returned in
|
order of appearance. Hash table-based unique, therefore does NOT sort.
|
|
Returns
|
-------
|
Series
|
Unique values for each of the grouped values.
|
|
See Also
|
--------
|
Series.unique : Return unique values of Series object.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([('Chihuahua', 'dog', 6.1),
|
... ('Beagle', 'dog', 15.2),
|
... ('Chihuahua', 'dog', 6.9),
|
... ('Persian', 'cat', 9.2),
|
... ('Chihuahua', 'dog', 7),
|
... ('Persian', 'cat', 8.8)],
|
... columns=['breed', 'animal', 'height_in'])
|
>>> df
|
breed animal height_in
|
0 Chihuahua dog 6.1
|
1 Beagle dog 15.2
|
2 Chihuahua dog 6.9
|
3 Persian cat 9.2
|
4 Chihuahua dog 7.0
|
5 Persian cat 8.8
|
>>> ser = df.groupby('animal')['breed'].unique()
|
>>> ser
|
animal
|
cat [Persian]
|
dog [Chihuahua, Beagle]
|
Name: breed, dtype: object
|
Úuniquer rª s rV rá zSeriesGroupBy.unique s ðP ×#Ñ# HÓ-Ø rU )rb rC r r6 )rf r r_ ú
|
str | Noner rE ©r r6 rx ©r r) ©FF)
|
rà r6 rÐ z list[Any]rÞ r rß r r úDataFrame | Series©Fr )r r rf r rÄ r? )r{ r r r6 ©T©r r )r r r úSeries | DataFrame)NNN)FTFNT)
|
r< r r! r r= r r r r rê )r zobject | ArrayLike | Noner úFillnaOptions | NonerÄ úAxis | None | lib.NoDefaultr r r ú
|
int | Noner zdict | None | lib.NoDefaultr z Series | None)r rF rÄ úAxis | lib.NoDefaultr r6 )rÄ rî r r rf r r r6 ©r r- )é r% )r¯ Úintr° z Literal['first', 'last', 'all']r r6 )rÄ rî r r r r6 )ÚpearsonN)rÁ r6 r r@ r rí r r6 ©Nr )rÁ r6 r rí rÅ rí r r6 ) NNTNNNNNé
|
NF)rÔ r rÕ rí rÖ ú float | Noner× rí rØ rõ rÙ útuple[int, int] | Noner@ úint | Sequence[int]rÚ râ rÛ r )2rO rP rQ rd rq r Ú_agg_examples_docr r0 Úformatrz r r/ r¦ Úaggr r rè r Ú#_SeriesGroupBy__examples_series_docr r1 rù r r r r3 r6 r8 r] r r¥ r r_ r£ Úpropertyr« rR r± rµ r· r¾ rÀ rÄ rÈ rÐ rÝ rk rá Ú __classcell__©r~ s @rV rX rX s§ ø óð ',Àñ Ø #ð Ø3=ð à ó ñ ð. ó0Ðñd ØJÑ ×&Ñ&Ø [Ð1BÑ%Cð 'ó
|
óô
|
4ó ð
|
4ñ Ð Ð(9ÀÔJðQ °ÀTó Q ó KðQ ðf Cò 1ó-ðf "'Ø "ð E0àðE0ð ðE0ð ð E0ð
|
ð E0ð
|
ó E0òNñ, #ð' ó) ÐñV Ð*?Ô@Ù Ð!Ó"Ø,0Àó
|
ó #ó Að
|
ð EFðMØðMØ&*ðMØ:AóMð"!Ø ð!à ó!ôF<ô|J:ñX Óõ
|
ó ð
|
ð ØØ Ø Øð _àð_ð ð_ð ð _ð ð _ð
|
ó_ðF ,0Ø'+Ø,/¯N©NØ Ø Ø03·±ð`à(ð`ð %ð`ð *ð `ð
|
ð `ð ð `ð .ð`ð
|
ó`ðJ &)§^¡^ðUà ðUð #ðUð
|
|
ó Uðr &)§^¡^ØØ "ð S
|
à"ðS
|
ð ðS
|
ð ð S
|
ð
|
ó S
|
ðj Ù× Ñ Ó òó ó ðñ × Ñ Ó!àBIðØðØ ?ðà òó "ðñ × Ñ × !Ñ !Ó"àBIðØðØ ?ðà òó #ðñ × Ñ Ó à+.¯>©>È$ðGØ(ðGØCGðGà òGó ðGñ
|
× Ñ Ó à+.¯>©>È$ðGØ(ðGØCGðGà òGó ðGñ
|
× Ñ Ó ð %.Ø"&ð àð ð "ð ð ð ð
|
|
ò ó ð ñ × Ñ Ó àPQðØðØ*4ðØCMðà òó ðð òCó ðCð$ òCó ðCñ$ × Ñ Ó ð Ø ØØ!%Ø !Ø!%Ø !Ø*.Ø$&Ø "Ø ð ð ð ð
|
ð ð ð ð ð ð ð ð (ð ð "ð ð ð ð ò ó ð ð@ Ù × Ñ Ó ò1ó ó ð1÷)rU rX c ó e Zd Z ed« Z eeed¬« d)dddd« ZeZd Z d*dZ
|
d+ d,d
|
Z d-d Z d. d/d Z d Z ed« Z ede¬« ee« dddd« « Zd Zd0dZd1d2dZd3 fd Zd)d4dZd dd d5dZd6dZd*dZd1d7dZ e j< dd f d8d Z e j< dd f d8d Z e!Z" d9 d:d Z#dde j< d de j< f d;d Z$e j< f d<d Z%e j< dd f d8d!Z&e' ee(jR jT « d=d"« « Z) ee(jV jT « d> d?d$« Z+ ee(jX jT « d@ dAd%« Z, ee(jZ jT « dB dCd&« Z-e' ee(j\ jT « dDd'« « Z. ee(j^ jT « e j< d d#d f dEd(« Z/ xZ0S )FÚDataFrameGroupBya
|
Examples
|
--------
|
>>> data = {"A": [1, 1, 2, 2],
|
... "B": [1, 2, 3, 4],
|
... "C": [0.362838, 0.227877, 1.267767, -0.562860]}
|
>>> df = pd.DataFrame(data)
|
>>> 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
|
|
User-defined function for aggregation
|
|
>>> df.groupby('A').agg(lambda x: sum(x) + 2)
|
B C
|
A
|
1 5 2.590715
|
2 9 2.704907
|
|
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.0
|
r) r Nr c óJ t |fi |¤\ }}}}t |« }t |« r
|
||d< ||d< t | |||¬« } | j « }
|
t |« s+|
|
)| j st |« r|
|
j « S |
|
S |r:t t |
|
« }
|
|
|
j d d
|f }
|
t t |
|
« }
|
||
|
_ |
|
ód|v r|d= |d= t |« r | j |g|¢d|i|¤S | j j dkD r | j |g|¢i |¤S |s|r | j" |g|¢i |¤}
|
n|| j$ dk( r| j# |« }
|
|
|
S t | |gdi ¬« } | j « }
|
t t |
|
« }
|
| j& j j) « |
|
_ | j s*| j/ |
|
« }
|
t1 t3 |
|
« « |
|
_ |
|
S # t* $ r)} dt- | « vr | j# |« }
|
Y d } ~ ed } ~ ww xY w)Nr r )r| r} r rT zNo objects to concatenate)r& r% r8 r$ rú r r r r r r) Úilocr r r r r Ú_aggregate_framerÄ ri rG r r rå r5 rá r ) ra r{ r r r| r} r¢ r ÚorderÚopr¥ Úgbar s rV r¦ zDataFrameGroupBy.aggregate sA ä+;¸DÑ+KÀFÑ+KÑ(
|
D' 5Ü# DÓ)ä 6Ô "ð &F8Ñ Ø&3F?Ñ #ä $ ¨4¸Ô ?ØÜDÔ! fÐ&8à==¤\°$Ô%7Ø ×)Ñ)Ó+Ð+à Ù ô ) VÓ,FØ[[¢ E Ñ*FÜ) VÓ,Fð
|
%FNà >ð 6Ñ!Ø8Ð$Ø?Ð+ô vÔ&Ø1t×1Ñ1ØðØ òØ/<ðØ@Fñð ð }}×"Ñ" QÒ&à/t×/Ñ/°ÐF°tÒF¸vÑFÐFÙð /×.Ñ.¨tÐE°dÒE¸fÑEàa ð ×.Ñ.¨tÓ4Ø ô # 4¨$¨°bÀÔDðNØ WWYFô "¤)¨VÓ 4FØ%)×%>Ñ%>×%FÑ%F×%KÑ%KÓ%MFNà}}Ø×0Ñ0°Ó8FÜ(¬¨V«Ó5FLà øô+ "ò 9Ø2¼#¸c»(ÑBØ ð "× 2Ñ 2°4Ó 8Fûð 9ús Å/G0 Ç0 H"Ç9 H È H"c óÀ }t j « |k7 r t j }t | ||« fd}| j dk( r | j || j d¬« S | j }| j dk( r |j }t |j « s | j || j « S i }t |j « « D ]) \ } \ }
|
} | j j | |« } | || < + | j j# |« } |j j% d¬« | _ | j' | « S )Nc ó | g¢i ¤S rx rT r© s rV r« z6DataFrameGroupBy._python_agg_general.<locals>.<lambda>ë r¬ rU r T©Úis_aggr F)Údeep)r r r® r( r r² Ú _selected_objri rÄ ÚTrá r rÎ rÊ r r¯ r] r rG r¡ )ra r{ r| r} r° r± r² r] rÚ rÖ r_ rn r¥ r³ s ``` rV r z$DataFrameGroupBy._python_agg_generalå s8 ú Ø Ü×"Ñ" 4Ó(Ø Ò Ü×,Ñ,¨TÑ2EÜ " 4¨°EÔ :Ý .à <<1Ò ð ×-Ñ-¨a°×1CÑ1CÈDÐ-ÓQÐ Qà×'Ñ'Ø 99>Ø%%Cä3;;Ô à×-Ñ-¨a°×1CÑ1CÓDÐ Dà')Ü )¨#¯)©)«+Ó 6ò !Ñ C$Ø]]×-Ñ-¨c°1Ó5FØ F3Kð !ð hh×#Ñ# FÓ+Økk×&Ñ&¨EÐ&Ó2 Ø×+Ñ+¨CÓ0Ð0rU c ó¾ | j j dk7 r t d« | j }i }| j j || j
|
« D ] \ }} ||g|¢i |¤}|||< | j j } |j d| j
|
z
|
}
|
| j j ||
|
| ¬« } | j
|
dk( r | j } | S )Nr zNumber of keys must be 1©r r r ) r r ÚAssertionErrorri rë rÄ r r\ r] r r ) ra r{ r| r} r] r¥ r_ Úgrp_dfÚfresr Úother_axrc s rV r z!DataFrameGroupBy._aggregate_frame sÐ Ø ==× Ñ !Ò #Ü Ð!;Ó<Ð <à×'Ñ'à79Ø MM× 6Ñ 6°s¸D¿I¹IÓ Fò LD&ÙÐ0 Ò0¨Ñ0DØ F4Lð ð }}×1Ñ1 Ø88A § ¡ MÑ*Øhh×#Ñ# F°(ÀLÐ#ÓQØ 99>Ø%%Cà
|
rU Fc óð t |« dk( rk|r |j }n| j j }| j j ||j ¬« }|j |j d¬« }|S t t j | d « }|| j j « S t |t « r| j |||¬« S | j r| j j nd }t |t j" t$ f« rUt' | j( « st+ | j( « } n | j( } | j j- ||| ¬« S t |t. « sd| j r | j j- ||¬« S | j j || j( g¬« }| j1 |« }|S | j3 |||||« S ) Nr r FrF rÝ rü r )r )rá r r r r] r r rl ÚdtypesÚnextr Únot_noner r) rä r r
|
Úndarrayr2 r Ú
|
_selectionr¸ Ú_constructor_slicedr6 rå Ú_wrap_applied_output_series)
|
ra rà rÐ rÞ rß ræ r¥ Úfirst_not_noneÚ key_indexr_ s
|
rV rè z%DataFrameGroupBy._wrap_applied_output s³ ô v;!Ò Ùà JJ à MM× 6Ñ 6 àXX×*Ñ*°ÀDÇLÁLÐ*ÓQFØ]] 4§;¡;°U]Ó;FØMô cll¨FÐ 3°TÓ:à Ð !à88×(Ñ(Ó*Ð *Ü ¬ Ô 2Ø×'Ñ'ØØ!1Ø )ð (ó ð ð 37·-²-DMM×.Ò.ÀT ä n¤r§z¡z´5Ð&9Ô :ô tÔ/ä T__Ó-ð
|
Ø88×/Ñ/°¸iÈdÐ/ÓSÐ SÜN¬FÔ3ð
|
}}Øxx×3Ñ3°FÀ)Ð3ÓLÐLà ×.Ñ.¨vÀÇÁÐ?PÐ.ÓQØ ×4Ñ4°VÓ<Ø ð ×3Ñ3ØØ Ø ØØ ó ð rU c ó: |j « }t di |¤}|D cg c] }||n|
|
}}t d |D « « } | s| j |d|¬« S t j
|
|D
|
cg c] }
|
t j |
|
« c}
|
« } | j dk( ri|} |j j « } | j [|D
|
ch c] }
|
|
|
j }}
|
t |« dk( r4t t |« « | _
|
n|j } |} | j } | j t k( r| j# « } | j$ j' | | | ¬« }| j( s| j+ |« }| j- |« S c c}w c c}
|
w c c}
|
w )Nc 3 ó4 K | ] }|j y wrx r rº s rV r¼ z?DataFrameGroupBy._wrap_applied_output_series.<locals>.<genexpr>h s è ø Ò+D¸¨A¯GGÑ+DùrÈ TrÝ r r r rT )Ú_construct_axes_dictr6 r4 rä r
|
ÚvstackÚasarrayrÄ r rG r_ rá r Úiterr rk rì Útolistr] r r rå râ )ra rÐ rÞ r r rß r} Úbackuprª Úall_indexed_sameÚvÚstacked_valuesr r rV r¥ s rV r z,DataFrameGroupBy._wrap_applied_output_series\ s ð ×4Ñ4Ó6ÜÑ!&Ñ!Ø<BÖC°q !¨FÑ2ÐCÐCä+Ñ+D¸VÔ+DÓDÐá à×'Ñ'ØØ!%Ø )ð (ó ð ô ¸6Ö#B°a¤B§J¡J¨q¥MÒ#BÓCà 99>Ø EØ$×*Ñ*×/Ñ/Ó1GØ||Ð#à)/Ö0 AÐ0Ð0Üu: ?Ü#'¬¨U« Ó#4GLà"×(Ñ(EØ GØ +× -Ñ -Nà × Ñ ¤6Ò )à +× 2Ñ 2Ó 4NØ×&Ñ& ~¸UÈGÐ&ÓTà}}Ø×0Ñ0°Ó8Fà×#Ñ# FÓ+Ð+ùòK Dùò $Cùò 1s FÁ* FÃFc ó |dk( sJ j |¬« }d fd }|j |« }|j d|j d « j j ||j ¬« } j |« }|S )Nr re c óD j j d| dfi ¤S )Nrù r )r rý )Úbvaluesr r} ra s rV Úarr_funcz4DataFrameGroupBy._cython_transform.<locals>.arr_func s- ø Ø24==×2Ñ2ØW c¨1ñØ06ñð rU r r[ )r+ r= r r= )rq Úgrouped_reduceÚset_axisr\ r] r^ Ú_maybe_transpose_result) ra r rf rÄ r} rb r, Úres_mgrr× s `` ` rV r z"DataFrameGroupBy._cython_transform s ú ð qyÐyð ×4Ñ4Ø%¨Cð 5ó
|
÷ ð ×$Ñ$ XÓ.Ø×ÑCHH QKÔ(à×/Ñ/°¸g¿l¹lÐ/ÓKØ×-Ñ-¨fÓ5Ø rU c óà t |« r | j |g|¢d|i|¤S ddlm} g }| j }| j
|
j || j ¬« } | j |g|¢i |¤\ }
|
} t | « \ } } t j | d| « | j |
|
| | « \ }}| j dkD r)t | j | |« }|j# |« | D ]\ \ } } | j dk( rt j | d| « | « }t | j | |« }|j# |« ^ | j dk( r |j& n |j( }| j dk( rdnd} ||| j d¬ « }|j+ ||d¬
|
« }| j- |« S # t $ r}d}t |« |d }~ww xY w# t$ $ r Y ÿw xY w) Nr r r rê r_ z3transform must return a scalar value for each groupr F)rÄ rW )rÄ rG )r8 r r rà ri r rë rÄ Ú _define_pathsr rì rí Ú _choose_pathr ÚsizeÚ _wrap_transform_general_framer] r Ú StopIterationr r Úreindexr )ra r{ r r r| r} rà Úappliedr] ÚgenÚ fast_pathÚ slow_pathr_ rñ Úpathr³ r rÔ Ú concat_indexÚ
|
other_axisr s rV r z#DataFrameGroupBy._transform_general sô Ü 6Ô "Ø-4×-Ñ-ØðØòØ+8ðØ<Bñð õ 6àØ×'Ñ'Ømm×(Ñ(¨°4·9±9Ð(Ó=Ø 1t× 1Ñ 1°$Ð H¸Ò HÀÑ HÑ 9ð
|
$Ü s)KD%ô
|
× Ñ u f¨dÔ 3ð /Ø × -Ñ -¨i¸ÀEÓ J cð
|
zzA~Ü3°D·H±H¸eÀSÓIØsÕ#ð ò KD%ØzzQØä × Ñ u f¨dÔ 3Ùu+Cä/°·±¸%ÀÓECØ NN3Õ ð ð '+§i¡i°1¢ns{{¸#¿)¹) Ø )) q.Q¨a
|
Ù g¨D¯I©IÈÔN Ø#×+Ñ+¨L¸zÐPUÐ+ÓV Ø×-Ñ-¨lÓ;Ð;øô/ ò /àKÜ o¨3Ð.ûð /ûô ò Ù ð ús* Á9G!  G Ç G Ç GÇG Ç! G-Ç,G-a
|
>>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
|
... 'foo', 'bar'],
|
... 'B' : ['one', 'one', 'two', 'three',
|
... 'two', 'two'],
|
... 'C' : [1, 5, 5, 2, 5, 5],
|
... 'D' : [2.0, 5., 8., 1., 2., 9.]})
|
>>> grouped = df.groupby('A')[['C', 'D']]
|
>>> grouped.transform(lambda x: (x - x.mean()) / x.std())
|
C D
|
0 -1.154701 -0.577350
|
1 0.577350 0.000000
|
2 0.577350 1.154701
|
3 -1.154701 -1.000000
|
4 0.577350 -0.577350
|
5 0.577350 1.000000
|
|
Broadcast result of the transformation
|
|
>>> grouped.transform(lambda x: x.max() - x.min())
|
C D
|
0 4.0 6.0
|
1 3.0 8.0
|
2 4.0 6.0
|
3 3.0 8.0
|
4 4.0 6.0
|
5 3.0 8.0
|
|
>>> grouped.transform("mean")
|
C D
|
0 3.666667 4.0
|
1 4.000000 5.0
|
2 3.666667 4.0
|
3 4.000000 5.0
|
4 3.666667 4.0
|
5 4.000000 5.0
|
|
.. versionchanged:: 1.3.0
|
|
The resulting dtype will reflect the return value of the passed ``func``,
|
for example:
|
|
>>> grouped.transform(lambda x: x.astype(int).max())
|
C D
|
0 5 8
|
1 5 9
|
2 5 8
|
3 5 9
|
4 5 8
|
5 5 9
|
rò c ó4 | j |g|¢||d|¤S rõ rö rø s rV rù zDataFrameGroupBy.transform rú rU c óv t t « rfd} fd}||fS fd} fd}||fS )Nc ó( t | « i ¤S rx r ©rñ r| r{ r} s rV r« z0DataFrameGroupBy._define_paths.<locals>.<lambda> s ø Ð&:¤g¨e°TÓ&:¸DÐ&KÀFÑ&K rU c óH | j fdj ¬« S )Nc ó( t | « i ¤S rx r r© s rV r« zBDataFrameGroupBy._define_paths.<locals>.<lambda>.<locals>.<lambda> s ø Ð*' ! TÓ*¨DÐ;°FÑ; rU rê ©rz rÄ ©rñ r| r{ r} ra s rV r« z0DataFrameGroupBy._define_paths.<locals>.<lambda> s ø e§k¡kÝ;À$Ç)Á)ð '2ó ' rU c ó | g¢i ¤S rx rT rB s rV r« z0DataFrameGroupBy._define_paths.<locals>.<lambda>" s ø ¡d¨5Ð&B°4Ò&B¸6Ñ&B rU c óH | j fdj ¬« S )Nc ó | g¢i ¤S rx rT r© s rV r« zBDataFrameGroupBy._define_paths.<locals>.<lambda>.<locals>.<lambda>$ s ø $qÐ2 4Ò2¨6Ñ2 rU rê rE rF s rV r« z0DataFrameGroupBy._define_paths.<locals>.<lambda># s ø e§k¡kÝ2¸¿¹ð '2ó ' rU )r r )ra r{ r| r} r: r; s ```` rV r2 z DataFrameGroupBy._define_paths sB û Ü dCÔ ÝKIöIð )Ð#Ð#õ CIöIð )Ð#Ð#rU c ó |} ||« }| j dk( r||fS ||« }t |t « r)|j
|
j |j
|
« sA||fS t |t « r)|j j |j
|
« s||fS ||fS |j |« r|}||fS # t $ r t $ r ||fcY S w xY wró ) r r Ú Exceptionr r) r Úequalsr6 r )ra r: r; rñ r< r³ Úres_fasts rV r3 z DataFrameGroupBy._choose_path( sÝ ØÙÓ à <<1Ò ð 9Ð ð Ù Ó'Hô h¤ Ô *Ø×#Ñ#×*Ñ*¨5¯=©=Ô9ØSyÐ Ü ¤&Ô )Ø>>×(Ñ(¨¯ © Ô7ØSyÐ à9Ð à ??3Ô Ø DàSyÐøô- ò Ø Üò ð 9Ò ð ús B4 Â4C à C Tc ó g }| j }| j j || j ¬« }|D ]« \ }} t j | d|« || g|¢i |¤}
|
|
|
j « }
|
t |
|
« st |
|
« r;t |
|
« r0t |
|
« sg|
|
sj|j | j |« « t dt |
|
« j d« | j# ||« S # t $ r Y w xY w)a7
|
Filter elements from groups that don't satisfy a criterion.
|
|
Elements from groups are filtered if they do not satisfy the
|
boolean criterion specified by func.
|
|
Parameters
|
----------
|
func : function
|
Criterion to apply to each group. Should return True or False.
|
dropna : bool
|
Drop groups that do not pass the filter. True by default; if False,
|
groups that evaluate False are filled with NaNs.
|
|
Returns
|
-------
|
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)r r rë rÄ rì rí ÚsqueezeÚAttributeErrorr r r! r" r r rl rm rO r ) ra r{ r r| r} r r] r9 r_ rñ r³ s rV r zDataFrameGroupBy.filterL s ðR à× Ñ Ømm×(Ñ(¨°4·9±9Ð(Ó=à ò KD%ô × Ñ u f¨dÔ 3áuÐ.tÒ. vÑ.Cð Økkmô
|
s|¤ ¨#¤´4¸´9Ü:¢#ØNN 4§?¡?°4Ó#8Õ9ô Ø1´$°s³)×2DÑ2DÐ1Eð F1ð 1óð ð% ð. ×!Ñ! '¨6Ó2Ð2øô "ò Ùð ús Á"C8Ã8 DÄDc ó¨ | j dk( r t d« t |t « rt |« dkD r t d« t
|
| |« S )Nr z'Cannot subset columns when using axis=1zRCannot subset columns with a tuple with more than one element. Use a list instead.)rÄ r r r¸ rá ry Ú __getitem__)ra rÇ r~ s rV rR z DataFrameGroupBy.__getitem__ sT ø Ø 99>ä Ð FÓGÐ Gä c5Ô !¤c¨#£h°¢lô ð&óð ô wÑ" 3Ó'Ð'rU c ó@ |dk( r| | j }t || j | j | j | j
|
| j || j | j | j | j | j ¬« S |dk( r|| j | }t || j | j | j
|
| j || j | j | j | j | j ¬« S t d« )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Ä ÚlevelÚgrouperÚ
|
exclusionsÚ selectionr r! Ú
|
group_keysÚobservedr r ) rU rV rW rX r r! rY rZ r zinvalid ndim for _gotitem)r] r rÅ rÄ rU r rW r r! rY rZ r rX r )ra rÇ ÚndimÚsubsets rV Ú_gotitemzDataFrameGroupBy._gotitem¡ sí ð 19Ø~Ø Ü#ØØ ØYYØjjØ Ø ??Ø Ø ØYYØ ??Ø Ø{{ô ð ð QYØ~Ø # Ü ØØ ØjjØ Ø ??Ø Ø ØYYØ ??Ø Ø{{ô ð ô Ð 8Ó9Ð9rU re c ó¦ | j }| j dk( r|j j }n |j }|r|j « }|S ró )ri rÄ r rj Úget_numeric_data)ra rf r_ r] rb s rV rq z'DataFrameGroupBy._get_data_to_aggregateÒ sF ð ×'Ñ'Ø 99>Ø%%**Cà((Cá Ø×&Ñ&Ó(CØ
|
rU c óP | j j ||j ¬« S rZ )r] r^ r\ )ra rb s rV rd z$DataFrameGroupBy._wrap_agged_managerß s Øxx×-Ñ-¨c¸¿¹Ð-ÓAÐArU c ó( ddl m} | j }|j }t |j « D cg c]D \ }}t |j d d
|f || j | j | j ¬« F }}}|D cg c]
|
} ||« } }t | « s#t g || j j ¬« }
|
n || |d¬« }
|
| j s*t t |
|
« « |
|
_ | j! |
|
« }
|
|
|
S c c}}w c c}w )Nr r )rX rV rW rZ ©r r r )rÅ rÄ )r rà ri r rÎ rX r r rW rZ rá r) r r r5 r rå ) ra r{ rà r] r ÚiÚcolnameÚsgbsÚsgbrÕ r× s rV Ú_apply_to_column_groupbysz*DataFrameGroupBy._apply_to_column_groupbysâ sï Ý5à×'Ñ'Ø++ô (¨¯ © Ó 4÷
|
ñ 7ô ØAØ!Ø Ø ??Ø ö ð
|
ñ
|
ð )-Ö- 49Ð-Ð-ä7|ä r¨7¸$¿-¹-×:TÑ:TÔUFáG¨'¸Ô:Fà}}Ü(¬¨V«Ó5FLØ×0Ñ0°Ó8FØ ùó+
|
ùò .s ·A D ÂDc ó | j dk7 r!| j fd| j d¬« S | j fd« 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
|
r c ó& | j « S rx ©r3 ©rf r s rV r« z*DataFrameGroupBy.nunique.<locals>.<lambda>. s ø CKK¨Ó / rU Tr c ó& | j « S rx rj rk s rV r« z*DataFrameGroupBy.nunique.<locals>.<lambda>1 s ø ¸#¿+¹+ÀfÓ:M rU )rÄ r² ri rg )ra r s `rV r3 zDataFrameGroupBy.nuniqueþ sK ø ðZ 99>à×-Ñ-Û/°×1JÑ1JÐSWð .ó ð ð ×-Ñ-Ó.MÓNÐNrU c ó, | j d|||¬« S )aÈ
|
Return index of first occurrence of maximum over requested axis.
|
|
NA/null values are excluded.
|
|
Parameters
|
----------
|
axis : {{0 or 'index', 1 or 'columns'}}, default None
|
The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
|
If axis is not provided, grouper's axis is used.
|
|
.. versionchanged:: 2.0.0
|
|
.. deprecated:: 2.1.0
|
For axis=1, operate on the underlying object instead. Otherwise
|
the axis keyword is not necessary.
|
|
skipna : bool, default True
|
Exclude NA/null values. If an entire row/column is NA, the result
|
will be NA.
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
Returns
|
-------
|
Series
|
Indexes of maxima along the specified axis.
|
|
Raises
|
------
|
ValueError
|
* If the row/column is empty
|
|
See Also
|
--------
|
Series.idxmax : Return index of the maximum element.
|
|
Notes
|
-----
|
This method is the DataFrame version of ``ndarray.argmax``.
|
|
Examples
|
--------
|
Consider a dataset containing food consumption in Argentina.
|
|
>>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
|
... 'co2_emissions': [37.2, 19.66, 1712]},
|
... index=['Pork', 'Wheat Products', 'Beef'])
|
|
>>> df
|
consumption co2_emissions
|
Pork 10.51 37.20
|
Wheat Products 103.11 19.66
|
Beef 55.48 1712.00
|
|
By default, it returns the index for the maximum value in each column.
|
|
>>> df.idxmax()
|
consumption Wheat Products
|
co2_emissions Beef
|
dtype: object
|
|
To return the index for the maximum value in each row, use ``axis="columns"``.
|
|
>>> df.idxmax(axis="columns")
|
Pork co2_emissions
|
Wheat Products consumption
|
Beef co2_emissions
|
dtype: object
|
r¾ ©rÄ rf r r¹ ©ra rÄ r rf s rV r¾ zDataFrameGroupBy.idxmax3 ó& ð\ ×"Ñ"Ø 4¨lÀ6ð #ó
|
ð
|
rU c ó, | j d|||¬« S )aË
|
Return index of first occurrence of minimum over requested axis.
|
|
NA/null values are excluded.
|
|
Parameters
|
----------
|
axis : {{0 or 'index', 1 or 'columns'}}, default None
|
The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
|
If axis is not provided, grouper's axis is used.
|
|
.. versionchanged:: 2.0.0
|
|
.. deprecated:: 2.1.0
|
For axis=1, operate on the underlying object instead. Otherwise
|
the axis keyword is not necessary.
|
|
skipna : bool, default True
|
Exclude NA/null values. If an entire row/column is NA, the result
|
will be NA.
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
Returns
|
-------
|
Series
|
Indexes of minima along the specified axis.
|
|
Raises
|
------
|
ValueError
|
* If the row/column is empty
|
|
See Also
|
--------
|
Series.idxmin : Return index of the minimum element.
|
|
Notes
|
-----
|
This method is the DataFrame version of ``ndarray.argmin``.
|
|
Examples
|
--------
|
Consider a dataset containing food consumption in Argentina.
|
|
>>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
|
... 'co2_emissions': [37.2, 19.66, 1712]},
|
... index=['Pork', 'Wheat Products', 'Beef'])
|
|
>>> df
|
consumption co2_emissions
|
Pork 10.51 37.20
|
Wheat Products 103.11 19.66
|
Beef 55.48 1712.00
|
|
By default, it returns the index for the minimum value in each column.
|
|
>>> df.idxmin()
|
consumption Pork
|
co2_emissions Wheat Products
|
dtype: object
|
|
To return the index for the minimum value in each row, use ``axis="columns"``.
|
|
>>> df.idxmin(axis="columns")
|
Pork consumption
|
Wheat Products co2_emissions
|
Beef consumption
|
dtype: object
|
r· rn r¹ ro s rV r· zDataFrameGroupBy.idxmin
rp rU c ó, | j |||||« S )a(
|
Return a Series or DataFrame containing counts of unique rows.
|
|
.. versionadded:: 1.4.0
|
|
Parameters
|
----------
|
subset : list-like, optional
|
Columns to use when counting unique combinations.
|
normalize : bool, default False
|
Return proportions rather than frequencies.
|
sort : bool, default True
|
Sort by frequencies.
|
ascending : bool, default False
|
Sort in ascending order.
|
dropna : bool, default True
|
Don't include counts of rows that contain NA values.
|
|
Returns
|
-------
|
Series or DataFrame
|
Series if the groupby as_index is True, otherwise DataFrame.
|
|
See Also
|
--------
|
Series.value_counts: Equivalent method on Series.
|
DataFrame.value_counts: Equivalent method on DataFrame.
|
SeriesGroupBy.value_counts: Equivalent method on SeriesGroupBy.
|
|
Notes
|
-----
|
- If the groupby as_index is True then the returned Series will have a
|
MultiIndex with one level per input column.
|
- If the groupby as_index is False then the returned DataFrame will have an
|
additional column with the value_counts. The column is labelled 'count' or
|
'proportion', depending on the ``normalize`` parameter.
|
|
By default, rows that contain any NA values are omitted from
|
the result.
|
|
By default, the result will be in descending order so that the
|
first element of each group is the most frequently-occurring row.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({
|
... 'gender': ['male', 'male', 'female', 'male', 'female', 'male'],
|
... 'education': ['low', 'medium', 'high', 'low', 'high', 'low'],
|
... 'country': ['US', 'FR', 'US', 'FR', 'FR', 'FR']
|
... })
|
|
>>> df
|
gender education country
|
0 male low US
|
1 male medium FR
|
2 female high US
|
3 male low FR
|
4 female high FR
|
5 male low FR
|
|
>>> df.groupby('gender').value_counts()
|
gender education country
|
female high FR 1
|
US 1
|
male low FR 2
|
US 1
|
medium FR 1
|
Name: count, dtype: int64
|
|
>>> df.groupby('gender').value_counts(ascending=True)
|
gender education country
|
female high FR 1
|
US 1
|
male low US 1
|
medium FR 1
|
low FR 2
|
Name: count, dtype: int64
|
|
>>> df.groupby('gender').value_counts(normalize=True)
|
gender education country
|
female high FR 0.50
|
US 0.50
|
male low FR 0.50
|
US 0.25
|
medium FR 0.25
|
Name: proportion, dtype: float64
|
|
>>> df.groupby('gender', as_index=False).value_counts()
|
gender education country count
|
0 female high FR 1
|
1 female high US 1
|
2 male low FR 2
|
3 male low US 1
|
4 male medium FR 1
|
|
>>> df.groupby('gender', as_index=False).value_counts(normalize=True)
|
gender education country proportion
|
0 female high FR 0.50
|
1 female high US 0.50
|
2 male low FR 0.50
|
3 male low US 0.25
|
4 male medium FR 0.25
|
)rY )ra r\ r< r! r= r s rV r] z DataFrameGroupBy.value_countsÙ s ð^ ×!Ñ! &¨)°T¸9ÀfÓMÐMrU c óê t j t | « j dt | j « j dt
|
t « ¬« | j d||||||¬« }|S )a)
|
Fill NA/NaN values using the specified method within groups.
|
|
.. deprecated:: 2.2.0
|
This method is deprecated and will be removed in a future version.
|
Use the :meth:`.DataFrameGroupBy.ffill` or :meth:`.DataFrameGroupBy.bfill`
|
for forward or backward filling instead. If you want to fill with a
|
single value, use :meth:`DataFrame.fillna` instead.
|
|
Parameters
|
----------
|
value : scalar, dict, Series, or DataFrame
|
Value to use to fill holes (e.g. 0), alternately a
|
dict/Series/DataFrame of values specifying which value to use for
|
each index (for a Series) or column (for a DataFrame). Values not
|
in the dict/Series/DataFrame will not be filled. This value cannot
|
be a list. Users wanting to use the ``value`` argument and not ``method``
|
should prefer :meth:`.DataFrame.fillna` as this
|
will produce the same result and be more performant.
|
method : {{'bfill', 'ffill', None}}, default None
|
Method to use for filling holes. ``'ffill'`` will propagate
|
the last valid observation forward within a group.
|
``'bfill'`` will use next valid observation to fill the gap.
|
axis : {0 or 'index', 1 or 'columns'}
|
Axis along which to fill missing values. When the :class:`DataFrameGroupBy`
|
``axis`` argument is ``0``, using ``axis=1`` here will produce
|
the same results as :meth:`.DataFrame.fillna`. When the
|
:class:`DataFrameGroupBy` ``axis`` argument is ``1``, using ``axis=0``
|
or ``axis=1`` here will produce the same results.
|
inplace : bool, default False
|
Broken. Do not set to True.
|
limit : int, default None
|
If method is specified, this is the maximum number of consecutive
|
NaN values to forward/backward fill within a group. In other words,
|
if there is a gap with more than this number of consecutive NaNs,
|
it will only be partially filled. If method is not specified, this is the
|
maximum number of entries along the entire axis where NaNs will be
|
filled. Must be greater than 0 if not None.
|
downcast : dict, default is None
|
A dict of item->dtype of what to downcast if possible,
|
or the string 'infer' which will try to downcast to an appropriate
|
equal type (e.g. float64 to int64 if possible).
|
|
Returns
|
-------
|
DataFrame
|
Object with missing values filled.
|
|
See Also
|
--------
|
ffill : Forward fill values within a group.
|
bfill : Backward fill values within a group.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame(
|
... {
|
... "key": [0, 0, 1, 1, 1],
|
... "A": [np.nan, 2, np.nan, 3, np.nan],
|
... "B": [2, 3, np.nan, np.nan, np.nan],
|
... "C": [np.nan, np.nan, 2, np.nan, np.nan],
|
... }
|
... )
|
>>> df
|
key A B C
|
0 0 NaN 2.0 NaN
|
1 0 2.0 3.0 NaN
|
2 1 NaN NaN 2.0
|
3 1 3.0 NaN NaN
|
4 1 NaN NaN NaN
|
|
Propagate non-null values forward or backward within each group along columns.
|
|
>>> df.groupby("key").fillna(method="ffill")
|
A B C
|
0 NaN 2.0 NaN
|
1 2.0 3.0 NaN
|
2 NaN NaN 2.0
|
3 3.0 NaN 2.0
|
4 3.0 NaN 2.0
|
|
>>> df.groupby("key").fillna(method="bfill")
|
A B C
|
0 2.0 2.0 NaN
|
1 2.0 3.0 NaN
|
2 3.0 NaN 2.0
|
3 3.0 NaN NaN
|
4 NaN NaN NaN
|
|
Propagate non-null values forward or backward within each group along rows.
|
|
>>> df.T.groupby(np.array([0, 0, 1, 1])).fillna(method="ffill").T
|
key A B C
|
0 0.0 0.0 2.0 2.0
|
1 0.0 2.0 3.0 3.0
|
2 1.0 1.0 NaN 2.0
|
3 1.0 3.0 NaN NaN
|
4 1.0 1.0 NaN NaN
|
|
>>> df.T.groupby(np.array([0, 0, 1, 1])).fillna(method="bfill").T
|
key A B C
|
0 0.0 NaN 2.0 NaN
|
1 0.0 2.0 3.0 NaN
|
2 1.0 NaN 2.0 2.0
|
3 1.0 3.0 NaN NaN
|
4 1.0 NaN NaN NaN
|
|
Only replace the first NaN element within a group along rows.
|
|
>>> df.groupby("key").fillna(method="ffill", limit=1)
|
A B C
|
0 NaN 2.0 NaN
|
1 2.0 3.0 NaN
|
2 NaN NaN 2.0
|
3 3.0 NaN 2.0
|
4 3.0 NaN NaN
|
r r r r r r r s rV r zDataFrameGroupBy.fillnaJ s ô| ÜDz×"Ñ"Ð#ð $!ô "& d§h¡h£ ×!8Ñ!8Ð 9¸ ð Jô Ü'Ó)õ
|
ð ×#Ñ#Ø ØØØØØØ ð $ó
|
ð rU c ó0 | j d||d|¤}|S )a
|
Return the elements in the given *positional* indices in each group.
|
|
This means that we are not indexing according to actual values in
|
the index attribute of the object. We are indexing according to the
|
actual position of the element in the object.
|
|
If a requested index does not exist for some group, this method will raise.
|
To get similar behavior that ignores indices that don't exist, see
|
:meth:`.DataFrameGroupBy.nth`.
|
|
Parameters
|
----------
|
indices : array-like
|
An array of ints indicating which positions to take.
|
axis : {0 or 'index', 1 or 'columns', None}, default 0
|
The axis on which to select elements. ``0`` means that we are
|
selecting rows, ``1`` means that we are selecting columns.
|
|
.. deprecated:: 2.1.0
|
For axis=1, operate on the underlying object instead. Otherwise
|
the axis keyword is not necessary.
|
|
**kwargs
|
For compatibility with :meth:`numpy.take`. Has no effect on the
|
output.
|
|
Returns
|
-------
|
DataFrame
|
An DataFrame containing the elements taken from each group.
|
|
See Also
|
--------
|
DataFrame.take : Take elements from a Series along an axis.
|
DataFrame.loc : Select a subset of a DataFrame by labels.
|
DataFrame.iloc : Select a subset of a DataFrame by positions.
|
numpy.take : Take elements from an array along an axis.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([('falcon', 'bird', 389.0),
|
... ('parrot', 'bird', 24.0),
|
... ('lion', 'mammal', 80.5),
|
... ('monkey', 'mammal', np.nan),
|
... ('rabbit', 'mammal', 15.0)],
|
... columns=['name', 'class', 'max_speed'],
|
... index=[4, 3, 2, 1, 0])
|
>>> df
|
name class max_speed
|
4 falcon bird 389.0
|
3 parrot bird 24.0
|
2 lion mammal 80.5
|
1 monkey mammal NaN
|
0 rabbit mammal 15.0
|
>>> gb = df.groupby([1, 1, 2, 2, 2])
|
|
Take elements at positions 0 and 1 along the axis 0 (default).
|
|
Note how the indices selected in the result do not correspond to
|
our input indices 0 and 1. That's because we are selecting the 0th
|
and 1st rows, not rows whose indices equal 0 and 1.
|
|
>>> gb.take([0, 1])
|
name class max_speed
|
1 4 falcon bird 389.0
|
3 parrot bird 24.0
|
2 2 lion mammal 80.5
|
1 monkey mammal NaN
|
|
The order of the specified indices influences the order in the result.
|
Here, the order is swapped from the previous example.
|
|
>>> gb.take([1, 0])
|
name class max_speed
|
1 3 parrot bird 24.0
|
4 falcon bird 389.0
|
2 1 monkey mammal NaN
|
2 lion mammal 80.5
|
|
Take elements at indices 1 and 2 along the axis 1 (column selection).
|
|
We may take elements using negative integers for positive indices,
|
starting from the end of the object, just like with Python lists.
|
|
>>> gb.take([-1, -2])
|
name class max_speed
|
1 3 parrot bird 24.0
|
4 falcon bird 389.0
|
2 0 rabbit mammal 15.0
|
1 monkey mammal NaN
|
r r r r s rV r_ zDataFrameGroupBy.takeÜ s& ðD $×#Ñ#ÐQ°GÀ$ÑQÈ&ÑQØ rU c ó |t j u rd}|dk7 r | j d|||d|¤}|S d } | j d|||d|¤S )a
|
Return unbiased skew within groups.
|
|
Normalized by N-1.
|
|
Parameters
|
----------
|
axis : {0 or 'index', 1 or 'columns', None}, default 0
|
Axis for the function to be applied on.
|
|
Specifying ``axis=None`` will apply the aggregation across both axes.
|
|
.. versionadded:: 2.0.0
|
|
.. deprecated:: 2.1.0
|
For axis=1, operate on the underlying object instead. Otherwise
|
the axis keyword is not necessary.
|
|
skipna : bool, default True
|
Exclude NA/null values when computing the result.
|
|
numeric_only : bool, default False
|
Include only float, int, boolean columns.
|
|
**kwargs
|
Additional keyword arguments to be passed to the function.
|
|
Returns
|
-------
|
DataFrame
|
|
See Also
|
--------
|
DataFrame.skew : Return unbiased skew over requested axis.
|
|
Examples
|
--------
|
>>> arrays = [['falcon', 'parrot', 'cockatoo', 'kiwi',
|
... 'lion', 'monkey', 'rabbit'],
|
... ['bird', 'bird', 'bird', 'bird',
|
... 'mammal', 'mammal', 'mammal']]
|
>>> index = pd.MultiIndex.from_arrays(arrays, names=('name', 'class'))
|
>>> df = pd.DataFrame({'max_speed': [389.0, 24.0, 70.0, np.nan,
|
... 80.5, 21.5, 15.0]},
|
... index=index)
|
>>> df
|
max_speed
|
name class
|
falcon bird 389.0
|
parrot bird 24.0
|
cockatoo bird 70.0
|
kiwi bird NaN
|
lion mammal 80.5
|
monkey mammal 21.5
|
rabbit mammal 15.0
|
>>> gb = df.groupby(["class"])
|
>>> gb.skew()
|
max_speed
|
class
|
bird 1.628296
|
mammal 1.669046
|
>>> gb.skew(skipna=False)
|
max_speed
|
class
|
bird NaN
|
mammal 1.669046
|
r r c ó2 t d| j « r r r s rV r z"DataFrameGroupBy.skew.<locals>.alt
|
r rU r¡ r¢ r¤ r§ s rV r£ zDataFrameGroupBy.skewA
|
s
ðT 3>>Ñ !ØDà 19Ø'T×'Ñ'ØðàØ Ø )ñ ð
|
ñ Fð Mò Nð
|
(t×'Ñ'Ø ð
|
Ø F¸ ñ
|
ØIOñ
|
ð
|
rU c ó t | « }|S rx r© rª s rV r« zDataFrameGroupBy.plot¡
|
r¬ rU rò c ó0 | j d|||¬« }|S )NrÀ )r r rf r )ra r r rf r¥ s rV rÀ zDataFrameGroupBy.corr§
|
s) ð ×#Ñ#Ø 6¨{È ð $ó
|
ð rU c ó0 | j d|||¬« }|S )NrÄ )r rÅ rf r )ra r rÅ rf r¥ s rV rÄ zDataFrameGroupBy.cov³
|
s) ð ×#Ñ#Ø {°ÀLð $ó
|
ð rU c óL | j d||||||||| |
|
| | | ||d|¤}|S )N)rL rÒ rÔ rÕ rÖ r× rØ rÓ ÚsharexÚshareyrÙ Úlayoutr@ rÚ rÛ rÜ r )ra rL rÒ rÔ rÕ rÖ r× rØ rÓ r{ r| rÙ r} r@ rÚ rÛ r} r¥ s rV rÝ zDataFrameGroupBy.hist¿
|
s\ ð( $×#Ñ#Ø ð
|
àØØØ!ØØ!ØØØØØØØØØñ!
|
ð" ñ#
|
ð& rU c ó° t j t | « j dt t « ¬« | j d | j « S )Nzj.dtypes is deprecated and will be removed in a future version. Check the dtypes on the base object insteadr c ó | j S rx )r )Údfs rV r« z)DataFrameGroupBy.dtypes.<locals>.<lambda>õ
|
s
|
ryy rU )r r rm rO r r r² r rÌ s rV r zDataFrameGroupBy.dtypesè
|
sU ô ÜDz×"Ñ"Ð#ð $Lð Lä Ü'Ó)õ
|
ð ×)Ñ)Ù $×"4Ñ"4ó
|
ð
|
rU c ó4 | j d|||||¬« }|S )NÚcorrwith)rÁ rÄ Údropr rf r )ra rÁ rÄ r r rf r¥ s rV r zDataFrameGroupBy.corrwithø
|
s2 ð ×#Ñ#Ø ØØØØØ%ð $ó
|
ð rU rx rä rå )rà r) rÐ r¹ rÞ r rß r )
|
rÐ z list[Series]rÞ r r z Index | Nonerß r r ræ rç )r r rf r rÄ r? r r) )r: r r; r rñ r) rè ré )r z DataFrameGroupBy | SeriesGroupBy)r[ rñ )rf r r_ râ r rD )rb rD r r) )r r r r) )rÄ rì r r rf r r r) )NFTFT) r\ zSequence[Hashable] | Noner< r r! r r= r r r r ræ ) r z.Hashable | Mapping | Series | DataFrame | Noner rë rÄ rì r r r rí r zDataFrame | None)r rF rÄ rì r r) rï )rò r F)r z/str | Callable[[np.ndarray, np.ndarray], float]r rñ rf r r r) )Nr F)r rí rÅ rí rf r r r) )NNTNNNNNFFNNrô NF)rL zIndexLabel | NonerÔ r rÕ rí rÖ rõ r× rí rØ rõ r{ r r| r rÙ rö r} rö r@ r÷ rÚ râ rÛ r rã ) rÁ ræ rÄ rî r r r r@ rf r r r) )1rO rP rQ r rø r r. r¦ rú r r rè r r r Ú)_DataFrameGroupBy__examples_dataframe_docr r r1 rù r2 r3 r rR r] rq rd rg r3 r r¥ r¾ r· r9 Úboxplotr] r r_ r£ rü r) r« rR rÀ rÄ rÝ r r rý rþ s @rV r r 1 s ø Ù ðV óXÐñt Ð Ð'8À ÔLðT°ÀTó Tó MðTðl Cò 1ó<ð. "'Ø "ð DàðDð ðDð ð Dð
|
ó DðL/,à ð/,ð ð/,ð
|
ð /,ð ð /,ð
|
ó/,ðh #Øð à ð ð ð ð ð ð
|
ó ò@/<ñb &ð2 ó4 Ð ñl Ð-EÔFÙ Ð!Ó"Ø,0Àó
|
ó #ó Gð
|
ò
|
$ó"ôHE3õN (ô /:ðd ',Àñ Ø #ð Ø3=ð à ó óBóô83Oðn -0¯N©NØØ "ð P
|
à)ðP
|
ð ðP
|
ð ð P
|
ð
|
|
ó P
|
ðh -0¯N©NØØ "ð P
|
à)ðP
|
ð ðP
|
ð ð P
|
ð
|
|
ó P
|
ðd $Gð -1Ø ØØ Øð oNà)ðoNð ðoNð ð oNð
|
ð oNð ð oNð
|
óoNðf AEØ'+Ø,/¯N©NØ Ø Ø ðPà=ðPð %ðPð *ð Pð
|
ð Pð ð Pð
|
óPðj -0¯N©Nðcà ðcð *ðcð
|
|
ó cðN -0¯N©NØØ "ð ^
|
à)ð^
|
ð ð^
|
ð ð ^
|
ð
|
ó ^
|
ð@ Ù × Ñ Ó òó !ó ðñ × Ñ Ó ð CLØ Ø "ð à?ð ð ð ð ð ð
|
|
ò ó !ð ñ × Ñ Ó ð #'Ø Ø "ð à ð ð ð ð ð ð
|
|
ò ó ð ñ × Ñ Ó ð %)Ø ØØ!%Ø !Ø!%Ø !Ø Ø Ø Ø*.Ø)-Ø$&Ø "Ø ð!&à!ð&ð ð &ð
|
ð &ð ð &ð ð&ð ð&ð ð&ð ð&ð (ð&ð 'ð&ð "ð &ð ð &ð ò!&ó !ð&ðP Ù× Ñ × !Ñ !Ó"ò
|
ó #ó ð
|
ñ × Ñ × #Ñ #Ó$ð &)§^¡^ØØ$-Ø "ð à!ðð #ðð ð ð
|
"ð ð ð ð
|
òó %ôrU r c ót ddl m} t |t « rØ|j j | j « rD ||gt |j « z d¬« }|j |_ |j |_ n[| j t j |j t |j « df« |j |j ¬« }t |t « sJ |S t |t « r9|j j |j « s|j |« d S |S )Nr r r rê rb )rÑ rà r r6 r Úis_rá r r r
|
rq rÐ r) Ú _align_frame)r] rñ r³ rÃ Ú res_frames rV r5 r5 sí õ ä#vÔ ð 99==Ô #Ù u¤s¨5¯=©=Ó'9Ñ 9ÀÔBIØ %§ ¡ IÔ Ø #kkIOà×(Ñ(Ü
|
|
¤S¨¯©Ó%5°qÐ$9Ó:Ø Økkð )ó Iô
|
)¤YÔ/Ð/Ð/ØÐÜ CÔ #¨C¯I©I¯M©M¸%¿+¹+Ô,FØ× Ñ Ó& qÑ)Ð)à
|
rU )r] r) rñ r) r³ ræ r r) )qrR Ú
|
__future__r Ú collectionsr Ú functoolsr Útextwrapr Útypingr r r r
|
r r r r r Únumpyr
|
Ú pandas._libsr r Úpandas._libs.hashtabler Ú pandas.errorsr Úpandas.util._decoratorsr r r Úpandas.util._exceptionsr Úpandas.core.dtypes.commonr r r r r r r Úpandas.core.dtypes.dtypesr r Ú pandas.core.dtypes.inferencer Úpandas.core.dtypes.missingr! r" Ú pandas.corer# Úpandas.core.applyr$ r% r& r' r( Úpandas.core.commonÚcoreÚcommonr Úpandas.core.framer) Úpandas.core.groupbyr* r+ Úpandas.core.groupby.groupbyr, r- r. r/ r0 r1 Úpandas.core.indexes.apir2 r3 r4 r5 Úpandas.core.seriesr6 Úpandas.core.sortingr7 Úpandas.core.util.numba_r8 Úpandas.plottingr9 Úcollections.abcr: r; r< Úpandas._typingr= r> r? r@ rA rB rC rD rE rF rÑ rG Úpandas.core.genericrH r rM rI rK rX r r5 rT rU rV ú<module>r© sL ðñõ #å Ý Ý ÷ ÷ ó ó ã ÷õ .Ý ,÷ñ õ
|
5÷÷ ñ ÷õ 5÷õ
|
#÷õ ÷ !Ð Ý '÷÷÷ ÷ó õ &Ý /Ý 3å 1á÷ñ ÷ ÷ ÷ õ #Ý+ð #x S Ñ)Ð)Ñ * ñ ~Ó& ôzô ô<TGFOô Tôn$XwyÑ)ô Xðv.Ø ðØ$ðØ+=ðàôrU
|
