Файловый менеджер - Редактировать - /home/digitalm/venv/lib/python3.7/site-packages/pandas/core/arrays/__pycache__/interval.cpython-37.pyc
Назад
B �5�g-� � @ s" U d dl mZ d dlZd dlmZmZ d dlZd dlmZmZm Z d dl Z d dl m Z d dlmZ d dlmZmZmZmZ d dlmZ d d lmZmZmZ d d lm Z d d l m Z d d 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. d d l/m0Z0 d dl1m2Z2m3Z3m4Z4m5Z5 d dl6m7Z7m8Z8m9Z9 d dl:m;Z;m<Z<m=Z=m>Z> d dl?m@Z@mAZA d dlBmCZC d dlDmE mFZG d dlHmIZJmKZKmLZL d dlMmNZN d dlOmPZP d dlQmRZRmSZS eddd�ZTi ZUdeVd< dd d d �ZWd eUd < e eUd dd!d"d d d e�Xd#�d$� �G d%d� dee@��ZYd&d'�d(d)�ZZdS )*� )� annotationsN)�le�lt)�Sequence�TypeVar�cast)� get_option)�NaT)� VALID_CLOSED�Interval� IntervalMixin� intervals_to_interval_bounds)�NA)� ArrayLike�Dtype�NpDtype)�function)�Appender)�is_categorical_dtype�is_datetime64_dtype�is_datetime64tz_dtype�is_dtype_equal�is_float_dtype�is_integer_dtype�is_interval_dtype� is_list_like�is_object_dtype� is_scalar�is_string_dtype�is_timedelta64_dtype�needs_i8_conversion� pandas_dtype)� IntervalDtype)� ABCDataFrame�ABCDatetimeIndex�ABCIntervalIndex�ABCPeriodIndex)�is_valid_na_for_dtype�isna�notna)�isin�take�unique� value_counts)�ExtensionArray� _extension_array_shared_docs)� Categorical)�array� ensure_wrapped_if_datetimelike� extract_array)�check_array_indexer)� ensure_index)�invalid_comparison�unpack_zerodim_and_defer�IntervalArrayT� IntervalArray)�boundzdict[str, str]�_interval_shared_docszarrays.IntervalArray� )�klass�qualname�namea� %(summary)s .. versionadded:: %(versionadded)s Parameters ---------- data : array-like (1-dimensional) Array-like containing Interval objects from which to build the %(klass)s. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. dtype : dtype or None, default None If None, dtype will be inferred. copy : bool, default False Copy the input data. %(name)sverify_integrity : bool, default True Verify that the %(klass)s is valid. Attributes ---------- left right closed mid length is_empty is_non_overlapping_monotonic %(extra_attributes)s Methods ------- from_arrays from_tuples from_breaks contains overlaps set_closed to_tuples %(extra_methods)s See Also -------- Index : The base pandas Index type. Interval : A bounded slice-like interval; the elements of an %(klass)s. interval_range : Function to create a fixed frequency IntervalIndex. cut : Bin values into discrete Intervals. qcut : Bin values into equal-sized Intervals based on rank or sample quantiles. Notes ----- See the `user guide <https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#intervalindex>`__ for more. %(examples)s�classz@Pandas array for interval data that are closed on the same side.z0.24.0a� Examples -------- A new ``IntervalArray`` can be constructed directly from an array-like of ``Interval`` objects: >>> pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]) <IntervalArray> [(0, 1], (1, 5]] Length: 2, dtype: interval[int64, right] It may also be constructed using one of the constructor methods: :meth:`IntervalArray.from_arrays`, :meth:`IntervalArray.from_breaks`, and :meth:`IntervalArray.from_tuples`. )r= �summaryZ versionaddedr? Zextra_attributesZ extra_methods�examplesc s e Zd ZdZdZej ZZd�ddddd�d d �Z e d�ddddd d �d d��Z e ddd�dddd d�dd��Z e ddd d d�dd��Z e�d�ed< e eed d e�d�d� �d�dddd d �d d ���Ze�d �ed < e eed d e�d!�d� �d�dddd d �d"d#���Ze�d$�ed%< e eed% d e�d&�d� �d�dddd d �d'd(���Zd)d*� Zd d d+�d,d-�Zed.d/�d0d1��Zed2d/�d3d4��Zed2d/�d5d6��Zd7d8� Zd2d/�d9d:�Z d;d<� Z d=d>� Z d?d@� Z e dA�dBdC� �Z!e dD�dEdF� �Z"e dG�dHdI� �Z#e dJ�dKdL� �Z$e dM�dNdO� �Z%e dP�dQdR� �Z&d�ddUdUddV�� fdWdX� Z'd�d d d+�dYdZ�Z(d�dd[�d\d]�Z)dd/�d^d_�Z*e dd`d da�dbdc��Z+d d d+�ddde�Z,dd/�dfdg�Z-d�d d2dhd di�djdk�Z.ddddl�d dd dm�dndo�Z/dpdq� Z0drds� Z1dtdu� Z2d�ddv�dwdx�Z3dUd/�dydz�Z4dUd/�d{d|�Z5dUd/�d}d~�Z6edd�� �Z7ed�d�� �Z8ed�d�� �Z9ed�d�� �Z:e�d��ed�< eed� d e�d��d� �d�d�� �Z;ed�d�� �Z<e�d��ed�< eed� d e�d��d� �d d d+�d�d���Z=d�ed�< eeed� e> �dd/�d�d����Z?d�d�dd��d�d��Z@d�d�d��ZAd�ed�< eed� d�d�d�� �d�dd/�d�d���ZBdd�d��d�d��ZCd d2d�d d��d�d��ZDd d d+�d�d��ZEeeFd� e> �d�d d�d�d d��d�d���ZGe�d��ed�< eed� d e�d��d� �d�d�� �ZHdd/�d�d��ZIed�d/�d�d���ZJdd d��d�d��ZKd d/�d�dZL� ZMS )�r9 � TNFztype[IntervalArrayT]z Dtype | None�bool)�cls�dtype�copy�verify_integrityc C s� t |dd�}t|| �r.|j}|j}|p*|j}nHt|�rP| j� d|� d�}t|��t|�}t ||d kd�\}}} |pt| }| j ||||||d�S )NT)� extract_numpyz5(...) must be called with a collection of some kind, z was passed)Zvalidate_closed)rG rF rH ) r3 � isinstance�_left�_right�closedr �__name__� TypeError� _maybe_convert_platform_intervalr � _simple_new) rE �datarM rF rG rH �left�right�msgZ infer_closed� rV �Q/home/digitalm-up/venv/lib/python3.7/site-packages/pandas/core/arrays/interval.py�__new__� s& zIntervalArray.__new__r8 )rE rG rF rH �returnc C sJ t �| �}|d kr"t|t�r"|j}|p(d}t||d�}t||d�}|d k r�t|�}t|�r�tt|�}|j d k r�|� |j �}|� |j �}nd|� �}t |��|jd kr�t|j |�}n||jkr�t d��t |�r�t|�r�|� |j�}n t |�r�t|�r�|� |j�}t|�t|�k�r8dt|�j� dt|�j� d�}t |��n�t|j��sPt|j��r^d}t |��nZt|t��rxd }t |��n@t|t��r�t|j�t|j�k�r�d |j� d |j� d �}t |��t|�}t|d d�}t|�}t|d d�}t|d|�j} t|d|�j} | d k �r| | k�r|� � }t|j|d�}||_ ||_ ||_ |�rF|� � |S )NrT )rG z$dtype must be an IntervalDtype, got z*closed keyword does not match dtype.closedz must not have differing left [z ] and right [z] typeszIcategory, object, and string subtypes are not supported for IntervalArrayz:Period dtypes are not supported, use a PeriodIndex insteadz2left and right must have the same time zone, got 'z' and '�'T)rI Z_ndarray)rM )!r rX rJ r" rM r5 r! r r �subtype�astyperO � ValueErrorr r rF �typerN r r r& r$ �str�tzr2 r3 �getattr�baserG �_dtyperK rL � _validate) rE rS rT rM rG rF rH �resultrU ZlbaseZrbaserV rV rW rQ � sd " zIntervalArray._simple_new)rF rG )rE rF rG rY c C s | |||d�S )N)rF rG rV )rE ZscalarsrF rG rV rV rW �_from_sequenceF s z IntervalArray._from_sequencez np.ndarray)rE �values�originalrY c C s( t |�dkr|�|jj�}| ||jd�S )Nr )rM )�lenr\ rF r[ rM )rE rg rh rV rV rW �_from_factorizedP s z IntervalArray._from_factorizedaS Construct an %(klass)s from an array of splits. Parameters ---------- breaks : array-like (1-dimensional) Left and right bounds for each interval. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. copy : bool, default False Copy the data. dtype : dtype or None, default None If None, dtype will be inferred. Returns ------- %(klass)s See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. %(klass)s.from_arrays : Construct from a left and right array. %(klass)s.from_tuples : Construct from a sequence of tuples. %(examples)s � from_breaksz� Examples -------- >>> pd.arrays.IntervalArray.from_breaks([0, 1, 2, 3]) <IntervalArray> [(0, 1], (1, 2], (2, 3]] Length: 3, dtype: interval[int64, right] )r= rB rT )rE rG rF rY c C s, t |�}| j|d d� |dd � |||d�S )N���rC )rG rF )rP � from_arrays)rE ZbreaksrM rG rF rV rV rW rk y s zIntervalArray.from_breaksa3 Construct from two arrays defining the left and right bounds. Parameters ---------- left : array-like (1-dimensional) Left bounds for each interval. right : array-like (1-dimensional) Right bounds for each interval. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. copy : bool, default False Copy the data. dtype : dtype, optional If None, dtype will be inferred. Returns ------- %(klass)s Raises ------ ValueError When a value is missing in only one of `left` or `right`. When a value in `left` is greater than the corresponding value in `right`. See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. %(klass)s.from_breaks : Construct an %(klass)s from an array of splits. %(klass)s.from_tuples : Construct an %(klass)s from an array-like of tuples. Notes ----- Each element of `left` must be less than or equal to the `right` element at the same position. If an element is missing, it must be missing in both `left` and `right`. A TypeError is raised when using an unsupported type for `left` or `right`. At the moment, 'category', 'object', and 'string' subtypes are not supported. %(examples)s rm z� >>> pd.arrays.IntervalArray.from_arrays([0, 1, 2], [1, 2, 3]) <IntervalArray> [(0, 1], (1, 2], (2, 3]] Length: 3, dtype: interval[int64, right] c C s& t |�}t |�}| j|||||dd�S )NT)rG rF rH )rP rQ )rE rS rT rM rG rF rV rV rW rm � s zIntervalArray.from_arraysa� Construct an %(klass)s from an array-like of tuples. Parameters ---------- data : array-like (1-dimensional) Array of tuples. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. copy : bool, default False By-default copy the data, this is compat only and ignored. dtype : dtype or None, default None If None, dtype will be inferred. Returns ------- %(klass)s See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. %(klass)s.from_arrays : Construct an %(klass)s from a left and right array. %(klass)s.from_breaks : Construct an %(klass)s from an array of splits. %(examples)s � from_tuplesz� Examples -------- >>> pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 2)]) <IntervalArray> [(0, 1], (1, 2]] Length: 2, dtype: interval[int64, right] c C s� t |�rg g }}n| }}x�|D ]�}t|�r:tj }} n�| j} y |\}} W nr tk r� } z | � d|� �} t| �| �W d d } ~ X Y n: tk r� } z | � d|� �} t| �| �W d d } ~ X Y nX |�|� |�| � q"W | j|||d|d�S )Nz..from_tuples requires tuples of length 2, got z'.from_tuples received an invalid item, F)rG rF ) ri r( �np�nanrN r] rO �appendrm ) rE rR rM rG rF rS rT �d�lhs�rhsr? �errrU rV rV rW rn s$ zIntervalArray.from_tuplesc C s� | j tkr d| j � �}t|��t| j�t| j�kr>d}t|��t| j�}t| j�}||k�� sjd}t|��| j| | j| k�� s�d}t|��dS )z� Verify that the IntervalArray is valid. Checks that * closed is valid * left and right match lengths * left and right have the same missing values * left is always below right z invalid option for 'closed': z(left and right must have the same lengthzMmissing values must be missing in the same location both left and right sidesz+left side of interval must be <= right sideN)rM r r] ri rK rL r) �all)�selfrU Z left_maskZ right_maskrV rV rW rd 5 s zIntervalArray._validate)rw rY c C s | j ||| jdd�S )a# Return a new IntervalArray with the replacement attributes Parameters ---------- left : Index Values to be used for the left-side of the intervals. right : Index Values to be used for the right-side of the intervals. F)rM rH )rQ rM )rw rS rT rV rV rW � _shallow_copyR s zIntervalArray._shallow_copyr" )rY c C s | j S )N)rc )rw rV rV rW rF b s zIntervalArray.dtype�intc C s | j j| jj S )N)rS �nbytesrT )rw rV rV rW rz f s zIntervalArray.nbytesc C s | j jS )N)rS �size)rw rV rV rW r{ j s zIntervalArray.sizec C s t t�| ��S )N)�iterro �asarray)rw rV rV rW �__iter__r s zIntervalArray.__iter__c C s t | j�S )N)ri rK )rw rV rV rW �__len__u s zIntervalArray.__len__c C st t | |�}| j| }| j| }t|tjtf�sRt|�rDt|�rD| j S t ||| j �S t� |�dkrht d��| �||�S )NrC z&multi-dimensional indexing not allowed)r4 rK rL rJ ro �ndarrayr. r r( � _fill_valuer rM �ndimr] rx )rw �keyrS rT rV rV rW � __getitem__x s zIntervalArray.__getitem__c C s0 | � |�\}}t| |�}|| j|< || j|< d S )N)�_validate_setitem_valuer4 rK rL )rw r� �value� value_left� value_rightrV rV rW � __setitem__� s zIntervalArray.__setitem__c C sB t |�r*t| �t|�kr td��t|�}nt|t�s@t| ||�S t|t�rTtd�}nTt|j �sf|j }nB|j j }t |�r�| j |j j kr�t| ||�S |j j |jd|j jd�}t |��r�| j |j kr�t| ||�S t|t�s�t| �|�}|tjk�r| j|jk| j|jk@ S |tjk�r(| j|jk| j|jkB S |tjk�rX| j|jk| j|jk| j|jk@ B S |tjk�rt| |k| |kB S |tjk�r�| j|jk | j|jk| j|jk @ B S | |k| |k B S t|��s�t| ||�S t j t| �t d�}x`t |�D ]T\}}y|| | |�||< W n2 t k �r6 |t!k�r0|tjk||< n� Y nX �q�W |S )Nz Lengths must match to compare�intervalT)� allow_fill� fill_value)rF )"r ri r] �pd_arrayrJ r r6 r! r rF � categoriesr rM r+ �codes� _na_valuer^ �operator�eqrK rS rL rT �ne�gt�ger r ro �zerosrD � enumeraterO r )rw �other�opZ other_dtypere �i�objrV rV rW � _cmp_method� sZ zIntervalArray._cmp_method�__eq__c C s | � |tj�S )N)r� r� r� )rw r� rV rV rW r� � s zIntervalArray.__eq__�__ne__c C s | � |tj�S )N)r� r� r� )rw r� rV rV rW r� � s zIntervalArray.__ne__�__gt__c C s | � |tj�S )N)r� r� r� )rw r� rV rV rW r� � s zIntervalArray.__gt__�__ge__c C s | � |tj�S )N)r� r� r� )rw r� rV rV rW r� � s zIntervalArray.__ge__�__lt__c C s | � |tj�S )N)r� r� r )rw r� rV rV rW r� � s zIntervalArray.__lt__�__le__c C s | � |tj�S )N)r� r� r )rw r� rV rV rW r� � s zIntervalArray.__le__� quicksort�lastr_ )� ascending�kind� na_positionrY c sN t �|||�}|r4|dkr4|dkr4t�| j| jf�S t� jf |||d�|��S )Nr� r� )r� r� r� )�nvZ validate_argsort_with_ascendingro ZlexsortrT rS �super�argsort)rw r� r� r� �args�kwargs)� __class__rV rW r� � s zIntervalArray.argsortc C sV |dk rt d��|dk r t d��| �|�\}}| jj|d�}| jj|d�}| �||�S )a� Fill NA/NaN values using the specified method. Parameters ---------- value : scalar, dict, Series If a scalar value is passed it is used to fill all missing values. Alternatively, a Series or dict can be used to fill in different values for each index. The value should not be a list. The value(s) passed should be either Interval objects or NA/NaN. method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None (Not implemented yet for IntervalArray) Method to use for filling holes in reindexed Series limit : int, default None (Not implemented yet for IntervalArray) If method is specified, this is the maximum number of consecutive NaN values to forward/backward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. If method is not specified, this is the maximum number of entries along the entire axis where NaNs will be filled. Returns ------- filled : IntervalArray with NA/NaN filled Nz5Filling by method is not supported for IntervalArray.z)limit is not supported for IntervalArray.)r� )rO �_validate_scalarrS �fillnarT rx )rw r� �method�limitr� r� rS rT rV rV rW r� s zIntervalArray.fillna)rG c C sb ddl m} ddlm} |dk r(t|�}t|�r�|| jkrJ|rF| �� S | S y0|| jdd�� |j �}|| j dd�� |j �}W n@ t k r� } z"d| j� d|� d �}t |�|�W dd}~X Y nX | � ||�S t|�r�tt�| �|d �S t||��r |�� j| dd�S yt�| �j ||d�S t tfk �r\ } z$d t| �j� d |� �}t |�|�W dd}~X Y nX dS ) a( Cast to an ExtensionArray or NumPy array with dtype 'dtype'. Parameters ---------- dtype : str or dtype Typecode or data-type to which the array is cast. copy : bool, default True Whether to copy the data, even if not necessary. If False, a copy is made only if the old dtype does not match the new dtype. Returns ------- array : ExtensionArray or ndarray ExtensionArray or NumPy ndarray with 'dtype' for its dtype. r )�Index)� StringDtypeNF)rG zCannot convert z to z; subtypes are incompatible)rF z Cannot cast z to dtype )�pandasr� Zpandas.core.arrays.string_r� r! r rF rG rK r\ r[ rL rO rx r r0 ro r} rJ Zconstruct_array_typerf r] r^ rN ) rw rF rG r� r� �new_left� new_rightru rU rV rV rW r\ + s. zIntervalArray.astypec C s@ t | �t |�krdS t| j|jko<| j�|j�o<| j�|j��S )NF)r^ rD rM rS �equalsrT )rw r� rV rV rW r� ` s zIntervalArray.equalszSequence[IntervalArrayT])rE � to_concatrY c C sd dd� |D �}t |�dkr"td��|�� }t�dd� |D ��}t�dd� |D ��}| j|||dd �S ) z� Concatenate multiple IntervalArray Parameters ---------- to_concat : sequence of IntervalArray Returns ------- IntervalArray c S s h | ] }|j �qS rV )rM )�.0r� rV rV rW � <setcomp>y s z2IntervalArray._concat_same_type.<locals>.<setcomp>rC z.Intervals must all be closed on the same side.c S s g | ] }|j �qS rV )rS )r� r� rV rV rW � <listcomp>~ s z3IntervalArray._concat_same_type.<locals>.<listcomp>c S s g | ] }|j �qS rV )rT )r� r� rV rV rW r� s F)rM rG )ri r] �popro � concatenaterQ )rE r� rM rS rT rV rV rW �_concat_same_typej s z IntervalArray._concat_same_typec C s. | j �� }| j�� }| j}t| �j|||d�S )zd Return a copy of the array. Returns ------- IntervalArray )rM )rK rG rL rM r^ rm )rw rS rT rM rV rV rW rG � s zIntervalArray.copyc C s t | j�S )N)r( rK )rw rV rV rW r( � s zIntervalArray.isna�object)rw �periodsr� rY c C s� t | �r|dkr| �� S t|�r(| jj}tt|�t | ��}t|�rtddlm} || j dd�j }t � |g|d �}n| � |g| �}|dkr�|}| d | � }n| t|�d � }|}| �||g�S )Nr )r� F)rG rC )ri rG r( rF Zna_value�min�absr� r� rK r� r9 rk rf r� )rw r� r� Z empty_lenr� �empty�a�brV rV rW �shift� s zIntervalArray.shift)r� r� �axis)rw r� rY c K sV t �d|� | }}|r&| �|�\}}t| j|||d�}t| j|||d�} | �|| �S )am Take elements from the IntervalArray. Parameters ---------- indices : sequence of integers Indices to be taken. 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 other negative values raise a ``ValueError``. fill_value : Interval or NA, 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 many ExtensionArrays, there will be two representations of `fill_value`: a user-facing "boxed" scalar, and a low-level physical NA value. `fill_value` should be the user-facing version, and the implementation should handle translating that to the physical version for processing the take if necessary. axis : any, default None Present for compat with IntervalIndex; does nothing. Returns ------- IntervalArray Raises ------ IndexError When the indices are out of bounds for the array. ValueError When `indices` contains negative values other than ``-1`` and `allow_fill` is True. rV )r� r� )r� Z validate_taker� r+ rK rL rx ) rw �indicesr� r� r� r� Z fill_leftZ fill_rightZ left_takeZ right_takerV rV rW r+ � s 6 zIntervalArray.takec C s� y(t |�}| j|dd� |j|j }}W n< tk rd } z dt|�� d�}t|�|�W d d }~X Y nX y| j�|� W n@ ttfk r� } z dt|�� d�}t|�|�W d d }~X Y nX ||fS )Nr� )r? z('value' should be an interval type, got z instead.z2'value' should be a compatible interval type, got )r9 �_check_closed_matchesrS rT rO r^ �_validate_fill_valuer] )rw r� r1 r� r� ru rU rV rV rW �_validate_listlike� s z IntervalArray._validate_listlikec C sP t |t�r(| j|dd� |j|j }}n t|| jj�r@| }}ntd��||fS )Nr� )r? z=can only insert Interval objects and NA into an IntervalArray)rJ r r� rS rT r' rF rO )rw r� rS rT rV rV rW r� s z IntervalArray._validate_scalarc C s� d}t || jj�rpt| jj�r$d}n@t| jj�r<t�d�}n(t| jj�rNt }nt | jj�rdt� d�}|| }}nJt |t �r�| j|dd� |j|j }}| j�|� | j�|� n | �|�S |r�td��||fS )NFTr r� )r? z4Cannot set float NaN to integer-backed IntervalArray)r' rS rF r r[ r ro Z datetime64r r r Z timedelta64rJ r r� rT r� r� r] )rw r� Zneeds_float_conversionr� r� rV rV rW r� s( z%IntervalArray._validate_setitem_value)�dropnac C s t t�| �|d�S )a2 Returns a Series containing counts of each interval. Parameters ---------- dropna : bool, default True Don't include counts of NaN. Returns ------- counts : Series See Also -------- Series.value_counts )r� )r- ro r} )rw r� rV rV rW r- < s zIntervalArray.value_countsc s& t | �}ttd�p|d d�}t� |dkr0d}n�|dkrR� | d �}d|� d�}n�|dkr�� | d �}� | d �}d|� d |� d�}n�||kr�t|d d�}� fd d �| d |� D �}� fd d �| | d � D �}d �|�}d �|�} d|� d| � d�}n(� fdd �| D �}d �|�} d| � d�}|S )Nzdisplay.max_seq_items� r z[]rC �[�]� rl z, c s g | ] }� |��qS rV rV )r� �x)� formatterrV rW r� i s z.IntervalArray._format_data.<locals>.<listcomp>c s g | ] }� |��qS rV rV )r� r� )r� rV rW r� j s z ... c s g | ] }� |��qS rV rV )r� r� )r� rV rW r� o s )ri r� r r_ �join) rw �nZ max_seq_itemsrA �firstr� �head�tailZhead_strZtail_strrV )r� rW � _format_dataS s. zIntervalArray._format_datac C s< | � � }dt| �j� d�}|� |� dt| �� d| j� �}|S )N�<z> z Length: z , dtype: )r� r^ rN ri rF )rw rR � class_name�templaterV rV rW �__repr__u s zIntervalArray.__repr__c C s dt t| �j�d }d|� �S )N� rC � )ri r^ rN )rw �spacerV rV rW � _format_space s zIntervalArray._format_spacec C s ddl m} || jdd�S )zf Return the left endpoints of each Interval in the IntervalArray as an Index. r )r� F)rG )r� r� rK )rw r� rV rV rW rS � s zIntervalArray.leftc C s ddl m} || jdd�S )zg Return the right endpoints of each Interval in the IntervalArray as an Index. r )r� F)rG )r� r� rL )rw r� rV rV rW rT � s zIntervalArray.rightc C sB y | j | j S tk r< } zd}t|�|�W dd}~X Y nX dS )zq Return an Index with entries denoting the length of each Interval in the IntervalArray. z]IntervalArray contains Intervals without defined length, e.g. Intervals with string endpointsN)rT rS rO )rw ru rU rV rV rW �length� s zIntervalArray.lengthc C s6 yd| j | j S tk r0 | j d| j S X dS )zX Return the midpoint of each Interval in the IntervalArray as an Index. g �?N)rS rT rO r� )rw rV rV rW �mid� s zIntervalArray.midaI Check elementwise if an Interval overlaps the values in the %(klass)s. Two intervals overlap if they share a common point, including closed endpoints. Intervals that only have an open endpoint in common do not overlap. Parameters ---------- other : %(klass)s Interval to check against for an overlap. Returns ------- ndarray Boolean array positionally indicating where an overlap occurs. See Also -------- Interval.overlaps : Check whether two Interval objects overlap. Examples -------- %(examples)s >>> intervals.overlaps(pd.Interval(0.5, 1.5)) array([ True, True, False]) Intervals that share closed endpoints overlap: >>> intervals.overlaps(pd.Interval(1, 3, closed='left')) array([ True, True, True]) Intervals that only have an open endpoint in common do not overlap: >>> intervals.overlaps(pd.Interval(1, 2, closed='right')) array([False, True, False]) �overlapsz� >>> data = [(0, 1), (1, 3), (2, 4)] >>> intervals = pd.arrays.IntervalArray.from_tuples(data) >>> intervals <IntervalArray> [(0, 1], (1, 3], (2, 4]] Length: 3, dtype: interval[int64, right] c C sz t |ttf�rt�n"t |t�s6dt|�j� �}t|��| jrF|j rFt nt }|jrZ| j rZt nt }|| j |j �||j | j �@ S )Nz#`other` must be Interval-like, got )rJ r9 r% �NotImplementedErrorr r^ rN rO Z closed_leftZ closed_rightr r rS rT )rw r� rU Zop1Zop2rV rV rW r� � s zIntervalArray.overlapsc C s | j jS )zi Whether the intervals are closed on the left-side, right-side, both or neither. )rF rM )rw rV rV rW rM � s zIntervalArray.closeda� Return an %(klass)s identical to the current one, but closed on the specified side. Parameters ---------- closed : {'left', 'right', 'both', 'neither'} Whether the intervals are closed on the left-side, right-side, both or neither. Returns ------- new_index : %(klass)s %(examples)s � set_closedav Examples -------- >>> index = pd.arrays.IntervalArray.from_breaks(range(4)) >>> index <IntervalArray> [(0, 1], (1, 2], (2, 3]] Length: 3, dtype: interval[int64, right] >>> index.set_closed('both') <IntervalArray> [[0, 1], [1, 2], [2, 3]] Length: 3, dtype: interval[int64, both] c C s4 |t krd|� �}t|��t| �j| j| j|dd�S )Nz invalid option for 'closed': F)rS rT rM rH )r r] r^ rQ rK rL )rw rM rU rV rV rW r� s zIntervalArray.set_closedz� Return True if the %(klass)s is non-overlapping (no Intervals share points) and is either monotonic increasing or monotonic decreasing, else False. � is_non_overlapping_monotonicc C s� | j dkrNt| jd d� | jdd � k �� pJ| jd d� | jdd � k�� �S t| jd d� | jdd � k�� p�| jd d� | jdd � k�� �S )NZbothrl rC )rM rD rL rK rv )rw rV rV rW r� B s " z*IntervalArray.is_non_overlapping_monotoniczNpDtype | None)rF rY c C sr | j }| j}| �� }| j}tjt|�td�}x@tt|��D ]0}|| rRtj ||< q:t || || |�||< q:W |S )zt Return the IntervalArray's data as a numpy array of Interval objects (with dtype='object') )rF ) rK rL r( rM ro r� ri r� �rangerp r )rw rF rS rT �maskrM re r� rV rV rW � __array__] s zIntervalArray.__array__c C sp ddl }ddlm} y|�| jj�}W n8 tk r^ } ztd| jj� d��|�W dd}~X Y nX ||| j�}|jj |j | j |dd�|j | j |dd�gdd gd �}| � � }|�� r�|� | ��� d } |jj|jt|�| g|�d�|�d �gd �}|dk �rb|�|j��r |S t||��rR|�|��sbtd | jj� d|j� d| j� d|j� d� ��ntd|� d���|j�||�S )z6 Convert myself into a pyarrow Array. r N)�ArrowIntervalTypez"Conversion to arrow with subtype 'z' is not supportedT)r^ Z from_pandasrS rT )�namesrC )�childrenzINot supported to convert IntervalArray to type with different 'subtype' (z vs z) and 'closed' (z ) attributesz+Not supported to convert IntervalArray to 'z' type)�pyarrowZ pandas.core.arrays._arrow_utilsr� Zfrom_numpy_dtyperF r[ rO rM Z StructArrayrm r1 rK rL r( �anyZbuffersZ from_buffersr^ ri �fieldr� Z storage_typerJ r. Z from_storage) rw r^ r� r� r[ ru Z interval_typeZ storage_arrayr� Z null_bitmaprV rV rW �__arrow_array__o s> ,z IntervalArray.__arrow_array__ak Return an %(return_type)s of tuples of the form (left, right). Parameters ---------- na_tuple : bool, default True Returns NA as a tuple if True, ``(nan, nan)``, or just as the NA value itself if False, ``nan``. Returns ------- tuples: %(return_type)s %(examples)s � to_tuplesr� r< )� return_typerB c C s2 t �t| j| j��}|s.t�| �� |tj�}|S )N) �comZasarray_tuplesafe�ziprK rL ro �wherer( rp )rw Zna_tupleZtuplesrV rV rW r� � s zIntervalArray.to_tuples�None)r� rY c C s^ | � |�\}}t| jtj�r>t�| j||� t�| j||� n | j�||� | j�||� d S )N)r� rJ rK ro r� �putmaskrL )rw r� r� r� r� rV rV rW r� � s zIntervalArray.putmaskr )rw �loc�itemrY c C s6 | � |�\}}| j�||�}| j�||�}| �||�S )ab Return a new IntervalArray inserting new item at location. Follows Python list.append semantics for negative values. Only Interval objects and NA can be inserted into an IntervalIndex Parameters ---------- loc : int item : Interval Returns ------- IntervalArray )r� rS �insertrT rx )rw r� r� Z left_insertZ right_insertr� r� rV rV rW r� � s zIntervalArray.insertc C sR t | jtj�r,t�| j|�}t�| j|�}n| j�|�}| j�|�}| j||d�S )N)rS rT )rJ rK ro r� �deleterL rx )rw r� r� r� rV rV rW r� � s zIntervalArray.delete�repeatzint | Sequence[int]z int | None)rw �repeatsr� rY c C s6 t �dd|i� | j�|�}| j�|�}| j||d�S )NrV r� )rS rT )r� Zvalidate_repeatrS r� rT rx )rw r� r� Z left_repeatZ right_repeatrV rV rW r� � s zIntervalArray.repeata� Check elementwise if the Intervals contain the value. Return a boolean mask whether the value is contained in the Intervals of the %(klass)s. .. versionadded:: 0.25.0 Parameters ---------- other : scalar The value to check whether it is contained in the Intervals. Returns ------- boolean array See Also -------- Interval.contains : Check whether Interval object contains value. %(klass)s.overlaps : Check if an Interval overlaps the values in the %(klass)s. Examples -------- %(examples)s >>> intervals.contains(0.5) array([ True, False, False]) �containsz� >>> intervals = pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 3), (2, 4)]) >>> intervals <IntervalArray> [(0, 1], (1, 3], (2, 4]] Length: 3, dtype: interval[int64, right] c C sF t |t�rtd��| jr"| j|k n| j|k| jr:|| jk n|| jk@ S )Nz*contains not implemented for two intervals)rJ r r� Z open_leftrK Z open_rightrL )rw r� rV rV rW r� s zIntervalArray.containsc C s� t |d�st�|�}t|dd�}t|j�r�| j|jkrFtj| jt d�S t | j|j�rx| j � d�}|j � d�}t� ||�S t| jj�t|jj�A r�tj| jt d�S t| �t�|�t��S )NrF T)rI )rF � complex128)�hasattrro r1 r3 r rF rM r� �shaperD r � _combined�viewZin1dr rS r* r\ r� )rw rg rS rT rV rV rW r* + s zIntervalArray.isinr c C sT | j j�dd�}| jj�dd�}t|j�r>|j||gdd�}ntj||gdd�}|S )Nrl rC )r� ) rS Z_values�reshaperT r rF r� ro r� )rw rS rT ZcombrV rV rW r D s zIntervalArray._combined)�combinedrY c C s� |� d��dd�}| jj}t|�rdt| j�j|dd�df |d�}t| j�j|dd�df |d�}n,|dd�df � |�}|dd�df � |�}| j||d�S ) zY Create a new IntervalArray with our dtype from a 1D complex128 ndarray. �i8rl r� Nr )rF rC )rS rT ) r r rK rF r r^ rf rL rx )rw r �ncrF r� r� rV rV rW �_from_combinedN s "z IntervalArray._from_combinedc C s6 t | j�d�d d �df �}|d d �d f }| �|�S )Nr� r )r, r r r )rw r rV rV rW r, ] s zIntervalArray.unique)NNFT)NFNT)rT FN)rT FN)rT FN)Tr� r� )NNN)T)rC N)T)N)N)T)N)NrN � __module__� __qualname__r� Z can_hold_naro rp r� r� rX � classmethodrQ rf rj �textwrap�dedentr; r rk rm rn rd rx �propertyrF rz r{ r~ r r� r� r� r7 r� r� r� r� r� r� r� r� r\ r� r� rG r( r� r+ r� r� r� r- r� r� r� rS rT r� r� r� rM r� �_shared_docs_kwargsr� r� r� r� r� r� r� r/ r� r� r* r r r, � __classcell__rV rV )r� rW r9 � s # O . G '5 "?!" % C r )rY c C s� t | ttf�r*t| �dkr*tjg tjd�S t| �r<t | t�r@| S t | �rTt� | �} n*t | d�srt | ttt f�sr| S t | dd�} t | d�s�t� | �S | S )a� Try to do platform conversion, with special casing for IntervalArray. Wrapper around maybe_convert_platform that alters the default return dtype in certain cases to be compatible with IntervalArray. For example, empty lists return with integer dtype instead of object dtype, which is prohibited for IntervalArray. Parameters ---------- values : array-like Returns ------- array r )rF rF T)rI )rJ �list�tupleri ro r1 Zint64r r# r r} r r� r3 )rg rV rV rW rP f s rP )[� __future__r r� r r r �typingr r r �numpyro Zpandas._configr Z pandas._libsr Zpandas._libs.intervalr r r r Zpandas._libs.missingr Zpandas._typingr r r Zpandas.compat.numpyr r� Zpandas.util._decoratorsr Zpandas.core.dtypes.commonr r r r r r r r r r r r r r! Zpandas.core.dtypes.dtypesr" Zpandas.core.dtypes.genericr# r$ r% r& Zpandas.core.dtypes.missingr' r( r) Zpandas.core.algorithmsr* r+ r, r- Zpandas.core.arrays.baser. r/ Z pandas.core.arrays.categoricalr0 Zpandas.core.common�core�commonr� Zpandas.core.constructionr1 r� r2 r3 Zpandas.core.indexersr4 Zpandas.core.indexes.baser5 Zpandas.core.opsr6 r7 r8 r; �__annotations__r r r9 rP rV rV rV rW �<module> sl @ @ 3
| ver. 1.4 |
Github
|
.
| PHP 8.3.23 | Генерация страницы: 0.05 |
proxy
|
phpinfo
|
Настройка