U
|
¬ý°dn ã @ sR d dl mZ d dlmZ d dlZd dlmZ d dlmZm Z m
|
Z
|
m Z m Z m Z d dlZd dlmZmZ d dlmZ d dlmZ d d lmZmZ d d
|
lm Z d d l m Z m Z d d l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( d d l)m*Z* d dl+m,Z, d dl-m. m/Z0 d dl1m2Z2 d dl3m. m4 m5Z6 d dl3m7Z7m8Z8 d dl9m:Z: e;d Z<G dd de7Z=dS )é )Ú annotations)Ú timedeltaN)Ú getsizeof)ÚAnyÚCallableÚHashableÚIteratorÚListÚcast)ÚindexÚlib)Ú unique_deltas)Ú
|
no_default)ÚDtypeÚnpt)Úfunction)Úcache_readonlyÚdoc)Úensure_platform_intÚensure_python_intÚis_floatÚ
|
is_integerÚ is_scalarÚis_signed_integer_dtypeÚis_timedelta64_dtype)ÚABCTimedeltaIndex)Úops)Ú extract_array)ÚIndexÚmaybe_extract_name)Úunpack_zerodim_and_deferc s& e Zd ZU dZdZedfZded< ded< edd d
|
d Z d¯dddd dddZ
|
e d°ddd dddZ e d±ddd dddZ e dddd d Zed d d d Zedd d!d"Zd#d$ Zd%d& Zd'd( Zd²d)d*Zd+d,d+d-d.d/Zed0d d1d2Zed0d d3d4Zed0d d5d6Zed0d d7d8Zd³dd0d9d:d;Zed<d d=d>Z edd d?d@Z edd dAdBZ edd dCdDZ dEddFdGdHZ ed,d dIdJZ!e"e#j$dKdL Z$d´dMdNdOdPdQ fdRdS Z%edd dTdUZ&dVd dWdXZ'e"e#j(dYd dZd[Z(e"e#j)e*fdd\d]d^Z)d d d_d`daZ+e"e#j,dµdddbdcddZ,d,dedfdgZ-d¶dd0didjdkZ.d·dd0didldmZ/dPd dndoZ0d¸dddpdqdrdsZ1dtddu fdvdw Z2d¹ddd,dydz fd{d| Z3dºdMdd} fd~d Z4d0d0dddZ5d0d0ddd
dZ6ddduddZ7dMd fdd Z8d» fdd Z9d¼dd fdd Z:dMd fdd Z;d0dMd fdd Z<dddMd fdd Z=d0d ddZ>ed0d ddZ? fddZ@d d d d¡d¢d£ZAeBd¤ fd¥d¦ZCdd d§d¨ZDdd d©dªZE fd«d¬ZF fdd®ZG ZHS )½Ú
|
RangeIndexaø
|
Immutable Index implementing a monotonic integer range.
|
|
RangeIndex is a memory-saving special case of an Index limited to representing
|
monotonic ranges with a 64-bit dtype. Using RangeIndex may in some instances
|
improve computing speed.
|
|
This is the default index type used
|
by DataFrame and Series when no explicit index is provided by the user.
|
|
Parameters
|
----------
|
start : int (default: 0), range, or other RangeIndex instance
|
If int and "stop" is not given, interpreted as "stop" instead.
|
stop : int (default: 0)
|
step : int (default: 1)
|
dtype : np.int64
|
Unused, accepted for homogeneity with other index types.
|
copy : bool, default False
|
Unused, accepted for homogeneity with other index types.
|
name : object, optional
|
Name to be stored in the index.
|
|
Attributes
|
----------
|
start
|
stop
|
step
|
|
Methods
|
-------
|
from_range
|
|
See Also
|
--------
|
Index : The base pandas Index type.
|
Z
|
rangeindexzsigned integerÚrangeÚ_rangez
|
np.ndarrayÚ_valuesztype[libindex.Int64Engine])Úreturnc C s t jS ©N)ÚlibindexZ Int64Engine©Úself© r* úPd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/indexes/range.pyÚ _engine_typee s zRangeIndex._engine_typeNFz Dtype | NoneÚboolr )ÚdtypeÚcopyÚnamer% c C sÈ | |¡ t||| }t|tr,|j|dS t|trD| j||dS t |||¡rZt d|d k rjt
|
|nd}|d krd| }}nt
|
|}|d k rt
|
|nd}|dkr®t dt|||}| j||dS )N©r0 z,RangeIndex(...) must be called with integersr é zStep must not be zero) Ú_validate_dtyper Ú
|
isinstancer! r/ r" Ú _simple_newÚcomZall_noneÚ TypeErrorr Ú
|
ValueError)ÚclsÚstartÚstopÚstepr. r/ r0 Úrngr* r* r+ Ú__new__l s"
|
|
|
zRangeIndex.__new__)Údatar. r% c C s< t |ts$t| j dt| d| |¡ | j||dS )zl
|
Create RangeIndex from a range object.
|
|
Returns
|
-------
|
RangeIndex
|
z7(...) must be called with object coercible to a range, z was passedr1 )r4 r" r7 Ú__name__Úreprr3 r5 )r9 r? r0 r. r* r* r+ Ú
|
from_range s
|
ÿ
|
zRangeIndex.from_range)Úvaluesr0 r% c C s< t | ¡}t|tst||_||_i |_| ¡ d |_ |S r& )
|
Úobjectr> r4 r" ÚAssertionErrorr# Ú_nameÚ_cacheZ_reset_identityZ _references)r9 rC r0 Úresultr* r* r+ r5 ¦ s
|
zRangeIndex._simple_newÚNone)r. r% c C s6 |d kr d S | j \}}||s2td| d| d S )Nz#Incorrect `dtype` passed: expected z , received )Ú_dtype_validation_metadatar8 )r9 r. Zvalidation_funcÚexpectedr* r* r+ r3 µ s
|
ÿzRangeIndex._validate_dtypez type[Index]c C s t S )z(return the class to use for construction)r r( r* r* r+ Ú _constructorÄ s zRangeIndex._constructorc C s t j| j| j| jt jdS )z
|
An int array that for performance reasons is created only when needed.
|
|
The constructed array is saved in ``_cache``.
|
©r. )ÚnpÚaranger: r; r< Úint64r( r* r* r+ Ú_dataÊ s zRangeIndex._datac C s" | j }d|jfd|jfd|jfgS )z,return a list of tuples of start, stop, stepr: r; r< )r# r: r; r< )r) r= r* r* r+ Ú_get_data_as_itemsÓ s z RangeIndex._get_data_as_itemsc C s0 d| j i}| t| ¡ ¡ tjt| |fd fS )Nr0 )r0 ÚupdateÚdictrR ÚibaseZ
|
_new_IndexÚtype)r) Údr* r* r+ Ú
|
__reduce__Ø s
|
zRangeIndex.__reduce__c C s, | ¡ }| jdk r(| dt | j¡f¡ |S )zH
|
Return a list of tuples of the (attr, formatted_value)
|
Nr0 )rR r0 ÚappendrU Zdefault_pprint)r) Úattrsr* r* r+ Ú _format_attrsà s
|
zRangeIndex._format_attrsc C s d S r& r* )r) r0 r* r* r+ Ú _format_dataé s zRangeIndex._format_dataz list[str]Ústr)ÚheaderÚna_repr% c sT t | js|S t| jd }t| jd }tt |t | | fdd| jD S )Nr éÿÿÿÿc s g | ]}|d qS )ú<r* ©Ú.0Úx©Ú
|
max_lengthr* r+ Ú
|
<listcomp>õ s z2RangeIndex._format_with_header.<locals>.<listcomp>)Úlenr# r] Úmax)r) r^ r_ Z first_val_strZ last_val_strr* re r+ Ú_format_with_headerí s
|
z RangeIndex._format_with_headerÚintc C s | j jS )zV
|
The value of the `start` parameter (``0`` if this was not supplied).
|
)r# r: r( r* r* r+ r: ù s zRangeIndex.startc C s | j jS )z4
|
The value of the `stop` parameter.
|
)r# r; r( r* r* r+ r; s zRangeIndex.stopc C s | j jS )zU
|
The value of the `step` parameter (``1`` if this was not supplied).
|
)r# r< r( r* r* r+ r< s zRangeIndex.stepc s$ | j t t fdddD S )zD
|
Return the number of bytes in the underlying data.
|
c 3 s | ]}t t |V qd S r& )r Úgetattr)rc Ú attr_name©r= r* r+ Ú <genexpr> s ÿz$RangeIndex.nbytes.<locals>.<genexpr>)r: r; r< )r# r Úsumr( r* rn r+ Únbytes s þzRangeIndex.nbytes)Údeepr% c C s | j S )aè
|
Memory usage of my values
|
|
Parameters
|
----------
|
deep : bool
|
Introspect the data deeply, interrogate
|
`object` dtypes for system-level memory consumption
|
|
Returns
|
-------
|
bytes used
|
|
Notes
|
-----
|
Memory usage does not include memory consumed by elements that
|
are not components of the array if deep=False
|
|
See Also
|
--------
|
numpy.ndarray.nbytes
|
)rq )r) rr r* r* r+ Ú memory_usage s zRangeIndex.memory_usageznp.dtypec C s t t j¡S r& )rN r. rP r( r* r* r+ r. 4 s zRangeIndex.dtypec C s dS )z%return if the index has unique valuesTr* r( r* r* r+ Ú is_unique8 s zRangeIndex.is_uniquec C s | j jdkpt| dkS ©Nr r2 ©r# r< rh r( r* r* r+ Úis_monotonic_increasing= s z"RangeIndex.is_monotonic_increasingc C s | j jdk pt| dkS ru rv r( r* r* r+ Úis_monotonic_decreasingA s z"RangeIndex.is_monotonic_decreasingr )Úkeyr% c C s6 t | z t|}W n tk
|
r* Y dS X || jkS )NF)Úhashr r7 r# )r) ry r* r* r+ Ú __contains__E s zRangeIndex.__contains__c C s dS )NÚintegerr* r( r* r* r+ Ú inferred_typeM s zRangeIndex.inferred_typec
|
C s t |st|r\| ¡ r\t|}z| j |¡W S tk
|
rZ } zt||W 5 d }~X Y nX t|trnt|| |¡ t|d S r& )
|
r r rk r# r r8 ÚKeyErrorr4 r Z_check_indexing_error)r) ry Únew_keyÚerrr* r* r+ Úget_locT s
|
|
zRangeIndex.get_locr z
|
str | Nonez
|
int | Noneznpt.NDArray[np.intp])ÚtargetÚmethodÚlimitr% c sÜ t |||¡r"t j||||dS | jdkrD| j| j| j }}}n&| jd d d
}|j|j|j }}}t |¡} | | }
|
|
|
| dk|
|
dk@ | |k @ } d|
|
| < |
|
| | |
|
| < || jkrÔt
|
| d |
|
| |
|
| < t |
|
S )N)r Ú tolerancer r r` r2 ) r6 Z any_not_noneÚsuperÚ _get_indexerr< r: r; r# rN Úasarrayrh r ) r) r r r r
r: r; r< ÚreverseZ target_arrayZlocsZvalid©Ú __class__r* r+ r a s& ÿ
|
|
|
|
zRangeIndex._get_indexerc C s dS )zA
|
Should an integer key be treated as positional?
|
Fr* r( r* r* r+ Ú _should_fallback_to_positional s z)RangeIndex._should_fallback_to_positionalz list[int]c C s
|
t | jS r& )Úlistr# r( r* r* r+ Útolist s zRangeIndex.tolistz Iterator[int]c c s | j E d H d S r& ©r# r( r* r* r+ Ú__iter__ s zRangeIndex.__iter__r1 c C s |t kr| jn|}|jjdkr.t||tjdS t|}t|dkr|d dkr|d }t |d |d | |}t
|
| j ||dS | j j ||dS d S )NÚf)r0 r. r2 r r` r1 ) r r0 r. Úkindr rN Úfloat64r rh r" rV r5 rL )r) rC r0 Z unique_diffsZdiffÚ new_ranger* r* r+ Ú _shallow_copy s zRangeIndex._shallow_copy)r) r% c C s" t | j| j| jd}| j|_|S )Nr1 )rV r5 r# rF rG )r) rH r* r* r+ Ú_view s zRangeIndex._view©r0 rr c C s" | j ||dd }| j|d}|S )Nr r r1 )Z_validate_namesZ_rename)r) r0 rr Ú new_indexr* r* r+ r/ ¤ s zRangeIndex.copy)Úmethc C sT t | d }|dkrtjS |dkr,| jdks>|dkrD| jdk rD| jS | j| j| S )Nr2 r` Úminr ri )rh rN Únanr< r: )r) r Úno_stepsr* r* r+ Ú_minmaxª s $zRangeIndex._minmaxT)Úskipnar% c O s t |¡ t ||¡ | d¡S )z#The minimum value of the RangeIndexr )ÚnvÚvalidate_minmax_axisZ validate_minr ©r) Zaxisr ÚargsÚkwargsr* r* r+ r ³ s
|
zRangeIndex.minc O s t |¡ t ||¡ | d¡S )z#The maximum value of the RangeIndexri )r r Z validate_maxr r¡ r* r* r+ ri ¹ s
|
zRangeIndex.maxc O sx | dd¡}| dd¡ t ||¡ | jjdkrFtjt| tjd}n tjt| d ddtjd}|st|ddd
}|S ) zÞ
|
Returns the indices that would sort the index and its
|
underlying data.
|
|
Returns
|
-------
|
np.ndarray[np.intp]
|
|
See Also
|
--------
|
numpy.ndarray.argsort
|
Ú ascendingTr Nr rM r2 r` ) Úpopr Zvalidate_argsortr# r< rN rO rh Úintp)r) r¢ r£ r¤ rH r* r* r+ Úargsort¿ s zRangeIndex.argsortz'tuple[npt.NDArray[np.intp], RangeIndex])ÚsortÚuse_na_sentinelr% c C sJ t jt| t jd}| }|rB| jdk rB|d d d
}|d d d
}||fS )NrM r r` )rN rO rh r¦ r< )r) r¨ r© ÚcodesZuniquesr* r* r+ Ú factorizeÙ s zRangeIndex.factorizerD )Úotherr% c s" t |tr| j|jkS t |¡S )zL
|
Determines if two Index objects contain the same elements.
|
)r4 r! r# r Úequals©r) r¬ r r* r+ r å s
|
zRangeIndex.equalsÚlastzCallable | None©Úreturn_indexerr¤ Ú na_positionry c s |d k r t j||||dS | }d}|rF| jdk rb| d d d
}d}n | jdkrb| d d d
}d}|r|rtt| d dd}n tt| }|t|fS |S d S )Nr° Fr r` Tr2 )r Ú sort_valuesr< r" rh r! )r) r± r¤ r² ry Z sorted_indexZinverse_indexerr= r r* r+ r³ í s, ü
|
|
zRangeIndex.sort_values)r¬ r¨ c sh t |tst j||dS | jdk r4| jd d d
n| j}|jdk rT|jd d d
n|j}t|j|j}t|j |j }||kr|
|
t ¡S | |j|j¡\}}} |j|j | r¸|
|
t ¡S |j|j|j |j | | }
|
|j|j | } t |
|
|| } |
|
| ¡} | |¡}t || j | j} |
|
| ¡} | jdk o6|jdk | jdk k rR| d d d
} |d krd| ¡ } | S )N©r¨ r r` )r4 r! r Ú _intersectionr< r# ri r: r r; r5 Ú _empty_rangeÚ _extended_gcdr" Ú_min_fitting_elementr³ )r) r¬ r¨ ÚfirstÚsecondZint_lowZint_highÚgcdÚsÚ_Z tmp_startZnew_stepr r Z new_startr r* r+ rµ s.
|
|
|
|
|
|
"
|
zRangeIndex._intersection)Ú lower_limitr% c C s, || j t| j }| j t| j| S )z?Returns the smallest element greater than or equal to the limit)r: Úabsr< )r) r¾ r r* r* r+ r¸ A s z RangeIndex._min_fitting_elementztuple[int, int, int])ÚaÚbr% c
|
C sh d\}}d\}}|| }}|r^|| } ||| | }}||| | }}||| | }}q|||fS )z¼
|
Extended Euclidean algorithms to solve Bezout's identity:
|
a*x + b*y = gcd(x, y)
|
Finds one particular solution for x, y: s, t
|
Returns: gcd, s, t
|
)r r2 )r2 r r* )
|
r) rÀ rÁ r¼ Zold_sÚtZold_tÚrZold_rZquotientr* r* r+ r· F s
|
zRangeIndex._extended_gcdc C sJ |sdS | j sdS t|dkr0|j| j j r0dS |j| j koH|d | j kS )z)Check if other range is contained in selfTFr2 r` )r# rh r< r: r® r* r* r+ Ú_range_in_selfW s zRangeIndex._range_in_self)r¬ c sz t |trj|dks8|dkrj| jdkrj| |j¡rj| j| j }}| j| jt| d }|j|j }}|j|jt|d }| jdk r || | }}}|jdk r¼|| | }}}t| dkrêt|dkrêt| j|j }}n&t| dk rþ|}nt|dkr|}t||} t ||}
|
||krÈ|| | dkrp|| |krp|| |krpt
|
| | |
|
| |S |d dkrjt|| |d krjt|| |d krjt
|
| | |
|
|d |d S n¢|| dkr|| | dkrj|| |krj|| |krjt
|
| | |
|
| |S nP|| dkrj|| | dkrj|| |krj|| |krjt
|
| | |
|
| |S t j ||dS )a
|
Form the union of two Index objects and sorts if possible
|
|
Parameters
|
----------
|
other : Index or array-like
|
|
sort : False or None, default None
|
Whether to sort (monotonically increasing) the resulting index.
|
``sort=None`` returns a ``RangeIndex`` if possible or a sorted
|
``Index`` with a int64 dtype if not.
|
``sort=False`` can return a ``RangeIndex`` if self is monotonically
|
increasing and other is fully contained in self. Otherwise, returns
|
an unsorted ``Index`` with an int64 dtype.
|
|
Returns
|
-------
|
union : Index
|
NFr r2 é r´ ) r4 r! r< rÄ r# r: rh r¿ r ri rV r Ú_union) r) r¬ r¨ Zstart_sZstep_sZend_sZstart_oZstep_oZend_oZstart_rZend_rr r* r+ rÆ b sp ÿÿ
|
ÿ
|
|
|
|
|
ÿ
|
þ
|
ý
|
ÿþý ÿ
|
þ
|
ýÿ
|
þ
|
ýzRangeIndex._unionc
|
sD | |¡ | |¡ | |¡\}}t|ts<t j||dS |dk rb| jdk rb| d d d
|¡S t | |¡}| jdk r| j
|
d d d
n| j
|
}| |¡}|jdk r°|d d d
}t |dkrÈ| j |dS t |t | krê| d d
|¡S t |dkrt|d | d kr| dd
S |d | d kr4| d d
S t | dkrb|d | d krb| d d d
S t j||dS n>t |dkr²|d |d kr²|d |d kr²| dd
S |j|jkrV|d |jkrìt|d |j |j|j}nh|d |d krt|j|d |j}n@|j
|
|dd
krDt |d }|d d |
}nt j||dS n¾t | dksht|j|jd kr|d |d kr¶|d |d |d fkr¶|dd d
}nL|d |d krò|d |d |d fkrò|d d d
}nt j||dS nt j||dS t| j||d} || j
|
k r@| d d d
} | S )
|
Nr´ Fr r` r1 r2 é rÅ éþÿÿÿ)Z_validate_sort_keywordZ_assert_can_do_setopZ_convert_can_do_setopr4 r! r Ú _differencer< r Úget_op_result_namer# Ú intersectionrh Úrenamer: r" r; rE rV r5 )
|
r) r¬ r¨ Ú result_nameÚres_namer¹ ÚoverlapÚnew_rngr< r r r* r+ rÉ s^
|
|
|
|
|
2 ,, zRangeIndex._difference)rÍ c sV t |tr|d k r"t |||¡S | |¡}| | ¡}| |¡}|d k rR| |¡}|S r& )r4 r! r Úsymmetric_differenceÚ
|
differenceÚunionrÌ )r) r¬ rÍ r¨ ÚleftÚrightrH r r* r+ rÑ s
|
|
|
|
z RangeIndex.symmetric_differencec s¼ t |rj|dt| fkr&| dd
S |dt| d fkrF| d d
S t| dkr°|dkr°| d d d
S nFt |¡r°t tj|tjdt| ¡}t|t r°| | }| j
|
|dd S t |¡S )
|
Nr r2 r` rÇ )r2 rÈ rÅ rM Fr´ ) r rh r Z is_list_likeZmaybe_indices_to_slicerN r r¦ r4 ÚslicerÒ r Údelete)r) ÚlocZslcr¬ r r* r+ r× s
|
|
zRangeIndex.delete)rØ r% c s t | r
|
t|s t|r
|
| j}|dkrh|| d | j krht|j|j |j|j}t| j || j
|
dS |t | kr²|| d | j kr²t|j|j|j |j}t| j || j
|
dS t | dkr
|
|| d | jd kr
|
t | jd }t| j| j|}t| j || j
|
dS t ||¡S )Nr r1 r` rÅ )rh r r r# r< r" r: r; rV r5 r0 rk r Úinsert)r) rØ Úitemr= rÐ r< r r* r+ rÙ * s &zRangeIndex.insertz list[Index])Úindexesr0 r% c s t dd |D s t ||¡S t|dkr4|d S ttt |}d } }}dd |D }|D ]ê}|j} |dkr| j}|dkrÜt| dkrÜ| j }nH|dkrÜ| j|krÒt
|
dd |D ¡}
|
| |
|
¡} | |¡ S | j| }|| j krôt| dkp|dk o| j|k} | r6| t
|
d d |D ¡¡} | |¡ S |dk r`| d
|
| }q`|r||dkrf|d
|
jn|} t|| | |¡S tdd |¡S ) a
|
Overriding parent method for the case of all RangeIndex instances.
|
|
When all members of "indexes" are of type RangeIndex: result will be
|
RangeIndex if possible, Index with a int64 dtype otherwise. E.g.:
|
indexes = [RangeIndex(3), RangeIndex(3, 6)] -> RangeIndex(6)
|
indexes = [RangeIndex(3), RangeIndex(4, 6)] -> Index([0,1,2,4,5], dtype='int64')
|
c s s | ]}t |tV qd S r& )r4 r! rb r* r* r+ ro H s z%RangeIndex._concat.<locals>.<genexpr>r2 r Nc S s g | ]}t |r|qS r* ©rh )rc Úobjr* r* r+ rg S s z&RangeIndex._concat.<locals>.<listcomp>c S s g | ]
|
}|j qS r* ©r$ rb r* r* r+ rg ` s c S s g | ]
|
}|j qS r* rÞ rb r* r* r+ rg k s r` )Úallr Ú_concatrh r
|
r r! r# r: r< rN Z concatenaterL rÌ r; )r) rÛ r0 Z rng_indexesr: r< Znext_Znon_empty_indexesrÝ r= rC rH Znon_consecutiver; r r* r+ rà ? sB
|
|
|
ÿÿzRangeIndex._concatc C s
|
t | jS )z5
|
return the length of the RangeIndex
|
)rh r# r( r* r* r+ Ú__len__| s zRangeIndex.__len__c C s t | S r& rÜ r( r* r* r+ Úsize s zRangeIndex.sizec
|
s t |tr$| j| }| j|| jdS t|rt|}z | j| W S tk
|
r| } z td| dt| |W 5 d}~X Y qX nt |rtdt
|
|¡S )zE
|
Conserve RangeIndex type for scalar and slice keys.
|
r1 zindex z' is out of bounds for axis 0 with size Nzuonly integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices) r4 rÖ r# r5 rF r rk Ú
|
IndexErrorrh r r Ú __getitem__)r) ry r r r r r* r+ rä s$
|
|
ÿþÿzRangeIndex.__getitem__rÖ )r) Úslobjr% c C s | j | }t| j|| jdS )zH
|
Fastpath for __getitem__ when we know we have a slice.
|
r1 )r# rV r5 rF )r) rå Úresr* r* r+ Ú_getitem_slice s
|
zRangeIndex._getitem_sliceÚ __floordiv__c s¾ t |r²|dkr²t| dks8| j| dkr|| j| dkr|| j| }| j| }|t| | }t|||phd}| j|| jdS t| dkr²| j| }t||d d}| j|| jdS t |¡S )Nr r2 r1 ) r rh r: r< r" r5 r0 r rè )r) r¬ r: r< r; r r r* r+ rè ¥ s (
|
|
|
zRangeIndex.__floordiv__c O s
|
d| j kS )Nr r ©r) r¢ r£ r* r* r+ rß ¸ s zRangeIndex.allc O s
|
t | jS r& )Úanyr# ré r* r* r+ rê » s zRangeIndex.anyc s2 t |tr$| j|jkr$t | |¡S t ||¡S r& )r4 r! r# r Ú _cmp_method)r) r¬ Úopr r* r+ rë À s zRangeIndex._cmp_methodc
|
s t |trtS t |ttjfr,t ||¡S t|rBt ||¡S |t j
|
t j t j t jt jt jtt jfkrvt ||¡S d}|t jt jt jt jfkr|}t|ddd}| }zº|rätjdd ||j|}W 5 Q R X t|rÞ|sêtn|j}tjdd ||j |}||j |}W 5 Q R X t | |¡} t | |||| d}
|
t dd |||fD s^|
|
!d ¡}
|
|
|
W S tt"t#fk
|
r t ||¡ Y S X dS )
|
z
|
Parameters
|
----------
|
other : Any
|
op : callable that accepts 2 params
|
perform the binary op
|
NT)Z extract_numpyZ extract_rangeÚignore)rß r1 c s s | ]}t |V qd S r& )r rb r* r* r+ ro s z+RangeIndex._arith_method.<locals>.<genexpr>r )$r4 r ÚNotImplementedr rN Z timedelta64r Ú _arith_methodr ÚoperatorÚpowr ZrpowÚmodZrmodÚfloordivZ rfloordivÚdivmodZrdivmodÚmulZrmulÚtruedivZrtruedivr Zerrstater< r r8 r: r; rÊ rV rß Zastyper7 ÚZeroDivisionError) r) r¬ rì r< rÕ rÔ ZrstepZrstartZrstoprÎ rH r r* r+ rï Æ sN
|
ø
|
|
zRangeIndex._arith_method)NNNNFN)NN)N)N)F)NNN)NF)NT)NT)FT)FTr¯ N)F)N)NN)Ir@ Ú
|
__module__Ú __qualname__Ú__doc__Z_typr rJ Ú__annotations__Úpropertyr, r> Ú classmethodrB r5 r3 r rL rQ rR rX r[ r\ rj r: r; r< rq rs r. rt rw rx r{ r} r r r r r r r r r r r/ r r ri r§ r« r r³ rµ r¸ r· rÄ rÆ rÉ rÑ r× rÙ rà rá râ rä rç r rè rß rê rë rï Ú __classcell__r* r* r r+ r! 9 sÌ
|
& ù$ ÿ ÿ
|
|
|
û ý
|
û&. KW= r! )>Ú
|
__future__r Údatetimer rð Úsysr Útypingr r r r r r
|
ÚnumpyrN Z pandas._libsr r' r Zpandas._libs.algosr Zpandas._libs.libr Zpandas._typingr r Zpandas.compat.numpyr r Zpandas.util._decoratorsr r Zpandas.core.dtypes.commonr r r r r r r Zpandas.core.dtypes.genericr Z pandas.corer Zpandas.core.commonÚcoreÚcommonr6 Zpandas.core.constructionr Zpandas.core.indexes.baserÛ ÚbaserU r r Zpandas.core.ops.commonr r" r¶ r! r* r* r* r+ Ú<module> s* $
|
