Ë
|
nñúhO ã ó4 U d Z ddlmZ ddlZddlmZmZmZmZm Z m
|
Z
|
m Z ddl Z ddl ZddlmZmZ ddlmZ ddlmZ ddlmZ dd lmZm Z m Z dd
|
l m Z dd l m!Z!m"Z"m#Z# dd l$m%Z% dd l&m'Z'm(Z(m)Z) ddl*m+Z+ ddl,m-Z-m.Z.m/Z/ ddl0m1Z1 ddl2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z= ddl>m?Z? ddl@mAZA ddlBmCZCmDZD er4ddlEmFZFmGZG ddlHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZY ddlZm[Z[ i Z\de]d< G d d « Z^ G d d e^« Z_ G d d « Z` G d! d"e`« Zay)#z
|
An interface for extending pandas with custom arrays.
|
|
.. warning::
|
|
This is an experimental API and subject to breaking changes
|
without warning.
|
é )Ú annotationsN)Ú TYPE_CHECKINGÚAnyÚCallableÚClassVarÚLiteralÚcastÚoverload)ÚalgosÚlib)Úset_function_name)Úfunction©ÚAbstractMethodError)ÚAppenderÚ SubstitutionÚcache_readonly)Úfind_stack_level)Úvalidate_bool_kwargÚvalidate_fillna_kwargsÚvalidate_insert_loc)Úmaybe_cast_pointwise_result)Ú is_list_likeÚ is_scalarÚ pandas_dtype)ÚExtensionDtype)Ú ABCDataFrameÚABCIndexÚ ABCSeries©Úisna)Ú arraylikeÚmissingÚ roperator)Ú
|
duplicatedÚfactorize_arrayÚisinÚ map_arrayÚmodeÚrankÚunique)Úquantile_with_mask)Ú_fill_limit_area_1d)Ú
|
nargminmaxÚnargsort)ÚIteratorÚSequence)Ú ArrayLikeÚ AstypeArgÚAxisIntÚDtypeÚDtypeObjÚ FillnaOptionsÚInterpolateOptionsÚ NumpySorterÚNumpyValueArrayLikeÚPositionalIndexerÚ ScalarIndexerÚSelfÚSequenceIndexerÚShapeÚSortKindÚ TakeIndexerÚnpt)ÚIndexzdict[str, str]Ú _extension_array_shared_docsc óÒ e Zd ZU dZdZdZedddd`d« Zedad« Zeddd d`d « Z ed
|
« Z
|
e dbd « Z e dcd « Z ddd Z dedZ dfdZdgdZdhdZdidZdidZddej( f djdZedkd« Zedld« Zedfd« Zedfd« Zedfd« Ze dmdnd« Z e dmdod« Z e dmdpd « Z dqdpd Z drd Z edsd « Z dtd!Z d d"d#d$ dud%Z dqdvd&Z!dqdvd'Z" dwd(Z#ddd d) dxd*Z$ dy dzd+Z%d{d,Z& d| d}d.Z'd~dd/Z(d{d0Z) d dd1Z*dd2Z+dd3Z,dd4Z- dq d
d5Z.d6e/d7< e0d ¬8« e1e/d7 « ddd9« « Z2ddd: dd;Z3d{d<Z4ddd=Z5dd>Z6dd?Z7dd@Z8dddAZ9ddBZ:eddC« Z;dddDZ<eddE« Z=e>dsdF« Z?d dG ddHZ@d ddI ddJZAdKeBdL< dtdMZC ddNZDddOZEddPZFddQZGddRZHddSZIddTZJ ddUZKdVdWd-d ddX ddYZLeddZ« ZMdd[ZNdqdd\ZOd d]ZPdd^ZQ d¡d_ZRy)¢ÚExtensionArrayav
|
Abstract base class for custom 1-D array types.
|
|
pandas will recognize instances of this class as proper arrays
|
with a custom type and will not attempt to coerce them to objects. They
|
may be stored directly inside a :class:`DataFrame` or :class:`Series`.
|
|
Attributes
|
----------
|
dtype
|
nbytes
|
ndim
|
shape
|
|
Methods
|
-------
|
argsort
|
astype
|
copy
|
dropna
|
duplicated
|
factorize
|
fillna
|
equals
|
insert
|
interpolate
|
isin
|
isna
|
ravel
|
repeat
|
searchsorted
|
shift
|
take
|
tolist
|
unique
|
view
|
_accumulate
|
_concat_same_type
|
_explode
|
_formatter
|
_from_factorized
|
_from_sequence
|
_from_sequence_of_strings
|
_hash_pandas_object
|
_pad_or_backfill
|
_reduce
|
_values_for_argsort
|
_values_for_factorize
|
|
Notes
|
-----
|
The interface includes the following abstract methods that must be
|
implemented by subclasses:
|
|
* _from_sequence
|
* _from_factorized
|
* __getitem__
|
* __len__
|
* __eq__
|
* dtype
|
* nbytes
|
* isna
|
* take
|
* copy
|
* _concat_same_type
|
* interpolate
|
|
A default repr displaying the type, (truncated) data, length,
|
and dtype is provided. It can be customized or replaced by
|
by overriding:
|
|
* __repr__ : A default repr for the ExtensionArray.
|
* _formatter : Print scalars inside a Series or DataFrame.
|
|
Some methods require casting the ExtensionArray to an ndarray of Python
|
objects with ``self.astype(object)``, which may be expensive. When
|
performance is a concern, we highly recommend overriding the following
|
methods:
|
|
* fillna
|
* _pad_or_backfill
|
* dropna
|
* unique
|
* factorize / _values_for_factorize
|
* argsort, argmax, argmin / _values_for_argsort
|
* searchsorted
|
* map
|
|
The remaining methods implemented on this class should be performant,
|
as they only compose abstract methods. Still, a more efficient
|
implementation may be available, and these methods can be overridden.
|
|
One can implement methods to handle array accumulations or reductions.
|
|
* _accumulate
|
* _reduce
|
|
One can implement methods to handle parsing from strings that will be used
|
in methods such as ``pandas.io.parsers.read_csv``.
|
|
* _from_sequence_of_strings
|
|
This class does not inherit from 'abc.ABCMeta' for performance reasons.
|
Methods and properties required by the interface raise
|
``pandas.errors.AbstractMethodError`` and no ``register`` method is
|
provided for registering virtual subclasses.
|
|
ExtensionArrays are limited to 1 dimension.
|
|
They may be backed by none, one, or many NumPy arrays. For example,
|
``pandas.Categorical`` is an extension array backed by two arrays,
|
one for codes and one for categories. An array of IPv6 address may
|
be backed by a NumPy structured array with two fields, one for the
|
lower 64 bits and one for the upper 64 bits. Or they may be backed
|
by some other storage type, like Python lists. Pandas makes no
|
assumptions on how the data are stored, just that it can be converted
|
to a NumPy array.
|
The ExtensionArray interface does not impose any rules on how this data
|
is stored. However, currently, the backing data cannot be stored in
|
attributes called ``.values`` or ``._values`` to ensure full compatibility
|
with pandas internals. But other names as ``.data``, ``._data``,
|
``._items``, ... can be freely used.
|
|
If implementing NumPy's ``__array_ufunc__`` interface, pandas expects
|
that
|
|
1. You defer by returning ``NotImplemented`` when any Series are present
|
in `inputs`. Pandas will extract the arrays and call the ufunc again.
|
2. You define a ``_HANDLED_TYPES`` tuple as an attribute on the class.
|
Pandas inspect this to determine whether the ufunc is valid for the
|
types present.
|
|
See :ref:`extending.extension.ufunc` for more.
|
|
By default, ExtensionArrays are not hashable. Immutable subclasses may
|
override this behavior.
|
|
Examples
|
--------
|
Please see the following:
|
|
https://github.com/pandas-dev/pandas/blob/main/pandas/tests/extension/list/array.py
|
Ú extensioniè NF©ÚdtypeÚcopyc ó t | « )añ
|
Construct a new ExtensionArray from a sequence of scalars.
|
|
Parameters
|
----------
|
scalars : Sequence
|
Each element will be an instance of the scalar type for this
|
array, ``cls.dtype.type`` or be converted into this type in this method.
|
dtype : dtype, optional
|
Construct for this particular dtype. This should be a Dtype
|
compatible with the ExtensionArray.
|
copy : bool, default False
|
If True, copy the underlying data.
|
|
Returns
|
-------
|
ExtensionArray
|
|
Examples
|
--------
|
>>> pd.arrays.IntegerArray._from_sequence([4, 5])
|
<IntegerArray>
|
[4, 5]
|
Length: 2, dtype: Int64
|
r )ÚclsÚscalarsrI rJ s úJH:\Change_password\venv_build\Lib\site-packages\pandas/core/arrays/base.pyÚ_from_sequencez ExtensionArray._from_sequence ó ô6 " #Ó&Ð&ó c ó¤ | j ||d¬« S # t t f$ r t $ r! t j
|
dt « ¬« w xY w)a¼
|
Strict analogue to _from_sequence, allowing only sequences of scalars
|
that should be specifically inferred to the given dtype.
|
|
Parameters
|
----------
|
scalars : sequence
|
dtype : ExtensionDtype
|
|
Raises
|
------
|
TypeError or ValueError
|
|
Notes
|
-----
|
This is called in a try/except block when casting the result of a
|
pointwise operation.
|
FrH zm_from_scalars should only raise ValueError or TypeError. Consider overriding _from_scalars where appropriate.©Ú
|
stacklevel)rO Ú
|
ValueErrorÚ TypeErrorÚ ExceptionÚwarningsÚwarnr )rL rM rI s rN Ú _from_scalarsz ExtensionArray._from_scalars* s[ ð(
|
Ø×%Ñ% g°UÀÐ%ÓGÐ GøÜIÐ&ò Ø Üò Ü MMðGä+Ó-õ ð
|
ð ús 9Ac ó t | « )aÚ
|
Construct a new ExtensionArray from a sequence of strings.
|
|
Parameters
|
----------
|
strings : Sequence
|
Each element will be an instance of the scalar type for this
|
array, ``cls.dtype.type``.
|
dtype : dtype, optional
|
Construct for this particular dtype. This should be a Dtype
|
compatible with the ExtensionArray.
|
copy : bool, default False
|
If True, copy the underlying data.
|
|
Returns
|
-------
|
ExtensionArray
|
|
Examples
|
--------
|
>>> pd.arrays.IntegerArray._from_sequence_of_strings(["1", "2", "3"])
|
<IntegerArray>
|
[1, 2, 3]
|
Length: 3, dtype: Int64
|
r )rL ÚstringsrI rJ s rN Ú_from_sequence_of_stringsz(ExtensionArray._from_sequence_of_stringsJ s ô: " #Ó&Ð&rQ c ó t | « )a
|
Reconstruct an ExtensionArray after factorization.
|
|
Parameters
|
----------
|
values : ndarray
|
An integer ndarray with the factorized values.
|
original : ExtensionArray
|
The original ExtensionArray that factorize was called on.
|
|
See Also
|
--------
|
factorize : Top-level factorize method that dispatches here.
|
ExtensionArray.factorize : Encode the extension array as an enumerated type.
|
|
Examples
|
--------
|
>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1),
|
... pd.Interval(1, 5), pd.Interval(1, 5)])
|
>>> codes, uniques = pd.factorize(interv_arr)
|
>>> pd.arrays.IntervalArray._from_factorized(uniques, interv_arr)
|
<IntervalArray>
|
[(0, 1], (1, 5]]
|
Length: 2, dtype: interval[int64, right]
|
r )rL ÚvaluesÚoriginals rN Ú_from_factorizedz ExtensionArray._from_factorizedi rP rQ c ó y ©N© ©ÚselfÚitems rN Ú __getitem__zExtensionArray.__getitem__ ó à rQ c ó y rc rd re s rN rh zExtensionArray.__getitem__ ri rQ c ó t | « )an
|
Select a subset of self.
|
|
Parameters
|
----------
|
item : int, slice, or ndarray
|
* int: The position in 'self' to get.
|
|
* slice: A slice object, where 'start', 'stop', and 'step' are
|
integers or None
|
|
* ndarray: A 1-d boolean NumPy ndarray the same length as 'self'
|
|
* list[int]: A list of int
|
|
Returns
|
-------
|
item : scalar or ExtensionArray
|
|
Notes
|
-----
|
For scalar ``item``, return a scalar value suitable for the array's
|
type. This should be an instance of ``self.dtype.type``.
|
|
For slice ``key``, return an instance of ``ExtensionArray``, even
|
if the slice is length 0 or 1.
|
|
For a boolean mask, return an instance of ``ExtensionArray``, filtered
|
to the values where ``item`` is True.
|
r re s rN rh zExtensionArray.__getitem__ s ô> " $Ó'Ð'rQ c ó0 t t | « d« )a^
|
Set one or more values inplace.
|
|
This method is not required to satisfy the pandas extension array
|
interface.
|
|
Parameters
|
----------
|
key : int, ndarray, or slice
|
When called from, e.g. ``Series.__setitem__``, ``key`` will be
|
one of
|
|
* scalar int
|
* ndarray of integers.
|
* boolean ndarray
|
* slice object
|
|
value : ExtensionDtype.type, Sequence[ExtensionDtype.type], or object
|
value or values to be set of ``key``.
|
|
Returns
|
-------
|
None
|
z does not implement __setitem__.)ÚNotImplementedErrorÚtype)rf ÚkeyÚvalues rN Ú __setitem__zExtensionArray.__setitem__² s ôV "¤T¨$£Z LÐ0PÐ"QÓRÐRrQ c ó t | « )z\
|
Length of this array
|
|
Returns
|
-------
|
length : int
|
r ©rf s rN Ú__len__zExtensionArray.__len__ß s ô " $Ó'Ð'rQ c # óL K t t | « « D ] }| | yw)z5
|
Iterate over elements of the array.
|
N)ÚrangeÚlen)rf Úis rN Ú__iter__zExtensionArray.__iter__é s) è ø ô s4yÓ!ò AØq'Mñ ùs "$c óø t |« r]t |« rR| j sy|| j j u s t || j j « r | j S y|| k( j « S )z,
|
Return for `item in self`.
|
F) r r! Ú _can_hold_narI Úna_valueÚ
|
isinstancern Ú_hasnaÚanyre s rN Ú __contains__zExtensionArray.__contains__ó sb ô T?t DzØ×$Ò$Ø Ø×,Ñ,Ñ,´
|
¸4ÀÇÁÇ Á Ô0QØ{{Ð"à ð DL×%Ñ%Ó'Ð 'rQ c ó t | « )zE
|
Return for `self == other` (element-wise equality).
|
r ©rf Úothers rN Ú__eq__zExtensionArray.__eq__ ó ô " $Ó'Ð'rQ c ó | |k( S )zH
|
Return for `self != other` (element-wise in-equality).
|
rd r s rN Ú__ne__zExtensionArray.__ne__ s ð
|
Ð Ð rQ c óÆ t j | |¬« }|s|t j ur|j « }|t j ur||| j « < |S )aI
|
Convert to a NumPy ndarray.
|
|
This is similar to :meth:`numpy.asarray`, but may provide additional control
|
over how the conversion is done.
|
|
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 a 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.
|
|
Returns
|
-------
|
numpy.ndarray
|
©rI )ÚnpÚasarrayr Ú
|
no_defaultrJ r! )rf rI rJ r| Úresults rN Úto_numpyzExtensionArray.to_numpy sN ô: D¨Ô.Ù 8¤3§>¡>Ñ1Ø[[]FØ 3>>Ñ )Ø"*F499;Ñ Ø rQ c ó t | « )z
|
An instance of ExtensionDtype.
|
|
Examples
|
--------
|
>>> pd.array([1, 2, 3]).dtype
|
Int64Dtype()
|
r rs s rN rI zExtensionArray.dtypeC r
rQ c ó t | « fS )z¥
|
Return a tuple of the array dimensions.
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr.shape
|
(3,)
|
)rw rs s rN ÚshapezExtensionArray.shapeO s ô D |ÐrQ c ó@ t j | j « S )z6
|
The number of elements in the array.
|
)r Úprodr rs s rN ÚsizezExtensionArray.size\ s ô wwtzzÓ"Ð"rQ c ó y)z°
|
Extension Arrays are only allowed to be 1-dimensional.
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr.ndim
|
1
|
é rd rs s rN ÚndimzExtensionArray.ndime s ð rQ c ó t | « )z¡
|
The number of bytes needed to store this object in memory.
|
|
Examples
|
--------
|
>>> pd.array([1, 2, 3]).nbytes
|
27
|
r rs s rN ÚnbyteszExtensionArray.nbytesr s ô " $Ó'Ð'rQ c ó y rc rd ©rf rI rJ s rN ÚastypezExtensionArray.astype ri rQ c ó y rc rd r s rN r zExtensionArray.astype ri rQ c ó y rc rd r s rN r zExtensionArray.astype ri rQ Tc óè t |« }|| j k( r|s| S | j « S t |t « r$|j « }|j | ||¬« S t j |d« rddl m
|
} |j | ||¬« S t j |d« rddl m } |j | ||¬« S |st j | |¬« S t j | ||¬« S )aÖ
|
Cast to a NumPy array or ExtensionArray with 'dtype'.
|
|
Parameters
|
----------
|
dtype : str or dtype
|
Typecode or data-type to which the array is cast.
|
copy : bool, default True
|
Whether to copy the data, even if not necessary. If False,
|
a copy is made only if the old dtype does not match the
|
new dtype.
|
|
Returns
|
-------
|
np.ndarray or pandas.api.extensions.ExtensionArray
|
An ``ExtensionArray`` if ``dtype`` is ``ExtensionDtype``,
|
otherwise a Numpy ndarray with ``dtype`` for its dtype.
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr
|
<IntegerArray>
|
[1, 2, 3]
|
Length: 3, dtype: Int64
|
|
Casting to another ``ExtensionDtype`` returns an ``ExtensionArray``:
|
|
>>> arr1 = arr.astype('Float64')
|
>>> arr1
|
<FloatingArray>
|
[1.0, 2.0, 3.0]
|
Length: 3, dtype: Float64
|
>>> arr1.dtype
|
Float64Dtype()
|
|
Otherwise, we will get a Numpy ndarray:
|
|
>>> arr2 = arr.astype('float64')
|
>>> arr2
|
array([1., 2., 3.])
|
>>> arr2.dtype
|
dtype('float64')
|
rH ÚMr )Ú DatetimeArrayÚm)ÚTimedeltaArrayr )r rI rJ r} r Úconstruct_array_typerO r Ú is_np_dtypeÚpandas.core.arraysr¡ r£ r r Úarray)rf rI rJ rL r¡ r£ s rN r zExtensionArray.astype sØ ôZ UÓ#Ø DJJÒ ÙØ àyy{Ð"ä e^Ô ,Ø×,Ñ,Ó.CØ×%Ñ% d°%¸dÐ%ÓCÐ Cä __U CÔ (Ý 8à ×/Ñ/°¸EÈÐ/ÓMÐ Mä __U CÔ (Ý 9à!×0Ñ0°¸UÈÐ0ÓNÐ NáÜ::d¨%Ô0Ð 0ä88D¨°DÔ9Ð 9rQ c ó t | « )a'
|
A 1-D array indicating if each value is missing.
|
|
Returns
|
-------
|
numpy.ndarray or pandas.api.extensions.ExtensionArray
|
In most cases, this should return a NumPy ndarray. For
|
exceptional cases like ``SparseArray``, where returning
|
an ndarray would be expensive, an ExtensionArray may be
|
returned.
|
|
Notes
|
-----
|
If returning an ExtensionArray, then
|
|
* ``na_values._is_boolean`` should be True
|
* `na_values` should implement :func:`ExtensionArray._reduce`
|
* ``na_values.any`` and ``na_values.all`` should be implemented
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, np.nan, np.nan])
|
>>> arr.isna()
|
array([False, False, True, True])
|
r rs s rN r! zExtensionArray.isna× s ô4 " $Ó'Ð'rQ c óP t | j « j « « S )z
|
Equivalent to `self.isna().any()`.
|
|
Some ExtensionArray subclasses may be able to optimize this check.
|
)Úboolr! r rs s rN r~ zExtensionArray._hasnaó s ô DIIKOOÓ%Ó&Ð&rQ c ó, t j | « S )aï
|
Return values for sorting.
|
|
Returns
|
-------
|
ndarray
|
The transformed values should maintain the ordering between values
|
within the array.
|
|
See Also
|
--------
|
ExtensionArray.argsort : Return the indices that would sort this array.
|
|
Notes
|
-----
|
The caller is responsible for *not* modifying these values in-place, so
|
it is safe for implementers to give views on ``self``.
|
|
Functions that use this (e.g. ``ExtensionArray.argsort``) should ignore
|
entries with missing values in the original array (according to
|
``self.isna()``). This means that the corresponding entries in the returned
|
array don't need to be modified to sort correctly.
|
|
Examples
|
--------
|
In most cases, this is the underlying Numpy array of the ``ExtensionArray``:
|
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr._values_for_argsort()
|
array([1, 2, 3])
|
)r r§ rs s rN Ú_values_for_argsortz"ExtensionArray._values_for_argsortý s ôB xx~Ð rQ Ú quicksortÚlast)Ú ascendingÚkindÚ na_positionc
|
ó² t j |d|« }| j « }t ||||t j
|
| j « « ¬« S )aú
|
Return the indices that would sort this array.
|
|
Parameters
|
----------
|
ascending : bool, default True
|
Whether the indices should result in an ascending
|
or descending sort.
|
kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
|
Sorting algorithm.
|
na_position : {'first', 'last'}, default 'last'
|
If ``'first'``, put ``NaN`` values at the beginning.
|
If ``'last'``, put ``NaN`` values at the end.
|
*args, **kwargs:
|
Passed through to :func:`numpy.argsort`.
|
|
Returns
|
-------
|
np.ndarray[np.intp]
|
Array of indices that sort ``self``. If NaN values are contained,
|
NaN values are placed at the end.
|
|
See Also
|
--------
|
numpy.argsort : Sorting implementation used internally.
|
|
Examples
|
--------
|
>>> arr = pd.array([3, 1, 2, 5, 4])
|
>>> arr.argsort()
|
array([1, 2, 0, 4, 3])
|
rd )r° r¯ r± Úmask)ÚnvÚ validate_argsort_with_ascendingr¬ r/ r r r! )rf r¯ r° r± Úkwargsr_ s rN ÚargsortzExtensionArray.argsort sR ôZ ×6Ñ6°yÀ"ÀfÓM à×)Ñ)Ó+ÜØ ØØ Ø#ÜDIIKÓ(ô
|
ð
|
rQ c óZ t |d« |s| j rt t | d« S )a
|
Return the index of minimum value.
|
|
In case of multiple occurrences of the minimum value, the index
|
corresponding to the first occurrence is returned.
|
|
Parameters
|
----------
|
skipna : bool, default True
|
|
Returns
|
-------
|
int
|
|
See Also
|
--------
|
ExtensionArray.argmax : Return the index of the maximum value.
|
|
Examples
|
--------
|
>>> arr = pd.array([3, 1, 2, 5, 4])
|
>>> arr.argmin()
|
1
|
ÚskipnaÚargmin©r r~ rm r. ©rf r¹ s rN rº zExtensionArray.argminX ó* ô: F HÔ-Ù$++Ü%Ð %Ü$ Ó)Ð)rQ c óZ t |d« |s| j rt t | d« S )a
|
Return the index of maximum value.
|
|
In case of multiple occurrences of the maximum value, the index
|
corresponding to the first occurrence is returned.
|
|
Parameters
|
----------
|
skipna : bool, default True
|
|
Returns
|
-------
|
int
|
|
See Also
|
--------
|
ExtensionArray.argmin : Return the index of the minimum value.
|
|
Examples
|
--------
|
>>> arr = pd.array([3, 1, 2, 5, 4])
|
>>> arr.argmax()
|
3
|
r¹ Úargmaxr» r¼ s rN r¿ zExtensionArray.argmaxz r½ rQ c óD t t | « j d« )a
|
See DataFrame.interpolate.__doc__.
|
|
Examples
|
--------
|
>>> arr = pd.arrays.NumpyExtensionArray(np.array([0, 1, np.nan, 3]))
|
>>> arr.interpolate(method="linear",
|
... limit=3,
|
... limit_direction="forward",
|
... index=pd.Index([1, 2, 3, 4]),
|
... fill_value=1,
|
... copy=False,
|
... axis=0,
|
... limit_area="inside"
|
... )
|
<NumpyExtensionArray>
|
[0.0, 1.0, 2.0, 3.0]
|
Length: 4, dtype: float64
|
z does not implement interpolate)rm rn Ú__name__) rf ÚmethodÚaxisÚindexÚlimitÚlimit_directionÚ
|
limit_arearJ r¶ s rN Ú interpolatezExtensionArray.interpolate s( ô@ "ÜDz×"Ñ"Ð#Ð#BÐ Có
|
ð
|
rQ )rÅ rÇ rJ c ó t | « j t j urt | « j t j u rZt j
|
dt t « ¬« |!t t | « j d« | j ||¬« S | j « }|j « r³t j |« }t j |« }| |j! « s t# ||« |dk( r*t% j& ||¬« }| j) |d¬ « S t% j& |ddd
|
|¬« ddd
|
}| ddd
|
j) |d¬ « S |s| S | j+ « } | S ) a&
|
Pad or backfill values, used by Series/DataFrame ffill and bfill.
|
|
Parameters
|
----------
|
method : {'backfill', 'bfill', 'pad', 'ffill'}
|
Method to use for filling holes in reindexed Series:
|
|
* pad / ffill: propagate last valid observation forward to next valid.
|
* backfill / bfill: use NEXT valid observation to fill gap.
|
|
limit : int, default None
|
This is the maximum number of consecutive
|
NaN values to forward/backward fill. In other words, if there is
|
a gap with more than this number of consecutive NaNs, it will only
|
be partially filled. If method is not specified, this is the
|
maximum number of entries along the entire axis where NaNs will be
|
filled.
|
|
copy : bool, default True
|
Whether to make a copy of the data before filling. If False, then
|
the original should be modified and no new memory should be allocated.
|
For ExtensionArray subclasses that cannot do this, it is at the
|
author's discretion whether to ignore "copy=False" or to raise.
|
The base class implementation ignores the keyword if any NAs are
|
present.
|
|
Returns
|
-------
|
Same type as self
|
|
Examples
|
--------
|
>>> arr = pd.array([np.nan, np.nan, 2, 3, np.nan, np.nan])
|
>>> arr._pad_or_backfill(method="backfill", limit=1)
|
<IntegerArray>
|
[<NA>, 2, 2, 3, <NA>, <NA>]
|
Length: 6, dtype: Int64
|
z¼ExtensionArray.fillna 'method' keyword is deprecated. In a future version. arr._pad_or_backfill will be called instead. 3rd-party ExtensionArray authors need to implement _pad_or_backfill.rS Nz does not implement limit_area (added in pandas 2.2). 3rd-party ExtnsionArray authors need to add this argument to _pad_or_backfill.)r rÅ Úpad©rÅ T©Ú
|
allow_filléÿÿÿÿ)rn ÚfillnarF Ú_pad_or_backfillrX rY ÚDeprecationWarningr rm rÁ r! r r# Úclean_fill_methodr r Úallr- ÚlibalgosÚget_fill_indexerÚtakerJ )
|
rf r rÅ rÇ rJ r³ ÚmethÚnpmaskÚindexerÚ
|
new_valuess
|
rN rÐ z ExtensionArray._pad_or_backfillÀ sk ôf J× Ñ ¤^×%:Ñ%:Ñ :ÜT
|
×+Ñ+¬~×/NÑ/NÑNô MMð$ô #Ü+Ó-õ ð Ð%Ü)ÜDz×*Ñ*Ð+ð ,Eð Eóð ð
|
;; f°E;Ó:Ð :àyy{à 88:ä×,Ñ,¨VÓ4DäZZ Ó%FØÐ%¨f¯j©j¬lÜ# F¨JÔ7Øu}Ü"×3Ñ3°FÀ%ÔHØyy °TyÓ:Ð:ô #×3Ñ3°F¹4¸R¸4±LÈÔNÉtÐQSÈtÑTØDbDz w¸4Ó@Ð@ñ Ø Ø JØÐrQ c ó¼ |;t j dt | « j dt t « ¬« t ||« \ }}| j « }t j ||t | « « }|j « r¶|t j |« }t j |« }|dk( r*t j ||¬« }| j# |d¬« S t j |ddd
|¬« ddd
}| ddd
j# |d¬« S |s| dd } n| j% « } || |< | S |s| dd } | S | j% « } | S )
|
at
|
Fill NA/NaN values using the specified method.
|
|
Parameters
|
----------
|
value : scalar, array-like
|
If a scalar value is passed it is used to fill all missing values.
|
Alternatively, an array-like "value" can be given. It's expected
|
that the array-like have the same length as 'self'.
|
method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None
|
Method to use for filling holes in reindexed Series:
|
|
* pad / ffill: propagate last valid observation forward to next valid.
|
* backfill / bfill: use NEXT valid observation to fill gap.
|
|
.. deprecated:: 2.1.0
|
|
limit : int, default None
|
If method is specified, this is the maximum number of consecutive
|
NaN values to forward/backward fill. In other words, if there is
|
a gap with more than this number of consecutive NaNs, it will only
|
be partially filled. If method is not specified, this is the
|
maximum number of entries along the entire axis where NaNs will be
|
filled.
|
|
.. deprecated:: 2.1.0
|
|
copy : bool, default True
|
Whether to make a copy of the data before filling. If False, then
|
the original should be modified and no new memory should be allocated.
|
For ExtensionArray subclasses that cannot do this, it is at the
|
author's discretion whether to ignore "copy=False" or to raise.
|
The base class implementation ignores the keyword in pad/backfill
|
cases.
|
|
Returns
|
-------
|
ExtensionArray
|
With NA/NaN filled.
|
|
Examples
|
--------
|
>>> arr = pd.array([np.nan, np.nan, 2, 3, np.nan, np.nan])
|
>>> arr.fillna(0)
|
<IntegerArray>
|
[0, 0, 2, 3, 0, 0]
|
Length: 6, dtype: Int64
|
NzThe 'method' keyword in z>.fillna is deprecated and will be removed in a future version.rS rÊ rË TrÌ rÎ )rX rY rn rÁ Ú FutureWarningr r r! r# Úcheck_value_sizerw r rÒ r r rÔ rÕ rÖ rJ )
|
rf rp r rÅ rJ r³ r× rØ rÙ rÚ s
|
rN rÏ zExtensionArray.fillna sk ðn Ð Ü MMØ*¬4°«:×+>Ñ+>Ð*?ð @Fð Fä Ü+Ó-õ ô /¨u°fÓ= vàyy{ô ×(Ñ(Ø 4Tó
|
ð 88:ØÐ!Ü ×0Ñ0°Ó8ä DÓ)Ø5=Ü &× 7Ñ 7¸ÀeÔ LGØ 99 W¸9Ó>Ð>ô '× 7Ñ 7¸¹tÀ¸t¹ ÈEÔ RÑSWÐUWÐSWÑ XGØ ¡ " :??¨7¸t?ÓDÐDñ Ø!%¡a Jà!%§¡£JØ#(
|
4Ñ ð Ðñ Ø !¡!W
|
ð Ðð "YY[
|
ØÐrQ c ó* | | j « S )zò
|
Return ExtensionArray without NA values.
|
|
Returns
|
-------
|
|
Examples
|
--------
|
>>> pd.array([1, 2, np.nan]).dropna()
|
<IntegerArray>
|
[1, 2]
|
Length: 2, dtype: Int64
|
r rs s rN ÚdropnazExtensionArray.dropna s ð TYY[LÑ!Ð!rQ Úkeepc ó| | j « j t j d¬« }t | ||¬« S )aU
|
Return boolean ndarray denoting duplicate values.
|
|
Parameters
|
----------
|
keep : {'first', 'last', False}, default 'first'
|
- ``first`` : Mark duplicates as ``True`` except for the first occurrence.
|
- ``last`` : Mark duplicates as ``True`` except for the last occurrence.
|
- False : Mark all duplicates as ``True``.
|
|
Returns
|
-------
|
ndarray[bool]
|
|
Examples
|
--------
|
>>> pd.array([1, 1, 2, 3, 3], dtype="Int64").duplicated()
|
array([False, True, False, False, True])
|
F)rJ )r_ rà r³ )r! r r Úbool_r% )rf rà r³ s rN r% zExtensionArray.duplicated s2 ð, yy{×!Ñ!¤"§(¡(°Ð!Ó7Ü ¨D°tÔ<Ð<rQ c ó` t | « r|dk( r| j « S t |« r| j j }| j |gt t |« t | « « z | j ¬« }|dkD r |}| d| }n| t |« d }|}| j ||g« S )a@
|
Shift values by desired number.
|
|
Newly introduced missing values are filled with
|
``self.dtype.na_value``.
|
|
Parameters
|
----------
|
periods : int, default 1
|
The number of periods to shift. Negative values are allowed
|
for shifting backwards.
|
|
fill_value : object, optional
|
The scalar value to use for newly introduced missing values.
|
The default is ``self.dtype.na_value``.
|
|
Returns
|
-------
|
ExtensionArray
|
Shifted.
|
|
Notes
|
-----
|
If ``self`` is empty or ``periods`` is 0, a copy of ``self`` is
|
returned.
|
|
If ``periods > len(self)``, then an array of size
|
len(self) is returned, with all values filled with
|
``self.dtype.na_value``.
|
|
For 2-dimensional ExtensionArrays, we are always shifting along axis=0.
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr.shift(2)
|
<IntegerArray>
|
[<NA>, <NA>, 1]
|
Length: 3, dtype: Int64
|
r r N) rw rJ r! rI r| rO ÚminÚabsÚ_concat_same_type)rf ÚperiodsÚ
|
fill_valueÚemptyÚaÚbs rN ÚshiftzExtensionArray.shift« s® ôV 4yG qLØ99;Ð ä
|
Ô Ø ×,Ñ,Jà×#Ñ#Ø L3s 7|¬S°«YÓ7Ñ 7¸t¿z¹zð $ó
|
ð Q;ØAØYwhAàS\^Ð$AØAØ×%Ñ% q¨! fÓ-Ð-rQ c óx t | j t « « }| j || j ¬« S )a@
|
Compute the ExtensionArray of unique values.
|
|
Returns
|
-------
|
pandas.api.extensions.ExtensionArray
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3, 1, 2, 3])
|
>>> arr.unique()
|
<IntegerArray>
|
[1, 2, 3]
|
Length: 3, dtype: Int64
|
r )r+ r ÚobjectrO rI )rf Úuniquess rN r+ zExtensionArray.uniqueç s1 ô ¤VÓ,Ó-Ø×"Ñ" 7°$·*±*Ð"Ó=Ð=rQ c ó | j t « }t |t « r|j t « }|j |||¬« S )a8
|
Find indices where elements should be inserted to maintain order.
|
|
Find the indices into a sorted array `self` (a) such that, if the
|
corresponding elements in `value` were inserted before the indices,
|
the order of `self` would be preserved.
|
|
Assuming that `self` is sorted:
|
|
====== ================================
|
`side` returned index `i` satisfies
|
====== ================================
|
left ``self[i-1] < value <= self[i]``
|
right ``self[i-1] <= value < self[i]``
|
====== ================================
|
|
Parameters
|
----------
|
value : array-like, list or scalar
|
Value(s) 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 array a into ascending
|
order. They are typically the result of argsort.
|
|
Returns
|
-------
|
array of ints or int
|
If value is array-like, array of insertion points.
|
If value is scalar, a single integer.
|
|
See Also
|
--------
|
numpy.searchsorted : Similar method from NumPy.
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3, 5])
|
>>> arr.searchsorted([4])
|
array([3])
|
)ÚsideÚsorter)r rî r} rF Ú searchsorted)rf rp rñ rò Úarrs rN ró zExtensionArray.searchsortedú sC ðn kk&Ó!Ü e^Ô ,ØLL¤Ó(EØ× Ñ ¨D¸Ð Ó@Ð@rQ c ó| t | « t |« k7 ryt t |« }| j |j k7 ryt | « t |« k7 ry| |k( }t |t « r|j d« }| j « |j « z }t ||z j « « S )a
|
Return if another array is equivalent to this array.
|
|
Equivalent means that both arrays have the same shape and dtype, and
|
all values compare equal. Missing values in the same location are
|
considered equal (in contrast with normal equality).
|
|
Parameters
|
----------
|
other : ExtensionArray
|
Array to compare to this Array.
|
|
Returns
|
-------
|
boolean
|
Whether the arrays are equivalent.
|
|
Examples
|
--------
|
>>> arr1 = pd.array([1, 2, np.nan])
|
>>> arr2 = pd.array([1, 2, np.nan])
|
>>> arr1.equals(arr2)
|
True
|
F)
|
rn r rF rI rw r} rÏ r! rª rÓ )rf r Ú equal_valuesÚequal_nas rN ÚequalszExtensionArray.equals6 s ô2 :eÒ $ØÜ^ UÓ+Ø ::Ò $ØÜ Y#e*Ò $Øà 5=LÜ,¬Ô7à +× 2Ñ 2°5Ó 9 àyy{ U§Z¡Z£\Ñ1HÜ ¨Ñ0×5Ñ5Ó7Ó8Ð 8rQ c ó@ t t j | « |« S )aÞ
|
Pointwise comparison for set containment in the given values.
|
|
Roughly equivalent to `np.array([x in values for x in self])`
|
|
Parameters
|
----------
|
values : np.ndarray or ExtensionArray
|
|
Returns
|
-------
|
np.ndarray[bool]
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr.isin([1])
|
<BooleanArray>
|
[True, False, False]
|
Length: 3, dtype: boolean
|
)r' r r )rf r_ s rN r' zExtensionArray.isin_ s ô, BJJtÓ$ fÓ-Ð-rQ c óL | j t « t j fS )aÝ
|
Return an array and missing value suitable for factorization.
|
|
Returns
|
-------
|
values : ndarray
|
An array suitable for factorization. This should maintain order
|
and be a supported dtype (Float64, Int64, UInt64, String, Object).
|
By default, the extension array is cast to object dtype.
|
na_value : object
|
The value in `values` to consider missing. This will be treated
|
as NA in the factorization routines, so it will be coded as
|
`-1` and not included in `uniques`. By default,
|
``np.nan`` is used.
|
|
Notes
|
-----
|
The values returned by this method are also used in
|
:func:`pandas.util.hash_pandas_object`. If needed, this can be
|
overridden in the ``self._hash_pandas_object()`` method.
|
|
Examples
|
--------
|
>>> pd.array([1, 2, 3])._values_for_factorize()
|
(array([1, 2, 3], dtype=object), nan)
|
)r rî r Únanrs s rN Ú_values_for_factorizez$ExtensionArray._values_for_factorizew s ð6 {{6Ó"¤B§F¡FÐ*Ð*rQ c óv | j « \ }}t |||¬« \ }}| j || « }||fS )a
|
Encode the extension array as an enumerated type.
|
|
Parameters
|
----------
|
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.
|
|
.. versionadded:: 1.5.0
|
|
Returns
|
-------
|
codes : ndarray
|
An integer NumPy array that's an indexer into the original
|
ExtensionArray.
|
uniques : ExtensionArray
|
An ExtensionArray containing the unique values of `self`.
|
|
.. note::
|
|
uniques will *not* contain an entry for the NA value of
|
the ExtensionArray if there are any missing values present
|
in `self`.
|
|
See Also
|
--------
|
factorize : Top-level factorize method that dispatches here.
|
|
Notes
|
-----
|
:meth:`pandas.factorize` offers a `sort` keyword as well.
|
|
Examples
|
--------
|
>>> idx1 = pd.PeriodIndex(["2014-01", "2014-01", "2014-02", "2014-02",
|
... "2014-03", "2014-03"], freq="M")
|
>>> arr, idx = idx1.factorize()
|
>>> arr
|
array([0, 0, 1, 1, 2, 2])
|
>>> idx
|
PeriodIndex(['2014-01', '2014-02', '2014-03'], dtype='period[M]')
|
)Úuse_na_sentinelr| )rü r& ra )rf rþ rô r| Úcodesrï Ú
|
uniques_eas rN Ú factorizezExtensionArray.factorize sK ðp ×2Ñ2Ó4 Xä(Ø ¸8ô
|
wð ×*Ñ*¨7°DÓ9
|
ØjÐ Ð rQ a;
|
Repeat elements of a %(klass)s.
|
|
Returns a new %(klass)s where each element of the current %(klass)s
|
is repeated consecutively a given number of times.
|
|
Parameters
|
----------
|
repeats : int or array of ints
|
The number of repetitions for each element. This should be a
|
non-negative integer. Repeating 0 times will return an empty
|
%(klass)s.
|
axis : None
|
Must be ``None``. Has no effect but is accepted for compatibility
|
with numpy.
|
|
Returns
|
-------
|
%(klass)s
|
Newly created %(klass)s with repeated elements.
|
|
See Also
|
--------
|
Series.repeat : Equivalent function for Series.
|
Index.repeat : Equivalent function for Index.
|
numpy.repeat : Similar method for :class:`numpy.ndarray`.
|
ExtensionArray.take : Take arbitrary positions.
|
|
Examples
|
--------
|
>>> cat = pd.Categorical(['a', 'b', 'c'])
|
>>> cat
|
['a', 'b', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
>>> cat.repeat(2)
|
['a', 'a', 'b', 'b', 'c', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
>>> cat.repeat([1, 2, 3])
|
['a', 'b', 'b', 'c', 'c', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
Úrepeat)Úklassc ó® t j dd|i« t j t | « « j |« }| j |« S )Nrd rà )r´ Úvalidate_repeatr Úarangerw r rÖ )rf Úrepeatsrà Úinds rN r zExtensionArray.repeat sC ô ×Ñ2 ¨~Ô.ÜiiD Ó"×)Ñ)¨'Ó2Øyy~Ð rQ )rÍ rè c ó t | « )aò
|
Take elements from an array.
|
|
Parameters
|
----------
|
indices : sequence of int or one-dimensional np.ndarray of int
|
Indices to be taken.
|
allow_fill : bool, default False
|
How to handle negative values in `indices`.
|
|
* False: negative values in `indices` indicate positional indices
|
from the right (the default). This is similar to
|
:func:`numpy.take`.
|
|
* True: negative values in `indices` indicate
|
missing values. These values are set to `fill_value`. Any other
|
other negative values raise a ``ValueError``.
|
|
fill_value : any, optional
|
Fill value to use for NA-indices when `allow_fill` is True.
|
This may be ``None``, in which case the default NA value for
|
the type, ``self.dtype.na_value``, is used.
|
|
For many ExtensionArrays, there will be two representations of
|
`fill_value`: a user-facing "boxed" scalar, and a low-level
|
physical NA value. `fill_value` should be the user-facing version,
|
and the implementation should handle translating that to the
|
physical version for processing the take if necessary.
|
|
Returns
|
-------
|
ExtensionArray
|
|
Raises
|
------
|
IndexError
|
When the indices are out of bounds for the array.
|
ValueError
|
When `indices` contains negative values other than ``-1``
|
and `allow_fill` is True.
|
|
See Also
|
--------
|
numpy.take : Take elements from an array along an axis.
|
api.extensions.take : Take elements from an array.
|
|
Notes
|
-----
|
ExtensionArray.take is called by ``Series.__getitem__``, ``.loc``,
|
``iloc``, when `indices` is a sequence of values. Additionally,
|
it's called by :meth:`Series.reindex`, or any other method
|
that causes realignment, with a `fill_value`.
|
|
Examples
|
--------
|
Here's an example implementation, which relies on casting the
|
extension array to object dtype. This uses the helper method
|
:func:`pandas.api.extensions.take`.
|
|
.. code-block:: python
|
|
def take(self, indices, allow_fill=False, fill_value=None):
|
from pandas.core.algorithms import take
|
|
# If the ExtensionArray is backed by an ndarray, then
|
# just pass that here instead of coercing to object.
|
data = self.astype(object)
|
|
if allow_fill and fill_value is None:
|
fill_value = self.dtype.na_value
|
|
# fill value should always be translated from the scalar
|
# type for the array, to the physical storage type for
|
# the data, before passing to take.
|
|
result = take(data, indices, fill_value=fill_value,
|
allow_fill=allow_fill)
|
return self._from_sequence(result, dtype=self.dtype)
|
r )rf ÚindicesrÍ rè s rN rÖ zExtensionArray.take s ôz " $Ó'Ð'rQ c ó t | « )a=
|
Return a copy of the array.
|
|
Returns
|
-------
|
ExtensionArray
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr2 = arr.copy()
|
>>> arr[0] = 2
|
>>> arr2
|
<IntegerArray>
|
[1, 2, 3]
|
Length: 3, dtype: Int64
|
r rs s rN rJ zExtensionArray.copyk s ô$ " $Ó'Ð'rQ c ó& | t |« | dd S )aÚ
|
Return a view on the array.
|
|
Parameters
|
----------
|
dtype : str, np.dtype, or ExtensionDtype, optional
|
Default None.
|
|
Returns
|
-------
|
ExtensionArray or np.ndarray
|
A view on the :class:`ExtensionArray`'s data.
|
|
Examples
|
--------
|
This gives view on the underlying data of an ``ExtensionArray`` and is not a
|
copy. Modifications on either the view or the original ``ExtensionArray``
|
will be reflectd on the underlying data:
|
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr2 = arr.view()
|
>>> arr[0] = 2
|
>>> arr2
|
<IntegerArray>
|
[2, 2, 3]
|
Length: 3, dtype: Int64
|
N)rm )rf rI s rN ÚviewzExtensionArray.view s ð@ Ð Ü% eÓ,Ð ,ØAwrQ c ó | j dkD r| j « S ddlm} || | j « d¬« j d« }dt | « j d}| j « }| | d | S )
|
Nr r ©Úformat_object_summaryF©Úindent_for_nameú,
|
ú<z>
|
ú
|
) r Ú_repr_2dÚpandas.io.formats.printingr Ú
|
_formatterÚrstriprn rÁ Ú_get_repr_footer)rf r ÚdataÚ
|
class_nameÚfooters rN Ú__repr__zExtensionArray.__repr__§ s Ø 99q=Ø==?Ð "åDñ
|
%Ø $//Ó#°Uô
|
ç
|
&.ð ð d×,Ñ,Ð-¨SÐ1
|
Ø×&Ñ&Ó(Ø dV 2 f XÐ.Ð.rQ c ó | j dkD r d| j d| j S dt | « d| j S )Nr zShape: z , dtype: zLength: )r r rI rw rs s rN r z ExtensionArray._get_repr_footer· sC à 99q=Ø TZZL¨ °$·*±*° Ð>Ð >Ø#d) I¨d¯j©j¨\Ð:Ð:rQ c ó
|
ddl m} | D cg c]* } ||| j « d¬« j d« , }}dj |« }dt | « j d}| j « }| d | d
|
| S c c}w ) Nr r Fr r z,
|
r ú>z
|
[
|
z
|
]
|
)r r r r Újoinrn rÁ r )rf r ÚxÚlinesr r r s rN r zExtensionArray._repr_2d½ s ÝDð ö
|
ð ñ " ! T§_¡_Ó%6ÈÔ N× UÑ UØõ ð
|
ð
|
ð zz%Ó Ød×,Ñ,Ð-¨QÐ/
|
Ø×&Ñ&Ó(Ø U 4 &¨¨f¨XÐ6Ð6ùò
|
s /B c ó |rt S t S )aÏ
|
Formatting function for scalar values.
|
|
This is used in the default '__repr__'. The returned formatting
|
function receives instances of your scalar type.
|
|
Parameters
|
----------
|
boxed : bool, default False
|
An indicated for whether or not your array is being printed
|
within a Series, DataFrame, or Index (True), or just by
|
itself (False). This may be useful if you want scalar values
|
to appear differently within a Series versus on its own (e.g.
|
quoted or not).
|
|
Returns
|
-------
|
Callable[[Any], str]
|
A callable that gets instances of the scalar type and
|
returns a string. By default, :func:`repr` is used
|
when ``boxed=False`` and :func:`str` is used when
|
``boxed=True``.
|
|
Examples
|
--------
|
>>> class MyExtensionArray(pd.arrays.NumpyExtensionArray):
|
... def _formatter(self, boxed=False):
|
... return lambda x: '*' + str(x) + '*' if boxed else repr(x) + '*'
|
>>> MyExtensionArray(np.array([1, 2, 3, 4]))
|
<MyExtensionArray>
|
[1*, 2*, 3*, 4*]
|
Length: 4, dtype: int64
|
)ÚstrÚrepr)rf Úboxeds rN r zExtensionArray._formatterÎ s ñD ÜJÜ rQ c ó | dd S )a
|
Return a transposed view on this array.
|
|
Because ExtensionArrays are always 1D, this is a no-op. It is included
|
for compatibility with np.ndarray.
|
|
Returns
|
-------
|
ExtensionArray
|
|
Examples
|
--------
|
>>> pd.array([1, 2, 3]).transpose()
|
<IntegerArray>
|
[1, 2, 3]
|
Length: 3, dtype: Int64
|
Nrd )rf Úaxess rN Ú transposezExtensionArray.transposeø s ð$ AwrQ c ó" | j « S rc )r+ rs s rN ÚTzExtensionArray.T s à~~Ó Ð rQ c ó | S )a
|
Return a flattened view on this array.
|
|
Parameters
|
----------
|
order : {None, 'C', 'F', 'A', 'K'}, default 'C'
|
|
Returns
|
-------
|
ExtensionArray
|
|
Notes
|
-----
|
- Because ExtensionArrays are 1D-only, this is a no-op.
|
- The "order" argument is ignored, is for compatibility with NumPy.
|
|
Examples
|
--------
|
>>> pd.array([1, 2, 3]).ravel()
|
<IntegerArray>
|
[1, 2, 3]
|
Length: 3, dtype: Int64
|
rd )rf Úorders rN ÚravelzExtensionArray.ravel s ð0 rQ c ó t | « )aÊ
|
Concatenate multiple array of this dtype.
|
|
Parameters
|
----------
|
to_concat : sequence of this type
|
|
Returns
|
-------
|
ExtensionArray
|
|
Examples
|
--------
|
>>> arr1 = pd.array([1, 2, 3])
|
>>> arr2 = pd.array([4, 5, 6])
|
>>> pd.arrays.IntegerArray._concat_same_type([arr1, arr2])
|
<IntegerArray>
|
[1, 2, 3, 4, 5, 6]
|
Length: 6, dtype: Int64
|
r )rL Ú to_concats rN ræ z ExtensionArray._concat_same_type* rP rQ c ó. | j j S rc )rI r{ rs s rN r{ zExtensionArray._can_hold_naL s àzz×&Ñ&Ð&rQ ©r¹ c ó8 t d| d| j « )as
|
Return an ExtensionArray performing an accumulation operation.
|
|
The underlying data type might change.
|
|
Parameters
|
----------
|
name : str
|
Name of the function, supported values are:
|
- cummin
|
- cummax
|
- cumsum
|
- cumprod
|
skipna : bool, default True
|
If True, skip NA values.
|
**kwargs
|
Additional keyword arguments passed to the accumulation function.
|
Currently, there is no supported kwarg.
|
|
Returns
|
-------
|
array
|
|
Raises
|
------
|
NotImplementedError : subclass does not define accumulations
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr._accumulate(name='cumsum')
|
<IntegerArray>
|
[1, 3, 6]
|
Length: 3, dtype: Int64
|
zcannot perform z with type )rm rI )rf Únamer¹ r¶ s rN Ú _accumulatezExtensionArray._accumulateP s! ôL " O°D°6¸ÀTÇZÁZÀLÐ"QÓRÐRrQ )r¹ Úkeepdimsc óÌ t | |d« }|2t dt | « j d| j d| d« |dd|i|¤}|rt j |g« }|S )a¹
|
Return a scalar result of performing the reduction operation.
|
|
Parameters
|
----------
|
name : str
|
Name of the function, supported values are:
|
{ any, all, min, max, sum, mean, median, prod,
|
std, var, sem, kurt, skew }.
|
skipna : bool, default True
|
If True, skip NaN values.
|
keepdims : bool, default False
|
If False, a scalar is returned.
|
If True, the result has dimension with size one along the reduced axis.
|
|
.. versionadded:: 2.1
|
|
This parameter is not required in the _reduce signature to keep backward
|
compatibility, but will become required in the future. If the parameter
|
is not found in the method signature, a FutureWarning will be emitted.
|
**kwargs
|
Additional keyword arguments passed to the reduction function.
|
Currently, `ddof` is the only supported kwarg.
|
|
Returns
|
-------
|
scalar
|
|
Raises
|
------
|
TypeError : subclass does not define reductions
|
|
Examples
|
--------
|
>>> pd.array([1, 2, 3])._reduce("min")
|
1
|
Nú'z ' with dtype z does not support reduction 'r¹ rd )ÚgetattrrV rn rÁ rI r r§ )rf r6 r¹ r8 r¶ r× r s rN Ú_reducezExtensionArray._reducex s ôP tT 4Ó(Ø <ÜØDJ×'Ñ'Ð(¨ °d·j±j°\ð B/Ø/3¨f°Að7óð ñ Ñ.VÐ. vÑ.Ù ÜXXvhÓ'Fà rQ zClassVar[None]Ú__hash__c ó, t j | « S )aY
|
Specify how to render our entries in to_json.
|
|
Notes
|
-----
|
The dtype on the returned ndarray is not restricted, but for non-native
|
types that are not specifically handled in objToJSON.c, to_json is
|
liable to raise. In these cases, it may be safer to return an ndarray
|
of strings.
|
)r r rs s rN Ú_values_for_jsonz ExtensionArray._values_for_jsonµ s ô zz$Ó Ð rQ c óL ddl m} | j « \ }} |||||¬« S )a
|
Hook for hash_pandas_object.
|
|
Default is to use the values returned by _values_for_factorize.
|
|
Parameters
|
----------
|
encoding : str
|
Encoding for data & key when strings.
|
hash_key : str
|
Hash_key for string key to encode.
|
categorize : bool
|
Whether to first categorize object arrays before hashing. This is more
|
efficient when the array contains duplicate values.
|
|
Returns
|
-------
|
np.ndarray[uint64]
|
|
Examples
|
--------
|
>>> pd.array([1, 2])._hash_pandas_object(encoding='utf-8',
|
... hash_key="1000000000000000",
|
... categorize=False
|
... )
|
array([ 6238072747940578789, 15839785061582574730], dtype=uint64)
|
r )Ú
|
hash_array)ÚencodingÚhash_keyÚ
|
categorize)Úpandas.core.util.hashingrA rü )rf rB rC rD rA r_ Ú_s rN Ú_hash_pandas_objectz"ExtensionArray._hash_pandas_object s/ õ< 8à×.Ñ.Ó0 ÙØ X°ÀZô
|
ð
|
rQ c ó | j « }t j t | « ft j ¬« }||fS )aÌ
|
Transform each element of list-like to a row.
|
|
For arrays that do not contain list-like elements the default
|
implementation of this method just returns a copy and an array
|
of ones (unchanged index).
|
|
Returns
|
-------
|
ExtensionArray
|
Array with the exploded values.
|
np.ndarray[uint64]
|
The original lengths of each list-like for determining the
|
resulting index.
|
|
See Also
|
--------
|
Series.explode : The method on the ``Series`` object that this
|
extension array method is meant to support.
|
|
Examples
|
--------
|
>>> import pyarrow as pa
|
>>> a = pd.array([[1, 2, 3], [4], [5, 6]],
|
... dtype=pd.ArrowDtype(pa.list_(pa.int64())))
|
>>> a._explode()
|
(<ArrowExtensionArray>
|
[1, 2, 3, 4, 5, 6]
|
Length: 6, dtype: int64[pyarrow], array([3, 1, 2], dtype=int32))
|
)r rI )rJ r Úonesrw Úuint64)rf r_ Úcountss rN Ú_explodezExtensionArray._explodeç s3 ð> ܤ D£ |´2·9±9Ô=Øv~Ð rQ c ó| | j dkD r | D cg c] }|j « c}S t | « S c c}w )as
|
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
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr.tolist()
|
[1, 2, 3]
|
r )r ÚtolistÚlist)rf r# s rN rN zExtensionArray.tolist
|
s5 ð$ 99q=Ø(,Ö- 1AHHJÒ-Ð -ÜDzÐùò .s 9c ó t j t j t | « « |« }| j |« S rc )r Údeleter rw rÖ )rf ÚlocrÙ s rN rQ zExtensionArray.delete s. Ü))BII¤c¨$£iÓ 0°#Ó6ØyyÓ!Ð!rQ c óÀ t |t | « « }t | « j |g| j ¬« }t | « j | d| || |d g« S )a²
|
Insert an item at the given position.
|
|
Parameters
|
----------
|
loc : int
|
item : scalar-like
|
|
Returns
|
-------
|
same type as self
|
|
Notes
|
-----
|
This method should be both type and dtype-preserving. If the item
|
cannot be held in an array of this type/dtype, either ValueError or
|
TypeError should be raised.
|
|
The default implementation relies on _from_sequence to raise on invalid
|
items.
|
|
Examples
|
--------
|
>>> arr = pd.array([1, 2, 3])
|
>>> arr.insert(2, -1)
|
<IntegerArray>
|
[1, 2, -1, 3]
|
Length: 4, dtype: Int64
|
r N)r rw rn rO rI ræ )rf rR rg Úitem_arrs rN ÚinsertzExtensionArray.insert$ s[ ô< " #¤s¨4£yÓ1ä:×,Ñ,¨d¨V¸4¿:¹:Ð,ÓFäDz×+Ñ+¨T°$°3¨Z¸À4ÈÈÀ:Ð,NÓOÐOrQ c ó4 t |« r|| }n|}|| |< y)aé
|
Analogue to np.putmask(self, mask, value)
|
|
Parameters
|
----------
|
mask : np.ndarray[bool]
|
value : scalar or listlike
|
If listlike, must be arraylike with same length as self.
|
|
Returns
|
-------
|
None
|
|
Notes
|
-----
|
Unlike np.putmask, we do not repeat listlike values with mismatched length.
|
'value' should either be a scalar or an arraylike with the same length
|
as self.
|
N)r )rf r³ rp Úvals rN Ú_putmaskzExtensionArray._putmaskH s# ô( Ô Ø+CàCàT
|
rQ c óZ | j « }t |« r|| }n|}||| < |S )zÞ
|
Analogue to np.where(mask, self, value)
|
|
Parameters
|
----------
|
mask : np.ndarray[bool]
|
value : scalar or listlike
|
|
Returns
|
-------
|
same type as self
|
)rJ r )rf r³ rp r rW s rN Ú_wherezExtensionArray._wherec s7 ð ä Ô Ø,CàCàu Ø rQ c óÔ t j |« }| j t « } ||||j « ¬« | j || j ¬« }|| | |< y)z
|
Replace values in locations specified by 'mask' using pad or backfill.
|
|
See also
|
--------
|
ExtensionArray.fillna
|
)rÅ r³ r N)r# Ú get_fill_funcr rî rJ rO rI )rf r rÅ r³ ÚfuncÚnpvaluesrÚ s rN Ú_fill_mask_inplacez!ExtensionArray._fill_mask_inplace{ s] ô ×$Ñ$ VÓ,Ø;;vÓ&ñ XU¨¯©«Õ5Ø×(Ñ(¨¸¿¹Ð(ÓD
|
Ø Ñ%T
|
rQ r Úaverage©rà rÂ Ú na_optionr¯ Úpctc óV |dk7 rt t | j « |||||¬« S )z*
|
See Series.rank.__doc__.
|
r ra )rm r* r¬ )rf rà r rb r¯ rc s rN Ú_rankzExtensionArray._rank s9 ð 19Ü%Ð %äØ × $Ñ $Ó &ØØØ Ø Øô
|
ð
|
rQ c óø | j g |¬« }t j t j d« |« }|j |d¬« }t || « r||j k7 rt d| d« |S )zÙ
|
Create an ExtensionArray with the given shape and dtype.
|
|
See also
|
--------
|
ExtensionDtype.empty
|
ExtensionDtype.empty is the 'official' public version of this API.
|
r rÎ TrÌ z5Default 'empty' implementation is invalid for dtype='r: )rO r Ú broadcast_toÚintprÖ r} rI rm )rL r rI ÚobjÚtakerr s rN Ú_emptyzExtensionArray._empty¥ sx ð × Ñ ¨5Ð Ó1䤧¡¨£ ¨UÓ3Ø%¨DÓ1Ü& #Ô&¨%°6·<±<Ò*?Ü%ØGÈÀwÈaÐPóð ð rQ c óä t j | j « « }t j | « }t j }t |||||« }t | « j |« S )zè
|
Compute the quantiles of self for each quantile in `qs`.
|
|
Parameters
|
----------
|
qs : np.ndarray[float64]
|
interpolation: str
|
|
Returns
|
-------
|
same type as self
|
)r r r! rû r, rn rO )rf ÚqsÚ interpolationr³ rô rè Ú
|
res_valuess rN Ú _quantilezExtensionArray._quantile¼ sV ô zz$))+Ó&ÜjjÓ ÜVV
|
ä'¨¨T°:¸rÀ=ÓQ
|
ÜDz×(Ñ(¨Ó4Ð4rQ c ó t | |¬« S )aT
|
Returns the mode(s) of the ExtensionArray.
|
|
Always returns `ExtensionArray` even if only one value.
|
|
Parameters
|
----------
|
dropna : bool, default True
|
Don't consider counts of NA values.
|
|
Returns
|
-------
|
same type as self
|
Sorted, if possible.
|
)rß )r) )rf rß s rN Ú_modezExtensionArray._modeÐ s ô$ D Ô(Ð(rQ c óD t d |D « « rt S t j | ||g|¢i |¤}|t ur|S d|v rt j | ||g|¢i |¤S |dk( r%t j
|
| ||g|¢i |¤}|t ur|S t j | ||g|¢i |¤S )Nc 3 óR K | ] }t |t t t f« ! y wrc )r} r r r )Ú.0r s rN ú <genexpr>z1ExtensionArray.__array_ufunc__.<locals>.<genexpr>å s# è ø ò
|
ØGLJuy¬(´LÐ A× Bñ
|
ùs %'ÚoutÚreduce)r ÚNotImplementedr" Ú!maybe_dispatch_ufunc_to_dunder_opÚdispatch_ufunc_with_outÚdispatch_reduction_ufuncÚdefault_array_ufunc)rf Úufuncr Úinputsr¶ r s rN Ú__array_ufunc__z ExtensionArray.__array_ufunc__ä så Ü ñ
|
ØPVô
|
ô
|
ô "Ð !ä×<Ñ<Ø %ð
|
Ø"(ò
|
Ø,2ñ
|
ð Ñ 'ØMà F?Ü ×4Ñ4ØeVðØ&,òØ06ñð ð XÒ Ü ×7Ñ7ØeVðØ&,òØ06ñFð ^Ñ+Ø ä×,Ñ,¨T°5¸&ÐTÀ6ÒTÈVÑTÐTrQ c ó t | ||¬« S )a³
|
Map values using an input mapping or function.
|
|
Parameters
|
----------
|
mapper : function, dict, or Series
|
Mapping correspondence.
|
na_action : {None, 'ignore'}, default None
|
If 'ignore', propagate NA values, without passing them to the
|
mapping correspondence. If 'ignore' is not supported, a
|
``NotImplementedError`` should be raised.
|
|
Returns
|
-------
|
Union[ndarray, Index, ExtensionArray]
|
The output of the mapping function applied to the array.
|
If the function returns a tuple with more than one element
|
a MultiIndex will be returned.
|
)Ú na_action)r( )rf Úmapperr s rN ÚmapzExtensionArray.mapþ s ô( v°Ô;Ð;rQ c ó: ddl m} ddlm} |j |« } ||| |¬« }
|
d} t | j |« rÆ|
|
j dv r t d| j d| d« |
|
j d vr?|
|
j |
|
j |
|
j t j t « d
|
« | } |
|
j d k( rd } |dk( r| j d « } | j t t j ¬ « } nt! d| j « |
|
j" | f|||d| d|¤}|
|
j |
|
j$ v r|S t | j |« r/| j }|j' « }|j) ||¬« S t )aã
|
Dispatch GroupBy reduction or transformation operation.
|
|
This is an *experimental* API to allow ExtensionArray authors to implement
|
reductions and transformations. The API is subject to change.
|
|
Parameters
|
----------
|
how : {'any', 'all', 'sum', 'prod', 'min', 'max', 'mean', 'median',
|
'median', 'var', 'std', 'sem', 'nth', 'last', 'ohlc',
|
'cumprod', 'cumsum', 'cummin', 'cummax', 'rank'}
|
has_dropped_na : bool
|
min_count : int
|
ngroups : int
|
ids : np.ndarray[np.intp]
|
ids[i] gives the integer label for the group that self[i] belongs to.
|
**kwargs : operation-specific
|
'any', 'all' -> ['skipna']
|
'var', 'std', 'sem' -> ['ddof']
|
'cumprod', 'cumsum', 'cummin', 'cummax' -> ['skipna']
|
'rank' -> ['ties_method', 'ascending', 'na_option', 'pct']
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray
|
r )Ú StringDtype)ÚWrappedCythonOp)Úhowr° Úhas_dropped_na) r ÚmeanÚmedianÚcumsumÚcumprodÚstdÚsemÚvarÚskewzdtype 'z ' does not support operation 'r: )r rÓ FÚsumÚ )r| z,function is not implemented for this dtype: N)Ú min_countÚngroupsÚcomp_idsr³ Úinitialr )Úpandas.core.arrays.string_r Úpandas.core.groupby.opsr Úget_kind_from_howr} rI r rV Ú_get_cython_functionr° r rî rÏ r rû rm Ú_cython_op_ndim_compatÚcast_blocklistr¤ rO )rf r r r r Úidsr¶ r r r° Úopr rô r^ ro rI Ústring_array_clss rN Ú _groupby_opzExtensionArray._groupby_op s õH ;Ý;à ×0Ñ0°Ó5Ù ¨4ÀÔ Oàä djj +Ô .àvvð
|
ñ
|
ô Ø djj\Ð)GÈÀuÈAÐNóð ð vv^Ñ+à×'Ñ'¨¯©°·±¼¿¹Ä&Ó9IÈ5ÔQàCØvvØ ð >Ø ** R.CØ||¤F´R·V±V|Ó<Hä%Ø>¸t¿z¹z¸lÐKóð ð /R×.Ñ.Ø ð
|
à ØØØØñ
|
ð ñ
|
|
ð 66R×&Ñ&Ñ &ð Ð ä djj +Ô .ØJJEØ $× 9Ñ 9Ó ;Ð Ø#×2Ñ2°:ÀUÐ2ÓKÐ Kô &Ð %rQ )rI ú Dtype | NonerJ rª )rI r6 Úreturnr= )rg r< r£ r )rg r> r£ r= )rg r; r£ z
|
Self | Any©r£ ÚNone)r£ Úint)r£ z Iterator[Any])rg rî r£ zbool | np.bool_)r rî r£ r2 )rI znpt.DTypeLike | NonerJ rª r| rî r£ ú
|
np.ndarray)r£ r )r£ r? ).)rI z npt.DTypeLikerJ rª r£ r§ )rI r rJ rª r£ rF )rI r3 rJ rª r£ r2 )T)r£ z)np.ndarray | ExtensionArraySupportsAnyAll)r£ rª )r£ r§ )r¯ rª r° r@ r± r& r£ r§ )r¹ rª r£ r¦ )
|
r r8 rà r¦ rÄ rC rJ rª r£ r= )
|
r r7 rÅ ú
|
int | NonerÇ z#Literal['inside', 'outside'] | NonerJ rª r£ r= )NNNT)
|
rp zobject | ArrayLike | Noner zFillnaOptions | NonerÅ r¨ rJ rª r£ r= )r£ r= )Úfirst)rà z Literal['first', 'last', False]r£ únpt.NDArray[np.bool_])r N)rç r¦ rè rî r£ rF )ÚleftN)rp z$NumpyValueArrayLike | ExtensionArrayrñ zLiteral['left', 'right']rò zNumpySorter | Noner£ z npt.NDArray[np.intp] | np.intp)r rî r£ rª )r_ r2 r£ rª )r£ ztuple[np.ndarray, Any])rþ rª r£ z!tuple[np.ndarray, ExtensionArray]rc )r zint | Sequence[int]rà zAxisInt | Noner£ r= )r
|
rA rÍ rª rè r r£ r= )rI r¢ r£ r2 )r£ r& )F)r( rª r£ zCallable[[Any], str | None])r* r¦ r£ rF )r£ rF )ÚC)r/ z"Literal['C', 'F', 'A', 'K'] | Noner£ rF )r2 zSequence[Self]r£ r= )r6 r& r¹ rª r£ rF )r6 r& r¹ rª r8 rª )rB r& rC r& rD rª r£ znpt.NDArray[np.uint64])r£ z#tuple[Self, npt.NDArray[np.uint64]])r£ rO )rR r; r£ r= )rR r¦ r£ r= )r³ rª r£ r¥ )r³ rª r£ r= )r r& rÅ r¨ r³ rª r£ r¥ )
|
rà r4 r r& rb r& r¯ rª rc rª )r r? rI r )rm znpt.NDArray[np.float64]rn r& r£ r= )rß rª r£ r= )r~ znp.ufuncr r& ) r r& r rª r r¦ r r¦ r znpt.NDArray[np.intp]r£ r2 )SrÁ Ú
|
__module__Ú __qualname__Ú__doc__Ú_typÚ__pandas_priority__Ú classmethodrO rZ r] ra r
|
rh rq rt ry r r r r r r ÚpropertyrI r r r r r r! r~ r¬ r· rº r¿ rÈ rÐ rÏ rß r% rì r+ ró rø r' rü r rD r r r rÖ rJ r r r r r r+ r- r0 ræ r r{ r7 r< Ú__annotations__r? rG rL rN rQ rU rX rZ r_ re rk rp rr r r r¡ rd rQ rN rF rF n sÐ
ñNðd Dð Ðð Ø>BÐQVô 'ó ð'ð8 ò ó ð ð> à/3À%ñ 'Ø ,ð 'Ø;?ò 'ó ð 'ð< ñ'ó ð'ð> ò ó ð ð ò ó ð ó (óB+SóZ(óó(ó(
|
(ó ð '+ØØ >>ð "à#ð"ð ð"ð ð "ð
|
|
ó "ðP ò (ó ð (ð ò
|
ó ð
|
ð ò#ó ð#ð ò
|
ó ð
|
ð ò (ó ð (ð" ó ó ð ð ó ó ð ð ó ó ð ôE:óN(ð8 ò'ó ð'ó! ðL Ø$Ø!ñ 6
|
ð ð6
|
ð ð 6
|
ð
|
ð 6
|
ð
|
ó6
|
ôp *ôD *ðD"
|
ð #ð"
|
ð ð "
|
ð
|
ð "
|
ð ð"
|
ð
|
ó"
|
ðP !Ø:>Øñ ]ð ð]ð ð ]ð
|
8ð ]ð ð ]ð
|
ó]ðB ,0Ø'+Ø Øð `à(ð`ð %ð`ð ð `ð
|
ð `ð
|
ó `óD"ð$ 7>ð=Ø3ð=à ó=ô2:.óx>ð, *0Ø%)ð :Aà3ð:Að 'ð:Að #ð :Að
|
|
(ó :Aóx'9óR.ó0+ð> !%ð?!à ð?!ð
|
+ó?!ðF( ð !ØññX Ð(Ô)Ù Ð*¨8Ñ4Ó5ó ó 6ó *ð ð !Ø ñ ](à ð](ð ð ](ð
|
ð ](ð
|
ó ](ó~(ô("óP/ó ;ó 7ô"$óTð( ò ó ð ôð4 ò'ó ð'ðB ò'ó ð'ð ,0ñ&SØð&SØ$(ð&Sà ó&SðR ,0À%ñ2Øð2Ø$(ð2Ø;?ó2ðn Ó ó ð#
|
Ø ð#
|
Ø*-ð#
|
Ø;?ð#
|
à ó#
|
óJ! óFó,"ó"PóHó6ð0&Øð&Ø",ð&Ø4Ið&à ó&ð* Ø Ø Ø Øñ
|
ð ð
|
ð ð
|
ð
|
ð
|
ð ð
|
ð ó
|
ð0 òó ðó,5ô()ó(Uó4<ð2b&ð ðb&ð ð b&ð
|
ð b&ð ð b&ð "ðb&ð
|
ôb&rQ rF c ó( e Zd ZddddZddddZy)Ú ExtensionArraySupportsAnyAllTr4 c ó t | « rc r r¼ s rN r z ExtensionArraySupportsAnyAll.any} ó Ü! $Ó'Ð'rQ c ó t | « rc r r¼ s rN rÓ z ExtensionArraySupportsAnyAll.all r¸ rQ N)r¹ rª r£ rª )rÁ r r® r rÓ rd rQ rN r¶ r¶ | s Ø$(õ (ð %)ö (rQ r¶ c óv e Zd ZdZed « Zed d« Zed « Zed d« Zed « Z ed d« Z
|
y)
|
ÚExtensionOpsMixinzú
|
A base class for linking the operators to their dunder names.
|
|
.. note::
|
|
You may want to set ``__array_priority__`` if you want your
|
implementation to be called when involved in binary operations
|
with NumPy arrays.
|
c ó t | « rc r ©rL r s rN Ú_create_arithmetic_methodz+ExtensionOpsMixin._create_arithmetic_method ó ä! #Ó&Ð&rQ c ó0 t | d| j t j « « t | d| j t j
|
« « t | d| j t j « « t | d| j t j « « t | d| j t j « « t | d| j t j « « t | d| j t j « « t | d| j t j « « t | d | j t j « « t | d
|
| j t j « « t | d | j t j « « t | d | j t j « « t | d | j t j « « t | d| j t j" « « t | d| j t$ « « t | d| j t j& « « y )NÚ__add__Ú__radd__Ú__sub__Ú__rsub__Ú__mul__Ú__rmul__Ú__pow__Ú__rpow__Ú__mod__Ú__rmod__Ú __floordiv__Ú __rfloordiv__Ú __truediv__Ú __rtruediv__Ú
|
__divmod__Ú __rdivmod__)Úsetattrr¾ ÚoperatorÚaddr$ ÚraddÚsubÚrsubÚmulÚrmulÚpowÚrpowÚmodÚrmodÚfloordivÚ rfloordivÚtruedivÚrtruedivÚdivmodÚrdivmod©rL s rN Ú_add_arithmetic_opsz%ExtensionOpsMixin._add_arithmetic_ops s½ äY × =Ñ =¼h¿l¹lÓ KÔLÜZ ×!>Ñ!>¼y¿~¹~Ó!NÔOÜY × =Ñ =¼h¿l¹lÓ KÔLÜZ ×!>Ñ!>¼y¿~¹~Ó!NÔOÜY × =Ñ =¼h¿l¹lÓ KÔLÜZ ×!>Ñ!>¼y¿~¹~Ó!NÔOÜY × =Ñ =¼h¿l¹lÓ KÔLÜZ ×!>Ñ!>¼y¿~¹~Ó!NÔOÜY × =Ñ =¼h¿l¹lÓ KÔLÜZ ×!>Ñ!>¼y¿~¹~Ó!NÔOÜ^ S×%BÑ%BÄ8×CTÑCTÓ%UÔVÜØ #×"?Ñ"?Ä ×@SÑ@SÓ"Tô
|
ô ] C×$AÑ$AÄ(×BRÑBRÓ$SÔTÜ^ S×%BÑ%BÄ9×CUÑCUÓ%VÔWÜ\ 3×#@Ñ#@ÄÓ#HÔIÜ] C×$AÑ$AÄ)×BSÑBSÓ$TÕUrQ c ó t | « rc r r½ s rN Ú_create_comparison_methodz+ExtensionOpsMixin._create_comparison_method¨ r¿ rQ c óü t | d| j t j « « t | d| j t j « « t | d| j t j
|
« « t | d| j t j « « t | d| j t j « « t | d| j t j « « y )Nr r Ú__lt__Ú__gt__Ú__le__Ú__ge__) rÑ ræ rÒ ÚeqÚneÚltÚgtÚleÚgerã s rN Ú_add_comparison_opsz%ExtensionOpsMixin._add_comparison_ops¬ s¤ äXs× <Ñ <¼X¿[¹[Ó IÔJÜXs× <Ñ <¼X¿[¹[Ó IÔJÜXs× <Ñ <¼X¿[¹[Ó IÔJÜXs× <Ñ <¼X¿[¹[Ó IÔJÜXs× <Ñ <¼X¿[¹[Ó IÔJÜXs× <Ñ <¼X¿[¹[Ó IÕJrQ c ó t | « rc r r½ s rN Ú_create_logical_methodz(ExtensionOpsMixin._create_logical_methodµ r¿ rQ c óü t | d| j t j « « t | d| j t j
|
« « t | d| j t j « « t | d| j t j « « t | d| j t j « « t | d| j t j « « y )NÚ__and__Ú__rand__Ú__or__Ú__ror__Ú__xor__Ú__rxor__)
|
rÑ rô rÒ Úand_r$ Úrand_Úor_Úror_ÚxorÚrxorrã s rN Ú_add_logical_opsz"ExtensionOpsMixin._add_logical_ops¹ s¤ äY × :Ñ :¼8¿=¹=Ó IÔJÜZ ×!;Ñ!;¼I¿O¹OÓ!LÔMÜXs× 9Ñ 9¼(¿,¹,Ó GÔHÜY × :Ñ :¼9¿>¹>Ó JÔKÜY × :Ñ :¼8¿<¹<Ó HÔIÜZ ×!;Ñ!;¼I¿N¹NÓ!KÕLrQ Nr¤ ) rÁ r r® r¯ r² r¾ rä ræ rò rô r rd rQ rN r» r» s
ñð ñ'ó ð'ð òVó ðVð( ñ'ó ð'ð òKó ðKð ñ'ó ð'ð òMó ñMrQ r» c óD e Zd ZdZeddd« Zed « Zed « Zy)ÚExtensionScalarOpsMixinaÐ
|
A mixin for defining ops on an ExtensionArray.
|
|
It is assumed that the underlying scalar objects have the operators
|
already defined.
|
|
Notes
|
-----
|
If you have defined a subclass MyExtensionArray(ExtensionArray), then
|
use MyExtensionArray(ExtensionArray, ExtensionScalarOpsMixin) to
|
get the arithmetic operators. After the definition of MyExtensionArray,
|
insert the lines
|
|
MyExtensionArray._add_arithmetic_ops()
|
MyExtensionArray._add_comparison_ops()
|
|
to link the operators to your class.
|
|
.. note::
|
|
You may want to set ``__array_priority__`` if you want your
|
implementation to be called when involved in binary operations
|
with NumPy arrays.
|
Nc óP fd}dj d}t ||| « S )a
|
A class method that returns a method that will correspond to an
|
operator for an ExtensionArray subclass, by dispatching to the
|
relevant operator defined on the individual elements of the
|
ExtensionArray.
|
|
Parameters
|
----------
|
op : function
|
An operator that takes arguments op(a, b)
|
coerce_to_dtype : bool, default True
|
boolean indicating whether to attempt to convert
|
the result to the underlying ExtensionArray dtype.
|
If it's not possible to create a new ExtensionArray with the
|
values, an ndarray is returned instead.
|
|
Returns
|
-------
|
Callable[[Any, Any], Union[ndarray, ExtensionArray]]
|
A method that can be bound to a class. When used, the method
|
receives the two arguments, one of which is the instance of
|
this class, and should return an ExtensionArray or an ndarray.
|
|
Returning an ndarray may be necessary when the result of the
|
`op` cannot be stored in the ExtensionArray. The dtype of the
|
ndarray uses NumPy's normal inference rules.
|
|
Examples
|
--------
|
Given an ExtensionArray subclass called MyExtensionArray, use
|
|
__add__ = cls._create_method(operator.add)
|
|
in the class definition of MyExtensionArray to create the operator
|
for addition, that will be based on the operator implementation
|
of the underlying elements of the ExtensionArray
|
c ó, fd}t |t t t f« rt S } ||« }t ||« D cg c] \ }}
|
||« }}} fd}
|
j dv rt | \ }} ||« ||« fS ||« S c c}}w )Nc ód t | t « s t | « r| }|S | gt « z }|S rc )r} rF r rw )ÚparamÚovaluesrf s rN Úconvert_valueszNExtensionScalarOpsMixin._create_method.<locals>._binop.<locals>.convert_values
|
s7 ø Ü e¤^Ô4¼ ÀUÔ8KØ #Gð ð %g¬¨D« Ñ 1GØ rQ c ó rDt | j d¬« }t |t « « st j
|
| « }|S t j
|
| ¬« }|S )NF)Ú
|
same_dtyper )r rI r} rn r r )rô ÚresÚcoerce_to_dtypeÚ result_dtyperf s rN Ú_maybe_convertzNExtensionScalarOpsMixin._create_method.<locals>._binop.<locals>._maybe_convert
|
sT ø Ù"ô 6°c¸4¿:¹:ÐRWÔXCÜ% c¬4°«:Ô6ä jj¨oð
|
ô ** S° Ô=CØ
|
rQ > rá râ )r} r r r ry ÚziprÁ ) rf r r
|
ÚlvaluesÚrvaluesrê rë r r r r r s ` rN Ú_binopz6ExtensionScalarOpsMixin._create_method.<locals>._binop
|
s ù ô ô %¤)¬X´|Ð!DÔEä%Ð%àGÙ$ UÓ+Gô +.¨g°wÓ*?×@¡ A2a8Ð@CÑ@ö ð {{Ð 3Ñ3ÜCy1Ù% aÓ(©.¸Ó*;Ð;Ð;á! #Ó&Ð &ùó' As ÁBÚ__)rÁ r )rL r r r r Úop_names ``` rN Ú_create_methodz&ExtensionScalarOpsMixin._create_methodÝ s- ú öP$ 'ðL r{{m 2Ð&Ü ¨°#Ó6Ð6rQ c ó$ | j |« S rc )r r½ s rN r¾ z1ExtensionScalarOpsMixin._create_arithmetic_method.
|
s à×!Ñ! "Ó%Ð%rQ c ó2 | j |dt ¬« S )NF)r r )r rª r½ s rN ræ z1ExtensionScalarOpsMixin._create_comparison_method2
|
s à×!Ñ! "°eÌ$Ð!ÓOÐOrQ )TN)r rª )rÁ r r® r¯ r² r r¾ ræ rd rQ rN r r à sH ñð2 óN7ó ðN7ð` ñ&ó ð&ð ñPó ñPrQ r )br¯ Ú
|
__future__r rÒ Útypingr r r r r r r
|
rX Únumpyr Ú pandas._libsr rÔ r Ú pandas.compatr Úpandas.compat.numpyr r´ Ú pandas.errorsr Úpandas.util._decoratorsr r r Úpandas.util._exceptionsr Úpandas.util._validatorsr r r Úpandas.core.dtypes.castr Úpandas.core.dtypes.commonr r r Úpandas.core.dtypes.dtypesr Úpandas.core.dtypes.genericr r r Úpandas.core.dtypes.missingr! Ú pandas.corer" r# r$ Úpandas.core.algorithmsr% r& r' r( r) r* r+ Ú pandas.core.array_algos.quantiler, Úpandas.core.missingr- Úpandas.core.sortingr. r/ Úcollections.abcr0 r1 Úpandas._typingr2 r3 r4 r5 r6 r7 r8 r9 r: r; r< r= r> r? r@ rA rB ÚpandasrC rD r´ rF r¶ r» r rd rQ rN ú<module>r1 s ðòõ #ã ÷÷ ñ ó ã ÷õ ,Ý .Ý -÷ñ õ
|
5÷ñ õ @÷ñ õ
|
5÷ñ õ
|
,÷ñ ÷
|
÷ ñ õ @Ý 3÷ñ
|
÷÷
|
÷ ÷ ÷ õ õ( à/1Ð nÓ 1÷K$&ñ K$&ô\H( >ô (÷<Mñ <Mô~qPÐ /õ qPrQ
|
