ujUddlmZddlmZddlmZddlZddlmZm Z m Z m Z m Z m Z mZddlZddlZddlmZddlmZmZddlmZdd lmZdd lmZmZmZmZm Z m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4ddl5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?ddl@mAZAmBZBmCZCmDZDddlEmFZFmGZGmHZHmIZImJZJddlKmLZMddlNmOcmPZQddlRmSZTmUZUmVZVmWZWddlXmYZYmZZZm[Z[m\Z\ddl]m^Z^m_Z_ereddl`maZambZbddlcmdZdmeZemfZfmgZgmhZhmiZimjZjddlkmlZlmmZmddlnmoZoddlpmqZqereqehzebzeszdfZtdeud<ehebzeszetzeretdfzZvdeud<e d ev!ZwesddZxd"ZyGd#d$ZzezZ{d%e{_|Gd&d'Z}Gd(d)eZ~Gd*d+e~ZGd,d-e~ZGd.d/eZGd0d1eZGd2d3eZd4ZdGd5ZdHd6ZdId7ZdJd8ZdKd9Zd:ZdLd;Zd<ZdHd=ZdHd>ZdMd?ZdNd@ZdOdAZdPdBZdQdCZdDdE dRdFZy)S) annotations)abc)suppressN) TYPE_CHECKINGAnySelf TypeAliasTypeVarcastfinal)NDFrameIndexerBase) is_np_dtypeitem_from_zerodim)CHAINED_WARNING_DISABLED) REF_COUNT_IDX)AbstractMethodErrorChainedAssignmentError IndexingErrorInvalidIndexErrorLossySetitemErrorPandas4Warning)_chained_assignment_msg)find_stack_level)can_hold_elementfloats_fit_integer_dtypemaybe_downcast_to_dtype) "is_array_like_deprecate_non_pandas is_bool_dtype is_hashable is_integer is_iterator is_list_likeis_numeric_dtypeis_object_dtype is_scalar is_sequence) concat_compat) ArrowDtypeBaseMaskedDtypeDatetimeTZDtypeExtensionDtype IntervalDtype NumpyEADtype PeriodDtype SparseDtype) ABCDataFrameABCExtensionArrayABCIndex ABCSeries)array_equivalent+construct_1d_array_from_inferred_fill_valueis_valid_na_for_dtypeisnana_value_for_dtype) algorithms)arrayensure_wrapped_if_datetimelike extract_arraysanitize_array)check_array_indexeris_list_like_indexeris_scalar_indexerlength_of_indexer)Index MultiIndex)HashableSequence) ArrayLikeAxisAxisIntDtypeObjScalarTnpt) DataFrameSeries)ExtensionArray) IndexOpsMixin.r _IndexSliceTuple_IndexSliceUnion_IndexSliceUnionT)boundz(indexer may only contain one '...' entryceZdZdZddZy) _IndexSlicea Create an object to more easily perform multi-index slicing. ``IndexSlice`` is a convenience object that allows the use of natural slice syntax (``start:stop``) when selecting from a :class:`MultiIndex`, rather than requiring explicit ``slice()`` calls. See Also -------- MultiIndex.remove_unused_levels : New MultiIndex with no unused levels. Notes ----- See :ref:`Defined 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|SN)selfargs _/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/indexing.py __getitem__z_IndexSlice.__getitem__s N)r[rSreturnrS)__name__ __module__ __qualname____doc__r]rYr^r\rVrVs ,\r^rVpandascXeZdZdZeddZeddZed dZed dZy) IndexingMixinzH Mixin for adding .loc/.iloc/.at/.iat to Dataframes and Series. ctd|S)a Purely integer-location based indexing for selection by position. .. versionchanged:: 3.0 Callables which return a tuple are deprecated as input. ``.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 `. 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]) >>> 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]]) >>> 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 **Selecting along an explicit axis** ``.iloc`` can be called with an ``axis`` argument to apply a single indexer to that axis. >>> df.iloc(axis=0)[1] a 100 b 200 c 300 d 400 Name: 1, dtype: int64 >>> df.iloc(axis=1)[1] 0 2 1 200 2 2000 Name: b, dtype: int64 iloc) _iLocIndexerrZs r\rhzIndexingMixin.ilocsDFD))r^ctd|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 `. 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 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 Multiple conditional using ``&`` that returns a boolean Series >>> df.loc[(df["max_speed"] > 1) & (df["shield"] < 8)] max_speed shield viper 4 5 Multiple conditional using ``|`` that returns a boolean Series >>> df.loc[(df["max_speed"] > 4) | (df["shield"] < 5)] max_speed shield cobra 1 2 sidewinder 7 8 Please ensure that each condition is wrapped in parentheses ``()``. See the :ref:`user guide` for more details and explanations of Boolean indexing. .. note:: If you find yourself using 3 or more conditionals in ``.loc[]``, consider using :ref:`advanced indexing`. See below for using ``.loc[]`` on MultiIndex DataFrames. Callable that returns a boolean Series >>> df.loc[lambda df: df["shield"] == 8] max_speed shield sidewinder 7 8 **Selecting along an explicit axis** ``.loc`` can be called with an ``axis`` argument to apply a single indexer to that axis. >>> df.loc(axis=0)["viper"] max_speed 4 shield 5 Name: viper, dtype: int64 >>> df.loc(axis=1)["shield"] cobra 2 viper 5 sidewinder 8 Name: shield, dtype: int64 **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 Add value matching location >>> df.loc["viper", "shield"] += 5 >>> df max_speed shield cobra 30 10 viper 0 5 sidewinder 0 0 Setting using a ``Series`` or a ``DataFrame`` sets the values matching the index labels, not the index positions. >>> shuffled_df = df.loc[["viper", "cobra", "sidewinder"]] >>> df.loc[:] += shuffled_df >>> df max_speed shield cobra 60 20 viper 0 10 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` for more details and explanations of advanced indexing. **Assignment with Series** When assigning a Series to .loc[row_indexer, col_indexer], pandas aligns the Series by index labels, not by order or position. Series assignment with .loc and index alignment: >>> df = pd.DataFrame({"A": [1, 2, 3]}, index=[0, 1, 2]) >>> s = pd.Series([10, 20], index=[1, 0]) # Note reversed order >>> df.loc[:, "B"] = s # Aligns by index, not order >>> df A B 0 1 20.0 1 2 10.0 2 3 NaN loc) _LocIndexerrjs r\rlzIndexingMixin.lochs` 5$''r^ctd|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 ` 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) _AtIndexerrjs r\rozIndexingMixin.atsD$%%r^ctd|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) _iAtIndexerrjs r\rrzIndexingMixin.iats^5$''r^N)r_ri)r_rm)r_rp)r_rs) r`rarbrcpropertyrhrlrorrrYr^r\rfrfs`a*a*FO(O(b A&A&F.(.(r^rfc~eZdZUded<dZded<ded<edd dZd Zed Zedd!d Z ed!d Z d"d Z d#dZ ed$dZ ed%dZed&dZed%dZed%dZed'dZed'dZed'dZd(dZd)dZedZd*dZd'dZd(dZd+dZed(dZy),_LocationIndexerstr _valid_typesNzAxisInt | Noneaxisbool _takeablect||j|j}||jj|}n|}||_|SrX)typenameobj_get_axis_numberry)rZrynew_self axis_int_nones r\__call__z_LocationIndexer.__call__7sI4:dii2   HH55d;M M% r^c|jdk(r|j||jt|tr|D] }t ||j!t |j|j|}|jjd}t|trK|jdk7r c5 ! .*1- . 99 (DIIsCC XX   " r: & V#CU3($56 'zz# ' ' c5 !-( 0**3/ 0 0 c5 !s)C''!'44 ' '  0 0sEE&E#&E/ct|trt|dk(rt|ttfr|\}}|j }t j|rht|t|k(rP|jd}t||j dz rQ|dk(rLt|dk(r|jdd}n&|jjj||}||f}||fSt|tjr|jj dk(rt|dk(r|dk(r.|jjj||}||f}||fS|dk(rZ|j"ddk(rHt|dk(r|jdd}n&|jjj%||}||f}||fSt j|r|jd}||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. rNi)rrlenr3r0rcomis_bool_indexernonzeror@rhr _align_seriesnpndarraydtypekindshape _align_frame)rZindexervaluepiicolsrnewkeys r\_maybe_mask_setitem_valuez*_LocationIndexer._maybe_mask_setitem_valuehs w &G !59l";<IB::D""2&3u:R+@a$UDIIM:tqy6{a' % 2A!% ; ;GU K%uoG0~+ubjj1 ((C/E aqy!% ; ;GU K#)5/~u{{1~':v;!+$)JJrNE%)HHMM$>$>w$NE#)5/~  )oo'*G~r^c2|jdk7ryt|trt|dkDr |d}||}|dk(rZt|jj t s4t|r'tj|std|Dr|jj j|d}t|dj|jj d}t|ra|jj j|}|jjj!||dd d }||j_y|jjj#|dd |j_yyyyyy) 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 rNrc32K|]}t|ywrX)r.0ks r\ z<_LocationIndexer._ensure_listlike_indexer..s0qKN0F)sortcopyrT)rry only_slice use_na_proxy)ryr)rrrrrcolumnsrCr?rrallunionrB difference get_indexer_mgrreindex_indexer reindex_axis)rZrrykeysdiffrnew_mgrs r\rz)_LocationIndexer._ensure_listlike_indexers^ 99>  c5 !c#hl|d)C AItxx//<$S)'',0C0088##))#E):D5)44TXX5E5EE4RD4y((**66t<((--77'dQU8!(  HHMM66t!PT6UDHHM+1-*= r^ctsFtjjtkr t j ttdt|t|trd|D}tfd|D}n2tj|j}j||}jjd}j!|}j#|jj$dk(rjj&}d}n:jj(j+}jj,}j.dk(r t1dnjj2}|j5||j.jjd|k7rj7||yy) Nr stacklevelc3LK|]}t|r t|n|ywrXr!rrrs r\rz/_LocationIndexer.__setitem__..Ak!n47!3A"$c3^K|]$}tj|j&ywrXrapply_if_callablerrrrZs r\rz/_LocationIndexer.__setitem__.."Hq--a:H*-rrrhri)rsys getrefcountrrwarningswarnrrrrrrr_raise_callable_usagerr_has_valid_setitem_indexerrrr get_dtypesrr~r rh_setitem_with_indexer_post_expansion_casting) rZrrmaybe_callable orig_nrowsrorig_dtype_info orig_columnsrhs ` r\ __setitem__z_LocationIndexer.__setitem__si'txx(M9 +-CPQ #3' c5 !ASACHCHHC 223AN,,S.ACXX^^A& ++C0 '', 88==A "hhnnOL"hhmm668O88++L+/))v*=D &488==  ""7E499= 88>>!  *  ( (, G +r^c|jjdk(rt|tjrJ||jj k7rt g|}t||jj}|jj||jj|jj}|j|j_ yyt|tjsJ|J|}|jjj}t|t|k(r||k7}tj|D]r} || j dk(rt g|| }t||jj"dd| fj}|jj%| |ty|j&r|jj(j&rt+||dD]s\} } |j| j } | | k7s%| j dk(r5t g| }t||j| j}||j| <uyy)Nrrindexr~VTstrict)rrrrrrpd_arrayinfer_and_maybe_downcast_values _constructorrr~rrr flatnonzerorrhisetitem is_uniquerzip) rZrrorig_arrnew_arrnew_ser orig_dtypes new_dtypeschanged_dtypesidxcol orig_dtype new_dtypes r\rz(_LocationIndexer._post_expansion_castings 88==A !/2::> >>$((..0#Bo>28TXX=M=MN((//488>> 0!(  1orzz: ::+ ++)K113J;3z?2!+{!:>>.9 4C"3',,3!'+c2BCH6 $((--3"7"?"?GHH%%c73 4''DHH,<,<,F,F(+<T'R 0OC $ 3 3I J.%??c1$#+Bj#A":$dhhsm&;&;#)0  0 r^ct|) 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. rrZrrys r\ _validate_keyz_LocationIndexer._validate_key0s("$''r^ctd|Drl|jtdkDrttt ||j k(r-|jt}g|d|t||dzd}|S|S)zt If a tuple key includes an Ellipsis, replace it with an appropriate number of null slices. c3,K|] }|tuywrX)Ellipsisrs r\rz4_LocationIndexer._expand_ellipsis..Ls*qH}*srN) anycountrr_one_ellipsis_messagerrr_NS)rZtuprnew_keys r\_expand_ellipsisz!_LocationIndexer._expand_ellipsisFs *c* *yy"Q&#$9::3x499$IIh'8CG8S83q1uw<8 r^c|j|}|j|}t|D]\}} |j|||S#t$r}t d|j d|d}~wwxYw)zA Check the key for valid keys across my indexer. z'Location based indexing can only have [z] typesN)_validate_key_lengthr enumerater ValueErrorrx)rZrrrerrs r\_validate_tuple_indexerz(_LocationIndexer._validate_tuple_indexer[s '',##C(cN DAq ""1a(    =d>O>O=PPWX sA  A3A..A3ctd|jjDr(tfd|jjDSy)6 Returns ------- bool c3<K|]}t|tywrX)rrC)rrs r\rz<_LocationIndexer._is_nested_tuple_indexer..rsBbz"j)Bc36K|]}t|ywrX)is_nested_tuple)rrrs r\rz<_LocationIndexer._is_nested_tuple_indexer..ssHBsB/HF)rraxesrZrs `r\_is_nested_tuple_indexerz)_LocationIndexer._is_nested_tuple_indexerks7 BDHHMMB BH$((--HH Hr^c|j|t|Dcgc]\}}|j||}}}t|Scc}}wNr)r r rr)rZrrrkeyidxs r\rz_LocationIndexer._convert_tuplevsM !!#&BKC.Q$!Q$**11*5QQV}RsA ct||jkDrC|dtur-|dd}t|vrtt|j |Std|S)NrrToo many indexers)rrrrrr rZrs r\r z%_LocationIndexer._validate_key_length}s^ s8dii 1v!!"gs?'(=>>0055 34 4 r^c|j}|jt|z dz}tt |D]o\}}|j|z |z }t j |r.t||jj||}|j|jk(roJ||jur|jd}|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. rrFdeep) rrrr reversedr is_null_slicegetattrr~ _getitem_axisr)rZrretval start_valrrs r\_getitem_tuple_same_dimz(_LocationIndexer._getitem_tuple_same_dimsYYS)Q.  . ,FAs A )A  %VTYY/==c=JF;;$))+ ++ , TXX [[e[,F r^c |j8|jj|j}|j||S|j |r|j |S|jj d}t|trU|jdk7rFtd|Ds4tt5td|j|cdddS|j|}t!t#t%|dz ddt'|d D]\}}t)|s(t+|st|t,s-t/|s9|j||}|j0|j0k(rg|d|t2||dzd}n!|d|||dzdz}t%|dk(r|d}t5j6|r|cSt9||j|cStd #1swY&xYw) Nrrrhc3<K|]}t|tywrXrslicers r\rz5_LocationIndexer._getitem_lowerdim..s: 1e,:rrmrTrznot applicable)ryrrr%r_getitem_nested_tuplerrrCr~rrrr "_handle_lowerdim_multi_index_axis0r rrrr" is_label_liker"r, need_slicerrrr#r$)rZrryax0rrsectionrs r\_getitem_lowerdimz"_LocationIndexer._getitem_lowerdims 99 88,,TYY7D%%c%5 5  ( ( ---c2 2hh  # sJ ' V#:c:: -( YM40SSTWX Y Y'',%C1 b"5x}TR .s/NO A51IS5F5Fq5IIs.0rmc3<K|]}t|tywrXrrrs r\rz9_LocationIndexer._getitem_nested_tuple..s9)* 1e$9rrrrrr)rrrr~r rrrr r/rrr3rryr%r"rr#r$r%hasattr)rZrrryrs r\r.z&_LocationIndexer._getitem_nested_tuples  ,C &s + , s8dii yyE! !344SV m, t4WWDHHi0S9.196$$78899>D%%c%5 5hh3x!|C= C  % #tyy)77$7GC AID~WS&%9   Ks &E22E;ct|rXrrs r\rz$_LocationIndexer._convert_to_indexer$ !$''r^cp|jdk(r&t|rt|tr t d|S)Nrhz;Returning a tuple from a callable with iloc is not allowed.)r~callablerrr )rZrrs r\rz&_LocationIndexer._raise_callable_usage's6 99 8C=ZPU5VM r^ct|t|tured|D}tfd|D}j|r&jj |dj iSj|Sjxsd}tj|j}j||}j||S)Nc3LK|]}t|r t|n|ywrXrrs r\rz/_LocationIndexer.__getitem__..3rrc3^K|]$}tj|j&ywrXrrs r\rz/_LocationIndexer.__getitem__..4rrtakeablerr) rr}r_is_scalar_accessr _get_valuer{_getitem_tupleryrrrr%)rZrryrs` r\r]z_LocationIndexer.__getitem__/s"3' 9 ASACHCHHC%%c**txx**CI$..II&&s+ +99>D 223AN!77^LN%%n4%@ @r^ctrXNotImplementedErrorrs r\rBz"_LocationIndexer._is_scalar_access@!!r^ct|rXrrs r\rDz_LocationIndexer._getitem_tupleCr;r^ctrXrFrs r\r%z_LocationIndexer._getitem_axisFrHr^ct|rXrrZrs r\rz+_LocationIndexer._has_valid_setitem_indexerIr;r^c|jj|}t||}|jd}|jj ||S)Nrr)rrcheck_bool_indexerrtake)rZrrylabelsindss r\ _getbool_axisz_LocationIndexer._getbool_axisLsK##D) -{{}Qxx}}T}--r^rX)ryz Axis | Noner_rr_None)rz"DtypeObj | npt.NDArray[np.object_]rz Index | Noner_rTryrHr_rT)rrr_r)rrr_rrrr_rzrrryrH)rrrrKr_rK)rrr_rz)r`rarb__annotations__ryr rrrrrrrrrrrr r(r4r.rrr]rBrDr%rrRrYr^r\rvrv0sD.O    #5J 2 2h 1V 1Vf #H #HJ7;7#7  7r(,  (               6 @. @.D 9 9v( A A "("( . .r^rvceZdZUdZdZded<dZddZddZddZ dd Z dd Z dd Z dd Z dd ZddZddZddZddZddZy)rma' 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 `. 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 column label. Note this returns the column as a Series. >>> df.loc[:, "max_speed"] cobra 1 viper 4 sidewinder 7 Name: max_speed, dtype: int64 List with a single column label. Note this returns a DataFrame. >>> df.loc[:, ["max_speed"]] max_speed cobra 1 viper 4 sidewinder 7 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 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 Multiple conditional using ``&`` that returns a boolean Series >>> df.loc[(df["max_speed"] > 1) & (df["shield"] < 8)] max_speed shield viper 4 5 Multiple conditional using ``|`` that returns a boolean Series >>> df.loc[(df["max_speed"] > 4) | (df["shield"] < 5)] max_speed shield cobra 1 2 sidewinder 7 8 Please ensure that each condition is wrapped in parentheses ``()``. See the :ref:`user guide` for more details and explanations of Boolean indexing. .. note:: If you find yourself using 3 or more conditionals in ``.loc[]``, consider using :ref:`advanced indexing`. See below for using ``.loc[]`` on MultiIndex DataFrames. 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 Add value matching location >>> df.loc["viper", "shield"] += 5 >>> df max_speed shield cobra 30 10 viper 0 5 sidewinder 0 0 Setting using a ``Series`` or a ``DataFrame`` sets the values matching the index labels, not the index positions. >>> shuffled_df = df.loc[["viper", "cobra", "sidewinder"]] >>> df.loc[:] += shuffled_df >>> df max_speed shield cobra 60 20 viper 0 10 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` for more details and explanations of advanced indexing. **Assignment with Series** When assigning a Series to .loc[row_indexer, col_indexer], pandas aligns the Series by index labels, not by order or position. Series assignment with .loc and index alignment: >>> df = pd.DataFrame({"A": [1, 2, 3]}, index=[0, 1, 2]) >>> s = pd.Series([10, 20], index=[1, 0]) # Note reversed order >>> df.loc[:, "B"] = s # Aligns by index, not order >>> df A B 0 1 20.0 1 2 10.0 2 3 NaN Frzr{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, booleanc|jj|}t|trpt |j s[|j j dk(sBt|tr$t |jdj st|dt|trCt|jtst|jtrt|dyy)rbooleanrz7: boolean label can not be used without a boolean indexz+: boolean values can not be used in a sliceN)rrrrzrrr~rCget_level_valuesrr,startstop TypeError)rZrryrs r\rz_LocIndexer._validate_keys0XX   % c4 "(( #xx}} )2z*!""5"5a"8">">?%NO  c5 ! syy$ ':chh+Ese#NOP P,F "r^cy)NTrYrLs r\rz&_LocIndexer._has_valid_setitem_indexersr^c$t||jk7ryt|D]i\}}t|sy|jj |}t |tryt |tr|jry|jriyy)rFT) rrr r%rrrrCrw!_supports_partial_string_indexing_index_as_unique)rZrrrrs r\rBz_LocIndexer._is_scalar_accesss s8tyy cN DAqQ<q!B"j)!S!b&J&J&&  r^cNtd|Dsytd|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`. c32K|]}t|ywrX)r?rs r\rz6_LocIndexer._multi_take_opportunity..s8q'*8rFc3FK|]}tj|ywrX)rrrs r\rz6_LocIndexer._multi_take_opportunity..s;!s**1-;s!)rrrs r\_multi_take_opportunityz#_LocIndexer._multi_take_opportunitys+$8C88;s;;;;r^c t||jjdDcic]\}}||j||}}}|jj |dScc}}w)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 Tr allow_dups)rr _AXIS_ORDERS_get_listlike_indexer_reindex_with_indexers)rZrrryds r\ _multi_takez_LocIndexer._multi_takesk& #3(=(=dK d $,,S$7 7  xx..qT.BB  sA#c|j|||j||\}}|jj|||gidS)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). Trk)rrnrro)rZrrykeyarrrs r\_getitem_iterablez_LocIndexer._getitem_iterable-sW. 3%44S$?xx.. FG$ %$/  r^ctt5|j|}|j|cdddS#1swYnxYw|j |}|j |r|j |S|j|SrX)rrrr4rrirqr(rs r\rDz_LocIndexer._getitem_tupleLs m $ /'',C))#. / / / **3/  ' ' ,##C( (++C00s "<Ac<|jj||Sr)rxs)rZlabelrys r\ _get_labelz_LocIndexer._get_labelZsxx{{5t{,,r^c|jxsd} |j||S#t$rP}|jt |cxkr$|j j jkr|td|d}~wwxYw)NrrzNo label returned) ryryrrrrrnlevelsr)rZrryeks r\r/z._LocIndexer._handle_lowerdim_multi_index_axis0^styy~A =??3T?2 2 =yy3s8=txx~~'='==> 34" <  =s% A>A A99A>c4t|}t|r t|}|tur t d}|j j |}t|trt|tr t|}t|tr%|j|||j||Stj|r|j||St|rt|trt|ts9t!|dr|j"dkDr t%d|j'||St)||r|j+|}t dg|j"z}|||<|j j,t|}t/d|D}|sg}t1|D]c\} } t3| s|j5| #t| ts4 |j6| j9| |j5| e|r@t=||j>k\r|jAd|}|S|jC||}|S|j|||jE||S#t:$rYwxYw)Nrrrz&Cannot index with multidimensional keyc3jK|]+}t|txstj|-ywrX)rr,rrrs r\rz,_LocIndexer._getitem_axis..s/(GHJq%(BC,?,?,BB(s13r)#rr!rrr,rrrrrCr_get_slice_axisrrrRr?r9rr rtrget_locsrhrr r"appendlevelsrrrr{_ixs droplevelry) rZrryrPlocsrresulthas_slice_or_masklevels_to_droprrs r\r%z_LocIndexer._getitem_axislsY$ s s)C (?+C##D) c5 !j&D*C c5 !   sD )''$'7 7   %%%c%5 5 !# &sE*z&*/M3'CHHqL$%MNN--c-==sF+s+?DT{mdii>W $ uW~6%((LO(%!)%'N"+C. %Q+A*11#6'51% & c 2 : :1 = . 5 5c : %&~.&..@&,[[[%>F &,%5%5n4%5%PF  3%s..$,% $%s1/J  JJcl|j}t|s|jdS|j|}|j |j |j |j}t|tr|jj||S|jj||S)zL This is pretty simple as we just have to deal with labels. Fr r) rr1rr slice_indexerr_r`steprr,_slicerO)rZ slice_objryrrPrs r\rz_LocIndexer._get_slice_axiss hh)$888' 't$&&y  W gu %88??7?6 688==t=4 4r^cx|jj|}t|tr|j |dSt|t r8t|t s(|jdkrt|dkDr tdd}t|t rtd|D}t|st|t rt|r|s |j|St'||r=|jdk(rtd |Dr td|j)|St+|rNt-|r t/|}t1j2|rt5||}|S|j7||dS |j|S#t$rBt|t r/t|t rt||jk(rd|icYSYt $rt|t sYt"$rt%|sd|icYSwxYw#t$rt+|sd|icYSwxYw) a Convert indexing key into something we can use to do actual fancy indexing on an 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 rl)rrrrFc3<K|]}t|tywrXr+)rvs r\rz2_LocIndexer._convert_to_indexer..s C!Au!5 Crrc3<K|]}t|tywrXr8rs r\rz2_LocIndexer._convert_to_indexer..s%HqjE&:%Hr)rrrr,_convert_slice_indexerrrCrrrrr%rr LookupErrorr{rr r rrr?r!rrrrNrn)rZrryrPcontains_slices r\rz_LocIndexer._convert_to_indexers##D) c5 !0050A A sE "vz2 A C1  34 4 c5 ! Cs CCN S> vz *{3/?  $~~c** 3 'yyA~#%HC%H"H#$788??3' ' !# &33i""3'(5 11#t>1 %s|+$ !&*56 $!#s|# $. +C0!3<'  s7FHAH H#H?HHH97H9c|jj|}|jj|}|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. )rr_get_axis_name_get_indexer_strict)rZrryr axis_namersrs r\rnz!_LocIndexer._get_listlike_indexersL.XX   %HH++D1 00i@wr^N)ryrGr_rTrYrrr_rzrVrWrXrr,ryrH)r`rarbrcr{rZrxrrrBrirqrtrDryr/r%rrrnrYr^r\rmrmUshKZ It :(QTD<0C2 > 1- =B/H5&N`r^rmceZdZdZdZdZddZddZddZddZ ddZ d d Z d d Z d!d Z d"d Zd ZddZd#dZd$d#dZd%dZd&dZ d'dZd(dZd#dZdZdZ d) d*dZd+dZy),ria Purely integer-location based indexing for selection by position. .. versionchanged:: 3.0 Callables which return a tuple are deprecated as input. ``.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 `. 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]) >>> 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]]) >>> 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 zlinteger, integer slice (START point is INCLUDED, END point is EXCLUDED), listlike of integers, boolean arrayTctj|rLt|dr?t|jt r%|jj dk(rytdyt|tryt|r|j||yt|tr tdt|rt|tr |j}n#t!|r|}nt#j$|}t'|j(j+|}t-|j.st1d|t'|r~t|j.t2r#|j5d}|j5d}n*t#j6|}t#j8|}||k\s|| kr t1dyytd |j:d ) NrintegerzBiLocation based boolean indexing cannot use an indexable as a maskrz%.iloc requires numeric indexers, got maxmin%positional indexers are out-of-boundsz#Can only index by location with a [])rrr9rrrB inferred_typer r,r _validate_integerrrr?r3rrrr:rrrr#r IndexErrorr+_reducerrrx)rZrryarrlen_axisarr_maxarr_mins r\rz_iLocIndexer._validate_keys   s #sG$CIIu)E99**i7 X  c5 !  _  " "3 - U # 34 4 !# &#y)kk3C8hhsm488--d34H$CII. #H!NOO3xcii8!kk%0G!kk%0G ffSkG ffSkGh&'XI*=$%LMM+>B4CTCTBUUVWX Xr^ct|tr tdt|tr t dt|t st |j|}t|jj|dD]b\}}t|trt|r#t|r|t|k\s=tdt|tsYtdy)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.FrT)rdictrr0rar_tuplifyrrrrr,r?r r)rZrrrs r\rz'_iLocIndexer._has_valid_setitem_indexers gt $DE E g| ,X  '5)tyy'2G> JEB!U#%a(AB<$%LMMAt$ !HII Jr^cXt||jk7rytd|DS)rFc32K|]}t|ywrX)r rs r\rz1_iLocIndexer._is_scalar_access..) s.Q:a=.r)rrrrs r\rBz_iLocIndexer._is_scalar_access s( s8tyy .#...r^cxt|jj|}||k\s|| kr tdy)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)rrrr)rZrryrs r\rz_iLocIndexer._validate_integer+ s= txx))$/0 (?cXIoIJ J.r^c|j|}tt5|j|cdddS#1swYnxYw|j |SrX)rrrr4r(rs r\rDz_iLocIndexer._getitem_tupleA sP**3/ m $ /))#. / / /++C00s <Acx |jj||S#t$r}td|d}~wwxYw)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. rrN)rrOr)rZrryr s r\_get_list_axisz_iLocIndexer._get_list_axisH s?" O88==4=0 0 ODE3 N Os 9 49cl|tur td}nt|tr t dt|tr|j ||St |r t|}t|trtj|}tj|r%|j|||j||St|r|j||St!|}t#|s t%d|j'|||j(j+||S)NzWDataFrame indexer is not allowed for .iloc Consider using .loc for automatic alignment.rz5Cannot index by location index with a non-integer key)rr,rr0rrr!rrasarrayrrrrRr?rrr rarrrrs r\r%z_iLocIndexer._getitem_axis_ s (?+C \ *?  c5 !''$'7 7 s s)C c4 **S/C   s #   sD )%%c%5 5"# &&&s&6 6$C(Cc? WXX  " "3 -88==4=0 0r^c|j}t|s|jdS|j|}|j ||jj ||S)NFr r)rr1rr_validate_positional_slicer)rZrryrrPs r\rz_iLocIndexer._get_slice_axis sWhh)$888' 't$)))4xxyt44r^c|S)zL Much simpler as we only have to deal with our valid types. rYrs r\rz _iLocIndexer._convert_to_indexer s  r^ct|r t|}|j!t|j|j|}|SrX)r!rryrrrs r\rz!_iLocIndexer._get_setitem_indexer s8 s s)C 99 (DIIsCC r^c<|jjj }|s't|tr|jj }|st |jjj r|jdkDrpt|trt|jn|}|jjj dj}t|t|d }t|trt |t |jjk(r`t||jjdD];\}}t|t st#|r#t%j&|r9d}n|st|trzt |dk(rlt#|dr^t#|dsPt)|rEt|t*tfs/|jjj dj,rd}|S)zD Decide whether we will take a block-by-block path. rrT extract_numpyrr)rris_single_blockrr0rblocksrrrvaluesrr<rrrrCr rr#r"r3 is_extension)rZrrtake_split_pathvalrrrs r\_decide_split_pathz_iLocIndexer._decide_split_path s#hhmm;;;:e\#B"'**"<"<>E--U3KeY/c2::.388q=SXQR]a&C*- GAJ' + 'DHHSMe$Gs488}DHHSM !eCJ.?(@uMCTXXbgg>>E--U3K#rzz*sxx1}SQ!f&)K #'DHHSM 8$((--P  "";t<r^c|jj}|j||}t|trMg}t |D]0\}}t |\}} | r|} |jdkDr||k(r|j|| ||y|jj|} t| | dd| jt| | } tjt| dztj} d| d<|| | fi}|jj!|d }|j"|j_|j%| j'|  |j%|3t |}n#t |\}} | r|j)||y|d k(r|j+||\}}|r|j-|||y|j/|||y) z _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. rr~Nrow on a DataFrame$Use a full-length tuple key instead.targethintrr-Trkrl)r_info_axis_numberrrrr convert_missing_indexerrrrmaybe_warn_multiindex_expansioninsertrrarangerrorrr_setitem_with_indexer_missingr _setitem_with_indexer_split_path_setitem_single_block)rZrrr~ info_axisrnindexerrrmissingrrrPr reindexersnew_objs r\rz"_iLocIndexer._setitem_with_indexer sHH.. 11'5A gu %H#G,( )36s; WCyy1}i00#u40P!HH..q1E33C  #\\#e*c:F IIc%j1nBGGDE "E"I"#fe_!5J"hh=="t>G%,LLDHHMOOFNN3$78OOC(Q( )THoG6w? GW227EB 5=!;;GUKNGU   1 1'5$ G  & &wt t |dk(r%t=|s|j?||df|dStd |dk(r,t |t |j j"k(ry t |t |k(r*tA||d D]\} } |j3| | |y t |dk(rDtCjD|r/t |j dk(r|j3|d||y td |D]} |j3| ||y ) z& Setitem column-wise. rztoo many indices for arrayrzCannot set values with ndim > 2rhrrrz@Must have equal len keys and value when setting with an iterableTrN)#rrrrrrrrr r3rrdrNr_ensure_iterable_column_indexerrArrr?r$r0!_setitem_with_indexer_frame_value_is_2d_value_for_columns_setitem_with_indexer_2d_valuer%_setitem_single_columnrBr$dtypesrr rrrr#) rZrrr~rNrilocsrlplane_indexerrlrs r\rz-_iLocIndexer._setitem_with_indexer_split_path_ s yyA~~'5)tyy'2G w<$)) #9: : gaj"** -'!*//A2E?@ @ ui (TV^ 5RV@W %&&wu >EAJ 44Y? QZ*2txx~~>  &75&!+Dq+H%.66wtL)%U<33GUCUq^s5z%A)TV-++E!HeR@''0_''a16 ++E!HeR@UqQ.%FCJ%F u:?:i+@ 55r9Q<6H%PQ(SS V 1$Us488>>7J)JUs5z)!%t<#E* :3jjA&++Cb9 :!5!5dhh6F6F!G :xx'',5=%)KN,,k* 1c6**C &&C++Cb9 :NO O :xx'',5=%)KN+C,,k**Cckk)!&&C++Cb9% :r^c|}tj|xs)tj|t|j}tj |xst |xrt|dk(}|ry|r+ |jjj|||dy|jjj|}|tjk(r;t'|t|j} |jj%|| |jjj|||y#tttf$r}|jjj|}|tjt fvr)|jj"std|d|d||jj%||Yd}~yd}~wwxYw)z Parameters ---------- loc : int Indexer for column position plane_indexer : int, slice, listlike[int] The indexer we use for setitem along axis=0. rNT) inplace_onlyzInvalid value 'z ' for dtype '')rr# is_full_slicerris_empty_slicerrcolumn_setitemr rarrrhrvoidobjectemptyrr5) rZrlr plane_indexerris_full_setteris_null_setterexcrrs r\rz#_iLocIndexer._setitem_single_column s**2.V#2C2CBDHH 2V++B/ .r 2 Cs2w!|     . ,,D-4HHOO((-EF3txx=!!#w/ HHMM ( (mU CG +<= .,,S1& 11$((..$)% eWAF!!#u--' .s;)D>>GBGGc ddlm}t|tr|dk7st|tr|j |||}|j j}|j j|}t|tr|jt|cxk(rdk(rwnntt|drftj|drN|||}t|j|gdk(r(|j!|}|j#|||dy|jdk(rt|dk(r|j j$ddkDr~tj|dsft|t&sVt)|j j*j,dj.t1|ds|j3|||y|jdk(r1t|dk(r"t|dst5|dst|t&st7|rt9|d ddk(rt|dt:t<t>t@jBttDfrt9|dd ddk(r|jG|d} t| dk(rmtI|dsa| d}t|rQtK|d|j jL} | t|k(r |j#tO|||dytQ|}t|t&r!|dk7r|jS||jT}|j j*jW|| |j _y) zQ _setitem_with_indexer for the case when we have a single Block. rrrhrrNTrr)rr),rdrNrr3rrrrrrrrr rr#get_indexer_forrrrr0rrrrr<rr%r?r$r,rrrrr2rrrArintmaybe_convert_ixrrsetitem) rZrrr~rNr item_labelsrrlrnrowss r\rz"_iLocIndexer._setitem_single_blockT s " ui (TV^ 5RV@W&&wu >EHH.. hh((3 gu %  S\.Q.wqz*%%gaj1!')"45{22C59:a?%--c2C//UGAJG QLA%HHNN1%)))'!*5"5,7(HHMM((+22!%t< 55gudK QLA%#71:.!'!*-"5,7(/E61-2 AJtRZZH UGAJ2a7<}n`tA|r6t|t|jj2k7r tCd|||jj2| }t|js|jEjF} |jj} t7| tHr | jJ} n | j.} tM|g| | _|s| jO} | j0|j_y|jjQ|j0|j_yy)zN Insert new row(s) or column(s) into the Series or DataFrame. rrrzvalue on a Seriesrrr-NrlF)compat warn_if_castrrrzaUse a full-length tuple key and an explicit column indexer instead, e.g. df.loc[key, :] = values.)rrrr)rr~rz(cannot set a row with mismatched columnsr))rdrNrrrrrrrrrrr%r6rr$r8rr:rr;r'rr~rrr9rr3reindexrrr?r to_framerKrCnamesrB infer_objects_append_internal) rZrrrNr new_indexr new_values has_dtypedfrr~s r\rz*_iLocIndexer._setitem_with_indexer_missing sH " 99>HHNNE +*;    SZ9I$// "#? 2%**,55k5%PPU#&udhhnn=&txx~~6.txx~~eLE1eJ488##$6E  #E r^ct|ttjtt fr|f}t|t rt|dk(r]t|dtjr@|djtjk(r |dtj|ddf}d}t t||}|Dcgc]}tj| }}t|}|dk(}|jdk(} |j } | r |xr|d}t#d|Dr|j%| j&d|dj(} t|dkDrr|spt|dtrt| j&d|d} nt|d} tj*| | j-| dj.} | St1|D]:\} }| j&| }t3|st|tr|rtj|rI||}t5|s t |g}n t |}t|r|j6j9|r|j(cS|j%|j(cS|s|j j&d}|j6j9|s t|s|j(j;cS|j%|j(cStCdt=|r|jdk(rt?|j jr|S|j jAd}|j6j9|r|j(j;S|j%|j(|St=|rk|j jAd}|j6j9|r|j(j;S|j%|j(StCdcc}w)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` rrrcZt|tjr|jS|SrX)rrrravel)rs r\r!z)_iLocIndexer._align_series..ravelO s $.q"**$=qwwyD1Dr^c3VK|]!}t|xst|t#ywrX)r&rr,)r_s r\rz-_iLocIndexer._align_series..d s#Ka;q>9Z5%99Ks')r-z Incompatible indexer with Series)"rr,rrrrBrrrbool_wheremaprr#sumrrrrrrtilereshaperKr r&r?rrrr r$rr )rZrrrr!raligners sum_alignerssingle_aligneris_framer ser_values len_indexerrrnew_ixs r\rz_iLocIndexer._align_series- s, grzz4? @jG gu %G !wqz2::6AJ$$0"1:rxx ';A'>? ECw/0G>EFsC--c22FHFx=L)Q.NyyA~H((C!/!?HQKK7KK [[!WQZ)@AII w!'!*e4&)#((1+gaj*A&B &)'!*o  K8@@bQSS"!#G, 33XXa[s#z#u'=%#*;*;C*@ WF/7!&x!&vv;#))*:*:6*B"{{*;;v.666$q)Byy''+3r7"{{//11;;r?222/ 3X;<<' TYY!^txx~~. ##A&Byy#{{''));;r?**73 3  ##A&Byy#{{''));;r?** *;< gu %"ICI"7+ (2XX]]1%r?jU&;!"bjj1ZZ^{ f!"v$$Q' (4#388??3'BJJ,=,=d,C'')C **S$*7C %(,@,Ix(Bxxr"ggiJr:."288Z8 bhh&6&66#5 jjrj*J>??r^NrUrYr)rzint | np.integerryrHr_rTrWrXr)rrKryrHr_rK)r~rwr_rT)rh)r~rwrS)rrMr~rwr_rT)rlr r_rT)F)rrNrrzr_zArrayLike | Series)rrMr_rM)r`rarbrcrxr{rrrBrrDrr%rrrrrrrrrrrrrrrrYr^r\riri2sM` BI +YZ"H /K,1O.#1J 5 1f?BH=TVD@ULnoFb*$) r=r=! r=  r=h/@r^ric0eZdZUdZded<dZdZddZy) _ScalarAccessIndexerz! Access scalars quickly. rzr{ct|rXrrs r\ _convert_keyz!_ScalarAccessIndexer._convert_key r;r^ct|tst|s|f}n td|j |}|j j |d|jiS)N)Invalid call for scalar access (getting)!rA)rrr?r r8rrCr{rs r\r]z _ScalarAccessIndexer.__getitem__ sW#u%',f !LMM$"txx""CA$..AAr^ct|trtfd|D}n tj|j}t|tst j |}tj|}t|j k7r tdjj||jdy)Nc3^K|]$}tj|j&ywrXrrs r\rz3_ScalarAccessIndexer.__setitem__.. rrz0Not enough indexers for scalar access (setting)!)rrA) rrrrrrrrr8rr  _set_valuer{)rZrrs` r\rz _ScalarAccessIndexer.__setitem__ s c5 !HCHHC''TXX6C#u%499c*C4$$S)* s8tyy OP PSGr^NrS)r`rarbrcrZr8r]rrYr^r\r6r6 s O( B Hr^r6cReZdZdZdZdZddZed dZfdZ dfd Z xZ S) rpa 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 ` 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 FcF|jdk(rt|dkDr|f}|S)zd Require they keys to be the same type as the index. (so we don't fallback) r)rrrs r\r8z_AtIndexer._convert_key= s% 99>c#hl&C r^ch|jdk(rVt|trt|dk7ry|d|jj f|d|jj fg}n>|}t|trt|dk(r|d}||jj fg}|D]u\}}t|ts t|rt|ts2 ||v}|s:|jdk(rdnd}tjd|dtt yy#ttf$rYwxYw) zI GH#48323 - Warn if .at setitem would expand the object. rNrrrMrNzSetting a value on a z via .at with a key that does not exist in the index is deprecated and will raise a KeyError in a future version. Use .loc instead.r)rrrrrrrr,r?rarrrrr)rZrchecks check_keyry is_expandingobj_types r\_warn_if_expandingz_AtIndexer._warn_if_expandingJ s+ 99>c5)SX]1vtxx~~.Q9I9I0JKFI#u%#c(a-F  $((..12F% OIt)U+/CI/N!)U3 (4 *.))q.;h +H:6((#/1 - 01  sDD10D1c|jdk(sJ|jjjxr |jjjS)Nr)rrrrrrjs r\_axes_are_uniquez_AtIndexer._axes_are_uniquep s=yyA~~xx~~''FDHH,<,<,F,FFr^c|jdk(rR|jsFt|trt d|Ds t d|j j|St|%|S)Nrc32K|]}t|ywrXr%rs r\rz)_AtIndexer.__getitem__..y 4OaYq\4Orr:) rrGrrrr rrlsuperr])rZr __class__s r\r]z_AtIndexer.__getitem__v s\ 99>$"7"7c5)4O34O1O !LMM88<<$ $w"3''r^ctsFtj|jtkr t j ttd|j||jdk(rS|jsGt|trtd|Ds td||jj |<yt"|I||S)Nrrc32K|]}t|ywrXrJrs r\rz)_AtIndexer.__setitem__.. rKrz)Invalid call for scalar access (setting)!)rrrrrrrrrrErrGrrrr rlrLrrZrrrMs r\rz_AtIndexer.__setitem__ s'txx(M9 +-CPQ $ 99>$"7"7c5)4O34O1O !LMM %DHHLL  w"3..r^rSrY) r`rarbrcr{r8rErtrGr]r __classcell__rMs@r\rprp s@?BI $LGG (//r^rpc.eZdZdZdZdZdfd ZxZS)rsa 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 Tc@|D]}t|rtd|S)zH Require integer args. (and convert to label arguments) z1iAt based indexing can only have integer indexers)r r )rZrrs r\r8z_iAtIndexer._convert_key s/ VAa= !TUU V r^ctsFtj|jtkr t j ttdt|)||S)Nrr) rrrrrrrrrrLrrPs r\rz_iAtIndexer.__setitem__ sD'txx(M9 +-CPQw"3..r^rS)r`rarbrcr{r8rrQrRs@r\rsrs s*XI//r^rsct|tr |jSt|ttj t tfr|St j|tS)a| Return a row of a 2D setitem value that can be indexed by position. ``_setitem_with_indexer_2d_value`` extracts each column with ``row[i]``, which is wrong for a Series (indexed by *label*) and for a foreign array such as ``pyarrow.Array`` (``__getitem__`` hands back a boxed scalar). Rows that already index positionally are returned as-is, to skip a copy. Anything else goes through ``np.asarray``, as every row did before GH#64230 replaced it with ``row[i]``; ``dtype=object`` is what keeps a heterogeneous row from being collapsed onto one numpy dtype, and ``pd.NA`` from becoming ``nan``. r) rr3rrrrr1r2rr)rs r\rr sF#y!{{#rzz+Q r^cpt|Dcgc]}tdd}}||d<t|Scc}w)z Given an indexer for the first dimension, create an equivalent tuple for indexing over all dimensions. Parameters ---------- ndim : int loc : object Returns ------- tuple Nr)rr,r)rrlr#_tups r\rrs:(-T{ 3!E$  3D 3DG ; 4s3c@tdg|z}|||<t|S)zI If we have an axis, adapt the given key to be axis-independent. N)r,r)rryrrs r\rr's'T{md"GGDM >r^c|}t|tr|jj|st|jj |}d|vr t d|j |}t|jts|jtjSt|rtj|t}nt|st!|t}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)rr3rrr rrOrr+astyperzrr$rrrrr>)rrrrs r\rNrN0s4F#y!#))*:*:5*A,,..u5 =4  W%&,,7==&.. .sF$/ / 7&- uf --r^crt|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 rz.cannot use a single bool to index into setitemTF)rrrzr)rs r\rrdsA '4 %. gt $KL L} E>r^cJfdtfdt|DS)zK Create a filtered indexer that doesn't have any missing indexers. cVt|tr|j|dS|S)Nr)rrr)_i_idxrs r\rz7convert_from_missing_indexer_tuple..get_indexerys*0:40FtBxU ,PDPr^c36K|]\}}||ywrXrY)rrgrhrs r\rz5convert_from_missing_indexer_tuple..|sJ82tR&Jr)rr )rrrs `@r\rrts! Q Jy7IJ JJr^c|D]0}t|tjttt fr.|cStj |S)z3 We likely want to take the cross-product. )rrrrr3rBix_)argsr[s r\r r s?# D)UCDK 664=r^ct|tsy|D]/}t|st|tst|tcSy)& Returns ------- bool F)rrr"r,rC)rrPrs r\rrsB c5 ! 2 ?jE2fj1 12 r^cTt|t xrt| xr|tuS)rn)rr,r?rrs r\r0r0s3 sE "" $S) ) x r^c|jduxs/|jduxs|jduxr|jdk7S)rnNr)r_r`r)rs r\r1r1sD  4 884  4 HHD 2SXX]r^ct|ts"t|trtd|Dr t dt|t s"t|trtd|Dr t dyy)zX Check if the indexer is or contains a dict or set, which is no longer allowed. c3<K|]}t|tywrX)rsetrs r\rz-check_dict_or_set_indexers..s&Gaz!S'9&GrzAPassing a set as an indexer is not supported. Use a list instead.c3<K|]}t|tywrX)rrrs r\rz-check_dict_or_set_indexers..s&Hqz!T':&HrzBPassing a dict as an indexer is not supported. Use a list instead.N)rrtrrrarrps r\rrsq#s33&G3&G#G O  #t33&HC&H#H P  $Ir^c,|j}t|tr |jn|}t|tjrN|j dvr@t|tj r&|jj dk(r t||syt|trtt j||St|ttttjfs|dk(r t||S tj5tjdt!||}dddt%t jt&t j|t&S#1swYGxYw#t"$rYywxYw)z Can new_arr's values be set losslessly into an array of orig's dtype? Decides whether a dtype change during setitem-with-expansion gets the GH#62369 deprecation warning. iufFstringignorerN)rrr- numpy_dtyperrrrrrr.r,r*rcatch_warnings simplefilterr Exceptionr4r)origrrnp_dtype converteds r\_expansion_can_holdrs= JJE$.ul$Cu  H8RXX& MMT ! w + MM  # %((; %&  4 0'::%+}orxxPQ  g..   $ $ & 7  ! !( + 6I  7  9F+RZZv-N  7 7  s*>F#E;5F;FF FFct|trTt|trt||jk(s+t j d|d|ttyyy)z GH#17024 warn when expanding a MultiIndex axis with a key that is not a full-length tuple. Depending on the path, such keys currently either flatten the MultiIndex to an Index of tuples or get padded with "". zSetting a new zq with a MultiIndex using a key that is not a full-length tuple is deprecated and will raise in a future version. rN) rrCrrr{rrrr)rrrrs r\rrs^ %$33s8u}}#< VH%#f & ')  $=%r^ct|tjr!|jtjdS|j tjtj S)zJ Numpy float64 representation of a numeric array, with NA as NaN. Fr)rna_value)rrrrcfloat64to_numpyr)rs r\ _as_float64r sD#rzz"zz"**5z11 <d|d|jd|jd t@tC |||}|S#t*t,f$rYwxYw#t4t*t,f$rYwxYw) NrxrwmMF)round_okz~Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. The existing dtype z: cannot hold the value being set, so the result has dtype z. Cast the object to z6 before this operation to retain the current behavior.r)"_cast_pointwise_resultrrr-r{r}_ndarrayrrr+rrr(r)r/subtyperrisnanrcr4r rar;as_unitunitAttributeErrorr7rrrrrr) rrrrarr_typefloatsrrwrapped pdep6_alloweds r\rrsy ))'2G JJE%&!!H'--.=""7==#&;ud+C)'595.) JJ$  MM  # %  )F%*o!>? ,,E;/ == #;(()8$$NN4::6 $K $:FC'G t   619 $ EBI %'#}}, t $ $GMM3/ $W !!#  %8w%G MM&&+W-007 ?$]]O,/ 0 +- 7# NWI&    I6   s%B$I>#J>JJJ*)J*)rYr r_rzrY)rr rlrDr_ztuple[Hashable | slice, ...])rr ryrHr_r)rrBr_ np.ndarray)rrrz list[Index]r_r)rr,r_rzrS)rrOr_rz)rrBrrwrrwr_rT)rrFr_r)rrOrrzr_rF) __future__r collectionsr contextlibrrtypingrrrr r r r rnumpyrpandas._libs.indexingr pandas._libs.librr pandas.compatrpandas.compat._constantsr pandas.errorsrrrrrrpandas.errors.cowrpandas.util._exceptionsrpandas.core.dtypes.castrrrpandas.core.dtypes.commonrrrr r!r"r#r$r%r&pandas.core.dtypes.concatr'pandas.core.dtypes.dtypesr(r)r*r+r,r-r.r/pandas.core.dtypes.genericr0r1r2r3pandas.core.dtypes.missingr4r5r6r7r8 pandas.corer9rpandas.core.commoncorecommonrpandas.core.constructionr:rr;r<r=pandas.core.indexersr>r?r@rApandas.core.indexes.apirBrCcollections.abcrDrEpandas._typingrFrGrHrIrJrKrLrdrMrNpandas.core.arraysrOpandas.core.baserPrr,rQrZrRrSrrrV IndexSlicerarfrvrmrir6rprsrrrXrrrNrrr rr0r1rrrrrrYr^r\rsV" 43264   4    ,     2."' (>(IE(QSV(V"WiW E!$44u=Ms=R7SSi 3;KL D$B00f]  n (n (bb.)b.JZ "Z z^@#^@B%#H-#HLX/%X/v?/&?/D)($.(1.h  K"   &0f $; ^ ^ ^  ^r^