U
|
¬ý°dA ã @ sâ d dl mZ d dlZd dlmZmZmZmZmZm Z m
|
Z
|
d dl Z d dl Z d dl Zd dlmZ d dlmZmZmZ d dlmZmZ d dlmZm Z m Z m Z m Z m Z m!Z! d dl"m#Z# d d l$m%Z% d d
|
l&m'Z' d d l(m)Z) d d l*m+Z+ d d l,m-Z-m.Z.m/Z/m0Z0 d dl1m2Z2 d dl3m4Z4m5Z5 d dl6m7Z7m8Z8 d dl9m: m;Z d dl<m=Z= d dl>m?Z? d dl@m: mAZB d dlCmDZDmEZE d dlFmGZG d dlHmIZImJZJ d dlKmLZLmMZMmNZN d dlOmPZPmQZQmRZRmSZSmTZTmUZUmVZV d dlWmXZXmYZY e dddZZG d d deLZ[G d d d ej\e[Z\G d d d e[eMZ]dSd"d#d$d$d d%d&d'Z^d(d#d$d)d d*d+d,Z_dTd-d.d#d/d0d1d2Z`d3d4d5d6d7Zad(d$d)d"d8d9d:Zbd"d;d<d=Zcd>d?d@dAZddBdBdCdDdEZed"dFd$dGdHdIdJZfdKdLdMdNZgdOd-d$dPdQdRZhdS )Ué )Ú annotationsN)ÚAnyÚCallableÚHashableÚLiteralÚSequenceÚTypeVarÚcast)Úusing_copy_on_write)ÚalgosÚ internalsÚlib)ÚBlockPlacementÚBlockValuesRefs)Ú ArrayLikeÚAxisIntÚDtypeObjÚQuantileInterpolationÚShapeÚnptÚtype_t)ÚPerformanceWarning)Úcache_readonly)Úfind_stack_level)Úvalidate_bool_kwarg)Úinfer_dtype_from_scalar)Úensure_platform_intÚis_1d_only_ea_dtypeÚis_dtype_equalÚ is_list_like)ÚExtensionDtype)Ú ABCDataFrameÚ ABCSeries)Ú array_equalsÚisna)ÚNDArrayBackedExtensionArray)Ú SparseDtype)Ú ensure_wrapped_if_datetimelikeÚ extract_array)Úmaybe_convert_indices)ÚIndexÚ ensure_index)Ú DataManagerÚSingleDataManagerÚinterleaved_dtype)ÚBlockÚ
|
NumpyBlockÚensure_block_shapeÚ extend_blocksÚget_block_typeÚ new_blockÚ new_block_2d)Ú blockwise_allÚoperate_blockwiseÚTÚBaseBlockManager)Úboundc @ sÀ e Zd ZU dZdZded< ded< ded< ded < ed
|
d d d Zded< ded< ddddddZe dddddddZ
|
edd d d Z edd d d Z d ddd!d"d#Z dd d$d%ZeZd&d
|
d'd(d)Zd&d*dd+d,d-Zedd d.d/Zed*d d0d1Zd
|
dd2d3d4Zd
|
dd5d6d7Zd dd8d9d:Zd d
|
dd;d<d=Zd>d? Zed@d dAdBZdCd dDdEZd¡ddFddGdHdIZddddJdKdLZ d¢dd
|
dddNdOdPZ ddd!dQdRZ d£ddSdTdUZ dd
|
d&ddVdWdXZ ddddYdZd[Z!dd
|
d&dd\d]d^Z"ddddYd_d`Z#d¤ddbdCddcdddeZ$ddbddfdgdhZ%ddddYdidjZ&dkdl Z'd¥ddmdmddddndodpZ(ddd!dqdrZ)edd dsdtZ*edd dudvZ+edd dwdxZ,ddyddzd{d|Z-d¦ddddfd}d~Z.d§ddddfddZ/d¨ddddddddZ0ed
|
d d
dZ1d©ddddddZ2ddd!ddZ3dªdMddd*dd&ddbdddd ddZ4e5j6dMfdMddddddddZ7d«ddddddZ8d¬dd&ddddddZ9d S )r9 a¡
|
Core internal data structure to implement DataFrame, Series, etc.
|
|
Manage a bunch of labeled 2D mixed-type ndarrays. Essentially it's a
|
lightweight blocked set of labeled data to be manipulated by the DataFrame
|
public API class
|
|
Attributes
|
----------
|
shape
|
ndim
|
axes
|
values
|
items
|
|
Methods
|
-------
|
set_axis(axis, new_labels)
|
copy(deep=True)
|
|
get_dtypes
|
|
apply(func, axes, block_filter_fn)
|
|
get_bool_data
|
get_numeric_data
|
|
get_slice(slice_like, axis)
|
get(label)
|
iget(loc)
|
|
take(indexer, axis)
|
reindex_axis(new_labels, axis)
|
reindex_indexer(new_labels, indexer, axis)
|
|
delete(label)
|
insert(loc, label, value)
|
set(label, value)
|
|
Parameters
|
----------
|
blocks: Sequence of Block
|
axes: Sequence of Index
|
verify_integrity: bool, default True
|
|
Notes
|
-----
|
This is *not* a public API class
|
© únpt.NDArray[np.intp]Ú_blknosÚ_blklocsútuple[Block, ...]Úblocksú list[Index]ÚaxesÚint©Úreturnc C s t d S ©N©ÚNotImplementedError©Úselfr; r; úUd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/internals/managers.pyÚndim s zBaseBlockManager.ndimÚboolÚ_known_consolidatedÚ_is_consolidatedTÚNone)Úverify_integrityrE c C s t d S rF rG )rJ r@ rB rQ r; r; rK Ú__init__ s zBaseBlockManager.__init__z type_t[T]ú list[Block]r8 )Úclsr@ rB rE c C s t d S rF rG ©rT r@ rB r; r; rK Ú from_blocks£ s z BaseBlockManager.from_blocksc C s | j dkr| ¡ | j S )a
|
|
Suppose we want to find the array corresponding to our i'th column.
|
|
blknos[i] identifies the block from self.blocks that contains this column.
|
|
blklocs[i] identifies the column of interest within
|
self.blocks[self.blknos[i]]
|
N)r= Ú_rebuild_blknos_and_blklocsrI r; r; rK Úblknos§ s
|
|
zBaseBlockManager.blknosc C s | j dkr| ¡ | j S )z$
|
See blknos.__doc__
|
N)r> rW rI r; r; rK Úblklocs· s
|
zBaseBlockManager.blklocsN)rJ rE c C s |dkr t g g| jdd
}| jdkrtt| ts8t| jd }|jdd
}tt dd}|j
|
||d}|g}ng }t | ||¡S )z9return an empty BlockManager with the items axis of len 0Né r ©Ú placement) r* rB rL Ú
|
isinstanceÚSingleBlockManagerÚAssertionErrorr@ Úvaluesr ÚsliceZmake_block_same_classÚtyperV )rJ rB ÚblkÚarrÚbpÚnbr@ r; r; rK Ú
|
make_empty s
|
|
zBaseBlockManager.make_emptyc C s dS ©NTr; rI r; r; rK Ú __nonzero__Ó s z BaseBlockManager.__nonzero__r )ÚaxisrE c C s | j dkr|dkrdnd}|S )Né r rZ ©rL )rJ rj r; r; rK Ú_normalize_axisÙ s
|
z BaseBlockManager._normalize_axisr* )rj Ú
|
new_labelsrE c C s | ||¡ || j|< d S rF )Z_validate_set_axisrB )rJ rj rn r; r; rK Úset_axisß s zBaseBlockManager.set_axisc C s t | jdkS ©NrZ ©Úlenr@ rI r; r; rK Úis_single_blockä s z BaseBlockManager.is_single_blockc C s
|
| j d S ©Nr ©rB rI r; r; rK Úitemsé s zBaseBlockManager.items©ÚirE c C s | j | }| |¡S )ú¾
|
Check for column `i` if it has references.
|
(whether it references another array or is itself being referenced)
|
Returns True if the column has no references.
|
)rX Ú_has_no_reference_block)rJ rx Úblknor; r; rK Ú_has_no_referenceí s
|
z"BaseBlockManager._has_no_reference)r{ rE c C s | j | j ¡ S )z¼
|
Check for block `i` if it has references.
|
(whether it references another array or is itself being referenced)
|
Returns True if the block has no references.
|
©r@ ÚrefsZ has_reference)rJ r{ r; r; rK rz ö s z(BaseBlockManager._has_no_reference_block)ÚmgrrE c C sJ t | jt |jkrdS t| jD ]"\}}|j| j|_|j |¡ q"dS )z
|
Adds the references from one manager to another. We assume that both
|
managers have the same block structure.
|
N)rr r@ Ú enumerater~ Z add_reference)rJ r rx rc r; r; rK Úadd_referencesþ s
|
z BaseBlockManager.add_references)r r{ rE c C s" t | j| ¡}||j| jjkS )zv
|
Checks if two blocks from two different block managers reference the
|
same underlying values.
|
)ÚweakrefÚrefr@ r~ Zreferenced_blocks)rJ r r{ r r; r; rK Úreferences_same_values s z'BaseBlockManager.references_same_valuesc C s" t dd | jD ¡}| | j¡S )Nc S s g | ]
|
}|j qS r; ©Údtype©Ú.0rc r; r; rK Ú
|
<listcomp> s z/BaseBlockManager.get_dtypes.<locals>.<listcomp>)ÚnpÚarrayr@ ÚtakerX ©rJ Zdtypesr; r; rK Ú
|
get_dtypes s zBaseBlockManager.get_dtypesúlist[ArrayLike]c C s dd | j D S )aµ
|
Quick access to the backing arrays of the Blocks.
|
|
Only for compatibility with ArrayManager for testing convenience.
|
Not to be used in actual code, and return value is not the same as the
|
ArrayManager method (list of 1D arrays vs iterator of 2D ndarrays / 1D EAs).
|
|
Warning! The returned arrays don't handle Copy-on-Write, so this should
|
be used with caution (only in read-mode).
|
c S s g | ]
|
}|j qS r; ©r` r r; r; rK r $ s z+BaseBlockManager.arrays.<locals>.<listcomp>©r@ rI r; r; rK Úarrays s zBaseBlockManager.arraysÚstrc C sh t | j}t| jD ]4\}}|dkr4|d| 7 }q|d| d| 7 }q| jD ]}|d| 7 }qP|S )Nr z
|
Items: z
|
Axis z: Ú
|
)rb Ú__name__r rB r@ )rJ Úoutputrx ÚaxÚblockr; r; rK Ú__repr__& s
|
|
zBaseBlockManager.__repr__zlist[str] | None)rJ Ú
|
align_keysrE c sð d ks t |pg }g } fdd|D }| jD ]¨}|r¦| ¡ D ]d\}}t|ttfr|jdkrv|j|jj j
|
|< q¤|jdd
|jj f j
|
|< q@||jj |< q@t |r¾|j |f } nt ||f } t| |}q0t| || j¡}
|
|
|
S )ab
|
Iterate over the blocks, collect and create a new BlockManager.
|
|
Parameters
|
----------
|
f : str or callable
|
Name of the Block method to apply.
|
align_keys: List[str] or None, default None
|
**kwargs
|
Keywords to pass to `f`
|
|
Returns
|
-------
|
BlockManager
|
Úfilterc s i | ]}| | qS r; r; )r Úk©Úkwargsr; rK Ú
|
<dictcomp>M s z*BaseBlockManager.apply.<locals>.<dictcomp>rZ N)r_ r@ rv r] r" r! rL ÚilocÚmgr_locsÚindexerZ_valuesÚcallableÚapplyÚgetattrr2 rb rV rB ) rJ Úfr r Ú result_blocksZ aligned_argsÚbr ÚobjÚappliedÚoutr; r rK r¤ 2 s$
|
|
zBaseBlockManager.apply)rJ ÚalignrE c C s6 |rddg}ndg}t |dd}| jd|||t dS )NÚotherÚcondT©Z extract_numpyÚwhere)r r r® Ú using_cow©r( r¤ r
|
)rJ r r® r¬ r r; r; rK r° f s
|
ûzBaseBlockManager.whereF)rJ Údecimalsr± rE c C s | j d||dS )NÚround)r³ r± ©r¤ )rJ r³ r± r; r; rK r´ u s
|
ýzBaseBlockManager.roundc C sP t |tjr(|j| jkr(td| j t r@| d¡s@| ¡ } | jd||dS )zi
|
Set values with indexer.
|
|
For SingleBlockManager, this backs s[indexer] = value
|
z Cannot set values with ndim > r Úsetitem)r¢ Úvalue) r] r ÚndarrayrL Ú
|
ValueErrorr
|
r| Úcopyr¤ ©rJ r¢ r· r; r; rK r¶ | s
|
zBaseBlockManager.setitem)r¬ c C s6 |rddg}ndg}t |dd}| jd|||t dS )NÚnewÚmaskTr¯ Úputmask)r r½ r¼ r± r² )rJ r½ r¼ r¬ r r; r; rK r¾ s
|
ûzBaseBlockManager.putmask)rJ Únrj rE c C s | |¡}| jd||dS )NÚdiff)r¿ rj )rm r¤ )rJ r¿ rj r; r; rK rÀ s
|
zBaseBlockManager.diff)rJ ÚinplacerE c K s | j dd|i|dt iS )NÚ interpolaterÁ r± )r ©r¤ r
|
)rJ rÁ r r; r; rK r s ÿÿÿÿz BaseBlockManager.interpolate)rJ Úperiodsrj rE c C s* | |¡}|tjkrd }| jd|||dS )NÚshift)rÄ rj Ú
|
fill_value)rm r Ú
|
no_defaultr¤ )rJ rÄ rj rÆ r; r; rK rÅ ¥ s
|
|
zBaseBlockManager.shiftc C s. |d k rt jd |d}| jd||||t dS )N)ÚlimitÚfillna)r· rÈ rÁ Údowncastr± )ÚlibalgosZvalidate_limitr¤ r
|
)rJ r· rÈ rÁ rÊ r; r; rK rÉ ¬ s úzBaseBlockManager.fillnaÚraisez bool | None)rJ rº ÚerrorsrE c C s: |d krt rd}q$d}n
|
t r$d}| jd|||t dS )NFTÚastype)r rº rÍ r± ©r
|
r¤ )rJ r rº rÍ r; r; rK rÎ º s ûzBaseBlockManager.astype)rJ rº rE c C s6 |d krt rd}q$d}n
|
t r$d}| jd|t dS )NFTÚconvert)rº r± rÏ ©rJ rº r; r; rK rÐ Ë s zBaseBlockManager.convertc C s8 t |d}t|rtt|r"t| jd|||t dS )NrÁ Úreplace)Ú
|
to_replacer· rÁ r± )r r r_ r¤ r
|
)rJ rÓ r· rÁ r; r; rK rÒ Ö s
|
ûzBaseBlockManager.replacec K s | j d|dt iS )NÚ_replace_regexr± )rÔ rà ©rJ r r; r; rK Ú replace_regexã s z BaseBlockManager.replace_regexz list[Any])rJ Úsrc_listÚ dest_listrÁ ÚregexrE c C s. t |d}| jd||||t d}| ¡ |S )zdo a list replacerÁ Ú replace_list)r× rØ rÁ rÙ r± )r r¤ r
|
Ú_consolidate_inplace)rJ r× rØ rÁ rÙ Úbmr; r; rK rÚ æ s
|
úz BaseBlockManager.replace_listc K s | j d|S )z}
|
Convert values to native types (strings / python objects) that are used
|
in formatting (repr / csv).
|
Úto_native_types)rÝ rµ rÕ r; r; rK rÝ û s z BaseBlockManager.to_native_typesc C s t dd | jD S )Nc s s | ] }|j V qd S rF ©Ú
|
is_numeric©r r r; r; rK Ú <genexpr> s z9BaseBlockManager.is_numeric_mixed_type.<locals>.<genexpr>)Úallr@ rI r; r; rK Úis_numeric_mixed_type s z&BaseBlockManager.is_numeric_mixed_typec C s t dd | jD S )z>Whether any of the blocks in this manager are extension blocksc s s | ] }|j V qd S rF ©Ú is_extensionrà r; r; rK rá s z7BaseBlockManager.any_extension_types.<locals>.<genexpr>)Úanyr@ rI r; r; rK Úany_extension_types s z$BaseBlockManager.any_extension_typesc C s t | jdkr| jd jS dS )z8return a boolean if we are a single block and are a viewrZ r F)rr r@ Úis_viewrI r; r; rK rè s zBaseBlockManager.is_viewr )rJ Ú predicaterE c s" fdd| j D }| j|ddS )Nc s g | ]} |j r|qS r; r r ©ré r; rK r s
|
z5BaseBlockManager._get_data_subset.<locals>.<listcomp>F©rº )r@ Ú_combine)rJ ré r@ r; rê rK Ú_get_data_subset s z!BaseBlockManager._get_data_subsetc C sZ g }| j D ]B}|jtkr$| |¡ q
|
|jr
|
| ¡ }|D ]}|jr6| |¡ q6q
|
| ||¡S )zä
|
Select blocks that are bool-dtype and columns from object-dtype blocks
|
that are all-bool.
|
|
Parameters
|
----------
|
copy : bool, default False
|
Whether to copy the blocks
|
)r@ r rM ÚappendÚ is_objectÚ_splitZis_boolrì )rJ rº Ú
|
new_blocksrc Únbsrf r; r; rK Ú get_bool_data s
|
|
z BaseBlockManager.get_bool_datac C sB dd | j D }t|t| j kr6|r2| jddS | S | ||¡S )zy
|
Parameters
|
----------
|
copy : bool, default False
|
Whether to copy the blocks
|
c S s g | ]}|j r|qS r; rÞ r r; r; rK r > s z5BaseBlockManager.get_numeric_data.<locals>.<listcomp>T©Údeep)r@ rr rº rì )rJ rº Znumeric_blocksr; r; rK Úget_numeric_data7 s z!BaseBlockManager.get_numeric_dataz Index | None)rJ r@ rº ÚindexrE c
|
C sþ t |dkrb| jdkrZ|dk r2| jdd
|g}n | jdd
g| jdd
}| |¡S | ¡ S t t dd |D ¡¡}t || j
|
d ¡}g }|D ],}|j |d} t || j j | _ | | ¡ qt| j}|dk rÞ||d< | j |¡|d< t| ||¡S ) z$return a new manager with the blocksr rk NrZ c S s g | ] }|j jqS r; ©r¡ Úas_array©r r¨ r; r; rK r U s z-BaseBlockManager._combine.<locals>.<listcomp>rô éÿÿÿÿ)rr rL rv rB rg r ÚsortÚ concatenater Zget_reverse_indexerÚshaperº r r¡ r¢ rî Úlistr rb rV )
|
rJ r@ rº r÷ rB r¢ Z inv_indexerrñ r¨ rf r; r; rK rì F s&
|
|
|
zBaseBlockManager._combinec C s
|
t | jS rF rq rI r; r; rK Únblocksh s zBaseBlockManager.nblocksz bool | None | Literal['all'])rJ rõ rE c s dkrt rdndr>fdd fdd| jD }n
|
t| j}| jdd }||_| jd
|
kr| j}|dk r| ¡ |_| j ¡ |_r| ¡ |S ) aN
|
Make deep or shallow copy of BlockManager
|
|
Parameters
|
----------
|
deep : bool, string or None, default True
|
If False or None, return a shallow copy (do not copy data)
|
If 'all', copy data and a deep copy of the index
|
|
Returns
|
-------
|
BlockManager
|
NFTc s dkr| j ddS | ¡ S )Nrâ Trô )rº Úview)r rô r; rK Ú copy_func s z(BaseBlockManager.copy.<locals>.copy_funcc s g | ] } |qS r; r; ©r r )r r; rK r s z)BaseBlockManager.copy.<locals>.<listcomp>rº rô rZ ) r
|
rB rÿ r¤ rL r= rº r> rÛ )rJ rõ Únew_axesÚresrX r; )r rõ rK rº l s$
|
|
|
zBaseBlockManager.copyc C s4 | ¡ r | S t| | j| jdd}d|_| ¡ |S )zr
|
Join together blocks having same dtype
|
|
Returns
|
-------
|
y : BlockManager
|
F©rQ )Úis_consolidatedrb r@ rB rO rÛ )rJ rÜ r; r; rK Ú consolidate s z BaseBlockManager.consolidate)Ú use_na_proxyznpt.NDArray[np.intp] | None) rJ Únew_axisr¢ rj Ú
|
allow_dupsrº Ú
|
only_slicer rE c s |dkrt rd}nd}dkr\|| j| kr6|s6| S | j|d} t| j| _|| j|< | S ttjslt|s| j| ¡ || j krt
|
d|dkr®| j ||d}
|
n fdd | j D }
|
t| j} || |< t | |
|
| ¡} |d
|
kr| j ¡ | _| j ¡ | _| S ) a?
|
Parameters
|
----------
|
new_axis : Index
|
indexer : ndarray[intp] or None
|
axis : int
|
fill_value : object, default None
|
allow_dups : bool, default False
|
copy : bool or None, default True
|
If None, regard as False to get shallow copy.
|
only_slice : bool, default False
|
Whether to take views, not copies, along columns.
|
use_na_proxy : bool, default False
|
Whether to use a np.void ndarray for newly introduced columns.
|
|
pandas-indexer with -1's only.
|
NFTrô ú#Requested axis not found in managerr )rÆ r r c s* g | ]"}|j d dk r n|jdqS )rZ N)rj rÆ )Útake_ndrÆ r ©rÆ r¢ r; rK r ë s ùüz4BaseBlockManager.reindex_indexer.<locals>.<listcomp>rZ )r
|
rB rº rÿ r] r r¸ r_ Z_validate_can_reindexrL Ú
|
IndexErrorÚ_slice_take_blocks_ax0r@ rb rV rX r= rY r> ) rJ r
|
r¢ rj rÆ r rº r r Úresultrñ r Únew_mgrr; r rK Úreindex_indexer« sB
|
|
ü ø
|
|
z BaseBlockManager.reindex_indexerúslice | np.ndarray)Úslice_or_indexerr r rE c s |t jk }t|| jd |d\}}}| jrÊ| jd |dkrf|dkrHg S ttd|} j|| dgS |rt| j dkrÊ|r|dkr j
|
}|s¨|r¨ fddt |D }
|
|
|
S ttd|} j |d| |d gS |dkrè| j | } | j| } n(tj | j |d
|
|d } tj | j|d
|
|d } g }
|
| } tj| | d D ]T\}}|d
|
krV|
|
| j|||d ¡ q(| j| js¶ js¶|pzt }|D ]0} j|d}tt||d |_|
|
|¡ qnÆ| |j }tt|| ¡ d }|sät rðt ||¡}t |tr j||d}|
|
|¡ nf|rbt ||D ]8\}}t||d }t|} j|| d}|
|
|¡ q&n j |d|d}|
|
|¡ q(|
|
S )ab
|
Slice/take blocks along axis=0.
|
|
Overloaded for SingleBlock
|
|
Parameters
|
----------
|
slice_or_indexer : slice or np.ndarray[int64]
|
fill_value : scalar, default lib.no_default
|
only_slice : bool, default False
|
If True, we always return views on existing arrays, never copies.
|
This is used when called from ops.blockwise.operate_blockwise.
|
use_na_proxy : bool, default False
|
Whether to use a np.void ndarray for newly introduced columns.
|
|
Returns
|
-------
|
new_blocks : list of Block
|
r )Ú
|
allow_fillra ©Ú new_mgr_locsrZ Nc s, g | ]$\}} j t||d t|dqS )rZ r )Úgetitem_block_columnsra r )r rx Úml©rc r; rK r 2 s
|
ý ÿz;BaseBlockManager._slice_take_blocks_ax0.<locals>.<listcomp>)rj r rÆ rû )rÆ r ©Úgroup)r\ rÆ r rô )rj r ) r rÇ Ú _preprocess_slice_or_indexerrþ rs r@ r ra r rL rÆ r r rX rY r Ú libinternalsÚget_blkno_placementsrî Ú_make_na_blockÚ_can_consolidateZ_validate_ndimr
|
rº r¡ r¢ Úmaxrr Zmaybe_indices_to_slicer] Úzip)rJ r rÆ r r r Zsl_typeÚslobjZsllenre r@ rX rY r r{ r¡ rõ Úmgr_locZnewblkÚtakerÚmax_lenrf rx r Zslcr; r rK r s
|
ÿ
|
|
üüÿ
|
ÿ ÿ
|
ýÿ
|
|
z'BaseBlockManager._slice_take_blocks_ax0r r/ )r\ r rE c
|
C s |rD|d kst t|| jd f}tj|tjd}t||dd}|S |d krRtj}t| j}t||d< t |\}}tj||d} |
|
|¡ t | |dS )NrZ r
rk rl r r[ ) r_ rr rþ r ÚemptyZvoidr0 Únanrÿ r Úfillr5 )
|
rJ r\ rÆ r rþ Úvalsrf Ú block_shaper Ú block_valuesr; r; rK r" s
|
|
z BaseBlockManager._make_na_blockrZ )rJ rj ÚverifyÚconvert_indicesrE c C st t |tr$tj|j|j|jtjdntj|tjd}| j | }|rPt
|
|||d}| j | |¡}| j |||dddS )aÖ
|
Take items along any axis.
|
|
indexer : np.ndarray or slice
|
axis : int, default 1
|
verify : bool, default True
|
Check that all entries are between 0 and len(self) - 1, inclusive.
|
Pass verify=False if this check has been done by the caller.
|
convert_indices : bool, default True
|
Whether to attempt to convert indices to positive values.
|
|
Returns
|
-------
|
BlockManager
|
r
)r0 TN)r
|
r¢ rj r rº )r] ra r ÚarangeÚstartÚstopÚstepÚintpZ
|
asanyarrayrþ r) rB r r )rJ r¢ rj r0 r1 r¿ rn r; r; rK r ¡ s ÿ ý
|
ûzBaseBlockManager.take)T)N)N)F)T)FrÌ )FF)F)F)TN)T)NFTF)NF)rZ TT):r Ú
|
__module__Ú __qualname__Ú__doc__Ú __slots__Ú__annotations__ÚpropertyrL rR Ú classmethodrV rX rY rg ri Ú__bool__rm ro rs rv r| rz r r r r r r¤ r° r´ r¶ r¾ rÀ r rÅ rÉ rÎ rÐ rÒ rÖ rÚ rÝ rã rç rè rí ró rö rì r rº r r r rÇ r r" r r; r; r; rK r9 _ s°
|
2
|
ý4 û ÿ"/ ø
|
ö"Xüú ÿ ûc @ s e Zd ZdZdZdhdddddd d
|
Zdd d d Zeddd dddZdddddZ diddddddZ
|
ddd d d Z e d d d d!Z djd#ddd$d%d&Zdkdd(d)dd*d+d,Zddddd-dd.d/d0Zdldd#ddd1d2d3Zdd4ddd5d6d7Zdd d8d9Zdd d:d;Zd d d<d=Zd>d?d>d@dAdBZd>d?d>d@dCdDZd d dEdFdGZd d ddHdIdJZdKdLdMd>dNdOdPd>dQdRdSZd d dTdUZdmddVdWdXZ d'd"e j fdYddZd[d\d]d^Z d'e j fdYdZd[d_d`daZ dd dbdcZ!dd dddeZ"dd dfdgZ#d'S )nÚ BlockManagerz0
|
BaseBlockManager that holds 2D blocks.
|
rk TzSequence[Block]zSequence[Index]rM rP )r@ rB rQ rE c C s@ |r<|D ]*}| j |j krtd|j d| j dq| ¡ d S )Nz Number of Block dimensions (z ) must equal number of axes (ú))rL r_ Ú_verify_integrity)rJ r@ rB rQ r r; r; rK rR Ö s ÿzBlockManager.__init__rD c C s | j }tdd | jD }| jD ]6}|j dd
|dd
kr t||j dd
| j q t| j|krtdt| j d| d S )Nc s s | ]}t |jV qd S rF )rr r¡ ©r Úxr; r; rK rá î s z1BlockManager._verify_integrity.<locals>.<genexpr>rZ zINumber of manager items must equal union of block items
|
# manager items: z, # tot_items: )rþ Úsumr@ Úraise_construction_errorrB rr rv r_ )rJ Z mgr_shapeÚ tot_itemsr r; r; rK rA ì s
|
ÿz BlockManager._verify_integrityrS rA ©r@ rB rE c C s | ||ddS )úZ
|
Constructor for BlockManager and SingleBlockManager with same signature.
|
Fr r; rU r; r; rK rV ù s zBlockManager.from_blocksrC r^ )ÚlocrE c C s@ t | jdkrX| jd td|f¡}t|tdt |d| jd jd}t|| jd S tdd | jD }t | }t |t
|
}t |t r¦|s¦| ¡ }|j |f|d}n tj||r´tn|d}t|}| jD ]*}t|jD ]\} }
|
| | |f¡||
|
< qØqÊ|rtt |}| ¡ j||d}t|tdt |dd}t|| jd S ) zÅ
|
Return the array corresponding to `frame.iloc[loc]`.
|
|
Parameters
|
----------
|
loc : int
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray
|
rZ r N©r\ rL r~ c S s g | ]
|
}|j qS r; r
r r; r; rK r s z(BlockManager.fast_xs.<locals>.<listcomp>r
©r\ rL )rr r@ Úigetra r4 r~ r^ rB r. r] r& r Zconstruct_array_typeÚ_emptyr r* Úobjectr' r r¡ r Z_from_sequence) rJ rI r r r r¿ Z immutable_earT rc rx Úrlr; r; rK Úfast_xs s8
|
ü
|
|
ÿ
|
|
zBlockManager.fast_xs)rx Ú track_refrE c C s` | j | j| }| | j| ¡}ttdt|}t|||d|rH|jndd}t || j
|
d S )z:
|
Return the data as a SingleBlockManager.
|
r rZ NrJ ) r@ rX rL rY r ra rr rb r~ r^ rB )rJ rx rQ r r` re rf r; r; rK rL < s ÿzBlockManager.igetr rw c C s$ | j | j| }| | j| ¡}|S )z×
|
Return the data for column i as the values (ndarray or ExtensionArray).
|
|
Warning! The returned array is a view but doesn't handle Copy-on-Write,
|
so this should be used with caution.
|
)r@ rX rL rY )rJ rx r r` r; r; rK Ú iget_valuesJ s zBlockManager.iget_valueszlist[np.ndarray]c C sd dgt | j }| jD ]H}|j}| ¡ }|jdkr@|||d < qt|D ]\}}|| ||< qHq|S )a'
|
Used in the JSON C code to access column arrays.
|
This optimizes compared to using `iget_values` by converting each
|
|
Warning! This doesn't handle Copy-on-Write, so should be used with
|
caution (current use case of consuming this in the JSON code is fine).
|
NrZ r )rr rv r@ Ú _mgr_locsZvalues_for_jsonrL r )rJ r rc r¡ r` rx rI r; r; rK Ú column_arraysV s
|
|
zBlockManager.column_arraysFzint | slice | np.ndarray)rI r· rÁ c s | j dkr | jdkr | ¡ tj}|sljdkr<jn tddjdd
| jdd
krltdt
|
|¡r¼t t |}| j | }| j| }t|jdkr¶| j||||dS |g}|rÎfdd}n fd d}| j | }| j| ¡ } g }
|
g } g tj|d
|
d D ]º\} } | j| }| | j }|rx| ¡rxt rb| | ¡sb| | ||| ¡ n| ||| ¡ q nL|
|
|j j | ¡ | | ¡ t| t|j kr¸ | ¡ q n | | |¡ q t rLt j | j!t j"d }d
|
| < t j#| j!t j$d }| %d ¡ t &| j!t ¡|| < || j' | _'t( fddt)| jD | _| rt *|
|
¡}t|}g }|r¬| +fdd|D ¡ t &|¡t| j | j'|< d| j |< nP| d | dd
¡}| t,||t-|d¡ t| j| j'|< t &|¡| j |< | jt(|7 _d| _.dS )z
|
Set new item in-place. Does not consolidate. Adds new Block if not
|
contained in the current set of items
|
NrZ rk rl z9Shape of new values must be compatible with manager shape)rÁ r{ rc c s S rF r; r[ ©r· r; rK Ú value_getitem¦ s z(BlockManager.iset.<locals>.value_getitemc s
|
| j S rF )r¢ r[ rU r; rK rV « s Tr r
rû c 3 s" | ]\}}|t kr|V qd S rF )Úset)r rx rc )Úremoved_blknosr; rK rá Ô s z$BlockManager.iset.<locals>.<genexpr>c 3 s( | ] }t tt||d dV qdS )rZ ©r` r\ N)r5 r ra )r r' rU r; rK rá ã s
|
üþr rY F)/r> rL rW r r r8 r1 rþ r_ r Ú
|
is_integerr rC rX r@ rr rS Ú _iset_singlerY rº r r! r¢ Ú should_storer
|
rz Ú_iset_split_blockÚ set_inplacerî r¡ rù r Úzerosr Úbool_r* r6 r, r2 r= Útupler rý Úextendr5 r rN )rJ rI r· rÁ Zvalue_is_extension_typer{ rc rV rX rY Zunfit_mgr_locsZunfit_val_locsÚblkno_lZval_locsÚblk_locsÚ
|
is_deletedÚ
|
new_blknosZ
|
unfit_idxrZ unfit_countrñ Zunfit_val_itemsr; )rX r· rK Úisetr s
|
|
|
ÿ
|
|
|
|
û
|
|
|
|
|
|
|
ÿ
|
|
û þÿzBlockManager.isetNznp.ndarray | list[int]zArrayLike | None)rc rd r· rE c C s | j | }| jdkr | ¡ t| |¡}|dk rN|jj| }t|t|}n|d }t|dd
}t | j }| j d|
|f | j |d d
| } | | _ |s°|dk r°dS t
|
t |¡| j|jj < t |D ]2\}
|
} t
|
t | ¡| j| jj < |
|
| | j| jj < qÐdS )aþ Removes columns from a block by splitting the block.
|
|
Avoids copying the whole block through slicing and updates the manager
|
after determinint the new block structure. Optionally adds a new block,
|
otherwise has to be done by the caller.
|
|
Parameters
|
----------
|
blkno_l: The block number to operate on, relevant for updating the manager
|
blk_locs: The locations of our block that should be deleted.
|
value: The value to set as a replacement.
|
Nr rZ )r@ r> rW ra Údeleter¡ rù r5 r rr r r2 r¢ r r= ) rJ rc rd r· rc Znbs_tupZlocsZfirst_nbZ nr_blocksZ
|
blocks_tuprx rf r; r; rK r] s&
|
|
|
(ÿ z BlockManager._iset_split_blockr/ )rI r· rÁ r{ rc rE c C s |rN| |¡rNd}t r&| |¡s&d}| j| }|jt||d ||d dS t||jd}| j} | d|
|f | |d d
}
|
|
|
| _dS )zþ
|
Fastpath for iset when we are only setting a single position and
|
the Block currently in that position is itself single-column.
|
|
In this case we can swap out the entire Block and blklocs and blknos
|
are unaffected.
|
FTrZ rë Nr[ ) r\ r
|
rz rY r^ ra r5 rS r@ ) rJ rI r· rÁ r{ rc rº r rf Z
|
old_blocksrñ r; r; rK r[ 0 s
|
"zBlockManager._iset_single)rI ÚidxÚ inplace_onlyrE c
|
C s¤ t r^| |¡s^| j| }| j| }| j| j}|jdkrD| ¡ }n
|
||g }| ||g|¡ | j |dd}|r~|
|
||¡ n"| |f|¡} | j || j jdd dS )zù
|
Set values ("setitem") into a single column (not setting the full column).
|
|
This is a method on the BlockManager level, to avoid creating an
|
intermediate Series at the DataFrame level (`s = df[loc]; s[idx] = value`)
|
rZ F)rQ T)rÁ N)r
|
r| rX rY r@ r` rL rº r] rL Úsetitem_inplacer¶ rg Ú_block)
|
rJ rI ri r· rj r{ Zblk_locr` Zcol_mgrr r; r; rK Úcolumn_setitemK s
|
|
|
|
|
zBlockManager.column_setitemr )rI Úitemr· rE c C s | j ||¡}|jdkr>|j}t|dkrLtd|jj nt|| jd}tt ||d }t
|
||d}t| j st j dgt jd| _t j dgt jd| _n| |¡ | |¡ || jd< | j |f7 _ d| _td d
|
| j D d krütjd tt d dS )z±
|
Insert item at selected position.
|
|
Parameters
|
----------
|
loc : int
|
item : hashable
|
value : np.ndarray or ExtensionArray
|
rk rZ z-Expected a 1D array, got an array with shape rl rY r r
Fc s s | ]}|j V qd S rF rä rà r; r; rK rá s z&BlockManager.insert.<locals>.<genexpr>éd a DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`)Ú
|
stacklevelN)rv ÚinsertrL r8 rr r¹ rþ r1 r ra r5 r@ r r r6 r> r= Ú_insert_update_mgr_locsÚ!_insert_update_blklocs_and_blknosrB rN rD ÚwarningsÚwarnr r )rJ rI rn r· r
|
re r r; r; rK rq k s0
|
ÿ
|
|
|
|
úzBlockManager.insertc C s8 t | j|d
D ] \}}| j| }|j |¡|_qdS )z
|
When inserting a new Block at location 'loc', we increment
|
all of the mgr_locs of blocks above that by one.
|
N)Ú_fast_count_smallintsrX r@ rS Zincrement_above)rJ rI r{ Úcountrc r; r; rK rr s
|
z$BlockManager._insert_update_mgr_locsc C s¾ || j jd kr8t | jd¡| _t | jt| j¡| _n|dkrt | jddd
d¡ddd
| _t | jddd
t| j¡ddd
| _n*t | j | j
|
|t| j¡\}}|| _|| _dS )zk
|
When inserting a new Block at location 'loc', we update our
|
_blklocs and _blknos.
|
r Nrû ) rY rþ r rî r> r= rr r@ r Zupdate_blklocs_and_blknosrX )rJ rI Z new_blklocsrf r; r; rK rs ¦ s $, ÿz.BlockManager._insert_update_blklocs_and_blknosc C sj t j| jd t jd}d||< | ¡ d }| j|dd}| j| }|| jd g}t| t ||ddS )zJ
|
Delete selected locations, returning a new BlockManager.
|
r r
T)r rZ Fr )
|
r r_ rþ r` Únonzeror rv rB rb ra )rJ r¢ re r( rò Ú new_columnsrB r; r; rK Úidelete¼ s zBlockManager.ideleter8 r )rJ ÚfuncrE c C s g }| j D ]B}|jr8| ¡ D ]}| |¡}t||}q q
|
| |¡}t||}q
|
t|dkr`d}n|d jjd }tt |}t
|
| || j d |g¡S )zâ
|
Apply grouped reduction function blockwise, returning a new BlockManager.
|
|
Parameters
|
----------
|
func : grouped reduction function
|
|
Returns
|
-------
|
BlockManager
|
r rû ) r@ rï rð r¤ r2 rr r` rþ r* Úrangerb rV rB )rJ r{ r§ rc Zsbrª Znrowsr÷ r; r; rK Úgrouped_reduceÌ s
|
|
|
zBlockManager.grouped_reducec C sV | j dkstg }| jD ]}| |¡}| |¡ qtdg}t| || j|g¡}|S )zÙ
|
Apply reduction function blockwise, returning a single-row BlockManager.
|
|
Parameters
|
----------
|
func : reduction function
|
|
Returns
|
-------
|
BlockManager
|
rk N) rL r_ r@ Úreducerb r* rb rV rv )rJ r{ Z
|
res_blocksrc rò r÷ r r; r; rK r~ í s
|
|
|
zBlockManager.reduce)r rE c C s t | ||S )zO
|
Apply array_op blockwise with another (aligned) BlockManager.
|
)r7 )rJ r Zarray_opr; r; rK r7 s z BlockManager.operate_blockwise©rJ r rE c C s t | |tS )ú
|
Used in .equals defined in base class. Only check the column values
|
assuming shape and indexes have already been checked.
|
)r6 r# )rJ r r; r; rK Ú _equal_values s zBlockManager._equal_valuesr Zlinear)rj Ú interpolationr* r r )rJ Úqsrj r rE c sh | j dksttst dks&tt| j}ttjd|d< fdd| jD }t | ||S )a
|
Iterate over blocks applying quantile reduction.
|
This routine is intended for reduction type operations and
|
will do inference on the generated blocks.
|
|
Parameters
|
----------
|
axis: reduction axis, default 0
|
consolidate: bool, default True. Join together blocks having same
|
dtype
|
interpolation : type of interpolation, default 'linear'
|
qs : list of the quantiles to be computed
|
|
Returns
|
-------
|
BlockManager
|
rk rZ r
c s g | ]}|j d qS ))rj r r )Úquantiler ©rj r r r; rK r 3 s ÿz)BlockManager.quantile.<locals>.<listcomp>)
|
rL r_ r rÿ rB r* r Úfloat64r@ rb )rJ r rj r r r@ r; r
rK r s
|
þzBlockManager.quantilec C s | | j¡}|j}|j }|r<|j j|j }|jdd}ntj |jd t
|
d}g }g } t | jdkrld}
|
n*t |t | j } | t | kst t | }
|
| jD ]\} | j} | |
|
¡}| j||||d\}}| |¡ | |¡ | ¡ tdd |D kst q|| }t|||gdd }|S )
|
a'
|
Return a BlockManager with all blocks unstacked.
|
|
Parameters
|
----------
|
unstacker : reshape._Unstacker
|
fill_value : Any
|
fill_value for newly introduced missing values.
|
|
Returns
|
-------
|
unstacked : BlockManager
|
r ©rj rZ r
)Ú new_placementÚ needs_maskingc s s | ]}t |jV qd S rF )rr rS )r rf r; r; rK rá o s z'BlockManager.unstack.<locals>.<genexpr>Fr )Zget_new_columnsrv Ú new_indexZmask_allr½ ÚreshapeZ
|
full_shaperæ r r_ rM rr rC r_ r@ r¡ Ztile_for_unstackZ_unstackrb rD r? )rJ Z unstackerrÆ ry r r Z
|
new_mask2Dr rñ Z columns_maskZfactorZfacrc r¡ r r@ r½ rÜ r; r; rK Úunstack< s:
|
|
ü
|
|
|
zBlockManager.unstackrë c s@ i }j D ] }| t|jg ¡ |¡ q
|
fdd| ¡ D S )zØ
|
Return a dict of str(dtype) -> BlockManager
|
|
Parameters
|
----------
|
copy : bool, default True
|
|
Returns
|
-------
|
values : a dict of dtype -> BlockManager
|
c s i | ]\}}|j | d qS )rë )rì )r r r@ ©rº rJ r; rK r s z(BlockManager.to_dict.<locals>.<dictcomp>)r@ Ú
|
setdefaultr r rî rv )rJ rº Zbdr¨ r; r rK Úto_dicty s
|
zBlockManager.to_dictznp.dtype | NonerN ú
|
np.ndarray)r rº Úna_valuerE c C sÖ t | jdkr&tj| jtd}| ¡ S |p2|tjk }| j rª| jd }|j
|
rd|j j ||d |j¡}n t | ¡ ¡}|r|j|dd}|r| ¡ }q¸t r¸| ¡ }d|j_n| j||d}|tjk rÎ||t|< | ¡ S )a-
|
Convert the blockmanager data into an numpy array.
|
|
Parameters
|
----------
|
dtype : np.dtype or None, default None
|
Data type of the return array.
|
copy : bool, default False
|
If True then guarantee that a copy is returned. A value of
|
False does not guarantee that the underlying data is not
|
copied.
|
na_value : object, default lib.no_default
|
Value to be used as the missing value sentinel.
|
|
Returns
|
-------
|
arr : ndarray
|
r r
©r r Frë )rr r@ r r* rþ ÚfloatZ transposer rÇ rs rå r` Úto_numpyr ZasarrayÚ
|
get_valuesrÎ rº r
|
r ÚflagsZ writeableÚ _interleaver$ )rJ r rº r rd rc r; r; rK rù s2
|
þý
|
|
|
zBlockManager.as_array)r r rE c C s* |st dd | jD }t|tr6|j}ttj|}n*t|trLt d¡}nt |t
|
r`t d¡}tj | j |d}t | j d ¡}|t d¡krÌ|tjkrÌ| jD ](}|j}| |¡}|||j< d||j< q|S | jD ]@}|j}|jrô|jj||d}n
|
| |¡}|||j< d||j< qÒ| ¡ s&td|S ) zt
|
Return ndarray from blocks with specified item order
|
Items must be contained in the blocks
|
c S s g | ]
|
}|j qS r; r
r r; r; rK r Û s z,BlockManager._interleave.<locals>.<listcomp>rN r
r rZ r z'Some items were not contained in blocks)r. r@ r] r& Úsubtyper r r r r r r* rþ r_ r rÇ r¡ r r¢ rå r` r râ r_ )rJ r r r Zitemmaskrc rO rd r; r; rK r Í sB ÿ
|
|
|
|
|
|
|
|
þ
|
|
|
zBlockManager._interleavec C s | j s| ¡ | jS )zH
|
Return True if more than one block with the same dtype
|
)rN Ú_consolidate_checkrO rI r; r; rK r s z BlockManager.is_consolidatedc C sN t | jdkr d| _d| _d S dd | jD }t |t t|k| _d| _d S )NrZ Tc S s g | ]}|j r|jqS r; )r# r r r; r; rK r s z3BlockManager._consolidate_check.<locals>.<listcomp>)rr r@ rO rN rW r r; r; rK r s z BlockManager._consolidate_checkc C s, | ¡ s(t| j| _d| _d| _| ¡ d S rh )r Ú _consolidater@ rO rN rW rI r; r; rK rÛ s
|
z!BlockManager._consolidate_inplace)T)T)F)N)F)T)$r r7 r8 r9 rL rR rA r= rV rP rL rR r< rT rg r] r[ rm rq rr rs rz r} r~ r7 r r r r r rÇ rù r r r rÛ r; r; r; rK r? Ì sV ü 9 ÿ ü/ ÿ 1
|
! û*=üBý@
|
r? c sÀ e Zd ZdZeddddZdZdZdZdZ dYd d
|
d d d ddZ
|
e ddd dddZ e dZdd
|
dd dddZ d
|
dd d d Zd[d d d!d"d#Zd$d% Zd&d' Zd dd(d)Zed dd*d+Zed,d- Zed.d/ Zd0d d1d2d3Zd\d4d5d d6d7d8Zed
|
dd9d:Zed;dd<d=Zd>dd?d@ZdAdB Z dCdD Z dEdF Z d]d dGdHdIZ ed ddJdKZ d d fdLdM Z!d ddNdOZ"dPdQ Z#dd dRdSdTZ$dUdUd dVdWdXZ% Z&S )^r^ zmanage a single block withz
|
Literal[1]rD c C s dS rp r; rI r; r; rK rL . s zSingleBlockManager.ndimTr; Fr/ r* rM rP )r rj rQ rE c C s |g| _ |f| _d S rF ©rB r@ )rJ r rj rQ r; r; rK rR 7 s
|
zSingleBlockManager.__init__rS rA rG c C s6 t |dkstt |dks t| |d |d ddS )rH rZ r Fr )rr r_ rU r; r; rK rV D s z SingleBlockManager.from_blocksNr zBlockValuesRefs | None)r r÷ r~ rE c C s$ t |tdt|d|d}| ||S )zN
|
Constructor for if we have an array that is not yet a Block.
|
r rZ rJ )r4 ra rr )rT r r÷ r~ r r; r; rK Ú
|
from_arrayQ s z SingleBlockManager.from_arrayr? )ÚcolumnsrE c C sT | j d }t|jdd}td}t|||d|jd}|| jd g}t|g|ddS )z5
|
Manager analogue of Series.to_frame
|
r rk rl rJ F)rB rQ )r@ r1 r` r rb r~ rB r? )rJ r rc rd re Znew_blkrB r; r; rK Ú to_2d_mgr[ s
|
z SingleBlockManager.to_2d_mgrr rC rw c C s | j d j ¡ S )ry r r} )rJ rx r; r; rK r| f s z$SingleBlockManager._has_no_referencec sT dd j D } fdd j D }t j}d|dd j D di}||||fS )Nc S s g | ]
|
}|j qS r; r rú r; r; rK r o s z3SingleBlockManager.__getstate__.<locals>.<listcomp>c s g | ]} j |jj qS r; )rv r¡ r¢ rú rI r; rK r p s ú0.14.1c S s g | ]}|j |jjd qS ))r` r¡ )r` r¡ r¢ rú r; r; rK r v s ÿr )r@ rÿ rB )rJ r/ Z block_itemsZ
|
axes_arrayZ extra_stater; rI rK Ú __getstate__n s
|
þþÿ z SingleBlockManager.__getstate__c s dddddt |tr|t|dkr|d|d kr||d d }d d
|
|d D | _t| j t fd d |d D | _ntd| ¡ d S )NrC r/ )rL rE c S s t | dd} t| ||dS )NTr¯ rK )r( r4 )r` r¡ rL r; r; rK Úunpickle_block s z7SingleBlockManager.__setstate__.<locals>.unpickle_blocké r é c S s g | ] }t |qS r; )r+ r r; r; rK r s z3SingleBlockManager.__setstate__.<locals>.<listcomp>rB c 3 s$ | ] }|d |d dV qdS )r` r¡ rl Nr; rú ©rL r¡ r; rK rá s ÿz2SingleBlockManager.__setstate__.<locals>.<genexpr>r@ z*pre-0.14.1 pickles are no longer supported)r] ra rr rB r@ rH Ú_post_setstate)rJ Ústater; r¤ rK Ú __setstate__ s "
|
þ z SingleBlockManager.__setstate__c C s d S rF r; rI r; r; rK r¥ s z!SingleBlockManager._post_setstatec C s
|
| j d S rt r rI r; r; rK rl s zSingleBlockManager._blockc C s dS ©zcompat with BlockManagerNr; rI r; r; rK r= s zSingleBlockManager._blknosc C s dS r¨ r; rI r; r; rK r> ¡ s zSingleBlockManager._blklocsr )r¢ rE c C sª | j }t rNt|tjrNt|dkrNt |¡rN| ¡ rNt | |j
|
dd| j S | |¡}|j dkrjtdttdt|}t |||d|jd}| j | }t | ||S )Nr Frô rZ z(dimension-expanding indexing not allowedrJ )rl r
|
r] r r¸ rr ÚcomZis_bool_indexerrâ rb rº r÷ Ú_slicerL r¹ r ra r~ )rJ r¢ rc r re r Znew_idxr; r; rK Ú getitem_mgr¦ s& ÿ
|
þ
|
ýüû
|
|
|
z SingleBlockManager.getitem_mgrra r )r& rj rE c C sd || j krtd| j}| |¡}ttdt|}t|||d|jd}| j
|
|¡}t| ||S )Nr r rZ rJ ) rL r rl rª r ra rr rb r~ r÷ Z_getitem_slice)rJ r& rj rc r re r r r; r; rK Ú get_slice½ s
|
|
z SingleBlockManager.get_slicec C s
|
| j d S rt ru rI r; r; rK r÷ Ì s zSingleBlockManager.indexr c C s | j jS rF )rl r rI r; r; rK r Ð s zSingleBlockManager.dtyper c C s t | jjg¡S rF )r r rl r rI r; r; rK r Ô s z SingleBlockManager.get_dtypesc C s
|
| j ¡ S )z$The array that Series.values returns)rl Úexternal_valuesrI r; r; rK r × s z"SingleBlockManager.external_valuesc C s | j jS )z%The array that Series._values returns)rl r` rI r; r; rK Úinternal_valuesÛ s z"SingleBlockManager.internal_valuesc C s | j jS )z#The array that Series.array returns)rl Ú array_valuesrI r; r; rK r¯ ß s z SingleBlockManager.array_valuesrë c C s | j jr| j|dS | ¡ S )Nrô )rl rß rº rg rÑ r; r; rK rö ã s z#SingleBlockManager.get_numeric_datac C s | j jS rF )rl Ú _can_hold_narI r; r; rK r° è s z SingleBlockManager._can_hold_nac s: t r(| d¡s(| j ¡ f| _| j ¡ t ||¡ dS )a'
|
Set values with indexer.
|
|
For Single[Block/Array]Manager, this backs s[indexer] = value
|
|
This is an inplace version of `setitem()`, mutating the manager/values
|
in place, not returning a new Manager (and Block), and thus never changing
|
the dtype.
|
r N) r
|
r| rl rº r@ Ú_cacheÚclearÚsuperrk r» ©Ú __class__r; rK rk ì s
|
|
z"SingleBlockManager.setitem_inplacec C s< | j |¡d }|f| _| jd |¡| jd< | j ¡ | S )zy
|
Delete single location from SingleBlockManager.
|
|
Ensures that self.blocks doesn't become empty.
|
r )rl rh r@ rB r± r² )rJ r¢ rf r; r; rK rz ü s
|
|
zSingleBlockManager.ideletec C s t ddS )zY
|
fast path for getting a cross-section
|
return a view of the data
|
z Use series._values[loc] insteadNrG )rJ rI r; r; rK rP s zSingleBlockManager.fast_xs)r` rE c C s( || j d _ttt|| j d _dS )z×
|
Set the values of the single block in place.
|
|
Use at your own risk! This does not check if the passed values are
|
valid for the current Block/SingleBlockManager (length, dtype, etc).
|
r N)r@ r` r ra rr rS )rJ r` r; r; rK Ú
|
set_values s
|
z SingleBlockManager.set_valuesr8 r c C s0 |j dkrdS | jd j}|jd j}t||S )r rZ Fr )rL r@ r` r# )rJ r ÚleftÚrightr; r; rK r s
|
|
z SingleBlockManager._equal_values)F)N)r )r )F)'r r7 r8 r9 r< rL rO rN r: rs rR r= rV r r r| r r§ r¥ r rl r= r> r« r¬ r÷ r r r r® r¯ rö r° rk rz rP r¶ r Ú __classcell__r; r; r´ rK r^ + sV ü ÿ
|
|
r^ TrS rA rM )r@ rB r rQ rE c
|
C s zt | ||d}W n^ tk
|
rp } z@dd | D }tdd |D }t||d jdd
|| W 5 d }~X Y nX |r~| ¡ |S )Nr c S s g | ]
|
}|j qS r; r r r; r; rK r > s z4create_block_manager_from_blocks.<locals>.<listcomp>c s s | ]}|j d V qdS )r N)rþ )r rd r; r; rK rá ? s z3create_block_manager_from_blocks.<locals>.<genexpr>r rZ )r? r¹ rD rE rþ rÛ )r@ rB r rQ r Úerrr rF r; r; rK Ú create_block_manager_from_blocks- s .r» r rÿ )r rB r r~ rE c
|
C sj z t | ||}t||dd}W n: tk
|
rX } z tt| | d j|| W 5 d }~X Y nX |rf| ¡ |S )NFr r )Ú _form_blocksr? r¹ rE rr rþ rÛ )r rB r r~ r@ r Úer; r; rK Ú'create_block_manager_from_column_arraysG s *r¾ rC r zValueError | None)rF r. rB r½ c C s t tt| gt| }t|dkr2|ddd
}t dd |D }t|dkr^|ddd
}||krr|dk rr||d dkrtdtd| d | dS )
|
z.raise a helpful message about our constructionrk Nrû c s s | ]}t |V qd S rF )rr r r; r; rK rá n s z+raise_construction_error.<locals>.<genexpr>r z)Empty data passed with indices specified.zShape of passed values is z, indices imply )ra ÚmaprC rÿ rr r¹ )rF r. rB r½ ZpassedZimpliedr; r; rK rE b s rE ztuple[int, ArrayLike]ztuple[int, bool, DtypeObj])ÚtuprE c C s2 | d j }t|r t|}nd}|t|tj |fS )NrZ r )r r Úidr] r )rÀ r Úsepr; r; rK Ú_grouping_func s
|
|
|
rà )r r r~ rE c sü t t| }|s t||}|S t |t¡}g }|D ]Ä\\}}}}t| t|tj r´|j
|
dk} t |j t tfrxt t¡}tt ||\}
|
} | rt|
|
}
|
|
|
t| dd} | | ¡ q2t|rÚ fdd|D } | | ¡ q2 fdd|D } | | ¡ q2|S )N)ÚmÚMrk rK c s& g | ] } |d t |d ddqS )rZ r rk rK )r rB ©Z
|
block_typer; rK r ® s ÿz _form_blocks.<locals>.<listcomp>c s, g | ]$} t |d dt|d ddqS )rZ rk r rK )r1 r rB rÆ r; rK r µ s ý
|
ÿ)rÿ r Ú _tuples_to_blocks_no_consolidateÚ itertoolsÚgroupbyrà r3 r] r r ÚkindÚ
|
issubclassrb r ÚbytesrN Ú _stack_arraysr' r rî r rb )r r r~ Útuplesrò ÚgrouperÚ_r Z tup_blockZ is_dtliker` r\ rc Z dtype_blocksr; rÆ rK r¼ s6
|
|
|
|
þ
|
ü r¼ rD c C s dd t | |D S )Nc S s. g | ]&\\}}}t t|d dt||dqS )rk rl )r\ r~ )r5 r1 r )r rx rd r r; r; rK r Á s
|
ý
|
ÿz4_tuples_to_blocks_no_consolidate.<locals>.<listcomp>)r% )rÎ r~ r; r; rK rÇ ¿ s ürÇ znp.dtyper
c C sT t | \}}|d }t|f|j }tj||d}t|D ]\}}|||< q:||fS )Nr r
)r% rr rþ r r* r ) rÎ r r\ r Úfirstrþ Zstackedrx rd r; r; rK rÍ É s
|
rÍ r? )r@ rE c C sZ dd }t t| |d|¡}g }|D ],\\}}}tt|||d\}}t||}q$t|S )zJ
|
Merge blocks having same dtype, exclude non-consolidating blocks
|
c S s | j S rF )Z_consolidate_key)rC r; r; rK Ú<lambda>Û ó z _consolidate.<locals>.<lambda>)Úkey)r Úcan_consolidate)rÈ rÉ ÚsortedÚ _merge_blocksrÿ r2 ra ) r@ ZgkeyrÏ rñ r# r Z group_blocksZ merged_blocksrÐ r; r; rK r Ö s ÿ
|
r r ztuple[list[Block], bool])r@ r rÕ rE c C s¾ t | dkr| dfS |r¶t dd | D ¡}t| d jtjrTt dd | D ¡}n.dd | D }ttt |}|d j |dd}t
|
|¡}|| }|| }t |}t ||d gd
|
fS | dfS ) NrZ Fc S s g | ] }|j jqS r; rø rú r; r; rK r ð s z!_merge_blocks.<locals>.<listcomp>r c S s g | ]
|
}|j qS r; r rú r; r; rK r ù s c S s g | ]
|
}|j qS r; r r r; r; rK r û s r r[ T) rr r rý r] r Zvstackr r r% Z_concat_same_typeÚargsortr r5 ) r@ r rÕ r Z
|
new_valuesZbvalsZbvals2rØ re r; r; rK r× ç s
|
r× r< )rd c C s$ t | ¡}| ¡ d }t||| S )z:Faster version of set(arr) for sequences of small numbers.r )r Zbincountrx r% )rd ÚcountsZnzr; r; rK rv
|
s
|
rv r )r Úlengthr c C sv t | tr d| t | |¡fS t | tjr4| jjdkrNt| dd }t t
|
| |t | }|sdt ||}d|t |fS d S )Nra rx r Zfancy)r] ra r Z slice_lenr r¸ r rÊ r¥ Ú TypeErrorrb r r) rr )r rÚ r r r¢ r; r; rK r s
|
|
ý
|
ÿ
|
þ
|
r )TT)N)iÚ
|
__future__r rÈ Útypingr r r r r r r rt r Únumpyr Zpandas._configr
|
Z pandas._libsr rË r r r Zpandas._libs.internalsr r Zpandas._typingr r r r r r r Z pandas.errorsr Zpandas.util._decoratorsr Zpandas.util._exceptionsr Zpandas.util._validatorsr Zpandas.core.dtypes.castr Zpandas.core.dtypes.commonr r r r Zpandas.core.dtypes.dtypesr Zpandas.core.dtypes.genericr! r" Zpandas.core.dtypes.missingr# r$ Zpandas.core.algorithmsÚcoreZ
|
algorithmsZpandas.core.arrays._mixinsr% Zpandas.core.arrays.sparser& Zpandas.core.commonÚcommonr© Zpandas.core.constructionr' r( Zpandas.core.indexersr) Zpandas.core.indexes.apir* r+ Zpandas.core.internals.baser, r- r. Z pandas.core.internals.blocksr/ r0 r1 r2 r3 r4 r5 Zpandas.core.internals.opsr6 r7 r8 r9 r? r^ r» r¾ rE rà r¼ rÇ rÍ r r× rv r r; r; r; rK Ú<module> sx $ $ $ s e ü ü 0
|
#
|
