Ë
|
nñúhVù ã óà U d dl mZ d dlZd dlmZmZ d dlZd dlmZmZm Z m
|
Z
|
d dl Z d dl Z d dlmZ d dlmZmZmZmZ d dlmZ d dlmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$ d d l%m&Z' d d
|
l(m)Z) d d l*m+Z+ d d l,m-Z- d d l.m/Z/m0Z0 d dl1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9 d dl:m;Z;m<Z< d dl=m>Z>m?Z?m@Z@mAZA d dlBmCZCmDZDmEZE d dlFmGZGmHZHmIZImJZK d dlLmMZM d dlNmOZOmPZP d dlQmRZR d dlSmTZT d dlUmVc mWZX d dlYmZZ[m\Z\m]Z] d dl^m_Z_ d dl`maZambZb erd dlcmdZdmeZe d dlfmgZgmhZh e e#e jÒ f Zje eekf Zli Zmd end < d d d d!Zod"emd#< e+emd# d d$d d d ejà d%« d&z « G d' d eeO« « Zqd)d(Zry)*é )Ú annotationsN)ÚleÚlt)Ú TYPE_CHECKINGÚLiteralÚUnionÚoverload)Úlib)Ú VALID_CLOSEDÚIntervalÚ IntervalMixinÚ intervals_to_interval_bounds)ÚNA) Ú ArrayLikeÚAxisIntÚDtypeÚ FillnaOptionsÚIntervalClosedTypeÚNpDtypeÚPositionalIndexerÚ ScalarIndexerÚSelfÚSequenceIndexerÚSortKindÚ TimeArrayLikeÚnpt)Úfunction)ÚIntCastingNaNError)ÚAppender)Úfind_stack_level)ÚLossySetitemErrorÚ maybe_upcast_numeric_to_64bit)Úis_float_dtypeÚis_integer_dtypeÚ is_list_likeÚis_object_dtypeÚ is_scalarÚis_string_dtypeÚneeds_i8_conversionÚ pandas_dtype)ÚCategoricalDtypeÚ IntervalDtype)Ú ABCDataFrameÚABCDatetimeIndexÚABCIntervalIndexÚABCPeriodIndex)Úis_valid_na_for_dtypeÚisnaÚnotna)ÚisinÚtakeÚuniqueÚvalue_counts_internal)ÚArrowExtensionArray)ÚExtensionArrayÚ _extension_array_shared_docs)Ú DatetimeArray)ÚTimedeltaArray)ÚarrayÚ ensure_wrapped_if_datetimelikeÚ extract_array)Úcheck_array_indexer)Úinvalid_comparisonÚunpack_zerodim_and_defer)ÚIteratorÚSequence)ÚIndexÚSerieszdict[str, str]Ú_interval_shared_docsÚ IntervalArrayzarrays.IntervalArrayÚ )ÚklassÚqualnameÚnameaç
|
%(summary)s
|
|
Parameters
|
----------
|
data : array-like (1-dimensional)
|
Array-like (ndarray, :class:`DateTimeArray`, :class:`TimeDeltaArray`) 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.aà 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`.
|
)rJ ÚsummaryrL Úextra_attributesÚ extra_methodsÚexamplesc ó8 e Zd ZU dZej
|
xZZedsd« Z de
|
d< de
|
d< de
|
d< dt dud
|
Z e dvd « Z e dw dxd « Ze dd d dyd« Ze dzd« Z ej$ d« ed< e eed d d ej$ d« dz « d{ d|d« « Z ej$ d« ed< e eed d d ej$ d« dz « d{ d|d« « Z ej$ d« ed< e eed d d ej$ d « dz « d{ d|d « « Ze d}d « Zd~d Zedd « Zedd!« Zedd"« Z dd#Z dd$Z e dd%« Z e dd&« Z dd'Z d
d(Z!d) Z" e#d*« d+ « Z$ e#d,« d- « Z% e#d.« d/ « Z& e#d0« d1 « Z' e#d2« d3 « Z( e#d4« d5 « Z)dd6d7d8 d fd9Z*ddd:dd;Z+ddd:dd<Z,dddd= d fd>Z- d d fd? Z.dd fd@ Z/ddAZ0e ddB« Z1d~dCZ2ddDZ3dddEZ4d dddF ddGZ5dH Z6dI Z7dJ Z8dddKZ9dddLZ:eddM« Z;eddN« Z<eddO« Z=eddP« Z> ej$ dQ« edR< eedR d ej$ dS« dTz « dU « Z?eddV« Z@ ej$ dW« edX< eedX d ej$ dY« dTz « ddZ« ZAd[ed\< e eed\ eBz « dd]« « ZC d dd^ZDdd_ZE ej$ d`« eda< eeda db ej$ dc« ddz « ddde« ZFddfZGddgZHd~dhZI eeJdi eBz « d ddj« ZK ej$ dk« edl< eedl d ej$ dm« dTz « dn « ZLd doZMed¡dp« ZNd¢dqZOd£drZP xZQS )¤rH Tc ó y)Né © ©Úselfs úNH:\Change_password\venv_build\Lib\site-packages\pandas/core/arrays/interval.pyÚndimzIntervalArray.ndimÚ s àó Ú IntervalSideÚ_leftÚ_rightr, Ú_dtypeNFc óN t |d¬« }t || « r@|j }|j }|xs |j }t |j |¬« }n£t |« r | j d| d}t |« t |« }t ||d u ¬« \ }}} |j t k( r*t j |« }t j |« }|xs | }| j |||||¬« \ }}}|r| j! |||¬« | j# |||¬« S ) NT©Ú extract_numpy©Úclosedz5(...) must be called with a collection of some kind, z was passed)Úvalidate_closed©rc ÚcopyÚdtype©rg )r? Ú
|
isinstancer\ r] rc r, rg r' Ú__name__Ú TypeErrorÚ _maybe_convert_platform_intervalr Úobjectr
|
Úmaybe_convert_objectsÚ_ensure_simple_new_inputsÚ _validateÚ _simple_new)
|
ÚclsÚdatarc rg rf Úverify_integrityÚleftÚrightÚmsgÚ infer_closeds
|
rX Ú__new__zIntervalArray.__new__æ s= ô T°Ô6ä dCÔ Ø!%§¡DØ"&§+¡+EØÒ*t{{FÜ! $§*¡*°VÔ<Eô à||nð %%Ø%) F¨+ð7ð ô nÐ$ô 4°DÓ9DÜ(DØ f° nô)Ñ %D% ð zzVÒ#Ü×0Ñ0°Ó6Ü×1Ñ1°%Ó8ØÒ+|Fà!$×!>Ñ!>ØØØ ØØð "?ó "Ñ D%ñ Ø MM$ ¨UMÔ 3àØ Ø Øð ó
|
ð
|
rZ c óZ t j | « }||_ ||_ ||_ |S ©N)r ry r\ r] r^ )rr ru rv rg Úresults rX rq zIntervalArray._simple_new s. ô ×&Ñ& sÓ+Ø Ø Ø à rZ c ó ddl m} |||¬« }t |« } |||¬« }t |« }| t |t « r |j
|
}|xs d}|«t |« }t |t « rC|j G|j |j « }|j |j « }nd| }t |« |j
|
t |j |« }n||j
|
k7 r t d« t |j « r1t |j « r |j |j « }nEt |j « r0t |j « r|j |j « }t |« t |« k7 r:dt |« j dt |« j d }t |« t |j t « st# |j « r d
|
}t |« t |t$ « r d }t |« t |t& « rSt) |j* « t) |j* « k7 r(d |j* d |j* d}t |« t- |j « rQ|j. |j. k7 r8|j0 j3 |j0 « \ }} ||« } || « }t5 |« }t7 |d¬« }t5 |« }t7 |d¬« }t |t8 « st |t8 « rn^t; |d|« }
|
t; |
|
d|
|
« j< }
|
t; |d|« } t; | d| « j< } |
|
|
|
| u r|j? « }t |j |¬« }|||fS )z;Ensure correctness of input parameters for cls._simple_new.r )Ú ensure_index©rf rv 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 'ú'Tr` Ú_ndarrayÚ_datarb ) Úpandas.core.indexes.baser~ r" ri r, rc r* ÚsubtypeÚastyperk Ú
|
ValueErrorr# rg r$ Útyperj r+ r( r0 r. ÚstrÚtzr) Úunitr Ú_ensure_matching_resosr> r? r8 ÚgetattrÚbaserf ) rr ru rv rc rf rg r~ rw Úleft_arrÚ right_arrÚlbaseÚrbases rX ro z'IntervalArray._ensure_simple_new_inputs' s4 õ :áD tÔ,Ü,¨TÓ2á U¨Ô.Ü-¨eÓ4à >j¨´ Ô >Ø\\FàÒ"7à Ð ä Ó'EÜ%¤ Ô/Ø==Ð,Ø ;; u§}¡}Ó5DØ !LL¨¯ © Ó 7Eà<¸U¸GÐDÜ nÐ$à||Ð#ä% e§m¡m°VÓ<Ø5<<Ò'Ü Ð!MÓNÐNô $**Ô %Ô*:¸5¿;¹;Ô*GØLL §¡Ó,EÜ EKKÔ (Ô-=¸d¿j¹jÔ-IØ;;u{{Ó+Dä :eÒ $à0´°d³×1DÑ1DÐ0Eð FÜ u+×.Ñ.Ð/¨wð8ð ô S/Ð !Ü djjÔ"2Ô 3´ÀtÇzÁzÔ7Rð$ð ô C.Ð Ü dNÔ +ØNCÜ S/Ð !Ü dÔ ,Ô -´#°d·g±g³,Ä#ÀeÇhÁhÃ-Ò2OðØGG9G E§H¡H :¨Qð0ð ô S/Ð !Ü §¡Ô ,°·±¸e¿j¹jÒ1Hà"&§*¡*×"CÑ"CÀEÇKÁKÓ"PÑ HiÙ Ó)DÙ Ó+Eô .¨dÓ3Ü T°Ô6Ü.¨uÓ5Ü e°4Ô8ä dÔ /Ô 0´JØ Ô&ô5
|
ð äD *¨dÓ3EÜE 7¨EÓ2×7Ñ7EÜE :¨uÓ5EÜE 7¨EÓ2×7Ñ7EØÐ U¨e¡^à
|
|
ä djj°Ô8àUEÐ!Ð!rZ ©rg rf c ó | |||¬« S )Nr rU )rr Úscalarsrg rf s rX Ú_from_sequencez IntervalArray._from_sequence s ñ 7 %¨dÔ3Ð3rZ c ó< | j ||j ¬« S )Nrh )r rg )rr ÚvaluesÚoriginals rX Ú_from_factorizedz IntervalArray._from_factorized s à×!Ñ! &°·±Ð!Ó?Ð?rZ ac
|
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. %(name)s
|
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_breaksrI zÒ Examples
|
--------
|
>>> pd.arrays.IntervalArray.from_breaks([0, 1, 2, 3])
|
<IntervalArray>
|
[(0, 1], (1, 2], (2, 3]]
|
Length: 3, dtype: interval[int64, right]
|
)rJ rL rQ c óP t |« }| j |d d |dd |||¬« S )NéÿÿÿÿrT ©rf rg )rl Ú from_arrays)rr Úbreaksrc rf rg s rX r zIntervalArray.from_breaksµ s4 ô2 2°&Ó9àv c r{¨F°1°2¨J¸ÀTÐQVÓWÐWrZ aC
|
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. %(name)s
|
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 r zÚ Examples
|
--------
|
>>> 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 ó² t |« }t |« }| j |||||¬« \ }}}| j |||¬« | j |||¬« S )Nre rh )rl ro rp rq )rr ru rv rc rf rg s rX r zIntervalArray.from_arrays sl ô4 0°Ó5Ü0°Ó7à × :Ñ :Ø Ø ØØØð ;ó
|
ÑeUð dE¨ Ô/àt U°%Ó8Ð8rZ aÚ
|
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. %(name)s
|
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 ó® t |« rg g }}n|x}}|D ]d }t |t « s t |« rt j
|
x}} n| j }
|
|\ }} |j |« |j | « f | j |||d|¬« S # t $ r} |
|
d| } t | « | d } ~ wt $ r} |
|
d| } t | « | d } ~ ww xY w)Nz..from_tuples requires tuples of length 2, got z'.from_tuples received an invalid item, Fr ) Úlenri Útupler2 ÚnpÚnanrj r rk Úappendr ) rr rs rc rf rg ru rv ÚdÚlhsÚrhsrL Úerrrw s rX r¡ zIntervalArray.from_tuplesM sð ô2 t9Ø b%Dð Ð D5àò AÜ a¤Ô'¬D°¬GÜ FFÐ"cà||ð2à HCð KKÔ Ø LLÕ ð ð" t U¨F¸ÀeÓLÐLøô "ò 3Ø !FÐ"PÐQRÐPSÐTCÜ$ S/¨sÐ2ûÜ ò 2Ø !FÐ"IÈ!ÈÐMCÜ# C.¨cÐ1ûð2ús$ ÁB C B0Â0 CÂ<CÃCc óD t |t « sd| }t |« t |« t |« k7 r d}t |« t |« }t |« }||k( j « s d}t |« || || k j « s d}t |« y)zì
|
Verify that the IntervalArray is valid.
|
|
Checks that
|
|
* dtype is correct
|
* left and right match lengths
|
* left and right have the same missing values
|
* left is always below right
|
zinvalid dtype: 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)ri r, r r£ r3 Úall)rr ru rv rg rw Ú left_maskÚ
|
right_masks rX rp zIntervalArray._validate sª ô %¤ Ô/Ø# E 7Ð+CÜ S/Ð !Ü t9E
|
Ò "Ø<CÜ S/Ð !Ü$K Ü5\
|
ØZÑ'×,Ñ,Ô.ð5ð ô S/Ð !ØY 5¨Ñ#3Ñ3×8Ñ8Ô:Ø?CÜ S/Ð !ð ;rZ c ó t |j | j ¬« }| j |||¬« \ }}}| j |||¬« 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.
|
rb rh )r, rg rc ro rq ©rW ru rv rg s rX Ú _shallow_copyzIntervalArray._shallow_copy sN ô djj°·±Ô=Ø !× ;Ñ ;¸DÀ%ÈuÐ ;Ó UÑeUà× Ñ e°5Ð Ó9Ð9rZ c ó | j S r{ )r^ rV s rX rg zIntervalArray.dtype° s à{{ÐrZ c ó\ | j j | j j z S r{ )ru Únbytesrv rV s rX rµ zIntervalArray.nbytes´ s! àyy× Ñ $§*¡*×"3Ñ"3Ñ3Ð3rZ c ó. | j j S r{ )ru ÚsizerV s rX r· zIntervalArray.size¸ s ð yy~~Ð rZ c ó> t t j | « « S r{ )Úiterr¥ ÚasarrayrV s rX Ú__iter__zIntervalArray.__iter__À s ÜBJJtÓ$Ó%Ð%rZ c ó, t | j « S r{ )r£ r\ rV s rX Ú__len__zIntervalArray.__len__à s Ü4::Ð rZ c ó y r{ rU ©rW Úkeys rX Ú __getitem__zIntervalArray.__getitem__Æ ó à rZ c ó y r{ rU r¿ s rX rÁ zIntervalArray.__getitem__Ê r rZ c ó t | |« }| j | }| j | }t |t j
|
t f« s9t |« rt |« r | j S t ||| j « S t j |« dkD r t d« | j ||| j ¬« S )NrT z&multi-dimensional indexing not allowedrh )r@ r\ r] ri r¥ Úndarrayr9 r' r2 Ú _fill_valuer rc rY r rq rg )rW rÀ ru rv s rX rÁ zIntervalArray.__getitem__Î s¢ Ü! $¨Ó,Øzz#Ø CÑ ä$¤§¡¬^Ð <Ô=ä¤4¨¤:Ø×'Ñ'Ð'ÜD %¨¯©Ó5Ð 5Ü 774=1Ò ä Ð EÓFÐ Fð
|
× Ñ e°4·:±:Ð Ó>Ð>rZ c ó | j |« \ }}t | |« }|| j |< || j |< y r{ )Ú_validate_setitem_valuer@ r\ r] )rW rÀ ÚvalueÚ
|
value_leftÚ value_rights rX Ú __setitem__zIntervalArray.__setitem__á s> Ø"&×">Ñ">¸uÓ"EÑ
|
KÜ! $¨Ó,à$
|
|
3Ø& CÒrZ c óî t |« r.t | « t |« k7 r t d« t |« }n~t |t
|
« sn|t u rYddlm} t j | j t ¬« }t j | j t ¬« } |||« S t | ||« S t |t
|
« r t d« }nÃt |j t" « s |j }n|j$ j }t |t& « rv| j( |j$ j( k7 r t | ||« S |j$ j* j- |j. d|j$ j0 ¬« }t |t& « r·| j( |j( k7 r t | ||« S t |t
|
« s t3 | « |« }|t4 j6 u r3| j8 |j: k( | j< |j> k( z S |t4 j@ u r3| j8 |j: k7 | j< |j> k7 z S |t4 jB u rM| j8 |j: kD | j8 |j: k( | j< |j> kD z z S |t4 jD u r | |k( | |kD z S |t4 jF u rM| j8 |j: k | j8 |j: k( | j< |j> k z z S | |k( | |k z S tI |« s t | ||« S t jJ t | « t ¬« }tM |« D ] \ }} || | | « ||< |S # tN $ r+ | t u r |jQ tR « }t ||< n Y Mw xY w)Nz Lengths must match to comparer )Ú BooleanArrayrh ÚintervalT©Ú
|
allow_fillÚ
|
fill_value)*r% r£ r Úpd_arrayri r r Úpandas.core.arraysrÎ r¥ ÚemptyÚshapeÚboolÚonesrA r* rg r+ Ú
|
categoriesr, rc Ú_valuesr5 ÚcodesÚ _na_valuer ÚoperatorÚeqr\ ru r] rv ÚneÚgtÚger r& ÚzerosÚ enumeraterk r
rm )
|
rW ÚotherÚoprÎ ÚarrÚmaskÚ other_dtyper| ÚiÚobjs
|
rX Ú _cmp_methodzIntervalArray._cmp_methodè s@ ä Ô Ü4yC JÒ&Ü Ð!@ÓAÐAÜ UOEÜE¤8Ô,à{å;ähhtzz´Ô6Üwwtzz´Ô6Ù# C¨Ó.Ð.Ü% d¨E°2Ó6Ð 6ô eXÔ &Ü& zÓ2KÜEKKÔ)9Ô:Ø ++Kð ×*Ñ*×0Ñ0Kô +¤}Ô5Ø;; %×"2Ñ"2×"9Ñ"9Ò9Ü-¨d°E¸2Ó>Ð>à ×(Ñ(×0Ñ0×5Ñ5ØKK¨D¸U×=MÑ=M×=WÑ=Wð 6ó ô
|
k¤=Õ 1Ø{{ellÒ*Ü)¨$°°rÓ:Ð:Ü ¤xÔ0Ø"T
|
5Ó)àX[[Ñ Ø
|
|
e§j¡jÑ0°T·[±[ÀEÇKÁKÑ5OÑPÐPØx{{Ñ"Ø
|
|
e§j¡jÑ0°T·[±[ÀEÇKÁKÑ5OÑPÐPØx{{Ñ"Ø
|
|
U§Z¡ZÑ/ØZZ 5§:¡:Ñ-°$·+±+ÀÇ Á Ñ2KÑLñð ð x{{Ñ"Ø ¨$°©,Ñ7Ð7Øx{{Ñ"Ø
|
|
U§Z¡ZÑ/ØZZ 5§:¡:Ñ-°$·+±+ÀÇ Á Ñ2KÑLñð ð
|
¨$°©,Ñ7Ð7ô {Ô+Ü% d¨E°2Ó6Ð 6ô #d)¬4Ô0Ü Ó&ò
|
FAsð Ù t Aw¨Ó ,q ð
|
ð øô ò Ø"9ð $]]¬6Ó 2FÜ "F1Iàñ ð ús Î-O Ï 1O4Ï3O4Ú__eq__c óB | j |t j « S r{ )rë rÝ rÞ ©rW rä s rX rì zIntervalArray.__eq__7 ó à× Ñ ¤x§{¡{Ó3Ð3rZ Ú__ne__c óB | j |t j « S r{ )rë rÝ rß rî s rX rð zIntervalArray.__ne__; rï rZ Ú__gt__c óB | j |t j « S r{ )rë rÝ rà rî s rX rò zIntervalArray.__gt__? rï rZ Ú__ge__c óB | j |t j « S r{ )rë rÝ rá rî s rX rô zIntervalArray.__ge__C rï rZ Ú__lt__c óB | j |t j « S r{ )rë rÝ r rî s rX rö zIntervalArray.__lt__G rï rZ Ú__le__c óB | j |t j « S r{ )rë rÝ r rî s rX rø zIntervalArray.__le__K rï rZ Ú quicksortÚlast©Ú ascendingÚkindÚ na_positionc óÆ t j |d|« }|r5|dk( r0|dk( r+t j | j | j
|
f« S t | d|||d|¤S )NrU rú rû rü )ÚnvÚ validate_argsort_with_ascendingr¥ Úlexsortrv ru ÚsuperÚargsort)rW rý rþ rÿ ÚkwargsÚ __class__s rX r zIntervalArray.argsortO so ø ô ×6Ñ6°yÀ"ÀfÓM á Ò,°ÀÒ1Fô ::tzz¨4¯9©9Ð 5Ó6Ð 6ô wð
|
Ø d¸ ñ
|
ØGMñ
|
ð
|
rZ )ÚaxisÚskipnac ó t j || j « t | « s | j S | j « }|j « r|s | j S | | }n| }|j « d }|| S )Nr ©r Úvalidate_minmax_axisrY r£ rÜ r2 Úanyr ©rW r r rç rê Úindexers rX ÚminzIntervalArray.minc sr Ü
|
× Ñ d§i¡iÔ0ä4yØ>>Ð !àyy{Ø 88:ÙØ~~Ð%Øu+CàCà++- Ñ"Ø7|ÐrZ c ó t j || j « t | « s | j S | j « }|j « r|s | j S | | }n| }|j « d }|| S )Nr r r s rX ÚmaxzIntervalArray.maxt sr Ü
|
× Ñ d§i¡iÔ0ä4yØ>>Ð !àyy{Ø 88:ÙØ~~Ð%Øu+CàCà++- Ñ#Ø7|ÐrZ )ÚlimitÚ
|
limit_arearf c ó* t | ||||¬« S )N)Úmethodr r rf )r Ú_pad_or_backfill)rW r r r rf r s rX r z IntervalArray._pad_or_backfill
s% ø ô wÑ'Ø °:ÀDð (ó
|
ð
|
rZ c óü |du rt |t | |||¬« S | j |« \ }}| j j |¬« }| j
|
j |¬« }| j ||« 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.
|
copy : bool, default True
|
Whether to make a copy of the data before filling. If False, then
|
the original should be modified and no new memory should be allocated.
|
For ExtensionArray subclasses that cannot do this, it is at the
|
author's discretion whether to ignore "copy=False" or to raise.
|
|
Returns
|
-------
|
filled : IntervalArray with NA/NaN filled
|
F)rÉ r r )rÉ )ÚNotImplementedErrorr ÚfillnaÚ_validate_scalarru rv r² )
|
rW rÉ r r rf rÊ rË ru rv r s
|
rX r zIntervalArray.fillna s ø ðD 5=Ü%Ð %Ø Ð Ü7>¨°fÀE>ÓJÐ Jà"&×"7Ñ"7¸Ó">Ñ
|
Kàyy× Ñ jÐ Ó1Ø
|
|
×!Ñ!¨ Ð!Ó4Ø×!Ñ! $¨Ó.Ð.rZ c ó, ddl m} | t |« }t |t « râ|| j
|
k( r|r| j « S | S t | j
|
j « r3t |j « r d| j
|
d| d}t |« || j d¬« j |j « } || j d¬« j |j « }| j! ||« S t" | 1 ||¬« S # t $ r t t f$ r$}d| j
|
d| d}t |« |d}~ww xY w# t t f$ r,}d t% | « j& d
|
| }t |« |d}~ww xY w) 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 ©rE NzCannot convert z to z; subtypes are incompatibleFr z Cannot cast z
|
to dtype )ÚpandasrE r* ri r, rg rf r# r r) rk r\ r
r] r r r² r r rj ) rW rg rf rE rw Únew_leftÚ new_rightr« r s rX r
zIntervalArray.astypeÀ s ø õ& !à Ð Ü Ó'Eä e]Ô +Ø
|
|
Ò"Ù&*tyy{Ð4°Ð4ä djj× 0Ñ 0Ô1Ô6IØ ô7ð
|
& d§j¡j \°°e°WÐ<WÐXð ô nÐ$ð .ñ ! §¡°%Ô8×?Ñ?ÀÇ Á ÓNÙ ! $§+¡+°EÔ :× AÑ AÀ%Ç-Á-Ó P ð ×%Ñ% h° Ó:Ð :ð .Ü w~ e°$~Ó7Ð7øô &ò àÜ zÐ*ò .ð & d§j¡j \°°e°WÐ<WÐXð ô n¨#Ð-ûð .ûô zÐ*ò .Ø$¤T¨$£Z×%8Ñ%8Ð$9¸ÀEÀ7ÐKÜ n¨#Ð-ûð .ús1 ÂAD ÄE ÄEÄ1 EÅEÅFÅ''FÆFc ó t | « t |« k7 ryt | j |j k( xrL | j j |j « xr% | j
|
j |j
|
« « S )NF)r r× rc ru Úequalsrv rî s rX r" zIntervalArray.equalsý sh Ü :eÒ $ØäØ KK5<<Ñ 'ò /Ø × Ñ §¡Ó,ò /à
|
|
×!Ñ! %§+¡+Ó.ó
|
ð
|
rZ c ó° |D ch c] }|j }}t |« dk7 r t d« |j « }t j
|
|D cg c] }|j c}« }t j
|
|D cg c] }|j c}« }| j |||¬« \ }}}| j |||¬« S c c}w c c}w c c}w )zÀ
|
Concatenate multiple IntervalArray
|
|
Parameters
|
----------
|
to_concat : sequence of IntervalArray
|
|
Returns
|
-------
|
IntervalArray
|
rT z.Intervals must all be closed on the same side.rb rh )
|
rc r£ r Úpopr¥ Ú concatenateru rv ro rq )rr Ú to_concatrÏ Ú
|
closed_setrc ru rv rg s rX Ú_concat_same_typez IntervalArray._concat_same_type s¼ ð 7@Ö@¨(hooÐ@
|
Ð@Ü z?aÒ Ü Ð MÓNÐ NØ Ó!ä ^^È9Ö,U¸x¨X¯]«]Ò,UÓ VÜ nnÈYÖ-WÀ¨h¯n«nÒ-WÓ Xà × :Ñ :¸4ÀÈvÐ :Ó VÑeUàt U°%Ó8Ð8ùò Aùò
|
-VùÚ-Ws
C ÁCÂCc óª | j j « }| j j « }| j }| j |||¬« S )zd
|
Return a copy of the array.
|
|
Returns
|
-------
|
IntervalArray
|
rh )r\ rf r] rg rq r± s rX rf zIntervalArray.copy sG ð zzÓ Ø × Ñ Ó"Ø
|
|
Ø× Ñ e°5Ð Ó9Ð9rZ c ó, t | j « S r{ )r2 r\ rV s rX r2 zIntervalArray.isna- s ÜDJJÓ Ð rZ c óÜ t | « r|dk( r| j « S | j |« t t |« t | « « }t |« rAddlm} || j d¬« j }t j |g|dz z « }n!| j |g|z | j ¬« }|dkD r |}| d | }n| t |« d }|}| j ||g« S )Nr r Fr rT rh )r£ rf r r Úabsr2 r rE r\ rÜ rH r r rg r( )rW ÚperiodsrÒ Ú empty_lenrE rÕ ÚaÚbs rX ÚshiftzIntervalArray.shift0 sÞ Ü4yG qLØ99;Ð à × Ñ jÔ)ô G ¤c¨$£iÓ0 Ü
|
Ô Ý $á tzz°Ô6×@Ñ@JÜ!×-Ñ-¨z¨l¸iÈ!¹mÑ.LÓMEà×'Ñ'¨¨ °yÑ(@ÈÏ
|
É
|
Ð'ÓSEà Q;ØAØYwhAàS\^Ð$AØAØ×%Ñ% q¨! fÓ-Ð-rZ )rÑ rÒ r c óê t j d|« |x}}|r| j |« \ }}t | j |||¬« }t | j
|
|||¬« } | j || « 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.
|
rU rÐ )r Ú validate_taker r5 r\ r] r² )
|
rW ÚindicesrÑ rÒ r r Ú fill_leftÚ
|
fill_rightÚ left_takeÚ
|
right_takes
|
rX r5 zIntervalArray.takeL s| ôl ×ÑVÔ$à!+Ð+ JÙ Ø$(×$9Ñ$9¸*Ó$EÑ !IzäØ JJ¨JÀ9ô
|
ô Ø KK¨ZÀJô
|
|
ð ×!Ñ! )¨ZÓ8Ð8rZ c ól t |« }| j |d¬« |j |j }} | j j |« ||fS # t $ r }dt |« d}t |« |d }~ww xY w# t t f$ r }dt |« d}t |« |d }~ww xY w)NrÉ ©rL z('value' should be an interval type, got z instead.z2'value' should be a compatible interval type, got )rH Ú_check_closed_matchesru rv rk r Ú_validate_fill_valuer! )rW rÉ r= rÊ rË r« rw s rX Ú_validate_listlikez IntervalArray._validate_listlike sÇ ð *Ü! %Ó(EØ × &Ñ & u°7Ð &Ô ;Ø&+§j¡j°%·+±+ Jð *Ø II× *Ñ *¨:Ô 6ð ;Ð&Ð&øô ò *à<¼TÀ%»[¸MÈÐSCÜC. cÐ )ûð *ûô "¤9Ð-ò *ðÜE{m 9ð.ð ô C. cÐ )ûð *ús. 6A ¹B Á BÁ!A<Á<BÂB3ÂB.Â.B3c ó t |t « r/| j |d¬« |j |j }}||fS t || j j « r | j j x}}||fS t d« )NrÉ r: z=can only insert Interval objects and NA into an IntervalArray) ri r r; ru rv r1 rg rÜ rk )rW rÉ ru rv s rX r z IntervalArray._validate_scalar§ s Ü eXÔ &Ø × &Ñ & u°7Ð &Ô ;Ø ** e§k¡k%Dð U{Ðô # 5¨$¯)©)¯/©/Ô :à 99×.Ñ.Ð .D5ð
|
U{Ðô ØOóð rZ c óÞ t || j j « rH| j j }t | j j
|
« r t d« ||}}||fS t |t « re| j |d¬« |j |j }}| j j |« | j j |« ||fS | j |« S )Nz4Cannot set float NaN to integer-backed IntervalArrayrÉ r: ) r1 ru rg rÜ r$ r rk ri r r; rv r< r= )rW rÉ rÊ rË s rX rÈ z%IntervalArray._validate_setitem_valueµ sÍ Ü ¨¯ © ¯©Ô 8àII×'Ñ'EÜ §
|
¡
|
× 2Ñ 2Ô3ô Ð VÓWÐWØ&+¨U Jð ;Ð&Ð&ô xÔ (à × &Ñ & u°7Ð &Ô ;Ø&+§j¡j°%·+±+ JØ II× *Ñ *¨:Ô 6Ø II× *Ñ *¨;Ô 7ð
|
;Ð&Ð&ð ×*Ñ*¨5Ó1Ð 1rZ c óÒ t j « 5 t j ddt ¬« t t j | « |¬« }ddd« |S # 1 sw Y S xY w)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
|
Úignorez<The behavior of value_counts with object-dtype is deprecated)Úcategory)ÚdropnaN)ÚwarningsÚcatch_warningsÚfilterwarningsÚ FutureWarningÚ value_countsr¥ rº )rW rC r| s rX rH zIntervalArray.value_countsÌ s_ ô$ × $Ñ $Ó &ñ CÜ × #Ñ #ØØNÜ&õ ô
|
"¤"§*¡*¨TÓ"2¸6ÔBF÷ Cð ÷ Cð ús =A Á A&c ó t S r{ )r )rW Úboxeds rX Ú
|
_formatterzIntervalArray._formatterì s ô
|
rZ c ó6 ddl m} || j d¬« S )a
|
Return the left endpoints of each Interval in the IntervalArray as an Index.
|
|
Examples
|
--------
|
|
>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(2, 5)])
|
>>> interv_arr
|
<IntervalArray>
|
[(0, 1], (2, 5]]
|
Length: 2, dtype: interval[int64, right]
|
>>> interv_arr.left
|
Index([0, 2], dtype='int64')
|
r r Fr )r rE r\ ©rW rE s rX ru zIntervalArray.leftô s õ !áTZZ eÔ,Ð,rZ c ó6 ddl m} || j d¬« S )a
|
Return the right endpoints of each Interval in the IntervalArray as an Index.
|
|
Examples
|
--------
|
|
>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(2, 5)])
|
>>> interv_arr
|
<IntervalArray>
|
[(0, 1], (2, 5]]
|
Length: 2, dtype: interval[int64, right]
|
>>> interv_arr.right
|
Index([1, 5], dtype='int64')
|
r r Fr )r rE r] rM s rX rv zIntervalArray.right s õ !áT[[ uÔ-Ð-rZ c ó4 | j | j z
|
S )a
|
Return an Index with entries denoting the length of each Interval.
|
|
Examples
|
--------
|
|
>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)])
|
>>> interv_arr
|
<IntervalArray>
|
[(0, 1], (1, 5]]
|
Length: 2, dtype: interval[int64, right]
|
>>> interv_arr.length
|
Index([1, 4], dtype='int64')
|
)rv ru rV s rX ÚlengthzIntervalArray.length s ð zzDIIÑ%Ð%rZ c ó d| j | j z z S # t $ r | j d| j z z cY S w xY w)a
|
Return the midpoint of each Interval in the IntervalArray as an Index.
|
|
Examples
|
--------
|
|
>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)])
|
>>> interv_arr
|
<IntervalArray>
|
[(0, 1], (1, 5]]
|
Length: 2, dtype: interval[int64, right]
|
>>> interv_arr.mid
|
Index([0.5, 3.0], dtype='float64')
|
g à?)ru rv rk rP rV s rX ÚmidzIntervalArray.mid. sF ð 1Ø$)) d§j¡jÑ0Ñ1Ð 1øÜò 1à99s T§[¡[Ñ 0Ñ0Ò 0ð 1ús %AÁAaI
|
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]
|
)rJ rQ c ó¦ t |t t f« rt t |t « s#dt |« j }t |« | j r|j rt nt }|j r| j rt nt } || j |j « ||j | j « z S )Nz#`other` must be Interval-like, got )ri rH r/ r r r rj rk Ú closed_leftÚ closed_rightr r ru rv )rW rä rw Úop1Úop2s rX rS zIntervalArray.overlapsl s ô" emÔ-=Ð >Ô ?Ü%Ð %Ü%¤Ô*Ø7¼¸U» ×8LÑ8LÐ7MÐNCÜC.Ð ð ×%Ò%¨%×*<Ò*<bÄ2Ø×&Ò&¨4×+<Ò+<bÄ2ñ
|
499ekkÓ*©S°·±¸T¿Z¹ZÓ-HÑHÐHrZ c ó. | j j S )a¢
|
String describing the inclusive side the intervals.
|
|
Either ``left``, ``right``, ``both`` or ``neither``.
|
|
Examples
|
--------
|
|
For arrays:
|
|
>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)])
|
>>> interv_arr
|
<IntervalArray>
|
[(0, 1], (1, 5]]
|
Length: 2, dtype: interval[int64, right]
|
>>> interv_arr.closed
|
'right'
|
|
For Interval Index:
|
|
>>> interv_idx = pd.interval_range(start=0, end=2)
|
>>> interv_idx
|
IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]')
|
>>> interv_idx.closed
|
'right'
|
)rg rc rV s rX rc zIntervalArray.closed s ð8 zz× Ñ Ð rZ aZ
|
Return an identical %(klass)s 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
|
-------
|
%(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 ó¸ |t vrd| }t |« | j | j }}t |j
|
|¬« }| j |||¬« S )Nz invalid option for 'closed': rb rh )r r r\ r] r, rg rq )rW rc rw ru rv rg s rX rZ zIntervalArray.set_closed¾ s[ ð, Ñ %Ø1°&°Ð:CÜ S/Ð !àjj $§+¡+eÜ djj°Ô8Ø× Ñ e°5Ð Ó9Ð9rZ ak
|
Return a boolean whether the %(klass)s is non-overlapping and monotonic.
|
|
Non-overlapping means (no Intervals share points), and monotonic means
|
either monotonic increasing or monotonic decreasing.
|
|
Examples
|
--------
|
For arrays:
|
|
>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)])
|
>>> interv_arr
|
<IntervalArray>
|
[(0, 1], (1, 5]]
|
Length: 2, dtype: interval[int64, right]
|
>>> interv_arr.is_non_overlapping_monotonic
|
True
|
|
>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1),
|
... pd.Interval(-1, 0.1)])
|
>>> interv_arr
|
<IntervalArray>
|
[(0.0, 1.0], (-1.0, 0.1]]
|
Length: 2, dtype: interval[float64, right]
|
>>> interv_arr.is_non_overlapping_monotonic
|
False
|
|
For Interval Index:
|
|
>>> interv_idx = pd.interval_range(start=0, end=2)
|
>>> interv_idx
|
IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]')
|
>>> interv_idx.is_non_overlapping_monotonic
|
True
|
|
>>> interv_idx = pd.interval_range(start=0, end=2, closed='both')
|
>>> interv_idx
|
IntervalIndex([[0, 1], [1, 2]], dtype='interval[int64, both]')
|
>>> interv_idx.is_non_overlapping_monotonic
|
False
|
Ú is_non_overlapping_monotonicc ó´ | j dk( ret | j d d | j dd k j « xs- | j d d | j dd kD j « « S t | j d d | j dd k j « xs- | j d d | j dd k\ j « « S )NÚbothr rT )rc r× r] r\ r rV s rX r\ z*IntervalArray.is_non_overlapping_monotonic sÌ ð ;;&Ò ÜØSbÐ! D§J¡J¨q¨r NÑ2×7Ñ7Ó9ò =ØJJs O d§k¡k°!°" oÑ5×:Ñ:Ó<óð ô Ø [["Ð §¡¨A¨B Ñ /× 4Ñ 4Ó 6ò :Ø
|
|
3B 4§;¡;¨q¨r ?Ñ2×7Ñ7Ó9ó
|
ð
|
rZ c ó |du r$t j dt t « ¬« | j }| j
|
}| j « }| j }t j t |« t ¬« }t |« D ]1 \ }} || rt j ||< t | || |« ||< 3 |S )zt
|
Return the IntervalArray's data as a numpy array of Interval
|
objects (with dtype='object')
|
FaS Starting with NumPy 2.0, the behavior of the 'copy' keyword has changed and passing 'copy=False' raises an error when returning a zero-copy NumPy array is not possible. pandas will follow this behavior starting with pandas 3.0.
|
This conversion to NumPy requires a copy, but 'copy=False' was passed. Consider using 'np.asarray(..)' instead.)Ú
|
stacklevelrh )rD ÚwarnrG r r\ r] r2 rc r¥ rÕ r£ rm rã r¦ r )
|
rW rg rf ru rv rç rc r| ré Ú
|
left_values
|
rX Ú __array__zIntervalArray.__array__# s ð 5=Ü MMð2ô Ü+Ó-õ ð zzØ Øyy{Øä#d)¬6Ô2Ü & t_ò CMAzØAwÜ FFq ä $ Z°°q±¸6Ó Bq ð Cð
|
rZ c ó2 ddl }ddlm} |j | j j
|
« } ||| j « }|j j |j | j |d¬« |j | j |d¬« gdd g¬
|
« }| j « }|j « rv|j | « j « d } |j j! |j" t% |« | g|j' d« |j' d « g¬ « }||j) |j* « r|S t- ||« r[|j) |« sYt d | j j
|
d|j
|
d| j d|j d « t d| d« |j. j1 ||« S # t $ r)}t d| j j
|
d« |d}~ww xY w)z6
|
Convert myself into a pyarrow Array.
|
r N)ÚArrowIntervalTypez"Conversion to arrow with subtype 'z' is not supportedT)r Ú from_pandasru rv )ÚnamesrT )Ú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)ÚpyarrowÚ(pandas.core.arrays.arrow.extension_typesre Úfrom_numpy_dtyperg r rk rc Ú StructArrayr r= r\ r] r2 r ÚbuffersÚ from_buffersr r£ Úfieldr" Ú storage_typeri r9 Ú from_storage)
|
rW r ri re r r« Ú interval_typeÚ storage_arrayrç Ú null_bitmaps
|
rX Ú__arrow_array__z IntervalArray.__arrow_array__C s ó åNð Ø ×.Ñ.¨t¯z©z×/AÑ/AÓBGñ *¨'°4·;±;Ó? Ø ×+Ñ+×7Ñ7à djj¨wÀD ÓIØ dkk°ÀT ÓJð ð 7Ð#ð 8ó
|
ð yy{Ø 88:à!--¨¨Ó.×6Ñ6Ó8¸Ñ;KØ #× /Ñ /× <Ñ <Ø ×"Ñ"ÜMÓ"Ø Ø'×-Ñ-¨aÓ0°-×2EÑ2EÀaÓ2HÐIð =ó Mð Ð Ø{{=×5Ñ5Ô6Ø$Ð$ÜDÐ"3Ô4à{{ =Ô1Ü#ð0Ø04·
|
±
|
×0BÑ0BÐ/CÀ4ÈÏ É À~ð V)Ø)-¯©¨ °T¸$¿+¹+¸ ÀlðTóð ô ØAÀ$ÀÀvÐNóð ð ×%Ñ%×2Ñ2°=À-ÓPÐPøôQ ò ÜØ4°T·Z±Z×5GÑ5GÐ4Hð I#ð #óð ð ûð ús %G$ Ç$ HÇ-$HÈHam
|
Return an %(return_type)s of tuples of the form (left, right).
|
|
Parameters
|
----------
|
na_tuple : bool, default True
|
If ``True``, return ``NA`` as a tuple ``(nan, nan)``. If ``False``,
|
just return ``NA`` as ``nan``.
|
|
Returns
|
-------
|
tuples: %(return_type)s
|
%(examples)s Ú to_tupleszFndarray (if self is IntervalArray) or Index (if self is IntervalIndex)aq
|
Examples
|
--------
|
For :class:`pandas.IntervalArray`:
|
|
>>> idx = pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 2)])
|
>>> idx
|
<IntervalArray>
|
[(0, 1], (1, 2]]
|
Length: 2, dtype: interval[int64, right]
|
>>> idx.to_tuples()
|
array([(0, 1), (1, 2)], dtype=object)
|
|
For :class:`pandas.IntervalIndex`:
|
|
>>> idx = pd.interval_range(start=0, end=2)
|
>>> idx
|
IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]')
|
>>> idx.to_tuples()
|
Index([(0, 1), (1, 2)], dtype='object')
|
)Ú return_typerQ c óØ t j t | j | j « « }|s4t j | j « |t
|
j « }|S r{ ) ÚcomÚasarray_tuplesafeÚzipr\ r] r¥ Úwherer2 r¦ )rW Úna_tupleÚtupless rX rv zIntervalArray.to_tuples sJ ôB ×&Ñ&¤s¨4¯:©:°t·{±{Ó'CÓDÙäXXtyy{l¨F´B·F±FÓ;FØ rZ c ó | j |« \ }}t | j t j « rit j
|
| j ||« t | j t j « sJ t j
|
| j ||« y | j j ||« t | j t j « rJ | j j ||« y r{ )rÈ ri r\ r¥ rÅ Úputmaskr] Ú_putmask)rW rç rÉ rÊ rË s rX r zIntervalArray._putmask± s© Ø"&×">Ñ">¸uÓ"EÑ
|
Kä djj¤"§*¡*Ô -Ü JJtzz 4¨Ô 4Ü dkk¬2¯:©:Ô6Ð 6Ð6Ü JJt{{ D¨+Õ 6à JJ× Ñ jÔ 1Ü! $§+¡+¬r¯z©zÔ:Ð :Ð:Ø KK× Ñ {Õ 3rZ c ó¾ | j |« \ }}| j j ||« }| j j ||« }| j ||« S )ac
|
Return a new IntervalArray inserting new item at location. Follows
|
Python numpy.insert semantics for negative values. Only Interval
|
objects and NA can be inserted into an IntervalIndex
|
|
Parameters
|
----------
|
loc : int
|
item : Interval
|
|
Returns
|
-------
|
IntervalArray
|
)r ru Úinsertrv r² )rW ÚlocÚitemÚ left_insertÚ right_insertr r s rX r zIntervalArray.insert½ sX ð %)×$9Ñ$9¸$Ó$?Ñ! \à99×#Ñ# C¨Ó5ØJJ×%Ñ% c¨<Ó8 à×!Ñ! (¨IÓ6Ð6rZ c óö t | j t j « rgt j | j |« }t | j
|
t j « sJ t j | j
|
|« }n\| j j |« }t | j
|
t j « rJ | j
|
j |« }| j ||¬« S )N©ru rv )ri r\ r¥ rÅ Údeleter] r² )rW r r r s rX r zIntervalArray.deleteÓ sª Ü djj¤"§*¡*Ô -Üyy §¡¨SÓ1HÜ dkk¬2¯:©:Ô6Ð 6Ð6Ü $§+¡+¨sÓ3Iàzz×(Ñ(¨Ó-HÜ! $§+¡+¬r¯z©zÔ:Ð :Ð:Ø ×*Ñ*¨3Ó/IØ×!Ñ! x°yÐ!ÓAÐArZ Úrepeatc óÄ t j dd|i« | j j |« }| j j |« }| j ||¬« S )NrU r r )r Úvalidate_repeatru r rv r² )rW Úrepeatsr Ú left_repeatÚ right_repeats rX r zIntervalArray.repeatÞ sV ô ×Ñ2 ¨~Ô.Øii×&Ñ& wÓ/ Øzz×(Ñ(¨Ó1 Ø×!Ñ! {¸,Ð!ÓGÐGrZ a¼
|
Check elementwise if the Intervals contain the value.
|
|
Return a boolean mask whether the value is contained in the Intervals
|
of the %(klass)s.
|
|
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 óæ t |t « r t d« | j r| j |k n| j |k | j
|
r|| j k z S || j k z S )Nz*contains not implemented for two intervals)ri r r Ú open_leftr\ Ú
|
open_rightr] rî s rX r zIntervalArray.contains si ô eXÔ &Ü%Ð&RÓSÐ Sà&*§n¢n
|
|
UÒ"¸$¿*¹*ÈÑ:MØ#'§?¢?EDKKÑ ñ
|
ð
|
Ø8=ÀÇÁÑ8Lñ
|
ð
|
rZ c ó² t |t « r| j |j k7 r%t j | j
|
t ¬« S | j |j k( rZ| j j d« }|j j d« }t j ||« j « S t | j j « t |j j « z r%t j | j
|
t ¬« S t | j t « |j t « « S )Nrh Ú
|
complex128)ri rH rc r¥ râ rÖ r× rg Ú _combinedÚviewr4 Úravelr) ru r
rm )rW r ru rv s rX r4 zIntervalArray.isin sé Ü fmÕ ,Ø{{fmmÒ+äxx §
|
¡
|
´$Ô7Ð7àzzV\\Ò)ð ~~×*Ñ*¨<Ó8Ø ×(Ñ(×-Ñ-¨lÓ;ô wwt UÓ+×1Ñ1Ó3Ð3ä$ T§Y¡Y§_¡_Ó5Ô8KØ ×!Ñ!ó9ò ô xx §
|
¡
|
´$Ô7Ð7äDKK¤Ó'¨¯ © ´vÓ)>Ó?Ð?rZ c ó( | j j j dd« }| j j j dd« }t |j
|
« r|j ||gd¬« }|S t j ||gd¬« }|S )Nr rT )r ) ru rÚ Úreshaperv r) rg r( r¥ r% )rW ru rv Úcombs rX r zIntervalArray._combined: s ð yy× Ñ ×(Ñ(¨¨QÓ/Ø
|
|
×"Ñ"×*Ñ*¨2¨qÓ1Ü tzzÔ *ð ×)Ñ)Øu Að *ó Dð
|
ô >> 4¨ -°aÔ8DØ rZ c ó |j d« j dd« }| j j }t |« rt | j t t f« sJ t | j « j |dd
df |¬« }t | j t t f« sJ t | j « j |dd
df |¬« }nLt |t j « sJ |dd
df j |« }|dd
df j |« }| j ||¬« S ) zY
|
Create a new IntervalArray with our dtype from a 1D complex128 ndarray.
|
Úi8r é Nr rh rT r ) r r r\ rg r) ri r; r< r r r] r¥ r² )rW ÚcombinedÚncrg r r s rX Ú_from_combinedz IntervalArray._from_combinedJ s
|
ð ]]4Ó × (Ñ (¨¨QÓ /à
|
|
× Ñ Ü uÔ %Ü djj¬=¼.Ð*IÔJÐ JÐJÜDJJÓ'×6Ñ6°rº!¸Q¸$±xÀuÐ6ÓMHÜ dkk¬M¼>Ð+JÔKÐ KÐKÜ T[[Ó)×8Ñ8¸ºA¸q¸D¹ÈÐ8ÓOIä e¤R§X¡XÔ.Ð .Ð.Ø!Q$x}} UÓ+HØ1a4 eÓ,IØ×!Ñ! x°yÐ!ÓAÐArZ c ó t | j j d« d d
df « }|d d
d f }| j |« S )Nr r )r6 r r r¢ )rW r¡ s rX r6 zIntervalArray.unique\ sI ô Ø NN× Ñ Ó -ªa°¨dÑ 3ó
|
ð 4[Ø×"Ñ" 2Ó&Ð&rZ )Úreturnz
|
Literal[1])NNFT)rc úIntervalClosedType | Nonerg ú Dtype | Nonerf r× rt r× )ru r[ rv r[ rg r, r¤ r )NFN)rc r¥ rf r× rg r¦ r¤ z0tuple[IntervalSide, IntervalSide, IntervalDtype])rg r¦ rf r× r¤ r )r ú
|
np.ndarrayr rH r¤ r )rv FN)rc r¥ rf r× rg r¦ r¤ r )rg r, r¤ ÚNone)r¤ r )r¤ r, )r¤ Úint)r¤ rC )rÀ r r¤ Ú IntervalOrNA)rÀ r r¤ r )rÀ r r¤ zSelf | IntervalOrNA)r¤ r¨ )rý r× rþ r rÿ r r¤ r§ )r úAxisInt | Noner r× r¤ rª )
|
r r r ú
|
int | Noner z#Literal['inside', 'outside'] | Nonerf r× r¤ r )NNNT)r r¬ rf r× r¤ r )T)rf r× )r¤ r× )r& zSequence[IntervalArray]r¤ r )r¤ r§ )rT N)r- r© rÒ rm r¤ rH )rÑ r× r¤ r )rC r× r¤ rF )F)rJ r× )r¤ rE )r¤ r )rc r r¤ r )NN)rg zNpDtype | Nonerf z bool | Noner¤ r§ r{ )r} r× r¤ r§ )rç únpt.NDArray[np.bool_]r¤ r¨ )r r© r
r r¤ r )r zint | Sequence[int]r r« r¤ r )r r r¤ r )r¤ r[ )r r§ r¤ rH )r¤ rH )Rrj Ú
|
__module__Ú __qualname__Ú can_hold_nar¥ r¦ rÜ rÆ ÚpropertyrY Ú__annotations__ry Ú classmethodrq ro r r ÚtextwrapÚdedentrG r r r r¡ rp r² rg rµ r· r» r½ r rÁ rÌ rë rB rì rð rò rô rö rø r r r r r r
r" r( rf r2 r1 r5 r= r rÈ rH rK ru rv rP rR rS rc rZ Ú_shared_docs_kwargsr\ rc ru rv r r r r: r r r4 r r¢ r6 Ú __classcell__)r s @rX rH rH » s` ø
ð8 KØ ffÐ$I à òó ðð ÓØ ÓØ Óð -1Ø "ØØ!%ð 1
|
ð *ð1
|
ð ð 1
|
ð
|
ð 1
|
ð ó 1
|
ðf ð àð ð ð ð ð ð
|
|
ò ó ð ð ð
|
-1ØØ "ð ^"ð *ð ^"ð
|
ð ^"ð ð ^"ð
|
:ò^"ó ð^"ð@ ð
|
#Øñ 4ð ð 4ð
|
ð 4ð
|
ò 4ó ð4ð ò@ó ð@ð ,;¨8¯?©?ð ó ,Ð-Ñ(ð> Ù Ø mÑ,à$ØØ'ð ó ñ
|
ñ
|
óð( -4ØØ "ð Xð *ð Xð ð Xð
|
ð Xð
|
ò Xó#ó ð$ Xð ,;¨8¯?©?ð. ó0,Ð-Ñ(ðd Ù Ø mÑ,à$ØØ'ð ó ñ
|
ñ
|
óð* -4ØØ "ð 9ð *ð 9ð
|
ð 9ð ð 9ð
|
ò9ó#ó ð$9ð, ,;¨8¯?©?ð ó ,Ð-Ñ(ðB Ù Ø mÑ,à$ØØ'ð ó ñ
|
ñ
|
óð( -4ØØ "ð Mð *ð Mð ð Mð
|
ð Mð
|
ò Mó#ó ð$ Mð@ ò"ó ð"ó::ð& òó ðð ò4ó ð4ð ò ó ð ó&ó ð ò ó ð ð ò ó ð ó?ó&'òMñ^ hÓ'ñ4ó (ð4ñ hÓ'ñ4ó (ð4ñ hÓ'ñ4ó (ð4ñ hÓ'ñ4ó (ð4ñ hÓ'ñ4ó (ð4ñ hÓ'ñ4ó (ð4ð Ø$Ø!ñ
|
ð ð
|
ð ð
|
ð
|
ð
|
ð
|
õ
|
ð( -1Àõ ð" -1Àõ ð* !Ø:>Øñ
|
ð ð
|
ð ð
|
ð
|
8ð
|
ð ð
|
ð
|
õ
|
ð OSð+/Ø.8ð+/ØGKð+/à õ+/öZ;.óz
|
ð ò9ó ð9ó0 :ó ô.ð@ !ØØ ñ C9ð ð C9ð
|
óC9òJ'ò, ò 'ô.ô@ð ò-ó ð-ð& ò.ó ð.ð& ò&ó ð&ð" ò1ó ð1ð* )8¨¯©ð$ ó&)Ð*Ñ%ñP Ø jÑ)à$Ø'ð ó ñ
|
ñ
|
óñ Ió!ð Ið$ ò!ó ð!ð: +:¨(¯/©/ð ó+Ð,Ñ'ñ$ Ø lÑ+à$Ø'ð óñ
|
ñ
|
óò*:ó+ð*:ð( ð Ø&ñðX Ù Ø Ð <Ñ=Ð@SÑSóò
|
óó ð
|
ð0 AEð Ø#ð Ø2=ð à ó ó@2Qðh *9¨¯ © ð ó*Ð+Ñ&ñ" Ø kÑ*ð Yà'ð óñ
|
ñ
|
ó ó@óA ð@ó
|
4ó7ó, Bñ Ð*¨8Ñ4Ð7JÑJÓKð $ðHà$ðHð ðHð
|
ò Hó LðHð )8¨¯©ð ó )Ð*Ñ%ñ< Ø jÑ)à$Ø'ð óñ
|
ñ
|
óñ
|
ó ð
|
ó@ð8 ò ó ð ó B÷$'rZ c ó t | t t f« r3t | « dk( r%t j
|
g t j ¬« S t | « rt | t « r| S t t | dd« t « rt j | « } n6t | d« s t | t t t f« s| S t | d¬« } t | d« sit j | « } | j j dv r<| j t j k7 r | j# t j « } | 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 rh rg NTr` Úiu)ri Úlistr¤ r£ r¥ r= Úint64r% r- r r+ rº ÚhasattrÚranger? rg rþ r
)r s rX rl rl f sç ô &4¤-Ô(¬S°«[¸AÒ-=ô xx¤"§(¡(Ô+Ð+Ü &Ô !¤Z°¼ Ô%Eà Ü GF G¨TÓ2Ô4DÔ EÜFÓ#Ü VWÔ %¬j¸Ä$ÌÌuÐAUÔ.Và ä v°TÔ:ä 67Ô #ÜFÓ#Ø <<× Ñ Ñ $¨¯ © ¼¿¹Ò)AØ]]¤2§8¡8Ó,FØ MrZ )r¤ r )sÚ
|
__future__r rÝ r r r´ Útypingr r r r rD Únumpyr¥ Ú pandas._libsr
|
Úpandas._libs.intervalr r r r Úpandas._libs.missingr Úpandas._typingr r r r r r r r r r r r r Úpandas.compat.numpyr r Ú pandas.errorsr Úpandas.util._decoratorsr Úpandas.util._exceptionsr Úpandas.core.dtypes.castr! r" Úpandas.core.dtypes.commonr# r$ r% r& r' r( r) r* Úpandas.core.dtypes.dtypesr+ r, Úpandas.core.dtypes.genericr- r. r/ r0 Úpandas.core.dtypes.missingr1 r2 r3 Úpandas.core.algorithmsr4 r5 r6 r7 rH rÔ r8 Úpandas.core.arrays.baser9 r: Ú pandas.core.arrays.datetimesr; Ú pandas.core.arrays.timedeltasr< Úpandas.core.commonÚcoreÚcommonry Úpandas.core.constructionr= rÓ r> r? Úpandas.core.indexersr@ Úpandas.core.opsrA rB Úcollections.abcrC rD r rE rF rÅ r[ Úfloatrª rG r² r¶ rµ rH rl rU rZ rX ú<module>rÚ s ðÞ "ã ÷ó ÷ó ó ã å ÷ó õ $÷÷ ÷ õ õ /Ý ,Ý ,Ý 4÷÷ ÷ ó ÷÷ó ÷ ñ ÷ ó õ 3÷õ 7Ý 8ß Ð ÷ñ õ
|
5֖
|
÷÷
|
ð ] B§J¡JÐ.Ñ/ ØXu_Ñ% à(*Ð ~Ó *ð Ø&Ø ñÐ ð8ð Ø ññz
|
Ø'Ñ"à ØUØØ ØØ#HOOð ó
|
ñ ñóô6M'M >ó M'ó7ð6M'ô`4$rZ
|
