U
|
¬ý°dðÔ ã @ s U d dl mZ d dlmZ d dlZd dlmZ d dlZd dlmZm Z m
|
Z
|
m Z m Z m Z mZmZmZmZmZmZmZ d dlZd dlZd dlmZ d dlmZm Z m Z m Z d dl!m"Z" d dl#m$ m%Z& d d l'm(Z(m)Z) d d
|
l*m+Z+ d d l,m-Z-m.Z.m/Z/m0Z0 d d l1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z> d d l?m@ZA d dlBmCZCmDZD d dlEmFZFmGZGmHZH d dlImJZJmKZK d dlLmMZMmNZN d dlOmPZPmQZQmRZRmSZSmTZTmUZUmVZV d dlWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZp d dlqmrZr d dlsmtZtmuZumvZvmwZwmxZx d dlymzZzm{Z{m|Z|m}Z}m~Z~mZ d dlmZ d dlmZmZm
Z
d dlmZmZ d dlmZ d dlm mZ d dlmZmZ d d lmZmZmZmZ d d lmZ d d lmZmZ d dlm mZ d d lmZm 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« d d%l¬mZm®Z®m¯Z¯ d d&l°m±Z± d d'l²m³Z³m´Z´mµZµm¶Z¶ er²d d(l·m¸Z¸m¹Z¹mºZºm»Z» d d)lm¼Z¼ d*gZ½e¾d+Z¿d*d,d*d,d*d-d.ZÀd/eÁd0< i ZÂd/eÁd1< eÃZÄe Åd2¡ZÆe jÇe jÈe jÉe jÊe jËe jÌe jÍe jÎe jÏe jÐe jÑe jÒe jÓe jÉe jÉe jÊe jÊe jËe jÌe jÍe jÎe jÏe jÐe jÑe jÒe jÓd3ZÔd4d4d5d6d7ZÕd8d9 ZÖed:d*d;Z×G d<d* d*eeZØd]d*d=d>d?ZÙd^dAdBd*dCdDdEZÚdFdG ZÛdHdHdIdJdKZÜdLdMdNdOdPZÝdQd=dRdSZÞd*dTdUdVdWZßd*d*dXdYdZZàd[d\ ZádS )_é )Ú annotations)ÚdatetimeN)Ú zip_longest) Ú TYPE_CHECKINGÚAnyÚCallableÚClassVarÚHashableÚIterableÚLiteralÚNoReturnÚSequenceÚTypeVarÚcastÚfinalÚoverload)Ú
|
get_option)ÚNaTÚalgosÚindexÚlib)ÚBlockValuesRefs)Úis_datetime_arrayÚ
|
no_default)Ú is_float_nan)ÚIncompatibleFrequencyÚOutOfBoundsDatetimeÚ TimestampÚ
|
tz_compare) ÚAnyAllÚ ArrayLikeÚAxesÚAxisÚDropKeepÚDtypeObjÚFÚ IgnoreRaiseÚ
|
IndexLabelÚJoinHowÚLevelÚShapeÚnpt)Úfunction)ÚDuplicateLabelErrorÚInvalidIndexError)ÚAppenderÚcache_readonlyÚdoc)Úfind_stack_levelÚrewrite_exception)Ú astype_arrayÚastype_is_view)ÚLossySetitemErrorÚcan_hold_elementÚ common_dtype_categorical_compatÚfind_result_typeÚinfer_dtype_fromÚmaybe_cast_pointwise_resultÚnp_can_hold_element)Ú ensure_int64Ú ensure_objectÚensure_platform_intÚis_any_real_numeric_dtypeÚ is_bool_dtypeÚis_categorical_dtypeÚis_dtype_equalÚis_ea_or_datetimelike_dtypeÚis_extension_array_dtypeÚis_floatÚis_float_dtypeÚ is_hashableÚ
|
is_integerÚis_integer_dtypeÚis_interval_dtypeÚ is_iteratorÚ is_list_likeÚis_numeric_dtypeÚis_object_dtypeÚ is_scalarÚis_signed_integer_dtypeÚis_string_dtypeÚneeds_i8_conversionÚ pandas_dtypeÚvalidate_all_hashable)Ú concat_compat)ÚCategoricalDtypeÚDatetimeTZDtypeÚExtensionDtypeÚ IntervalDtypeÚ PeriodDtype)Ú ABCDataFrameÚABCDatetimeIndexÚ ABCMultiIndexÚABCPeriodIndexÚ ABCSeriesÚABCTimedeltaIndex)Ú is_dict_like)Úarray_equivalentÚis_valid_na_for_dtypeÚisna)Ú arraylikeÚops)ÚCachedAccessor)Úsetitem_datetimelike_compatÚvalidate_putmask)ÚArrowExtensionArrayÚBaseMaskedArrayÚ CategoricalÚExtensionArray)Ú StringArray)Ú IndexOpsMixinÚ PandasObject)Ú ensure_wrapped_if_datetimelikeÚ extract_arrayÚsanitize_array)Údisallow_ndim_indexing)Ú
|
FrozenList)Úclean_reindex_fill_method)Úget_op_result_name)Úmake_invalid_op)Úensure_key_mappedÚget_group_index_sorterÚnargsort)Ú StringMethods)Ú
|
PrettyDictÚdefault_pprintÚformat_object_summaryÚ pprint_thing)ÚCategoricalIndexÚ DataFrameÚ
|
MultiIndexÚSeries)Ú PeriodArrayÚIndex)Úmixedú mixed-integerÚ ú
|
np.ndarray)ÚklassÚinplaceZ target_klassZraises_sectionÚuniqueÚ
|
duplicatedzdict[str, str]Ú_index_doc_kwargsÚ_index_shared_docsÚobject)Z
|
Complex128Z Complex64ZFloat64ZFloat32ZUInt64ZUInt32ZUInt16ZUInt8ZInt64ZInt32ZInt16ZInt8Úbooleanzdouble[pyarrow]zfloat64[pyarrow]zfloat32[pyarrow]zfloat[pyarrow]zuint64[pyarrow]zuint32[pyarrow]zuint16[pyarrow]zuint8[pyarrow]zint64[pyarrow]zint32[pyarrow]zint16[pyarrow]z int8[pyarrow]z bool[pyarrow]r% )ÚmethÚreturnc s8 t ¡dddddddddd fd d
|
}tt|S ) zG
|
Decorator to simplify 'return_indexers' checks in Index.join.
|
ÚleftNF©ÚhowÚlevelÚreturn_indexersÚsortr r( Úbool)Úotherr r r c sJ | ||||d\}}}|s |S |d k r0t |}|d k r@t |}|||fS )N©r r r )r? ) Úselfr r r r r Ú
|
join_indexÚlidxÚridx©r © úOd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/indexes/base.pyÚjoinù s
|
z$_maybe_return_indexers.<locals>.join)Ú functoolsÚwrapsr r% )r r¦ r¤ r£ r¥ Ú_maybe_return_indexersô s ù r© c C s t | tr"ddlm} || f|S t | trTd|krJd|krJ| d¡|d< d|d< n d|krrd|krr|d j|d< | j| f|S ) zv
|
This is called upon unpickling, rather than the default which doesn't
|
have arguments and breaks __new__.
|
r )Ú_new_PeriodIndexÚlabelsÚcodesFÚverify_integrityÚdtypeÚdata)Ú
|
issubclassr_ Zpandas.core.indexes.periodrª r^ Úpopr® Ú__new__)ÚclsÚdrª r¤ r¤ r¥ Ú
|
_new_Index s
|
|
|
rµ Ú_IndexT)Úboundc s e Zd ZU dZdZeddddddZeddddd d
|
Zeddddd d Zeddddd dZ dZ
|
de d< de d< e j efZde d< dZde d< dZde d< dZd e d < d gZd e d < d gZd e d!< ed d"d#d$Ze e j¡eje e j¡ej e e j ¡ej e e j ¡ej e e j!¡ej"e e j#¡ej$e e j%¡ej&e e j'¡ej(e e j)¡ej*e e j+¡ej,e e j-¡ej.e e j/¡ej0i Z1d%e d&< e2d'd"d(d)Z3dZ4dhZ5e6de7Z8dZ9dvd d d d+d,d-Z:e;d d.d/d0Z<ee;d1d2d3d4Z=e;dwd5d6ddd7d8d9Z>e;d:d; Z?edd5d<d=d>Z@ed?d"d@dAZAedBd"dCdDZBeCfddddEdFdGZDddd<dHdIZEeddddEdJdKZFed d"dLdMZGed?d"dNdOZHed?d"dPdQZIedRd"dSdTZJeedUd"dVdWZKdXd"dYdZZLdxd[d"d\d]ZMd^d_d`dadbZNdydcddZOed1d"dedfZedzd_d dhdidjZPd{dkdlZQd|d d.dmdnZRdoeSdp< eTeSdp eU d}drd dsdtduZVed d dvdwdxZWdyeSdz< eTeSdz eU d~d{d|ZXddd}d dd~ddZYeddd<ddZZedddd<ddZ[ed_d"d
dZ\d_d"ddZ]e2dd Z^dd_d"ddZ_dd"ddZ`edd"ddZaed[d"ddZbdd dd_ddddZcdd_ddddZddddddd d_d_d¡d¢d£d¤Zedd_d"d¥d¦Zfddd<d§d¨Zgeddd©dªd«d¬Zhd*eijCfd ddBdd®d¯Zje2dd"d°d±Zkekjldd?d²d³d±Zked
d d´dµd¶d·Zmdd¸d´d¹dºd»Znd¼d"d½d¾Zodd¿d?d"dÀdÁZpe2epeodÂZqerdÃdÃdÄddÅddÆdÇdÈZserdÃd¿dÉd?dÊdËdÈZserdÃdÃdÄdd dÌdÆdÍdÈZsdddÄdd dÌdÆdÎdÈZsdd dÏdÐdÑZte2dXd"dÒdÓZuddd<dÔdÕZved?d"dÖd×ZwdXd"dØdÙZxddÚdÛdÜdÝZyd d"dÞdßZzezZ{eddàd¿dádâZ|edãdädådæZ}eed d"dçdèZ~e2d d"dédêZe2d d"dëdìZee2d d"dídîZee2d d"dïdðZed d"dñdòZee2d d"dódôZed d"dõdöZ
ed d"d÷døZed d"dùdúZed d"dûdüZed d"dýdþZed d"dÿd Zed d"ddZed d"ddZed d"ddZed_d"ddZeed d"d d
|
Zeed d"d d Zd d Zedd Zedd"ddZed d"ddZedd"ddZeZedd"ddZeZdddZddd dd d d Zddd}dd! fd"d# Zd$d%dd&dd' fd(d)Zdd&dd*d+d,Zd-d. Zed/d"d0d1ZeZ d2d3 Z¡ed4d5 Z¢ed d_d6d7d8d9Z£edd:d;Z¤d d<d=d>Z¥ed d d?d@dAZ¦edd dBdCdDZ§dd d dEdFdGZ¨dHdI Z©edJdKd?dLdMZªeddNdOZ«dPdQ Z¬dRdS ZddTdUZ®ed d"dVdWZ¯dXd"dYdZZ°d[d\ Z±d]eSd^< eTeSd^ eU edd_d`ddadbdcZ²dd d_d`ddddedfZ³ed d dgdhdiZ´edd_d`d?dadjdkZµdld[dgdmdnZ¶edd d_d`ddddodpZ·edd d_d`ddddqdrZ¸ed d`ddsdtduZ¹ed dddvdwdxZºed dd6dvdydzZ»ed{d?d|d}d~Z¼d{d_dddZ½eeijCfd_dd?ddd
Z¾ed[d?dddZ¿ddd"ddZÀd dddZÁd d dddZÂed ddgddZÃerdÃdÃdÃdd dddÉd ddddZÄerdÃdÃdÃdÃdd dddÅd d dddZÄerdÃdÃdÃdÃdd ddd d ddddZÄeeÅd ddddd ddd d ddd¡dZÄed dd dd¢d£d¤ZÆed dd¥d¦d§ZÇedd dd¨d©dªd«ZÈedd dd d¬dd®d¯ZÉedd ddd©d°d±ZÊdd6ddddd²d³d´ZËed d"dµd¶ZÌe2d6d"d·d¸ZÍeeÎeÏjÐd¹d"dºd»ZÐe2dd"d¼d½ZÑd6d"d¾d¿ZÒd6d"dÀdÁZÓd[d6dÂdÃdÄZÔeÎeÏjÕdd dXdµdÅdÆZÖedd d"dÇdÈZ×ee;dÉdÊ ZØdËdÌ ZÙedÍdÎ ZÚd d"dÏdÐZÛdÑd d|dÒdÓZÜdÔe dÕ< edÖd× ZÝdØdÙ ZÞdd{ddÚdÛdÜZßed d"dÝdÞZàdßd d?dàdáZádâdd dãdädåZâd d"dædçZãdÑd d?dèdéZäed d"dêdëZåedìdí Zæd dddîdïdðZçdd d d_ddòdódôZèedõdö ZéddXd÷dødùZêdd"dúdûZëdüdý Zìed d"dþdÿZíd eSd< eTeSd eU dd"ddZîedd"ddZïd_ddd d
|
Zðd_d?dd d Zñerd d dÉdd ddZòerd dÅdd ddZòerd¡d d dd ddZòed¢d d dd ddZòe2d d"ddZódZôed d6d?ddZõed1d"ddZöed d d?dd Z÷d1d d d d Zøed d"d!d"Zùd£d#d$Zúedd¿d d"d%d&Zûd¤dd"d'd(Züd_d)d*d+Zýd¥d}d}d`d{d,d-d.Zþd/d0 Zÿd d"d1d2Z ed_d_d?d3d4d5Zd_d6d7d8Zd¦d9d6d:d;Zd9dXd<d=d>Zd§d?d"d@dAZddd<dBdCZdXd dDdEdFZd¨dHdId dJdKdLZd©d d dMdNdOZ dPdQ Z
|
edRdS Z edTdU Z fdVdWZ edXdY Zd d"dZd[Zd d"d\d]Zd d"d^d_Zd d"d`daZdbdc Zddde Zed_d?dfdgdhZeTeÏjjdªd dXdi fdjdk ZeTeÏjjd«d dXdi fdldm ZeÎeÏjd¬d dn fdodp ZeÎeÏjdd dn fdqdr Zee2dsd"dtduZ ZS (® r a-
|
Immutable sequence used for indexing and alignment.
|
|
The basic object storing axis labels for all pandas objects.
|
|
.. versionchanged:: 2.0.0
|
|
Index can hold all numpy numeric dtypes (except float16). Previously only
|
int64/uint64/float64 dtypes were accepted.
|
|
Parameters
|
----------
|
data : array-like (1-dimensional)
|
dtype : NumPy dtype (default: object)
|
If dtype is None, we find the dtype that best fits the data.
|
If an actual dtype is provided, we coerce to that dtype if it's safe.
|
Otherwise, an error will be raised.
|
copy : bool
|
Make a copy of input ndarray.
|
name : object
|
Name to be stored in the index.
|
tupleize_cols : bool (default: True)
|
When True, attempt to create a MultiIndex if possible.
|
|
See Also
|
--------
|
RangeIndex : Index implementing a monotonic integer range.
|
CategoricalIndex : Index of :class:`Categorical` s.
|
MultiIndex : A multi-level, or hierarchical Index.
|
IntervalIndex : An Index of :class:`Interval` s.
|
DatetimeIndex : Index of datetime64 data.
|
TimedeltaIndex : Index of timedelta64 data.
|
PeriodIndex : Index of Period data.
|
|
Notes
|
-----
|
An Index instance can **only** contain hashable objects.
|
An Index instance *can not* hold numpy float16 dtype.
|
|
Examples
|
--------
|
>>> pd.Index([1, 2, 3])
|
Index([1, 2, 3], dtype='int64')
|
|
>>> pd.Index(list('abc'))
|
Index(['a', 'b', 'c'], dtype='object')
|
|
>>> pd.Index([1, 2, 3], dtype="uint8")
|
Index([1, 2, 3], dtype='uint8')
|
é r¶ únpt.NDArray[np.intp])r r r c C s4 | ¡ }| ¡ }ttj|}ttj|}t ||¡S ©N)Ú_get_join_targetr ÚnpÚndarrayÚlibjoinZleft_join_indexer_unique)r r ÚsvÚovr¤ r¤ r¥ Ú_left_indexer_uniquek s
|
zIndex._left_indexer_uniquez<tuple[ArrayLike, npt.NDArray[np.intp], npt.NDArray[np.intp]]c C sN | ¡ }| ¡ }ttj|}ttj|}t ||¡\}}}| |¡}|||fS rº )r» r r¼ r½ r¾ Zleft_join_indexerÚ_from_join_target©r r r¿ rÀ Zjoined_ndarrayr¡ r¢ Újoinedr¤ r¤ r¥ Ú _left_indexerv s
|
zIndex._left_indexerc C sN | ¡ }| ¡ }ttj|}ttj|}t ||¡\}}}| |¡}|||fS rº )r» r r¼ r½ r¾ Zinner_join_indexerr rà r¤ r¤ r¥ Ú_inner_indexer s
|
zIndex._inner_indexerc C sN | ¡ }| ¡ }ttj|}ttj|}t ||¡\}}}| |¡}|||fS rº )r» r r¼ r½ r¾ Zouter_join_indexerr rà r¤ r¤ r¥ Ú_outer_indexer s
|
zIndex._outer_indexerr ÚstrÚ_typzExtensionArray | np.ndarrayÚ_datazDtype[ExtensionArray] | tuple[type[np.ndarray], type[ExtensionArray]]Ú _data_clsNz object | NoneÚ_idr Ú_nameFr Ú_no_setting_nameÚnameú list[str]Ú _comparablesÚ _attributes©r c C s
|
t | S rº )rN ©r r¤ r¤ r¥ Ú_can_hold_strings¯ s zIndex._can_hold_stringsz;dict[np.dtype | ExtensionDtype, type[libindex.IndexEngine]]Ú _engine_typesz;type[libindex.IndexEngine] | type[libindex.ExtensionEngine]c C s | j | jtj¡S rº )rÖ Úgetr® ÚlibindexÚ ObjectEnginerÔ r¤ r¤ r¥ Ú _engine_type s zIndex._engine_typeT)ÚcopyÚ tupleize_colsr c
|
C s ddl m} t||| }|d k r(t|}t|dd }d }|sPt|ttfrP|j}t|t |fr||||d} |d k r| j
|
|ddS | S t |rnLt |rn@t|t j ttfrÞt|trÀ|j}|jjdkrÚtj|td}n t|rò| |¡nìt|d rtt |¡|||d
|
S t|s6t|ts6| |¡n¨|rt|rNt |}|rt d d |D rdd l m }
|
|
|
j ||dS t|t t!fst |}t"|dkr¶t j#|t$d}t"|rÞt|d t!rÞtj|td}zt%|d ||d} W nX t&k
|
rJ } z8dt'| kr | |¡| dt'| kr8t&d| W 5 d } ~ X Y nX t(| } | )| j¡} | j*| | jdd} | j+| ||dS )Nr )Ú
|
RangeIndexr® )ÚstartrÛ rÏ F©rÛ )ÚiÚuÚfÚbÚcÚmÚM©r® Ú __array__©r® rÛ rÏ c s s | ]}t |tV qd S rº )Ú
|
isinstanceÚtuple)Ú.0Úer¤ r¤ r¥ Ú <genexpr> s z Index.__new__.<locals>.<genexpr>©r ©Únames©r® rÛ z2index must be specified when data is not list-likezData must be 1-dimensionalú Index data must be 1-dimensional)Úrefs),Zpandas.core.indexes.rangerÝ Úmaybe_extract_namerT Úgetattrrê r` r Ú _referencesÚrangeÚastyperD r¼ r½ r^ Ú_valuesr® ÚkindÚcomÚasarray_tuplesafeÚ
|
_dtype_objrP Ú_raise_scalar_data_errorÚhasattrÚasarrayrM Ú
|
memoryviewrL ÚlistÚallÚpandas.core.indexes.multir Ú from_tuplesrë ÚlenÚarrayr rt Ú
|
ValueErrorrÈ rr Ú_dtype_to_subclassÚ _ensure_arrayÚ _simple_new)r³ r¯ r® rÛ rÏ rÜ rÝ Z
|
data_dtyperô Úresultr ÚarrÚerrr r¤ r¤ r¥ r² Õ sh
|
|
|
z Index.__new__rß c C s6 |j dkrtdn|tjkr&td|r2| ¡ }|S )zF
|
Ensure we have a valid array to pass to _simple_new.
|
r¸ ró z!float16 indexes are not supported)Úndimr r¼ Úfloat16ÚNotImplementedErrorrÛ )r³ r¯ r® rÛ r¤ r¤ r¥ r 5 s
|
|
|
zIndex._ensure_arrayr$ rç c C sÜ t |trvt |tr$ddlm} |S t |tr>ddlm} |S t |trXddlm} |S t |t rrddlm
|
} |S t S |j dkrddlm} |S |j dkrªddlm } |S |j d kr¸t S t|jtsÌt|rÐt S t|d S )
|
Nr )Ú DatetimeIndex)r )Ú IntervalIndex)Ú PeriodIndexræ rå )ÚTimedeltaIndexÚO)rê rY rX Úpandasr rW r rZ r r[ r r rû r r° ÚtyperÈ rN r )r³ r® r r r r r r¤ r¤ r¥ r
|
G s2
|
|
|
|
|
|
|
|
zIndex._dtype_to_subclassz type[_IndexT]r )r³ ÚvaluesrÏ r c C sd t || jstt|t | ¡}||_||_i |_| ¡ |dk rL||_
|
nt |_
|
|j
|
|¡ |S )zÁ
|
We require that we have a dtype compat for the values. If we are passed
|
a non-dtype compat, then coerce using the constructor.
|
|
Must be careful not to recurse.
|
N) rê rË ÚAssertionErrorr r r² rÊ rÍ Ú_cacheÚ_reset_identityr÷ r Úadd_index_reference)r³ r rÏ rô r r¤ r¤ r¥ r s
|
|
zIndex._simple_newc O sD | ||}|j tkr@|js@t |j¡}|j jdkr@t||jdS |S )zw
|
Constructor that uses the 1.0.x behavior inferring numeric dtypes
|
for ndarray[object] inputs.
|
)rà rá râ rã ©rÏ ) r® rþ Ú _is_multir Úmaybe_convert_objectsrú rû r rÏ )r³ ÚargsÚkwargsr r r¤ r¤ r¥ Ú _with_infer s
|
zIndex._with_infer)r r c C s t | S rº )r rÔ r¤ r¤ r¥ Ú _constructor« s zIndex._constructorÚNonec C s, | j s(d}| ¡ }|d| 7 }t|dS )a:
|
Check that an Index has no duplicates.
|
|
This is typically only called via
|
`NDFrame.flags.allows_duplicate_labels.setter` when it's set to
|
True (duplicates aren't allowed).
|
|
Raises
|
------
|
DuplicateLabelError
|
When the index is not unique.
|
zIndex has duplicates.Ú
|
N)Ú is_uniqueÚ_format_duplicate_messager- )r ÚmsgÚ
|
duplicatesr¤ r¤ r¥ Ú_maybe_check_unique¯ s
|
zIndex._maybe_check_uniquer c C s ddl m} | | jdd ¡ }t|s,t|t t| ¡ | ¡ t
|
¡| }| j rft | |j¡|_| jdkrz| d¡}|jddS ) a¼
|
Construct the DataFrame for a DuplicateLabelError.
|
|
This returns a DataFrame indicating the labels and positions
|
of duplicates in an index. This should only be called when it's
|
already known that duplicates are present.
|
|
Examples
|
--------
|
>>> idx = pd.Index(['a', 'b', 'a'])
|
>>> idx._format_duplicate_message()
|
positions
|
label
|
a [0, 2]
|
r ©r
Úfirst©Úkeepr¸ ÚlabelZ positionsr )r r
r r r r r¼ ÚarangeÚgroupbyZaggr r r r r ÚnlevelsZ rename_axisÚto_frame)r r
r+ Úoutr¤ r¤ r¥ r) Ä s "
|
|
z Index._format_duplicate_message)r rÏ r c C s$ |t kr| jn|}| j||| jdS )az
|
Create a new Index with the same class as the caller, don't copy the
|
data, use the same object attributes with passed in attributes taking
|
precedence.
|
|
*this is an internal non-public method*
|
|
Parameters
|
----------
|
values : the values to create the new Index, optional
|
name : Label, defaults to self.name
|
©rÏ rô )r rÍ r r÷ )r r rÏ r¤ r¤ r¥ Ú _shallow_copyç s zIndex._shallow_copyc C s" | j | j| j| jd}| j|_|S )zR
|
fastpath to make a shallow copy, i.e. new object with same data.
|
r7 )r rú rÍ r÷ r ©r r r¤ r¤ r¥ Ú_viewø s z Index._viewc C s | ¡ }||_|S )zG
|
fastpath for rename if new name is already validated.
|
)r: rÍ )r rÏ r r¤ r¤ r¥ Ú_rename s z Index._renamec C sB | |kr dS t |dsdS | jdks.|jdkr2dS | j|jkS dS )a
|
More flexible, faster check like ``is`` but that works through views.
|
|
Note: this is *not* the same as ``Index.identical()``, which checks
|
that metadata is also the same.
|
|
Parameters
|
----------
|
other : object
|
Other object to compare against.
|
|
Returns
|
-------
|
bool
|
True if both have same underlying data, False otherwise.
|
|
See Also
|
--------
|
Index.identical : Works like ``Index.is_`` but also checks metadata.
|
TrÌ FN)r rÌ ©r r r¤ r¤ r¥ Úis_
|
s
|
z Index.is_c C s t | _dS )zJ
|
Initializes or resets ``_id`` attribute with new object.
|
N)r rÌ rÔ r¤ r¤ r¥ r ) s zIndex._reset_identityc C s | j ¡ d S rº )Ú_engineZ clear_mappingrÔ r¤ r¤ r¥ Ú_cleanup0 s zIndex._cleanupzLlibindex.IndexEngine | libindex.ExtensionEngine | libindex.MaskedIndexEnginec C sÈ | ¡ }t|tr`t|ttfrJzt|jj |W S tk
|
rF Y q`X n| j t
|
j kr`t
|
|¡S t tj|}|jtkrt
|
|¡S |jtjkrt
|
|¡S |jtjkr¬t
|
|¡S t| jr¾| jj}| |¡S rº )Ú_get_engine_targetrê rn rl rk Ú_masked_enginesr® rÏ ÚKeyErrorrÚ rØ rÙ ZExtensionEnginer r¼ r½ r Z
|
BoolEngineÚ complex64ÚComplex64EngineÚ
|
complex128ÚComplex128EnginerS rÊ Ú_ndarray)r Ú target_valuesr¤ r¤ r¥ r> 4 s&
|
|
|
|
|
|
|
z Index._enginez
|
set[str_t]c C s" dd | j dddtd
D S )z
|
Add the string-like labels to the owner dataframe/series dir output.
|
|
If this is a MultiIndex, it's first level values are used.
|
c S s" h | ]}t |tr| ¡ r|qS r¤ )rê rÈ Ú isidentifier©rì rä r¤ r¤ r¥ Ú <setcomp>a s
|
þz1Index._dir_additions_for_owner.<locals>.<setcomp>r ©r Nzdisplay.max_dir_items)r r rÔ r¤ r¤ r¥ Ú_dir_additions_for_ownerY s þz Index._dir_additions_for_ownerÚintc C s
|
t | jS )z1
|
Return the length of the Index.
|
)r rÊ rÔ r¤ r¤ r¥ Ú__len__k s z Index.__len__r c C s t j| j|dS )z8
|
The array interface, return my values.
|
rç )r¼ r rÊ ©r r® r¤ r¤ r¥ rè q s zIndex.__array__znp.ufuncÚstr_t)ÚufuncÚmethodc sä t dd |D rtS tj ||f||}|tk r8|S d|krVtj ||f||S |dkrtj ||f||}|tk r|S fdd|D }t||||}|jdkrÂt fdd|D S |j t
|
j krÚ| t
|
j ¡} |¡S ) Nc s s | ]}t |ttfV qd S rº )rê r` r\ )rì r r¤ r¤ r¥ rî x s z(Index.__array_ufunc__.<locals>.<genexpr>r6 Úreducec s g | ]}| k r|n|j qS r¤ ©rú ©rì ÚxrÔ r¤ r¥ Ú
|
<listcomp> s z)Index.__array_ufunc__.<locals>.<listcomp>é c 3 s | ]} |¡V qd S rº )Ú__array_wrap__rV rÔ r¤ r¥ rî s )ÚanyÚNotImplementedrf Z!maybe_dispatch_ufunc_to_dunder_opZdispatch_ufunc_with_outZdispatch_reduction_ufuncrö Znoutrë r® r¼ r rù Úfloat32rZ )r rR rS Úinputsr# r Z
|
new_inputsr¤ rÔ r¥ Ú__array_ufunc__w sT ÿÿÿ ÿÿÿ ÿÿÿ
|
zIndex.__array_ufunc__c C s< t |¡}t|s*t |¡s*t |¡dkr.|S t|| jdS )zN
|
Gets called after a ufunc and other functions e.g. np.split.
|
r¸ r )r Úitem_from_zerodimrA rP r¼ r r rÏ )r r Úcontextr¤ r¤ r¥ rZ s
|
zIndex.__array_wrap__c C s | j jS )zA
|
Return the dtype object of the underlying data.
|
)rÊ r® rÔ r¤ r¤ r¥ r® £ s z Index.dtypeÚC)Úorderr c C s | dd
S )z²
|
Return a view on self.
|
|
Returns
|
-------
|
Index
|
|
See Also
|
--------
|
numpy.ndarray.ravel : Return a flattened array.
|
Nr¤ )r rc r¤ r¤ r¥ Úravelª s z Index.ravelc C s |d k r¤t |ds¤|}t|tr(t|}t|tjtfrt|r|jdkr^|dkr^| j
|
|¡S | |¡}|j }|| j
|
d¡|d}|j || j| jdS | j
|
|¡}n| ¡ }t|tr¾| j|_|S )NrÉ rå zm8[ns]Úi8rç r7 )r rê rÈ rT r¼ r® rY rS rû rÊ Úviewr
|
rË r rÏ r÷ r: r rÌ )r r³ r® Zidx_clsZarr_clsr r r¤ r¤ r¥ rf ¹ s$
|
ÿ
|
|
z
|
Index.viewc C sæ |dk rt |}t| j|r,|r(| ¡ S | S | j}t|trntt|j t| j |j
|
||d}W 5 Q R X n2t|t r| ¡ }|j | ||d}nt|||d}t|| j|jdd}|sâ| jdk rât| j|râ| j|_|j |¡ |S )a[
|
Create an Index with values cast to dtypes.
|
|
The class of a new Index is determined by dtype. When conversion is
|
impossible, a TypeError exception is raised.
|
|
Parameters
|
----------
|
dtype : numpy dtype or pandas type
|
Note that any signed integer `dtype` is treated as ``'int64'``,
|
and any unsigned integer `dtype` is treated as ``'uint64'``,
|
regardless of the size.
|
copy : bool, default True
|
By default, astype always returns a newly allocated object.
|
If copy is set to False and internal requirements on dtype are
|
satisfied, the original data is used to create a new Index
|
or the original Index is returned.
|
|
Returns
|
-------
|
Index
|
Index with values cast to specified dtype.
|
Nrß rò F)rÏ r® rÛ )rT rC r® rÛ rÊ rê rn r3 r Ú__name__rù rY Zconstruct_array_typeÚ_from_sequencer4 r rÏ r÷ r5 r )r r® rÛ r Ú
|
new_valuesr³ r r¤ r¤ r¥ rù × s,
|
|
ÿþ
|
ý z Index.astypeas
|
Return a new %(klass)s of the values selected by the indices.
|
|
For internal compatibility with numpy arrays.
|
|
Parameters
|
----------
|
indices : array-like
|
Indices to be taken.
|
axis : int, optional
|
The axis over which to select values, always 0.
|
allow_fill : bool, default True
|
fill_value : scalar, default None
|
If allow_fill=True and fill_value is not None, indices specified by
|
-1 are regarded as NA. If Index doesn't hold NA, raise ValueError.
|
|
Returns
|
-------
|
Index
|
An index formed of elements at the given indices. Will be the same
|
type as self, except for RangeIndex.
|
|
See Also
|
--------
|
numpy.ndarray.take: Return an array formed from the
|
elements of a at the given indices.
|
Útaker r" )ÚaxisÚ
|
allow_fillc K s |rt d|¡ t|r tdt|}| |||¡}| j}t|tj r^t
|
j |||| j d}n|j ||| j d}| j j|| jdS )Nr¤ z!Expected indices to be array-like)rl Ú
|
fill_valuer )ÚnvZ validate_takerP Ú TypeErrorr? Ú_maybe_disallow_fillrú rê r¼ r½ r rj Ú _na_valuer% r rÏ )r Úindicesrk rl rm r# r Ztakenr¤ r¤ r¥ rj . s( ÿ ÿz
|
Index.take)rl r c C sL |rD|dk rD| j r(|dk ¡ rBtdqHt| j}td| dnd}|S )zm
|
We only use pandas-style take when allow_fill is True _and_
|
fill_value is not None.
|
NéÿÿÿÿzJWhen allow_fill=True and fill_value is not None, all indices must be >= -1z Unable to fill values because z cannot contain NAF)Ú _can_hold_nar[ r r rg )r rl rm rr Zcls_namer¤ r¤ r¥ rp M s ÿ
|
|
ÿzIndex._maybe_disallow_filla|
|
Repeat elements of a %(klass)s.
|
|
Returns a new %(klass)s where each element of the current %(klass)s
|
is repeated consecutively a given number of times.
|
|
Parameters
|
----------
|
repeats : int or array of ints
|
The number of repetitions for each element. This should be a
|
non-negative integer. Repeating 0 times will return an empty
|
%(klass)s.
|
axis : None
|
Must be ``None``. Has no effect but is accepted for compatibility
|
with numpy.
|
|
Returns
|
-------
|
%(klass)s
|
Newly created %(klass)s with repeated elements.
|
|
See Also
|
--------
|
Series.repeat : Equivalent function for Series.
|
numpy.repeat : Similar method for :class:`numpy.ndarray`.
|
|
Examples
|
--------
|
>>> idx = pd.Index(['a', 'b', 'c'])
|
>>> idx
|
Index(['a', 'b', 'c'], dtype='object')
|
>>> idx.repeat(2)
|
Index(['a', 'a', 'b', 'b', 'c', 'c'], dtype='object')
|
>>> idx.repeat([1, 2, 3])
|
Index(['a', 'b', 'b', 'c', 'c', 'c'], dtype='object')
|
Úrepeatc C s6 t |}t dd|i¡ | j |¡}| jj|| jdS )Nr¤ rk r )r? rn Zvalidate_repeatrú ru r% r rÏ )r Zrepeatsrk Ú
|
res_valuesr¤ r¤ r¥ ru s z Index.repeatzHashable | None)r rÏ Údeepr c C sD | j ||dd }|r4| j ¡ }t| j||d}n | j|d}|S )a
|
Make a copy of this object.
|
|
Name is set on the new object.
|
|
Parameters
|
----------
|
name : Label, optional
|
Set name for new object.
|
deep : bool, default False
|
|
Returns
|
-------
|
Index
|
Index refer to new object which is a copy of this object.
|
|
Notes
|
-----
|
In most cases, there should be no functional difference from using
|
``deep``, but if ``deep`` is passed it will attempt to deepcopy.
|
)rÏ rw r r )Ú_validate_namesrÊ rÛ r r r; )r rÏ rw Znew_dataÚ new_indexr¤ r¤ r¥ rÛ s
|
z
|
Index.copyc K s | j f |S rº rß )r r# r¤ r¤ r¥ Ú__copy__º s zIndex.__copy__c C s | j ddS )zq
|
Parameters
|
----------
|
memo, default None
|
Standard signature. Unused
|
T©rw rß )r Úmemor¤ r¤ r¥ Ú __deepcopy__¾ s zIndex.__deepcopy__c C s` t | j}| ¡ }| ¡ }| ¡ }dd |D }d| |¡}|dkrLd}| d| | dS )zA
|
Return a string representation for this object.
|
c S s g | ]\}}| d | qS )ú=r¤ ©rì ÚkÚvr¤ r¤ r¥ rX Ô s z"Index.__repr__.<locals>.<listcomp>ú,Nr ú(ú))r rg Ú _format_dataÚ _format_attrsÚ _format_spacer¦ )r Ú
|
klass_namer¯ ÚattrsÚspaceZ attrs_strZpreprr¤ r¤ r¥ Ú__repr__Ë s
|
zIndex.__repr__c C s dS )Nú r¤ rÔ r¤ r¤ r¥ r Ý s zIndex._format_spacec C s t S )z0
|
Return the formatter function.
|
)r rÔ r¤ r¤ r¥ Ú_formatter_funcæ s zIndex._formatter_funcc C sL d}| j dkrd}n"| j dkr6td| } t| jr6d}t| | j||| jdS )z@
|
Return the formatted data as a unicode string.
|
TÚstringFÚ categoricalr )Ú
|
is_justifyrÏ Zline_break_each_value)Ú inferred_typer rO Ú
|
categoriesr r r )r rÏ r r¤ r¤ r¥ r
í s
|
|
|
|
ûzIndex._format_dataz-list[tuple[str_t, str_t | int | bool | None]]c C s¢ g }| j s"| dd| j df¡ | jdk rB| dt| jf¡ n.| j rptdd | jD rp| dt| jf¡ tdp~t| }t| |kr| d t| f¡ |S )
|
zH
|
Return a list of tuples of the (attr,formatted_value).
|
r® ú'NrÏ c s s | ]}|d k V qd S rº r¤ rV r¤ r¤ r¥ rî s z&Index._format_attrs.<locals>.<genexpr>rñ zdisplay.max_seq_itemsÚlength) r Úappendr® rÏ r r[ rñ r r )r r Z max_seq_itemsr¤ r¤ r¥ r s
|
zIndex._format_attrsz Hashable | Sequence[Hashable]c C s2 | j rdd t| jD S | jdkr(dS | jS dS )zX
|
Return a name or list of names with None replaced by the level number.
|
c S s g | ]\}}|d kr|n|qS rº r¤ )rì r rÏ r¤ r¤ r¥ rX s z*Index._get_level_names.<locals>.<listcomp>Nr )r Ú enumeraterñ rÏ rÔ r¤ r¤ r¥ Ú_get_level_names s
|
ÿzIndex._get_level_namesc C s8 t | jtjr(| jjdkr(ttj| jS | jtddj S )Nræ Frß )
|
rê r® r¼ rû r r½ r rù r rú rÔ r¤ r¤ r¥ Ú _mpl_repr" s zIndex._mpl_reprÚNaNzCallable | Nonez list[str_t])rÏ Ú formatterÚna_repr c C sR g }|r*| | jdk r$t| jddnd¡ |dk rD|t| |¡ S | j||dS )z>
|
Render a string representation of the Index.
|
N©ú ú r' ©Z escape_charsr )r )r rÏ r r ÚmapÚ_format_with_header)r rÏ r r Úheaderr¤ r¤ r¥ Úformat) s ÿýz Index.format)r¢ r r c C s ddl m} | j}t|jrpttj|}tj |dd}dd |D }t
|
|}| ¡ rt |¡}|||< | ¡ }nt||d dd}|| S ) Nr )Ú format_arrayT)Úsafec S s g | ]}t |d dqS )r r )r rV r¤ r¤ r¥ rX H s z-Index._format_with_header.<locals>.<listcomp>r )Zjustify)Úpandas.io.formats.formatr¤ rú rO r® r r¼ r½ r r! r r[ r ÚtolistÚ
|
trim_front)r r¢ r r¤ r r ÚmaskZ
|
result_arrr¤ r¤ r¥ r¡ ? s
|
|
|
zIndex._format_with_headerr Ú.)r ÚdecimalÚ float_formatÚ date_formatÚquotingúnpt.NDArray[np.object_])r r« r c
|
C s ddl m} t| jr>t| js>|| j||||dd}| ¡ S t| }t| sd|sdt
|
| ¡ t ¡} nt j | tdd} || |< | S )z>
|
Actually format specific types of the index.
|
r )ÚFloatArrayFormatterF)r r¬ r« r® Z fixed_widthTrò )r¦ r° rG r® rE rú Zget_result_as_arrayre rO r¼ r rù rÈ r r )
|
r r r« r¬ r r® r° r r© r r¤ r¤ r¥ Ú_format_native_typesT s" ú zIndex._format_native_typesc C sÐ t | dkr¢| d }t|dr2t|ts2| ¡ }n t| jrN| |¡ dd¡}| d }t|drtt|tst| ¡ }n t| jr| |¡ dd¡}d| d| }nd}|dkr¸t | j
|
}| d t | d
|
| S ) a
|
Return a summarized representation.
|
|
Parameters
|
----------
|
name : str
|
name to use in the summary representation
|
|
Returns
|
-------
|
String with a summarized representation of the index
|
r r£ r r rs z, z to Nz: z entries) r r rê rÈ r£ rS r® r Úreplacer rg )r rÏ ÚheadÚtailZ index_summaryr¤ r¤ r¥ Ú_summaryv s
|
|
|
|
|
zIndex._summaryc C s | S )a+
|
Identity method.
|
|
This is implemented for compatibility with subclass implementations
|
when chaining.
|
|
Returns
|
-------
|
pd.Index
|
Caller.
|
|
See Also
|
--------
|
MultiIndex.to_flat_index : Subclass implementation.
|
r¤ rÔ r¤ r¤ r¥ Ú to_flat_index s zIndex.to_flat_indexr
)rÏ r c C s> ddl m} |dkr | ¡ }|dkr*| j}|| j ¡ ||dS )a
|
Create a Series with both index and values equal to the index keys.
|
|
Useful with map for returning an indexer based on an index.
|
|
Parameters
|
----------
|
index : Index, optional
|
Index of resulting Series. If None, defaults to original index.
|
name : str, optional
|
Name of resulting Series. If None, defaults to name of original
|
index.
|
|
Returns
|
-------
|
Series
|
The dtype will be based on the type of the Index values.
|
|
See Also
|
--------
|
Index.to_frame : Convert an Index to a DataFrame.
|
Series.to_frame : Convert Series to DataFrame.
|
|
Examples
|
--------
|
>>> idx = pd.Index(['Ant', 'Bear', 'Cow'], name='animal')
|
|
By default, the original Index and original name is reused.
|
|
>>> idx.to_series()
|
animal
|
Ant Ant
|
Bear Bear
|
Cow Cow
|
Name: animal, dtype: object
|
|
To enforce a new Index, specify new labels to ``index``:
|
|
>>> idx.to_series(index=[0, 1, 2])
|
0 Ant
|
1 Bear
|
2 Cow
|
Name: animal, dtype: object
|
|
To override the name of the resulting column, specify `name`:
|
|
>>> idx.to_series(name='zoo')
|
animal
|
Ant Ant
|
Bear Bear
|
Cow Cow
|
Name: zoo, dtype: object
|
r r- N)r rÏ )r r
r: rÏ rú rÛ )r r rÏ r
r¤ r¤ r¥ Ú to_series® s 7 zIndex.to_series)r rÏ r c C s> ddl m} |tjkr | ¡ }||| j ¡ i}|r:| |_|S )a¿
|
Create a DataFrame with a column containing the Index.
|
|
Parameters
|
----------
|
index : bool, default True
|
Set the index of the returned DataFrame as the original Index.
|
|
name : object, defaults to index.name
|
The passed name should substitute for the index name (if it has
|
one).
|
|
Returns
|
-------
|
DataFrame
|
DataFrame containing the original Index data.
|
|
See Also
|
--------
|
Index.to_series : Convert an Index to a Series.
|
Series.to_frame : Convert Series to DataFrame.
|
|
Examples
|
--------
|
>>> idx = pd.Index(['Ant', 'Bear', 'Cow'], name='animal')
|
>>> idx.to_frame()
|
animal
|
animal
|
Ant Ant
|
Bear Bear
|
Cow Cow
|
|
By default, the original Index is reused. To enforce a new Index:
|
|
>>> idx.to_frame(index=False)
|
animal
|
0 Ant
|
1 Bear
|
2 Cow
|
|
To override the name of the resulting column, specify `name`:
|
|
>>> idx.to_frame(index=False, name='zoo')
|
zoo
|
0 Ant
|
1 Bear
|
2 Cow
|
r )r )r r r r r rú rÛ r )r r rÏ r r r¤ r¤ r¥ r5 î s 3
|
zIndex.to_framec C s | j S )z2
|
Return Index or MultiIndex name.
|
)rÍ rÔ r¤ r¤ r¥ rÏ . s z
|
Index.name)Úvaluer c C s( | j rtdt|d t| || _d S )NzOCannot set name on a level of a MultiIndex. Use 'MultiIndex.set_names' instead.)rÎ Ú RuntimeErrorrõ r rÍ ©r r¸ r¤ r¤ r¥ rÏ 5 s ÿzlist[Hashable])rw r c C sÊ ddl m} |dk r$|dk r$td|dkrJ|dkrJ|rB|| jn| j}n2|dk rht|sbtd|}nt|sx|g}n|}t|t| jkr¬tdt| j dt| t|dt| j d i |S )
|
z
|
Handles the quirks of having a singular 'name' parameter for general
|
Index and plural 'names' parameter for MultiIndex.
|
r )ÚdeepcopyNz*Can only provide one of `names` and `name`ú Must pass list-like as `names`.z Length of new names must be z, got Ú
|
error_nameú.name)
|
rÛ r» ro rñ rM r r rU r rg )r rÏ rñ rw r» Ú new_namesr¤ r¤ r¥ rx @ s$ ÿzIndex._validate_namesz$Hashable | Sequence[Hashable] | None)rñ r c C sz ddl m} |dk r(t|ttfr(|g}t|tsB|dk rBtd|svt| |r^t | j ¡}n| j
|
dkrn|gn| j
|
g}|S )a=
|
Get names of index.
|
|
Parameters
|
----------
|
names : int, str or 1-dimensional list, default None
|
Index names to set.
|
default : str
|
Default name of index.
|
|
Raises
|
------
|
TypeError
|
if names not str or list-like
|
r rï Nz-Index names must be str or 1-dimensional list) r r rê rN rÈ r r rü Zfill_missing_namesrñ rÏ )r rñ Údefaultr r¤ r¤ r¥ Ú_get_default_index_namesa s
|
z Index._get_default_index_namesrv c C s t | jfS rº )rv rÏ rÔ r¤ r¤ r¥ Ú
|
_get_names s zIndex._get_namesrL c C sV t |stdt|dkr.tdt| t|dt| j di |d | _dS )aÙ
|
Set new names on index. Each name has to be a hashable type.
|
|
Parameters
|
----------
|
values : str or sequence
|
name(s) to set
|
level : int, level name, or sequence of int/level names (default None)
|
If the index is a MultiIndex (hierarchical), level(s) to set (None
|
for all levels). Otherwise level must be None
|
|
Raises
|
------
|
TypeError if each name is not hashable.
|
zNames must be a list-liker¸ z#Length of new names must be 1, got r½ r¾ r N)rM r r rU r rg rÍ ©r r r r¤ r¤ r¥ Ú
|
_set_names s zIndex._set_names)ÚfsetÚfget.)r r zLiteral[False])r r r c C s d S rº r¤ ©r rñ r r r¤ r¤ r¥ Ú set_names¤ s zIndex.set_namesz Literal[True])r r c C s d S rº r¤ rÇ r¤ r¤ r¥ rÈ ª s z_IndexT | Nonec C s d S rº r¤ rÇ r¤ r¤ r¥ rÈ ® s c C sF |dk rt | tstd|dk r:t|s:t|r:tdt|s\|dkr\| jdkr\tdt|rvt | tsvtdt|r|dk rtdt | trît|rî|dkrîg g }}t| jD ],\}}|| ¡ kr¼|
|
|¡ |
|
|| ¡ q¼|}t|sü|g}|dk rt|s|g}|r"| }n| ¡ }|j ||d |sB|S dS ) aû
|
Set Index or MultiIndex name.
|
|
Able to set new names partially and by level.
|
|
Parameters
|
----------
|
|
names : label or list of label or dict-like for MultiIndex
|
Name(s) to set.
|
|
.. versionchanged:: 1.3.0
|
|
level : int, label or list of int or label, optional
|
If the index is a MultiIndex and names is not dict-like, level(s) to set
|
(None for all levels). Otherwise level must be None.
|
|
.. versionchanged:: 1.3.0
|
|
inplace : bool, default False
|
Modifies the object directly, instead of creating a new Index or
|
MultiIndex.
|
|
Returns
|
-------
|
Index or None
|
The same type as the caller or None if ``inplace=True``.
|
|
See Also
|
--------
|
Index.rename : Able to set new names without level.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 2, 3, 4])
|
>>> idx
|
Index([1, 2, 3, 4], dtype='int64')
|
>>> idx.set_names('quarter')
|
Index([1, 2, 3, 4], dtype='int64', name='quarter')
|
|
>>> idx = pd.MultiIndex.from_product([['python', 'cobra'],
|
... [2018, 2019]])
|
>>> idx
|
MultiIndex([('python', 2018),
|
('python', 2019),
|
( 'cobra', 2018),
|
( 'cobra', 2019)],
|
)
|
>>> idx = idx.set_names(['kind', 'year'])
|
>>> idx.set_names('species', level=0)
|
MultiIndex([('python', 2018),
|
('python', 2019),
|
( 'cobra', 2018),
|
( 'cobra', 2019)],
|
names=['species', 'year'])
|
|
When renaming levels with a dict, levels can not be passed.
|
|
>>> idx.set_names({'kind': 'snake'})
|
MultiIndex([('python', 2018),
|
('python', 2019),
|
( 'cobra', 2018),
|
( 'cobra', 2019)],
|
names=['snake', 'year'])
|
Nz%Level must be None for non-MultiIndexz7Names must be a string when a single level is provided.r¸ r¼ z2Can only pass dict-like as `names` for MultiIndex.z(Can not pass level for dictlike `names`.rL ) rê r^ r rM ro r4 rb r rñ Úkeysr r: rÄ )r rñ r r Znames_adjustedrà rÏ Úidxr¤ r¤ r¥ rÈ ´ s8 D
|
|
©r c C s | j |g|dS )aq
|
Alter Index or MultiIndex name.
|
|
Able to set new names without level. Defaults to returning new index.
|
Length of names must match number of levels in MultiIndex.
|
|
Parameters
|
----------
|
name : label or list of labels
|
Name(s) to set.
|
inplace : bool, default False
|
Modifies the object directly, instead of creating a new Index or
|
MultiIndex.
|
|
Returns
|
-------
|
Index or None
|
The same type as the caller or None if ``inplace=True``.
|
|
See Also
|
--------
|
Index.set_names : Able to set new names partially and by level.
|
|
Examples
|
--------
|
>>> idx = pd.Index(['A', 'C', 'A', 'B'], name='score')
|
>>> idx.rename('grade')
|
Index(['A', 'C', 'A', 'B'], dtype='object', name='grade')
|
|
>>> idx = pd.MultiIndex.from_product([['python', 'cobra'],
|
... [2018, 2019]],
|
... names=['kind', 'year'])
|
>>> idx
|
MultiIndex([('python', 2018),
|
('python', 2019),
|
( 'cobra', 2018),
|
( 'cobra', 2019)],
|
names=['kind', 'year'])
|
>>> idx.rename(['species', 'year'])
|
MultiIndex([('python', 2018),
|
('python', 2019),
|
( 'cobra', 2018),
|
( 'cobra', 2019)],
|
names=['species', 'year'])
|
>>> idx.rename('species')
|
Traceback (most recent call last):
|
TypeError: Must pass list-like as `names`.
|
rË )rÈ )r rÏ r r¤ r¤ r¥ Úrename s 1z Index.renamec C s dS )z#
|
Number of levels.
|
r¸ r¤ rÔ r¤ r¤ r¥ r4 U s z Index.nlevelsc C s | S )z)
|
Compat with MultiIndex.
|
r¤ rÔ r¤ r¤ r¥ Ú_sort_levels_monotonic\ s z Index._sort_levels_monotonicc C sl t |trF|dk r*|dkr*td| d|dkrhtd|d n"|| jkrhtd| d| j d d
|
S ) z¨
|
Validate index level.
|
|
For single-level Index getting level number is a no-op, but some
|
verification must be done like in MultiIndex.
|
|
r rs z)Too many levels: Index has only 1 level, z is not a valid level numberz-Too many levels: Index has only 1 level, not r¸ zRequested level (z ) does not match index name (r N)rê rN Ú
|
IndexErrorrÏ rB ©r r r¤ r¤ r¥ Ú_validate_index_levelb s
|
|
ÿ ÿ
|
ÿzIndex._validate_index_levelc C s | |¡ dS )Nr ©rÐ rÏ r¤ r¤ r¥ Ú_get_level_numberz s
|
zIndex._get_level_numberzbool | list[bool])Ú ascendingc C s\ t |ttfstdt |tr<t|dkr4td|d }t |tsNtd| jd|dS )a\
|
For internal compatibility with the Index API.
|
|
Sort the Index. This is for compat with MultiIndex
|
|
Parameters
|
----------
|
ascending : bool, default True
|
False to sort in descending order
|
|
level, sort_remaining are compat parameters
|
|
Returns
|
-------
|
Index
|
zIascending must be a single bool value ora list of bool values of length 1r¸ z3ascending must be a list of bool values of length 1r z ascending must be a bool valueT)Úreturn_indexerrÓ )rê r r ro r Ú sort_values)r r rÓ Zsort_remainingr¤ r¤ r¥ Ú sortlevel~ s ÿ
|
|
zIndex.sortlevelc C s | |¡ | S )aÅ
|
Return an Index of values for requested level.
|
|
This is primarily useful to get an individual level of values from a
|
MultiIndex, but is provided on Index as well for compatibility.
|
|
Parameters
|
----------
|
level : int or str
|
It is either the integer position or the name of the level.
|
|
Returns
|
-------
|
Index
|
Calling object, as there is only one level in the Index.
|
|
See Also
|
--------
|
MultiIndex.get_level_values : Get values for a level of a MultiIndex.
|
|
Notes
|
-----
|
For Index, level should be 0, since there are no multiple levels.
|
|
Examples
|
--------
|
>>> idx = pd.Index(list('abc'))
|
>>> idx
|
Index(['a', 'b', 'c'], dtype='object')
|
|
Get level values by supplying `level` as integer:
|
|
>>> idx.get_level_values(0)
|
Index(['a', 'b', 'c'], dtype='object')
|
rÑ rÏ r¤ r¤ r¥ Ú_get_level_values¡ s $
|
zIndex._get_level_valuesr' c s> t |ttfs|g}t fdd|D ddd
} |¡S )a¾
|
Return index with requested level(s) removed.
|
|
If resulting index has only 1 level left, the result will be
|
of Index type, not MultiIndex. The original index is not modified inplace.
|
|
Parameters
|
----------
|
level : int, str, or list-like, default 0
|
If a string is given, must be the name of a level
|
If list-like, elements must be names or indexes of levels.
|
|
Returns
|
-------
|
Index or MultiIndex
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays(
|
... [[1, 2], [3, 4], [5, 6]], names=['x', 'y', 'z'])
|
>>> mi
|
MultiIndex([(1, 3, 5),
|
(2, 4, 6)],
|
names=['x', 'y', 'z'])
|
|
>>> mi.droplevel()
|
MultiIndex([(3, 5),
|
(4, 6)],
|
names=['y', 'z'])
|
|
>>> mi.droplevel(2)
|
MultiIndex([(1, 3),
|
(2, 4)],
|
names=['x', 'y'])
|
|
>>> mi.droplevel('z')
|
MultiIndex([(1, 3),
|
(2, 4)],
|
names=['x', 'y'])
|
|
>>> mi.droplevel(['x', 'y'])
|
Index([5, 6], dtype='int64', name='z')
|
c 3 s | ]} |¡V qd S rº )rÒ )rì ÚlevrÔ r¤ r¥ rî ú s z"Index.droplevel.<locals>.<genexpr>Nrs )rê rë r ÚsortedÚ_drop_level_numbers)r r Úlevnumsr¤ rÔ r¥ Ú droplevelÊ s - zIndex.droplevelz list[int])rÛ c C s\ |st | ts| S t|| jkr<tdt| d| j dtd| } t| j}t| j}t| j }|D ]"}|
|
|¡ |
|
|¡ |
|
|¡ qht|dkr<|d }t|dkrøt|d dkrÌ|dd
}n*t j |j |d dd }|jj||d d
|
}n@|d d k} |d |d ¡}| ¡ r.| | tj¡}|d |_|S dd lm}
|
|
|
|||d dS dS )zE
|
Drop MultiIndex levels by level _number_, not name.
|
zCannot remove z levels from an index with z) levels: at least one level must be left.r r¸ r NT)rl r rs rï F©Úlevelsr¬ rñ r )rê r^ r r4 r r r rÞ r¬ rñ r± r rj rú r% r r[ Úputmaskr¼ ÚnanrÍ r r ) r rÛ Ú
|
new_levelsÚ new_codesr¿ rà rØ r rv r© r r¤ r¤ r¥ rÚ þ sD ÿ
|
|
|
|
|
|
|
|
üzIndex._drop_level_numbersc C s8 t | jtr$t | jtr dS | jjS | jjdkr4dS dS )NT)rà rá rã F)rê r® rY rZ rt rû rÔ r¤ r¤ r¥ rt ; s zIndex._can_hold_nac C s | j jS )aâ
|
Return a boolean if the values are equal or increasing.
|
|
Returns
|
-------
|
bool
|
|
See Also
|
--------
|
Index.is_monotonic_decreasing : Check if the values are equal or decreasing.
|
|
Examples
|
--------
|
>>> pd.Index([1, 2, 3]).is_monotonic_increasing
|
True
|
>>> pd.Index([1, 2, 2]).is_monotonic_increasing
|
True
|
>>> pd.Index([1, 3, 2]).is_monotonic_increasing
|
False
|
)r> Úis_monotonic_increasingrÔ r¤ r¤ r¥ rã I s z Index.is_monotonic_increasingc C s | j jS )aâ
|
Return a boolean if the values are equal or decreasing.
|
|
Returns
|
-------
|
bool
|
|
See Also
|
--------
|
Index.is_monotonic_increasing : Check if the values are equal or increasing.
|
|
Examples
|
--------
|
>>> pd.Index([3, 2, 1]).is_monotonic_decreasing
|
True
|
>>> pd.Index([3, 2, 2]).is_monotonic_decreasing
|
True
|
>>> pd.Index([3, 1, 2]).is_monotonic_decreasing
|
False
|
)r> Úis_monotonic_decreasingrÔ r¤ r¤ r¥ rä a s z Index.is_monotonic_decreasingc C s | j o
|
| jS )aq
|
Return if the index is strictly monotonic increasing
|
(only increasing) values.
|
|
Examples
|
--------
|
>>> Index([1, 2, 3])._is_strictly_monotonic_increasing
|
True
|
>>> Index([1, 2, 2])._is_strictly_monotonic_increasing
|
False
|
>>> Index([1, 3, 2])._is_strictly_monotonic_increasing
|
False
|
)r( rã rÔ r¤ r¤ r¥ Ú!_is_strictly_monotonic_increasingy s z'Index._is_strictly_monotonic_increasingc C s | j o
|
| jS )aq
|
Return if the index is strictly monotonic decreasing
|
(only decreasing) values.
|
|
Examples
|
--------
|
>>> Index([3, 2, 1])._is_strictly_monotonic_decreasing
|
True
|
>>> Index([3, 2, 2])._is_strictly_monotonic_decreasing
|
False
|
>>> Index([3, 1, 2])._is_strictly_monotonic_decreasing
|
False
|
)r( rä rÔ r¤ r¤ r¥ Ú!_is_strictly_monotonic_decreasing s z'Index._is_strictly_monotonic_decreasingc C s | j jS )aÚ
|
Return if the index has unique values.
|
|
Returns
|
-------
|
bool
|
|
See Also
|
--------
|
Index.has_duplicates : Inverse method that checks if it has duplicate values.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 5, 7, 7])
|
>>> idx.is_unique
|
False
|
|
>>> idx = pd.Index([1, 5, 7])
|
>>> idx.is_unique
|
True
|
|
>>> idx = pd.Index(["Watermelon", "Orange", "Apple",
|
... "Watermelon"]).astype("category")
|
>>> idx.is_unique
|
False
|
|
>>> idx = pd.Index(["Orange", "Apple",
|
... "Watermelon"]).astype("category")
|
>>> idx.is_unique
|
True
|
)r> r( rÔ r¤ r¤ r¥ r( s !zIndex.is_uniquec C s | j S )a#
|
Check if the Index has duplicate values.
|
|
Returns
|
-------
|
bool
|
Whether or not the Index has duplicate values.
|
|
See Also
|
--------
|
Index.is_unique : Inverse method that checks if it has unique values.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 5, 7, 7])
|
>>> idx.has_duplicates
|
True
|
|
>>> idx = pd.Index([1, 5, 7])
|
>>> idx.has_duplicates
|
False
|
|
>>> idx = pd.Index(["Watermelon", "Orange", "Apple",
|
... "Watermelon"]).astype("category")
|
>>> idx.has_duplicates
|
True
|
|
>>> idx = pd.Index(["Orange", "Apple",
|
... "Watermelon"]).astype("category")
|
>>> idx.has_duplicates
|
False
|
©r( rÔ r¤ r¤ r¥ Úhas_duplicatesÀ s #zIndex.has_duplicatesc C s( t jt| j dtt d | jdkS )ah
|
Check if the Index only consists of booleans.
|
|
.. deprecated:: 2.0.0
|
Use `pandas.api.types.is_bool_dtype` instead.
|
|
Returns
|
-------
|
bool
|
Whether or not the Index only consists of booleans.
|
|
See Also
|
--------
|
is_integer : Check if the Index only consists of integers (deprecated).
|
is_floating : Check if the Index is a floating type (deprecated).
|
is_numeric : Check if the Index only consists of numeric data (deprecated).
|
is_object : Check if the Index is of the object dtype (deprecated).
|
is_categorical : Check if the Index holds categorical data.
|
is_interval : Check if the Index holds Interval objects (deprecated).
|
|
Examples
|
--------
|
>>> idx = pd.Index([True, False, True])
|
>>> idx.is_boolean() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index(["True", "False", "True"])
|
>>> idx.is_boolean() # doctest: +SKIP
|
False
|
|
>>> idx = pd.Index([True, False, "True"])
|
>>> idx.is_boolean() # doctest: +SKIP
|
False
|
zE.is_boolean is deprecated. Use pandas.api.types.is_bool_type instead.©Ú
|
stacklevel)r ©ÚwarningsÚwarnr rg Ú FutureWarningr2 r rÔ r¤ r¤ r¥ Ú
|
is_booleanå s $üzIndex.is_booleanc C s( t jt| j dtt d | jdkS )ax
|
Check if the Index only consists of integers.
|
|
.. deprecated:: 2.0.0
|
Use `pandas.api.types.is_integer_dtype` instead.
|
|
Returns
|
-------
|
bool
|
Whether or not the Index only consists of integers.
|
|
See Also
|
--------
|
is_boolean : Check if the Index only consists of booleans (deprecated).
|
is_floating : Check if the Index is a floating type (deprecated).
|
is_numeric : Check if the Index only consists of numeric data (deprecated).
|
is_object : Check if the Index is of the object dtype. (deprecated).
|
is_categorical : Check if the Index holds categorical data (deprecated).
|
is_interval : Check if the Index holds Interval objects (deprecated).
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 2, 3, 4])
|
>>> idx.is_integer() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index([1.0, 2.0, 3.0, 4.0])
|
>>> idx.is_integer() # doctest: +SKIP
|
False
|
|
>>> idx = pd.Index(["Apple", "Mango", "Watermelon"])
|
>>> idx.is_integer() # doctest: +SKIP
|
False
|
zI.is_integer is deprecated. Use pandas.api.types.is_integer_dtype instead.ré )Úintegerrë rÔ r¤ r¤ r¥ rI s $üzIndex.is_integerc C s( t jt| j dtt d | jdkS )a
|
Check if the Index is a floating type.
|
|
.. deprecated:: 2.0.0
|
Use `pandas.api.types.is_float_dtype` instead
|
|
The Index may consist of only floats, NaNs, or a mix of floats,
|
integers, or NaNs.
|
|
Returns
|
-------
|
bool
|
Whether or not the Index only consists of only consists of floats, NaNs, or
|
a mix of floats, integers, or NaNs.
|
|
See Also
|
--------
|
is_boolean : Check if the Index only consists of booleans (deprecated).
|
is_integer : Check if the Index only consists of integers (deprecated).
|
is_numeric : Check if the Index only consists of numeric data (deprecated).
|
is_object : Check if the Index is of the object dtype. (deprecated).
|
is_categorical : Check if the Index holds categorical data (deprecated).
|
is_interval : Check if the Index holds Interval objects (deprecated).
|
|
Examples
|
--------
|
>>> idx = pd.Index([1.0, 2.0, 3.0, 4.0])
|
>>> idx.is_floating() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index([1.0, 2.0, np.nan, 4.0])
|
>>> idx.is_floating() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index([1, 2, 3, 4, np.nan])
|
>>> idx.is_floating() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index([1, 2, 3, 4])
|
>>> idx.is_floating() # doctest: +SKIP
|
False
|
zH.is_floating is deprecated. Use pandas.api.types.is_float_dtype instead.ré )Úfloatingzmixed-integer-floatz
|
integer-narë rÔ r¤ r¤ r¥ Ú is_floating= s ,üzIndex.is_floatingc C s( t jt| j dtt d | jdkS )aR
|
Check if the Index only consists of numeric data.
|
|
.. deprecated:: 2.0.0
|
Use `pandas.api.types.is_numeric_dtype` instead.
|
|
Returns
|
-------
|
bool
|
Whether or not the Index only consists of numeric data.
|
|
See Also
|
--------
|
is_boolean : Check if the Index only consists of booleans (deprecated).
|
is_integer : Check if the Index only consists of integers (deprecated).
|
is_floating : Check if the Index is a floating type (deprecated).
|
is_object : Check if the Index is of the object dtype. (deprecated).
|
is_categorical : Check if the Index holds categorical data (deprecated).
|
is_interval : Check if the Index holds Interval objects (deprecated).
|
|
Examples
|
--------
|
>>> idx = pd.Index([1.0, 2.0, 3.0, 4.0])
|
>>> idx.is_numeric() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index([1, 2, 3, 4.0])
|
>>> idx.is_numeric() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index([1, 2, 3, 4])
|
>>> idx.is_numeric() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index([1, 2, 3, 4.0, np.nan])
|
>>> idx.is_numeric() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index([1, 2, 3, 4.0, np.nan, "Apple"])
|
>>> idx.is_numeric() # doctest: +SKIP
|
False
|
zQ.is_numeric is deprecated. Use pandas.api.types.is_any_real_numeric_dtype insteadré )rð rñ rë rÔ r¤ r¤ r¥ Ú
|
is_numericq s ,üzIndex.is_numericc C s( t jt| j dtt d t| jS )a2
|
Check if the Index is of the object dtype.
|
|
.. deprecated:: 2.0.0
|
Use `pandas.api.types.is_object_dtype` instead.
|
|
Returns
|
-------
|
bool
|
Whether or not the Index is of the object dtype.
|
|
See Also
|
--------
|
is_boolean : Check if the Index only consists of booleans (deprecated).
|
is_integer : Check if the Index only consists of integers (deprecated).
|
is_floating : Check if the Index is a floating type (deprecated).
|
is_numeric : Check if the Index only consists of numeric data (deprecated).
|
is_categorical : Check if the Index holds categorical data (deprecated).
|
is_interval : Check if the Index holds Interval objects (deprecated).
|
|
Examples
|
--------
|
>>> idx = pd.Index(["Apple", "Mango", "Watermelon"])
|
>>> idx.is_object() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index(["Apple", "Mango", 2.0])
|
>>> idx.is_object() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index(["Watermelon", "Orange", "Apple",
|
... "Watermelon"]).astype("category")
|
>>> idx.is_object() # doctest: +SKIP
|
False
|
|
>>> idx = pd.Index([1.0, 2.0, 3.0, 4.0])
|
>>> idx.is_object() # doctest: +SKIP
|
False
|
zE.is_object is deprecated.Use pandas.api.types.is_object_dtype insteadré )rì rí r rg rî r2 rO r® rÔ r¤ r¤ r¥ Ú is_object¥ s )üzIndex.is_objectc C s( t jt| j dtt d | jdkS )a
|
Check if the Index holds categorical data.
|
|
.. deprecated:: 2.0.0
|
Use :meth:`pandas.api.types.is_categorical_dtype` instead.
|
|
Returns
|
-------
|
bool
|
True if the Index is categorical.
|
|
See Also
|
--------
|
CategoricalIndex : Index for categorical data.
|
is_boolean : Check if the Index only consists of booleans (deprecated).
|
is_integer : Check if the Index only consists of integers (deprecated).
|
is_floating : Check if the Index is a floating type (deprecated).
|
is_numeric : Check if the Index only consists of numeric data (deprecated).
|
is_object : Check if the Index is of the object dtype. (deprecated).
|
is_interval : Check if the Index holds Interval objects (deprecated).
|
|
Examples
|
--------
|
>>> idx = pd.Index(["Watermelon", "Orange", "Apple",
|
... "Watermelon"]).astype("category")
|
>>> idx.is_categorical() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index([1, 3, 5, 7])
|
>>> idx.is_categorical() # doctest: +SKIP
|
False
|
|
>>> s = pd.Series(["Peter", "Victor", "Elisabeth", "Mar"])
|
>>> s
|
0 Peter
|
1 Victor
|
2 Elisabeth
|
3 Mar
|
dtype: object
|
>>> s.index.is_categorical() # doctest: +SKIP
|
False
|
zO.is_categorical is deprecated.Use pandas.api.types.is_categorical_dtype insteadré )r rë rÔ r¤ r¤ r¥ Úis_categoricalÖ s ,üzIndex.is_categoricalc C s( t jt| j dtt d | jdkS )au
|
Check if the Index holds Interval objects.
|
|
.. deprecated:: 2.0.0
|
Use `pandas.api.types.is_interval_dtype` instead.
|
|
Returns
|
-------
|
bool
|
Whether or not the Index holds Interval objects.
|
|
See Also
|
--------
|
IntervalIndex : Index for Interval objects.
|
is_boolean : Check if the Index only consists of booleans (deprecated).
|
is_integer : Check if the Index only consists of integers (deprecated).
|
is_floating : Check if the Index is a floating type (deprecated).
|
is_numeric : Check if the Index only consists of numeric data (deprecated).
|
is_object : Check if the Index is of the object dtype. (deprecated).
|
is_categorical : Check if the Index holds categorical data (deprecated).
|
|
Examples
|
--------
|
>>> idx = pd.Index([pd.Interval(left=0, right=5),
|
... pd.Interval(left=5, right=10)])
|
>>> idx.is_interval() # doctest: +SKIP
|
True
|
|
>>> idx = pd.Index([1, 3, 5, 7])
|
>>> idx.is_interval() # doctest: +SKIP
|
False
|
zI.is_interval is deprecated.Use pandas.api.types.is_interval_dtype insteadré )Úintervalrë rÔ r¤ r¤ r¥ Ú is_interval
|
s "üzIndex.is_intervalc C s
|
| j dkS )z6
|
Whether the type is an integer type.
|
)rð r ©r rÔ r¤ r¤ r¥ Ú_holds_integer5
|
s zIndex._holds_integerc C s& t jt| j dtt d | ¡ S )z
|
Whether the type is an integer type.
|
|
.. deprecated:: 2.0.0
|
Use `pandas.api.types.infer_dtype` instead
|
zG.holds_integer is deprecated. Use pandas.api.types.infer_dtype instead.ré )rì rí r rg rî r2 rù rÔ r¤ r¤ r¥ Ú holds_integer<
|
s üzIndex.holds_integerc C s t j| jddS )zG
|
Return a string of the type inferred from the values.
|
F©Úskipna)r Ú infer_dtyperú rÔ r¤ r¤ r¥ r L
|
s zIndex.inferred_typec C s4 t | jrdS | jtkr dS | jr&dS tt| jS )zH
|
Whether or not the index values only consist of dates.
|
TF)rS r® rþ r r r> rú rÔ r¤ r¤ r¥ Ú _is_all_datesS
|
s
|
|
zIndex._is_all_datesc C s
|
t | tS )zI
|
Cached check equivalent to isinstance(self, MultiIndex)
|
)rê r^ rÔ r¤ r¤ r¥ r d
|
s zIndex._is_multic C s | j | jd}tt| |fd fS )N)r¯ rÏ )rÊ rÏ rµ r )r r´ r¤ r¤ r¥ Ú
|
__reduce__o
|
s zIndex.__reduce__c C s, | j }t|tj r&|jdkr tS tjS |jS )z-The expected NA value to use with this index.©rå ræ )r® rê r¼ rû r rà Úna_valuerP r¤ r¤ r¥ rq v
|
s
|
zIndex._na_valueznpt.NDArray[np.bool_]c C s4 | j rt| S tjt| tjd}| d¡ |S dS )z.
|
Return if each value is NaN.
|
rç FN)rt re r¼ Úemptyr Úbool_Úfill)r r r¤ r¤ r¥ Ú_isnan
|
s
|
|
z Index._isnanc C s | j rt| j ¡ S dS dS )z
|
Return True if there are any NaNs.
|
|
Enables various performance speedups.
|
|
Returns
|
-------
|
bool
|
FN)rt r r r[ rÔ r¤ r¤ r¥ Úhasnans
|
s z Index.hasnansc C s | j S )aÿ
|
Detect missing values.
|
|
Return a boolean same-sized object indicating if the values are NA.
|
NA values, such as ``None``, :attr:`numpy.NaN` or :attr:`pd.NaT`, get
|
mapped to ``True`` values.
|
Everything else get mapped to ``False`` values. Characters such as
|
empty strings `''` or :attr:`numpy.inf` are not considered NA values
|
(unless you set ``pandas.options.mode.use_inf_as_na = True``).
|
|
Returns
|
-------
|
numpy.ndarray[bool]
|
A boolean array of whether my values are NA.
|
|
See Also
|
--------
|
Index.notna : Boolean inverse of isna.
|
Index.dropna : Omit entries with missing values.
|
isna : Top-level isna.
|
Series.isna : Detect missing values in Series object.
|
|
Examples
|
--------
|
Show which entries in a pandas.Index are NA. The result is an
|
array.
|
|
>>> idx = pd.Index([5.2, 6.0, np.NaN])
|
>>> idx
|
Index([5.2, 6.0, nan], dtype='float64')
|
>>> idx.isna()
|
array([False, False, True])
|
|
Empty strings are not considered NA values. None is considered an NA
|
value.
|
|
>>> idx = pd.Index(['black', '', 'red', None])
|
>>> idx
|
Index(['black', '', 'red', None], dtype='object')
|
>>> idx.isna()
|
array([False, False, False, True])
|
|
For datetimes, `NaT` (Not a Time) is considered as an NA value.
|
|
>>> idx = pd.DatetimeIndex([pd.Timestamp('1940-04-25'),
|
... pd.Timestamp(''), None, pd.NaT])
|
>>> idx
|
DatetimeIndex(['1940-04-25', 'NaT', 'NaT', 'NaT'],
|
dtype='datetime64[ns]', freq=None)
|
>>> idx.isna()
|
array([False, True, True, True])
|
)r rÔ r¤ r¤ r¥ re
|
s 6z
|
Index.isnac C s
|
| ¡ S )a
|
Detect existing (non-missing) values.
|
|
Return a boolean same-sized object indicating if the values are not NA.
|
Non-missing values get mapped to ``True``. Characters such as empty
|
strings ``''`` or :attr:`numpy.inf` are not considered NA values
|
(unless you set ``pandas.options.mode.use_inf_as_na = True``).
|
NA values, such as None or :attr:`numpy.NaN`, get mapped to ``False``
|
values.
|
|
Returns
|
-------
|
numpy.ndarray[bool]
|
Boolean array to indicate which entries are not NA.
|
|
See Also
|
--------
|
Index.notnull : Alias of notna.
|
Index.isna: Inverse of notna.
|
notna : Top-level notna.
|
|
Examples
|
--------
|
Show which entries in an Index are not NA. The result is an
|
array.
|
|
>>> idx = pd.Index([5.2, 6.0, np.NaN])
|
>>> idx
|
Index([5.2, 6.0, nan], dtype='float64')
|
>>> idx.notna()
|
array([ True, True, False])
|
|
Empty strings are not considered NA values. None is considered a NA
|
value.
|
|
>>> idx = pd.Index(['black', '', 'red', None])
|
>>> idx
|
Index(['black', '', 'red', None], dtype='object')
|
>>> idx.notna()
|
array([ True, True, True, False])
|
)re rÔ r¤ r¤ r¥ Únotna×
|
s +z Index.notnac C sR | |¡}| jrJ| | j|¡}|dkr6tj|| jdS tt| j d|
|
¡ S )a
|
Fill NA/NaN values with the specified value.
|
|
Parameters
|
----------
|
value : scalar
|
Scalar value to use to fill holes (e.g. 0).
|
This value cannot be a list-likes.
|
downcast : dict, default is None
|
A dict of item->dtype of what to downcast if possible,
|
or the string 'infer' which will try to downcast to an appropriate
|
equal type (e.g. float64 to int64 if possible).
|
|
Returns
|
-------
|
Index
|
|
See Also
|
--------
|
DataFrame.fillna : Fill NaN values of a DataFrame.
|
Series.fillna : Fill NaN Values of a Series.
|
Nr zF.fillna does not support 'downcast' argument values other than 'None'.) Ú_require_scalarr rß r r r$ rÏ r r rg r: )r r¸ Zdowncastr r¤ r¤ r¥ Úfillna s
|
ÿz Index.fillnar[ r )r r r c C sF |dkrt d| | jr>| j| j }t| j|| jdS | ¡ S )a
|
Return Index without NA/NaN values.
|
|
Parameters
|
----------
|
how : {'any', 'all'}, default 'any'
|
If the Index is a MultiIndex, drop the value when any or all levels
|
are NaN.
|
|
Returns
|
-------
|
Index
|
)r[ r zinvalid how option: r )r r rú r r r rÏ r: )r r rv r¤ r¤ r¥ Údropna, s z Index.dropna)r r r c s4 |dk r| |¡ | jr | ¡ S t ¡ }| |¡S )a6
|
Return unique values in the index.
|
|
Unique values are returned in order of appearance, this does NOT sort.
|
|
Parameters
|
----------
|
level : int or hashable, optional
|
Only return values from specified level (for MultiIndex).
|
If int, gets the level by integer position, else by level name.
|
|
Returns
|
-------
|
Index
|
|
See Also
|
--------
|
unique : Numpy array of unique values in that column.
|
Series.unique : Return unique values of Series object.
|
N)rÐ r( r: Úsuperr r8 )r r r ©Ú __class__r¤ r¥ r E s
|
|
z Index.uniquer. r/ r# )r r0 r c s | j r| ¡ S t j|dS )a
|
Return Index with duplicate values removed.
|
|
Parameters
|
----------
|
keep : {'first', 'last', ``False``}, default 'first'
|
- 'first' : Drop duplicates except for the first occurrence.
|
- 'last' : Drop duplicates except for the last occurrence.
|
- ``False`` : Drop all duplicates.
|
|
Returns
|
-------
|
Index
|
|
See Also
|
--------
|
Series.drop_duplicates : Equivalent method on Series.
|
DataFrame.drop_duplicates : Equivalent method on DataFrame.
|
Index.duplicated : Related method on Index, indicating duplicate
|
Index values.
|
|
Examples
|
--------
|
Generate an pandas.Index with duplicate values.
|
|
>>> idx = pd.Index(['lama', 'cow', 'lama', 'beetle', 'lama', 'hippo'])
|
|
The `keep` parameter controls which duplicate values are removed.
|
The value 'first' keeps the first occurrence for each
|
set of duplicated entries. The default value of keep is 'first'.
|
|
>>> idx.drop_duplicates(keep='first')
|
Index(['lama', 'cow', 'beetle', 'hippo'], dtype='object')
|
|
The value 'last' keeps the last occurrence for each set of duplicated
|
entries.
|
|
>>> idx.drop_duplicates(keep='last')
|
Index(['cow', 'beetle', 'lama', 'hippo'], dtype='object')
|
|
The value ``False`` discards all sets of duplicated entries.
|
|
>>> idx.drop_duplicates(keep=False)
|
Index(['cow', 'beetle', 'hippo'], dtype='object')
|
r/ )r( r: r Údrop_duplicates©r r0 r r¤ r¥ r c s .zIndex.drop_duplicates)r0 r c C s$ | j rtjt| tdS | j|dS )a
|
Indicate duplicate index values.
|
|
Duplicated values are indicated as ``True`` values in the resulting
|
array. Either all duplicates, all except the first, or all except the
|
last occurrence of duplicates can be indicated.
|
|
Parameters
|
----------
|
keep : {'first', 'last', False}, default 'first'
|
The value or values in a set of duplicates to mark as missing.
|
|
- 'first' : Mark duplicates as ``True`` except for the first
|
occurrence.
|
- 'last' : Mark duplicates as ``True`` except for the last
|
occurrence.
|
- ``False`` : Mark all duplicates as ``True``.
|
|
Returns
|
-------
|
np.ndarray[bool]
|
|
See Also
|
--------
|
Series.duplicated : Equivalent method on pandas.Series.
|
DataFrame.duplicated : Equivalent method on pandas.DataFrame.
|
Index.drop_duplicates : Remove duplicate values from Index.
|
|
Examples
|
--------
|
By default, for each set of duplicated values, the first occurrence is
|
set to False and all others to True:
|
|
>>> idx = pd.Index(['lama', 'cow', 'lama', 'beetle', 'lama'])
|
>>> idx.duplicated()
|
array([False, False, True, False, True])
|
|
which is equivalent to
|
|
>>> idx.duplicated(keep='first')
|
array([False, False, True, False, True])
|
|
By using 'last', the last occurrence of each set of duplicated values
|
is set on False and all others on True:
|
|
>>> idx.duplicated(keep='last')
|
array([ True, False, True, False, False])
|
|
By setting keep on ``False``, all duplicates are True:
|
|
>>> idx.duplicated(keep=False)
|
array([ True, False, True, False, True])
|
rç r/ )r( r¼ Úzerosr r Z _duplicatedr r¤ r¤ r¥ r s 6zIndex.duplicatedc C s | | S rº r¤ r< r¤ r¤ r¥ Ú__iadd__Ô s zIndex.__iadd__r c C s t dt| j dd S )NzThe truth value of a zC is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().)r r rg rÔ r¤ r¤ r¥ Ú __nonzero__Ø s ÿzIndex.__nonzero__c C s" t | |}| j|k r | |¡S | S )z¡
|
If the result of a set operation will be self,
|
return self, unless the name changes, in which
|
case make a shallow copy of self.
|
)rx rÏ rÌ )r r rÏ r¤ r¤ r¥ Ú_get_reconciled_name_objectä s
|
|
|
z!Index._get_reconciled_name_objectc C s |dkrt d| dd S )N)NFTzBThe 'sort' keyword only takes the values of None, True, or False; z was passed.©r )r r r¤ r¤ r¥ Ú_validate_sort_keywordï s
|
ÿz Index._validate_sort_keywordztuple[Index, Index])r Úsetopr c C sL t | trDt |trD| jdk rD|jdk rD| d¡}| d¡}||fS | |fS )z>
|
With mismatched timezones, cast both to UTC.
|
NÚUTC)rê r] ÚtzÚ
|
tz_convert)r r r r Úrightr¤ r¤ r¥ Ú_dti_setop_align_tzs÷ s ÿþýü
|
|
zIndex._dti_setop_align_tzsc C s | |¡ | |¡ | |¡\}}t| j|jst| trZtt|sZt |dkrZt
|
d| |d¡\} }| |¡}| j |dd}|j |dd}|j||dS t |r°| |¡rÎ| |¡}|dkrÊ| ¡ S |S t | sô| | ¡}|dkrð| ¡ S |S | j||d}| ||¡S )aË
|
Form the union of two Index objects.
|
|
If the Index objects are incompatible, both Index objects will be
|
cast to dtype('object') first.
|
|
Parameters
|
----------
|
other : Index or array-like
|
sort : bool or None, default None
|
Whether to sort the resulting Index.
|
|
* None : Sort the result, except when
|
|
1. `self` and `other` are equal.
|
2. `self` or `other` has length 0.
|
3. Some values in `self` or `other` cannot be compared.
|
A RuntimeWarning is issued in this case.
|
|
* False : do not sort the result.
|
* True : Sort the result (which may raise TypeError).
|
|
Returns
|
-------
|
Index
|
|
Examples
|
--------
|
Union matching dtypes
|
|
>>> idx1 = pd.Index([1, 2, 3, 4])
|
>>> idx2 = pd.Index([3, 4, 5, 6])
|
>>> idx1.union(idx2)
|
Index([1, 2, 3, 4, 5, 6], dtype='int64')
|
|
Union mismatched dtypes
|
|
>>> idx1 = pd.Index(['a', 'b', 'c', 'd'])
|
>>> idx2 = pd.Index([1, 2, 3, 4])
|
>>> idx1.union(idx2)
|
Index(['a', 'b', 'c', 'd', 1, 2, 3, 4], dtype='object')
|
|
MultiIndex case
|
|
>>> idx1 = pd.MultiIndex.from_arrays(
|
... [[1, 1, 2, 2], ["Red", "Blue", "Red", "Blue"]]
|
... )
|
>>> idx1
|
MultiIndex([(1, 'Red'),
|
(1, 'Blue'),
|
(2, 'Red'),
|
(2, 'Blue')],
|
)
|
>>> idx2 = pd.MultiIndex.from_arrays(
|
... [[3, 3, 2, 2], ["Red", "Green", "Red", "Green"]]
|
... )
|
>>> idx2
|
MultiIndex([(3, 'Red'),
|
(3, 'Green'),
|
(2, 'Red'),
|
(2, 'Green')],
|
)
|
>>> idx1.union(idx2)
|
MultiIndex([(1, 'Blue'),
|
(1, 'Red'),
|
(2, 'Blue'),
|
(2, 'Green'),
|
(2, 'Red'),
|
(3, 'Green'),
|
(3, 'Red')],
|
)
|
>>> idx1.union(idx2, sort=False)
|
MultiIndex([(1, 'Red'),
|
(1, 'Blue'),
|
(2, 'Red'),
|
(2, 'Blue'),
|
(3, 'Red'),
|
(3, 'Green'),
|
(2, 'Green')],
|
)
|
r zjCan only union MultiIndex with MultiIndex or Index of tuples, try mi.to_flat_index().union(other) instead.ÚunionFrß ©r T)r Ú_assert_can_do_setopÚ_convert_can_do_setoprC r® rê r^ rO Ú_unpack_nested_dtyper r r Ú_find_common_type_compatrù r Úequalsr rÕ Ú_unionÚ_wrap_setop_result)r r r Ú result_namer® r r r r¤ r¤ r¥ r
|
s< S
|
|
ÿ
|
þ
|
ýÿ
|
|
|
z Index.union)r c sH | j }|j }|dkr| jr|jr| jr,|js| jrz| |¡d W S ttfk
|
r t|}t| | fdd|D ¡ t
|
j |t d Y S X n |j s°t | |¡}t||S | jrÒ| |¡}|dk ¡ d }nt | |¡d ¡}| jr | | |¡¡} n*t|dkr&| |¡}
|
t||
|
f} n|} | jr:|jsDt| |} | S )a
|
Specific union logic should go here. In subclasses, union behavior
|
should be overwritten here rather than in `self.union`.
|
|
Parameters
|
----------
|
other : Index or array-like
|
sort : False or None, default False
|
Whether to sort the resulting index.
|
|
* False : do not sort the result.
|
* None : sort the result, except when `self` and `other` are equal
|
or when the values cannot be compared.
|
|
Returns
|
-------
|
Index
|
Nr c s g | ]}| kr|qS r¤ r¤ rV ©Z value_setr¤ r¥ rX ¬ s z Index._union.<locals>.<listcomp>rç rs r¸ )rú rã rè Ú_can_use_libjoinrÇ ro r r ÚsetÚextendr¼ r r r( r Zunion_with_duplicatesÚ_maybe_try_sortÚ_index_as_uniqueÚ get_indexerÚnonzeroÚunique1dÚget_indexer_non_uniquer r rj r rV ) r r r ZlvalsZrvalsZ
|
value_listZ result_dupsÚindexerÚmissingr Z
|
other_diffr¤ r& r¥ r# sJ ÿþýüüû
|
|
|
|
|
z Index._union©r r c C s< t | |}t|tr*|j|kr8| |¡}n| j||d}|S ©Nr )rx rê r rÏ rÌ r8 )r r r rÏ r¤ r¤ r¥ r$ Ñ s
|
|
|
zIndex._wrap_setop_resultr c C s | |¡ | |¡ | |¡\}}t| j|js@| |d¡\} }| |¡r~| jr`| ¡ |¡}n
|
| |¡}|dkrz|
|
¡ }|S t | dkst |dkr
|
| j s¤|j r¶| dd
|¡S | |¡}t| j|rüt | dkrê| dd
|¡S |dd
|¡S tg ||dS | |¡s@t| tr4| dd
|¡S tg |dS t| j|js| |¡}| j|dd}|j|dd}|j||d S | j||d }| ||¡S )
|
a
|
Form the intersection of two Index objects.
|
|
This returns a new Index with elements common to the index and `other`.
|
|
Parameters
|
----------
|
other : Index or array-like
|
sort : True, False or None, default False
|
Whether to sort the resulting index.
|
|
* None : sort the result, except when `self` and `other` are equal
|
or when the values cannot be compared.
|
* False : do not sort the result.
|
* True : Sort the result (which may raise TypeError).
|
|
Returns
|
-------
|
Index
|
|
Examples
|
--------
|
>>> idx1 = pd.Index([1, 2, 3, 4])
|
>>> idx2 = pd.Index([3, 4, 5, 6])
|
>>> idx1.intersection(idx2)
|
Index([3, 4], dtype='int64')
|
Ú intersectionTr N)r® rÏ r Frß r )r r r rC r® r r" rè r r rÕ r r rÌ r! r Ú_should_comparerê r^ rù r4 Ú _intersectionÚ_wrap_intersection_result)r r r r% r r® Úthisr¤ r¤ r¥ r4 Û s@
|
|
|
|
|
|
zIndex.intersection)r r c C s | j rt|j rt| jrtt| tstz| |¡\}}}W n tk
|
rD Y n0X t| rZt |¡}n| |¡}|
|
¡ }t |S | j ||d}t ||}|S )zL
|
intersection specialized to the case with matching dtypes.
|
r )rã r' rê r^ rÆ ro rN r r. rj r rr Ú _intersection_via_get_indexerr* ) r r r Z res_indexerr0 Ú_Úresr rv r¤ r¤ r¥ r6 / s( ÿþýü
|
|
zIndex._intersectionc C s | ||¡S rº ©r$ ©r r r r¤ r¤ r¥ r7 M s z Index._wrap_intersection_resultzIndex | MultiIndexzArrayLike | MultiIndexc C sl | ¡ }| ¡ }| |¡}|dk}| | ¡ d ¡}|dkrFt |¡}t|tr\| |¡}n | |¡j}|S )z¾
|
Find the intersection of two Indexes using get_indexer.
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray
|
The returned array will be unique.
|
rs r F) r Úget_indexer_forrj r- r¼ r rê r^ rú ) r r r Z left_uniqueZ right_uniquer0 r© Útakerr r¤ r¤ r¥ r9 Q s
|
|
|
z#Index._intersection_via_get_indexerc C sª | |¡ | |¡ | |¡\}}| |¡r>| dd
|¡S t|dkrh| |¡}|dkrd| ¡ S |S | |¡s| |¡}|dkr| ¡ S |S | j||d}| ||¡S )aç
|
Return a new Index with elements of index not in `other`.
|
|
This is the set difference of two Index objects.
|
|
Parameters
|
----------
|
other : Index or array-like
|
sort : bool or None, default None
|
Whether to sort the resulting index. By default, the
|
values are attempted to be sorted, but any TypeError from
|
incomparable elements is caught by pandas.
|
|
* None : Attempt to sort the result, but catch any TypeErrors
|
from comparing incomparable elements.
|
* False : Do not sort the result.
|
* True : Sort the result (which may raise TypeError).
|
|
Returns
|
-------
|
Index
|
|
Examples
|
--------
|
>>> idx1 = pd.Index([2, 1, 3, 4])
|
>>> idx2 = pd.Index([3, 4, 5, 6])
|
>>> idx1.difference(idx2)
|
Index([1, 2], dtype='int64')
|
>>> idx1.difference(idx2, sort=False)
|
Index([2, 1], dtype='int64')
|
Nr Tr )
|
r r r r" rÌ r rÕ r5 Ú _differenceÚ_wrap_difference_result)r r r r% r r¤ r¤ r¥ Ú
|
differenceq s" !
|
|
|
|
|
|
zIndex.differencec C sp | ¡ }| |¡}| |dk ¡ d ¡}tjt |j¡|dd}t|t rV| |¡}n |j
|
|¡}t ||}|S )Nrs r T©Z assume_unique) r r> rj r- r¼ Ú setdiff1dr2 Úsizerê r^ rú r* )r r r r8 r0 Z
|
label_diffZthe_diffr¤ r¤ r¥ r@ ¯ s
|
|
|
zIndex._differencec C s | ||¡S rº r< r= r¤ r¤ r¥ rA Â s z Index._wrap_difference_resultc C s~ | |¡ | |¡ | |¡\}}|dkr.|}t| j|jsL| |d¡\} }| |¡sj| j||d |¡S t| j|js²| |¡}| j
|
|dd}|j
|
|dd}|j ||d |¡S | ¡ }| ¡ }| |¡}| |dk ¡ d ¡} tjt |j¡| dd }
|
| |
|
¡} |dk ¡ d } | | ¡} | | ¡}t||}| jsJt|||jd
|
S td | } t|dkrp| ¡ |¡S | |¡S dS ) a
|
Compute the symmetric difference of two Index objects.
|
|
Parameters
|
----------
|
other : Index or array-like
|
result_name : str
|
sort : bool or None, default None
|
Whether to sort the resulting index. By default, the
|
values are attempted to be sorted, but any TypeError from
|
incomparable elements is caught by pandas.
|
|
* None : Attempt to sort the result, but catch any TypeErrors
|
from comparing incomparable elements.
|
* False : Do not sort the result.
|
* True : Sort the result (which may raise TypeError).
|
|
Returns
|
-------
|
Index
|
|
Notes
|
-----
|
``symmetric_difference`` contains elements that appear in either
|
``idx1`` or ``idx2`` but not both. Equivalent to the Index created by
|
``idx1.difference(idx2) | idx2.difference(idx1)`` with duplicates
|
dropped.
|
|
Examples
|
--------
|
>>> idx1 = pd.Index([1, 2, 3, 4])
|
>>> idx2 = pd.Index([2, 3, 4, 5])
|
>>> idx1.symmetric_difference(idx2)
|
Index([1, 5], dtype='int64')
|
NÚsymmetric_differencer Frß rs r TrC ©rÏ r® r ) r r r rC r® r r5 r rÌ r! rù rF r r> rj r- r¼ rD r2 rE r r* r r r r Úremove_unused_levelsrÈ )r r r% r Zresult_name_updater® r8 Úthatr0 Zcommon_indexerÚ left_indexerZ left_diffÚ right_indexerZ
|
right_diffrv r r¤ r¤ r¥ rF Æ sD $
|
|
|
|
|
|
ÿ
|
|
|
|
|
zIndex.symmetric_differencec C s t |stddS )Nz!Input must be Index or array-likeT)rM ro r< r¤ r¤ r¥ r s zIndex._assert_can_do_setopztuple[Index, Hashable]c C s2 t |ts t|| jd}| j}n
|
t| |}||fS r3 )rê r rÏ rx )r r r% r¤ r¤ r¥ r s
|
|
|
zIndex._convert_can_do_setopc
|
C sh | |¡}z| j |¡W S tk
|
rD } zt||W 5 d}~X Y n tk
|
rb | |¡ Y nX dS )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
|
--------
|
>>> unique_index = pd.Index(list('abc'))
|
>>> unique_index.get_loc('b')
|
1
|
|
>>> monotonic_index = pd.Index(list('abbc'))
|
>>> monotonic_index.get_loc('b')
|
slice(1, 3, None)
|
|
>>> non_monotonic_index = pd.Index(list('abcb'))
|
>>> non_monotonic_index.get_loc('b')
|
array([False, True, False, True])
|
N)Ú_maybe_cast_indexerr> Úget_locrB ro Ú_check_indexing_error)r ÚkeyZ
|
casted_keyr r¤ r¤ r¥ rM ( s
|
|
z Index.get_locaM
|
Compute indexer and mask for new index given the current index.
|
|
The indexer should be then used as an input to ndarray.take to align the
|
current data to the new index.
|
|
Parameters
|
----------
|
target : %(target_klass)s
|
method : {None, 'pad'/'ffill', 'backfill'/'bfill', 'nearest'}, optional
|
* default: exact matches only.
|
* pad / ffill: find the PREVIOUS index value if no exact match.
|
* backfill / bfill: use NEXT index value if no exact match
|
* nearest: use the NEAREST index value if no exact match. Tied
|
distances are broken by preferring the larger index value.
|
limit : int, optional
|
Maximum number of consecutive labels in ``target`` to match for
|
inexact matches.
|
tolerance : optional
|
Maximum distance between original and new labels for inexact
|
matches. The values of the index at the matching locations must
|
satisfy the equation ``abs(index[indexer] - target) <= tolerance``.
|
|
Tolerance may be a scalar value, which applies the same tolerance
|
to all values, or list-like, which applies variable tolerance per
|
element. List-like includes list, tuple, array, Series, and must be
|
the same size as the index and its dtype must exactly match the
|
index's type.
|
|
Returns
|
-------
|
np.ndarray[np.intp]
|
Integers from 0 to n - 1 indicating that the index at these
|
positions matches the corresponding target values. Missing values
|
in the target are marked by -1.
|
%(raises_section)s
|
Notes
|
-----
|
Returns -1 for unmatched values, for further explanation see the
|
example below.
|
|
Examples
|
--------
|
>>> index = pd.Index(['c', 'a', 'b'])
|
>>> index.get_indexer(['a', 'b', 'x'])
|
array([ 1, 2, -1])
|
|
Notice that the return value is an array of locations in ``index``
|
and ``x`` is marked by -1, as it is not in ``index``.
|
r, z str_t | Nonez
|
int | None)rS Úlimitr c C s t |}|}| |¡}| |||¡ | js4t| jt|dkrPtjg tj dS |
|
|¡st| |¡st| j ||ddS t | jràt| j|jst| j |j¡}| jrÜ|jrÜt|}| tj¡}| ¡ } |||< d|| | @ < |S t |jrF| |j¡}
|
tj|
|
|jdd}| js>| jr>|jr>| tj¡}| ¡ } ||| < t |S | |¡\} } | | k sh| |k rz| j| |||dS t| j|jrª| |¡rªtj t|tj dS t| j|jsþ| |¡sþ| |¡} | j!| dd }|j!| dd }|j"||||dS | "||||¡S )
|
Nr rç T©rS r rs )rm ©rS rP Ú toleranceFrß )#rw Ú _maybe_cast_listlike_indexerÚ_check_indexing_methodr+ r. Ú_requires_unique_msgr r¼ r Úintpr5 Ú_should_partial_indexÚ_get_indexer_non_comparablerB r® rC r r> r, r¬ r re rM rà r r Ztake_ndr r? Ú_maybe_promoter" r2 r! rù Ú _get_indexer)r ÚtargetrS rP rS Z orig_targetr0 Z target_nansÚlocr© Zcategories_indexerÚpselfÚptargetr® r8 r¤ r¤ r¥ r, sl
|
|
|
ÿ ÿþ
|
ÿzIndex.get_indexer)r\ rS rP r c C s |d k r| ||¡}|dkr.| ||||¡}nJ|dkrF| |||¡}n2|jrd| jrd| j}| |¡}n| ¡ }| j |¡}t|S )N©ÚpadÚbackfillÚnearest) Ú_convert_toleranceÚ_get_fill_indexerÚ_get_nearest_indexerr r> Ú_extract_level_codesr@ r, r? )r r\ rS rP rS r0 ÚengineÚ
|
tgt_valuesr¤ r¤ r¥ r[ Û s ÿ zIndex._get_indexer)r\ r c C s t | jr t |jrdS dS dS )z>
|
Should we attempt partial-matching indexing?
|
FT)rK r® ©r r\ r¤ r¤ r¥ rX ø s
|
|
|
zIndex._should_partial_indexc C s |dkrt d| jr>|dkr&td|dkr>|dk r>tdt| jsRt| jrt|dk rttd| d t| j |dkr|dk rt d
|
|dk rt d dS ) zY
|
Raise if we have a get_indexer `method` that is not supported or valid.
|
)NZbfillrb ra Zffillrc zInvalid fill methodrc zJmethod='nearest' not implemented yet for MultiIndex; see GitHub issue 9365r` Nz,tolerance not implemented yet for MultiIndexzmethod z not yet implemented for zJtolerance argument only valid if doing pad, backfill or nearest reindexingzFlimit argument only valid if doing pad, backfill or nearest reindexing)r r r rK r® rB r rg )r rS rP rS r¤ r¤ r¥ rU s4
|
ÿÿÿÿÿz Index._check_indexing_methodznp.ndarray | Indexc C s t |¡}|j|jkr*|jdkr*tdnft| rt |jt j¡s|jdkrjtdt | j
|
d| j dtdt | j
|
d| j dt | |S )Nr¸ z5list-like tolerance size must match target index sizer ztolerance argument for z with dtype z1 must contain numeric elements if it is list typez$ must be numeric if it is a scalar: ) r¼ r rE r rN Z
|
issubdtyper® Únumberr r rg Úrepr)r rS r\ r¤ r¤ r¥ rd 6 s
|
|
|
ÿ ÿzIndex._convert_tolerancec
|
C sà | j rL| j}t ¡ 2 tjdtd |j|j| j||dW 5 Q R £ S Q R X | jr°|jr°| ¡ }| ¡ }t
|
|t j rt
|
|t j st |dkrtj|||d}q¾tj|||d}n| |||¡}|d k rÜt| rÜ| |||¡}|S )NÚignore)Úcategory)r\ r rS rP ra ©rP )r r> rì Úcatch_warningsÚfilterwarningsÚRuntimeWarningZget_indexer_with_fillrú rã r@ rê r¼ r½ r Úlibalgosra rb Ú _get_fill_indexer_searchsortedr Ú_filter_indexer_tolerance) r r\ rS rP rS rh rH Ú
|
own_valuesr0 r¤ r¤ r¥ re H s2
|
ü ÿzIndex._get_fill_indexerc C s |dk r t dt| d|dkr(dnd}| |¡}|dk}| || |¡||< |dkrl|| d8 < nd||t| k< |S ) z
|
Fallback pad/backfill get_indexer that works for monotonic decreasing
|
indexes and non-monotonic targets.
|
Nzlimit argument for z; method only well-defined if index and target are monotonicra r r rs r¸ )r rl r, Ú_searchsorted_monotonicr )r r\ rS rP Úsider0 Znonexactr¤ r¤ r¥ rt n s ÿ
|
z$Index._get_fill_indexer_searchsorted)r\ rP r c
|
C s t | s| |d¡S | j|d|d}| j|d|d}| ||¡}| ||¡}| jrXtjntj}t ||||dkB ||¡} |dk r|
|
|| |¡} | S )z³
|
Get the indexer for the nearest index labels; requires an index with
|
values that can be subtracted from each other (e.g., not strings or
|
tuples).
|
ra ro rb rs N) r re r, Ú_difference_compatrã ÚoperatorÚltÚler¼ Úwhereru )
|
r r\ rP rS rJ rK Zleft_distancesZright_distancesÚopr0 r¤ r¤ r¥ rf s" ÿù zIndex._get_nearest_indexer)r\ r0 r c C s | ||¡}t ||k|d¡S )Nrs )ry r¼ r} )r r\ r0 rS Zdistancer¤ r¤ r¥ ru ° s z Index._filter_indexer_tolerancec C sN t | jtr6td| jj}td|jj}|| | }n| j| |j }t|S )Nr )rê r® r[ r rÊ rG rú Úabs)r r\ r0 rv rH Zdiffr¤ r¤ r¥ ry » s zIndex._difference_compatÚslice)rO r c C s4 | d|jd¡ | d|jd¡ | d|jd¡ dS )zz
|
For positional indexing, a slice must have either int or None
|
for each of start, stop, and step.
|
Ú
|
positionalÚilocN)Ú_validate_indexerrÞ ÚstopÚstep©r rO r¤ r¤ r¥ Ú_validate_positional_sliceÐ s z Index._validate_positional_slice)rO rû c C sZ |dkst ||j|j|j }}}t| jtjrLt| jrL| |||¡S dd }||oj||oj||}| j pzt
|
| j}|o|} |dkrÎt | js|rÎ| d|jd¡ | d|jd¡ | d|jd¡ |S | rz,|dk rè| |¡ |dk rú| |¡ d} W n tk
|
r Y nX t |¡r*|}
|
n,| rH|dkrBtd |}
|
n| |||¡}
|
|
|
S )
|
a(
|
Convert a slice indexer.
|
|
By definition, these are labels unless 'iloc' is passed in.
|
Floats are not allowed as the start, step, or stop of the slice.
|
|
Parameters
|
----------
|
key : label of the slice bound
|
kind : {'loc', 'getitem'}
|
)r] Úgetitemc S s | d kpt | S rº )rI )r r¤ r¤ r¥ Úis_intó s z,Index._convert_slice_indexer.<locals>.is_intr r NFr] zjSlicing a positional slice with .loc is not allowed, Use .loc with labels or .iloc with positions instead.)r rÞ r r
rê r® r¼ rG Ú slice_indexerÚ _should_fallback_to_positionalrK rJ r rM rB rü Z is_null_slicero ) r rO rû rÞ r r
r Zis_index_sliceZints_are_positionalZ is_positionalr0 r¤ r¤ r¥ Ú_convert_slice_indexerÚ sF ÿ
|
|
|
ÿz Index._convert_slice_indexerz lib.NoDefault | None | Exception)ÚformÚreraiser c C sH d| dt | j d| dt |j }|tjk r<t||t|dS )z;
|
Raise consistent invalid indexer message.
|
z
|
cannot do z indexing on z with these indexers [z
|
] of type N)r rg r r ro )r r rO r r* r¤ r¤ r¥ Ú_raise_invalid_indexer' s
|
&ÿ
|
|
z Index._raise_invalid_indexer)r0 r c C s | j st|rtddS )zé
|
Check if we are allowing reindexing with this particular indexer.
|
|
Parameters
|
----------
|
indexer : an integer ndarray
|
|
Raises
|
------
|
ValueError if its a duplicate axis
|
ú/cannot reindex on an axis with duplicate labelsN)r+ r r )r r0 r¤ r¤ r¥ Ú_validate_can_reindex< s zIndex._validate_can_reindexz)tuple[Index, npt.NDArray[np.intp] | None]c
|
C s t |d }t|}t|tsVt|dkrV|dk rD| jrD| j| }n| }|dd
}nt|}|dk r¨t| tszt|tr¨|dk rt d| j
|
||d| j d\}}} nX| |¡r¸d}nH| j rÒ| j ||||d}n.| jrâtdn | jsòtd n| |¡\}} | |||¡}||fS )
|
aè
|
Create index with target's values.
|
|
Parameters
|
----------
|
target : an iterable
|
method : {None, 'pad'/'ffill', 'backfill'/'bfill', 'nearest'}, optional
|
* default: exact matches only.
|
* pad / ffill: find the PREVIOUS index value if no exact match.
|
* backfill / bfill: use NEXT index value if no exact match
|
* nearest: use the NEAREST index value if no exact match. Tied
|
distances are broken by preferring the larger index value.
|
level : int, optional
|
Level of multiindex.
|
limit : int, optional
|
Maximum number of consecutive labels in ``target`` to match for
|
inexact matches.
|
tolerance : int or float, optional
|
Maximum distance between original and new labels for inexact
|
matches. The values of the index at the matching locations must
|
satisfy the equation ``abs(index[indexer] - target) <= tolerance``.
|
|
Tolerance may be a scalar value, which applies the same tolerance
|
to all values, or list-like, which applies variable tolerance per
|
element. List-like includes list, tuple, array, Series, and must be
|
the same size as the index and its dtype must exactly match the
|
index's type.
|
|
Returns
|
-------
|
new_index : pd.Index
|
Resulting index.
|
indexer : np.ndarray[np.intp] or None
|
Indices of output values in original index.
|
|
Raises
|
------
|
TypeError
|
If ``method`` passed along with ``level``.
|
ValueError
|
If non-unique multi-index
|
ValueError
|
If non-unique index and ``method`` or ``limit`` passed.
|
|
See Also
|
--------
|
Series.reindex : Conform Series to new index with optional filling logic.
|
DataFrame.reindex : Conform DataFrame to new index with optional filling logic.
|
|
Examples
|
--------
|
>>> idx = pd.Index(['car', 'bike', 'train', 'tractor'])
|
>>> idx
|
Index(['car', 'bike', 'train', 'tractor'], dtype='object')
|
>>> idx.reindex(['car', 'bike'])
|
(Index(['car', 'bike'], dtype='object'), array([0, 1]))
|
rÏ r Nz)Fill method not supported if level passedr )r Ú
|
keep_orderrR z'cannot handle a non-unique multi-index!r )r Úensure_has_lenrê r r r rÞ Ú ensure_indexr^ ro Ú _join_levelr" r+ r, r r( r/ Ú_wrap_reindex_result)
|
r r\ rS r rP rS Úpreserve_namesrÊ r0 r: r¤ r¤ r¥ ÚreindexM sJ > ÿÿ ÿ
|
ÿ
|
|
z Index.reindex)r c C s | ||¡}|S rº )Ú_maybe_preserve_names)r r\ r0 r r¤ r¤ r¥ r ¹ s zIndex._wrap_reindex_result)r\ r c C s2 |r.|j dkr.|j| jkr.|jdd}| j|_|S )Nr¸ Fr{ )r4 rÏ rÛ )r r\ r r¤ r¤ r¥ r ½ s zIndex._maybe_preserve_namesz?tuple[Index, npt.NDArray[np.intp], npt.NDArray[np.intp] | None]c C s t |}t|dkr2| dd
tjg tjddfS | |¡\}}|dk}| || ¡}d}t|rPtjt|tjd}t|}| |¡}|| } | || ¡j }
|
|| } tj
|
t|ft d}|
|
|| < ||| < t| sêtjdtjd}nf|j r"tjt|tjd}t t|
|
¡|| < d|| < n.d|| < tjt| |¡tjd}d|| < t | tslt|| jd} nt| j|| jd} | ||fS )aÓ
|
Create a new index with target's values (move/add/delete values as
|
necessary) use with non-unique Index and a possibly non-unique target.
|
|
Parameters
|
----------
|
target : an iterable
|
|
Returns
|
-------
|
new_index : pd.Index
|
Resulting index.
|
indexer : np.ndarray[np.intp]
|
Indices of output values in original index.
|
new_indexer : np.ndarray[np.intp] or None
|
|
r Nrç rs r rð )r r r¼ r rW r/ rj r2 r? r r r r( rê r^ r rÏ r r rñ ) r r\ r0 r1 ÚcheckZ
|
new_labelsÚ new_indexerr Zmissing_labelsZmissing_indexerZ
|
cur_labelsZ cur_indexerry r¤ r¤ r¥ Ú_reindex_non_uniqueà s<
|
|
|
|
|
|
zIndex._reindex_non_uniquer r( r) zFtuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None])r r r r r r c C s d S rº r¤ ©r r r r r r r¤ r¤ r¥ r¦ s
|
z
|
Index.joinr c C s d S rº r¤ r r¤ r¤ r¥ r¦ s
|
zNIndex | tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]c C s d S rº r¤ r r¤ r¤ r¥ r¦ & s
|
r c C s t |}t| tr8t|tr8| jdk|jdkA r8td| jsv|jsv| |¡\}}|| k sb||k rv|j|||d|dS |dkr¦| js|jr¦| j|jkrn| j ||dS |dk rÊ| jsº|jrÊ| j
|
|||dS t |dkr0|dkr
|
| ¡ }t t d¡t |¡} |d| fS |d kr0| ¡ }t g ¡}
|
||
|
dfS t | dkr|d
|
krp| ¡ }t t d¡t |¡}
|
||
|
dfS |d kr| ¡ }t g ¡} |d| fS | j|jk ræd d d} | ||¡}|j| ||dd\}} } | | } } || | fS t| j|js,| |¡}| j|dd}|j|dd}|j||ddS t| | jsR|jsR| j||dS | jrb|js| jr|jrt| js| j ||dS n| j||dS nX| jrö|jrö| j röt| t söt | jsöz| j ||dW S tk
|
rô Y nX | |||¡S )a@
|
Compute join_index and indexers to conform data structures to the new index.
|
|
Parameters
|
----------
|
other : Index
|
how : {'left', 'right', 'inner', 'outer'}
|
level : int or level name, default None
|
return_indexers : bool, default False
|
sort : bool, default False
|
Sort the join keys lexicographically in the result Index. If False,
|
the order of the join keys depends on the join type (how keyword).
|
|
Returns
|
-------
|
join_index, (left_indexer, right_indexer)
|
Nz0Cannot join tz-naive with tz-aware DatetimeIndexTr ©r r )r Úouterrs )r ÚinnerÚcross)r r )r r r¡ r r ©r r )r r r Frß ©r r )!r rê r] r ro r rZ r¦ rñ Ú _join_multir r r: r¼ Z broadcast_torW r Ú_join_precedencer× rC r® r! rù Ú_validate_join_methodr( Ú_join_non_uniquerã rK Ú_join_monotonicr' r^ rB Ú_join_via_get_indexer)r r r r r r r^ Zpotherr ÚrindexerÚlindexerÚflipr¡ r¢ r® r8 r¤ r¤ r¥ r¦ 2 s ÿ
|
|
|
|
|
|
|
|
|
|
|
ÿ
|
|
|
þýüûú
|
)r r r r c C s |dkr| }n8|dkr |}n*|dkr4| j |dd}n|dkrF| |¡}|rR| ¡ }|| kr`d }n
|
| |¡}||krxd }n
|
| |¡}|||fS )Nr r r Fr r )r4 r rÕ r> )r r r r r r« rª r¤ r¤ r¥ r© ¯ s"
|
|
|
zIndex._join_via_get_indexer)r r c C s¦ ddl m} ddlm} ttj| j }ttj|j }|j}|j}t |} t |}
|
| |
|
@ } | sht
|
dt | |r*t ||r*t | | |d} t |
|
| |d} t | | s¾| }| | j¡}n| | ¡}| | ¡}|j||dd\}}}| | }|| |||||\}}}||||dd }| ¡ }|||fS t| d }d}t | |rj|| } }d}d
|
d d }| ||¡}|j |¡}| j|||d } |r¢| d | d | d fS | S )Nr rï )Ú restore_dropped_levels_multijoinz+cannot join with no overlapping index names©rO Tr£ FrÝ r r r¢ r rY r¸ )r r Úpandas.core.reshape.merger r rü Znot_nonerñ r r( r rê rÙ r Zreorder_levelsrÜ r¦ rH r× r ) r r r r r Zself_names_listZother_names_listZself_names_orderZother_names_orderZ
|
self_namesZ other_namesÚoverlapZ ldrop_namesZ rdrop_namesZ self_jnlevelsZother_jnlevelsÚjoin_idxr¡ r¢ Z dropped_namesrÞ r¬ rñ Zmulti_join_idxZjlÚ
|
flip_orderr¬ r r r¤ r¤ r¥ r¤ Ò sj
|
|
ÿ ú
|
|
ÿ
|
|
|
zIndex._join_multiz8tuple[Index, npt.NDArray[np.intp], npt.NDArray[np.intp]])r r r c
|
C sj ddl m} | j|jks t|| jg|jg|dd\}}|dk}| |¡}| |¡}| ||¡} | ||fS )Nr )Úget_join_indexersT)r r rs )r¯ r³ r® r rú rj rß )
|
r r r r³ Zleft_idxZ right_idxr© r± r r r¤ r¤ r¥ r§ $ s ÿ
|
|
|
zIndex._join_non_uniquezKtuple[MultiIndex, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None])r r r r c sð ddl m} ddddd}t| |r8t||r8td| | }}t| | } | rr|| }}d d
|
d }
|
|
|
||¡}t||st| |¡}|j| } |js¢t d | j
|
||d d\} } }| dk rþ|sÒt |dkrÜd |}n ||j d|d
| }nt | } t | t | ¡}|j | }||dk }| |¡}t|j }|||< t|j}| ||< |r®tjt |tjd ttj |dk ¡ srfdd|D } nÄ|dkrt |dkrÊdn| ¡ }d| }t ||¡\ } |d d
fdd|D }nd|dk ¡ }|s6fdd|D }||d|d
fdd|D }|sr ¡ d ||||j dd}|dk r | |j | ¡}n
|
|j | }| rº| } dkrÈdnt |dkrÞdnt |}| |fS )ai
|
The join method *only* affects the level of the resulting
|
MultiIndex. Otherwise it just exactly aligns the Index data to the
|
labels of the level in the MultiIndex.
|
|
If ```keep_order == True```, the order of the data indexed by the
|
MultiIndex will not be changed; otherwise, it will tie out
|
with `other`.
|
r rï zlist[np.ndarray]r¹ )r« r c S sÀ | d j dkr tjdtjdS t| dkr:tt| d S | d dd
| d dd
k}| dd
D ] }||dd
|dd
kO }qft dg|dgf¡ ¡ d }t | d }t
|
|t|¡S )aj
|
Returns sorter for the inner most level while preserving the
|
order of higher levels.
|
|
Parameters
|
----------
|
labels : list[np.ndarray]
|
Each ndarray has signed integer dtype, not necessarily identical.
|
|
Returns
|
-------
|
np.ndarray[np.intp]
|
r rç r¸ Nrs T) rE r¼ r rW r r{ r? Zhstackr- r= r Zget_level_sorter)r« ZticÚlabZstartsr¤ r¤ r¥ Ú_get_leaf_sorterF s z+Index._join_level.<locals>._get_leaf_sorterz9Join on level between two MultiIndex objects is ambiguousr r r¢ z8Index._join_level on non-unique index is not implementedTr£ Nr¸ rs rç c s g | ] }| qS r¤ r¤ ©rì r´ ©r© r¤ r¥ rX s z%Index._join_level.<locals>.<listcomp>c s g | ] }| qS r¤ r¤ r¶ ©rJ r¤ r¥ rX ¥ s c s g | ] }| qS r¤ r¤ r¶ r· r¤ r¥ rX « s c s g | ] }| qS r¤ r¤ r¶ r¸ r¤ r¥ rX ® s FrÝ ) r r rê ro r× r rÒ rÞ r( r r¦ r r¬ r? r Zget_reverse_indexerrj r r¼ r2 rW r r½ r Úmaxrs Zgroupsort_indexerr- rñ )r r r r r r rµ r r r² r¬ Z old_levelZ new_levelZleft_lev_indexerZright_lev_indexerr Z rev_indexerZ old_codesr? Z new_lev_codesrâ rá Z max_new_levZngroupsÚcountsZmask_allrK r¤ )rJ r© r¥ r 7 s
|
|
|
|
|
ÿ ÿ
|
|
|
|
|
|
|
|
ÿü
|
|
|
ÿÿzIndex._join_levelc C s |j | j kst| |¡r4|dkr&|n| }|d d fS | jrÌ|jrÌ|dkr\| }d }| |¡}nn|dkrx|}| | ¡}d }nR|dkr¢| |¡\}}}| ||||¡}n(|dkrÊ| |¡\}}}| ||||¡}n|dkræ| |¡\}}}nR|dkr| | ¡\}}}n6|dkr | |¡\}}}n|dkr8| |¡\}}}|d k sFt|d k sTt| ||||¡}|d krrd nt |}|d krd nt |}|||fS )Nr r r r )
|
r® r r" r( rÁ rÆ Ú_wrap_joined_indexrÇ rÅ r? )r r r Z ret_indexr r¡ r¢ Z
|
join_arrayr¤ r¤ r¥ r¨ Ì sB
|
|
|
|
|
|
zIndex._join_monotonic)r rÄ r r¡ r¢ r c
|
C s |j | j kstt| trb| j|jkr,| jnd }|dk}| |¡}| |¡}| ||¡} | |¡S t| |}| j j
|
||| j dS d S )Nrs rG ) r® r rê r^ rñ rj rß rÈ rx r% r$ )
|
r rÄ r r¡ r¢ rÏ r© r± r r r¤ r¤ r¥ r» s
|
|
|
|
|
zIndex._wrap_joined_indexc C s> t | tkr2t| jtjp0t| jtp0t| jtS t | j S )zJ
|
Whether we can use the fastpaths implement in _libs.join
|
)
|
r r rê r® r¼ r rl rú rk rK rÔ r¤ r¤ r¥ r' s
|
ÿ
|
ýzIndex._can_use_libjoinc C s | j S )a
|
Return an array representing the data in the Index.
|
|
.. warning::
|
|
We recommend using :attr:`Index.array` or
|
:meth:`Index.to_numpy`, depending on whether you need
|
a reference to the underlying data or a NumPy array.
|
|
Returns
|
-------
|
array: numpy.ndarray or ExtensionArray
|
|
See Also
|
--------
|
Index.array : Reference to the underlying data.
|
Index.to_numpy : A NumPy array representing the underlying data.
|
©rÊ rÔ r¤ r¤ r¥ r ( s z Index.valuesrn c C s* | j }t|tjr&ddlm} ||}|S )Nr )Ú PandasArray)rÊ rê r¼ r½ Zpandas.core.arrays.numpy_r½ )r r r½ r¤ r¤ r¥ r > s
|
z Index.arrayc C s | j S )a
|
|
The best array representation.
|
|
This is an ndarray or ExtensionArray.
|
|
``_values`` are consistent between ``Series`` and ``Index``.
|
|
It may differ from the public '.values' method.
|
|
index | values | _values |
|
----------------- | --------------- | ------------- |
|
Index | ndarray | ndarray |
|
CategoricalIndex | Categorical | Categorical |
|
DatetimeIndex | ndarray[M8ns] | DatetimeArray |
|
DatetimeIndex[tz] | ndarray[M8ns] | DatetimeArray |
|
PeriodIndex | ndarray[object] | PeriodArray |
|
IntervalIndex | IntervalArray | IntervalArray |
|
|
See Also
|
--------
|
values : Values
|
r¼ rÔ r¤ r¤ r¥ rú H s z Index._valuesc C sl | j }t|tr|jS t| tkrht| j trht| j tsht| j tr\t | j
|
r\| j
|
j dksh| j t ¡S |S )zl
|
Get the ndarray or ExtensionArray that we can pass to the IndexEngine
|
constructor.
|
r )rú rê ro rG r r rn rl rk rN r® rû rù r )r Úvalsr¤ r¤ r¥ r@ b s"
|
|
ÿ
|
þ
|
ý
|
ûú
|
ø zIndex._get_engine_targetc C s2 t | jtr| jjS t | jtr*| j ¡ S | ¡ S )zc
|
Get the ndarray or ExtensionArray that we can pass to the join
|
functions.
|
)rê rú rl rÊ rk Úto_numpyr@ rÔ r¤ r¤ r¥ r» z s
|
|
zIndex._get_join_target)r r c C sJ t | jtr*t| j|tj|jtjdS t | jtrFt| j |¡S |S )z{
|
Cast the ndarray returned from one of the libjoin.foo_indexer functions
|
back to type(self)._data.
|
rç )
|
rê r rl r r¼ r Úshaper rk rh r9 r¤ r¤ r¥ r s
|
zIndex._from_join_targetc C s" | j |d}|| jj|d7 }|S )Nr{ )Ú _memory_usager> Úsizeof)r rw r r¤ r¤ r¥ Ú memory_usage s zIndex.memory_usagec C s. t | trtdtj|td}| | |¡S )aº
|
Replace values where the condition is False.
|
|
The replacement is taken from other.
|
|
Parameters
|
----------
|
cond : bool array-like with the same length as self
|
Condition to select the values on.
|
other : scalar, or array-like, default None
|
Replacement if the condition is False.
|
|
Returns
|
-------
|
pandas.Index
|
A copy of self with values replaced from other
|
where the condition is False.
|
|
See Also
|
--------
|
Series.where : Same method for Series.
|
DataFrame.where : Same method for DataFrame.
|
|
Examples
|
--------
|
>>> idx = pd.Index(['car', 'bike', 'train', 'tractor'])
|
>>> idx
|
Index(['car', 'bike', 'train', 'tractor'], dtype='object')
|
>>> idx.where(idx.isin(['car', 'train']), 'other')
|
Index(['car', 'other', 'train', 'other'], dtype='object')
|
z1.where is not supported for MultiIndex operationsrç )rê r^ r r¼ r r rß )r Zcondr r¤ r¤ r¥ r} s !
|
ÿz Index.wherec C s t | j dt| dd S )Nz5(...) must be called with a collection of some kind, z was passed)ro rg rl )r³ r¯ r¤ r¤ r¥ rÿ Ä s ÿz Index._raise_scalar_data_errorc
|
C sh | j }t|tj rT|jdkrTz t||W S tk
|
rP } z
|
t|W 5 d}~X Y qdX nt| j|sdt|S )a
|
Check if the value can be inserted into our array without casting,
|
and convert it to an appropriate native type if necessary.
|
|
Raises
|
------
|
TypeError
|
If the value cannot be inserted into an array of this dtype.
|
r N) r® rê r¼ rû r< r6 ro r7 rú )r r¸ r® r r¤ r¤ r¥ Ú_validate_fill_valueÎ s
|
zIndex._validate_fill_valuec C s t |s tdt|j |S )z
|
Check that this is a scalar value that we can use for setitem-like
|
operations without changing dtype.
|
z"'value' must be a scalar, passed: )rP ro r rg rº r¤ r¤ r¥ r ä s zIndex._require_scalarc C s
|
t | jS )zH
|
Return a boolean if we need a qualified .info display.
|
)rO r® rÔ r¤ r¤ r¥ Ú_is_memory_usage_qualifiedî s z Index._is_memory_usage_qualifiedr c
|
C s6 t | z || jkW S tttfk
|
r0 Y dS X dS )aô
|
Return a boolean indicating whether the provided key is in the index.
|
|
Parameters
|
----------
|
key : label
|
The key to check if it is present in the index.
|
|
Returns
|
-------
|
bool
|
Whether the key search is in the index.
|
|
Raises
|
------
|
TypeError
|
If the key is not hashable.
|
|
See Also
|
--------
|
Index.isin : Returns an ndarray of boolean dtype indicating whether the
|
list-like key is in the index.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 2, 3, 4])
|
>>> idx
|
Index([1, 2, 3, 4], dtype='int64')
|
|
>>> 2 in idx
|
True
|
>>> 6 in idx
|
False
|
FN)Úhashr> Ú OverflowErrorro r r r¤ r¤ r¥ Ú __contains__ô s
|
# zIndex.__contains__zClassVar[None]Ú__hash__c C s t dd S )Nz)Index does not support mutable operations©ro )r rO r¸ r¤ r¤ r¥ Ú __setitem__" s zIndex.__setitem__c C s¸ | j j}t|st|r*t |¡}||S t|trT||}t| j || j
|
| j dS t |¡rt t|ddr~|jtdd}ntj|td}||}|jdkr¦t| | jj || j
|
dS ) aA
|
Override numpy.ndarray's __getitem__ method to work as desired.
|
|
This function adds lists and Series as valid boolean indexers
|
(ndarrays only supports ndarray with dtype=bool).
|
|
If resulting ndim != 1, plain ndarray is returned instead of
|
corresponding `Index` subclass.
|
|
r7 r® NF)r® r rç r¸ r )rÊ Ú __getitem__rI rF rü Zcast_scalar_indexerrê r r r rÍ r÷ Zis_bool_indexerrE rö r¿ r r¼ r r ru r% )r rO r r r¤ r¤ r¥ rÌ & s&
|
|
ÿ
|
|
zIndex.__getitem__)r Úslobjr c C s" | j | }t| j|| j| jdS )zH
|
Fastpath for __getitem__ when we know we have a slice.
|
r7 )rÊ r r rÍ r÷ )r rÍ r; r¤ r¤ r¥ Ú_getitem_sliceT s
|
zIndex._getitem_slicec C s* t | js t| js t| jr&|| kS dS )a]
|
Faster check for ``name in self`` when we know `name` is a Python
|
identifier (e.g. in NDFrame.__getattr__, which hits this to support
|
. key lookup). For indexes that can't hold identifiers (everything
|
but object & categorical) we just return False.
|
|
https://github.com/pandas-dev/pandas/issues/19764
|
F)rO r® rR rB )r rÏ r¤ r¤ r¥ Ú$_can_hold_identifiers_and_holds_name[ s ÿþýz*Index._can_hold_identifiers_and_holds_namezIndex | Sequence[Index]c C sx | g}t |ttfr"|t|7 }n
|
| |¡ |D ]}t |ts0tdq0dd |D }t|dkrfdn| j}| ||¡S )zÅ
|
Append a collection of Index options together.
|
|
Parameters
|
----------
|
other : Index or list/tuple of indices
|
|
Returns
|
-------
|
Index
|
zall inputs must be Indexc S s h | ]
|
}|j qS r¤ r )rì Úobjr¤ r¤ r¥ rK s z Index.append.<locals>.<setcomp>r¸ N) rê r rë r r ro r rÏ Ú_concat)r r Ú to_concatrÐ rñ rÏ r¤ r¤ r¥ r m s
|
|
|
z Index.appendz list[Index])rÒ rÏ r c C s$ dd |D }t |}tj||dS )z5
|
Concatenate multiple Index objects.
|
c S s g | ]
|
}|j qS r¤ rU rV r¤ r¤ r¥ rX s z!Index._concat.<locals>.<listcomp>r )rV r r$ )r rÒ rÏ Zto_concat_valsr r¤ r¤ r¥ rÑ s z Index._concatc
|
C sè t | j|\}}|r | ¡ S | jtkr8t|| jr8| j}z| |¡}W nT tt t
|
fk
|
r } z0t | rj|| |¡}| |¡ ||¡ W Y ¢S d}~X Y nX | j ¡ }t|tjrÒt|| ¡ |}t |||¡ n | ||¡ | |¡S )a
|
Return a new Index of the values set with the mask.
|
|
Returns
|
-------
|
Index
|
|
See Also
|
--------
|
numpy.ndarray.putmask : Changes elements of an array
|
based on conditional and input values.
|
N)rj rú rÛ r® r rd rq rÄ r6 r ro rO r! rù rß rê r¼ r½ ri ÚsumZ_putmaskr8 )r r© r¸ ZnoopZ convertedr r® r r¤ r¤ r¥ rß s$
|
(
|
z Index.putmaskc C s¦ | |¡rdS t|ts dS t| jr:t|js:| | ¡S t|trN| | ¡S t| jtrt|t | sldS t
|
t| j }| |j ¡S t |jr| | ¡S t | j|jS )a
|
Determine if two Index object are equal.
|
|
The things that are being compared are:
|
|
* The elements inside the Index object.
|
* The order of the elements inside the Index object.
|
|
Parameters
|
----------
|
other : Any
|
The other object to compare against.
|
|
Returns
|
-------
|
bool
|
True if "other" is an Index and it has the same elements and order
|
as the calling index; False otherwise.
|
|
Examples
|
--------
|
>>> idx1 = pd.Index([1, 2, 3])
|
>>> idx1
|
Index([1, 2, 3], dtype='int64')
|
>>> idx1.equals(pd.Index([1, 2, 3]))
|
True
|
|
The elements inside are compared
|
|
>>> idx2 = pd.Index(["1", "2", "3"])
|
>>> idx2
|
Index(['1', '2', '3'], dtype='object')
|
|
>>> idx1.equals(idx2)
|
False
|
|
The order is compared
|
|
>>> ascending_idx = pd.Index([1, 2, 3])
|
>>> ascending_idx
|
Index([1, 2, 3], dtype='int64')
|
>>> descending_idx = pd.Index([3, 2, 1])
|
>>> descending_idx
|
Index([3, 2, 1], dtype='int64')
|
>>> ascending_idx.equals(descending_idx)
|
False
|
|
The dtype is *not* compared
|
|
>>> int64_idx = pd.Index([1, 2, 3], dtype='int64')
|
>>> int64_idx
|
Index([1, 2, 3], dtype='int64')
|
>>> uint64_idx = pd.Index([1, 2, 3], dtype='uint64')
|
>>> uint64_idx
|
Index([1, 2, 3], dtype='uint64')
|
>>> int64_idx.equals(uint64_idx)
|
True
|
TF)r= rê r rO r® r" r^ rú rn r r rÊ rE rc )r r Zearrr¤ r¤ r¥ r" Á s ;
|
|
|
|
|
|
|
z Index.equalsc s@ ¡o>t fddjD o>tt ko>j jkS )zô
|
Similar to equals, but checks that object attributes and types are also equal.
|
|
Returns
|
-------
|
bool
|
If two Index objects have equal elements and same type True,
|
otherwise False.
|
c 3 s& | ] }t |d t |d kV qd S rº )rö rJ ©r r r¤ r¥ rî % s ÿz"Index.identical.<locals>.<genexpr>)r" r rÑ r r® r< r¤ rÔ r¥ Ú identical s
|
þÿû
|
ùzIndex.identicalc C s | |¡ z| |¡}W n^ ttfk
|
rv | j|gdd}|jdksP|jdkrXtd| ¡ }|dkrr| j Y S Y n X t |t
|
r| t | ¡d }| | S )aB
|
Return the label from the index, or, if not present, the previous one.
|
|
Assuming that the index is sorted, return the passed index label if it
|
is in the index, or return the previous index label if the passed one
|
is not in the index.
|
|
Parameters
|
----------
|
label : object
|
The label up to which the method returns the latest index label.
|
|
Returns
|
-------
|
object
|
The passed label if it is in the index. The previous label if the
|
passed label is not in the sorted index or `NaN` if there is no
|
such label.
|
|
See Also
|
--------
|
Series.asof : Return the latest value in a Series up to the
|
passed index.
|
merge_asof : Perform an asof merge (similar to left join but it
|
matches on nearest key rather than equal key).
|
Index.get_loc : An `asof` is a thin wrapper around `get_loc`
|
with method='pad'.
|
|
Examples
|
--------
|
`Index.asof` returns the latest index label up to the passed label.
|
|
>>> idx = pd.Index(['2013-12-31', '2014-01-02', '2014-01-03'])
|
>>> idx.asof('2014-01-01')
|
'2013-12-31'
|
|
If the label is in the index, the method returns the passed label.
|
|
>>> idx.asof('2014-01-02')
|
'2014-01-02'
|
|
If all of the labels in the index are later than the passed label,
|
NaN is returned.
|
|
>>> idx.asof('1999-01-02')
|
nan
|
|
If the index is not sorted, an error is raised.
|
|
>>> idx_not_sorted = pd.Index(['2013-12-31', '2015-01-02',
|
... '2014-01-03'])
|
>>> idx_not_sorted.asof('2013-12-31')
|
Traceback (most recent call last):
|
ValueError: index must be monotonic increasing or decreasing
|
ra ©rS r¸ z!asof requires scalar valued inputrs ) rw rM rB ro r, r rE Úitemrq rê r rr r )r r1 r] r0 r¤ r¤ r¥ Úasof- s 9
|
|
z
|
Index.asof)r} r© r c C sr | j | j|j dd}t |dk|d d¡}tjt| tjd| |¡}| j | ¡ }d||dk|j |k @ < |S )a³
|
Return the locations (indices) of labels in the index.
|
|
As in the `asof` function, if the label (a particular entry in
|
`where`) is not in the index, the latest index label up to the
|
passed label is chosen and its index returned.
|
|
If all of the labels in the index are later than a label in `where`,
|
-1 is returned.
|
|
`mask` is used to ignore NA values in the index during calculation.
|
|
Parameters
|
----------
|
where : Index
|
An Index consisting of an array of timestamps.
|
mask : np.ndarray[bool]
|
Array of booleans denoting where values in the original
|
data are not NA.
|
|
Returns
|
-------
|
np.ndarray[np.intp]
|
An array of locations (indices) of the labels from the Index
|
which correspond to the return values of the `asof` function
|
for every element in `where`.
|
r ©rx r r¸ rç rs ) rú Ú searchsortedr¼ r} r2 r rW rj Úargmax)r r} r© Zlocsr Z first_valuer¤ r¤ r¥ Ú asof_locsy s !
|
ÿ zIndex.asof_locsÚlast)rÔ rÓ Ú na_positionrO c C s^ t | |}t| ts&t||||d}n| ¡ }|s@|ddd
}| |¡}|rV||fS |S dS )a
|
Return a sorted copy of the index.
|
|
Return a sorted copy of the index, and optionally return the indices
|
that sorted the index itself.
|
|
Parameters
|
----------
|
return_indexer : bool, default False
|
Should the indices that would sort the index be returned.
|
ascending : bool, default True
|
Should the index values be sorted in an ascending order.
|
na_position : {'first' or 'last'}, default 'last'
|
Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at
|
the end.
|
|
.. versionadded:: 1.2.0
|
|
key : callable, optional
|
If not None, apply the key function to the index values
|
before sorting. This is similar to the `key` argument in the
|
builtin :meth:`sorted` function, with the notable difference that
|
this `key` function should be *vectorized*. It should expect an
|
``Index`` and return an ``Index`` of the same shape.
|
|
.. versionadded:: 1.1.0
|
|
Returns
|
-------
|
sorted_index : pandas.Index
|
Sorted copy of the index.
|
indexer : numpy.ndarray, optional
|
The indices that the index itself was sorted by.
|
|
See Also
|
--------
|
Series.sort_values : Sort values of a Series.
|
DataFrame.sort_values : Sort values in a DataFrame.
|
|
Examples
|
--------
|
>>> idx = pd.Index([10, 100, 1, 1000])
|
>>> idx
|
Index([10, 100, 1, 1000], dtype='int64')
|
|
Sort values in ascending order (default behavior).
|
|
>>> idx.sort_values()
|
Index([1, 10, 100, 1000], dtype='int64')
|
|
Sort values in descending order, and also get the indices `idx` was
|
sorted by.
|
|
>>> idx.sort_values(ascending=False, return_indexer=True)
|
(Index([1000, 100, 10, 1], dtype='int64'), array([3, 1, 0, 2]))
|
)ÚitemsrÓ rÞ rO Nrs )rz rê r^ r| Úargsortrj )r rÔ rÓ rÞ rO rÊ Z_asZ sorted_indexr¤ r¤ r¥ rÕ ¦ s ?
|
|
ÿ
|
zIndex.sort_valuesc O s t ddS )z*
|
Use sort_values instead.
|
z=cannot sort an Index object in-place, use sort_values insteadNrÊ ©r r" r# r¤ r¤ r¥ r ù s z
|
Index.sort)Úperiodsc C s t dt| j dS )a
|
Shift index by desired number of time frequency increments.
|
|
This method is for shifting the values of datetime-like indexes
|
by a specified time increment a given number of times.
|
|
Parameters
|
----------
|
periods : int, default 1
|
Number of periods (or increments) to shift by,
|
can be positive or negative.
|
freq : pandas.DateOffset, pandas.Timedelta or str, optional
|
Frequency increment to shift by.
|
If None, the index is shifted by its own `freq` attribute.
|
Offset aliases are valid strings, e.g., 'D', 'W', 'M' etc.
|
|
Returns
|
-------
|
pandas.Index
|
Shifted index.
|
|
See Also
|
--------
|
Series.shift : Shift values of Series.
|
|
Notes
|
-----
|
This method is only implemented for datetime-like index classes,
|
i.e., DatetimeIndex, PeriodIndex and TimedeltaIndex.
|
|
Examples
|
--------
|
Put the first 5 month starts of 2011 into an index.
|
|
>>> month_starts = pd.date_range('1/1/2011', periods=5, freq='MS')
|
>>> month_starts
|
DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01', '2011-04-01',
|
'2011-05-01'],
|
dtype='datetime64[ns]', freq='MS')
|
|
Shift the index by 10 days.
|
|
>>> month_starts.shift(10, freq='D')
|
DatetimeIndex(['2011-01-11', '2011-02-11', '2011-03-11', '2011-04-11',
|
'2011-05-11'],
|
dtype='datetime64[ns]', freq=None)
|
|
The default value of `freq` is the `freq` attribute of the index,
|
which is 'MS' (month start) in this example.
|
|
>>> month_starts.shift(10)
|
DatetimeIndex(['2011-11-01', '2011-12-01', '2012-01-01', '2012-02-01',
|
'2012-03-01'],
|
dtype='datetime64[ns]', freq='MS')
|
z\This method is only implemented for DatetimeIndex, PeriodIndex and TimedeltaIndex; Got type N)r r rg )r râ Úfreqr¤ r¤ r¥ Úshift s 8ÿz Index.shiftc O s | j j||S )aK
|
Return the integer indices that would sort the index.
|
|
Parameters
|
----------
|
*args
|
Passed to `numpy.ndarray.argsort`.
|
**kwargs
|
Passed to `numpy.ndarray.argsort`.
|
|
Returns
|
-------
|
np.ndarray[np.intp]
|
Integer indices that would sort the index if used as
|
an indexer.
|
|
See Also
|
--------
|
numpy.argsort : Similar method for NumPy arrays.
|
Index.sort_values : Return sorted copy of Index.
|
|
Examples
|
--------
|
>>> idx = pd.Index(['b', 'a', 'd', 'c'])
|
>>> idx
|
Index(['b', 'a', 'd', 'c'], dtype='object')
|
|
>>> order = idx.argsort()
|
>>> order
|
array([1, 0, 3, 2])
|
|
>>> idx[order]
|
Index(['a', 'b', 'c', 'd'], dtype='object')
|
)rÊ rà rá r¤ r¤ r¥ rà = s %z Index.argsortc C s t |st|d S rº )rP r. r r¤ r¤ r¥ rN d s zIndex._check_indexing_errorc C s
|
| j dkS )zA
|
Should an integer key be treated as positional?
|
> r rñ rð Úcomplexrø rÔ r¤ r¤ r¥ r j s z$Index._should_fallback_to_positionala:
|
Compute indexer and mask for new index given the current index.
|
|
The indexer should be then used as an input to ndarray.take to align the
|
current data to the new index.
|
|
Parameters
|
----------
|
target : %(target_klass)s
|
|
Returns
|
-------
|
indexer : np.ndarray[np.intp]
|
Integers from 0 to n - 1 indicating that the index at these
|
positions matches the corresponding target values. Missing values
|
in the target are marked by -1.
|
missing : np.ndarray[np.intp]
|
An indexer into the target of the values not found.
|
These correspond to the -1 in the indexer array.
|
|
Examples
|
--------
|
>>> index = pd.Index(['c', 'b', 'a', 'b', 'b'])
|
>>> index.get_indexer_non_unique(['b', 'b'])
|
(array([1, 3, 4, 1, 3, 4]), array([], dtype=int64))
|
|
In the example below there are no matched values.
|
|
>>> index = pd.Index(['c', 'b', 'a', 'b', 'b'])
|
>>> index.get_indexer_non_unique(['q', 'r', 't'])
|
(array([-1, -1, -1]), array([0, 1, 2]))
|
|
For this reason, the returned ``indexer`` contains only integers equal to -1.
|
It demonstrates that there's no match between the index and the ``target``
|
values at these positions. The mask [0, 1, 2] in the return value shows that
|
the first, second, and third elements are missing.
|
|
Notice that the return value is a tuple contains two items. In the example
|
below the first item is an array of locations in ``index``. The second
|
item is a mask shows that the first and third elements are missing.
|
|
>>> index = pd.Index(['c', 'b', 'a', 'b', 'b'])
|
>>> index.get_indexer_non_unique(['f', 'b', 's'])
|
(array([-1, 1, 3, 4, -1]), array([0, 2]))
|
r/ z1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]c C sà t |}| |¡}| |¡s6| |¡s6| j|d ddS | |¡\}}|| k sT||k r^| |¡S t| j|js| |¡}| j
|
|dd}|j
|
|dd}| |¡S | ¡ }| j rÀ|j rÀ| j }| |¡}| j |¡\} }
|
t| t|
|
fS )NFrQ rß )r rT r5 rX rY rZ r/ rC r® r! rù r@ r r> rg r? ) r r\ r^ r_ r® r8 rI ri rh r0 r1 r¤ r¤ r¥ r/ ¦ s$
|
|
|
|
|
z Index.get_indexer_non_uniquec C s" | j r| |¡S | |¡\}}|S )a
|
Guaranteed return of an indexer even when non-unique.
|
|
This dispatches to get_indexer or get_indexer_non_unique
|
as appropriate.
|
|
Returns
|
-------
|
np.ndarray[np.intp]
|
List of indices.
|
|
Examples
|
--------
|
>>> idx = pd.Index([np.nan, 'var1', np.nan])
|
>>> idx.get_indexer_for([np.nan])
|
array([0, 2])
|
)r+ r, r/ )r r\ r0 r: r¤ r¤ r¥ r> Î s
|
zIndex.get_indexer_forztuple[Index, np.ndarray])Ú axis_namer c C s² |}t |tst |¡}| jr8| |¡}| |¡d }n| |¡\}}}| |||¡ | |¡}t |trr|j
|
|_
|
|j j dkrªt |t s t |t| rª|jdkrª| d¡}||fS )zR
|
Analogue to get_indexer that raises if any elements are missing.
|
r r N)rê r rü rý r+ r> r r Ú_raise_if_missingrj rÏ r® rû r r rã Z
|
_with_freq)r rO ræ Zkeyarrr0 r r¤ r¤ r¥ Ú_get_indexer_strictæ s&
|
|
|
|
|
|
ÿý
|
zIndex._get_indexer_strictc C s t |dkrdS |dk }| ¡ }|rt| jpBt| joBt| jj}|t |krr|r\t|}td| d| dtt|| ¡ d
|
¡ }t| ddS )a8
|
Check that indexer can be used to return a result.
|
|
e.g. at least one element was found,
|
unless the list of keys was actually empty.
|
|
Parameters
|
----------
|
key : list-like
|
Targeted labels (only used to show correct error message).
|
indexer: array-like of booleans
|
Indices corresponding to the key,
|
(with -1 indicating not found).
|
axis_name : str
|
|
Raises
|
------
|
KeyError
|
If at least one key was requested but none was found.
|
r Nz None of [z] are in the [ú]z not in index) r rÓ rK r® rB r r rB r r- r )r rO r0 ræ Z missing_maskZnmissingZuse_interval_msgÚ not_foundr¤ r¤ r¥ rç s"
|
|
ÿý zIndex._raise_if_missing)r\ r r c C s d S rº r¤ ©r r\ rS r r¤ r¤ r¥ rY 4 s z!Index._get_indexer_non_comparablec C s d S rº r¤ rë r¤ r¤ r¥ rY : s zHnpt.NDArray[np.intp] | tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]c C s d S rº r¤ rë r¤ r¤ r¥ rY @ s c C sf |dk r(t |}td| j d|j dtj|jtjd }|rF|S tjt|tjd}||fS dS )a
|
Called from get_indexer or get_indexer_non_unique when the target
|
is of a non-comparable dtype.
|
|
For get_indexer lookups with method=None, get_indexer is an _equality_
|
check, so non-comparable dtypes mean we will always have no matches.
|
|
For get_indexer lookups with a method, get_indexer is an _inequality_
|
check, so non-comparable dtypes mean we will always raise TypeError.
|
|
Parameters
|
----------
|
target : Index
|
method : str or None
|
unique : bool, default True
|
* True if called from get_indexer.
|
* False if called from get_indexer_non_unique.
|
|
Raises
|
------
|
TypeError
|
If doing an inequality check, i.e. method is not None.
|
NzCannot compare dtypes z and rs rç ) r ro r® r¼ ÚonesrÀ rW r2 r )r r\ rS r r Z
|
no_matchesr1 r¤ r¤ r¥ rY F s c C s | j S )z
|
Whether we should treat this as unique for the sake of
|
get_indexer vs get_indexer_non_unique.
|
|
For IntervalIndex compat.
|
rç rÔ r¤ r¤ r¥ r+ n s zIndex._index_as_uniquez8Reindexing only valid with uniquely valued Index objectsc C sb t | trLt |trL| jdk rJ|jdk rJt| j|jsJ| d¡| d¡fS nè| jdkrt |trzt|| |fW S tk
|
r | |f Y S X n¢| jdkr¶t |tr¶t|| |fS | j j
|
dkrì|j j
|
dkrì| ¡ dkrê| | | j ¡fS nH| j r4|j s4zt| |¡}W n$ ttfk
|
r2 t| j} Y nX t| j sZt|j rZ| | ¡\}} | |fS )z
|
When dealing with an object-dtype Index and a non-object Index, see
|
if we can upcast the object-dtype one to improve performance.
|
Nr ÚdateÚ timedeltará rà r )rê r] r r r r r r ra r® rû Úminrù r r ro r r rú rO rZ r< r¤ r¤ r¥ rZ z s4 ÿþ ý zIndex._maybe_promotec C sV t |dd\}}| jdks"|dkr8t| js4t|r8tS t| j|}t| |g|}|S )zk
|
Implementation of find_common_type that adjusts for Index-specific
|
special cases.
|
T)rT Úuint64)r: r® rQ rþ r9 rú r8 )r r\ Z target_dtyper: r® r¤ r¤ r¥ r! ¨ s ÿ z Index._find_common_type_compatc C sD t |rt| s t | r$t|r$dS t|}|j}| |¡pBt|S )zK
|
Check if `self == other` can ever have non-False entries.
|
F)rA r@ r r® Ú_is_comparable_dtyperO )r r r® r¤ r¤ r¥ r5 À s ÿÿzIndex._should_compare)r® r c C s, | j jdkr|jdkS t| j r(t|S dS )zF
|
Can we compare values of the given dtype to our own?
|
rã T)r® rû rN rP r¤ r¤ r¥ rñ Ò s
|
|
|
zIndex._is_comparable_dtypez PrettyDict[Hashable, np.ndarray]c s> t |tr|j}t|}| ¡ } fdd| ¡ D }t|S )a
|
|
Group the index labels by a given array of values.
|
|
Parameters
|
----------
|
values : array
|
Values used to determine the groups.
|
|
Returns
|
-------
|
dict
|
{group name -> group labels}
|
c s i | ]\}}| |¡qS r¤ )rj r rÔ r¤ r¥ Ú
|
<dictcomp>õ s z!Index.groupby.<locals>.<dictcomp>)rê r^ rú rm Z_reverse_indexerrß r~ )r r r r¤ rÔ r¥ r3 Þ s
|
z Index.groupbyc C sº ddl m} | j||d}|jrnt|d trnt| |r@| j}n | jr\| jgt|d }nd}|j ||dS d}|js~| j
|
}t j |dd| j k}|r¦t|| j
|
|d}tj||d| jd S )
|
aB
|
Map values using an input mapping or function.
|
|
Parameters
|
----------
|
mapper : function, dict, or Series
|
Mapping correspondence.
|
na_action : {None, 'ignore'}
|
If 'ignore', propagate NA values, without passing them to the
|
mapping correspondence.
|
|
Returns
|
-------
|
Union[Index, MultiIndex]
|
The output of the mapping function applied to the index.
|
If the function returns a tuple with more than one element
|
a MultiIndex will be returned.
|
r rï )Ú na_actionNrð Frû )Ú
|
same_dtyperé )r r Z _map_valuesrE rê rë rñ rÏ r r r® r rý r r; r r$ )r Zmapperró r ri rñ r® rô r¤ r¤ r¥ r ù s(
|
ÿz Index.mapc sZ t tr4 fddtjD }t |¡S fddD }t|jddS dS )zÓ
|
Apply function to all values found in index.
|
|
This includes transforming multiindex entries separately.
|
Only apply function to one level of the MultiIndex if level is specified.
|
c s6 g | ].}|ksd kr( |¡ ¡n |¡qS rº )Úget_level_valuesr ©rì rà ©Úfuncr r r¤ r¥ rX 4 s þÿÿz*Index._transform_index.<locals>.<listcomp>c s g | ] } |qS r¤ r¤ rV )rø r¤ r¥ rX < s F)rÏ rÜ N)rê r^ rø r4 r Ú from_arraysr rÏ )r rø r r rß r¤ r÷ r¥ Ú_transform_index+ s
|
üzIndex._transform_indexc C s |dk r| |¡ t | j|¡S )a
|
|
Return a boolean array where the index values are in `values`.
|
|
Compute boolean array of whether each index value is found in the
|
passed set of values. The length of the returned boolean array matches
|
the length of the index.
|
|
Parameters
|
----------
|
values : set or list-like
|
Sought values.
|
level : str or int, optional
|
Name or position of the index level to use (if the index is a
|
`MultiIndex`).
|
|
Returns
|
-------
|
np.ndarray[bool]
|
NumPy array of boolean values.
|
|
See Also
|
--------
|
Series.isin : Same for Series.
|
DataFrame.isin : Same method for DataFrames.
|
|
Notes
|
-----
|
In the case of `MultiIndex` you must either specify `values` as a
|
list-like object containing tuples that are the same length as the
|
number of levels, or specify `level`. Otherwise it will raise a
|
``ValueError``.
|
|
If `level` is specified:
|
|
- if it is the name of one *and only one* index level, use that level;
|
- otherwise it should be a number indicating level position.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1,2,3])
|
>>> idx
|
Index([1, 2, 3], dtype='int64')
|
|
Check whether each index value in a list of values.
|
|
>>> idx.isin([1, 4])
|
array([ True, False, False])
|
|
>>> midx = pd.MultiIndex.from_arrays([[1,2,3],
|
... ['red', 'blue', 'green']],
|
... names=('number', 'color'))
|
>>> midx
|
MultiIndex([(1, 'red'),
|
(2, 'blue'),
|
(3, 'green')],
|
names=['number', 'color'])
|
|
Check whether the strings in the 'color' level of the MultiIndex
|
are in a list of colors.
|
|
>>> midx.isin(['red', 'orange', 'yellow'], level='color')
|
array([ True, False, False])
|
|
To check across the levels of a MultiIndex, pass a list of tuples:
|
|
>>> midx.isin([(1, 'red'), (3, 'red')])
|
array([ True, False, False])
|
|
For a DatetimeIndex, string values in `values` are converted to
|
Timestamps.
|
|
>>> dates = ['2000-03-11', '2000-03-12', '2000-03-13']
|
>>> dti = pd.to_datetime(dates)
|
>>> dti
|
DatetimeIndex(['2000-03-11', '2000-03-12', '2000-03-13'],
|
dtype='datetime64[ns]', freq=None)
|
|
>>> dti.isin(['2000-03-11'])
|
array([ True, False, False])
|
N)rÐ r Úisinrú rà r¤ r¤ r¥ rû ? s Q
|
z
|
Index.isinr® c C s t d S rº )r r r¤ r¤ r¥ Ú_get_string_slice s zIndex._get_string_slice)rÞ Úendr
r c C s@ | j |||d\}}t|s$tdt|s4tdt|||S )aù
|
Compute the slice indexer for input labels and step.
|
|
Index needs to be ordered and unique.
|
|
Parameters
|
----------
|
start : label, default None
|
If None, defaults to the beginning.
|
end : label, default None
|
If None, defaults to the end.
|
step : int, default None
|
|
Returns
|
-------
|
slice
|
|
Raises
|
------
|
KeyError : If key does not exist, or key is not unique and index is
|
not ordered.
|
|
Notes
|
-----
|
This function assumes that the data is sorted, so use at your own peril
|
|
Examples
|
--------
|
This is a method on all index types. For example you can do:
|
|
>>> idx = pd.Index(list('abcd'))
|
>>> idx.slice_indexer(start='b', end='c')
|
slice(1, 3, None)
|
|
>>> idx = pd.MultiIndex.from_arrays([list('abcd'), list('efgh')])
|
>>> idx.slice_indexer(start='b', end=('c', 'g'))
|
slice(1, 3, None)
|
)r
z Start slice bound is non-scalarz End slice bound is non-scalar)Ú
|
slice_locsrP r r )r rÞ rý r
Ú start_sliceÚ end_slicer¤ r¤ r¥ r s ,zIndex.slice_indexerc C s |S )zx
|
If we have a float key and are not a floating index, then try to cast
|
to an int if equivalent.
|
r¤ r r¤ r¤ r¥ rL Ï s zIndex._maybe_cast_indexerc C s t |S )zT
|
Analogue to maybe_cast_indexer for get_indexer instead of get_loc.
|
)r rj r¤ r¤ r¥ rT Ö s z"Index._maybe_cast_listlike_indexer)r rû r c C s, |dks t |dk r(t|s(| ||¡ dS )zz
|
If we are positional indexer, validate that we have appropriate
|
typed bounds must be an integer.
|
)r r N)r rI r )r r rO rû r¤ r¤ r¥ r Ü s zIndex._validate_indexerrÙ c C s< t | jr| |¡S t|s$t|r8|| kr8| d|¡ |S )aÉ
|
This function should be overloaded in subclasses that allow non-trivial
|
casting on label-slice bounds, e.g. datetime-like indices allowing
|
strings containing formatted datetimes.
|
|
Parameters
|
----------
|
label : object
|
side : {'left', 'right'}
|
|
Returns
|
-------
|
label : object
|
|
Notes
|
-----
|
Value of `side` parameter should be validated in caller.
|
r )rN r® rL rF rI r )r r1 rx r¤ r¤ r¥ Ú_maybe_cast_slice_boundç s
|
|
|
z Index._maybe_cast_slice_boundzLiteral[('left', 'right')]c C sV | j r| j||dS | jrJ| d d d
j||dkr6dndd}t| | S tdd S )NrÙ rs r r z0index must be monotonic increasing or decreasing)rã rÚ rä r r )r r1 rx Úposr¤ r¤ r¥ rw s ÿ z Index._searchsorted_monotonic)rx r c C s |dkrt d| |}| ||¡}z| |¡}W nR tk
|
r } z4z| ||¡W W Y ¢ S t k
|
rt |Y nX W 5 d}~X Y nX t|tjrÖt|j s¢t
|
t | d¡¡}t|tjrÖtd| dt| t|trö|dkrî|jS |jS n|dkr|d S |S dS )
|
aY
|
Calculate slice bound that corresponds to given label.
|
|
Returns leftmost (one-past-the-rightmost if ``side=='right'``) position
|
of given label.
|
|
Parameters
|
----------
|
label : object
|
side : {'left', 'right'}
|
|
Returns
|
-------
|
int
|
Index of label.
|
)r r z@Invalid value for side kwarg, must be either 'left' or 'right': NÚu1z Cannot get z# slice bound for non-unique label: r r r¸ )r r rM rB rw rê r¼ r½ rA r® r r Zmaybe_booleans_to_slicerf rl r rÞ r )r r1 rx Zoriginal_labelZslcr r¤ r¤ r¥ Úget_slice_bound s6 ÿ ÿ
|
|
zIndex.get_slice_boundztuple[int, int]c C s |dkp|dk}|s || }}t |ttfr~t |ttfr~zt|}t|}W n ttfk
|
rf Y nX t|j|js~tdd}|dk r| |d¡}|dkr¢d}d}|dk rº| |d¡}|dkrÊt | }|s |d |d }}|dkrö|t | 8 }|dkr |t | 8 }||fS )aÈ
|
Compute slice locations for input labels.
|
|
Parameters
|
----------
|
start : label, default None
|
If None, defaults to the beginning.
|
end : label, default None
|
If None, defaults to the end.
|
step : int, defaults None
|
If None, defaults to 1.
|
|
Returns
|
-------
|
tuple[int, int]
|
|
See Also
|
--------
|
Index.get_loc : Get location for a single label.
|
|
Notes
|
-----
|
This method only works if the index is monotonic or unique.
|
|
Examples
|
--------
|
>>> idx = pd.Index(list('abcd'))
|
>>> idx.slice_locs(start='b', end='c')
|
(1, 3)
|
Nr z(Both dates must have the same UTC offsetr r r¸ rs )
|
rê rÈ r r r ro r Útzinfor r ) r rÞ rý r
ÚincZts_startZts_endrÿ r r¤ r¤ r¥ rþ S s8
|
|
zIndex.slice_locsc C s< | j }t|tjr t ||¡}n
|
| |¡}| jj|| jdS )aø
|
Make new Index with passed location(-s) deleted.
|
|
Parameters
|
----------
|
loc : int or list of int
|
Location of item(-s) which will be deleted.
|
Use a list of locations to delete more than one value at the same time.
|
|
Returns
|
-------
|
Index
|
Will be same type as self, except for RangeIndex.
|
|
See Also
|
--------
|
numpy.delete : Delete any rows and column from NumPy array (ndarray).
|
|
Examples
|
--------
|
>>> idx = pd.Index(['a', 'b', 'c'])
|
>>> idx.delete(1)
|
Index(['a', 'c'], dtype='object')
|
|
>>> idx = pd.Index(['a', 'b', 'c'])
|
>>> idx.delete([0, 2])
|
Index(['b'], dtype='object')
|
r )rú rê r¼ r½ Údeleter% r rÏ )r r] r rv r¤ r¤ r¥ r « s
|
|
z Index.delete)r] r c
|
C s t |¡}t|| jr&| jtkr&| j}| j}z:t|trZ| ||¡}t
|
| j || j dW S | |¡}W n6 tttfk
|
r | |¡}| |¡ ||¡ Y S X |jtks¼t|ttjtjfsØ|j
|
|¡}t |||¡}n*t ||d¡}|dkrò|n|d }|||< tj|| j dS )a
|
Make new Index inserting new item at location.
|
|
Follows Python numpy.insert semantics for negative values.
|
|
Parameters
|
----------
|
loc : int
|
item : object
|
|
Returns
|
-------
|
Index
|
r Nr r¸ )r r` rd r® r rq rú rê rn Úinsertr r rÏ rÄ ro r r6 r! rù rë r¼ Z
|
datetime64Z timedelta64r r$ )r r] r× r rv r® Zcastedri r¤ r¤ r¥ r Ó s,
|
|
|
ÿ z Index.insertÚraisez'Index | np.ndarray | Iterable[Hashable]r& )r« Úerrorsr c C sv t |ts*| jdkrdnd}tj||d}| |¡}|dk}| ¡ rl|dkrbtt|| d|| }| |¡S )añ
|
Make new Index with passed list of labels deleted.
|
|
Parameters
|
----------
|
labels : array-like or scalar
|
errors : {'ignore', 'raise'}, default 'raise'
|
If 'ignore', suppress error and existing labels are dropped.
|
|
Returns
|
-------
|
Index
|
Will be same type as self, except for RangeIndex.
|
|
Raises
|
------
|
KeyError
|
If not all of the labels are found in the selected axis
|
r Nrç rs rm z not found in axis)
|
rê r r® rü Zindex_labels_to_arrayr> r[ rB r r )r r« r
|
Z arr_dtyper0 r© r¤ r¤ r¥ Údrop s
|
|
|
z
|
Index.drop)rÛ r c C s | j rtd| jtkr(|r$| ¡ S | S | j}td|}tj|ddddd}|r`||kr`| ¡ S t || j
|
d}|s||kr| j dk r| j |_ |j |¡ |S )zÞ
|
If we have an object dtype, try to infer a non-object dtype.
|
|
Parameters
|
----------
|
copy : bool, default True
|
Whether to make a copy in cases where no inference occurs.
|
z^infer_objects is not implemented for MultiIndex. Use index.to_frame().infer_objects() instead.r¯ T)Zconvert_datetimeZconvert_timedeltaZconvert_periodZconvert_intervalr N) r r r® r rÛ rú r r r! r rÏ r÷ r )r rÛ r rv r r¤ r¤ r¥ Ú infer_objects, s, ÿ
|
|
û zIndex.infer_objectsc C s¢ | |¡r|tjtjtjhkrPtjt| td}| j rLt
|
| t sLd|| ¡ < |S |tj krtjt| td}| j rt
|
| t sd|| ¡ < |S t
|
|tjtttfr¸t| t|kr¸tdt
|
|t sÐt|dd}n
|
t |¡}t| jrt
|
|trtjdd || j|}W 5 Q R X nt
|
| jtr4|| j|}njt| jrvt
|
| t svtjdd t || j|¡}W 5 Q R X n(tjdd t | j||¡}W 5 Q R X |S )zA
|
Wrapper used to dispatch comparison operations.
|
rç FTz Lengths must match to compare)Ú extract_numpyrm ©r ) r= rz Úeqr| Úger¼ rì r r rt rê r^ re Úner r½ r r` rn r rs r rO r® Zerrstaterú rg Zcomp_method_OBJECT_ARRAYZ comparison_op)r r r~ r r r¤ r¤ r¥ Ú _cmp_methodQ s>
|
|
ÿþ
|
|
zIndex._cmp_methodc C s< t | |¡}| j}t|ddd}t |||¡}| j||dS )NT)r Z extract_ranger )rg rx rú rs Z
|
logical_opÚ_construct_result)r r r~ Zres_nameZlvaluesZrvaluesrv r¤ r¤ r¥ Ú_logical_method s
|
zIndex._logical_methodc C sJ t |tr:t|d ||d jdt|d ||d jdfS t|||jdS )Nr rG r¸ )rê rë r r® )r r rÏ r¤ r¤ r¥ r s
|
|
þzIndex._construct_resultc s2 t |tr$t|jr$t|tk r$tS t ||¡S rº )rê r rO r® r r\ r Ú _arith_method)r r r~ r r¤ r¥ r s ÿþ
|
ýzIndex._arith_methodc C s || j }t|| jdS r3 )rú r rÏ )r r~ r r¤ r¤ r¥ Ú _unary_method s
|
zIndex._unary_methodc C s | tj¡S rº )r rz r rÔ r¤ r¤ r¥ Ú__abs__¥ s z Index.__abs__c C s | tj¡S rº )r rz ÚnegrÔ r¤ r¤ r¥ Ú__neg__¨ s z Index.__neg__c C s | tj¡S rº )r rz r rÔ r¤ r¤ r¥ Ú__pos__« s z Index.__pos__c C s | tj¡S rº )r rz ÚinvrÔ r¤ r¤ r¥ Ú
|
__invert__® s zIndex.__invert__c O s" t ||¡ | d¡ t | j¡S )an
|
Return whether any element is Truthy.
|
|
Parameters
|
----------
|
*args
|
Required for compatibility with numpy.
|
**kwargs
|
Required for compatibility with numpy.
|
|
Returns
|
-------
|
bool or array-like (if axis is specified)
|
A single element array-like may be converted to bool.
|
|
See Also
|
--------
|
Index.all : Return whether all elements are True.
|
Series.all : Return whether all elements are True.
|
|
Notes
|
-----
|
Not a Number (NaN), positive infinity and negative infinity
|
evaluate to True because these are not equal to zero.
|
|
Examples
|
--------
|
>>> index = pd.Index([0, 1, 2])
|
>>> index.any()
|
True
|
|
>>> index = pd.Index([0, 0, 0])
|
>>> index.any()
|
False
|
r[ )rn Z validate_anyÚ _maybe_disable_logical_methodsr¼ r[ r rá r¤ r¤ r¥ r[ µ s $
|
z Index.anyc O s" t ||¡ | d¡ t | j¡S )a
|
Return whether all elements are Truthy.
|
|
Parameters
|
----------
|
*args
|
Required for compatibility with numpy.
|
**kwargs
|
Required for compatibility with numpy.
|
|
Returns
|
-------
|
bool or array-like (if axis is specified)
|
A single element array-like may be converted to bool.
|
|
See Also
|
--------
|
Index.any : Return whether any element in an Index is True.
|
Series.any : Return whether any element in a Series is True.
|
Series.all : Return whether all elements in a Series are True.
|
|
Notes
|
-----
|
Not a Number (NaN), positive infinity and negative infinity
|
evaluate to True because these are not equal to zero.
|
|
Examples
|
--------
|
True, because nonzero integers are considered True.
|
|
>>> pd.Index([1, 2, 3]).all()
|
True
|
|
False, because ``0`` is considered False.
|
|
>>> pd.Index([0, 1, 2]).all()
|
False
|
r )rn Z validate_allr r¼ r r rá r¤ r¤ r¥ r á s '
|
z Index.all)Úopnamer c C sB t | ts2t| js2t| js2t| js2t| jr>t|| dS )zK
|
raise if this Index subclass does not support any or all.
|
N)rê r^ rS r® rK rB rG ry )r r r¤ r¤ r¥ r s ÿþýüûz$Index._maybe_disable_logical_methods)rü r c sF t ||¡ t |¡ | js8| jr8| j}|r4| ¡ r8dS t j|dS ©Nrs rû ) rn Zvalidate_argminÚvalidate_minmax_axisr r r r r Úargmin©r rk rü r" r# r© r r¤ r¥ r! s
|
z Index.argminc sF t ||¡ t |¡ | js8| jr8| j}|r4| ¡ r8dS t j|dS r ) rn Zvalidate_argmaxr r r r r r rÛ r" r r¤ r¥ rÛ + s
|
z Index.argmaxrû c s t ||¡ t |¡ t| s$| jS t| rF| jrF| d }t|sF|S | jsj| jrj| j }|rd|
|
¡ rj| jS | jst | j t js| j jd|dS t j|dS )Nr rï ©rÏ rü rû )rn Z validate_minr r rq rã re r r r r rê rú r¼ r½ Ú_reducer rï )r rk rü r" r# r. r© r r¤ r¥ rï 7 s
|
z Index.minc s t ||¡ t |¡ t| s$| jS t| rF| jrF| d }t|sF|S | jsj| jrj| j }|rd|
|
¡ rj| jS | jst | j t js| j jd|dS t j|dS )Nrs r¹ r# rû )rn Z validate_maxr r rq rã re r r r r rê rú r¼ r½ r$ r r¹ )r rk rü r" r# rÝ r© r r¤ r¥ r¹ P s
|
z Index.maxr* c C s
|
t | fS )zE
|
Return a tuple of the shape of the underlying data.
|
)r rÔ r¤ r¤ r¥ rÀ k s z Index.shape)NNFNT)NN)N)N)rb )N)T)r TN)N)NF)N)N)FNr )N)NN)NNF)NN)F)NTN)r )NN)r[ )N)r. )N)F)F)N)NN)NNN)NNN)NN)NN)N)NNNN)r )r T)r )F)N)FTrÝ N)r¸ N).)T)T)N)N)NNN)r )NNN)r )T)NT)NT)NT)NT( rg Ú
|
__module__Ú __qualname__Ú__doc__r¥ r rÁ rÅ rÆ rÇ rÉ Ú__annotations__r¼ r½ rn rË rÌ rÍ rÎ rÑ rÒ r0 rÕ r® Zint8rØ Z
|
Int8EngineÚint16Z Int16EngineÚint32Z Int32EngineÚint64Z Int64EngineZuint8Z UInt8EngineZuint16Z UInt16EngineZuint32Z UInt32Enginerð Z UInt64Enginer] Z Float32EngineÚfloat64Z Float64EnginerC rD rE rF rÖ ÚpropertyrÚ Z!_supports_partial_string_indexingZ
|
_accessorsrh r} rÈ r÷ r² Ú classmethodr r
|
r r$ r% r, r) r r8 r: r; r= r r? r> rM rO rè r_ rZ rd rf rù r r/ r rj rp ru rÛ rz r} r r r r
r r r r£ r¡ r± rµ r¶ r· r r5 rÏ Úsetterrx rÁ r rÄ rñ r rÈ rÌ r4 rÍ rÐ rÒ rÖ r× rõ rÜ rÚ rt rã rä rå ræ r( rè rï rI rò ró rô rõ r÷ rù rú r rþ r rÿ rq r r re Zisnullr Znotnullr r
|
r r r r r Ú__bool__r r r r r# r$ r4 r6 r7 r9 rB r@ rA rF r r rM r, r[ rX rU rd re rt rf ru ry r r r r r r r r r¦ r© r© r¤ r§ r r¨ r» r' r r1 rp r rú r@ r» r rÁ rà r} rÿ rÄ r rÅ rÈ rË rÌ rÎ rÏ r rÑ rß r" rÕ rØ rÜ rÕ r rä rà rN r r/ r> rè rç rY r+ rV rZ r! r5 rñ r3 r rú rû rü r rL rT r r rw 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 / s
|
4
|
þ
|
|
|
|
|
|
|
|
|
|
|
|
ô
|
ú`7 ÿ
|
" $"
|
;þÿ û þÿ' ý#
|
üù"&@ ÿ@
|
ÿ! ÿ# ÿ ÿ ÿk6 ÿ#'3< "#++3304) 7,& (3 > yM S = Q (þÿ5 û"Y û ü - ÿ %ÿ !
|
Mü ÿlJù, ù* ù, ù.{ "Qÿ ÿ" ÿ 3 ( , .
|
,WK/ û S=' þÿ0' /ÿ ÿ ÿ ' - 2U ü 6
|
>X(7ý % %/ ,/ " "
|
|
rÓ c C sJ ddl m} t| dkr8|dk r(|d }t| d |dS |j| |dS dS )a
|
Construct an index from sequences of data.
|
|
A single sequence returns an Index. Many sequences returns a
|
MultiIndex.
|
|
Parameters
|
----------
|
sequences : sequence of sequences
|
names : sequence of str
|
|
Returns
|
-------
|
index : Index or MultiIndex
|
|
Examples
|
--------
|
>>> ensure_index_from_sequences([[1, 2, 3]], names=["name"])
|
Index([1, 2, 3], dtype='int64', name='name')
|
|
>>> ensure_index_from_sequences([["a", "a"], ["a", "b"]], names=["L1", "L2"])
|
MultiIndex([('a', 'a'),
|
('a', 'b')],
|
names=['L1', 'L2'])
|
|
See Also
|
--------
|
ensure_index
|
r rï r¸ Nr rð )r r r r rù )Ú sequencesrñ r r¤ r¤ r¥ Úensure_index_from_sequencesu s r3 Fr! r )Ú
|
index_likerÛ r c C s® t | tr|r| ¡ } | S t | tr8| j}t| ||dS t| rHt| } t | trt| tk rft| } t| rt
|
| ¡rddl m } | | ¡S t| |ddS n t| |dS dS )ak
|
Ensure that we have an index from some index-like object.
|
|
Parameters
|
----------
|
index_like : sequence
|
An Index or other sequence
|
copy : bool, default False
|
|
Returns
|
-------
|
index : Index or MultiIndex
|
|
See Also
|
--------
|
ensure_index_from_sequences
|
|
Examples
|
--------
|
>>> ensure_index(['a', 'b'])
|
Index(['a', 'b'], dtype='object')
|
|
>>> ensure_index([('a', 'a'), ('b', 'c')])
|
Index([('a', 'a'), ('b', 'c')], dtype='object')
|
|
>>> ensure_index([['a', 'a'], ['b', 'c']])
|
MultiIndex([('a', 'b'),
|
('a', 'c')],
|
)
|
)rÏ rÛ r rï F)rÛ rÜ rß N)rê r rÛ r` rÏ rL r r r r Zis_all_arrayliker r rù )r4 rÛ rÏ r r¤ r¤ r¥ r s"
|
|
|
|
r c C s2 z t | W n tk
|
r( t| Y S X | S dS )z<
|
If seq is an iterator, put its values into a list.
|
N)r ro r )Úseqr¤ r¤ r¥ r Ø s
|
r rÐ )Ústringsr c C s6 | s| S t | r2t dd | D r2dd | D } q| S )z£
|
Trims zeros and decimal points.
|
|
Examples
|
--------
|
>>> trim_front([" a", " b"])
|
['a', 'b']
|
|
>>> trim_front([" a", " "])
|
['a', '']
|
c s s | ]}|d dkV qdS )r r Nr¤ rV r¤ r¤ r¥ rî ò s z trim_front.<locals>.<genexpr>c S s g | ]}|d d
qS ©r¸ Nr¤ rV r¤ r¤ r¥ rX ó s z trim_front.<locals>.<listcomp>r )r6 r¤ r¤ r¥ r¨ ä s
|
r¨ rÈ r& )rS r c C s | dkrt d| d S )N)r r r r z do not recognize join method r rÖ r¤ r¤ r¥ r¦ ÷ s r¦ r c C s8 | dkr t |ttfr |j} t| s4t|j d| S )zR
|
If no name is passed, then extract it from data, validating hashability.
|
Nz .name must be a hashable type)rê r r` rÏ rH ro rg )rÏ rÐ r³ r¤ r¤ r¥ rõ ü s
|
rõ ztuple[Hashable, ...])Úindexesr c G s6 dd | D }dd t | D }tdd |D }|S )zñ
|
Return common name if all indices agree, otherwise None (level-by-level).
|
|
Parameters
|
----------
|
indexes : list of Index objects
|
|
Returns
|
-------
|
list
|
A list representing the unanimous 'names' found.
|
c S s g | ]}t |jqS r¤ )rë rñ rö r¤ r¤ r¥ rX s z'get_unanimous_names.<locals>.<listcomp>c S s g | ]
|
}|qS r¤ r¤ ©rì Únsr¤ r¤ r¥ rX s c s s& | ] }t |d kr| ¡ ndV qdS r7 )r r± r9 r¤ r¤ r¥ rî s z&get_unanimous_names.<locals>.<genexpr>)r rë )r8 Z name_tupsZ name_setsrñ r¤ r¤ r¥ Úget_unanimous_names s r; r2 c C s | j }t|tr|jS | S )zÜ
|
When checking if our dtype is comparable with another, we need
|
to unpack CategoricalDtype to look at its categories.dtype.
|
|
Parameters
|
----------
|
other : Index
|
|
Returns
|
-------
|
Index
|
)r® rê rW r )r r® r¤ r¤ r¥ r s
|
r c
|
C s` |dk r\zt | ¡} W nD tk
|
rZ } z&|dkr2 tj| dtt d W 5 d }~X Y nX | S )NFTz3, sort order is undefined for incomparable objects.ré )r Z safe_sortro rì rí rr r2 )r r r r¤ r¤ r¥ r* 4 s ýr* )N)F)âÚ
|
__future__r r r§ Ú itertoolsr rz Útypingr r r r r r
|
r r r r r r r rì Únumpyr¼ Zpandas._configr Z pandas._libsr r rs r rØ r Zpandas._libs.internalsr Zpandas._libs.joinZ_libsr¦ r¾ Zpandas._libs.libr r Zpandas._libs.missingr Zpandas._libs.tslibsr r r r Zpandas._typingr r r! r" r# r$ r% r& r' r( r) r* r+ Zpandas.compat.numpyr, rn Z pandas.errorsr- r. Zpandas.util._decoratorsr/ r0 r1 Zpandas.util._exceptionsr2 r3 Zpandas.core.dtypes.astyper4 r5 Zpandas.core.dtypes.castr6 r7 r8 r9 r: r; r< Zpandas.core.dtypes.commonr= r> r? r@ rA rB rC rD rE rF rG rH rI rJ rK rL rM rN rO rP rQ rR rS rT rU Zpandas.core.dtypes.concatrV Zpandas.core.dtypes.dtypesrW rX rY rZ r[ Zpandas.core.dtypes.genericr\ r] r^ r_ r` ra Z pandas.core.dtypes.inferencerb Zpandas.core.dtypes.missingrc rd re Z pandas.corerf rg Zpandas.core.accessorrh Zpandas.core.algorithmsÚcoreZ
|
algorithmsZ pandas.core.array_algos.putmaskri rj Zpandas.core.arraysrk rl rm rn Zpandas.core.arrays.string_ro Zpandas.core.baserp rq Zpandas.core.commonÚcommonrü Zpandas.core.constructionrr rs rt Zpandas.core.indexersru Zpandas.core.indexes.frozenrv Zpandas.core.missingrw Zpandas.core.opsrx Zpandas.core.ops.invalidry Zpandas.core.sortingrz r{ r| Z pandas.core.strings.accessorr} Zpandas.io.formats.printingr~ r r r r r r r r
r Ú__all__Ú frozensetZ_unsortable_typesr r( r rÈ rQ r® rþ ZMaskedComplex128EngineZMaskedComplex64EngineZMaskedFloat64EngineZMaskedFloat32EngineZMaskedUInt64EngineZMaskedUInt32EngineZMaskedUInt16EngineZMaskedUInt8EngineZMaskedInt64EngineZMaskedInt32EngineZMaskedInt16EngineZMaskedInt8EngineZMaskedBoolEnginerA r© rµ r¶ r r3 r r r¨ r¦ rõ r; r r* r¤ r¤ r¤ r¥ Ú<module> s0 < < $ l ú
|
æ z(;
|
