U
|
¬ý°d+ ã @ s d dl mZ d dlmZ d dlmZ d dlmZmZm Z m
|
Z
|
m Z m Z m Z mZmZmZmZmZ d dlZd dlZd dlmZ d dlmZmZ m Z d dl 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+ d d
|
l,m-Z. d d l/m0Z0m1Z1m2Z2 d d l3m4Z4m5Z5m6Z6 d d l7m8Z8 d dl9m:Z: d dl;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZF d dlGmHZH d dlImJZJmKZKmLZL d dlMmNZNmOZO d dlPmQ mRZ d dlSmTZT d dlUmVZV d dlWmXZX d dlYmQ mZZ[ d dl\mQ m] m^Z_ d dl\m`Z`maZambZbmcZc d dldmeZe d dlfmgZg d dlhmiZimjZjmkZk d dllmmZm erFd dlnmoZompZpmqZq ere_jsZses td d d ¡ G d d d e jue jvZwG d!d" d"e jue jxZyd#d#d$d%d&ZzG d'd d e`Z{d(d)d)d*d+d,Z|dCd)d.d/d0d1Z}d2d3d4d5Z~d6d6d7d8d9ZdDd;d<d=d>d?Zd2d@dAdBZdS )Eé )Ú annotations)Úwraps©Ú getsizeof) Ú TYPE_CHECKINGÚAnyÚCallableÚ
|
CollectionÚ GeneratorÚHashableÚIterableÚListÚLiteralÚSequenceÚTupleÚcastN)Ú
|
get_option)ÚalgosÚindexÚlib)Ú
|
duplicated) ÚAnyAllÚ AnyArrayLikeÚAxisÚDropKeepÚDtypeObjÚFÚ IgnoreRaiseÚ
|
IndexLabelÚScalarÚShapeÚnpt)Úfunction)ÚInvalidIndexErrorÚPerformanceWarningÚUnsortedIndexError)ÚAppenderÚcache_readonlyÚdoc)Úfind_stack_level)Úcoerce_indexer_dtype) Ú ensure_int64Úensure_platform_intÚis_categorical_dtypeÚis_extension_array_dtypeÚ is_hashableÚ
|
is_integerÚ is_iteratorÚ is_list_likeÚis_object_dtypeÚ is_scalarÚ pandas_dtype)ÚExtensionDtype)Ú ABCDataFrameÚABCDatetimeIndexÚABCTimedeltaIndex)Úarray_equivalentÚisna)Úvalidate_putmask)Ú Categorical)Úfactorize_from_iterables)ÚIndexÚ_index_shared_docsÚ ensure_indexÚget_unanimous_names)Ú
|
FrozenList)Úmake_invalid_op)Úget_group_indexÚindexer_from_factorizedÚlexsort_indexer)Ú pprint_thing)ÚCategoricalIndexÚ DataFrameÚSeriesÚ
|
MultiIndexz MultiIndex or list of tuples)ÚklassZ target_klassc @ s e Zd ZdZejZdd ZdS )ÚMultiIndexUIntEngineza
|
This class manages a MultiIndex by mapping label combinations to positive
|
integers.
|
c C s0 || j K }|jdkr tj |¡S tjj|ddS )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Úcodes© rZ úPd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/indexes/multi.pyÚ_codes_to_ints} s
|
|
z#MultiIndexUIntEngine._codes_to_intsN)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__ÚlibindexÚ UInt64EngineÚ_baser\ rZ rZ rZ r[ rN u s rN c @ s e Zd ZdZejZdd ZdS )Ú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 C s6 | d¡| j> }|jdkr&tj |¡S tjj|ddS )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).
|
ÚobjectrO rP )ÚastyperR rS rT rU rV rW rZ rZ r[ r\ ¥ s
|
z$MultiIndexPyIntEngine._codes_to_intsN)r] r^ r_ r` ra Ú ObjectEnginerc r\ rZ rZ rZ r[ rd s rd r )ÚmethÚreturnc s t fdd}tt|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 s> d|krd|krt dd|kr.| d¡|d< | f||S )NÚnameÚnamesz*Can only provide one of `names` and `name`)Ú TypeErrorÚpop)Z self_or_clsÚargsÚkwargs©rh rZ r[ Únew_methÌ s
|
z names_compat.<locals>.new_meth)r r r )rh rq rZ rp r[ Ú names_compatÅ s rr c s2 e Zd ZU dZeje B ZdZg Zde d< e
|
Z e
|
Z dgZ de d< dZd d d d d dZdddddZd[dddddZedejfdd dddZeed\ddd d d d d Zedejfd ddd d!d"d#Zed]d$d d%d&d'Zed(d)d*d+Zed(d)d,d-Z ed.d/ Z ed0d)d1d2Z d3d)d4d5Z ed3d)d6d7Z ed8d)d9d:Z!dd d
|
d d;d d d d<d=d>d?Z"dd
|
d@d d dAdBdCZ#ed3d)dDdEZ$edFd)dGdHZ%edIdJ Z&dd d
|
d d;d d d d<d=dKdLZ'dd
|
d@d dMdNdOZ(edPdQ Z)edRd)dSdTZ*e+ej,ejfd(d dUdVdWZ,d d)dXdYZ-d^d dZd[d\Z.d_d(d)d]d^Z/d`d_d`Z0e+ej1dad dbdcddZ1eded)dfdgZ2d d)dhdiZ3e+ej4dad d3djdkdlZ4ed3d)dmdnZ5dbd d3djdodpZ6dqdr Z7dsdtdudvdwdxdyZ8dcd{d|d}d d3d dd~ddZ9d8d)ddZ:dd
|
dd dd
dZ;ee;e:ddZ<edud)ddZ=d3d)ddZ>ed d)ddZ?ed d)ddZ@edd)ddZAe+ejBdddddddZBeBZCdeddZDe+ejEdfdd ddd ZEdgd3d d¡d¢d£d¤ZFd¥d¦ ZGe+ejHdhd§d¨ZHd
|
ejd fd d d$d©dªd«ZId¡d)d¬dZJd d)d®d¯ZKed3d)d°d±ZLdid d d²d³d´ZMd d)dµd¶ZNd·d¸ ZOd¹dº ZPd d»d d¼d½d¾ZQeReSd¿ eT djd dÁd d dÂdÃdÄZUdÅdÆ ZVdÇd)dÈdÉZWeReSdÊ eT dkd3d dËdÌdÍZXdldÏdÐd dÑdÒdÓZYdmdÐd dÔdÕdÖZZdnd d)dÙdÚZ[d d)dÛdÜZ\dÝd)dÞdßZ]dodàdád dâdãdädåZ^d dædçdèZ_d¡d d¡dédêdëZ`d<d)dìdíZaed d)dîdïZbdudðdñ fdòdó Zcdud<dñ fdôdõ ZddÇd)död÷Zedødùd3dúdûdüZfdpdýd) fdþdÿ ZgdqddùdddZhd¡dd3dddZid d
|
Zjdrdàd d d d ZkdsddddZldtd3ddddZmdd ZnddÇdÇdddZodud d)d d Zpd d d d d!Zqd d d d"d#Zrd d) fd$d% Zsd&d d'd(d)Ztd d)d*d+Zud,d- Zvd d)d.d/Zwd d d0d1d2Zxd3d4 Zye+ejzdvd d5d6d7Zzd8d9 Z{d d d:d;d<Z|d3d d=d>d?Z}d d)d@dAZ~e+ejdwdd)dBdCZejZedDZedEZedFZ
edGZedHZedIZedJZedKZedLZedMZedNZedOZedPZedQZedRZedSZedTZedUZedVZedWZedXZedYZ ZS (x rL 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.
|
Z
|
multiindexzlist[Hashable | None]Ú_namesrk z
|
int | NoneÚ sortorderNFTÚbool)ÚcopyÚverify_integrityri c C sà |d k r |}|d ks |d kr$t dt|t|kr<tdt|dkrPtdt | ¡} i | _| j||dd | j||dd d gt| | _|d k r¢| |¡ |d k r¶t
|
|| _ n|| _ |rÎ| ¡ }
|
|
|
| _ | ¡ 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)rv Úvalidate)rl ÚlenÚ
|
ValueErrorre Ú__new__Ú_cacheÚ _set_levelsÚ
|
_set_codesrs Ú
|
_set_namesÚintrt Ú_verify_integrityÚ_codesÚ_reset_identityZ _references) ÚclsÚlevelsrY rt rk Údtyperv rj rw ÚresultÚ new_codesrZ rZ r[ r{ : s0
|
|
zMultiIndex.__new__Úlist)ÚlevelÚcodec C s( t |}t |¡r$t || 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; rT ÚanyÚwhere)rX r r Z null_maskrZ rZ r[ Ú_validate_codesi s
|
zMultiIndex._validate_codesz list | None)rY r
c sf |p j }|p j}t|t|kr,tdt|d }tt||D ]¸\}\}}t||krvtddd |D t|r²| ¡ t|kr²td| d| ¡ dt| d t|rà| ¡ d
|
k ràtd| d | ¡ d |jsFtd t | d| qF j
|
dk rB j
|
t j j krBtd j
|
dt j j fddt||D }t |}|S )a7
|
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.
|
|
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: c S s g | ] }t |qS rZ ©ry )Ú.0Zcode_rZ rZ r[ Ú
|
<listcomp>£ s z0MultiIndex._verify_integrity.<locals>.<listcomp>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 NzQValue for sortorder must be inferior or equal to actual lexsort_depth: sortorder z with lexsort_depth c s g | ]\}} ||¡qS rZ )r )r r r ©rX rZ r[ r ¹ s )rY r
ry rz Ú enumerateÚzipÚmaxÚminÚ is_uniquer rt Ú_lexsort_depthÚnlevelsrC )rX rY r
Z codes_lengthÚir Ú level_codesr rZ r r[ r s@
|
|
ÿ ÿ ÿÿ ÿ
|
ÿz MultiIndex._verify_integrityz-Sequence[Hashable] | Hashable | lib.NoDefault)rk ri c C s¬ d}t |st|t|r$t|}|D ]}t |s(t|q(tdt|D ](}t|| t||d krLtdqLt|\}}|tj krdd |D }| ||||ddS )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.rO z all arrays must be same lengthc S s g | ]}t |d dqS ©rj N©Úgetattr)r ÚarrrZ rZ r[ r ü s z*MultiIndex.from_arrays.<locals>.<listcomp>F©r
rY rt rk rw )
|
r2 rl r1 r Úrangery rz r> r Ú
|
no_default) r Úarraysrt rk Ú error_msgÚarrayr rY r
rZ rZ r[ Ú from_arrays¿ s* *
|
|
|
ûzMultiIndex.from_arraysz Iterable[tuple[Hashable, ...]]z Sequence[Hashable] | Hashable)Útuplesrt rk ri c C s8 t |stdt|r t|}ttttdf |}t|rt dd |D rt
|
t|¡g}t t j|t
|
d¡dg}| ||||ddS t|d kr¸|d
|
kr¨td g gt| }npt|t
|
jt frðt|t rÞt
|
|j¡}tt |¡j}n8t|trtt |¡j}nt| }tttt |}| j|||d 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 s s | ]}t |to| V qd S ©N)Ú
|
isinstanceÚtuple)r ÚerZ rZ r[ Ú <genexpr>8 s z)MultiIndex.from_tuples.<locals>.<genexpr>re ©r Fr¡ r Nz-Cannot infer number of levels from empty list©rt rk ) r2 rl r1 r r r r r ry ÚallrT Úzerosr? ÚcomÚasarray_tuplesafer rª ÚndarrayÚasarrayÚ_valuesr Ztuples_to_object_arrayÚTZto_object_array_tuplesr r r r§ )r r¨ rt rk rY r
r¤ ZarrsrZ rZ r[ Ú from_tuples s8 +û
|
zMultiIndex.from_tuplesz Sequence[Iterable[Hashable]])Ú iterablesrt rk ri c C sh ddl m} t|s tdt|r,t|}t|\}}|tjkrPdd |D }||}| ||||dS )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.c S s g | ]}t |d dqS r r )r ÚitrZ rZ r[ r s z+MultiIndex.from_product.<locals>.<listcomp>r¯ ) Zpandas.core.reshape.utilrº r2 rl r1 r r> r r£ )r r¹ rt rk rº rY r
rZ rZ r[ Ú from_productW s .
|
zMultiIndex.from_productrJ )Údfri c C sB t |tstdt| ¡ \}}|dkr.|n|}| j|||dS )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 DataFrameNr¯ )rª r7 rl r Úitemsr§ )r r½ rt rk Z column_namesÚcolumnsrZ rZ r[ Ú
|
from_frame s
|
9
|
zMultiIndex.from_frameú
|
np.ndarray©ri c C s¦ g }t | jD ]}| j| }| j| }|}t|jrHtd|}|j ¡ }t |jt
|
sbt |t t frl| t¡}tj|dd}tj|||jd}| |¡ qt |¡}|S )NrI F©rv ©Ú
|
fill_value)r¢ r r
rY r- r r Ú_dataZ_internal_get_valuesrª r6 r8 r9 rf re rT r¦ r Útake_ndÚ _na_valueÚappendr Zfast_zip)rX Úvaluesr r rY Úvalsr rZ rZ r[ r¶ Ö s$
|
|
|
|
|
ÿ
|
|
zMultiIndex._valuesc C s | j S r© ©r¶ r rZ rZ r[ rÊ ð s zMultiIndex.valuesc C s t ddS )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.N)rz r rZ rZ r[ r¦ ô s
|
ÿzMultiIndex.arrayrK c C s> ddl m} t dd | jD ¡}|dd | jD t|dS )zN
|
Return the dtypes as a Series for the underlying MultiIndex.
|
r )rK c S s g | ]
|
}|j qS rZ ©rj ©r r rZ rZ r[ r
|
s z%MultiIndex.dtypes.<locals>.<listcomp>c S s g | ]
|
}|j qS rZ r® rÎ rZ rZ r[ r s )r )ÚpandasrK r² Zfill_missing_namesr
r? )rX rK rk rZ rZ r[ Údtypes s zMultiIndex.dtypesr c C s t | jd S ©Nr )ry rY r rZ rZ r[ Ú__len__ s zMultiIndex.__len__c C s t | S )zG
|
Return the number of elements in the underlying data.
|
r r rZ rZ r[ Úsize s zMultiIndex.sizerC c C s0 dd t | j| jD }|D ]
|
}d|_q t|S )Nc S s g | ]\}}|j |d qS )rÍ )Z_rename)r Úxrj rZ rZ r[ r s z%MultiIndex.levels.<locals>.<listcomp>T)r Ú_levelsrs Z_no_setting_namerC )rX r r rZ rZ r[ r
s zMultiIndex.levels)r rv rx rw ÚNone)rv rx rw ri c s |rVt |dkrtd|d kr6t |jkr6td|d k rVt |t |krVtd|d krvt fdd|D }nLfdd|D }tj}t||D ] \} }
|
t|
|
d ¡ || < qt|}|rØj |d
|
} | _
|
j } |_t | rö | ¡ ¡ d S ) 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 s | ]}t | d ¡ V qdS ©rà N)rA Ú_view©r Úlevrà rZ r[ r ; s z)MultiIndex._set_levels.<locals>.<genexpr>c s g | ]} |¡qS rZ ©Ú_get_level_numberrÙ r rZ r[ r ? s z*MultiIndex._set_levels.<locals>.<listcomp>rà ©r
)ry rz r rC r rÕ r rA rØ r r rk r r Ú _reset_cache) rX r
r rv rx rw Ú
|
new_levelsÚ level_numbersZnew_levels_listÚlev_numrÚ r rk rZ ©rv rX r[ r} & s0 ÿ
|
|
|
zMultiIndex._set_levels©r rw )rw ri c C sP t |rt|tst|}t||d\}}| ¡ }| ¡ |j||d|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]])
|
ZLevelsT)r rx rw )r2 rª r? r Ú_require_listlikerØ r r} )rX r
r rw ÚidxrZ rZ r[ Ú
|
set_levelsP s S ÿzMultiIndex.set_levelsc C s
|
t | jS )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
|
)ry rÕ r rZ rZ r[ r ® s zMultiIndex.nlevelsr c C s t dd | jD 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 s s | ]}t |V qd S r© r ©r rÔ rZ rZ r[ r Ì s z&MultiIndex.levshape.<locals>.<genexpr>)r« r
r rZ rZ r[ Úlevshape¾ s zMultiIndex.levshapec C s | j S r© )r r rZ rZ r[ rY Ñ s zMultiIndex.codesc sà |rB|d kr"t |jkr"td|d k rBt |t |krBtd|d krjt fddtj|D }nTfdd|D }tj}t||D ]$\} }
|
j| } t |
|
| d|| < qt|}|rÎj
|
|d}|_ ¡ d S ) Nz+Length of codes must match number of levelsz,Length of codes must match length of levels.c 3 s$ | ] \}}t || d ¡ V qdS r× )Ú_coerce_indexer_frozenÚview)r rÚ r rà rZ r[ r å s ÿz(MultiIndex._set_codes.<locals>.<genexpr>c s g | ]} |¡qS rZ rÛ rÙ r rZ r[ r ê s z)MultiIndex._set_codes.<locals>.<listcomp>rà ©rY ) ry r rz rC r rÕ r r r
ré r rÞ ) rX rY r rv rx rw r rà Znew_codes_listrá r rÚ rZ râ r[ r~ Õ s.
|
þ
|
|
|
ÿ zMultiIndex._set_codes)rw c C s4 t ||d\}}| ¡ }| ¡ |j|||d |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'])
|
ZCodesrã )rä rØ r r~ )rX rY r rw rå rZ rZ r[ Ú set_codesú s
|
8zMultiIndex.set_codesc C s t t dd | jD ¡¡}t |d d d
¡d d d
}t |dd
dgg¡ d¡}|d dkrtt| j| j|S t | j| j|S )Nc S s g | ]}t |tj qS rZ )ry ra Zmultiindex_nulls_shiftrÎ rZ rZ r[ r C s þÿz&MultiIndex._engine.<locals>.<listcomp>r rO r Úuint64é@ )
|
rT ÚceilÚlog2r
ZcumsumÚ concatenaterf rd rY rN )rX ÚsizesZlev_bitsrR rZ rZ r[ Ú_engine; s ýÿÿ zMultiIndex._enginezCallable[..., MultiIndex]c C s
|
t | jS r© )Útyper¸ r rZ rZ r[ Ú _constructor] s zMultiIndex._constructor)rÊ ri c C s( |t jk r|n| j}t| j|d |dS )Nr¯ )r r£ rk rô r¸ )rX rÊ rj rk rZ rZ r[ Ú _shallow_copya s zMultiIndex._shallow_copyc C s< t | | j| j| j| jdd}| j ¡ |_|j dd ¡ |S )NFr¡ r
)rô r
rY rt rk r| rv rm )rX r rZ rZ r[ rØ g s û zMultiIndex._view©Údeepc C s¨ | j |||d}| }d\}}|rBddlm} || j}|| j}|dk rN|n| j}|dk r`|n| j}t| ||| j|dd}| 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')],
|
)
|
)rj rk rø )NNr )ÚdeepcopyNFr¡ r
)
|
Z_validate_namesrv rù r
rY rô rt r| rm Ú_id) rX rk rø rj Zkeep_idr
rY rù Ú new_indexrZ rZ r[ rv v s* &
|
|
û zMultiIndex.copyc C s | j S )z%the array interface, return my values)rÊ ©rX r rZ rZ r[ Ú __array__¶ s zMultiIndex.__array__c C s | ¡ }| j|_|S )z0this is defined as a copy with the same identity)rv rú )rX r r rZ rZ r[ rê º s zMultiIndex.viewr )Úkeyri c
|
C s: t | z| |¡ W dS tttfk
|
r4 Y dS X d S )NTF)ÚhashÚget_locÚ LookupErrorrl rz ©rX rþ rZ rZ r[ Ú __contains__À s
|
zMultiIndex.__contains__znp.dtypec C s
|
t d¡S )NÚO)rT r r rZ rZ r[ r É s zMultiIndex.dtypec s& dddd t fdd| jD S )z5return a boolean if we need a qualified .info displayru r c S s d| kpd| kpd| kS )NÚmixedÚstringÚunicoderZ ©r rZ rZ r[ ÚfÐ s z0MultiIndex._is_memory_usage_qualified.<locals>.fc 3 s | ]} |V qd S r© rZ rÎ ©r rZ r[ r Ó s z8MultiIndex._is_memory_usage_qualified.<locals>.<genexpr>)r Ú_inferred_type_levelsr rZ r
|
r[ Ú_is_memory_usage_qualifiedÍ s z%MultiIndex._is_memory_usage_qualified)rø ri c C s
|
| |¡S r© ©Ú_nbytes)rX rø rZ rZ r[ Ú memory_usageÖ s zMultiIndex.memory_usagec C s
|
| d¡S )z1return the number of bytes in the underlying dataFr r rZ rZ r[ ÚnbytesÝ s zMultiIndex.nbytesc sj dt fdd| jD }t dd | jD }t fdd| jD }|| | }|| jj d7 }|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 s | ]}|j d V qdS )r÷ N)r ©r r r÷ rZ r[ r ï s z%MultiIndex._nbytes.<locals>.<genexpr>c s s | ] }|j V qd S r© )r r rZ rZ r[ r ð s c 3 s | ]}t | V qd S r© r r )ÚobjsizerZ r[ r ñ s r÷ )Úsumr
rY rk ró Úsizeof)rX rø Z level_nbytesZ label_nbytesZ names_nbytesr rZ )rø r r[ r â s zMultiIndex._nbytesc C s( dd | j D }tdd t||D S )zW
|
Formats each item in tup according to its level's formatter function.
|
c S s g | ]
|
}|j qS rZ )Ú_formatter_funcrÎ rZ rZ r[ r ÿ s z.MultiIndex._formatter_func.<locals>.<listcomp>c s s | ]\}}||V qd S r© rZ )r ÚfuncÚvalrZ rZ r[ r s z-MultiIndex._formatter_func.<locals>.<genexpr>)r
r« r )rX ÚtupZformatter_funcsrZ rZ r[ r û s zMultiIndex._formatter_funcÚnan)Úna_repÚstrznpt.NDArray[np.object_])r ri c K sØ g }g }t | j| jD ]z\}}|jf d|i|}|dk}| ¡ r|t|} | t¡}t ||¡}|j
|
j rlt | ¡ }| ||< | |¡ | |¡ qt|dkr¸t|d |d ¡ ¡ S t||| j| jdd}
|
|
|
jS d S )Nr r rO r F©r
rY rk rt rw )r r
rY Ú_format_native_typesr ry rf r rT rÉ ÚflagsÚ writeableÚAssertionErrorrv r? ÚtakerL rk rt r¶ ) rX r ro rß r r r Z
|
level_strsÚmaskZ nan_indexÚmirZ rZ r[ r s0
|
|
ûz MultiIndex._format_native_typesé z bool | NonezCallable | Nonez
|
str | None)rj Ú formatterr rk ÚspaceÚadjoinri c s¶ |d k r |}t | dkr g S g }t| j| jD ]\} }
|
|d k rB|nt| j t | dkr| |
|
¡j|d} |
|
dk} | ¡ r¶t j
|
| t d} | | < | ¡ } n fddt | j|
|
¡D } | | ¡ q.g } t|| jD ]N\} }g }|r| |d k rüt|ddnd ¡ | t j
|
| t d¡ | |¡ qÒ|d kr4td
|
}|rd }t|tsZ|tjksZt|d tjfkrn|}t| t||d } |r®dd l m } | }|j |f| d¡S | S d S )Nr )r& r r® c s$ g | ] }t t|r n|d dqS )©ú ú Ú
|
©Z escape_chars)rH r; rç ©ÚnarZ r[ r F s ÿz%MultiIndex.format.<locals>.<listcomp>r) r- Ú zdisplay.multi_sparseF©ÚstartÚsentinel)Úget_adjustmentr, ) ry r r
rY Ú _get_na_repr r" Úformatr rT r¦ re Útolistr rÇ r¶ rÉ rk rH Úextendr rª ru r r£ r! Úsparsify_labelsr Zpandas.io.formats.formatr4 r( Úsplit)rX rj r& r rk r' Zsparsifyr( Zstringified_levelsrÚ r Ú formattedr# Z result_levelsZlev_namer r3 r4 ZadjrZ r. r[ r6 & s\
|
|
|
þ ÿý
|
ÿ zMultiIndex.formatc C s
|
t | jS r© )rC rs r rZ rZ r[ Ú
|
_get_namess s zMultiIndex._get_names)r rx ©rx c sÖ |dk rt |stdt|}|rb|dk rDt|t|krDtd|dkrbt| jkrbtd|dkrvt j}n fdd|D }t||D ]6\}}|dk r¾t|s¾tt j
|
d| j |< q ¡ dS )aö
|
Set new names on index. Each name has to be a hashable type.
|
|
Parameters
|
----------
|
values : str or sequence
|
name(s) to set
|
level : int, level name, or sequence of int/level names (default None)
|
If the index is a MultiIndex (hierarchical), level(s) to set (None
|
for all levels). Otherwise level must be None
|
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.c s g | ]} |¡qS rZ rÛ rÙ r rZ r[ r s z)MultiIndex._set_names.<locals>.<listcomp>z .name must be a hashable type) r2 rz r ry r r¢ r r/ rl rô r] rs rÞ )rX rk r rx rÚ rj rZ r r[ r v s* ÿ ÿ zMultiIndex._set_namesam
|
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 C s dS )Nr rZ r rZ rZ r[ Ú inferred_typeÅ s zMultiIndex.inferred_typec
|
C sä | j |¡}|dkr,t|s,td| dz| j |¡}W n¢ tk
|
rÞ } zt|shtd| d||dk r¨|| j7 }|dk rÎ|| j }td| j d| d |n&|| jkrÎtd| j d
|
|d |W 5 d }~X Y nX |S ) NrO 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 )rk Úcountr0 rz r ÚKeyErrorr Ú
|
IndexError)rX r rA ÚerrZ
|
orig_levelrZ rZ r[ rÜ É s4
|
ÿ
|
|
ÿý
|
ÿýz MultiIndex._get_level_numberc s t dd jD rdS tdd jD rBt dd jD ¡S fddttt jD }zt
|
|¡}t |j W S t k
|
r t jj Y S X dS ) zI
|
Return a boolean if the values are equal or increasing.
|
c s s | ]}d |kV qdS )r NrZ )r r rZ rZ r[ r é s z5MultiIndex.is_monotonic_increasing.<locals>.<genexpr>Fc s s | ] }|j V qd S r© ©Úis_monotonic_increasingrÎ rZ rZ r[ r ì s c S s g | ]}|j d ddqS )Úint64Frà )rf rç rZ rZ r[ r ï s z6MultiIndex.is_monotonic_increasing.<locals>.<listcomp>c s g | ]} |¡jqS rZ )Ú_get_level_valuesr¶ r r rZ r[ r ó s N)r rY r° r
ÚlibalgosÚ is_lexsortedÚreversedr¢ ry rT Úlexsortr? rF rl r¶ )rX rÊ Z
|
sort_orderrZ r r[ rF ä s ÿ
|
ÿ
|
z"MultiIndex.is_monotonic_increasingc C s | ddd
j S )zI
|
Return a boolean if the values are equal or decreasing.
|
Nr rE r rZ rZ r[ Úis_monotonic_decreasing s z"MultiIndex.is_monotonic_decreasingz list[str]c C s dd | j D S )z7return a list of the inferred types, one for each levelc S s g | ]
|
}|j qS rZ )r@ r rZ rZ r[ r s z4MultiIndex._inferred_type_levels.<locals>.<listcomp>rÝ r rZ rZ r[ r s z MultiIndex._inferred_type_levelsÚfirstr únpt.NDArray[np.bool_])Úkeepri c C s0 t dd | jD }t| j|ddd}t||S )Nc s s | ]}t |V qd S r© r rÙ rZ rZ r[ r s z(MultiIndex.duplicated.<locals>.<genexpr>F)ÚsortZxnull)r« r
rE rY r )rX rP ÚshapeÚidsrZ rZ r[ r s zMultiIndex.duplicatedc C s t ddS )z:
|
fillna is not implemented for MultiIndex
|
z"isna is not defined for MultiIndexN)ÚNotImplementedError)rX ÚvalueZdowncastrZ rZ r[ Úfillna s zMultiIndex.fillnar r )Úhowri c sn dd | j D }|dkr(tj|dd n&|dkr@tj|dd ntd| fdd| j D }| j|d S )
|
Nc S s g | ] }|d kqS )r rZ ©r r rZ rZ r[ r # s z%MultiIndex.dropna.<locals>.<listcomp>r r rP r° zinvalid how option: c s g | ]}| qS rZ rZ rX ©ÚindexerrZ r[ r + s rë )rY rT r r° rz rì )rX rW Znansr rZ rY r[ Údropna! s zMultiIndex.dropnar? )r Úuniqueri c C sN | j | }| j| }| j| }|r,t |¡}tj|j||jd}|j||dS )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
rY rs r r\ rÇ r¶ rÈ rö )rX r r\ rÚ r rj ZfilledrZ rZ r[ rH . s
|
|
|
|
z MultiIndex._get_level_valuesc C s | |¡}| |¡}|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Ü rH )rX r rÊ rZ rZ r[ Úget_level_valuesG s 0
|
|
zMultiIndex.get_level_valuesc C s, |d kr| ¡ S | |¡}| j|ddS d S )NT)r r\ )Zdrop_duplicatesrÜ rH )rX r rZ rZ r[ r\ { s
|
zMultiIndex.unique)r Úallow_duplicatesri c s¦ ddl m} |tjk rFt|s&tdt|t jkr@td|}n ¡ }|sntt
|
|t|krntd| fddt t jD dd }||_ |r¢ |_ |S )
|
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 )rJ 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 Falsec s i | ]}| |¡qS rZ ©rH rÎ r rZ r[ Ú
|
<dictcomp>Ô s z'MultiIndex.to_frame.<locals>.<dictcomp>Frà )rÏ rJ r r£ r2 rl ry r
rz Z_get_level_namesÚsetr¢ r¿ r )rX r rj r^ rJ Z idx_namesr rZ r r[ Úto_frame s, <
|
ÿÿþzMultiIndex.to_framec C s t | jddS )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)Z tupleize_cols)r? r¶ r rZ rZ r[ Ú to_flat_indexß s zMultiIndex.to_flat_indexc C s | j | jkS )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 rZ rZ r[ Ú _is_lexsortedý s "zMultiIndex._is_lexsortedc C s | j dk r| j S t| j| jS )z
|
Compute and return the lexsort_depth, the number of levels of the
|
MultiIndex that are sorted lexically
|
|
Returns
|
-------
|
int
|
N)rt r rY r r rZ rZ r[ r ! s
|
|
zMultiIndex._lexsort_depth)Úraise_if_incomparableri c C s¸ | ¡ r| jr| S g }g }t| j| jD ]x\}}|jsz | ¡ }W n tk
|
r\ |rX Y n0X | |¡}t|}t
|
|t |¡}t ||¡}| |¡ | |¡ q(t||| j| jddS )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')],
|
)
|
F)rk rt rw )rd rF r r
rY Úargsortrl r" r, r Zget_reverse_indexerry r rÇ rÉ rL rk rt )rX re rß r rÚ r rZ ÚrirZ rZ r[ Ú_sort_levels_monotonic/ s0 "
|
|
ûz!MultiIndex._sort_levels_monotonicc C sb g }g }d}t | j| jD ]\}}t t |d ¡dk¡d d }tt|oX|d dk}t|t|| kr| ¡ ¡ rt|t|kr q,d}t
|
|¡}|rÔt |dk¡d }||d dg |d|d g< t t|| ¡} t t|¡| | |< | | }| ||d
¡}| |¡ | |¡ q| ¡ }
|
|r^|
|
¡ |
|
j|dd |
|
j|dd |
|
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']])
|
FrO r r TNr= )r r
rY rT r Zbincountr ry r; r r r\ r± Úaranger" rÉ rê r r} r~ ) rX rß r ÚchangedrÚ r ZuniquesZhas_naZna_idxZ code_mappingr rZ rZ r[ Úremove_unused_levelsr s4 #
|
|
z MultiIndex.remove_unused_levelsc C s6 t | jt | j| jt | jd}tjt| |fdfS )z*Necessary for making this object picklable)r
rY rt rk N)r r
rY rt rk ÚibaseZ
|
_new_Indexrô )rX ÚdrZ rZ r[ Ú
|
__reduce__Ê s üzMultiIndex.__reduce__c sî t rbt ¡ g }t| j| jD ]4\}}| dkrF| tj¡ q$| || ¡ q$t |S d }t
|
¡rtj t d | j }n:t tr¬ jd ks¤ jdkrÀ| j }nt trÀt ¡ fdd| jD }t| j|| j|ddS d S )Nr r® r c s g | ] }| qS rZ rZ rX ©rþ rZ r[ r î s z*MultiIndex.__getitem__.<locals>.<listcomp>Fr )r4 r² Zcast_scalar_indexerr r
rY rÉ rT r r« Úis_bool_indexerrµ ru rt rª ÚsliceÚstepr? rL rk )rX rþ ÚretvalrÚ r rt r rZ ro r[ Ú __getitem__Ö s2
|
|
|
|
|
ûzMultiIndex.__getitem__rq )rX Úslobjri c sL d} j dks j dkr | j} fdd| jD }t| | j|| j|ddS )zH
|
Fastpath for __getitem__ when we know we have a slice.
|
Nr c s g | ] }| qS rZ rZ rX ©ru rZ r[ r s z-MultiIndex._getitem_slice.<locals>.<listcomp>Fr )rr rt rY rô r
rs )rX ru rt r rZ rv r[ Ú_getitem_sliceø s ûzMultiIndex._getitem_slicer" r r )rX rQ Ú
|
allow_fillri c s t d|¡ t | || ¡}d} fdd| jD }|r| dk}| ¡ r|g } |D ] }
|
|
|
} || |< | t | ¡¡ qV| }t | j
|
|| j ddS )NrZ r c s g | ]}| ¡qS rZ ©r" )r Úlab©ÚindicesrZ r[ r s z#MultiIndex.take.<locals>.<listcomp>F©r
rY rk rw ) ÚnvZ validate_taker, Z_maybe_disallow_fillrY r rÉ rT rµ rL r
rk ) rX r| rQ rx rÅ ro Úna_valueZtakenr# ZmaskedZ new_labelZ label_valuesrZ r{ r[ r"
|
s( ÿzMultiIndex.takec s t |ttfs|g}tfdd|D r¨g g }}tjD ]Z ¡ fdd|D }| |¡¡ tfdd|D }| |rjnd¡ q>t j
|
||dS j ftdd |D }t |¡}z t |¡W S ttfk
|
rú t| Y S X dS ) 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 s$ | ] }t |to|j jkV qd S r© )rª rL r ©r Úor rZ r[ r D s z$MultiIndex.append.<locals>.<genexpr>c s g | ]}| ¡qS rZ r_ r )r rZ r[ r J s z%MultiIndex.append.<locals>.<listcomp>c 3 s | ]} j |j kV qd S r© rÍ rç )ÚlabelrZ r[ r L s N©rk c s s | ] }|j V qd S r© rÌ ©r ÚkrZ rZ r[ r P s )rª r r« r° r¢ r rH rÉ rj rL r§ r¶ rT rñ r¸ rl rC r? )rX Úotherr¤ rk ZappendedZsingle_label_nameZ to_concatZ
|
new_tuplesrZ )r r rX r[ rÉ * s& ÿ
|
|
|
zMultiIndex.appendznpt.NDArray[np.intp]c O s> t |dkr0t |dkr0| jdd}t| ¡ S | jj||S )Nr T)re )ry rh rG Ú_get_codes_for_sortingr¶ rf )rX rn ro ÚtargetrZ rZ r[ rf [ s zMultiIndex.argsortÚrepeat)Úrepeatsri c s@ t dd|i¡ t t| j fdd| jD | j| jddS )NrZ rQ c s* g | ]"}| tj¡jtjd d ¡qS )Frà )rê rT r´ rf Úintpr rX ©r rZ r[ r j s ÿz%MultiIndex.repeat.<locals>.<listcomp>Fr )r~ Zvalidate_repeatr, rL r
rY rk rt )rX r rQ rZ r r[ r b s
|
þøzMultiIndex.repeatÚraisez.Index | np.ndarray | Iterable[Hashable] | Noner )r Úerrorsri c C s> |dk r| |||¡S t|tjtfsTztj|t d¡d}W n tk
|
rR Y nX g }|D ]Ö}z®| |¡}t|t
|
r| |¡ nt|t r¸|j dk r|j nd}| t|j|j|¡ nTt |¡rö| jdkrÞtjdtt d | ¡ d }| |¡ ndt| }t|W q\ tk
|
r0 |d kr, Y q\X q\| |¡S )
|
aV
|
Make new MultiIndex with 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
|
Nre r® rO r zYdropping on a non-lexsorted multi-index without a level parameter may impact performance.©Ú
|
stacklevelz unsupported indexer of type Úignore) Ú_drop_from_levelrª rT r´ r? r² Úindex_labels_to_arrayr rz r r rÉ rq rr r8 r¢ r2 Ústoprp r ÚwarningsÚwarnr$ r) Únonzerorô r! rB Údelete) rX rY r r Zindsr Úlocrr ÚmsgrZ rZ r[ Údropt s>
|
|
|
|
|
ü
|
|
zMultiIndex.drop)r ri c
|
C s¸ t |¡}| |¡}| j| }| |¡}t|}d|t |d¡|dk@ < |jd | jd krld|t |d¡< ||dk }t |dkr|dkrt
|
d| dt | j | |¡ } | | S ) NéþÿÿÿFr r Tr zlabels z not found in level)r² r rÜ r
Ú get_indexerr; rT ÚequalrR ry rB r ÚisinrY )
|
rX rY r r r r rÊ Z nan_codesÚ not_foundr# rZ rZ r[ r ¯ s
|
|
|
|
zMultiIndex._drop_from_levelr r c C s t | j}t | j}t | j}| |¡}| |¡}|| || ||< ||< || || ||< ||< || || ||< ||< t|||ddS )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
rY rk rÜ rL )rX r Újrß r Ú new_namesrZ rZ r[ Ú swaplevelÄ s +
|
|
|
|
|
ÿzMultiIndex.swaplevelc s fdd|D }t | jkr:td j dt | fdd|D } fdd|D } fdd|D }t|||dd S )
|
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'])
|
c s g | ]} |¡qS rZ rÛ r r rZ r[ r s z-MultiIndex.reorder_levels.<locals>.<listcomp>z2Length of order must be same as number of levels (z), got c s g | ]} j | qS rZ rÝ r r rZ r[ r $ s c s g | ]} j | qS rZ rë r r rZ r[ r % s c s g | ]} j | qS rZ r r r rZ r[ r & s Fr} )ry r r! rL )rX Úorderrß r r¢ rZ r r[ Úreorder_levelsþ s ÿ ÿzMultiIndex.reorder_levelszlist[Categorical]c s dd fdd| j D S )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 S s* t jt| r t | ¡ ¡ d nd| jdS )NrO r r® )rT ri ry r¦ r r )r rZ rZ r[ Úcats5 s þz/MultiIndex._get_codes_for_sorting.<locals>.catsc s g | ]}t j| |d dqS )T)Zordered)r= Ú
|
from_codesrX ©r¦ rZ r[ r ; s ÿz5MultiIndex._get_codes_for_sorting.<locals>.<listcomp>rë r rZ r¨ r[ r , s
|
þz!MultiIndex._get_codes_for_sortingr zbool | list[bool]z'tuple[MultiIndex, npt.NDArray[np.intp]])r Ú ascendingÚsort_remainingri c
|
sR t |s|g}fdd|D }d}t|trbt|t|ksFtdtfdd|D |dn¶tj tjt fdd|D }tfd d|D }t |d
|
d D ]}
|
|¡
|
|¡ q®|rî||t 7 }||t 7 }n|d }t ||d d|sddd
t fddjD }t |jj|d d} | fS )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
|
|
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]))
|
c s g | ]} |¡qS rZ rÛ rÙ r rZ r[ r } s z(MultiIndex.sortlevel.<locals>.<listcomp>Nz(level must have same length as ascendingc s g | ]} j | qS rZ rë rÙ r rZ r[ r s )Zordersc 3 s | ]} | V qd S r© rZ rÙ rë rZ r[ r s z'MultiIndex.sortlevel.<locals>.<genexpr>c 3 s | ]} | V qd S r© rZ rÙ )rR rZ r[ r s T©Úreverser F)Úcompressr c s g | ]}| ¡qS rZ ry rX rY rZ r[ r ¦ s )rY r
rk rt rw )r2 rª r ry rz rG rY rè r« Úsortedrm rF r, rL r
rk )
|
rX r r© rª rt ZprimaryZprimshprÚ r rû rZ )rY rZ rX rR r[ Ú sortlevel@ sJ 9
|
ÿ
|
ÿ
|
|
|
ûzMultiIndex.sortlevel)Úpreserve_namesc C sh t |tsX|d kr| }n@|dk ¡ r0| |¡}n(zt |¡}W n tk
|
rV | Y S X | ||¡}|S rÑ )rª rL r° r" r¸ rl Ú_maybe_preserve_names)rX r rZ r° rZ rZ r[ Ú_wrap_reindex_result² s
|
|
z MultiIndex._wrap_reindex_result)r r° ri c C s4 |r0|j | j kr0|j| jkr0|jdd}| j|_|S )NFr÷ )r rk rv )rX r r° rZ rZ r[ r± Â s ÿ
|
þ
|
ý z MultiIndex._maybe_preserve_namesc C s t |rt|rt|d S r© )r/ r1 r# r rZ rZ r[ Ú_check_indexing_errorÏ s z MultiIndex._check_indexing_errorc C s | j d jS )zA
|
Should integer key(s) be treated as positional?
|
r )r
Ú _should_fallback_to_positionalr rZ rZ r[ r´ Ö s z)MultiIndex._should_fallback_to_positionalz"tuple[Index, npt.NDArray[np.intp]])Ú axis_nameri c s` |}t |tst |¡}t|rRt |d tsR| |¡}| |||¡ | | |fS t ||¡S rÑ )
|
rª r? r² r³ ry r« Ú_get_indexer_level_0Ú_raise_if_missingÚsuperÚ_get_indexer_strict)rX rþ rµ ÚkeyarrrZ ©Ú __class__rZ r[ r¹ Þ s
|
|
|
z MultiIndex._get_indexer_strictc s |}t |tst |¡}t|rt |d ts|dk}| ¡ r| jd |¡}|dk}| ¡ rpt || dt | dnt
|
|||¡S d S )Nr r z not in index) rª r? r² r³ ry r« r r
r rB r¸ r· )rX rþ rZ rµ rº r# ÚcheckZcmaskr» rZ r[ r· í s
|
|
z MultiIndex._raise_if_missingc C s4 | j d }| jd }tj||d}t|}| |¡S )z]
|
Optimized equivalent to `self.get_level_values(0).get_indexer_for(target)`.
|
r )rY Ú
|
categories)r
r r= r§ r? Úget_indexer_for)rX r rÚ rY ÚcatÚcirZ rZ r[ r¶
|
s
|
|
|
z MultiIndex._get_indexer_level_0z Hashable | Sequence[Hashable]zLiteral[('left', 'right')])r Úsideri c C s t |ts|f}| j||dS )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.
|
©r )rª r« Ú_partial_tup_index)rX r r rZ rZ r[ Úget_slice_bound
|
s 0
|
zMultiIndex.get_slice_boundztuple[int, int]c s 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.
|
)r¸ Ú
|
slice_locs)rX r2 Úendrr r» rZ r[ rÆ @
|
s 5zMultiIndex.slice_locsÚleftr« )r r c C sÎ t || jkr*tdt | d| j dt |}dt | }}t|| j| j}t|D ]n\}\}} }
|
|
|
||
} || krt|sztj | ||d} W n2 t
|
k
|
rÎ } zt
|
d| | W 5 d } ~ X Y nX t | sæt
|
d| |dkr| dkr| d8 } |tj | | |d S | | |¡}t |trN||d k rN|j}|j}qX||d k r|tj | |dd }|tj | |d d }qXt |tr°|j}|tj | ||d S |tj | ||d S qXd S )
|
Nú Key length (z-) was greater than MultiIndex lexsort depth (ú)r rà zLevel type mismatch: ÚrightrO rÈ )ry r r% r r
rY r r; r Ú searchsortedrl r0 Ú_get_loc_single_level_indexrª rq r2 r )rX r r Únr2 rÇ Zzippedr
rz rÚ r Úsectionr rD rå rZ rZ r[ rÄ w
|
sL ÿ " ÿ ÿ
|
z MultiIndex._partial_tup_indexr )Ú level_indexrþ ri c C s" t |rt|rdS | |¡S dS )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 N)r4 r; r )rX rÐ rþ rZ rZ r[ rÍ ©
|
s z&MultiIndex._get_loc_single_level_indexc
|
sð |¡ fdd}t|ts6 j|dd}||S t|} j|k r`td| d j d| jkr² jr²z j |¡W S t
|
k
|
r° |t t j¡\}}| Y S X j}|d|
||d
}}|säd} t }
|
nDz ||¡\} }
|
W n. t
|
k
|
r& } zt|| W 5 d} ~ X Y nX | |
|
kr:t||sJt| |
|
S tjd tt d
|
tj| |
|
tjd }t|t|D ]N\}} j| | j| | ¡k} | ¡ s¶|| }t|s|t|q|t||
|
| kræ||S t| |
|
S ) 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 sb t | tjr| jtjkr | S t | t ¡} t | tr:| S tj t dd}|
|
d¡ d|| < |S )z<convert integer indexer to boolean mask or slice if possibleru r® FT) rª rT r´ r r r Zmaybe_indices_to_slicery rq ÚemptyÚfill)r r# r rZ r[ Ú_maybe_to_sliceí
|
s
|
|
z+MultiIndex.get_loc.<locals>._maybe_to_slicer r rÉ z) exceeds index depth (rÊ Nz3indexing past lexsort depth may impact performance.r r® ) r³ rª r« Ú_get_level_indexerry r rB r ró r rl Ú get_loc_levelr r¢ r rÆ rq r r r$ r) rT ri r r rY rÍ r
r° )rX rþ rÓ r ZkeylenÚ_r Zlead_keyZ
|
follow_keyr2 r rD r
r# rZ r r[ r Â
|
sZ )
|
|
|
ÿ
|
|
|
|
ý ÿ
|
|
zMultiIndex.get_loc)r Ú
|
drop_levelc sn t |ttfs |¡}n fdd|D } j||d\}}|sft |¡r^ ||d
}n | }||fS )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)
|
c s g | ]} |¡qS rZ rÛ rÙ r rZ r[ r f s z,MultiIndex.get_loc_level.<locals>.<listcomp>r rO )rª r r« rÜ Ú_get_loc_levelr r0 )rX rþ r r× r r$ rZ r r[ rÕ : s )
|
zMultiIndex.get_loc_levelzint | list[int]r c
|
sÐ fdd}t |ttfrÌt t|kr2tdd}t| D ]V\}}j||d\}}t |trtj tt
|
d} d| |< | }|dkr|n||@ }q@z|||}
|
W n t k
|
r | }
|
Y nX ||
|
fS t trÞt t trF|dkrFz8 j d kr*j |d} || dg}| |fW S W n ttfk
|
rF Y nX td d
|
D sNt jkrÊjrÊzj ¡dfW S tk
|
r´ } zt | W 5 d} ~ X Y n tk
|
rÈ Y nX ¡} fd d tt D } t| jkr@t| r| dfS fd d tt D } t| jkr@g } | || | fS d} t D ]¬\}}t |tsÌj ||d}t |trÆt |¡sZt |t¡rªqZtj tt
|
d}d||< n|}n t |¡rÞqZntd | dkrü|} n| |M } qZ| dkr tdd} fdd tt D } | || | fS nj |d} t t rj | j rj | ¡}t|s| | fS z|| |g}W n t k
|
r | }Y nX | |fS dS )zX
|
get_loc_level but with `level` known to be positional, not name-based.
|
c s* | }t |ddD ]}| |g¡}q|S )z
|
If level does not exist or all levels were dropped, the exception
|
has to be handled outside.
|
Tr« )r® Ú_drop_level_numbers)rZ r
rû r r rZ r[ Úmaybe_mi_droplevelsv s z6MultiIndex._get_loc_level.<locals>.maybe_mi_droplevelsz:Key for location must have same length as number of levelsNr r® Tr c s s | ]}t |tV qd S r© )rª rq r rZ rZ r[ r © s z,MultiIndex._get_loc_level.<locals>.<genexpr>c s" g | ]} | t d d kr|qS r© ©rq r ro rZ r[ r · s z-MultiIndex._get_loc_level.<locals>.<listcomp>c s< g | ]4}t | tr"j| js | td d kr|qS r© )rª r r
Ú!_supports_partial_string_indexingrq r ©rþ rX rZ r[ r À s
|
úz'Expected label or tuple of labels, got c s" g | ]} | t d d kr|qS r© rÛ r ro rZ r[ r ð s ) rª r« r ry r! r rØ rq rT r± ru rz r
rÔ rl r# r r r ró r rB r¢ r0 r r² Ú is_null_sliceZ is_full_slicer rÜ )rX rþ r rÚ r rÚ r
r rû r# r$ rZ rD Zilevelsr Z loc_levelZk_indexr½ Z result_indexrZ rÝ r[ rØ p s¨ ÿ
|
|
|
|
|
þ ÿ
|
|
|
|
ÿ
|
þ
|
zMultiIndex._get_loc_levelz npt.NDArray[np.bool_] | None©r rZ c C sz | j | }| j| }||fdd}t|tr|j}|d k oB|dk }zt|jd k r^| |j¡} n|rpt|d } nd} |jd k r| |j¡}
|
n*|rd}
|
n t| trªt|}
|
n t|d }
|
W n2 t k
|
rê |
|
|j|j|j¡ } }
|
| j}Y nX t| tst|
|
tr(t | d| } t |
|
d|
|
}
|
|| |
|
|S |dksH| j dksH|d k rj|rV|
|
d n|
|
d }
|
|| |
|
|S t j|| dd} t j||
|
d d} t| | |S nÞ| ||¡} |dksº| j dkrt| trÞ|| jk|| jk @ }|S tj|| ktd
|
d }| ¡ st ||S t| tr:t j|| jdd} t j|| jdd}n t j|| dd} t j|| d d}| |krlt |t| |S d S ) Nc S sr |d k r|| }|d ks |dkr2|| k||k @ }n t j| |||jd}t ||¡}|d kr^|S | ¡ }|||< |S )NrO r® )rT ri r r r rv )r2 r rr rZ rY Ú new_indexerÚrrZ rZ r[ Úconvert_indexer s z6MultiIndex._get_level_indexer.<locals>.convert_indexerr rO r2 r rÈ rà rË F)r rv )r
rY rª rq rr r2 r ry r rB Z slice_indexerr r r rÌ rÍ rT r¦ ru r )rX rþ r rZ rÐ r râ rr Zis_negative_stepr2 r r r¡ rå ZlocsrÇ rZ rZ r[ rÔ sb
|
|
|
|
|
|
|
|
z MultiIndex._get_level_indexerc s: dd t t |¡D }|r@|d | jkr@td| d| j tdd |D rZtdt| d d
|
fd d }d }t |D ]\}}d }t |¡rºt| kr¬t dt
|
|¡}nt |r~z| j |||d}W n tttfk
|
r\ } z^|D ]T} t| s|| j | ||d}
|
|d kr,||
|
}qöt|
|
trBd||
|
< qö||
|
O }qöW 5 d }~X Y nX |d krÊt
|
jg t
|
jd S nLt |¡rº|d kr|t|d krt
|
j t
|
jd S qn| j |||d}||}|d krâ|}q||M }t
|
|¡st
|
|¡rt|q|d kr"t
|
jg t
|
jdS | ¡ d } | || ¡S )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)
|
c S s g | ]\}}|r|qS rZ rZ )r r ÚsrZ rZ r[ r s z'MultiIndex.get_locs.<locals>.<listcomp>r zIMultiIndex slicing requires the index to be lexsorted: slicing on levels z, lexsort depth c s s | ]}|t kV qd S r© )ÚEllipsisrç rZ rZ r[ r ¡ s z&MultiIndex.get_locs.<locals>.<genexpr>z2MultiIndex does not support indexing with EllipsisrO r c s* t | tr&tj tjd}d|| < |S | S )Nr® T)rª rq rT r± Úbool_)rZ rà ©rÎ rZ r[ Ú_to_bool_indexer¨ s
|
|
z-MultiIndex.get_locs.<locals>._to_bool_indexerNzLcannot index with a boolean indexer that is not the same length as the indexrß Tr® rO r )r r² Zis_true_slicesr r% r rT ry rp rz rT rµ r2 rÔ r# rl rB r/ rª rq r¦ r rÞ ri r Ú_reorder_indexer) rX ÚseqZ true_slicesrç rZ r r
Z lvl_indexerrD rÔ Z item_indexerZ pos_indexerrZ ræ r[ Úget_locsv sl $ÿÿ
|
ÿ
|
|
ÿ
|
|
|
|
|
|
|
zMultiIndex.get_locsz,tuple[Scalar | Iterable | AnyArrayLike, ...])ré rZ ri c C sD d}t |D ]¾\}}t |¡sÂt |¡sÂt|r2nt|rt|dkrHqÂ| ¡ r| j| |¡}||dk }|dd
|dd
k
|
¡ }qÂd}n2t |t r¾| ¡ r¸|j dk o´|j dk }qÂd}nd}|r qÌq |sÔ|S t| }d}t |D ]F\}}t|r|g}t |¡r t |¡| } nt|rt |¡}tjt| j| tjdt| j| }
|
| j| |¡} | | dk } t t| ¡|
|
| < |
|
| j| | } nt |t rÜ|j dk rÜ|j dk rÜt |¡ddd
| } nJt |t r|jdkr|jdkrtj|ftjd| } nt |¡| } | f| }qèt |¡} || 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
|
FrO r Nr TrZ r® )r r² rÞ rp r4 r2 ry rd r
r r rª rq rr rT ri r r\ Zonesrí rY r2 r r rL ) rX ré rZ Z need_sortr r
Zk_codesrÎ ÚkeysZ new_orderZ key_order_mapZ level_indexerÚindrZ rZ r[ rè û sZ
|
|
|
|
ÿ $$
|
zMultiIndex._reorder_indexerc s |r|r||k rt d| jd ||¡\}}| ||¡\ t| j}|d ||
|d< fdd| jD }|d | |d< t||| jddS )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 c s g | ]}|
qS rZ rZ rX ©rÈ rË rZ r[ r t s z'MultiIndex.truncate.<locals>.<listcomp>Fr} )rz r
rÆ r rY rL rs )rX ZbeforeÚafterr r¡ rß r rZ rí r[ ÚtruncateQ s
|
üzMultiIndex.truncatere )r ri c C sV | |¡rdS t|ts dS t| t|kr0dS t|tsV| |¡sHdS t| j|jS | j|jkrfdS t | jD ]à}| j
|
| }|j
|
| }|dk}|dk}t ||¡sª dS || }| j | j |¡}|| }|j | j |¡}t|dkrüt|dkrüqpt|t js | |¡sP dS qpt|t js@| |¡sP dS qpt||sp dS qpdS )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ª r? ry rL Z_should_comparer: r¶ r r¢ rY rT Z array_equalr
r" r´ Úequals) rX r r Z
|
self_codesZ other_codesZ self_maskZ
|
other_maskZ self_valuesZ other_valuesrZ rZ r[ rñ ~ sD
|
|
|
|
|
|
|
|
|
zMultiIndex.equalsc C s@ | j |j krdS t| j D ] }| j| |j| ¡s dS qdS )zT
|
Return True if the levels of both MultiIndex objects are the same
|
|
FT)r r¢ r
rñ )rX r r rZ rZ r[ Ú equal_levels¼ s zMultiIndex.equal_levelsc s¾ | |¡\}}|jrDt ||¡}t|tr0|S tjt| d |dS |j| dd}t |rf|
|
|¡}n
|
| |¡}|dk r¶z | ¡ }W n0 t k
|
r´ |dkr tjdtt d Y nX |S d S )Nr¯ F©rQ TzTThe values in the array are unorderable. Pass `sort=False` to suppress this warning.r )Ú_convert_can_do_setopZhas_duplicatesr¸ Ú_unionrª rL r§ r Ú
|
differencery rÉ Ú_get_reconciled_name_objectZ sort_valuesrl r r ÚRuntimeWarningr) )rX r rQ Ú result_namesr Z right_missingr» rZ r[ rõ Ì s4
|
ÿ
|
ü zMultiIndex._unionr )r ri c C s t |S r© )r3 rü rZ rZ r[ Ú_is_comparable_dtypeî s z MultiIndex._is_comparable_dtypec C s" | |¡}| j|kr | |¡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_namesrk Úrename)rX r rk rZ rZ r[ r÷ ñ s
|
|
|
z&MultiIndex._get_reconciled_name_objectc C sb t | jt |jkr$dgt | j S g }t| j|jD ]&\}}||krR| |¡ q6| d¡ q6|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)ry rk r rÉ )rX r rk Za_nameZb_namerZ rZ r[ rû ý s z MultiIndex._maybe_match_namesc C s | |¡\}}| |¡S r© )rô Ú set_names©rX r r rÖ rù rZ rZ r[ Ú_wrap_intersection_result s z$MultiIndex._wrap_intersection_result)r ri c C s6 | |¡\}}t|dkr(| ¡ |¡S | |¡S d S rÑ )rô ry rk rý rþ rZ rZ r[ Ú_wrap_difference_result s z"MultiIndex._wrap_difference_resultc
|
C s | j }t|tszt|dkr.| d d
| j fS d}ztj|| j d}W q ttfk
|
rv } zt||W 5 d }~X Y qX n
|
t| |}||fS )Nr z.other must be a MultiIndex or a list of tuplesr ) rk rª r? ry rL r¸ rz rl rB )rX r rù r rD rZ rZ r[ rô s
|
|
z MultiIndex._convert_can_do_setoprà c C s@ t |}t|r d}t|t|s,td|dkr<| ¡ S | S )Nz3> 1 ndim Categorical are not supported at this timezISetting a MultiIndex dtype to anything other than object is not supportedT)r5 r- rT r3 rl rØ )rX r rv r rZ rZ r[ rf / s ÿzMultiIndex.astypec C s^ t |tr$|j| jkr td|jS t |tsD|fd| jd }nt|| jkrZtd|S )Nz0Item must have length equal to number of levels.)r0 rO )rª rL r rz r¶ r« ry )rX ÚitemrZ rZ r[ Ú_validate_fill_value> s
|
|
z MultiIndex._validate_fill_value)rU ri c C s t | |\}}|r| ¡ S t|t|kr8|| ¡ }n| ¡ }g }g }tt|j| j| jD ]P\}\}} }
|
| j|dd} | |
|
|¡¡} t |
|
} | | |< | | ¡ | | ¡ q^t ||| jddS )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< rv ry rk r r r
rY Úunionr¿ r] r+ rÉ rL rk )rX r# rU ZnoopZsubsetrß r r Z value_levelr r Z new_levelZ value_codesZnew_coderZ rZ r[ ÚputmaskL s. ÿ
|
ÿzMultiIndex.putmask)r ri c C s | |¡}g }g }t|| j| jD ]T\}}}||krJt|}| ||¡}n
|
| |¡}| |¡ | t t |||¡¡ q"t
|
||| j ddS )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
rY ry Úinsertr rÉ rT r+ rL rk ) rX r r rß r r
r r Zlev_locrZ rZ r[ r t s
|
|
|
ÿzMultiIndex.insertc s( fdd| j D }t| j|| jddS )z}
|
Make new index with passed location deleted
|
|
Returns
|
-------
|
new_index : MultiIndex
|
c s g | ]}t | ¡qS rZ )rT r rX ©r rZ r[ r s z%MultiIndex.delete.<locals>.<listcomp>Fr} )rY rL r
rk )rX r r rZ r r[ r s üzMultiIndex.deletec C s¢ t |trt|}|d krbt|dkr<tjt| ftjdS t |tsPt |¡}| ¡
|
| ¡dkS | |¡}| |¡}|j dkrtjt|tjdS | |¡S d S )Nr r® r )rª r
|
r ry rT r± rå rL r¸ r\ r¿ rÜ r] rÓ r )rX rÊ r ÚnumZlevsrZ rZ r[ r § s
|
|
|
|
|
|
zMultiIndex.isinÚ__add__Ú__radd__Ú__iadd__Ú__sub__Ú__rsub__Ú__isub__Ú__pow__Ú__rpow__Ú__mul__Ú__rmul__Ú __floordiv__Ú __rfloordiv__Ú __truediv__Ú __rtruediv__Ú__mod__Ú__rmod__Ú
|
__divmod__Ú __rdivmod__Ú__neg__Ú__pos__Ú__abs__Ú
|
__invert__)NNNNNFNT)NN)NN)NN)NFN)N)N)F)F)NNNFr% NT)rN )NN)r )F)N)F)r TN)N)Nr )r )r r )r TT)NNN)rÈ )r T)r )r N)NN)T)N)r] r^ r_ r` r? Z _hidden_attrsÚ frozensetZ_typrs Ú__annotations__rC rÕ r Z _comparablesr{ r r Ú classmethodr r£ r§ rr r¸ r¼ rÀ r' r¶ ÚpropertyrÊ r¦ rÐ rÒ rÓ r
r} ræ r rè rY r~ rì ró rõ r( rö rØ rv rý rê r r r r r r r r r6 r< r rk r@ rÜ rF rM r r Z _duplicatedrV r[ rH r] r\ rb rc rd r rh rk rn rt rw r& r@ Ú_index_doc_kwargsr" rÉ rf 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ô rf r r r r r rý rü rD r r r
|
r r r r r r r r r r r r r r r r r r r Ú __classcell__rZ rZ r» r[ rL Ø sÀ
|
S ÷/>üF üOü<A
|
|
ù+ ÿ^
|
ù%A
|
! ü@ ÿ& ø M:ý 4 ü\ $ CX " û 1 ü<ÿ:. ür
|
57 2 x6 ÿq V->" (#
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
zlist[np.ndarray]r )rY r ri c C s> dd | D }t |ddD ] }t |d|
¡r| S qdS )zJCount depth (up to a maximum of `nlevels`) with which codes are lexsorted.c S s g | ] }t |qS rZ )r+ rX rZ rZ r[ r Ü s z"_lexsort_depth.<locals>.<listcomp>r r N)r¢ rI rJ )rY r Z int64_codesr
rZ rZ r[ r Ú s
|
|
r r0 re r1 c C sÊ t t| }t| }|d |d
}|| }||d d
D ]}g }tt||D ]d\} \}
|
} | |d kr| | ¡ | |¡ q¸|
|
| kr| |¡ qR| || d
¡ | |¡ q¸qR|}q<t t| S )NrO )r r ry r rÉ r8 ) Z
|
label_listr2 r3 Zpivotedr
r ÚprevÚcurZ
|
sparse_curr ÚpÚtrZ rZ r[ r9 ã s$
|
|
|
r9 r r c C s. t | r| j S | j} tjdtjdi | d¡S )NZNaTÚNaN)r. r rô rT Z
|
datetime64Z timedelta64Úgetr® rZ rZ r[ r5 ÿ s r5 r? )r ri c C sr | }t |trH|D ]2}z| dg¡} W q tk
|
rB | Y S X qn&z| dg¡} W n tk
|
rl Y nX | S )z¬
|
Attempt to drop level or levels from the given index.
|
|
Parameters
|
----------
|
index: Index
|
key : scalar or tuple
|
|
Returns
|
-------
|
Index
|
r )rª r« rÙ rz )r rþ Zoriginal_indexrÖ rZ rZ r[ Úmaybe_droplevels s
|
r* Fru rÁ )rv ri c C s" t | |} |r| ¡ } 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* rv r r )Z
|
array_liker¾ rv rZ rZ r[ ré ) s
|
|
ré )Úarrnamec C s | dk rZt | sZt |s&t| dt|dkrLt |d rLt| d| g} |g}n2| dksjt | rt |r~t |d st| d| |fS )zT
|
Ensure that level is either None or listlike, and arr is list-of-listlike.
|
Nz must be list-liker z must be list of lists-like)r2 rl ry )r r r+ rZ rZ r[ rä @ s rä )r r0 )F)Ú
|
__future__r Ú functoolsr Úsysr Útypingr r r r r
|
r r r r r r r r ÚnumpyrT Zpandas._configr Z pandas._libsr rI r ra r Zpandas._libs.hashtabler Zpandas._typingr r r r r r r r r r r! Zpandas.compat.numpyr" r~ Z pandas.errorsr# r$ r% Zpandas.util._decoratorsr& r' r( Zpandas.util._exceptionsr) Zpandas.core.dtypes.castr* Zpandas.core.dtypes.commonr+ r, r- r. r/ r0 r1 r2 r3 r4 r5 Zpandas.core.dtypes.dtypesr6 Zpandas.core.dtypes.genericr7 r8 r9 Zpandas.core.dtypes.missingr: r; Zpandas.core.algorithmsÚcoreZ
|
algorithmsZ pandas.core.array_algos.putmaskr< Zpandas.core.arraysr= Z pandas.core.arrays.categoricalr> Zpandas.core.commonÚcommonr² Zpandas.core.indexes.baseZindexesÚbaserl r? r@ rA rB Zpandas.core.indexes.frozenrC Zpandas.core.ops.invalidrD Zpandas.core.sortingrE rF rG Zpandas.io.formats.printingrH rÏ rI rJ rK Údictr" ÚupdateZBaseMultiIndexCodesEnginerb rN rg rd rr rL r r9 r5 r* ré rä rZ rZ rZ r[ Ú<module> s 8 4 4
|
ÿ') !
|
