U
|
¬ý°dPk ã @ sî d dl mZ d dlmZ d dlZd dlmZmZmZm Z m
|
Z
|
m Z d dl Z d dl Zd dlmZ d dlmZ d dlmZ d dlmZmZ d d lmZ d d
|
lmZm 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(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5m6Z6 d dl7m8Z8m9Z9m:Z:m;Z; d dl<m=Z> d dl?m@ mAZB d dlCmDZEmFZF d dlGmHZHmIZImJZJmKZK d dlLmMZMmNZN er d dlOmPZPmQZQ e dddZReSddZTdZUG dd dZVeV ZWG d d d ZXG d d deZYe"eXjZG d d d eYZ[e"eXj\G d!d" d"eYZ]G d#d$ d$eZ^e"eXj_G d%d& d&e^Z`e"eXjaG d'd( d(e^Zbd)d*d+d,d-d.Zcd)d/d0d1d2d3Zdd4d5d6d7d8Zed9d: Zfd;d< Zgd=d> Zhd?d@dAdBZid?d@dCdDZjdEd?dFdGdHZkdId@dJdKZldS )Lé )Ú annotations)ÚsuppressN)Ú TYPE_CHECKINGÚHashableÚSequenceÚTypeVarÚcastÚfinal)Úusing_copy_on_write)ÚNDFrameIndexerBase)Úitem_from_zerodim)ÚAxisÚAxisInt)ÚPYPY)ÚAbstractMethodErrorÚChainedAssignmentErrorÚ IndexingErrorÚInvalidIndexErrorÚLossySetitemErrorÚ_chained_assignment_msg)Údoc)Úcan_hold_elementÚ maybe_promote) Ú is_array_likeÚ is_bool_dtypeÚis_extension_array_dtypeÚ is_hashableÚ
|
is_integerÚ is_iteratorÚ is_list_likeÚis_numeric_dtypeÚis_object_dtypeÚ is_scalarÚ is_sequence)Ú concat_compat)Ú ABCDataFrameÚ ABCSeries)Úinfer_fill_valueÚis_valid_na_for_dtypeÚisnaÚna_value_for_dtype)Ú
|
algorithms)ÚarrayÚ extract_array)Úcheck_array_indexerÚis_list_like_indexerÚis_scalar_indexerÚlength_of_indexer)ÚIndexÚ
|
MultiIndex)Ú DataFrameÚSeriesÚ_LocationIndexerTÚ_LocationIndexer)Úboundz(indexer may only contain one '...' entryc @ 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; úKd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/indexing.pyÚ __getitem__ s z_IndexSlice.__getitem__N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r? r; r; r; r> r9 ` s 'r9 c @ sX e Zd ZdZeddddZeddddZed dd
|
d Zed dd dZdS )Ú IndexingMixinzH
|
Mixin for adding .loc/.iloc/.at/.iat to Dataframes and Series.
|
Ú _iLocIndexer©Úreturnc C s
|
t d| S )aÙ
|
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.
|
- A tuple of row and column indexes. The tuple elements consist of one of the
|
above inputs, e.g. ``(0, 1)``.
|
|
``.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)rE ©r< r; r; r> rH 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
|
|
Please see the :ref:`user guide<advanced.advanced_hierarchical>`
|
for more details and explanations of advanced indexing.
|
Úloc)rJ rI r; r; r> rK 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 getting a value and 'label' does not exist in a DataFrame or
|
Series.
|
ValueError
|
* If row/column label pair is not a tuple or if any label from
|
the pair is not a scalar for DataFrame.
|
* If label is list-like (*excluding* NamedTuple) for Series.
|
|
See Also
|
--------
|
DataFrame.at : Access a single value for a row/column pair by label.
|
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).
|
DataFrame.iloc : Access a group of rows and columns by integer
|
position(s).
|
Series.at : Access a single value by label.
|
Series.iat : Access a single value by integer position.
|
Series.loc : Access a group of rows by label(s).
|
Series.iloc : Access a group of rows by integer position(s).
|
|
Notes
|
-----
|
See :ref:`Fast scalar value getting and setting <indexing.basics.get_value>`
|
for more details.
|
|
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)rL rI r; r; r> rM & 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)rN rI r; r; r> rO g s .zIndexingMixin.iatN) r@ rA rB rC ÚpropertyrH rK rM rO r; r; r; r> rD s @rD c @ s e Zd ZU ded< dZded< ded< ed>dd dd
|
d d Zd d Zedd Zed?ddddZ eddddZ
|
ddddZ eddd d d Z eddd d d!Z eddd d"d#Zeddd d$d%Zeddd d&d'Zedd(d)d*Zedd(d+d,Zedd(d-d.Zddd/d0Zed1d2 Zdd3d4d5Zdd(d6d7Zddd8d9Zddd:d;Zeddd<d=ZdS )@r7 ÚstrÚ _valid_typesNzAxisInt | NoneÚaxisÚboolÚ _takeabler6 z Axis | None)r< rS rG c C s6 t | | j| j}|d k r(| j |¡}n|}||_|S r: )ÚtypeÚnameÚobjÚ_get_axis_numberrS )r< rS Znew_selfZ axis_int_noner; r; r> Ú__call__ s z_LocationIndexer.__call__c
|
C sê | j dkr| |¡ t|tr0|D ] }t| q"| jdk rJt| j| j|}| j d¡}t|t
|
r| j dkrt |rt t t | |¡W 5 Q R £ S Q R X t|trÊt t | |¡W 5 Q R £ S Q R X t|trÜt|}| j|ddS )zR
|
Convert a potentially-label-based key into a positional indexer.
|
rK Nr rH ©rS )rW Ú_ensure_listlike_indexerÚ
|
isinstanceÚtupleÚcheck_dict_or_set_indexersrS Ú_tupleize_axis_indexerÚndimrX Ú _get_axisr3 r r ÚKeyErrorr Úget_locr Ú_convert_tupleÚrangeÚlistÚ_convert_to_indexer)r< ÚkeyÚxÚaxr; r; r> Ú_get_setitem_indexer s"
|
|
|
|
|
|
|
|
z%_LocationIndexer._get_setitem_indexerc C sn t |trNt|dkrNt |ttfrN|\}}|j}t |¡rft|t|krf| ¡ d }t || jd r°|dkr°t|dkr|j
|
dd
}n| j j
|
||¡}||f}nt |t jrf|jjdkrft|dkrf|dkrü| j j
|
||¡}||f}nP|dkrf|jd dkrft|dkr4|j
|
dd
}n| j j
|
||¡}||f}nt |¡rf| ¡ d }||fS )a
|
If we have obj.iloc[mask] = series_or_frame and series_or_frame has the
|
same length as obj, we treat this as obj.iloc[mask] = series_or_frame[mask],
|
similar to Series.__setitem__.
|
|
Note this is only for loc, not iloc.
|
é r é NÚi)r] r^ Úlenr& r% ra ÚcomÚis_bool_indexerÚnonzeror0 rH rX Ú _align_seriesÚnpÚndarrayÚdtypeÚkindÚshapeÚ _align_frame)r< ÚindexerÚvalueÚpiZicolsra Znewkeyr; r; r> Ú_maybe_mask_setitem_valueÎ s@ ÿ
|
þ ý
|
|
ÿ
|
þ
|
ý
|
|
z*_LocationIndexer._maybe_mask_setitem_valueÚNonerF c
|
C s& d}| j dkrdS |}t|tr8t|dkr8|| }|}||kr"t| jjts"t|r"t |¡s"t
|
dd |D r"| jjj |dd}t |j | jjdd}t|r
|
t |d ¡r
|
tjt|tjd }d
|
|t| jjd
< | jjj||dd d d } | | j_dS | jjj|dd 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
|
rn rm Nc s s | ]}t |V qd S r: )r ©Ú.0Úkr; r; r> Ú <genexpr>' s z<_LocationIndexer._ensure_listlike_indexer.<locals>.<genexpr>F)Úsortr ©rw éÿÿÿÿT)r{ rS Ú
|
only_sliceZ use_na_proxy)rS r )ra r] r^ rp rX Úcolumnsr3 r/ rq rr ÚallÚunionr2 Ú
|
differenceÚ is_null_sliceru ÚarangeÚintpÚ_mgrZreindex_indexerZ reindex_axis)
|
r< ri rS r| Z column_axisZorig_keyÚkeysZdiffr{ Znew_mgrr; r; r> r\ s@
|
ÿ þýüû ÿz)_LocationIndexer._ensure_listlike_indexerc s² t s*t r*t j¡dkr*tjttdd t | t
|
|t rft dd |D }t fdd|D }nt | j¡} |¡} |¡ jdkr n jj}| || j¡ d S )Nrm )Ú
|
stacklevelc s s" | ]}t |rt|n|V qd S r: ©r rg ©r rj r; r; r> r I s z/_LocationIndexer.__setitem__.<locals>.<genexpr>c 3 s | ]}t | j¡V qd S r: ©rq Úapply_if_callablerX r rI r; r> r J s rH )r r
|
ÚsysÚ getrefcountrX ÚwarningsÚwarnr r r_ r] r^ rq r rl Ú_has_valid_setitem_indexerrW rH Ú_setitem_with_indexer)r< ri r| r{ rH r; rI r> Ú __setitem__? s
|
ÿ
|
|
|
z _LocationIndexer.__setitem__r r[ 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< ri rS r; r; r> Ú _validate_keyS s z _LocationIndexer._validate_keyr^ ©ÚtuprG c C sj t dd |D rf| t¡dkr(ttt|| jkrf| t¡}|d|
tf ||d d
}|S |S )zt
|
If a tuple key includes an Ellipsis, replace it with an appropriate
|
number of null slices.
|
c s s | ]}|t kV qd S r: )ÚEllipsisr r; r; r> r o s z4_LocationIndexer._expand_ellipsis.<locals>.<genexpr>rn N) ÚanyÚcountr¢ r Ú_one_ellipsis_messagerp ra ÚindexÚ_NS)r< r¡ ro Únew_keyr; r; r> Ú_expand_ellipsisi s
|
"z!_LocationIndexer._expand_ellipsis©ri rG c C sr | |¡}| |¡}t|D ]P\}}z| ||¡ W q tk
|
rj } ztd| j d|W 5 d}~X Y q X q |S )zA
|
Check the key for valid keys across my indexer.
|
z'Location based indexing can only have [z] typesN)Ú_validate_key_lengthr© Ú enumerater Ú
|
ValueErrorrR )r< ri ro r Úerrr; r; r> Ú_validate_tuple_indexer s
|
|
ÿýz(_LocationIndexer._validate_tuple_indexerc s4 t dd | jjD r0t fdd| jjD S dS )ú6
|
Returns
|
-------
|
bool
|
c s s | ]}t |tV qd S r: )r] r3 ©r rk r; r; r> r s z<_LocationIndexer._is_nested_tuple_indexer.<locals>.<genexpr>c 3 s | ]}t |V qd S r: )Úis_nested_tupler± ©r¡ r; r> r s F)r£ rX Úaxes©r< r¡ r; r³ r> Ú_is_nested_tuple_indexer s z)_LocationIndexer._is_nested_tuple_indexerc s( |¡ fddt|D }t|S )Nc s g | ]\}} j ||d qS )r[ )rh )r ro r rI r; r> Ú
|
<listcomp> s z3_LocationIndexer._convert_tuple.<locals>.<listcomp>)r« r¬ r^ )r< ri Zkeyidxr; rI r> re s
|
z _LocationIndexer._convert_tuplec C sL t || jkrH|d tkr@|dd
}t|kr6tt| |¡S td|S )Nr rn úToo many indexers)rp ra r¢ r r¥ r« ©r< ri r; r; r> r« ¢ s
|
z%_LocationIndexer._validate_key_lengthr³ c C sd | j }t|D ]:\}}t |¡r"qt|| jj||d}|j| jkstq|| j kr`|j dd}|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.
|
r[ F©Údeep)
|
rX r¬ rq r ÚgetattrrW Ú _getitem_axisra ÚAssertionErrorÚcopy)r< r¡ Úretvalro ri r; r; r> Ú_getitem_tuple_same_dim® s
|
|
z(_LocationIndexer._getitem_tuple_same_dimc
|
C s` | j d k r&| j | j ¡}| j||dS | |¡r:| |¡S | j d¡}t|tr| j dkrt
|
dd |D st t t t| |¡W 5 Q R £ S Q R X | |¡}t|D ]¨\}}t|rª| j||d}|j| jkrø|d |
tf ||d d
}n2|d |
||d d
}t|dkr*|d }t |¡r>| S t|| j | S qªt dd S )Nr[ r rH c s s | ]}t |tV qd S r: )r] Úslicer r; r; r> r Ù s z5_LocationIndexer._getitem_lowerdim.<locals>.<genexpr>rn znot applicable)rS rX rY r½ r¶ Ú_getitem_nested_tuplerb r] r3 rW r£ r r r rJ Ú"_handle_lowerdim_multi_index_axis0r« r¬ Ú is_label_likera r§ rp rq r r¼ )r< r¡ rS Zax0ro ri Úsectionr¨ r; r; r> Ú_getitem_lowerdimÇ s6
|
|
|
ÿþý
|
"
|
$ z"_LocationIndexer._getitem_lowerdimc
|
C s& |D ] }t | qt|| jkr°| jdkr2tdtdd |D rrtt tt |
|
|¡W 5 Q R £ S Q R X n&t | j t rtdd |D rtd| jp d}| j||dS | j }t|d }|d d d
|
D ]P}t |¡rè|d 8 }qÐt|| jj||d}|d 8 }t|st|d sÐ q"qÐ|S ) NrK zToo many indicesc s s | ]}t |pt |¡V qd S r: )r rq r r r; r; r> r s z9_LocationIndexer._getitem_nested_tuple.<locals>.<genexpr>c s s | ]}t |tV qd S r: ©r] r^ r r; r; r> r s r¸ r r[ rn r ra )r_ rp ra rW r r r r r rJ rÄ r] rX r& r£ rS r½ rq r r¼ r" Úhasattr)r< r¡ ri rS rX r; r; r> rà s6
|
|
|
|
ÿÿ
|
|
z&_LocationIndexer._getitem_nested_tuplec C s t | d S r: r r r; r; r> rh > s z$_LocationIndexer._convert_to_indexerc s t | t|tkrdtdd |D }t fdd|D } |¡rZ jj|d jiS |¡S jpld}t
|
| j¡} j ||dS d S )Nc s s" | ]}t |rt|n|V qd S r: r r r; r; r> r E s z/_LocationIndexer.__getitem__.<locals>.<genexpr>c 3 s | ]}t | j¡V qd S r: r r rI r; r> r F s Útakeabler r[ ) r_ rV r^ Ú_is_scalar_accessrX Ú
|
_get_valuerU Ú_getitem_tuplerS rq r r½ )r< ri rS Zmaybe_callabler; rI r> r? A s
|
|
|
z _LocationIndexer.__getitem__©ri c C s
|
t d S r: ©ÚNotImplementedErrorr¹ r; r; r> rË Q s z"_LocationIndexer._is_scalar_accessc C s t | d S r: r rµ r; r; r> rÍ T s z _LocationIndexer._getitem_tuplec C s
|
t d S r: rÏ r r; r; r> r½ W s z _LocationIndexer._getitem_axisc C s t | d S r: r ©r< r{ r; r; r> r Z s z+_LocationIndexer._has_valid_setitem_indexerc C s2 | j |¡}t||}| ¡ d }| j j||dS )Nr r[ )rX rb Úcheck_bool_indexerrs Ú_take_with_is_copy)r< ri rS ÚlabelsZindsr; r; r> Ú _getbool_axis] s
|
z _LocationIndexer._getbool_axis)N)NN)r@ rA rB Ú__annotations__rS r rZ rl r~ r\ r r r© r¯ r¶ re r« rÁ rÇ rà rh r? rË rÍ r½ r rÕ r; r; r; r> r7 sN
|
ÿ !
|
:5
|
<9
|
c @ sä e Zd ZU dZded< dZeejddddZdd d
|
d Z d dd ddZ
|
d ddddZ d dddZ ddddZ d dddZdddd Zd dd d Zddd d Zd!dd"d#d$Zddd%d&Zddd'd(Zd)S )*rJ FrT rU zlabels (MUST BE IN THE INDEX), slices of labels (BOTH endpoints included! Can be slices of integers if the index is integers), listlike of labels, booleanr r[ c C s | j |¡}t|trPt|sP|jjdksPt|trBt| d¡sPt | dt|t
|
rt|j tsrt|j trt | dd S )NÚbooleanr z7: boolean label can not be used without a boolean indexz+: boolean values can not be used in a slice)rX rb r] rT r rw rW r3 Zget_level_valuesrc r ÚstartÚstopÚ TypeError)r< ri rS rk r; r; r> r r s&
|
ÿ
|
þý üÿ
|
|
ÿ
|
ÿz_LocIndexer._validate_keyrF c C s dS )NTr; rÑ r; r; r> r s z&_LocIndexer._has_valid_setitem_indexerr^ rª c C st t || jkrdS t|D ]T\}}t|s0 dS | jj| }t|trL dS t|trb|j rb dS |j
|
s dS qdS )r° FT) rp ra r¬ r" rX r´ r] r3 rQ Z!_supports_partial_string_indexingZ_index_as_unique)r< ri ro r rk r; r; r> rË s
|
|
z _LocIndexer._is_scalar_accessr 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 r: )r/ r r; r; r> r ¿ s z6_LocIndexer._multi_take_opportunity.<locals>.<genexpr>Fc s s | ]}t |¡V qd S r: )rq rr r r; r; r> r à s )r r£ rµ r; r; r> Ú_multi_take_opportunity s z#_LocIndexer._multi_take_opportunityr³ c s. fddt | jjD } jj|dddS )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 ri rS rI r; r> Ú
|
<dictcomp>Ö s ÿ z+_LocIndexer._multi_take.<locals>.<dictcomp>T©r¿ Ú
|
allow_dups)ÚziprX Z _AXIS_ORDERSÚ_reindex_with_indexers)r< r¡ Údr; rI r> Ú _multi_takeÅ s
|
þz_LocIndexer._multi_taker c C s6 | ||¡ | ||¡\}}| jj|||gidddS )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).
|
TrÞ )r rÜ rX rá )r< ri rS Úkeyarrr{ r; r; r> Ú_getitem_iterableÞ s
|
ÿz _LocIndexer._getitem_iterablec
|
C sX t t" | |¡}| |¡W 5 Q R £ S Q R X | |¡}| |¡rN| |¡S | |¡S r: )r r r© rÇ r¯ rÛ rã rÁ rµ r; r; r> rÍ ý s
|
|
|
|
|
z_LocIndexer._getitem_tuplec C s | j j||dS )Nr[ )rX Úxs)r< ÚlabelrS r; r; r> Ú
|
_get_label s z_LocIndexer._get_labelc
|
C st | j pd}z| j||dW S tk
|
rn } z6| jt| k rL| jjjkrTn n|td|W 5 d }~X Y nX d S )Nr r[ zNo label returned) rS rè rc ra rp rX r¦ Únlevelsr )r< r¡ rS Zekr; r; r> rÄ s
|
$z._LocIndexer._handle_lowerdim_multi_index_axis0c C s, t |}t|rt|}|tkr(td }| j |¡}t|trPt|t rPt|}t|trt|
|
||¡ | j ||dS t |¡r| j||dS t|rt|trªt|t sÔt|drÆ|jdkrÆtd| j||dS t||r| |¡}td g| j }|||< | jjt| S |
|
||¡ | j||dS )Nr[ ra rn z&Cannot index with multidimensional key)r r rg r¢ r rX rb r] r^ r3 r Ú_get_slice_axisrq rr rÕ r/ rÉ ra r rå r² Úget_locsrH rè )r< ri rS rÔ Zlocsr{ r; r; r> r½ s2
|
|
|
|
z_LocIndexer._getitem_axisr ©Ú slice_objrS c C sf | j }t|s|jddS | |¡}| |j|j|j¡}t|t rR| j j
|
||dS | j j ||dS dS )zL
|
This is pretty simple as we just have to deal with labels.
|
Frº r[ N) rX Ú
|
need_slicer¿ rb Z slice_indexerrØ rÙ Ústepr] r Ú_sliceÚtake)r< rí rS rX rÔ r{ r; r; r> rê A s
|
|
z_LocIndexer._get_slice_axisc C sÒ | j |¡}t|tr$|j|ddS t|trVt|tsV| jdk rVt|dkrVt dt
|
|stt|tr t |r z | |¡W S t k
|
rÄ t|trÀt|trÀt||jkr¾d|i Y S Y nH tk
|
râ t|tsÞ Y n* tk
|
r
|
t| sþ d|i Y S X t||rJ| jdkr@tdd |D r@t d| |¡S t|rt|rft|}t |¡rt||}|S | ||¡d S n<z | |¡W S t k
|
rÌ t|sÆd|i Y S Y nX d S )
|
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
|
rK )rx rm rn r¸ ri c s s | ]}t |tV qd S r: rÈ r r; r; r> r
s z2_LocIndexer._convert_to_indexer.<locals>.<genexpr>N) rX rb r] r Z_convert_slice_indexerr^ r3 ra rp r r" r rd Ú LookupErrorré r r r r² r£ rë r/ r rg rq rr rÒ rÜ )r< ri rS rÔ r; r; r> rh T sX
|
ÿþý
|
ü
|
|
|
|
|
|
|
z _LocIndexer._convert_to_indexerc C s0 | j |¡}| j |¡}| ||¡\}}||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.
|
)rX rb Z_get_axis_nameZ_get_indexer_strict)r< ri rS rk Z axis_namerä r{ r; r; r> rÜ s z!_LocIndexer._get_listlike_indexerN)r@ rA rB rU rÖ rR r r7 r r rË rÛ rã rå rÍ rè rÄ r½ rê rh rÜ r; r; r; r> rJ f s"
|
ÿ " $HrJ c @ s* e Zd ZdZdZddddZddd d
|
Zd dd d dZddddddZd dddZ ddddZ
|
ddddZ ddd d d Z ddd d Z d!d" ZdCd$d%d&d'Zd$d%d(d)Zd*d+ Zd,d$d-d.d/Zddd0d1d2Zd$dd3d4d5Zd6d7 Zd8d9 ZdDd;dd<d=d>Zd,d,d?d@dAZdBS )ErE zlinteger, integer slice (START point is INCLUDED, END point is EXCLUDED), listlike of integers, boolean arrayTr r[ c C s t |¡r@t|dr<t|jtr<|jjdkr4tdtdd S t|t rNd S t
|
|rd| ||¡ n²t|t rxt dnt|rt|tr|j}nt|r¢|}n
|
t |¡}t| j |¡}t|jsÔtd| t|r| ¡ |ksú| ¡ | k rtdntd| 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 maskr¸ z%.iloc requires numeric indexers, got ú%positional indexers are out-of-boundsz#Can only index by location with a [ú]) rq rr rÉ r] r¦ r2 Z inferred_typerÐ r r r Ú_validate_integerr^ r r/ r& Ú_valuesr ru r, rp rX rb r rw Ú
|
IndexErrorÚmaxÚminrR )r< ri rS ÚarrÚlen_axisr; r; r> r Æ s8
|
ÿÿ
|
|
|
|
|
|
|
&
|
z_iLocIndexer._validate_keyrT rF c C s t |trtdt |tr$tdt |ts:t| j|}t| j j
|
|D ]N\}}t |t r\qHt |rfqHt |r|t|krtdqHt |trHtdqHdS )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 objectzsDataFrame indexer for .iloc is not supported. Consider using .loc with a DataFrame indexer for automatic alignment.T)r] Údictrø r% rÚ r^ Ú_tuplifyra rà rX r´ r r/ r rp )r< r{ rk ro r; r; r> r ð s&
|
|
ÿ
|
|
|
|
|
z'_iLocIndexer._has_valid_setitem_indexerr^ rª c C s$ t || jkrdS tdd |D S )r° Fc s s | ]}t |V qd S r: )r r r; r; r> r ! s z1_iLocIndexer._is_scalar_access.<locals>.<genexpr>)rp ra r r¹ r; r; r> rË s
|
z _iLocIndexer._is_scalar_accessÚintr )ri rS rG c C s. t | j |¡}||ks"|| k r*tddS )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)rp rX rb rø )r< ri rS rü r; r; r> rö # s z _iLocIndexer._validate_integerr³ c
|
C s: | |¡}tt | |¡W 5 Q R £ S Q R X | |¡S r: )r¯ r r rÇ rÁ rµ r; r; r> rÍ 9 s
|
|
z_iLocIndexer._getitem_tuplec
|
C sD z| j j||dW S tk
|
r> } ztd|W 5 d}~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.
|
r[ rô N)rX rÓ rø )r< ri rS r® r; r; r> Ú_get_list_axis@ s z_iLocIndexer._get_list_axisc C sÒ |t krtd }nt|tr$tdt|tr<| j||dS t|rLt|}t|tr`t |¡}t
|
|¡r| ||¡ | j ||dS t|r| j||dS t|}t|s²td| ||¡ | jj||dS d S )NzWDataFrame indexer is not allowed for .iloc
|
Consider using .loc for automatic alignment.r[ z5Cannot index by location index with a non-integer key)r¢ r r] r% rø rê r rg ru Úasarrayrq rr r rÕ r/ r r r rÚ rö rX Z_ixsr r; r; r> r½ W s,
|
|
ÿ
|
|
|
|
z_iLocIndexer._getitem_axisr rì c C s> | j }t|s|jddS | |¡}| |¡ | j j||dS )NFrº r[ )rX rî r¿ rb Z_validate_positional_slicerð )r< rí rS rX rÔ r; r; r> rê | s
|
|
z _iLocIndexer._get_slice_axisc C s |S )zL
|
Much simpler as we only have to deal with our valid types.
|
r; r r; r; r> rh s z _iLocIndexer._convert_to_indexerc C s. t |rt|}| jd k r*t| j| j|}|S r: )r rg rS r` ra r¹ r; r; r> rl s
|
|
z!_iLocIndexer._get_setitem_indexerrH rQ ©rW c C s | j j}| j jj }|s,t|tr,|jj }|st| j jjr| jdkrt|t r^t
|
| ¡ n|}| j jjd }t |t |dd }t|trÞt|t| j jkrÞt|| j jD ],\}} t| tr°t|s°t |¡s°d} qÞq°t|tr¼g }
|
t|D ]¸\}} t| t r¦t| \} } | jdkr ||kr t| j s\t|sLtd|| j | < dS t |d ¡r||| j | < dS t|rìt |dd}dtjt| 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öt|
|
}n"t|\}}|rÞ| +||¡ dS |d krø| ,||¡\}}|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.
|
rn r T)Z extract_numpyz5cannot set a frame with no defined index and a scalarNr r
)rß ©ÚclearrK )/rX Ú_info_axis_numberr Zis_single_blockr] r% rp Zarraysra rý rg Úvaluesr r- r^ r´ rà r3 r rq r r¬ Úconvert_missing_indexerr/ r r ru Zonesr ÚalgosZtake_ndr& r' Ú"convert_from_missing_indexer_tupler rb Úinsertr rá Ú_maybe_update_cacherZ_is_copyÚappendrd Ú _setitem_with_indexer_missingr~ Ú _setitem_with_indexer_split_pathÚ_setitem_single_block)r< r{ r| rW Ú info_axisZtake_split_pathÚvalrû ro rk ZnindexerÚidxri Ú_ZtakerZ empty_valueÚ new_indexerr¦ rÔ Z
|
reindexersZnew_objÚmissingr; r; r> r s
|
|
ÿ
|
ÿÿ
|
ÿ
|
|
|
|
ÿ ÿ
|
|
|
z"_iLocIndexer._setitem_with_indexerc C s² | j dkstt|ts$t| j |}t|| j kr:tdt|d tjr`|d j dkr`t dt|t
|
rr|dks|t|t rddl m } | |||¡}|d }| |¡}|d }t|| jj}t|rt|dddkrt|trø| |||¡ q®t |¡dkr| ||¡ q®t|dkrT|t|krTt|sT| |d ||¡ q®t|dkr¼d| kr~t|kr¼n n:t|dkr²t|s²| ||d f|d ¡S t d nÖ|dkrÞt|t| jjkrÞn´| |¡rt | jj |d r| |d ||¡ n~t|t|krLt ||D ]\} }
|
| | |
|
|¡ q0nFt|dkrt !|¡rt| jdkr| |d ||¡ nt d n|D ]} | | ||¡ qd
|
S ) z&
|
Setitem column-wise.
|
rm ztoo many indices for arrayr z Cannot set values with ndim > 2rH ©r5 rn ra z@Must have equal len keys and value when setting with an iterableN)"ra r¾ r] r^ rþ rp rø ru rv r r& rý Úpandasr5 rt Ú _ensure_iterable_column_indexerr1 rX r¦ r/ r¼ r% Ú!_setitem_with_indexer_frame_valueÚ _setitem_with_indexer_2d_valuer" Ú_setitem_single_columnr r rË r! Zdtypesrà rq r ) r< r{ r| rW r5 r Úilocsr} Zlplane_indexerrK Úvr; r; r> r ( sV
|
|
|
&.ÿ ÿ*ÿz-_iLocIndexer._setitem_with_indexer_split_pathc C s |d }| |d ¡}t|s,tj|td}t||jd krFtdt|D ]8\}}|d d
|f }t |j
|
rx| ¡ }| |||¡ qNd S )Nr rn r
z?Must have equal len keys and value when setting with an ndarray) r r ru r, Úobjectrp ry r r¬ r! rw Útolistr )r< r{ r| r} r ro rK Z value_colr; r; r> r s ÿ
|
z+_iLocIndexer._setitem_with_indexer_2d_valuer4 )r| rW c C sH | |d ¡}t|}|d }t| jjt}|jj}|dkrpt|D ](\} }
|
|jd d
| f } | |
|
| |¡ qDnÔ|sâ|j
|
| jj¡râ|D ]V}
|
| jj|
|
} | |krÊ| |d< | t ||jd d
|
|
f |¡} nt j} | |
|
| |¡ qnb|sðtdnT|D ]N}
|
| jj|
|
} | |kr.| |d< | t ||| |¡} nt j} | |
|
| |¡ qôd S )Nrn r rH z/Setting with non-unique columns is not allowed.)r rg r] rX r r3 Ú is_uniquer¬ rH r Úequalsrt r^ ru Únanr ) r< r{ r| rW r Z sub_indexerr} Úmultiindex_indexerZ unique_colsro rK r Úitemr; r; r> r sD ý
|
|
ÿz._iLocIndexer._setitem_with_indexer_frame_value)rK rG c
|
C s° |}t |¡p t |t| j¡}t |¡p<t|o<t|dk}|rFdS |rz| jjj|||dd W q¢ t t
|
t fk
|
r | j ||¡ Y q¢X n| jj |||¡ | 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 NT)Z inplace_only)rq r Z is_full_slicerp rX Zis_empty_slicer r Zcolumn_setitemr rÚ r ZisetitemZ_clear_item_cache)r< rK r| Z plane_indexerr} Zis_full_setterZis_null_setterr; r; r> r Ê s"
|
ÿ
|
z#_iLocIndexer._setitem_single_column)rW rG c C s, ddl m} | jj}| j |¡}t|trª| jt| krDdkr¢n nZt |d r¢t
|
|d ¡r¢||| }t| |g¡dkr¢| |¡}| |||d ¡ dS t| }t|tr¼|dksÆt|trØ| |||¡}n t|trø|dkrø| ||¡j}| j ¡ | jjj||d| j_| jjddd dS )
|
zQ
|
_setitem_with_indexer for the case when we have a single Block.
|
r r rm rn NrH )r{ r| T)r Zinplace)r r5 rX r rb r] r^ ra rp r rq r Úget_indexer_forrd r Úmaybe_convert_ixr& rý rt r% rz r÷ Z%_check_is_chained_assignment_possibler Úsetitemr ) r< r{ r| rW r5 r Z item_labelsÚcolrK r; r; r> r ï s4
|
ÿÿ
|
|
þ ý
|
|
z"_iLocIndexer._setitem_single_blockc C s ddl m} | jdkrT| jj}| t||¡}|jrb| |dd
¡}|dk ¡ rb|
|
||d¡S t |spd}nt || jj r®t| jj st| jj dd}t| jj |d }nJt|r¼d}n<| jjsôt| jj sô| jj }t|d |}t||d }nd}||g|d
|
j} t| jjr&t| jj| g} | jj| || jjd j| j_| jjd d n4| jdkrt| jjsvtdt |d}
|
t |t r¦|j | jjd d}||_n\t |t rÈ||| jj|t!d}n:t"|rðt|t| jjkrðtd||| jj|d }t| jsh| #¡ j$} | jj} t | t%r4| j&} n| j} t'|g| d| _|
|
s\| j(dd} | j| j_n| j )|¡j| j_| jjd d dS )zN
|
Insert new row(s) or column(s) into the Series or DataFrame.
|
r r rn r NrK F)ÚcompatZ numpy_dtyper
)r¦ rW Tr rm z*cannot set a frame with no defined columnsrw )r¦ r¿ )r¦ rW rw z(cannot set a row with mismatched columnsr ©r¿ )*r r5 ra rX r¦ r
|
rp r Ú get_indexerr£ r r" r( rw r! r* r r) Úemptyr¼ r÷ r$ Z _constructorrW r r r r rÉ r] r& Úreindexrý r r/ Zto_frameÚTr3 Únamesr2 Z infer_objectsÚ_append)r< r{ r| r5 r¦ Z new_indexr Z new_dtypeZ
|
curr_dtypeZ
|
new_valuesZ has_dtypeÚdfr rW r; r; r> r sx ÿ
|
ÿ
|
|
z*_iLocIndexer._setitem_with_indexer_missingc C sd t |r|g}nPt|tr2t t| jj¡| }n.t|tjr\t |j
|
r\t t|¡| }n|}|S )zX
|
Ensure that our column indexer is something that can be iterated over.
|
) r r] r ru r rp rX r rv r rw )r< Zcolumn_indexerr r; r; r> r s
|
ÿz,_iLocIndexer._ensure_iterable_column_indexerFr5 )Úserr# c C st t |ttjttfr|f}t |trÔ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 t|D ]Þ\} } | j | }t| st | tr|r.t | ¡r.qò|| }t|sLt|g}nt|}|j |¡slt|sz|j ¡ S | |¡j S |rò| j
|
j d }|j |¡s²t|sÀ|j ¡ S | |¡j S qònt|r.| j dkr.t | j
|
rú|S | j
|
d¡}|j |¡r |j ¡ S | |¡j| S t|rh| j
|
d¡}|j |¡r\|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 | tjr| ¡ S | S r: )r] ru rv Úravel)ro r; r; r> r3 § s z)_iLocIndexer._align_series.<locals>.ravelc S s g | ]}t |¡ qS r; )rq r )r r r; r; r> r· ¬ s z._iLocIndexer._align_series.<locals>.<listcomp>rn rm r c s s | ]}t |V qd S r: )r# ©r r r; r; r> r ½ s z-_iLocIndexer._align_series.<locals>.<genexpr>Tr* r z Incompatible indexer with SeriesN) r] r ru rv rg r2 r^ ÚmapÚsumra rX r r- r´ r÷ rp ZtileZreshaper. r¬ r# rq r r/ r¦ r! r¿ r r! rb r )r< r{ r2 r# r3 ZalignersZ sum_alignersZsingle_alignerÚis_framerX Z
|
ser_valuesZ len_indexerro r rk Znew_ixr; r; r> rt sb
|
ÿ
|
|
|
|
|
z_iLocIndexer._align_series)r1 rG c C sj | j dk}t|trÞd\}}g }t|D ]n\}}| jj| } t|sNt|trt|tj rb|
|
¡ }|d krt| | }q|d kr| | }q qq(| |¡ q(|d k rÜ|d k rÜ|j |¡rÊ|j |¡rÊ| ¡ }
|
n|j||d}
|
|
|
S nt|tsòt|r^|r^| jj | } |j | ¡r | ¡ }
|
n>t| trNt|j trN| j|j jkrNtd|j| d}
|
|
|
S tdd S )Nrm )NN)r zAcannot align on a multi-index with out specifying the join levels)r¦ z#Incompatible indexer with DataFrame)ra r] r^ r¬ rX r´ r# r ru rv r3 r r¦ r! r r¿ r- r/ r3 ré rÚ r ) r< r{ r1 r7 r ÚcolsZ sindexersro Úixrk r r; r; r> rz ö sH
|
|
|
|
|
|
ÿ
|
þ ýÿ z_iLocIndexer._align_frameN)rH )F)r@ rA rB rR rU r r rË rö rÍ r r½ rê rh rl r r r r r r r r rt rz r; r; r; r> rE » s0 ÿ*$% [1%*gerE c @ s8 e Zd ZU dZded< dd Zdd Zdd d
|
d Zd S ) Ú_ScalarAccessIndexerz!
|
Access scalars quickly.
|
rT rU c C s t | d S r: r r¹ r; r; r> Ú _convert_key0 s z!_ScalarAccessIndexer._convert_keyc C s@ t |ts"t|s|f}ntd| |¡}| jj|d| jiS )Nú)Invalid call for scalar access (getting)!rÊ )r] r^ r/ r r; rX rÌ rU r¹ r; r; r> r? 3 s
|
|
z _ScalarAccessIndexer.__getitem__r rF c s t |tr"t fdd|D }nt | j¡}t |tsFt j|}t |¡}t | jkrjt
|
d jj || j d d S )Nc 3 s | ]}t | j¡V qd S r: r r rI r; r> r @ s z3_ScalarAccessIndexer.__setitem__.<locals>.<genexpr>z0Not enough indexers for scalar access (setting)!)r| rÊ ) r] r^ rq r rX rþ ra rg r; rp r Z
|
_set_valuerU ©r< ri r| r; rI r> r > s
|
|
z _ScalarAccessIndexer.__setitem__N)r@ rA rB rC rÖ r; r? r r; r; r; r> r: ( s
|
|
r: c sF e Zd ZdZdd ZeddddZ fdd Z fd
|
d Z Z S ) rL Fc C s | j dkr t|dkr |f}|S )zd
|
Require they keys to be the same type as the index. (so we don't
|
fallback)
|
rn )ra rp r¹ r; r; r> r; R s z_AtIndexer._convert_keyrT rF c C s" | j dkst| jjjo | jjjS )Nrm )ra r¾ rX r¦ r r rI r; r; r> Ú_axes_are_unique_ s z_AtIndexer._axes_are_uniquec sL | j dkr@| js@t|tr,tdd |D s4td| jj| S t |¡S )Nrm c s s | ]}t |V qd S r: ©r" r r; r; r> r h s z)_AtIndexer.__getitem__.<locals>.<genexpr>r< )
|
ra r> r] r^ r r rX rK Úsuperr? r¹ ©Ú __class__r; r> r? e s
|
z_AtIndexer.__getitem__c sR | j dkrD| jsDt|tr,tdd |D s4td|| jj|< d S t ||¡S )Nrm c s s | ]}t |V qd S r: r? r r; r; r> r q s z)_AtIndexer.__setitem__.<locals>.<genexpr>z)Invalid call for scalar access (setting)!)
|
ra r> r] r^ r r rX rK r@ r r= rA r; r> r n s z_AtIndexer.__setitem__)
|
r@ rA rB rU r; rP r> r? r Ú __classcell__r; r; rA r> rL N s rL c @ s e Zd ZdZdd ZdS )rN Tc C s |D ]}t |stdq|S )zH
|
Require integer args. (and convert to label arguments)
|
z1iAt based indexing can only have integer indexers)r r )r< ri ro r; r; r> r; ~ s
|
z_iAtIndexer._convert_keyN)r@ rA rB rU r; r; r; r; r> rN z s rN rÿ r z tuple[Hashable | slice, ...])ra rK rG 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 r: )r r4 r; r; r> r· s z _tuplify.<locals>.<listcomp>r )rf r^ )ra rK Z_tupr; r; r> rþ s rþ r r^ )ra rS rG c C s t dg| }|||< t|S )zI
|
If we have an axis, adapt the given key to be axis-independent.
|
N)r r^ )ra rS ri r¨ r; r; r> r` s r` r2 z
|
np.ndarray)r¦ rG c C s |}t |trV|j | ¡sV|j | ¡}d|kr6td| |¡}t|jsV| t
|
¡j S t |rnt j|t
|
d}nt|st|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.
|
r ztUnalignable boolean Series provided as indexer (index of the boolean Series and of the indexed object do not match).r
)r] r& r¦ r! r% r rñ r rw ZastyperT r÷ r! ru r r Úpd_arrayr. )r¦ ri Úresultr{ r; r; r> rÒ ¥ s ÿ
|
|
rÒ c C s4 t | tr,| d } t | tr$td| dfS | dfS )z
|
Reverse convert a missing indexer, which is a dict
|
return the scalar indexer and a boolean indicating if we converted
|
ri z.cannot use a single bool to index into setitemTF)r] rý rT rc )r{ r; r; r> r Ù s
|
|
r c s& fddt fddt| D S )zK
|
Create a filtered indexer that doesn't have any missing indexers.
|
c s t |tr | |d ¡S |S )Nri )r] rý rd )Ú_iÚ_idx)r´ r; r> r+ î s z7convert_from_missing_indexer_tuple.<locals>.get_indexerc 3 s | ]\}} ||V qd S r: r; )r rF rG )r+ r; r> r ñ s z5convert_from_missing_indexer_tuple.<locals>.<genexpr>)r^ r¬ )r{ r´ r; )r´ r+ r> r é s r c G s0 | D ] }t |tjtttfs| S qtj| S )z3
|
We likely want to take the cross-product.
|
)r] ru rv rg r& r2 Zix_)Úargsr= r; r; r> r& ô s
|
r& rT rF c C s< t | tsdS | D ]$}t|s(t |trt |t S qdS )ú&
|
Returns
|
-------
|
bool
|
F)r] r^ r r r3 )r¡ rÔ r r; r; r> r² þ s
|
r² c C s t | t o t| o | tk S )rI )r] r r/ r¢ rÎ r; r; r> rÅ
|
s
|
ÿýrÅ r )rX rG c C s( | j dk p&| jdk p&| jdk o&| jdkS )rI Nrn )rØ rÙ rï )rX r; r; r> rî
|
s
|
|
ÿýrî r c C s` t | ts&t | tr.tdd | D r.tdt | tsTt | tr\tdd | D r\tddS )zX
|
Check if the indexer is or contains a dict or set, which is no longer allowed.
|
c s s | ]}t |tV qd S r: )r] Úsetr r; r; r> r 1
|
s z-check_dict_or_set_indexers.<locals>.<genexpr>zAPassing a set as an indexer is not supported. Use a list instead.c s s | ]}t |tV qd S r: )r] rý r r; r; r> r :
|
s zBPassing a dict as an indexer is not supported. Use a list instead.N)r] rJ r^ r£ rÚ rý rÎ r; r; r> r_ *
|
s$ ÿþýÿÿþýÿr_ )mÚ
|
__future__r Ú
|
contextlibr r Útypingr r r r r r r Únumpyru Zpandas._configr
|
Zpandas._libs.indexingr Zpandas._libs.libr Zpandas._typingr r Z pandas.compatr Z pandas.errorsr r r r r r Zpandas.util._decoratorsr Zpandas.core.dtypes.castr r 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( r) r* Z pandas.corer+ r Zpandas.core.commonÚcoreÚcommonrq Zpandas.core.constructionr, rD r- Zpandas.core.indexersr. r/ r0 r1 Zpandas.core.indexes.apir2 r3 r r4 r5 r6 r r§ r¥ r9 Z
|
IndexSlicerD r7 rK rJ rH rE r: rM rL rO rN rþ r` rÒ r r r& r² rÅ rî r_ r; r; r; r> Ú<module> s 4
|
, Q V r&+ 4
|
|
