3
���h"� � @ s� d dl mZ d dlmZmZmZmZmZmZm Z m
Z
m Z m Z d dl
Z
d dlZd dlmZ d dlmZmZmZ d dlmZ d dlmZm Z d dl m Z d d l m!Z!m"Z"m#Z# d d
l$m%Z%m&Z&m'Z' d d l(m)Z) d d l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4 d d
l5m6Z6 d dl7m8Z8m9Z9m:Z: d dl;m<Z<m=Z= d dl>j?j@Zd dlAmBZB d dlCmDZD d dlEj?jFZGd dlHj?jIjJZKd dlHmLZLmMZMmNZN d dlOmPZP d dlQmRZR d dlSj?jTZTd dlUmVZVmWZWmXZX d dlYmZZZm[Z[m\Z\ e�r�d dl]m^Z^ e_eKj`�Z`e`jae_ddd�� G dd � d ejbejc�ZdG d d � d ejbeje�ZfG d d� deL�Zgegjh� egji� egjj� d-ekd!�d"d#�Zlemd$�d%d&�Znd'd(� Zod.epejqd*�d+d,�ZrdS )/� )� getsizeof)
�
TYPE_CHECKING�Any�Callable�Hashable�Iterable�List�Optional�Sequence�Tuple�UnionN)�
get_option)�algos�index�lib)�duplicated_int64)� AnyArrayLike�Scalar)�function)�InvalidIndexError�PerformanceWarning�UnsortedIndexError)�Appender�cache_readonly�doc)�coerce_indexer_dtype)
� ensure_int64�ensure_platform_int�is_categorical_dtype� is_hashable�
is_integer� is_iterator� is_list_like�is_object_dtype� is_scalar� pandas_dtype)�ExtensionDtype)� ABCDataFrame�ABCDatetimeIndex�ABCTimedeltaIndex)�array_equivalent�isna)� Categorical)�factorize_from_iterables)�Index�_index_shared_docs� ensure_index)�
FrozenList)�
Int64Index)�get_group_index�indexer_from_factorized�lexsort_indexer)�format_object_attrs�format_object_summary� pprint_thing)�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 tjj|�S tjj|dd�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�codes� rF �;/tmp/pip-build-5_djhm0z/pandas/pandas/core/indexes/multi.py�_codes_to_intsR s
z#MultiIndexUIntEngine._codes_to_intsN)�__name__�
__module__� __qualname__�__doc__�libindex� UInt64Engine�_baserH rF rF rF rG r< J s r< 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 |j d�| j> }|jdkr&tjj|�S tjj|dd�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).
�objectr= )r> )�astyper? r@ rA rB rC )rD rE rF rF rG rH z s
z$MultiIndexPyIntEngine._codes_to_intsN)rI rJ rK rL rM � ObjectEnginerO rH rF rF rF rG rP q s rP c s� e Zd ZU dZeje� B ZdZe� Z e� Z
e� Z dgZ ej
ZdZee d�eed�dd �Zeed
�d d �Zd�ee ee d
�dd�Zedejfd d�dd��Zed�dd��Z edejfdd��Z ed�dd��Z e dd� �Z e dd � �Z!e d d � �Z"e d d � �Z#ed�d!d"�Z$e%d#d$� �Z&d�d%d&�Z'd�d'd(�Z(e ed�d)d*��Z)e d+d,� �Z*e d-d.� �Z+d�d/d0�Z,d�d1d2�Z-e%d3d4� �Z.e d5d6� �Z/e0ej1�dejddddejdfed7�d8d9��Z1d�d:d;�Z2�d d<d=�Z3�de4j5d�d>d?�Z6�dd@dA�Z7e0ej8�e9edB�dCdD��Z8e%e4j:d�dEdF��Z:ed�dGdH�Z;e0ej<��deedI�dJdK��Z<e%ed�dLdM��Z=�deedI�dNdO�Z>dPdQ� Z?�ddRdS�Z@dTdU� ZA�ddWdX�ZB�dee eeC eeD eeeedZ�d[d\�ZEd]d^� ZF�dd_d`�ZGe eGeFdadb�ZHe0ejI�dcdd� �ZIe%eDd�dedf��ZJed�dgdh�ZKe ed�didj��ZLe%ed�dkdl��ZMe%ed�dmdn��ZNe%dodp� �ZOe0ejP��d drds��ZP�d
dtdu�ZQe0ejR��d dwdx��ZR�d dydz�ZSd{d|� ZTe0ejU��d
� fd}d~� �ZUdd�� ZV�dd�d��ZWd�d�� ZXe ed�d�d���ZYed�d�d��ZZe%d�d�� �Z[ed�d�d��Z\d�d�� Z]d�d�� Z^d�d�� Z_d�d�� Z`eaebd� ec ��dd�d���Zd�dd�d��Zed�d�� Zfe4j5d�d�d��Zgeaebd� ec ��dd�d���Zh�dd�d��Zi�dd�d��Zj�dd�d��Zk�dd�d��Zld�d�� Zmd�d�� Zn�dd�d��Zo�dd�d��Zpd�d�� Zqed�d�d��Zrd�d��d�d��Zs� fd�d��Ztd�d�� Zueaebd� ec ��dd�d�Zveaebd� ec �� fd�dń�Zwexeyezey f eDeDedƜd�dȄZ{�d� fd�dʄ Z|�d d�d̈́Z}eeyedΜd�dЄZ~�d d�d҄Z�d edӜd�dՄZ��d d�dׄZ�d�dل Z�e�exe�e�e�f d�f e�e�dۜd�d݄Z��d d�d߄Z�ed�d�d�Z�ed�d�d�Z��d!d�d�Z��d"d�d�Z��d#d�d�Z�d�d� Z�e0ej���d$d�d��Z�ed�d�d�Z�d�d� Z�d�d� Z�e0ej���d%d�d���Z�� Z�S (& r: 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.
.. versionadded:: 0.24.0
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
Methods
-------
from_arrays
from_tuples
from_product
from_frame
set_levels
set_codes
to_frame
to_flat_index
is_lexsorted
sortlevel
droplevel
swaplevel
reorder_levels
remove_unused_levels
get_locs
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
multiindex�namesNFT)�verify_integrity�
_set_identityc
C s� |d k r |}|d ks |d kr$t d��t|�t|�kr<td��t|�dkrPtd��tjt�}
i |
_|
j||dd� |
j||dd� d gt|� |
_ |d k r�|
j
|� |d k r�t |�|
_ n||
_ |r�|
j
� } | |
_| r�|
j� |
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)� TypeError�len�
ValueErrorrQ �__new__r: �_cache� _set_levels�
_set_codes�_names�
_set_names�int� sortorder�_verify_integrity�_codes�_reset_identity) �cls�levelsrE rc rT �dtyperW �namerU rV �result� new_codesrF rF rG r\ � s0
zMultiIndex.__new__)�level�codec C s( t |�}tj|�r$tj|| 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= ���)r+ rA �any�where)rD rm rn Z null_maskrF rF rG �_validate_codes, s
zMultiIndex._validate_codes)rE rh c s^ |p� j }|p� j}t|�t|�kr,td��t|d �}x�tt||��D ]�\}\}}t|�|krxtddd� |D �� ���t|�r�|j� t|�kr�td|� d|j� � dt|�� d ���t|�r�|j� dk r�td|� d |j� � d ���|jsHtd
t |�� d|� ���qHW � j
dk �r:� j
� j � k�r:td� j
� d� j � � ���� fdd�t||�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 rF )rZ )�.0Zcode_rF rF rG �
<listcomp>e 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 | ]\}}� j ||��qS rF )rr )rs rm rn )rD rF rG rt | s ro )
rE rh rZ r[ � enumerate�zip�max�min� is_unique�listrc �_lexsort_depthr1 )rD rE rh Z codes_length�irm � level_codesrl rF )rD rG rd A s2
" z MultiIndex._verify_integrity)�returnc C s� d}t |�st|��nt|�r&t|�}x |D ]}t |�s,t|��q,W x:tdt|��D ](}t|| �t||d �krTtd��qTW t|�\}}|tj kr�dd� |D �}t
||||dd�S )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.r= z all arrays must be same lengthc S s g | ]}t |d d��qS )rj N)�getattr)rs ZarrrF rF rG rt � s z*MultiIndex.from_arrays.<locals>.<listcomp>F)rh rE rc rT rU ) r" rY r! rz �rangerZ r[ r- r �
no_defaultr: ) rg �arraysrc rT Z error_msg�arrayr| rE rh rF rF rG � from_arrays� s( %
zMultiIndex.from_arraysc C s� t |�std��nt|�r"t|�}t|�dkrN|dkr>td��g gt|� }nVt|tjtf�r�t|t�rn|j }tt
j |�j �}n$t|t�r�tt
j
|�j �}nt|� }tj|||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.r Nz-Cannot infer number of levels from empty list)rc rT )r" rY r! rz rZ �
isinstancerA �ndarrayr. �_valuesr Ztuples_to_object_array�TZto_object_array_tuplesrv r: r� )rg Ztuplesrc rT r� rF rF rG � from_tuples� s %
zMultiIndex.from_tuplesc C sj ddl m} t|�s td��nt|�r.t|�}t|�\}}|tjkrRdd� |D �}||�}t ||||d�S )a�
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.
.. versionchanged:: 1.0.0
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 d��qS )rj N)r )rs �itrF rF rG rt 2 s z+MultiIndex.from_product.<locals>.<listcomp>)rc rT )
Zpandas.core.reshape.utilr� r" rY r! rz r- r r� r: )rg � iterablesrc rT r� rE rh rF rF rG � from_product� s ,
zMultiIndex.from_productc C sB t |t�std��t|j� � \}}|dkr.|n|}| j|||d�S )am
Make a MultiIndex from a DataFrame.
.. versionadded:: 0.24.0
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 DataFrameN)rc rT )r� r' rY rv �itemsr� )rg Zdfrc rT Z column_names�columnsrF rF rG �
from_frame8 s
;
zMultiIndex.from_framec C s | j S )N)�values)rD rF rF rG r� | s zMultiIndex._valuesc C s� | j d k r| j S g }xjt| j�D ]\}| j|�}t|j�r@|j� }t|jt�sZt|t t
f�rd|j t �}t
j|dd�}|j|� q W tj|�| _ | j S )NF)rW )�_tuplesr� �nlevels�_get_level_valuesr ri Z_internal_get_valuesr� r& r( r) rR rQ rA r� �appendr Zfast_zip)rD r� r| �valsrF rF rG r� � s
zMultiIndex.valuesc C s t d��dS )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)r[ )rD rF rF rG r� � s
zMultiIndex.arrayc C s
t | �fS )zE
Return a tuple of the shape of the underlying data.
)rZ )rD rF rF rG �shape� s zMultiIndex.shapec C s t | jd �S )Nr )rZ rE )rD rF rF rG �__len__� s zMultiIndex.__len__c C s4 dd� t | j| j�D �}x|D ]
}d|_q W t|�S )Nc S s g | ]\}}|j |d ��qS ))rj )�
_shallow_copy)rs �xrj rF rF rG rt � s z%MultiIndex.levels.<locals>.<listcomp>T)rv �_levelsr` Z_no_setting_namer1 )rD rk rm rF rF rG rh � s
zMultiIndex.levelsc s |rVt |�dkrtd��|d kr6t |��jkr6td��|d k rVt |�t |�krVtd��|d krvt� fdd�|D ��}nP�fdd�|D �}t�j�}x*t||�D ] \}} t| � d �j� ||< q�W t|�}|r܈j |d
�}
|
�_
�j } |�_t | �r��j
| � d �_�j� 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 �j� V qdS ))rW N)r0 r� )rs �lev)rW rF rG � <genexpr>� s z)MultiIndex._set_levels.<locals>.<genexpr>c s g | ]}� j |��qS rF )�_get_level_number)rs r� )rD rF rG rt � s z*MultiIndex._set_levels.<locals>.<listcomp>)rW )rh )rZ r[ r� r1 rz r� rv r0 r� rd re rT rp ra r� � _reset_cache) rD rh rm rW rX rU �
new_levels�
level_numbers�lev_numr� rl rT rF )rW rD rG r^ � s0
zMultiIndex._set_levelsc C s� t |�r t|t� r t|�}|dk r`t |� r`t |�s>td��t |d �rRtd��|g}|g}n0|dkspt |�r�t |� s�t |d � r�td��|r�| }n| j� }|j� |j||d|d� |s�|S dS )aE
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).
inplace : bool
If True, mutates in place.
verify_integrity : bool, default True
If True, checks that levels and codes are compatible.
Returns
-------
new index (of same type and class...etc)
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]])
NzLevels must be list-liker z!Levels must be list of lists-likeT)rm rX rU )r" r� r. rz rY r� rf r^ )rD rh rm �inplacerU �idxrF rF rG �
set_levels� s( R zMultiIndex.set_levelsc C s
t | j�S )z>
Integer number of levels in this MultiIndex.
)rZ r� )rD rF rF rG r� Q s zMultiIndex.nlevelsc C s t dd� | jD ��S )z8
A tuple with the length of each level.
c s s | ]}t |�V qd S )N)rZ )rs r� rF rF rG r� ] s z&MultiIndex.levshape.<locals>.<genexpr>)�tuplerh )rD rF rF rG �levshapeX s zMultiIndex.levshapec C s | j S )N)re )rD rF rF rG rE b s zMultiIndex.codesc s� |rB|d kr"t |��jkr"td��|d k rBt |�t |�krBtd��|d krjt� fdd�t�j|�D ��}nX�fdd�|D �}t�j�}x2t||�D ]$\}} �j| }
t | |
� d�||< q�W t|�}|r҈j
|d�}|�_d �_ �j � d S ) Nz+Length of codes must match number of levelsz,Length of codes must match length of levels.c 3 s$ | ] \}}t ||� d �j� V qdS ))rW N)�_coerce_indexer_frozen�view)rs r� r} )rW rF rG r� q s z(MultiIndex._set_codes.<locals>.<genexpr>c s g | ]}� j |��qS rF )r� )rs r� )rD rF rG rt u s z)MultiIndex._set_codes.<locals>.<listcomp>)rW )rE )
rZ r� r[ r1 rv r� rz re rh r� rd r� r� ) rD rE rm rW rX rU rl r� r� r} r� rF )rW rD rG r_ f s(
zMultiIndex._set_codesc C s� |dk rDt |� rDt |�s"td��t |d �r6td��|g}|g}n0|dksTt |�rtt |� slt |d � rttd��|r~| }n| j� }|j� |j|||d� |s�|S dS )a}
Set new codes on MultiIndex. Defaults to returning new index.
.. versionadded:: 0.24.0
New name for deprecated method `set_labels`.
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).
inplace : bool
If True, mutates in place.
verify_integrity : bool (default True)
If True, checks that levels and codes are compatible.
Returns
-------
new index (of same type and class...etc)
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'])
NzCodes must be list-liker z Codes must be list of lists-like)rm rU )r" rY r� rf r_ )rD rE rm r� rU r� rF rF rG � set_codes� s" < zMultiIndex.set_codesc C s� t jt jdd� | jD ���}t j|d d d� �d d d� }t j|dd � dgg�jd�}|d dkrtt| j| j|�S t | j| j|�S ) Nc S s g | ]}t |�d �qS )r= )rZ )rs �lrF rF rG rt � s z&MultiIndex._engine.<locals>.<listcomp>r= r �uint64�@ ro ro )
rA �ceil�log2rh Zcumsum� concatenaterR rP rE r< )rD �sizesZlev_bitsr? rF rF rG �_engine� s zMultiIndex._enginec C s t jS )N)r: r� )rD rF rF rG � _constructor� s zMultiIndex._constructor)rV c
C s� |t jk r |t jk r td��n |t jkr<|t jk r6|n| j}|d k rp|d kr\|d kr\|d ks`t�tj|||d�S |d k r||n| j}|d k r�|n| j}t|||||d|d�} | j j
� | _ | j j dd � | S )Nz*Can only provide one of `names` and `name`)rc rT F)rh rE ri rc rT rU rV rh ) r r� rY rT �AssertionErrorr: r� rh rE r] rW �pop)
rD r� rj rh rE ri rc rT rV rk rF rF rG r� � s(
zMultiIndex._shallow_copyc C s` t j| |||�}t|�dkrLtdd� t| j�D �dd� t| j�D �|jd�S t| �j||jd�S )Nr c S s g | ]}g �qS rF rF )rs �_rF rF rG rt s z3MultiIndex.symmetric_difference.<locals>.<listcomp>c S s g | ]}g �qS rF rF )rs r� rF rF rG rt s )rh rE rT )rT ) r. �symmetric_differencerZ r: r� r� rj �typer� )rD �otherZ result_name�sortZtupsrF rF rG r� s
z MultiIndex.symmetric_differencec C s\ | j |||d�}|rDddlm} |dkr2|| j�}|dkrD|| j�}| j||||| j|d�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
dtype : numpy dtype or pandas type, optional
levels : sequence, optional
codes : 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.
)rj rT �deepr )�deepcopyN)rh rE rT ri rc rV )Z_validate_namesrW r� rh rE r� rc ) rD rT ri rh rE r� rj rV r� rF rF rG rW $ s "
zMultiIndex.copyc C s | j S )z' the array interface, return my values )r� )rD ri rF rF rG � __array__X s zMultiIndex.__array__c C s | j � }| j|_|S )z2 this is defined as a copy with the same identity )rW �_id)rD rg rk rF rF rG r� \ s zMultiIndex.view)�keyr~ c
C s6 t |� y| j|� dS tttfk
r0 dS X d S )NTF)�hash�get_loc� LookupErrorrY r[ )rD r� rF rF rG � __contains__b s
zMultiIndex.__contains__c C s
t jd�S )N�O)rA ri )rD rF rF rG ri k s zMultiIndex.dtypec s dd� � t � fdd�| jD ��S )z7 return a boolean if we need a qualified .info display c S s d| kpd| kpd| kS )N�mixed�string�unicoderF )r� rF rF rG �fr s z0MultiIndex._is_memory_usage_qualified.<locals>.fc 3 s | ]}� |�V qd S )NrF )rs r� )r� rF rG r� u s z8MultiIndex._is_memory_usage_qualified.<locals>.<genexpr>)rp �_inferred_type_levels)rD rF )r� rG �_is_memory_usage_qualifiedo s z%MultiIndex._is_memory_usage_qualified)r� r~ c C s
| j |�S )N)�_nbytes)rD r� rF rF rG � memory_usagew s zMultiIndex.memory_usagec C s
| j d�S )z3 return the number of bytes in the underlying data F)r� )rD rF rF rG �nbytes~ s zMultiIndex.nbytesc sj d�t � fdd�| jD ��}t dd� | jD ��}t �fdd�| jD ��}|| | }|| jj� d�7 }|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� )rs r| )r� rF rG r� � s z%MultiIndex._nbytes.<locals>.<genexpr>c s s | ] }|j V qd S )N)r� )rs r| rF rF rG r� � s c 3 s | ]}t |� �V qd S )N)r )rs r| )�objsizerF rG r� � s )r� )�sumrh rE rT r� �sizeof)rD r� Z level_nbytesZ label_nbytesZ names_nbytesrk rF )r� r� rG 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 rF )�_formatter_func)rs rm rF rF rG rt � s z.MultiIndex._formatter_func.<locals>.<listcomp>c s s | ]\}}||�V qd S )NrF )rs �func�valrF rF rG r� � s z-MultiIndex._formatter_func.<locals>.<genexpr>)rh r� rv )rD �tupZformatter_funcsrF rF rG r� � s zMultiIndex._formatter_funcc C s t | | j|dd�S )z?
Return the formatted data as a unicode string
T)rj Zline_break_each_value)r7 r� )rD rj rF rF rG � _format_data� s zMultiIndex._format_datac C s t | dd�S )zH
Return a list of tuples of the (attr,formatted_value).
F)Z
include_dtype)r6 )rD rF rF rG �
_format_attrs� s zMultiIndex._format_attrs�nanc
K s� g }g }x�t | j| j�D ]r\}}|jf d|i|��}|dk}|j� rvt|�}tj||�}|jj sft
�|j � }|||< |j|� |j|� qW t|�dkr�t |d j
|d ��j� S t||| j| jdd�} | jS d S )N�na_repr= r F)rh rE rT rc rU ro )rv rh rE �_format_native_typesrp rZ rA r� �flags� writeabler� rW r. �taker: rT rc r� )
rD r� �kwargsr� rl rm r} �maskZ nan_index�mirF rF rG r� � s,
z MultiIndex._format_native_types� )rj � formatterr� rT �space�adjoinr~ c s� |d k r |}t | �dkr g S g }x�t| j| j�D ]�\} }
|d k rD|n
t| jj�� t | �dkr�| j|
�j|d�} |
dk} | j � r�t
j | t d�} � | | < | j
� } n � fdd�tj| j|
�D �} |j| � q0W g }
x`t|| j�D ]P\} }g }|�r |j|d k �rt|dd
�nd � |jt
j | t d�� |
j|� q�W |d k�r@td �}|�r�d }t|t��sf|tjk�sft�|d
tjgk�rz|}t|
t |�|d�}
|�r�ddl m } |� }|j |f|
�� j d �S |
S d S )Nr )r� r= )ri c s$ g | ] }t t|�r� n|dd��qS )� �
�
)� escape_chars)r� r� r� )r8 r+ )rs r� )�narF rG rt � s z%MultiIndex.format.<locals>.<listcomp>r� r� r� )r� � zdisplay.multi_sparseF)�start�sentinel)�_get_adjustmentro )r� r� r� )!rZ rv rh rE � _get_na_repri r� r� �formatrp rA r� rQ �tolistr �take_1dr� r� rT r8 �extendr
r� �boolr r� r� � _sparsifyrb Zpandas.io.formats.formatr� r� �split)rD rj r� r� rT r� Zsparsifyr� Zstringified_levelsr� r} � formattedr� Z
result_levelsZlev_namerm r� r� ZadjrF )r� rG r� � sP
zMultiIndex.formatc C s
t | j�S )N)r1 r` )rD rF rF rG �
_get_names s zMultiIndex._get_namesc s� |dk rt |� rtd��t|�}|rd|dk rFt|�t|�krFtd��|dkrdt|�� jkrdtd��|dkrxt� j�}n� fdd�|D �}xDt||�D ]6\}}|dk r�t|�s�tt � �j
� d���|� j |< q�W � j � 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 : boolean, 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 | ]}� j |��qS rF )r� )rs r� )rD rF rG rt L s z)MultiIndex._set_names.<locals>.<listcomp>z .name must be a hashable type)
r" r[ rz rZ r� r� rv r rY r� rI r` r� )rD rT rm rX r� rj rF )rD rG ra " s& zMultiIndex._set_namesz
Names of levels in MultiIndex.
)�fset�fgetr c C s� | j | }| j| }|d k r@| j| j|�}|j|�}|d d fS tj|dd�\}}t|�dkr�|d dkr�|dk} tj|| dd�\}
}tjt|�|j d�}|
|| < d || < t|�t|�k r�|j|�}n|j
� }|j r�|j|dd�}n
|j|�}|||fS )
NT)r� r r= )ri )�
fill_valuero ro ro ) rE rh r� �mapr Z factorizerZ rA �emptyri rW Z _can_hold_na) rD �mapperrm �indexer� level_indexZ level_valuesZgrouperrE �uniquesr� Zok_codesrF rF rG �_get_grouper_for_levelb s(
z!MultiIndex._get_grouper_for_levelc C s dS )Nr� rF )rD rF rF rG �
inferred_type� s zMultiIndex.inferred_typec C s� | j j|�}|dkr.t|� r.td|� d���y| j j|�}W n� tk
r� } z�t|�sltd|� d��|�nf|dk r�|| j7 }|dk r�|| j }td| j� d|� d ��|�n&|| jkr�td| j� d
|d � ��|�W Y d d }~X nX |S ) Nr= 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)rD rm r �errZ
orig_levelrF rF rG r� � s*
z MultiIndex._get_level_numberc C s dS )NTrF )rD rF rF rG �_has_complex_internals� s z!MultiIndex._has_complex_internalsc s� t dd� � jD ��rdS tdd� � jD ��rBtjdd� � jD ��S � fdd�ttt� j���D �}yt j
|�}t |�j S t
k
r� t � j�j S X dS ) zh
return if the index is monotonic increasing (only equal or
increasing) values.
c s s | ]}d|kV qdS )r= Nro rF )rs rn rF rF rG r� � s z5MultiIndex.is_monotonic_increasing.<locals>.<genexpr>Fc s s | ] }|j V qd S )N)� is_monotonic)rs rm rF rF rG r� � s c S s g | ]}|j d dd��qS )�int64F)rW )rR )rs r� rF rF rG rt � s z6MultiIndex.is_monotonic_increasing.<locals>.<listcomp>c s g | ]}� j |�j�qS rF )r� r� )rs r| )rD rF rG rt � s N)rp rE �allrh �libalgos� is_lexsorted�reversedr� rZ rA �lexsortr. r rY r� )rD r� Z
sort_orderrF )rD rG �is_monotonic_increasing� s
z"MultiIndex.is_monotonic_increasingc C s | ddd� j S )zh
return if the index is monotonic decreasing (only equal or
decreasing) values.
Nr= ro )r )rD rF rF rG �is_monotonic_decreasing� s z"MultiIndex.is_monotonic_decreasingc C s dd� | j D �S )z9 return a list of the inferred types, one for each level c S s g | ]
}|j �qS rF )r )rs r| rF rF rG rt � s z4MultiIndex._inferred_type_levels.<locals>.<listcomp>)rh )rD rF rF rG r� � s z MultiIndex._inferred_type_levels�firstc C s( t t| j�}t| j|ddd�}t||�S )NF)r� Zxnull)r� rZ rh r3 rE r )rD Zkeepr� �idsrF rF rG �
duplicated� s zMultiIndex.duplicatedc C s t d��dS )z:
fillna is not implemented for MultiIndex
z"isna is not defined for MultiIndexN)�NotImplementedError)rD �valueZdowncastrF rF rG �fillna� s zMultiIndex.fillnarp c sp dd� | j D �}|dkr(tj|dd�� n&|dkr@tj|dd�� ntd|� ���� fdd�| j D �}| j|d d
�S ) Nc S s g | ] }|dk�qS )r= ro rF )rs r} rF rF rG rt � s z%MultiIndex.dropna.<locals>.<listcomp>rp r )r> r
zinvalid how option: c s g | ]}|� �qS rF rF )rs r} )r� rF rG rt � s T)rE r� )rE rA rp r
r[ rW )rD �howZnansrl rF )r� rG �dropna� s zMultiIndex.dropnac C sN | j | }| j| }| j| }|r,tj|�}tj|j||jd�}|j||d�S )aa
Return vector of label values for requested level,
equal to the length of the index
**this is an internal method**
Parameters
----------
level : int level
unique : bool, default False
if True, drop duplicated values
Returns
-------
values : ndarray
)r� )rj ) rh rE r` r �uniquer� r� Z _na_valuer� )rD rm r r� r} rj ZfilledrF rF rG r� � s
z MultiIndex._get_level_valuesc C s | 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
-------
values : Index
Values is a level of this MultiIndex converted to
a single :class:`Index` (or subclass thereof).
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')
)r� r� )rD rm r� rF rF rG �get_level_values s
zMultiIndex.get_level_valuesc s. |d krt � j� S | j|�}| j|dd�S d S )NT)rm r )�superr r� r� )rD rm )� __class__rF rG r + s
zMultiIndex.uniquec C s | j dd� | jD ��S )z+ convert to object if we are a categorical c S s g | ] }|j � �qS rF )�_to_safe_for_reshape)rs r| rF rF rG rt 6 s z3MultiIndex._to_safe_for_reshape.<locals>.<listcomp>)r� rh )rD rF rF rG r 4 s z MultiIndex._to_safe_for_reshapec s� ddl m} |dk rDt|�s$td��t|�t� j�kr>td��|}n� j}|� fdd�t|t t� j���D �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.
.. versionadded:: 0.24.0
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.
Returns
-------
DataFrame : a DataFrame containing the original MultiIndex data.
See Also
--------
DataFrame : Two-dimensional, size-mutable, potentially heterogeneous
tabular data.
r )� DataFrameNz1'name' must be a list / sequence of column names.z<'name' should have same length as number of levels on index.c s( i | ] \}}� j |�|d kr |n|�qS )N)r� )rs Zlvlnamerm )rD rF rG �
<dictcomp>b s z'MultiIndex.to_frame.<locals>.<dictcomp>F)rW ) �pandasr r" rY rZ rh r[ rT rv r� r )rD r rj r Z idx_namesrk rF )rD rG �to_frame8 s
zMultiIndex.to_framec C s t | jdd�S )a�
Convert a MultiIndex to an Index of Tuples containing the level values.
.. versionadded:: 0.24.0
Returns
-------
pd.Index
Index with the MultiIndex data represented in Tuples.
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� )rD rF rF rG �
to_flat_indexm s zMultiIndex.to_flat_indexc C s dS )NFrF )rD rF rF rG � is_all_dates� s zMultiIndex.is_all_datesc 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
)�
lexsort_depthr� )rD rF rF rG r � s zMultiIndex.is_lexsortedc C s | j d k r| j S | j� S )N)rc r{ )rD rF rF rG r$ � s
zMultiIndex.lexsort_depthc C sB dd� | j D �}x,t| jdd�D ]}tj|d|� �r |S q W dS )z�
Compute and return the lexsort_depth, the number of levels of the
MultiIndex that are sorted lexically
Returns
-------
int
c S s g | ] }t |��qS rF )r )rs r} rF rF rG rt � s z-MultiIndex._lexsort_depth.<locals>.<listcomp>r r= Nro )rE r� r� r r )rD Z int64_codes�krF rF rG r{ � s
zMultiIndex._lexsort_depthc
C s� | j � r| jr| S g }g }x�t| j| j�D ]r\}}|js�y |j� }W n tk
rX Y n0X |j|�}t|�}t j
|t |��}t j
||�}|j|� |j|� q*W t||| j| jdd�S )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)rT rc rU )r r rv rh rE �argsortrY r� r r Zget_reverse_indexerrZ r r� r� r: rT rc )rD r� rl r� r} r� �rirF rF rG �_sort_levels_monotonic� s, "
z!MultiIndex._sort_levels_monotonicc C sB g }g }d}� x�t | j| j�D ]�\}}tjtj|d �dk�d d }tt|�oZ|d dk�}t|�t|�| kr�d}tj |�}|r�tj|dk�d }||d dg |d|d g< tj
t|�| �} tj t|��| | |< | | }|j ||d� �}|j
|� |j
|� q W | j� }
|�r>|
j� |
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']])
Fr= r TN)rX ro ro )rv rh rE rA rq Zbincountrb rZ r r �zeros�aranger� r� r� rf r^ r_ ) rD r� rl �changedr� r} r Zhas_naZna_idxZ code_mappingrk rF rF rG �remove_unused_levels s0 #
z MultiIndex.remove_unused_levelsc C s8 t t| j�t| j�| jt| j�d�}tjt| �|fdfS )z*Necessary for making this object picklable)rh rE rc rT N) �dictrz rh rE rc rT �ibaseZ
_new_Indexr� )rD �drF rF rG �
__reduce___ s zMultiIndex.__reduce__c s� t � �rjtj� dd�� g }xFt| j| j�D ]4\}}|� d krL|jtj� q*|j||� � q*W t |�S tj
� �r�tj � t d�� | j
}nd }t� t�r�tj � �� � fdd�| jD �}t| j|| j|dd�S d S )
NT)Z
warn_floatr= )ri c s g | ] }|� �qS rF rF )rs r} )r� rF rG rt � s z*MultiIndex.__getitem__.<locals>.<listcomp>F)rh rE rT rc rU ro )r$ �comZcast_scalar_indexerrv rh rE r� rA r� r� �is_bool_indexer�asarrayr� rc r� r. r: rT )rD r� �retvalr� r} rc rl rF )r� rG � __getitem__k s*
zMultiIndex.__getitem__r� r c K s@ t jt� |� t|�}| j| j|||dd�}t| j|| jdd�S )Nr= )�
allow_fillr� �na_valueF)rh rE rT rU ro ) �nvZ
validate_taker� r �_assert_take_fillablerE r: rh rT )rD �indicesr> r6 r� r� �takenrF rF rG r� � s zMultiIndex.takec s� |r||dk r|� dk j � r$d}t|��� fdd�| jD �}� dk}|j � r�g } x(|D ] }
|
} || |< | jtj| �� qRW | }n� fdd�| jD �}|S ) z. Internal method to handle NA filling of take Nr= zJWhen allow_fill=True and fill_value is not None, all indices must be >= -1c s g | ]}|j � ��qS rF )r� )rs �lab)r: rF rG rt � s z4MultiIndex._assert_take_fillable.<locals>.<listcomp>c s g | ]}|j � ��qS rF )r� )rs r< )r: rF rG rt � s ro ro )rp r[ rE r� rA r3 ) rD r� r: r6 r� r7 �msgr; r� ZmaskedZ new_labelZ label_valuesrF )r: rG r9 � s
z MultiIndex._assert_take_fillablec s� t |ttf�s|g}t�fdd�|D ��r~g }x>t�j�D ]0� �j� �}� fdd�|D �}|j|j|�� q:W tj |�j
d�S �j ftdd� |D �� }t j
|�}ytj|�j
d�S ttfk
r� t|�S X dS )z�
Append a collection of Index options together
Parameters
----------
other : Index or list/tuple of indices
Returns
-------
appended : Index
c 3 s$ | ] }t |t�o|j� jkV qd S )N)r� r: r� )rs �o)rD rF rG r� � s z$MultiIndex.append.<locals>.<genexpr>c s g | ]}|j � ��qS rF )r� )rs r> )r| rF rG rt � s z%MultiIndex.append.<locals>.<listcomp>)rT c s s | ] }|j V qd S )N)r� )rs r% rF rF rG r� � s N)r� rz r� r
r� r� r� r� r: r� rT r� rA r� r� rY r r. )rD r� r� �labelZappendedZ to_concatZ
new_tuplesrF )r| rD rG r� � s
zMultiIndex.appendc O s | j j||�S )N)r� r& )rD �argsr� rF rF rG r& � s zMultiIndex.argsort�repeatc sD t jt� t|d�� t� �� t| j� fdd�| jD �| j| j dd�S )N)r> c s& g | ] }|j tj�jtj�j� ��qS rF )r� rA r� rR �intprA )rs r} )�repeatsrF rG rt � s z%MultiIndex.repeat.<locals>.<listcomp>F)rh rE rT rc rU )
r8 Zvalidate_repeatr� r- r r: rh rE rT rc )rD rC r> rF )rC rG rA � s
zMultiIndex.repeatc C s t d��d S )Nz1.where is not supported for MultiIndex operations)r )rD Zcondr� rF rF rG rq � s zMultiIndex.where�raisec C s$ |dk r| j |||�S t|tjtf�sNytj|td�}W n tk
rL Y nX g }x�|D ]�}y�| j |�}t|t
�r~|j |� nrt|t �r�|j
t|j|j�� nRtj|�r�| jdkr�tjdtdd� |j� d }|j
|� ndt|�� �}t|��W qX tk
�r |dk�r� Y qXX qXW | j|�S ) aB
Make new MultiIndex with passed list of codes deleted
Parameters
----------
codes : array-like
Must be a list of tuples
level : int or level name, default None
errors : str, default 'raise'
Returns
-------
dropped : MultiIndex
N)ri r zYdropping on a non-lexsorted multi-index without a level parameter may impact performance.� )�
stacklevelz unsupported indexer of type �ignore)�_drop_from_levelr� rA r� r. r1 �index_labels_to_arrayrQ r[ r� rb r� �slicer� r� r� �stopr2 r$ �warnings�warnr �nonzeror� r� r �delete)rD rE rm �errorsZindsr} �locr= rF rF rG �drop� s:
zMultiIndex.dropc C sd t j|�}| j|�}| j| }|j|�}tj| j| |� }|j� r\|dkr\t d|� d���| | S )NrG zlabels z not found in level)
r1 rI r� rh � get_indexerr �isinrE r
r )rD rE rm rP r| r r� r� rF rF rG rH s
zMultiIndex._drop_from_levelr= c C s� t | j�}t | j�}t | j�}| j|�}| j|�}|| || ||< ||< || || ||< ||< || || ||< ||< t|||dd�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')],
)
F)rh rE rT rU )rz rh rE rT r� r: )rD r| �jr� rl � new_namesrF rF rG � swaplevel, s +
zMultiIndex.swaplevelc s� � fdd�|D �}t |�� jkr:td� j� dt |�� ���� fdd�|D �}� fdd�|D �}� fdd�|D �}t|||dd �S )
aP
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
c s g | ]}� j |��qS rF )r� )rs r| )rD rF rG rt t s z-MultiIndex.reorder_levels.<locals>.<listcomp>z2Length of order must be same as number of levels (z), got c s g | ]}� j | �qS rF )rh )rs r| )rD rF rG rt z s c s g | ]}� j | �qS rF )rE )rs r| )rD rF rG rt { s c s g | ]}� j | �qS rF )rT )rs r| )rD rF rG rt | s F)rh rE rT rU )rZ r� r� r: )rD �orderr� rl rV rF )rD rG �reorder_levelsf s zMultiIndex.reorder_levelsc s dd� � � fdd�| j D �S )a
we 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 j| �j� d nd| jd�S )Nr= r )ri )rA r* rZ r� rw ri )r} rF rF rG �cats� s z/MultiIndex._get_codes_for_sorting.<locals>.catsc s g | ]}t j|� |�d d��qS )T)�ordered)r, Z
from_codes)rs r} )rZ rF rG rt � s z5MultiIndex._get_codes_for_sorting.<locals>.<listcomp>)rE )rD rF )rZ rG �_get_codes_for_sorting� s
z!MultiIndex._get_codes_for_sortingc
s\ t |ttf�r|g}�fdd�|D �}d}t |t�rht|�t|�ksLtd��t�fdd�|D �|d��n�t�j�� t�j��t � fdd�|D ��}t �fd d�|D ��}x(t
|d
d �D ]}� j |� �j |� q�W |r�||t � � 7 }||t �� 7 }n|d }t ||d
d��|�s"�ddd� �t
����fdd��jD �}t|�j�j|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
Indices of output values in original index.
c s g | ]}� j |��qS rF )r� )rs r� )rD rF rG rt � s z(MultiIndex.sortlevel.<locals>.<listcomp>Nz(level must have same length as ascendingc s g | ]}� j | �qS rF )rE )rs r� )rD rF rG rt � s )Zordersc 3 s | ]}� | V qd S )NrF )rs r� )rE rF rG r� � s z'MultiIndex.sortlevel.<locals>.<genexpr>c 3 s | ]}� | V qd S )NrF )rs r� )r� rF rG r� � s T)�reverser F)�compressr= c s g | ]}|j � ��qS rF )r� )rs r} )r� rF rG rt � s )rE rh rT rc rU ro )r� �strrb rz rZ r[ r5 rE r� r� �sortedr� r4 r r: rh rT )
rD rm Z ascendingZsort_remainingrc ZprimaryZprimshpr� rl � new_indexrF )rE r� rD r� rG � sortlevel� s@
zMultiIndex.sortlevelc C s^ t |d� }|dk r�|dk r$td��tj|�}t|�dkr�t|t� r�| j| }|j� }|j dd� t
|�j t j
d|jd�f|�}nt|�}| j||ddd d
�\}} }
n:t|�}| j|�r�d} n"| jr�| j||||d �} ntd ��t|t��s | dkr�| }n$| dkj� �r| j| �}n
tj|�}|�rV|j| jk�rV|j| jk�rV|jd d
�}| j|_|| fS )a
Create index with target's values (move/add/delete values as necessary)
Returns
-------
new_index : pd.MultiIndex
Resulting index
indexer : np.ndarray or None
Indices of output values in original index.
rT Nz)Fill method not supported if level passedr �freq)ri �rightTF)r Zreturn_indexersZ
keep_order)�method�limit� tolerancez'cannot handle a non-unique multi-index!)r� ) �hasattrrY r. Zensure_has_lenrZ r� r. rh Z_get_attributes_dictr� r� Z _simple_newrA r� ri r0 Z _join_level�equalsry rS r[ r: r
r� r� r� rT rW ) rD �targetre rm rf rg Zpreserve_namesr� �attrsr� r� rF rF rG �reindex� s@
zMultiIndex.reindexc C s t |� st|�rt|��d S )N)r r! r )rD r� rF rF rG �_check_indexing_error' s z MultiIndex._check_indexing_errorc C s | j d j� S )zA
Should integer key(s) be treated as positional?
r )rh � _should_fallback_to_positional)rD rF rF rG rn . s z)MultiIndex._should_fallback_to_positionalr9 )�seriesc C sD |j | }t|�r|S | | }t||�}|j|||jd�}|j|�S )z�
Do a positional lookup on the given Series, returning either a scalar
or a Series.
Assumes that `series.index is self`
)r rj )r� r$ �maybe_droplevelsr� rj Z __finalize__)rD ro rQ r� Z
new_valuesra Znew_serrF rF rG �_get_values_for_loc5 s
z MultiIndex._get_values_for_locc s� t � j|�\}}|dkr�t|�r�t|d t� r�d}| j||d�\}}|dkr\tjt| ��}| jd j |�}|dk}|j
� r�t || � d���||fS )a
Parameters
----------
keyarr : list-like
Indexer to convert.
Returns
-------
tuple (indexer, keyarr)
indexer is an ndarray or None if cannot convert
keyarr are tuple-safe keys
Nr )rm r= z
not in indexro ) r �_convert_listlike_indexerrZ r� r� rl rA r* rh rS rp r )rD Zkeyarrr� rm r� �checkr� )r rF rG rr E s
z$MultiIndex._convert_listlike_indexerc C s� t |t�r8| jd jr8t|gtd�gt| j�d �}t |t�r�g }xHt|�D ]<\}}t |t�r�| j| jr�|jt||d�� qP|j|� qPW t|�}|S )z�
Translate any partial string timestamp matches in key, returning the
new key.
Only relevant for MultiIndex.
r Nr= ) r� r_ rh Z!_supports_partial_string_indexingr� rJ rZ ru r� )rD r� Znew_keyr| � componentrF rF rG �'_get_partial_string_timestamp_match_keyd s "
z2MultiIndex._get_partial_string_timestamp_match_keyrS c C s� t j|�}t|�}t|�r2t|� r2ttjg ��S t|t �s�yt j
|�}W n8 t t fk
r� |d kr~t
| j�j||||d�S Y nX | js�t d��|dks�|dkr�|d k r�td��| jj| j|||d�}n |dkr�td��n | jj|�}t|�S ) N)re rf rg z8Reindexing only valid with uniquely valued Index objects�padZbackfillz,tolerance not implemented yet for MultiIndex)r� rj re rf ZnearestzJmethod='nearest' not implemented yet for MultiIndex; see GitHub issue 9365)�missingZclean_reindex_fill_methodr0 r" rZ r rA r� r� r: r� rY r[ r. r� rS ry r r� )rD rj re rf rg r� rF rF rG rS � s0
zMultiIndex.get_indexer�get_indexer_non_uniquec s t � j|�S )N)r rx )rD rj )r rF rG rx � s z!MultiIndex.get_indexer_non_unique)r? �side�kindr~ c C s t |t�s|f}| j||d�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'}
kind : {'loc', 'getitem'}
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", kind="loc")
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", kind="loc")
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.
)ry )r� r� �_partial_tup_index)rD r? ry rz rF rF rG �get_slice_bound� s /
zMultiIndex.get_slice_boundc s t � j||||d�S )a{
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
kind : string, optional, defaults None
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.
)rz )r �
slice_locs)rD r� �end�steprz )r rF rG r} � s 6zMultiIndex.slice_locs�leftc C s< t |�| jkr*tdt |�� d| j� d���t |�}dt | � }}t|| j| j�}x�t|�D ]�\}\}} }
|
||� } || kr�t|� r�| jt j
|gdd��s�t d|� ���| j ||d�} |d kr�| dkr�| d
8 } || j | |d� S | j
| |�}
||d
k �r"|| j |
d d� }|| j |
d d� }qZ|| j |
|d� S qZW d S ) Nz Key length (z-) was greater than MultiIndex lexsort depth (�)r F)ZskipnazLevel type mismatch: )ry rd r= r� )rZ r$ r rv rh rE ru r+ Zis_type_compatibler Z infer_dtyperY � searchsorted�_get_loc_single_level_index)rD r� ry �nr� r~ Zzippedr% r< r� Zlabs�sectionrQ r� rF rF rG r{
s( z MultiIndex._partial_tup_index)r� r� r~ c C s" t |�rt|�rdS |j|�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= Nro )r$ r+ r� )rD r� r� rF rF rG r� 7
s z&MultiIndex._get_loc_single_level_indexc
s� |dk rt d��t|� � fdd�}t|t�sD� j|dd�}||�S t|�}� j|k rntd|� d� j� d ���|� jkr�� jr�� j j
|�S � j }|d|� ||d� }}|r�� j ||�n
dt� �f\} }
| |
kr�t|��|s�t
| |
�S tjd
td d � tj| |
tjd
�}x`t|t|��D ]N\}} � j| | � j� j| | �k} | j� �sT|| }t|��st|���qW t|�|
| k�r�||�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)
method : None
Returns
-------
loc : 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
NzEonly the default get_loc method is currently supported for MultiIndexc sd t | tj� s| jtjkr | S tj| t� ��} t | t�r<| S tj t� �dd�}|j
d� d|| < |S )z<convert integer indexer to boolean mask or slice if possibler� )ri FT) r� rA r� ri rB r Zmaybe_indices_to_slicerZ rJ r� �fill)rQ r� )rD rF rG �_maybe_to_slice�
s
z+MultiIndex.get_loc.<locals>._maybe_to_slicer )rm z Key length (z) exceeds index depth (r� z3indexing past lexsort depth may impact performance.�
)rF )ri )r r� r� r� �_get_level_indexerrZ r� r ry r� r� r$ r} rJ rL rM r rA r* rB ru rE r� rh r
)
rD r� re r� rQ Zkeylenr| Zlead_keyZ
follow_keyr� rK r% r� rF )rD rG r� O
sD *
zMultiIndex.get_loc)�
drop_levelc s� t d��fdd� �t|ttf�r�t��t|�kr8td��d}xdt|��D ]V\}}�j||d�\}}t|t�r�t j
t��t d�} d| |< | }|dkr�|n||@ }qHW |�||� �fS �j |�}t�t�r�t���t�t�o�|d k�r�y8��j d k�r�j
�|d�}
�|
d g� �}|
|fS W n ttfk
�r4 Y nX td
d � �D ���s�d� ��fd d
� } t���jk�r��j�r�y�jj��dfS tk
�r� } zt��| �W Y dd} ~ X nX n| ��S n�d}
x�t��D ]�\}
}t|t��s(�j
||
d�}t|t��r$|jd k�r(|jt��k�r(tdd�}n|}t|t��rR|tdd�k�rJ�q�nt���|
dk�rb|}
n|
|M }
�q�W |
dk�r�tdd�}
�fdd�tt���D �}|
�|
|� �fS n �j
�|d�}
|
�|
|g� �fS dS )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
-------
loc : A 2-tuple where the elements are:
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� c sh |s � | S � | }}� fdd�|D �}x8t |dd�D ](}y|j|�}W q8 tk
r^ |S X q8W |S )Nc s g | ]}� j |��qS rF )r� )rs r| )rD rF rG rt �
s zIMultiIndex.get_loc_level.<locals>.maybe_mi_droplevels.<locals>.<listcomp>T)r] )r` � droplevelr[ )r� rh r� Z
orig_indexra r| )rD rF rG �maybe_mi_droplevels�
s
z5MultiIndex.get_loc_level.<locals>.maybe_mi_droplevelsz:Key for location must have same length as number of levelsN)rm )ri Tr c s s | ]}t |t�V qd S )N)r� rJ )rs r% rF rF rG r� s z+MultiIndex.get_loc_level.<locals>.<genexpr>c s< |d kr�j � �}� fdd�tt� ��D �}|�||��fS )Nc s" g | ]}� | t d d �kr|�qS )N)rJ )rs r| )r� rF rG rt s zGMultiIndex.get_loc_level.<locals>.partial_selection.<locals>.<listcomp>)r� r� rZ )r� r� �ilevels)r� r� rD )r� rG �partial_selection s
z3MultiIndex.get_loc_level.<locals>.partial_selectionc s" g | ]}� | t d d �kr|�qS )N)rJ )rs r| )r� rF rG rt B s z,MultiIndex.get_loc_level.<locals>.<listcomp>)N)r� r� r� rz rZ r� rv �
get_loc_levelrJ rA r) r� rh r� rY r rp r� ry r� r� r ru r� rK r� )rD r� rm r� rk r� r% rQ ra r� r� r� �er| Zk_indexr� rF )r� r� r� rD rG r� �
sl '
zMultiIndex.get_loc_levelc C s� | j | }| j| }||fdd�}t|t��rByJ|jd k rH|j|j�}nd}|jd k rd|j|j�}n t|�d }|j} W n6 t k
r� |j
|j|j|jdd� }}|j} Y nX t|t�s�t|t�r�t |d|�}t |d|�}|||| �S |dk�s| j dk�s| d k �r|||d | �S |j
|d d
�}
|j
|d d
�} t|
| | �S n�| j||�} |dk�sd| j dk�r�tj|| ktd d
�}
|
j� �s�t |��|
S |j
| d d
�}
|j
| d d
�} |
| k�r�t |��t|
| �S d S )Nc
S s� t j| ||�}|d k rxt|�t|�krxddlm} ||�}|jt|��}|t|�j|�j � d �}|j
|�} t j | �} n,t j t|�t
d�} d| t j||t|�jd�< | S )Nr )r9 )ri T)�
assume_unique)rA r* rZ r r9 r� r r. rT rN r� r3 r) r� Zin1dry )
r� rK r r� rE �rr9 r� rk �mrF rF rG �convert_indexerP s
z6MultiIndex._get_level_indexer.<locals>.convert_indexerr r= rQ )rz r� rK r� )ry rd F)ri rW )rh rE r� rJ r� r� rK rZ r r Z
slice_indexerr r$ r� r� rA r� r� rp )rD r� rm r� r� r} r� r� rK r r| rU rn ZlocsrF rF rG r� H sH
z MultiIndex._get_level_indexerc s� ddl m� dd� ttj|��D �}|rL|d | jkrLtd|� d| j� ���t| ��d}� d �� �fd
d � }|f�fd d
� }�x,t|�D �] \}}tj|�r�t j
|�}|||�|d�}q�t |��rDd}xR|D ]J} y,|| j | ||d��}
|dkr�|
n||
B }W q� t
k
�r w�Y q�X q�W |dk �r2|||d�}nt jg t jd�S q�tj|��r^|d|d�}q�t|t��r�||| j |||d��|d�}q�||| j||dd�d �|d�}q�W |dk�r�t jg t jd�S t|� ��s�tt|���| j||�}|jS )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 )r2 c S s g | ]\}}|r|�qS rF rF )rs r| �srF rF rG rt � s z'MultiIndex.get_locs.<locals>.<listcomp>r= zIMultiIndex slicing requires the index to be lexsorted: slicing on levels z, lexsort depth N)r~ c s` t | t�r.tj�td�}d|| < |j� d } n*tj| �rXt| ��krLt d��| j� d } � | �S )N)ri Tr zLcannot index with a boolean indexer that is not the same length as the index)
r� rJ rA r) r� rN r1 r2 rZ r[ )r� r� )r2 r� rF rG �_convert_to_indexer� s
z0MultiIndex.get_locs.<locals>._convert_to_indexerc s* |d krt tj� ��}| d kr"|S || @ S )N)r. rA r* )Zidxrr� )r� rF rG �_update_indexer� s
z,MultiIndex.get_locs.<locals>._update_indexer)r� )rm r� )ri F)rm r� ro )�pandas.core.indexes.numericr2 ru r1 Zis_true_slicesr$ r rZ r2 rA r3 r" r� r r� r Z
is_null_slicer� rJ r� r� r� �_reorder_indexerr� ) rD �seqZ true_slicesr� r� r� r| r% Zindexersr� ZidxrsrF )r2 r� rG �get_locs� sR "
zMultiIndex.get_locs.)r� r� r~ c
C sJ | j � rnd}xXt|�D ]L\}}t|�r|s| j| j|�}||dk }|dd� |dd� kj� }qW |sn|S t| �}t� }x�t|�D ]�\}}tj |�r�t
j |�| } n�t|��r t
j t| j| �t
j
d�t| j| � }
| j| j|�} | | dk } t
j t| ��|
| < |
| j| | } nt
j |�| } | f| }q�W t
j|�} || S )aq
Reorder an indexer of a MultiIndex (self) so that the label are in the
same order as given in seq
Parameters
----------
seq : label/slice/list/mask or a sequence of such
indexer: an Int64Index indexer of self
Returns
-------
indexer : a sorted Int64Index indexer of self ordered as seq
Fr Nr= )ri ro )r ru r" rh rS rp rZ r� r1 r2 rA r* Zonesr� rE r )
rD r� r� Z need_sortr| r% Zk_codesr� �keysZ new_orderZ
key_order_mapZ
level_indexer�indrF rF rG r� , s4
zMultiIndex._reorder_indexerc s� |r|r||k rt d��| jd j||�\}}| j||�\� �t| j�}|d ||� |d< � �fdd�| jD �}|d | |d< t||| jdd�S )av
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
-------
truncated : MultiIndex
zafter < beforer c s g | ]}|� �� �qS rF rF )rs r} )r� rd rF rG rt � s z'MultiIndex.truncate.<locals>.<listcomp>F)rh rE rT rU )r[ rh r} rz rE r: r` )rD Zbefore�afterr| rU r� rl rF )r� rd rG �truncatei s
zMultiIndex.truncatec C s& | j |�rdS t|t�s dS t|t�sVt|j�s4dS t| �t|�krHdS t| j|j�S | j |j krfdS t| �t|�krzdS x�t
| j �D ]�}| j | }||dk }t j
tj| j| j�|dd�}|j | }||dk }t j
tj|j| j�|dd�}t|�dk�rt|�dk�rq�t||�s�dS q�W dS )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= )r6 r ro ro )�is_r� r. r: r# ri rZ r* r� r� r� rE r Ztake_ndrA r3 rh )rD r� r| Z
self_codesZ self_valuesZ other_codesZ other_valuesrF rF rG ri � s8
zMultiIndex.equalsc C sB | j |j krdS x,t| j �D ] }| j| j|j| �s dS q W dS )zT
Return True if the levels of both MultiIndex objects are the same
FT)r� r� rh ri )rD r� r| rF rF rG � equal_levels� s zMultiIndex.equal_levelsc C sx | j |� | j|� | j|�\}}t|�dks8| j|�r<| S t|j�sNtd��tj | j
|j
g|d�}t j t
|� d|d�S )a/
Form the union of two MultiIndex objects
Parameters
----------
other : MultiIndex or array / Index of tuples
sort : False or None, default None
Whether to sort the resulting Index.
* None : Sort the result, except when
1. `self` and `other` are equal.
2. `self` has length 0.
3. Some values in `self` or `other` cannot be compared.
A RuntimeWarning is issued in this case.
* False : do not sort the result.
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default value from ``True`` to ``None``
(without change in behaviour).
Returns
-------
Index
Examples
--------
>>> idx1 = pd.MultiIndex.from_arrays(
... [[1, 1, 2, 2], ["Red", "Blue", "Red", "Blue"]]
... )
>>> idx1
MultiIndex([(1, 'Red'),
(1, 'Blue'),
(2, 'Red'),
(2, 'Blue')],
)
>>> idx2 = pd.MultiIndex.from_arrays(
... [[3, 3, 2, 2], ["Red", "Green", "Red", "Green"]]
... )
>>> idx2
MultiIndex([(3, 'Red'),
(3, 'Green'),
(2, 'Red'),
(2, 'Green')],
)
>>> idx1.union(idx2)
MultiIndex([(1, 'Blue'),
(1, 'Red'),
(2, 'Blue'),
(2, 'Green'),
(2, 'Red'),
(3, 'Green'),
(3, 'Red')],
)
>>> idx1.union(idx2, sort=False)
MultiIndex([(1, 'Red'),
(1, 'Blue'),
(2, 'Red'),
(2, 'Blue'),
(3, 'Red'),
(3, 'Green'),
(2, 'Green')],
)
r zjCan only union MultiIndex with MultiIndex or Index of tuples, try mi.to_flat_index().union(other) instead.)r� )rc rT )�_validate_sort_keyword�_assert_can_do_setop�_convert_can_do_setoprZ ri r# ri r r Zfast_unique_multipler� r: r� rv )rD r� r� � result_names� uniq_tuplesrF rF rG �union� s G
zMultiIndex.unionc s0 | j |� | j|� | j|�\}}| j|�r>| jr:| j� S | S t|j�sbt| j g g| j
|dd�S | j }|j }d}| j r�|j r�y| j
||�d }d}W n tk
r� Y n X tj|�}|dkr�t|�� t� �� �fdd�|D �}|dkr�t|�}t|�dk�rt| j g g| j
|dd�S tjt|� d|d�S dS )a�
Form the intersection of two MultiIndex objects.
Parameters
----------
other : MultiIndex or array / Index of tuples
sort : False or None, default False
Sort the resulting MultiIndex if possible
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default from ``True`` to ``False``, to match
behaviour from before 0.24.0
Returns
-------
Index
F)rh rE rT rU Nr c s, g | ]$}|� kr|�kp �j |� r|�qS rF )�add)rs r� )�
other_uniq�seenrF rG rt h
s z+MultiIndex.intersection.<locals>.<listcomp>)rc rT )r� r� r� ri Zhas_duplicatesr r# ri r: rh r� r� r Z_inner_indexerrY r �setr` rZ r� rv )rD r� r� r� ZlvalsZrvalsr� Z inner_tuplesrF )r� r� rG � intersection/
sJ
zMultiIndex.intersectionc C s� | j |� | j|� | j|�\}}t|�dkr2| S | j|�rVt| jg g| j |dd�S | j� }|j |�}|j
|d kj � d �}t j
t j|j�|dd�}|jj
|�}|dkr�t|�}t|�dkr�tg g| j g g| j |dd�S tj|d|d�S dS )
a�
Compute set difference of two MultiIndex objects
Parameters
----------
other : MultiIndex
sort : False or None, default None
Sort the resulting MultiIndex if possible
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default value from ``True`` to ``None``
(without change in behaviour).
Returns
-------
diff : MultiIndex
r F)rh rE rT rU r= T)r� N)rc rT ro )r� r� r� rZ ri r: rh r� Z_get_unique_indexrS r� rN rA Z setdiff1dr* �sizer� r` r� )rD r� r� r� �thisr� Z
label_diff�
differencerF rF rG r� z
s2
zMultiIndex.differencec C s� | j }t|t�s~t|�dkr<tg g| j g g| j dd�}q�d}ytj|�}W q� tk
rz } zt|�|�W Y d d }~X q�X n| j |j kr�| j nd }||fS )Nr F)rh rE rU z.other must be a MultiIndex or a list of tuples)rT r� r. rZ r: r� r� rY )rD r� r� r= r rF rF rG r� �
s
z MultiIndex._convert_can_do_setopc C sP t |�}t|�r d}t|��n.t|�s<tdt| �� d���n|dkrL| j� S | S )Nz3> 1 ndim Categorical are not supported at this timezSetting z5 dtype to anything other than object is not supportedT)r% r r r# rY r� r� )rD ri rW r= rF rF rG rR �
s
zMultiIndex.astype)rQ c C s� t |t�s |fd| jd }nt|�| jkr6td��g }g }xht|| j| j�D ]T\}}}||krxt|�}|j||�}n
|j |�}|j
|� |j
t jt |�||�� qPW t
||| jdd�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
r� r= z0Item must have length equal to number of levels.F)rh rE rT rU )r� )r� r� r� rZ r[ rv rh rE �insertr� r� rA r r: rT ) rD rQ �itemr� rl r% rm r} Zlev_locrF rF rG r� �
s
zMultiIndex.insertc s( � fdd�| j D �}t| j|| jdd�S )z}
Make new index with passed location deleted
Returns
-------
new_index : MultiIndex
c s g | ]}t j|� ��qS rF )rA rO )rs r} )rQ rF rG rt s z%MultiIndex.delete.<locals>.<listcomp>F)rh rE rT rU )rE r: rh rT )rD rQ rl rF )rQ rG rO s zMultiIndex.deletec C s$ | j |j kr| j nd }tj||d�S )N)rT )rT r: r� )rD Zjoinedr� rT rF rF rG �_wrap_joined_index s z MultiIndex._wrap_joined_indexc C sh |d kr(t j|| jd�j}tj| j|�S | j|�}| j|�}|jdkrZt j
t |�t j d�S |j|�S d S )N)rT r )ri )
r: r� rT r� r rT r� r r� rA r) rZ Zbool_)rD r� rm �numZlevsrF rF rG rT s
zMultiIndex.isin) NNNNNFNTT)NN)NN)NN)NFTF)NFT)NFTF)NFT)NN)NNNNFNF)N)N)F)F)N)r� )NNNFr� NT)NT)r )NN)rp )F)N)TN)r TN)TNN)N)N)NrD )rD ���ro )r� ro )r TT)NNNN)NNN)NNNN)r� )N)r T)r N)NN)N)F)N)T)N)�rI rJ rK rL r. Z
_deprecations� frozensetZ_typr1 r` r� re Z _comparablesZ set_names�renamer� r rb rc r� r\ r rr rd � classmethodr r� r� r� r� r� �propertyr� r� r� r� r� r rh r^ r� r� r� rE r_ r� r� r� r r� r� rW rA r� r� r� r� r ri r� r� r� r� r� r� r� r� r r_ r� r� ra rT r r r� r r r r� r r r r� r r r r! r" r# r r$ r{ r( r, r0 r5 r r/ �_index_doc_kwargsr� r9 r� r& rA rq rR rH rW rY r\ rb rl rm rn rq rr ru rS rx r r r
r| r} r{ r� r� r� r� r� r r r r r2 r� r� ri r� r� r� r� r� rR r� rO r� rT �
__classcell__rF rF )r rG r: � sZ
O '?A 9: C
$
k
S
, " E : % $ 5 " CW ! " 5 : N C ( 18 p
b 9 "8 \ K 8(r� )r� c C s� t t| � �}t| �}|d |d � }|| }x�||d d � D ]�}g }xrtt||��D ]`\} \}
} | |d kr�|j| � |j|� P |
| kr�|j|� qV|j|| d � � |j|� P qVW |}q>W t t|� �S )Nr= )rz rv rZ ru r� r� ) Z
label_listr� r� Zpivotedr% rk �prev�curZ
sparse_curr| �p�trF rF rG r� ' s$
r� )r~ c C s t jdt jdij| d�S )NZNaT�NaN)rA Z
datetime64Z timedelta64�get)ri rF rF rG r� C s r� c C sj | }t |t�rBxV|D ](}y| jd�} W q tk
r: |S X qW n$y| jd�} W n tk
rd 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� r[ )r r� Zoriginal_indexr� rF rF rG rp G s
rp F)rW r~ c C s" 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 rW r� r� )Z
array_like�
categoriesrW rF rF rG r� f s
r� )r r� )F)s�sysr Ztypingr r r r r r r r
r r rL ZnumpyrA Zpandas._configr
Z pandas._libsr r r rM r Zpandas._libs.hashtabler Zpandas._typingr r Zpandas.compat.numpyr r8 Z
pandas.errorsr r r Zpandas.util._decoratorsr r r Zpandas.core.dtypes.castr Zpandas.core.dtypes.commonr r r r r r! r" r# r$ r% Zpandas.core.dtypes.dtypesr& Zpandas.core.dtypes.genericr' r( r) Zpandas.core.dtypes.missingr* r+ Zpandas.core.algorithms�coreZ
algorithmsZpandas.core.arraysr, Z pandas.core.arrays.categoricalr- Zpandas.core.common�commonr1 Zpandas.core.indexes.base�indexes�baser. r. r/ r0 Zpandas.core.indexes.frozenr1 r� r2 Zpandas.core.missingrw Zpandas.core.sortingr3 r4 r5 Zpandas.io.formats.printingr6 r7 r8 r r9 r- r� �updateZBaseMultiIndexCodesEnginerN r< rS rP r: Z _add_numeric_methods_disabledZ%_add_numeric_methods_add_sub_disabledZ _add_logical_methods_disabledrb r� r_ r� rp r� r� r� rF rF rF rG �<module> s� 0 0
') # |