Ë
|
nñúhf ã ól d Z ddlmZ ddlmZmZ ddlZddlmZm Z m
|
Z
|
ddl Z ddl mZ ddlmZmZmZ ddlmZmZmZmZmZ dd lmZ dd
|
lm Z m Z dd l m Z dd l m!Z!m"Z"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/m0Z0 ddl1m2Z2m3Z3 ddl4m5Z5 ddl6m7Z7 ddl8m9Z9 ddl:m;Z;m<Z< ddl=m>c m?Z@ ddlAmBZB ddlCm>c mDc mEZF ddlCmGZGmHZHmIZImJZJ ddlKmLZLmMZM ddlNmOZOmPZP ddlQmRZR ddlSmTZTmUZU erddlVmWZW ddlXmYZYmZZZm[Z[m\Z\m]Z] e^eFj¾ « Z_e_jÁ ddd ej d « d « d Zbd Zcd! Zd e e<d" dd#e_d$ d%d& ej d'« d(z « ePd)d*ge;d+¬,« ePg d-¢e;« ePd.d/ge;d+¬0« G d1 deO« « « « « Zed5d2Zfd5d3Zg d6 d7d4Zhy)8z define the IntervalIndex é )Ú annotations)ÚleÚltN)Ú TYPE_CHECKINGÚAnyÚLiteral)Úlib)ÚIntervalÚ IntervalMixinÚ IntervalTree)Ú
|
BaseOffsetÚPeriodÚ TimedeltaÚ TimestampÚ to_offset)Ú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_float_dtypeÚ
|
is_integerÚis_integer_dtypeÚ is_list_likeÚ is_numberÚis_object_dtypeÚ is_scalarÚis_string_dtypeÚ pandas_dtype)ÚDatetimeTZDtypeÚ IntervalDtype)Úis_valid_na_for_dtype©Úunique)Úvalidate_periods)Ú 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)ÚHashable)ÚDtypeÚDtypeObjÚIntervalClosedTypeÚSelfÚnptÚ IntervalIndexz"IntervalIndex or list of IntervalszX name : object, optional
|
Name to be stored in the index.
|
)ÚklassÚqualnameÚ target_klassÚnamec ó° t | dt | « « }t | t t f« rd}t |« }t j |d« st |t « r| t j dd« z S t |« r| dz S t |« r$t j | t j « S t dt! t | « « « ©NÚdtypezdatetime64[ns]ÚmMé Únsz%cannot determine next label for type ©ÚgetattrÚtypeÚ
|
isinstancer r r$ r Ú is_np_dtyper% ÚnpÚ timedelta64r r Ú nextafterÚinfÚ TypeErrorÚrepr©ÚlabelrF s úOH:\Change_password\venv_build\Lib\site-packages\pandas/core/indexes/interval.pyÚ_get_next_labelrX v s« ä E7¤D¨£KÓ 0EÜ%)¤YÐ/Ô0Ø Ü Ó Eä
|
udÔ#¤z°%¼ Ô'IØr~~ a¨Ó.Ñ.Ð.Ü %Ô ØqyÐÜ Ô Ü||E¤2§6¡6Ó*Ð*äÐ?ÄÄTÈ%Ã[Ó@QÐ?RÐSÓTÐTó c ó² t | dt | « « }t | t t f« rd}t |« }t j |d« st |t « r| t j dd« z
|
S t |« r| dz
|
S t |« r%t j | t j « S t dt! t | « « « rE rJ rU s rW Ú_get_prev_labelr[ s ä E7¤D¨£KÓ 0EÜ%)¤YÐ/Ô0Ø Ü Ó Eä
|
udÔ#¤z°%¼ Ô'IØr~~ a¨Ó.Ñ.Ð.Ü %Ô ØqyÐÜ Ô Ü||E¤B§F¡F 7Ó+Ð+äÐ?ÄÄTÈ%Ã[Ó@QÐ?RÐSÓTÐTrY c ó& | j di |¤S )zv
|
This is called upon unpickling, rather than the default which doesn't have
|
arguments and breaks __new__.
|
© )Ú from_arrays)ÚclsÚds rW Ú_new_IntervalIndexra s ð
|
3??Ñ QÑ Ð rY Úclassz>Immutable index of intervals that are closed on the same side.rC zis_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@ ÚsummaryrC Úextra_attributesÚ extra_methodsÚexamplesÚ
|
set_closedÚ to_tuplesT)Úwrap)Ú __array__ÚoverlapsÚcontainsÚ closed_leftÚ closed_rightÚ open_leftÚ
|
open_rightÚis_emptyÚ is_non_overlapping_monotonicÚclosed)Úcachec ój e Zd ZU dZded< ded< ded< ded< ded< ded < d
|
ed < d
|
ed < d ZeZ d< d=dZe e
|
e d d e j d« e j d« dz « d> d?d« « Ze e
|
e d d e j d« e j d« dz « d> d@d« « Ze e
|
e d d e j d« e j d« dz « d> d@d« « ZedAd« ZdBdZdCd ZedDd « Zd ZedEd « Z e
|
ej4 j6 « dFdGd « ZedHd!« Z edHd"« Z edHd#« Z dHd$Z d% Z dIdJd&Z!dKd'Z" dL dMd(Z# e
|
e$d) e%z « dNd*« Z&dOd+Z' dNd,Z(edHd-« Z)d.Z*dP fd/ Z+edHd0« Z,dQd1Z-dRd2Z.edSd3« Z/edSd4« Z0edSd5« Z1edSd6« Z2d7 Z3dTd8Z4dTd9Z5dUd:Z6d; Z7 xZ8S )Vr? Ú intervalindexr< rt Úboolrs rn ro rp rq r+ Ú_dataÚ_valuesFc ó¶ t ||| « }t d| j « 5 t |||||¬« }d d d « | j |« S # 1 sw Y xY w)Nr+ )rt ÚcopyrF Úverify_integrity)r1 r Ú__name__r+ Ú _simple_new)r_ Údatart rF r| rC r} Úarrays rW Ú__new__zIntervalIndex.__new__ß sa ô " $¨¨cÓ2ä °· ± Ó =ñ Ü!ØØ ØØØ!1ô E÷ ð u dÓ+Ð+÷ ð ús ¤AÁAÚ 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@ rC rg c ó° t d| j « 5 t j ||||¬« }d d d « | j |¬« S # 1 sw Y xY w©Nr+ )rt r| rF ©rC )r r~ r+ r r )r_ Úbreaksrt rC r| rF r s rW r zIntervalIndex.from_breaksõ sU ô: °· ± Ó =ñ Ü!×-Ñ-Øv¨D¸ôE÷ ð u¨4Ó0Ð0÷ ð úó A Á Ar^ zÏ Examples
|
--------
|
>>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3])
|
IntervalIndex([(0, 1], (1, 2], (2, 3]],
|
dtype='interval[int64, right]')
|
c ó² t d| j « 5 t j |||||¬« }d d d « | j |¬« S # 1 sw Y xY w)Nr+ )r| rF r )r r~ r+ r^ r )r_ ÚleftÚrightrt rC r| rF r s rW r^ zIntervalIndex.from_arrays sW ô< °· ± Ó =ñ Ü!×-Ñ-ØeV¨$°eôE÷ ð u¨4Ó0Ð0÷ ð ús A Á AÚ from_tupleszÄ Examples
|
--------
|
>>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)])
|
IntervalIndex([(0, 1], (1, 2]],
|
dtype='interval[int64, right]')
|
c ó° t d| j « 5 t j ||||¬« }d d d « | j |¬« S # 1 sw Y xY wr
)r r~ r+ r r )r_ r rt rC r| rF Úarrs rW r zIntervalIndex.from_tuples< sU ô: °· ± Ó =ñ YÜ ×+Ñ+¨D¸ÀdÐRWÔXC÷ Yàs¨Ó.Ð.÷ Yð Yúr c óÊ | j | j « }t |« }| j | j « }t |« }t ||| j
|
¬« S )N©rt )Ú_maybe_convert_i8r r r r rt )Úselfr r s rW Ú_enginezIntervalIndex._engine` sS ð ×%Ñ% d§i¡iÓ0Ü,¨TÓ2Ø×&Ñ& t§z¡zÓ2Ü-¨eÓ4ÜD %°· ± Ô<Ð<rY c ó t |« t |t « s#t || j « r | j
|
S y | j |« y# t $ r Y yw xY w)zÏ
|
return a boolean if this key is IN the index
|
We *only* accept an Interval
|
|
Parameters
|
----------
|
key : Interval
|
|
Returns
|
-------
|
bool
|
FT)ÚhashrM r
|
r' rF ÚhasnansÚget_locÚKeyError)r Úkeys rW Ú __contains__zIntervalIndex.__contains__i sV ô S Ü#xÔ(Ü$ S¨$¯*©*Ô5Ø||Ð#Øð Ø LLÔ ØøÜò Ùð ús Á A Á A Á A c ól | j | }t | « j || j ¬« S )zH
|
Fastpath for __getitem__ when we know we have a slice.
|
r )ry rL r Ú_name)r ÚslobjÚress rW Ú_getitem_slicez IntervalIndex._getitem_slice s0 ð jjÑ ÜDz×%Ñ% c°·
|
±
|
Ð%Ó;Ð;rY c ó` t j | j | j gddg¬« S )Nr r )Únames)r6 r^ r r ©r s rW Ú _multiindexzIntervalIndex._multiindex s' ä×%Ñ% t§y¡y°$·*±*Ð&=ÀfÈgÐEVÔWÐWrY c ó | j | j | j | j d}t t | « |fd fS )N)r r rt rC )r r rt rC ra rL )r r` s rW Ú
|
__reduce__zIntervalIndex.__reduce__ s< àIIØZZØkkØIIñ
|
ô "¤D¨£J° ?°DÐ8Ð8rY c ó y)z4Return a string of the type inferred from the valuesÚintervalr] r¢ s rW Ú inferred_typezIntervalIndex.inferred_type s ð rY c ót | j j |¬« | j j |¬« z S )N)Údeep)r Ú memory_usager )r rª s rW r« zIntervalIndex.memory_usage s4 ð yy×%Ñ%¨4Ð%Ó0°4·:±:×3JÑ3JÐPTÐ3JÓ3UÑUÐUrY c ó& | ddd
j S )z
|
Return True if the IntervalIndex is monotonic decreasing (only equal or
|
decreasing values), else False
|
Néÿÿÿÿ)Úis_monotonic_increasingr¢ s rW Úis_monotonic_decreasingz%IntervalIndex.is_monotonic_decreasing¤ s ð DbDz×1Ñ1Ð1rY c ó^ | j }| j }| j « j « dkD ry|j s |j ryt « }t j |j d¬« « d }|D ]# }|| || f}||v r y|j |« % y)zX
|
Return True if the IntervalIndex contains unique elements, else False.
|
rH FT)Úkeepr )
|
r r ÚisnaÚsumÚ is_uniqueÚsetrO ÚwhereÚ
|
duplicatedÚadd)r r r Ú
|
seen_pairsÚ check_idxÚidxÚpairs rW r´ zIntervalIndex.is_unique¬ s ð
|
yyØ
|
|
à 99;??Ó qÒ Øà >>U__ØäU
|
ÜHHT__°%_Ó 8Ó9¸!Ñ< Ø ò !CØIu SzÐ*DØzÑ!Ù Ø NN4Õ ð !ð rY c ó. | j j S )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
|
)r Úis_overlappingr¢ s rW r¾ z IntervalIndex.is_overlappingÄ s ð` ||×*Ñ*Ð*rY c óÖ t |dd« }t |t « st |t « r| j |j
|
« S t t t t f}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
|
rF N)
|
rK rM r& r
|
Ú_needs_i8_conversionr r r r2 r7 )r r Ú key_dtypeÚi8_typess rW rÀ z"IntervalIndex._needs_i8_conversionö sU ô$ C ¨$Ó/ Ü i¤ Ô /´:¸cÄ8Ô3LØ×,Ñ,¨S¯X©XÓ6Ð 6ä y¬-¼ ÐHÜ#xÓ(Ð(rY c ó t |« rt |« }t |« }| j |« s|S t |« }t |dd« }t |t « st |t « rc| j |j « }| j |j « }|rt nt j } |||| j ¬« S |rt |« \ }}t |t « r |j" }n¢t |t$ « r |j& }n
t |t( j* t( j, f« r[|j/ d« }nI|j0 t3 |j4 « }}|j6 r |j9 |j: « }| j0 j< }||k7 rt? 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.
|
rF Nr Úi8z)Cannot index an IntervalIndex of subtype z with values of dtype ) r r0 r rÀ r" rK rM r& r
|
r r r r? r^ rt r r Úordinalr Ú_valuerO Ú
|
datetime64rP ÚviewrF r. Úasi8r r¶ Ú_isnanÚsubtypeÚ
|
ValueError) r r ÚscalarrÁ r r Ú constructorÚkey_i8rË s rW r z IntervalIndex._maybe_convert_i8 s ô" Ô Ü sÓ#CÜ/°Ó4Cà×(Ñ(¨Ô-ØJä3 ÜC ¨$Ó/ Ü i¤ Ô /´:¸cÄ8Ô3Là×)Ñ)¨#¯(©(Ó3DØ×*Ñ*¨3¯9©9Ó5EÙ&,(´-×2KÑ2KKá Øe D§K¡Kôð ñ ä 7¸Ó <Ñ IvÜ#vÔ&Ø ÜF¤IÔ.Ø ÜF¤R§]¡]´B·N±NÐ$CÔDØ TÓ*ð !$§ ¡ ¬5°·±«?vIØ{{ð s§z¡z kÓ2ð
|
**×$Ñ$à iÒ Ü Ø;¸G¸9ð E#Ø#, +ð/óð ð
|
rY c ó | j s t d« t |t t f« r t d« |dk( r| j j s|dk( r:| j j s$| j }| j r/t |« }n#| j }| j r t |« }|j ||« S )Nzrcan only get slices from an IntervalIndex if bounds are non-overlapping and all monotonic increasing or decreasingz,Interval objects are not currently supportedr r )rs r rM r r? ÚNotImplementedErrorr r® r rq rX rp r[ Ú_searchsorted_monotonic)r rV ÚsideÚsub_idxs rW rÒ z%IntervalIndex._searchsorted_monotonicQ sª Ø×0Ò0ÜðMóð ô
|
em¬]Ð ;Ô <Ü%Ð&TÓUÐ Uð
|
FNtyy× @Ò @Ø GO D§I¡I×$EÒ$EàjjGØÜ'¨Ó.àiiGØ~~Ü'¨Ó.à×.Ñ.¨u°dÓ;Ð;rY c ón | j |« t |t « rX| j |j k7 r t |« | j
|
|j
|
k( | j |j k( z }nt || j « r| j « }nX| j rt nt }| j rt nt } || j
|
|« ||| j « z }|j « }|dk( r t |« |dk( r|j! « S t# j$ |j' d« « }t |t( « r6|j* *t) |j, t/ | « |j0 « }|S # t $ r}t |« |d}~ww xY w)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 rH Úu1)Ú_check_indexing_errorrM r
|
rt r r r r' rF r² rn r r ro rS r³ Úargmaxr Úmaybe_booleans_to_slicerÈ ÚsliceÚstopÚstartÚlenÚstep)r r ÚmaskÚop_leftÚop_rightÚerrÚmatchesr s rW r zIntervalIndex.get_locn sR ðJ ×"Ñ" 3Ô'ä c8Ô $Ø{{cjjÒ(Ü smÐ#ØII §¡Ñ)¨d¯j©j¸C¿I¹IÑ.EÑFDÜ " 3¨¯
|
©
|
Ô 3Ø99;Dð !× ,Ò ,b´"GØ !× .Ò .r´BHð -Ù tyy¨#Ó.±¸#¸t¿z¹zÓ1JÑJð
|
((*Ø a<Ü3-Ð Ø a<Ø;;=Ð ä×)Ñ)¨$¯)©)°D«/Ó:Ü c5Ô ! c§h¡hÐ&6ä ¤3 t£9¨c¯h©hÓ7CØ
|
øô ò -ä sm¨Ð,ûð -ús Ã'F Æ F4Æ# F/Æ/F4c óX t |t « r | j |« }t |« S t |j « sVt |j « sA| j |« }| j j |j « }t |« S | j |« d S )Nr ) rM r? Ú_get_indexer_unique_sidesr! rF r# r r Ú get_indexerÚvaluesÚ_get_indexer_pointwiser )r ÚtargetÚmethodÚlimitÚ toleranceÚindexers rW Ú _get_indexerzIntervalIndex._get_indexer± s ô fmÔ ,ð
|
×4Ñ4°VÓ<Gô # 7Ó+Ð+ô " &§,¡,Ô/´?À6Ç<Á<Ô3Pð ×+Ñ+¨FÓ3FØll×.Ñ.¨v¯}©}Ó=Gô # 7Ó+Ð+ð ×.Ñ.¨vÓ6°qÑ9Ð 9rY Úget_indexer_non_uniquec óz t |« }| j |« s%| j |« s| j |d d¬« S t |t
|
« re| j j r>| j j r(| j |« }|dk( j « d }n| j |« S t |j « s| j |« s| j |« S | j |« }| j j! |j" « \ }}t% |« t% |« fS )NFr( r r )r0 Ú_should_compareÚ_should_partial_indexÚ_get_indexer_non_comparablerM r? r r´ r rå Únonzerorè r! rF r r rï rç r )r ré rí Úmissings rW rï z$IntervalIndex.get_indexer_non_uniqueË s ô fÓ%à×#Ñ# FÔ+°D×4NÑ4NÈvÔ4Vð ×3Ñ3°F¸DÈÐ3ÓOÐ Oä ¤ Ô .Øyy×"Ò" t§z¡z×';Ò';à ×8Ñ8¸Ó@Ø" b=×1Ñ1Ó3°AÑ6à×2Ñ2°6Ó:Ð:ä V\\Ô *°$×2LÑ2LÈVÔ2Tà×.Ñ.¨vÓ6Ð 6ð
|
×+Ñ+¨FÓ3FØ #||× BÑ BÀ6Ç=Á=Ó QÑ GWä" 7Ó+Ô-@ÀÓ-IÐIÐIrY c óÎ | j j |j « }| j j |j « }t j ||k( |d« }|S )zZ
|
_get_indexer specialized to the case where both of our sides are unique.
|
r )r ræ r rO r¶ )r ré Ú left_indexerÚ right_indexerrí s rW rå z'IntervalIndex._get_indexer_unique_sidesê sP ð yy×,Ñ,¨V¯[©[Ó9 Ø
|
|
×.Ñ.¨v¯|©|Ó< Ü((<¨=Ñ8¸,ÈÓKØrY c ó´ g g }}t |« D ]µ \ }} | j |« }t |t « r8t j
|
|j |j |j d¬« }nEt j |« rt j |d¬« }nt j |« d }|j |« · t j |« }t# |« t# |« fS # t $ r* |j |« t j dg« }Y pt $ r* |j |« t j dg« }Y ¡w xY w)zV
|
pointwise implementation for get_indexer and get_indexer_non_unique.
|
Úintp©rF rH )Úndminr r )Ú enumerater rM rÚ rO ÚarangerÜ rÛ rÞ r r r r¶ r Úappendr Ú concatenater )r ré rí rõ Úir Úlocss rW rè z$IntervalIndex._get_indexer_pointwiseö s ð rÜ Ó'ò !FAsð &Ø|| CÓ(Ü d¤EÔ*ä 99 T§Z¡Z°·±¸D¿I¹IÈVÔTDÜ^^ DÔ)Ü 88 D°Ô2Dô 88 D>¨!Ñ,Dð NN4Õ ð) !ô, .. Ó)Ü" 7Ó+Ô-@ÀÓ-IÐIÐIøô ò &ØqÔ!Üxx ~Ü$ò &ð qÔ!Üxx ~ð &ús B C3Ã30EÄ%/EÅEc óR | j xr | j j dk S )Né )r¾ r Ú _na_countr¢ s rW Ú_index_as_uniquez IntervalIndex._index_as_unique s% à×&Ñ&Ð&ÒE¨4¯<©<×+AÑ+AÀAÑ+EÐErY zKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquec ó´ |j <|j dk( s-d}|dk( r t |« |dk( rt |« s t |« t | ||« S )NrH zClabel-based slicing with step!=1 is not supported for IntervalIndexÚlocÚgetitem)rÞ rÌ r- ÚsuperÚ_convert_slice_indexer)r r ÚkindÚmsgÚ __class__s rW r z$IntervalIndex._convert_slice_indexer s\ ø ØÐ C§H¡H°¢Mð XCØu}Ü oÐ%ØyÒ Ü0°Ô5ä$ S/Ð)äwÑ-¨c°4Ó8Ð8rY c óF | j j j dv S )NrG )rF rË r r¢ s rW Ú _should_fallback_to_positionalz,IntervalIndex._should_fallback_to_positional, s ð zz×!Ñ!×&Ñ&¨$Ð.Ð.rY c ó: t | |« j ||« S ©N)rK Ú_maybe_cast_slice_bound)r rV rÓ s rW r z%IntervalIndex._maybe_cast_slice_bound4 s ÜtTÓ"×:Ñ:¸5À$ÓGÐGrY c ój t |t « syt | j |g« }t |« S )NF)rM r& r rF r! )r rF Úcommon_subtypes rW Ú_is_comparable_dtypez"IntervalIndex._is_comparable_dtype7 s0 Ü%¤ Ô/ØÜ)¨4¯:©:°uÐ*=Ó>Ü" >Ó2Ð2Ð2rY c óD t | j j d¬« S ©NF)r| )r. ry r r¢ s rW r zIntervalIndex.left? s äTZZ__¨5Ô1Ð1rY c óD t | j j d¬« S r )r. ry r r¢ s rW r zIntervalIndex.rightC s äTZZ×%Ñ%¨EÔ2Ð2rY c óD t | j j d¬« S r )r. ry Úmidr¢ s rW r zIntervalIndex.midG s äTZZ^^¨%Ô0Ð0rY c óD t | j j d¬« S r )r. ry Úlengthr¢ s rW r zIntervalIndex.lengthK s äTZZ×&Ñ&¨UÔ3Ð3rY c ó | j j r(| j j r| j |« }np|j j rI|j j r3| j « j « dk r|j | « }n| j |« }||j « }|S )zL
|
intersection specialized to the case with matching dtypes.
|
rH )r r´ r Ú_intersection_uniquer² r³ Ú_intersection_non_uniqueÚ sort_values)r ÚotherÚsortÚtakens rW Ú _intersectionzIntervalIndex._intersectionR s ð
|
99× Ò 4§:¡:×#7Ò#7Ø×-Ñ-¨eÓ4EØ ZZ× !Ò ! e§k¡k×&;Ò&;ÀÇ Á à ÇÁÓ@QÐUVÒ@Vð ×.Ñ.¨tÓ4Eð ×1Ñ1°%Ó8Eà <Ø×%Ñ%Ó'Eà rY c ó( | j j |j « }| j j |j « }||k( |dk7 z }|j |j « d « }t |« }| j |« 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 )r ræ r Útakerô r) )r r" ÚlindexerÚrindexerÚmatchrí s rW r z"IntervalIndex._intersection_uniquef sx ð 99×(Ñ(¨¯©Ó4Ø::×)Ñ)¨%¯+©+Ó6àXÑ%¨(°b©.Ñ9Ø-- § ¡ £°Ñ 2Ó3Ü/àyyÓ!Ð!rY c óº t j t | « t ¬« }| j rC|j r7t j
|
t | « « | j « d }d||< t t |j |j « « }t t | j | j « « D ] \ }}||v s d||< | | 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) rO ÚzerosrÝ rx r rþ r² rµ Úzipr r rý )r r" rß Ú first_nan_locÚ
|
other_tupsr Útups rW r z&IntervalIndex._intersection_non_unique| s® ô xxD ¬Ô.à <<EMMÜ II¤c¨$£iÓ 0°·±³Ñ =¸aÑ @MØ"&D Ñ äUZZ¨¯©Ó5Ó6
|
Ü ¤ D§I¡I¨t¯z©zÓ :Ó;ò FAsØjÒ Ø Qð ð DzÐrY c ó t d« )NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objects©rÑ r¢ s rW Ú_get_engine_targetz IntervalIndex._get_engine_target s ô "ð "ó
|
ð
|
rY c ó t d« )Nz,IntervalIndex does not use libjoin fastpathsr2 )r Úresults rW Ú_from_join_targetz IntervalIndex._from_join_target¤ s Ü!Ð"PÓQÐQrY )NNFNT) rt úIntervalClosedType | NonerF ú Dtype | Noner| rx rC úHashable | Noner} rx Úreturnr= )r NFN)
|
rt r7 rC r9 r| rx rF r8 r: r? )
|
rt r< rC r9 r| rx rF r8 r: r? )r: r )r r r: rx )r rÚ r: r? )r: r6 )r: Ústr)F)rª rx r: Úint©r: rx )r )rÓ zLiteral['left', 'right'])r: zint | slice | np.ndarray)NNN)
|
ré r. rê z
|
str | Nonerë z
|
int | Nonerì z
|
Any | Noner: únpt.NDArray[np.intp])ré r. r: z1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])ré r? r: r> )r rÚ r zLiteral['loc', 'getitem'])rÓ r; )rF r; r: rx )r: r. )r" r? r: r? )r: z
|
np.ndarray)9r~ Ú
|
__module__Ú __qualname__Ú_typÚ__annotations__Ú_can_hold_stringsr+ Ú _data_clsr Ú classmethodr r, ÚtextwrapÚdedentr r^ r r r r r r£ r¥ Úpropertyr¨ r. r« Ú__doc__r¯ r´ r¾ rÀ r rÒ r rî r/ Ú_index_doc_kwargsrï rå rè r Ú_requires_unique_msgr r r r r r r r r% r r r3 r6 Ú __classcell__)r s @rW r? r? s ø
ðZ Dð Ó Ø"&Ó&ØÓØÓØOØÓà ÓØ ÓØ ÐØ Ið -1Ø "ØØ $Ø!%ð,ð *ð,ð ð ,ð
|
ð ,ð ð ,ð ð,ð
|
ó,ð, Ù Ø mÑ,à$Ø#HOOð:óð
|
(ð óñ
|
ñ
|
óð. -4Ø $ØØ "ð 1ð *ð 1ð ð 1ð
|
ð 1ð ð 1ð
|
ò 1ó)ó ð* 1ð Ù Ø mÑ,à$Ø#HOOð:óð
|
(ð óñ
|
ñ
|
óð0 &-Ø $ØØ "ð 1ð #ð 1ð
|
ð 1ð ð 1ð ð 1ð
|
ò 1ó)ó ð* 1ð Ù Ø mÑ,à$Ø#HOOð:óð
|
(ð óñ
|
ñ
|
óð. &-Ø $ØØ "ð
|
/ð #ð
|
/ð ð
|
/ð
|
ð
|
/ð ð
|
/ð
|
ò
|
/ó)ó ð*
|
/ð ò=ó ð=óó2<ð òXó ðXò9ð òó ðñ
|
e× Ñ ×(Ñ(Ó)óVó *ðVð ò2ó ð2ð òó ðð. ò/+ó ð/+ób)ò2@ôD<ó:AðL "Ø Ø $ð ,àð,ð ð,ð ð ,ð
|
ð ,ð
|
ó ,ñ4 Ð Ð!9Ñ:Ð=NÑNÓOð JØð Jà :ò Jó Pð Jó<
|
ð JØð Jà :ó Jð@ òFó ðFð Vð õ 9ð ò/ó ð/óHó3ð ò2ó ð2ð ò3ó ð3ð ò1ó ð1ð ò4ó ð4ò ó("ó,ó>
|
öRrY c ón t t | « t | t « t | t « | du g« S )zJ
|
Helper for interval_range to check if start/end are valid types.
|
N)Úanyr rM r r )Úendpoints rW Ú_is_valid_endpointrP ª s: ô ä hÓ Ü x¤Ó +Ü x¤Ó +Ø Ð ð
|
ó ð rY c ó¾ d }d }t | « xr t |« xs> || « xr ||« xs* || « xr ||« xs t j | |« S )zK
|
Helper for interval_range to check type compat of start/end/freq.
|
c ó. t | t t f« S r )rM r r ©Úxs rW ú<lambda>z%_is_type_compatible.<locals>.<lambda>¼ ó Z¨¬I´zÐ+BÓ C rY c ó. t | t t f« S r )rM r r rS s rW rU z%_is_type_compatible.<locals>.<lambda>½ rV rY )r ÚcomÚany_none)ÚaÚbÚ is_ts_compatÚ is_td_compats rW Ú_is_type_compatibler^ ¸ sc ñ DLÙCLä 1 Ò &) A,ò Ù OÒ /¡ ¨Q£ò á OÒ /¡ ¨Q£ò ô <<1Ó ð rY c ól t | « } t |« }| | n|}|&t j || |« rt |« rdnd}t j | |||« dk7 r t d« t | « st d| « t |« st d| « t |« }|t |« s t |« }t t | |« t | |« t ||« g« s t d « ||dz }t |« rÅt j | ||« r t j | ||d
|
z z |« }nI|t || z
|
|z « dz }n| ||dz
|
|z z
|
} n | | |dz
|
|z z }t j | ||« }t d t j" | ||« D « « rOt% |t j& d « « }n/t) |t* « rt- | |||¬ « }nt/ | |||¬ « }t0 j3 |||¬« S # t
|
$ r}t d| « |d}~ww xY w)a
|
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, Timedelta, 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 00:00:00, 2017-01-02 00:00:00],
|
(2017-01-02 00:00:00, 2017-01-03 00:00:00],
|
(2017-01-03 00:00:00, 2017-01-04 00:00:00]],
|
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 00:00:00, 2017-02-01 00:00:00],
|
(2017-02-01 00:00:00, 2017-03-01 00:00:00],
|
(2017-03-01 00:00:00, 2017-04-01 00:00:00]],
|
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]')
|
NrH Ú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 z7freq must be numeric or convertible to DateOffset, got z+start, end, freq need to be type compatibleg¹?c 3 ó2 K | ] }t |« y wr )r )Ú.0rT s rW ú <genexpr>z!interval_range.<locals>.<genexpr>` s è ø ÒE z!}ÑEùs Úint64)rÜ ÚendÚperiodsÚfreq)rC rt )r rX rY r Úcount_not_nonerÌ rP r* r Úallr^ rS Ú all_not_nonerO rþ r< ÚlinspaceÚnot_noner rF rM r r3 r8 r? r ) rÜ rf rg rh rC rt rO râ r s rW Úinterval_rangern Æ sZ ô@ # 5Ó )EÜ
|
Ó
|
%CØ Ð)u¨sHà | W¨e°SÔ9Ü hÔ'q¨Sä
|
×Ñ% g¨tÓ4¸Ò9Üð 4ó
|
ð
|
ô
|
eÔ $ÜÐGÈÀwÐOÓPÐPÜ cÔ "ÜÐEÀcÀUÐKÓLÐLä wÓ'Gà Ф ¨$¤ð Ü T?Dô ä sÓ +Ü tÓ ,Ü TÓ *ð
|
ô ô ÐEÓFÐFð ÐØ1 ô ÔÜ × Ñ E 3¨Ô -äYYu c¨T°C©ZÑ&8¸$Ó?Fð Ü s U{¨tÑ 3Ó4°qÑ8Ø Øw¨{¨dÑ 2Ñ2ØØw¨{¨dÑ 2Ñ2ä[[ ¨¨WÓ5FÜ ÑE¤c§l¡l°5¸#¸tÓ&DÔEÔ Eô ,ØÜÓ!óFô h¤ Ô *Ü e°¸gÈDÔQFä$¨5°cÀ7ÐQUÔVFä × $Ñ $ V°$¸vÐ $Ó FÐFøôi ò Ü ØIÈ$ÈÐPóàð ûð ús Â6 H È H3È H.È.H3r= )NNNNNr )rC r9 rt r< r: r? )irI Ú
|
__future__r Úoperatorr r rF Útypingr r r ÚnumpyrO Ú pandas._libsr Úpandas._libs.intervalr
|
r r Úpandas._libs.tslibsr r r r r Ú pandas.errorsr Úpandas.util._decoratorsr r Úpandas.util._exceptionsr Úpandas.core.dtypes.castr r r r r Úpandas.core.dtypes.commonr r r r r r r! r" r# r$ Úpandas.core.dtypes.dtypesr% r& Úpandas.core.dtypes.missingr' Úpandas.core.algorithmsr) Ú pandas.core.arrays.datetimeliker* Úpandas.core.arrays.intervalr+ r, Úpandas.core.commonÚcoreÚcommonrX Úpandas.core.indexersr- Úpandas.core.indexes.baseÚindexesÚbaseÚibaser. r/ r0 r1 Ú pandas.core.indexes.datetimesr2 r3 Ú pandas.core.indexes.extensionr4 r5 Úpandas.core.indexes.multir6 Ú pandas.core.indexes.timedeltasr7 r8 Úcollections.abcr9 Úpandas._typingr: r; r< r= r> ÚdictrJ ÚupdaterG rX r[ ra r? rP r^ rn r] rY rW ú<module>r s ðÙ Ý "÷ó ÷ñ ó å ÷ñ ÷
|
õ õ ,÷õ 6÷õ ÷ ÷ ÷ ÷õ =å )Ý <÷÷ !Ð Ý :ß (Ó (÷ó ÷ ÷õ 1÷ñ
|
Ý(÷õ ñ ×0Ñ0Ó1Ð à × Ñ à Ø#Ø<Ø ð ó
|
ñ
|
ô ò Uò"Uò" ñ
|
Ø'Ñ"à ØSØ! &Ñ)Ø 6ØØ#HOOð ó
|
ñ ñó ñ: kÐ*¨MÀÔEÙò ð ó ñ Ð.°Ð9¸=ÐPTÔUôY RNó Y Ró Vó ó Fó; ðXY Ró| ó ð Ø Ø Ø Ø Ø!(ð kGð
|
ð kGð ð kGð ôkGrY
|
