U
|
¬ý°dî ã @ s d Z ddlmZ ddlZddlmZ ddlmZmZm Z m
|
Z
|
m Z m Z m Z mZmZmZmZmZ ddlZddlZddlZddlmZmZ ddlmZm Z m Z ddl m Z dd l m!Z! dd
|
l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZA dd lBmCZC dd lDmEZF dd lGmHZHmIZImJZJ ddlKmLZLmMZMmNZN ddlOmPZP ddlQmRZRmSZSmTZT ddlUmVZV ddlWmXZXmYZYmZZZm[Z[ ddl\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZg ddlhmiZi ddljmkZk ddllmmZmmnZnmoZompZp ddlqmrZrmsZsmtZumvZvmwZwmxZx ddlymzZz ddl{m|Z| ddl}m~Z~ ddlmZ dd lmZ dd lmZm
Z
dd lmZ dd lmZmZ dd lmZ dd!lmZmZmZmZmZmZ ddlm m msZ dd"lmZ dd#lmZmZ dd$lmZmZ dd%l m¡Z¡ dd&l¢m£Z£ dd'l¤m¥Z¥m¦Z¦ dd(l§m¨Z¨ dd)l©mªZª ddl«m¬ m m®Z¯ dd*l°m±Z±m²Z²m³Z³ ddl´ZµerÆdd+l"m¶Z¶m·Z·m¸Z¸ dd,l¹mºZº dd-l»m¼Z¼ dd.l½m¾Z¾ d/gZ¿d0d/d1d2d3d4d/d5d5d6d7d8 ZÀd9d: ZÁG d;d/ d/esjÂeZÃeà ġ ex Åeá dS )<zG
|
Data structure for 1-dimensional cross-sectional and time series data
|
é )Ú annotationsN)Údedent) ÚIOÚ TYPE_CHECKINGÚAnyÚCallableÚHashableÚIterableÚLiteralÚMappingÚSequenceÚUnionÚcastÚoverload)Ú
|
get_optionÚusing_copy_on_write)ÚlibÚ
|
propertiesÚreshape)ÚBlockValuesRefs)Úis_range_indexer) Ú AggFuncTypeÚ AlignJoinÚAnyAllÚ AnyArrayLikeÚ ArrayLikeÚAxisÚAxisIntÚCorrelationMethodÚDropKeepÚDtypeÚ DtypeBackendÚDtypeObjÚFilePathÚ FillnaOptionsÚ FrequencyÚ IgnoreRaiseÚ IndexKeyFuncÚ
|
IndexLabelÚLevelÚ
|
NaPositionÚQuantileInterpolationÚRenamerÚScalarÚ SingleManagerÚSortKindÚStorageOptionsÚTimedeltaConvertibleTypesÚTimestampConvertibleTypesÚ ValueKeyFuncÚ WriteBufferÚnpt)ÚPYPY)Úfunction)ÚChainedAssignmentErrorÚInvalidIndexErrorÚ_chained_assignment_msg)ÚAppenderÚ SubstitutionÚdoc)Úfind_stack_level)Úvalidate_ascendingÚvalidate_bool_kwargÚvalidate_percentile)Úastype_is_view)ÚLossySetitemErrorÚconvert_dtypesÚmaybe_box_nativeÚmaybe_cast_pointwise_result) Úensure_platform_intÚ is_dict_likeÚis_extension_array_dtypeÚ
|
is_integerÚ is_iteratorÚ is_list_likeÚis_numeric_dtypeÚis_object_dtypeÚ is_scalarÚ pandas_dtypeÚvalidate_all_hashable)Ú ABCDataFrame)Ú is_hashable)ÚisnaÚna_value_for_dtypeÚnotnaÚremove_na_arraylike)Ú
|
algorithmsÚbaseÚcommonÚmissingÚnanopsÚops)ÚCachedAccessor)Ú SeriesApply)ÚExtensionArray)ÚCategoricalAccessor)ÚSparseAccessor)Ú extract_arrayÚsanitize_array)ÚNDFrame)Údisallow_ndim_indexingÚ unpack_1tuple)Ú CombinedDatetimelikeProperties)Ú DatetimeIndexÚIndexÚ
|
MultiIndexÚ PeriodIndexÚ default_indexÚ ensure_index)Úmaybe_droplevels)Úcheck_bool_indexerÚcheck_dict_or_set_indexers)ÚSingleArrayManagerÚSingleBlockManager)Úselectn)Ú _shared_docs)Úensure_key_mappedÚnargsort)Ú StringMethods)Ú to_datetime)ÚINFO_DOCSTRINGÚ
|
SeriesInfoÚseries_sub_kwargs)Ú NumpySorterÚNumpyValueArrayLikeÚSuffixes©Ú DataFrame©Ú SeriesGroupBy)Ú ResamplerÚSeriesÚindexz{0 or 'index'}zXaxis : {0 or 'index'}
|
Unused. Parameter needed for compatibility with DataFrame.z[inplace : bool, default False
|
If True, performs operation inplace and returns None.ú
|
np.ndarrayÚ z
|
index : array-like, optional
|
New labels for the index. Preferably an Index object to avoid
|
duplicating data.
|
axis : int or str, optional
|
Unused.z
|
This differs from updating with ``.loc`` or ``.iloc``, which require
|
you to specify a location to update with some value.) ÚaxesÚklassÚaxes_single_argÚaxisÚinplaceÚuniqueÚ
|
duplicatedZ optional_byZoptional_mapperÚoptional_reindexÚ replace_ilocc s fdd}d j d|_ |S )z.
|
Install the scalar coercion methods.
|
c sP t | dkr>tjd j d j dtt d | jd S td d S )Né zCalling zX on a single element Series is deprecated and will raise a TypeError in the future. Use z(ser.iloc[0]) instead©Ú
|
stacklevelr z cannot convert the series to )ÚlenÚwarningsÚwarnÚ__name__Ú FutureWarningr> ÚilocÚ TypeError©Úself©Ú converter© úId:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/series.pyÚwrapperÜ s ûz _coerce_method.<locals>.wrapperÚ__)r )r r¢ r r r¡ Ú_coerce_method× s r¤ c s e Zd ZU dZdZeeejfZ de
|
d< dgZ de
|
d< dhe j B Z d d
|
d d hZejje jB eg B Zeejjjejjjd Zde
|
d< de
|
d< de
|
d< dOdddddddZdPd d d d d Zed!d"d#d$Zed%d"d&d'Zedd"d(d)Zed*d"d+d,Zed*d"d-d.Z edd"d/d0Z e j ddd1d2d0Z ed3d4 Z ed5d6 Z ed7d"d8d9Z!e"ejj#jed:d"d;d<Z#dQd d>d?d@dAZ$dBd"dCdDZ%dRdd dEdFdGZ&eeejfZ dSdHdIdEdJdKZ'e(e)Z*e(e+Z,edLd"dMdNZ-e"e j.jdTdPd dQdRdSZ.dUdPd dQdTdUZ/dVdBdVdWdXdYdZZ0dWd[dPd d\d]d^Z1d_d` Z2dadb Z3dcdddedfZ4dgd dhdidjZ5dXddkdldmZ6dd"dndoZ7dd"dpdqZ8dd"drdsZ9dd"dtduZ:dd"dvdwZ;dYdddxdydzZ<edd"d{d|Z=d}d~ Z>dd"ddZ?dd"ddZ@dd"ddZAdd" fd
d ZBdZddddd fdd ZCedd"ddZDd[ddd dddZEeFd\ddddddddddddddZGeFd]dddddddddd dddZGeFd^dddddddddddddZGd_deHjIddddddddddd dZGd d"d¡d¢ZJeFd`dd d£ddd¤d¤d d¥d¦d§ZKeFdad¨d d£ddd¤d¤dd¥d©d§ZKdbd«d d£dddddd¤d¤d£d¬ dd§ZKeLeMd® eNd¯ eOd°d±dcd³d dd´d£dµd¶d·ZPd¸d"d¹dºZQd»d"d¼d½ZReSfd¾d¿dÀdÁdÂZTeHjIfdddÃdÄdÅZUdddd dÆdÇdÈZVe"dÉe"eNdÊ eM dedPdddddddËdÌdÍdÎZWdÏdÐ ZXdfdd dÑdÒdÓZYd>d" fdÔdÕ ZZeFddddÖd×ddd dØdÙdÚZ[eFdddÛd×ddddØdÜdÚZ[eFddddÖd×dddÝdØdÞdÚZ[dßdddÖd×dddÝdØ fdàdÚZ[dgd×d dádâdãZ\dhdPdddädådæZ]didPdddädçdèZ^djdBd dédêdëZ_eFdkdìdídìdîdïdðZ`eFdldñdíd dîdòdðZ`eFdmdódídôdîdõdðZ`dndódídôdîdødðZ`dod dúd¤dìdûdüdýZadpd d¤d¤dìdÿd dZbeLd ddeOdddqdBd dddZcdrdBdìdd d
|
Zdd d d ddZedd Zfdd ZgeLejjhd ddsddddddd Zhdtddd d d Zidud d d!d"Zjd#dd$d%d&d'ZkeLeNd( d)eMd® ddvd dPddd+d,d- fd.d/ Zldwd0d1dd d2d3d4Zmd d"d5d6Znd7dd d8d9ZoeFdddddddd:dPd;dd d dd<d d=d>d?ZpeFddddddd@dPd;dd d dd<dd=dAd?ZpdOdddBdCddd:dPd;dd d dd<dÝd=dDd?ZpeFdddddddddEdPddFddGdHdddIddJ
|
dKdLZqeFddddddddddM dPddFddGdHdddId dJ
|
dNdLZqeFddddddddddM dPddFddGdHdddIdÝdJ
|
dOdLZqdOddddBdCddddM dPddFddGdHdddIdÝdJ
|
fdPdLZqdxdPdGdd dQdRdSZrdydBdUd dVdWdXZsdzdBd d dVdYdZZteLeMd® eOd[eOd\d]d{dddd d`dadbZudcd d?dddeZvd|dd dfdgdhZwd}ddddidjdkZxd~dldmd dndodpZydd d"dqdrZzeOdsZ{eOdtZ|eLeNdu eMd® eMdv e{e|dwddPdxdydzZ}e}Z~eFddddd{dPddddd|d}d~ZeFdddddPddddd|dd~ZeLe jfeMddPddddd|dd~ZeLeNd eMd® eMdv d
dddPd,dddZddddd,dddZdOddddd dPdddddZd ddd dddZdd"ddZeLe j
eMd® eMd ddd ddddddd¤dPdd d fd d¡ Z
eFd
ddddd¢d£ddddd¤dd¥d¦d§ZeFddddddd¨d£ddddd¤d d¥d©d§ZeFddddddd¨d£ddddd¤dÝd¥dªd§Zdddddd«d¨d£ddddd¤dÝd¥ fd¬d§Ze"def eMdddd®e"e jjdOdd¯dPdd d° fd±d²ZeLe jeMd® eMd³ d´dddddddddµdd£ddd¶d¤d d· fd¸d¹ZeLe jeHjIfeHjIdOdddºd d»dPdddÝd¼ fd½d¾ZeFddddddd¿ddPddddd¤ddÀdÁdÂZeFddddddddÃddPddddd¤d dÀdÄdÂZeFddddddddÃddPddddd¤dÝdÀdÅdÂZddOdddddÆdÃddPddddd¤dÝdÀ fdÇdÂZeFdddddddÈdÉdddd¤dÊd dËdÌdÍZeFddddddÎdÉdddd¤dÊddËdÏdÍZeFdddddddÈdÉdddd¤dÊdÝdËdÐdÍZeLe jfeMdddddddÈdÉdddd¤dÊdÝdË fdÑdÍZddWdÒ fdÓdÔ ZeFddddddÕdd¤ddÖd d×dØdÙZeFdddddÚdd¤ddÖdd×dÛdÙZeLe jeMd® eMdÜ eMdÝ dÞdeHjIfdddeHjIdÕdd¤ddÖdÝd× fdßdÙZeLefeddd³d¤dàdddádâdãZd ddädådæZeLe jeMd® dddBdPdd dç fdèdé ZddddBdêdëdìZd d"dídîZddðd dñdòdóZdddddddõd död÷døZeLe jeMd® dd d"dùdúZeLe jeMd® dd d" fdûdü ZeLe jeMd® dd d" fdýdþ ZeLe jeMd® dd d" fdÿd ZeFddddddPdddd dddZeFdddddPdddddddZdOdddddPddddÝdddZeLe jfeMdd dd£ddd d
|
fd d ZeLe jfeMddPd£d£d d£ddddddd fdd Zdddd dddZdd£dd dddZ eFddddd d dd dÊd d d d!Z¡eFdddd"d dd dÊdd d#d!Z¡eFddddd d dd dÊdÝd d$d!Z¡ddddd d dd dÊdÝd fd%d!Z¡eFddddd d dd dÊd d d&d'Z¢eFdddd"d dd dÊdd d(d'Z¢eFddddd d dd dÊdÝd d)d'Z¢ddddd d dd dÊdÝd fd*d'Z¢dddd+d dddÝd, fd-d.Z£ddOdddddd/d d dPd¤dd£d£d£dÝd0 fd1d2Z¤eFddddd3dddd d4d5d6Z¥eFd ddd7ddddd4d8d6Z¥eFd¡dddd3ddddÝd4d9d6Z¥eHjIfdddd3ddddÝd4 fd:d6Z¥eFd¢dddd3dddd d4d;d<Z¦eFd£ddd7ddddd4d=d<Z¦eFd¤dddd3ddddÝd4d>d<Z¦eHjIfdddd3ddddÝd4 fd?d<Z¦dgZ§d@e
|
dA< e¨e§Z©dOZªdBe
|
dC< dZ«dDe
|
dE< e¬jdOdFdGZ®e¯d e°Z±e¯d e²Z³e¯d
|
e´Zµe¯dHe¶j·j¸Z¹e¯d eºZ»e¶j·j¼Z½dIdJ Z¾dKdL Z¿dMdN ZÀ ZÁS (¥ r
a4
|
One-dimensional ndarray with axis labels (including time series).
|
|
Labels need not be unique but must be a hashable type. The object
|
supports both integer- and label-based indexing and provides a host of
|
methods for performing operations involving the index. Statistical
|
methods from ndarray have been overridden to automatically exclude
|
missing data (currently represented as NaN).
|
|
Operations between Series (+, -, /, \*, \*\*) align values based on their
|
associated index values-- they need not be the same length. The result
|
index will be the sorted union of the two indexes.
|
|
Parameters
|
----------
|
data : array-like, Iterable, dict, or scalar value
|
Contains data stored in Series. If data is a dict, argument order is
|
maintained.
|
index : array-like or Index (1d)
|
Values must be hashable and have the same length as `data`.
|
Non-unique index values are allowed. Will default to
|
RangeIndex (0, 1, 2, ..., n) if not provided. If data is dict-like
|
and index is None, then the keys in the data are used as the index. If the
|
index is not None, the resulting Series is reindexed with the index values.
|
dtype : str, numpy.dtype, or ExtensionDtype, optional
|
Data type for the output Series. If not specified, this will be
|
inferred from `data`.
|
See the :ref:`user guide <basics.dtypes>` for more usages.
|
name : Hashable, default None
|
The name to give to the Series.
|
copy : bool, default False
|
Copy input data. Only affects Series or 1d ndarray input. See examples.
|
|
Notes
|
-----
|
Please reference the :ref:`User Guide <basics.series>` for more information.
|
|
Examples
|
--------
|
Constructing Series from a dictionary with an Index specified
|
|
>>> d = {'a': 1, 'b': 2, 'c': 3}
|
>>> ser = pd.Series(data=d, index=['a', 'b', 'c'])
|
>>> ser
|
a 1
|
b 2
|
c 3
|
dtype: int64
|
|
The keys of the dictionary match with the Index values, hence the Index
|
values have no effect.
|
|
>>> d = {'a': 1, 'b': 2, 'c': 3}
|
>>> ser = pd.Series(data=d, index=['x', 'y', 'z'])
|
>>> ser
|
x NaN
|
y NaN
|
z NaN
|
dtype: float64
|
|
Note that the Index is first build with the keys from the dictionary.
|
After this the Series is reindexed with the given Index values, hence we
|
get all NaN as a result.
|
|
Constructing Series from a list with `copy=False`.
|
|
>>> r = [1, 2]
|
>>> ser = pd.Series(r, copy=False)
|
>>> ser.iloc[0] = 999
|
>>> r
|
[1, 2]
|
>>> ser
|
0 999
|
1 2
|
dtype: int64
|
|
Due to input data type the Series has a `copy` of
|
the original data even though `copy=False`, so
|
the data is unchanged.
|
|
Constructing Series from a 1d ndarray with `copy=False`.
|
|
>>> r = np.array([1, 2])
|
>>> ser = pd.Series(r, copy=False)
|
>>> ser.iloc[0] = 999
|
>>> r
|
array([999, 2])
|
>>> ser
|
0 999
|
1 2
|
dtype: int64
|
|
Due to input data type the Series has a `view` on
|
the original data, so
|
the data is changed as well.
|
Zseriesr Ú_nameÚnamez list[str]Ú _metadatar ÚdtÚcatÚstrÚsparse)r= r. Ú_mgrz Callable[[Series, Any], Series]ÚdivZrdivNFz Dtype | Nonez bool | NoneÚboolÚNone)ÚdtypeÚcopyÚfastpathÚreturnc C sB t |ttfrj|d krj|d krj|dks.|d krjt r@|jdd}t | |¡ |r`t | d|¡ n|| _ d S t |t
|
t j fr¨|dk r¨t r¨|d ks t |jt|r¨| ¡ }|d kr´d}|rBt |ttfsütd}|dkræt ||¡}n|dkrút ||¡}nt r|s|jdd}|r$| ¡ }t | d|¡ t | |¡ d S t |trht rh|sh|jdd}t ||t| ¡}|d k rt|}|d k r | |¡}|d krê|d k r¸|ntd}t|sÔ|d k rætt|dd}ng }t |trþtd d }t |t rN|d k r&|j |dd
|
}t r<|j }|j }n
|
|j ¡ }d}nt |t j rrt|jr^t d nìt |t!r¸|d kr|j"}|j#jdd}n|j$||d
|
}d}|j#}n¦t%|rÞ| &|||¡\}}d }d}nt |ttfr |d kr |j"}n |j" '|¡r|r^t(d n@t |t
|
r,n2t) *|¡}t+|r^t|s^|d kr^t t¡}|d krt+|sx|g}tt|}nt+|rt) ,||¡ t |ttfrØ|d k rÈ|j |d |d}n|r | ¡ }nHt-||||}td}|dkr
|
tj|||d}n|dkr t ||¡}t | |¡ || _ | .d|¡ d S )NF©Údeepr¥ zmode.data_managerÚblockÚarrayr ©Úcompatz8initializing a Series from a MultiIndex is not supported©r± zVCannot construct a Series from an ndarray with compound dtype. Use DataFrame instead.zkCannot pass both SingleBlockManager `data` argument and a different `index` argument. `copy` must be False.Úignore)r° Úerrorsr± )Úrefs)/Ú
|
isinstancers rr r r± re Ú__init__ÚobjectÚ __setattr__r¦ r` ÚnpÚndarrayrB r° rP r Z
|
from_arrayÚibaseZmaybe_extract_nameÚtypern Z_validate_dtyperm r rU rk ÚNotImplementedErrorrj ÚastypeÚ _referencesÚ_valuesÚ
|
ValueErrorr
r r¬ ÚreindexrH Ú
|
_init_dictÚequalsÚAssertionErrorÚcomZmaybe_iterable_to_listrL Zrequire_length_matchrd Z _set_axis) r Údatar r° r¦ r± r² Úmanagerr½ r r r¡ r¿ p sÜ
|
ÿþýüü
|
|
|
|
ÿ
|
|
ÿ
|
|
|
ÿ
|
|
|
|
|
|
|
|
|
zSeries.__init__z Index | NonezDtypeObj | None©r r° c C s |r t | ¡ }t| ¡ }nB|dk rRt|s6|dk rHtt|dd}ng }|}ntdg }}t|||d}|r|dk r|j |dd}|j
|
|j fS )aM
|
Derive the "_mgr" and "index" attributes of a new Series from a
|
dictionary input.
|
|
Parameters
|
----------
|
data : dict or dict-like
|
Data used to populate the new Series.
|
index : Index or None, default None
|
Index for the new Series: if None, use dict keys.
|
dtype : np.dtype, ExtensionDtype, or None, default None
|
The dtype for the new Series: if None, infer from data.
|
|
Returns
|
-------
|
_data : BlockManager for the new Series
|
index : index for the new Series
|
NFr¸ r rÒ rº ) ÚtupleÚkeysÚlistÚvaluesr rU rP rm r
rË r¬ r )r rÐ r r° rÔ rÖ Úsr r r¡ rÌ s zSeries._init_dictzCallable[..., Series])r³ c C s t S ©N)r
r r r r¡ Ú _constructor> s zSeries._constructorzCallable[..., DataFrame]c C s ddl m} |S )z}
|
Used when a manipulation result has one higher dimension as the
|
original, such as Series.to_frame()
|
r r )Úpandas.core.framer )r r r r r¡ Ú_constructor_expanddimB s z Series._constructor_expanddimc C s | j jS rØ )r¬ Ú _can_hold_nar r r r¡ rÜ M s zSeries._can_hold_nar" c C s | j jS )z´
|
Return the dtype object of the underlying data.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.dtype
|
dtype('int64')
|
)r¬ r° r r r r¡ r° R s z Series.dtypec C s | j S )zµ
|
Return the dtype object of the underlying data.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.dtypes
|
dtype('int64')
|
©r° r r r r¡ Údtypes_ s z Series.dtypesc C s | j S )aN
|
Return the name of the Series.
|
|
The name of a Series becomes its index or column name if it is used
|
to form a DataFrame. It is also used whenever displaying the Series
|
using the interpreter.
|
|
Returns
|
-------
|
label (hashable object)
|
The name of the Series, also the column name if part of a DataFrame.
|
|
See Also
|
--------
|
Series.rename : Sets the Series name when given a scalar input.
|
Index.name : Corresponding Index property.
|
|
Examples
|
--------
|
The Series name can be set initially when calling the constructor.
|
|
>>> s = pd.Series([1, 2, 3], dtype=np.int64, name='Numbers')
|
>>> s
|
0 1
|
1 2
|
2 3
|
Name: Numbers, dtype: int64
|
>>> s.name = "Integers"
|
>>> s
|
0 1
|
1 2
|
2 3
|
Name: Integers, dtype: int64
|
|
The name of a Series within a DataFrame is its column name.
|
|
>>> df = pd.DataFrame([[1, 2], [3, 4], [5, 6]],
|
... columns=["Odd Numbers", "Even Numbers"])
|
>>> df
|
Odd Numbers Even Numbers
|
0 1 2
|
1 3 4
|
2 5 6
|
>>> df["Even Numbers"].name
|
'Even Numbers'
|
)r¥ r r r r¡ r¦ m s 0z Series.name)Úvaluer³ c C s* t |t| j dd t | d|¡ d S )Nz.name)Z
|
error_namer¥ )rQ rÅ r rÀ rÁ )r rß r r r¡ r¦ s c C s
|
| j ¡ S )a¹
|
Return Series as ndarray or ndarray-like depending on the dtype.
|
|
.. warning::
|
|
We recommend using :attr:`Series.array` or
|
:meth:`Series.to_numpy`, depending on whether you need
|
a reference to the underlying data or a NumPy array.
|
|
Returns
|
-------
|
numpy.ndarray or ndarray-like
|
|
See Also
|
--------
|
Series.array : Reference to the underlying data.
|
Series.to_numpy : A NumPy array representing the underlying data.
|
|
Examples
|
--------
|
>>> pd.Series([1, 2, 3]).values
|
array([1, 2, 3])
|
|
>>> pd.Series(list('aabc')).values
|
array(['a', 'a', 'b', 'c'], dtype=object)
|
|
>>> pd.Series(list('aabc')).astype('category').values
|
['a', 'a', 'b', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
|
Timezone aware datetime data is converted to UTC:
|
|
>>> pd.Series(pd.date_range('20130101', periods=3,
|
... tz='US/Eastern')).values
|
array(['2013-01-01T05:00:00.000000000',
|
'2013-01-02T05:00:00.000000000',
|
'2013-01-03T05:00:00.000000000'], dtype='datetime64[ns]')
|
)r¬ Zexternal_valuesr r r r¡ rÖ ¤ s (z Series.valuesc C s
|
| j ¡ S )a
|
Return the internal repr of this data (defined by Block.interval_values).
|
This are the values as stored in the Block (ndarray or ExtensionArray
|
depending on the Block class), with datetime64[ns] and timedelta64[ns]
|
wrapped in ExtensionArrays to match Index._values behavior.
|
|
Differs from the public ``.values`` for certain data types, because of
|
historical backwards compatibility of the public attribute (e.g. period
|
returns object ndarray and datetimetz a datetime64[ns] ndarray for
|
``.values`` while it returns an ExtensionArray for ``._values`` in those
|
cases).
|
|
Differs from ``.array`` in that this still returns the numpy array if
|
the Block is backed by a numpy array (except for datetime64 and
|
timedelta64 dtypes), while ``.array`` ensures to always return an
|
ExtensionArray.
|
|
Overview:
|
|
dtype | values | _values | array |
|
----------- | ------------- | ------------- | ------------- |
|
Numeric | ndarray | ndarray | PandasArray |
|
Category | Categorical | Categorical | Categorical |
|
dt64[ns] | ndarray[M8ns] | DatetimeArray | DatetimeArray |
|
dt64[ns tz] | ndarray[M8ns] | DatetimeArray | DatetimeArray |
|
td64[ns] | ndarray[m8ns] | TimedeltaArray| ndarray[m8ns] |
|
Period | ndarray[obj] | PeriodArray | PeriodArray |
|
Nullable | EA | EA | EA |
|
|
)r¬ Zinternal_valuesr r r r¡ rÉ Î s zSeries._valueszBlockValuesRefs | Nonec C s t | jtrd S | jjjS rØ )r¾ r¬ rr Ú_blockr½ r r r r¡ rÈ ð s zSeries._referencesr` c C s
|
| j ¡ S rØ )r¬ Z array_valuesr r r r¡ r· ÷ s z Series.arrayÚCr )Úorderr³ c C s, | j j|d}t|tjr(t r(d|j_|S )a%
|
Return the flattened underlying data as an ndarray or ExtensionArray.
|
|
Returns
|
-------
|
numpy.ndarray or ExtensionArray
|
Flattened data of the Series.
|
|
See Also
|
--------
|
numpy.ndarray.ravel : Return a flattened array.
|
)râ F)rÉ Úravelr¾ r rà r ÚflagsÚ writeable)r râ Úarrr r r¡ rã ý s z Series.ravelÚintc C s
|
t | jS )z2
|
Return the length of the Series.
|
)r r¬ r r r r¡ Ú__len__ s zSeries.__len__)r° r³ c C s` | j |¡}| j|| jdd}t|jtrRt rR|jj}t d| j
|
|_ |j |¡ |j | ddS )aþ
|
Create a new view of the Series.
|
|
This function will return a new Series with a view of the same
|
underlying values in memory, optionally reinterpreted with a new data
|
type. The new data type must preserve the same size in bytes as to not
|
cause index misalignment.
|
|
Parameters
|
----------
|
dtype : data type
|
Data type object or one of their string representations.
|
|
Returns
|
-------
|
Series
|
A new Series object as a view of the same data in memory.
|
|
See Also
|
--------
|
numpy.ndarray.view : Equivalent numpy function to create a new view of
|
the same data in memory.
|
|
Notes
|
-----
|
Series are instantiated with ``dtype=float64`` by default. While
|
``numpy.ndarray.view()`` will return a view with the same data type as
|
the original array, ``Series.view()`` (without specified dtype)
|
will try using ``float64`` and may fail if the original data type size
|
in bytes is not the same.
|
|
Examples
|
--------
|
>>> s = pd.Series([-2, -1, 0, 1, 2], dtype='int8')
|
>>> s
|
0 -2
|
1 -1
|
2 0
|
3 1
|
4 2
|
dtype: int8
|
|
The 8 bit signed integer representation of `-1` is `0b11111111`, but
|
the same bytes represent 255 if read as an 8 bit unsigned integer:
|
|
>>> us = s.view('uint8')
|
>>> us
|
0 254
|
1 255
|
2 0
|
3 1
|
4 2
|
dtype: uint8
|
|
The views share the same underlying values:
|
|
>>> us[0] = 128
|
>>> s
|
0 -128
|
1 -1
|
2 0
|
3 1
|
4 2
|
dtype: int8
|
F©r r± r Úview©Úmethod)r· rê rÙ r r¾ r¬ rs r rà r rÈ r½ Z add_referenceÚ __finalize__)r r° Ú
|
res_valuesZres_serZblkr r r¡ rê s D z Series.viewznpt.DTypeLike | Noner c C s< | j }tj||d}t r8t|j|jr8| ¡ }d|j_|S )a
|
Return the values as a NumPy array.
|
|
Users should not call this directly. Rather, it is invoked by
|
:func:`numpy.array` and :func:`numpy.asarray`.
|
|
Parameters
|
----------
|
dtype : str or numpy.dtype, optional
|
The dtype to use for the resulting NumPy array. By default,
|
the dtype is inferred from the data.
|
|
Returns
|
-------
|
numpy.ndarray
|
The values in the series converted to a :class:`numpy.ndarray`
|
with the specified `dtype`.
|
|
See Also
|
--------
|
array : Create a new array from data.
|
Series.array : Zero-copy view to the array backing the Series.
|
Series.to_numpy : Series method for similar behavior.
|
|
Examples
|
--------
|
>>> ser = pd.Series([1, 2, 3])
|
>>> np.asarray(ser)
|
array([1, 2, 3])
|
|
For timezone-aware data, the timezones may be retained with
|
``dtype='object'``
|
|
>>> tzser = pd.Series(pd.date_range('2000', periods=2, tz="CET"))
|
>>> np.asarray(tzser, dtype="object")
|
array([Timestamp('2000-01-01 00:00:00+0100', tz='CET'),
|
Timestamp('2000-01-02 00:00:00+0100', tz='CET')],
|
dtype=object)
|
|
Or the values may be localized to UTC and the tzinfo discarded with
|
``dtype='datetime64[ns]'``
|
|
>>> np.asarray(tzser, dtype="datetime64[ns]") # doctest: +ELLIPSIS
|
array(['1999-12-31T23:00:00.000000000', ...],
|
dtype='datetime64[ns]')
|
rÝ F) rÉ r Úasarrayr rB r° rê rä rå )r r° rÖ ræ r r r¡ Ú __array__e s /zSeries.__array__z list[Index]c C s | j gS )z7
|
Return a list of the row axis labels.
|
©r r r r r¡ r ¥ s z Series.axesr r )r r³ c K st t d|¡ t|}|jdkr>t r>t|t| r>| jd dS | j |¡}| j
|
|¡}| j ||dd}|j | ddS )Nr r r´ T)r r² Útakerë ) ÚnvZ validate_takerG Úndimr r r r± r rò rÉ rÙ rí )r Úindicesr ÚkwargsÚ new_indexÚ
|
new_valuesÚresultr r r¡ rò ¯ s ÿþ ý z Series.takec C s | j ||dS )af
|
Internal version of the `take` method that sets the `_is_copy`
|
attribute to keep track of the parent dataframe (using in indexing
|
for the SettingWithCopyWarning). For Series this does the same
|
as the public take (it never sets `_is_copy`).
|
|
See the docstring of `take` for full explanation of the parameters.
|
)rõ r )rò )r rõ r r r r¡ Ú_take_with_is_copy s zSeries._take_with_is_copyr r )Úir r³ c C s
|
| j | S )zÕ
|
Return the i-th value or values in the Series by location.
|
|
Parameters
|
----------
|
i : int
|
|
Returns
|
-------
|
scalar (int) or Series (slice, sequence)
|
)rÉ )r rû r r r r¡ Ú_ixsÍ s z Series._ixszslice | np.ndarray)Úslobjr r³ c C s
|
| |¡S rØ )Ú _get_values)r rý r r r r¡ Ú_sliceÛ s z Series._slicec
|
C s t | t || ¡}|tkr | S t|}t|ttfr>t|}t |rX| j
|
j rX| j | S |rf| |¡S t|r¾z| |¡}|W S tttfk
|
r¼ t|tr¸t| j
|
tr¸| |¡ Y S Y nX t|rÎt|}t |¡ rþt| j
|
|}tj|td}| |¡S | |¡S )NrÝ ) rq rÏ Úapply_if_callableÚEllipsisrO r¾ rÕ rÓ rg rJ r Ú _should_fallback_to_positionalrÉ Ú
|
_get_valuerS ÚKeyErrorr r9 rk Ú_get_values_tuplerK Úis_bool_indexerrp r rï r® rþ Ú _get_with)r ÚkeyZ key_is_scalarrù r r r¡ Ú __getitem__à s2
|
|
|
|
zSeries.__getitem__c C sÊ t |tr$| jj|dd}| |¡S t |tr8tdn&t |trL| |¡S t |s^| j
|
| S t |t t j tttfs|t |}t |tr|j}ntj|dd}|dkrÀ| jjs¶| j
|
| S | j| S | j
|
| S )NÚgetitem©ÚkindzWIndexing a Series with DataFrame is not supported, use the appropriate DataFrame columnF©ÚskipnaÚinteger)r¾ Úslicer Ú_convert_slice_indexerrÿ rR r rÓ r rL ÚlocrÕ r rà r` r
rj Z inferred_typer Ú infer_dtyper r )r r rý Úkey_typer r r¡ r s*
|
|
|
ÿ
|
|
|
|
|
|
zSeries._get_withrÓ )r c C s t j| r&t | j| ¡}t| |S t| jts:t d| j
|
|¡\}}| j | j| |dd}t r~t|t r~|j | j¡ | | ¡S )Nú0key of type tuple not found and not a MultiIndexFré )rÏ Zany_noner rï rÉ rf r¾ r rk r Z get_loc_levelrÙ r r r¬ Úadd_referencesrí )r r rù Úindexerr÷ Únew_serr r r¡ r 3 s
|
zSeries._get_values_tuplez slice | npt.NDArray[np.bool_])r r³ c C s | j |¡}| |¡ | ¡S rØ )r¬ Z getitem_mgrrÙ rí )r r Znew_mgrr r r¡ rþ G s zSeries._get_values)Útakeablec C s |r| j | S | j |¡}t|r,| j | S t| jtr´| j}| j | }t|dkrf|jdkrf|d S || }t||}| j ||| j
|
dd}t rªt|t rª|j | j ¡ | | ¡S | j| S dS )zü
|
Quickly retrieve single value at passed index label.
|
|
Parameters
|
----------
|
label : object
|
takeable : interpret the index as indexers, default False
|
|
Returns
|
-------
|
scalar value
|
r r F©r r¦ r± N)rÉ r Úget_locrJ r¾ rk r Únlevelsro rÙ r¦ r r r¬ r rí r )r Úlabelr r Úmirø r÷ r r r r¡ r K s,
|
|
|
|
ÿ
|
zSeries._get_valuec C s2 t s(t r(t | ¡dkr(tjttdd t| t
|
|| ¡}| ¡ }|t krTt d }t|t rz| jj|dd}| ||¡S z| ||¡ W n tk
|
rÖ t|rÆ| jjs¸|| j|< qÐ| ||¡ n
|
|| j|< Y nF tttfk
|
r
|
| j |¡}| ||¡ Y n tk
|
r } zòt|t r@t| jt s@td|t |¡rþt | j|}t j!|t"d}t#|r¼t$|t$| kr¼t|t%s¼t&| j's¼| (¡ d }| ||¡ W Y ¢Vd S z| j)| |d d
|
W n tk
|
rò || j*|< Y nX W Y ¢d S | +||¡ W 5 d }~X Y nX |r.| j,d d
|
d S ) Né é r r
|
r r rÝ r T©r )-r6 r ÚsysÚ getrefcountr r r: r8 rq rÏ r Ú%_check_is_chained_assignment_possibler r r¾ r r Ú _set_valuesÚ_set_with_enginer rJ r r r rÊ rC r r9 rÓ rk r rp r rï r® rL r r
rN r° ZnonzeroZ_wherer Ú _set_withÚ_maybe_update_cacher)r r rß Zcacher_needs_updatingr Úerrr r r¡ Ú __setitem__t sn
|
ÿ
|
ÿþ ÿþýü
|
|
zSeries.__setitem__c C s | j |¡}| j ||¡ d S rØ )r r r¬ Zsetitem_inplace)r r rß r r r r¡ r& Å s zSeries._set_with_enginec C sh t |trtt|r t|}| jjs4| ||¡ n0tj |dd}|dkrX|
|
||¡ n | ||¡ d S )NFr r ) r¾ rÓ rÎ rK rÕ r r Ú _set_labelsr r r% )r r rß r r r r¡ r' Ë s zSeries._set_withc C sH t |¡}| j |¡}|dk}| ¡ r8t|| d| ||¡ d S )Néÿÿÿÿz not in index)rÏ Zasarray_tuplesafer Z get_indexerÚanyr r% )r r rß r Úmaskr r r¡ r+ â s
|
zSeries._set_labelsc C s2 t |ttfr|j}| jj||d| _| ¡ d S )N)r rß )r¾ rj r
rÉ r¬ Úsetitemr( )r r rß r r r¡ r% ê s zSeries._set_values)r r³ c C sL |s8z| j |¡}W q< tk
|
r4 || j|< Y dS X n|}| ||¡ dS )a
|
Quickly set single value at passed label.
|
|
If label is not contained, a new object is created with the label
|
placed at the end of the result index.
|
|
Parameters
|
----------
|
label : object
|
Partial indexing with MultiIndex not allowed.
|
value : object
|
Scalar value.
|
takeable : interpret the index as indexers, default False
|
N)r r r r r% )r r rß r r r r r¡ Ú
|
_set_valueñ s
|
|
zSeries._set_valuec C s t | dddk S )z3Return boolean indicating if self is cached or not.Ú_cacherN©Úgetattrr r r r¡ Ú
|
_is_cached s zSeries._is_cachedc C s" t | dd}|dk r |d }|S )zreturn my cacher or Noner1 Nr r2 )r Úcacherr r r¡ Ú _get_cacher s
|
zSeries._get_cacherc C s t | dr| `dS )z#
|
Reset the cacher.
|
r1 N)Úhasattrr1 r r r r¡ Ú _reset_cacher s
|
zSeries._reset_cacherc C s t r
|
dS |t |¡f| _dS )zc
|
Set the _cacher attribute on the calling object with a weakref to
|
cacher.
|
N)r ÚweakrefÚrefr1 )r Úitemr5 r r r¡ Ú_set_as_cached" s zSeries._set_as_cachedc C s d S rØ r r r r r¡ Ú_clear_item_cache+ s zSeries._clear_item_cachec s> | j r4| jr4| ¡ }|dk r0|jr0| jddd dS t ¡ S )zK
|
See NDFrame._check_is_chained_assignment_possible.__doc__
|
NZreferentT)ÚtÚforce)Z_is_viewr4 r6 Ú_is_mixed_typeZ_check_setitem_copyÚsuperr$ )r r: ©Ú __class__r r¡ r$ / s z,Series._check_is_chained_assignment_possibleT)ÚclearÚverify_is_copyr r³ c s t r
|
dS t| dd}|dk r| jdks,t|d }|dkrD| `nDt| t|krv| j|jkrv|j|d | |d n|j
|
|d d¡ t j |||d dS )z:
|
See NDFrame._maybe_update_cacher.__doc__
|
Nr1 r r r! )rD rE r ) r r3 rô rÎ r1 r r¦ ÚcolumnsZ_maybe_cache_changedZ _item_cacheÚpoprA r( )r rD rE r r5 r: rB r r¡ r( : s
|
ÿzSeries._maybe_update_cacherc C s dS )NFr r r r r¡ r@ ^ s zSeries._is_mixed_typezint | Sequence[int])Úrepeatsr r³ c C sB t dd|i¡ | j |¡}| j |¡}| j||ddj| ddS )aº
|
Repeat elements of a Series.
|
|
Returns a new Series where each element of the current Series
|
is repeated consecutively a given number of times.
|
|
Parameters
|
----------
|
repeats : int or array of ints
|
The number of repetitions for each element. This should be a
|
non-negative integer. Repeating 0 times will return an empty
|
Series.
|
axis : None
|
Unused. Parameter needed for compatibility with DataFrame.
|
|
Returns
|
-------
|
Series
|
Newly created Series with repeated elements.
|
|
See Also
|
--------
|
Index.repeat : Equivalent function for Index.
|
numpy.repeat : Similar method for :class:`numpy.ndarray`.
|
|
Examples
|
--------
|
>>> s = pd.Series(['a', 'b', 'c'])
|
>>> s
|
0 a
|
1 b
|
2 c
|
dtype: object
|
>>> s.repeat(2)
|
0 a
|
0 a
|
1 b
|
1 b
|
2 c
|
2 c
|
dtype: object
|
>>> s.repeat([1, 2, 3])
|
0 a
|
1 b
|
1 b
|
2 c
|
2 c
|
2 c
|
dtype: object
|
r r Fré Úrepeatrë )ró Zvalidate_repeatr rI rÉ rÙ rí )r rH r r÷ rø r r r¡ rI b s 3 ÿz Series.repeat.)Údropr¦ r Úallow_duplicatesr( zLiteral[False]r) r )ÚlevelrJ r¦ r rK r³ c C s d S rØ r ©r rL rJ r¦ r rK r r r¡ Ú reset_index s
|
zSeries.reset_index)r¦ r rK z Literal[True]c C s d S rØ r rM r r r¡ rN ¨ s
|
)rJ r¦ rK c C s d S rØ r rM r r r¡ rN ´ s
|
zDataFrame | Series | Nonec
|
s
|
t |d}|r¾tt }|dk rjt|ttfs8|g}n|} fdd|D }t| jjk rj j |¡}|rv| _nFt r j
|
dd}||_|j ddS j j
|
¡ |dd j ddS nH|rÌtd
|
n:|tjkrì jdkræd }n j} |¡} | j|||d S dS ) au
|
Generate a new DataFrame or Series with the index reset.
|
|
This is useful when the index needs to be treated as a column, or
|
when the index is meaningless and needs to be reset to the default
|
before another operation.
|
|
Parameters
|
----------
|
level : int, str, tuple, or list, default optional
|
For a Series with a MultiIndex, only remove the specified levels
|
from the index. Removes all levels by default.
|
drop : bool, default False
|
Just reset the index, without inserting it as a column in
|
the new DataFrame.
|
name : object, optional
|
The name to use for the column containing the original Series
|
values. Uses ``self.name`` by default. This argument is ignored
|
when `drop` is True.
|
inplace : bool, default False
|
Modify the Series in place (do not create a new object).
|
allow_duplicates : bool, default False
|
Allow duplicate column labels to be created.
|
|
.. versionadded:: 1.5.0
|
|
Returns
|
-------
|
Series or DataFrame or None
|
When `drop` is False (the default), a DataFrame is returned.
|
The newly created columns will come first in the DataFrame,
|
followed by the original Series values.
|
When `drop` is True, a `Series` is returned.
|
In either case, if ``inplace=True``, no value is returned.
|
|
See Also
|
--------
|
DataFrame.reset_index: Analogous function for DataFrame.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3, 4], name='foo',
|
... index=pd.Index(['a', 'b', 'c', 'd'], name='idx'))
|
|
Generate a DataFrame with default index.
|
|
>>> s.reset_index()
|
idx foo
|
0 a 1
|
1 b 2
|
2 c 3
|
3 d 4
|
|
To specify the name of the new column use `name`.
|
|
>>> s.reset_index(name='values')
|
idx values
|
0 a 1
|
1 b 2
|
2 c 3
|
3 d 4
|
|
To generate a new Series with the default set `drop` to True.
|
|
>>> s.reset_index(drop=True)
|
0 1
|
1 2
|
2 3
|
3 4
|
Name: foo, dtype: int64
|
|
The `level` parameter is interesting for Series with a multi-level
|
index.
|
|
>>> arrays = [np.array(['bar', 'bar', 'baz', 'baz']),
|
... np.array(['one', 'two', 'one', 'two'])]
|
>>> s2 = pd.Series(
|
... range(4), name='foo',
|
... index=pd.MultiIndex.from_arrays(arrays,
|
... names=['a', 'b']))
|
|
To remove a specific level from the Index, use `level`.
|
|
>>> s2.reset_index(level='a')
|
a foo
|
b
|
one bar 0
|
two bar 1
|
one baz 2
|
two baz 3
|
|
If `level` is not set, all levels are removed from the Index.
|
|
>>> s2.reset_index()
|
a b foo
|
0 bar one 0
|
1 bar two 1
|
2 baz one 2
|
3 baz two 3
|
r Nc s g | ]} j |¡qS r )r Z_get_level_number)Ú.0Zlevr r r¡ Ú
|
<listcomp>6 s z&Series.reset_index.<locals>.<listcomp>Fr´ rN rë ré z<Cannot reset_index inplace on a Series to create a DataFramer )rL rJ rK )r@ rm r r¾ rÓ rÕ r r Z droplevelr r± rí rÙ rÉ r r Ú
|
no_defaultr¦ Úto_framerN )
|
r rL rJ r¦ r rK r÷ Z
|
level_listr Údfr r r¡ rN À sN m
|
ÿ þÿ
|
|
|
ÿc C s t ¡ }| jf |S )zI
|
Return a string representation for a particular Series.
|
)ÚfmtZget_series_repr_paramsÚ to_string)r Z repr_paramsr r r¡ Ú__repr__Z s zSeries.__repr__z
|
str | Nonez
|
int | None)ÚbufÚna_repÚ float_formatÚheaderr Úmax_rowsÚmin_rowsr³ c C s d S rØ r © r rW rX rY rZ r Úlengthr° r¦ r[ r\ r r r¡ rU b s zSeries.to_stringzFilePath | WriteBuffer[str]c C s d S rØ r r] r r r¡ rU r s ÚNaNz"FilePath | WriteBuffer[str] | None) rW rX rY rZ r r^ r° r¦ r[ r\ r³ c C s t j| ||||||||
|
| d
|
} | ¡ } t| tsHtdtt| j |dkrT| S t |drj|
|
| ¡ n t |d} |
|
| ¡ W 5 Q R X dS )aÇ
|
Render a string representation of the Series.
|
|
Parameters
|
----------
|
buf : StringIO-like, optional
|
Buffer to write to.
|
na_rep : str, optional
|
String representation of NaN to use, default 'NaN'.
|
float_format : one-parameter function, optional
|
Formatter function to apply to columns' elements if they are
|
floats, default None.
|
header : bool, default True
|
Add the Series header (index name).
|
index : bool, optional
|
Add index (row) labels, default True.
|
length : bool, default False
|
Add the Series length.
|
dtype : bool, default False
|
Add the Series dtype.
|
name : bool, default False
|
Add the Series name if not None.
|
max_rows : int, optional
|
Maximum number of rows to show before truncating. If None, show
|
all.
|
min_rows : int, optional
|
The number of rows to display in a truncated repr (when number
|
of rows is above `max_rows`).
|
|
Returns
|
-------
|
str or None
|
String representation of Series if ``buf=None``, otherwise None.
|
) r¦ r^ rZ r r° rX rY r\ r[ z.result must be of type str, type of result is NÚwriteÚw) rT ZSeriesFormatterrU r¾ rª rÎ ÚreprrÅ r r7 r` Úopen)r rW rX rY rZ r r^ r° r¦ r[ r\ Ú formatterrù Úfr r r¡ rU s0 /ö
|
ÿ
|
r Ústorage_optionsaý Examples
|
--------
|
>>> s = pd.Series(["elk", "pig", "dog", "quetzal"], name="animal")
|
>>> print(s.to_markdown())
|
| | animal |
|
|---:|:---------|
|
| 0 | elk |
|
| 1 | pig |
|
| 2 | dog |
|
| 3 | quetzal |
|
|
Output markdown with a tabulate option.
|
|
>>> print(s.to_markdown(tablefmt="grid"))
|
+----+----------+
|
| | animal |
|
+====+==========+
|
| 0 | elk |
|
+----+----------+
|
| 1 | pig |
|
+----+----------+
|
| 2 | dog |
|
+----+----------+
|
| 3 | quetzal |
|
+----+----------+)r rf ÚexamplesÚwtzIO[str] | Noner0 )rW Úmoder rf r³ c K s | ¡ j|||fd|i|S )a]
|
Print {klass} in Markdown-friendly format.
|
|
Parameters
|
----------
|
buf : str, Path or StringIO-like, optional, default None
|
Buffer to write to. If None, the output is returned as a string.
|
mode : str, optional
|
Mode in which file is opened, "wt" by default.
|
index : bool, optional, default True
|
Add index (row) labels.
|
|
.. versionadded:: 1.1.0
|
{storage_options}
|
|
.. versionadded:: 1.2.0
|
|
**kwargs
|
These parameters will be passed to `tabulate <https://pypi.org/project/tabulate>`_.
|
|
Returns
|
-------
|
str
|
{klass} in Markdown-friendly format.
|
|
Notes
|
-----
|
Requires the `tabulate <https://pypi.org/project/tabulate>`_ package.
|
|
{examples}
|
rf )rR Ú to_markdown)r rW ri r rf rö r r r¡ rj Ð s G ÿÿÿzSeries.to_markdownz Iterable[tuple[Hashable, Any]]c C s t t| jt| S )a
|
Lazily iterate over (index, value) tuples.
|
|
This method returns an iterable tuple (index, value). This is
|
convenient if you want to create a lazy iterator.
|
|
Returns
|
-------
|
iterable
|
Iterable of tuples containing the (index, value) pairs from a
|
Series.
|
|
See Also
|
--------
|
DataFrame.items : Iterate over (column name, Series) pairs.
|
DataFrame.iterrows : Iterate over DataFrame rows as (index, Series) pairs.
|
|
Examples
|
--------
|
>>> s = pd.Series(['A', 'B', 'C'])
|
>>> for index, value in s.items():
|
... print(f"Index : {index}, Value : {value}")
|
Index : 0, Value : A
|
Index : 1, Value : B
|
Index : 2, Value : C
|
)ÚzipÚiterr r r r r¡ Úitems s z Series.itemsrj c C s | j S )zy
|
Return alias for index.
|
|
Returns
|
-------
|
Index
|
Index of the Series.
|
rñ r r r r¡ rÔ = s z Series.keysz
|
type[dict]Údict)Úintor³ c C s@ t |¡}t| st| r0|dd | ¡ D S || ¡ S dS )a¡
|
Convert Series to {label -> value} dict or dict-like object.
|
|
Parameters
|
----------
|
into : class, default dict
|
The collections.abc.Mapping subclass to use as the return
|
object. 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.
|
|
Returns
|
-------
|
collections.abc.Mapping
|
Key-value representation of Series.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3, 4])
|
>>> s.to_dict()
|
{0: 1, 1: 2, 2: 3, 3: 4}
|
>>> from collections import OrderedDict, defaultdict
|
>>> s.to_dict(OrderedDict)
|
OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
|
>>> dd = defaultdict(list)
|
>>> s.to_dict(dd)
|
defaultdict(<class 'list'>, {0: 1, 1: 2, 2: 3, 3: 4})
|
c s s | ]\}}|t |fV qd S rØ )rE )rO ÚkÚvr r r¡ Ú <genexpr>i s z!Series.to_dict.<locals>.<genexpr>N)rÏ Zstandardize_mappingrN rI rm )r ro Zinto_cr r r¡ Úto_dictH s
|
zSeries.to_dict)r¦ r³ c C s\ |t jkr.| j}|dkr"td}q8t|g}n
|
t|g}| j |¡}| |¡}|j| ddS )a
|
Convert Series to DataFrame.
|
|
Parameters
|
----------
|
name : object, optional
|
The passed name should substitute for the series name (if it has
|
one).
|
|
Returns
|
-------
|
DataFrame
|
DataFrame representation of Series.
|
|
Examples
|
--------
|
>>> s = pd.Series(["a", "b", "c"],
|
... name="vals")
|
>>> s.to_frame()
|
vals
|
0 a
|
1 b
|
2 c
|
Nr rR rë ) r rQ r¦ rm rj r¬ Z to_2d_mgrrÛ rí )r r¦ rF ZmgrrS r r r¡ rR o s
|
|
|
|
zSeries.to_frame)r r³ c C s$ t |d}|r| n| ¡ }||_|S )z·
|
Set the Series name.
|
|
Parameters
|
----------
|
name : str
|
inplace : bool
|
Whether to modify `self` directly or return a copy.
|
r )r@ r± r¦ )r r¦ r Zserr r r¡ Ú _set_name s
|
|
zSeries._set_namea´
|
Examples
|
--------
|
>>> ser = pd.Series([390., 350., 30., 20.],
|
... index=['Falcon', 'Falcon', 'Parrot', 'Parrot'], name="Max Speed")
|
>>> ser
|
Falcon 390.0
|
Falcon 350.0
|
Parrot 30.0
|
Parrot 20.0
|
Name: Max Speed, dtype: float64
|
>>> ser.groupby(["a", "b", "a", "b"]).mean()
|
a 210.0
|
b 185.0
|
Name: Max Speed, dtype: float64
|
>>> ser.groupby(level=0).mean()
|
Falcon 370.0
|
Parrot 25.0
|
Name: Max Speed, dtype: float64
|
>>> ser.groupby(ser > 100).mean()
|
Max Speed
|
False 25.0
|
True 370.0
|
Name: Max Speed, dtype: float64
|
|
**Grouping by 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'))
|
>>> ser = pd.Series([390., 350., 30., 20.], index=index, name="Max Speed")
|
>>> ser
|
Animal Type
|
Falcon Captive 390.0
|
Wild 350.0
|
Parrot Captive 30.0
|
Wild 20.0
|
Name: Max Speed, dtype: float64
|
>>> ser.groupby(level=0).mean()
|
Animal
|
Falcon 370.0
|
Parrot 25.0
|
Name: Max Speed, dtype: float64
|
>>> ser.groupby(level="Type").mean()
|
Type
|
Captive 210.0
|
Wild 185.0
|
Name: Max Speed, dtype: float64
|
|
We can also choose to include `NA` in group keys or not by defining
|
`dropna` parameter, the default setting is `True`.
|
|
>>> ser = pd.Series([1, 2, 3, 3], index=["a", 'a', 'b', np.nan])
|
>>> ser.groupby(level=0).sum()
|
a 3
|
b 3
|
dtype: int64
|
|
>>> ser.groupby(level=0, dropna=False).sum()
|
a 3
|
b 3
|
NaN 3
|
dtype: int64
|
|
>>> arrays = ['Falcon', 'Falcon', 'Parrot', 'Parrot']
|
>>> ser = pd.Series([390., 350., 30., 20.], index=arrays, name="Max Speed")
|
>>> ser.groupby(["a", "b", "a", np.nan]).mean()
|
a 210.0
|
b 350.0
|
Name: Max Speed, dtype: float64
|
|
>>> ser.groupby(["a", "b", "a", np.nan], dropna=False).mean()
|
a 210.0
|
b 350.0
|
NaN 20.0
|
Name: Max Speed, dtype: float64
|
Úgroupbyr )r rL Úas_indexÚsortÚ
|
group_keysÚobservedÚdropnar³ c
|
C sT ddl m} |d kr$|d kr$td|s0td| |¡}| | ||||||||d S )Nr r z*You have to supply one of 'by' and 'level'z(as_index=False only valid with DataFrame) ÚobjrÔ r rL rv rw rx ry rz )Úpandas.core.groupby.genericr r Ú_get_axis_number)
|
r Zbyr rL rv rw rx ry rz r r r r¡ ru ¦ s" ^
|
÷zSeries.groupbyc C s t | j ¡ d¡S )a¤
|
Return number of non-NA/null observations in the Series.
|
|
Returns
|
-------
|
int or Series (if level specified)
|
Number of non-null values in the Series.
|
|
See Also
|
--------
|
DataFrame.count : Count non-NA cells for each column or row.
|
|
Examples
|
--------
|
>>> s = pd.Series([0.0, 1.0, np.nan])
|
>>> s.count()
|
2
|
Úint64)rV rÉ ÚsumrÇ r r r r¡ Úcount s z Series.count)rz r³ c C sJ | j }t|tjr"tj||d}n |j|d}| j|tt || j
|
ddS )a¥
|
Return the mode(s) of the Series.
|
|
The mode is the value that appears most often. There can be multiple modes.
|
|
Always returns Series even if only one value is returned.
|
|
Parameters
|
----------
|
dropna : bool, default True
|
Don't consider counts of NaN/NaT.
|
|
Returns
|
-------
|
Series
|
Modes of the Series in sorted order.
|
)rz Fr ) rÉ r¾ r rà rX ri Ú_moderÙ Úranger r¦ )r rz rÖ rî r r r¡ ri 1 s
|
ÿz Series.modec s
|
t ¡ S )a
|
Return unique values of Series object.
|
|
Uniques are returned in order of appearance. Hash table-based unique,
|
therefore does NOT sort.
|
|
Returns
|
-------
|
ndarray or ExtensionArray
|
The unique values returned as a NumPy array. See Notes.
|
|
See Also
|
--------
|
Series.drop_duplicates : Return Series with duplicate values removed.
|
unique : Top-level unique method for any 1-d array-like object.
|
Index.unique : Return Index with unique values from an Index object.
|
|
Notes
|
-----
|
Returns the unique values as a NumPy array. In case of an
|
extension-array backed Series, a new
|
:class:`~api.extensions.ExtensionArray` of that type with just
|
the unique values is returned. This includes
|
|
* Categorical
|
* Period
|
* Datetime with Timezone
|
* Datetime without Timezone
|
* Timedelta
|
* Interval
|
* Sparse
|
* IntegerNA
|
|
See Examples section.
|
|
Examples
|
--------
|
>>> pd.Series([2, 1, 3, 3], name='A').unique()
|
array([2, 1, 3])
|
|
>>> pd.Series([pd.Timestamp('2016-01-01') for _ in range(3)]).unique()
|
<DatetimeArray>
|
['2016-01-01 00:00:00']
|
Length: 1, dtype: datetime64[ns]
|
|
>>> pd.Series([pd.Timestamp('2016-01-01', tz='US/Eastern')
|
... for _ in range(3)]).unique()
|
<DatetimeArray>
|
['2016-01-01 00:00:00-05:00']
|
Length: 1, dtype: datetime64[ns, US/Eastern]
|
|
An Categorical will return categories in the order of
|
appearance and with the same dtype.
|
|
>>> pd.Series(pd.Categorical(list('baabc'))).unique()
|
['b', 'a', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
>>> pd.Series(pd.Categorical(list('baabc'), categories=list('abc'),
|
... ordered=True)).unique()
|
['b', 'a', 'c']
|
Categories (3, object): ['a' < 'b' < 'c']
|
)rA r r rB r r¡ r O s ?z Series.unique)Úkeepr Ú ignore_indexr )r r r r³ c C s d S rØ r ©r r r r r r r¡ Údrop_duplicates s zSeries.drop_duplicates)r r c C s d S rØ r r
r r r¡ r s z Series | Nonec C s d S rØ r r
r r r¡ r s Úfirstc sD t |d}t j|d}|r*tt||_|r<| |¡ dS |S dS )uc
|
Return Series with duplicate values removed.
|
|
Parameters
|
----------
|
keep : {'first', 'last', ``False``}, default 'first'
|
Method to handle dropping duplicates:
|
|
- 'first' : Drop duplicates except for the first occurrence.
|
- 'last' : Drop duplicates except for the last occurrence.
|
- ``False`` : Drop all duplicates.
|
|
inplace : bool, default ``False``
|
If ``True``, performs operation inplace and returns None.
|
|
ignore_index : bool, default ``False``
|
If ``True``, the resulting axis will be labeled 0, 1, â¦, n - 1.
|
|
.. versionadded:: 2.0.0
|
|
Returns
|
-------
|
Series or None
|
Series with duplicates dropped or None if ``inplace=True``.
|
|
See Also
|
--------
|
Index.drop_duplicates : Equivalent method on Index.
|
DataFrame.drop_duplicates : Equivalent method on DataFrame.
|
Series.duplicated : Related method on Series, indicating duplicate
|
Series values.
|
Series.unique : Return unique values as an array.
|
|
Examples
|
--------
|
Generate a Series with duplicated entries.
|
|
>>> s = pd.Series(['lama', 'cow', 'lama', 'beetle', 'lama', 'hippo'],
|
... name='animal')
|
>>> s
|
0 lama
|
1 cow
|
2 lama
|
3 beetle
|
4 lama
|
5 hippo
|
Name: animal, dtype: object
|
|
With the 'keep' parameter, the selection behaviour of duplicated values
|
can be changed. The value 'first' keeps the first occurrence for each
|
set of duplicated entries. The default value of keep is 'first'.
|
|
>>> s.drop_duplicates()
|
0 lama
|
1 cow
|
3 beetle
|
5 hippo
|
Name: animal, dtype: object
|
|
The value 'last' for parameter 'keep' keeps the last occurrence for
|
each set of duplicated entries.
|
|
>>> s.drop_duplicates(keep='last')
|
1 cow
|
3 beetle
|
4 lama
|
5 hippo
|
Name: animal, dtype: object
|
|
The value ``False`` for parameter 'keep' discards all sets of
|
duplicated entries.
|
|
>>> s.drop_duplicates(keep=False)
|
1 cow
|
3 beetle
|
5 hippo
|
Name: animal, dtype: object
|
r ©r N)r@ rA r rm r r Ú_update_inplace)r r r r rù rB r r¡ r ¦ s U
|
|
)r r³ c C s, | j |d}| j|| jdd}|j| ddS )a\
|
Indicate duplicate Series values.
|
|
Duplicated values are indicated as ``True`` values in the resulting
|
Series. Either all duplicates, all except the first or all except the
|
last occurrence of duplicates can be indicated.
|
|
Parameters
|
----------
|
keep : {'first', 'last', False}, default 'first'
|
Method to handle dropping duplicates:
|
|
- '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[bool]
|
Series indicating whether each value has occurred in the
|
preceding values.
|
|
See Also
|
--------
|
Index.duplicated : Equivalent method on pandas.Index.
|
DataFrame.duplicated : Equivalent method on pandas.DataFrame.
|
Series.drop_duplicates : Remove duplicate values from Series.
|
|
Examples
|
--------
|
By default, for each set of duplicated values, the first occurrence is
|
set on False and all others on True:
|
|
>>> animals = pd.Series(['lama', 'cow', 'lama', 'beetle', 'lama'])
|
>>> animals.duplicated()
|
0 False
|
1 False
|
2 True
|
3 False
|
4 True
|
dtype: bool
|
|
which is equivalent to
|
|
>>> animals.duplicated(keep='first')
|
0 False
|
1 False
|
2 True
|
3 False
|
4 True
|
dtype: bool
|
|
By using 'last', the last occurrence of each set of duplicated values
|
is set on False and all others on True:
|
|
>>> animals.duplicated(keep='last')
|
0 True
|
1 False
|
2 True
|
3 False
|
4 False
|
dtype: bool
|
|
By setting keep on ``False``, all duplicates are True:
|
|
>>> animals.duplicated(keep=False)
|
0 True
|
1 False
|
2 True
|
3 False
|
4 True
|
dtype: bool
|
r Fré r rë )Z _duplicatedrÙ r rí )r r Úresrù r r r¡ r s L zSeries.duplicated)r r r³ c O s, | j ||f||}|dkr"tjS | j| S )aù
|
Return the row label of the minimum value.
|
|
If multiple values equal the minimum, the first row label with that
|
value is returned.
|
|
Parameters
|
----------
|
axis : {0 or 'index'}
|
Unused. Parameter needed for compatibility with DataFrame.
|
skipna : bool, default True
|
Exclude NA/null values. If the entire Series is NA, the result
|
will be NA.
|
*args, **kwargs
|
Additional arguments and keywords have no effect but might be
|
accepted for compatibility with NumPy.
|
|
Returns
|
-------
|
Index
|
Label of the minimum value.
|
|
Raises
|
------
|
ValueError
|
If the Series is empty.
|
|
See Also
|
--------
|
numpy.argmin : Return indices of the minimum values
|
along the given axis.
|
DataFrame.idxmin : Return index of first occurrence of minimum
|
over requested axis.
|
Series.idxmax : Return index *label* of the first occurrence
|
of maximum of values.
|
|
Notes
|
-----
|
This method is the Series version of ``ndarray.argmin``. This method
|
returns the label of the minimum, while ``ndarray.argmin`` returns
|
the position. To get the position, use ``series.values.argmin()``.
|
|
Examples
|
--------
|
>>> s = pd.Series(data=[1, None, 4, 1],
|
... index=['A', 'B', 'C', 'D'])
|
>>> s
|
A 1.0
|
B NaN
|
C 4.0
|
D 1.0
|
dtype: float64
|
|
>>> s.idxmin()
|
'A'
|
|
If `skipna` is False and there is an NA value in the data,
|
the function returns ``nan``.
|
|
>>> s.idxmin(skipna=False)
|
nan
|
r, )Zargminr Únanr ©r r r Úargsrö rû r r r¡ ÚidxminW s Az Series.idxminc O s, | j ||f||}|dkr"tjS | j| S )a
|
Return the row label of the maximum value.
|
|
If multiple values equal the maximum, the first row label with that
|
value is returned.
|
|
Parameters
|
----------
|
axis : {0 or 'index'}
|
Unused. Parameter needed for compatibility with DataFrame.
|
skipna : bool, default True
|
Exclude NA/null values. If the entire Series is NA, the result
|
will be NA.
|
*args, **kwargs
|
Additional arguments and keywords have no effect but might be
|
accepted for compatibility with NumPy.
|
|
Returns
|
-------
|
Index
|
Label of the maximum value.
|
|
Raises
|
------
|
ValueError
|
If the Series is empty.
|
|
See Also
|
--------
|
numpy.argmax : Return indices of the maximum values
|
along the given axis.
|
DataFrame.idxmax : Return index of first occurrence of maximum
|
over requested axis.
|
Series.idxmin : Return index *label* of the first occurrence
|
of minimum of values.
|
|
Notes
|
-----
|
This method is the Series version of ``ndarray.argmax``. This method
|
returns the label of the maximum, while ``ndarray.argmax`` returns
|
the position. To get the position, use ``series.values.argmax()``.
|
|
Examples
|
--------
|
>>> s = pd.Series(data=[1, None, 4, 3, 4],
|
... index=['A', 'B', 'C', 'D', 'E'])
|
>>> s
|
A 1.0
|
B NaN
|
C 4.0
|
D 3.0
|
E 4.0
|
dtype: float64
|
|
>>> s.idxmax()
|
'C'
|
|
If `skipna` is False and there is an NA value in the data,
|
the function returns ``nan``.
|
|
>>> s.idxmax(skipna=False)
|
nan
|
r, )Zargmaxr r r r r r r¡ Úidxmax s Bz Series.idxmax)Údecimalsr³ c O s8 t ||¡ | j |¡}| j|| jddj| dd}|S )aa
|
Round each value in a Series to the given number of decimals.
|
|
Parameters
|
----------
|
decimals : int, default 0
|
Number of decimal places to round to. If decimals is negative,
|
it specifies the number of positions to the left of the decimal point.
|
*args, **kwargs
|
Additional arguments and keywords have no effect but might be
|
accepted for compatibility with NumPy.
|
|
Returns
|
-------
|
Series
|
Rounded values of the Series.
|
|
See Also
|
--------
|
numpy.around : Round values of an np.array.
|
DataFrame.round : Round values of a DataFrame.
|
|
Examples
|
--------
|
>>> s = pd.Series([0.1, 1.3, 2.7])
|
>>> s.round()
|
0 0.0
|
1 1.0
|
2 3.0
|
dtype: float64
|
Fré Úroundrë )ró Zvalidate_roundrÉ r rÙ r rí )r r r rö rù r r r¡ r ä s ÿz Series.roundÚfloatr+ )ÚqÚ interpolationr³ c C s d S rØ r ©r r r r r r¡ Úquantile
|
s zSeries.quantilez Sequence[float] | AnyArrayLikec C s d S rØ r r r r r¡ r
|
s z&float | Sequence[float] | AnyArrayLikezfloat | Seriesc C s d S rØ r r r r r¡ r
|
s ç à?Úlinearc C sz t | | ¡ }|j||dd}|jdkr<|jdd
df }t|rl| j|_t|tj d}| j
|
||| jdS |jd S dS )a¤
|
Return value at the given quantile.
|
|
Parameters
|
----------
|
q : float or array-like, default 0.5 (50% quantile)
|
The quantile(s) to compute, which can lie in range: 0 <= q <= 1.
|
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.
|
|
Returns
|
-------
|
float or Series
|
If ``q`` is an array, a Series will be returned where the
|
index is ``q`` and the values are the quantiles, otherwise
|
a float will be returned.
|
|
See Also
|
--------
|
core.window.Rolling.quantile : Calculate the rolling quantile.
|
numpy.percentile : Returns the q-th percentile(s) of the array elements.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3, 4])
|
>>> s.quantile(.5)
|
2.5
|
>>> s.quantile([.25, .5, .75])
|
0.25 1.75
|
0.50 2.50
|
0.75 3.25
|
dtype: float64
|
F)r r Ú numeric_onlyr Nr rÝ )r r¦ ) rA rR r rô r rL r¦ rj r Úfloat64rÙ )r r r rS rù Úidxr r r¡ r "
|
s .
|
Úpearsonr )Úotherrì Ú min_periodsr³ c C s` | j |ddd\}}t|dkr&tjS |dks6t|rLtj|j|j||dS td| dd S )
|
aj
|
Compute correlation with `other` Series, excluding missing values.
|
|
The two `Series` objects are not required to be the same length and will be
|
aligned internally before the correlation function is applied.
|
|
Parameters
|
----------
|
other : Series
|
Series with which to compute the correlation.
|
method : {'pearson', 'kendall', 'spearman'} or callable
|
Method used to compute 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.
|
|
.. warning::
|
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 needed to have a valid result.
|
|
Returns
|
-------
|
float
|
Correlation with other.
|
|
See Also
|
--------
|
DataFrame.corr : Compute pairwise correlation between columns.
|
DataFrame.corrwith : Compute pairwise correlation with another
|
DataFrame or 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
|
>>> s1 = pd.Series([.2, .0, .6, .2])
|
>>> s2 = pd.Series([.3, .6, .0, .1])
|
>>> s1.corr(s2, method=histogram_intersection)
|
0.3
|
ÚinnerF©Újoinr± r )r ZspearmanZkendall)rì r zHmethod must be either 'pearson', 'spearman', 'kendall', or a callable, 'z' was suppliedN) Úalignr r r Úcallabler\ ZnancorrrÖ rÊ )r r rì r Úthisr r r¡ Úcorrb
|
s < ÿ
|
ÿz Series.corrr )r r Úddofr³ c C s< | j |ddd\}}t|dkr&tjS tj|j|j||dS )ak
|
Compute covariance with Series, excluding missing values.
|
|
The two `Series` objects are not required to be the same length and
|
will be aligned internally before the covariance is calculated.
|
|
Parameters
|
----------
|
other : Series
|
Series with which to compute the covariance.
|
min_periods : int, optional
|
Minimum number of observations needed 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
|
|
Returns
|
-------
|
float
|
Covariance between Series and other normalized by N-1
|
(unbiased estimator).
|
|
See Also
|
--------
|
DataFrame.cov : Compute pairwise covariance of columns.
|
|
Examples
|
--------
|
>>> s1 = pd.Series([0.90010907, 0.13484424, 0.62036035])
|
>>> s2 = pd.Series([0.12528585, 0.26962463, 0.51111198])
|
>>> s1.cov(s2)
|
-0.01685762652715874
|
r Fr r )r r¦ )r¢ r r r r\ ZnancovrÖ )r r r r¦ r¤ r r r¡ Úcov
|
s ) ÿz
|
Series.covr a
|
Difference with previous row
|
|
>>> s = pd.Series([1, 1, 2, 3, 5, 8])
|
>>> s.diff()
|
0 NaN
|
1 0.0
|
2 1.0
|
3 1.0
|
4 2.0
|
5 3.0
|
dtype: float64
|
|
Difference with 3rd previous row
|
|
>>> s.diff(periods=3)
|
0 NaN
|
1 NaN
|
2 NaN
|
3 2.0
|
4 4.0
|
5 6.0
|
dtype: float64
|
|
Difference with following row
|
|
>>> s.diff(periods=-1)
|
0 0.0
|
1 -1.0
|
2 -1.0
|
3 -2.0
|
4 -3.0
|
5 NaN
|
dtype: float64
|
|
Overflow in input dtype
|
|
>>> s = pd.Series([1, 0], dtype=np.uint8)
|
>>> s.diff()
|
0 NaN
|
1 255.0
|
dtype: float64)r Ú extra_paramsZ other_klassrg )Úperiodsr³ c C s* t | j|¡}| j|| jddj| ddS )a0
|
First discrete difference of element.
|
|
Calculates the difference of a {klass} element compared with another
|
element in the {klass} (default is element in previous row).
|
|
Parameters
|
----------
|
periods : int, default 1
|
Periods to shift for calculating difference, accepts negative
|
values.
|
{extra_params}
|
Returns
|
-------
|
{klass}
|
First differences of the Series.
|
|
See Also
|
--------
|
{klass}.pct_change: Percent change over given number of periods.
|
{klass}.shift: Shift index by desired number of periods with an
|
optional time freq.
|
{other_klass}.diff: First discrete difference of object.
|
|
Notes
|
-----
|
For boolean dtypes, this uses :meth:`operator.xor` rather than
|
:meth:`operator.sub`.
|
The result is calculated according to current dtype in {klass},
|
however dtype of the result is always float64.
|
|
Examples
|
--------
|
{examples}
|
Fré Údiffrë )rX rª rÉ rÙ r rí )r r© rù r r r¡ rª Ý
|
s
|
U ÿz Series.diff)Úlagr³ c C s | | |¡¡S )aÜ
|
Compute the lag-N autocorrelation.
|
|
This method computes the Pearson correlation between
|
the Series and its shifted self.
|
|
Parameters
|
----------
|
lag : int, default 1
|
Number of lags to apply before performing autocorrelation.
|
|
Returns
|
-------
|
float
|
The Pearson correlation between self and self.shift(lag).
|
|
See Also
|
--------
|
Series.corr : Compute the correlation between two Series.
|
Series.shift : Shift index by desired number of periods.
|
DataFrame.corr : Compute pairwise correlation of columns.
|
DataFrame.corrwith : Compute pairwise correlation between rows or
|
columns of two DataFrame objects.
|
|
Notes
|
-----
|
If the Pearson correlation is not well defined return 'NaN'.
|
|
Examples
|
--------
|
>>> s = pd.Series([0.25, 0.5, 0.2, -0.05])
|
>>> s.autocorr() # doctest: +ELLIPSIS
|
0.10355...
|
>>> s.autocorr(lag=2) # doctest: +ELLIPSIS
|
-0.99999...
|
|
If the Pearson correlation is not well defined, then 'NaN' is returned.
|
|
>>> s = pd.Series([1, 0, 0, 0])
|
>>> s.autocorr()
|
nan
|
)r¥ Úshift)r r« r r r¡ Úautocorr7 s +zSeries.autocorrr zSeries | np.ndarray)r r³ c C s" t |ttfrr| j |j¡}t|t| jks@t|t|jkrHtd| j|dd}|j|dd}|j}|j}n<| j}t
|
|¡}|j d |j d kr®t d|j d|j t |trÜ| j t ||¡|jddj| ddS t |tròt ||¡S t |t jr t ||¡S td t| d
|
S ) aC
|
Compute the dot product between the Series and the columns of other.
|
|
This method computes the dot product between the Series and another
|
one, or the Series and each columns of a DataFrame, or the Series and
|
each columns of an 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 dot product with its columns.
|
|
Returns
|
-------
|
scalar, Series or numpy.ndarray
|
Return the dot product of the Series and other if other is a
|
Series, the Series of the dot product of Series and each rows of
|
other if other is a DataFrame or a numpy.ndarray between the Series
|
and each columns of the numpy array.
|
|
See Also
|
--------
|
DataFrame.dot: Compute the matrix product with the DataFrame.
|
Series.mul: Multiplication of series and other, element-wise.
|
|
Notes
|
-----
|
The Series and other has to share the same index if other is a Series
|
or a DataFrame.
|
|
Examples
|
--------
|
>>> s = pd.Series([0, 1, 2, 3])
|
>>> other = pd.Series([-1, 2, -3, 4])
|
>>> s.dot(other)
|
8
|
>>> s @ other
|
8
|
>>> df = pd.DataFrame([[0, 1], [-2, 3], [4, -5], [6, 7]])
|
>>> s.dot(df)
|
0 24
|
1 14
|
dtype: int64
|
>>> arr = np.array([[0, 1], [-2, 3], [4, -5], [6, 7]])
|
>>> s.dot(arr)
|
array([24, 14])
|
zmatrices are not alignedFré r z Dot product shape mismatch, z vs Údotrë zunsupported type: N)r¾ r
rR r Úunionr rÊ rË rÖ r rï ÚshapeÚ ExceptionrÙ r® rF rí rà r rÅ )r r rZ ÚleftÚrightZlvalsZrvalsr r r¡ r® d s8 2$
|
ÿ
|
|
ÿ þ
|
z
|
Series.dotc C s
|
| |¡S ©zQ
|
Matrix multiplication using binary `@` operator in Python>=3.5.
|
)r® ©r r r r r¡ Ú
|
__matmul__² s zSeries.__matmul__c C s | t |¡¡S r´ )r® r Z transposerµ r r r¡ Ú __rmatmul__¸ s zSeries.__rmatmul__)r r² z$NumpyValueArrayLike | ExtensionArrayzLiteral[('left', 'right')]r} z npt.NDArray[np.intp] | np.intp)rß ÚsideÚsorterr³ c C s t jj| |||dS )N)r¸ r¹ )rY Ú IndexOpsMixinÚ searchsorted)r rß r¸ r¹ r r r¡ r» ¾ s zSeries.searchsorted©r Úverify_integrityc C sh ddl m} t|ttfr,| g}| |¡ n| |g}tdd |dd
D rZd}t|||||dS )Nr )Úconcatc s s | ]}t |tfV qd S rØ )r¾ rR )rO Úxr r r¡ rr Õ s z!Series._append.<locals>.<genexpr>r zCto_append should be a Series or list/tuple of Series, got DataFramer¼ )Zpandas.core.reshape.concatr¾ r¾ rÕ rÓ Úextendr- r )r Z to_appendr r½ r¾ Z to_concatÚmsgr r r¡ Ú_appendË s ÿzSeries._append)r c
|
C s t |tstd| }| j |j¡s:| j||ddd\}}t |j|j|¡\}}t j
|
dd |||}W 5 Q R X t | |¡} | || ¡S )a6
|
Perform generic binary operation with optional fill value.
|
|
Parameters
|
----------
|
other : Series
|
func : binary operator
|
fill_value : float or object
|
Value to substitute for NA/null values. If both Series are NA in a
|
location, the result will be NA regardless of the passed fill value.
|
level : int or level name, default None
|
Broadcast across a level, matching Index values on the
|
passed MultiIndex level.
|
|
Returns
|
-------
|
Series
|
z Other operand must be SeriesÚouterF)rL r¡ r± r» ©Úall) r¾ r
rÎ r rÍ r¢ r] Z
|
fill_binoprÉ r ÚerrstateÚget_op_result_nameÚ_construct_result)
|
r r ÚfuncrL Ú
|
fill_valuer¤ Z this_valsZ
|
other_valsrù r¦ r r r¡ Ú_binopÜ s
|
z Series._binopz'ArrayLike | tuple[ArrayLike, ArrayLike]z Series | tuple[Series, Series])rù r¦ r³ c C s t |trR| j|d |d}| j|d |d}t |ts<tt |tsJt||fS t|dd}| j|| j|d}| | ¡}||_ |S )a8
|
Construct an appropriately-labelled Series from the result of an op.
|
|
Parameters
|
----------
|
result : ndarray or ExtensionArray
|
name : Label
|
|
Returns
|
-------
|
Series
|
In the case of __divmod__ or __rdivmod__, a 2-tuple of Series.
|
r ©r¦ r r° NrÒ )
|
r¾ rÓ rÈ r
rÎ r3 rÙ r rí r¦ )r rù r¦ Zres1Zres2r° Úoutr r r¡ rÈ ÿ s
|
|
zSeries._construct_resultÚcompareax
|
Returns
|
-------
|
Series or DataFrame
|
If axis is 0 or 'index' the result will be a Series.
|
The resulting index will be a MultiIndex with 'self' and 'other'
|
stacked alternately at the inner level.
|
|
If axis is 1 or 'columns' the result will be a DataFrame.
|
It will have two columns namely 'self' and 'other'.
|
|
See Also
|
--------
|
DataFrame.compare : Compare with another DataFrame and show differences.
|
|
Notes
|
-----
|
Matching NaNs will not appear as a difference.
|
|
Examples
|
--------
|
>>> s1 = pd.Series(["a", "b", "c", "d", "e"])
|
>>> s2 = pd.Series(["a", "a", "c", "b", "e"])
|
|
Align the differences on columns
|
|
>>> s1.compare(s2)
|
self other
|
1 b a
|
3 d b
|
|
Stack the differences on indices
|
|
>>> s1.compare(s2, align_axis=0)
|
1 self b
|
other a
|
3 self d
|
other b
|
dtype: object
|
|
Keep all original rows
|
|
>>> s1.compare(s2, keep_shape=True)
|
self other
|
0 NaN NaN
|
1 b a
|
2 NaN NaN
|
3 d b
|
4 NaN NaN
|
|
Keep all original rows and also all original values
|
|
>>> s1.compare(s2, keep_shape=True, keep_equal=True)
|
self other
|
0 a a
|
1 b a
|
2 c c
|
3 d b
|
4 e e
|
rµ r zDataFrame | Series)r Ú
|
align_axisÚ
|
keep_shapeÚ
|
keep_equalÚ result_namesr³ c s t j|||||dS )N)r rÏ rÐ rÑ rÒ )rA rÎ )r r rÏ rÐ rÑ rÒ rB r r¡ rÎ % s HûzSeries.comparezSeries | Hashablez(Callable[[Hashable, Hashable], Hashable])r rÉ rÊ r³ c
|
s" |dkrt | jdd}ttr| j j¡}t | ¡}tj t
|
|t d}t |D ]F\}}| ||¡} ||¡}
|
tjdd | |
|
||< W 5 Q R X qTnT| j}tj t
|
|t d}tjdd$ fdd| jD |dd
< W 5 Q R X | j}tj|dd } t| | jdd
|
} | j| ||dd S ) a
|
Combine the Series with a Series or scalar according to `func`.
|
|
Combine the Series and `other` using `func` to perform elementwise
|
selection for combined Series.
|
`fill_value` is assumed when value is missing at some index
|
from one of the two objects being combined.
|
|
Parameters
|
----------
|
other : Series or scalar
|
The value(s) to be combined with the `Series`.
|
func : function
|
Function that takes two scalars as inputs and returns an element.
|
fill_value : scalar, optional
|
The value to assume when an index is missing from
|
one Series or the other. The default specifies to use the
|
appropriate NaN value for the underlying dtype of the Series.
|
|
Returns
|
-------
|
Series
|
The result of combining the Series with the other object.
|
|
See Also
|
--------
|
Series.combine_first : Combine Series values, choosing the calling
|
Series' values first.
|
|
Examples
|
--------
|
Consider 2 Datasets ``s1`` and ``s2`` containing
|
highest clocked speeds of different birds.
|
|
>>> s1 = pd.Series({'falcon': 330.0, 'eagle': 160.0})
|
>>> s1
|
falcon 330.0
|
eagle 160.0
|
dtype: float64
|
>>> s2 = pd.Series({'falcon': 345.0, 'eagle': 200.0, 'duck': 30.0})
|
>>> s2
|
falcon 345.0
|
eagle 200.0
|
duck 30.0
|
dtype: float64
|
|
Now, to combine the two datasets and view the highest speeds
|
of the birds across the two datasets
|
|
>>> s1.combine(s2, max)
|
duck NaN
|
eagle 200.0
|
falcon 345.0
|
dtype: float64
|
|
In the previous example, the resulting value for duck is missing,
|
because the maximum of a NaN and a float is a NaN.
|
So, in the example, we set ``fill_value=0``,
|
so the maximum value returned will be the value from some dataset.
|
|
>>> s1.combine(s2, max, fill_value=0)
|
duck 30.0
|
eagle 200.0
|
falcon 345.0
|
dtype: float64
|
NFr¸ rÝ r» rÄ c s g | ]} |qS r r )rO Úlv©rÉ r r r¡ rP Ñ s z"Series.combine.<locals>.<listcomp>)Z try_float)Z
|
same_dtyper )rU r° r¾ r
r r¯ r] rÇ r Úemptyr rÀ Ú enumerateÚgetrÆ rÉ r¦ r Zmaybe_convert_objectsrF rÙ ) r r rÉ rÊ r÷ Únew_namerø rû r rÓ ÚrvZnpvaluesrî r rÔ r¡ Úcombineu s& H
|
(zSeries.combinec C sZ | j |j ¡}| j|dd}|j|dd}|jjdkrJ|jjdkrJt|}| t||¡S )aÐ
|
Update null elements with value in the same location in 'other'.
|
|
Combine two Series objects by filling null values in one Series with
|
non-null values from the other Series. Result index will be the union
|
of the two indexes.
|
|
Parameters
|
----------
|
other : Series
|
The value(s) to be used for filling null values.
|
|
Returns
|
-------
|
Series
|
The result of combining the provided Series with the other object.
|
|
See Also
|
--------
|
Series.combine : Perform element-wise operation on two Series
|
using a given function.
|
|
Examples
|
--------
|
>>> s1 = pd.Series([1, np.nan])
|
>>> s2 = pd.Series([3, 4, 5])
|
>>> s1.combine_first(s2)
|
0 1.0
|
1 4.0
|
2 5.0
|
dtype: float64
|
|
Null values still persist if the location of that null value
|
does not exist in `other`
|
|
>>> s1 = pd.Series({'falcon': np.nan, 'eagle': 160.0})
|
>>> s2 = pd.Series({'eagle': 200.0, 'duck': 30.0})
|
>>> s1.combine_first(s2)
|
duck 30.0
|
eagle 160.0
|
falcon NaN
|
dtype: float64
|
Frº ÚM)r r¯ rË r° r ry ÚwhererV )r r r÷ r¤ r r r¡ Ú combine_firstÙ s ,zSeries.combine_firstzSeries | Sequence | Mappingc C sB t |tst|}| | ¡}t|}| jj||d| _| ¡ dS )aÃ
|
Modify Series in place using values from passed Series.
|
|
Uses non-NA values from passed Series to make updates. Aligns
|
on index.
|
|
Parameters
|
----------
|
other : Series, or object coercible into Series
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.update(pd.Series([4, 5, 6]))
|
>>> s
|
0 4
|
1 5
|
2 6
|
dtype: int64
|
|
>>> s = pd.Series(['a', 'b', 'c'])
|
>>> s.update(pd.Series(['d', 'e'], index=[0, 2]))
|
>>> s
|
0 d
|
1 b
|
2 e
|
dtype: object
|
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.update(pd.Series([4, 5, 6, 7, 8]))
|
>>> s
|
0 4
|
1 5
|
2 6
|
dtype: int64
|
|
If ``other`` contains NaNs the corresponding values are not updated
|
in the original Series.
|
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.update(pd.Series([4, np.nan, 6]))
|
>>> s
|
0 4
|
1 2
|
2 6
|
dtype: int64
|
|
``other`` can also be a non-Series object type
|
that is coercible into a Series
|
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.update([4, np.nan, 6])
|
>>> s
|
0 4
|
1 2
|
2 6
|
dtype: int64
|
|
>>> s = pd.Series([1, 2, 3])
|
>>> s.update({1: 9})
|
>>> s
|
0 1
|
1 9
|
2 3
|
dtype: int64
|
)r. ÚnewN)r¾ r
Z reindex_likerV r¬ Zputmaskr( )r r r. r r r¡ Úupdate s D
|
|
z Series.update)r Ú ascendingr r Ú na_positionr r z+bool | int | Sequence[bool] | Sequence[int]r3 )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¡ Ú sort_values] s zSeries.sort_values)r rà r rá r r c C s d S rØ r râ r r r¡ rã k s Ú quicksortÚlastc C s, t |d}| |¡ |r&| jr&tdt|rlttttt f |}t
|
|dkrdtdt
|
| d|d }t |}|dkrtd| |rt | |j n| j }t||t||} t| t
|
| rÚ|rÎ| | ¡S | jd d
|
S | j| j | | j| d d }
|
|r
|
tt
|
| |
|
_|s |
|
j| d dS | |
|
¡ d S )uc
|
Sort by the values.
|
|
Sort a Series in ascending or descending order by some
|
criterion.
|
|
Parameters
|
----------
|
axis : {0 or 'index'}
|
Unused. Parameter needed for compatibility with DataFrame.
|
ascending : bool or list of bools, default True
|
If True, sort values in ascending order, otherwise descending.
|
inplace : bool, default False
|
If True, perform operation in-place.
|
kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort'
|
Choice of sorting algorithm. See also :func:`numpy.sort` for more
|
information. 'mergesort' and 'stable' are the only stable algorithms.
|
na_position : {'first' or 'last'}, default 'last'
|
Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at
|
the end.
|
ignore_index : bool, default False
|
If True, the resulting axis will be labeled 0, 1, â¦, n - 1.
|
key : callable, optional
|
If not None, apply the key function to the series values
|
before sorting. This is similar to the `key` argument in the
|
builtin :meth:`sorted` function, with the notable difference that
|
this `key` function should be *vectorized*. It should expect a
|
``Series`` and return an array-like.
|
|
.. versionadded:: 1.1.0
|
|
Returns
|
-------
|
Series or None
|
Series ordered by values or None if ``inplace=True``.
|
|
See Also
|
--------
|
Series.sort_index : Sort by the Series indices.
|
DataFrame.sort_values : Sort DataFrame by the values along either axis.
|
DataFrame.sort_index : Sort DataFrame by indices.
|
|
Examples
|
--------
|
>>> s = pd.Series([np.nan, 1, 3, 10, 5])
|
>>> s
|
0 NaN
|
1 1.0
|
2 3.0
|
3 10.0
|
4 5.0
|
dtype: float64
|
|
Sort values ascending order (default behaviour)
|
|
>>> s.sort_values(ascending=True)
|
1 1.0
|
2 3.0
|
4 5.0
|
3 10.0
|
0 NaN
|
dtype: float64
|
|
Sort values descending order
|
|
>>> s.sort_values(ascending=False)
|
3 10.0
|
4 5.0
|
2 3.0
|
1 1.0
|
0 NaN
|
dtype: float64
|
|
Sort values putting NAs first
|
|
>>> s.sort_values(na_position='first')
|
0 NaN
|
1 1.0
|
2 3.0
|
4 5.0
|
3 10.0
|
dtype: float64
|
|
Sort a series of strings
|
|
>>> s = pd.Series(['z', 'b', 'd', 'a', 'c'])
|
>>> s
|
0 z
|
1 b
|
2 d
|
3 a
|
4 c
|
dtype: object
|
|
>>> s.sort_values()
|
3 a
|
1 b
|
4 c
|
2 d
|
0 z
|
dtype: object
|
|
Sort using a key function. Your `key` function will be
|
given the ``Series`` of values and should return an array-like.
|
|
>>> s = pd.Series(['a', 'B', 'c', 'D', 'e'])
|
>>> s.sort_values()
|
1 B
|
3 D
|
0 a
|
2 c
|
4 e
|
dtype: object
|
>>> s.sort_values(key=lambda x: x.str.lower())
|
0 a
|
1 B
|
2 c
|
3 D
|
4 e
|
dtype: object
|
|
NumPy ufuncs work well here. For example, we can
|
sort by the ``sin`` of the value
|
|
>>> s = pd.Series([-4, -2, 0, 2, 4])
|
>>> s.sort_values(key=np.sin)
|
1 -2
|
4 4
|
2 0
|
0 -4
|
3 2
|
dtype: int64
|
|
More complicated user-defined functions can be used,
|
as long as they expect a Series and return an array-like
|
|
>>> s.sort_values(key=lambda x: (np.tan(x.cumsum())))
|
0 -4
|
3 2
|
4 4
|
1 -2
|
2 0
|
dtype: int64
|
r zRThis Series is a view of some other array, to sort in-place you must create a copyr zLength of ascending (z) must be 1 for Seriesr )r rå zinvalid na_position: Nr´ Fré rã rë )r@ r} r4 rÊ rL r r r r® rç r r? rv rÉ rw r r r± rÙ r rm rí ) r r rà r r rá r r Zvalues_to_sortZ sorted_indexrù r r r¡ rã y sD
|
|
|
ÿ ÿ
|
ÿ
|
)r rL rà r rá Úsort_remainingr r zbool | Sequence[bool]r/ r* r' )
|
r rL rà r r rá ræ r r r³ c
|
C s d S rØ r ©
|
r r rL rà r r rá ræ r r r r r¡ Ú
|
sort_indexA s zSeries.sort_index© r rL rà r r rá ræ r r c
|
C s d S rØ r rç r r r¡ rè Q s c
|
C s d S rØ r rç r r r¡ rè a s c
|
s t j||||||||| d S )uW
|
Sort Series by index labels.
|
|
Returns a new Series sorted by label if `inplace` argument is
|
``False``, otherwise updates the original series and returns None.
|
|
Parameters
|
----------
|
axis : {0 or 'index'}
|
Unused. Parameter needed for compatibility with DataFrame.
|
level : int, optional
|
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
|
If True, perform operation in-place.
|
kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort'
|
Choice of sorting algorithm. See also :func:`numpy.sort` for more
|
information. 'mergesort' and 'stable' are the only stable algorithms. For
|
DataFrames, this option is only applied when sorting on a single
|
column or label.
|
na_position : {'first', 'last'}, default 'last'
|
If 'first' puts NaNs at the beginning, '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.
|
|
.. versionadded:: 1.1.0
|
|
Returns
|
-------
|
Series or None
|
The original Series sorted by the labels or None if ``inplace=True``.
|
|
See Also
|
--------
|
DataFrame.sort_index: Sort DataFrame by the index.
|
DataFrame.sort_values: Sort DataFrame by the value.
|
Series.sort_values : Sort Series by the value.
|
|
Examples
|
--------
|
>>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, 4])
|
>>> s.sort_index()
|
1 c
|
2 b
|
3 a
|
4 d
|
dtype: object
|
|
Sort Descending
|
|
>>> s.sort_index(ascending=False)
|
4 d
|
3 a
|
2 b
|
1 c
|
dtype: object
|
|
By default NaNs are put at the end, but use `na_position` to place
|
them at the beginning
|
|
>>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, np.nan])
|
>>> s.sort_index(na_position='first')
|
NaN d
|
1.0 c
|
2.0 b
|
3.0 a
|
dtype: object
|
|
Specify index level to sort
|
|
>>> arrays = [np.array(['qux', 'qux', 'foo', 'foo',
|
... 'baz', 'baz', 'bar', 'bar']),
|
... np.array(['two', 'one', 'two', 'one',
|
... 'two', 'one', 'two', 'one'])]
|
>>> s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], index=arrays)
|
>>> s.sort_index(level=1)
|
bar one 8
|
baz one 6
|
foo one 4
|
qux one 2
|
bar two 7
|
baz two 5
|
foo two 3
|
qux two 1
|
dtype: int64
|
|
Does not sort by remaining levels when sorting by levels
|
|
>>> s.sort_index(level=1, sort_remaining=False)
|
qux one 2
|
foo one 4
|
baz one 6
|
bar one 8
|
qux two 1
|
foo two 3
|
baz two 5
|
bar two 7
|
dtype: int64
|
|
Apply a key function before sorting
|
|
>>> s = pd.Series([1, 2, 3, 4], index=['A', 'b', 'C', 'd'])
|
>>> s.sort_index(key=lambda x : x.str.lower())
|
A 1
|
b 2
|
C 3
|
d 4
|
dtype: int64
|
ré )rA rè rç rB r r¡ rè q s ÷)r r râ r³ c C s | j }t|}| ¡ rJtjt| dtjd}| }tj|| |d||< ntj||d}| j|| j | j
|
tjdd}|j | ddS )aÏ
|
Return the integer indices that would sort the Series values.
|
|
Override ndarray.argsort. Argsorts the value, omitting NA/null values,
|
and places the result in the same locations as the non-NA values.
|
|
Parameters
|
----------
|
axis : {0 or 'index'}
|
Unused. Parameter needed for compatibility with DataFrame.
|
kind : {'mergesort', 'quicksort', 'heapsort', 'stable'}, default 'quicksort'
|
Choice of sorting algorithm. See :func:`numpy.sort` for more
|
information. 'mergesort' and 'stable' are the only stable algorithms.
|
order : None
|
Has no effect but is accepted for compatibility with numpy.
|
|
Returns
|
-------
|
Series[np.intp]
|
Positions of values within the sort order with -1 indicating
|
nan values.
|
|
See Also
|
--------
|
numpy.ndarray.argsort : Returns the indices that would sort this array.
|
r, rÝ r F)r r¦ r° r± Úargsortrë ) rÉ rT r- r Úfullr Zintprê rÙ r r¦ rí ) r r r râ rÖ r. rù Znotmaskr r r r¡ rê s ÿzSeries.argsorté z!Literal[('first', 'last', 'all')])Únr r³ c C s t j| ||d ¡ S )a
|
Return the largest `n` elements.
|
|
Parameters
|
----------
|
n : int, default 5
|
Return this many descending sorted values.
|
keep : {'first', 'last', 'all'}, default 'first'
|
When there are duplicate values that cannot all fit in a
|
Series of `n` elements:
|
|
- ``first`` : return the first `n` occurrences in order
|
of appearance.
|
- ``last`` : return the last `n` occurrences in reverse
|
order of appearance.
|
- ``all`` : keep all occurrences. This can result in a Series of
|
size larger than `n`.
|
|
Returns
|
-------
|
Series
|
The `n` largest values in the Series, sorted in decreasing order.
|
|
See Also
|
--------
|
Series.nsmallest: Get the `n` smallest elements.
|
Series.sort_values: Sort Series by values.
|
Series.head: Return the first `n` rows.
|
|
Notes
|
-----
|
Faster than ``.sort_values(ascending=False).head(n)`` for small `n`
|
relative to the size of the ``Series`` object.
|
|
Examples
|
--------
|
>>> countries_population = {"Italy": 59000000, "France": 65000000,
|
... "Malta": 434000, "Maldives": 434000,
|
... "Brunei": 434000, "Iceland": 337000,
|
... "Nauru": 11300, "Tuvalu": 11300,
|
... "Anguilla": 11300, "Montserrat": 5200}
|
>>> s = pd.Series(countries_population)
|
>>> s
|
Italy 59000000
|
France 65000000
|
Malta 434000
|
Maldives 434000
|
Brunei 434000
|
Iceland 337000
|
Nauru 11300
|
Tuvalu 11300
|
Anguilla 11300
|
Montserrat 5200
|
dtype: int64
|
|
The `n` largest elements where ``n=5`` by default.
|
|
>>> s.nlargest()
|
France 65000000
|
Italy 59000000
|
Malta 434000
|
Maldives 434000
|
Brunei 434000
|
dtype: int64
|
|
The `n` largest elements where ``n=3``. Default `keep` value is 'first'
|
so Malta will be kept.
|
|
>>> s.nlargest(3)
|
France 65000000
|
Italy 59000000
|
Malta 434000
|
dtype: int64
|
|
The `n` largest elements where ``n=3`` and keeping the last duplicates.
|
Brunei will be kept since it is the last with value 434000 based on
|
the index order.
|
|
>>> s.nlargest(3, keep='last')
|
France 65000000
|
Italy 59000000
|
Brunei 434000
|
dtype: int64
|
|
The `n` largest elements where ``n=3`` with all duplicates kept. Note
|
that the returned Series has five elements due to the three duplicates.
|
|
>>> s.nlargest(3, keep='all')
|
France 65000000
|
Italy 59000000
|
Malta 434000
|
Maldives 434000
|
Brunei 434000
|
dtype: int64
|
©rí r )rt Ú SelectNSeriesÚnlargest©r rí r r r r¡ rð 3 s bzSeries.nlargestc C s t j| ||d ¡ S )aß
|
Return the smallest `n` elements.
|
|
Parameters
|
----------
|
n : int, default 5
|
Return this many ascending sorted values.
|
keep : {'first', 'last', 'all'}, default 'first'
|
When there are duplicate values that cannot all fit in a
|
Series of `n` elements:
|
|
- ``first`` : return the first `n` occurrences in order
|
of appearance.
|
- ``last`` : return the last `n` occurrences in reverse
|
order of appearance.
|
- ``all`` : keep all occurrences. This can result in a Series of
|
size larger than `n`.
|
|
Returns
|
-------
|
Series
|
The `n` smallest values in the Series, sorted in increasing order.
|
|
See Also
|
--------
|
Series.nlargest: Get the `n` largest elements.
|
Series.sort_values: Sort Series by values.
|
Series.head: Return the first `n` rows.
|
|
Notes
|
-----
|
Faster than ``.sort_values().head(n)`` for small `n` relative to
|
the size of the ``Series`` object.
|
|
Examples
|
--------
|
>>> countries_population = {"Italy": 59000000, "France": 65000000,
|
... "Brunei": 434000, "Malta": 434000,
|
... "Maldives": 434000, "Iceland": 337000,
|
... "Nauru": 11300, "Tuvalu": 11300,
|
... "Anguilla": 11300, "Montserrat": 5200}
|
>>> s = pd.Series(countries_population)
|
>>> s
|
Italy 59000000
|
France 65000000
|
Brunei 434000
|
Malta 434000
|
Maldives 434000
|
Iceland 337000
|
Nauru 11300
|
Tuvalu 11300
|
Anguilla 11300
|
Montserrat 5200
|
dtype: int64
|
|
The `n` smallest elements where ``n=5`` by default.
|
|
>>> s.nsmallest()
|
Montserrat 5200
|
Nauru 11300
|
Tuvalu 11300
|
Anguilla 11300
|
Iceland 337000
|
dtype: int64
|
|
The `n` smallest elements where ``n=3``. Default `keep` value is
|
'first' so Nauru and Tuvalu will be kept.
|
|
>>> s.nsmallest(3)
|
Montserrat 5200
|
Nauru 11300
|
Tuvalu 11300
|
dtype: int64
|
|
The `n` smallest elements where ``n=3`` and keeping the last
|
duplicates. Anguilla and Tuvalu will be kept since they are the last
|
with value 11300 based on the index order.
|
|
>>> s.nsmallest(3, keep='last')
|
Montserrat 5200
|
Anguilla 11300
|
Tuvalu 11300
|
dtype: int64
|
|
The `n` smallest elements where ``n=3`` with all duplicates kept. Note
|
that the returned Series has four elements due to the three duplicates.
|
|
>>> s.nsmallest(3, keep='all')
|
Montserrat 5200
|
Nauru 11300
|
Tuvalu 11300
|
Anguilla 11300
|
dtype: int64
|
rî )rt rï Ú nsmallestrñ r r r¡ rò s _zSeries.nsmallestzFcopy : bool, default True
|
Whether to copy underlying data.añ Examples
|
--------
|
>>> s = pd.Series(
|
... ["A", "B", "A", "C"],
|
... index=[
|
... ["Final exam", "Final exam", "Coursework", "Coursework"],
|
... ["History", "Geography", "History", "Geography"],
|
... ["January", "February", "March", "April"],
|
... ],
|
... )
|
>>> s
|
Final exam History January A
|
Geography February B
|
Coursework History March A
|
Geography April C
|
dtype: object
|
|
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.
|
|
>>> s.swaplevel()
|
Final exam January History A
|
February Geography B
|
Coursework March History A
|
April Geography C
|
dtype: object
|
|
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.
|
|
>>> s.swaplevel(0)
|
January History Final exam A
|
February Geography Final exam B
|
March History Coursework A
|
April Geography Coursework C
|
dtype: object
|
|
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.
|
|
>>> s.swaplevel(0, 1)
|
History Final exam January A
|
Geography Final exam February B
|
History Coursework March A
|
Geography Coursework April C
|
dtype: object)r r¨ rg éþÿÿÿr, )rû Újr± r³ c C s8 t | jtst| j|o t d}| j ||¡|_|S )a¦
|
Swap levels i and j in a :class:`MultiIndex`.
|
|
Default is to swap the two innermost levels of the index.
|
|
Parameters
|
----------
|
i, j : int or str
|
Levels of the indices to be swapped. Can pass level name as string.
|
{extra_params}
|
|
Returns
|
-------
|
{klass}
|
{klass} with levels swapped in MultiIndex.
|
|
{examples}
|
r´ )r¾ r rk rÎ r± r Ú swaplevel)r rû rô r± rù r r r¡ rõ ø s QzSeries.swaplevelzSequence[Level]c C sB t | jtstd| jdd}t |jts0t|j |¡|_|S )a9
|
Rearrange index levels using input order.
|
|
May not drop or duplicate levels.
|
|
Parameters
|
----------
|
order : list of int representing new level order
|
Reference level by number or key.
|
|
Returns
|
-------
|
type of caller (new object)
|
z/Can only reorder levels on a hierarchical axis.Nr´ )r¾ r rk r± r± rÎ Úreorder_levels)r râ rù r r r¡ rö N s zSeries.reorder_levels)r r³ c C st t | rt| s,| ¡ }|r(|jddS |S t t | j¡¡\}}|rTt t |}n | j
|
|¡}| j ||| j ddS )un
|
Transform each element of a list-like to a row.
|
|
Parameters
|
----------
|
ignore_index : bool, default False
|
If True, the resulting index will be labeled 0, 1, â¦, n - 1.
|
|
.. versionadded:: 1.1.0
|
|
Returns
|
-------
|
Series
|
Exploded lists to rows; index will be duplicated for these rows.
|
|
See Also
|
--------
|
Series.str.split : Split string values on specified separator.
|
Series.unstack : Unstack, a.k.a. pivot, Series with MultiIndex
|
to produce DataFrame.
|
DataFrame.melt : Unpivot a DataFrame from wide format to long format.
|
DataFrame.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 elements in
|
the output will be non-deterministic when exploding sets.
|
|
Reference :ref:`the user guide <reshaping.explode>` for more examples.
|
|
Examples
|
--------
|
>>> s = pd.Series([[1, 2, 3], 'foo', [], [3, 4]])
|
>>> s
|
0 [1, 2, 3]
|
1 foo
|
2 []
|
3 [3, 4]
|
dtype: object
|
|
>>> s.explode()
|
0 1
|
0 2
|
0 3
|
1 foo
|
2 NaN
|
3 3
|
3 4
|
dtype: object
|
T)rJ Fr )r rN r± rN r Úexploder rï rÉ rm r rI rÙ r¦ )r r rù rÖ Úcountsr r r r¡ r÷ e s 7 zSeries.explode)rL rÊ r³ c C s ddl m} || ||S )a!
|
Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.
|
|
Parameters
|
----------
|
level : int, str, or list of these, default last level
|
Level(s) to unstack, can pass level name.
|
fill_value : scalar value, default None
|
Value to use when replacing NaN values.
|
|
Returns
|
-------
|
DataFrame
|
Unstacked Series.
|
|
Notes
|
-----
|
Reference :ref:`the user guide <reshaping.stacking>` for more examples.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3, 4],
|
... index=pd.MultiIndex.from_product([['one', 'two'],
|
... ['a', 'b']]))
|
>>> s
|
one a 1
|
b 2
|
two a 3
|
b 4
|
dtype: int64
|
|
>>> s.unstack(level=-1)
|
a b
|
one 1 2
|
two 3 4
|
|
>>> s.unstack(level=0)
|
one two
|
a 1 3
|
b 2 4
|
r )Úunstack)Zpandas.core.reshape.reshaperù )r rL rÊ rù r r r¡ rù © s * zSeries.unstackzCallable | Mapping | SerieszLiteral['ignore'] | None)ÚargÚ na_actionr³ c C s* | j ||d}| j|| jddj| ddS )aý
|
Map values of Series according to an input mapping or function.
|
|
Used for substituting each value in a Series with another value,
|
that may be derived from a function, a ``dict`` or
|
a :class:`Series`.
|
|
Parameters
|
----------
|
arg : function, collections.abc.Mapping subclass or Series
|
Mapping correspondence.
|
na_action : {None, 'ignore'}, default None
|
If 'ignore', propagate NaN values, without passing them to the
|
mapping correspondence.
|
|
Returns
|
-------
|
Series
|
Same index as caller.
|
|
See Also
|
--------
|
Series.apply : For applying more complex functions on a Series.
|
DataFrame.apply : Apply a function row-/column-wise.
|
DataFrame.applymap : Apply a function elementwise on a whole DataFrame.
|
|
Notes
|
-----
|
When ``arg`` is a dictionary, values in Series that are not in the
|
dictionary (as keys) are converted to ``NaN``. However, if the
|
dictionary is a ``dict`` subclass that defines ``__missing__`` (i.e.
|
provides a method for default values), then this default is used
|
rather than ``NaN``.
|
|
Examples
|
--------
|
>>> s = pd.Series(['cat', 'dog', np.nan, 'rabbit'])
|
>>> s
|
0 cat
|
1 dog
|
2 NaN
|
3 rabbit
|
dtype: object
|
|
``map`` accepts a ``dict`` or a ``Series``. Values that are not found
|
in the ``dict`` are converted to ``NaN``, unless the dict has a default
|
value (e.g. ``defaultdict``):
|
|
>>> s.map({'cat': 'kitten', 'dog': 'puppy'})
|
0 kitten
|
1 puppy
|
2 NaN
|
3 NaN
|
dtype: object
|
|
It also accepts a function:
|
|
>>> s.map('I am a {}'.format)
|
0 I am a cat
|
1 I am a dog
|
2 I am a nan
|
3 I am a rabbit
|
dtype: object
|
|
To avoid applying the function to missing values (and keep them as
|
``NaN``) ``na_action='ignore'`` can be used:
|
|
>>> s.map('I am a {}'.format, na_action='ignore')
|
0 I am a cat
|
1 I am a dog
|
2 NaN
|
3 I am a rabbit
|
dtype: object
|
)rû Fré Úmaprë )Z _map_valuesrÙ r rí )r rú rû rø r r r¡ rü Ú s
|
O ÿz
|
Series.mapc C 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.
|
r )r r rô Zsubsetr r r¡ Ú_gotitem. s zSeries._gotitemz
|
See Also
|
--------
|
Series.apply : Invoke function on a Series.
|
Series.transform : Transform function producing a Series with like indexes.
|
zî
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3, 4])
|
>>> s
|
0 1
|
1 2
|
2 3
|
3 4
|
dtype: int64
|
|
>>> s.agg('min')
|
1
|
|
>>> s.agg(['min', 'max'])
|
min 1
|
max 4
|
dtype: int64
|
Ú aggregater )r r Zsee_alsorg )r c O s< | |¡ |d kr t| ¡ }t| |d||d}| ¡ }|S )NF)Ú convert_dtyper rö )r} rn rm r_ Úagg)r rÉ r r rö Úoprù r r r¡ rþ [ s
|
zSeries.aggregate)r Ú bool_onlyr rL )r r r rL r³ c K s d S rØ r ©r r r r rL rö r r r¡ r- q s
|
z
|
Series.any)r r r z Series | boolc K s d S rØ r r r r r¡ r- } s
|
z Level | Nonec K s d S rØ r r r r r¡ r- s Ú transform)r r r )rÉ r r³ c O s$ | |¡ t| |d||d ¡ }|S )NT)rÉ rÿ r rö )r} r_ r )r rÉ r r rö rù r r r¡ r s
|
ÿ
|
zSeries.transformr ztuple[Any, ...])rÉ rÿ r r³ c K s t | |||| ¡ S )aC
|
Invoke function on values of Series.
|
|
Can be ufunc (a NumPy function that applies to the entire Series)
|
or a Python function that only works on single values.
|
|
Parameters
|
----------
|
func : function
|
Python function or NumPy ufunc to apply.
|
convert_dtype : bool, default True
|
Try to find better dtype for elementwise function results. If
|
False, leave as dtype=object. Note that the dtype is always
|
preserved for some extension array dtypes, such as Categorical.
|
args : tuple
|
Positional arguments passed to func after the series value.
|
**kwargs
|
Additional keyword arguments passed to func.
|
|
Returns
|
-------
|
Series or DataFrame
|
If func returns a Series object the result will be a DataFrame.
|
|
See Also
|
--------
|
Series.map: For element-wise operations.
|
Series.agg: Only perform aggregating type operations.
|
Series.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
|
--------
|
Create a series with typical summer temperatures for each city.
|
|
>>> s = pd.Series([20, 21, 12],
|
... index=['London', 'New York', 'Helsinki'])
|
>>> s
|
London 20
|
New York 21
|
Helsinki 12
|
dtype: int64
|
|
Square the values by defining a function and passing it as an
|
argument to ``apply()``.
|
|
>>> def square(x):
|
... return x ** 2
|
>>> s.apply(square)
|
London 400
|
New York 441
|
Helsinki 144
|
dtype: int64
|
|
Square the values by passing an anonymous function as an
|
argument to ``apply()``.
|
|
>>> s.apply(lambda x: x ** 2)
|
London 400
|
New York 441
|
Helsinki 144
|
dtype: int64
|
|
Define a custom function that needs additional positional
|
arguments and pass these additional arguments using the
|
``args`` keyword.
|
|
>>> def subtract_custom_value(x, custom_value):
|
... return x - custom_value
|
|
>>> s.apply(subtract_custom_value, args=(5,))
|
London 15
|
New York 16
|
Helsinki 7
|
dtype: int64
|
|
Define a custom function that takes keyword arguments
|
and pass these arguments to ``apply``.
|
|
>>> def add_custom_values(x, **kwargs):
|
... for month in kwargs:
|
... x += kwargs[month]
|
... return x
|
|
>>> s.apply(add_custom_values, june=30, july=20, august=25)
|
London 95
|
New York 96
|
Helsinki 87
|
dtype: int64
|
|
Use a function from the Numpy library.
|
|
>>> s.apply(np.log)
|
London 2.995732
|
New York 3.044522
|
Helsinki 2.484907
|
dtype: float64
|
)r_ Úapply)r rÉ rÿ r rö r r r¡ r ¤ s nz Series.apply)r r r Ú filter_type)r¦ r r r c
|
|
K sª | j }|dk r| |¡ t|tr8|j|fd|i|S |rrt| jsrd} |dkrVd} td| d| d| d tj d
|
d " ||fd|i|W 5 Q R £ S Q R X dS ) z¨
|
Perform a reduction operation.
|
|
If we have an ndarray as a value, then simply perform the operation,
|
otherwise delegate to the object.
|
Nr r )r- rÅ r zSeries.z does not allow ú=z with non-numeric dtypes.r» rÄ )
|
rÉ r} r¾ r` Ú_reducerM r° r r rÆ )
|
r r r¦ r r r r ÚkwdsZdelegateZkwd_namer r r¡ r s
|
|
ÿzSeries._reduceznpt.NDArray[np.intp] | None)r÷ r r± r³ c C sp |d krL|d ks |j | jj krLt r0| j|dS |s<|d krH| j|dS | S tj| j|dd d}| j||ddS )Nr´ T)Z
|
allow_fillrÊ Fré )Únamesr r r± rX Ztake_ndrÉ rÙ )r r÷ r r± rø r r r¡ Ú_reindex_indexer< s" ÿ ÿ ÿzSeries._reindex_indexerc C s dS )zc
|
Check if we do need a multi reindex; this is for compat with
|
higher dims.
|
Fr )r r rì rL r r r¡ Ú_needs_reindex_multiR s zSeries._needs_reindex_multir )r r rà r z Axis | NonezFillnaOptions | None) r r¡ r rL r± rÊ rì ÚlimitÚ fill_axisÚbroadcast_axisr³ c s t j||||||||| |
|
d
|
S )N) r¡ r rL r± rÊ rì r r r )rA r¢ ) r r r¡ r rL r± rÊ rì r r r rB r r¡ r¢ Z s öz Series.align)r r± rL r¼ zRenamer | Hashable | Noner& )r r r± r rL r¼ r³ c C s d S rØ r ©r r r r± r rL r¼ r r r¡ Úrenamey s z Series.rename)r r± r rL r¼ c C s d S rØ r r r r r¡ r s c C s d S rØ r r r r r¡ r s r» c sJ |dk r| |¡}t|s"t|r8t j|||||dS | j||dS dS )a¯
|
Alter Series index labels or name.
|
|
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.
|
|
Alternatively, change ``Series.name`` with a scalar value.
|
|
See the :ref:`user guide <basics.rename>` for more.
|
|
Parameters
|
----------
|
index : scalar, hashable sequence, dict-like or function optional
|
Functions or dict-like are transformations to apply to
|
the index.
|
Scalar or hashable sequence-like will alter the ``Series.name``
|
attribute.
|
axis : {0 or 'index'}
|
Unused. Parameter needed for compatibility with DataFrame.
|
copy : bool, default True
|
Also copy underlying data.
|
inplace : bool, default False
|
Whether to return a new Series. If True the value of copy is ignored.
|
level : int or level name, default None
|
In case of MultiIndex, only rename labels in the specified level.
|
errors : {'ignore', 'raise'}, default 'ignore'
|
If 'raise', raise `KeyError` when a `dict-like mapper` or
|
`index` 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
|
-------
|
Series or None
|
Series with index labels or name altered or None if ``inplace=True``.
|
|
See Also
|
--------
|
DataFrame.rename : Corresponding DataFrame method.
|
Series.rename_axis : Set the name of the axis.
|
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3])
|
>>> s
|
0 1
|
1 2
|
2 3
|
dtype: int64
|
>>> s.rename("my_name") # scalar, changes Series.name
|
0 1
|
1 2
|
2 3
|
Name: my_name, dtype: int64
|
>>> s.rename(lambda x: x ** 2) # function, changes labels
|
0 1
|
1 2
|
4 3
|
dtype: int64
|
>>> s.rename({1: 3, 2: 5}) # mapping, changes labels
|
0 1
|
3 2
|
5 3
|
dtype: int64
|
N)r± r rL r¼ r! )r} r£ rH rA Z_renamert r rB r r¡ r s K
|
ûa
|
Examples
|
--------
|
>>> s = pd.Series([1, 2, 3])
|
>>> s
|
0 1
|
1 2
|
2 3
|
dtype: int64
|
|
>>> s.set_axis(['a', 'b', 'c'], axis=0)
|
a 1
|
b 2
|
c 3
|
dtype: int64
|
)Zextended_summary_subZaxis_description_subZ see_also_sub©r r± )r r± r³ c s t j|||dS )Nr )rA Úset_axis)r Úlabelsr r± rB r r¡ r þ s zSeries.set_axisr )r r )r rì r± rL rÊ r Ú tolerancez Scalar | None)r rì r± rL rÊ r r³ c s t j|||||||dS )N)r rì r± rL rÊ r r )rA rË ) r r r rì r± rL rÊ r r rB r r¡ rË ! s ùzSeries.reindex)r r r± r zIndexLabel | lib.NoDefault)r Úmapperr r± r r³ c s t j|||||dS )N)r r r r± r )rA Ú rename_axis)r r r r r± r rB r r¡ r < s
|
ûzSeries.rename_axis)r r rF rL r¼ )r r r rF rL r r¼ r³ c C s d S rØ r ©r r r r rF rL r r¼ r r r¡ rJ N s z Series.drop)r r rF rL r r¼ c C s d S rØ r r r r r¡ rJ \ s c C s d S rØ r r r r r¡ rJ j s Úraisec s t j|||||||dS )a
|
Return Series with specified index labels removed.
|
|
Remove elements of a Series based on specifying the index labels.
|
When using a multi-index, labels on different levels can be removed
|
by specifying the level.
|
|
Parameters
|
----------
|
labels : single label or list-like
|
Index labels to drop.
|
axis : {0 or 'index'}
|
Unused. Parameter needed for compatibility with DataFrame.
|
index : single label or list-like
|
Redundant for application on Series, but 'index' can be used instead
|
of 'labels'.
|
columns : single label or list-like
|
No change is made to the Series; use 'index' or 'labels' instead.
|
level : int or level name, optional
|
For MultiIndex, level for which the labels will be removed.
|
inplace : bool, default False
|
If True, do operation inplace and return None.
|
errors : {'ignore', 'raise'}, default 'raise'
|
If 'ignore', suppress error and only existing labels are dropped.
|
|
Returns
|
-------
|
Series or None
|
Series with specified index labels removed or None if ``inplace=True``.
|
|
Raises
|
------
|
KeyError
|
If none of the labels are found in the index.
|
|
See Also
|
--------
|
Series.reindex : Return only specified index labels of Series.
|
Series.dropna : Return series without null values.
|
Series.drop_duplicates : Return Series with duplicate values removed.
|
DataFrame.drop : Drop specified labels from rows or columns.
|
|
Examples
|
--------
|
>>> s = pd.Series(data=np.arange(3), index=['A', 'B', 'C'])
|
>>> s
|
A 0
|
B 1
|
C 2
|
dtype: int64
|
|
Drop labels B en C
|
|
>>> s.drop(labels=['B', 'C'])
|
A 0
|
dtype: int64
|
|
Drop 2nd level label in MultiIndex Series
|
|
>>> 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]])
|
>>> s = pd.Series([45, 200, 1.2, 30, 250, 1.5, 320, 1, 0.3],
|
... index=midx)
|
>>> s
|
lama speed 45.0
|
weight 200.0
|
length 1.2
|
cow speed 30.0
|
weight 250.0
|
length 1.5
|
falcon speed 320.0
|
weight 1.0
|
length 0.3
|
dtype: float64
|
|
>>> s.drop(labels='weight', level=1)
|
lama speed 45.0
|
length 1.2
|
cow speed 30.0
|
length 1.5
|
falcon speed 320.0
|
length 0.3
|
dtype: float64
|
)r r r rF rL r r¼ )rA rJ r rB r r¡ rJ x s aù)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¡ Úfillnaã s z Series.fillna)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||||||dS )N)rß rì r r r r )rA r r rB r r¡ r
|
s ú)r; r³ c s t j|dS )aÁ
|
Return item and drops from series. Raise KeyError if not found.
|
|
Parameters
|
----------
|
item : label
|
Index of the element that needs to be removed.
|
|
Returns
|
-------
|
Value that is popped from series.
|
|
Examples
|
--------
|
>>> ser = pd.Series([1,2,3])
|
|
>>> ser.pop(0)
|
1
|
|
>>> ser
|
1 2
|
2 3
|
dtype: int64
|
)r; )rA rG )r r; rB r r¡ rG s z
|
Series.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¡ Úreplace9 s zSeries.replace)r r rì c C s d S rØ r r r r r¡ r F s r r )r r r c s t j||||||dS )N)r rß r r r rì )rA r r rB r r¡ r S s úzbool | str | None)ÚverboserW Úmax_colsÚ memory_usageÚ show_countsr³ c C s t | |j||||dS )N)rW r" r! r$ )r{ Úrender)r r! rW r" r# r$ r r r¡ Úinfol s
|
üz Series.info)rì r c C s` |r| n| ¡ }|j}t ||¡}t|tr<| |||¡ nt |¡}||||d |r\dS |S )z
|
Replaces values in a Series using the fill method specified when no
|
replacement value is given in the replace method
|
)r r. N)r± rÉ r[ Z mask_missingr¾ r` Z_fill_mask_inplaceZ get_fill_func) r r rì r r rù rÖ r. Zfill_fr r r¡ Ú_replace_single| s
|
|
zSeries._replace_single)r© r rÊ r³ c s t j||||dS )N)r© Úfreqr rÊ )rA r¬ )r r© r( r rÊ rB r r¡ r¬ s ÿz Series.shift)r rµ r³ c C s& | j |d}|r"|| jj|d7 }|S )aP
|
Return the memory usage of the Series.
|
|
The memory usage can optionally include the contribution of
|
the index and of elements of `object` dtype.
|
|
Parameters
|
----------
|
index : bool, default True
|
Specifies whether to include the memory usage of the Series index.
|
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 value.
|
|
Returns
|
-------
|
int
|
Bytes of memory consumed.
|
|
See Also
|
--------
|
numpy.ndarray.nbytes : Total bytes consumed by the elements of the
|
array.
|
DataFrame.memory_usage : Bytes consumed by a DataFrame.
|
|
Examples
|
--------
|
>>> s = pd.Series(range(3))
|
>>> s.memory_usage()
|
152
|
|
Not including the index gives the size of the rest of the data, which
|
is necessarily smaller:
|
|
>>> s.memory_usage(index=False)
|
24
|
|
The memory footprint of `object` values is ignored by default:
|
|
>>> s = pd.Series(["a", "b"])
|
>>> s.values
|
array(['a', 'b'], dtype=object)
|
>>> s.memory_usage()
|
144
|
>>> s.memory_usage(deep=True)
|
244
|
r´ )Z _memory_usager r# )r r rµ rq r r r¡ r# s 1 zSeries.memory_usagec C s* t | j|¡}| j|| jddj| ddS )ad
|
Whether elements in Series are contained in `values`.
|
|
Return a boolean Series showing whether each element in the Series
|
matches an element in the passed sequence of `values` exactly.
|
|
Parameters
|
----------
|
values : set or list-like
|
The sequence of values to test. Passing in a single string will
|
raise a ``TypeError``. Instead, turn a single string into a
|
list of one element.
|
|
Returns
|
-------
|
Series
|
Series of booleans indicating if each element is in values.
|
|
Raises
|
------
|
TypeError
|
* If `values` is a string
|
|
See Also
|
--------
|
DataFrame.isin : Equivalent method on DataFrame.
|
|
Examples
|
--------
|
>>> s = pd.Series(['lama', 'cow', 'lama', 'beetle', 'lama',
|
... 'hippo'], name='animal')
|
>>> s.isin(['cow', 'lama'])
|
0 True
|
1 True
|
2 True
|
3 False
|
4 True
|
5 False
|
Name: animal, dtype: bool
|
|
To invert the boolean values, use the ``~`` operator:
|
|
>>> ~s.isin(['cow', 'lama'])
|
0 False
|
1 False
|
2 False
|
3 True
|
4 False
|
5 True
|
Name: animal, dtype: bool
|
|
Passing a single string as ``s.isin('lama')`` will raise an error. Use
|
a list of one element instead:
|
|
>>> s.isin(['lama'])
|
0 True
|
1 False
|
2 True
|
3 False
|
4 True
|
5 False
|
Name: animal, dtype: bool
|
|
Strings and integers are distinct and are therefore not comparable:
|
|
>>> pd.Series([1]).isin(['1'])
|
0 False
|
dtype: bool
|
>>> pd.Series([1.1]).isin(['1.1'])
|
0 False
|
dtype: bool
|
Fré Úisinrë )rX r) rÉ rÙ r rí )r rÖ rù r r r¡ r) Ñ s
|
I ÿz Series.isinÚbothz-Literal[('both', 'neither', 'left', 'right')])Ú inclusiver³ c C sx |dkr| |k}| |k}nV|dkr4| |k}| |k }n<|dkrN| |k}| |k}n"|dkrh| |k}| |k }nt d||@ S )aý
|
Return boolean Series equivalent to left <= series <= right.
|
|
This function returns a boolean vector containing `True` wherever the
|
corresponding Series element is between the boundary values `left` and
|
`right`. NA values are treated as `False`.
|
|
Parameters
|
----------
|
left : scalar or list-like
|
Left boundary.
|
right : scalar or list-like
|
Right boundary.
|
inclusive : {"both", "neither", "left", "right"}
|
Include boundaries. Whether to set each bound as closed or open.
|
|
.. versionchanged:: 1.3.0
|
|
Returns
|
-------
|
Series
|
Series representing whether each element is between left and
|
right (inclusive).
|
|
See Also
|
--------
|
Series.gt : Greater than of series and other.
|
Series.lt : Less than of series and other.
|
|
Notes
|
-----
|
This function is equivalent to ``(left <= ser) & (ser <= right)``
|
|
Examples
|
--------
|
>>> s = pd.Series([2, 0, 4, 8, np.nan])
|
|
Boundary values are included by default:
|
|
>>> s.between(1, 4)
|
0 True
|
1 False
|
2 True
|
3 False
|
4 False
|
dtype: bool
|
|
With `inclusive` set to ``"neither"`` boundary values are excluded:
|
|
>>> s.between(1, 4, inclusive="neither")
|
0 True
|
1 False
|
2 False
|
3 False
|
4 False
|
dtype: bool
|
|
`left` and `right` can be any scalar value:
|
|
>>> s = pd.Series(['Alice', 'Bob', 'Carol', 'Eve'])
|
>>> s.between('Anna', 'Daniel')
|
0 False
|
1 True
|
2 True
|
3 False
|
dtype: bool
|
r* r² r³ ZneitherzJInclusive has to be either string of 'both','left', 'right', or 'neither'.)rÊ )r r² r³ r+ ZlmaskZrmaskr r r¡ Úbetween s I
|
|
|
|
ÿzSeries.betweenÚnumpy_nullabler! )Ú infer_objectsÚconvert_stringÚconvert_integerÚconvert_booleanÚconvert_floatingÚ dtype_backendr³ c
|
C sf | }|r$| ¡ }t|r$|jd d}|s4|s4|s4|rVt|j||||||}| |¡} n |jd d} | S )Nr´ )r. rN r± rD rÉ rÇ )
|
r r. r/ r0 r1 r2 r3 Z input_seriesZinferred_dtyperù r r r¡ Ú_convert_dtypes s$ ù zSeries._convert_dtypesc C s
|
t | ¡S rØ )re rT r r r r¡ rT s z Series.isnac s
|
t ¡ S )z<
|
Series.isnull is an alias for Series.isna.
|
)rA Úisnullr rB r r¡ r5 ¥ s z Series.isnullc s
|
t ¡ S rØ )rA rV r rB r r¡ rV s z Series.notnac s
|
t ¡ S )z>
|
Series.notnull is an alias for Series.notna.
|
)rA Únotnullr rB r r¡ r6 ² s zSeries.notnull)r r Úhowr z AnyAll | None)r r r7 r r³ c C s d S rØ r ©r r r r7 r r r r¡ rz ¹ s z Series.dropna)r r7 r c C s d S rØ r r8 r r r¡ rz Ä s c C sp t |d}t |d}| |p d¡ | jr2t| }n|sD| jdd}n| }|rZtt||_|rh| |¡S |S dS )u*
|
Return a new Series with missing values removed.
|
|
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'}
|
Unused. Parameter needed for compatibility with DataFrame.
|
inplace : bool, default False
|
If True, do operation inplace and return None.
|
how : str, optional
|
Not in use. Kept for compatibility.
|
ignore_index : bool, default ``False``
|
If ``True``, the resulting axis will be labeled 0, 1, â¦, n - 1.
|
|
.. versionadded:: 2.0.0
|
|
Returns
|
-------
|
Series or None
|
Series with NA entries dropped from it or None if ``inplace=True``.
|
|
See Also
|
--------
|
Series.isna: Indicate missing values.
|
Series.notna : Indicate existing (non-missing) values.
|
Series.fillna : Replace missing values.
|
DataFrame.dropna : Drop rows or columns which contain NA values.
|
Index.dropna : Drop missing indices.
|
|
Examples
|
--------
|
>>> ser = pd.Series([1., 2., np.nan])
|
>>> ser
|
0 1.0
|
1 2.0
|
2 NaN
|
dtype: float64
|
|
Drop NA values from a Series.
|
|
>>> ser.dropna()
|
0 1.0
|
1 2.0
|
dtype: float64
|
|
Empty strings are not considered NA values. ``None`` is considered an
|
NA value.
|
|
>>> ser = pd.Series([np.NaN, 2, pd.NaT, '', None, 'I stay'])
|
>>> ser
|
0 NaN
|
1 2
|
2 NaT
|
3
|
4 None
|
5 I stay
|
dtype: object
|
>>> ser.dropna()
|
1 2
|
3
|
5 I stay
|
dtype: object
|
r r r Nr´ ) r@ r} rÜ rW r± rm r r r )r r r r7 r rù r r r¡ rz Ï s J
|
|
|
|
r% )r( rì r7 Ú normalizerÊ r³ c s t j|||||dS )N)r( rì r7 r9 rÊ )rA Úasfreq)r r( rì r7 r9 rÊ rB r r¡ r: 2 s ûz Series.asfreqÚstartÚ start_dayz str | TimestampConvertibleTypesz TimedeltaConvertibleTypes | Noner ) r Úclosedr Ú
|
conventionr ÚonrL ÚoriginÚoffsetrx r³ c s" t j||||||||| |
|
| d S )N) Úruler r= r r> r r? rL r@ rA rx )rA Úresample) r rB r r= r r> r r? rL r@ rA rx rB r r¡ rC D s õzSeries.resamplez#Literal[('s', 'e', 'start', 'end')])r7 r± r³ c C sV t | jts"tdt| jj | j|o0t d}| jj||d}t |d| |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.
|
copy : bool, default True
|
Whether or not to return a copy.
|
|
Returns
|
-------
|
Series with DatetimeIndex
|
|
Examples
|
--------
|
>>> idx = pd.PeriodIndex(['2023', '2024', '2025'], freq='Y')
|
>>> s1 = pd.Series([1, 2, 3], index=idx)
|
>>> s1
|
2023 1
|
2024 2
|
2025 3
|
Freq: A-DEC, dtype: int64
|
|
The resulting frequency of the Timestamps is `YearBegin`
|
|
>>> s1 = s1.to_timestamp()
|
>>> s1
|
2023-01-01 1
|
2024-01-01 2
|
2025-01-01 3
|
Freq: AS-JAN, dtype: int64
|
|
Using `freq` which is the offset that the Timestamps will have
|
|
>>> s2 = pd.Series([1, 2, 3], index=idx)
|
>>> s2 = s2.to_timestamp(freq='M')
|
>>> s2
|
2023-01-31 1
|
2024-01-31 2
|
2025-01-31 3
|
Freq: A-JAN, dtype: int64
|
úunsupported Type r´ )r( r7 r )
|
r¾ r rl r rÅ r r± r Ú to_timestampÚsetattr)r r( r7 r± Únew_objr÷ r r r¡ rE a s 4 zSeries.to_timestamp)r( r± r³ c C sT t | jts"tdt| jj | j|o0t d}| jj|d}t |d| |S )a
|
Convert Series from DatetimeIndex to PeriodIndex.
|
|
Parameters
|
----------
|
freq : str, default None
|
Frequency associated with the PeriodIndex.
|
copy : bool, default True
|
Whether or not to return a copy.
|
|
Returns
|
-------
|
Series
|
Series with index converted to PeriodIndex.
|
|
Examples
|
--------
|
>>> idx = pd.DatetimeIndex(['2023', '2024', '2025'])
|
>>> s = pd.Series([1, 2, 3], index=idx)
|
>>> s = s.to_period()
|
>>> s
|
2023 1
|
2024 2
|
2025 3
|
Freq: A-DEC, dtype: int64
|
|
Viewing the index
|
|
>>> s.index
|
PeriodIndex(['2023', '2024', '2025'], dtype='period[A-DEC]')
|
rD r´ )r( r )
|
r¾ r ri r rÅ r r± r Ú to_periodrF )r r( r± rG r÷ r r r¡ rH s zSeries.to_period©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¡ ÚffillÅ s z Series.ffill)r r r c C s d S rØ r rJ r r r¡ rK Ð s c C s d S rØ r rJ r r r¡ rK Û s c s t j||||dS ©NrI )rA rK rJ rB r r¡ rK æ s c C s d S rØ r rJ r r r¡ Úbfillð s z Series.bfillc C s d S rØ r rJ r r r¡ rM û s c C s d S rØ r rJ r r r¡ rM s c s t j||||dS rL )rA rM rJ rB r r¡ rM s ©r r )r r r r³ c s t j||f||d|S )NrN )rA Úclip)r ÚlowerÚupperr r rö rB r r¡ rO s z Series.clip)r r r Úlimit_directionÚ
|
limit_arear ) r rì r r r rR rS r r³ c
|
s" t jf |||||||d|S )N)rì r r r rR rS r )rA Ú interpolate) r rì r r r rR rS r rö rB r r¡ rT & s ùøzSeries.interpolate©r r rL )r r rL r³ c C s d S rØ r ©r Zcondr r r rL r r r¡ rÜ = s
|
z Series.where)r rL c C s d S rØ r rV r r r¡ rÜ I s
|
c C s d S rØ r rV r r r¡ rÜ U s
|
c s t j|||||dS ©NrU )rA rÜ rV rB r r¡ rÜ a s ûc C s d S rØ r rV r r r¡ r. r s
|
z Series.maskc C s d S rØ r rV r r r¡ r. ~ s
|
c C s d S rØ r rV r r r¡ r. s
|
c s t j|||||dS rW )rA r. rV rB r r¡ r. s ûz#list[Literal[('index', 'columns')]]Ú _AXIS_ORDERSz
|
Literal[0]Ú_info_axis_numberzLiteral['index']Ú_info_axis_namez&The index (axis labels) of the Series.)r r= Úplotc C sp t | |¡}t|tr(| |¡s(td| j}t|ddd}tj dd t
|
|||¡}W 5 Q R X | j ||dS )Nz3Can only compare identically-labeled Series objectsT©Z extract_numpyZ extract_ranger» rÄ rÌ ) r] rÇ r¾ r
Z _indexed_samerÊ rÉ rc r rÆ Z comparison_oprÈ ©r r r Zres_nameZlvaluesZrvaluesrî r r r¡ Ú _cmp_method s zSeries._cmp_methodc C sP t | |¡}t j| |dd\} }| j}t|ddd}t |||¡}| j||dS )NT)Zalign_asobjectr\ rÌ )r] rÇ Úalign_method_SERIESrÉ rc Z
|
logical_oprÈ r] r r r¡ Ú_logical_methodÐ s zSeries._logical_methodc C s t | |¡\} }tj | ||¡S rØ )r] r_ rY rº Ú _arith_method)r r r r r r¡ ra Ú s zSeries._arith_method)NNNNNF)NN)rá )N)N)r )r )r )r )F)F)FTF)N).).).)N)
|
..........) .........)
|
Nr_ NTTFFFNN)Nrh TN)F)Nr NTTTFT)T)r )r T)r T)r )..).)..)r r )r N)Nr )r )r )r² N)FF)NN)r FFrµ )N)r rä N)rì r )rì r )ró r, N)F)r, N)N)N)Nr )r NTN)r )Tr ) rà NNNNNNr N).).).)N)N).).).)N).).).)N)..)..)NNNNT)r Nr N)TF)r* )TTTTTr- )NNFN)
|
r NNr; NNNr< NF)Nr; N)NN)NN)r ).).).).).).)Âr Ú
|
__module__Ú __qualname__Ú__doc__Z_typrj r` r rà Z_HANDLED_TYPESÚ__annotations__r§ re Z_internal_names_setZ
|
_accessorsrY rº Z _hidden_attrsÚ frozensetÚpropertyZhasnansÚfgetr¿ rÌ rÙ rÛ rÜ r° rÞ r¦ ÚsetterrÖ rÉ rÈ r; r· rã rè rê rð r¤ r Ú __float__rç Ú__int__r rò rú rü rÿ r r r rþ r r* r& r' r+ r% r0 r4 r6 r8 r< r= r$ r( r@ rI r rN r rQ rV rU r= Ú_shared_doc_kwargsru r rj rm rÔ rn rs rR rt ru r ri r r r r r r r r¥ r§ rª r r® r¶ r· r» r rË rÈ rÎ rÚ rÝ rß rã rè rê rð rò rõ rö r÷ rù rü rý Z_agg_see_also_docZ_agg_examples_docrþ r r- r r r r r r¢ r r< r rË r rJ r rG r rz r| r& r' r¬ r# r) r, r4 rT r5 rV r6 rz r: rC rE rH rK rM rO rT rÜ r. rX r Z _AXIS_LENrY rZ r Z AxisPropertyr r^ rx rª rh r¨ ra r© ÚpandasZplottingZ PlotAccessorr[ rb r« Z hist_seriesÚhistr^ r` ra Ú __classcell__r r rB r¡ r
ô s@
|
a ÿý ù ÿ5
|
1
|
)
|
! N :
|
+()Q ÿ$:þù þù þù þù õ õ õ$Nÿý! û. '(ÿR ÷"# Aû ÿ ÿû aPFG( ÿý ý ýC üN ü0ÿü1 )-N ü& ÿ# &<ÂC ú*ü d4P÷. ÷.÷, Iõ6õ6õ6õ8 ü 0 ÿ d aÿÿú= ÿ D 4ý Tÿ ÿû ú$ û& û$
|
ýÿ ü"uø ( ý õ8þø0 þø0 þø0þø2^ÿü
|
|
û(
|
ýþö2þù,þ÷. þ÷. þ÷.þ÷0kþø0 þø0 þø0 þø4 ýø& ýø& üýø*
|
ú$ ÿ" 6Rüb ù$!ú&
|
ú& ú$c ú* ô6 ü < (ú*
|
ú*
|
ú* ú,
|
ú*
|
ú*
|
ú* ú, ýú& þ÷.ýù$ ýù$ ýù$ýù&ýù$ ýù$ ýù$ýù& ÿ
|
|
|
|
|
)Ærd Ú
|
__future__r r" Útextwrapr Útypingr r r r r r r
|
r r r r r r r9 Únumpyr Zpandas._configr r Z pandas._libsr r r Zpandas._libs.internalsr Zpandas._libs.libr Zpandas._typingr r r r r 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 Z pandas.compatr6 Zpandas.compat.numpyr7 ró Z pandas.errorsr8 r9 r: Zpandas.util._decoratorsr; r< r= Zpandas.util._exceptionsr> Zpandas.util._validatorsr? r@ rA Zpandas.core.dtypes.astyperB Zpandas.core.dtypes.castrC rD rE rF Zpandas.core.dtypes.commonrG rH rI rJ rK rL rM rN rO rP rQ Zpandas.core.dtypes.genericrR Z pandas.core.dtypes.inferencerS Zpandas.core.dtypes.missingrT rU rV rW Z pandas.corerX rY rZ rÏ r[ r\ r] Zpandas.core.accessorr^ Zpandas.core.applyr_ Zpandas.core.arraysr` Z pandas.core.arrays.categoricalra Zpandas.core.arrays.sparserb Zpandas.core.constructionrc rd Zpandas.core.genericre Zpandas.core.indexersrf rg Z pandas.core.indexes.accessorsrh Zpandas.core.indexes.apiri rj rk rl rm rn Zpandas.core.indexes.baseÚcoreZindexesrÄ Zpandas.core.indexes.multiro Zpandas.core.indexingrp rq Zpandas.core.internalsrr rs Zpandas.core.methodsrt Zpandas.core.shared_docsru Zpandas.core.sortingrv rw Z pandas.core.strings.accessorrx Zpandas.core.tools.datetimesry Zpandas.io.formats.formatÚioÚformatsÚformatrT Zpandas.io.formats.inforz r{ r| Zpandas.plottingrm r} r~ r rÚ r r| r Zpandas.core.resampler Ú__all__rl r¤ rº r
Z_add_numeric_operationsZadd_flex_arithmetic_methodsr r r r¡ Ú<module> sæ 8 ! 4 î
|
