Файловый менеджер - Редактировать - /home/digitalm/venv/lib/python3.7/site-packages/pandas/core/indexes/__pycache__/interval.cpython-37.pyc
Назад
B �5�g�� � @ s� d Z ddlmZ ddlmZmZ ddlZddlmZm Z ddl Z ddl m Z ddlmZmZmZ ddlmZmZmZmZ dd lmZmZ dd lmZ dd l m Z m Z dd l m Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z& ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:Z: ddl;m<Z<m=Z= ddl>m? m@ZA ddlBmCZC ddlDm? mE mFZG ddlDmHZHmIZImJZJmKZK ddlLmMZMmNZN ddlOmPZPmQZQ ddlRmSZS ddlTmUZUmVZV eWeGjX�ZXeX�Yddde�Zd�d �� d d � Z[d d � Z\d!d"� Z]e e=d# dd$eXd% d&d'd(e�Zd)�d*� �eQd+d,ge<d-d.�eQd/d0d1d2d3d4d5d6ge<�eQd7d8ge<d-d9�G d:d� deP�����Z^d;d<�d=d>�Z_d;d<�d?d@�Z`dFdBddC�dDdE�ZadS )Gz define the IntervalIndex � )� annotations)�le�ltN)�Any�Hashable)�lib)�Interval� IntervalMixin� IntervalTree)� BaseOffset� Timedelta� Timestamp� to_offset)�Dtype�DtypeObj)�InvalidIndexError)�Appender�cache_readonly)�rewrite_exception)�'construct_1d_object_array_from_listlike�find_common_type�infer_dtype_from_scalar�maybe_box_datetimelike�maybe_downcast_numeric) �ensure_platform_int�is_datetime64tz_dtype� is_datetime_or_timedelta_dtype�is_dtype_equal�is_float�is_float_dtype� is_integer�is_integer_dtype�is_interval_dtype� is_list_like� is_number�is_object_dtype� is_scalar)� IntervalDtype)�is_valid_na_for_dtype)�unique)� IntervalArray�_interval_shared_docs)�is_valid_positional_slice)�Index�_index_shared_docs� ensure_index�maybe_extract_name)� DatetimeIndex� date_range)�ExtensionIndex� inherit_names)� MultiIndex)�TimedeltaIndex�timedelta_range� IntervalIndexz"IntervalIndex or list of IntervalszX name : object, optional Name to be stored in the index. )�klass�qualnameZ target_klass�namec C s� t | dt| ��}t| ttf�r"d}t|�s2t|�rB| t�dd� S t |�rR| d S t |�rht� | tj �S t dtt| ��� ���d S )N�dtype� datetime64� �nsz%cannot determine next label for type )�getattr�type� isinstancer r r r �np� timedelta64r! r � nextafter�infty� TypeError�repr)�labelr< � rJ �R/home/digitalm-up/venv/lib/python3.7/site-packages/pandas/core/indexes/interval.py�_get_next_labelm s rL c C s� t | dt| ��}t| ttf�r"d}t|�s2t|�rB| t�dd� S t |�rR| d S t |�rjt� | tj �S t dtt| ��� ���d S )Nr< r= r> r? z%cannot determine next label for type )r@ rA rB r r r r rC rD r! r rE rF rG rH )rI r< rJ rJ rK �_get_prev_label{ s rM c C s | j f |�S )zv This is called upon unpickling, rather than the default which doesn't have arguments and breaks __new__. )� from_arrays)�cls�drJ rJ rK �_new_IntervalIndex� s rQ �classz>Immutable index of intervals that are closed on the same side.r; z0.20.0zis_overlapping values � a7 Examples -------- A new ``IntervalIndex`` is typically constructed using :func:`interval_range`: >>> pd.interval_range(start=0, end=5) IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]], dtype='interval[int64, right]') It may also be constructed using one of the constructor methods: :meth:`IntervalIndex.from_arrays`, :meth:`IntervalIndex.from_breaks`, and :meth:`IntervalIndex.from_tuples`. See further examples in the doc strings of ``interval_range`` and the mentioned constructor methods. )r9 �summaryr; Z versionaddedZextra_attributesZ extra_methods�examplesZ set_closedZ to_tuplesT)�wrapZ __array__�overlaps�contains� closed_left� closed_right� open_left� open_rightZis_empty� is_non_overlapping_monotonic�closed)�cachec sV e Zd ZU dZded< ded< ded< ded< ded < ded < d ZeZd�ddddd d�dd�Ze e e d d e � d�d� �d�ddddd d�dd���Ze e e d d e � d�d� �d�ddddd d�d d ���Ze e e d d e � d �d� �d�ddddd d�d d!���Zed"d#�d$d%��Zd&dd'�d(d)�Zed*d#�d+d,��Zd-d.� Zedd#�d/d0��Ze ejj�d�dd1d2�d3d4��Zedd#�d5d6��Zedd#�d7d8��Z edd#�d9d:��Z dd#�d;d<�Z d=d>� Z d�dd@�dAdB�Z d�dCdDdE�dFdG�Z!d�dHdCdIdJdKdL�dMdN�Z"e e#dO e$ �dHdPdQ�dRdS��Z%dHdPdQ�dTdU�Z&edd#�dVdW��Z'dXZ(dYddZ�� fd[d\� Z)dd#�d]d^�Z*e+j,fdd@�d_d`�Z-daddb�dcdd�Z.edHd#�dedf��Z/edHd#�dgdh��Z0edHd#�didj��Z1edHd#�dkdl��Z2d�dnddndo�dpdq�Z3d�� fdrds� Z4d�dd#�dtdu�Z5dvdw� Z6d d dx�dydz�Z7d d dx�d{d|�Z8edd#�d}d~��Z9dKd#�dd��Z:d�d�� Z;� Z<S )�r8 Z intervalindex�strr^ �boolr] rY rZ r* �_dataZ_valuesFNTz Dtype | Noner )r< �copyr; �verify_integrity�returnc C sB t ||| �}td| j�� t|||||d�}W d Q R X | �||�S )Nr* )r^ rc r< rd )r0 r �__name__r* � _simple_new)rO �datar^ r< rc r; rd �arrayrJ rJ rK �__new__� s zIntervalIndex.__new__� from_breaksz� Examples -------- >>> pd.IntervalIndex.from_breaks([0, 1, 2, 3]) IntervalIndex([(0, 1], (1, 2], (2, 3]], dtype='interval[int64, right]') )r9 rU �right)r^ r; rc r< re c C s8 t d| j�� tj||||d�}W d Q R X | j||d�S )Nr* )r^ rc r< )r; )r rf r* rk rg )rO �breaksr^ r; rc r< ri rJ rJ rK rk � s zIntervalIndex.from_breaksrN z� Examples -------- >>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3]) IntervalIndex([(0, 1], (1, 2], (2, 3]], dtype='interval[int64, right]') c C s: t d| j�� tj|||||d�}W d Q R X | j||d�S )Nr* )rc r< )r; )r rf r* rN rg )rO �leftrl r^ r; rc r< ri rJ rJ rK rN s zIntervalIndex.from_arrays� from_tuplesz� Examples -------- >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)]) IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]') c C s8 t d| j�� tj||||d�}W d Q R X | j||d�S )Nr* )r^ rc r< )r; )r rf r* ro rg )rO rh r^ r; rc r< �arrrJ rJ rK ro # s zIntervalIndex.from_tuplesr )re c C s( | � | j�}| � | j�}t||| jd�S )N)r^ )�_maybe_convert_i8rn rl r r^ )�selfrn rl rJ rJ rK �_engineA s zIntervalIndex._enginer )�keyre c C sP t |� t|t�s(t|| j�r$| jS dS y| �|� dS tk rJ dS X dS )z� return a boolean if this key is IN the index We *only* accept an Interval Parameters ---------- key : Interval Returns ------- bool FTN)�hashrB r r( r< �hasnans�get_loc�KeyError)rr rt rJ rJ rK � __contains__G s zIntervalIndex.__contains__r5 c C s t j| j| jgddgd�S )Nrn rl )�names)r5 rN rn rl )rr rJ rJ rK � _multiindex` s zIntervalIndex._multiindexc C s2 | j | j| jd�}|�| �� � tt| �|fd fS )N)rn rl r^ )rn rl r^ �updateZ_get_attributes_dictrQ rA )rr rP rJ rJ rK � __reduce__d s zIntervalIndex.__reduce__c C s dS )z4Return a string of the type inferred from the values�intervalrJ )rr rJ rJ rK � inferred_typei s zIntervalIndex.inferred_type�int)�deepre c C s | j j|d�| jj|d� S )N)r� )rn � memory_usagerl )rr r� rJ rJ rK r� n s zIntervalIndex.memory_usagec C s | ddd� j S )z� Return True if the IntervalIndex is monotonic decreasing (only equal or decreasing values), else False N���)�is_monotonic_increasing)rr rJ rJ rK �is_monotonic_decreasingv s z%IntervalIndex.is_monotonic_decreasingc C s� | j }| j}| �� �� dkr dS |js,|jr0dS t� }t�|jdd��d }x2|D ]*}|| || f}||krrdS |� |� qRW dS )zX Return True if the IntervalIndex contains unique elements, else False. r> FT)Zkeepr ) rn rl �isna�sum� is_unique�setrC �whereZ duplicated�add)rr rn rl Z seen_pairsZ check_idx�idx�pairrJ rJ rK r� ~ s zIntervalIndex.is_uniquec C s | j jS )a� Return True if the IntervalIndex has overlapping intervals, else False. Two intervals overlap if they share a common point, including closed endpoints. Intervals that only have an open endpoint in common do not overlap. Returns ------- bool Boolean indicating if the IntervalIndex has overlapping intervals. See Also -------- Interval.overlaps : Check whether two Interval objects overlap. IntervalIndex.overlaps : Check an IntervalIndex elementwise for overlaps. Examples -------- >>> index = pd.IntervalIndex.from_tuples([(0, 2), (1, 3), (4, 5)]) >>> index IntervalIndex([(0, 2], (1, 3], (4, 5]], dtype='interval[int64, right]') >>> index.is_overlapping True Intervals that share closed endpoints overlap: >>> index = pd.interval_range(0, 3, closed='both') >>> index IntervalIndex([[0, 1], [1, 2], [2, 3]], dtype='interval[int64, both]') >>> index.is_overlapping True Intervals that only have an open endpoint in common do not overlap: >>> index = pd.interval_range(0, 3, closed='left') >>> index IntervalIndex([[0, 1), [1, 2), [2, 3)], dtype='interval[int64, left]') >>> index.is_overlapping False )rs �is_overlapping)rr rJ rJ rK r� � s 0z IntervalIndex.is_overlappingc C s4 t |�st|t�r | �|j�S ttttf}t||�S )a Check if a given key needs i8 conversion. Conversion is necessary for Timestamp, Timedelta, DatetimeIndex, and TimedeltaIndex keys. An Interval-like requires conversion if its endpoints are one of the aforementioned types. Assumes that any list-like data has already been cast to an Index. Parameters ---------- key : scalar or Index-like The key that should be checked for i8 conversion Returns ------- bool ) r" rB r �_needs_i8_conversionrn r r r1 r6 )rr rt Zi8_typesrJ rJ rK r� � s z"IntervalIndex._needs_i8_conversionc C s |}t |�rt|�}| �|�s"|S t|�}t|�s<t|t�rr| �|j�}| �|j �}|r\tnt j }|||| j d�S |r�t |dd�\}}t�|�r�|j}q�t|t�r�|j}q�t|tjtjf�r�|�d�}n&|jt|j� }}|jr�|�|j �}| jj } t | |��st d| � d|� ���|S )a Maybe convert a given key to its equivalent i8 value(s). Used as a preprocessing step prior to IntervalTree queries (self._engine), which expects numeric data. Parameters ---------- key : scalar or list-like The key that should maybe be converted to i8. Returns ------- scalar or list-like The original key if no conversion occurred, int if converted scalar, Int64Index if converted list-like. )r^ T)Z pandas_dtype�i8z)Cannot index an IntervalIndex of subtype z with values of dtype ) r# r/ r� r& r" rB r rq rn rl r8 rN r^ r r Z is_periodZordinalr �valuerC r= rD �viewr< r- Zasi8rv r� Z_isnan�subtyper � ValueError) rr rt �originalZscalarrn rl � constructorZ key_dtypeZkey_i8r� rJ rJ rK rq � s6 z IntervalIndex._maybe_convert_i8rn )�sidec C sz | j std��t|ttf�r$td��|dkr4| jjsD|dkrZ| jjsZ| j}| j rnt |�}n| j}| j rnt |�}|� ||�S )Nzrcan only get slices from an IntervalIndex if bounds are non-overlapping and all monotonic increasing or decreasingz,Interval objects are not currently supportedrn rl )r] rx rB r r8 �NotImplementedErrorrn r� rl r\ rL r[ rM �_searchsorted_monotonic)rr rI r� Zsub_idxrJ rJ rK r� s z%IntervalIndex._searchsorted_monotonicz str | Nonezint | slice | np.ndarray)�methodre c C s8 | � |� t|�st|��t|t�rR| j|jkr8t|��| j|jk| j|jk@ }n|t || j �rh| � � }nf| j rrt nt}| jr�t nt}y || j|�||| j�@ }W n, tk r� } zt|�|�W dd}~X Y nX |�� }|dkr�t|��n|dkr�|�� S t�|�d��} t| t��r4| jdk�r4t| jt| �| j�} | S )a Get integer location, slice or boolean mask for requested label. Parameters ---------- key : label method : {None}, optional * default: matches where the label is within an interval only. Returns ------- int if unique index, slice if monotonic index, else mask Examples -------- >>> i1, i2 = pd.Interval(0, 1), pd.Interval(1, 2) >>> index = pd.IntervalIndex([i1, i2]) >>> index.get_loc(1) 0 You can also supply a point inside an interval. >>> index.get_loc(1.5) 1 If a label is in several intervals, you get the locations of all the relevant intervals. >>> i3 = pd.Interval(0, 2) >>> overlapping_index = pd.IntervalIndex([i1, i2, i3]) >>> overlapping_index.get_loc(0.5) array([ True, False, True]) Only exact matches will be returned if an interval is provided. >>> index.get_loc(pd.Interval(0, 1)) 0 Nr r> �u1)Z_check_indexing_methodr& r rB r r^ rx rn rl r( r< r� rY r r rZ rG r� Zargmaxr Zmaybe_booleans_to_slicer� �slice�stop�start�len�step) rr rt r� � tolerance�maskZop_leftZop_right�err�matches�resrJ rJ rK rw 9 s0 ) zIntervalIndex.get_locr- z int | Nonez Any | Nonez np.ndarray)�targetr� �limitr� re c C s� t |t�rp| �|�r&tjt| �dd�S | �|�s@| j||dd�S | j� |j�}| j � |j �}t� ||k|d�}n0t |�s�| � |�}| j� |j�}n| �|�d S t|�S )N�intp)r< T)r) r� r )rB r8 �equalsrC �aranger� �_should_compare�_get_indexer_non_comparablern � get_indexerrl r� r% rq rs �values�_get_indexer_pointwiser )rr r� r� r� r� Z left_indexerZ right_indexer�indexerrJ rJ rK � _get_indexer� s zIntervalIndex._get_indexer�get_indexer_non_uniquez tuple[np.ndarray, np.ndarray])r� re c C sv t |�}t|t�r,| �|�s,| j|d dd�S t|j�s@t|t�rJ| �|�S | �|�}| j � |j �\}}t |�t |�fS )NF)r) ) r/ rB r8 r� r� r% r< r� rq rs r� r� r )rr r� r� �missingrJ rJ rK r� � s z$IntervalIndex.get_indexer_non_uniquec C s� g g }}x�t |�D ]�\}}y>| �|�}t|t�rJtj|j|j|jdd�}tj |dd�}W nR t k r� |� |� t� dg�}Y n* t k r� |� |� t� dg�}Y nX |� |� qW t� |�}t|�t|�fS )zV pointwise implementation for get_indexer and get_indexer_non_unique. r� )r< r> )Zndminr� )� enumeraterw rB r� rC r� r� r� r� ri rx �appendr Z concatenater )rr r� r� r� �irt ZlocsrJ rJ rK r� � s z$IntervalIndex._get_indexer_pointwisec C s | j o| jjdk S )N� )r� rs Z _na_count)rr rJ rJ rK �_index_as_unique� s z IntervalIndex._index_as_uniquezKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquer� )rt �kindc sP |j d ksB|j dksBd}|dkr*t|��n|dkrBt|�sBt|��t� �||�S )Nr> zClabel-based slicing with step!=1 is not supported for IntervalIndex�loc�getitem)r� r� r, �super�_convert_slice_indexer)rr rt r� �msg)� __class__rJ rK r� � s z$IntervalIndex._convert_slice_indexerc C s | j jjdkS )N)�m�M)r< r� r� )rr rJ rJ rK � _should_fallback_to_positional� s z,IntervalIndex._should_fallback_to_positionalc C s | � |dd� t| |��||�S )Nr� �_maybe_cast_slice_bound)Z_deprecated_argr@ r� )rr rI r� r� rJ rJ rK r� � s z%IntervalIndex._maybe_cast_slice_boundr )r< re c C s& t |t�sdS t| j|g�}t|� S )NF)rB r' r r< r% )rr r< Zcommon_subtyperJ rJ rK �_is_comparable_dtype� s z"IntervalIndex._is_comparable_dtypec C s t | jjdd�S )NF)rc )r- rb rn )rr rJ rJ rK rn � s zIntervalIndex.leftc C s t | jjdd�S )NF)rc )r- rb rl )rr rJ rJ rK rl s zIntervalIndex.rightc C s t | jjdd�S )NF)rc )r- rb �mid)rr rJ rJ rK r� s zIntervalIndex.midc C s t | jjdd�S )NF)rc )r- rb �length)rr rJ rJ rK r� s zIntervalIndex.length�NaNz list[str])�header�na_repre c C s |t | j|d�� S )N)r� )�list�_format_native_types)rr r� r� rJ rJ rK �_format_with_header s z!IntervalIndex._format_with_headerc s t � jf ||d�|��S )N)r� �quoting)r� r� )rr r� r� �kwargs)r� rJ rK r� s z"IntervalIndex._format_native_typesc C s | j �� d | �� S )N�,)rb � _format_dataZ _format_space)rr r; rJ rJ rK r� s zIntervalIndex._format_datac C sf | j jr | jjr | �|�}n6|j jrH|jjrH| �� �� dkrH|�| �}n | �|�}|dkrb|�� }|S )zL intersection specialized to the case with matching dtypes. r> N)rn r� rl �_intersection_uniquer� r� �_intersection_non_uniqueZ sort_values)rr �other�sortZtakenrJ rJ rK � _intersection s zIntervalIndex._intersection)r� re c C sP | j �|j �}| j�|j�}||k|dk@ }|�|�� d �}t|�}| �|�S )a' Used when the IntervalIndex does not have any common endpoint, no matter left or right. Return the intersection with another IntervalIndex. Parameters ---------- other : IntervalIndex Returns ------- IntervalIndex r� r )rn r� rl ZtakeZnonzeror) )rr r� ZlindexerZrindexer�matchr� rJ rJ rK r� 3 s z"IntervalIndex._intersection_uniquec C s� t jt| �td�}| jr@|jr@t �t| ��| �� d }d||< tt|j |j ��}x.t t| j | j ��D ]\}}||krfd||< qfW | | S )a Used when the IntervalIndex does have some common endpoints, on either sides. Return the intersection with another IntervalIndex. Parameters ---------- other : IntervalIndex Returns ------- IntervalIndex )r< r T) rC Zzerosr� ra rv r� r� r� �ziprn rl r� )rr r� r� Z first_nan_locZ other_tupsr� �tuprJ rJ rK r� I s z&IntervalIndex._intersection_non_uniquec C s dS )z� This is False even when left/right contain datetime-like objects, as the check is done on the Interval itself FrJ )rr rJ rJ rK � _is_all_datesh s zIntervalIndex._is_all_datesc C s t t| j| j��}t|�}|S )N)r� r� rn rl r )rr Ztupsr� rJ rJ rK �_get_join_targetp s z IntervalIndex._get_join_targetc C s@ t t|� �\}}t| j�j||| j| jd�}t| �j|| jd�S )N)r< r^ )r; ) r� r� rA rb rN r< r^ rg r; )rr �resultrn rl rp rJ rJ rK �_from_join_targetv s z IntervalIndex._from_join_target)NNFNT)rl NFN)rl NFN)rl NFN)F)rn )NN)NNN)r� )r� N)N)=rf � __module__� __qualname__Z_typ�__annotations__Z_can_hold_stringsr* Z _data_clsrj � classmethodr r+ �textwrap�dedentrk rN ro r rs ry r{ r} �propertyr r- r� �__doc__r� r� r� r� rq r� rw r� r. �_index_doc_kwargsr� r� r� Z_requires_unique_msgr� r� r Z no_defaultr� r� rn rl r� r� r� r� r� r� r� r� r� r� r� � __classcell__rJ rJ )r� rK r8 � s� . 2< L ra )re c C s$ t t| �t| t�t| t�| dkg�S )zJ Helper for interval_range to check if start/end are valid types. N)�anyr$ rB r r )�endpointrJ rJ rK �_is_valid_endpoint� s r� c C sL dd� }dd� }t | �r t |�pJ|| �r0||�pJ|| �r@||�pJt�| |�S )zK Helper for interval_range to check type compat of start/end/freq. c S s t | ttf�S )N)rB r r )�xrJ rJ rK �<lambda>� � z%_is_type_compatible.<locals>.<lambda>c S s t | ttf�S )N)rB r r )r� rJ rJ rK r� � r� )r$ �com�any_none)�a�bZ is_ts_compatZ is_td_compatrJ rJ rK �_is_type_compatible� s r� rl r )r; re c C sN t | �} t |�}| dk r | n|}|dkrFt�|| |�rFt|�rBdnd}t�| |||�dkrbtd��t| �sztd| � ���nt|�s�td|� ���t|�r�t|�}n t |�s�|dk r�t d|� ���|dk �rt|��sy t |�}W n4 tk �r } ztd |� ��|�W dd}~X Y nX t t | |�t | |�t ||�g��s@t d ��|dk �rR|d7 }t|��rt�| ||��r|||| | 8 }|dk�r�t|| | �d }n6| dk�r�||d | } n|dk�r�| |d | }t�| ||�}t d d � t�| ||�D ���r>t|t�d ��}n.t|t��r.t| |||d�}nt| |||d�}tj|||d�S )aP Return a fixed frequency IntervalIndex. Parameters ---------- start : numeric or datetime-like, default None Left bound for generating intervals. end : numeric or datetime-like, default None Right bound for generating intervals. periods : int, default None Number of periods to generate. freq : numeric, str, or DateOffset, default None The length of each interval. Must be consistent with the type of start and end, e.g. 2 for numeric, or '5H' for datetime-like. Default is 1 for numeric and 'D' for datetime-like. name : str, default None Name of the resulting IntervalIndex. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. Returns ------- IntervalIndex See Also -------- IntervalIndex : An Index of intervals that are all closed on the same side. Notes ----- Of the four parameters ``start``, ``end``, ``periods``, and ``freq``, exactly three must be specified. If ``freq`` is omitted, the resulting ``IntervalIndex`` will have ``periods`` linearly spaced elements between ``start`` and ``end``, inclusively. To learn more about datetime-like frequency strings, please see `this link <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__. Examples -------- Numeric ``start`` and ``end`` is supported. >>> pd.interval_range(start=0, end=5) IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]], dtype='interval[int64, right]') Additionally, datetime-like input is also supported. >>> pd.interval_range(start=pd.Timestamp('2017-01-01'), ... end=pd.Timestamp('2017-01-04')) IntervalIndex([(2017-01-01, 2017-01-02], (2017-01-02, 2017-01-03], (2017-01-03, 2017-01-04]], dtype='interval[datetime64[ns], right]') The ``freq`` parameter specifies the frequency between the left and right. endpoints of the individual intervals within the ``IntervalIndex``. For numeric ``start`` and ``end``, the frequency must also be numeric. >>> pd.interval_range(start=0, periods=4, freq=1.5) IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]], dtype='interval[float64, right]') Similarly, for datetime-like ``start`` and ``end``, the frequency must be convertible to a DateOffset. >>> pd.interval_range(start=pd.Timestamp('2017-01-01'), ... periods=3, freq='MS') IntervalIndex([(2017-01-01, 2017-02-01], (2017-02-01, 2017-03-01], (2017-03-01, 2017-04-01]], dtype='interval[datetime64[ns], right]') Specify ``start``, ``end``, and ``periods``; the frequency is generated automatically (linearly spaced). >>> pd.interval_range(start=0, end=6, periods=4) IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]], dtype='interval[float64, right]') The ``closed`` parameter specifies which endpoints of the individual intervals within the ``IntervalIndex`` are closed. >>> pd.interval_range(end=5, periods=4, closed='both') IntervalIndex([[1, 2], [2, 3], [3, 4], [4, 5]], dtype='interval[int64, both]') Nr> �D� zVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedz,start must be numeric or datetime-like, got z*end must be numeric or datetime-like, got z periods must be a number, got z7freq must be numeric or convertible to DateOffset, got z+start, end, freq need to be type compatiblec s s | ]}t |�V qd S )N)r )�.0r� rJ rJ rK � <genexpr>2 s z!interval_range.<locals>.<genexpr>Zint64)r� �end�periods�freq)r; r^ )r r� r� r$ Zcount_not_noner� r� r r� r rG r �allr� Z all_not_nonerC ZlinspaceZnot_noner r< rB r r2 r7 r8 rk ) r� r� r� r� r; r^ r� r� rm rJ rJ rK �interval_range� s^ Y r� )NNNNNrl )br� � __future__r �operatorr r r� �typingr r �numpyrC Z pandas._libsr Zpandas._libs.intervalr r r Zpandas._libs.tslibsr r r r Zpandas._typingr r Z pandas.errorsr Zpandas.util._decoratorsr r Zpandas.util._exceptionsr Zpandas.core.dtypes.castr r r r r Zpandas.core.dtypes.commonr r r r r r r r! r" r# r$ r% r& Zpandas.core.dtypes.dtypesr' Zpandas.core.dtypes.missingr( Zpandas.core.algorithmsr) Zpandas.core.arrays.intervalr* r+ Zpandas.core.common�core�commonr� Zpandas.core.indexersr, Zpandas.core.indexes.baseZindexes�baseZibaser- r. r/ r0 Z pandas.core.indexes.datetimesr1 r2 Z pandas.core.indexes.extensionr3 r4 Zpandas.core.indexes.multir5 Z pandas.core.indexes.timedeltasr6 r7 �dictr� r| r� rL rM rQ r8 r� r� r� rJ rJ rJ rK �<module> s� < G
| ver. 1.4 |
Github
|
.
| PHP 8.3.23 | Генерация страницы: 0.03 |
proxy
|
phpinfo
|
Настройка