U
|
¬ý°dÿ_ ã @ s d dl mZ d dlmZ d dlZd dlmZmZmZm Z m
|
Z
|
m Z m Z d dl Zd dlmZ d dlmZmZmZ d dlmZmZ d dlmZ d d lm Z d d
|
l m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& d d l'm(Z( d d l)m*Z* d d l+m,Z, d dl-m.Z.m/Z/ d dl0m1Z1m2Z2m3Z3m4Z4m5Z5 d dl6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z> d dl?m@Z@mAZAmBZBmCZC d dlDmEZEmFZFmGZGmHZH d dlImJZJmKZKmLZL d dlMmNZN d dlOmP mQZR d dlSmTZTmUZUmVZVmWZWmXZX d dlYmZZZ d dl[m\Z\m]Z]m^Z^ d dl_m`Z` d dlambZbmcZcmdZdmeZemfZfmgZgmhZh d dlimjZj d dlkmlZl d dlmmP mnZo d d lpmqZq d d lrmsZsmtZt d d lumvZv ervd d lwmxZx d d lymzZz e {d!¡Z|d"d"d#d$d%Z}G d&d' d'elZ~G d(d) d)e~ZG d*d+ d+ej~eZG d,d- d-eje~ZG d.d/ d/eZG d0d1 d1ejeZd2d3d4d5d6Z
G d7d8 d8eZG d9d: d:eZG d;d< d<eZd=d=d>d?d@ZdAdBdCdDZdjd=dEdFdGdHdIZddJdKdFd'dLdMdNZdEdKd3dOdPdQZdRdSdKdTdUdVdWZdkdXdYdZd[Zdld=dKd=d]d^d_Zd`dddadbd=dcdcdddedfdgZd=d=d>dhdiZdS )mé )Ú annotations)ÚwrapsN)Ú TYPE_CHECKINGÚAnyÚCallableÚIterableÚSequenceÚcastÚfinal)Úusing_copy_on_write)Ú internalsÚlibÚwriters)ÚBlockPlacementÚBlockValuesRefs)ÚNA)ÚIncompatibleFrequency) Ú ArrayLikeÚAxisIntÚDtypeObjÚFÚ FillnaOptionsÚ IgnoreRaiseÚQuantileInterpolationÚShapeÚnpt©ÚAbstractMethodError)Úcache_readonly)Úvalidate_bool_kwarg)Úastype_array_safeÚastype_is_view)ÚLossySetitemErrorÚcan_hold_elementÚfind_result_typeÚmaybe_downcast_to_dtypeÚnp_can_hold_element)Úensure_platform_intÚis_1d_only_ea_dtypeÚis_1d_only_ea_objÚis_dtype_equalÚis_interval_dtypeÚ is_list_likeÚ is_sparseÚis_string_dtype)ÚDatetimeTZDtypeÚExtensionDtypeÚ PandasDtypeÚ PeriodDtype)Ú ABCDataFrameÚABCIndexÚABCPandasArrayÚ ABCSeries)Úis_valid_na_for_dtypeÚisnaÚna_value_for_dtype)Úmissing)Úextract_bool_arrayÚputmask_inplaceÚputmask_without_repeatÚsetitem_datetimelike_compatÚvalidate_putmask)Úquantile_compat)Úcompare_or_regex_searchÚ replace_regexÚshould_use_regex)Úshift)Ú CategoricalÚ DatetimeArrayÚExtensionArrayÚ IntervalArrayÚ PandasArrayÚ PeriodArrayÚTimedeltaArray)Ú SparseDtype)Ú PandasObject)Ú expressions)Ú ensure_wrapped_if_datetimelikeÚ extract_array)Úcheck_setitem_lengths)ÚIndex)ÚNDArrayBackedExtensionArrayÚobjectr )ÚmethÚreturnc s$ t dd fdd }tt|S )zp
|
If we have a multi-column block, split and operate block-wise. Otherwise
|
use the original method.
|
ú list[Block]©rV c s> | j dks| jd dkr( | f||S | j f||S d S )Né r )ÚndimÚshapeÚsplit_and_operate)ÚselfÚargsÚkwargs©rU © úSd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/internals/blocks.pyÚnewfunc
s z maybe_split.<locals>.newfunc)r r r )rU rc ra r` rb Ú maybe_split s rd c @ s¶ e Zd ZU dZded< ded< ded< ded < d
|
Zd Zd Zd Zd Z d Z
|
e e d d Z e e ddddZe eddddZe dd Ze e dd Ze dd Zeddd d Zejdd d d d Ze dÆd"d d#d$d%Ze dÇd&d"d d'd(d)Ze d*dd+d,Ze ddd-d.Ze d/d d0d1d2Ze d3dd d4d5d6Ze d7dd8d9d:Z e d;dd<d=d>Z e d?dd@dAZ e d?ddBdCZ e d;d?dDdEdFZ e d?ddGdHZ!e d?ddIdJZ"e d ddKdLZ#e dÈd?dd?dMdNdOZ$e e%dÉdd?dPdQdRZ&d d dSddd?dTdUdVZ'e dWddXdYZ(e dÊdWdd[dd d\d]d^Z)e dËd*d d`dadbZ*e dÌdd dcdddeZ+e dÍddfdd?dgdhdiZ,e dÎddd?djdkdlZ-e dÏdmdndddd?dodpdqZ.e dÐdrdddd?dsdtduZ/dvdvdwdxdyZ0dzd{ Z1ed|dd}d~Z2ddvdddZ3dd;d0dd
Z4dÑd;dd dddZ5d!e6j7fddd&d dddZ8ddrdddZ9dÒdd dPddZ:dÓdd?dPddZ;dÔddd?dddZ<dÕdddd?dddZ=ddd!d d!d d!d!d!d d¡
|
d¢dd£ddd*d¤d¥d¤dd?d¦ d§d¨Z>dÖddd?dªd«d¬Z?d×ddd7d?dd®d¯Z@e dØd±d²dd d³d´dµZAdÙddd d¶d·d¸ZBd?dd¹dºZCeddd»d¼ZDed½dd¾d¿ZEdÚdÀdvdÁdÂdÃZFdvddÄdÅZGd!S )ÛÚBlockz
|
Canonical n-dimensional unit of homogeneous dtype contained in a pandas
|
data structure
|
|
Index-ignorant; let the container take care of that
|
únp.ndarray | ExtensionArrayÚvaluesÚintrZ r Úrefsr Ú__init__ra FTc C s | j | jjfS ©N)Ú_can_consolidateÚdtypeÚname©r] ra ra rb Ú_consolidate_key¤ s zBlock._consolidate_keyÚboolrX c C s" | j }t|tj r |jdkS |jS )z7
|
Can we store NA values in this Block?
|
)ÚbÚiÚu)rm Ú
|
isinstanceÚnpÚkindÚ _can_hold_na©r] rm ra ra rb rx © s
|
zBlock._can_hold_nac C s | j jt t¡kS )z^
|
We can be bool if a) we are bool dtype or b) object dtype with bool objects.
|
)rg rm rv rq ro ra ra rb Úis_bool´ s z Block.is_boolc C s
|
t | jS rk )Úexternal_valuesrg ro ra ra rb r{ ¼ s zBlock.external_valuesc C s t | jddS )NF)Úcompat)r9 rm ro ra ra rb Ú
|
fill_valueÀ s zBlock.fill_valuec C s | j tkr t|| j r | j}|S rk )rm Ú
|
_dtype_objr7 r} ©r] Úvaluera ra rb Ú_standardize_fill_valueÆ s z Block._standardize_fill_valuer c C s | j S rk ©Ú _mgr_locsro ra ra rb Úmgr_locsÍ s zBlock.mgr_locsÚNone)Ú new_mgr_locsrV c C s
|
|| _ d S rk r )r] r ra ra rb r Ñ s NúBlockValuesRefs | None)ri rV c C s4 |dkr| j }| jr"t|| jd}t||| j|dS )zm
|
Create a new block, with type inference propagate any values that are
|
not specified
|
N©rZ ©Ú placementrZ ri )r Ú is_extensionÚensure_block_shaperZ Ú new_block©r] rg r ri ra ra rb Ú
|
make_blockÕ s
|
zBlock.make_blockzBlockPlacement | None)r ri rV c C s$ |dkr| j }t| ||| j|dS )z2Wrap given values in a block of same type as self.Nr )r ÚtyperZ r ra ra rb Úmake_block_same_classæ s
|
zBlock.make_block_same_classÚstrc C sj t | j}| jdkr0| dt| d| j }n6d dd | jD ¡}| d| jj d| d| j }|S ) NrY z: z dtype: z x c S s g | ] }t |qS ra )r ©Ú.0Úsra ra rb Ú
|
<listcomp>ý s z"Block.__repr__.<locals>.<listcomp>z, z , dtype: ) r Ú__name__rZ Úlenrm Újoinr[ r Úindexer)r] rn Úresultr[ ra ra rb Ú__repr__ö s
|
|
zBlock.__repr__c C s
|
t | jS rk )r rg ro ra ra rb Ú__len__ s z Block.__len__z slice | npt.NDArray[np.intp]©ÚslicerrV c C s> | j | }| |¡}t|tr$| jnd}t| ||| j|dS )ú
|
Perform __getitem__-like, return result as block.
|
|
Only supports slices that preserve dimensionality.
|
N©ri )r Ú_sliceru Úsliceri r rZ )r] r r Ú
|
new_valuesri ra ra rb Ú getitem_block s
|
|
zBlock.getitem_blockr£ )r r rV c C s8 | |¡}|j| jjkr tdt| ||| j| jdS )r z Only same dim slicing is allowedr¡ )r¢ rZ rg Ú
|
ValueErrorr ri )r] r r r¤ ra ra rb Úgetitem_block_columns s
|
zBlock.getitem_block_columnsr )ÚelementrV c C s t |dd}t| j|S )z#require the same dtype as ourselvesT©Z extract_numpy)rP r# rg )r] r¨ ra ra rb Ú_can_hold_element' s zBlock._can_hold_elementr )r rV c C s* z|j | j kW S tk
|
r$ Y dS X dS )zÝ
|
Should we set self.values[indexer] = value inplace or do we need to cast?
|
|
Parameters
|
----------
|
value : np.ndarray or ExtensionArray
|
|
Returns
|
-------
|
bool
|
FN)rm Ú TypeErrorr ra ra rb Ú should_store- s zBlock.should_storerW c K s || j f|}| |¡S )z[
|
apply the function to my values; return a block if we are not
|
one
|
)rg Ú_split_op_result)r] Úfuncr_ r ra ra rb ÚapplyC s z Block.applyc C sP | j dkst|| j}| jj dkr4t |gg¡}n | dd¡}| |¡}|gS )Né rY éÿÿÿÿ)rZ ÚAssertionErrorrg rv ÚarrayÚreshaper )r] r® r Ú
|
res_valuesÚnbra ra rb ÚreduceM s
|
|
z Block.reduce)r rV c C s| |j dkrlt|jtrlg }t| jD ]B\}}t|sF|||d
}n|| }| j||d}| |¡ q$|S | |¡}|gS )NrY )rg r ) rZ ru rm r0 Ú enumerater r) r Úappend)r] r Únbsrs ÚlocÚvalsÚblockr¶ ra ra rb r ^ s
|
zBlock._split_op_resultc C sf | j dkstg }t| jD ]D\}}| jt||d }t|}t| ||d| jd}| |¡ q |S )zD
|
Split a block into a list of single-column blocks.
|
r° rY r )
|
rZ r² r¸ r rg r£ r r ri r¹ )r] Ú
|
new_blocksrs Zref_locr¼ Úbpr¶ ra ra rb Ú_splits s z Block._splitc O sL | j dkr| jd dks tg }| ¡ D ] }||f||}| |¡ q(|S )zÙ
|
Split the block and apply func column-by-column.
|
|
Parameters
|
----------
|
func : Block method
|
*args
|
**kwargs
|
|
Returns
|
-------
|
List[Block]
|
r° r rY )rZ r[ r² rÀ Úextend)r] r® r^ r_ Ú
|
res_blocksr¶ Úrbsra ra rb r\ s zBlock.split_and_operatec C s t | j|}| j|ddS )zé
|
coerce the current block to a dtype compat for other
|
we will return a block, possibly object, and not raise
|
|
we can also safely try to coerce to the same dtype
|
and will receive the same block
|
F©Úcopy)r$ rg Úastype)r] ÚotherZ new_dtypera ra rb Úcoerce_to_target_dtype s z Block.coerce_to_target_dtype)ÚblocksÚ using_cowrV c sP dkr |S | j tkr,tfdd|D S d kr8|S t fdd|D S )NFc s g | ]}|j d qS ))rÊ rÅ ©Úconvert©r Úblk©rÊ ra rb r ¹ s z)Block._maybe_downcast.<locals>.<listcomp>c s g | ]}| ¡qS ra )Ú _downcast_2d©r rr ©ÚdowncastrÊ ra rb r ¿ s )rm r~ Ú extend_blocks)r] rÉ rÓ rÊ ra rÒ rb Ú_maybe_downcastª s
|
ÿzBlock._maybe_downcast©rÊ rV c C s6 t | j|d}|r"|| jkr"| jnd}| j||dgS )zs
|
downcast specialized to 2D case post-validation.
|
|
Refactored to allow use of maybe_split.
|
©rm Nr¡ )r% rg ri r )r] rm rÊ r¤ ri ra ra rb rÐ Á s zBlock._downcast_2d©rÅ rÊ ©rÅ rÊ rV c C s* |s|r| j ddgS |r$| ¡ gS | gS )z®
|
attempt to coerce any object types to better types return a copy
|
of the block (if copy = True) by definition we are not an ObjectBlock
|
here!
|
F©ÚdeeprÄ )r] rÅ rÊ ra ra rb rÌ Í s z Block.convertr c C s | j jS rk )rg rm ro ra ra rb rm ß s z Block.dtypeÚraiser )rm rÅ ÚerrorsrÊ rV c C s | j }t||||d}t|}d}|r:t|j|jr:| j}| j||d}|j| jkrtd| d| jj d| j d|jj d|j d |S ) a
|
Coerce to the new dtype.
|
|
Parameters
|
----------
|
dtype : np.dtype or ExtensionDtype
|
copy : bool, default False
|
copy if indicated
|
errors : str, {'raise', 'ignore'}, default 'raise'
|
- ``raise`` : allow exceptions to be raised
|
- ``ignore`` : suppress exceptions. On error return original object
|
using_cow: bool, default False
|
Signaling if copy on write copy logic is used.
|
|
Returns
|
-------
|
Block
|
)rÅ rÝ Nr¡ z cannot set astype for copy = [z ] for dtype (z [z]) to different shape (z]))
|
rg r Úmaybe_coerce_valuesr! rm ri r r[ r« rn ) r] rm rÅ rÝ rÊ rg r¤ ri Znewbra ra rb rÆ ã s .ÿz Block.astypeÚnan)Úna_reprV c K s" t | jf||d|}| |¡S )ú"convert to our native types format)rà Úquoting)Úto_native_typesrg r )r] rà râ r_ r ra ra rb rã s zBlock.to_native_types)rÛ rV c C s6 | j }|r| ¡ }d}n| j}t| || j| j|dS )zcopy constructorNr )rg rÅ ri r r rZ )r] rÛ rg ri ra ra rb rÅ s z
|
Block.copyz npt.NDArray[np.bool_] | None)ÚinplaceÚmaskrÊ rV c C s | j }t|trp|r,| j ¡ s"|s,| ¡ }n"|r>| jdd}n|rF| n| ¡ }tt|j }|j||dd |gS | |¡s |r| jddgS |r| gS | ¡ gS |dkr´t
|
||¡}| ¡ sæ|rÎ| jddgS |rØ| gS | ¡ gS n,| |¡rh|r |r| j| j ¡ d}n| ¡ }n|r&| n| ¡ }t |j || | j rN|dks^|jd|d}n|g}|S | jdks| jd dkrÆ|dks|tkrª| t t¡¡}n
|
| |¡}|j||d|d S g }t| ¡ D ]6\} }
|
| t| j|
|
||d|| | d
|d
|
¡ qÖ|S dS ) z
|
replace the to_replace value with value, possible to create new
|
blocks here this is just a call to putmask.
|
FrÚ T©Ú
|
to_replacer rä NrØ rY r )rç r rä rå ©rç r rä rå rÊ ) rg ru rE ri Ú has_referencerÅ r Ú_replacerª r: Ú mask_missingÚanyr< Ú is_objectrÌ rZ r[ r rÆ rv rm rT rÈ Úreplacer¸ rÀ rÁ r ) r] rç r rä rå rÊ rg rÎ rÉ rs r¶ ra ra rb rî % sl
|
|
|
|
|
ü úÿ
|
z Block.replace)rä rÊ rV c
|
C s¬ | |¡s0|r | jddgS |r&| gS | ¡ gS t |¡}|rj|rZ| j ¡ sZ| j}| j}qd}| j ¡ }nd}|rx| jn| j ¡ }t|||| | j||d} | j d|dS )aA
|
Replace elements by the given value.
|
|
Parameters
|
----------
|
to_replace : object or pattern
|
Scalar to replace or regular expression to match.
|
value : object
|
Replacement object.
|
inplace : bool, default False
|
Perform inplace modification.
|
mask : array-like of bool, optional
|
True indicate corresponding element is ignored.
|
using_cow: bool, default False
|
Specifying if copy on write is enabled.
|
|
Returns
|
-------
|
List[Block]
|
FrÚ Nr¡ rØ )
|
rª rÅ ÚreÚcompileri ré rg rB r rÌ )
|
r] rç r rä rå rÊ Úrxri r¤ r½ ra ra rb Ú_replace_regex s
|
|
zBlock._replace_regexz Iterable[Any]z Sequence[Any])Úsrc_listÚ dest_listrä ÚregexrÊ rV c
|
sü j ttr^r,|r,jj ¡ d}n|r4n ¡ }tt|j j||dd |gS fddt||D }t |s¤rjddgS |rgS ¡ gS t |d }t
|
j rÜt fdd |D } nfd
|
d |D } |rút | } r|rg}
|
n|rn ¡ g}
|
tt|| D ]Æ\} \\} } }| |k}g }t|
|
D ]\}}t |
|
dkrp|}n$|}t|trt|||d
}|j| | ||d }|râ|jrâtd d |D sâtfd d|D }| |¡ qT|}
|
q0|
|
S )z:
|
See BlockManager.replace_list docstring.
|
rÚ Træ c s" g | ]\}} |¡r||fqS ra )rª )r ÚxÚyro ra rb r Ù s
|
z&Block.replace_list.<locals>.<listcomp>FrY c
|
3 s, | ]$}t ttt|d dV qdS )r )rõ rå N)r; r r rA r )Úna_maskrõ rg ra rb Ú <genexpr>è s ø ÿþÿz%Block.replace_list.<locals>.<genexpr>c 3 s | ]}t |d ¡V qdS )r N)r: rë r ©rg ra rb rù õ s )rç r rå rä rõ rÊ c s s | ]}|d kV qd S rk ra ©r rö ra ra rb rù s c s g | ]}|j d o dqS )TrØ rË rÑ rÏ ra rb r s ÿ)rg ru rE rÅ ri ré r rê Úzipr r. rm r8 Úlistr¸ rq r² Ú_replace_coercerí ÚallrÔ rÁ )r] ró rô rä rõ rÊ rÎ ÚpairsZsrc_lenÚmasksÚrbrs ÚsrcÚdestrå rÌ Znew_rbZblk_numÚmZmibr ra )rø rõ r] rÊ rg rb Ú replace_list¿ sj
|
|
ÿ
|
|
÷ ú"
|
þÿzBlock.replace_listúnpt.NDArray[np.bool_])rå rä rõ rÊ rV c C sÒ t ||r | j||||dS |dkrº| ¡ r| j ¡ }| jt t¡d|d}|| ksX|rf|sf| ¡ }n|r|r|j ¡ r| ¡ }t
|
|j || |gS |r¦| j ddgS |r°| gS | ¡ gS | j |||||dS dS )ai
|
Replace value corresponding to the given boolean array with another
|
value.
|
|
Parameters
|
----------
|
to_replace : object or pattern
|
Scalar to replace or regular expression to match.
|
value : object
|
Replacement object.
|
mask : np.ndarray[bool]
|
True indicate corresponding element is ignored.
|
inplace : bool, default True
|
Perform inplace modification.
|
regex : bool, default False
|
If true, perform regular expression substitution.
|
|
Returns
|
-------
|
List[Block]
|
)rä rå NFrØ rÚ rè ) rC rò rì ri ré rÆ rv rm rT rÅ r< rg rî ) r] rç r rå rä rõ rÊ Zhas_refr¶ ra ra rb rþ ( s6
|
ü
|
|
ûzBlock._replace_coerceú
|
np.ndarray)ÚargrV c C s |S ©zA
|
For compatibility with 1D-only ExtensionArrays.
|
ra ©r] r ra ra rb Ú_maybe_squeeze_argj s zBlock._maybe_squeeze_argc C s |S r
|
ra )r] r ra ra rb Ú_unwrap_setitem_indexerp s z Block._unwrap_setitem_indexerr c C s | j jS rk )rg r[ ro ra ra rb r[ x s z Block.shapeú)int | tuple[int, int] | tuple[slice, int])rs rV c C s
|
| j | S rk rú )r] rs ra ra rb Úiget| s z
|
Block.igetú4slice | npt.NDArray[np.bool_] | npt.NDArray[np.intp]c C s
|
| j | S )zreturn a slice of my valuesrú )r] r ra ra rb r¢
s z Block._slice©rg rÅ rV c C s |r| j ¡ | _ || j |< dS )a¨
|
Modify block values in-place with new item value.
|
|
If copy=True, first copy the underlying values in place before modifying
|
(for Copy-on-Write).
|
|
Notes
|
-----
|
`set_inplace` never creates a new array or new Block, whereas `setitem`
|
_may_ create a new array and always creates a new Block.
|
|
Caller is responsible for checking values.dtype == self.dtype.
|
N©rg rÅ ©r] Úlocsrg rÅ ra ra rb Ú set_inplace s zBlock.set_inplaceúnpt.NDArray[np.intp]r )r Úaxisr rV c C s | j }|tjkr | j}d}nd}tj|||||d}t| trT| jdkrT|dkrTt |dkrh|dkrht |dkrv| j
|
}t |j | j s| ||¡S | ||¡S dS )zN
|
Take values according to indexer and return them as a block.
|
FT)r Ú
|
allow_fillr} rY Nr )rg r Ú
|
no_defaultr} ÚalgosÚtake_ndru ÚExtensionBlockrZ r² r r* rm r r )r] r r r r} rg r r¤ ra ra rb r s(
|
|
ÿ
|
z Block.take_nd©Ú new_placementÚ needs_maskingc C sP |j | jj|d\}}| d¡}|j| }|| }t|}t||dg}||fS )a
|
Return a list of unstacked blocks of self
|
|
Parameters
|
----------
|
unstacker : reshape._Unstacker
|
fill_value : int
|
Only used in ExtensionBlock._unstack
|
new_placement : np.ndarray[np.intp]
|
allow_fill : bool
|
needs_masking : np.ndarray[bool]
|
|
Returns
|
-------
|
blocks : list of Block
|
New blocks of unstacked values.
|
mask : array-like of bool
|
The mask of columns of `blocks` we should keep.
|
©r} r ©r )Zget_new_valuesrg ÚTrì r Ú new_block_2d) r] Ú unstackerr} r r r¤ rå r¿ rÉ ra ra rb Ú_unstackÅ s ÿ
|
|
|
zBlock._unstackc C sä | |¡}ttj| j}| jdkr(|j}t||| t|dd}zt |j
|
|}W n* t k
|
rz | |¡}| ||¡ Y S X | j
|
tkr¨|| }t |¡r¨t|t||}|rØ| j ¡ rØ| ¡ }| |jdkrÒ|jn|¡} |||< | S )a
|
Attempt self.values[indexer] = value, possibly creating a new array.
|
|
Parameters
|
----------
|
indexer : tuple, list-like, array-like, slice, int
|
The subset of self.values to set
|
value : object
|
The value being set
|
using_cow: bool, default False
|
Signaling if CoW is used.
|
|
Returns
|
-------
|
Block
|
|
Notes
|
-----
|
`indexer` is a direct slice/positional indexer. `value` must
|
be a compatible shape.
|
r° Tr© )r r rv Úndarrayrg rZ r" rQ rP r& rm r" rÈ Úsetitemr~ r r, r> r ri ré rÅ r )r] r r rÊ rg Úcastedr¶ Úvira ra rb r' ó s,
|
|
|
|
|
ÿz Block.setitemc C sÚ |}t tj| j}t|j|\}}t|ttt fr6t
|
|t j krF| j }| |¡}t|dd}|rx|rr| jddgS | gS zVt|j|}|r¦| j ¡ r¦| ¡ }| |¡} t|j|| |rÈ| jddgW S | gW S tk
|
rÔ | jdk sü| jd dkrHt|s | |¡ ||¡ Y S | ¡ d }| j ||| |d} | g Y S nt|tj}
|
g } | ¡ } t | D ]^\} } |}|
|
r|dd
| | d
f }|dd
| | d
f }| j |||d}| !|¡ qh| Y S Y nX dS ) a}
|
putmask the data to the block; it is possible that we may create a
|
new dtype of block
|
|
Return the resulting block(s).
|
|
Parameters
|
----------
|
mask : np.ndarray[bool], SparseArray[bool], or BooleanArray
|
new : a ndarray/object
|
using_cow: bool, default False
|
|
Returns
|
-------
|
List[Block]
|
Tr© FrÚ rY r rÏ N)"r rv r& rg r? r" ru r4 r6 r3 r² r r r} r rP rÅ r& rm ri ré r r= r" rZ r[ r, rÈ ÚputmaskZnonzeror' rÀ r¸ rÁ )r] rå ÚnewrÊ Ú orig_maskrg Únoopr( r r¶ Úis_arrayr rº rs ÚnÚsubmaskrà ra ra rb r* , sN
|
|
|
|
z Block.putmaskÚinferú
|
str | bool©Ú _downcastrÊ rV c
|
C sp |j | j kstt|tttfr$t| j dk}t|}ttj | j
|
}|}|rR|j }t || \}} | r|rx| j ddgS | ¡ gS |tjkr| j}| |¡}zt|j|}
|
W nò tttfk
|
r | j dksÞ| jd dkr | |¡} | j|||d} | j| ||d Y S t|tj tf} g }| ¡ }t |D ]`\}}|}| rZ|dd
||d
f }|dd
||d
f }|j||||d }| |¡ q0| Y S Y nºX |
|
}t || ¡ |}||k r
|
t!|ròt"|t"|k ròt | ||¡ t#d
|
| ¡ }t $|||¡ nNt!|rHt|tj sHt"|| jd krHt %|¡ &|j¡}t' | ||¡}|rd|j }| (|¡gS ) a
|
evaluate the block; return result block(s) from the result
|
|
Parameters
|
----------
|
other : a ndarray/object
|
cond : np.ndarray[bool], SparseArray[bool], or BooleanArray
|
_downcast : str or None, default "infer"
|
Private because we only specify it when calling from fillna.
|
|
Returns
|
-------
|
List[Block]
|
r° FrÚ rY r rÏ rÒ N)r4 rÊ zThis should not be reached; call to np.where above is expected to raise ValueError. Please report a bug at github.com/pandas-dev/pandasr± ))rZ r² ru r4 r6 r3 r; r rv r& rg r" r? rÅ r r r} r r& rm r¦ r« r" r[ rÈ ÚwhererÕ rG rÀ r¸ rÁ r> Úsumr, r ÚNotImplementedErrorr* r³ r´ rN r )r] rÇ Úcondr4 rÊ Z transposerg Ú
|
orig_otherÚicondr- r( r½ rÉ r. r rº rs r¶ Zothr0 rà Zaltr ra ra rb r5 u s
|
|
|
|
|
ÿ
|
ÿ
|
ÿÿ
|
þýz Block.whereú
|
int | None©Úlimiträ rÊ rV c
|
sØ t |d}| jsd}nt| j}t| j|\}}|rt|rPrJ| jddgS | gS | j d}|j|g d} | S |dk rd|| | jd ¡|k< |r¬| j |j
|
|d} n| j ||j
|
dd } t fd
|
d | D S ) zs
|
fillna on the block with the value. If we fail, then convert to
|
ObjectBlock and try again
|
rä TFrÚ rÒ NrY rÏ )r4 c s g | ]}|j |g d qS )rÒ )rÕ rÍ rÒ ra rb r s ÿz Block.fillna.<locals>.<listcomp>) r rx r8 rg r? rÅ rÕ ZcumsumrZ r* r" r5 rÔ )
|
r] r r= rä rÓ rÊ r- rå r¶ rº ra rÒ rb Úfillnaì s.
|
|
þÿz Block.fillnaÚpadr Zforward)
|
Úmethodr Úindexrä r= Úlimit_directionÚ
|
limit_arear} rÓ rÊ r ú Index | Nonez
|
str | Nonez
|
Any | None) r@ r rA rä r= rB rC r} rÓ rÊ rV c
|
K sv t |d}| js6|
|
r"| jddgS |r,| gS | ¡ gS zt |¡} W n tk
|
r\ d } Y nX | d kr| jjdkr|
|
r| jddgS |r| gS | ¡ gS | jrê| j dkrê| j
|
d dkrê|dkrê| j t | j f||||||||| d | S d } |r |
|
r| j ¡ r| j ¡ }n | j}| j} n
|
| j ¡ }ttj|}tj|f|||||||d | | j|| d
|
}| |g| |
|
¡S ) Nrä FrÚ Úfr° r rY ) r@ r rA rä r= rB rC r} rÓ )r@ r rA r= rB rC r} r¡ )r rx rÅ r: Zclean_fill_methodr¦ rm rw rí rZ r[ r\ r Ú interpolateri ré rg r rv r& Úinterpolate_array_2dr rÕ )r] r@ r rA rä r= rB rC r} rÓ rÊ r_ r ri Údatar¶ ra ra rb rF $ sh
|
|
&ÿö õ
|
ÿø ÷ zBlock.interpolaterY ©r/ r rV c C s t j| j||d}| j|dgS )z'return block for the diff of the values©r rú ©r Údiffrg r ©r] r/ r r¤ ra ra rb rL q s z
|
Block.diff©Úperiodsr r} rV c C s t |¡s | jtkr td| |¡}zt| j|}W n. tk
|
rd | |¡}|j |||d Y S X t
|
t j | j }t ||||}| |¡gS dS )z+shift the block by periods, possibly upcastzfill_value must be a scalar)r r} N)r Z is_scalarrm r~ r¦ r r& r" rÈ rD r rv r& rg r )r] rO r r} r( r¶ rg r¤ ra ra rb rD w s
|
ÿ
|
z Block.shiftÚlinearrR r )ÚqsÚ interpolationr rV c C sV | j dkst|dkstt|s&tt| jt |j¡|}t|dd}t || j
|
dS )aX
|
compute the quantiles of the
|
|
Parameters
|
----------
|
qs : Index
|
The quantiles to be computed in float64.
|
interpolation : str, default 'linear'
|
Type of interpolation.
|
axis : int, default 0
|
Axis to compute.
|
|
Returns
|
-------
|
Block
|
r° rY r r! ) rZ r² r, r@ rg rv ÚasarrayÚ_valuesr r# r )r] rQ rR r r ra ra rb Úquantile s zBlock.quantile)ÚdecimalsrÊ rV c C sT | j r | jr| j| dS d}| j |¡}|| jkrF| j}|sF| ¡ }| j||dS )aÉ
|
Rounds the values.
|
If the block is not of an integer or float dtype, nothing happens.
|
This is consistent with DataFrame.round behavivor.
|
(Note: Series.round would raise)
|
|
Parameters
|
----------
|
decimals: int,
|
Number of decimal places to round to.
|
Caller is responsible for validating this
|
using_cow: bool,
|
Whether Copy on Write is enabled right now
|
rÚ Nr¡ )Ú
|
is_numericrz rÅ rg Úroundri r )r] rV rÊ ri rg ra ra rb rX » s
|
z Block.roundc C s t |s|g}| jdkrTttj| j}t ||¡}| j |¡}t| ||| jdgS t |¡| jj
|
d krnt t || jj
|
d gg¡}| jj }g }d}| j ¡ r¦| jnd}|D ]d}||d krÀnN| j|d |
dd
f }||d |
} t| |t| | j|d}
|
| |
|
¡ |}q®|S )a Deletes the locs from the block.
|
|
We split the block to avoid copying the underlying data. We create new
|
blocks for every connected segment of the initial block that is not deleted.
|
The new blocks point to the initial array.
|
rY ©r rZ r r± Nr )r, rZ r rv r& rg Údeleter r Úmaxr[ Ú
|
IndexErrorZ concatenateZas_arrayri ré r r¹ ) r] r» rg r Z mgr_locs_arrr¾ Z previous_locri Úidxr r¶ ra ra rb rZ ß s8
|
ÿ
|
z Block.deletec C s t | dS ©z(return a boolean if I am possibly a viewNr ro ra ra rb Úis_view s z Block.is_viewrG c C s t | dS )zP
|
The array that Series.array returns. Always an ExtensionArray.
|
Nr ro ra ra rb Ú array_values s zBlock.array_valuesúDtypeObj | None©rm rV c C s t | dS )z
|
return an internal format, currently just the ndarray
|
this is often overridden to handle to_dense like operations
|
Nr ry ra ra rb Ú
|
get_values s zBlock.get_valuesc C s t | d S rk r ro ra ra rb Úvalues_for_json" s zBlock.values_for_json)NN)NN)NF)F)FrÜ F)rß N)T)FNF)FNF)FFF)TFF)F)F)F)r1 F)NFNF)rY )r N)rP r )F)N)Hr Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__Ú __slots__rW rí r rl Ú_validate_ndimr
|
r rp rx Úpropertyrz r{ r} r r Úsetterr r r r r¥ r§ rª r¬ r¯ r· r rÀ r\ rÈ rÕ rd rÐ rÌ rm rÆ rã rÅ rî rò r rþ r r r[ r r¢ r r r r r% r' r* r5 r> rF rL rD rU rX rZ r_ r` rc rd ra ra ra rb re s0
|
|
|
ÿ ü ÿ ü û, ùc ú5 ú h ùA û'.9J ÿz ú;ô&M ÿ" ü!$0re c s¾ e Zd ZU dZded< d(ddddZd)d
|
dd d d dZd*dd dddZd d fdd Ze ddddZ
|
d+ddddd Z ddd d Z d d ddddd!d"d#dd$dd%d&d'Z ZS ),Ú EABackedBlockz>
|
Mixin for Block subclasses backed by ExtensionArray.
|
rG rg Frq rÏ c
|
C sÔ |}|}| |¡}| |¡}| j}|jdkr2|j}t||| z |||< W n ttfk
|
rÊ } z^t| t | j
|
r| |¡}| ||¡ W Y ¢0S t | tr¸| |¡}| ||¡ W Y ¢S W 5 d}~X Y nX | S dS )a
|
Attempt self.values[indexer] = value, possibly creating a new array.
|
|
This differs from Block.setitem by not allowing setitem to change
|
the dtype of the Block.
|
|
Parameters
|
----------
|
indexer : tuple, list-like, array-like, slice, int
|
The subset of self.values to set
|
value : object
|
The value being set
|
using_cow: bool, default False
|
Signaling if CoW is used.
|
|
Returns
|
-------
|
Block
|
|
Notes
|
-----
|
`indexer` is a direct slice/positional indexer. `value` must
|
be a compatible shape.
|
r° N)r r rg rZ r" rQ r¦ r« Ú _catch_deprecated_value_errorr+ rm rÈ r' ru ÚNDArrayBackedExtensionBlock) r] r r rÊ Z orig_indexerZ
|
orig_valuerg Úerrr¶ ra ra rb r' - s(
|
|
|
|
|
|
|
zEABackedBlock.setitemr1 r2 rW r3 c
|
C sì | j j}t|}|}|}| |¡}| |¡}|tjkr<| j}t|| \}} | rl|rb| jddgS | ¡ gS z| ||¡j}
|
W nZ t
|
t fk
|
rÚ } z4t | | j dks¼| jd dkr:t| jrø| |¡} | j|||d} | j| ||d W Y ¢ØS t| tr6| |¡} | j|||d} | j| ||d W Y ¢S nt|tjtf}g }| ¡ } t| D ]^\}}|}|r|d d
||d
f }|d d
||d
f }|j|||d}| |¡ q^| W Y ¢S W 5 d } ~ X Y nX | |
|
¡}|gS )NFrÚ rY r rÏ rÒ ) rg r" r; r r r r} r? rÅ Z_wherer¦ r« rn rZ r[ r+ rm rÈ r5 rÕ ru ro rv r& rG rÀ r¸ rÁ r )r] rÇ r8 r4 rÊ Zarrr9 Z orig_condr: r- rµ rp rÎ rº r. r rs r¶ r/ r0 rà ra ra rb r5 g s`
|
|
|
|
|
|
ÿ
|
ÿ
|
zEABackedBlock.whererÖ c
|
C sä t |}|tjkr| j}| j}|jdkr.|j}|}|}| |¡}| |¡}| ¡ sj|rd| j ddgS | gS |r| j
|
¡ r| ¡ }| |jdkr|jn|¡} z| ||¡ W n0 ttfk
|
rÜ } z
|
t| | jdksè| jd dkr@t| jr| |¡}| ||¡ W Y ¢ÀS t| tr<| |¡}| ||¡ W Y ¢S nt|tjtf} g }
|
| ¡ } t | D ]Z\} } |}| r|dd
| | d
f }|dd
| | d
f }| ||¡}|
|
|¡ qd|
|
W Y ¢S W 5 d}~X Y nX | gS )z+
|
See Block.putmask.__doc__
|
r° FrÚ rY r N) r; r r r} rg rZ r" r rì rÅ ri ré r Z_putmaskr« r¦ rn r[ r+ rm rÈ r* ru ro rv r& rG rÀ r¸ rÁ )r] rå r+ rÊ rg Zorig_newr, rp rÎ r. r rº rs r¶ r/ r0 rà ra ra rb r* sV
|
|
|
|
ÿ
|
|
zEABackedBlock.putmaskrX c sT | j dkr8| j |¡}| j |¡}t| ||| j dgS | jj dkrHg S t |¡S )NrY rY )rZ rg rZ r r Úsuper)r] r» rg r ©Ú __class__ra rb rZ ò s
|
zEABackedBlock.deletec C s | j S rk rú ro ra ra rb r` ý s zEABackedBlock.array_valuesNra r rb c C s* | j }|tkr| t¡}t |¡ | j¡S )zS
|
return object dtype as boxed values, such as Timestamps/Timedelta
|
)rg r~ rÆ rT rv rS r´ r[ )r] rm rg ra ra rb rc s
|
zEABackedBlock.get_valuesc C s t | j¡S rk )rv rS rg ro ra ra rb rd s z EABackedBlock.values_for_jsonr? r )r@ r rä r= r} rÊ r rh r; )r@ r rä r= rÊ c
|
K sH | j }|jdkr.|dkr.|jj|||dj} n|j|||d} | | ¡S )Nr° r ©r r@ r= )rg rZ r" r> r )
|
r] r@ r rä r= r} rÊ r_ rg r¤ ra ra rb rF s
|
zEABackedBlock.interpolate)F)r1 F)F)N)r re rf rg rh r' r5 r* rZ r r` rc rd rF Ú __classcell__ra ra rr rb rm & s&
|
; ÿFE
|
ørm c s e Zd ZU dZdZdZdZded< d9dddd d
|
fd d Ze d dddZ
|
ddddZ d:ddddddZ dd Z d d Zeddd d Ze d d! Zd"dd#d$d%Zed&d d#d'd(Zd;d*d+d d,d-d.Zd<d*d+d0d d1d2d3Zd4d5d6d7d8Z ZS )=r zñ
|
Block for holding extension types.
|
|
Notes
|
-----
|
This holds all 3rd-party extension array types. It's also the immediate
|
parent class for our internal extension types' blocks.
|
|
ExtensionArrays are limited to 1-D.
|
FTrG rg Nr; rq rW r< c sv t | jr t j|||||dS |r@| jr@| jjs@| j}| j}nd }| jj|d |d}| j||d}|j |g||dS )N)r r= rä rÓ rÊ rt r¡ rÏ )
|
r+ rm rq r> rx rg Z_hasnari r rÕ ) r] r r= rä rÓ rÊ ri r¤ r¶ rr ra rb r> 4 s
|
ûzExtensionBlock.fillnar rX c C s* | j dkrt| jfS t| jt| jfS )NrY )rZ r rg r ro ra ra rb r[ N s
|
zExtensionBlock.shaper )rs c C s t |trn|\}}t |¡s2|dkr2t| dt |trd|dk rR|t| j7 }| j||d
S | j| S |dkrt| d| jS d S )Nr z only contains one itemrY )ru ÚtupleÚcomÚ is_null_slicer\ r£ r rg )r] rs Úcolr» ra ra rb r U s
|
|
|
zExtensionBlock.igetr r
r c C s" |r| j ¡ | _ || j d d
< d S rk r r ra ra rb r q s zExtensionBlock.set_inplacec C sv t |tjtfrF|j| jjd krF|jd dks4t|dd
df }n,t |trr|jd dksbt|j dddj
|
}|S )z@
|
If necessary, squeeze a (N, 1) ndarray to (N,)
|
rY Nr rJ ) ru rv r& rG rZ rg r[ r² r3 Z_ixsrT r ra ra rb r x s ÿþ
|
z!ExtensionBlock._maybe_squeeze_argc C sÜ t |trØt|dkrØtdd |D rn|\}}|jdkrT|dk ¡ rT|jd dks\td|dd
df }njt |d ¡r|d dkr|d }nFt
|
|d ¡rª|d }n.t |d rÐ|d d dkrÐ|d }ntd|S )zw
|
Adapt a 2D-indexer to our 1D values.
|
|
This is intended for 'setitem', not 'iget' or '_slice'.
|
r° c s s$ | ] }t |tjo|jd kV qdS )r° N)ru rv r& rZ rû ra ra rb rù s z9ExtensionBlock._unwrap_setitem_indexer.<locals>.<genexpr>rY r zPThis should not be reached. Please report a bug at github.com/pandas-dev/pandas/N) ru rv r rÿ Úsizer[ r7 r Ú
|
is_integerrw rx r, )r] r ÚfirstÚsecondra ra rb r s. ÿ
|
ÿ ÿÿ
|
|
|
ÿz&ExtensionBlock._unwrap_setitem_indexerc C s dS )z,Extension arrays are never treated as views.Fra ro ra ra rb r_ ¸ s zExtensionBlock.is_viewc C s
|
| j jjS rk )rg rm Z _is_numericro ra ra rb rW ½ s zExtensionBlock.is_numericr r c C sN | j dkrDt|ts td|td| }t|s<td|td}| j| S )zþ
|
Return a slice of my values.
|
|
Parameters
|
----------
|
slicer : slice, ndarray[int], or ndarray[bool]
|
Valid (non-reducing) indexer for self.values.
|
|
Returns
|
-------
|
ExtensionArray
|
r° z+invalid slicing for a 1-ndim ExtensionArrayrY N)rZ ru r£ r² Úranger rg )r] r Znew_locsra ra rb r¢ Á s
|
|
ÿ ÿzExtensionBlock._slicer£ c C s$ | j | }t| || j| j| jdS )zN
|
Perform __getitem__-like specialized to slicing along index.
|
)rZ ri )rg r r rZ ri )r] r r¤ ra ra rb Úgetitem_block_indexé s
|
z"ExtensionBlock.getitem_block_indexrY rh r rI c C s t j| j|dd}| j|dgS )Nr rJ rú rK rM ra ra rb rL ó s zExtensionBlock.diffr r rN c C s | j j||d}| |¡gS )z
|
Shift the block by `periods`.
|
|
Dispatches to underlying ExtensionArray and re-boxes in an
|
ExtensionBlock.
|
)rO r} ©rg rD r )r] rO r r} r¤ ra ra rb rD ù s zExtensionBlock.shiftr r r c sD |j \}}|j| }|| } fddtt||D }||fS )Nc s< g | ]4\}\}}t jj|| d t|ddqS ))r r} r° r )r rg Ztaker )r rs ÚindicesZplace©r} r r] ra rb r ! s
|
ù ÿûz+ExtensionBlock._unstack.<locals>.<listcomp>)Z arange_resultr" r¸ rü )r] r$ r} r r r¤ rå rÉ ra r rb r% s
|
|
÷ zExtensionBlock._unstack)NFNF)F)rY )r N)r re rf rg rl rj r rh r> r r[ r r r r rk r_ rW r¢ r
|
r rL rD r% ru ra ra rr rb r " s8
|
ú *
|
( ÿ r c @ sZ e Zd ZU ded< eddddZedddd Zdd dd d dZddddZd
|
S )Ú
|
NumpyBlockr rg rq rX c C s | j jdk S r^ )rg Úbasero ra ra rb r_ 2 s zNumpyBlock.is_viewrG c C s
|
t | jS rk )rI rg ro ra ra rb r` 7 s zNumpyBlock.array_valuesNra rb c C s |t kr| j t ¡S | jS rk )r~ rg rÆ ry ra ra rb rc ; s zNumpyBlock.get_valuesc C s | j S rk rú ro ra ra rb rd @ s zNumpyBlock.values_for_json)N) r re rf rh rk r_ r` rc rd ra ra ra rb r / s
|
r c @ s e Zd ZdZdZdS )Ú NumericBlockra TN)r re rf ri rW ra ra ra rb r
D s r
c @ sh e Zd ZU dZded< eddddZedddd Zdd d d dddZ dd d dd dddZ
|
dS )ro z8
|
Block backed by an NDArrayBackedExtensionArray
|
rS rg rq rX c C s t | jtj S rk )ru rm rv ro ra ra rb r Q s z(NDArrayBackedExtensionBlock.is_extensionc C s | j jjdk S r^ )rg Ú_ndarrayr ro ra ra rb r_ V s z#NDArrayBackedExtensionBlock.is_viewr rh r rW rI c C s$ | j }||j||d }| |¡gS )a
|
1st discrete difference.
|
|
Parameters
|
----------
|
n : int
|
Number of periods to diff.
|
axis : int, default 0
|
Axis to diff upon.
|
|
Returns
|
-------
|
A list with a new Block.
|
|
Notes
|
-----
|
The arguments here are mimicking shift so they are called correctly
|
by apply.
|
rJ )rg rD r )r] r/ r rg r¤ ra ra rb rL \ s z NDArrayBackedExtensionBlock.diffNr rN c C s" | j }|j|||d}| |¡gS )N)r} r r )r] rO r r} rg r¤ ra ra rb rD v s z!NDArrayBackedExtensionBlock.shift)r )r N) r re rf rg rh r r rk r_ rL rD ra ra ra rb ro I s
|
ÿro Ú Exceptionr
)rp rV c C s& t | tr"t | trn dt| kr"dS )z
|
We catch ValueError for now, but only a specific one raised by DatetimeArray
|
which will no longer be raised in version.2.0.
|
z'value.closed' isN)ru r¦ r r )rp ra ra rb rn ~ s
|
|
|
rn c @ sZ e Zd ZU dZdZdZded< dddd Zd
|
d d dd d dd dddddddddZd S )ÚDatetimeLikeBlockz*Block for datetime64[ns], timedelta64[ns].ra Fz DatetimeArray | TimedeltaArrayrg r rX c C s | j jS rk )rg r ro ra ra rb rd s z!DatetimeLikeBlock.values_for_jsonr? Nr )r@ rA r rä r= r} rÊ r rD rh rq r; )r@ rA r rä r= rÊ c K sÊ | j } |dkrd }
|
|r>|r2| j ¡ s2| j} | j}
|
qR| j ¡ } n|rH| jn| j ¡ } tj| ||||d t| j| | j d} | j
|
| |
|
dS | j dkr°|dkr°| j j |||dj } n| j |||d} |
|
| ¡S )NrP )r@ r= rA r r× r¡ r° r rt )rg ri ré r rÅ r: rG r Z _simple_newrm r rZ r" r> ) r] r@ rA r rä r= r} rÊ r_ rg ri Zdata_outr¤ ra ra rb rF s, ÿz DatetimeLikeBlock.interpolate) r re rf rg ri rW rh rd rF ra ra ra rb r s
|
÷r c @ s0 e Zd ZU dZded< dZdZdZdZe j
|
Z
|
dS )ÚDatetimeTZBlockz0implement a datetime64 block with a tz attributerF rg ra TFN) r re rf rg rh ri r rj rl ro rd ra ra ra rb r ¿ s
|
r c @ s2 e Zd ZdZdZeddddddddd Zd
|
S ) Ú ObjectBlockra TFrØ rq rW rÙ c C s | j tkr"|r | jddgS | gS | j}|jdkr:|d }tj|ddddd}d}|rh||krh| ¡ }n||krz|rz| j}t|| j}| j ||dgS ) z
|
attempt to cast any object types to better types return a copy of
|
the block (if copy = True) by definition we ARE an ObjectBlock!!!!!
|
FrÚ r° r T)Zconvert_datetimeZconvert_timedeltaZconvert_periodZconvert_intervalNr¡ )
|
rm r~ rÅ rg rZ r Zmaybe_convert_objectsri r r )r] rÅ rÊ rg rµ ri ra ra rb rÌ Ò s*
|
|
û
|
zObjectBlock.convertN)r re rf ri rí rd rÌ ra ra ra rb r Î s ür r )rg rV c C sV t | tjr0t| } t| jjtr0tj| t d} t | t
|
t frR| j dk rR| d¡} | S )a:
|
Input validation for values passed to __init__. Ensure that
|
any datetime64/timedelta64 dtypes are in nanoseconds. Ensure
|
that we do not have string dtypes.
|
|
Parameters
|
----------
|
values : np.ndarray or ExtensionArray
|
|
Returns
|
-------
|
values : np.ndarray or ExtensionArray
|
r× N)ru rv r& rO Ú
|
issubclassrm r r r³ rT rF rK ÚfreqZ
|
_with_freqrú ra ra rb rÞ ÿ s
|
rÞ r r× c C sj | j }t| trt}nPt| tr&t}n@t| tr6t}n0t| trFt}n |dkrTt }n|dkrbt
|
}nt }|S )zÑ
|
Find the appropriate Block subclass to use for the given values and dtype.
|
|
Parameters
|
----------
|
dtype : numpy or pandas dtype
|
|
Returns
|
-------
|
cls : class, subclass of Block
|
)ÚMr )rE Úcrs rt rr ) rw ru rL r r/ r r2 ro r0 r r
r )rm rw Úclsra ra rb Úget_block_type s
|
|
|
|
r r r )rg r ri c C s" t | j}t| } || d||dS )Nr° ©rZ r ri )r rm rÞ )rg r ri Úklassra ra rb r# B s
|
r# r¡ rh )rZ ri rV c C s@ t |tst|}t| || t| j}t| } || |||dS )Nr )ru r Ú
|
check_ndimr rm rÞ )rg r rZ ri r ra ra rb r O s
|
|
r )r rZ rV c C s | j |kr"td| j d| dt| js|| j |krNtd| j d| dt|t| krtdt| dt| n |dkrt|d krtd
|
d S ) aV
|
ndim inference and validation.
|
|
Validates that values.ndim and ndim are consistent.
|
Validates that len(values) and len(placement) are consistent.
|
|
Parameters
|
----------
|
values : array-like
|
placement : BlockPlacement
|
ndim : int
|
|
Raises
|
------
|
ValueError : the number of dimensions do not match
|
z0Wrong number of dimensions. values.ndim > ndim [z > ú]z1Wrong number of dimensions. values.ndim != ndim [z != z Wrong number of items passed z, placement implies r° rY z need to splitN)rZ r¦ r( rm r )rg r rZ ra ra rb r _ s
|
ÿ
|
|
ÿÿr rf ra z3tuple[np.ndarray | ExtensionArray, DtypeObj | None])rg rm rZ rV c C s@ t | tr(| ¡ } |r(|dkr(t | ¡} t |tr8|j}| |fS )zL
|
Ensure that we don't allow PandasArray / PandasDtype in internals.
|
rY )ru r5 Zto_numpyrv Z
|
atleast_2dr1 Z numpy_dtype)rg rm rZ ra ra rb Úextract_pandas_array s
|
|
|
r rW rX c C sf |dkr g }t | trB| D ]$}t |tr4| |¡ q| |¡ qn t | tsXtt| | | ¡ |S )z.return a new extended blocks, given the resultN)ru rý rÁ r¹ re r² r )r rÉ Úrra ra rb rÔ s
|
|
|
rÔ rY )rg rZ rV c C s. | j |k r*t| js*td| } | dd¡} | S )z:
|
Reshape if possible to have values.ndim == ndim.
|
z+np.ndarray | DatetimeArray | TimedeltaArrayrY r± )rZ r( rm r r´ )rg rZ ra ra rb r ¯ s
|
|
|
|
r rß Ú.)rà râ Ú float_formatÚdecimalr r )rg rà r rV c K s0 t | tr2| jjjdkr2tj| jjt| j |d} t
|
| } t | t t frÌ| j dkrx| jf d|i|}|jtdd}|S g }tt| D ]8}| |dd
f jf d|i|}| |jtdd¡ qt |¡S | jjdkrtt| st|dkr:|d kr:t| } |s| t¡} ntj| d
|
d } || | < | jtdd} | S d d lm}
|
|
|
| ||||dd} | ¡ } | jtdd} | S t | t r¤t| } t | t¡¡} || | < | S t| } t |¡}| jt!kr|s|r| t¡} | jj"t d¡j" |k r| d| ¡} ntj| d
|
d } || | < | jtdd} | S dS )rá ZMmr rY rà FrÄ NrE r rT r× r )ÚFloatArrayFormatter)rà r r râ Z fixed_widthZU1z<U)#ru rE Ú
|
categoriesrm rw r r rT r' Ú_codesrO rF rK rZ Z_format_native_typesrÆ rT r~ r r¹ rv Zvstackr- r8 r r³ Zpandas.io.formats.formatr Zget_result_as_arrayrG rS r Zword_lenr~ Úitemsize)rg rà râ r r r_ r Zresults_convertedrs rå r Ú formatterÚresr¤ r ra ra rb rã ¿ sj
|
ý
|
|
ú
|
|
rã c C sR t | ttfr| t¡S t | ttfr,| j} t | tj rNt
|
rN| ¡ } d| j _ | S )a+
|
The array that Series.values returns (public attribute).
|
|
This has some historical constraints, and is overridden in block
|
subclasses to return the correct array (e.g. period returns
|
object ndarray and datetimetz a datetime64[ns] ndarray instead of
|
proper extension array).
|
F)ru rJ rH rÆ rT rF rK r rv r& r ÚviewÚflagsZ writeablerú ra ra rb r{
|
s
|
r{ )N)N)rY )Ú
|
__future__r Ú functoolsr rï Útypingr r r r r r r
|
Únumpyrv Zpandas._configr Z pandas._libsr Z libinternalsr r Zpandas._libs.internalsr r Zpandas._libs.missingr Zpandas._libs.tslibsr Zpandas._typingr r r r r r r r r Z pandas.errorsr Zpandas.util._decoratorsr Zpandas.util._validatorsr Zpandas.core.dtypes.astyper r! Zpandas.core.dtypes.castr" r# r$ r% r& Zpandas.core.dtypes.commonr' r( r) r* r+ r, r- r. Zpandas.core.dtypes.dtypesr/ r0 r1 r2 Zpandas.core.dtypes.genericr3 r4 r5 r6 Zpandas.core.dtypes.missingr7 r8 r9 Z pandas.corer: Zpandas.core.algorithmsÚcoreZ
|
algorithmsr Z pandas.core.array_algos.putmaskr; r< r= r> r? Z pandas.core.array_algos.quantiler@ Z pandas.core.array_algos.replacerA rB rC Z"pandas.core.array_algos.transformsrD Zpandas.core.arraysrE rF rG rH rI rJ rK Zpandas.core.arrays.sparserL Zpandas.core.baserM Zpandas.core.commonÚcommonrw Zpandas.core.computationrN Zpandas.core.constructionrO rP Zpandas.core.indexersrQ Zpandas.core.apirR Zpandas.core.arrays._mixinsrS rm r~ rd re rm r r r
ZNDArrayBackedBlockro rn r r r rÞ r r# r r r rÔ r rã r{ ra ra ra rb Ú<module> s $
|
, (
|
$
|
! } 5 41 ' ÿÿ*úW
|
