U
|
¬ý°d¸¼ ã @ s¶ d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dl Z d dl
|
m Z m Z m Z mZmZmZmZmZmZmZmZmZ d dlZd dlmZ d dlm Z d d l m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z% d d
|
l&m'Z' d d l(m)Z) d d l*m+Z+ d d l,m-Z-m.Z.m/Z/m0Z0 d dl1m2Z2m3Z3m4Z4 d dl5m6Z6 d dl7m8Z8 d dl9m: m;Z< d dl=m>Z> e rd dl?m@Z@mAZAmBZB d dlCmDZD d dlEmFZF d dlGmHZH eeIe f ZJdTdddddd d d d ZKG d d! d!ejLd"ZMG d#d$ d$eMZNG d%d d eNZOG d&d' d'eOZPG d(d) d)eOZQG d*d+ d+eNZRG d,d- d-eMZSG d.d/ d/eMZTd0d1d2d3d4ZUdd5d6d7ZVd8d9d:d;d<ZWd=d=d>d?d@ZXdAdBdCdDdEdFdGdHZYdIdIdJdKdLZZdMdMdNdOdPZ[d8dQd:dRdSZ\dS )Ué )Ú annotationsN)Ú defaultdict)Ú nullcontext)Úpartial) Ú TYPE_CHECKINGÚAnyÚCallableÚContextManagerÚ DefaultDictÚDictÚHashableÚIterableÚIteratorÚListÚSequenceÚcast)Úoption_context)Úlib)Ú AggFuncTypeÚAggFuncTypeBaseÚAggFuncTypeDictÚ
|
AggObjTypeÚAxisÚAxisIntÚNDFrameTÚnpt)ÚSpecificationError)Úcache_readonly)Úis_nested_object)Ú is_dict_likeÚis_extension_array_dtypeÚ is_list_likeÚ is_sequence)Ú ABCDataFrameÚ
|
ABCNDFrameÚ ABCSeries)Ú safe_sort)ÚSelectionMixin)Ú ensure_wrapped_if_datetimelike)Ú DataFrameÚIndexÚSeries)ÚGroupBy)Ú Resampler)Ú
|
BaseWindowFr) r r Úboolú
|
str | NoneÚ
|
FrameApply)ÚobjÚfuncÚaxisÚrawÚ result_typeÚreturnc C s8 | |¡}|dkrt}n |dkr$t}|| |||||dS )z=construct and return a row or column based frame apply objectr é ©r5 r6 ÚargsÚkwargs)Ú_get_axis_numberÚ FrameRowApplyÚFrameColumnApply)r2 r3 r4 r5 r6 r: r; Úklass© r@ úHd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/apply.pyÚ frame_applyI s
|
|
úrB c @ sÊ e Zd ZU ded< ddddddd Zejd
|
d d d Zdd ddZd
|
d ddZ dd Z
|
d
|
d ddZ d
|
d ddZ d
|
d ddZ d
|
d dd Zd
|
d d d Zd d
|
d d d!d"d#Zd d$d%d&Zd'S )(ÚApplyr r4 r r/ r0 ÚNone)r2 r5 r6 r7 c s| || _ || _ pd| _p i | _|dkr0td|| _s> rhttjt fsht
|
sh fdd}n}| _ || _ d S )Nr@ )NÚreduceÚ broadcastÚexpandzUinvalid value for result_type, must be one of {None, 'reduce', 'broadcast', 'expand'}c s | f S ©Nr@ )Úx©r: r3 r; r@ rA Úf s zApply.__init__.<locals>.f) r2 r5 r: r; Ú
|
ValueErrorr6 Ú
|
isinstanceÚnpÚufuncÚstrr! Úorig_frK )Úselfr2 r3 r5 r6 r: r; rK r@ rJ rA Ú__init__g s*
|
|
ÿÿÿþýzApply.__init__úDataFrame | Series©r7 c C s d S rH r@ ©rR r@ r@ rA Úapply s z Apply.applyzDataFrame | Series | Nonec C sx | j }| j}| j}| j}t|tr*| ¡ S t|r:| ¡ S t |rJ|
|
¡ S t |rtt |¡}|rt|st|stt|| S dS )z»
|
Provide an implementation for the aggregators.
|
|
Returns
|
-------
|
Result of aggregation, or None if agg cannot be performed by
|
this method.
|
N)r2 rK r: r; rM rP Ú apply_strr Ú agg_dict_liker! Ú agg_list_likeÚcallableÚcomÚget_cython_funcÚgetattr©rR r2 Úargr: r; rK r@ r@ rA Úagg s
|
|
z Apply.aggc
|
sf | j }| j | j}| j}| j}|jdk}| |¡dkrV|r>t|jj df||jS t
|
rt st t t |rdd D n fdd|D t r¶t t | ¡S t t z| ¡}W nB tk
|
rä Y n. tk
|
r } ztd|W 5 d}~X Y nX t|ttfr:|jr:|js:tdt|ttfrZ|j |j¡sbtd|S ) aI
|
Transform a DataFrame or Series.
|
|
Returns
|
-------
|
DataFrame or Series
|
Result of applying ``func`` along the given axis of the
|
Series or DataFrame.
|
|
Raises
|
------
|
ValueError
|
If the transform function fails or does not transform.
|
r8 r c S s i | ]}t |¡p||qS r@ ©r\ Úget_callable_name©Ú.0Úvr@ r@ rA Ú
|
<dictcomp>Ï s z#Apply.transform.<locals>.<dictcomp>c s i | ]
|
}| qS r@ r@ )re Úcol©r3 r@ rA rg Ñ s zTransform function failedNzFunction did not transform)r2 rQ r4 r: r; Úndimr< ÚAssertionErrorÚTÚ transformr! r r r r r Útransform_dict_likeÚtransform_str_or_callableÚ TypeErrorÚ ExceptionrL rM r% r# ÚemptyÚindexÚequals)rR r2 r4 r: r; Z is_seriesÚresultÚerrr@ ri rA rm ° sH
|
|
|
|
ÿþýÿzApply.transformc
|
C s ddl m} | j}| j}| j}t|ts,tt|dkr@t d|
|
d||¡}i }| ¡ D ].\}}|j |dd} | j |df||||< qZ||ddS )zC
|
Compute transform in the case of a dict-like func
|
r ©Úconcatz$No transform functions were providedrm r8 ©rj ©r4 )Úpandas.core.reshape.concatrx r2 r: r; rM r$ rk ÚlenrL Únormalize_dictlike_argÚitemsÚ_gotitemrm )
|
rR r3 rx r2 r: r; ÚresultsÚnameÚhowÚcolgr@ r@ rA rn ó s zApply.transform_dict_likec C s | j }| j}| j}t|tr0| j||f||S |sR|sRt |¡}|rRt|| S z|j |fd|i|W S t
|
k
|
r ||f|| Y S X dS )zL
|
Compute transform in the case of a string or callable func
|
r: N) r2 r: r; rM rP Ú _try_aggregate_string_functionr\ r] r^ rW rq )rR r3 r2 r: r; rK r@ r@ rA ro s
|
|
z Apply.transform_str_or_callablec
|
C sP ddl m}m} ddlm} | j}ttt | j }t
|
|dddkrJt dt |t sZ|}n|jjdkrn|j}n|j}g }g }t |||f} | rt |dd¡}
|
nt }
|
|
|
, |jdkr:|D ]z} |j|jd|d } t | ttfrü| j| | jf| j| j} n| j| f| j| j} | | ¡ t | ¡p*| }| |¡ q¼ng }t |D ]~\}}|j|d|j d
|
d
|
|f d } t | ttfr| j|| jf| j| j} n| j|f| j| j} | | ¡ | |¡ qF|j !|¡}W 5 Q R X z|||dd d W S t"k
|
rJ } z<dd l#m$} ||||jd}t%|r2t&d|| W Y ¢S d
|
}~X Y nX d
|
S )z
|
Compute aggregation in the case of a list-like argument.
|
|
Returns
|
-------
|
Result of aggregation.
|
r ©ÚDataFrameGroupByÚ SeriesGroupByrw r4 r8 ú"axis other than 0 is not supportedÚas_indexT)rj ZsubsetNF)Úkeysr4 Úsort©r+ )rs r z3cannot combine transform and aggregation operations)'Úpandas.core.groupby.genericr r r{ rx r2 r r r rK r^ ÚNotImplementedErrorrM r' Ú _selected_objrj Z_obj_with_exclusionsr\ Ú temp_setattrr r r r% r# Ú aggregater4 r: r; Úappendrc Ú enumerateZilocÚcolumnsZtakerp Úpandasr+ r rL )rR r r rx r2 r` Ú selected_objr r Ú
|
is_groupbyÚcontext_managerÚar Znew_resr Úindicesrs rh rv r+ ru r@ r@ rA rZ ! s|
|
ÿÿÿ
|
ÿÿÿ
|
|
ÿþzApply.agg_list_likec sô ddl m} ddlm}m} ddlm} | jtt | j
|
}t dddkrRt dt tsf}d}n j}j}| d ||¡}t ||f}|r¢t d
|
d ¡} nt } | L |jdkrÞj|dd fd d| ¡ D nfdd| ¡ D W 5 Q R X t| ¡ }
|
dd ¡ D } t| r¢fdd|
|
D } | g krF| n|
|
} |jdkrp|| } | |j j ¡ | } t t rdnd}|fdd| D || d}nNt | r¶t!dn:ddl m"} jdkràtdj#}nd}||d}|S )z
|
Compute aggregation in the case of a dict-like argument.
|
|
Returns
|
-------
|
Result of aggregation.
|
r ©r* r
rw r4 r8 r Nra r Try c s i | ]\}}| |¡qS r@ )ra ©re Úkeyr )r r@ rA rg ¡ s z'Apply.agg_dict_like.<locals>.<dictcomp>c s& i | ] \}}| j |d d |¡qS )r8 ry )r ra r )r2 r@ rA rg ¤ s c S s g | ]}t |tqS r@ )rM r$ )re Úrr@ r@ rA Ú
|
<listcomp>¬ s z'Apply.agg_dict_like.<locals>.<listcomp>c s g | ]} | j s|qS r@ )rr ©re Úk©r r@ rA r ± s
|
é c s i | ]}| | qS r@ r@ r r¢ r@ rA rg ¼ s )r4 r zLcannot perform both aggregation and transformation operations simultaneouslyr r+ )r )$r r* r r r r{ rx r2 r r rK r^ r rM r' r Z
|
_selectionr} r\ r r rj r r~ Úlistr ÚvaluesÚallZ
|
_set_namesr Únamesr% ÚanyrL r+ r )rR r* r r rx r` r Z selectionr r r Z
|
is_ndframeZ keys_to_useZktur4 ru r+ r r@ )r r2 r rA rY v sd
|
|
|
ÿ
|
ý
|
ÿ
|
zApply.agg_dict_likec C s t t| j}| j}t||d}t|rzt |¡}|j|j }| j
|
dkrfd|ksV|dkrft d| dd|krz| j
|
| j d< | j ||f| j| j S )zy
|
Compute apply in case of a string.
|
|
Returns
|
-------
|
result: Series or DataFrame
|
Nr r4 )ZcorrwithZskewz
|
Operation z does not support axis=1)r rP rK r2 r^ r[ ÚinspectÚgetfullargspecr: Ú
|
kwonlyargsr4 rL r; r )rR rK r2 r3 ÚsigÚ arg_namesr@ r@ rA rX Ö s
|
|
ÿÿ zApply.apply_strc C s | j j| j| jf| j| jS )zÜ
|
Compute apply in case of a list-like or dict-like.
|
|
Returns
|
-------
|
result: Series, DataFrame, or None
|
Result when self.f is a list-like or dict-like, None otherwise.
|
)r2 r rK r4 r: r; rV r@ r@ rA Úapply_multipleò s zApply.apply_multiplerP r )r r2 r3 r7 c sþ |dks t |dkr4t|tr4tdd | ¡ D sJtdd | ¡ D rRtd|jdkrt| ¡ t|j }t
|
|dkrt t t |}t d | d
|
t ttf t fd d| ¡ D rúi }| ¡ D ]&\}}t| sì|g||< qÎ|||< qÎ|}|S ) a
|
Handler for dict-like argument.
|
|
Ensures that necessary columns exist if obj is a DataFrame, and
|
that a nested renamer is not passed. Also normalizes to all lists
|
when values consists of a mix of list and non-lists.
|
)rW ra rm ra c s s | ]\}}t |V qd S rH )r! ©re Ú_rf r@ r@ rA Ú <genexpr> s z/Apply.normalize_dictlike_arg.<locals>.<genexpr>c s s | ]\}}t |V qd S rH )r r¯ r@ r@ rA r± s z nested renamer is not supportedr8 r z
|
Column(s) z do not existc 3 s | ]\}}t | V qd S rH )rM )re r° rI ©Zaggregator_typesr@ rA r± s )rk rM r% r¨ r~ r rj Úsetr r r| r¤ r& ÚKeyErrorÚtupleÚdict) rR r r2 r3 ÚcolsZ cols_sortedÚnew_funcr¡ rf r@ r² rA r} ý s0
|
ÿþýü
|
|
|
|
z Apply.normalize_dictlike_arg)r` c O s° t |tstt||d}|dk rbt|r4|||S t|dksDttdd |D dks^t|S tt|d}|dk rt|dr||f||S td| dt |j
|
ddS ) z´
|
if arg is a string, then try to operate on it:
|
- try to find a function (or attribute) on ourselves
|
- try to find a numpy function
|
- raise
|
Nr c S s g | ]}|d kr|qS )rz r@ )re Úkwargr@ r@ rA r : s z8Apply._try_aggregate_string_function.<locals>.<listcomp>Z __array__ú'z ' is not a valid function for 'z' object) rM rP rk r^ r[ r| rN ÚhasattrÚAttributeErrorÚtypeÚ__name__r_ r@ r@ rA r ) s
|
ÿz$Apply._try_aggregate_string_functionN)r¾ Ú
|
__module__Ú __qualname__Ú__annotations__rS ÚabcÚabstractmethodrW ra rm rn ro rZ rY rX r® r} r r@ r@ r@ rA rC d s
|
& CU` ,rC )Ú metaclassc @ s> e Zd ZU dZded< eddddZedddd Zd
|
S ) Ú NDFrameApplyzg
|
Methods shared by FrameApply and SeriesApply but
|
not GroupByApply or ResamplerWindowApply
|
rT r2 r* rU c C s | j jS rH )r2 rs rV r@ r@ rA rs O s zNDFrameApply.indexc C s | j | j¡S rH )r2 Z _get_agg_axisr4 rV r@ r@ rA Úagg_axisS s zNDFrameApply.agg_axisN)r¾ r¿ rÀ Ú__doc__rÁ Úpropertyrs rÆ r@ r@ r@ rA rÅ G s
|
rÅ c s0 e Zd ZU ded< eejddddZeejddddZeejd dd
|
d Z ejd dd dddZ
|
eddddZ eddddZ e dd Ze ddddZd dddZ fd d Zd d Zd d! Zddd"d#d$Zd%d& Zd'dd(d)Zd dd dd*d+Zd d fd,d- Z ZS ).r1 r) r2 r* rU c C s d S rH r@ rV r@ r@ rA Ú result_index^ s zFrameApply.result_indexc C s d S rH r@ rV r@ r@ rA Úresult_columnsc s zFrameApply.result_columnszIterator[Series]c C s d S rH r@ rV r@ r@ rA Úseries_generatorh s zFrameApply.series_generatorÚResTyperT ©r Ú res_indexr7 c C s d S rH r@ ©rR r rÎ r@ r@ rA Úwrap_results_for_axism s z FrameApply.wrap_results_for_axisc C s | j S rH )rÊ rV r@ r@ rA Ú res_columnsu s zFrameApply.res_columnsc C s | j jS rH )r2 r rV r@ r@ rA r y s zFrameApply.columnsc C s | j jS rH )r2 r¥ rV r@ r@ rA r¥ } s zFrameApply.valuesr+ c C s | j jS rH )r2 ÚdtypesrV r@ r@ rA rÒ s zFrameApply.dtypesc C sÒ t | jr| ¡ S t| jdkr6t| jdkr6| ¡ S t| jtrJ| ¡ S t| jt
|
j rt
|
j dd | j jjd| jd}W 5 Q R X | j j|dS | jdkr¨| | j ¡S t| j js¼| ¡ S | jrÊ| ¡ S | ¡ S )zcompute the resultsr Úignore©r¦ rW ri ©ÚdatarF )r! rK r® r| r rs Úapply_empty_resultrM rP rX rN rO Úerrstater2 Ú_mgrrW Ú _constructorr6 Úapply_broadcastr¦ Úshaper5 Ú apply_rawÚapply_standard)rR r r@ r@ rA rW
s"
|
|
zFrameApply.applyc s | j }| j}| jdkr | j n| j j| _ d| _d }zt ¡ }W 5 || _ || _X |dkrh|d k rd|jn|}|d kr| j j| j|fd| ji| j}|S )Nr r8 r: ) r2 r4 rl Úsuperra rW rQ r: r; )rR r2 r4 ru ©Ú __class__r@ rA ra ¨ s zFrameApply.aggc C sâ t | jst| jdkr"| j ¡ S | jdk}ddlm} |sz:| jdkr^| |g t j
|
d¡}n| || j t j
|
d¡}W n t k
|
r Y nX t || }|rÔt| jr¼| |g t j
|
d¡}nt j}| jj|| jdS | j ¡ S dS ) zµ
|
we have an empty result; at least 1 axis is 0
|
|
we will try to apply the function to an empty
|
series in order to see if this is a reduction function
|
)rE NrE r r ©Údtype)rs rã ©rs N)r[ rK rk r6 r2 Úcopyr r+ r4 rN Úfloat64r rq rM r| rÆ ÚnanÚ_constructor_sliced)rR Z should_reducer+ r r@ r@ rA r× ¿ s&
|
|
|
|
|
z FrameApply.apply_empty_resultc C sV dd }t || j| j| j¡}|jdkr@| jj|| j| j dS | jj
|
|| j dS dS )z$apply to the values as a numpy arrayc s fdd}|S )z
|
Wrap user supplied function to work around numpy issue.
|
|
see https://github.com/numpy/numpy/issues/8352
|
c s& | |}t |tr"tj|td}|S )Nrâ )rM rP rN ÚarrayÚobject)r: r; ru ri r@ rA Úwrapperñ s
|
|
z<FrameApply.apply_raw.<locals>.wrap_function.<locals>.wrapperr@ )r3 rë r@ ri rA Ú wrap_functionê s z+FrameApply.apply_raw.<locals>.wrap_functionr£ ©rs r rä N) rN Zapply_along_axisrK r4 r¥ rj r2 rÚ rs r rè rÆ )rR rì ru r@ r@ rA rÝ ç s
|
|
zFrameApply.apply_raw©Útargetr7 c C s¨ t | jstt |j¡}|jd }t|jD ]^\}}| || ¡}t |¡j
|
}|dkr`t d|dkr||t |kr|t d||d d
|f< q.| j j||j|jd}|S )Nr r8 ztoo many dims to broadcastzcannot broadcast resultrí )r[ rK rk rN Z
|
empty_liker¥ rÜ r r Zasarrayrj rL r| r2 rÚ rs ) rR rï Z result_valuesZresult_compareÚirh ÚresZaresru r@ r@ rA rÛ s$
|
ÿzFrameApply.apply_broadcastc C s | ¡ \}}| ||¡S rH )Úapply_series_generatorÚ wrap_resultsrÏ r@ r@ rA rÞ s zFrameApply.apply_standardztuple[ResType, Index]c C s~ t | jst| j}| j}i }tdd H t|D ]8\}}| |¡||< t|| tr2|| j dd||< q2W 5 Q R X ||fS )Nzmode.chained_assignmentF)Údeep)
|
r[ rK rk rË rÉ r r rM r% rå )rR Z
|
series_genrÎ r rð rf r@ r@ rA rò # s z!FrameApply.apply_series_generatorc C sv ddl m} t|dkr8d|kr8t|d r8| ||¡S | jj}t|dkrd||krd||tjd}n||}||_ |S )Nr r râ )
|
r r+ r| r" rÐ r2 rè rN ræ rs )rR r rÎ r+ Zconstructor_slicedru r@ r@ rA ró 6 s zFrameApply.wrap_resultsc s6 | j dkr,| j}|j| j }|j|| jdS t ¡ S )NÚsizerä )rK r2 rÜ r4 rè rÆ rß rX )rR r2 Úvaluerà r@ rA rX K s
|
|
zFrameApply.apply_str)r¾ r¿ rÀ rÁ rÈ r rà rÉ rÊ rË rÐ rÑ r r r¥ rÒ rW ra r× rÝ rÛ rÞ rò ró rX Ú __classcell__r@ r@ rà rA r1 X s:
|
|
# ( c @ s\ e Zd ZU dZded< edd Zedddd Zeddd
|
d Zd dd dddZ dS )r= r r r4 c s fddt t jD S )Nc 3 s | ]} j j|d dV qdS )r8 rz N)r2 Ú_ixs)re rð rV r@ rA r± [ s z1FrameRowApply.series_generator.<locals>.<genexpr>)Úranger| r rV r@ rV rA rË Y s z FrameRowApply.series_generatorr* rU c C s | j S rH ©r rV r@ r@ rA rÉ ] s zFrameRowApply.result_indexc C s | j S rH rä rV r@ r@ rA rÊ a s z FrameRowApply.result_columnsrÌ rT rÍ c
|
C sþ | j dkr | j |¡}||_|S | j dkrVtdd | ¡ D rV| j |¡}||_|S z| jj|d}W nN tk
|
r¶ } z0dt|kr¤| j |¡}||_| W Y ¢S W 5 d}~X Y nX t |d t
|
sât |jt | j krâ| j |_t |j t |krú||_ |S )z return the results for the rowsrE Nc s s | ]}t |tV qd S rH )rM r¶ )re rI r@ r@ rA r± p s z6FrameRowApply.wrap_results_for_axis.<locals>.<genexpr>rÕ z%All arrays must be of the same lengthr )r6 r2 rè rs r¦ r¥ rÚ rL rP rM r% r| rÑ r )rR r rÎ rñ ru rv r@ r@ rA rÐ e s0
|
ÿ z#FrameRowApply.wrap_results_for_axisN)
|
r¾ r¿ rÀ r4 rÁ rÈ rË rÉ rÊ rÐ r@ r@ r@ rA r= V s
|
|
r= c s e Zd ZU dZded< ddd fdd Zedd Zed
|
d d d Zed
|
d ddZ dd
|
ddddZ
|
dd
|
ddddZ Z S )r> r8 r r4 r) rî c s t |j¡}|jS rH )rß rÛ rl )rR rï ru rà r@ rA rÛ s z FrameColumnApply.apply_broadcastc c s¦ | j }t|}t|dks t| jjddd}|j}t|jrh| j}t t|D ]}|j|ddV qPn:t
|
|| j D ],\}}||_| |¡ t |d|¡ |V qtd S )Nr rz Ú_name)r¥ r( r| rk r2 rø rÙ r rã rù Úziprs Z
|
set_valuesrê Ú __setattr__)rR r¥ ZserZmgrr2 rð Zarrr r@ r@ rA rË s
|
|
z!FrameColumnApply.series_generatorr* rU c C s | j S rH rä rV r@ r@ rA rÉ ° s z FrameColumnApply.result_indexc C s | j S rH rú rV r@ r@ rA rÊ ´ s z FrameColumnApply.result_columnsrÌ rT rÍ c C sJ | j dkr| ||¡}n.t|d ts:| j |¡}||_n | ||¡}|S )z"return the results for the columnsrG r )r6 Úinfer_to_same_shaperM r% r2 rè rs ©rR r rÎ ru r@ r@ rA rÐ ¸ s
|
z&FrameColumnApply.wrap_results_for_axisc C s* | j j|d}|j}||_|jdd}|S )z7infer the results to the same shape as the input objectrÕ F©rå )r2 rÚ rl rs Z infer_objectsrÿ r@ r@ rA rþ Í s
|
z$FrameColumnApply.infer_to_same_shape) r¾ r¿ rÀ r4 rÁ rÛ rÈ rË rÉ rÊ rÐ rþ r÷ r@ r@ rà rA r> s
|
|
r> c st e Zd ZU ded< dZded< ddddd fd
|
d Zd d ddZ fddZdd ddZd d ddZ Z
|
S )Ú SeriesApplyr+ r2 r r r4 r r/ rD )r2 r3 Ú convert_dtyper7 c s" || _ t j||dd ||d d S ©NFr9 )r rß rS )rR r2 r3 r r: r; rà r@ rA rS ß s úzSeriesApply.__init__rT rU c C sH | j }t|dkr| ¡ S t| jr,| ¡ S t| jtr@| ¡ S | ¡ S )Nr )
|
r2 r| r× r! rK r® rM rP rX rÞ ©rR r2 r@ r@ rA rW ò s
|
zSeriesApply.applyc
|
sp t ¡ }|d krl| j}| j}t|s*t| dd ¡ z| j |¡}W n$ t t
|
t fk
|
rj || j}Y nX |S )NZ_level) rß ra rK r; r[ rk Úpopr2 rW rL r¼ rp )rR ru rK r; rà r@ rA ra s
|
|
zSeriesApply.aggc C s" | j }|j|j|jdj|ddS )N)rã rs rW ©Úmethod)r2 rÚ rã rs Ú __finalize__r r@ r@ rA r× s
|
ÿz SeriesApply.apply_empty_resultc
|
C sÔ t t| j}| j}tjddh t|tjr@||W 5 Q R £ S t|j rdt
|
|j drd|j |¡}n | t¡j }tj||| jd}W 5 Q R X t|r¶t|d tr¶|jt||jdS |j||jdj|ddS d S ) NrÓ rÔ Úmap)Úconvertr rä rW r )r r rK r2 rN rØ rM rO r rã r» Z_valuesr Zastyperê r Z map_inferr r| r% Z_constructor_expanddimr¤ rs rÚ r )rR rK r2 Zmappedr¥ r@ r@ rA rÞ % s& ý ÿzSeriesApply.apply_standard) r¾ r¿ rÀ rÁ r4 rS rW ra r× rÞ r÷ r@ r@ rà rA r Û s
|
r c s6 e Zd Zdddd fdd Zdd Zd d
|
Z ZS ) Ú GroupByApplyzGroupBy[NDFrameT]r rD ©r2 r3 r7 c s: | ¡ }|j | dd¡¡| _t j||dd ||d d S )Nr4 r Fr9 )rå r2 r< Úgetr4 rß rS ©rR r2 r3 r: r; rà r@ rA rS E s úzGroupByApply.__init__c C s t d S rH ©r rV r@ r@ rA rW W s zGroupByApply.applyc C s t d S rH r rV r@ r@ rA rm Z s zGroupByApply.transform)r¾ r¿ rÀ rS rW rm r÷ r@ r@ rà rA r D s r c sL e Zd ZU dZded< ded< dddd fd d
|
Zd d Zd d Z ZS )ÚResamplerWindowApplyr r r4 zResampler | BaseWindowr2 r rD r c s t j||dd ||d d S r )rß rS r rà r@ rA rS b s úz ResamplerWindowApply.__init__c C s t d S rH r rV r@ r@ rA rW r s zResamplerWindowApply.applyc C s t d S rH r rV r@ r@ rA rm u s z ResamplerWindowApply.transform) r¾ r¿ rÀ r4 rÁ rS rW rm r÷ r@ r@ rà rA r ^ s
|
|
r zAggFuncType | NonezNtuple[bool, AggFuncType | None, list[str] | None, npt.NDArray[np.intp] | None])r3 r7 c K sr | dkot f |}d}d}|sTt| trDt| tt| krDtd| dkrTtd|rft|\} }}|| ||fS )aÅ
|
This is the internal function to reconstruct func given if there is relabeling
|
or not and also normalize the keyword to get new order of columns.
|
|
If named aggregation is applied, `func` will be None, and kwargs contains the
|
column and aggregation function information to be parsed;
|
If named aggregation is not applied, `func` is either string (e.g. 'min') or
|
Callable, or list of them (e.g. ['min', np.max]), or the dictionary of column name
|
and str/Callable/list of them (e.g. {'A': 'min'}, or {'A': [np.min, lambda x: x]})
|
|
If relabeling is True, will return relabeling, reconstructed func, column
|
names, and the reconstructed order of columns.
|
If relabeling is False, the columns and order will be None.
|
|
Parameters
|
----------
|
func: agg function (e.g. 'min' or Callable) or list of agg functions
|
(e.g. ['min', np.max]) or dictionary (e.g. {'A': ['min', np.max]}).
|
**kwargs: dict, kwargs used in is_multi_agg_with_relabel and
|
normalize_keyword_aggregation function for relabelling
|
|
Returns
|
-------
|
relabelling: bool, if there is relabelling or not
|
func: normalized and mangled func
|
columns: list of column names
|
order: array of columns indices
|
|
Examples
|
--------
|
>>> reconstruct_func(None, **{"foo": ("col", "min")})
|
(True, defaultdict(<class 'list'>, {'col': ['min']}), ('foo',), array([0]))
|
|
>>> reconstruct_func("min")
|
(False, 'min', None, None)
|
NzFFunction names must be unique if there is no new column names assignedz4Must provide 'func' or tuples of '(column, aggfunc).)Úis_multi_agg_with_relabelrM r¤ r| r³ r rp Ú normalize_keyword_aggregation)r3 r; Z
|
relabelingr Úorderr@ r@ rA Úreconstruct_funcy s ' ÿr rU c K s" t dd | ¡ D o t| dkS )ax
|
Check whether kwargs passed to .agg look like multi-agg with relabeling.
|
|
Parameters
|
----------
|
**kwargs : dict
|
|
Returns
|
-------
|
bool
|
|
Examples
|
--------
|
>>> is_multi_agg_with_relabel(a="max")
|
False
|
>>> is_multi_agg_with_relabel(a_max=("a", "max"), a_min=("a", "min"))
|
True
|
>>> is_multi_agg_with_relabel()
|
False
|
c s s$ | ] }t |tot|d kV qdS )r£ N)rM rµ r| rd r@ r@ rA r± Ë s z,is_multi_agg_with_relabel.<locals>.<genexpr>r )r¦ r¥ r| )r; r@ r@ rA r ¶ s
|
ÿr r¶ z,tuple[dict, list[str], npt.NDArray[np.intp]])r; r7 c C s ddl m} tt}g }tt| ¡ \}}|D ].\}}|| |¡ | |t |¡pX|f¡ q0t |}dd | ¡ D } t | }
|
||
|
|
|¡} ||| fS )aL
|
Normalize user-provided "named aggregation" kwargs.
|
Transforms from the new ``Mapping[str, NamedAgg]`` style kwargs
|
to the old Dict[str, List[scalar]]].
|
|
Parameters
|
----------
|
kwargs : dict
|
|
Returns
|
-------
|
aggspec : dict
|
The transformed kwargs.
|
columns : List[str]
|
The user-provided keys.
|
col_idx_order : List[int]
|
List of columns indices.
|
|
Examples
|
--------
|
>>> normalize_keyword_aggregation({"output": ("input", "sum")})
|
(defaultdict(<class 'list'>, {'input': ['sum']}), ('output',), array([0]))
|
r r c S s, g | ]$\}}|D ]}|t |¡p"|fqqS r@ rb )re ÚcolumnÚaggfuncsÚaggfuncr@ r@ rA r ÿ s þz1normalize_keyword_aggregation.<locals>.<listcomp>) Úpandas.core.indexes.baser* r r¤ rü r~ r r\ rc Ú_make_unique_kwarg_listÚ get_indexer) r; r* Zaggspecr r Úpairsr r Zuniquified_orderZ aggspec_orderZuniquified_aggspecÚ col_idx_orderr@ r@ rA r Ð s þr zSequence[tuple[Any, Any]])Úseqr7 c s fddt D S )a
|
Uniquify aggfunc name of the pairs in the order list
|
|
Examples:
|
--------
|
>>> kwarg_list = [('a', '<lambda>'), ('a', '<lambda>'), ('b', '<lambda>')]
|
>>> _make_unique_kwarg_list(kwarg_list)
|
[('a', '<lambda>_0'), ('a', '<lambda>_1'), ('b', '<lambda>')]
|
c sJ g | ]B\}} |¡d krB|d |d d d|
|¡ fn|qS )r8 r r° N)Úcount)re rð Úpair©r r@ rA r s ÿz+_make_unique_kwarg_list.<locals>.<listcomp>)r r r@ r rA r s
|
þr rT z dict[str, list[Callable | str]]zIterable[Hashable]z Iterable[int]zdict[Hashable, Series])ru r3 r r r7 c C sÎ ddl m} dd tt||dd dD }i }d}t| t oLt| jdk}| ¡ D ]r\} }
|
| | ¡ } |rd d |
|
D }
|
|| j
|
|
|
¡} | | } |||t|
|
| _
|
| j |d
|
d || < |t|
|
}qV|S ) a¥
|
Internal function to reorder result if relabelling is True for
|
dataframe.agg, and return the reordered result in dict.
|
|
Parameters:
|
----------
|
result: Result from aggregation
|
func: Dict of (column name, funcs)
|
columns: New columns name for relabelling
|
order: New order for relabelling
|
|
Examples:
|
---------
|
>>> result = DataFrame({"A": [np.nan, 2, np.nan],
|
... "C": [6, np.nan, np.nan], "B": [np.nan, 4, 2.5]}) # doctest: +SKIP
|
>>> funcs = {"A": ["max"], "C": ["max"], "B": ["mean", "min"]}
|
>>> columns = ("foo", "aab", "bar", "dat")
|
>>> order = [0, 1, 2, 3]
|
>>> _relabel_result(result, func, columns, order) # doctest: +SKIP
|
dict(A=Series([2.0, NaN, NaN, NaN], index=["foo", "aab", "bar", "dat"]),
|
C=Series([NaN, 6.0, NaN, NaN], index=["foo", "aab", "bar", "dat"]),
|
B=Series([NaN, NaN, 2.5, 4.0], index=["foo", "aab", "bar", "dat"]))
|
r r c S s g | ] }|d qS )r r@ )re r r@ r@ rA r < s z"relabel_result.<locals>.<listcomp>c S s | d S )Nr8 r@ )Útr@ r@ rA Ú<lambda>= ó z relabel_result.<locals>.<lambda>)r r8 c S s$ g | ] }t |ts t |¡n|qS r@ )rM rP r\ rc )re rK r@ r@ rA r [ s Fr ) r r* Úsortedrü rM r% r| r r~ Zdropnars r Zreindex) ru r3 r r r* Zreordered_indexesZreordered_result_in_dictÚidxZ reorder_maskrh ZfunÚsr r@ r@ rA Úrelabel_result s& ÿ ÿr' z Sequence[Any])r r7 c C s\ t | dkr| S d}g }| D ]:}t |¡dkrLt|}d| d|_|d7 }| |¡ q |S )aJ
|
Possibly mangle a list of aggfuncs.
|
|
Parameters
|
----------
|
aggfuncs : Sequence
|
|
Returns
|
-------
|
mangled: list-like
|
A new AggSpec sequence, where lambdas have been converted
|
to have unique names.
|
|
Notes
|
-----
|
If just one aggfunc is passed, the name will not be mangled.
|
r8 r z<lambda>z<lambda_ú>)r| r\ rc r r¾ r )r rð Úmangled_aggfuncsr r@ r@ rA Ú_managle_lambda_listp s r* r )Úagg_specr7 c C sl t | }|st| s| S t| }|r`| ¡ D ].\}}t|rPt |sPt|}n|}|||< q.nt| }|S )aZ
|
Make new lambdas with unique names.
|
|
Parameters
|
----------
|
agg_spec : Any
|
An argument to GroupBy.agg.
|
Non-dict-like `agg_spec` are pass through as is.
|
For dict-like `agg_spec` a new spec is returned
|
with name-mangled lambdas.
|
|
Returns
|
-------
|
mangled : Any
|
Same type as the input.
|
|
Examples
|
--------
|
>>> maybe_mangle_lambdas('sum')
|
'sum'
|
>>> maybe_mangle_lambdas([lambda: 1, lambda: 2]) # doctest: +SKIP
|
[<function __main__.<lambda_0>,
|
<function pandas...._make_lambda.<locals>.f(*args, **kwargs)>]
|
)r r! r½ r~ r* )r+ Zis_dictZmangled_aggspecr r r) r@ r@ rA Úmaybe_mangle_lambdas s
|
|
r, z0tuple[list[str], list[str | Callable[..., Any]]]c C sf d}t | }g }| ¡ D ]4}t|tsBt|sBt| t|j¡| |¡ q|s^d}t|||fS )aÛ
|
Validates types of user-provided "named aggregation" kwargs.
|
`TypeError` is raised if aggfunc is not `str` or callable.
|
|
Parameters
|
----------
|
kwargs : dict
|
|
Returns
|
-------
|
columns : List[str]
|
List of user-provied keys.
|
func : List[Union[str, callable[...,Any]]]
|
List of user-provided aggfuncs
|
|
Examples
|
--------
|
>>> validate_func_kwargs({'one': 'min', 'two': 'max'})
|
(['one', 'two'], ['min', 'max'])
|
z-func is expected but received {} in **kwargs.z2Must provide 'func' or named aggregation **kwargs.)
|
r¤ r¥ rM rP r[ rp Úformatr½ r¾ r )r; Ztuple_given_messager r3 Zcol_funcZno_arg_messager@ r@ rA Úvalidate_func_kwargs½ s r. )r FNNN)]Ú
|
__future__r rÂ Ú collectionsr Ú
|
contextlibr Ú functoolsr r© Útypingr r r r r
|
r r r r r r r ÚnumpyrN Zpandas._configr Z pandas._libsr Zpandas._typingr r r r r r r r Z pandas.errorsr Zpandas.util._decoratorsr Zpandas.core.dtypes.castr Zpandas.core.dtypes.commonr r r! r" Zpandas.core.dtypes.genericr# r$ r% Zpandas.core.algorithmsr& Zpandas.core.baser' Zpandas.core.commonÚcoreÚcommonr\ Zpandas.core.constructionr( r r) r* r+ Zpandas.core.groupbyr, Zpandas.core.resampler- Zpandas.core.window.rollingr. ÚintrÌ rB ÚABCMetarC rÅ r1 r= r> r r r r r r r r' r* r, r. r@ r@ r@ rA Ú<module> sh 8 (
|
ù f 9Li=;S!,
|
