U
|
¬ý°dª¦ ã @ sô U d Z ddlmZ ddlZddlmZmZmZmZm Z m
|
Z
|
m Z m Z m Z mZ ddlZddlmZ ddlmZ ddlmZmZmZmZmZmZm Z ddl m Z dd l m 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/m0Z0m1Z1m2Z2 ddl3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9 ddl:m;Z; ddl<m=Z= ddl>m?Z? ddl@mAZAmBZB erddlmCZCmDZDmEZEmFZF ddlGmHZHmIZImJZJ i ZKdeLd< dddddZMe d dd ZNG d d d e;ZOG d d! d!ZPG d"d# d#ee ZQG d$d de=ZRdS )%z.
|
Base and utility classes for pandas objects.
|
é )Ú annotationsN)
|
Ú TYPE_CHECKINGÚAnyÚGenericÚHashableÚIteratorÚLiteralÚTypeVarÚcastÚfinalÚoverload)Úusing_copy_on_write)Úlib)ÚAxisÚAxisIntÚDtypeObjÚ
|
IndexLabelÚNDFrameTÚShapeÚnpt)ÚPYPY)Úfunction©ÚAbstractMethodError)Úcache_readonlyÚdoc)Úcan_hold_element)Úis_categorical_dtypeÚ is_dict_likeÚis_extension_array_dtypeÚis_object_dtypeÚ is_scalar)Ú ABCDataFrameÚABCIndexÚ ABCSeries)ÚisnaÚremove_na_arraylike)Ú
|
algorithmsÚnanopsÚops)Ú DirNamesMixin)ÚOpsMixin)ÚExtensionArray)Ú ensure_wrapped_if_datetimelikeÚ extract_array)ÚDropKeepÚ NumpySorterÚNumpyValueArrayLikeÚ ScalarLike_co)Ú CategoricalÚIndexÚSerieszdict[str, str]Ú _shared_docsÚ IndexOpsMixinÚ )ÚklassZinplaceÚuniqueÚ
|
duplicatedÚ_T)Úboundc s\ e Zd ZU dZded< edd Zdddd Zdd d d ddZdd fdd Z Z
|
S )Ú PandasObjectz/
|
Baseclass for various pandas objects.
|
zdict[str, Any]Ú_cachec C s t | S )zJ
|
Class constructor (for this class it's just `__class__`.
|
)Útype©Úself© rC úGd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/base.pyÚ _constructorl s zPandasObject._constructorÚstr©Úreturnc C s
|
t | ¡S )zI
|
Return a string representation for a particular object.
|
)ÚobjectÚ__repr__rA rC rC rD rJ s s zPandasObject.__repr__Nz
|
str | NoneÚNone©ÚkeyrH c C s4 t | dsdS |dkr"| j ¡ n| j |d¡ dS )zV
|
Reset cached properties. If ``key`` is passed, only clears that key.
|
r? N)Úhasattrr? ÚclearÚpop)rB rM rC rC rD Ú _reset_cachez s
|
|
zPandasObject._reset_cacheÚintc s< t | dd}|r2|dd}tt|r(|n| ¡ S t ¡ S )zx
|
Generates the total memory usage for an object that returns
|
either a value or Series of values
|
Ú memory_usageNT©Údeep)ÚgetattrrR r! ÚsumÚsuperÚ
|
__sizeof__)rB rS Zmem©Ú __class__rC rD rY
s
|
|
zPandasObject.__sizeof__)N) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__ÚpropertyrE rJ rQ rY Ú __classcell__rC rC rZ rD r> d s
|
|
r> c @ s. e Zd ZdZddddZddddd Zd
|
S ) Ú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)`.
|
rK rG c C s t | dd¡ dS )z9
|
Prevents setting additional attributes.
|
Ú__frozenTN)rI Ú __setattr__rA rC rC rD Ú_freeze s z NoNewAttributesMixin._freezerF rL c C sT t | ddrB|dksB|t| jksBt | |d d k sBtd| dt | ||¡ d S )Nrd Fr? z"You cannot add any new attribute 'ú')rV r@ Ú__dict__ÚAttributeErrorrI re )rB rM ÚvaluerC rC rD re ¦ s ÿ þýz NoNewAttributesMixin.__setattr__N)r\ r] r^ r_ rf re rC rC rC rD rc s rc c @ s¤ e Zd ZU dZded< dZded< ded< d d
|
gZeeZe e
|
d d Z e d d Z e e ddddZe e dd Zdd Zd ddddZdd ZeZdS ) ÚSelectionMixinz
|
mixin implementing the selection & aggregation interface on a group-like
|
object sub-classes need to define: obj, exclusions
|
r ÚobjNzIndexLabel | NoneÚ
|
_selectionzfrozenset[Hashable]Ú
|
exclusionsr? Ú __setstate__c C s& t | jtttttjfs | jgS | jS ©N)Ú
|
isinstancerm ÚlistÚtupler$ r# ÚnpÚndarrayrA rC rC rD Ú_selection_listÁ s ÿz SelectionMixin._selection_listc C s, | j d kst| jtr | jS | j| j S d S rp )rm rq rl r$ rA rC rC rD Ú _selected_objÊ s z SelectionMixin._selected_objrR rG c C s | j jS rp )rw ÚndimrA rC rC rD rx Ñ s zSelectionMixin.ndimc C sV t | jtr| jS | jd k r*| j | j¡S t| jdkrL| jj| jdddS | jS d S )Nr é T)ÚaxisZ
|
only_slice) rq rl r$ rm Z_getitem_nocopyrv Úlenrn Z
|
_drop_axisrA rC rC rD Ú_obj_with_exclusionsÖ s
|
z#SelectionMixin._obj_with_exclusionsc C sÈ | j d k r td| j dt|tttttjfrt | j
|
j |¡t t |krtt | | j
|
j ¡}tdt|dd
| jt|ddS || j
|
krªtd| | j
|
| j}| j||dS d S ) Nz
|
Column(s) z already selectedzColumns not found: ry éÿÿÿÿé ©rx zColumn not found: )rm Ú
|
IndexErrorrq rr rs r$ r# rt ru r{ rl ÚcolumnsÚ intersectionÚsetÚ
|
differenceÚKeyErrorrF Ú_gotitemrx )rB rM Úbad_keysrx rC rC rD Ú __getitem__è s
|
|
zSelectionMixin.__getitem__r c C s t | dS )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
|
Nr )rB rM rx ZsubsetrC rC rD r ø s zSelectionMixin._gotitemc O s t | d S rp r )rB ÚfuncÚargsÚkwargsrC rC rD Ú aggregate s zSelectionMixin.aggregate)N)r\ r] r^ r_ r` rm Z_internal_namesr Z_internal_names_setr ra rv r rw rx r| r r r ZaggrC rC rC rD rk µ s*
|
|
rk c @ s8 e Zd ZU dZdZedgZded< edddd Z ed
|
dd d Z
|
e d d dddZ ee ddZ eddddZddddZeddddZe d d Zeddd d Zeddd d!Zed"dd#d$Ze d%d&ejfd'd(d)d*d+d,d-Ze ed(dd.d/Zdd1d(d2d3d4Zed5d6d7d8dd1d(dd9d:d;Zdd1d(d2d<d=Z eed6d5d>d8dd1d(dd9d?d@Z dAdB Z e Z dCddDdEZ e!d(ddFdGZ"dHddIdJZ#dKd0d%d%dLdMdNd(dOdPdQZ$e ddRdSZ%e dd(d(d(d(dTdUdVdWZ&dXdY Z'e dd(ddZd[d\Z(ed(dd]d^Z)ed(dd_d`Z*ed(ddadbZ+e dd(ddcdddeZ,ee-j.dfdfdfe/ 0dg¡dhdd(d(didjdkdlZ.dme1dn< e2ddpdqdrdsdtdudvZ3e2ddwdqdrdxdtdydvZ3ee1dn dzd{dd}dqdrd~dtddvZ3ddddddZ4e dddHd
ddZ5dd Z6dd Z7d%S )r7 zS
|
Common ops mixin to support a unified interface / docs for Series / Index
|
iè Útolistzfrozenset[str]Ú _hidden_attrsr rG c C s t | d S rp r rA rC rC rD Údtype s zIndexOpsMixin.dtypezExtensionArray | np.ndarrayc C s t | d S rp r rA rC rC rD Ú_values s zIndexOpsMixin._valuesr< )rB rH c O s t ||¡ | S )zw
|
Return the transpose, which is by definition self.
|
|
Returns
|
-------
|
%(klass)s
|
)ÚnvZvalidate_transpose)rB r r rC rC rD Ú transpose" s zIndexOpsMixin.transposezD
|
Return the transpose, which is by definition self.
|
)r r c C s | j jS )z®
|
Return a tuple of the shape of the underlying data.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.shape
|
(3,)
|
)r ÚshaperA rC rC rD r 5 s zIndexOpsMixin.shaperR c C s t | d S rp r rA rC rC rD Ú__len__B s zIndexOpsMixin.__len__z
|
Literal[1]c C s dS )zO
|
Number of dimensions of the underlying data, by definition 1.
|
ry rC rA rC rC rD rx F s zIndexOpsMixin.ndimc C s$ t | dkrtt| S tddS )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.
|
ry z6can only convert an array of size 1 to a Python scalarN)r{ ÚnextÚiterÚ
|
ValueErrorrA rC rC rD ÚitemM s zIndexOpsMixin.itemc C s | j jS )zD
|
Return the number of bytes in the underlying data.
|
)r ÚnbytesrA rC rC rD r ` s zIndexOpsMixin.nbytesc C s
|
t | jS )zG
|
Return the number of elements in the underlying data.
|
)r{ r rA rC rC rD Úsizeg s zIndexOpsMixin.sizer, c C s t | dS )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
|
<PandasArray>
|
[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']
|
Nr rA rC rC rD Úarrayn s ?zIndexOpsMixin.arrayNFznpt.DTypeLike | NoneÚboolrI z
|
np.ndarray)r ÚcopyÚna_valuerH c K s t | jr$| jj|f||d|S |rHt| ¡ d }td| d|tjk r| j }t
|
||srt j ||d}n| ¡ }||t | ¡ ¡< n| j }t j ||d}|r°|tjksº|süt rüt | j dd
|dd
¡rüt 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]')
|
)r r r z/to_numpy() got an unexpected keyword argument 'rg ©r Nr~ F)r r r Úto_numpyrr ÚkeysÚ TypeErrorr Ú
|
no_defaultr r rt Zasarrayr Z
|
asanyarrayr% r Z shares_memoryÚviewÚflagsZ writeable)rB r r r r r ÚvaluesÚresultrC rC rD r ¯ s4 _
|
|
ÿ
|
|
ÿÿ
|
|
zIndexOpsMixin.to_numpyc C s | j S rp )r rA rC rC rD Úempty3 s zIndexOpsMixin.emptyTzAxisInt | None)rz Úskipnac O s& t |¡ t ||¡ tj| j|dS )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© )r Úvalidate_minmax_axisZ validate_maxr( Znanmaxr ©rB rz r© r r rC rC rD Úmax8 s (
|
zIndexOpsMixin.maxr ÚminÚlargest)ÚopZopposerj )rz r© rH c O sX | j }t |¡ t |||¡}t|trF|s<| ¡ ¡ r<dS | ¡ S nt j
|
||dS dS )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.
|
r} rª N) r r r« Zvalidate_argmax_with_skipnarq r, r% ÚanyÚargmaxr( Z nanargmax©rB rz r© r r ZdelegaterC rC rD r² d s 6
|
|
|
ÿzIndexOpsMixin.argmaxc O s& t |¡ t ||¡ tj| j|dS )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ª )r r« Z validate_minr( Znanminr r¬ rC rC rD r® ª s (
|
zIndexOpsMixin.minÚsmallestc O sX | j }t |¡ t |||¡}t|trF|s<| ¡ ¡ r<dS | ¡ S nt j
|
||dS d S )Nr} rª ) r r r« Zvalidate_argmin_with_skipnarq r, r% r± Úargminr( Z nanargminr³ rC rC rD rµ Ö s
|
|
|
ÿzIndexOpsMixin.argminc C s
|
| j ¡ S )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.
|
)r r rA rC rC rD r ê s zIndexOpsMixin.tolistr c C s2 t | jtjst| jS t| jjt| jjS dS )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
|
N) rq r rt ru r Úmapr Úranger rA rC rC rD Ú__iter__ÿ s
|
zIndexOpsMixin.__iter__c C s t t| ¡ S )z
|
Return True if there are any NaNs.
|
|
Enables various performance speedups.
|
|
Returns
|
-------
|
bool
|
)r r% r± rA rC rC rD Úhasnans s zIndexOpsMixin.hasnansznpt.NDArray[np.bool_]c C s
|
t | jS rp )r% r rA rC rC rD r% ! s zIndexOpsMixin.isnar )rz r© Ú numeric_onlyÚ filter_typerF r )Únamerz r© c K s> t | |d}|dkr,tt| j d| |f d|i|S )zA
|
Perform the reduction type operation if we can.
|
Nz cannot perform the operation r© )rV r¢ r@ r\ ) rB r° r¼ rz r© rº r» Úkwdsr rC rC rD Ú_reduce$ s ÿzIndexOpsMixin._reducec
|
sj t |r^t|tr.t|dr.| fdd}n0ddlm} t|dkrV||tjd}n||}t|t rÞ|dkrd| d }t
|
||d
|
kr||j ¡ }t | jrºtd | j}| |¡S | j}|j |¡}t |j|¡}|S t| jrt| jd r| j}|d k r tdd } nF| j t¡}|d
|
kr6dd } n&|d krHtj} 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 s" t | tr t | ¡r tjn| S rp )rq Úfloatrt ÚisnanÚnan)Úx©Zdict_with_defaultrC rD Ú<lambda>V s ÿz+IndexOpsMixin._map_values.<locals>.<lambda>r )r5 r )NÚignorez+na_action must either be 'ignore' or None, z was passedrÆ r3 r¶ Nc S s
|
| |¡S rp )r¶ ©r¦ ÚfrC rC rD rÅ ó c S s t | |t| tj¡¡S rp )r Zmap_infer_maskr% r¤ rt Zuint8rÇ rC rC rD rÅ s ÿ)r rq ÚdictrN Úpandasr5 r{ rt Úfloat64r$ r ÚindexZnotnar r r
|
r r¶ Z get_indexerr' Ztake_ndr ÚNotImplementedErrorÚastyperI r Z map_infer)
|
rB ZmapperZ na_actionr5 ÚmsgÚcatr¦ ZindexerZ
|
new_valuesZmap_frC rÄ rD Ú _map_values9 sJ
|
|
ÿ
|
|
|
|
|
|
|
|
ÿ
|
zIndexOpsMixin._map_valuesr5 )Ú normalizeÚsortÚ ascendingÚdropnarH c C s t j| |||||dS )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)rB rÓ rÔ rÕ r× rÖ rC rC rD rØ s WúzIndexOpsMixin.value_countsc C s* | j }t|tjs | ¡ }n
|
t |¡}|S rp )r rq rt ru r: r' Zunique1d)rB r¦ r§ rC rC rD r: s
|
|
|
zIndexOpsMixin.unique)rÖ rH c C s | ¡ }|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{ )rB rÖ ZuniqsrC rC rD Únunique s #zIndexOpsMixin.nuniquec C s | j ddt| kS )zr
|
Return boolean if values in the object are unique.
|
|
Returns
|
-------
|
bool
|
F)rÖ )rÙ r{ rA rC rC rD Ú is_unique1 s zIndexOpsMixin.is_uniquec C s ddl m} || jS )z
|
Return boolean if values in the object are monotonically increasing.
|
|
Returns
|
-------
|
bool
|
r ©r4 )rË r4 Úis_monotonic_increasing©rB r4 rC rC rD rÜ < s z%IndexOpsMixin.is_monotonic_increasingc C s ddl m} || jS )z
|
Return boolean if values in the object are monotonically decreasing.
|
|
Returns
|
-------
|
bool
|
r rÛ )rË r4 Úis_monotonic_decreasingrÝ rC rC rD rÞ I s z%IndexOpsMixin.is_monotonic_decreasing)rU rH c C sR t | jdr| jj|dS | jj}|rNt| rNtsNttj| j }|t
|
|¡7 }|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
|
rS rT ) rN r rS r r r r
|
rt ru r r Zmemory_usage_of_objects)rB rU Úvr¦ rC rC rD Ú _memory_usageV s ÿzIndexOpsMixin._memory_usager8 z sort : bool, default False
|
Sort `uniques` and shuffle `codes` to maintain the
|
relationship.
|
)r¦ ÚorderZ size_hintrÔ z"tuple[npt.NDArray[np.intp], Index])rÔ Úuse_na_sentinelrH c C s` t j| j||d\}}|jtjkr.| tj¡}t| t rD|
|
|¡}nddl m } ||}||fS )N)rÔ râ r rÛ ) r' Ú factorizer r rt Úfloat16rÏ Úfloat32rq r# rE rË r4 )rB rÔ râ ÚcodesZuniquesr4 rC rC rD rã z s ÿ
|
|
zIndexOpsMixin.factorizea
|
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.r2 zLiteral[('left', 'right')]r0 znp.intp)rj ÚsideÚsorterrH c C s d S rp rC ©rB rj rè ré rC rC rD rç s zIndexOpsMixin.searchsortedz npt.ArrayLike | ExtensionArrayznpt.NDArray[np.intp]c C s d S rp rC rê rC rC rD rç s r4 )r9 Úleftz$NumpyValueArrayLike | ExtensionArrayz npt.NDArray[np.intp] | np.intpc C sX t |tr$dt|j d}t|| j}t |tjsF|j|||dS t j||||dS )Nz(Value must be 1-D array-like or scalar, z is not supported)rè ré )
|
rq r" r@ r\ r r rt ru rç r' )rB rj rè ré rÐ r¦ rC rC rD rç s
|
ÿ üÚfirst©Úkeepr/ c C s | j |d}| | S ©Nrí )Ú _duplicated)rB rî r; rC rC rD Údrop_duplicates2 s z IndexOpsMixin.drop_duplicates)rî rH c C s t j| j|dS rï )r' r; r )rB rî rC rC rD rð 7 s zIndexOpsMixin._duplicatedc C sj t | |¡}| j}t|ddd}t ||j¡}t|}tjdd t |||¡}W 5 Q R X | j
|
||dS )NT)Z extract_numpyZ extract_rangerÆ )Úall)r¼ ) r) Zget_op_result_namer r. Zmaybe_prepare_scalar_for_opr r- rt ZerrstateZ arithmetic_opÚ_construct_result)rB Úotherr° Zres_nameZlvaluesZrvaluesr§ rC rC rD Ú _arith_method; s zIndexOpsMixin._arith_methodc C s t | dS )z~
|
Construct an appropriately-wrapped result from the ArrayLike result
|
of an arithmetic-like operation.
|
Nr )rB r§ r¼ rC rC rD ró H s z IndexOpsMixin._construct_result)NT)NT)NT)NT)N)FTFNT)T)F)FT)..)..)rë N)rì )8r\ r] r^ r_ Z__array_priority__Ú frozensetr r` ra r r r r ÚTr r rx r r r r r r£ r r¨ r r r² r® rµ r Zto_listr¸ r r¹ r% r¾ rÒ rØ r: rÙ rÚ rÜ rÞ rà r' rã ÚtextwrapÚdedentr6 r rç rñ rð rõ ró rC rC rC rD r7 sÞ
|
ÿ þ
|
@ü , ÿE, ÿø f ú_ '
|
#ÿû ýþÿg ü ü ü )Sr_ Ú
|
__future__r rø Útypingr r r r r r r r
|
r r Únumpyrt Zpandas._configr Z pandas._libsr Zpandas._typingr r r r r r r Z pandas.compatr Zpandas.compat.numpyr r Z pandas.errorsr Zpandas.util._decoratorsr r Zpandas.core.dtypes.castr Zpandas.core.dtypes.commonr r r r r! Zpandas.core.dtypes.genericr" r# r$ Zpandas.core.dtypes.missingr% r& Z pandas.corer' r( r) Zpandas.core.accessorr* Zpandas.core.arrayliker+ Zpandas.core.arraysr, Zpandas.core.constructionr- r. r/ r0 r1 r2 rË r3 r4 r5 r6 r` Z_indexops_doc_kwargsr< r> rc rk r7 rC rC rC rD Ú<module> sD 0 $ ü /"X
|
