`Vg UdZddlmZddlZddlmZmZmZmZm Z m Z m Z m Z m Z ddlZddlZddlmcmZddlmZmZmZmZmZmZddlmZddlmZddl m!Z!dd l"m#Z#m$Z$dd l%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.m/Z/m0Z0dd l1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7ddl8m9Z9ddl:m;Z;mm?Z?ddl@mAZAddlBmCZCmDZDmEZEerddlmFZFmGZGmHZHddlImJZJmKZKiZLdeMd<dddddZNe ddZOGdde9ZPGdd ZQGd!d"eeZRGd#de?ZSy)$z. Base and utility classes for pandas objects. ) annotationsN) TYPE_CHECKINGAnyGenericHashableLiteralTypeVarcastfinaloverload) ArrayLikeDtypeObj IndexLabelNDFrameTShapenpt)PYPY)functionAbstractMethodError)cache_readonlydoc)find_stack_level)is_categorical_dtype is_dict_likeis_extension_array_dtypeis_object_dtype is_scalar) ABCDataFrameABCIndex ABCSeries)isnaremove_na_arraylike) algorithmsnanopsops) DirNamesMixin) duplicatedunique1d value_counts)OpsMixin)ExtensionArray)!create_series_with_explicit_dtypeensure_wrapped_if_datetimelike extract_array) NumpySorterNumpyValueArrayLike ScalarLike_co) CategoricalSerieszdict[str, str] _shared_docs IndexOpsMixin)klassinplaceuniquer(_T)boundcReZdZUdZded<edZddZd d dZd fd Z xZ S) PandasObjectz/ Baseclass for various pandas objects. zdict[str, Any]_cachect|S)zJ Class constructor (for this class it's just `__class__`. )typeselfs Q/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/pandas/core/base.py _constructorzPandasObject._constructorns Dzc,tj|S)zI Return a string representation for a particular object. )object__repr__rBs rDrIzPandasObject.__repr__us t$$rFct|dsy||jjy|jj|dy)zV Reset cached properties. If ``key`` is passed, only clears that key. r?N)hasattrr?clearpop)rCkeys rD _reset_cachezPandasObject._reset_cache|s8tX&  ; KK    KKOOC &rFct|dd}|r3|d}tt|r|S|jSt|S)zx Generates the total memory usage for an object that returns either a value or Series of values memory_usageNTdeep)getattrintrsumsuper __sizeof__)rCrQmem __class__s rDrXzPandasObject.__sizeof__sO t^T: D)Cins< <#'')< <w!##rF)returnstrN)rNz str | Noner[Noner[rU) __name__ __module__ __qualname____doc____annotations__propertyrErIrOrX __classcell__)rZs@rDr>r>fs6   % ' $ $rFr>ceZdZdZdZddZy)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)`. c2tj|ddy)z9 Prevents setting additional attributes. __frozenTN)rH __setattr__rBs rD_freezezNoNewAttributesMixin._freezes 4T2rFct|ddr8|dk(s3|t|jvst||dtd|dtj |||y)NrjFr?z"You cannot add any new attribute '')rTrA__dict__AttributeErrorrHrk)rCrNvalues rDrkz NoNewAttributesMixin.__setattr__s_ 4U + 8Od4j)))tS$'3 #EcU!!LM M4e,rFN)rNr\r[r^)r`rarbrcrlrkrFrDrhrhs 3 -rFrhceZdZUdZded<dZded<ded<d d gZeeZe e d Z e d Z e e dd Ze e dZdZdddZdZeZy)SelectionMixinz mixin implementing the selection & aggregation interface on a group-like object sub-classes need to define: obj, exclusions robjNzIndexLabel | None _selectionzfrozenset[Hashable] exclusionsr? __setstate__ct|jtttt t jfs |jgS|jSr]) isinstancervlisttupler!r npndarrayrBs rD_selection_listzSelectionMixin._selection_lists= OOdE9h K OO$ $rFc|jt|jtr |jS|j|jSr])rvrzrur!rBs rD _selected_objzSelectionMixin._selected_objs5 ?? "j9&E88O88DOO, ,rFc.|jjSr])rndimrBs rDrzSelectionMixin.ndims!!&&&rFc|j3t|jtr|j|jSt |j dkDr(|jj|j ddS|jS)NrT)axis only_slice)rvrzrurrlenrw _drop_axisrBs rD_obj_with_exclusionsz#SelectionMixin._obj_with_exclusionssl ?? &:dhh +M88D001 1 t ! # 88&&tQ4&P P88OrFc,|jtd|jdt|ttt t tjfrt|jjj|tt|k7rQtt|j|jj}tdt!|dd|j#t|dSt%|dd s9||jjvrtd ||j#|dS||jvrtd ||j|}|j&}|j#||| S) Nz Column(s) z already selectedzColumns not found: r)ras_indexFzColumn not found: )rsubset)rv IndexErrorrzr{r|r!r r}r~rrucolumns intersectionset differenceKeyErrorr\_gotitemrTr)rCrNbad_keysrrs rD __getitem__zSelectionMixin.__getitem__sR ?? &z$//)::KLM M cD%HbjjI J488##0056#c#h-GC 3 3DHH4D4D EF!4S]1R5H4IJKK==c=3 3z51$((***!3C59::==1=- -$(("!3C59::XXc]F;;D==4=? ?rFct|)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)rCrNrrs rDrzSelectionMixin._gotitems"$''rFct|r]r)rCfuncargskwargss rD aggregatezSelectionMixin.aggregate s !$''rFr_r])rrU)r`rarbrcrdrv_internal_namesr_internal_names_setr rerrrrrrrraggrrrFrDrtrts M$(J!(##0Oo.   --  ' '    @, (( CrFrtc eZdZUdZdZedgZded<ed?dZ ed@dZ dAdZ ee d Z edBd Z dCd ZedDd ZdZedCdZedCdZedEdZddej*f dFdZedGdZdHdIdZeddddHdJdZdHdIdZeeddddHdCdZd ZeZd!Ze dGd"Z!dKd#Z"d$dddd% dLd&Z#e$dMd'Z% dN dOd(Z&d)Z'dPdQd*Z(edGd+Z)edGd,Z*edGd-Z+edGd.Z,dRdSd/Z-ee.j^d0d0d0e0jbd12dej*ej*f dTd3Z/d4e2d5<e3 dU dVd6Z4e3 dU dWd7Z4ee2d5d89 dX dYd:Z4dZd;Z5e$ dZ d[d<Z6d=Z7d>Z8y)\r6zS Common ops mixin to support a unified interface / docs for Series / Index itolistzfrozenset[str] _hidden_attrsct|r]rrBs rDdtypezIndexOpsMixin.dtype"$''rFct|r]rrBs rD_valueszIndexOpsMixin._values"rrFc2tj|||S)zw Return the transpose, which is by definition self. Returns ------- %(klass)s )nvvalidate_transpose)rCrrs rD transposezIndexOpsMixin.transpose's dF+ rFzD Return the transpose, which is by definition self. )rc.|jjS)zE Return a tuple of the shape of the underlying data. )rshaperBs rDrzIndexOpsMixin.shape9s ||!!!rFct|r]rrBs rD__len__zIndexOpsMixin.__len__@s !$''rFcy)zO Number of dimensions of the underlying data, by definition 1. rrrrBs rDrzIndexOpsMixin.ndimDs rFc\t|dk(rtt|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 ValueErrorrBs rDitemzIndexOpsMixin.itemKs* t9>T # #QRRrFc.|jjS)zD Return the number of bytes in the underlying data. )rnbytesrBs rDrzIndexOpsMixin.nbytes]s ||"""rFc,t|jS)zG Return the number of elements in the underlying data. )rrrBs rDsizezIndexOpsMixin.sizeds 4<<  rFct|)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'] rrBs rDarrayzIndexOpsMixin.arrayks~"$''rFNFc t|jr |jj|f||d|S|r+t |j d}t d|dtj|j|}|s|tjurH|j}|tjur&||tj|j<|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. .. versionadded:: 1.0.0 **kwargs Additional keywords passed through to the ``to_numpy`` method of the underlying array (for extension arrays). .. versionadded:: 1.0.0 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]') )copyna_valuerz/to_numpy() got an unexpected keyword argument 'rn)r)rrrto_numpyr{keys TypeErrorr}asarrayrlib no_defaultr asanyarrayr")rCrrrrrresults rDrzIndexOpsMixin.to_numpysF $DJJ /&4::&&uU4(UfU U FKKM*1-HA(1M DLL6 83>>1[[]Fs~~-5=r}}TYY[12 rFc|j Sr])rrBs rDemptyzIndexOpsMixin.emptys99}rFTctj|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) skipna)rvalidate_minmax_axis validate_maxr%nanmaxrrCrrrrs rDmaxzIndexOpsMixin.max#6P % f%}}T\\&99rFrminlargest)opopposerqc"|j}tj|tj|||}t |t r1|s|j jry|jStj||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_skipnarzr,r"anyargmaxr% nanargmaxrCrrrrdelegates rDrzIndexOpsMixin.argmaxOsxh<< %//fE h /hmmo113((## rFctj|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 rDrzIndexOpsMixin.minrrFsmallestc"|j}tj|tj|||}t |t r1|s|j jry|jStj||S)Nrr) rrrvalidate_argmin_with_skipnarzr,r"rargminr% nanargminrs rDrzIndexOpsMixin.argminsu<< %//fE h /hmmo113((## rFc6|jjS)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. )rrrBs rDrzIndexOpsMixin.tolists"||""$$rFct|jtjst |jSt |jj t|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 ) rzrr}r~rmaprrangerrBs rD__iter__zIndexOpsMixin.__iter__sK$,, 3 % %t||((% 0A0A*BC CrFcFtt|jS)zc Return True if there are any NaNs. Enables various performance speedups. )boolr"rrBs rDhasnanszIndexOpsMixin.hasnanssDJNN$%%rFc,t|jSr])r"rrBs rDr"zIndexOpsMixin.isnasDLL!!rFr)rr numeric_only filter_typec zt||d}|#tt|jd||dd|i|S)zA Perform the reduction type operation if we can. Nz cannot perform the operation rrr)rTrrAr`) rCrnamerrrrkwdsrs rD_reducezIndexOpsMixin._reducesStT4( <:&&''EdVL *6*T**rFcd t|r?t|trt|dr| fd}nt |t j }t|tr|dvrd|d}t||dk(r||jj}t|jr'td|j}|j|S|j}|jj!|}t#j$|j|}|St'|jr.t|jd r|j}|t(d }nL|jj+t,}|dk(rd }n$|t.j0}nd|d}t||||}|S) a An internal function that maps values using the input correspondence (which can be a dict, Series, or function). Parameters ---------- mapper : function, dict, or Series The input correspondence object na_action : {None, 'ignore'} If 'ignore', propagate NA values, without passing them to the mapping function Returns ------- Union[Index, MultiIndex], inferred The output of the mapping function applied to the index. If the function returns a tuple with more than one element a MultiIndex will be returned. __missing__c|Sr]rr)xdict_with_defaults rDz+IndexOpsMixin._map_values..9s #4Q#7rF)dtype_if_empty)Nignorez+na_action must either be 'ignore' or None, z was passedrr3rc$|j|Sr])rvaluesfs rDrz+IndexOpsMixin._map_values..isfjjmrFc|tj||t|jtj Sr])rmap_infer_maskr"viewr}uint8rs rDrz+IndexOpsMixin._map_values..ms+#*<*<AtF|00:+rF)rrzdictrKr-r}float64r!rindexnotnarrr rr get_indexerr$take_ndrNotImplementedErrorastyperHr map_infer) rCmapper na_actionmsgcatrindexer new_valuesmap_frs @rD _map_valueszIndexOpsMixin._map_valuess0  &$'GFM,J%+!7;2:: fi ( 00A k.!o%H$ 2 2 45$DJJ/=$,,7wwv&\\Fll..v6G#++FNNGDJ  $DJJ /GDLL%4P\\F$))3E\\((0FH$" B k.!o%66* rFc$t||||||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 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 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 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 dtype: int64 )sort ascending normalizebinsdropna)r*)rCrrrrrs rDr*zIndexOpsMixin.value_counts~s$l    rFcN|j}t|tjss|j }t|j tj r=|j j dvr%t|trtj|}|St|}|S)N)mM) rrzr}r~r:rkindr!rr))rCrrs rDr:zIndexOpsMixin.uniquesw&"**- & F4::rxx0TZZ__ 5RT9-F+ f%F rFcR|j}|r t|}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)rCruniqss rDnuniquezIndexOpsMixin.nuniques'D  '.E5zrFc>|jdt|k(S)zr Return boolean if values in the object are unique. Returns ------- bool F)r)r#rrBs rD is_uniquezIndexOpsMixin.is_uniques||5|)SY66rFcbtjdtt|jS)a$ Return boolean if values in the object are monotonically increasing. .. deprecated:: 1.5.0 is_monotonic is deprecated and will be removed in a future version. Use is_monotonic_increasing instead. Returns ------- bool zhis_monotonic is deprecated and will be removed in a future version. Use is_monotonic_increasing instead.) stacklevel)warningswarn FutureWarningris_monotonic_increasingrBs rD is_monotoniczIndexOpsMixin.is_monotonics,   3 ')  +++rFc2ddlm}||jS)z Return boolean if values in the object are monotonically increasing. Returns ------- bool rIndex)pandasr/r+rCr/s rDr+z%IndexOpsMixin.is_monotonic_increasing4 !T{222rFc2ddlm}||jS)z Return boolean if values in the object are monotonically decreasing. Returns ------- bool rr.)r0r/is_monotonic_decreasingr1s rDr4z%IndexOpsMixin.is_monotonic_decreasingAr2rFc4t|jdr|jj|S|jj}|rMt |rBt szIndexOpsMixin.factorizeqs &## to  rFa 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 searchsortedcyr]rrrCrqsidesorters rDr?zIndexOpsMixin.searchsorteds rFcyr]rrrAs rDr?zIndexOpsMixin.searchsorteds rFr/)r8c|j}t|tjs|j |||St j||||S)N)rBrC)rrzr}r~r?r$)rCrqrBrCrs rDr?zIndexOpsMixin.searchsortedsR&"**-&&u4&G G&&     rFc2|j|}||SN)keep) _duplicated)rCrHr(s rDdrop_duplicateszIndexOpsMixin.drop_duplicatess"%%4%0 ZK  rFc0t|j|SrG)r(r)rCrHs rDrIzIndexOpsMixin._duplicateds$,,T22rFcbtj||}|j}t|dd}tj||j }t |}tjd5tj|||}ddd|j|S#1swYxYw)NT) extract_numpy extract_ranger)all)r) r&get_op_result_namerr/maybe_prepare_scalar_for_oprr.r}errstate arithmetic_op_construct_result)rCotherrres_namelvaluesrvaluesrs rD _arith_methodzIndexOpsMixin._arith_method$s))$6,,TN11'7==I09 [[X & =&&wtextwrapdedentr5r r?rJrIrYrTrrrFrDr6r6s  $-  %M>((((    A"" ( S$## !! >(>(D'+>> q#qq q  qf*:X E%y1A2AF*:X E%z:;"%&GD&&&"++* _ _F   ] ] ]  ]  ]  ] ~ %N77,,( 3 3 3 3!F  X__  +.>>03   ) .    ` N*-!   '       *-!  - '       n %W5*0"  3 '   (  6 &!  6=333 3 3 =(rF)Trc __future__rrctypingrrrrrr r r r r(numpyr}pandas._libs.lib_libsrpandas._typingr rrrrr pandas.compatrpandas.compat.numpyrr pandas.errorsrpandas.util._decoratorsrrpandas.util._exceptionsrpandas.core.dtypes.commonrrrrrpandas.core.dtypes.genericrr r!pandas.core.dtypes.missingr"r# pandas.corer$r%r&pandas.core.accessorr'pandas.core.algorithmsr(r)r*pandas.core.arrayliker+pandas.core.arraysr,pandas.core.constructionr-r.r/r0r1r2r0r3r4r5rd_indexops_doc_kwargsr;r>rhrtr6rrrFrDrzs#   .-5   / +-   " n! !  T),$=,$^--DXWX&Xvd(Hd(rF