Ë
|
nñúh¨¡ ã ó U d Z ddlmZ ddlZddlmZmZmZmZm Z m
|
Z
|
m Z ddl Z ddl ZddlmZ ddlmZ ddlmZmZmZmZmZmZmZ ddlm Z dd l m Z dd
|
l m!Z! dd l"m#Z#m$Z$ dd l%m&Z& dd l'm(Z( ddl)m*Z*m+Z+ ddl,m-Z- ddl.m/Z/m0Z0m1Z1m2Z2 ddl3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9 ddl:m;Z; ddl<m=Z= ddl>m?Z? ddl@mAZAmBZB er ddlCmDZDmEZE ddlmFZFmGZGmHZHmIZI ddlJmKZKmLZLmMZM i ZNdeOd< d d d d d ZP G d d e;« ZQ G d! d"« ZR G d# d$ee « ZS G d% d e=« ZTy)&z.
|
Base and utility classes for pandas objects.
|
é )Ú annotationsN)Ú TYPE_CHECKINGÚAnyÚGenericÚLiteralÚcastÚfinalÚoverload)Úusing_copy_on_write)Úlib)ÚAxisIntÚDtypeObjÚ
|
IndexLabelÚNDFrameTÚSelfÚShapeÚnpt)ÚPYPY)Úfunction©ÚAbstractMethodError)Úcache_readonlyÚdoc)Úfind_stack_level)Úcan_hold_element)Úis_object_dtypeÚ is_scalar)ÚExtensionDtype)Ú ABCDataFrameÚABCIndexÚ ABCMultiIndexÚ ABCSeries)ÚisnaÚremove_na_arraylike)Ú
|
algorithmsÚnanopsÚops)Ú DirNamesMixin)ÚOpsMixin)ÚExtensionArray)Ú ensure_wrapped_if_datetimelikeÚ extract_array)ÚHashableÚIterator)ÚDropKeepÚ NumpySorterÚNumpyValueArrayLikeÚ ScalarLike_co)Ú DataFrameÚIndexÚSerieszdict[str, str]Ú _shared_docsÚ IndexOpsMixinÚ )ÚklassÚinplaceÚuniqueÚ
|
duplicatedc óR e Zd ZU dZded< ed « ZddZd d
|
dZd fd Z xZ
|
S ) Ú PandasObjectz/
|
Baseclass for various pandas objects.
|
zdict[str, Any]Ú_cachec ó t | « S )zK
|
Class constructor (for this class it's just `__class__`).
|
)Útype©Úselfs úCH:\Change_password\venv_build\Lib\site-packages\pandas/core/base.pyÚ _constructorzPandasObject._constructorm s ô
|
DzÐó c ó, t j | « S )zI
|
Return a string representation for a particular object.
|
)ÚobjectÚ__repr__rB s rD rI zPandasObject.__repr__t s ô
|
tÓ$Ð$rF c ó t | d« sy|| j j « y| j j |d« y)zV
|
Reset cached properties. If ``key`` is passed, only clears that key.
|
r? N)Úhasattrr? ÚclearÚpop)rC Úkeys rD Ú _reset_cachezPandasObject._reset_cache{ s8 ô tXÔ&Ø Ø ;Ø KK× Ñ Õ à KKOOC Õ &rF c ó¤ t | dd« }|r3 |d¬« }t t |« r|« S |j « « S t | « S )zx
|
Generates the total memory usage for an object that returns
|
either a value or Series of values
|
Ú memory_usageNT©Údeep)ÚgetattrÚintr ÚsumÚsuperÚ
|
__sizeof__)rC rQ ÚmemÚ __class__s rD rX zPandasObject.__sizeof__ sO ø ô
|
t ^°TÓ: Ù Ù DÔ)CÜi¨nsÓ<Ð <°#·'±'³)Ó<Ð <ô wÑ!Ó#Ð#rF )ÚreturnÚstr©N)rN z
|
str | Noner[ ÚNone©r[ rU ) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__ÚpropertyrE rI rO rX Ú __classcell__)rZ s @rD r> r> e s6 ø
ñð
|
Óà ñó ðó %ô '÷ $ñ $rF r> c ó e Zd ZdZddZddZy)Ú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)`.
|
c ó2 t j | dd« y)z9
|
Prevents setting additional attributes.
|
Ú__frozenTN)rH Ú __setattr__rB s rD Ú_freezez NoNewAttributesMixin._freeze s ô ×Ñ4 ¨TÕ2rF c ó¼ t | dd« r8|dk( s3|t | « j v s t | |d « t d| d« t j | ||« y )Nrj Fr? z"You cannot add any new attribute 'ú')rT rA Ú__dict__ÚAttributeErrorrH rk )rC rN Úvalues rD rk z NoNewAttributesMixin.__setattr__§ s_ ô 4 UÔ +Ø 8OØd4j×)Ñ)Ñ)ÜtS $Ó'Ð3ä Ð#EÀcÀUÈ!Ð!LÓMÐ MÜ×Ñ4 eÕ,rF N)r[ r^ )rN r\ r[ r^ )r` ra rb rc rl rk © rF rD rh rh s ñ ó3ô -rF rh c óØ e Zd ZU dZded< dZded< ded< d d
|
gZ ee« Ze e
|
d « « Z e d « Z e e dd « « Ze e d « « Zd ZdddZe dd« Zd ZeZy)Ú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 ó¦ t | j t t t t
|
t j f« s | j gS | j S r] )Ú
|
isinstancerv ÚlistÚtupler" r ÚnpÚndarrayrB s rD Ú_selection_listz SelectionMixin._selection_list s= ô Ø OOd¤E¬9´hÄÇ
|
Á
|
Ð Kô
|
ð OOÐ$Ð $ØÐ rF c ó | j t | j t « r | j S | j | j S r] )rv rz ru r" rB s rD Ú _selected_objz SelectionMixin._selected_objË s5 à ??Ð "¤j°·±¼9Ô&EØ88Oà88DOOÑ,Ð ,rF c ó. | j j S r] )r ÚndimrB s rD r zSelectionMixin.ndimÒ s ð ×!Ñ!×&Ñ&Ð&rF c óH t | j t « r | j S | j %| j j | j
|
« S t | j « dkD r(| j j | j dd¬« S | j S )Nr é T)ÚaxisÚ
|
only_slice) rz ru r" rv Ú_getitem_nocopyr Úlenrw Ú
|
_drop_axisrB s rD Ú_obj_with_exclusionsz#SelectionMixin._obj_with_exclusions× s| ô dhh¤ Ô *Ø88Oà ??Ð &Ø88×+Ñ+¨D×,@Ñ,@ÓAÐ Aä tÓ !Ò #ð
|
88×&Ñ& t§¡¸QÈ4Ð&ÓPÐ Pà88OrF c ó | j t d| j d« t |t t t
|
t t j f« r°t | j j j |« « t t |« « k7 rQt t |« j | j j « « }t dt! |« dd « | j# t |« d¬« S || j vrt d| « | j | j$ }| j# ||¬« S ) Nz
|
Column(s) z already selectedzColumns not found: r
éÿÿÿÿé )r zColumn not found: )rv Ú
|
IndexErrorrz r{ r| r" r r} r~ r ru ÚcolumnsÚ intersectionÚsetÚ
|
differenceÚKeyErrorr\ Ú_gotitemr )rC rN Úbad_keysr s rD Ú __getitem__zSelectionMixin.__getitem__é s Ø ??Ð &Ü z¨$¯/©/Ð):Ð:KÐ LÓMÐ Mä cD¤%¬´H¼b¿j¹jÐIÔ JÜ488×#Ñ#×0Ñ0°Ó5Ó6¼#¼cÀ#»h»-ÒGÜ ¤ C£× 3Ñ 3°D·H±H×4DÑ4DÓ EÓFÜ Ð!4´S¸³]À1ÀRÐ5HÐ4IÐ JÓKÐKØ==¤ c£°=Ó3Ð 3ð $((Ñ"Ü Ð!3°C°5Ð 9Ó:Ð:Ø88C=×%Ñ%DØ== ¨4=Ó0Ð 0rF 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 )rC rN r Úsubsets rD r zSelectionMixin._gotitemù s ô " $Ó'Ð'rF c óö d}|j dk( r2t j |« r||v st j |« r|}|S |j dk( r&t j |« r||j k( r|}|S )zO
|
Infer the `selection` to pass to our constructor in _gotitem.
|
Nr r
)r r r Ú is_list_likeÚname)rC rN r Ú selections rD Ú_infer_selectionz SelectionMixin._infer_selection sp ð Ø ;;!Ò Ü ]]3Ô C¨6¡M´c×6FÑ6FÀsÔ6KàIð Ðð [[AÒ ¤#§-¡-°Ô"4¸ÀÇ Á Ò9KØIØÐrF c ó t | « r] r )rC ÚfuncÚargsÚkwargss rD Ú aggregatezSelectionMixin.aggregate s Ü! $Ó'Ð'rF r_ r] )r rU )r zSeries | DataFrame)r` ra rb rc rd rv Ú_internal_namesr Ú_internal_names_setr re r r r r r r r r r£ Úaggrr rF rD rt rt ¶ sÄ
ñð
|
|
MØ$(JÐ!Ó(Ø#Ó#Ø Ð0OÙ oÓ.Ðà
|
Ø ñ ó ó ð ð ñ-ó ð-ð Øò'ó ó ð'ð Øñ ó ó ð ò 1ô (ð ò ó ð ò (ð CrF rt c ó¤ e Zd ZU dZdZ edg« Zded< ed9d« Z ed:d« Z
|
e d;d« Z ee d ¬
|
« Z ed<d « Zd=d Zed=d « Ze d « Zed=d« Zed=d« Zed>d« Ze ddej, f d?d« Ze ed@d« « Z eddd¬« dA dBd« Z eeddd¬« dA dBd « Zd Z e Z dCd Z e d@d « Z e dAdDd « Z!e dE dFd!« Z"d" Z#e dGdHd#« Z$ed@d$« Z%ed@d%« Z&ed@d&« Z'e dIdJd'« Z( ee)jT d(d(d( e+jX d)« ¬*« dK dLd+« Z*d,e-d-< e. dM dNd.« Z/e. dM dOd/« Z/ ee-d- d0¬1« dP dQd2« Z/d3d4dRd5Z0e dSdTd6« Z1d7 Z2d8 Z3y)Ur7 zS
|
Common ops mixin to support a unified interface / docs for Series / Index
|
iè Útolistzfrozenset[str]Ú _hidden_attrsc ó t | « r] r rB s rD ÚdtypezIndexOpsMixin.dtype( ó ô " $Ó'Ð'rF c ó t | « r] r rB s rD Ú_valueszIndexOpsMixin._values- r¬ rF c ó2 t j ||« | S )zw
|
Return the transpose, which is by definition self.
|
|
Returns
|
-------
|
%(klass)s
|
)ÚnvÚvalidate_transpose)rC r¡ r¢ s rD Ú transposezIndexOpsMixin.transpose2 s ô × Ñ d FÔ+Ø rF aÙ
|
Return the transpose, which is by definition self.
|
|
Examples
|
--------
|
For Series:
|
|
>>> s = pd.Series(['Ant', 'Bear', 'Cow'])
|
>>> s
|
0 Ant
|
1 Bear
|
2 Cow
|
dtype: object
|
>>> s.T
|
0 Ant
|
1 Bear
|
2 Cow
|
dtype: object
|
|
For Index:
|
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx.T
|
Index([1, 2, 3], dtype='int64')
|
)r c ó. | j j S )z®
|
Return a tuple of the shape of the underlying data.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.shape
|
(3,)
|
)r® ÚshaperB s rD r´ zIndexOpsMixin.shape[ s ð ||×!Ñ!Ð!rF c ó t | « r] r rB s rD Ú__len__zIndexOpsMixin.__len__h s ä! $Ó'Ð'rF c ó y)a
|
Number of dimensions of the underlying data, by definition 1.
|
|
Examples
|
--------
|
>>> s = pd.Series(['Ant', 'Bear', 'Cow'])
|
>>> s
|
0 Ant
|
1 Bear
|
2 Cow
|
dtype: object
|
>>> s.ndim
|
1
|
|
For Index:
|
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx
|
Index([1, 2, 3], dtype='int64')
|
>>> idx.ndim
|
1
|
r
rr rB s rD r zIndexOpsMixin.ndimo s ð0 rF c ó\ t | « dk( rt t | « « S t d« )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.
|
|
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)r ÚnextÚiterÚ
|
ValueErrorrB s rD ÚitemzIndexOpsMixin.item s* ô6 t9>ÜT
|
Ó#Ð #ÜÐQÓRÐRrF c ó. | j j S )a½
|
Return the number of bytes in the underlying data.
|
|
Examples
|
--------
|
For Series:
|
|
>>> s = pd.Series(['Ant', 'Bear', 'Cow'])
|
>>> s
|
0 Ant
|
1 Bear
|
2 Cow
|
dtype: object
|
>>> s.nbytes
|
24
|
|
For Index:
|
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx
|
Index([1, 2, 3], dtype='int64')
|
>>> idx.nbytes
|
24
|
)r® ÚnbytesrB s rD r¾ zIndexOpsMixin.nbytes¨ s ð4 ||×"Ñ"Ð"rF c ó, t | j « S )aº
|
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: object
|
>>> s.size
|
3
|
|
For Index:
|
|
>>> idx = pd.Index([1, 2, 3])
|
>>> idx
|
Index([1, 2, 3], dtype='int64')
|
>>> idx.size
|
3
|
)r r® rB s rD ÚsizezIndexOpsMixin.sizeÄ s ô4 4<<Ó Ð rF c ó t | « )ac
|
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 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
|
<NumpyExtensionArray>
|
[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']
|
r rB s rD ÚarrayzIndexOpsMixin.arrayà s ô~ " $Ó'Ð'rF NFc ól t | j t « r | j j |f||d|¤S |r1t t |j « « « }t d| d« |t j uxrC |t j u xr. t j | j t j « }| j }|rUt! ||« st j" ||¬« }n|j% « }||t j& t) | « « < t j" ||¬« }|r|r |sot+ « ret j, | j dd |dd « r?t+ « r%|s#|j/ « }d|j0 _ |S |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.
|
**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]')
|
)ÚcopyÚna_valuez/to_numpy() got an unexpected keyword argument 'rn ©r« Nr F)rz r« r r Úto_numpyr¹ rº ÚkeysÚ TypeErrorr Ú
|
no_defaultr} ÚnanÚ
|
issubdtypeÚfloatingr® r ÚasarrayrÄ Ú
|
asanyarrayr# r Ú shares_memoryÚviewÚflagsÚ writeable) rC r« rÄ rÅ r¢ r ÚfillnaÚvaluesÚresults rD rÇ zIndexOpsMixin.to_numpy! si ô~ djj¤.Ô 1Ø&4::×&Ñ& uÐU°4À(ÑUÈfÑUÐ UÙ ÜD §¡£ Ó /Ó0HÜØAÀ(ÀÈ1ÐMóð ð
|
CNNÐ *ò Tà ¤§¡Ð'ÒR¬B¯M©M¸$¿*¹*ÄbÇkÁkÓ,RÐSð ð Ù Ü# F¨HÔ5ô F°%Ô8à à08F2==¤ d£Ó,Ñ -äF¨%Ô0á ©Ô2EÔ2GÜ× Ñ § ¡ ¨R¨aÐ 0°&¸¸!°*Ô=ä&Ô(±Ø #[[]FØ-2FLLÔ*ð ð $[[]Fà rF c ó | j S r] )rÀ rB s rD ÚemptyzIndexOpsMixin.empty§ s ð 99}Ð rF ÚmaxÚminÚlargest)ÚopÚopposerq c ó | j }t j |« t j |||« }t |t
|
« rl|sZ|j « j « r<t j dt | « j dt t « ¬« y|j « S t j ||¬« }|dk( r;t j dt | « j dt t « ¬« |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.
|
úThe behavior of úx.argmax/argmin with skipna=False and NAs, or with all-NAs is deprecated. In a future version this will raise ValueError.©Ú
|
stacklevelr ©Úskipna)r® r° Úvalidate_minmax_axisÚvalidate_argmax_with_skipnarz r* r# ÚanyÚwarningsÚwarnrA r` Ú FutureWarningr Úargmaxr& Ú nanargmax©rC r rä r¡ r¢ ÚdelegaterÖ s rD rë zIndexOpsMixin.argmax¬ sê ðl <<Ü
|
× Ñ Ô%Ü×/Ñ/°¸¸fÓEä h¤Ô /Ùhmmo× 1Ñ 1Ô 3Ü Ø&¤t¨D£z×':Ñ':Ð&;ð <Fð Fô "Ü /Ó 1õ ð à Ó(Ð(ä×%Ñ% h°vÔ>FØ|Ü Ø&¤t¨D£z×':Ñ':Ð&;ð <Fð Fô "Ü /Ó 1õ ð MrF Úsmallestc ó | j }t j |« t j |||« }t |t
|
« rl|sZ|j « j « r<t j dt | « j dt t « ¬« y|j « S t j ||¬« }|dk( r;t j dt | « j dt t « ¬« |S )Nrß rà rá r rã )r® r° rå Úvalidate_argmin_with_skipnarz r* r# rç rè ré rA r` rê r Úargminr& Ú nanargminrí s rD rò zIndexOpsMixin.argmin sé ð <<Ü
|
× Ñ Ô%Ü×/Ñ/°¸¸fÓEä h¤Ô /Ùhmmo× 1Ñ 1Ô 3Ü Ø&¤t¨D£z×':Ñ':Ð&;ð <Fð Fô "Ü /Ó 1õ ð à Ó(Ð(ä×%Ñ% h°vÔ>FØ|Ü Ø&¤t¨D£z×':Ñ':Ð&;ð <Fð Fô "Ü /Ó 1õ ð MrF c ó6 | j 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.
|
|
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]
|
)r® r¨ rB s rD r¨ zIndexOpsMixin.tolist" s ðD ||×"Ñ"Ó$Ð$rF c óî t | j t j « st | j « S t | j j t | j j « « S )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
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3])
|
>>> for x in s:
|
... print(x)
|
1
|
2
|
3
|
) rz r® r} r~ rº Úmapr¼ ÚrangerÀ rB s rD Ú__iter__zIndexOpsMixin.__iter__H sK ô, $,,¬¯
|
©
|
Ô3ä Ó%Ð %ät||×(Ñ(¬%°· ± ×0AÑ0AÓ*BÓCÐ CrF c óF t t | « j « « S )ak
|
Return True if there are any NaNs.
|
|
Enables various performance speedups.
|
|
Returns
|
-------
|
bool
|
|
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
|
)Úboolr# rç rB s rD ÚhasnanszIndexOpsMixin.hasnansd s ô2 DJNNÓ$Ó%Ð%rF c ó | j }t |t « r|j ||¬« S t 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
|
convert : bool, default True
|
Try to find better dtype for elementwise function results. If
|
False, leave as dtype=object. Note that the dtype is always
|
preserved for some extension array dtypes, such as Categorical.
|
|
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)rý Úconvert)r® rz r* rö r% Ú map_array)rC Úmapperrý rþ Úarrs rD Ú _map_valueszIndexOpsMixin._map_values sA ð2 llä c>Ô *Ø776¨Y7Ó7Ð 7ä×#Ñ# C¨¸9ÈgÔVÐVrF c ó8 t j | |||||¬« 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 when True. Preserve the order of the data when False.
|
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
|
)ÚsortÚ ascendingÚ normalizeÚbinsÚdropna)r% Úvalue_counts_internal)rC r r r r r s rD Ú value_countszIndexOpsMixin.value_counts s* ôn ×/Ñ/Ø ØØ Ø ØØô
|
ð
|
rF c ó | j }t |t j « s|j « }|S t j |« }|S r] )r® rz r} r~ r; r% Úunique1d)rC rÕ rÖ s rD r; zIndexOpsMixin.uniqueÿ sB Ø Ü&¤"§*¡*Ô-à]]_Fð ô ×(Ñ(¨Ó0FØ rF c óR | 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 )rC r Úuniqss rD ÚnuniquezIndexOpsMixin.nunique s' ðF Ù Ü'¨Ó.EÜ5zÐrF c ó> | j d¬« t | « k( S )a.
|
Return boolean if values in the object are unique.
|
|
Returns
|
-------
|
bool
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.is_unique
|
True
|
|
>>> s = pd.Series([1, 2, 3, 1])
|
>>> s.is_unique
|
False
|
F)r )r r rB s rD Ú is_uniquezIndexOpsMixin.is_unique0 s ð& || 5|Ó)¬S°«YÑ6Ð6rF c ó2 ddl m} || « j S )aY
|
Return boolean if values in the object are monotonically increasing.
|
|
Returns
|
-------
|
bool
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 2])
|
>>> s.is_monotonic_increasing
|
True
|
|
>>> s = pd.Series([3, 2, 1])
|
>>> s.is_monotonic_increasing
|
False
|
r ©r4 )Úpandasr4 Úis_monotonic_increasing©rC r4 s rD r z%IndexOpsMixin.is_monotonic_increasingE ó õ& !áT{×2Ñ2Ð2rF c ó2 ddl m} || « j S )a\
|
Return boolean if values in the object are monotonically decreasing.
|
|
Returns
|
-------
|
bool
|
|
Examples
|
--------
|
>>> s = pd.Series([3, 2, 2, 1])
|
>>> s.is_monotonic_decreasing
|
True
|
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.is_monotonic_decreasing
|
False
|
r r )r r4 Úis_monotonic_decreasingr s rD r z%IndexOpsMixin.is_monotonic_decreasing\ r rF c óH t | j d« r | j j |¬« S | j j }|rWt | j
|
« rBt s<t t j | j « }|t j |« 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
|
|
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
|
rQ rR ) rK r rQ r¾ r r« r r r} r~ r® r Úmemory_usage_of_objects)rC rS ÚvrÕ s rD Ú _memory_usagezIndexOpsMixin._memory_usages s ô> 4::~Ô .Ø::×*Ñ*Øð +ó ð ð JJ× Ñ Ù O D§J¡JÔ/½Ü"** d§l¡lÓ3FØ ×,Ñ,¨VÓ4Ñ 4AØrF r8 z sort : bool, default False
|
Sort `uniques` and shuffle `codes` to maintain the
|
relationship.
|
)rÕ ÚorderÚ size_hintr c ó t j | j ||¬« \ }}|j t j
|
k( r |j t j « }t | t « r| j |« }||fS ddl m } ||| j ¬« }||fS # t $ r ||« }Y ||fS w xY w)N)r Úuse_na_sentinelr r rÆ )r% Ú factorizer® r« r} Úfloat16ÚastypeÚfloat32rz r! rE r r4 ÚNotImplementedError)rC r r! ÚcodesÚuniquesr4 s rD r" zIndexOpsMixin.factorize s¹ ô$ $×-Ñ-Ø LLt°_ô
|
wð ==BJJÒ &Ø nn¤R§Z¡ZÓ0Gä dMÔ *à×'Ñ'¨Ó0Gð g~Ð õ %ð )Ù ¨t¯z©zÔ:ð
|
g~Ð øô 'ò )ñ .Øg~Ð ð )ús ÂB& Â&B=Â<B=a
|
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
|
Ú searchsortedc ó y r] rr ©rC rq ÚsideÚsorters rD r) zIndexOpsMixin.searchsorted, ó ð rF c ó y r] rr r+ s rD r) zIndexOpsMixin.searchsorted5 r. rF r4 )r9 c ó t |t « r$dt |« j d}t |« | j
|
}t |t j « s|j |||¬« S t j ||||¬« S )Nz(Value must be 1-D array-like or scalar, z is not supported)r, r- )
|
rz r rA r` r» r® r} r~ r) r% )rC rq r, r- ÚmsgrÕ s rD r) zIndexOpsMixin.searchsorted> s ô e\Ô *à:Ü;×'Ñ'Ð(Ð(9ð;ð ô S/Ð !à Ü&¤"§*¡*Ô-à×&Ñ& u°4ÀÐ&ÓGÐ Gä×&Ñ&Ø Ø ØØô
|
ð
|
rF Úfirst©Úkeepc ó2 | j |¬« }| | S ©Nr3 )Ú _duplicated)rC r4 r< s rD Údrop_duplicatesz IndexOpsMixin.drop_duplicatesX s" Ø×%Ñ%¨4Ð%Ó0
|
àZKÑ Ð rF c ó | j }t |t « r|j |¬« S t j ||¬« S r6 )r® rz r* r< r% )rC r4 r s rD r7 zIndexOpsMixin._duplicated] s9 àllÜ c>Ô *Ø>> t>Ó,Ð ,Ü×$Ñ$ S¨tÔ4Ð4rF c óì t j | |« }| j }t |dd¬« }t j ||j
|
« }t |« }t |t « r5t j |j |j |j « }t j d¬« 5 t j |||« }d d d « | j! |¬« S # 1 sw Y xY w)NT)Ú extract_numpyÚ extract_rangeÚignore)Úall)r )r' Úget_op_result_namer® r, Úmaybe_prepare_scalar_for_opr´ r+ rz r÷ r} ÚarangeÚstartÚstopÚstepÚerrstateÚ arithmetic_opÚ_construct_result)rC ÚotherrÜ Úres_nameÚlvaluesÚrvaluesrÖ s rD Ú _arith_methodzIndexOpsMixin._arith_methodd sÀ Ü×)Ñ)¨$°Ó6à,,Ü °TÈÔNÜ×1Ñ1°'¸7¿=¹=ÓIÜ0°Ó9Ü guÔ %Üii § ¡ ¨w¯|©|¸W¿\¹\ÓJGä [[XÔ &ñ =Ü×&Ñ& w°¸Ó<F÷ =ð ×%Ñ% f°8Ð%Ó<Ð<÷ =ð =ús Â7C*Ã*C3c ó t | « )z~
|
Construct an appropriately-wrapped result from the ArrayLike result
|
of an arithmetic-like operation.
|
r )rC rÖ r s rD rG z IndexOpsMixin._construct_results s ô
|
" $Ó'Ð'rF )r[ r )r[ zExtensionArray | np.ndarray)r[ r )r[ r r_ )r[ r* )r« znpt.DTypeLike | NonerÄ rú rÅ rH r[ z
|
np.ndarray)r[ rú )NT)r zAxisInt | Nonerä rú r[ rU )r[ r. )rþ rú )FTFNT)
|
r rú r rú r rú r rú r[ r5 )T)r rú r[ rU )F)rS rú r[ rU )FT)r rú r! rú r[ z"tuple[npt.NDArray[np.intp], Index])..)rq r2 r, úLiteral['left', 'right']r- r0 r[ znp.intp)rq z npt.ArrayLike | ExtensionArrayr, rN r- r0 r[ znpt.NDArray[np.intp])ÚleftN)rq z$NumpyValueArrayLike | ExtensionArrayr, rN r- zNumpySorter | Noner[ z npt.NDArray[np.intp] | np.intp)r4 r/ )r2 )r4 r/ r[ znpt.NDArray[np.bool_])4r` ra rb rc Ú__array_priority__Ú frozensetr© rd re r« r® r r² ÚTr´ r¶ r r¼ r¾ rÀ r r rÊ rÇ rØ r rë rò r¨ Úto_listrø r rû r r
|
r; r r r r r r% r" ÚtextwrapÚdedentr6 r
|
r) r8 r7 rL rG rr rF rD r7 r7 sO
ñð
|
ÐÙ$-Ø
|
ó%M>ó ð ò(ó ð(ð ò(ó ð(ð ò ó ð ñ Øð ô Að: ò
|
"ó ð
|
"ó(ð òó ðð2 ñ Só ð Sð< ò#ó ð#ð6 ò!ó ð!ð6 ò>(ó ð>(ð@ ð '+ØØ >>ð Cà#ðCð ðCð ð Cð
|
ò Có ðCðJ Ø ò ó ó ð ñ E% yÔ1à:>ðQØ"ðQØ37ðQà òQó 2ðQñf E %¨zÔ:à:>ð Ø"ð Ø37ð à ò ó ;ð òB"%ðH GóDð8 ò&ó ð&ð4 ó Wó ð Wð> ð ØØ Ø Øð ]
|
àð]
|
ð ð]
|
ð ð ]
|
ð ð ]
|
ð
|
ò]
|
ó ð]
|
ò~ð ó%ó ð%ðN ò7ó ð7ð( ò3ó ð3ð, ò3ó ð3ð, ó'ó ð'ñR Ø× Ñ ØØØØ X__ð ó
|
ô ð Ø $ð àð ð ð ð
|
,ò ó ð ð6` ð ØñðR ð *-Ø !ð à ð ð 'ð ð ð ð
|
|
ò ó ð ð ð *-Ø !ð à-ð ð 'ð ð ð ð
|
|
ò ó ð ñ nÑ %¨WÔ5ð *0Ø%)ð
|
à3ð
|
ð 'ð
|
ð #ð
|
ð
|
|
(ò
|
ó 6ð
|
ð2 3:õ !ð
|
ó5ó ð5ò =ó (rF )Urc Ú
|
__future__r rT Útypingr r r r r r r
|
rè Únumpyr} Úpandas._configr Ú pandas._libsr Úpandas._typingr r r r r r r Ú pandas.compatr Úpandas.compat.numpyr r° Ú pandas.errorsr Úpandas.util._decoratorsr r Úpandas.util._exceptionsr Úpandas.core.dtypes.castr Úpandas.core.dtypes.commonr r Úpandas.core.dtypes.dtypesr Úpandas.core.dtypes.genericr r r! r" Úpandas.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/ r0 r1 r2 r r3 r4 r5 r6 rd Ú_indexops_doc_kwargsr> rh rt r7 rr rF rD ú<module>rm s ðòõ #ã ÷÷ ñ ó ã å .å ÷÷ ñ õ Ý .Ý -÷õ 5å 4÷õ 5÷ó ÷ ÷
|
ñ õ
|
/Ý *Ý -÷ñ
|
÷÷
|
ó ÷ñ ð " nÓ !à ØØ Ø!ñ Ð ô,$=ô ,$÷^ -ñ -ôDdWXÑ&ô dôN[(Hõ [(rF
|
