Файловый менеджер - Редактировать - /home/digitalm/venv/lib/python3.7/site-packages/pandas/core/__pycache__/indexing.cpython-37.pyc
Назад
B �5�gKE � @ s� d dl mZ d dlmZ d dlmZmZmZmZ d dl Z d dl Z d dl m Z d dlmZ d dlmZmZ d dlmZ d d lmZmZmZmZmZmZm Z m Z m Z m Z m Z d d l!m"Z" d d l#m$Z$m%Z% d d l&m'Z'm(Z( d d l)m*Z+ d dl,m- m.Z/ d dl0m1Z2m3Z3 d dl4m5Z5m6Z6m7Z7m8Z8m9Z9 d dl:m;Z;m<Z<m=Z=m>Z>m?Z? e�rPd dl@mAZAmBZB eCdd�ZDG dd� d�ZEeE� ZFG dd� deG�ZHG dd� d�ZIG dd� de �ZJeeIjK�G dd� deJ��ZLeeIjM�G d d � d eJ��ZNG d d � d e �ZOeeIjP�G d d!� d!eO��ZQeeIjR�G d"d#� d#eO��ZSd$d%d&d'�d(d)�ZTd*d+�d,d-�ZUd.d/d0�d1d2�ZVd3d4� ZWd5d6� ZXd7d8� ZYd9d:�d;d<�ZZd9d:�d=d>�Z[d?d9d@�dAdB�Z\dS )C� )� annotations)�suppress)� TYPE_CHECKING�Any�Hashable�SequenceN)�NDFrameIndexerBase)�item_from_zerodim)�AbstractMethodError�InvalidIndexError)�doc) � is_array_like� is_bool_dtype� is_hashable� is_integer� is_iterator� is_list_like�is_numeric_dtype�is_object_dtype� is_scalar� is_sequence�needs_i8_conversion)� concat_compat)� ABCDataFrame� ABCSeries)�infer_fill_value�isna)� algorithms)�array� extract_array)�check_array_indexer�is_empty_indexer�is_exact_shape_match�is_list_like_indexer�length_of_indexer)�CategoricalIndex�Index� IntervalIndex� MultiIndex� ensure_index)� DataFrame�Seriesc @ s e Zd ZdZdd� ZdS )� _IndexSlicea Create an object to more easily perform multi-index slicing. See Also -------- MultiIndex.remove_unused_levels : New MultiIndex with no unused levels. Notes ----- See :ref:`Defined Levels <advanced.shown_levels>` for further info on slicing a MultiIndex. Examples -------- >>> midx = pd.MultiIndex.from_product([['A0','A1'], ['B0','B1','B2','B3']]) >>> columns = ['foo', 'bar'] >>> dfmi = pd.DataFrame(np.arange(16).reshape((len(midx), len(columns))), ... index=midx, columns=columns) Using the default slice command: >>> dfmi.loc[(slice(None), slice('B0', 'B1')), :] foo bar A0 B0 0 1 B1 2 3 A1 B0 8 9 B1 10 11 Using the IndexSlice class for a more intuitive command: >>> idx = pd.IndexSlice >>> dfmi.loc[idx[:, 'B0':'B1'], :] foo bar A0 B0 0 1 B1 2 3 A1 B0 8 9 B1 10 11 c C s |S )N� )�self�argr- r- �J/home/digitalm-up/venv/lib/python3.7/site-packages/pandas/core/indexing.py� __getitem__u s z_IndexSlice.__getitem__N)�__name__� __module__� __qualname__�__doc__r1 r- r- r- r0 r, M s &r, c @ s e Zd ZdS )� IndexingErrorN)r2 r3 r4 r- r- r- r0 r6 | s r6 c @ sX e Zd ZdZedd�dd��Zedd�dd��Zed d�d d ��Zed d�d d��ZdS )� IndexingMixinzH Mixin for adding .loc/.iloc/.at/.iat to Dataframes and Series. � _iLocIndexer)�returnc C s t d| �S )aZ Purely integer-location based indexing for selection by position. ``.iloc[]`` is primarily integer position based (from ``0`` to ``length-1`` of the axis), but may also be used with a boolean array. Allowed inputs are: - An integer, e.g. ``5``. - A list or array of integers, e.g. ``[4, 3, 0]``. - A slice object with ints, e.g. ``1:7``. - A boolean array. - A ``callable`` function with one argument (the calling Series or DataFrame) and that returns valid output for indexing (one of the above). This is useful in method chains, when you don't have a reference to the calling object, but would like to base your selection on some value. ``.iloc`` will raise ``IndexError`` if a requested indexer is out-of-bounds, except *slice* indexers which allow out-of-bounds indexing (this conforms with python/numpy *slice* semantics). See more at :ref:`Selection by Position <indexing.integer>`. See Also -------- DataFrame.iat : Fast integer location scalar accessor. DataFrame.loc : Purely label-location based indexer for selection by label. Series.iloc : Purely integer-location based indexing for selection by position. Examples -------- >>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4}, ... {'a': 100, 'b': 200, 'c': 300, 'd': 400}, ... {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000 }] >>> df = pd.DataFrame(mydict) >>> df a b c d 0 1 2 3 4 1 100 200 300 400 2 1000 2000 3000 4000 **Indexing just the rows** With a scalar integer. >>> type(df.iloc[0]) <class 'pandas.core.series.Series'> >>> df.iloc[0] a 1 b 2 c 3 d 4 Name: 0, dtype: int64 With a list of integers. >>> df.iloc[[0]] a b c d 0 1 2 3 4 >>> type(df.iloc[[0]]) <class 'pandas.core.frame.DataFrame'> >>> df.iloc[[0, 1]] a b c d 0 1 2 3 4 1 100 200 300 400 With a `slice` object. >>> df.iloc[:3] a b c d 0 1 2 3 4 1 100 200 300 400 2 1000 2000 3000 4000 With a boolean mask the same length as the index. >>> df.iloc[[True, False, True]] a b c d 0 1 2 3 4 2 1000 2000 3000 4000 With a callable, useful in method chains. The `x` passed to the ``lambda`` is the DataFrame being sliced. This selects the rows whose index label even. >>> df.iloc[lambda x: x.index % 2 == 0] a b c d 0 1 2 3 4 2 1000 2000 3000 4000 **Indexing both axes** You can mix the indexer types for the index and columns. Use ``:`` to select the entire axis. With scalar integers. >>> df.iloc[0, 1] 2 With lists of integers. >>> df.iloc[[0, 2], [1, 3]] b d 0 2 4 2 2000 4000 With `slice` objects. >>> df.iloc[1:3, 0:3] a b c 1 100 200 300 2 1000 2000 3000 With a boolean array whose length matches the columns. >>> df.iloc[:, [True, False, True, False]] a c 0 1 3 1 100 300 2 1000 3000 With a callable function that expects the Series or DataFrame. >>> df.iloc[:, lambda df: [0, 2]] a c 0 1 3 1 100 300 2 1000 3000 �iloc)r8 )r. r- r- r0 r: � s zIndexingMixin.iloc� _LocIndexerc C s t d| �S )a� Access a group of rows and columns by label(s) or a boolean array. ``.loc[]`` is primarily label based, but may also be used with a boolean array. Allowed inputs are: - A single label, e.g. ``5`` or ``'a'``, (note that ``5`` is interpreted as a *label* of the index, and **never** as an integer position along the index). - A list or array of labels, e.g. ``['a', 'b', 'c']``. - A slice object with labels, e.g. ``'a':'f'``. .. warning:: Note that contrary to usual python slices, **both** the start and the stop are included - A boolean array of the same length as the axis being sliced, e.g. ``[True, False, True]``. - An alignable boolean Series. The index of the key will be aligned before masking. - An alignable Index. The Index of the returned selection will be the input. - A ``callable`` function with one argument (the calling Series or DataFrame) and that returns valid output for indexing (one of the above) See more at :ref:`Selection by Label <indexing.label>`. Raises ------ KeyError If any items are not found. IndexingError If an indexed key is passed and its index is unalignable to the frame index. See Also -------- DataFrame.at : Access a single value for a row/column label pair. DataFrame.iloc : Access group of rows and columns by integer position(s). DataFrame.xs : Returns a cross-section (row(s) or column(s)) from the Series/DataFrame. Series.loc : Access group of values using labels. Examples -------- **Getting values** >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]], ... index=['cobra', 'viper', 'sidewinder'], ... columns=['max_speed', 'shield']) >>> df max_speed shield cobra 1 2 viper 4 5 sidewinder 7 8 Single label. Note this returns the row as a Series. >>> df.loc['viper'] max_speed 4 shield 5 Name: viper, dtype: int64 List of labels. Note using ``[[]]`` returns a DataFrame. >>> df.loc[['viper', 'sidewinder']] max_speed shield viper 4 5 sidewinder 7 8 Single label for row and column >>> df.loc['cobra', 'shield'] 2 Slice with labels for row and single label for column. As mentioned above, note that both the start and stop of the slice are included. >>> df.loc['cobra':'viper', 'max_speed'] cobra 1 viper 4 Name: max_speed, dtype: int64 Boolean list with the same length as the row axis >>> df.loc[[False, False, True]] max_speed shield sidewinder 7 8 Alignable boolean Series: >>> df.loc[pd.Series([False, True, False], ... index=['viper', 'sidewinder', 'cobra'])] max_speed shield sidewinder 7 8 Index (same behavior as ``df.reindex``) >>> df.loc[pd.Index(["cobra", "viper"], name="foo")] max_speed shield foo cobra 1 2 viper 4 5 Conditional that returns a boolean Series >>> df.loc[df['shield'] > 6] max_speed shield sidewinder 7 8 Conditional that returns a boolean Series with column labels specified >>> df.loc[df['shield'] > 6, ['max_speed']] max_speed sidewinder 7 Callable that returns a boolean Series >>> df.loc[lambda df: df['shield'] == 8] max_speed shield sidewinder 7 8 **Setting values** Set value for all items matching the list of labels >>> df.loc[['viper', 'sidewinder'], ['shield']] = 50 >>> df max_speed shield cobra 1 2 viper 4 50 sidewinder 7 50 Set value for an entire row >>> df.loc['cobra'] = 10 >>> df max_speed shield cobra 10 10 viper 4 50 sidewinder 7 50 Set value for an entire column >>> df.loc[:, 'max_speed'] = 30 >>> df max_speed shield cobra 30 10 viper 30 50 sidewinder 30 50 Set value for rows matching callable condition >>> df.loc[df['shield'] > 35] = 0 >>> df max_speed shield cobra 30 10 viper 0 0 sidewinder 0 0 **Getting values on a DataFrame with an index that has integer labels** Another example using integers for the index >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]], ... index=[7, 8, 9], columns=['max_speed', 'shield']) >>> df max_speed shield 7 1 2 8 4 5 9 7 8 Slice with integer labels for rows. As mentioned above, note that both the start and stop of the slice are included. >>> df.loc[7:9] max_speed shield 7 1 2 8 4 5 9 7 8 **Getting values with a MultiIndex** A number of examples using a DataFrame with a MultiIndex >>> tuples = [ ... ('cobra', 'mark i'), ('cobra', 'mark ii'), ... ('sidewinder', 'mark i'), ('sidewinder', 'mark ii'), ... ('viper', 'mark ii'), ('viper', 'mark iii') ... ] >>> index = pd.MultiIndex.from_tuples(tuples) >>> values = [[12, 2], [0, 4], [10, 20], ... [1, 4], [7, 1], [16, 36]] >>> df = pd.DataFrame(values, columns=['max_speed', 'shield'], index=index) >>> df max_speed shield cobra mark i 12 2 mark ii 0 4 sidewinder mark i 10 20 mark ii 1 4 viper mark ii 7 1 mark iii 16 36 Single label. Note this returns a DataFrame with a single index. >>> df.loc['cobra'] max_speed shield mark i 12 2 mark ii 0 4 Single index tuple. Note this returns a Series. >>> df.loc[('cobra', 'mark ii')] max_speed 0 shield 4 Name: (cobra, mark ii), dtype: int64 Single label for row and column. Similar to passing in a tuple, this returns a Series. >>> df.loc['cobra', 'mark i'] max_speed 12 shield 2 Name: (cobra, mark i), dtype: int64 Single tuple. Note using ``[[]]`` returns a DataFrame. >>> df.loc[[('cobra', 'mark ii')]] max_speed shield cobra mark ii 0 4 Single tuple for the index with a single label for the column >>> df.loc[('cobra', 'mark i'), 'shield'] 2 Slice from index tuple to single label >>> df.loc[('cobra', 'mark i'):'viper'] max_speed shield cobra mark i 12 2 mark ii 0 4 sidewinder mark i 10 20 mark ii 1 4 viper mark ii 7 1 mark iii 16 36 Slice from index tuple to index tuple >>> df.loc[('cobra', 'mark i'):('viper', 'mark ii')] max_speed shield cobra mark i 12 2 mark ii 0 4 sidewinder mark i 10 20 mark ii 1 4 viper mark ii 7 1 �loc)r; )r. r- r- r0 r< s zIndexingMixin.loc� _AtIndexerc C s t d| �S )a� Access a single value for a row/column label pair. Similar to ``loc``, in that both provide label-based lookups. Use ``at`` if you only need to get or set a single value in a DataFrame or Series. Raises ------ KeyError If 'label' does not exist in DataFrame. See Also -------- DataFrame.iat : Access a single value for a row/column pair by integer position. DataFrame.loc : Access a group of rows and columns by label(s). Series.at : Access a single value using a label. Examples -------- >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]], ... index=[4, 5, 6], columns=['A', 'B', 'C']) >>> df A B C 4 0 2 3 5 0 4 1 6 10 20 30 Get value at specified row/column pair >>> df.at[4, 'B'] 2 Set value at specified row/column pair >>> df.at[4, 'B'] = 10 >>> df.at[4, 'B'] 10 Get value within a Series >>> df.loc[5].at['B'] 4 �at)r= )r. r- r- r0 r> s /zIndexingMixin.at� _iAtIndexerc C s t d| �S )a� Access a single value for a row/column pair by integer position. Similar to ``iloc``, in that both provide integer-based lookups. Use ``iat`` if you only need to get or set a single value in a DataFrame or Series. Raises ------ IndexError When integer position is out of bounds. See Also -------- DataFrame.at : Access a single value for a row/column label pair. DataFrame.loc : Access a group of rows and columns by label(s). DataFrame.iloc : Access a group of rows and columns by integer position(s). Examples -------- >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]], ... columns=['A', 'B', 'C']) >>> df A B C 0 0 2 3 1 0 4 1 2 10 20 30 Get value at specified row/column pair >>> df.iat[1, 2] 1 Set value at specified row/column pair >>> df.iat[1, 2] = 10 >>> df.iat[1, 2] 10 Get value within a series >>> df.loc[0].iat[1] 2 �iat)r? )r. r- r- r0 r@ C s .zIndexingMixin.iatN) r2 r3 r4 r5 �propertyr: r< r> r@ r- r- r- r0 r7 � s 1r7 c @ s e Zd ZU ded< dZd8dd�Zdd� Zd9dd �Zd d � Zd d �dd�Z dd�dd�Z ddd�dd�Z d:dd�dd�Z d d d �d d �Z dd!�d"d#�Zdd!�d$d%�Zdd!�d&d'�Zd;d dd(�d)d*�Zd+d,� Zdd�d-d.�Zdd!�d/d0�Zd d �d1d2�Zdd3�d4d5�Zd d �d6d7�ZdS )<�_LocationIndexer�str� _valid_typesNc C s0 t | �| j| j�}|d k r&| j�|�}||_|S )N)�type�name�obj�_get_axis_number�axis)r. rI Znew_selfr- r- r0 �__call__x s z_LocationIndexer.__call__c C s | j dkr| �|� | jdk r,| j|dd�S | j�d�}t|t�rj| j dkrjtt t t �� |� |�S Q R X t|t �r�tt�� | j|dd�S Q R X t|t�r�t|�S y| j|ddd�S t k �r } z,dt|�kr nd t|�kr� t|�|�W dd}~X Y nX dS ) zR Convert a potentially-label-based key into a positional indexer. r< NT)� is_setterr r: )rI rK z cannot dozunhashable type)rF �_ensure_listlike_indexerrI �_convert_tuplerG � _get_axis� isinstancer( r � TypeError�KeyErrorr �get_loc�tupler6 �range�list�_convert_to_indexerrC )r. �key�ax�er- r- r0 �_get_setitem_indexer� s* z%_LocationIndexer._get_setitem_indexerc C s� d}| j dkrdS t|t�r4t|�dkr4|| }|}||kr�t| jjt�s�t|�r�t� |�s�t dd� |D ��r�| jjj |dd�}| jj j |ddd d �| j_ dS ) a Ensure that a list-like of column labels are all present by adding them if they do not already exist. Parameters ---------- key : list-like of column labels Target labels. axis : key axis if known � � Nc s s | ]}t |�V qd S )N)r )�.0�kr- r- r0 � <genexpr>� s z<_LocationIndexer._ensure_listlike_indexer.<locals>.<genexpr>F)�sortr T)rI Z consolidateZ only_slice)�ndimrO rS �lenrG �columnsr( r# �com�is_bool_indexer�all�union�_mgrZ reindex_axis)r. rW rI �valueZ column_axis�keysr- r- r0 rL � s z)_LocationIndexer._ensure_listlike_indexerc s� t |t�r4tdd� |D ��}t� fdd�|D ��}nt�|� j�}� �|�}� �|� � jdkrd� n� jj}|� ||� j� d S )Nc s s" | ]}t |�rt|�n|V qd S )N)r rU )r] �xr- r- r0 r_ � s z/_LocationIndexer.__setitem__.<locals>.<genexpr>c 3 s | ]}t �|� j�V qd S )N)rd �apply_if_callablerG )r] rk )r. r- r0 r_ � s r: ) rO rS rd rl rG rZ �_has_valid_setitem_indexerrF r: �_setitem_with_indexer)r. rW ri �indexerr: r- )r. r0 � __setitem__� s z _LocationIndexer.__setitem__�int)rI c C s t | ��dS )a� Ensure that key is valid for current indexer. Parameters ---------- key : scalar, slice or list-like Key requested. axis : int Dimension on which the indexing is being made. Raises ------ TypeError If the key (or some element of it) has wrong type. IndexError If the key (or some element of it) is out of bounds. KeyError If the key was not found. N)r )r. rW rI r- r- r0 � _validate_key� s z _LocationIndexer._validate_keyrS )rW c C sl | � |� x\t|�D ]P\}}y| �||� W q tk rb } ztd| j� d��|�W dd}~X Y qX qW dS )zA Check the key for valid keys across my indexer. z'Location based indexing can only have [z] typesN)�_validate_key_length� enumeraterr � ValueErrorrD )r. rW �ir^ �errr- r- r0 �_has_valid_tuple� s z!_LocationIndexer._has_valid_tuple�bool)�tupr9 c s4 t dd� | jjD ��r0t � fdd�| jjD ��S dS )z6 Returns ------- bool c s s | ]}t |t�V qd S )N)rO r( )r] rX r- r- r0 r_ � s z<_LocationIndexer._is_nested_tuple_indexer.<locals>.<genexpr>c 3 s | ]}t � |�V qd S )N)�is_nested_tuple)r] rX )rz r- r0 r_ s F)�anyrG �axes)r. rz r- )rz r0 �_is_nested_tuple_indexer� s z)_LocationIndexer._is_nested_tuple_indexerF)rK c C s� g }| j d k r`| j�| j �}x|t| j�D ]2}||krL|�| j|||d�� q(|�td �� q(W n:| �|� x.t |�D ]"\}}| j|||d�}|�|� qtW t |�S )N)rI rK ) rI rG rH rT ra �appendrV �slicers rt rS )r. rW rK ZkeyidxrI rv r^ �idxr- r- r0 rM s z _LocationIndexer._convert_tuplez Sequence[Any]�None)rW r9 c C s t |�| jkrtd��d S )NzToo many indexers)rb ra r6 )r. rW r- r- r0 rs s z%_LocationIndexer._validate_key_length)rz c C sR | j }xFt|�D ]:\}}t�|�r$qt|| j�j||d�}|j| jkst�qW |S )z� Index with indexers that should return an object of the same dimension as self.obj. This is only called after a failed call to _getitem_lowerdim. )rI ) rG rt rd � is_null_slice�getattrrF � _getitem_axisra �AssertionError)r. rz �retvalrv rW r- r- r0 �_getitem_tuple_same_dim s z(_LocationIndexer._getitem_tuple_same_dimc C s8 | j d k r&| j�| j �}| j||d�S | �|�r:| �|�S | j�d�}t|t�rt| j dkrtt t �� | � |�S Q R X | � |� x�t|�D ]�\}}t|�r�| j||d�}|j| jkr�|d |� tf ||d d � }n2|d |� ||d d � }t|�dk�r|d }t�|��r|S t|| j �| S q�W t d��d S )N)rI r r: r[ znot applicable)rI rG rH r� r~ �_getitem_nested_tuplerN rO r( rF r r6 �"_handle_lowerdim_multi_index_axis0rs rt � is_label_likera �_NSrb rd r� r� )r. rz rI Zax0rv rW �sectionZnew_keyr- r- r0 �_getitem_lowerdim- s, $ z"_LocationIndexer._getitem_lowerdimc C s t |�| jkr�| jdkr td��t| jt�rFtdd� |D ��rFtd��| jdksbtdd� |D ��s|tt �� | � |�S Q R X | j p�d}| j ||d�S | j}t |�d }x^|d d d � D ]L}t �|�r�|d8 }q�t|| j�j ||d�}|d8 }t|��s t|d �s�P q�W |S ) Nr< zToo many indicesc s s | ]}t |t�V qd S )N)rO rS )r] r^ r- r- r0 r_ n s z9_LocationIndexer._getitem_nested_tuple.<locals>.<genexpr>r[ c s s | ]}t |t�V qd S )N)rO r� )r] rk r- r- r0 r_ r s r )rI ���ra )rb ra rF ru rO rG r r| r r6 r� rI r� rd r� r� r �hasattr)r. rz rI rG rW r- r- r0 r� b s, z&_LocationIndexer._getitem_nested_tuple)rI rK c C s t | ��d S )N)r )r. rW rI rK r- r- r0 rV � s z$_LocationIndexer._convert_to_indexerc s� t |�tkrntdd� |D ��}t� fdd�|D ��}� �|�rdttt�� � jj|d� ji�S Q R X � � |�S � j pvd}t � |� j�}� j ||d�S d S )Nc s s" | ]}t |�rt|�n|V qd S )N)r rU )r] rk r- r- r0 r_ � s z/_LocationIndexer.__getitem__.<locals>.<genexpr>c 3 s | ]}t �|� j�V qd S )N)rd rl rG )r] rk )r. r- r0 r_ � s �takeabler )rI )rE rS �_is_scalar_accessr rQ � IndexErrorrG � _get_value� _takeable�_getitem_tuplerI rd rl r� )r. rW rI Zmaybe_callabler- )r. r0 r1 � s z _LocationIndexer.__getitem__c C s t � �d S )N)�NotImplementedError)r. rW r- r- r0 r� � s z"_LocationIndexer._is_scalar_accessc C s t | ��d S )N)r )r. rz r- r- r0 r� � s z _LocationIndexer._getitem_tuplec C s t � �d S )N)r� )r. rW rI r- r- r0 r� � s z _LocationIndexer._getitem_axis)r9 c C s t | ��d S )N)r )r. ro r- r- r0 rm � s z+_LocationIndexer._has_valid_setitem_indexerc C s2 | j �|�}t||�}|�� d }| j j||d�S )Nr )rI )rG rN �check_bool_indexer�nonzero�_take_with_is_copy)r. rW rI �labels�indsr- r- r0 � _getbool_axis� s z _LocationIndexer._getbool_axis)N)NN)F)F)r2 r3 r4 �__annotations__rI rJ rZ rL rp rr rx r~ rM rs r� r� r� rV r1 r� r� r� rm r� r- r- r- r0 rB t s* # % 51rB c @ s� e Zd ZU dZded< dZeej�dd�dd��Zdd �d d �Z d dd �dd�Z d dd�dd�Z d d�dd�Z dd�dd�Z d d�dd�Zdd�dd�Zd d�d d �Zdd�d d �Zd dd!�d"d#�Zd,ddd$�d%d&�Zdd�d'd(�Zdd�d)d*�Zd+S )-r; Fry r� z�labels (MUST BE IN THE INDEX), slices of labels (BOTH endpoints included! Can be slices of integers if the index is integers), listlike of labels, booleanrq )rI c C sX t |t�r$t| jj�s$t|� d���t |t�rTt |jt�sFt |jt�rTt |� d���d S )Nz7: boolean label can not be used without a boolean indexz+: boolean values can not be used in a slice) rO ry r rG �indexrQ r� �start�stoprP )r. rW rI r- r- r0 rr � s z_LocIndexer._validate_key)r9 c C s dS )NTr- )r. ro r- r- r0 rm � s z&_LocIndexer._has_valid_setitem_indexerrS )rW r9 c C sp t |�| jkrdS xXt|�D ]L\}}t|�s0dS | jj| }t|t�rJdS t|t�r^|j r^dS |j s dS q W dS )z6 Returns ------- bool FT) rb ra rt r rG r} rO r( rC �!_supports_partial_string_indexing�_index_as_unique)r. rW rv r^ rX r- r- r0 r� � s z _LocIndexer._is_scalar_access)rz r9 c C s* t dd� |D ��sdS tdd� |D �� S )a� Check whether there is the possibility to use ``_multi_take``. Currently the limit is that all axes being indexed, must be indexed with list-likes. Parameters ---------- tup : tuple Tuple of indexers, one per axis. Returns ------- bool Whether the current indexing, can be passed through `_multi_take`. c s s | ]}t |�V qd S )N)r# )r] rk r- r- r0 r_ s z6_LocIndexer._multi_take_opportunity.<locals>.<genexpr>Fc s s | ]}t �|�V qd S )N)rd re )r] rk r- r- r0 r_ s )rf r| )r. rz r- r- r0 �_multi_take_opportunity� s z#_LocIndexer._multi_take_opportunity)rz c s. � fdd�t |� jj�D �}� jj|ddd�S )a� Create the indexers for the passed tuple of keys, and executes the take operation. This allows the take operation to be executed all at once, rather than once for each dimension. Improving efficiency. Parameters ---------- tup : tuple Tuple of indexers, one per axis. Returns ------- values: same type as the object being indexed c s i | ]\}}� � ||�|�qS r- )�_get_listlike_indexer)r] rW rI )r. r- r0 � <dictcomp># s z+_LocIndexer._multi_take.<locals>.<dictcomp>T)�copy� allow_dups)�ziprG Z _AXIS_ORDERS�_reindex_with_indexers)r. rz �dr- )r. r0 � _multi_take s z_LocIndexer._multi_takec C s6 | � ||� | �||�\}}| jj|||giddd�S )a� Index current object with an iterable collection of keys. Parameters ---------- key : iterable Targeted labels. axis : int Dimension on which the indexing is being made. Raises ------ KeyError If no key was found. Will change in the future to raise if not all keys were found. Returns ------- scalar, DataFrame, or Series: indexed value(s). T)r� r� )rr r� rG r� )r. rW rI �keyarrro r- r- r0 �_getitem_iterable+ s z _LocIndexer._getitem_iterablec C sB t t�� | �|�S Q R X | �|� | �|�r8| �|�S | �|�S )N)r r6 r� rx r� r� r� )r. rz r- r- r0 r� J s z_LocIndexer._getitem_tuplec C s | j j||d�S )N)rI )rG Zxs)r. �labelrI r- r- r0 � _get_labelW s z_LocIndexer._get_labelc C s� | j pd}y| j||d�S ttfk r0 Y nJ tk rx } z,| jt|� k r`| jjj krhn n|�W d d }~X Y nX t d��d S )Nr )rI zNo label returned) rI r� rP r rQ ra rb rG r� �nlevelsr6 )r. rz rI Zekr- r- r0 r� [ s $z._LocIndexer._handle_lowerdim_multi_index_axis0c C s t |�}t|�rt|�}| j�|�}|�|�}t|t�rR| �||� | j ||d�S t � |�rj| j ||d�S t |�r�t|t�r�t|t�s�t|d�r�|jdkr�td��| j||d�S t||�r�|�|�}td �g| j }|||< | jjt|� S | �||� | j||d�S )N)rI ra r[ z&Cannot index with multidimensional key)r r rU rG rN Z'_get_partial_string_timestamp_match_keyrO r� rr �_get_slice_axisrd re r� r# rS r( r� ra ru r� r{ �get_locsr: r� )r. rW rI r� Zlocsro r- r- r0 r� l s, z_LocIndexer._getitem_axisr� )� slice_objrI c C sf | j }t|�s|jdd�S |�|�}|�|j|j|j�}t|t �rR| j j ||d�S | j j ||d�S dS )zL This is pretty simple as we just have to deal with labels. F)�deep)rI N) rG � need_slicer� rN Z slice_indexerr� r� �steprO r� �_slice�take)r. r� rI rG r� ro r- r- r0 r� � s z_LocIndexer._get_slice_axis)rI rK c C s� | j �|�}t|t�r$|j|dd�S |�� }t|�o8| }t|�sLt|t�r�y |�|�S t k r� t|t �r�t|t�r�t |�|j kr�d|iS � Y nJ t k r� t|t�s�� Y n, tk r� Y n tk r� |sڂ Y nX |r�d|iS t||��r,t| j t��r"tdd� |D ���r"td��|�|�S t|��r~t|��rHt|�}t�|��rlt||�}|�� \}|S | �||�d S n6y |�|�S t k �r� t|��s�d|iS � Y nX dS ) a� Convert indexing key into something we can use to do actual fancy indexing on a ndarray. Examples ix[:5] -> slice(0, 5) ix[[1,2,3]] -> [1,2,3] ix[['foo', 'bar', 'baz']] -> [i, j, k] (indices of foo, bar, baz) Going by Zen of Python? 'In the face of ambiguity, refuse the temptation to guess.' raise AmbiguousIndexError with integer labels? - No, prefer label-based indexing r< )�kindrW c s s | ]}t |t�V qd S )N)rO rS )r] r^ r- r- r0 r_ � s z2_LocIndexer._convert_to_indexer.<locals>.<genexpr>zToo many indicesr[ N) rG rN rO r� �_convert_slice_indexerr r r( rR � LookupErrorrS rb r� r rP ru r{ r r| r� r# r rU rd re r� r� r� )r. rW rI rK r� Z is_int_indexZis_int_positionalr� r- r- r0 rV � sT z _LocIndexer._convert_to_indexerc C s� | j �|�}|}t|t�s$t�|�}t|t�rX|�|�}|dk rX|dk�� rX|| |fS |j rx|� |�}|� |�d }n|� |�\}}}| � |||� t|j�s�t|ttf�r�|�|�}|jjdkr�t|t�s�t|t|��r�|jdkr�|�d�}||fS )aJ Transform a list-like of keys into a new index and an indexer. Parameters ---------- key : list-like Targeted labels. axis: int Dimension on which the indexing is being made. Raises ------ KeyError If at least one key was requested but none was found. Returns ------- keyarr: Index New index (coinciding with 'key' if the axis is unique). values : array-like Indexer for the return object, -1 denotes keys not found. Nr� r )�m�M)rG rN rO r& rd Zasarray_tuplesafer( Z_convert_listlike_indexerrf r� �get_indexer_for�reindexZ_reindex_non_unique�_validate_read_indexerr �dtyper' r% r� r� rU rE �freqZ _with_freq)r. rW rI rX r� ro � new_indexerr- r- r0 r� � s* z!_LocIndexer._get_listlike_indexerc C s� t |�dkrdS |dk }|�� }|r�| j�|�}t|t�pNt|t�oNt|jt�}|t |�kr�| j�|�}|rtt |�}t d|� d|� d���t t |�|� � d � � �} t | � d���dS )an Check that indexer can be used to return a result. e.g. at least one element was found, unless the list of keys was actually empty. Parameters ---------- key : list-like Targeted labels (only used to show correct error message). indexer: array-like of booleans Indices corresponding to the key, (with -1 indicating not found). axis : int Dimension on which the indexing is being made. Raises ------ KeyError If at least one key was requested but none was found. r Nz None of [z] are in the [�]z not in index)rb �sumrG rN rO r' r% � categoriesZ_get_axis_namerU rQ r) r� �unique) r. rW ro rI Z missing_mask�missingrX Zuse_interval_msgZ axis_name� not_foundr- r- r0 r� 3 s z"_LocIndexer._validate_read_indexerN)F)r2 r3 r4 r� r� rD r rB rr rm r� r� r� r� r� r� r� r� r� rV r� r� r- r- r- r0 r; � s " "R@r; c @ s" e Zd ZdZdZdd�dd�Zdd�d d �Zd dd �d d�Zdddd�dd�Zd d�dd�Z dd�dd�Z dd�dd�Z ddd�d d �Z dBddd �d d!�Z d"d#� ZdCd%d&�Zd'd(�d)d*�Zd+d,� Zd-d'd.�d/d0�Zdd1�d2d3�Zd'd(�d4d5�Zd6d7� Zd8d9� ZdDd:dd;�d<d=�Zd-d>�d?d@�ZdAS )Er8 zlinteger, integer slice (START point is INCLUDED, END point is EXCLUDED), listlike of integers, boolean arrayTrq )rI c C s� t �|�r@t|d�r<t|jt�r<|jjdkr4td��td��d S t|t �rNd S t |�rd| � ||� n�t|t �rxt d��nxt|�r�t�|�}t| j�|��}t|j�s�td|� ���t|�r�|�� |ks�|�� | k r�td��ntd| j� d ���d S ) Nr� �integerzDiLocation based boolean indexing on an integer type is not availablezBiLocation based boolean indexing cannot use an indexable as a maskzToo many indexersz%.iloc requires numeric indexers, got z%positional indexers are out-of-boundsz#Can only index by location with a [r� )rd re r� rO r� r& Z inferred_typer� ru r� r �_validate_integerrS r6 r# �npr rb rG rN r r� r� �max�minrD )r. rW rI �arr�len_axisr- r- r0 rr o s, " z_iLocIndexer._validate_keyry )r9 c C s� t |t�rtd��t |t�r,tjdtdd� t |t�sBt| j |�}x`t | j j |�D ]N\}}t |t �rfqRt|�rpqRt|�r�|t|�kr�td��qRt |t�rRtd��qRW dS )z� Validate that a positional indexer cannot enlarge its target will raise if needed, does not modify the indexer externally. Returns ------- bool z%iloc cannot enlarge its target objectz�DataFrame indexer for .iloc is deprecated and will be removed ina future version. consider using .loc with a DataFrame indexer for automatic alignment.� )� stacklevelT)rO �dictr� r �warnings�warn� FutureWarningrS �_tuplifyra r� rG r} r� r# r rb )r. ro rX rv r- r- r0 rm � s( z'_iLocIndexer._has_valid_setitem_indexerrS )rW r9 c C s$ t |�| jkrdS tdd� |D ��S )z6 Returns ------- bool Fc s s | ]}t |�V qd S )N)r )r] r^ r- r- r0 r_ � s z1_iLocIndexer._is_scalar_access.<locals>.<genexpr>)rb ra rf )r. rW r- r- r0 r� � s z _iLocIndexer._is_scalar_accessr� )rW rI r9 c C s. t | j�|��}||ks"|| k r*td��dS )a@ Check that 'key' is a valid position in the desired axis. Parameters ---------- key : int Requested position. axis : int Desired axis. Raises ------ IndexError If 'key' is not a valid position in axis 'axis'. z*single positional indexer is out-of-boundsN)rb rG rN r� )r. rW rI r� r- r- r0 r� � s z _iLocIndexer._validate_integer)rz c C s. | � |� tt�� | �|�S Q R X | �|�S )N)rx r r6 r� r� )r. rz r- r- r0 r� � s z_iLocIndexer._getitem_tuplec C sB y| j j||d�S tk r< } ztd�|�W dd}~X Y nX dS )a Return Series values by list or array of integers. Parameters ---------- key : list-like positional indexer axis : int Returns ------- Series object Notes ----- `axis` can only be zero. )rI z%positional indexers are out-of-boundsN)rG r� r� )r. rW rI rw r- r- r0 �_get_list_axis� s z_iLocIndexer._get_list_axisc C s� t |t�rtd��t |t�r*| j||d�S t|�r:t|�}t |t�rNt�|�}t � |�rr| � ||� | j ||d�S t |�r�| j||d�S t|�}t|�s�td��| �||� | jj||d�S d S )NzWDataFrame indexer is not allowed for .iloc Consider using .loc for automatic alignment.)rI z5Cannot index by location index with a non-integer key)rO r r� r� r� r rU r� �asarrayrd re rr r� r# r� r r rP r� rG �_ixs)r. rW rI r- r- r0 r� � s& z_iLocIndexer._getitem_axisr� )r� rI c C s> | j }t|�s|jdd�S |�|�}|�|� | j j||d�S )NF)r� )rI )rG r� r� rN Z_validate_positional_slicer� )r. r� rI rG r� r- r- r0 r� " s z _iLocIndexer._get_slice_axisF)rI rK c C s |S )zL Much simpler as we only have to deal with our valid types. r- )r. rW rI rK r- r- r0 rV - s z _iLocIndexer._convert_to_indexerc C s t |�rt|�S |S )N)r rU )r. rW r- r- r0 rZ 3 s z!_iLocIndexer._get_setitem_indexerr: c C s� | j j}| j jj }|sft| j jdd�rf| jdkrft|t�rHt|� � �n|}| j jj d }|� |� }t|t �r�t |�t | j j�kr�x<t|| j j�D ]*\}} t| t�r�t|�s�t�|�s�d}P q�W t|t ��r�g } �x�t|�D �]�\}} t| t��r�t| �\} } | jdk�r�||k�r�t | j ��sBt|��s4td��|| j | < dS t�|d ��r`|| j | < dS t|��r�t|dd�}d tjt | j �tj d � }t � ||�}t|t ��s�|||d < || j | < dS || j | < nt |�| j | < t!|| j j�}| �"|||� dS | j �#|�}|�$t |�| �}tj%t |�d tj d �}d |d < |||fi}| j j&|dd �}|j| j _| j j'dd � d| j _(| �)|�*| �� q�| �)| � q�W t | �}n"t|�\}}|�r�| �+||� dS |�r�| �,|||� n| �-|||� dS ) a� _setitem_with_indexer is for setting values on a Series/DataFrame using positional indexers. If the relevant keys are not present, the Series/DataFrame may be expanded. This method is currently broken when dealing with non-unique Indexes, since it goes from positional indexers back to labels when calling BlockManager methods, see GH#12991, GH#22046, GH#15686. �blocksFr[ r Tz5cannot set a frame with no defined index and a scalarN)Z extract_numpyr� )r� )r� )�clear).rG �_info_axis_numberrh Zis_single_blockr� ra rO r� rU �valuesr� Z_can_hold_elementrS rb r} r� r( r rd r� rt �convert_missing_indexerr# ru r r r� ZonesZintp�algosZtake_ndr r �"convert_from_missing_indexer_tuplern rN �insert�aranger� �_maybe_update_cacherZ_is_copyr rR � _setitem_with_indexer_missing� _setitem_with_indexer_split_path�_setitem_single_block)r. ro ri rF � info_axisZtake_split_path�valZblkrv rX Znindexerr� rW �_r� ZtakerZ empty_valuer� r� r� Z reindexersZnew_objr� r- r- r0 rn ; s~ z"_iLocIndexer._setitem_with_indexerrC )rF c C s� | j dkst�t|t�s$t| j |�}t|�| j kr:td��t|d tj�r`|d j dkr`t d��t|t �rr|dks|t|t �r�ddl m } | �|||��}|d }| �|�}|d }t|| jj�}t|��rbt|dd�dk�rbt|t�r�| �|||� �q�t� |�dk�r| �||� �q�t|�dk�rT|t|�k�rTt|��sT| �|d ||� �q�t|�dk�r�d| k�r~t|�k�r�n n:t|�dk�r�t|��s�| �||d f|d �S t d ��n�|dk�r�t|�t| jj�k�r�n�t|�t|�k�rxnt ||�D ]\} } | �| | |� �q�W nFt|�dk�rXt � |��rXt| j�dk�rX| �|d ||� nt d ��n x |D ]} | �| ||� �qhW d S ) z& Setitem column-wise. r\ ztoo many indices for arrayr z Cannot set values with ndim > 2r: )r+ r[ ra z@Must have equal len keys and value when setting with an iterableN) ra r� rO rS r� rb r� r� �ndarrayru r r� �pandasr+ � _align_series� _ensure_iterable_column_indexerr$ rG r� r# r� r �!_setitem_with_indexer_frame_value� _setitem_with_indexer_2d_valuer �_setitem_single_columnr rn r� rd r� ) r. ro ri rF r+ r� �ilocs�piZlplane_indexerr< �vr- r- r0 r� � sJ &. * z-_iLocIndexer._setitem_with_indexer_split_pathc C sv |d }| � |d �}tj|td�}t|�|jd kr>td��x2t|�D ]&\}}| �||d d �|f � � |� qHW d S )Nr r[ )r� z?Must have equal len keys and value when setting with an ndarray) r� r� r �objectrb �shaperu rt r� �tolist)r. ro ri r� r� rv r< r- r- r0 r� s z+_iLocIndexer._setitem_with_indexer_2d_valuer* )ri rF c C sT | � |d �}t|�}|d }t| jjt�}|jj}|dkrtx4t|�D ](\} } |jd d �| f } | � | | |� qFW n�|s�|j� | jj�r�x�|D ]V} | jj| } | |kr�| |d< | � t |�|jd d �| f |�} nt j} | � | | |� q�W nf|s�td��nXxV|D ]N} | jj| } | |k�r8| |d< | � t |�|| |�} nt j} | � | | |� q�W d S )Nr[ r r: z/Setting with non-unique columns is not allowed.)r� rU rO rG rc r( � is_uniquert r: r� �equalsr� rS r� �nanru ) r. ro ri rF r� Z sub_indexerr� �multiindex_indexerZ unique_colsrv r< r� �itemr- r- r0 r� - s< z._iLocIndexer._setitem_with_indexer_frame_value)r< c C s� |}| j j|dd�}t�|�s0t�|t| j ��r6|}nft|�rtt||�rtt||�stt |�rj|t � |� }q�|| }n(|� � }|j j|f|d�|_ |jdd� | j �||� dS )z� Parameters ---------- loc : int Indexer for column position plane_indexer : int, slice, listlike[int] The indexer we use for setitem along axis=0. r[ )rI )ro ri T)r� N)rG r� rd r� Z is_full_slicerb r r" r! r r� Zargsortr� rh �setitemr� Z _iset_item)r. r< ri Z plane_indexerr� �serr- r- r0 r� ^ s z#_iLocIndexer._setitem_single_columnc s ddl m} | jj� | j�� �}t|t�r�t|�� kr�t|� �r�t � fdd�t |�D ��r�||� }t|� |g��dkr�|| j|< dS t |� }t|t �r�|dks�t|t�r�| �|||��}n t|t�r�|dkr�| �||�}| j�� | jjj||d�| j_| jjd d � dS ) zQ _setitem_with_indexer for the case when we have a single Block. r )r+ c 3 s$ | ] \}}|� krt �|�V qd S )N)rd r� )r] rv r� )r� r- r0 r_ � s z5_iLocIndexer._setitem_single_block.<locals>.<genexpr>r[ Nr: )ro ri T)r� )r� r+ rG r� rN rO rS rb r rf rt r� �maybe_convert_ixr r� r� r � _align_frameZ%_check_is_chained_assignment_possiblerh r� r� )r. ro ri rF r+ Z item_labelsZselected_item_labelsr- )r� r0 r� � s* z"_iLocIndexer._setitem_single_blockc C sx ddl m} | jdkr�| jj}|�t|�|�}|jr`|�|dd� �}|dk� � r`| � ||d�S ||g�j }t| jj �r�t | jj |g�}| jj ||| jjd�j| j_| jjdd � n�| jd k�rtt| jj�s�td ��t|t�r�|j| jjdd �}||_n\t|t��r||| jj|td �}n:t|��rBt|�t| jj�k�rBtd��||| jj|d�}| j�|�j| j_| jjdd � dS )zN Insert new row(s) or column(s) into the Series or DataFrame. r )r+ r[ r� Nr< )r� rF T)r� r\ z*cannot set a frame with no defined columns)r� r� )r� rF r� z(cannot set a row with mismatched columns)r� r+ ra rG r� r� rb r� � get_indexerr| rn �_valuesr Z _constructorrF rh r� rc ru rO r r� r� r� r# r )r. ro ri r+ r� Z new_indexr� � new_valuesr- r- r0 r� � s: z*_iLocIndexer._setitem_with_indexer_missingc C sd t |�r|g}nPt|t�r2t�t| jj��| }n.t|tj�r\t |j �r\t�t|��| }n|}|S )zX Ensure that our column indexer is something that can be iterated over. ) r rO r� r� r� rb rG rc r� r r� )r. Zcolumn_indexerr� r- r- r0 r� � s z,_iLocIndexer._ensure_iterable_column_indexerr+ )r� r� c C sh t |ttjttf�r|f}t |t��r�dd� }tt||��}dd� |D �}t|�}|dk}| j dk}| j } |rz|ox|d }|| j kr�t dd � |D ��r�|j | j d |d d d �j}t|�dkr�|s�t|d �} t�|| ��| d �j}|S x�t|�D ]�\} } | j | } t| ��s t | t��r�|�r0t�| ��r0q�| | }t|��sNt|g�}nt|�}|j�|��snt|��sx|j�� S |� |�jS |r�| j j d } |j�| ��s�t| ��s�|j�� S |� | �jS q�W n�t|��r"| j dk�r"t | j ��r�|S | j � d�} |j�| ��r|j�� S |� | �j| S t|��r\| j � d�} |j�| ��rP|j�� S |� | �jS t d ��dS )aT Parameters ---------- indexer : tuple, slice, scalar Indexer used to get the locations that will be set to `ser`. ser : pd.Series Values to assign to the locations specified by `indexer`. multiindex_indexer : bool, optional Defaults to False. Should be set to True if `indexer` was from a `pd.MultiIndex`, to avoid unnecessary broadcasting. Returns ------- `np.array` of `ser` broadcast to the appropriate shape for assignment to the locations selected by `indexer` c S s t | tj�r| �� S | S )N)rO r� r� �ravel)rv r- r- r0 r s z)_iLocIndexer._align_series.<locals>.ravelc S s g | ]}t �|� �qS r- )rd r� )r] r� r- r- r0 � <listcomp> s z._iLocIndexer._align_series.<locals>.<listcomp>r[ r\ r c s s | ]}t |�V qd S )N)r )r] r� r- r- r0 r_ / s z-_iLocIndexer._align_series.<locals>.<genexpr>T)r� r� z Incompatible indexer with SeriesN) rO r� r� r� rU r& rS �mapr� ra rG rf r� r} r rb ZtileZreshape�Trt r rd r� r# r� r� r� r r rN ru )r. ro r� r� r ZalignersZ sum_alignersZsingle_aligner�is_framerG Z len_indexerrv r� rX Znew_ixr- r- r0 r� s` z_iLocIndexer._align_series)�dfc C st | j dk}t|t�r�d\}}g }xxt|�D ]l\}}| jj| } t|�sPt|t�r�t|tj �rd|� � }|d krv| | }q�|d kr�| | }q�P q*|� |� q*W |d k r�|d k r�|j � |�r�|j� |�r�|�� j} n|j||d�j} | S n�t|t�s�t|��rh|�rh| jj | } |j � | ��r$|�� j} n@t| t��rVt|j t��rV| j|j jk�rVtd��|j| d�j} | S td��d S )Nr\ )NN)rc zAcannot align on a multi-index with out specifying the join levels)r� z#Incompatible indexer with DataFrame)ra rO rS rt rG r} r r� r� r� r r r� r� rc r� r r� r# r( r� rP ru ) r. ro r r r� �colsZ sindexersrv ZixrX r� r- r- r0 r g s@ z_iLocIndexer._align_frameN)F)r: )F)r2 r3 r4 rD r� rr rm r� r� r� r� r� r� rV rZ rn r� r� r� r� r� r� r� r� r r- r- r- r0 r8 d s. %'# U1(-?er8 c @ s0 e Zd ZdZd dd�dd�Zdd� Zd d � Zd S ) �_ScalarAccessIndexerz! Access scalars quickly. Fry )rK c C s t | ��d S )N)r )r. rW rK r- r- r0 � _convert_key� s z!_ScalarAccessIndexer._convert_keyc C s@ t |t�s"t|�s|f}ntd��| �|�}| jj|d| ji�S )Nz)Invalid call for scalar access (getting)!r� )rO rS r# ru r rG r� r� )r. rW r- r- r0 r1 � s z _ScalarAccessIndexer.__getitem__c s� t |t�r"t� fdd�|D ��}nt�|� j�}t |t�sFt� j|�}t� j|dd��}t |�� jkrnt d��� jj ||� j d�� d S )Nc 3 s | ]}t �|� j�V qd S )N)rd rl rG )r] rk )r. r- r0 r_ � s z3_ScalarAccessIndexer.__setitem__.<locals>.<genexpr>T)rK z0Not enough indexers for scalar access (setting)!)ri r� ) rO rS rd rl rG r� ra rU r rb ru Z _set_valuer� )r. rW ri r- )r. r0 rp � s z _ScalarAccessIndexer.__setitem__N)F)r2 r3 r4 r5 r r1 rp r- r- r- r0 r � s r c sN e Zd ZdZd dd�dd�Zedd�dd��Z� fd d �Z� fd d �Z� Z S )r= Fry )rK c C s, | j dkr t|�dkr |f}|r(t|�S |S )zd Require they keys to be the same type as the index. (so we don't fallback) r[ )ra rb rU )r. rW rK r- r- r0 r � s z_AtIndexer._convert_key)r9 c C s" | j dkst�| jjjo | jjjS )Nr\ )ra r� rG r� r� rc )r. r- r- r0 �_axes_are_unique� s z_AtIndexer._axes_are_uniquec sL | j dkr@| js@t|t�r,tdd� |D ��s4td��| jj| S t� � |�S )Nr\ c s s | ]}t |�V qd S )N)r )r] rk r- r- r0 r_ � s z)_AtIndexer.__getitem__.<locals>.<genexpr>z)Invalid call for scalar access (getting)!) ra r rO rS rf ru rG r< �superr1 )r. rW )� __class__r- r0 r1 � s z_AtIndexer.__getitem__c sR | j dkrD| jsDt|t�r,tdd� |D ��s4td��|| jj|< d S t� � ||�S )Nr\ c s s | ]}t |�V qd S )N)r )r] rk r- r- r0 r_ � s z)_AtIndexer.__setitem__.<locals>.<genexpr>z)Invalid call for scalar access (setting)!) ra r rO rS rf ru rG r< r rp )r. rW ri )r r- r0 rp � s z_AtIndexer.__setitem__)F) r2 r3 r4 r� r rA r r1 rp � __classcell__r- r- )r r0 r= � s r= c @ s e Zd ZdZddd�dd�ZdS ) r? TFry )rK c C s" x |D ]}t |�std��qW |S )zH Require integer args. (and convert to label arguments) z1iAt based indexing can only have integer indexers)r ru )r. rW rK rv r- r- r0 r � s z_iAtIndexer._convert_keyN)F)r2 r3 r4 r� r r- r- r- r0 r? � s r? rq r z tuple[Hashable | slice, ...])ra r< r9 c C s" dd� t | �D �}||d< t|�S )z� Given an indexer for the first dimension, create an equivalent tuple for indexing over all dimensions. Parameters ---------- ndim : int loc : object Returns ------- tuple c S s g | ]}t d d ��qS )N)r� )r] r� r- r- r0 r s z _tuplify.<locals>.<listcomp>r )rT rS )ra r< Z_tupr- r- r0 r� � s r� r* )rG c C s~ | j }t|t�r |j|dd�S t|t�rz|| jkr6dS |jrzy"|�t|��}tj dt dd� |S t t t fk rx dS X dS )zR If we are index sliceable, then return my slicer, otherwise return None. �getitem)r� Nz�Indexing a DataFrame with a datetimelike index using a single string to slice the rows, like `frame[string]`, is deprecated and will be removed in a future version. Use `frame.loc[string]` instead.r� )r� )r� rO r� r� rC rc r� Z_get_string_slicer� r� r� rQ ru r� )rG rW r� �resr- r- r0 �convert_to_index_sliceable s" r r& z np.ndarray)r� r9 c C s� |}t |t�rJ|j�| �sJ|�| �}t|j�}|�� r>td��|� t �jS t |�rbt j |t d�}nt|�svt|t d�}t| |�S )aL Check if key is a valid boolean indexer for an object with such index and perform reindexing or conversion if needed. This function assumes that is_bool_indexer(key) == True. Parameters ---------- index : Index Index of the object on which the indexing is done. key : list-like Boolean indexer to check. Returns ------- np.array Resulting key. Raises ------ IndexError If the key does not have the same length as index. IndexingError If the index of the key is unalignable to index. ztUnalignable boolean Series provided as indexer (index of the boolean Series and of the indexed object do not match).)r� )rO r r� r� r� r r r| r6 Zastypery r r� r� r �pd_arrayr )r� rW �result�maskr- r- r0 r� 5 s r� c C s4 t | t�r,| d } t | t�r$td��| dfS | dfS )z� Reverse convert a missing indexer, which is a dict return the scalar indexer and a boolean indicating if we converted rW z.cannot use a single bool to index into setitemTF)rO r� ry rQ )ro r- r- r0 r� d s r� c s& � fdd��t �fdd�t| �D ��S )zK Create a filtered indexer that doesn't have any missing indexers. c s t |t�r � | �|d �S |S )NrW )rO r� rR )�_i�_idx)r} r- r0 r z s z7convert_from_missing_indexer_tuple.<locals>.get_indexerc 3 s | ]\}}� ||�V qd S )Nr- )r] r r )r r- r0 r_ } s z5convert_from_missing_indexer_tuple.<locals>.<genexpr>)rS rt )ro r} r- )r} r r0 r� u s r� c G s0 x$| D ] }t |tjtttf�s| S qW tj| � S )z3 We likely want to take the cross-product. )rO r� r� rU r r& Zix_)�argsr/ r- r- r0 r � s r ry )r9 c C s< t | t�sdS x(| D ] }t|�s*t |t�rt |t�S qW dS )z& Returns ------- bool F)rO rS r r� r( )rz r� r^ r- r- r0 r{ � s r{ c C s t | t� ot| � S )z& Returns ------- bool )rO r� r# )rW r- r- r0 r� � s r� r� )rG r9 c C s( | j dk p&| jdk p&| jdk o&| jdkS )z& Returns ------- bool Nr[ )r� r� r� )rG r- r- r0 r� � s r� )]� __future__r � contextlibr �typingr r r r r� �numpyr� Zpandas._libs.indexingr Zpandas._libs.libr Z pandas.errorsr r Zpandas.util._decoratorsr Zpandas.core.dtypes.commonr r r r r r r r r r r Zpandas.core.dtypes.concatr Zpandas.core.dtypes.genericr r Zpandas.core.dtypes.missingr r Z pandas.corer r� Zpandas.core.common�core�commonrd Zpandas.core.constructionr r r Zpandas.core.indexersr r! r" r# r$ Zpandas.core.indexes.apir% r& r' r( r) r� r* r+ r� r� r, Z IndexSlice� Exceptionr6 r7 rB r< r; r: r8 r r> r= r@ r? r� r r� r� r� r r{ r� r� r- r- r- r0 �<module> sr 4 , w G - =$0 "/
| ver. 1.4 |
Github
|
.
| PHP 8.3.23 | Генерация страницы: 0.03 |
proxy
|
phpinfo
|
Настройка