Файловый менеджер - Редактировать - /home/digitalm/venv/lib/python3.7/site-packages/pandas/core/__pycache__/resample.cpython-37.pyc
Назад
B �5�g� � @ s� U d dl mZ d dlZd dlmZ d dlmZ d dlmZm Z m Z m Z d dl Z d dlmZ d dlmZmZmZmZmZmZmZ d dlmZmZmZm Z m Z m Z d d l m Z! d d l"m#Z# d d l$m%Z%m&Z&m'Z'm(Z( d d l)m*Z*m+Z+ d dl,m- m.Z/ d d l0m1Z1 d dl2m3Z3m4Z4 d dl5m- m6Z7 d dl8m9Z9m:Z: d dl;m<Z< d dl=m>Z>m?Z?m@Z@mAZA d dlBmCZC d dlDmEZE d dlFmGZG d dlHmIZImJZJ d dlKmLZLmMZM d dlNmOZOmPZP d dlQmRZRmSZS d dlTmUZUmVZVmWZWmXZX e�r�d dlmYZY i ZZde[d < G d d � d e>e4�Z\x6d D ].Z]e]d fd d!�Z^e_e?e]�j`e^_`eae\e]e^� �qW x4d"D ],Z]e]fd#d$�Zbe_e?e]�j`eb_`eae\e]eb� �q<W x4d%D ],Z]e]fd&d'�Zce_e<e]�j`ec_`eae\e]ec� �qrW G d(d)� d)e4�ZdG d*d+� d+e\�ZeG d,d-� d-edee�ZfG d.d/� d/ee�ZgG d0d1� d1edeg�ZhG d2d3� d3ee�ZiG d4d5� d5edei�Zjdcd6d7�Zke\j`ek_`ddd8d9�ZlG d:d;� d;eC�Zmded<d=d>d?d<d@�dAdB�ZndfdEdEdFdGdHdIdJ�dKdL�ZodgdMdMdFdGdHdNdJ�dOdP�ZpdQd=dQd?dRdS�dTdU�ZqdhdEdEdWdGdHdIdJ�dXdY�Zrdid<d[d<d\�d]d^�Zsd_d`�dadb�ZtdS )j� )� annotationsN)� timedelta)�dedent)� TYPE_CHECKING�Callable�Hashable� no_type_check)�lib)� BaseOffset�IncompatibleFrequency�NaT�Period� Timedelta� Timestamp� to_offset)� FrameOrSeries� IndexLabel�T�TimedeltaConvertibleTypes�TimestampConvertibleTypes�final)�function)�AbstractMethodError)�Appender� Substitution� deprecate_nonkeyword_arguments�doc)� ABCDataFrame� ABCSeries)�ResamplerWindowApply)� DataError� PandasObject)�NDFrame� _shared_docs)� SeriesGroupBy)� BaseGroupBy�GroupBy�_pipe_template� get_groupby)�Grouper)� BinGrouper)�Index)� DatetimeIndex� date_range)� PeriodIndex� period_range)�TimedeltaIndex�timedelta_range)� is_subperiod�is_superperiod)� DateOffset�Day�Nano�Tick)�Literalzdict[str, str]�_shared_docs_kwargsc s& e Zd ZU dZded< e� Zded< dddd d d d d dg Zdmdd�dddd�dd�Ze dd� �Z dd�d d �Z dd �d d �Z e dd�d!d"��Ze d#d$� �Ze d%d�d&d'��Zddd(�d)d*�Zd+d,� Ze d-d.� �Zed d/d0�ee�d1d2d3�� fd4d5� ��Zed6�Zed7�Zee d8 eed9d:d;�d<d=� �Z e Z e Z d>d?� Z d@dA� Z!dndBdC�Z"doddD�dEdF�Z#dpdGdH�Z$dIdJ� Z%dKdL� Z&dMdN� Z'dqdOdP�Z(e(Z)drdQdR�Z*dsdSdT�Z+e+Z,dtdUdV�Z-e.ddWdXgdY�ee/j0fe1�dud]d^���Z0dvd_d`�Z2dwdbdc�Z3dxddde�Z4ee5j6�dfdg� �Z6ee5j7�dhdi� �Z7dydkdl�Z8� Z9S )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* �grouperzfrozenset[Hashable]� exclusions�freq�axis�closed�label� convention�loffset�kind�origin�offsetr N)� selectionr � TimeGrouper�int)�obj�groupbyr> c K s` || _ d | _d| _|| _|| _d| _d| _d| _| j j| � |�dd� | � � \| _ | _ || _ d S )NTF)�sort)rJ �keysrK r> rC ZsqueezeZ group_keysZas_index� _set_grouper� _convert_obj� _get_binner�binnerr; � _selection)�selfrI rJ r> rC rF �kwargs� rT �J/home/digitalm-up/venv/lib/python3.7/site-packages/pandas/core/resample.py�__init__� s zResampler.__init__c K sF t || j�r|j}x$| jD ]}||krt| |�||< qW | j|f|�S )zE return a new object with the replacement attributes )� isinstance� _constructorrI � _attributes�getattr)rR rI rS �attrrT rT rU � _shallow_copy� s zResampler._shallow_copy�str)�returnc s0 � fdd�� j D �}t� �j� dd�|�� d�S )z@ Provide a nice str repr of our rolling object. c 3 s6 | ].}t � j|d �d k r|� dt � j|�� �V qd S )N�=)rZ rJ )�.0�k)rR rT rU � <genexpr>� s z$Resampler.__str__.<locals>.<genexpr>z [z, �])rY �type�__name__�join)rR �attrsrT )rR rU �__str__� s zResampler.__str__)r[ c C sJ || j krt�| |�S || jkr,t| j|�S || jkr>| | S t�| |�S )N)Z_internal_names_set�object�__getattribute__rY rZ rJ rI )rR r[ rT rT rU � __getattr__� s zResampler.__getattr__c C s | j jS )N)rJ rI )rR rT rT rU rI � s z Resampler.objc C s | j jS )N)rJ �ax)rR rT rT rU rl � s z Resampler.ax�boolc C s" | j dk o | j jdk p | j jdk S )zP Is the resampling from a DataFrame column or MultiIndex level. N)rJ �key�level)rR rT rT rU �_from_selection� s zResampler._from_selection)rI r^ c C s |� � S )z� Provide any conversions for the object in order to correctly handle. Parameters ---------- obj : Series or DataFrame Returns ------- Series or DataFrame )Z _consolidate)rR rI rT rT rU rN � s zResampler._convert_objc C s t | ��d S )N)r )rR rT rT rU �_get_binner_for_time� s z Resampler._get_binner_for_timec C s< | � � \}}}t|�t|�ks"t�t||| jjd�}||fS )zk Create the BinGrouper, assume that self.set_grouper(obj) has already been called. )�indexer)rq �len�AssertionErrorr* rJ rr )rR rP �bins� binlabelsZ bin_grouperrT rT rU rO � s zResampler._get_binnera� >>> 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�examplesz/Callable[..., T] | tuple[Callable[..., T], str]r )�funcr^ c s t � j|f|�|�S )N)�super�pipe)rR ry �argsrS )� __class__rT rU r{ � s zResampler.pipea[ 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')) 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') DatetimeIndexResampler [freq=<2 * Seconds>, axis=0, closed=left, label=left, convention=start] >>> r.agg(np.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' : np.sum}) total result 2013-01-01 00:00:00 3 2.121320 2013-01-01 00:00:02 7 4.949747 2013-01-01 00:00:04 5 NaN � aggregate� DataFrame� )Zsee_alsorx rw r> c O sF t | |||d��� }|d kr8|}d }| j||f|�|�}| �|�}|S )N)r| rS )r �agg�_groupby_and_aggregate�_apply_loffset)rR ry r| rS �result�howr; rT rT rU r~ F s zResampler.aggregatec O s | j �| j�j|f|�|�S )a� Call function producing a like-indexed Series on each group and return a Series with the transformed values. Parameters ---------- arg : function To apply to each group. Should return a Series with the same index. Returns ------- transformed : Series Examples -------- >>> resampled.transform(lambda x: (x - x.mean()) / x.std()) )� _selected_objrJ � transform)rR �argr| rS rT rT rU r� [ s zResampler.transformc C s t | ��d S )N)r )rR �frT rT rU � _downsampleo s zResampler._downsamplec C s t | ��d S )N)r )rR r� �limit� fill_valuerT rT rU � _upsampler s zResampler._upsample)�ndimc C sH | j }|dkr| j}t|d|| jd�}y|| S tk rB |S X dS )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)�byr; r> )r; rI r( r> �KeyError)rR rn r� �subsetr; �groupedrT rT rU �_gotitemu s zResampler._gotitemc O s |dkr| j }| j}t|d|| jd�}y<t|t�rNt|�rN|j|f|�|�}n|j|f|�|�}W n� t k r� |j |f|�|�}Y nl t t fk r� |j |f|�|�}Y nD t k r� } z&dt|�kr�n� |j |f|�|�}W dd}~X Y nX | �|�}| �|�S )zA Re-evaluate the obj with a groupby aggregation. N)r� r; r> z Must produce aggregated value)r; r� r( r> rW r �callableZ_aggregate_item_by_itemr~ r �apply�AttributeErrorr� � ValueErrorr] r� � _wrap_result) rR r� r; r| rS rI r� r� �errrT rT rU r� � s& $ z Resampler._groupby_and_aggregatec C sJ t | jtttjf�o,t |jt�o,t|j�dk}|r@|j| j |_d| _|S )a If loffset is set, offset the result index. This is NOT an idempotent routine, it will be applied exactly once to the result. Parameters ---------- result : Series or DataFrame the result of resample r N) rW rB r4 r �npZ timedelta64�indexr, rs )rR r� Z needs_offsetrT rT rU r� � s zResampler._apply_loffsetc C s | j | |d�S )zG Return the correct class for resampling with groupby. )rJ )�_resampler_for_grouping)rR rJ rT rT rU �_get_resampler_for_grouping� s z%Resampler._get_resampler_for_groupingc C s^ t |t�r | jdk r | j|_t |t�rZ|jrZ| j}t|jdd� | jd�|_t |dd�|_|S )z/ Potentially wrap any results. Nr )r= �name) rW r rQ r� �emptyrI �_asfreq_compatr� r= rZ )rR r� rI rT rT rU r� � s zResampler._wrap_resultc C s | j d|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. �pad)r� )r� )rR r� rT rT rU r� � s z Resampler.padc C s | j d|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: 15T, 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: 15T, dtype: float64 �nearest)r� )r� )rR r� rT rT rU r� s :zResampler.nearestc C s | j d|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. pad : 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').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: 30T, dtype: int64 >>> s.resample('15min').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: 15T, 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').backfill() 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').backfill(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 �backfill)r� )r� )rR r� rT rT rU r� = s dzResampler.backfillc C s | j ||d�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 -------- backfill : Backward fill NaN values in the resampled data. pad : 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: 30T, 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: 30T, 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: 15T, 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: 30T, 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: 30T, 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: 30T, 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: 30T, 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: 30T, 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 )r� )r� )rR �methodr� rT rT rU �fillna� s zResampler.fillnarR r� )�versionZ allowed_args�linearF�forwardc K s* | � d�} | jf |||||||d�|��S )zD Interpolate values according to different methods. �asfreq)r� r> r� �inplace�limit_direction� limit_area�downcast)r� � interpolate) rR r� r> r� r� r� r� r� rS r� rT rT rU r� E s zResampler.interpolatec C s | j d|d�S )a6 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. r� )r� )r� )rR r� rT rT rU r� a s zResampler.asfreq� c O s t �d||� | jd|d�S )a/ Compute standard deviation of groups, excluding missing values. Parameters ---------- ddof : int, default 1 Degrees of freedom. Returns ------- DataFrame or Series Standard deviation of values within each group. �std)�ddof)�nv�validate_resampler_funcr� )rR r� r| rS rT rT rU r� w s z Resampler.stdc O s t �d||� | jd|d�S )a Compute variance of groups, excluding missing values. Parameters ---------- ddof : int, default 1 Degrees of freedom. Returns ------- DataFrame or Series Variance of values within each group. �var)r� )r� r� r� )rR r� r| rS rT rT rU r� � s z Resampler.varc C sP | � d�}t| j�sLddlm} | jjdkr6| jj}nd }|g |jd|d�}|S )N�sizer )�Seriesr� �int64)r� �dtyper� ) r� rs rl �pandasr� r� r� r� r� )rR r� r� r� rT rT rU r� � s zResampler.sizec C sb | � d�}t| j�s^| jjdkr>t| j�g |jd| jjd�}n ddlm } |g |j|j dd�}|S )N�countr� r� )r� r� r� r )r )r� �columnsr� ) r� rs rl r� r� rd r� r� r� r r� )rR r� r rT rT rU r� � s zResampler.count� �?c K s | 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 coulmns are groupby columns, and the values are its quantiles. �quantile�q)r� )r� )rR r� rS rT rT rU r� � s zResampler.quantile)r N)NN)N)N)N)N)N)N)r� r NFr� NN)N)r� )r� )r� ):re � __module__� __qualname__�__doc__�__annotations__� frozensetr< rY rV r r\ rh rk �propertyrI rl rp rN rq rO r r r' r{ r Z_agg_see_also_docZ_agg_examples_docr r# r~ r� r� r� r� r� r� r� r� r� r� r� Zffillr� r� Zbfillr� r r" r� r9 r� r� r� r& r� r� r� � __classcell__rT rT )r} rU r: b s� # - < f ! r: )�sum�prod�min�max�first�lastc O s t �|||� | j||d�S )N)� min_count)r� r� r� )rR �_methodr� r| rS rT rT rU r� � s r� )�meanZsemZmedian�ohlcc O s t �|||� | �|�S )N)r� r� r� )rR r� r| rS rT rT rU �g� s r� )Znuniquec C s | � |�S )N)r� )rR r� rT rT rU �h� s r� c @ sX e Zd ZU dZded< dZded< d dd�Zedd d ��ZeZ eZ eZ e dd d ��Z dS )� _GroupByMixinz) Provide the groupby facilities. z list[str]rY NzIndexLabel | NonerQ c K st |d kr |}x(| j D ] }t| ||�|t||��� qW |�d�| _|j| _|| _d| j_d| jj_t � |j �| _ d S )NrF T) rY �setattr�getrZ rQ rP �_groupbyZmutatedr; �copyrJ )rR rI �parentrJ rS r[ rT rT rU rV � s z_GroupByMixin.__init__c s( � ���fdd�}�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 s< �j | �jd�} t�t�r*t| ��f ��S | j�f� ���S )N)rJ )r\ rJ rW r] rZ r� )�x)r| r� rS rR rT rU ry s z"_GroupByMixin._apply.<locals>.func)r� r� r� )rR r� r; r| rS ry r� rT )r| r� rS rR rU �_apply s z_GroupByMixin._applyc s� |dkr� j }� fdd�� jD �}y� j| }W n tk rJ � j}Y nX d}|jdkrzt�|�rl||ksvt�|�rz|}t� �|f|� |d�|��}|S )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 Nc s i | ]}t � |�|�qS rT )rZ )r` r[ )rR rT rU � <dictcomp>; s z*_GroupByMixin._gotitem.<locals>.<dictcomp>� )rJ r� rF ) rI rY r� � IndexErrorr� r Z is_scalarZ is_list_likerd )rR rn r� r� rS rJ rF Znew_rsrT )rR rU r� ' s z_GroupByMixin._gotitem)NN)N)N)re r� r� r� r� rQ rV r r� r� r� r� r r� rT rT rT rU r� � s r� c sJ e Zd Zedd� �Zdd� Zdd� Zdd� Zdd d �Z� fd d �Z � Z S )�DatetimeIndexResamplerc C s t S )N)� DatetimeIndexResamplerGroupby)rR rT rT rU r� P s z.DatetimeIndexResampler._resampler_for_groupingc C s& | j dkr| j�| j�S | j�| j�S )N�period)rC rJ �_get_time_period_binsrl �_get_time_bins)rR rT rT rU rq T s z+DatetimeIndexResampler._get_binner_for_timec K s� t �|�p |}| j}| j}t|�s^|�� }|j�| j�|_|jj| jksZt |jj| jf��|S |jdk sr|j dk r�t| j j �t|�kr�|dkr�| � � S |j| j | jd�j|f|�}| �|�}| �|�S )z� Downsample the cython defined function. Parameters ---------- how : string / cython mapped function **kwargs : kw args passed to how function N)r> )�com�get_cython_funcrl r� rs r� r� Z _with_freqr= rt � inferred_freqr; rv r� rJ r> r~ r� r� )rR r� rS rl rI r� rT rT rU r� [ s z"DatetimeIndexResampler._downsamplec C s( | j dkr|dd� }n |dd� }|S )z| Adjust our binner when upsampling. The range of a new index should not be outside specified range �rightr� N���)r? )rR rP rT rT rU �_adjust_binner_for_upsample� s z2DatetimeIndexResampler._adjust_binner_for_upsampleNc C s� | j rtd��| jr td��| j}| j}| j}| �|�}|dkrpt|j �| j krpt |�t |�krp|� � }||_ n|j||||d�}| �|�}| �|�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-likeN)r� r� r� )r> rt rp r� rl r� rP r� r r� r= rs r� r� �reindexr� r� ) rR r� r� r� rl rI rP Z res_indexr� rT rT rU r� � s$ z DatetimeIndexResampler._upsamplec s6 t � �|�}| jdkr2t|jt�s2|j�| j�|_|S )Nr� )rz r� rC rW r� r. � to_periodr= )rR r� )r} rT rU r� � s z#DatetimeIndexResampler._wrap_result)NN) re r� r� r� r� rq r� r� r� r� r� rT rT )r} rU r� O s ' .r� c @ s e Zd ZdZedd� �ZdS )r� z9 Provides a resample of a groupby implementation c C s t S )N)r� )rR rT rT rU rX � s z*DatetimeIndexResamplerGroupby._constructorN)re r� r� r� r� rX rT rT rT rU r� � s r� c sV e Zd Zedd� �Z� fdd�Zddd�� fdd� Z� fd d �Zd� fd d � Z� Z S )�PeriodIndexResamplerc C s t S )N)�PeriodIndexResamplerGroupby)rR rT rT rU r� � s z,PeriodIndexResampler._resampler_for_groupingc s" | j dkrt� �� S | j�| j�S )N� timestamp)rC rz rq rJ �_get_period_binsrl )rR )r} rT rU rq � s z)PeriodIndexResampler._get_binner_for_timer )rI r^ c sJ t � �|�}| jr d}t|��| jd k r.d| _| jdkrF|j| jd�}|S )Nz�Resampling from level= or on= selection with a PeriodIndex is not currently supported, use .set_index(...) to explicitly set indexr� )r� )rz rN rp �NotImplementedErrorrB rC � to_timestamprA )rR rI �msg)r} rT rU rN � s z!PeriodIndexResampler._convert_objc s� | j dkrt� j|f|�S t�|�p&|}| j}t|j| j�rT| j|fd| j i|��S t |j| j�r�|dkrz| j|| j d�S | � � S |j| jkr�| � � S t d|j� d| j� d���dS ) z� Downsample the cython defined function. Parameters ---------- how : string / cython mapped function **kwargs : kw args passed to how function r� r; r� )r; z Frequency z cannot be resampled to z&, as they are not sub or super periodsN) rC rz r� r� r� rl r2 r= r� r; r3 r� r )rR r� rS rl )r} rT rU r� � s z PeriodIndexResampler._downsampleNc sl | j dkr t� j|||d�S | j}| j}| j}|j| j| jd�}|j |||d�}t |||| j d�} | � | �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� r� )r> ) rC rz r� rl rI rP r� r= rA Z get_indexer�_take_new_indexr> r� ) rR r� r� r� rl rI � new_index�membrr �new_obj)r} rT rU r� s z PeriodIndexResampler._upsample)NN) re r� r� r� r� rq rN r� r� r� rT rT )r} rU r� � s $r� c @ s e Zd ZdZedd� �ZdS )r� z: Provides a resample of a groupby implementation. c C s t S )N)r� )rR rT rT rU rX @ s z(PeriodIndexResamplerGroupby._constructorN)re r� r� r� r� rX rT rT rT rU r� ; s r� c @ s( e Zd Zedd� �Zdd� Zdd� ZdS )�TimedeltaIndexResamplerc C s t S )N)� TimedeltaIndexResamplerGroupby)rR rT rT rU r� F s z/TimedeltaIndexResampler._resampler_for_groupingc C s | j �| j�S )N)rJ �_get_time_delta_binsrl )rR rT rT rU rq J s z,TimedeltaIndexResampler._get_binner_for_timec C s |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 rT )rR rP rT rT rU r� M s z3TimedeltaIndexResampler._adjust_binner_for_upsampleN)re r� r� r� r� rq r� rT rT rT rU r� E s r� c @ s e Zd ZdZedd� �ZdS )r� z: Provides a resample of a groupby implementation. c C s t S )N)r� )rR rT rT rU rX \ s z+TimedeltaIndexResamplerGroupby._constructorN)re r� r� r� r� rX rT rT rT rU r� W s r� c K s t f |�}|j| |d�S )z8 Create a TimeGrouper and return our resampler. )rC )rG �_get_resampler)rI rC �kwds�tgrT rT rU � get_resamplera s r� c K s0 t f ||d�|��}|j| j|d�} | j| d�S )zA Return our appropriate resampler when grouping as well. )r= rn )rC )rJ )rG r� rI r� ) rJ �ruler� � fill_methodr� rC �onrS r� Z resamplerrT rT rU �get_resampler_for_groupingl s r� c s� e Zd ZdZejd Zd%dd d d d d d d �� fdd� Zd&dd�Zd'dd�dd�Zdd�dd�Z dd � Z d d�d d �Z dd�d d!�Z d"d�d#d$�Z � ZS )(rG 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 )r? r@ r� rB rC rA rD rE �MinNr� r � start_dayz!Literal[('left', 'right')] | Nonez str | Nonez int | Nonez str | TimestampConvertibleTypesz TimedeltaConvertibleTypes | None)r? r@ rC rA �baserD rE c sR |dkrt d|� d���|dkr0t d|� d���| dkrHt d| � d���t|�}ddd d d d d h}|j}||ks�d|kr�|d |�d�� |kr�|d kr�d}|d kr�d}n:| dkr�|d kr�d}|d kr�d}n|d kr�d}|d kr�d}|| _|| _| | _| p�d| _| j�� | _|| _ || _ || _ | dk�r.| | _ nJyt | �| _ W n: t tfk �rv } zt d| � d��|�W d d }~X Y nX y | d k �r�t| �nd | _W n: t tfk �r� } zt d| � d��|�W d d }~X Y nX d|d< | d k �r�| d k �r�t d��| �r t|t��r t| |j |j �| _t|t��r0t|�}|| _t� jf ||d�|�� d S )N> N�leftr� zUnsupported value z for `label`z for `closed`> N�e�s�start�endz for `convention`�M�A�QZBMZBAZBQ�W�-r� )r �end_dayr �E)�epochr r r 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 'TrK z6'offset' and 'base' cannot be present at the same time)r= r> )r� r Z rule_code�findr? r@ rC rA �lowerr� r� r� rD r � TypeErrorr rE rW r7 �nanos�nr] rB rz rV )rR r= r? r@ r� r> r� r� rB rC rA r rD rE rS Z end_typesr� r� )r} rT rU rV � sl & zTimeGrouper.__init__c C s� | � |� | j}t|t�r,t|| || jd�S t|t�s>|dkrPt|| || jd�S t|t�rjt || | jd�S t dt |�j � d���dS )a_ Return my resampler or raise if we have an invalid axis. Parameters ---------- obj : input object kind : string, optional 'period','timestamp','timedelta' are valid Returns ------- a Resampler Raises ------ TypeError if incompatible axis )rJ rC r> r� )rJ r> zVOnly valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, but got an instance of '�'N) rM rl rW r, r� r> r. r� r0 r� r rd re )rR rI rC rl rT rT rU r� � s zTimeGrouper._get_resamplerTrm )�validatec C s | � |�}|j|j|jfS )N)r� rP r; rI )rR rI r �rrT rT rU � _get_grouper s zTimeGrouper._get_grouperr, )rl c C sF t |t�s tdt|�j� ���t|�dkrJtg | j|jd� }}|g |fS t|� � |� � | j| j | j | j d�\}}t| j|||j|jddd� }}|j}| �||�\}}tj||| j |jd�}| j d kr�|}| jd kr�|d d � }n| jd kr�|d d � }|j�r|�dt�}|�dt�}t|�t|�k �r<|d t|�� }|||fS ) Nz5axis must be a DatetimeIndex, but got an instance of r )�datar= r� )r? rD rE TZ shift_forward)r= r r �tzr� Z ambiguousZ nonexistent)�hasnansr� r� )rW r, r rd re rs r= r� �_get_timestamp_range_edgesr� r� r? rD rE r- r �asi8�_adjust_bin_edgesr Zgenerate_bins_dt64r r@ �insertr ) rR rl rP �labelsr� r� � ax_values� bin_edgesru rT rT rU r� ! sJ zTimeGrouper._get_time_binsc C s� | j dkr~t| j d�r~| jdkrN|�d �}|td� td� }|�|j�j}n|j}|d |�� kr�|d d� }|d d� }n|j}||fS )N�Dr� r� ���r� ) r= r3 r? � tz_localizer r6 r r r� )rR rP r! r" rT rT rU r ` s z TimeGrouper._adjust_bin_edgesr0 c C s� t |t�s tdt|�j� ���t|�sFtg | j|jd� }}|g |fS |�� |� � }}t ||| j|jd� }}|| j }|j |dd�}| j r�|| j 7 }| j r�|| j 7 }|||fS )Nz6axis must be a TimedeltaIndex, but got an instance of )r r= r� )r r r= r� r )�side)rW r0 r rd re rs r= r� r� r� r1 � searchsortedrE rB )rR rl rP r r r � end_stampsru rT rT rU r� t s z TimeGrouper._get_time_delta_binsc C s� t |t�s tdt|�j� ���| j}t|�sJtg ||jd� }}|g |fS t |d |d ||jd� }}|| � |d�� � }|j r�|� |j �}|j|dd�}|||fS ) Nz5axis must be a DatetimeIndex, but got an instance of )r r= r� r r� )r r r= r� r r )r& )rW r, r rd re r= rs r. r� r/ r� r� r r% r' )rR rl r= rP r r( ru rT rT rU r� � s z!TimeGrouper._get_time_period_binsr. c C s� t |t�s tdt|�j� ���|j| j| jd�}d}|jrRt � |j �}||j }t |�s�t j g t jd�}tg | j|jd� }}t |�dkr�t|||t |��\}}}|||fS | jj}|�� j| j| jd�}|�� j| jdd�} d} t | jt��r8t|| | j| j| j| jd�\} } t|| j�t| | j� } | j| } | }t|| | j|jd� }}|j} t |�| }|| d | d }t � | d | d | |�}||7 }|| 8 }t|j �||j d�}|j |d d �}|dk�r�t||||�\}}}|||fS ) Nz3axis must be a PeriodIndex, but got an instance of )r� r )r� )r r= r� r )r? rD rE )r r r= r� r� r )r& ) rW r. r rd re r� r= rA r r� r� Z_isnanrs �arrayr� r� �_insert_nat_binr r� r� r7 �_get_period_range_edgesr? rD rE r r/ r Zarange�_datar� r' )rR rl r� � nat_countru rP r Z freq_multr r Z bin_shiftZp_startZ start_offset�i8Zexpected_bins_countZ i8_extend�rngZprngrT rT rU r� � sT z TimeGrouper._get_period_bins) r NNr� r NNNNNNr N)N)T)re r� r� r� r) rY rV r� r r� r r� r� r� r� rT rT )r} rU rG x s. [ #? rG r z np.ndarrayr+ rH )rI rr r� r> r^ c C sl t | t�r*t�| j|�}| j||| jd�S t | t�r`|dkrDtd��| j j ||dd�}| �|�S t d��d S )N)r� r� r� zaxis 1 is not supported)Znew_axisrr r> z.'obj' should be either a Series or a DataFrame) rW r �algosZtake_ndZ_valuesrX r� r r� Z_mgrZreindex_indexerr� )rI rr r� r> � new_valuesZnew_mgrrT rT rU r� � s r� r r r r zLiteral[('right', 'left')]zTimedelta | Noneztuple[Timestamp, Timestamp])r� r� r= r? rE r^ c C s� t |t�r�| j}t |t�r6|jdk|dkkr6td��n|dkrJtd|d�}t |t�r|| �d�} |�d�}t |t�r||�d�}t| |||||d�\} }t |t�r�| �|�} |�|�}n@| �� } |�� }|dkr�t|� | ��} n t| | �} t|| �}| |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 )r? rD rE r ) rW r7 r r r� r5 r% �_adjust_dates_anchored� normalize�rollback)r� r� r= r? rD rE Zindex_tzrT rT rU r s. ( r r ztuple[Period, Period]c C s� t dd� | |gD ��s td��| �� }|�� }|�|� }|�|�} t||||||d�\}}|t|�| �|�} |t| �| �|�}| |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 s s | ]}t |t�V qd S )N)rW r )r` rI rT rT rU rb z s z*_get_period_range_edges.<locals>.<genexpr>z3'first' and 'last' must be instances of type Period)r? rD rE )�allr r� Z is_on_offsetr rH r� ) r� r� r= r? rD rE Zfirst_tsZlast_tsZ adjust_firstZ adjust_lastrT rT rU r+ T s & r+ r. z+tuple[PeriodIndex, np.ndarray, PeriodIndex])rP ru r r- r^ c C sD |dks t �||7 }t�|d|�}| �dt�} |�dt�}| ||fS )Nr )rt r� r r )rP ru r r- rT rT rU r* � s r* r� r7 c C s� d}|dkr| � � j}nt|dkr(| j}ndt|t�r:|j}nR|dkr�|dkrN|n|�d�}|j| j |j }|dkrz|d7 }||| } | j}||r�|jnd7 }| j}|j} |d k r�| �d �} | d k r�|�d �}| j| |j } |j| |j } |d k�r>| dk�r| j| } n | j|j } | dk�r6|j|j| } n|j} nD| dk�rT| j| } n| j} | dk�rv|j|j| } n |j|j } t| �} t| �} |d k �r�| �d ��|�} | d k �r�| �d ��| �} | | fS ) Nr r r )r r r r# r r� �UTCr� ) r3 �valuerW r �ceilr �tzinfoZ tz_convertr% )r� r� r= r? rD rE Z origin_nanosZsub_freq_timesZ first_tzinfoZ last_tzinfoZfoffsetrB ZfresultZlresultrT rT rU r2 � sV r2 Frm )rI r3 r^ c C s� t | jt�rD|dk r td��|dkr(d}| �� }| jj||d�|_njt| j�dkrj| �� }t| j|�|_nDt| j� � | j� � |d�}| jj |_ | j |||d�}|r�|j� � |_|S )z� Utility frequency conversion method for Series/DataFrame. See :meth:`pandas.NDFrame.asfreq` for full documentation. Nz"'method' argument is not supportedr )r� r )r= )r� r� )rW r� r. r� r� r� rs r� r- r� r� r� r� r3 )rI r= r� r� r3 r� r� ZdtirT rT rU r� � s r� z,DatetimeIndex | PeriodIndex | TimedeltaIndex)r� c C s| t | �dkrtd��t| t�r,| j|d�}nLt| t�rLtg | j|| jd�}n,t| t�rltg | j|| jd�}n t t | ���|S )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 TimedeltaIndex)r= )r� r= r� ) rs r� rW r. r� r, r� r� r0 r rd )r� r= r� rT rT rU r� s r� )N)NNNNN)r )r r N)r r N)r� r N)NNFN)u� __future__r r� �datetimer �textwrapr �typingr r r r �numpyr� Z pandas._libsr Zpandas._libs.tslibsr r r r r r r Zpandas._typingr r r r r r Zpandas.compat.numpyr r� Z pandas.errorsr Zpandas.util._decoratorsr r r r Zpandas.core.dtypes.genericr r Zpandas.core.algorithms�coreZ algorithmsr0 Zpandas.core.applyr Zpandas.core.baser r! Zpandas.core.common�commonr� Zpandas.core.genericr" r# Zpandas.core.groupby.genericr$ Zpandas.core.groupby.groupbyr% r& r' r( Zpandas.core.groupby.grouperr) Zpandas.core.groupby.opsr* Zpandas.core.indexes.apir+ Z pandas.core.indexes.datetimesr, r- Zpandas.core.indexes.periodr. r/ Z pandas.core.indexes.timedeltasr0 r1 Zpandas.tseries.frequenciesr2 r3 Zpandas.tseries.offsetsr4 r5 r6 r7 r8 r9 r� r: r� r� rZ r� r� r� r� r� r� r� r� r� r� r� r� r� rG r� r r+ r* r2 r� r� rT rT rT rU �<module> s� $ { Yw k { L 2 I
| ver. 1.4 |
Github
|
.
| PHP 8.3.23 | Генерация страницы: 0.05 |
proxy
|
phpinfo
|
Настройка