U
|
¬ý°dÕa ã @ s@ d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m
|
Z
|
m Z m Z m Z mZmZmZmZmZmZmZmZ ddlZddlmZmZmZ dd l m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z' dd
|
l(m)Z) dd l*m+Z+m,Z,m-Z- dd l.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 dd l7m8Z8m9Z9 ddl:m;Z; ddl<m=Z=m>Z>m?Z?m@Z@ ddlAmB mCZD ddlEmFZF ddlGmHZH ddlImJZJmKZKmLZLmMZMmNZN ddlOmPZPmQZQmRZRmSZS ddlTmUZU ddlVmWZW ddlXmYZY e
|
rÔddlZm[Z[ ddl\m]Z] ee^e de f f Z_edZ`G dd d eZaG d d d eJeU ZbG d d d eJeF Zcd!d!d"d!d#d$d%ZddS )&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ÚHashableÚIterableÚLiteralÚMappingÚ
|
NamedTupleÚSequenceÚTypeVarÚUnionÚcastN)ÚIntervalÚlibÚ reduction)
|
Ú ArrayLikeÚAxisÚAxisIntÚCorrelationMethodÚ FillnaOptionsÚ
|
IndexLabelÚManagerÚ Manager2DÚ SingleManagerÚ TakeIndexer)ÚSpecificationError)ÚAppenderÚ SubstitutionÚdoc)Ú ensure_int64Úis_boolÚis_categorical_dtypeÚ is_dict_likeÚis_integer_dtypeÚis_interval_dtypeÚis_numeric_dtypeÚ is_scalar)ÚisnaÚnotna)Ú
|
algorithms)Ú GroupByApplyÚmaybe_mangle_lambdasÚreconstruct_funcÚvalidate_func_kwargs)Ú DataFrame)Úbase)ÚGroupByÚ GroupByPlotÚ _agg_templateÚ _apply_docsÚ_transform_template)ÚIndexÚ
|
MultiIndexÚall_indexes_sameÚ default_index)ÚSeries)Úmaybe_use_numba)Úboxplot_frame_groupby)Ú Categorical)ÚNDFrame.Ú ScalarResultc @ s" e Zd ZU dZded< ded< dS )Ú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=np.mean)
|
>>> 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Ú AggScalarZaggfuncN)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__© rK rK úRd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/groupby/generic.pyrC m s
|
rC c s@ e Zd ZdddddZdddd d
|
d d d dZddddZedZee d j
|
de d ddd fdd Z e e eddddddd d ZeZd d Zd dd!d"Zddd#d d d$d%d&d'Zd(d) Zed*Zeded+eedddd,d-Zdd/d d0d1d2d3Zd4dd5d6d7Zdd d9d:d;Zdd d<d=d>d?Ze e j fd@dAZ dd d d d d<dBdCdDZ d
dEdFdGd dHdIdJdKdLdMZ ddNdOddPdQdRZ e!j"d8dfdSd d ddTdUdVZ#e$e e j%j&dWdX Z%e e j'j&dd[d\dd]d^d_Z'e e j(j&dd[d\dd]d`daZ(e e j)j&ddOd ddbdcddZ)e e j*j&ddOd ddbdedfZ*e e j+j&dddhdHddidjdkZ+e e j,j&dddHdHddmdndoZ,e$e e j-j&dddpdqZ-e$e e j.j&dddrdsZ.e e j/j&dd dHdudHdudvdwd
|
d dx dydzZ/e$e e j0j&ddd{d|Z0e e j1j&ddd}d~Z1 Z2S )Ú SeriesGroupByr r= ©ÚmgrÚreturnc C s | j j|| j jdS )N©Úname)ÚobjÚ _constructorrR ©ÚselfrO rK rK rL Ú_wrap_agged_manager s z!SeriesGroupBy._wrap_agged_managerFN©Ú numeric_onlyrR Úboolú
|
str | Noner ©rY rR rP c C sD | j }|j}|r@t|js@d}td| dt| j d| d|S )NrY z Cannot use z =True with Ú.z and non-numeric dtypes.)Ú _selected_objÚ_mgrr) ÚdtypeÚ TypeErrorÚtyperF )rV rY rR ÚserZsingleZkwd_namerK rK rL Ú_get_data_to_aggregate s ÿz$SeriesGroupBy._get_data_to_aggregateúIterable[Series]©rP c c s | j V d S ©N)r^ ©rV rK rK rL Ú_iterate_slices s z SeriesGroupBy._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: float64
|
ÚtemplateZseriesZseries_examples)ÚinputÚexamplesc s t j|f||S rg )ÚsuperÚapply)rV ÚfuncÚargsÚkwargs©Ú __class__rK rL rn Ò s zSeriesGroupBy.apply©rl Úklass©ÚengineÚ engine_kwargsc O s| t |r"| j|f|d|i|S |d k}d }|rBt|\}}i }t|tr\t| |||S t|tjrªt|}| j |f||}|r|d k st
|
||_ | j s¦| ¡ }|S t |¡} | rÌ|sÌ|sÌt| | S | jdk rü| j}
|
| jjg | jj| jj|
|
jdS | jjdkr | j|f||S z| j|f||W S tk
|
rv | j|f||} t | | jjd} | | ¡} | Y S X d S )Nrx r ©rR Úindexr` é ©rz ) r> Ú_aggregate_with_numbar1 Ú
|
isinstanceÚstrÚgetattrr r
|
r/ Ú_aggregate_multiple_funcsÚAssertionErrorÚcolumnsÚas_indexÚ reset_indexÚcomZget_cython_funcÚngroupsÚ_obj_with_exclusionsrS rT rR ÚgrouperÚ result_indexr` ÚnkeysÚ_python_agg_generalÚKeyErrorÚ_aggregate_namedr= Ú_wrap_aggregated_output) rV ro rw rx rp rq Ú
|
relabelingr ÚretZcyfuncrS ÚresultrK rK rL Ú aggregateÚ s\ ÿÿÿÿ
|
|
ü
|
zSeriesGroupBy.aggregatec sH t ¡ fdd}| j}| j ||¡}|j||jd}| |¡S )Nc s | f S rg rK ©Úx©rp ro rq rK rL Ú<lambda> ó z3SeriesGroupBy._python_agg_general.<locals>.<lambda>rQ )r Úis_builtin_funcr r Ú
|
agg_seriesrT rR r )rV ro rp rq ÚfrS r ÚresrK r rL r s
|
z!SeriesGroupBy._python_agg_generalr2 c O sL t |tr(| jrtdqvt| ¡ }nNtdd |D rJdd |D }n,g }|D ]}| t |¡pf|¡ qRt
|
||}i }t | dd¡@ t |D ]0\}\}} t j||d}
|
| j| f||||
|
< qW 5 Q R X td d | ¡ D rd
|
d lm} | | ¡ d d d |D d} | S dd | ¡ D } | jj| d d}tdd |D |_|S )Nz nested renamer is not supportedc s s | ]}t |ttfV qd S rg ©r~ ÚtupleÚlist©Ú.0r rK rK rL Ú <genexpr>, s z:SeriesGroupBy._aggregate_multiple_funcs.<locals>.<genexpr>c S s& g | ] }t |ttfs ||fn|qS rK r r rK rK rL Ú
|
<listcomp>- s z;SeriesGroupBy._aggregate_multiple_funcs.<locals>.<listcomp>r T©ÚlabelÚpositionc s s | ]}t |tV qd S rg )r~ r2 r rK rK rL r¢ > s r ©Úconcatr{ c S s g | ]
|
}|j qS rK ©r¥ ©r¡ ÚkeyrK rK rL r£ B s )ÚaxisÚkeysc S s i | ]\}}|j |qS rK ©r¦ ©r¡ r« ÚvalrK rK rL Ú
|
<dictcomp>F s z;SeriesGroupBy._aggregate_multiple_funcs.<locals>.<dictcomp>r| c s s | ] }|j V qd S rg r© rª rK rK rL r¢ H s )r~ Údictr r r ÚitemsÚanyÚappendr Zget_callable_nameÚzipZ temp_setattrÚ enumerater3 Ú OutputKeyr ÚvaluesÚpandasr¨ rS Ú_constructor_expanddimr9 r )rV Úargrp rq r r ÚresultsÚidxrR ro r« r¨ Úres_dfÚindexed_outputÚoutputrK rK rL r $ s6
|
|
|
" ÿz'SeriesGroupBy._aggregate_multiple_funcsz list[Any]úDataFrame | Series)Údatar¹ Únot_indexed_sameÚ is_transformrP c
|
C s6 t |dkr:|r|j}n| jj}| jjg | jj||jdS |dk sFtt |d t
|
r| jj}| jj ||d}| |¡}|j | jd}| jj|_|S t |d ttfrî| j|||d} t | trÈ| jj| _| jsê|rê| | ¡} tt | | _| S | jj|| jj| jjd} | js(| | ¡} tt | | _| | ¡S dS )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 ry Nr| ©Údropna©rÄ rÅ )rà rz rR )Úlenrz r r rS rT rR r` r r~ r² r» Ú_reindex_outputÚstackÚobservedr= r2 Ú_concat_objectsr Ú_insert_inaxis_grouperr< )
|
rV rà r¹ rÄ rÅ Ú res_indexrz r¿ Zres_serr rK rK rL Ú_wrap_applied_outputL sN ü
|
|
ý
|
|
|
|
ÿ
|
z"SeriesGroupBy._wrap_applied_outputc O s` i }d}| D ]N\}}t |d|¡ ||f||}t |¡}|sRt ||j¡ d}|||< q |S )NFrR T)ÚobjectÚ __setattr__Ú libreductionZextract_resultZcheck_result_arrayr` ) rV ro rp rq r Z initializedrR ÚgrouprÁ rK rK rL r s
|
|
z SeriesGroupBy._aggregate_nameda)
|
>>> 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
|
©ru Zexamplec O s | j |f|||d|S ©Nrv ©Z
|
_transform©rV ro rw rx rp rq rK rK rL Ú transformÒ s ÿÿ ÿÿzSeriesGroupBy.transformr r r )ÚhowrY r¬ c
|
K s |dks t | j}z | jjd|j||f|}W n: tk
|
rh } z t| d|j d|W 5 d }~X Y nX |j|| j j
|
|j dS )Nr rÙ z is not supported for z dtype©rz rR ) r r^ r Ú_cython_operationÚ_valuesÚNotImplementedErrorra r` rT rS rz rR )rV rÚ rY r¬ rq rS r ÚerrrK rK rL Ú_cython_transformÙ s ÿÿ*z SeriesGroupBy._cython_transformr )ro rP c O s¬ t |s tt| j}g }| jj| j| jdD ]:\}}t |d|¡ ||f||}|
|
|||j d¡ q.|rddl m } | |}
|
| |
|
¡} n| jjtjd} | jj| _| S )z2
|
Transform with a callable func`.
|
©r¬ rR r| r r§ ©r` )Úcallabler rb rS r Ú get_iteratorr^ r¬ rÑ rÒ rµ rz Úpandas.core.reshape.concatr¨ Ú_set_result_index_orderedrT ÚnpÚfloat64rR ) rV ro rp rq ru r½ rR rÔ r r¨ Ú concatenatedr rK rK rL Ú_transform_generalê s"
|
ÿ
|
z SeriesGroupBy._transform_generalTrÆ c
|
s t tr fddn fddddfdd zfdd D }W n0 ttfk
|
r } ztd
|
|W 5 d }~X Y nX ||¡}|S ) 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 s t | S rg ©r r r rK rL r . r z&SeriesGroupBy.filter.<locals>.<lambda>c s | f S rg rK r r rK rL r 0 r rZ rf c s | }t |o|S rg )r, )r Úb)ÚwrapperrK rL Útrue_and_notna3 s z,SeriesGroupBy.filter.<locals>.true_and_notnac s" g | ]\}}|r |¡qS rK )Ú
|
_get_index)r¡ rR rÔ )rV rî rK rL r£ 8 s z(SeriesGroupBy.filter.<locals>.<listcomp>z'the filter must return a boolean resultN)r~ r Ú
|
ValueErrorra Ú _apply_filter)rV ro rÇ rp rq Úindicesrß ÚfilteredrK )rp ro rq rV rî rí rL Úfilter s &
|
ÿ
|
zSeriesGroupBy.filterzSeries | DataFrame©rÇ rP c C sÌ | j j\}}}| jj}tj|dd\}}t ||f¡}|| }|| }tjddt |dd
|dd
k¡d f }tjd|dd
|dd
kf }|dk} |r¶d||< d|| < n&d|| tjd| dd
f @ < d||< tj
|
||¡j ddd}
|
t |r.|d dkr(|
|
dd
} |t |¡ }n|
|
} n |
|
dd
} | j j} t | t | krtjt | |
|
jd | } }
|
t |dkr|
|
| || < | jj| | | jjd
|
} | js¾| | ¡} tt | | _| j| dd S ) z§
|
Return number of unique elements in the group.
|
|
Returns
|
-------
|
Series
|
Number of unique values within each group.
|
F©Úsortr r{ NéÿÿÿÿÚint64©Úcopyrâ rÛ )Ú
|
fill_value)r Ú
|
group_inforS rÝ r- Ú factorizerç ÚlexsortÚr_ÚnonzeroÚaddÚreduceatÚastyperÉ Z flatnonzeror Úzerosr` rT rR r rÎ r< rz rÊ )rV rÇ ÚidsÚ_r° ÚcodesÚsorterr¾ ÚincÚmaskÚoutr Úrir rK rK rL ÚnuniqueA sF 0"
|
|
ÿ
|
zSeriesGroupBy.nuniquec s t jf |S rg )rm Údescribe)rV rq rr rK rL r } s zSeriesGroupBy.describe)Ú normalizer÷ Ú ascendingrÇ rP c & s |rdnd}|d kr0| j ||||d}||_|S ddlm} ddlm} | jj\}
|
} } | jj } | jj
|
| jjg } t | j s|d k r´t |¡s´| jtj||||d}||_| |j_
|
|S |
|
dk|
|
| }
|
} |d kròtj| d d
|
\}}d d }nD| t| d d|d d}td|j }|j}|j|jd |jd}dd }t|j rbtt|}t |j |j |
|
f¡}nt ||
|
f¡}|
|
| || }
|
}dt |
|
dd
|
|
d d
k¡d }t j d|f }t!|
|
sÄ|}||t"dd ||t"d dk}t j d |f }t!| s |}d ||< t #t t j |d f ¡d ¡}t$t j%t j& '||¡d| jj(}fdd|D |||g }dd | jj)D |g } |rº|d dk *¡ rd }n | fdd|D }}|r"| +d¡}t #t j |t!|
|
f ¡} |r|
|
|dk } t j& ,| | d¡ | } n| } || }|r|d kr|rD|
|
| n|
|
| } t |rZ|n| | f¡}|| |d | }|d< |d k rÊt j-t!|dd|d d
D ],}!t j d |!dd
|!d d
kf O q¨ .¡ t!| d }"t %t /|"¡¡t 0t /¡|"¡g}# 1¡ d |d g}$||#|$d d d \} }t 2|dk|| d¡}|rt |rb|n| |#d f¡}|| |#d | }|#d< d d d fd d! fd"d|d d
D }| 3|#d ¡ t4| || d d#}%t5|j rît6|}| jj7||%|d$}| j8s| 9¡ }|S )%NZ
|
proportionÚcount)r r÷ r rÇ r )Úget_join_indexers)Úcut)r r÷ r Úbinsrø Trö c S s | | S rg rK ©Úlabr
|
rK rK rL r ± r z,SeriesGroupBy.value_counts.<locals>.<lambda>Frú )Zinclude_lowestr@ )Z
|
allow_fillrü c S s | | j jd S )Nrø )Z _multiindexr r rK rK rL r ¼ r r{ )Zrepeatsc s g | ] } |qS rK rK ©r¡ Ú level_codes)ÚreprK rL r£ Û s z.SeriesGroupBy.value_counts.<locals>.<listcomp>c S s g | ]
|
}|j qS rK )Z group_index)r¡ ZpingrK rK rL r£ Ü s c s g | ] }| qS rK rK r )r rK rL r£ ã s ÚfloatrZ râ Úleft)r÷ rÚ z
|
np.ndarray)Ú lev_codesrP c s t | ¡S rg )rç Úrepeat)r )ÚdiffÚnbinrK rL Ú build_codes
|
s z/SeriesGroupBy.value_counts.<locals>.build_codesc s g | ] } |qS rK rK )r¡ r )r! rK rL r£ s )Úlevelsr ÚnamesÚverify_integrityrÛ ):Ú _value_countsrR Zpandas.core.reshape.merger Zpandas.core.reshape.tiler r rý rS rÝ r# r% r` rç Úiterablern r= Ú value_countsrz r- rþ r Ú
|
categoriesÚtaker Z _na_valuer( r rÿ r Úrightr r rÉ Úslicer r r r r Zreconstructed_codesZ groupingsÚallr Úatr ÚsumZarangeÚtileZcumsumÚwhererµ r: r' r# rT r r
)&rV r r÷ r r rÇ rR r r r r r r° Z index_namesrc r ZlevZllabZcat_serZcat_objZ lab_intervalr Z idchangesr¾ Zlchangesr
|
r r r" ÚdÚmÚaccÚcatr Zncatr r* ÚmirK )r! r r r r rL r' sØ ÿ
|
ÿÿû
|
ý
|
&
|
|
|
|
|
*$ ÿ zSeriesGroupBy.value_countszobject | ArrayLike | NoneúFillnaOptions | Noneú Axis | Noneú
|
int | Nonez dict | Nonez Series | None)ÚvalueÚmethodr¬ ÚinplaceÚlimitÚdowncastrP c C s | j d||||||d}|S )a
|
Fill NA/NaN values using the specified method within groups.
|
|
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
|
--------
|
>>> ser = pd.Series([np.nan, np.nan, 2, 3, np.nan, np.nan])
|
>>> ser
|
0 NaN
|
1 NaN
|
2 2.0
|
3 3.0
|
4 NaN
|
5 NaN
|
dtype: float64
|
|
Propagate non-null values forward or backward within each group.
|
|
>>> ser.groupby([0, 0, 0, 1, 1, 1]).fillna(method="ffill")
|
0 NaN
|
1 NaN
|
2 2.0
|
3 3.0
|
4 3.0
|
5 3.0
|
dtype: float64
|
|
>>> ser.groupby([0, 0, 0, 1, 1, 1]).fillna(method="bfill")
|
0 2.0
|
1 2.0
|
2 2.0
|
3 3.0
|
4 NaN
|
5 NaN
|
dtype: float64
|
|
Only replace the first NaN element within a group.
|
|
>>> ser.groupby([0, 0, 0, 1, 1, 1]).fillna(method="ffill", limit=1)
|
0 NaN
|
1 NaN
|
2 2.0
|
3 3.0
|
4 3.0
|
5 NaN
|
dtype: float64
|
Úfillna©r9 r: r¬ r; r< r= ©Z _op_via_apply©rV r9 r: r¬ r; r< r= r rK rK rL r> s _ù zSeriesGroupBy.fillnar r ©rò r¬ rP c K s | 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.
|
**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) r@ ©rV rò r¬ rq r rK rK rL r)
s OzSeriesGroupBy.takezAxis | lib.NoDefault©r¬ ÚskipnarY rP c K s | 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.
|
|
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
|
Úskew©r¬ rF rY )rG r@ ©rV r¬ rF rY rq r rK rK rL rG × s ; ÿüûzSeriesGroupBy.skewc C s t | }|S rg ©r5 ©rV r rK rK rL Úplot s zSeriesGroupBy.ploté ÚfirstÚintz!Literal[('first', 'last', 'all')])ÚnÚkeeprP c C s* t tj||d}| j}| j||dd}|S ©N)rP rQ T©rÄ )r r= Únlargestr^ Ú_python_apply_general©rV rP rQ r rà r rK rK rL rT ! s zSeriesGroupBy.nlargestc C s* t tj||d}| j}| j||dd}|S rR )r r= Ú nsmallestr^ rU rV rK rK rL rW , s zSeriesGroupBy.nsmallest)r¬ rF rP c C s | j d||d}|S )NÚidxmin©r¬ rF r@ ©rV r¬ rF r rK rK rL rX 7 s zSeriesGroupBy.idxminc C s | j d||d}|S )NÚidxmaxrY r@ rZ rK rK rL r[ < s zSeriesGroupBy.idxmaxÚpearsonr )Úotherr: Ú min_periodsrP c C s | j d|||d}|S )NÚcorr)r] r: r^ r@ )rV r] r: r^ r rK rK rL r_ A s ÿzSeriesGroupBy.corrr{ )r] r^ ÚddofrP c C s | j d|||d}|S )NÚcov)r] r^ r` r@ )rV r] r^ r` r rK rK rL ra M s ÿzSeriesGroupBy.covc C s | dd ¡S )Nc S s | j S rg )Úis_monotonic_increasing©rc rK rK rL r Y r z7SeriesGroupBy.is_monotonic_increasing.<locals>.<lambda>©rn rh rK rK rL rb V s z%SeriesGroupBy.is_monotonic_increasingc C s | dd ¡S )Nc S s | j S rg )Úis_monotonic_decreasingrc rK rK rL r ^ r z7SeriesGroupBy.is_monotonic_decreasing.<locals>.<lambda>rd rh rK rK rL re [ s z%SeriesGroupBy.is_monotonic_decreasingé
|
ú float | Noneútuple[int, int] | Noneúint | Sequence[int]) ÚgridÚ
|
xlabelsizeÚxrotÚ
|
ylabelsizeÚyrotÚfigsizer ÚbackendÚlegendc K s, | j d||||||||| |
|
| d | } | S )NÚhist) ÚbyÚaxrj rk rl rm rn ro r rp rq )rr r@ )rV rs rt rj rk rl rm rn ro r rp rq rq r rK rK rL rr ` s$ ÿô ózSeriesGroupBy.histc C s | dd ¡S )Nc S s | j S rg râ rc rK rK rL r r z%SeriesGroupBy.dtype.<locals>.<lambda>rd rh rK rK rL r` s zSeriesGroupBy.dtypec C s | d¡}|S )NÚuniquer@ rK rK rK rL ru s
|
zSeriesGroupBy.unique)N)FF)Fr )T)T)FTFNT)NNNFNN)r )rM rN )rM rN )r T)r T)r\ N)Nr{ ) NNTNNNNNrf NF)3rF rG rH rW rd ri r Ú_agg_examples_docr r7 Úformatrn r" r6 r Úaggr r rÐ r Z#_SeriesGroupBy__examples_series_docr! r8 rÙ rà rê rô r r= r r' r> r) r Ú
|
no_defaultrG ÚpropertyrL rI rT rW rX r[ r_ ra rb re rr r` ru Ú __classcell__rK rK rr rL rM sÒ ÿÿ2 ÿÿ > , ûGÿ,
|
ÿ :< ú ù m ýTüD
|
|
ÿ
|
|
ÿ
|
|
|
|
ü
|
ÿ
|
|
|
ô"
|
|
rM c sú e Zd ZedZeeeddddddddZeZdd Z d
|
d d d Z
|
dd ddZ ddddddddZ ddddddddZ d
d dd dd d d!Zd"d# Zed$Zeded%eedddd&d'Zd(d) Zd*d*dd+d,d-Zddd/d0d1Zd2d fd3d4 Zdd5d6d7d8Zddd9dd:d;d<d=d>Zd?dd@dAdBZd;ddCdDdEZ ddFdGdHZ dddIdJdKZ ddddLdMdNZ ddOddddPdQdRZ ddOddddPdSdTZ!e"Z#ddUddddddVdWdXZ$ddYdZdOdd[d\d]d^Z%dd_dOdd`dadbZ&e'j(d.dfdcddddPdddeZ)e*ee+j,j-dfd dgdhZ,ee+j.j-ddkd5dddldmdnZ.ee+j/j-ddododddpdqdrZ/ee+j0j-ddtddodudodudddvdvdwd:ddx dydzZ0e*ee+j1j-d{d d|d}Z1ee+j2j-ddd~dddddddZ2 Z3S )ÚDataFrameGroupByaª
|
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
|
|
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
|
r2 rt Nrv c
|
O s t |r"| j|f|d|i|S t|f|\}}}}t|}t| |||} | ¡ }
|
t|sh|
|
d k rh|
|
S |rtt|
|
}
|
|
|
j d d
|f }
|
tt|
|
}
|
||
|
_
|
|
|
d krj| j j dkrÀ| j |f||S |sÈ|rÜ| j|f||}
|
n| jdkrô| |¡}
|
|
|
S t| |gdi d} z | ¡ }
|
W n> tk
|
rP } z dt| kr6 | |¡}
|
W 5 d } ~ X Y nX tt|
|
}
|
| jj
|
¡ |
|
_
|
| js| |
|
¡}
|
tt|
|
|
|
_|
|
S )Nrx r{ rK )rp rq zNo objects to concatenate)r> r} r0 r/ r. rx r& r r2 Úilocr r r r Ú_aggregate_framer¬ rð r r rû r rÎ r< rÉ rz ) rV ro rw rx rp rq r r ÚorderÚopr Zgbarß rK rK rL r ê sT ÿÿÿÿ
|
|
|
|
|
|
|
zDataFrameGroupBy.aggregatec s t ¡ fdd}i }| jdkr:| j|| jddS t| ¡ D ]2\}}|j}| j ||¡} t
|
j ||d}
|
| ||
|
< qF|s| || j¡S | |¡} | | ¡S )Nc s | f S rg rK r r rK rL r 5 r z6DataFrameGroupBy._python_agg_general.<locals>.<lambda>r T©Zis_aggr¤ )r r r rU r^ r· ri rR r r r3 r¸ Ú_indexed_output_to_ndframer ) rV ro rp rq r rÁ r¾ rS rR r r« r rK r rL r 3 s
|
|
|
|
z$DataFrameGroupBy._python_agg_generalre rf c c s\ | j }| jdkr|j}t|tr4|j| jkr4|V n$| ¡ D ]\}}|| jkrPq<|V q<d S ©Nr{ )r^ r¬ ÚTr~ r= rR Ú
|
exclusionsr³ )rV rS r¥ r¹ rK rK rL ri L s
|
|
z DataFrameGroupBy._iterate_slicesc O s | j jdkrtd| j}i }| j || j¡D ] \}}||f||}|||< q.| j j} |jd| j }
|
| jj ||
|
| d} | jdkr| j
|
} | S )Nr{ zNumber of keys must be 1©rz r r ) r r r r rä r¬ r ÚaxesrS rT r ) rV ro rp rq rS r rR Zgrp_dfZfresr Zother_axr rK rK rL r~ ^ s
|
|
z!DataFrameGroupBy._aggregate_frameFr rZ )rà r¹ rÄ rÅ c C s t |dkrF|r|j}n| jj}| jj||jd}|j|jdd}|S t t
|
j | d }|d krh| j ¡ S t |t r| j|||dS | jr| jjnd }t |tjtfr¸| jj||| jdS t |t sþ| jrÚ| jj||dS | jj|| jgd}| |¡}|S n| |||||¡S d S ) Nr r Frú rÈ rÛ r| )r )rÉ rz r r rS rT r r ÚdtypesÚnextr Znot_noner~ r2 rÍ r rç Zndarrayr9 Z_constructor_slicedZ
|
_selectionr= rÎ Ú_wrap_applied_output_series) rV rà r¹ rÄ rÅ rÏ r Úfirst_not_noneÚ key_indexrK rK rL rÐ q sH
|
|
ý ÿ
|
ûz%DataFrameGroupBy._wrap_applied_outputz list[Series]z Index | Noner )r¹ rÄ r rÅ rP c sø | ¡ }tf | fdd|D }tdd |D }|sJ| j|d|dS t dd |D ¡}| jdkrª|} |j ¡ }
|
|
|
j d krºd d
|
|D } t
|
| d krºt | d |
|
_ n|j} |}
|
|j }|j tkrÌ| ¡ }| jj|| |
|
d } | jsî| | ¡} | | ¡S ) Nc s g | ]}|d k r|n qS rg rK r ©ÚbackuprK rL r£ º s z@DataFrameGroupBy._wrap_applied_output_series.<locals>.<listcomp>c s s | ] }|j V qd S rg r| r rK rK rL r¢ ¼ s z?DataFrameGroupBy._wrap_applied_output_series.<locals>.<genexpr>TrÈ c S s g | ]}t |¡qS rK )rç Zasarray©r¡ ÚvrK rK rL r£ È s r c S s h | ]
|
}|j qS rK rQ r rK rK rL Ú <setcomp>Ï s z?DataFrameGroupBy._wrap_applied_output_series.<locals>.<setcomp>r{ r )Z_construct_axes_dictr= r; rÍ rç Zvstackr¬ rz rû rR rÉ r r r` rÑ ÚtolistrS rT r rÎ rÊ ) rV r¹ rÄ r r rÅ rq Zall_indexed_sameZstacked_valuesrz r r# r rK r rL r ° s6
|
ý
|
|
|
|
|
z,DataFrameGroupBy._wrap_applied_output_seriesr r r )rÚ rY r¬ rP c sh |dks t j| d}ddd fdd }| |¡}| d|jd ¡ j |¡} |¡}|S )Nr rX r )ÚbvaluesrP c s j jd| dfS )NrÙ r{ )r rÜ )r ©rÚ rq rV rK rL Úarr_funcó s ÿÿz4DataFrameGroupBy._cython_transform.<locals>.arr_funcr{ )r rd Zgrouped_reduceZset_axisr rS rT Z_maybe_transpose_result) rV rÚ rY r¬ rq rO r Zres_mgrr¿ rK r rL rà á s ÿ
|
|
z"DataFrameGroupBy._cython_transformc
|
O sz ddl m} g }| j}| jj|| jd}| j|f||\}} zt|\}
|
} W n tk
|
rb Y nzX t
|
| d|
|
¡ z| || | ¡\} } W n0 t k
|
r¸ } zd}t ||W 5 d }~X Y nX | j dkrÜt| j| | } | | ¡ |D ]B\}
|
} | j dkrôqàt
|
| d|
|
¡ | | } t| j| | } | | ¡ qà| jdkr6|jn|j}| jdkrLdnd}||| jdd}|j||dd }| |¡S )
|
Nr r§ rá rR z3transform must return a scalar value for each groupr{ F)r¬ r$ )r¬ rû )rå r¨ r r rä r¬ Ú _define_pathsr Ú StopIterationrÑ rÒ Ú _choose_pathrð ÚsizeÚ _wrap_transform_general_framerS rµ r rz Zreindexræ )rV ro rp rq r¨ ZappliedrS ÚgenÚ fast_pathÚ slow_pathrR rÔ Úpathr rß ÚmsgZ concat_indexZ
|
other_axisré rK rK rL rê s<
|
|
|
z#DataFrameGroupBy._transform_generala
|
>>> 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 O s | j |f|||d|S rÖ r× rØ rK rK rL rÙ b s ÿÿ ÿÿzDataFrameGroupBy.transformc sX t tr. fdd} fdd}n" fdd} fdd}||fS )Nc s t | S rg rë ©rÔ r rK rL r k r z0DataFrameGroupBy._define_paths.<locals>.<lambda>c s | j fddjdS )Nc s t | S rg rë r r rK rL r m r úBDataFrameGroupBy._define_paths.<locals>.<lambda>.<locals>.<lambda>rá ©rn r¬ r ©rp ro rq rV rK rL r l s ÿc s | f S rg rK r r rK rL r p r c s | j fddjdS )Nc s | f S rg rK r r rK rL r r r r¡ rá r¢ r r£ rK rL r q s ÿ)r~ r )rV ro rp rq r r rK r£ rL r i s
|
z DataFrameGroupBy._define_pathsr )r r rÔ c C s¾ |}||}| j dkr ||fS z ||}W n0 tk
|
r@ Y n tk
|
rZ ||f Y S X t|tr~|j |j¡s¨||fS n*t|tr |j |j¡s¨||fS n||fS | |¡r¶|}||fS r ) r r Ú Exceptionr~ r2 r Úequalsr= rz )rV r r rÔ r r Zres_fastrK rK rL r v s(
|
|
|
|
|
|
z DataFrameGroupBy._choose_pathTrÆ c O s g }| j }| jj|| jd}|D ]\}} t | d|¡ || f||}
|
z |
|
¡ }
|
W n tk
|
rf Y nX t|
|
st |
|
rt
|
|
|
rt |
|
r´|
|
r´| | |¡¡ q tdt|
|
j dq | ||¡S )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á rR zfilter function returned a z , but expected a scalar bool)r^ r rä r¬ rÑ rÒ ZsqueezeÚAttributeErrorr$ r* r+ r, rµ rï ra rb rF rñ ) rV ro rÇ rp rq rò rS r rR rÔ r rK rK rL rô s" ) ÿzDataFrameGroupBy.filterz DataFrameGroupBy | SeriesGroupByc s< | j dkrtdt|tr0t|dkr0tdt |¡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É rm Ú __getitem__)rV r« rr rK rL r§ ß s
|
ÿz DataFrameGroupBy.__getitem__rO )Úndimc C s |dkrJ|dkr| j }t|| j| j| j| j| j|| j| j| j| j | j
|
d S |dkr|dkrd| j | }t || j| j| j|| j| j| j| j | j
|
d
|
S t ddS )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
|
é N)
|
r¬ Úlevelr r
Ú selectionr r÷ Ú
|
group_keysrÌ rÇ r{ ) rª r r
r« r r÷ r¬ rÌ rÇ zinvalid ndim for _gotitem) rS r| r r¬ rª r
r r÷ r¬ rÌ rÇ rM r )rV r« r¨ ÚsubsetrK rK rL Ú_gotitemí sB ô
|
ö zDataFrameGroupBy._gotitemrX r[ r r\ c C s4 | j }| jdkr|jj}n|j}|r0|jdd}|S )Nr{ Frú )r r¬ r r_ Zget_numeric_data)rV rY rR rS rO rK rK rL rd s
|
|
z'DataFrameGroupBy._get_data_to_aggregatez"Mapping[base.OutputKey, ArrayLike])rÁ rP c C sT dd | ¡ D }tdd |D }| | j d| j ¡j¡ | j |¡}||_ |S )zQ
|
Wrap the dict result of a GroupBy aggregation into a DataFrame.
|
c S s i | ]\}}|j |qS rK r® r¯ rK rK rL r± 0 s z?DataFrameGroupBy._indexed_output_to_ndframe.<locals>.<dictcomp>c S s g | ]
|
}|j qS rK r© rª rK rK rL r£ 1 s z?DataFrameGroupBy._indexed_output_to_ndframe.<locals>.<listcomp>r{ )
|
r³ r9 Z
|
_set_namesr Z _get_axisr¬ r# rS rT r )rV rÁ rÀ r r rK rK rL r * s z+DataFrameGroupBy._indexed_output_to_ndframerN c C s | j |¡S rg )rS rT rU rK rK rL rW 8 s z$DataFrameGroupBy._wrap_agged_manager©rS c c sD t |jD ]4\}}|t|jd d
|f || j| j| jdfV q
|
d S )N)r« r r
rÌ )r· r rM r} r r
rÌ )rV rS ÚiZcolnamerK rK rL Ú_iterate_column_groupbys; s ûz)DataFrameGroupBy._iterate_column_groupbys)rS rP c sV ddl m} |j} fdd| |¡D }t|sDtg || jjdS |||ddS d S )Nr r§ c s g | ]\}} |qS rK rK )r¡ r Z col_groupby©ro rK rL r£ I s z>DataFrameGroupBy._apply_to_column_groupbys.<locals>.<listcomp>©r rz r{ )r r¬ )rå r¨ r r± rÉ r2 r r )rV ro rS r¨ r r½ rK r² rL Ú_apply_to_column_groupbysE s
|
ÿz*DataFrameGroupBy._apply_to_column_groupbysrõ c sb | j dkr$| j fdd| jddS | j}| j fdd|d}| js^tt||_| |¡}|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 s
|
| ¡S rg ©r ©ZsgbrÆ rK rL r r z*DataFrameGroupBy.nunique.<locals>.<lambda>Tr c s
|
| ¡S rg rµ r¶ rÆ rK rL r r r¯ ) r¬ rU r r´ r r< rÉ rz rÎ )rV rÇ rS r½ rK rÆ rL r S s -
|
|
ÿ
|
ÿ
|
zDataFrameGroupBy.nuniquer7 rE c s: dkr| j fdd}d|_| j|| jdd}|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
|
|
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
|
Nc s | j dS ©NrH )r[ ©Zdf©r¬ rY rF rK rL ro Þ s z%DataFrameGroupBy.idxmax.<locals>.funcr[ TrS ©r¬ rF rU r ©rV r¬ rF rY ro r rK r¹ rL r[ s J ÿzDataFrameGroupBy.idxmaxc s: dkr| j fdd}d|_| j|| jdd}|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
|
|
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
|
Nc s | j dS r· )rX r¸ r¹ rK rL ro 4 s z%DataFrameGroupBy.idxmin.<locals>.funcrX TrS rº r» rK r¹ rL rX ç s J ÿzDataFrameGroupBy.idxminzSequence[Hashable] | None)r r r÷ r rÇ rP c C s | |||||¡S )u'
|
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
|
)r% )rV r r r÷ r rÇ rK rK rL r' ? s oz DataFrameGroupBy.value_countsz'Hashable | Mapping | Series | DataFramer6 zDataFrame | None)r9 r: r¬ r; rP c C s | j d||||||d}|S )aÈ
|
Fill NA/NaN values using the specified method within groups.
|
|
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.groupby([0, 0, 1, 1], axis=1).fillna(method="ffill")
|
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.groupby([0, 0, 1, 1], axis=1).fillna(method="bfill")
|
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@ rA rK rK rL r> ° s xù zDataFrameGroupBy.fillnar rB c K s | j d||d|}|S )ae
|
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.
|
**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) rC )r) r@ rD rK rK rL r) 3 s ]zDataFrameGroupBy.takezAxis | None | lib.NoDefaultc K s | j d|||d|}|S )at
|
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
|
|
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
|
rG rH )rG r@ rI rK rK rL rG s F ÿüûzDataFrameGroupBy.skewr5 c C s t | }|S rg rJ rK rK rK rL rL â s zDataFrameGroupBy.plotr\ r{ z/str | Callable[[np.ndarray, np.ndarray], float])r: r^ rY rP c C s | j d|||d}|S )Nr_ )r: r^ rY r@ )rV r: r^ rY r rK rK rL r_ è s ÿzDataFrameGroupBy.corrr8 )r^ r` rY rP c C s | j d|||d}|S )Nra )r^ r` rY r@ )rV r^ r` rY r rK rK rL ra ô s ÿzDataFrameGroupBy.covrf r rg rh ri ) rD rj rk rl rm rn ÚsharexÚshareyro Úlayoutr rp rq c K s4 | j d||||||||| |
|
| | | ||d|}|S )Nrr )rD rs rj rk rl rm rn rt r¼ r½ ro r¾ r rp rq )rr r@ )rV rD rs rj rk rl rm rn rt r¼ r½ ro r¾ r rp rq rq r rK rK rL rr
|
s, ÿðïzDataFrameGroupBy.histr= c C s | dd ¡S )Nc S s | j S rg )r r¸ rK rK rL r -
|
r z)DataFrameGroupBy.dtypes.<locals>.<lambda>rd rh rK rK rL r )
|
s zDataFrameGroupBy.dtypesr r )r] r¬ Údropr: rY rP c C s | j d|||||d}|S )NÚcorrwith)r] r¬ r¿ r: rY r@ )rV r] r¬ r¿ r: rY r rK rK rL rÀ /
|
s úzDataFrameGroupBy.corrwith)N)FF)Fr )T)N)T)NTF)NTF)NFTFT)NNNFNN)r )r\ r{ F)Nr{ F)NNTNNNNNFFNNrf NF)r Fr\ F)4rF rG rH r rv r" r6 r rx r ri r~ rÐ r rà rê Z)_DataFrameGroupBy__examples_dataframe_docr! r r8 rÙ r r rô r§ r® rd r rW r± r´ r r[ rX r? Zboxplotr' r> r) r ry rG rz r2 rL rI r_ ra rr r rÀ r{ rK rK rr rL r| sÐ ÿ] F û?4 ü +ÿ6
|
$E1 ÿ
|
@ üX üV ús ù ýbüO
|
|
ü
|
ü
|
ð*(
|
|
úr| r2 r )rS rÔ r rP c C s¶ ddl m} t|tr|j | j¡rN||gt|j dd}|j|_|j|_n(| jt
|
|j t|jdf¡|j|jd}t|t st |S t|t r®|j |j¡s®| |¡d S |S d S )Nr r§ r{ rá r³ )rº r¨ r~ r= rz Úis_rÉ r rT rç r/ r¹ r2 r Z _align_frame)rS rÔ r r¨ Z res_framerK rK rL r C
|
s
|
|
ýr )erI Ú
|
__future__r Ú collectionsr Ú functoolsr Útextwrapr Útypingr r r r r
|
r r r r r r r Únumpyrç Z pandas._libsr r r rÓ Zpandas._typingr r r r r r r r r r Z pandas.errorsr Zpandas.util._decoratorsr r! r" Zpandas.core.dtypes.commonr# r$ r% r& r' r( r) r* Zpandas.core.dtypes.missingr+ r, Z pandas.corer- Zpandas.core.applyr. r/ r0 r1 Zpandas.core.commonÚcoreÚcommonr Zpandas.core.framer2 Zpandas.core.groupbyr3 Zpandas.core.groupby.groupbyr4 r5 r6 r7 r8 Zpandas.core.indexes.apir9 r: r; r< Zpandas.core.seriesr= Zpandas.core.util.numba_r> Zpandas.plottingr? rº r@ Zpandas.core.genericrA r rE rB rC rM r| r rK rK rK rL Ú<module> sd 80 (
|
B
|
