U
|
¬ý°dËú ã @ sô U d Z ddlmZ ddlZddlmZmZmZmZm Z m
|
Z
|
m Z m Z m Z mZ ddlZddlmZ ddlmZmZmZmZmZmZmZmZm Z m Z m Z m Z ddl m!Z! ddl"m#Z$ dd l%m&Z& dd
|
l'm(Z(m)Z)m*Z* dd l+m,Z,m-Z-m.Z. dd l/m0Z0 dd l1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7 ddl8m9Z9 ddl:m;Z;m<Z<m=Z= ddl>m?Z? ddl@mAZAmBZBmCZC ddlDmEZEmFZFmGZGmHZHmIZI ddlJmKZK ddlLmMZMmNZN erddlmOZOmPZP i ZQdeRd< e dddZSG dd dZTG d d d eTZUG d d d ZVG d d! d!eVZWdS )"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ÚIteratorÚLiteralÚSequenceÚTypeVarÚcastÚoverload)Úlib) Ú ArrayLikeÚ AstypeArgÚAxisIntÚDtypeÚ FillnaOptionsÚPositionalIndexerÚ ScalarIndexerÚSequenceIndexerÚShapeÚSortKindÚ TakeIndexerÚnpt)Úset_function_name)Úfunction©ÚAbstractMethodError)ÚAppenderÚ SubstitutionÚcache_readonly)Úvalidate_bool_kwargÚvalidate_fillna_kwargsÚvalidate_insert_loc)Ú maybe_cast_to_extension_array)Úis_datetime64_dtypeÚis_dtype_equalÚ is_list_likeÚ is_scalarÚis_timedelta64_dtypeÚ pandas_dtype)ÚExtensionDtype)Ú ABCDataFrameÚABCIndexÚ ABCSeries©Úisna)Ú arraylikeÚmissingÚ roperator)Úfactorize_arrayÚisinÚmodeÚrankÚunique)Úquantile_with_mask)Ú
|
nargminmaxÚnargsort)Ú NumpySorterÚNumpyValueArrayLikezdict[str, str]Ú _extension_array_shared_docsÚExtensionArrayTÚExtensionArray)Úboundc @ sÞ e Zd ZU dZdZedddddddd Zeddddddd
|
d Zed d Ze dddddZ
|
e ddddddZ
|
ddddddZ
|
ddd d Z d dd d Z d!dd"d#Z d$d%dd&d'Zdd(d)d*d+Zdd(d)d,d-Zddejfd.dd$d/d0d1d2Zed3dd4d5Zed6dd7d8Zed dd9d:Zed dd;d<Zed dd=d>Ze dÚd@dd/dAdBdCZe dÛd3dd dAdDdCZe dÜdEdd(dAdFdCZdÝdEdd(dAdHdCZdIddJdKZedddLdMZ d/ddNdOZ dGdPdQdRddSdTd/dUdVdWZ dÞdd dXdYdZZ dßdd dXd[d\Z dàdd]d^d_dd`dadbZ!dddcdddeZ"dád d$d dgdhdiZ#dddcdjdkZ$dâdmdndodpdqdrdsZ%d$dd)dtduZ&dvddwdxZ'dyddzd{Z(dãdd|d}d~dZ)de*d< e+d de,e*d däddddd
ddZ-dddddddddddZ.dddcddZ/dådd(dddZ0dTdddZ1dTdddZ2dædddddZ3d d dddZ4ed dddZ5dçd d d¡d¢d£Z6ed¤d¥dd¦d§d¨Z7e8ddd©dªZ9dGd«dTdd d¬dd®Z:dGd«dTdd¯d°d±Z;d²e<d³< d´ddµd¶Z=dddd·d¸d¹Z>dd dd·dºd»Z?dvdd¼d½d¾Z@ddvdd¿dÀdÁZAdTdvddÂdÃdÄZBdÅdÆdÇdGddÈdÉdTdTdddÈdÊdËZCed6d3dÌdÍdÎZDddÏdTddÐdÑdÒZEdèddddÓdÔdÕZFdÖdTd×dØdÙZGdS )ér@ aX
|
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
|
factorize
|
fillna
|
equals
|
insert
|
isin
|
isna
|
ravel
|
repeat
|
searchsorted
|
shift
|
take
|
tolist
|
unique
|
view
|
_accumulate
|
_concat_same_type
|
_formatter
|
_from_factorized
|
_from_sequence
|
_from_sequence_of_strings
|
_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
|
|
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
|
* dropna
|
* unique
|
* factorize / _values_for_factorize
|
* argsort, argmax, argmin / _values_for_argsort
|
* searchsorted
|
|
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.
|
Ú extensionNF©ÚdtypeÚcopyz Dtype | NoneÚboolc C s t | dS )aN
|
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
|
Nr )ÚclsZscalarsrD rE © rH úNd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/arrays/base.pyÚ_from_sequenceñ s z ExtensionArray._from_sequencec C s t | dS )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
|
Nr )rG ÚstringsrD rE rH rH rI Ú_from_sequence_of_strings s z(ExtensionArray._from_sequence_of_stringsc C s t | dS )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.
|
Nr )rG ÚvaluesÚoriginalrH rH rI Ú_from_factorized s z ExtensionArray._from_factorizedr r )ÚitemÚreturnc C s d S ©NrH ©ÚselfrP rH rH rI Ú __getitem__5 s zExtensionArray.__getitem__r? r )rT rP rQ c C s d S rR rH rS rH rH rI rU 9 s r zExtensionArrayT | Anyc C s t | dS )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.
|
Nr rS rH rH rI rU = s !ÚNone©rQ c C s t t| ddS )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__.N)ÚNotImplementedErrorÚtype)rT ÚkeyÚvaluerH rH rI Ú __setitem__` s +zExtensionArray.__setitem__Úintc C s t | dS )z\
|
Length of this array
|
|
Returns
|
-------
|
length : int
|
Nr ©rT rH rH rI Ú__len__ s zExtensionArray.__len__z Iterator[Any]c c s t t| D ]}| | V q dS )z5
|
Iterate over elements of the array.
|
N)ÚrangeÚlen)rT ÚirH rH rI Ú__iter__ s zExtensionArray.__iter__Úobjectzbool | np.bool_c C sP t |r@t|r@| jsdS || jjks4t|| jjr:| jS dS n || k ¡ S dS )z,
|
Return for `item in self`.
|
FN) r( r0 Ú _can_hold_narD Úna_valueÚ
|
isinstancerY Ú_hasnaÚanyrS rH rH rI Ú __contains__¡ s zExtensionArray.__contains__r )ÚotherrQ c C s t | dS )zE
|
Return for `self == other` (element-wise equality).
|
Nr ©rT rk rH rH rI Ú__eq__µ s
|
zExtensionArray.__eq__c C s
|
| |k S )zH
|
Return for `self != other` (element-wise in-equality).
|
rH rl rH rH rI Ú__ne__Â s zExtensionArray.__ne__znpt.DTypeLike | Nonez
|
np.ndarray)rD rE rf rQ c C s> t j| |d}|s |tjk r$| ¡ }|tjk r:||| ¡ < |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
|
©rD )ÚnpÚasarrayr Ú
|
no_defaultrE r0 )rT rD rE rf ÚresultrH rH rI Úto_numpyÈ s
|
zExtensionArray.to_numpyr+ c C s t | dS )z2
|
An instance of 'ExtensionDtype'.
|
Nr r^ rH rH rI rD ð s zExtensionArray.dtyper c C s
|
t | fS )z9
|
Return a tuple of the array dimensions.
|
)ra r^ rH rH rI Úshape÷ s zExtensionArray.shapec C s t | j¡S )z6
|
The number of elements in the array.
|
)rp Úprodru r^ rH rH rI Úsizeþ s zExtensionArray.sizec C s dS )zH
|
Extension Arrays are only allowed to be 1-dimensional.
|
é rH r^ rH rH rI Úndim s zExtensionArray.ndimc C s t | dS )zL
|
The number of bytes needed to store this object in memory.
|
Nr r^ rH rH rI Únbytes s zExtensionArray.nbytes.z npt.DTypeLike)rD rE rQ c C s d S rR rH ©rT rD rE rH rH rI Úastype s zExtensionArray.astypec C s d S rR rH r{ rH rH rI r| s r c C s d S rR rH r{ rH rH rI r| # s Tc C s t |}t|| jr$|s | S | ¡ S t|trF| ¡ }|j| ||dS t|rjddl m
|
} |j| ||dS t |rddl m } |j| ||dS t j| ||dS )ae
|
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.
|
rC r )Ú DatetimeArray)ÚTimedeltaArray)r* r& rD rE rg r+ Zconstruct_array_typerJ r% Zpandas.core.arraysr} r) r~ rp Úarray)rT rD rE rG r} r~ rH rH rI r| ' s
|
z)np.ndarray | ExtensionArraySupportsAnyAllc C s t | dS )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
|
Nr r^ rH rH rI r0 R s zExtensionArray.isnac C s t | ¡ ¡ S )z
|
Equivalent to `self.isna().any()`.
|
|
Some ExtensionArray subclasses may be able to optimize this check.
|
)rF r0 ri r^ rH rH rI rh h s zExtensionArray._hasnac C s
|
t | ¡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 implementors 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.
|
)rp r r^ rH rH rI Ú_values_for_argsortr s z"ExtensionArray._values_for_argsortZ quicksortÚlast)Ú ascendingÚkindÚ na_positionr Ústr)r r r rQ c K s2 t |d|¡}| ¡ }t||||t | ¡ ¡dS )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.
|
*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.
|
rH )r r r Úmask)ÚnvZ validate_argsort_with_ascendingr r; rp rq r0 )rT r r r ÚkwargsrM rH rH rI Úargsort s $ ûzExtensionArray.argsort©ÚskipnarQ c C s" t |d |s| jrtt| dS )aq
|
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
|
r Úargmin©r! rh rX r: ©rT r rH rH rI r ¼ s
|
|
zExtensionArray.argminc C s" t |d |s| jrtt| dS )aq
|
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
|
r Úargmaxr r rH rH rI r Ø s
|
|
zExtensionArray.argmaxzobject | ArrayLike | NonezFillnaOptions | Nonez
|
int | None)rT r[ ÚmethodÚlimitrQ c C s t ||\}}| ¡ }t ||t| ¡}| ¡ r~|dk rlt |¡}| t¡}||||d | j || j
|
d}q| ¡ }|||< n| ¡ }|S )a
|
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.
|
|
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.
|
|
Returns
|
-------
|
ExtensionArray
|
With NA/NaN filled.
|
N©r r ro ) r" r0 r2 Zcheck_value_sizera ri Ú get_fill_funcr| rd rJ rD rE )rT r[ r r r ÚfuncÚnpvaluesÚ
|
new_valuesrH rH rI Úfillnaô s" " ÿ
|
|
|
zExtensionArray.fillna)rT rQ c C s | | ¡ S )z
|
Return ExtensionArray without NA values.
|
|
Returns
|
-------
|
pandas.api.extensions.ExtensionArray
|
r/ r^ rH rH rI Údropna- s zExtensionArray.dropnarx )ÚperiodsÚ
|
fill_valuerQ c C s t | r|dkr| ¡ S t|r(| jj}| j|gtt|t | | jd}|dkrh|}| d|
}n| t|d
}|}| ||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``.
|
r ro N) ra rE r0 rD rf rJ ÚminÚabsÚ_concat_same_type)rT r r ÚemptyÚaÚbrH rH rI Úshift8 s ! ÿzExtensionArray.shiftc C s t | t¡}| j|| jdS )z
|
Compute the ExtensionArray of unique values.
|
|
Returns
|
-------
|
pandas.api.extensions.ExtensionArray
|
ro )r8 r| rd rJ rD )rT ÚuniquesrH rH rI r8 j s zExtensionArray.uniqueÚleftz$NumpyValueArrayLike | ExtensionArrayzLiteral[('left', 'right')]r< z npt.NDArray[np.intp] | np.intp)r[ ÚsideÚsorterrQ c C s. | t¡}t|tr | t¡}|j|||dS )a·
|
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.
|
)r¤ r¥ )r| rd rg r@ Ú searchsorted)rT r[ r¤ r¥ ÚarrrH rH rI r¦ u s 1
|
|
|
zExtensionArray.searchsortedc C s t | t |krdS tt|}t| j|js0dS t| t|krDdS | |k}t|tr`| d¡}| ¡ | ¡ @ }t ||B
|
¡ S dS )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.
|
FN) rY r r@ r& rD ra rg r r0 rF Úall)rT rk Z equal_valuesZequal_narH rH rI Úequals« s
|
|
|
zExtensionArray.equalsznpt.NDArray[np.bool_]c C s t t | ¡|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 : Sequence
|
|
Returns
|
-------
|
np.ndarray[bool]
|
)r5 rp rq )rT rM rH rH rI r5 Í s zExtensionArray.isinztuple[np.ndarray, Any]c C s | t¡tjfS )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`.
|
)r| rd rp Únanr^ rH rH rI Ú_values_for_factorizeÝ s z$ExtensionArray._values_for_factorizez!tuple[np.ndarray, ExtensionArray])Úuse_na_sentinelrQ c C s2 | ¡ \}}t|||d\}}| || ¡}||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.
|
)r¬ rf )r« r4 rO )rT r¬ r§ rf Úcodesr¢ Z
|
uniques_earH rH rI Ú factorizeõ s . ÿ
|
zExtensionArray.factorizea;
|
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)Úklasszint | Sequence[int]zAxisInt | None)rT ÚrepeatsÚaxisrQ c C s. t dd|i¡ t t| ¡ |¡}| |¡S )NrH r² )r Zvalidate_repeatrp Úarangera r¯ Útake)rT r± r² ÚindrH rH rI r¯ X s zExtensionArray.repeat)Ú
|
allow_fillr r )rT Úindicesr¶ r rQ c C s t | dS )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)
|
Nr )rT r· r¶ r rH rH rI r´ e s ]zExtensionArray.takec C s t | dS )ze
|
Return a copy of the array.
|
|
Returns
|
-------
|
ExtensionArray
|
Nr r^ rH rH rI rE Ä s zExtensionArray.copy)rD rQ c C s |dk rt || 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.
|
N)rX )rT rD rH rH rI ÚviewÎ s zExtensionArray.viewc C sf | j dkr| ¡ S ddlm} || | ¡ dd d¡}dt| j d}| | d t| d
|
| j S ) Nrx r ©Úformat_object_summaryF©Zindent_for_nameú,
|
ú<z>
|
z
|
Length: ú , dtype: )
|
ry Ú_repr_2dÚpandas.io.formats.printingrº Ú
|
_formatterÚrstriprY Ú__name__ra rD )rT rº ÚdataÚ
|
class_namerH rH rI Ú__repr__è s
|
ÿþzExtensionArray.__repr__c sZ ddl m fddD }d |¡}dtj d}| d| d j d
|
j S ) Nr r¹ c s$ g | ] } | ¡ d d d¡qS )Fr» r¼ )rÁ r ©Ú.0Úx©rº rT rH rI Ú
|
<listcomp>ý s ýÿz+ExtensionArray._repr_2d.<locals>.<listcomp>z,
|
r½ ú>z
|
[
|
z
|
|
]
|
Shape: r¾ )rÀ rº ÚjoinrY rà ru rD )rT ÚlinesrÄ rÅ rH rÊ rI r¿ ÷ s ü
|
zExtensionArray._repr_2dzCallable[[Any], str | None])ÚboxedrQ c C s |rt S tS )aY
|
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``.
|
)r
Úrepr)rT rÏ rH rH rI rÁ s zExtensionArray._formatter)ÚaxesrQ c G s | dd
S )zµ
|
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.
|
NrH )rT rÑ rH rH rI Ú transpose' s zExtensionArray.transposec C s | ¡ S rR )rÒ r^ rH rH rI ÚT0 s zExtensionArray.TÚCz$Literal[('C', 'F', 'A', 'K')] | None)ÚorderrQ c C s | S )ax
|
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.
|
rH )rT rÕ rH rH rI Úravel4 s zExtensionArray.ravelztype[ExtensionArrayT]zSequence[ExtensionArrayT])rG Ú to_concatrQ c C s t | dS )zÄ
|
Concatenate multiple array of this dtype.
|
|
Parameters
|
----------
|
to_concat : sequence of this type
|
|
Returns
|
-------
|
ExtensionArray
|
Nr )rG r× rH rH rI r G s z ExtensionArray._concat_same_typec C s | j jS rR )rD re r^ rH rH rI re b s zExtensionArray._can_hold_na©r )Únamer rQ c K s t d| d| j dS )a¶
|
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
|
zcannot perform z with type N)rX rD )rT rÙ r r rH rH rI Ú _accumulatef s zExtensionArray._accumulate)rÙ r c K sJ t | |d}|dkr8tdt| j d| j d| d|f d|i|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.
|
**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
|
Nú'z ' with dtype z does not support reduction 'r )ÚgetattrÚ TypeErrorrY rà rD )rT rÙ r r ÚmethrH rH rI Ú_reduce s ÿzExtensionArray._reducezClassVar[None]Ú__hash__Úlistc C s | j dkrdd | D S t| S )zÿ
|
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
|
rx c S s g | ] }| ¡ qS rH )ÚtolistrÇ rH rH rI rË ¼ s z)ExtensionArray.tolist.<locals>.<listcomp>)ry rá r^ rH rH rI râ ¯ s
|
zExtensionArray.tolist)rT ÚlocrQ c C s t t t| ¡|¡}| |¡S rR )rp Údeleter³ ra r´ )rT rã ZindexerrH rH rI rä ¿ s zExtensionArray.deletec C sH t |t| }t| j|g| jd}t| | 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.
|
ro N)r# ra rY rJ rD r )rT rã rP Zitem_arrrH rH rI Úinsertà s zExtensionArray.insert)r rQ c C s" t |r|| }n|}|| |< dS )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' )rT r r[ ÚvalrH rH rI Ú_putmaskß s
|
zExtensionArray._putmask)rT r rQ c C s. | ¡ }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
|
)rE r' )rT r r[ rs ræ rH rH rI Ú_whereú s
|
zExtensionArray._where)r r rQ c C sF t |¡}| t¡}|||| ¡ d | j|| jd}|| | |< dS )z
|
Replace values in locations specified by 'mask' using pad or backfill.
|
|
See also
|
--------
|
ExtensionArray.fillna
|
r ro N)r2 r r| rd rE rJ rD )rT r r r r r r rH rH rI Ú_fill_mask_inplace s
|
|
|
|
z!ExtensionArray._fill_mask_inplacer ZaverageZkeep©r² r Ú na_optionr Úpctr c C s |dkr t t| |||||dS )z*
|
See Series.rank.__doc__.
|
r rê )rX r7 )rT r² r rë r rì rH rH rI Ú_rank% s úzExtensionArray._rank)ru rD c C sV | j g |d}t t d¡|¡}|j|dd}t|| rB||jkrRtd| 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.
|
ro éÿÿÿÿT)r¶ z5Default 'empty' implementation is invalid for dtype='rÛ )rJ rp Z broadcast_toZintpr´ rg rD rX )rG ru rD ÚobjZtakerrs rH rH rI Ú_empty= s
|
ÿzExtensionArray._emptyznpt.NDArray[np.float64])rT ÚqsÚ interpolationrQ c C s< t | ¡ ¡}t | ¡}t j}t|||||}t| |¡S )zè
|
Compute the quantiles of self for each quantile in `qs`.
|
|
Parameters
|
----------
|
qs : np.ndarray[float64]
|
interpolation: str
|
|
Returns
|
-------
|
same type as self
|
)rp rq r0 rª r9 rY rJ )rT rñ rò r r§ r Z
|
res_valuesrH rH rI Ú _quantileT s
|
|
zExtensionArray._quantile)rT r rQ c C s t | |dS )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 )r6 )rT r rH rH rI Ú_modej s zExtensionArray._modeznp.ufunc)Úufuncr c O s t dd |D rtS tj| ||f||}|tk r8|S d|krVtj| ||f||S |dkrtj| ||f||}|tk r|S tj| ||f||S )Nc s s | ]}t |tttfV qd S rR )rg r. r- r, )rÈ rk rH rH rI Ú <genexpr> s z1ExtensionArray.__array_ufunc__.<locals>.<genexpr>ÚoutÚreduce)ri ÚNotImplementedr1 Z!maybe_dispatch_ufunc_to_dunder_opZdispatch_ufunc_with_outZdispatch_reduction_ufuncZdefault_array_ufunc)rT rõ r Úinputsr rs rH rH rI Ú__array_ufunc__~ sL ÿ ÿÿÿ ÿÿÿ ÿÿÿz ExtensionArray.__array_ufunc__).).).)T)T)T)NNN)rx N)r£ N)T)N)N)F)rÔ )T)Hrà Ú
|
__module__Ú __qualname__Ú__doc__Z_typÚ classmethodrJ rL rO r rU r\ r_ rc rj rm rn r rr rt ÚpropertyrD ru rw ry rz r| r0 rh r r r r r r r¡ r8 r¦ r© r5 r« r® r> r r r¯ r´ rE r¸ rÆ r¿ rÁ rÒ rÓ rÖ r r re rÚ rß Ú__annotations__râ rä rå rç rè ré rí rð ró rô rû rH rH rH rI r@ f sâ
|
ÿ
|
#-
|
|
ü( + û/ ü9 2 ü6" þ9þÿ,
|
ÿû_
|
ÿ # ùc @ s8 e Zd ZdddddddZdddddddZd S )
|
Ú ExtensionArraySupportsAnyAllTrØ rF r c C s t | d S rR r r rH rH rI ri s z ExtensionArraySupportsAnyAll.anyc C s t | d S rR r r rH rH rI r¨ s z ExtensionArraySupportsAnyAll.allN)rà rü rý ri r¨ rH rH rH rI r s r c @ sj e Zd ZdZedd ZeddddZedd Zeddd
|
d Zed d Z eddddZ
|
dS )Ú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 C s t | d S rR r ©rG ÚoprH rH rI Ú_create_arithmetic_method¬ s z+ExtensionOpsMixin._create_arithmetic_methodrV rW c C sB t | d| tj¡ t | d| tj¡ t | d| tj¡ t | d| tj¡ t | d| tj¡ t | d| tj ¡ t | d| tj
|
¡ t | d| tj ¡ t | d | tj ¡ t | d
|
| tj ¡ t | d | tj¡ t | d | tj¡ t | d | tj¡ t | d| tj¡ t | d| t¡ t | d| tj¡ d S )NÚ__add__Ú__radd__Ú__sub__Ú__rsub__Ú__mul__Ú__rmul__Ú__pow__Ú__rpow__Ú__mod__Ú__rmod__Ú __floordiv__Ú __rfloordiv__Ú __truediv__Ú __rtruediv__Ú
|
__divmod__Ú __rdivmod__)Úsetattrr ÚoperatorÚaddr3 ZraddÚsubZrsubÚmulZrmulÚpowZrpowÚmodZrmodÚfloordivZ rfloordivÚtruedivZrtruedivÚdivmodÚrdivmod©rG rH rH rI Ú_add_arithmetic_ops° s(
|
ÿz%ExtensionOpsMixin._add_arithmetic_opsc C s t | d S rR r r rH rH rI Ú_create_comparison_methodÅ s z+ExtensionOpsMixin._create_comparison_methodc C s| t | d| tj¡ t | d| tj¡ t | d| tj¡ t | d| tj¡ t | d| tj¡ t | d| tj¡ d S )Nrm rn Ú__lt__Ú__gt__Ú__le__Ú__ge__) r r$ r ÚeqÚneÚltÚgtÚleÚger" rH rH rI Ú_add_comparison_opsÉ s z%ExtensionOpsMixin._add_comparison_opsc C s t | d S rR r r rH rH rI Ú_create_logical_methodÒ s z(ExtensionOpsMixin._create_logical_methodc C s| t | d| tj¡ t | d| tj¡ t | d| tj¡ t | d| tj¡ t | d| tj¡ t | d| tj ¡ d S )NÚ__and__Ú__rand__Ú__or__Ú__ror__Ú__xor__Ú__rxor__)
|
r r0 r Úand_r3 Zrand_Úor_Zror_ÚxorZrxorr" rH rH rI Ú_add_logical_opsÖ s z"ExtensionOpsMixin._add_logical_opsN) rà rü rý rþ rÿ r r# r$ r/ r0 r: rH rH rH rI r ¡ s
|
|
|
|
r c @ s< e Zd ZdZed ddddZedd Zed
|
d ZdS ) Ú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.
|
TNrF )Úcoerce_to_dtypec s* fdd}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 s fdd}t |tttfr tS }||}fddt||D } fdd}jdkrzt| \}}||||fS ||S )Nc s* t | tst| r| }n| gt }|S rR )rg r@ r' ra )ÚparamZovaluesr^ rH rI Úconvert_values# s zNExtensionScalarOpsMixin._create_method.<locals>._binop.<locals>.convert_valuesc s g | ]\}} ||qS rH rH )rÈ r r )r rH rI rË 3 s zJExtensionScalarOpsMixin._create_method.<locals>._binop.<locals>.<listcomp>c s> r,t t| }t|ts:t | ¡}ntj| d}|S )Nro )r$ rY rg rp rq )r§ Úres)r< Ú result_dtyperT rH rI Ú_maybe_convert5 s zNExtensionScalarOpsMixin._create_method.<locals>._binop.<locals>._maybe_convert> r! r )rg r. r- r, rù Úziprà ) rT rk r> ZlvaluesZrvaluesr? rA r r ©r< r r@ r^ rI Ú_binop" s
|
z6ExtensionScalarOpsMixin._create_method.<locals>._binopÚ__)rà r )rG r r< r@ rD Zop_namerH rC rI Ú_create_methodú s (&z&ExtensionScalarOpsMixin._create_methodc C s
|
| |¡S rR )rF r rH rH rI r K s z1ExtensionScalarOpsMixin._create_arithmetic_methodc C s | j |dtdS )NF)r< r@ )rF rF r rH rH rI r$ O s z1ExtensionScalarOpsMixin._create_comparison_method)TN)rà rü rý rþ rÿ rF r r$ rH rH rH rI r; à s P
|
r; )Xrþ Ú
|
__future__r r Útypingr r r r r r r r
|
r r Únumpyrp Z pandas._libsr Zpandas._typingr r r r r r r r r r r r Z pandas.compatr Zpandas.compat.numpyr r Z pandas.errorsr Zpandas.util._decoratorsr r r Zpandas.util._validatorsr! r" r# Zpandas.core.dtypes.castr$ Zpandas.core.dtypes.commonr% r& r' r( r) r* Zpandas.core.dtypes.dtypesr+ Zpandas.core.dtypes.genericr, r- r. Zpandas.core.dtypes.missingr0 Z pandas.corer1 r2 r3 Zpandas.core.algorithmsr4 r5 r6 r7 r8 Z pandas.core.array_algos.quantiler9 Zpandas.core.sortingr: r; r< r= r> r r? r@ r r r; rH rH rH rI Ú<module> sP 0 8 ??
|
