U
|
¬ý°d¶³ ã @ sF d dl mZ d dlZd dlmZmZ d dlZd dlm Z d dl
|
m Z d dl m mZ d dlmZ d dlmZmZmZmZmZmZmZmZ d dlm Z m Z m Z d d l m Z d dl!Z"d d
|
l!m#Z#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/m0Z0m1Z1m2Z2m3Z3m4Z4 d d l5m6Z6 d dl7m8Z8 d dl9m:Z: d dl;m<Z< dmdddddddZ=dd Z>dnd dd d d Z?dod!d!d"d d d d ddd#dd$ d%d&Z@dpd"d#dd(d)d*ZAdqd#d#dd,d-d.ZBdd/d0d1ZCdd/d2d3ZDdrd d d#dd5d6d7ZEdsdd#dd(d9d:ZFdtd#dd<d=d>ZGdud#d dd@dAdBZHdvd#d dd@dDdEZIdwdFdGZJdxd dd#ddJdKdLZKdydd ddd#ddNdOdPZLdzd dHdRddd d d d d d d d ddd#d d ddSdTdUZMd{dddd d d d d d d d d ddd#ddWdXdYZNdd/dZd[ZOdd/d\d]ZPdd/d^d_ZQdd/d`daZRd d/dbdcZSdQddddddedfdgZTd|dhdiddjdkdlZUdS )}é )Ú annotationsN)ÚLiteralÚcast)Úis_matching_na)Ú SparseIndex)Ú compare_mismatched_resolutions)Úis_boolÚis_categorical_dtypeÚis_extension_array_dtypeÚis_integer_dtypeÚis_interval_dtypeÚ is_numberÚis_numeric_dtypeÚneeds_i8_conversion)ÚCategoricalDtypeÚDatetimeTZDtypeÚ PandasDtype)Úarray_equivalent)
|
Ú CategoricalÚ DataFrameÚ DatetimeIndexÚIndexÚ IntervalIndexÚ
|
MultiIndexÚ PeriodIndexÚ
|
RangeIndexÚSeriesÚTimedeltaIndex)Útake_nd)Ú DatetimeArrayÚExtensionArrayÚ IntervalArrayÚ PeriodArrayÚTimedeltaArray)ÚDatetimeLikeArrayMixin)Ú StringDtype)Úsafe_sort_index)Ú pprint_thingÚequivçñhãµøä>ç:0âyE>zbool | Literal['equiv']ÚfloatÚNone)Ú check_dtypeÚrtolÚatolÚreturnc K sô t | tr(t| |fd|||d| nÈt | trPt| |fd|||d| n t | trxt| |fd|||d| nx|rÐt| rt|rnBt| r t|r n0t | t j
|
s¸t |t j
|
r¾d}nd}t | ||d t j | |ft|||d| dS ) aØ
|
Check that the left and right objects are approximately equal.
|
|
By approximately equal, we refer to objects that are numbers or that
|
contain numbers which may be equivalent to specific levels of precision.
|
|
Parameters
|
----------
|
left : object
|
right : object
|
check_dtype : bool or {'equiv'}, default 'equiv'
|
Check dtype if both a and b are the same type. If 'equiv' is passed in,
|
then `RangeIndex` and `Index` with int64 dtype are also considered
|
equivalent when doing type checking.
|
rtol : float, default 1e-5
|
Relative tolerance.
|
|
.. versionadded:: 1.1.0
|
atol : float, default 1e-8
|
Absolute tolerance.
|
|
.. versionadded:: 1.1.0
|
F)Ú check_exactÚexactr. r/ )r1 r- r. r/ ú numpy arrayÚInput©Úobj)r- r. r/ N)Ú
|
isinstancer Úassert_index_equalr Úassert_series_equalr Úassert_frame_equalr r ÚnpÚndarrayÚassert_class_equalÚ_testingÚassert_almost_equalÚbool)ÚleftÚrightr- r. r/ Úkwargsr6 © rD úPd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/_testing/asserters.pyr? = sn
|
þúù
|
|
þúù
|
|
þúù ÿ ÿÿr? c C sZ |j }t| |s.t| d| dt| dt||sVt| d| dt| ddS )aª
|
Helper method for our assert_* methods that ensures that
|
the two objects being compared have the right type before
|
proceeding with the comparison.
|
|
Parameters
|
----------
|
left : The first object being compared.
|
right : The second object being compared.
|
cls : The class type to check against.
|
|
Raises
|
------
|
AssertionError : Either `left` or `right` is not an instance of `cls`.
|
z Expected type z, found z insteadN)Ú__name__r7 ÚAssertionErrorÚtype)rA rB ÚclsZcls_namerD rD rE Ú_check_isinstance s
|
ÿ
|
ÿrJ Tr@ )Ú compare_keysr0 c C s t | |t tj| ||d d S )N)rK )rJ Údictr> Úassert_dict_equal)rA rB rK rD rD rE rM ¯ s rM r z
|
bool | strÚstr) rA rB r2 Ú check_namesr1 Úcheck_categoricalÚ check_orderr. r/ r6 r0 c
|
s¬ d}
|
d ddd fdd } dd } t | |t | | || d
|
| j|jkr| d } | j d | }|j d | }t| | || t| t|krÎ| d } t| d | }t| d | }t| | || |sât| } t|}| jdkrftt| } tt|}t| jD ]X}| | |}| ||}d| d}t |||||||d | | j
|
| |j
|
| | d
|
q |rè rè| |¡s| j |j k}t |r¤td| d¡}t | t¡¡d t| }| dt |d¡ d}t| || | n&t}tj| j|j|||| | |d |r$td| || d
|
t| ts<t|trLtd| || d
|
t| tsdt|trrt | j |j r¨t | j st |j r¨t | j |j | dd
|
dS ) aÎ
|
Check that left and right Index are equal.
|
|
Parameters
|
----------
|
left : Index
|
right : Index
|
exact : bool or {'equiv'}, default 'equiv'
|
Whether to check the Index class, dtype and inferred_type
|
are identical. If 'equiv', then RangeIndex can be substituted for
|
Index with an int64 dtype as well.
|
check_names : bool, default True
|
Whether to check the names attribute.
|
check_exact : bool, default True
|
Whether to compare number exactly.
|
check_categorical : bool, default True
|
Whether to compare internal Categorical exactly.
|
check_order : bool, default True
|
Whether to compare the order of index entries as well as their values.
|
If True, both indexes must contain the same elements, in the same order.
|
If False, both indexes must contain the same elements, but in any order.
|
|
.. versionadded:: 1.2.0
|
rtol : float, default 1e-5
|
Relative tolerance. Only used when check_exact is False.
|
|
.. versionadded:: 1.1.0
|
atol : float, default 1e-8
|
Absolute tolerance. Only used when check_exact is False.
|
|
.. versionadded:: 1.1.0
|
obj : str, default 'Index'
|
Specify object name being compared, internally used to show appropriate
|
assertion message.
|
|
Examples
|
--------
|
>>> from pandas import testing as tm
|
>>> a = pd.Index([1, 2, 3])
|
>>> b = pd.Index([1, 2, 3])
|
>>> tm.assert_index_equal(a, b)
|
Tr rN r, ©r6 r0 c sz sd S t | ||d td| ||d t| jrft|jrf rbtd| ||d t| j|jd d S td| ||d d S )N)r2 r6 Z inferred_typer5 Údtype)r2 )r= Úassert_attr_equalr rS r8 Ú
|
categories©rA rB r6 ©rP r2 rD rE Ú _check_typesì s z(assert_index_equal.<locals>._check_typesc S s: | j | }| j| }t|j||jd}|j|| j| dS )N)Ú
|
fill_value)Úname)ÚlevelsÚcodesr Ú_valuesZ _na_valueZ _shallow_copyÚnames)ÚindexÚlevelÚuniqueZ level_codesZfilledrD rD rE Ú_get_ilevel_valuesü s
|
|
z.assert_index_equal.<locals>._get_ilevel_valuesr5 z levels are differentú, z length are differenté zMultiIndex level [ú])r2 rO r1 r. r/ r6 r ç Y@ú values are different (é ú %))r. r/ r- r6 ÚlobjZrobjr^ Úfreqú categoryN)r ) rJ r ZnlevelsÚraise_assert_detailÚlenr& r r Úranger8 r[ Úequalsr] r
|
Zfillnar; ÚsumZastypeÚintÚroundr@ r> r? ÚvaluesrT r7 r r Úassert_interval_array_equalr rS Úassert_categorical_equal)rA rB r2 rO r1 rP rQ r. r/ r6 Ú__tracebackhide__rX rb Úmsg1Úmsg2Zmsg3r` ZllevelZrlevelrj ZmismatchÚdiffÚmsgZ
|
exact_boolrD rW rE r8 ´ s 6
|
|
|
|
|
|
ø
|
ø r8 r4 )r2 r6 r0 c C sp d}dd }ddddd}t | t |kr0d S |d
|
krL|| rL||rLd S | d }t|||| || d S ) z#
|
Checks classes are equal.
|
Tc S s t | tr| S t| jS )N)r7 r rH rF )ÚxrD rD rE Ú
|
repr_classb s
|
z&assert_class_equal.<locals>.repr_classr r@ )Úidxr0 c S s t | tkpt| tS )zµClasses that are a RangeIndex (sub-)instance or exactly an `Index` .
|
|
This only checks class equivalence. There is a separate check that the
|
dtype is int64.
|
)rH r r7 r )r~ rD rD rE Úis_class_equivi s z*assert_class_equal.<locals>.is_class_equivNr( z classes are different)rH rm )rA rB r2 r6 rw r} r r{ rD rD rE r= Z s
|
r= Ú
|
Attributes)Úattrr6 r0 c C s¢ d}t || }t || }||ks*t||r.dS z ||k}W n tk
|
rR d}Y nX |tjk|tjkA rnd}nt|ts| ¡ }|sd| d}t|||| dS )aO
|
Check attributes are equal. Both objects must have attribute.
|
|
Parameters
|
----------
|
attr : str
|
Attribute name being compared.
|
left : object
|
right : object
|
obj : str, default 'Attributes'
|
Specify object name being compared, internally used to show appropriate
|
assertion message
|
TNFz Attribute "z" are different) Úgetattrr Ú TypeErrorÚpdZNAr7 r@ Úallrm ) r rA rB r6 rw Z left_attrZ
|
right_attrÚresultr{ rD rD rE rT | s"
|
|
|
|
rT )r0 c C s dd l m} t| ttjfrX| ¡ D ]0}dtt|j }t||j
|
t fs$t |q$n.dtt| j }t| |j tt fst |d S )Nr zBone of 'objs' is not a matplotlib Axes instance, type encountered zoobjs is neither an ndarray of Artist instances nor a single ArtistArtist instance, tuple, or dict, 'objs' is a )Zmatplotlib.pyplotZpyplotr7 r r; r< ZravelÚreprrH rF ZAxesrL rG ZArtistÚtuple)ÚobjsZpltÚelr{ rD rD rE Ú"assert_is_valid_plot_return_object£ s ÿ ÿr c C s. t | ttfr| j} t| t t | ¡¡ dS )z#Assert that the sequence is sorted.N)r7 r r rt Úassert_numpy_array_equalr; ÚsortÚarray)ÚseqrD rD rE Úassert_is_sorted¶ s r r )r- Úcheck_category_orderr6 r0 c C sø t | |t t| jts$t|jtr*d}nd}|rht| j|j| d|d t| j|j|| dd n|z| j ¡ }|j ¡ }W n" t k
|
r¢ | j|j }}Y nX t||| d|d t| j
|
| j¡|j
|
|j¡| d|d t d| ||d d
|
S ) a}
|
Test that Categoricals are equivalent.
|
|
Parameters
|
----------
|
left : Categorical
|
right : Categorical
|
check_dtype : bool, default True
|
Check that integer dtype of the codes are the same.
|
check_category_order : bool, default True
|
Whether the order of the categories should be compared, which
|
implies identical integer codes. If False, only the resulting
|
values are compared. The ordered attribute is
|
checked regardless.
|
obj : str, default 'Categorical'
|
Specify object name being compared, internally used to show appropriate
|
assertion message.
|
r( Tz .categories)r6 r2 z.codes©r- r6 z.valuesZorderedr5 N) rJ r r7 rU r r8 r r\ Z sort_valuesr ZtakerT )rA rB r- r r6 r2 ÚlcÚrcrD rD rE rv ¾ sB ÿ ÿ ÿ
|
ürv r! c C sz t | |t i }| jjjdkr&d|d< t| j|jfd| di| t| j|jfd| di| td| ||d dS ) a
|
Test that two IntervalArrays are equivalent.
|
|
Parameters
|
----------
|
left, right : IntervalArray
|
The IntervalArrays to compare.
|
exact : bool or {'equiv'}, default 'equiv'
|
Whether to check the Index class, dtype and inferred_type
|
are identical. If 'equiv', then RangeIndex can be substituted for
|
Index with an int64 dtype as well.
|
obj : str, default 'IntervalArray'
|
Specify object name being compared, internally used to show appropriate
|
assertion message
|
)ÚmÚMFÚ
|
check_freqr6 z.leftÚclosedr5 N)rJ r! Ú_leftrS ÚkindÚ assert_equalZ_rightrT )rA rB r2 r6 rC rD rD rE ru û s ru r" rR c C s8 t | |t t| j|j| dd td| ||d d S )Nú ._ndarrayr5 rk )rJ r" r Ú_ndarrayrT rV rD rD rE Úassert_period_array_equal s r r )r6 r r0 c C sP d}t | |t t| j|j| dd |r<td| ||d td| ||d d S )NTr r5 rk Útz)rJ r r r rT ©rA rB r6 r rw rD rD rE Úassert_datetime_array_equal! s r¡ r# c C s@ d}t | |t t| j|j| dd |r<td| ||d d S )NTr r5 rk )rJ r# r r rT r rD rD rE Ú assert_timedelta_array_equal- s
|
r¢ c C sØ d}| d| }t |tjr0|dt| 7 }t |tjrFt|}nt |tttfr^t|}t |tjrtt|}nt |tttfrt|}|d| d| 7 }|d k r¶|d| 7 }|d k rÌ|d| 7 }t|d S )NTz are different
|
|
z
|
|
[index]: z
|
|
[left]: z
|
|
[right]: z
|
[diff]: Ú
|
) r7 r; r< r' r r r% r rG ) r6 ÚmessagerA rB rz Z
|
first_diffÚ index_valuesrw r{ rD rD rE rm 7 s0 þ
|
|
ÿþrm Fr3 )Ú
|
strict_nanr- r6 r0 c sè d}t | |d t| |tj dd } | | }
|
| |} |dkrd|
|
| k rtt|
|
dt| n*|dkr|
|
| krtt|
|
dt| fd d
|
} t| |d s¸| | || |rät| tjrät|tjrätd | |d d S )a+
|
Check that 'np.ndarray' is equivalent.
|
|
Parameters
|
----------
|
left, right : numpy.ndarray or iterable
|
The two arrays to be compared.
|
strict_nan : bool, default False
|
If True, consider NaN and None to be different.
|
check_dtype : bool, default True
|
Check dtype if both a and b are np.ndarray.
|
err_msg : str, default None
|
If provided, used as assertion message.
|
check_same : None|'copy'|'same', default None
|
Ensure left and right refer/do not refer to the same memory area.
|
obj : str, default 'numpy array'
|
Specify object name being compared, internally used to show appropriate
|
assertion message.
|
index_values : numpy.ndarray, default None
|
optional index (shared by both left and right), used in output.
|
Tr5 c S s t | dd d k r| jS | S )NÚbase)r r§ r5 rD rD rE Ú _get_base s z+assert_numpy_array_equal.<locals>._get_baseZsamez is not Úcopyz is c s |d kr| j |j kr,t d| j |j d}t| |D ] \}}t||ds:|d7 }q:|d | j } dt |d¡ d}t|| | d t|d S )
|
Nz shapes are differentr ©r¦ rd rf rg rh ri )r¥ )Úshaperm Úzipr Úsizer; rs rG )rA rB Úerr_msgrz Zleft_arrZ right_arrr{ ©r¥ r6 r¦ rD rE Ú_raise s ÿ
|
z(assert_numpy_array_equal.<locals>._raiserª rS N) r= rJ r; r< rG r r r7 rT ) rA rB r¦ r- r® Z
|
check_samer6 r¥ rw r¨ Z left_baseZ
|
right_baser° rD r¯ rE r Z s$ r r )r- r1 r. r/ r6 r0 c C s¨ t | tstdt |ts$td|r>td| |d| d t | trt |trt|t| kr|sö| jjdkröt | jtjst t
|
| jj }nt | j¡d }t |jtjsÄt t
|
| jj } nt |j¡d } || kröt | j|jtj ¡ rödS tt | j¡t |j¡||d dS t | ¡ ¡}
|
t | ¡ ¡} t|
|
| | d
|
|d | |
|
jtd } || jtd } |rt| | ||d n tj| | t|||||d dS )a"
|
Check that left and right ExtensionArrays are equal.
|
|
Parameters
|
----------
|
left, right : ExtensionArray
|
The two arrays to compare.
|
check_dtype : bool, default True
|
Whether to check if the ExtensionArray dtypes are identical.
|
index_values : numpy.ndarray, default None
|
Optional index (shared by both left and right), used in output.
|
check_exact : bool, default False
|
Whether to compare number exactly.
|
rtol : float, default 1e-5
|
Relative tolerance. Only used when check_exact is False.
|
|
.. versionadded:: 1.1.0
|
atol : float, default 1e-8
|
Absolute tolerance. Only used when check_exact is False.
|
|
.. versionadded:: 1.1.0
|
obj : str, default 'ExtensionArray'
|
Specify object name being compared, internally used to show appropriate
|
assertion message.
|
|
.. versionadded:: 2.0.0
|
|
Notes
|
-----
|
Missing values are checked separately from valid values.
|
A mask of missing values is computed for each and checked to match.
|
The remaining all-valid values are cast to object dtype and checked.
|
|
Examples
|
--------
|
>>> from pandas import testing as tm
|
>>> a = pd.Series([1, 2, 3, 4])
|
>>> b, c = a.array, a.array
|
>>> tm.assert_extension_array_equal(b, c)
|
z left is not an ExtensionArrayz right is not an ExtensionArrayrS úAttributes of r5 ZmMr N)r¥ r6 z NA mask)r6 r¥ )rS )r- r. r/ r6 r¥ )r7 r rG rT r$ rH rS r r; r r ÚunitZ datetime_datar r ÚoperatorÚeqr
r ÚasarrayZasi8ZisnaZto_numpyÚobjectr> r? r@ )rA rB r- r¥ r1 r. r/ r6 Zl_unitZr_unitZleft_naZright_naZ
|
left_validZ right_validrD rD rE Ú assert_extension_array_equalª sv 2ÿþýÿ ÿþ
|
|
ü ÿ ÿùr· r )Ú check_indexÚ
|
check_like)r- Úcheck_index_typeÚcheck_series_typerO r1 Úcheck_datetimelike_compatrP r r Ú check_flagsr. r/ r6 r¸ r¹ r0 c C sô d}|s|rt dt| |t |r2t| ||d t| t|krxt| d| j }t| d|j }t|d|| | r¦| j|jks¦tt | j dt |j |rÒt
|
| j|j||||| | | | dd
|
|rà| |¡} |
|
r"t | jt tfr"| j}|j}|j|jks"t|j|jf|rbt | jtrLt |jtrL|sLntd | |d
|
| d |ræt| jræt|jræ| j}|j}t |trÄt |trÄt|||t | j¡t|d n t|||t|t | j¡d n¸|r>t| jst|jr>t | j t |j¡sd | j d|j d}t|n`t | jrht |jrht | j |j n6t | jtst |jtr²t!j"| j|j| | t#|t|t | j¡d nìt$| jròt$|jròt| j|j| | |t | j¡t|d n¬t%| j|jst%|j| jr6t| j|j|t | j¡t|d nht| jrrt|jrrt| j|j|t | j¡t|d n,t!j"| j|j| | t#|t|t | j¡d |r´td| ||d |rðt | jtsÖt |jtrðt&| j|j| d| d dS )a¦
|
Check that left and right Series are equal.
|
|
Parameters
|
----------
|
left : Series
|
right : Series
|
check_dtype : bool, default True
|
Whether to check the Series dtype is identical.
|
check_index_type : bool or {'equiv'}, default 'equiv'
|
Whether to check the Index class, dtype and inferred_type
|
are identical.
|
check_series_type : bool, default True
|
Whether to check the Series class is identical.
|
check_names : bool, default True
|
Whether to check the Series and Index names attribute.
|
check_exact : bool, default False
|
Whether to compare number exactly.
|
check_datetimelike_compat : bool, default False
|
Compare datetime-like which is comparable ignoring dtype.
|
check_categorical : bool, default True
|
Whether to compare internal Categorical exactly.
|
check_category_order : bool, default True
|
Whether to compare category order of internal Categoricals.
|
|
.. versionadded:: 1.0.2
|
check_freq : bool, default True
|
Whether to check the `freq` attribute on a DatetimeIndex or TimedeltaIndex.
|
|
.. versionadded:: 1.1.0
|
check_flags : bool, default True
|
Whether to check the `flags` attribute.
|
|
.. versionadded:: 1.2.0
|
|
rtol : float, default 1e-5
|
Relative tolerance. Only used when check_exact is False.
|
|
.. versionadded:: 1.1.0
|
atol : float, default 1e-8
|
Absolute tolerance. Only used when check_exact is False.
|
|
.. versionadded:: 1.1.0
|
obj : str, default 'Series'
|
Specify object name being compared, internally used to show appropriate
|
assertion message.
|
check_index : bool, default True
|
Whether to check index equivalence. If False, then compare only values.
|
|
.. versionadded:: 1.3.0
|
check_like : bool, default False
|
If True, ignore the order of the index. Must be False if check_index is False.
|
Note: same labels must be with the same data.
|
|
.. versionadded:: 1.5.0
|
|
Examples
|
--------
|
>>> from pandas import testing as tm
|
>>> a = pd.Series([1, 2, 3, 4])
|
>>> b = pd.Series([1, 2, 3, 4])
|
>>> tm.assert_series_equal(a, b)
|
Tz0check_like must be False if check_index is Falser5 rc zSeries length are differentú != ú.index©r2 rO r1 rP rQ r. r/ r6 rS r± )r- r¥ r6 )r- r6 r¥ z[datetimelike_compat=True] z is not equal to Ú.)r. r/ r- r6 r¥ )r. r/ r- r¥ r6 rZ rl )r6 r N)'Ú
|
ValueErrorrJ r r= rn r_ rm ÚflagsrG r r8 Ú reindex_liker7 r r rk rS r rT r r] r r· r; rµ rN r r r rp r ru r r> r? r@ r
|
Ú0is_extension_array_dtype_and_needs_i8_conversionrv )rA rB r- rº r» rO r1 r¼ rP r r r½ r. r/ r6 r¸ r¹ rw rx ry ZlidxZridxZ left_valuesZ right_valuesr{ rD rD rE r9 s S *ö
|
|
ÿ
|
þý ÿ
|
û
|
û
|
ÿÿ ÿ ÿ
|
ù
|
ù ÿ þ
|
û
|
û
|
ù ÿür9 r )r- rº Úcheck_column_typeÚcheck_frame_typerO Ú by_blocksr1 r¼ rP r¹ r r½ r. r/ r6 r0 c C s d}t | |t |r&t| t|s&t| j|jkrVt|| dt| j t|j | r| j|jkstt| j dt|j t | j
|
|j
|
||||
|
| ||| dd
|
t | j |j ||||
|
| ||| dd
|
| râ| |¡} |rV| ¡ }| ¡ }ttt| ¡ t| ¡ D ]:}||ks*t||ks8tt|| || ||d qnht| j D ]\\}}| j|dd }|j|dd }t||||||| |
|
| | d
|
| d | d ||d d d q`dS )a]
|
Check that left and right DataFrame are equal.
|
|
This function is intended to compare two DataFrames and output any
|
differences. It is mostly intended for use in unit tests.
|
Additional parameters allow varying the strictness of the
|
equality checks performed.
|
|
Parameters
|
----------
|
left : DataFrame
|
First DataFrame to compare.
|
right : DataFrame
|
Second DataFrame to compare.
|
check_dtype : bool, default True
|
Whether to check the DataFrame dtype is identical.
|
check_index_type : bool or {'equiv'}, default 'equiv'
|
Whether to check the Index class, dtype and inferred_type
|
are identical.
|
check_column_type : bool or {'equiv'}, default 'equiv'
|
Whether to check the columns class, dtype and inferred_type
|
are identical. Is passed as the ``exact`` argument of
|
:func:`assert_index_equal`.
|
check_frame_type : bool, default True
|
Whether to check the DataFrame class is identical.
|
check_names : bool, default True
|
Whether to check that the `names` attribute for both the `index`
|
and `column` attributes of the DataFrame is identical.
|
by_blocks : bool, default False
|
Specify how to compare internal data. If False, compare by columns.
|
If True, compare by blocks.
|
check_exact : bool, default False
|
Whether to compare number exactly.
|
check_datetimelike_compat : bool, default False
|
Compare datetime-like which is comparable ignoring dtype.
|
check_categorical : bool, default True
|
Whether to compare internal Categorical exactly.
|
check_like : bool, default False
|
If True, ignore the order of index & columns.
|
Note: index labels must match their respective rows
|
(same as in columns) - same labels must be with the same data.
|
check_freq : bool, default True
|
Whether to check the `freq` attribute on a DatetimeIndex or TimedeltaIndex.
|
|
.. versionadded:: 1.1.0
|
check_flags : bool, default True
|
Whether to check the `flags` attribute.
|
rtol : float, default 1e-5
|
Relative tolerance. Only used when check_exact is False.
|
|
.. versionadded:: 1.1.0
|
atol : float, default 1e-8
|
Absolute tolerance. Only used when check_exact is False.
|
|
.. versionadded:: 1.1.0
|
obj : str, default 'DataFrame'
|
Specify object name being compared, internally used to show appropriate
|
assertion message.
|
|
See Also
|
--------
|
assert_series_equal : Equivalent method for asserting Series equality.
|
DataFrame.equals : Check DataFrame equality.
|
|
Examples
|
--------
|
This example shows comparing two DataFrames that are equal
|
but with columns of differing dtypes.
|
|
>>> from pandas.testing import assert_frame_equal
|
>>> df1 = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
|
>>> df2 = pd.DataFrame({'a': [1, 2], 'b': [3.0, 4.0]})
|
|
df1 equals itself.
|
|
>>> assert_frame_equal(df1, df1)
|
|
df1 differs from df2 as column 'b' is of a different type.
|
|
>>> assert_frame_equal(df1, df2)
|
Traceback (most recent call last):
|
...
|
AssertionError: Attributes of DataFrame.iloc[:, 1] (column name="b") are different
|
|
Attribute "dtype" are different
|
[left]: int64
|
[right]: float64
|
|
Ignore differing dtypes in columns with check_dtype.
|
|
>>> assert_frame_equal(df1, df2, check_dtype=False)
|
Tz shape mismatchr¾ r¿ rÀ z.columnsr rd )Zaxisz .iloc[:, z] (column name="z")F) r- rº r1 rO r¼ rP r r6 r. r/ r¸ r½ N)rJ r r7 rH rG r« rm r rà r8 r_ ÚcolumnsrÄ Z_to_dict_of_blocksÚlistÚsetÚkeysr: Ú enumerateZ_ixsr9 )rA rB r- rº rÆ rÇ rO rÈ r1 r¼ rP r¹ r r½ r. r/ r6 rw ZrblocksZlblocksrS ÚiÚcolZlcolZrcolrD rD rE r: s o
|
|
ÿ*öö
|
$ ÿ òr: c K sf d}t | trJt| |f| t | ttfrF| j|jksFt| j|jfnt | trdt| |f| nþt | t r~t
|
| |f| nät | t rt | |f| nÊt | t r²t| |f| n°t | trÌt| |f| nt | træt| |f| n|t | trt| |f| n`t | tjr t| |f| nBt | trJ|i ks:t| |ksbtn|i ksXtt| | dS )aC
|
Wrapper for tm.assert_*_equal to dispatch to the appropriate test function.
|
|
Parameters
|
----------
|
left, right : Index, Series, DataFrame, ExtensionArray, or np.ndarray
|
The two items to be compared.
|
**kwargs
|
All keyword arguments are passed through to the underlying assert method.
|
TN)r7 r r8 r r rk rG r r9 r r: r! ru r" r r r¡ r# r¢ r r· r; r< r rN r? )rA rB rC rw rD rD rE r Ú s4
|
|
|
|
|
|
|
r c C s t | |tjj t| j|j t| jts.t t|jts>t | j}|j}|
|
|¡sdt dd|| n t d| | t d| | t| ¡ | ¡ dS )z
|
Check that the left and right SparseArray are equal.
|
|
Parameters
|
----------
|
left : SparseArray
|
right : SparseArray
|
zSparseArray.indexzindex are not equalrY rS N)rJ r ZarraysZ SparseArrayr Z sp_valuesr7 Zsp_indexr rG rp rm rT Zto_dense)rA rB Z
|
left_indexZ right_indexrD rD rE Úassert_sp_array_equal s
|
ÿ rÐ c C s( | D ] }||kst dt| qd S )NzDid not contain item: )rG r )ÚiterableZdicÚkrD rD rE Úassert_contains_all$ s rÓ c K sX t | |D ]H\}}t||f| dtt| dtt| d}||k s
|
t|q
|
dS )zï
|
iter1, iter2: iterables that produce elements
|
comparable with assert_almost_equal
|
|
Checks that the elements are equal, but not
|
the same object. (Does not check that items
|
in sequences are also not the same object)
|
zExpected object z and object z8 to be different objects, but they were the same object.N)r¬ r? r rH rG )Ziter1Ziter2Z
|
eql_kwargsZelem1Zelem2r{ rD rD rE Ú assert_copy) s
|
ÿrÔ c C s t | ot|S )z¸
|
Checks that we have the combination of an ExtensionArraydtype and
|
a dtype that should be converted to int64
|
|
Returns
|
-------
|
bool
|
|
Related to issue #37609
|
)r
|
r )Z
|
left_dtypeZ right_dtyperD rD rE rÅ ; s rÅ Úslice)ÚserÚl_slcÚi_slcr0 c C s6 | j | }t| j| | t| js2t| | | dS )z_
|
Check that ser.iloc[i_slc] matches ser.loc[l_slc] and, if applicable,
|
ser[l_slc].
|
N)Zilocr9 Úlocr r_ )rÖ r× rØ ÚexpectedrD rD rE Ú!assert_indexing_slices_equivalentI s
|
|
rÛ zDataFrame | SerieszDataFrame | Series | None)rA rB r0 c C sF | j D ]:}t| |d}|dkr,|dks@tq|t||dkstqdS )z:
|
Check that ._metadata attributes are equivalent.
|
N)Ú _metadatar rG )rA rB r ÚvalrD rD rE Úassert_metadata_equivalentW s
|
|
rÞ )r( r) r* )T)r( TTTTr) r* r )Tr4 )r )TTr )r( r! )r" )r T)r# T)NNN)FTNNr3 N)TNFr) r* r ) Tr( TTFFTTTTr) r* r )Tr( r( TTFFFTFTTr) r* r )N)VÚ
|
__future__r r³ Útypingr r Únumpyr; Zpandas._libs.missingr Zpandas._libs.sparser Zpandas._libs.testingZ_libsZtestingr> Z pandas._libs.tslibs.np_datetimer Zpandas.core.dtypes.commonr r r
|
r r r r r Zpandas.core.dtypes.dtypesr r r Zpandas.core.dtypes.missingr Zpandasr r r r r r r r r r r Zpandas.core.algorithmsr Zpandas.core.arraysr r r! r" r# Z pandas.core.arrays.datetimeliker$ Zpandas.core.arrays.string_r% Zpandas.core.indexes.apir& Zpandas.io.formats.printingr' r? rJ rM r8 r= rT r r rv ru r r¡ r¢ rm r r· r9 r: r rÐ rÓ rÔ rÅ rÛ rÞ rD rD rD rE Ú<module> sæ (
|
0 ûV ö$ ( ÿ"' û> ÿ ÿ ÿ ÿ
|
& øS øs ñî0 { ï. J)! ÿ
|
