U
|
¬ý°dr ã @ sþ U d dl mZ d dlZd dlZd dlmZ d dlZd dlm Z d dl
|
Z
|
d dl Z d dl Z d dl mZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dl Z d dl Z d dl Z d dl m!Z!m"Z" d dl#m$Z$ d dl%m&Z& d d l'm(Z(m)Z)m*Z*m+Z+ d d
|
l,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZR d d lSmTZT d d lUmVZW d d lXmYZYmZZZm[Z[m\Z\ d dl]m^Z^ d dl_m`Z` d dlambZbmcZcmdZdmeZemfZf d dlgmhZh d dlimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{ d dl|m}Z}m~Z~ d dlmZmZ d dlmZmZ d dl
mZmZmZmZmZmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d d lmZmZmZmZmZmZmZ d d lm Z m¡Z¡m¢Z¢ d d l£m¤Z¤m¥Z¥ d d l¦m§Z§ d d l¨m©Z©mªZªm«Z« d d!l¬mZ d d"l®m¯Z¯ d d#l°m±Z± d d$l²m³Z³ d d%l´mµZµm¶Z¶m·Z·m¸Z¸ d d&l¹mºZºm»Z» d d'l¼m½Z½ erôd d(l'm¾Z¾ d d)l¿mÀZÀ d d*lÁmÂZÂ d d+lÃmÄZÄ d d,lÅmÆZÆ d d-lÇmÈZÈ e±Z±d.d/d0d1d2d3d4d5ZÉeÊZËG d6d7 d7eejÌZÍd8d9 ZÎd:ZÏd;ZÐd<ZÑd=ZÒd>ZÓd?ZÔd@ZÕdAZÖdBZ×dCZØdDZÙdEZÚdFZÛdGZÜdHZÝdIZÞdJZßdKe±dL< e±dL jàdMdNdOdPdQdRZáeádS7 Záe±dL jàdTdUdQdVdQdRZâdWeãdX< e±dL jàdYdZd d[d dRZädWeãd\< d]Zåd^Zæd_Zçd`d`dadbdcdddeZèdS )fé )Ú annotationsN©Úpartial)Úloads)Ú TYPE_CHECKINGÚAnyÚCallableÚClassVarÚHashableÚIteratorÚLiteralÚMappingÚNoReturnÚSequenceÚTypeÚcastÚfinalÚoverload)ÚconfigÚusing_copy_on_write)Úlib)Úis_range_indexer)ÚPeriodÚTickÚ TimestampÚ to_offset)&Ú AlignJoinÚ AnyArrayLikeÚ ArrayLikeÚAxisÚAxisIntÚCompressionOptionsÚDtypeÚDtypeArgÚ DtypeBackendÚDtypeObjÚFilePathÚ FillnaOptionsÚFloatFormatTypeÚFormattersTypeÚ FrequencyÚ IgnoreRaiseÚ IndexKeyFuncÚ
|
IndexLabelÚIntervalClosedTypeÚJSONSerializableÚLevelÚManagerÚ
|
NaPositionÚNDFrameTÚ RandomStateÚRenamerÚScalarÚSortKindÚStorageOptionsÚSuffixesÚTÚ TimeAmbiguousÚTimedeltaConvertibleTypesÚTimeNonexistentÚTimestampConvertibleTypesÚ ValueKeyFuncÚ WriteBufferÚnpt)Úimport_optional_dependency)Úfunction)ÚAbstractMethodErrorÚInvalidIndexErrorÚSettingWithCopyErrorÚSettingWithCopyWarning)Údoc)Úfind_stack_level)Úcheck_dtype_backendÚvalidate_ascendingÚvalidate_bool_kwargÚvalidate_fillna_kwargsÚvalidate_inclusive)Úastype_is_view)Ú ensure_objectÚensure_platform_intÚ
|
ensure_strÚis_boolÚ is_bool_dtypeÚis_datetime64_any_dtypeÚis_datetime64tz_dtypeÚ is_dict_likeÚis_dtype_equalÚis_extension_array_dtypeÚis_floatÚ is_list_likeÚ is_numberÚis_numeric_dtypeÚis_re_compilableÚ is_scalarÚis_timedelta64_dtypeÚ pandas_dtype)Ú ABCDataFrameÚ ABCSeries)Ú is_hashableÚis_nested_list_like)ÚisnaÚnotna)Ú
|
algorithmsÚ arraylikeÚcommonÚindexingÚnanopsÚsample)Úshould_use_regex)ÚExtensionArray)Ú PandasObject)Ú extract_array)ÚFlags)Ú DatetimeIndexÚIndexÚ
|
MultiIndexÚ PeriodIndexÚ
|
RangeIndexÚ default_indexÚ ensure_index)Ú ArrayManagerÚ BlockManagerÚSingleArrayManager)Ú
|
mgr_to_mgrÚndarray_to_mgr©Údescribe_ndframe)Úclean_fill_methodÚclean_reindex_fill_methodÚfind_valid_index)Úalign_method_FRAME)Úconcat)Ú _shared_docs)Úget_indexer_indexer)Ú ExpandingÚExponentialMovingWindowÚRollingÚWindow)ÚDataFrameFormatterÚDataFrameRenderer)Ú pprint_thing)Ú
|
BaseOffset)Ú DataFrame)Ú BaseIndexer)Ú Resampler©ÚSeries)ÚHDFStorezkeywords for axeszSeries/DataFramezint or labels for objectz)axes to permute (int or label for object)z`
|
inplace : bool, default False
|
If True, performs operation inplace and returns None.zM
|
by : str or list of str
|
Name or list of names to sort byz
|
This differs from updating with ``.loc`` or ``.iloc``, which require
|
you to specify a location to update with some value.)ÚaxesÚklassZaxes_single_argZargs_transposeÚinplaceZ optional_byÚ replace_ilocc s>" e Zd ZU dZdddddddd d
|
d d d dg Zded< eeZded< e Zded< e g Z
|
ded< g Z ded < dZ ded< ded< ded< ded < ddd d d d!d"d#Z eddd$d dd%d&d'Zdd)dd d)d*d+d,Zedd-d.d/Zejd0d d1d2d/Zeed3d-d4d5Zed dd6d)d d7d)d8d9d:Zeed;d-d<d=Zed)d>d?d@dAZeedBdC ZdDZdEZdFedG< dDdDdDdHZ dIedJ< dKedL< dMedN< dKedO< eddPdQdRdSZ eedTdUdVdWdXZ eedTdMdVdYdZZ edTd[dVd\d]Z eedTdUdVd^d_Z!edd`dVdadbZ"edcd-dddeZ#edfd-dgdhZ$ed[d-didjZ%ed[d-dkdlZ&edmd-dndoZ'edpd-dqdrZ(edKd-dsdtZ)edKd-dudvZ*dDddwd)dTd7d)dxdydzZ+edTd d7d{d|d}Z,edUd~d dddZ-edd)dTdTd7d)dddZ.ee/e0d
ddd)ddTd)dddZ1dddddZ2edddddZ3d ddddd dddd)ddddd7d dddd
|
ddZ4e5d
|
ddddddd)ddTd7dd)d d¡d¢Z6e5d ddddd£ddTd7d¤d d¥d¦d¢Z6e5d ddddddd)ddTd7d dd d§d¢Z6e7j8fe7j8e7j8dDdd dd)ddTd7d dd d¨d¢Z6ed dTd d7d{d©dªZ9ed d-d«d¬Z:edd d®d¯d°Z;ed)d)d?d±d²Z<ed)d)d?d³d´Z=ed)d)d?dµd¶Z>ed·d-d¸d¹Z?e?Z@ed d-dºd»ZAed)d)d?d¼d½ZBed)d)d?d¾d¿ZCedd)dKd)dÀdÁdÂZDeddÃdTd dÄdÅdÆZEeddÃdTd dÄdÇdÈZFeddÃdUd dÄdÉdÊZGeddÃdTd dÄdËdÌZHeddÃdUdÍdÄdÎdÏZIeddUddÐdÑZJdÒedÓ< dÔd-dÕdÖZKd[d-d×dØZLdÙdÚ ZMdKd-dÛdÜZNed d-dÝdÞZOed d-dßdàZPdáZQdKedâ< ddãdädådædçZRedèddédédêdëdìZSedíd-dîdïZTed d-dðdñZUdd-dòdóZVedôdõ ZWedöd÷ ZXee/deYdø dùdúddddþdÿd d ddKdKdþd dddd dddZZee/eYdø eYd d ddd dþdþdKd ddd dd ddddþdddZ[eddddddþd dþd dd7dddd dd d Z\edddþd d ddd dþdd! d"d#Z]ee/eYdø eYd d$ dd e^j_dfd%ddKdd d&d'd(Z`edd dþd d)d*d+Zaed,d- Zbe5dd dÿd.d dd/d0d7d d dþd7d7dþdd7dþd7d1dþdþdd2d3d4Zce5d d5dÿd.d dd/d0d7d d dþd7d7dþdd7dþd7d1dþdþd d2d6d4Zced d9dÿd.d dd/d0d7d d dþd7d7dþdd7dþd7d1dþdþdþd2d:d4Zcd dddddd;d<d<d<d<d=d;d>d?Zde5d d ddd@dÿdAd dBddþddddþddþd dþdddddCdDdEZee5d dFddd@dÿdAd dBddþddddþddþd dþdddd dCdGdEZeee/eYdø eYd d dd!d ddd@dÿdAd dBddþddddþddþd dþddddþdCdJdEZed d-dKdLZfd"d d d d dMdNdOZgd d-dPdQZhd#d)dTd)dRdSdTZid$d)dTd d)dUdVdWZjd%d)dTd)dRdXdYZked&d)ddTdd d)dZd[d\Zld]d^ Zmd'd)d_dTd)d`dadbZned(d d d dcdddeZod d-dfdgZped)dd didjdkZqd d-dldmZredndo Zsed*dpdqZteed d-drdsZued+d)dtd7d)dudvdwZve5d,ddddddxddTdddd¤dyd dzd{d|Zwe5d-ddddddd}d)ddTdddddyd)d~ dd|Zwe5d.ddddddd}d)ddTdddd dydd~ dd|Zwd/dDdddd dd}d)ddTdddd dydd~ dd|Zwed0d)dyd d)ddd
Zxed1d d dddZyed2d)ddd)dddZzed3d)ddd)dddZ{e5ddddddddd)dTddddd dd)d ddZ|e5ddddddddTdd¤ddd dd dddZ|e5ddddddddd)dTdd ddd ddd ddZ|dDd(d ddd ddd)dTdd ddd ddd ddZ|e5ddddddddddTddd¤ddd d dd d
|
d¡d¢Z}e5dddddddddd£ d)dTdddddd d dd)d¤ d¥d¢Z}e5dddddddddd£ d)dTddd ddd d ddd¤ d¦d¢Z}dDdd(d ddd(d dd£ d)dTddd ddd d ddd¤ d§d¢Z}e/e0d
düd¨ddddddde~jddf
|
d)ddþd7dd©dd)dªd«d¬Zd)d)d?dd®Zd d-d¯d°Zd±d² Zed4d)d7d d)d³d´dµZd5d)dþdþdd)d¶d·d¸Z
ed6d)dKd)dºd»d¼Zed7d)dKd)dºd½d¾Zed8d)dd¿d dÀdd d)dÁdÂdÃZee/e0d
ddÄdÅdÆdÇdÈZed9d)dþd)dÉdÊdËZddÌdÍdÎZdd dÏdÐdÑZedd- fdÒdÓ ZedÔdÕ Zed d-dÖd×ZedØdÙ Zed d-dÚdÛZed d-dÜdÝZed)d)d?dÞdßZedàdá Zedâdã ZedÍd-dädåZedædç Zd:d)d7dyd)dèdédêZed;d)d7d)dëdìdíZed<d)d d)dëdîdïZed=d)d)d?dðdñZed>d)d7d)dòdódôZed?d)d d d d d död)d÷dødùZe5d@ddddddúd)dûdüdddd=d)dýdþdÿZe5dAddddd dûdüdd¤dd=d dddÿZe5dBddddddúd)dûdüdd dd=ddýddÿZe/f e0dCddd dddúd)dûdüdd dd=ddýddÿZe5dddddd)dddd=d)dd d
|
Ze5dddd dd¤dd=d d d d
|
Ze5dddddd)dd dd=dddd
|
Ze/e0d
ddd dddd)dd dd=dddd
|
Ze/e0d
ddd dddd)dd dd=ddddZ e5dddddd)dddd=d)dddZ¡e5dddd dd¤dd=d d ddZ¡e5dddddd)dd dd=ddddZ¡e/e0d
ddd dddd)dd dd=ddddZ¡e/e0d
ddd dddd)dd dd=ddddZ¢e5dDdddddd)ddd dd)dd d Z£e5dEdddd d¤dd dd d d d Z£e5dFdddddd)d dd dddd!d Z£e/eYd" e0d
e0d# e0d$ d%de7j8fd dd e7j8dd)d dd dddd&d Z£dGdDdd dddd(d)ddTdd dþdþdþdd) d*d+Z¤edHd,d-Z¥e/e0d
dd)d)d?d.d/Z¦e/e¦e0d
dd)d)d?d0d1Z§e/e0d
dd)d)d?d2d3Z¨e/e¨e0d
dd)d)d?d4d5Z©edId d6d7d8Zªed9d: Z«dJdd d;d)dd dd<d=d>Z¬e/f e0dKd)d?düdþd dd)d@dAdBZedLd)d dd)dCdDdEZ®edMd)dGdd)dHdIdJZ¯e/f e0dNdTdþdþddþdÃdÃdMdNd dOdP dQdRZ°ed)d)d?dSdTZ±ed)d)d?dUdVZ²edOd)dTdd dd d d)dYdZd[Z³e/eYd\ e0d
ddPdTd d d_d`dadbZ´e/f e0dQd)d)ddddÃd7ddüddTdd)de dfdgZµedRdddd7dTdhdidjZ¶edSdddd7dTdhdkdlZ·ee7j8d ddfd ddmdndoZ¸e5dTddddpd)dddÃd)dqdrdsZ¹e5dUdddtd¤ddÃd dudvdsZ¹e5dVddddpd)d ddÃddqdwdsZ¹e/e0d
dxdydzd{d|e~jfd dddpd)d ddÃddqd}dsZ¹e5dWddddpd)dddÃd)dqd~dZºe5dXdddtd¤ddÃd duddZºe5dYddddpd)d ddÃddqddZºe/e¹e0d
dydxd{dzd|e7j8fd dddpd)d ddÃddqddZºe/e0d
ddZd)dKdTdd)ddd
Z»d[d)dd7d)dxddZ¼ee/e0d
dd\d)dTd7d)dxddZ½ee/e0d
dd]d)dTd7ddd)dddZ¾ed^d)d)d?ddZ¿ed_d)dKdd)dddZÀed`ddTd d ddddZÁdadTd d ddddZÂdbdTd d ddddZÃedcddd d d¡d¢ZÄdddd d£d¤d¥ZÅdedd d£d¦d§ZÆdfdd d£d¨d©ZÇdgdd d£dªd«ZÈedhddd dKd d¬dd®d¯ZÉdidd dKd d¬d°d±d²ZÊdjdd dKd d¬d°d³d´ZËdkdd dKd d¬d°dµd¶ZÌedlddd d d·d¸d¹ZÍdmdd d dºd»d¼ZÎdndd d dºd½d¾ZÏdodd d d¬d¿dÀdÁZÐdpdd d d¬d¿dÂdÃZÑdqdd d d¬d¿dÄdÅZÒdrdd d d¬d¿dÆdÇZÓeÓZÔedsddd d dKdÈdÉdÊZÕdtdd d dKdËdÌdÍZÖdudd d dKdËdÎdÏZ×e×ZØed d-dÐdÑZÙee/eÚdvdÓdd dþdþdTdþdddÔdÕ
|
dÖd×ZÛee/eÜdwdKdTddØdÙdÚdÛZÝee/eÞdxd¿d¿dÜd¿dd d dTdÝddÞdß dàdáZßedâdã Zàd)d)d?dädåZád)d)d?dædçZâd)d)d?dèdéZãd)d)d?dêdëZäd)d)d?dìdíZåd)d)d?dîdïZæd)d)d?dðdñZçd)d)d?dòdóZèd)d)d?dôdõZéd)d)d?död÷ZêeddødùdúdûZëee/düe0d
dýdød-dþdÿZìee/eìde0d
dýdød-d dZí ZîS (y Ú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
|
Ú_mgrZ_cacherÚ _item_cacheÚ_cacheÚ_is_copyZ_subtypÚ_nameZ _default_kindZ_default_fill_valueÚ _metadataZ__array_struct__Z__array_interface__Ú_flagsz list[str]Ú_internal_nameszset[str]Ú_internal_names_setÚ
|
_accessorszfrozenset[str]Ú _hidden_attrsNz%weakref.ReferenceType[NDFrame] | Noner1 zdict[Hashable, Any]Ú_attrsÚstrÚ_typFÚbool_tz Mapping[Hashable, Any] | NoneÚNone)ÚdataÚcopyÚattrsÚreturnc C sh t | dd ¡ t | d|¡ t | di ¡ |d kr8i }nt|}t | d|¡ t | dt| dd¡ d S )Nr r r r¦ r¡ T)Úallows_duplicate_labels)ÚobjectÚ __setattr__Údictrr )Úselfr« r¬ r © r´ úJd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/generic.pyÚ__init__ s zNDFrame.__init__z Dtype | None)ÚmgrÚdtyper¬ r® c C s | ¡ D ]0\}}|dk rt|}| |¡}|j||d}q|rF| ¡ }|dk rt|tr|t|jdkr|t |jd j
|
j |r|n |j |d}|S )z passed a manager and a axes dictN©Úaxisé r ©r¸ ) Úitemsry Ú_get_block_manager_axisZ reindex_axisr¬ Ú
|
isinstancer{ ÚlenÚblocksrX Úvaluesr¸ Úastype)Úclsr· r r¸ r¬ ÚaZaxeÚbm_axisr´ r´ rµ Ú _init_mgr s"
|
ÿ þý zNDFrame._init_mgrTr3 )r³ Útypr¬ r® c C s t | j||d}| |¡ | ¡S )aö
|
Private helper function to create a DataFrame with specific manager.
|
|
Parameters
|
----------
|
typ : {"block", "array"}
|
copy : bool, default True
|
Only controls whether the conversion from Block->ArrayManager
|
copies the 1D arrays (to ensure proper/contiguous memory layout).
|
|
Returns
|
-------
|
DataFrame
|
New DataFrame using specified manager type. Is not guaranteed
|
to be a copy or not.
|
)rÈ r¬ )r} r Ú _constructorÚ __finalize__)r³ rÈ r¬ Únew_mgrr´ r´ rµ Ú _as_manager9 s zNDFrame._as_manager©r® c C s | j dkri | _ | j S )zý
|
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.
|
N)r¦ ©r³ r´ r´ rµ r R s
|
z NDFrame.attrszMapping[Hashable, Any])Úvaluer® c C s t || _d S ©N)r² r¦ ©r³ rÏ r´ r´ rµ r c s rr c C s | j S )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(allows_duplicate_labels=True)>
|
|
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
|
)r¡ rÎ r´ r´ rµ Úflagsg s 'z NDFrame.flags)r¬ r¯ z bool_t | None)r³ r¬ r¯ r® c C s* | j |ot d}|dk r&||jd< |S )a+
|
Return a new object with updated flags.
|
|
Parameters
|
----------
|
copy : bool, default False
|
Specify if a copy of the object should be made.
|
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
|
©ÚdeepNr¯ )r¬ r rÒ )r³ r¬ r¯ Údfr´ r´ rµ Ú set_flags s 0
|
zNDFrame.set_flagszDtypeObj | Nonec C s0 |dk r,t |}|jdkr,td| j d|S )zvalidate the passed dtypeNÚVz+compound dtypes are not implemented in the z constructor)ra ÚkindÚNotImplementedErrorÚ__name__)rÄ r¸ r´ r´ rµ Ú_validate_dtypeÅ s
|
ÿzNDFrame._validate_dtypezCallable[..., NDFrameT])r³ r® c C s t | dS )zb
|
Used when a manipulation result has the same dimensions as the
|
original.
|
N©rD rÎ r´ r´ rµ rÉ Ø s zNDFrame._constructorc C s | j S rÐ )r rÎ r´ r´ rµ Ú_dataã s z NDFrame._datar Úindexz#list[Literal[('index', 'columns')]]Ú _AXIS_ORDERS)r rÞ Úrowszdict[Axis, AxisInt]Ú_AXIS_TO_AXIS_NUMBERÚintÚ_info_axis_numberz Literal[('index', 'columns')]Ú_info_axis_nameÚ _AXIS_LENzSequence[Axis] | None©r c s& fdd|p j D }| |¡ |S )z%Return an axes dictionary for myself.c s i | ]}| |¡qS r´ ©Ú _get_axis©Ú.0rÅ rÎ r´ rµ Ú
|
<dictcomp>÷ s z0NDFrame._construct_axes_dict.<locals>.<dictcomp>)rß Úupdate)r³ r ÚkwargsÚdr´ rÎ rµ Ú_construct_axes_dictô s
|
z NDFrame._construct_axes_dictr r )rº r® c C s< z | j | W S tk
|
r6 td| d| j Y nX d S )NzNo axis named z for object type )rá ÚKeyErrorÚ
|
ValueErrorrÚ )rÄ rº r´ r´ rµ Ú_get_axis_numberý s zNDFrame._get_axis_numberc C s | |¡}| j| S rÐ )rò rß )rÄ rº Ú axis_numberr´ r´ rµ Ú_get_axis_name s
|
zNDFrame._get_axis_namert c C s* | |¡}|dkst|dkr$| jS | jS )N> r r» r )rò ÚAssertionErrorrÞ Úcolumns)r³ rº ró r´ r´ rµ rè s
|
zNDFrame._get_axisc C s$ | |¡}| j}|dkr d| S |S )z'Map the axis to the block_manager axis.é r» )rò rå )rÄ rº Úndimr´ r´ rµ r¾ s
|
|
z NDFrame._get_block_manager_axisz dict[str, Series | MultiIndex]c C s t | |}i }|d }t|jD ]L\}}|d k r:| }}n| d| }|}| |¡} | ¡ }
|
||
|
_|
|
||< q t|tr~|} n| ¡ } | ||< |S )Nr Zlevel_)ÚgetattrÚ enumerateÚnamesÚget_level_valuesZ to_seriesrÞ r¿ ru ) r³ rº Z
|
axis_indexrî ÚprefixÚiÚnameÚkeyÚlevelZ level_valuesÚsZdindexr´ r´ rµ Ú_get_axis_resolvers s"
|
|
|
|
|
zNDFrame._get_axis_resolversz#dict[Hashable, Series | MultiIndex]c sB ddl m i }| jD ]}| | |¡¡ q fdd| ¡ D S )Nr ©Úclean_column_namec s$ i | ] \}}t |ts ||qS r´ ©r¿ râ ©rê ÚkÚvr r´ rµ rë C s
|
z0NDFrame._get_index_resolvers.<locals>.<dictcomp>)Ú pandas.core.computation.parsingr rß rì r r½ )r³ rî Ú axis_namer´ r rµ Ú_get_index_resolvers; s
|
|
z NDFrame._get_index_resolverszdict[Hashable, Series]c s: ddl m t| tr$ | j| iS fdd| ¡ D S )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`.
|
r r c s$ i | ] \}}t |ts ||qS r´ r r r r´ rµ rë S s
|
z9NDFrame._get_cleaned_column_resolvers.<locals>.<dictcomp>)r
|
r r¿ rc rÿ r½ rÎ r´ r rµ Ú _get_cleaned_column_resolversE s
|
|
ÿz%NDFrame._get_cleaned_column_resolversc C s t | | jS rÐ )rù rä rÎ r´ r´ rµ Ú
|
_info_axisW s zNDFrame._info_axisc C s t | | jS rÐ )rù Ú_stat_axis_namerÎ r´ r´ rµ Ú
|
_stat_axis[ s zNDFrame._stat_axisztuple[int, ...]c s t fdd jD S )z3
|
Return a tuple of axis dimensions
|
c 3 s | ]}t |¡V qd S rÐ ©rÀ rè ré rÎ r´ rµ Ú <genexpr>d s z NDFrame.shape.<locals>.<genexpr>)Útuplerß rÎ r´ rÎ rµ Úshape_ s z NDFrame.shapez list[Index]c s fdd j D S )z?
|
Return index label(s) of the internal NDFrame
|
c s g | ]} |¡qS r´ rç ré rÎ r´ rµ Ú
|
<listcomp>m s z NDFrame.axes.<locals>.<listcomp>)rß rÎ r´ rÎ rµ r f s z NDFrame.axesc C s | j jS )aº
|
Return an int representing the number of axes / array dimensions.
|
|
Return 1 if Series. Otherwise return 2 if DataFrame.
|
|
See Also
|
--------
|
ndarray.ndim : Number of array dimensions.
|
|
Examples
|
--------
|
>>> s = pd.Series({'a': 1, 'b': 2, 'c': 3})
|
>>> s.ndim
|
1
|
|
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
|
>>> df.ndim
|
2
|
)r rø rÎ r´ r´ rµ rø o s z NDFrame.ndimc C s t | j¡S )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
|
--------
|
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
|
)ÚnpÚprodr rÎ r´ r´ rµ Úsize s z NDFrame.size©rº r¬ )r³ rº r¬ r® c C s | j ||d|dS )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 True
|
Whether to make a copy of the underlying data.
|
|
.. versionadded:: 1.5.0
|
|
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.
|
F)r r¬ )Ú_set_axis_nocheck)r³ Úlabelsrº r¬ r´ r´ rµ Úset_axis s $zNDFrame.set_axis©rº r r¬ c C sF |rt | | |¡| n*| j|o&t d}t || |¡| |S d S ©NrÓ )Úsetattrrô r¬ r )r³ r rº r r¬ Úobjr´ r´ rµ r Æ s
|
zNDFrame._set_axis_nocheckzAnyArrayLike | list)rº r r® c C s" t |}| j ||¡ | ¡ dS )z
|
This is called from the cython code when we set the `index` attribute
|
directly, e.g. `series.index = [1, 2, 3]`.
|
N)ry r r Ú_clear_item_cache)r³ rº r r´ r´ rµ Ú _set_axisÓ s zNDFrame._set_axis)r³ Úaxis1Úaxis2r¬ r® c s< |¡} |¡}||kr0j|o*t dS ||||i fddtjD }j ||¡}t rújjrút jt
|
rút ||d |d dddd }t |t
|
s¨t t jt
|
s¸t jj d j|j d _|j d j |j d ¡ |¡jd
|
d S |s
|
|dkr jjr | ¡ }j|f|d dijd
|
d S ) z}
|
Interchange axes and swap values axes appropriately.
|
|
Returns
|
-------
|
same as input
|
rÓ c s g | ]} ||¡¡qS r´ )rè Úget©rê r ©Úmappingr³ r´ rµ r ð s z$NDFrame.swapaxes.<locals>.<listcomp>r r» NFÚblock)r¸ r¬ rÈ Úswapaxes©Úmethodr¬ )rò r¬ r Úrangerå Ú_valuesr* r Úis_single_blockr¿ r{ r~ rõ rÁ ÚrefsZ add_referencerÉ rÊ ) r³ r# r$ r¬ rþ ÚjZnew_axesZ
|
new_valuesrË r´ r' rµ r* Ý sP
|
|
ÿþ
|
ýú ÿÿþü ûzNDFrame.swapaxesr )r r- )r³ r rº r® c C s$ | |¡}| |¡}| j||ddS )aü
|
Return {klass} 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
|
-------
|
{klass}
|
{klass} with requested index / column level(s) removed.
|
|
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
|
Nr )rè Ú droplevelr )r³ r rº r Z
|
new_labelsr´ r´ rµ r2 s =
|
|
zNDFrame.droplevelr
|
z Series | Any)Úitemr® c C s | | }| |= |S rÐ r´ )r³ r3 Úresultr´ r´ rµ ÚpopT s z NDFrame.popú Axis | Noner¹ c s@ |dkrt | jn
|
| |¡f | jt fddt| jD S )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()
|
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()
|
1
|
Nc 3 s2 | ]*\}}| kr"t |d kr"dntdV qdS )r» r N)rÀ Úslice©rê rþ rÅ ræ r´ rµ r Ä s ÿz"NDFrame.squeeze.<locals>.<genexpr>)r- rå rò Úilocr rú r )r³ rº r´ ræ rµ ÚsqueezeZ s h þÿzNDFrame.squeezeÚignore)rÞ rö rº r¬ r r ÚerrorszRenamer | Nonez Level | NonezNDFrameT | None)
|
r³ ÚmapperrÞ rö rº r¬ r r r< r® c s |d kr |d kr |d kr t d|d k s0|d k rR|d k r@t d|d k rnt dn |rj| |¡dkrj|}n|}| |¡ |r| n| j|ot d} t||fD ]Ø\}
|
} | d kr²q | |
|
¡} t | ¡} |d k rØ| |¡}t
|
| sP| j r|d k r| |¡ | ¡ n
|
| | ¡ |dkrPt dk rP fdd t| D }t| d
|
| j| |d }| j||
|
d d d | ¡ q |r| | ¡ d S | j| ddS d S )Nz must pass an index to renameú:Cannot specify both 'axis' and any of 'index' or 'columns'z<Cannot specify both 'mapper' and any of 'index' or 'columns'r» rÓ Úraiseéÿÿÿÿc s g | ]\}} | d kr|qS )r@ r´ )rê rÞ Úlabel©Úindexerr´ rµ r s þz#NDFrame._rename.<locals>.<listcomp>ú not found in axis©r TFr Úrenamer+ )Ú TypeErrorrò Ú*_check_inplace_and_allows_duplicate_labelsr¬ r rú rè rj Úget_rename_functionÚ_get_level_numberÚcallableZ _is_multirü Úget_indexer_forrÀ rð Z_transform_indexr r! Ú_update_inplacerÊ )r³ r= rÞ rö rº r¬ r r r< r4 Zaxis_noÚ replacementsÚaxÚfZmissing_labelsÚ new_indexr´ rB rµ Ú_renameÍ sN ÿÿ
|
|
|
|
|
|
|
þ
|
|
zNDFrame._rename.)rÞ rö rº r¬ r zIndexLabel | lib.NoDefaultzLiteral[False])r³ r= rº r¬ r r® c C s d S rÐ r´ ©r³ r= rÞ rö rº r¬ r r´ r´ rµ Ú rename_axis s zNDFrame.rename_axis)rÞ rö rº r¬ z Literal[True])r= rº r¬ r r® c C s d S rÐ r´ rS r´ r´ rµ rT ! s c C s d S rÐ r´ rS r´ r´ rµ rT . s c s( ||d}|dk r | |¡}t|d}|r4t r4d}|tjk rxt|pVt|oVt| }|rn| j||||dS t dn¬|r| n
|
| j
|
|d} t | j D ]~}| | |¡¡}
|
|
|
tjkr¶qt|
|
pÎt|
|
oÎt|
|
}|rÚ|
|
} n(t |
|
¡ | |¡j} fdd | D } | j| |d
|
|d q|s | S dS dS ) ar
|
Set the name of the axis for the index or columns.
|
|
Parameters
|
----------
|
mapper : scalar, list-like, optional
|
Value to set the axis name attribute.
|
index, columns : scalar, list-like, dict-like or function, optional
|
A scalar, list-like, dict-like or functions transformations to
|
apply to that axis' values.
|
Note that the ``columns`` parameter is not allowed if the
|
object is a Series. This parameter only apply for DataFrame
|
type objects.
|
|
Use either ``mapper`` and ``axis`` to
|
specify the axis to target with ``mapper``, or ``index``
|
and/or ``columns``.
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
The axis to rename. For `Series` this parameter is unused and defaults to 0.
|
copy : bool, default None
|
Also copy underlying data.
|
inplace : bool, default False
|
Modifies the object directly, instead of creating a new Series
|
or DataFrame.
|
|
Returns
|
-------
|
Series, 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
|
--------
|
**Series**
|
|
>>> s = pd.Series(["dog", "cat", "monkey"])
|
>>> s
|
0 dog
|
1 cat
|
2 monkey
|
dtype: object
|
>>> s.rename_axis("animal")
|
animal
|
0 dog
|
1 cat
|
2 monkey
|
dtype: object
|
|
**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
|
©rÞ rö Nr Fr z,Use `.rename` to alter labels with a mapper.rÓ c s g | ] } |qS r´ r´ )rê rÿ ©rP r´ rµ r ä s z'NDFrame.rename_axis.<locals>.<listcomp>T)rò rL r r Ú
|
no_defaultr_ r[ rW Ú_set_axis_namerñ r¬ r- rå r% rô rj rI rè rû ) r³ r= rÞ rö rº r¬ r r Z
|
non_mapperr4 r ZnewnamesZcurnamesr´ rV rµ rT ; sD
|
|
|
|
|
ÿ ÿ
|
|
|
c C sZ | |¡}| |¡ |¡}t|d}|r,| n
|
| j|d}|dkrH||_n||_|sV|S dS )at
|
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.
|
copy:
|
Whether to make a copy of the result.
|
|
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
|
r rÓ r N)rò rè Z set_namesrL r¬ rÞ rö )r³ rÿ rº r r¬ ÚidxZrenamedr´ r´ rµ rX ê s 7
|
|
zNDFrame._set_axis_namec s t fddjD S )Nc 3 s$ | ] } |¡ |¡¡V qd S rÐ )rè Úequalsré ©Úotherr³ r´ rµ r 3 s z(NDFrame._indexed_same.<locals>.<genexpr>)Úallrß ©r³ r\ r´ r[ rµ Ú _indexed_same1 s ÿzNDFrame._indexed_samer° )r\ r® c C s8 t |t| s t | t|s dS tt|}| j |j¡S )a.
|
Test whether two objects contain the same elements.
|
|
This function allows two Series or DataFrames to be compared against
|
each other to see if they have the same shape and elements. NaNs in
|
the same location are considered equal.
|
|
The row/column index do not need to have the same type, as long
|
as the values are considered equal. Corresponding columns must be of
|
the same dtype.
|
|
Parameters
|
----------
|
other : Series or DataFrame
|
The other Series or DataFrame to be compared with the first.
|
|
Returns
|
-------
|
bool
|
True if all elements are the same in both objects, False
|
otherwise.
|
|
See Also
|
--------
|
Series.eq : Compare two Series objects of the same length
|
and return a Series where each element is True if the element
|
in each Series is equal, False otherwise.
|
DataFrame.eq : Compare two DataFrame objects of the same shape and
|
return a DataFrame where each element is True if the respective
|
element in each DataFrame is equal, False otherwise.
|
testing.assert_series_equal : Raises an AssertionError if left and
|
right are not equal. Provides an easy interface to ignore
|
inequality in dtypes, indexes and precision among others.
|
testing.assert_frame_equal : Like assert_series_equal, but targets
|
DataFrames.
|
numpy.array_equal : Return True if two arrays have the same shape
|
and elements, False otherwise.
|
|
Examples
|
--------
|
>>> 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
|
F)r¿ Útyper r r rZ r^ r´ r´ rµ rZ 7 s O
|
zNDFrame.equalsc C s2 dddd}| j |¡}| |¡}|j| ddS )Nr ©r c S s" t | jrt | ¡S t | ¡S d S rÐ )rT r¸ ÚoperatorÚinvÚnegra r´ r´ rµ Úblk_func s
|
|
z!NDFrame.__neg__.<locals>.blk_funcÚ__neg__r+ ©r ÚapplyrÉ rÊ ©r³ re Únew_dataÚresr´ r´ rµ rf s
|
zNDFrame.__neg__c C s2 dddd}| j |¡}| |¡}|j| ddS )Nr ra c S s t | jr| ¡ S t | ¡S d S rÐ )rT r¸ r¬ rb Úposra r´ r´ rµ re ¢ s
|
z!NDFrame.__pos__.<locals>.blk_funcÚ__pos__r+ rg ri r´ r´ rµ rm s
|
zNDFrame.__pos__c C s4 | j s| jddS | j tj¡}| |¡j| ddS )NFrÓ Ú
|
__invert__r+ )r r¬ r rh rb ÚinvertrÉ rÊ )r³ rj r´ r´ rµ rn ¯ s zNDFrame.__invert__r c C s t dt| j dd S )NzThe truth value of a zC is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().)rñ r` rÚ rÎ r´ r´ rµ Ú __nonzero__¸ s ÿzNDFrame.__nonzero__c C sH | ¡ }t|ttjfr t|S t|r<tdt| j | ¡ dS )a"
|
Return the bool of a single element Series or DataFrame.
|
|
This must be a boolean scalar value, either True or False. It will raise a
|
ValueError if the Series or DataFrame does not have exactly 1 element, or that
|
element is not boolean (integer values 0 and 1 will also raise an exception).
|
|
Returns
|
-------
|
bool
|
The value in the Series or DataFrame.
|
|
See Also
|
--------
|
Series.astype : Change the data type of a Series, including to boolean.
|
DataFrame.astype : Change the data type of a DataFrame, including to boolean.
|
numpy.bool_ : NumPy boolean data type, used by pandas for boolean values.
|
|
Examples
|
--------
|
The method will only work for single element objects with a boolean value:
|
|
>>> pd.Series([True]).bool()
|
True
|
>>> pd.Series([False]).bool()
|
False
|
|
>>> pd.DataFrame({'col': [True]}).bool()
|
True
|
>>> pd.DataFrame({'col': [False]}).bool()
|
False
|
z0bool cannot act on a non-boolean single element T)
|
r: r¿ Úboolr Úbool_r_ rñ r` rÚ rp )r³ r r´ r´ rµ rq Á s "ÿz NDFrame.boolc C s" | j tj¡}| |¡j| ddS )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[ns]
|
|
Select rows with data closest to certain value using argsort (from
|
`StackOverflow <https://stackoverflow.com/a/17758115>`__).
|
|
>>> 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
|
Úabs©rÿ )r rh r rs rÉ rÊ )r³ Zres_mgrr´ r´ rµ rs ð s Dz NDFrame.absc C s | ¡ S rÐ )rs rÎ r´ r´ rµ Ú__abs__7 s zNDFrame.__abs__)r³ Údecimalsr® c C s | |¡j| ddS )NÚ __round__r+ )ÚroundrÊ )r³ rv r´ r´ rµ rw ; s zNDFrame.__round__r0 )r rº r® c C s: | |¡}|dk o8t|o8|| j| jko8| j||d S )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¹ )rò rd r rû Ú_is_label_reference)r³ r rº Úaxis_intr´ r´ rµ Ú_is_level_referenceG s
|
ÿþüzNDFrame._is_level_referencec sJ |¡ fddtjD }dk oHtoHtfdd|D S )aR
|
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
|
c 3 s | ]}| kr|V qd S rÐ r´ ©rê rO ©rz r´ rµ r | s z.NDFrame._is_label_reference.<locals>.<genexpr>Nc 3 s | ]} j | kV qd S rÐ ræ r| ©r r³ r´ rµ r s )rò r- rå rd Úany)r³ r rº Ú
|
other_axesr´ ©rz r r³ rµ ry f s
|
ÿýzNDFrame._is_label_referencec C s | j ||dp| j||dS )a8
|
Test whether a key is a label or level reference for a given axis.
|
|
To be considered either a label or a level reference, `key` must be a
|
string that:
|
- (axis=0): Matches a column label or an index level
|
- (axis=1): Matches an index label or a column level
|
|
Parameters
|
----------
|
key : Hashable
|
Potential label or level name
|
axis : int, default 0
|
Axis that levels are associated with (0 for index, 1 for columns)
|
|
Returns
|
-------
|
bool
|
r¹ )r{ ry )r³ r rº r´ r´ rµ Ú _is_label_or_level_reference s ÿz$NDFrame._is_label_or_level_referencec s² |¡ fddtjD }dk r®tr®j jkr®tfdd|D r® dkrfdnd\}} dkrzdnd\}}d d | d
|
| d | d
|
| d }t|dS ) a¼
|
Check whether `key` is ambiguous.
|
|
By ambiguous, we mean that it matches both a level of the input
|
`axis` and a label of the other axis.
|
|
Parameters
|
----------
|
key : Hashable
|
Label or level name.
|
axis : int, default 0
|
Axis that levels are associated with (0 for index, 1 for columns).
|
|
Raises
|
------
|
ValueError: `key` is ambiguous
|
c 3 s | ]}| kr|V qd S rÐ r´ r| r} r´ rµ r ² s z:NDFrame._check_label_or_level_ambiguity.<locals>.<genexpr>Nc 3 s | ]} j | kV qd S rÐ ræ r| r~ r´ rµ r ¸ s r )ZanrÞ )rÅ Úcolumnú'z
|
' is both ú z level and z label, which is ambiguous.)rò r- rå rd r rû r rñ ) r³ r rº r Z level_articleZ
|
level_typeZ label_articleZ
|
label_typeÚmsgr´ r rµ Ú _check_label_or_level_ambiguity s"
|
ÿþýüÿÿ"ÿz'NDFrame._check_label_or_level_ambiguityr c sØ | ¡ fddt| jD }| j| drT| j| d | j||d dj}n*| j| drv| j |¡j}nt
|
||j dkrÔ|r¦t | |d ¡tr¦d}nd} dkr¶dnd }td
|
| d | d | |S ) 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
|
c s g | ]}| kr|qS r´ r´ r| r¹ r´ rµ r ê s z6NDFrame._get_label_or_level_values.<locals>.<listcomp>r¹ r r» zX
|
For a multi-index, the label must be a tuple with elements corresponding to each level.Ú r rÞ zThe z label 'z' is not unique.)rò r- rå ry r Úxsr. r{ r rü rð rø r¿ rè ru rñ )r³ r rº r r Z multi_messageZlabel_axis_namer´ r¹ rµ Ú_get_label_or_level_valuesÉ s$
|
|
ÿÿz"NDFrame._get_label_or_level_valuesc sì ¡ t |¡} fdd|D }|r@td d| fdd|D } fdd|D }jdd} d kr¦|r|j|d
|
d
|
d |rè|j|d d
|
d nB|rÔt|jt rÆ|j
|
|¡|_nt |jj |_|rè|j|d d
|
d |S )a
|
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
|
c s g | ]}j | d s|qS ©r¹ )r r& ©rº r³ r´ rµ r % s z2NDFrame._drop_labels_or_levels.<locals>.<listcomp>z;The following keys are not valid labels or levels for axis z: c s g | ]}j | d r|qS r ©r{ r& r r´ rµ r 0 s c s g | ]}j | d s|qS r r r& r r´ rµ r 2 s FrÓ r T)Údropr r» ©rº r ) rò rj Zmaybe_make_listrñ r¬ Z reset_indexr r¿ rö ru r2 rw r )r³ Úkeysrº Z invalid_keysZlevels_to_dropZlabels_to_dropZdroppedr´ r rµ Ú_drop_labels_or_levels s0
|
|
ÿÿ z NDFrame._drop_labels_or_levelszClassVar[None]Ú__hash__r c C s
|
t | jS )z~
|
Iterate over info axis.
|
|
Returns
|
-------
|
iterator
|
Info axis as iterator.
|
)Úiterr rÎ r´ r´ rµ Ú__iter__Z s zNDFrame.__iter__c C s | j S )z¾
|
Get the 'info axis' (see Indexing for more).
|
|
This is index for Series, columns for DataFrame.
|
|
Returns
|
-------
|
Index
|
Info axis.
|
©r rÎ r´ r´ rµ r f s z NDFrame.keysc c s | j D ]}|| | fV qdS )z«
|
Iterate over (label, values) on info axis
|
|
This is index for Series and columns for DataFrame.
|
|
Returns
|
-------
|
Generator
|
Nr )r³ Úhr´ r´ rµ r½ s s
|
|
z NDFrame.itemsc C s
|
t | jS )zReturns length of info axis)rÀ r rÎ r´ r´ rµ Ú__len__ s zNDFrame.__len__c C s
|
|| j kS )z#True if the key is in the info axisr )r³ r r´ r´ rµ Ú __contains__ s zNDFrame.__contains__c s t fdd jD S )aË
|
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
|
c 3 s | ]}t |¡d kV qdS )r Nr ré rÎ r´ rµ r à s z NDFrame.empty.<locals>.<genexpr>)r rß rÎ r´ rÎ rµ Úempty s :z NDFrame.emptyiè Ú__array_priority__znpt.DTypeLike | Nonez
|
np.ndarray)r¸ r® c C sf | j }tj||d}t|j|jrbt rb| jjrbt| jj d |jrbt|j|jrb|
|
¡ }d|j _ |S )Nr¼ r F) r. r ÚasarrayrO r¸ r r r/ Údtypesr9 ÚviewrÒ Z writeable)r³ r¸ r Zarrr´ r´ rµ Ú __array__Ì s ÿþý ÿzNDFrame.__array__znp.ufuncr )Úufuncr, Úinputsrí c O s t j| ||f||S rÐ )ri Z array_ufunc)r³ r r, r rí r´ r´ rµ Ú__array_ufunc__Ü s zNDFrame.__array_ufunc__zdict[str, Any]c sB fdd j D } j j j j fdd jjD d|S )Nc s i | ]}|t |d qS rÐ )rù r& rÎ r´ rµ rë ç s z(NDFrame.__getstate__.<locals>.<dictcomp>c s i | ]}| j | qS r´ )rÒ r& rÎ r´ rµ rë í s )r r¨ r r r¡ )r r r¨ r rÒ Ú_keys)r³ Úmetar´ rÎ rµ Ú __getstate__å s ûúzNDFrame.__getstate__c C s( t |tr|| _n
|
t |trd|kr>d|kr>| d¡|d< | d¡}|d k rþ| di ¡}t | d|¡ | dddi¡}t | dt| f|¡ t | j
|
| j }t |D ]*}||kr¨|dkr¨|| }t | ||¡ q¨| ¡ D ] \}}||krÜt | ||¡ qÜntdnt|d kr tdi | _d S )
|
NrÝ r r¨ r¦ r¡ r¯ Tz(Pre-0.12 pickles are no longer supportedr÷ )r¿ r{ r r² r5 r% r° r± rr Úsetr¢ r Úlistr½ rÙ rÀ r )r³ ÚstaterÈ r rÒ r£ r r r´ r´ rµ Ú __setstate__ñ s.
|
|
|
|
zNDFrame.__setstate__c C s. dd tt| ¡ d}t| j d| dS )Nú[ú,ú]ú(ú))ÚjoinÚmapr r` rÚ )r³ Zpreprr´ r´ rµ Ú__repr__ s zNDFrame.__repr__c C s t d¡dkr| ¡ S dS dS )z
|
Returns a LaTeX representation for a particular object.
|
Mainly for use with nbconvert (jupyter notebook conversion to pdf).
|
zstyler.render.reprÚlatexN)r Ú
|
get_optionÚto_latexrÎ r´ r´ rµ Ú _repr_latex_ s zNDFrame._repr_latex_c C sB t d¡r>| t d¡¡}|jdd}tt|}t|tjdS dS )zh
|
Not a real Jupyter special repr method, but we use the same
|
naming convention.
|
zdisplay.html.table_schemazdisplay.max_rowsÚtable)Úorient)Úobject_pairs_hookN) r r² ÚheadÚto_jsonr r§ r Ú collectionsÚ OrderedDict)r³ r« Zas_jsonr´ r´ rµ Ú_repr_data_resource_) s
|
|
|
z NDFrame._repr_data_resource_Ústorage_optionsz1.2.0)r r½ Z storage_options_versionaddedÚSheet1r Úinfz
|
str | NonezSequence[Hashable] | NonezSequence[Hashable] | bool_tztuple[int, int] | Noner8 )Ú
|
sheet_nameÚna_repÚ float_formatrö ÚheaderrÞ Ú index_labelÚstartrowÚstartcolÚengineÚ merge_cellsÚinf_repÚ freeze_panesr½ r® c C sX t | tr| n| ¡ }ddlm} ||||||||| | d }|j||| |
|
|| |d dS )aG
|
Write {klass} to an Excel sheet.
|
|
To write a single {klass} 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 result in the contents of the existing file being erased.
|
|
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, default True
|
Write MultiIndex and Hierarchical Rows as merged cells.
|
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}
|
|
.. versionadded:: {storage_options_versionadded}
|
|
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.
|
|
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
|
... df.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
|
r )ÚExcelFormatter)rÁ Úcolsrà r rÞ rÄ rÈ rÉ )rÀ rÅ rÆ rÊ rÇ r½ N)r¿ rb Úto_frameZpandas.io.formats.excelrË Úwrite)r³ Z excel_writerrÀ rÁ r rö rà rÞ rÄ rÅ rÆ rÇ rÈ rÉ rÊ r½ rÕ rË Ú formatterr´ r´ rµ Úto_excel9 s. ÷ ùzNDFrame.to_excelÚcompression_optionsÚ path_or_buf)r½ rÑ é
|
ÚmsÚinferÚwz7FilePath | WriteBuffer[bytes] | WriteBuffer[str] | Nonez(Callable[[Any], JSONSerializable] | Noner! z
|
int | NonezLiteral[('a', 'w')])rÒ r¶ Ú date_formatÚdouble_precisionÚ force_asciiÚ date_unitÚdefault_handlerÚlinesÚ compressionrÞ Úindentr½ Úmoder® c C sf ddl m} |dkr"|dkr"d}n |dkr.d}t | ¡ | p>d} |j|| |||||||| |
|
| | | dS )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'.
|
double_precision : int, default 10
|
The number of decimal places to use when encoding
|
floating point values.
|
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_options}
|
|
.. versionchanged:: 1.4.0 Zstandard support.
|
|
index : bool, default True
|
Whether to include the index values in the JSON string. Not
|
including the index (``index=False``) is only supported when
|
orient is 'split' or 'table'.
|
indent : int, optional
|
Length of whitespace used to indent each record.
|
|
{storage_options}
|
|
.. versionadded:: 1.2.0
|
|
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 )ÚjsonNrµ ZisoÚepoch)rÒ r r¶ r× rØ rÙ rÚ rÛ rÜ rÝ rÞ rÞ r½ rß )Ú pandas.iorà r Zis_nonnegative_intr¹ )r³ rÒ r¶ r× rØ rÙ rÚ rÛ rÜ rÝ rÞ rÞ r½ rß rà r´ r´ rµ r¹ Ö s2
|
òzNDFrame.to_jsonrÅ ÚstrictúUTF-8zFilePath | HDFStorezint | dict[str, int] | Nonez Literal[True] | list[str] | None)rÒ r rß Ú complevelÚcomplibÚappendÚformatrÞ Ú min_itemsizeÚdropnaÚ data_columnsr< Úencodingr® c C s8 ddl m} |j||| ||||||| |
|
| | | |d dS )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 <io.hdf5>`.
|
|
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.
|
As of v0.20.2 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<io.hdf5-query-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"
|
|
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 )Úpytables) rß rå ræ rç rè rÞ ré Únan_reprê rë r< rì N)râ rí Úto_hdf)r³ rÒ r rß rå ræ rç rè rÞ ré rî rê rë r< rì rí r´ r´ rµ rï õ s& ñzNDFrame.to_hdfÚfailz&Literal[('fail', 'replace', 'append')]zDtypeArg | None) rÿ ÚschemaÚ if_existsrÞ rÄ Ú chunksizer¸ r, r® c
|
C s* ddl m}
|
|
|
j| ||||||||| d
|
S )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.
|
|
Parameters
|
----------
|
name : str
|
Name of SQL table.
|
con : sqlalchemy.engine.(Engine or Connection) or sqlite3.Connection
|
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 <https://docs.sqlalchemy.org/en/20/core/connections.html>`_.
|
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'}, 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.
|
|
index : bool, default True
|
Write DataFrame index as a column. Uses `index_label` as the column
|
name in the table.
|
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 at a time.
|
By default, all rows will be written at once.
|
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 <io.sql.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 <https://docs.python.org/3/library/sqlite3.html#sqlite3.Cursor.rowcount>`__ or
|
`SQLAlchemy <https://docs.sqlalchemy.org/en/20/core/connections.html#sqlalchemy.engine.CursorResult.rowcount>`__.
|
|
.. versionadded:: 1.4.0
|
|
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.
|
|
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('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('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('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('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')]
|
|
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('integers', con=engine, index=False,
|
... dtype={"A": Integer()})
|
3
|
|
>>> with engine.connect() as conn:
|
... conn.execute(text("SELECT * FROM integers")).fetchall()
|
[(1,), (None,), (2,)]
|
r )Úsql)rñ rò rÞ rÄ ró r¸ r, )râ rô Úto_sql) r³ rÿ Úconrñ rò rÞ rÄ ró r¸ r, rô r´ r´ rµ rõ
|
s 1 özNDFrame.to_sqlÚpathz FilePath | WriteBuffer[bytes])r÷ rÝ Úprotocolr½ r® c C s" ddl m} || ||||d dS )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_options}
|
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}
|
|
.. versionadded:: 1.2.0
|
|
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_pickle)rÝ rø r½ N)Zpandas.io.picklerù )r³ r÷ rÝ rø r½ rù r´ r´ rµ rù K s > ûzNDFrame.to_pickle)ÚexcelÚsepr® c K s( ddl m} |j| f||d| dS )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 )Ú
|
clipboards)rú rû N)râ rü Ú to_clipboard)r³ rú rû rí rü r´ r´ rµ rý s E zNDFrame.to_clipboardc C s. t d}| jdkr |j | ¡S |j | ¡S dS )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 <https://xarray.pydata.org/en/stable/>`__
|
|
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()
|
<xarray.Dataset>
|
Dimensions: (index: 4)
|
Coordinates:
|
* index (index) int64 0 1 2 3
|
Data variables:
|
name (index) object 'falcon' 'parrot' 'lion' 'monkey'
|
class (index) object 'bird' 'bird' 'mammal' 'mammal'
|
max_speed (index) float64 389.0 24.0 80.5 nan
|
num_legs (index) int64 2 2 4 4
|
|
>>> df['max_speed'].to_xarray()
|
<xarray.DataArray 'max_speed' (index: 4)>
|
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()
|
<xarray.Dataset>
|
Dimensions: (date: 2, animal: 2)
|
Coordinates:
|
* date (date) datetime64[ns] 2018-01-01 2018-01-02
|
* animal (animal) object 'falcon' 'parrot'
|
Data variables:
|
speed (date, animal) int64 350 18 361 15
|
Úxarrayr» N)rB rø Z DataArrayZ from_seriesZDatasetZfrom_dataframe)r³ rþ r´ r´ rµ Ú to_xarrayÜ s M
|
zNDFrame.to_xarrayzbool_t | Sequence[str]zFormattersType | NonezFloatFormatType | Nonez str | tuple[str, str] | None)Úbufrö rà rÞ rÁ Ú
|
formattersr ÚsparsifyÚ index_namesÚ bold_rowsÚ column_formatÚ longtableÚescaperì ÚdecimalÚ multicolumnÚmulticolumn_formatÚmultirowÚcaptionrA Úpositionr® c C s d S rÐ r´ ©r³ r rö rà rÞ rÁ r r r r r r r r rì r r r
|
r r rA r r´ r´ rµ r³ 0 s zNDFrame.to_latexzFilePath | WriteBuffer[str]c C s d S rÐ r´ r r´ r´ rµ r³ K s ÚNaNÚ.z"FilePath | WriteBuffer[str] | Nonec # s4 | j dkr| ¡ } | dkr(t d¡dk} | dkr>t d¡dk} |dkrPt d¡}|dkrbt d¡}|dkrtt d ¡}| dk rt| tstd
|
dkr t| jnt}t|t t
|
frÜt||krÜtd | d t| d || rædnd|d}ddi|}ddi|}ttr"fddnfdd d}tt r^ fddt | jD }n´tt rî dd¡} dd¡} |dk r| d|i¡ | dk r²| d| i¡ }| jddj} | D ]"} | ¡ krÈ| | i¡ qÈn$dkrdk rt d d d }||g} g } g }!rH| fd d | jD d d!¡ |d"krb| dd i¡ n&t|t t
|
fr|! |d d#¡ |g} |d"kr | dd$i¡ | d"krº| d%d$d&¡ d%||| rÊdnd|rÖ|nd'| |rèd(nd)||||| |r t| jtr d*nd|
|
d+ }"| j|| |!d|i|| |"d,S )-a6
|
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:: 1.2.0
|
Added position argument, changed meaning of caption argument.
|
|
.. 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.
|
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
|
<https://en.wikibooks.org/wiki/LaTeX/Tables>`__ 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.
|
|
.. versionchanged:: 1.2.0
|
Optionally allow caption to be a tuple ``(full_caption, short_caption)``.
|
|
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.
|
|
.. versionadded:: 1.2.0
|
|
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}
|
r» Nzstyler.latex.environmentr zstyler.format.escaper± zstyler.sparse.columnszstyler.latex.multicol_alignzstyler.sparse.indexz&`column_format` must be str or unicodezWriting z cols but got z aliases)rÁ r r rº r c s | S rÐ r´ ©Úx)r r´ rµ Ú<lambda>9 ó z"NDFrame.to_latex.<locals>.<lambda>c s* t | ttfr d k r | S || S d S rÐ )r¿ ÚfloatÚcomplex)r Ú alt_format_)Ú float_format_r´ rµ Ú_wrap= s z NDFrame.to_latex.<locals>._wrapc s" i | ]\}}|t | d qS )©r r )rê rþ Úc)r r r´ rµ rë E s ÿ z$NDFrame.to_latex.<locals>.<dictcomp>Ú __index__Z __columns__rÏ r )Úincludec S s | S rÐ r´ ©r r´ r´ rµ r W r r c s g | ]}| kr|qS r´ r´ ©rê r )rö r´ rµ r ` s z$NDFrame.to_latex.<locals>.<listcomp>rö )Úsubsetrº F)r rº rÞ T)rû rº znaive-ÚtZnaivezskip-last;data) ZhrulesZ sparse_indexZsparse_columnsÚ environmentZmulticol_alignZmultirow_alignrì r rA r r Zclinesr ©ÚhideÚ relabel_indexrè Ú format_indexÚ render_kwargs)rø rÍ r r² r¿ r§ rñ rÀ rö r¦ r rú r² r5 rì Z select_dtypesr r rç rÞ ru Ú_to_latex_via_styler)#r³ r rö rà rÞ rÁ r r r r r r r r rì r r r
|
r r rA r ÚlengthZ base_format_Z index_format_Zcolumn_format_Z formatters_Zindex_formatterZcolumn_formatterZ float_columnsÚcolZ format_index_Zhide_Zrelabel_index_Zrender_kwargs_r´ )r rö r r r rµ r³ f sº 7
|
|
|
|
|
ý þ
|
|
þÿ
|
|
|
ÿ ÿ
|
ÿï
|
úr# zdict | list[dict] | Nonez dict | Nonec C s² ddl m} td| } || dd}dD ]N} t | }
|
t|
|
trPt|| f |
|
q&t|
|
tr&|
|
D ]} t|| f | q^q&|dkri n|}| d¡r| d d
|
¡ |j
|
f d |i|S ) 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 )ÚStylerr r )Úuuid)r$ r% rè r& Nr c S s dS )Nztextbf:--rwrap;r´ r r´ r´ rµ r Ë r z.NDFrame._to_latex_via_styler.<locals>.<lambda>r ) Zpandas.io.formats.styler+ r Úvarsr¿ r² rù r¦ r5 Zapplymap_indexr³ ) r³ r r$ r% rè r& r' r+ ZstylerZkw_nameÚkwZsub_kwr´ r´ rµ r( s /
|
|
|
|
|
z NDFrame._to_latex_via_stylerzstr | Callable | Nonezbool_t | list[str]zIndexLabel | None)rÒ rû rÁ r rö rà rÞ rÄ rß rì rÝ ÚquotingÚ quotecharÚlineterminatorró r× Ú doublequoteÚ
|
escapecharr r< r½ r® c C s d S rÐ r´ ©r³ rÒ rû rÁ r rö rà rÞ rÄ rß rì rÝ r/ r0 r1 ró r× r2 r3 r r< r½ r´ r´ rµ Úto_csvÏ s zNDFrame.to_csvz0FilePath | WriteBuffer[bytes] | WriteBuffer[str]c C s d S rÐ r´ r4 r´ r´ rµ r5 ê s rª ú"c C sX t | tr| n| ¡ }t||||||d}t|j||||
|
|| | ||| || ||||dS )aÈ
|
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'`.
|
|
.. versionchanged:: 1.2.0
|
|
Support for binary file objects was introduced.
|
|
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 : str, default 'w'
|
Python write mode. The available write modes are the same as
|
:py:func:`open`.
|
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_options}
|
|
.. versionchanged:: 1.0.0
|
|
May now be a dict with key 'method' as compression mode
|
and other entries as additional compression options if
|
compression mode is 'zip'.
|
|
.. versionchanged:: 1.1.0
|
|
Passing compression options as keys in dict is
|
supported for compression modes 'gzip', 'bz2', 'zstd', and 'zip'.
|
|
.. versionchanged:: 1.2.0
|
|
Compression is supported for binary file objects.
|
|
.. versionchanged:: 1.2.0
|
|
Previous versions forwarded dict entries for 'gzip' to
|
`gzip.open` instead of `gzip.GzipFile` which prevented
|
setting `mtime`.
|
|
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.).
|
|
.. versionchanged:: 1.5.0
|
|
Previously was line_terminator, changed for consistency with
|
read_csv and the standard library 'csv' module.
|
|
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.
|
|
.. versionadded:: 1.1.0
|
|
{storage_options}
|
|
.. versionadded:: 1.2.0
|
|
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
|
--------
|
>>> df = pd.DataFrame({{'name': ['Raphael', 'Donatello'],
|
... 'mask': ['red', 'purple'],
|
... 'weapon': ['sai', 'bo staff']}})
|
>>> df.to_csv(index=False)
|
'name,mask,weapon\nRaphael,red,sai\nDonatello,purple,bo staff\n'
|
|
Create 'out.zip' containing 'out.csv'
|
|
>>> 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
|
)Úframerà rÞ rÁ r r )r1 rû rì r< rÝ r/ rö rÄ rß ró r0 r× r2 r3 r½ )r¿ rb rÍ r r r5 )r³ rÒ rû rÁ r rö rà rÞ rÄ rß rì rÝ r/ r0 r1 ró r× r2 r3 r r< r½ rÕ rÏ r´ r´ rµ r5 s8 -ú ðc C s t | dS )z#
|
Reset the cacher.
|
NrÜ rÎ r´ r´ rµ Ú _reset_cacherÒ s zNDFrame._reset_cacher)ÚclearÚverify_is_copyr r® c C s* t r
|
dS |r| jdd |r&| ¡ dS )a!
|
See if we need to update our parent cacher if clear, then clear our
|
cache.
|
|
Parameters
|
----------
|
clear : bool, default False
|
Clear the item cache.
|
verify_is_copy : bool, default True
|
Provide is_copy checks.
|
NÚreferent©r! )r Ú_check_setitem_copyr! )r³ r9 r: r r´ r´ rµ Ú_maybe_update_cacherØ s z NDFrame._maybe_update_cacherc C s t | d S rÐ rÜ rÎ r´ r´ rµ r! ò s zNDFrame._clear_item_cache)r³ rº r® c K s t d|¡ | ||¡S )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', None}, 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
|
r´ )ÚnvZ validate_takeÚ_take)r³ Úindicesrº rí r´ r´ rµ Útakeø s K z NDFrame.take)r³ rº Úconvert_indicesr® c C sz t |tsLtj|tjd}|dkrL|jdkrLt rLt|t| rL| j ddS | j
|
j || |¡d|d}| |¡j| dd S )
|
z¨
|
Internal version of the `take` allowing specification of additional args.
|
|
See the docstring of `take` for full explanation of the parameters.
|
r¼ r r» NrÓ T)rº ÚverifyrC rB r+ )r¿ r7 r r Zintprø r r rÀ r¬ r rB r¾ rÉ rÊ )r³ rA rº rC rj r´ r´ rµ r@ G s$
|
ÿþý ü üz NDFrame._takec C s2 | j ||d}| |¡ | |¡¡s.| | ¡ |S )a
|
Internal version of the `take` method that sets the `_is_copy`
|
attribute to keep track of the parent dataframe (using in indexing
|
for the SettingWithCopyWarning).
|
|
See the docstring of `take` for full explanation of the parameters.
|
)rA rº )r@ rè rZ Ú _set_is_copy)r³ rA rº r4 r´ r´ rµ Ú_take_with_is_copyd s
|
zNDFrame._take_with_is_copy)r³ r rº r Ú
|
drop_levelr® c C s | |¡}| |¡}t|tr&td|dk rt|ts@td|j|||d\}}tdg| j }|||< t |} | j
|
| }
|
t |
|
|
|
|¡| |
|
S |dkr°|r¨| | S | j } n| j} t| trü| j|dd\}} |sút |¡rò| ||d
} n| | } n^| |¡}t|tjrH|jtjkr:| ¡ \} | j| |dS | j||dS t|sZ| | } t|r¬|dkr¬| jdkr| j| S | j |¡}| j || j| d | ¡}
|
nVt|rÔ| j
|
dd
t||d f }
|
n.|dkrò| j
|
dd
|f }
|
n| j
|
| }
|
| |
|
_|
|
j | |
|
j d
|
|
|
S ) aQ
|
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 <advanced.mi_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 rG r» r rE r¹ rt ©r¬ )!rò rè r¿ r¦ rG ru Z get_loc_levelr7 rø r r9 r rô rö rÞ Z_get_loc_levelr Ú
|
is_integerÚget_locr Úndarrayr¸ rr ÚnonzerorF r_ r. r Zfast_xsÚ_constructor_slicedrÊ rE Ú_is_view)r³ r rº r rG r ÚlocÚnew_axZ_indexerrC r4 rÞ rQ ZindsrË r´ r´ rµ r r sf j
|
|
|
|
|
|
|
|
|
|
|
|
ÿþ
|
|
|
z
|
NDFrame.xsc C s t | d S rÐ rÜ )r³ r3 r´ r´ rµ Ú __getitem__% s zNDFrame.__getitem__r7 )r³ Úslobjrº r® c C s` t |tstt|| |¡}| | jj||d¡}| | ¡}|dkpL|j }|j
|
| |d |S )zp
|
Construct a slice of this container.
|
|
Slicing with this method is *always* positional.
|
r¹ r rH ) r¿ r7 rõ r` r¾ rÉ r Z get_slicerÊ rN rE )r³ rR rº r4 Zis_copyr´ r´ rµ Ú_slice( s
|
|
zNDFrame._slice)Úrefr¬ r® c C s( |s d | _ n|d k stt |¡| _ d S rÐ )r rõ ÚweakrefrT )r³ rT r¬ r´ r´ rµ rE 9 s zNDFrame._set_is_copyc C s | j r| jdd dS )aV
|
Check if we are a view, have a cacher, and are of mixed type.
|
If so, then force a setitem_copy check.
|
|
Should be called just near setting a value
|
|
Will return a boolean if it we are a view and are cached, but a
|
single-dtype meaning that the cacher should be updated following
|
setting.
|
r; r< F)r r= rÎ r´ r´ rµ Ú%_check_is_chained_assignment_possibleA s z-NDFrame._check_is_chained_assignment_possibleÚsetting)r! Úforcec C sÈ t r
|
dS |s| jsdS t d¡}|dkr.dS | jdk rtt| jtst| ¡ }t |¡rj|dk rt|j| jkrtd| _dS t| jtr| j}n|dkrd}nd}|dkrªt ||dkrÄt
|
j |t t d dS ) a
|
|
Parameters
|
----------
|
t : str, the type of setting error
|
force : bool, default False
|
If True, then force showing an error.
|
|
validate if we are doing a setitem on a chained copy.
|
|
It is technically possible to figure out that we are setting on
|
a copy even WITH a multi-dtyped pandas object. In other words, some
|
blocks may be views while other are not. Currently _is_view will ALWAYS
|
return False for multi-blocks to avoid having to handle this case.
|
|
df = DataFrame(np.arange(0,9), columns=['count'])
|
df['group'] = 'b'
|
|
# This technically need not raise SettingWithCopy if both are view
|
# (which is not generally guaranteed but is usually True. However,
|
# this is in general not a good practice and we recommend using .loc.
|
df.iloc[0:5]['group'] = 'a'
|
|
Nzmode.chained_assignmentr; zÎ
|
A value is trying to be set on a copy of a slice from a DataFrame
|
|
See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copya
|
A value is trying to be set on a copy of a slice from a DataFrame.
|
Try using .loc[row_indexer,col_indexer] = value instead
|
|
See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copyr? Úwarn©Ú
|
stacklevel)r r r r² r¿ r§ ÚgcZ get_referentsr rF ÚwarningsrY rG rI )r³ r! rX rÏ Úrr´ r´ rµ r= P s.
|
|
ÿ ÿ
|
zNDFrame._check_setitem_copyc C sÔ d}d}| j dkrDt| jtrDz|| jjk}W n tk
|
rB Y nX |rt|tsX|f}| jD ],}t|tr^|dt|
|kr^| |= d}q^|s®| jd |¡}| j
|
|¡| _
|
z | j |= W n t k
|
rÎ Y nX dS )z
|
Delete item
|
Fr÷ NTr@ )rø r¿ rö ru Z_enginerG r rÀ r rJ r Zideleter rð )r³ r ZdeletedZmaybe_shortcutr* rO r´ r´ rµ Ú __delitem__ s*
|
|
zNDFrame.__delitem__c C s |r| j jstdd S )NzQCannot specify 'inplace=True' when 'self.flags.allows_duplicate_labels' is False.)rÒ r¯ rñ )r³ r r´ r´ rµ rH Ã s ÿz2NDFrame._check_inplace_and_allows_duplicate_labelsc
|
C s. z
|
| | W S t ttfk
|
r( | Y S X dS )aB
|
Get item from object for given key (ex: DataFrame column).
|
|
Returns default value if not found.
|
|
Parameters
|
----------
|
key : object
|
|
Returns
|
-------
|
same type as items contained in object
|
|
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]'
|
N)rð rñ Ú
|
IndexError)r³ r Údefaultr´ r´ rµ r% Ë s 6
|
z NDFrame.getc C s | j jS )z:Return boolean indicating if self is view of another array)r Zis_viewrÎ r´ r´ rµ rN s zNDFrame._is_viewz@Literal[('backfill', 'bfill', 'pad', 'ffill', 'nearest')] | None)r³ r, r¬ r® c C s" |j | j||||d}| jf |S )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.
|
|
* 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 True
|
Return a new object, even if the passed indexes are the same.
|
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
|
)r r, r¬ ÚlimitÚ tolerance)rï rß Úreindex)r³ r\ r, r¬ rb rc rî r´ r´ rµ Ú reindex_like s fûzNDFrame.reindex_like)rº rÞ rö r r< r+ )r rº rÞ rö r r r< r® c C s d S rÐ r´ ©r³ r rº rÞ rö r r r< r´ r´ rµ r | s z NDFrame.drop)rº rÞ rö r r r< ) r³ r rº rÞ rö r r r< r® c C s d S rÐ r´ rf r´ r´ rµ r s c C s d S rÐ r´ rf r´ r´ rµ r s r? c C s¼ t |d}|d k r>|d k s"|d k r*td| |¡}||i} n4|d k sN|d k rjd|i} | jdkrr|| d< ntd| }
|
| ¡ D ]"\}}|d k r~|
|
j||||d}
|
q~|r´| |
|
¡ d S |
|
S d S )Nr z2Cannot specify both 'labels' and 'index'/'columns'rÞ r÷ rö z>Need to specify at least one of 'labels', 'index' or 'columns'©r r< )rL rñ rô rø r½ Ú
|
_drop_axisrM ) r³ r rº rÞ rö r r r< r r r r´ r´ rµ r ¦ s*
|
|
|
|
|
ÿ
|
)r³ r< Ú
|
only_slicer® c C s² | |¡}| |¡}|jrb|dk rFt|ts4td|j|||d}n|j||d}| |¡}nt|prt|t } t
|
t |¡}|dk rÎt|tstd| |¡ |¡ }
|
|dkrÌ|
|
¡ rÌt| dnht|trú|jdkrú| sú| d¡ |¡ }
|
n<| |¡ }
|
| |¡d k ¡ } |dkr6| r6t| dt|
|
jrN|
|
jtd
|
}
|
|
|
¡ d }| |¡}| j| d } | jj||| d d|d } | | ¡}| jd kr¨| j |_ | | ¡S )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.
|
|
Nzaxis must be a MultiIndexrg )r< r? rD r° r r@ r¼ r» T)rº Ú
|
allow_dupsr¬ ri ) rò rè Z is_uniquer¿ ru rõ r Z get_indexerre r rP rj Zindex_labels_to_arrayrü Úisinr] rð r¸ rL r rY Zto_numpyrq rL rB rø r Úreindex_indexerrÉ rÿ rÊ )r³ r rº r r< ri Zaxis_numZnew_axisrC Zis_tuple_labelsÚmaskZlabels_missingrÆ rË r4 r´ r´ rµ rh Í sZ
|
|
|
|
ÿþý
|
ú
|
zNDFrame._drop_axis)r: r® c C s* | ¡ | ¡ |j| _| j|dd dS )zÏ
|
Replace self internals with result.
|
|
Parameters
|
----------
|
result : same type as self
|
verify_is_copy : bool, default True
|
Provide is_copy checks.
|
T)r: r N)Ú _reset_cacher! r r> )r³ r4 r: r´ r´ rµ rM $ s zNDFrame._update_inplace)r³ rý rº r® c s8 fdd}| j }|dk r$| |¡}||i}| jf |S )a8
|
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 s | S rÐ r´ r ©rý r´ rµ r q r z$NDFrame.add_prefix.<locals>.<lambda>N©rä rô rR )r³ rý rº rP r r= r´ ro rµ Ú
|
add_prefix6 s ;
|
zNDFrame.add_prefix)r³ Úsuffixrº r® c s8 fdd}| j }|dk r$| |¡}||i}| jf |S )a7
|
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 s | S rÐ r´ r ©rr r´ rµ r » r z$NDFrame.add_suffix.<locals>.<lambda>Nrp )r³ rr rº rP r r= r´ rs rµ Ú
|
add_suffix s ;
|
zNDFrame.add_suffix)rº Ú ascendingr rØ Ú na_positionÚ ignore_indexr zbool_t | Sequence[bool_t]r? ) r³ rº ru r rØ rv rw r r® c C s d S rÐ r´ ©r³ rº ru r rØ rv rw r r´ r´ rµ Ú sort_valuesÉ s zNDFrame.sort_values)rº ru rØ rv rw r )rº ru r rØ rv rw r r® c C s d S rÐ r´ rx r´ r´ rµ ry × s c C s d S rÐ r´ rx r´ r´ rµ ry å s Z quicksortÚlastc C s t | dS )u
|
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.
|
|
.. versionadded:: 1.1.0
|
|
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 <https://github.com/SethMMorton/natsort>` package.
|
|
>>> df = pd.DataFrame({
|
... "time": ['0hr', '128hr', '72hr', '48hr', '96hr'],
|
... "value": [10, 20, 30, 40, 50]
|
... })
|
>>> df
|
time value
|
0 0hr 10
|
1 128hr 20
|
2 72hr 30
|
3 48hr 40
|
4 96hr 50
|
>>> from natsort import index_natsorted
|
>>> df.sort_values(
|
... by="time",
|
... key=lambda x: np.argsort(index_natsorted(df["time"]))
|
... )
|
time value
|
0 0hr 10
|
3 48hr 40
|
2 72hr 30
|
4 96hr 50
|
1 128hr 20
|
NrÜ rx r´ r´ rµ ry ó s )rº r ru rØ rv Úsort_remainingrw r r7 r2 r, )
|
rº r ru r rØ rv r{ rw r r® c
|
C s d S rÐ r´ ©
|
r³ rº r ru r rØ rv r{ rw r r´ r´ rµ Ú
|
sort_index s zNDFrame.sort_index) rº r ru r rØ rv r{ rw r ) r³ rº r ru r rØ rv r{ rw r r® c
|
C s d S rÐ r´ r| r´ r´ rµ r} s c
|
C s d S rÐ r´ r| r´ r´ rµ r} s c C sü t |d}| |¡}t|}| |¡}
|
t|
|
|||||| } | d krv|rL| } n | jd d} |rjtt| | _|rrd S | S | |¡} | j
|
j | | dd}| | |j | ¡ ¡ |rÒt| trºdnd}| |tt| ¡ | |¡} |rê| | ¡S | j| ddS d S ) Nr rÓ F)rº rD r» r r} r+ )rL rò rK rè r r¬ rx rÀ rÞ r¾ r rB r r Z_sort_levels_monotonicr¿ rb rÉ rM rÊ )r³ rº r ru r rØ rv r{ rw r ÚtargetrC r4 Úbaxisrj r´ r´ rµ r} ½ s@
|
|
|
ÿ
|
|
|
)r Zoptional_reindexz Scalar | None)r³ rº r, r¬ r Ú
|
fill_valuerb r® c sü |dk r"|dk r"|dk r"t dnX|dk s2|dk r^|dk rBt d|dk rz|dk rX|}qz|}n |rv |¡dkrv|}n|}||d} t|}|rt rd}t fdd| ¡ D rÀ j|d S | ||¡rÜ | ||¡S | || |
|
|||¡j
|
d
|
d S ) aà
|
Conform {klass} 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
|
----------
|
{optional_reindex}
|
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 True
|
Return a new object, even if the passed indexes are the same.
|
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
|
-------
|
{klass} 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']
|
>>> df = pd.DataFrame({{'http_status': [200, 200, 404, 404, 301],
|
... 'response_time': [0.04, 0.02, 0.07, 0.08, 1.0]}},
|
... 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 <basics.reindexing>` for more.
|
Nz3Cannot specify all of 'labels', 'index', 'columns'.r> r» rU Fc 3 s* | ]"\}}|d k r |¡ |¡V qd S rÐ )rè Z identical)rê r rO rÎ r´ rµ r ä s þz"NDFrame.reindex.<locals>.<genexpr>rÓ rd r+ ) rG rò r r r] r½ r¬ Ú_needs_reindex_multiÚ_reindex_multiÚ _reindex_axesrÊ ) r³ r rÞ rö rº r, r¬ r r rb rc r r´ rÎ rµ rd ò sN X
|
ÿþ
|
þ ÿ þzNDFrame.reindexc C sp | }| j D ]`} || }
|
|
|
dkr q
|
| | ¡} | j|
|
||||d\} } | | ¡}|j|| | gi||dd}d}q
|
|S )z%Perform the reindex for all the axes.N)r rb rc r, F)r r¬ rj )rß rè rd rò Ú_reindex_with_indexers)r³ r r rb rc r, r r¬ r rÅ r rO rQ rC rº r´ r´ rµ r ô s,
|
|
ÿ
|
|
|
üzNDFrame._reindex_axesc C sV t j| ¡ | jkoT|dkoT|dkoT| j oT| jdkoRt| jdkoRt| jj d S )z$Check if we do need a multi reindex.Nr÷ r» r )
|
rj Úcount_not_noner rå Ú_is_mixed_typerø rÀ r rY r9 )r³ r r, r r´ r´ rµ r s ÿþý
|
ÿýûz NDFrame._needs_reindex_multic C s t | d S rÐ rÜ )r³ r r¬ r r´ r´ rµ r s zNDFrame._reindex_multi)r³ r¬ rj r® c
|
C sÀ | j }t| ¡ D ]V}|| \}}| |¡} |dkr6qt|}|dk rNt|}|j||| |||d}d}q|sv|dkr|| j krt s|j|d}n t r°|| j kr°|jdd}| |¡
|
| ¡S )z*allow_dups indicates an internal call hereN)rº r rj r¬ FrÓ ) r Úsortedr r¾ ry rQ rl r r¬ rÉ rÊ )
|
r³ Ú
|
reindexersr r¬ rj rj rº rÞ rC r r´ r´ rµ r s<
|
|
ú ÿÿþý z NDFrame._reindex_with_indexers)r³ ÚlikeÚregexrº r® c sÜ t ||¡}|dkr td|dkr,| j}| |¡ |dk rf| |¡}| jf | fdd|D iS rddfdd } |¡}| j|d
|
| S |rÐddfd d }t
|
|¡ |¡}| j|d
|
| S td dS ) uF
|
Subset the dataframe rows or columns according to the specified index labels.
|
|
Note that this routine does not filter a dataframe on its
|
contents. 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 input object
|
|
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
|
r» zDKeyword arguments `items`, `like`, or `regex` are mutually exclusiveNc s g | ]}| kr|qS r´ r´ )rê r^ )r r´ rµ r ¢ s z"NDFrame.filter.<locals>.<listcomp>r© rÍ c s d k s t t| kS rÐ )rõ rR r )r r´ rµ rP ¦ s zNDFrame.filter.<locals>.fr¹ c s t| ¡d k S rÐ )ÚsearchrR r )Úmatcherr´ rµ rP ® s z,Must pass either `items`, `like`, or `regex`) rj r
rG rä rè rô rd r¯ rO ÚreÚcompile) r³ r½ r r rº Znkwrÿ rP r r´ )r r r rµ ÚfilterM s. Fÿ
|
|
ÿ
|
|
|
zNDFrame.filteré )r³ Únr® c C s | j d|
S )a·
|
Return the first `n` rows.
|
|
This function returns the first `n` rows for the object based
|
on position. It is useful for quickly testing if your object
|
has the right type of data in it.
|
|
For negative values of `n`, this function returns all rows except
|
the last `|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
|
-------
|
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
|
N©r9 ©r³ r r´ r´ rµ r¸ · s Iz NDFrame.headc C s& |dkr| j dd
S | j | d
S )a
|
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
|
r Nr r r´ r´ rµ Útail s Iz NDFrame.tailz float | NonezRandomState | None)r³ r ÚfracÚreplaceÚ random_staterº rw r® c C s¦ |dkr| j }| |¡}| j| }t |¡} t |||¡}
|
|
|
dkrZ|dk sNtt|| }
|
|dk rpt | ||¡}t ||
|
||| ¡} | j
|
| |d} |r¢t t | | _ | S )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.
|
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.
|
|
.. versionchanged:: 1.1.0
|
|
array-like and BitGenerator object now passed to np.random.RandomState()
|
as seed
|
|
.. versionchanged:: 1.4.0
|
|
np.random.Generator objects now accepted
|
|
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.
|
|
.. versionadded:: 1.3.0
|
|
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`.
|
|
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
|
Nr¹ )Ú_stat_axis_numberrò r rj r rm Zprocess_sampling_sizerõ rx Zpreprocess_weightsrB rx rÀ rÞ ) r³ r r r Úweightsr rº rw Zobj_lenÚrsr Zsampled_indicesr4 r´ r´ rµ rm O s"
|
|
|
zNDFrame.samplez/Callable[..., T] | tuple[Callable[..., T], str]r: )Úfuncr® c O s6 t r"tj| jdd|f||S tj| |f||S )a»
|
Apply chainable functions that expect Series or DataFrames.
|
|
Parameters
|
----------
|
func : function
|
Function to apply to the {klass}.
|
``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 {klass}.
|
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``.
|
|
See Also
|
--------
|
DataFrame.apply : Apply a function along input axis of DataFrame.
|
DataFrame.applymap : 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. Instead of writing
|
|
>>> func(g(h(df), arg1=a), arg2=b, arg3=c) # doctest: +SKIP
|
|
You can write
|
|
>>> (df.pipe(h)
|
... .pipe(g, arg1=a)
|
... .pipe(func, arg2=b, arg3=c)
|
... ) # doctest: +SKIP
|
|
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 ``func`` takes its data as ``arg2``:
|
|
>>> (df.pipe(h)
|
... .pipe(g, arg1=a)
|
... .pipe((func, 'arg2'), arg1=a, arg3=c)
|
... ) # doctest: +SKIP
|
NrÓ )r rj Úpiper¬ )r³ r Úargsrí r´ r´ rµ r ê s : z NDFrame.pipe)r³ r, r® c sà t |trp|jD ]}|j| | j|< q|jj| j_t| jt|j@ D ](}t |tsXtt
|
| |t ||d¡ qF|dkrÜ|j d j t fdd|j dd
D }|rÀ D ]} | | j|< q¬t dd |j D }|| j_| S )aÜ
|
Propagate metadata from other to self.
|
|
Parameters
|
----------
|
other : the object from which to get the attributes that we are going
|
to propagate
|
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.
|
Nr
r c 3 s | ]}|j kV qd S rÐ ©r )rê Úobjsr r´ rµ r K s z'NDFrame.__finalize__.<locals>.<genexpr>r» c s s | ]}|j jV qd S rÐ )rÒ r¯ ©rê r r´ r´ rµ r P s )r¿ r r rÒ r¯ r¥ r r§ rõ r° r± rù r r] )r³ r\ r, rí rÿ Z check_attrsr¯ r´ r rµ rÊ + s$
|
|
ÿzNDFrame.__finalize__rt c C s> || j kr2|| jkr2|| jkr2| j |¡r2| | S t | |¡S )z
|
After regular attribute access, try looking up the name
|
This allows simpler access to columns for interactive use.
|
)r£ r r¤ r Z$_can_hold_identifiers_and_holds_namer° Ú__getattribute__)r³ rÿ r´ r´ rµ Ú __getattr__W s ÿþý
|
üzNDFrame.__getattr__)rÿ r® c C sþ z t | |¡ t | ||¡W S tk
|
r0 Y nX || jkrLt | ||¡ n®|| jkrft | ||¡ nzJt| |}t|trt | ||¡ n"|| j kr || |< nt | ||¡ W nH tt
|
fk
|
rø t| t ræt |ræt jdt d t | ||¡ Y nX dS )z
|
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-accessrZ N)r° r¡ r± ÚAttributeErrorr£ r rù r¿ rt r rG rb r[ r] rY rI )r³ rÿ rÏ Úexistingr´ r´ rµ r± g s.
|
|
|
|
|
|
ûzNDFrame.__setattr__c s$ t ¡ }| jjr | | jj¡ |S )z
|
add the string-like attributes from the info_axis.
|
If info_axis is a MultiIndex, its first level values are used.
|
)ÚsuperÚ_dir_additionsr Z_can_hold_stringsrì Z_dir_additions_for_owner)r³ Z additions©Ú __class__r´ rµ r¦ s
|
zNDFrame._dir_additionsc C sD t | jttfr| S t| jj}| }t| jj|kr@| ¡ |S )z^
|
Consolidate _mgr -- if the blocks have changed, then clear the
|
cache
|
)r¿ r rz r| rÀ rÁ r! )r³ rP Z blocks_beforer4 r´ r´ rµ Ú_protect_consolidate s z NDFrame._protect_consolidatec s dd fdd } |¡ dS )z)Consolidate data in place and return Nonerª rÍ c s j ¡ _ d S rÐ ©r Z consolidater´ rÎ r´ rµ rP ° s z'NDFrame._consolidate_inplace.<locals>.fN)r© )r³ rP r´ rÎ rµ Ú_consolidate_inplace¬ s z NDFrame._consolidate_inplacec s& fdd} |¡} |¡ ¡S )zÎ
|
Compute NDFrame with "consolidated" internals (data of each dtype
|
grouped together in a single ndarray).
|
|
Returns
|
-------
|
consolidated : same type as caller
|
c s
|
j ¡ S rÐ rª r´ rÎ r´ rµ r ¿ r z&NDFrame._consolidate.<locals>.<lambda>)r© rÉ rÊ )r³ rP Z cons_datar´ rÎ rµ Ú _consolidateµ s
|
|
zNDFrame._consolidatec C s& | j jr dS | j jrdS | j ¡ dkS )NFTr» )r r/ Zany_extension_typesr ÚnuniquerÎ r´ r´ rµ r à s
|
zNDFrame._is_mixed_typec C s: | j r6| jjs6t|r t |¡s*|tjkr.dS tddS )z?check whether we allow in-place setting with this type of valueTzHCannot do inplace boolean setting on mixed-types with a non np.nan value) r r Zis_numeric_mixed_typerZ r Úisnanr rW rG rÑ r´ r´ rµ Ú_check_inplace_settingÏ s ÿz NDFrame._check_inplace_settingc C s | | j ¡ ¡ | ¡S rÐ )rÉ r Zget_numeric_datarÊ rÎ r´ r´ rµ Ú_get_numeric_dataÞ s zNDFrame._get_numeric_datac C s | | j ¡ ¡ | ¡S rÐ )rÉ r Z get_bool_datarÊ rÎ r´ r´ rµ Ú_get_bool_dataâ s zNDFrame._get_bool_datac C s t | d S rÐ rÜ rÎ r´ r´ rµ r é s zNDFrame.valuesc C s t | dS )zinternal implementationNrÜ rÎ r´ r´ rµ r. í s zNDFrame._valuesc C s | j ¡ }| j|| jtjdS )aJ
|
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 <basics.dtypes>` for more.
|
|
Returns
|
-------
|
pandas.Series
|
The data type of each column.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'float': [1.0],
|
... 'int': [1],
|
... 'datetime': [pd.Timestamp('20180310')],
|
... 'string': ['foo']})
|
>>> df.dtypes
|
float float64
|
int int64
|
datetime datetime64[ns]
|
string object
|
dtype: object
|
)rÞ r¸ )r Z
|
get_dtypesrM r r Zobject_)r³ r« r´ r´ rµ r ò s
|
zNDFrame.dtypes)r³ r¬ r< r® c sè rt rd tr@jdkrXtdks8jkr@tdj } | |¡S ddlm} |t d}|j
|
D ] }|krvtd| dqv|j j d dd
|
}g }t ¡ D ]\} \}}
|
|j| } t| râ|
|
j d } nPz|
|
j| |d } W n: tk
|
r0 } z| d | df| _ W 5 d } ~ X Y nX | | ¡ q¶n^trxjdkrx fddttj D }n&jj |d } |¡jddS |s°jd d S t|ddd} |¡}j |_ |jdd}tt |S )a+
|
Cast a pandas object to a specified dtype ``dtype``.
|
|
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 True
|
Return a copy when ``copy=True`` (be very careful setting
|
``copy=False`` as changes to values then may propagate to other
|
pandas objects).
|
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
|
|
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[ns]
|
Fr» zFOnly the Series name can be used for the key in Series dtype mappings.r r r¼ zJOnly a column name can be used for the key in a dtype mappings argument. 'z' not found in columns.N)r r¬ rÓ )r¸ r¬ r< z': Error while type casting for column 'r c s( g | ] }j d d
|f j dqS )NrH )r9 rà )rê rþ ©r¬ r¸ r³ r´ rµ r s ÿz"NDFrame.astype.<locals>.<listcomp>rà r+ r ) r rW rø rÀ rÿ rð rà Úpandasr r° rÞ rd rö rú r½ Ziatrf r¬ rñ r rç rY r- r rÉ rÊ r
r r3 )r³ r¸ r¬ r< Únew_typer Z dtype_serÚcol_nameÚresultsrþ r* ZcdtZres_colÚexrj r4 r´ r² rµ rà sV l
|
|
|
ÿ
|
|
|
ÿ
|
ÿ þ
|
zNDFrame.astype)r³ rÔ r® c C s* | j j|d}| ¡ | |¡j| ddS )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). Any changes to the data of the original
|
will be reflected in the shallow copy (and vice versa).
|
|
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.
|
|
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 <gotchas.thread-safety>` when copying in a threading
|
environment.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2], index=["a", "b"])
|
>>> s
|
a 1
|
b 2
|
dtype: int64
|
|
>>> s_copy = s.copy()
|
>>> s_copy
|
a 1
|
b 2
|
dtype: int64
|
|
**Shallow copy versus default (deep) copy:**
|
|
>>> s = pd.Series([1, 2], index=["a", "b"])
|
>>> deep = s.copy()
|
>>> shallow = s.copy(deep=False)
|
|
Shallow copy shares data and index with original.
|
|
>>> s is shallow
|
False
|
>>> s.values is shallow.values and s.index is shallow.index
|
True
|
|
Deep copy has own copy of data and index.
|
|
>>> s is deep
|
False
|
>>> s.values is deep.values or s.index is deep.index
|
False
|
|
Updates to the data shared by shallow copy and original is reflected
|
in both; deep copy remains unchanged.
|
|
>>> s[0] = 3
|
>>> shallow[1] = 4
|
>>> s
|
a 3
|
b 4
|
dtype: int64
|
>>> shallow
|
a 3
|
b 4
|
dtype: int64
|
>>> deep
|
a 1
|
b 2
|
dtype: int64
|
|
Note that when copying an object containing Python objects, a deep copy
|
will copy the data, but will not do so recursively. 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
|
rÓ r¬ r+ )r r¬ r! rÉ rÊ )r³ rÔ r« r´ r´ rµ r¬ Æ s nz NDFrame.copyc C s | j |dS r rH )r³ rÔ r´ r´ rµ Ú__copy__8 s zNDFrame.__copy__c C s | j ddS )zq
|
Parameters
|
----------
|
memo, default None
|
Standard signature. Unused
|
TrÓ rH )r³ Úmemor´ r´ rµ Ú __deepcopy__< s zNDFrame.__deepcopy__)r³ r¬ r® c C s" | j j|d}| |¡j| ddS )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 True
|
Whether to make a copy for non-object or non-inferrable columns
|
or Series.
|
|
Returns
|
-------
|
same type as 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
|
rH Ú infer_objectsr+ )r ÚconvertrÉ rÊ )r³ r¬ rË r´ r´ rµ r» F s -zNDFrame.infer_objectsÚnumpy_nullabler$ )r³ r» Úconvert_stringÚconvert_integerÚconvert_booleanÚconvert_floatingÚ dtype_backendr® c
|
s¦ t | jdkr(| j dS fdd| ¡ D }t|dkrt|dd| jd}ttd | j } | |}|j
|
| d d
|
}tt |S | j d d S d S ) az
|
Convert columns to the best possible dtypes using dtypes supporting ``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.
|
|
.. versionadded:: 1.2.0
|
dtype_backend : {"numpy_nullable", "pyarrow"}, default "numpy_nullable"
|
Which dtype_backend to use, e.g. whether a DataFrame should use nullable
|
dtypes for all dtypes that have a nullable
|
implementation when "numpy_nullable" is set, pyarrow is used for all
|
dtypes if "pyarrow" is set.
|
|
The dtype_backends are still experimential.
|
|
.. 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.
|
|
.. versionchanged:: 1.2
|
Starting with pandas 1.2, this method also converts float columns
|
to the nullable 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 <NA>
|
1 2 y False i <NA> 100.5
|
2 3 z <NA> <NA> 20 200.0
|
|
>>> dfn.dtypes
|
a Int32
|
b string[python]
|
c boolean
|
d string[python]
|
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: object
|
|
Obtain a Series with dtype ``StringDtype``.
|
|
>>> s.convert_dtypes()
|
0 a
|
1 b
|
2 <NA>
|
dtype: string
|
r» ©r c
|
s& g | ] \}}|j d qS )rà )Ú_convert_dtypes)rê rµ r* ©rÀ rÁ r¿ r¾ r r» r´ rµ r s øúz*NDFrame.convert_dtypes.<locals>.<listcomp>r F)rº r¬ r r Úconvert_dtypesr+ NrÓ ) rJ rø rÄ r½ rÀ r
rö r r rÉ rÊ r3 r¬ )
|
r³ r» r¾ r¿ rÀ rÁ r r¶ r4 Úconsr´ rÅ rµ rÆ v s*
|
ú ÷
|
zNDFrame.convert_dtypes©r, rº r rb Údowncastz'Hashable | Mapping | Series | DataFramezFillnaOptions | None)r³ rÏ r, rº r rb rÉ r® c C s d S rÐ r´ ©r³ rÏ r, rº r rb rÉ r´ r´ rµ Úfillna( s zNDFrame.fillna)r, rº rb rÉ )rÏ r, rº r rb rÉ r® c C s d S rÐ r´ rÊ r´ r´ rµ rË 5 s c C s d S rÐ r´ rÊ r´ r´ rµ rË B s c C s¬ t |d}t||\}}|dkr$d}| |¡}|dkr| jjsf|dkrf|rPt | jj||dj}|S | jj|||||d}n | j dkrt
|
|t t frât |s¶|rªdS | jddS ddlm} | |}|j| jd d
|
}|j}n t|sìntd t|j d | jj||||d }nft
|
|t t fr |dkr<tdt rR| jdd}n|r\| n| ¡ }t
|
|t }
|
| ¡ D ]p\} } | |krqv|
|
s|n| | ¡} || j| || d}|sÈ||| < qvt
|
|t r|j|| jkrú||j dd
| f< n||| < nâ|j | ¡}t
|
|t r2t !| j"d ¡| }nNt
|
|t j#r\|jj$dkr\| %¡ d }n$t
|
|t j#rx|jj$dkstdt&|D ]\\}}|j'dd
|f }| j'dd
|f }|j|jkrÖ||j'dd
|f< n | (||¡ qqv|rú| )|¡S |S nt|sB|dkr,| jj||dj}|}n| jj||||d }n>t
|
|t*rn| j dkrn| +| ,¡ |¡j}nt-dt| | .|¡}|r| )|¡S |j/| ddS dS )a;
|
Fill NA/NaN values using the specified method.
|
|
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.
|
method : {{'backfill', 'bfill', 'ffill', None}}, default None
|
Method to use for filling holes in reindexed Series:
|
|
* ffill: propagate last valid observation forward to next valid.
|
* backfill / bfill: use next valid observation to fill gap.
|
|
axis : {axes_single_arg}
|
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.
|
downcast : dict, default is None
|
A dict of item->dtype of what to downcast if possible,
|
or the string 'infer' which will try to downcast to an appropriate
|
equal type (e.g. float64 to int64 if possible).
|
|
Returns
|
-------
|
{klass} or None
|
Object with missing values filled or None if ``inplace=True``.
|
|
See Also
|
--------
|
interpolate : Fill NaN values using interpolation.
|
reindex : Conform object to new index.
|
asfreq : Convert TimeSeries to specified frequency.
|
|
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
|
|
We can also propagate non-null values forward or backward.
|
|
>>> df.fillna(method="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
|
|
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.
|
r Nr r» ©r, rb )r, rº rb r rÉ rÓ r FrH zF"value" parameter must be a scalar, dict or Series, but you passed a "r6 )rÏ rb r rÉ z9Currently only can fill with dict/Series column by column)rb rÉ Úbrþ zVUnexpected get_loc result, please report a bug at https://github.com/pandas-dev/pandas)rÏ rb r÷ zinvalid fill value with a rË r+ )0rL rM rò r r/ rÙ r: rË Ú interpolaterø r¿ r² rc rÀ r¬ r³ r rd rÞ r. r[ rG r` rÚ r r½ r% r¸ rO rö rJ r7 r Úaranger rK rØ rL rú r9 ZisetitemrM rb Úwhererg rñ rÉ rÊ )r³ rÏ r, rº r rb rÉ r4 rj r Zis_dictr r Z
|
downcast_kZres_kÚlocsrþ rO Zres_locr~ r´ r´ rµ rË O sÎ {
|
|
û
|
ÿ ÿ
|
|
ÿ
|
|
ÿý
|
|
ÿ
|
ÿ
|
ÿ
|
ÿÿ
|
|
|
ÿ
|
|
©rº r rb rÉ z None | Axisz
|
None | int)r³ rº r rb rÉ r® c C s d S rÐ r´ ©r³ rº r rb rÉ r´ r´ rµ ÚffillU s z NDFrame.ffill)rº rb rÉ )rº r rb rÉ r® c C s d S rÐ r´ rÓ r´ r´ rµ rÔ ` s c C s d S rÐ r´ rÓ r´ r´ rµ rÔ k s c C s | j d||||dS )zÓ
|
Synonym for :meth:`DataFrame.fillna` with ``method='ffill'``.
|
|
Returns
|
-------
|
{klass} or None
|
Object with missing values filled or None if ``inplace=True``.
|
rÔ rÈ ©rË rÓ r´ r´ rµ rÔ v s ÿc C s$ t jdtt d | j||||dS )a3
|
Synonym for :meth:`DataFrame.fillna` with ``method='ffill'``.
|
|
.. deprecated:: 2.0
|
|
{klass}.pad is deprecated. Use {klass}.ffill instead.
|
|
Returns
|
-------
|
{klass} or None
|
Object with missing values filled or None if ``inplace=True``.
|
zPDataFrame.pad/Series.pad is deprecated. Use DataFrame.ffill/Series.ffill insteadrZ rÒ )r] rY Ú FutureWarningrI rÔ rÓ r´ r´ rµ Úpad s üz NDFrame.padc C s d S rÐ r´ rÓ r´ r´ rµ Úbfill¨ s z NDFrame.bfillc C s d S rÐ r´ rÓ r´ r´ rµ rØ ³ s c C s d S rÐ r´ rÓ r´ r´ rµ rØ ¾ s c C s | j d||||dS )zÓ
|
Synonym for :meth:`DataFrame.fillna` with ``method='bfill'``.
|
|
Returns
|
-------
|
{klass} or None
|
Object with missing values filled or None if ``inplace=True``.
|
rØ rÈ rÕ rÓ r´ r´ rµ rØ É s ÿc C s$ t jdtt d | j||||dS )a8
|
Synonym for :meth:`DataFrame.fillna` with ``method='bfill'``.
|
|
.. deprecated:: 2.0
|
|
{klass}.backfill is deprecated. Use {klass}.bfill instead.
|
|
Returns
|
-------
|
{klass} or None
|
Object with missing values filled or None if ``inplace=True``.
|
zZDataFrame.backfill/Series.backfill is deprecated. Use DataFrame.bfill/Series.bfill insteadrZ rÒ )r] rY rÖ rI rØ rÓ r´ r´ rµ ÚbackfillÞ s üzNDFrame.backfill)r rb r r, z2Literal[('pad', 'ffill', 'bfill')] | lib.NoDefault)r³ r rb r r, r® c C s d S rÐ r´ ©r³ Ú
|
to_replacerÏ r rb r r, r´ r´ rµ r û s zNDFrame.replace)rb r r, )r rb r r, r® c C s d S rÐ r´ rÚ r´ r´ rµ r s c C s d S rÐ r´ rÚ r´ r´ rµ r s r r r )r r r c sþ t s0ts0ts0tdttj t|d}t|sRd k rRt dt
|
j ksh|t
|
j k rÒ|t
|
j krvd}t st |sgt ttfrät trÔddlm} j|j|||fd}|rÐd S |S |||¡S t st |sþtd|d }t ¡ } | r&t| \}
|
} n
|
g g }
|
} d
|
d | D } t| r´t| sZtd i } i }| D ]@\}}tt| ¡ pg g f\}
|
} t|
|
| |< t| ||< qf| | n
|
|
|
| j|||d S jsð|räd S jd dS t rzt r, fdd ¡ D } |||¡S tsn j dkrJt dfdd ¡ D } |||¡S tdnXtrâtsgt t t krÌt dt dt d j j!||d}nðd kr6t|s"t|s"t |s"tdtt|j j|||d d S t rx j dkrTt dfdd ¡ D } |||¡S tsºt"|}|r¦ j j#|d }n j j|d }ntd ttj $|¡}|rì %|¡S |j& d d S d S ) NzYExpecting 'to_replace' to be either a scalar, array-like, dict or None, got invalid type r z4'to_replace' must be 'None' if 'regex' is not a boolr× r r )r zfIf "to_replace" and "value" are both None and "to_replace" is not a list, then regex must be a mappingTc S s g | ] }t |qS r´ )rW )rê r r´ r´ rµ r m s z#NDFrame.replace.<locals>.<listcomp>zSIf a nested mapping is passed, all values of the top level mapping must be mappings)r rb r rÓ c s2 i | ]*}| ¡ kr| kr|| | fqS r´ )r )rê r* ©r³ rÛ rÏ r´ rµ rë s
|
þ z#NDFrame.replace.<locals>.<dictcomp>r» zASeries.replace cannot use dict-like to_replace and non-None valuec s i | ]\}}|| fqS r´ r´ )rê r* Zto_rep)rÏ r´ rµ rë s z.value argument must be scalar, dict, or Seriesz2Replacement lists must match in length. Expecting z got r
)Zsrc_listZ dest_listr r z|'regex' must be a string or a compiled regular expression or a list or dict of strings or regular expressions, you passed a z<Series.replace cannot use dict-value and non-None to_replacec s i | ]\}}| |fqS r´ r´ )rê r* Úval)rÛ r´ rµ rë Ñ s )rÛ rÏ r zInvalid "to_replace" type: r r+ )'r_ r^ r[ rG Úreprr` rÚ rL rS rñ r rW rW r¿ r r¦ rb r³ r rh Z_replace_singler½ Úzipr r] r r r¬ r Z_replace_columnwiserø rÀ r Z replace_listrn Z replace_regexrÉ rM rÊ )r³ rÛ rÏ r rb r r, r r4 r½ r r Z are_mappingsZ to_rep_dictZ
|
value_dictr r r( rj r´ rÜ rµ r " s ÿþýÿ
|
|
|
|
þ
|
ÿ
|
|
|
ÿ
|
ÿ
|
|
þ
|
ÿ
|
ÿ
|
|
ÿü
|
ÿþýÿ ÿ
|
ÿ
|
|
ý ÿÿ
|
|
Úlinear)rº rb r Úlimit_directionÚ
|
limit_arearÉ ) r³ r, rº rb r rá râ rÉ r® c K sÞ t |d}| |¡}ddddg} |dko.|| k}
|
|
|
r:| jn| } | jrL| ¡ S || krZ| j}t| jtrv|dkrvt d|d kr|d
|
krd nd }n@|d kr°|d kr°t d| d|d
|
krÐ|d krÐt d| d| j
|
dkrøt | j t d¡k¡røtd|dkrtt t| j¡} nT| j} ddddh} t| jpJt| jpJt| j}|| krl|slt d| dt| ¡ rtd| jjf ||| |||||d|}| |¡}|
|
r¼|j}|rÌ| |¡S |j | d d S d S ) a
|
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.
|
* 'index', 'values': use the actual numerical values of the index.
|
* 'pad': Fill in NaNs using existing values.
|
* '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` which
|
replaces 'piecewise_polynomial' interpolation method in
|
scipy 0.18.
|
|
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
|
Consecutive NaNs will be filled in this direction.
|
|
If limit is specified:
|
* If 'method' is 'pad' or 'ffill', 'limit_direction' must be 'forward'.
|
* If 'method' is 'backfill' or 'bfill', 'limit_direction' must be
|
'backwards'.
|
|
If 'limit' is not specified:
|
* If 'method' is 'backfill' or 'bfill', the default is 'backward'
|
* else the default is 'forward'
|
|
.. versionchanged:: 1.1.0
|
raises ValueError if `limit_direction` is 'forward' or 'both' and
|
method is 'backfill' or 'bfill'.
|
raises ValueError if `limit_direction` is 'backward' or 'both' and
|
method is 'pad' or 'ffill'.
|
|
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).
|
|
downcast : optional, 'infer' or None, defaults to None
|
Downcast dtypes if possible.
|
``**kwargs`` : optional
|
Keyword arguments to pass on to the interpolating function.
|
|
Returns
|
-------
|
Series or DataFrame or None
|
Returns the same object type as the caller, interpolated at
|
some or all ``NaN`` values or None if ``inplace=True``.
|
|
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
|
<https://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__.
|
|
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 by padding, but filling at most two
|
consecutive ``NaN`` at a time.
|
|
>>> s = pd.Series([np.nan, "single_one", np.nan,
|
... "fill_two_more", np.nan, np.nan, np.nan,
|
... 4.71, np.nan])
|
>>> s
|
0 NaN
|
1 single_one
|
2 NaN
|
3 fill_two_more
|
4 NaN
|
5 NaN
|
6 NaN
|
7 4.71
|
8 NaN
|
dtype: object
|
>>> s.interpolate(method='pad', limit=2)
|
0 NaN
|
1 single_one
|
2 single_one
|
3 fill_two_more
|
4 fill_two_more
|
5 fill_two_more
|
6 NaN
|
7 4.71
|
8 4.71
|
dtype: object
|
|
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
|
r rÔ rØ r× rÙ r» rà z@Only `method=linear` interpolation is supported on MultiIndexes.N)rÙ rØ ZbackwardZforward)r× rÔ z0`limit_direction` must be 'forward' for method `ú`z1`limit_direction` must be 'backward' for method `r÷ r° zvCannot interpolate with all object-dtype columns in the DataFrame. Try setting at least one column to a numeric dtype.rÞ r ZnearestÚtimez9Index column must be numeric or datetime type when using z_ method other than linear. Try setting a numeric or datetime index column before interpolating.zkInterpolation with NaNs in the index has not been implemented. Try filling those NaNs before interpolating.)r, rº rÞ rb rá râ r rÉ rÎ r+ ) rL rò r: r r¬ rã r¿ rÞ ru rñ rø r r] r r¸ rG rt rÏ rÀ r] rU r` rf r rÙ r rÎ rÉ rM rÊ )r³ r, rº rb r rá râ rÉ rí Zfillna_methodsZshould_transposer rÞ ÚmethodsZis_numeric_or_datetimerj r4 r´ r´ rµ rÎ ë s S
|
|
ÿÿ
|
ÿ
|
ÿ ÿ
|
ÿý
|
ÿÿø ÷
|
|
zNDFrame.interpolatec C s t |trt|}| jjs"tdt | t}|rB|dk r^tdn |dkrP| j}t|s^|g}t|}|s| jd }t | jt rt
|
|| jj d}||k r¸|s²| j | j|t jdS t jS |r| jj|dd}|dkrÞ|d 8 }| j}|dkrt|| r|d 8 }qä|| S t |ts2|r(t|nt|g}|r@| ¡ n| | ¡ jd d
|
}| ¡ rÈ|rtd | } | jt j|| jd S |r¦td | } | jt j|| jdS td | } | j t j| j|d d S | j ||j ¡} | dk}
|
| | ¡} || _|
|
¡ rt j| j|
|
< |r| S | j d S )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
|
|
Return scalar, Series, or DataFrame.
|
|
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)
|
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)
|
2.0
|
|
Take all columns into consideration
|
|
>>> df = pd.DataFrame({'a': [10, 20, 30, 40, 50],
|
... '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 NaN
|
2018-02-27 09:04:30 40 NaN
|
z asof requires a sorted indexNz subset is not valid for Seriesr )Úfreq)rÞ rÿ r¸ Úright©Zsider» r¹ r )rÞ rÿ r rU r@ ) r¿ r§ r rÞ Úis_monotonic_increasingrñ rc rö r[ rv r ræ rM r Úfloat64ÚnanÚ searchsortedr. rf rt r r] r rÉ rÿ Z asof_locsrB rO r9 ) r³ rÐ r Ú is_seriesZis_listÚstartrO r ZnullsrÑ Úmissingr« r´ r´ rµ Úasof sp a
|
|
|
|
ÿ
|
"
|
|
|
|
ÿ
|
|
z NDFrame.asofc C s t | j| ddS )ah
|
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
|
(unless you set ``pandas.options.mode.use_inf_as_na = True``).
|
|
Returns
|
-------
|
{klass}
|
Mask of bool values for each element in {klass} that
|
indicates whether an element is an NA value.
|
|
See Also
|
--------
|
{klass}.isnull : Alias of isna.
|
{klass}.notna : Boolean inverse of isna.
|
{klass}.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 None
|
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
|
rf r+ ©rf rÊ rÎ r´ r´ rµ rf Æ s =z NDFrame.isnac C s t | j| ddS )NÚisnullr+ rñ rÎ r´ r´ rµ rò s zNDFrame.isnullc C s t | j| ddS )a
|
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
|
(unless you set ``pandas.options.mode.use_inf_as_na = True``).
|
NA values, such as None or :attr:`numpy.NaN`, get mapped to False
|
values.
|
|
Returns
|
-------
|
{klass}
|
Mask of bool values for each element in {klass} that
|
indicates whether an element is not an NA value.
|
|
See Also
|
--------
|
{klass}.notnull : Alias of notna.
|
{klass}.isna : Boolean inverse of notna.
|
{klass}.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 None
|
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
|
rg r+ ©rg rÊ rÎ r´ r´ rµ rg s =z NDFrame.notnac C s t | j| ddS )NÚnotnullr+ ró rÎ r´ r´ rµ rô H s zNDFrame.notnull©r c C sÈ |d k rt t|¡s,|d k r4t t|¡r4td| }t| j}t jddJ |d k rr| |k}|j||d dd}|d k r| |k}|j||d dd}W 5 Q R X t |¡r²t j||< |rÀ| |¡S |S d S )Nz*Cannot use an NA value as a clip thresholdr; )r] Fr ) r r rf rñ r. ZerrstaterÐ rë rM )r³ ÚlowerÚupperr r4 rm r r´ r´ rµ Ú_clip_with_scalarL s( ÿ ÿ
|
|
|
|
zNDFrame._clip_with_scalarc C sä |d k r| |¡}t|rLt|rL|jdkr<| jd ||dS | j|d |dS t|tst|rt| trz| j|| j d}nt
|
| ||d dd }t|rº|jdkr¦t j nt j }| |¡}n|}|||dt| B }| j||||dS )NÚlerõ )rÞ )Zflexr» r¹ r )rò r_ r\ rÚ rø r¿ rc r[ rÉ rÞ r r r¿ rË rf rÐ )r³ Ú thresholdr, rº r r Z threshold_infr r´ r´ rµ Ú_clip_with_one_boundf s
|
|
|
z NDFrame._clip_with_one_boundr )r³ rº r r® c K sJ t |d}t |d|¡}|dk r*| |¡}t|}t|sJt |¡rXd}nt |¡rXd}t|}t|sxt |¡rd}nt |¡rd}|dk r¼|dk r¼t |r¼t |r¼t
|
||t || }}|dksÔt |rüt |rü|dksìt |rüt |rü| j |||dS | }|dk r |j|| j||d}|dk rF|r2| }|j|| j||d}|S )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.
|
*args, **kwargs
|
Additional keywords have no effect but might be accepted
|
for compatibility with numpy.
|
|
Returns
|
-------
|
Series or DataFrame or None
|
Same type as calling object with the values outside the
|
clip boundaries replaced or None if ``inplace=True``.
|
|
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 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 2
|
1 -3 -4
|
2 0 6
|
3 6 8
|
4 5 3
|
r r´ Nrõ )r, rº r )rL r? Zvalidate_clip_with_axisrò rf r[ r r r] r_ ÚminÚmaxr\ rø rû Úgerù ) r³ rö r÷ rº r rí Z
|
isna_lowerZ
|
isna_upperr4 r´ r´ rµ Úclip sf k
|
|
|
|
|
|
ÿþýüÿÿÿ
|
ÿ
|
ÿz NDFrame.clipr* )r³ ræ r, ÚhowÚ normalizer r® c C s ddl m} || |||||dS )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 {klass} is a :class:`~pandas.PeriodIndex`, the new index
|
is the result of transforming the original index with
|
:meth:`PeriodIndex.asfreq <pandas.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 first and
|
last 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
|
* '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
|
-------
|
{klass}
|
{klass} 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 `this link
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
|
|
Examples
|
--------
|
Start by creating a series with 4 one minute timestamps.
|
|
>>> index = pd.date_range('1/1/2000', periods=4, freq='T')
|
>>> 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)r, r r r )Úpandas.core.resampler )r³ ræ r, r r r r r´ r´ rµ r ' s r úzNDFrame.asfreq)r³ rð rº r® c C sP |dkr| j }| |¡}| |¡}t|ts4td|j||d}| j||dS )a'
|
Select values at particular time of day (e.g., 9:30AM).
|
|
Parameters
|
----------
|
time : datetime.time or str
|
The values to select.
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
For `Series` this parameter is unused and defaults to 0.
|
|
Returns
|
-------
|
Series or DataFrame
|
|
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
|
NúIndex must be DatetimeIndex)rð r¹ )r rò rè r¿ rs rG Zindexer_at_timerF )r³ rä rð rº rÞ rC r´ r´ rµ Úat_time¤ s /
|
|
|
zNDFrame.at_timeÚbothr. )r³ Ú inclusiverº r® c C s` |dkr| j }| |¡}| |¡}t|ts4tdt|\}}|j||||d}| j||dS )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
|
Nr )Z include_startZ include_endr¹ ) r rò rè r¿ rs rG rN Zindexer_between_timerF ) r³ Ú
|
start_timeZend_timer rº rÞ Zleft_inclusiveZright_inclusiverC r´ r´ rµ Ú between_timeß s D
|
|
|
üzNDFrame.between_timerî Ú start_dayz str | TimestampConvertibleTypesz TimedeltaConvertibleTypes | Noner ) rº ÚclosedrA Ú
|
conventionrØ Úonr ÚoriginÚoffsetÚ
|
group_keysr® c C s< ddl m} | |¡}| td| ||||||||| |
|
| d S )a³6
|
Resample time-series data.
|
|
Convenience method for frequency conversion and resampling of time series.
|
The object must have a datetime-like index (`DatetimeIndex`, `PeriodIndex`,
|
or `TimedeltaIndex`), or the caller must pass the label of a datetime-like
|
series/index to the ``on``/``level`` keyword parameter.
|
|
Parameters
|
----------
|
rule : DateOffset, Timedelta or str
|
The offset string or object representing target conversion.
|
axis : {{0 or 'index', 1 or 'columns'}}, default 0
|
Which axis to use for up- or down-sampling. For `Series` this parameter
|
is unused and defaults to 0. Must be
|
`DatetimeIndex`, `TimedeltaIndex` or `PeriodIndex`.
|
closed : {{'right', 'left'}}, default None
|
Which side of bin interval is closed. The default is 'left'
|
for all frequency offsets except for 'M', 'A', 'Q', 'BM',
|
'BA', 'BQ', and 'W' which all have a default of 'right'.
|
label : {{'right', 'left'}}, default None
|
Which bin edge label to label bucket with. The default is 'left'
|
for all frequency offsets except for 'M', 'A', 'Q', 'BM',
|
'BA', 'BQ', and 'W' which all have a default of 'right'.
|
convention : {{'start', 'end', 's', 'e'}}, default 'start'
|
For `PeriodIndex` only, controls whether to use the start or
|
end of `rule`.
|
kind : {{'timestamp', 'period'}}, optional, default None
|
Pass 'timestamp' to convert the resulting index to a
|
`DateTimeIndex` or 'period' to convert it to a `PeriodIndex`.
|
By default the input representation is retained.
|
|
on : str, optional
|
For a DataFrame, column to use instead of index for resampling.
|
Column must be datetime-like.
|
level : str or int, optional
|
For a MultiIndex, level (name or number) to use for
|
resampling. `level` must be datetime-like.
|
origin : Timestamp or str, default 'start_day'
|
The timestamp on which to adjust the grouping. The timezone of origin
|
must match the timezone of the index.
|
If string, must be one of the following:
|
|
- 'epoch': `origin` is 1970-01-01
|
- 'start': `origin` is the first value of the timeseries
|
- 'start_day': `origin` is the first day at midnight of the timeseries
|
|
.. versionadded:: 1.1.0
|
|
- 'end': `origin` is the last value of the timeseries
|
- 'end_day': `origin` is the ceiling midnight of the last day
|
|
.. versionadded:: 1.3.0
|
|
offset : Timedelta or str, default is None
|
An offset timedelta added to the origin.
|
|
.. versionadded:: 1.1.0
|
|
group_keys : bool, default False
|
Whether to include the group keys in the result index when using
|
``.apply()`` on the resampled object.
|
|
.. versionadded:: 1.5.0
|
|
Not specifying ``group_keys`` will retain values-dependent behavior
|
from pandas 1.4 and earlier (see :ref:`pandas 1.5.0 Release notes
|
<whatsnew_150.enhancements.resample_group_keys>` for examples).
|
|
.. versionchanged:: 2.0.0
|
|
``group_keys`` now defaults to ``False``.
|
|
Returns
|
-------
|
pandas.core.Resampler
|
:class:`~pandas.core.Resampler` object.
|
|
See Also
|
--------
|
Series.resample : Resample a Series.
|
DataFrame.resample : Resample a DataFrame.
|
groupby : Group {klass} by mapping, function, label, or list of labels.
|
asfreq : Reindex a {klass} with the given frequency without grouping.
|
|
Notes
|
-----
|
See the `user guide
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#resampling>`__
|
for more.
|
|
To learn more about the offset strings, please see `this link
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects>`__.
|
|
Examples
|
--------
|
Start by creating a series with 9 one minute timestamps.
|
|
>>> index = pd.date_range('1/1/2000', periods=9, freq='T')
|
>>> 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: T, dtype: int64
|
|
Downsample the series into 3 minute bins and sum the values
|
of the timestamps falling into a bin.
|
|
>>> series.resample('3T').sum()
|
2000-01-01 00:00:00 3
|
2000-01-01 00:03:00 12
|
2000-01-01 00:06:00 21
|
Freq: 3T, 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).
|
To include this value close the right side of the bin interval as
|
illustrated in the example below this one.
|
|
>>> series.resample('3T', 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: 3T, dtype: int64
|
|
Downsample the series into 3 minute bins as above, but close the right
|
side of the bin interval.
|
|
>>> series.resample('3T', 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: 3T, 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('3T').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: 3T, 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='A',
|
... periods=2))
|
>>> s
|
2012 1
|
2013 2
|
Freq: A-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.
|
|
>>> d = {{'price': [10, 11, 9, 13, 14, 18, 17, 19],
|
... 'volume': [50, 60, 40, 100, 50, 100, 40, 50]}}
|
>>> df = pd.DataFrame(d)
|
>>> 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('M', 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')
|
>>> d2 = {{'price': [10, 11, 9, 13, 14, 18, 17, 19],
|
... 'volume': [50, 60, 40, 100, 50, 100, 40, 50]}}
|
>>> df2 = pd.DataFrame(
|
... d2,
|
... 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: 7T, 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: 17T, 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: 17T, 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: 17T, 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: 17T, 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: 17T, 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: 17T, 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: 17T, dtype: int64
|
r )Ú get_resamplerzSeries | DataFrame) ræ rA r rº rØ r r r r r r )r r rò r ) r³ Zrulerº r rA r rØ r r r r r r r´ r´ rµ Úresample4! s&
|
ôzNDFrame.resamplec C s¼ t | jtstdt| jdkr.| jddS t|}t |tsj| | jd ¡rj| jd |j | }}n| jd | }}t |tr®|| jkr®| jj
|
|dd}| j d|
S | j d|
S )aþ
|
Select initial periods of time series data based on a date offset.
|
|
For a DataFrame with a sorted DatetimeIndex, this function can
|
select the first few rows based on a date offset.
|
|
Parameters
|
----------
|
offset : str, DateOffset or dateutil.relativedelta
|
The offset length of the data that will be selected. For instance,
|
'1M' will display all the rows having their index within the first month.
|
|
Returns
|
-------
|
Series or DataFrame
|
A subset of the caller.
|
|
Raises
|
------
|
TypeError
|
If the index is not a :class:`DatetimeIndex`
|
|
See Also
|
--------
|
last : Select final periods of time series based on a date offset.
|
at_time : Select values at a particular time of the day.
|
between_time : Select values between particular times of the day.
|
|
Examples
|
--------
|
>>> i = pd.date_range('2018-04-09', periods=4, freq='2D')
|
>>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
|
>>> ts
|
A
|
2018-04-09 1
|
2018-04-11 2
|
2018-04-13 3
|
2018-04-15 4
|
|
Get the rows for the first 3 days:
|
|
>>> ts.first('3D')
|
A
|
2018-04-09 1
|
2018-04-11 2
|
|
Notice the data for 3 first calendar days were returned, not the first
|
3 days observed in the dataset, and therefore data for 2018-04-13 was
|
not returned.
|
z+'first' only supports a DatetimeIndex indexr FrÓ Úleftrè N) r¿ rÞ rs rG rÀ r¬ r r Z is_on_offsetÚbaserì r9 rO )r³ r Úend_dateÚendr´ r´ rµ ÚfirstÇ" s 4 z NDFrame.firstc C sb t | jtstdt| jdkr.| jddS t|}| jd | }| jj|dd}| j|d
S ) aõ
|
Select final periods of time series data based on a date offset.
|
|
For a DataFrame with a sorted DatetimeIndex, this function
|
selects the last few rows based on a date offset.
|
|
Parameters
|
----------
|
offset : str, DateOffset, dateutil.relativedelta
|
The offset length of the data that will be selected. For instance,
|
'3D' will display all the rows having their index within the last 3 days.
|
|
Returns
|
-------
|
Series or DataFrame
|
A subset of the caller.
|
|
Raises
|
------
|
TypeError
|
If the index is not a :class:`DatetimeIndex`
|
|
See Also
|
--------
|
first : Select initial periods of time series based on a date offset.
|
at_time : Select values at a particular time of the day.
|
between_time : Select values between particular times of the day.
|
|
Examples
|
--------
|
>>> i = pd.date_range('2018-04-09', periods=4, freq='2D')
|
>>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
|
>>> ts
|
A
|
2018-04-09 1
|
2018-04-11 2
|
2018-04-13 3
|
2018-04-15 4
|
|
Get the rows for the last 3 days:
|
|
>>> ts.last('3D')
|
A
|
2018-04-13 3
|
2018-04-15 4
|
|
Notice the data for 3 last calendar days were returned, not the last
|
3 observed days in the dataset, and therefore data for 2018-04-11 was
|
not returned.
|
z*'last' only supports a DatetimeIndex indexr FrÓ r@ rç rè N) r¿ rÞ rs rG rÀ r¬ r rì r9 )r³ r Z
|
start_daterî r´ r´ rµ rz # s 4 z NDFrame.lastÚaverageÚkeep)r³ rº r, Ú numeric_onlyÚ na_optionru Úpctr® c
|
sj |¡dkr d}t| fdd}|r^jdkrTtjsTtd ¡ } n} || S )aÔ
|
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
|
> Útopr Úbottomz3na_option must be one of 'keep', 'top', or 'bottom'c sn | j dkr| j}n| j}t|tr8|j d}ntj| d}j|f| ¡ }|j
|
ddS )Nr÷ )rº r, ru r r Úrankr+ ) rø r r. r¿ ro Z_rankÚalgosr rÉ rï rÊ )r« r ZranksZ ranks_obj©ru rz r, r r r³ r´ rµ ÚrankerÃ# s*
|
|
ûú z NDFrame.rank.<locals>.rankerr» zDSeries.rank does not allow numeric_only=True with non-numeric dtype.)rò rñ rø r] r¸ rG r° )
|
r³ rº r, r r ru r r r" r« r´ r! rµ r P# s m
|
ÿ
|
z NDFrame.rankÚcomparer» r^ r9 )Ú
|
align_axisÚ
|
keep_shapeÚ
|
keep_equalÚ result_namesc C sÜ t | t |k rBt | jt |j }}td| d| d| d| |k| ¡ | ¡ @ B }|jddd |s| |¡} | |¡}|sÒt| trÂ| ¡ } |jdd}
|
| j |
|
| f } |j |
|
| f }n| | } || }t|t
|
sðtd t | d
|
|d kr d} n
|
| |¡} t | |g| |d } | | j kr,| S | | ¡} t | j¡}t t|¡| _ttd| jd g }t| tr| j|| d} n
|
| |¡} || | j| d_t | j| ¡ d| j| d g¡j ¡ }| j || d} | S )Nzcan only compare 'z' (not 'z ') with 'r Trõ r» r¹ z Passing 'result_names' as a z= is not supported. Provide 'result_names' as a tuple instead.)r» rö )rº r r r÷ ) r` rÚ rG rf rË rÐ r¿ rb r rO r rò r
rø rè r Úarrayrû rÏ rÀ r¦ r- ZnlevelsZreorder_levelsr Úreshaper: ÚflattenrB )r³ r\ r$ r% r& r' Zcls_selfZ cls_otherrm ZcmaskZrmaskrº ZdiffrO Zax_namesÚorderrA r´ r´ rµ r# í# sP ÿ
|
|
|
|
ÿ
|
|
|
|
(ÿzNDFrame.compareÚouterr ) r³ r\ r® rº r r¬ r r, rb Ú fill_axisÚbroadcast_axisr® c s* t |}|
|
dkr´j jkr´ttrhj} | fdd jD f ¡ } | j |||||||| d S t tr´ j} | fddjD f ¡ } j| |||||||| d S |dk rÆ |¡}t t rìj |||||||| d S t trj
|
|||||||| d S t dt dS )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
|
join : {{'outer', 'inner', 'left', 'right'}}, default 'outer'
|
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 True
|
Always returns new objects. If copy=False and no reindexing is
|
required then original objects are returned.
|
fill_value : scalar, default np.NaN
|
Value to use for missing values. Defaults to NaN, but can be any
|
"compatible" value.
|
method : {{'backfill', 'bfill', 'pad', 'ffill', None}}, default None
|
Method to use for filling holes in reindexed Series:
|
|
- pad / ffill: propagate last valid observation forward to next valid.
|
- backfill / bfill: use NEXT valid observation to fill gap.
|
|
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.
|
fill_axis : {axes_single_arg}, default 0
|
Filling axis, method and limit.
|
broadcast_axis : {axes_single_arg}, default None
|
Broadcast values along this axis, if aligning two objects of
|
different dimensions.
|
|
Returns
|
-------
|
tuple of ({klass}, type of other)
|
Aligned objects.
|
|
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» c s i | ]
|
}| qS r´ r´ r rÎ r´ rµ rë º$ s z!NDFrame.align.<locals>.<dictcomp>)r® rº r r¬ r r, rb r- c s i | ]
|
}| qS r´ r´ r )r\ r´ rµ rë Ì$ s Nzunsupported type: ) r rø r¿ rc Z_constructor_expanddimrö rï Ú _align_framerò rb Ú _align_seriesrG r` ) r³ r\ r® rº r r¬ r r, rb r- r. rÇ rÕ r´ r[ rµ Úalign6$ s |
|
ÿÿ÷
|
ÿÿ÷
|
|
÷ ÷ z NDFrame.align)r® rº r¬ r- c
|
C sP d\}
|
} d\} } d\}}t | t}|d ks2|dkr\| j |j¡s\| jj|j||dd\}
|
} } |d ksl|dkr|s| j |j¡s| jj|j||dd\} }}|r¬d|
|
| gi}n|
|
| g| |gd}| j|||dd}|j|
|
| g| |gd||dd}|d k r,|j|| |d}|d k st|}|j|| |d}t |||
|
\}}|
|
| ¡|
|
|¡fS ) N©NNr T©r r Zreturn_indexersr» )r r» )r¬ r rj ©r, rº rb ) r¿ rc rÞ rZ r® rö r rË rõ Ú _align_as_utcrÊ )r³ r\ r® rº r r¬ r r, rb r- Ú
|
join_indexZ join_columnsZilidxZiridxZclidxZcridxrí r r rç Ú_leftr´ r´ rµ r/ ÷$ sb
|
ÿ ÿÿþ ý ÿ ÿü
|
þzNDFrame._align_framec
|
C s t | t}
|
|rt rd}|
|
s$|d ks,|dkr4td|
|
rH|dkrHtd|sÞ| j |j¡rfd\} } } n | jj|j||dd\} } } |
|
r| | | |¡}n8| d ks¦| d kr´| j|d }n| | j
|
j | | d|d
|
¡}| | | |¡}n®| j
|
}| j d } d \} } | |j¡s | j|j||dd\} } } | d k rB| d¡}|j | | |d }|r\|| j
|
kr\| ¡ }| |¡}| d kr~|j|d }n|j| |d }t|p|d k }|rÆ|j|||| d}|j|||d}|
|
sÜ|
|
sì|dkrìt||| \}}| | ¡| |¡fS )NF)Nr r» zMust specify axis=0 or 1r» z1cannot align series to a series other than axis 0)NNNTr3 rÓ r r2 r¹ rE )r, rb rº rÌ r )r¿ rc r rñ rÞ rZ r® Z_reindex_indexerr¬ rÉ r rl r r¾ rd rg rË r5 rÊ )r³ r\ r® rº r r¬ r r, rb r- rí r6 ZlidxZridxr rç ÚfdatarÆ Zfill_nar´ r´ rµ r0 7% sh
|
|
ÿ ÿ
|
ÿ
|
|
|
|
þzNDFrame._align_series)r rº c C sÎ t |d}|dk r | |¡}t || ¡}t|trJ|j| ddddd }nBt|ds^t |¡}|j
|
| j
|
krrt d | j |f| ¡ d
|
di}t|}| |¡}d }|jsôt|tsÎt|sòt |j|jd qþ|jD ] }t|sÔt |j|d qÔn
|
| t¡}|r
|
| n|}|j| j| jdd }t|trÌ|j| jkrÂ| j|d||dddd }|dkrp| | ¡spt |j| jk rÊ|j }|dkrt |d¡}n|dkr²t |d¡}t || j
|
¡}nt dn t|t!tfsèt"|dd}t|tj#t$fr8|j
|
| j
|
kr | jdkr8t dn| j |f| ¡ d
|
di}|dkrFd}| jt%|ddkr`d} n| |¡dk} |r¤| &|¡ | j'j(||| d}
|
| |
|
¡} | )| ¡S | j'j*||| d}
|
| |
|
¡} | +| ¡S dS )z
|
Equivalent to public method `where`, except that `other` is not
|
applied as a function even if callable. Used in __setitem__.
|
r Nrç r» F)r® r. r¬ r r z,Array conditional must be same shape as selfr¬ z5Boolean array expected for the condition, not {dtype}r¼ r r )r® rº r r r¬ )r@ r» )r» r@ z.cannot align with a higher dimensional NDFrameT)Z extract_numpyz4other must be the same shape as self when an ndarrayrø )rm Únewr1 )r\ Úcondr1 ),rL rò rj Úapply_if_callabler¿ r r1 Úhasattrr Z
|
asanyarrayr rñ rÉ rï rq rË r rb rT rè r¸ r rà rd r rã rø r_ rE r. r) Z broadcast_torÙ ru rq rK ro rù r¯ r ZputmaskrM rÐ rÊ ) r³ r: r\ r rº r r r Z_dtr1 rj r4 r´ r´ rµ Ú_where% s
|
|
|
|
|
|
|
|
|
úù
|
|
|
ÿ ÿÿÿÿ
|
|
|
|
ý
|
zNDFrame._where)r rº r )r³ r rº r r® c C s d S rÐ r´ ©r³ r: r\ r rº r r´ r´ rµ rÐ & s
|
z NDFrame.where)rº r )r rº r r® c C s d S rÐ r´ r> r´ r´ rµ rÐ & s
|
c C s d S rÐ r´ r> r´ r´ rµ rÐ '& s
|
ÚTrueÚFalserÐ rm )r r: Zcond_revrÿ Z
|
name_otherc C s t || ¡}| |||||¡S )aü
|
Replace values where the condition is {cond_rev}.
|
|
Parameters
|
----------
|
cond : bool {klass}, array-like, or callable
|
Where `cond` is {cond}, keep the original value. Where
|
{cond_rev}, replace with corresponding value from `other`.
|
If `cond` is callable, it is computed on the {klass} and
|
should return boolean {klass} or array. The callable must
|
not change input {klass} (though pandas doesn't check it).
|
other : scalar, {klass}, or callable
|
Entries where `cond` is {cond_rev} are replaced with
|
corresponding value from `other`.
|
If other is callable, it is computed on the {klass} and
|
should return scalar or {klass}. The callable must not
|
change input {klass} (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
|
-------
|
Same type as caller or None if ``inplace=True``.
|
|
See Also
|
--------
|
:func:`DataFrame.{name_other}` : Return an object of same shape as
|
self.
|
|
Notes
|
-----
|
The {name} method is an application of the if-then idiom. For each
|
element in the calling DataFrame, if ``cond`` is ``{cond}`` the
|
element is used; otherwise the corresponding element from the DataFrame
|
``other`` is used. If the axis of ``other`` does not align with axis of
|
``cond`` {klass}, the misaligned index positions will be filled with
|
{cond_rev}.
|
|
The signature for :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 ``{name}`` documentation in
|
:ref:`indexing <indexing.where_mask>`.
|
|
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
|
)rj r; r= r> r´ r´ rµ rÐ 3& s c C s d S rÐ r´ r> r´ r´ rµ rm Ï& s
|
z NDFrame.maskc C s d S rÐ r´ r> r´ r´ rµ rm Û& s
|
c C s d S rÐ r´ r> r´ r´ rµ rm ç& s
|
c C s@ t |d}t || ¡}t|ds*t |¡}| j| ||||dS )Nr rn )r\ r rº r )rL rj r; r< r r( rÐ r> r´ r´ rµ rm ó& s
|
|
|
û)r³ Úperiodsrº r r® c C s |dkr| j ddS |dkrL| |¡}| jj|||d}| |¡j| ddS | |¡}|dkrt|dd}|dkr~t|d d}|dkr¦d
|
}t|nt |t
|
r¦t |}t |t ròt |j }||kræ|dk sÎttd |j d |j | |¡} n | ||¡} | j| |d }
|
|
|
j| ddS )aa
|
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
|
Number of periods to shift. Can be positive or negative.
|
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 numeric data, ``np.nan`` is used.
|
For datetime, timedelta, or period data, etc. :attr:`NaT` is used.
|
For extension dtypes, ``self.dtype.na_value`` is used.
|
|
.. versionchanged:: 1.1.0
|
|
Returns
|
-------
|
{klass}
|
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({{"Col1": [10, 20, 15, 30, 45],
|
... "Col2": [13, 23, 18, 33, 48],
|
... "Col3": [17, 27, 22, 37, 52]}},
|
... 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
|
r NrÓ )rA rº r Úshiftr+ rÕ ræ Z inferred_freqz6Freq was not set in the index hence cannot be inferredz Given freq z! does not match PeriodIndex freq r¹ )r¬ rò r rB rÉ rÊ rè rù rñ r¿ r§ r rv ræ rõ Z rule_coder ) r³ rA ræ rº r rj rÞ r Z orig_freqrP r4 r´ r´ rµ rB ' s> j
|
ÿ
|
|
|
|
|
ÿ z NDFrame.shiftc C s |dkr| j }| |¡}| |¡}|js6|js6td|jrXddlm} ||}||}|dk r|dk r||krtd| d| t |dkr¬|jr¬|
|
¡ dkr¬|| }}t ddg| j }t ||||< | j t| }t|tr t|| |¡| ||¡ |j|ot d}|S ) aa
|
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 is True,
|
Return a copy of the truncated section.
|
|
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: object
|
|
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
|
Nz truncate requires a sorted indexr )Ú to_datetimez
|
Truncate: z must be after r» rÓ )r rò rè ré Zis_monotonic_decreasingrñ Z _is_all_datesZpandas.core.tools.datetimesrC rÀ r r7 rå rO r r¿ ru r rô Útruncater¬ r ) r³ ZbeforeÚafterrº r¬ rO rC Zslicerr4 r´ r´ rµ rD §' s* }
|
|
|
zNDFrame.truncatec s² ¡ ¡} fdd}t|trV| |¡}||j| |}|j||d}n*|dd|jfkrvtd| d|||}j |ot
|
d}|j | d d
|
}|j d d S ) a%
|
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 True
|
Also make a copy of the underlying data.
|
|
Returns
|
-------
|
{klass}
|
Object with time zone converted axis.
|
|
Raises
|
------
|
TypeError
|
If the axis is tz-naive.
|
|
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 sJ t | ds<t| dkr. ¡}t| dtg |d} n
|
| |¡} | S )NÚ
|
tz_convertr ú, is not a valid DatetimeIndex or PeriodIndex©Útz)r< rÀ rô rG rs rF )rO rI Úax_namer r´ rµ Ú _tz_convert}( s
|
|
ÿ
|
z'NDFrame.tz_convert.<locals>._tz_convertrE Nr ú
|
The level ú is not validrÓ Fr rF r+ ) rò rè r¿ ru rJ ÚlevelsÚ
|
set_levelsrÿ rñ r¬ r r rÊ ) r³ rI rº r r¬ rO rK Ú new_levelr4 r´ r rµ rF G( s 3
|
|
|
|
|
zNDFrame.tz_convertr; r= )r³ rº r¬ Ú ambiguousÚ nonexistentr® c sÚ d}||kr t |tjs td ¡ ¡} fdd} t |trz| |¡}| |j| |||}
|
|j |
|
|d}n.|dd|j
|
fkrtd| d | ||||}j |o¶t d
|
} | j | d d } | jd dS )aß
|
Localize tz-naive index of a Series or DataFrame to target time zone.
|
|
This operation localizes the Index. To localize the values in a
|
timezone-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 True
|
Also make a copy of the underlying data.
|
ambiguous : 'infer', 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-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 an AmbiguousTimeError 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 an NonExistentTimeError if there are
|
nonexistent times.
|
|
Returns
|
-------
|
{klass}
|
Same type as the input.
|
|
Raises
|
------
|
TypeError
|
If the TimeSeries is tz-aware and tz is not None.
|
|
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'`.
|
|
>>> s = pd.Series(range(2),
|
... index=pd.DatetimeIndex(['2015-03-29 02:30:00',
|
... '2015-03-29 03:30:00']))
|
>>> 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
|
)r? ZNaTZ shift_forwardZshift_backwardzoThe nonexistent argument must be one of 'raise', 'NaT', 'shift_forward', 'shift_backward' or a timedelta objectc sP t | ds<t| dkr. ¡}t| dtg |d} n| j|||d} | S )NÚ tz_localizer rG rH )rQ rR )r< rÀ rô rG rs rS )rO rI rQ rR rJ r r´ rµ Ú _tz_localize3) s
|
|
ÿz)NDFrame.tz_localize.<locals>._tz_localizerE Nr rL rM rÓ Fr rS r+ )r¿ ÚdtÚ timedeltarñ rò rè ru rJ rN rO rÿ r¬ r r rÊ ) r³ rI rº r r¬ rQ rR Znonexistent_optionsrO rT rP r4 r´ r rµ rS ( s,
|
ÿÿ
|
|
|
|
zNDFrame.tz_localizec C s t | |||dS )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 is
|
``[.25, .5, .75]``, which returns 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 or timestamps), 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. Timestamps also include the ``first`` and ``last`` items.
|
|
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
|
)r r ÚexcludeÚ percentilesr )r³ rX r rW r´ r´ rµ ÚdescribeQ) s süzNDFrame.describer× z5Literal[('backfill', 'bfill', 'pad', 'ffill')] | None)r³ rA Ú fill_methodr® c K s | | d| j¡¡}|dkr"| }n | j|||d}|dk s>t|}|jf |||d|} || d }
|
|dk r|
|
j|
|
j ¡ }
|
|
|
|¡}
|
|
|
j
|
| ddS )a*
|
Percentage change between the current and a prior element.
|
|
Computes the percentage change from the immediately previous row by
|
default. This is useful in comparing the percentage of change in a time
|
series of elements.
|
|
Parameters
|
----------
|
periods : int, default 1
|
Periods to shift for forming percent change.
|
fill_method : {'backfill', 'bfill', 'pad', 'ffill', None}, default 'pad'
|
How to handle NAs **before** computing percent changes.
|
limit : int, default None
|
The number of consecutive NAs to fill before stopping.
|
freq : DateOffset, timedelta, or str, optional
|
Increment to use from time series API (e.g. 'M' 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.pct_change(fill_method='ffill')
|
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
|
rº Nr4 )rA ræ rº r» Ú
|
pct_changer+ ) rò r5 r rË rõ rB rO rÞ Z
|
duplicatedre rÊ ) r³ rA rZ rb ræ rí rº r« rÝ Zshiftedr r´ r´ rµ r[ J* s {
|
zNDFrame.pct_changezSeries | bool_t)rÿ rº Ú bool_onlyÚskipnar® c K sÖ t jd||d t|ddd | jdkrd|d krd| j||fd||d|}|j||fd|i|S | jdkrÀ|dkrÀt| jjdkrÀtd d
|
| jjD rÀ|sÀ| }|r°| ¡ }|j
|
|||d S | j |||||d d S )Nr´ ©Úfnamer] F©Z none_allowedr» r ©rº r\ r] c s s | ]}|j d kV qdS )r÷ N)rø r r´ r´ rµ r ð* s z(NDFrame._logical_func.<locals>.<genexpr>©r] rq )rÿ rº r] r Z filter_type) r? Zvalidate_logical_funcrL rø Ú _logical_funcrÀ r Zarraysr] r± Z _reduce_axis1Ú_reduce) r³ rÿ r rº r\ r] rí rk r r´ r´ rµ rc ×* sH
|
ÿ ÿÿÿþýûú úzNDFrame._logical_funczDataFrame | Series | bool_t)rº r\ r] r® c K s | j dtj|||f|S )Nr )rc rl Znanany©r³ rº r\ r] rí r´ r´ rµ r + s ÿÿz NDFrame.anyc K s | j dtj|||f|S )Nr] )rc rl Znanallre r´ r´ rµ r] + s ÿÿz NDFrame.all)rÿ rº r] c s t |¡|d kr | j}n
|
| |¡}|dkrT| jj f|ddjS fdd}| j |¡}| |¡j | dS )Nr» r ©rº r] c s^ t | dr| jn| }t|tr6|jfdi}ntj| d}t |drV|jn|}|S )Nr: r] rb )r< r: r¿ ro Ú _accumulaterl Z na_accum_func)Z
|
blk_valuesr r4 ©r rí rÿ r] r´ rµ Úblock_accum_func-+ s
|
z-NDFrame._accum_func.<locals>.block_accum_funcr+ )
|
r? Z validate_cum_func_with_skipnar rò r: Ú _accum_funcr rh rÉ rÊ ) r³ rÿ r rº r] r rí ri r4 r´ rh rµ rj + s&
|
|
ÿÿ ÿÿ zNDFrame._accum_funcrf c O s | j dtjj||f||S )NÚcummax)rj r ÚmaximumÚ
|
accumulate©r³ rº r] r rí r´ r´ rµ rk =+ s ÿÿÿzNDFrame.cummaxc O s | j dtjj||f||S )NÚcummin)rj r Úminimumrm rn r´ r´ rµ ro B+ s ÿÿÿzNDFrame.cumminc O s | j dtj||f||S )NÚcumsum)rj r rq rn r´ r´ rµ rq G+ s zNDFrame.cumsumc O s | j dtj||f||S )NÚcumprod)rj r rr rn r´ r´ rµ rr J+ s zNDFrame.cumprodzSeries | float)rÿ rº r] Úddofr r® c K sB t jd||d t|ddd |d kr,| j}| j||||||dS )Nr´ r^ r] Fr` )rº r r] rs )r? Zvalidate_stat_ddof_funcrL r rd )r³ rÿ r rº r] rs r rí r´ r´ rµ Ú_stat_function_ddofM+ s ÿzNDFrame._stat_function_ddof)rº r] rs r r® c K s | j dtj||||f|S )NÚsem)rt rl Znansem©r³ rº r] rs r rí r´ r´ rµ ru a+ s ÿÿz NDFrame.semc K s | j dtj||||f|S )NÚvar)rt rl Znanvarrv r´ r´ rµ rw m+ s ÿÿz NDFrame.varc K s | j dtj||||f|S )NÚstd)rt rl Znanstdrv r´ r´ rµ rx y+ s ÿÿz NDFrame.std©rÿ rº r] r c K sH |dkrt d|¡ nt jd||d t|ddd | j|||||dS )NÚmedianr´ r^ r] Fr` ry )r? Zvalidate_medianÚvalidate_stat_funcrL rd )r³ rÿ r rº r] r rí r´ r´ rµ Ú_stat_function
+ s
|
ÿzNDFrame._stat_function©rº r] r c K s | j dtj|||f|S )Nrü )r| rl Znanmin©r³ rº r] r rí r´ r´ rµ rü + s ûúz NDFrame.minc K s | j dtj|||f|S )Nrý )r| rl Znanmaxr~ r´ r´ rµ rý ª+ s ûúz NDFrame.max)rº r] r r® c K s | j dtj|||f|S )NÚmean)r| rl Znanmeanr~ r´ r´ rµ r º+ s ÿÿz NDFrame.meanc K s | j dtj|||f|S )Nrz )r| rl Z nanmedianr~ r´ r´ rµ rz Å+ s ÿÿzNDFrame.medianc K s | j dtj|||f|S )NÚskew)r| rl Znanskewr~ r´ r´ rµ r Ð+ s ÿÿz NDFrame.skewc K s | j dtj|||f|S )NÚkurt)r| rl Znankurtr~ r´ r´ rµ r Û+ s ÿÿz NDFrame.kurt©rÿ rº r] r Ú min_countc K sn |dkrt d|¡ n&|dkr,t d|¡ nt jd||d t|ddd |d krX| j}| j||||||dS ) NÚsumr´ r r^ r] Fr` r )r? Z validate_sumZ validate_prodr{ rL r rd )r³ rÿ r rº r] r r rí r´ r´ rµ Ú_min_count_stat_functionè+ s úz NDFrame._min_count_stat_function©rº r] r r c K s | j dtj||||f|S )Nr )r
rl Znansum©r³ rº r] r r rí r´ r´ rµ r , s ÿÿz NDFrame.sumc K s | j dtj||||f|S )Nr )r
rl Znanprodr r´ r´ rµ r , s úùz NDFrame.prodc
|
C sÎ t | \}}}ttt|||ttddddddddd d
|
d }t| d | ttt|||tt dddVddd d d}t| d| tt
|
d|||ddddWddddddd}t| d| tt
|
d|||dt ddXddddddd }t| d | tt
|
d |||t t ddYdddddd d }t| d!| ttd"|||d#td$dZddd d%d&} t| d'| ttd(|||d)td$d[ddd d*d+}
|
t| d,|
|
ttd-|||d-td$d\ddd d.d/} t| d0| ttd1|||d2td$d]ddd d3d4} t| d5| ttd6|||tttd7d^ddddd8d9d:} t| d-| ttd;|||tttd7d_ddddd8d<d=}t| d2| || _ttd>|||dddd7d`d?ddd@dAdB}t| dC| ttdD|||dddd7dad?ddd@dEdF}t| dG| ttdH|||dddd7dbdddd@dIdJ}t| dK| || _ttdL|||dddd7dcd?ddd@dMdN}t| dO| ttdP|||dttd7ddd?ddd@dQdR}t| d)| ttdS|||dttd7ded?ddd@dTdU}t| d#| dS )fzO
|
Add the operations to the cls; evaluate the doc strings again
|
F)ÚdescÚname1Úname2Ú
|
axis_descrÚsee_alsoÚexamplesZ empty_valuer NTra r r© rf c [ s t j| f|||d|S )Nra )r r re r´ r´ rµ r /, s ÿüûz,NDFrame._add_numeric_operations.<locals>.anyr c [ s t j| |||f|S rÐ )r r] re r´ r´ rµ r] K, s z,NDFrame._add_numeric_operations.<locals>.allr] zReturn unbiased standard error of the mean over requested axis.
|
|
Normalized by N-1 by default. This can be changed using the ddof argumentr )r r r r Znotesr r» r6 râ )rº r] rs r c [ s t j| ||||f|S rÐ )r ru rv r´ r´ rµ ru `, s z,NDFrame._add_numeric_operations.<locals>.semru zyReturn unbiased variance over requested axis.
|
|
Normalized by N-1 by default. This can be changed using the ddof argument.c [ s t j| ||||f|S rÐ )r rw rv r´ r´ rµ rw w, s z,NDFrame._add_numeric_operations.<locals>.varrw zReturn sample standard deviation over requested axis.
|
|
Normalized by N-1 by default. This can be changed using the ddof argument.c [ s t j| ||||f|S rÐ )r rx rv r´ r´ rµ rx , s z,NDFrame._add_numeric_operations.<locals>.stdrx rp rü )r r r r Zaccum_func_namer c _ s t j| ||f||S rÐ )r ro rn r´ r´ rµ ro ¤, s z/NDFrame._add_numeric_operations.<locals>.cumminro rl rý c _ s t j| ||f||S rÐ )r rk rn r´ r´ rµ rk ´, s z/NDFrame._add_numeric_operations.<locals>.cummaxrk r c _ s t j| ||f||S rÐ )r rq rn r´ r´ rµ rq Ä, s z/NDFrame._add_numeric_operations.<locals>.cumsumrq Úproductr c _ s t j| ||f||S rÐ )r rr rn r´ r´ rµ rr Ô, s z0NDFrame._add_numeric_operations.<locals>.cumprodrr zfReturn the sum of the values over the requested axis.
|
|
This is equivalent to the method ``numpy.sum``.)r r r r r r r r c [ s t j| ||||f|S rÐ )r r r r´ r´ rµ r å, s z,NDFrame._add_numeric_operations.<locals>.sumz9Return the product of the values over the requested axis.c [ s t j| ||||f|S rÐ )r r r r´ r´ rµ r ü, s z-NDFrame._add_numeric_operations.<locals>.prodz6Return the mean of the values over the requested axis.zAxisInt | Noner} c [ s t j| |||f|S rÐ )r r r~ r´ r´ rµ r - s z-NDFrame._add_numeric_operations.<locals>.meanr z=Return unbiased skew over requested axis.
|
|
Normalized by N-1.c [ s t j| |||f|S rÐ )r r r~ r´ r´ rµ r (- s z-NDFrame._add_numeric_operations.<locals>.skewr zReturn unbiased kurtosis over requested axis.
|
|
Kurtosis obtained using Fisher's definition of
|
kurtosis (kurtosis of normal == 0.0). Normalized by N-1.c [ s t j| |||f|S rÐ )r r r~ r´ r´ rµ r =- s z-NDFrame._add_numeric_operations.<locals>.kurtr z8Return the median of the values over the requested axis.c [ s t j| |||f|S rÐ )r rz r~ r´ r´ rµ rz V- s z/NDFrame._add_numeric_operations.<locals>.medianrz zµReturn 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``.c [ s t j| |||f|S rÐ )r rý r~ r´ r´ rµ rý k- s z,NDFrame._add_numeric_operations.<locals>.maxzµReturn 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``.c [ s t j| |||f|S rÐ )r rü r~ r´ r´ rµ rü - s z,NDFrame._add_numeric_operations.<locals>.min)r NT)NTr» F)NTr» F)NTr» F)NT)NT)NT)NT)NTFr )NTFr )r TF)r TF)r TF)r TF)r TF)r TF) Ú _doc_paramsrH Ú _bool_docÚ _any_descÚ _any_see_alsoÚ _any_examplesr Ú _all_descÚ _all_see_alsoÚ _all_examplesÚ _num_ddof_docÚ _var_examplesÚ
|
_std_notesÚ _std_examplesÚ _cnum_docÚ_cummin_examplesÚ_cummax_examplesÚ_cumsum_examplesÚ_cumprod_examplesÚ_num_docÚ_min_count_stubÚ_stat_func_see_alsoÚ _sum_examplesÚ_prod_examplesr ÚkurtosisÚ _max_examplesÚ _min_examples)rÄ r r r r r] ru rw rx ro rk rq rr r r r r r rz rý rü r´ r´ rµ Ú_add_numeric_operations(, sø ø û ø ü ÷ û
|
ø û
|
÷ û
|
ù
|
ÿ ù
|
ÿ ù
|
ÿ ù
|
ÿ ÷ û
|
ø û
|
ø ü ø ü õ ü ø ü ö ü ö ü z NDFrame._add_numeric_operationsÚsinglez3int | dt.timedelta | str | BaseOffset | BaseIndexerzWindow | Rolling)
|
ÚwindowÚ min_periodsÚcenterÚwin_typer rº r Ústepr, r® c
|
|
C sJ | |¡}|d k r.t| ||||||||| d
|
S t| ||||||||| d
|
S )N) rª r« r¬ r r rº r r® r, )rò r r )
|
r³ rª r« r¬ r r rº r r® r, r´ r´ rµ Úrolling- s4
|
ö özNDFrame.rollingr )r« rº r, r® c C s | |¡}t| |||dS )N)r« rº r, )rò r )r³ r« rº r, r´ r´ rµ Ú expandingÄ- s
|
zNDFrame.expandingz(float | TimedeltaConvertibleTypes | Nonez&np.ndarray | DataFrame | Series | Noner ) ÚcomÚspanÚhalflifeÚalphar« ÚadjustÚ ignore_narº Útimesr, r® c C s( | |¡}t| ||||||||| |
|
d S )N)
|
r± r² r³ r´ r« rµ r¶ rº r· r, )rò r ) r³ r± r² r³ r´ r« rµ r¶ rº r· r, r´ r´ rµ ÚewmÏ- s
|
õz NDFrame.ewmc C sh || |}| j dkrD| | ¡rDt|j| jrD| j td|j¡ | S | ¡ | j |j
|
| dddd | S )z<
|
Wrap arithmetic method to operate inplace.
|
r» NFrH )r: ) rø r_ rX r¸ r Zsetitem_inplacer7 r. r8 rM re )r³ r\ Úopr4 r´ r´ rµ Ú_inplace_methodð- s$
|
ÿþ ý ÿ ÿzNDFrame._inplace_methodc C s | |t| j¡S rÐ )rº r` Ú__add__r^ r´ r´ rµ Ú__iadd__. s zNDFrame.__iadd__c C s | |t| j¡S rÐ )rº r` Ú__sub__r^ r´ r´ rµ Ú__isub__. s zNDFrame.__isub__c C s | |t| j¡S rÐ )rº r` Ú__mul__r^ r´ r´ rµ Ú__imul__. s zNDFrame.__imul__c C s | |t| j¡S rÐ )rº r` Ú __truediv__r^ r´ r´ rµ Ú __itruediv__. s ÿzNDFrame.__itruediv__c C s | |t| j¡S rÐ )rº r` Ú __floordiv__r^ r´ r´ rµ Ú __ifloordiv__ . s ÿzNDFrame.__ifloordiv__c C s | |t| j¡S rÐ )rº r` Ú__mod__r^ r´ r´ rµ Ú__imod__&. s zNDFrame.__imod__c C s | |t| j¡S rÐ )rº r` Ú__pow__r^ r´ r´ rµ Ú__ipow__*. s zNDFrame.__ipow__c C s | |t| j¡S rÐ )rº r` Ú__and__r^ r´ r´ rµ Ú__iand__.. s zNDFrame.__iand__c C s | |t| j¡S rÐ )rº r` Ú__or__r^ r´ r´ rµ Ú__ior__2. s zNDFrame.__ior__c C s | |t| j¡S rÐ )rº r` Ú__xor__r^ r´ r´ rµ Ú__ixor__6. s zNDFrame.__ixor__zHashable | None)r r® c C s. t | j|t| j d}|dkr$dS | j| S )a
|
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
|
)r Zis_validN)r r. rf rÞ )r³ r Zidxposr´ r´ rµ Ú_find_valid_index=. s zNDFrame._find_valid_indexr )r r c C s | j ddS )a
|
Return index for {position} non-NA value or None, if no non-NA value is found.
|
|
Returns
|
-------
|
type of index
|
|
Notes
|
-----
|
If all elements are non-NA/null, returns None.
|
Also returns None for empty {klass}.
|
r ©r ©rÏ rÎ r´ r´ rµ Úfirst_valid_indexP. s zNDFrame.first_valid_indexc C s | j ddS )Nrz rÐ rÑ rÎ r´ r´ rµ Úlast_valid_indexa. s zNDFrame.last_valid_index)FN)NF)T)N)N)r )N)N).).).)r FT)r )r )r )r )r )r )r )N)r¾ r NNTTNr r NTr¿ NN) NNNrÓ TrÔ NFrÕ TNNrÖ ) rÅ NNFNTNNNNrã rä )Nrð TNNNN)TN).....................)....................)NNTTr NNNTFNNNNr NNNNNN)N).....................)....................)Nrª r NNTTNrÖ NrÕ Nr6 NNNTNr rã N)FTF)r )r T)r )r NT)r )T)rW F)N)NNNN).).).)N)Nr? F)T)N)N)NFF)NNNN)r )r )NNFNNNF)N)Nr? )T)T)N)N)TTTTTr½ ).).).)N)..)..)..)rà )N)F)NN)NNFN)FN)r N)
|
r NNrî NNNr
|
NF)r r Fr TF)r» FFr^ ) r, NNNNNNr N)r, NNNNNNr )r, NNNNNNr ).).).).).).)r» Nr N)NNNN)r NN)r NNr? r? )NNN)r» r× NN)r FT)r FT)r FT)NT)NT)NT)NT)NT)NTr» F)NTr» F)NTr» F)NTr» F)r TF)r TF)r TF)r TF)r TF)r TF)r TF)NTFr )NTFr )NTFr )NFNNr NNr© )r» r r© )
|
NNNNr TFr Nr© )ïrÚ Ú
|
__module__Ú __qualname__Ú__doc__r¢ Ú__annotations__r¥ r£ r¤ Ú frozensetr¥ r r r¶ Ú classmethodrÇ rÌ Úpropertyr Úsetterr rÒ rÖ rÛ rÉ rÝ r r rá rï rò rô rè r¾ r r r r r r r rø r r r r" r* rH Ú_shared_doc_kwargsr2 r5 r: rR r rT r rW rX r_ rZ rf rm rn rp Ú__bool__rq rs ru rw r{ ry r r r r r r r½ r r r r r r¡ r¤ r¨ r° r´ r¼ r rÐ r¹ rï rõ ÚpickleÚHIGHEST_PROTOCOLrù rý rÿ r³ r( r5 r8 r> r! rB r@ rF r rQ rS rE rV r= r_ rH r% rN re r rh rM rq rt ry r} r rë rd r r r r r r¸ r rm r rÊ r¢ r± r¦ r© r« r¬ r r¯ r° r± r r. r rà r¬ r¸ rº r» rÆ rË rÔ r× rØ rÙ r rÎ rð rf rò rg rô rø rû rÿ r r r r r rz r r# r1 r/ r0 r= rÐ rm rB rD rF rS rY r[ rc r r] rj rk ro rq rr rt ru rw rx r| rü rý r rz r r r¥ r
r r r r¨ r r¯ r r° r r¸ rº r¼ r¾ rÀ r rÄ rÆ rÈ rÊ rÌ rÎ rÏ rÒ rÓ Ú __classcell__r´ r´ r§ rµ r â st
|
ó ü û 'ü4
|
û& ÿ5 ?tþö$Gþø þù þø þø 0 ÿFV.F +<Q @ &
|
|
|
ý ð< þ ò@ ñ: ö0 ?þû(C ÿ HS êJ êL êL )þø,C êP êRþ êT I ü R ü û" 3 J(: ú oþ÷, þ÷. þ÷.þ÷,' ú V I H÷0 ÷. ÷0÷. õ6õ8õ8õ65þõ* û . û j J L ø, ?ÿ +) ÿ 6 q / ù( 2þø2 þø0 þø2 þø2 ú,
|
ú*
|
ú,
|
ú, ú, ú,
|
ú*
|
ú,
|
ú, ú, ýø* ýø( ýø* üýø* Fþ÷, / . > >" ýú ! ú(| ÿ : û T ô2 H? ù& ú H õ4 A ö ? ö Rú ýù$ ýù" ýù$ û
|
ýù$ ýù$ ýù" ýù$ ú ýù$ û û ! ÿ O ù( 8 ü y û ú", ü ü û $ ù$ û û û ú ü ü ü ü ü ü ù ! û û r ö4) ü" õ< r c C sH dd dd t| jD ¡ d}| jdkr4| jjnd}| j}|||fS )z!Return a tuple of the doc params.Ú{z, c S s g | ]\}}| d | dqS )z (r r´ r8 r´ r´ rµ r j. s z _doc_params.<locals>.<listcomp>Ú}r» Zscalar)r® rú rß rå rM rÚ )rÄ r rÿ r r´ r´ rµ r g. s
|
ÿr ac
|
{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. Not implemented for Series.
|
|
{min_count}**kwargs
|
Additional keyword arguments to be passed to the function.
|
|
Returns
|
-------
|
{name1} or scalar{see_also}{examples}
|
a+
|
{desc}
|
|
Parameters
|
----------
|
axis : {axis_descr}
|
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.
|
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.
|
|
Returns
|
-------
|
{name1} or {name2} (if level specified) {notes}{examples}
|
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: float64a
|
{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 None
|
Include only boolean columns. If None, will attempt to use everything,
|
then use only boolean data. 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
|
-------
|
{name1} or {name2}
|
If level is specified, then, {name2} is returned; otherwise, {name1}
|
is returned.
|
|
{see_also}
|
{examples}zËReturn 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).aó Examples
|
--------
|
**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
|
z
See Also
|
--------
|
Series.all : Return True if all elements are True.
|
DataFrame.any : Return True if one (or more) elements are True.
|
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}a½ Examples
|
--------
|
**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
|
aµ Examples
|
--------
|
**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
|
aÆ Examples
|
--------
|
**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
|
a½ Examples
|
--------
|
**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
|
a2 See 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.
|
zÔReturn 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}Zstat_func_exampler ZSumé é é )Ú stat_funcZverbZdefault_outputZlevel_output_0Zlevel_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)
|
nanrý ZMaxé r§ r¦ rü ZMinr÷ r§ 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)
|
nanz®min_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.
|
r3 z Index | Noneztuple[NDFrameT, NDFrameT])r rç r6 r® c C sH t | jjr@| jj|jjkr@|dk r@| ¡ } | ¡ }|| _||_| |fS )zt
|
If we are aligning timezone-aware DatetimeIndexes and the timezones
|
do not match, convert both to UTC.
|
N)rV rÞ r¸ rI r¬ )r rç r6 r´ r´ rµ r5 +1 s r5 )éÚ
|
__future__r rº ÚdatetimerU Ú functoolsr r\ rà r rb rÞ r Útypingr r r r r
|
r r r r r r r r r r] rU Únumpyr Zpandas._configr r Z pandas._libsr Zpandas._libs.libr Zpandas._libs.tslibsr r r r Zpandas._typingr r r r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r; r< r= r> r? r@ rA Zpandas.compat._optionalrB Zpandas.compat.numpyrC r? Z pandas.errorsrD rE rF rG Zpandas.util._decoratorsrH Zpandas.util._exceptionsrI Zpandas.util._validatorsrJ rK rL rM rN Zpandas.core.dtypes.astyperO Zpandas.core.dtypes.commonrP rQ rR rS rT rU rV rW rX rY rZ r[ r\ r] r^ r_ r` ra Zpandas.core.dtypes.genericrb rc Z pandas.core.dtypes.inferencerd re Zpandas.core.dtypes.missingrf rg Z pandas.corerh r ri rj rk rl rm Z pandas.core.array_algos.replacern Zpandas.core.arraysro Zpandas.core.baserp Zpandas.core.constructionrq Zpandas.core.flagsrr Zpandas.core.indexes.apirs rt ru rv rw rx ry Zpandas.core.internalsrz r{ r| Z"pandas.core.internals.constructionr} r~ Z pandas.core.methods.describer Zpandas.core.missingr r r Zpandas.core.opsr Zpandas.core.reshape.concatr
Zpandas.core.shared_docsr Zpandas.core.sortingr Zpandas.core.windowr r r r Zpandas.io.formats.formatr r Zpandas.io.formats.printingr r Zpandas.core.framer Z pandas.core.indexers.objectsr r r Zpandas.core.seriesr Zpandas.io.pytablesr rÜ rq r© Z IndexingMixinr r r r r r r r r r r r r r r r r r r rè r£ r¦ r× r§ r¢ r¤ r¡ r5 r´ r´ r´ rµ Ú<module> s @ ( P $ õ `
|
$.$AAAA
|
Hþÿ ÿ ÿ ÿ
|
