A>iw%SSKJr SSKrSSKJr SSKrSSKJr SSK J r SSK r SSK r SSK r SSKrSSKJrJrJrJrJrJrJrJrJrJr SSKrSSKrSSKJr SSKJ r SS K!J"r" SS K#J$r$J%r%J&r& SS K'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrPJQrQJRrRJSrSJTrT SS KUJVrV SS KWJXrX SSKYJZrZ SSK[J\r] SSK^J_r_J`r`JaraJbrb SSKcJdrd SSKeJfrfJgrg SSKhJiri SSKjJkrkJlrlJmrmJnrn SSKoJprp SSKqJrrr SSKsJtrtJuruJvrvJwrwJxrxJyryJzrzJ{r{J|r|J}r}J~r~JrJr SSKJrJrJr SSKJrJr SSKJrJr SSKJrJr SSKJrJrJrJrJrJrJr SSKJr SSKJr SSKJr SS KJr SS!KJr SS"KJrJrJrJrJrJr SS#KJr SS$KJr SS%KJrJrJr SS&KJr SS'KJr SS(KJr SS)KJrJrJrJr SS*KJrJr SS+KJr \(a2SS,KJrJrJrJrJr SS-K#Jr SS.K'Jr SS/KJrJrJrJr SS0KJr SS1KJr 0\ErS2S3S4S5S6S7.r"S8S9\\GR5rS:rS;rSrS?rS@rSArSBrSCrSDrSErSFrSGrSHrSIrSJrSKrSLrSMrSNrSOrSPrSQ\SR'\SRGRSSSTSUSVSWSX9r\SY- r\SRGRSZS[SWS\SWSX9rS]\S^'\SRGRS_S`SSaSSX9rS]\Sb'ScrSdrSerSfrShSgjrg)i) annotationsN)deepcopy)partial)loads) TYPE_CHECKINGAnyClassVar ConcatenateLiteralNoReturnSelfcastfinaloverload)config)lib)is_range_indexer)Period Timestamp to_offset)- AlignJoin AnyArrayLike ArrayLikeAxesAxisAxisIntCompressionOptionsDtypeArg DtypeBackendDtypeObjFilePath FillnaOptionsFloatFormatTypeFormattersType Frequency IgnoreRaise IndexKeyFunc IndexLabelInterpolateOptionsIntervalClosedTypeJSONSerializableLevelListLikeManager NaPositionNDFrameTOpenFileErrors RandomState ReindexMethodRenamerScalarSequenceNotStrSortKindStorageOptionsSuffixesT TimeAmbiguousTimedeltaConvertibleTypesTimeNonexistentTimestampConvertibleTypesTimeUnit ValueKeyFunc WriteBufferWriteExcelBuffernpt)CHAINED_WARNING_DISABLED)REF_COUNT_METHOD)import_optional_dependency)function)AbstractMethodErrorChainedAssignmentErrorInvalidIndexErrorPandas4Warning)_chained_assignment_method_msg)deprecate_kwargdoc)find_stack_level)check_dtype_backendvalidate_ascendingvalidate_bool_kwargvalidate_inclusive)astype_is_view)can_hold_element) ensure_objectensure_platform_int ensure_stris_bool is_bool_dtype is_dict_likeis_extension_array_dtype is_list_like is_numberis_numeric_dtypeis_re_compilable is_scalar pandas_dtype)DatetimeTZDtypeExtensionDtype PeriodDtype) ABCDataFrame ABCSeries) is_hashableis_nested_list_like)isnanotna) algorithms arraylikecommonindexingmissingnanopssample)should_use_regex)ExtensionArray) PandasObject) extract_array)Flags) DatetimeIndexIndex MultiIndex PeriodIndex default_index ensure_index) BlockManager)describe_ndframe)clean_fill_methodclean_reindex_fill_methodfind_valid_index)concat) _shared_docs)get_indexer_indexer) ExpandingExponentialMovingWindowRollingWindow)DataFrameFormatterDataFrameRenderer) pprint_thing)CallableHashableIteratorMappingSequence) BaseOffset)P) DataFrame ExcelWriterHDFStoreSeries) BaseIndexer) Resamplerzkeywords for axeszSeries/DataFramezG{0 or 'index'} for Series, {0 or 'index', 1 or 'columns'} for DataFramezO inplace : bool, default False If True, performs operation inplace.zM by : str or list of str Name or list of names to sort by)axesklassaxes_single_arginplace optional_byc%^\rSrSr%Sr/SQrS\S'\"\5rS\S'\"5r S\S'\ "/5r S \S '/r S\S 'S \S 'S\S'S\S'GS3Sjr \\GS4GS5Sjj55r\\GS6Sj55r\GS7Sj5r\R(GS8Sj5r\\GS9Sj55r\\R.SS.GS:Sjj5r\\GS;Sj55r\GSS)jj5r\\GS?S*j55r\\GS@S+j55r\GSAS,j5r\\GS?S-j55r \GSBS.j5r!\GSCS/j5r"\GSDS0j5r#\\GSES1j55r$\GSFS2j5r%\GSGS3j5r&\\GSHS4j55r'\\GSHS5j55r(S \R.S6.GSIS7jjr)\*GSJS8j5r+\*GSKS9j5r+\*GSLS:j5r+\GSLS;j5r+\GSMS<j5r,\GSNGSOS=jj5r-GSPS>jr.\GS=GSQS?jj5r/\*GSRS@S@S@S@S@S@SA.GSSSBjjj5r0\*GSRS@S@S@S@S@SC.GSTSDjjj5r0\*GSRS@S@S@S@S@SC.GSUSEjjj5r0\GS=SSSSSSFSA.GSUSGjjj5r0\*GSRS@S@S@\R.S@SH.GSVSIjjj5r1\*GSRS@S@S@\R.SJ.GSWSKjjj5r1\*GSRS@S@S@\R.S@SH.GSXSLjjj5r1\R.4\R.\R.S \R.SSH.GSXSMjjjr1\*GSRS@SN.GSJSOjjj5r2\*GSRGSKSPjj5r2\*GSRGSLSQjj5r2\GSNSSN.GSLSRjjj5r2\GSYSSj5r3\GSZSTj5r4\GS[SUj5r5\GS[SVj5r6\GS[SWj5r7\GS\SXj5r8\GS[SYj5r9\GS[SZj5r:\GSNGS]S[jj5r;\GSNGS^S\jj5r<\GSNGS^S]jj5r=\GSNGS_S^jj5r>\GSNGS`S_jj5r?\GSNGSaS`jj5r@\GSNGSbSajj5rASb\Sc'GScSdjrBGSESejrCSfrDGSHSgjrE\GSYShj5rF\GSYSij5rGSjrHS$\Sk'GSdGSeSljjrI\GSfSnj5rJ\GSgSoj5rK\GShSpj5rLGSiSqjrM\Sr5rN\Ss5rO\StSuSSSvSvSS S SSvSwSSSSSx.GSjSyjj5rP\GS=SSSzSvS{SSS|SSSS}S~. GSkSjjj5rQ\SSSSSSvSSSSSSS. GSlSjj5rR\SSSvSSSSS.GSmSjj5rS\S|\TRSS.GSnSjj5rV\SvSS.GSoSjj5rW\S5rX\*GSRS@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S.GSpSjjj5rY\*S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S.GSqSjj5rY\GS=SSvSvSSSSSvSSSSSSSSSSSSS.GSrSjjj5rY\GS=SSSSSSS.GSsSjjj5rZ\*GSRS@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S.GStSjjj5r[\*S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S@S.GSuSjj5r[\GS=SSuSSSvSvSS}SS|SSSSSSvSSSSS.GSvSjjj5r[\GSNGSwSjj5r\\GSxGSySjj5r]Sr^\GSzSj5r_GSNGS{Sjjr`\GShSj5ra\GS|Sj5rb\GS=Sj5rc\dS5re\f"\gSmSS9\S\R.SS4GS}Sjj55rh\*GSRS@S@S@S@S@S.GS~Sjjj5ri\*GSRS@S@S@S@S@S@S.GSSjjj5ri\*GSRS@S@S@S@S@S@S.GSSjjj5riGS=S SSSSSS.GSSjjjri\GSGSSjj5rj\GShSj5rk\GS=GSSjj5rl\GS=GSSjj5rm\*S@S@S@S@S@S@S@S.GSSjj5rn\*S@S@S@S@S@S@S.GSSjj5rn\*S@S@S@S@S@S@S@S.GSSjj5rnS SvSSSSSS.GSSjjrn\*S@S@S@S@S@S@S@S@S.GSSjj5ro\*S@S@S@S@S@S@S@S@S@S. GSSjj5ro\*S@S@S@S@S@S@S@S@S@S. GSSjj5roS SSvSSSSvSSS. GSSjjroGS=SSSS\R.S\pRSSS. GSSjjjrr\GSSj5rsGSSjrtSru\GS4GSSjj5rvGSGSSjjrw\GSGSSjj5rx\GSGSSjj5ry\GSGSSjj5rz\*GSSj5r{\*GSSj5r{\GSSj5r{\GS=GSSjj5r|\GSSj5r}\GSSj5r~\GSU4Sjj5r\GShSj5r\S5r\\GSYSj55r\GS[Sj5r\S5r\S5r\GSSj5r\S5r\\R.S4GSSjj5r\GSGSSjj5r\GS[Sj5r\GS=GS[Sjj5r\\R.4GSSjj5r\GSGSSjj5r\SSSSS.GSSjj5r\SSSS.GSSjj5r\SSSSS.GSSjj5r\SSSSS.GSSjj5r\S\R.4SSS.GSSjjj5r\GSS SSSSS.GSSjjj5r\GS=Sj5rGS[SjrGS[SjrGS[SjrGS[Sjr\GSGSSjj5r\S5r\GSdSSS.GSSjjj5r\GSGSSjj5r\GSGSSjj5r\GSGSSjj5r\GSGSSjj5r\GSGSSjj5rGSGSSjjr\SSS\R.S4GSSjj5r\GSGSSjj5r\GSGSSjj5r\\R.4SSSS.GSSjjj5r\\R.4SSSS.GSSjjj5r\\R.4SSSS.GSSjjj5rSSS \R.S4GSGSjjr\GSGSj5r\SSS\R.4GSGSjj5r\S S\R.4GSIGSjj5r\S S\R.SS4GSGSjj5r\GSGS[GSjj5r\GSGSGSjj5r\GSGSGSjj5rS SSvGS.GSGS jjrS SSvGS.GSGS jjr\GSGSGS jj5rGSGSGS jjrGSGSGS jjrGSGSGSjjrGSGSGSjjr\GSGSGSjj5rS SvSSGS.GSGSjjrS SvSSGS.GSGSjjrS SvSSGS.GSGSjjr\GSGSGSjj5rS SvSGS.GSGSjjrS SvSGS.GSGSjjrS SvSGS.GSGSjjrS SvSGS.GSGSjjrS SvSGS.GSGSjjrS SvSGS.GSGSjjr\r\GSGSGSjj5rS SvSS GS.GSGSjjrS SvSS GS.GSGS jjr\r\GSGSGS!jj5r\GSGSGS"jj5r\\"\5GSGSGS#jj55r\GS[GS$j5r\GS[GS%j5r\GS[GS&j5r\GS[GS'j5r\GS[GS(j5r\GS[GS)j5r\GS[GS*j5r\GS[GS+j5r\GS[GS,j5r\GS[GS-j5r\GS[GS.j5r\GSGS/j5r\GSGS0j5r\GSGS1j5rGS2rU=r$(NDFramez N-dimensional analogue of DataFrame. Store multi-dimensional in a size-mutable, labeled data structure Parameters ---------- data : BlockManager axes : list copy : bool, default False )_mgr_cache_name _metadata_flagsz list[str]_internal_namesset[str]_internal_names_set _accessorszfrozenset[str] _hidden_attrsrr.rdict[Hashable, Any]_attrsstr_typc [RUSU5 [RUS05 [RUS[USS95 g)NrrrT)allows_duplicate_labels)object __setattr__rwselfdatas R/var/www/html/land-tabula/venv/lib/python3.13/site-packages/pandas/core/generic.py__init__NDFrame.__init__s?4.42.45t+TUNFcUR5H5upVUcM [U5nURU5nURXgS9nM7 U(aUR SS9nUbg[ U[ 5(aC[UR5S:Xa*URSRRU:XaU$URUS9nU$)z passed a manager and a axes dictaxisTdeeprdtype) itemsr}_get_block_manager_axis reindex_axiscopy isinstancer~lenblocksvaluesrastype)clsmgrrrraaxebm_axiss r _init_mgrNDFrame._init_mgrsjjlFA"3'55a8&&s&9 # (((%C  3 -- Oq(JJqM((..%7 jjuj- rcRURU5n[RX15 U$)a3 Construct a new object of this type from a Manager object and axes. Parameters ---------- mgr : Manager Must have the same ndim as cls. axes : list[Index] Notes ----- The axes must match mgr.axes, but are required for future-proofing in the event that axes are refactored out of the Manager objects. )__new__rr)rrrobjs r _from_mgrNDFrame._from_mgr&s%"kk#" rcUR$)a Dictionary of global attributes of this dataset. .. warning:: attrs is experimental and may change without warning. See Also -------- DataFrame.flags : Global flags applying to this object. Notes ----- Many operations that create new datasets will copy ``attrs``. Copies are always deep so that changing ``attrs`` will only affect the present dataset. :func:`pandas.concat` and :func:`pandas.merge` will only copy ``attrs`` if all input datasets have the same ``attrs``. Examples -------- For Series: >>> ser = pd.Series([1, 2, 3]) >>> ser.attrs = {"A": [10, 20, 30]} >>> ser.attrs {'A': [10, 20, 30]} For DataFrame: >>> df = pd.DataFrame({"A": [1, 2], "B": [3, 4]}) >>> df.attrs = {"A": [10, 20, 30]} >>> df.attrs {'A': [10, 20, 30]} )rrs rattrs NDFrame.attrs>sH{{rc$[U5UlgN)dictr)rvalues rrrds 5k rcUR$)a) Get the properties associated with this pandas object. The available flags are * :attr:`Flags.allows_duplicate_labels` See Also -------- Flags : Flags that apply to pandas objects. DataFrame.attrs : Global metadata applying to this dataset. Notes ----- "Flags" differ from "metadata". Flags reflect properties of the pandas object (the Series or DataFrame). Metadata refer to properties of the dataset, and should be stored in :attr:`DataFrame.attrs`. Examples -------- >>> df = pd.DataFrame({"A": [1, 2]}) >>> df.flags Flags can be get or set using ``.`` >>> df.flags.allows_duplicate_labels True >>> df.flags.allows_duplicate_labels = False Or by slicing with a key >>> df.flags["allows_duplicate_labels"] False >>> df.flags["allows_duplicate_labels"] = True )rrs rflags NDFrame.flagshsN{{r)rrchURU5 URSS9nUbX#RS'U$)aR Return a new object with updated flags. This method creates a shallow copy of the original object, preserving its underlying data while modifying its global flags. In particular, it allows you to update properties such as whether duplicate labels are permitted. This behavior is especially useful in method chains, where one wishes to adjust DataFrame or Series characteristics without altering the original object. Parameters ---------- copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. allows_duplicate_labels : bool, optional Whether the returned object allows duplicate labels. Returns ------- Series or DataFrame The same type as the caller. See Also -------- DataFrame.attrs : Global metadata applying to this dataset. DataFrame.flags : Global flags applying to this object. Notes ----- This method returns a new object that's a view on the same data as the input. Mutating the input or the output values will be reflected in the other. This method is intended to be used in method chains. "Flags" differ from "metadata". Flags reflect properties of the pandas object (the Series or DataFrame). Metadata refer to properties of the dataset, and should be stored in :attr:`DataFrame.attrs`. Examples -------- >>> df = pd.DataFrame({"A": [1, 2]}) >>> df.flags.allows_duplicate_labels True >>> df2 = df.set_flags(allows_duplicate_labels=False) >>> df2.flags.allows_duplicate_labels False Frr)_check_copy_deprecationrr)rrrdfs r set_flagsNDFrame.set_flagss;B $$T* YYEY " " .2IHH. / rctUb4[U5nURS:Xa[SURS35eU$)zvalidate the passed dtypeVz+compound dtypes are not implemented in the z constructor)rbkindNotImplementedError__name__)rrs r_validate_dtypeNDFrame._validate_dtypesK   'EzzS )!ll^<9  rc[U5e)zJ Used when a manipulation result has the same dimensions as the original. rHrs r _constructorNDFrame._constructors "$''rz!list[Literal['index', 'columns']] _AXIS_ORDERSr)rindexrowszdict[Axis, AxisInt]_AXIS_TO_AXIS_NUMBERint_info_axis_numberLiteral['index', 'columns']_info_axis_name _AXIS_LENc U=(d URVs0sHo3URU5_M nnURU5 U$s snf)z%Return an axes dictionary for myself.)r _get_axisupdate)rrkwargsrds r_construct_axes_dictNDFrame._construct_axes_dictsM -1,ED4E4E,E G,Eaq! !,E G  HsAc~URU$![a!n[SUSUR35UeSnAff=f)NzNo axis named z for object type )rKeyError ValueErrorr)rrerrs r_get_axis_numberNDFrame._get_axis_numbersM ++D1 1  &7 ~F  s <7<cBURU5nURU$r)rr)rr axis_numbers r_get_axis_nameNDFrame._get_axis_names%**40  ,,rcpURU5nUS;deUS:Xa UR$UR$)N>rrr)rrcolumns)rrr s rrNDFrame._get_axiss:++D1 f$$$(A-tzz?4<<?rcVURU5nURnUS:XaSU- $U$)z'Map the axis to the block_manager axis.r)rr)rrndims rrNDFrame._get_block_manager_axiss2##D)}} 19t8O rc4[X5n0nUSn[UR5H@upVUbU=pxO USU3nUnURU5n U R 5n X*lXU'MB [ U[5(aUn OUR 5n XU'U$)Nrlevel_)getattr enumeratenamesget_level_values to_seriesrrrz) rr axis_indexrprefixinamekeylevel level_valuessdindexs r_get_axis_resolversNDFrame._get_axis_resolvers(sT( a !1!12GA""e  qc*%66u=L&&(A GcF3 j* - -F))+F$rc SSKJn 0nURH#nURUR U55 M% UR 5VVs0sH%upE[ U[5(aMU"U5U_M' snn$s snnf)Nrclean_column_name)pandas.core.computation.parsingr(rrr$rrr)rr(r axis_namekvs r_get_index_resolversNDFrame._get_index_resolversGslE,.**I HHT--i8 9+56GGIXIDAZPQSVEW'!!$a'IXXXs A?. A?cXSSKJn SSKJn [ U[ 5(aU"UR 5U0$URn[URUR5USS9VVVs0sH/upEnU"U5U"USURXFS9RU5_M1 snnn$s snnnf)z Return the special character free column resolvers of a DataFrame. Column names with special characters are 'cleaned up' so that they can be referred to by backtick quoting. Used in :meth:`DataFrame.eval`. rr'rT)strictF)rrrr) r)r(pandas.core.seriesrrrgrdtypeszipr_iter_column_arraysr __finalize__)rr(rr3r+r,rs r_get_cleaned_column_resolvers%NDFrame._get_cleaned_column_resolversQs F- dI & &%dii0$7 7 # ((*      e a &TZZa#l4  !    s*6B%c,[XR5$r)rrrs r _info_axisNDFrame._info_axismst1122rcB^[U4SjTR55$)z# Return a tuple of axis dimensions c3X># UHn[TRU55v M! g7frrr.0rrs r NDFrame.shape..ws$G5FS*++5Fs'*)tuplerrs`rshape NDFrame.shapers GT5F5FGGGrcbURVs/sHoRU5PM sn$s snf)z/ Return index label(s) of the internal NDFrame )rr)rrs rr NDFrame.axesys+,0+<+<=+>> s = pd.Series({"a": 1, "b": 2, "c": 3}) >>> s.ndim 1 >>> df = pd.DataFrame({"col1": [1, 2], "col2": [3, 4]}) >>> df.ndim 2 )rrrs rr NDFrame.ndims,yy~~rcT[[R"UR55$)a Return an int representing the number of elements in this object. Return the number of rows if Series. Otherwise return the number of rows times number of columns if DataFrame. See Also -------- numpy.ndarray.size : Number of elements in the array. Examples -------- >>> s = pd.Series({"a": 1, "b": 2, "c": 3}) >>> s.size 3 >>> df = pd.DataFrame({"col1": [1, 2], "col2": [3, 4]}) >>> df.size 4 )rnpprodrDrs rsize NDFrame.sizes02774::&''r)rrcDURU5 URXSS9$)a Assign desired index to given axis. Indexes for%(extended_summary_sub)s row labels can be changed by assigning a list-like or Index. Parameters ---------- labels : list-like, Index The values for the new index. axis : %(axes_single_arg)s, default 0 The axis to update. The value 0 identifies the rows. For `Series` this parameter is unused and defaults to 0. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. Returns ------- %(klass)s An object of type %(klass)s. See Also -------- %(klass)s.rename_axis : Alter the name of the index%(see_also_sub)s. Fr)r_set_axis_nocheck)rlabelsrrs rset_axisNDFrame.set_axiss)X $$T*%%fE%BBrcgrrrRrrs rrQNDFrame._set_axis_nocheckrcgrrVrWs rrQrXsUXrcgrrVrWs rrQrXsSVrcU(a[XRU5U5 gURSS9n[XDRU5U5 U$NFr)setattrr r)rrRrrrs rrQrXsG  D--d3V <iiUi#''-v6 rcP[U5nURRX5 g)zr This is called from the cython code when we set the `index` attribute directly, e.g. `series.index = [1, 2, 3]`. N)r}rrS)rrrRs r _set_axisNDFrame._set_axiss f% 4(rcdURU5nURU5nURXBS9$)aW Return Series/DataFrame with requested index / column level(s) removed. Parameters ---------- level : int, str, or list-like If a string is given, must be the name of a level If list-like, elements must be names or positional indexes of levels. axis : {{0 or 'index', 1 or 'columns'}}, default 0 Axis along which the level(s) is removed: * 0 or 'index': remove level(s) in column. * 1 or 'columns': remove level(s) in row. For `Series` this parameter is unused and defaults to 0. Returns ------- Series/DataFrame Series/DataFrame with requested index / column level(s) removed. See Also -------- DataFrame.replace : Replace values given in `to_replace` with `value`. DataFrame.pivot : Return reshaped DataFrame organized by given index / column values. Examples -------- >>> df = ( ... pd.DataFrame([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) ... .set_index([0, 1]) ... .rename_axis(["a", "b"]) ... ) >>> df.columns = pd.MultiIndex.from_tuples( ... [("c", "e"), ("d", "f")], names=["level_1", "level_2"] ... ) >>> df level_1 c d level_2 e f a b 1 2 3 4 5 6 7 8 9 10 11 12 >>> df.droplevel("a") level_1 c d level_2 e f b 2 3 4 6 7 8 10 11 12 >>> df.droplevel("level_2", axis=1) level_1 c d a b 1 2 3 4 5 6 7 8 9 10 11 12 r)r droplevelrS)rr rrR new_labelss rrcNDFrame.droplevels4D%%%e, }}Z}33rcXnX U$rrV)ritemresults rpop NDFrame.popFs J rc^Uc[UR5OURU54mUR[ U4Sj[ UR 555n[U[5(aURUSS9nU$)a Squeeze 1 dimensional axis objects into scalars. Series or DataFrames with a single element are squeezed to a scalar. DataFrames with a single column or a single row are squeezed to a Series. Otherwise the object is unchanged. This method is most useful when you don't know if your object is a Series or DataFrame, but you do know it has just a single column. In that case you can safely call `squeeze` to ensure you have a Series. Parameters ---------- axis : {0 or 'index', 1 or 'columns', None}, default None A specific axis to squeeze. By default, all length-1 axes are squeezed. For `Series` this parameter is unused and defaults to `None`. Returns ------- DataFrame, Series, or scalar The projection after squeezing `axis` or all the axes. See Also -------- Series.iloc : Integer-location based indexing for selecting scalars. DataFrame.iloc : Integer-location based indexing for selecting Series. Series.to_frame : Inverse of DataFrame.squeeze for a single-column DataFrame. Examples -------- >>> primes = pd.Series([2, 3, 5, 7]) Slicing might produce a Series with a single value: >>> even_primes = primes[primes % 2 == 0] >>> even_primes 0 2 dtype: int64 >>> even_primes.squeeze() np.int64(2) Squeezing objects with more than one value in every axis does nothing: >>> odd_primes = primes[primes % 2 == 1] >>> odd_primes 1 3 2 5 3 7 dtype: int64 >>> odd_primes.squeeze() 1 3 2 5 3 7 dtype: int64 Squeezing is even more effective when used with DataFrames. >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["a", "b"]) >>> df a b 0 1 2 1 3 4 Slicing a single column will produce a DataFrame with the columns having only one value: >>> df_a = df[["a"]] >>> df_a a 0 1 1 3 So the columns can be squeezed down, resulting in a Series: >>> df_a.squeeze("columns") 0 1 1 3 Name: a, dtype: int64 Slicing a single row from a single column will produce a single scalar DataFrame: >>> df_0a = df.loc[df.index < 1, ["a"]] >>> df_0a a 0 1 Squeezing the rows produces a single scalar Series: >>> df_0a.squeeze("rows") a 1 Name: 0, dtype: int64 Squeezing all axes will project directly into a scalar: >>> df_0a.squeeze() np.int64(1) c3l># UH)upUT;a[U5S:XaSO [S5v M+ g7f)rrN)rslice)r@rrrs rrA"NDFrame.squeeze..s30DA$Y3q6Q;E$K?0s14squeezemethod) rangerrilocrCrrrrr6)rrrhrs @rroNDFrame.squeezeLs~P)- uT^^$4;P;PQU;V:X %dii0   fg & &((i(@F r.)rrrrr errorscgrrVrmapperrrrrr rus r_renameNDFrame._renamer)rrrr rucgrrVrws rryrzr{rcgrrVrws rryrzrignorecUcUcUc [S5eUcUbUb [S5eUb [S5eO!U(aURU5S:XaUnOUnURU5 U(aUOURSS9n[ X#45GHIupU cM UR U 5n [ R"U 5n UbU RU5n[U [5(a&U RR(d [S5e[U 5(dU R(a$Ub!U R!U5R#U 5n OU R#U 5n US:XaL[%XS :H5(a7[ U 5VVs/sHup.XS :XdMUPM nnn['US 35eU R)XS 9nUR+UU S S 9 GML U(aUR-U5 gUR/USS9$s snnf)Nzmust pass an index to rename:Cannot specify both 'axis' and any of 'index' or 'columns'zem:; ;   3P!R" d++D1Q6GE 77@ diiUi&;%./?%@ !G#(B**<8A ,,U3, 22<;M;M;W;W !UVVL))<GW$W]-C)D)D-6l,C&,CLE">R/,C#& #n%55G#HII++A+;I  $ $YWd $ K=&A@    (&&tH&= =&s H H)rrrrrcgrrVrrxrrrrrs r rename_axisNDFrame.rename_axis2r)rrrrcgrrVrs rrr>rrcgrrVrs rrrJsrcZURU5 X#S.nUbURU5n[US5nU[RLaV[ U5=(d" [ U5=(a [U5(+nU(aURXUS9$[S5eU(aUOURSS9n [UR5HnURURU55n U [RLaM8[ U 5=(d" [ U 5=(a [U 5(+nU(aU n OH[R "U 5n UR#U5R$n U Vs/sH o"U5PM n nU RXSS9 M U(dU $gs snf) a Set the name of the axis for the index or columns. Parameters ---------- mapper : scalar, list-like, optional Value to set the axis name attribute. Use either ``mapper`` and ``axis`` to specify the axis to target with ``mapper``, or ``index`` and/or ``columns``. index : scalar, list-like, dict-like or function, optional A scalar, list-like, dict-like or functions transformations to apply to that axis' values. columns : scalar, list-like, dict-like or function, optional A scalar, list-like, dict-like or functions transformations to apply to that axis' values. axis : {0 or 'index', 1 or 'columns'}, default 0 The axis to rename. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. inplace : bool, default False Modifies the object directly, instead of creating a new Series or DataFrame. Returns ------- DataFrame, or None The same type as the caller or None if ``inplace=True``. See Also -------- Series.rename : Alter Series index labels or name. DataFrame.rename : Alter DataFrame index labels or name. Index.rename : Set new names on index. Notes ----- ``DataFrame.rename_axis`` supports two calling conventions * ``(index=index_mapper, columns=columns_mapper, ...)`` * ``(mapper, axis={'index', 'columns'}, ...)`` The first calling convention will only modify the names of the index and/or the names of the Index object that is the columns. In this case, the parameter ``copy`` is ignored. The second calling convention will modify the names of the corresponding index if mapper is a list or a scalar. However, if mapper is dict-like or a function, it will use the deprecated behavior of modifying the axis *labels*. We *highly* recommend using keyword arguments to clarify your intent. Examples -------- **DataFrame** >>> df = pd.DataFrame( ... {"num_legs": [4, 4, 2], "num_arms": [0, 0, 2]}, ["dog", "cat", "monkey"] ... ) >>> df num_legs num_arms dog 4 0 cat 4 0 monkey 2 2 >>> df = df.rename_axis("animal") >>> df num_legs num_arms animal dog 4 0 cat 4 0 monkey 2 2 >>> df = df.rename_axis("limbs", axis="columns") >>> df limbs num_legs num_arms animal dog 4 0 cat 4 0 monkey 2 2 **MultiIndex** >>> df.index = pd.MultiIndex.from_product( ... [["mammal"], ["dog", "cat", "monkey"]], names=["type", "name"] ... ) >>> df limbs num_legs num_arms type name mammal dog 4 0 cat 4 0 monkey 2 2 >>> df.rename_axis(index={"type": "class"}) limbs num_legs num_arms class name mammal dog 4 0 cat 4 0 monkey 2 2 >>> df.rename_axis(columns=str.upper) LIMBS num_legs num_arms type name mammal dog 4 0 cat 4 0 monkey 2 2 rrNrrz,Use `.rename` to alter labels with a mapper.FrT)rrrRr no_defaultrar]r[_set_axis_namerrrrrgetr rnrrr)rrxrrrrrr non_mapperrhr,newnamesrcurnamesrs rrrVspB $$T*3  ((.D%gy9  '"6*V$A\&-A)A **6g*NN !OPP%T$)))*?Fdnn-HHT0067&&q\Vl1o.UlSToBU  H2215A#~~d399H4<=HD$HH=%%h4%H.  >s7F(rPcgrrVrrrrs rrNDFrame._set_axis_namerYrcgrrVrs rrrrYrcgrrVrs rrrsrcURU5nURU5RU5n[US5nU(aUOUR SS9nUS:XaXElOXElU(dU$g)a Set the name(s) of the axis. Parameters ---------- name : str or list of str Name(s) to set. axis : {0 or 'index', 1 or 'columns'}, default 0 The axis to set the label. The value 0 or 'index' specifies index, and the value 1 or 'columns' specifies columns. inplace : bool, default False If `True`, do operation inplace and return None. Returns ------- Series, DataFrame, or None The same type as the caller or `None` if `inplace` is `True`. See Also -------- DataFrame.rename : Alter the axis labels of :class:`DataFrame`. Series.rename : Alter the index labels or set the index name of :class:`Series`. Index.rename : Set the name of :class:`Index` or :class:`MultiIndex`. Examples -------- >>> df = pd.DataFrame({"num_legs": [4, 4, 2]}, ["dog", "cat", "monkey"]) >>> df num_legs dog 4 cat 4 monkey 2 >>> df._set_axis_name("animal") num_legs animal dog 4 cat 4 monkey 2 >>> df.index = pd.MultiIndex.from_product( ... [["mammal"], ["dog", "cat", "monkey"]] ... ) >>> df._set_axis_name(["type", "name"]) num_legs type name mammal dog 4 cat 4 monkey 2 rFrrN)rr set_namesrRrrr)rrrridxrenameds rrr sjj$$T*nnT",,T2%gy9!$tyyey'< 19M!ONrcF^^[UU4SjTR55$)Nc3># UH4nTRU5RTRU55v M6 g7fr)requals)r@rotherrs rrA(NDFrame._indexed_same..Ts5 BSQDNN1  $ $U__Q%7 8 8BSs>> df = pd.DataFrame({1: [10], 2: [20]}) >>> df 1 2 0 10 20 DataFrames df and exactly_equal have the same types and values for their elements and column labels, which will return True. >>> exactly_equal = pd.DataFrame({1: [10], 2: [20]}) >>> exactly_equal 1 2 0 10 20 >>> df.equals(exactly_equal) True DataFrames df and different_column_type have the same element types and values, but have different types for the column labels, which will still return True. >>> different_column_type = pd.DataFrame({1.0: [10], 2.0: [20]}) >>> different_column_type 1.0 2.0 0 10 20 >>> df.equals(different_column_type) True DataFrames df and different_data_type have different types for the same values for their elements, and will return False even though their column labels are the same values and types. >>> different_data_type = pd.DataFrame({1: [10.0], 2: [20.0]}) >>> different_data_type 1 2 0 10.0 20.0 >>> df.equals(different_data_type) False DataFrames with NaN in the same locations compare equal. >>> df_nan1 = pd.DataFrame({"a": [1, np.nan], "b": [3, np.nan]}) >>> df_nan2 = pd.DataFrame({"a": [1, np.nan], "b": [3, np.nan]}) >>> df_nan1.equals(df_nan2) True If the NaN values are not in the same locations, they compare unequal. >>> df_nan3 = pd.DataFrame({"a": [1, np.nan], "b": [3, 4]}) >>> df_nan1.equals(df_nan3) False F)rtyperrrrrs rrNDFrame.equalsXsNx5$t*--D$u+1N1NWe$yy ++rcSSjnURRU5nURX"RS9nUR USS9$)Nc[UR5(a[R"U5$[R"U5$r)rZroperatorinvnegrs rblk_func!NDFrame.__neg__..blk_funcs3V\\** ||F++  ||F++rr__neg__rprrrapply_constructor_from_mgrrr6rrnew_dataress rrNDFrame.__neg__sH ,99??8,(( (FY77rcSSjnURRU5nURX"RS9nUR USS9$)Nc[UR5(aUR5$[R"U5$r)rZrrrposrs rr!NDFrame.__pos__..blk_funcs.V\\**{{}$  ||F++rr__pos__rprrrs rrNDFrame.__pos__sH ,99??8,(( (FY77rcUR(dURSS9$URR[R 5nUR XRS9nURUSS9$)NFrr __invert__rp) rMrrrrinvertrrr6)rrrs rrNDFrame.__invert__s]yy99%9( (99??8??3(( (F\::rcF[S[U5RS35e)NzThe truth value of a zC is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().)rrrrs r__bool__NDFrame.__bool__s-#DJ$7$7#89C C  rcURR[R5nUR XR S9R USS9$)a Return a Series/DataFrame with absolute numeric value of each element. This function only applies to elements that are all numeric. Returns ------- abs Series/DataFrame containing the absolute value of each element. See Also -------- numpy.absolute : Calculate the absolute value element-wise. Notes ----- For ``complex`` inputs, ``1.2 + 1j``, the absolute value is :math:`\sqrt{ a^2 + b^2 }`. Examples -------- Absolute numeric values in a Series. >>> s = pd.Series([-1.10, 2, -3.33, 4]) >>> s.abs() 0 1.10 1 2.00 2 3.33 3 4.00 dtype: float64 Absolute numeric values in a Series with complex numbers. >>> s = pd.Series([1.2 + 1j]) >>> s.abs() 0 1.56205 dtype: float64 Absolute numeric values in a Series with a Timedelta element. >>> s = pd.Series([pd.Timedelta("1 days")]) >>> s.abs() 0 1 days dtype: timedelta64[us] Select rows with data closest to certain value using argsort (from `StackOverflow `__). >>> df = pd.DataFrame( ... {"a": [4, 5, 6, 7], "b": [10, 20, 30, 40], "c": [100, 50, -30, -50]} ... ) >>> df a b c 0 4 10 100 1 5 20 50 2 6 30 -30 3 7 40 -50 >>> df.loc[(df.c - 43).abs().argsort()] a b c 1 5 20 50 0 4 10 100 2 6 30 -30 3 7 40 -50 rabs)r)rrrKrrrr6)rres_mgrs rr NDFrame.abssKD))//"&&)))' )ERR uS  rc"UR5$r)rrs r__abs__NDFrame.__abs__5sxxzrc@URU5RUSS9$)N __round__rp)roundr6)rdecimalss rrNDFrame.__round__9s!zz(#00k0JJrcURU5nUSL=(aH [U5=(a6 XRUR;=(a UR XS9(+$)a Test whether a key is a level reference for a given axis. To be considered a level reference, `key` must be a string that: - (axis=0): Matches the name of an index level and does NOT match a column label. - (axis=1): Matches the name of a column level and does NOT match an index label. Parameters ---------- key : Hashable Potential level name for the given axis axis : int, default 0 Axis that levels are associated with (0 for index, 1 for columns) Returns ------- is_level : bool Nr)rrhrr_is_label_reference)rrraxis_ints r_is_level_referenceNDFrame._is_level_referenceEsg,((. tO AC  Ayy*000 A,,S,@@  rc^^^TRU5mU4Sj[TR55n[T5=(a [ UU4SjU55$)a Test whether a key is a label reference for a given axis. To be considered a label reference, `key` must be a string that: - (axis=0): Matches a column label - (axis=1): Matches an index label Parameters ---------- key : Hashable Potential label name, i.e. Index entry. axis : int, default 0 Axis perpendicular to the axis that labels are associated with (0 means search for column labels, 1 means search for index labels) Returns ------- is_label: bool c36># UHoT:wdM Uv M g7frrVr@rrs rrA.NDFrame._is_label_reference..zK#8R(Nbb#8  c3H># UHnTTRU;v M g7frrr@rrrs rrAr|s'Rztyy}(# UHoT:wdM Uv M g7frrVrs rrA:NDFrame._check_label_or_level_ambiguity..rrNc3H># UHnTTRU;v M g7frrrs rrArs>:RC499R=(:rr)anr)rcolumn'z ' is both  z level and z label, which is ambiguous.)rrrrrhrrrr) rrrr level_article level_type label_article label_typemsgrs `` @r_check_label_or_level_ambiguity'NDFrame._check_label_or_level_ambiguitys(((.K5#8K  OC  tyy*000>:>>>$,q=o &M $,q=o &M C5 =/:,k /:,.IK S/ !?1! rc\^URT5m[U4Sj[UR55S5nUR UTS9(a8UR UTS9 Uc [ S5eURXS9RnOIURUTS9(a)URTRU5RnO [U5eURS:aJUb'[URU5[ 5(aSnOSnTS:XaS OS n[ S US US U35eU$)a Return a 1-D array of values associated with `key`, a label or level from the given `axis`. Retrieval logic: - (axis=0): Return column values if `key` matches a column label. Otherwise return index level values if `key` matches an index level. - (axis=1): Return row values if `key` matches an index label. Otherwise return column level values if 'key' matches a column level Parameters ---------- key : Hashable Label or level name. axis : int, default 0 Axis that levels are associated with (0 for index, 1 for columns) Returns ------- np.ndarray or ExtensionArray Raises ------ KeyError if `key` matches neither a label nor a level ValueError if `key` matches multiple labels c36># UHoT:wdM Uv M g7frrV)r@rrs rrA5NDFrame._get_label_or_level_values..s >/B:RR/rNrzaxis matched all axesrzX For a multi-index, the label must be a tuple with elements corresponding to each level.rrrzThe z label 'z' is not unique.)rnextrrrrr rxs_valuesrrrrrrrrz)rrrfirst_other_axesr multi_messagelabel_axis_names ` r_get_label_or_level_values"NDFrame._get_label_or_level_valuess8@$$T* >%/ >   # #Cd # 3  0 04 0 @' !899WWSW8@@F  % %c % 5YYt_55c:BBF3-  ;;?+ /0*11G !# *.!)hO'xu4D]OT  rc URU5n[R"U5nUVs/sHo0RX2S9(aMUPM nnU(a[ SUSU35eUVs/sHo0R X2S9(dMUPM nnUVs/sHo0R X2S9(aMUPM nnUR SS9nUS:Xa2U(aURUSSS9 U(aURUS SS 9 U$U(ad[UR[5(a!URRU5Ul O$[URR5Ul U(aURUSSS 9 U$s snfs snfs snf) ai Drop labels and/or levels for the given `axis`. For each key in `keys`: - (axis=0): If key matches a column label then drop the column. Otherwise if key matches an index level then drop the level. - (axis=1): If key matches an index label then drop the row. Otherwise if key matches a column level then drop the level. Parameters ---------- keys : str or list of str labels or levels to drop axis : int, default 0 Axis that levels are associated with (0 for index, 1 for columns) Returns ------- dropped: DataFrame Raises ------ ValueError if any `keys` match neither a label nor a level rz;The following keys are not valid labels or levels for axis z: FrrT)droprrr)rrnmaybe_make_listrrrr reset_indexrrrrzrcr|rM)rkeysrr+ invalid_keyslevels_to_droplabels_to_dropdroppeds r_drop_labels_or_levelsNDFrame._drop_labels_or_levelss{6$$T*%%d+ !#D#DQ#D#RAt   ##'&<.:  &*TT-E-Ea-E-S!TT%)XT1I1I!1I1W!TX )))' 19##Nt#L ^!T B gooz::&-oo&?&?&OGO'4GOO4H4H&IGO ^!T BW UXs#FF+FFF -F zClassVar[None]__hash__c,[UR5$)aQ Iterate over info axis. Returns ------- iterator Info axis as iterator. See Also -------- DataFrame.items : Iterate over (column name, Series) pairs. DataFrame.itertuples : Iterate over DataFrame rows as namedtuples. Examples -------- >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}) >>> for x in df: ... print(x) A B )iterr:rs r__iter__NDFrame.__iter__Zs,DOO$$rcUR$)a Get the 'info axis' (see Indexing for more). This is index for Series, columns for DataFrame. Returns ------- Index Info axis. See Also -------- DataFrame.index : The index (row labels) of the DataFrame. DataFrame.columns: The column labels of the DataFrame. Examples -------- >>> d = pd.DataFrame( ... data={"A": [1, 2, 3], "B": [0, 4, 8]}, index=["a", "b", "c"] ... ) >>> d A B a 1 0 b 2 4 c 3 8 >>> d.keys() Index(['A', 'B'], dtype='str') r:rs rr NDFrame.keysss:rc#B# URH nXU4v M g7f)z{ Iterate over (label, values) on info axis This is index for Series and columns for DataFrame. Returns ------- Generator Nr))rhs rr NDFrame.itemss!A!W* !sc,[UR5$)zReturns length of info axis)rr:rs r__len__NDFrame.__len__s4??##rcXR;$)z#True if the key is in the info axisr))rrs r __contains__NDFrame.__contains__soo%%rcB^[U4SjTR55$)aX Indicator whether Series/DataFrame is empty. True if Series/DataFrame is entirely empty (no items), meaning any of the axes are of length 0. Returns ------- bool If Series/DataFrame is empty, return True, if not return False. See Also -------- Series.dropna : Return series without null values. DataFrame.dropna : Return DataFrame with labels on given axis omitted where (all or any) data are missing. Notes ----- If Series/DataFrame contains only NaNs, it is still not considered empty. See the example below. Examples -------- An example of an actual empty DataFrame. Notice the index is empty: >>> df_empty = pd.DataFrame({"A": []}) >>> df_empty Empty DataFrame Columns: [A] Index: [] >>> df_empty.empty True If we only have NaNs in our DataFrame, it is not considered empty! We will need to drop the NaNs to make the DataFrame empty: >>> df = pd.DataFrame({"A": [np.nan]}) >>> df A 0 NaN >>> df.empty False >>> df.dropna().empty True >>> ser_empty = pd.Series({"A": []}) >>> ser_empty A [] dtype: object >>> ser_empty.empty False >>> ser_empty = pd.Series() >>> ser_empty.empty True c3^># UH"n[TRU55S:Hv M$ g7f)rNr>r?s rrA NDFrame.empty..s&J8I13t~~a()Q.8Is*-)rrrs`rempty NDFrame.emptystJ8I8IJJJri__array_priority__cjUSLa7URR(dUR(d [S5eURnUc[ R "X1S9nO[ R"X1US9nUSLa[URUR5(aURR(ax[URRSUR5(aF[URUR5(a!UR5nSURlU$)NFz:Unable to avoid copy while creating an array as requested.r)rrTr)ris_single_blockr7rrrKasarrayarrayrTrr3rsviewr writeable)rrrrarrs r __array__NDFrame.__array__s 5=!:!:4::L  <**V1C((6T:C  v||SYY77 ))dkk..q16<<@@^ ciiFFhhj&+ # rrqc8[R"XU/UQ70UD6$r)rm array_ufunc)rufuncrqinputsrs r__array_ufunc__NDFrame.__array_ufunc__s!$$T&L6LVLLrc *URVs0sHo[XS5_M nnURURURURUR R Vs0sHoUR U_M snS.UE$s snfs snf)N)rrrrr)rrrrrr_keys)rr+metas r __getstate__NDFrame.__getstate__s37>>B>a74D))>BIIIIZZ151A1AB1AA$**Q-'1AB     C Cs B +B c [U[5(aXlg[U[5(Ga-SU;aSU;aUR S5US'UR S5nUbUR S05nUc0n[ RUSU5 UR SSS05n[ RUS[U40UD65 [URUR-5nUH,nXa;dM US:wdMXn[ RXU5 M. UR5H"upgXe;dM [ RXU5 M$ g[S5e[U5S :Xa [S5eg) N_datarrrrrTz(Pre-0.12 pickles are no longer supportedr)rr~rrrirrrrwsetrrrrr)rstatetyprrrKr+r,s r __setstate__NDFrame.__setstate__sM e\ * *I t $ $%F%$7 % ' 2f ))F#C (B/=E""459 (-F,MN""453G3GH 4//$..@AAza8m!H**4A6 "KKMDA}**4A6* **TUU Z1_%&PQ Qrc~SSR[[U55S3n[U5RSUS3$)N[,]())joinmaprrr)rpreprs r__repr__NDFrame.__repr__DsACHHSt456a8t*%%&awa00rcX[R"S5S:XaUR5$g)z} Returns a LaTeX representation for a particular object. Mainly for use with nbconvert (jupyter notebook conversion to pdf). zstyler.render.reprlatexN)r get_optionto_latexrs r _repr_latex_NDFrame._repr_latex_Js'   1 2g ===? "rc[R"S5(a\UR[R"S55nURSS9n[ [ U5n[ U[RS9$g)zP Not a real Jupyter special repr method, but we use the same naming convention. zdisplay.html.table_schemazdisplay.max_rowstable)orient)object_pairs_hookN) rrbheadto_jsonrrr collections OrderedDict)rras_jsons r_repr_data_resource_NDFrame._repr_data_resource_Usd   8 9 999V../ABCDll'l2G3(GK4K4KL L :rSheet1rTinf) sheet_namena_rep float_formatrheaderr index_labelstartrowstartcolengine merge_cellsinf_rep freeze_panesstorage_options engine_kwargs autofilterc Uc0n[U[5(aUOUR5nSSKJn U"UUUUUUUU U US9 nUR UUU U UU UUS9 g)a Write object to an Excel sheet. To write a single object to an Excel .xlsx file it is only necessary to specify a target file name. To write to multiple sheets it is necessary to create an `ExcelWriter` object with a target file name, and specify a sheet in the file to write to. Multiple sheets may be written to by specifying unique `sheet_name`. With all data written to the file it is necessary to save the changes. Note that creating an `ExcelWriter` object with a file name that already exists will overwrite the existing file because the default mode is write. Parameters ---------- excel_writer : path-like, file-like, or ExcelWriter object File path or existing ExcelWriter. sheet_name : str, default 'Sheet1' Name of sheet which will contain DataFrame. na_rep : str, default '' Missing data representation. float_format : str, optional Format string for floating point numbers. For example ``float_format="%.2f"`` will format 0.1234 to 0.12. columns : sequence or list of str, optional Columns to write. header : bool or list of str, default True Write out the column names. If a list of string is given it is assumed to be aliases for the column names. index : bool, default True Write row names (index). index_label : str or sequence, optional Column label for index column(s) if desired. If not specified, and `header` and `index` are True, then the index names are used. A sequence should be given if the DataFrame uses MultiIndex. startrow : int, default 0 Upper left cell row to dump data frame. startcol : int, default 0 Upper left cell column to dump data frame. engine : str, optional Write engine to use, 'openpyxl' or 'xlsxwriter'. You can also set this via the options ``io.excel.xlsx.writer`` or ``io.excel.xlsm.writer``. merge_cells : bool or 'columns', default False If True, write MultiIndex index and columns as merged cells. If 'columns', merge MultiIndex column cells only. inf_rep : str, default 'inf' Representation for infinity (there is no native representation for infinity in Excel). freeze_panes : tuple of int (length 2), optional Specifies the one-based bottommost row and rightmost column that is to be frozen. storage_options : dict, optional Extra options that make sense for a particular storage connection, e.g. host, port, username, password, etc. For HTTP(S) URLs the key-value pairs are forwarded to ``urllib.request.Request`` as header options. For other URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more details, and for more examples on storage options refer `here `_. engine_kwargs : dict, optional Arbitrary keyword arguments passed to excel engine. autofilter : bool, default False If True, add automatic filters to all columns. See Also -------- to_csv : Write DataFrame to a comma-separated values (csv) file. ExcelWriter : Class for writing DataFrame objects into excel sheets. read_excel : Read an Excel file into a pandas DataFrame. read_csv : Read a comma-separated values (csv) file into DataFrame. io.formats.style.Styler.to_excel : Add styles to Excel sheet. Notes ----- For compatibility with :meth:`~DataFrame.to_csv`, to_excel serializes lists and dicts to strings before writing. Once a workbook has been saved it is not possible to write further data without rewriting the whole workbook. pandas will check the number of rows, columns, and cell character count does not exceed Excel's limitations. All other limitations must be checked by the user. Examples -------- Create, write to and save a workbook: >>> df1 = pd.DataFrame( ... [["a", "b"], ["c", "d"]], ... index=["row 1", "row 2"], ... columns=["col 1", "col 2"], ... ) >>> df1.to_excel("output.xlsx") # doctest: +SKIP To specify the sheet name: >>> df1.to_excel("output.xlsx", sheet_name="Sheet_name_1") # doctest: +SKIP If you wish to write to more than one sheet in the workbook, it is necessary to specify an ExcelWriter object: >>> df2 = df1.copy() >>> with pd.ExcelWriter("output.xlsx") as writer: # doctest: +SKIP ... df1.to_excel(writer, sheet_name="Sheet_name_1") ... df2.to_excel(writer, sheet_name="Sheet_name_2") ExcelWriter can also be used to append to an existing Excel file: >>> with pd.ExcelWriter("output.xlsx", mode="a") as writer: # doctest: +SKIP ... df1.to_excel(writer, sheet_name="Sheet_name_3") To set the library that is used to write the Excel file, you can pass the `engine` keyword (the default engine is automatically chosen depending on the file extension): >>> df1.to_excel("output1.xlsx", engine="xlsxwriter") # doctest: +SKIP Nr)ExcelFormatter) rtcolsrvrurrwr{r|r)rsrxryr}rzr~r)rrfto_framepandas.io.formats.excelrwrite)r excel_writerrsrtrurrvrrwrxryrzr{r|r}r~rrrr formatters rto_excelNDFrame.to_exceles`  Ml33T:" %##!    !%+'  r msinferw) rh date_formatdouble_precision force_ascii date_unitdefault_handlerlines compressionrindentr~modec SSKJn Uc US:XaSnOUceSnURS:Xa URO UR/n[ SU55(a"[ R"S[[5S 9 O(US:Xa"[ R"S [[5S 9 [R"U 5 U =(d Sn URUUUUUUUUUU U U U U S 9$) a Convert the object to a JSON string. Note NaN's and None will be converted to null and datetime objects will be converted to UNIX timestamps. Parameters ---------- path_or_buf : str, path object, file-like object, or None, default None String, path object (implementing os.PathLike[str]), or file-like object implementing a write() function. If None, the result is returned as a string. orient : str Indication of expected JSON string format. * Series: - default is 'index' - allowed values are: {{'split', 'records', 'index', 'table'}}. * DataFrame: - default is 'columns' - allowed values are: {{'split', 'records', 'index', 'columns', 'values', 'table'}}. * The format of the JSON string: - 'split' : dict like {{'index' -> [index], 'columns' -> [columns], 'data' -> [values]}} - 'records' : list like [{{column -> value}}, ... , {{column -> value}}] - 'index' : dict like {{index -> {{column -> value}}}} - 'columns' : dict like {{column -> {{index -> value}}}} - 'values' : just the values array - 'table' : dict like {{'schema': {{schema}}, 'data': {{data}}}} Describing the data, where data component is like ``orient='records'``. date_format : {{None, 'epoch', 'iso'}} Type of date conversion. 'epoch' = epoch milliseconds, 'iso' = ISO8601. The default depends on the `orient`. For ``orient='table'``, the default is 'iso'. For all other orients, the default is 'epoch'. .. deprecated:: 3.0.0 'epoch' date format is deprecated and will be removed in a future version, please use 'iso' instead. double_precision : int, default 10 The number of decimal places to use when encoding floating point values. The possible maximal value is 15. Passing double_precision greater than 15 will raise a ValueError. force_ascii : bool, default True Force encoded string to be ASCII. date_unit : str, default 'ms' (milliseconds) The time unit to encode to, governs timestamp and ISO8601 precision. One of 's', 'ms', 'us', 'ns' for second, millisecond, microsecond, and nanosecond respectively. default_handler : callable, default None Handler to call if object cannot otherwise be converted to a suitable format for JSON. Should receive a single argument which is the object to convert and return a serialisable object. lines : bool, default False If 'orient' is 'records' write out line-delimited json format. Will throw ValueError if incorrect 'orient' since others are not list-like. compression : str or dict, default 'infer' For on-the-fly compression of the output data. If 'infer' and 'path_or_buf' is path-like, then detect compression from the following extensions: '.gz', '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2' (otherwise no compression). Set to ``None`` for no compression. Can also be a dict with key ``'method'`` set to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and other key-value pairs are forwarded to ``zipfile.ZipFile``, ``gzip.GzipFile``, ``bz2.BZ2File``, ``zstandard.ZstdCompressor``, ``lzma.LZMAFile`` or ``tarfile.TarFile``, respectively. As an example, the following could be passed for faster compression and to create a reproducible gzip archive: ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``. index : bool or None, default None The index is only used when 'orient' is 'split', 'index', 'column', or 'table'. Of these, 'index' and 'column' do not support `index=False`. The string 'index' as a column name with empty :class:`Index` or if it is 'index' will raise a ``ValueError``. indent : int, optional Length of whitespace used to indent each record. storage_options : dict, optional Extra options that make sense for a particular storage connection, e.g. host, port, username, password, etc. For HTTP(S) URLs the key-value pairs are forwarded to ``urllib.request.Request`` as header options. For other URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more details, and for more examples on storage options refer `here `_. mode : str, default 'w' (writing) Specify the IO mode for output when supplying a path_or_buf. Accepted args are 'w' (writing) and 'a' (append) only. mode='a' is only supported when lines is True and orient is 'records'. Returns ------- None or str If path_or_buf is None, returns the resulting json format as a string. Otherwise returns None. See Also -------- read_json : Convert a JSON string to pandas object. Notes ----- The behavior of ``indent=0`` varies from the stdlib, which does not indent the output but does insert newlines. Currently, ``indent=0`` and the default ``indent=None`` are equivalent in pandas, though this may change in a future release. ``orient='table'`` contains a 'pandas_version' field under 'schema'. This stores the version of `pandas` used in the latest revision of the schema. Examples -------- >>> from json import loads, dumps >>> df = pd.DataFrame( ... [["a", "b"], ["c", "d"]], ... index=["row 1", "row 2"], ... columns=["col 1", "col 2"], ... ) >>> result = df.to_json(orient="split") >>> parsed = loads(result) >>> dumps(parsed, indent=4) # doctest: +SKIP {{ "columns": [ "col 1", "col 2" ], "index": [ "row 1", "row 2" ], "data": [ [ "a", "b" ], [ "c", "d" ] ] }} Encoding/decoding a Dataframe using ``'records'`` formatted JSON. Note that index labels are not preserved with this encoding. >>> result = df.to_json(orient="records") >>> parsed = loads(result) >>> dumps(parsed, indent=4) # doctest: +SKIP [ {{ "col 1": "a", "col 2": "b" }}, {{ "col 1": "c", "col 2": "d" }} ] Encoding/decoding a Dataframe using ``'index'`` formatted JSON: >>> result = df.to_json(orient="index") >>> parsed = loads(result) >>> dumps(parsed, indent=4) # doctest: +SKIP {{ "row 1": {{ "col 1": "a", "col 2": "b" }}, "row 2": {{ "col 1": "c", "col 2": "d" }} }} Encoding/decoding a Dataframe using ``'columns'`` formatted JSON: >>> result = df.to_json(orient="columns") >>> parsed = loads(result) >>> dumps(parsed, indent=4) # doctest: +SKIP {{ "col 1": {{ "row 1": "a", "row 2": "c" }}, "col 2": {{ "row 1": "b", "row 2": "d" }} }} Encoding/decoding a Dataframe using ``'values'`` formatted JSON: >>> result = df.to_json(orient="values") >>> parsed = loads(result) >>> dumps(parsed, indent=4) # doctest: +SKIP [ [ "a", "b" ], [ "c", "d" ] ] Encoding with Table Schema: >>> result = df.to_json(orient="table") >>> parsed = loads(result) >>> dumps(parsed, indent=4) # doctest: +SKIP {{ "schema": {{ "fields": [ {{ "name": "index", "type": "string" }}, {{ "name": "col 1", "type": "string" }}, {{ "name": "col 2", "type": "string" }} ], "primaryKey": [ "index" ], "pandas_version": "1.4.0" }}, "data": [ {{ "index": "row 1", "col 1": "a", "col 2": "b" }}, {{ "index": "row 2", "col 1": "c", "col 2": "d" }} ] }} r)jsonrgisoepochrc3># UHoRS;v M g7f)mMNr)r@rs rrA"NDFrame.to_json..8 s:6%::%6sz|The default 'epoch' date format is deprecated and will be removed in a future version, please use 'iso' date format instead. stacklevelzp'epoch' date format is deprecated and will be removed in a future version, please use 'iso' date format instead.) path_or_bufrrhrrrrrrrrrr~r) pandas.iorrr3rrwarningswarnrKrOris_nonnegative_intrk)rrrhrrrrrrrrrr~rrr3s rrkNDFrame.to_json s| #  6W#4K  !K$(IINT[[ F:6::: Q"/1  G # MMA+-   !!&)1||##-#+#+  rrr1zUTF-8 r complevelcomplibappendformatr min_itemsizenan_repdropna data_columnsruencodingc JSSKJn URUUUUUUUUUU U U U U US9 g)a Write the contained data to an HDF5 file using HDFStore. Hierarchical Data Format (HDF) is self-describing, allowing an application to interpret the structure and contents of a file with no outside information. One HDF file can hold a mix of related objects which can be accessed as a group or as individual objects. In order to add another DataFrame or Series to an existing HDF file please use append mode and a different a key. .. warning:: One can store a subclass of ``DataFrame`` or ``Series`` to HDF5, but the type of the subclass is lost upon storing. For more information see the :ref:`user guide `. Parameters ---------- path_or_buf : str or pandas.HDFStore File path or HDFStore object. key : str Identifier for the group in the store. mode : {'a', 'w', 'r+'}, default 'a' Mode to open file: - 'w': write, a new file is created (an existing file with the same name would be deleted). - 'a': append, an existing file is opened for reading and writing, and if the file does not exist it is created. - 'r+': similar to 'a', but the file must already exist. complevel : {0-9}, default None Specifies a compression level for data. A value of 0 or None disables compression. complib : {'zlib', 'lzo', 'bzip2', 'blosc'}, default 'zlib' Specifies the compression library to be used. These additional compressors for Blosc are supported (default if no compressor specified: 'blosc:blosclz'): {'blosc:blosclz', 'blosc:lz4', 'blosc:lz4hc', 'blosc:snappy', 'blosc:zlib', 'blosc:zstd'}. Specifying a compression library which is not available issues a ValueError. append : bool, default False For Table formats, append the input data to the existing. format : {'fixed', 'table', None}, default 'fixed' Possible values: - 'fixed': Fixed format. Fast writing/reading. Not-appendable, nor searchable. - 'table': Table format. Write as a PyTables Table structure which may perform worse but allow more flexible operations like searching / selecting subsets of the data. - If None, pd.get_option('io.hdf.default_format') is checked, followed by fallback to "fixed". index : bool, default True Write DataFrame index as a column. min_itemsize : dict or int, optional Map column names to minimum string sizes for columns. nan_rep : Any, optional How to represent null values as str. Not allowed with append=True. dropna : bool, default False, optional Remove missing values. data_columns : list of columns or True, optional List of columns to create as indexed data columns for on-disk queries, or True to use all columns. By default only the axes of the object are indexed. See :ref:`Query via data columns`. for more information. Applicable only to format='table'. errors : str, default 'strict' Specifies how encoding and decoding errors are to be handled. See the errors argument for :func:`open` for a full list of options. encoding : str, default "UTF-8" Set character encoding. See Also -------- read_hdf : Read from HDF file. DataFrame.to_orc : Write a DataFrame to the binary orc format. DataFrame.to_parquet : Write a DataFrame to the binary parquet format. DataFrame.to_sql : Write to a SQL table. DataFrame.to_feather : Write out feather-format for DataFrames. DataFrame.to_csv : Write out to a csv file. Examples -------- >>> df = pd.DataFrame( ... {"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"] ... ) # doctest: +SKIP >>> df.to_hdf("data.h5", key="df", mode="w") # doctest: +SKIP We can add another object to the same file: >>> s = pd.Series([1, 2, 3, 4]) # doctest: +SKIP >>> s.to_hdf("data.h5", key="s") # doctest: +SKIP Reading from HDF file: >>> pd.read_hdf("data.h5", "df") # doctest: +SKIP A B a 1 4 b 2 5 c 3 6 >>> pd.read_hdf("data.h5", "s") # doctest: +SKIP 0 1 1 2 2 3 3 4 dtype: int64 r)pytablesrN)rrto_hdf)rrrrrrrrrrrrrrurrs rrNDFrame.to_hdf\ sHH '    %%  rfailschema if_existsrrw chunksizerrqc >SSKJn U RUUUUUUUUUU S9 $)a ! Write records stored in a DataFrame to a SQL database. Databases supported by SQLAlchemy [1]_ are supported. Tables can be newly created, appended to, or overwritten. .. warning:: The pandas library does not attempt to sanitize inputs provided via a to_sql call. Please refer to the documentation for the underlying database driver to see if it will properly prevent injection, or alternatively be advised of a security risk when executing arbitrary commands in a to_sql call. Parameters ---------- name : str Name of SQL table. con : ADBC connection, sqlalchemy.engine.(Engine or Connection) or sqlite3.Connection ADBC provides high performance I/O with native type support, where available. Using SQLAlchemy makes it possible to use any DB supported by that library. Legacy support is provided for sqlite3.Connection objects. The user is responsible for engine disposal and connection closure for the SQLAlchemy connectable. See `here `_. If passing a sqlalchemy.engine.Connection which is already in a transaction, the transaction will not be committed. If passing a sqlite3.Connection, it will not be possible to roll back the record insertion. schema : str, optional Specify the schema (if database flavor supports this). If None, use default schema. if_exists : {'fail', 'replace', 'append', 'delete_rows'}, default 'fail' How to behave if the table already exists. * fail: Raise a ValueError. * replace: Drop the table before inserting new values. * append: Insert new values to the existing table. * delete_rows: If a table exists, delete all records and insert data. index : bool, default True Write DataFrame index as a column. Uses `index_label` as the column name in the table. Creates a table index for this column. index_label : str or sequence, default None Column label for index column(s). If None is given (default) and `index` is True, then the index names are used. A sequence should be given if the DataFrame uses MultiIndex. chunksize : int, optional Specify the number of rows in each batch to be written to the database connection at a time. By default, all rows will be written at once. Also see the method keyword. dtype : dict or scalar, optional Specifying the datatype for columns. If a dictionary is used, the keys should be the column names and the values should be the SQLAlchemy types or strings for the sqlite3 legacy mode. If a scalar is provided, it will be applied to all columns. method : {None, 'multi', callable}, optional Controls the SQL insertion clause used: * None : Uses standard SQL ``INSERT`` clause (one per row). * 'multi': Pass multiple values in a single ``INSERT`` clause. * callable with signature ``(pd_table, conn, keys, data_iter)``. Details and a sample callable implementation can be found in the section :ref:`insert method `. Returns ------- None or int Number of rows affected by to_sql. None is returned if the callable passed into ``method`` does not return an integer number of rows. The number of returned rows affected is the sum of the ``rowcount`` attribute of ``sqlite3.Cursor`` or SQLAlchemy connectable which may not reflect the exact number of written rows as stipulated in the `sqlite3 `__ or `SQLAlchemy `__. Raises ------ ValueError When the table already exists and `if_exists` is 'fail' (the default). See Also -------- read_sql : Read a DataFrame from a table. Notes ----- Timezone aware datetime columns will be written as ``Timestamp with timezone`` type with SQLAlchemy if supported by the database. Otherwise, the datetimes will be stored as timezone unaware timestamps local to the original timezone. Not all datastores support ``method="multi"``. Oracle, for example, does not support multi-value insert. References ---------- .. [1] https://docs.sqlalchemy.org .. [2] https://www.python.org/dev/peps/pep-0249/ Examples -------- Create an in-memory SQLite database. >>> from sqlalchemy import create_engine >>> engine = create_engine('sqlite://', echo=False) Create a table from scratch with 3 rows. >>> df = pd.DataFrame({'name' : ['User 1', 'User 2', 'User 3']}) >>> df name 0 User 1 1 User 2 2 User 3 >>> df.to_sql(name='users', con=engine) 3 >>> from sqlalchemy import text >>> with engine.connect() as conn: ... conn.execute(text("SELECT * FROM users")).fetchall() [(0, 'User 1'), (1, 'User 2'), (2, 'User 3')] An `sqlalchemy.engine.Connection` can also be passed to `con`: >>> with engine.begin() as connection: ... df1 = pd.DataFrame({'name' : ['User 4', 'User 5']}) ... df1.to_sql(name='users', con=connection, if_exists='append') 2 This is allowed to support operations that require that the same DBAPI connection is used for the entire operation. >>> df2 = pd.DataFrame({'name' : ['User 6', 'User 7']}) >>> df2.to_sql(name='users', con=engine, if_exists='append') 2 >>> with engine.connect() as conn: ... conn.execute(text("SELECT * FROM users")).fetchall() [(0, 'User 1'), (1, 'User 2'), (2, 'User 3'), (0, 'User 4'), (1, 'User 5'), (0, 'User 6'), (1, 'User 7')] Overwrite the table with just ``df2``. >>> df2.to_sql(name='users', con=engine, if_exists='replace', ... index_label='id') 2 >>> with engine.connect() as conn: ... conn.execute(text("SELECT * FROM users")).fetchall() [(0, 'User 6'), (1, 'User 7')] Delete all rows before inserting new records with ``df3`` >>> df3 = pd.DataFrame({"name": ['User 8', 'User 9']}) >>> df3.to_sql(name='users', con=engine, if_exists='delete_rows', ... index_label='id') 2 >>> with engine.connect() as conn: ... conn.execute(text("SELECT * FROM users")).fetchall() [(0, 'User 8'), (1, 'User 9')] Use ``method`` to define a callable insertion method to do nothing if there's a primary key conflict on a table in a PostgreSQL database. >>> from sqlalchemy.dialects.postgresql import insert >>> def insert_on_conflict_nothing(table, conn, keys, data_iter): ... # "a" is the primary key in "conflict_table" ... data = [dict(zip(keys, row)) for row in data_iter] ... stmt = insert(table.table).values(data).on_conflict_do_nothing(index_elements=["a"]) ... result = conn.execute(stmt) ... return result.rowcount >>> df_conflict.to_sql(name="conflict_table", con=conn, if_exists="append", # noqa: F821 ... method=insert_on_conflict_nothing) # doctest: +SKIP 0 For MySQL, a callable to update columns ``b`` and ``c`` if there's a conflict on a primary key. >>> from sqlalchemy.dialects.mysql import insert # noqa: F811 >>> def insert_on_conflict_update(table, conn, keys, data_iter): ... # update columns "b" and "c" on primary key conflict ... data = [dict(zip(keys, row)) for row in data_iter] ... stmt = ( ... insert(table.table) ... .values(data) ... ) ... stmt = stmt.on_duplicate_key_update(b=stmt.inserted.b, c=stmt.inserted.c) ... result = conn.execute(stmt) ... return result.rowcount >>> df_conflict.to_sql(name="conflict_table", con=conn, if_exists="append", # noqa: F821 ... method=insert_on_conflict_update) # doctest: +SKIP 2 Specify the dtype (especially useful for integers with missing values). Notice that while pandas is forced to store the data as floating point, the database supports nullable integers. When fetching the data with Python, we get back integer scalars. >>> df = pd.DataFrame({"A": [1, None, 2]}) >>> df A 0 1.0 1 NaN 2 2.0 >>> from sqlalchemy.types import Integer >>> df.to_sql(name='integers', con=engine, index=False, ... dtype={"A": Integer()}) 3 >>> with engine.connect() as conn: ... conn.execute(text("SELECT * FROM integers")).fetchall() [(1,), (None,), (2,)] .. versionadded:: 2.2.0 pandas now supports writing via ADBC drivers >>> df = pd.DataFrame({'name' : ['User 10', 'User 11', 'User 12']}) >>> df name 0 User 10 1 User 11 2 User 12 >>> from adbc_driver_sqlite import dbapi # doctest:+SKIP >>> with dbapi.connect("sqlite://") as conn: # doctest:+SKIP ... df.to_sql(name="users", con=conn) 3 r)sqlr)rrto_sql) rrconrrrrwrrrqrs rrNDFrame.to_sql s<h "zz   #  rrprotocolr~c$SSKJn U"UUUUUS9 g)a) Pickle (serialize) object to file. Parameters ---------- path : str, path object, or file-like object String, path object (implementing ``os.PathLike[str]``), or file-like object implementing a binary ``write()`` function. File path where the pickled object will be stored. compression : str or dict, default 'infer' For on-the-fly compression of the output data. If 'infer' and 'path_or_buf' is path-like, then detect compression from the following extensions: '.gz', '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2' (otherwise no compression). Set to ``None`` for no compression. Can also be a dict with key ``'method'`` set to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and other key-value pairs are forwarded to ``zipfile.ZipFile``, ``gzip.GzipFile``, ``bz2.BZ2File``, ``zstandard.ZstdCompressor``, ``lzma.LZMAFile`` or ``tarfile.TarFile``, respectively. As an example, the following could be passed for faster compression and to create a reproducible gzip archive: ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``. protocol : int Int which indicates which protocol should be used by the pickler, default HIGHEST_PROTOCOL (see [1]_ paragraph 12.1.2). The possible values are 0, 1, 2, 3, 4, 5. A negative value for the protocol parameter is equivalent to setting its value to HIGHEST_PROTOCOL. .. [1] https://docs.python.org/3/library/pickle.html. storage_options : dict, optional Extra options that make sense for a particular storage connection, e.g. host, port, username, password, etc. For HTTP(S) URLs the key-value pairs are forwarded to ``urllib.request.Request`` as header options. For other URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more details, and for more examples on storage options refer `here `_. See Also -------- read_pickle : Load pickled pandas object (or any object) from file. DataFrame.to_hdf : Write DataFrame to an HDF5 file. DataFrame.to_sql : Write DataFrame to a SQL database. DataFrame.to_parquet : Write a DataFrame to the binary parquet format. Examples -------- >>> original_df = pd.DataFrame( ... {{"foo": range(5), "bar": range(5, 10)}} ... ) # doctest: +SKIP >>> original_df # doctest: +SKIP foo bar 0 0 5 1 1 6 2 2 7 3 3 8 4 4 9 >>> original_df.to_pickle("./dummy.pkl") # doctest: +SKIP >>> unpickled_df = pd.read_pickle("./dummy.pkl") # doctest: +SKIP >>> unpickled_df # doctest: +SKIP foo bar 0 0 5 1 1 6 2 2 7 3 3 8 4 4 9 r) to_picklerN)pandas.io.pickler)rpathrrr~rs rrNDFrame.to_pickle sh /  #+  rexcelsepc :SSKJn UR"U4XS.UD6 g)a] Copy object to the system clipboard. Write a text representation of object to the system clipboard. This can be pasted into Excel, for example. Parameters ---------- excel : bool, default True Produce output in a csv format for easy pasting into excel. - True, use the provided separator for csv pasting. - False, write a string representation of the object to the clipboard. sep : str, default ``'\t'`` Field delimiter. **kwargs These parameters will be passed to DataFrame.to_csv. See Also -------- DataFrame.to_csv : Write a DataFrame to a comma-separated values (csv) file. read_clipboard : Read text from clipboard and pass to read_csv. Notes ----- Requirements for your platform. - Linux : `xclip`, or `xsel` (with `PyQt4` modules) - Windows : none - macOS : none This method uses the processes developed for the package `pyperclip`. A solution to render any output string format is given in the examples. Examples -------- Copy the contents of a DataFrame to the clipboard. >>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=["A", "B", "C"]) >>> df.to_clipboard(sep=",") # doctest: +SKIP ... # Wrote the following to the system clipboard: ... # ,A,B,C ... # 0,1,2,3 ... # 1,4,5,6 We can omit the index by passing the keyword `index` and setting it to false. >>> df.to_clipboard(sep=",", index=False) # doctest: +SKIP ... # Wrote the following to the system clipboard: ... # A,B,C ... # 1,2,3 ... # 4,5,6 Using the original `pyperclip` package for any string output format. .. code-block:: python import pyperclip html = df.style.to_html() pyperclip.copy(html) r) clipboardsrN)rr to_clipboard)rrrrrs rrNDFrame.to_clipboardW s L )EEEfErc[S5nURS:XaURRU5$URR U5$)a Return an xarray object from the pandas object. Returns ------- xarray.DataArray or xarray.Dataset Data in the pandas structure converted to Dataset if the object is a DataFrame, or a DataArray if the object is a Series. See Also -------- DataFrame.to_hdf : Write DataFrame to an HDF5 file. DataFrame.to_parquet : Write a DataFrame to the binary parquet format. Notes ----- See the `xarray docs `__ Examples -------- >>> df = pd.DataFrame( ... [ ... ("falcon", "bird", 389.0, 2), ... ("parrot", "bird", 24.0, 2), ... ("lion", "mammal", 80.5, 4), ... ("monkey", "mammal", np.nan, 4), ... ], ... columns=["name", "class", "max_speed", "num_legs"], ... ) >>> df name class max_speed num_legs 0 falcon bird 389.0 2 1 parrot bird 24.0 2 2 lion mammal 80.5 4 3 monkey mammal NaN 4 >>> df.to_xarray() # doctest: +SKIP Dimensions: (index: 4) Coordinates: * index (index) int64 32B 0 1 2 3 Data variables: name (index) object 32B 'falcon' 'parrot' 'lion' 'monkey' class (index) object 32B 'bird' 'bird' 'mammal' 'mammal' max_speed (index) float64 32B 389.0 24.0 80.5 nan num_legs (index) int64 32B 2 2 4 4 >>> df["max_speed"].to_xarray() # doctest: +SKIP array([389. , 24. , 80.5, nan]) Coordinates: * index (index) int64 0 1 2 3 >>> dates = pd.to_datetime( ... ["2018-01-01", "2018-01-01", "2018-01-02", "2018-01-02"] ... ) >>> df_multiindex = pd.DataFrame( ... { ... "date": dates, ... "animal": ["falcon", "parrot", "falcon", "parrot"], ... "speed": [350, 18, 361, 15], ... } ... ) >>> df_multiindex = df_multiindex.set_index(["date", "animal"]) >>> df_multiindex speed date animal 2018-01-01 falcon 350 parrot 18 2018-01-02 falcon 361 parrot 15 >>> df_multiindex.to_xarray() # doctest: +SKIP Dimensions: (date: 2, animal: 2) Coordinates: * date (date) datetime64[s] 2018-01-01 2018-01-02 * animal (animal) object 'falcon' 'parrot' Data variables: speed (date, animal) int64 350 18 361 15 xarrayr)rFr DataArray from_seriesDatasetfrom_dataframe)rrs r to_xarrayNDFrame.to_xarray sFh,H5 99>##//5 5>>006 6r)rrvrrt formattersrusparsify index_names bold_rows column_format longtableescaperdecimal multicolumnmulticolumn_formatmultirowcaptionrpositioncgrrVrbufrrvrrtrrurrrrrrrrrrrrrrs rrcNDFrame.to_latex 2rcgrrVrs rrcr 2rNaN.c^^'URS:XaUR5nU c[R"S5S:Hn U c[R"S5S:Hn Uc[R"S5nUc[R"S5nUc[R"S 5nU b [ U [ 5(d [ S 5eUc[UR5O [U5n[ U[[45(a*[U5U:wa[ S US [U5S 35eUU (aSOSUS.nSS0UEnSS0UEn[ T[ 5(aU4Sjm'OTm'U'4SjnSn[ U[5(a7[UR5VVs0sHunnU[UUUS9_M nnnO[ U[5(aURSS5nURSS5nUbURSU05 UbURSU05 UnUR!SS9Rn U H,n!U!UR#5;dMURU!T'05 M. OUcTb [USS9nUU/n"UU/n#/n$/n%U(a7U$R%URVs/sH nUU;dM UPM snSS.5 USLaU$R%SS05 O2[ U[[45(aU%R%USS.5 U/n"USLaU$R%SS05 U SLaU$R%SSS .5 SUUU (aSOSU(aUOS!U3U(aS"OS#UUUUU U(a![ UR&[(5(aS$OSU S%. n&UR+UU$U%SU0UEU"U#U&S&9$s snnfs snf)'a Render object to a LaTeX tabular, longtable, or nested table. Requires ``\usepackage{booktabs}``. The output can be copy/pasted into a main LaTeX document or read from an external file with ``\input{table.tex}``. .. versionchanged:: 2.0.0 Refactored to use the Styler implementation via jinja2 templating. Parameters ---------- buf : str, Path or StringIO-like, optional, default None Buffer to write to. If None, the output is returned as a string. columns : list of label, optional The subset of columns to write. Writes all columns by default. header : bool or list of str, default True Write out the column names. If a list of strings is given, it is assumed to be aliases for the column names. Braces must be escaped. index : bool, default True Write row names (index). na_rep : str, default 'NaN' Missing data representation. formatters : list of functions or dict of {str: function}, optional Formatter functions to apply to columns' elements by position or name. The result of each function must be a unicode string. List must be of length equal to the number of columns. float_format : one-parameter function or str, optional, default None Formatter for floating point numbers. For example ``float_format="%.2f"`` and ``float_format="{:0.2f}".format`` will both result in 0.1234 being formatted as 0.12. sparsify : bool, optional Set to False for a DataFrame with a hierarchical index to print every multiindex key at each row. By default, the value will be read from the config module. index_names : bool, default True Prints the names of the indexes. bold_rows : bool, default False Make the row labels bold in the output. column_format : str, optional The columns format as specified in `LaTeX table format `__ e.g. 'rcl' for 3 columns. By default, 'l' will be used for all columns except columns of numbers, which default to 'r'. longtable : bool, optional Use a longtable environment instead of tabular. Requires adding a \usepackage{longtable} to your LaTeX preamble. By default, the value will be read from the pandas config module, and set to `True` if the option ``styler.latex.environment`` is `"longtable"`. .. versionchanged:: 2.0.0 The pandas option affecting this argument has changed. escape : bool, optional By default, the value will be read from the pandas config module and set to `True` if the option ``styler.format.escape`` is `"latex"`. When set to False prevents from escaping latex special characters in column names. .. versionchanged:: 2.0.0 The pandas option affecting this argument has changed, as has the default value to `False`. encoding : str, optional A string representing the encoding to use in the output file, defaults to 'utf-8'. decimal : str, default '.' Character recognized as decimal separator, e.g. ',' in Europe. multicolumn : bool, default True Use \multicolumn to enhance MultiIndex columns. The default will be read from the config module, and is set as the option ``styler.sparse.columns``. .. versionchanged:: 2.0.0 The pandas option affecting this argument has changed. multicolumn_format : str, default 'r' The alignment for multicolumns, similar to `column_format` The default will be read from the config module, and is set as the option ``styler.latex.multicol_align``. .. versionchanged:: 2.0.0 The pandas option affecting this argument has changed, as has the default value to "r". multirow : bool, default True Use \multirow to enhance MultiIndex rows. Requires adding a \usepackage{multirow} to your LaTeX preamble. Will print centered labels (instead of top-aligned) across the contained rows, separating groups via clines. The default will be read from the pandas config module, and is set as the option ``styler.sparse.index``. .. versionchanged:: 2.0.0 The pandas option affecting this argument has changed, as has the default value to `True`. caption : str or tuple, optional Tuple (full_caption, short_caption), which results in ``\caption[short_caption]{full_caption}``; if a single string is passed, no short caption will be set. label : str, optional The LaTeX label to be placed inside ``\label{}`` in the output. This is used with ``\ref{}`` in the main ``.tex`` file. position : str, optional The LaTeX positional argument for tables, to be placed after ``\begin{}`` in the output. Returns ------- str or None If buf is None, returns the result as a string. Otherwise returns None. See Also -------- io.formats.style.Styler.to_latex : Render a DataFrame to LaTeX with conditional formatting. DataFrame.to_string : Render a DataFrame to a console-friendly tabular output. DataFrame.to_html : Render a DataFrame as an HTML table. Notes ----- As of v2.0.0 this method has changed to use the Styler implementation as part of :meth:`.Styler.to_latex` via ``jinja2`` templating. This means that ``jinja2`` is a requirement, and needs to be installed, for this method to function. It is advised that users switch to using Styler, since that implementation is more frequently updated and contains much more flexibility with the output. Examples -------- Convert a general DataFrame to LaTeX with formatting: >>> df = pd.DataFrame(dict(name=['Raphael', 'Donatello'], ... age=[26, 45], ... height=[181.23, 177.65])) >>> print(df.to_latex(index=False, ... formatters={"name": str.upper}, ... float_format="{:.1f}".format, ... )) # doctest: +SKIP \begin{tabular}{lrr} \toprule name & age & height \\ \midrule RAPHAEL & 26 & 181.2 \\ DONATELLO & 45 & 177.7 \\ \bottomrule \end{tabular} rNzstyler.latex.environmentrzstyler.format.escaperazstyler.sparse.columnszstyler.latex.multicol_alignzstyler.sparse.indexz&`column_format` must be str or unicodezWriting z cols but got z aliases)rtrrrrc>TU-$rrV)xrus r"NDFrame.to_latex.. s |a7Grc`>[U[[45(a TbT"U5$U"U5$r)rfloatcomplex)r alt_format_ float_format_s r_wrapNDFrame.to_latex.._wraps/!eW-..=3L$Q''"1~%r)r __index__ __columns__rr)includecU$rrVr,s rrrsqrr)subsetrF)rRrrT)rrznaive-tnaivezskip-last;data) hrules sparse_indexsparse_columns environmentmulticol_alignmultirow_alignrrrrrclinesrhide relabel_indexr format_indexformat_index_names render_kwargs)rrrrbrrrrrlistrCrrrrir select_dtypesrrrrz_to_latex_via_styler)(rrrrvrrtrrurrrrrrrrrrrrrrlength base_format_ index_format_column_format_r formatters_rcindex_formattercolumn_formatter float_columnscol format_index_format_index_names_hide_relabel_index_render_kwargs_rs( ` @rrcr2 s\ 99>==?D  ))*DETI >&&'=>'IF   ++,CDK  %!'!2!23P!Q   (()>?H  $Z s-K-KEF F&-oT\\"3w< ftUm , ,V1Fxx~c&k](ST T!'gT *0(Cl(C *0!)D|)D lC ( (-GM(M & >B j$ ' '&dll33DAq75jm<<3 K D ) )(nn[$?O)~~mTB *$$k?%CD+%%{4D&EF$K ..w.?GGM$joo//&&]';<% L$<!%[AK&7 ,n=%'  LL*.,,K,Q!7:Jq,K%  U? LL&), - u . .  ! !VY"G H*OM E> LL&'* + %  LL49 :$&*3;1,-.%-c7  *Z J??'"# ((( (= =&2()  8LsN7. N=<N=rcSSKJn [SU5nU"USS9n SHin [5U n [ U [ 5(a[ X5"S 0U D6 M8[ U [5(dMOU Hn [ X5"S 0U D6 M Mk Uc0OUnURS5(aU RS5 U R"S S U0UD6$) a" Render object to a LaTeX tabular, longtable, or nested table. Uses the ``Styler`` implementation with the following, ordered, method chaining: .. code-block:: python styler = Styler(DataFrame) styler.hide(**hide) styler.relabel_index(**relabel_index) styler.format(**format) styler.format_index(**format_index) styler.to_latex(buf=buf, **render_kwargs) Parameters ---------- buf : str, Path or StringIO-like, optional, default None Buffer to write to. If None, the output is returned as a string. hide : dict, list of dict Keyword args to pass to the method call of ``Styler.hide``. If a list will call the method numerous times. relabel_index : dict, list of dict Keyword args to pass to the method of ``Styler.relabel_index``. If a list will call the method numerous times. format : dict, list of dict Keyword args to pass to the method call of ``Styler.format``. If a list will call the method numerous times. format_index : dict, list of dict Keyword args to pass to the method call of ``Styler.format_index``. If a list will call the method numerous times. render_kwargs : dict Keyword args to pass to the method call of ``Styler.to_latex``. Returns ------- str or None If buf is None, returns the result as a string. Otherwise returns None. r)Stylerrr)uuid)rr rr r rcg)Nztextbf:--rwrap;rVrs rr.NDFrame._to_latex_via_styler..s'8rrrV) pandas.io.formats.styler rvarsrrrr ri map_indexrc) rrrr rr r r r stylerkw_namekwsub_kws rrNDFrame._to_latex_via_stylerRsb 3K&2& GB"d##(.2.B%% FF,6v6! ,3   [ ) )   8 9838-88r)rrtrurrvrrwrrrquoting quotecharlineterminatorrr doublequote escapecharrrur~cgrrVrrrrtrurrvrrwrrrr,r-r.rrr/r0rrur~s rto_csvNDFrame.to_csvrrcgrrVr2s rr3r4rrrW"c[U[5(aUOUR5n[UUUUUUS9n[ U5R UUUU UU U UUU UU UUUUS9$)aH Write object to a comma-separated values (csv) file. Parameters ---------- path_or_buf : str, path object, file-like object, or None, default None String, path object (implementing os.PathLike[str]), or file-like object implementing a write() function. If None, the result is returned as a string. If a non-binary file object is passed, it should be opened with `newline=''`, disabling universal newlines. If a binary file object is passed, `mode` might need to contain a `'b'`. sep : str, default ',' String of length 1. Field delimiter for the output file. na_rep : str, default '' Missing data representation. float_format : str, Callable, default None Format string for floating point numbers. If a Callable is given, it takes precedence over other numeric formatting parameters, like decimal. columns : sequence, optional Columns to write. header : bool or list of str, default True Write out the column names. If a list of strings is given it is assumed to be aliases for the column names. index : bool, default True Write row names (index). index_label : str or sequence, or False, default None Column label for index column(s) if desired. If None is given, and `header` and `index` are True, then the index names are used. A sequence should be given if the object uses MultiIndex. If False do not print fields for index names. Use index_label=False for easier importing in R. mode : {{'w', 'x', 'a'}}, default 'w' Forwarded to either `open(mode=)` or `fsspec.open(mode=)` to control the file opening. Typical values include: - 'w', truncate the file first. - 'x', exclusive creation, failing if the file already exists. - 'a', append to the end of file if it exists. encoding : str, optional A string representing the encoding to use in the output file, defaults to 'utf-8'. `encoding` is not supported if `path_or_buf` is a non-binary file object. compression : str or dict, default 'infer' For on-the-fly compression of the output data. If 'infer' and 'path_or_buf' is path-like, then detect compression from the following extensions: '.gz', '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2' (otherwise no compression). Set to ``None`` for no compression. Can also be a dict with key ``'method'`` set to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and other key-value pairs are forwarded to ``zipfile.ZipFile``, ``gzip.GzipFile``, ``bz2.BZ2File``, ``zstandard.ZstdCompressor``, ``lzma.LZMAFile`` or ``tarfile.TarFile``, respectively. As an example, the following could be passed for faster compression and to create a reproducible gzip archive: ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``. May be a dict with key 'method' as compression mode and other entries as additional compression options if compression mode is 'zip'. Passing compression options as keys in dict is supported for compression modes 'gzip', 'bz2', 'zstd', and 'zip'. quoting : optional constant from csv module Defaults to csv.QUOTE_MINIMAL. If you have set a `float_format` then floats are converted to strings and thus csv.QUOTE_NONNUMERIC will treat them as non-numeric. quotechar : str, default '\"' String of length 1. Character used to quote fields. lineterminator : str, optional The newline character or character sequence to use in the output file. Defaults to `os.linesep`, which depends on the OS in which this method is called ('\\n' for linux, '\\r\\n' for Windows, i.e.). chunksize : int or None Rows to write at a time. date_format : str, default None Format string for datetime objects. doublequote : bool, default True Control quoting of `quotechar` inside a field. escapechar : str, default None String of length 1. Character used to escape `sep` and `quotechar` when appropriate. decimal : str, default '.' Character recognized as decimal separator. E.g. use ',' for European data. errors : str, default 'strict' Specifies how encoding and decoding errors are to be handled. See the errors argument for :func:`open` for a full list of options. storage_options : dict, optional Extra options that make sense for a particular storage connection, e.g. host, port, username, password, etc. For HTTP(S) URLs the key-value pairs are forwarded to ``urllib.request.Request`` as header options. For other URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more details, and for more examples on storage options refer `here `_. Returns ------- None or str If path_or_buf is None, returns the resulting csv format as a string. Otherwise returns None. See Also -------- read_csv : Load a CSV file into a DataFrame. to_excel : Write DataFrame to an Excel file. Examples -------- Create 'out.csv' containing 'df' without indices >>> df = pd.DataFrame( ... [["Raphael", "red", "sai"], ["Donatello", "purple", "bo staff"]], ... columns=["name", "mask", "weapon"], ... ) >>> df.to_csv("out.csv", index=False) # doctest: +SKIP Create 'out.zip' containing 'out.csv' >>> df.to_csv(index=False) 'name,mask,weapon\nRaphael,red,sai\nDonatello,purple,bo staff\n' >>> compression_opts = dict( ... method="zip", archive_name="out.csv" ... ) # doctest: +SKIP >>> df.to_csv( ... "out.zip", index=False, compression=compression_opts ... ) # doctest: +SKIP To write a csv file to a new folder or nested folder you will first need to create it using either Pathlib or os: >>> from pathlib import Path # doctest: +SKIP >>> filepath = Path("folder/subfolder/out.csv") # doctest: +SKIP >>> filepath.parent.mkdir(parents=True, exist_ok=True) # doctest: +SKIP >>> df.to_csv(filepath) # doctest: +SKIP >>> import os # doctest: +SKIP >>> os.makedirs("folder/subfolder", exist_ok=True) # doctest: +SKIP >>> df.to_csv("folder/subfolder/out.csv") # doctest: +SKIP Format floats to two decimal places: >>> df.to_csv("out1.csv", float_format="%.2f") # doctest: +SKIP Format floats using scientific notation: >>> df.to_csv("out2.csv", float_format="{{:.2e}}".format) # doctest: +SKIP )framervrrtrur)r.rrrurr,rrwrrr-rr/r0r~)rrfrrrr3)rrrrtrurrvrrwrrrr,r-r.rrr/r0rrur~rrs rr3r4sl l33T&%  !+22 )####!+!3  rc [R"SU5 [U[5(a![ [ U5R S35e[R"U[RS9nUS:Xa9URS:Xa)[U[U55(aURSS9$URRUUR!U5SS 9nUR#XDR$S 9R'US S 9$) a Return the elements in the given *positional* indices along an axis. This means that we are not indexing according to actual values in the index attribute of the object. We are indexing according to the actual position of the element in the object. Parameters ---------- indices : array-like An array of ints indicating which positions to take. axis : {0 or 'index', 1 or 'columns'}, default 0 The axis on which to select elements. ``0`` means that we are selecting rows, ``1`` means that we are selecting columns. For `Series` this parameter is unused and defaults to 0. **kwargs For compatibility with :meth:`numpy.take`. Has no effect on the output. Returns ------- same type as caller An array-like containing the elements taken from the object. See Also -------- DataFrame.loc : Select a subset of a DataFrame by labels. DataFrame.iloc : Select a subset of a DataFrame by positions. numpy.take : Take elements from an array along an axis. Examples -------- >>> df = pd.DataFrame( ... [ ... ("falcon", "bird", 389.0), ... ("parrot", "bird", 24.0), ... ("lion", "mammal", 80.5), ... ("monkey", "mammal", np.nan), ... ], ... columns=["name", "class", "max_speed"], ... index=[0, 2, 3, 1], ... ) >>> df name class max_speed 0 falcon bird 389.0 2 parrot bird 24.0 3 lion mammal 80.5 1 monkey mammal NaN Take elements at positions 0 and 3 along the axis 0 (default). Note how the actual indices selected (0 and 1) do not correspond to our selected indices 0 and 3. That's because we are selecting the 0th and 3rd rows, not rows whose indices equal 0 and 3. >>> df.take([0, 3]) name class max_speed 0 falcon bird 389.0 1 monkey mammal NaN Take elements at indices 1 and 2 along the axis 1 (column selection). >>> df.take([1, 2], axis=1) class max_speed 0 bird 389.0 2 bird 24.0 3 mammal 80.5 1 mammal NaN We may take elements using negative integers for positive indices, starting from the end of the object, just like with Python lists. >>> df.take([-1, -2]) name class max_speed 1 monkey mammal NaN 3 lion mammal 80.5 rVz1.take requires a sequence of integers, not slice.rrrFrTrverifyrtakerp)nv validate_takerrmrrrrKr<intprrrrrr<rrrr6)rindicesrrrs rr< NDFrame.takes` V$ gu % %:&&'( **WBGG4 19*/?T/S/S99%9( (99>> --d3"  ))()GTT U  rcURU5nURU5n[U[5(a [ S5eUb[U[ 5(d [ S5eUR XUS9upg[S5/UR-nXhU'[U5n URU n [XRU5U5 U $US:XaU(aX$URn O URn [U [ 5(aAU RUSS9uplU(d'[ R""U5(aXUS-n OXn OU R%U5n[U[&R(5(aNUR*[&R,:Xa!UR/5un UR1XS9$UR1XbS9$[3U5(dXn [3U5(aUS:XazURS:XaUR4U$UR6R9U5nUR;XR<S 9n URUU lU RAU5n U $[3U5(a!URSS2[XfS-54n U $US:XaURSS2U4n U $URUn W U lU $) a Return cross-section from the Series/DataFrame. This method takes a `key` argument to select data at a particular level of a MultiIndex. Parameters ---------- key : label or tuple of label Label contained in the index, or partially in a MultiIndex. axis : {0 or 'index', 1 or 'columns'}, default 0 Axis to retrieve cross-section on. level : object, defaults to first n levels (n=1 or len(key)) In case of a key partially contained in a MultiIndex, indicate which levels are used. Levels can be referred by label or position. drop_level : bool, default True If False, returns object with same levels as self. Returns ------- Series or DataFrame Cross-section from the original Series or DataFrame corresponding to the selected index levels. See Also -------- DataFrame.loc : Access a group of rows and columns by label(s) or a boolean array. DataFrame.iloc : Purely integer-location based indexing for selection by position. Notes ----- `xs` can not be used to set values. MultiIndex Slicers is a generic way to get/set values on any level or levels. It is a superset of `xs` functionality, see :ref:`MultiIndex Slicers `. Examples -------- >>> d = { ... "num_legs": [4, 4, 2, 2], ... "num_wings": [0, 0, 2, 2], ... "class": ["mammal", "mammal", "mammal", "bird"], ... "animal": ["cat", "dog", "bat", "penguin"], ... "locomotion": ["walks", "walks", "flies", "walks"], ... } >>> df = pd.DataFrame(data=d) >>> df = df.set_index(["class", "animal", "locomotion"]) >>> df num_legs num_wings class animal locomotion mammal cat walks 4 0 dog walks 4 0 bat flies 2 2 bird penguin walks 2 2 Get values at specified index >>> df.xs("mammal") num_legs num_wings animal locomotion cat walks 4 0 dog walks 4 0 bat flies 2 2 Get values at several indexes >>> df.xs(("mammal", "dog", "walks")) num_legs 4 num_wings 0 Name: (mammal, dog, walks), dtype: int64 Get values at specified index and level >>> df.xs("cat", level=1) num_legs num_wings class locomotion mammal walks 4 0 Get values at several indexes and levels >>> df.xs(("bird", "walks"), level=[0, "locomotion"]) num_legs num_wings animal penguin 2 2 Get values at specified column and axis >>> df.xs("num_wings", axis=1) class animal locomotion mammal cat walks 0 dog walks 0 bat flies 2 bird penguin walks 2 Name: num_wings, dtype: int64 z7list keys are not supported in xs, pass a tuple insteadNzIndex must be a MultiIndex)r  drop_levelrrrrr)!rrrr rrz get_loc_levelrmrrCrsr^r rr_get_loc_levelr is_integerget_locrKndarrayrbool_nonzeror<rarrfast_xs_constructor_sliced_from_mgrrrr6)rrrr rCrRlocnew_ax_indexerrrhrrindsnew_mgrs rr NDFrame.xssV$$T*% c4 UV V  fj11 <== ..sJ.WKCd }tyy0H TNHoGYYw'F F11$7 @M 19y LLEJJE eZ ( ("11#Q1?NC>>#&& %C!G 4I % I--$C#rzz**99(!kkmGT99T95599S944S>>!J S>>daiyyA~||C((ii'',G66w\\6RF::c?FL((.F s^^YYq%1W"556F QYYYq#v&F  YYs^F$FL rc[U5err)rrgs r __getitem__NDFrame.__getitem__ !$''rcrURRUSS9n[U[R5(an[ R "UR[R5[U55n[U[R5(aURUSS9$UnURU5$)z; __getitem__ for the case where the key is a slice object. getitemrrr) r_convert_slice_indexerrrKrHrmaybe_indices_to_slicerr?rr<_slice)rrslobjrs r_getitem_sliceNDFrame._getitem_slices 11#I1F eRZZ ( (00bgg1FD RG'2::..yyqy11E{{5!!rc[U[5(d[U55eURU5nURR XS9nUR X3RS9nURU5nU$)zX Construct a slice of this container. Slicing with this method is *always* positional. rr) rrmrrr get_slicerrr6)rr\rrQrhs rr[NDFrame._slicess %''4e4'++D1))%%e%7++G,,+G$$T* rc SnSnURS:Xa8[UR[5(aXRR;nU(aZ[U[ 5(dU4nURH2n[U[ 5(dMUS[U5U:XdM.X SnM4 U(d?URSRU5nURRU5Ul gg![ a Nf=f)z Delete item FrNTr) rrrrz_enginerrCrrrGridelete)rrdeletedmaybe_shortcutrrMs r __delitem__NDFrame.__delitem__s  99>jzBB "%LL,@,@!@ c5))f||c5))c*CHo.D "G$))B-'',C ))#.DI   sC55 DDc`U(a'URR(d [S5egg)NzQCannot specify 'inplace=True' when 'self.flags.allows_duplicate_labels' is False.)rrr)rrs rr2NDFrame._check_inplace_and_allows_duplicate_labelss+ 4::==A >7rcFX$![[[4a Us$f=f)aa Get item from object for given key (ex: DataFrame column). Returns ``default`` value if not found. Parameters ---------- key : object Key for which item should be returned. default : object, default None Default value to return if key is not found. Returns ------- same type as items contained in object Item for given key or ``default`` value, if key is not found. See Also -------- DataFrame.get : Get item from object for given key (ex: DataFrame column). Series.get : Get item from object for given key (ex: DataFrame column). Examples -------- >>> df = pd.DataFrame( ... [ ... [24.3, 75.7, "high"], ... [31, 87.8, "high"], ... [22, 71.6, "medium"], ... [35, 95, "medium"], ... ], ... columns=["temp_celsius", "temp_fahrenheit", "windspeed"], ... index=pd.date_range(start="2014-02-12", end="2014-02-15", freq="D"), ... ) >>> df temp_celsius temp_fahrenheit windspeed 2014-02-12 24.3 75.7 high 2014-02-13 31.0 87.8 high 2014-02-14 22.0 71.6 medium 2014-02-15 35.0 95.0 medium >>> df.get(["temp_celsius", "windspeed"]) temp_celsius windspeed 2014-02-12 24.3 high 2014-02-13 31.0 high 2014-02-14 22.0 medium 2014-02-15 35.0 medium >>> ser = df["windspeed"] >>> ser.get("2014-02-13") 'high' If the key isn't found, the default value will be used. >>> df.get(["temp_celsius", "temp_kelvin"], default="default_value") 'default_value' >>> ser.get("2014-02-10", "[unknown]") '[unknown]' )rr IndexError)rrdefaults rr NDFrame.get s+~ 9 *j1 N s   cpU[RLa#[R"S[[ 5S9 gg)NzThe copy keyword is deprecated and will be removed in a future version. Copy-on-Write is active in pandas since 3.0 which utilizes a lazy copy mechanism that defers copies until necessary. Use .copy() to make an eager copy if necessary.r)rrrrrKrOrs rrNDFrame._check_copy_deprecationPs/ s~~ % MM>+-   &r) new_arg_namecURU5 URURUUUS9nUR"S0UD6$)a Return an object with matching indices as other object. Conform the object to the same index on all axes. Optional filling logic, placing NaN in locations having no value in the previous index. A new object is produced unless the new index is equivalent to the current one and copy=False. Parameters ---------- other : Object of the same data type Its row and column indices are used to define the new indices of this object. method : {None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'} Method to use for filling holes in reindexed DataFrame. Please note: this is only applicable to DataFrames/Series with a monotonically increasing/decreasing index. .. deprecated:: 3.0.0 * None (default): don't fill gaps * pad / ffill: propagate last valid observation forward to next valid * backfill / bfill: use next valid observation to fill gap * nearest: use nearest valid observations to fill gap. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. limit : int, default None Maximum number of consecutive labels to fill for inexact matches. tolerance : optional Maximum distance between original and new labels for inexact matches. The values of the index at the matching locations must satisfy the equation ``abs(index[indexer] - target) <= tolerance``. Tolerance may be a scalar value, which applies the same tolerance to all values, or list-like, which applies variable tolerance per element. List-like includes list, tuple, array, Series, and must be the same size as the index and its dtype must exactly match the index's type. Returns ------- Series or DataFrame Same type as caller, but with changed indices on each axis. See Also -------- DataFrame.set_index : Set row labels. DataFrame.reset_index : Remove row labels or move them to new columns. DataFrame.reindex : Change to new indices or expand indices. Notes ----- Same as calling ``.reindex(index=other.index, columns=other.columns,...)``. Examples -------- >>> df1 = pd.DataFrame( ... [ ... [24.3, 75.7, "high"], ... [31, 87.8, "high"], ... [22, 71.6, "medium"], ... [35, 95, "medium"], ... ], ... columns=["temp_celsius", "temp_fahrenheit", "windspeed"], ... index=pd.date_range(start="2014-02-12", end="2014-02-15", freq="D"), ... ) >>> df1 temp_celsius temp_fahrenheit windspeed 2014-02-12 24.3 75.7 high 2014-02-13 31.0 87.8 high 2014-02-14 22.0 71.6 medium 2014-02-15 35.0 95.0 medium >>> df2 = pd.DataFrame( ... [[28, "low"], [30, "low"], [35.1, "medium"]], ... columns=["temp_celsius", "windspeed"], ... index=pd.DatetimeIndex(["2014-02-12", "2014-02-13", "2014-02-15"]), ... ) >>> df2 temp_celsius windspeed 2014-02-12 28.0 low 2014-02-13 30.0 low 2014-02-15 35.1 medium >>> df2.reindex_like(df1) temp_celsius temp_fahrenheit windspeed 2014-02-12 28.0 NaN low 2014-02-13 30.0 NaN low 2014-02-14 NaN NaN NaN 2014-02-15 35.1 NaN medium )rrqlimit tolerancerV)rrrreindex)rrrqrrtrurs r reindex_likeNDFrame.reindex_like]sNj $$T*  & &"" ' || a  r)rrrr rucgrrVrrRrrrr rrus rr NDFrame.dropr{r)rrrr rrucgrrVrzs rrr{r{rcgrrVrzs rrr{r~rrcx[US5nUb&UcUb [S5eURU5nX0n O;UcUb*US:Xa [S5eSU0n URS:XaXIS'O [S5eUn U R 5Hup!UcM U R XXWS 9n M U(aUR U 5 gU $) Nrz2Cannot specify both 'labels' and 'index'/'columns'rz0Cannot specify both 'axis' and 'index'/'columns'rrrz>Need to specify at least one of 'labels', 'index' or 'columns'r ru)rRrr rr _drop_axisr) rrRrrrr rrur*rrs rrr{s&gy9   G$7 !UVV++D1I&D  '"5qy !STTU#DyyA~")YP  JJLLD!nnVnN)    %JrcLURU5nURU5nUR(aVUb1[U[5(d [ S5eUR XUS9nOUR XS9nURU5nGO[U5=(d [U[5n [[R"U55nUbk[U[5(d [ S5eURU5RU5)n US:Xa#U R5(a[!US35eO[U[5(a9UR"S:Xa)U (d"URS5RU5)n OOURU5)n UR%U5S:HR'5n US:XaU (a[!US35e[U R"[(5(aU R+[,S 9n U R/5SnUR1U5nUR2U- S - n UR4R7UUU S US 9n UR9XR:S 9nUR2S :XaUR<UlURAU5$)a Drop labels from specified axis. Used in the ``drop`` method internally. Parameters ---------- labels : single label or list-like axis : int or axis name level : int or level name, default None For MultiIndex errors : {'ignore', 'raise'}, default 'raise' If 'ignore', suppress error and existing labels are dropped. only_slice : bool, default False Whether indexing along columns should be view-only. zaxis must be a MultiIndexrrurrrrrrrT)r allow_dups only_slicer)!rrrrrzAssertionErrorr get_indexerrirCrVrnindex_labels_to_arrayrisinrrrrrrdto_numpyboolrJr<rrreindex_indexerrrrrr6)rrRrr ruraxis_numnew_axisris_tuple_labelsmasklabels_missingrrQrhs rrNDFrame._drop_axis,sO2((.~~d# >> !$ 33()DEE99V9H99V9;&&x0G2&9VZPU=VO"6#?#?#GHF !$ 33()DEE--e499&AAW$"fX-?#@AA4,,LLH,' --a055f== &))"&"6"6v">""D!I!I!KW$"fX-?#@AA$**n55}}4}0llnQ'Gyy)H))h&*))++  ! , ++G,,+G 99>99FL""4((rc&URUlg)zW Replace self internals with result. Parameters ---------- result : same type as self N)r)rrhs rrNDFrame._update_inplacesKK rcz^U4SjnURnUbURU5nXC0nUR"S0UD6$)a Prefix labels with string `prefix`. For Series, the row labels are prefixed. For DataFrame, the column labels are prefixed. Parameters ---------- prefix : str The string to add before each label. axis : {0 or 'index', 1 or 'columns', None}, default None Axis to add prefix on .. versionadded:: 2.0.0 Returns ------- Series or DataFrame New Series or DataFrame with updated labels. See Also -------- Series.add_suffix: Suffix row labels with string `suffix`. DataFrame.add_suffix: Suffix column labels with string `suffix`. Examples -------- >>> s = pd.Series([1, 2, 3, 4]) >>> s 0 1 1 2 2 3 3 4 dtype: int64 >>> s.add_prefix("item_") item_0 1 item_1 2 item_2 3 item_3 4 dtype: int64 >>> df = pd.DataFrame({"A": [1, 2, 3, 4], "B": [3, 4, 5, 6]}) >>> df A B 0 1 3 1 2 4 2 3 5 3 4 6 >>> df.add_prefix("col_") col_A col_B 0 1 3 1 2 4 2 3 5 3 4 6 c>TU3$rrV)rrs rr$NDFrame.add_prefix..s nrrVrr ry)rrrrr*rxs ` r add_prefixNDFrame.add_prefixsGv %((  ++D1I ||%f%%rcz^U4SjnURnUbURU5nXC0nUR"S0UD6$)a Suffix labels with string `suffix`. For Series, the row labels are suffixed. For DataFrame, the column labels are suffixed. Parameters ---------- suffix : str The string to add after each label. axis : {0 or 'index', 1 or 'columns', None}, default None Axis to add suffix on .. versionadded:: 2.0.0 Returns ------- Series or DataFrame New Series or DataFrame with updated labels. See Also -------- Series.add_prefix: Prefix row labels with string `prefix`. DataFrame.add_prefix: Prefix column labels with string `prefix`. Examples -------- >>> s = pd.Series([1, 2, 3, 4]) >>> s 0 1 1 2 2 3 3 4 dtype: int64 >>> s.add_suffix("_item") 0_item 1 1_item 2 2_item 3 3_item 4 dtype: int64 >>> df = pd.DataFrame({"A": [1, 2, 3, 4], "B": [3, 4, 5, 6]}) >>> df A B 0 1 3 1 2 4 2 3 5 3 4 6 >>> df.add_suffix("_col") A_col B_col 0 1 3 1 2 4 2 3 5 3 4 6 c>UT3$rrV)rsuffixs rr$NDFrame.add_suffix..s F8nrrVr)rrrrr*rxs ` r add_suffixNDFrame.add_suffixsGv %((  ++D1I||%f%%r)r ascendingrr na_position ignore_indexrcgrrVrrrrrrrrs r sort_valuesNDFrame.sort_valuesr{r)rrrrrrcgrrVrs rrr+r{rcgrrVrs rrr8r~r quicksortlastc[U5e)uu Sort by the values along either axis. Parameters ----------%(optional_by)s axis : %(axes_single_arg)s, default 0 Axis to be sorted. ascending : bool or list of bool, default True Sort ascending vs. descending. Specify list for multiple sort orders. If this is a list of bools, must match the length of the by. inplace : bool, default False If True, perform operation in-place. kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort' Choice of sorting algorithm. See also :func:`numpy.sort` for more information. `mergesort` and `stable` are the only stable algorithms. For DataFrames, this option is only applied when sorting on a single column or label. na_position : {'first', 'last'}, default 'last' Puts NaNs at the beginning if `first`; `last` puts NaNs at the end. ignore_index : bool, default False If True, the resulting axis will be labeled 0, 1, …, n - 1. key : callable, optional Apply the key function to the values before sorting. This is similar to the `key` argument in the builtin :meth:`sorted` function, with the notable difference that this `key` function should be *vectorized*. It should expect a ``Series`` and return a Series with the same shape as the input. It will be applied to each column in `by` independently. The values in the returned Series will be used as the keys for sorting. Returns ------- DataFrame or None DataFrame with sorted values or None if ``inplace=True``. See Also -------- DataFrame.sort_index : Sort a DataFrame by the index. Series.sort_values : Similar method for a Series. Examples -------- >>> df = pd.DataFrame( ... { ... "col1": ["A", "A", "B", np.nan, "D", "C"], ... "col2": [2, 1, 9, 8, 7, 4], ... "col3": [0, 1, 9, 4, 2, 3], ... "col4": ["a", "B", "c", "D", "e", "F"], ... } ... ) >>> df col1 col2 col3 col4 0 A 2 0 a 1 A 1 1 B 2 B 9 9 c 3 NaN 8 4 D 4 D 7 2 e 5 C 4 3 F Sort by col1 >>> df.sort_values(by=["col1"]) col1 col2 col3 col4 0 A 2 0 a 1 A 1 1 B 2 B 9 9 c 5 C 4 3 F 4 D 7 2 e 3 NaN 8 4 D Sort by multiple columns >>> df.sort_values(by=["col1", "col2"]) col1 col2 col3 col4 1 A 1 1 B 0 A 2 0 a 2 B 9 9 c 5 C 4 3 F 4 D 7 2 e 3 NaN 8 4 D Sort Descending >>> df.sort_values(by="col1", ascending=False) col1 col2 col3 col4 4 D 7 2 e 5 C 4 3 F 2 B 9 9 c 0 A 2 0 a 1 A 1 1 B 3 NaN 8 4 D Putting NAs first >>> df.sort_values(by="col1", ascending=False, na_position="first") col1 col2 col3 col4 3 NaN 8 4 D 4 D 7 2 e 5 C 4 3 F 2 B 9 9 c 0 A 2 0 a 1 A 1 1 B Sorting with a key function >>> df.sort_values(by="col4", key=lambda col: col.str.lower()) col1 col2 col3 col4 0 A 2 0 a 1 A 1 1 B 2 B 9 9 c 3 NaN 8 4 D 4 D 7 2 e 5 C 4 3 F Natural sort with the key argument, using the `natsort ` package. >>> df = pd.DataFrame( ... { ... "hours": ["0hr", "128hr", "0hr", "64hr", "64hr", "128hr"], ... "mins": [ ... "10mins", ... "40mins", ... "40mins", ... "40mins", ... "10mins", ... "10mins", ... ], ... "value": [10, 20, 30, 40, 50, 60], ... } ... ) >>> df hours mins value 0 0hr 10mins 10 1 128hr 40mins 20 2 0hr 40mins 30 3 64hr 40mins 40 4 64hr 10mins 50 5 128hr 10mins 60 >>> from natsort import natsort_keygen >>> df.sort_values( ... by=["hours", "mins"], ... key=natsort_keygen(), ... ) hours mins value 0 0hr 10mins 10 2 0hr 40mins 30 4 64hr 10mins 50 3 64hr 40mins 40 5 128hr 10mins 60 1 128hr 40mins 20 rrs rrrEsJ"$''r)rr rrrsort_remainingrrc grrV rrr rrrrrrrs r sort_indexNDFrame.sort_indexr) rr rrrrrrrc grrVrs rrrrrc grrVrs rrr src [US5nURU5n[U5nURU5n [ XX5XgU 5n U cmU(aUn OUR SS9n U(aCUS:Xa$[ [UR55U lO[ [U55U l U(agU $URU5n URRXSS9nU(dURU R5nO[ [U 55nURX5 UR!XRS9n U(aUR#U 5$U R%USS9$) NrFrrr:rrrp)rRrrQrrrr|rrrrrr<r_sort_levels_monotonicrSrrr6)rrr rrrrrrrtargetrrhbaxisrrs rrrsC&gy9$$T*&y1 %% 9K  ?.19%23t||3D%EFN#0T#;FL ,,T299>>'e>D}}U+BBDH$S\2H%*++H==+I ''/ /&&tL&A Ar) rrrrqrr  fill_valuertruc ^UcqUbn[U[5(aY[TR[5(d:TRRUR;aTRRnTR U5 UbUbUb [ S5eUcUbUb [ S5eUbUbUnO$UnO!U(aTRU5S:XaUnOUnUUS.n [U5n[U4SjU R555(aTRSS9$TRXU5(aTRX5$TRXXXX5RTSS 9$) ax Conform Series/DataFrame to new index with optional filling logic. Places NA/NaN in locations having no value in the previous index. A new object is produced unless the new index is equivalent to the current one and ``copy=False``. Parameters ---------- method : {{None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}} Method to use for filling holes in reindexed DataFrame. Please note: this is only applicable to DataFrames/Series with a monotonically increasing/decreasing index. * None (default): don't fill gaps * pad / ffill: Propagate last valid observation forward to next valid. * backfill / bfill: Use next valid observation to fill gap. * nearest: Use nearest valid observations to fill gap. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. level : int or name Broadcast across a level, matching Index values on the passed MultiIndex level. fill_value : scalar, default np.nan Value to use for missing values. Defaults to NaN, but can be any "compatible" value. limit : int, default None Maximum number of consecutive elements to forward or backward fill. tolerance : optional Maximum distance between original and new labels for inexact matches. The values of the index at the matching locations most satisfy the equation ``abs(index[indexer] - target) <= tolerance``. Tolerance may be a scalar value, which applies the same tolerance to all values, or list-like, which applies variable tolerance per element. List-like includes list, tuple, array, Series, and must be the same size as the index and its dtype must exactly match the index's type. Returns ------- Series/DataFrame Series/DataFrame with changed index. See Also -------- DataFrame.set_index : Set row labels. DataFrame.reset_index : Remove row labels or move them to new columns. DataFrame.reindex_like : Change to same indices as other DataFrame. Examples -------- ``DataFrame.reindex`` supports two calling conventions * ``(index=index_labels, columns=column_labels, ...)`` * ``(labels, axis={{'index', 'columns'}}, ...)`` We *highly* recommend using keyword arguments to clarify your intent. Create a DataFrame with some fictional data. >>> index = ["Firefox", "Chrome", "Safari", "IE10", "Konqueror"] >>> columns = ["http_status", "response_time"] >>> df = pd.DataFrame( ... [[200, 0.04], [200, 0.02], [404, 0.07], [404, 0.08], [301, 1.0]], ... columns=columns, ... index=index, ... ) >>> df http_status response_time Firefox 200 0.04 Chrome 200 0.02 Safari 404 0.07 IE10 404 0.08 Konqueror 301 1.00 Create a new index and reindex the DataFrame. By default values in the new index that do not have corresponding records in the DataFrame are assigned ``NaN``. >>> new_index = ["Safari", "Iceweasel", "Comodo Dragon", "IE10", "Chrome"] >>> df.reindex(new_index) http_status response_time Safari 404.0 0.07 Iceweasel NaN NaN Comodo Dragon NaN NaN IE10 404.0 0.08 Chrome 200.0 0.02 We can fill in the missing values by passing a value to the keyword ``fill_value``. Because the index is not monotonically increasing or decreasing, we cannot use arguments to the keyword ``method`` to fill the ``NaN`` values. >>> df.reindex(new_index, fill_value=0) http_status response_time Safari 404 0.07 Iceweasel 0 0.00 Comodo Dragon 0 0.00 IE10 404 0.08 Chrome 200 0.02 >>> df.reindex(new_index, fill_value="missing") http_status response_time Safari 404 0.07 Iceweasel missing missing Comodo Dragon missing missing IE10 404 0.08 Chrome 200 0.02 We can also reindex the columns. >>> df.reindex(columns=["http_status", "user_agent"]) http_status user_agent Firefox 200 NaN Chrome 200 NaN Safari 404 NaN IE10 404 NaN Konqueror 301 NaN Or we can use "axis-style" keyword arguments >>> df.reindex(["http_status", "user_agent"], axis="columns") http_status user_agent Firefox 200 NaN Chrome 200 NaN Safari 404 NaN IE10 404 NaN Konqueror 301 NaN To further illustrate the filling functionality in ``reindex``, we will create a DataFrame with a monotonically increasing index (for example, a sequence of dates). >>> date_index = pd.date_range("1/1/2010", periods=6, freq="D") >>> df2 = pd.DataFrame( ... {"prices": [100, 101, np.nan, 100, 89, 88]}, index=date_index ... ) >>> df2 prices 2010-01-01 100.0 2010-01-02 101.0 2010-01-03 NaN 2010-01-04 100.0 2010-01-05 89.0 2010-01-06 88.0 Suppose we decide to expand the DataFrame to cover a wider date range. >>> date_index2 = pd.date_range("12/29/2009", periods=10, freq="D") >>> df2.reindex(date_index2) prices 2009-12-29 NaN 2009-12-30 NaN 2009-12-31 NaN 2010-01-01 100.0 2010-01-02 101.0 2010-01-03 NaN 2010-01-04 100.0 2010-01-05 89.0 2010-01-06 88.0 2010-01-07 NaN The index entries that did not have a value in the original data frame (for example, '2009-12-29') are by default filled with ``NaN``. If desired, we can fill in the missing values using one of several options. For example, to back-propagate the last valid value to fill the ``NaN`` values, pass ``bfill`` as an argument to the ``method`` keyword. >>> df2.reindex(date_index2, method="bfill") prices 2009-12-29 100.0 2009-12-30 100.0 2009-12-31 100.0 2010-01-01 100.0 2010-01-02 101.0 2010-01-03 NaN 2010-01-04 100.0 2010-01-05 89.0 2010-01-06 88.0 2010-01-07 NaN Please note that the ``NaN`` value present in the original DataFrame (at index value 2010-01-03) will not be filled by any of the value propagation schemes. This is because filling while reindexing does not look at DataFrame values, but only compares the original and desired indexes. If you do want to fill in the ``NaN`` values present in the original DataFrame, use the ``fillna()`` method. See the :ref:`user guide ` for more. z3Cannot specify all of 'labels', 'index', 'columns'.rrrc3r># UH,upUcM TRU5RU5v M. g7fr)r identical)r@r*rrs rrA"NDFrame.reindex..Xs6 !-  4DNN9 % / / 3 3!-s 7'7Frrvrp)rrzrrrrrrrrrr_needs_reindex_multi_reindex_multi _reindex_axesr6) rrRrrrrqrr rrtrurs ` rrvNDFrame.reindexQsqL M!5*--tzz:66 5;;.JJOOE $$T*  !49KQR R  '"5P!$$G"E d++D1Q6GE8 +62  !%   99%9( (  $ $T5 9 9&&t8 8!! 6 ,tI, . /rc UnURHUnXn U cM URU5n U RXX4US9upURU5n UR XU /0USS9nMW U$)z%Perform the reindex for all the axes.)r rtrurqFrr)rrrvr_reindex_with_indexers)rrr rtrurqrrrrRrrrrs rrNDFrame._reindex_axeshs""AWF~"B!#5f"," I((+D,,7+,% -C#" rc[R"UR56UR:H=(a" USL=(a USL=(a UR$)z$Check if we do need a multi reindex.N)rncount_not_nonerr_can_fast_transpose)rrrqr s rrNDFrame._needs_reindex_multisN " "DKKM 2dnn D )$ )  ) ((  rc[U5err)rrrs rrNDFrame._reindex_multirVrc tURn[UR55HKnXupgURU5nUcM[ U5nUb [ U5nUR UUUUUS9nMM X@RLaURSS9nURXDRS9RU5$)z*allow_dups indicates an internal call here)rrrFrr) rsortedrrr}rWrrrrr6) r reindexersrrrrrrrs rrNDFrame._reindex_with_indexerss99:??,-D'-NE006E} 'E"-g6 //%% 0H.( yy }}%}0H))()GTT   rcx^^ [R"UTU5nUS:a [S5eUc URnUR U5nUbhUR U5n[ U5RU5n[U5S:XaURUR5nUR"S0Xq0D6$T(a+S U4SjjnURU5n URUS9U $U(aAS U 4Sjjn[R"U5m URU5n URUS9U $[S5e) a Subset the DataFrame or Series according to the specified index labels. For DataFrame, filter rows or columns depending on ``axis`` argument. Note that this routine does not filter based on content. The filter is applied to the labels of the index. Parameters ---------- items : list-like Keep labels from axis which are in items. like : str Keep labels from axis for which "like in label == True". regex : str (regular expression) Keep labels from axis for which re.search(regex, label) == True. axis : {0 or 'index', 1 or 'columns', None}, default None The axis to filter on, expressed either as an index (int) or axis name (str). By default this is the info axis, 'columns' for ``DataFrame``. For ``Series`` this parameter is unused and defaults to ``None``. Returns ------- Same type as caller The filtered subset of the DataFrame or Series. See Also -------- DataFrame.loc : Access a group of rows and columns by label(s) or a boolean array. Notes ----- The ``items``, ``like``, and ``regex`` parameters are enforced to be mutually exclusive. ``axis`` defaults to the info axis that is used when indexing with ``[]``. Examples -------- >>> df = pd.DataFrame( ... np.array(([1, 2, 3], [4, 5, 6])), ... index=["mouse", "rabbit"], ... columns=["one", "two", "three"], ... ) >>> df one two three mouse 1 2 3 rabbit 4 5 6 >>> # select columns by name >>> df.filter(items=["one", "three"]) one three mouse 1 3 rabbit 4 6 >>> # select columns by regular expression >>> df.filter(regex="e$", axis=1) one three mouse 1 3 rabbit 4 6 >>> # select rows containing 'bbi' >>> df.filter(like="bbi", axis=0) one two three rabbit 4 5 6 rzDKeyword arguments `items`, `like`, or `regex` are mutually exclusiverc*>TceT[U5;$r)rX)rlikes rrNDFrame.filter..fs'''z!},,rrc<>TR[U55SL$r)searchrX)rmatchers rrr!s~~jm4D@@rz,Must pass either `items`, `like`, or `regex`rVreturnr)rnrrrrr ry intersectionrrrrvr\rMrecompile) rrrregexrnkwrRrrrrs ` @rfilterNDFrame.filters!V##E47 7V  <''D%  &&t,D%L--f5E5zQ V\\2<<04-0 0  -ZZ]F888&v. .  Ajj'GZZ]F888&v. .JK Krc<URSUR5$)a) Return the first `n` rows. This function exhibits the same behavior as ``df[:n]``, returning the first ``n`` rows based on position. It is useful for quickly checking if your object has the right type of data in it. When ``n`` is positive, it returns the first ``n`` rows. For ``n`` equal to 0, it returns an empty object. When ``n`` is negative, it returns all rows except the last ``|n|`` rows, mirroring the behavior of ``df[:n]``. If ``n`` is larger than the number of rows, this function returns all rows. Parameters ---------- n : int, default 5 Number of rows to select. Returns ------- same type as caller The first `n` rows of the caller object. See Also -------- DataFrame.tail: Returns the last `n` rows. Examples -------- >>> df = pd.DataFrame( ... { ... "animal": [ ... "alligator", ... "bee", ... "falcon", ... "lion", ... "monkey", ... "parrot", ... "shark", ... "whale", ... "zebra", ... ] ... } ... ) >>> df animal 0 alligator 1 bee 2 falcon 3 lion 4 monkey 5 parrot 6 shark 7 whale 8 zebra Viewing the first 5 lines >>> df.head() animal 0 alligator 1 bee 2 falcon 3 lion 4 monkey Viewing the first `n` lines (three in this case) >>> df.head(3) animal 0 alligator 1 bee 2 falcon For negative values of `n` >>> df.head(-3) animal 0 alligator 1 bee 2 falcon 3 lion 4 monkey 5 parrot Nrsrrns rrj NDFrame.head*snyy!}!!##rcUS:XaURSSR5$URU*SR5$)ar Return the last `n` rows. This function returns last `n` rows from the object based on position. It is useful for quickly verifying data, for example, after sorting or appending rows. For negative values of `n`, this function returns all rows except the first `|n|` rows, equivalent to ``df[|n|:]``. If ``n`` is larger than the number of rows, this function returns all rows. Parameters ---------- n : int, default 5 Number of rows to select. Returns ------- type of caller The last `n` rows of the caller object. See Also -------- DataFrame.head : The first `n` rows of the caller object. Examples -------- >>> df = pd.DataFrame( ... { ... "animal": [ ... "alligator", ... "bee", ... "falcon", ... "lion", ... "monkey", ... "parrot", ... "shark", ... "whale", ... "zebra", ... ] ... } ... ) >>> df animal 0 alligator 1 bee 2 falcon 3 lion 4 monkey 5 parrot 6 shark 7 whale 8 zebra Viewing the last 5 lines >>> df.tail() animal 4 monkey 5 parrot 6 shark 7 whale 8 zebra Viewing the last `n` lines (three in this case) >>> df.tail(3) animal 6 shark 7 whale 8 zebra For negative values of `n` >>> df.tail(-3) animal 3 lion 4 monkey 5 parrot 6 shark 7 whale 8 zebra rNrrs rtail NDFrame.tails@l 699Qq>&&( (yy!~""$$rcUcSnURU5nURUn[R"U5n [R "XU5n U cUce[ X(-5n Ub[R"XU5n[R"XX4U 5n URXS9n U(a[[U 55U l U $)u/ Return a random sample of items from an axis of object. You can use `random_state` for reproducibility. Parameters ---------- n : int, optional Number of items from axis to return. Cannot be used with `frac`. Default = 1 if `frac` = None. frac : float, optional Fraction of axis items to return. Cannot be used with `n`. replace : bool, default False Allow or disallow sampling of the same row more than once. weights : str or ndarray-like, optional Default ``None`` results in equal probability weighting. If passed a Series, will align with target object on index. Index values in weights not found in sampled object will be ignored and index values in sampled object not in weights will be assigned weights of zero. If called on a DataFrame, will accept the name of a column when axis = 0. Unless weights are a Series, weights must be same length as axis being sampled. If weights do not sum to 1, they will be normalized to sum to 1. Missing values in the weights column will be treated as zero. Infinite values not allowed. When replace = False will not allow ``(n * max(weights) / sum(weights)) > 1`` in order to avoid biased results. See the Notes below for more details. random_state : int, array-like, BitGenerator, np.random.RandomState, np.random.Generator, optional If int, array-like, or BitGenerator, seed for random number generator. If np.random.RandomState or np.random.Generator, use as given. Default ``None`` results in sampling with the current state of np.random. axis : {0 or 'index', 1 or 'columns', None}, default None Axis to sample. Accepts axis number or name. Default is stat axis for given data type. For `Series` this parameter is unused and defaults to `None`. ignore_index : bool, default False If True, the resulting index will be labeled 0, 1, …, n - 1. Returns ------- Series or DataFrame A new object of same type as caller containing `n` items randomly sampled from the caller object. See Also -------- DataFrameGroupBy.sample: Generates random samples from each group of a DataFrame object. SeriesGroupBy.sample: Generates random samples from each group of a Series object. numpy.random.choice: Generates a random sample from a given 1-D numpy array. Notes ----- If `frac` > 1, `replacement` should be set to `True`. When replace = False will not allow ``(n * max(weights) / sum(weights)) > 1``, since that would cause results to be biased. E.g. sampling 2 items without replacement with weights [100, 1, 1] would yield two last items in 1/2 of cases, instead of 1/102. This is similar to specifying `n=4` without replacement on a Series with 3 elements. Examples -------- >>> df = pd.DataFrame( ... { ... "num_legs": [2, 4, 8, 0], ... "num_wings": [2, 0, 0, 0], ... "num_specimen_seen": [10, 2, 1, 8], ... }, ... index=["falcon", "dog", "spider", "fish"], ... ) >>> df num_legs num_wings num_specimen_seen falcon 2 2 10 dog 4 0 2 spider 8 0 1 fish 0 0 8 Extract 3 random elements from the ``Series`` ``df['num_legs']``: Note that we use `random_state` to ensure the reproducibility of the examples. >>> df["num_legs"].sample(n=3, random_state=1) fish 0 spider 8 falcon 2 Name: num_legs, dtype: int64 A random 50% sample of the ``DataFrame`` with replacement: >>> df.sample(frac=0.5, replace=True, random_state=1) num_legs num_wings num_specimen_seen dog 4 0 2 fish 0 0 8 An upsample sample of the ``DataFrame`` with replacement: Note that `replace` parameter has to be `True` for `frac` parameter > 1. >>> df.sample(frac=2, replace=True, random_state=1) num_legs num_wings num_specimen_seen dog 4 0 2 fish 0 0 8 falcon 2 2 10 falcon 2 2 10 fish 0 0 8 dog 4 0 2 fish 0 0 8 dog 4 0 2 Using a DataFrame column as weights. Rows with larger value in the `num_specimen_seen` column are more likely to be sampled. >>> df.sample(n=2, weights="num_specimen_seen", random_state=1) num_legs num_wings num_specimen_seen falcon 2 2 10 fish 0 0 8 rr) rrDrn random_staterrprocess_sampling_sizerpreprocess_weightsr<r|rr) rrfracreplaceweightsrrrobj_lenrsrMsampled_indicesrhs rrrNDFrame.samplesD <D$$T***T"  .++AW= <# ##(D  //tDG --wL?6 (V5FL rcgrrVrfuncargsrs rpipe NDFrame.pipex rcgrrVrs rrrrrcR[R"URSS9U/UQ70UD6$)at Apply chainable functions that expect Series or DataFrames. Parameters ---------- func : function Function to apply to the Series/DataFrame. ``args``, and ``kwargs`` are passed into ``func``. Alternatively a ``(callable, data_keyword)`` tuple where ``data_keyword`` is a string indicating the keyword of ``callable`` that expects the Series/DataFrame. *args : iterable, optional Positional arguments passed into ``func``. **kwargs : mapping, optional A dictionary of keyword arguments passed into ``func``. Returns ------- The return type of ``func``. The result of applying ``func`` to the Series or DataFrame. See Also -------- DataFrame.apply : Apply a function along input axis of DataFrame. DataFrame.map : Apply a function elementwise on a whole DataFrame. Series.map : Apply a mapping correspondence on a :class:`~pandas.Series`. Notes ----- Use ``.pipe`` when chaining together functions that expect Series, DataFrames or GroupBy objects. Examples -------- Constructing an income DataFrame from a dictionary. >>> data = [[8000, 1000], [9500, np.nan], [5000, 2000]] >>> df = pd.DataFrame(data, columns=["Salary", "Others"]) >>> df Salary Others 0 8000 1000.0 1 9500 NaN 2 5000 2000.0 Functions that perform tax reductions on an income DataFrame. >>> def subtract_federal_tax(df): ... return df * 0.9 >>> def subtract_state_tax(df, rate): ... return df * (1 - rate) >>> def subtract_national_insurance(df, rate, rate_increase): ... new_rate = rate + rate_increase ... return df * (1 - new_rate) Instead of writing >>> subtract_national_insurance( ... subtract_state_tax(subtract_federal_tax(df), rate=0.12), ... rate=0.05, ... rate_increase=0.02, ... ) # doctest: +SKIP You can write >>> ( ... df.pipe(subtract_federal_tax) ... .pipe(subtract_state_tax, rate=0.12) ... .pipe(subtract_national_insurance, rate=0.05, rate_increase=0.02) ... ) Salary Others 0 5892.48 736.56 1 6997.32 NaN 2 3682.80 1473.12 If you have a function that takes the data as (say) the second argument, pass a tuple indicating which keyword expects the data. For example, suppose ``national_insurance`` takes its data as ``df`` in the second argument: >>> def subtract_national_insurance(rate, df, rate_increase): ... new_rate = rate + rate_increase ... return df * (1 - new_rate) >>> ( ... df.pipe(subtract_federal_tax) ... .pipe(subtract_state_tax, rate=0.12) ... .pipe( ... (subtract_national_insurance, "df"), rate=0.05, rate_increase=0.02 ... ) ... ) Salary Others 0 5892.48 736.56 1 6997.32 NaN 2 3682.80 1473.12 Fr)rnrrrs rrrs+L{{499%90$HHHHrc  ^[U[5(aUR(a[UR5UlURR =(a URR URl[ UR5[ UR5-H:n[U[5(de[RX[XS55 M< U$[US5(aURn[SU55(a>USRm[U4SjUSS55nU(a[T5Ul[SU55nXpRlU$)a6 Propagate metadata from other to self. This is the default implementation. Subclasses may override this method to implement their own metadata handling. Parameters ---------- other : the object from which to get the attributes that we are going to propagate. If ``other`` has an ``input_objs`` attribute, then this attribute must contain an iterable of objects, each with an ``attrs`` attribute. method : str, optional A passed method name providing context on where ``__finalize__`` was called. .. warning:: The value passed as `method` are not currently considered stable across pandas releases. Notes ----- In case ``other`` has an ``input_objs`` attribute, this method only propagates its metadata if each object in ``input_objs`` has the exact same metadata as the others. N input_objsc3L# UHn[UR5v M g7fr)rr)r@rs rrA'NDFrame.__finalize__..#s3ds4 ??d"$rc3@># UHoRT:Hv M g7fr)r)r@rrs rrAr&s%MHSii5&8Hsrc3L# UHoRRv M g7fr)rr)r@rs rrAr*s)XSWa''*I*ISWr)rrrrrrrPrrrrrhasattrrr) rrrqrrobjshave_same_attrsrrs @rr6NDFrame.__finalize__s(: eW % %{{ &ekk2  228KK77 JJ . DNN+c%//.BB!$,,,,""4wuD/IJC" UL ) )##D3d333Q "%%MDH%M"M"!)%DJ&))XSW)X&X #1HJJ . rcXR;aBXR;a3XR;a$URR U5(aX$[ R X5$)zt After regular attribute access, try looking up the name This allows simpler access to columns for interactive use. )rrrr:$_can_hold_identifiers_and_holds_namer__getattribute__)rrs r __getattr__NDFrame.__getattr__/sR 00 0NN*OO+DDTJJ: &&t22rc[RX5 [RXU5$![a Of=fXR;a[RXU5 gXR ;a[RXU5 g[ X5n[U[5(a[RXU5 gXR;aX U'g[RXU5 g![[4a[ [U[5(a-[U5(a[R"S[5S9 [RXU5 gf=f)zq After regular attribute access, try setting the name This allows simpler access to columns for interactive use. zPandas doesn't allow columns to be created via a new attribute name - see https://pandas.pydata.org/pandas-docs/stable/indexing.html#attribute-accessrN)rrrAttributeErrorrrrrryr:rrfr]rrrO)rrrexistings rrNDFrame.__setattr__@s   # #D /%%d%8 8    ++ +   t5 1 ^^ #   t5 1 6"4.h..&&t59__,!&J&&t59"I. 6dL11|E7J7JMM@$4#5 ""4u5 6s+*- :: 6C,C,C,,A(EEc>[TU]5nURR(a%UR URR 5 U$)zs add the string-like attributes from the info_axis. If info_axis is a MultiIndex, its first level values are used. )super_dir_additionsr:_can_hold_stringsr_dir_additions_for_owner)r additions __class__s rrNDFrame._dir_additionsjs= G*, ?? , ,   T__EE FrcBURR5Ulg)z)Consolidate data in place and return NoneN)r consolidaters r_consolidate_inplaceNDFrame._consolidate_inplacexsII))+ rcURR5nURXRS9R U5$)z Compute NDFrame with "consolidated" internals (data of each dtype grouped together in a single ndarray). Returns ------- consolidated : same type as caller r)rrrrr6)r cons_datas r _consolidateNDFrame._consolidate~s>II))+ )))..)IVV   rcURR(agURR(agURR 5S:$)NFTr)rr;any_extension_typesr3nuniquers r_is_mixed_typeNDFrame._is_mixed_types> 99 $ $ 99 ( ({{""$q((rcURR5nURXRS9R U5$Nr)rget_numeric_datarrr6rrQs r_get_numeric_dataNDFrame._get_numeric_datas8)),,.))' )ERRSWXXrcURR5nURXRS9R U5$r%)r get_bool_datarrr6r's r_get_bool_dataNDFrame._get_bool_datas8))))+))' )ERRSWXXrc[U5errrs rrNDFrame.valuess !$''rc[U5e)zinternal implementationrrs rrNDFrame._valuess"$''rcURR5nURXR[R S9$)a Return the dtypes in the DataFrame. This returns a Series with the data type of each column. The result's index is the original DataFrame's columns. Columns with mixed types are stored with the ``object`` dtype. See :ref:`the User Guide ` for more. Returns ------- pandas.Series The data type of each column. See Also -------- Series.dtypes : Return the dtype object of the underlying data. Examples -------- >>> df = pd.DataFrame( ... { ... "float": [1.0], ... "int": [1], ... "datetime": [pd.Timestamp("20180310")], ... "string": ["foo"], ... } ... ) >>> df.dtypes float float64 int int64 datetime datetime64[us] string str dtype: object )rr)r get_dtypes_constructor_slicedr:rKobject_rs rr3NDFrame.dtypess5Hyy##%''OO2::'VVrc ^URU5 [T5(Ga"URS:XaH[T5S:dURT;a [ S5eTURnUR XCS9$SSKJn U"T[S9nURHnXp;dM [ SUS35e URURS S 9n/n[UR55HXun upzURU n [!U 5(aU R#S S 9n OU R XS 9n UR)U 5 MZ O[+T5(aURS:a[-T5m[/T[05(a=[3U4SjUR4R655(aUR#S S 9$UR5VVs/sHupUR TUS9PM nnnODUR4R TUS 9nUR9UUR:S9nUR=USS9$U(dUR#S S 9$[?USS9nURAU5nURUl UR=USS9n[C[DU5$![$an U SUS34U leS n A ff=fs snnf)a Cast a pandas object to a specified dtype ``dtype``. This method allows the conversion of the data types of pandas objects, including DataFrames and Series, to the specified dtype. It supports casting entire objects to a single data type or applying different data types to individual columns using a mapping. Parameters ---------- dtype : str, data type, Series or Mapping of column name -> data type Use a str, numpy.dtype, pandas.ExtensionDtype or Python type to cast entire pandas object to the same type. Alternatively, use a mapping, e.g. {col: dtype, ...}, where col is a column label and dtype is a numpy.dtype or Python type to cast one or more of the DataFrame's columns to column-specific types. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. errors : {'raise', 'ignore'}, default 'raise' Control raising of exceptions on invalid data for provided dtype. - ``raise`` : allow exceptions to be raised - ``ignore`` : suppress exceptions. On error return original object. Returns ------- same type as caller The pandas object casted to the specified ``dtype``. See Also -------- to_datetime : Convert argument to datetime. to_timedelta : Convert argument to timedelta. to_numeric : Convert argument to a numeric type. numpy.ndarray.astype : Cast a numpy array to a specified type. Notes ----- .. versionchanged:: 2.0.0 Using ``astype`` to convert from timezone-naive dtype to timezone-aware dtype will raise an exception. Use :meth:`Series.dt.tz_localize` instead. Examples -------- Create a DataFrame: >>> d = {"col1": [1, 2], "col2": [3, 4]} >>> df = pd.DataFrame(data=d) >>> df.dtypes col1 int64 col2 int64 dtype: object Cast all columns to int32: >>> df.astype("int32").dtypes col1 int32 col2 int32 dtype: object Cast col1 to int32 using a dictionary: >>> df.astype({"col1": "int32"}).dtypes col1 int32 col2 int64 dtype: object Create a series: >>> ser = pd.Series([1, 2], dtype="int32") >>> ser 0 1 1 2 dtype: int32 >>> ser.astype("int64") 0 1 1 2 dtype: int64 Convert to categorical type: >>> ser.astype("category") 0 1 1 2 dtype: category Categories (2, int32): [1, 2] Convert to ordered categorical type with custom ordering: >>> from pandas.api.types import CategoricalDtype >>> cat_dtype = CategoricalDtype(categories=[2, 1], ordered=True) >>> ser.astype(cat_dtype) 0 1 1 2 dtype: category Categories (2, int64): [2 < 1] Create a series of dates: >>> ser_date = pd.Series(pd.date_range("20200101", periods=3)) >>> ser_date 0 2020-01-01 1 2020-01-02 2 2020-01-03 dtype: datetime64[us] rzFOnly the Series name can be used for the key in Series dtype mappings.rrr0rzJOnly a column name can be used for the key in a dtype mappings argument. 'z' not found in columns.N)rFr)rruz': Error while type casting for column 'rc3T># UHoRRT:Hv M g7fr)rr)r@blockrs rrA!NDFrame.astype..s"99I ""e+9Is%(rrrpr)#rr[rrrrrpandasrrrrvrrriatrjrrrrr\rbrrdrrrrrr6rrrr )rrrrunew_typer dtype_sercol_nameresultsrrcdtres_colex_serrrrhs ` rrNDFrame.astypes| $$T*   yyA~u:>TYYe%;"<!+{{8{;; &uF3I%OO'"$:%<>,"))$,,4)HIG&/ &="?HmmA&99!hhEh2G"%**3*"F w''>&e , ,Q 'E%00S99=9I9I966yyey,,GKjjlSlFAszz%z7lGSGyy''eF'CH,,XHMM,JC##D#: :99%9( (a(""6*$$T($;D&!!K&!d"I(STU#  Ts!JJ= J:&J55J:cURRUS9nURX"RS9R USS9$)a Make a copy of this object's indices and data. When ``deep=True`` (default), a new object will be created with a copy of the calling object's data and indices. Modifications to the data or indices of the copy will not be reflected in the original object (see notes below). When ``deep=False``, a new object will be created without copying the calling object's data or index (only references to the data and index are copied). With Copy-on-Write, changes to the original will *not* be reflected in the shallow copy (and vice versa). The shallow copy uses a lazy (deferred) copy mechanism that copies the data only when any changes to the original or shallow copy are made, ensuring memory efficiency while maintaining data integrity. .. note:: In pandas versions prior to 3.0, the default behavior without Copy-on-Write was different: changes to the original *were* reflected in the shallow copy (and vice versa). See the :ref:`Copy-on-Write user guide ` for more information. Parameters ---------- deep : bool, default True Make a deep copy, including a copy of the data and the indices. With ``deep=False`` neither the indices nor the data are copied. Returns ------- Series or DataFrame Object type matches caller. See Also -------- copy.copy : Return a shallow copy of an object. copy.deepcopy : Return a deep copy of an object. Notes ----- When ``deep=True``, data is copied but actual Python objects will not be copied recursively, only the reference to the object. This is in contrast to `copy.deepcopy` in the Standard Library, which recursively copies object data (see examples below). While ``Index`` objects are copied when ``deep=True``, the underlying numpy array is not copied for performance reasons. Since ``Index`` is immutable, the underlying data can be safely shared and a copy is not needed. Since pandas is not thread safe, see the :ref:`gotchas ` when copying in a threading environment. Copy-on-Write protects shallow copies against accidental modifications. This means that any changes to the copied data would make a new copy of the data upon write (and vice versa). Changes made to either the original or copied variable would not be reflected in the counterpart. See :ref:`Copy_on_Write ` for more information. Examples -------- >>> s = pd.Series([1, 2], index=["a", "b"]) >>> s a 1 b 2 dtype: int64 >>> s_copy = s.copy(deep=True) >>> s_copy a 1 b 2 dtype: int64 Due to Copy-on-Write, shallow copies still protect data modifications. Note shallow does not get modified below. >>> s = pd.Series([1, 2], index=["a", "b"]) >>> shallow = s.copy(deep=False) >>> s.iloc[1] = 200 >>> shallow a 1 b 2 dtype: int64 When the data has object dtype, even a deep copy does not copy the underlying Python objects. Updating a nested data object will be reflected in the deep copy. >>> s = pd.Series([[1, 2], [3, 4]]) >>> deep = s.copy() >>> s[0][0] = 10 >>> s 0 [10, 2] 1 [3, 4] dtype: object >>> deep 0 [10, 2] 1 [3, 4] dtype: object rrrrp)rrrrr6)rrrs rr NDFrame.copysINyy~~4~())$YY)?LL M  rc URSS9$r]rprs r__copy__NDFrame.__copy__ syyey$$rc URSS9$)zI Parameters ---------- memo, default None Standard signature. Unused Trrp)rmemos r __deepcopy__NDFrame.__deepcopy__syydy##rcURU5 URR5nURX"RS9nUR USS9$)a Attempt to infer better dtypes for object columns. Attempts soft conversion of object-dtyped columns, leaving non-object and unconvertible columns unchanged. The inference rules are the same as during normal Series/DataFrame construction. Parameters ---------- copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. Returns ------- same type as input object Returns an object of the same type as the input object. See Also -------- to_datetime : Convert argument to datetime. to_timedelta : Convert argument to timedelta. to_numeric : Convert argument to numeric type. convert_dtypes : Convert argument to best possible dtype. Examples -------- >>> df = pd.DataFrame({"A": ["a", 1, 2, 3]}) >>> df = df.iloc[1:] >>> df A 1 1 2 2 3 3 >>> df.dtypes A object dtype: object >>> df.infer_objects().dtypes A int64 dtype: object r infer_objectsrp)rrconvertrrr6)rrrQrs rrQNDFrame.infer_objectssRn $$T*))##%((||(D_==rc [U5 URRUUUUUUS9nURXwRS9nUR USS9$)a Convert columns from numpy dtypes to the best dtypes that support ``pd.NA``. Parameters ---------- infer_objects : bool, default True Whether object dtypes should be converted to the best possible types. convert_string : bool, default True Whether object dtypes should be converted to ``StringDtype()``. convert_integer : bool, default True Whether, if possible, conversion can be done to integer extension types. convert_boolean : bool, defaults True Whether object dtypes should be converted to ``BooleanDtypes()``. convert_floating : bool, defaults True Whether, if possible, conversion can be done to floating extension types. If `convert_integer` is also True, preference will be give to integer dtypes if the floats can be faithfully casted to integers. dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable' Back-end data type applied to the resultant :class:`DataFrame` or :class:`Series` (still experimental). Behaviour is as follows: * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame` or :class:`Serires`. * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype` :class:`DataFrame` or :class:`Series`. .. versionadded:: 2.0 Returns ------- Series or DataFrame Copy of input object with new dtype. See Also -------- infer_objects : Infer dtypes of objects. to_datetime : Convert argument to datetime. to_timedelta : Convert argument to timedelta. to_numeric : Convert argument to a numeric type. Notes ----- By default, ``convert_dtypes`` will attempt to convert a Series (or each Series in a DataFrame) to dtypes that support ``pd.NA``. By using the options ``convert_string``, ``convert_integer``, ``convert_boolean`` and ``convert_floating``, it is possible to turn off individual conversions to ``StringDtype``, the integer extension types, ``BooleanDtype`` or floating extension types, respectively. For object-dtyped columns, if ``infer_objects`` is ``True``, use the inference rules as during normal Series/DataFrame construction. Then, if possible, convert to ``StringDtype``, ``BooleanDtype`` or an appropriate integer or floating extension type, otherwise leave as ``object``. If the dtype is integer, convert to an appropriate integer extension type. If the dtype is numeric, and consists of all integers, convert to an appropriate integer extension type. Otherwise, convert to an appropriate floating extension type. In the future, as new dtypes are added that support ``pd.NA``, the results of this method will change to support those new dtypes. Examples -------- >>> df = pd.DataFrame( ... { ... "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")), ... "b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")), ... "c": pd.Series([True, False, np.nan], dtype=np.dtype("O")), ... "d": pd.Series(["h", "i", np.nan], dtype=np.dtype("O")), ... "e": pd.Series([10, np.nan, 20], dtype=np.dtype("float")), ... "f": pd.Series([np.nan, 100.5, 200], dtype=np.dtype("float")), ... } ... ) Start with a DataFrame with default dtypes. >>> df a b c d e f 0 1 x True h 10.0 NaN 1 2 y False i NaN 100.5 2 3 z NaN NaN 20.0 200.0 >>> df.dtypes a int32 b object c object d object e float64 f float64 dtype: object Convert the DataFrame to use best possible dtypes. >>> dfn = df.convert_dtypes() >>> dfn a b c d e f 0 1 x True h 10 1 2 y False i 100.5 2 3 z 20 200.0 >>> dfn.dtypes a Int32 b string c boolean d string e Int64 f Float64 dtype: object Start with a Series of strings and missing data represented by ``np.nan``. >>> s = pd.Series(["a", "b", np.nan]) >>> s 0 a 1 b 2 NaN dtype: str Obtain a Series with dtype ``StringDtype``. >>> s.convert_dtypes() 0 a 1 b 2 dtype: string )rQconvert_stringconvert_integerconvert_booleanconvert_floating dtype_backendrconvert_dtypesrp)rPrrZrrr6) rrQrUrVrWrXrYrQrs rrZNDFrame.convert_dtypesVshT M*))**')++-' + ((||(D-=>>rrrrt limit_areacUcSnURU5n[U5nUS:XaNURR(d U(a[eUR R XUS9R nU$URRUUUUS9nURXwRS9nU(aURU5 U$URUSS9$)Nrr)rqrtr])rqrtr]rrfillnarp) rrrr;rr:_pad_or_backfillpad_or_backfillrrrr6)rrqrrrtr]rhrQs rr`NDFrame._pad_or_backfills <D$$T*"6* 1999,,))VV,,z-a M))++! ,  ++G,,+G    (K&&tH&= =r)rrrtc@ [US5nU(ab[(dW[R"U5[::a9[ R "U5(d[R"[[SS9 [U[[45(a"[S[U5R S35eUcSnUR#U5nUR$S:Xa[U[&[(45(a^[+U5(dU(aU$UR-S S 9$SS KJn U"U5nUR3UR45nUR6nO3[9U5(dO"[S [U5R S35eUR:R=XUS 9nGO[U[&[(45(GaU(aUOUR-S S 9nUS:Xa[>R@"UR:RC55n[+U5S:a[ES[U535e[GURHSS2S4U5(d URK5n [EUSU 35eURLR=US9RLnU(aUROU5 UnU$URQ5GHupX;aM XzR=XS9n U(dXU 'M+[U [(5(a6U RRXzRR:XaXRTSS2U 4'MpXU 'MvURVRYU 5n [U [Z5(a[]UR^S5U n O[U [`Rb5(a.U RRRdS:XaU Rg5Sn OD[U [`Rb5(aU RRRdS:Xd [iS5e[kU 5HlupU RHSS2U4nURHSS2U4nURRURR:XaUURHSS2U4'MZURmUU5 Mn GM U$[9U5(dQUS:Xa0URLR=XS9RLnUR:nOUR:R=XUS 9nOg[U[n5(a;UR$S:Xa+URqURs5U5R:nO[ES[U535eURuXfRvS9nU(aUROU5 U$URyUSS9$)a Fill NA/NaN values with `value`. Parameters ---------- value : scalar, dict, Series, or DataFrame Value to use to fill holes (e.g. 0), alternately a dict/Series/DataFrame of values specifying which value to use for each index (for a Series) or column (for a DataFrame). Values not in the dict/Series/DataFrame will not be filled. This value cannot be a list. axis : {0 or 'index'} for Series, {0 or 'index', 1 or 'columns'} for DataFrame Axis along which to fill missing values. For `Series` this parameter is unused and defaults to 0. inplace : bool, default False If True, fill in-place. Note: this will modify any other views on this object (e.g., a no-copy slice for a column in a DataFrame). limit : int, default None This is the maximum number of entries along the entire axis where NaNs will be filled. Must be greater than 0 if not None. Returns ------- Series/DataFrame Object with missing values filled. See Also -------- ffill : Fill values by propagating the last valid observation to next valid. bfill : Fill values by using the next valid observation to fill the gap. interpolate : Fill NaN values using interpolation. reindex : Conform object to new index. asfreq : Convert TimeSeries to specified frequency. Notes ----- For non-object dtype, ``value=None`` will use the NA value of the dtype. See more details in the :ref:`Filling missing data` section. Examples -------- >>> df = pd.DataFrame( ... [ ... [np.nan, 2, np.nan, 0], ... [3, 4, np.nan, 1], ... [np.nan, np.nan, np.nan, np.nan], ... [np.nan, 3, np.nan, 4], ... ], ... columns=list("ABCD"), ... ) >>> df A B C D 0 NaN 2.0 NaN 0.0 1 3.0 4.0 NaN 1.0 2 NaN NaN NaN NaN 3 NaN 3.0 NaN 4.0 Replace all NaN elements with 0s. >>> df.fillna(0) A B C D 0 0.0 2.0 0.0 0.0 1 3.0 4.0 0.0 1.0 2 0.0 0.0 0.0 0.0 3 0.0 3.0 0.0 4.0 Replace all NaN elements in column 'A', 'B', 'C', and 'D', with 0, 1, 2, and 3 respectively. >>> values = {"A": 0, "B": 1, "C": 2, "D": 3} >>> df.fillna(value=values) A B C D 0 0.0 2.0 2.0 0.0 1 3.0 4.0 2.0 1.0 2 0.0 1.0 2.0 3.0 3 0.0 3.0 2.0 4.0 Only replace the first NaN element. >>> df.fillna(value=values, limit=1) A B C D 0 0.0 2.0 2.0 0.0 1 3.0 4.0 NaN 1.0 2 NaN 1.0 NaN 3.0 3 NaN 3.0 NaN 4.0 When filling using a DataFrame, replacement happens along the same column names and same indices >>> df2 = pd.DataFrame(np.zeros((4, 4)), columns=list("ABCE")) >>> df.fillna(df2) A B C D 0 0.0 2.0 0.0 0.0 1 3.0 4.0 0.0 1.0 2 0.0 0.0 0.0 NaN 3 0.0 3.0 0.0 4.0 Note that column D is not affected since it is not present in df2. rrrz>"value" parameter must be a scalar or dict, but you passed a "r6NrrFrr0zF"value" parameter must be a scalar, dict or Series, but you passed a ")rrtrz6All columns must have the same dtype, but got dtypes: z" not a suitable type to fill into )r)rtbrzVUnexpected get_loc result, please report a bug at https://github.com/pandas-dev/pandas)rrtzinvalid fill value with a rr_rp)=rRrDsys getrefcountrErnis_local_in_caller_framerrrLrIrr rCrrrrrrrgrrr;rrvrrr]rr_algosuniquer3rrUrsrgr:rrrrMrrGrmrrrDrKrHrrJrrisetitemrfwhererkrrr6)rrrrrtrrrh unique_dtypes frame_dtyper+r,res_klocsrrMres_locrs rr_NDFrame.fillnas\&gy9 ++??%&.4.M.Md.S.SMM6.#$ edE] + +!!%e!5!5 6a9  <D$$T* 99>%$ !2335zz#*4E u 0EE)u  djj1 !%((U ,,-Q0 yy''e''RH i0 1 1$T$)))*?Fqy!& TYY-A-A-C D }%)$P ./1 ( AqD(95AA"/"4"4"6K$ '!CK=Q u577((0!FVMS"KKMDA "I,,Q,T#'<<>!#4D&tRZZ88TZZ__PS=S#6!G# '0oFA&+jjA&6G%)YYq#v%6F&}} <6= AsF 3 &W ='6C*RMe$$qyU@BB!;;99++%g+V | , ,azz$**,6;;H9$u+GH H++H==+I    (K&&tH&= =rc[US5nU(ab[(dW[R"U5[::a9[ R "U5(d[R"[[SS9 URSUUUUS9$)a Fill NA/NaN values by propagating the last valid observation to next valid. Parameters ---------- axis : {0 or 'index'} for Series, {0 or 'index', 1 or 'columns'} for DataFrame Axis along which to fill missing values. For `Series` this parameter is unused and defaults to 0. inplace : bool, default False If True, fill in-place. Note: this will modify any other views on this object (e.g., a no-copy slice for a column in a DataFrame). limit : int, default None If method is specified, this is the maximum number of consecutive NaN values to forward/backward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. If method is not specified, this is the maximum number of entries along the entire axis where NaNs will be filled. Must be greater than 0 if not None. limit_area : {{`None`, 'inside', 'outside'}}, default None If limit is specified, consecutive NaNs will be filled with this restriction. * ``None``: No fill restriction. * 'inside': Only fill NaNs surrounded by valid values (interpolate). * 'outside': Only fill NaNs outside valid values (extrapolate). .. versionadded:: 2.2.0 Returns ------- Series/DataFrame Object with missing values filled. See Also -------- DataFrame.bfill : Fill NA/NaN values by using the next valid observation to fill the gap. Examples -------- >>> df = pd.DataFrame( ... [ ... [np.nan, 2, np.nan, 0], ... [3, 4, np.nan, 1], ... [np.nan, np.nan, np.nan, np.nan], ... [np.nan, 3, np.nan, 4], ... ], ... columns=list("ABCD"), ... ) >>> df A B C D 0 NaN 2.0 NaN 0.0 1 3.0 4.0 NaN 1.0 2 NaN NaN NaN NaN 3 NaN 3.0 NaN 4.0 >>> df.ffill() A B C D 0 NaN 2.0 NaN 0.0 1 3.0 4.0 NaN 1.0 2 3.0 4.0 NaN 1.0 3 3.0 3.0 NaN 4.0 >>> ser = pd.Series([1, np.nan, 2, 3]) >>> ser.ffill() 0 1.0 1 1.0 2 2.0 3 3.0 dtype: float64 rrrffillr\ rRrDrerfrErnrgrrrLrIr`rrrrtr]s rrs NDFrame.ffillsd&gy9 ++??%&.4.M.Md.S.SMM6.#$ $$ ! %  rc[US5nU(ab[(dW[R"U5[::a9[ R "U5(d[R"[[SS9 URSUUUUS9$)ab Fill NA/NaN values by using the next valid observation to fill the gap. This method fills missing values in a backward direction along the specified axis, propagating non-null values from later positions to earlier positions containing NaN. Parameters ---------- axis : {0 or 'index'} for Series, {0 or 'index', 1 or 'columns'} for DataFrame Axis along which to fill missing values. For `Series` this parameter is unused and defaults to 0. inplace : bool, default False If True, fill in-place. Note: this will modify any other views on this object (e.g., a no-copy slice for a column in a DataFrame). limit : int, default None If method is specified, this is the maximum number of consecutive NaN values to forward/backward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. If method is not specified, this is the maximum number of entries along the entire axis where NaNs will be filled. Must be greater than 0 if not None. limit_area : {{`None`, 'inside', 'outside'}}, default None If limit is specified, consecutive NaNs will be filled with this restriction. * ``None``: No fill restriction. * 'inside': Only fill NaNs surrounded by valid values (interpolate). * 'outside': Only fill NaNs outside valid values (extrapolate). .. versionadded:: 2.2.0 Returns ------- Series/DataFrame Object with missing values filled. See Also -------- DataFrame.ffill : Fill NA/NaN values by propagating the last valid observation to next valid. Examples -------- For Series: >>> s = pd.Series([1, None, None, 2]) >>> s.bfill() 0 1.0 1 2.0 2 2.0 3 2.0 dtype: float64 >>> s.bfill(limit=1) 0 1.0 1 NaN 2 2.0 3 2.0 dtype: float64 With DataFrame: >>> df = pd.DataFrame({"A": [1, None, None, 4], "B": [None, 5, None, 7]}) >>> df A B 0 1.0 NaN 1 NaN 5.0 2 NaN NaN 3 4.0 7.0 >>> df.bfill() A B 0 1.0 5.0 1 4.0 5.0 2 4.0 7.0 3 4.0 7.0 >>> df.bfill(limit=1) A B 0 1.0 5.0 1 NaN 5.0 2 4.0 7.0 3 4.0 7.0 rrrbfillr\rtrus rrx NDFrame.bfilljsz&gy9 ++??%&.4.M.Md.S.SMM6.#$ $$ ! %  rrrc2 [U5(dUb [S5e[U5(dB[U5(d2[ U5(d"[ S[ U5R<35eU[RLaA[U5(d1[U5(d![[ U5RS35e[US5nU(ab[(dW[R"U5[::a9[ R""U5(d[$R&"[([*SS9 U[RLa[U5(dUnSn[-UR/55nU(a[1USS06upgO//pvUVs/sHn[U5PM n n[3U 5(av[5U 5(d [ S 5e0n 0n UHNup[-[1UR/5SS065=(d //4upg[-U5X'[-U5X'MP Xp!OXgp!UR7XX4S 9$UR8(dU(aU$UR;S S 9$[U5(a[U5(au[=U[>5(a [S 5eURA5V s0sH(n XRA5;dMX;dMXU X-4_M* nn URCXU5$[ U5(dSURDS:Xa [S5eUR/5V Vs0sH upXU4_M nn nURCXU5$[ S5e[ U5(ay[ U5(dU/[GU5-n[GU5[GU5:wa$[S[GU5S[GU5S35eURHRKUUUUS9nGOEUcc[U5(dB[ U5(d2[U5(d"[ S[ U5R<35eUR7XBUSS 9$[U5(aTURDS:Xa [S5eUR/5V Vs0sH un nXU4_M nn nURCXU5$[ U5(dI[MXA5nU(aURHROUUUS9nO=URHR7XUS9nO"[ S[ U5R<35eURQUURRS9nU(aURUU5 U$URWUSS9$s snfs sn fs snn fs snn f)ap! Replace values given in `to_replace` with `value`. Values of the Series/DataFrame are replaced with other values dynamically. This differs from updating with ``.loc`` or ``.iloc``, which require you to specify a location to update with some value. Parameters ---------- to_replace : str, regex, list, dict, Series, int, float, or None How to find the values that will be replaced. * numeric, str or regex: - numeric: numeric values equal to `to_replace` will be replaced with `value` - str: string exactly matching `to_replace` will be replaced with `value` - regex: regexes matching `to_replace` will be replaced with `value` * list of str, regex, or numeric: - First, if `to_replace` and `value` are both lists, they **must** be the same length. - Second, if ``regex=True`` then all of the strings in **both** lists will be interpreted as regexes otherwise they will match directly. This doesn't matter much for `value` since there are only a few possible substitution regexes you can use. - str, regex and numeric rules apply as above. * dict: - Dicts can be used to specify different replacement values for different existing values. For example, ``{'a': 'b', 'y': 'z'}`` replaces the value 'a' with 'b' and 'y' with 'z'. To use a dict in this way, the optional `value` parameter should not be given. - For a DataFrame a dict can specify that different values should be replaced in different columns. For example, ``{'a': 1, 'b': 'z'}`` looks for the value 1 in column 'a' and the value 'z' in column 'b' and replaces these values with whatever is specified in `value`. The `value` parameter should not be ``None`` in this case. You can treat this as a special case of passing two lists except that you are specifying the column to search in. - For a DataFrame nested dictionaries, e.g., ``{'a': {'b': np.nan}}``, are read as follows: look in column 'a' for the value 'b' and replace it with NaN. The optional `value` parameter should not be specified to use a nested dict in this way. You can nest regular expressions as well. Note that column names (the top-level dictionary keys in a nested dictionary) **cannot** be regular expressions. * None: - This means that the `regex` argument must be a string, compiled regular expression, or list, dict, ndarray or Series of such elements. If `value` is also ``None`` then this **must** be a nested dictionary or Series. See the examples section for examples of each of these. value : scalar, dict, list, str, regex, default None Value to replace any values matching `to_replace` with. For a DataFrame a dict of values can be used to specify which value to use for each column (columns not in the dict will not be filled). Regular expressions, strings and lists or dicts of such objects are also allowed. inplace : bool, default False If True, performs operation inplace. regex : bool or same types as `to_replace`, default False Whether to interpret `to_replace` and/or `value` as regular expressions. Alternatively, this could be a regular expression or a list, dict, or array of regular expressions in which case `to_replace` must be ``None``. Returns ------- Series/DataFrame Object after replacement. Raises ------ AssertionError * If `regex` is not a ``bool`` and `to_replace` is not ``None``. TypeError * If `to_replace` is not a scalar, array-like, ``dict``, or ``None`` * If `to_replace` is a ``dict`` and `value` is not a ``list``, ``dict``, ``ndarray``, or ``Series`` * If `to_replace` is ``None`` and `regex` is not compilable into a regular expression or is a list, dict, ndarray, or Series. * When replacing multiple ``bool`` or ``datetime64`` objects and the arguments to `to_replace` does not match the type of the value being replaced ValueError * If a ``list`` or an ``ndarray`` is passed to `to_replace` and `value` but they are not the same length. See Also -------- Series.fillna : Fill NA values. DataFrame.fillna : Fill NA values. Series.where : Replace values based on boolean condition. DataFrame.where : Replace values based on boolean condition. DataFrame.map: Apply a function to a Dataframe elementwise. Series.map: Map values of Series according to an input mapping or function. Series.str.replace : Simple string replacement. Notes ----- * Regex substitution is performed under the hood with ``re.sub``. The rules for substitution for ``re.sub`` are the same. * Regular expressions will only substitute on strings, meaning you cannot provide, for example, a regular expression matching floating point numbers and expect the columns in your frame that have a numeric dtype to be matched. However, if those floating point numbers *are* strings, then you can do this. * This method has *a lot* of options. You are encouraged to experiment and play with this method to gain intuition about how it works. * When dict is used as the `to_replace` value, it is like key(s) in the dict are the to_replace part and value(s) in the dict are the value parameter. Examples -------- **Scalar `to_replace` and `value`** >>> s = pd.Series([1, 2, 3, 4, 5]) >>> s.replace(1, 5) 0 5 1 2 2 3 3 4 4 5 dtype: int64 >>> df = pd.DataFrame( ... { ... "A": [0, 1, 2, 3, 4], ... "B": [5, 6, 7, 8, 9], ... "C": ["a", "b", "c", "d", "e"], ... } ... ) >>> df.replace(0, 5) A B C 0 5 5 a 1 1 6 b 2 2 7 c 3 3 8 d 4 4 9 e **List-like `to_replace`** >>> df.replace([0, 1, 2, 3], 4) A B C 0 4 5 a 1 4 6 b 2 4 7 c 3 4 8 d 4 4 9 e >>> df.replace([0, 1, 2, 3], [4, 3, 2, 1]) A B C 0 4 5 a 1 3 6 b 2 2 7 c 3 1 8 d 4 4 9 e **dict-like `to_replace`** >>> df.replace({0: 10, 1: 100}) A B C 0 10 5 a 1 100 6 b 2 2 7 c 3 3 8 d 4 4 9 e >>> df.replace({"A": 0, "B": 5}, 100) A B C 0 100 100 a 1 1 6 b 2 2 7 c 3 3 8 d 4 4 9 e >>> df.replace({"A": {0: 100, 4: 400}}) A B C 0 100 5 a 1 1 6 b 2 2 7 c 3 3 8 d 4 400 9 e **Regular expression `to_replace`** >>> df = pd.DataFrame({"A": ["bat", "foo", "bait"], "B": ["abc", "bar", "xyz"]}) >>> df.replace(to_replace=r"^ba.$", value="new", regex=True) A B 0 new abc 1 foo new 2 bait xyz >>> df.replace({"A": r"^ba.$"}, {"A": "new"}, regex=True) A B 0 new abc 1 foo bar 2 bait xyz >>> df.replace(regex=r"^ba.$", value="new") A B 0 new abc 1 foo new 2 bait xyz >>> df.replace(regex={r"^ba.$": "new", "foo": "xyz"}) A B 0 new abc 1 xyz new 2 bait xyz >>> df.replace(regex=[r"^ba.$", "foo"], value="new") A B 0 new abc 1 new new 2 bait xyz Compare the behavior of ``s.replace({'a': None})`` and ``s.replace('a', None)`` to understand the peculiarities of the `to_replace` parameter: >>> s = pd.Series([10, "a", "a", "b", "a"]) When one uses a dict as the `to_replace` value, it is like the value(s) in the dict are equal to the `value` parameter. ``s.replace({'a': None})`` is equivalent to ``s.replace(to_replace={'a': None}, value=None)``: >>> s.replace({"a": None}) 0 10 1 None 2 None 3 b 4 None dtype: object If ``None`` is explicitly passed for ``value``, it will be respected: >>> s.replace("a", None) 0 10 1 None 2 None 3 b 4 None dtype: object When ``regex=True``, ``value`` is not ``None`` and `to_replace` is a string, the replacement will be applied in all columns of the DataFrame. >>> df = pd.DataFrame( ... { ... "A": [0, 1, 2, 3, 4], ... "B": ["a", "b", "c", "d", "e"], ... "C": ["f", "g", "h", "i", "j"], ... } ... ) >>> df.replace(to_replace="^[a-g]", value="e", regex=True) A B C 0 0 e e 1 1 e e 2 2 e h 3 3 e i 4 4 e j If ``value`` is not ``None`` and `to_replace` is a dictionary, the dictionary keys will be the DataFrame columns that the replacement will be applied. >>> df.replace(to_replace={"B": "^[a-c]", "C": "^[h-j]"}, value="e", regex=True) A B C 0 0 e f 1 1 e g 2 2 e e 3 3 d e 4 4 e e z4'to_replace' must be 'None' if 'regex' is not a boolzYExpecting 'to_replace' to be either a scalar, array-like, dict or None, got invalid type zU.replace must specify either 'value', a dict-like 'to_replace', or dict-like 'regex'.rrrTr1zSIf a nested mapping is passed, all values of the top level mapping must be mappingsrzFrz;to_replace and value cannot be dict-like for Series.replacerzISeries.replace cannot specify both a dict-like 'to_replace' and a 'value'z.value argument must be scalar, dict, or Seriesz2Replacement lists must match in length. Expecting z got r)src_list dest_listrrz|'regex' must be a string or a compiled regular expression or a list or dict of strings or regular expressions, you passed a z$VCH++-P-hc33S 11-P//%HH!%(((;#yy66#-# ' 7 H $yy00#-G 1 H 1$z2B2K2K1NO++H8==+I    (K&&tI&> >}=RZQs$VVV" VV V)rrtrlimit_directionr]c [US5nU(ab[(dW[R"U5[::a9[ R "U5(d[R"[[SS9 URU5nUR(aU(aU$UR5$[U[5(d [!S5eUS:XaUR"S4OUS4up[UR$[&5(aUS:wa [!S 5e[(R*"XQ5n[(R,"XR$5n UR.R0"SUU UUUUS .UD6n UR3XR4S 9n U (a U R"n U(aUR7U 5 U$U R9US S 9$)a6 Fill NaN values using an interpolation method. Please note that only ``method='linear'`` is supported for DataFrame/Series with a MultiIndex. Parameters ---------- method : str, default 'linear' Interpolation technique to use. One of: * 'linear': Ignore the index and treat the values as equally spaced. This is the only method supported on MultiIndexes. * 'time': Works on daily and higher resolution data to interpolate given length of interval. This interpolates values based on time interval between observations. * 'index': The interpolation uses the numerical values of the DataFrame's index to linearly calculate missing values. * 'values': Interpolation based on the numerical values in the DataFrame, treating them as equally spaced along the index. * 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'barycentric', 'polynomial': Passed to `scipy.interpolate.interp1d`, whereas 'spline' is passed to `scipy.interpolate.UnivariateSpline`. These methods use the numerical values of the index. Both 'polynomial' and 'spline' require that you also specify an `order` (int), e.g. ``df.interpolate(method='polynomial', order=5)``. Note that, `slinear` method in Pandas refers to the Scipy first order `spline` instead of Pandas first order `spline`. * 'krogh', 'piecewise_polynomial', 'spline', 'pchip', 'akima', 'cubicspline': Wrappers around the SciPy interpolation methods of similar names. See `Notes`. * 'from_derivatives': Refers to `scipy.interpolate.BPoly.from_derivatives`. axis : {{0 or 'index', 1 or 'columns', None}}, default None Axis to interpolate along. For `Series` this parameter is unused and defaults to 0. limit : int, optional Maximum number of consecutive NaNs to fill. Must be greater than 0. inplace : bool, default False Update the data in place if possible. limit_direction : {{'forward', 'backward', 'both'}}, optional, default 'forward' Consecutive NaNs will be filled in this direction. limit_area : {{`None`, 'inside', 'outside'}}, default None If limit is specified, consecutive NaNs will be filled with this restriction. * ``None``: No fill restriction. * 'inside': Only fill NaNs surrounded by valid values (interpolate). * 'outside': Only fill NaNs outside valid values (extrapolate). **kwargs : optional Keyword arguments to pass on to the interpolating function. Returns ------- Series or DataFrame Returns the same object type as the caller, interpolated at some or all ``NaN`` values. See Also -------- fillna : Fill missing values using different methods. scipy.interpolate.Akima1DInterpolator : Piecewise cubic polynomials (Akima interpolator). scipy.interpolate.BPoly.from_derivatives : Piecewise polynomial in the Bernstein basis. scipy.interpolate.interp1d : Interpolate a 1-D function. scipy.interpolate.KroghInterpolator : Interpolate polynomial (Krogh interpolator). scipy.interpolate.PchipInterpolator : PCHIP 1-d monotonic cubic interpolation. scipy.interpolate.CubicSpline : Cubic spline data interpolator. Notes ----- The 'krogh', 'piecewise_polynomial', 'spline', 'pchip' and 'akima' methods are wrappers around the respective SciPy implementations of similar names. These use the actual numerical values of the index. For more information on their behavior, see the `SciPy documentation `__. Examples -------- Filling in ``NaN`` in a :class:`~pandas.Series` via linear interpolation. >>> s = pd.Series([0, 1, np.nan, 3]) >>> s 0 0.0 1 1.0 2 NaN 3 3.0 dtype: float64 >>> s.interpolate() 0 0.0 1 1.0 2 2.0 3 3.0 dtype: float64 Filling in ``NaN`` in a Series via polynomial interpolation or splines: Both 'polynomial' and 'spline' methods require that you also specify an ``order`` (int). >>> s = pd.Series([0, 2, np.nan, 8]) >>> s.interpolate(method="polynomial", order=2) 0 0.000000 1 2.000000 2 4.666667 3 8.000000 dtype: float64 Fill the DataFrame forward (that is, going down) along each column using linear interpolation. Note how the last entry in column 'a' is interpolated differently, because there is no entry after it to use for interpolation. Note how the first entry in column 'b' remains ``NaN``, because there is no entry before it to use for interpolation. >>> df = pd.DataFrame( ... [ ... (0.0, np.nan, -1.0, 1.0), ... (np.nan, 2.0, np.nan, np.nan), ... (2.0, 3.0, np.nan, 9.0), ... (np.nan, 4.0, -4.0, 16.0), ... ], ... columns=list("abcd"), ... ) >>> df a b c d 0 0.0 NaN -1.0 1.0 1 NaN 2.0 NaN NaN 2 2.0 3.0 NaN 9.0 3 NaN 4.0 -4.0 16.0 >>> df.interpolate(method="linear", limit_direction="forward", axis=0) a b c d 0 0.0 NaN -1.0 1.0 1 1.0 2.0 -2.0 5.0 2 2.0 3.0 -3.0 9.0 3 2.0 4.0 -4.0 16.0 Using polynomial interpolation. >>> df["d"].interpolate(method="polynomial", order=2) 0 1.0 1 4.0 2 9.0 3 16.0 Name: d, dtype: float64 rrrz&'method' should be a string, not None.rTFlinearz@Only `method=linear` interpolation is supported on MultiIndexes.)rqrrtrr]rr interpolaterprV)rRrDrerfrErnrgrrrLrIrr7rrrrr:rrzrpinfer_limit_directionget_interp_indexrrrrrr6) rrqrrtrrr]rrshould_transposerrrhs rrNDFrame.interpolatesR&gy9 ++??%&.4.M.Md.S.SMM6.#$ $$T* ::"4 3 3&#&&EF F26!)$ cii , ,81CR "77P((;88'' +!   ++H==+I XXF    (K&&tM&B Brc[U[5(a [U5nURR(d [ S5e[U[ 5nU(aUb [ S5eO"Uc URn[U5(dU/n[U5nU(GdURSn[UR[5(a[XRRS9nX:a@U(d)URURU[RS9$[R$U(alURR!USS9nUS:aUS-nUR"nUS:a1[%Xv5(aUS-nUS:a[%Xv5(aMXv$[U[&5(dU(a ['U5O ['U/5nU(aUR%5OXR%5R)SS 9nUR+5(aU(a4[-S U5nUR/[RXR0S 9$U(a4[-S U5nUR/[RXRS 9$[-S U5nUR[RURUSS 9$URR3XR")5n U S:Hn UR5U 5n XlU R)5(a[RU R6U 'U(aU $U R8S$)a Return the last row(s) without any NaNs before `where`. The last row (for each element in `where`, if list) without any NaN is taken. In case of a :class:`~pandas.DataFrame`, the last row without NaN considering only the subset of columns (if not `None`) If there is no good value, NaN is returned for a Series or a Series of NaN values for a DataFrame Parameters ---------- where : date or array-like of dates Date(s) before which the last row(s) are returned. subset : str or array-like of str, default `None` For DataFrame, if not `None`, only use these columns to check for NaNs. Returns ------- scalar, Series, or DataFrame The return can be: * scalar : when `self` is a Series and `where` is a scalar * Series: when `self` is a Series and `where` is an array-like, or when `self` is a DataFrame and `where` is a scalar * DataFrame : when `self` is a DataFrame and `where` is an array-like See Also -------- merge_asof : Perform an asof merge. Similar to left join. Notes ----- Dates are assumed to be sorted. Raises if this is not the case. Examples -------- A Series and a scalar `where`. >>> s = pd.Series([1, 2, np.nan, 4], index=[10, 20, 30, 40]) >>> s 10 1.0 20 2.0 30 NaN 40 4.0 dtype: float64 >>> s.asof(20) np.float64(2.0) For a sequence `where`, a Series is returned. The first value is NaN, because the first element of `where` is before the first index value. >>> s.asof([5, 20]) 5 NaN 20 2.0 dtype: float64 Missing values are not considered. The following is ``2.0``, not NaN, even though NaN is at the index location for ``30``. >>> s.asof(30) np.float64(2.0) Take all columns into consideration >>> df = pd.DataFrame( ... { ... "a": [10.0, 20.0, 30.0, 40.0, 50.0], ... "b": [None, None, None, None, 500], ... }, ... index=pd.DatetimeIndex( ... [ ... "2018-02-27 09:01:00", ... "2018-02-27 09:02:00", ... "2018-02-27 09:03:00", ... "2018-02-27 09:04:00", ... "2018-02-27 09:05:00", ... ] ... ), ... ) >>> df.asof(pd.DatetimeIndex(["2018-02-27 09:03:30", "2018-02-27 09:04:30"])) a b 2018-02-27 09:03:30 NaN NaN 2018-02-27 09:04:30 NaN NaN Take a single column into consideration >>> df.asof( ... pd.DatetimeIndex(["2018-02-27 09:03:30", "2018-02-27 09:04:30"]), ... subset=["a"], ... ) a b 2018-02-27 09:03:30 30.0 NaN 2018-02-27 09:04:30 40.0 NaN zasof requires a sorted indexzsubset is not valid for Seriesr)freq)rrrright)siderrr)rrrrr)rrrris_monotonic_increasingrrgrr]r{rrr4rKfloat64nan searchsortedrrjryrrrrr asof_locsr<rMrs) rrkr is_seriesis_liststartrMrnullsrorrs rasof NDFrame.asofsN eS ! !e$Ezz11;< <tY/ ! !ABB"~'' u%JJqME$**k22u::??;} 33"llbjj4vv jj--e'-B71HCAg$v{"3"31HCAg$v{"3"3{"%''$+E%LwE( dl.?.?.A.E.E1.E.M 99;;Hd+((u99(MMK.((ull(SSK.//FF$,,U1X0 zz##EMM>:rzyy 88:: VVDHHTNt1DIIbM1rc4[U5RUSS9$)aM Detect missing values. Return a boolean same-sized object indicating if the values are NA. NA values, such as None or :attr:`numpy.NaN`, gets mapped to True values. Everything else gets mapped to False values. Characters such as empty strings ``''`` or :attr:`numpy.inf` are not considered NA values. Returns ------- Series/DataFrame Mask of bool values for each element in Series/DataFrame that indicates whether an element is an NA value. See Also -------- Series.isnull : Alias of isna. DataFrame.isnull : Alias of isna. Series.notna : Boolean inverse of isna. DataFrame.notna : Boolean inverse of isna. Series.dropna : Omit axes labels with missing values. DataFrame.dropna : Omit axes labels with missing values. isna : Top-level isna. Examples -------- Show which entries in a DataFrame are NA. >>> df = pd.DataFrame( ... dict( ... age=[5, 6, np.nan], ... born=[ ... pd.NaT, ... pd.Timestamp("1939-05-27"), ... pd.Timestamp("1940-04-25"), ... ], ... name=["Alfred", "Batman", ""], ... toy=[None, "Batmobile", "Joker"], ... ) ... ) >>> df age born name toy 0 5.0 NaT Alfred NaN 1 6.0 1939-05-27 Batman Batmobile 2 NaN 1940-04-25 Joker >>> df.isna() age born name toy 0 False True False True 1 False False False False 2 True False False False Show which entries in a Series are NA. >>> ser = pd.Series([5, 6, np.nan]) >>> ser 0 5.0 1 6.0 2 NaN dtype: float64 >>> ser.isna() 0 False 1 False 2 True dtype: bool rjrprjr6rs rrj NDFrame.isnaM sJDz&&tF&;;rc4[U5RUSS9$)aQ Detect missing values. Return a boolean same-sized object indicating if the values are NA. NA values, such as None or :attr:`numpy.NaN`, gets mapped to True values. Everything else gets mapped to False values. Characters such as empty strings ``''`` or :attr:`numpy.inf` are not considered NA values. Returns ------- Series/DataFrame Mask of bool values for each element in Series/DataFrame that indicates whether an element is an NA value. See Also -------- Series.isna : Alias of isnull. DataFrame.isna : Alias of isnull. Series.notna : Boolean inverse of isnull. DataFrame.notna : Boolean inverse of isnull. Series.dropna : Omit axes labels with missing values. DataFrame.dropna : Omit axes labels with missing values. isna : Top-level isna. Examples -------- Show which entries in a DataFrame are NA. >>> df = pd.DataFrame( ... dict( ... age=[5, 6, np.nan], ... born=[ ... pd.NaT, ... pd.Timestamp("1939-05-27"), ... pd.Timestamp("1940-04-25"), ... ], ... name=["Alfred", "Batman", ""], ... toy=[None, "Batmobile", "Joker"], ... ) ... ) >>> df age born name toy 0 5.0 NaT Alfred NaN 1 6.0 1939-05-27 Batman Batmobile 2 NaN 1940-04-25 Joker >>> df.isna() age born name toy 0 False True False True 1 False False False False 2 True False False False Show which entries in a Series are NA. >>> ser = pd.Series([5, 6, np.nan]) >>> ser 0 5.0 1 6.0 2 NaN dtype: float64 >>> ser.isna() 0 False 1 False 2 True dtype: bool isnullrprrs rrNDFrame.isnull sJDz&&tH&==rc4[U5RUSS9$)j Detect existing (non-missing) values. Return a boolean same-sized object indicating if the values are not NA. Non-missing values get mapped to True. Characters such as empty strings ``''`` or :attr:`numpy.inf` are not considered NA values. NA values, such as None or :attr:`numpy.NaN`, get mapped to False values. Returns ------- Series/DataFrame Mask of bool values for each element in Series/DataFrame that indicates whether an element is not an NA value. See Also -------- Series.notnull : Alias of notna. DataFrame.notnull : Alias of notna. Series.isna : Boolean inverse of notna. DataFrame.isna : Boolean inverse of notna. Series.dropna : Omit axes labels with missing values. DataFrame.dropna : Omit axes labels with missing values. notna : Top-level notna. Examples -------- Show which entries in a DataFrame are not NA. >>> df = pd.DataFrame( ... dict( ... age=[5, 6, np.nan], ... born=[ ... pd.NaT, ... pd.Timestamp("1939-05-27"), ... pd.Timestamp("1940-04-25"), ... ], ... name=["Alfred", "Batman", ""], ... toy=[None, "Batmobile", "Joker"], ... ) ... ) >>> df age born name toy 0 5.0 NaT Alfred NaN 1 6.0 1939-05-27 Batman Batmobile 2 NaN 1940-04-25 Joker >>> df.notna() age born name toy 0 True False True False 1 True True True True 2 False True True True Show which entries in a Series are not NA. >>> ser = pd.Series([5, 6, np.nan]) >>> ser 0 5.0 1 6.0 2 NaN dtype: float64 >>> ser.notna() 0 True 1 True 2 False dtype: bool rkrprkr6rs rrk NDFrame.notna sJT{''W'==rc4[U5RUSS9$)rnotnullrprrs rrNDFrame.notnull"!sJT{''Y'??rcDUb$[R"[U55(d'Ub/[R"[U55(a [S5eUnUR5nUbXPU:-nUR XaUS9nUbXPU:*-nUR XbUS9nU$)Nz*Cannot use an NA value as a clip thresholdrP)rKrrjrrk)rlowerupperrrhrconds r_clip_with_scalarNDFrame._clip_with_scalari!s  "&&e"5"5  "&&e"5"5IJ Jyy{  5=)D\\$w\?F  5=)D\\$w\?F rcUbURU5n[U5(aA[U5(a1URS:XaUR SXS9$UR USUS9$[ U[ 5(dR[U5(aB[ U[ 5(aURXRS9nOURXSS9Sn[U5(aCURS:Xa[RO[R*nURU5nOUnU"XcS9[U5-nURXqX4S9$)NlerP)r)flexrrr)rrar^rrrrgr]rr _align_for_oprKrrr_rjrk)r thresholdrqrrr threshold_infrs r_clip_with_one_boundNDFrame._clip_with_one_bound|!s&  ((.D Y  Ii$8$8$&--dI-OO)))T7)K K 9i00l96M6M$ ** --izz-J  ..yT.J1M   " "#)??d#:J%,,Z8M%M 1DJ>zz&$zHHrrc  [US5nU(ab[(dW[R"U5[::a9[ R "U5(d[R"[[SS9 [R"USU5nUbURU5n[U5n[U5(d[ R""U5(aSnO[ R$"U5(aSn[U5n[U5(d[ R""U5(aSnO[ R$"U5(aSnUb8Ub5['U5(a%['U5(a[)X5[+X5p!Ub[-U5(a#Ub[-U5(aUR/XUS9$UnUbUR1XR2X4S9nUb#U(aUnUR1X R4X4S9nU$)a Trim values at input threshold(s). Assigns values outside boundary to boundary values. Thresholds can be singular values or array like, and in the latter case the clipping is performed element-wise in the specified axis. Parameters ---------- lower : float or array-like, default None Minimum threshold value. All values below this threshold will be set to it. A missing threshold (e.g `NA`) will not clip the value. upper : float or array-like, default None Maximum threshold value. All values above this threshold will be set to it. A missing threshold (e.g `NA`) will not clip the value. axis : {{0 or 'index', 1 or 'columns', None}}, default None Align object with lower and upper along the given axis. For `Series` this parameter is unused and defaults to `None`. inplace : bool, default False Whether to perform the operation in place on the data. **kwargs Additional keywords have no effect but might be accepted for compatibility with numpy. Returns ------- Series or DataFrame Same type as calling object with the values outside the clip boundaries replaced. See Also -------- Series.clip : Trim values at input threshold in series. DataFrame.clip : Trim values at input threshold in DataFrame. numpy.clip : Clip (limit) the values in an array. Examples -------- >>> data = {"col_0": [9, -3, 0, -1, 5], "col_1": [-2, -7, 6, 8, -5]} >>> df = pd.DataFrame(data) >>> df col_0 col_1 0 9 -2 1 -3 -7 2 0 6 3 -1 8 4 5 -5 Clips per column using lower and upper thresholds: >>> df.clip(-4, 6) col_0 col_1 0 6 -2 1 -3 -4 2 0 6 3 -1 6 4 5 -4 Clips using specific lower and upper thresholds per column: >>> df.clip([-2, -1], [4, 5]) col_0 col_1 0 4 -1 1 -2 -1 2 0 5 3 -1 5 4 4 -1 Clips using specific lower and upper thresholds per column element: >>> t = pd.Series([2, -4, -1, 6, 3]) >>> t 0 2 1 -4 2 -1 3 6 4 3 dtype: int64 >>> df.clip(t, t + 4, axis=0) col_0 col_1 0 6 2 1 -3 -4 2 0 3 3 6 8 4 5 3 Clips using specific lower threshold per column element, with missing values: >>> t = pd.Series([2, -4, np.nan, 6, 3]) >>> t 0 2.0 1 -4.0 2 NaN 3 6.0 4 3.0 dtype: float64 >>> df.clip(t, axis=0) col_0 col_1 0 9.0 2.0 1 -3.0 -4.0 2 0.0 6.0 3 6.0 8.0 4 5.0 3.0 rrrrVNrP)rqrr)rRrDrerfrErnrgrrrLrIr=validate_clip_with_axisrrjr]rKrrraminmaxr^rrger) rrrrrr isna_lower isna_upperrhs rclip NDFrame.clip!sl&gy9 ++??%&.4.M.Md.S.SMM6.#$ ))$F;  ((.D%[ E""vvj!! VVJ  E%[ E""vvj!! VVJ  E  !%  %  u,c%.?5 MYu--EMYuEUEU))%)H H  00ggD1F  00ggD1F rc $SSKJn U"UUUUUUS9$)a Convert time series to specified frequency. Returns the original data conformed to a new index with the specified frequency. If the index of this Series/DataFrame is a :class:`~pandas.PeriodIndex`, the new index is the result of transforming the original index with :meth:`PeriodIndex.asfreq ` (so the original index will map one-to-one to the new index). Otherwise, the new index will be equivalent to ``pd.date_range(start, end, freq=freq)`` where ``start`` and ``end`` are, respectively, the min and max entries in the original index (see :func:`pandas.date_range`). The values corresponding to any timesteps in the new index which were not present in the original index will be null (``NaN``), unless a method for filling such unknowns is provided (see the ``method`` parameter below). The :meth:`resample` method is more appropriate if an operation on each group of timesteps (such as an aggregate) is necessary to represent the data at the new frequency. Parameters ---------- freq : DateOffset or str Frequency DateOffset or string. method : {{'backfill'/'bfill', 'pad'/'ffill'}}, default None Method to use for filling holes in reindexed Series (note this does not fill NaNs that already were present): * 'pad' / 'ffill': propagate last valid observation forward to next valid based on the order of the index * 'backfill' / 'bfill': use NEXT valid observation to fill. how : {{'start', 'end'}}, default end For PeriodIndex only (see PeriodIndex.asfreq). normalize : bool, default False Whether to reset output index to midnight. fill_value : scalar, optional Value to use for missing values, applied during upsampling (note this does not fill NaNs that already were present). Returns ------- Series/DataFrame Series/DataFrame object reindexed to the specified frequency. See Also -------- reindex : Conform DataFrame to new index with optional filling logic. Notes ----- To learn more about the frequency strings, please see :ref:`this link`. Examples -------- Start by creating a series with 4 one minute timestamps. >>> index = pd.date_range("1/1/2000", periods=4, freq="min") >>> series = pd.Series([0.0, None, 2.0, 3.0], index=index) >>> df = pd.DataFrame({"s": series}) >>> df s 2000-01-01 00:00:00 0.0 2000-01-01 00:01:00 NaN 2000-01-01 00:02:00 2.0 2000-01-01 00:03:00 3.0 Upsample the series into 30 second bins. >>> df.asfreq(freq="30s") s 2000-01-01 00:00:00 0.0 2000-01-01 00:00:30 NaN 2000-01-01 00:01:00 NaN 2000-01-01 00:01:30 NaN 2000-01-01 00:02:00 2.0 2000-01-01 00:02:30 NaN 2000-01-01 00:03:00 3.0 Upsample again, providing a ``fill value``. >>> df.asfreq(freq="30s", fill_value=9.0) s 2000-01-01 00:00:00 0.0 2000-01-01 00:00:30 9.0 2000-01-01 00:01:00 NaN 2000-01-01 00:01:30 9.0 2000-01-01 00:02:00 2.0 2000-01-01 00:02:30 9.0 2000-01-01 00:03:00 3.0 Upsample again, providing a ``method``. >>> df.asfreq(freq="30s", method="bfill") s 2000-01-01 00:00:00 0.0 2000-01-01 00:00:30 NaN 2000-01-01 00:01:00 NaN 2000-01-01 00:01:30 2.0 2000-01-01 00:02:00 2.0 2000-01-01 00:02:30 3.0 2000-01-01 00:03:00 3.0 r)asfreq)rqhow normalizer)pandas.core.resampler)rrrqrrrrs rrNDFrame.asfreqQ"s'd 0  !   rcUcSnURU5nURU5n[U[5(d [ S5eUR XS9nUR XSS9$)ay Select values at particular time of day (e.g., 9:30AM). Parameters ---------- time : datetime.time or str The values to select. asof : bool, default False This parameter is currently not supported. axis : {0 or 'index', 1 or 'columns'}, default 0 For `Series` this parameter is unused and defaults to 0. Returns ------- Series or DataFrame The values with the specified time. Raises ------ TypeError If the index is not a :class:`DatetimeIndex` See Also -------- between_time : Select values between particular times of the day. first : Select initial periods of time series based on a date offset. last : Select final periods of time series based on a date offset. DatetimeIndex.indexer_at_time : Get just the index locations for values at particular time of the day. Examples -------- >>> i = pd.date_range("2018-04-09", periods=4, freq="12h") >>> ts = pd.DataFrame({"A": [1, 2, 3, 4]}, index=i) >>> ts A 2018-04-09 00:00:00 1 2018-04-09 12:00:00 2 2018-04-10 00:00:00 3 2018-04-10 12:00:00 4 >>> ts.at_time("12:00") A 2018-04-09 12:00:00 2 2018-04-10 12:00:00 4 rIndex must be DatetimeIndex)rr)rrrrxrindexer_at_timer<)rtimerrrrs rat_timeNDFrame.at_time"sj` <D$$T*t$%//9: :'''8yyy,,rcUcSnURU5nURU5n[U[5(d [ S5e[ U5upgUR UUUUS9nURXS9$)a Select values between particular times of the day (e.g., 9:00-9:30 AM). By setting ``start_time`` to be later than ``end_time``, you can get the times that are *not* between the two times. Parameters ---------- start_time : datetime.time or str Initial time as a time filter limit. end_time : datetime.time or str End time as a time filter limit. inclusive : {"both", "neither", "left", "right"}, default "both" Include boundaries; whether to set each bound as closed or open. axis : {0 or 'index', 1 or 'columns'}, default 0 Determine range time on index or columns value. For `Series` this parameter is unused and defaults to 0. Returns ------- Series or DataFrame Data from the original object filtered to the specified dates range. Raises ------ TypeError If the index is not a :class:`DatetimeIndex` See Also -------- at_time : Select values at a particular time of the day. first : Select initial periods of time series based on a date offset. last : Select final periods of time series based on a date offset. DatetimeIndex.indexer_between_time : Get just the index locations for values between particular times of the day. Examples -------- >>> i = pd.date_range("2018-04-09", periods=4, freq="1D20min") >>> ts = pd.DataFrame({"A": [1, 2, 3, 4]}, index=i) >>> ts A 2018-04-09 00:00:00 1 2018-04-10 00:20:00 2 2018-04-11 00:40:00 3 2018-04-12 01:00:00 4 >>> ts.between_time("0:15", "0:45") A 2018-04-10 00:20:00 2 2018-04-11 00:40:00 3 You get the times that are *not* between two times by setting ``start_time`` later than ``end_time``: >>> ts.between_time("0:45", "0:15") A 2018-04-09 00:00:00 1 2018-04-12 01:00:00 4 rr) include_start include_endr)rrrrxrrSindexer_between_timer<) r start_timeend_time inclusiverrleft_inclusiveright_inclusivers r between_timeNDFrame.between_time #sH <D$$T*t$%//9: :*`__ for more. To learn more about the offset strings, please see `this link `__. Examples -------- Start by creating a series with 9 one minute timestamps. >>> index = pd.date_range("1/1/2000", periods=9, freq="min") >>> series = pd.Series(range(9), index=index) >>> series 2000-01-01 00:00:00 0 2000-01-01 00:01:00 1 2000-01-01 00:02:00 2 2000-01-01 00:03:00 3 2000-01-01 00:04:00 4 2000-01-01 00:05:00 5 2000-01-01 00:06:00 6 2000-01-01 00:07:00 7 2000-01-01 00:08:00 8 Freq: min, dtype: int64 Downsample the series into 3 minute bins and sum the values of the timestamps falling into a bin. >>> series.resample("3min").sum() 2000-01-01 00:00:00 3 2000-01-01 00:03:00 12 2000-01-01 00:06:00 21 Freq: 3min, dtype: int64 Downsample the series into 3 minute bins as above, but label each bin using the right edge instead of the left. Please note that the value in the bucket used as the label is not included in the bucket, which it labels. For example, in the original series the bucket ``2000-01-01 00:03:00`` contains the value 3, but the summed value in the resampled bucket with the label ``2000-01-01 00:03:00`` does not include 3 (if it did, the summed value would be 6, not 3). >>> series.resample("3min", label="right").sum() 2000-01-01 00:03:00 3 2000-01-01 00:06:00 12 2000-01-01 00:09:00 21 Freq: 3min, dtype: int64 To include this value close the right side of the bin interval, as shown below. >>> series.resample("3min", label="right", closed="right").sum() 2000-01-01 00:00:00 0 2000-01-01 00:03:00 6 2000-01-01 00:06:00 15 2000-01-01 00:09:00 15 Freq: 3min, dtype: int64 Upsample the series into 30 second bins. >>> series.resample("30s").asfreq()[0:5] # Select first 5 rows 2000-01-01 00:00:00 0.0 2000-01-01 00:00:30 NaN 2000-01-01 00:01:00 1.0 2000-01-01 00:01:30 NaN 2000-01-01 00:02:00 2.0 Freq: 30s, dtype: float64 Upsample the series into 30 second bins and fill the ``NaN`` values using the ``ffill`` method. >>> series.resample("30s").ffill()[0:5] 2000-01-01 00:00:00 0 2000-01-01 00:00:30 0 2000-01-01 00:01:00 1 2000-01-01 00:01:30 1 2000-01-01 00:02:00 2 Freq: 30s, dtype: int64 Upsample the series into 30 second bins and fill the ``NaN`` values using the ``bfill`` method. >>> series.resample("30s").bfill()[0:5] 2000-01-01 00:00:00 0 2000-01-01 00:00:30 1 2000-01-01 00:01:00 1 2000-01-01 00:01:30 2 2000-01-01 00:02:00 2 Freq: 30s, dtype: int64 Pass a custom function via ``apply`` >>> def custom_resampler(arraylike): ... return np.sum(arraylike) + 5 >>> series.resample("3min").apply(custom_resampler) 2000-01-01 00:00:00 8 2000-01-01 00:03:00 17 2000-01-01 00:06:00 26 Freq: 3min, dtype: int64 For a Series with a PeriodIndex, the keyword `convention` can be used to control whether to use the start or end of `rule`. Resample a year by quarter using 'start' `convention`. Values are assigned to the first quarter of the period. >>> s = pd.Series( ... [1, 2], index=pd.period_range("2012-01-01", freq="Y", periods=2) ... ) >>> s 2012 1 2013 2 Freq: Y-DEC, dtype: int64 >>> s.resample("Q", convention="start").asfreq() 2012Q1 1.0 2012Q2 NaN 2012Q3 NaN 2012Q4 NaN 2013Q1 2.0 2013Q2 NaN 2013Q3 NaN 2013Q4 NaN Freq: Q-DEC, dtype: float64 Resample quarters by month using 'end' `convention`. Values are assigned to the last month of the period. >>> q = pd.Series( ... [1, 2, 3, 4], index=pd.period_range("2018-01-01", freq="Q", periods=4) ... ) >>> q 2018Q1 1 2018Q2 2 2018Q3 3 2018Q4 4 Freq: Q-DEC, dtype: int64 >>> q.resample("M", convention="end").asfreq() 2018-03 1.0 2018-04 NaN 2018-05 NaN 2018-06 2.0 2018-07 NaN 2018-08 NaN 2018-09 3.0 2018-10 NaN 2018-11 NaN 2018-12 4.0 Freq: M, dtype: float64 For DataFrame objects, the keyword `on` can be used to specify the column instead of the index for resampling. >>> df = pd.DataFrame([10, 11, 9, 13, 14, 18, 17, 19], columns=["price"]) >>> df["volume"] = [50, 60, 40, 100, 50, 100, 40, 50] >>> df["week_starting"] = pd.date_range("01/01/2018", periods=8, freq="W") >>> df price volume week_starting 0 10 50 2018-01-07 1 11 60 2018-01-14 2 9 40 2018-01-21 3 13 100 2018-01-28 4 14 50 2018-02-04 5 18 100 2018-02-11 6 17 40 2018-02-18 7 19 50 2018-02-25 >>> df.resample("ME", on="week_starting").mean() price volume week_starting 2018-01-31 10.75 62.5 2018-02-28 17.00 60.0 For a DataFrame with MultiIndex, the keyword `level` can be used to specify on which level the resampling needs to take place. >>> days = pd.date_range("1/1/2000", periods=4, freq="D") >>> df2 = pd.DataFrame( ... [ ... [10, 50], ... [11, 60], ... [9, 40], ... [13, 100], ... [14, 50], ... [18, 100], ... [17, 40], ... [19, 50], ... ], ... columns=["price", "volume"], ... index=pd.MultiIndex.from_product([days, ["morning", "afternoon"]]), ... ) >>> df2 price volume 2000-01-01 morning 10 50 afternoon 11 60 2000-01-02 morning 9 40 afternoon 13 100 2000-01-03 morning 14 50 afternoon 18 100 2000-01-04 morning 17 40 afternoon 19 50 >>> df2.resample("D", level=0).sum() price volume 2000-01-01 21 110 2000-01-02 22 140 2000-01-03 32 150 2000-01-04 36 90 If you want to adjust the start of the bins based on a fixed timestamp: >>> start, end = "2000-10-01 23:30:00", "2000-10-02 00:30:00" >>> rng = pd.date_range(start, end, freq="7min") >>> ts = pd.Series(np.arange(len(rng)) * 3, index=rng) >>> ts 2000-10-01 23:30:00 0 2000-10-01 23:37:00 3 2000-10-01 23:44:00 6 2000-10-01 23:51:00 9 2000-10-01 23:58:00 12 2000-10-02 00:05:00 15 2000-10-02 00:12:00 18 2000-10-02 00:19:00 21 2000-10-02 00:26:00 24 Freq: 7min, dtype: int64 >>> ts.resample("17min").sum() 2000-10-01 23:14:00 0 2000-10-01 23:31:00 9 2000-10-01 23:48:00 21 2000-10-02 00:05:00 54 2000-10-02 00:22:00 24 Freq: 17min, dtype: int64 >>> ts.resample("17min", origin="epoch").sum() 2000-10-01 23:18:00 0 2000-10-01 23:35:00 18 2000-10-01 23:52:00 27 2000-10-02 00:09:00 39 2000-10-02 00:26:00 24 Freq: 17min, dtype: int64 >>> ts.resample("17min", origin="2000-01-01").sum() 2000-10-01 23:24:00 3 2000-10-01 23:41:00 15 2000-10-01 23:58:00 45 2000-10-02 00:15:00 45 Freq: 17min, dtype: int64 If you want to adjust the start of the bins with an `offset` Timedelta, the two following lines are equivalent: >>> ts.resample("17min", origin="start").sum() 2000-10-01 23:30:00 9 2000-10-01 23:47:00 21 2000-10-02 00:04:00 54 2000-10-02 00:21:00 24 Freq: 17min, dtype: int64 >>> ts.resample("17min", offset="23h30min").sum() 2000-10-01 23:30:00 9 2000-10-01 23:47:00 21 2000-10-02 00:04:00 54 2000-10-02 00:21:00 24 Freq: 17min, dtype: int64 If you want to take the largest Timestamp as the end of the bins: >>> ts.resample("17min", origin="end").sum() 2000-10-01 23:35:00 0 2000-10-01 23:52:00 18 2000-10-02 00:09:00 27 2000-10-02 00:26:00 63 Freq: 17min, dtype: int64 In contrast with the `start_day`, you can use `end_day` to take the ceiling midnight of the largest Timestamp as the end of the bins and drop the bins not containing data: >>> ts.resample("17min", origin="end_day").sum() 2000-10-01 23:38:00 3 2000-10-01 23:55:00 15 2000-10-02 00:12:00 45 2000-10-02 00:29:00 45 Freq: 17min, dtype: int64 r) get_resamplerzSeries | DataFrame) rrclosed conventionrr originoffset group_keys)rrr) rrulerrronr rrrrs rresampleNDFrame.resample_#s;\ 7 %t ,!!  rc^^^^^^ TRU5m TS;a Sn[U5eUU UUUU4SjnU(aFTRS:Xa%[TR5(d [ S5eTR 5n OTn U"U 5$)a2 Compute numerical data ranks (1 through n) along axis. By default, equal values are assigned a rank that is the average of the ranks of those values. Parameters ---------- axis : {0 or 'index', 1 or 'columns'}, default 0 Index to direct ranking. For `Series` this parameter is unused and defaults to 0. method : {'average', 'min', 'max', 'first', 'dense'}, default 'average' How to rank the group of records that have the same value (i.e. ties): * average: average rank of the group * min: lowest rank in the group * max: highest rank in the group * first: ranks assigned in order they appear in the array * dense: like 'min', but rank always increases by 1 between groups. numeric_only : bool, default False For DataFrame objects, rank only numeric columns if set to True. .. versionchanged:: 2.0.0 The default value of ``numeric_only`` is now ``False``. na_option : {'keep', 'top', 'bottom'}, default 'keep' How to rank NaN values: * keep: assign NaN rank to NaN values * top: assign lowest rank to NaN values * bottom: assign highest rank to NaN values ascending : bool, default True Whether or not the elements should be ranked in ascending order. pct : bool, default False Whether or not to display the returned rankings in percentile form. Returns ------- same type as caller Return a Series or DataFrame with data ranks as values. See Also -------- core.groupby.DataFrameGroupBy.rank : Rank of values within each group. core.groupby.SeriesGroupBy.rank : Rank of values within each group. Examples -------- >>> df = pd.DataFrame( ... data={ ... "Animal": ["cat", "penguin", "dog", "spider", "snake"], ... "Number_legs": [4, 2, 4, 8, np.nan], ... } ... ) >>> df Animal Number_legs 0 cat 4.0 1 penguin 2.0 2 dog 4.0 3 spider 8.0 4 snake NaN Ties are assigned the mean of the ranks (by default) for the group. >>> s = pd.Series(range(5), index=list("abcde")) >>> s["d"] = s["b"] >>> s.rank() a 1.0 b 2.5 c 4.0 d 2.5 e 5.0 dtype: float64 The following example shows how the method behaves with the above parameters: * default_rank: this is the default behaviour obtained without using any parameter. * max_rank: setting ``method = 'max'`` the records that have the same values are ranked using the highest rank (e.g.: since 'cat' and 'dog' are both in the 2nd and 3rd position, rank 3 is assigned.) * NA_bottom: choosing ``na_option = 'bottom'``, if there are records with NaN values they are placed at the bottom of the ranking. * pct_rank: when setting ``pct = True``, the ranking is expressed as percentile rank. >>> df["default_rank"] = df["Number_legs"].rank() >>> df["max_rank"] = df["Number_legs"].rank(method="max") >>> df["NA_bottom"] = df["Number_legs"].rank(na_option="bottom") >>> df["pct_rank"] = df["Number_legs"].rank(pct=True) >>> df Animal Number_legs default_rank max_rank NA_bottom pct_rank 0 cat 4.0 2.5 3.0 2.5 0.625 1 penguin 2.0 1.0 1.0 1.0 0.250 2 dog 4.0 2.5 3.0 2.5 0.625 3 spider 8.0 4.0 4.0 4.0 1.000 4 snake NaN NaN NaN 5.0 NaN >topkeepbottomz3na_option must be one of 'keep', 'top', or 'bottom'c <>URS:Xa URnO URn[U[5(aUR TTTTTS9nO[ R"UTTTTTS9nT R"U40UR5D6nURT SS9$)Nr)rrqr na_optionpctrankrp) rrrrrt_rankrhrrrr6) rrranks ranks_objrrrqrrrs rrankerNDFrame.rank..rankerR%syyA~&.11 !!'' % !!'' ))%O43L3L3NOI))$v)> >rrzDSeries.rank does not allow numeric_only=True with non-numeric dtype.)rrrr_rrr() rrrq numeric_onlyrrrr rrrs ` ` ``` @rr NDFrame.rank$s`((. 5 5GCS/ ! ? ?: yyA~&6tzz&B&B)))+DDd|rrc P[U5[U5La>[U5R[U5Rpv[SUSUSUS35eX:HUR5UR5--)nUR SSS9 U(d"UR U5nUR U5nU(d][ U[5(a@UR5n URSS9n URX4nURX4nOXnXn[ U[5(d[S [U5S 35eUS ;aSn OURU5n [X/U US 9n XR:aU $U RU 5n [R "U R"5n[R$"['U55U l/[)SU R*5QS Pn[ U [5(aU R-XS9n OU R-U5n XU RU S9l[R$"U R.U 5R1SU R.U S-/5R2R1S5nU R5UU S9n U $)af Compare to another Series/DataFrame and show the differences. Parameters ---------- other : Series/DataFrame Object to compare with. align_axis : {0 or 'index', 1 or 'columns'}, default 1 Determine which axis to align the comparison on. * 0, or 'index' : Resulting differences are stacked vertically with rows drawn alternately from self and other. * 1, or 'columns' : Resulting differences are aligned horizontally with columns drawn alternately from self and other. keep_shape : bool, default False If true, all rows and columns are kept. Otherwise, only the ones with different values are kept. keep_equal : bool, default False If true, the result keeps values that are equal. Otherwise, equal values are shown as NaNs. result_names : tuple, default ('self', 'other') Set the dataframes names in the comparison. zcan only compare 'z' (not 'z ') with 'rTrPrrzPassing 'result_names' as a z= is not supported. Provide 'result_names' as a tuple instead.)rr)rrrrr)rrrrjr_rkrrfrrMrCrrrrrKr=rarangerrrnlevelsreorder_levelsrDreshaper:r<)rr align_axis keep_shape keep_equal result_namescls_self cls_otherrcmaskrmaskrdiffrax_namesorderr@s rcompareNDFrame.compare|%suF :T%[ ("&t*"5"5tE{7K7Ki$XJhyk8*TUV  -DIIK%**,$>?@ D$ '::d#DKK%E$ -- a(xx - %,/z ,...tL/A.BCHH   'D((4D M  99 K ^^D !88BHH%99S]++%2::&** dL ) )&&u&8D&&u-D+3/D!' IIdjj& ' WaD)Q./ 0 Qwwr{  yyty, routercURU5 UbURU5n[U[5(aUR UUUUUS9upxn OC[U[ 5(aUR UUUUUS9upxn O[S[U535e[[U5n URS:XdUS:Xa[URR[5(a[URRU RR:wa-U b*UR!SS9nU R!SS9n Xl Xl UR#U5nU R#U5n Xz4$)a Align two objects on their axes with the specified join method. Join method is specified for each axis Index. Parameters ---------- other : DataFrame or Series The object to align with. join : {{'outer', 'inner', 'left', 'right'}}, default 'outer' Type of alignment to be performed. * left: use only keys from left frame, preserve key order. * right: use only keys from right frame, preserve key order. * outer: use union of keys from both frames, sort keys lexicographically. * inner: use intersection of keys from both frames, preserve the order of the left keys. axis : allowed axis of the other object, default None Align on index (0), columns (1), or both (None). level : int or level name, default None Broadcast across a level, matching Index values on the passed MultiIndex level. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. fill_value : scalar, default np.nan Value to use for missing values. Defaults to NaN, but can be any "compatible" value. Returns ------- tuple of (Series/DataFrame, type of other) Aligned objects. See Also -------- Series.align : Align two objects on their axes with specified join method. DataFrame.align : Align two objects on their axes with specified join method. Examples -------- >>> df = pd.DataFrame( ... [[1, 2, 3, 4], [6, 7, 8, 9]], columns=["D", "B", "E", "A"], index=[1, 2] ... ) >>> other = pd.DataFrame( ... [[10, 20, 30, 40], [60, 70, 80, 90], [600, 700, 800, 900]], ... columns=["A", "B", "C", "D"], ... index=[2, 3, 4], ... ) >>> df D B E A 1 1 2 3 4 2 6 7 8 9 >>> other A B C D 2 10 20 30 40 3 60 70 80 90 4 600 700 800 900 Align on columns: >>> left, right = df.align(other, join="outer", axis=1) >>> left A B C D E 1 4 2 NaN 1 3 2 9 7 NaN 6 8 >>> right A B C D E 2 10 20 30 40 NaN 3 60 70 80 90 NaN 4 600 700 800 900 NaN We can also align on the index: >>> left, right = df.align(other, join="outer", axis=0) >>> left D B E A 1 1.0 2.0 3.0 4.0 2 6.0 7.0 8.0 9.0 3 NaN NaN NaN NaN 4 NaN NaN NaN NaN >>> right A B C D 1 NaN NaN NaN NaN 2 10.0 20.0 30.0 40.0 3 60.0 70.0 80.0 90.0 4 600.0 700.0 800.0 900.0 Finally, the default `axis=None` will align on both index and columns: >>> left, right = df.align(other, join="outer", axis=None) >>> left A B C D E 1 4.0 2.0 NaN 1.0 3.0 2 9.0 7.0 NaN 6.0 8.0 3 NaN NaN NaN NaN NaN 4 NaN NaN NaN NaN NaN >>> right A B C D E 1 NaN NaN NaN NaN NaN 2 10.0 20.0 30.0 40.0 NaN 3 60.0 70.0 80.0 90.0 NaN 4 600.0 700.0 800.0 900.0 NaN r[rr rzunsupported type: rrFr)rrrrf _align_framerg _align_seriesrrrr0rrrrctzrr6) rrr[rr rrleft_right join_indexrs ralign NDFrame.align%sZz $$T*  ((.D e\ * *'+'8'8% (9( $D*y ) )'+'9'9% (:( $D*0e >? ?Xv& 99>TQY$****O<<::==EKKNN2!- $yyey4 %  6%/ &0   &""5){rc0SupgSupSup[U[5n UbUS:XaRURRUR5(d(URR URX$SS9uphn UbUS:XaYU (dRUR RUR 5(d(UR R UR X$SS9upzn U (aSXh/0n OXh/Xz/S.n UR XSS9nUR Xi/X{/S.USS9nXU4$)NNNrTrr return_indexersr)rrr)rrgrrr[rr)rrr[rr rr join_columnsilidxiridxclidxcridxrrr rs rr NDFrame._align_frame&s6$. ! ! tY/ LDAItzz/@/@/M/M'+zz D(7( $Ju \TQYLL'' 66)-):): 4d*;* &L j01J(0l5JKJ** $+ ,,#(= >!-  J&&rc[U[5nU(dUbUS;a [S5eU(aUS:Xa [S5eU(dURR UR5(aSupxn O(URR URX$SS9upxn U(aUR Xx5n OIUbUcURSS 9n O3URRXxSS 9n URXRS 9n UR Xy5n OURn URSnS upUR UR5(dUR URX$SS9upxn Ub!URS5nU RXxUS 9n URXRS 9n UR Xy5n [U5nU(a"U RU5n U RU5n XU4$) N)NrrzMust specify axis=0 or 1rz1cannot align series to a series other than axis 0NNNTrFrrrr)rrgrrrr[_reindex_indexerrrrrrrrkr_)rrr[rr rrrlidxridxr rQrfdatarfill_nas rr NDFrame._align_series&stY/ dlt!3yyey,))33J13M11' 1M**:H?n[5UR:5(aM[7UR9UR:S95e UR<R@(a3UR&"URC[*US940UR)5D6nOURE[*5nU(aU*OUnURGURHURJS9n[ U[ 5(GaMUR UR ::Ga'URUSUUSS9SnUcURMU5(d[NeUR UR :GaURPn[ U[RR5(a]US :Xa[RT"US5nOUS:Xa[RT"US5n[RV"X R"5nGOUS :Xa[[UR"S5V s/sH7n URXSS2U 4R[URXSS2U 4U5PM9 n n O}US:Xaw[UR"S5V s/sHTn URXSS2U 4R[URXSS2U 4X)U S-R][U555PMV n n UR'[[_W 555n UR`U l0URU l U(aURcU 5 U$U ReU5$O0[gS5e[ U[h[ 45(d [kUSS9n[ U[RR[l45(a[UR"UR":waUR S:wa [%S5eO%UR&"U40UR)5DS S0D6nUcS nUR [oUSS 5:XaSn OURU5S:Hn U(aFUR<RqXU S9n URsXRtS9nURcU5 U$UR<RwUUU S9n URsXRtS9nUReU5$s sn fs sn f)z~ Equivalent to public method `where`, except that `other` is not applied as a function even if callable. Used in __setitem__. rNrrFrpr)r[rrDz,Array conditional must be same shape as selfrz5Boolean array expected for the condition, not {dtype}r)rna_valuerr r )rr)rrz.cannot align with a higher dimensional NDFrameT) extract_numpyz4other must be the same shape as self when an ndarrayr)rnewrr)rrr)E!QY$&JJug$>E "zz B 19 */tzz!})= ( *>A !% !Q$ 6 6$(IIadO$)!"*> %(H"QY*/tzz!})= ( *>A !% !Q$ 6 6$(IIadO$)a!e$4$;$;CI$F!"*> %(#//Yx5H0IJ$(JJ &*ll " 005#'K"//55G*N*DEJ#899!%t %N "))!668?D <D 99vq1 1E))$/14E yy((dU(KH//}}/MF   (Kyy'H //}}/MF&&t, ,W((s >ZAZ c:[US5nU(ab[(dW[R"U5[::a9[ R "U5(d[R"[[SS9 [ R"X 5nURXX4US9$)a Replace values where the condition is False. This method allows conditional replacement of values. Where the condition evaluates to True, the original values are retained; where it evaluates to False, values are replaced with corresponding entries from ``other``. Parameters ---------- cond : bool Series/DataFrame, array-like, or callable Where `cond` is True, keep the original value. Where False, replace with corresponding value from `other`. If `cond` is callable, it is computed on the Series/DataFrame and should return boolean Series/DataFrame or array. The callable must not change input Series/DataFrame (though pandas doesn't check it). other : scalar, Series/DataFrame, or callable Entries where `cond` is False are replaced with corresponding value from `other`. If other is callable, it is computed on the Series/DataFrame and should return scalar or Series/DataFrame. The callable must not change input Series/DataFrame (though pandas doesn't check it). If not specified, entries will be filled with the corresponding NULL value (``np.nan`` for numpy dtypes, ``pd.NA`` for extension dtypes). inplace : bool, default False Whether to perform the operation in place on the data. axis : int, default None Alignment axis if needed. For `Series` this parameter is unused and defaults to 0. level : int, default None Alignment level if needed. Returns ------- Series or DataFrame When applied to a Series, the function will return a Series, and when applied to a DataFrame, it will return a DataFrame. See Also -------- :func:`DataFrame.mask` : Return an object of same shape as caller. :func:`Series.mask` : Return an object of same shape as caller. Notes ----- The where method is an application of the if-then idiom. For each element in the caller, if ``cond`` is ``True`` the element is used; otherwise the corresponding element from ``other`` is used. If the axis of ``other`` does not align with axis of ``cond`` Series/DataFrame, the values of ``cond`` on misaligned index positions will be filled with False. The signature for :func:`Series.where` or :func:`DataFrame.where` differs from :func:`numpy.where`. Roughly ``df1.where(m, df2)`` is equivalent to ``np.where(m, df1, df2)``. For further details and examples see the ``where`` documentation in :ref:`indexing `. The dtype of the object takes precedence. The fill value is casted to the object's dtype, if this can be done losslessly. Examples -------- >>> s = pd.Series(range(5)) >>> s.where(s > 0) 0 NaN 1 1.0 2 2.0 3 3.0 4 4.0 dtype: float64 >>> s.mask(s > 0) 0 0.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64 >>> s = pd.Series(range(5)) >>> t = pd.Series([True, False]) >>> s.where(t, 99) 0 0 1 99 2 99 3 99 4 99 dtype: int64 >>> s.mask(t, 99) 0 99 1 1 2 99 3 99 4 99 dtype: int64 >>> s.where(s > 1, 10) 0 10 1 10 2 2 3 3 4 4 dtype: int64 >>> s.mask(s > 1, 10) 0 0 1 1 2 10 3 10 4 10 dtype: int64 >>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=["A", "B"]) >>> df A B 0 0 1 1 2 3 2 4 5 3 6 7 4 8 9 >>> m = df % 3 == 0 >>> df.where(m, -df) A B 0 0 -1 1 -2 3 2 -4 -5 3 6 -7 4 -8 9 >>> df.where(m, -df) == np.where(m, df, -df) A B 0 True True 1 True True 2 True True 3 True True 4 True True >>> df.where(m, -df) == df.mask(~m, -df) A B 0 True True 1 True True 2 True True 3 True True 4 True True rrrr$) rRrDrerfrErnrgrrrLrIr)r.rrrrrr s rrk NDFrame.where's~t&gy9 ++??%&.4.M.Md.S.SMM6.#$ ((5{{4%{PPrc[US5nU(ab[(dW[R"U5[::a9[ R "U5(d[R"[[SS9 [ R"X5n[ R"X 5n[US5(d[R"U5nURU)UUUUS9$)a Replace values where the condition is True. Parameters ---------- cond : bool Series/DataFrame, array-like, or callable Where `cond` is False, keep the original value. Where True, replace with corresponding value from `other`. If `cond` is callable, it is computed on the Series/DataFrame and should return boolean Series/DataFrame or array. The callable must not change input Series/DataFrame (though pandas doesn't check it). other : scalar, Series/DataFrame, or callable Entries where `cond` is True are replaced with corresponding value from `other`. If other is callable, it is computed on the Series/DataFrame and should return scalar or Series/DataFrame. The callable must not change input Series/DataFrame (though pandas doesn't check it). If not specified, entries will be filled with the corresponding NULL value (``np.nan`` for numpy dtypes, ``pd.NA`` for extension dtypes). inplace : bool, default False Whether to perform the operation in place on the data. axis : int, default None Alignment axis if needed. For `Series` this parameter is unused and defaults to 0. level : int, default None Alignment level if needed. Returns ------- Series or DataFrame When applied to a Series, the function will return a Series, and when applied to a DataFrame, it will return a DataFrame. See Also -------- :func:`DataFrame.where` : Return an object of same shape as caller. :func:`Series.where` : Return an object of same shape as caller. Notes ----- The mask method is an application of the if-then idiom. For each element in the caller, if ``cond`` is ``False`` the element is used; otherwise the corresponding element from ``other`` is used. If the axis of ``other`` does not align with axis of ``cond`` Series/DataFrame, the values of ``cond`` on misaligned index positions will be filled with True. The signature for :func:`Series.where` or :func:`DataFrame.where` differs from :func:`numpy.where`. Roughly ``df1.where(m, df2)`` is equivalent to ``np.where(m, df1, df2)``. For further details and examples see the ``mask`` documentation in :ref:`indexing `. The dtype of the object takes precedence. The fill value is casted to the object's dtype, if this can be done losslessly. Examples -------- >>> s = pd.Series(range(5)) >>> s.where(s > 0) 0 NaN 1 1.0 2 2.0 3 3.0 4 4.0 dtype: float64 >>> s.mask(s > 0) 0 0.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64 >>> s = pd.Series(range(5)) >>> t = pd.Series([True, False]) >>> s.where(t, 99) 0 0 1 99 2 99 3 99 4 99 dtype: int64 >>> s.mask(t, 99) 0 99 1 1 2 99 3 99 4 99 dtype: int64 >>> s.where(s > 1, 10) 0 10 1 10 2 2 3 3 4 4 dtype: int64 >>> s.mask(s > 1, 10) 0 0 1 1 2 10 3 10 4 10 dtype: int64 >>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=["A", "B"]) >>> df A B 0 0 1 1 2 3 2 4 5 3 6 7 4 8 9 >>> m = df % 3 == 0 >>> df.where(m, -df) A B 0 0 -1 1 -2 3 2 -4 -5 3 6 -7 4 -8 9 >>> df.where(m, -df) == np.where(m, df, -df) A B 0 True True 1 True True 2 True True 3 True True 4 True True >>> df.where(m, -df) == df.mask(~m, -df) A B 0 True True 1 True True 2 True True 3 True True 4 True True rrrr)rrrr )rRrDrerfrErnrgrrrLrIr)rrKr=r.r4s rr NDFrame.maskS(sj&gy9 ++??%&.4.M.Md.S.SMM6.#$ ''3((5t\**88D>D{{ E   rcURU5nUbU[RLa [S5eUS:XaUR SS9$[ U5(a3[ U[5(aUR5RXX4S9$[[U5nUcYURU5nUS:XdeURRXS9nURXfRS9RUSS 9$UR!XU5$) a Shift index by desired number of periods with an optional time `freq`. When `freq` is not passed, shift the index without realigning the data. If `freq` is passed (in this case, the index must be date or datetime, or it will raise a `NotImplementedError`), the index will be increased using the periods and the `freq`. `freq` can be inferred when specified as "infer" as long as either freq or inferred_freq attribute is set in the index. Parameters ---------- periods : int or Sequence Number of periods to shift. Can be positive or negative. If an iterable of ints, the data will be shifted once by each int. This is equivalent to shifting by one value at a time and concatenating all resulting frames. The resulting columns will have the shift suffixed to their column names. For multiple periods, axis must not be 1. freq : DateOffset, tseries.offsets, timedelta, or str, optional Offset to use from the tseries module or time rule (e.g. 'EOM'). If `freq` is specified then the index values are shifted but the data is not realigned. That is, use `freq` if you would like to extend the index when shifting and preserve the original data. If `freq` is specified as "infer" then it will be inferred from the freq or inferred_freq attributes of the index. If neither of those attributes exist, a ValueError is thrown. axis : {{0 or 'index', 1 or 'columns', None}}, default None Shift direction. For `Series` this parameter is unused and defaults to 0. fill_value : object, optional The scalar value to use for newly introduced missing values. the default depends on the dtype of `self`. For Boolean and numeric NumPy data types, ``np.nan`` is used. For datetime, timedelta, or period data, etc. :attr:`NaT` is used. For extension dtypes, ``self.dtype.na_value`` is used. suffix : str, optional If str and periods is an iterable, this is added after the column name and before the shift value for each shifted column name. For `Series` this parameter is unused and defaults to `None`. Returns ------- Series/DataFrame Copy of input object, shifted. See Also -------- Index.shift : Shift values of Index. DatetimeIndex.shift : Shift values of DatetimeIndex. PeriodIndex.shift : Shift values of PeriodIndex. Examples -------- >>> df = pd.DataFrame( ... [[10, 13, 17], [20, 23, 27], [15, 18, 22], [30, 33, 37], [45, 48, 52]], ... columns=["Col1", "Col2", "Col3"], ... index=pd.date_range("2020-01-01", "2020-01-05"), ... ) >>> df Col1 Col2 Col3 2020-01-01 10 13 17 2020-01-02 20 23 27 2020-01-03 15 18 22 2020-01-04 30 33 37 2020-01-05 45 48 52 >>> df.shift(periods=3) Col1 Col2 Col3 2020-01-01 NaN NaN NaN 2020-01-02 NaN NaN NaN 2020-01-03 NaN NaN NaN 2020-01-04 10.0 13.0 17.0 2020-01-05 20.0 23.0 27.0 >>> df.shift(periods=1, axis="columns") Col1 Col2 Col3 2020-01-01 NaN 10 13 2020-01-02 NaN 20 23 2020-01-03 NaN 15 18 2020-01-04 NaN 30 33 2020-01-05 NaN 45 48 >>> df.shift(periods=3, fill_value=0) Col1 Col2 Col3 2020-01-01 0 0 0 2020-01-02 0 0 0 2020-01-03 0 0 0 2020-01-04 10 13 17 2020-01-05 20 23 27 >>> df.shift(periods=3, freq="D") Col1 Col2 Col3 2020-01-04 10 13 17 2020-01-05 20 23 27 2020-01-06 15 18 22 2020-01-07 30 33 37 2020-01-08 45 48 52 >>> df.shift(periods=3, freq="infer") Col1 Col2 Col3 2020-01-04 10 13 17 2020-01-05 20 23 27 2020-01-06 15 18 22 2020-01-07 30 33 37 2020-01-08 45 48 52 >>> df["Col1"].shift(periods=[0, 1, 2]) Col1_0 Col1_1 Col1_2 2020-01-01 10 NaN NaN 2020-01-02 20 10.0 NaN 2020-01-03 15 20.0 10.0 2020-01-04 30 15.0 20.0 2020-01-05 45 30.0 15.0 z=Passing a 'freq' together with a 'fill_value' is not allowed.rFr)periodsrrr)r9rrshiftrp)rrrrrr]rrgrr:rrrrrr6_shift_with_freq)rr9rrrrrs rr: NDFrame.shift)st$$T*   #.. @O  a<99%9( (  Zi%@%@==?(() sG$ <((.D19 9yywNH--}}.l4l0 1$$WD99rcBURU5nUS:Xa.[USS5nUc [USS5nUc Sn[U5eO.[U[5(a[U[ 5n[ X6S9n[U[ 5(ah[ UR5nX7:wa<Uce[S[U5RS[U5R35eURU5nOURX5nURXS9n U RUS S 9$) Nrr inferred_freqz6Freq was not set in the index hence cannot be inferred) is_periodz Given freq z! does not match PeriodIndex freq rr:rp) rrrrrr{rrre_freqstrr:rSr6) rr9rrrr r? orig_freqrNrhs rr;NDFrame._shift_with_freq)s$t$ 7?5&$/D|uot<|N o%c " ""5+6IT7D e[ ) )!%**-I  ,,, !+d"3"<"7"9-6679 "KK0F[[/Fv1""4"88rcURU5 UcSnURU5nURU5nUR(dUR(d [ S5eUR (aSSKJn UbU"U5nUbU"U5nUbUbX:a[ SUSU35e[U5S:a'UR(aUR5S:aX!p![SS5/UR-n[X5Xs'UR[U5n[U[ 5(a*[#XR%U5UR'X55 UR)SS 9nU$) a Truncate a Series or DataFrame before and after some index value. This is a useful shorthand for boolean indexing based on index values above or below certain thresholds. Parameters ---------- before : date, str, int Truncate all rows before this index value. after : date, str, int Truncate all rows after this index value. axis : {0 or 'index', 1 or 'columns'}, optional Axis to truncate. Truncates the index (rows) by default. For `Series` this parameter is unused and defaults to 0. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. Returns ------- type of caller The truncated Series or DataFrame. See Also -------- DataFrame.loc : Select a subset of a DataFrame by label. DataFrame.iloc : Select a subset of a DataFrame by position. Notes ----- If the index being truncated contains only datetime values, `before` and `after` may be specified as strings instead of Timestamps. Examples -------- >>> df = pd.DataFrame( ... { ... "A": ["a", "b", "c", "d", "e"], ... "B": ["f", "g", "h", "i", "j"], ... "C": ["k", "l", "m", "n", "o"], ... }, ... index=[1, 2, 3, 4, 5], ... ) >>> df A B C 1 a f k 2 b g l 3 c h m 4 d i n 5 e j o >>> df.truncate(before=2, after=4) A B C 2 b g l 3 c h m 4 d i n The columns of a DataFrame can be truncated. >>> df.truncate(before="A", after="B", axis="columns") A B 1 a f 2 b g 3 c h 4 d i 5 e j For Series, only rows can be truncated. >>> df["A"].truncate(before=2, after=4) 2 b 3 c 4 d Name: A, dtype: str The index values in ``truncate`` can be datetimes or string dates. >>> dates = pd.date_range("2016-01-01", "2016-02-01", freq="s") >>> df = pd.DataFrame(index=dates, data={"A": 1}) >>> df.tail() A 2016-01-31 23:59:56 1 2016-01-31 23:59:57 1 2016-01-31 23:59:58 1 2016-01-31 23:59:59 1 2016-02-01 00:00:00 1 >>> df.truncate( ... before=pd.Timestamp("2016-01-05"), after=pd.Timestamp("2016-01-10") ... ).tail() A 2016-01-09 23:59:56 1 2016-01-09 23:59:57 1 2016-01-09 23:59:58 1 2016-01-09 23:59:59 1 2016-01-10 00:00:00 1 Because the index is a DatetimeIndex containing only dates, we can specify `before` and `after` as strings. They will be coerced to Timestamps before truncation. >>> df.truncate("2016-01-05", "2016-01-10").tail() A 2016-01-09 23:59:56 1 2016-01-09 23:59:57 1 2016-01-09 23:59:58 1 2016-01-09 23:59:59 1 2016-01-10 00:00:00 1 Note that ``truncate`` assumes a 0 value for any unspecified time component (midnight). This differs from partial string slicing, which returns any partially matching dates. >>> df.loc["2016-01-05":"2016-01-10", :].tail() A 2016-01-10 23:59:55 1 2016-01-10 23:59:56 1 2016-01-10 23:59:57 1 2016-01-10 23:59:58 1 2016-01-10 23:59:59 1 Nrz truncate requires a sorted index) to_datetimez Truncate: z must be after rFr)rrrris_monotonic_decreasingr _is_all_datespandas.core.tools.datetimesrDrr!rmrrMrCrrzr^r truncater) rbeforeafterrrrrDslicerrhs rrHNDFrame.truncate)sJZ $$T* <D$$T* ^^D !))"2L2L?@ @    ?!$V, #E*  %"3z%xHI I r7Q;255"**,:J!Ed#$t~~5V+ %-( b* % % F//5r{{67Q R%( rc^^TRU5 TRT5mTRT5nUU4Sjn[U[5(a7UR U5nU"UR UU5nURXsS9nO*USSUR4;a[SUS35eU"XQ5nTRSS9nURUTS 9nURTS S 9$) ab Convert tz-aware axis to target time zone. Parameters ---------- tz : str or tzinfo object or None Target time zone. Passing ``None`` will convert to UTC and remove the timezone information. axis : {{0 or 'index', 1 or 'columns'}}, default 0 The axis to convert level : int, str, default None If axis is a MultiIndex, convert a specific level. Otherwise must be None. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. Returns ------- Series/DataFrame Object with time zone converted axis. Raises ------ TypeError If the axis is tz-naive. See Also -------- DataFrame.tz_localize: Localize tz-naive index of DataFrame to target time zone. Series.tz_localize: Localize tz-naive index of Series to target time zone. Examples -------- Change to another time zone: >>> s = pd.Series( ... [1], ... index=pd.DatetimeIndex(["2018-09-15 01:30:00+02:00"]), ... ) >>> s.tz_convert("Asia/Shanghai") 2018-09-15 07:30:00+08:00 1 dtype: int64 Pass None to convert to UTC and get a tz-naive index: >>> s = pd.Series([1], index=pd.DatetimeIndex(["2018-09-15 01:30:00+02:00"])) >>> s.tz_convert(None) 2018-09-14 23:30:00 1 dtype: int64 c>[US5(d:[U5S:aTRT5n[US35e[ /US9nU$UR U5nU$)N tz_convertr, is not a valid DatetimeIndex or PeriodIndexr )rrr rrxrO)rr ax_namerrs r _tz_convert'NDFrame.tz_convert.._tz_convert*sm2|,,r7Q;"11$7G#")#OP#2"-I]]2&IrrNr The level is not validFrrrOrp) rrrrrzrlevels set_levelsrrrrSr6) rr rr rrrS new_levelrhs ` ` rrONDFrame.tz_converts*sH $$T*$$T* ^^D !  b* % %((/E#BIIe$4b9Iy6BT1bgg.. :eWM!BCCR$B&$/""4 "==rc*^^TRU5 SnXg;a*[U[R5(d [ S5eTR T5mTR T5nUU4Sjn [U[5(a8URU5nU "URUXU5n URXS9nO+USSUR4;a[ SUS35eU "XXV5nTRS S 9n U RUTS 9n U RTS S 9$)a| Localize time zone naive index of a Series or DataFrame to target time zone. This operation localizes the Index. To localize the values in a time zone naive Series, use :meth:`Series.dt.tz_localize`. Parameters ---------- tz : str or tzinfo or None Time zone to localize. Passing ``None`` will remove the time zone information and preserve local time. axis : {{0 or 'index', 1 or 'columns'}}, default 0 The axis to localize level : int, str, default None If axis ia a MultiIndex, localize a specific level. Otherwise must be None. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. ambiguous : 'infer', bool, bool-ndarray, 'NaT', default 'raise' When clocks moved backward due to DST, ambiguous times may arise. For example in Central European Time (UTC+01), when going from 03:00 DST to 02:00 non-DST, 02:30:00 local time occurs both at 00:30:00 UTC and at 01:30:00 UTC. In such a situation, the `ambiguous` parameter dictates how ambiguous times should be handled. - 'infer' will attempt to infer fall dst-transition hours based on order - bool (or bool-ndarray) where True signifies a DST time, False designates a non-DST time (note that this flag is only applicable for ambiguous times) - 'NaT' will return NaT where there are ambiguous times - 'raise' will raise a ValueError if there are ambiguous times. nonexistent : str, default 'raise' A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST. Valid values are: - 'shift_forward' will shift the nonexistent time forward to the closest existing time - 'shift_backward' will shift the nonexistent time backward to the closest existing time - 'NaT' will return NaT where there are nonexistent times - timedelta objects will shift nonexistent times by the timedelta - 'raise' will raise a ValueError if there are nonexistent times. Returns ------- Series/DataFrame Same type as the input, with time zone naive or aware index, depending on ``tz``. Raises ------ TypeError If the TimeSeries is tz-aware and tz is not None. See Also -------- Series.dt.tz_localize: Localize the values in a time zone naive Series. Timestamp.tz_localize: Localize the Timestamp to a timezone. Examples -------- Localize local times: >>> s = pd.Series( ... [1], ... index=pd.DatetimeIndex(["2018-09-15 01:30:00"]), ... ) >>> s.tz_localize("CET") 2018-09-15 01:30:00+02:00 1 dtype: int64 Pass None to convert to tz-naive index and preserve local time: >>> s = pd.Series([1], index=pd.DatetimeIndex(["2018-09-15 01:30:00+02:00"])) >>> s.tz_localize(None) 2018-09-15 01:30:00 1 dtype: int64 Be careful with DST changes. When there is sequential data, pandas can infer the DST time: >>> s = pd.Series( ... range(7), ... index=pd.DatetimeIndex( ... [ ... "2018-10-28 01:30:00", ... "2018-10-28 02:00:00", ... "2018-10-28 02:30:00", ... "2018-10-28 02:00:00", ... "2018-10-28 02:30:00", ... "2018-10-28 03:00:00", ... "2018-10-28 03:30:00", ... ] ... ), ... ) >>> s.tz_localize("CET", ambiguous="infer") 2018-10-28 01:30:00+02:00 0 2018-10-28 02:00:00+02:00 1 2018-10-28 02:30:00+02:00 2 2018-10-28 02:00:00+01:00 3 2018-10-28 02:30:00+01:00 4 2018-10-28 03:00:00+01:00 5 2018-10-28 03:30:00+01:00 6 dtype: int64 In some cases, inferring the DST is impossible. In such cases, you can pass an ndarray to the ambiguous parameter to set the DST explicitly >>> s = pd.Series( ... range(3), ... index=pd.DatetimeIndex( ... [ ... "2018-10-28 01:20:00", ... "2018-10-28 02:36:00", ... "2018-10-28 03:46:00", ... ] ... ), ... ) >>> s.tz_localize("CET", ambiguous=np.array([True, True, False])) 2018-10-28 01:20:00+02:00 0 2018-10-28 02:36:00+02:00 1 2018-10-28 03:46:00+01:00 2 dtype: int64 If the DST transition causes nonexistent times, you can shift these dates forward or backward with a timedelta object or `'shift_forward'` or `'shift_backward'`. >>> dti = pd.DatetimeIndex( ... ["2015-03-29 02:30:00", "2015-03-29 03:30:00"], dtype="M8[ns]" ... ) >>> s = pd.Series(range(2), index=dti) >>> s.tz_localize("Europe/Warsaw", nonexistent="shift_forward") 2015-03-29 03:00:00+02:00 0 2015-03-29 03:30:00+02:00 1 dtype: int64 >>> s.tz_localize("Europe/Warsaw", nonexistent="shift_backward") 2015-03-29 01:59:59.999999999+01:00 0 2015-03-29 03:30:00+02:00 1 dtype: int64 >>> s.tz_localize("Europe/Warsaw", nonexistent=pd.Timedelta("1h")) 2015-03-29 03:30:00+02:00 0 2015-03-29 03:30:00+02:00 1 dtype: int64 )rNaT shift_forwardshift_backwardzoThe nonexistent argument must be one of 'raise', 'NaT', 'shift_forward', 'shift_backward' or a timedelta objectc>[US5(d:[U5S:aTRT5n[US35e[ /US9nU$UR XUS9nU$)N tz_localizerrPrQ) ambiguous nonexistent)rrr rrxr`)rr rarbrRrrs r _tz_localize)NDFrame.tz_localize.._tz_localize+sq2}--r7Q;"11$7G#")#OP#2"-I^^B^UIrrNrrUrVFrrr`rp)rrdt timedeltarrrrzrrWrXrrrSr6) rr rr rrarbnonexistent_optionsrrcrYrhs ` ` rr`NDFrame.tz_localize*sT $$T*Q  1* ; ; %  $$T* ^^D !  b* % %((/E$RYYu%5rkRIy6BT1bgg.. :eWM!BCCbi=B&$/""4 ">>rc6[UUUUS9RUSS9$)a- Generate descriptive statistics. Descriptive statistics include those that summarize the central tendency, dispersion and shape of a dataset's distribution, excluding ``NaN`` values. Analyzes both numeric and object series, as well as ``DataFrame`` column sets of mixed data types. The output will vary depending on what is provided. Refer to the notes below for more detail. Parameters ---------- percentiles : list-like of numbers, optional The percentiles to include in the output. All should fall between 0 and 1. The default, ``None``, will automatically return the 25th, 50th, and 75th percentiles. include : 'all', list-like of dtypes or None (default), optional A white list of data types to include in the result. Ignored for ``Series``. Here are the options: - 'all' : All columns of the input will be included in the output. - A list-like of dtypes : Limits the results to the provided data types. To limit the result to numeric types submit ``numpy.number``. To limit it instead to object columns submit the ``numpy.object`` data type. Strings can also be used in the style of ``select_dtypes`` (e.g. ``df.describe(include=['O'])``). To select pandas categorical columns, use ``'category'`` - None (default) : The result will include all numeric columns. exclude : list-like of dtypes or None (default), optional, A black list of data types to omit from the result. Ignored for ``Series``. Here are the options: - A list-like of dtypes : Excludes the provided data types from the result. To exclude numeric types submit ``numpy.number``. To exclude object columns submit the data type ``numpy.object``. Strings can also be used in the style of ``select_dtypes`` (e.g. ``df.describe(exclude=['O'])``). To exclude pandas categorical columns, use ``'category'`` - None (default) : The result will exclude nothing. Returns ------- Series or DataFrame Summary statistics of the Series or Dataframe provided. See Also -------- DataFrame.count: Count number of non-NA/null observations. DataFrame.max: Maximum of the values in the object. DataFrame.min: Minimum of the values in the object. DataFrame.mean: Mean of the values. DataFrame.std: Standard deviation of the observations. DataFrame.select_dtypes: Subset of a DataFrame including/excluding columns based on their dtype. Notes ----- For numeric data, the result's index will include ``count``, ``mean``, ``std``, ``min``, ``max`` as well as lower, ``50`` and upper percentiles. By default the lower percentile is ``25`` and the upper percentile is ``75``. The ``50`` percentile is the same as the median. For object data (e.g. strings), the result's index will include ``count``, ``unique``, ``top``, and ``freq``. The ``top`` is the most common value. The ``freq`` is the most common value's frequency. If multiple object values have the highest count, then the ``count`` and ``top`` results will be arbitrarily chosen from among those with the highest count. For mixed data types provided via a ``DataFrame``, the default is to return only an analysis of numeric columns. If the DataFrame consists only of object and categorical data without any numeric columns, the default is to return an analysis of both the object and categorical columns. If ``include='all'`` is provided as an option, the result will include a union of attributes of each type. The `include` and `exclude` parameters can be used to limit which columns in a ``DataFrame`` are analyzed for the output. The parameters are ignored when analyzing a ``Series``. Examples -------- Describing a numeric ``Series``. >>> s = pd.Series([1, 2, 3]) >>> s.describe() count 3.0 mean 2.0 std 1.0 min 1.0 25% 1.5 50% 2.0 75% 2.5 max 3.0 dtype: float64 Describing a categorical ``Series``. >>> s = pd.Series(["a", "a", "b", "c"]) >>> s.describe() count 4 unique 3 top a freq 2 dtype: object Describing a timestamp ``Series``. >>> s = pd.Series( ... [ ... np.datetime64("2000-01-01"), ... np.datetime64("2010-01-01"), ... np.datetime64("2010-01-01"), ... ] ... ) >>> s.describe() count 3 mean 2006-09-01 08:00:00 min 2000-01-01 00:00:00 25% 2004-12-31 12:00:00 50% 2010-01-01 00:00:00 75% 2010-01-01 00:00:00 max 2010-01-01 00:00:00 dtype: object Describing a ``DataFrame``. By default only numeric fields are returned. >>> df = pd.DataFrame( ... { ... "categorical": pd.Categorical(["d", "e", "f"]), ... "numeric": [1, 2, 3], ... "object": ["a", "b", "c"], ... } ... ) >>> df.describe() numeric count 3.0 mean 2.0 std 1.0 min 1.0 25% 1.5 50% 2.0 75% 2.5 max 3.0 Describing all columns of a ``DataFrame`` regardless of data type. >>> df.describe(include="all") # doctest: +SKIP categorical numeric object count 3 3.0 3 unique 3 NaN 3 top f NaN a freq 1 NaN 1 mean NaN 2.0 NaN std NaN 1.0 NaN min NaN 1.0 NaN 25% NaN 1.5 NaN 50% NaN 2.0 NaN 75% NaN 2.5 NaN max NaN 3.0 NaN Describing a column from a ``DataFrame`` by accessing it as an attribute. >>> df.numeric.describe() count 3.0 mean 2.0 std 1.0 min 1.0 25% 1.5 50% 2.0 75% 2.5 max 3.0 Name: numeric, dtype: float64 Including only numeric columns in a ``DataFrame`` description. >>> df.describe(include=[np.number]) numeric count 3.0 mean 2.0 std 1.0 min 1.0 25% 1.5 50% 2.0 75% 2.5 max 3.0 Including only string columns in a ``DataFrame`` description. >>> df.describe(include=[object]) # doctest: +SKIP object count 3 unique 3 top a freq 1 Including only categorical columns from a ``DataFrame`` description. >>> df.describe(include=["category"]) categorical count 3 unique 3 top d freq 1 Excluding numeric columns from a ``DataFrame`` description. >>> df.describe(exclude=[np.number]) # doctest: +SKIP categorical object count 3 3 unique 3 3 top f a freq 1 1 Excluding object columns from a ``DataFrame`` description. >>> df.describe(exclude=[object]) # doctest: +SKIP categorical numeric count 3 3.0 unique 3 NaN top f NaN freq 1 NaN mean NaN 2.0 std NaN 1.0 min NaN 1.0 25% NaN 1.5 50% NaN 2.0 75% NaN 2.5 max NaN 3.0 )rrexclude percentilesdescriberp)rr6)rrkrrjs rrlNDFrame.describe+s.l #  ,tJ, /  0rc :Ub[SU<S35eURURSS55nUR"S XUS.UD6nX- S- nUb9URUR R 5)nURU5nURUSS9$) a Fractional change between the current and a prior element. Computes the fractional change from the immediately previous row by default. This is useful in comparing the fraction of change in a time series of elements. .. note:: Despite the name of this method, it calculates fractional change (also known as per unit change or relative change) and not percentage change. If you need the percentage change, multiply these values by 100. Parameters ---------- periods : int, default 1 Periods to shift for forming percent change. fill_method : None Must be None. This argument will be removed in a future version of pandas. freq : DateOffset, timedelta, or str, optional Increment to use from time series API (e.g. 'ME' or BDay()). **kwargs Additional keyword arguments are passed into `DataFrame.shift` or `Series.shift`. Returns ------- Series or DataFrame The same type as the calling object. See Also -------- Series.diff : Compute the difference of two elements in a Series. DataFrame.diff : Compute the difference of two elements in a DataFrame. Series.shift : Shift the index by some number of periods. DataFrame.shift : Shift the index by some number of periods. Examples -------- **Series** >>> s = pd.Series([90, 91, 85]) >>> s 0 90 1 91 2 85 dtype: int64 >>> s.pct_change() 0 NaN 1 0.011111 2 -0.065934 dtype: float64 >>> s.pct_change(periods=2) 0 NaN 1 NaN 2 -0.055556 dtype: float64 See the percentage change in a Series where filling NAs with last valid observation forward to next valid. >>> s = pd.Series([90, 91, None, 85]) >>> s 0 90.0 1 91.0 2 NaN 3 85.0 dtype: float64 >>> s.ffill().pct_change() 0 NaN 1 0.011111 2 0.000000 3 -0.065934 dtype: float64 **DataFrame** Percentage change in French franc, Deutsche Mark, and Italian lira from 1980-01-01 to 1980-03-01. >>> df = pd.DataFrame( ... { ... "FR": [4.0405, 4.0963, 4.3149], ... "GR": [1.7246, 1.7482, 1.8519], ... "IT": [804.74, 810.01, 860.13], ... }, ... index=["1980-01-01", "1980-02-01", "1980-03-01"], ... ) >>> df FR GR IT 1980-01-01 4.0405 1.7246 804.74 1980-02-01 4.0963 1.7482 810.01 1980-03-01 4.3149 1.8519 860.13 >>> df.pct_change() FR GR IT 1980-01-01 NaN NaN NaN 1980-02-01 0.013810 0.013684 0.006549 1980-03-01 0.053365 0.059318 0.061876 Percentage of change in GOOG and APPL stock volume. Shows computing the percentage change between columns. >>> df = pd.DataFrame( ... { ... "2016": [1769950, 30586265], ... "2015": [1500923, 40912316], ... "2014": [1371819, 41403351], ... }, ... index=["GOOG", "APPL"], ... ) >>> df 2016 2015 2014 GOOG 1769950 1500923 1371819 APPL 30586265 40912316 41403351 >>> df.pct_change(axis="columns", periods=-1) 2016 2015 2014 GOOG 0.179241 0.094112 NaN APPL -0.252395 -0.011860 NaN z*fill_method must be None; got fill_method=rrr)r9rrr pct_changerprV) rrrir:rMr duplicatedrwr6)rr9 fill_methodrrrshiftedrs rroNDFrame.pct_change,sL  "Jk^1MN N$$VZZ%@A**MWdMfM ^a   ,,../B&BtL99rc [R"SXaS9 [USSS9 URS:a.Uc+UR"X4SXES.UD6nUR"X4SU0UD6$UcSnURS:aUS:Xa~[ UR R5S:a[[S UR R55(a0U(d)UnU(aUR5nURXUS 9$URUUUUUS S 9$) NrVfnameskipnaF none_allowedrrr bool_onlyrwc3R# UHoRRS:Hv M g7f)rN)rr)r@r9s rrA(NDFrame._logical_func..[-sI8HuLL%%*8Hs%'rwr)rrrwr filter_type) r=validate_logical_funcrRr _logical_funcrrrrr, _reduce_axis1_reduce) rrrrr{rwrrrs rrNDFrame._logical_func=-s'   V8FH5A 99q=T\$$!"iJPC$$#)-3 \D IIM DII$$%)I 8H8HIIIC))+$$T$? ?|| "   rrzc JUR"S[RXU40UD6$)Nr)rrqnananyrrr{rwrs rr NDFrame.anym-,!! 6==$6 =C  rc JUR"S[RXU40UD6$)Nr)rrqnanallrs rr NDFrame.ally-rrch^^^^[R"TUTT5mUcSnOURU5nUS:Xa.URR"TT/UQ7STS.TD6R$UUUU4SjnUR R U5nURXRS9RUTS9$)Nrr)rrwc >[US5(a UROUn[U[5(aUR"T4ST0TD6nO[ R "UTTS9n[US5(aURnU$UnU$)Nr:rwr~)rr:rrt _accumulaterq na_accum_func) blk_valuesrrhrrrrws rblock_accum_func-NDFrame._accum_func..block_accum_func-s~%,Z%=%=Z\\:F&.11++DJJ6J--fd6J!(!5!5VXXFM`. If a BaseIndexer subclass, the window boundaries based on the defined ``get_window_bounds`` method. Additional rolling keyword arguments, namely ``min_periods``, ``center``, ``closed`` and ``step`` will be passed to ``get_window_bounds``. min_periods : int, default None Minimum number of observations in window required to have a value; otherwise, result is ``np.nan``. For a window that is specified by an offset, ``min_periods`` will default to 1. For a window that is specified by an integer, ``min_periods`` will default to the size of the window. center : bool, default False If False, set the window labels as the right edge of the window index. If True, set the window labels as the center of the window index. win_type : str, default None If ``None``, all points are evenly weighted. If a string, it must be a valid `scipy.signal window function `__. Certain Scipy window types require additional parameters to be passed in the aggregation function. The additional parameters must match the keywords specified in the Scipy window type method signature. on : str, optional For a DataFrame, a column label or Index level on which to calculate the rolling window, rather than the DataFrame's index. Provided integer column is ignored and excluded from result since an integer index is not used to calculate the rolling window. closed : str, default None Determines the inclusivity of points in the window If ``'right'``, uses the window (first, last] meaning the last point is included in the calculations. If ``'left'``, uses the window [first, last) meaning the first point is included in the calculations. If ``'both'``, uses the window [first, last] meaning all points in the window are included in the calculations. If ``'neither'``, uses the window (first, last) meaning the first and last points in the window are excluded from calculations. () and [] are referencing open and closed set notation respetively. Default ``None`` (``'right'``). step : int, default None Evaluate the window at every ``step`` result, equivalent to slicing as ``[::step]``. ``window`` must be an integer. Using a step argument other than None or 1 will produce a result with a different shape than the input. method : str {'single', 'table'}, default 'single' Execute the rolling operation per single column or row (``'single'``) or over the entire object (``'table'``). This argument is only implemented when specifying ``engine='numba'`` in the method call. Returns ------- pandas.api.typing.Window or pandas.api.typing.Rolling An instance of Window is returned if ``win_type`` is passed. Otherwise, an instance of Rolling is returned. See Also -------- expanding : Provides expanding transformations. ewm : Provides exponential weighted functions. Notes ----- See :ref:`Windowing Operations ` for further usage details and examples. Examples -------- >>> df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) >>> df B 0 0.0 1 1.0 2 2.0 3 NaN 4 4.0 **window** Rolling sum with a window length of 2 observations. >>> df.rolling(2).sum() B 0 NaN 1 1.0 2 3.0 3 NaN 4 NaN Rolling sum with a window span of 2 seconds. >>> df_time = pd.DataFrame( ... {"B": [0, 1, 2, np.nan, 4]}, ... index=[ ... pd.Timestamp("20130101 09:00:00"), ... pd.Timestamp("20130101 09:00:02"), ... pd.Timestamp("20130101 09:00:03"), ... pd.Timestamp("20130101 09:00:05"), ... pd.Timestamp("20130101 09:00:06"), ... ], ... ) >>> df_time B 2013-01-01 09:00:00 0.0 2013-01-01 09:00:02 1.0 2013-01-01 09:00:03 2.0 2013-01-01 09:00:05 NaN 2013-01-01 09:00:06 4.0 >>> df_time.rolling("2s").sum() B 2013-01-01 09:00:00 0.0 2013-01-01 09:00:02 1.0 2013-01-01 09:00:03 3.0 2013-01-01 09:00:05 NaN 2013-01-01 09:00:06 4.0 Rolling sum with forward looking windows with 2 observations. >>> indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=2) >>> df.rolling(window=indexer, min_periods=1).sum() B 0 1.0 1 3.0 2 2.0 3 4.0 4 4.0 **min_periods** Rolling sum with a window length of 2 observations, but only needs a minimum of 1 observation to calculate a value. >>> df.rolling(2, min_periods=1).sum() B 0 0.0 1 1.0 2 3.0 3 2.0 4 4.0 **center** Rolling sum with the result assigned to the center of the window index. >>> df.rolling(3, min_periods=1, center=True).sum() B 0 1.0 1 3.0 2 3.0 3 6.0 4 4.0 >>> df.rolling(3, min_periods=1, center=False).sum() B 0 0.0 1 1.0 2 3.0 3 3.0 4 6.0 **step** Rolling sum with a window length of 2 observations, minimum of 1 observation to calculate a value, and a step of 2. >>> df.rolling(2, min_periods=1, step=2).sum() B 0 0.0 2 3.0 4 4.0 **win_type** Rolling sum with a window length of 2, using the Scipy ``'gaussian'`` window type. ``std`` is required in the aggregation function. >>> df.rolling(2, win_type="gaussian").sum(std=3) B 0 NaN 1 0.986207 2 2.958621 3 NaN 4 NaN **on** Rolling sum with a window length of 2 days. >>> df = pd.DataFrame( ... { ... "A": [ ... pd.to_datetime("2020-01-01"), ... pd.to_datetime("2020-01-01"), ... pd.to_datetime("2020-01-02"), ... ], ... "B": [1, 2, 3], ... }, ... index=pd.date_range("2020", periods=3), ... ) >>> df A B 2020-01-01 2020-01-01 1 2020-01-02 2020-01-01 2 2020-01-03 2020-01-02 3 >>> df.rolling("2D", on="A").sum() A B 2020-01-01 2020-01-01 1.0 2020-01-02 2020-01-01 3.0 2020-01-03 2020-01-02 6.0 )window min_periodscenterwin_typerrsteprq)rr) rrrrrrrrrqs rrollingNDFrame.rolling.s]N  '!   #  rc[XUS9$)a Provide expanding window calculations. An expanding window yields the value of an aggregation statistic with all the data available up to that point in time. Parameters ---------- min_periods : int, default 1 Minimum number of observations in window required to have a value; otherwise, result is ``np.nan``. method : str {'single', 'table'}, default 'single' Execute the rolling operation per single column or row (``'single'``) or over the entire object (``'table'``). This argument is only implemented when specifying ``engine='numba'`` in the method call. Returns ------- pandas.api.typing.Expanding An instance of Expanding for further expanding window calculations, e.g. using the ``sum`` method. See Also -------- rolling : Provides rolling window calculations. ewm : Provides exponential weighted functions. Notes ----- See :ref:`Windowing Operations ` for further usage details and examples. Examples -------- >>> df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) >>> df B 0 0.0 1 1.0 2 2.0 3 NaN 4 4.0 **min_periods** Expanding sum with 1 vs 3 observations needed to calculate a value. >>> df.expanding(1).sum() B 0 0.0 1 1.0 2 3.0 3 3.0 4 7.0 >>> df.expanding(3).sum() B 0 NaN 1 NaN 2 3.0 3 3.0 4 7.0 )rrq)r)rrrqs r expandingNDFrame.expanding/sNvFFrc &[UUUUUUUUUU S9 $)N) comspanhalflifealpharadjust ignore_natimesrq)r) rrrrrrrrrrqs rewm NDFrame.ewm0s/' #  rcVU"X5nURURU55 U$)z, Wrap arithmetic method to operate inplace. )rrw)rroprhs r_inplace_methodNDFrame._inplace_method#0s- D V0067 rcLURU[U5R5$r)rr__add__rs r__iadd__NDFrame.__iadd__/0!##E4:+=+=>>rcLURU[U5R5$r)rr__sub__rs r__isub__NDFrame.__isub__40rrcLURU[U5R5$r)rr__mul__rs r__imul__NDFrame.__imul__90rrcLURU[U5R5$r)rr __truediv__rs r __itruediv__NDFrame.__itruediv__>0s'##  J " "  rcLURU[U5R5$r)rr __floordiv__rs r __ifloordiv__NDFrame.__ifloordiv__F0s'##  J # #  rcLURU[U5R5$r)rr__mod__rs r__imod__NDFrame.__imod__N0rrcLURU[U5R5$r)rr__pow__rs r__ipow__NDFrame.__ipow__S0rrcLURU[U5R5$r)rr__and__rs r__iand__NDFrame.__iand__X0rrcLURU[U5R5$r)rr__or__rs r__ior__NDFrame.__ior__]0s##E4:+<+<==rcLURU[U5R5$r)rr__xor__rs r__ixor__NDFrame.__ixor__a0rrcnUR5Rn[XS9nUcgURU$)z Retrieves the index of the first valid value. Parameters ---------- how : {'first', 'last'} Use this parameter to change between the first or last valid index. Returns ------- idx_first_valid : type of index )ris_validN)rkrrr)rrr(idxposs r_find_valid_indexNDFrame._find_valid_indexi0s6::<&&!c= >zz&!!rc URSS9$)a3 Return index for first non-missing value or None, if no value is found. See the :ref:`User Guide ` for more information on which values are considered missing. Returns ------- type of index Index of first non-missing value. See Also -------- DataFrame.last_valid_index : Return index for last non-NA value or None, if no non-NA value is found. Series.last_valid_index : Return index for last non-NA value or None, if no non-NA value is found. DataFrame.isna : Detect missing values. Examples -------- For Series: >>> s = pd.Series([None, 3, 4]) >>> s.first_valid_index() 1 >>> s.last_valid_index() 2 >>> s = pd.Series([None, None]) >>> print(s.first_valid_index()) None >>> print(s.last_valid_index()) None If all elements in Series are NA/null, returns None. >>> s = pd.Series() >>> print(s.first_valid_index()) None >>> print(s.last_valid_index()) None If Series is empty, returns None. For DataFrame: >>> df = pd.DataFrame({"A": [None, None, 2], "B": [None, 3, 4]}) >>> df A B 0 NaN NaN 1 NaN 3.0 2 2.0 4.0 >>> df.first_valid_index() 1 >>> df.last_valid_index() 2 >>> df = pd.DataFrame({"A": [None, None, None], "B": [None, None, None]}) >>> df A B 0 None None 1 None None 2 None None >>> print(df.first_valid_index()) None >>> print(df.last_valid_index()) None If all elements in DataFrame are NA/null, returns None. >>> df = pd.DataFrame() >>> df Empty DataFrame Columns: [] Index: [] >>> print(df.first_valid_index()) None >>> print(df.last_valid_index()) None If DataFrame is empty, returns None. firstrr*rs rfirst_valid_indexNDFrame.first_valid_index}0sj%%'%22rc URSS9$)a5 Return index for last non-missing value or None, if no value is found. See the :ref:`User Guide ` for more information on which values are considered missing. Returns ------- type of index Index of last non-missing value. See Also -------- DataFrame.first_valid_index : Return index for first non-NA value or None, if no non-NA value is found. Series.first_valid_index : Return index for first non-NA value or None, if no non-NA value is found. DataFrame.isna : Detect missing values. Examples -------- For Series: >>> s = pd.Series([None, 3, 4]) >>> s.first_valid_index() 1 >>> s.last_valid_index() 2 >>> s = pd.Series([None, None]) >>> print(s.first_valid_index()) None >>> print(s.last_valid_index()) None If all elements in Series are NA/null, returns None. >>> s = pd.Series() >>> print(s.first_valid_index()) None >>> print(s.last_valid_index()) None If Series is empty, returns None. For DataFrame: >>> df = pd.DataFrame({"A": [None, None, 2], "B": [None, 3, 4]}) >>> df A B 0 NaN NaN 1 NaN 3.0 2 2.0 4.0 >>> df.first_valid_index() 1 >>> df.last_valid_index() 2 >>> df = pd.DataFrame({"A": [None, None, None], "B": [None, None, None]}) >>> df A B 0 None None 1 None None 2 None None >>> print(df.first_valid_index()) None >>> print(df.last_valid_index()) None If all elements in DataFrame are NA/null, returns None. >>> df = pd.DataFrame() >>> df Empty DataFrame Columns: [] Index: [] >>> print(df.first_valid_index()) None >>> print(df.last_valid_index()) None If DataFrame is empty, returns None. rr.r/rs rlast_valid_indexNDFrame.last_valid_index0sj%%&%11r)rrr)rr.rNone)NF) rr.rz.dict[Literal['index', 'columns'], Axes | None]rDtypeObj | Nonerrrr.)rr.r list[Index]rr )rr)rzMapping[Hashable, Any]rr5)rrw)rbool | lib.NoDefaultr bool | Nonerr )rr6)rzCallable[..., Self]r)rzSequence[Axis] | Nonerrrr)rrrr)rrrr)rrrry)rrrzdict[str, Series | MultiIndex])rz#dict[Hashable, Series | MultiIndex])rzdict[Hashable, Series])rry)rztuple[int, ...])rr7)rr)rrrr8rr )rrrLiteral[False]rr )rrr Literal[True]rr5)rrrrr Self | None)rrrRzAnyArrayLike | listrr5)r)r r(rrrr )rgrrz Series | Any)r Axis | NonerzScalar | Series | DataFrame).)rxRenamer | Nonerr>rr>rr=rr:r  Level | Nonerurrr )rxr>rr>rr>rr=rr;r r?rurrr5)rxr>rr>rr>rr=rrr r?rurrr<) rxIndexLabel | lib.NoDefaultrrrr8rr:rr ) rxr@rrrr8rr;rr5) rxr@rrrr8rrrr<r)rrrr)rr )rr )rrrr )rr,rrrr)rr,rrrr)rr,rrrr5)rr,rrrr)rr)rrr)rznpt.DTypeLike | Nonerr9rz np.ndarray)rEznp.ufuncrqrrFrrr)rzdict[str, Any])rr5)rr)$rz)FilePath | WriteExcelBuffer | ExcelWriterrsrrtrru str | NonerSequence[Hashable] | NonervzSequence[Hashable] | boolrrrwIndexLabel | Nonerxrryrrzz(Literal['openpyxl', 'xlsxwriter'] | Noner{rr|rr}ztuple[int, int] | Noner~StorageOptions | Nonerzdict[str, Any] | Nonerrrr5)r7FilePath | WriteBuffer[bytes] | WriteBuffer[str] | NonerhzILiteral['split', 'records', 'index', 'table', 'columns', 'values'] | NonerrArrrrrr?rz(Callable[[Any], JSONSerializable] | Nonerrrrrr9r int | Noner~rDrzLiteral['a', 'w']rrA)rzFilePath | HDFStorerrrzLiteral['a', 'w', 'r+']rrFrz/Literal['zlib', 'lzo', 'bzip2', 'blosc'] | Nonerrrz Literal['fixed', 'table'] | Nonerrrzint | dict[str, int] | Nonerr9rz Literal[True] | list[str] | Nonerur1rrrr5)rrrrArz3Literal['fail', 'replace', 'append', 'delete_rows']rrrwrCrrFrzDtypeArg | Nonerqz"Literal['multi'] | Callable | NonerrF) rzFilePath | WriteBuffer[bytes]rrrrr~rDrr5)rrrrArr5),rr5rrBrvbool | SequenceNotStr[str]rrrtrrFormattersType | NoneruFloatFormatType | Nonerr9rrrrrrArr9rr9rrArrrr9rrArr9rstr | tuple[str, str] | NonerrArrArr),rzFilePath | WriteBuffer[str]rrBrvrGrrrtrrrHrurIrr9rrrrrrArr9rr9rrArrrr9rrArr9rrJrrArrArr5),rz"FilePath | WriteBuffer[str] | NonerrBrvrGrrrtrrrHrurIrr9rrrrrrArr9rr9rrArrrr9rrArr9rrJrrArrArrA) rdict | list[dict] | Noner rKrrKr rKr rKr z dict | None),rr5rrrtrrustr | Callable | NonerrBrvbool | list[str]rrrwrCrrrrArrr,rFr-rr.rArrFrrAr/rr0rArrrur1r~r8rr),rz0FilePath | WriteBuffer[bytes] | WriteBuffer[str]rrrtrrurLrrBrvrMrrrwrCrrrrArrr,rFr-rr.rArrFrrAr/rr0rArrrur1r~r8rr5),rrErrrtrrurLrrBrvrMrrrwrCrrrrArrr,rFr-rr.rArrFrrAr/rr0rArrrur1r~rDrrA)rrrr )rNT) rr(rrr rCrCrrr )rrmrr )r\rmrrrr )rrrr5)rqz>Literal['backfill', 'bfill', 'pad', 'ffill', 'nearest'] | Nonerr8rtrFrr )rRIndexLabel | ListLikerrrrNrrNr r?rr;rur&rr5)rRrNrrrrNrrNr r?rr:rur&rr )rRrNrrrrNrrNr r?rrrur&rr<)NrF)rur&rrrr )rrrr=rr )rrrr=rr )rrrbool | Sequence[bool]rr:rr7rr/rrrr@rr )rrrrOrr;rr7rr/rrrr@rr5)rrrrOrrrr7rr/rrrr@rr<)rrrrOrrrr7rr/rrrzValueKeyFunc | Nonerr<)rrr r(rrOrr;rr7rr/rrrrrr'rr5)rrr r(rrOrr:rr7rr/rrrrrr'rr )rrr r(rrOrrrr7rr/rrrrrr'rr<)rrr rCrrOrrrr7rr/rrrrrzIndexKeyFunc | Nonerr<)rr=rqzReindexMethod | Nonerr8r r?r Scalar | NonertrFrr )r r?rtrFrrPrr )r r?rr)rrrr )NNNN)rrArrArr=rr ))rrrr )NNFNNNF)rrFr float | NonerrrzRandomState | Nonerr=rrrr )rz!Callable[Concatenate[Self, P], T]rzP.argsrzP.kwargsrr:)rztuple[Callable[..., T], str]rrrrrr:)rz@Callable[Concatenate[Self, P], T] | tuple[Callable[..., T], str]rrrrrr:)rqrArr )rr)rrrr5)rr)rr)rr8rur&rr )T)rrrr )rr8rr )TTTTTnumpy_nullable)rQrrUrrVrrWrrXrrYrrr ) rqz,Literal['ffill', 'bfill', 'pad', 'backfill']r None | Axisrrrt None | intr]#Literal['inside', 'outside'] | None) rz'Hashable | Mapping | Series | DataFramerr=rrrtrFrr ) rrTrrrtrUr]rVrr )rrrrrr )r)rqr)rrrtrFrrrz-Literal['forward', 'backward', 'both'] | Noner]rVrr )F)rr)rr=rrrr )NNFN) rr%rqzFillnaOptions | NonerzLiteral['start', 'end'] | NonerrrHashable | Nonerr )FN)rrrr=rr )bothN)rr*rr=rr )NNrNN start_dayNF)rLiteral['right', 'left'] | NonerrZrz!Literal['start', 'end', 's', 'e']rr?r r?rzstr | TimestampConvertibleTypesrz TimedeltaConvertibleTypes | Nonerrrr)raverageFrTF)rrrqz2Literal['average', 'min', 'max', 'first', 'dense']rrrz Literal['keep', 'top', 'bottom']rrrrrr )rFFr) rr rrrrrrrr9)rr0r[rrr=r r?rr8rrWrztuple[Self, NDFrameT])rNNN)rrr[rrr=rz$tuple[Self, DataFrame, Index | None])rrr[rrr=rz!tuple[Self, Series, Index | None])rrrr=rr )rrrr=r r?rr ) r9zint | Sequence[int]rrrrrrArzSelf | DataFrame)r9rrrrr )rr=rr8rr ) rrrr8rar;rbr=rr r)rNN)r9rrqr5rr )rFT) rrrr=r{rrwrr Series | bool)rr=r{rrwrrr\)rrr{rrwrrr\)NT)rrrr=rwr)rT)rrrwrrr )rTrF) rrrr=rwrrrrrrSeries | float) rr=rwrrrrrrr])rTF)rrrr=rwrrr)rr=rwrrr)rr=rwrrrrr])rTFr) rrrr=rwrrrrr)rr=rwrrrrr)NFNNNNsingle)rz3int | dt.timedelta | str | BaseOffset | BaseIndexerrrFrrrrArrArzIntervalClosedType | NonerrFrqrrzWindow | Rolling)rr^)rrrqLiteral['single', 'table']rr) NNNNrTFNr^)rrRrrRrz(float | TimedeltaConvertibleTypes | NonerrRrrFrrrrrz&np.ndarray | DataFrame | Series | Nonerqr_rr)rrrr)rr)r __module__ __qualname____firstlineno____doc__r__annotations__rPrr frozensetrrrr classmethodrrpropertyrsetterrrrrrrrrrr rrr$r-r7r:rDrrrMrSrrQr`rcriroryrrrrrrrrrrrrrrr rr!r&rrr/r2r7r9rArGrLrSr^rdrorrkrrpickleHIGHEST_PROTOCOLrrrrcrr3r<rrTr]r[rgrr staticmethodrrMrKrwrrrrrrrrKrrvrrrrrrjrrrrr6r rrrrr"r(r,rrr3rrrJrNrQrZr`r_rsrxrrrrjrrkrrrrrrrrrrrr r r.rkrr:r;rHrOr`rlrorrrrrrrrrrrrrrrrrrrkurtosisrrrLproductrrrNrrrrrr r rrrrr!r%r*r0r3__static_attributes__ __classcell__)rs@rrrs83 "OY%($885J $-bMM>1Iy M  I V   "&  =      :  ,##J \\""  % %N &)^^/3 D#D"- D  D DL    $((434510M-M00N ,0)>   ,  ( (8%(^^ -C -C # -C  -C^ +9 XX VV   ) ) C4 C4J  p pj"% !$"%"%!              "% !$"%!             "% !$"%!              "&F>!%"& "F>F> F>  F>  F>F>F>F> F> F>P.1 %(^^"% *   #      .1 %(^^ *   #     .1 %(^^ *   #     .1^^enn%(^^e*e  e#ee eN!$CF2@ !$2? !$26  !"@7<@@04@ @ @J     ^, ^,F 8 8"  8  8 ; ;     D  D L   K K    < S S2    0 )" )"V @ @D I Ib%2> $ & &9K9K@#"GK)8C : MM'*M58MDGM M       !R !RL1     M  M ##'-1,0)-;? /315/3 'k ?k  k  k ! k +k *k k 'k k k 9k k k -!k "/#k $-%k &'k ( )k  k Z PTF "& " "DH*1!!15"%!F LF  F  F F F F BF F (F F F /F  !F " #F  F P  ), $CG3748"9=!)!W (W  W & W  W AW W 1W W 2W W 7W W !W " #W  W r "IO)- $!%59@ @  @ G @ @ '@ @ @ 3@  @  @ D +2//15 [ +[ ( [  [ / [  [  [ z #tGFGF*4GF GF GFR X7 X7t.1-0,//2 #$'!$!"#&), #03"/ +  +   *-" !"#$!%&''()*.+,-./0 14 .1-0,//2 #$'!$!"#&), #03"/ (+  +   *-" !"#$!%&''()*.+,-./0 14 37] .2-1,0/3 $ $(!%"##')- $04 #/] /] + ] + ]  ] ] *] -] ] ] ] "] ] ] !] "#] $!%] &''] ()] *.+] ,-] ./] 0 1]  ] ~  H9*.26+/157;%)H9' H9 0 H9 ) H9/H95H9#H9 H9T .1-0#&),"*-!%( #"%!$!$*-/    , +!'( #!"#$ %&'()*+,-.(/0 14 .1-0#&),"*-!%( #"%!$!$*-/E    , +!'( #!"#$ %&'()*+,-.(/0 14 PTQ .2-1#')-#*1"%) $"& !%!)15/Q LQ  Q  Q , Q +Q !Q Q 'Q Q Q (Q Q Q #!Q "#Q $ %Q &'Q ()Q *+Q ,-Q .//Q 0 1Q  Q l a  a F #' o oo! o  o  o ob( " "   / /D   A AF  ^XDA RV%(^^  {!O{!# {!  {! {! B{!z), '*),!! %   %  '       ), '*),!"%! %   %  '        ), '*),!! %   %  '       )-''+)-"%'%' ' % ' ' '''' 'R % S)  S)  S) S) S)j       E& E&N D& D&L+."%"%   )            +."%   )            +."%   )            +/$"("#'e(e() e(  e(  e( e(e(!e( e(N+."%"     )            +."%"%"     )            +."%"     )            "#'+/$"(#"#'6B6B! 6B ) 6B  6B6B 6B6B6B!6B 6BtU/ '+%(^^"$&FF U/  U/%U/#U/U/"U/U/ U/n  "  <  (  "  "  "  " L  nLnL nL  nL  nL` V$ V$p W% W%r !+/ "X XX X ) XXX X Xt/  *   eINeIeI eI eI eIT 9 9v 3 3  '6 '6R   , ,          )  ) Y Y Y Y(((($W$WL &)^^% E"#E" E"  E" E"N i  i V % % $ $ 9<9> 9>v ## $ $!%&6S?S?S? S?  S?  S?$S? S? S?p ! :>#><#> #>  #>  #>8#> #>J ! l>6l> l>  l>  l> l> l>\ ! :> c c  c  c 8 c  c  c J ! :> n n  n  n 8 n  n  n ` nn[?  [?  [?  [? [? [?z &.XC IM:>XC"XC XC  XC  XCGXC8XC XC XCz p2 p2jENE>NE@N  $ I I@ q ! q  q  q q qf (,.2&* z z %z , z  z $ z  z  z x 9- 9-v )/ R-& R-  R-  R- R-h 37158?"2=37 z 0z / z 6 z  z z 0z 1z z  z  z x  EN"6<]]C] ] 4 ]  ]] ] ]D  !2 jjj j  j  jX " "%(^^&*eee e  e # e$e e eN "  +'+'+' +' .+' +'Z "  <'<'<' <' +<' <'| nnj-  j-  j-  j- j- j-X nnfQ  "fQ  fQ  fQfQ fQ fQP nnm  "m  m  m m  m  m b() "~~! T:$T: T:  T:  T: T:l !9 !9F  %(^^ s s # s  s sj %(^^ `>`> # `>  `> `>D %(^^#*'.P?P? # P? ! P?%P? P? P?j  z0  z0 z0x   Q:Q:Q:  Q: Q:f  - -  -  -  -  -  - d                       ! ) )  )  )  ) V    TTVV "             ("             "             "              "           *"       ("       ("           "           "           "           H "           6"          "         &G #'#,0] C]  ]  ]  ]  ] *] ] ]  ]  ] ~ -5FGFG+FG  FG FGP  !!!=A""#8<-5   ;        6 +  ! "  8     ? ? ? ? ? ?         ? ? ? ? ? ? > > ? ? " "& T3 T3l T2 T2rra {desc} Parameters ---------- axis : {axis_descr} Axis for the function to be applied on. For `Series` this parameter is unused and defaults to 0. For DataFrames, specifying ``axis=None`` will apply the aggregation across both axes. .. versionadded:: 2.0.0 skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. {min_count}**kwargs Additional keyword arguments to be passed to the function. Returns ------- {name1} or scalar Value containing the calculation referenced in the description.{see_also}{examples} a= {desc} Parameters ---------- axis : {axis_descr} Axis for the function to be applied on. For `Series` this parameter is unused and defaults to 0. .. warning:: The behavior of DataFrame.{name} with ``axis=None`` is deprecated, in a future version this will reduce over both axes and return a scalar To retain the old behavior, pass axis=0 (or do not pass axis). .. versionadded:: 2.0.0 skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. Not implemented for Series. {min_count}**kwargs Additional keyword arguments to be passed to the function. Returns ------- {name1} or scalar Value containing the calculation referenced in the description.{see_also}{examples} a {desc} Parameters ---------- axis : {axis_descr} For `Series` this parameter is unused and defaults to 0. .. warning:: The behavior of DataFrame.{name} with ``axis=None`` is deprecated, in a future version this will reduce over both axes and return a scalar To retain the old behavior, pass axis=0 (or do not pass axis). skipna : bool, default True Exclude NA/null values. If an entire row/column is NA, the result will be NA. ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. numeric_only : bool, default False Include only float, int, boolean columns. Not implemented for Series. **kwargs : Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- {name1} or {name2} (if level specified) {return_desc} See Also -------- {see_also}{notes}{examples} avscipy.stats.sem : Compute standard error of the mean. {name2}.std : Return sample standard deviation over requested axis. {name2}.var : Return unbiased variance over requested axis. {name2}.mean : Return the mean of the values over the requested axis. {name2}.median : Return the median of the values over the requested axis. {name2}.mode : Return the mode(s) of the Series.z8Unbiased standard error of the mean over requested axis.anumpy.std : Compute the standard deviation along the specified axis. {name2}.var : Return unbiased variance over requested axis. {name2}.sem : Return unbiased standard error of the mean over requested axis. {name2}.mean : Return the mean of the values over the requested axis. {name2}.median : Return the median of the values over the requested axis. {name2}.mode : Return the mode(s) of the Series.z'Standard deviation over requested axis.zg Notes ----- To have the same behaviour as `numpy.std`, use `ddof=0` (instead of the default `ddof=1`)ay Examples -------- >>> df = pd.DataFrame({'person_id': [0, 1, 2, 3], ... 'age': [21, 25, 62, 43], ... 'height': [1.61, 1.87, 1.49, 2.01]} ... ).set_index('person_id') >>> df age height person_id 0 21 1.61 1 25 1.87 2 62 1.49 3 43 2.01 The standard deviation of the columns can be found as follows: >>> df.std() age 18.786076 height 0.237417 dtype: float64 Alternatively, `ddof=0` can be set to normalize by N instead of N-1: >>> df.std(ddof=0) age 16.269219 height 0.205609 dtype: float64a? Examples -------- >>> df = pd.DataFrame({'person_id': [0, 1, 2, 3], ... 'age': [21, 25, 62, 43], ... 'height': [1.61, 1.87, 1.49, 2.01]} ... ).set_index('person_id') >>> df age height person_id 0 21 1.61 1 25 1.87 2 62 1.49 3 43 2.01 >>> df.var() age 352.916667 height 0.056367 dtype: float64 Alternatively, ``ddof=0`` can be set to normalize by N instead of N-1: >>> df.var(ddof=0) age 264.687500 height 0.042275 dtype: float64ag {desc} Parameters ---------- axis : {{0 or 'index', 1 or 'columns', None}}, default 0 Indicate which axis or axes should be reduced. For `Series` this parameter is unused and defaults to 0. * 0 / 'index' : reduce the index, return a Series whose index is the original column labels. * 1 / 'columns' : reduce the columns, return a Series whose index is the original index. * None : reduce all axes, return a scalar. bool_only : bool, default False Include only boolean columns. Not implemented for Series. skipna : bool, default True Exclude NA/null values. If the entire row/column is NA and skipna is True, then the result will be {empty_value}, as for an empty row/column. If skipna is False, then NA are treated as True, because these are not equal to zero. **kwargs : any, default None Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- {name2} or {name1} If axis=None, then a scalar boolean is returned. Otherwise a Series is returned with index matching the index argument. {see_also} {examples}zReturn whether all elements are True, potentially over an axis. Returns True unless there at least one element within a series or along a Dataframe axis that is False or equivalent (e.g. zero or empty).aExamples -------- **Series** >>> pd.Series([True, True]).all() True >>> pd.Series([True, False]).all() False >>> pd.Series([], dtype="float64").all() True >>> pd.Series([np.nan]).all() True >>> pd.Series([np.nan]).all(skipna=False) True **DataFrames** Create a DataFrame from a dictionary. >>> df = pd.DataFrame({'col1': [True, True], 'col2': [True, False]}) >>> df col1 col2 0 True True 1 True False Default behaviour checks if values in each column all return True. >>> df.all() col1 True col2 False dtype: bool Specify ``axis='columns'`` to check if values in each row all return True. >>> df.all(axis='columns') 0 True 1 False dtype: bool Or ``axis=None`` for whether every value is True. >>> df.all(axis=None) False zSee Also -------- Series.all : Return True if all elements are True. DataFrame.any : Return True if one (or more) elements are True. a Return cumulative {desc} over a DataFrame or Series axis. Returns a DataFrame or Series of the same size containing the cumulative {desc}. Parameters ---------- axis : {{0 or 'index', 1 or 'columns'}}, default 0 The index or the name of the axis. 0 is equivalent to None or 'index'. For `Series` this parameter is unused and defaults to 0. skipna : bool, default True Exclude NA/null values. If an entire row/column is NA, the result will be NA. numeric_only : bool, default False Include only float, int, boolean columns. *args, **kwargs Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- {name1} or {name2} Return cumulative {desc} of {name1} or {name2}. See Also -------- core.window.expanding.Expanding.{accum_func_name} : Similar functionality but ignores ``NaN`` values. {name2}.{accum_func_name} : Return the {desc} over {name2} axis. {name2}.cummax : Return cumulative maximum over {name2} axis. {name2}.cummin : Return cumulative minimum over {name2} axis. {name2}.cumsum : Return cumulative sum over {name2} axis. {name2}.cumprod : Return cumulative product over {name2} axis. {examples}aZ Return cumulative {desc} over a DataFrame or Series axis. Returns a DataFrame or Series of the same size containing the cumulative {desc}. Parameters ---------- axis : {{0 or 'index', 1 or 'columns'}}, default 0 The index or the name of the axis. 0 is equivalent to None or 'index'. For `Series` this parameter is unused and defaults to 0. skipna : bool, default True Exclude NA/null values. If an entire row/column is NA, the result will be NA. *args, **kwargs Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- {name1} or {name2} Return cumulative {desc} of {name1} or {name2}. See Also -------- core.window.expanding.Expanding.{accum_func_name} : Similar functionality but ignores ``NaN`` values. {name2}.{accum_func_name} : Return the {desc} over {name2} axis. {name2}.cummax : Return cumulative maximum over {name2} axis. {name2}.cummin : Return cumulative minimum over {name2} axis. {name2}.cumsum : Return cumulative sum over {name2} axis. {name2}.cumprod : Return cumulative product over {name2} axis. {examples}aExamples -------- **Series** >>> s = pd.Series([2, np.nan, 5, -1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 -1.0 4 0.0 dtype: float64 By default, NA values are ignored. >>> s.cummin() 0 2.0 1 NaN 2 2.0 3 -1.0 4 -1.0 dtype: float64 To include NA values in the operation, use ``skipna=False`` >>> s.cummin(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64 **DataFrame** >>> df = pd.DataFrame([[2.0, 1.0], ... [3.0, np.nan], ... [1.0, 0.0]], ... columns=list('AB')) >>> df A B 0 2.0 1.0 1 3.0 NaN 2 1.0 0.0 By default, iterates over rows and finds the minimum in each column. This is equivalent to ``axis=None`` or ``axis='index'``. >>> df.cummin() A B 0 2.0 1.0 1 2.0 NaN 2 1.0 0.0 To iterate over columns and find the minimum in each row, use ``axis=1`` >>> df.cummin(axis=1) A B 0 2.0 1.0 1 3.0 NaN 2 1.0 0.0 aExamples -------- **Series** >>> s = pd.Series([2, np.nan, 5, -1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 -1.0 4 0.0 dtype: float64 By default, NA values are ignored. >>> s.cumsum() 0 2.0 1 NaN 2 7.0 3 6.0 4 6.0 dtype: float64 To include NA values in the operation, use ``skipna=False`` >>> s.cumsum(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64 **DataFrame** >>> df = pd.DataFrame([[2.0, 1.0], ... [3.0, np.nan], ... [1.0, 0.0]], ... columns=list('AB')) >>> df A B 0 2.0 1.0 1 3.0 NaN 2 1.0 0.0 By default, iterates over rows and finds the sum in each column. This is equivalent to ``axis=None`` or ``axis='index'``. >>> df.cumsum() A B 0 2.0 1.0 1 5.0 NaN 2 6.0 1.0 To iterate over columns and find the sum in each row, use ``axis=1`` >>> df.cumsum(axis=1) A B 0 2.0 3.0 1 3.0 NaN 2 1.0 1.0 aExamples -------- **Series** >>> s = pd.Series([2, np.nan, 5, -1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 -1.0 4 0.0 dtype: float64 By default, NA values are ignored. >>> s.cumprod() 0 2.0 1 NaN 2 10.0 3 -10.0 4 -0.0 dtype: float64 To include NA values in the operation, use ``skipna=False`` >>> s.cumprod(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64 **DataFrame** >>> df = pd.DataFrame([[2.0, 1.0], ... [3.0, np.nan], ... [1.0, 0.0]], ... columns=list('AB')) >>> df A B 0 2.0 1.0 1 3.0 NaN 2 1.0 0.0 By default, iterates over rows and finds the product in each column. This is equivalent to ``axis=None`` or ``axis='index'``. >>> df.cumprod() A B 0 2.0 1.0 1 6.0 NaN 2 6.0 0.0 To iterate over columns and find the product in each row, use ``axis=1`` >>> df.cumprod(axis=1) A B 0 2.0 2.0 1 3.0 NaN 2 1.0 0.0 aExamples -------- **Series** >>> s = pd.Series([2, np.nan, 5, -1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 -1.0 4 0.0 dtype: float64 By default, NA values are ignored. >>> s.cummax() 0 2.0 1 NaN 2 5.0 3 5.0 4 5.0 dtype: float64 To include NA values in the operation, use ``skipna=False`` >>> s.cummax(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64 **DataFrame** >>> df = pd.DataFrame([[2.0, 1.0], ... [3.0, np.nan], ... [1.0, 0.0]], ... columns=list('AB')) >>> df A B 0 2.0 1.0 1 3.0 NaN 2 1.0 0.0 By default, iterates over rows and finds the maximum in each column. This is equivalent to ``axis=None`` or ``axis='index'``. >>> df.cummax() A B 0 2.0 1.0 1 3.0 NaN 2 3.0 1.0 To iterate over columns and find the maximum in each row, use ``axis=1`` >>> df.cummax(axis=1) A B 0 2.0 2.0 1 3.0 NaN 2 1.0 1.0 a2See Also -------- numpy.any : Numpy version of this method. Series.any : Return whether any element is True. Series.all : Return whether all elements are True. DataFrame.any : Return whether any element is True over requested axis. DataFrame.all : Return whether all elements are True over requested axis. zReturn whether any element is True, potentially over an axis. Returns False unless there is at least one element within a series or along a Dataframe axis that is True or equivalent (e.g. non-zero or non-empty).a\Examples -------- **Series** For Series input, the output is a scalar indicating whether any element is True. >>> pd.Series([False, False]).any() False >>> pd.Series([True, False]).any() True >>> pd.Series([], dtype="float64").any() False >>> pd.Series([np.nan]).any() False >>> pd.Series([np.nan]).any(skipna=False) True **DataFrame** Whether each column contains at least one True element (the default). >>> df = pd.DataFrame({"A": [1, 2], "B": [0, 2], "C": [0, 0]}) >>> df A B C 0 1 0 0 1 2 2 0 >>> df.any() A True B True C False dtype: bool Aggregating over the columns. >>> df = pd.DataFrame({"A": [True, False], "B": [1, 2]}) >>> df A B 0 True 1 1 False 2 >>> df.any(axis='columns') 0 True 1 True dtype: bool >>> df = pd.DataFrame({"A": [True, False], "B": [1, 0]}) >>> df A B 0 True 1 1 False 0 >>> df.any(axis='columns') 0 True 1 False dtype: bool Aggregating over the entire DataFrame with ``axis=None``. >>> df.any(axis=None) True `any` for an empty DataFrame is an empty Series. >>> pd.DataFrame([]).any() Series([], dtype: bool) a Examples -------- >>> idx = pd.MultiIndex.from_arrays([ ... ['warm', 'warm', 'cold', 'cold'], ... ['dog', 'falcon', 'fish', 'spider']], ... names=['blooded', 'animal']) >>> s = pd.Series([4, 2, 0, 8], name='legs', index=idx) >>> s blooded animal warm dog 4 falcon 2 cold fish 0 spider 8 Name: legs, dtype: int64 >>> s.{stat_func}() {default_output}stat_func_examplerSum) stat_funcverbdefault_outputlevel_output_0level_output_1a By default, the sum of an empty or all-NA Series is ``0``. >>> pd.Series([], dtype="float64").sum() # min_count=0 is the default 0.0 This can be controlled with the ``min_count`` parameter. For example, if you'd like the sum of an empty series to be NaN, pass ``min_count=1``. >>> pd.Series([], dtype="float64").sum(min_count=1) nan Thanks to the ``skipna`` parameter, ``min_count`` handles all-NA and empty series identically. >>> pd.Series([np.nan]).sum() 0.0 >>> pd.Series([np.nan]).sum(min_count=1) nanrMaxr _max_examplesrMinr _min_examplesz See Also -------- Series.skew : Return unbiased skew over requested axis. Series.var : Return unbiased variance over requested axis. Series.std : Return unbiased standard deviation over requested axis.a See Also -------- Series.sum : Return the sum. Series.min : Return the minimum. Series.max : Return the maximum. Series.idxmin : Return the index of the minimum. Series.idxmax : Return the index of the maximum. DataFrame.sum : Return the sum over the requested axis. DataFrame.min : Return the minimum over the requested axis. DataFrame.max : Return the maximum over the requested axis. DataFrame.idxmin : Return the index of the minimum over the requested axis. DataFrame.idxmax : Return the index of the maximum over the requested axis.a Examples -------- By default, the product of an empty or all-NA Series is ``1`` >>> pd.Series([], dtype="float64").prod() 1.0 This can be controlled with the ``min_count`` parameter >>> pd.Series([], dtype="float64").prod(min_count=1) nan Thanks to the ``skipna`` parameter, ``min_count`` handles all-NA and empty series identically. >>> pd.Series([np.nan]).prod() 1.0 >>> pd.Series([np.nan]).prod(min_count=1) nanzmin_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. c US:XaSnSnSnOSnSnSnUS:Xa[n[n[n[nSS 0n GO7US :Xa[n[n[ n[ nSS 0n GOUS :Xa[nS n[n[nSS0n GOUS:Xa[nSn[n[nSS0n GOUS:Xa[nSn[n[nS[0n GOUS:Xa[nSn[n[nS[0n GOUS:Xa[nSn[nSnSS0n GOoUS:Xa[nSn[nSnSS0n GOSUS:Xa[nSn[ nSnSS0n GO7US:Xa,[nS n["n[$R'US!9nS[(S".n GOUS#:Xa'[nS$nS%n[*R'US!9nS[,S".n OUS&:Xa[nS'n[.nS(nSS0n OUS):Xa[nS*nSnS+nSS0n OUS,:Xa"US:Xa[0nO[2nSnSn[4nS-S0n O~US.:Xa"US:Xa[0nO[2nS/nSn[6nS-S0n OVUS0:Xa"US:Xa[0nO[2nS1nSn[8nS-S 0n O.US2:Xa"US:Xa[0nO[2nS3nSn[:nS-S0n O[<eUR&"S5UUUUUUUS4.U D6n U $)6z: Generate the docstring for a Series/DataFrame reduction. rscalarrz {index (0)}rz{index (0), columns (1)}r empty_valueFalserTruerzReturn the minimum of the values over the requested axis. If you want the *index* of the minimum, use ``idxmin``. This is the equivalent of the ``numpy.ndarray`` method ``argmin``.rrrzReturn the maximum of the values over the requested axis. If you want the *index* of the maximum, use ``idxmax``. This is the equivalent of the ``numpy.ndarray`` method ``argmax``.rzfReturn the sum of the values over the requested axis. This is equivalent to the method ``numpy.sum``.rLz9Return the product of the values over the requested axis.rz8Return the median of the values over the requested axis.a Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.median() 2.0 With a DataFrame >>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra']) >>> df a b tiger 1 2 zebra 2 3 >>> df.median() a 1.5 b 2.5 dtype: float64 Using axis=1 >>> df.median(axis=1) tiger 1.5 zebra 2.5 dtype: float64 In this case, `numeric_only` should be set to `True` to avoid getting an error. >>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']}, ... index=['tiger', 'zebra']) >>> df.median(numeric_only=True) a 1.5 dtype: float64rz6Return the mean of the values over the requested axis.aw Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.mean() 2.0 With a DataFrame >>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra']) >>> df a b tiger 1 2 zebra 2 3 >>> df.mean() a 1.5 b 2.5 dtype: float64 Using axis=1 >>> df.mean(axis=1) tiger 1.5 zebra 2.5 dtype: float64 In this case, `numeric_only` should be set to `True` to avoid getting an error. >>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']}, ... index=['tiger', 'zebra']) >>> df.mean(numeric_only=True) a 1.5 dtype: float64rzyReturn unbiased variance over requested axis. Normalized by N-1 by default. This can be changed using the ddof argument.notesrzReturn sample standard deviation over requested axis. Normalized by N-1 by default. This can be changed using the ddof argument.)name2)r return_descrzReturn unbiased standard error of the mean over requested axis. Normalized by N-1 by default. This can be changed using the ddof argumenta Examples -------- >>> s = pd.Series([1, 2, 3]) >>> round(s.sem(), 6) 0.57735 With a DataFrame >>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra']) >>> df a b tiger 1 2 zebra 2 3 >>> df.sem() a 0.5 b 0.5 dtype: float64 Using axis=1 >>> df.sem(axis=1) tiger 0.5 zebra 0.5 dtype: float64 In this case, `numeric_only` should be set to `True` to avoid getting an error. >>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']}, ... index=['tiger', 'zebra']) >>> df.sem(numeric_only=True) a 0.5 dtype: float64rz=Return unbiased skew over requested axis. Normalized by N-1.a- Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.skew() 0.0 With a DataFrame >>> df = pd.DataFrame({'a': [1, 2, 3], 'b': [2, 3, 4], 'c': [1, 3, 5]}, ... index=['tiger', 'zebra', 'cow']) >>> df a b c tiger 1 2 1 zebra 2 3 3 cow 3 4 5 >>> df.skew() a 0.0 b 0.0 c 0.0 dtype: float64 Using axis=1 >>> df.skew(axis=1) tiger 1.732051 zebra -1.732051 cow 0.000000 dtype: float64 In this case, `numeric_only` should be set to `True` to avoid getting an error. >>> df = pd.DataFrame({'a': [1, 2, 3], 'b': ['T', 'Z', 'X']}, ... index=['tiger', 'zebra', 'cow']) >>> df.skew(numeric_only=True) a 0.0 dtype: float64rzReturn unbiased kurtosis over requested axis. Kurtosis obtained using Fisher's definition of kurtosis (kurtosis of normal == 0.0). Normalized by N-1.a7 Examples -------- >>> s = pd.Series([1, 2, 2, 3], index=['cat', 'dog', 'dog', 'mouse']) >>> s cat 1 dog 2 dog 2 mouse 3 dtype: int64 >>> s.kurt() 1.5 With a DataFrame >>> df = pd.DataFrame({'a': [1, 2, 2, 3], 'b': [3, 4, 4, 4]}, ... index=['cat', 'dog', 'dog', 'mouse']) >>> df a b cat 1 3 dog 2 4 dog 2 4 mouse 3 4 >>> df.kurt() a 1.5 b 4.0 dtype: float64 With axis=None >>> df.kurt(axis=None) -0.9886927196984727 Using axis=1 >>> df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [3, 4], 'd': [1, 2]}, ... index=['cat', 'dog']) >>> df.kurt(axis=1) cat -6.0 dog -6.0 dtype: float64raccum_func_namerrmrrrr)descrname1r axis_descrsee_alsoexamplesrV) _bool_doc _any_desc _any_see_also _any_examples _all_desc _all_see_also _all_examples_num_doc_stat_func_see_alsor~r| _sum_prod_doc _sum_examples_min_count_stub_prod_examples _num_ddof_doc _var_examples _std_examples _std_see_alsor_std_return_desc _sem_see_also_sem_return_desc_skew_see_also_cnum_series_doc _cnum_pd_doc_cumsum_examples_cumprod_examples_cummin_examples_cummax_examplesr) rrrrrbase_docrrrrdocstrs rmake_docr[4s| qy" /  u}  )   (  I ' r"  I ' r"   > ' /  J&!/  I&"Fr" G&"Fr"   K !2    ! ''e'4.>?   & "F!''e'4.>? P!&Nr"   )Tr"   19'H#H##U+   19'H#H$#V,   19'H#H##U+   19'H#H##U+"! __      F Mr)rrrrrr) __future__rrlrrdatetimere functoolsrrrrrirretypingrrr r r r r rrrrnumpyrKpandas._configr pandas._libsrpandas._libs.librpandas._libs.tslibsrrrpandas._typingrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrC pandas.compatrDpandas.compat._constantsrEpandas.compat._optionalrFpandas.compat.numpyrGr= pandas.errorsrHrIrJrKpandas.errors.cowrLpandas.util._decoratorsrMrNpandas.util._exceptionsrOpandas.util._validatorsrPrQrRrSpandas.core.dtypes.astyperTpandas.core.dtypes.castrUpandas.core.dtypes.commonrVrWrXrYrZr[r\r]r^r_r`rarbpandas.core.dtypes.dtypesrcrdrepandas.core.dtypes.genericrfrgpandas.core.dtypes.inferencerhripandas.core.dtypes.missingrjrk pandas.corerlrhrmrnrorprqrrpandas.core.array_algos.replacerspandas.core.arraysrtpandas.core.baserupandas.core.constructionrvpandas.core.flagsrwpandas.core.indexes.apirxryrzr{r|r}pandas.core.internalsr~pandas.core.methods.describerpandas.core.missingrrrpandas.core.reshape.concatrpandas.core.shared_docsrpandas.core.sortingrpandas.core.windowrrrrpandas.io.formats.formatrrpandas.io.formats.printingrcollections.abcrrrrrrrr;rrrrpandas.core.indexers.objectsrrr_shared_doc_kwargs IndexingMixinrrrrrrrr _std_notesrrrrrrrrrrrrrrrrrr|rdr~rrrrrrVrrrs8"    !- ............^3?. =554  =-)2#/9 .034/  9.  ,  `00 EA2lH22EA2PB @! F$ L4 <4 +  < 8!  F , \ $ L"H?B?B?B?B   D L% !(0188%1UV9  ,""56==%!TU> s""56==%!TU> sH O.nr