Файловый менеджер - Редактировать - /home/digitalm/venv/lib/python3.7/site-packages/pandas/core/__pycache__/algorithms.cpython-37.pyc
Назад
B �5�g�� � @ s U d Z ddlmZ ddlZddlmZ ddlmZmZm Z ddl m Z ddl Z ddlmZmZmZmZ ddlmZmZmZmZmZmZ dd lm Z dd l m Z m Z m Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4 dd l5m6Z6 dd l7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z> ddl?m@Z@mAZA ddlBmCZC ddlDmEZFmGZGmHZH ddlImJZJ e�r�ddlmKZK ddlLmMZMmNZNmOZOmPZP ddlQmRZRmSZS i ZTdeUd< ddd�dd�ZVdd d dd �d d �ZWdd!�d"d#�ZXejYejZej[ej\ej]ej^ej_ej`ejaejbejcejdejeejfd$�Zgd%d&�d'd(�Zhdd%d�d)d*�Zidd&�d+d,�Zjd%d-d�d.d/�Zkd0d1� ZlelZmd d d%d2�d3d4�Znd�d%d6d7d8d9d:�d;d<�Zoe ed=�ed>�ed?�d@�d�dBd7d7dCdD�dEdF��Zpd�dBdBdBdBdHdI�dJdK�ZqdBdL�dMdN�Zrd�ddPd%dQ�dRdS�Zsd�dBdHdT�dUdV�Ztd�dd6d-d-dBdBd%dY�dZd[�Zud�d%d8d8d%d\�d]d^�Zvd�d`da�ZwG dbdc� dc�ZxG ddde� deex�ZyG dfdg� dgex�Zzd�d%d6dBdh�didj�Z{d�d%d!�dldm�Z|dndodpdqdrdshZ}d�d6d6d6du�dvdw�Z~d�d6dBdBdxdy�dzd{�Zd%d!�d|d}�Z�d%d%d�d~d�Z�dddd��d�d��Z�dS )�zl Generic data algorithms. This module is experimental at the moment and not intended for public consumption � )� annotationsN)�dedent)� TYPE_CHECKING�Union�cast)�warn)�algos� hashtable�iNaT�lib)� AnyArrayLike� ArrayLike�DtypeObj�FrameOrSeriesUnion�Scalar�final)�doc)�'construct_1d_object_array_from_listlike�infer_dtype_from_array�sanitize_to_nanoseconds)�ensure_float64� ensure_object�ensure_platform_int� is_array_like� is_bool_dtype�is_categorical_dtype�is_complex_dtype�is_datetime64_dtype�is_extension_array_dtype�is_float_dtype� is_integer�is_integer_dtype� is_list_like�is_numeric_dtype�is_object_dtype� is_scalar�is_timedelta64_dtype�needs_i8_conversion� pandas_dtype)� PandasDtype)�ABCDatetimeArray�ABCExtensionArray�ABCIndex� ABCMultiIndex� ABCRangeIndex� ABCSeries�ABCTimedeltaArray)�isna�na_value_for_dtype)�take_nd)�array� ensure_wrapped_if_datetimelike� extract_array)�validate_indices)�Literal)� Categorical� DataFrame�Index�Series)� DatetimeArray�TimedeltaArrayzdict[str, str]� _shared_docsr ztuple[np.ndarray, DtypeObj])�values�returnc C s� t | t�st| dd�} t| j�r8tt�| ��t�d�fS t| j�r�t | tj �rdt�| �� d�| jfS yt�| �j ddd�| jfS t t fk r� t�| �| jfS X n�t| j�r�t�| �| jfS t| j�� r�| jjdkr�t| �| jfS t�| �| jfS t| j��r | | jfS t| j��rNt | tj ��r.t| �} | � d�}ttj |�}|| jfS t| j��rztd | �} | j} td �}| |fS tj| td �} t| �t�d�fS ) a� routine to ensure that our data is of the correct input dtype for lower-level routines This will coerce: - ints -> int64 - uint -> uint64 - bool -> uint64 (TODO this should be uint8) - datetimelike -> i8 - datetime64tz -> i8 (in local tz) - categorical -> codes Parameters ---------- values : array-like Returns ------- values : ndarray pandas_dtype : np.dtype or ExtensionDtype T)� extract_numpy�object�uint8F)�copy)� � � �i8r9 �category)�dtype)� isinstancer- r6 r$ rK r �np�asarrayr �ndarray�view�astype� TypeError� ValueErrorr! r �itemsizer r r' r r r �codesr( rC )r@ ZnpvaluesrK � rV �L/home/digitalm-up/venv/lib/python3.7/site-packages/pandas/core/algorithms.py� _ensure_datag s@ rX r r )r@ rK �originalrA c C s� t | t�r| j|kr| S t |tj�sP|�� }t | |�rD| j|krD| S |�| �} nlt|�r�| j|dd�} t |t�r�| jt dd�} n<|dk r�t |�r�t�d�}nt |�r�t�d�}| j|dd�} | S )z� reverse of _ensure_data Parameters ---------- values : np.ndarray or ExtensionArray dtype : np.dtype or ExtensionDtype original : AnyArrayLike Returns ------- ExtensionArray or np.ndarray F)rE Nzdatetime64[ns]ztimedelta64[ns]) rL r+ rK rM Zconstruct_array_type�_from_sequencer rQ r, rC r r& )r@ rK rY �clsrV rV rW �_reconstruct_data� s$ r\ )rA c C sH t | �sDtj| dd�}|dkr:t| t�r0t| �} t| �} n t�| �} | S )z5 ensure that we are arraylike if not already F)�skipna)�mixed�stringz mixed-integer) r r � infer_dtyperL �tuple�listr rM rN )r@ �inferredrV rV rW �_ensure_arraylike� s rd )Z complex128Z complex64�float64�float32Zuint64Zuint32Zuint16rD �int64�int32�int16�int8r_ rC z np.ndarray)r@ c C s$ t | �\} }t| �}t| }|| fS )z� Parameters ---------- values : np.ndarray Returns ------- htable : HashTable subclass values : ndarray )rX �_check_object_for_strings� _hashtables)r@ �_�ndtype�htablerV rV rW �_get_hashtable_algo s rp c C sL t | �rtd| ��� } t| �\} }| jjdkrH| jjd }| j|dd�} | S )Nr9 )�i�u�f�8F)rE )r r Z_values_for_rankrX rK �kindrQ )r@ rm rK rV rV rW �_get_values_for_rank s rv c C s( t | �} t| �}t�|td �}|| fS )NrC )rv rk rl �get)r@ rn ro rV rV rW � get_data_algo# s rx �strc C s* | j j}|dkr&tj| dd�dkr&d}|S )z� Check if we can use string hashtable instead of object hashtable. Parameters ---------- values : ndarray Returns ------- str rC F)r] )r_ r_ )rK �namer r` )r@ rn rV rV rW rk , s rk c C sP t | �} t| �r| �� S | }t| �\}} |t| ��}|�| �}t||j|�}|S )a� Hash table-based unique. Uniques are returned in order of appearance. This does NOT sort. Significantly faster than numpy.unique for long enough sequences. Includes NA values. Parameters ---------- values : 1d array-like Returns ------- numpy.ndarray or ExtensionArray The return can be: * Index : when the input is an Index * Categorical : when the input is a Categorical dtype * ndarray : when the input is a Series/ndarray Return numpy.ndarray or ExtensionArray. See Also -------- Index.unique : Return unique values from an Index. Series.unique : Return unique values of Series object. Examples -------- >>> pd.unique(pd.Series([2, 1, 3, 3])) array([2, 1, 3]) >>> pd.unique(pd.Series([2] + [1] * 5)) array([2, 1]) >>> pd.unique(pd.Series([pd.Timestamp("20160101"), pd.Timestamp("20160101")])) array(['2016-01-01T00:00:00.000000000'], dtype='datetime64[ns]') >>> pd.unique( ... pd.Series( ... [ ... pd.Timestamp("20160101", tz="US/Eastern"), ... pd.Timestamp("20160101", tz="US/Eastern"), ... ] ... ) ... ) <DatetimeArray> ['2016-01-01 00:00:00-05:00'] Length: 1, dtype: datetime64[ns, US/Eastern] >>> pd.unique( ... pd.Index( ... [ ... pd.Timestamp("20160101", tz="US/Eastern"), ... pd.Timestamp("20160101", tz="US/Eastern"), ... ] ... ) ... ) DatetimeIndex(['2016-01-01 00:00:00-05:00'], dtype='datetime64[ns, US/Eastern]', freq=None) >>> pd.unique(list("baabc")) array(['b', 'a', 'c'], dtype=object) An unordered Categorical will return categories in the order of appearance. >>> pd.unique(pd.Series(pd.Categorical(list("baabc")))) ['b', 'a', 'c'] Categories (3, object): ['a', 'b', 'c'] >>> pd.unique(pd.Series(pd.Categorical(list("baabc"), categories=list("abc")))) ['b', 'a', 'c'] Categories (3, object): ['a', 'b', 'c'] An ordered Categorical preserves the category ordering. >>> pd.unique( ... pd.Series( ... pd.Categorical(list("baabc"), categories=list("abc"), ordered=True) ... ) ... ) ['b', 'a', 'c'] Categories (3, object): ['a' < 'b' < 'c'] An array of tuples >>> pd.unique([("a", "b"), ("b", "a"), ("a", "c"), ("b", "a")]) array([('a', 'b'), ('b', 'a'), ('a', 'c')], dtype=object) )rd r �uniquerp �lenr\ rK )r@ rY ro �table�uniquesrV rV rW r{ H s ] r{ )�compsr@ rA c C s� t | �s tdt| �j� d���t |�s<tdt|�j� d���t|ttttj f�s^t t |��}n$t|t �rtt� |�}nt|ddd�}t | �} t| dd�} t| tj �s�| �|�S t| j�r�t| ��|�S t|j�r�t| j�s�tj| jtd�S t|j��rt| |�t��S t|j��r&tt�| �t�|��S t| �dk�rlt|�dk�rlt| ��slt |�� � �rdd d � }ntj }n6t� |j| jgg �}|j|d d �}| j|d d �} t j!}|| |�S ) z� Compute the isin boolean array. Parameters ---------- comps : array-like values : array-like Returns ------- ndarray[bool] Same length as `comps`. zIonly list-like objects are allowed to be passed to isin(), you passed a [�]T)rB Z extract_range)rB )rK i@B � c S s t �t �| |�t �| ��S )N)rM � logical_or�in1d�isnan)�c�vrV rV rW rs � s zisin.<locals>.fF)rE )"r" rR �type�__name__rL r, r/ r+ rM rO rd rb r- r4 r6 �isinr' rK �pd_arrayr$ �zeros�shape�boolrQ rC r rN r| r1 �anyr� Zfind_common_typero Zismember)r r@ rs �commonrV rV rW r� � sB & r� ����intz int | Noneznp.ndarray | Nonez tuple[np.ndarray, np.ndarray])r@ � na_sentinel� size_hint�maskrA c C sB t | �\}} ||pt| ��}|j| |||d�\}}t|�}||fS )a[ Factorize an array-like to codes and uniques. This doesn't do any coercion of types or unboxing before factorization. Parameters ---------- values : ndarray na_sentinel : int, default -1 size_hint : int, optional Passed through to the hashtable's 'get_labels' method na_value : object, optional A value in `values` to consider missing. Note: only use this parameter when you know that you don't have any values pandas would consider missing in the array (NaN for float data, iNaT for datetimes, etc.). mask : ndarray[bool], optional If not None, the mask is used as indicator for missing values (True = missing, False = valid) instead of `na_value` or condition "val != val". Returns ------- codes : ndarray[np.intp] uniques : ndarray )r� �na_valuer� )rx r| � factorizer ) r@ r� r� r� r� � hash_klassr} r~ rU rV rV rW �factorize_array s ! r� z� values : sequence A 1-D sequence. Sequences that aren't pandas objects are coerced to ndarrays before factorization. zt sort : bool, default False Sort `uniques` and shuffle `codes` to maintain the relationship. zG size_hint : int, optional Hint to the hashtable sizer. )r@ �sortr� Fr� z%tuple[np.ndarray, np.ndarray | Index])r� r� r� rA c C s t | t�r| j|d�S t| �} | }t | t�s8t| dd�} d}|dkrLd}d}t | ttf�r�| jdk r�| j|d�\}}t |t �r�|j |dd�}n t |t �r�dd l m } ||�}||fS t | jtj�s�| j|d �\}}|j} n6t| �\} } |jjd kr�t} nd} t| ||| d �\}}|�r:t|�dk�r:t|||ddd �\}}||k} |�s�| �� �r�t|jdd�} t�|| g�}t�| t|�d |�}t|| |�}t |t ��r�|jjd k�r�t |tj��r�t d|j �|_ t |j �j ||jd�}|j |dd�}n t |t ��r dd l m } ||�}||fS )a Encode the object as an enumerated type or categorical variable. This method is useful for obtaining a numeric representation of an array when all that matters is identifying distinct values. `factorize` is available as both a top-level function :func:`pandas.factorize`, and as a method :meth:`Series.factorize` and :meth:`Index.factorize`. Parameters ---------- {values}{sort} na_sentinel : int or None, default -1 Value to mark "not found". If None, will not drop the NaN from the uniques of the values. .. versionchanged:: 1.1.2 {size_hint} Returns ------- codes : ndarray An integer ndarray that's an indexer into `uniques`. ``uniques.take(codes)`` will have the same values as `values`. uniques : ndarray, Index, or Categorical The unique valid values. When `values` is Categorical, `uniques` is a Categorical. When `values` is some other pandas object, an `Index` is returned. Otherwise, a 1-D ndarray is returned. .. note :: Even if there's a missing value in `values`, `uniques` will *not* contain an entry for it. See Also -------- cut : Discretize continuous-valued array. unique : Find the unique value in an array. Examples -------- These examples all show factorize as a top-level method like ``pd.factorize(values)``. The results are identical for methods like :meth:`Series.factorize`. >>> codes, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b']) >>> codes array([0, 0, 1, 2, 0]...) >>> uniques array(['b', 'a', 'c'], dtype=object) With ``sort=True``, the `uniques` will be sorted, and `codes` will be shuffled so that the relationship is the maintained. >>> codes, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'], sort=True) >>> codes array([1, 1, 0, 2, 1]...) >>> uniques array(['a', 'b', 'c'], dtype=object) Missing values are indicated in `codes` with `na_sentinel` (``-1`` by default). Note that missing values are never included in `uniques`. >>> codes, uniques = pd.factorize(['b', None, 'a', 'c', 'b']) >>> codes array([ 0, -1, 1, 2, 0]...) >>> uniques array(['b', 'a', 'c'], dtype=object) Thus far, we've only factorized lists (which are internally coerced to NumPy arrays). When factorizing pandas objects, the type of `uniques` will differ. For Categoricals, a `Categorical` is returned. >>> cat = pd.Categorical(['a', 'a', 'c'], categories=['a', 'b', 'c']) >>> codes, uniques = pd.factorize(cat) >>> codes array([0, 0, 1]...) >>> uniques ['a', 'c'] Categories (3, object): ['a', 'b', 'c'] Notice that ``'b'`` is in ``uniques.categories``, despite not being present in ``cat.values``. For all other pandas objects, an Index of the appropriate type is returned. >>> cat = pd.Series(['a', 'a', 'c']) >>> codes, uniques = pd.factorize(cat) >>> codes array([0, 0, 1]...) >>> uniques Index(['a', 'c'], dtype='object') If NaN is in the values, and we want to include NaN in the uniques of the values, it can be achieved by setting ``na_sentinel=None``. >>> values = np.array([1, 2, 1, np.nan]) >>> codes, uniques = pd.factorize(values) # default: na_sentinel=-1 >>> codes array([ 0, 1, 0, -1]) >>> uniques array([1., 2.]) >>> codes, uniques = pd.factorize(values, na_sentinel=None) >>> codes array([0, 1, 0, 2]) >>> uniques array([ 1., 2., nan]) )r� T)rB Nr� F)rz r )r; )r� )�m�M)r� r� r� )r� � assume_unique�verify)�compat� z$Union[DatetimeArray, TimedeltaArray])rK ) rL r. r� rd r- r6 r* r0 �freqr, Z _shallow_copyr/ �pandasr; rK rM rX ru r r� r| � safe_sortr� r2 �append�wherer\ rO r �_datar� Z _simple_new) r@ r� r� r� rY �dropnarU r~ r; rK r� Z code_is_narV rV rW r� ; s` r� Tr< )r� � ascending� normalizer� rA c C sB ddl m} t| dd�}|dk r�ddlm} || �} y|| |dd�} W n, tk rr } ztd�| �W dd} ~ X Y nX | j|d �} | | j�� } | j� d �| _| � � } |r�| j dk� � r�| j dd� } t�t| �g�} nDt| �r�|| �j j|d �} || _| j } n t| |�\} } || | |d �} |�r,| j|d �} |�r>| | �� } | S ) aK Compute a histogram of the counts of non-null values. Parameters ---------- values : ndarray (1-d) sort : bool, default True Sort by values ascending : bool, default False Sort in ascending order normalize: bool, default False If True then compute a relative histogram bins : integer, optional Rather than count values, group them into half-open bins, convenience for pd.cut, only works with numeric data dropna : bool, default True Don't include counts of NaN Returns ------- Series r )r< rz N)�cutT)Zinclude_lowestz+bins argument only works with numeric data.)r� �interval)�indexrz )r� )Zpandas.core.seriesr< �getattrZpandas.core.reshape.tiler� rR � value_countsr� ZnotnarQ Z sort_index�_values�all�ilocrM r4 r| r rz �value_counts_arraylike� sort_values�sum)r@ r� r� r� Zbinsr� r< rz r� �ii�err�result�counts�keysrV rV rW r� s6 r� )r� c C sf t | �} | }t| �\} }t�| |�\}}t|j�rP|rP|tk}|| || }}t||j|�}||fS )z� Parameters ---------- values : arraylike dropna : bool Returns ------- uniques : np.ndarray or ExtensionArray counts : np.ndarray )rd rX ro Z value_countr' rK r r\ )r@ r� rY rm r� r� ZmskZres_keysrV rV rW r� l s r� �firstz!Literal[('first', 'last', False)])r@ �keeprA c C s t | �\} }tj| |d�S )a Return boolean ndarray denoting duplicate values. Parameters ---------- values : ndarray-like Array over which to check for duplicate values. keep : {'first', 'last', False}, default 'first' - ``first`` : Mark duplicates as ``True`` except for the first occurrence. - ``last`` : Mark duplicates as ``True`` except for the last occurrence. - False : Mark all duplicates as ``True``. Returns ------- duplicated : ndarray[bool] )r� )rX ro � duplicated)r@ r� rm rV rV rW r� � s r� )r� rA c C s ddl m} ddlm m m} t| �} | }t| �rft| |�rZ|| j j |d�| j d�S | j |d�S |r�t | j �r�| �� }| | } t| �\} }tj | |d�}yt�|�}W n0 tk r� } ztd|� �� W dd}~X Y nX t||j |�} || |�t| ��d�S )a Returns the mode(s) of an array. Parameters ---------- values : array-like Array over which to check for duplicate values. dropna : bool, default True Don't consider counts of NaN/NaT. Returns ------- mode : Series r )r< N)r� )rz zUnable to sort modes: )r� )r� r< Zpandas.core.indexes.base�coreZindexes�baserd r rL r� �moderz r' rK ZisnullrX ro rM r� rR r r\ Z default_indexr| ) r@ r� r< ZibaserY r� rm Znpresultr� r� rV rV rW r� � s& r� �averager� )r@ �axis�method� na_optionr� �pctrA c C sv t | j�}t| �} | jdkrFtj| tjt| �tj d�|||||d�}n,| jdkrjtj | ||||||d�}nt d��|S )a� Rank the values along a given axis. Parameters ---------- values : array-like Array whose values will be ranked. The number of dimensions in this array must not exceed 2. axis : int, default 0 Axis over which to perform rankings. method : {'average', 'min', 'max', 'first', 'dense'}, default 'average' The method by which tiebreaks are broken during the ranking. na_option : {'keep', 'top'}, default 'keep' The method by which NaNs are placed in the ranking. - ``keep``: rank each NaN value with a NaN ranking - ``top``: replace each NaN with either +/- inf so that they there are ranked at the top ascending : bool, default True Whether or not the elements should be ranked in ascending order. pct : bool, default False Whether or not to the display the returned rankings in integer form (e.g. 1, 2, 3) or in percentile form (e.g. 0.333..., 0.666..., 1). r� )rK )�labels�is_datetimelike� ties_methodr� r� r� rF )r� r� r� r� r� r� z&Array with ndim > 2 are not supported.) r' rK rv �ndimr Zrank_1drM r� r| �intpZrank_2drR )r@ r� r� r� r� r� r� ZranksrV rV rW �rank� s, r� )�arr�arr_mask�b_maskrA c C s: t �|| j�}|dk r&t �|| j�}nd}|dk rJ|dk rJt �||B �}nB|dk r^t �|�}n.|dk rrt �|�}nt j| jtd�}|�d� tj}t }|dk} |dk } | � � s�|| | k|@ � � } n`| � � s�|| | k |@ � � } nB||| | | k || @ � � �p"||| | | k|| @ � � } | �r2t d��| | S )a� Perform array addition that checks for underflow and overflow. Performs the addition of an int64 array and an int64 integer (or array) but checks that they do not result in overflow first. For elements that are indicated to be NaN, whether or not there is overflow for that element is automatically ignored. Parameters ---------- arr : array addend. b : array or scalar addend. arr_mask : np.ndarray[bool] or None, default None array indicating which elements to exclude from checking b_mask : np.ndarray[bool] or None, default None array or scalar indicating which element(s) to exclude from checking Returns ------- sum : An array for elements x + b for each element x in arr if b is a scalar or an array for elements x + y for each element pair (x, y) in (arr, b). Raises ------ OverflowError if any x + y exceeds the maximum or minimum int64 value. N)rK Tr zOverflow in int64 addition) rM Z broadcast_tor� Z logical_not�emptyr� �fillr �i8maxr r� � OverflowError) r� �br� r� �b2Zb2_maskZnot_nanr� Zi8minZmask1Zmask2Zto_raiserV rV rW �checked_add_with_arr s2 # " r� �fractionc s� t �| �} t| �}| | } t �| ��dd� ����fdd�� t|�rN� |�S t �|t j�}� fdd�|D �}t j|t jd�}|S dS ) a� Compute sample quantile or quantiles of the input array. For example, q=0.5 computes the median. The `interpolation_method` parameter supports three values, namely `fraction` (default), `lower` and `higher`. Interpolation is done only, if the desired quantile lies between two data points `i` and `j`. For `fraction`, the result is an interpolated value between `i` and `j`; for `lower`, the result is `i`, for `higher` the result is `j`. Parameters ---------- x : ndarray Values from which to extract score. q : scalar or array Percentile at which to extract score. interpolation_method : {'fraction', 'lower', 'higher'}, optional This optional parameter specifies the interpolation method to use, when the desired quantile lies between two data points `i` and `j`: - fraction: `i + (j - i)*fraction`, where `fraction` is the fractional part of the index surrounded by `i` and `j`. -lower: `i`. - higher: `j`. Returns ------- score : float Score at percentile. Examples -------- >>> from scipy import stats >>> a = np.arange(100) >>> stats.scoreatpercentile(a, 50) 49.5 c S s | || | S )z| Returns the point at the given fraction between a and b, where 'fraction' must be between 0 and 1. rV )�ar� r� rV rV rW � _interpolate� s z quantile.<locals>._interpolatec s� t ��dkrtjS | t ��d }|d dkr<�t|� }nf�dkrj� �t|� �t|�d |d �}n8�dkr��t�|� }n �dkr��t�|� }ntd��|S )Nr r� r� �lowerZhigherzAinterpolation_method can only be 'fraction' , 'lower' or 'higher')r| rM �nanr� �floor�ceilrS )�at�idxZscore)r� �interpolation_methodr@ rV rW � _get_score� s &z quantile.<locals>._get_scorec s g | ] }� |��qS rV rV )�.0�x)r� rV rW � <listcomp>� s z quantile.<locals>.<listcomp>)rK N)rM rN r1 r� r% re r4 )r� �qr� r� r� rV )r� r� r� r@ rW �quantile\ s ' r� c @ s\ e Zd Zddd�dd�Zddd�dd �Zed d � �Zed d � �Zeeddd�dd���Z dS )�SelectNr� ry )�nr� c C s( || _ || _|| _| jdkr$td��d S )N)r� �lastr� z,keep must be either "first", "last" or "all")�objr� r� rS )�selfr� r� r� rV rV rW �__init__� s zSelectN.__init__r )r� rA c C s t �d S )N)�NotImplementedError)r� r� rV rV rW �compute� s zSelectN.computec C s | � d�S )N�nlargest)r� )r� rV rV rW r� � s zSelectN.nlargestc C s | � d�S )N� nsmallest)r� )r� rV rV rW r� � s zSelectN.nsmallestr r� )rK rA c C s t | �rt| � pt| �S )zg Helper function to determine if dtype is valid for nsmallest/nlargest methods )r# r r' )rK rV rV rW �is_valid_dtype_n_method� s z SelectN.is_valid_dtype_n_methodN) r� � __module__� __qualname__r� r� r r� r� � staticmethodr� rV rV rV rW r� � s r� c @ s e Zd ZdZddd�dd�ZdS )� SelectNSeriesz� Implement n largest/smallest for Series Parameters ---------- obj : Series n : int keep : {'first', 'last'}, default 'first' Returns ------- nordered : Series ry r< )r� rA c C s� | j }| jj}| �|�s,td|� d|� ���|dkr>| jg S | j�� }t|j�r�ddlm} |j }t ||�r�t |�|j |j |jd�}t | �|| j | jd��|�}|�|j�S |t| j�kr�|dk} |j| d��|�S t|j�\}} |d k�r | }t| ��r|d 8 }nt| ��r d | }| jd k�r6|d d d � }t|�} t|| �}t�|j d d�|d �} t � || k�\} | || j dd� }| jdk�r�|d |� }| jd k�r�| d | }|j | S )NzCannot use method 'z ' with dtype r )�BaseMaskedArray)r� rz )r� r� r� )r� r� r� r� r� �C)�order� mergesort)ru r� )!r� r� rK r� rR r� r �pandas.core.arraysr� r� rL r� r� r� rz r� r� rQ r| r� �headrX r@ r! r �minr Z kth_smallestrE rM Znonzero�argsortr� )r� r� r� rK Zdroppedr� r� Zserr� r� Z new_dtypeZnarrZkth_val�nsZindsrV rV rW r� � sH zSelectNSeries.computeN)r� r� r� �__doc__r� rV rV rV rW r� � s r� c s8 e Zd ZdZddd�� fdd� Zddd�d d �Z� ZS ) � SelectNFramez� Implement n largest/smallest for DataFrame Parameters ---------- obj : DataFrame n : int keep : {'first', 'last'}, default 'first' columns : list or str Returns ------- nordered : DataFrame r� ry )r� r� c s: t � �|||� t|�r"t|t�r(|g}t|�}|| _d S )N)�superr� r" rL ra rb �columns)r� r� r� r� r� )� __class__rV rW r� 5 s zSelectNFrame.__init__r: )r� rA c s� ddl m} | j}| j}| j}xD|D ]<}|| j}| �|�s$tdt|�� d|� dt� �� d���q$W � fdd�}|j } |j d d � } }|} |g �} x�t |�D ]�\} }| | }t |�d | k}t |� �| |r�| jnd d �}|s�t |�| kr�|| |j �} P |||j d k}|| }|| }|| |j �} | j|j } |t | � } q�W |�| �}| �| �|_ t |�d k�rj|S � dk}|j||dd�S )Nr )� Int64IndexzColumn z has dtype z, cannot use method z with this dtypec s � dkr| � |�S |� | �S dS )z{ Helper function to concat `current_indexer` and `other_indexer` depending on `method` r� N)r� )Zcurrent_indexerZ other_indexer)r� rV rW � get_indexerL s z)SelectNFrame.compute.<locals>.get_indexerT)Zdropr� r� )r� r� r� r� )r� ru )r� r r� r� r� rK r� rR �reprr� Z reset_index� enumerater| r� r� �loc�taker� )r� r� r r� �framer� �columnrK r Zoriginal_indexZ cur_frameZcur_n�indexerrq ZseriesZis_last_columnr@ Z border_valueZ unsafe_valuesZ safe_valuesr� rV )r� rW r� < sD & zSelectNFrame.compute)r� r� r� r� r� r� � __classcell__rV rV )r rW r� % s r� )�indicesr� � allow_fillc C s\ t | �st�| �} tj|tjd�}|rJt|| j| � t| ||d|d�}n| j||d�}|S )av Take elements from an array. Parameters ---------- arr : sequence Non array-likes (sequences without a dtype) are coerced to an ndarray. indices : sequence of integers Indices to be taken. axis : int, default 0 The axis over which to select values. allow_fill : bool, default False How to handle negative values in `indices`. * False: negative values in `indices` indicate positional indices from the right (the default). This is similar to :func:`numpy.take`. * True: negative values in `indices` indicate missing values. These values are set to `fill_value`. Any other negative values raise a ``ValueError``. fill_value : any, optional Fill value to use for NA-indices when `allow_fill` is True. This may be ``None``, in which case the default NA value for the type (``self.dtype.na_value``) is used. For multi-dimensional `arr`, each *element* is filled with `fill_value`. Returns ------- ndarray or ExtensionArray Same type as the input. Raises ------ IndexError When `indices` is out of bounds for the array. ValueError When the indexer contains negative values other than ``-1`` and `allow_fill` is True. Notes ----- When `allow_fill` is False, `indices` may be whatever dimensionality is accepted by NumPy for `arr`. When `allow_fill` is True, `indices` should be 1-D. See Also -------- numpy.take : Take elements from an array along an axis. Examples -------- >>> from pandas.api.extensions import take With the default ``allow_fill=False``, negative numbers indicate positional indices from the right. >>> take(np.array([10, 20, 30]), [0, 0, -1]) array([10, 10, 30]) Setting ``allow_fill=True`` will place `fill_value` in those positions. >>> take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True) array([10., 10., nan]) >>> take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True, ... fill_value=-10) array([ 10, 10, -10]) )rK T)r� r � fill_value)r� )r rM rN r� r7 r� r3 r )r� r r� r r r� rV rV rW r � s L r �leftc C s� |dk rt |�}t| tj�r�t| j�r�t|�s6t|�r�t�| jj�}t |�rXt� |g�nt� |�}||j k� � r�||j k� � r�| j}n|j}t |�r�|�|�}q�t||d�}n t| �s�t| �s�t| �s�t| �} | j|||d�S )a� Find indices where elements should be inserted to maintain order. .. versionadded:: 0.25.0 Find the indices into a sorted array `arr` (a) such that, if the corresponding elements in `value` were inserted before the indices, the order of `arr` would be preserved. Assuming that `arr` is sorted: ====== ================================ `side` returned index `i` satisfies ====== ================================ left ``arr[i-1] < value <= self[i]`` right ``arr[i-1] <= value < self[i]`` ====== ================================ Parameters ---------- arr: array-like Input array. If `sorter` is None, then it must be sorted in ascending order, otherwise `sorter` must be an array of indices that sort it. value : array-like Values to insert into `arr`. side : {'left', 'right'}, optional If 'left', the index of the first suitable location found is given. If 'right', return the last such index. If there is no suitable index, return either 0 or N (where N is the length of `self`). sorter : 1-D array-like, optional Optional array of integer indices that sort array a into ascending order. They are typically the result of argsort. Returns ------- array of ints Array of insertion points with the same shape as `value`. See Also -------- numpy.searchsorted : Similar method from NumPy. N)rK )�side�sorter)r rL rM rO r! rK r �iinfor� r% r4 r� r� �maxr� r$ r# r r5 � searchsorted)r� �valuer r r Z value_arrrK rV rV rW r � s , r re rf rg rh ri rj � )r� r� � stacklevelc C s^ t |�}tj}| j}t|�}|r(tj}ntj}t|t �rF| � � } | j}t|tj�s�t | d|j � d��r�|dkr�t dt| �j � d|� ���|| | �|��S tdt|d� t�| �} | j}d}t| j�r�tj}| �d�} t}d }n2|r�tj}n&t|��r| jjd k�r tj}ntj}| j } | d k�r,| � d d �} t�|�}tj | j |d �} t d�gd } |dk�rht d|�nt |d�| |< || t!| �< | jjt"k�r�t#j$| | |||d� n�t d�gd } |dk�r�t |d�nt d|�| |< t!| �} t d�gd }|dk�rt d| �n t | d�||< t!|�}|| | | | �| | < |�r@| �d�} | d k�rZ| dd�df } | S )aQ difference of n between self, analogous to s-s.shift(n) Parameters ---------- arr : ndarray or ExtensionArray n : int number of periods axis : {0, 1} axis to shift on stacklevel : int, default 3 The stacklevel for the lost dtype warning. Returns ------- shifted �__r z cannot diff z on axis=zwdtype lost in 'diff()'. In the future this will raise a TypeError. Convert to a suitable dtype prior to calling 'diff'.)r FrI T)rj ri r� r� )rK NrF )Z datetimelikeztimedelta64[ns])%r� rM r� rK r �operator�xor�subrL r) Zto_numpy�hasattrr� rS r� �shiftr � FutureWarningrN r' rg rP r Zobject_r! rz rf re r� Zreshaper� r� �slicera � _diff_specialr Zdiff_2d)r� r� r� r �narK Zis_bool�opZ is_timedeltaZ orig_ndimZout_arrZ na_indexerZ _res_indexerZ res_indexerZ _lag_indexerZ lag_indexerrV rV rW �diffK sn " "& r" z*np.ndarray | tuple[np.ndarray, np.ndarray])r� r� r� rA c C s t | �std��t| tjtf�s:t| �\}}tj| |d�} d}t| �sbt j | dd�dkrbt | �}nRy| � � }| � |�}W n: tk r� | jr�t| d t�r�t| �}nt | �}Y nX |dkr�|S t |�s�td��tt�|��}|s�tt| ��t| �ks�td ��|dk�r8t| �\} } | t| ��} | �| � t| �|��}|d k�r�|� � } t| |d d �} |�rz|t| � k |t| �kB } nd} ndtjt|�tjd�}|�|t� t|��� |j |d d �} ||k} |�r�| |t| � k B |t| �kB } | dk �r�t� | | |� |t| �fS )a� Sort ``values`` and reorder corresponding ``codes``. ``values`` should be unique if ``codes`` is not None. Safe for use with mixed types (int, str), orders ints before strs. Parameters ---------- values : list-like Sequence; must be unique if ``codes`` is not None. codes : list_like, optional Indices to ``values``. All out of bound indices are treated as "not found" and will be masked with ``na_sentinel``. na_sentinel : int, default -1 Value in ``codes`` to mark "not found". Ignored when ``codes`` is None. assume_unique : bool, default False When True, ``values`` are assumed to be unique, which can speed up the calculation. Ignored when ``codes`` is None. verify : bool, default True Check if codes are out of bound for the values and put out of bound codes equal to na_sentinel. If ``verify=False``, it is assumed there are no out of bound codes. Ignored when ``codes`` is None. .. versionadded:: 0.25.0 Returns ------- ordered : ndarray Sorted ``values`` new_codes : ndarray Reordered ``codes``; returned when ``codes`` is not None. Raises ------ TypeError * If ``values`` is not list-like or if ``codes`` is neither None nor list-like * If ``values`` cannot be sorted ValueError * If ``codes`` is not None and ``values`` contain duplicates. zFOnly list-like objects are allowed to be passed to safe_sort as values)rK NF)r] z mixed-integerr zMOnly list-like objects or None are allowed to be passed to safe_sort as codesz,values should be unique if codes is not Noner� )r �wrap)r� ) r" rR rL rM rO r+ r rN r r r` � _sort_mixedr� r �sizera � _sort_tuplesr r| r{ rS rx Z map_locations�lookupr3 r� �int_�putZarangeZputmask)r@ rU r� r� r� rK rm r Zorderedr� �tZorder2Z new_codesr� Zreverse_indexerrV rV rW r� � sZ 1 r� c C sN t jdd� | D �td�}t �| | �}t �| | �}t �|t j|td�g�S )z3order ints before strings in 1d arrays, safe in py3c S s g | ]}t |t��qS rV )rL ry )r� r� rV rV rW r� C s z _sort_mixed.<locals>.<listcomp>)rK )rM r4 r� r� Z concatenaterN rC )r@ Zstr_pos�nums�strsrV rV rW r$ A s r$ c C s: ddl m} ddlm} || d�\}}||dd�}| | S )a Convert array of tuples (1d) to array or array (2d). We need to keep the columns separately as they contain different types and nans (can't use `np.sort` as it may fail when str and nan are mixed in a column as types cannot be compared). r )� to_arrays)�lexsort_indexerNT)Zorders)Z"pandas.core.internals.constructionr- Zpandas.core.sortingr. )r@ r- r. Zarraysrm r rV rV rW r& I s r& )�lvals�rvalsrA c C s� g }t | dd�}t |dd�}|j|dd�\}}tt�| |��}t| tj�s^t| �j|| j d�}x4t |�D ](\}}||gt t || || �� 7 }qhW |� |�S )a� Extracts the union from lvals and rvals with respect to duplicates and nans in both arrays. Parameters ---------- lvals: np.ndarray or ExtensionArray left values which is ordered in front. rvals: np.ndarray or ExtensionArray right values ordered after lvals. Returns ------- np.ndarray or ExtensionArray Containing the unsorted union of both arrays. F)r� r )r )rK )r� �alignr{ rM r� rL rO r� rZ rK r r� r r )r/ r0 r Zl_countZr_countZ unique_arrayrq r rV rV rW �union_with_duplicatesX s $r2 )r� NNN)Fr� N)TFFNT)r� )T)r r� r� TF)NN)r� )r FN)r N)r r )Nr� FT)�r� � __future__r r �textwrapr �typingr r r �warningsr �numpyrM Z pandas._libsr r ro r r Zpandas._typingr r r r r r Zpandas.util._decoratorsr Zpandas.core.dtypes.castr r r Zpandas.core.dtypes.commonr r r r r r r r r r r r! r" r# r$ r% r& r' r( Zpandas.core.dtypes.dtypesr) Zpandas.core.dtypes.genericr* r+ r, r- r. r/ r0 Zpandas.core.dtypes.missingr1 r2 Z pandas.core.array_algos.taker3 Zpandas.core.constructionr4 r� r5 r6 Zpandas.core.indexersr7 r8 r� r9 r: r; r< r� r= r> r? �__annotations__rX r\ rd ZComplex128HashTableZComplex64HashTableZFloat64HashTableZFloat32HashTableZUInt64HashTableZUInt32HashTableZUInt16HashTableZUInt8HashTableZInt64HashTableZInt32HashTableZInt16HashTableZ Int8HashTableZStringHashTableZPyObjectHashTablerl rp rv rx rk r{ Zunique1dr� r� r� r� r� r� r� r� r� r� r� r� r� r r r r" r� r$ r& r2 rV rV rV rW �<module> s� T $ P, lZ ' J J / 8 M [ NoaSv }
| ver. 1.4 |
Github
|
.
| PHP 8.3.23 | Генерация страницы: 0.06 |
proxy
|
phpinfo
|
Настройка