U
|
¬ý°dt ã @ sº d Z ddlmZ ddlmZmZ ddlZddlmZm Z m
|
Z
|
ddl Z ddl mZ ddlmZmZmZ ddlmZmZmZmZ dd lmZmZmZm Z dd
|
l m Z 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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7 ddl8m9Z9 ddl:m;Z; ddl<m=Z= ddl>m?Z?m@Z@ ddlAmB mCZD ddlEmFZF ddlGmB mH mIZJ ddlGmKZKmLZLmMZMmNZN ddlOmPZPmQZQ ddlRmSZSmTZT ddlUmVZV ddlWmXZXmYZY eZeJj[Z[e[ \ddde ]d¡d ¡ d d Z^d d Z_d!d" Z`e e@d# dd$e[d% d&d'd(e ]d)¡d* eTd+d,ge?d-d.eTd/d0d1d2d3d4d5d6ge?eTd7d8ge?d-d9G d:d deSZad;d<d=d>Zbd;d<d?d@ZcdGdBdCddDdEdFZddS )Hz define the IntervalIndex é )Ú annotations)ÚleÚltN)ÚAnyÚHashableÚLiteral)Úlib)ÚIntervalÚ IntervalMixinÚ IntervalTree)Ú
|
BaseOffsetÚ TimedeltaÚ TimestampÚ to_offset)ÚDtypeÚDtypeObjÚIntervalClosedTypeÚnpt)ÚInvalidIndexError)ÚAppenderÚcache_readonly)Úrewrite_exception)Úfind_common_typeÚinfer_dtype_from_scalarÚmaybe_box_datetimelikeÚmaybe_downcast_numericÚ maybe_upcast_numeric_to_64bit) Ú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| ttfr"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" Z nextafterZinftyÚ TypeErrorÚrepr©ÚlabelrA © rO úSd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/indexes/interval.pyÚ_get_next_labelp s rQ c C s t | dt| }t| ttfr"d}t|s2t|rB| t dd¡ S t |rR| d S t
|
|rjt | tj ¡S t dtt| d S r@ rE rM rO rO rP Ú_get_prev_label~ s rR 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ÚdrO rO rP Ú_new_IntervalIndex s rV Ú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.
|
)r= Ú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 s e Zd ZU dZded< ded< ded< ded< ded< ded < d
|
ed < d
|
ed < d ZeZdddddd dddZe e
|
e d d e d¡e d¡d dddddd dd d Ze e
|
e d d e d¡e d ¡d dddddd dd d!Ze e
|
e d" d e d¡e d#¡d dddddd dd$d%Zed&d'd(d)Zd*dd+d,d-Zed.d'd/d0Zd1d2 Zed3d'd4d5Ze
|
ejjddd6d7d8d9Zedd'd:d;Zedd'd<d=Z edd'd>d?Z dd'd@dAZ dBdC Z ddEdFdGdHZ dId'dJdKZ!ddLdMdNdOdPdQdRdSZ"e
|
e#dT e$ dLdUdVdWdXZ%d dPdVdYdZZ&dLdUdVd[d\Z'edd'd]d^Z(d_Z)d`d3da fdbdc Z*edd'dddeZ+d3dFdfdgZ,dhddidjdkZ-edLd'dldmZ.edLd'dndoZ/edLd'dpdqZ0edLd'drdsZ1dtd3dtdudvdwZ2dxddyd3dzd{ fd|d}Z3dd3d'd~dZ4dd Z5d d dddZ6d d dd
dZ7dd'ddZ8dd Z9 Z:S )r< Z intervalindexr rc Úboolrb r^ r_ r` ra r. Ú_dataZ_valuesFNTz Dtype | Noner )rA Úcopyr? Úverify_integrityÚreturnc C sB t ||| }td| j t|||||d}W 5 Q R X | ||¡S )Nr. )rc rg rA rh )r4 r Ú__name__r. Ú _simple_new)rT Údatarc rA rg r? rh ÚarrayrO rO rP Ú__new__Ô s ûzIntervalIndex.__new__Ú from_breakszY
|
name : str, optional
|
Name of the resulting IntervalIndex.zÇ Examples
|
--------
|
>>> pd.IntervalIndex.from_breaks([0, 1, 2, 3])
|
IntervalIndex([(0, 1], (1, 2], (2, 3]],
|
dtype='interval[int64, right]')
|
)r= r? rZ ÚrightzIntervalClosedType | None)rc r? rg rA ri c C s8 t d| j tj||||d}W 5 Q R X | j||dS ©Nr. )rc rg rA ©r? )r rj r. ro rk )rT Úbreaksrc r? rg rA rm rO rO rP ro ê s ÿzIntervalIndex.from_breaksrS 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 5 Q R X | j||dS )Nr. )rg rA rr )r rj r. rS rk )rT Úleftrp rc r? rg rA rm rO rO rP rS 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 5 Q R X | j||dS rq )r rj r. ru rk )rT rl rc r? rg rA ZarrrO rO rP ru 1 s zIntervalIndex.from_tuplesr ©ri c C s8 | | j¡}t|}| | j¡}t|}t||| jdS )N©rc )Ú_maybe_convert_i8rt r rp r rc )Úselfrt rp rO rO rP Ú_engineU s
|
zIntervalIndex._enginer )Úkeyri c C sT t | t|ts(t|| jr$| jS dS z| |¡ W dS tk
|
rN Y 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)ÚhashrH r r+ rA ÚhasnansÚget_locÚKeyError)ry r{ rO rO rP Ú __contains__^ s
|
|
zIntervalIndex.__contains__r9 c C s t j| j| jgddgdS )Nrt rp )Únames)r9 rS rt rp ©ry rO rO rP Ú _multiindexw s zIntervalIndex._multiindexc C s( | j | j| j| jd}tt| |fd fS )N)rt rp rc r? )rt rp rc r? rV rG )ry rU rO rO rP Ú
|
__reduce__{ s üzIntervalIndex.__reduce__Ústrc C s dS )z4Return a string of the type inferred from the valuesÚintervalrO r rO rO rP Ú inferred_type s zIntervalIndex.inferred_typeÚint)Údeepri c C s | j j|d| jj|d S )N)r )rt Ú memory_usagerp )ry r rO rO rP r 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_increasingr rO rO rP Úis_monotonic_decreasing s z%IntervalIndex.is_monotonic_decreasingc C s | j }| j}| ¡ ¡ dkr dS |js,|jr0dS t }t |jdd¡d }|D ],}|| || f}||krr dS | |¡ qPdS )zX
|
Return True if the IntervalIndex contains unique elements, else False.
|
rC FT)Zkeepr )
|
rt rp ÚisnaÚsumÚ is_uniqueÚsetrI ÚwhereZ
|
duplicatedÚadd)ry rt rp Z
|
seen_pairsZ check_idxÚidxÚpairrO rO rP 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
|
)rz Úis_overlappingr rO rO rP r ² s 0z IntervalIndex.is_overlappingc C s4 t |st|tr | |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% rH r Ú_needs_i8_conversionrt r r r5 r: )ry r{ Zi8_typesrO rO rP r ä s z"IntervalIndex._needs_i8_conversionc C s t |rt|}t|}| |¡s&|S t|}t|s@t|trv| |j ¡}| |j
|
¡}|r`tnt j }|||| j dS |rÌt|dd\}}t |¡r|j}qòt|tr®|j}qòt|tjtjfrò| 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,
|
Index with an int64 dtype if converted list-like.
|
rw T)Z pandas_dtypeÚi8z)Cannot index an IntervalIndex of subtype z with values of dtype )!r& r3 r r r) r% rH r rx rt rp r< rS rc r r Z is_periodZordinalr Ú_valuerI rB rJ ÚviewrA r1 Zasi8r} r Z_isnanÚsubtyper Ú
|
ValueError) ry r{ Zscalarrt rp Ú constructorZ key_dtypeZkey_i8r rO rO rP rx ü s@
|
ÿ
|
|
ÿz IntervalIndex._maybe_convert_i8rt zLiteral[('left', 'right')])Úsidec C sz | j stdt|ttfr$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 supportedrt rp )rb r rH r
|
r< ÚNotImplementedErrorrt r rp ra rQ r` rR Ú_searchsorted_monotonic)ry rN r Zsub_idxrO rO rP r = s$ ÿÿÿ
|
z%IntervalIndex._searchsorted_monotoniczint | slice | np.ndarrayc
|
C s& | |¡ t|trB| j|jkr(t|| j|jk| j|jk@ }n|t|| jrX| ¡ }nf| j
|
rbt nt }| j rpt nt }z || j|||| j@ }W n, tk
|
r¼ } zt||W 5 d}~X Y nX | ¡ }|dkrÖt||dkræ| ¡ S t | d¡¡}t|tr"|jdkr"t|jt| |j}|S )a£
|
Get integer location, slice or boolean mask for requested label.
|
|
Parameters
|
----------
|
key : label
|
|
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 rC Úu1)Z_check_indexing_errorrH r rc r rt rp r+ rA r r^ r r r_ rK r Zargmaxr Zmaybe_booleans_to_slicer ÚsliceÚstopÚstartÚlenÚstep)ry r{ ÚmaskZop_leftZop_rightÚerrÚmatchesÚresrO rO rP r~ Z s, %
|
|
|
zIntervalIndex.get_locr1 z
|
str | Nonez
|
int | Nonez
|
Any | Noneznpt.NDArray[np.intp])ÚtargetÚmethodÚlimitÚ toleranceri c C sP t |tr| |¡}n2t|js:| |¡}| j |j¡}n| |¡d S t
|
|S )Nr ) rH r< Ú_get_indexer_unique_sidesr( rA rx rz Ú get_indexerÚvaluesÚ_get_indexer_pointwiser )ry r« r¬ r r® ÚindexerrO rO rP Ú _get_indexer s
|
|
|
zIntervalIndex._get_indexerÚget_indexer_non_uniquez1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])r« ri c C s¸ t |}| |¡s,| |¡s,| j|d ddS t|trn| jjrb| jjrb| |¡}|dk
|
¡ d }q¨| |¡S n:t |j s| |¡s| |¡S | |¡}| j |j¡\}}t|t|fS )NFr, r r )r3 Z_should_compareZ_should_partial_indexZ_get_indexer_non_comparablerH r< rt r rp r¯ Únonzeror² r( rA rx rz rµ r± r )ry r« r³ ÚmissingrO rO rP rµ · s
|
|
|
|
z$IntervalIndex.get_indexer_non_uniquec C s2 | j |j ¡}| j |j¡}t ||k|d¡}|S )zZ
|
_get_indexer specialized to the case where both of our sides are unique.
|
r )rt r° rp rI r )ry r« Z left_indexerZ right_indexerr³ rO rO rP r¯ Ö s z'IntervalIndex._get_indexer_unique_sidesc C sî g g }}t |D ]À\}}zZ| |¡}t|trJtj|j|j|jdd}n(t
|
|¡rdtj |dd}nt |¡d }W nR t k
|
r | |¡ t dg¡}Y n* tk
|
rÆ | |¡ t dg¡}Y nX | |¡ qt |¡}t|t|fS )zV
|
pointwise implementation for get_indexer and get_indexer_non_unique.
|
Zintp©rA rC )Zndminr r )Ú enumerater~ rH r¢ rI Úaranger¤ r£ r¦ r r# rm r r Úappendr Z concatenater )ry r« r³ r· Úir{ ZlocsrO rO rP r² â s$
|
|
|
|
|
|
|
z$IntervalIndex._get_indexer_pointwisec C s | j o| jjdk S )Né )r rz Z _na_countr rO rO rP Ú_index_as_unique s z IntervalIndex._index_as_uniquezKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquer¢ )r{ Úkindc sN |j d ks@|j dks@d}|dkr(t||dkr@t|s@t|t ||¡S )NrC zClabel-based slicing with step!=1 is not supported for IntervalIndexÚlocÚgetitem)r¦ r r0 ÚsuperÚ_convert_slice_indexer)ry r{ r¿ Úmsg©Ú __class__rO rP rÃ
|
s z$IntervalIndex._convert_slice_indexerc C s | j jjdkS )N)ÚmÚM)rA r r¿ r rO rO rP Ú _should_fallback_to_positional s z,IntervalIndex._should_fallback_to_positionalc C s t | | ||¡S ©N)rF Ú_maybe_cast_slice_bound)ry rN r rO rO rP rË s z%IntervalIndex._maybe_cast_slice_boundr )rA ri c C s& t |tsdS t| j|g}t| S )NF)rH r* r rA r( )ry rA Zcommon_subtyperO rO rP Ú_is_comparable_dtype# s
|
z"IntervalIndex._is_comparable_dtypec C s t | jjddS ©NF)rg )r1 rf rt r rO rO rP rt + s zIntervalIndex.leftc C s t | jjddS rÍ )r1 rf rp r rO rO rP rp / s zIntervalIndex.rightc C s t | jjddS rÍ )r1 rf Úmidr rO rO rP rÎ 3 s zIntervalIndex.midc C s t | jjddS rÍ )r1 rf Úlengthr rO rO rP rÏ 7 s zIntervalIndex.lengthz list[str])ÚheaderÚna_repri c C s |t | j|d S )N)rÑ )ÚlistÚ_format_native_types)ry rÐ rÑ rO rO rP Ú_format_with_header? s z!IntervalIndex._format_with_headerÚNaN©rÑ Úquotingznpt.NDArray[np.object_])rÑ ri c s t jf ||d|S )NrÖ )r rÓ )ry rÑ r× ÚkwargsrÅ rO rP rÓ C s z"IntervalIndex._format_native_typesc C s | j ¡ d| ¡ S )Nú,)rf Ú _format_dataZ _format_space)ry r? rO rO rP rÚ I 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.
|
rC N)rt r rp Ú_intersection_uniquer r Ú_intersection_non_uniqueZ sort_values)ry ÚotherÚsortZtakenrO rO rP Ú _intersectionQ s
|
zIntervalIndex._intersection)rÝ ri 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 )rt r° rp Ztaker¶ r- )ry rÝ ZlindexerZrindexerÚmatchr³ rO rO rP rÛ e s z"IntervalIndex._intersection_uniquec C s t jt| td}| jr@|jr@t t| ¡| ¡ d }d||< tt|j |j
|
}t t| j | j
|
D ]\}}||krdd||< qd| | 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) rI Úzerosr¥ re r} rº r r Úziprt rp r¹ )ry rÝ r§ Z first_nan_locZ
|
other_tupsr¼ ÚtuprO rO rP rÜ { s
|
z&IntervalIndex._intersection_non_uniquez
|
np.ndarrayc C s t dd S )NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objects©r r rO rO rP Ú_get_engine_target s ÿz IntervalIndex._get_engine_targetc C s t dd S )Nz,IntervalIndex does not use libjoin fastpathsrä )ry ÚresultrO rO rP Ú_from_join_target£ s z IntervalIndex._from_join_target)NNFNT)rp NFN)rp NFN)rp NFN)F)rt )NNN)N);rj Ú
|
__module__Ú __qualname__Z_typÚ__annotations__Z_can_hold_stringsr. Z _data_clsrn Ú classmethodr r/ ÚtextwrapÚdedentro rS ru r rz r r r Úpropertyr r1 r Ú__doc__r r r r rx r r~ r´ r2 Ú_index_doc_kwargsrµ r¯ r² r¾ Z_requires_unique_msgrà rÉ rË rÌ rt rp rÎ rÏ rÔ rÓ rÚ rß rÛ rÜ rå rç Ú __classcell__rO rO rÅ rP r< sü
|
. ùÿÿùÿÿ ú ÿÿùÿÿ ù ÿÿùÿÿ ú
|
1A F û ÿ ÿ re rv c C s$ t t| t| tt| t| dkgS )zJ
|
Helper for interval_range to check if start/end are valid types.
|
N)Úanyr' rH r r )ÚendpointrO rO rP Ú_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 | ttfS rÊ )rH r r ©ÚxrO rO rP Ú<lambda>» ó z%_is_type_compatible.<locals>.<lambda>c S s t | ttfS rÊ )rH r r rõ rO rO rP r÷ ¼ rø )r' ÚcomÚany_none)ÚaÚbZ is_ts_compatZ is_td_compatrO rO rP Ú_is_type_compatible· s ÿþ
|
ürý rp r r )r? rc ri c
|
C sL t | } t |}| dk r | n|}|dkrFt || |¡rFt|rBdnd}t | |||¡dkrbtdt| sxtd| t|std| t|r t|}n t |s¾|dk r¾t
|
d| |dk rt|sz t |}W n4 tk
|
r } ztd | |W 5 d}~X Y nX t t | |t | |t ||gs>t
|
d
|
|dk rP|d7 }t|rt | ||¡rz||| | 8 }|dkrt|| | d }n6| dkr¶||d | } n|dkrÐ| |d | }t | ||¡}t d d t | ||¡D r<t|t d ¡}n.t|tr,t| |||d}nt| |||d}tj|||dS )ad
|
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, datetime.timedelta, 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]')
|
NrC Ú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 rÊ )r# )Ú.0rö rO rO rP Ú <genexpr>` s z!interval_range.<locals>.<genexpr>Úint64)r¤ ÚendÚperiodsÚfreq)r? rc )r rù rú r' Zcount_not_noner rô r! r r# rK r Úallrý Z all_not_nonerI ZlinspaceZnot_noner rA rH r r6 r; r< ro ) r¤ r r r r? rc ró r¨ rs rO rO rP Úinterval_rangeÅ sl ^ÿ
|
ÿþýÿ
|
|
|
|
|
þ r )NNNNNrp )erï Ú
|
__future__r Úoperatorr r rì Útypingr r r ÚnumpyrI Z pandas._libsr Zpandas._libs.intervalr r
|
r Zpandas._libs.tslibsr r r r Zpandas._typingr r r 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.indexersr0 Zpandas.core.indexes.baseZindexesÚbaseZibaser1 r2 r3 r4 Z pandas.core.indexes.datetimesr5 r6 Z pandas.core.indexes.extensionr7 r8 Zpandas.core.indexes.multir9 Z pandas.core.indexes.timedeltasr: r; Údictrð Úupdaterí rQ rR rV r< rô rý r rO rO rO rP Ú<module> s¤ <
|
ÿüÿÿùÿÿ ø
|
õ m ú
|
