Ë
|
nñúh3 ã ó d dl mZ d dlmZmZmZmZmZ d dlm Z d dl
|
m Z d dl m Z mZmZmZmZ d dlZd dlZd dlmZ d dlmZmZm Z d d l m Z d d
|
l m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ d d l,m-Z. d d l/m0Z0m1Z1m2Z2 d d l3m4Z4m5Z5m6Z6 d dl7m8Z8 d dl9m:Z: d dl;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZE d dlFmGZGmHZH d dlImJZJmKZK d dlLmMZM d dlNmOZOmPZP d dlQmRc mSZ d dlTmUZU d dlVmWZWmXZX d dlYmZZZm[Z[ d dl\mRc m]Z^ d dl_m`Z` d dlamRc mbc mcZd d dlameZemfZfmgZgmhZh d dlimjZj d dlkmlZl d d lmmnZnmoZo d d lpmqZqmrZr e r
|
d d lsmtZtmuZumvZv ewedjð « Zxexjó d d d!« G d" d#ejô ejö « Z| G d$ d%ejô ejú « Z~d.d&Z G d' d ee« Zd/d(Zd0d1d)Zd2d*Zd3d+Zd4d5d,Z
d6d-Zy)7é )Ú annotations)Ú
|
CollectionÚ GeneratorÚHashableÚIterableÚSequence)Úwraps©Ú getsizeof)Ú TYPE_CHECKINGÚAnyÚCallableÚLiteralÚcastN)Ú
|
get_option)ÚalgosÚindexÚlib)Ú
|
duplicated) ÚAnyAllÚ AnyArrayLikeÚAxisÚDropKeepÚDtypeObjÚFÚ IgnoreRaiseÚ
|
IndexLabelÚScalarÚSelfÚShapeÚnpt)Úfunction)ÚInvalidIndexErrorÚPerformanceWarningÚUnsortedIndexError)ÚAppenderÚcache_readonlyÚdoc)Úfind_stack_level)Úcoerce_indexer_dtype)
|
Ú ensure_int64Úensure_platform_intÚ is_hashableÚ
|
is_integerÚ is_iteratorÚ is_list_likeÚis_object_dtypeÚ is_scalarÚis_string_dtypeÚ pandas_dtype)ÚCategoricalDtypeÚExtensionDtype)Ú ABCDataFrameÚ ABCSeries)Ú is_array_like)Úarray_equivalentÚisna)Úvalidate_putmask)Ú CategoricalÚExtensionArray)Úfactorize_from_iterablesÚrecode_for_categories)Úsanitize_array)ÚIndexÚ_index_shared_docsÚ ensure_indexÚget_unanimous_names)Ú
|
FrozenList)Úmake_invalid_op)Úget_group_indexÚlexsort_indexer)Úget_adjustmentÚ pprint_thing)ÚCategoricalIndexÚ DataFrameÚSeriesÚ
|
MultiIndexz MultiIndex or list of tuples)ÚklassÚ target_klassc ó. e Zd ZdZej
|
Zd Zy)ÚMultiIndexUIntEngineza
|
This class manages a MultiIndex by mapping label combinations to positive
|
integers.
|
c ó¾ || j z }|j dk( r t j j |« S t j j |d¬« S )a
|
Transform combination(s) of uint64 in one uint64 (each), in a strictly
|
monotonic way (i.e. respecting the lexicographic order of integer
|
combinations): see BaseMultiIndexCodesEngine documentation.
|
|
Parameters
|
----------
|
codes : 1- or 2-dimensional array of dtype uint64
|
Combinations of integers (one per row)
|
|
Returns
|
-------
|
scalar or 1-dimensional array, of dtype uint64
|
Integer(s) representing one combination (each).
|
é ©Úaxis)ÚoffsetsÚndimÚnpÚ
|
bitwise_orÚreduce©ÚselfÚcodess úLH:\Change_password\venv_build\Lib\site-packages\pandas/core/indexes/multi.pyÚ_codes_to_intsz#MultiIndexUIntEngine._codes_to_ints sP ð$ $,,Ñ ð
|
::?ä==×'Ñ'¨Ó.Ð .ô }}×#Ñ# E°Ð#Ó2Ð2ó N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__ÚlibindexÚ UInt64EngineÚ_basera © rb r` rS rS s ñð
|
× !Ñ !Eó 3rb rS c ó. e Zd ZdZej
|
Zd Zy)ÚMultiIndexPyIntEnginezÂ
|
This class manages those (extreme) cases in which the number of possible
|
label combinations overflows the 64 bits integers, and uses an ObjectEngine
|
containing Python integers.
|
c óÜ |j d« | j z }|j dk( r t j j |« S t j j |d¬« S )a
|
Transform combination(s) of uint64 in one Python integer (each), in a
|
strictly monotonic way (i.e. respecting the lexicographic order of
|
integer combinations): see BaseMultiIndexCodesEngine documentation.
|
|
Parameters
|
----------
|
codes : 1- or 2-dimensional array of dtype uint64
|
Combinations of integers (one per row)
|
|
Returns
|
-------
|
int, or 1-dimensional array of dtype object
|
Integer(s) representing one combination (each).
|
ÚobjectrU rV )ÚastyperX rY rZ r[ r\ r] s r` ra z$MultiIndexPyIntEngine._codes_to_ints± sY ð& XÓ&¨$¯,©,Ñ6ð
|
::?ä==×'Ñ'¨Ó.Ð .ô }}×#Ñ# E°Ð#Ó2Ð2rb N)rc rd re rf rg Ú ObjectEngineri ra rj rb r` rl rl ¨ s ñð × !Ñ !Eó 3rb rl c óJ t « fd« }t t |« S )z
|
A decorator to allow either `name` or `names` keyword but not both.
|
|
This makes it easier to share code with base class.
|
c ór d|v rd|v r t d« d|v r|j d« |d< | g|¢i |¤S )NÚnameÚnamesz*Can only provide one of `names` and `name`)Ú TypeErrorÚpop)Ú self_or_clsÚargsÚkwargsÚmeths r` Únew_methz names_compat.<locals>.new_methØ sM ø à VÑ ¨6Ñ 1ÜÐ HÓIÐ IØ VÑ Ø $jj¨Ó 0F7OáKÐ1 $Ò1¨&Ñ1Ð1rb )r r r )rz r{ s ` r` Ú names_compatr| Ñ s* ø ô 4[ó2ó ð2ô 8Ó Ð rb c ó
|
e Zd ZU dZej
|
e« z ZdZg Zde d< e
|
« Z e
|
« Z dgZ de d< d dd Zdd Z d dd Zedej& f dd« Zee d dd« « Zedej& f dd« Ze d dd« Zed d« Zed d« Z ed « Z ed¡d« Z d¢dZ ed¢d« Z ed£d« Z!dd d
|
d d d¤dZ"dd
|
d d¥d Z#ed¢d « Z$ed¦d « Z%ed£d « Z&dd d
|
d d d¤d Z'dd
|
d d¥d!Z(ed" « Z)ed§d#« Z* e+ejX « ej& fd¨d$« Z,d©d%Z- dª d«d&Z.dd d'Z/d¬dd(Z0 e+ejb « d®d)« Z1ed¯d*« Z2d°d+Z3 e+ejh « d±d²d,« Z4ed¢d-« Z5d±d²d.Z6d/ Z7d0d1 d³d2Z8 d´ dµd3Z9dd4 d¶d5Z:d£d6Z;dd
|
d7d·d8Z< ee<e;d9¬:« Z=ed¸d;« Z>d¢d<Z?ed°d=« Z@ed°d>« ZAed¹d?« ZB e+ej « dºd»d@« ZCeCZDddAZE e+ej « d¼d½dB« ZFd±d¾dCZGd¿dDZH e+ej « d¬dE« ZId
|
ej& d f dÀdFZJd¿dGZKd°dHZLed¢dI« ZMd±dÁdJZNd©dKZOdL ZPdM ZQdÂdNZR eSeTdO eUz « dà dÄdP« ZVdQ ZWdRdS dÅdTZX eSeTdU eUz « d¬dÆdV« ZY dÇ dÈdWZZ dÉ dÊdXZ[dËd©dYZ\d©dZZ]d©d[Z^ dÌ dÍd\Z_dÎd]Z` dÏ dÐd^ZadÑd_ZbdÒd`ZcdÓdaZded°db« Ze dÔ fdc ZfdÕ fdd ZgdÖdeZh d×dfZiddØ fdg ZjdÙdÚdhZkdÛdiZldj ZmdÜdÝdkZndÞdßdlZo dà dádmZpdÖdnZq dâdoZrdd©dpZsdãdqZtdädrZud© fds ZvdådtZwd©duZxdv Zyd©dwZzdædxZ{dy Z| e+ejú « dÌdçdz« Z}d{ Z~dèd|Zdéd}Zd©d~Z e+ej « d¬dêd« Zej Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d
« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z e
d« Z xZS )ërO aö
|
A multi-level, or hierarchical, index object for pandas objects.
|
|
Parameters
|
----------
|
levels : sequence of arrays
|
The unique labels for each level.
|
codes : sequence of arrays
|
Integers for each level designating which label at each location.
|
sortorder : optional int
|
Level of sortedness (must be lexicographically sorted by that
|
level).
|
names : optional sequence of objects
|
Names for each of the index levels. (name is accepted for compat).
|
copy : bool, default False
|
Copy the meta-data.
|
verify_integrity : bool, default True
|
Check that the levels/codes are consistent and valid.
|
|
Attributes
|
----------
|
names
|
levels
|
codes
|
nlevels
|
levshape
|
dtypes
|
|
Methods
|
-------
|
from_arrays
|
from_tuples
|
from_product
|
from_frame
|
set_levels
|
set_codes
|
to_frame
|
to_flat_index
|
sortlevel
|
droplevel
|
swaplevel
|
reorder_levels
|
remove_unused_levels
|
get_level_values
|
get_indexer
|
get_loc
|
get_locs
|
get_loc_level
|
drop
|
|
See Also
|
--------
|
MultiIndex.from_arrays : Convert list of arrays to MultiIndex.
|
MultiIndex.from_product : Create a MultiIndex from the cartesian product
|
of iterables.
|
MultiIndex.from_tuples : Convert list of tuples to a MultiIndex.
|
MultiIndex.from_frame : Make a MultiIndex from a DataFrame.
|
Index : The base pandas Index type.
|
|
Notes
|
-----
|
See the `user guide
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html>`__
|
for more.
|
|
Examples
|
--------
|
A new ``MultiIndex`` is typically constructed using one of the helper
|
methods :meth:`MultiIndex.from_arrays`, :meth:`MultiIndex.from_product`
|
and :meth:`MultiIndex.from_tuples`. For example (using ``.from_arrays``):
|
|
>>> arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']]
|
>>> pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
|
MultiIndex([(1, 'red'),
|
(1, 'blue'),
|
(2, 'red'),
|
(2, 'blue')],
|
names=['number', 'color'])
|
|
See further examples for how to construct a MultiIndex in the doc strings
|
of the mentioned helper methods.
|
Ú
|
multiindexzlist[Hashable | None]Ú_namesrt ú
|
int | NoneÚ sortorderNFTc ó ||}|| t d« t |« t |« k7 r t d« t |« dk( r t d« t j | « } i | _ | j ||d¬« | j ||d¬« d gt |« z | _ || j |« |t |« | _ n|| _ |r| j « }
|
|
|
| _ | j « d | _ | S )Nz Must pass both levels and codesz,Length of levels and codes must be the same.r z)Must pass non-zero number of levels/codesF)ÚcopyÚvalidate)ru ÚlenÚ
|
ValueErrorrn Ú__new__Ú_cacheÚ _set_levelsÚ
|
_set_codesr Ú
|
_set_namesÚintr Ú_verify_integrityÚ_codesÚ_reset_identityÚ _references) ÚclsÚlevelsr_ r rt Údtyper rs Úverify_integrityÚresultÚ new_codess r` r zMultiIndex.__new__F s
|
ð Ð ØEØ >U]ÜÐ =Ó>Ð >Ü v;#e*Ò $Ü Ð KÓLÐ LÜ v;!Ò Ü Ð HÓIÐ Iä Ó$Ø ð ×Ñ6¨°uÐÔ=Ø×Ñ% d°UÐÔ;à ¤ V£Ñ, Ø Ð à × Ñ eÔ $à Ð Ü " 9~FÕ à (FÔ á Ø ×0Ñ0Ó2IØ %FMà× Ñ Ô Ø !Ôà rb c óz t |« }t j |« rt j || d|« }|S )a
|
Reassign code values as -1 if their corresponding levels are NaN.
|
|
Parameters
|
----------
|
code : list
|
Code to reassign.
|
level : list
|
Level to check for missing values (NaN, NaT, None).
|
|
Returns
|
-------
|
new code where code value = -1 if it corresponds
|
to a level with missing values (NaN, NaT, None).
|
éÿÿÿÿ)r; rZ ÚanyÚwhere)r^ ÚlevelÚcodeÚ null_masks r` Ú_validate_codeszMultiIndex._validate_codesu s6 ô K Ü 66)Ô ô 88I dO¨R°Ó6DØ rb c ó |xs | j }|xs | j }|t t |« « }t |« t |« k7 r t d« t |d « }|D ]ö }|| }|| }t |« |k7 r%t d|D cg c] }t |« c} « t |« rH|j « t |« k\ r,t d| d|j « dt |« d« t |« r3|j « dk r t d| d |j « d
|
« |j rÞt d t |« d | « | j f| j t | j | j « kD r9t d | j dt | j | j « « g } t t |« « D ]B }||v r(| j | j || || « « /| j || « D t | « }
|
|
|
S c c}w )a
|
Parameters
|
----------
|
codes : optional list
|
Codes to check for validity. Defaults to current codes.
|
levels : optional list
|
Levels to check for validity. Defaults to current levels.
|
levels_to_validate: optional list
|
Specifies the levels to verify.
|
|
Raises
|
------
|
ValueError
|
If length of levels and codes don't match, if the codes for any
|
level would exceed level bounds, or there are any duplicate levels.
|
|
Returns
|
-------
|
new codes where code value = -1 if it corresponds to a
|
NaN level.
|
zTLength of levels and codes must match. NOTE: this index is in an inconsistent state.r zUnequal code lengths: z On level z , code max (z) >= length of level (z/). NOTE: this index is in an inconsistent stater z, code value (z) < -1z Level values must be unique: z
|
on level zQValue for sortorder must be inferior or equal to actual lexsort_depth: sortorder z with lexsort_depth )r_ r Úranger
r ÚmaxÚminÚ is_uniqueÚlistr Ú_lexsort_depthÚnlevelsÚappendr rF ) r^ r_ r Úlevels_to_verifyÚ codes_lengthÚir Ú level_codesÚcode_Ú result_codesr s r` r z MultiIndex._verify_integrity sN ð: Ò#ØÒ&4;;Ø Ð #Ü $¤S¨£[Ó 1Ð ä v;#e*Ò $Ü ð:óð ô 5 8} Ø!ò AØ1IEØ (Kä;Ó <Ò/Ü Ø,ÀeÖ-L¸U¬c°%jÒ-LÐ,MÐNóð ô ;Ô K§O¡OÓ$5¼¸U»Ò$CÜ Ø s ,¨{¯©Ó/@Ð.Að B Ü ! %j\ð *)ð)óð ô
|
;Ô K§O¡OÓ$5¸Ò$:Ü 9¨Q¨C¨~¸k¿o¹oÓ>OÐ=PÐPVÐ!WÓXÐXØ??Ü Ø3´D¸³K°=À
|
È1È#ÐNóð ð# ð( >>Ð %Ø~~¤¨t¯z©z¸4¿<¹<Ó HÒHÜ ð0Ø04·±Ð/?ð @*Ü*8¸¿¹ÀTÇ\Á\Ó*RÐ)SðUóð ð Üs6{Ó#ò .AØÐ$Ñ$Ø ×#Ñ# D×$8Ñ$8¸À¹ÀEÈ!ÁHÓ$MÕNà ×#Ñ# E¨!¡HÕ-ð .ô |Ó, ØÐùò= .Ms ÂH< c óº d}t |« s t |« t |« r t |« }|D ] }t |« rt |« t dt |« « D ]- }t || « t ||dz
|
« k7 s$t d« t |« \ }}|t j u r|D cg c] } t | dd« }} | ||||d¬« S c c} w )a
|
Convert arrays to MultiIndex.
|
|
Parameters
|
----------
|
arrays : list / sequence of array-likes
|
Each array-like gives one level's value for each data point.
|
len(arrays) is the number of levels.
|
sortorder : int or None
|
Level of sortedness (must be lexicographically sorted by that
|
level).
|
names : list / sequence of str, optional
|
Names for the levels in the index.
|
|
Returns
|
-------
|
MultiIndex
|
|
See Also
|
--------
|
MultiIndex.from_tuples : Convert list of tuples to MultiIndex.
|
MultiIndex.from_product : Make a MultiIndex from cartesian product
|
of iterables.
|
MultiIndex.from_frame : Make a MultiIndex from a DataFrame.
|
|
Examples
|
--------
|
>>> arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']]
|
>>> pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
|
MultiIndex([(1, 'red'),
|
(1, 'blue'),
|
(2, 'red'),
|
(2, 'blue')],
|
names=['number', 'color'])
|
z/Input must be a list / sequence of array-likes.rU z all arrays must be same lengthrs NF©r r_ r rt r ) r0 ru r/ r¤ r r
r r? r Ú
|
no_defaultÚgetattr)
|
r Úarraysr rt Ú error_msgÚarrayrª r_ r Úarrs
|
r` Ú from_arrayszMultiIndex.from_arraysÛ sô ðT F ÜFÔ#ÜIÓ&Ð &Ü vÔ Ü&\Fð ò +EÜ Õ&Ü Ó*Ð*ð +ô q#f+Ó&ò CAÜ6!9~¤ V¨A°©E¡]Ó!3Ó3Ü Ð!AÓBÐBð Cô 1°Ó8 vØ CNNÑ "Ø;AÖB°CWS &¨$Õ/ÐBEÐBáØØØ ØØ "ô
|
ð
|
ùò Cs Â5Cc óÀ t |« s t d« t |« r t |« }t t
|
t t df |« }t |« rrt d |D « « r`t j t |« « g}t t j |t j d« ¬« « g} | ||||d¬« S t |« dk( r | t d « g gt |« z }n×t! |t j" t f« rXt! |t « r t j$ |j& « }t t) j* |« j, « }n_t! |t « r)t t) j. |« j, « }n&t1 | }t t t2 t |« }| j5 |||¬
|
« S ) a}
|
Convert list of tuples to MultiIndex.
|
|
Parameters
|
----------
|
tuples : list / sequence of tuple-likes
|
Each tuple is the index of one row/column.
|
sortorder : int or None
|
Level of sortedness (must be lexicographically sorted by that
|
level).
|
names : list / sequence of str, optional
|
Names for the levels in the index.
|
|
Returns
|
-------
|
MultiIndex
|
|
See Also
|
--------
|
MultiIndex.from_arrays : Convert list of arrays to MultiIndex.
|
MultiIndex.from_product : Make a MultiIndex from cartesian product
|
of iterables.
|
MultiIndex.from_frame : Make a MultiIndex from a DataFrame.
|
|
Examples
|
--------
|
>>> tuples = [(1, 'red'), (1, 'blue'),
|
... (2, 'red'), (2, 'blue')]
|
>>> pd.MultiIndex.from_tuples(tuples, names=('number', 'color'))
|
MultiIndex([(1, 'red'),
|
(1, 'blue'),
|
(2, 'red'),
|
(2, 'blue')],
|
names=['number', 'color'])
|
z/Input must be a list / sequence of tuple-likes..c 3 óF K | ] }t |t « xr | y w©N)Ú
|
isinstanceÚtuple)Ú.0Úes r` ú <genexpr>z)MultiIndex.from_tuples.<locals>.<genexpr>T s! è ø Ò NÀ!z¨!¬UÓ 3Ò =¸A¸Ó =Ñ Nùs !rn ©r Fr¯ r z-Cannot infer number of levels from empty list©r rt )r0 ru r/ r¤ r r r» r r
ÚallrZ ÚzerosrB ÚcomÚasarray_tuplesafer rº ÚndarrayÚasarrayÚ_valuesr Útuples_to_object_arrayÚTÚto_object_array_tuplesÚzipr r¶ )r Útuplesr rt r_ r r² Úarrss r` Ú from_tupleszMultiIndex.from_tuples" s ôV FÔ#ÜÐ MÓNÐ NÜ vÔ Ü&\FÜj¤¤x° }Ñ!5Ñ6¸Ó?ô v;3Ñ NÀvÔ NÔNÜXXc &kÓ*Ð+EÜC× 1Ñ 1°&ÄÇÁÈÓ@RÔ SÓTÐUFÙØ ØØ#ØØ!&ô ð ô v;!Ò Ø}Ü Ð OÓPÐPð TC JÑ&FÜ ¤§¡¬UÐ 3Ô 4Ü&¤%Ô(Ü F§N¡NÓ3ä#×4Ñ4°VÓ<×>Ñ>Ó?FÜ ¤Ô %Ü#×4Ñ4°VÓ<×>Ñ>Ó?Fä<DÜ$x¬Ñ 1Ñ2°DÓ9Fàv°À%ÓHÐHrb c ó ddl m} t |« s t d« t |« r t |« }t |« \ }}|t j u r|D cg c] }t |dd« }} ||« } | ||||¬« S c c}w )at
|
Make a MultiIndex from the cartesian product of multiple iterables.
|
|
Parameters
|
----------
|
iterables : list / sequence of iterables
|
Each iterable has unique labels for each level of the index.
|
sortorder : int or None
|
Level of sortedness (must be lexicographically sorted by that
|
level).
|
names : list / sequence of str, optional
|
Names for the levels in the index.
|
If not explicitly provided, names will be inferred from the
|
elements of iterables if an element has a name attribute.
|
|
Returns
|
-------
|
MultiIndex
|
|
See Also
|
--------
|
MultiIndex.from_arrays : Convert list of arrays to MultiIndex.
|
MultiIndex.from_tuples : Convert list of tuples to MultiIndex.
|
MultiIndex.from_frame : Make a MultiIndex from a DataFrame.
|
|
Examples
|
--------
|
>>> numbers = [0, 1, 2]
|
>>> colors = ['green', 'purple']
|
>>> pd.MultiIndex.from_product([numbers, colors],
|
... names=['number', 'color'])
|
MultiIndex([(0, 'green'),
|
(0, 'purple'),
|
(1, 'green'),
|
(1, 'purple'),
|
(2, 'green'),
|
(2, 'purple')],
|
names=['number', 'color'])
|
r )Úcartesian_productz-Input must be a list / sequence of iterables.rs NrÀ )
|
Úpandas.core.reshape.utilrÐ r0 ru r/ r¤ r? r r° r± )r Ú iterablesr rt rÐ r_ r Úits r` Ú from_productzMultiIndex.from_products s õ\ ?äIÔ&ÜÐ KÓLÐ LÜ yÔ !Ü YIä0°Ó; vØ CNNÑ "Ø9BÖC°2WR ¨Õ.ÐCEÐCñ " %Ó(Ù65¨I¸UÔCÐCùò Ds ÁBc ó t |t « s t d« t |j « \ }}||n|}| j |||¬« S )aK
|
Make a MultiIndex from a DataFrame.
|
|
Parameters
|
----------
|
df : DataFrame
|
DataFrame to be converted to MultiIndex.
|
sortorder : int, optional
|
Level of sortedness (must be lexicographically sorted by that
|
level).
|
names : list-like, optional
|
If no names are provided, use the column names, or tuple of column
|
names if the columns is a MultiIndex. If a sequence, overwrite
|
names with the given sequence.
|
|
Returns
|
-------
|
MultiIndex
|
The MultiIndex representation of the given DataFrame.
|
|
See Also
|
--------
|
MultiIndex.from_arrays : Convert list of arrays to MultiIndex.
|
MultiIndex.from_tuples : Convert list of tuples to MultiIndex.
|
MultiIndex.from_product : Make a MultiIndex from cartesian product
|
of iterables.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([['HI', 'Temp'], ['HI', 'Precip'],
|
... ['NJ', 'Temp'], ['NJ', 'Precip']],
|
... columns=['a', 'b'])
|
>>> df
|
a b
|
0 HI Temp
|
1 HI Precip
|
2 NJ Temp
|
3 NJ Precip
|
|
>>> pd.MultiIndex.from_frame(df)
|
MultiIndex([('HI', 'Temp'),
|
('HI', 'Precip'),
|
('NJ', 'Temp'),
|
('NJ', 'Precip')],
|
names=['a', 'b'])
|
|
Using explicit names, instead of the column names
|
|
>>> pd.MultiIndex.from_frame(df, names=['state', 'observation'])
|
MultiIndex([('HI', 'Temp'),
|
('HI', 'Precip'),
|
('NJ', 'Temp'),
|
('NJ', 'Precip')],
|
names=['state', 'observation'])
|
zInput must be a DataFramerÀ )rº r7 ru rË Úitemsr¶ )r Údfr rt Ú column_namesÚcolumnss r` Ú
|
from_framezMultiIndex.from_frame° sP ô| "lÔ+ÜÐ 7Ó8Ð 8ä # R§X¡X£ZÐ 0Ñ gØ % °5Øw°)À5ÓIÐIrb c óV g }t | j « D ]ù }| j | }| j | }|}t |j
|
t « r&t d|« }|j j « }t |j
|
t « s t j |j
|
d« r|j t « }t j |« }t# j$ |||j& ¬« }|j) |« û t j* |« }|S )NrL ÚmM©Ú
|
fill_value)r r¦ r r_ rº r r5 r Ú_dataÚ_internal_get_valuesr6 r Ú is_np_dtypero rn rZ rÆ r Útake_ndÚ _na_valuer§ Úfast_zip)r^ Úvaluesrª r r_ Úvalsrµ s r` rÇ zMultiIndex._values÷ så ð ät||Ó$ò AØKK NEØJJqMEàDÜ$**Ô&6Ô7ÜÐ .°Ó5Øzz×6Ñ6Ó8ä$**¤nÔ5¼¿ ¹ Ø
|
|
Dô:ð {{¤6Ó*ä::dÓ#DÜ== u¸¿ ¹ ÔIDØ MM$Õ ð! ô$ ll6Ó"Ø
|
rb c ó | j S r¹ ©rÇ ©r^ s r` rå zMultiIndex.values s à||Ðrb c ó t d« )z¦
|
Raises a ValueError for `MultiIndex` because there's no single
|
array backing a MultiIndex.
|
|
Raises
|
------
|
ValueError
|
zcMultiIndex has no single backing array. Use 'MultiIndex.to_numpy()' to get a NumPy array of tuples.)r ré s r` r´ zMultiIndex.array s ô ð Fó
|
ð
|
rb c óú ddl m} t j | j D cg c] }|j
|
c}« } || j D cg c] }|j c}t |« ¬« S c c}w c c}w )ax
|
Return the dtypes as a Series for the underlying MultiIndex.
|
|
Examples
|
--------
|
>>> idx = pd.MultiIndex.from_product([(0, 1, 2), ('green', 'purple')],
|
... names=['number', 'color'])
|
>>> idx
|
MultiIndex([(0, 'green'),
|
(0, 'purple'),
|
(1, 'green'),
|
(1, 'purple'),
|
(2, 'green'),
|
(2, 'purple')],
|
names=['number', 'color'])
|
>>> idx.dtypes
|
number int64
|
color object
|
dtype: object
|
r )rN )r )ÚpandasrN rà Úfill_missing_namesr rs r rB )r^ rN r rt s r` ÚdtypeszMultiIndex.dtypes$ sW õ, "ä×&Ñ&ÀÇ Á Ö'L°u¨¯
|
«
|
Ò'LÓMÙ°· ± Ö< uu{{Ò<ÄEÈ%ÃLÔQÐQùò (MùÚ<s ¤A3ÁA8c ó2 t | j d « S ©Nr )r
r_ ré s r` Ú__len__zMultiIndex.__len__? s Ü4::a=Ó!Ð!rb c ó t | « S )zG
|
Return the number of elements in the underlying data.
|
©r
ré s r` ÚsizezMultiIndex.sizeB s ô 4yÐrb c óÄ t | j | j « D cg c] \ }}|j |¬« }}}|D ] }d|_ t |« S c c}}w )aA
|
Levels of the MultiIndex.
|
|
Levels refer to the different hierarchical levels or layers in a MultiIndex.
|
In a MultiIndex, each level represents a distinct dimension or category of
|
the index.
|
|
To access the levels, you can use the levels attribute of the MultiIndex,
|
which returns a tuple of Index objects. Each Index object represents a
|
level in the MultiIndex and contains the unique values found in that
|
specific level.
|
|
If a MultiIndex is created with levels A, B, C, and the DataFrame using
|
it filters out all rows of the level C, MultiIndex.levels will still
|
return A, B, C.
|
|
Examples
|
--------
|
>>> index = pd.MultiIndex.from_product([['mammal'],
|
... ('goat', 'human', 'cat', 'dog')],
|
... names=['Category', 'Animals'])
|
>>> leg_num = pd.DataFrame(data=(4, 2, 4, 4), index=index, columns=['Legs'])
|
>>> leg_num
|
Legs
|
Category Animals
|
mammal goat 4
|
human 2
|
cat 4
|
dog 4
|
|
>>> leg_num.index.levels
|
FrozenList([['mammal'], ['cat', 'dog', 'goat', 'human']])
|
|
MultiIndex levels will not change even if the DataFrame using the MultiIndex
|
does not contain all them anymore.
|
See how "human" is not in the DataFrame, but it is still in levels:
|
|
>>> large_leg_num = leg_num[leg_num.Legs > 2]
|
>>> large_leg_num
|
Legs
|
Category Animals
|
mammal goat 4
|
cat 4
|
dog 4
|
|
>>> large_leg_num.index.levels
|
FrozenList([['mammal'], ['cat', 'dog', 'goat', 'human']])
|
©rs T)rË Ú_levelsr Ú_renameÚ_no_setting_namerF )r^ Úxrs r r s r` r zMultiIndex.levelsM s` ôj 7:¸$¿,¹,ÈÏ É Ó6T×U©7¨1¨d!)) )Õ&ÐUÑUØò *Eà%)EÕ "ð *ô &Ó!Ð!ùó Vs ¤ A )r r r r c óÖ |rbt |« dk( r t d« |#t |« | j k7 r t d« |"t |« t |« k7 r t d« |2t fd|D « « }t t t |« « « }np|D cg c] }| j |« }}t | j « } t ||« D ]# \ }
|
}t |¬« j « | |
|
< % t | « }|r| j ||¬« } | | _ | j } || _ t | « r| j | « | j! « y c c}w )Nr z#Must set non-zero number of levels.z-Length of levels must match number of levels.z,Length of levels must match length of level.c 3 óT K | ] }t |¬ « j « ! yw©©r N)rD Ú_view)r¼ Úlevr s r` r¾ z)MultiIndex._set_levels.<locals>.<genexpr> s& øè ø ò $Ø9< S tÔ,×2Ñ2×4ñ$ùs %(rþ )r r¨ )r
r r¦ rF r¤ r Ú_get_level_numberr÷ rË rD rÿ r r rt r r Ú _reset_cache) r^ r r r r r Ú
|
new_levelsÚ level_numbersr Únew_levels_listÚlev_numr rt s ` r` r zMultiIndex._set_levels sY ø ñ Ü6{aÒ Ü Ð!FÓGÐGØ}¤ V£°· ± Ò!<Ü Ð!PÓQÐQØÐ ¤S¨£[´C¸³JÒ%>Ü Ð!OÓPÐPà =Ü#ó $Ø@Fô$ó Jô !¤¤s¨:£Ó!7Ó 8MàDIÖ J¸ST× 3Ñ 3°CÕ 8Ð JMÐ JÜ " 4§<¡<Ó 0OÜ # M°6Ó :ò P Ü+7¸À$Ô+G×+MÑ+MÓ+O Ò(ð Pä# OÓ4Já Ø ×.Ñ.Ø!°Mð /ó Ið $DKà
|
|
Ø! Ü u:Ø OOEÔ "à ×ÑÕùò# Ks  E&©r r c ó t |t « rn-t |« r t |« }nt |« r t |« }t ||d« \ }}| j « }|j « |j ||d|¬« |S )aé
|
Set new levels on MultiIndex. Defaults to returning new index.
|
|
Parameters
|
----------
|
levels : sequence or list of sequence
|
New level(s) to apply.
|
level : int, level name, or sequence of int/level names (default None)
|
Level(s) to set (None for all levels).
|
verify_integrity : bool, default True
|
If True, checks that levels and codes are compatible.
|
|
Returns
|
-------
|
MultiIndex
|
|
Examples
|
--------
|
>>> idx = pd.MultiIndex.from_tuples(
|
... [
|
... (1, "one"),
|
... (1, "two"),
|
... (2, "one"),
|
... (2, "two"),
|
... (3, "one"),
|
... (3, "two")
|
... ],
|
... names=["foo", "bar"]
|
... )
|
>>> idx
|
MultiIndex([(1, 'one'),
|
(1, 'two'),
|
(2, 'one'),
|
(2, 'two'),
|
(3, 'one'),
|
(3, 'two')],
|
names=['foo', 'bar'])
|
|
>>> idx.set_levels([['a', 'b', 'c'], [1, 2]])
|
MultiIndex([('a', 1),
|
('a', 2),
|
('b', 1),
|
('b', 2),
|
('c', 1),
|
('c', 2)],
|
names=['foo', 'bar'])
|
>>> idx.set_levels(['a', 'b', 'c'], level=0)
|
MultiIndex([('a', 'one'),
|
('a', 'two'),
|
('b', 'one'),
|
('b', 'two'),
|
('c', 'one'),
|
('c', 'two')],
|
names=['foo', 'bar'])
|
>>> idx.set_levels(['a', 'b'], level='bar')
|
MultiIndex([(1, 'a'),
|
(1, 'b'),
|
(2, 'a'),
|
(2, 'b'),
|
(3, 'a'),
|
(3, 'b')],
|
names=['foo', 'bar'])
|
|
If any of the levels passed to ``set_levels()`` exceeds the
|
existing length, all of the values from that argument will
|
be stored in the MultiIndex levels, though the values will
|
be truncated in the MultiIndex output.
|
|
>>> idx.set_levels([['a', 'b', 'c'], [1, 2, 3, 4]], level=[0, 1])
|
MultiIndex([('a', 1),
|
('a', 2),
|
('b', 1),
|
('b', 2),
|
('c', 1),
|
('c', 2)],
|
names=['foo', 'bar'])
|
>>> idx.set_levels([['a', 'b', 'c'], [1, 2, 3, 4]], level=[0, 1]).levels
|
FrozenList([['a', 'b', 'c'], [1, 2, 3, 4]])
|
ÚLevelsT)r r r ) rº rB r9 r0 r¤ Ú_require_listlikerÿ r r )r^ r r r Úidxs r` Ú
|
set_levelszMultiIndex.set_levelsµ s ôf feÔ $Ø Ü 6Ô "Ü6]FÜ &Ô !Ü&\Fä)¨%°¸ÓB vØjjlØ ×ÑÔ Ø Ø %¨$ÐAQð ô
|
ð
|
rb c ó, t | j « S )a
|
Integer number of levels in this MultiIndex.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']])
|
>>> mi
|
MultiIndex([('a', 'b', 'c')],
|
)
|
>>> mi.nlevels
|
3
|
)r
r÷ ré s r` r¦ zMultiIndex.nlevels s ô 4<<Ó Ð rb c ó: t d | j D « « S )a
|
A tuple with the length of each level.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']])
|
>>> mi
|
MultiIndex([('a', 'b', 'c')],
|
)
|
>>> mi.levshape
|
(1, 1, 1)
|
c 3 ó2 K | ] }t |« y wr¹ ró ©r¼ rú s r` r¾ z&MultiIndex.levshape.<locals>.<genexpr>5 s è ø Ò1 SVÑ1ùó )r» r ré s r` ÚlevshapezMultiIndex.levshape' s ô Ñ1 T§[¡[Ô1Ó1Ð1rb c ó | j S r¹ )r ré s r` r_ zMultiIndex.codes: s à{{Ðrb c ó` |rI|#t |« | j k7 r t d« |"t |« t |« k7 r t d« |=t fdt | j
|
|« D « « }t t |« « }nr|D cg c] }| j |« }}t | j « } t ||« D ]% \ }
|
} | j |
|
}t | |¬« | |
|
< ' t | « }|r| j ||¬« }|| _ | j « y c c}w )Nz+Length of codes must match number of levelsz,Length of codes must match length of levels.c 3 ó\ K | ]# \ }}t ||¬ « j « % ywrý )Ú_coerce_indexer_frozenÚview)r¼ r r« r s r` r¾ z(MultiIndex._set_codes.<locals>.<genexpr>O s/ øè ø ò #á$Cô ' {°C¸dÔC×HÑH×Jñ#ùs ),rþ )r_ r¨ )r
r¦ r rF rË r÷ r r r¤ r r r r r ) r^ r_ r r r r r r r Únew_codes_listr r« s ` r` r zMultiIndex._set_codes> s1 ø ñ Ø}¤ U£¨t¯|©|Ò!;Ü Ð!NÓOÐOØÐ ¤S¨£Z´3°u³:Ò%=Ü Ð!OÓPÐPð =Ü"ó #ä(+¨D¯L©L¸%Ó(@ô#ó Iô "¤# i£.Ó 1MàDIÖ J¸ST× 3Ñ 3°CÕ 8Ð JMÐ JÜ ! $§+¡+Ó .NÜ(+¨M¸5Ó(Aò Ñ$Økk 'Ñ*Ü*@Ø ¨4ô+wÒ'ð ô
|
# >Ó2Iá Ø ×.Ñ.Ø °-ð /ó Ið à ×ÑÕùò! Ks ÂD+c ó t ||d« \ }}| j « }|j « |j |||¬« |S )a0
|
Set new codes on MultiIndex. Defaults to returning new index.
|
|
Parameters
|
----------
|
codes : sequence or list of sequence
|
New codes to apply.
|
level : int, level name, or sequence of int/level names (default None)
|
Level(s) to set (None for all levels).
|
verify_integrity : bool, default True
|
If True, checks that levels and codes are compatible.
|
|
Returns
|
-------
|
new index (of same type and class...etc) or None
|
The same type as the caller or None if ``inplace=True``.
|
|
Examples
|
--------
|
>>> idx = pd.MultiIndex.from_tuples(
|
... [(1, "one"), (1, "two"), (2, "one"), (2, "two")], names=["foo", "bar"]
|
... )
|
>>> idx
|
MultiIndex([(1, 'one'),
|
(1, 'two'),
|
(2, 'one'),
|
(2, 'two')],
|
names=['foo', 'bar'])
|
|
>>> idx.set_codes([[1, 0, 1, 0], [0, 0, 1, 1]])
|
MultiIndex([(2, 'one'),
|
(1, 'one'),
|
(2, 'two'),
|
(1, 'two')],
|
names=['foo', 'bar'])
|
>>> idx.set_codes([1, 0, 1, 0], level=0)
|
MultiIndex([(2, 'one'),
|
(1, 'two'),
|
(2, 'one'),
|
(1, 'two')],
|
names=['foo', 'bar'])
|
>>> idx.set_codes([0, 0, 1, 1], level='bar')
|
MultiIndex([(1, 'one'),
|
(1, 'one'),
|
(2, 'two'),
|
(2, 'two')],
|
names=['foo', 'bar'])
|
>>> idx.set_codes([[1, 0, 1, 0], [0, 0, 1, 1]], level=[0, 1])
|
MultiIndex([(2, 'one'),
|
(1, 'one'),
|
(2, 'two'),
|
(1, 'two')],
|
names=['foo', 'bar'])
|
ÚCodesr )r
|
rÿ r r )r^ r_ r r r s r` Ú set_codeszMultiIndex.set_codesg sF ôt )¨°°wÓ? uØjjlØ ×ÑÔ Ø u EÐ<LÔMØ
|
rb c
|
óê t j t j | j D cg c] }t |« t
|
j z c}« « }t j |d d d
« d d d
}t j |dd dgg« j d« }|d dkD r!t | j | j |« S t | j | j |« S c c}w )Nr rU r Úuint64é@ ) rZ ÚceilÚlog2r r
rg Úmultiindex_nulls_shiftÚcumsumÚ concatenatero rl r_ rS )r^ r ÚsizesÚlev_bitsrX s r` Ú_enginezMultiIndex._engineª sÊ ô Ü GGØKOÏ;É;ÖWÀ%Uh× =Ñ =Ó=ÒWó ó
|
ô 99U¡4 R 4[Ó)©$¨B¨$Ñ/ô .. (¨1¨2 ,°°Ð!4Ó5×<Ñ<¸XÓFð A;Ò ä(¨¯©°d·j±jÀ'ÓJÐ JÜ# D§K¡K°·±¸WÓEÐEùò% Xs #C0 c ó, t | « j S r¹ )ÚtyperÎ ré s r` Ú _constructorzMultiIndex._constructorÈ s äDz×%Ñ%Ð%rb c ó| |t j ur|n | j }t | « j |d |¬« S )NrÀ )r r° rt r( rÎ )r^ rå rs rt s r` Ú _shallow_copyzMultiIndex._shallow_copyÌ s4 à ¤C§N¡NÑ2¸¿
|
¹
|
äDz×%Ñ% f¸ÀEÐ%ÓJÐJrb c óø t | « | j | j | j | j d¬« }| j
|
j « |_ |j
|
j dd « |S )NFr¯ r )r( r r_ r rt r r rv )r^ r s r` rÿ zMultiIndex._viewÒ s` ØdØ;;Ø**ØnnØ**Ø "ô
|
ð ×(Ñ(Ó* Ø ×Ñ( DÔ)Ø rb c ó² | j |||¬« }| }d\ }}|r*ddlm} || j « } || j « }||n | j }||n | j } t | « ||| j |d¬« }| j j « |_ |j j dd« |r| j |_ |S ) a
|
Make a copy of this object.
|
|
Names, dtype, levels and codes can be passed and will be set on new copy.
|
|
Parameters
|
----------
|
names : sequence, optional
|
deep : bool, default False
|
name : Label
|
Kept for compatibility with 1-dimensional Index. Should not be used.
|
|
Returns
|
-------
|
MultiIndex
|
|
Notes
|
-----
|
In most cases, there should be no functional difference from using
|
``deep``, but if ``deep`` is passed it will attempt to deepcopy.
|
This could be potentially expensive on large MultiIndex objects.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']])
|
>>> mi
|
MultiIndex([('a', 'b', 'c')],
|
)
|
>>> mi.copy()
|
MultiIndex([('a', 'b', 'c')],
|
)
|
)rs rt Údeep©NNr )ÚdeepcopyNFr¯ r )
|
Ú_validate_namesr r0 r r_ r( r r rv Ú_id) r^ rt r. rs Úkeep_idr r_ r0 Ú new_indexs r` r zMultiIndex.copyá sÒ ðL ×$Ñ$¨$°eÀ$Ð$ÓGØ(Ø" á Ý %á dkkÓ*FÙ TZZÓ(Eà!Ð-°4·;±;Ø Ð*°·
|
±
|
à DJØØØnnØØ "ô
|
ð ;;×+Ñ+Ó- ÔØ×Ñ× Ñ X tÔ,Ù Ø HHIMØÐrb c ó´ |du r$t j dt t « ¬« |du r!t j
|
| j |¬« S | j S )z%the array interface, return my valuesFaS Starting with NumPy 2.0, the behavior of the 'copy' keyword has changed and passing 'copy=False' raises an error when returning a zero-copy NumPy array is not possible. pandas will follow this behavior starting with pandas 3.0.
|
This conversion to NumPy requires a copy, but 'copy=False' was passed. Consider using 'np.asarray(..)' instead.©Ú
|
stacklevelTr¿ )ÚwarningsÚwarnÚ FutureWarningr) rZ r´ rå )r^ r r s r` Ú __array__zMultiIndex.__array__! sO à 5=ä MMð2ô Ü+Ó-õ ð 4<ô 88DKK¨uÔ5Ð 5Ø{{Ðrb c óH | j « }| j |_ |S )z0this is defined as a copy with the same identity)r r2 )r^ r r s r` r zMultiIndex.view5 s àØXX
|
Ø rb c ór t |« | j |« y# t t t f$ r Y yw xY w)NTF)ÚhashÚget_locÚ LookupErrorru r ©r^ Úkeys r` Ú __contains__zMultiIndex.__contains__; s6 ä S ð Ø LLÔ ØøÜY¬
|
Ð3ò Ùð ús 6µ6c ó, t j d« S )NÚO)rZ r ré s r` r zMultiIndex.dtypeD s äxx}Ð rb c óH ddt fd| j D « « S )z5return a boolean if we need a qualified .info displayc óT t | « xs t | « xr | j dk( S )NÚpython)r1 r3 Ústorager¿ s r` Úfz0MultiIndex._is_memory_usage_qualified.<locals>.fK s* Ü" 5Ó)ò Ü Ó&ÒD¨5¯=©=¸HÑ+Dð rb c 3 óB K | ] } |j « y wr¹ r¿ )r¼ r rJ s r` r¾ z8MultiIndex._is_memory_usage_qualified.<locals>.<genexpr>P s øè ø Ò; e1U[[>Ñ;ùó ©ÚreturnÚbool)r r )r^ rJ s @r` Ú_is_memory_usage_qualifiedz%MultiIndex._is_memory_usage_qualifiedH s ø ó ô
|
Ó;¨t¯{©{Ô;Ó;Ð;rb c ó$ | j |« S r¹ ©Ú_nbytes)r^ r. s r` Ú memory_usagezMultiIndex.memory_usageS s ð
|
||DÓ!Ð!rb c ó$ | j d« S )z1return the number of bytes in the underlying dataFrR ré s r` ÚnbyteszMultiIndex.nbytesZ s ð ||EÓ"Ð"rb c ó dt fd| j D « « }t d | j D « « }t fd| j D « « }||z |z }|| j j ¬« z }|S )zÇ
|
return the number of bytes in the underlying data
|
deeply introspect the level data if deep=True
|
|
include the engine hashtable
|
|
*this is in internal routine*
|
|
é c 3 óB K | ] }|j ¬ « yw)©r. N)rT )r¼ rª r. s r` r¾ z%MultiIndex._nbytes.<locals>.<genexpr>l s øè ø ÒJ¸1>>¨t>×4ÑJùrL c 3 ó4 K | ] }|j y wr¹ )rV )r¼ rª s r` r¾ z%MultiIndex._nbytes.<locals>.<genexpr>m s è ø Ò8¨188Ñ8ùó c 3 ó6 K | ] }t |« y wr¹ r
|
)r¼ rª Úobjsizes r` r¾ z%MultiIndex._nbytes.<locals>.<genexpr>n s øè ø ÒE°Q9 Q¨×0ÑEùs rZ )Úsumr r_ rt r& Úsizeof)r^ r. Ú level_nbytesÚ label_nbytesÚ names_nbytesr r^ s ` @r` rS zMultiIndex._nbytes_ sx ù ð äÓJ¸d¿k¹kÔJÓJ ÜÑ8¨T¯Z©ZÔ8Ó8 ÜÓE¸$¿*¹*ÔEÓE Ø Ñ,¨|Ñ;ð $,,×%Ñ%¨4Ð%Ó0Ñ0Ø rb c ó | j D cg c] }|j }}t d t ||« D « « S c c}w )zW
|
Formats each item in tup according to its level's formatter function.
|
c 3 ó2 K | ] \ }} ||« y wr¹ rj )r¼ ÚfuncÚvals r` r¾ z-MultiIndex._formatter_func.<locals>.<genexpr>} s è ø ÒJ¡9 4¨T#YÑJùr )r Ú_formatter_funcr» rË )r^ Útupr Úformatter_funcss r` rh zMultiIndex._formatter_funcx s@ ð ?C¿k¹kÖJ°U5×0Ó0ÐJÐJÜÑJ´°OÀSÓ0IÔJÓJÐJùò Ks A Únan)Úna_repc ó g }g }t | j | j « D ]³ \ }} |j dd|i|¤}|dk( }|j « rct |« } |j t « }t j ||« }|j j rJ |j « }| ||< |j |« |j |« µ t |« dk( r.t |d j |d « « j « S t ||| j | j" d¬« }
|
|
|
j$ S )Nrl r rU r F©r r_ rt r r rj )rË r r_ Ú_get_values_for_csvr r
ro ÚstrrZ r§ ÚflagsÚ writeabler rB ÚtakerO rt r rÇ ) r^ rl ry r r r r« Ú
|
level_strsÚmaskÚ nan_indexÚmis r` ro z MultiIndex._get_values_for_csv s6 ð
|
Ø ô #& d§k¡k°4·:±:Ó">ò *Ñ E;Ø2×2Ñ2ÑK¸&ÐKÀFÑKJà "Ñ$DØxxzÜ
|
O à '× .Ñ .¬sÓ 3
|
Ü YY z°6Ó :
|
Ø&×,Ñ,×6Ò6Ð6Ð6Ø )× .Ñ .Ó 0 Ø$- DÑ!Ø × Ñ jÔ )Ø × Ñ [Õ )ð *ô z?aÒ ä A ×+Ñ+¨I°a©LÓ9Ó:×NÑNÓPÐ Pô Ø!Ø ØjjØ ..Ø!&ô Bð ::Ð rb c óæ t j t | « j dt t « ¬« ||}t | « dk( rg S g }t | j | j « D ]é \ } }
|
||nt | j « } t | « dkD rg| j |
|
« j |¬« } |
|
dk( } | j « rvt j | t" ¬« } | | | < | j% « } nEt' j( | j* |
|
« D cg c] }t- t/ |« r| n|d¬« } }|j1 | « ë g }t || j2 « D ]d \ } }g }|r |j1 | t- |d¬« nd « |j5 t j | t" ¬« « |j1 |« f | t7 d
|
« }|rSd }t9 |t: « s|t< j> u sJ |d t< j> fv r|}tA |tC |« |¬ « }|r,tE « } |jF |g|¢ jI d « S |S c c}w )Nz.format is deprecated and will be removed in a future version. Convert using index.astype(str) or index.map(formatter) instead.r6 r ©Ú formatterr r¿ ©ú ú ú
|
©Ú escape_charsÚ údisplay.multi_sparseF©ÚstartÚsentinelr~ )%r8 r9 r( rc r: r) r
rË r r_ Ú _get_na_repr rs Úformatr rZ r´ rn Útolistr râ rÇ rK r; r§ rt Úextendr rº rO r r° Úsparsify_labelsr rJ ÚadjoinÚsplit)r^ rs rz rl rt ÚspaceÚsparsifyr Ústringified_levelsr r« ÚnaÚ formattedru rú Ú result_levelsÚlev_namer r
Úadjs r` r zMultiIndex.format£ sS ô äDz×"Ñ"Ð#ð $,ð ,ô Ü'Ó)õ
|
ð Ð ØEä t9>ØIà ÐÜ # D§K¡K°·±Ó <ò 1Ñ CØ!Ð-´;¸s¿y¹yÓ3IBä3x!|Ø HH [Ó 1× 8Ñ 8À9Ð 8Ó M ð # bÑ(Ø88:Ü "§¡¨¼&Ô AIØ&(IdOØ )× 0Ñ 0Ó 2Iô #]]¨3¯;©;¸ Ó Dö àô !¤t¨A¤w¡°AÐDVÖWð ð ð × %Ñ % iÕ 0ð' 1ð* Ü Ð!3°T·Z±ZÓ @ò (MCØEáØ à Ð+ô ! Ð8JÕKàôð LL #¬VÔ4Ô 5Ø × Ñ Õ 'ð (ð Ð Ü!Ð"8Ó9Há Ø;=Hä h¬Ô-°¼S¿^¹^Ñ1KÐ KÐKØE¤3§>¡>Ð2Ñ2Ø#ä +Ø ¤S¨£Z¸(ô Mñ Ü Ó"CØ 3::eÐ4 mÒ4×:Ñ:¸4Ó@Ð @à Ð ùòM s Ä'!I.ry c ó t | « dk( rg S g }t | j | j « D ]ê \ }}t |j
|
« }t |« dkD rl|j |« x}} |j d|¬« } |dk( }
|
|
|
j « rvt j | t ¬« } || |
|
< | j « } nEt j |j |« D cg c] } t! t# | « r|n| d¬« } } |j% | « ì g } t || j& « D ]d \ }} g }|r |j% | t! | d¬« nd« |j) t j |t ¬« « | j% |« f | t+ d « }|rQd}t- |t. « s|t0 j2 u sJ |t0 j2 u r|}t5 | t7 |« |¬
|
« } | S c c} w ) Nr F)Ú include_namerz r r¿ r{ r r r r ) r
rË r r_ r r rs Ú _format_flatr rZ r´ rn r r râ rÇ rK r; r§ rt r r rº rO r r° r r )r^ Ú include_namesr rz r r r« r Útakenr ru rú r r r r
s r` Ú _format_multizMultiIndex._format_multiô sê ô t9>ØIà ÐÜ # D§K¡K°·±Ó <ò 1Ñ CÜ SYYÓ'Bä3x!|Ø$'§H¡H¨[Ó$9Ð9 Ø !× .Ñ .¸EÈYÐ .Ó W ð # bÑ(Ø88:Ü "§¡¨¼&Ô AIØ&(IdOØ )× 0Ñ 0Ó 2Iô #]]¨3¯;©;¸ Ó Dö àô !¤t¨A¤w¡°AÐDVÖWð ð ð × %Ñ % iÕ 0ð) 1ð, Ü Ð!3°T·Z±ZÓ @ò (MCØEá Ø à Ð+ô ! Ð8JÕKàôð LL #¬VÔ4Ô 5Ø × Ñ Õ 'ð (ð Ð Ü!Ð"8Ó9Há Ø;=Hä h¬Ô-°¼S¿^¹^Ñ1KÐ KÐKØ3>>Ñ)Ø#ä +Ø ¤S¨ Ó%7À(ô Mð Ð ùòE s Ã*!Hc ó, t | j « S r¹ )rF r ré s r` Ú
|
_get_nameszMultiIndex._get_names6 s Ü$++Ó&Ð&rb )r r c ó |t |« s t d« t |« }|rI|"t |« t |« k7 r t d« |#t |« | j k7 r t d« |t | j « }n |D cg c] }| j |« }}t ||« D ]B \ }}|,t |« s!t t | « j d« || j |< D | j « yc c}w )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
|
validate : bool, default True
|
validate that the names match level lengths
|
|
Raises
|
------
|
TypeError if each name is not hashable.
|
|
Notes
|
-----
|
sets names on levels. WARNING: mutates!
|
|
Note that you generally want to set this *after* changing levels, so
|
that it only acts on copies
|
Nz*Names should be list-like for a MultiIndexz+Length of names must match length of level.z:Length of names must match number of levels in MultiIndex.z .name must be a hashable type)r0 r r¤ r
r¦ r r rË r- ru r( rc r r )r^ rt r r r rs s r` r zMultiIndex._set_names9 s ð6 Ð ¤\°%Ô%8Ü Ð IÓJÐ JÜU á ØÐ ¤S¨£Z´3°u³:Ò%=Ü Ð!NÓOÐOØ}¤ U£¨t¯|©|Ò!;Ü ØPóð ð =Ü$,,Ó'Eà<AÖB°ST×+Ñ+¨CÕ0ÐBEÐBô U EÓ*ò $ICØÐ ô # 4Ô(Ü#Ü :×.Ñ.Ð/Ð/LÐMóð ð $DKKÒ ð $ð ×ÑÕùò Cs  Dam
|
Names of levels in 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.names
|
FrozenList(['x', 'y', 'z'])
|
)ÚfsetÚfgetr( c ó y)NÚmixedrj ré s r` Ú inferred_typezMultiIndex.inferred_type s àrb c óü | j j |« }|dkD rt |« st d| d« | j j |« }|S # t $ r}t |« st d| d« ||dk r@|| j z }|dk rZ|| j z
|
}t d| j d| d « ||| j k\ r t d| j d
|
|dz « |Y d }~|S d }~ww xY w) NrU z The name z* occurs multiple times, use a level numberzLevel z
|
not foundr z Too many levels: Index has only z levels, z is not a valid level numberz levels, not )rt Úcountr. r r ÚKeyErrorr¦ Ú
|
IndexError)r^ r r¤ ÚerrÚ
|
orig_levels r` r z MultiIndex._get_level_number s, Ø
|
|
× Ñ Ó'Ø AIz¨%Ô 0Ü ØE7Ð"LÐMóð ð ØJJ×$Ñ$ UÓ+Eð$ øô# ò Ü eÔ$Ü ¨ w¨jÐ 9Ó:ÀÐCØqyØ Ñ%Ø19Ø!&¨¯ © Ñ!5JÜ$Ø:¸4¿<¹<¸.È Ø%,Ð&BðDóð ð ð
|
$,,Ò&Ü Ø6°t·|±|°nð EØ 19+ð'óð ðûð ûð# ús ¼A Á C;Á"BC6Ã6C;c óP t d | j D « « ryt d | j D « « r>t j
|
| j D cg c] }|j dd¬« c}« S t t t | j « « « D cg c] }| j |« j }} t j |« }t |« j S c c}w c c}w # t $ r" t | j « j cY S w xY w)zI
|
Return a boolean if the values are equal or increasing.
|
c 3 ó$ K | ] }d |v
|
yw)r Nrj )r¼ r s r` r¾ z5MultiIndex.is_monotonic_increasing.<locals>.<genexpr>¬ s è ø Ò1drTzÑ1ùs Fc 3 ó4 K | ] }|j y wr¹ ©Úis_monotonic_increasing)r¼ r s r` r¾ z5MultiIndex.is_monotonic_increasing.<locals>.<genexpr>¯ s è ø ÒF°u×,Õ,ÑFùr\ Úint64rþ )r r_ rÁ r ÚlibalgosÚ is_lexsortedro Úreversedr r
Ú_get_level_valuesrÇ rZ ÚlexsortrB r ru )r^ rú rª rå Ú
|
sort_orders r` r z"MultiIndex.is_monotonic_increasing§ sõ ô
|
Ñ1 d§j¡jÔ1Ô 1Øä ÑF¸$¿+¹+ÔFÔ Fä×(Ñ(Ø8<¿
|
¹
|
ÖC°1'¨Õ.ÒCóð ô 8@ÄÄcÈ$Ï+É+ÓFVÓ@WÓ7Xö
|
Ø23D× "Ñ " 1Ó %× -Ó -ð
|
ð
|
ð ?ô FÓ+JÜÓ$×<Ñ<Ð <ùò Dùò
|
øô ò ?ä Ó&×>Ñ>Ò >ð ?ús ÁC0Â!"C5Ã)C: Ã:(D%Ä$D%c ó& | ddd
j S )zI
|
Return a boolean if the values are equal or decreasing.
|
Nr r¬ ré s r` Úis_monotonic_decreasingz"MultiIndex.is_monotonic_decreasingÆ s ð DbDz×1Ñ1Ð1rb c óT | j D cg c] }|j c}S c c}w )z7return a list of the inferred types, one for each level)r r¢ )r^ rª s r` Ú_inferred_type_levelsz MultiIndex._inferred_type_levelsÎ s ð *.¯©Ö5 AÒ5Ð5ùÒ5s %c ó t d | j D « « }t | j |dd¬« }t ||« S )Nc 3 ó2 K | ] }t |« y wr¹ ró )r¼ r s r` r¾ z(MultiIndex.duplicated.<locals>.<genexpr>Õ s è ø Ò6 3c#hÑ6ùr F)ÚsortÚxnull)r» r rH r_ r )r^ ÚkeepÚshapeÚidss r` r zMultiIndex.duplicatedÓ s7 äÑ6¨$¯+©+Ô6Ó6Ü djj¨%°eÀ5ÔIä#tÓ$Ð$rb c ó t d« )z:
|
fillna is not implemented for MultiIndex
|
z"isna is not defined for MultiIndex)ÚNotImplementedError)r^ ÚvalueÚdowncasts r` ÚfillnazMultiIndex.fillnaÞ s ô "Ð"FÓGÐGrb c ó< | j D cg c] }|dk( }}|dk( rt j |d¬« }n+|dk( rt j |d¬« }nt d| « | j D cg c] }||
|
}}| j |¬« S c c}w c c}w )Nr r r rV rÁ zinvalid how option: )r_ )r_ rZ r rÁ r r )r^ Úhowr« ÚnansÚindexerr s r` ÚdropnazMultiIndex.dropnaä s à59·Z±ZÖ@ k rÓ!Ð@Ð@Ø %<ÜffT¨Ô*GØ E\ÜffT¨Ô*Gä Ð 3°C°5Ð 9Ó:Ð :à>B¿j¹jÖI¨{[ ' Ó*ÐI ÐIØ~~ I~Ó.Ð.ùò Aùò Js BÁ3 Bc ó | j | }| j | }| j | }|rt j |« }t j
|
|j ||j ¬« }|j ||¬« S )aP
|
Return vector of label values for requested level,
|
equal to the length of the index
|
|
**this is an internal method**
|
|
Parameters
|
----------
|
level : int
|
unique : bool, default False
|
if True, drop duplicated values
|
|
Returns
|
-------
|
Index
|
rÝ rö ) r r_ r r Úuniquerâ rÇ rã r+ )r^ r rË r r« rs Úfilleds r` r² z MultiIndex._get_level_valuesñ so ð" kk%Ñ Øjj Ñ' Ø{{5Ñ!Ù Ü ,, {Ó3KÜ s{{¨KÀCÇMÁMÔRØ× Ñ ¨dÐ Ó3Ð3rb c óJ | j |« }| j |« }|S )a(
|
Return vector of label values for requested level.
|
|
Length of returned vector is equal to the length of the index.
|
|
Parameters
|
----------
|
level : int or str
|
``level`` is either the integer position of the level in the
|
MultiIndex, or the name of the level.
|
|
Returns
|
-------
|
Index
|
Values is a level of this MultiIndex converted to
|
a single :class:`Index` (or subclass thereof).
|
|
Notes
|
-----
|
If the level contains missing values, the result may be casted to
|
``float`` with missing values specified as ``NaN``. This is because
|
the level is converted to a regular ``Index``.
|
|
Examples
|
--------
|
Create a MultiIndex:
|
|
>>> mi = pd.MultiIndex.from_arrays((list('abc'), list('def')))
|
>>> mi.names = ['level_1', 'level_2']
|
|
Get level values by supplying level as either integer or name:
|
|
>>> mi.get_level_values(0)
|
Index(['a', 'b', 'c'], dtype='object', name='level_1')
|
>>> mi.get_level_values('level_2')
|
Index(['d', 'e', 'f'], dtype='object', name='level_2')
|
|
If a level contains missing values, the return type of the level
|
may be cast to ``float``.
|
|
>>> pd.MultiIndex.from_arrays([[1, None, 2], [3, 4, 5]]).dtypes
|
level_0 int64
|
level_1 int64
|
dtype: object
|
>>> pd.MultiIndex.from_arrays([[1, None, 2], [3, 4, 5]]).get_level_values(0)
|
Index([1.0, nan, 2.0], dtype='float64')
|
)r r² )r^ r rå s r` Úget_level_valueszMultiIndex.get_level_values s* ð` ×&Ñ& uÓ-Ø×'Ñ'¨Ó.Ø rb c ón || j « S | j |« }| j |d¬« S )NT)r rË )Údrop_duplicatesr r² )r^ r s r` rË zMultiIndex.unique? s< à =Ø×'Ñ'Ó)Ð )à×*Ñ*¨5Ó1EØ×)Ñ)°¸dÐ)ÓCÐ Crb c óì ddl m} |t j urEt |« s t d« t |« t | j « k7 r t d« |}n| j « }|s+t t |« « t |« k7 r t d« |t t | j « « D ci c] }|| j |« c}d¬« }||_ |r| |_ |S c c}w )a$
|
Create a DataFrame with the levels of the MultiIndex as columns.
|
|
Column ordering is determined by the DataFrame constructor with data as
|
a dict.
|
|
Parameters
|
----------
|
index : bool, default True
|
Set the index of the returned DataFrame as the original MultiIndex.
|
|
name : list / sequence of str, optional
|
The passed names should substitute index level names.
|
|
allow_duplicates : bool, optional default False
|
Allow duplicate column labels to be created.
|
|
.. versionadded:: 1.5.0
|
|
Returns
|
-------
|
DataFrame
|
|
See Also
|
--------
|
DataFrame : Two-dimensional, size-mutable, potentially heterogeneous
|
tabular data.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([['a', 'b'], ['c', 'd']])
|
>>> mi
|
MultiIndex([('a', 'c'),
|
('b', 'd')],
|
)
|
|
>>> df = mi.to_frame()
|
>>> df
|
0 1
|
a c a c
|
b d b d
|
|
>>> df = mi.to_frame(index=False)
|
>>> df
|
0 1
|
0 a c
|
1 b d
|
|
>>> df = mi.to_frame(name=['x', 'y'])
|
>>> df
|
x y
|
a c a c
|
b d b d
|
r )rM z1'name' must be a list / sequence of column names.z<'name' should have same length as number of levels on index.zBCannot create duplicate column labels if allow_duplicates is FalseFrþ )rì rM r r° r0 ru r
r r Ú_get_level_namesÚsetr r² rÙ r )r^ r rs Úallow_duplicatesrM Ú idx_namesr r s r` Úto_framezMultiIndex.to_frameG sâ õx %à s~~Ñ %Ü Ô%Ü Ð SÓTÐTä4yC § ¡ Ó ,Ò,Ü ØRóð ð Ià ×-Ñ-Ó/Iá ¤C¬¨I«Ó$7¼3¸y»>Ò$IÜ ØTóð ñ
|
Ü?DÄSÈÏÉÓEUÓ?VÖ W°eUD×*Ñ*¨5Ó1Ñ 1Ò WØô
|
ð #á Ø FLØ ùò Xs Â=C1c ó0 t | j d¬« S )a
|
Convert a MultiIndex to an Index of Tuples containing the level values.
|
|
Returns
|
-------
|
pd.Index
|
Index with the MultiIndex data represented in Tuples.
|
|
See Also
|
--------
|
MultiIndex.from_tuples : Convert flat index back to MultiIndex.
|
|
Notes
|
-----
|
This method will simply return the caller if called by anything other
|
than a MultiIndex.
|
|
Examples
|
--------
|
>>> index = pd.MultiIndex.from_product(
|
... [['foo', 'bar'], ['baz', 'qux']],
|
... names=['a', 'b'])
|
>>> index.to_flat_index()
|
Index([('foo', 'baz'), ('foo', 'qux'),
|
('bar', 'baz'), ('bar', 'qux')],
|
dtype='object')
|
F)Ú tupleize_cols)rB rÇ ré s r` Ú to_flat_indexzMultiIndex.to_flat_index£ s ô8 T\\°Ô7Ð7rb c ó4 | j | j k( S )a´
|
Return True if the codes are lexicographically sorted.
|
|
Returns
|
-------
|
bool
|
|
Examples
|
--------
|
In the below examples, the first level of the MultiIndex is sorted because
|
a<b<c, so there is no need to look at the next level.
|
|
>>> pd.MultiIndex.from_arrays([['a', 'b', 'c'],
|
... ['d', 'e', 'f']])._is_lexsorted()
|
True
|
>>> pd.MultiIndex.from_arrays([['a', 'b', 'c'],
|
... ['d', 'f', 'e']])._is_lexsorted()
|
True
|
|
In case there is a tie, the lexicographical sorting looks
|
at the next level of the MultiIndex.
|
|
>>> pd.MultiIndex.from_arrays([[0, 1, 1], ['a', 'b', 'c']])._is_lexsorted()
|
True
|
>>> pd.MultiIndex.from_arrays([[0, 1, 1], ['a', 'c', 'b']])._is_lexsorted()
|
False
|
>>> pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'],
|
... ['aa', 'bb', 'aa', 'bb']])._is_lexsorted()
|
True
|
>>> pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'],
|
... ['bb', 'aa', 'aa', 'bb']])._is_lexsorted()
|
False
|
)r¥ r¦ ré s r` Ú _is_lexsortedzMultiIndex._is_lexsortedÁ s ðD ×"Ñ" d§l¡lÑ2Ð2rb c ór | j | j S t | j | j « S )z
|
Compute and return the lexsort_depth, the number of levels of the
|
MultiIndex that are sorted lexically
|
|
Returns
|
-------
|
int
|
)r r¥ r_ r¦ ré s r` r¥ zMultiIndex._lexsort_depthå s- ð >>Ð %Ø>>Ð !Ü djj¨$¯,©,Ó7Ð7rb c ó& | j « r| j r| S g }g }t | j | j « D ] \ }}|j sd |j « }|j |« }t |« }t j |t |« « }t j ||d¬« }|j |« |j |« t ||| j | j" d¬« S # t $ r |r Y Vw xY w)aÖ
|
This is an *internal* function.
|
|
Create a new MultiIndex from the current to monotonically sorted
|
items IN the levels. This does not actually make the entire MultiIndex
|
monotonic, JUST the levels.
|
|
The resulting MultiIndex will have the same outward
|
appearance, meaning the same .values and ordering. It will also
|
be .equals() to the original.
|
|
Returns
|
-------
|
MultiIndex
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex(levels=[['a', 'b'], ['bb', 'aa']],
|
... codes=[[0, 0, 1, 1], [0, 1, 0, 1]])
|
>>> mi
|
MultiIndex([('a', 'bb'),
|
('a', 'aa'),
|
('b', 'bb'),
|
('b', 'aa')],
|
)
|
|
>>> mi.sort_values()
|
MultiIndex([('a', 'aa'),
|
('a', 'bb'),
|
('b', 'aa'),
|
('b', 'bb')],
|
)
|
r rÝ F)rt r r )rÛ r rË r r_ Úargsortrs r, r Úget_reverse_indexerr
r râ ru r§ rO rt r )r^ Úraise_if_incomparabler r r r« rÈ Úris r` Ú_sort_levels_monotonicz!MultiIndex._sort_levels_monotonicó s ðD × Ñ Ô D×$@Ò$@ØKà
|
Ø ä # D§K¡K°·±Ó <ò *Ñ CØ×.Ò.ð Pà !kkmGð
|
(( 7Ó+Cô 2°'Ó :GÜ ×0Ñ0°¼#¸g»,ÓGBÜ"'§-¡-°°KÈBÔ"OKà × Ñ cÔ "Ø × Ñ [Õ )ð# *ô& Ø Ø Ø**ØnnØ "ô
|
ð
|
øô !ò Ù,Ø ñ -ð ús ÁDÄ DÄDc óÈ g }g }d}t | j | j « D ]o \ }}t j t j
|
|dz « dkD « d dz
|
}t t |« xr |d dk( « }t |« t |« |z k7 rÛ|j « j « rt |« t |« k( r nÉd}t j |« }|r-t j |dk( « d }||d dg |d|d g< t j t |« |z « } t j t |« « |z
|
| |< | | }|j ||d « }|j |« |j |« r | j! « }
|
|r6|
|
j# « |
|
j% |d¬« |
|
j' |d¬« |
|
S )a¤
|
Create new MultiIndex from current that removes unused levels.
|
|
Unused level(s) means levels that are not expressed in the
|
labels. The resulting MultiIndex will have the same outward
|
appearance, meaning the same .values and ordering. It will
|
also be .equals() to the original.
|
|
Returns
|
-------
|
MultiIndex
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_product([range(2), list('ab')])
|
>>> mi
|
MultiIndex([(0, 'a'),
|
(0, 'b'),
|
(1, 'a'),
|
(1, 'b')],
|
)
|
|
>>> mi[2:]
|
MultiIndex([(1, 'a'),
|
(1, 'b')],
|
)
|
|
The 0 from the first level is not represented
|
and can be removed
|
|
>>> mi2 = mi[2:].remove_unused_levels()
|
>>> mi2.levels
|
FrozenList([[1], ['a', 'b']])
|
FrU r r TN©r )rË r r_ rZ r Úbincountr r
r; r r rË r Úarangers r§ r r r r ) r^ r r Úchangedr r« ÚuniquesÚhas_naÚna_idxÚ code_mappingr s r` Úremove_unused_levelsz MultiIndex.remove_unused_levels6 s¿ ðF
|
Ø àÜ # D§K¡K°·±Ó <ó # *Ñ Cô hhr{{¨;¸©?Ó ;¸aÑ ?Ó@ÀÑCÀaÑGGÜW Ò<¨7°1©:¸Ñ+;Ó=Fä7|s 3x¨&Ñ 0Ò0Ø88:>>Ô#¬¨G« ¼¸C»Ò(@Ùà ô ,, {Ó3ÙÜ XX g°¡mÓ 4°QÑ 7Fà.5°v¸a±yÀ!°nÑ.EGQ q¡ NÑ+ô "xx¬¨C«°6Ñ(9Ó : ä(*¯ © ´#°g³,Ó(?À&Ñ(H WÑ%à *¨;Ñ 7 ð hhw v wÐ /Ó0à × Ñ cÔ "Ø × Ñ [Ö )ðG# *ðJ á Ø × "Ñ "Ô $Ø × Ñ z°EÐ Ô :Ø × Ñ i°%Ð Ô 8à rb c óÒ t | j « t | j « | j t | j « d}t
|
j t | « |fdfS )z*Necessary for making this object picklable)r r_ r rt N)r¤ r r_ r rt ÚibaseÚ
|
_new_Indexr( )r^ Úds r` Ú
|
__reduce__zMultiIndex.__reduce__ sS ô 4;;Ó'Ü$**Ó%Ø Ü$**Ó%ñ
|
ô × Ñ ¤$ t£*¨a °$Ð6Ð6rb c óì t |« rt j |« }g }t | j | j
|
« D ]D \ }}|| dk( r |j t j « .|j ||| « F t |« S d }t j |« r(t j |t ¬« }| j }n]t |t « r(|j |j dkD r2| j }n%t |t" « rt j |« }| j
|
D cg c] }|| }}t% | j || j& |d¬« S c c}w )Nr r¿ r Frn )r2 rà Úcast_scalar_indexerrË r r_ r§ rZ rk r» Úis_bool_indexerrÆ rO r rº ÚsliceÚsteprB rO rt )r^ rB Úretvalr r« r r s r` Ú __getitem__zMultiIndex.__getitem__ s2 Ü S>Ü×)Ñ)¨#Ó.CàFÜ$'¨¯ © °T·Z±ZÓ$@ò 9Ñ [Ø sÑ# rÒ)ØMM¤"§&¡&Õ)àMM # k°#Ñ&6Ñ"7Õ8ð 9ô =Ð ð IÜ×"Ñ" 3Ô'Üjj ¬DÔ1Ø NN ÜC¤Ô'Ø88Ð# s§x¡x°!¢|Ø $§¡IÜC¤Ô'Üjj oà=A¿Z¹ZÖH¨k SÓ)ÐHIÐHä Ø{{Ø ØjjØ#Ø!&ô ð ùò Is Ä? E1c óê d}|j |j dkD r | j }| j D cg c] }|| }} t | « | j || j
|
|d¬« S c c}w )zH
|
Fastpath for __getitem__ when we know we have a slice.
|
Nr Frn )rö r r_ r( r r )r^ Úslobjr r« r s r` Ú_getitem_slicezMultiIndex._getitem_slice¼ sr ð Ø ::Ð §¡¨a¢ Ø Ià;?¿:¹:ÖF¨K[ Ó'ÐF ÐFàtDzØ;;ØØ++Ø Ø "ô
|
ð
|
ùò Gs ¸ A0rs c ó¨ t j d|« t |« }| j |||« }d}| j D cg c] }|j |« }}|rK|dk( } | j « r6g }
|
|D ]- } | } || | < |
|
j t j | « « / |
|
}t | j || j d¬« S c c}w )Nrj r F©r r_ rt r ) ÚnvÚ validate_taker, Ú_maybe_disallow_fillr_ rs r r§ rZ rÆ rO r rt ) r^ ÚindicesrW Ú
|
allow_fillrÞ ry Úna_valueÚlabr ru ÚmaskedÚ new_labelÚ label_valuess r` rs zMultiIndex.takeÎ sÑ ô ×ÑVÔ$Ü% gÓ.ð ×.Ñ.¨z¸:ÀwÓO
|
àà.2¯j©jÖ9 s'Õ"Ð9Ð9Ù Øb=DØxxzØØ!&ò <IØ#,LØ)1L Ñ&ØMM¤"§*¡*¨\Ó":Õ;ð<ð äØ;; e°4·:±:ÐPUô
|
ð
|
ùò :s ÁCc
|
óT
|
t |t t f« s|g}t fd|D « « rg }g }g }t j
|
« D ]Û
|
j
|
}|D ] }|j |j
|
« }" g|¢D cg c]+ }t |j
|
|j
|
|d¬« - }} j
|
t
|
fd|D « « rd |j t j |« « |j |« |j « Ý t |||d¬« S j ft d |D « « z }t j |« } t j# | « S c c}w # t$ t& f$ r t) | « cY S w xY w)aä
|
Append a collection of Index options together.
|
|
Parameters
|
----------
|
other : Index or list/tuple of indices
|
|
Returns
|
-------
|
Index
|
The combined index.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([['a'], ['b']])
|
>>> mi
|
MultiIndex([('a', 'b')],
|
)
|
>>> mi.append(mi)
|
MultiIndex([('a', 'b'), ('a', 'b')],
|
)
|
c 3 ót K | ]/ }t |t « xr |j j k\ 1 y wr¹ )rº rO r¦ )r¼ Úor^ s r` r¾ z$MultiIndex.append.<locals>.<genexpr> s2 øè ø ò
|
ØJKZ:Ó &Ò D¨1¯9©9¸¿ ¹ Ñ+DÓ Dñ
|
ùs 58Frþ c 3 óB K | ] }|j k7 y wr¹ ©rt )r¼ rw rª Ú
|
level_names r` r¾ z$MultiIndex.append.<locals>.<genexpr> s øè ø ÒA°Rrxx { jÕ0ÑAùrL N)r_ r rt r c 3 ó4 K | ] }|j y wr¹ rè ©r¼ Úks r` r¾ z$MultiIndex.append.<locals>.<genexpr>" s è ø Ò+E¸!¨A¯IIÑ+Eùr\ )rº r¤ r» rÁ r r¦ r Úunionr@ r_ rt r r§ rZ r# rO rÇ rÎ ru r¦ rB ) r^ Úotherr_ r rt Ú level_valuesrw r« Ú to_concatÚ
|
new_tuplesrª r s ` @@r` r§ zMultiIndex.appendî s£ ú ô. %¤$¬ Ô/ØGEä ó
|
ØOTô
|
õ
|
ð EØFØEÜ4<<Ó(ò )Ø #{{¨1~ Ø ò DBØ#/×#5Ñ#5°b·i±iÀ±lÓ#CLðDð !%~ u~ö ð ô *Ø R§Y¡Y¨q¡\°<Àeöð ð ð "ZZ¨]
|
ÜÔA¸5ÔAÔAØ!%JØ R^^¨KÓ 8Ô9Ø lÔ+Ø ZÕ(ð )ô Ø F°%È%ôð ð \\O¤eÑ+E¸uÔ+EÓ&EÑE Ü^^ IÓ.
|
ð %ô ×)Ñ)¨*Ó5Ð 5ùò/ øô0 :Ð&ò %ÜÓ$Ò $ð %ús  0FÅ0F
|
Æ
|
F'Æ&F'Úlast)Ú na_positionc ó | j d¬« }|j « D cg c] }|j }}t ||d¬« S c c}w )NT)rà )r Ú codes_given)râ Ú_get_codes_for_sortingr_ rI )r^ r rx ry Útargetr Úkeyss r` rÞ zMultiIndex.argsort- sL ð ×,Ñ,À4Ð,ÓHØ%+×%BÑ%BÓ%DÖEc ÐEÐEÜ t°È$ÔOÐOùò Fs ¥AÚrepeatc
|
ót t j dd|i« t |« }t | j | j
|
D cg c]O }|j t j « j t j d¬« j |« Q c}| j | j d¬« S c c}w )Nrj rW Frþ rn )rþ Úvalidate_repeatr, rO r r_ r rZ rÅ ro Úintpr rt r )r^ ÚrepeatsrW r« s r` r zMultiIndex.repeat4 s ä
|
×Ñ2 ¨~Ô.ô & gÓ.ÜØ;;ð $(§:¡:öà ð × Ñ ¤§¡Ó,×3Ñ3´B·G±GÀ%Ð3ÓH×OÑOÐPWÕXòð **ØnnØ "ô
|
ð
|
ùòs ÁAB5
|
c óp || j |||« S t |t j t f« s+ t j |t j d« ¬« }g }|D ] } | j |« }t |t « r|j |« nát |t « rK|j |j nd}|j t |j |j" |« « nt j$ |« rX| j& dk( r$t) j* dt, t/ « ¬« |j1 « d }|j |« ndt3 |« }t5 |« | j9 |« S # t $ r Y =w xY w# t6 $ r
|
|dk7 r Y Ow xY w) a½
|
Make a new :class:`pandas.MultiIndex` with the passed list of codes deleted.
|
|
Parameters
|
----------
|
codes : array-like
|
Must be a list of tuples when ``level`` is not specified.
|
level : int or level name, default None
|
errors : str, default 'raise'
|
|
Returns
|
-------
|
MultiIndex
|
|
Examples
|
--------
|
>>> idx = pd.MultiIndex.from_product([(0, 1, 2), ('green', 'purple')],
|
... names=["number", "color"])
|
>>> idx
|
MultiIndex([(0, 'green'),
|
(0, 'purple'),
|
(1, 'green'),
|
(1, 'purple'),
|
(2, 'green'),
|
(2, 'purple')],
|
names=['number', 'color'])
|
>>> idx.drop([(1, 'green'), (2, 'purple')])
|
MultiIndex([(0, 'green'),
|
(0, 'purple'),
|
(1, 'purple'),
|
(2, 'green')],
|
names=['number', 'color'])
|
|
We can also drop from a specific level.
|
|
>>> idx.drop('green', level='color')
|
MultiIndex([(0, 'purple'),
|
(1, 'purple'),
|
(2, 'purple')],
|
names=['number', 'color'])
|
|
>>> idx.drop([1, 2], level=0)
|
MultiIndex([(0, 'green'),
|
(0, 'purple')],
|
names=['number', 'color'])
|
rn r¿ rU r zYdropping on a non-lexsorted multi-index without a level parameter may impact performance.r6 z unsupported indexer of type Úignore) Ú_drop_from_levelrº rZ rÅ rB rà Úindex_labels_to_arrayr r r? r r§ rõ rö r r r Ústoprô r¥ r8 r9 r$ r) Únonzeror( ÚAssertionErrorr¥ Údelete) r^ r_ r ÚerrorsÚindsr« Úlocrö Úmsgs r` ÚdropzMultiIndex.dropF s
ðh Ð Ø×(Ñ(¨°°vÓ>Ð >ä%¤"§*¡*¬eÐ!4Ô5ð Ü×1Ñ1°%¼r¿x¹xÈÓ?QÔRð Ø ó Kð Øll ;Ó/ô c¤3Ô'ØKK Õ$Ü ¤UÔ+Ø'*§x¡xÐ';388ÀDØKK¤ c§i¡i°·±¸4Ó @ÕAÜ×(Ñ(¨Ô-Ø×*Ñ*¨aÒ/Ü ð Pä .Ü'7Ó'9õ ð ++-¨Ñ*CØKK Õ$à 8¼¸c»¸ ÐDCÜ(¨Ó-Ð-ùð- ð6 {{4Ó Ð øô? ò Úð ûô6 ò ØXÒ%Øò &ð ús$ ·*F Á*DF"Æ F Æ F Æ"F5Æ4F5c óø t j |« }| j |« }| j | }|j |« }t |« }d|t j |d« |dk( z < |j d | j d k( rd|t j |d« < ||dk( }t |« dk7 r|dk7 rt d| d« t j | j | |« } | | S ) NéþÿÿÿFr r Tr# zlabels z not found in level)rà r% r r Ú get_indexerr; rZ Úequalr¾ r
r¥ r Úisinr_ )
|
r^ r_ r r* rª r rå Ú nan_codesÚ not_foundru s
|
r` r$ zMultiIndex._drop_from_level¡ sò ô ×)Ñ)¨%Ó0Ø × "Ñ " 5Ó )Ø AØ×"Ñ" 5Ó)ô K Ø@B EÓ*¨v¸©|Ñ<Ñ=Ø ;;q>TZZ¨]Ò *Ø02F288I tÓ,Ñ -à& B,Ñ' Ü y>QÒ 6¨XÒ#5ÜW Y KÐ/BÐCÓDÐ DÜ
|
|
4:: a=¨&Ó1Ð1àDzÐrb c óH t | j « }t | j « }t | j « }| j |« }| j |« }|| || c||< ||< || || c||< ||< || || c||< ||< t |||d¬« S )aú
|
Swap level i with level j.
|
|
Calling this method does not change the ordering of the values.
|
|
Parameters
|
----------
|
i : int, str, default -2
|
First level of index to be swapped. Can pass level name as string.
|
Type of parameters can be mixed.
|
j : int, str, default -1
|
Second level of index to be swapped. Can pass level name as string.
|
Type of parameters can be mixed.
|
|
Returns
|
-------
|
MultiIndex
|
A new MultiIndex.
|
|
See Also
|
--------
|
Series.swaplevel : Swap levels i and j in a MultiIndex.
|
DataFrame.swaplevel : Swap levels i and j in a MultiIndex on a
|
particular axis.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex(levels=[['a', 'b'], ['bb', 'aa']],
|
... codes=[[0, 0, 1, 1], [0, 1, 0, 1]])
|
>>> mi
|
MultiIndex([('a', 'bb'),
|
('a', 'aa'),
|
('b', 'bb'),
|
('b', 'aa')],
|
)
|
>>> mi.swaplevel(0, 1)
|
MultiIndex([('bb', 'a'),
|
('aa', 'a'),
|
('bb', 'b'),
|
('aa', 'b')],
|
)
|
Frý )r¤ r r_ rt r rO )r^ rª Újr r Ú new_namess r` Ú swaplevelzMultiIndex.swaplevel¶ sº ôV $++Ó&
|
ÜÓ$ ÜÓ$ à × "Ñ " 1Ó %Ø × "Ñ " 1Ó %à'1°!¡}°jÀ±mÐ$
|
1 z !}Ø%.¨q¡\°9¸Q±<Ð" ! i lØ%.¨q¡\°9¸Q±<Ð" ! i läØ Y°iÐRWô
|
ð
|
rb c ón |D cg c] }| j |« }}| j |« }|S c c}w )aI
|
Rearrange levels using input order. May not drop or duplicate levels.
|
|
Parameters
|
----------
|
order : list of int or list of str
|
List representing new level order. Reference level by number
|
(position) or by key (label).
|
|
Returns
|
-------
|
MultiIndex
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([[1, 2], [3, 4]], names=['x', 'y'])
|
>>> mi
|
MultiIndex([(1, 3),
|
(2, 4)],
|
names=['x', 'y'])
|
|
>>> mi.reorder_levels(order=[1, 0])
|
MultiIndex([(3, 1),
|
(4, 2)],
|
names=['y', 'x'])
|
|
>>> mi.reorder_levels(order=['y', 'x'])
|
MultiIndex([(3, 1),
|
(4, 2)],
|
names=['y', 'x'])
|
)r Ú_reorder_ilevels)r^ Úorderrª r s r` Úreorder_levelszMultiIndex.reorder_levelsð s= ð@ 5:Ö:¨q×'Ñ'¨Õ*Ð:Ð:Ø×&Ñ& uÓ-Ø ùò ;s
2c ó^ t |« | j k7 r$t d| j dt |« « |D cg c] }| j | }}|D cg c] }| j | }}|D cg c] }| j
|
| }}t |||d¬« S c c}w c c}w c c}w )Nz2Length of order must be same as number of levels (z), got Frý )r
r¦ r( r r_ rt rO )r^ r< rª r r r8 s r` r; zMultiIndex._reorder_ilevels
|
s³ Ü u: Ò %Ü ØDÀTÇ\Á\ÀNð SÜ5zlð$óð ð /4Ö4¨dkk !nÐ4
|
Ð4Ø,1Ö2 qTZZ ]Ð2 Ð2Ø,1Ö2 qTZZ ]Ð2 Ð2äØ Y°iÐRWô
|
ð
|
ùò 5ùÚ2ùÚ2s ÁB Á B%Á9B*c # ó K t |« | j kD r%t dt |« d| j d« t t |« « D ]0 }t | j
|
| | j | || |¬« 2 y w)NzLength of new_levels (z) must be <= self.nlevels (ú)rþ )r
r¦ r( r r@ r_ r )r^ r r rª s r` Ú_recode_for_new_levelsz!MultiIndex._recode_for_new_levels"
|
s è ø ô z?T\\Ò )Ü Ø(¬¨Z« Ð(9ð :,Ø,0¯L©L¨>¸ð<óð ô s:Ó'ò AÜ'Ø
|
|
1 t{{¨1~¨z¸!©}À4ôó ñ ùs BBc ó d }| j D cg c]! }t j | ||« dd¬« # c}S c c}w )a
|
|
we are categorizing our codes by using the
|
available categories (all, not just observed)
|
excluding any missing ones (-1); this is in preparation
|
for sorting, where we need to disambiguate that -1 is not
|
a valid valid
|
c ó¦ t j t | « r&t j | « j « dz nd| j
|
¬« S )NrU r r¿ )rZ ræ r
r´ r¡ r )r« s r` Úcatsz/MultiIndex._get_codes_for_sorting.<locals>.cats8
|
s? Ü99Ü36°{Ô3CÓ%×)Ñ)Ó+¨aÒ/ÈØ!×'Ñ'ôð rb TFrä )r_ r= Ú
|
from_codes)r^ rD r« s r` r z!MultiIndex._get_codes_for_sorting/
|
sD ò ð $zzö
|
àô × "Ñ " ;±°[Ó0AÀ4ÐRWÖ Xò
|
ð
|
ùò
|
s &;c ó t |« s|g}|D cg c] }| j |« }}d}|D cg c] }| j | }}t |t « r"t |« t |« k( s`t d« |rN|j t t | j « « D cg c] }||vs| j | c}« n|d }t |||d¬« }t |« }| j D cg c] } | j |« }
|
} t |
|
| j | j |d¬« } | |fS c c}w c c}w c c}w c c} w )a
|
Sort MultiIndex at the requested level.
|
|
The result will respect the original ordering of the associated
|
factor at that level.
|
|
Parameters
|
----------
|
level : list-like, int or str, default 0
|
If a string is given, must be a name of the level.
|
If list-like must be names or ints of levels.
|
ascending : bool, default True
|
False to sort in descending order.
|
Can also be a list to specify a directed ordering.
|
sort_remaining : sort by the remaining levels after level
|
na_position : {'first' or 'last'}, default 'first'
|
Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at
|
the end.
|
|
.. versionadded:: 2.1.0
|
|
Returns
|
-------
|
sorted_index : pd.MultiIndex
|
Resulting index.
|
indexer : np.ndarray[np.intp]
|
Indices of output values in original index.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([[0, 0], [2, 1]])
|
>>> mi
|
MultiIndex([(0, 2),
|
(0, 1)],
|
)
|
|
>>> mi.sortlevel()
|
(MultiIndex([(0, 1),
|
(0, 2)],
|
), array([1, 0]))
|
|
>>> mi.sortlevel(sort_remaining=False)
|
(MultiIndex([(0, 2),
|
(0, 1)],
|
), array([0, 1]))
|
|
>>> mi.sortlevel(1)
|
(MultiIndex([(0, 1),
|
(0, 2)],
|
), array([1, 0]))
|
|
>>> mi.sortlevel(1, ascending=False)
|
(MultiIndex([(0, 2),
|
(0, 1)],
|
), array([0, 1]))
|
Nz(level must have same length as ascendingr T)Úordersr r F)r_ r rt r r )r0 r r_ rº r¤ r
r r r r rI r, rs rO rt ) r^ r Ú ascendingÚsort_remainingr r r r_ rÈ r« r r4 s r` Ú sortlevelzMultiIndex.sortlevelC
|
sO ô~ EÔ"ØGEð 49ö
|
Ø,/D× "Ñ " 3Õ 'ð
|
ð
|
ð à,1Ö2 SC Ð2Ð2ä i¤Ô &Üu:¤ Y£ Ò/Ü Ð!KÓLÐLÙ Ø LLÜ,1´#°d·k±kÓ2BÓ,CÖX SÀsÐRWÒGWC ÒXõ ð aIä!Ø )°È$ô
|
ô & gÓ.ØBFÇ*Á*ÖM°;[×%Ñ% gÕ.ÐM ÐMä ØØ;;Ø**Ø Ø "ô
|
ð 'Ð!Ð!ùòA
|
ùò
|
3ùò Yùò Ns D<³EÂ* EÂ4EÃ:E c óì t |t « s@|| }n;|dk\ j « r| j |« }n t j |« }| j ||« }|S # t
|
$ r |cY S w xY wrð )rº rO rÁ rs rÎ ru Ú_maybe_preserve_names)r^ r rÈ Úpreserve_namess r` Ú_wrap_reindex_resultz MultiIndex._wrap_reindex_result¨
|
sx Ü&¤*Ô-ØØ ØQ,×#Ñ#Ô%Ø 7Ó+ð"Ü '× 3Ñ 3°FÓ ;Fð
|
×+Ñ+¨F°NÓCØ øô !ò "à!Mð"ús ¼A% Á% A3Á2A3c ó´ |rU|j | j k( r<|j | j k7 r#|j d¬« }| j |_ |S )NFrZ )r¦ rt r )r^ r rM s r` rL z MultiIndex._maybe_preserve_names¸
|
sE á Ø $§,¡,Ò.Ø §
|
¡
|
Ò*à[[ e[Ó,FØ ::FLØ rb c óF t |« r t |« r t |« y r¹ )r- r/ r# rA s r` Ú_check_indexing_errorz MultiIndex._check_indexing_errorÅ
|
s# Ü3Ô ¤;¨sÔ#3ô $ CÓ(Ð (ð $4rb c ó4 | j d j S )zA
|
Should integer key(s) be treated as positional?
|
r )r Ú _should_fallback_to_positionalré s r` rS z)MultiIndex._should_fallback_to_positionalÌ
|
s ð {{1~×<Ñ<Ð<rb c ó |}t |t « st j |« }t |« r>t |d t
|
« s+| j |« }| j |||« | | |fS t | % ||« S rð )
|
rº rB rà rÄ r
r» Ú_get_indexer_level_0Ú_raise_if_missingÚsuperÚ_get_indexer_strict)r^ rB Ú axis_nameÚkeyarrrÈ Ú __class__s r` rX z MultiIndex._get_indexer_strictÔ
|
s{ ø ð Ü&¤%Ô(Ü×*Ñ*¨6Ó2Fä v;z¨&°©)´UÔ ;Ø×/Ñ/°Ó7Gà × "Ñ " 3¨°Ô ;Ø= 'Ð)Ð )äwÑ*¨3° Ó:Ð:rb c ó |}t |t « st j |« }t |« r{t |d t
|
« sh|dk( }|j « rR| j d j |« }|dk( }|j « rt || d« t | d« y t | - |||« S )Nr r z not in index) rº rB rà rÄ r
r» r r r1 r¥ rW rV ) r^ rB rÈ rY rZ ru ÚcheckÚcmaskr[ s r` rV z MultiIndex._raise_if_missingã
|
s¹ ø ØÜ#uÔ%Ü×*Ñ*¨3Ó/Fä v;z¨&°©)´UÔ ;ð b=DØxxzØ A×2Ñ2°6Ó:Ø Ø99;Ü" f¨U¡m _°MÐ#BÓCÐCô & ¨ Ð 7Ó8Ð8ð ô 7Ñ,¨S°'¸9ÓEÐ Erb c ó¦ | j d }| j d }t j ||d¬« }t |« }|j |« S )z]
|
Optimized equivalent to `self.get_level_values(0).get_indexer_for(target)`.
|
r F)r_ Ú
|
categoriesr )r r r= rE rB Úget_indexer_for)r^ r r r_ ÚcatÚcis r` rU z MultiIndex._get_indexer_level_0÷
|
sL ð kk!nØ AÜ×$Ñ$¨5¸SÈ5ÔQÜ 3ZØ×!Ñ! &Ó)Ð)rb c óN t |t « s|f}| j ||¬« S )a¼
|
For an ordered MultiIndex, compute slice bound
|
that corresponds to given label.
|
|
Returns leftmost (one-past-the-rightmost if `side=='right') position
|
of given label.
|
|
Parameters
|
----------
|
label : object or tuple of objects
|
side : {'left', 'right'}
|
|
Returns
|
-------
|
int
|
Index of label.
|
|
Notes
|
-----
|
This method only works if level 0 index of the MultiIndex is lexsorted.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([list('abbc'), list('gefd')])
|
|
Get the locations from the leftmost 'b' in the first level
|
until the end of the multiindex:
|
|
>>> mi.get_slice_bound('b', side="left")
|
1
|
|
Like above, but if you get the locations from the rightmost
|
'b' in the first level and 'f' in the second level:
|
|
>>> mi.get_slice_bound(('b','f'), side="right")
|
3
|
|
See Also
|
--------
|
MultiIndex.get_loc : Get location for a label or a tuple of labels.
|
MultiIndex.get_locs : Get location for a label/slice/list/mask or a
|
sequence of such.
|
©Úside)rº r» Ú_partial_tup_index)r^ Úlabelrf s r` Úget_slice_boundzMultiIndex.get_slice_bound s, ô` %¤Ô'ØHEØ×&Ñ& u°4Ð&Ó8Ð8rb c ó& t | |||« S )aL
|
For an ordered MultiIndex, compute the slice locations for input
|
labels.
|
|
The input labels can be tuples representing partial levels, e.g. for a
|
MultiIndex with 3 levels, you can pass a single value (corresponding to
|
the first level), or a 1-, 2-, or 3-tuple.
|
|
Parameters
|
----------
|
start : label or tuple, default None
|
If None, defaults to the beginning
|
end : label or tuple
|
If None, defaults to the end
|
step : int or None
|
Slice step
|
|
Returns
|
-------
|
(start, end) : (int, int)
|
|
Notes
|
-----
|
This method only works if the MultiIndex is properly lexsorted. So,
|
if only the first 2 levels of a 3-level MultiIndex are lexsorted,
|
you can only pass two levels to ``.slice_locs``.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([list('abbd'), list('deff')],
|
... names=['A', 'B'])
|
|
Get the slice locations from the beginning of 'b' in the first level
|
until the end of the multiindex:
|
|
>>> mi.slice_locs(start='b')
|
(1, 4)
|
|
Like above, but stop at the end of 'b' in the first level and 'f' in
|
the second level:
|
|
>>> mi.slice_locs(start='b', end=('b', 'f'))
|
(1, 3)
|
|
See Also
|
--------
|
MultiIndex.get_loc : Get location for a label or a tuple of labels.
|
MultiIndex.get_locs : Get location for a label/slice/list/mask or a
|
sequence of such.
|
)rW Ú
|
slice_locs)r^ r Úendrö r[ s r` rk zMultiIndex.slice_locs6 s ø ôj wÑ! %¨¨dÓ3Ð3rb c óò t |« | j kD r%t dt |« d| j d« t |« }dt | « }}t || j | j
|
« }t |« D ]R \ }\ }} }
|
|
|
|| } || vrit |« s^ t j | ||¬« } t | « st d| « |dk( r
|
| dk\ r| dz } |t j | | |¬« z c S | j | |« }t |t « r!||dz
|
k r|j }|j }À||dz
|
k r7|t j | |d¬« z }|t j | |d ¬« z }ÿt |t « r)|j }|t j | ||¬« z c S |t j | ||¬« z c S y # t $ r} t d| « | d } ~ ww xY w)
|
Nú Key length (z-) was greater than MultiIndex lexsort depth (r@ r re zLevel type mismatch: ÚrightrU Úleft)r
r¥ r% rË r r_ Ú enumerater; r Ú searchsortedru r. Ú_get_loc_single_level_indexrº rõ r r& )r^ ri rf Únr rl Úzippedr r r r« Úsectionr, r§ r s r` rg z MultiIndex._partial_tup_indexm s Ü s8d×)Ñ)Ò )Ü$Ø s 3xjð )Ø×'Ñ'Ð(¨ð+óð ô
|
HØD sÜS$++ t§z¡zÓ2Ü*3°FÓ*;ó ' KÑ &AÑ&S+Ø! %¨Ð,Gð #~¤d¨3¤iðLÜ ×,Ñ,¨S°#¸DÔACô " #ä#Ð&;¸C¸5Ð$AÓBÐBØ7? s¨a¢xØ1HCØ u× 1Ñ 1°'¸3ÀTÔ JÑJÒJà×2Ñ2°3¸Ó<CÜ#uÔ%¨!¨a°!©eª)ð ØhhØQUð e× 0Ñ 0ØS wô ñ ð
|
¤× 2Ñ 2ØS vô!ñ ô C¤Ô'ØiiØ u× 1Ñ 1°'¸3ÀTÔ JÑJÒJà u× 1Ñ 1°'¸3ÀTÔ JÑJÒJñO' Køô !ò Lä#Ð&;¸C¸5Ð$AÓBÈÐKûðLús Â"GÇ G6Ç"G1Ç1G6c óR t |« r t |« ry|j |« S )a
|
If key is NA value, location of index unify as -1.
|
|
Parameters
|
----------
|
level_index: Index
|
key : label
|
|
Returns
|
-------
|
loc : int
|
If key is NA value, loc is -1
|
Else, location of key in index.
|
|
See Also
|
--------
|
Index.get_loc : The get_loc method for (single-level) index.
|
r )r2 r; r? )r^ Ú level_indexrB s r` rs z&MultiIndex._get_loc_single_level_index s% ô& S>d 3iàà ×&Ñ& sÓ+Ð +rb c óÔ j |« fd}t |t « s j |d¬« } ||« S t |« } j
|
|k r t d| d j
|
d« | j
|
k( r( j r j j |« S j }|d| ||d } }|sd}
|
t « } n j ||« \ }
|
} |
|
| k( r t |« | s t! |
|
| « S t# j$ dt& t) « ¬ « t+ j, |
|
| t* j. ¬
|
« }t1 | t |« « D ]b \ }} j2 | | j5 j6 | | « k( } | j9 « s|| }t |« rYt |« t |« | |
|
z
|
k7 r ||« S t! |
|
| « S # t $ r}t |« |d}~wt $ r6 j |t t j
|
« « « \ }}|cY S w xY w# t $ r}t |« |d}~ww xY w) aÌ
|
Get location for a label or a tuple of labels.
|
|
The location is returned as an integer/slice or boolean
|
mask.
|
|
Parameters
|
----------
|
key : label or tuple of labels (one for each level)
|
|
Returns
|
-------
|
int, slice object or boolean mask
|
If the key is past the lexsort depth, the return may be a
|
boolean mask array, otherwise it is always a slice or int.
|
|
See Also
|
--------
|
Index.get_loc : The get_loc method for (single-level) index.
|
MultiIndex.slice_locs : Get slice location given start label(s) and
|
end label(s).
|
MultiIndex.get_locs : Get location for a label/slice/list/mask or a
|
sequence of such.
|
|
Notes
|
-----
|
The key cannot be a slice, list of same-level labels, a boolean mask,
|
or a sequence of such. If you want to use those, use
|
:meth:`MultiIndex.get_locs` instead.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')])
|
|
>>> mi.get_loc('b')
|
slice(1, 3, None)
|
|
>>> mi.get_loc(('b', 'e'))
|
1
|
c óH t | t j « r | j t j k7 r| S t j | t « « } t | t « r| S t j t « d¬« }|j d« d|| < |S )z<convert integer indexer to boolean mask or slice if possiblerO r¿ FT) rº rZ rÅ r r r Úmaybe_indices_to_slicer
rõ ÚemptyÚfill)r, ru r^ s r` Ú_maybe_to_slicez+MultiIndex.get_loc.<locals>._maybe_to_sliceä sx ø ä c¤2§:¡:Ô.°#·)±)¼r¿w¹wÒ2FØ
|
ä×,Ñ,¨S´#°d³)Ó<CÜ#uÔ%Ø
|
ä88C I¨VÔ4DØ IIeÔ Ø DIØKrb r ©r rn z) exceeds index depth (r@ Nz3indexing past lexsort depth may impact performance.r6 r¿ ) rQ rº r» Ú_get_level_indexerr
r¦ r¥ r£ r& r? ru Ú get_loc_levelr¤ r r¥ rk rõ r8 r9 r$ r) rZ ræ r rq r_ rs r rÁ )r^ rB r~ r, Úkeylenr§ Ú_rª Úlead_keyÚ
|
follow_keyr r& r ru s ` r` r? zMultiIndex.get_loc¹ sW ø ðR ×"Ñ" 3Ô'ô ô #uÔ%Ø×)Ñ)¨#°QÐ)Ó7CÙ" 3Ó'Ð 'äSØ <<&Ò ÜØ vhÐ&=¸d¿l¹l¸^È1ÐMóð ð T\\Ò ! d§n¢nð Ø||×+Ñ+¨CÓ0Ð0ð × Ñ Ø " 2 Aw¨¨A¨B¨*áØEÜt9Dð -Ø "oo¨h¸Ó A tð D=Ü3-Ð áÜ Ó%Ð %ä Ø AÜ Ü'Ó)õ
|
ô iit¬2¯7©7Ô3ä j¬#¨h«-Ó8ò $DAqØ::a= Ñ%¨×)IÑ)IØ A ó*ñ Dð 88:Ø$iÜs8Ü smÐ#ð $ô (+¨3£x°4¸%±<Ò'?sÓ#ÐWÄUÈ5ÐRVÓEWÐWøôa ò -Ü sm¨Ð,ûÜ ò à ×+Ñ+¨C´´e¸D¿L¹LÓ6IÓ1JÓKQØ
|
ð ûô$ ò -ô sm¨Ð,ûð -ús6 ÂG3 ÃI Ç3 I
|
Ç< HÈ?I
|
É I
|
É I'É I"É"I'c ó t |t t f« s| j |« }n |D cg c] }| j |« }}| j ||¬« \ }}|s&t j |« r | ||dz }||fS | | }||fS c c}w )a
|
Get location and sliced index for requested label(s)/level(s).
|
|
Parameters
|
----------
|
key : label or sequence of labels
|
level : int/level name or list thereof, optional
|
drop_level : bool, default True
|
If ``False``, the resulting index will not drop any level.
|
|
Returns
|
-------
|
tuple
|
A 2-tuple where the elements :
|
|
Element 0: int, slice object or boolean array.
|
|
Element 1: The resulting sliced multiindex/index. If the key
|
contains all levels, this will be ``None``.
|
|
See Also
|
--------
|
MultiIndex.get_loc : Get location for a label or a tuple of labels.
|
MultiIndex.get_locs : Get location for a label/slice/list/mask or a
|
sequence of such.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')],
|
... names=['A', 'B'])
|
|
>>> mi.get_loc_level('b')
|
(slice(1, 3, None), Index(['e', 'f'], dtype='object', name='B'))
|
|
>>> mi.get_loc_level('e', level='B')
|
(array([False, True, False]), Index(['b'], dtype='object', name='A'))
|
|
>>> mi.get_loc_level(['b', 'e'])
|
(1, None)
|
r rU )rº r¤ r» r Ú_get_loc_levelr r. )r^ rB r Ú
|
drop_levelr r, rw s r` r zMultiIndex.get_loc_level3 s ôR %¤$¬ Ô/Ø×*Ñ*¨5Ó1Eà<AÖB°ST×+Ñ+¨CÕ0ÐBEÐBà×%Ñ% c°Ð%Ó7RÙÜ~~cÔ"à# a¡Ð(ð Bwð #YØBwùò Cs B c ó fd}t |t t f« r t |« t |« k7 r t d« d}t ||« D ]_ \ }} j ||¬« \ }}t |t « r+t j t « t ¬« } d| |< | }||n||z }a |||« }
|
||
|
fS t |t « r t |« }t |t « r¤|dk( r | j d v r! j ||¬« } || dg« }| |fS t! d |D « « s2t |« j" k( r* j$ r j& j) |« dfS j) |« } t- t |« « D cg c] } || t dd« k7 s| }} t |« j" k( rt/ | « r| dfS t- t |« « D cg c]B } t || t0 « r j | j2 s|| t dd« k7 r| D }} t |« j" k( rg }| || |« fS d} t5 |« D ]È \ } }t |t « s
j || ¬« }t |t « r_t7 j8 |« s t7 j: |t « « rnt j t « t ¬« }d||< n'|}n$t7 j8 |« r±t d | « | |} Ä| |z } Ê | t dd« } t- t |« « D cg c] } || t dd« k7 s| }} | || |« fS j ||¬« } t |t0 « rI j | j2 r0 j | j) |« }t/ |« s| | fS || |g« }| |fS # t $ r | }
|
Y ||
|
fS w xY w# t t f$ r Y w xY w# t* $ r} t+ |« | d} ~ wt $ r Y áw xY wc c} w c c} w c c} w # t $ r | }Y | |fS w xY w)
|
zX
|
get_loc_level but with `level` known to be positional, not name-based.
|
c óZ | }t |d¬« D ] }|j |g« } |S )z
|
If level does not exist or all levels were dropped, the exception
|
has to be handled outside.
|
T)Úreverse)ÚsortedÚ_drop_level_numbers)rÈ r r4 rª r^ s r` Úmaybe_mi_droplevelsz6MultiIndex._get_loc_level.<locals>.maybe_mi_droplevelsp s> ø ð
|
W IäF¨DÔ1ò ?Ø %× 9Ñ 9¸1¸#Ó > ð ?ð Ð rb z:Key for location must have same length as number of levelsNr r¿ Tr c 3 ó< K | ] }t |t « y wr¹ )rº rõ r s r` r¾ z,MultiIndex._get_loc_level.<locals>.<genexpr>£ s è ø Ò9°z !¤U×+Ñ9ùs z'Expected label or tuple of labels, got ) rº r» r¤ r
r( rË r rõ rZ r rO r r r ru r# r r¦ r£ r& r? r¥ r r. rp Ú!_supports_partial_string_indexingrq rÃ Ú is_null_sliceÚ is_full_slice)r^ rB r r r r r r, r4 ru rw rÈ r§ rª ÚilevelsÚ loc_levelÚk_indexr] Ú result_indexs ` r` r zMultiIndex._get_loc_levelj s« ø ô
|
ô ee¤T]Ô +Ü3x3u:Ò%Ü$ØPóð ð FÜ e S/ò AQØ!%×!4Ñ!4°Q¸cÐ!4Ó!BYÜ c¤5Ô)Ü 88¤C¨£I´TÔ:DØ $DIØ CØ & °F¸S±Lð Að "ñ )¨°Ó7ð 2:Ð ô c4Ô Ü*Cä c5Õ ! e¨q£jð à$++ a.Ñ(Ø "× 5Ñ 5°cÀÐ 5Ó GGÙ 3°G¸a¸SÓ AIØ" IÐ-Ð-ð )ô Ñ9°SÔ9Õ9Üs8t||Ò+°·²ð Ø $§ ¡ × 4Ñ 4°SÓ 9¸4Ð @Ð@ð ,, sÓ+Ü&+¬C°«H£oÖU ¸¸Q¹Ä5ÈÈtÓCTÓ9T1ÐUÐUÜw< 4§<¡<Ò/Ü! 'Ô*à &¨}Ð,ô "'¤s¨3£x£ ö à ä *¨3¨q©6´3Ô 7Ø#'§;¡;¨q¡>×#SÒ#Sà F¤e¨D°$Ó&7Ò 7ò ð Gð ô 7| t§|¡|Ò3à"$Ø Ñ 3°G¸WÓ EÐEÐEð Ü % cNò +DAqÜ% a¬Ô/Ø$(×$;Ñ$;¸AÀQÐ$;Ó$G Ü% i´Ô7Ü "× 0Ñ 0°Ô ;¼s×?PÑ?PØ )¬3¨t«9ô@ ð !)ô ')§h¡h¬s°4«yÄÔ&EGØ15G IÒ .ð '0Gä ×*Ñ*¨1Ô-à ô
|
(Ð*QÐRUÐQVÐ(WÓ XÐXà Ø")à 7Ñ*ð; +ð< ?Ü # D¨$Ó /GÜ&+¬C°«H£oÖU ¸¸Q¹Ä5ÈÈtÓCTÓ9T1ÐUÐUØ Ñ 3°G¸WÓ EÐEÐEà×-Ñ-¨c¸Ð-Ó?Gä3¤Ô$ØKK Ñ&×HÒHð EÑ*×2Ñ2°3Ó7Ü! %Ô(à" D¨¡MÐ1Ð1ð -Ù 2°7¸U¸GÓ D ð LÐ(Ð (øô_ ò "ð &\à2:Ð ð "ûô$ Ô 0Ð1ò Úð ûô $ò 5Ü & sm°Ð4ûÜ$ò ò ð üò Vùò ùò` Vøô ò -Ø # G} àLÐ(Ð (ð -úss Â0 P Ã01P Å P5 Æ Q Æ7Q Ç:AQ"Í$Q'Í<Q'Ï:
|
Q, ÐP ÐP Ð P2Ð1P2Ð5 QÐ> Q
|
Ñ
|
QÑQÑ,R Ñ?R c ó | j | }| j | }||fd}t |t « rW|j }|d uxr |dk } |j
|
|j |j
|
« } n|rt |« dz
|
} nd} |j |j |j « }
|
n/|rd}
|
n*t | t « r t |« }
|
nt |« dz
|
}
|
t | t « st |
|
t « r$t | d| « } t |
|
d|
|
« }
|
|| |
|
|« S |dkD s| j dk( s||r|
|
dz
|
n|
|
dz }
|
|| |
|
|« S t j || d¬« } t j ||
|
d¬« } t | | |« S | j ||« } |dkD s| j dk( rlt | t « r!|| j
|
k\ || j k z }|S t! j" || k( t$ ¬ « }|j' « s t |« |S t | t « rEt j || j
|
d¬« } t j || j d¬« }n0t j || d¬« } t j || d¬« }| |k( r t |« t | |« S # t $ rC |j |j
|
|j |j « x} }
|
| j }Y +w xY w)
|
Nc óÞ ||| }||dk( r || k\ ||k z }n9t j | |||j ¬« }t j ||« }||S |j « }|||< |S )NrU r¿ )rZ ræ r r r3 r )r r& rö rÈ r_ Ú new_indexerÚrs r` Úconvert_indexerz6MultiIndex._get_level_indexer.<locals>.convert_indexer
|
s ð Ð"ð gà|t qyØ $¨~°%¸$±,Ñ ? äIIe T¨4°u·{±{ÔCÜ #jj¨°Ó 2 àØ"Ð"à llnGØ *GGÑ ØNrb r rU r r& rp re ro r¿ )r r_ rº rõ rö r r? r
r& r¥ Ú slice_indexerr± r¥ r rr rs rZ rÆ rO r )r^ rB r rÈ rx r« r rö Úis_negative_stepr r& rª r7 r Úlocsrl s r` r z MultiIndex._get_level_indexerÿ sÐ ð kk %Ñ( Øjj Ñ' à7>Àkó ô, c5Õ !ð 88DØ #¨4Ð /Ò <°D¸1±HÐ ð "Ø99Ð(Ø '× /Ñ /°· ± Ó :EÙ%Ü Ó ,¨qÑ 0Eà Eà88Ð'Ø&×.Ñ.¨s¯x©xÓ8DÙ%Ø DÜ ¤uÔ-Ü {Ó+Dä {Ó+¨aÑ/Dô %¤Ô'¬:°d¼EÔ+Bô
|
w°Ó6Ü t V¨TÓ2Ù& u¨d°DÓ9Ð9àd× 1Ñ 1°QÒ 6¸$Ð:Jñ &6q¸DÀ1¹HÙ& u¨d°DÓ9Ð9ô ×&Ñ& {°EÀÔGÜ×&Ñ& {°D¸wÔGÜ Q 4Ó(Ð(ð ×2Ñ2°;ÀÓDCàqyD× /Ñ /°1Ò 4ä c¤5Ô)à '¨3¯9©9Ñ 4¸ÀsÇxÁxÑ9OÑPDØ Käzz +°Ñ"4¼DÔAàxxzä" 3-Ð'Ø ä#uÔ%ä ×*Ñ*¨;¸¿ ¹ ÈÔOä×(Ñ(¨°c·h±hÀVÔLä ×*Ñ*¨;¸À&ÔIÜ×(Ñ(¨°cÀÔHà|ä smÐ#Ü Ó$Ð $øôq ò "ð +× 8Ñ 8¸¿¹ÀCÇHÁHÈcÏhÉhÓ WÐWØ zzð "ús ÁBK Ë AL Ì L c ót t t j |« « D cg c]
|
\ }}|s | }}}|r-|d | j k\ rt d| d| j « t d |D « « r t d« t | « d fd }d}t |« D ]U \ }}d}t j |« rAt |« k7 r t d« t j |« }|¾|j « }nt |« r> | j |||¬ « }|t j* g t j, ¬ « c S t j. |« r;|8|t |« d z
|
k( r't j0 t j, ¬ « c S ø| j |||¬ « } ||« }||}||z }t j
|
|« r6t j
|
|« sMt# |« |%t j* g t j, ¬ « S |j3 « d } | j5 || « S c c}}w # t t t" f$ rY} |D ]I }
|
t% |
|
« s| | j |
|
||¬ « } | || « }/t' | t( « rd
|
|| < E|| z }K Y d} ~ d} ~ ww xY w)a
|
Get location for a sequence of labels.
|
|
Parameters
|
----------
|
seq : label, slice, list, mask or a sequence of such
|
You should use one of the above for each level.
|
If a level should not be used, set it to ``slice(None)``.
|
|
Returns
|
-------
|
numpy.ndarray
|
NumPy array of integers suitable for passing to iloc.
|
|
See Also
|
--------
|
MultiIndex.get_loc : Get location for a label or a tuple of labels.
|
MultiIndex.slice_locs : Get slice location given start label(s) and
|
end label(s).
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')])
|
|
>>> mi.get_locs('b') # doctest: +SKIP
|
array([1, 2], dtype=int64)
|
|
>>> mi.get_locs([slice(None), ['e', 'f']]) # doctest: +SKIP
|
array([1, 2], dtype=int64)
|
|
>>> mi.get_locs([[True, False, True], slice('e', 'f')]) # doctest: +SKIP
|
array([2], dtype=int64)
|
r zIMultiIndex slicing requires the index to be lexsorted: slicing on levels z, lexsort depth c 3 ó, K | ] }|t u y wr¹ )ÚEllipsisr s r` r¾ z&MultiIndex.get_locs.<locals>.<genexpr> s è ø Ò* qH}Ñ*ùs z2MultiIndex does not support indexing with Ellipsisc ó t | t « r,t j t j ¬« }d|| < |S | S )Nr¿ T)rº rõ rZ r Úbool_)rÈ r rt s r` Ú_to_bool_indexerz-MultiIndex.get_locs.<locals>._to_bool_indexer¢ s6 ø Ü'¤5Ô)Ü hh q´·±Ô 9 Ø'+ GÑ$Ø"Ð"ØNrb NzLcannot index with a boolean indexer that is not the same length as the index)r rÈ Tr¿ rU r ©rN únpt.NDArray[np.bool_])rq rà Úis_true_slicesr¥ r% r rÁ r
rô r rZ rÆ r r0 r r# ru r¥ r- rº rõ r´ r r ræ r' Ú_reorder_indexer)r^ Úseqrª ÚsÚ true_slicesr¤ rÈ r Ú lvl_indexerr§ rú Ú item_indexerÚ pos_indexerrt s @r` Úget_locszMultiIndex.get_locsp s³ ø ôH (1´×1CÑ1CÀCÓ1HÓ'I×OVa ÊQqÐO ÑOÙ ; r?¨d×.AÑ.AÒAÜ$ð Ø (MÐ)9¸$×:MÑ:MÐ9NðPóð ô
|
Ñ* cÔ*Ô *Ü%ØDóð ô Iõ ð 15ä cNó @ (DAqØ@DKä×"Ñ" 1Ô%Üq6Q;Ü$ð>óð ô !jj¨m Ø?Ø"-×"2Ñ"2Ó"4Kä a ð8Ø"&×"9Ñ"9¸!À1ÈgÐ"9Ó"VKð0 Ð&ô 88 B¬b¯g©gÔ6Ò6ä×"Ñ" 1Ô%à? q¬C°«H°q©LÒ'8Ü 99 Q¬b¯g©gÔ6Ò6Øð #× 5Ñ 5°a¸qÈ'Ð 5Ó R ñ +¨;Ó7KØØ%à;Ñ&Üvvg¬2¯6©6°+Ö+>Ü" 3-Ð'ðA@ (ðF ?Ü88B¤b§g¡gÔ.Ð .à ooÓ'¨Ñ* Ø×$Ñ$ S¨+Ó6Ð6ùó PøôV *¬9´hÐ?ò 8ð ò 8Ü *¨1~à"%Ið (,×'>Ñ'>Ø Q°ð (?ó ( ð 'Ð.Ù*:¸<Ó*HKÜ '¨ ´eÔ <Ø8<K¨ Ò 5à '¨<Ñ 7Kö 8ûð 8ús# £
|
I®IÄ
|
I
|
É
|
J7É AJ2Ê2J7c ó d}t |« D ]ñ \ }}t j |« s t j |« s t |« rn²t |« rbt |« dk rn| j « r@| j | j |« }||dk\ }|dd |dd kD j « }nHd}nEt |t « r3| j « r |j duxr |j dk }nd}nd}|sñ n |s|S t | « }d}t |« D ] \ }}t |« r|g}t j |« rt j |« | } n»t |« rüt |t j t" t$ t& f« s t) |d« }t+ j, |« }t j. t | j | « t j0 ¬« t | j | « z }
|
| j | j |« } | | dk\ } t j t | « « |
|
| < |
|
| j2 | | } n´t |t « r:|j .|j dk r t j |« ddd
| } njt |t « rB|j4 6|j6 *t j. |ft j8 ¬« | } nt j |« | } | f|z } t j: |« } || S ) am
|
Reorder an indexer of a MultiIndex (self) so that the labels are in the
|
same order as given in seq
|
|
Parameters
|
----------
|
seq : label/slice/list/mask or a sequence of such
|
indexer: a position indexer of self
|
|
Returns
|
-------
|
indexer : a sorted position indexer of self ordered as seq
|
FrU r Nr Trj r¿ ) rq rà r rô r2 r0 r
rÛ r r1 r rº rõ rö rZ ræ rÅ r> rB r8 rA r rË Úonesr r_ r r& r r³ ) r^ r© rÈ Ú need_sortrª r Úk_codesrt r Ú new_orderÚ key_order_mapÚ level_indexerÚinds r` r¨ zMultiIndex._reorder_indexer÷ s ð( Ü cNò DAqÜ× Ñ Ô#¤s×':Ñ':¸1Ô'=ÄÈ1Ä ØÜ a Üq6Q;ØØ×'Ñ'Ô)ð #kk¨!n× 8Ñ 8¸Ó ;GØ % g°¡lÑ 3Gà!(¨¨" °¸¸° Ñ!;× @Ñ @Ó BIà $IÜAuÔ%Ø×%Ñ%Ô'Ø !§¡¨dÐ 2Ò A°q·v±vÀ±zIà $Ià ÚÙð/ ñ0 ØNä IØ')ô cNó 'DAqÜ|àCÜ×"Ñ" 1Ô%Ü II aL¨Ñ 1 Ü a ä! !¤b§j¡j´.Ä%ÌÐ%SÔTÜ& q¨$Ó/AÜLL OÜ "§¡¬¨D¯K©K¸©NÓ(;Ä2Ç9Á9Ô MÔPSØKK NóQñ ! ð !%§ ¡ ¨A¡× :Ñ :¸1Ó = Ø -¨m¸qÑ.@Ñ A Ü/1¯y©y¼¸]Ó9KÓ/L mÑ,à )¨$¯*©*°Q©-¸Ñ*@Ñ A ÜAuÔ%¨!¯&©&Ð*<ÀÇÁÈ!Âä II aL©¨2¨Ñ .¨wÑ 7 ÜAuÔ%¨!¯'©'¨/¸a¿f¹f¸nä GG Q D´·±Ô 8¸Ñ A ô II aL¨Ñ 1 Ø < $Ñ&Dð; 'ô@ jjÓ Øs|Ðrb c ób |r|r||k r t d« | j d j ||« \ }}| j ||« \ }}t | j « }|d || |d< | j D cg c] }||| } }| d |z
|
| d< t || | j d¬« S c c}w )aÓ
|
Slice index between two labels / tuples, return new MultiIndex.
|
|
Parameters
|
----------
|
before : label or tuple, can be partial. Default None
|
None defaults to start.
|
after : label or tuple, can be partial. Default None
|
None defaults to end.
|
|
Returns
|
-------
|
MultiIndex
|
The truncated MultiIndex.
|
|
Examples
|
--------
|
>>> mi = pd.MultiIndex.from_arrays([['a', 'b', 'c'], ['x', 'y', 'z']])
|
>>> mi
|
MultiIndex([('a', 'x'), ('b', 'y'), ('c', 'z')],
|
)
|
>>> mi.truncate(before='a', after='b')
|
MultiIndex([('a', 'x'), ('b', 'y')],
|
)
|
zafter < beforer Frý )r r rk r¤ r_ rO r )
|
r^ ÚbeforeÚafterrª r7 rp ro r r« r s
|
r` ÚtruncatezMultiIndex.truncateO s ñ4 V ¨¢Ü Ð -Ó.Ð .à{{1~×(Ñ(¨°Ó71Øoo f¨eÓ4 eä$++Ó&
|
Ø" 1 a¨Ð*
|
1 à@DÇ
|
Á
|
ÖK°[ eÒ,ÐK ÐKØ | aÑ' ! äØ ØØ++Ø "ô
|
ð
|
ùò Ls Á: B,c ó² | j |« ryt |t « syt | « t |« k7 ryt |t « s2| j |« syt | j |j « S | j |j k7 ryt | j « D ]' }| j | }|j | }|dk( }|dk( }t j ||« s y|| }| j | j j |« }|| }|j | j j |« }t |« dk( rt |« dk( r½t |t j « s|j! |« ré yt |t j « s|j! |« r yt ||« r( y y)zØ
|
Determines if two MultiIndex objects have the same labeling information
|
(the levels themselves do not necessarily have to be the same)
|
|
See Also
|
--------
|
equal_levels
|
TFr r )Úis_rº rB r
rO Ú_should_comparer: rÇ r¦ r r_ rZ Ú array_equalr rs rÅ Úequals) r^ r rª Ú
|
self_codesÚ other_codesÚ self_maskÚ
|
other_maskÚ self_valuesÚ other_valuess r` rÀ zMultiIndex.equals| s ð 88E?Øä%¤Ô'Øä t9E
|
Ò "Øä%¤Ô,à×'Ñ'¨Ô.à Ü# D§L¡L°%·-±-Ó@Ð @à <<5==Ò (Øät||Ó$ó !AØ A JØ ++ a.KØ" bÑ(IØ$¨Ñ*JÜ>> )¨ZÔ8Ù Ø# Y JÑ/JØ ++ a.×0Ñ0×5Ñ5°jÓAKà% z kÑ2KØ <<¨?×2Ñ2×7Ñ7¸ ÓDLô ;Ó 1Ò$¬¨\Ó):¸aÒ)?Øä k¬2¯:©:Ô6à"×)Ñ)¨,Õ7Ù Ü ¬b¯j©jÔ9à#×*Ñ*¨;Ö7Ù ä'¨ °\ÖBÙ ð= !ð@ rb c óÆ | j |j k7 ryt | j « D ]/ }| j | j |j | « r/ y y)zT
|
Return True if the levels of both MultiIndex objects are the same
|
|
FT)r¦ r r rÀ )r^ r rª s r` Ú equal_levelszMultiIndex.equal_levelsº sU ð
|
<<5==Ò (Øät||Ó$ò AØ;;q>×(Ñ(¨¯ © °a© Õ9Ù ð ð rb c óê | j |« \ }}|j r@t | ||« }t |t
|
« r|S t
|
j t | d |¬« S |j | d¬« }t |« r| j |« }n| j |« }|dur |j « }|S |S # t $ r- |du r t j dt t# « ¬« Y |S w xY w)NrÀ F©r» TzTThe values in the array are unorderable. Pass `sort=False` to suppress this warning.r6 )Ú_convert_can_do_setopÚhas_duplicatesrW Ú_unionrº rO r¶ rË Ú
|
differencer
r§ Ú_get_reconciled_name_objectÚ sort_valuesru r8 r9 ÚRuntimeWarningr) )r^ r r» Ú result_namesr Ú right_missingr[ s r` rÍ zMultiIndex._unionÊ s ø Ø "× 8Ñ 8¸Ó ?Ñ|Ø × Ò ô W^ E¨4Ó0Fä&¤*Ô-Ø Ü ×)Ñ)ÜV ¨°Lð *ó ð ð
|
"× ,Ñ ,¨T¸Ð ,Ó >MÜ=Ô!Ø ]Ó3à ×9Ñ9¸%Ó@à5Ñ ð
|
Ø #× /Ñ /Ó 1Fð M6Møô !ò Øt|Ø Ü MMðFä&Ü#3Ó#5ö ð Mðús Â(B< Â<2C2Ã1C2c ó t |« S r¹ )r1 )r^ r s r` Ú_is_comparable_dtypez MultiIndex._is_comparable_dtypeì s Ü uÓ%Ð%rb c óh | j |« }| j |k7 r| j |« S | S )z¡
|
If the result of a set operation will be self,
|
return self, unless the names change, in which
|
case make a shallow copy of self.
|
)Ú_maybe_match_namesrt Úrename)r^ r rt s r` rÏ z&MultiIndex._get_reconciled_name_objectï s4 ð ×'Ñ'¨Ó.Ø ::Ò à;;uÓ%Ð %Ø rb c ó2 t | j « t |j « k7 rdgt | j « z S g }t | j |j « D ]- \ }}||k( r|j |« |j d« / |S )zë
|
Try to find common names to attach to the result of an operation between
|
a and b. Return a consensus list of names if they match at least partly
|
or list of None if they have completely different names.
|
N)r
rt rË r§ )r^ r rt Úa_nameÚb_names r` r× z MultiIndex._maybe_match_namesû s ô tzz?c %§+¡+Ó .Ò .Ø6C §
|
¡
|
OÑ+Ð +ØÜ ! $§*¡*¨e¯k©kÓ :ò #NFFØÒ Ø VÕ$ð TÕ"ð #ð rb c óL | j |« \ }}|j |« S r¹ )rË Ú set_names©r^ r r r rÒ s r` Ú_wrap_intersection_resultz$MultiIndex._wrap_intersection_result s' Ø ×4Ñ4°UÓ;<Ø× Ñ Ó-Ð-rb c ó¦ | j |« \ }}t |« dk( r |j « j |« S |j |« S rð )rË r
rì rÝ rÞ s r` Ú_wrap_difference_resultz"MultiIndex._wrap_difference_result sM Ø ×4Ñ4°UÓ;<ä v;!Ò Ø×.Ñ.Ó0×:Ñ:¸<ÓHÐ Hà×#Ñ# LÓ1Ð 1rb c ó. | j }t |t « sGt |« dk( r| d d | j fS d} t j || j ¬« }||fS t | |« }||fS # t t f$ r}t |« |d }~ww xY w)Nr z.other must be a MultiIndex or a list of tuplesr ) rt rº rB r
rO rÎ r ru rE )r^ r rÒ r- r§ s r` rË z MultiIndex._convert_can_do_setop s£ Øzz ä%¤Ô'Ü5zQØBQx §¡Ð+Ð+àFð2Ü &× 2Ñ 2°5ÀÇ
|
Á
|
Ð 2Ó KEð lÐ"Ð"ô /¨t°UÓ;LàlÐ"Ð"øô #¤IÐ.ò 2ô $ C.¨cÐ1ûð2ús ¿!A4 Á4BÂ BÂBc óª t |« }t |t « r d}t |« t |« s t d« |du r| j « S | S )Nz3> 1 ndim Categorical are not supported at this timezISetting a MultiIndex dtype to anything other than object is not supportedT)r4 rº r5 rÁ r1 ru rÿ )r^ r r r- s r` ro zMultiIndex.astype- s[ ä UÓ#Ü eÔ -Ô .ØGCÜ% cÓ*Ð *Ü uÔ%Üð#óð ð 4<Ø::<Ð Ø rb c ó t |t « r0|j | j k7 r t d« |j S t |t
|
« s|fd| j dz
|
z z }|S t |« | j k7 r t d« |S )Nz0Item must have length equal to number of levels.)r rU )rº rO r¦ r rÇ r» r
)r^ Úitems r` Ú_validate_fill_valuez MultiIndex._validate_fill_value< s Ü dJÔ 'à||t||Ò+Ü Ð!SÓTÐTØ<<Ð ÜD¤%Ô(ð 7U d§l¡l°QÑ&6Ñ 7Ñ7Dð ô Y$,,Ò &Ü Ð OÓPÐ PØ rb c ó> t | |« \ }}|r| j « S t |« t |« k( r|| j « }n|j « }g }g }t t |j | j | j « « D ]n \ }\ }} }
|
| j |d¬« } | j |j |« « } t |
|
« } | | |< |j | « |j | « p t ||| j d¬« S )a
|
Return a new MultiIndex of the values set with the mask.
|
|
Parameters
|
----------
|
mask : array like
|
value : MultiIndex
|
Must either be the same length as self or length one
|
|
Returns
|
-------
|
MultiIndex
|
FrÊ rý )r< r r
rì rq rË r r_ r ra rÎ r+ r§ rO rt )r^ ru r ÚnoopÚsubsetr r rª Ú value_levelr r« Ú new_levelÚ value_codesÚnew_codes r` ÚputmaskzMultiIndex.putmaskJ s ô & d¨DÓ1
|
dÙ Ø99;Ð ä t9E
|
Ò "Ø4[×5Ñ5Ó7Fà×/Ñ/Ó1Fà
|
Ø ä4=Ü t{{¨D¯J©JÓ 7ó5
|
ò 'Ñ 0AÑ0 U Kð K°e Ó<IØ#×3Ñ3°F×4KÑ4KÈAÓ4NÓOKÜ# KÓ0HØ (HTNØ × Ñ iÔ (Ø × Ñ XÕ &ð 'ô Ø Y°d·j±jÐSXô
|
ð
|
rb c ó | j |« }g }g }t || j | j « D ]y \ }}}||vr t |« }|j ||« }n|j |« }|j |« |j t j
|
t |« ||« « { t ||| j d¬« S )a
|
Make new MultiIndex inserting new item at location
|
|
Parameters
|
----------
|
loc : int
|
item : tuple
|
Must be same length as number of levels in the MultiIndex
|
|
Returns
|
-------
|
new_index : Index
|
Frý ) ræ rË r r_ r
Úinsertr? r§ rZ r+ rO rt ) r^ r, rå r r r r r« Úlev_locs r` rð zMultiIndex.insertr s ð ×(Ñ(¨Ó.à
|
Ø Ü%(¨¨t¯{©{¸D¿J¹JÓ%Gò QÑ !AukØ~ô e*Ø W¨aÓ0à --¨Ó*à × Ñ eÔ $Ø × Ñ RYY¤|°KÓ'@À#ÀwÓ OÕ Pð Qô Ø Y°d·j±jÐSXô
|
ð
|
rb c ó¬ | j D cg c] }t j ||« }}t | j || j
|
d¬« S c c}w )z}
|
Make new index with passed location deleted
|
|
Returns
|
-------
|
new_index : MultiIndex
|
Frý )r_ rZ r) rO r rt )r^ r, r« r s r` r) zMultiIndex.delete sO ð EIÇJÁJÖO°[RYY{¨CÕ0ÐO ÐOÜØ;;ØØ**Ø "ô
|
ð
|
ùò Ps Ac ó$ t |t « r t |« }|t |« dk( r/t j
|
t | « ft j ¬« S t |t « st j |« }|j « j | « dk7 S | j |« }| j |« }|j dk( r.t j
|
t |« t j ¬« S |j |« S )Nr r¿ r )rº r r¤ r
rZ r r£ rO rÎ rË ra r rÎ rô r3 )r^ rå r ÚnumÚlevss r` r3 zMultiIndex.isin¥ sÊ ä fiÔ (Ü&\Fà =Ü6{aÒ Üxx¤ T£ ´B·H±HÔ=Ð=Ü f¤jÔ1Ü#×/Ñ/°Ó7Ø==?×2Ñ2°4Ó8¸BÑ>Ð >à×(Ñ(¨Ó/CØ×(Ñ(¨Ó-DàyyA~Üxx¤ D£ ´·±Ô:Ð:Ø99VÓ$Ð $rb Ú__add__Ú__radd__Ú__iadd__Ú__sub__Ú__rsub__Ú__isub__Ú__pow__Ú__rpow__Ú__mul__Ú__rmul__Ú __floordiv__Ú __rfloordiv__Ú __truediv__Ú __rtruediv__Ú__mod__Ú__rmod__Ú
|
__divmod__Ú __rdivmod__Ú__neg__Ú__pos__Ú__abs__Ú
|
__invert__)NNNNNFNT)r rO r rO rN r )r r¤ r r¤ )NNN)r_ ú list | Noner r r¨ zlist[int] | range | None)r r rt ú-Sequence[Hashable] | Hashable | lib.NoDefaultrN rO r/ )rÌ z Iterable[tuple[Hashable, ...]]r r rt ú$Sequence[Hashable] | Hashable | NonerN rO )rÒ z Sequence[Iterable[Hashable]]r r rt r rN rO )r× rM r r rt r rN rO )rN ú
|
np.ndarray)rN rN )rN r )rN rF )r rO r rO r rO rN ÚNone)r rO rN rO )rN r )rN zCallable[..., MultiIndex])rå r rN rO )rN rO )NFN)r. rO rN r r¹ )rN r )rB r rN rO )rN znp.dtyperM ©F)r. rO rN r )rl rp rN znpt.NDArray[np.object_])NNNFé NT)rs z bool | Nonerz úCallable | Nonerl z
|
str | Nonert rO r r r rO rN r¤ )r rO r zbool | None | lib.NoDefaultrz r rN r¤ )r rO )rN rp )rN z list[str])Úfirst)r½ r rN r¦ )r )rÆ r rN rO )r r rË rO rN rB )rN rB )r rO rÔ rO rN rM )rà rO rN rO )r^ rO rú rõ rN rO )r TN)r^ rO rW r r rO rN rO )r rp rN únpt.NDArray[np.intp])r! r rN rO )NÚraise)r z.Index | np.ndarray | Iterable[Hashable] | Noner* r rN rO )r )r* r rN rO )r0 r )T)r rO rN z!Generator[np.ndarray, None, None])rN zlist[Categorical])r TTr )
|
r r rH zbool | list[bool]rI rO r rp rN z'tuple[MultiIndex, npt.NDArray[np.intp]])rM rO )r rB rM rO rN rB )rN r )rY rp rN z"tuple[Index, npt.NDArray[np.intp]])rY rp rN r )rN r )rh z Hashable | Sequence[Hashable]rf úLiteral['left', 'right']rN r )rN ztuple[int, int])rp )ri r» rf r )rx rB rB r rN r )r T)r r r rO )r )r zint | list[int])r N)r r rÈ z npt.NDArray[np.bool_] | None)r© z,tuple[Scalar | Iterable | AnyArrayLike, ...]rÈ r rN r )r rn rN rO )r rO rN rO )r r rN rO )r rO rN rO )r rO )r rO rN rO )r, r rN rO r¥ )rc rd re rf rB Ú _hidden_attrsÚ frozensetÚ_typr Ú__annotations__rF r÷ r Ú _comparablesr r r Ú classmethodr r° r¶ r| rÎ rÔ rÚ r' rÇ Úpropertyrå r´ rî rñ rô r r r r¦ r r_ r r r& r) r( r+ rÿ r r; r rC r rP rT rV rS rh ro r r r r rt r¢ r r r¶ r¸ r Ú _duplicatedrÄ rÉ r² rÎ rË rÖ rÙ rÛ r¥ râ rì rñ rø rû r& rC Ú_index_doc_kwargsrs r§ rÞ r r. r$ r9 r= r; rA r rJ rN rL rQ rS rX rV rU ri rk rg rs r? r r r r¯ r¨ r» rÀ rÈ rÍ rÕ rÏ r× rß rá rË ro ræ rî rð r) r3 rÝ rØ rG rö r÷ rø rù rú rû rü rý rþ rÿ r r r r r r r r r r r
|
r Ú __classcell__)r[ s @r` rO rO ä s(
|
ø
ñQðf ×'Ñ'©)«+Ñ5Mð DØ$&FÐ !Ó&ÙlGÙ \FØ9LàÓð ØØØØØØ Ø!%ð-ð ð-ð ð-ð
|
ó-ó^ð4 "Ø "Ø59ð LàðLð ðLð 3ó Lð\ ð !%Ø?B¿~¹~ð D
|
ð ðD
|
ð =ð D
|
ð
|
|
ò D
|
ó ðD
|
ðL Øð !%Ø6:ð MIà.ðMIð ðMIð 4ð MIð
|
|
ò MIó ó ðMIð^ ð !%Ø?B¿~¹~ð :Dà/ð:Dð ð:Dð =ð :Dð
|
|
ò :Dó ð:Dðx ð !%Ø6:ð BJà ðBJð ðBJð 4ð BJð
|
|
ò BJó ðBJðL òó ðð2 ò ó ð ð ñ
|
ó ð
|
ð òRó ðRó4"ð òó ðð ò8"ó ð8"ð| ØØ Ø!&ñ+ ð
|
ð + ð ð + ð ð+ ð
|
ó+ ð\ $¸dñ`Ø7;ð`à ó`ðD ò !ó ð !ð ò 2ó ð 2ð$ òó ðð ØØ Ø!&ñ' ð
|
ð ' ð ð ' ð ð' ð
|
ó' ðT #¸Tñ>Ø6:ð>à ó>ðF ñFó ðFð: ò&ó ð&ñ × Ñ Ó Ø58·^±^ó Kó ðKó
|
|
ð" ØØ ð >ð ð>ð
|
|
ó >ô@ô(ñ × Ñ Ó òó ðð ò ó ð ó<ñ × Ñ Ó ó"ó ð"ð ò#ó ð#ôò2Kð %ñ" Ø ð" à ó" ðL !Ø%)Ø !ØØØØðO!àðO!ð #ðO!ð ð O!ð
|
ð O!ð ð O!ð ðO!ð
|
óO!ðl &*ñ = ð ð= ð .ð = ð
|
#ð = ð
|
ó = óD'ð *.Àõ 8 ñt Ø Ø ð ô Eð* òó ðóð6 ò ?ó ð ?ð< ò2ó ð2ð ò6ó ð6ñ × Ñ Óó%ó ð%ð KóHñ Óó
|
/ó ð
|
/ô4ó42ñh ÓòDó ðDð Ø ^^Ø!&ð XàðXð ð Xð
|
|
ó Xóx 8ó<"3ðH ò 8ó ð 8ôA
|
óFSòp7ò óD
|
ñ$ Ð Ñ(Ð+<Ñ<Ó=ð Ø Øð
|
Øð
|
ð ð
|
ð ð
|
ð
|
ò
|
ó >ð
|
ò>=%ð@ )/ñPØ"%ðPà óPñ Ð Ñ*Ð->Ñ>Ó?ó
|
ó @ð
|
ð( AEØ %ð Y!ð >ðY!ð ð Y!ð
|
|
ó Y!ðx 3:ðØ$/ðà óô*8
|
ót"óH
|
ð (,ð Ø $ð à *ó ó
|
ð, Ø'+Ø #Ø"ð c"àðc"ð %ðc"ð ð c"ð
|
ð c"ð
|
1ó c"óJó ó)ð ò=ó ð=ð ;Ø !ð ;à +õ ;õ Fó(*ð29à,ð29ð 'ð29ð
|
ó 29öj54ôn1Kóf,ò2xXôt5ônS)ðl LPðo%Ø ðo%Ø,Hóo%óbC7ðNV à 9ðV ð &ðV ð
|
ó V ôp+
|
óZ<ó| õ óD&ó
|
òó".ó2ò#ñ* Óó ó ð ò ó &
|
óP!
|
óF
|
ñ _ó%ó ð%ð( __Fñ
|
iÓ(GÙ zÓ*HÙ zÓ*HÙ iÓ(GÙ zÓ*HÙ zÓ*HÙ iÓ(GÙ zÓ*HÙ iÓ(GÙ zÓ*HÙ" >Ó2LÙ# OÓ4MÙ! -Ó0KÙ" >Ó2LÙ iÓ(GÙ zÓ*HÙ Ó.JÙ! -Ó0Ká iÓ(GÙ iÓ(GÙ iÓ(GÙ Ó.Jrb c ó | D cg c] }t |« }}t |dd« D ] }t j |d| « s |c S yc c}w )zJCount depth (up to a maximum of `nlevels`) with which codes are lexsorted.r r N)r+ r r¯ r° )r_ r¦ r« Ú int64_codesr s r` r¥ r¥ Ø sV à@EÖF°< Õ,ÐFKÐFÜ 7ArÓ "ò Ü × Ñ ¨R¨a Õ 1ØHðð ùò Gs
Ac óª t t | « }t | « }|d |dz }|| }||dz d D ] }g }t t ||« « D ]q \ } \ }
|
} | |dz
|
k( r$|j | « |j |« n?|
|
| k( r|j |« L|j || d « |j |« n |} t t | « S )NrU )r¤ rË r
rq r§ r ) Ú
|
label_listr r
Úpivotedr r ÚprevÚcurÚ
|
sparse_currª ÚpÚts r` r r á sð Ü3
|
Ð#Ó$GÜ JAà [uqyÐ !FØ 5>Dàuqy{Ð#ò Ø
|
ä"¤3 t¨S£>Ó2ò IAv1ØAEzØ×!Ñ! !Ô$ð jÔ)ÙàAvØ×!Ñ! (Õ+à×!Ñ! # a b 'Ô*ð jÔ)Ùð ð" ð)ô, V Ó Ð rb c ó¸ t | t « r | j S | j }t j
|
dt j dij |d« S )NÚNaTÚNaN)rº r6 r r( rZ Ú
|
datetime64Ú timedelta64Úget)r Ú
|
dtype_types r` r r sF Ü% Ô(Ø..Ð!Ð"àZZ
|
ä MM5¤"§.¡.°%Ð 8× <Ñ <¸ZÈÓ OÐOrb c óÎ | }t |t « r |D ] } | j dg« } | S | j dg« } | S # t $ r |cY c S w xY w# t $ r Y | S w xY w)z¬
|
Attempt to drop level or levels from the given index.
|
|
Parameters
|
----------
|
index: Index
|
key : scalar or tuple
|
|
Returns
|
-------
|
Index
|
r )rº r» r r )r rB Úoriginal_indexr s r` Úmaybe_droplevelsr5
|
s ð NÜ#uÔ ð ò &Að &Ø ×1Ñ1°1°#Ó6ð &ð Lð Ø×-Ñ-¨q¨cÓ2Eð Løô ò &à%Ô%ð &ûô ò Ø à Lð ús" A°A Á AÁAÁ A$Á#A$c ód t | |« } |r| j « } d| j _ | S )a
|
Coerce the array-like indexer to the smallest integer dtype that can encode all
|
of the given categories.
|
|
Parameters
|
----------
|
array_like : array-like
|
categories : array-like
|
copy : bool
|
|
Returns
|
-------
|
np.ndarray
|
Non-writeable.
|
F)r* r rq rr )Ú
|
array_liker` r s r` r r + s3 ô & j°*Ó=JÙ Ø __Ó&
|
Ø!&J×ÑÔ Ø Ðrb c ó& | Xt | « sMt |« st | d« t |« dkD r t |d « rt | d« | g} |g}| |fS | t | « r't |« rt |d « st | d« | |fS )zT
|
Ensure that level is either None or listlike, and arr is list-of-listlike.
|
z must be list-liker z must be list of lists-like)r0 ru r
)r rµ Úarrnames r` r
|
r
|
B s ð Ф ¨eÔ!4ÜCÔ ÜwiÐ'9Ð :Ó;Ð ;Ü s8a<L¨¨Q©Ô 0ÜwiÐ'9Ð :Ó;Ð ;ØØeð #:Ðð
|
, uÔ-ÜCÔ ¬ °S¸±VÔ(<ÜwiÐ'BÐ CÓDÐ DØ #:Ðrb )rz r rN r )r_ zlist[np.ndarray]r¦ r rN r )r r )r r r
rn )r r rN rp )r rB rN rB r )r rO rN r )r9 rp )Ú
|
__future__r Úcollections.abcr r r r r Ú functoolsr Úsysr Útypingr r r r r r8 ÚnumpyrZ Úpandas._configr Ú pandas._libsr r¯ r rg r Úpandas._libs.hashtabler Úpandas._typingr r r r r r r r r r r r! Úpandas.compat.numpyr" rþ Ú pandas.errorsr# r$ r% Úpandas.util._decoratorsr& r' r( Úpandas.util._exceptionsr) Úpandas.core.dtypes.castr* Úpandas.core.dtypes.commonr+ r, r- r. r/ r0 r1 r2 r3 r4 Úpandas.core.dtypes.dtypesr5 r6 Úpandas.core.dtypes.genericr7 r8 Ú pandas.core.dtypes.inferencer9 Úpandas.core.dtypes.missingr: r; Úpandas.core.algorithmsÚcoreÚ
|
algorithmsÚ pandas.core.array_algos.putmaskr< Úpandas.core.arraysr= r> Ú pandas.core.arrays.categoricalr? r@ Úpandas.core.commonÚcommonrà Úpandas.core.constructionrA Úpandas.core.indexes.baseÚindexesÚbaserî rB rC rD rE Úpandas.core.indexes.frozenrF Úpandas.core.ops.invalidrG Úpandas.core.sortingrH rI Úpandas.io.formats.printingrJ rK rì rL rM rN Údictr ÚupdateÚBaseMultiIndexCodesEnginerh rS rp rl r| rO r¥ r r r5 r r
|
rj rb r` ú<module>ra s} ðÝ "÷õ õ Ý ÷õ ó ã å %÷ñ õ
|
.÷ ÷ ÷ ó õ /÷ñ ÷
|
ñ õ
|
5å 8÷ ÷ ÷ ÷÷õ 7÷÷
|
'Ð &Ý <÷÷÷ !Ð Ý 3ß (Ó (÷ó õ 2Ý 3÷÷
|
ñ
|
÷ñ ñ ×0Ñ0Ó1Ð Ø × Ñ ØÐ,JÑKôô
|
$38×=Ñ=¸x×?TÑ?Tô $3ôN&3H× >Ñ >À×@UÑ@Uô &3óR ô&q;/ô q;/óhw ô ó@Pó ôBô.rb
|
