d]<UdZddlmZddlZddlmZmZmZmZm Z m Z m Z m Z m Z mZddlZddlmZddlmZddlmZmZmZmZmZmZmZddlmZdd lm Z!dd l"m#Z#dd l$m%Z%m&Z&dd l'm(Z(dd l)m*Z*m+Z+m,Z,m-Z-m.Z.ddl/m0Z0m1Z1m2Z2ddl3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAmBZBerddlmCZCmDZDmEZEmFZFddlGmHZHmIZImJZJiZKdeLd<dddddZMe ddZNGdde;ZOGd d!ZPGd"d#eeZQGd$de=ZRdS)%z. Base and utility classes for pandas objects. ) annotationsN) TYPE_CHECKINGAnyGenericHashableIteratorLiteralTypeVarcastfinaloverload)using_copy_on_write)lib)AxisAxisIntDtypeObj IndexLabelNDFrameTShapenpt)PYPY)functionAbstractMethodError)cache_readonlydoc)can_hold_element)is_categorical_dtype is_dict_likeis_extension_array_dtypeis_object_dtype is_scalar) ABCDataFrameABCIndex ABCSeries)isnaremove_na_arraylike) algorithmsnanopsops) DirNamesMixin)OpsMixin)ExtensionArray)ensure_wrapped_if_datetimelike extract_array)DropKeep NumpySorterNumpyValueArrayLike ScalarLike_co) CategoricalIndexSerieszdict[str, str] _shared_docs IndexOpsMixin)klassinplaceunique duplicated_T)boundcXeZdZUdZded<edZddZddd Zdfd Z xZ S) PandasObjectz/ Baseclass for various pandas objects. zdict[str, Any]_cachec t|S)zJ Class constructor (for this class it's just `__class__`. )typeselfs L/var/www/html/t/fyr/venv311/lib/python3.11/site-packages/pandas/core/base.py _constructorzPandasObject._constructorls Dzzreturnstrc6t|S)zI Return a string representation for a particular object. )object__repr__rEs rGrNzPandasObject.__repr__ss t$$$rINkey str | NoneNonect|dsdS||jdS|j|ddS)zV Reset cached properties. If ``key`` is passed, only clears that key. rBN)hasattrrBclearpop)rFrOs rG _reset_cachezPandasObject._reset_cachezsVtX&&  F ; K        KOOC & & & & &rIintct|dd}|r>|d}tt|r|n|St S)zx Generates the total memory usage for an object that returns either a value or Series of values memory_usageNTdeep)getattrrWr"sumsuper __sizeof__)rFrYmem __class__s rGr_zPandasObject.__sizeof__sm t^T::  =,D)))Cinn;ss#''))<< <ww!!###rI)rJrKN)rOrPrJrQrJrW) __name__ __module__ __qualname____doc____annotations__propertyrHrNrVr_ __classcell__)ras@rGrArAds  X %%%% ' ' ' ' ' $ $ $ $ $ $ $ $ $ $rIrAc"eZdZdZd dZd dZdS) NoNewAttributesMixina Mixin which prevents adding new attributes. Prevents additional attributes via xxx.attribute = "something" after a call to `self.__freeze()`. Mainly used to prevent the user from using wrong attributes on an accessor (`Series.cat/.str/.dt`). If you really want to add a new attribute at a later time, you need to use `object.__setattr__(self, key, value)`. rJrQc>t|dddS)z9 Prevents setting additional attributes. __frozenTN)rM __setattr__rEs rG_freezezNoNewAttributesMixin._freezes" 4T22222rIrOrKct|ddr@|dks:|t|jvs$t||dtd|dt|||dS)NrnFrBz"You cannot add any new attribute '')r\rD__dict__AttributeErrorrMro)rFrOvalues rGroz NoNewAttributesMixin.__setattr__s 4U + + N 8OOd4jj)))tS$''3 !Lc!L!L!LMM M4e,,,,,rIN)rJrQ)rOrKrJrQ)rdrerfrgrprorIrGrlrlsF  3333 - - - - - -rIrlceZdZUdZded<dZded<ded<d d gZeeZe e d Z e d Z e e ddZe e dZdZdddZdZeZdS)SelectionMixinz mixin implementing the selection & aggregation interface on a group-like object sub-classes need to define: obj, exclusions robjNzIndexLabel | None _selectionzfrozenset[Hashable] exclusionsrB __setstate__ct|jtttt t jfs|jgS|jSrb) isinstancerzlisttupler%r$npndarrayrEs rG_selection_listzSelectionMixin._selection_lists? OdE9h K   %O$ $rIcv|jt|jtr|jS|j|jSrb)rzr~ryr%rEs rG _selected_objzSelectionMixin._selected_objs1 ? "j9&E&E "8O8DO, ,rIrJrWc|jjSrb)rndimrEs rGrzSelectionMixin.ndims!&&rIct|jtr|jS|j|j|jSt |jdkr"|j|jddS|jS)NrT)axis only_slice) r~ryr%rz_getitem_nocopyrlenr{ _drop_axisrEs rG_obj_with_exclusionsz#SelectionMixin._obj_with_exclusionss} dh * * 8O ? &8++D,@AA A t  ! # # 8&&tQ4&PP P8OrIc|jtd|jdt|ttt t tjfrt|j j |tt|kr`tt||j j }tdt!|dd|t|dS||j vrtd||j |j}|||S) Nz Column(s) z already selectedzColumns not found: r)rzColumn not found: )rz IndexErrorr~rrr%r$rrrrycolumns intersectionset differenceKeyErrorrK_gotitemr)rFrObad_keysrs rG __getitem__zSelectionMixin.__getitem__s) ? &L$/LLLMM M cD%HbjI J J 148#005566#c#hh--GGC 3 3DH4D E EFFJS]]1R45HJJKKK==c=33 3$(""9C99:::8C=%D==4=00 0rIrc t|)a sub-classes to define return a sliced object Parameters ---------- key : str / list of selections ndim : {1, 2} requested ndim of result subset : object, default None subset to act on r)rFrOrsubsets rGrzSelectionMixin._gotitems"$'''rIc t|rbr)rFfuncargskwargss rG aggregatezSelectionMixin.aggregates!$'''rIrcrb)rrW)rdrerfrgrhrz_internal_namesr_internal_names_setr rirrrrrrrraggrvrIrGrxrxs' MMM$(J((((####0O#o..  X U--^-  '''^ U' ^ U 111 ( ( ( ( (((( CCCrIrxc  eZdZUdZdZedgZded<edodZ edpd Z e dqd Z ee dZ edrdZdsdZedtdZe dZedsdZedsdZedudZe ddejfdvd$Ze edwd%Zdxdyd*Zed+d,d-. dxdzd/Zdxdyd0Zeed,d+d1. dxdzd2Zd3ZeZd{d5Z e!dwd6Z"d|d8Z#d9d&ddd:d}d>Z$e d~d?Z%e dddEZ&dFZ'e dddGZ(edwdHZ)edwdIZ*edwdJZ+e dddLZ,ee-j.dMdMdMe/j0dNO dddRZ.dSe1dT<e2 ddd]Z3e2 ddd`Z3ee1dTdab dddfZ3dgdhddkZ4e dddlZ5dmZ6dnZ7dS)r8zS Common ops mixin to support a unified interface / docs for Series / Index itolistzfrozenset[str] _hidden_attrsrJrc t|rbrrEs rGdtypezIndexOpsMixin.dtype"$'''rIExtensionArray | np.ndarrayc t|rbrrEs rG_valueszIndexOpsMixin._valuesrrIrFr>c0tj|||S)zw Return the transpose, which is by definition self. Returns ------- %(klass)s )nvvalidate_transpose)rFrrs rG transposezIndexOpsMixin.transpose"s dF+++ rIzD Return the transpose, which is by definition self. )rrc|jjS)z Return a tuple of the shape of the underlying data. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.shape (3,) )rshaperEs rGrzIndexOpsMixin.shape5s|!!rIrWc t|rbrrEs rG__len__zIndexOpsMixin.__len__Bs!$'''rI Literal[1]cdS)zO Number of dimensions of the underlying data, by definition 1. rrvrEs rGrzIndexOpsMixin.ndimFs qrIc~t|dkrtt|Std)a  Return the first element of the underlying data as a Python scalar. Returns ------- scalar The first element of %(klass)s. Raises ------ ValueError If the data is not length-1. rz6can only convert an array of size 1 to a Python scalar)rnextiter ValueErrorrEs rGitemzIndexOpsMixin.itemMs6 t99>>T ## #QRRRrIc|jjS)zD Return the number of bytes in the underlying data. )rnbytesrEs rGrzIndexOpsMixin.nbytes`s |""rIc*t|jS)zG Return the number of elements in the underlying data. )rrrEs rGsizezIndexOpsMixin.sizegs 4<   rIr-c t|)aM The ExtensionArray of the data backing this Series or Index. Returns ------- ExtensionArray An ExtensionArray of the values stored within. For extension types, this is the actual array. For NumPy native types, this is a thin (no copy) wrapper around :class:`numpy.ndarray`. ``.array`` differs ``.values`` which may require converting the data to a different form. See Also -------- Index.to_numpy : Similar method that always returns a NumPy array. Series.to_numpy : Similar method that always returns a NumPy array. Notes ----- This table lays out the different array types for each extension dtype within pandas. ================== ============================= dtype array type ================== ============================= category Categorical period PeriodArray interval IntervalArray IntegerNA IntegerArray string StringArray boolean BooleanArray datetime64[ns, tz] DatetimeArray ================== ============================= For any 3rd-party extension types, the array type will be an ExtensionArray. For all remaining dtypes ``.array`` will be a :class:`arrays.NumpyExtensionArray` wrapping the actual ndarray stored within. If you absolutely need a NumPy array (possibly with copying / coercing data), then use :meth:`Series.to_numpy` instead. Examples -------- For regular NumPy types like int, and float, a PandasArray is returned. >>> pd.Series([1, 2, 3]).array [1, 2, 3] Length: 3, dtype: int64 For extension types, like Categorical, the actual ExtensionArray is returned >>> ser = pd.Series(pd.Categorical(['a', 'b', 'a'])) >>> ser.array ['a', 'b', 'a'] Categories (2, object): ['a', 'b'] rrEs rGarrayzIndexOpsMixin.arrayns~"$'''rINFrnpt.DTypeLike | Nonecopyboolna_valuerM np.ndarrayc t|jr|jj|f||d|S|r:t |d}t d|d|tjurl|j }t||stj ||}n| }||tj|<n|j }tj ||}|r|tjus|s}t!rotj|j dd|ddrEt!r#|s!|}d|j_n| }|S) a A NumPy ndarray representing the values in this Series or Index. Parameters ---------- dtype : str or numpy.dtype, optional The dtype to pass to :meth:`numpy.asarray`. copy : bool, default False Whether to ensure that the returned value is not a view on another array. Note that ``copy=False`` does not *ensure* that ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that a copy is made, even if not strictly necessary. na_value : Any, optional The value to use for missing values. The default value depends on `dtype` and the type of the array. **kwargs Additional keywords passed through to the ``to_numpy`` method of the underlying array (for extension arrays). Returns ------- numpy.ndarray See Also -------- Series.array : Get the actual data stored within. Index.array : Get the actual data stored within. DataFrame.to_numpy : Similar method for DataFrame. Notes ----- The returned array will be the same up to equality (values equal in `self` will be equal in the returned array; likewise for values that are not equal). When `self` contains an ExtensionArray, the dtype may be different. For example, for a category-dtype Series, ``to_numpy()`` will return a NumPy array and the categorical dtype will be lost. For NumPy dtypes, this will be a reference to the actual data stored in this Series or Index (assuming ``copy=False``). Modifying the result in place will modify the data stored in the Series or Index (not that we recommend doing that). For extension types, ``to_numpy()`` *may* require copying data and coercing the result to a NumPy type (possibly object), which may be expensive. When you need a no-copy reference to the underlying data, :attr:`Series.array` should be used instead. This table lays out the different dtypes and default return types of ``to_numpy()`` for various dtypes within pandas. ================== ================================ dtype array type ================== ================================ category[T] ndarray[T] (same dtype as input) period ndarray[object] (Periods) interval ndarray[object] (Intervals) IntegerNA ndarray[object] datetime64[ns] datetime64[ns] datetime64[ns, tz] ndarray[object] (Timestamps) ================== ================================ Examples -------- >>> ser = pd.Series(pd.Categorical(['a', 'b', 'a'])) >>> ser.to_numpy() array(['a', 'b', 'a'], dtype=object) Specify the `dtype` to control how datetime-aware data is represented. Use ``dtype=object`` to return an ndarray of pandas :class:`Timestamp` objects, each with the correct ``tz``. >>> ser = pd.Series(pd.date_range('2000', periods=2, tz="CET")) >>> ser.to_numpy(dtype=object) array([Timestamp('2000-01-01 00:00:00+0100', tz='CET'), Timestamp('2000-01-02 00:00:00+0100', tz='CET')], dtype=object) Or ``dtype='datetime64[ns]'`` to return an ndarray of native datetime64 values. The values are converted to UTC and the timezone info is dropped. >>> ser.to_numpy(dtype="datetime64[ns]") ... # doctest: +ELLIPSIS array(['1999-12-31T23:00:00.000000000', '2000-01-01T23:00:00...'], dtype='datetime64[ns]') )rrrz/to_numpy() got an unexpected keyword argument 'rrrNrF)r rrto_numpyrkeys TypeErrorr no_defaultrrrasarrayr asanyarrayr&r shares_memoryviewflags writeable)rFrrrrrvaluesresults rGrzIndexOpsMixin.to_numpys~ $DJ / / &4:&uU4(UUfUU U  FKKMM**1-HM(MMM  3> ) )\F#FH55 'F%88819F2=-- . .\FF%000  +X//0,..0 RaR 0&!*== +&((++#[[]]F-2FL**#[[]]F rIc|j Srb)rrEs rGemptyzIndexOpsMixin.empty3s9}rITrAxisInt | Noneskipnactj|tj||tj|j|S)a Return the maximum value of the Index. Parameters ---------- axis : int, optional For compatibility with NumPy. Only 0 or None are allowed. skipna : bool, default True Exclude NA/null values when showing the result. *args, **kwargs Additional arguments and keywords for compatibility with NumPy. Returns ------- scalar Maximum value. See Also -------- Index.min : Return the minimum value in an Index. Series.max : Return the maximum value in a Series. DataFrame.max : Return the maximum values in a DataFrame. Examples -------- >>> idx = pd.Index([3, 2, 1]) >>> idx.max() 3 >>> idx = pd.Index(['c', 'b', 'a']) >>> idx.max() 'c' For a MultiIndex, the maximum is determined lexicographically. >>> idx = pd.MultiIndex.from_product([('a', 'b'), (2, 1)]) >>> idx.max() ('b', 2) r)rvalidate_minmax_axis validate_maxr)nanmaxrrFrrrrs rGmaxzIndexOpsMixin.max8?P %%% f%%%}T\&9999rIrminlargest)opopposeruc6|j}tj|tj|||}t |t r>|s(|rdS|Stj ||S)ab Return int position of the {value} value in the Series. If the {op}imum is achieved in multiple locations, the first row position is returned. Parameters ---------- axis : {{None}} Unused. Parameter needed for compatibility with DataFrame. skipna : bool, default True Exclude NA/null values when showing the result. *args, **kwargs Additional arguments and keywords for compatibility with NumPy. Returns ------- int Row position of the {op}imum value. See Also -------- Series.arg{op} : Return position of the {op}imum value. Series.arg{oppose} : Return position of the {oppose}imum value. numpy.ndarray.arg{op} : Equivalent method for numpy arrays. Series.idxmax : Return index label of the maximum values. Series.idxmin : Return index label of the minimum values. Examples -------- Consider dataset containing cereal calories >>> s = pd.Series({{'Corn Flakes': 100.0, 'Almond Delight': 110.0, ... 'Cinnamon Toast Crunch': 120.0, 'Cocoa Puff': 110.0}}) >>> s Corn Flakes 100.0 Almond Delight 110.0 Cinnamon Toast Crunch 120.0 Cocoa Puff 110.0 dtype: float64 >>> s.argmax() 2 >>> s.argmin() 0 The maximum cereal calories is the third element and the minimum cereal calories is the first element, since series is zero-indexed. rr) rrrvalidate_argmax_with_skipnar~r-r&anyargmaxr) nanargmaxrFrrrrdelegates rGrzIndexOpsMixin.argmaxdsl< %%%/fEE h / /  )hmmoo1133 )r(((# rIctj|tj||tj|j|S)a Return the minimum value of the Index. Parameters ---------- axis : {None} Dummy argument for consistency with Series. skipna : bool, default True Exclude NA/null values when showing the result. *args, **kwargs Additional arguments and keywords for compatibility with NumPy. Returns ------- scalar Minimum value. See Also -------- Index.max : Return the maximum value of the object. Series.min : Return the minimum value in a Series. DataFrame.min : Return the minimum values in a DataFrame. Examples -------- >>> idx = pd.Index([3, 2, 1]) >>> idx.min() 1 >>> idx = pd.Index(['c', 'b', 'a']) >>> idx.min() 'a' For a MultiIndex, the minimum is determined lexicographically. >>> idx = pd.MultiIndex.from_product([('a', 'b'), (2, 1)]) >>> idx.min() ('a', 1) r)rr validate_minr)nanminrrs rGrzIndexOpsMixin.minrrIsmallestc6|j}tj|tj|||}t |t r>|s(|rdS|Stj ||S)Nrr) rrrvalidate_argmin_with_skipnar~r-r&rargminr) nanargminrs rGrzIndexOpsMixin.argmins< %%%/fEE h / /  )hmmoo1133 )r(((# rIc4|jS)a Return a list of the values. These are each a scalar type, which is a Python scalar (for str, int, float) or a pandas scalar (for Timestamp/Timedelta/Interval/Period) Returns ------- list See Also -------- numpy.ndarray.tolist : Return the array as an a.ndim-levels deep nested list of Python scalars. )rrrEs rGrzIndexOpsMixin.tolists"|""$$$rIrct|jtjst |jSt |jjt|jjS)a Return an iterator of the values. These are each a scalar type, which is a Python scalar (for str, int, float) or a pandas scalar (for Timestamp/Timedelta/Interval/Period) Returns ------- iterator ) r~rrrrmaprrangerrEs rG__iter__zIndexOpsMixin.__iter__sM$, 33 D %% %t|(% 0A*B*BCC CrIc^tt|S)z Return True if there are any NaNs. Enables various performance speedups. Returns ------- bool )rr&rrEs rGhasnanszIndexOpsMixin.hasnanss"DJJNN$$%%%rInpt.NDArray[np.bool_]c*t|jSrb)r&rrEs rGr&zIndexOpsMixin.isna!sDL!!!rIr)rr numeric_only filter_typenamerKrc t||d}|&tt|jd||dd|i|S)zA Perform the reduction type operation if we can. Nz cannot perform the operation rrv)r\rrDrd) rFrrrrrrkwdsrs rG_reducezIndexOpsMixin._reduce$sctT4(( <::&LLdLL t**6*T***rIc t|rit|trt|dr| fd}nz+IndexOpsMixin._map_values..Vs2#4(E22Irx{{IBFF$rIr)r6r)Nignorez+na_action must either be 'ignore' or None, z was passedrr4rNc,||Srb)rrfs rGr z+IndexOpsMixin._map_values..sfjjmmrIctj||t|tjSrb)rmap_infer_maskr&rruint8rs rGr z+IndexOpsMixin._map_values..s0#*<AtF||00::++rI)rr~dictrSpandasr6rrfloat64r%rindexnotnarrr rr get_indexerr(take_ndr NotImplementedErrorastyperMr map_infer) rFmapper na_actionr6msgcatrindexer new_valuesmap_fr s @rG _map_valueszIndexOpsMixin._map_values9s@0    ,&$'' ,GFM,J,J ,%+!*)))))v;;!###VF"*===FF#VF^^F fi ( (  000. ...!oo%H$$ 2 2 4 45$DJ// '=$,77wwv&\Fl..v66G#+FNGDDJ  $DJ / / &GDL%4P4P &\F$))33EE\((00FH$$" . ...!oo%U66** rI normalizesort ascendingdropnar6c6tj||||||S)a Return a Series containing counts of unique values. The resulting object will be in descending order so that the first element is the most frequently-occurring element. Excludes NA values by default. Parameters ---------- normalize : bool, default False If True then the object returned will contain the relative frequencies of the unique values. sort : bool, default True Sort by frequencies. ascending : bool, default False Sort in ascending order. bins : int, optional Rather than count values, group them into half-open bins, a convenience for ``pd.cut``, only works with numeric data. dropna : bool, default True Don't include counts of NaN. Returns ------- Series See Also -------- Series.count: Number of non-NA elements in a Series. DataFrame.count: Number of non-NA elements in a DataFrame. DataFrame.value_counts: Equivalent method on DataFrames. Examples -------- >>> index = pd.Index([3, 1, 2, 3, 4, np.nan]) >>> index.value_counts() 3.0 2 1.0 1 2.0 1 4.0 1 Name: count, dtype: int64 With `normalize` set to `True`, returns the relative frequency by dividing all values by the sum of values. >>> s = pd.Series([3, 1, 2, 3, 4, np.nan]) >>> s.value_counts(normalize=True) 3.0 0.4 1.0 0.2 2.0 0.2 4.0 0.2 Name: proportion, dtype: float64 **bins** Bins can be useful for going from a continuous variable to a categorical variable; instead of counting unique apparitions of values, divide the index in the specified number of half-open bins. >>> s.value_counts(bins=3) (0.996, 2.0] 2 (2.0, 3.0] 2 (3.0, 4.0] 1 Name: count, dtype: int64 **dropna** With `dropna` set to `False` we can also see NaN index values. >>> s.value_counts(dropna=False) 3.0 2 1.0 1 2.0 1 4.0 1 NaN 1 Name: count, dtype: int64 )r(r)r'binsr*)r( value_counts)rFr'r(r)r,r*s rGr-zIndexOpsMixin.value_countss1n&      rIc|j}t|tjs|}nt j|}|Srb)rr~rrr<r(unique1d)rFrrs rGr<zIndexOpsMixin.uniquesA&"*-- 1]]__FF(00F rIcj|}|rt|}t|S)a Return number of unique elements in the object. Excludes NA values by default. Parameters ---------- dropna : bool, default True Don't include NaN in the count. Returns ------- int See Also -------- DataFrame.nunique: Method nunique for DataFrame. Series.count: Count non-NA/null observations in the Series. Examples -------- >>> s = pd.Series([1, 3, 5, 7, 7]) >>> s 0 1 1 3 2 5 3 7 4 7 dtype: int64 >>> s.nunique() 4 )r<r'r)rFr*uniqss rGnuniquezIndexOpsMixin.nunique s3F   /'..E5zzrIcP|dt|kS)zr Return boolean if values in the object are unique. Returns ------- bool F)r*)r2rrEs rG is_uniquezIndexOpsMixin.is_unique1s#||5|))SYY66rIc.ddlm}||jS)z Return boolean if values in the object are monotonically increasing. Returns ------- bool rr5)rr5is_monotonic_increasingrFr5s rGr7z%IndexOpsMixin.is_monotonic_increasing<' !     uT{{22rIc.ddlm}||jS)z Return boolean if values in the object are monotonically decreasing. Returns ------- bool rr6)rr5is_monotonic_decreasingr8s rGr;z%IndexOpsMixin.is_monotonic_decreasingIr9rIr[ct|jdr|j|S|jj}|rLt |r=t s6t tj|j }|tj |z }|S)aN Memory usage of the values. Parameters ---------- deep : bool, default False Introspect the data deeply, interrogate `object` dtypes for system-level memory consumption. Returns ------- bytes used See Also -------- numpy.ndarray.nbytes : Total bytes consumed by the elements of the array. Notes ----- Memory usage does not include memory consumed by elements that are not components of the array if deep=False or if used on PyPy rYrZ) rSrrYrr!rr rrrrmemory_usage_of_objects)rFr[vrs rG _memory_usagezIndexOpsMixin._memory_usageVs2 4:~ . . :**+  J   5OD)) 5$ 5"*dl33F ,V44 4ArIr9z sort : bool, default False Sort `uniques` and shuffle `codes` to maintain the relationship. )rorder size_hintr(use_na_sentinel"tuple[npt.NDArray[np.intp], Index]c(tj|j||\}}|jtjkr|tj}t|tr| |}nddl m }||}||fS)N)r(rBrr6) r( factorizerrrfloat16rfloat32r~r$rHrr5)rFr(rBcodesuniquesr5s rGrEzIndexOpsMixin.factorizezs$$- Lt_   w =BJ & &nnRZ00G dH % % %''00GG $ $ $ $ $ $eGnnGg~rIa Find indices where elements should be inserted to maintain order. Find the indices into a sorted {klass} `self` such that, if the corresponding elements in `value` were inserted before the indices, the order of `self` would be preserved. .. note:: The {klass} *must* be monotonically sorted, otherwise wrong locations will likely be returned. Pandas does *not* check this for you. Parameters ---------- value : array-like or scalar Values to insert into `self`. side : {{'left', 'right'}}, optional If 'left', the index of the first suitable location found is given. If 'right', return the last such index. If there is no suitable index, return either 0 or N (where N is the length of `self`). sorter : 1-D array-like, optional Optional array of integer indices that sort `self` into ascending order. They are typically the result of ``np.argsort``. Returns ------- int or array of int A scalar or array of insertion points with the same shape as `value`. See Also -------- sort_values : Sort by the values along either axis. numpy.searchsorted : Similar method from NumPy. Notes ----- Binary search is used to find the required insertion points. Examples -------- >>> ser = pd.Series([1, 2, 3]) >>> ser 0 1 1 2 2 3 dtype: int64 >>> ser.searchsorted(4) 3 >>> ser.searchsorted([0, 4]) array([0, 3]) >>> ser.searchsorted([1, 3], side='left') array([0, 2]) >>> ser.searchsorted([1, 3], side='right') array([1, 3]) >>> ser = pd.Series(pd.to_datetime(['3/11/2000', '3/12/2000', '3/13/2000'])) >>> ser 0 2000-03-11 1 2000-03-12 2 2000-03-13 dtype: datetime64[ns] >>> ser.searchsorted('3/14/2000') 3 >>> ser = pd.Categorical( ... ['apple', 'bread', 'bread', 'cheese', 'milk'], ordered=True ... ) >>> ser ['apple', 'bread', 'bread', 'cheese', 'milk'] Categories (4, object): ['apple' < 'bread' < 'cheese' < 'milk'] >>> ser.searchsorted('bread') 1 >>> ser.searchsorted(['bread'], side='right') array([3]) If the values are not monotonically sorted, wrong locations may be returned: >>> ser = pd.Series([2, 1, 3]) >>> ser 0 2 1 1 2 3 dtype: int64 >>> ser.searchsorted(1) # doctest: +SKIP 0 # wrong result, correct would be 1 searchsorted.rur3sideLiteral['left', 'right']sorterr1np.intpcdSrbrvrFrurKrMs rGrJzIndexOpsMixin.searchsorteds  rInpt.ArrayLike | ExtensionArraynpt.NDArray[np.intp]cdSrbrvrPs rGrJzIndexOpsMixin.searchsorteds  rIr5)r:left$NumpyValueArrayLike | ExtensionArraynpt.NDArray[np.intp] | np.intpct|tr'dt|jd}t ||j}t|t js||||Stj||||S)Nz(Value must be 1-D array-like or scalar, z is not supported)rKrM) r~r#rDrdrrrrrJr()rFrurKrMr!rs rGrJzIndexOpsMixin.searchsorteds e\ * * ";;;';;; S// !&"*-- H&&u4&GG G&       rIfirstkeeprZr0c@||}||SNrY) _duplicated)rFrZr=s rGdrop_duplicateszIndexOpsMixin.drop_duplicates2s%%%4%00 ZK  rIc8tj|j|Sr\)r(r=r)rFrZs rGr]zIndexOpsMixin._duplicated7s$T\====rIcdtj||}|j}t|dd}tj||j}t |}tjd5tj |||}dddn #1swxYwY| ||S)NT) extract_numpy extract_ranger)all)r) r*get_op_result_namerr/maybe_prepare_scalar_for_oprr.rerrstate arithmetic_op_construct_result)rFotherrres_namelvaluesrvaluesrs rG _arith_methodzIndexOpsMixin._arith_method;s)$66,TNNN1'7=II099 [X & & & = =&w<rJr>)rJrrc)rJr)rJr-)rrrrrrMrJr)rJr)NT)rrrr)rrrrrJrW)rJr)rJr)rrKrrrrrb)FTFNT) r'rr(rr)rr*rrJr6)T)r*rrJrW)F)r[rrJrW)FT)r(rrBrrJrC)..)rur3rKrLrMr1rJrN)rurQrKrLrMr1rJrR)rTN)rurUrKrLrMr1rJrV)rZr0)rX)rZr0rJr)8rdrerfrg__array_priority__ frozensetrrhrirrr rTrrrrrrrrrrrrrrrrrto_listrrrr&rr&r-r<r2r4r7r;r?r(rEtextwrapdedentr7r rJr^r]rmrhrvrIrGr8r8 s $-I  %%M(((X((((X(     U      A " " "X "((((X  SS US$###X# !!!X! >(>(>(X>(@ '+> AAAA UAF  X U*:*:*:*:*:X SE%y111:>CCCC21CJ*:*:*:*:*:X SE%z::::>;:&%%%&GDDDD& & & &^ &""""++++++* ddd UdL    ] ] ] ]  U] ~ %%%% U%N777X7 3 3 3X 3 3 3 3X 3 !!!! U!F S X_      $  ,` N*-!     X  *-!     X  Sn %W555*0"     65 23:!!!!!!  >>>> U> = = =(((((rI)Srg __future__rrstypingrrrrrr r r r r numpyrpandas._configr pandas._libsrpandas._typingrrrrrrr pandas.compatrpandas.compat.numpyrr pandas.errorsrpandas.util._decoratorsrrpandas.core.dtypes.castrpandas.core.dtypes.commonrrr r!r"pandas.core.dtypes.genericr#r$r%pandas.core.dtypes.missingr&r' pandas.corer(r)r*pandas.core.accessorr+pandas.core.arrayliker,pandas.core.arraysr-pandas.core.constructionr.r/r0r1r2r3rr4r5r6r7rh_indexops_doc_kwargsr>rArlrxr8rvrIrGrs_#"""""                        ............------ 544444   /.....******------   " !!!! !  WT))),$,$,$,$,$=,$,$,$^--------DUUUUUWX&UUUp@(@(@(@(@(H@(@(@(@(@(rI