U
|
¬ý°d< ã @ sè d Z ddlmZ ddlZddlmZ ddlZddlZddlmZ ddl Z ddl
|
Z
|
ddl m Z ddl mZmZmZmZmZmZmZmZmZmZmZ ddlZddlZddlm Z dd l m Z m Z dd
|
l m!Z"m#Z#m$Z$ dd l%m&Z& dd l'm(Z(m)Z)m*Z* dd l+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQ ddlRmSZS ddlTmUZU ddlVmWZXmYZY ddlZm[Z[m\Z\m]Z] ddl^m_Z_m`Z`maZa ddlbmcZc ddldmeZemfZfmgZg ddlhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZq ddlrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZmZmZmZ ddl
mZ ddlmZmZ ddlmZmZmZmZ ddlmZ ddlmZmZ dd lmZ dd lmZ dd lmZmZmZmZ dd lmZ dd l m¡Z¡ dd!l¢m£Z£m¤Z¤m¥Z¥m¦Z¦ dd"l§m¨Z¨ dd#l©mªZª dd$l«m¬Z¬mZm®Z®m¯Z¯m°Z°m±Z± dd%l²m³Z³m´Z´ dd&lµm¶Z¶m·Z· dd'l¸m¹Z¹mºZº dd(l»m¼Z¼m½Z½m¾Z¾m¿Z¿mÀZÀmÁZÁmÂZÂmÃZÃmÄZÄmÅZÅ dd)lÆmÇZÇ dd*lÈmÉZÉ dd+lÊmËZË dd,lÌmÍZÍ dd-lÎmÏZÏmÐZÐmÑZÑ dd.lÒmÓZÓ dd/lÔmÕZÕmÖZ× dd0lØmÙZÙmÚZÚmÛZÛ ddlÜZÝerdd1lÞmßZß dd2làmáZâ dd3l¸mãZã dd4lämåZå dd5læmçZç d6d7d8d9d:d;d<d=d>Zèd?Zéd@ZêG dAd7 d7e¨eZáeá ë¡ e ìeá¡ dBdCdDdEZídFdGdHdIdJdKZîdS )La#
|
DataFrame
|
---------
|
An efficient 2D container for potentially mixed-type time series or other
|
labeled data series.
|
|
Similar to its R counterpart, data.frame, except providing automatic data
|
alignment and a host of useful data manipulation methods having to do with the
|
labeling information
|
é )Ú annotationsN)Úabc)ÚStringIO)Údedent) Ú TYPE_CHECKINGÚAnyÚCallableÚHashableÚIterableÚIteratorÚLiteralÚMappingÚSequenceÚcastÚoverload)Úma)Ú
|
get_optionÚusing_copy_on_write)ÚalgosÚlibÚ
|
properties)Ú
|
duplicated)Ú NoDefaultÚis_range_indexerÚ
|
no_default)&Ú AggFuncTypeÚ AlignJoinÚAnyAllÚ AnyArrayLikeÚ ArrayLikeÚAxesÚAxisÚAxisIntÚColspaceArgTypeÚCompressionOptionsÚCorrelationMethodÚDropKeepÚDtypeÚDtypeObjÚFilePathÚ FillnaOptionsÚFloatFormatTypeÚFormattersTypeÚ FrequencyÚ IgnoreRaiseÚ IndexKeyFuncÚ
|
IndexLabelÚLevelÚMergeHowÚ
|
NaPositionÚPythonFuncTypeÚQuantileInterpolationÚ
|
ReadBufferÚRenamerÚScalarÚSortKindÚStorageOptionsÚSuffixesÚTimedeltaConvertibleTypesÚTimestampConvertibleTypesÚ ValueKeyFuncÚ WriteBufferÚnpt)ÚPYPY)Úimport_optional_dependency)ÚfunctionÚnp_percentile_argname)ÚChainedAssignmentErrorÚInvalidIndexErrorÚ_chained_assignment_msg)ÚAppenderÚ SubstitutionÚdoc)Úfind_stack_level)Úvalidate_ascendingÚvalidate_bool_kwargÚvalidate_percentile) ÚLossySetitemErrorÚcan_hold_elementÚ"construct_1d_arraylike_from_scalarÚ"construct_2d_arraylike_from_scalarÚfind_common_typeÚinfer_dtype_from_scalarÚinvalidate_string_dtypesÚmaybe_box_nativeÚmaybe_downcast_to_dtype)Úinfer_dtype_from_objectÚis_1d_only_ea_dtypeÚ is_bool_dtypeÚ is_dataclassÚ is_dict_likeÚis_dtype_equalÚis_extension_array_dtypeÚis_floatÚis_float_dtypeÚ is_hashableÚ
|
is_integerÚis_integer_dtypeÚ is_iteratorÚ is_list_likeÚ is_scalarÚ is_sequenceÚneeds_i8_conversionÚ pandas_dtype)ÚExtensionDtype)ÚisnaÚnotna)Ú
|
algorithmsÚcommonÚnanopsÚops)ÚCachedAccessor)Úreconstruct_funcÚrelabel_result)Ú take_2d_multi)ÚOpsMixin)Ú DatetimeArrayÚExtensionArrayÚ PeriodArrayÚTimedeltaArray)Ú
|
ArrowDtype)ÚSparseFrameAccessor)Ú ensure_wrapped_if_datetimelikeÚ extract_arrayÚsanitize_arrayÚsanitize_masked_array)ÚNDFrame)Úcheck_key_length)Ú DatetimeIndexÚIndexÚ PeriodIndexÚ default_indexÚ ensure_indexÚensure_index_from_sequences)Ú
|
MultiIndexÚmaybe_droplevels)Úcheck_bool_indexerÚcheck_dict_or_set_indexers)Ú ArrayManagerÚ BlockManager)
|
Ú arrays_to_mgrÚdataclasses_to_dictsÚ dict_to_mgrÚ
|
mgr_to_mgrÚndarray_to_mgrÚnested_data_to_arraysÚrec_array_to_mgrÚreorder_arraysÚ to_arraysÚtreat_as_nested)Úselectn)Úmelt©ÚSeries)Ú _shared_docs)Úget_group_indexÚlexsort_indexerÚnargsort)Ú
|
get_handle)ÚconsoleÚformat)ÚINFO_DOCSTRINGÚ DataFrameInfoÚframe_sub_kwargs©ÚDataFrameGroupBy©Ú DataFrame)ÚSingleDataManager)Ú Resampler©ÚStylerzindex, columnsr© z {0 or 'index', 1 or 'columns'}zaxis : {0 or 'index', 1 or 'columns'}, default 0
|
If 0 or 'index': apply function to each column.
|
If 1 or 'columns': apply function to each row.zj
|
inplace : bool, default False
|
Whether to modify the DataFrame rather than creating a new one.a
|
by : str or list of str
|
Name or list of names to sort by.
|
|
- if `axis` is 0 or `'index'` then `by` may contain index
|
levels and/or column labels.
|
- if `axis` is 1 or `'columns'` then `by` may contain column
|
levels and/or index labels.aÆ
|
labels : array-like, optional
|
New labels / index to conform the axis specified by 'axis' to.
|
index : array-like, optional
|
New labels for the index. Preferably an Index object to avoid
|
duplicating data.
|
columns : array-like, optional
|
New labels for the columns. Preferably an Index object to avoid
|
duplicating data.
|
axis : int or str, optional
|
Axis to target. Can be either the axis name ('index', 'columns')
|
or number (0, 1).z
|
This differs from updating with ``.loc`` or ``.iloc``, which require
|
you to specify a location to update with some value.)ÚaxesÚklassZaxes_single_argÚaxisÚinplaceZ optional_byÚoptional_reindexZ replace_iloczNnumeric_only : bool, default False
|
Include only float, int, boolean data.
|
aJ
|
Merge DataFrame or named Series objects with a database-style join.
|
|
A named Series object is treated as a DataFrame with a single named column.
|
|
The join is done on columns or indexes. If joining columns on
|
columns, the DataFrame indexes *will be ignored*. Otherwise if joining indexes
|
on indexes or indexes on a column or columns, the index will be passed on.
|
When performing a cross merge, no column specifications to merge on are
|
allowed.
|
|
.. warning::
|
|
If both key columns contain rows where the key is a null value, those
|
rows will be matched against each other. This is different from usual SQL
|
join behaviour and can lead to unexpected results.
|
|
Parameters
|
----------%s
|
right : DataFrame or named Series
|
Object to merge with.
|
how : {'left', 'right', 'outer', 'inner', 'cross'}, default 'inner'
|
Type of merge to be performed.
|
|
* left: use only keys from left frame, similar to a SQL left outer join;
|
preserve key order.
|
* right: use only keys from right frame, similar to a SQL right outer join;
|
preserve key order.
|
* outer: use union of keys from both frames, similar to a SQL full outer
|
join; sort keys lexicographically.
|
* inner: use intersection of keys from both frames, similar to a SQL inner
|
join; preserve the order of the left keys.
|
* cross: creates the cartesian product from both frames, preserves the order
|
of the left keys.
|
|
.. versionadded:: 1.2.0
|
|
on : label or list
|
Column or index level names to join on. These must be found in both
|
DataFrames. If `on` is None and not merging on indexes then this defaults
|
to the intersection of the columns in both DataFrames.
|
left_on : label or list, or array-like
|
Column or index level names to join on in the left DataFrame. Can also
|
be an array or list of arrays of the length of the left DataFrame.
|
These arrays are treated as if they are columns.
|
right_on : label or list, or array-like
|
Column or index level names to join on in the right DataFrame. Can also
|
be an array or list of arrays of the length of the right DataFrame.
|
These arrays are treated as if they are columns.
|
left_index : bool, default False
|
Use the index from the left DataFrame as the join key(s). If it is a
|
MultiIndex, the number of keys in the other DataFrame (either the index
|
or a number of columns) must match the number of levels.
|
right_index : bool, default False
|
Use the index from the right DataFrame as the join key. Same caveats as
|
left_index.
|
sort : bool, default False
|
Sort the join keys lexicographically in the result DataFrame. If False,
|
the order of the join keys depends on the join type (how keyword).
|
suffixes : list-like, default is ("_x", "_y")
|
A length-2 sequence where each element is optionally a string
|
indicating the suffix to add to overlapping column names in
|
`left` and `right` respectively. Pass a value of `None` instead
|
of a string to indicate that the column name from `left` or
|
`right` should be left as-is, with no suffix. At least one of the
|
values must not be None.
|
copy : bool, default True
|
If False, avoid copy if possible.
|
indicator : bool or str, default False
|
If True, adds a column to the output DataFrame called "_merge" with
|
information on the source of each row. The column can be given a different
|
name by providing a string argument. The column will have a Categorical
|
type with the value of "left_only" for observations whose merge key only
|
appears in the left DataFrame, "right_only" for observations
|
whose merge key only appears in the right DataFrame, and "both"
|
if the observation's merge key is found in both DataFrames.
|
|
validate : str, optional
|
If specified, checks if merge is of specified type.
|
|
* "one_to_one" or "1:1": check if merge keys are unique in both
|
left and right datasets.
|
* "one_to_many" or "1:m": check if merge keys are unique in left
|
dataset.
|
* "many_to_one" or "m:1": check if merge keys are unique in right
|
dataset.
|
* "many_to_many" or "m:m": allowed, but does not result in checks.
|
|
Returns
|
-------
|
DataFrame
|
A DataFrame of the two merged objects.
|
|
See Also
|
--------
|
merge_ordered : Merge with optional filling/interpolation.
|
merge_asof : Merge on nearest keys.
|
DataFrame.join : Similar method using indices.
|
|
Notes
|
-----
|
Support for specifying index levels as the `on`, `left_on`, and
|
`right_on` parameters was added in version 0.23.0
|
Support for merging named Series objects was added in version 0.24.0
|
|
Examples
|
--------
|
>>> df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
|
... 'value': [1, 2, 3, 5]})
|
>>> df2 = pd.DataFrame({'rkey': ['foo', 'bar', 'baz', 'foo'],
|
... 'value': [5, 6, 7, 8]})
|
>>> df1
|
lkey value
|
0 foo 1
|
1 bar 2
|
2 baz 3
|
3 foo 5
|
>>> df2
|
rkey value
|
0 foo 5
|
1 bar 6
|
2 baz 7
|
3 foo 8
|
|
Merge df1 and df2 on the lkey and rkey columns. The value columns have
|
the default suffixes, _x and _y, appended.
|
|
>>> df1.merge(df2, left_on='lkey', right_on='rkey')
|
lkey value_x rkey value_y
|
0 foo 1 foo 5
|
1 foo 1 foo 8
|
2 foo 5 foo 5
|
3 foo 5 foo 8
|
4 bar 2 bar 6
|
5 baz 3 baz 7
|
|
Merge DataFrames df1 and df2 with specified left and right suffixes
|
appended to any overlapping columns.
|
|
>>> df1.merge(df2, left_on='lkey', right_on='rkey',
|
... suffixes=('_left', '_right'))
|
lkey value_left rkey value_right
|
0 foo 1 foo 5
|
1 foo 1 foo 8
|
2 foo 5 foo 5
|
3 foo 5 foo 8
|
4 bar 2 bar 6
|
5 baz 3 baz 7
|
|
Merge DataFrames df1 and df2, but raise an exception if the DataFrames have
|
any overlapping columns.
|
|
>>> df1.merge(df2, left_on='lkey', right_on='rkey', suffixes=(False, False))
|
Traceback (most recent call last):
|
...
|
ValueError: columns overlap but no suffix specified:
|
Index(['value'], dtype='object')
|
|
>>> df1 = pd.DataFrame({'a': ['foo', 'bar'], 'b': [1, 2]})
|
>>> df2 = pd.DataFrame({'a': ['foo', 'baz'], 'c': [3, 4]})
|
>>> df1
|
a b
|
0 foo 1
|
1 bar 2
|
>>> df2
|
a c
|
0 foo 3
|
1 baz 4
|
|
>>> df1.merge(df2, how='inner', on='a')
|
a b c
|
0 foo 1 3
|
|
>>> df1.merge(df2, how='left', on='a')
|
a b c
|
0 foo 1 3.0
|
1 bar 2 NaN
|
|
>>> df1 = pd.DataFrame({'left': ['foo', 'bar']})
|
>>> df2 = pd.DataFrame({'right': [7, 8]})
|
>>> df1
|
left
|
0 foo
|
1 bar
|
>>> df2
|
right
|
0 7
|
1 8
|
|
>>> df1.merge(df2, how='cross')
|
left right
|
0 foo 7
|
1 foo 8
|
2 bar 7
|
3 bar 8
|
c s`# e Zd ZU dZddhejB ZdZeee e
|
j fZ dhZ ded< ejeg B Zded < d
|
ed < ed d ddZeZded< dddddddddZdd d d d d d Zed!d d"d#Zed$d d%d&Zed d d'd(Zed d d)d*Zed+d d,d-Zd d d.d/Zdd d d0d1d2Z d d d3d4Z d5d d6d7Z d8d d9d:Z e ddd<d=d>d d5d?d@dd d8dAdAd d5dAdAdAd8d5dBdCdDZ!e ddEd<d=d>d d5d?d@dd d8dAdAd d5dAdAdAd8ddBdFdDZ!e"dGdHdIdJdKe"e#j$e#j%dLddOd<d=d>d d5d?d@dd d8dAdAd d5dAdAdAd8d8dBdPdDZ!edQd dRdSZ&dTe'dU< e(e'dU dVd dWdXZ)dVd dYdZZ*dd d8d\d]d^d_Z+d`d dadbZ,e dcdcdddedfZ-e dgd dddhdfZ-didjdddkdfZ-e dcdcdddldmZ.e didjdddndmZ.didjdddodmZ.d d dpdqZ/e0ddrd5ddd dsdtduZ1dde2j3fdvd dwdxdydzd{Z4d d|d}d~ddZ5e ddddrddd
Z6e d dddddd
Z6dre7dfddd dddd
Z6d d5d8dAd d5d dd8d dd
|
ddZ8e0d d dAd dddZ9d d ddddZ:e0d dd d dddZ;e<e'd e'd d dddddddd dd¡ddd¢ d£d¤d d8d¥d8d¤dAd¦d§d¨d©ddª d«d¬Z=d£ddd®d¯Z>e<ej?e@d° e'd d±d²d!dOd5d d¨d8d´dµd¶Z?e d"dd5d8dd·d¨d¸d¹dºd»ZAe d#d£d5d8dd·d¨dd¹d¼d»ZAe<e'd d½d$dÀd5d8dd·d¨dÁd¹dÂd»ZAd%dÃdddÄdÀdÅddÆdÁdÇdÈdÉZBe d&dEdÊdËd>d d5dÌdÍdd d8dAdAdÎd5d dÏd d dÐd8d d8ddÑdÒdÓZCe d'ddÊdËd>d d5dÌdÍdd d8dAdAdÎd5d dÏd d dÐd8d d8d5dÑdÔdÓZCe"d dÕdÖd×dKe"e#j$e#j%dLd(dOdÊdËd>d d5dÌdÍdd d8dAdAdÎd5d dÏd d dÐd8d d8d8dÑdØdÓZCe<e'd e'd dÙ dd)dÞd d8d8d8d·d·dßd8d5ddd8dàd§d¨d8dádâdãZDe<eEfeFd*ddädAdådddædçdèZGd+d d dcdédêdëZHddìd d dídîdïZIed d dðdñZJd,d`dódcdôdõdöZKd`d÷dødùdúZLdûd düdýZMd}dþdÿd ZNdd ZOdd ZPdd ZQd-d ddd d
|
ZRdd d d ZSd d ZTdddddZUdd ZVdd ZWdd ZXd ddddZYd.d d dd d d ZZd÷ddd d!Z[d`dd"d#d$Z\dd d%d&Z]d/d'dd dd(d)d*Z^dd d+d,Z_d-d`dcd.d/d0Z`dd d1d2Zad3dcd4d5d6Zbdd d7d8Zcdcd dd9d:d;Zde d;d<d5d=d d>d?d@Zee d5dAdd>dBd@Zee d;d<d5d dCd>dDd@Zedd<d5d dCd>dEd@Zee d;d<d5d=dFd>dGdHZfe d5dAdd>dIdHZfdd<d5d dJd>dKdHZfd0d d dLdMZge2j3fd`d3dNdOddPdQdRZhd d dSdTZid÷d dUdVZjedWdX ZkdYdZ Zle
|
jmddfd d[d\d]d^Znd1d d[d\d_d`Zodad d dbdcddZpe<ejqfe@d2d dfdgd[ddhdAdidgd dj
|
fdkdl Zqe(dme"f e@dndodpdqe(ejrjdòddrdidd ds fdtduZre<ejse@d° e@dv dwd3dddddde
|
jmdddx dgd8ddydzdAd d{ fd|d}Zse d4d;d;d;d;d;d~d'did'd'd[dAdddddZte d5d;d;d;d;d;d;dd'did'd'd[d=dd dddZte d6d;d;d;d;d;d;dd'did'd'd[d ddCdd
dZtd7dòddddddd'did'd'd[d ddCd fddZte d8d;d;d;d;d;d;dddddgddAd[ddd ddZue d9d;d;d;d;d;d;d;dddddgdd=d[dd d ddZue d:d;d;d;d;d;d;d;dddddgdd d[ddCd ddZud;ddddddddddddgdd d[ddCd fddZue d<d;d;d;d;d;dddhdgd=dAdd dddZve d=d;d;d;d;dddhdgdAdAdddddZve d>d;d;d;d;d;dddhdgd dAddCdddZve<ejvfe@d?ddddddddhdgd dAddCd fddZvd3dcd4 fdd Zwe d@d;d;d;d;dd=dAd dd d d¡d¢Zxe dAd;d;d;d£dAdAd ddd d¤d¢Zxe<ejxfe@de2j3fddde2j3dd dAd ddCd fd¥d¢Zxd¦d d§d¨d©Zye<ejze@d° dªd«ddòe2j3fd`d¬did3d d fd®d¯ Zze d;d;d;d;d°d d d=d d d±d²d³Z{e d;d;d;d´d d dAd dd±dµd³Z{ddddd°d d d d dCd±d¶d³Z{e dBd;d;d;d;d;dd·d'd d=d3d3dOd¸d d¹dºd»Z|e dCd;d;d;d;dd¼d'd dAd3d3dOd¸dd¹d½d»Z|e dDd;d;d;d;d;dd·d'd d d3d3dOd¸dCd¹d¾d»Z|dEdddòd¿e2j3dd·d'd d d3d3dOd¸dCd¹dÀd»Z|e<ej}e@d° dªd d dÁdÂZ}e<ej}e@d° dªd d dÃdÄZ~e<eje@d° dªd d dÅdÆZe<eje@d° dªd d dÇdÈZe d;d;d;d;d;d;dÉdidÊdËd'd=d d dÌdÍdÎZe d;d;d;d;d;dÏdidÊdËd'dAd ddÌdÐdÎZdòe3e3ddddÉdidÊdËd'd d dCdÌdÑdÎZdFdÒdddÓdÔdÕd d dCdÖd×dØZdGdÔdÕdcdÙdÚdÛZe d;d;d;d;d;d;d;dÜd'did=d5d5d dÝd dÞdßdàZe d;d;d;d;d;d;dád'didAd5d5d dÝddÞdâdàZe"f e@e(ejjdòdddãdädddÜd'didåd d5d5d dÝdCdæ dçdàZe d;d;d;d;d;d;d;d;dèdid'dédAdêdëd d dìddí
|
dîdïZ
e d;d;d;d;d;d;d;d;d;dð did'déd=dêdëd d dìd dí
|
dñdïZ
e d;d;d;d;d;d;d;d;d;dð did'déd dêdëd d dìdCdí
|
dòdïZ
dòddddãdäddddð did'déd dêdëd d dìdCdí
|
fdódïZ
dHd¦d d d d dcdôdõdöZdId`d'd5d d÷dødùZdJd`d'd5d d÷dúdûZe<eje@d° edüedýdþdKdididid dddZdLddid dddZdd Zd
|
d ZeZdMd d dddZdNd dddZd d ddZdd ddZdd ddZe<e'd d e@d° dªdOd did d d d d fd d! ZdPd d"d d d#d$d%Zd d ddd&d'ZdQd5d d5dd)d*d+Ze(d,e(e'd- e@ dRdid.d d d d d d/d0d1d2Zd3e'd4< e"d¿e(e'd4 e2je2jd5d d d6d7Zd8e'd9< e"d¿e(e'd9 dSd<d d d[d d d d=d>d?ZdTd[d d@dAdBZdUd'd d dCdDdEZdVd[dFdGdHZe(e'dI dJdIdK dWd3d[d d dMdNdOZe<ej d dPdcedQdRdXd`did dSdTdUZ dYd'd`dVdjdWdXdYZ¡edZZ¢ed[Z£e<e'd\ e@d° e@d] e¢e£d^dZdid_d`daZ¤e¤Z¥e d;d;d;d;dbdidd ddcdcdddeZ¦e d;d;d;dfdidd d[djdcdgdeZ¦e<ej¦fe@d[didd d[djdcdhdeZ¦e<e'di e@d° e@d] djd\d<did dkdldmZ§d]d<did dodpdqdrZ¨d^dsd8d dtdudvZ©d_d d d d dwdxdyZªd`dzd.d{d5d5d d8d d|d}d~Z«dadzd.d{d5d5d d8dddZ¬e"d¿e(edddbdjd{d.d.d.d d d d ddd8d d ddZ®dcdd dddZ¯dddd`d d dddZ°dedAdAd d dddZ±dfdjdid dd dcdddZ²dgdid dddZ³dòddddd5did d dddZ´d5d dcd d¡d¢Zµdhdid dcd£d¤d¥Z¶e<e'd¦ d§d¨didid d dcd©dªd«Z·e<e'd¬ d§d¨djdid d dcd©dd®Z¸d`d¯d°d±d²Z¹dkdid d d d³d´dµZºe dld¶did d·dcd¸d¹dºZ»e dmd»did d·d¼d¸d½dºZ»e dnd¾did d·d¼d¸d¿dºZ»dod¾did d·dÃd¼dÄdÅdºZ»e<ej¼fe@dpdÆdhd8d d3d dÇ fdÈdÉ Z¼e<ej½fe@dqdid8d8d5d8d[d[dÌdÍd dÎdÏ fdÐdÑ Z½drd¬d5didd dÒdÓdÔZ¾dsd¬didd dÕdÖd×Z¿dØd dÙdÚdÛZÀddgZÁdÜedÝ< ejÂd«d«dÞZÂdßedà< eÃeÁZÄd«ZÅdáedâ< dZÆdãedä< eÇjÈd«dådæZÉeÇjÈdòdçdæZÊeËdèeÌjÍjÎZÏeÌjÍjÐZÑeÌjÍjÒZÓeËdeÔZÕdtd dìdédêZÖedxd dëdìZ×e d;d;d;d;dídîd=dïdd dðdñdòZØe d;d;d;dódîdAdïdddðdôdòZØe d;d;d;d;dídîd dïddCdðdõdòZØdddddídîd dïddCdð fdödòZØe d;d;d;d;dídîd=dïd d÷dødùZÙe d;d;d;dódîdAdïdd÷dúdùZÙe d;d;d;d;dídîd dïdCd÷dûdùZÙdddddídîd dïdCd÷ fdüdùZÙdudddýd dþdþdgd dCdÿ fd dZÚdvdòddddddd d5didAd d8d8d8dCd fddZÛe dwd;d;d;dd=dgd[d ddd ZÜe dxd;d;d
|
dAdgd[ddd d ZÜe dyd;d;d;dd dgd[dCdd d ZÜe2j3fddddd dgd[dCd fd d ZÜe dzd;d;d;dd=dgd[d dddZÝe d{d;d;d
|
dAdgd[ddddZÝe d|d;d;d;dd dgd[dCdddZÝe2j3fddddd dgd[dCd fddZÝ ZÞS (} r© a³
|
Two-dimensional, size-mutable, potentially heterogeneous tabular data.
|
|
Data structure also contains labeled axes (rows and columns).
|
Arithmetic operations align on both row and column labels. Can be
|
thought of as a dict-like container for Series objects. The primary
|
pandas data structure.
|
|
Parameters
|
----------
|
data : ndarray (structured or homogeneous), Iterable, dict, or DataFrame
|
Dict can contain Series, arrays, constants, dataclass or list-like objects. If
|
data is a dict, column order follows insertion-order. If a dict contains Series
|
which have an index defined, it is aligned by its index. This alignment also
|
occurs if data is a Series or a DataFrame itself. Alignment is done on
|
Series/DataFrame inputs.
|
|
If data is a list of dicts, column order follows insertion-order.
|
|
index : Index or array-like
|
Index to use for resulting frame. Will default to RangeIndex if
|
no indexing information part of input data and no index provided.
|
columns : Index or array-like
|
Column labels to use for resulting frame when data does not have them,
|
defaulting to RangeIndex(0, 1, 2, ..., n). If data contains column labels,
|
will perform column selection instead.
|
dtype : dtype, default None
|
Data type to force. Only a single dtype is allowed. If None, infer.
|
copy : bool or None, default None
|
Copy data from inputs.
|
For dict data, the default of None behaves like ``copy=True``. For DataFrame
|
or 2d ndarray input, the default of None behaves like ``copy=False``.
|
If data is a dict containing one or more Series (possibly of different dtypes),
|
``copy=False`` will ensure that these inputs are not copied.
|
|
.. versionchanged:: 1.3.0
|
|
See Also
|
--------
|
DataFrame.from_records : Constructor from tuples, also record arrays.
|
DataFrame.from_dict : From dicts of Series, arrays, or dicts.
|
read_csv : Read a comma-separated values (csv) file into DataFrame.
|
read_table : Read general delimited file into DataFrame.
|
read_clipboard : Read text from clipboard into DataFrame.
|
|
Notes
|
-----
|
Please reference the :ref:`User Guide <basics.dataframe>` for more information.
|
|
Examples
|
--------
|
Constructing DataFrame from a dictionary.
|
|
>>> d = {'col1': [1, 2], 'col2': [3, 4]}
|
>>> df = pd.DataFrame(data=d)
|
>>> df
|
col1 col2
|
0 1 3
|
1 2 4
|
|
Notice that the inferred dtype is int64.
|
|
>>> df.dtypes
|
col1 int64
|
col2 int64
|
dtype: object
|
|
To enforce a single dtype:
|
|
>>> df = pd.DataFrame(data=d, dtype=np.int8)
|
>>> df.dtypes
|
col1 int8
|
col2 int8
|
dtype: object
|
|
Constructing DataFrame from a dictionary including Series:
|
|
>>> d = {'col1': [0, 1, 2, 3], 'col2': pd.Series([2, 3], index=[2, 3])}
|
>>> pd.DataFrame(data=d, index=[0, 1, 2, 3])
|
col1 col2
|
0 0 NaN
|
1 1 NaN
|
2 2 2.0
|
3 3 3.0
|
|
Constructing DataFrame from numpy ndarray:
|
|
>>> df2 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
... columns=['a', 'b', 'c'])
|
>>> df2
|
a b c
|
0 1 2 3
|
1 4 5 6
|
2 7 8 9
|
|
Constructing DataFrame from a numpy ndarray that has labeled columns:
|
|
>>> data = np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)],
|
... dtype=[("a", "i4"), ("b", "i4"), ("c", "i4")])
|
>>> df3 = pd.DataFrame(data, columns=['c', 'a'])
|
...
|
>>> df3
|
c a
|
0 3 1
|
1 6 4
|
2 9 7
|
|
Constructing DataFrame from dataclass:
|
|
>>> from dataclasses import make_dataclass
|
>>> Point = make_dataclass("Point", [("x", int), ("y", int)])
|
>>> pd.DataFrame([Point(0, 0), Point(0, 3), Point(2, 3)])
|
x y
|
0 0 0
|
1 0 3
|
2 2 3
|
|
Constructing DataFrame from Series/DataFrame:
|
|
>>> ser = pd.Series([1, 2, 3], index=["a", "b", "c"])
|
>>> df = pd.DataFrame(data=ser, index=["a", "c"])
|
>>> df
|
0
|
a 1
|
c 3
|
|
>>> df1 = pd.DataFrame([1, 2, 3], index=["a", "b", "c"], columns=["x"])
|
>>> df2 = pd.DataFrame(data=df1, index=["a", "c"])
|
>>> df2
|
x
|
a 1
|
c 3
|
ÚcolumnsÚindexZ dataframeÚsparsezset[str]Ú
|
_accessorszfrozenset[str]Ú _hidden_attrszBlockManager | ArrayManagerÚ_mgrzCallable[..., DataFrame]©Úreturnc C s t S ©Nr¨ ©Úself© r¾ úHd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/frame.pyÚ _constructorx s zDataFrame._constructorzCallable[..., Series]Ú_constructor_slicedNz Axes | Nonez Dtype | Nonez bool | NoneÚNone)r´ r³ ÚdtypeÚcopyrº c s\ d k r| ¡t tr2 j |s2 jdd t ttfr~t rR jdd d kr~|d kr~d kr~|s~t | ¡ d S t
|
d}d k r tt r t d|d k rºt|t rºt d|d kr t t rÔd}nL|dkrüt tjtfrü jdkrüd}n$t r t tttfs d}nd} d krpd k r8ntd |d k rN|ntd }d k rdnttg t ttfr| j |d
|
|d }n¤t t rÀt |||d }nt tjrd d lm } t |j rðt dt t |||d }n0t tjtttfr¨ j!j"rRt#tj t$ |||d}nRt% dd d k rt rp|nd} t j& i||| d}nt |||d }nt' rt t(j)sàt* drØt + ¡ nt, t- d krlt. d rt/ t tjsVt0 rV|d k r.t1|}t2 |\}
|
}t3|
|
||d}nt |||d }n$ti |d k r|ntd |d}n®d ks¦|d kr®t dt1t1|}sÔt4 dd\} tt5r fddt6t-|D } t3| |d |d}n.t7 t-t-||} t | || j!d|d }t8||d}t | |¡ d S )NF©Údeepúmode.data_managerzindex cannot be a setzcolumns cannot be a setTÚarrayé r ©r´ r³ )r® rà rÄ )rà rÄ Útyp)Úmrecordsz]MaskedRecords are not supported. Pass {name: data[name] for name in data.dtype.names} instead©rË Úname)rà rË rÄ Z __array__)rà rË z*DataFrame constructor not properly called!)ri c s g | ]}t tqS r¾ )rQ Úlen)Ú.0Ú_©Údatarà r´ r¾ r¿ Ú
|
<listcomp>= s ÿz&DataFrame.__init__.<locals>.<listcomp>)9Z_validate_dtypeÚ
|
isinstancer© r¸ rÄ r r r r Ú__init__r ÚsetÚ
|
ValueErrorÚdictÚnpÚndarrayrw Úndimr r r
ri ÚobjectZ _init_mgrr r Z MaskedArrayZnumpy.marÌ Z MaskedRecordsÚ TypeErrorr r rà Únamesr r ÚgetattrrÎ re r r ÚhasattrÚasarrayÚlistrÏ r[ r r r r r rT rj ÚrangerR r )r½ rÓ r´ r³ rà rÄ ÚmanagerÚmgrrÌ Z_copyÚarraysrÑ ÚvaluesZarr2dr¾ rÒ r¿ rÖ s<
|
|
|
|
ÿþý
|
ÿ
|
ÿ
|
ÿú
|
|
úø ú
|
|
|
|
ú
|
ûú û
|
þûú
|
zDataFrame.__init__FTÚboolÚ DataFrameXchg)Ú nan_as_nullÚ
|
allow_copyrº c C s ddl m} || ||S )a
|
Return the dataframe interchange object implementing the interchange protocol.
|
|
Parameters
|
----------
|
nan_as_null : bool, default False
|
Whether to tell the DataFrame to overwrite null values in the data
|
with ``NaN`` (or ``NaT``).
|
allow_copy : bool, default True
|
Whether to allow memory copying when exporting. If set to False
|
it would cause non-zero-copy exports to fail.
|
|
Returns
|
-------
|
DataFrame interchange object
|
The object which consuming library can use to ingress the dataframe.
|
|
Notes
|
-----
|
Details on the interchange protocol:
|
https://data-apis.org/dataframe-protocol/latest/index.html
|
|
`nan_as_null` currently has no effect; once support for nullable extension
|
dtypes is added, this value should be propagated to columns.
|
r )ÚPandasDataFrameXchg)Z!pandas.core.interchange.dataframerí )r½ rë rì rí r¾ r¾ r¿ Ú __dataframe__Z s zDataFrame.__dataframe__z list[Index]c C s | j | jgS )a
|
Return a list representing the axes of the DataFrame.
|
|
It has the row axis labels and column axis labels as the only members.
|
They are returned in that order.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
|
>>> df.axes
|
[RangeIndex(start=0, stop=2, step=1), Index(['col1', 'col2'],
|
dtype='object')]
|
rÊ r¼ r¾ r¾ r¿ r® } s zDataFrame.axesztuple[int, int]c C s t | jt | jfS )aÃ
|
Return a tuple representing the dimensionality of the DataFrame.
|
|
See Also
|
--------
|
ndarray.shape : Tuple of array dimensions.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
|
>>> df.shape
|
(2, 2)
|
|
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4],
|
... 'col3': [5, 6]})
|
>>> df.shape
|
(2, 3)
|
)rÏ r´ r³ r¼ r¾ r¾ r¿ Úshape s zDataFrame.shapec C sT t | jtr&tdd | jjD dkS | jjrHtdd | jjD dkS | j S dS )a>
|
Whether all the columns in a DataFrame have the same type.
|
|
Returns
|
-------
|
bool
|
|
See Also
|
--------
|
Index._is_homogeneous_type : Whether the object has a single
|
dtype.
|
MultiIndex._is_homogeneous_type : Whether all the levels of a
|
MultiIndex have the same dtype.
|
|
Examples
|
--------
|
>>> DataFrame({"A": [1, 2], "B": [3, 4]})._is_homogeneous_type
|
True
|
>>> DataFrame({"A": [1, 2], "B": [3.0, 4.0]})._is_homogeneous_type
|
False
|
|
Items with the same type but different sizes are considered
|
different types.
|
|
>>> DataFrame({
|
... "A": np.array([1, 2], dtype=np.int32),
|
... "B": np.array([1, 2], dtype=np.int64)})._is_homogeneous_type
|
False
|
c S s h | ]
|
}|j qS r¾ ©rà )rÐ Úarrr¾ r¾ r¿ Ú <setcomp>Ä s z1DataFrame._is_homogeneous_type.<locals>.<setcomp>é c S s h | ]
|
}|j qS r¾ rð )rÐ Úblockr¾ r¾ r¿ rò Æ s N)rÕ r¸ r rÏ rç Úany_extension_typesÚblocksÚ_is_mixed_typer¼ r¾ r¾ r¿ Ú_is_homogeneous_type¤ s
|
z DataFrame._is_homogeneous_typec C s< t | jtrdS | jj}t|dkr(dS |d j}t| S )zY
|
Can we transpose this DataFrame without creating any new array objects.
|
Fró r )rÕ r¸ r rö rÏ rà rY )r½ rö rà r¾ r¾ r¿ Ú_can_fast_transposeÊ s
|
z DataFrame._can_fast_transposeú9np.ndarray | DatetimeArray | TimedeltaArray | PeriodArrayc C s | j }t|trJt|jdkr@t|jd js@|jd dd¡S t| j S |j
|
}t|dkrft| j S |d j }|j dkr| j S t d|}|j S )zK
|
Analogue to ._values that may return a 2D ExtensionArray.
|
ró r éÿÿÿÿrú )r¸ rÕ r rÏ rç rY rà Úreshaper| rè rö rÜ r ÚT)r½ ræ rö rñ r¾ r¾ r¿ Ú_valuesÙ s
|
|
|
|
|
|
zDataFrame._valuesc C s t d}t| |kS )z0
|
Check length against max_rows.
|
údisplay.max_rows)r rÏ )r½ Úmax_rowsr¾ r¾ r¿ Ú_repr_fits_vertical_÷ s z DataFrame._repr_fits_vertical_)Ú ignore_widthrº c C sà t ¡ \}}td}t| j}|r*||ks>|sB|rB||d krBdS |sV|dksVt ¡ sZdS tddk snt ¡ rtd}ntd}t }| }|dk r¨|jdt |t|
}ndS |j
|
|d | ¡ } t d
|
d | d ¡D }
|
|
|
|k S ) a^
|
Check if full repr fits in horizontal boundaries imposed by the display
|
options width and max_columns.
|
|
In case of non-interactive session, no boundaries apply.
|
|
`ignore_width` is here so ipynb+HTML output can behave the way
|
users expect. display.max_columns remains in effect.
|
GH3541, GH3573
|
údisplay.max_columnsrÉ FNTz display.widthró rÿ ©Úbufc s s | ]}t |V qd S r» )rÏ )rÐ Úliner¾ r¾ r¿ Ú <genexpr>/ s z3DataFrame._repr_fits_horizontal_.<locals>.<genexpr>Ú
|
)r¡ Zget_console_sizer rÏ r³ Zin_interactive_sessionZin_ipython_frontendr ÚilocÚminÚ to_stringÚgetvalueÚmaxÚsplit) r½ r ÚwidthÚheightZ max_columnsZ
|
nb_columnsr r ÚdÚvalueZ
|
repr_widthr¾ r¾ r¿ Ú_repr_fits_horizontal_þ s2
|
ÿÿ
|
ÿ z DataFrame._repr_fits_horizontal_c C s" t ddk}|o | ¡ o | ¡ S )z=
|
True if the repr should show the info view.
|
zdisplay.large_reprÚinfo)r r r )r½ Zinfo_repr_optionr¾ r¾ r¿ Ú
|
_info_repr3 s ÿzDataFrame._info_reprÚstrc C s6 | ¡ r"t }| j|d | ¡ S t ¡ }| jf |S )zL
|
Return a string representation for a particular DataFrame.
|
r )r r r r ÚfmtZget_dataframe_repr_paramsr )r½ r Z repr_paramsr¾ r¾ r¿ Ú__repr__< s zDataFrame.__repr__z
|
str | Nonec C s¶ | ¡ rFt }| j|d | ¡ ddd¡}| ddd¡}d| dS td r®td
|
}td }td }td }tj| dddddddddddd||||dd}t |¡j ddS dS dS )zp
|
Return a html representation for a particular DataFrame.
|
|
Mainly for IPython notebook.
|
r ú<z<ró ú>z>z<pre>z</pre>zdisplay.notebook_repr_htmlrÿ zdisplay.min_rowsr zdisplay.show_dimensionsNÚNaNTÚ.)r³ Ú col_spaceÚna_repÚ
|
formattersÚ float_formatÚsparsifyÚjustifyÚ index_namesÚheaderr´ Ú bold_rowsÚescaper Úmin_rowsÚmax_colsÚshow_dimensionsÚdecimal)Únotebook)
|
r r r r Úreplacer r ÚDataFrameFormatterÚDataFrameRendererÚto_html)r½ r Úvalr r' r( r) Ú formatterr¾ r¾ r¿ Ú _repr_html_H sB îzDataFrame._repr_html_.zSequence[str] | Nonez,int | list[int] | dict[Hashable, int] | Nonezbool | Sequence[str]zfmt.FormattersType | Nonezfmt.FloatFormatType | Nonez
|
int | None)r r³ r r$ r´ r r r r! r# r" r r( r) r* Ú
|
line_widthr' Ú max_colwidthÚencodingrº c C s d S r» r¾ ©r½ r r³ r r$ r´ r r r r! r# r" r r( r) r* r3 r' r4 r5 r¾ r¾ r¿ r t s zDataFrame.to_stringzFilePath | WriteBuffer[str]c C s d S r» r¾ r6 r¾ r¾ r¿ r s zbool or sequence of strzkWrite out the column names. If a list of strings is given, it is assumed to be aliases for the column nameszint, list or dict of intzÅThe minimum width of each column. If a list of ints is given every integers corresponds with one column. If a dict is given, the key references the column, while the value defines the space to use.)Z header_typer$ Zcol_space_typer )Z shared_paramsZreturnsr r z"FilePath | WriteBuffer[str] | Nonec C sn ddl m} |d|N tj| |||||| | |
|
|||| | ||d}t |¡j|||dW 5 Q R £ S Q R X dS )ax
|
Render a DataFrame to a console-friendly tabular output.
|
%(shared_params)s
|
line_width : int, optional
|
Width to wrap a line in characters.
|
min_rows : int, optional
|
The number of rows to display in the console in a truncated repr
|
(when number of rows is above `max_rows`).
|
max_colwidth : int, optional
|
Max width to truncate each column in characters. By default, no limit.
|
encoding : str, default "utf-8"
|
Set character encoding.
|
%(returns)s
|
See Also
|
--------
|
to_html : Convert DataFrame to HTML.
|
|
Examples
|
--------
|
>>> d = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
|
>>> df = pd.DataFrame(d)
|
>>> print(df.to_string())
|
col1 col2
|
0 1 4
|
1 2 5
|
2 3 6
|
r )Úoption_contextzdisplay.max_colwidth)r³ r r r r r! r" r# r$ r´ r' r r( r) r* )r r5 r3 N)Úpandasr7 r r- r. r )r½ r r³ r r$ r´ r r r r! r# r" r r( r) r* r3 r' r4 r5 r7 r1 r¾ r¾ r¿ r ¦ s2 < ð
|
ýr c C s ddl m} || S )a
|
Returns a Styler object.
|
|
Contains methods for building a styled HTML representation of the DataFrame.
|
|
See Also
|
--------
|
io.formats.style.Styler : Helps style a DataFrame or Series according to the
|
data with HTML and CSS.
|
r r¬ )Úpandas.io.formats.styler )r½ r r¾ r¾ r¿ Ústyleÿ s zDataFrame.styleaÆ
|
Iterate over (column name, Series) pairs.
|
|
Iterates over the DataFrame columns, returning a tuple with
|
the column name and the content as a Series.
|
|
Yields
|
------
|
label : object
|
The column names for the DataFrame being iterated over.
|
content : Series
|
The column entries belonging to each label, as a Series.
|
|
See Also
|
--------
|
DataFrame.iterrows : Iterate over DataFrame rows as
|
(index, Series) pairs.
|
DataFrame.itertuples : Iterate over DataFrame rows as namedtuples
|
of the values.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'species': ['bear', 'bear', 'marsupial'],
|
... 'population': [1864, 22000, 80000]},
|
... index=['panda', 'polar', 'koala'])
|
>>> df
|
species population
|
panda bear 1864
|
polar bear 22000
|
koala marsupial 80000
|
>>> for label, content in df.items():
|
... print(f'label: {label}')
|
... print(f'content: {content}', sep='\n')
|
...
|
label: species
|
content:
|
panda bear
|
polar bear
|
koala marsupial
|
Name: species, dtype: object
|
label: population
|
content:
|
panda 1864
|
polar 22000
|
koala 80000
|
Name: population, dtype: int64
|
Úitemsz!Iterable[tuple[Hashable, Series]]c c s\ | j jr0t| dr0| j D ]}|| |¡fV qn(t| j D ] \}}|| j|ddfV q:d S )NÚ _item_cacheró ©r° )r³ Ú is_uniquerá Ú_get_item_cacheÚ enumerateÚ_ixs)r½ ÚkÚir¾ r¾ r¿ r; A s
|
|
zDataFrame.itemsc c sf | j }| j}t }t| j| jD ]@\}}||||d | ¡}|rV| jjrV|j | j¡ ||fV q dS )aÛ
|
Iterate over DataFrame rows as (index, Series) pairs.
|
|
Yields
|
------
|
index : label or tuple of label
|
The index of the row. A tuple for a `MultiIndex`.
|
data : Series
|
The data of the row as a Series.
|
|
See Also
|
--------
|
DataFrame.itertuples : Iterate over DataFrame rows as namedtuples of the values.
|
DataFrame.items : Iterate over (column name, Series) pairs.
|
|
Notes
|
-----
|
1. Because ``iterrows`` returns a Series for each row,
|
it does **not** preserve dtypes across the rows (dtypes are
|
preserved across columns for DataFrames). For example,
|
|
>>> df = pd.DataFrame([[1, 1.5]], columns=['int', 'float'])
|
>>> row = next(df.iterrows())[1]
|
>>> row
|
int 1.0
|
float 1.5
|
Name: 0, dtype: float64
|
>>> print(row['int'].dtype)
|
float64
|
>>> print(df['int'].dtype)
|
int64
|
|
To preserve dtypes while iterating over the rows, it is better
|
to use :meth:`itertuples` which returns namedtuples of the values
|
and which is generally faster than ``iterrows``.
|
|
2. You should **never modify** something you are iterating over.
|
This is not guaranteed to work in all cases. Depending on the
|
data types, the iterator returns a copy and not a view, and writing
|
to it will have no effect.
|
©r´ rÎ N)
|
r³ rÁ r Úzipr´ rè Ú __finalize__r¸ Zis_single_blockÚadd_references)r½ r³ r¯ Ú using_cowrB ÚvÚsr¾ r¾ r¿ ÚiterrowsJ s * zDataFrame.iterrowsÚPandaszIterable[tuple[Any, ...]])r´ rÎ rº c s| g }t j}|r*| j¡ | dd¡ | fddtt jD ¡ |dk rttj ||dd}t
|
|j t | S t | S )aã
|
Iterate over DataFrame rows as namedtuples.
|
|
Parameters
|
----------
|
index : bool, default True
|
If True, return the index as the first element of the tuple.
|
name : str or None, default "Pandas"
|
The name of the returned namedtuples or None to return regular
|
tuples.
|
|
Returns
|
-------
|
iterator
|
An object to iterate over namedtuples for each row in the
|
DataFrame with the first field possibly being the index and
|
following fields being the column values.
|
|
See Also
|
--------
|
DataFrame.iterrows : Iterate over DataFrame rows as (index, Series)
|
pairs.
|
DataFrame.items : Iterate over (column name, Series) pairs.
|
|
Notes
|
-----
|
The column names will be renamed to positional names if they are
|
invalid Python identifiers, repeated, or start with an underscore.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'num_legs': [4, 2], 'num_wings': [0, 2]},
|
... index=['dog', 'hawk'])
|
>>> df
|
num_legs num_wings
|
dog 4 0
|
hawk 2 2
|
>>> for row in df.itertuples():
|
... print(row)
|
...
|
Pandas(Index='dog', num_legs=4, num_wings=0)
|
Pandas(Index='hawk', num_legs=2, num_wings=2)
|
|
By setting the `index` parameter to False we can remove the index
|
as the first element of the tuple:
|
|
>>> for row in df.itertuples(index=False):
|
... print(row)
|
...
|
Pandas(num_legs=4, num_wings=0)
|
Pandas(num_legs=2, num_wings=2)
|
|
With the `name` parameter set we set a custom name for the yielded
|
namedtuples:
|
|
>>> for row in df.itertuples(name='Animal'):
|
... print(row)
|
...
|
Animal(Index='dog', num_legs=4, num_wings=0)
|
Animal(Index='hawk', num_legs=2, num_wings=2)
|
r r c 3 s | ]} j d d
|f V qd S r» )r ©rÐ rB r¼ r¾ r¿ r Ä s z'DataFrame.itertuples.<locals>.<genexpr>NT)Úrename) rã r³ Úappendr´ ÚinsertÚextendrä rÏ Ú collectionsÚ
|
namedtupleÚmapÚ_makerE )r½ r´ rÎ rç ÚfieldsZ itertupler¾ r¼ r¿ Ú
|
itertuples} s @
|
" ÿzDataFrame.itertuplesÚintc C s
|
t | jS )zI
|
Returns length of info axis, but here we use the index.
|
)rÏ r´ r¼ r¾ r¾ r¿ Ú__len__Ñ s zDataFrame.__len__r )Úotherrº c C s d S r» r¾ ©r½ rZ r¾ r¾ r¿ Údot× s z DataFrame.dotz DataFrame | Index | ArrayLikec C s d S r» r¾ r[ r¾ r¾ r¿ r\ Û s zAnyArrayLike | DataFrameúDataFrame | Seriesc C sf t |ttfrr| j |j¡}t|t| jks@t|t|jkrHtd| j|dd}|j|dd}|j }|j
|
}n@| }| j }t |¡}|j d |j d kr²td|j d|j t |trÚ| jt ||¡|j|jdd S t |tr | jt ||¡|jddS t |t jtfrPt ||¡}|jd
|
kr<| j||jddS | j||jddS ntd t| d S ) aÐ
|
Compute the matrix multiplication between the DataFrame and other.
|
|
This method computes the matrix product between the DataFrame and the
|
values of an other Series, DataFrame or a numpy array.
|
|
It can also be called using ``self @ other`` in Python >= 3.5.
|
|
Parameters
|
----------
|
other : Series, DataFrame or array-like
|
The other object to compute the matrix product with.
|
|
Returns
|
-------
|
Series or DataFrame
|
If other is a Series, return the matrix product between self and
|
other as a Series. If other is a DataFrame or a numpy.array, return
|
the matrix product of self and other in a DataFrame of a np.array.
|
|
See Also
|
--------
|
Series.dot: Similar method for Series.
|
|
Notes
|
-----
|
The dimensions of DataFrame and other must be compatible in order to
|
compute the matrix multiplication. In addition, the column names of
|
DataFrame and the index of other must contain the same values, as they
|
will be aligned prior to the multiplication.
|
|
The dot method for Series computes the inner product, instead of the
|
matrix product here.
|
|
Examples
|
--------
|
Here we multiply a DataFrame with a Series.
|
|
>>> df = pd.DataFrame([[0, 1, -2, -1], [1, 1, 1, 1]])
|
>>> s = pd.Series([1, 1, 2, 1])
|
>>> df.dot(s)
|
0 -4
|
1 5
|
dtype: int64
|
|
Here we multiply a DataFrame with another DataFrame.
|
|
>>> other = pd.DataFrame([[0, 1], [1, 2], [-1, -1], [2, 0]])
|
>>> df.dot(other)
|
0 1
|
0 1 4
|
1 2 2
|
|
Note that the dot method give the same result as @
|
|
>>> df @ other
|
0 1
|
0 1 4
|
1 2 2
|
|
The dot method works also if other is an np.array.
|
|
>>> arr = np.array([[0, 1], [1, 2], [-1, -1], [2, 0]])
|
>>> df.dot(arr)
|
0 1
|
0 1 4
|
1 2 2
|
|
Note how shuffling of the objects does not change the result.
|
|
>>> s2 = s.reindex([1, 0, 2, 3])
|
>>> df.dot(s2)
|
0 -4
|
1 5
|
dtype: int64
|
zmatrices are not alignedF©r³ rÄ ©r´ rÄ ró r z Dot product shape mismatch, z vs ©r´ r³ rÄ rÉ zunsupported type: N)rÕ r r© r³ Úunionr´ rÏ rØ Úreindexrè rþ rÚ râ rï rÀ r\ rÁ rÛ r rÜ rÞ Útype)r½ rZ rn ÚleftÚrightZlvalsZrvalsÚresultr¾ r¾ r¿ r\ ß sD M$
|
ÿ
|
|
ü
|
ÿ c C s d S r» r¾ r[ r¾ r¾ r¿ Ú
|
__matmul__R s zDataFrame.__matmul__c C s d S r» r¾ r[ r¾ r¾ r¿ rg V s c C s
|
| |¡S )úQ
|
Matrix multiplication using binary `@` operator in Python>=3.5.
|
)r\ r[ r¾ r¾ r¿ rg Z s c
|
C sp z| j t |¡¡j W S tk
|
rj } z6dt|kr6 dt |¡ d| j d}t||W 5 d}~X Y nX dS )rh zshape mismatchzshapes z and z not alignedN)rý r\ rÚ Ú transposerØ r rï )r½ rZ ÚerrÚmsgr¾ r¾ r¿ Ú __rmatmul__` s zDataFrame.__rmatmul__rÙ )rÓ Úorientrà r³ rº c C sð d}| ¡ }|dkr^t|dkrtt| ¡ d ttfrDt|}qt| ¡ }t| ¡ }n2|dkr|dk rt d| dnt d| d|d kr¨| ||||d
|
S |d }d d }||d |d }||d |d }| ||||d
|
S dS )aZ
|
Construct DataFrame from dict of array-like or dicts.
|
|
Creates DataFrame object from dictionary by columns or by index
|
allowing dtype specification.
|
|
Parameters
|
----------
|
data : dict
|
Of the form {field : array-like} or {field : dict}.
|
orient : {'columns', 'index', 'tight'}, default 'columns'
|
The "orientation" of the data. If the keys of the passed dict
|
should be the columns of the resulting DataFrame, pass 'columns'
|
(default). Otherwise if the keys should be rows, pass 'index'.
|
If 'tight', assume a dict with keys ['index', 'columns', 'data',
|
'index_names', 'column_names'].
|
|
.. versionadded:: 1.4.0
|
'tight' as an allowed value for the ``orient`` argument
|
|
dtype : dtype, default None
|
Data type to force after DataFrame construction, otherwise infer.
|
columns : list, default None
|
Column labels to use when ``orient='index'``. Raises a ValueError
|
if used with ``orient='columns'`` or ``orient='tight'``.
|
|
Returns
|
-------
|
DataFrame
|
|
See Also
|
--------
|
DataFrame.from_records : DataFrame from structured ndarray, sequence
|
of tuples or dicts, or DataFrame.
|
DataFrame : DataFrame object creation using constructor.
|
DataFrame.to_dict : Convert the DataFrame to a dictionary.
|
|
Examples
|
--------
|
By default the keys of the dict become the DataFrame columns:
|
|
>>> data = {'col_1': [3, 2, 1, 0], 'col_2': ['a', 'b', 'c', 'd']}
|
>>> pd.DataFrame.from_dict(data)
|
col_1 col_2
|
0 3 a
|
1 2 b
|
2 1 c
|
3 0 d
|
|
Specify ``orient='index'`` to create the DataFrame using dictionary
|
keys as rows:
|
|
>>> data = {'row_1': [3, 2, 1, 0], 'row_2': ['a', 'b', 'c', 'd']}
|
>>> pd.DataFrame.from_dict(data, orient='index')
|
0 1 2 3
|
row_1 3 2 1 0
|
row_2 a b c d
|
|
When using the 'index' orientation, the column names can be
|
specified manually:
|
|
>>> pd.DataFrame.from_dict(data, orient='index',
|
... columns=['A', 'B', 'C', 'D'])
|
A B C D
|
row_1 3 2 1 0
|
row_2 a b c d
|
|
Specify ``orient='tight'`` to create the DataFrame using a 'tight'
|
format:
|
|
>>> data = {'index': [('a', 'b'), ('a', 'c')],
|
... 'columns': [('x', 1), ('y', 2)],
|
... 'data': [[1, 3], [2, 4]],
|
... 'index_names': ['n1', 'n2'],
|
... 'column_names': ['z1', 'z2']}
|
>>> pd.DataFrame.from_dict(data, orient='tight')
|
z1 x y
|
z2 1 2
|
n1 n2
|
a b 1 3
|
c 2 4
|
Nr´ r )r³ Útightz*cannot use columns parameter with orient='ú'zBExpected 'index', 'columns' or 'tight' for orient parameter. Got 'z ' insteadrn ©r´ r³ rà rÓ c S s0 t |dkr tj| |d}nt| |d d}|S )Nró ©rß r ©rÎ )rÏ r Ú from_tuplesr )Z indexlistÚnamelistr´ r¾ r¾ r¿ Ú create_indexä s z)DataFrame.from_dict.<locals>.create_indexr# r³ Z column_names)
|
ÚlowerrÏ rÕ rã rè r rÙ Ú_from_nested_dictÚkeysrØ )ÚclsrÓ rm rà r³ r´ Zrealdataru r¾ r¾ r¿ Ú from_dictp s* Z
|
|
ÿzDataFrame.from_dictznpt.DTypeLike | NonerÝ ú
|
np.ndarray)rà rÄ Úna_valuerº c C sB |dk rt |¡}| jj|||d}|j|k r>t j||dd}|S )aV
|
Convert the DataFrame to a NumPy array.
|
|
By default, the dtype of the returned array will be the common NumPy
|
dtype of all types in the DataFrame. For example, if the dtypes are
|
``float16`` and ``float32``, the results dtype will be ``float32``.
|
This may require copying data and coercing values, which may be
|
expensive.
|
|
Parameters
|
----------
|
dtype : str or numpy.dtype, optional
|
The dtype to pass to :meth:`numpy.asarray`.
|
copy : bool, default False
|
Whether to ensure that the returned value is not a view on
|
another array. Note that ``copy=False`` does not *ensure* that
|
``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
|
a copy is made, even if not strictly necessary.
|
na_value : Any, optional
|
The value to use for missing values. The default value depends
|
on `dtype` and the dtypes of the DataFrame columns.
|
|
.. versionadded:: 1.1.0
|
|
Returns
|
-------
|
numpy.ndarray
|
|
See Also
|
--------
|
Series.to_numpy : Similar method for Series.
|
|
Examples
|
--------
|
>>> pd.DataFrame({"A": [1, 2], "B": [3, 4]}).to_numpy()
|
array([[1, 3],
|
[2, 4]])
|
|
With heterogeneous data, the lowest common type will have to
|
be used.
|
|
>>> df = pd.DataFrame({"A": [1, 2], "B": [3.0, 4.5]})
|
>>> df.to_numpy()
|
array([[1. , 3. ],
|
[2. , 4.5]])
|
|
For a mix of numeric and non-numeric types, the output array will
|
have object dtype.
|
|
>>> df['C'] = pd.date_range('2000', periods=2)
|
>>> df.to_numpy()
|
array([[1, 3.0, Timestamp('2000-01-01 00:00:00')],
|
[2, 4.5, Timestamp('2000-01-02 00:00:00')]], dtype=object)
|
N)rà rÄ r| F)rà rÄ )rÚ rà r¸ Úas_arrayrÈ )r½ rà rÄ r| rf r¾ r¾ r¿ Úto_numpyð s <
|
|
zDataFrame.to_numpyz list[int]rã )Úare_all_object_dtype_colsÚobject_dtype_indicesrº c C sb |r dd | j dddD }n@dd | j dddD }|r^|D ] }|D ]}t|| ||< qFq>|S )z
|
Simple helper method to create data for to ``to_dict(orient="split")`` and
|
``to_dict(orient="tight")`` to create the main output data
|
c S s g | ]}t tt|qS r¾ )rã rT rV ©rÐ Útr¾ r¾ r¿ rÔ < s ÿzFDataFrame._create_data_for_split_and_tight_to_dict.<locals>.<listcomp>FNrD c S s g | ] }t |qS r¾ )rã r r¾ r¾ r¿ rÔ A s )rW rV )r½ r r rÓ ÚrowrC r¾ r¾ r¿ Ú(_create_data_for_split_and_tight_to_dict4 s þz2DataFrame._create_data_for_split_and_tight_to_dictz>Literal[('dict', 'list', 'series', 'split', 'tight', 'index')]z
|
type[dict])rm Úintorº c C s d S r» r¾ ©r½ rm r
r¾ r¾ r¿ Úto_dictJ s zDataFrame.to_dictzLiteral['records']z
|
list[dict]c C s d S r» r¾ r r¾ r¾ r¿ r R s zILiteral[('dict', 'list', 'series', 'split', 'tight', 'records', 'index')]zdict | list[dict])rm r
r´ rº c C s ddl m} || |||S )a
|
Convert the DataFrame to a dictionary.
|
|
The type of the key-value pairs can be customized with the parameters
|
(see below).
|
|
Parameters
|
----------
|
orient : str {'dict', 'list', 'series', 'split', 'tight', 'records', 'index'}
|
Determines the type of the values of the dictionary.
|
|
- 'dict' (default) : dict like {column -> {index -> value}}
|
- 'list' : dict like {column -> [values]}
|
- 'series' : dict like {column -> Series(values)}
|
- 'split' : dict like
|
{'index' -> [index], 'columns' -> [columns], 'data' -> [values]}
|
- 'tight' : dict like
|
{'index' -> [index], 'columns' -> [columns], 'data' -> [values],
|
'index_names' -> [index.names], 'column_names' -> [column.names]}
|
- 'records' : list like
|
[{column -> value}, ... , {column -> value}]
|
- 'index' : dict like {index -> {column -> value}}
|
|
.. versionadded:: 1.4.0
|
'tight' as an allowed value for the ``orient`` argument
|
|
into : class, default dict
|
The collections.abc.Mapping subclass used for all Mappings
|
in the return value. Can be the actual class or an empty
|
instance of the mapping type you want. If you want a
|
collections.defaultdict, you must pass it initialized.
|
|
index : bool, default True
|
Whether to include the index item (and index_names item if `orient`
|
is 'tight') in the returned dictionary. Can only be ``False``
|
when `orient` is 'split' or 'tight'.
|
|
.. versionadded:: 2.0.0
|
|
Returns
|
-------
|
dict, list or collections.abc.Mapping
|
Return a collections.abc.Mapping object representing the DataFrame.
|
The resulting transformation depends on the `orient` parameter.
|
|
See Also
|
--------
|
DataFrame.from_dict: Create a DataFrame from a dictionary.
|
DataFrame.to_json: Convert a DataFrame to JSON format.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'col1': [1, 2],
|
... 'col2': [0.5, 0.75]},
|
... index=['row1', 'row2'])
|
>>> df
|
col1 col2
|
row1 1 0.50
|
row2 2 0.75
|
>>> df.to_dict()
|
{'col1': {'row1': 1, 'row2': 2}, 'col2': {'row1': 0.5, 'row2': 0.75}}
|
|
You can specify the return orientation.
|
|
>>> df.to_dict('series')
|
{'col1': row1 1
|
row2 2
|
Name: col1, dtype: int64,
|
'col2': row1 0.50
|
row2 0.75
|
Name: col2, dtype: float64}
|
|
>>> df.to_dict('split')
|
{'index': ['row1', 'row2'], 'columns': ['col1', 'col2'],
|
'data': [[1, 0.5], [2, 0.75]]}
|
|
>>> df.to_dict('records')
|
[{'col1': 1, 'col2': 0.5}, {'col1': 2, 'col2': 0.75}]
|
|
>>> df.to_dict('index')
|
{'row1': {'col1': 1, 'col2': 0.5}, 'row2': {'col1': 2, 'col2': 0.75}}
|
|
>>> df.to_dict('tight')
|
{'index': ['row1', 'row2'], 'columns': ['col1', 'col2'],
|
'data': [[1, 0.5], [2, 0.75]], 'index_names': [None], 'column_names': [None]}
|
|
You can also specify the mapping type.
|
|
>>> from collections import OrderedDict, defaultdict
|
>>> df.to_dict(into=OrderedDict)
|
OrderedDict([('col1', OrderedDict([('row1', 1), ('row2', 2)])),
|
('col2', OrderedDict([('row1', 0.5), ('row2', 0.75)]))])
|
|
If you want a `defaultdict`, you need to initialize it:
|
|
>>> dd = defaultdict(list)
|
>>> df.to_dict('records', into=dd)
|
[defaultdict(<class 'list'>, {'col1': 1, 'col2': 0.5}),
|
defaultdict(<class 'list'>, {'col1': 2, 'col2': 0.75})]
|
r )r )Zpandas.core.methods.to_dictr )r½ rm r
r´ r r¾ r¾ r¿ r V s l Úfailzlist[dict[str, str]] | None)
|
Údestination_tableÚ
|
project_idÚ chunksizeÚreauthÚ if_existsÚauth_local_webserverÚ table_schemaÚlocationÚ progress_barrº c C s0 ddl m} | j| ||||||||| |
|
d dS )ab
|
Write a DataFrame to a Google BigQuery table.
|
|
This function requires the `pandas-gbq package
|
<https://pandas-gbq.readthedocs.io>`__.
|
|
See the `How to authenticate with Google BigQuery
|
<https://pandas-gbq.readthedocs.io/en/latest/howto/authentication.html>`__
|
guide for authentication instructions.
|
|
Parameters
|
----------
|
destination_table : str
|
Name of table to be written, in the form ``dataset.tablename``.
|
project_id : str, optional
|
Google BigQuery Account project ID. Optional when available from
|
the environment.
|
chunksize : int, optional
|
Number of rows to be inserted in each chunk from the dataframe.
|
Set to ``None`` to load the whole dataframe at once.
|
reauth : bool, default False
|
Force Google BigQuery to re-authenticate the user. This is useful
|
if multiple accounts are used.
|
if_exists : str, default 'fail'
|
Behavior when the destination table exists. Value can be one of:
|
|
``'fail'``
|
If table exists raise pandas_gbq.gbq.TableCreationError.
|
``'replace'``
|
If table exists, drop it, recreate it, and insert data.
|
``'append'``
|
If table exists, insert data. Create if does not exist.
|
auth_local_webserver : bool, default True
|
Use the `local webserver flow`_ instead of the `console flow`_
|
when getting user credentials.
|
|
.. _local webserver flow:
|
https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_local_server
|
.. _console flow:
|
https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_console
|
|
*New in version 0.2.0 of pandas-gbq*.
|
|
.. versionchanged:: 1.5.0
|
Default value is changed to ``True``. Google has deprecated the
|
``auth_local_webserver = False`` `"out of band" (copy-paste)
|
flow
|
<https://developers.googleblog.com/2022/02/making-oauth-flows-safer.html?m=1#disallowed-oob>`_.
|
table_schema : list of dicts, optional
|
List of BigQuery table fields to which according DataFrame
|
columns conform to, e.g. ``[{'name': 'col1', 'type':
|
'STRING'},...]``. If schema is not provided, it will be
|
generated according to dtypes of DataFrame columns. See
|
BigQuery API documentation on available names of a field.
|
|
*New in version 0.3.1 of pandas-gbq*.
|
location : str, optional
|
Location where the load job should run. See the `BigQuery locations
|
documentation
|
<https://cloud.google.com/bigquery/docs/dataset-locations>`__ for a
|
list of available locations. The location must match that of the
|
target dataset.
|
|
*New in version 0.5.0 of pandas-gbq*.
|
progress_bar : bool, default True
|
Use the library `tqdm` to show the progress bar for the upload,
|
chunk by chunk.
|
|
*New in version 0.5.0 of pandas-gbq*.
|
credentials : google.auth.credentials.Credentials, optional
|
Credentials for accessing Google APIs. Use this parameter to
|
override default credentials, such as to use Compute Engine
|
:class:`google.auth.compute_engine.Credentials` or Service
|
Account :class:`google.oauth2.service_account.Credentials`
|
directly.
|
|
*New in version 0.8.0 of pandas-gbq*.
|
|
See Also
|
--------
|
pandas_gbq.to_gbq : This function in the pandas-gbq library.
|
read_gbq : Read a DataFrame from Google BigQuery.
|
r )Úgbq) r r r r r r r r Ú credentialsN)Z pandas.ior Úto_gbq) r½ r r r r r r r r r r r r¾ r¾ r¿ r Æ s ` õzDataFrame.to_gbq)Ú coerce_floatÚnrowsrº c s t trZ|dk r(t|r |g}| |dk r: |¡|dk rNj|djddS d}|dk rnt|}dddddd d
|
}tr2|d kr| S z t} W n t k
|
rÆ | ||d Y S X d}
|
t
|
| d rä| j j rä| j }
|
| g} |dk rþ| 7 } n| t |d ¡¡ |
|
dk r.tj| |
|
dn| t trÄ|dkrltt } fdd|D nVg g } ¡ D ](\} }| |kr|| | ¡ |¡ q|t| | ||\ }nt tjtfrêt|\}| nrt|\ |r0tD ](\}}|j tkrtj |dd|< qt |dkrH }n| ||\ }|dkrnt }nt |}|dk r(t |t st
|
|dsÚ| |¡}| |¡ t!d krÌt| |d}n tg |d}nNz fdd|D }W n t"t#fk
|
r |}Y nX t$||d}| %|¡ t&|rv fdd|D } fdd|D fddtD | |¡}t'd}t(|||d }| |S ) a
|
|
|
Convert structured or record ndarray to DataFrame.
|
|
Creates a DataFrame object from a structured ndarray, sequence of
|
tuples or dicts, or DataFrame.
|
|
Parameters
|
----------
|
data : structured ndarray, sequence of tuples or dicts, or DataFrame
|
Structured input data.
|
index : str, list of fields, array-like
|
Field of array to use as the index, alternately a specific set of
|
input labels to use.
|
exclude : sequence, default None
|
Columns or fields to exclude.
|
columns : sequence, default None
|
Column names to use. If the passed data do not have names
|
associated with them, this argument provides names for the
|
columns. Otherwise this argument indicates the order of the columns
|
in the result (any names not found in the data will become all-NA
|
columns).
|
coerce_float : bool, default False
|
Attempt to convert values of non-string, non-numeric objects (like
|
decimal.Decimal) to floating point, useful for SQL result sets.
|
nrows : int, default None
|
Number of rows to read if data is an iterator.
|
|
Returns
|
-------
|
DataFrame
|
|
See Also
|
--------
|
DataFrame.from_dict : DataFrame from dict of array-like or dicts.
|
DataFrame : DataFrame object creation using constructor.
|
|
Examples
|
--------
|
Data can be provided as a structured ndarray:
|
|
>>> data = np.array([(3, 'a'), (2, 'b'), (1, 'c'), (0, 'd')],
|
... dtype=[('col_1', 'i4'), ('col_2', 'U1')])
|
>>> pd.DataFrame.from_records(data)
|
col_1 col_2
|
0 3 a
|
1 2 b
|
2 1 c
|
3 0 d
|
|
Data can be provided as a list of dicts:
|
|
>>> data = [{'col_1': 3, 'col_2': 'a'},
|
... {'col_1': 2, 'col_2': 'b'},
|
... {'col_1': 1, 'col_2': 'c'},
|
... {'col_1': 0, 'col_2': 'd'}]
|
>>> pd.DataFrame.from_records(data)
|
col_1 col_2
|
0 3 a
|
1 2 b
|
2 1 c
|
3 0 d
|
|
Data can be provided as a list of tuples with corresponding columns:
|
|
>>> data = [(3, 'a'), (2, 'b'), (1, 'c'), (0, 'd')]
|
>>> pd.DataFrame.from_records(data, columns=['col_1', 'col_2'])
|
col_1 col_2
|
0 3 a
|
1 2 b
|
2 1 c
|
3 0 d
|
N©r³ FrÅ zlist[ArrayLike]r z+tuple[list[ArrayLike], Index, Index | None])rç Ú arr_columnsr³ rº c S s^ t | rt | d }nd}d}t | dkrB|dkrB|dkrBtd}t| |||\} }| ||fS )z·
|
If our desired 'columns' do not match the data's pre-existing 'arr_columns',
|
we re-order our arrays. This is like a pre-emptive (cheap) reindex.
|
r N)rÏ r
r )rç r r³ r´ ÚlengthÚ result_indexr¾ r¾ r¿ Ú maybe_reorder s z-DataFrame.from_records.<locals>.maybe_reorderr rÊ rà ró rð c s g | ] } | qS r¾ r¾ rM ©rÓ r¾ r¿ rÔ È s z*DataFrame.from_records.<locals>.<listcomp>T)Z try_floatÚ__iter__rr c s g | ]} |¡ qS r¾ ©Úget_loc)rÐ Úfield)r rç r¾ r¿ rÔ ý s rq c s g | ]}| kr|qS r¾ r¾ ©rÐ Úx©r r¾ r¿ rÔ s c s g | ]} |¡qS r¾ r ©rÐ Úcolr£ r¾ r¿ rÔ s c s g | ]\}}| kr|qS r¾ r¾ )rÐ rC rI )Ú to_remover¾ r¿ rÔ s rÇ rÍ ))rÕ r© rf Ú set_indexÚdroprÄ r rd ÚnextÚ StopIterationrá rà rß rQ Ú itertoolsÚislicerÚ rÈ rÙ Úsortedr; rO r rÛ r r@ rÝ r Úmaybe_convert_objectsr× r r ÚaddrÏ ÚKeyErrorrÞ r ÚupdateÚanyr r )ry rÓ r´ Úexcluder³ r r r r Z first_rowrà rè Zarr_columns_listrB rI rC rñ Z
|
index_dataZ arr_excluderå ræ r¾ )r rç rÓ r¦ r¿ Ú from_records6 s¸ R
|
|
|
|
|
|
|
|
|
ÿ þ
|
ÿ
|
|
|
|
|
|
|
|
|
zDataFrame.from_recordsz np.recarray)r´ rº c sÀ |r fddt jjD }| fddt t jD }t jj}t jtrbt
|
|¡}n|d dkrtdg}dd t | j¡D }n0 fddt t jD }d d jD }g }t|}g } t |D ]Ö\}
|
} |
|
} | |k rô|} || }n| |8 } |} j| }t| r@|| kr(| | } n| | kr<| | } nd} | dkrX| | j¡ qÒt| ttjtfrx| | ¡ qÒ|
|
|k rd
|
nd }d | d | d| }t|qÒtjj||| ddS )a{
|
Convert DataFrame to a NumPy record array.
|
|
Index will be included as the first field of the record array if
|
requested.
|
|
Parameters
|
----------
|
index : bool, default True
|
Include index in resulting record array, stored in 'index'
|
field or using the index label, if set.
|
column_dtypes : str, type, dict, default None
|
If a string or type, the data type to store all columns. If
|
a dictionary, a mapping of column names and indices (zero-indexed)
|
to specific data types.
|
index_dtypes : str, type, dict, default None
|
If a string or type, the data type to store all index levels. If
|
a dictionary, a mapping of index level names and indices
|
(zero-indexed) to specific data types.
|
|
This mapping is applied only if `index=True`.
|
|
Returns
|
-------
|
numpy.recarray
|
NumPy ndarray with the DataFrame labels as fields and each row
|
of the DataFrame as entries.
|
|
See Also
|
--------
|
DataFrame.from_records: Convert structured or record ndarray
|
to DataFrame.
|
numpy.recarray: An ndarray that allows field access using
|
attributes, analogous to typed columns in a
|
spreadsheet.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'A': [1, 2], 'B': [0.5, 0.75]},
|
... index=['a', 'b'])
|
>>> df
|
A B
|
a 1 0.50
|
b 2 0.75
|
>>> df.to_records()
|
rec.array([('a', 1, 0.5 ), ('b', 2, 0.75)],
|
dtype=[('index', 'O'), ('A', '<i8'), ('B', '<f8')])
|
|
If the DataFrame index has no label then the recarray field name
|
is set to 'index'. If the index has a label then this is used as the
|
field name:
|
|
>>> df.index = df.index.rename("I")
|
>>> df.to_records()
|
rec.array([('a', 1, 0.5 ), ('b', 2, 0.75)],
|
dtype=[('I', 'O'), ('A', '<i8'), ('B', '<f8')])
|
|
The index can be excluded from the record array:
|
|
>>> df.to_records(index=False)
|
rec.array([(1, 0.5 ), (2, 0.75)],
|
dtype=[('A', '<i8'), ('B', '<f8')])
|
|
Data types can be specified for the columns:
|
|
>>> df.to_records(column_dtypes={"A": "int32"})
|
rec.array([('a', 1, 0.5 ), ('b', 2, 0.75)],
|
dtype=[('I', 'O'), ('A', '<i4'), ('B', '<f8')])
|
|
As well as for the index:
|
|
>>> df.to_records(index_dtypes="<S2")
|
rec.array([(b'a', 1, 0.5 ), (b'b', 2, 0.75)],
|
dtype=[('I', 'S2'), ('A', '<i8'), ('B', '<f8')])
|
|
>>> index_dtypes = f"<S{df.index.str.len().max()}"
|
>>> df.to_records(index_dtypes=index_dtypes)
|
rec.array([(b'a', 1, 0.5 ), (b'b', 2, 0.75)],
|
dtype=[('I', 'S1'), ('A', '<i8'), ('B', '<f8')])
|
c s g | ]}t j |¡¡qS r¾ )rÚ râ r´ Zget_level_values©rÐ rC r¼ r¾ r¿ rÔ e s ÿz(DataFrame.to_records.<locals>.<listcomp>c s$ g | ] }t jd d
|f ¡qS r» ©rÚ râ r rµ r¼ r¾ r¿ rÔ j s r Nr´ c S s g | ] }t |qS r¾ ©r )rÐ rÎ r¾ r¾ r¿ rÔ u s c s$ g | ] }t jd d
|f ¡qS r» r¶ rµ r¼ r¾ r¿ rÔ w s c S s g | ] }t |qS r¾ r· ©rÐ Úcr¾ r¾ r¿ rÔ x s r ÚcolumnzInvalid dtype z specified for ú )rß Úformatsrð )rä r´ ÚnlevelsrÏ r³ rã rß rÕ r ÚcomZfill_missing_namesr« Úchainr@ r\ rO rà rc rÚ r rØ ZrecZ
|
fromarrays)r½ r´ Z column_dtypesZ index_dtypesZix_valsrç r# rß Z index_lenr¼ rC rI Z index_intZ dtype_mappingrÎ Úelementrk r¾ r¼ r¿ Ú
|
to_records sP S
|
|
þ ÿ
|
|
|
|
|
|
|
|
|
zDataFrame.to_records)rà Úverify_integrityrº c C sT |dk rt |}td}t|}t|t|kr8tdt||||||d}| |S )aÆ
|
Create DataFrame from a list of arrays corresponding to the columns.
|
|
Parameters
|
----------
|
arrays : list-like of arrays
|
Each array in the list corresponds to one column, in order.
|
columns : list-like, Index
|
The column names for the resulting DataFrame.
|
index : list-like, Index
|
The rows labels for the resulting DataFrame.
|
dtype : dtype, optional
|
Optional dtype to enforce for all arrays.
|
verify_integrity : bool, default True
|
Validate and homogenize all input. If set to False, it is assumed
|
that all elements of `arrays` are actual arrays how they will be
|
stored in a block (numpy ndarray or ExtensionArray), have the same
|
length as and are aligned with the index, and that `columns` and
|
`index` are ensured to be an Index object.
|
|
Returns
|
-------
|
DataFrame
|
NrÇ z#len(columns) must match len(arrays))rà r rË )ri r r rÏ rØ r )ry rç r³ r´ rà r rå ræ r¾ r¾ r¿ Ú _from_arrays± s !úzDataFrame._from_arraysÚstorage_optionsÚcompression_optionsÚpath)rÄ rÅ ér Úinfer) Ú convert_datesÚ write_indexÚ byteorderÚ
|
time_stampÚ
|
data_labelÚvariable_labelsÚversionÚ convert_strlÚ compressionrÄ Ú value_labelsz FilePath | WriteBuffer[bytes]zdict[Hashable, str] | Nonezdatetime.datetime | NonezSequence[Hashable] | Noner$ r: z'dict[Hashable, dict[float, str]] | None) rÆ rÉ rÊ rË rÌ rÍ rÎ rÏ rÐ rÑ rÄ rÒ rº c C s¾ |dkrt d|dkr6| dk r(t dddlm} n"|dkrLdd lm} n dd
|
lm} i }|dksl|dkrt| |d < |dks|d kr||d < | || f|||||||
|
| | d |}| ¡ dS )a}
|
Export DataFrame object to Stata dta format.
|
|
Writes the DataFrame to a Stata dataset file.
|
"dta" files contain a Stata dataset.
|
|
Parameters
|
----------
|
path : str, path object, or buffer
|
String, path object (implementing ``os.PathLike[str]``), or file-like
|
object implementing a binary ``write()`` function.
|
|
convert_dates : dict
|
Dictionary mapping columns containing datetime types to stata
|
internal format to use when writing the dates. Options are 'tc',
|
'td', 'tm', 'tw', 'th', 'tq', 'ty'. Column can be either an integer
|
or a name. Datetime columns that do not have a conversion type
|
specified will be converted to 'tc'. Raises NotImplementedError if
|
a datetime column has timezone information.
|
write_index : bool
|
Write the index to Stata dataset.
|
byteorder : str
|
Can be ">", "<", "little", or "big". default is `sys.byteorder`.
|
time_stamp : datetime
|
A datetime to use as file creation date. Default is the current
|
time.
|
data_label : str, optional
|
A label for the data set. Must be 80 characters or smaller.
|
variable_labels : dict
|
Dictionary containing columns as keys and variable labels as
|
values. Each label must be 80 characters or smaller.
|
version : {{114, 117, 118, 119, None}}, default 114
|
Version to use in the output dta file. Set to None to let pandas
|
decide between 118 or 119 formats depending on the number of
|
columns in the frame. Version 114 can be read by Stata 10 and
|
later. Version 117 can be read by Stata 13 or later. Version 118
|
is supported in Stata 14 and later. Version 119 is supported in
|
Stata 15 and later. Version 114 limits string variables to 244
|
characters or fewer while versions 117 and later allow strings
|
with lengths up to 2,000,000 characters. Versions 118 and 119
|
support Unicode characters, and version 119 supports more than
|
32,767 variables.
|
|
Version 119 should usually only be used when the number of
|
variables exceeds the capacity of dta format 118. Exporting
|
smaller datasets in format 119 may have unintended consequences,
|
and, as of November 2020, Stata SE cannot read version 119 files.
|
|
convert_strl : list, optional
|
List of column names to convert to string columns to Stata StrL
|
format. Only available if version is 117. Storing strings in the
|
StrL format can produce smaller dta files if strings have more than
|
8 characters and values are repeated.
|
{compression_options}
|
|
.. versionadded:: 1.1.0
|
|
.. versionchanged:: 1.4.0 Zstandard support.
|
|
{storage_options}
|
|
.. versionadded:: 1.2.0
|
|
value_labels : dict of dicts
|
Dictionary containing columns as keys and dictionaries of column value
|
to labels as values. Labels for a single variable must be 32,000
|
characters or smaller.
|
|
.. versionadded:: 1.4.0
|
|
Raises
|
------
|
NotImplementedError
|
* If datetimes contain timezone information
|
* Column dtype is not representable in Stata
|
ValueError
|
* Columns listed in convert_dates are neither datetime64[ns]
|
or datetime.datetime
|
* Column listed in convert_dates is not in DataFrame
|
* Categorical label contains more than 32,000 characters
|
|
See Also
|
--------
|
read_stata : Import Stata data files.
|
io.stata.StataWriter : Low-level writer for Stata data files.
|
io.stata.StataWriter117 : Low-level writer for version 117 files.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({{'animal': ['falcon', 'parrot', 'falcon',
|
... 'parrot'],
|
... 'speed': [350, 18, 361, 15]}})
|
>>> df.to_stata('animals.dta') # doctest: +SKIP
|
)rÇ éu év éw Nz1Only formats 114, 117, 118 and 119 are supported.rÇ Nz#strl is not supported in format 114r )Ú StataWriterrÓ )ÚStataWriter117)ÚStataWriterUTF8rÐ rÔ rÏ ) rÉ rË rÌ rÍ rÊ rÎ rÑ rÄ rÒ )rØ Zpandas.io.statarÖ r× rØ Ú
|
write_file)r½ rÆ rÉ rÊ rË rÌ rÍ rÎ rÏ rÐ rÑ rÄ rÒ Z statawriterÚkwargsÚwriterr¾ r¾ r¿ Úto_stataã s> r þõ ôzDataFrame.to_stata)rÆ rº c K s ddl m} || |f| dS )aá
|
Write a DataFrame to the binary Feather format.
|
|
Parameters
|
----------
|
path : str, path object, file-like object
|
String, path object (implementing ``os.PathLike[str]``), or file-like
|
object implementing a binary ``write()`` function. If a string or a path,
|
it will be used as Root Directory path when writing a partitioned dataset.
|
**kwargs :
|
Additional keywords passed to :func:`pyarrow.feather.write_feather`.
|
Starting with pyarrow 0.17, this includes the `compression`,
|
`compression_level`, `chunksize` and `version` keywords.
|
|
.. versionadded:: 1.1.0
|
|
Notes
|
-----
|
This function writes the dataframe as a `feather file
|
<https://arrow.apache.org/docs/python/feather.html>`_. Requires a default
|
index. For saving the DataFrame with your custom index use a method that
|
supports custom indices e.g. `to_parquet`.
|
r )Ú
|
to_featherN)Zpandas.io.feather_formatrÝ )r½ rÆ rÚ rÝ r¾ r¾ r¿ rÝ
|
s zDataFrame.to_featherr¯ aä Examples
|
--------
|
>>> df = pd.DataFrame(
|
... data={"animal_1": ["elk", "pig"], "animal_2": ["dog", "quetzal"]}
|
... )
|
>>> print(df.to_markdown())
|
| | animal_1 | animal_2 |
|
|---:|:-----------|:-----------|
|
| 0 | elk | dog |
|
| 1 | pig | quetzal |
|
|
Output markdown with a tabulate option.
|
|
>>> print(df.to_markdown(tablefmt="grid"))
|
+----+------------+------------+
|
| | animal_1 | animal_2 |
|
+====+============+============+
|
| 0 | elk | dog |
|
+----+------------+------------+
|
| 1 | pig | quetzal |
|
+----+------------+------------+)r¯ rÄ ÚexamplesÚwt)r Úmoder´ rÄ rº c K s d|krt d| dd¡ | dd¡ | d|¡ td}|j| f|}|d krV|S t|||d}|j |¡ W 5 Q R X d S ) NZ showindexz"Pass 'index' instead of 'showindexÚheadersrx ZtablefmtÚpipeÚtabulate©rÄ )rØ Ú
|
setdefaultrB rã r ÚhandleÚwrite) r½ r rà r´ rÄ rÚ rã rf Zhandlesr¾ r¾ r¿ Ú to_markdown
|
s " zDataFrame.to_markdownzlist[str] | NoneÚbytes)rÆ ÚenginerÑ r´ Úpartition_colsrÄ rº c K s d S r» r¾ ©r½ rÆ rê rÑ r´ rë rÄ rÚ r¾ r¾ r¿ Ú
|
to_parquetÍ
|
s zDataFrame.to_parquetc K s d S r» r¾ rì r¾ r¾ r¿ rí Ú
|
s rä ÚautoÚsnappyz$FilePath | WriteBuffer[bytes] | Nonez bytes | Nonec K s* ddl m} || ||f||||d|S )a
|
Write a DataFrame to the binary parquet format.
|
|
This function writes the dataframe as a `parquet file
|
<https://parquet.apache.org/>`_. You can choose different parquet
|
backends, and have the option of compression. See
|
:ref:`the user guide <io.parquet>` for more details.
|
|
Parameters
|
----------
|
path : str, path object, file-like object, or None, default None
|
String, path object (implementing ``os.PathLike[str]``), or file-like
|
object implementing a binary ``write()`` function. If None, the result is
|
returned as bytes. If a string or path, it will be used as Root Directory
|
path when writing a partitioned dataset.
|
|
.. versionchanged:: 1.2.0
|
|
Previously this was "fname"
|
|
engine : {{'auto', 'pyarrow', 'fastparquet'}}, default 'auto'
|
Parquet library to use. If 'auto', then the option
|
``io.parquet.engine`` is used. The default ``io.parquet.engine``
|
behavior is to try 'pyarrow', falling back to 'fastparquet' if
|
'pyarrow' is unavailable.
|
compression : {{'snappy', 'gzip', 'brotli', None}}, default 'snappy'
|
Name of the compression to use. Use ``None`` for no compression.
|
index : bool, default None
|
If ``True``, include the dataframe's index(es) in the file output.
|
If ``False``, they will not be written to the file.
|
If ``None``, similar to ``True`` the dataframe's index(es)
|
will be saved. However, instead of being saved as values,
|
the RangeIndex will be stored as a range in the metadata so it
|
doesn't require much space and is faster. Other indexes will
|
be included as columns in the file output.
|
partition_cols : list, optional, default None
|
Column names by which to partition the dataset.
|
Columns are partitioned in the order they are given.
|
Must be None if path is not a string.
|
{storage_options}
|
|
.. versionadded:: 1.2.0
|
|
**kwargs
|
Additional arguments passed to the parquet library. See
|
:ref:`pandas io <io.parquet>` for more details.
|
|
Returns
|
-------
|
bytes if no path argument is provided else None
|
|
See Also
|
--------
|
read_parquet : Read a parquet file.
|
DataFrame.to_orc : Write an orc file.
|
DataFrame.to_csv : Write a csv file.
|
DataFrame.to_sql : Write to a sql table.
|
DataFrame.to_hdf : Write to hdf.
|
|
Notes
|
-----
|
This function requires either the `fastparquet
|
<https://pypi.org/project/fastparquet>`_ or `pyarrow
|
<https://arrow.apache.org/docs/python/>`_ library.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame(data={{'col1': [1, 2], 'col2': [3, 4]}})
|
>>> df.to_parquet('df.parquet.gzip',
|
... compression='gzip') # doctest: +SKIP
|
>>> pd.read_parquet('df.parquet.gzip') # doctest: +SKIP
|
col1 col2
|
0 1 3
|
1 2 4
|
|
If you want to get a buffer to the parquet content you can use a io.BytesIO
|
object, as long as you don't use partition_cols, which creates multiple files.
|
|
>>> import io
|
>>> f = io.BytesIO()
|
>>> df.to_parquet(f)
|
>>> f.seek(0)
|
0
|
>>> content = f.read()
|
r )rí )rÑ r´ rë rÄ )Zpandas.io.parquetrí ) r½ rÆ rê rÑ r´ rë rÄ rÚ rí r¾ r¾ r¿ rí ç
|
s ` ýùøZpyarrow©rê r´ Ú engine_kwargszLiteral['pyarrow']zdict[str, Any] | None)rÆ rê r´ rñ rº c C s ddl m} || ||||dS )a
|
Write a DataFrame to the ORC format.
|
|
.. versionadded:: 1.5.0
|
|
Parameters
|
----------
|
path : str, file-like object or None, default None
|
If a string, it will be used as Root Directory path
|
when writing a partitioned dataset. By file-like object,
|
we refer to objects with a write() method, such as a file handle
|
(e.g. via builtin open function). If path is None,
|
a bytes object is returned.
|
engine : str, default 'pyarrow'
|
ORC library to use. Pyarrow must be >= 7.0.0.
|
index : bool, optional
|
If ``True``, include the dataframe's index(es) in the file output.
|
If ``False``, they will not be written to the file.
|
If ``None``, similar to ``infer`` the dataframe's index(es)
|
will be saved. However, instead of being saved as values,
|
the RangeIndex will be stored as a range in the metadata so it
|
doesn't require much space and is faster. Other indexes will
|
be included as columns in the file output.
|
engine_kwargs : dict[str, Any] or None, default None
|
Additional keyword arguments passed to :func:`pyarrow.orc.write_table`.
|
|
Returns
|
-------
|
bytes if no path argument is provided else None
|
|
Raises
|
------
|
NotImplementedError
|
Dtype of one or more columns is category, unsigned integers, interval,
|
period or sparse.
|
ValueError
|
engine is not pyarrow.
|
|
See Also
|
--------
|
read_orc : Read a ORC file.
|
DataFrame.to_parquet : Write a parquet file.
|
DataFrame.to_csv : Write a csv file.
|
DataFrame.to_sql : Write to a sql table.
|
DataFrame.to_hdf : Write to hdf.
|
|
Notes
|
-----
|
* Before using this function you should read the :ref:`user guide about
|
ORC <io.orc>` and :ref:`install optional dependencies <install.warn_orc>`.
|
* This function requires `pyarrow <https://arrow.apache.org/docs/python/>`_
|
library.
|
* For supported dtypes please refer to `supported ORC features in Arrow
|
<https://arrow.apache.org/docs/cpp/orc.html#data-types>`__.
|
* Currently timezones in datetime columns are not preserved when a
|
dataframe is converted into ORC files.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame(data={'col1': [1, 2], 'col2': [4, 3]})
|
>>> df.to_orc('df.orc') # doctest: +SKIP
|
>>> pd.read_orc('df.orc') # doctest: +SKIP
|
col1 col2
|
0 1 4
|
1 2 3
|
|
If you want to get a buffer to the orc content you can write it to io.BytesIO
|
>>> import io
|
>>> b = io.BytesIO(df.to_orc()) # doctest: +SKIP
|
>>> b.seek(0) # doctest: +SKIP
|
0
|
>>> content = b.read() # doctest: +SKIP
|
r )Úto_orcrð )Z pandas.io.orcrò )r½ rÆ rê r´ rñ rò r¾ r¾ r¿ rò T s Q ÿzDataFrame.to_orczSequence[Level] | NonezColspaceArgType | NonezFormattersType | NonezFloatFormatType | Nonez
|
bool | strzstr | list | tuple | Nonezint | bool | None)r r³ r r$ r´ r r r r! r# r" r r( r) r* r% Úclassesr& r+ ÚborderÚtable_idÚ render_linksr5 rº 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+ rô rõ rö r5 r¾ r¾ r¿ r/ « s zDataFrame.to_htmlc C s d S r» r¾ r÷ r¾ r¾ r¿ r/ È s z,Whether to print column labels, default Truez&str or int, list or dict of int or strzXThe minimum width of each column in CSS length units. An int is assumed to be px units.c C sd | dk r| t jkrtdt j| ||||||||| | |
|
||| | |d}t |¡j|||||||dS )a4
|
Render a DataFrame as an HTML table.
|
%(shared_params)s
|
bold_rows : bool, default True
|
Make the row labels bold in the output.
|
classes : str or list or tuple, default None
|
CSS class(es) to apply to the resulting html table.
|
escape : bool, default True
|
Convert the characters <, >, and & to HTML-safe sequences.
|
notebook : {True, False}, default False
|
Whether the generated HTML is for IPython Notebook.
|
border : int
|
A ``border=border`` attribute is included in the opening
|
`<table>` tag. Default ``pd.options.display.html.border``.
|
table_id : str, optional
|
A css id is included in the opening `<table>` tag if specified.
|
render_links : bool, default False
|
Convert URLs to HTML links.
|
encoding : str, default "utf-8"
|
Set character encoding.
|
|
.. versionadded:: 1.0
|
%(returns)s
|
See Also
|
--------
|
to_string : Convert DataFrame to a string.
|
Nz#Invalid value for justify parameter)r³ r r r$ r´ r r r% r! r" r# r& r* r r( r) )r ró r+ rô r5 rõ rö )r Z_VALID_JUSTIFY_PARAMETERSrØ 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 r1 r¾ r¾ r¿ r/ å s< =ï
|
ùÚpath_or_bufferrÓ r úutf-8Úlxmlz7FilePath | WriteBuffer[bytes] | WriteBuffer[str] | Nonez dict[str | None, str] | Nonez5FilePath | ReadBuffer[str] | ReadBuffer[bytes] | None)rø r´ Ú root_nameÚrow_namer Ú attr_colsÚ elem_colsÚ
|
namespacesÚprefixr5 Úxml_declarationÚ pretty_printÚparserÚ
|
stylesheetrÑ rÄ rº c C s ddl m}m} tddd}| dkr<|dk r2|}qRtdn| d krJ|}ntd
|
|| ||||||||| |
|
| | |||d }| ¡ S ) a©
|
Render a DataFrame to an XML document.
|
|
.. versionadded:: 1.3.0
|
|
Parameters
|
----------
|
path_or_buffer : 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.
|
index : bool, default True
|
Whether to include index in XML document.
|
root_name : str, default 'data'
|
The name of root element in XML document.
|
row_name : str, default 'row'
|
The name of row element in XML document.
|
na_rep : str, optional
|
Missing data representation.
|
attr_cols : list-like, optional
|
List of columns to write as attributes in row element.
|
Hierarchical columns will be flattened with underscore
|
delimiting the different levels.
|
elem_cols : list-like, optional
|
List of columns to write as children in row element. By default,
|
all columns output as children of row element. Hierarchical
|
columns will be flattened with underscore delimiting the
|
different levels.
|
namespaces : dict, optional
|
All namespaces to be defined in root element. Keys of dict
|
should be prefix names and values of dict corresponding URIs.
|
Default namespaces should be given empty string key. For
|
example, ::
|
|
namespaces = {{"": "https://example.com"}}
|
|
prefix : str, optional
|
Namespace prefix to be used for every element and/or attribute
|
in document. This should be one of the keys in ``namespaces``
|
dict.
|
encoding : str, default 'utf-8'
|
Encoding of the resulting document.
|
xml_declaration : bool, default True
|
Whether to include the XML declaration at start of document.
|
pretty_print : bool, default True
|
Whether output should be pretty printed with indentation and
|
line breaks.
|
parser : {{'lxml','etree'}}, default 'lxml'
|
Parser module to use for building of tree. Only 'lxml' and
|
'etree' are supported. With 'lxml', the ability to use XSLT
|
stylesheet is supported.
|
stylesheet : str, path object or file-like object, optional
|
A URL, file-like object, or a raw string containing an XSLT
|
script used to transform the raw XML output. Script should use
|
layout of elements and attributes from original output. This
|
argument requires ``lxml`` to be installed. Only XSLT 1.0
|
scripts and not later versions is currently supported.
|
{compression_options}
|
|
.. versionchanged:: 1.4.0 Zstandard support.
|
|
{storage_options}
|
|
Returns
|
-------
|
None or str
|
If ``io`` is None, returns the resulting XML format as a
|
string. Otherwise returns None.
|
|
See Also
|
--------
|
to_json : Convert the pandas object to a JSON string.
|
to_html : Convert DataFrame to a html.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({{'shape': ['square', 'circle', 'triangle'],
|
... 'degrees': [360, 360, 180],
|
... 'sides': [4, np.nan, 3]}})
|
|
>>> df.to_xml() # doctest: +SKIP
|
<?xml version='1.0' encoding='utf-8'?>
|
<data>
|
<row>
|
<index>0</index>
|
<shape>square</shape>
|
<degrees>360</degrees>
|
<sides>4.0</sides>
|
</row>
|
<row>
|
<index>1</index>
|
<shape>circle</shape>
|
<degrees>360</degrees>
|
<sides/>
|
</row>
|
<row>
|
<index>2</index>
|
<shape>triangle</shape>
|
<degrees>180</degrees>
|
<sides>3.0</sides>
|
</row>
|
</data>
|
|
>>> df.to_xml(attr_cols=[
|
... 'index', 'shape', 'degrees', 'sides'
|
... ]) # doctest: +SKIP
|
<?xml version='1.0' encoding='utf-8'?>
|
<data>
|
<row index="0" shape="square" degrees="360" sides="4.0"/>
|
<row index="1" shape="circle" degrees="360"/>
|
<row index="2" shape="triangle" degrees="180" sides="3.0"/>
|
</data>
|
|
>>> df.to_xml(namespaces={{"doc": "https://example.com"}},
|
... prefix="doc") # doctest: +SKIP
|
<?xml version='1.0' encoding='utf-8'?>
|
<doc:data xmlns:doc="https://example.com">
|
<doc:row>
|
<doc:index>0</doc:index>
|
<doc:shape>square</doc:shape>
|
<doc:degrees>360</doc:degrees>
|
<doc:sides>4.0</doc:sides>
|
</doc:row>
|
<doc:row>
|
<doc:index>1</doc:index>
|
<doc:shape>circle</doc:shape>
|
<doc:degrees>360</doc:degrees>
|
<doc:sides/>
|
</doc:row>
|
<doc:row>
|
<doc:index>2</doc:index>
|
<doc:shape>triangle</doc:shape>
|
<doc:degrees>180</doc:degrees>
|
<doc:sides>3.0</doc:sides>
|
</doc:row>
|
</doc:data>
|
r )ÚEtreeXMLFormatterÚLxmlXMLFormatterz
|
lxml.etreeÚignore)Úerrorsrú Nz7lxml not found, please install or use the etree parser.Úetreez,Values for parser can only be lxml or etree.)rø r´ rû rü r rý rþ rÿ r r5 r r r rÑ rÄ )Zpandas.io.formats.xmlr r rB Ú ImportErrorrØ Ú write_output)r½ rø r´ rû rü r rý rþ rÿ r r5 r r r r rÑ rÄ r r rú Ú TreeBuilderZ xml_formatterr¾ r¾ r¿ Úto_xmlC s> " ÿðzDataFrame.to_xmlzWriteBuffer[str] | Nonezbool | str | None)Úverboser r( Ú memory_usageÚ show_countsrº c C s" t | |d}|j||||d d S )N)rÓ r )r r( r r )r¤ Úrender)r½ r r r( r r r r¾ r¾ r¿ r s þüzDataFrame.info)r´ rÆ rº c sR | j fdd| ¡ D | jtjd}|rN| j | jj ddgd}| |¡}|S )a
|
Return the memory usage of each column in bytes.
|
|
The memory usage can optionally include the contribution of
|
the index and elements of `object` dtype.
|
|
This value is displayed in `DataFrame.info` by default. This can be
|
suppressed by setting ``pandas.options.display.memory_usage`` to False.
|
|
Parameters
|
----------
|
index : bool, default True
|
Specifies whether to include the memory usage of the DataFrame's
|
index in returned Series. If ``index=True``, the memory usage of
|
the index is the first item in the output.
|
deep : bool, default False
|
If True, introspect the data deeply by interrogating
|
`object` dtypes for system-level memory consumption, and include
|
it in the returned values.
|
|
Returns
|
-------
|
Series
|
A Series whose index is the original column names and whose values
|
is the memory usage of each column in bytes.
|
|
See Also
|
--------
|
numpy.ndarray.nbytes : Total bytes consumed by the elements of an
|
ndarray.
|
Series.memory_usage : Bytes consumed by a Series.
|
Categorical : Memory-efficient array for string values with
|
many repeated values.
|
DataFrame.info : Concise summary of a DataFrame.
|
|
Notes
|
-----
|
See the :ref:`Frequently Asked Questions <df-memory-usage>` for more
|
details.
|
|
Examples
|
--------
|
>>> dtypes = ['int64', 'float64', 'complex128', 'object', 'bool']
|
>>> data = dict([(t, np.ones(shape=5000, dtype=int).astype(t))
|
... for t in dtypes])
|
>>> df = pd.DataFrame(data)
|
>>> df.head()
|
int64 float64 complex128 object bool
|
0 1 1.0 1.0+0.0j 1 True
|
1 1 1.0 1.0+0.0j 1 True
|
2 1 1.0 1.0+0.0j 1 True
|
3 1 1.0 1.0+0.0j 1 True
|
4 1 1.0 1.0+0.0j 1 True
|
|
>>> df.memory_usage()
|
Index 128
|
int64 40000
|
float64 40000
|
complex128 80000
|
object 40000
|
bool 5000
|
dtype: int64
|
|
>>> df.memory_usage(index=False)
|
int64 40000
|
float64 40000
|
complex128 80000
|
object 40000
|
bool 5000
|
dtype: int64
|
|
The memory footprint of `object` dtype columns is ignored by default:
|
|
>>> df.memory_usage(deep=True)
|
Index 128
|
int64 40000
|
float64 40000
|
complex128 80000
|
object 180000
|
bool 5000
|
dtype: int64
|
|
Use a Categorical for efficient storage of an object-dtype column with
|
many repeated values.
|
|
>>> df['object'].astype('category').memory_usage(deep=True)
|
5244
|
c s g | ]\}}|j d dqS )F)r´ rÆ )r )rÐ r¥ r¹ rÅ r¾ r¿ rÔ s z*DataFrame.memory_usage.<locals>.<listcomp>)r´ rà rÅ r ©r´ )rÁ r; r³ rÚ Úintpr´ r Ú_append)r½ r´ rÆ rf Zindex_memory_usager¾ rÅ r¿ r % s Yý ÿ
|
zDataFrame.memory_usage©rÄ )rÄ rº c s t |i ¡ t| j}| jrn| jj}|r6t s6| ¡ }| j || j
|
| j dd}t røt | dkrø|j | j ¡ n| jrÈ|rÈt|d rÈ|d ¡ | j} fdd|D }t| j|| j
|
| j d}n0| jj}|rât sâ| ¡ }| j || j
|
| j dd}|j| ddS ) a©
|
|
Transpose index and columns.
|
|
Reflect the DataFrame over its main diagonal by writing rows as columns
|
and vice-versa. The property :attr:`.T` is an accessor to the method
|
:meth:`transpose`.
|
|
Parameters
|
----------
|
*args : tuple, optional
|
Accepted for compatibility with NumPy.
|
copy : bool, default False
|
Whether to copy the data after transposing, even for DataFrames
|
with a single dtype.
|
|
Note that a copy is always required for mixed dtype DataFrames,
|
or for DataFrames with any extension types.
|
|
Returns
|
-------
|
DataFrame
|
The transposed DataFrame.
|
|
See Also
|
--------
|
numpy.transpose : Permute the dimensions of a given array.
|
|
Notes
|
-----
|
Transposing a DataFrame with mixed dtypes will result in a homogeneous
|
DataFrame with the `object` dtype. In such a case, a copy of the data
|
is always made.
|
|
Examples
|
--------
|
**Square DataFrame with homogeneous dtype**
|
|
>>> d1 = {'col1': [1, 2], 'col2': [3, 4]}
|
>>> df1 = pd.DataFrame(data=d1)
|
>>> df1
|
col1 col2
|
0 1 3
|
1 2 4
|
|
>>> df1_transposed = df1.T # or df1.transpose()
|
>>> df1_transposed
|
0 1
|
col1 1 2
|
col2 3 4
|
|
When the dtype is homogeneous in the original DataFrame, we get a
|
transposed DataFrame with the same dtype:
|
|
>>> df1.dtypes
|
col1 int64
|
col2 int64
|
dtype: object
|
>>> df1_transposed.dtypes
|
0 int64
|
1 int64
|
dtype: object
|
|
**Non-square DataFrame with mixed dtypes**
|
|
>>> d2 = {'name': ['Alice', 'Bob'],
|
... 'score': [9.5, 8],
|
... 'employed': [False, True],
|
... 'kids': [0, 0]}
|
>>> df2 = pd.DataFrame(data=d2)
|
>>> df2
|
name score employed kids
|
0 Alice 9.5 False 0
|
1 Bob 8.0 True 0
|
|
>>> df2_transposed = df2.T # or df2.transpose()
|
>>> df2_transposed
|
0 1
|
name Alice Bob
|
score 9.5 8.0
|
employed False True
|
kids 0 0
|
|
When the DataFrame has mixed dtypes, we get a transposed DataFrame with
|
the `object` dtype:
|
|
>>> df2.dtypes
|
name object
|
score float64
|
employed bool
|
kids int64
|
dtype: object
|
>>> df2_transposed.dtypes
|
0 object
|
1 object
|
dtype: object
|
Fr` r c s g | ]} j |d qS )rð )Z_from_sequence)rÐ r ©Zarr_typerà r¾ r¿ rÔ s z'DataFrame.transpose.<locals>.<listcomp>rÊ ri ©Úmethod)ÚnvZvalidate_transposerã Údtypesrù rþ rý r rÄ rÀ r³ r´ rÏ r¸ rG rø r^ Zconstruct_array_typerè rc rà rF ) r½ rÄ Úargsr Únew_valsrf rè Ú
|
new_valuesZnew_arrr¾ r r¿ ri sN a
|
|
ÿÿÿ
|
ÿ ÿ
|
ûzDataFrame.transposec C s | ¡ S )aç
|
The transpose of the DataFrame.
|
|
Returns
|
-------
|
DataFrame
|
The transposed DataFrame.
|
|
See Also
|
--------
|
DataFrame.transpose : Transpose index and columns.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
|
>>> df
|
col1 col2
|
0 1 3
|
1 2 4
|
|
>>> df.T
|
0 1
|
col1 1 2
|
col2 3 4
|
)ri r¼ r¾ r¾ r¿ rý s z DataFrame.Tr r" )rC r° rº c C s |dkrZ| j |¡}t|jtjo,|jjdk}| j|| j| d | ¡}|j
|
| |d |S | j | }| j |¡}| ||¡}| || ¡ |S dS )z
|
Parameters
|
----------
|
i : int
|
axis : int
|
|
Returns
|
-------
|
Series
|
r Nrr r )r¸ Zfast_xsrÕ rÈ rÚ rÛ ÚbaserÁ r´ rF Ú _set_is_copyr³ ÚigetÚ_box_col_valuesZ_set_as_cached)r½ rC r° Únew_mgrrÄ rf ÚlabelZcol_mgrr¾ r¾ r¿ rA 7 s ÿ
|
zDataFrame._ixsr )rC rº c C s | j |¡S )a
|
Get the values of the i'th column (ndarray or ExtensionArray, as stored
|
in the Block)
|
|
Warning! The returned array is a view but doesn't handle Copy-on-Write,
|
so this should be used with caution (for read-only purposes).
|
)r¸ Z iget_values©r½ rC r¾ r¾ r¿ Ú_get_column_arrayY s zDataFrame._get_column_arrayzIterator[ArrayLike]c c s$ t t| jD ]}| |¡V qdS )a-
|
Iterate over the arrays of all columns in order.
|
This returns the values as stored in the Block (ndarray or ExtensionArray).
|
|
Warning! The returned array is a view but doesn't handle Copy-on-Write,
|
so this should be used with caution (for read-only purposes).
|
N)rä rÏ r³ r% r$ r¾ r¾ r¿ Ú_iter_column_arraysc s z DataFrame._iter_column_arrays)Úkeyc C s> | j |d¡d }| j | }| jj||ddddd}| |¡S )zt
|
Behaves like __getitem__, but returns a view in cases where __getitem__
|
would make a copy.
|
r³ ró r TF)r° Ú
|
allow_dupsrÄ Z
|
only_slice)r³ Ú_get_indexer_strictr¸ Úreindex_indexerrÀ )r½ r' ÚindexerZnew_axisr" r¾ r¾ r¿ Ú_getitem_nocopyn s
|
úzDataFrame._getitem_nocopyc C sø t | t |¡}t || ¡}t|rt|st| jt }|sl| jj
|
rP|| jksb|| jj ddkrl| |¡S |r| jj
|
r|| jkr| |¡S t|trö| jj|dd}t|tjrèt |jtjddt| ¡}t|tjrè| j|ddS | j|ddS t|tr | |¡S t |¡r"| |¡S t|t p6t | }|rt| jj dkrV| |¡S | j |¡}t!|r|g}n$t|rt"|}| j #|d ¡d }t$|d
|
d t%kr¸t |¡d }| j&|dd}|rô|j'd dkrôt| jt sô| |¡S |S ) NF©ÚkeepÚgetitem©Úkindr r r= ró r³ rà )(r r Úitem_from_zerodimr¾ Úapply_if_callablera rd rÕ r³ r r> Údrop_duplicatesr? Ú_getitem_multilevelÚslicer´ Ú_convert_slice_indexerrÚ rÛ Zmaybe_indices_to_sliceÚastyper rÏ ÚtakeZ_slicer© ÚwhereÚis_bool_indexerÚ_getitem_bool_arrayÚtuplere r½ r rb rã r) rà ré Ú_take_with_is_copyrï )r½ r' Zis_mir+ Z is_single_keyrÓ r¾ r¾ r¿ Ú __getitem__ s\
|
ÿþý
|
|
|
ÿ
|
|
|
|
|
|
zDataFrame.__getitem__c C s t |tr,|j | j¡s,tjdtt d n2t|t| jkr^t dt| dt| j dt
|
| j|}| ¡ r~| j d dS | ¡ d }| j|ddS ) Nz>Boolean Series key will be reindexed to match DataFrame index.©Ú
|
stacklevelúItem wrong length ú instead of r rÅ r r= )rÕ r r´ ÚequalsÚwarningsÚwarnÚ UserWarningrK rÏ rØ r ÚallrÄ Únonzeror> )r½ r' r+ r¾ r¾ r¿ r< Ê s ýÿ z DataFrame._getitem_bool_arrayc C s | j |¡}t|ttjfrü| j | }t||}| jrJ| j|d}||_ nN| j d d
|f }| j
|
|| j |dd}t rt|tr|j | j ¡ | | ¡}t|j dkrî|j d }t|trÂ|d }|dkrî|d }t|trî| j|| j |d}| | ¡ |S | j|ddS d S ) Nr Fr` ró r Ú rD r= )r³ r rÕ r6 rÚ rÛ r r÷ rb rþ rÀ r´ r r¸ rG rF rÏ r= r rÁ r rA )r½ r' ÚlocÚ new_columnsZresult_columnsrf r Útopr¾ r¾ r¿ r5 å s@
|
|
ÿ
|
|
|
|
ÿ
|
z DataFrame._getitem_multilevelr8 )Útakeablerº c C sd |r | j |dd}|j| S | |¡}| jj}t| jtsP| j |¡}|j| S | |¡}|j| S )aÃ
|
Quickly retrieve single value at passed column and index.
|
|
Parameters
|
----------
|
index : row label
|
col : column label
|
takeable : interpret the index/col as indexers, default False
|
|
Returns
|
-------
|
scalar
|
|
Notes
|
-----
|
Assumes that both `self.index._index_as_unique` and
|
`self.columns._index_as_unique`; Caller is responsible for checking.
|
ró r= )rA rþ r? r´ Z_enginerÕ r r )r½ r´ r¥ rN Úseriesrê r rK r¾ r¾ r¿ Ú
|
_get_value s
|
|
|
|
zDataFrame._get_valuec C st t |trVt|r|g}t|D ]0\}}| |jdd
|f ¡}| j||dd q dS | |¡}| j||dd dS )a]
|
Set the given value in the column with position `loc`.
|
|
This is a positional analogue to ``__setitem__``.
|
|
Parameters
|
----------
|
loc : int or sequence of ints
|
Index position for the column.
|
value : scalar or arraylike
|
Value(s) for the column.
|
|
Notes
|
-----
|
``frame.isetitem(loc, value)`` is an in-place method as it will
|
modify the DataFrame in place (not returning a new object). In contrast to
|
``frame.iloc[:, i] = value`` which will try to update the existing values in
|
place, ``frame.isetitem(loc, value)`` will not update the values of the column
|
itself in place, it will instead insert a new array.
|
|
In cases where ``frame.columns`` is unique, this is equivalent to
|
``frame[frame.columns[i]] = value``.
|
NF©r± )rÕ r© rf r@ Ú_sanitize_columnr Ú_iset_item_mgr)r½ rK r rC ÚidxÚ arrayliker¾ r¾ r¿ Úisetitem7 s
|
|
zDataFrame.isetitemc C s t s(t r(t | ¡dkr(tjttdd t || ¡}t
|
|t rZ| j j |dd}| ||¡S t
|
|tstt|dd dkr| ||¡ nt
|
|ttjttfr¤| ||¡ ntt
|
|tr¼| ||¡ n\t|r | jjs dt | j |g¡ k røt |kr n n| |g|¡ n | ||¡ d S )Né rÉ r@ r/ r0 rÜ ró ) rA r ÚsysÚ getrefcountrE rF rG rE r¾ r3 rÕ r6 r´ r7 Ú_setitem_slicer© rà Ú_setitem_framer rÚ rÛ rã r Ú_setitem_arrayÚ_set_item_frame_valuere r³ r> rÏ Úget_indexer_forÚ _set_item)r½ r' r Zslcr¾ r¾ r¿ Ú __setitem__[ s8
|
ÿ
|
|
ÿþ ýý zDataFrame.__setitem__r6 )r' rº c C s | ¡ || j|< d S r» )Ú_check_setitem_copyr ©r½ r' r r¾ r¾ r¿ rZ z s zDataFrame._setitem_slicec C s: t |¡rt|t| jkr<tdt| dt| j dt| j|}| ¡ d }| ¡ t|t rx|
|
| j |¡¡}|| j |< n²t|t rÀt | j|| t||jD ]\}}|| | |< q¨nvt|sÜ|D ] }|| |< qÌnZt|tjr|jdkr| ||¡ n2t |¡dkr*t |j}| ||¡S | ||¡ d S )NrB rC ú!r rÉ ró )r¾ r; rÏ r´ rØ r rI ra rÕ r© rb r9 r r r³ rE re rÚ rÛ rÜ Ú_iset_not_inplacerè r\ )r½ r' r r+ Zk1Zk2r¥ r¾ r¾ r¿ r\ s0
|
ÿ
|
|
|
zDataFrame._setitem_arrayc C sò dddd}| j jrVt |¡d t|kr4tdt|D ]\}}|||| |< q<n| j |¡d }|dk ¡ rvt t |¡d t|krtdt
|
|¡dks¦t | j }z8t t t| j | _ t|D ]\}}|||| |< qÊW 5 || _ X d S ) NrX )rC c S s$ t | tjr| d|f S | | S d S )N.)rÕ rÚ rÛ )ÚobjrC r¾ r¾ r¿ Úigetitem° s z-DataFrame._iset_not_inplace.<locals>.igetitemrû ú"Columns must be same length as keyr rÉ )r³ r> rÚ rï rÏ rØ r@ Zget_indexer_non_uniquer² ÚNotImplementedErrorrÜ ÚAssertionErrorr rä ) r½ r' r rf rC r¥ ZilocsZ orig_columnsr r¾ r¾ r¿ rd © s$ zDataFrame._iset_not_inplacec C s t |tjr:|j| jkr td| j|f| ¡ ddi}|jr\tdd |j D s\t
|
d| |¡ | ¡ | j | |dd d S ) Nz,Array conditional must be same shape as selfrÄ Fc s s | ]}t |V qd S r» )rZ )rÐ rà r¾ r¾ r¿ r Ý s z+DataFrame._setitem_frame.<locals>.<genexpr>z;Must pass DataFrame or 2-d ndarray with boolean values onlyTrQ )rÕ rÚ rÛ rï rØ rÀ Z_construct_axes_dictÚsizerH r rÞ Z_check_inplace_settingra Z_whererb r¾ r¾ r¿ r[ Õ s ÿ
|
zDataFrame._setitem_frame)r rº c
|
C s> | |¡ || jkr
|
| j |¡}| j| }t|s>t|trBdnt|}|t|jkr`tdt| jtrÐt|t t
|
t j t frÐt||}t|r¬| |j¡s¬|j|dd}t||D ]\}}|| | |< q¶d S t|rî||jd | |< d S t|| j} | || ¡ d S t|jdkr(td| ||jd | |< d S )Nró rg r= r zBCannot set a DataFrame with multiple columns to the single column )Ú_ensure_valid_indexr³ r rf rÕ r= rÏ rØ r r6 r rÚ rÛ r r rD rb rE Ú_reindex_for_setitemr´ Ú _set_item_mgr)
|
r½ r' r rK ÚcolsZlen_colsZcols_droplevelr¥ Z col_droplevelrU r¾ r¾ r¿ r] æ s8
|
|
ÿ
|
ÿz DataFrame._set_item_frame_valuezint | slice | np.ndarray)rK r± rº c C s | j j|||d | ¡ d S )NrQ )r¸ ÚisetÚ_clear_item_cache)r½ rK r r± r¾ r¾ r¿ rS s zDataFrame._iset_item_mgrc C s\ z| j |¡}W n* tk
|
r: | j t| j ||¡ Y nX | ||¡ t| rX| ¡ d S r» )Ú
|
_info_axisr r° r¸ rP rÏ rS ra )r½ r' r rK r¾ r¾ r¿ rm s zDataFrame._set_item_mgr)rK rº c C s. | |¡}| j||dd t| r*| ¡ d S )NTrQ )rR rS rÏ ra )r½ rK r rU r¾ r¾ r¿ Ú
|
_iset_item% s
|
zDataFrame._iset_itemc C st | |¡}|| jkrd|jdkrdt|sd| jjr:t| jtrd| | }t|trdt |t
|
|jdf¡j }| ||¡ dS )a8
|
Add series to DataFrame in specified column.
|
|
If series is a numpy-array (not a Series/TimeSeries), it must be the
|
same length as the DataFrames index or an error will be thrown.
|
|
Series/TimeSeries will be conformed to the DataFrames index to
|
ensure homogeneity.
|
ró N) rR r³ rÜ r^ r> rÕ r r© rÚ ZtilerÏ rý rm )r½ r' r Zexisting_piecer¾ r¾ r¿ r_ / s
|
|
ÿþý
|
zDataFrame._set_itemr0 )r´ r rN rº c C sÒ zL|r|}t t|}n| j |¡}| j |¡}| jj|||dd | ¡ W n tt t
|
t fk
|
r |rx|| j ||f< n|| j ||f< | j |d¡ Y n6 tk
|
rÌ } ztdt| |W 5 d}~X Y nX dS )a>
|
Put single value at passed column and index.
|
|
Parameters
|
----------
|
index : Label
|
row label
|
col : Label
|
column label
|
value : scalar
|
takeable : bool, default False
|
Sets whether or not index/col interpreted as indexers
|
T)Z inplace_onlyNz)You can only assign a scalar value not a )r rX r³ r r´ r¸ Zcolumn_setitemrp r° rÞ rØ rO r rK r< ÚpoprF rc )r½ r´ r¥ r rN ZicolZiindexZii_errr¾ r¾ r¿ Ú
|
_set_valueH s& ÿþzDataFrame._set_valuec
|
C s t | jst|rt |rt|tsdz t|}W n2 tttfk
|
rb } ztd|W 5 d}~X Y nX |j ¡ }| jj
|
dk r| jj
|
|_
|
| j j |dt jd| _ dS )zn
|
Ensure that if we don't have an index, that we can create one from the
|
passed value.
|
zYCannot set a frame with no defined index and a value that cannot be converted to a SeriesNró )r° Ú
|
fill_value)rÏ r´ re rÕ r© r rØ rh rÞ rÄ rÎ r¸ Z reindex_axisrÚ Únan)r½ r rj Z
|
index_copyr¾ r¾ r¿ rk u s
|
ÿý
|
|
z DataFrame._ensure_valid_indexrª )rè rK rº c C s$ | j | }| j}|||dd | ¡S )z4
|
Provide boxed values for a column.
|
T)rÎ Úfastpath)r³ rÁ rF )r½ rè rK rÎ r¯ r¾ r¾ r¿ r! s
|
zDataFrame._box_col_valuesc C s | j ¡ d S r» )r< Úclearr¼ r¾ r¾ r¿ rp s zDataFrame._clear_item_cacher )Úitemrº c C sf t r | j |¡}| j|ddS | j}| |¡}|dkrb| j |¡}| j|dd}|||< | j|_|S )z8Return the cached item, item represents a label indexer.ró r= N)r r³ r rA r< ÚgetZ_is_copy)r½ ry rK ÚcacheÚresr¾ r¾ r¿ r? s
|
zDataFrame._get_item_cachec C s d S r» r¾ r¼ r¾ r¾ r¿ Ú _reset_cacher² s zDataFrame._reset_cacher)r r± rº c C sJ | j |¡}|j}| j|dd}|j|jkr4|r4dS | jj|||d dS )zO
|
The object has called back to us saying maybe it has changed.
|
ró r= NrQ )rq r rþ rA r¸ ro )r½ ry r r± rK rU Úoldr¾ r¾ r¿ Ú_maybe_cache_changed¶ s z DataFrame._maybe_cache_changedrQ zLiteral[False])Úexprr± rº c K s d S r» r¾ ©r½ r r± rÚ r¾ r¾ r¿ ÚqueryÇ s zDataFrame.queryz Literal[True]c K s d S r» r¾ r r¾ r¾ r¿ r Ë s zDataFrame | Nonec K s d S r» r¾ r r¾ r¾ r¿ r Ï s c K s t |d}t|ts,dt| d}t|| dd¡d |d< d|d< | j|f|}z| j| }W n tk
|
r | | }Y nX |r| |¡ dS |S dS ) aÏ
|
Query the columns of a DataFrame with a boolean expression.
|
|
Parameters
|
----------
|
expr : str
|
The query string to evaluate.
|
|
You can refer to variables
|
in the environment by prefixing them with an '@' character like
|
``@a + b``.
|
|
You can refer to column names that are not valid Python variable names
|
by surrounding them in backticks. Thus, column names containing spaces
|
or punctuations (besides underscores) or starting with digits must be
|
surrounded by backticks. (For example, a column named "Area (cm^2)" would
|
be referenced as ```Area (cm^2)```). Column names which are Python keywords
|
(like "list", "for", "import", etc) cannot be used.
|
|
For example, if one of your columns is called ``a a`` and you want
|
to sum it with ``b``, your query should be ```a a` + b``.
|
|
inplace : bool
|
Whether to modify the DataFrame rather than creating a new one.
|
**kwargs
|
See the documentation for :func:`eval` for complete details
|
on the keyword arguments accepted by :meth:`DataFrame.query`.
|
|
Returns
|
-------
|
DataFrame or None
|
DataFrame resulting from the provided query expression or
|
None if ``inplace=True``.
|
|
See Also
|
--------
|
eval : Evaluate a string describing operations on
|
DataFrame columns.
|
DataFrame.eval : Evaluate a string describing operations on
|
DataFrame columns.
|
|
Notes
|
-----
|
The result of the evaluation of this expression is first passed to
|
:attr:`DataFrame.loc` and if that fails because of a
|
multidimensional key (e.g., a DataFrame) then the result will be passed
|
to :meth:`DataFrame.__getitem__`.
|
|
This method uses the top-level :func:`eval` function to
|
evaluate the passed query.
|
|
The :meth:`~pandas.DataFrame.query` method uses a slightly
|
modified Python syntax by default. For example, the ``&`` and ``|``
|
(bitwise) operators have the precedence of their boolean cousins,
|
:keyword:`and` and :keyword:`or`. This *is* syntactically valid Python,
|
however the semantics are different.
|
|
You can change the semantics of the expression by passing the keyword
|
argument ``parser='python'``. This enforces the same semantics as
|
evaluation in Python space. Likewise, you can pass ``engine='python'``
|
to evaluate an expression using Python itself as a backend. This is not
|
recommended as it is inefficient compared to using ``numexpr`` as the
|
engine.
|
|
The :attr:`DataFrame.index` and
|
:attr:`DataFrame.columns` attributes of the
|
:class:`~pandas.DataFrame` instance are placed in the query namespace
|
by default, which allows you to treat both the index and columns of the
|
frame as a column in the frame.
|
The identifier ``index`` is used for the frame index; you can also
|
use the name of the index to identify it in a query. Please note that
|
Python keywords may not be used as identifiers.
|
|
For further details and examples see the ``query`` documentation in
|
:ref:`indexing <indexing.query>`.
|
|
*Backtick quoted variables*
|
|
Backtick quoted variables are parsed as literal Python code and
|
are converted internally to a Python valid identifier.
|
This can lead to the following problems.
|
|
During parsing a number of disallowed characters inside the backtick
|
quoted string are replaced by strings that are allowed as a Python identifier.
|
These characters include all operators in Python, the space character, the
|
question mark, the exclamation mark, the dollar sign, and the euro sign.
|
For other characters that fall outside the ASCII range (U+0001..U+007F)
|
and those that are not further specified in PEP 3131,
|
the query parser will raise an error.
|
This excludes whitespace different than the space character,
|
but also the hashtag (as it is used for comments) and the backtick
|
itself (backtick can also not be escaped).
|
|
In a special case, quotes that make a pair around a backtick can
|
confuse the parser.
|
For example, ```it's` > `that's``` will raise an error,
|
as it forms a quoted string (``'s > `that'``) with a backtick inside.
|
|
See also the Python documentation about lexical analysis
|
(https://docs.python.org/3/reference/lexical_analysis.html)
|
in combination with the source code in :mod:`pandas.core.computation.parsing`.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'A': range(1, 6),
|
... 'B': range(10, 0, -2),
|
... 'C C': range(10, 5, -1)})
|
>>> df
|
A B C C
|
0 1 10 10
|
1 2 8 9
|
2 3 6 8
|
3 4 4 7
|
4 5 2 6
|
>>> df.query('A > B')
|
A B C C
|
4 5 2 6
|
|
The previous expression is equivalent to
|
|
>>> df[df.A > df.B]
|
A B C C
|
4 5 2 6
|
|
For columns with spaces in their name, you can use backtick quoting.
|
|
>>> df.query('B == `C C`')
|
A B C C
|
0 1 10 10
|
|
The previous expression is equivalent to
|
|
>>> df[df.B == df['C C']]
|
A B C C
|
0 1 10 10
|
r± z'expr must be a string to be evaluated, z givenÚlevelr ró NÚtarget) rM rÕ r rc rØ rs ÚevalrK Ú_update_inplace)r½ r r± rÚ rk r| rf r¾ r¾ r¿ r Ó s
|
|
|
|
r c K s d S r» r¾ r r¾ r¾ r¿ r
q s zDataFrame.evalc K s d S r» r¾ r r¾ r¾ r¿ r
u s z
|
Any | Nonec K s~ ddl m} t|d}| dd¡d |d< | ¡ }| ¡ }||f}d|krR| |d< t| dd¡| |d< ||fd|i|S ) a
|
|
Evaluate a string describing operations on DataFrame columns.
|
|
Operates on columns only, not specific rows or elements. This allows
|
`eval` to run arbitrary code, which can make you vulnerable to code
|
injection if you pass user input to this function.
|
|
Parameters
|
----------
|
expr : str
|
The expression string to evaluate.
|
inplace : bool, default False
|
If the expression contains an assignment, whether to perform the
|
operation inplace and mutate the existing DataFrame. Otherwise,
|
a new DataFrame is returned.
|
**kwargs
|
See the documentation for :func:`eval` for complete details
|
on the keyword arguments accepted by
|
:meth:`~pandas.DataFrame.query`.
|
|
Returns
|
-------
|
ndarray, scalar, pandas object, or None
|
The result of the evaluation or None if ``inplace=True``.
|
|
See Also
|
--------
|
DataFrame.query : Evaluates a boolean expression to query the columns
|
of a frame.
|
DataFrame.assign : Can evaluate an expression or function to create new
|
values for a column.
|
eval : Evaluate a Python expression as a string using various
|
backends.
|
|
Notes
|
-----
|
For more details see the API documentation for :func:`~eval`.
|
For detailed examples see :ref:`enhancing performance with eval
|
<enhancingperf.eval>`.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'A': range(1, 6), 'B': range(10, 0, -2)})
|
>>> df
|
A B
|
0 1 10
|
1 2 8
|
2 3 6
|
3 4 4
|
4 5 2
|
>>> df.eval('A + B')
|
0 11
|
1 10
|
2 9
|
3 8
|
4 7
|
dtype: int64
|
|
Assignment is allowed though by default the original DataFrame is not
|
modified.
|
|
>>> df.eval('C = A + B')
|
A B C
|
0 1 10 11
|
1 2 8 10
|
2 3 6 9
|
3 4 4 8
|
4 5 2 7
|
>>> df
|
A B
|
0 1 10
|
1 2 8
|
2 3 6
|
3 4 4
|
4 5 2
|
|
Multiple columns can be assigned to using multi-line expressions:
|
|
>>> df.eval(
|
... '''
|
... C = A + B
|
... D = A - B
|
... '''
|
... )
|
A B C D
|
0 1 10 11 -9
|
1 2 8 10 -6
|
2 3 6 9 -3
|
3 4 4 8 0
|
4 5 2 7 3
|
r )r
r± r ró r Ú resolversr¾ )Z pandas.core.computation.evalr
rM rs Z_get_index_resolversZ _get_cleaned_column_resolversr= rz )r½ r r± rÚ Z_evalZindex_resolversZcolumn_resolversr r¾ r¾ r¿ r
y s \
|
c sì t sdk rfndt s4dk r0fndttf}t|sTtddd }||fD ] }t| qt ¡std@ ddd d
|
d d dd fdd }| j |¡jdd}t | |
|
| ¡S )aÅ
|
Return a subset of the DataFrame's columns based on the column dtypes.
|
|
Parameters
|
----------
|
include, exclude : scalar or list-like
|
A selection of dtypes or strings to be included/excluded. At least
|
one of these parameters must be supplied.
|
|
Returns
|
-------
|
DataFrame
|
The subset of the frame including the dtypes in ``include`` and
|
excluding the dtypes in ``exclude``.
|
|
Raises
|
------
|
ValueError
|
* If both of ``include`` and ``exclude`` are empty
|
* If ``include`` and ``exclude`` have overlapping elements
|
* If any kind of string dtype is passed in.
|
|
See Also
|
--------
|
DataFrame.dtypes: Return Series with the data type of each column.
|
|
Notes
|
-----
|
* To select all *numeric* types, use ``np.number`` or ``'number'``
|
* To select strings you must use the ``object`` dtype, but note that
|
this will return *all* object dtype columns
|
* See the `numpy dtype hierarchy
|
<https://numpy.org/doc/stable/reference/arrays.scalars.html>`__
|
* To select datetimes, use ``np.datetime64``, ``'datetime'`` or
|
``'datetime64'``
|
* To select timedeltas, use ``np.timedelta64``, ``'timedelta'`` or
|
``'timedelta64'``
|
* To select Pandas categorical dtypes, use ``'category'``
|
* To select Pandas datetimetz dtypes, use ``'datetimetz'`` (new in
|
0.20.0) or ``'datetime64[ns, tz]'``
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'a': [1, 2] * 3,
|
... 'b': [True, False] * 3,
|
... 'c': [1.0, 2.0] * 3})
|
>>> df
|
a b c
|
0 1 True 1.0
|
1 2 False 2.0
|
2 1 True 1.0
|
3 2 False 2.0
|
4 1 True 1.0
|
5 2 False 2.0
|
|
>>> df.select_dtypes(include='bool')
|
b
|
0 True
|
1 False
|
2 True
|
3 False
|
4 True
|
5 False
|
|
>>> df.select_dtypes(include=['float64'])
|
c
|
0 1.0
|
1 2.0
|
2 1.0
|
3 2.0
|
4 1.0
|
5 2.0
|
|
>>> df.select_dtypes(exclude=['int64'])
|
b c
|
0 True 1.0
|
1 False 2.0
|
2 True 1.0
|
3 False 2.0
|
4 True 1.0
|
5 False 2.0
|
Nr¾ z3at least one of include or exclude must be nonemptyc S s| g }| D ]j}t |tr |dks&|tkr@| tj¡ | tj¡ q|dksP|tkrd| tj tj
|
g¡ q| t |¡ qt |S )NrX Úfloat) rÕ r rX rO rÚ Úint32Úint64r rQ Úfloat64Úfloat32rX Ú frozenset)r Zconverted_dtypesrà r¾ r¾ r¿ Úcheck_int_infer_dtype@ s z6DataFrame.select_dtypes.<locals>.check_int_infer_dtypez include and exclude overlap on r( ré )rà rº c S sD t | ts| n| j} t| jt|pBtj|koBt| ddoBt | S )NZ _is_numericF)
|
rÕ rz Z numpy_dtypeÚ
|
issubclassrc r= rÚ Únumberrà rZ )rà Z
|
dtypes_setr¾ r¾ r¿ Údtype_predicateY s
|
|
ÿýz0DataFrame.select_dtypes.<locals>.dtype_predicater )rñ rº c s. | j }r |sdS r* |r*dS dS )NFTrð )rñ rà ©r r³ Úincluder¾ r¿ Ú predicateb s
|
|
z*DataFrame.select_dtypes.<locals>.predicaterÅ ) re r r² rØ rU Ú
|
isdisjointr¸ Z_get_data_subsetrÄ rc rF )r½ r r³ Z selectionr r r ræ r¾ r r¿ Ú select_dtypesâ s$ S
|
|
zDataFrame.select_dtypeszScalar | AnyArrayLikezbool | lib.NoDefault)rK rº r Úallow_duplicatesrº c C sp |t jkrd}|r"| jjs"td|s@|| jkr@td| dt|tsRtd| |¡}| j
|
|||¡ dS )a
|
Insert column into DataFrame at specified location.
|
|
Raises a ValueError if `column` is already contained in the DataFrame,
|
unless `allow_duplicates` is set to True.
|
|
Parameters
|
----------
|
loc : int
|
Insertion index. Must verify 0 <= loc <= len(columns).
|
column : str, number, or hashable object
|
Label of the inserted column.
|
value : Scalar, Series, or array-like
|
allow_duplicates : bool, optional, default lib.no_default
|
|
See Also
|
--------
|
Index.insert : Insert new item by index.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
|
>>> df
|
col1 col2
|
0 1 3
|
1 2 4
|
>>> df.insert(1, "newcol", [99, 99])
|
>>> df
|
col1 newcol col2
|
0 1 99 3
|
1 2 99 4
|
>>> df.insert(0, "col1", [100, 100], allow_duplicates=True)
|
>>> df
|
col1 col1 newcol col2
|
0 100 1 99 3
|
1 100 2 99 4
|
|
Notice that pandas uses index alignment in case of `value` from type `Series`:
|
|
>>> df.insert(0, "col0", pd.Series([5, 6], index=[1, 2]))
|
>>> df
|
col0 col1 col1 newcol col2
|
0 NaN 100 1 99 3
|
1 5.0 100 2 99 4
|
FzZCannot specify 'allow_duplicates=True' when 'self.flags.allows_duplicate_labels' is False.zcannot insert z, already existszloc must be intN) r r ÚflagsZallows_duplicate_labelsrØ r³ rÕ rX rÞ rR r¸ rP )r½ rK rº r r r¾ r¾ r¿ rP q s 4
|
ÿ
|
|
zDataFrame.insertc K s2 | j dd}| ¡ D ]\}}t ||¡||< q|S )a²
|
Assign new columns to a DataFrame.
|
|
Returns a new object with all original columns in addition to new ones.
|
Existing columns that are re-assigned will be overwritten.
|
|
Parameters
|
----------
|
**kwargs : dict of {str: callable or Series}
|
The column names are keywords. If the values are
|
callable, they are computed on the DataFrame and
|
assigned to the new columns. The callable must not
|
change input DataFrame (though pandas doesn't check it).
|
If the values are not callable, (e.g. a Series, scalar, or array),
|
they are simply assigned.
|
|
Returns
|
-------
|
DataFrame
|
A new DataFrame with the new columns in addition to
|
all the existing columns.
|
|
Notes
|
-----
|
Assigning multiple columns within the same ``assign`` is possible.
|
Later items in '\*\*kwargs' may refer to newly created or modified
|
columns in 'df'; items are computed and assigned into 'df' in order.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'temp_c': [17.0, 25.0]},
|
... index=['Portland', 'Berkeley'])
|
>>> df
|
temp_c
|
Portland 17.0
|
Berkeley 25.0
|
|
Where the value is a callable, evaluated on `df`:
|
|
>>> df.assign(temp_f=lambda x: x.temp_c * 9 / 5 + 32)
|
temp_c temp_f
|
Portland 17.0 62.6
|
Berkeley 25.0 77.0
|
|
Alternatively, the same behavior can be achieved by directly
|
referencing an existing Series or sequence:
|
|
>>> df.assign(temp_f=df['temp_c'] * 9 / 5 + 32)
|
temp_c temp_f
|
Portland 17.0 62.6
|
Berkeley 25.0 77.0
|
|
You can create multiple columns within the same assign where one
|
of the columns depends on another one defined within the same assign:
|
|
>>> df.assign(temp_f=lambda x: x['temp_c'] * 9 / 5 + 32,
|
... temp_k=lambda x: (x['temp_f'] + 459.67) * 5 / 9)
|
temp_c temp_f temp_k
|
Portland 17.0 62.6 290.15
|
Berkeley 25.0 77.0 298.15
|
NrÅ )rÄ r; r¾ r3 )r½ rÚ rÓ rB rI r¾ r¾ r¿ Úassignµ s > zDataFrame.assignc C s` | |¡ t|tr t|| jS t|r8tt|| jS t|rNt || j¡ t
|
|| jdddS )a)
|
Ensures new columns (which go into the BlockManager as new blocks) are
|
always copied and converted into an array.
|
|
Parameters
|
----------
|
value : scalar, Series, or array-like
|
|
Returns
|
-------
|
numpy.ndarray or ExtensionArray
|
T)rÄ Zallow_2d) rk rÕ r© rl r´ r\ r re r¾ Zrequire_length_matchr~ )r½ r r¾ r¾ r¿ rR ù s
|
|
zDataFrame._sanitize_columnc s fddt jD S )Nc s, i | ]$\}}|t j |¡ j|d dqS )T)r´ rÎ rw )r r¸ r r´ )rÐ rT ry r¼ r¾ r¿ Ú
|
<dictcomp> s ý
|
ÿz%DataFrame._series.<locals>.<dictcomp>)r@ r³ r¼ r¾ r¼ r¿ Ú_series s
|
üzDataFrame._seriesc C sT | }|d } | d k r*| | ||||||¡}|d }
|
|
|
d k rP| |
|
||||||¡}|S )Nr³ r´ )Ú_reindex_columnsÚ_reindex_index) r½ r® r ÚlimitÚ tolerancer ru rÄ Úframer³ r´ r¾ r¾ r¿ Ú _reindex_axes s0 ÿ ÿzDataFrame._reindex_axesr1 )rÄ r c C s4 | j j|||||d\}}| jd||gi||ddS )N©r r r r r F©rÄ ru r( )r´ rb Ú_reindex_with_indexers) r½ Ú new_indexr rÄ r ru r r r+ r¾ r¾ r¿ r 0 s
|
ÿ
|
|
üzDataFrame._reindex_indexc C s4 | j j|||||d\}}| jd||gi||ddS )Nr¢ ró Fr£ )r³ rb r¤ ) r½ rL r rÄ r ru r r r+ r¾ r¾ r¿ r D s
|
ÿ
|
|
üzDataFrame._reindex_columnszdict[str, Index])r® rÄ rº c
|
C s | j |d ¡\}}| j |d ¡\}}|dk rb|dk rb||f}t| j||d} | j| ||ddS | j||g||gd||dS dS ) z:
|
We are guaranteed non-Nones in the axes.
|
r´ r³ N)ru Fr` )r ró )rÄ ru )r´ rb r³ rt rè rÀ r¤ )
|
r½ r® rÄ ru r¥ Z row_indexerrL Z col_indexerr+ r r¾ r¾ r¿ Ú_reindex_multiX s ÿýzDataFrame._reindex_multiÚouterr z Axis | NonezFillnaOptions | Noner! )
|
rZ Újoinr° r rÄ r r Ú fill_axisÚbroadcast_axisrº c s t j||||||||| |
|
d
|
S )N) r¨ r° r rÄ ru r r r© rª )ÚsuperÚalign) r½ rZ r¨ r° r rÄ ru r r r© rª ©Ú __class__r¾ r¿ r¬ t s özDataFrame.aligna
|
Examples
|
--------
|
>>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
|
|
Change the row labels.
|
|
>>> df.set_axis(['a', 'b', 'c'], axis='index')
|
A B
|
a 1 4
|
b 2 5
|
c 3 6
|
|
Change the column labels.
|
|
>>> df.set_axis(['I', 'II'], axis='columns')
|
I II
|
0 1 4
|
1 2 5
|
2 3 6
|
z
|
column orz , and 1 identifies the columnsz or columns)Zextended_summary_subZaxis_description_subZ see_also_sub©r° rÄ )r° rÄ rº c s t j|||dS )Nr¯ )r« Úset_axis)r½ Úlabelsr° rÄ r r¾ r¿ r° s %zDataFrame.set_axisr² )r¯ r² ) r´ r³ r° r rÄ r ru r r z Level | Nonez Scalar | None)r° r rÄ r ru r rº c s t j||||||||| |
|
d
|
S )N)
|
r± r´ r³ r° r rÄ r ru r r )r« rb ) r½ r± r´ r³ r° r rÄ r ru r r r r¾ r¿ rb ¶ s özDataFrame.reindex)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 zDataFrame.drop)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 Úraisec s t j|||||||dS )al
|
Drop specified labels from rows or columns.
|
|
Remove rows or columns by specifying label names and corresponding
|
axis, or by specifying directly index or column names. When using a
|
multi-index, labels on different levels can be removed by specifying
|
the level. See the :ref:`user guide <advanced.shown_levels>`
|
for more information about the now unused levels.
|
|
Parameters
|
----------
|
labels : single label or list-like
|
Index or column labels to drop. A tuple will be used as a single
|
label and not treated as a list-like.
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
Whether to drop labels from the index (0 or 'index') or
|
columns (1 or 'columns').
|
index : single label or list-like
|
Alternative to specifying axis (``labels, axis=0``
|
is equivalent to ``index=labels``).
|
columns : single label or list-like
|
Alternative to specifying axis (``labels, axis=1``
|
is equivalent to ``columns=labels``).
|
level : int or level name, optional
|
For MultiIndex, level from which the labels will be removed.
|
inplace : bool, default False
|
If False, return a copy. Otherwise, do operation
|
inplace and return None.
|
errors : {'ignore', 'raise'}, default 'raise'
|
If 'ignore', suppress error and only existing labels are
|
dropped.
|
|
Returns
|
-------
|
DataFrame or None
|
DataFrame without the removed index or column labels or
|
None if ``inplace=True``.
|
|
Raises
|
------
|
KeyError
|
If any of the labels is not found in the selected axis.
|
|
See Also
|
--------
|
DataFrame.loc : Label-location based indexer for selection by label.
|
DataFrame.dropna : Return DataFrame with labels on given axis omitted
|
where (all or any) data are missing.
|
DataFrame.drop_duplicates : Return DataFrame with duplicate rows
|
removed, optionally only considering certain columns.
|
Series.drop : Return Series with specified index labels removed.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame(np.arange(12).reshape(3, 4),
|
... columns=['A', 'B', 'C', 'D'])
|
>>> df
|
A B C D
|
0 0 1 2 3
|
1 4 5 6 7
|
2 8 9 10 11
|
|
Drop columns
|
|
>>> df.drop(['B', 'C'], axis=1)
|
A D
|
0 0 3
|
1 4 7
|
2 8 11
|
|
>>> df.drop(columns=['B', 'C'])
|
A D
|
0 0 3
|
1 4 7
|
2 8 11
|
|
Drop a row by index
|
|
>>> df.drop([0, 1])
|
A B C D
|
2 8 9 10 11
|
|
Drop columns and/or rows of MultiIndex DataFrame
|
|
>>> midx = pd.MultiIndex(levels=[['lama', 'cow', 'falcon'],
|
... ['speed', 'weight', 'length']],
|
... codes=[[0, 0, 0, 1, 1, 1, 2, 2, 2],
|
... [0, 1, 2, 0, 1, 2, 0, 1, 2]])
|
>>> df = pd.DataFrame(index=midx, columns=['big', 'small'],
|
... data=[[45, 30], [200, 100], [1.5, 1], [30, 20],
|
... [250, 150], [1.5, 0.8], [320, 250],
|
... [1, 0.8], [0.3, 0.2]])
|
>>> df
|
big small
|
lama speed 45.0 30.0
|
weight 200.0 100.0
|
length 1.5 1.0
|
cow speed 30.0 20.0
|
weight 250.0 150.0
|
length 1.5 0.8
|
falcon speed 320.0 250.0
|
weight 1.0 0.8
|
length 0.3 0.2
|
|
Drop a specific index combination from the MultiIndex
|
DataFrame, i.e., drop the combination ``'falcon'`` and
|
``'weight'``, which deletes only the corresponding row
|
|
>>> df.drop(index=('falcon', 'weight'))
|
big small
|
lama speed 45.0 30.0
|
weight 200.0 100.0
|
length 1.5 1.0
|
cow speed 30.0 20.0
|
weight 250.0 150.0
|
length 1.5 0.8
|
falcon speed 320.0 250.0
|
length 0.3 0.2
|
|
>>> df.drop(index='cow', columns='small')
|
big
|
lama speed 45.0
|
weight 200.0
|
length 1.5
|
falcon speed 320.0
|
weight 1.0
|
length 0.3
|
|
>>> df.drop(index='length', level=1)
|
big small
|
lama speed 45.0 30.0
|
weight 200.0 100.0
|
cow speed 30.0 20.0
|
weight 250.0 150.0
|
falcon speed 320.0 250.0
|
weight 1.0 0.8
|
)r± r° r´ r³ r r± r )r« r¨ r² r r¾ r¿ r¨ s ù)r´ r³ r° rÄ r r zRenamer | None) Úmapperr´ 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¿ rN s zDataFrame.rename)r´ r³ r° rÄ r± r r c C s d S r» r¾ rµ r¾ r¾ r¿ rN s c C s d S r» r¾ rµ r¾ r¾ r¿ rN ¼ s r c
|
s t j||||||||dS )a·
|
Rename columns or index labels.
|
|
Function / dict values must be unique (1-to-1). Labels not contained in
|
a dict / Series will be left as-is. Extra labels listed don't throw an
|
error.
|
|
See the :ref:`user guide <basics.rename>` for more.
|
|
Parameters
|
----------
|
mapper : dict-like or function
|
Dict-like or function transformations to apply to
|
that axis' values. Use either ``mapper`` and ``axis`` to
|
specify the axis to target with ``mapper``, or ``index`` and
|
``columns``.
|
index : dict-like or function
|
Alternative to specifying axis (``mapper, axis=0``
|
is equivalent to ``index=mapper``).
|
columns : dict-like or function
|
Alternative to specifying axis (``mapper, axis=1``
|
is equivalent to ``columns=mapper``).
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
Axis to target with ``mapper``. Can be either the axis name
|
('index', 'columns') or number (0, 1). The default is 'index'.
|
copy : bool, default True
|
Also copy underlying data.
|
inplace : bool, default False
|
Whether to modify the DataFrame rather than creating a new one.
|
If True then value of copy is ignored.
|
level : int or level name, default None
|
In case of a MultiIndex, only rename labels in the specified
|
level.
|
errors : {'ignore', 'raise'}, default 'ignore'
|
If 'raise', raise a `KeyError` when a dict-like `mapper`, `index`,
|
or `columns` contains labels that are not present in the Index
|
being transformed.
|
If 'ignore', existing keys will be renamed and extra keys will be
|
ignored.
|
|
Returns
|
-------
|
DataFrame or None
|
DataFrame with the renamed axis labels or None if ``inplace=True``.
|
|
Raises
|
------
|
KeyError
|
If any of the labels is not found in the selected axis and
|
"errors='raise'".
|
|
See Also
|
--------
|
DataFrame.rename_axis : Set the name of the axis.
|
|
Examples
|
--------
|
``DataFrame.rename`` supports two calling conventions
|
|
* ``(index=index_mapper, columns=columns_mapper, ...)``
|
* ``(mapper, axis={'index', 'columns'}, ...)``
|
|
We *highly* recommend using keyword arguments to clarify your
|
intent.
|
|
Rename columns using a mapping:
|
|
>>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
|
>>> df.rename(columns={"A": "a", "B": "c"})
|
a c
|
0 1 4
|
1 2 5
|
2 3 6
|
|
Rename index using a mapping:
|
|
>>> df.rename(index={0: "x", 1: "y", 2: "z"})
|
A B
|
x 1 4
|
y 2 5
|
z 3 6
|
|
Cast index labels to a different type:
|
|
>>> df.index
|
RangeIndex(start=0, stop=3, step=1)
|
>>> df.rename(index=str).index
|
Index(['0', '1', '2'], dtype='object')
|
|
>>> df.rename(columns={"A": "a", "B": "b", "C": "c"}, errors="raise")
|
Traceback (most recent call last):
|
KeyError: ['C'] not found in axis
|
|
Using axis-style parameters:
|
|
>>> df.rename(str.lower, axis='columns')
|
a b
|
0 1 4
|
1 2 5
|
2 3 6
|
|
>>> df.rename({1: 2, 2: 4}, axis='index')
|
A B
|
0 1 4
|
2 2 5
|
4 3 6
|
)r´ r´ r³ r° rÄ r± r r )r« Z_renamerµ r r¾ r¿ rN Ë s wø)r r° r± r Údowncastz'Hashable | Mapping | Series | DataFramez dict | None)r r r° r± r r¶ rº c C s d S r» r¾ ©r½ r r r° r± r r¶ r¾ r¾ r¿ ÚfillnaM s zDataFrame.fillna)r r° r r¶ c C s d S r» r¾ r· r¾ r¾ r¿ r¸ Z s c C s d S r» r¾ r· r¾ r¾ r¿ r¸ g s c s t j||||||dS )N)r r r° r± r r¶ )r« r¸ r· r r¾ r¿ r¸ t s úc s t j|dS )a1
|
Return item and drop from frame. Raise KeyError if not found.
|
|
Parameters
|
----------
|
item : label
|
Label of column to be popped.
|
|
Returns
|
-------
|
Series
|
|
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'))
|
>>> df
|
name class max_speed
|
0 falcon bird 389.0
|
1 parrot bird 24.0
|
2 lion mammal 80.5
|
3 monkey mammal NaN
|
|
>>> df.pop('class')
|
0 bird
|
1 bird
|
2 mammal
|
3 mammal
|
Name: class, dtype: object
|
|
>>> df
|
name max_speed
|
0 falcon 389.0
|
1 parrot 24.0
|
2 lion 80.5
|
3 monkey NaN
|
)ry )r« rs )r½ ry r r¾ r¿ rs s )z DataFrame.pop)r± r Úregexr z2Literal[('pad', 'ffill', 'bfill')] | lib.NoDefault)r± r r¹ r rº c C s d S r» r¾ ©r½ Ú
|
to_replacer r± r r¹ r r¾ r¾ r¿ r, ³ s zDataFrame.replace)r r¹ r c C s d S r» r¾ rº r¾ r¾ r¿ r, À s c s t j||||||dS )N)r» r r± r r¹ r )r« r, rº r r¾ r¿ r, Í s úz dict[Hashable, tuple[Any, Any]])Úmappingr± c C s |r| n
|
| j dd}| j}t|D ]J\}}||kr"| jdd
|f }|| \} }
|
|j| |
|
|d} | || ¡ q"|rvdS | | ¡S )a@
|
Dispatch to Series.replace column-wise.
|
|
Parameters
|
----------
|
mapping : dict
|
of the form {col: (target, value)}
|
inplace : bool
|
regex : bool or same types as `to_replace` in DataFrame.replace
|
|
Returns
|
-------
|
DataFrame or None
|
NrÅ )r¹ )rÄ r³ r@ r r, rr rF ) r½ r¼ r± r¹ r| ÚaxrC Zax_valueÚserr r Znewobjr¾ r¾ r¿ Ú_replace_columnwiseá s z DataFrame._replace_columnwise)r¯ ró zFrequency | None)ÚperiodsÚfreqr° ru rº c s* | |¡}t| j}|dkr.|dkr.|d kr.|tjkr.|dkr.| jd }|dkrº| jd d
d |
f }tt|t|D ]2}| jd d
df t| ¡} |j
|
d|| dd qnd| jd d
| d
f }tt|t|D ]8}| jd d
df t| ¡} |j
|
t|j|| dd qä| j ¡ |_|S |dkr|dkr|tjk r|dkr| j j }
|
t|
|
dks~t|
|
d |st|} t| |} |dkrÂtjdg| tt|| tjd} n$tjtt| |dg| tjd} | j j| j| d|dd} | | ¡}|j| dd S t j ||||d
|
S ) Nró r T©r rû rð )r° ru r( Úshiftr )rÀ rÁ r° ru )Ú_get_axis_numberrÏ r³ r r r rä r
|
Úabsrà rP rÄ r¸ rç rP rÚ rÈ rã r r* rÀ rF r« )r½ rÀ rÁ r° ru Zncolsr# rf r¥ Zfillerrç Znperr+ ræ Úres_dfr r¾ r¿ rà s
|
|
ÿþýüû
|
|
ÿ ÿþýü û
|
|
ÿ ÿû
|
ÿzDataFrame.shift)r¨ rO r± r )r¨ rO r± r rº c C s d S r» r¾ ©r½ rx r¨ rO r± r r¾ r¾ r¿ r§ T s
|
zDataFrame.set_index)r¨ rO r c C s d S r» r¾ rÇ r¾ r¾ r¿ r§ ` s
|
c C sÒ t |d}| |¡ t|ts$|g}d}g }|D ]}t|tttjttj frft
|
|dddkr¾t |q0z|| j k} W n: t k
|
r® }
|
z t | dt| |
|
W 5 d}
|
~
|
X Y q0X | s0| |¡ q0|rÔtd| d|rÞ| } n | jdd } g } g } |rFt| jj} t| jtr:t| jjD ]}| | j |¡¡ q n | | j¡ g }|D ]}t|trt|jD ]}| | |¡¡ qj| |j¡ n t|ttfr¸| |¡ | |j¡ nxt|ttjfrà| |¡ | d¡ nPt|tj r| t|¡ | d¡ n(| | | ¡ | |¡ |r0| |¡ t| d
|
t| krNt d t| d t| d
|
qNt| | }|r |j s || ¡ ¡ }t d | t |D ] }| |= q¨| ¡ || _|sÎ| S dS )a¾
|
Set the DataFrame index using existing columns.
|
|
Set the DataFrame index (row labels) using one or more existing
|
columns or arrays (of the correct length). The index can replace the
|
existing index or expand on it.
|
|
Parameters
|
----------
|
keys : label or array-like or list of labels/arrays
|
This parameter can be either a single column key, a single array of
|
the same length as the calling DataFrame, or a list containing an
|
arbitrary combination of column keys and arrays. Here, "array"
|
encompasses :class:`Series`, :class:`Index`, ``np.ndarray``, and
|
instances of :class:`~collections.abc.Iterator`.
|
drop : bool, default True
|
Delete columns to be used as the new index.
|
append : bool, default False
|
Whether to append columns to existing index.
|
inplace : bool, default False
|
Whether to modify the DataFrame rather than creating a new one.
|
verify_integrity : bool, default False
|
Check the new index for duplicates. Otherwise defer the check until
|
necessary. Setting to False will improve the performance of this
|
method.
|
|
Returns
|
-------
|
DataFrame or None
|
Changed row labels or None if ``inplace=True``.
|
|
See Also
|
--------
|
DataFrame.reset_index : Opposite of set_index.
|
DataFrame.reindex : Change to new indices or expand indices.
|
DataFrame.reindex_like : Change to same indices as other DataFrame.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'month': [1, 4, 7, 10],
|
... 'year': [2012, 2014, 2013, 2014],
|
... 'sale': [55, 40, 84, 31]})
|
>>> df
|
month year sale
|
0 1 2012 55
|
1 4 2014 40
|
2 7 2013 84
|
3 10 2014 31
|
|
Set the index to become the 'month' column:
|
|
>>> df.set_index('month')
|
year sale
|
month
|
1 2012 55
|
4 2014 40
|
7 2013 84
|
10 2014 31
|
|
Create a MultiIndex using columns 'year' and 'month':
|
|
>>> df.set_index(['year', 'month'])
|
sale
|
year month
|
2012 1 55
|
2014 4 40
|
2013 7 84
|
2014 10 31
|
|
Create a MultiIndex using an Index and a column:
|
|
>>> df.set_index([pd.Index([1, 2, 3, 4]), 'year'])
|
month sale
|
year
|
1 2012 1 55
|
2 2014 4 40
|
3 2013 7 84
|
4 2014 10 31
|
|
Create a MultiIndex using two Series:
|
|
>>> s = pd.Series([1, 2, 3, 4])
|
>>> df.set_index([s, s**2])
|
month year sale
|
1 1 1 2012 55
|
2 4 4 2014 40
|
3 9 7 2013 84
|
4 16 10 2014 31
|
r± zThe parameter "keys" may be a column key, one-dimensional array, or a list containing only valid column keys and one-dimensional arrays.rÜ ró z. Received column of type NzNone of z are in the columnsrÅ rû zLength mismatch: Expected z rows, received array of length zIndex has duplicate keys: )!rM Ú*_check_inplace_and_allows_duplicate_labelsrÕ rã r r rÚ rÛ r r rà rØ r³ rÞ rc rO r° rÄ r´ rß r rä r½ Z_get_level_valuesrQ rÎ rÏ r r> r Úuniquer× Ú_cleanup)r½ rx r¨ rO r± r Úerr_msgÚmissingr¥ Úfoundrj r rç rß rC r¦ Únr´ Ú
|
duplicatesr¹ r¾ r¾ r¿ r§ l s b
|
|
|
ÿ
|
ÿþ
|
|
|
|
|
ÿ
|
|
)r¨ r± Ú col_levelÚcol_fillr rß z Hashable | Sequence[Hashable])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¿ Ú reset_index8 s zDataFrame.reset_index)r¨ rÐ rÑ r rß c C s d S r» r¾ rÒ r¾ r¾ r¿ rÓ F s c C s d S r» r¾ rÒ r¾ r¾ r¿ rÓ T s rJ c s* t |d} |¡ |r }n jdd}|tjk r>t |d}tt|} |dk rt|tt fsf|g} fdd|D }t| j
|
j k r j
|
|¡} |sd kr¦dnd}
|
j
|
||
|
¡}t j
|
trØt j
|
j j
|
j} n j
|
dff} t jt} tt t| D ]\} \}}|dk r&| |kr&q || }| rÄt|trHt |n|g}|dkrt|d jj fkr|td
|
| |d } j |¡}|g| | } jj t| }||g| 7 }t|}|j}|jtjkrât |¡}|dk r t j ||d |j d }|j d |||d q | |_
|
|s&|S dS )ar
|
Reset the index, or a level of it.
|
|
Reset the index of the DataFrame, and use the default one instead.
|
If the DataFrame has a MultiIndex, this method can remove one or more
|
levels.
|
|
Parameters
|
----------
|
level : int, str, tuple, or list, default None
|
Only remove the given levels from the index. Removes all levels by
|
default.
|
drop : bool, default False
|
Do not try to insert index into dataframe columns. This resets
|
the index to the default integer index.
|
inplace : bool, default False
|
Whether to modify the DataFrame rather than creating a new one.
|
col_level : int or str, default 0
|
If the columns have multiple levels, determines which level the
|
labels are inserted into. By default it is inserted into the first
|
level.
|
col_fill : object, default ''
|
If the columns have multiple levels, determines how the other
|
levels are named. If None then the index name is repeated.
|
allow_duplicates : bool, optional, default lib.no_default
|
Allow duplicate column labels to be created.
|
|
.. versionadded:: 1.5.0
|
|
names : int, str or 1-dimensional list, default None
|
Using the given string, rename the DataFrame column which contains the
|
index data. If the DataFrame has a MultiIndex, this has to be a list or
|
tuple with length equal to the number of levels.
|
|
.. versionadded:: 1.5.0
|
|
Returns
|
-------
|
DataFrame or None
|
DataFrame with the new index or None if ``inplace=True``.
|
|
See Also
|
--------
|
DataFrame.set_index : Opposite of reset_index.
|
DataFrame.reindex : Change to new indices or expand indices.
|
DataFrame.reindex_like : Change to same indices as other DataFrame.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([('bird', 389.0),
|
... ('bird', 24.0),
|
... ('mammal', 80.5),
|
... ('mammal', np.nan)],
|
... index=['falcon', 'parrot', 'lion', 'monkey'],
|
... columns=('class', 'max_speed'))
|
>>> df
|
class max_speed
|
falcon bird 389.0
|
parrot bird 24.0
|
lion mammal 80.5
|
monkey mammal NaN
|
|
When we reset the index, the old index is added as a column, and a
|
new sequential index is used:
|
|
>>> df.reset_index()
|
index class max_speed
|
0 falcon bird 389.0
|
1 parrot bird 24.0
|
2 lion mammal 80.5
|
3 monkey mammal NaN
|
|
We can use the `drop` parameter to avoid the old index being added as
|
a column:
|
|
>>> df.reset_index(drop=True)
|
class max_speed
|
0 bird 389.0
|
1 bird 24.0
|
2 mammal 80.5
|
3 mammal NaN
|
|
You can also use `reset_index` with `MultiIndex`.
|
|
>>> index = pd.MultiIndex.from_tuples([('bird', 'falcon'),
|
... ('bird', 'parrot'),
|
... ('mammal', 'lion'),
|
... ('mammal', 'monkey')],
|
... names=['class', 'name'])
|
>>> columns = pd.MultiIndex.from_tuples([('speed', 'max'),
|
... ('species', 'type')])
|
>>> df = pd.DataFrame([(389.0, 'fly'),
|
... (24.0, 'fly'),
|
... (80.5, 'run'),
|
... (np.nan, 'jump')],
|
... index=index,
|
... columns=columns)
|
>>> df
|
speed species
|
max type
|
class name
|
bird falcon 389.0 fly
|
parrot 24.0 fly
|
mammal lion 80.5 run
|
monkey NaN jump
|
|
Using the `names` parameter, choose a name for the index column:
|
|
>>> df.reset_index(names=['classes', 'names'])
|
classes names speed species
|
max type
|
0 bird falcon 389.0 fly
|
1 bird parrot 24.0 fly
|
2 mammal lion 80.5 run
|
3 mammal monkey NaN jump
|
|
If the index has multiple levels, we can reset a subset of them:
|
|
>>> df.reset_index(level='class')
|
class speed species
|
max type
|
name
|
falcon bird 389.0 fly
|
parrot bird 24.0 fly
|
lion mammal 80.5 run
|
monkey mammal NaN jump
|
|
If we are not dropping the index, by default, it is placed in the top
|
level. We can place it in another level:
|
|
>>> df.reset_index(level='class', col_level=1)
|
speed species
|
class max type
|
name
|
falcon bird 389.0 fly
|
parrot bird 24.0 fly
|
lion mammal 80.5 run
|
monkey mammal NaN jump
|
|
When the index is inserted under another level, we can specify under
|
which one with the parameter `col_fill`:
|
|
>>> df.reset_index(level='class', col_level=1, col_fill='species')
|
species speed species
|
class max type
|
name
|
falcon bird 389.0 fly
|
parrot bird 24.0 fly
|
lion mammal 80.5 run
|
monkey mammal NaN jump
|
|
If we specify a nonexistent level for `col_fill`, it is created:
|
|
>>> df.reset_index(level='class', col_level=1, col_fill='genus')
|
genus speed species
|
class max type
|
name
|
falcon bird 389.0 fly
|
parrot bird 24.0 fly
|
lion mammal 80.5 run
|
monkey mammal NaN jump
|
r± NrÅ r c s g | ]} j |¡qS r¾ )r´ Ú_get_level_number)rÐ Úlevr¼ r¾ r¿ rÔ s z)DataFrame.reset_index.<locals>.<listcomp>r´ Zlevel_0ró z:col_fill=None is incompatible with incomplete column name r T)Z
|
allow_fillru r ) rM rÈ rÄ r r r
rÏ rÕ r= rã r´ r½ Z droplevelZ_get_default_index_namesr rE ÚlevelsÚcodesr³ Úreversedr@ rØ rÔ rþ rà rÚ Zobject_r® rm r9 Z _na_valuerP )r½ r r¨ r± rÐ rÑ r rß Únew_objr¥ ÚdefaultZ to_insertZ multi_colrC rÕ ZlabrÎ Zcol_nameZlev_numZname_lstrÌ Z level_valuesr¾ r¼ r¿ rÓ b sv .
|
|
|
|
|
ÿ
|
|
ÿü
|
c C s" | | jjtd¡}|j| ddS )N)Úfuncrk r )rÀ r¸ rk rF )r½ rf r¾ r¾ r¿ rk [ s zDataFrame.isnac C s | ¡ S )zB
|
DataFrame.isnull is an alias for DataFrame.isna.
|
©rk r¼ r¾ r¾ r¿ Úisnull` s zDataFrame.isnullc C s
|
| ¡ S r» rÜ r¼ r¾ r¾ r¿ rl g s zDataFrame.notnac C s
|
| ¡ S )zD
|
DataFrame.notnull is an alias for DataFrame.notna.
|
rÜ r¼ r¾ r¾ r¿ Únotnullk s zDataFrame.notnull)r° ÚhowÚthreshÚsubsetr± Ú ignore_indexzAnyAll | NoDefaultzint | NoDefault)r° rß rà rá r± râ rº c C s d S r» r¾ ©r½ r° rß rà rá r± râ r¾ r¾ r¿ Údropnar s zDataFrame.dropna)r° rß rà rá râ c C s d S r» r¾ rã r¾ r¾ r¿ rä s c C st |t k r|t k rtd|t kr$d}t|d}t|ttfrDtd| |¡}d| }| }|dk r¸t|sp|g}| |¡} | |¡}
|
|
|
dk} |
|
¡ rªt t |¡| ¡ | j|
|
|d}|t k rÖ|j|d} | |k} nH|dkròt|j|d d
|
} n,|d krt|j
|
|d d
|
} ntd | t | ¡r8| jdd }n| j|d| }|r\tt||_|sf|S | |¡ dS )u¤
|
Remove missing values.
|
|
See the :ref:`User Guide <missing_data>` for more on which values are
|
considered missing, and how to work with missing data.
|
|
Parameters
|
----------
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
Determine if rows or columns which contain missing values are
|
removed.
|
|
* 0, or 'index' : Drop rows which contain missing values.
|
* 1, or 'columns' : Drop columns which contain missing value.
|
|
Pass tuple or list to drop on multiple axes.
|
Only a single axis is allowed.
|
|
how : {'any', 'all'}, default 'any'
|
Determine if row or column is removed from DataFrame, when we have
|
at least one NA or all NA.
|
|
* 'any' : If any NA values are present, drop that row or column.
|
* 'all' : If all values are NA, drop that row or column.
|
|
thresh : int, optional
|
Require that many non-NA values. Cannot be combined with how.
|
subset : column label or sequence of labels, optional
|
Labels along other axis to consider, e.g. if you are dropping rows
|
these would be a list of columns to include.
|
inplace : bool, default False
|
Whether to modify the DataFrame rather than creating a new one.
|
ignore_index : bool, default ``False``
|
If ``True``, the resulting axis will be labeled 0, 1, â¦, n - 1.
|
|
.. versionadded:: 2.0.0
|
|
Returns
|
-------
|
DataFrame or None
|
DataFrame with NA entries dropped from it or None if ``inplace=True``.
|
|
See Also
|
--------
|
DataFrame.isna: Indicate missing values.
|
DataFrame.notna : Indicate existing (non-missing) values.
|
DataFrame.fillna : Replace missing values.
|
Series.dropna : Drop missing values.
|
Index.dropna : Drop missing indices.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({"name": ['Alfred', 'Batman', 'Catwoman'],
|
... "toy": [np.nan, 'Batmobile', 'Bullwhip'],
|
... "born": [pd.NaT, pd.Timestamp("1940-04-25"),
|
... pd.NaT]})
|
>>> df
|
name toy born
|
0 Alfred NaN NaT
|
1 Batman Batmobile 1940-04-25
|
2 Catwoman Bullwhip NaT
|
|
Drop the rows where at least one element is missing.
|
|
>>> df.dropna()
|
name toy born
|
1 Batman Batmobile 1940-04-25
|
|
Drop the columns where at least one element is missing.
|
|
>>> df.dropna(axis='columns')
|
name
|
0 Alfred
|
1 Batman
|
2 Catwoman
|
|
Drop the rows where all elements are missing.
|
|
>>> df.dropna(how='all')
|
name toy born
|
0 Alfred NaN NaT
|
1 Batman Batmobile 1940-04-25
|
2 Catwoman Bullwhip NaT
|
|
Keep only the rows with at least 2 non-NA values.
|
|
>>> df.dropna(thresh=2)
|
name toy born
|
1 Batman Batmobile 1940-04-25
|
2 Catwoman Bullwhip NaT
|
|
Define in which columns to look for missing values.
|
|
>>> df.dropna(subset=['name', 'toy'])
|
name toy born
|
1 Batman Batmobile 1940-04-25
|
2 Catwoman Bullwhip NaT
|
zBYou cannot set both the how and thresh arguments at the same time.r² r± z7supplying multiple axes to axis is no longer supported.ró Nrû r= F)r° Ú bool_onlyrH zinvalid how option: rÅ )r rÞ rM rÕ r= rã rÄ re Ú _get_axisr^ r² r° rÚ rÈ Útolistr9 Úcountrl rH rØ rÄ rK r
rÏ r´ r )r½ r° rß rà rá r± râ Zagg_axisZagg_objr½ ÚindicesÚcheckrè Úmaskrf r¾ r¾ r¿ rä sL lÿ
|
|
|
|
|
|
|
Úfirst)r. r± râ z$Hashable | Sequence[Hashable] | Noner& )rá r. r± râ rº c C sf | j r| jddS t|d}t|d}| | j||d }|rLtt||_|r^| |¡ dS |S dS )u¨
|
Return DataFrame with duplicate rows removed.
|
|
Considering certain columns is optional. Indexes, including time indexes
|
are ignored.
|
|
Parameters
|
----------
|
subset : column label or sequence of labels, optional
|
Only consider certain columns for identifying duplicates, by
|
default use all of the columns.
|
keep : {'first', 'last', ``False``}, default 'first'
|
Determines which duplicates (if any) to keep.
|
|
- 'first' : Drop duplicates except for the first occurrence.
|
- 'last' : Drop duplicates except for the last occurrence.
|
- ``False`` : Drop all duplicates.
|
|
inplace : bool, default ``False``
|
Whether to modify the DataFrame rather than creating a new one.
|
ignore_index : bool, default ``False``
|
If ``True``, the resulting axis will be labeled 0, 1, â¦, n - 1.
|
|
Returns
|
-------
|
DataFrame or None
|
DataFrame with duplicates removed or None if ``inplace=True``.
|
|
See Also
|
--------
|
DataFrame.value_counts: Count unique combinations of columns.
|
|
Examples
|
--------
|
Consider dataset containing ramen rating.
|
|
>>> df = pd.DataFrame({
|
... 'brand': ['Yum Yum', 'Yum Yum', 'Indomie', 'Indomie', 'Indomie'],
|
... 'style': ['cup', 'cup', 'cup', 'pack', 'pack'],
|
... 'rating': [4, 4, 3.5, 15, 5]
|
... })
|
>>> df
|
brand style rating
|
0 Yum Yum cup 4.0
|
1 Yum Yum cup 4.0
|
2 Indomie cup 3.5
|
3 Indomie pack 15.0
|
4 Indomie pack 5.0
|
|
By default, it removes duplicate rows based on all columns.
|
|
>>> df.drop_duplicates()
|
brand style rating
|
0 Yum Yum cup 4.0
|
2 Indomie cup 3.5
|
3 Indomie pack 15.0
|
4 Indomie pack 5.0
|
|
To remove duplicates on specific column(s), use ``subset``.
|
|
>>> df.drop_duplicates(subset=['brand'])
|
brand style rating
|
0 Yum Yum cup 4.0
|
2 Indomie cup 3.5
|
|
To remove duplicates and keep last occurrences, use ``keep``.
|
|
>>> df.drop_duplicates(subset=['brand', 'style'], keep='last')
|
brand style rating
|
1 Yum Yum cup 4.0
|
2 Indomie cup 3.5
|
4 Indomie pack 5.0
|
NrÅ r± râ r- )ÚemptyrÄ rM r r
rÏ r´ r )r½ rá r. r± râ rf r¾ r¾ r¿ r4 - s Q
|
|
|
zDataFrame.drop_duplicates)rá r. rº c
|
s" j r jtdS dd fdd }dkr4 jn.t ¡r\tts\ttrb jkrbft t
|
t t j }|rt t |tdkr¼ jjr¼ d |¡}d|_nXfd d
|
¡ D }tttt|| \}}t|t|d d d } jt| | jd }|j ddS )a)
|
|
Return boolean Series denoting duplicate rows.
|
|
Considering certain columns is optional.
|
|
Parameters
|
----------
|
subset : column label or sequence of labels, optional
|
Only consider certain columns for identifying duplicates, by
|
default use all of the columns.
|
keep : {'first', 'last', False}, default 'first'
|
Determines which duplicates (if any) to mark.
|
|
- ``first`` : Mark duplicates as ``True`` except for the first occurrence.
|
- ``last`` : Mark duplicates as ``True`` except for the last occurrence.
|
- False : Mark all duplicates as ``True``.
|
|
Returns
|
-------
|
Series
|
Boolean series for each duplicated rows.
|
|
See Also
|
--------
|
Index.duplicated : Equivalent method on index.
|
Series.duplicated : Equivalent method on Series.
|
Series.drop_duplicates : Remove duplicate values from Series.
|
DataFrame.drop_duplicates : Remove duplicate values from DataFrame.
|
|
Examples
|
--------
|
Consider dataset containing ramen rating.
|
|
>>> df = pd.DataFrame({
|
... 'brand': ['Yum Yum', 'Yum Yum', 'Indomie', 'Indomie', 'Indomie'],
|
... 'style': ['cup', 'cup', 'cup', 'pack', 'pack'],
|
... 'rating': [4, 4, 3.5, 15, 5]
|
... })
|
>>> df
|
brand style rating
|
0 Yum Yum cup 4.0
|
1 Yum Yum cup 4.0
|
2 Indomie cup 3.5
|
3 Indomie pack 15.0
|
4 Indomie pack 5.0
|
|
By default, for each set of duplicated values, the first occurrence
|
is set on False and all others on True.
|
|
>>> df.duplicated()
|
0 False
|
1 True
|
2 False
|
3 False
|
4 False
|
dtype: bool
|
|
By using 'last', the last occurrence of each set of duplicated values
|
is set on False and all others on True.
|
|
>>> df.duplicated(keep='last')
|
0 True
|
1 False
|
2 False
|
3 False
|
4 False
|
dtype: bool
|
|
By setting ``keep`` on False, all duplicates are True.
|
|
>>> df.duplicated(keep=False)
|
0 True
|
1 True
|
2 False
|
3 False
|
4 False
|
dtype: bool
|
|
To find duplicates on specific column(s), use ``subset``.
|
|
>>> df.duplicated(subset=['brand'])
|
0 False
|
1 True
|
2 False
|
3 True
|
4 True
|
dtype: bool
|
rð ztuple[np.ndarray, int]r¹ c s, t j| t d\}}|jdddt|fS )N)Z size_hintÚi8Fr )rm Z factorizerÏ r8 )Úvalsr± rï r¼ r¾ r¿ Úfï s z DataFrame.duplicated.<locals>.fNró r c 3 s | ]\}}| kr|j V qd S r» ©rè )rÐ rÎ r¥ )rá r¾ r¿ r s z'DataFrame.duplicated.<locals>.<genexpr>F)ÚsortZxnullr r r )rí rÁ ré r³ rÚ ÚiterablerÕ r r= r r r× r° r rÏ r> r rÎ r; rT rã rE r r´ rF )
|
r½ rá r. rð Údiffrf rï r± rï Úidsr¾ )r½ rá r¿ r s> ^ ÿþýü
|
úzDataFrame.duplicated)r° Ú ascendingr± r1 Ú na_positionrâ r' r> )Úbyr° r± r1 r÷ râ r' rº c C s d S r» r¾ © r½ rø r° rö r± r1 r÷ râ r' r¾ r¾ r¿ Ú sort_values s zDataFrame.sort_values)r° rö r1 r÷ râ r' c C s d S r» r¾ rù r¾ r¾ r¿ rú / s Z quicksortÚlastz$bool | list[bool] | tuple[bool, ...]) rø r° rö r± r1 r÷ râ r' rº c sÞ t |d} ¡ t|}t|ts,|g}t|rbt|t|krbtdt| dt| dt|dkr° fdd|D } |d k rdd t| |D } t | |||d }
|
nzt|r|d
|
}j
|
| d } |d k rät | |d } t|t tfrú|d
|
}t | ||||d }
|
n |r ¡S jd dS t|
|
t|
|
rzj| oLt d} |rftt| | _|rv | ¡S | S jj|
|
¡dd} |r²| ¡tt|
|
¡ | ¡} |rÌ | ¡S | jddS d S )Nr± zLength of ascending (z) != length of by (ú)ró c s g | ]}j | d qS )r= ©Ú_get_label_or_level_valuesr¡ ©r° r½ r¾ r¿ rÔ ^ s z)DataFrame.sort_values.<locals>.<listcomp>c S s g | ]\}}t ||d qS )rr r )rÐ rB rÎ r¾ r¾ r¿ rÔ d s ÿ)Zordersr÷ r' r r= rr )r1 rö r÷ r' rÅ F)r° Úverifyrú r )rM rÄ rL rÕ rã rg rÏ rØ rE r rþ r r= r r rÄ r r r
r´ r¸ r9 Z_get_block_manager_axisr° rÀ rF )r½ rø r° rö r± r1 r÷ râ r' rx r+ rB rf Únew_datar¾ rÿ r¿ rú ? sz
|
|
|
ÿÿ þ ÿ
|
ÿ
|
|
ÿ
|
ÿ
|
|
)r° r rö r1 r÷ Úsort_remainingrâ r' zbool | Sequence[bool]r9 r3 r/ )
|
r° r rö r± r1 r÷ r râ r' rº c
|
C s d S r» r¾ ©
|
r½ r° r rö r± r1 r÷ r râ r' r¾ r¾ r¿ Ú
|
sort_index s zDataFrame.sort_index© r° r rö r± r1 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 c
|
s t j||||||||| d S )u
|
Sort object by labels (along an axis).
|
|
Returns a new DataFrame sorted by label if `inplace` argument is
|
``False``, otherwise updates the original DataFrame and returns None.
|
|
Parameters
|
----------
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
The axis along which to sort. The value 0 identifies the rows,
|
and 1 identifies the columns.
|
level : int or level name or list of ints or list of level names
|
If not None, sort on values in specified index level(s).
|
ascending : bool or list-like of bools, default True
|
Sort ascending vs. descending. When the index is a MultiIndex the
|
sort direction can be controlled for each level individually.
|
inplace : bool, default False
|
Whether to modify the DataFrame rather than creating a new one.
|
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.
|
Not implemented for MultiIndex.
|
sort_remaining : bool, default True
|
If True and sorting by level and index is multilevel, sort by other
|
levels too (in order) after sorting by specified level.
|
ignore_index : bool, default False
|
If True, the resulting axis will be labeled 0, 1, â¦, n - 1.
|
key : callable, optional
|
If not None, apply the key function to the index 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 an
|
``Index`` and return an ``Index`` of the same shape. For MultiIndex
|
inputs, the key is applied *per level*.
|
|
.. versionadded:: 1.1.0
|
|
Returns
|
-------
|
DataFrame or None
|
The original DataFrame sorted by the labels or None if ``inplace=True``.
|
|
See Also
|
--------
|
Series.sort_index : Sort Series by the index.
|
DataFrame.sort_values : Sort DataFrame by the value.
|
Series.sort_values : Sort Series by the value.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([1, 2, 3, 4, 5], index=[100, 29, 234, 1, 150],
|
... columns=['A'])
|
>>> df.sort_index()
|
A
|
1 4
|
29 2
|
100 1
|
150 5
|
234 3
|
|
By default, it sorts in ascending order, to sort in descending order,
|
use ``ascending=False``
|
|
>>> df.sort_index(ascending=False)
|
A
|
234 3
|
150 5
|
100 1
|
29 2
|
1 4
|
|
A key function can be specified which is applied to the index before
|
sorting. For a ``MultiIndex`` this is applied to each level separately.
|
|
>>> df = pd.DataFrame({"a": [1, 2, 3, 4]}, index=['A', 'b', 'C', 'd'])
|
>>> df.sort_index(key=lambda x: x.str.lower())
|
a
|
A 1
|
b 2
|
C 3
|
d 4
|
r )r« r r r r¾ r¿ r Í s c÷)rá Ú normalizerò rö rä rº c C s |dkr| j ¡ }|rdnd}| j||dj ¡ }||_|rH|j|d}|rX|| ¡ }t|rt |dkrt
|
j |j g|j jgd|_ |S )uS
|
Return a Series containing counts of unique rows in the DataFrame.
|
|
.. versionadded:: 1.1.0
|
|
Parameters
|
----------
|
subset : label or list of labels, optional
|
Columns to use when counting unique combinations.
|
normalize : bool, default False
|
Return proportions rather than frequencies.
|
sort : bool, default True
|
Sort by frequencies.
|
ascending : bool, default False
|
Sort in ascending order.
|
dropna : bool, default True
|
Donât include counts of rows that contain NA values.
|
|
.. versionadded:: 1.3.0
|
|
Returns
|
-------
|
Series
|
|
See Also
|
--------
|
Series.value_counts: Equivalent method on Series.
|
|
Notes
|
-----
|
The returned Series will have a MultiIndex with one level per input
|
column but an Index (non-multi) for a single label. By default, rows
|
that contain any NA values are omitted from the result. By default,
|
the resulting Series will be in descending order so that the first
|
element is the most frequently-occurring row.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'num_legs': [2, 4, 4, 6],
|
... 'num_wings': [2, 0, 0, 0]},
|
... index=['falcon', 'dog', 'cat', 'ant'])
|
>>> df
|
num_legs num_wings
|
falcon 2 2
|
dog 4 0
|
cat 4 0
|
ant 6 0
|
|
>>> df.value_counts()
|
num_legs num_wings
|
4 0 2
|
2 2 1
|
6 0 1
|
Name: count, dtype: int64
|
|
>>> df.value_counts(sort=False)
|
num_legs num_wings
|
2 2 1
|
4 0 2
|
6 0 1
|
Name: count, dtype: int64
|
|
>>> df.value_counts(ascending=True)
|
num_legs num_wings
|
2 2 1
|
6 0 1
|
4 0 2
|
Name: count, dtype: int64
|
|
>>> df.value_counts(normalize=True)
|
num_legs num_wings
|
4 0 0.50
|
2 2 0.25
|
6 0 0.25
|
Name: proportion, dtype: float64
|
|
With `dropna` set to `False` we can also count rows with NA values.
|
|
>>> df = pd.DataFrame({'first_name': ['John', 'Anne', 'John', 'Beth'],
|
... 'middle_name': ['Smith', pd.NA, pd.NA, 'Louise']})
|
>>> df
|
first_name middle_name
|
0 John Smith
|
1 Anne <NA>
|
2 John <NA>
|
3 Beth Louise
|
|
>>> df.value_counts()
|
first_name middle_name
|
Beth Louise 1
|
John Smith 1
|
Name: count, dtype: int64
|
|
>>> df.value_counts(dropna=False)
|
first_name middle_name
|
Anne NaN 1
|
Beth Louise 1
|
John Smith 1
|
NaN 1
|
Name: count, dtype: int64
|
|
>>> df.value_counts("first_name")
|
first_name
|
John 2
|
Anne 1
|
Beth 1
|
Name: count, dtype: int64
|
NZ
|
proportionrè ©rä )rö ró rq ) r³ rç ÚgroupbyZgrouperrj rÎ rú Úsumre rÏ r Z from_arraysr´ )r½ rá r rò rö rä rÎ Úcountsr¾ r¾ r¿ Ú value_counts< s t
|
ÿzDataFrame.value_counts)rÎ r³ r. rº c C s t j| |||d ¡ S )a^
|
Return the first `n` rows ordered by `columns` in descending order.
|
|
Return the first `n` rows with the largest values in `columns`, in
|
descending order. The columns that are not specified are returned as
|
well, but not used for ordering.
|
|
This method is equivalent to
|
``df.sort_values(columns, ascending=False).head(n)``, but more
|
performant.
|
|
Parameters
|
----------
|
n : int
|
Number of rows to return.
|
columns : label or list of labels
|
Column label(s) to order by.
|
keep : {'first', 'last', 'all'}, default 'first'
|
Where there are duplicate values:
|
|
- ``first`` : prioritize the first occurrence(s)
|
- ``last`` : prioritize the last occurrence(s)
|
- ``all`` : do not drop any duplicates, even it means
|
selecting more than `n` items.
|
|
Returns
|
-------
|
DataFrame
|
The first `n` rows ordered by the given columns in descending
|
order.
|
|
See Also
|
--------
|
DataFrame.nsmallest : Return the first `n` rows ordered by `columns` in
|
ascending order.
|
DataFrame.sort_values : Sort DataFrame by the values.
|
DataFrame.head : Return the first `n` rows without re-ordering.
|
|
Notes
|
-----
|
This function cannot be used with all column types. For example, when
|
specifying columns with `object` or `category` dtypes, ``TypeError`` is
|
raised.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'population': [59000000, 65000000, 434000,
|
... 434000, 434000, 337000, 11300,
|
... 11300, 11300],
|
... 'GDP': [1937894, 2583560 , 12011, 4520, 12128,
|
... 17036, 182, 38, 311],
|
... 'alpha-2': ["IT", "FR", "MT", "MV", "BN",
|
... "IS", "NR", "TV", "AI"]},
|
... index=["Italy", "France", "Malta",
|
... "Maldives", "Brunei", "Iceland",
|
... "Nauru", "Tuvalu", "Anguilla"])
|
>>> df
|
population GDP alpha-2
|
Italy 59000000 1937894 IT
|
France 65000000 2583560 FR
|
Malta 434000 12011 MT
|
Maldives 434000 4520 MV
|
Brunei 434000 12128 BN
|
Iceland 337000 17036 IS
|
Nauru 11300 182 NR
|
Tuvalu 11300 38 TV
|
Anguilla 11300 311 AI
|
|
In the following example, we will use ``nlargest`` to select the three
|
rows having the largest values in column "population".
|
|
>>> df.nlargest(3, 'population')
|
population GDP alpha-2
|
France 65000000 2583560 FR
|
Italy 59000000 1937894 IT
|
Malta 434000 12011 MT
|
|
When using ``keep='last'``, ties are resolved in reverse order:
|
|
>>> df.nlargest(3, 'population', keep='last')
|
population GDP alpha-2
|
France 65000000 2583560 FR
|
Italy 59000000 1937894 IT
|
Brunei 434000 12128 BN
|
|
When using ``keep='all'``, all duplicate items are maintained:
|
|
>>> df.nlargest(3, 'population', keep='all')
|
population GDP alpha-2
|
France 65000000 2583560 FR
|
Italy 59000000 1937894 IT
|
Malta 434000 12011 MT
|
Maldives 434000 4520 MV
|
Brunei 434000 12128 BN
|
|
To order by the largest values in column "population" and then "GDP",
|
we can specify multiple columns like in the next example.
|
|
>>> df.nlargest(3, ['population', 'GDP'])
|
population GDP alpha-2
|
France 65000000 2583560 FR
|
Italy 59000000 1937894 IT
|
Brunei 434000 12128 BN
|
©rÎ r. r³ )r Ú SelectNFrameÚnlargest©r½ rÎ r³ r. r¾ r¾ r¿ r Ä s izDataFrame.nlargestc C s t j| |||d ¡ S )aà
|
Return the first `n` rows ordered by `columns` in ascending order.
|
|
Return the first `n` rows with the smallest values in `columns`, in
|
ascending order. The columns that are not specified are returned as
|
well, but not used for ordering.
|
|
This method is equivalent to
|
``df.sort_values(columns, ascending=True).head(n)``, but more
|
performant.
|
|
Parameters
|
----------
|
n : int
|
Number of items to retrieve.
|
columns : list or str
|
Column name or names to order by.
|
keep : {'first', 'last', 'all'}, default 'first'
|
Where there are duplicate values:
|
|
- ``first`` : take the first occurrence.
|
- ``last`` : take the last occurrence.
|
- ``all`` : do not drop any duplicates, even it means
|
selecting more than `n` items.
|
|
Returns
|
-------
|
DataFrame
|
|
See Also
|
--------
|
DataFrame.nlargest : Return the first `n` rows ordered by `columns` in
|
descending order.
|
DataFrame.sort_values : Sort DataFrame by the values.
|
DataFrame.head : Return the first `n` rows without re-ordering.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'population': [59000000, 65000000, 434000,
|
... 434000, 434000, 337000, 337000,
|
... 11300, 11300],
|
... 'GDP': [1937894, 2583560 , 12011, 4520, 12128,
|
... 17036, 182, 38, 311],
|
... 'alpha-2': ["IT", "FR", "MT", "MV", "BN",
|
... "IS", "NR", "TV", "AI"]},
|
... index=["Italy", "France", "Malta",
|
... "Maldives", "Brunei", "Iceland",
|
... "Nauru", "Tuvalu", "Anguilla"])
|
>>> df
|
population GDP alpha-2
|
Italy 59000000 1937894 IT
|
France 65000000 2583560 FR
|
Malta 434000 12011 MT
|
Maldives 434000 4520 MV
|
Brunei 434000 12128 BN
|
Iceland 337000 17036 IS
|
Nauru 337000 182 NR
|
Tuvalu 11300 38 TV
|
Anguilla 11300 311 AI
|
|
In the following example, we will use ``nsmallest`` to select the
|
three rows having the smallest values in column "population".
|
|
>>> df.nsmallest(3, 'population')
|
population GDP alpha-2
|
Tuvalu 11300 38 TV
|
Anguilla 11300 311 AI
|
Iceland 337000 17036 IS
|
|
When using ``keep='last'``, ties are resolved in reverse order:
|
|
>>> df.nsmallest(3, 'population', keep='last')
|
population GDP alpha-2
|
Anguilla 11300 311 AI
|
Tuvalu 11300 38 TV
|
Nauru 337000 182 NR
|
|
When using ``keep='all'``, all duplicate items are maintained:
|
|
>>> df.nsmallest(3, 'population', keep='all')
|
population GDP alpha-2
|
Tuvalu 11300 38 TV
|
Anguilla 11300 311 AI
|
Iceland 337000 17036 IS
|
Nauru 337000 182 NR
|
|
To order by the smallest values in column "population" and then "GDP", we can
|
specify multiple columns like in the next example.
|
|
>>> df.nsmallest(3, ['population', 'GDP'])
|
population GDP alpha-2
|
Tuvalu 11300 38 TV
|
Anguilla 11300 311 AI
|
Nauru 337000 182 NR
|
r )r r Ú nsmallestr r¾ r¾ r¿ r / s `zDataFrame.nsmallestzaxis : {0 or 'index', 1 or 'columns'}, default 0
|
The axis to swap levels on. 0 or 'index' for row-wise, 1 or
|
'columns' for column-wise.at Examples
|
--------
|
>>> df = pd.DataFrame(
|
... {"Grade": ["A", "B", "A", "C"]},
|
... index=[
|
... ["Final exam", "Final exam", "Coursework", "Coursework"],
|
... ["History", "Geography", "History", "Geography"],
|
... ["January", "February", "March", "April"],
|
... ],
|
... )
|
>>> df
|
Grade
|
Final exam History January A
|
Geography February B
|
Coursework History March A
|
Geography April C
|
|
In the following example, we will swap the levels of the indices.
|
Here, we will swap the levels column-wise, but levels can be swapped row-wise
|
in a similar manner. Note that column-wise is the default behaviour.
|
By not supplying any arguments for i and j, we swap the last and second to
|
last indices.
|
|
>>> df.swaplevel()
|
Grade
|
Final exam January History A
|
February Geography B
|
Coursework March History A
|
April Geography C
|
|
By supplying one argument, we can choose which index to swap the last
|
index with. We can for example swap the first index with the last one as
|
follows.
|
|
>>> df.swaplevel(0)
|
Grade
|
January History Final exam A
|
February Geography Final exam B
|
March History Coursework A
|
April Geography Coursework C
|
|
We can also define explicitly which indices we want to swap by supplying values
|
for both i and j. Here, we for example swap the first and second indices.
|
|
>>> df.swaplevel(0, 1)
|
Grade
|
History Final exam January A
|
Geography Final exam February B
|
History Coursework March A
|
Geography Coursework April C)r¯ Ú extra_paramsrÞ éþÿÿÿrû )rC Újr° rº c C s| | j d d}| |¡}t| |¡ts.td|dkrXt|jtsFt|j ||¡|_n t|j tsht|j ||¡|_ |S )NrÅ z,Can only swap levels on a hierarchical axis.r )
|
rÄ rÄ rÕ ræ r rÞ r´ ri Ú swaplevelr³ )r½ rC r r° rf r¾ r¾ r¿ r s ?
|
zDataFrame.swaplevelzSequence[int | str])Úorderr° rº c C sx | |¡}t| |¡ts"td| jdd}|dkrVt|jtsFt|j |¡|_n t|j tsft|j |¡|_ |S )a[
|
Rearrange index levels using input order. May not drop or duplicate levels.
|
|
Parameters
|
----------
|
order : list of int or list of str
|
List representing new level order. Reference level by number
|
(position) or by key (label).
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
Where to reorder levels.
|
|
Returns
|
-------
|
DataFrame
|
|
Examples
|
--------
|
>>> data = {
|
... "class": ["Mammals", "Mammals", "Reptiles"],
|
... "diet": ["Omnivore", "Carnivore", "Carnivore"],
|
... "species": ["Humans", "Dogs", "Snakes"],
|
... }
|
>>> df = pd.DataFrame(data, columns=["class", "diet", "species"])
|
>>> df = df.set_index(["class", "diet"])
|
>>> df
|
species
|
class diet
|
Mammals Omnivore Humans
|
Carnivore Dogs
|
Reptiles Carnivore Snakes
|
|
Let's reorder the levels of the index:
|
|
>>> df.reorder_levels(["diet", "class"])
|
species
|
diet class
|
Omnivore Mammals Humans
|
Carnivore Mammals Dogs
|
Reptiles Snakes
|
z/Can only reorder levels on a hierarchical axis.NrÅ r )
|
rÄ rÕ ræ r rÞ rÄ r´ ri Úreorder_levelsr³ )r½ r r° rf r¾ r¾ r¿ r ß s )
|
zDataFrame.reorder_levelsc C s6 d}t j| ||dd d\} }| j|||d}| |¡S )Nró F©Zflexr r= )rp Úalign_method_FRAMEÚ_dispatch_frame_opÚ_construct_result©r½ rZ Úopr° r r¾ r¾ r¿ Ú _cmp_method s zDataFrame._cmp_methodc C sl t | ||dd d ¡r"t | ||¡S d}t || j| f¡}t j| ||dd d\} }| j|||d}| |¡S )Nró Tr r= )rp Zshould_reindex_frame_opZ frame_arith_method_with_reindexZmaybe_prepare_scalar_for_oprï r r r r r¾ r¾ r¿ Ú _arith_method" s zDataFrame._arith_methodr zAxisInt | None)rÛ r° c s t |¡ t ¡tsNtjdd | jj d}W 5 Q R X | |¡S t
|
t r®| j j ¡sjt| j j¡s|ttjdd | j j ¡}W 5 Q R X | |¡S t
|
tr"|dkr"j | j¡sÖtjt
|
tjrìttjdd" fddt| ¡ D }W 5 Q R X n`t
|
trzj | j ¡sBtjtjdd fdd| ¡ D }W 5 Q R X ntt| j|| j| j dd S )
|
af
|
Evaluate the frame operation func(left, right) by evaluating
|
column-by-column, dispatching to the Series implementation.
|
|
Parameters
|
----------
|
right : scalar, Series, or DataFrame
|
func : arithmetic or comparison operator
|
axis : {None, 0, 1}
|
|
Returns
|
-------
|
DataFrame
|
r ©rH )re ró c s g | ]\}} ||qS r¾ r¾ )rÐ Ú_leftZ_right)Úarray_opr¾ r¿ rÔ g s ÿz0DataFrame._dispatch_frame_op.<locals>.<listcomp>c s g | ]} |qS r¾ r¾ )rÐ rd ©r! re r¾ r¿ rÔ q s F)r )rp Z get_array_opr r2 re rÚ Úerrstater¸ ÚapplyrÀ rÕ r© r´ rD ri r³ Zoperate_blockwiser rþ rÛ rE r& rh rc rà )r½ re rÛ r° Zbmrç r¾ r" r¿ r 0 sF
|
|
|
|
ø
|
|
|
þ $ ÿz DataFrame._dispatch_frame_op)rZ c s, d kr}n fdd}| ||¡}|S )Nc s t | | ¡\} }| |S r» )rp Z
|
fill_binop)rd re ©ru rÛ r¾ r¿ Ú _arith_op
s z+DataFrame._combine_frame.<locals>._arith_op)r )r½ rZ rÛ ru r& r r¾ r% r¿ Ú_combine_frame{ s
|
zDataFrame._combine_framec C s( | j |dd | ¡}| j|_| j|_|S )zÊ
|
Wrap the result of an arithmetic, comparison, or logical operation.
|
|
Parameters
|
----------
|
result : DataFrame
|
|
Returns
|
-------
|
DataFrame
|
Fr )rÀ rF r³ r´ )r½ rf Úoutr¾ r¾ r¿ r s zDataFrame._construct_resultztuple[DataFrame, DataFrame]c C s | | }| || }||fS r» r¾ ©r½ rZ ÚdivÚmodr¾ r¾ r¿ Ú
|
__divmod__¢ s zDataFrame.__divmod__c C s || }||| }||fS r» r¾ r) r¾ r¾ r¿ Ú __rdivmod__¨ s zDataFrame.__rdivmod__Úcomparea´
|
Returns
|
-------
|
DataFrame
|
DataFrame that shows the differences stacked side by side.
|
|
The resulting index will be a MultiIndex with 'self' and 'other'
|
stacked alternately at the inner level.
|
|
Raises
|
------
|
ValueError
|
When the two DataFrames don't have identical labels or shape.
|
|
See Also
|
--------
|
Series.compare : Compare with another Series and show differences.
|
DataFrame.equals : Test whether two objects contain the same elements.
|
|
Notes
|
-----
|
Matching NaNs will not appear as a difference.
|
|
Can only compare identically-labeled
|
(i.e. same shape, identical row and column labels) DataFrames
|
|
Examples
|
--------
|
>>> df = pd.DataFrame(
|
... {{
|
... "col1": ["a", "a", "b", "b", "a"],
|
... "col2": [1.0, 2.0, 3.0, np.nan, 5.0],
|
... "col3": [1.0, 2.0, 3.0, 4.0, 5.0]
|
... }},
|
... columns=["col1", "col2", "col3"],
|
... )
|
>>> df
|
col1 col2 col3
|
0 a 1.0 1.0
|
1 a 2.0 2.0
|
2 b 3.0 3.0
|
3 b NaN 4.0
|
4 a 5.0 5.0
|
|
>>> df2 = df.copy()
|
>>> df2.loc[0, 'col1'] = 'c'
|
>>> df2.loc[2, 'col3'] = 4.0
|
>>> df2
|
col1 col2 col3
|
0 c 1.0 1.0
|
1 a 2.0 2.0
|
2 b 3.0 4.0
|
3 b NaN 4.0
|
4 a 5.0 5.0
|
|
Align the differences on columns
|
|
>>> df.compare(df2)
|
col1 col3
|
self other self other
|
0 a c NaN NaN
|
2 NaN NaN 3.0 4.0
|
|
Assign result_names
|
|
>>> df.compare(df2, result_names=("left", "right"))
|
col1 col3
|
left right left right
|
0 a c NaN NaN
|
2 NaN NaN 3.0 4.0
|
|
Stack the differences on rows
|
|
>>> df.compare(df2, align_axis=0)
|
col1 col3
|
0 self a NaN
|
other c NaN
|
2 self NaN 3.0
|
other NaN 4.0
|
|
Keep the equal values
|
|
>>> df.compare(df2, keep_equal=True)
|
col1 col3
|
self other self other
|
0 a c 1.0 1.0
|
2 b b 3.0 4.0
|
|
Keep all original rows and columns
|
|
>>> df.compare(df2, keep_shape=True)
|
col1 col2 col3
|
self other self other self other
|
0 a c NaN NaN NaN NaN
|
1 NaN NaN NaN NaN NaN NaN
|
2 NaN NaN NaN NaN 3.0 4.0
|
3 NaN NaN NaN NaN NaN NaN
|
4 NaN NaN NaN NaN NaN NaN
|
|
Keep all original rows and columns and also all original values
|
|
>>> df.compare(df2, keep_shape=True, keep_equal=True)
|
col1 col2 col3
|
self other self other self other
|
0 a c 1.0 1.0 1.0 1.0
|
1 a a 2.0 2.0 2.0 2.0
|
2 b b 3.0 3.0 3.0 4.0
|
3 b b NaN NaN 4.0 4.0
|
4 a a 5.0 5.0 5.0 5.0
|
r[ r; )rZ Ú
|
align_axisÚ
|
keep_shapeÚ
|
keep_equalÚ result_namesrº c s t j|||||dS )N)rZ r/ r0 r1 r2 )r« r. )r½ rZ r/ r0 r1 r2 r r¾ r¿ r. ± s zûzDataFrame.comparez-Callable[[Series, Series], Series | Hashable])rZ rÛ Ú overwriterº c C s t |j}| j|dd\}}|j}|jrBt |t | jkrB| ¡ S | jr\t ||kr\| ¡ S |j |j¡}|dk } i }
|
|D ] } || } || } | j}| j}t| }t| }|sÊ| ¡ rÊ|| ¡ |
|
| < qz| rî| ¡ } | ¡ } || |< || |< | | jkr*|}z| j
|
|dd} W n t k
|
r& Y nX n(t ||g}| j
|
|dd} | j
|
|dd} || | }t |tjrtt||}||
|
| < qz| j|
|
||dS )a
|
Perform column-wise combine with another DataFrame.
|
|
Combines a DataFrame with `other` DataFrame using `func`
|
to element-wise combine columns. The row and column indexes of the
|
resulting DataFrame will be the union of the two.
|
|
Parameters
|
----------
|
other : DataFrame
|
The DataFrame to merge column-wise.
|
func : function
|
Function that takes two series as inputs and return a Series or a
|
scalar. Used to merge the two dataframes column by columns.
|
fill_value : scalar value, default None
|
The value to fill NaNs with prior to passing any column to the
|
merge func.
|
overwrite : bool, default True
|
If True, columns in `self` that do not exist in `other` will be
|
overwritten with NaNs.
|
|
Returns
|
-------
|
DataFrame
|
Combination of the provided DataFrames.
|
|
See Also
|
--------
|
DataFrame.combine_first : Combine two DataFrame objects and default to
|
non-null values in frame calling the method.
|
|
Examples
|
--------
|
Combine using a simple function that chooses the smaller column.
|
|
>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [4, 4]})
|
>>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
|
>>> take_smaller = lambda s1, s2: s1 if s1.sum() < s2.sum() else s2
|
>>> df1.combine(df2, take_smaller)
|
A B
|
0 0 3
|
1 0 3
|
|
Example using a true element-wise combine function.
|
|
>>> df1 = pd.DataFrame({'A': [5, 0], 'B': [2, 4]})
|
>>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
|
>>> df1.combine(df2, np.minimum)
|
A B
|
0 1 2
|
1 0 3
|
|
Using `fill_value` fills Nones prior to passing the column to the
|
merge function.
|
|
>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [None, 4]})
|
>>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
|
>>> df1.combine(df2, take_smaller, fill_value=-5)
|
A B
|
0 0 -5.0
|
1 0 4.0
|
|
However, if the same element in both dataframes is None, that None
|
is preserved
|
|
>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [None, 4]})
|
>>> df2 = pd.DataFrame({'A': [1, 1], 'B': [None, 3]})
|
>>> df1.combine(df2, take_smaller, fill_value=-5)
|
A B
|
0 0 -5.0
|
1 0 3.0
|
|
Example that demonstrates the use of `overwrite` and behavior when
|
the axis differ between the dataframes.
|
|
>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [4, 4]})
|
>>> df2 = pd.DataFrame({'B': [3, 3], 'C': [-10, 1], }, index=[1, 2])
|
>>> df1.combine(df2, take_smaller)
|
A B C
|
0 NaN NaN NaN
|
1 NaN 3.0 -10.0
|
2 NaN 3.0 1.0
|
|
>>> df1.combine(df2, take_smaller, overwrite=False)
|
A B C
|
0 0.0 NaN NaN
|
1 0.0 3.0 -10.0
|
2 NaN 3.0 1.0
|
|
Demonstrating the preference of the passed in dataframe.
|
|
>>> df2 = pd.DataFrame({'B': [3, 3], 'C': [1, 1], }, index=[1, 2])
|
>>> df2.combine(df1, take_smaller)
|
A B C
|
0 0.0 NaN NaN
|
1 0.0 3.0 NaN
|
2 NaN 3.0 NaN
|
|
>>> df2.combine(df1, take_smaller, overwrite=False)
|
A B C
|
0 0.0 NaN NaN
|
1 0.0 3.0 1.0
|
2 NaN 3.0 1.0
|
Fr NrÊ )rÏ r´ r¬ rí rÄ r³ ra rà rk rH r8 rØ rS rÕ rÚ rW rÀ )r½ rZ rÛ ru r3 Z other_idxlenÚthisr¥ rL Zdo_fillrf r¥ rO Z other_seriesZ
|
this_dtypeZ other_dtypeZ this_maskZ
|
other_maskZ new_dtyperñ r¾ r¾ r¿ Úcombine3 sT o
|
|
|
ÿ
|
zDataFrame.combinec s\ ddl m fdd}j|dd fddj j¡D }|rX |¡ S ) a<
|
Update null elements with value in the same location in `other`.
|
|
Combine two DataFrame objects by filling null values in one DataFrame
|
with non-null values from other DataFrame. The row and column indexes
|
of the resulting DataFrame will be the union of the two. The resulting
|
dataframe contains the 'first' dataframe values and overrides the
|
second one values where both first.loc[index, col] and
|
second.loc[index, col] are not missing values, upon calling
|
first.combine_first(second).
|
|
Parameters
|
----------
|
other : DataFrame
|
Provided DataFrame to use to fill null values.
|
|
Returns
|
-------
|
DataFrame
|
The result of combining the provided DataFrame with the other object.
|
|
See Also
|
--------
|
DataFrame.combine : Perform series-wise operation on two DataFrames
|
using a given function.
|
|
Examples
|
--------
|
>>> df1 = pd.DataFrame({'A': [None, 0], 'B': [None, 4]})
|
>>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
|
>>> df1.combine_first(df2)
|
A B
|
0 1.0 3.0
|
1 0.0 4.0
|
|
Null values still persist if the location of that null value
|
does not exist in `other`
|
|
>>> df1 = pd.DataFrame({'A': [None, 0], 'B': [4, None]})
|
>>> df2 = pd.DataFrame({'B': [3, 3], 'C': [1, 1]}, index=[1, 2])
|
>>> df1.combine_first(df2)
|
A B C
|
0 NaN 4.0 NaN
|
1 0.0 3.0 1.0
|
2 NaN 3.0 1.0
|
r ©Ú expressionsc sB t t| }t | dd}t |dd}|jjkr4|S |||¡S )NT)Z extract_numpy)r} rk rÎ r³ r: )r¢ Úyrë Zx_valuesZy_values)r7 r½ r¾ r¿ Úcombiner s z)DataFrame.combine_first.<locals>.combinerF)r3 c s< i | ]4}t j| j| s|tj| j| gqS r¾ )r] r rS r¤ )ÚcombinedrZ r½ r¾ r¿ r % s þ z+DataFrame.combine_first.<locals>.<dictcomp>)Úpandas.core.computationr7 r5 r³ Ú intersectionr8 )r½ rZ r9 r r¾ )r: r7 rZ r½ r¿ Ú combine_firstå s / þ
|
zDataFrame.combine_firstrd )r¨ r3 r rº c
|
C s ddl m} |dkr td|dkr,tdt|ts>t|}| | j¡}| j |j¡D ]´}| | j
|
}|| j
|
} |dk r¤t j dd || t | B }
|
W 5 Q R X nB|d
|
krÐt| } t|} t| | @ rÐtd |rÞt | }
|
nt|}
|
|
|
¡ rðqX| |
|
|| ¡| jdd
|f< qXdS ) a
|
Modify in place using non-NA values from another DataFrame.
|
|
Aligns on indices. There is no return value.
|
|
Parameters
|
----------
|
other : DataFrame, or object coercible into a DataFrame
|
Should have at least one matching index/column label
|
with the original DataFrame. If a Series is passed,
|
its name attribute must be set, and that will be
|
used as the column name to align with the original DataFrame.
|
join : {'left'}, default 'left'
|
Only left join is implemented, keeping the index and columns of the
|
original object.
|
overwrite : bool, default True
|
How to handle non-NA values for overlapping keys:
|
|
* True: overwrite original DataFrame's values
|
with values from `other`.
|
* False: only update values that are NA in
|
the original DataFrame.
|
|
filter_func : callable(1d-array) -> bool 1d-array, optional
|
Can choose to replace values other than NA. Return True for values
|
that should be updated.
|
errors : {'raise', 'ignore'}, default 'ignore'
|
If 'raise', will raise a ValueError if the DataFrame and `other`
|
both contain non-NA data in the same place.
|
|
Returns
|
-------
|
None
|
This method directly changes calling object.
|
|
Raises
|
------
|
ValueError
|
* When `errors='raise'` and there's overlapping non-NA data.
|
* When `errors` is not either `'ignore'` or `'raise'`
|
NotImplementedError
|
* If `join != 'left'`
|
|
See Also
|
--------
|
dict.update : Similar method for dictionaries.
|
DataFrame.merge : For column(s)-on-column(s) operations.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'A': [1, 2, 3],
|
... 'B': [400, 500, 600]})
|
>>> new_df = pd.DataFrame({'B': [4, 5, 6],
|
... 'C': [7, 8, 9]})
|
>>> df.update(new_df)
|
>>> df
|
A B
|
0 1 4
|
1 2 5
|
2 3 6
|
|
The DataFrame's length does not increase as a result of the update,
|
only values at matching index/column labels are updated.
|
|
>>> df = pd.DataFrame({'A': ['a', 'b', 'c'],
|
... 'B': ['x', 'y', 'z']})
|
>>> new_df = pd.DataFrame({'B': ['d', 'e', 'f', 'g', 'h', 'i']})
|
>>> df.update(new_df)
|
>>> df
|
A B
|
0 a d
|
1 b e
|
2 c f
|
|
For Series, its name attribute must be set.
|
|
>>> df = pd.DataFrame({'A': ['a', 'b', 'c'],
|
... 'B': ['x', 'y', 'z']})
|
>>> new_column = pd.Series(['d', 'e'], name='B', index=[0, 2])
|
>>> df.update(new_column)
|
>>> df
|
A B
|
0 a d
|
1 b y
|
2 c e
|
>>> df = pd.DataFrame({'A': ['a', 'b', 'c'],
|
... 'B': ['x', 'y', 'z']})
|
>>> new_df = pd.DataFrame({'B': ['d', 'e']}, index=[1, 2])
|
>>> df.update(new_df)
|
>>> df
|
A B
|
0 a x
|
1 b d
|
2 c e
|
|
If `other` contains NaNs the corresponding values are not updated
|
in the original dataframe.
|
|
>>> df = pd.DataFrame({'A': [1, 2, 3],
|
... 'B': [400, 500, 600]})
|
>>> new_df = pd.DataFrame({'B': [4, np.nan, 6]})
|
>>> df.update(new_df)
|
>>> df
|
A B
|
0 1 4
|
1 2 500
|
2 3 6
|
r r6 rd zOnly left join is supported)r r³ z7The parameter errors must be either 'ignore' or 'raise'Nr r r³ zData overlaps.)r; r7 rh rØ rÕ r© rb r´ r³ r< rþ rÚ r# rk rl r² rH r: rK ) r½ rZ r¨ r3 Z filter_funcr r7 r¥ r4 Úthatrë Z mask_thisZ mask_thatr¾ r¾ r¿ r± 0 s2 t
|
|
|
|
zDataFrame.updateaÃ
|
Examples
|
--------
|
>>> df = pd.DataFrame({'Animal': ['Falcon', 'Falcon',
|
... 'Parrot', 'Parrot'],
|
... 'Max Speed': [380., 370., 24., 26.]})
|
>>> df
|
Animal Max Speed
|
0 Falcon 380.0
|
1 Falcon 370.0
|
2 Parrot 24.0
|
3 Parrot 26.0
|
>>> df.groupby(['Animal']).mean()
|
Max Speed
|
Animal
|
Falcon 375.0
|
Parrot 25.0
|
|
**Hierarchical Indexes**
|
|
We can groupby different levels of a hierarchical index
|
using the `level` parameter:
|
|
>>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'],
|
... ['Captive', 'Wild', 'Captive', 'Wild']]
|
>>> index = pd.MultiIndex.from_arrays(arrays, names=('Animal', 'Type'))
|
>>> df = pd.DataFrame({'Max Speed': [390., 350., 30., 20.]},
|
... index=index)
|
>>> df
|
Max Speed
|
Animal Type
|
Falcon Captive 390.0
|
Wild 350.0
|
Parrot Captive 30.0
|
Wild 20.0
|
>>> df.groupby(level=0).mean()
|
Max Speed
|
Animal
|
Falcon 370.0
|
Parrot 25.0
|
>>> df.groupby(level="Type").mean()
|
Max Speed
|
Type
|
Captive 210.0
|
Wild 185.0
|
|
We can also choose to include NA in group keys or not by setting
|
`dropna` parameter, the default setting is `True`.
|
|
>>> l = [[1, 2, 3], [1, None, 4], [2, 1, 3], [1, 2, 2]]
|
>>> df = pd.DataFrame(l, columns=["a", "b", "c"])
|
|
>>> df.groupby(by=["b"]).sum()
|
a c
|
b
|
1.0 2 3
|
2.0 2 5
|
|
>>> df.groupby(by=["b"], dropna=False).sum()
|
a c
|
b
|
1.0 2 3
|
2.0 2 5
|
NaN 1 4
|
|
>>> l = [["a", 12, 12], [None, 12.3, 33.], ["b", 12.3, 123], ["a", 1, 1]]
|
>>> df = pd.DataFrame(l, columns=["a", "b", "c"])
|
|
>>> df.groupby(by="a").sum()
|
b c
|
a
|
a 13.0 13.0
|
b 12.3 123.0
|
|
>>> df.groupby(by="a", dropna=False).sum()
|
b c
|
a
|
a 13.0 13.0
|
b 12.3 123.0
|
NaN 12.3 33.0
|
|
When using ``.apply()``, use ``group_keys`` to include or exclude the group keys.
|
The ``group_keys`` argument defaults to ``True`` (include).
|
|
>>> df = pd.DataFrame({'Animal': ['Falcon', 'Falcon',
|
... 'Parrot', 'Parrot'],
|
... 'Max Speed': [380., 370., 24., 26.]})
|
>>> df.groupby("Animal", group_keys=True).apply(lambda x: x)
|
Animal Max Speed
|
Animal
|
Falcon 0 Falcon 380.0
|
1 Falcon 370.0
|
Parrot 2 Parrot 24.0
|
3 Parrot 26.0
|
|
>>> df.groupby("Animal", group_keys=False).apply(lambda x: x)
|
Animal Max Speed
|
0 Falcon 380.0
|
1 Falcon 370.0
|
2 Parrot 24.0
|
3 Parrot 26.0
|
r zIndexLabel | Noner§ )r° r Úas_indexrò Ú
|
group_keysÚobservedrä rº c
|
C sH ddl m} |d kr$|d kr$td| |¡}| | ||||||||d S )Nr r¦ z*You have to supply one of 'by' and 'level') re rx r° r r? rò r@ rA rä )Úpandas.core.groupby.genericr§ rÞ rÄ )
|
r½ rø r° r r? rò r@ rA rä r§ r¾ r¾ r¿ r Ì s t
|
÷zDataFrame.groupbya
|
Return reshaped DataFrame organized by given index / column values.
|
|
Reshape data (produce a "pivot" table) based on column values. Uses
|
unique values from specified `index` / `columns` to form axes of the
|
resulting DataFrame. This function does not support data
|
aggregation, multiple values will result in a MultiIndex in the
|
columns. See the :ref:`User Guide <reshaping>` for more on reshaping.
|
|
Parameters
|
----------%s
|
columns : str or object or a list of str
|
Column to use to make new frame's columns.
|
|
.. versionchanged:: 1.1.0
|
Also accept list of columns names.
|
|
index : str or object or a list of str, optional
|
Column to use to make new frame's index. If not given, uses existing index.
|
|
.. versionchanged:: 1.1.0
|
Also accept list of index names.
|
|
values : str, object or a list of the previous, optional
|
Column(s) to use for populating new frame's values. If not
|
specified, all remaining columns will be used and the result will
|
have hierarchically indexed columns.
|
|
Returns
|
-------
|
DataFrame
|
Returns reshaped DataFrame.
|
|
Raises
|
------
|
ValueError:
|
When there are any `index`, `columns` combinations with multiple
|
values. `DataFrame.pivot_table` when you need to aggregate.
|
|
See Also
|
--------
|
DataFrame.pivot_table : Generalization of pivot that can handle
|
duplicate values for one index/column pair.
|
DataFrame.unstack : Pivot based on the index values instead of a
|
column.
|
wide_to_long : Wide panel to long format. Less flexible but more
|
user-friendly than melt.
|
|
Notes
|
-----
|
For finer-tuned control, see hierarchical indexing documentation along
|
with the related stack/unstack methods.
|
|
Reference :ref:`the user guide <reshaping.pivot>` for more examples.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'foo': ['one', 'one', 'one', 'two', 'two',
|
... 'two'],
|
... 'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
|
... 'baz': [1, 2, 3, 4, 5, 6],
|
... 'zoo': ['x', 'y', 'z', 'q', 'w', 't']})
|
>>> df
|
foo bar baz zoo
|
0 one A 1 x
|
1 one B 2 y
|
2 one C 3 z
|
3 two A 4 q
|
4 two B 5 w
|
5 two C 6 t
|
|
>>> df.pivot(index='foo', columns='bar', values='baz')
|
bar A B C
|
foo
|
one 1 2 3
|
two 4 5 6
|
|
>>> df.pivot(index='foo', columns='bar')['baz']
|
bar A B C
|
foo
|
one 1 2 3
|
two 4 5 6
|
|
>>> df.pivot(index='foo', columns='bar', values=['baz', 'zoo'])
|
baz zoo
|
bar A B C A B C
|
foo
|
one 1 2 3 x y z
|
two 4 5 6 q w t
|
|
You could also assign a list of column names or a list of index names.
|
|
>>> df = pd.DataFrame({
|
... "lev1": [1, 1, 1, 2, 2, 2],
|
... "lev2": [1, 1, 2, 1, 1, 2],
|
... "lev3": [1, 2, 1, 2, 1, 2],
|
... "lev4": [1, 2, 3, 4, 5, 6],
|
... "values": [0, 1, 2, 3, 4, 5]})
|
>>> df
|
lev1 lev2 lev3 lev4 values
|
0 1 1 1 1 0
|
1 1 1 2 2 1
|
2 1 2 1 3 2
|
3 2 1 2 4 3
|
4 2 1 1 5 4
|
5 2 2 2 6 5
|
|
>>> df.pivot(index="lev1", columns=["lev2", "lev3"], values="values")
|
lev2 1 2
|
lev3 1 2 1 2
|
lev1
|
1 0.0 1.0 2.0 NaN
|
2 4.0 3.0 NaN 5.0
|
|
>>> df.pivot(index=["lev1", "lev2"], columns=["lev3"], values="values")
|
lev3 1 2
|
lev1 lev2
|
1 1 0.0 1.0
|
2 2.0 NaN
|
2 1 4.0 3.0
|
2 NaN 5.0
|
|
A ValueError is raised if there are any duplicates.
|
|
>>> df = pd.DataFrame({"foo": ['one', 'one', 'two', 'two'],
|
... "bar": ['A', 'A', 'B', 'C'],
|
... "baz": [1, 2, 3, 4]})
|
>>> df
|
foo bar baz
|
0 one A 1
|
1 one A 2
|
2 two B 3
|
3 two C 4
|
|
Notice that the first two rows are the same for our `index`
|
and `columns` arguments.
|
|
>>> df.pivot(index='foo', columns='bar', values='baz')
|
Traceback (most recent call last):
|
...
|
ValueError: Index contains duplicate entries, cannot reshape
|
Úpivot)r´ rè c C s ddl m} || |||dS )Nr )rC )r´ r³ rè )Úpandas.core.reshape.pivotrC )r½ r³ r´ rè rC r¾ r¾ r¿ rC ã s zDataFrame.pivota
|
Create a spreadsheet-style pivot table as a DataFrame.
|
|
The levels in the pivot table will be stored in MultiIndex objects
|
(hierarchical indexes) on the index and columns of the result DataFrame.
|
|
Parameters
|
----------%s
|
values : list-like or scalar, optional
|
Column or columns to aggregate.
|
index : column, Grouper, array, or list of the previous
|
If an array is passed, it must be the same length as the data. The
|
list can contain any of the other types (except list).
|
Keys to group by on the pivot table index. If an array is passed,
|
it is being used as the same manner as column values.
|
columns : column, Grouper, array, or list of the previous
|
If an array is passed, it must be the same length as the data. The
|
list can contain any of the other types (except list).
|
Keys to group by on the pivot table column. If an array is passed,
|
it is being used as the same manner as column values.
|
aggfunc : function, list of functions, dict, default numpy.mean
|
If list of functions passed, the resulting pivot table will have
|
hierarchical columns whose top level are the function names
|
(inferred from the function objects themselves)
|
If dict is passed, the key is column to aggregate and value
|
is function or list of functions. If ``margin=True``,
|
aggfunc will be used to calculate the partial aggregates.
|
fill_value : scalar, default None
|
Value to replace missing values with (in the resulting pivot table,
|
after aggregation).
|
margins : bool, default False
|
If ``margins=True``, special ``All`` columns and rows
|
will be added with partial group aggregates across the categories
|
on the rows and columns.
|
dropna : bool, default True
|
Do not include columns whose entries are all NaN. If True,
|
rows with a NaN value in any column will be omitted before
|
computing margins.
|
margins_name : str, default 'All'
|
Name of the row / column that will contain the totals
|
when margins is True.
|
observed : bool, default False
|
This only applies if any of the groupers are Categoricals.
|
If True: only show observed values for categorical groupers.
|
If False: show all values for categorical groupers.
|
|
sort : bool, default True
|
Specifies if the result should be sorted.
|
|
.. versionadded:: 1.3.0
|
|
Returns
|
-------
|
DataFrame
|
An Excel style pivot table.
|
|
See Also
|
--------
|
DataFrame.pivot : Pivot without aggregation that can handle
|
non-numeric data.
|
DataFrame.melt: Unpivot a DataFrame from wide to long format,
|
optionally leaving identifiers set.
|
wide_to_long : Wide panel to long format. Less flexible but more
|
user-friendly than melt.
|
|
Notes
|
-----
|
Reference :ref:`the user guide <reshaping.pivot>` for more examples.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({"A": ["foo", "foo", "foo", "foo", "foo",
|
... "bar", "bar", "bar", "bar"],
|
... "B": ["one", "one", "one", "two", "two",
|
... "one", "one", "two", "two"],
|
... "C": ["small", "large", "large", "small",
|
... "small", "large", "small", "small",
|
... "large"],
|
... "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
|
... "E": [2, 4, 5, 5, 6, 6, 8, 9, 9]})
|
>>> df
|
A B C D E
|
0 foo one small 1 2
|
1 foo one large 2 4
|
2 foo one large 2 5
|
3 foo two small 3 5
|
4 foo two small 3 6
|
5 bar one large 4 6
|
6 bar one small 5 8
|
7 bar two small 6 9
|
8 bar two large 7 9
|
|
This first example aggregates values by taking the sum.
|
|
>>> table = pd.pivot_table(df, values='D', index=['A', 'B'],
|
... columns=['C'], aggfunc=np.sum)
|
>>> table
|
C large small
|
A B
|
bar one 4.0 5.0
|
two 7.0 6.0
|
foo one 4.0 1.0
|
two NaN 6.0
|
|
We can also fill missing values using the `fill_value` parameter.
|
|
>>> table = pd.pivot_table(df, values='D', index=['A', 'B'],
|
... columns=['C'], aggfunc=np.sum, fill_value=0)
|
>>> table
|
C large small
|
A B
|
bar one 4 5
|
two 7 6
|
foo one 4 1
|
two 0 6
|
|
The next example aggregates by taking the mean across multiple columns.
|
|
>>> table = pd.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
|
... aggfunc={'D': np.mean, 'E': np.mean})
|
>>> table
|
D E
|
A C
|
bar large 5.500000 7.500000
|
small 5.500000 8.500000
|
foo large 2.000000 4.500000
|
small 2.333333 4.333333
|
|
We can also calculate multiple types of aggregations for any given
|
value column.
|
|
>>> table = pd.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
|
... aggfunc={'D': np.mean,
|
... 'E': [min, max, np.mean]})
|
>>> table
|
D E
|
mean max mean min
|
A C
|
bar large 5.500000 9 7.500000 6
|
small 5.500000 9 8.500000 8
|
foo large 2.000000 5 4.500000 4
|
small 2.333333 6 4.333333 2
|
Ú pivot_tableÚmeanÚAllr )ÚaggfuncÚmarginsrä Ú margins_namerA rò rº c C s* ddl m} | | ||||||||| |
|
d S )Nr )rE )
|
rè r´ r³ rH ru rI rä rJ rA rò )rD rE ) r½ rè r´ r³ rH ru rI rä rJ rA rò rE r¾ r¾ r¿ rE |! s õzDataFrame.pivot_table)r rä c C sJ ddl m}m} t|ttfr.|| ||d}n|| ||d}|j| ddS )a
|
Stack the prescribed level(s) from columns to index.
|
|
Return a reshaped DataFrame or Series having a multi-level
|
index with one or more new inner-most levels compared to the current
|
DataFrame. The new inner-most levels are created by pivoting the
|
columns of the current dataframe:
|
|
- if the columns have a single level, the output is a Series;
|
- if the columns have multiple levels, the new index
|
level(s) is (are) taken from the prescribed level(s) and
|
the output is a DataFrame.
|
|
Parameters
|
----------
|
level : int, str, list, default -1
|
Level(s) to stack from the column axis onto the index
|
axis, defined as one index or label, or a list of indices
|
or labels.
|
dropna : bool, default True
|
Whether to drop rows in the resulting Frame/Series with
|
missing values. Stacking a column level onto the index
|
axis can create combinations of index and column values
|
that are missing from the original dataframe. See Examples
|
section.
|
|
Returns
|
-------
|
DataFrame or Series
|
Stacked dataframe or series.
|
|
See Also
|
--------
|
DataFrame.unstack : Unstack prescribed level(s) from index axis
|
onto column axis.
|
DataFrame.pivot : Reshape dataframe from long format to wide
|
format.
|
DataFrame.pivot_table : Create a spreadsheet-style pivot table
|
as a DataFrame.
|
|
Notes
|
-----
|
The function is named by analogy with a collection of books
|
being reorganized from being side by side on a horizontal
|
position (the columns of the dataframe) to being stacked
|
vertically on top of each other (in the index of the
|
dataframe).
|
|
Reference :ref:`the user guide <reshaping.stacking>` for more examples.
|
|
Examples
|
--------
|
**Single level columns**
|
|
>>> df_single_level_cols = pd.DataFrame([[0, 1], [2, 3]],
|
... index=['cat', 'dog'],
|
... columns=['weight', 'height'])
|
|
Stacking a dataframe with a single level column axis returns a Series:
|
|
>>> df_single_level_cols
|
weight height
|
cat 0 1
|
dog 2 3
|
>>> df_single_level_cols.stack()
|
cat weight 0
|
height 1
|
dog weight 2
|
height 3
|
dtype: int64
|
|
**Multi level columns: simple case**
|
|
>>> multicol1 = pd.MultiIndex.from_tuples([('weight', 'kg'),
|
... ('weight', 'pounds')])
|
>>> df_multi_level_cols1 = pd.DataFrame([[1, 2], [2, 4]],
|
... index=['cat', 'dog'],
|
... columns=multicol1)
|
|
Stacking a dataframe with a multi-level column axis:
|
|
>>> df_multi_level_cols1
|
weight
|
kg pounds
|
cat 1 2
|
dog 2 4
|
>>> df_multi_level_cols1.stack()
|
weight
|
cat kg 1
|
pounds 2
|
dog kg 2
|
pounds 4
|
|
**Missing values**
|
|
>>> multicol2 = pd.MultiIndex.from_tuples([('weight', 'kg'),
|
... ('height', 'm')])
|
>>> df_multi_level_cols2 = pd.DataFrame([[1.0, 2.0], [3.0, 4.0]],
|
... index=['cat', 'dog'],
|
... columns=multicol2)
|
|
It is common to have missing values when stacking a dataframe
|
with multi-level columns, as the stacked dataframe typically
|
has more values than the original dataframe. Missing values
|
are filled with NaNs:
|
|
>>> df_multi_level_cols2
|
weight height
|
kg m
|
cat 1.0 2.0
|
dog 3.0 4.0
|
>>> df_multi_level_cols2.stack()
|
height weight
|
cat kg NaN 1.0
|
m 2.0 NaN
|
dog kg NaN 3.0
|
m 4.0 NaN
|
|
**Prescribing the level(s) to be stacked**
|
|
The first parameter controls which level or levels are stacked:
|
|
>>> df_multi_level_cols2.stack(0)
|
kg m
|
cat height NaN 2.0
|
weight 1.0 NaN
|
dog height NaN 4.0
|
weight 3.0 NaN
|
>>> df_multi_level_cols2.stack([0, 1])
|
cat height m 2.0
|
weight kg 1.0
|
dog height m 4.0
|
weight kg 3.0
|
dtype: float64
|
|
**Dropping missing values**
|
|
>>> df_multi_level_cols3 = pd.DataFrame([[None, 1.0], [2.0, 3.0]],
|
... index=['cat', 'dog'],
|
... columns=multicol2)
|
|
Note that rows where all values are missing are dropped by
|
default but this behaviour can be controlled via the dropna
|
keyword parameter:
|
|
>>> df_multi_level_cols3
|
weight height
|
kg m
|
cat NaN 1.0
|
dog 2.0 3.0
|
>>> df_multi_level_cols3.stack(dropna=False)
|
height weight
|
cat kg NaN NaN
|
m 1.0 NaN
|
dog kg NaN 2.0
|
m 3.0 NaN
|
>>> df_multi_level_cols3.stack(dropna=True)
|
height weight
|
cat m 1.0 NaN
|
dog kg NaN 2.0
|
m 3.0 NaN
|
r )ÚstackÚstack_multipler rK r )Úpandas.core.reshape.reshaperK rL rÕ r= rã rF )r½ r rä rK rL rf r¾ r¾ r¿ rK ! s $zDataFrame.stack)rº râ rº c sx | j js*| j | j ¡ ¡ }td| t|s<t|trD|g}nRt|trt dd |D r|sltdt
|
|t
|
t |krtd|}ntd| j dd t
|
|d krÀ |d
|
¡ }n`d d }| |d
|
|¡}|d d
D ]"}t || | |¡ksætdqæt fdd|D } j|d d |¡}|rJtt
|
||_n| j |j¡|_|j| j dd}|j| ddS )u
|
Transform each element of a list-like to a row, replicating index values.
|
|
Parameters
|
----------
|
column : IndexLabel
|
Column(s) to explode.
|
For multiple columns, specify a non-empty list with each element
|
be str or tuple, and all specified columns their list-like data
|
on same row of the frame must have matching length.
|
|
.. versionadded:: 1.3.0
|
Multi-column explode
|
|
ignore_index : bool, default False
|
If True, the resulting index will be labeled 0, 1, â¦, n - 1.
|
|
.. versionadded:: 1.1.0
|
|
Returns
|
-------
|
DataFrame
|
Exploded lists to rows of the subset columns;
|
index will be duplicated for these rows.
|
|
Raises
|
------
|
ValueError :
|
* If columns of the frame are not unique.
|
* If specified columns to explode is empty list.
|
* If specified columns to explode have not matching count of
|
elements rowwise in the frame.
|
|
See Also
|
--------
|
DataFrame.unstack : Pivot a level of the (necessarily hierarchical)
|
index labels.
|
DataFrame.melt : Unpivot a DataFrame from wide format to long format.
|
Series.explode : Explode a DataFrame from list-like columns to long format.
|
|
Notes
|
-----
|
This routine will explode list-likes including lists, tuples, sets,
|
Series, and np.ndarray. The result dtype of the subset rows will
|
be object. Scalars will be returned unchanged, and empty list-likes will
|
result in a np.nan for that row. In addition, the ordering of rows in the
|
output will be non-deterministic when exploding sets.
|
|
Reference :ref:`the user guide <reshaping.explode>` for more examples.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'A': [[0, 1, 2], 'foo', [], [3, 4]],
|
... 'B': 1,
|
... 'C': [['a', 'b', 'c'], np.nan, [], ['d', 'e']]})
|
>>> df
|
A B C
|
0 [0, 1, 2] 1 [a, b, c]
|
1 foo 1 NaN
|
2 [] 1 []
|
3 [3, 4] 1 [d, e]
|
|
Single-column explode.
|
|
>>> df.explode('A')
|
A B C
|
0 0 1 [a, b, c]
|
0 1 1 [a, b, c]
|
0 2 1 [a, b, c]
|
1 foo 1 NaN
|
2 NaN 1 []
|
3 3 1 [d, e]
|
3 4 1 [d, e]
|
|
Multi-column explode.
|
|
>>> df.explode(list('AC'))
|
A B C
|
0 0 1 a
|
0 1 1 b
|
0 2 1 c
|
1 foo 1 NaN
|
2 NaN 1 NaN
|
3 3 1 d
|
3 4 1 e
|
z5DataFrame columns must be unique. Duplicate columns: c s s | ]}t |pt|tV qd S r» )rf rÕ r= r¸ r¾ r¾ r¿ r ®" s z$DataFrame.explode.<locals>.<genexpr>zcolumn must be nonemptyzcolumn must be uniquez/column must be a scalar, tuple, or list thereofT)r¨ ró r c S s t | r t| dkr t| S dS )Nr ró )re rÏ ©r¢ r¾ r¾ r¿ Ú<lambda>½" ó z#DataFrame.explode.<locals>.<lambda>Nz)columns must have matching element countsc s i | ]}| | ¡ qS r¾ )Úexploder¸ ©Údfr¾ r¿ r Â" s z%DataFrame.explode.<locals>.<dictcomp>r= Fr^ rQ r )r³ r> r rç rØ rf rÕ r= rã rH rÏ r× rÓ rQ r$ r© r¨ r¨ r
r´ r9 rb rF ) r½ rº râ Zduplicate_colsr³ rf ÚmylenZcounts0r¹ r¾ rR r¿ rQ J" s> [ÿÿ
|
zDataFrame.explode)r c C s& ddl m} || ||}|j| ddS )aÏ
|
Pivot a level of the (necessarily hierarchical) index labels.
|
|
Returns a DataFrame having a new level of column labels whose inner-most level
|
consists of the pivoted index labels.
|
|
If the index is not a MultiIndex, the output will be a Series
|
(the analogue of stack when the columns are not a MultiIndex).
|
|
Parameters
|
----------
|
level : int, str, or list of these, default -1 (last level)
|
Level(s) of index to unstack, can pass level name.
|
fill_value : int, str or dict
|
Replace NaN with this value if the unstack produces missing values.
|
|
Returns
|
-------
|
Series or DataFrame
|
|
See Also
|
--------
|
DataFrame.pivot : Pivot a table based on column values.
|
DataFrame.stack : Pivot a level of the column labels (inverse operation
|
from `unstack`).
|
|
Notes
|
-----
|
Reference :ref:`the user guide <reshaping.stacking>` for more examples.
|
|
Examples
|
--------
|
>>> index = pd.MultiIndex.from_tuples([('one', 'a'), ('one', 'b'),
|
... ('two', 'a'), ('two', 'b')])
|
>>> s = pd.Series(np.arange(1.0, 5.0), index=index)
|
>>> s
|
one a 1.0
|
b 2.0
|
two a 3.0
|
b 4.0
|
dtype: float64
|
|
>>> s.unstack(level=-1)
|
a b
|
one 1.0 2.0
|
two 3.0 4.0
|
|
>>> s.unstack(level=0)
|
one two
|
a 1.0 3.0
|
b 2.0 4.0
|
|
>>> df = s.unstack(level=0)
|
>>> df.unstack()
|
one a 1.0
|
b 2.0
|
two a 3.0
|
b 4.0
|
dtype: float64
|
r )ÚunstackrU r )rM rU rF )r½ r ru rU rf r¾ r¾ r¿ rU Ì" s = zDataFrame.unstackr zdf.melt()ZcallerrZ r )Ú
|
value_namerÐ râ rº c C s t | ||||||dj| ddS )N)Úid_varsÚ
|
value_varsÚvar_namerV rÐ râ r r )r rF )r½ rW rX rY rV rÐ râ r¾ r¾ r¿ r # s
|
ù øzDataFrame.meltzcaxis : {0 or 'index', 1 or 'columns'}, default 0
|
Take difference over rows (0) or columns (1).
|
a¹
|
Difference with previous row
|
|
>>> df = pd.DataFrame({'a': [1, 2, 3, 4, 5, 6],
|
... 'b': [1, 1, 2, 3, 5, 8],
|
... 'c': [1, 4, 9, 16, 25, 36]})
|
>>> df
|
a b c
|
0 1 1 1
|
1 2 1 4
|
2 3 2 9
|
3 4 3 16
|
4 5 5 25
|
5 6 8 36
|
|
>>> df.diff()
|
a b c
|
0 NaN NaN NaN
|
1 1.0 0.0 3.0
|
2 1.0 1.0 5.0
|
3 1.0 1.0 7.0
|
4 1.0 2.0 9.0
|
5 1.0 3.0 11.0
|
|
Difference with previous column
|
|
>>> df.diff(axis=1)
|
a b c
|
0 NaN 0 0
|
1 NaN -1 3
|
2 NaN -1 7
|
3 NaN -1 13
|
4 NaN 0 20
|
5 NaN 2 28
|
|
Difference with 3rd previous row
|
|
>>> df.diff(periods=3)
|
a b c
|
0 NaN NaN NaN
|
1 NaN NaN NaN
|
2 NaN NaN NaN
|
3 3.0 2.0 15.0
|
4 3.0 4.0 21.0
|
5 3.0 6.0 27.0
|
|
Difference with following row
|
|
>>> df.diff(periods=-1)
|
a b c
|
0 -1.0 0.0 -3.0
|
1 -1.0 -1.0 -5.0
|
2 -1.0 -1.0 -7.0
|
3 -1.0 -2.0 -9.0
|
4 -1.0 -3.0 -11.0
|
5 NaN NaN NaN
|
|
Overflow in input dtype
|
|
>>> df = pd.DataFrame({'a': [1, 0]}, dtype=np.uint8)
|
>>> df.diff()
|
a
|
0 NaN
|
1 255.0)r¯ r Z other_klassrÞ )rÀ r° rº c C s| t |¡s*t|r| ¡ s"tdt|}| |¡}|dkrZ|dkrV| | j||d S d}| jj||d}| |¡
|
| d¡S )Nzperiods must be an integerró r r= )rÎ r° rô ) r rb r_ rØ rX rÄ rà r¸ rô rÀ rF )r½ rÀ r° r r¾ r¾ r¿ rô &# s J
|
ÿý
|
zDataFrame.diffzDataFrame | Series | None)r' rÜ rá rº c C s$ |dkr| }n|j dkr |S || S )a
|
Sub-classes to define. Return a sliced object.
|
|
Parameters
|
----------
|
key : string / list of selections
|
ndim : {1, 2}
|
requested ndim of result
|
subset : object, default None
|
subset to act on
|
Nró )rÜ )r½ r' rÜ rá r¾ r¾ r¿ Ú_gotitem# s
|
|
zDataFrame._gotitemaÅ
|
The aggregation operations are always performed over an axis, either the
|
index (default) or the column axis. This behavior is different from
|
`numpy` aggregation functions (`mean`, `median`, `prod`, `sum`, `std`,
|
`var`), where the default is to compute the aggregation of the flattened
|
array, e.g., ``numpy.mean(arr_2d)`` as opposed to
|
``numpy.mean(arr_2d, axis=0)``.
|
|
`agg` is an alias for `aggregate`. Use the alias.
|
|
See Also
|
--------
|
DataFrame.apply : Perform any type of operations.
|
DataFrame.transform : Perform transformation type operations.
|
core.groupby.GroupBy : Perform operations over groups.
|
core.resample.Resampler : Perform operations over resampled bins.
|
core.window.Rolling : Perform operations over rolling window.
|
core.window.Expanding : Perform operations over expanding window.
|
core.window.ExponentialMovingWindow : Perform operation over exponential weighted
|
window.
|
aÕ
|
Examples
|
--------
|
>>> df = pd.DataFrame([[1, 2, 3],
|
... [4, 5, 6],
|
... [7, 8, 9],
|
... [np.nan, np.nan, np.nan]],
|
... columns=['A', 'B', 'C'])
|
|
Aggregate these functions over the rows.
|
|
>>> df.agg(['sum', 'min'])
|
A B C
|
sum 12.0 15.0 18.0
|
min 1.0 2.0 3.0
|
|
Different aggregations per column.
|
|
>>> df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']})
|
A B
|
sum 12.0 NaN
|
min 1.0 2.0
|
max NaN 8.0
|
|
Aggregate different functions over the columns and rename the index of the resulting
|
DataFrame.
|
|
>>> df.agg(x=('A', max), y=('B', 'min'), z=('C', np.mean))
|
A B C
|
x 7.0 NaN NaN
|
y NaN 2.0 NaN
|
z NaN NaN 6.0
|
|
Aggregate over the columns.
|
|
>>> df.agg("mean", axis="columns")
|
0 2.0
|
1 5.0
|
2 8.0
|
3 NaN
|
dtype: float64
|
Ú aggregater° )r¯ r° Zsee_alsorÞ r= c O s~ ddl m} | |¡}t|f|\}}}}|| ||||d} | ¡ }
|
|rz|d k sTt|d k s`tt|
|
|||} t| |d}
|
|
|
S )Nr ©Ú frame_apply©rÛ r° r rÚ r )Úpandas.core.applyr] rÄ rr Úaggri rs r© ) r½ rÛ r° r rÚ r] Z
|
relabelingr³ r r rf Zresult_in_dictr¾ r¾ r¿ r[ ç# s
|
zDataFrame.aggregate)r° rå Úskipnar )r° rå ra r rº c K s d S r» r¾ ©r½ r° rå ra r rÚ r¾ r¾ r¿ r² $ s
|
z DataFrame.any)r° rå ra c K s d S r» r¾ rb r¾ r¾ r¿ r² $ s
|
c K s d S r» r¾ rb r¾ r¾ r¿ r² "$ s Ú transform)r¯ r° )rÛ r° rº c O s8 ddl m} || ||||d}| ¡ }t|ts4t|S )Nr r\ r^ )r_ r] rc rÕ r© ri )r½ rÛ r° r rÚ r] r rf r¾ r¾ r¿ rc -$ s
|
zDataFrame.transformr¾ z1Literal[('expand', 'reduce', 'broadcast')] | None)rÛ r° ÚrawÚ result_typec K s4 ddl m} || ||||||d}| ¡ j| ddS )aÙ
|
Apply a function along an axis of the DataFrame.
|
|
Objects passed to the function are Series objects whose index is
|
either the DataFrame's index (``axis=0``) or the DataFrame's columns
|
(``axis=1``). By default (``result_type=None``), the final return type
|
is inferred from the return type of the applied function. Otherwise,
|
it depends on the `result_type` argument.
|
|
Parameters
|
----------
|
func : function
|
Function to apply to each column or row.
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
Axis along which the function is applied:
|
|
* 0 or 'index': apply function to each column.
|
* 1 or 'columns': apply function to each row.
|
|
raw : bool, default False
|
Determines if row or column is passed as a Series or ndarray object:
|
|
* ``False`` : passes each row or column as a Series to the
|
function.
|
* ``True`` : the passed function will receive ndarray objects
|
instead.
|
If you are just applying a NumPy reduction function this will
|
achieve much better performance.
|
|
result_type : {'expand', 'reduce', 'broadcast', None}, default None
|
These only act when ``axis=1`` (columns):
|
|
* 'expand' : list-like results will be turned into columns.
|
* 'reduce' : returns a Series if possible rather than expanding
|
list-like results. This is the opposite of 'expand'.
|
* 'broadcast' : results will be broadcast to the original shape
|
of the DataFrame, the original index and columns will be
|
retained.
|
|
The default behaviour (None) depends on the return value of the
|
applied function: list-like results will be returned as a Series
|
of those. However if the apply function returns a Series these
|
are expanded to columns.
|
args : tuple
|
Positional arguments to pass to `func` in addition to the
|
array/series.
|
**kwargs
|
Additional keyword arguments to pass as keywords arguments to
|
`func`.
|
|
Returns
|
-------
|
Series or DataFrame
|
Result of applying ``func`` along the given axis of the
|
DataFrame.
|
|
See Also
|
--------
|
DataFrame.applymap: For elementwise operations.
|
DataFrame.aggregate: Only perform aggregating type operations.
|
DataFrame.transform: Only perform transforming type operations.
|
|
Notes
|
-----
|
Functions that mutate the passed object can produce unexpected
|
behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`
|
for more details.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B'])
|
>>> df
|
A B
|
0 4 9
|
1 4 9
|
2 4 9
|
|
Using a numpy universal function (in this case the same as
|
``np.sqrt(df)``):
|
|
>>> df.apply(np.sqrt)
|
A B
|
0 2.0 3.0
|
1 2.0 3.0
|
2 2.0 3.0
|
|
Using a reducing function on either axis
|
|
>>> df.apply(np.sum, axis=0)
|
A 12
|
B 27
|
dtype: int64
|
|
>>> df.apply(np.sum, axis=1)
|
0 13
|
1 13
|
2 13
|
dtype: int64
|
|
Returning a list-like will result in a Series
|
|
>>> df.apply(lambda x: [1, 2], axis=1)
|
0 [1, 2]
|
1 [1, 2]
|
2 [1, 2]
|
dtype: object
|
|
Passing ``result_type='expand'`` will expand list-like results
|
to columns of a Dataframe
|
|
>>> df.apply(lambda x: [1, 2], axis=1, result_type='expand')
|
0 1
|
0 1 2
|
1 1 2
|
2 1 2
|
|
Returning a Series inside the function is similar to passing
|
``result_type='expand'``. The resulting column names
|
will be the Series index.
|
|
>>> df.apply(lambda x: pd.Series([1, 2], index=['foo', 'bar']), axis=1)
|
foo bar
|
0 1 2
|
1 1 2
|
2 1 2
|
|
Passing ``result_type='broadcast'`` will ensure the same shape
|
result, whether list-like or scalar is returned by the function,
|
and broadcast it along the axis. The resulting column names will
|
be the originals.
|
|
>>> df.apply(lambda x: [1, 2], axis=1, result_type='broadcast')
|
A B
|
0 1 2
|
1 1 2
|
2 1 2
|
r r\ )rÛ r° rd re r rÚ r$ r )r_ r] r$ rF ) r½ rÛ r° rd re r rÚ r] r r¾ r¾ r¿ r$ <$ s ù zDataFrame.applyr4 )rÛ Ú na_actionrº c sP |dkrt dt| |dktj f| fdd}| |¡ | d¡S )u
|
Apply a function to a Dataframe elementwise.
|
|
This method applies a function that accepts and returns a scalar
|
to every element of a DataFrame.
|
|
Parameters
|
----------
|
func : callable
|
Python function, returns a single value from a single value.
|
na_action : {None, 'ignore'}, default None
|
If âignoreâ, propagate NaN values, without passing them to func.
|
|
.. versionadded:: 1.2
|
|
**kwargs
|
Additional keyword arguments to pass as keywords arguments to
|
`func`.
|
|
.. versionadded:: 1.3.0
|
|
Returns
|
-------
|
DataFrame
|
Transformed DataFrame.
|
|
See Also
|
--------
|
DataFrame.apply : Apply a function along input axis of DataFrame.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([[1, 2.12], [3.356, 4.567]])
|
>>> df
|
0 1
|
0 1.000 2.120
|
1 3.356 4.567
|
|
>>> df.applymap(lambda x: len(str(x)))
|
0 1
|
0 3 4
|
1 5 5
|
|
Like Series.map, NA values can be ignored:
|
|
>>> df_copy = df.copy()
|
>>> df_copy.iloc[0, 0] = pd.NA
|
>>> df_copy.applymap(lambda x: len(str(x)), na_action='ignore')
|
0 1
|
0 NaN 4
|
1 5.0 5
|
|
Note that a vectorized version of `func` often exists, which will
|
be much faster. You could square each number elementwise.
|
|
>>> df.applymap(lambda x: x**2)
|
0 1
|
0 1.000000 4.494400
|
1 11.262736 20.857489
|
|
But it's better to avoid applymap in that case.
|
|
>>> df ** 2
|
0 1
|
0 1.000000 4.494400
|
1 11.262736 20.857489
|
> Nr z(na_action must be 'ignore' or None. Got r c s. | j rtj| dS tj| t¡j dS )N)Ú ignore_na)rí r Z map_inferr8 rÝ rþ rN ©rÛ rg r¾ r¿ rÈ )% s z!DataFrame.applymap.<locals>.inferÚapplymap)rØ ÚreprÚ functoolsÚpartialr$ rF )r½ rÛ rf rÚ rÈ r¾ rh r¿ ri Û$ s F ÿzDataFrame.applymap)râ r rò rº c
|
C s t |ttfrzt |tr,|s$tdt|}|jd krB|sBtdt|jg| jjd}| ¡ j}|j ddj
|
|j dd}nBt |t r¼|sn2t |d t s¼t |}| jjd k r¼|s¼| jj|j_ddlm} t |t tfrâ| f|}n| |g}|||||d} | j| d d
|
S ) Nz+Can only append a dict if ignore_index=TruezICan only append a Series if ignore_index=True or if the Series has a namerr Fr r ©Úconcat)râ r rò rO r )rÕ r rÙ rÞ rÎ r r´ Zto_framerý Z infer_objectsZ rename_axisrß rã r© Úpandas.core.reshape.concatrn r= rF )
|
r½ rZ râ r rò r´ Zrow_dfrn Z to_concatrf r¾ r¾ r¿ r 3% sB
|
ÿ
|
ÿ
|
üzDataFrame._appendz1DataFrame | Series | Iterable[DataFrame | Series]r2 )rZ Úonrß ÚlsuffixÚrsuffixrò Úvalidaterº c C s | j |||||||dS )a
|
Join columns of another DataFrame.
|
|
Join columns with `other` DataFrame either on index or on a key
|
column. Efficiently join multiple DataFrame objects by index at once by
|
passing a list.
|
|
Parameters
|
----------
|
other : DataFrame, Series, or a list containing any combination of them
|
Index should be similar to one of the columns in this one. If a
|
Series is passed, its name attribute must be set, and that will be
|
used as the column name in the resulting joined DataFrame.
|
on : str, list of str, or array-like, optional
|
Column or index level name(s) in the caller to join on the index
|
in `other`, otherwise joins index-on-index. If multiple
|
values given, the `other` DataFrame must have a MultiIndex. Can
|
pass an array as the join key if it is not already contained in
|
the calling DataFrame. Like an Excel VLOOKUP operation.
|
how : {'left', 'right', 'outer', 'inner', 'cross'}, default 'left'
|
How to handle the operation of the two objects.
|
|
* left: use calling frame's index (or column if on is specified)
|
* right: use `other`'s index.
|
* outer: form union of calling frame's index (or column if on is
|
specified) with `other`'s index, and sort it.
|
lexicographically.
|
* inner: form intersection of calling frame's index (or column if
|
on is specified) with `other`'s index, preserving the order
|
of the calling's one.
|
* cross: creates the cartesian product from both frames, preserves the order
|
of the left keys.
|
|
.. versionadded:: 1.2.0
|
|
lsuffix : str, default ''
|
Suffix to use from left frame's overlapping columns.
|
rsuffix : str, default ''
|
Suffix to use from right frame's overlapping columns.
|
sort : bool, default False
|
Order result DataFrame lexicographically by the join key. If False,
|
the order of the join key depends on the join type (how keyword).
|
validate : str, optional
|
If specified, checks if join is of specified type.
|
* "one_to_one" or "1:1": check if join keys are unique in both left
|
and right datasets.
|
* "one_to_many" or "1:m": check if join keys are unique in left dataset.
|
* "many_to_one" or "m:1": check if join keys are unique in right dataset.
|
* "many_to_many" or "m:m": allowed, but does not result in checks.
|
.. versionadded:: 1.5.0
|
|
Returns
|
-------
|
DataFrame
|
A dataframe containing columns from both the caller and `other`.
|
|
See Also
|
--------
|
DataFrame.merge : For column(s)-on-column(s) operations.
|
|
Notes
|
-----
|
Parameters `on`, `lsuffix`, and `rsuffix` are not supported when
|
passing a list of `DataFrame` objects.
|
|
Support for specifying index levels as the `on` parameter was added
|
in version 0.23.0.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3', 'K4', 'K5'],
|
... 'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']})
|
|
>>> df
|
key A
|
0 K0 A0
|
1 K1 A1
|
2 K2 A2
|
3 K3 A3
|
4 K4 A4
|
5 K5 A5
|
|
>>> other = pd.DataFrame({'key': ['K0', 'K1', 'K2'],
|
... 'B': ['B0', 'B1', 'B2']})
|
|
>>> other
|
key B
|
0 K0 B0
|
1 K1 B1
|
2 K2 B2
|
|
Join DataFrames using their indexes.
|
|
>>> df.join(other, lsuffix='_caller', rsuffix='_other')
|
key_caller A key_other B
|
0 K0 A0 K0 B0
|
1 K1 A1 K1 B1
|
2 K2 A2 K2 B2
|
3 K3 A3 NaN NaN
|
4 K4 A4 NaN NaN
|
5 K5 A5 NaN NaN
|
|
If we want to join using the key columns, we need to set key to be
|
the index in both `df` and `other`. The joined DataFrame will have
|
key as its index.
|
|
>>> df.set_index('key').join(other.set_index('key'))
|
A B
|
key
|
K0 A0 B0
|
K1 A1 B1
|
K2 A2 B2
|
K3 A3 NaN
|
K4 A4 NaN
|
K5 A5 NaN
|
|
Another option to join using the key columns is to use the `on`
|
parameter. DataFrame.join always uses `other`'s index but we can use
|
any column in `df`. This method preserves the original DataFrame's
|
index in the result.
|
|
>>> df.join(other.set_index('key'), on='key')
|
key A B
|
0 K0 A0 B0
|
1 K1 A1 B1
|
2 K2 A2 B2
|
3 K3 A3 NaN
|
4 K4 A4 NaN
|
5 K5 A5 NaN
|
|
Using non-unique key values shows how they are matched.
|
|
>>> df = pd.DataFrame({'key': ['K0', 'K1', 'K1', 'K3', 'K0', 'K1'],
|
... 'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']})
|
|
>>> df
|
key A
|
0 K0 A0
|
1 K1 A1
|
2 K1 A2
|
3 K3 A3
|
4 K0 A4
|
5 K1 A5
|
|
>>> df.join(other.set_index('key'), on='key', validate='m:1')
|
key A B
|
0 K0 A0 B0
|
1 K1 A1 B1
|
2 K1 A2 B1
|
3 K3 A3 NaN
|
4 K0 A4 B0
|
5 K1 A5 B1
|
)rp rß rq rr rò rs )Ú _join_compat)r½ rZ rp rß rq rr rò rs r¾ r¾ r¿ r¨ c% s $ùzDataFrame.join)rZ rp rß rq rr rò rs c C sR ddl m} ddlm} t|trB|jd kr4tdt|j|i}t|tr|dkrn| | |||||f||dS | | ||||d kd||f||d S |d k r td |s¨|r°td
|
t d | gt
|
| }
|
t d d |
|
D } | r|dkr||
|
ddd|d} | j | j ddS ||
|
d|d|dS |
|
d } |
|
dd
D ]}| | ||dd|d} q.| S d S )Nr rm ©Úmergez Other Series must have a nameZcross)rß rp Úsuffixesrò rs T)Úleft_onrß Ú
|
left_indexÚ right_indexrw rò rs z?Joining multiple DataFrames only supported for joining on indexz7Suffixes not supported when joining multiple DataFramesr] c s s | ]}|j jV qd S r» )r´ r> )rÐ rS r¾ r¾ r¿ r I& s z)DataFrame._join_compat.<locals>.<genexpr>rd ró r§ )r° r¨ r rò Fr )rß ry rz rs )ro rn Úpandas.core.reshape.mergerv rÕ r rÎ rØ r© r rã rH rb r´ )r½ rZ rp rß rq rr rò rs rn rv ÚframesZ
|
can_concatr| Zjoinedr r¾ r¾ r¿ rt & s
|
|
|
|
ù ÷ ÿÿ
|
ÿ ÿú
|
zDataFrame._join_compatrÉ )ÚindentsÚinner©Ú_xZ_yz
|
str | bool) re rß rp rx Úright_onry rz rò rw rÄ Ú indicatorrs rº c C s. ddl m} | | ||||||||| |
|
| | d S )Nr ru ) rß rp rx r ry rz rò rw rÄ r rs )r{ rv )r½ re rß rp rx r ry rz rò rw rÄ r rs rv r¾ r¾ r¿ rv e& s ózDataFrame.mergez$int | dict[IndexLabel, int] | Series)Údecimalsrº c s ddl m} dd fdd }dddd d
|
d t ||¡ t|ttfrt|trd|jjsdt d t
|
|rt d d | ¡ D st dt|| |}n2t|rÄ| | jj|t d¡j| ddS t d|dk r
|
t|dkr
|
| j||dd| j| jdj| ddS | jddS dS )aÍ
|
Round a DataFrame to a variable number of decimal places.
|
|
Parameters
|
----------
|
decimals : int, dict, Series
|
Number of decimal places to round each column to. If an int is
|
given, round each column to the same number of places.
|
Otherwise dict and Series round to variable numbers of places.
|
Column names should be in the keys if `decimals` is a
|
dict-like, or in the index if `decimals` is a Series. Any
|
columns not included in `decimals` will be left as is. Elements
|
of `decimals` which are not columns of the input will be
|
ignored.
|
*args
|
Additional keywords have no effect but might be accepted for
|
compatibility with numpy.
|
**kwargs
|
Additional keywords have no effect but might be accepted for
|
compatibility with numpy.
|
|
Returns
|
-------
|
DataFrame
|
A DataFrame with the affected columns rounded to the specified
|
number of decimal places.
|
|
See Also
|
--------
|
numpy.around : Round a numpy array to the given number of decimals.
|
Series.round : Round a Series to the given number of decimals.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([(.21, .32), (.01, .67), (.66, .03), (.21, .18)],
|
... columns=['dogs', 'cats'])
|
>>> df
|
dogs cats
|
0 0.21 0.32
|
1 0.01 0.67
|
2 0.66 0.03
|
3 0.21 0.18
|
|
By providing an integer each column is rounded to the same number
|
of decimal places
|
|
>>> df.round(1)
|
dogs cats
|
0 0.2 0.3
|
1 0.0 0.7
|
2 0.7 0.0
|
3 0.2 0.2
|
|
With a dict, the number of places for specific columns can be
|
specified with the column names as key and the number of decimal
|
places as value
|
|
>>> df.round({'dogs': 1, 'cats': 0})
|
dogs cats
|
0 0.2 0.0
|
1 0.0 1.0
|
2 0.7 0.0
|
3 0.2 0.0
|
|
Using a Series, the number of places for specific columns can be
|
specified with the column names as index and the number of
|
decimal places as value
|
|
>>> decimals = pd.Series([0, 1], index=['cats', 'dogs'])
|
>>> df.round(decimals)
|
dogs cats
|
0 0.2 0.0
|
1 0.0 1.0
|
2 0.7 0.0
|
3 0.2 0.0
|
r rm r© rR c 3 sF | ¡ D ]8\}}z ||| V W q tk
|
r> |V Y qX qd S r» )r; r° )rS r r¥ rï ©Ú _series_roundr¾ r¿ Ú _dict_roundÙ& s
|
z$DataFrame.round.<locals>._dict_roundr rX )r¾ r rº c S s" t | jst| jr | |¡S | S r» )rc rà r` Úround)r¾ r r¾ r¾ r¿ r
à& s
|
z&DataFrame.round.<locals>._series_roundz Index of decimals must be uniquec s s | ]\}}t |V qd S r» )rb )rÐ rÑ r r¾ r¾ r¿ r ê& s z"DataFrame.round.<locals>.<genexpr>z#Values in decimals must be integers)r rH r r z4decimals must be an integer, a dict-like or a SeriesNró r= rÊ FrÅ )ro rn r Zvalidate_roundrÕ rÙ r r´ r> rØ r\ rH r; rÞ rã rb rÀ r¸ r r rF rÏ r³ rÄ )r½ r r rÚ rn r Znew_colsr¾ r r¿ r & s< O ÿÿ þ
|
ÿ þzDataFrame.roundÚpearsonr% )r Ú min_periodsÚ numeric_onlyrº c C s |r | ¡ n| }|j}| ¡ }|jttjdd}|dkrJtj||d}n"|dkrdtj ||d}n|dksvt
|
|r\|dkrd}|j }t |¡} t|}
|
tj|
|
|
|
ftd }t |¡} t|D ]\} } t|D ]\}}| |kràqÎ| | | | @ }| ¡ |k rtj}n8| |krd
|
}n(| ¡ s4| | | || }n
|
| | |}||| |f< |||| f< qÎq¾ntd | d | j|||dd }|j| ddS )a
|
|
|
Compute pairwise correlation of columns, excluding NA/null values.
|
|
Parameters
|
----------
|
method : {'pearson', 'kendall', 'spearman'} or callable
|
Method of correlation:
|
|
* pearson : standard correlation coefficient
|
* kendall : Kendall Tau correlation coefficient
|
* spearman : Spearman rank correlation
|
* callable: callable with input two 1d ndarrays
|
and returning a float. Note that the returned matrix from corr
|
will have 1 along the diagonals and will be symmetric
|
regardless of the callable's behavior.
|
min_periods : int, optional
|
Minimum number of observations required per pair of columns
|
to have a valid result. Currently only available for Pearson
|
and Spearman correlation.
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
.. versionchanged:: 2.0.0
|
The default value of ``numeric_only`` is now ``False``.
|
|
Returns
|
-------
|
DataFrame
|
Correlation matrix.
|
|
See Also
|
--------
|
DataFrame.corrwith : Compute pairwise correlation with another
|
DataFrame or Series.
|
Series.corr : Compute the correlation between two Series.
|
|
Notes
|
-----
|
Pearson, Kendall and Spearman correlation are currently computed using pairwise complete observations.
|
|
* `Pearson correlation coefficient <https://en.wikipedia.org/wiki/Pearson_correlation_coefficient>`_
|
* `Kendall rank correlation coefficient <https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient>`_
|
* `Spearman's rank correlation coefficient <https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient>`_
|
|
Examples
|
--------
|
>>> def histogram_intersection(a, b):
|
... v = np.minimum(a, b).sum().round(decimals=1)
|
... return v
|
>>> df = pd.DataFrame([(.2, .3), (.0, .6), (.6, .0), (.2, .1)],
|
... columns=['dogs', 'cats'])
|
>>> df.corr(method=histogram_intersection)
|
dogs cats
|
dogs 1.0 0.3
|
cats 0.3 1.0
|
|
>>> df = pd.DataFrame([(1, 1), (2, np.nan), (np.nan, 3), (4, 4)],
|
... columns=['dogs', 'cats'])
|
>>> df.corr(min_periods=3)
|
dogs cats
|
dogs 1.0 NaN
|
cats NaN 1.0
|
F©rà r| rÄ r )ÚminpÚspearmanÚkendallNró rð g ð?zHmethod must be either 'pearson', 'spearman', 'kendall', or a callable, 'z' was suppliedr` Úcorrr )Ú_get_numeric_datar³ rÄ r~ r rÚ rv ÚlibalgosÚnancorrZnancorr_spearmanÚcallablerý ro Z get_corr_funcrÏ rí Úisfiniter@ r rH rØ rÀ rF )r½ r r r rÓ rn rT ÚmatÚcorrelZcorrfÚKrë rC Úacr ZbcZvalidr¹ rf r¾ r¾ r¿ r ' sF G
|
|
|
|
|
|
ÿzDataFrame.corr)r Úddofr rº c
|
C sÐ |r | ¡ n| }|j}| ¡ }|jttjdd}t| ¡ r |dk rx|t |krxt
|
|j d |j d f¡}| tj¡ ntj |j|d}| t |t |f¡}ntj|d|d}| j|||dd} | j| d d
|
S ) a
|
Compute pairwise covariance of columns, excluding NA/null values.
|
|
Compute the pairwise covariance among the series of a DataFrame.
|
The returned data frame is the `covariance matrix
|
<https://en.wikipedia.org/wiki/Covariance_matrix>`__ of the columns
|
of the DataFrame.
|
|
Both NA and null values are automatically excluded from the
|
calculation. (See the note below about bias from missing values.)
|
A threshold can be set for the minimum number of
|
observations for each value created. Comparisons with observations
|
below this threshold will be returned as ``NaN``.
|
|
This method is generally used for the analysis of time series data to
|
understand the relationship between different measures
|
across time.
|
|
Parameters
|
----------
|
min_periods : int, optional
|
Minimum number of observations required per pair of columns
|
to have a valid result.
|
|
ddof : int, default 1
|
Delta degrees of freedom. The divisor used in calculations
|
is ``N - ddof``, where ``N`` represents the number of elements.
|
|
.. versionadded:: 1.1.0
|
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
.. versionchanged:: 2.0.0
|
The default value of ``numeric_only`` is now ``False``.
|
|
Returns
|
-------
|
DataFrame
|
The covariance matrix of the series of the DataFrame.
|
|
See Also
|
--------
|
Series.cov : Compute covariance with another Series.
|
core.window.ewm.ExponentialMovingWindow.cov : Exponential weighted sample
|
covariance.
|
core.window.expanding.Expanding.cov : Expanding sample covariance.
|
core.window.rolling.Rolling.cov : Rolling sample covariance.
|
|
Notes
|
-----
|
Returns the covariance matrix of the DataFrame's time series.
|
The covariance is normalized by N-ddof.
|
|
For DataFrames that have Series that are missing data (assuming that
|
data is `missing at random
|
<https://en.wikipedia.org/wiki/Missing_data#Missing_at_random>`__)
|
the returned covariance matrix will be an unbiased estimate
|
of the variance and covariance between the member Series.
|
|
However, for many applications this estimate may not be acceptable
|
because the estimate covariance matrix is not guaranteed to be positive
|
semi-definite. This could lead to estimate correlations having
|
absolute values which are greater than one, and/or a non-invertible
|
covariance matrix. See `Estimation of covariance matrices
|
<https://en.wikipedia.org/w/index.php?title=Estimation_of_covariance_
|
matrices>`__ for more details.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([(1, 2), (0, 3), (2, 0), (1, 1)],
|
... columns=['dogs', 'cats'])
|
>>> df.cov()
|
dogs cats
|
dogs 0.666667 -1.000000
|
cats -1.000000 1.666667
|
|
>>> np.random.seed(42)
|
>>> df = pd.DataFrame(np.random.randn(1000, 5),
|
... columns=['a', 'b', 'c', 'd', 'e'])
|
>>> df.cov()
|
a b c d e
|
a 0.998438 -0.020161 0.059277 -0.008943 0.014144
|
b -0.020161 1.059352 -0.008543 -0.024738 0.009826
|
c 0.059277 -0.008543 1.010670 -0.001486 -0.000271
|
d -0.008943 -0.024738 -0.001486 0.921297 -0.013692
|
e 0.014144 0.009826 -0.000271 -0.013692 0.977795
|
|
**Minimum number of periods**
|
|
This method also supports an optional ``min_periods`` keyword
|
that specifies the required minimum number of non-NA observations for
|
each column pair in order to have a valid result:
|
|
>>> np.random.seed(42)
|
>>> df = pd.DataFrame(np.random.randn(20, 3),
|
... columns=['a', 'b', 'c'])
|
>>> df.loc[df.index[:5], 'a'] = np.nan
|
>>> df.loc[df.index[5:10], 'b'] = np.nan
|
>>> df.cov(min_periods=12)
|
a b c
|
a 0.316741 NaN -0.150812
|
b NaN 1.248003 0.191417
|
c -0.150812 0.191417 0.895202
|
Fr Nró )r T)Úcovr r` r r )r r³ rÄ r~ r rÚ rv rl rH rÏ rí rï Úfillr rý rü r r rÀ rF )
|
r½ r r r rÓ rn rT r Zbase_covrf r¾ r¾ r¿ r s' s q z DataFrame.cov)rZ r° r¨ r r rº c sª | |¡}|r| ¡ n| }ttr<|j fdd|dS |rH ¡ |jddd\}}|dkrp|j}|j} dkrê||d }||d }||j|d
|
} ||j|d
|
}
|
| |
|
¡ } | ¡ d |j
|
|d
|
|j
|
|d
|
} | | } nV d ksüt r0 fd d }| j t |t|jj|jj|jdd} ntd d|s¦|d krTdnd }| |¡ |¡¡}| | j¡}t|d kr¦| ttjgt| |d¡} | S )a
|
Compute pairwise correlation.
|
|
Pairwise correlation is computed between rows or columns of
|
DataFrame with rows or columns of Series or DataFrame. DataFrames
|
are first aligned along both axes before computing the
|
correlations.
|
|
Parameters
|
----------
|
other : DataFrame, Series
|
Object with which to compute correlations.
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
The axis to use. 0 or 'index' to compute row-wise, 1 or 'columns' for
|
column-wise.
|
drop : bool, default False
|
Drop missing indices from result.
|
method : {'pearson', 'kendall', 'spearman'} or callable
|
Method of correlation:
|
|
* pearson : standard correlation coefficient
|
* kendall : Kendall Tau correlation coefficient
|
* spearman : Spearman rank correlation
|
* callable: callable with input two 1d ndarrays
|
and returning a float.
|
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionadded:: 1.5.0
|
|
.. versionchanged:: 2.0.0
|
The default value of ``numeric_only`` is now ``False``.
|
|
Returns
|
-------
|
Series
|
Pairwise correlations.
|
|
See Also
|
--------
|
DataFrame.corr : Compute pairwise correlation of columns.
|
|
Examples
|
--------
|
>>> index = ["a", "b", "c", "d", "e"]
|
>>> columns = ["one", "two", "three", "four"]
|
>>> df1 = pd.DataFrame(np.arange(20).reshape(5, 4), index=index, columns=columns)
|
>>> df2 = pd.DataFrame(np.arange(16).reshape(4, 4), index=index[:4], columns=columns)
|
>>> df1.corrwith(df2)
|
one 1.0
|
two 1.0
|
three 1.0
|
four 1.0
|
dtype: float64
|
|
>>> df2.corrwith(df1, axis=1)
|
a 1.0
|
b 1.0
|
c 1.0
|
d 1.0
|
e NaN
|
dtype: float64
|
c s j | dS )Nr )r rN ©r rZ r¾ r¿ rO B( rP z$DataFrame.corrwith.<locals>.<lambda>r= r~ F)r¨ rÄ ró r r )r )r r c s t j| d | d dS )Nr ró r )ro r rN r r¾ r¿ r¹ `( s z DataFrame.corrwith.<locals>.cr_ zInvalid method zM was passed, valid methods are: 'pearson', 'kendall', 'spearman', or callabler )rÄ r rÕ r r$ r¬ rý rF r rè Zstdr rÁ rT rE rè r³ rØ ræ ra Ú
|
differencer´ rÏ r rÚ rv )r½ rZ r° r¨ r r r4 rd re ZldemZrdemÚnumÚdomr r¹ Zraxisr Zidx_diffr¾ r r¿ Úcorrwithö' sT H
|
|
|
|
ÿ
|
þÿ
|
ý
|
ÿ ÿzDataFrame.corrwith)r° r c C s¤ | |¡}|r| ¡ }n| }t| |¡dkrD| jd| |¡d}nL|jsR|jjrdt |j
|
|d}n,t |j
|
|d}|j }| j|| |¡dd}| d¡j | ddS ) a
|
Count non-NA cells for each column or row.
|
|
The values `None`, `NaN`, `NaT`, and optionally `numpy.inf` (depending
|
on `pandas.options.mode.use_inf_as_na`) are considered NA.
|
|
Parameters
|
----------
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
If 0 or 'index' counts are generated for each column.
|
If 1 or 'columns' counts are generated for each row.
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
Returns
|
-------
|
Series or DataFrame
|
For each column/row the number of non-NA/null entries.
|
If `level` is specified returns a `DataFrame`.
|
|
See Also
|
--------
|
Series.count: Number of non-NA elements in a Series.
|
DataFrame.value_counts: Count unique combinations of columns.
|
DataFrame.shape: Number of DataFrame rows and columns (including NA
|
elements).
|
DataFrame.isna: Boolean same-sized DataFrame showing places of NA
|
elements.
|
|
Examples
|
--------
|
Constructing DataFrame from a dictionary:
|
|
>>> df = pd.DataFrame({"Person":
|
... ["John", "Myla", "Lewis", "John", "Myla"],
|
... "Age": [24., np.nan, 21., 33, 26],
|
... "Single": [False, True, True, True, False]})
|
>>> df
|
Person Age Single
|
0 John 24.0 False
|
1 Myla NaN True
|
2 Lewis 21.0 True
|
3 John 33.0 True
|
4 Myla 26.0 False
|
|
Notice the uncounted NA values:
|
|
>>> df.count()
|
Person 5
|
Age 4
|
Single 5
|
dtype: int64
|
|
Counts for each **row**:
|
|
>>> df.count(axis='columns')
|
0 3
|
1 2
|
2 3
|
3 3
|
4 3
|
dtype: int64
|
r r r= Fr_ r rè r )rÄ r rÏ ræ rÁ Ú _get_agg_axisr÷ r¸ rõ rl r rþ r8 rF )r½ r° r r rf Z series_countsr
|
r¾ r¾ r¿ rè ( s @
|
|
ÿzDataFrame.count©r° ra r Ú filter_type)rÎ r° ra r c sl d ksdkst dkr$dnd } d k r: ¡ dd fdd } dddfd d
|
}
|
d d fd d } } |r| } d kr¢| | jS dkròt| jdkrì| jfdddjd d
} | j| _| S | j} | j |
|
¡}|
|
|¡jd }|d k r$| |¡}nD| j ¡ t k ¡ rD| t ¡}n$tdkrhdkrh| tj¡}|S )Nré r{ rñ c s | f dS )N©r° ra r¾ rñ )r° Úkwdsr ra r¾ r¿ rÛ ë( s z DataFrame._reduce.<locals>.funcró r! r= c sh t | trNt| js8t jts8| jfdd S | jfdi S | f|d S d S )Nró r¤ ra )rÕ rw rY rà r¸ r Ú_reduce)rè r° )r¥ rÎ r r½ ra r¾ r¿ Úblk_funcï( s
|
ÿz#DataFrame._reduce.<locals>.blk_funcr© r¹ c s* d kr ¡ } n dks t ¡ } | S )Nré )r ri Z_get_bool_datar )r£ r½ r¾ r¿ Ú _get_dataù( s
|
|
z$DataFrame._reduce.<locals>._get_datar Fr¢ )r Úprod)ró )ri rÄ rè rÏ r´ r¦ r rý r¸ ÚreducerÀ r8 Z
|
get_dtypesrÝ r² rÚ r )r½ r rÎ r° ra r r£ r¥ Z out_dtyperÛ r§ r¨ rS rf r| r( r¾ )r° r£ r¥ rÎ r r½ ra r¿ r¦ Ú( sN
|
|
|
|
þúùø
|
zDataFrame._reduce)rÎ ra rº c C s |dkr"t jt| td}t j}n*|dkrDt jt| td}t j}nt|| jj D ] }||d|d}|||}qT| j
|
|| j dd}|S )zÃ
|
Special case for _reduce to try to avoid a potentially-expensive transpose.
|
|
Apply the reduction block-wise along axis=1 and then reduce the resulting
|
1D arrays.
|
rH rð r² r r¤ Fr_ ) rÚ ZonesrÏ ré Ú logical_andÚzerosÚ
|
logical_orrh r¸ rç rÁ r´ ) r½ rÎ rÛ ra rf Zufuncrñ ZmiddleZres_serr¾ r¾ r¿ Ú _reduce_axis1)) s zDataFrame._reduce_axis1)r° rä rº c C s | j tj||dS )a
|
Count number of distinct elements in specified axis.
|
|
Return Series with number of distinct elements. Can ignore NaN
|
values.
|
|
Parameters
|
----------
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for
|
column-wise.
|
dropna : bool, default True
|
Don't include NaN in the counts.
|
|
Returns
|
-------
|
Series
|
|
See Also
|
--------
|
Series.nunique: Method nunique for Series.
|
DataFrame.count: Count non-NA cells for each column or row.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'A': [4, 5, 6], 'B': [4, 1, 1]})
|
>>> df.nunique()
|
A 3
|
B 2
|
dtype: int64
|
|
>>> df.nunique(axis=1)
|
0 1
|
1 2
|
2 2
|
dtype: int64
|
)r° rä )r$ r Únunique)r½ r° rä r¾ r¾ r¿ r¯ E) s &zDataFrame.nuniqueÚidxminÚFalse)Znumeric_only_default)r° ra r rº c s | |¡}|r| ¡ }n| }|jtjd||dd}|j}t|tjsHt |
|
|¡ fdd|D }|j || |¡d}|j | ddS ) NZargminF©r° ra r c s" g | ]}|d kr | nt jqS ©r ©rÚ rv rµ r r¾ r¿ rÔ ) s z$DataFrame.idxmin.<locals>.<listcomp>r r° r )rÄ r r¦ ro Z nanargminrþ rÕ rÚ rÛ ri ræ rÁ r¡ rF © r½ r° ra r rÓ r| ré rf Z final_resultr¾ r r¿ r° m) s"
|
|
ÿ
|
zDataFrame.idxminÚidxmaxc s | |¡}|r| ¡ }n| }|jtjd||dd}|j}t|tjsHt |
|
|¡ fdd|D }|j || |¡d}|j | ddS ) NZargmaxFr² c s" g | ]}|d kr | nt jqS r³ r´ rµ r r¾ r¿ rÔ ) s z$DataFrame.idxmax.<locals>.<listcomp>r r¶ r )rÄ r r¦ ro Z nanargmaxrþ rÕ rÚ rÛ ri ræ rÁ r¡ rF rµ r¾ r r¿ r¶ ) s"
|
|
ÿ
|
zDataFrame.idxmaxr )Úaxis_numrº c C s4 |dkr| j S |dkr | jS tdt| ddS )z/
|
Let's be explicit about this.
|
r ró zAxis must be 0 or 1 (got rü N)r³ r´ rØ rj )r½ r· r¾ r¾ r¿ r¡ ) s
|
zDataFrame._get_agg_axis)r° r rä rº c s> |s| n| ¡ } fdd}|j||d}|jr:td|_|S )a
|
|
Get the mode(s) of each element along the selected axis.
|
|
The mode of a set of values is the value that appears most often.
|
It can be multiple values.
|
|
Parameters
|
----------
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
The axis to iterate over while searching for the mode:
|
|
* 0 or 'index' : get mode of each column
|
* 1 or 'columns' : get mode of each row.
|
|
numeric_only : bool, default False
|
If True, only apply to numeric columns.
|
dropna : bool, default True
|
Don't consider counts of NaN/NaT.
|
|
Returns
|
-------
|
DataFrame
|
The modes of each column or row.
|
|
See Also
|
--------
|
Series.mode : Return the highest frequency value in a Series.
|
Series.value_counts : Return the counts of values in a Series.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame([('bird', 2, 2),
|
... ('mammal', 4, np.nan),
|
... ('arthropod', 8, 0),
|
... ('bird', 2, np.nan)],
|
... index=('falcon', 'horse', 'spider', 'ostrich'),
|
... columns=('species', 'legs', 'wings'))
|
>>> df
|
species legs wings
|
falcon bird 2 2.0
|
horse mammal 4 NaN
|
spider arthropod 8 0.0
|
ostrich bird 2 NaN
|
|
By default, missing values are not considered, and the mode of wings
|
are both 0 and 2. Because the resulting DataFrame has two rows,
|
the second row of ``species`` and ``legs`` contains ``NaN``.
|
|
>>> df.mode()
|
species legs wings
|
0 bird 2.0 0.0
|
1 NaN NaN 2.0
|
|
Setting ``dropna=False`` ``NaN`` values are considered and they can be
|
the mode (like for wings).
|
|
>>> df.mode(dropna=False)
|
species legs wings
|
0 bird 2 NaN
|
|
Setting ``numeric_only=True``, only the mode of numeric columns is
|
computed, and columns of other types are ignored.
|
|
>>> df.mode(numeric_only=True)
|
legs wings
|
0 2.0 0.0
|
1 NaN 2.0
|
|
To compute the mode over columns and not rows, use the axis parameter:
|
|
>>> df.mode(axis='columns', numeric_only=True)
|
0 1
|
falcon 2.0 NaN
|
horse 4.0 NaN
|
spider 0.0 8.0
|
ostrich 2.0 NaN
|
c s | j dS )Nr )rà )rJ r r¾ r¿ rð ü) s zDataFrame.mode.<locals>.fr= r )r r$ rí r
r´ )r½ r° r rä rÓ rð r¾ r r¿ rà ª) s P
|
zDataFrame.moder r5 )Úqr° r Ú interpolationrº c C s d S r» r¾ ©r½ r¸ r° r r¹ r¾ r¾ r¿ Úquantile* s zDataFrame.quantilez AnyArrayLike | Sequence[float]zSeries | DataFramec C s d S r» r¾ rº r¾ r¾ r¿ r» * s z&float | AnyArrayLike | Sequence[float]c C s d S r» r¾ rº r¾ r¾ r¿ r» * s ç à?ÚlinearÚsinglez Literal[('single', 'table')])r¸ r° r r¹ r rº c s t | | |¡}t|s| j|g||||d}|dkrD|jd }n|jjdd
df }|dkrt| dkrtt| j }t
|
|r| |¡S |S t |t jd}|rª| ¡ n| |dkr¼ j t jdkr(t g | jjd} t j}|dkrtt| j }
|
t
|
|
|
r|
|
}| jg || |d}|j| d d
|
S dd h} || krPtd | d | d|dkrn jj|d|d}nü|d krjdddh} || kr td| d| t dkrä jdkrÊtt| j }n| j}| jg | j|dS t jt t ¡|ft|i} j}t|dkr2 fdd|D }t|}n|d } |¡}t |} jj || dd}||j d< | |¡}|j| d d
|
S )a¥
|
Return values at the given quantile over requested axis.
|
|
Parameters
|
----------
|
q : float or array-like, default 0.5 (50% quantile)
|
Value between 0 <= q <= 1, the quantile(s) to compute.
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
Equals 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
|
numeric_only : bool, default False
|
Include only `float`, `int` or `boolean` data.
|
|
.. versionchanged:: 2.0.0
|
The default value of ``numeric_only`` is now ``False``.
|
|
interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
|
This optional parameter specifies the interpolation method to use,
|
when the desired quantile lies between two data points `i` and `j`:
|
|
* linear: `i + (j - i) * fraction`, where `fraction` is the
|
fractional part of the index surrounded by `i` and `j`.
|
* lower: `i`.
|
* higher: `j`.
|
* nearest: `i` or `j` whichever is nearest.
|
* midpoint: (`i` + `j`) / 2.
|
method : {'single', 'table'}, default 'single'
|
Whether to compute quantiles per-column ('single') or over all columns
|
('table'). When 'table', the only allowed interpolation methods are
|
'nearest', 'lower', and 'higher'.
|
|
Returns
|
-------
|
Series or DataFrame
|
|
If ``q`` is an array, a DataFrame will be returned where the
|
index is ``q``, the columns are the columns of self, and the
|
values are the quantiles.
|
If ``q`` is a float, a Series will be returned where the
|
index is the columns of self and the values are the quantiles.
|
|
See Also
|
--------
|
core.window.rolling.Rolling.quantile: Rolling quantile.
|
numpy.percentile: Numpy function to compute the percentile.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame(np.array([[1, 1], [2, 10], [3, 100], [4, 100]]),
|
... columns=['a', 'b'])
|
>>> df.quantile(.1)
|
a 1.3
|
b 3.7
|
Name: 0.1, dtype: float64
|
>>> df.quantile([.1, .5])
|
a b
|
0.1 1.3 3.7
|
0.5 2.5 55.0
|
|
Specifying `method='table'` will compute the quantile over all columns.
|
|
>>> df.quantile(.1, method="table", interpolation="nearest")
|
a 1
|
b 1
|
Name: 0.1, dtype: int64
|
>>> df.quantile([.1, .5], method="table", interpolation="nearest")
|
a b
|
0.1 1 1
|
0.5 3 100
|
|
Specifying `numeric_only=False` will also compute the quantile of
|
datetime and timedelta data.
|
|
>>> df = pd.DataFrame({'A': [1, 2],
|
... 'B': [pd.Timestamp('2010'),
|
... pd.Timestamp('2011')],
|
... 'C': [pd.Timedelta('1 days'),
|
... pd.Timedelta('2 days')]})
|
>>> df.quantile(0.5, numeric_only=False)
|
A 1.5
|
B 2010-07-02 12:00:00
|
C 1 days 12:00:00
|
Name: 0.5, dtype: object
|
)r° r r¹ r r¾ r Nró rð rr rp r» r ÚtablezInvalid method: z. Method must be in r )Úqsr° r¹ Znearestrv ZhigherzInvalid interpolation: z. Interpolation must be in rÉ c s g | ]} |¡qS r¾ rý r¡ r r¾ r¿ rÔ Ê* s z&DataFrame.quantile.<locals>.<listcomp>F)r ) rN rÄ re r» r rý rÏ rS rã r rh r8 r rÚ r r r³ rÎ rÀ rF rØ r¸ rÜ rà ZarangerD r rþ r r9 r® )r½ r¸ r° r r¹ r rÆ r| rà rn ZcdtypeZ valid_methodZvalid_interpolationZq_idxrø rx r+ rB rf r¾ r r¿ r» $* s [
|
û
|
|
|
|
ÿ
|
|
|
|
ÿ ÿÿ
|
|
|
|
r- )rÁ r rß r ru rº c s t j|||||dS )N)rÁ r rß r ru )r« Úasfreq)r½ rÁ r rß r ru r r¾ r¿ rÁ ×* s ûzDataFrame.asfreqÚstartÚ start_dayz str | TimestampConvertibleTypesz TimedeltaConvertibleTypes | Noner« ) r° Úclosedr# Ú
|
conventionr1 rp r ÚoriginÚoffsetr@ rº c s" t j||||||||| |
|
| d S )N) Úruler° rÄ r# rÅ r1 rp r rÆ rÇ r@ )r« Úresample) r½ rÈ r° rÄ r# rÅ r1 rp r rÆ rÇ r@ r r¾ r¿ rÉ è* s õzDataFrame.resample)rÁ rß r° rÄ rº c C sd | j |ot d}| |¡}t| |}t|tsFtdt|j |j ||d}t
|
||| |S )a
|
Cast to DatetimeIndex of timestamps, at *beginning* of period.
|
|
Parameters
|
----------
|
freq : str, default frequency of PeriodIndex
|
Desired frequency.
|
how : {'s', 'e', 'start', 'end'}
|
Convention for converting period to timestamp; start of period
|
vs. end.
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
The axis to convert (the index by default).
|
copy : bool, default True
|
If False then underlying input data is not copied.
|
|
Returns
|
-------
|
DataFrame
|
The DataFrame has a DatetimeIndex.
|
|
Examples
|
--------
|
>>> idx = pd.PeriodIndex(['2023', '2024'], freq='Y')
|
>>> d = {'col1': [1, 2], 'col2': [3, 4]}
|
>>> df1 = pd.DataFrame(data=d, index=idx)
|
>>> df1
|
col1 col2
|
2023 1 3
|
2024 2 4
|
|
The resulting timestamps will be at the beginning of the year in this case
|
|
>>> df1 = df1.to_timestamp()
|
>>> df1
|
col1 col2
|
2023-01-01 1 3
|
2024-01-01 2 4
|
>>> df1.index
|
DatetimeIndex(['2023-01-01', '2024-01-01'], dtype='datetime64[ns]', freq=None)
|
|
Using `freq` which is the offset that the Timestamps will have
|
|
>>> df2 = pd.DataFrame(data=d, index=idx)
|
>>> df2 = df2.to_timestamp(freq='M')
|
>>> df2
|
col1 col2
|
2023-01-31 1 3
|
2024-01-31 2 4
|
>>> df2.index
|
DatetimeIndex(['2023-01-31', '2024-01-31'], dtype='datetime64[ns]', freq=None)
|
rÅ úunsupported Type )rÁ rß ) rÄ r Ú_get_axis_namerà rÕ r rÞ rc Ú__name__Ú to_timestampÚsetattr) r½ rÁ rß r° rÄ rÙ Ú axis_nameÚold_axÚnew_axr¾ r¾ r¿ rÍ + s :
|
|
|
zDataFrame.to_timestamp)rÁ r° rÄ rº c C sb | j |ot d}| |¡}t| |}t|tsFtdt|j |j |d}t
|
||| |S )aÍ
|
Convert DataFrame from DatetimeIndex to PeriodIndex.
|
|
Convert DataFrame from DatetimeIndex to PeriodIndex with desired
|
frequency (inferred from index if not passed).
|
|
Parameters
|
----------
|
freq : str, default
|
Frequency of the PeriodIndex.
|
axis : {0 or 'index', 1 or 'columns'}, default 0
|
The axis to convert (the index by default).
|
copy : bool, default True
|
If False then underlying input data is not copied.
|
|
Returns
|
-------
|
DataFrame
|
The DataFrame has a PeriodIndex.
|
|
Examples
|
--------
|
>>> idx = pd.to_datetime(
|
... [
|
... "2001-03-31 00:00:00",
|
... "2002-05-31 00:00:00",
|
... "2003-08-31 00:00:00",
|
... ]
|
... )
|
|
>>> idx
|
DatetimeIndex(['2001-03-31', '2002-05-31', '2003-08-31'],
|
dtype='datetime64[ns]', freq=None)
|
|
>>> idx.to_period("M")
|
PeriodIndex(['2001-03', '2002-05', '2003-08'], dtype='period[M]')
|
|
For the yearly frequency
|
|
>>> idx.to_period("Y")
|
PeriodIndex(['2001', '2002', '2003'], dtype='period[A-DEC]')
|
rÅ rÊ )rÁ ) rÄ r rË rà rÕ r rÞ rc rÌ Ú to_periodrÎ )r½ rÁ r° rÄ rÙ rÏ rÐ rÑ r¾ r¾ r¿ rÒ K+ s -
|
|
|
zDataFrame.to_periodz'Series | DataFrame | Sequence | Mapping)rè rº c s t trFddlm} t t¡| fddt jD dd}n®t t rvj
|
j s`t d j ¡dd}n~t trªjj rj
|
j st d ¡¡}nJtsÈtd tj d
|
jt j ¡ ¡ j¡ j
|
jd d }|j d dS )ag
|
Whether each element in the DataFrame is contained in values.
|
|
Parameters
|
----------
|
values : iterable, Series, DataFrame or dict
|
The result will only be true at a location if all the
|
labels match. If `values` is a Series, that's the index. If
|
`values` is a dict, the keys must be the column names,
|
which must match. If `values` is a DataFrame,
|
then both the index and column labels must match.
|
|
Returns
|
-------
|
DataFrame
|
DataFrame of booleans showing whether each element in the DataFrame
|
is contained in values.
|
|
See Also
|
--------
|
DataFrame.eq: Equality test for DataFrame.
|
Series.isin: Equivalent method on Series.
|
Series.str.contains: Test if pattern or regex is contained within a
|
string of a Series or Index.
|
|
Examples
|
--------
|
>>> df = pd.DataFrame({'num_legs': [2, 4], 'num_wings': [2, 0]},
|
... index=['falcon', 'dog'])
|
>>> df
|
num_legs num_wings
|
falcon 2 2
|
dog 4 0
|
|
When ``values`` is a list check whether every value in the DataFrame
|
is present in the list (which animals have 0 or 2 legs or wings)
|
|
>>> df.isin([0, 2])
|
num_legs num_wings
|
falcon True True
|
dog False True
|
|
To check if ``values`` is *not* in the DataFrame, use the ``~`` operator:
|
|
>>> ~df.isin([0, 2])
|
num_legs num_wings
|
falcon False False
|
dog True False
|
|
When ``values`` is a dict, we can pass values to check for each
|
column separately:
|
|
>>> df.isin({'num_wings': [0, 3]})
|
num_legs num_wings
|
falcon False False
|
dog False True
|
|
When ``values`` is a Series or DataFrame the index and column must
|
match. Note that 'falcon' does not match based on the number of legs
|
in other.
|
|
>>> other = pd.DataFrame({'num_legs': [8, 3], 'num_wings': [0, 2]},
|
... index=['spider', 'falcon'])
|
>>> df.isin(other)
|
num_legs num_wings
|
falcon False True
|
dog False False
|
r rm c 3 s0 | ](\}} j d d
|gf | ¡V qd S r» )r Úisin)rÐ rC r¥ ©r½ rè r¾ r¿ r Î+ s ÿz!DataFrame.isin.<locals>.<genexpr>ró r= z*cannot compute isin with a duplicate axis.r´ z`only list-like or dict-like objects are allowed to be passed to DataFrame.isin(), you passed a 'ro Fr rÓ r ) rÕ rÙ ro rn rR Ú defaultdictrã r@ r³ r r´ r> rØ ÚeqZ reindex_liker© re rÞ rc rÌ rÀ rm rÓ rè Zravelrü rï rF )r½ rè rn rf r¾ rÔ r¿ rÓ + sB E
|
þû
|
|
ÿ ÿþúzDataFrame.isinz#list[Literal[('index', 'columns')]]Ú _AXIS_ORDERS)ró r³ zdict[Axis, int]Ú_AXIS_TO_AXIS_NUMBERz
|
Literal[1]Ú_info_axis_numberzLiteral['columns']Ú_info_axis_namez(The index (row labels) of the DataFrame.)r° rJ z#The column labels of the DataFrame.Úplotc s8 j }t|d}tt|} fdd|j|d ¡ D S )z
|
Return a dict of dtype -> Constructor Types that
|
each is a homogeneous dtype.
|
|
Internal ONLY - only works for BlockManager
|
rô c s" i | ]\}}| |¡ ¡qS r¾ )rÀ rF )rÐ rB rI r¼ r¾ r¿ r , s ÿ z0DataFrame._to_dict_of_blocks.<locals>.<dictcomp>r )r¸ r r r r r; )r½ rÄ ræ r¾ r¼ r¿ Ú_to_dict_of_blocks , s
|
|
|
þz DataFrame._to_dict_of_blocksc C s
|
| j ¡ S )a´
|
Return a Numpy representation of the DataFrame.
|
|
.. warning::
|
|
We recommend using :meth:`DataFrame.to_numpy` instead.
|
|
Only the values in the DataFrame will be returned, the axes labels
|
will be removed.
|
|
Returns
|
-------
|
numpy.ndarray
|
The values of the DataFrame.
|
|
See Also
|
--------
|
DataFrame.to_numpy : Recommended alternative to this method.
|
DataFrame.index : Retrieve the index labels.
|
DataFrame.columns : Retrieving the column names.
|
|
Notes
|
-----
|
The dtype will be a lower-common-denominator dtype (implicit
|
upcasting); that is to say if the dtypes (even of numeric types)
|
are mixed, the one that accommodates all will be chosen. Use this
|
with care if you are not dealing with the blocks.
|
|
e.g. If the dtypes are float16 and float32, dtype will be upcast to
|
float32. If dtypes are int32 and uint8, dtype will be upcast to
|
int32. By :func:`numpy.find_common_type` convention, mixing int64
|
and uint64 will result in a float64 dtype.
|
|
Examples
|
--------
|
A DataFrame where all columns are the same type (e.g., int64) results
|
in an array of the same type.
|
|
>>> df = pd.DataFrame({'age': [ 3, 29],
|
... 'height': [94, 170],
|
... 'weight': [31, 115]})
|
>>> df
|
age height weight
|
0 3 94 31
|
1 29 170 115
|
>>> df.dtypes
|
age int64
|
height int64
|
weight int64
|
dtype: object
|
>>> df.values
|
array([[ 3, 94, 31],
|
[ 29, 170, 115]])
|
|
A DataFrame with mixed type columns(e.g., str/object, int64, float32)
|
results in an ndarray of the broadest type that accommodates these
|
mixed types (e.g., object).
|
|
>>> df2 = pd.DataFrame([('parrot', 24.0, 'second'),
|
... ('lion', 80.5, 1),
|
... ('monkey', np.nan, None)],
|
... columns=('name', 'max_speed', 'rank'))
|
>>> df2.dtypes
|
name object
|
max_speed float64
|
rank object
|
dtype: object
|
>>> df2.values
|
array([['parrot', 24.0, 'second'],
|
['lion', 80.5, 1],
|
['monkey', nan, None]], dtype=object)
|
)r¸ r} r¼ r¾ r¾ r¿ rè , s JzDataFrame.values©r° r± r r¶ z None | Axisz
|
None | int)r° r± r r¶ rº c C s d S r» r¾ ©r½ r° r± r r¶ r¾ r¾ r¿ Úffillg, s zDataFrame.ffill)r° r r¶ c C s d S r» r¾ rÞ r¾ r¾ r¿ rß r, s c C s d S r» r¾ rÞ r¾ r¾ r¿ rß }, s c s t j||||dS ©NrÝ )r« rß rÞ r r¾ r¿ rß , s )r° r± r rº c C s d S r» r¾ rÞ r¾ r¾ r¿ Úbfill, s zDataFrame.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 s t j||||dS rà )r« rá rÞ r r¾ r¿ rá ³, s ©r° r± z float | None)r½ rv Úupperr° r± rº c s t j||f||d|S )Nrâ )r« Úclip)r½ rv rã r° r± rÚ r r¾ r¿ rä ½, s zDataFrame.clip)r° r r± Úlimit_directionÚ
|
limit_arear¶ ) r½ r r° r r± rå ræ r¶ rº c
|
s" t jf |||||||d|S )N)r r° r r± rå ræ r¶ )r« Ú interpolate) r½ r r° r r± rå ræ r¶ rÚ r r¾ r¿ rç È, s ùøzDataFrame.interpolate©r± r° r )r± r° r rº c C s d S r» r¾ ©r½ ZcondrZ r± r° r r¾ r¾ r¿ r: ß, s
|
zDataFrame.where)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 s t j|||||dS ©Nrè )r« r: ré r r¾ r¿ r: - s ûc C s d S r» r¾ ré r¾ r¾ r¿ rë - s
|
zDataFrame.maskc 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 s t j|||||dS rê )r« rë ré r r¾ r¿ rë 8- s û)NNNNN)FT)F)...................)..................)NNNTTr NNNTNNNFr NNNN)TrL )r³ NN)..).) NNFr TNNTN)NNNFN)TNN)NT)Nrß TN)......).....)Nrî rï NNN)N)......................).......................)NNNTTr NNNTNNNFr TNTFNNFN)NTrÓ r NNNNNrù TTrú NrÈ N)NNNNN)TF)r )F)F)F)NN)NNN) r§ NNNNNNr N)N).).).)N).).).)N).).).)N)..)..).).).)N)N)Nrì )NFTFT)rì )rì )r rû r )r )N)N)ró FFr[ )NT)rd TNr )Nr NTTTFT)
|
NNNrF NFTrG FT)rû T)F)rû N)NNNr NT)ró r )N)Nr )r NTN)r )r FNr¾ )N)FFF)Nrd rJ rJ FN)Nrd rJ rJ FN) r~ NNNFFFr NFN)r )r ró F)Nró F)r Fr F)r F)r T)r TF)r TF)r FT)....)...)....)r¼ r Fr½ r¾ )NNFN)
|
r NNr NNNrà NF)Nr r N)Nr N)T)NN)r½ ).).).).).).)ßrÌ Ú
|
__module__Ú __qualname__Ú__doc__r Z_internal_names_setZ_typr r rw rÚ rÛ Z_HANDLED_TYPESr¶ Ú__annotations__r· r ÚpropertyrÀ rÁ rÖ rî r® rï rø rù rþ r r r r r2 r r rI r Zcommon_docstringZreturn_docstringr: r rH r; rK rW rY r\ rg rl Ú classmethodrz r r r~ r r rÙ r r´ rÁ rà rJ rÜ rÝ rè Ú_shared_doc_kwargsrí rò r/ r r£ r¥ r r ri rý rA r% r& r, r? r< r5 rP rV r` rZ r\ rd r[ r] rS rm rr r_ rt rk r! rp r? r} r r r
r rP r rR r r¡ rv r r r¦ r¬ r° rb r¨ rN r¸ rs r, r¿ rà r§ rÓ rk rÝ rl rÞ rä r4 r rú r r r r r r r r r Z_logical_methodr r' r r, r- r. r5 r= r± r r rC rE rK rQ rU r rô rZ Z _agg_summary_and_see_also_docZ_agg_examples_docr[ r` r² rc r$ ri r r¨ rt Ú
|
_merge_docrv r r r r rè r¦ r® r¯ r° r¶ r¡ rà r» rÁ rÉ rÍ rÒ rÓ r× rØ rÏ Z _AXIS_LENrÙ rÚ r Z AxisPropertyr´ r³ rq r8 ZplottingZ PlotAccessorrÛ Z
|
hist_frameÚhistZ boxplot_frameZboxplotr{ rµ rÜ rè rß rá rä rç r: rë Ú __classcell__r¾ r¾ r r¿ r© ê s>
|
ú [ ÿ#% 5 , ì8 ì8ú
|
ì:Nþÿ2
|
4 ÿTs û üD ýús õ"p ù \ ÿ ! ú1
|
þò, ü û ù ù ù nþúW è@ è@ ü èBV
|
þ ï2 K
|
ú e "
|
I , &$ ( , *ÿ
|
ÿ -$ $" & "i û$DD ø ø õ:ÿü
|
|
û* ýþô2þ÷8 þ÷8 þ÷8þ÷: þö:þö:þö:þö< þø2 þø2 þø2 þø6 + ýø( ýø( ýø,"û*Pù& ù&ù$ Mþ÷6 þ÷6 þ÷6þ÷4 zø2 ø2ø0 $þú(c ý ö2ö2
|
ö8\õ<õ<õ<õ>q ú k bÿÿø>& : K nu ú* û 3N ú ÿh ÷. þÿ $þÿ õ* 3ý C ù"ÿúI ü ÿÿ-û ú& û( û$
|
ýÿ ú" !ÿ [ û 3 ø* 1 ø(U ó>"ÿ{ ü t ü ú$ ^ø"O ( ÿ ÿ ÿ \ û& û( û( ú* 4 ú, ô< û"G ÿ 9ný ÿ
|
Kú,
|
ú,
|
ú, ú.
|
ú(
|
ú(
|
ú( ú* ýú0 þ÷2ýù( ýù( ýù(ýù*ýù( ýù( ýù(ýùzcollections.defaultdictr¹ c C s> t t¡}| ¡ D ]&\}}| ¡ D ]\}}||| |< q"q|S r» )rR rÕ rÙ r; )rÓ r r´ rJ r¥ rI r¾ r¾ r¿ rw O- s
|
|
rw r] r r )r r´ rº c
|
C sl | j |¡st|s | j ¡ S z| |¡j}W n8 tk
|
rf } z| j jsL|td|W 5 d }~X Y nX |S )Nz6incompatible index of inserted column with frame index) r´ rD rÏ rþ rÄ rb rØ r> rÞ )r r´ Zreindexed_valuerj r¾ r¾ r¿ rl W- s
|
ÿþrl )ïrí Ú
|
__future__r rR r Údatetimerk Úior r« rX Útextwrapr Útypingr r r r r
|
r r r r r r rE ÚnumpyrÚ r Zpandas._configr r Z pandas._libsr r r r Zpandas._libs.hashtabler Zpandas._libs.libr r r Zpandas._typingr r 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@ Z pandas.compatrA Zpandas.compat._optionalrB Zpandas.compat.numpyrC r rD Z pandas.errorsrE rF rG Zpandas.util._decoratorsrH rI rJ Zpandas.util._exceptionsrK Zpandas.util._validatorsrL rM rN Zpandas.core.dtypes.castrO rP rQ rR rS rT rU rV rW Zpandas.core.dtypes.commonrX rY rZ r[ r\ r] r^ r_ r` ra rb rc rd re rf rg rh ri Zpandas.core.dtypes.dtypesrj Zpandas.core.dtypes.missingrk rl Z pandas.corerm rn r¾ ro rp Zpandas.core.accessorrq r_ rr rs Z pandas.core.array_algos.takert Zpandas.core.arraylikeru Zpandas.core.arraysrv rw rx ry Zpandas.core.arrays.arrowrz Zpandas.core.arrays.sparser{ Zpandas.core.constructionr| r} r~ r Zpandas.core.genericr Zpandas.core.indexersr Zpandas.core.indexes.apir r r r
r r Zpandas.core.indexes.multir r Zpandas.core.indexingr r Zpandas.core.internalsr r Z"pandas.core.internals.constructionr r r r r r r r r r Zpandas.core.methodsr Zpandas.core.reshape.meltr Zpandas.core.seriesr Zpandas.core.shared_docsr Zpandas.core.sortingr r r Zpandas.io.commonr Zpandas.io.formatsr¡ r¢ r Zpandas.io.formats.infor£ r¤ r¥ Zpandas.plottingr8 rB r§ Z*pandas.core.interchange.dataframe_protocolr© rê rª Zpandas.core.resampler« r9 r rñ Z_numeric_only_docrò Z_add_numeric_operationsZadd_flex_arithmetic_methodsrw rl r¾ r¾ r¾ r¿ Ú<module> sH
|
4 ( , P 0 â# K 7
|
|
