Ë
|
nñúhy ã ó¢ U d dl mZ d dlmZ d dlmZ d dlZd dlmZ d dlZd dl m
|
Z
|
m Z m Z m Z mZmZmZmZmZ d dlZd dlZd dlmZmZmZ d dlmZm Z m Z m Z m!Z! d d l"m#Z# d dl$m%c m&Z' d d
|
l(m)Z)m*Z* d d l+m,Z,m-Z-m.Z.m/Z/ d d l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@ d d lAmBZC d dlDmEZEmFZF d dlGmHZHmIZImJZJmKZK d dlLmMZMmNZN d dlOmPZPmQZQ d dlRmSZSmTZTmUZUmVZVmWZWmXZXmYZY d dlZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZm d dlnmoZo d dlpmqZqmrZrmsZsmtZtmuZumvZvmwZw d dlxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZ d dlmZ d dlm
Z
mZmZ d dlmZmZmZ d dlmZ d dlmc mZ d dlmZmZ d d lmZmZmZmZmZmZ d d lmZmZ d d lmZm Z d dl¡mc m¢Z£ d d l¤m¥Z¥m¦Z¦m§Z§ d d l¨m©Z©mªZª d d!l«m¬Z¬ d d"lm®Z® d d#l¯m°Z° d d$l±m²Z² d d%l³m´Z´mµZµm¶Z¶ d d&l·m¸Z¸ d d'l¹mºZºm»Z»m¼Z¼m½Z½ e
|
r d d(l¾m¿Z¿mÀZÀmÁZÁ d d)lÂmÃZÃmÄZÄmÅZÅmÆZÆ d d*lmÇZÇmÈZÈ d+gZÉ eÊd,« ZËd+d-d+d-d+d.d/ZÌd0eÍd1< i ZÎd0eÍd2< eÏZÐ ej¢ d3« ZÒi d4e j¦ d5e j¨ d6e jª d7e j¬ d8e j® d9e j° d:e j² d;e j´ d<e j¶ d=e j¸ d>e jº d?e j¼ d@e j¾ dAe jª dBe jª dCe j¬ dDe j¬ e j® e j° e j² e j´ e j¶ e j¸ e jº e j¼ e j¾ dE ¥ZàdVdFZádG Zâ G dH d+ee « ZãdWdXdIZädYdZdJZådK Zæd[dLZçd\dMZèd]dNZéd^dOZêd_dPZëd`dQZìdRdddSdT dadUZíy)bé )Ú annotations)Úabc)ÚdatetimeN)Ú zip_longest) Ú TYPE_CHECKINGÚAnyÚCallableÚClassVarÚLiteralÚNoReturnÚcastÚfinalÚoverload)Ú
|
get_optionÚusing_copy_on_writeÚusing_string_dtype)ÚNaTÚalgosÚindexÚlibÚwriters)ÚBlockValuesRefs)Úis_datetime_arrayÚ
|
no_default)ÚIncompatibleFrequencyÚOutOfBoundsDatetimeÚ TimestampÚ
|
tz_compare)ÚAnyAllÚ ArrayLikeÚAxesÚAxisÚDropKeepÚDtypeObjÚFÚ IgnoreRaiseÚ
|
IndexLabelÚJoinHowÚLevelÚ
|
NaPositionÚ ReindexMethodÚSelfÚShapeÚnpt)Úfunction)ÚDuplicateLabelErrorÚInvalidIndexError)ÚAppenderÚcache_readonlyÚ deprecate_nonkeyword_argumentsÚ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_ea_or_datetimelike_dtypeÚis_floatÚ is_hashableÚ
|
is_integerÚ 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)Ú
|
ArrowDtypeÚCategoricalDtypeÚDatetimeTZDtypeÚExtensionDtypeÚ IntervalDtypeÚ PeriodDtypeÚ SparseDtype) ÚABCCategoricalIndexÚ ABCDataFrameÚABCDatetimeIndexÚABCIntervalIndexÚ ABCMultiIndexÚABCPeriodIndexÚ ABCRangeIndexÚ ABCSeriesÚABCTimedeltaIndex)Ú is_dict_like)Úarray_equivalentÚis_valid_na_for_dtypeÚisna)Ú arraylikeÚnanopsÚops)ÚCachedAccessor)Úsetitem_datetimelike_compatÚvalidate_putmask)ÚArrowExtensionArrayÚBaseMaskedArrayÚ CategoricalÚ DatetimeArrayÚExtensionArrayÚTimedeltaArray)Ú StringArrayÚ StringDtype)Ú IndexOpsMixinÚ PandasObject)Ú ensure_wrapped_if_datetimelikeÚ extract_arrayÚsanitize_array)Údisallow_ndim_indexingÚis_valid_positional_slice)Ú
|
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)ÚHashableÚIterableÚSequence)ÚCategoricalIndexÚ DataFrameÚ
|
MultiIndexÚSeries)Ú IntervalArrayÚ PeriodArrayÚIndex)Úmixedú mixed-integerÚ ú
|
np.ndarray)ÚklassÚinplaceÚ target_klassÚraises_sectionÚuniqueÚ
|
duplicatedzdict[str, str]Ú_index_doc_kwargsÚ_index_shared_docsÚobjectÚ
|
Complex128Ú Complex64ÚFloat64ÚFloat32ÚUInt64ÚUInt32ÚUInt16ÚUInt8ÚInt64ÚInt32ÚInt16ÚInt8Ú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]c óz t j « ddddd d fd« }t t |« S )zG
|
Decorator to simplify 'return_indexers' checks in Index.join.
|
ÚleftNF©ÚhowÚlevelÚreturn_indexersÚsortc ól | ||||¬« \ }}}|s|S | t |« }| t |« }|||fS )N©r± r² r´ )rC )
|
ÚselfÚotherr± r² r³ r´ Ú
|
join_indexÚlidxÚridxÚmeths
|
úKH:\Change_password\venv_build\Lib\site-packages\pandas/core/indexes/base.pyÚjoinz$_maybe_return_indexers.<locals>.join sT ø ñ "& d¨E°sÀ%ÈdÔ!SÑ
|
D$Ù Ø Ð à Ð Ü& tÓ,DØ Ð Ü& tÓ,DØ4 Ð%Ð%ó )r¸ r r± r( r³ Úboolr´ rÀ )Ú functoolsÚwrapsr r% )r¼ r¾ s ` r½ Ú_maybe_return_indexersrà sb ø ô
|
__TÓð
|
ØØ %Øñ&àð&ð ð &ð ð &ð ô&ó ð&ô& 4=Ðr¿ c óþ t | t « rddlm} || fi |¤S t | t « r"d|v rd|vr|j d« |d< d|d< nd|vrd|v r|d j |d< | j | fi |¤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)Ú
|
issubclassra Úpandas.core.indexes.periodrÅ r` ÚpoprÉ Ú__new__)ÚclsÚdrÅ s r½ Ú
|
_new_IndexrÑ $ s ô #~Ô&Ý?á Ñ) qÑ)Ð)ä#}Ô%Ø q=W¨AÑ -àx AgJð !&Ð
|
Ò à Ñ f¨kð vY__'
|
Ø 3;;sÑ aÑ Ð r¿ c ó¸ e Zd ZU dZdZed d« Ze d d« Ze d d« Ze d d« Z dZ
|
de d < d
|
e d < e j efZd e d < dZde d< dZde d< dZde d< dgZde d< dgZde d< ed!d« Z e j. e j0 « ej4 e j. e j6 « ej8 e j. e j: « ej< e j. e j> « ej@ e j. e jB « ejD e j. e jF « ejH e j. e jJ « ejL e j. e jN « ejP e j. e jR « ejT e j. e jV « ejX e j. e jZ « ej\ e j. e j^ « ej` i Z1de d < e2 d"d « Z3dZ4dhZ5 e6de7« Z8dZ9 d# d$d Z:e;d%d « Z<ee;d&d!« « Z=e; d' d(d"« Z>e;d# « Z?ed)d$« Z@ed*d%« ZAed+d&« ZBeCfd,d'ZDd-d(ZEed,d)« ZFed!d*« ZGed*d+« ZHed*d,« ZIe d.d-« ZJeed/d.« « ZKd0d/ZLd'd1d0ZMd2d1ZNed3d2« ZOed4d3« Zed5d6d4« ZPd7d5ZQd8d%d6ZRd7eSd8< eTeSd8 eUz « d9 d:d9« ZVed;d:« ZWd;eSd<< eTeSd< eUz « d7d<d=« ZX d3 d=d>ZYed-d?« ZZed7d-d@« Z[ed>dA« Z\e2dB « Z]ed7d>dC« Z^d?dDZ_ed@dE« Z`ed1dF« Za dA dBdHZbdGZceddI dCdJ« ZddDdKZedLdMddddN dEdOZfd7d>dPZgd-dQZhed'dFdR« Zid ejj f dGdSZke2dHdT« ZleljÚ dIdU« Zle dJ dKdV« Zn d' dLdWZodMdXZpddYd*dZZq e2eqep¬[« Zresd\d\d]dNd^« Ztesd\dYdOd_« Ztesd\d\d]dPd`« Ztddd]dPdaZtesd\dbdNdc« ZuesdOdd« Zu evdedfdgdg¬h« dQdPdi« Zue2d0dj« Zwd-dkZxed*dl« Zyd0dmZz dR dSdoZ{dTdpZ|e|Z}edUdVdq« Z~edWdr« Zeed!ds« « Ze2d!dt« Ze2d!du« Zee2d!dv« « Zee2d!dw« « Zed!dx« Z
ee2d!dy« « Zed!dz« Zed!d{« Zed!d|« Zed!d}« Zed!d~« Zed!d« Zed!d« Zed!d« Zed!d« Zed>d« Zeed!d« « Zeed!d
« « Zd Zed « ZedXd« Zed!d« ZedXd« ZeZedXd« ZeZdejj fdZdYdZdZd7d[ fd Zdndd\ fdZd]d^dZd Z ed_d« Z¡e¡Z¢d Z£ed « Z¤ed`d« Z¥ed7d« Z¦dadZ§edbd« Z¨edQdcd« Z©dQdddZªd Z«e ded« Z¬ed7d« Zd Z®d Z¯d'd¡Z°ed!d¢« Z±dfd£Z²d¤ Z³e dg dhd¥« Z´ dg did¦Zµedjd§« Z¶e d' dkd¨« Z·dld©Z¸e d' dmdª« Z¹e d7 dmd«« Zºe dnd¬« Z»e dod« Z¼e dpd®« Z½edqd¯« Z¾drd°Z¿eejj f dsd±« ZÀedtd²« ZÁ du dvd³ZÂdwd´ZÃdxdµZÄe dyd¶« ZÅesd\d\d\d· dzd¸« ZÆesd\d\d\d\d¹ d{dº« ZÆesd\d\d\d\d¹ d|d»« ZÆeeÇd¼dddd¹ d}d½« « ZÆe d~d¾« ZÈe d~d¿« ZÉeddÀ« ZÊe d ddÁ« ZËe d dd« ZÌe d d
dë ZÍ ddÄZÎeed!dÅ« « ZÏe2ddÆ« ZÐe eÑeÒj¦ « ddÇ« « ZÓe2ddÈ« ZÔddÉZÕed1dÊ« ZÖddËZ× eÑeÒj° « dQddÌ« ZÙed7dTdÍ« ZÚee;dÎ « « ZÛdÏ ZÜd!dÐZÝddÑZÞdÒe dÓ< ed*dÔ« ZßdÕ ZàddÖZáed!d׫ ZâddØZãddÙZädTdÚZåddÛZæed!dÜ« ZçedÝ « Zè ddÞZéesd\d\d\d\dß ddà« Zêesd\d\d\dá ddâ« Zêesd\d\d\d\dß ddã« Zê evdedfgdä¬h« d ddå« Zêedæ « ZëdddçZìddèZídé Zîed!dê« ZïdëeSdì< eTeSdì eUz « ddí« Zðeddî« ZñddïZòddðZóes d ddñ« Zôes ddò« Zôes d8 ddó« Zôe d8 ddô« Zôe2d!dõ« ZõdöZöed d÷« Z÷ed4dø« Zøed¡dù« Zùd¢dúZúed£dû« Zûd7d¤düZüeddYdTdý« Zýd7dXdþZþd¥dÿZÿ dg d¦d Z d ZdTdZe d§d« Zd¨dZdd©dZdªdZdgd«dZd-dZd¬d Z d d®d
|
Z
|
ed8d¯d « Z ed°d±d « Z edUd²d « Z d Zed « Zed « Z fdZed « ZdTdZdTdZdTdZdTdZd Zd Zed³d« Z eTeÒj4 j « d´dµ fd « Z eTeÒj6 j « d´dµ fd « Zd´d¶d Z d´d¶d Z ee2d·d « « Z xZ S (¸ 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 : str, numpy.dtype, or ExtensionDtype, optional
|
Data type for the output Index. If not specified, this will be
|
inferred from `data`.
|
See the :ref:`user guide <basics.dtypes>` for more usages.
|
copy : bool, default False
|
Copy input data.
|
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')
|
iÐ c ón | j « }|j « }t j ||« S ©N)Ú_get_join_targetÚlibjoinÚleft_join_indexer_unique)r· r¸ ÚsvÚovs r½ Ú_left_indexer_uniquezIndex._left_indexer_unique} s3 ð × "Ñ "Ó $Ø × #Ñ #Ó %ä×/Ñ/°°BÓ7Ð7r¿ c ó¢ | j « }|j « }t j ||« \ }}}| j |« }|||fS rÔ )rÕ rÖ Úleft_join_indexerÚ_from_join_target©r· r¸ rØ rÙ Újoined_ndarrayrº r» Újoineds r½ Ú _left_indexerzIndex._left_indexer
sV ð
|
× "Ñ "Ó $Ø × #Ñ #Ó %Ü%,×%>Ñ%>¸rÀ2Ó%FÑ"dØ×'Ñ'¨Ó7ØtTÐ!Ð!r¿ c ó¢ | j « }|j « }t j ||« \ }}}| j |« }|||fS rÔ )rÕ rÖ Úinner_join_indexerrÝ rÞ s r½ Ú_inner_indexerzIndex._inner_indexer óV ð
|
× "Ñ "Ó $Ø × #Ñ #Ó %Ü%,×%?Ñ%?ÀÀBÓ%GÑ"dØ×'Ñ'¨Ó7ØtTÐ!Ð!r¿ c ó¢ | j « }|j « }t j ||« \ }}}| j |« }|||fS rÔ )rÕ rÖ Úouter_join_indexerrÝ rÞ s r½ Ú_outer_indexerzIndex._outer_indexer rå r¿ r ÚstrÚ_typúExtensionArray | np.ndarrayÚ_datazDtype[ExtensionArray] | tuple[type[np.ndarray], type[ExtensionArray]]Ú _data_clsNz object | NoneÚ_idr Ú_nameFrÀ Ú_no_setting_nameÚnameú list[str]Ú _comparablesÚ _attributesc ó. t | j « S rÔ )rL rÉ ©r· s r½ Ú_can_hold_stringszIndex._can_hold_stringsµ s ä# D§J¡JÓ/Ð/Ð/r¿ z;dict[np.dtype | ExtensionDtype, type[libindex.IndexEngine]]Ú _engine_typesc ój | j j | j t j « S rÔ )rø ÚgetrÉ ÚlibindexÚ ObjectEnginerö s r½ Ú _engine_typezIndex._engine_typeÈ s' ð ×!Ñ!×%Ñ% d§j¡j´(×2GÑ2GÓHÐHr¿ Tc ó ddl m} t ||| « }| t |« }t |dd « }d }|s"t |t t f« r |j }t |t t t f« } t |t |f« r" ||||¬« }
|
||
|
j |d¬« S |
|
S t |« r$t |t t f« rÍt |« }nÀt |« rn³t |t j" t t f« rRt |t$ « r |j& }|j( j* dvrYt- j. |t0 ¬« }n<t3 |« r| j5 |« t7 |d « r | t! j8 |« |||¬
|
« S t; |« s!t |t< « s| j5 |« |rDt? |« r t |« }|r,tA d |D « « rdd l!m"} | jF ||¬ « S t |t tH f« s t |« }tK |« dk( rt! jL |tN ¬« }tK |« r.t |d tH « rt- j. |t0 ¬« } tQ |d ||¬« } tW | « } | jY | j( « }|j[ | | j( d¬« } |j] | ||¬« }
|
|@| r>|t j^ k( r+|
|
j( |k7 r ta jb dtd d¬« |
|
S # tR $ r>} dtU | « v r| j5 |« | dtU | « v r tS d« | d } ~ ww xY w)Nr ©Ú
|
RangeIndexrÉ )ÚstartÚcopyrñ F©r ÚiufcbmM©rÉ Ú __array__©rÉ r rñ c 3 ó< K | ] }t |t « y wrÔ )Ú
|
isinstanceÚtuple)Ú.0Úes r½ ú <genexpr>z Index.__new__.<locals>.<genexpr> s è ø Ò C¸¤
|
¨1¬e× 4Ñ Cùó ©r ©Únames©rÉ r z2index must be specified when data is not list-likezData must be 1-dimensionalú Index data must be 1-dimensional)ÚrefszÏDtype inference on a pandas object (Series, Index, ExtensionArray) is deprecated. The Index constructor will keep the original dtype in the future. Call `infer_objects` on the result to get the old behavior.é ©Ú
|
stacklevel)3Úpandas.core.indexes.ranger Úmaybe_extract_namerR Úgetattrr rc r Ú _referencesrs ÚrangeÚastyperF ÚsetÚ frozensetÚlistÚnpÚndarrayr` Ú_valuesrÉ ÚkindÚcomÚasarray_tuplesafeÚ
|
_dtype_objrN Ú_raise_scalar_data_errorÚhasattrÚasarrayrK Ú
|
memoryviewrJ ÚallÚpandas.core.indexes.multir Ú from_tuplesr
|
ÚlenÚarrayr r{ Ú
|
ValueErrorré ry Ú_dtype_to_subclassÚ _ensure_arrayÚ _simple_newÚobject_ÚwarningsÚwarnÚ FutureWarning)rÏ rÊ rÉ r rñ Ú tupleize_colsr Ú
|
data_dtyper Úis_pandas_objectÚresultr ÚarrÚerrr s r½ rÎ z Index.__new__Û s õ 9ä! $¨¨cÓ2à Ð Ü Ó'Eä T 7¨DÓ1
|
àÙ
|
4¬)´UÐ);Ô<Ø×#Ñ#Dä% d¬Y¼¼~Ð,NÓOÐô dU JÐ /Ô 0Ù d°¸DÔAFØÐ Ø }} U°}Ó7Ð7ð Mä (¨Ô /ä$¤¤iÐ 0Õ1ÜDzä (¨Ô 4Ù ä rzz¬5´)Ð <Ô =Ü$¤ Ô.Ø||àzz iÒ/ô
|
×,Ñ,¨T¼ÔDä t_Ø×.Ñ.¨tÓ4Ð 4Ü T;Ô 'Ùrzz $Ó'¨u¸4ÀdÔKÐ KÜ dÔ#¬J°t¼ZÔ,Hð ×.Ñ.¨tÓ4Ð 4ñ ä tÔ$Ü :DáCÑ C¸dÔ CÔ Cõ Eð 2:×1Ñ1Ø Dô ð ô
|
d¤T¬5 MÔ2ô DzÜ4yA~äxx ¬FÔ3ä4yZ¨¨Q©´Ô 7ä×,Ñ,¨T¼ÔDð Ü t°5¸tÔDCô -¨SÓ1à×&Ñ& s§y¡yÓ1à×!Ñ! # s§y¡y°uÐ!Ó=Ø×"Ñ" 3¨°4Ð"Ó8Ø =Ñ -°*ÄÇ
|
Á
|
Ò2JØ||zÒ)Ü ð ô
|
"Ø õð øô/ ò ØCÄsÈ3ÃxÑOØ×2Ñ2°4Ó8¸cÐAØ+¬s°3«xÑ7Ü Ð!CÓDÈ#ÐMØ ûð ús ÊL> Ì> NÍ9N Î Nc ó |j dkD r t d« |t j k( r t d« |r|j « }|S )zF
|
Ensure we have a valid array to pass to _simple_new.
|
é r z!float16 indexes are not supported)Úndimr1 r! Úfloat16ÚNotImplementedErrorr )rÏ rÊ rÉ r s r½ r3 zIndex._ensure_arrayP sH ð
|
99q=ä Ð ?Ó@Ð @Ø bjjÒ ä%Ð&IÓJÐ Já ð 99;DØ r¿ c ó, t |t « r |j S |j dk( rddlm} |S |j dk( rddlm} |S |j dk( rt S t |j t « s t |« rt S t |« )NÚMr )Ú DatetimeIndexÚm)ÚTimedeltaIndexÚO) r rX Ú index_classr$ ÚpandasrF rH r rË Útyperé rL rC )rÏ rÉ rF rH s r½ r2 zIndex._dtype_to_subclassb s{ ô
|
e^Ô ,Ø×$Ñ$Ð $à ::Ò Ý ,à Ð à ZZ3Ò Ý -à!Ð !à ZZ3Ò äLä
|
|
¤CÔ (Ô,<¸UÔ,CÜLä! %Ó(Ð(r¿ c ó. t || j « sJ t |« « t j | « }||_ ||_ i |_ |j « |||_ nt « |_ |j 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.
|
) r rí rL r rÎ rì rï Ú_cacheÚ_reset_identityr r Úadd_index_reference)rÏ Úvaluesrñ r r< s r½ r4 zIndex._simple_new s ô & #§-¡-Ô0Ð>´$°v³,Ó>Ð0ä Ó$Ø Ø Ø Ø× Ñ Ô Ø Ð Ø!%FÕ ä!0Ó!2FÔ Ø×Ñ×.Ñ.¨vÔ6à r¿ c óð | |i |¤}|j t k( rZ|j sNt j |j
|
« }|j j dv rt ||j ¬« S |S )zw
|
Constructor that uses the 1.0.x behavior inferring numeric dtypes
|
for ndarray[object] inputs.
|
Úiufb©rñ ) rÉ r' Ú _is_multir Úmaybe_convert_objectsr# r$ r rñ )rÏ ÚargsÚkwargsr< rQ s r½ Ú _with_inferzIndex._with_infer£ se ñ dÐ%fÑ%à <<:Ò %¨f×.>Ò.>ô ×.Ñ.¨v¯~©~Ó>FØ||× Ñ FÑ*Ü V¨&¯+©+Ô6Ð6à r¿ c ó t | « S rÔ )rL rö s r½ Ú _constructorzIndex._constructorµ s äDzÐr¿ c óf | j s%d}| j « }|d| z }t |« y)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_messager0 )r· ÚmsgÚ
|
duplicatess r½ Ú_maybe_check_uniquezIndex._maybe_check_unique¹ s? ð ~~Ø-CØ ×7Ñ7Ó9JØ R
|
|Ð$Ñ $Cä% cÓ*Ð *ð r¿ c óÖ ddl m} | | j d¬« j « }t |« sJ |t j t | « « d¬« j | d¬« j t « | }| j r)t | « j |j « |_ | j dk( r|j d « }|j! d
|
¬ « S ) 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©ÚkeepFr )Úobservedr@ ÚlabelÚ positionsrT )rK r r r r/ r! ÚarangeÚgroupbyÚaggr rU rL r. r ÚnlevelsÚ rename_axisÚto_frame)r· r ra Úouts r½ r_ z Index._format_duplicate_messageÎ s½ õ" "à$//¨w/Ó7Ñ8×?Ñ?ÓA
|
Ü:Ð ñ 299S YÓ'¨eÔ 4ß WT EWÓ *ß SYzñ #ð ð
|
>>ô T
|
×.Ñ.¨s¯y©yÓ9CIà <<1Ò Ø// 'Ó*CØ|| |Ó-Ð-r¿ c ój |t u r | j n|}| j ||| j ¬« S )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ï r4 r )r· rQ rñ s r½ Ú _shallow_copyzIndex._shallow_copyõ s4 ð "¤ZÑ /tzz°Tà× Ñ ¨T¸×8HÑ8HÐ ÓIÐIr¿ c ó | j | j | j | j ¬« }| j |_ |S )zR
|
fastpath to make a shallow copy, i.e. new object with same data.
|
rs )r4 r# rï r rN ©r· r< s r½ Ú_viewz Index._view s9 ð ×!Ñ! $§,¡,°T·Z±ZÀd×FVÑFVÐ!ÓWà Ø r¿ c ó4 | j « }||_ |S )zG
|
fastpath for rename if new name is already validated.
|
)rw rï )r· rñ r< s r½ Ú_renamez Index._rename s ð
|
Ø Ø r¿ c ó | |u ryt |d« sy| j |j y| j |j u S )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.
|
|
Examples
|
--------
|
>>> idx1 = pd.Index(['1', '2', '3'])
|
>>> idx1.is_(idx1.view())
|
True
|
|
>>> idx1.is_(idx1.copy())
|
False
|
Trî F)r) rî ©r· r¸ s r½ Úis_z Index.is_ sD ð> 5=ØÜ Ô&ØØ XXÐ §¡Ð!2Øà88uyyÐ(Ð (r¿ c ó" t « | _ y)zJ
|
Initializes or resets ``_id`` attribute with new object.
|
N)r rî rö s r½ rO zIndex._reset_identity@ s ô
|
8r¿ c ó8 | j j « y rÔ )Ú_engineÚ clear_mappingrö s r½ Ú_cleanupzIndex._cleanupG s à ×"Ñ"Õ$r¿ c ó | j « }t | j t « rä| j j
|
dv rÌdd l}| j j j }|j j |« r9| j j « }t j |j « S |j j |« r9| j j! « }t j" |j « S t |t$ « rjt |t& t f« r# t) |j j* |« S | j. t j0 u rt j2 |« S t5 t6 j8 |« }|j t: k( rt j< |« S |j t6 j> k( rt j@ |« S |j t6 jB k( rt jD |« S tG | j « r| jH j }nTtK | j « r?tM | j « s*t jN || j jP « S | j/ |« S # t, $ r Y Cw xY w)NÚMmr ))Ú_get_engine_targetr r# ro rÉ r$ ÚpyarrowÚ _pa_arrayrL ÚtypesÚ is_timestampÚ_to_datetimearrayrû ÚDatetimeEngineÚ_ndarrayÚ is_durationÚ_to_timedeltaarrayÚTimedeltaEnginers rp Ú_masked_enginesrñ ÚKeyErrorrý rü ÚExtensionEnginer r! r" rÀ Ú
|
BoolEngineÚ complex64ÚComplex64EngineÚ
|
complex128ÚComplex128EnginerQ rì rP rM ÚStringObjectEngineÚna_value)r· Ú target_valuesÚpaÚpa_types r½ r z Index._engineK s ð
|
×/Ñ/Ó1 ä dllÔ$7Ô 8¸T¿Z¹Z¿_¹_ÐPTÑ=TÛ àll×,Ñ,×1Ñ1GØxx×$Ñ$ WÔ-Ø $§ ¡ × >Ñ >Ó @ Ü ×.Ñ.¨}×/EÑ/EÓFÐFØ×%Ñ% gÔ.Ø $§ ¡ × ?Ñ ?Ó A Ü ×/Ñ/° ×0FÑ0FÓGÐGä m¤^Ô 4Ü-¬/Ô;NÐ)OÔPðÜ*¨=×+>Ñ+>×+CÑ+CÑDÀ]ÓSÐSð ×"Ñ"¤h×&;Ñ&;Ñ;Ü ×/Ñ/° Ó>Ð>ä RZZ¨ Ó7 ð × Ñ ¤$Ò &Ü×&Ñ& }Ó5Ð 5Ø × Ñ ¤B§L¡LÒ 0Ü×+Ñ+¨MÓ:Ð :Ø × Ñ ¤B§M¡MÒ 1Ü×,Ñ,¨]Ó;Ð ;Ü §¡Ô ,ð !JJ× /Ñ /MÜ TZZÔ (´ ÀÇÁÔ1LÜ×.Ñ.¨}¸d¿j¹j×>QÑ>QÓRÐ Rð × Ñ Ó/Ð/øô7 ò âðús Ä6!K Ë K Ë K c ó¤ | j d¬« dt d« D ch c]$ }t |t « r|j « r|& c}S c c}w )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.
|
r ©r² Nzdisplay.max_dir_items)r r r ré Ú isidentifier)r· Úcs r½ Ú_dir_additions_for_ownerz Index._dir_additions_for_owner~ sP ð [[ q[Ó)Ð*O¬JÐ7NÓ,OÐPö
|
àÜ!SÔ! a§n¡nÔ&6ò ò
|
ð
|
ùò
|
s ¡)A c ó, t | j « S )z1
|
Return the length of the Index.
|
)r/ rì rö s r½ Ú__len__z Index.__len__ s ô 4::Ð r¿ c ó |!t j | j |¬« S t j | j ||¬« S )z8
|
The array interface, return my values.
|
r r )r! r* rì r0 )r· rÉ r s r½ r zIndex.__array__ s5 ð <ä::djj°Ô6Ð 6äxx
|
|
¨%°dÔ;Ð;r¿ c ó t d |D « « rt S t j ||g|¢i |¤}|t ur|S d|v rt j ||g|¢i |¤S |dk( r%t j
|
||g|¢i |¤}|t ur|S |D cg c] }| ur|n |j }} t ||« |i |¤}|j dk( rt fd|D « « S |dk( rt j |« }|S |j t j k( r |j t j « } j# |« S c c}w )Nc 3 óH K | ] }t |t t f« y wrÔ )r rc r] )r r¸ s r½ r z(Index.__array_ufunc__.<locals>.<genexpr>¡ s è ø ÒPÀz%¤)¬\Ð!:×;ÑPùs "rq Úreducer c 3 ó@ K | ] }j |« y wrÔ )Ú__array_wrap__)r Úxr· s r½ r z(Index.__array_ufunc__.<locals>.<genexpr>» s øè ø Ò@°A×,Ñ,¨Q×/Ñ@ùó )ÚanyÚNotImplementedri Ú!maybe_dispatch_ufunc_to_dunder_opÚdispatch_ufunc_with_outÚdispatch_reduction_ufuncr# r Únoutr
|
r Úitem_from_zerodimrÉ r! rB r Úfloat32r¨ )r· ÚufuncÚmethodÚinputsrX r< r© Ú
|
new_inputss ` r½ Ú__array_ufunc__zIndex.__array_ufunc__ sj ø Ü ÑPÈÔPÔ PÜ!Ð !ä×<Ñ<Ø %ð
|
Ø"(ò
|
Ø,2ñ
|
ð Ñ 'ØMà F?ä ×4Ñ4ØeVðØ&,òØ06ñð ð XÒ Ü ×7Ñ7ØeVðØ&,òØ06ñFð ^Ñ+Ø àAGÖH¸A1 D=a¨a¯i©iÑ7ÐH
|
ÐHØ' Ó'¨Ð>°vÑ>Ø ::?äÓ@¸Ô@Ó@Ð @Ø xÒ Ü×*Ñ*¨6Ó2FØMà <<2::Ò %Ø]]¤2§:¡:Ó.Fà×"Ñ" 6Ó*Ð*ùò Is  Ec óØ t j |« }t |t « st |j
|
« st j |« dkD r|S t || j ¬« S )zN
|
Gets called after a ufunc and other functions e.g. np.split.
|
r@ rT ) r r± r r rE rÉ r! rA rñ )r· r< ÚcontextÚ return_scalars r½ r¨ zIndex.__array_wrap__Å sY ô
|
×&Ñ& vÓ.Ü6¤5Ô)¬m¸F¿L¹LÔ.IÌbÏgÉgØ óO
|
à òOð MäV $§)¡)Ô,Ð,r¿ c ó. | j j S )zï
|
Return the dtype object of the underlying data.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx
|
Index([1, 2, 3], dtype='int64')
|
>>> idx.dtype
|
dtype('int64')
|
)rì rÉ rö s r½ rÉ z Index.dtypeÕ s ð zz× Ñ Ð r¿ c ó | dd S )a\
|
Return a view on self.
|
|
Returns
|
-------
|
Index
|
|
See Also
|
--------
|
numpy.ndarray.ravel : Return a flattened array.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
|
>>> s.index.ravel()
|
Index(['a', 'b', 'c'], dtype='object')
|
N© )r· Úorders r½ Úravelz Index.ravelä s ð& Awr¿ c óR |¶t |d« sª|}t |t « r t |« }t |« rf| j |« }| j j |« }t |t « r(|j || j | j ¬« S |S | j j |« }nM|;t j dt | « j dt" t% « ¬« | j' « }t |t( « r| j* |_ |S )Nrê rs zPassing a type in zr.view is deprecated and will raise in a future version. Call view without any argument to retain the old behavior.r )r) r ré rR rQ r2 r0 Úviewrs r4 rñ r rì r6 r7 rL Ú__name__r8 r6 rw r rî )r· rÏ rÉ Úidx_clsr= r< s r½ rÁ z
|
Index.viewù s ð ?¤7¨3°Ô#7ØEÜ#sÔ#Ü$ SÓ)ä" 5Ô)Ø ×1Ñ1°%Ó8Øjjoo eÓ,Ü c¤>Ô2à"×.Ñ.Ø $§)¡)°$×2BÑ2Bð /ó ð ð
|
àZZ__ SÓ)FàÜ à(¬¨d«×)<Ñ)<Ð(=ð >Qð Qô "Ü /Ó 1õ ð ZZ\FÜ feÔ $Ø FJØ r¿ c óÀ | t |« }| j |k( r|r| j « S | S | j }t |t
|
« rOt t |« j t | « j « 5 |j ||¬« }ddd« nCt |t « r%|j « }|j | ||¬« }nt |||¬« }t | j |j d¬« }|sN| j Bt# | j |« r,| j |_ |j j% |« |S # 1 sw Y ~xY w)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.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx
|
Index([1, 2, 3], dtype='int64')
|
>>> idx.astype('float')
|
Index([1.0, 2.0, 3.0], dtype='float64')
|
Nr r F)rñ rÉ r )rR rÉ r rì r rs r7 rL r r rX Úconstruct_array_typeÚ_from_sequencer8 r rñ r r9 rP )r· rÉ r rQ Ú
|
new_valuesrÏ r< s r½ r z Index.astype s5 ð@ Ð Ü Ó'Eà ::Ò á"&499;Ð 0¨DÐ 0àÜ fnÔ -Ü"¤4¨£<×#8Ñ#8¼$¸t»*×:MÑ:MÓNñ =Ø #]]¨5°t]Ó <
|
÷ =ð =ô ~Ô .Ø×,Ñ,Ó.Cð ×+Ñ+¨D¸ÀDÐ+ÓIJô & f°EÀÔEJô z¨¯ © ¸×9IÑ9IÐPUÔVáØ× Ñ Ð,Ü tzz¨5Ô1à!%×!1Ñ!1FÔ Ø × Ñ × 2Ñ 2°6Ô :Ø ÷- =ð =ús Á?EÅE a
|
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.
|
|
Examples
|
--------
|
>>> idx = pd.Index(['a', 'b', 'c'])
|
>>> idx.take([2, 2, 1, 2])
|
Index(['c', 'c', 'b', 'c'], dtype='object')
|
Útakec ó¸ |rt j d|« t |« r t d« t |« }| j |||« }| j }t |t j « r$t j |||| j ¬« }n |j ||| j ¬« }| j j || j ¬« S )Nr½ z!Expected indices to be array-like)Ú
|
allow_fillÚ
|
fill_valuerT )ÚnvÚ validate_takerN Ú TypeErrorrC Ú_maybe_disallow_fillr# r r! r" r rÈ Ú _na_valuer[ r4 rñ )r· ÚindicesÚaxisrÊ rË rX rQ Útakens r½ rÈ z
|
Index.take s¿ ñ Ü × Ñ R Ô (Ü WÔ ÜÐ ?Ó@Ð @Ü% gÓ.Ø×.Ñ.¨z¸:ÀwÓO
|
ð Ü fbjjÔ )ÜJJبJÀ4Ç>Á>ôEð
|
KKØ J¸4¿>¹>ð ó Eð × Ñ ×,Ñ,¨U¸¿¹Ð,ÓCÐCr¿ c ó² |rR|P| j r |dk j « r/t d« t | « j }t d| d« |S d}|S )zm
|
We only use pandas-style take when allow_fill is True _and_
|
fill_value is not None.
|
éÿÿÿÿ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« r1 rL r )r· rÊ rË rÑ Úcls_names r½ rÏ zIndex._maybe_disallow_fill sw ñ *Ð0à× Ò ØbL×%Ñ%Ô'Ü$ð4óð ô
|
:×.Ñ.Ü Ø4°X°JÐ>PÐQóð ð
|
Ðð JØÐr¿ a|
|
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 óÌ t |« }t j dd|i« | j j |« }| j
|
j || j ¬« S )Nr½ rÒ rT )rC rÌ Úvalidate_repeatr# rØ r[ r4 rñ )r· ÚrepeatsrÒ Ú
|
res_valuess r½ rØ z Index.repeatÝ sV ä% gÓ.Ü
|
×Ñ2 ¨~Ô.Ø\\×(Ñ(¨Ó1
|
ð × Ñ ×,Ñ,¨Z¸d¿i¹iÐ,ÓHÐHr¿ c óÊ | j ||¬« d }|r8| j j « }t | « j ||¬« }|S | j |¬« }|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.
|
|
Examples
|
--------
|
>>> idx = pd.Index(['a', 'b', 'c'])
|
>>> new_idx = idx.copy()
|
>>> idx is new_idx
|
False
|
)rñ Údeepr rT )Ú_validate_namesrì r rL r4 ry )r· rñ rÞ Únew_dataÚ new_indexs r½ r z
|
Index.copyé sk ðD ×#Ñ#¨°DÐ#Ó9¸!Ñ<Ù ØzzÓ(HÜ T
|
×.Ñ.¨x¸dÐ.ÓCIð Ðð ¨$ Ó/IØÐr¿ c ó& | j di |¤S )Nr½ r )r· rX s r½ Ú__copy__zIndex.__copy__ s àtyyÑ"6Ñ"Ð"r¿ c ó& | j d¬« S )zq
|
Parameters
|
----------
|
memo, default None
|
Standard signature. Unused
|
T©rÞ r )r· Úmemos r½ Ú __deepcopy__zIndex.__deepcopy__ s ð yydyÓ#Ð#r¿ c óà t | « j }| j « }| j « }|D cg c] \ }}| d| }}}dj |« }| d| | dS c c}}w )zA
|
Return a string representation for this object.
|
ú=ú, ú(ú))rL rÂ Ú _format_dataÚ _format_attrsr¾ )r· Ú
|
klass_namerÊ ÚattrsÚkÚvÚ attrs_strÚpreprs r½ Ú__repr__zIndex.__repr__$ sz ô
|
$Z×(Ñ(
|
Ø× Ñ Ó"Ø×"Ñ"Ó$Ø,1×2¡D A qs!A3ZÐ2 Ñ2Ø )Ó$à Qtf U G¨1Ð-Ð-ùó 3s »A*c ó t S )z0
|
Return the formatter function.
|
)r rö s r½ Ú_formatter_funczIndex._formatter_func1 s
|
ô
|
Ð r¿ c ó$ d}| j dk( rd}nYt | j t « r.t d| « } t | j j « rd}nt | t « ryt | | j ||| j ¬« S )z@
|
Return the formatted data as a unicode string.
|
TÚstringFr r )Ú
|
is_justifyrñ Úline_break_each_value) Ú inferred_typer rÉ rV r rM Ú
|
categoriesrb r r÷ rU )r· rñ rú s r½ rí zIndex._format_data8 s ð
|
à × Ñ Ò )Ø JÜ
|
|
Ô$4Ô 5ÜÐ*¨DÓ1DÜ t× 4Ñ 4Ô5Ø "
|
Ü mÔ ,àä$Ø Ø × Ñ Ø!ØØ"&§.¡.ô
|
ð
|
r¿ c óê g }| j s!|j dd| j df« | j '|j dt | j « f« nN| j rBt d | j D « « r&|j dt | j « f« t d« xs t | « }t | « |kD r |j dt | « f« |S )zH
|
Return a list of tuples of the (attr,formatted_value).
|
rÉ ú'rñ c 3 ó$ K | ] }|d u
|
y wrÔ r½ ©r r© s r½ r z&Index._format_attrs.<locals>.<genexpr>] s è ø Ò#F°a A¨T¤MÑ#Fùs r zdisplay.max_seq_itemsÚlength) rU ÚappendrÉ rñ r r« r r r/ )r· rð Ú max_seq_itemss r½ rî zIndex._format_attrsR sÀ ð @Bà~~Ø LL' Q t§z¡z l°!Ð#4Ð5Ô 6à 99Ð Ø LL&¤.°·±Ó";Ð<Õ =Ø ^^¤Ñ#F¸4¿:¹:Ô#FÔ FØ LL'¤>°$·*±*Ó#=Ð>Ô ?ä"Ð#:Ó;ÒH¼sÀ4»y Ü t9}Ò $Ø LL(¤C¨£IÐ.Ô /Ø r¿ c ó² | j r,t | j « D cg c] \ }}||n| c}}S | j dS | j S c c}}w )zX
|
Return a name or list of names with None replaced by the level number.
|
r )rU Ú enumerater rñ )r· r² rñ s r½ Ú_get_level_nameszIndex._get_level_namese sX ð
|
>>äCLÈTÏZÉZÓCX÷Ù4?°E¸4 ¨4Ñ/óð ð Ð)1Ð 8¨t¯y©yÐ 8ùó s ¥Ac ó t | j t j « r=| j j dk7 r$t t j
|
| j « S | j t d¬« j S )NrE Fr )
|
r rÉ r! r$ r r" rQ r r r# rö s r½ Ú _mpl_reprzIndex._mpl_reprq sS ô djj¤"§(¡(Ô +°·
|
±
|
·±À3Ò0FÜ
|
|
D§K¡KÓ0Ð 0Ø{{6¨{Ó.×6Ñ6Ð6r¿ ÚNaNc óJ t j t | « j dt t « ¬« g }|r4|j | j t | j d¬« nd« | |t | j |« « z S | j ||¬« S )ú>
|
Render a string representation of the Index.
|
z.format is deprecated and will be removed in a future version. Convert using index.astype(str) or index.map(formatter) instead.r ©ú ú r] ©Ú escape_charsr ©ÚheaderÚna_rep) r6 r7 rL r r8 r6 r rñ r r ÚmapÚ_format_with_header)r· rñ Ú formatterr r s r½ Úformatz Index.formatx s ô äDz×"Ñ"Ð#ð $,ð ,ô Ü'Ó)õ
|
ð Ù Ø MMà99Ð(ô TYYÐ5GÕHàô ð Ð ØD §¡¨)Ó!4Ó 5Ñ5Ð 5à×'Ñ'¨v¸fÐ'ÓEÐEr¿ )r c óê g }|r4|j | j t | j d¬« nd« | |t | j |« « z S | j || j ¬« S )r r r r r )r rñ r r r r Ú_default_na_rep)r· Ú include_namer r s r½ Ú _format_flatzIndex._format_flat ss ð Ù Ø MMà99Ð(ô TYYÐ5GÕHàô ð Ð ØD §¡¨)Ó!4Ó 5Ñ5Ð 5à×'Ñ'¨v¸d×>RÑ>RÐ'ÓSÐSr¿ c óú ddl m} | j }t |j « s5t |j « s t | j t t f« rd}nd} ||d |¬« }t |« }||z S )Nr )Ú format_arrayr, r¯ )Újustify)
|
Úpandas.io.formats.formatr r# rM rÉ rP r rY rV Ú
|
trim_front)r· r r r rQ r Ú formattedr< s r½ r zIndex._format_with_header¯ sl Ý9à ô FLLÔ )Ü v||Ô,Ü$**¤}Ô6FÐ&GÔHð Gà Gñ ! ¨°wÔ? ÜIÓ&ØÐ r¿ r ú.©r ÚdecimalÚ float_formatÚ date_formatÚquotingc ó8 t | j |||||¬« S )Nr$ )Úget_values_for_csvr# )r· r r% r& r' r( s r½ Ú_get_values_for_csvzIndex._get_values_for_csvÄ s' ô "Ø LLØØØ%Ø#Øô
|
ð
|
r¿ c ó( t | « dkD rÙ| d }t |d« r!t |t « s|j « }n6t | j « r!| j |« j dd« }| d }t |d« r!t |t « s|j « }n6t | j « r!| j |« j dd« }d| d| }nd}|t | « j }| dt | « 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 rÕ rê z to z: z entries) r/ r) r ré r rQ rÉ r÷ ÚreplacerL r )r· rñ ÚheadÚtailÚ index_summarys r½ Ú_summaryzIndex._summaryÖ sõ ô t9q=Ø7DÜtXÔ&¬z¸$ÄÔ/DØ{{}Ü$ T§Z¡ZÔ0à×+Ñ+¨DÓ1×9Ñ9¸#¸rÓBØ8DÜtXÔ&¬z¸$ÄÔ/DØ{{}Ü$ T§Z¡ZÔ0à×+Ñ+¨DÓ1×9Ñ9¸#¸rÓBà d¨4¨&Ð 1Mà Mà <Ü:×&Ñ&DØr#d) H¨]¨OÐ<Ð<r¿ c ó | 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ö s r½ Ú to_flat_indexzIndex.to_flat_indexü s ð r¿ c ó ddl m} || j « }| | j } || j j « ||¬« S )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 rd )r rñ )rK r rw rñ r# r )r· r rñ r s r½ Ú to_serieszIndex.to_series sB õn "à =ØJJLEØ <Ø99Dádll×'Ñ'Ó)°¸TÔBÐBr¿ c ó ddl m} |t j u r| j « } ||| it « ¬« }|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 )rK r r r r r r )r· r rñ r r< s r½ rp zIndex.to_frameN sH õf %à 3>>Ñ !Ø×(Ñ(Ó*DÙD $<Ô2EÓ2GÐ.GÔHá Ø FLØ r¿ c ó | j S )zé
|
Return Index or MultiIndex name.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 2, 3], name='x')
|
>>> idx
|
Index([1, 2, 3], dtype='int64', name='x')
|
>>> idx.name
|
'x'
|
)rï rö s r½ rñ z
|
Index.name s ð zzÐr¿ c ól | j r t d« t |d t | « « || _ y )NzOCannot set name on a level of a MultiIndex. Use 'MultiIndex.set_names' instead.)rð Ú RuntimeErrorr rL rï )r· Úvalues r½ rñ z
|
Index.name s6 à × Ò ä ð2óð ô 5 $¬¨T«
|
Ô3Ø
|
r¿ c ó° ddl m} | | t d« |#|!|r || j « n | j }n,|t |« s t d« |}nt |« s|g}n|}t |« t | j « k7 r-t dt | j « dt |« « t |dt | « j di |S ) z
|
Handles the quirks of having a singular 'name' parameter for general
|
Index and plural 'names' parameter for MultiIndex.
|
r )Údeepcopyz*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< rÎ r rK r/ r1 rS rL r )r· rñ r rÞ r< Ú new_namess r½ rß zIndex._validate_names¨ sÖ õ "à Ð Ð!1ÜÐ HÓIÐ IØ =T\Ù04 §¡Ô,¸$¿*¹*IØ Ð Ü Ô&Ü Ð AÓBÐBØ IÜ dÔ#Ø Ià Iä y>S §¡_Ò ,Ü Ø.¬s°4·:±:«Ð.?¸vÄcÈ)ÃnÐEUÐVóð ô
|
yÐS¼¸T»
|
×8KÑ8KÐ7LÈEÐ5RÒSàÐr¿ c ó ddl m} |t |t t f« r|g}t |t
|
« s | t d« |sIt | |« r!t j | j « }|S | j |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 z-Index names must be str or 1-dimensional list) r- r r Úintré r r1 r% Úfill_missing_namesr rñ )r· r Údefaultr s r½ Ú_get_default_index_namesz Index._get_default_index_namesÉ s õ$ 9à Ð Ü%¤#¤s Ô,Ø ä%¤Ô&¨5Ð+<Ü Ð LÓMÐ MáÜ$
|
Ô+Ü×.Ñ.¨t¯z©zÓ:ð ð &*§Y¡YÐ%6 ¸T¿Y¹Y¸Kà r¿ c ó. t | j f« S rÔ )r~ rñ rö s r½ Ú
|
_get_nameszIndex._get_namesì s Ü499,Ó'Ð'r¿ r c óÐ t |« s t d« t |« dk7 rt dt |« « t |dt | « j
|
di |d | _ y)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)rK r1 r/ rS rL r rï ©r· rQ r² s r½ Ú
|
_set_nameszIndex._set_namesï sg ô FÔ#Ü Ð 8Ó9Ð 9Ü v;!Ò Ü Ð BÄ3ÀvÃ;À-Ð PÓQÐ Qô vÐP´T¸$³Z×5HÑ5HÐ4IÈÐ2OÒPàAY
|
r¿ )ÚfsetÚfget.)r² r c ó y rÔ r½ ©r· r r² r s r½ Ú set_nameszIndex.set_names ó à r¿ c ó y rÔ r½ rN s r½ rO zIndex.set_names rP r¿ c ó y rÔ r½ rN s r½ rO zIndex.set_names rP r¿ c óÒ |t | t « s t d« |!t |« st |« r t d« t |« s || j
|
dkD r t d« t |« rt | t « s t d« t |« r | t d« t | t « rht |« r]|[g g }}t | j « D ]= \ }}||j « v s|j |« |j || « ? |}t |« s|g}|t |« s|g}|r| }n| j « }|j ||¬« |s|S y) 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`.r ) r r` r1 rK rÎ rn re r r Úkeysr rw rJ )r· r r² r Únames_adjustedÚirñ Úidxs r½ rO zIndex.set_names sV ðD Ð ¤Z°´mÔ%DÜ Ð DÓEÐ Eà Ð ¤\°%Ô%8¼\È%Ô=PÜÐ UÓVÐ VäEÔ" u }¸¿ ¹ ÈÒ9IÜÐ =Ó>Ð >ä Ô ¤z°$¼ Ô'FÜÐ PÓQÐ Qä Ô 5Ð#4ÜÐ FÓGÐ Gä dMÔ *¬|¸EÔ/BÀuÀ}à$&¨>EÜ$ T§Z¡ZÓ0ò 74Ø5::<Ò'ØLL OØ"×)Ñ)¨%°©+Õ6ð 7ð #EäEÔ"ØGEØ Ð ¤\°%Ô%8ØGEá ØCà**,Cà u EÔ*ÙØJØr¿ ©r c ó y rÔ r½ ©r· rñ r s r½ Úrenamez Index.rename rP r¿ c ó y rÔ r½ rZ s r½ r[ z Index.rename
rP r¿ z3.0r· r[ )ÚversionÚ allowed_argsrñ c ó* | j |g|¬« S )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`.
|
rX )rO rZ s r½ r[ z Index.rename s ðh ~~tf¨g~Ó6Ð6r¿ c ó y)z#
|
Number of levels.
|
r@ r½ rö s r½ rn z Index.nlevels s ð
|
r¿ c ó | S )z)
|
Compat with MultiIndex.
|
r½ rö s r½ Ú_sort_levels_monotonicz Index._sort_levels_monotonicÉ s ð r¿ c óÚ t |t « r0|dk r|dk7 rt d| d« |dkD rt d|dz « y
|
|| j k7 r t d| d| j d « y
|
) 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 rÕ 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 rB Ú
|
IndexErrorrñ r ©r· r² s r½ Ú_validate_index_levelzIndex._validate_index_levelÏ s ô eSÔ !ØqyU b[Ü Ø?Ø gÐ 9ð;óð ð qyÜ ØCÀEÈAÁIÀ;ÐOóð ð ð diiÒ ÜØ# E 7Ð*GÈÏ É À{ÐRSÐTóð ð r¿ c ó& | j |« y)Nr ©rf re s r½ Ú_get_level_numberzIndex._get_level_numberç s Ø ×"Ñ" 5Ô)Ør¿ re c óþ t |t t f« s t d« t |t « r t |« dk7 r t d« |d }t |t « s t d« | j d||¬« S )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
|
na_position : {'first' or 'last'}, default 'first'
|
Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at
|
the end.
|
|
.. versionadded:: 2.1.0
|
|
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_indexerÚ ascendingÚ na_position)r r rÀ rÎ r/ Ú sort_values)r· r² rl Úsort_remainingrm s r½ Ú sortlevelzIndex.sortlevelë s ô8 )¤d¬D \Ô2Üð4óð ô
|
i¤Ô &Ü9~ Ò"Ü Ð UÓVÐVØ! ! Iä)¤TÔ*ÜÐ <Ó=Ð =à× Ñ Ø ¨9À+ð ó
|
ð
|
r¿ c ó( | j |« | 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')
|
rh re s r½ Ú_get_level_valueszIndex._get_level_values s ðH ×"Ñ" 5Ô)Ø r¿ c ó t |t t f« s|g}t fd|D « « ddd
} j |« 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 ó@ K | ] }j |« y wrÔ )ri )r Úlevr· s r½ r z"Index.droplevel.<locals>.<genexpr>r s øè ø ÒF¸×/Ñ/°×4ÑFùrª NrÕ )r r
|
r ÚsortedÚ_drop_level_numbers)r· r² Úlevnumss ` r½ Ú droplevelzIndex.droplevelB sE ø ôZ %¤%¬ Ô/ØGEäÓFÀÔFÓFÁtÈÀtÑLà×'Ñ'¨Ó0Ð0r¿ c ó |st | t « s| S t |« | j k\ r%t dt |« d| j d« t d| « } t | j « }t | j « }t | j « }|D ]5 }|j |« |j |« |j |« 7 t |« dk( rÍ|d }t |« dk( r_t |d « dk( r|dd }|S t j |j |d d¬ « }|j j ||d ¬
|
« }|S |d d k( } |d j |d « }| j! « r |j# | t$ j& « }|d |_ |S dd lm}
|
|
|
|||d ¬« S )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)rÊ rT rÕ r F©ÚlevelsrÇ r rÈ )r r` r/ rn r1 r r r| rÇ r rÍ r rÈ r# r[ r4 r« Úputmaskr! Únanrï r- r ) r· rx Ú
|
new_levelsÚ new_codesr@ rV ru r< rÜ Úmaskr s r½ rw zIndex._drop_level_numbersv s¹ ñ z¨$´ Ô >ØKÜ w<4<<Ò 'Ü Ø ¤ W£ Ð.IØ<<.Ð IðKóð ô
|
L $Ó'ä$++Ó&
|
ÜÓ$ ÜÓ$ àò AØ NN1Ô Ø MM!Ô Ø MM!Õ ð ô
|
z?aÒ Ø Q-Cä3x1}äy |Ó$¨Ò)ð ! !WFð Mô "'§¡¨C¯K©K¸À1¹ ÐRVÔ!WJà × -Ñ -× 9Ñ 9¸*È9ÐUVÉ<Ð 9Ó XFð Mð ! | rÑ)Ø# A ×+Ñ+¨I°a©LÓ9Ø88:Ø #^^¨D´"·&±&Ó 9Fà (¨| àMå <á Ø!Ø Ø Ø!&ô ð r¿ c ó t | j t « r| j j S | j j dv ryy)NÚiubFT)r rÉ rX rÖ r$ rö s r½ rÖ zIndex._can_hold_na³ s8 ô djj¤.Ô 1Ø::×*Ñ*Ð *Ø ::??eÑ #ØØr¿ c ó. | j j S )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ö s r½ r
z Index.is_monotonic_increasing¼ ó ð, ||×3Ñ3Ð3r¿ c ó. | j j S )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ö s r½ r z Index.is_monotonic_decreasingÔ r r¿ c ó6 | j xr | j S )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ö s r½ Ú!_is_strictly_monotonic_increasingz'Index._is_strictly_monotonic_increasingì ó ð ~~Ò> $×">Ñ">Ð>r¿ c ó6 | j xr | j S )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ö s r½ Ú!_is_strictly_monotonic_decreasingz'Index._is_strictly_monotonic_decreasingþ r r¿ c ó. | j j S )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ö s r½ r^ zIndex.is_unique s ðB ||×%Ñ%Ð%r¿ c ó | 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ö s r½ Úhas_duplicateszIndex.has_duplicates3 s ðF >>Ð!Ð!r¿ c ó t j t | « j dt t « ¬« | j dv S )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.r )r ©r6 r7 rL r r8 r6 rü rö s r½ Ú
|
is_booleanzIndex.is_booleanX sG ôH ÜDz×"Ñ"Ð#ð $9ð 9ä Ü'Ó)õ
|
ð ×!Ñ! [Ð0Ð0r¿ c ó t j t | « j dt t « ¬« | j dv S )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ö s r½ rI zIndex.is_integer sG ôH ÜDz×"Ñ"Ð#ð $=ð =ä Ü'Ó)õ
|
ð ×!Ñ! [Ð0Ð0r¿ c ó t j t | « j dt t « ¬« | j dv S )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ö s r½ Ú is_floatingzIndex.is_floating° sH ôX ÜDz×"Ñ"Ð#ð $;ð ;ä Ü'Ó)õ
|
ð ×!Ñ!Ð%VÐVÐVr¿ c ó t j t | « j dt t « ¬« | j dv S )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ö s r½ Ú
|
is_numericzIndex.is_numericä sJ ôX ÜDz×"Ñ"Ð#ð $Eð Eä Ü'Ó)õ
|
ð ×!Ñ!Ð%<Ð<Ð<r¿ c ó t j t | « j dt t « ¬« t | j « S )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 )r6 r7 rL r r8 r6 rM rÉ rö s r½ Ú is_objectzIndex.is_object
|
sE ôR ÜDz×"Ñ"Ð#ð $;ð ;ä Ü'Ó)õ
|
ô tzzÓ*Ð*r¿ c ó t j t | « j dt t « ¬« | j dv S )a
|
Check if the Index holds categorical data.
|
|
.. deprecated:: 2.0.0
|
Use `isinstance(index.dtype, pd.CategoricalDtype)` 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 )Ú categoricalr rö s r½ Úis_categoricalzIndex.is_categoricalI
|
sI ôX ÜDz×"Ñ"Ð#ð $@ð @ä Ü'Ó)õ
|
ð ×!Ñ! _Ð4Ð4r¿ c ó t j t | « j dt t « ¬« | j dv S )a|
|
Check if the Index holds Interval objects.
|
|
.. deprecated:: 2.0.0
|
Use `isinstance(index.dtype, pd.IntervalDtype)` 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ö s r½ Ú is_intervalzIndex.is_interval~
|
sG ôD ÜDz×"Ñ"Ð#ð $=ð =ä Ü'Ó)õ
|
ð ×!Ñ! \Ð1Ð1r¿ c ó | j dv S )z6
|
Whether the type is an integer type.
|
)r r ©rü rö s r½ Ú_holds_integerzIndex._holds_integer¨
|
s ð
|
×!Ñ!Ð%AÐAÐAr¿ c ó t j t | « j dt t « ¬« | j « 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 )r6 r7 rL r r8 r6 r¦ rö s r½ Ú holds_integerzIndex.holds_integer¯
|
sD ô ÜDz×"Ñ"Ð#ð $8ð 8ä Ü'Ó)õ
|
ð ×"Ñ"Ó$Ð$r¿ c óD t j | j d¬« S )zø
|
Return a string of the type inferred from the values.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx
|
Index([1, 2, 3], dtype='int64')
|
>>> idx.inferred_type
|
'integer'
|
F©Úskipna)r Ú infer_dtyper# rö s r½ rü zIndex.inferred_type¿
|
s ô t||°EÔ:Ð:r¿ c ó¬ t | j « ry| j t k7 ry| j ryt t | j « « S )zH
|
Whether or not the index values only consist of dates.
|
TF)rQ rÉ r' rU r rB r# rö s r½ Ú _is_all_dateszIndex._is_all_datesÎ
|
sB ô tzzÔ *ØØ ZZ:Ò %ð Ø ^^ØÜ ¤ ¨t¯|©|Ó!<Ó=Ð=r¿ c ó" t | t « S )zI
|
Cached check equivalent to isinstance(self, MultiIndex)
|
)r r` rö s r½ rU zIndex._is_multiß
|
s ô $¤ Ó.Ð.r¿ c ó\ | j | j d}t t | « |fd fS )N)rÊ rñ )rì rñ rÑ rL )r· rÐ s r½ Ú
|
__reduce__zIndex.__reduce__ê
|
s) ØZZ¨¯©Ñ 3ÜD J¨?¨DÐ0Ð0r¿ c ó® | j }t |t j « r$|j dv rt S t j
|
S |j S )z-The expected NA value to use with this index.ÚmM)rÉ r r! r$ r r~ r ©r· rÉ s r½ rÐ zIndex._na_valueñ
|
s? ð
|
|
Ü eRXXÔ &ØzzTÑ!Ü
|
Ü66MØ~~Ð r¿ c ó² | j r t | « S t j t | « t j
|
¬« }|j d« |S )z.
|
Return if each value is NaN.
|
r F)rÖ rh r! Úemptyr/ Úbool_Úfill)r· rQ s r½ Ú_isnanz Index._isnanû
|
sB ð
|
× Ò Ü:Ð ô XXc $i¬r¯x©xÔ8FØ KKÔ ØMr¿ c ób | j r#t | j j « « S y)aj
|
Return True if there are any NaNs.
|
|
Enables various performance speedups.
|
|
Returns
|
-------
|
bool
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3], index=['a', 'b', None])
|
>>> s
|
a 1
|
b 2
|
None 3
|
dtype: int64
|
>>> s.index.hasnans
|
True
|
F)rÖ rÀ r¹ r« rö s r½ Úhasnansz Index.hasnans s& ð, × Ò Ü Ó)Ó*Ð *àr¿ c ó | 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.
|
|
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ö s r½ rh z
|
Index.isna# s ðj {{Ðr¿ c ó$ | j « 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.
|
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])
|
)rh rö s r½ Únotnaz Index.notna\ s ðT |Ðr¿ c óò t |« s!t dt |« j « |t j
|
ur<t j dt | « j dt t « ¬« nd}| j r`| j | j |« }|!t j || j ¬« S t! t | « j d« | j# « 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).
|
|
.. deprecated:: 2.1.0
|
|
Returns
|
-------
|
Index
|
|
See Also
|
--------
|
DataFrame.fillna : Fill NaN values of a DataFrame.
|
Series.fillna : Fill NaN Values of a Series.
|
|
Examples
|
--------
|
>>> idx = pd.Index([np.nan, np.nan, 3])
|
>>> idx.fillna(0)
|
Index([0.0, 0.0, 3.0], dtype='float64')
|
z"'value' must be a scalar, passed: zThe 'downcast' keyword in zb.fillna is deprecated and will be removed in a future version. It was previously silently ignored.r NrT zF.fillna does not support 'downcast' argument values other than 'None'.)rN rÎ rL r r r r6 r7 r8 r6 r» r} r¹ r rY rñ rC rw )r· r: Údowncastr< s r½ Úfillnaz Index.fillna sã ô> Ô ÜÐ @ÄÀeÃ×AUÑAUÐ@VÐ WÓXÐ XØ 3>>Ñ )Ü MMØ,¬T°$«Z×-@Ñ-@Ð,Að B6ð 6ô Ü+Ó-ö ð Hà <<Ø\\ $§+¡+¨uÓ5FØÐ ô ×(Ñ(¨°d·i±iÐ(Ó@Ð@Ü%Ü:×&Ñ&Ð'ð (5ð 5óð ð zz|Ðr¿ c óÞ |dvrt d| « | j r@| j | j }t | « j || j ¬« S | j « 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
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, np.nan, 3])
|
>>> idx.dropna()
|
Index([1.0, 3.0], dtype='float64')
|
)r« r, zinvalid how option: rT )r1 r» r# r¹ rL r4 rñ rw )r· r± rÜ s r½ Údropnaz Index.dropnaà sd ð( nÑ $Ü Ð 3°C°5Ð 9Ó:Ð :à <<Ø t§{¡{ lÑ3JÜ:×)Ñ)¨*¸4¿9¹9Ð)ÓEÐ EØzz|Ðr¿ c ó || j |« | j r| j « S t | « }| j |« S )aÆ
|
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.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 1, 2, 3, 3])
|
>>> idx.unique()
|
Index([1, 2, 3], dtype='int64')
|
)rf r^ rw Úsuperr rt )r· r² r< Ú __class__s r½ r z Index.uniqueâ sI ø ð6 Ð Ø × &Ñ & uÔ -à >>Ø::<Ð ä Ó!Ø×!Ñ! &Ó)Ð)r¿ rf c ó\ | j r| j « S t | |¬« S )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')
|
rf )r^ rw rÅ Údrop_duplicates)r· rg rÆ s r½ rÈ zIndex.drop_duplicates s, ø ð\ >>Ø::<Ð äwÑ&¨DÐ&Ó1Ð1r¿ c ó | j r$t j t | « t ¬« S | j |¬« S )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 rf )r^ r! Úzerosr/ rÀ Ú _duplicated)r· rg s r½ r zIndex.duplicated9 s5 ðl >>ä88C I¬TÔ2Ð 2Ø× Ñ TÐ Ó*Ð*r¿ c ó | |z S rÔ r½ r{ s r½ Ú__iadd__zIndex.__iadd__w s àe|Ðr¿ c óF t dt | « j d« )NzThe truth value of a zC is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().)r1 rL r rö s r½ Ú __nonzero__zIndex.__nonzero__{ s- äØ#¤D¨£J×$7Ñ$7Ð#8ð 9Cð Có
|
ð
|
r¿ c ó\ t | |« }| j |ur| j |« 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.
|
)r rñ r[ )r· r¸ rñ s r½ Ú_get_reconciled_name_objectz!Index._get_reconciled_name_object s0 ô " $¨Ó.Ø 99DÑ Ø;;tÓ$Ð $Ø r¿ c ó* |dvrt d| d« y )N)NFTzBThe 'sort' keyword only takes the values of None, True, or False; z was passed.©r1 )r· r´ s r½ Ú_validate_sort_keywordz Index._validate_sort_keyword s. à Ð*Ñ *Ü ð)Ø)-¨¨lð<óð ð +r¿ c óÆ t | t « rNt |t « r>| j 2|j &| j d« }|j d« }||fS | |fS )z>
|
With mismatched timezones, cast both to UTC.
|
ÚUTC)r r^ ÚtzÚ
|
tz_convert)r· r¸ Úsetopr¯ Úrights r½ Ú_dti_setop_align_tzszIndex._dti_setop_align_tzs sb ô tÔ -Ô .Ü5Ô"2Ô3ØÐ#ØÐ$ð ?? 5Ó)DØ×$Ñ$ UÓ+EØ;Ð ØU{Ðr¿ c ó | j |« | j |« | j |« \ }}| j |j k7 rt | t
|
« r-t t |« « st |« dkD r t d« | j |d« \ } }| j |« }| j |d¬« }|j |d¬« }|j ||¬« S t |« r| j |« r'| j |« }|du r|j! « S |S t | « s'|j | « }|du r|j! « S |S | j# ||¬« }| j% ||« 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_setoprÉ r r` rM Ú_unpack_nested_dtyper/ rC rÛ Ú_find_common_type_compatr rÝ ÚequalsrÑ rn Ú_unionÚ_wrap_setop_result)r· r¸ r´ Ú result_namerÉ r¯ rÚ r< s r½ rÝ z Index.union sq ðf ×#Ñ# DÔ)Ø ×!Ñ! %Ô(Ø !× 7Ñ 7¸Ó >Ñ{à ::Ò $ä4¤ Ô/Ü'Ô(<¸UÓ(CÔDÜJ Nä)ðCóð ð ×3Ñ3°E¸7ÓCKD%à×1Ñ1°%Ó8EØ;;u¨5;Ó1DØLL ¨ULÓ3EØ::e¨$:Ó/Ð /äUt{{¨5Ô 1ð ×5Ñ5°eÓ<FØt|Ø ×)Ñ)Ó+Ð+ØMäTØ×6Ñ6°tÓ<FØt|Ø ×)Ñ)Ó+Ð+ØMàU¨Ó.à×&Ñ& u¨fÓ5Ð5r¿ c óê | j }|j }|dv r]| j rQ|j rE| j r |j s-| j r!|j r | j |« d S |j s"t j | |« }t! ||« S | j" r(| j% |« } | dk( j' « d }
|
n't j( | j+ |« d « }
|
| j, r!| j/ |j1 |
|
« « } n/t3 |
|
« dkD r |j1 |
|
« } t5 || f« } n|} | j r |j s t! | |« } | S # t
|
t f$ r^ t |« }t |« }|j |D cg c] }||vs| nc c}w c}« t j |t ¬« cY S w xY w)aC
|
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.
|
|
* True : sort the result
|
* 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
|
©NTr r rÕ r@ )r# r
r Ú_can_use_libjoinrè rÎ r r r Úextendr! r0 r r^ r Úunion_with_duplicatesÚ_maybe_try_sortÚ_index_as_uniqueÚ get_indexerÚnonzeroÚunique1dÚget_indexer_non_uniquerU r rÈ r/ rT ) r· r¸ r´ ÚlvalsÚrvalsÚ
|
value_listÚ value_setr© Ú result_dupsÚindexerÚmissingr< Ú
|
other_diffs r½ rä z Index._union' sº ð( Ø ð LÑ Ø×,Ò,Ø×-Ò-Ø×(Ò(¨U×-AÒ-AØ×%Ò%Ø×&Ò&ð
|
|
:Ø×*Ñ*¨5Ó1°!Ñ4Ð4ð ä ×5Ñ5°d¸EÓBKÜ" ;°Ó5Ð 5ð × Ò Ø×&Ñ& uÓ-GØ "}×-Ñ-Ó/°Ñ2Gänn T×%@Ñ%@ÀÓ%GÈÑ%JÓKGð >>à[[ §¡¨GÓ!4Ó5Fô 7|aÒ Ø "ZZ¨Ó 0
|
Ü&¨¨zÐ':Ó;à à×+Ò+°5×3PÒ3Pä$ V¨TÓ2Fà øôS Ô 4Ð5ò :ä ! %[
|
ô J Ø×!Ñ!¨eÖ"J¨°qÀ Ò7I¢1Ñ"JùÔ"JÔKäxx
|
´&Ô9Ò9ð :ús$ Á&F Æ4G2Æ9 G
|
ÇG
|
Ç(G2Ç1G2c ó¨ t | |« }t |t « r"|j |k7 r|j |« }|S | j ||¬« }|S ©NrT )r r r rñ r[ rt )r· r¸ r< rñ s r½ rå zIndex._wrap_setop_resultv sU ä! $¨Ó.Ü feÔ $Ø{{dÒ"Ø tÓ,ð ð ×'Ñ'¨°TÐ'Ó:FØ r¿ c ó~ | j |« | j |« | j |« \ }}| j |j k7 r| j |d« \ } }| j |« rS| j s | j « j |« }n| j |« }|du r|j « }|S t | « dk( st |« dk( r| j s |j r| dd j |« S | j |« }| j |k( r6t | « dk( r| dd j |« S |dd j |« S t g ||¬« S | j |« s1t! | t" « r| dd j |« S t g |¬« S | j |j k7 rJ| j |« }| j% |d¬« }|j% |d¬« }|j' ||¬ « S | j) ||¬ « }| j+ ||« 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ñ rT Fr rÞ )rÔ rß rà rÉ rÛ rã r^ r rÑ rn r/ rU r[ râ r Ú_should_comparer r` r rý Ú _intersectionÚ_wrap_intersection_result)r· r¸ r´ ræ r< rÉ Úthiss r½ rý zIndex.intersection s ð> ×#Ñ# DÔ)Ø ×!Ñ! %Ô(Ø !× 7Ñ 7¸Ó >Ñ{à ::Ò $Ø ×3Ñ3°E¸>ÓJKD%à ;;uÔ Ø>>Ø ×BÑBÀ5ÓIà ×9Ñ9¸%Ó@Øt|Ø ×+Ñ+Ó-ØMä t9>S Z¨1_ð ~~ § ¢ ð BQx {Ó3Ð3à×1Ñ1°%Ó8EØzzUÒ"ô t9 >Ø 8??¨;Ó7Ð7à !9×+Ñ+¨KÓ8Ð8ä 5¨{Ô;Ð ;à×%Ñ% eÔ,ä$¤ Ô.ØBQx {Ó3Ð3Ü +Ô.Ð .à ZZ5;;Ò &Ø×1Ñ1°%Ó8EØ;;u¨5;Ó1DØLL ¨ULÓ3EØ×$Ñ$ U°Ð$Ó6Ð 6à×#Ñ# E°Ð#Ó5Ø×-Ñ-¨e°VÓ<Ð<r¿ c ó° | j r|j r| j r|j rw | j |« \ }}}t | j « r t j |« }t |« S | j |« }|j « }t |« S | j ||¬« }t ||« }|S # t $ r Y ,w xY w)zL
|
intersection specialized to the case with matching dtypes.
|
rÞ ) r
ré rä rL rÉ r rð rÈ rÈ ry rÎ Ú _intersection_via_get_indexerrì ) r· r¸ r´ Ú res_indexerr÷ Ú_Úresr< rÜ s r½ rÿ zIndex._intersectionÖ sÓ ð
|
× (Ò (Ø×-Ò-Ø×%Ò%Ø×&Ò&ð ;Ø*.×*=Ñ*=¸eÓ*DÑ' W aô $ D§J¡JÔ/ô ..¨Ó5Cô 6°cÓ:Ð:ð "YY wÓ /FØ ×0Ñ0Ó2CÜ5°cÓ:Ð:à×7Ñ7¸ÀDÐ7ÓI
|
Ü$ Z°Ó6
|
ØÐøô! ò áð ús ²C Ã CÃCc ó& | j ||« S rÔ ©rå ©r· r¸ r< s r½ r z Index._wrap_intersection_resultô ó à×&Ñ& u¨fÓ5Ð5r¿ c ód | j « }|j « }|j |« }|dk7 }|j |j « d « }|du rt j
|
|« }t |t « r|j |« }|S |j |« j }|S )zÌ
|
Find the intersection of two Indexes using get_indexer.
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray or MultiIndex
|
The returned array will be unique.
|
rÕ r F) r Úget_indexer_forrÈ rï r! r´ r r` r# ) r· r¸ r´ Ú left_uniqueÚ right_uniquer÷ r Útakerr< s r½ r z#Index._intersection_via_get_indexerø s¤ ð kkm Ø ||~ ð ×-Ñ-¨lÓ;à"}à T\\^¨AÑ .Ó/Ø 5=ô GGENEô k¤=Ô 1Ø ×%Ñ% eÓ,Fð ð !×%Ñ% eÓ,×4Ñ4FØ r¿ c ó | j |« | j |« | j |« \ }}| j |« r| dd j |« S t |« dk( r5| j « j |« }|du r|j « S |S | j |« s5| j « j |« }|du r|j « S |S | j ||¬« }| j ||« 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 rn rþ Ú _differenceÚ_wrap_difference_result)r· r¸ r´ ræ r< s r½ Ú
|
differencezIndex.difference sü ðB ×#Ñ# DÔ)Ø ×!Ñ! %Ô(Ø !× 7Ñ 7¸Ó >Ñ{ð ;;uÔ à8?? ;Ó/Ð /ä u:?à[[]×)Ñ)¨+Ó6FØt|Ø ×)Ñ)Ó+Ð+ØMà×#Ñ# EÔ*à[[]×)Ñ)¨+Ó6FØt|Ø ×)Ñ)Ó+Ð+ØMà×!Ñ! %¨dÐ!Ó3Ø×+Ñ+¨E°6Ó:Ð:r¿ c ó | }t | t « r(| j r |j r|j « }|j « }||j |« dk( }|j r|n|j « }t ||« }|S ©NrÕ )r r\ r» rà r r r^ rì )r· r¸ r´ r Úthe_diffs r½ r zIndex._differenceW ss àÜ dÔ /Ô 0°T·\²\ÀeÇmÂmØ;;=DØ Ø×-Ñ-¨dÓ3°rÑ9Ñ:Ø #~~8°8·?±?Ó3DÜ" 8¨TÓ2Ør¿ c ó& | j ||« S rÔ r r s r½ r z Index._wrap_difference_resultb r
|
r¿ c ó¸ | j |« | j |« | j |« \ }}||}| j |j k7 r| j |d« \ } }| j |« s"| j ||¬« j |« S | j |j k7 rY| j |« }| j |d¬« }|j |d¬« }|j ||¬« j |« S | j « }|j « }|j |« }|j |dk7 j « d « } t j t j" |j$ « | d¬« }
|
|j |
|
« } |dk( j « d } |j | « } | j' | « }t) ||« }| j* st- |||j ¬ « S t/ d
|
| « } t1 |« dk( r | j3 « j5 |« S |j5 |« S ) 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')
|
Úsymmetric_differencerÞ Fr rÕ r T)Ú assume_unique©rñ rÉ r )rÔ rß rà rÉ rÛ rþ rÝ r[ râ r r r r rÈ rï r! Ú setdiff1drk Úsizer rì rU r r r/ Úremove_unused_levelsrO )r· r¸ ræ r´ Úresult_name_updaterÉ r Úthatr÷ Úcommon_indexerÚ left_indexerÚ left_diffÚ right_indexerÚ
|
right_diffrÜ r< s r½ r zIndex.symmetric_differencef s ðH ×#Ñ# DÔ)Ø ×!Ñ! %Ô(Ø$(×$>Ñ$>¸uÓ$EÑ!Ð!Ø Ð Ø,Kà ::Ò $Ø ×3Ñ3°EÐ;QÓRKD%à×#Ñ# EÔ*Ø::e¨$:Ó/×6Ñ6°{ÓCÐ Cà ZZ5;;Ò &Ø×1Ñ1°%Ó8EØ;;u¨5;Ó1DØ<< ¨E<Ó2DØ×,Ñ,¨T¸Ð,Ó=×DÑDÀ[ÓQÐ Qà{{}Ø Ø×&Ñ& uÓ-ð ! w°"¡}×&=Ñ&=Ó&?ÀÑ&BÓCÜ||Ü IIdiiÓ .Àô
|
ð IIlÓ+ ð ! B ×/Ñ/Ó1°!Ñ4 ØZZ Ó.
|
à ×%Ñ% jÓ1
|
Ü ¨TÓ2à~~Ü k¸×9IÑ9IÔJÐ Jä \¨9Ó5IÜ6{aÒ à ×5Ñ5Ó7×AÑAÀ+ÓNÐNØ×#Ñ# KÓ0Ð 0r¿ c ó0 t |« s t d« y)Nz!Input must be Index or array-likeT)rK rÎ r{ s r½ rß zIndex._assert_can_do_setop· s äEÔ"ÜÐ ?Ó@Ð @Ør¿ c ó t |t « s't || j ¬« }| j }||fS t | |« }||fS rû )r r rñ r )r· r¸ ræ s r½ rà zIndex._convert_can_do_setop½ sK Ü%¤Ô'Ü% d§i¡iÔ0EØ ))Kð kÐ!Ð!ô -¨T°5Ó9KØkÐ!Ð!r¿ c óX | j |« } | j j |« S # t $ rX}t |t
|
« s,t |t j « r t d |D « « r t |« t |« |d}~wt $ r | j |« w xY w)a
|
Get integer location, slice or boolean mask for requested label.
|
|
Parameters
|
----------
|
key : label
|
|
Returns
|
-------
|
int if unique index, slice if monotonic index, else mask
|
|
Examples
|
--------
|
>>> 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])
|
c 3 ó< K | ] }t |t « y wrÔ )r Úslicer s r½ r z Index.get_loc.<locals>.<genexpr>è s è ø ÒA°
|
1¤e×,ÑAùr N) Ú_maybe_cast_indexerr Úget_locr r r* r r r« r1 rÎ Ú_check_indexing_error)r· ÚkeyÚ
|
casted_keyr> s r½ r, z Index.get_locÈ s ð4 ×-Ñ-¨cÓ2
|
ð Ø<<×'Ñ'¨
|
Ó3Ð 3øÜò )Ü*¤eÔ,Ü:¤s§|¡|Ô4ÜÑA°jÔAÔAä'¨Ó,Ð,Ü3- SÐ (ûÜò ð × &Ñ & sÔ +Ø ð ús . ® B)·AB
|
Â
|
B)c ó t |« }|}| j |« }| j |||« | j st | j
|
« t |« dk( r%t j g t j ¬« S | j |« s%| j |« s| j ||d¬« S t | j t « r¢| j |j k( sJ | j j# |j$ « }| j& rT|j& rHt) |« }| j+ t j, « }|j) « } |||< d|| | z < |S t |j t « r | j# |j. « }
|
t1 j2 |
|
|j$ d¬« }| j4 sL| j& r@|j& r4| j+ t j, « }|j) « } ||| < t7 |« S | j9 |« \ } } | | us| |ur| j# | |||¬« S | j |j k( r?| j; |« r.t j< t |« t j ¬« S | j |j k7 r]| j |« sL| j? |« } | jA | d¬ « }|jA | d¬ « }|jC ||||¬« S | jC ||||« S )
|
a(
|
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 : Index
|
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.
|
|
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 r T©r´ r rÕ ©rË ©r´ ÚlimitÚ toleranceFr )"r Ú _maybe_cast_listlike_indexerÚ_check_indexing_methodrí r1 Ú_requires_unique_msgr/ r! r0 Úintprþ Ú_should_partial_indexÚ_get_indexer_non_comparabler rÉ rV r rî rÇ r» rh r, r~ rý r Útake_ndrU rC Ú _maybe_downcast_for_indexingrã rk râ r Ú _get_indexer)r· Útargetr´ r4 r5 Ú orig_targetr÷ Ú target_nansÚlocr Úcategories_indexerÚpselfÚptargetrÉ r s r½ rî zIndex.get_indexeró sÉ ôt +¨6Ó2Ø Ø×2Ñ2°6Ó:à ×#Ñ# F¨E°9Ô=à×$Ò$Ü# D×$=Ñ$=Ó>Ð >ä v;!Ò Ü88B¤b§g¡gÔ.Ð .à×#Ñ# FÔ+°D×4NÑ4NÈvÔ4Vð ×3Ñ3°FÀ6ÐRVÐ3ÓWÐ Wä djjÔ"2Ô 3ð :: § ¡ Ò-Ð -Ð-àll×.Ñ.¨v¯|©|Ó<GØ|| §¢ô
|
# ;Ó / Øll¤2§6¡6Ó*Ø {{}Ø'* Ñ$Ø/1 |Ñ+Ñ,ØNä fllÔ$4Ô 5ð
|
"&×!1Ñ!1°&×2CÑ2CÓ!DÐ ämmÐ$6¸¿ ¹ ÐQSÔTGàNN t§|¢|¸¿ º ð ll¤2§6¡6Ó*Ø {{}Ø # ä& wÓ/Ð /à ×:Ñ:¸6ÓBwØ Ñ ¨vÑ 5Ø×$Ñ$Ø ¨e¸yð %ó ð ð :: Ò %¨$¯+©+°fÔ*=ä99S [´·±Ô8Ð 8à :: Ò %¨d×.HÑ.HÈÔ.Pð ×1Ñ1°&Ó9Eà;;u¨5;Ó1DØ]] 5¨u]Ó5FØ×$Ñ$Øv¨U¸ið %ó ð ð × Ñ ¨°¸ ÓBÐBr¿ c ó || j ||« }|dv r | j ||||« }t |« S |dk( r | j |||« }t |« S |j r*| j r | j }|j |« }n|j « }| j j |« }t |« S )N©ÚpadÚbackfillÚnearest) Ú_convert_toleranceÚ_get_fill_indexerÚ_get_nearest_indexerrU r Ú_extract_level_codesr rî rC )r· r? r´ r4 r5 r÷ ÚengineÚ
|
tgt_valuess r½ r> zIndex._get_indexerz sÑ ð Ð Ø ×/Ñ/° ¸6ÓBIà Ð(Ñ (Ø×,Ñ,¨V°V¸UÀIÓNGô # 7Ó+Ð+ð yÒ Ø×/Ñ/°¸¸yÓIGô # 7Ó+Ð+ð × Ò D§N¢NØ ð $× 8Ñ 8Øó
|
ð $× 6Ñ 6Ó 8
|
àll×.Ñ.¨zÓ:Gä" 7Ó+Ð+r¿ c ó¤ t | j t « r6t |j t « ry| j j |« S y)z>
|
Should we attempt partial-matching indexing?
|
F)r rÉ rY r¯ rþ ©r· r? s r½ r: zIndex._should_partial_index s; ô
|
djj¤-Ô 0Ü&,,¬ Ô6Ø à99×,Ñ,¨VÓ4Ð 4Ør¿ c óB |dvr t d« | j r!|dk( r t d« |dv r | t d« t | j t
|
t f« r&|$t d| d t | « j « || t d
|
« | t d « yy) zY
|
Raise if we have a get_indexer `method` that is not supported or valid.
|
)NÚbfillrI rH ÚffillrJ zInvalid fill methodrJ zJmethod='nearest' not implemented yet for MultiIndex; see GitHub issue 9365rG 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) r1 rU rC r rÉ rY rV rL r )r· r´ r4 r5 s r½ r7 z Index._check_indexing_method£ så ð ÐOÑ Oô Ð 2Ó3Ð 3à >>ØÒ"Ü)ð<óð ð Ð,Ñ,Ø Ð(Ü-ØFóð ô djj¤=Ô2BÐ"CÔ DàÐ!Ü)Ø fXÐ%>¼tÀD»z×?RÑ?RÐ>SÐTóð ð >ØÐ$Ü ð5óð ð Ð Ü ð5óð ð !ð r¿ c
|
óø t j |« }|j |j k7 r|j dkD r t d« t | « r¦t j
|
|j t j « sx|j dkD r/t dt | « j d| j d« t dt | « 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* r r1 rL Ú
|
issubdtyperÉ ÚnumberrA rL r Úrepr)r· r5 r? s r½ rK zIndex._convert_toleranceÑ sÜ äJJyÓ) Ø ;;)..Ò (¨Y¯^©^¸aÒ-?Ü Ð TÓUÐ UÜ dÔ #¬B¯M©M¸)¿/¹/Ì2Ï9É9Ô,UØ~~ Ò!Ü Ø-¬d°4«j×.AÑ.AÐ-BÀ,ØzzlÐ"SðUóð ô
|
Ø)¬$¨t«*×*=Ñ*=Ð)>¸lÈ4Ï:É:È,ð W6Ü6:¸9³oÐ5FðHóð ð Ðr¿ c óê | j r| j s| j s t d« | j |« j
|
j }t |d t | « « }t |t | « d « }|j ||||« S | j r|j r|j « }| j « } t |t j « rt | t j « st |dk( rt j | ||¬« }
|
n,t j" | ||¬« }
|
n| j% |||« }
|
| t | « r| j' ||
|
|« }
|
|
|
S )Nú0index must be monotonic increasing or decreasingrH ©r4 )rU r
r r1 r r rQ r r/ rL r r r! r" rC ÚlibalgosrH rI Ú _get_fill_indexer_searchsortedÚ_filter_indexer_tolerance) r· r? r´ r4 r5 ÚencodedÚ self_encodedÚtarget_encodedr Ú
|
own_valuesr÷ s r½ rL zIndex._get_fill_indexerã sF ð >>Ø×0Ò0°D×4PÒ4PÜ Ð!SÓTÐTØkk &Ó)×1Ñ1×8Ñ8GÜ ¨¬3¨t«9Ð!5Ó6LÜ " 7¬3¨t«9¨;Ð#7Ó 8NØ ×1Ñ1Ø ¨¨yóð ð × 'Ò '¨F×,JÒ,JØ "× 5Ñ 5Ó 7MØ ×0Ñ0Ó2JÜ m¬R¯Z©ZÔ8Ä
|
ØBJJôAô *Ð)àÜ",, z°=ÈÔNô #×+Ñ+¨J¸ ÈUÔSà×9Ñ9¸&À&È%ÓPGØ Ð ¤S¨¤YØ×4Ñ4°V¸WÀiÓPGØr¿ c óò |t dt |« d« |dk( rdnd}| j |« }|dk( }| j || |« ||< |dk( r||xx dz cc< |S d||t | « k( < |S )z
|
Fallback pad/backfill get_indexer that works for monotonic decreasing
|
indexes and non-monotonic targets.
|
zlimit argument for z; method only well-defined if index and target are monotonicrH r¯ rÚ rÕ r@ )r1 rY rî Ú_searchsorted_monotonicr/ )r· r? r´ r4 Úsider÷ Únonexacts r½ r^ z$Index._get_fill_indexer_searchsorted s¬ ð Ð Ü Ø%¤d¨6£l ^ð 44ð 4óð ð
|
4:¸U²?©Èð ×"Ñ" 6Ó*Øb=Ø × 8Ñ 8¸ÀÑ9IÈ4Ó PÑØ 6>ð
|
HÓ Ñ "Ó ð ð -/GGs 4yÑ(Ñ )Ør¿ c ó¢ t | « s| j |d« S | j |d|¬« }| j |d|¬« }| j ||« }| j ||« }| j rt
|
j nt
|
j }t j |||« |dk( z ||« } || j || |« } | 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).
|
rH r\ rI rÕ ) r/ rL rî Ú_difference_compatr
ÚoperatorÚltÚler! Úwherer_ )
|
r· r? r4 r5 r" r$ Úleft_distancesÚright_distancesÚopr÷ s
|
r½ rM zIndex._get_nearest_indexer& sÕ ô 4yØ×)Ñ)¨&°%Ó8Ð 8à×'Ñ'¨°¸UÐ'ÓC Ø ×(Ñ(¨°À5Ð(ÓI à ×0Ñ0°¸ ÓFØ ×1Ñ1°&¸-ÓHà × 8Ò 8X[[¼h¿k¹kÜ((ñ ~Ó /Ø Ñ"ñ $à Ø ó
|
ð Ð Ø×4Ñ4°V¸WÀiÓPGØr¿ c óZ | j ||« }t j ||k |d« S r )ri r! rm )r· r? r÷ r5 Údistances r½ r_ z Index._filter_indexer_toleranceF s. ð ×*Ñ*¨6°7Ó;äxx IÑ-¨w¸Ó;Ð;r¿ c ó* t | j t « rSt d| j « j
|
}t d|j « j
|
}|| |z
|
}t |« S | j | |j z
|
}t |« S )Nr )r rÉ rZ r rì r r# Úabs)r· r? r÷ rc r Údiffs r½ ri zIndex._difference_compatQ s| ô djj¤+Ô .ä m¨T¯Z©ZÓ8×AÑAJÜ °· ± Ó =× FÑ FMØ gÑ&¨ Ñ6Dô 4yÐð << Ñ(¨6¯>©>Ñ9DÜ4yÐr¿ c ó² | j d|j d« | j d|j d« | j d|j d« y)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· r. s r½ Ú_validate_positional_slicez Index._validate_positional_slicef sF ð × Ñ |¨S¯Y©Y¸Ô?Ø × Ñ |¨S¯X©X°vÔ>Ø × Ñ |¨S¯X©X°vÕ>r¿ c ó@ |j |j |j }}}t |« }t j
|
| j d« rH|dk( r0|r.||k( s)|dk7 r$t j dt t « ¬« | j |||« S |dk( ru|r|S | j j dv rY| j d|j d« | j d|j d« | j d|j d« |S |xr | j }|r) || j |« || j |« d}t# j$ |« r|}|S |r|d k( r t' d
|
« |}|S | j |||« }|S # t $ r Y Ow xY w) 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'}
|
ÚfÚgetitemr zÂThe behavior of obj[i:j] with a float-dtype index is deprecated. In a future version, this will be treated as positional instead of label-based. For label-based slicing, use obj.loc[i:j] insteadr Úiur* FrB zjSlicing a positional slice with .loc is not allowed, Use .loc with labels or .iloc with positions instead.)r rz r{ r} r Ú is_np_dtyperÉ r6 r7 r8 r6 Ú slice_indexerr$ ry Ú _should_fallback_to_positionalr, r r% Ú is_null_slicerÎ ) r· r. r$ r rz r{ Úis_index_sliceÚ is_positionalr÷ s r½ Ú_convert_slice_indexerz Index._convert_slice_indexerp s¯ ð II s§x¡x°·±Ttô 3°3Ó7ô ??4:: sÔ +ð yÒ ¡^¸EÀTºMÈdÐVWÊiô
|
ð/ô "Ü /Ó 1õð ×%Ñ% e¨T°4Ó8Ð 8à 9Ò á à
|
Ø DÑ(à×&Ñ& w°· ± ¸9ÔEØ×&Ñ& w°·±¸)ÔDØ×&Ñ& w°·±¸)ÔDØ
|
ð 'ÒN¨4×+NÑ+N ñ ð àÐ$ØLL Ô'ØÐ#ØLL Ô&Ø % ô × Ñ SÔ !àGð ñ Øu}ä ðLóð ð Gð ð ×(Ñ(¨°°dÓ;Gàøô# ò Ùð ús Ä%(F Æ F Æ F c
|
ó¼ d| dt | « j d| dt |« j }|t j ur t |« |t |« )z;
|
Raise consistent invalid indexer message.
|
z
|
cannot do z indexing on z with these indexers [z
|
] of type )rL r r r rÎ )r· Úformr. Úreraiser` s r½ Ú_raise_invalid_indexerz Index._raise_invalid_indexerÄ sf ð m¬D°«J×,?Ñ,?Ð+@ð AØ Z¬¨S« ×(:Ñ(:Ð';ð =ð ð #..Ñ (ÜC. gÐ -ÜnÐ r¿ c óJ | j st |« r t d« yy)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/ r1 )r· r÷ s r½ Ú_validate_can_reindexzIndex._validate_can_reindexÙ s' ð ×$Ò$¬¨W¬ Ü Ð NÓOÐ Oð *6Ð$r¿ c ó t |d« }t |« }t |t « s4t |« dk( r&| | j
|
r| j | }n| }|dd }n t |« }|Rt | t « st |t « r2| t d« | j ||d| j
|
¬« \ }}} nx| j |« rd}nd| j r| j ||||¬« }nB| j
|
r t d« | j s t d « | j! |« \ }} | j# |||« }||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_orderr3 z'cannot handle a non-unique multi-index!r )r) Úensure_has_lenr r r/ rU r| Ú ensure_indexr` rÎ Ú _join_levelrã rí rî r1 r^ rñ Ú_wrap_reindex_result)
|
r· r? r´ r² r4 r5 Úpreserve_namesrW r÷ r s
|
r½ Úreindexz Index.reindexê sV ôF % V¨VÓ 4Ð4ô Ó'ä&¤%Ô(¬S°«[¸AÒ-=ØÐ T§^¢^àkk %Ñ(àØ!WFä! &Ó)Fà Ð Ü t]Ô +¬z¸&Ä-Ô/PàÐ!Ü Ð KÓLÐLð "&×!1Ñ!1Ø 7¸4¿>¹>Ð7Ið "2ó "Ñ FGQð
|
{{6Ô"Ø à×(Ò(Ø "× .Ñ .Ø v°UÀið /ó Gð ^^Ü$Ð%NÓOÐOØ ä$Ð%VÓWÐWà!%×!<Ñ!<¸VÓ!DJGQà×*Ñ*¨6°7¸NÓKØwÐ r¿ c ó* | j ||« }|S rÔ )Ú_maybe_preserve_names)r· r? r÷ r s r½ r zIndex._wrap_reindex_result[ s Ø×+Ñ+¨F°NÓCØ r¿ c ó |rK|j dk( r<|j | j k7 r#|j d¬« }| j |_ |S )Nr@ Frå )rn rñ r )r· r? r s r½ r zIndex._maybe_preserve_names_ s? Ù fnn°Ò 1°f·k±kÀTÇYÁYÒ6NØ[[ e[Ó,FØ ))FKØ r¿ c ó t |« }t |« dk( r+| dd t j g t j ¬« dfS | j |« \ }}|dk7 }| j || « }d}t |« r}t j t |« t j ¬« }t |« }|j |« }|| } | j || « j }
|
|| } t j t |« ft ¬« }|
|
|| < ||| < t | « s&t j dt j ¬« }nª|j rUt j t |« t j ¬« }t j t |
|
« « || < d|| < nId|| < t j t | j |« « t j ¬« }d|| < t | t « st || j ¬« } n&t# | « j% || j& ¬« } | ||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 rÕ rT r )r r/ r! r0 r9 rñ rÈ rk rC rQ r¶ r r^ r r` r rñ rL r. r ) r· r? r÷ rø ÚcheckÚ
|
new_labelsÚ new_indexerr Úmissing_labelsÚmissing_indexerÚ
|
cur_labelsÚ cur_indexerrá s r½ Ú_reindex_non_uniquezIndex._reindex_non_uniquee sâ ô* fÓ%Ü v;!Ò à8RXX b´·±Ô 8¸$Ð>Ð >à ×6Ñ6°vÓ>ÑØ2 Ø)-¯©°7¸5±>Ó)B
|
Ø ä w<ÜYYs 7|´2·7±7Ô;Fä)¨'Ó2GØ #[[¨Ó 1NØ $ e VnOØ 7¨5¡>Ó2×9Ñ9JØ -Kô ¤3 w£< /¼Ô@JØ&0J{Ñ #Ø*8JÑ 'ô t9Ü ii¨´·±Ô 9 ð ×!Ò!ä ii¬¨G« ¼B¿G¹GÔ D Ü+-¯9©9´S¸³_Ó+E KÑ(Ø/1 OÒ,ð #%ô !ii¬¨D¯I©I°gÓ,>Ó(?ÄrÇwÁwÔ O Ø&( UFÑ#ä$¤ Ô.Ü j¨t¯y©yÔ9Iä T
|
×.Ñ.¨zÀÇÁÐ.ÓLIØ' ;Ð.Ð.r¿ r¶ c ó y rÔ r½ ©r· r¸ r± r² r³ r´ s r½ r¾ z
|
Index.join° ó ð r¿ r° c ó y rÔ r½ r¥ s r½ r¾ z
|
Index.join¼ r¦ r¿ c ó y rÔ r½ r¥ s r½ r¾ z
|
Index.joinÈ r¦ r¿ r¯ c óè t |« }|xs |dk( }t | t « r8t |t « r(| j du |j du z r t d« | j
|
s>|j
|
s2| j |« \ }}|| us||ur|j |||d|¬« S |E| j
|
s |j
|
r-| j |j k( rn| j ||¬« S |,| j
|
s |j
|
r| j |||¬« S t | « dk( st |« dk( r | j |||« S | j |j k7 rK| j |« }| j |d¬ « } |j |d¬ « }| j ||d¬
|
« S t | t « rot |t « r_| j" sS| j$ j' |j$ « s.t) |j* j- | j$ « « }t/ |« | j0 rP|j0 rD| j2 r8|j2 r,| j4 s |j4 r | j7 ||¬« S | j4 r |j4 s| j9 |||¬ « S | j; |||« S # t $ r Y w xY w# t $ r Y .w xY w) 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)
|
|
Examples
|
--------
|
>>> idx1 = pd.Index([1, 2, 3])
|
>>> idx2 = pd.Index([4, 5, 6])
|
>>> idx1.join(idx2, how='outer')
|
Index([1, 2, 3, 4, 5, 6], dtype='int64')
|
ÚouterNz0Cannot join tz-naive with tz-aware DatetimeIndexTr° ©r± r Fr ©r± r³ ©r± r´ ) r r r^ r× rÎ rU r= r¾ r Ú _join_multir r/ Ú _join_emptyrÉ râ r r\ Úorderedrý rã r r# Úreorder_categoriesÚ_validate_join_methodr
ré r^ Ú_join_monotonicÚ_join_non_uniqueÚ_join_via_get_indexer)
|
r· r¸ r± r² r³ r´ rD ÚpotherrÉ r s
|
r½ r¾ z
|
Index.joinÔ s¨ ôF UÓ#ØÒ%sg~ä dÔ ,Ô -´*¸UÔDTÔ2UØ4 E§H¡H°Ð$4Ò5ä Ð RÓSÐSà~~ e§o¢oà × =Ñ =¸eÓ DME6ØDÑ F°%Ñ$7Ø zzØ ¨5À$ÈTð "ó ð ð =dnn°·²àzzU[[Ò(Øà×'Ñ'¨°3Ð'Ó7Ð7ð Ð $§.¢.°E·O²OØ×#Ñ# E¨5°cÐ#Ó:Ð :ä t9>S Z¨1_ð Ø×'Ñ'¨¨s°DÓ9Ð9ð
|
::Ò $Ø×1Ñ1°%Ó8EØ;;u¨5;Ó1DØLL ¨ULÓ3EØ99U¨¸T9ÓBÐ Bä tÔ 0Ô 1Ü5Ô"5Ô6ØLLØOO×*Ñ*¨5×+;Ñ+;Ô<ô %--×:Ñ:¸4¿?¹?ÓKÓLEä cÔ"ð × (Ò (Ø×-Ò-Ø×%Ò%Ø×&Ò&Ø 5§?¢?ð Ø×+Ñ+¨E°sÐ+Ó;Ð;ð u§¢Ø×(Ñ(¨°C¸dÐ(ÓCÐ Cà×)Ñ)¨%°°dÓ;Ð;øôG ò âð ûô: ò áð ús$ Ä9K ÊK% Ë K"Ë!K"Ë% K1Ë0K1c óJ t | « dk( st |« dk( sJ t |« t |« r;t t dddj ||« « }|j | ||« \ }}}n°|dv ru|r.| j s"| j « }| j |« }nd }| j « }t j t j d« t |« « }n7|j « }t j g t j ¬« }d }|||fS )Nr rÚ r¯ ©r¯ rÚ )r¯ rª rÕ r )r/ r² r r( rú r¯ r
ÚargsortrÈ rw r! Ú broadcast_tor9 r0 )r· r¸ r± r´ r¹ r» rº s r½ r¯ zIndex._join_empty< sò ô 4yA~¤ U£¨q¢ Ð0Ð0Ü cÔ"ô
|
u:Üw¨¸6Ñ B× FÑ FÀsÈCÓ PÓQCØ%*×%6Ñ%6°t¸SÀ$Ó%GÑ "JdØ Ð%Ñ %ÙD× 8Ò 8Ø||~Ø !YY t_
|
àØ !ZZ\
|
Ü??¤2§7¡7¨2£;´°J³Ó@Dà JÜ88B¤b§g¡gÔ.DØDØ4 Ð%Ð%r¿ c ó² |dk( r|r| j « n| }nL|dk( r|r|j « n|}n2|dk( r| j ||¬« }n|dk( r | j ||¬« }| u rd }n| j |« }||u rd }n|j |« }|||fS # t $ r1 | j |« } t ||« }n# t $ r Y nw xY wY nw xY w)Nr¯ rÚ ÚinnerrÞ rª )rn rý rÝ rÎ rì r )r· r¸ r± r´ r¹ ÚlindexerÚrindexers r½ rµ zIndex._join_via_get_indexerW sû ð &=Ù/3×)Ñ)Ô+¸JØ G^Ù04×*Ñ*Ô,¸%JØ G^Ø ×*Ñ*¨5°tÐ*Ó<JØ G^ð Ø !ZZ¨°DZÓ 9
|
ð Ñ ØHà×+Ñ+¨JÓ7HØ Ñ ØHà ×,Ñ,¨ZÓ8HØ8 XÐ-Ð-øô ò Ø !ZZ¨Ó .
|
ðÜ!0°¸TÓ!BJøÜ ò Ùðüð ús6 ÁB  CÂ7 CÃCà Cà CÃCÃCÃCc ó ddl m} ddlm} t t j | j « }t t j |j « }|j }|j }t |« } t |« }
|
| |
|
z } | s t d« t | |« rêt ||« rÞt | | z
|
|¬« } t |
|
| z
|
|¬« } t | | z « s | }|j | j « }n"| j | « }|j | « }|j! ||d¬« \ }}}| | z } || |||||« \ }}} ||||d¬ « }|j# « }|d
|
k( r|| z }n|| z }|j |« }|||fS t% t' | « « }d}t | |« r || }} d}d d
|
d }|j) ||« }|j j |« } | j+ || |¬ « } |r| d | d | d fS | S )Nr r )Ú restore_dropped_levels_multijoinz+cannot join with no overlapping index names)r. Tr¬ Fr{ rÚ r¯ ©rÚ r¯ r« r r@ )r- r Úpandas.core.reshape.mergerÀ r r% Únot_noner r r r1 r rv r/ Úreorder_levelsry r¾ r ÚnextÚiterrú r ) r· r¸ r± r rÀ Úself_names_listÚother_names_listÚself_names_orderÚother_names_orderÚ
|
self_namesÚ other_namesÚoverlapÚ ldrop_namesÚ rdrop_namesÚ self_jnlevelsÚother_jnlevelsÚjoin_idxrº r» Ú dropped_namesr| rÇ r Úmulti_join_idxÚ level_orderÚjlÚ
|
flip_orderÚflipr² r< s r½ r® zIndex._join_multiz sE å8ÝNô s||¨T¯Z©ZÐ 8Ó9Ü ¤§ ¡ ¨e¯k©kÐ :Ó;ÐØ*×0Ñ0ÐØ ,× 2Ñ 2ÐÜ Ó)
|
ÜÐ*Ó+ Ø {Ñ*ñ Ü Ð JÓKÐ Kä dJÔ '¬J°u¸jÔ,Iä ¨gÑ!5Ð;KÔLKÜ ¨wÑ!6Ð<MÔNKô { [Ñ0Ô1Ø $ Ø!&×!5Ñ!5°d·j±jÓ!Aà $§¡¨{Ó ; Ø!&§ ¡ °Ó!=ð $1×#5Ñ#5Ø C¸ð $6ó $Ñ HdDð (¨+Ñ 5Mñ
|
$DØØØ ØØØó $Ñ FE5ñ (Ø U°%È%ô Nð ,× @Ñ @Ó BNð g~Ø .°Ñ < à -° Ñ ; Ø +× :Ñ :¸;Ó GNà! 4¨Ð-Ð -ä $w-Ó ð
|
Ü dJÔ 'Ø %DØ Jà5;ÀWÑ+MDØ((3 Ó$Cà ×!Ñ! "Ó%Ø×!Ñ! %¨°CÐ!Ó8á Ø!9f Qi¨°©Ð2Ð 2Ø r¿ c óP ddl m} | j |j k( sJ || j |j ||¬« \ }}|dk( }| j |« }|j |« } |j || « }
|
t |
|
t « r|dk( r|
|
j « }
|
|
|
||fS )Nr )Ú get_join_indexers_non_uniquer rÕ rª ) r rÚ rÉ r# rÈ r} r r` rb ) r· r¸ r± r´ rÚ Úleft_idxÚ right_idxr rÒ rÚ r¹ s r½ r´ zIndex._join_non_uniqueÓ s¤ õ Kð zzU[[Ò(Ð(Ð(á :Ø LL%--¨S°tô
|
Ñ)ð 2~à99XÓ&Ø
|
|
9Ó%Ø ×%Ñ% d¨EÓ2
|
Ü j¤-Ô 0°S¸G²^à#×:Ñ:Ó<JØ8 YÐ.Ð.r¿ c ó^ ddl m} dd}t | |« rt ||« r t d« | |}}t | |« } | r||}}ddd}
|
|
|
j ||« }t ||« sJ |j |« }|j | } |j s t d« | j ||d ¬
|
« \ } } }| 5|st |« dk( rd }|}nñ ||j d |d z « }|| }nÒt | « } t j | t | « « }|j | }||d k7 }|j |« }t! |j « }|||< t! |j « }| ||< |rut# j$ t |« t" j& ¬« }t) t" j* |« }|d k7 }|j- « s×|D cg c] }|| }}|| }n¿|dk( rYt |« dk( rdn|j/ « }d |z }t1 j2 ||« \ }}||d d }|D cg c] }|| }}na|d k7 }|j- « } | s|D cg c] }|| }} ||d |d z « }|D cg c] }|| }}| s|j5 « d | } ||||j6 d¬« }| |j |j | « } n|j | } | r| |} }|d n
|
t |« }| d n
|
t | « } ||| fS c c}w c c}w c c}w c c}w )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 c ó¼ | d j dk( r%t j dt j ¬« S t | « dk( rt t | d « « S | d dd | d dd k7 }| dd D ] }||dd |dd k7 z } t j dg|dgf« j « d }t | d « }t j |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@ NrÕ T) r r! r¶ r9 r/ r rC Úhstackrï rA r Úget_level_sorter)rÆ ÚticÚlabÚstartss r½ Ú_get_leaf_sorterz+Index._join_level.<locals>._get_leaf_sorterø sê ð ay~~ Ò"Üxx ¬¯©Ô1Ð1ä6{aÒ Ü-Ô.AÀ&ÈÁ)Ó.LÓMÐMð )CR. F¨1¡I¨a¨b MÑ1CØ a |ò +Øs3Bx 3 q r 7Ñ*Ñ*ð +ô YY ¨¨d¨VÐ 4Ó5×=Ñ=Ó?ÀÑBFÜ v bzÓ*CÜ×'Ñ'¨Ô-@ÀÓ-HÓIÐ Ir¿ z9Join on level between two MultiIndex objects is ambiguousr¯ rÚ rÁ z8Index._join_level on non-unique index is not implementedTr¬ Nr@ rÕ r Fr{ )rÆ zlist[np.ndarray]Úreturnúnpt.NDArray[np.intp]) r- r r rÎ rú ri r| r^ rC r¾ r/ rÇ rC r Úget_reverse_indexerrÈ r r! rk r9 r r" r, Úmaxr] Úgroupsort_indexerrï r ) r· r¸ r² r± r r rä r¯ rÚ r× rØ Ú old_levelÚ new_levelÚleft_lev_indexerÚright_lev_indexerr" r¹ Ú rev_indexerÚ old_codesr Ú new_lev_codesr r r râ Ú max_new_levÚngroupsÚcountsÚmask_allr$ s r½ r zIndex._join_levelé s õ 9ó Jô< dJÔ '¬J°u¸jÔ,IÜÐ WÓXÐ XàEeä# D¨*Ó5Ð5
|
Ù Ø %DØ5;ÀWÑ+MDØ((3 Ó$Cä$
|
Ô+Ð+Ð+à×&Ñ& uÓ-ØKK Ñ& àÜ%ØJóð ð :C¿ ¹ Ø s¨Dð :Hó :
|
Ñ6 Ð#Ð%6ð Ð #ÙS Y¨!^Ø # Ø !
|
á /°·
|
±
|
¸;¸UÀQ¹YÐ0GÓ H Ø ! ,Ñ /
|
ô 3Ð3CÓ DÐ Ü ×1Ñ1Ð2BÄCÈ ÃNÓSKØ
|
|
5Ñ)Ià i¨2oÑ.EØ '× ,Ñ ,¨UÓ 3Mä TZZÓ(IØ ,IeÑ ä dkkÓ*JØ )JuÑ áÜ !yy¬¨T«¼"¿'¹'Ô B Ü #¤B§J¡J° Ó = Ø$¨Ñ*ØxxzØ6?Ö @¨s T£Ð @IÐ @Ø#/°Ñ#5Lð A:Ü'*¨=Ó'9¸QÒ'>¡!ÀM×DUÑDUÓDWKØ +oGÜ+3×+EÑ+EØ% wó,Ñ(L &ð
|
$0°°q± ° Ð#<LØ>GÖ H°s \Ó!2Ð HIÑ Hð )¨BÑ.DØ #xxzHÙ#Ø:CÖ$D°3 S¨£YÐ$D Ð$Dá#3°I¸kÀÈÁ Ð4JÓ#KLØ>GÖ H°s \Ó!2Ð HIÐ Hñ $Ø'+§|¡|£~°aÑ'8¸ Ñ'F á#Ø!Ø ØjjØ!&ô Jð Ð (Ø -× 2Ñ 2°:×3CÑ3CÀEÑ3JÓ KMà &× ,Ñ ,¨UÑ 3Má Ø*7¸ -Lð !Ð(DÔ.AÀ,Ó.Oð ð "Ð)DÔ/BÀ=Ó/Qð ð <¨ Ð6Ð6ùòe !Aùò !Iùò %Eùò !Is Ç LÈ< L É& L%Ê L*c óX |j | j k( sJ | j r |j sJ | j |« r|dk( r|n| }|d d fS | j r¡|j r|dk( r| }d }| j |« }n |dk( r|}|j | « }d }nå|dk( r*| j |« \ }}}| j ||||« }n¶|dk( r±| j |« \ }}}| j ||||« }n|dk( r| j |« \ }}}nP|dk( r|j | « \ }}}n5|dk( r| j |« \ }}}n|dk( r| j |« \ }}}J J | j |||« }d n
|
t |« }d n
|
t |« }||fS )NrÚ r¯ r¼ rª )
|
rÉ ré rã r^ rÚ rä Ú_wrap_joined_indexrè rá rC )r· r¸ r± Ú ret_indexr¹ rº r» Ú
|
join_arrays r½ r³ zIndex._join_monotonic~ sç ð
|
{{djjÒ(Ð(Ð(Ø×$Ò$¨×)?Ò)?Ð?Ð?à ;;uÔ ð "%¨¢ °TIØ d DÐ(Ð (ð
|
>>eooàf}Ø !
|
ØØ×0Ñ0°Ó7Ø Ø "
|
Ø ×1Ñ1°$Ó7ØØ Ø)-×)<Ñ)<¸UÓ)CÑ&
|
D $Ø !× 4Ñ 4°ZÀÈÈdÓ S
|
Ø Ø)-×)<Ñ)<¸UÓ)CÑ&
|
D $Ø !× 4Ñ 4°ZÀÈÈdÓ S
|
àf}Ø)-×);Ñ);¸EÓ)BÑ&
|
D¡$Ø Ø).×)<Ñ)<¸TÓ)BÑ&
|
D¡$Ø Ø)-×)<Ñ)<¸UÓ)CÑ&
|
D¡$Ø Ø)-×)<Ñ)<¸UÓ)CÑ&
|
D $àÐ#Ð #Ð#ØÐ#Ð #Ð#à ×0Ñ0°¸UÀDÈ$ÓOJà|tÔ)<¸TÓ)BØ|tÔ)<¸TÓ)BØ4 Ð%Ð%r¿ c óÒ |j | j k( sJ t | t « r| j |j k( r | j nd }|dk( }| j |« }t d|j |« « }|j ||« j « } | j |« S t | |« }| j j ||| j ¬« S )NrÕ r r ) rÉ r r` r rÈ r r} rb rO r r[ rY )
|
r· rà r¸ rº r» rñ r rÒ rÚ r¹ s
|
r½ rö zIndex._wrap_joined_index³ sÅ ð {{djjÒ(Ð(Ð(ä dMÔ *Ø!%§¡¨u¯{©{Ò!:4::ÀDð 2:DØyy HÜ u§z¡z°$Ó'7Ó8EØ!×)Ñ)¨$°Ó6×MÑMÓOJØ ×'Ñ'¨Ó-Ð -ä% d¨EÓ2DØ×$Ñ$×0Ñ0°¸dÈ$Ï*É*Ð0ÓUÐ Ur¿ c óL t | « t u r}t | j t j « xsW t | j
|
t t f« xs5 t | j t « xr | j j dk( S t | t t f« S )aG
|
Whether we can use the fastpaths implemented in _libs.join.
|
|
This is driven by whether (in monotonic increasing cases that are
|
guaranteed not to have NAs) we can convert to a np.ndarray without
|
making a copy. If we cannot, this negates the performance benefit
|
of using libjoin.
|
Úpython) rL r r rÉ r! r# ro rp rv Ústorager_ r` rö s r½ ré zIndex._can_use_libjoinÉ s ô :Ñ ô 4::¤r§x¡xÓ0ò Ü dllÔ-@Ä/Ð,RÓSòô tzz¬;Ó7ò 7Ø
|
|
×*Ñ*¨hÑ6ð ô dÔ%5´}Ð$EÓFÐFÐFr¿ c óÀ t « rI| j }t |t j « r!|j « }d|j _ |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.
|
|
Examples
|
--------
|
For :class:`pandas.Index`:
|
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx
|
Index([1, 2, 3], dtype='int64')
|
>>> idx.values
|
array([1, 2, 3])
|
|
For :class:`pandas.IntervalIndex`:
|
|
>>> idx = pd.interval_range(start=0, end=5)
|
>>> idx.values
|
<IntervalArray>
|
[(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]]
|
Length: 5, dtype: interval[int64, right]
|
F)r rì r r! r" rÁ ÚflagsÚ writeable)r· rÊ s r½ rQ z Index.valuesê sH ôL Ô Ø::DÜ$¤§
|
¡
|
Ô+Øyy{Ø',
|
|
Ô$ØKØzzÐr¿ c ón | j }t |t j « rddlm} ||« }|S )Nr )ÚNumpyExtensionArray)rì r r! r" Úpandas.core.arrays.numpy_r )r· r0 r s r½ r0 z Index.array s- ð
|
|
Ü eRZZÔ (Ý Eá'¨Ó.EØ r¿ c ó | 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ö s r½ r# z Index._values" s ð0 zzÐr¿ c óJ | j }t |t « r |j S t |t « r¾| j
|
j dv r¦ddl}|j j }|j j |« r+|j « }|j j d« S |j j |« r+|j « }|j j d« S t | « t u rt | j t" « rt | j t$ « sgt | j t « r.t' | j
|
« r| j
|
j dk7 s | j j) t* « S |S )zl
|
Get the ndarray or ExtensionArray that we can pass to the IndexEngine
|
constructor.
|
r r NÚi8rI )r# r ru r ro rÉ r$ r
r rL r r r rÁ r r r rs rp rL r r )r· Úvalsr r s r½ r zIndex._get_engine_target< s& ð
|
||Ü dKÔ (à==Ð Ü dÔ /Ô 0°T·Z±Z·_±_ÈÑ5LÛ ànn×)Ñ)GØxx×$Ñ$ WÔ-Ø×-Ñ-Ó/Ø}}×)Ñ)¨$Ó/Ð/Ø×%Ñ% gÔ.Ø×.Ñ.Ó0Ø}}×)Ñ)¨$Ó/Ð/ä J%Ñ Ü4<<¬ Ô8Ü t||¬_Ô=ä4<<Ô)<Ô=Ü$ T§Z¡ZÔ0àJJOO sÒ*ð <<×&Ñ&¤vÓ.Ð .Ø r¿ c ó8 t | j t « r| j j S t | j t « r| j j « S | j « }t |t j « s t d« |S )zc
|
Get the ndarray or ExtensionArray that we can pass to the join
|
functions.
|
z%_can_use_libjoin should return False.)
|
r r# rp rì ro Úto_numpyr r! r" r1 rR s r½ rÕ zIndex._get_join_target^ su ô dll¤OÔ 4à<<×%Ñ%Ð %Ü Ô&9Ô :ð <<×(Ñ(Ó*Ð *ð ×(Ñ(Ó*Ü&¤"§*¡*Ô-Ü Ð DÓEÐ EØ r¿ c ól t | j t « rI t | j « |t j
|
|j t j ¬« « S t | j t t f« r0t | j « j || j ¬« S |S )z{
|
Cast the ndarray returned from one of the libjoin.foo_indexer functions
|
back to type(self._data).
|
r ) r rQ rp rL r! rÊ Úshaper· ro ru rÆ rÉ rv s r½ rÝ zIndex._from_join_targetr sy ô
|
dkk¤?Ô 3Ø$4 Ó$ V¬R¯X©X°f·l±lÌ"Ï(É(Ô-SÓTÐ TÜ Ô&9¼;Ð%GÔ HÜ Ó$×3Ñ3°FÀ$Ç*Á*Ð3ÓMÐ MØ r¿ c óh | j |¬« }|| j j |¬« z }|S )Nrå )Ú _memory_usager Úsizeof)r· rÞ r< s r½ Ú memory_usagezIndex.memory_usage} s8 à×#Ñ#¨Ð#Ó.ð $,,×%Ñ%¨4Ð%Ó0Ñ0Ø r¿ c ó t | t « r t d« t j |t
|
¬« }| j | |« 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` rC r! r* rÀ r} )r· Úcondr¸ s r½ rm z Index.where
sD ôB dMÔ *Ü%ØCóð ô zz$¤dÔ+Ø||TE 5Ó)Ð)r¿ c ó t | j dt |t j « s t |« n
|
t |« d« )Nz5(...) must be called with a collection of some kind, z was passed)rÎ r r r! ÚgenericrY ré )rÏ rÊ s r½ r( z Index._raise_scalar_data_error® sG ô
|
Ø||nð Ü'1°$¼¿
|
¹
|
Ô'CT$ZÌÈTËÐSð Tð ó
|
ð
|
r¿ c óð | j }t |t j « r|j dvr t ||« S t | j |« st |S # t
|
$ r }t |d}~ww xY w)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@ r: rÎ r; r# )r· r: rÉ r> s r½ Ú_validate_fill_valuezIndex._validate_fill_value¹ sl ð
|
|
Ü eRXXÔ &¨5¯:©:¸TÑ+Að )Ü*¨5°%Ó8Ð8ô " $§,¡,°Ô6ÜOØ øô %ò )ä SÐ(ûð )ús ¶ A Á A5Á)A0Á0A5c ó t | j « xs0 t | j « xr | j j dk( S )zH
|
Return a boolean if we need a qualified .info display.
|
rû )rM rÉ rP rü rö s r½ Ú_is_memory_usage_qualifiedz Index._is_memory_usage_qualifiedÏ s: ô tzzÓ*ò
|
Ü DJJÓ 'Ò J¨D¯J©J×,>Ñ,>À(Ñ,Jð
|
r¿ c ój t |« || j v S # t t t f$ r Y yw xY w)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
|
F)Úhashr Ú OverflowErrorrÎ r1 r| s r½ Ú __contains__zIndex.__contains__× s9 ôF S ð Ø$,,Ð&Ð &øÜ y¬*Ð5ò Ùð ús 2±2zClassVar[None]Ú__hash__c ó t d« )Nz)Index does not support mutable operations©rÎ )r· r. r: s r½ Ú __setitem__zIndex.__setitem__ s äÐCÓDÐDr¿ c óô | j j }t |« s t |« r t j
|
|« } ||« S t |t « r| j |« S t j |« r±t t |dd« t « r|j t d¬« }nt j |t ¬« }t | j t « sIt# |« dk( r;t# |« t# | « k7 r$t% j& dt( t+ « ¬« ||« }|j, d kD r t/ |« | j0 j3 || j4 ¬
|
« S ) 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.
|
|
rÉ NF)rÉ r r r z~Using a boolean indexer with length 0 on an Index with length greater than 0 is deprecated and will raise in a future version.r r@ rT )rì Ú __getitem__rI rG r% Úcast_scalar_indexerr r* Ú_getitem_sliceÚis_bool_indexerr rX r rÀ r! r* rÉ r/ r6 r7 r8 r6 rA r| r[ r4 rï )r· r. r r< s r½ r zIndex.__getitem__ s ð **×(Ñ(ä c?h smä×)Ñ)¨#Ó.CÙ3<Ð ä c5Ô !ð ×&Ñ& sÓ+Ð +ä × Ñ sÔ #ô
|
' # w°Ó5´~ÔFØll¬¸lÓ>äjj ¬DÔ1ä djj¬.Ô9Üs8q=¤S¨£X´°T³Ò%:Ü MMð*ô &Ü#3Ó#5õ ñ à ;;?Ü " 6Ô *ð × Ñ ×,Ñ,¨V¸$¿*¹*Ð,ÓEÐEr¿ c ó. | j | }t | « j || j | j ¬« }d| j
|
v rF|j duxr |j dk }|j j | j |¬« |S )zH
|
Fastpath for __getitem__ when we know we have a slice.
|
rs r Nr )Úreverse) rì rL r4 rï r rN r{ r Ú_update_from_sliced)r· Úslobjr r< r% s r½ r" zIndex._getitem_slice= s~ ð jjÑ Üd×'Ñ'¨°$·*±*À4×CSÑCSÐ'ÓTØ Ñ #Øjj¨Ð,Ò?°·±¸a± GØ NN× .Ñ .¨t¯|©|ÀWÐ .Ô Mà r¿ c ó t | j « s/t | j « st | j t « r|| v S y)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)rM rÉ rP r rV )r· rñ s r½ Ú$_can_hold_identifiers_and_holds_namez*Index._can_hold_identifiers_and_holds_nameI s8 ô DJJÔ 'Ü tzzÔ*Ü$**Ô&6Ô7à4<Ð Ør¿ c óP | g}t |t t f« r|t |« z }n|j |« |D ] }t |t « rt d« |D ch c] }|j }}t |« dkD rdn | j }| j ||« S c c}w )a_
|
Append a collection of Index options together.
|
|
Parameters
|
----------
|
other : Index or list/tuple of indices
|
|
Returns
|
-------
|
Index
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx.append(pd.Index([4]))
|
Index([1, 2, 3, 4], dtype='int64')
|
zall inputs must be Indexr@ N) r r r
|
r r rÎ rñ r/ Ú_concat)r· r¸ Ú to_concatÚobjr rñ s r½ r z Index.append[ s ð$ F ä ed¤E]Ô +Ø eÑ $Ið × Ñ UÔ #à ò <CÜ c¤5Õ)Ü Ð :Ó;Ð;ð <ð &/Ö/cÐ/Ð/Ü5z A~t¨4¯9©9à||I tÓ,Ð,ùò 0s Á B#c ó |D cg c] }|j }}t |« }t j ||¬« S c c}w )z5
|
Concatenate multiple Index objects.
|
rT )r# rT r rY )r· r, rñ r© Úto_concat_valsr< s r½ r+ z Index._concat s@ ð .7Ö7¨!))Ð7Ð7ä ~Ó.ä× Ñ ¨dÐ Ó3Ð3ùò 8s
<c óÎ t | j |« \ }}|r| j « S | j t k7 r"t || j « r | j } | j |« }| j j « }t |t j" « r3t% ||j' « |« }t! j |||« n|j) ||« | j+ |« S # t t t f$ rS}t | j « r|| j |« }| j |« j ||« cY d}~S d}~ww xY w)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.
|
|
Examples
|
--------
|
>>> idx1 = pd.Index([1, 2, 3])
|
>>> idx2 = pd.Index([5, 6, 7])
|
>>> idx1.putmask([True, False, False], idx2)
|
Index([5, 2, 3], dtype='int64')
|
N)rn r# r rÉ r rg rÐ r r: r1 rÎ rM râ r r} r r! r" rm ÚsumÚ_putmaskrt )r· r r: ÚnoopÚ convertedr> rÉ rQ s r½ r} z Index.putmask s ô( & d§l¡l°DÓ9
|
dÙ Ø99;Ð à ::Ò Ô$9¸%ÀÇÁÔ$LàNNEð ;Ø ×1Ñ1°%Ó8Ið ×"Ñ"Ó$ä fbjjÔ )Ü3°F¸D¿H¹H»JÈ ÓRIÜ JJvt YÕ /ð
|
OOD %Ô (à×!Ñ! &Ó)Ð)øô' "¤:¬yÐ9ò ;Ü tzzÔ*Ø ð ×1Ñ1°%Ó8EØ;;uÓ%×-Ñ-¨d°EÓ:Õ :ûð ;ús Á"C= Ã=E$ÄAE ÅE$Å E$c ó | j |« ryt |t « syt | « t |« k7 ryt | j t
|
« rc| j j t j u r=|j | j k7 r$|j | j t « « S t | j « r&t |j « s|j | « S t |t « r|j | « S t | j t « rKt |t! | « « syt# t | j$ « }|j |j$ « S t |j t& « r|j | « S t) | j |j « S )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 r/ rÉ rv r r! r~ rã r r rM r` r# rs rL r rì rX rf )r· r¸ Úearrs r½ rã z Index.equals¼ s6 ðv 88E?Øä%¤Ô'Øä t9E
|
Ò "àô tzz¤;Ô /Ø
|
|
×#Ñ#¤r§v¡vÑ-Ø tzzÒ)ð << § ¡ ¬FÓ 3Ó4Ð 4ä 4::Ô &¬¸u¿{¹{Ô/Kà<< Ó%Ð %ä e]Ô +à<< Ó%Ð %ä dll¤NÔ 3ä e¤T¨$£ZÔ0Ø ä¨¯
|
©
|
Ó3DØ;;u{{Ó+Ð +ä ekk¤>Ô 2à<< Ó%Ð %ä § ¡ ¨e¯m©mÓ<Ð<r¿ c óÒ j « xrS t fd j D « « xr2 t « t « k( xr j j k( S )a=
|
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.
|
|
Examples
|
--------
|
>>> idx1 = pd.Index(['1', '2', '3'])
|
>>> idx2 = pd.Index(['1', '2', '3'])
|
>>> idx2.identical(idx1)
|
True
|
|
>>> idx1 = pd.Index(['1', '2', '3'], name="A")
|
>>> idx2 = pd.Index(['1', '2', '3'], name="B")
|
>>> idx2.identical(idx1)
|
False
|
c 3 óT K | ] }t |d « t |d « k( ! y wrÔ )r )r r r¸ r· s r½ r z"Index.identical.<locals>.<genexpr>9 s0 øè ø ò àô a Ó&¬'°%¸¸DÓ*AÕAñùs %()rã r, ró rL rÉ r{ s ``r½ Ú identicalzIndex.identical sd ù ð0 KKÓ ò *Üô à ×*Ñ*ôó ò *ô
|
T
|
d 5kÑ)ò *ð
|
|
ekkÑ)ð
|
r¿ c ó | j |« | j |« }t |t « r |j t | « « d }| | S # t t f$ rg | j |gd¬« }|j dkD s|j dkD r t d« |j « }|dk( r| j cY S Y | | S w xY w)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
|
rÕ rH ©r´ r@ z!asof requires scalar valued input) re r, r r* rÑ r/ r rÎ rî rA r ÚitemrÐ )r· ri rB r÷ s r½ Úasofz
|
Index.asofA sÒ ðr ×$Ñ$ UÔ+ð 1Ø,,uÓ%Cô #uÔ%Økk¤# d£)Ó,¨RÑ0àCyÐøô )Ð$ò &ð ×&Ñ&¨ w°uÐ&Ó=GØ||aÒ 7§<¡<°!Ò#3Ü Ð CÓDÐDØ,,.CØbyØ~~Ò%ð ð CyÐð &ús A ÁA-C à C c ó~ | j | j |j d¬« }t j |dkD |dz
|
d« }t j t | « t j ¬« | j |« }| j |j « }d||dk( |j |k z < |S )az
|
Return the locations (indices) of labels in the index.
|
|
As in the :meth:`pandas.Index.asof`, 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 :meth:`pandas.Index.asof`
|
for every element in ``where``.
|
|
See Also
|
--------
|
Index.asof : Return the label from the index, or, if not present, the
|
previous one.
|
|
Examples
|
--------
|
>>> idx = pd.date_range('2023-06-01', periods=3, freq='D')
|
>>> where = pd.DatetimeIndex(['2023-05-30 00:12:00', '2023-06-01 00:00:00',
|
... '2023-06-02 23:59:59'])
|
>>> mask = np.ones(3, dtype=bool)
|
>>> idx.asof_locs(where, mask)
|
array([-1, 0, 1])
|
|
We can use ``mask`` to ignore certain values in the index during calculation.
|
|
>>> mask[1] = False
|
>>> idx.asof_locs(where, mask)
|
array([-1, 0, 0])
|
rÚ ©rf r r@ r rÕ ) r# Ú searchsortedr! rm rk r/ r9 rÈ Úargmax)r· rm r Úlocsr< Ú first_values r½ Ú asof_locszIndex.asof_locs s¥ ðj ||DÑ!×.Ñ.Ø MM ð /ó
|
ô xxq $¨¡(¨AÓ.ä3t9¬B¯G©GÔ4°TÑ:×?Ñ?ÀÓEàll 4§;¡;£=Ñ1 Ø>@ emm¨kÑ 9Ñ:Ñ;à r¿ )rk rl rm r. c ó y rÔ r½ ©r· rk rl rm r. s r½ rn zIndex.sort_valuesÎ ó ð r¿ )rl rm r. c ó y rÔ r½ rF s r½ rn zIndex.sort_valuesÙ rG r¿ c ó y rÔ r½ rF s r½ rn zIndex.sort_valuesä rG r¿ rn c óÀ |n|r | j s|s^| j rR|r@t j t | « t j
|
¬« }| j « |fS | j « S t | t « st | |||¬« }n6t t t | |« « }|j |¬« }|s|ddd
}| j |« }|r||fS |S )aD
|
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.
|
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.
|
|
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]))
|
Nr )Úitemsrl rm r. )rm rÕ )r
r r! rk r/ r9 r r r` r r r r r¹ rÈ ) r· rk rl rm r. r÷ Ú_asrW Ú sorted_indexs r½ rn zIndex.sort_valuesï sÎ ðz ;Ù 4×7Ò7Ù $×">Ò">á Ü ))¤C¨£I´R·W±WÔ=Øyy{ GÐ+Ð+àyy{Ð"ô $¤ Ô.ÜØ i¸[ÈcôCô uÔ /°°cÓ :Ó;CØ++¨++Ó6CÙ Ø$B$iàyy ~ á Ø Ð$Ð $à Ð r¿ c ó t d« )z*
|
Use sort_values instead.
|
z=cannot sort an Index object in-place, use sort_values insteadr ©r· rW rX s r½ r´ z
|
Index.sortI s ô
|
ÐWÓXÐXr¿ c óD t dt | « j « )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 )rC rL r )r· ÚperiodsÚfreqs r½ Úshiftz Index.shiftP s, ôp "ð(Ü(,¨T«
|
×(;Ñ(;Ð'<ð >ó
|
ð
|
r¿ c ó: | j j |i |¤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¹ rO s r½ r¹ z Index.argsort s! ðJ "tzz×!Ñ! 4Ð2¨6Ñ2Ð2r¿ c ó0 t |« s t |« y rÔ )rN r1 r| s r½ r- zIndex._check_indexing_error´ s Ü~ô $ CÓ(Ð (ð r¿ c ó | j dvS )zA
|
Should an integer key be treated as positional?
|
> Úcomplexr r r r¥ rö s r½ r z$Index._should_fallback_to_positionalº s ð
|
×!Ñ!ð *
|
ð
|
ð
|
r¿ a:
|
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ñ c ó | j |« }| j |« s%| j |« s| j |d d¬« S | j |« \ }}|| us||ur|j |« S | j |j k7 rH| j |« }| j |d¬« }|j |d¬« }|j |« S | j r*|j r | j }|j |« }n|j « }| j j |« \ } }
|
t | « t |
|
« fS )NFr1 r )r6 rþ r: r; r= rñ rÉ râ r rU r rN r rC ) r· r? rD rE rÉ r r rO rP r÷ rø s r½ rñ z Index.get_indexer_non_uniqueö s> ð ×2Ñ2°6Ó:à×#Ñ# FÔ+°D×4NÑ4NÈvÔ4Vð ×3Ñ3°FÀ4ÐPUÐ3ÓVÐ Và ×:Ñ:¸6ÓBwØ Ñ ¨vÑ 5Ø×/Ñ/°Ó8Ð 8à :: Ò %ð ×1Ñ1°&Ó9Eà;;u¨5;Ó1DØ== ¨U=Ó3DØ×.Ñ.¨tÓ4Ð 4ð >>f× .Ò .Ø\\Fð ×4Ñ4°VÓ<Jà ×2Ñ2Ó4Jà <<×>Ñ>¸zÓJÑÜ" 7Ó+Ô-@ÀÓ-IÐIÐIr¿ c óh | j r| j |« S | j |« \ }}|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? r÷ r s r½ r zIndex.get_indexer_for s7 ð& × Ò Ø×#Ñ# FÓ+Ð +Ø×0Ñ0°Ó8
|
Ør¿ c óh |}t |t « st j |« }| j r&| j |« }| j |« d }n| j |« \ }}}| j |||« | j |« }t |t « r|j |_
|
t j |j d« st |j t « rBt |t « s!t |t! | « « r |j" |j% 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_missingrÈ rñ r r rÉ rW r rL rR Ú
|
_with_freq)r· r. Ú axis_nameÚkeyarrr÷ r s r½ Ú_get_indexer_strictzIndex._get_indexer_strict6 sû ð Ü&¤%Ô(Ü×*Ñ*¨6Ó2Fà × Ò Ø×*Ñ*¨6Ó2GØ\\ &Ó)¨!Ñ,Fà+/×+CÑ+CÀFÓ+KÑ (FG[à × Ñ v w° Ô:à7Ó#Ü c5Ô !à ((FKÜ ??6<<¨Ô .´*Ø LL/ô3
|
ô #tÔ$Ü3¤ T£
|
Ô+àHHÐ$à ×*Ñ*¨4Ó0àwÐ r¿ c ó t |« dk( ry|dk }|j « }|rd|t |« k( rt d| d| d« t t |« |j « d j « « }t | d« y)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/ r1 r r r rï r )r· r. r÷ r] Ú missing_maskÚnmissingÚ not_founds r½ r[ zIndex._raise_if_missingW s ô* s8q=Ø ð { Ø ×#Ñ#Ó%á Ø3w<Ò'Ü ¨3¨%¨~¸i¸[ÈÐ JÓKÐKä \¨#Ó .¨|×/CÑ/CÓ/EÀaÑ/HÑ I× PÑ PÓ RÓSIÜi[¨ Ð6Ó7Ð 7ð r¿ c ó y rÔ r½ ©r· r? r´ r s r½ r; z!Index._get_indexer_non_comparablez ó ð r¿ c ó y rÔ r½ rf s r½ r; z!Index._get_indexer_non_comparable rg r¿ c ó y rÔ r½ rf s r½ r; z!Index._get_indexer_non_comparable rg r¿ c ó" |&t |« }t d| j d| « dt j |j
|
t j ¬« z }|r|S t j t |« t j ¬« }||fS )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.
|
zCannot compare dtypes z and rÕ r ) rá rÎ rÉ r! Úonesr
|
r9 rk r/ )r· r? r´ r Ú other_dtypeÚ
|
no_matchesrø s r½ r; z!Index._get_indexer_non_comparable s| ð6 Ð Ü.¨vÓ6KÜÐ 4°T·Z±Z°LÀÀkÀ]Ð SÓTÐ Tà"'' &§,¡,´b·g±gÔ>Ñ>
|
Ù à Ð ô ii¤ F£ ´2·7±7Ô;GØ wÐ&Ð &r¿ c ó | 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ö s r½ rí zIndex._index_as_unique´ s ð ~~Ð r¿ z8Reindexing only valid with uniquely valued Index objectsc óî t | t « rmt |t « r]| j J|j =t | j |j « s | j d« |j d« fS | j
|
dk( r$t |t « r t |« | « |fS | j
|
dk( r#t |t « r t |« | « |fS | j j dk( rI|j j dk( r0|j « dk\ rP| |j | j « fS | j r'|j s t | « j |« }t' | j « s)t' |j « r|j) | « \ }} | |fS # t $ r | |fcY S w xY w# t t f$ r t# | j$ « } Y {w xY w)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.
|
rÖ ÚdateÚ timedeltaÚurV r )r r^ r× r rØ rü rL r rd rÉ r$ Úminr rU r. rÎ r1 r r# rM r= r{ s r½ r= z"Index._maybe_downcast_for_indexingÀ s§ ô dÔ ,Ô -´*¸UÔDTÔ2UàÑ#ØHHÑ(Ü" 4§7¡7¨E¯H©HÕ5ð uÓ-¨u×/?Ñ/?ÀÓ/FÐFÐFà × Ñ 6Ò )¬j¸Ô@PÔ.Qð #Ø"tE{ 4Ó(¨%Ð/Ð/ð × Ñ ;Ò .´:¸eÔEVÔ3Wà 4;tÓ$ eÐ+Ð +à ZZ__ Ò #¨¯ © ×(8Ñ(8¸CÒ(?àyy{aÒ ð U\\¨$¯*©*Ó 5Ð5Ð5à ^^ E§O¢Oð +ä T
|
×.Ñ.¨uÓ5ô
|
tzzÔ*¬¸u¿{¹{Ô/Kà ×<Ñ<¸TÓBKE4àU{Ðøô3 'ò #ØU{Ò"ð #ûô" zÐ*ò +ä T\\Ó*ð +ús$  F: Å G Æ: G
|
Ç G
|
Ç $G4Ç3G4c ó t |« \ }}t « ráddlm} t | « dk( rt | |« s | j t j k( r[|j dk( rJt |d« rt d|j ¬« }nt j d« } t ||d¬ « |S |S t |t « r9t |« dk( r+t ||« s|t j k( r | j S | j d
|
k( s|d
|
k( r&t# | j « s t# |« rt$ S t' | j |« }t) | |g|« }|S # t $ r t j t « cY S t $ r Y |S w xY w) zk
|
Implementation of find_common_type that adjusts for Index-specific
|
special cases.
|
r rÿ rE r× Úns)r× zdatetime64[ns]Fr Úuint64)r> r r r r/ r rÉ r! r5 r$ r) rW r× r r r Ú ExceptionrO r' r= r< )r· r? Ú target_dtyper r Útarget_dtype_nsrÉ s r½ râ z Index._find_common_type_compatî sV ô +¨6Ó2 aä Ô õ
|
=ä4yA~Ü4 Ô,°·
|
±
|
¼b¿j¹jÒ0Hà ×$Ñ$¨Ò+Ü |¨TÔ2Ü*9¸$À<Ç?Á?Ô*Sä*,¯(©(Ð3CÓ*Dð Ü f¨OÀ%ÕHð
|
+Ð*Ø#Ð#ä6¤5Ô)ÜK 1Ò$Ü ¨
|
Ô3°|ÄrÇzÁzÒ7QàzzÐ!ð ::Ò ! \°XÒ%=Ü& t§z¡zÔ2Ô6MØ ô7ô "Ð!ä §¡¨VÓ4Ü/°°v°ÀÓFØ øô7 /ò 0Ü !xx¬Ó /Ò/Ü$ò Ø Ø*Ð*ð ús  E Å"F
|
Å>F
|
Æ F
|
c ó |j dk( rt | j « s$| j dk( rt |j « ryt |« }| j |« xs t |« xs t |« S )zK
|
Check if `self == other` can ever have non-False entries.
|
r F)rü rD rÉ rá Ú_is_comparable_dtyperM rP )r· r¸ rÉ s r½ rþ zIndex._should_compare$ st ð × Ñ 9Ò ,Ô1JÈ4Ï:É:Ô1Và × Ñ )Ò +Ô0IÈ%Ï+É+Ô0Vð
|
ä$ UÓ+à × %Ñ % eÓ ,ò &Ü uÓ%ò &ä uÓ%ð
|
r¿ c ó | j j dk( r|j dk( S t | j « r t |« S y)zF
|
Can we compare values of the given dtype to our own?
|
ÚbT)rÉ r$ rL r´ s r½ r{ zIndex._is_comparable_dtype= s? ð ::??cÒ !Ø:: Ñ$Ð $Ü djjÔ )Ü# EÓ*Ð *ð r¿ c óö t |t « r |j }t |« }|j « }|j « D ci c] \ }}|| j |« }}}t |« S c c}}w )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}
|
)r r` r# rq Ú_reverse_indexerrK rÈ r )r· rQ r< rñ rò s r½ rl z Index.groupbyI sj ô" fmÔ ,Ø^^FÜ VÓ$Ø×(Ñ(Ó*ð /5¯l©l«n×=¡d a¨!TYYq\/Ð=Ñ=ä&Ó!Ð!ùó >s Á A5c ó ddl m} | j ||¬« }|j rkt |d t
|
« rXt | |« r | j }n+| j r | j gt |d « z }nd} |j ||¬« S d}|j s | j }t j |d¬« | j k( }|rt || j |¬« }t j! ||d| j ¬ « S )
|
a&
|
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.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx.map({1: 'a', 2: 'b', 3: 'c'})
|
Index(['a', 'b', 'c'], dtype='object')
|
|
Using `map` with a function:
|
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx.map('I am a {}'.format)
|
Index(['I am a 1', 'I am a 2', 'I am a 3'], dtype='object')
|
|
>>> idx = pd.Index(['a', 'b', 'c'])
|
>>> idx.map(lambda x: x.upper())
|
Index(['A', 'B', 'C'], dtype='object')
|
r r )Ú na_actionNr Frª )Ú
|
same_dtyper )r- r Ú _map_valuesr r r
|
r rñ r/ r. rÉ r r¬ rü r? r rY )r· Úmapperr r rÇ r rÉ r s r½ r z Index.mapd sê õF 9à×%Ñ% f¸ Ð%ÓB
|
ð ??z¨*°Q©-¼Ô ?Ü$
|
Ô+Ø
|
|
ØØ ¤c¨*°Q©-Ó&8Ñ8à Ø):×)Ñ)¨*¸EÔBÐ BàØàJJEô
|
__ Z¸Ô>À$×BTÑBTÑT
|
Ù Ü4ØDJJ°:ôJô × Ñ °5¸uÈ4Ï9É9Ð ÓUÐUr¿ c ót t | t « rrt | j « D cg c]: }||k( s| | j |« j |« n| j |« < }}t | « j |« S | D cg c]
|
} ||« }}t || j d¬« S c c}w c c}w )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.
|
F)rñ r9 )
|
r r` r rn Úget_level_valuesr rL Ú from_arraysr rñ )r· Úfuncr² rV rQ r© rK s r½ Ú_transform_indexzIndex._transform_index¦ s¹ ô dMÔ *ô
|
t||Ó,ö ð ð : ð ×%Ñ% aÓ(×,Ñ,¨TÔ2à×*Ñ*¨1Ó-ñ.ðFð ô :×)Ñ)¨&Ó1Ð 1à&*Ö+ T!WÐ+EÐ+Ü T§Y¡Y¸eÔDÐ Dùòùò ,s ¨?B0ÂB5c óh || j |« t j | 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])
|
)rf r Úisinr# rI s r½ r z
|
Index.isinº s. ðJ Ð Ø × &Ñ & uÔ -Üzz$,,¨Ó/Ð/r¿ c ó t rÔ )rC r| s r½ Ú_get_string_slicezIndex._get_string_slice s
|
ô "Ð!r¿ c ó¢ | j |||¬« \ }}t |« s t d« t |« s t d« t |||« 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_locsrN ÚAssertionErrorr* )r· r Úendr{ Ú start_sliceÚ end_slices r½ r zIndex.slice_indexer sW ðX "&§ ¡ °¸À$ Ó!GÑ Yô Ô%Ü Ð!BÓCÐ CÜÔ#Ü Ð!@ÓAÐ Aä[ )¨TÓ2Ð2r¿ c ó |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| s r½ r+ zIndex._maybe_cast_indexer> s ð
|
|
r¿ c ó¦ t |« }t |d« s9| j t k( r&|j dk( rt || j ¬« }|S )zT
|
Analogue to maybe_cast_indexer for get_indexer instead of get_loc.
|
rÉ rù r )r r) rÉ r r )r· r? Ú target_indexs r½ r6 z"Index._maybe_cast_listlike_indexerE sJ ô $ FÓ+ ä Ô(Ø
|
|
fÒ$Ø ×"Ñ" hÒ.ô ! ¨t¯z©zÔ:LØÐr¿ c óT t j |« s| j ||« yy)zz
|
If we are positional indexer, validate that we have appropriate
|
typed bounds must be an integer.
|
N)r Úis_int_or_noner )r· r r. r$ s r½ ry zIndex._validate_indexerT s' ô ×!Ñ! #Ô&Ø × 'Ñ '¨¨cÕ 2ð 'r¿ c óª t | j « r| j |« S t |« s t |« r|| vr| j 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* )rL rÉ r+ rG rI r )r· ri rf s r½ Ú_maybe_cast_slice_boundz Index._maybe_cast_slice_boundb sM ô. DJJÔ 'Ø×+Ñ+¨EÓ2Ð 2ô UOz¨%Ô 0°eÀ4Ñ6GØ × 'Ñ '¨°Ô 7à r¿ c óÊ | j r| j ||¬« S | j r.| d d d
j ||dk( rdnd¬« }t | « |z
|
S t d« )Nr? rÕ r¯ rÚ r[ )r
r@ r r/ r1 )r· ri rf Úposs r½ re z Index._searchsorted_monotonic sr Ø × 'Ò 'Ø×$Ñ$ U°Ð$Ó6Ð 6Ø × )Ò )ð tt*×)Ñ)Ø t¨v¢~G¸6ð *ó Cô t9s?Ð "äÐKÓLÐLr¿ c óf |dvrt d| « |}| j ||« } | j |« }t |t j « rot |j « sJ t j |j d« « }t |t j « rt d| dt |« « t |t « r |dk( r |j S |j S |dk( r|d z S |S # t $ r,} | j ||« cY d}~S # t $ r |w xY wd}~ww xY w)
|
aÉ
|
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.
|
|
See Also
|
--------
|
Index.get_loc : Get integer location, slice or boolean mask for requested
|
label.
|
|
Examples
|
--------
|
>>> idx = pd.RangeIndex(5)
|
>>> idx.get_slice_bound(3, 'left')
|
3
|
|
>>> idx.get_slice_bound(3, 'right')
|
4
|
|
If ``label`` is non-unique in the index, an error will be raised.
|
|
>>> idx_duplicate = pd.Index(['a', 'b', 'a', 'c', 'd'])
|
>>> idx_duplicate.get_slice_bound('a', 'left')
|
Traceback (most recent call last):
|
KeyError: Cannot get left slice bound for non-unique label: 'a'
|
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@ )r1 r r, r re r r! r" rE rÉ r Úmaybe_booleans_to_slicerÁ rY r* r rz )r· ri rf Úoriginal_labelÚslcr> s r½ Úget_slice_boundzIndex.get_slice_bound sC ðN Ð(Ñ (Ü ð&Ø&* Vð-óð ð
|
ð ×,Ñ,¨U°DÓ9ð Ø,,uÓ%Cô c2::Ô &ô ! §¡Ô+Ð +Ð+Ü×-Ñ-¨c¯h©h°t«nÓ=CÜ#rzzÔ*Ü Ø! $ ð ( Ü " >Ó 2Ð 3ð5óð ô
|
c5Ô !Øv~ØyyÐ àxxàwØQwà
|
øô7 ò ð Ø×3Ñ3°E¸4Ó@Õ@øÜ ò à ð þð ús) ¨C; Ã; D0ÄD ÄD0Ä D(Ä(D+Ä+D0c ó |du xs |dk\ }|s||}}t |t t f« rXt |t t f« rB t |« }t |« }t |j
|
|j
|
« s t d« d}|| j |d« }|d}d}|| j |d« }| t | « }|s0|dz
|
|dz
|
}}|dk( r|t | « z }|dk( r|t | « z }||fS # t t f$ r Y w xY w)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@ rÕ )
|
r ré r r r Útzinfor1 rÎ r¢ r/ ) r· r r r{ ÚincÚts_startÚts_endr r s r½ r zIndex.slice_locsã s3 ð> dlÒ'd aiáà e3Eô ec¤8_Ô -´*¸SÄ3ÌÀ/Ô2Rð QÜ$ UÓ+Ü" 3 ô " (§/¡/°6·=±=ÔAÜ$Ð%OÓPÐPà Ø Ð Ø ×.Ñ.¨u°fÓ=KØ Ð ØKà Ø ?Ø ×,Ñ,¨S°'Ó:IØ Ð ÜD Iáð &1°1¡_°iÀ!±m{Ið
|
BØS YÑ& ØbÒ Øs 4yÑ( àIÐ%Ð%øôW ¤ Ð*ò Ùð ús ¿C3 Ã3DÄDc óì | j }t |t j « rt j ||« }n|j |« }| j
|
j || j ¬« S )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')
|
rT )r# r r! r" Údeleter[ r4 rñ )r· rB rQ rÜ s r½ r© z Index.delete; s[ ð: ä fbjjÔ )ä 6¨3Ó/Jà sÓ+Jð × Ñ ×,Ñ,¨Z¸d¿i¹iÐ,ÓHÐHr¿ c ó¶ t j |« }t || j « r | j t k7 r | j
|
}| j }t « rlt | « dk( r^| j t j k( rA| j |« }|| j k7 r!| j |« j ||« S t |t « r8|j ||« }t! | « j# || j$ ¬« S | j' |« } |j t k7 s/t |t. t j0 t j2 f« s3|j j! |« }t j |||« }n(t j ||d« }|dk\ r|n|dz
|
}|||< t4 j7 || j$ ¬« }t « rCt9 |j « r.|j t k( r|j |j « }| j t k( r7|j t k7 r$t; j< dt> tA « ¬« |S # t( t* t, f$ rE | j |« }|| j k( r | j |« j ||« cY S w xY w)a¤
|
Make new Index inserting new item at location.
|
|
Follows Python numpy.insert semantics for negative values.
|
|
Parameters
|
----------
|
loc : int
|
item : object
|
|
Returns
|
-------
|
Index
|
|
Examples
|
--------
|
>>> idx = pd.Index(['a', 'b', 'c'])
|
>>> idx.insert(1, 'x')
|
Index(['a', 'x', 'b', 'c'], dtype='object')
|
r rT Nr@ zòThe behavior of Index.insert with object-dtype is deprecated, in a future version this will return an object-dtype Index instead of inferring a non-object dtype. To retain the old behavior, do `idx.insert(loc, item).infer_objects(copy=False)`r )!r r± rg rÉ r rÐ r# r r/ r! r5 râ r Úinsertr rs rL r4 rñ r rÎ r1 r: r
|
Ú
|
datetime64Ú timedelta64r rY rP r6 r7 r8 r6 ) r· rB r< r= rÉ rÜ ÚcastedrÇ rq s r½ r« z Index.insertc sA ô* ×$Ñ$ TÓ*Ü t§z¡zÔ 2°t·z±zÄVÒ7KØ>>Dàllä Ô ¤C¨£I°¢N°t·z±zÄRÇZÁZÒ7Oð ×1Ñ1°$Ó7EØ
|
|
Ò"Ø{{ 5Ó)×0Ñ0°°dÓ;Ð;ð 8Ü#~Ô.Ø ZZ¨¨TÓ 2
|
ÜDz×-Ñ-¨j¸t¿y¹yÐ-ÓIÐIà×0Ñ0°Ó6ð 99Ò ¤jØ 5"--¬¯ © Ð8ô'
|
ð YY^^ DÓ)FÜ 3¨¨VÓ4Jô
|
3¨¨TÓ2JØ # s¨Q¡wCØ "JsOä× Ñ
|
°·±Ð Ó;ä Ô Ü § ¡ Ô*Ø× Ñ ¤FÒ*à**Z× -Ñ -Ó.CØ ::Ò C§I¡I´Ò$7ä MMðQô Ü+Ó-õ ð
|
øôW :Ô'8Ð9ò 8ð ×1Ñ1°$Ó7EØ
|
|
Ò"àØ;;uÓ%×,Ñ,¨S°$Ó7Ò 7ð 8ús ÃAI? ÄI? É?AKËKc ó8 t |t « s*| j dk( rdnd}t j ||¬« }| j |« }|dk( }|j « r*|dk7 r t || j « d« || }| j |« 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
|
|
Examples
|
--------
|
>>> idx = pd.Index(['a', 'b', 'c'])
|
>>> idx.drop(['a'])
|
Index(['b', 'c'], dtype='object')
|
r Nr rÕ Úignorez not found in axis)
|
r r rÉ r% Úindex_labels_to_arrayr r« r Útolistr© )r· rÆ ÚerrorsÚ arr_dtyper÷ r s r½ Údropz
|
Index.drop¹ s ô< &¤%Ô(à$(§J¡J°(Ò$:ÀIÜ×.Ñ.¨v¸YÔGFà×&Ñ& vÓ.Ø"}Ø 88:ØÒ!Ü &¨¡,×"5Ñ"5Ó"7Ð!8Ð8JÐ KÓLÐLØ tenGØ{{7Ó#Ð#r¿ c ó¶ | j r t d« | j t k7 r|r| j « S | S | j
|
}t d|« }t j |d¬« }|r||u r| j « S t || j ¬« }|s<||u r8| j ,| j |_ |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.únpt.NDArray[np.object_]T)Úconvert_non_numericrT ) rU rC rÉ r r r# r r rV r rñ r rP )r· r rQ rÜ r< s r½ Ú infer_objectszIndex.infer_objectsä sÏ ð >>Ü%ð@óð ð ::Ò Ù"&499;Ð 0¨DÐ 0à ÜÐ/°Ó8Ü×.Ñ.Ø Ø $ô
|
|
ñ J &Ñ(Ø99;Ð Üz¨¯ © Ô2Ù
|
fÑ,°×1AÑ1AÐ1MØ!%×!1Ñ!1FÔ Ø × Ñ × 2Ñ 2°6Ô :Ø r¿ c óR t | j « j |« « S )aà
|
Computes the difference between consecutive values in the Index object.
|
|
If periods is greater than 1, computes the difference between values that
|
are `periods` number of positions apart.
|
|
Parameters
|
----------
|
periods : int, optional
|
The number of positions between the current and previous
|
value to compute the difference with. Default is 1.
|
|
Returns
|
-------
|
Index
|
A new Index object with the computed differences.
|
|
Examples
|
--------
|
>>> import pandas as pd
|
>>> idx = pd.Index([10, 20, 30, 40, 50])
|
>>> idx.diff()
|
Index([nan, 10.0, 10.0, 10.0, 10.0], dtype='float64')
|
|
)r r5 ru )r· rQ s r½ ru z
|
Index.diff s! ô6 T^^Ó%×*Ñ*¨7Ó3Ó4Ð4r¿ c ó^ | j | j « j |« « S )a
|
Round each value in the Index to the given number of decimals.
|
|
Parameters
|
----------
|
decimals : int, optional
|
Number of decimal places to round to. If decimals is negative,
|
it specifies the number of positions to the left of the decimal point.
|
|
Returns
|
-------
|
Index
|
A new Index with the rounded values.
|
|
Examples
|
--------
|
>>> import pandas as pd
|
>>> idx = pd.Index([10.1234, 20.5678, 30.9123, 40.4567, 50.7890])
|
>>> idx.round(decimals=2)
|
Index([10.12, 20.57, 30.91, 40.46, 50.79], dtype='float64')
|
|
)r[ r5 Úround)r· Údecimalss r½ r¼ z Index.round! s' ð0 × Ñ § ¡ Ó!1×!7Ñ!7¸Ó!AÓBÐBr¿ c ó¤ | j |« rí|t j t j t j hv rUt j t | « t ¬« }| j r#t | t « sd|| j « < |S |t j u rUt j t | « t ¬« }| j r#t | t « sd|| j « < |S t |t
|
j t t" t$ f« r"t | « t |« k7 r t' d« t |t « st) |d¬« }nt j* |« }t- | j. « r%t |t$ « r || j0 |« }|S t | j0 t$ « r || j0 |« }|S t- | j. « r3t | t « s#t3 j4 || j0 |« }|S t3 j6 | j0 ||« }|S )zA
|
Wrapper used to dispatch comparison operations.
|
r FTz Lengths must match to compare)Ú extract_numpy) r| rj Úeqrl Úger! rk r/ rÀ rÖ r r` rh ÚnerÊ r" r rc rs r1 rz r* rM rÉ r# rk Úcomp_method_OBJECT_ARRAYÚ comparison_op)r· r¸ rp r= r< s r½ Ú _cmp_methodzIndex._cmp_method> s¶ ð 88E?àhkk¤8§;¡;´· ± Ð<Ñ<Üggc $i¬tÔ4Ø×$Ò$¬Z¸¼mÔ-Là',C Ñ$Ø
|
Øx{{Ñ"Ühhs 4y´Ô5Ø×$Ò$¬Z¸¼mÔ-LØ'+C Ñ$Ø
|
ä ebjj¬%´¼NÐ KÔ LÔQTØ óR
|
ä ZòRô Ð <Ó=Ð =ä%¤ Ô/Ü! %°tÔ<EäJJuÓ%Eä 4::Ô &¬:°e¼^Ô+Lá eÓ,Fð ô ¤nÔ 5Ù eÓ,Fð ô TZZÔ (´¸DÄ-Ô1Pä×1Ñ1°"°d·l±lÀEÓJFð
|
ô ×&Ñ& t§|¡|°U¸BÓ?Fà r¿ c ó¶ t j | |« }| j }t |dd¬« }t j |||« }| j ||¬« S )NT)r¿ Ú extract_rangerT )rk r r# rz Ú
|
logical_opÚ_construct_result)r· r¸ rp Úres_nameÚlvaluesÚrvaluesrÜ s r½ Ú_logical_methodzIndex._logical_methodj sS ä×)Ñ)¨$°Ó6à,,Ü °TÈÔNä^^ G¨W°bÓ9
|
Ø×%Ñ% j°xÐ%Ó@Ð@r¿ c óÊ t |t « r<t |d ||d j ¬« t |d ||d j ¬« fS t |||j ¬« S )Nr r r@ )r r
|
r rÉ )r· r< rñ s r½ rÉ zIndex._construct_resultt s[ ä feÔ $äfQi d°&¸±)·/±/ÔBÜfQi d°&¸±)·/±/ÔBðð ô V $¨f¯l©lÔ;Ð;r¿ c ó t |t « r,t |j « rt |« t urt
|
S t | ||« S rÔ )r r rM rÉ rL r¬ rÅ Ú _arith_method)r· r¸ rp rÆ s r½ rÐ zIndex._arith_method} s? ø ä ueÔ $Ü § ¡ Ô,ÜU ¤5Ñ(ô
|
"Ð !äwÑ$ U¨BÓ/Ð/r¿ c óT || j « }t || j ¬« S rû )r# r rñ )r· rp r< s r½ Ú _unary_methodzIndex._unary_method s! áDLLÓ!ÜV $§)¡)Ô,Ð,r¿ c ó@ | j t j « S rÔ )rÒ rj rt rö s r½ Ú__abs__z Index.__abs__ ó Ø×!Ñ!¤(§,¡,Ó/Ð/r¿ c ó@ | j t j « S rÔ )rÒ rj Únegrö s r½ Ú__neg__z Index.__neg__ rÕ r¿ c ó@ | j t j « S rÔ )rÒ rj r rö s r½ Ú__pos__z Index.__pos__ rÕ r¿ c ó@ | j t j « S rÔ )rÒ rj Úinvrö s r½ Ú
|
__invert__zIndex.__invert__ s à×!Ñ!¤(§,¡,Ó/Ð/r¿ c óè t j ||« | j d« | j }t |t
|
j « s|j d« S 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« ) rÌ Ú validate_anyÚ _maybe_disable_logical_methodsr# r r! r" Ú_reducer« ©r· rW rX r s r½ r« z Index.any sW ôH fÔ%Ø ×+Ñ+¨EÔ2Ø||Ü$¤§
|
¡
|
Ô+ð << Ó&Ð &Üvvd|Ðr¿ c óè t j ||« | j d« | j }t |t
|
j « s|j d« S 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, ) rÌ Ú validate_allrà r# r r! r" rá r, râ s r½ r, z Index.allÌ sW ôN fÔ%Ø ×+Ñ+¨EÔ2Ø||Ü$¤§
|
¡
|
Ô+ð << Ó&Ð &Üvvd|Ðr¿ c ó¦ t | t « s.t | j « r,| j j dk7 r t |« | « yyy)zK
|
raise if this Index subclass does not support any or all.
|
rG N)r r` rQ rÉ r$ r )r· Úopnames r½ rà z$Index._maybe_disable_logical_methodsü sE ô t]Ô +ô $ D§J¡JÔ/°D·J±J·O±OÀsÒ4Jð $OFÓ # DÕ )ð 5KÐ/r¿ c ó^ t j ||« t j |« | j sf| j rZ| j
|
}|r|j « r<t j dt | « j dt t « ¬« yt | 9 |¬« S ©NzThe behavior of zx.argmax/argmin with skipna=False and NAs, or with all-NAs is deprecated. In a future version this will raise ValueError.r rÕ rª )rÌ Úvalidate_argminÚvalidate_minmax_axisrU r» r¹ r, r6 r7 rL r r8 r6 rÅ Úargmin©r· rÒ r« rW rX r rÆ s r½ rë z Index.argmin
|
ó ø ä
|
×Ñ4 Ô(Ü
|
× Ñ Ô%à~~ $§,¢,à;;DÙTXXZÜ Ø&¤t¨D£z×':Ñ':Ð&;ð <Fð Fô "Ü /Ó 1õ ð Üw~ V~Ó,Ð,r¿ c ó^ t j ||« t j |« | j sf| j rZ| j
|
}|r|j « r<t j dt | « j dt t « ¬« yt | 9 |¬« S rè )rÌ Úvalidate_argmaxrê rU r» r¹ r, r6 r7 rL r r8 r6 rÅ rA rì s r½ rA z Index.argmax rí r¿ c ó8 t j ||« t j |« t | « s | j S t | « r | j
|
r| d }t |« s|S | j s6| j r*| j }|r|j « r | j S | j sAt | j t j « s | j j d|¬« S t! j" | j |¬« S )a
|
Return the minimum value of the Index.
|
|
Parameters
|
----------
|
axis : {None}
|
Dummy argument for consistency with Series.
|
skipna : bool, default True
|
Exclude NA/null values when showing the result.
|
*args, **kwargs
|
Additional arguments and keywords for compatibility with NumPy.
|
|
Returns
|
-------
|
scalar
|
Minimum value.
|
|
See Also
|
--------
|
Index.max : Return the maximum value of the object.
|
Series.min : Return the minimum value in a Series.
|
DataFrame.min : Return the minimum values in a DataFrame.
|
|
Examples
|
--------
|
>>> idx = pd.Index([3, 2, 1])
|
>>> idx.min()
|
1
|
|
>>> idx = pd.Index(['c', 'b', 'a'])
|
>>> idx.min()
|
'a'
|
|
For a MultiIndex, the minimum is determined lexicographically.
|
|
>>> idx = pd.MultiIndex.from_product([('a', 'b'), (2, 1)])
|
>>> idx.min()
|
('a', 1)
|
r rs ©rñ r« rª )rÌ Ú validate_minrê r/ rÐ r
rh rU r» r¹ r, r r# r! r" rá rj Únanmin)r· rÒ r« rW rX re r s r½ rs z Index.min0 sÈ ôP fÔ%Ü
|
× Ñ Ô%ä4yØ>>Ð !ä t9×5Ò5àGEÜ;Ø à~~ $§,¢,à;;DÙTXXZØ~~Ð%à~~¤j°· ± ¼r¿z¹zÔ&JØ<<×'Ñ'¨U¸6Ð'ÓBÐ Bä}}T\\°&Ô9Ð9r¿ c ó8 t j ||« t j |« t | « s | j S t | « r | j
|
r| d }t |« s|S | j s6| j r*| j }|r|j « r | j S | j sAt | j t j « s | j j d|¬« S t! j" | j |¬« S )a
|
Return the maximum value of the Index.
|
|
Parameters
|
----------
|
axis : int, optional
|
For compatibility with NumPy. Only 0 or None are allowed.
|
skipna : bool, default True
|
Exclude NA/null values when showing the result.
|
*args, **kwargs
|
Additional arguments and keywords for compatibility with NumPy.
|
|
Returns
|
-------
|
scalar
|
Maximum value.
|
|
See Also
|
--------
|
Index.min : Return the minimum value in an Index.
|
Series.max : Return the maximum value in a Series.
|
DataFrame.max : Return the maximum values in a DataFrame.
|
|
Examples
|
--------
|
>>> idx = pd.Index([3, 2, 1])
|
>>> idx.max()
|
3
|
|
>>> idx = pd.Index(['c', 'b', 'a'])
|
>>> idx.max()
|
'c'
|
|
For a MultiIndex, the maximum is determined lexicographically.
|
|
>>> idx = pd.MultiIndex.from_product([('a', 'b'), (2, 1)])
|
>>> idx.max()
|
('b', 2)
|
rÕ rè rñ rª )rÌ Ú validate_maxrê r/ rÐ r
rh rU r» r¹ r, r r# r! r" rá rj Únanmax)r· rÒ r« rW rX Úlastr s r½ rè z Index.maxo sÈ ôR fÔ%Ü
|
× Ñ Ô%ä4yØ>>Ð !ä t9×5Ò5à8DÜ:Ø à~~ $§,¢,à;;DÙTXXZØ~~Ð%à~~¤j°· ± ¼r¿z¹zÔ&JØ<<×'Ñ'¨U¸6Ð'ÓBÐ Bä}}T\\°&Ô9Ð9r¿ c ó t | « fS )zé
|
Return a tuple of the shape of the underlying data.
|
|
Examples
|
--------
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx
|
Index([1, 2, 3], dtype='int64')
|
>>> idx.shape
|
(3,)
|
)r/ rö s r½ r
|
z Index.shape± s ô D |Ðr¿ )r¸ r, rå ræ )r¸ r, rå z<tuple[ArrayLike, npt.NDArray[np.intp], npt.NDArray[np.intp]])rå rÀ )rå z5type[libindex.IndexEngine | libindex.ExtensionEngine])NNFNT)r rÀ r9 rÀ rå r, )r rÀ )rÉ r$ )NN)rQ r rñ úHashable | Nonerå r, )rå z
|
type[Self])rå ÚNone)rå r )rñ r rå r, )rå r, )rå zLlibindex.IndexEngine | libindex.ExtensionEngine | libindex.MaskedIndexEngine)rå z
|
set[str_t])rå rB )rå r )r³ znp.ufuncr´ Ústr_t)NF)rå r$ )ÚC)r¾ rû rå r, rÔ )T)r TN)rÒ r" rÊ rÀ rå r, )rÊ rÀ rå rÀ )rÒ rú rå r, )rñ rù rÞ rÀ rå r, )rå rû )rå z-list[tuple[str_t, str_t | int | bool | None]])rå z Hashable | Sequence[Hashable])FNr
|
)rñ rÀ r úCallable | Noner rû rå ú list[str_t])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 ©rå r )r: r rå rú )NNF)rÞ rÀ rå úlist[Hashable])r z$Hashable | Sequence[Hashable] | Nonerå r )rå r~ )r úLiteral[False]rå r, )r ú Literal[True]rå rú )r rÀ rå z Self | None©F)NTNre )rl zbool | list[bool]rm r* ©rå r )r )r² r' )rx z list[int])rå únpt.NDArray[np.bool_])r« )r± r rå r, )r² rù rå r, )rg r# rå r, )re )rg r# rå r )rå r )r¸ r rÙ rû rå útuple[Index, Index])r¸ r r´ ú bool | None)r¸ r rå r )r´ rÀ )r¸ r r´ rÀ )r¸ zIndex | MultiIndexrå zArrayLike | MultiIndex)rå ztuple[Index, Hashable])NNN)r´ úReindexMethod | Noner4 ú
|
int | Nonerå ræ )r? r r´ ú str_t | Noner4 r rå ræ )r? r rå rÀ )r´ r
|
r4 r rå rú )r? znp.ndarray | Indexrå r )r? r r´ rû r4 r rå ræ )r? r r4 r rå ræ )r? r r÷ ræ rå ræ )r? r r÷ ræ rå r )r. r* rå rú )r. r* r$ zLiteral['loc', 'getitem'])r z Literal['slice', 'positional']r z lib.NoDefault | None | Exceptionrå rú )r÷ r rå rú )NNNN)r´ r r4 r r5 z float | Nonerå z)tuple[Index, npt.NDArray[np.intp] | None])r rÀ )r? r r rÀ )r? r rå z?tuple[Index, npt.NDArray[np.intp], npt.NDArray[np.intp] | None]) r¸ r r± r( r² r) r³ r r´ rÀ rå úFtuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]) r¸ r r± r( r² r) r³ r r´ rÀ rå r ) r¸ r r± r( r² r) r³ rÀ r´ rÀ rå úNIndex | tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]) r¸ r r± r( r² z Level | Noner³ rÀ r´ rÀ rå r )r¸ r r± r( r´ rÀ rå r )r¸ r r± r( )r¯ F)r¸ r r± r( r´ rÀ rå z8tuple[Index, npt.NDArray[np.intp], npt.NDArray[np.intp]])r¯ T)r¸ r r± r( r rÀ rå zKtuple[MultiIndex, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None])r¯ )r¸ r r± r( rå r )
|
rà r r¸ r, rº ræ r» ræ rå r, )rå r )rå rs )rå rë )r< r rå r )rÞ rÀ rå rB )r. r rå rÀ )r' r* rå r, )r¸ zIndex | Sequence[Index]rå r )r, z list[Index]rñ r rå r )r¸ r rå rÀ )rm r r r rå ræ )
|
rk r rl rÀ rm r* r. rý rå r, )
|
rk r rl rÀ rm r* r. rý rå ztuple[Self, np.ndarray])
|
rk rÀ rl rÀ rm r* r. rý rå z Self | tuple[Self, np.ndarray])FTr÷ N©r@ N)rQ rB )rå ræ )rå ú1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])r] rû rå ztuple[Index, np.ndarray])r] rû rå rú ).)r? r r r rå ræ )r? r r r rå r )r? r r rÀ rå zHnpt.NDArray[np.intp] | tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])r¸ r rå r )r¸ r rå rÀ )rÉ r$ rå rÀ )rå z PrettyDict[Hashable, np.ndarray])r zLiteral['ignore'] | None)r. rû )r rù r rù r{ r rå r* )r z Literal['positional', 'slice']r$ zLiteral['getitem', 'iloc']rå rú )rf rû )rf úLiteral['left', 'right'])rf r rå rB )rå ztuple[int, int])rB rB rå r )Úraise)rÆ z'Index | np.ndarray | Iterable[Hashable]r³ r& rå r )r rÀ rå r )r@ )rQ rB rå r )r½ rB rå r, )ræ rû rå rú rè )r« rÀ rå rB )r« rÀ )rå r- ( r Ú
|
__module__Ú __qualname__Ú__doc__Ú__pandas_priority__r rÚ rá rä rè rê Ú__annotations__r! r" rs rí rî rï rð ró rô r3 r÷ rÉ Úint8rû Ú
|
Int8EngineÚint16Ú Int16EngineÚint32Ú Int32EngineÚint64Ú Int64EngineÚuint8Ú UInt8EngineÚuint16Ú UInt16EngineÚuint32Ú UInt32Enginerv Ú UInt64Enginer² Ú Float32EngineÚfloat64Ú Float64Enginer r r r rø Úpropertyrý Ú!_supports_partial_string_indexingÚ
|
_accessorsrl r
ré r rÎ Ú classmethodr3 r2 r4 rY r[ rb r_ r rt rw ry r| rO r r r r¢ r r· r¨ r¿ rÁ r r r2 r rÈ rÏ rØ r rã rç rõ r÷ rí rî r r r r r r r+ r1 r3 r5 r rp rñ Úsetterrß rE rG rJ r r rO r[ r4 rn rb rf ri rp rr r ry rw rÖ r
r r r r^ r r rI r r r r r£ r¦ r¨ rü r® rU r± rÐ r¹ r» rh Úisnullr¾ ÚnotnullrÁ rà r rÈ r rÍ rÏ Ú__bool__rÑ rÔ rÛ rÝ rä rå rý rÿ r r r r r r rß rà r, rî r> r: r7 rK rL r^ rM r_ ri r} r r r r r r r£ r¾ rà r¯ rµ r® r´ r r³ rö ré rQ r5 rw r0 r# r rÕ rÝ r r rm r( r r r r r r" r) r r+ r} rã r9 r= rD rn r´ rS r¹ r- r rñ r r_ r[ r; rí r8 r= râ rþ r{ rl r r r r r r+ r6 ry r re r¢ r r© r« rµ r¹ ru r¼ rÅ rÍ rÉ rÐ rÒ rÔ rØ rÚ rÝ r« r, rà rë rA rs rè r
|
Ú __classcell__)rÆ s @r½ r r @ s ø
ñ1ðj Ðð ó8ó ð8ð ð"Øð"à Eó"ó ð"ð ð"Øð"à Eó"ó ð"ð ð"Øð"à Eó"ó ð"ð D#ÓØ &Ó&à
|
|
|
ØðWIÐSó ð C Ó ØE8Óð #ÐdÓ"Ø %hL)Ó&Ø $XKÓ%àó0ó ð0ð Ó8×.Ñ.ØÓH× 0Ñ 0ØÓH× 0Ñ 0ØÓH× 0Ñ 0ØÓH× 0Ñ 0ØÓX× 2Ñ 2ØÓX× 2Ñ 2ØÓX× 2Ñ 2ØÓ h× 4Ñ 4ØÓ h× 4Ñ 4Ø Ó × 8Ñ 8Ø Ó ×!:Ñ!:ð RMÐNó ð ðIà >óIó ðIð ).Ð%àJá
|
Ó
|
.CàKð ØØØ Ø "ñ sð ð sð ð sð
|
ôsðj óó ðð" Øó)ó ó ð)ðL àCGñØ ðØ&5ðà óó ðð0 ñó ðð" óó ðð ó+ó ð+ð( ó!.ó ð!.ðL 6@õ Jô"ð óó ðð ó%)ó ð%)ðN ó ó ð ð ó%ó ð%ð ð00à Uó00ó ð00ðd Øó
|
|
ó ó ð
|
|
ô ö <ô#+ðJ ó -ó ð -ð ó ó ð ð õó ðô(!öF?ðF ð ØññH Ð Ñ(Ð+<Ñ<Ó=ð Ø Øñ Dð ðDð ð Dð
|
óDó >ðDð: óó ðð0# ð ØññN Ð Ñ*Ð->Ñ>Ó?õIó @ðIð !%Øñ(à ð(ð ð(ð
|
ô (ðT ó#ó ð#ð õ$ó ð$ð ó
|
.ó ð
|
.ð ñ ó ð ð õ
|
ó ð
|
ô2ð& ó 9ó ð 9ð ó7ó ð7ð Ø%)Ø ñ Fàð Fð #ð Fð ð Fð
|
|
ô Fð< Oà
|
ð
|
&*ñ Tð ðTð #ð Tð
|
|
ó Tó ðTô, ð0 Ø ØØØñ
|
ð ð
|
ð ð
|
ð
|
!ô
|
ö$!=ôLð$ õ=Có ð=Cð@ !°3·>±>ð;Øð;Ø(0ð;à ô;ð@ ó ó ð ð
|
[[óó ðð à27ñ Ø+/ð à ó ó ð ðB KOñ!Ø9ð!à ô!ôF(ð +/ö ñ6 *¨:Ô 6Eà Ø(+Àsõ ó ð ð Ø(+õ ó ð ð Ø(+¸Sõ ó ð ð )-¸eö gðR Ø8;õ ó ð ð ó ó ð ñ $Ø V¨VÐ$4¸8ôõ17óð17ðl óó ðô ð óó ðô.ð Ø'+ØØ")ñ ,
|
ð %ð,
|
ð
|
ô ,
|
ô\%ðN )Ðà
|
õ11ó ð11ðf ó7ó ð7ðx Ø
|
óó ó ðð ó4ó ð4ð. ó4ó ð4ð. Ø ó?ó ó ð?ð Ø ó?ó ó ð?ð ó &ó ð &ðD Ø ó!"ó ó ð!"ðF ó)1ó ð)1ðV ó)1ó ð)1ðV ó1Wó ð1Wðf ó1=ó ð1=ðf ó.+ó ð.+ð` ó25ó ð25ðh ó'2ó ð'2ðR óBó ðBð ó %ó ð %ð ó ;ó ð ;ð Ø
|
ó >ó ó ð >ð Øó/ó ó ð/ò1ð ñ ó ð ð ó
|
ó ð
|
ð óó ðð4 ó4ó ð4ðl Fà
|
ó) ó ð) ðV Gà ¨#¯.©.ó 7 ör ÷>"*ð "*ðH 3:÷ 12ð 12öf9+ò| ð ó
|
ó ð
|
ð Hò
|
ð ñó ðð óó ðð$ ów6ó ðw6ôrMð^ óó ðð õS=ó ðS=öj ò<6ð ð Ø'ð à ó ó ð ð@ ó;;ó ð;;òz ò6ôO1ðb óó ðô
|
"ò)ðV ð (,Ø Øñ DCð %ðDCð ð DCð
|
ó DCó ðDCðR $Ø Øñ ,àð,ð ð,ð ð ,ð
|
ô ,ð: ó ó ð ð ð !Øñ +à ð+ð ð+ð
|
|
ó +ó ð+ôZð$ àPTñ Øð Ø%*ð Ø3=ð à ó ó ð ð@ à@Dñ Øð Ø%*ð Ø3=ð à ó ó ð ðB ð Øð Ø$.ð à ó ó ð ð> ð<àð<ð &ð<ð
|
|
ó <ó ð<ð ðØðØ&:ðà óó ðð( ó?ó ð?ôRðh ð
|
58·N±Nð à,ð ð 2ð ð
|
|
ó ó ð ð( óPó ðPð& (,ØØ Ø"&ñ o ð %ðo ð
|
ð o ð ð o ð
|
3ôo ôbôð ðE/ØðE/à HóE/ó ðE/ðT ð
|
Øàñ àð ð ð ð
|
ð ð 'ð ð ð ð
|
Pó ó ð ð ð
|
ØØ*-Øñ àð ð ð ð
|
ð ð (ð ð ð ð
|
ó ó ð ð ð
|
ØØ #Øñ àð ð ð ð
|
ð ð ð ð ð ð
|
Xó ó ð ð Øð
|
Ø "Ø %Øñd<àðd<ð ð d<ð
|
ð d<ð ð d<ð ðd<ð
|
Xód<ó ó ðd<ðL ð&Øð&Ø!(ð&Ø04ð&à Oó&ó ð&ð4 ð .Øð .Ø!(ð .Ø04ð .à Oó .ó ð .ðD óVó ðVðp à@Eñ/Øð/Ø!(ð/Ø9=ð/à Aó/ó ð/ð* àMQñR7ØðR7Ø(/ðR7ØFJðR7à TóR7ó ðR7ðh à+1ñ2&Øð2&Ø!(ð2&à Oó2&ó ð2&ðhVàðVð ðVð #ð Vð
|
#ð Vð
|
ô Vð, ØóGó ó ðGð> ó+ó ð+ðZ Ù × Ò Ó óó ó ðð óó ðô2 ðD óó ðô& ñ × $Ò $Ó%õó &ðð õ%*ó ð%*ðP Øñ
|
ó ó ð
|
òô,
|
ô'ðX Ó à
|
óEó ðEò2Fôh
|
ð óó ðô""-ôH4ô1*ôfb=ðH ó
|
ó ð
|
ð@ ñIó ðIðV?Øð?Ø"7ð?à ô?ðB ð *-Ø Ø"%Ø "ñ ð 'ð ð ð ð
|
ð ð ð ð
|
ó ó ð ð ð
|
Ø"%Ø "ñ ð &ð ð ð ð
|
ð ð ð ð
|
!ó ó ð ð ð #Ø Ø"%Ø "ñ ð ð ð ð ð
|
ð ð ð ð
|
(ó ó ð ñ $Ø V H°=ôð
|
%Ø Ø"(Ø #ñ U à ðU ð ðU ð ð U ð
|
ð U ð
|
(ó U óðU ðn ñYó ðYö ;
|
ôz%3òN)ð ó
|
ó ð
|
ð, ð Ø ññ` Ð Ð!9Ñ:Ð=NÑNÓOð%Jà :ó%Jó Pð%JðN óó ðô. ôB!8ðF à=@ñ Øð Ø-:ð à ó ó ð ð
|
ð Øð Ø-;ð à :ó ó ð ð
|
à48ñ Øð Ø-1ð à Qó ó ð ð
|
à48ñ%'Øð%'Ø-1ð%'à Qó%'ó ð%'ðN ó ó ð ð VÐà
|
ó+ó ð+ðZ ó3ó ð3ðj ó
|
ó ð
|
ô0
|
ð ó"ó ð"ö4?VðD Ø.2õ Eó ðEö&G0ôR"ð "&Ø #Ø ñ 43à ð43ð ð43ð ð 43ð
|
|
ö 43ôlö ð ð 3à,ð 3ð )ð 3ð
|
|
ô 3ó ñ 3ö ÷@ Mð Mö Q÷fV&ð V&öp&IöPTðr &ñ)$à7ð)$ð ð)$ð
|
ö )$ðV ö ó ñ ð> ö5ó ñ5ð8 öCó ñCô8*ðX òAó ñAð ò<ó ñ<ö 0ð ò-ó ñ-ö0ö0ö0ö0ô+ ôZ. ð` ô *ó ñ *ñ m×"Ò"×*Ñ*Ó+÷-ð -ó ,ñ-ñ$ m×"Ò"×*Ñ*Ó+÷-ð -ó ,ñ-÷$=:ð =:÷~>:ð >:ðD Ø ô ó ó ö r¿ c ó ddl m} t | « dk( r||d }t | d |¬« S |j | |¬« S )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@ rT r )r- r r/ r r )Ú sequencesr r s r½ Úensure_index_from_sequencesr3 Ã sH õ< 5ä
|
9~ÒØ Ð Ø!HEÜYq\¨Ô.Ð.à%z×%Ñ% i°uÔ=Ð=r¿ c óÈ t | t « r|r| j « } | S t | t « r| j }t | ||¬« S t | « r t | « } t | t « rbt | « t ur t | « } t | « r-t j | « rddl m } |j | « S t | |d¬« S t | |¬« S )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 r9 r )r r r rc rñ rJ r rL r/ r Úis_all_arrayliker- r r )Ú
|
index_liker rñ r s r½ r r ë sÀ ô> *eÔ$Ù Ø# Ó*JØÐä*iÔ(ØÜZ d°Ô6Ð6ä:Ô Ü*Ó%
|
ä*dÔ#Ü
|
Ó ¤4Ñ 'ô jÓ)Jä z?s× 3Ñ 3°JÔ ?Ý <à):×)Ñ)¨*Ó5Ð 5ä¨$¸eÔDÐ DäZ dÔ+Ð+r¿ c óR t | « | S # t $ r t | « cY S w xY w)z<
|
If seq is an iterator, put its values into a list.
|
)r/ rÎ r )Úseqs r½ r r & s0 ðÜ Cð
|
øô ò ÜCyÒðús &¥&c ó² | s| S t | « rBt d | D « « r0| D cg c] }|dd } }t | « rt d | D « « r0| S c c}w )z£
|
Trims zeros and decimal points.
|
|
Examples
|
--------
|
>>> trim_front([" a", " b"])
|
['a', 'b']
|
|
>>> trim_front([" a", " "])
|
['a', '']
|
c 3 ó, K | ] }|d dk( yw)r ú Nr½ r s r½ r z trim_front.<locals>.<genexpr>@ s è ø Ò <¨qq t s{Ñ <ùs r@ N)r, )Ústringsr© s r½ r! r! 2 sY ñ ØÜ
|
g,3Ñ <°GÔ <Ô<Ø")Ö*Q1QR5Ð*Ð*ô g,3Ñ <°GÔ <Õ<à Nùò +s ¦ Ac ó( | dvrt d| « y )N)r¯ rÚ r¼ rª z do not recognize join method rÓ r; s r½ r² r² E s# Ø Ð8Ñ8ÜÐ8¸¸ÐAÓBÐBð 9r¿ c ó | "t |t t f« r |j } t | « st |j d« | S )zR
|
If no name is passed, then extract it from data, validating hashability.
|
z .name must be a hashable type)r r rc rñ rH rÎ r )rñ r- rÏ s r½ r r J sH ð |
|
3¬´ Ð(:Ô;ð xxô tÔ Ü3<<.Ð(EÐFÓGÐGà Kr¿ c ó° | D cg c] }t |j « }}t | D cg c] }h |£ }}t d |D « « }|S c c}w c c}w )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 3 ó\ K | ]$ }t |« d k( r|j « nd & ywr )r/ rÍ )r ru s r½ r z&get_unanimous_names.<locals>.<genexpr>i s% è ø ÒI¸c "g¨l"&&(°Ó4ÑIùs *,)r
|
r r )ÚindexesrV Ú name_tupsru Ú name_setsr s r½ Úget_unanimous_namesrD Z sX ð *1Ö1 Aqww Ð1IÐ1Ü!,¨iÐ!8Ö922Ð9IÐ9Ü ÑI¸yÔIÓ IEØ Lùò 2ùÚ9s
|
A Ac óR | j }t |t « r|j j S t |t « rZddl}|j j |j « r1| dd j t |j j « « } | j 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
|
-------
|
np.dtype or ExtensionDtype
|
r N) rÉ r rV rý rU r
r Ú is_dictionaryÚ pyarrow_dtyper Ú
|
value_type)r¸ rÉ r s r½ rá rá m s ð KKEÜ%Ô)Ô*ð × Ñ ×%Ñ%Ð%Ü E:Ô &ã à 88× !Ñ ! %×"5Ñ"5Ô 6Ø"1I×$Ñ$¤Z°×0CÑ0C×0NÑ0NÓ%OÓPEØ ;;Ðr¿ c óÄ |dur t j | « } | S | S # t $ r7}|du r t j | dt
|
t « ¬« Y d }~| S d }~ww xY w)NFTz3, sort order is undefined for incomparable objects.r )r Ú safe_sortrÎ r6 r7 ÚRuntimeWarningr6 )r< r´ r> s r½ rì rì sr Ø 5Ñð ô __ VÓ,Fð M6Møô ò Øt|ØÜ MMØ%ÐJÐKÜ Ü+Ó-÷ ñ ð
|
Mûð ús A ¨,AÁA r~ r# )r r( r& r% c óÊ t | t « ra| j j j dv r?t j | j j t | j « |¬« } t | « } t | t t f« r«| j dk( r,| j ||¬« }|j t d¬« }|S g }t# t% | « « D ]B }| |dd
f j ||¬« }|j' |j t d¬« « D t) j* |« S t | j t, « r!t/ d| « } | j ||¬« } | S t | j t0 « rjt/ d | « } | j3 « }
|
|s)t) j4 | « j t6 « }n t) j8 | t d
|
¬ « }|||
|
< |S | j j d k( r¶t | j t: « s|]|d k( rXt3 | « }
|
|s| j t6 « } nt) j8 | d¬« } || |
|
< | j t d¬« } | S ddl m } | | ||||d¬« } | jA « } | j t d¬« } | S t | tB « r:t3 | « }
|
t) j4 | j t « « } || |
|
< | S t3 | « }
|
tE jF |« }| j tH k7 rg|se|rc| j t6 « } | j jJ t) j d« jJ z |k r,| j d| « } nt) j8 | d¬« } || |
|
< | j t d¬« } | S )zd
|
Convert to types which can be consumed by the standard library's
|
csv.writer.writerows.
|
r r2 r@ )r r' Fr Nr r Tr r r# r r r )ÚFloatArrayFormatter)r r& r% r( Ú fixed_widthÚU1z<U)&r rq rý rÉ r$ r r< r# rC Ú_codesry rr rt rA Ú_format_native_typesr r r r/ r r! ÚvstackrZ r rY rh r* ré r0 r[ r rM Úget_result_as_arrayrs r Úword_lenr' Úitemsize)rQ r' r r( r& r% r< Úresults_convertedrV r r rM r rÇ rU s r½ r* r* sG ô &+Ô&¨6×+<Ñ+<×+BÑ+B×+GÑ+GÈ4Ñ+Oä Ø × Ñ × %Ñ %Ü § ¡ Ó .Ø ô
|
ô ,¨FÓ 3Fä&=¬.Ð9Ô:Ø ;;!Ò Ø×0Ñ0¸ÈKÐ0ÓXFØ]]¤6°]Ó6FØMð ÐÜs6{Ó#ò HAØAqD\×6Ñ6Ø ¨;ð 7ó Fð × $Ñ $ V§]¡]´6À ]Ó%FÕ Gð Hô
|
yyÐ*Ó+Ð+ä FLL¤+Ô .äm VÓ,Ø×)Ñ)°À[Ð)ÓQØ
|
ä FLL¤-Ô 0äo vÓ.Ø{{}ÙÜZZ Ó'×.Ñ.¬sÓ3FäXXf¬F¸Ô>Fà t Ø à × Ñ cÒ !¬*°V·\±\Ä;Ô*Oð Ð G¨s¢NÜ<DáØ ¤sÓ+ä &°Ô9à!F4LØ]]¤6°]Ó6FØMå@á'Ø ØØ%ØØØ ô
|
ð ×+Ñ+Ó-Øjj ejÓ,Ø
|
ä FNÔ +ÜF|äZZ § ¡ ¬fÓ 5Ó6
|
Ø!
|
4ÑØÐô F|Ü×#Ñ# FÓ+à <<:Ò %©g¹(Ø]]¤3Ó'FØ||×$Ñ$¤r§x¡x°£~×'>Ñ'>Ñ>ÀÒIà ¨¨H¨: Ó7äXXf¨HÔ5Fà t Ø v¨E Ó2Ø r¿ )r¼ r% rå r% rÔ r r )r6 r! r rÀ rå r )r< rò rå rò )r´ ré rå rú rÿ )rA r rå ztuple[Hashable, ...])r¸ r rå r$ )r< zIndex | ArrayLiker´ r )rQ r r ré r% ré rå r· )îÚ
|
__future__r Ú collectionsr r rÁ Ú itertoolsr rj Útypingr r r r
|
r r r r r r6 Únumpyr! Úpandas._configr r r Ú pandas._libsr r r] r rû r r Úpandas._libs.internalsr Úpandas._libs.joinÚ_libsr¾ rÖ Úpandas._libs.libr r Úpandas._libs.tslibsr r r r Úpandas._typingr r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. Úpandas.compat.numpyr/ rÌ Ú pandas.errorsr0 r1 Úpandas.util._decoratorsr2 r3 r4 r5 Úpandas.util._exceptionsr6 r7 Úpandas.core.dtypes.astyper8 r9 Úpandas.core.dtypes.castr: r; r< r= r> r? r@ Úpandas.core.dtypes.commonrA rB rC rD rE rF rG rH rI rJ rK rL rM rN rO rP rQ rR rS Úpandas.core.dtypes.concatrT Úpandas.core.dtypes.dtypesrU rV rW rX rY rZ r[ Úpandas.core.dtypes.genericr\ r] r^ r_ r` ra rb rc rd Ú pandas.core.dtypes.inferencere Úpandas.core.dtypes.missingrf rg rh Ú pandas.coreri rj rk Úpandas.core.accessorrl Úpandas.core.algorithmsÚcoreÚ
|
algorithmsÚ pandas.core.array_algos.putmaskrm rn Úpandas.core.arraysro rp rq rr rs rt Úpandas.core.arrays.string_ru rv Úpandas.core.baserw rx Úpandas.core.commonÚcommonr% Úpandas.core.constructionry rz r{ Úpandas.core.indexersr| r} Úpandas.core.indexes.frozenr~ Úpandas.core.missingr Úpandas.core.opsr Úpandas.core.ops.invalidr Úpandas.core.sortingr r r Ú pandas.core.strings.accessorr
Úpandas.io.formats.printingr r r r Úcollections.abcr r r rK r r r r r r Ú__all__r Ú_unsortable_typesr r r ré rû rÉ r' ÚMaskedComplex128EngineÚMaskedComplex64EngineÚMaskedFloat64EngineÚMaskedFloat32EngineÚMaskedUInt64EngineÚMaskedUInt32EngineÚMaskedUInt16EngineÚMaskedUInt8EngineÚMaskedInt64EngineÚMaskedInt32EngineÚMaskedInt16EngineÚMaskedInt8EngineÚMaskedBoolEnginer rà rÑ r r3 r r r! r² r rD rá rì r* r½ r¿ r½ ú<module>r sï ðÞ "å Ý Û Ý !Û ÷
|
÷
|
õ
|
ó ã ÷ñ ÷ õ õ 3ß #Ð #÷÷ó ÷ ÷ ÷ ÷ ó õ$ /÷÷ó ÷ ÷
|
÷÷ ñ ÷÷ ÷ ÷ ÷ ñ õ* 4÷÷ ñ ÷
|
÷
|
õ
|
õ 6÷ñ ÷ ñ õ
|
0ß &Ð &÷÷÷ ÷÷÷ !Ð ÷ñ ÷
|
õ 2Ý 9Ý .Ý 3÷ñ õ
|
7÷ó ñ ÷ñ ÷ ó ÷ ð
|
)á Ð 8Ó9Ð ð ØØØØØ ñ %Ð >ó ð &(Ð NÓ 'Ø à RXXhÓ
|
ðØ(×1Ò1ðà×/Ò/ðð x×+Ò+ðð x×+Ò+ð ð
|
h×)Ò)ð ð h×)Ò)ð ð h×)Ò)ðð X× 'Ò 'ðð X× 'Ò 'ðð X× 'Ò 'ðð X× 'Ò 'ðð H× %Ò %ðð x×(Ò(ðð x×3Ò3ð ð ×4Ò4ð ð ×4Ò4ð!ð" h×2Ò2ð#ð$ ×2Ò2Ø ×2Ò2Ø ×2Ò2Ø ×0Ò0Ø ×0Ò0Ø ×0Ò0Ø ×0Ò0Ø ×.Ò.Ø ×.Ò.ò5ó<ò8!ô8@r M<ô @r ôFd%>ôP8,òv óó&Có
|
ó ó&ó6ð0 Ø ØØñkØ ðkð ð kð ðkð ôkr¿
|
