Ë
|
nñúh&s ã ó U d dl mZ d dlZd dlmZ d dlmZmZmZm Z m
|
Z
|
m Z d dl Z d dl Zd dlmZ d dlmZmZmZmZmZmZmZ d dlmZ d dlm Z d d l m Z d d
|
l m!Z! d d l"m#Z#m$Z$m%Z% d d l&m'Z'm(Z( d d l)m*Z* d dl+m,Z,m-Z- d dl.m/c m0Z1 d dl2m3Z3m4Z4 d dl5m6Z6 d dl7m8Z8m9Z9 d dl:m/c m;Z< d dl=m>Z>m?Z? d dl@mAZA d dlBmCZCmDZDmEZEmFZFmGZG d dlHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZQmRZR d dlSmTZTmUZU d dlVmWZWmXZX d d lYmZZZm[Z[ d d l\m]Z]m^Z^ er(d d l_m`Z` d d lmaZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZk d d llmmZmmnZn i Zod!epd"< G d# d$eCe8« Zq G d% d&e8e9« Zr G d' d(eq« Zs G d) d*eres« Zt G d+ d,es« Zu G d- d.ereu« Zv G d/ d0es« Zw G d1 d2erew« Zxd@dAd3Zyeqjô ey_z dB dCd4Z{ G d5 d6eI« Z| dD dEd7Z} dF dGd8Z~ dF dHd9Z dId:Z dJ dKd;Z dL dMd<ZdNd=ZdOd>Z dPd?Z
y)Qé )Ú annotationsN)Údedent)Ú TYPE_CHECKINGÚCallableÚLiteralÚcastÚfinalÚ no_type_check)Úlib)Ú
|
BaseOffsetÚIncompatibleFrequencyÚNaTÚPeriodÚ TimedeltaÚ TimestampÚ to_offset)Úfreq_to_period_freqstr)ÚNDFrameT)Úfunction©ÚAbstractMethodError)ÚAppenderÚ SubstitutionÚdoc)Úfind_stack_levelÚrewrite_warning)Ú
|
ArrowDtype)Ú ABCDataFrameÚ ABCSeries)ÚResamplerWindowApplyÚwarn_alias_replacement)ÚArrowExtensionArray)Ú PandasObjectÚSelectionMixin)ÚNDFrameÚ _shared_docs)Ú SeriesGroupBy)Ú BaseGroupByÚGroupByÚ_apply_groupings_deprÚ_pipe_templateÚ get_groupby)ÚGrouper)Ú
|
BinGrouper)Ú
|
MultiIndex)ÚIndex)Ú DatetimeIndexÚ
|
date_range)Ú PeriodIndexÚ period_range)ÚTimedeltaIndexÚtimedelta_range)Ú is_subperiodÚis_superperiod)ÚDayÚTick)ÚHashable) Ú AnyArrayLikeÚAxisÚAxisIntÚ FrequencyÚ
|
IndexLabelÚInterpolateOptionsÚTÚTimedeltaConvertibleTypesÚTimeGrouperOriginÚTimestampConvertibleTypesÚnpt)Ú DataFrameÚSerieszdict[str, str]Ú_shared_docs_kwargsc ó e Zd ZU dZded< ded< ded< e« Zded < eh d
|
£« Zg d ¢Z dAdd dd dBdZ
|
e dCd« Z e dDd« Z e edEd« « ZdFdZd Ze d « Ze ed d¬« ee« dG fd « « « Z ed« Z ed « Ze eed eed d ¬ « dHd!« « Z e Z e Z e d" « Z d# Z dIdJd$Z!dHdKd%Z"d& Z#e dL dMd'« Z$d( Z%e dHdJd)« Z&e dHdJd*« Z'e dHdJd+« Z(e dHdJd,« Z)e dNd d dd-d e*jV d. dOd/« Z,e dHd0« Z-e dP dQd1« Z.e dP dQd2« Z/e dP dQd3« Z0e dP dQd4« Z1e ee2jf « dR dSd5« « Z3e ee2jh « dR dSd6« « Z4e ee2jj « dTdUd7« « Z5e dT dUd8« Z6e dV dWd9« Z7e dV dWd:« Z8e ee2jr « dV dWd;« « Z9e ee2jt « d< « « Z:e ee;jx « d= « « Z<e ee2jz « d> « « Z=e ee2j| « d? « « Z>e dXdYd@« Z? xZ@S )ZÚ Resamplera/
|
Class for resampling datetimelike data, a groupby-like operation.
|
See aggregate, transform, and apply functions on this object.
|
|
It's easiest to use obj.resample(...) to use Resampler.
|
|
Parameters
|
----------
|
obj : Series or DataFrame
|
groupby : TimeGrouper
|
axis : int, default 0
|
kind : str or None
|
'period', 'timestamp' to override default index treatment
|
|
Returns
|
-------
|
a Resampler of the appropriate type
|
|
Notes
|
-----
|
After resampling, see aggregate, apply, and transform functions.
|
r. Ú_grouperÚ TimeGrouperÚ _timegrouperz,DatetimeIndex | TimedeltaIndex | PeriodIndexÚbinnerzfrozenset[Hashable]Ú
|
exclusions> ÚaxÚobjÚ_indexer)ÚfreqÚaxisÚclosedÚlabelÚ
|
conventionÚkindÚoriginÚoffsetr NFT)Ú
|
group_keysÚ selectionÚinclude_groupsc óð || _ d | _ d| _ |j |« | _ || _ || _ d| _ || _ | j j | j |« d|¬« \ | _ | _ | _ | j « \ | _ | _ || _ | j j$ &t' | j j$ g« | _ y t' « | _ y )NT)ÚsortÚ gpr_index)rN Úkeysr` Ú_get_axis_numberrU rY r\ Úas_indexr^ Ú _set_grouperÚ _convert_objrR rQ rS Ú _get_binnerrO rL Ú
|
_selectionÚkeyÚ frozensetrP ) ÚselfrR Ú timegrouperrU rY ra r\ r] r^ s úGH:\Change_password\venv_build\Lib\site-packages\pandas/core/resample.pyÚ__init__zResampler.__init__£ sÚ ð (ÔØ Ø Ø×(Ñ(¨Ó. Ø Ø$Ø Ø ,Ôà+/×+<Ñ+<×+IÑ+IØ × Ñ cÓ "¨¸ð ,Jó ,
|
Ñ($'4=ð &*×%5Ñ%5Ó%7Ñ" T]Ø#Ø × Ñ × Ñ Ð ,Ü '¨×):Ñ):×)>Ñ)>Ð(?Ó @DOä 'kDOó c ó fd j D « }t « j ddj |« dS )z@
|
Provide a nice str repr of our rolling object.
|
c 3 ó K | ]6 }t j |d « | dt j |« 8 y w)Nú=)ÚgetattrrN )Ú.0Úkrk s rm ú <genexpr>z$Resampler.__str__.<locals>.<genexpr>Ç sG øè ø ò
|
àÜt×(Ñ(¨!¨TÓ2Ð>ð c74×,Ñ,¨aÓ0Ð1Ô 2ñ
|
ùs <?z [z, ú])Ú _attributesÚtypeÚ__name__Újoin)rk Úattrss ` rm Ú__str__zResampler.__str__Â sB ø ó
|
|
à×%Ñ%ô
|
ô
|
t*×%Ñ%Ð& b¨¯©°5Ó)9Ð(:¸!Ð<Ð<ro c óä || j v rt j | |« S || j v rt | j
|
|« S || j v r| | S t j | |« S ©N)Ú_internal_names_setÚobjectÚ__getattribute__rx rs rN rR )rk Úattrs rm Ú __getattr__zResampler.__getattr__Î sm à 4×+Ñ+Ñ +Ü×*Ñ*¨4°Ó6Ð 6Ø 4×#Ñ#Ñ #Ü4×,Ñ,¨dÓ3Ð 3Ø 488Ñ Ø:Ð ä×&Ñ& t¨TÓ2Ð2ro c ó | j duxr2 | j j duxs | j j duS )zP
|
Is the resampling from a DataFrame column or MultiIndex level.
|
N)rN ri Úlevel©rk s rm Ú_from_selectionzResampler._from_selectionÙ sG ð × Ñ ¨Ð,ò
|
Ø × Ñ × !Ñ !¨Ð -Ò T°×1BÑ1B×1HÑ1HÐPTÐ1Tð
|
ro c ó" |j « S )zÜ
|
Provide any conversions for the object in order to correctly handle.
|
|
Parameters
|
----------
|
obj : Series or DataFrame
|
|
Returns
|
-------
|
Series or DataFrame
|
)Ú _consolidate)rk rR s rm rf zResampler._convert_objå s ð × Ñ Ó!Ð!ro c ó t | « r r r s rm Ú_get_binner_for_timez Resampler._get_binner_for_timeó ó Ü! $Ó'Ð'ro c ó | j « \ }}}t |« t |« k( sJ t ||| j ¬« }||fS )zk
|
Create the BinGrouper, assume that self.set_grouper(obj)
|
has already been called.
|
)Úindexer)r Úlenr. rS )rk rO ÚbinsÚ binlabelsÚ bin_groupers rm rg zResampler._get_binnerö sL ð #'×";Ñ";Ó"=Ñ iÜ4yC NÒ*Ð*Ð*Ü y¸$¿-¹-ÔH Ø{Ð"Ð"ro a¼
|
>>> df = pd.DataFrame({'A': [1, 2, 3, 4]},
|
... index=pd.date_range('2012-08-02', periods=4))
|
>>> df
|
A
|
2012-08-02 1
|
2012-08-03 2
|
2012-08-04 3
|
2012-08-05 4
|
|
To get the difference between each 2-day period's maximum and minimum
|
value in one pass, you can do
|
|
>>> df.resample('2D').pipe(lambda x: x.max() - x.min())
|
A
|
2012-08-02 1
|
2012-08-04 1)ÚklassÚexamplesc ó* t | |g|¢i |¤S r )ÚsuperÚpipe)rk ÚfuncÚargsÚkwargsÚ __class__s rm r zResampler.pipe s ø ô8 w|DÐ2 4Ò2¨6Ñ2Ð2ro a[
|
See Also
|
--------
|
DataFrame.groupby.aggregate : Aggregate using callable, string, dict,
|
or list of string/callables.
|
DataFrame.resample.transform : Transforms the Series on each group
|
based on the given function.
|
DataFrame.aggregate: Aggregate using one or more
|
operations over the specified axis.
|
a
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3, 4, 5],
|
... index=pd.date_range('20130101', periods=5, freq='s'))
|
>>> s
|
2013-01-01 00:00:00 1
|
2013-01-01 00:00:01 2
|
2013-01-01 00:00:02 3
|
2013-01-01 00:00:03 4
|
2013-01-01 00:00:04 5
|
Freq: s, dtype: int64
|
|
>>> r = s.resample('2s')
|
|
>>> r.agg("sum")
|
2013-01-01 00:00:00 3
|
2013-01-01 00:00:02 7
|
2013-01-01 00:00:04 5
|
Freq: 2s, dtype: int64
|
|
>>> r.agg(['sum', 'mean', 'max'])
|
sum mean max
|
2013-01-01 00:00:00 3 1.5 2
|
2013-01-01 00:00:02 7 3.5 4
|
2013-01-01 00:00:04 5 5.0 5
|
|
>>> r.agg({'result': lambda x: x.mean() / x.std(),
|
... 'total': "sum"})
|
result total
|
2013-01-01 00:00:00 2.121320 3
|
2013-01-01 00:00:02 4.949747 7
|
2013-01-01 00:00:04 NaN 5
|
|
>>> r.agg(average="mean", total="sum")
|
average total
|
2013-01-01 00:00:00 1.5 3
|
2013-01-01 00:00:02 3.5 7
|
2013-01-01 00:00:04 5.0 5
|
Ú aggregaterG Ú )Úsee_alsor r rU c ót t | |||¬« j « }||} | j |g|¢i |¤}|S )N)r r )r ÚaggÚ_groupby_and_aggregate)rk r r r ÚresultÚhows rm r zResampler.aggregateW sH ô & d¨D°tÀFÔK×OÑOÓQØ >ØCØ0T×0Ñ0°ÐF°tÒF¸vÑFFà ro c ót | j j | j « j |g|¢i |¤S )aw
|
Call function producing a like-indexed Series on each group.
|
|
Return a Series with the transformed values.
|
|
Parameters
|
----------
|
arg : function
|
To apply to each group. Should return a Series with the same index.
|
|
Returns
|
-------
|
Series
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2],
|
... index=pd.date_range('20180101',
|
... periods=2,
|
... freq='1h'))
|
>>> s
|
2018-01-01 00:00:00 1
|
2018-01-01 01:00:00 2
|
Freq: h, dtype: int64
|
|
>>> resampled = s.resample('15min')
|
>>> resampled.transform(lambda x: (x - x.mean()) / x.std())
|
2018-01-01 00:00:00 NaN
|
2018-01-01 01:00:00 NaN
|
Freq: h, dtype: float64
|
)Ú _selected_objÚgroupbyrN Ú transform)rk Úargr r s rm r¨ zResampler.transformj sE ðB Gt×!Ñ!×)Ñ)¨$×*;Ñ*;Ó<×FÑFØ ð
|
Øò
|
Ø ñ
|
ð
|
ro c ó t | « r r )rk Úfr s rm Ú _downsamplezResampler._downsample r ro c ó t | « r r )rk r« ÚlimitÚ
|
fill_values rm Ú _upsamplezResampler._upsample r ro c óà | j }|%| j }||| }n|j dk( sJ |dk( r|j dk( sJ t |d|| j | j
|
¬« }|S )á
|
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é ©ÚbyÚgrouperrU r\ )rL rR Úndimr, rU r\ )rk ri r· Úsubsetr¶ Úgroupeds rm Ú_gotitemzResampler._gotitem sz ð --Ø >ØXXFØØ ð {{ aÒ'Ð'Ð'Ø 19Ø;; !Ò#Ð #Ð#ä Ø t W°4·9±9ÈÏ É ô
|
ð ro c óò | j }| j }t |d|| j | j ¬« } t « rfd}|j |« }n |j g¢i ¤}| j |« S # t t f$ r t |g¢d| j i¤}Y >t $ r5} dt | « v rn t |g¢d| j i¤}Y d} ~ vd} ~ ww xY w)zA
|
Re-evaluate the obj with a groupby aggregation.
|
Nr´ c ó | g¢i ¤S r © )Úxr r¤ r s rm ú<lambda>z2Resampler._groupby_and_aggregate.<locals>.<lambda>Â s ø ¡ QÐ!8¨Ò!8°Ñ!8 ro r^ z Must produce aggregated value)rL Ú_obj_with_exclusionsr, rU r\ Úcallabler ÚAttributeErrorÚKeyErrorÚ_applyr^ Ú
|
ValueErrorÚstrÚ _wrap_result)
|
rk r¤ r r r¶ rR r¹ r r£ Úerrs
|
``` rm r¢ z Resampler._groupby_and_aggregate± s ú ð --ð ×'Ñ'ä Ø D '°· ± ÀdÇoÁoô
|
ð Ü}õ 9Ø ×*Ñ*¨4Ó0à*×*Ñ*¨3Ð@°Ò@¸Ñ@ð6 × Ñ Ó(Ð(øô5 ¤Ð)ò
|
ô ØðØ #òØ48×4GÑ4GðØKQñFô ò Ø.´#°c³(Ñ:ð àô ØðØ #òØ48×4GÑ4GðØKQñFûð ús Á:B  +C6Â9C6Ã+C1Ã1C6c ó, | j ||| |¬« S )zG
|
Return the correct class for resampling with groupby.
|
)r§ ri Úparentr^ )Ú_resampler_for_grouping)rk r§ ri r^ s rm Ú_get_resampler_for_groupingz%Resampler._get_resampler_for_groupingâ s% ð ×+Ñ+Ø ¨TÀ.ð ,ó
|
ð
|
ro c ó | j }t |t « r]t |« dk( rOt |j t
|
« s5|j t |j dd | j ¬« d¬« }t |t « r | j | j |_ t |t « rG|j r;t |j dd | j ¬« |_ t |dd« |_ | j j 4|j j! | j j « |_ |S )z/
|
Potentially wrap any results.
|
r N©rT T)ÚappendÚname)rR Ú
|
isinstancer r Úindexr3 Ú set_indexÚ_asfreq_compatrT r rh rÐ Úemptyrs rN Ú _arrow_dtypeÚastype)rk r£ rR s rm rÇ zResampler._wrap_resultí sõ ð
|
hhä v|Ô ,ÜF qÒ Ü v||¬[Ô9à×%Ñ%Ü syy¨¨!}°4·9±9Ô=Àdð &ó Fô fiÔ (¨T¯_©_Ð-HØ //FKä fiÔ (¨V¯\ª\ä)¨#¯)©)°B°Q¨-¸d¿i¹iÔHFLÜ! # v¨tÓ4FKà × Ñ × )Ñ )Ð 5Ø!<<×.Ñ.¨t×/@Ñ/@×/MÑ/MÓNFLà ro c ó( | j d|¬« S )a¿
|
Forward fill the values.
|
|
Parameters
|
----------
|
limit : int, optional
|
Limit of how many values to fill.
|
|
Returns
|
-------
|
An upsampled Series.
|
|
See Also
|
--------
|
Series.fillna: Fill NA/NaN values using the specified method.
|
DataFrame.fillna: Fill NA/NaN values using the specified method.
|
|
Examples
|
--------
|
Here we only create a ``Series``.
|
|
>>> ser = pd.Series([1, 2, 3, 4], 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 4
|
dtype: int64
|
|
Example for ``ffill`` with downsampling (we have fewer dates after resampling):
|
|
>>> ser.resample('MS').ffill()
|
2023-01-01 1
|
2023-02-01 3
|
Freq: MS, dtype: int64
|
|
Example for ``ffill`` with upsampling (fill the new dates with
|
the previous value):
|
|
>>> ser.resample('W').ffill()
|
2023-01-01 1
|
2023-01-08 1
|
2023-01-15 2
|
2023-01-22 2
|
2023-01-29 2
|
2023-02-05 3
|
2023-02-12 3
|
2023-02-19 4
|
Freq: W-SUN, dtype: int64
|
|
With upsampling and limiting (only fill the first new date with the
|
previous value):
|
|
>>> ser.resample('W').ffill(limit=1)
|
2023-01-01 1.0
|
2023-01-08 1.0
|
2023-01-15 2.0
|
2023-01-22 2.0
|
2023-01-29 NaN
|
2023-02-05 3.0
|
2023-02-12 NaN
|
2023-02-19 4.0
|
Freq: W-SUN, dtype: float64
|
Úffill©r® ©r° ©rk r® s rm rÙ zResampler.ffill s ðF ~~g¨U~Ó3Ð3ro c ó( | j d|¬« S )a
|
Resample by using the nearest value.
|
|
When resampling data, missing values may appear (e.g., when the
|
resampling frequency is higher than the original frequency).
|
The `nearest` method will replace ``NaN`` values that appeared in
|
the resampled data with the value from the nearest member of the
|
sequence, based on the index value.
|
Missing values that existed in the original data will not be modified.
|
If `limit` is given, fill only this many values in each direction for
|
each of the original values.
|
|
Parameters
|
----------
|
limit : int, optional
|
Limit of how many values to fill.
|
|
Returns
|
-------
|
Series or DataFrame
|
An upsampled Series or DataFrame with ``NaN`` values filled with
|
their nearest value.
|
|
See Also
|
--------
|
backfill : Backward fill the new missing values in the resampled data.
|
pad : Forward fill ``NaN`` values.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2],
|
... index=pd.date_range('20180101',
|
... periods=2,
|
... freq='1h'))
|
>>> s
|
2018-01-01 00:00:00 1
|
2018-01-01 01:00:00 2
|
Freq: h, dtype: int64
|
|
>>> s.resample('15min').nearest()
|
2018-01-01 00:00:00 1
|
2018-01-01 00:15:00 1
|
2018-01-01 00:30:00 2
|
2018-01-01 00:45:00 2
|
2018-01-01 01:00:00 2
|
Freq: 15min, dtype: int64
|
|
Limit the number of upsampled values imputed by the nearest:
|
|
>>> s.resample('15min').nearest(limit=1)
|
2018-01-01 00:00:00 1.0
|
2018-01-01 00:15:00 1.0
|
2018-01-01 00:30:00 NaN
|
2018-01-01 00:45:00 2.0
|
2018-01-01 01:00:00 2.0
|
Freq: 15min, dtype: float64
|
ÚnearestrÚ rÛ rÜ s rm rÞ zResampler.nearestN s ðv ~~i¨u~Ó5Ð5ro c ó( | j d|¬« S )a±
|
Backward fill the new missing values in the resampled data.
|
|
In statistics, imputation is the process of replacing missing data with
|
substituted values [1]_. When resampling data, missing values may
|
appear (e.g., when the resampling frequency is higher than the original
|
frequency). The backward fill will replace NaN values that appeared in
|
the resampled data with the next value in the original sequence.
|
Missing values that existed in the original data will not be modified.
|
|
Parameters
|
----------
|
limit : int, optional
|
Limit of how many values to fill.
|
|
Returns
|
-------
|
Series, DataFrame
|
An upsampled Series or DataFrame with backward filled NaN values.
|
|
See Also
|
--------
|
bfill : Alias of backfill.
|
fillna : Fill NaN values using the specified method, which can be
|
'backfill'.
|
nearest : Fill NaN values with nearest neighbor starting from center.
|
ffill : Forward fill NaN values.
|
Series.fillna : Fill NaN values in the Series using the
|
specified method, which can be 'backfill'.
|
DataFrame.fillna : Fill NaN values in the DataFrame using the
|
specified method, which can be 'backfill'.
|
|
References
|
----------
|
.. [1] https://en.wikipedia.org/wiki/Imputation_(statistics)
|
|
Examples
|
--------
|
Resampling a Series:
|
|
>>> s = pd.Series([1, 2, 3],
|
... index=pd.date_range('20180101', periods=3, freq='h'))
|
>>> s
|
2018-01-01 00:00:00 1
|
2018-01-01 01:00:00 2
|
2018-01-01 02:00:00 3
|
Freq: h, dtype: int64
|
|
>>> s.resample('30min').bfill()
|
2018-01-01 00:00:00 1
|
2018-01-01 00:30:00 2
|
2018-01-01 01:00:00 2
|
2018-01-01 01:30:00 3
|
2018-01-01 02:00:00 3
|
Freq: 30min, dtype: int64
|
|
>>> s.resample('15min').bfill(limit=2)
|
2018-01-01 00:00:00 1.0
|
2018-01-01 00:15:00 NaN
|
2018-01-01 00:30:00 2.0
|
2018-01-01 00:45:00 2.0
|
2018-01-01 01:00:00 2.0
|
2018-01-01 01:15:00 NaN
|
2018-01-01 01:30:00 3.0
|
2018-01-01 01:45:00 3.0
|
2018-01-01 02:00:00 3.0
|
Freq: 15min, dtype: float64
|
|
Resampling a DataFrame that has missing values:
|
|
>>> df = pd.DataFrame({'a': [2, np.nan, 6], 'b': [1, 3, 5]},
|
... index=pd.date_range('20180101', periods=3,
|
... freq='h'))
|
>>> df
|
a b
|
2018-01-01 00:00:00 2.0 1
|
2018-01-01 01:00:00 NaN 3
|
2018-01-01 02:00:00 6.0 5
|
|
>>> df.resample('30min').bfill()
|
a b
|
2018-01-01 00:00:00 2.0 1
|
2018-01-01 00:30:00 NaN 3
|
2018-01-01 01:00:00 NaN 3
|
2018-01-01 01:30:00 6.0 5
|
2018-01-01 02:00:00 6.0 5
|
|
>>> df.resample('15min').bfill(limit=2)
|
a b
|
2018-01-01 00:00:00 2.0 1.0
|
2018-01-01 00:15:00 NaN NaN
|
2018-01-01 00:30:00 NaN 3.0
|
2018-01-01 00:45:00 NaN 3.0
|
2018-01-01 01:00:00 NaN 3.0
|
2018-01-01 01:15:00 NaN NaN
|
2018-01-01 01:30:00 6.0 5.0
|
2018-01-01 01:45:00 6.0 5.0
|
2018-01-01 02:00:00 6.0 5.0
|
ÚbfillrÚ rÛ rÜ s rm rà zResampler.bfill s ðJ ~~g¨U~Ó3Ð3ro c ó t j t | « j dt t « ¬« | j ||¬« S )a
|
Fill missing values introduced by upsampling.
|
|
In statistics, imputation is the process of replacing missing data with
|
substituted values [1]_. When resampling data, missing values may
|
appear (e.g., when the resampling frequency is higher than the original
|
frequency).
|
|
Missing values that existed in the original data will
|
not be modified.
|
|
Parameters
|
----------
|
method : {'pad', 'backfill', 'ffill', 'bfill', 'nearest'}
|
Method to use for filling holes in resampled data
|
|
* 'pad' or 'ffill': use previous valid observation to fill gap
|
(forward fill).
|
* 'backfill' or 'bfill': use next valid observation to fill gap.
|
* 'nearest': use nearest valid observation to fill gap.
|
|
limit : int, optional
|
Limit of how many consecutive missing values to fill.
|
|
Returns
|
-------
|
Series or DataFrame
|
An upsampled Series or DataFrame with missing values filled.
|
|
See Also
|
--------
|
bfill : Backward fill NaN values in the resampled data.
|
ffill : Forward fill NaN values in the resampled data.
|
nearest : Fill NaN values in the resampled data
|
with nearest neighbor starting from center.
|
interpolate : Fill NaN values using interpolation.
|
Series.fillna : Fill NaN values in the Series using the
|
specified method, which can be 'bfill' and 'ffill'.
|
DataFrame.fillna : Fill NaN values in the DataFrame using the
|
specified method, which can be 'bfill' and 'ffill'.
|
|
References
|
----------
|
.. [1] https://en.wikipedia.org/wiki/Imputation_(statistics)
|
|
Examples
|
--------
|
Resampling a Series:
|
|
>>> s = pd.Series([1, 2, 3],
|
... index=pd.date_range('20180101', periods=3, freq='h'))
|
>>> s
|
2018-01-01 00:00:00 1
|
2018-01-01 01:00:00 2
|
2018-01-01 02:00:00 3
|
Freq: h, dtype: int64
|
|
Without filling the missing values you get:
|
|
>>> s.resample("30min").asfreq()
|
2018-01-01 00:00:00 1.0
|
2018-01-01 00:30:00 NaN
|
2018-01-01 01:00:00 2.0
|
2018-01-01 01:30:00 NaN
|
2018-01-01 02:00:00 3.0
|
Freq: 30min, dtype: float64
|
|
>>> s.resample('30min').fillna("backfill")
|
2018-01-01 00:00:00 1
|
2018-01-01 00:30:00 2
|
2018-01-01 01:00:00 2
|
2018-01-01 01:30:00 3
|
2018-01-01 02:00:00 3
|
Freq: 30min, dtype: int64
|
|
>>> s.resample('15min').fillna("backfill", limit=2)
|
2018-01-01 00:00:00 1.0
|
2018-01-01 00:15:00 NaN
|
2018-01-01 00:30:00 2.0
|
2018-01-01 00:45:00 2.0
|
2018-01-01 01:00:00 2.0
|
2018-01-01 01:15:00 NaN
|
2018-01-01 01:30:00 3.0
|
2018-01-01 01:45:00 3.0
|
2018-01-01 02:00:00 3.0
|
Freq: 15min, dtype: float64
|
|
>>> s.resample('30min').fillna("pad")
|
2018-01-01 00:00:00 1
|
2018-01-01 00:30:00 1
|
2018-01-01 01:00:00 2
|
2018-01-01 01:30:00 2
|
2018-01-01 02:00:00 3
|
Freq: 30min, dtype: int64
|
|
>>> s.resample('30min').fillna("nearest")
|
2018-01-01 00:00:00 1
|
2018-01-01 00:30:00 2
|
2018-01-01 01:00:00 2
|
2018-01-01 01:30:00 3
|
2018-01-01 02:00:00 3
|
Freq: 30min, dtype: int64
|
|
Missing values present before the upsampling are not affected.
|
|
>>> sm = pd.Series([1, None, 3],
|
... index=pd.date_range('20180101', periods=3, freq='h'))
|
>>> sm
|
2018-01-01 00:00:00 1.0
|
2018-01-01 01:00:00 NaN
|
2018-01-01 02:00:00 3.0
|
Freq: h, dtype: float64
|
|
>>> sm.resample('30min').fillna('backfill')
|
2018-01-01 00:00:00 1.0
|
2018-01-01 00:30:00 NaN
|
2018-01-01 01:00:00 NaN
|
2018-01-01 01:30:00 3.0
|
2018-01-01 02:00:00 3.0
|
Freq: 30min, dtype: float64
|
|
>>> sm.resample('30min').fillna('pad')
|
2018-01-01 00:00:00 1.0
|
2018-01-01 00:30:00 1.0
|
2018-01-01 01:00:00 NaN
|
2018-01-01 01:30:00 NaN
|
2018-01-01 02:00:00 3.0
|
Freq: 30min, dtype: float64
|
|
>>> sm.resample('30min').fillna('nearest')
|
2018-01-01 00:00:00 1.0
|
2018-01-01 00:30:00 NaN
|
2018-01-01 01:00:00 NaN
|
2018-01-01 01:30:00 3.0
|
2018-01-01 02:00:00 3.0
|
Freq: 30min, dtype: float64
|
|
DataFrame resampling is done column-wise. All the same options are
|
available.
|
|
>>> df = pd.DataFrame({'a': [2, np.nan, 6], 'b': [1, 3, 5]},
|
... index=pd.date_range('20180101', periods=3,
|
... freq='h'))
|
>>> df
|
a b
|
2018-01-01 00:00:00 2.0 1
|
2018-01-01 01:00:00 NaN 3
|
2018-01-01 02:00:00 6.0 5
|
|
>>> df.resample('30min').fillna("bfill")
|
a b
|
2018-01-01 00:00:00 2.0 1
|
2018-01-01 00:30:00 NaN 3
|
2018-01-01 01:00:00 NaN 3
|
2018-01-01 01:30:00 6.0 5
|
2018-01-01 02:00:00 6.0 5
|
zv.fillna is deprecated and will be removed in a future version. Use obj.ffill(), obj.bfill(), or obj.nearest() instead.©Ú
|
stacklevelrÚ )ÚwarningsÚwarnry rz Ú FutureWarningr r° )rk Úmethodr® s rm ÚfillnazResampler.fillnaò sK ô~ ÜDz×"Ñ"Ð#ð $(ð (ô Ü'Ó)õ
|
ð ~~f¨E~Ó2Ð2ro Úforward)rU r® ÚinplaceÚlimit_directionÚ
|
limit_areaÚdowncastc ó |t j u sJ | j d« } | j d|||||||d|¤S )a¸
|
Interpolate values between target timestamps according to different methods.
|
|
The original index is first reindexed to target timestamps
|
(see :meth:`core.resample.Resampler.asfreq`),
|
then the interpolation of ``NaN`` values via :meth:`DataFrame.interpolate`
|
happens.
|
|
Parameters
|
----------
|
method : str, default 'linear'
|
Interpolation technique to use. One of:
|
|
* 'linear': Ignore the index and treat the values as equally
|
spaced. This is the only method supported on MultiIndexes.
|
* 'time': Works on daily and higher resolution data to interpolate
|
given length of interval.
|
* 'index', 'values': use the actual numerical values of the index.
|
* 'pad': Fill in NaNs using existing values.
|
* 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',
|
'barycentric', 'polynomial': Passed to
|
`scipy.interpolate.interp1d`, whereas 'spline' is passed to
|
`scipy.interpolate.UnivariateSpline`. These methods use the numerical
|
values of the index. Both 'polynomial' and 'spline' require that
|
you also specify an `order` (int), e.g.
|
``df.interpolate(method='polynomial', order=5)``. Note that,
|
`slinear` method in Pandas refers to the Scipy first order `spline`
|
instead of Pandas first order `spline`.
|
* 'krogh', 'piecewise_polynomial', 'spline', 'pchip', 'akima',
|
'cubicspline': Wrappers around the SciPy interpolation methods of
|
similar names. See `Notes`.
|
* 'from_derivatives': Refers to
|
`scipy.interpolate.BPoly.from_derivatives`.
|
|
axis : {{0 or 'index', 1 or 'columns', None}}, default None
|
Axis to interpolate along. For `Series` this parameter is unused
|
and defaults to 0.
|
limit : int, optional
|
Maximum number of consecutive NaNs to fill. Must be greater than
|
0.
|
inplace : bool, default False
|
Update the data in place if possible.
|
limit_direction : {{'forward', 'backward', 'both'}}, Optional
|
Consecutive NaNs will be filled in this direction.
|
|
If limit is specified:
|
* If 'method' is 'pad' or 'ffill', 'limit_direction' must be 'forward'.
|
* If 'method' is 'backfill' or 'bfill', 'limit_direction' must be
|
'backwards'.
|
|
If 'limit' is not specified:
|
* If 'method' is 'backfill' or 'bfill', the default is 'backward'
|
* else the default is 'forward'
|
|
raises ValueError if `limit_direction` is 'forward' or 'both' and
|
method is 'backfill' or 'bfill'.
|
raises ValueError if `limit_direction` is 'backward' or 'both' and
|
method is 'pad' or 'ffill'.
|
|
limit_area : {{`None`, 'inside', 'outside'}}, default None
|
If limit is specified, consecutive NaNs will be filled with this
|
restriction.
|
|
* ``None``: No fill restriction.
|
* 'inside': Only fill NaNs surrounded by valid values
|
(interpolate).
|
* 'outside': Only fill NaNs outside valid values (extrapolate).
|
|
downcast : optional, 'infer' or None, defaults to None
|
Downcast dtypes if possible.
|
|
.. deprecated:: 2.1.0
|
|
``**kwargs`` : optional
|
Keyword arguments to pass on to the interpolating function.
|
|
Returns
|
-------
|
DataFrame or Series
|
Interpolated values at the specified freq.
|
|
See Also
|
--------
|
core.resample.Resampler.asfreq: Return the values at the new freq,
|
essentially a reindex.
|
DataFrame.interpolate: Fill NaN values using an interpolation method.
|
|
Notes
|
-----
|
For high-frequent or non-equidistant time-series with timestamps
|
the reindexing followed by interpolation may lead to information loss
|
as shown in the last example.
|
|
Examples
|
--------
|
|
>>> start = "2023-03-01T07:00:00"
|
>>> timesteps = pd.date_range(start, periods=5, freq="s")
|
>>> series = pd.Series(data=[1, -1, 2, 1, 3], index=timesteps)
|
>>> series
|
2023-03-01 07:00:00 1
|
2023-03-01 07:00:01 -1
|
2023-03-01 07:00:02 2
|
2023-03-01 07:00:03 1
|
2023-03-01 07:00:04 3
|
Freq: s, dtype: int64
|
|
Upsample the dataframe to 0.5Hz by providing the period time of 2s.
|
|
>>> series.resample("2s").interpolate("linear")
|
2023-03-01 07:00:00 1
|
2023-03-01 07:00:02 2
|
2023-03-01 07:00:04 3
|
Freq: 2s, dtype: int64
|
|
Downsample the dataframe to 2Hz by providing the period time of 500ms.
|
|
>>> series.resample("500ms").interpolate("linear")
|
2023-03-01 07:00:00.000 1.0
|
2023-03-01 07:00:00.500 0.0
|
2023-03-01 07:00:01.000 -1.0
|
2023-03-01 07:00:01.500 0.5
|
2023-03-01 07:00:02.000 2.0
|
2023-03-01 07:00:02.500 1.5
|
2023-03-01 07:00:03.000 1.0
|
2023-03-01 07:00:03.500 2.0
|
2023-03-01 07:00:04.000 3.0
|
Freq: 500ms, dtype: float64
|
|
Internal reindexing with ``asfreq()`` prior to interpolation leads to
|
an interpolated timeseries on the basis the reindexed timestamps (anchors).
|
Since not all datapoints from original series become anchors,
|
it can lead to misleading interpolation results as in the following example:
|
|
>>> series.resample("400ms").interpolate("linear")
|
2023-03-01 07:00:00.000 1.0
|
2023-03-01 07:00:00.400 1.2
|
2023-03-01 07:00:00.800 1.4
|
2023-03-01 07:00:01.200 1.6
|
2023-03-01 07:00:01.600 1.8
|
2023-03-01 07:00:02.000 2.0
|
2023-03-01 07:00:02.400 2.2
|
2023-03-01 07:00:02.800 2.4
|
2023-03-01 07:00:03.200 2.6
|
2023-03-01 07:00:03.600 2.8
|
2023-03-01 07:00:04.000 3.0
|
Freq: 400ms, dtype: float64
|
|
Note that the series erroneously increases between two anchors
|
``07:00:00`` and ``07:00:02``.
|
Úasfreq)rç rU r® rê rë rì rí r½ )r Ú
|
no_defaultr° Ú interpolate)
|
rk rç rU r® rê rë rì rí r r£ s
|
rm rñ zResampler.interpolate s^ ðH 3>>Ñ)Ð)Ð)Ø Ó)Ø!v×!Ñ!ð
|
ØØØØØ +Ø!Ø ñ
|
ð ñ
|
ð
|
ro c ó( | j d|¬« S )aï
|
Return the values at the new freq, essentially a reindex.
|
|
Parameters
|
----------
|
fill_value : scalar, optional
|
Value to use for missing values, applied during upsampling (note
|
this does not fill NaNs that already were present).
|
|
Returns
|
-------
|
DataFrame or Series
|
Values at the specified freq.
|
|
See Also
|
--------
|
Series.asfreq: Convert TimeSeries to specified frequency.
|
DataFrame.asfreq: Convert TimeSeries to specified frequency.
|
|
Examples
|
--------
|
|
>>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
|
... ['2023-01-01', '2023-01-31', '2023-02-01', '2023-02-28']))
|
>>> ser
|
2023-01-01 1
|
2023-01-31 2
|
2023-02-01 3
|
2023-02-28 4
|
dtype: int64
|
>>> ser.resample('MS').asfreq()
|
2023-01-01 1
|
2023-02-01 3
|
Freq: MS, dtype: int64
|
rï )r¯ rÛ )rk r¯ s rm rï zResampler.asfreqK s ðJ ~~h°:~Ó>Ð>ro c ó t t | « d||« t j d||« | j d||¬« S )a
|
Compute sum of group values.
|
|
Parameters
|
----------
|
numeric_only : bool, default False
|
Include only float, int, boolean columns.
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only no longer accepts ``None``.
|
|
min_count : int, default 0
|
The required number of valid values to perform the operation. If fewer
|
than ``min_count`` non-NA values are present the result will be NA.
|
|
Returns
|
-------
|
Series or DataFrame
|
Computed sum of values within each group.
|
|
Examples
|
--------
|
>>> ser = pd.Series([1, 2, 3, 4], 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 4
|
dtype: int64
|
>>> ser.resample('MS').sum()
|
2023-01-01 3
|
2023-02-01 7
|
Freq: MS, dtype: int64
|
Úsum©Ú numeric_onlyÚ min_count©Úmaybe_warn_args_and_kwargsry ÚnvÚvalidate_resampler_funcr¬ ©rk rö r÷ r r s rm rô z Resampler.sumr sA ôX #¤4¨£:¨u°d¸FÔCÜ
|
×"Ñ" 5¨$°Ô7Ø× Ñ °LÈIÐ ÓVÐVro c ó t t | « d||« t j d||« | j d||¬« S )a
|
Compute prod of group values.
|
|
Parameters
|
----------
|
numeric_only : bool, default False
|
Include only float, int, boolean columns.
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only no longer accepts ``None``.
|
|
min_count : int, default 0
|
The required number of valid values to perform the operation. If fewer
|
than ``min_count`` non-NA values are present the result will be NA.
|
|
Returns
|
-------
|
Series or DataFrame
|
Computed prod of values within each group.
|
|
Examples
|
--------
|
>>> ser = pd.Series([1, 2, 3, 4], 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 4
|
dtype: int64
|
>>> ser.resample('MS').prod()
|
2023-01-01 2
|
2023-02-01 12
|
Freq: MS, dtype: int64
|
Úprodrõ rø rü s rm rþ zResampler.prod¢ sA ôX #¤4¨£:¨v°t¸VÔDÜ
|
×"Ñ" 6¨4°Ô8Ø× Ñ °\ÈYÐ ÓWÐWro c ó t t | « d||« t j d||« | j d||¬« S )a
|
Compute min value of group.
|
|
Returns
|
-------
|
Series or DataFrame
|
|
Examples
|
--------
|
>>> ser = pd.Series([1, 2, 3, 4], 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 4
|
dtype: int64
|
>>> ser.resample('MS').min()
|
2023-01-01 1
|
2023-02-01 3
|
Freq: MS, dtype: int64
|
Úminrõ rø rü s rm r z Resampler.minÒ s@ ô> #¤4¨£:¨u°d¸FÔCÜ
|
×"Ñ" 5¨$°Ô7Ø× Ñ °LÈIÐ ÓVÐVro c ó t t | « d||« t j d||« | j d||¬« S )a
|
Compute max value of group.
|
|
Returns
|
-------
|
Series or DataFrame
|
|
Examples
|
--------
|
>>> ser = pd.Series([1, 2, 3, 4], 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 4
|
dtype: int64
|
>>> ser.resample('MS').max()
|
2023-01-01 2
|
2023-02-01 4
|
Freq: MS, dtype: int64
|
Úmaxrõ rø rü s rm r z Resampler.maxõ s@ ô< #¤4¨£:¨u°d¸FÔCÜ
|
×"Ñ" 5¨$°Ô7Ø× Ñ °LÈIÐ ÓVÐVro c ó t t | « d||« t j d||« | j d|||¬« S )NÚfirst©rö r÷ Úskipnarø ©rk rö r÷ r r r s rm r zResampler.first sI ô #¤4¨£:¨w¸¸fÔEÜ
|
×"Ñ" 7¨D°&Ô9Ø× Ñ Ø ,¸)ÈFð ó
|
ð
|
ro c ó t t | « d||« t j d||« | j d|||¬« S )NÚlastr rø r s rm r zResampler.last' sI ô #¤4¨£:¨v°t¸VÔDÜ
|
×"Ñ" 6¨4°Ô8Ø× Ñ Ø ¸È6ð ó
|
ð
|
ro c ó t t | « d||« t j d||« | j d|¬« S )NÚmedian©rö rø ©rk rö r r s rm r zResampler.median7 s> ô #¤4¨£:¨x¸¸vÔFÜ
|
×"Ñ" 8¨T°6Ô:Ø× Ñ °|Ð ÓDÐDro c ó t t | « d||« t j d||« | j d|¬« S )aX
|
Compute mean of groups, excluding missing values.
|
|
Parameters
|
----------
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only now defaults to ``False``.
|
|
Returns
|
-------
|
DataFrame or Series
|
Mean of values within each group.
|
|
Examples
|
--------
|
|
>>> ser = pd.Series([1, 2, 3, 4], 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 4
|
dtype: int64
|
>>> ser.resample('MS').mean()
|
2023-01-01 1.5
|
2023-02-01 3.5
|
Freq: MS, dtype: float64
|
Úmeanr rø r s rm r zResampler.mean> s? ôP #¤4¨£:¨v°t¸VÔDÜ
|
×"Ñ" 6¨4°Ô8Ø× Ñ °\Ð ÓBÐBro c ó t t | « d||« t j d||« | j d||¬« S )a
|
Compute standard deviation of groups, excluding missing values.
|
|
Parameters
|
----------
|
ddof : int, default 1
|
Degrees of freedom.
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only now defaults to ``False``.
|
|
Returns
|
-------
|
DataFrame or Series
|
Standard deviation of values within each group.
|
|
Examples
|
--------
|
|
>>> ser = pd.Series([1, 3, 2, 4, 3, 8],
|
... index=pd.DatetimeIndex(['2023-01-01',
|
... '2023-01-10',
|
... '2023-01-15',
|
... '2023-02-01',
|
... '2023-02-10',
|
... '2023-02-15']))
|
>>> ser.resample('MS').std()
|
2023-01-01 1.000000
|
2023-02-01 2.645751
|
Freq: MS, dtype: float64
|
Ústd©Úddofrö rø ©rk r rö r r s rm r z Resampler.stdj sA ôX #¤4¨£:¨u°d¸FÔCÜ
|
×"Ñ" 5¨$°Ô7Ø× Ñ ¨D¸|Ð ÓLÐLro c ó t t | « d||« t j d||« | j d||¬« S )aî
|
Compute variance of groups, excluding missing values.
|
|
Parameters
|
----------
|
ddof : int, default 1
|
Degrees of freedom.
|
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
.. versionchanged:: 2.0.0
|
|
numeric_only now defaults to ``False``.
|
|
Returns
|
-------
|
DataFrame or Series
|
Variance of values within each group.
|
|
Examples
|
--------
|
|
>>> ser = pd.Series([1, 3, 2, 4, 3, 8],
|
... index=pd.DatetimeIndex(['2023-01-01',
|
... '2023-01-10',
|
... '2023-01-15',
|
... '2023-02-01',
|
... '2023-02-10',
|
... '2023-02-15']))
|
>>> ser.resample('MS').var()
|
2023-01-01 1.0
|
2023-02-01 7.0
|
Freq: MS, dtype: float64
|
|
>>> ser.resample('MS').var(ddof=0)
|
2023-01-01 0.666667
|
2023-02-01 4.666667
|
Freq: MS, dtype: float64
|
Úvarr rø r s rm r z Resampler.var sA ôd #¤4¨£:¨u°d¸FÔCÜ
|
×"Ñ" 5¨$°Ô7Ø× Ñ ¨D¸|Ð ÓLÐLro c ó t t | « d||« t j d||« | j d||¬« S )NÚsemr rø r s rm r z Resampler.semÐ s@ ô #¤4¨£:¨u°d¸FÔCÜ
|
×"Ñ" 5¨$°Ô7Ø× Ñ ¨D¸|Ð ÓLÐLro c ó t t | « d||« t j d||« | j }| j
|
}t |« dk( r£|j « }t |j | j « |_ |j dk( r'|j « }|j g d¢d¬« }|S t j |j g d¢g« }|j |d¬« }|S | j# d« S )NÚohlcr r³ )ÚopenÚhighÚlowÚclose©rU )rù ry rú rû rQ rÀ r ÚcopyrÔ rÒ rT r· Úto_frameÚreindexr/ Ú from_productÚcolumnsr¬ )rk r r rQ rR Úmis rm r zResampler.ohlcÝ sá ô #¤4¨£:¨v°t¸VÔDÜ
|
×"Ñ" 6¨4°Ô8à WWØ×'Ñ'Ü r7a<à((*CÜ& s§y¡y°$·)±)Ó<CIØxx1}ØllnØkkÒ"BÈkÓKð Jô ×,Ñ,Ø[[Ò"BÐCóð kk "¨1kÓ-ØJà× Ñ Ó'Ð'ro c ó t t | « d||« t j d||« | j d« S )NÚnuniquerø )rk r r s rm r' zResampler.nuniqueù s9 ô #¤4¨£:¨y¸$ÀÔGÜ
|
×"Ñ" 9¨d°FÔ;Ø× Ñ Ó*Ð*ro c óJ | j d« }t |t « r |j s|j d¬« }t | j « sNddlm} | j j dk( r| j j }nd } |g |j d|¬« }|S ) NÚsizeT)Ú future_stackr )rH r³ Úint64©rÒ ÚdtyperÐ ) r¬ rÑ r rÕ Ústackr rQ ÚpandasrH r¦ r· rÐ rÒ )rk r£ rH rÐ s rm r) zResampler.size s ð ×!Ñ! &Ó)ô flÔ +°F·L²LØ\\¨t\Ó4Fä477|Ý %à×!Ñ!×&Ñ&¨!Ò+Ø×)Ñ)×.Ñ.àÙB f§l¡l¸'ÈÔMFØ ro c óN | j d« }t | j « s~| j j dk( r? t | j « g |j d| j j ¬« }|S ddlm } |g |j |j d¬« }|S )NÚcountr³ r+ r, r )rG )rÒ r$ r- ) r¬ r rQ r¦ r· ry rÒ rÐ r/ rG r$ )rk r£ rG s rm r1 zResampler.count s ð ×!Ñ! 'Ó*Ü477|Ø×!Ñ!×&Ñ&¨!Ò+Ø1d× 0Ñ 0Ó1Øfll°'À×@RÑ@R×@WÑ@Wôð õ -á"Øfll°F·N±NÈ'ôð ro c ó* | j dd|i|¤S )a¥
|
Return value at the given quantile.
|
|
Parameters
|
----------
|
q : float or array-like, default 0.5 (50% quantile)
|
|
Returns
|
-------
|
DataFrame or Series
|
Quantile of values within each group.
|
|
See Also
|
--------
|
Series.quantile
|
Return a series, where the index is q and the values are the quantiles.
|
DataFrame.quantile
|
Return a DataFrame, where the columns are the columns of self,
|
and the values are the quantiles.
|
DataFrameGroupBy.quantile
|
Return a DataFrame, where the columns are groupby columns,
|
and the values are its quantiles.
|
|
Examples
|
--------
|
|
>>> ser = pd.Series([1, 3, 2, 4, 3, 8],
|
... index=pd.DatetimeIndex(['2023-01-01',
|
... '2023-01-10',
|
... '2023-01-15',
|
... '2023-02-01',
|
... '2023-02-10',
|
... '2023-02-15']))
|
>>> ser.resample('MS').quantile()
|
2023-01-01 2.0
|
2023-02-01 4.0
|
Freq: MS, dtype: float64
|
|
>>> ser.resample('MS').quantile(.25)
|
2023-01-01 1.5
|
2023-02-01 3.5
|
Freq: MS, dtype: float64
|
Úq)Úquantile)r¬ )rk r3 r s rm r4 zResampler.quantile* s ðZ t× Ñ Ñ:¨aÐ:°6Ñ:Ð:ro )r N)rR r% rl rM rU r= ra r0 r\ Úboolr^ r5 ÚreturnÚNone)r6 rÆ )r rÆ )r6 r5 ©rR r r6 r )r z/Callable[..., T] | tuple[Callable[..., T], str]r6 rB r ©NN©r® ú
|
int | None)r· Úint©T)r§ r) r^ r5 )Úlinear)
|
rç rA rU r= r® r; rê r5 rë z&Literal['forward', 'backward', 'both'])Fr )rö r5 r÷ r< )Fr T)rö r5 r÷ r< r r5 ©F)rö r5 )r³ F)r r< rö r5 )g à?)r3 z"float | list[float] | AnyArrayLike)Arz Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__rj rP Úsetr rx rn r r} r Úpropertyr rf r rg r r r+ r r Ú_agg_see_also_docÚ_agg_examples_docr r& r r¡ Úapplyr¨ 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) r1 r4 Ú __classcell__©r s @rm rK rK y så ø
ñð. ÓØ Ó Ø 8Ó8Ù&/£kJÐ#Ó1Ù Ò 7Ó8Ðò Kð Ø ð *ð !ØØ #ñ *à ð *ð !ð *ð ð *ð ð *ð ð *ð ð *ð
|
ó *ð> ò =ó ð =ð ò3ó ð3ð Ø ò
|
ó ó ð
|
ó "ò (ð ñ#ó ð#ð ÙØðôñ( nÓ ð3à=ð3ð
|
|
ô 3ó ó)ó ð,3ñ ð ó Ðñ ð' ó)ÐðV ÙØ[Ñ!Ø"Ø"ØØ ô òóó ðð CØ Eà
|
ñ"
|
ó ð"
|
òH(ô(ôò8/)ðb à<@ð
|
Ø ð
|
Ø59ò
|
ó ð
|
òð8 óB4ó ðB4ðH ó:6ó ð:6ðx ód4ó ðd4ðL óe3ó ðe3ðN ð &.ðn
|
ð Ø Ø ØBKØØ ñn
|
à"ðn
|
ð ð n
|
ð
|
ð n
|
ð ð n
|
ð @òn
|
ó ðn
|
ð` ò$?ó ð$?ðL ð #Øð-Wàð-Wð ò-Wó ð-Wð^ ð #Øð-Xàð-Xð ò-Xó ð-Xð^ ð #Øð Wàð Wð ò Wó ð WðD ð #Øð Wàð Wð ò Wó ð WðB Ù Óð #ØØð
|
àð
|
ð ð
|
ð ò
|
ó ó ð
|
ð Ù Óð #ØØð
|
àð
|
ð ð
|
ð ò
|
ó ó ð
|
ð Ù ÓóEó ó ðEð
|
ð #ð)Càò)Có ð)CðV ð Ø "ð-Màð-Mð ò-Mó ð-Mð^ ð Ø "ð3Màð3Mð ò3Mó ð3Mðj ÙÓð Ø "ð Màð Mð ò Mó ó ð Mð Ù Óñ(ó ó ð(ð4 Ù × Ñ Ó ñ+ó ó ð+ð Ù Óñó ó ðð$ Ù Óñó ó ðð ó,;ó ô,;ro rK c ó e Zd ZU dZded< dZded< ded< d ed
|
< ddd d dd Zed « ZeZ eZ
|
eZ e dd« Z y)Ú _GroupByMixinz)
|
Provide the groupby facilities.
|
z list[str]rx NúIndexLabel | Nonerh r) Ú_groupbyrM rN F)ri r] r^ c óº t |t « sJ t |« « t |t « sJ t |« « | j D ] }t | |t ||« « || _ |j | _ || _ || _
|
t j |j « | _ |j | _ |j | _ || _ y r )rÑ r) ry rK rx Úsetattrrs rh rO ri rN r rN rQ rR r^ )rk rÊ r§ ri r] r^ r s rm rn z_GroupByMixin.__init__d s· ô '¤7Ô+Ð:¬T°'«]Ó:Ð+ô &¤)Ô,Ð:¬d°6«lÓ:Ð,ð ×$Ñ$ò 7DÜ D$¤¨°Ó 5Õ 6ð 7à#à mm Øà Ü II f×&9Ñ&9Ó :Ôà))Ø::Ø ,Õro c ó fd}t j | j ¬« } j |« S )z
|
Dispatch to _upsample; we are stripping all of the _upsample kwargs and
|
performing the original function call on the grouped object.
|
c óÄ j | j j ¬« } t t « r t | « di ¤S | j g¢i ¤S )N)rl ra r½ )Ú_resampler_clsrN rQ rÑ rÆ rs rH )r¾ r r« r rk s rm r z"_GroupByMixin._apply.<locals>.func sb ø Ø×#Ñ# A°4×3DÑ3DÐPT×PWÑPWÐ#ÓXAä!SÔ!Ø$wq !}Ñ. vÑ.Ð.à1771Ð.tÒ. vÑ.Ð .ro )r^ )rÄ rN r^ rÇ )rk r« r r r r£ s ```` rm rÄ z_GroupByMixin._apply s3 û ÷ /ô t¸D×<OÑ<OÔPØ× Ñ Ó(Ð(ro c ó |%| j }||| }n|j dk( sJ t |t « r5| j |vr'| j |j | j « | j | }| j ||« } t | « |t t | « |¬« }|S # t $ r | j }Y Mw xY w)r² r³ )r§ rÊ r] ) rR r· rÑ Úlistri rÏ rN Ú
|
IndexErrorÚ_infer_selectionry r rK )rk ri r· r¸ r§ r] Únew_rss rm rº z_GroupByMixin._gotitem sÊ ð >ØXXFØØ ð {{ aÒ'Ð'Ð'ð $Ü#tÔ$¨¯©¸Ñ)<ÀÇÁÐAUØ
|
|
488Ô$Ømm CÑ(Gð ×)Ñ)¨#¨vÓ6 àdØÜ 4Ó(Ø ô
|
ð
|
øô ò $ØmmGð $ús ©AB3 Â3C Ã
|
C )
|
rÊ rK r§ r) r] rM r^ r5 r6 r7 r )rz r@ rA rB rC rh rn r
|
rÄ r° r¬ r¢ r rº r½ ro rm rL rL Z s¡
ñð ÓØ$(JÐ!Ó(ØÓØ Ó ð Ø'+Ø $ñ -ð ð -ð ð -ð %ð -ð ð -ð
|
ó -ð@ ñ)ó ð)ð" IØKØ #Ðà
|
ò$ó ñ$ro rL c óV e Zd ZU ded< ed « Zd Zd Zd Zd d
|
dZ fdZ
|
xZ S ) ÚDatetimeIndexResamplerr1 rQ c ó t S r )Ú DatetimeIndexResamplerGroupbyr s rm rË z.DatetimeIndexResampler._resampler_for_groupingÅ s ä,Ð,ro c ó´ | j dk( r%| j j | j « S | j j | j « S )NÚperiod)rY rN Ú_get_time_period_binsrQ Ú_get_time_binsr s rm r z+DatetimeIndexResampler._get_binner_for_timeÉ sD à 99Ò Ø×$Ñ$×:Ñ:¸4¿7¹7ÓCÐ CØ× Ñ ×/Ñ/°·±Ó8Ð8ro c ór |}t j |« xs |}||k7 r t | ||« | j }| j }t |« s|j « }|j j | j « |_ |j j | j k( s'J |j j | j f« |S |j |j =t | j j « t |« kD r|| j « S | j dk( r- |j | j « j |fi |¤}n@ |j" j | j « j |fi |¤j" }| j% |« S )úÀ
|
Downsample the cython defined function.
|
|
Parameters
|
----------
|
how : string / cython mapped function
|
**kwargs : kw args passed to how function
|
r )ÚcomÚget_cython_funcr! rQ rÀ r r rÒ Ú
|
_with_freqrT Ú inferred_freqrL r rï rU r§ r rB rÇ )rk r¤ r Úorig_howrQ rR r£ s rm r¬ z"DatetimeIndexResampler._downsampleÏ s_ ð Ü×!Ñ! #Ó&Ò-¨#Ø s?Ü " 4¨°3Ô 7Ø WWð ×'Ñ'ä2wà((*CØ ×,Ñ,¨T¯Y©YÓ7CIØ99>> T§Y¡YÒ.Ð K°·±· ± ÀÇÁÐ0KÓ KÐ.ØJð WWÐ B×$4Ñ$4Ð$@ÜDMM×+Ñ+Ó,¬s°2«wÒ6Ø ð ;;=Ð ð 99>Ø9S[[ § ¡ Ó/×9Ñ9¸#ÑHÀÑHFð <SUU]] 4§=¡=Ó1×;Ñ;¸CÑJÀ6ÑJ×LÑLFà× Ñ Ó(Ð(ro c ó< | j dk( r|dd }|S |dd }|S )z|
|
Adjust our binner when upsampling.
|
|
The range of a new index should not be outside specified range
|
Úrightr³ Néÿÿÿÿ)rV ©rk rO s rm Ú_adjust_binner_for_upsamplez2DatetimeIndexResampler._adjust_binner_for_upsampleý s4 ð ;;'Ò !ØABZFð ð CR[FØ ro c óÈ | j r t d« | j r t d« | j }| j
|
}| j }| j |« }|Qt |j « | j k( r/t |« t |« k( r|j « }||_ n |dk( rd}|j ||||¬« }| j |« S )aª
|
Parameters
|
----------
|
method : string {'backfill', 'bfill', 'pad',
|
'ffill', 'asfreq'} method for upsampling
|
limit : int, default None
|
Maximum size gap to fill when reindexing
|
fill_value : scalar, default None
|
Value to use for missing values
|
|
See Also
|
--------
|
.fillna: Fill NA/NaN values using the specified method.
|
|
zaxis must be 0zvUpsampling from level= or on= selection is not supported, use .set_index(...) to explicitly set index to datetime-likeNrï )rç r® r¯ )rU ÚAssertionErrorr rÅ rQ r¦ rO rl r rf rT r r rÒ r" rÇ ) rk rç r® r¯ rQ rR rO Ú res_indexr£ s rm r° z DatetimeIndexResampler._upsample sÝ ð 99Ü Ð!1Ó2Ð 2Ø × Ò Ü ð;óð ð WWØ× Ñ ØØ×4Ñ4°VÓ< ð MÜ"×*Ñ*Ó+¨t¯y©yÒ8ÜCC NÒ*àXXZFØ$FLàÒ!Ø Ø[[Ø &°À*ð !ó Fð × Ñ Ó(Ð(ro c óú t | |« }| j dk( rÛt |j t
|
« sÁt |j t « r}t |j j d t
|
« sT|j j d j | j « }|j j |d¬« |_ |S |j j | j « |_ |S )Nr^ rj )r ) r rÇ rY rÑ rÒ r3 r/ ÚlevelsÚ to_periodrT Ú
|
set_levels)rk r£ Ú new_levelr s rm rÇ z#DatetimeIndexResampler._wrap_result8 sº ø ÜÑ% fÓ-ð 99Ò ¬°F·L±LÄ+Ô)NÜ&,,¬
|
Ô3ä! &§,¡,×"5Ñ"5°bÑ"9¼;ÔGØ &§ ¡ × 3Ñ 3°BÑ 7× AÑ AÀ$Ç)Á)Ó LIØ#)§<¡<×#:Ñ#:¸9ÈBÐ#:Ó#OFLð ð &||× 5Ñ 5°d·i±iÓ @ Ø ro r9 r: ) rz r@ rA rC rE rË r r¬ rl r° rÇ rI rJ s @rm rZ rZ Â s; ø
ØÓà ñ-ó ð-ò9ò ,)ò\
|
ô-)÷^ ð ro rZ c ó e Zd ZdZed « Zy)r\ z9
|
Provides a resample of a groupby implementation
|
c ó t S r )rZ r s rm rS z,DatetimeIndexResamplerGroupby._resampler_clsQ s ä%Ð%ro N©rz r@ rA rB rE rS r½ ro rm r\ r\ J s ñð ñ&ó ñ&ro r\ c ó^ e Zd ZU ded< ed « Z fdZd fd Z fdZd d
|
fd Z xZ
|
S ) ÚPeriodIndexResamplerr3 rQ c ó t S r )ÚPeriodIndexResamplerGroupbyr s rm rË z,PeriodIndexResampler._resampler_for_grouping[ s ä*Ð*ro c ó | j dk( rt | « S | j j | j
|
« S )NÚ timestamp)rY r r rN Ú_get_period_binsrQ )rk r s rm r z)PeriodIndexResampler._get_binner_for_time_ s8 ø Ø 99 Ò #Ü7Ñ/Ó1Ð 1Ø× Ñ ×1Ñ1°$·'±'Ó:Ð:ro c ó® t | |« }| j r d}t |« | j dk( r |j | j ¬« }|S )NzResampling from level= or on= selection with a PeriodIndex is not currently supported, use .set_index(...) to explicitly set indexr} ©r¤ )r rf r ÚNotImplementedErrorrY Ú to_timestamprX )rk rR Úmsgr s rm rf z!PeriodIndexResampler._convert_objd s\ ø ÜgÑ" 3Ó'à × Ò ð>ð ô
|
& cÓ*Ð *ð 99 Ò #Ø×"Ñ" t§¡Ð"Ó7Cà
|
ro c óD | j dk( rt | |fi |¤S |}t j |« xs |}||k7 r t | ||« | j }t |j | j « r | j |fi |¤S t |j | j « r&|dk( r| j |« S | j « S |j | j k( r| j « S t d|j d| j d« )rb r} r z
|
Frequency z cannot be resampled to z&, as they are not sub or super periods) rY r r¬ rc rd r! rQ r7 rT r¢ r8 rï r )rk r¤ r rg rQ r s rm r¬ z PeriodIndexResampler._downsamplev s ø ð 99 Ò #Ü7Ñ& sÑ5¨fÑ5Ð 5àÜ×!Ñ! #Ó&Ò-¨#Ø s?Ü " 4¨°3Ô 7Ø WWä §¡Ô +à.4×.Ñ.¨sÑ=°fÑ=Ð =Ü BGG T§Y¡YÔ /Øf}ð ×2Ñ2°3Ó7Ð7Ø;;=Ð Ø WW Ò !Ø;;=Ð ä#Ø Ð!9¸$¿)¹)¸ð E3ð 3ó
|
ð
|
ro c óf | j dk( rt
|
| |||¬« S | j }| j }| j
|
}|j | j | j ¬« }|dk( rd}|j |||¬« }t |||| j ¬« } | j | « S )a
|
Parameters
|
----------
|
method : {'backfill', 'bfill', 'pad', 'ffill'}
|
Method for upsampling.
|
limit : int, default None
|
Maximum size gap to fill when reindexing.
|
fill_value : scalar, default None
|
Value to use for missing values.
|
|
See Also
|
--------
|
.fillna: Fill NA/NaN values using the specified method.
|
|
r} )r® r¯ r rï N)rç r® r ) rY r r° rQ rR rO rï rT rX Ú get_indexerÚ_take_new_indexrU rÇ ) rk rç r® r¯ rQ rR Ú new_indexÚmembr Únew_objr s rm r° z PeriodIndexResampler._upsample s² ø ð" 99 Ò #Ü7Ñ$ V°5ÀZÐ$ÓPÐ Pà WWØhhØKK ð yy¨¯©yÓ8ð XÒ ØFØ×"Ñ" 9°VÀ5Ð"ÓIÜ!Ø Ø Ø Øô
|
ð × Ñ Ó)Ð)ro r8 r9 r: ) rz r@ rA rC rE rË r rf r¬ r° rI rJ s @rm ry ry V s6 ø
ð Oà ñ+ó ð+ô;õ
|
ô$%
|
÷N%*ò %*ro ry c ó e Zd ZdZed « Zy)r{ ú:
|
Provides a resample of a groupby implementation.
|
c ó t S r )ry r s rm rS z*PeriodIndexResamplerGroupby._resampler_clsÎ s ä#Ð#ro Nrw r½ ro rm r{ r{ Ç s ñð ñ$ó ñ$ro r{ c ó4 e Zd ZU ded< ed « Zd Zd Zy)ÚTimedeltaIndexResamplerr5 rQ c ó t S r )Ú TimedeltaIndexResamplerGroupbyr s rm rË z/TimedeltaIndexResampler._resampler_for_groupingØ s ä-Ð-ro c óL | j j | j « S r )rN Ú_get_time_delta_binsrQ r s rm r z,TimedeltaIndexResampler._get_binner_for_timeÜ s Ø× Ñ ×5Ñ5°d·g±gÓ>Ð>ro c ó |S )zÇ
|
Adjust our binner when upsampling.
|
|
The range of a new index is allowed to be greater than original range
|
so we don't need to change the length of a binner, GH 13022
|
r½ rk s rm rl z3TimedeltaIndexResampler._adjust_binner_for_upsampleß s ð ro N)rz r@ rA rC rE rË r rl r½ ro rm r r Ó s&
ð Óà ñ.ó ð.ò?óro r c ó e Zd ZdZed « Zy)r r c ó t S r )r r s rm rS z-TimedeltaIndexResamplerGroupby._resampler_clsò s ä&Ð&ro Nrw r½ ro rm r r ë s ñð ñ'ó ñ'ro r c ó@ t | fi |¤}|j | |¬« S )z8
|
Create a TimeGrouper and return our resampler.
|
©rY )rM Ú_get_resampler)rR rY ÚkwdsÚtgs rm Ú get_resamplerr ÷ s) ô
|
SÑ !DÑ !BØ × Ñ S tÐ Ó ,Ð,ro c ó t d||d|¤} | j | j |¬« }
|
|
|
j | || j ¬« S )zA
|
Return our appropriate resampler when grouping as well.
|
)rT ri r )r§ r^ ri r½ )rM r rR rÌ ri ) r§ Úruler¤ Ú fill_methodr® rY Úonr^ r r Ú resamplers rm Úget_resampler_for_groupingr¢ sT ô
|
Ð 1$ BÑ 1¨&Ñ 1BØ×!Ñ! '§+¡+°DÐ!Ó9IØ × 0Ñ 0ب¸B¿F¹Fð 1ó ð ro c ó e Zd ZU dZej
|
dz Zded< d d fd ZdddZ d ddZ dd Z
|
dd
|
Z dd Z dd Z dd Z ddd d fdZ xZS ) rM ah
|
Custom groupby class for time-interval grouping.
|
|
Parameters
|
----------
|
freq : pandas date offset or offset alias for identifying bin edges
|
closed : closed end of interval; 'left' or 'right'
|
label : interval boundary to use for labeling; 'left' or 'right'
|
convention : {'start', 'end', 'e', 's'}
|
If axis is PeriodIndex
|
)rV rW r¤ rY rX rZ r[ rD rZ Nc ób |dvrt d| d« |dvrt d| d« | dvrt d| d« | |t |j t « s|#|!t || dd « dk( rt |d ¬
|
« }n t |« }h d £}|j }||v sd |v r |d |j d « |v r |d }|d }n| dv r |d }| d }n|d}|d}|| _ || _ |
|
| _
|
| | nd| _ || _ || _ | | _ || _ d | _ | dv r| | _ n t% | « | _ | t) | « nd | _ d |d< t- | \ d|||d|¤ y # t t& f$ r}t d| d« |d }~ww xY w# t t& f$ r}t d| d« |d }~ww xY w)N> NÚleftri zUnsupported value z for `label`z for `closed`> NÚeÚsÚendÚstartz for `convention`r- r^ T)Ú is_period> ÚWÚMEÚQEÚYEÚBMEÚBQEÚBYEú-ri ©r¨ Úend_dayr¥ r¦ )Úepochr© Ú start_dayr¨ r´ z|'origin' should be equal to 'epoch', 'start', 'start_day', 'end', 'end_day' or should be a Timestamp convertible type. Got 'z
|
' instead.z6'offset' should be a Timedelta convertible type. Got 'r` )rT ri rU r½ )rÅ rÑ rÒ r3 rs r Ú rule_codeÚfindrV rW rY rX r¤ r r® r\ rÖ rZ r Ú TypeErrorr r[ r rn )rk rR rT ri rV rW r¤ rU r r® rY rX rZ r[ r\ r Ú end_typesr rÈ r s rm rn zTimeGrouper.__init__1 sF ø ð* Ð/Ñ /Ü Ð 1°%°¸ Ð EÓFÐ FØ Ð0Ñ 0Ü Ð 1°&°¸ Ð GÓHÐ HØ Ð =Ñ =Ü Ð 1°*° Ð=NÐ OÓPÐ Pð KØÜ399¤kÔ2àØOÜC H g¨tÓ4¸Ò@ô T¨TÔ2Dä T?Dâ@ Ø~~Ø 9Ñ ¨¡°Ð6F¸¿ ¹ À#»Ð1GÈ9Ñ1TØ~Ø Ø}Ø ð Ð+Ñ+Ø>Ø $FØ=Ø #Eà>Ø #FØ=Ø "Eà Ø
|
Ø Ø(2Ð(>*ÀCØØ&ÔØ
|
Ø$Ø/3Ôà ÐFÑ Fð !DKð Ü '¨Ó / ð Ø/5Ð/A) FÔ+ÀtDKð vä ÑÐAd¨°$ÑA¸&ÓAøô% ¤ Ð*ò Ü ðDàDJÀ8È:ðWóð ð ûð ûô IÐ&ò Ü ðØ xzð+óð ð ûð ús0 Ä%E# Ä6F
|
Å#FÅ2FÆFÆ
|
F.ÆF)Æ)F.c ó" | j |d¬« \ }}}t |t « r%t || || j | j
|
|¬« S t |t « s|dk( rYt |t « s$t j dt t « ¬« t || || j | j
|
|¬« S t |t « r$t || | j | j
|
|¬« S t dt |« j d « )
|
ad
|
Return my resampler or raise if we have an invalid axis.
|
|
Parameters
|
----------
|
obj : Series or DataFrame
|
kind : string, optional
|
'period','timestamp','timedelta' are valid
|
|
Returns
|
-------
|
Resampler
|
|
Raises
|
------
|
TypeError if incompatible axis
|
|
N©ra )rl rY rU r\ ra r^ zIResampling with kind='period' is deprecated. Use datetime paths instead.râ )rl rU r\ ra zVOnly valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, but got an instance of 'ú')re rÑ r1 rZ rU r\ r3 rä rå ræ r ry r5 r r¹ ry rz )rk rR rY Ú_rQ s rm r zTimeGrouper._get_resampler s ð& ×$Ñ$ S°DÐ$Ó92qÜ b-Ô (Ü)ØØ ØØYYØ ??Ø ô ð ô KÔ (¨D°HÒ,<Ü b¤+Ô.Ü ð2ä!Ü /Ó 1õ ô (ØØ ØØYYØ ??Ø ô ð ô NÔ +Ü*ØØ ØYYØ ??Ø ô ð ô ð 'ä'+¨B£x×'8Ñ'8Ð&9¸ð <ó
|
ð
|
ro c óp | j |« }|j t t |j « fS r )r rL r r rR )rk rR ÚvalidateÚrs rm Ú _get_grouperzTimeGrouper._get_grouperØ s. ð × Ñ Ó $Øzz4¤¨!¯%©%Ó0Ð0Ð0ro c
|
óü t |t « s!t dt |« j « t |« dk( r4t g | j |j |j ¬« x}}|g |fS t |j « |j « | j |j | j | j | j ¬« \ }}t! | j |||j" |j dd|j ¬« x}}|j$ }| j' ||« \ }}t) j* ||| j |j, ¬« }| j d k( r|}| j. d k( r|d
|
d }n| j. d k( r|d
|
d }|j, r,|j1 dt2 « }|j1 dt2 « }t |« t |« k r|d t |« }|||fS ) Nú5axis must be a DatetimeIndex, but got an instance of r ©ÚdatarT rÐ r- ©ÚunitrV rZ r[ TÚ shift_forward)rT r© r¨ ÚtzrÐ Ú ambiguousÚ nonexistentrÈ )Úhasnansri r³ )rÑ r1 r¹ ry rz r rT rÐ r- Ú_get_timestamp_range_edgesr r rÈ rV rZ r[ r2 rÊ Úasi8Ú_adjust_bin_edgesr Úgenerate_bins_dt64rÍ rW Úinsertr ) rk rQ rO Úlabelsr r Ú ax_valuesÚ bin_edgesr s rm r` zTimeGrouper._get_time_binsß sÏ Ü"mÔ,Üð"Ü"& r£(×"3Ñ"3Ð!4ð6óð ô
|
r7a<Ü +Ødii¨b¯g©g¸R¿X¹Xô ð FVð 2vÐ%Ð %ä0Ø FFHØ FFHØ IIØØ;;Ø;;Ø;;ô
|
tô %ØØØØuuØØØ'Øô
|
ð
|
ð GG Ø × 2Ñ 2°6¸9Ó EÑ ô ×%Ñ%Ø y $§+¡+°r·z±zô
|
ð ;;'Ò !ØFØzzWÒ$Ø Ø ZZ7Ò "ØABZFà ::Ø]] 1¤cÓ*FØ]] 1¤cÓ*Fô
|
t9s6{Ò "ØKc $iÐ(FàtVÐ#Ð#ro c óZ | j j dv s*| j j j d« d dv rÚ| j dk( r|j d « }|t d|j ¬« j |j « z t d|j ¬« j |j « z
|
}|j |j « j }n |j }|d |j « kD r
|
|d d
|
}|d d
|
}||fS |j }||fS ) N)r¯ r¬ r« r² r )r° r± r r® r« ri r³ )ÚdaysrÈ ©rÈ éþÿÿÿrj ) rT rÐ ÚsplitrV Ú tz_localizer rÈ Úas_unitrÊ rÏ r )rk rO rÔ Ú edges_dtirÕ s rm rÐ z TimeGrouper._adjust_bin_edges" s ð
|
99>>Ð /Ñ /°4·9±9·>±>×3GÑ3GÈÓ3LÈQÑ3Oð T
|
ñ 4
|
ð {{gÒ%à "× .Ñ .¨tÓ 4 à Ü Q¨Y¯^©^Ô<×DÑDÀYÇ^Á^ÓTñUä ¨ ¯©Ô7×?Ñ?À ÇÁÓOñPð ð
|
&× 1Ñ 1°&·)±)Ó <× AÑ A à "KK ð }y}}Ò.Ø % c rN Ø ð yÐ Ð ð IØyÐ Ð ro c ó° t |t « s!t dt |« j « t | j
|
t « st d| j
|
« t |« s)t g | j
|
|j ¬« x}}|g |fS |j « |j « }}| j dk( r|| j
|
z }t ||| j
|
|j ¬« x}}|}| j dk( r|| j
|
z }|j || j ¬« }| j r|| j z }|||fS )Nz6axis must be a TimedeltaIndex, but got an instance of zWResampling on a TimedeltaIndex requires fixed-duration `freq`, e.g. '24h' or '3D', not ©rÆ rT rÐ ri ©r© r¨ rT rÐ r¥ ©Úside)rÑ r5 r¹ ry rz rT r: rÅ r rÐ r r rV r6 Ú searchsortedr[ )rk rQ rO rÓ r© r¨ Ú
|
end_stampsr s rm r z TimeGrouper._get_time_delta_binsF s> Ü"nÔ-Üð"Ü"& r£(×"3Ñ"3Ð!4ð6óð ô
|
$))¤TÔ*ä ð+Ø+/¯9©9¨+ð7óð ô
|
2wÜ ,°"¸4¿9¹9È2Ï7É7Ô SÐ SFVØ2vÐ%Ð %àVVXrvvxsà ;;'Ò !Ø 499Ñ Cä)ØS t§y¡y°r·w±wô
|
ð
|
ð
|
Ø ;;&Ò Ø $))Ñ #Jàz°· ± Ó<à ;;à dkkÑ !FàtVÐ#Ð#ro c óò t |t « s!t dt |« j « | j
|
}t |« dk( r*t g ||j |j ¬« x}}|g |fS t |d |d ||j ¬« x}}||z j |d« j « }|j r|j |j « }|j |d¬« }|||fS ) NrÄ r rÅ rj rà r§ r¥ rá )rÑ r1 r¹ ry rz rT r r3 rÐ r- r4 rï r rÊ rÛ rã )rk rQ rT rO rÓ rä r s rm r_ z!TimeGrouper._get_time_period_binsm s÷ Ü"mÔ,Üð"Ü"& r£(×"3Ñ"3Ð!4ð6óð ð
|
yyä r7a<Ü )Ød¨¯©¸¿¹ô ð FVð 2vÐ%Ð %ä&¨R°©U¸¸2¹ÀTÐPR×PWÑPWÔXÐXà tm×+Ñ+¨D°#Ó6×CÑCÓE
|
Ø 55Ø#×/Ñ/°·±Ó6JØz°Ó7àtVÐ#Ð#ro c óâ t |t « s!t dt |« j « |j | j | j ¬« }d}|j r/t j |j « }||j }t |« swt j g t j ¬« }t g | j |j ¬« x}}t |« dkD rt! |||t |« « \ }}}|||fS | j j" }|j% « j | j | j ¬« }|j' « j | j d¬« } d}
|
t | j t( « rzt+ || | j | j, | j. | j0 ¬« \ } } t3 || j « t3 | | j « z
|
} | j" |z }
|
| }t5 || | j |j ¬« x}}|j6 } t |« |z }|| d | d z
|
z
|
}t j8 | d | d |z |« }||z }||
|
z } t |j: « ||j< ¬« }|j? |d
|
¬ « }|dkD rt! ||||« \ }}}|||fS ) Nz3axis must be a PeriodIndex, but got an instance of r r )r- rß r¨ )rV rZ r[ rà rj r¥ rá ) rÑ r3 r¹ ry rz rï rT rX rÍ Únprô Ú_isnanr Úarrayr+ rÐ Ú_insert_nat_binÚnr r r: Ú_get_period_range_edgesrV rZ r[ r r4 rÏ ÚarangeÚ_datar- rã )rk rQ r Ú nat_countr rO rÓ Ú freq_multr© r¨ Ú bin_shiftÚp_startÚ start_offsetÚi8Úexpected_bins_countÚ i8_extendÚrngÚprngs rm r~ z TimeGrouper._get_period_bins
s Ü"kÔ*Üð"Ü"& r£(×"3Ñ"3Ð!4ð6óð ð
|
yy¨¯©yÓ8ð Ø <<ô t{{Ó+IØ Ñ%Dä4yä88B¤b§h¡hÔ/DÜ )¨r¸¿ ¹ ÈÏÉÔ PÐ PFVÜ2w{ä'6°v¸tÀVÌSÐQSËWÓ'UÑ$fØ4 Ð'Ð 'àIIKK à § ¡ ¨t¯©Ó?Øffhoodii¨UoÓ3Ø ä dii¤Ô &ô
|
3ØØØ Ø{{Ø{{Ø{{ô LGSô " %¨¯©Ó3´f¸WÀdÇiÁiÓ6PÑPLà$¨Ñ2IØEä&ØS t§y¡y°r·w±wô
|
ð
|
ð YYô " &k¨IÑ 5ÐØ'¨2¨b©6°B°q±E©>Ñ: Üii1r "v¨ Ñ 1°9Ó=Ø yÑà yÑð tDJJÓ ¨4¯:©:Ô6Ø× Ñ ¨FÐ Ó3à q=Ü#2°6¸4ÀÈÓ#SÑ FD&àtVÐ#Ð#ro r¼ c ó" t | |||¬« \ }}}t |j t « rZ|j j
|
dv rB|j | _ t t t |j « j « « }|||fS )Nr¼ ÚMm) r re rÑ r- r rY rÖ r0 r r" ré Ú _maybe_convert_datelike_array)rk rR r` ra rQ r r s rm re zTimeGrouper._set_grouperÐ s| ø ô !7Ñ/°°TÀYÐ/ÓOÑRÜ bhh¤
|
Ô +°·±· ± ÀÑ0EØ "§¡DÔ ÜÜÔ(¨"¯(©(Ó3×QÑQÓSóBð BÐ Ð ro )NÚMinNNNr r NNNNr¶ NF) rR zGrouper | NonerT r? ri ú
|
str | NonerV ú Literal['left', 'right'] | NonerW rþ r¤ rÆ rU r= r® r; rY rý rX z(Literal['start', 'end', 'e', 's'] | NonerZ zTLiteral['epoch', 'start', 'start_day', 'end', 'end_day'] | TimestampConvertibleTypesr[ z TimedeltaConvertibleTypes | Noner\ r5 r6 r7 r )rR r% r6 rK r= )rR r rÀ r5 r6 ztuple[BinGrouper, NDFrameT])rQ r1 )rO r1 rÔ znpt.NDArray[np.int64]r6 z+tuple[DatetimeIndex, npt.NDArray[np.int64]])rQ r5 )rQ r3 r? )rR r r` r5 ra z Index | Noner6 z3tuple[NDFrameT, Index, npt.NDArray[np.intp] | None])rz r@ rA rB r- rx rC rn r r r` rÐ r r_ r~ re rI rJ s @rm rM rM s ø
ñ
|
ð ×%Ñ%ð )ñ Kð Ó ð #Ø Ø Ø26Ø15ØØØØ Ø Ø?Cà&1Ø37Ø ð!iBà ðiBð ðiBð ð iBð
|
0ð iBð /ð iBð ðiBð ðiBð ðiBð ðiBð =ðiBð$ðiBð 1ð iBð ð!iBð$
|
õ%iBôV:
|
ðz /3ð1Øð1Ø'+ð1à $ó1óA$ðF"!Ø#ð"!Ø0Eð"!à 4ó"!óH%$óN$ó0I$ðX +0ð ØNRñ Øð Ø#'ð Ø?Kð à <÷ ñ ro rM c ój t | t « r>t j | j |« }| j ||| j ¬« S t | t « rK|dk( r t d« | j j ||d¬« }| j ||j ¬« S t d« )N)rÒ rÐ r³ zaxis 1 is not supported)Únew_axisr rU )Úaxesz.'obj' should be either a Series or a DataFrame)rÑ r ÚalgosÚtake_ndÚ_valuesÚ _constructorrÐ r r Ú_mgrÚreindex_indexerÚ_constructor_from_mgrr rÅ )rR r r rU Ú
|
new_valuesÚnew_mgrs rm r r Ü s¦ ô #yÔ!Ü]] 3§;¡;°Ó8
|
à× Ñ Ø i¨c¯h©hð ó
|
ð
|
ô
|
C Ô &Ø 19Ü%Ð&?Ó@Ð @Ø((×*Ñ*°IÀwÐUVÐ*ÓWà×(Ñ(¨°w·|±|Ð(ÓDÐDäÐIÓJÐJro c ó¶ t |t « rê| j }t |t « r |j du |du k7 r t d« |dk( r t d|¬« }t |t
|
« rC| j d« } |j d« }t |t « r|j d« }t | ||||||¬« \ } }t |t
|
« r"| j |« } |j |« }| |fS | j « } |j « }|dk( rt |j | « « } nt | |z
|
« } t ||z « }| |fS )aW
|
Adjust the `first` Timestamp to the preceding Timestamp that resides on
|
the provided offset. Adjust the `last` Timestamp to the following
|
Timestamp that resides on the provided offset. Input Timestamps that
|
already reside on the offset will be adjusted depending on the type of
|
offset and the `closed` parameter.
|
|
Parameters
|
----------
|
first : pd.Timestamp
|
The beginning Timestamp of the range to be adjusted.
|
last : pd.Timestamp
|
The ending Timestamp of the range to be adjusted.
|
freq : pd.DateOffset
|
The dateoffset to which the Timestamps will be adjusted.
|
closed : {'right', 'left'}, default "left"
|
Which side of bin interval is closed.
|
origin : {'epoch', 'start', 'start_day'} or Timestamp, default 'start_day'
|
The timestamp on which to adjust the grouping. The timezone of origin must
|
match the timezone of the index.
|
If a timestamp is not used, these values are also supported:
|
|
- 'epoch': `origin` is 1970-01-01
|
- 'start': `origin` is the first value of the timeseries
|
- 'start_day': `origin` is the first day at midnight of the timeseries
|
offset : pd.Timedelta, default is None
|
An offset timedelta added to the origin.
|
|
Returns
|
-------
|
A tuple of length 2, containing the adjusted pd.Timestamp objects.
|
Nz4The origin must have the same timezone as the index.rµ z
|
1970-01-01)rÊ )rV rZ r[ rÈ r¥ )
|
rÑ r: rÊ r rÅ r9 rÛ Ú_adjust_dates_anchoredÚ normalizeÚrollback)r r rT rÈ rV rZ r[ Úindex_tzs rm rÎ rÎ ï sQ ôR $Ô Ø88Ü fiÔ (¨f¯i©i¸4Ð.?ÀXÐQUÐEUÒ-VÜ Ð SÓTÐ TØ WÒ ô |°Ô9Fä dCÔ ð ×%Ñ% dÓ+EØ×#Ñ# DÓ)DÜ&¤)Ô,Ø ×+Ñ+¨DÓ1ä,Ø 4 f°VÀFÐQUô
|
tô dCÔ Ø×%Ñ% hÓ/EØ×#Ñ# HÓ-Dð $;Ðð Ó!Ø~~Ó à VÒ Ü dmm¨EÓ 2Ó3Eä e dlÓ+Eä Ó%à $;Ðro c óx t d | |fD « « s t d« | j « }|j « }|j |« }|j |« } t |||d|||¬« \ }}|t |« |z z j |« } |t | « |z z
|
j |« }| |fS )al
|
Adjust the provided `first` and `last` Periods to the respective Period of
|
the given offset that encompasses them.
|
|
Parameters
|
----------
|
first : pd.Period
|
The beginning Period of the range to be adjusted.
|
last : pd.Period
|
The ending Period of the range to be adjusted.
|
freq : pd.DateOffset
|
The freq to which the Periods will be adjusted.
|
closed : {'right', 'left'}, default "left"
|
Which side of bin interval is closed.
|
origin : {'epoch', 'start', 'start_day'}, Timestamp, default 'start_day'
|
The timestamp on which to adjust the grouping. The timezone of origin must
|
match the timezone of the index.
|
|
If a timestamp is not used, these values are also supported:
|
|
- 'epoch': `origin` is 1970-01-01
|
- 'start': `origin` is the first value of the timeseries
|
- 'start_day': `origin` is the first day at midnight of the timeseries
|
offset : pd.Timedelta, default is None
|
An offset timedelta added to the origin.
|
|
Returns
|
-------
|
A tuple of length 2, containing the adjusted pd.Period objects.
|
c 3 ó< K | ] }t |t « y wr )rÑ r )rt rR s rm rv z*_get_period_range_edges.<locals>.<genexpr>d
|
s è ø Ò@¨3z#v×&Ñ@ùs z3'first' and 'last' must be instances of type PeriodÚnsrÇ )Úallr¹ r Ú is_on_offsetrÎ r< rr )
|
r r rT rV rZ r[ Úfirst_tsÚlast_tsÚ adjust_firstÚ adjust_lasts
|
rm rì rì >
|
sÍ ôL Ñ@°5¸$°-Ô@Ô @ÜÐMÓNÐNð ×!Ñ!Ó#HØ× Ñ Ó!GØ×(Ñ(¨Ó2Ð2LØ×#Ñ# GÓ,Kä2Ø'4 d°6À&ÐQWôÑHgð LÓ)¨DÑ0Ñ 0× ;Ñ ;¸DÓ AEØ c+Ó&¨Ñ-Ñ -× 8Ñ 8¸Ó >DØ $;Ðro c óª |dkD sJ ||z }t j |d|« }| j dt « } |j dt « }| ||fS )Nr )rç rÒ r )rO r rÓ rï s rm rê rê v
|
s] ð
|
q=Ð=ØIÑDÜ 99T1iÓ (Dð ]]1cÓ "Fð ]]1cÓ "FØ 4Ð Ð ro c óú | j |« } |j |« }||j |« }t |« j |« j }d}|dk( r| j « j }n|dk( r | j }nt |t
|
« r |j |« j }nV|dv rR|dk( r|n|j d« } | j | j z
|
|z }
|
|dk( r|
|
dz }
|
| |
|
|z z
|
} | j }||r |j ndz }| j } |j } | | j d « } | |j d « }| j |z
|
|z } |j |z
|
|z }|d
|
k( rI| dkD r| j | z
|
}n| j |z
|
}|dkD r|j ||z
|
z }nU|j }nH| dkD r| j | z
|
}n | j }|dkD r|j ||z
|
z }n|j |z }t ||¬ « }t ||¬ « }| |j d « j | « }| |j d « j | « }||fS ) Nr r¶ r© r³ r¨ ÚDr¥ r³ ÚUTCri rØ )
|
rÜ r Ú_valuer rÑ r ÚceilÚtzinfoÚ
|
tz_convertrÛ )r r rT rV rZ r[ rÈ Ú
|
freq_valueÚorigin_timestampÚ origin_lastÚsub_freq_timesÚ first_tzinfoÚ last_tzinfoÚfoffsetÚloffsetÚ fresult_intÚ lresult_intÚfresultÚlresults rm r r
|
sx ð MM$Ó EØ <<Ó DØ ÐØ Ó%ä4 ×(Ñ(¨Ó.×5Ñ5JàÐØ Ò Ø ??Ó,×3Ñ3ÑØ 7Ò Ø <<ÑÜ FIÔ &Ø!>>¨$Ó/×6Ñ6ÑØ Ð%Ñ %Ø $¨od°4·9±9¸S³> Ø%×,Ñ,¨u¯|©|Ñ;À
|
ÑJØ VÒ Ø aÑ NØn¨tÑ 3Ñ3Ø <<ÐØ© °QÑ6Ðð
|
<<LØ++KØÐ Ø× Ñ Ó'ØÐ ØuÓ%à||Ð .Ñ.°*Ñ<GØ{{Ð -Ñ-°Ñ;Gà ÒØ Q;à ,,¨Ñ0Kà ,,¨Ñ3Kà Q;à ++¨°gÑ)=Ñ>Kð ++Kà Q;Ø ,,¨Ñ0Kð ,,Kà Q;à ++¨°gÑ)=Ñ>Kà ++¨
|
Ñ2KÜ ¨$Ô/GÜ ¨$Ô/GØÐ Ø×%Ñ% eÓ,×7Ñ7¸ ÓEØÐ Ø×%Ñ% eÓ,×7Ñ7¸ ÓDØ GÐ Ðro c ó| t | j t « r| t d« |d}t |t « rFt |d« r!t |j |j « }nt d|j d« | j « }| j j ||¬« |_ |S t | j « dk( r-| j « }t | j |« |_ |S d}t | j t « r| j j }t# | j j% « | j j' « ||¬ « }| j j |_ | j) |||¬
|
« }|r |j j+ « |_ |S ) z
|
Utility frequency conversion method for Series/DataFrame.
|
|
See :meth:`pandas.NDFrame.asfreq` for full documentation.
|
Nz"'method' argument is not supportedÚEÚ_period_dtype_codezInvalid offset: 'z.' for converting time series with PeriodIndex.r r )rT rÈ )rç r¯ )rÑ rÒ r3 r r Úhasattrr rë rÐ rÅ Úbaser rï r rÔ r1 rÈ r2 r r r" r ) rR rT rç r¤ r r¯ r rÈ Údtis rm rï rï Ü
|
sc ô #))[Ô)Ø Ð Ü%Ð&JÓKÐ Kà ;ØCä dJÔ 'ÜtÐ 1Ô2Ü-¨d¯f©f°d·i±iÓ@ä Ø'¨¯ © {ð 3(ð )óð ð
|
((*Ø ×(Ñ(¨°3Ð(Ó7 ð" Nô
|
SYY 1Ò Ø((*ä& s§y¡y°$Ó7 ð Nð Ü cii¤ Ô /à99>>DÜ ¨#¯)©)¯-©-«/ÀÈ4ÔPØ99>>Ø++c¨&¸Z+ÓHÙ Ø #MM× 3Ñ 3Ó 5GMà Nro c óx t | « dk7 r t d« t | t « r| j |¬« }|S t | t
|
« r%t g | j || j ¬« }|S t | t « r%t g | j || j ¬« }|S t t | « « )zì
|
Helper to mimic asfreq on (empty) DatetimeIndex and TimedeltaIndex.
|
|
Parameters
|
----------
|
index : PeriodIndex, DatetimeIndex, or TimedeltaIndex
|
freq : DateOffset
|
|
Returns
|
-------
|
same type as index
|
r zECan only set arbitrary freq for empty DatetimeIndex or TimedeltaIndexrÎ )r- rT rÐ ) r rÅ rÑ r3 rï r1 r- rÐ r5 r¹ ry )rÒ rT r s rm rÔ rÔ s¬ ô 5zQäØ Só
|
ð
|
ô %Ô%ØLL dLÓ+ ð Ðô
|
E=Ô )Ü! "¨E¯K©K¸dÈÏÉÔT ð
|
Ðô
|
E>Ô *Ü" 2¨U¯[©[¸tÈ%Ï*É*ÔU ð Ðô U Ó$Ð$ro c óè |duxr t |« dkD }|duxr t |« dkD }|r|rd}n |rd}n|rd}nyt j d| d| j d| d t t « ¬
|
« y) a
|
Warn for deprecation of args and kwargs in resample functions.
|
|
Parameters
|
----------
|
cls : type
|
Class to warn about.
|
kernel : str
|
Operation name.
|
args : tuple or None
|
args passed by user. Will be None if and only if kernel does not have args.
|
kwargs : dict or None
|
kwargs passed by user. Will be None if and only if kernel does not have kwargs.
|
Nr zargs and kwargsr r zPassing additional z to ú.zj has no impact on the result and is deprecated. This will raise a TypeError in a future version of pandas.)Úcategoryrã )r rä rå rz ræ r )ÚclsÚkernelr r Ú warn_argsÚ warn_kwargsr s rm rù rù , s ð DÐ Ò2¤S¨£Y°¡]IØ Ð$Ò8¬¨V«°q© KÙ[Ø Ù ØÙ ØàÜ MMØ
|
cU $ s§|¡| n°A°f°Xð >;ð ;ô Ü#Ó%ö ro c ó¶ d}t j dd« }t |t |¬« 5 | j |g|¢d|i|¤}d d d « |S # 1 sw Y S xY w)Nz7DataFrameGroupBy.apply operated on the grouping columnsÚDataFrameGroupByÚresample)Útarget_messageÚtarget_categoryÚ new_messager^ )r* Úformatr ræ rH )r¹ r¤ r^ r r r> r@ r£ s rm rÄ rÄ N sp ð ONÜ'×.Ñ.Ð/AÀ:ÓNKÜ Ø%Ü%Ø ô
|
ñ Tð
|
sÐS TÒS¸.ÐSÈFÑS÷ Tð M÷ Tð Mús «AÁAr )rR zSeries | DataFramer6 rK )NNNNNT)r§ r) r® r; r^ r5 r6 rK )r )
|
rR r r znpt.NDArray[np.intp]r r0 rU r> r6 r )r¥ r¶ N)r r r r rT r rÈ rÆ rV úLiteral['right', 'left']rZ rD r[ úTimedelta | Noner6 útuple[Timestamp, Timestamp])r r r r rT r rV rB rZ rD r[ rC r6 ztuple[Period, Period])
|
rO r3 r z
|
np.ndarrayrÓ r3 rï r< r6 z+tuple[PeriodIndex, np.ndarray, PeriodIndex])ri r¶ Nr )r r r r rT r: rV rB rZ rD r[ rC rÈ rÆ r6 rD )NNFN)rR r r r5 r6 r )rÒ z,DatetimeIndex | PeriodIndex | TimedeltaIndex)r8 rÆ r6 r7 )r¹ r) r¤ r r^ r5 r6 rG )Ú
|
__future__r r Útextwrapr Útypingr r r r r r
|
rä Únumpyrç Ú pandas._libsr Úpandas._libs.tslibsr r r r r r r Úpandas._libs.tslibs.dtypesr Úpandas._typingr Úpandas.compat.numpyr rú Ú pandas.errorsr Úpandas.util._decoratorsr r r Úpandas.util._exceptionsr r Úpandas.core.dtypes.dtypesr Úpandas.core.dtypes.genericr r Úpandas.core.algorithmsÚcoreÚ
|
algorithmsr Úpandas.core.applyr r! Úpandas.core.arraysr" Úpandas.core.baser# r$ Úpandas.core.commonÚcommonrc Úpandas.core.genericr% r& Úpandas.core.groupby.genericr' Úpandas.core.groupby.groupbyr( r) r* r+ r, Úpandas.core.groupby.grouperr- Úpandas.core.groupby.opsr. Úpandas.core.indexes.apir/ Úpandas.core.indexes.baser0 Ú pandas.core.indexes.datetimesr1 r2 Úpandas.core.indexes.periodr3 r4 Ú pandas.core.indexes.timedeltasr5 r6 Úpandas.tseries.frequenciesr7 r8 Úpandas.tseries.offsetsr9 r: Úcollections.abcr; r< r= r> r? r@ rA rB rC rD rE rF r/ rG rH rI rC rK rL rZ r\ ry r{ r r r rB r¢ rM r rÎ rì rê r rï rÔ rù rÄ r½ ro rm ú<module>rh s« ðÞ "ã Ý ÷÷ ó ã å ÷÷ ñ õ >Ý #Ý .Ý -÷ñ ÷
|
õ
|
1÷÷
|
'Ð &÷õ 3÷÷ !Ð ÷õ 6÷õ õ 0Ý .Ý .Ý *÷÷÷÷
|
֖
|
Ý(÷ ÷ ÷ ñ ÷ ð
|
')Ð ^Ó (ô^; \ô ^;ôB/eL .ô eôPCYô CôP &ØÐ)ô &ôl*Ð1ô l*ôb $ØÐ'ô $ôÐ 4ô ô0 'ØÐ*ô 'ô-ð "×)Ñ) Ô ð ØØ Ø Ø Ø ðØ ðð
|
ð ð ðð óô,A 'ô A ðJ UVðKØ ðKØ 0ðKØ=BðKØJQðKà óKð0 (.Ø +Ø #ðLØ ðLà
|
ðLð ðLð ð Lð
|
%ð Lð ð Lð ðLð !óLðf (.Ø +Ø #ð 5Ø ð5à
|
ð5ð ð5ð %ð 5ð
|
ð 5ð ð 5ð ó5ðp Ø ð Ø )ð Ø3>ð ØKNð à0ó ð, (/Ø +Ø #ØðQ Ø ðQ à
|
ðQ ð ðQ ð %ð Q ð
|
ð Q ð ð Q ð ðQ ð !óQ ðn Ø ØØð /Ø ð/ð
|
ð /ð ó/ódó< ðD Ø ð Ø#ð Ø<@ð àô ro
|
