U
|
¬ý°d¤³ ã @ sî d Z ddlmZ ddlmZmZmZmZmZ ddl Z
|
ddl m Z m ZmZ ddlmZmZmZmZmZ ddlmZ ddlmZ dd lmZm Z dd
|
l m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z% dd l&m'Z'm(Z( dd l)m*Z*m+Z+ dd l,m-Z-m.Z.m/Z/ ddl0m1 m2Z ddl3m4Z4 ddl5m6Z6 ddl7m8Z8m9Z9m:Z:m;Z; ddl<m=Z= ddl>m?Z?m@Z@mAZA ddlBmCZCmDZD ddlEmFZFmGZG ddlHmIZImJZJmKZK ddlLmMZMmNZNmOZOmPZPmQZQmRZR edddZSG dd deIZTG dd d eTZUG d d d eTeJZVG d d d ZWdS )!zA
|
Experimental manager based on storing a collection of 1D arrays
|
é )Ú annotations)ÚAnyÚCallableÚHashableÚLiteralÚTypeVarN)ÚNaTÚalgosÚlib)Ú ArrayLikeÚAxisIntÚDtypeObjÚQuantileInterpolationÚnpt)Úvalidate_bool_kwarg)Úastype_array_safe)Úensure_dtype_can_hold_naÚinfer_dtype_from_scalar)Úensure_platform_intÚis_datetime64_ns_dtypeÚis_dtype_equalÚis_extension_array_dtypeÚ
|
is_integerÚis_numeric_dtypeÚis_object_dtypeÚis_timedelta64_ns_dtype)ÚExtensionDtypeÚ PandasDtype)Ú ABCDataFrameÚ ABCSeries)Ú array_equalsÚisnaÚna_value_for_dtype)Úquantile_compat©Útake_1d)Ú DatetimeArrayÚExtensionArrayÚ PandasArrayÚTimedeltaArray)Ú SparseDtype)Ú ensure_wrapped_if_datetimelikeÚ extract_arrayÚsanitize_array)Úmaybe_convert_indicesÚvalidate_indices)ÚIndexÚ ensure_index)Ú DataManagerÚSingleDataManagerÚinterleaved_dtype)Úensure_block_shapeÚexternal_valuesÚextract_pandas_arrayÚmaybe_coerce_valuesÚ new_blockÚto_native_typesÚTÚBaseArrayManager)Úboundc @ s8 e Zd ZU dZddgZded< ded< dddddd d
|
d Zd
d d dddZeddddZ eddddZ
|
eddddZ e ddd d d Z dddd d d!Zd"dd#d$Zd dd%d&d'Zd(d) Zddd*d+Zd,dd-d.Zdd d/d d0d1d2Zdd dd d3d4d5Zd dd d6d7d8Zdd ddd d:d;d<Zd d dd=d>Zdd dd d6d?d@Zd ddd dAdBdCZd d ddDdEZd ddd dFdGdHZ d dd dIdJdKZ dd dMd,d dNdOdPZ d dMd dQdRdSZ d d ddTdUZ d dd dIdVdWZ!dd dXdXddd dYdZd[Z"d d dd\d]Z#eddd^d_Z$eddd`daZ%edddbdcZ&edddddeZ'edddfdgZ(d dhd didjdkZ)dd dd dQdldmZ*dd dd dQdndoZ+dd dpd dqdrdsZ,dd dddMddd dtdudvZ-dd dwdddMdd dxdydzZ.dd dddd d|d}d~Z/dddddZ0ddddZ1d S )r< aO
|
Core internal data structure to implement DataFrame and Series.
|
|
Alternative to the BlockManager, storing a list of 1D arrays instead of
|
Blocks.
|
|
This is *not* a public API class
|
|
Parameters
|
----------
|
arrays : Sequence of arrays
|
axes : Sequence of Index
|
verify_integrity : bool, default True
|
|
Ú_axesÚarraysú!list[np.ndarray | ExtensionArray]ú list[Index]TÚboolÚNone©r? ÚaxesÚverify_integrityÚreturnc C s t d S ©N©ÚNotImplementedError©Úselfr? rE rF © rM úZd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/internals/array_manager.pyÚ__init__| s zBaseArrayManager.__init__Nr; )rL rG c C s0 |dkr | j dd
tg g}g }t| ||S )zFReturn an empty ArrayManager with the items axis of len 0 (no columns)Né )rE r0 Útype)rL rE r? rM rM rN Ú
|
make_empty s zBaseArrayManager.make_emptyr0 ©rG c C s
|
| j d S )Néÿÿÿÿ©r> ©rL rM rM rN Úitems s zBaseArrayManager.itemsc C s | j d | j d gS )z5Axes is BlockManager-compatible order (columns, rows)rP r rU rV rM rM rN rE s zBaseArrayManager.axesztuple[int, ...]c C s t dd | jD S )Nc s s | ]}t |V qd S rH )Úlen©Ú.0ÚaxrM rM rN Ú <genexpr> s z0BaseArrayManager.shape_proper.<locals>.<genexpr>)Útupler> rV rM rM rN Ú shape_proper s z BaseArrayManager.shape_properr Úint)ÚaxisrG c C s | dkr dnd} | S ©Nr rP rM ©r` rM rM rN Ú_normalize_axis s z BaseArrayManager._normalize_axis)r` Ú
|
new_labelsrG c C s$ | ||¡ | |¡}|| j|< d S rH )Z_validate_set_axisrc r> )rL r` rd rM rM rN Úset_axis£ s
|
zBaseArrayManager.set_axisú
|
np.ndarrayc C s t jdd | jD ddS )Nc S s g | ]
|
}|j qS rM ©Údtype©rZ ÚarrrM rM rN Ú
|
<listcomp>ª s z/BaseArrayManager.get_dtypes.<locals>.<listcomp>Úobjectrg )ÚnpÚarrayr? rV rM rM rN Ú
|
get_dtypes© s zBaseArrayManager.get_dtypes)ÚmgrrG c C s dS )z<
|
Only implemented on the BlockManager level
|
NrM )rL rp rM rM rN Úadd_references¬ s z BaseArrayManager.add_referencesc C s | j | jfS rH ©r? r> rV rM rM rN Ú __getstate__² s z BaseArrayManager.__getstate__c C s |d | _ |d | _d S ra rr )rL ÚstaterM rM rN Ú __setstate__µ s
|
z BaseArrayManager.__setstate__Ústrc C sr t | j}|d| jd 7 }| jdkr<|d| jd 7 }|dt| j d7 }| jD ]}|d|j 7 }qX|S )Nz
|
Index: r é z
|
|
Columns: rP Ú
|
z arrays:)rQ Ú__name__r> ÚndimrX r? rh )rL Úoutputrj rM rM rN Ú__repr__¹ s
|
|
|
zBaseArrayManager.__repr__zlist[str] | None)rL Ú
|
align_keysrG c sø d ks t |pg }g } fdd|D }|dkr< d¡}t| jD ]\}}|r²| ¡ D ]V\}} t| ttfr¤| jdkr| j | |< q°| j dd
|f j
|
|< qZ| | |< qZt |rÈ||f }
|
nt ||f }
|
| |
|
¡ qF| j} t| || S )ab
|
Iterate over the arrays, collect and create a new ArrayManager.
|
|
Parameters
|
----------
|
f : str or callable
|
Name of the Array method to apply.
|
align_keys: List[str] or None, default None
|
**kwargs
|
Keywords to pass to `f`
|
|
Returns
|
-------
|
ArrayManager
|
Úfilterc s i | ]}| | qS rM rM ©rZ Úk©ÚkwargsrM rN Ú
|
<dictcomp>Þ s z*BaseArrayManager.apply.<locals>.<dictcomp>ÚapplyÚfuncrP N)ÚAssertionErrorÚpopÚ enumerater? rW Ú
|
isinstancer r rz ÚilocÚ_valuesÚcallableÚgetattrÚappendr> rQ ) rL Úfr} r Ú result_arraysÚ aligned_argsÚirj r ÚobjÚappliedÚnew_axesrM r rN r à s(
|
|
zBaseArrayManager.apply)rL Ú swap_axisrG c sî |r.d kr.| j dkr. d dkr&dnd d< |p4g } fdd|D }g }t| jD ]\}}|rþ| ¡ D ]\} }
|
t|
|
ttfrä|
|
j dkrÈ| j dkr²|
|
jt||d j | < qâ|
|
jd d
j | < qü|
|
jd d
|gf j | < ql|
|
j dkrl|
|
|g | < qlt|j
|
t j
|
r&t|t j s&t |¡}| j dkrTt|d}t|tddddd} nt|tdt| ddd} t| |f } t| tr| d } | j}| j dkrÒ|j dkrÒt|dksÂt|dd d
f }| |¡ qVt| || jS )Nr` rw r rP c s i | ]}| | qS rM rM r r rM rN r s z5BaseArrayManager.apply_with_block.<locals>.<dictcomp>)Z placementrz )rz r r? rW r r r r Úslicer rh rm ÚndarrayÚasarrayr5 r9 rX r ÚlistÚvaluesr r rQ r> ) rL r r} r r r r r rj r r Úblockr rM r rN Úapply_with_block s>
|
|
|
|
|
z!BaseArrayManager.apply_with_block)rL ÚalignrG c C s2 |rddg}ndg}t |dd}| jd|||dS )NÚotherÚcondT©Z extract_numpyÚwhere)r} r r ©r, r )rL r r r r} rM rM rN r¢ 8 s
|
üzBaseArrayManager.whereF)rL ÚdecimalsÚ using_cowrG c C s | j d||dS )NÚround)r¤ r¥ ©r )rL r¤ r¥ rM rM rN r¦ F s zBaseArrayManager.roundc C s | j d||dS )NÚsetitem©ÚindexerÚvaluer§ ©rL rª r« rM rM rN r¨ I s zBaseArrayManager.setitemc C s2 |rddg}ndg}t |dd}| jd|||dS )NÚnewÚmaskTr¡ Úputmask)r} r® r r£ )rL r® r r r} rM rM rN r¯ L s
|
üzBaseArrayManager.putmask)rL Únr` rG c C s( | j dkr|dkst| jtj||dS )Nrw r )r° r` )rz r r r Údiff)rL r° r` rM rM rN r± Z s zBaseArrayManager.diffc K s | j dddi|S )NÚ interpolater F)r² r§ ©rL r rM rM rN r² ^ s z BaseArrayManager.interpolate)rL Úperiodsr` rG c C s6 |t jkrd }|dkr$| jdkr$t| jd|||dS )NrP rw Úshift)r´ r` Ú
|
fill_value)r
|
Ú
|
no_defaultrz rJ r )rL r´ r` r¶ rM rM rN rµ a s
|
ÿzBaseArrayManager.shift)rL ÚinplacerG c C s* |d k rt jd |d}| jd||||dS )N)ÚlimitÚfillna)r« r¹ r¸ Údowncast)ÚlibalgosZvalidate_limitr )rL r« r¹ r¸ r» rM rM rN rº m s ÿzBaseArrayManager.fillnaÚraisez bool | None)rL ÚcopyÚerrorsrG c C s |d kr d}| j t|||dS )NT)rh r¾ r¿ )r r )rL rh r¾ r¿ rM rM rN Úastypev s zBaseArrayManager.astype)rL r¾ rG c s" d kr d fdd}| |¡S )NTc sT t | jr@t | ¡} tj| ddddd}|| kr< r<| ¡ S |S rL| ¡ S | S d S )NT)Zconvert_datetimeZconvert_timedeltaZconvert_periodZconvert_interval)r rh rm r r
|
Zmaybe_convert_objectsr¾ )rj Úresult©r¾ rM rN Ú_convert s
|
|
û z*BaseArrayManager.convert.<locals>._convert)r )rL r¾ rà rM r rN Úconvert| s zBaseArrayManager.convertc K s | j d|S )NÚ_replace_regex)rÅ r§ r³ rM rM rN Ú replace_regex s z BaseArrayManager.replace_regexc C s2 t |d}t |¡dks t|| jd|||dS )Nr¸ r Úreplace)r« Ú
|
to_replacer¸ )r rm rz r r )rL rÈ r« r¸ rM rM rN rÇ s
|
ÿzBaseArrayManager.replacez list[Any])rL Úsrc_listÚ dest_listr¸ ÚregexrG c C s t |d}| jd||||dS )zdo a list replacer¸ Ú replace_list)rÉ rÊ r¸ rË )r r )rL rÉ rÊ r¸ rË rM rM rN rÌ s
|
ûz BaseArrayManager.replace_listc K s | j tf|S rH )r r: r³ rM rM rN r: ± s z BaseArrayManager.to_native_typesc C s dS ©NTrM rV rM rM rN Ú is_mixed_type´ s z BaseArrayManager.is_mixed_typec C s t dd | ¡ D S )Nc s s | ]}t |V qd S rH )r )rZ ÚtrM rM rN r\ º s z9BaseArrayManager.is_numeric_mixed_type.<locals>.<genexpr>)Úallro rV rM rM rN Úis_numeric_mixed_type¸ s z&BaseArrayManager.is_numeric_mixed_typec C s dS )z>Whether any of the blocks in this manager are extension blocksFrM rV rM rM rN Úany_extension_types¼ s z$BaseArrayManager.any_extension_typesc C s dS )z8return a boolean if we are a single block and are a viewFrM rV rM rM rN Úis_viewÁ s zBaseArrayManager.is_viewc C s t | jdkS ©NrP )rX r? rV rM rM rN Úis_single_blockÇ s z BaseArrayManager.is_single_blockr )rL Ú predicaterG c sh fddt jD }fdd|D }tj|dd}jd |¡}jd |g}t||dd S )
|
Nc s g | ]\}} |r|qS rM rM )rZ r rj )rÖ rM rN rk Ì s z5BaseArrayManager._get_data_subset.<locals>.<listcomp>c s g | ]} j | qS rM ©r? ©rZ r rV rM rN rk Í s Úintprg rP r F©rF )r r? rm rn r> ÚtakerQ )rL rÖ Úindicesr? ZtakerZnew_colsr rM )rÖ rL rN Ú_get_data_subsetË s z!BaseArrayManager._get_data_subsetc C s | dd ¡S )zÑ
|
Select columns that are bool-dtype and object-dtype columns that are all-bool.
|
|
Parameters
|
----------
|
copy : bool, default False
|
Whether to copy the blocks
|
c S s | j t t¡kS rH )rh rm rB )ÚxrM rM rN Ú<lambda>ß ó z0BaseArrayManager.get_bool_data.<locals>.<lambda>©rÝ ©rL r¾ rM rM rN Ú get_bool_dataÖ s z BaseArrayManager.get_bool_datac C s | dd ¡S )z¬
|
Select columns that have a numeric dtype.
|
|
Parameters
|
----------
|
copy : bool, default False
|
Whether to copy the blocks
|
c S s t | jpt| jddS )NZ _is_numericF)r rh r )rj rM rM rN rß ë s
|
z3BaseArrayManager.get_numeric_data.<locals>.<lambda>rá râ rM rM rN Úget_numeric_dataá s ÿz!BaseArrayManager.get_numeric_dataz bool | Literal['all'] | None)rL ÚdeeprG c sn dkr dr2fdd fdd| j D }n
|
t| j }rRdd | jD }n
|
t| j}t| ||dd S )
|
a>
|
Make deep or shallow copy of ArrayManager
|
|
Parameters
|
----------
|
deep : bool or string, default True
|
If False, return shallow copy (do not copy data)
|
If 'all', copy data and a deep copy of the index
|
|
Returns
|
-------
|
BlockManager
|
NTc s dkr| j ddS | ¡ S )NrÐ T©rå )r¾ Úview)r[ ræ rM rN Ú copy_func s z(BaseArrayManager.copy.<locals>.copy_funcc s g | ] } |qS rM rM rY )rè rM rN rk s z)BaseArrayManager.copy.<locals>.<listcomp>c S s g | ] }| ¡ qS rM r ri rM rM rN rk s FrÚ )r> r r? rQ )rL rå r Ú
|
new_arraysrM )rè rå rN r¾ ï s
|
|
zBaseArrayManager.copy)rL r` Ú
|
allow_dupsr¾ Ú
|
only_sliceÚ use_na_proxyrG c C s | |¡}| |||||||¡S rH )rc Ú_reindex_indexer) rL Únew_axisrª r` r¶ rê r¾ rë rì rM rM rN Úreindex_indexer s
|
ùz BaseArrayManager.reindex_indexerznpt.NDArray[np.intp] | None)rL rª r` rê r¾ rì rG c s0 |dkr d}dkrP|| j | kr*|s*| S | j|d}t| j |_ ||j |< |S |sd| j | ¡ || jkrvtd|dkrÆg } D ]<}
|
|
|
dkr¢| j |d} n| j|
|
} |r¸| ¡ } | | ¡ qnFt t
|
| j d t dk ¡ fd d
|
| jD } t| j } || |< t | | | d d 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, default True
|
|
|
pandas-indexer with -1's only.
|
NTræ ú#Requested axis not found in managerrP rT )r¶ rì r c s g | ]}t | d qS )©Ú
|
allow_fillr¶ r® r$ ri ©r¶ rª r® Ú needs_maskingrM rN rk i s øûz5BaseArrayManager._reindex_indexer.<locals>.<listcomp>FrÚ )r> r¾ r Z_validate_can_reindexrz Ú
|
IndexErrorÚ_make_na_arrayr? r r/ rX r ÚanyrQ ) rL rî rª r` r¶ rê r¾ rì rÁ ré r rj r rM ró rN rí + sF
|
|
ÿ
|
÷
|
z!BaseArrayManager._reindex_indexerrP )rL r` ÚverifyÚconvert_indicesrG c C s | |¡}t|tr,tj|j|j|jddn tj|dd}|j dksLt
|
d| j | }|rht |||d}| j | |¡}| j|||ddS )z,
|
Take items along any axis.
|
Úint64rg rP z indexer should be 1-dimensional)rø T)rî rª r` rê )rc r r rm ZarangeÚstartÚstopÚstepZ
|
asanyarrayrz Ú
|
ValueErrorr^ r. r> rÛ rí )rL rª r` rø rù r° rd rM rM rN rÛ z s"
|
|
ÿ ý
|
|
ÿzBaseArrayManager.take)rì c C sZ |r |d kst t| jd S |d kr,tj}t|\}}tj| jd |d}| |¡ |S )Nr rg )r ÚNullArrayProxyr^ rm Únanr ÚemptyÚfill)rL r¶ rì rh r rM rM rN rö s
|
z BaseArrayManager._make_na_arrayc C s, t | j|jD ]\}}t||s dS qdS )z
|
Used in .equals defined in base class. Only check the column values
|
assuming shape and indexes have already been checked.
|
FT)Úzipr? r )rL r ÚleftÚrightrM rM rN Ú _equal_values© s
|
z BaseArrayManager._equal_values)T)N)N)NT)F)T)Fr½ )FF)F)F)T)NFTFF)NFTF)rP TT)NF)2ry Ú
|
__module__Ú __qualname__Ú__doc__Ú __slots__Ú__annotations__rO rR ÚpropertyrW rE r^ Ú staticmethodrc re ro rq rs ru 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 rM rM rM rN r< c s
|
þ ü ý? ÿ7 û ) õ ø R û c @ sd e Zd ZeddddZdJdddd d
|
d d Zd dd dZdddddZdKddd dddZddddd Z dd dd d Z
|
ed dd!d"Z dLd$d dd d%d&d'Z dMdd$dd d(d)d*Z dd+d d d,d-d.Zd dd/d0Zd1d2d1d3d4d5Zd1d2d1d3d6d7Zd d d8d9d:Zdd#d;d<d=ddd>d d?d@dAZd ddBdCZdDd#ejfddEdFdGdHdIZdDS )NÚ ArrayManagerz
|
Literal[2]rS c C s dS )Nrw rM rV rM rM rN rz ¸ s zArrayManager.ndimTr@ rA rB rC rD c C sJ || _ || _|rFdd |D | _ dd |D }dd |D | _| ¡ d S )Nc S s g | ] }t |qS rM ©r1 rY rM rM rN rk È s z)ArrayManager.__init__.<locals>.<listcomp>c S s g | ]}t |d dd qS )NrP r )r7 ©rZ rÞ rM rM rN rk É s c S s g | ] }t |qS rM )r8 ri rM rM rN rk Ê s )r> r? Ú_verify_integrityrK rM rM rN rO ¼ s zArrayManager.__init__c C sª | j \}}t| j|ks4tdt| j d| d| jD ]j}t||ksdtdt| d| dt|tjtfstdt| d|j d ks:td
|
|j d q:d S ) NzANumber of passed arrays must equal the size of the column Index: z arrays vs z columns.z=Passed arrays should have the same length as the rows Index: z vs z rowszDPassed arrays should be np.ndarray or ExtensionArray instances, got z insteadrP z6Passed arrays should be 1-dimensional, got array with ú dimensions instead.)
|
r^ rX r? rþ r rm r r' rQ rz )rL Ún_rowsZ n_columnsrj rM rM rN r Í s$
|
ÿ
|
ÿÿ
|
ÿz ArrayManager._verify_integrityr_ ÚSingleArrayManager©ÚlocrG c s t dd | jD } fdd| jD }t|trF| ¡ j||d}nBt|r`tj||dj}n(t |rzt
|
j||dj}nt j ||d}t |g| jd gS )zÅ
|
Return the array corresponding to `frame.iloc[loc]`.
|
|
Parameters
|
----------
|
loc : int
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray
|
c S s g | ]
|
}|j qS rM rg ri rM rM rN rk ô s z(ArrayManager.fast_xs.<locals>.<listcomp>c s g | ] }| qS rM rM ri ©r rM rN rk ö s rg rP )r4 r? r r Úconstruct_array_typeÚ_from_sequencer r& Z_ndarrayr r) rm rn r r> )rL r rh r rÁ rM r rN Úfast_xsè s
|
zArrayManager.fast_xsr r r ©Úslobjr` rG c sh | |¡}|dkr( fdd| jD }n|dkr:| j }t| j}|| ¡||< t| ||ddS )Nr c s g | ] }| qS rM rM ri ©r rM rN rk s z*ArrayManager.get_slice.<locals>.<listcomp>rP FrÚ )rc r? r r> Ú_getitem_slicerQ )rL r r` r? r rM r rN Ú get_slice s
|
|
|
zArrayManager.get_slice)r rG c C s | j | }t|g| jd gS )z:
|
Return the data as a SingleArrayManager.
|
r )r? r r> )rL r r rM rM rN Úiget s
|
zArrayManager.igetr c C s
|
| j | S )zY
|
Return the data for column i as the values (ndarray or ExtensionArray).
|
r× )rL r rM rM rN Ú iget_values s zArrayManager.iget_valueszlist[ArrayLike]c C s dd | j D S )zB
|
Used in the JSON C code to access column arrays.
|
c S s g | ]}t |¡qS rM )rm r ri rM rM rN rk " s z.ArrayManager.column_arrays.<locals>.<listcomp>r× rV rM rM rN Ú column_arrays s zArrayManager.column_arraysFzint | slice | np.ndarray)r r« r¸ rG c C sp t |¡rt|tjrB|jdkrB|jd dks2t|dd
df }t|}t|tjt fs^t|jdksltt
|
|t
|
| j d kst|| j |< dS t|t rât|jdk r°|jnd|jdk rÂ|jn| jd |jdk rÚ|jnd}n.t|tjsòt|jdkstt |¡d }|jdks t|jd t
|
| j d ks>tt|D ]$\}}|dd
|f }|| j |< qFdS )aÒ
|
Set new column(s).
|
|
This changes the ArrayManager in-place, but replaces (an) existing
|
column(s), not changing column values in-place).
|
|
Parameters
|
----------
|
loc : integer, slice or boolean mask
|
Positional location (already bounds checked)
|
value : np.ndarray or ExtensionArray
|
inplace : bool, default False
|
Whether overwrite existing array as opposed to replacing it.
|
rw rP Nr rB )r
|
r r rm r rz Úshaper r8 r' rX r> r? r Úrangerû rü r^ rý rh Únonzeror )rL r r« r¸ rÜ Z value_idxZmgr_idxZ value_arrrM rM rN Úiset$ s2
|
|
|
ý zArrayManager.iset)r ÚidxÚ inplace_onlyrG c C sb t |std| j| }t|g| jd g}|r@| ||¡ n | |f|¡}|jd | j|< dS )zù
|
Set values ("setitem") into a single column (not setting the full column).
|
|
This is a method on the ArrayManager level, to avoid creating an
|
intermediate Series at the DataFrame level (`s = df[loc]; s[idx] = value`)
|
z%The column index should be an integerr N)r Ú TypeErrorr? r r> Zsetitem_inplacer¨ )rL r r' r« r( rj rp Únew_mgrrM rM rN Úcolumn_setitem_ s
|
zArrayManager.column_setitemr )r Úitemr« rG c C s | j ||¡}t|dd}|jdkrT|jd dkrD|ddd
f }ntd|j t|}| j ¡ }| ||¡ || _|| j d< dS )z±
|
Insert item at selected position.
|
|
Parameters
|
----------
|
loc : int
|
item : hashable
|
value : np.ndarray or ExtensionArray
|
Tr¡ rw r rP Nz-Expected a 1D array, got an array with shape )
|
rW Úinsertr, rz r# rþ r8 r? r¾ r> )rL r r, r« rî r? rM rM rN r- s s
|
|
ÿ
|
zArrayManager.insertc sZ t j jd t jd}d||< fddt |¡d D _ jd jd | g _ S )z]
|
Delete selected locations in-place (new block and array, same BlockManager)
|
r rg Fc s g | ]} j | qS rM r× rØ rV rM rN rk s z(ArrayManager.idelete.<locals>.<listcomp>rP )rm Úonesr# Úbool_r% r? r> ©rL rª Zto_keeprM rV rN Úidelete s
|
zArrayManager.ideleter; r )rL r
rG c
|
C s¬ g }g }t | jD ]T\}}t|dd}||}|jdkrR|jd dksJt|d }| |¡ | |¡ qt|dkrzd}n|d jd }tt |}| j
|
} t | ||| gS )zã
|
Apply grouped reduction function columnwise, returning a new ArrayManager.
|
|
Parameters
|
----------
|
func : grouped reduction function
|
|
Returns
|
-------
|
ArrayManager
|
rw )rz r rP ) r r? r5 rz r# r r rX r0 r$ rW rQ )
|
rL r
r Zresult_indicesr rj ÚresZnrowsÚindexÚcolumnsrM rM rN Úgrouped_reduce¤ s
|
|
zArrayManager.grouped_reducec
|
C s~ g }t | jD ]<\}}||dd}|tkr0|jnd}| t|gd|d¡ qt tj dgt
|
d¡}| j }t | |||g} | S )zÛ
|
Apply reduction function column-wise, returning a single-row ArrayManager.
|
|
Parameters
|
----------
|
func : reduction function
|
|
Returns
|
-------
|
ArrayManager
|
r rb Nrg ) r r? r rh r r- r0 Z _simple_newrm rn rl rW rQ )
|
rL r
r r rj r2 rh r3 r4 r* rM rM rN ÚreduceË s ÿzArrayManager.reduce)r rG c s4 | j }|j } fddt||D }t| || jS )zO
|
Apply array_op blockwise with another (aligned) BlockManager.
|
c s g | ]\}} ||qS rM rM )rZ r r ©Úarray_oprM rN rk ò s z2ArrayManager.operate_blockwise.<locals>.<listcomp>)r? r rQ r> )rL r r8 Z left_arraysZ right_arraysr rM r7 rN Úoperate_blockwiseë s
|
ÿz ArrayManager.operate_blockwiseZlinear)r` Ú
|
transposedÚ interpolationr0 r )Úqsr` r: r; rG c
|
s dd | j D }|dks t fdd|D }t|D ]6\}}|jdkr8|jd dksbt|j|d ||< q8| jd g} t| || S )Nc S s g | ]}t |d qS )rw )r5 r rM rM rN rk ÿ s z)ArrayManager.quantile.<locals>.<listcomp>rP c s g | ]}t |t j¡ qS rM )r# rm r r r ©r; r< rM rN rk s rw r )r? r r rz r# r> rQ )
|
rL r< r` r: r; ZarrsZnew_arrsr rj rE rM r= rN Úquantile÷ s ÿ
|
zArrayManager.quantilec
|
C s |j \}}|j ¡ r&|}d}d}d}n:t |jjd¡}|||j< d}|j j|j }|jdd}|j|j } t | } g }
|
| j
|
D ]p} t |jd D ]\} |rÈt | | dd
| f || ||dd
| f d} nt | | dd
| f dd } |
|
| ¡ qq~|j}| | jd ¡}||g}t| |
|
|dd
|
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
|
FNrT Tr rb rP rñ ©rò rÚ )Z_indexer_and_to_sortr® rÐ rm Úfullr# ZreshapeZ
|
full_shaper÷ r r? r$ r% r Ú new_indexZget_new_columnsr> rQ )rL Z unstackerr¶ rª Ú_Z new_indexerrò Z
|
new_mask2Drô Z new_indexer2Dré rj r Znew_arrrA Z new_columnsr rM rM rN Úunstack s<
|
|
|
|
ûzArrayManager.unstackNrl rf )r¾ Úna_valuerG c C sè t | jdkr&tj| jtd}| ¡ S |p2|tjk }|sLt dd | jD }t
|
|t r^|j }n.t
|
|t rp|j}n t|r~d}nt|trd}tj| j|d}t| jD ]&\}}|j||d}||dd
|f< q¦|tjk rä||t|< |S )a#
|
Convert the blockmanager data into an numpy array.
|
|
Parameters
|
----------
|
dtype : object, 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 rg c S s g | ]
|
}|j qS rM rg ri rM rM rN rk d s z)ArrayManager.as_array.<locals>.<listcomp>rl r N)rX r? rm r r# ÚfloatZ transposer
|
r· r4 r r* Úsubtyper Z numpy_dtyper r rv r^ r rÀ r! )rL rh r¾ rD Z empty_arrrÁ r rj rM rM rN Úas_arrayC s*
|
|
|
|
zArrayManager.as_array)T)r )F)F)ry r r r rz rO r r r r r! r" r& r+ r- r1 r5 r6 r9 r> rC r
|
r· rG rM rM rM rN r · s: ü ÿ< ÿ#' ú7ür c @ sv e Zd ZU ddgZded< ded< eddddZdGddd
|
d d d dZd dddZe dd Z
|
dHd dddZ e d dddZ edd Zedddd Zed d Zd d Zd!d" Zd#d$ Zed
|
dd%d&Zed
|
dd'd(Zd)d d*d+d,ZdId.d/d d0d1d2Zd dd3d4Zd5d6 Zd dd7d8Zd dd9d:Zd;d d<d=d>Z d?d d@dAdBZ ddCdDdEdFZ dS )Jr r> r? r@ rA z
|
Literal[1]rS c C s dS rÔ rM rV rM rM rN rz s zSingleArrayManager.ndimTrB rC rD c C sv || _ || _|rrt|dks tt|dks0tdd | j D | _ |d }t|}t|d dd }|g| _| ¡ d S )NrP c S s g | ] }t |qS rM r rY rM rM rN rk s z/SingleArrayManager.__init__.<locals>.<listcomp>r )r> r? rX r r8 r7 r )rL r? rE rF rj rM rM rN rO s zSingleArrayManager.__init__c C sT | j \}t| jdkst| jd }t||ks4t|jdksPtd|j dd S )NrP r z5Passed array should be 1-dimensional, got array with r )r# rX r? r rz rþ )rL r rj rM rM rN r s
|
|
ÿz$SingleArrayManager._verify_integrityc C s | S rH rM rb rM rM rN rc ¦ s z"SingleArrayManager._normalize_axisNc C s6 |dkrt g tdg}tjg | jd}t| |g|S )z9Return an empty ArrayManager with index/array of length 0Nrg )r0 rl rm rn rh rQ )rL rE rn rM rM rN rR ª s z SingleArrayManager.make_emptyc C s | |g|gS rH rM )Úclsrn r3 rM rM rN Ú
|
from_array± s z SingleArrayManager.from_arrayc C s | j S rH rU rV rM rM rN rE µ s zSingleArrayManager.axesr0 c C s
|
| j d S )Nr rU rV rM rM rN r3 ¹ s zSingleArrayManager.indexc C s | j jS rH )rn rh rV rM rM rN rh ½ s zSingleArrayManager.dtypec C s
|
t | jS )z$The array that Series.values returns)r6 rn rV rM rM rN r6 Á s z"SingleArrayManager.external_valuesc C s | j S )z%The array that Series._values returns)rn rV rM rM rN Úinternal_valuesÅ s z"SingleArrayManager.internal_valuesc C s | j }t|tjrt|}|S )z#The array that Series.array returns)rn r rm r r( )rL rj rM rM rN Ú array_valuesÉ s z SingleArrayManager.array_valuesc C s( t | jtjr | jjjdkS | jjS d S )N)Úbr Úu)r rn rm r rh ÚkindÚ _can_hold_narV rM rM rN rO Ð s z SingleArrayManager._can_hold_nac C s dS rÍ rM rV rM rM rN rÕ Ø s z"SingleArrayManager.is_single_blockr_ r c C s t dd S )Nz Use series._values[loc] insteadrI )rL r rM rM rN r Ü s zSingleArrayManager.fast_xsr r r r c C s> || j krtd| j| }| j |¡}t| |g|gddS )Nrð FrÚ )rz rõ rn r3 r rQ )rL r r` Ú new_arrayrA rM rM rN r ß s
|
|
|
z SingleArrayManager.get_slicec C s& | j | }| j| }t| |g|gS rH )rn r3 rQ )rL rª rP rA rM rM rN Ú getitem_mgrç s
|
|
z SingleArrayManager.getitem_mgrc K s< t |r|| jf|}nt| j|f |}t| |g| jS rH )r rn r rQ r> )rL r
r rP rM rM rN r ì s zSingleArrayManager.applyc C s8 t |tjr(|j| jkr(td| j | jd||dS )zÓ
|
Set values with indexer.
|
|
For SingleArrayManager, this backs s[indexer] = value
|
|
See `setitem_inplace` for a version that works inplace and doesn't
|
return a new Manager.
|
z Cannot set values with ndim > r¨ r© )r rm r rz rþ r r¬ rM rM rN r¨ ó s zSingleArrayManager.setitemc C sF t j| jd t jd}d||< | jd | g| _| jd | g| _| S )zS
|
Delete selected locations in-place (new array, same ArrayManager)
|
r rg F)rm r. r# r/ r? r> r0 rM rM rN r1 s
|
zSingleArrayManager.ideleter )rÖ rG c C s, || j r t| | j| jddS | ¡ S d S )NFrÚ )rn rQ r? r> rR )rL rÖ rM rM rN rÝ s
|
z#SingleArrayManager._get_data_subsetr )r rG c C s || j d< dS )zá
|
Set (replace) the values of the SingleArrayManager in place.
|
|
Use at your own risk! This does not check if the passed values are
|
valid for the current SingleArrayManager (length, dtype, etc).
|
r Nr× )rL r rM rM rN Ú
|
set_values s z SingleArrayManager.set_valuesr )r4 rG c C s( | j d g}| jd |g}t||ddS )z5
|
Manager analogue of Series.to_frame
|
r FrÚ )r? rE r )rL r4 r? rE rM rM rN Ú to_2d_mgr s z SingleArrayManager.to_2d_mgr)T)N)r ) ry r r r
|
r r rz rO r r rc rR Ú classmethodrI rE r3 rh r6 rJ rK rO rÕ r r rQ r r¨ r1 rÝ rR rS rM rM rM rN r { sJ
|
þ ü
|
|
|
r c @ sF e Zd ZdZdZdddddZedd d
|
d Zd d dddZdS )rÿ ab
|
Proxy object for an all-NA array.
|
|
Only stores the length of the array, and not the dtype. The dtype
|
will only be known when actually concatenating (after determining the
|
common dtype, for which this proxy is ignored).
|
Using this object avoids that the internals/concat.py needs to determine
|
the proper dtype and array type.
|
rP r_ rC )r° rG c C s
|
|| _ d S rH ©r° )rL r° rM rM rN rO 2 s zNullArrayProxy.__init__z
|
tuple[int]rS c C s | j fS rH rU rV rM rM rN r# 5 s zNullArrayProxy.shaper r )rh rG c C st t |tr>| ¡ jg |d}tj| jtjd }|j|ddS t |}t
|
|}tj | j|d}| |¡ t |S dS )a'
|
Helper function to create the actual all-NA array from the NullArrayProxy
|
object.
|
|
Parameters
|
----------
|
arr : NullArrayProxy
|
dtype : the dtype for the resulting array
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray
|
rg Tr? N)r r r r rm r. r° rÙ rÛ r r" r r r+ )rL rh r rª r¶ rj rM rM rN Úto_array9 s
|
|
zNullArrayProxy.to_arrayN) ry r r r rz rO r r# rV rM rM rM rN rÿ % s
|
rÿ )Xr Ú
|
__future__r Útypingr r r r r Únumpyrm Z pandas._libsr r r¼ r
|
Zpandas._typingr r r r r Zpandas.util._validatorsr Zpandas.core.dtypes.astyper Zpandas.core.dtypes.castr r Zpandas.core.dtypes.commonr r r r r r r r Zpandas.core.dtypes.dtypesr r Zpandas.core.dtypes.genericr r Zpandas.core.dtypes.missingr r! r" Zpandas.core.algorithmsÚcoreZ
|
algorithmsZ pandas.core.array_algos.quantiler# Z pandas.core.array_algos.taker% Zpandas.core.arraysr& r' r( r) Zpandas.core.arrays.sparser* Zpandas.core.constructionr+ r, r- Zpandas.core.indexersr. r/ Zpandas.core.indexes.apir0 r1 Zpandas.core.internals.baser2 r3 r4 Z pandas.core.internals.blocksr5 r6 r7 r8 r9 r: r; r< r r rÿ rM rM rM rN Ú<module> sF (
|
X G +
|
