PidZddlmZddlmZmZmZmZmZm Z m Z m Z ddl Z ddlmZddlmZmZmZmZmZmZddlmZddlmZdd lmZdd lmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0Z0m1Z1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:m;Z;erddlZ>ddlm?Z?m@Z@mAZAmBZBddlCmDZDmEZEmFZFGdde4ZGGddZHGddeeZIGdde6ZJdS) z. Base and utility classes for pandas objects. ) annotations) TYPE_CHECKINGAnyGenericLiteralSelfcastfinaloverloadN)lib)AxisIntDtypeObj IndexLabelNDFrameTShapenpt)PYPY)functionAbstractMethodError)cache_readonly)can_hold_element)is_object_dtype is_scalar)ExtensionDtype) ABCDataFrameABCIndex ABCMultiIndex ABCSeries)isnaremove_na_arraylike) algorithmsnanopsops) DirNamesMixin)OpsMixin)ExtensionArray)ensure_wrapped_if_datetimelike extract_array)HashableIterator)DropKeep NumpySorterNumpyValueArrayLike ScalarLike_co) DataFrameIndexSeriescZeZdZUdZded<eddZddZddd Zdfd Z xZ S) PandasObjectz0 Base class for various pandas objects. zdict[str, Any]_cachereturn type[Self]c t|S)zK Class constructor (for this class it's just `__class__`). )typeselfs d/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/pandas/core/base.py _constructorzPandasObject._constructor\s Dzzstrc6t|S)zI Return a string representation for a particular object. )object__repr__r:s r<rBzPandasObject.__repr__cs t$$$r>Nkey str | NoneNonect|dsdS||jdS|j|ddS)zV Reset cached properties. If ``key`` is passed, only clears that key. r5N)hasattrr5clearpop)r;rCs r< _reset_cachezPandasObject._reset_cachejsVtX&&  F ; K        KOOC & & & & &r>intct|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)getattrrKrsumsuper __sizeof__)r;rMmem __class__s r<rSzPandasObject.__sizeof__usm t^T::  =,D)))Cinn;ss#''))<< <ww!!###r>)r6r7)r6r?N)rCrDr6rEr6rK) __name__ __module__ __qualname____doc____annotations__propertyr=rBrJrS __classcell__)rUs@r<r4r4Ts  X %%%% ' ' ' ' ' $ $ $ $ $ $ $ $ $ $r>r4c"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)`. r6rEc>t|dddS)z9 Prevents setting additional attributes. __frozenTN)rA __setattr__r:s r<_freezezNoNewAttributesMixin._freezes" 4T22222r>rCr?ct|ddr@|dks:|t|jvs$t||dtd|dt|||dS)NrbFr5z"You cannot add any new attribute '')rPr9__dict__AttributeErrorrArc)r;rCvalues r<rcz NoNewAttributesMixin.__setattr__s 4U + + N 8OOd4jj)))tS$''3 !Lc!L!L!LMM M4e,,,,,r>N)r6rE)rCr?r6rE)rXrYrZr[rdrcr>r<r`r`sF  3333 - - - - - -r>r`ceZdZUdZded<dZded<ded<d d gZeeZe e d Z e d Z e e ddZe e dZdZdddZe ddZdZeZdS)SelectionMixinz mixin implementing the selection & aggregation interface on a group-like object sub-classes need to define: obj, exclusions robjNzIndexLabel | None _selectionzfrozenset[Hashable] exclusionsr5 __setstate__ct|jtttt t jfs|jgS|jSrV) isinstancernlisttuplerrnpndarrayr:s r<_selection_listzSelectionMixin._selection_lists? OdE9h K   %O$ $r>cv|jt|jtr|jS|j|jSrV)rnrrrmrr:s r< _selected_objzSelectionMixin._selected_objs1 ? "j9&E&E "8O8DO, ,r>r6rKc|jjSrV)ryndimr:s r<r{zSelectionMixin.ndims!&&r>ct|jtr|jS|j|j|jSt |jdkr"|j|jddS|jS)NrT)axis only_slice)rrrmrrnrwlenro _drop_axisr:s r<_obj_with_exclusionsz#SelectionMixin._obj_with_exclusionsst dh * * 8O ? &8D01 1 t  ! # # 8&&tQ4&PP P8Or>c|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})r{zColumn not found: )rn IndexErrorrrrsrtrrrurvrrmcolumns intersectionset differenceKeyErrorr?_gotitemr{)r;rCbad_keysr{s r< __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 0r>r{c 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)r;rCr{subsets r<rzSelectionMixin._gotitems"$'''r>rSeries | DataFramecd}|jdkr/tj|r||vstj|r|}n,|jdkr!tj|r ||jkr|}|S)zO Infer the `selection` to pass to our constructor in _gotitem. Nrr})r{r r is_list_likename)r;rCr selections r<_infer_selectionzSelectionMixin._infer_selectionsz  ;!   ]3   $'6MMc6Fs6K6KMII [A  #-"4"4  9K9KIr>c t|rVr)r;funcargskwargss r< aggregatezSelectionMixin.aggregates!$'''r>rWrV)r{rK)rr)rXrYrZr[r\rn_internal_namesr_internal_names_setr r]rwrryr{rrrrraggrjr>r<rlrlsG MMM$(J((((####0O#o..  X U--^-  '''^ U' ^ U 111 ( ( ( ( (     U ((( CCCr>rlceZdZUdZdZedgZded<edZdZ ed[d Z e d\d Z ee d Z ed]dZd^dZed^dZe dZed^dZed^dZed_dZddejfd`d"Ze edad#Z dbdcd(Z dbdcd)Zddd+ZeZded-Zedad.Ze dfd/Z dgdhd5Z!d6Z"e didjd7Z#edad8Z$edad9Z%edad:Z&e dkdld<Z' dmdnd?Z(e) dodpdHZ*e) dodqdKZ* drdsdPZ*dQdRdtdUZ+e dudvdWZ,dXZ-dYZ.dS)w IndexOpsMixinzS Common ops mixin to support a unified interface / docs for Series / Index itolistzfrozenset[str] _hidden_attrsr6rc t|rVrr:s r<dtypezIndexOpsMixin.dtype"$'''r>ExtensionArray | np.ndarrayc t|rVrr:s r<_valueszIndexOpsMixin._valuesrr>rc0tj|||S)zw Return the transpose, which is by definition self. Returns ------- %(klass)s )nvvalidate_transpose)r;rrs r< transposezIndexOpsMixin.transpose!s dF+++ r>a: Return the transpose, which is by definition self. See Also -------- Index : Immutable sequence used for indexing and alignment. Examples -------- For Series: >>> s = pd.Series(['Ant', 'Bear', 'Cow']) >>> s 0 Ant 1 Bear 2 Cow dtype: str >>> s.T 0 Ant 1 Bear 2 Cow dtype: str For Index: >>> idx = pd.Index([1, 2, 3]) >>> idx.T Index([1, 2, 3], dtype='int64') )docrc|jjS)a Return a tuple of the shape of the underlying data. See Also -------- Series.ndim : Number of dimensions of the underlying data. Series.size : Return the number of elements in the underlying data. Series.nbytes : Return the number of bytes in the underlying data. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.shape (3,) )rshaper:s r<rzIndexOpsMixin.shapeNs"|!!r>rKc t|rVrr:s r<__len__zIndexOpsMixin.__len__as!$'''r>cdS)a Number of dimensions of the underlying data, by definition 1. See Also -------- Series.size: Return the number of elements in the underlying data. Series.shape: Return a tuple of the shape of the underlying data. Series.dtype: Return the dtype object of the underlying data. Series.values: Return Series as ndarray or ndarray-like depending on the dtype. Examples -------- >>> s = pd.Series(["Ant", "Bear", "Cow"]) >>> s 0 Ant 1 Bear 2 Cow dtype: str >>> s.ndim 1 For Index: >>> idx = pd.Index([1, 2, 3]) >>> idx Index([1, 2, 3], dtype='int64') >>> idx.ndim 1 r}rjr:s r<r{zIndexOpsMixin.ndimhs >qr>c~t|dkrtt|Std)a Return the first element of the underlying data as a Python scalar. Returns ------- scalar The first element of Series or Index. Raises ------ ValueError If the data is not length = 1. See Also -------- Index.values : Returns an array representing the data in the Index. Series.head : Returns the first `n` rows. Examples -------- >>> s = pd.Series([1]) >>> s.item() 1 For an index: >>> s = pd.Series([1], index=["a"]) >>> s.index.item() 'a' r}z6can only convert an array of size 1 to a Python scalar)rnextiter ValueErrorr:s r<itemzIndexOpsMixin.items7@ t99>>T ## #QRRRr>c|jjS)al Return the number of bytes in the underlying data. See Also -------- Series.ndim : Number of dimensions of the underlying data. Series.size : Return the number of elements in the underlying data. Examples -------- For Series: >>> s = pd.Series(["Ant", "Bear", "Cow"]) >>> s 0 Ant 1 Bear 2 Cow dtype: str >>> s.nbytes 34 For Index: >>> idx = pd.Index([1, 2, 3]) >>> idx Index([1, 2, 3], dtype='int64') >>> idx.nbytes 24 )rnbytesr:s r<rzIndexOpsMixin.nbytess>|""r>c*t|jS)a Return the number of elements in the underlying data. See Also -------- Series.ndim: Number of dimensions of the underlying data, by definition 1. Series.shape: Return a tuple of the shape of the underlying data. Series.dtype: Return the dtype object of the underlying data. Series.values: Return Series as ndarray or ndarray-like depending on the dtype. Examples -------- For Series: >>> s = pd.Series(["Ant", "Bear", "Cow"]) >>> s 0 Ant 1 Bear 2 Cow dtype: str >>> s.size 3 For Index: >>> idx = pd.Index([1, 2, 3]) >>> idx Index([1, 2, 3], dtype='int64') >>> idx.size 3 )rrr:s r<sizezIndexOpsMixin.sizesB4<   r>r'c t|)ae The ExtensionArray of the data backing this Series or Index. This property provides direct access to the underlying array data of a Series or Index without requiring conversion to a NumPy array. It returns an ExtensionArray, which is the native storage format for pandas extension dtypes. 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 from ``.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 NumpyExtensionArray 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, str): ['a', 'b'] rr:s r<arrayzIndexOpsMixin.arraysH"$'''r>NFrnpt.DTypeLike | Nonecopyboolna_valuerA np.ndarrayc Ft|jtr|jj|f||d|S|rAt t |}td|d|tj uo2|tj uo#tj |jtj }|j}|rf|jr_t#||stj||}n|}||tjt+|<tj||}|r|r|satj|jdd|ddr7|s!|}d|j_n|}|S)a1 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 The NumPy ndarray holding the values from this Series or Index. The dtype of the array may differ. See Notes. 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]') )rrz/to_numpy() got an unexpected keyword argument 'rf)rNrF)rrrrrto_numpyrrkeys TypeErrorr no_defaultrunan issubdtypefloatingrhasnansrasarrayr asanyarrayr shares_memoryviewflags writeable) r;rrrrrfillnavaluesresults r<rzIndexOpsMixin.to_numpy7s@ dj. 1 1 &4:&uU4(UUfUU U  D//00HM(MMM  CN * T'RBM$*bk,R,RS    9dl 9#FH55 'F%88808F2=d,, -F%000  + + + RaR 0&!*== ++#[[]]F-2FL**#[[]]F r>c|j S)a Indicator whether Index is empty. An Index is considered empty if it has no elements. This property can be useful for quickly checking the state of an Index, especially in data processing and analysis workflows where handling of empty datasets might be required. Returns ------- bool If Index is empty, return True, if not return False. See Also -------- Index.size : Return the number of elements in the underlying data. Examples -------- >>> idx = pd.Index([1, 2, 3]) >>> idx Index([1, 2, 3], dtype='int64') >>> idx.empty False >>> idx_empty = pd.Index([]) >>> idx_empty Index([], dtype='object') >>> idx_empty.empty True If we only have NaNs in our DataFrame, it is not considered empty! >>> idx = pd.Index([np.nan, np.nan]) >>> idx Index([nan, nan], dtype='float64') >>> idx.empty False )rr:s r<emptyzIndexOpsMixin.emptysT9}r>Tr~AxisInt | Noneskipnac|j}tj|tj|||}t |t r||Stj||}|S)aJ Return int position of the largest value in the Series. If the maximum 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. If the entire Series is NA, or if ``skipna=False`` and there is an NA value, this method will raise a ``ValueError``. *args, **kwargs Additional arguments and keywords for compatibility with NumPy. Returns ------- int Row position of the maximum value. See Also -------- Series.argmax : Return position of the maximum value. Series.argmin : Return position of the minimum value. numpy.ndarray.argmax : 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( ... [100.0, 110.0, 120.0, 110.0], ... index=[ ... "Corn Flakes", ... "Almond Delight", ... "Cinnamon Toast Crunch", ... "Cocoa Puff", ... ], ... ) >>> s Corn Flakes 100.0 Almond Delight 110.0 Cinnamon Toast Crunch 120.0 Cocoa Puff 110.0 dtype: float64 >>> s.argmax() np.int64(2) >>> s.argmin() np.int64(0) The maximum cereal calories is the third element and the minimum cereal calories is the first element, since series is zero-indexed. r) rrvalidate_minmax_axisvalidate_argmax_with_skipnarrr'argmaxr# nanargmaxr;r~rrrdelegaters r<rzIndexOpsMixin.argmaxsz< %%%/fEE h / / ??&?11 1%hv>>>FMr>c|j}tj|tj|||}t |t r||Stj||}|S)aK Return int position of the smallest value in the Series. If the minimum 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. If the entire Series is NA, or if ``skipna=False`` and there is an NA value, this method will raise a ``ValueError``. *args, **kwargs Additional arguments and keywords for compatibility with NumPy. Returns ------- int Row position of the minimum value. See Also -------- Series.argmin : Return position of the minimum value. Series.argmax : Return position of the maximum value. numpy.ndarray.argmin : Equivalent method for numpy arrays. Series.idxmin : Return index label of the minimum values. Series.idxmax : Return index label of the maximum values. Examples -------- Consider dataset containing cereal calories >>> s = pd.Series( ... [100.0, 110.0, 120.0, 110.0], ... index=[ ... "Corn Flakes", ... "Almond Delight", ... "Cinnamon Toast Crunch", ... "Cocoa Puff", ... ], ... ) >>> s Corn Flakes 100.0 Almond Delight 110.0 Cinnamon Toast Crunch 120.0 Cocoa Puff 110.0 dtype: float64 >>> s.argmax() np.int64(2) >>> s.argmin() np.int64(0) The maximum cereal calories is the third element and the minimum cereal calories is the first element, since series is zero-indexed. r) rrrrrrr'argminr# nanargminrs r<rzIndexOpsMixin.argmin3rr>rsc4|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 List containing the values as Python or pandas scalers. See Also -------- numpy.ndarray.tolist : Return the array as an a.ndim-levels deep nested list of Python scalars. Examples -------- For Series >>> s = pd.Series([1, 2, 3]) >>> s.to_list() [1, 2, 3] For Index: >>> idx = pd.Index([1, 2, 3]) >>> idx Index([1, 2, 3], dtype='int64') >>> idx.to_list() [1, 2, 3] )rrr:s r<rzIndexOpsMixin.tolist|sF|""$$$r>r+ct|jtjst |jSt |jjt|jjS)aD 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 An iterator yielding scalar values from the Series. See Also -------- Series.items : Lazily iterate over (index, value) tuples. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> for x in s: ... print(x) 1 2 3 ) rrrrurvrmaprrangerr:s r<__iter__zIndexOpsMixin.__iter__sM6$, 33 D %% %t|(% 0A*B*BCC Cr>c^tt|S)a Return True if there are any NaNs. Enables various performance speedups. Returns ------- bool See Also -------- Series.isna : Detect missing values. Series.notna : Detect existing (non-missing) values. Examples -------- >>> s = pd.Series([1, 2, 3, None]) >>> s 0 1.0 1 2.0 2 3.0 3 NaN dtype: float64 >>> s.hasnans True )rr anyr:s r<rzIndexOpsMixin.hasnanss"<DJJNN$$%%%r>c|j}t|tr|||St j|||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. ) na_action)rrrr'rr" map_array)r;mapperrarrs r< _map_valueszIndexOpsMixin._map_valuessK*l c> * * 8776Y777 7#C9EEEEr> normalizesort ascendingdropnar2c6tj||||||S)aA 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 Stable sort by frequencies when True. Preserve the order of the data when False. .. versionchanged:: 3.0.0 Prior to 3.0.0, the sort was unstable. 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 Series containing counts of unique values. 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 **Categorical Dtypes** Rows with categorical type will be counted as one group if they have same categories and order. In the example below, even though ``a``, ``c``, and ``d`` all have the same data types of ``category``, only ``c`` and ``d`` will be counted as one group since ``a`` doesn't have the same categories. >>> df = pd.DataFrame({"a": [1], "b": ["2"], "c": [3], "d": [3]}) >>> df = df.astype({"a": "category", "c": "category", "d": "category"}) >>> df a b c d 0 1 2 3 3 >>> df.dtypes a category b str c category d category dtype: object >>> df.dtypes.value_counts() category 2 category 1 str 1 Name: count, dtype: int64 )rrrbinsr)r"value_counts_internal)r;rrrrrs r< value_countszIndexOpsMixin.value_countss1p/      r>c|j}t|tjs|}nt j|}|SrV)rrrrurvuniquer"unique1d)r;rrs r<rzIndexOpsMixin.uniquesA&"*-- 1]]__FF(00F r>cj|}|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 An integer indicating the number of unique elements in the object. 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 )rr!r)r;runiqss r<nuniquezIndexOpsMixin.nuniques3H   /'..E5zzr>cP|dt|kS)a Return True if values in the object are unique. Returns ------- bool See Also -------- Series.unique : Return unique values of Series object. Series.drop_duplicates : Return Series with duplicate values removed. Series.duplicated : Indicate duplicate Series values. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.is_unique True >>> s = pd.Series([1, 2, 3, 1]) >>> s.is_unique False F)r)rrr:s r< is_uniquezIndexOpsMixin.is_uniques#2||5|))SYY66r>c.ddlm}||jS)a Return True if values in the object are monotonically increasing. Returns ------- bool See Also -------- Series.is_monotonic_decreasing : Return boolean if values in the object are monotonically decreasing. Examples -------- >>> s = pd.Series([1, 2, 2]) >>> s.is_monotonic_increasing True >>> s = pd.Series([3, 2, 1]) >>> s.is_monotonic_increasing False rr1)pandasr1is_monotonic_increasingr;r1s r<rz%IndexOpsMixin.is_monotonic_increasing'0 !     uT{{22r>c.ddlm}||jS)a Return True if values in the object are monotonically decreasing. Returns ------- bool See Also -------- Series.is_monotonic_increasing : Return boolean if values in the object are monotonically increasing. Examples -------- >>> s = pd.Series([3, 2, 2, 1]) >>> s.is_monotonic_decreasing True >>> s = pd.Series([1, 2, 3]) >>> s.is_monotonic_decreasing False rr)rr1is_monotonic_decreasingrs r<r z%IndexOpsMixin.is_monotonic_decreasingrr>rOc$t|jdr|j|S|jj}|rQt |jr=t s6ttj |j }|tj |z }|S)a 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 Returns memory usage of the values in the Index in bytes. 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 Examples -------- >>> idx = pd.Index([1, 2, 3]) >>> idx.memory_usage() 24 rMrN) rGrrMrrrrr rurvrr memory_usage_of_objects)r;rOvrs r< _memory_usagezIndexOpsMixin._memory_usages@ 4:~ . . :**+  J   5ODJ// 5 5"*dl33F ,V44 4Ar>use_na_sentinel"tuple[npt.NDArray[np.intp], Index]ctj|j||\}}|jtjkr|tj}t|tr4t|dkr |dd}nN| |}n8ddl m } |||jd}n#t$r||d}YnwxYw||fS)a Encode the object as an enumerated type or categorical variable. This method is useful for obtaining a numeric representation of an array when all that matters is identifying distinct values. `factorize` is available as both a top-level function :func:`pandas.factorize`, and as a method :meth:`Series.factorize` and :meth:`Index.factorize`. Parameters ---------- sort : bool, default False Sort `uniques` and shuffle `codes` to maintain the relationship. use_na_sentinel : bool, default True If True, the sentinel -1 will be used for NaN values. If False, NaN values will be encoded as non-negative integers and will not drop the NaN from the uniques of the values. Returns ------- codes : ndarray An integer ndarray that's an indexer into `uniques`. ``uniques.take(codes)`` will have the same values as `values`. uniques : ndarray, Index, or Categorical The unique valid values. When `values` is Categorical, `uniques` is a Categorical. When `values` is some other pandas object, an `Index` is returned. Otherwise, a 1-D ndarray is returned. .. note:: Even if there's a missing value in `values`, `uniques` will *not* contain an entry for it. See Also -------- cut : Discretize continuous-valued array. unique : Find the unique value in an array. Notes ----- Reference :ref:`the user guide ` for more examples. Examples -------- These examples all show factorize as a top-level method like ``pd.factorize(values)``. The results are identical for methods like :meth:`Series.factorize`. >>> codes, uniques = pd.factorize( ... np.array(["b", "b", "a", "c", "b"], dtype="O") ... ) >>> codes array([0, 0, 1, 2, 0]) >>> uniques array(['b', 'a', 'c'], dtype=object) With ``sort=True``, the `uniques` will be sorted, and `codes` will be shuffled so that the relationship is the maintained. >>> codes, uniques = pd.factorize( ... np.array(["b", "b", "a", "c", "b"], dtype="O"), sort=True ... ) >>> codes array([1, 1, 0, 2, 1]) >>> uniques array(['a', 'b', 'c'], dtype=object) When ``use_na_sentinel=True`` (the default), missing values are indicated in the `codes` with the sentinel value ``-1`` and missing values are not included in `uniques`. >>> codes, uniques = pd.factorize( ... np.array(["b", None, "a", "c", "b"], dtype="O") ... ) >>> codes array([ 0, -1, 1, 2, 0]) >>> uniques array(['b', 'a', 'c'], dtype=object) Thus far, we've only factorized lists (which are internally coerced to NumPy arrays). When factorizing pandas objects, the type of `uniques` will differ. For Categoricals, a `Categorical` is returned. >>> cat = pd.Categorical(["a", "a", "c"], categories=["a", "b", "c"]) >>> codes, uniques = pd.factorize(cat) >>> codes array([0, 0, 1]) >>> uniques ['a', 'c'] Categories (3, str): ['a', 'b', 'c'] Notice that ``'b'`` is in ``uniques.categories``, despite not being present in ``cat.values``. For all other pandas objects, an Index of the appropriate type is returned. >>> cat = pd.Series(["a", "a", "c"]) >>> codes, uniques = pd.factorize(cat) >>> codes array([0, 0, 1]) >>> uniques Index(['a', 'c'], dtype='str') If NaN is in the values, and we want to include NaN in the uniques of the values, it can be achieved by setting ``use_na_sentinel=False``. >>> values = np.array([1, 2, 1, np.nan]) >>> codes, uniques = pd.factorize(values) # default: use_na_sentinel=True >>> codes array([ 0, 1, 0, -1]) >>> uniques array([1., 2.]) >>> codes, uniques = pd.factorize(values, use_na_sentinel=False) >>> codes array([0, 1, 0, 2]) >>> uniques array([ 1., 2., nan]) )rrrNrF)rr)r)r" factorizerrrufloat16astypefloat32rrrrr=rr1NotImplementedError)r;rrcodesuniquesr1s r<rzIndexOpsMixin.factorize1sz$- Lt_   w =BJ & &nnRZ00G dM * * 54yyA~~rr(++G44 $ $ $ $ $ $ 5%tzFFF& 5 5 5 %e444 5g~s$B88CC.rir/sideLiteral['left', 'right']sorterr-np.intpcdSrVrjr;rirrs r< searchsortedzIndexOpsMixin.searchsorteds #r>npt.ArrayLike | ExtensionArraynpt.NDArray[np.intp]cdSrVrjrs r<rzIndexOpsMixin.searchsorteds #sr>left$NumpyValueArrayLike | ExtensionArrayNumpySorter | Nonenpt.NDArray[np.intp] | np.intpct|tr'dt|jd}t ||j}t|t js||||Stj||||S)a Find indices where elements should be inserted to maintain order. Find the indices into a sorted Index `self` such that, if the corresponding elements in `value` were inserted before the indices, the order of `self` would be preserved. .. note:: The Index *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) np.int64(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[us] >>> ser.searchsorted("3/14/2000") np.int64(3) >>> ser = pd.Categorical( ... ["apple", "bread", "bread", "cheese", "milk"], ordered=True ... ) >>> ser ['apple', 'bread', 'bread', 'cheese', 'milk'] Categories (4, str): ['apple' < 'bread' < 'cheese' < 'milk'] >>> ser.searchsorted("bread") np.int64(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 z(Value must be 1-D array-like or scalar, z is not supported)rr) rrrr9rXrrrurvrr")r;rirrmsgrs r<rzIndexOpsMixin.searchsortedsN e\ * * ";;;';;; S// !&"*-- H&&u4&GG G&       r>firstkeepr*r,c@||}||SNr)) _duplicated)r;r* duplicateds r<drop_duplicateszIndexOpsMixin.drop_duplicatesUs%%%4%00 ZK  r>npt.NDArray[np.bool_]c|j}t|tr||St j||Sr,)rrrr'r.r")r;r*rs r<r-zIndexOpsMixin._duplicatedZsEl c> * * ->>t>,, ,$St4444r>ctj||}|j}t|dd}tj||j}t |}t|tr%tj |j |j |j }tjd5tj|||}dddn #1swxYwY||||S)NT) extract_numpy extract_rangeignore)all)rother)r$get_op_result_namerr)maybe_prepare_scalar_for_oprr(rrrruarangestartstopsteperrstate arithmetic_op_construct_result)r;r7opres_namelvaluesrvaluesrs r< _arith_methodzIndexOpsMixin._arith_methodas)$66,TNNN1'7=II099 gu % % Ki w|W\JJG [X & & & = =&w<)r6r)r6r)r6r)r6rrW)r6r')rrrrrrAr6r)r6r)NT)r~rrrr6rK)r6rs)r6r+rV)FTFNT) rrrrrrrrr6r2)T)rrr6rK)F)rOrr6rK)FT)rrrrr6r)..)rir/rrrr-r6r)rirrrrr-r6r )r"N)rir#rrrr$r6r%)r*r,r6r)r()r*r,r6r0)/rXrYrZr[__array_priority__ frozensetrr\r]rrr rTrrr{rrrrr rrrrrrto_listrrrrrrrrrr r rr rr/r-rEr@rjr>r<rr s $-I  %%M(((X((((X(     U      AB"""X"$((((X@ !S!S U!SF###X#@ ! ! !X !DC(C(C(XC(N'+> EEEEEN  (((X U(V;?GGGGGT;?GGGGGR#%#%#%#%JGDDDDB&&&^&> FFF UF:        B &&&& U&P777X74333X36333X36 (((( U(X $SSSSSt*-! X*-! ####X#*0%) x x x x x t3:!!!!!!  5555 U5 J J J(((((r>r)Kr[ __future__rtypingrrrrrr r r numpyru pandas._libsr pandas._typingr rrrrr pandas.compatrpandas.compat.numpyrr pandas.errorsrpandas.util._decoratorsrpandas.core.dtypes.castrpandas.core.dtypes.commonrrpandas.core.dtypes.dtypesrpandas.core.dtypes.genericrrrrpandas.core.dtypes.missingr r! pandas.corer"r#r$pandas.core.accessorr%pandas.core.arrayliker&pandas.core.arraysr'pandas.core.constructionr(r)collections.abcr*r+r,r-r.r/rr0r1r2r4r`rlrrjr>r<r_s#"""""                    ......------222222444444544444   /.....******------  ,$,$,$,$,$=,$,$,$^--------DdddddWX&dddNi(i(i(i(i(Hi(i(i(i(i(r>