Файловый менеджер - Редактировать - /home/digitalm/venv/lib/python3.7/site-packages/pandas/core/groupby/__pycache__/grouper.cpython-37.pyc
Назад
B �5�g�� � @ sf d Z ddlmZ ddlmZ ddlZddlZddlm Z m Z m Z ddl m Z ddlmZ ddlmZ dd lmZmZmZ ddlm mZ dd lmZmZ ddl m m Z dd l m Z dd l!m"Z" dd l#m$Z$m%Z% ddl&m'Z'm(Z(m)Z) ddl*m+Z+ ddl,m-Z- G dd� d�Z.e G dd� d��Z/d'ddddddddd�d d �Z0dd �d d �Z1d!d"�d#d$�Z2d%d&� Z3dS )(z] Provide user facing operators for doing the split part of the split-apply-combine paradigm. � )� annotations)�HashableN)� ArrayLike� FrameOrSeries�final)�InvalidIndexError)�cache_readonly)�sanitize_to_nanoseconds)�is_categorical_dtype� is_list_like� is_scalar)� Categorical�ExtensionArray)� DataFrame)�ops)�recode_for_groupby�recode_from_groupby)�CategoricalIndex�Index� MultiIndex)�Series)� pprint_thingc s� e Zd ZU dZded< ded< ded< ded< ded < d Zd ed < � fd d�Zd&dddd�dd�Zee dd�dd���Z d'ddd�d d �Z ed(ddd �d d ��Z ee d!d"� ��Z ed#d�d$d%��Z� ZS ))�Groupera� A Grouper allows the user to specify a groupby instruction for an object. This specification will select a column via the key parameter, or if the level and/or axis parameters are given, a level of the index of the target object. If `axis` and/or `level` are passed as keywords to both `Grouper` and `groupby`, the values passed to `Grouper` take precedence. Parameters ---------- key : str, defaults to None Groupby key, which selects the grouping column of the target. level : name/number, defaults to None The level for the target index. freq : str / frequency object, defaults to None This will groupby the specified frequency if the target selection (via key or level) is a datetime-like object. For full specification of available frequencies, please see `here <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`_. axis : str, int, defaults to 0 Number/name of the axis. sort : bool, default to False Whether to sort the resulting labels. closed : {'left' or 'right'} Closed end of interval. Only when `freq` parameter is passed. label : {'left' or 'right'} Interval boundary to use for labeling. Only when `freq` parameter is passed. convention : {'start', 'end', 'e', 's'} If grouper is PeriodIndex and `freq` parameter is passed. base : int, default 0 Only when `freq` parameter is passed. For frequencies that evenly subdivide 1 day, the "origin" of the aggregated intervals. For example, for '5min' frequency, base could range from 0 through 4. Defaults to 0. .. deprecated:: 1.1.0 The new arguments that you should use are 'offset' or 'origin'. loffset : str, DateOffset, timedelta object Only when `freq` parameter is passed. .. deprecated:: 1.1.0 loffset is only working for ``.resample(...)`` and not for Grouper (:issue:`28302`). However, loffset is also deprecated for ``.resample(...)`` See: :class:`DataFrame.resample` origin : {{'epoch', 'start', 'start_day', 'end', 'end_day'}}, Timestamp or str, 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 .. versionadded:: 1.1.0 - 'end': `origin` is the last value of the timeseries - 'end_day': `origin` is the ceiling midnight of the last day .. versionadded:: 1.3.0 offset : Timedelta or str, default is None An offset timedelta added to the origin. .. versionadded:: 1.1.0 dropna : bool, default True If True, and if group keys contain NA values, NA values together with row/column will be dropped. If False, NA values will also be treated as the key in groups. .. versionadded:: 1.2.0 Returns ------- A specification for a groupby instruction Examples -------- Syntactic sugar for ``df.groupby('A')`` >>> df = pd.DataFrame( ... { ... "Animal": ["Falcon", "Parrot", "Falcon", "Falcon", "Parrot"], ... "Speed": [100, 5, 200, 300, 15], ... } ... ) >>> df Animal Speed 0 Falcon 100 1 Parrot 5 2 Falcon 200 3 Falcon 300 4 Parrot 15 >>> df.groupby(pd.Grouper(key="Animal")).mean() Speed Animal Falcon 200.0 Parrot 10.0 Specify a resample operation on the column 'Publish date' >>> df = pd.DataFrame( ... { ... "Publish date": [ ... pd.Timestamp("2000-01-02"), ... pd.Timestamp("2000-01-02"), ... pd.Timestamp("2000-01-09"), ... pd.Timestamp("2000-01-16") ... ], ... "ID": [0, 1, 2, 3], ... "Price": [10, 20, 30, 40] ... } ... ) >>> df Publish date ID Price 0 2000-01-02 0 10 1 2000-01-02 1 20 2 2000-01-09 2 30 3 2000-01-16 3 40 >>> df.groupby(pd.Grouper(key="Publish date", freq="1W")).mean() ID Price Publish date 2000-01-02 0.5 15.0 2000-01-09 2.0 30.0 2000-01-16 3.0 40.0 If you want to adjust the start of the bins based on a fixed timestamp: >>> start, end = '2000-10-01 23:30:00', '2000-10-02 00:30:00' >>> rng = pd.date_range(start, end, freq='7min') >>> ts = pd.Series(np.arange(len(rng)) * 3, index=rng) >>> ts 2000-10-01 23:30:00 0 2000-10-01 23:37:00 3 2000-10-01 23:44:00 6 2000-10-01 23:51:00 9 2000-10-01 23:58:00 12 2000-10-02 00:05:00 15 2000-10-02 00:12:00 18 2000-10-02 00:19:00 21 2000-10-02 00:26:00 24 Freq: 7T, dtype: int64 >>> ts.groupby(pd.Grouper(freq='17min')).sum() 2000-10-01 23:14:00 0 2000-10-01 23:31:00 9 2000-10-01 23:48:00 21 2000-10-02 00:05:00 54 2000-10-02 00:22:00 24 Freq: 17T, dtype: int64 >>> ts.groupby(pd.Grouper(freq='17min', origin='epoch')).sum() 2000-10-01 23:18:00 0 2000-10-01 23:35:00 18 2000-10-01 23:52:00 27 2000-10-02 00:09:00 39 2000-10-02 00:26:00 24 Freq: 17T, dtype: int64 >>> ts.groupby(pd.Grouper(freq='17min', origin='2000-01-01')).sum() 2000-10-01 23:24:00 3 2000-10-01 23:41:00 15 2000-10-01 23:58:00 45 2000-10-02 00:15:00 45 Freq: 17T, dtype: int64 If you want to adjust the start of the bins with an `offset` Timedelta, the two following lines are equivalent: >>> ts.groupby(pd.Grouper(freq='17min', origin='start')).sum() 2000-10-01 23:30:00 9 2000-10-01 23:47:00 21 2000-10-02 00:04:00 54 2000-10-02 00:21:00 24 Freq: 17T, dtype: int64 >>> ts.groupby(pd.Grouper(freq='17min', offset='23h30min')).sum() 2000-10-01 23:30:00 9 2000-10-01 23:47:00 21 2000-10-02 00:04:00 54 2000-10-02 00:21:00 24 Freq: 17T, dtype: int64 To replace the use of the deprecated `base` argument, you can now use `offset`, in this example it is equivalent to have `base=2`: >>> ts.groupby(pd.Grouper(freq='17min', offset='2min')).sum() 2000-10-01 23:16:00 0 2000-10-01 23:33:00 9 2000-10-01 23:50:00 36 2000-10-02 00:07:00 39 2000-10-02 00:24:00 24 Freq: 17T, dtype: int64 �int�axis�bool�sort�dropnaz Index | None� _gpr_index�_grouper)�key�level�freqr r ztuple[str, ...]� _attributesc s6 |� d�d k r*ddlm} t|| d� |} t� �| �S )Nr" r )� TimeGrouper)�origin)�get�pandas.core.resampler$ �!_check_deprecated_resample_kwargs�super�__new__)�cls�args�kwargsr$ )� __class__� �Q/home/digitalm-up/venv/lib/python3.7/site-packages/pandas/core/groupby/grouper.pyr* s zGrouper.__new__Nr FT)r r r c C sR || _ || _|| _|| _|| _d | _d | _d | _d | _d | _ d | _ d | _ || _ d S )N) r r! r" r r �grouperr �obj�indexer�binnerr �_indexerr )�selfr r! r" r r r r/ r/ r0 �__init__ s zGrouper.__init__r )�returnc C s | j }|d krtd��|S )Nz1_set_grouper must be called before ax is accessed)r � ValueError)r6 �indexr/ r/ r0 �ax$ s z Grouper.axr )r2 �validatec C sH | � |� t| j| jg| j| j| j|| jd�\| _}| _| j | j| jfS )z� Parameters ---------- obj : Series or DataFrame validate : bool, default True if True, validate the grouper Returns ------- a tuple of binner, grouper, obj (possibly sorted) )r r! r r< r ) � _set_grouper� get_grouperr2 r r r! r r r1 r4 )r6 r2 r< �_r/ r/ r0 � _get_grouper, s zGrouper._get_grouper)r2 r c C s� |dk s t �| jdk r(| jdk r(td��| jdkrB| j| _| j| _| jdk r�| j}t| jdd�|kr�t |t �r�| jdk s|t �| jdk r�| j� � }| j� |�}|� |j �}q�| j� |j �}n*||jkr�td|� d���t|| |d�}nn|�| j�}| jdk �rT| j}t |t��r4|�|�}t|�|�|j| d�}n |d|jfk�rTtd|� d ���| j�sb|�r�|j�s�|jj d d d � }| _|� |�}|j || jd �}|| _|| _| jS )a% given an object and the specifications, setup the internal grouper for this particular specification Parameters ---------- obj : Series or DataFrame sort : bool, default False whether the resulting grouper should be sorted Nz2The Grouper cannot specify both a key and a level!�namezThe grouper name z is not found)rA r z The level z is not validZ mergesort�first)�kindZ na_position)r ) �AssertionErrorr r! r9 r r r3 r5 �getattr� isinstancer ZargsortZtaker: Z _info_axis�KeyErrorr � _get_axisr r Z_get_level_numberZ_get_level_values�namesrA r Z is_monotonic�arrayr2 ) r6 r2 r r Zreverse_indexerZ unsorted_axr; r! r3 r/ r/ r0 r= I sF zGrouper._set_grouperc C s | j jS )N)r1 �groups)r6 r/ r/ r0 rK � s zGrouper.groups�strc s8 � fdd�� j D �}d�|�}t� �j}|� d|� d�S )Nc 3 s4 | ],}t � |�d k r|� dtt � |��� �V qd S )N�=)rE �repr)�.0� attr_name)r6 r/ r0 � <genexpr>� s z#Grouper.__repr__.<locals>.<genexpr>z, �(�))r# �join�type�__name__)r6 Z attrs_list�attrs�cls_namer/ )r6 r0 �__repr__� s zGrouper.__repr__)NNNr FT)T)F)rV � __module__� __qualname__�__doc__�__annotations__r# r* r7 r �propertyr; r@ r= rK rY � __classcell__r/ r/ )r. r0 r 1 s. J Lr c @ s e Zd ZU dZdZded< dZded< ded< d ed < d ed < d4d dddddd�dd�Zdd�dd�Zdd� Z e dd�dd��Z e d d�d d ��Z e d d�d d!��Ze d"d#� �Ze d$d�d%d&��Ze d'd�d(d)��Ze d d�d*d+��Ze d d�d,d-��Ze d.d�d/d0��Ze d1d�d2d3��ZdS )5�GroupingaJ Holds the grouping information for a single key Parameters ---------- index : Index grouper : obj : DataFrame or Series name : Label level : observed : bool, default False If we are a Categorical, use the observed values in_axis : if the Grouping is a column in self.obj and hence among Groupby.exclusions list Returns ------- **Attributes**: * indices : dict of {group -> index_list} * codes : ndarray, group codes * group_index : unique groups * groups : dict of {group -> label_list} Nznp.ndarray | None�_codesz Index | None� _group_indexr �_passed_categoricalzCategorical | None� _all_grouperr �_indexTFzFrameOrSeries | None)r: r2 r �observed�in_axisr c C s� || _ || _t||�| _d | _|| _|| _|| _|| _|| _ || _ d| _ | j } | d k rx| j} |� | | �\| _| _| _�n&t| jt�r�| jj| jdd�\} } } | | _| �� }t| tj�r�|| _nt|| jjd�| _n�t| j�r�d| _ t| j||�\| _| _n�t| jtttt j f��s�t | jdd�dk�rL| j�p:t t | j��}t!d|� d���|�"| j�| _t#| jd ��r|t$| j�t$|�k�s�t%| j�}d |� �}d | _t&|��t| jt j ��r�t'| j�| _d S ) NF)r< )rA T�ndim� z Grouper for 'z' not 1-dimensional�__len__z9Grouper result violates len(labels) == len(data) result: )(r! � _orig_grouper�_convert_grouper�grouping_vectorrd re �_sortr2 � _observedrg �_dropnarc �_ilevelZ_get_grouper_for_levelra rb rF r r@ r Z BinGrouperr � result_indexrA r r r r �np�ndarrayrE rL rU r9 �map�hasattr�lenr rD r )r6 r: r1 r2 r! r rf rg r �ilevelZmapperr? Z newgrouperZnewobj�ng�tZgrper�errmsgr/ r/ r0 r7 � sT zGrouping.__init__rL )r8 c C s d| j � d�S )Nz Grouping(rS )rA )r6 r/ r/ r0 rY * s zGrouping.__repr__c C s t | j�S )N)�iter�indices)r6 r/ r/ r0 �__iter__- s zGrouping.__iter__r c C sb | j }|d k r| jj| S t| jttf�r2| jjS t| jt j �rJ| jj jS t| jt�r^| jjS d S )N) rq re rI rF rk r r rA rm r � BaseGrouperrr )r6 rx r/ r/ r0 rA 0 s z Grouping.namez int | Nonec C sL | j }|dkrdS t|t�sH| j}||jkr<td|� d���|j�|�S |S )zS If necessary, converted index level name to index level position. NzLevel z not in index)r! rF r re rI rD r: )r6 r! r: r/ r/ r0 rq B s zGrouping._ilevelr c C s t | j�S )N)rw � group_index)r6 r/ r/ r0 �ngroupsQ s zGrouping.ngroupsc C s( t | jtj�r| jjS t| j�}|�� S )N)rF rm r r r} r Z_reverse_indexer)r6 �valuesr/ r/ r0 r} U s zGrouping.indicesz np.ndarrayc C s | j d k r| j S | jd S )Nr )ra �_codes_and_uniques)r6 r/ r/ r0 �codes^ s zGrouping.codesr c C s | j d S )zz Analogous to result_index, but holding an ArrayLike to ensure we can can retain ExtensionDtypes. ri )r� )r6 r/ r/ r0 �group_arraylikef s zGrouping.group_arraylikec C s4 | j d k r.| j}t|t�s t�t| j | j|�S | jS )N)rd r� rF r rD r rn )r6 Z group_idxr/ r/ r0 rr n s zGrouping.result_indexc C s$ | j d k r| j S | j}t|| jd�S )N)rA )rb r� r rA )r6 �uniquesr/ r/ r0 r� w s zGrouping.group_indexz tuple[np.ndarray, ArrayLike]c C s� | j rr| j}|j}| jrHt�|j�}||dk }| js<|jrVt � |�}nt � t |��}t j|||jd�}|j|fS t| jtj�r�| jj}| jj}n(| js�d }nd}tj| j| j|d�\}}||fS )N���)r� � categories�ordered)r � na_sentinel)rc rm r� ro � algorithmsZunique1dr� rn r� rs r Zarangerw r � from_codesrF r r Z codes_infoZresult_arraylikerp Z factorize)r6 �catr� Zucodesr� r� r� r/ r/ r0 r� s* zGrouping._codes_and_uniqueszdict[Hashable, np.ndarray]c C s | j �t�| j| j��S )N)re �groupbyr r� r� r� )r6 r/ r/ r0 rK � s zGrouping.groups)NNNTFFT)rV rZ r[ r\ ra r] rb r7 rY r~ r rA rq r^ r� r} r� r� rr r� r� rK r/ r/ r/ r0 r` � s2 Y $r` TFr r r z:tuple[ops.BaseGrouper, frozenset[Hashable], FrameOrSeries])r2 r r rf �mutatedr< r r8 c sx � � |�} |dk r�t| t�rXt|�r8t|�dkr8|d }|dkr�t|�r�| �|�}d}n�t|�r�t|�} | dkrz|d }n| dkr�td��ntd��t|t�rʈ � |�j |kr�td|� d� � |�� ���n|dks�|dk r�td ��d}| }t|t ��r6|j � d d �\} } � |j dk�r"| t� � fS | t|j h�� fS nt|tj��rP|t� � fS t|t��sh|g} d }n|} t| �t| �k}td d � | D ��}tdd � | D ��}tdd � | D ��}|�s0|�s0|�s0|�r0|dk�r0t� t��r�t� fdd �| D ��}n&t� t��st�t� fdd �| D ��}|�s0t�| �g} t|ttf��r^|dk�rXdgt|� } |}n|gt| � }g }t� }dd�� fdd� }dd�� fdd� }�xdt| |�D �]T\}}||��r�d}|� |j � n�||��r^|� k�r2|�r�� j ||d� d|� | }}}|j dk�r&td|� d���|� |� n*� j ||d��rTd |d }}}nt |��n.t|t ��r�|j dk �r�|� |j � d }nd }t!|��r�t|�� j"| k�r�td t|�� d � j"| � d ���t|t#��s�t#| |� |||||d �n|}|�$|� �q�W t|�dk�r$t� ��r$td��n2t|�dk�rV|�$t#t%g d d!�t&j'g t&j(d!��� tj| ||||d"�} | t|�� fS )#a� Create and return a BaseGrouper, which is an internal mapping of how to create the grouper indexers. This may be composed of multiple Grouping objects, indicating multiple groupers Groupers are ultimately index mappings. They can originate as: index mappings, keys to columns, functions, or Groupers Groupers enable local references to axis,level,sort, while the passed in axis, level, and sort are 'global'. This routine tries to figure out what the passing in references are and then creates a Grouping for each one, combined into a BaseGrouper. If observed & we have a categorical grouper, only show the observed values. If validate, then check for key/level overlaps. Nri r zNo group keys passed!z*multiple levels only valid with MultiIndexz level name z is not the name of the r� z2level > 0 or level < -1 only valid with MultiIndexF)r< c s s | ]}t |�pt|t�V qd S )N)�callablerF �dict)rO �gr/ r/ r0 rQ s z get_grouper.<locals>.<genexpr>c s s | ]}t |t�V qd S )N)rF r )rO r� r/ r/ r0 rQ s c s s$ | ] }t |tttttjf�V qd S )N)rF �list�tupler r rs rt )rO r� r/ r/ r0 rQ s c 3 s$ | ] }|� j kp|� jjkV qd S )N)�columnsr: rI )rO r� )r2 r/ r0 rQ s c 3 s | ]}|� j jkV qd S )N)r: rI )rO r� )r2 r/ r0 rQ " s r )r8 c s@ t | �s<� jd }y|�| � W n tttfk r: dS X dS )Nr� FT)�_is_label_likeZaxesZget_locrG � TypeErrorr )r �items)r2 r/ r0 � is_in_axis2 s z get_grouper.<locals>.is_in_axisc s< t | d�sdS y| � | j kS tttfk r6 dS X d S )NrA F)rv rA rG � IndexErrorr )�gpr)r2 r/ r0 � is_in_obj? s z get_grouper.<locals>.is_in_objT)r z Grouper for 'z' not 1-dimensionalzLength of grouper (z ) and axis (z) must be same length)r2 r! r rf rg r r )Zdtype)r r� r ))rH rF r r rw r Zget_level_valuesr9 rL rA Z_get_axis_namer r@ r � frozensetr r r� �anyr �allr rD �com�asarray_tuplesafer� �set�zip�addZ _check_label_or_level_ambiguityrh Z_is_level_referencerG r �shaper` �appendr rs rJ Zintp) r2 r r r! r rf r� r< r Z group_axisZnlevelsr4 r1 �keysZmatch_axis_lengthZ any_callableZ any_groupersZ any_arraylikeZall_in_columns_indexZlevelsZ groupingsZ exclusionsr� r� r� rg rA Zpingr/ )r2 r0 r> � s� ! $ $r> )r8 c C s t | ttf�p | d k o t| �S )N)rF rL r� r )�valr/ r/ r0 r� � s r� r )r c C s� t |t�r|jS t |t�r:|j�| �r,|jS |�| �jS n^t |t�rJ|jS t |t t tt t j f�r�t|�t| �krxtd��t |t t f�r�t�|�}|S |S d S )Nz$Grouper and axis must be same length)rF r� r& r r: �equalsZ_valuesZreindexr r� r� r rs rt rw r9 r� r� )r r1 r/ r/ r0 rl � s rl c C sd ddl m} ||krdndd }| �dd�dk r@tjdt|d � | �d d�dk r`tjd t|d � dS ) a Check for use of deprecated parameters in ``resample`` and related functions. Raises the appropriate warnings if these parameters are detected. Only sets an approximate ``stacklevel`` for the warnings (see #37603, #36629). Parameters ---------- kwargs : dict Dictionary of keyword arguments to check for deprecated parameters. origin : object From where this function is being called; either Grouper or TimeGrouper. Used to determine an approximate stacklevel. r )r$ � � ri �baseNz�'base' in .resample() and in Grouper() is deprecated. The new arguments that you should use are 'offset' or 'origin'. >>> df.resample(freq="3s", base=2) becomes: >>> df.resample(freq="3s", offset="2s") )� stacklevelZloffseta 'loffset' in .resample() and in Grouper() is deprecated. >>> df.resample(freq="3s", loffset="8H") becomes: >>> from pandas.tseries.frequencies import to_offset >>> df = df.resample(freq="3s").mean() >>> df.index = df.index.to_timestamp() + to_offset("8H") )r' r$ r& �warnings�warn� FutureWarning)r- r% r$ r� r/ r/ r0 r( � s r( )Nr NTFFTT)4r\ � __future__r �typingr r� �numpyrs Zpandas._typingr r r Z pandas.errorsr Zpandas.util._decoratorsr Zpandas.core.dtypes.castr Zpandas.core.dtypes.commonr r r Zpandas.core.algorithms�corer� Zpandas.core.arraysr r Zpandas.core.common�commonr� Zpandas.core.framer Zpandas.core.groupbyr Z pandas.core.groupby.categoricalr r Zpandas.core.indexes.apir r r Zpandas.core.seriesr Zpandas.io.formats.printingr r r` r> r� rl r( r/ r/ r/ r0 �<module> sH y [
| ver. 1.4 |
Github
|
.
| PHP 8.3.23 | Генерация страницы: 0.05 |
proxy
|
phpinfo
|
Настройка