3
���hEW � @ s2 d Z ddlmZ ddlmZ ddlmZ ddlmZm Z m
Z
m Z m Z m
Z
mZmZmZmZ ddlZddlZddlmZ ddlmZmZmZmZ dd l m Z dd
l m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z% dd l&m'Z( dd l)m*Z* dd
l+m,Z,m-Z-m.Z. ddl/m0Z0m1Z1 ddl2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@ ddlAmBZB ddlCmDZD ddlEmFZFmGZGmHZHmIZI ddlJZKddlLmMZMmNZNmOZOmPZPmQZQ ddlRmSZS ddlTmUZU ddlVmWZW ddlXmYZY ddlZj[j\Z]ddl^m_Z_m`Z`maZambZb ddlcmdZd ddlemfZfmgZg dd lhmiZi dd ljmkZkmlZlmmZmmnZn ddloj[jpjNZqdd lrmsZs dd ltmuZu dd lvmwZw dd!lxmyZy dd"lzm{Z{ dd#l|m}Z} dd$l~mZ dd%l�m�Z� ddl�jj�j�Z�ddl�ZJe �r�dd&l�m�Z� dd'l�m�Z� d(gZ�e�d)d(d*d+d,d-d(d.d.d.d.d/d0� Z�d1d2� Z�G d3d(� d(eNj�eOjd�Z�e�j�� e�j�� eQj�e�� eQj�e�� dS )4zG
Data structure for 1-dimensional cross-sectional and time series data
� )�StringIO)�get_terminal_size)�dedent)
�IO�
TYPE_CHECKING�Any�Callable�Iterable�List�Optional�Tuple�Type�UnionN)�
get_option)�lib�
properties�reshape�tslibs)�
no_default)� ArrayLike�Axis�DtypeObj�FrameOrSeriesUnion� IndexKeyFunc�Label� ValueKeyFunc)�function)�InvalidIndexError)�Appender� Substitution�doc)�validate_bool_kwarg�validate_percentile)�convert_dtypes� maybe_cast_to_extension_array�validate_numeric_casting)
�ensure_platform_int�is_bool�is_categorical_dtype� is_dict_like�is_extension_array_dtype�
is_integer� is_iterator� is_list_like�is_object_dtype� is_scalar)� ABCDataFrame)� is_hashable)�isna�na_value_for_dtype�notna�remove_na_arraylike)�
algorithms�base�generic�nanops�ops)�CachedAccessor)�ExtensionArray)�CategoricalAccessor)�SparseAccessor)�!create_series_with_explicit_dtype�
extract_array�
is_empty_data�sanitize_array)�NDFrame)�deprecate_ndim_indexing�
unpack_1tuple)� CombinedDatetimelikeProperties)� Float64Index�Index�
MultiIndex� ensure_index)�
DatetimeIndex)� PeriodIndex)�TimedeltaIndex)�check_bool_indexer)�SingleBlockManager)�ensure_key_mapped)�
StringMethods)� to_datetime)� DataFrame)�
SeriesGroupBy�Series�indexz{0 or 'index'}zPaxis : {0 or 'index'}
Parameter needed for compatibility with DataFrame.z^inplace : boolean, default False
If True, performs operation inplace and returns None.z
np.ndarray� z
.. versionadded:: 0.20.0
) �axes�klass�axes_single_arg�axis�inplace�unique�
duplicatedZ optional_byZoptional_mapper�optional_labels�
optional_axisZversionadded_to_excelc s � fdd�}d� j � d�|_ |S )z.
Install the scalar coercion methods.
c s, t | �dkr� | jd �S td� � ���d S )N� r z cannot convert the series to )�len�iloc� TypeError)�self)� converter� �4/tmp/pip-build-5_djhm0z/pandas/pandas/core/series.py�wrapper~ s z _coerce_method.<locals>.wrapper�__)�__name__)rf ri rg )rf rh �_coerce_methody s rl c s�
e Zd ZU dZdZedgZee dhe
j j B Z ddddhZ
ejje
j jB ed d
g�B Zeejjjejjjd �Zeed egd f ed egd f �d,dd�Z�d-dd�Z ee d d�dd��Z ee d d�dd��Z edd� �Z d Z!�d.e"e#d d�dd �Z$ee%d�d d ��Z&ee%d�d d ��Z'eed�d!d"��Z(e(j)ed d#�d$d"��Z(ed%d&� �Z*ed'd(� �Z+e,ejj-j�ee.d�d)d*���Z-�d/d,d-�Z/e"d�d.d/�Z0�d0d d�d0d1�Z1e2e.e3j4fZ5ee eed2�d3d4�Z6�d1e3j4d�d5d6�Z7e8e9�Z:e8e"�Z;e8e"�Z<eee2 d�d7d8��Z=e,e
j j>j��d2d d�d:d;��Z>�d3d<d=�Z?�d4e"e"d>�d?d@�Z@�d5eAe"d dA�dBdC�ZBdDdE� ZCdFdG� ZDdHdI� ZEdJdK� ZF�d6e#dL�dMdN�ZGdOdP� ZHdQdR� ZIdSdT� ZJdUdV� ZKdWdX� ZL�d7e#dL�dYdZ�ZMed[d\� �ZN�d8d d�d]d^�ZO�d9d_d`�ZPe d�dadb�ZQ�d:dedf�ZReSeTdg eUdh�di��d;eVeWe eVe e#eVe dj�dkdl��ZXeYeZeef d�dmdn�Z[e,e[j�eYeZeef d�dodp��Z\e2d�dqdr�Z]e^fdsdt�Z_�d<dd�dudv�Z`�d=d d�dwdx�Zae,dy�e,e
jbdz eT �d d9d ddddddecd
ddf e#e#e#e#e#e#d{d|�d}d~���Zd�d>dd��Ze�d?d d�d�d��Zf� fd�d��Zg�d@eVd d�� fd�d��
Zh�dAd d�� fd�d��
Zi�dBd�d��Zj�dCd�d��Zk�dDd d�d�d��Zl�dEd�d��Zm�dFe9d�d�d��Zn�dGd eVe" eVe" e9d��d�d��ZoeSd d�deUd��d���dHe"d d��d�d���Zp�dIe9d�d�d��Zqd�d�� Zrd�d�� Zsd�d�� ZteSejjud d���dJd�d���Zu�dKd�d��Zv�dLd�d��ZwexeyeZeyeyf f eexd eZ�dM f d��d�d��Zze,d��e,e
jbd� eT ��dNd e{e#e#e|d��� fd�d��
��Z}�dOd d�d�d��Z~d d�d�d��Zd d�d�d��Z��dPe#e e e#e�d��d�dÄZ��dQe#e#e e e#e#e�dĜd�dƄZ��dRd d�d�dȄZ��dSd d�d�d˄Z��dTd d�d�d̈́Z��dWd d�d�dЄZ�d d�d�d҄Z��dXe#d dӜd�dՄZ��dZd�dׄZ��d[d d�� fd�dل
Z��d\d d�d�dۄZ�eUd܃Z�eUd݃Z�eSe
jbd� eTdg eTd� e�e�d�d��d]d�d��Z�e�Z�eSe j�eTdg eTd� d��d^� fd�d� �Z�ddf fd�d�Z��d_d�d�Z�d�d� Z�d�d� Z�eSe j�eTdg eTd� d��d`� fd�d� �Z��dad ddd
d d�d��� fd�d�� Z�e,d��e�f eTd�d�d�d����e,e
j j�j��dbe{e#d��� fd�d��
���Z�eSe j�eTdg eTd� eTd� eTd� �d ��dc� f�d�d� �Z��ddd d�� f�d�d�
Z�eSe j�feT��deeVd d�� f�d�d�
�Z�ee�d�� f�d �d
� Z�eSe j�eTdg d���df� f�d �d
� �Z�eSe j�eTdg d���dgd d�� f�d�d�
�Z��dh� f�d�d� Z�d d��d�d�Z��did d��d�d�Z��dje#e#e#e#d �d��d�d�Z�eSe j�eTdg d��d d�� f�d�d� �Z�eSe j�eTdg d��d d�� f�d�d � �Z�eSe j�eTdg d��d d�� f�d �d � �Z�eSe j�eTdg d��d d�� f�d �d � �Z��dk�d!�d"�Z��dld d��d$�d%�Z��dmd d��d&�d'�Z�dgZ�d
Z�e�e��Z�d9Z�dZ�e�j�d9�d(�d)�Z��d*�e�de��Z e�de��Z�e�de��Z�e��d+e�j�j��Z�e�de��Z�e�j�j�Z Z�S (n rU a
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.
.. versionchanged:: 0.23.0
If data is a dict, argument order is maintained for Python 3.6
and later.
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 both a dict and index
sequence are used, the index will override the keys found in the
dict.
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 : str, optional
The name to give to the Series.
copy : bool, default False
Copy input data.
Zseries�namerV �dt�cat�str�sparse�compressZptp)r NFc C s t |t�r8|d kr8|d kr8|dkr8tj| |� || _d S |rpt |t�sRtj||�}|r^|j� }|d krl|j}�n|tj ||t
| ��}t |�r�|d kr�t j
dtdd� |d k r�t|�}|d kr�i }|d k r�| j|�}t |t�r�td���n0t |t��r|d k �r|j|�}n
|jj� }d}n�t |tj��r<t|j��rtd��n�t |t��rt|d k�rZ|j}n|j ||d�}d}|j }n�t |��r�| j |||�\}}d }d}n|t |t��r�|d k�r�|j}n |jj |� �s�|�rt!d��n>t"|��r�n2t |t#t$f��r t%d t
|�j&� d
���n
t'j(|�}|d k�r@t)|��s0|g}tj*t|��}nVt)|��r�y4t|�t|�k�r|td t|�� d t|�� d
���W n t%k
�r� Y nX t |t��r�|d k �r�|j|d|d�}n|�r�|j� }n t+||||dd�}tj||�}t,jj| |� || _| j-d|dd� d S )NFz�The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.� )�
stacklevelz8initializing a Series from a MultiIndex is not supportedzVCannot construct a Series from an ndarray with compound dtype. Use DataFrame instead.)�copyzkCannot pass both SingleBlockManager `data` argument and a different `index` argument. `copy` must be False.�'z' type is unorderedzLength of passed values is z, index implies �.�ignore)�dtype�errorsru T)Zraise_cast_failurer )�fastpath).�
isinstancerO rC �__init__rm Z
from_arrayru rV �ibaseZmaybe_extract_name�typerA �warnings�warn�DeprecationWarningrJ Z_validate_dtyperI �NotImplementedErrorrH �astype�_values�np�ndarrayrb ry �
ValueErrorrU �reindex�_mgrr) �
_init_dict�equals�AssertionErrorr* �set� frozensetrd rk �comZmaybe_iterable_to_listr- �
default_indexrB r8 � _set_axis)re �datarV ry rm ru r{ rg rg rh r} � s�
zSeries.__init__c C sv |r t |j� � \}}t|�}n |dk r4t|�}|}n
g g }}t|||tjd�}|rj|dk rj|j|dd�}|j|j fS )a7
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 index-like, default None
Index for the new Series: if None, use dict keys.
dtype : dtype, 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
N)rV ry Zdtype_if_emptyF)ru )
�zip�items�listr3 r? r� Zfloat64r� r� rV )re r� rV ry �keys�values�srg rg rh r� O s
zSeries._init_dict)�returnc C s t S )N)rU )re rg rg rh � _constructor} s zSeries._constructorrS c C s ddl m} |S )Nr )rS )�pandas.core.framerS )re rS rg rg rh �_constructor_expanddim� s z Series._constructor_expanddimc C s | j jS )N)r� � _can_hold_na)re rg rg rh r� � s zSeries._can_hold_na)r[ r{ r� c C s� |s t |�}|j}|r`t|tttf�s`y t|�}|rB| jj||� W n tj t
fk
r^ Y nX t j | d|� |s�| jj||� dS )z�
Override generic, we want to set the _typ here.
This is called from the cython code when we set the `index` attribute
directly, e.g. `series.index = [1, 2, 3]`.
�_indexN)
rJ � is_all_datesr| rK rL rM r� �set_axisr ZOutOfBoundsDatetimer� �object� __setattr__)re r[ �labelsr{ r� rg rg rh r� � s zSeries._set_axisc C s | j jS )zA
Return the dtype object of the underlying data.
)r� ry )re rg rg rh ry � s z Series.dtypec C s | j S )zA
Return the dtype object of the underlying data.
)ry )re rg rg rh �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'
)�_name)re rg rg rh rm � s 0z Series.name)�valuer� c C s" t |�std��tj| d|� d S )Nz#Series.name must be a hashable typer� )r1 rd r� r� )re r� rg rg rh rm � s c C s
| j 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_values)re rg rg rh r� � s (z
Series.valuesc C s
| j 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_values)re rg rg rh r� s zSeries._valuesc C s | j jj� S )N)r� �_blockZ array_values)re rg rg rh �array> s z Series.array�Cc C s | j j|d�S )a
Return the flattened underlying data as an ndarray.
Returns
-------
numpy.ndarray or ndarray-like
Flattened data of the Series.
See Also
--------
numpy.ndarray.ravel : Return a flattened array.
)�order)r� �ravel)re r� rg rg rh r� D s
z Series.ravelc C s
t | j�S )z2
Return the length of the Series.
)rb r� )re rg rg rh �__len__S s zSeries.__len__c C s" | j | jj|�| jd�j| dd�S )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
)rV �view)�method)r� r� r� rV � __finalize__)re ry rg rg rh r� Y s Bz Series.view)�ufuncr� �inputs�kwargsc s� t ��}tj�|�f|�|�}|tk r*|S tjj|jf}xT|D ]L}t|d�oV|j�jk} t|d�o|t |�j|ko|t |�j
� }
| s�|
r>tS q>W dd� |D �} t dd� |D ��} dd� t || �D �}
t
|
�dk�r|
d j�x |
dd � D ]}�|jO �q�W t �fd
d�t || �D ��}n�j�t d d� |D ��}t|��||�}t
t| ��dk�rZ| d nd �����fd d
�� t |�t k�r�t � fdd�|D ��S �dk�r�d S � |�S d S )N�__array_priority__�__array_ufunc__c S s g | ]}t |d �rt|d ��qS )rm )�hasattr�getattr)�.0�xrg rg rh �
<listcomp>� s z*Series.__array_ufunc__.<locals>.<listcomp>c s s | ]}t |�V qd S )N)r )r� r� rg rg rh � <genexpr>� s z)Series.__array_ufunc__.<locals>.<genexpr>c S s g | ]\}}t |t�r|�qS rg )�
issubclassrU )r� r� �trg rg rh r� � s ra r c 3 s* | ]"\}}t |t�r |j� �n|V qd S )N)r� rU r� )r� r� r� )rV rg rh r� � s c s s | ]}t |d d�V qdS )T)Z
extract_numpyN)r@ )r� r� rg rg rh r� � s c s: t j| �r| S | jdkr(�dkr$t�| S �j| � �dd�S )Nra �outerF)rV rm ru )r r/ �ndimr� r� )�result)rV r� rm re rg rh �construct_return� s
z0Series.__array_ufunc__.<locals>.construct_returnc 3 s | ]}� |�V qd S )Nrg )r� r� )r� rg rh r� � s Zat)r r: Z!maybe_dispatch_ufunc_to_dunder_op�NotImplementedr� r� r� r� r� r| �_HANDLED_TYPES�tupler� rb rV r� r� )re r� r� r� r� �clsr� Zno_defer�itemZhigher_priorityZhas_array_ufunc�names�typesZ alignabler� rg )r� rV r� rm re rh r� � sD
zSeries.__array_ufunc__c C s t j| 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', freq='D'),
Timestamp('2000-01-02 00:00:00+0100', tz='CET', freq='D')],
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� �asarrayr� )re ry rg rg rh � __array__� s /zSeries.__array__c C s | j gS )z7
Return a list of the row axis labels.
)rV )re rg rg rh rX * s z Series.axesr c K sd |d k rt jdtdd� tjt� |� t|�}| jj|�}| j j|�}| j
||dd�}|j | dd�S )Nz�is_copy is deprecated and will be removed in a future version. 'take' always returns a copy, so there is no need to specify this.rs )rt T)rV r{ �take)r� ) r� r� �
FutureWarning�nvZ
validate_taker� r& rV r� r� r� r� )re �indicesr[ Zis_copyr� � new_index�
new_valuesr� rg rg rh r� 4 s z Series.takec C s | j ||d�S )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� )re r� r[ rg rg rh �_take_with_is_copyF s zSeries._take_with_is_copy)�ir[ 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� )re r� r[ rg rg rh �_ixsQ s z Series._ixs)�slobjr[ r� c C s
| j |�S )N)� _get_values)re r� r[ rg rg rh �_slice_ s z
Series._slicec C s� t j|| �}|tkr| S t|�}t|ttf�r6t|�}t|�rR| j j
� rR| j | S |r`| j |�S t
|�r�y| j |�}|S ttfk
r� t|t�r�t| j t�r�| j|�S Y nX t|�r�t|�}t j|�r�t| j |�}tj|td�}| j|�S | j|�S )N)ry )r� �apply_if_callable�Ellipsisr/ r| r� r� rE r+ rV � _should_fallback_to_positionalr� �
_get_valuer1 �KeyErrorrd rI �_get_values_tupler, �is_bool_indexerrN r� r� �boolr� � _get_with)re �keyZ
key_is_scalarr� rg rg rh � __getitem__d s0
zSeries.__getitem__c C s� t |t�r$| jj|dd�}| j|�S t |t�r8td��n&t |t�rL| j|�S t |�s^| j
| S t |t t j
tttf�s|t |�}t |t�r�|j}ntj|dd�}|dkr�| jj� s�| j
| S | j| S | j
| S )N�getitem)�kindzWIndexing a Series with DataFrame is not supported, use the appropriate DataFrame columnF)�skipna�integer)r| �slicerV �_convert_slice_indexerr� r0 rd r� r� r- �locr� r� r� r< rU rH �
inferred_typer � infer_dtyper� rc )re r� r� �key_typerg rg rh r� � s(
zSeries._get_withc C sb t j|� r$| j|�}t|dd� |S t| jt�s8td��| jj|�\}}| j | j
| |d�j | �S )N� )rt z0key of type tuple not found and not a MultiIndex)rV ) r� Zany_noner� rD r| rV rI r� Z
get_loc_levelr� r� r� )re r� r� �indexerr� rg rg rh r� � s
zSeries._get_values_tuplec C s> y| j | jj|��j| �S tk
r8 tj| j�| S X d S )N)r� r� Z get_slicer� r� r� r� r� )re r� rg rg rh r� � s zSeries._get_values)�takeablec C s* |r| j | S | jj|�}| jj| ||�S )z�
Quickly retrieve single value at passed index label.
Parameters
----------
label : object
takeable : interpret the index as indexers, default False
Returns
-------
scalar value
)r� rV �get_locZ_get_values_for_loc)re �labelr� r� rg rg rh r� � s
zSeries._get_valuec C sB t j|| �}| j� }|tkr$td �}y| j||� W n� ttfk
r| | j}t |�rn| j
j dk rn|||< n
|| j |< Y n� t
k
�r. } z�t|t�r�t| j
t� r�td�|�t j|��rt| j
|�}tj|td�}y| j| |dd� W n tk
�r || j|< Y nX d S | j||� W Y d d }~X nX |�r>| j� d S )Nr� z0key of type tuple not found and not a MultiIndex)ry T)r\ )r� r� Z%_check_is_chained_assignment_possibler� r� �_set_with_enginer� r� r� r+ rV r� r� rd r| r� rI r� rN r� r� r� Z_wherer rc � _set_with�_maybe_update_cacher)re r� r� Zcacher_needs_updatingr� �errrg rg rh � __setitem__� s6
zSeries.__setitem__c C s( | j jj|�}t| j|� || j|< d S )N)rV Z_enginer� r% ry r� )re r� r� r� rg rg rh r� s zSeries._set_with_enginec C s� t |t�r&| jj|dd�}| j||�S t |t� s6t�t|�rD|g}t |t�r\|j }|j
}nt j |dd�}|dkr�| jj
� s�| j||� q�| j||� n
|| j|< d S )Nr� )r� F)r� r� )r| r� rV r� � _set_valuesr� r� r/ rH r� r� r r� r� � _set_labelsr� )re r� r� r� r� rg rg rh r� s
zSeries._set_withc C sH t j|�}| jj|�}|dk}|j� r8t|| � d���| j||� d S )Nra z
not in index���)r� Zasarray_tuplesaferV Z get_indexer�anyr� r� )re r� r� r� �maskrg rg rh r� * s
zSeries._set_labelsc C s. t |t�r|j}| jj||d�| _| j� d S )N)r� r� )r| rU r� r� �setitemr� )re r� r� rg rg rh r� 2 s
zSeries._set_valuesc C sZ y6|r|| j |< n"| jj|�}t| j|� || j |< W n tk
rT || j|< Y nX 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� rV r� r% ry r� r� )re r� r� r� r� rg rg rh �
_set_value8 s zSeries._set_valuec C s dS )NFrg )re rg rg rh �_is_mixed_typeV s zSeries._is_mixed_typec C sD t jt� t|d�� | jj|�}| jj|�}| j||d�j| dd�S )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
Must be ``None``. Has no effect but is accepted for compatibility
with numpy.
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[ )rV �repeat)r� ) r� Zvalidate_repeatr� �dictrV r� r� r� r� )re Zrepeatsr[ r� r� rg rg rh r� Z s
4 z
Series.repeatc s� t |d�}|r�tjt� ��}|dk rft|ttf�s8|g}� fdd�|D �}t|�� jjk rf� jj |�}|r~|� _|px� j
� _
qĈ j � j j
� |d�j� dd�S n&|r�td��n� j|�}|j||d �S dS )
a
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).
Returns
-------
Series or DataFrame
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
To update the Series in place, without generating a new one
set `inplace` to True. Note that it also requires ``drop=True``.
>>> s.reset_index(inplace=True, drop=True)
>>> s
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 j|��qS rg )rV �_get_level_number)r� �lev)re rg rh r� s z&Series.reset_index.<locals>.<listcomp>)rV � reset_index)r� z<Cannot reset_index inplace on a Series to create a DataFrame)�level�drop)r! r~ r� rb r| r� r� rV ZnlevelsZ droplevelrm r� r� ru r� rd �to_framer )re r r rm r\ r� �dfrg )re rh r � s( l
zSeries.reset_indexc C sp t d�}t� \}}td�dkr"|ntd�}td�dkr:|ntd�}td�}| j|| j| j|||d� |j� }|S )zI
Return a string representation for a particular Series.
rW zdisplay.max_rowsr zdisplay.min_rowszdisplay.show_dimensions)�bufrm ry �min_rows�max_rows�length)r r r � to_stringrm ry �getvalue)re r �width�heightr r Zshow_dimensionsr� rg rg rh �__repr__ s
zSeries.__repr__�NaNTc C s� t j| ||||||||
| d�
} | j� } t| t�sHtdtt| �j�� ���|dkrT| S y|j | � W n4 t
k
r� t |d��}
|
j | � W dQ R X Y nX 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.
) rm r
�headerrV ry �na_rep� float_formatr r z.result must be of type str, type of result is N�w) �fmtZSeriesFormatterr r| rp r� �reprr rk �write�AttributeError�open)re r r r r rV r
ry rm r r � formatterr� �frg rg rh r < s, /
zSeries.to_stringrY aa
Examples
--------
>>> s = pd.Series(["elk", "pig", "dog", "quetzal"], name="animal")
>>> print(s.to_markdown())
| | animal |
|---:|:---------|
| 0 | elk |
| 1 | pig |
| 2 | dog |
| 3 | quetzal |
)rY �examples)r �moderV r� c K s | j � j|||f|�S )a^
Print {klass} in Markdown-friendly format.
.. versionadded:: 1.0.0
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.
index : bool, optional, default True
Add index (row) labels.
.. versionadded:: 1.1.0
**kwargs
These parameters will be passed to `tabulate <https://pypi.org/project/tabulate>`_.
Returns
-------
str
{klass} in Markdown-friendly format.
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 � to_markdown)re r r rV r� rg rg rh r � s KzSeries.to_markdownc C s t t| j�t| ��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
)r� �iterrV )re rg rg rh r� � s z Series.itemsc C s | j � S )N)r� )re rg rg rh � iteritems� s zSeries.iteritemsc C s | j S )zy
Return alias for index.
Returns
-------
Index
Index of the Series.
)rV )re rg rg rh r� � s z Series.keysc C s t j|�}|| j� �S )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})
)r� Zstandardize_mappingr� )re ZintoZinto_crg rg rh �to_dict s
zSeries.to_dictc C s& |dkr| j | �}n| j || i�}|S )a
Convert Series to DataFrame.
Parameters
----------
name : object, default None
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
N)r� )re rm r rg rg rh r ( s zSeries.to_framec C s$ t |d�}|r| n| j� }||_|S )z�
Set the Series name.
Parameters
----------
name : str
inplace : bool
Whether to modify `self` directly or return a copy.
r\ )r! ru rm )re rm r\ Zserrg rg rh � _set_nameH 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
�groupbyrT )�as_index�sort�
group_keys�squeeze�observed�dropnar� c
C sh ddl m}
|tk r&tjdtdd� nd}|d krB|d krBtd��| j|�}|
| ||||||||| d�
S ) Nr )rT zNThe `squeeze` parameter is deprecated and will be removed in a future version.rs )rt Fz*You have to supply one of 'by' and 'level')
�objr� r[ r r$ r% r& r' r( r) )�pandas.core.groupby.genericrT r r� r� r� rd �_get_axis_number) re Zbyr[ r r$ r% r& r' r( r) rT rg rg rh r# W s* _
zSeries.groupbyc C s� |dkrt | j�j� S t|t�r,| jj|�}| jj| }tj| jj | ddd�}|d k}|j
� r~t |� ||< }|j ||j
�}|t | j� }tj|t |�p�dd�}| j||dd�j| d d
�S ) a�
Return number of non-NA/null observations in the Series.
Parameters
----------
level : int or level name, default None
If the axis is a MultiIndex (hierarchical), count along a
particular level, collapsing into a smaller 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
NFT)Zsubokru ra )Z minlength�int64)rV ry �count)r� r� )r4 r� �sumr| rp rV r �levelsr� �codesr� rb �insertZ _na_valuer� Zbincountr� r� )re r r Z level_codesr� ZcntZobs�outrg rg rh r. � s
z Series.countc C s t j| |d�S )aw
Return the mode(s) of the dataset.
Always returns Series even if only one value is returned.
Parameters
----------
dropna : bool, default True
Don't consider counts of NaN/NaT.
.. versionadded:: 0.24.0
Returns
-------
Series
Modes of the Series in sorted order.
)r) )r6 r )re r) rg rg rh r s z Series.modec s t � j� }|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
--------
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
* 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()
array(['2016-01-01T00:00:00.000000000'], 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 unordered Categorical will return categories in the order of
appearance.
>>> pd.Series(pd.Categorical(list('baabc'))).unique()
['b', 'a', 'c']
Categories (3, object): ['b', 'a', 'c']
An ordered Categorical preserves the category ordering.
>>> pd.Series(pd.Categorical(list('baabc'), categories=list('abc'),
... ordered=True)).unique()
['b', 'a', 'c']
Categories (3, object): ['a' < 'b' < 'c']
)�superr] )re r� )� __class__rg rh r] s =
z
Series.unique�firstc s2 t |d�}t� j|d�}|r*| j|� dS |S dS )a�
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.
Returns
-------
Series
Series with duplicates dropped.
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.
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. Setting the value of 'inplace' to ``True`` performs
the operation inplace and returns ``None``.
>>> s.drop_duplicates(keep=False, inplace=True)
>>> s
1 cow
3 beetle
5 hippo
Name: animal, dtype: object
r\ )�keepN)r! r4 �drop_duplicates�_update_inplace)re r7 r\ r� )r5 rg rh r8 \ s K
zSeries.drop_duplicatesc s t � j|d�S )aV
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
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
)r7 )r4 r^ )re r7 )r5 rg rh r^ � s LzSeries.duplicatedc O s6 t j|||�}tj| j|d�}|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 : int, default 0
For compatibility with DataFrame.idxmin. Redundant for application
on Series.
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� ra r� )r� Zvalidate_argmin_with_skipnar9 Z nanargminr� r� �nanrV )re r[ r� �argsr� r� rg rg rh �idxmin� s
@z
Series.idxminc O s6 t j|||�}tj| j|d�}|dkr,tjS | j| S )a1
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 : int, default 0
For compatibility with DataFrame.idxmax. Redundant for application
on Series.
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� ra r� )r� Zvalidate_argmax_with_skipnar9 Z nanargmaxr� r� r: rV )re r[ r� r; r� r� rg rg rh �idxmaxC s
Az
Series.idxmaxc O s6 t j||� | jj|�}| j|| jd�j| 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
)rV �round)r� )r� Zvalidate_roundr� r> r� rV r� )re Zdecimalsr; r� r� rg rg rh r> � s
z Series.round� �?�linearc C sp t |� | j� }|j||dd�}|jdkr<|jdd�df }t|�rb| j|_| j|t|�| jd�S |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)�q�
interpolation� numeric_onlyrs Nr )rV rm ) r" r �quantiler� rc r- rm r� rG )re rA rB r r� rg rg rh rD � s *
zSeries.quantile�pearsonc C s` | j |ddd�\}}t|�dkr&tjS |d ks6t|�rLtj|j|j||d�S td |� d
���d S )
a�
Compute correlation with `other` Series, excluding missing values.
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.
.. versionadded:: 0.24.0
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.
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)�joinru r rE �spearman�kendall)r� � min_periodszHmethod must be either 'pearson', 'spearman', 'kendall', or a callable, 'z' was suppliedN)rE rH rI ) �alignrb r� r: �callabler9 Znancorrr� r� )re �otherr� rJ �thisrg rg rh �corr� s , z Series.corrra )rM rJ �ddofr� c C s< | j |ddd�\}}t|�dkr&tjS tj|j|j||d�S )a�
Compute covariance with Series, excluding missing values.
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
rF F)rG ru r )rJ rP )rK rb r� r: r9 Znancovr� )re rM rJ rP rN rg rg rh �cov( s
& z
Series.covrW 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)rY Z extra_paramsZ other_klassr )�periodsr� c C s( t j| j|�}| j|| jd�j| dd�S )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}
)rV �diff)r� )r6 rS r� r� rV r� )re rR r� rg rg rh rS U s Uz Series.diffc C s | j | j|��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
)rO �shift)re Zlagrg rg rh �autocorr� s +zSeries.autocorrc C s t |ttf�rr| jj|j�}t|�t| j�ks@t|�t|j�krHtd��| j|dd�}|j|dd�}|j}|j}n<| j}t j
|�}|j d |j d kr�t d|j � d|j � ���t |t�r�| j
t j||�|jd�j| dd �S t |t�r�t j||�S t |t j��r
t j||�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 alignedF)rV ru r z Dot product shape mismatch, z vs )rV �dot)r� zunsupported type: N)r| rU r0 rV �unionrb r� r� r� r� r� �shape� Exceptionr� rV �columnsr� r� rd r )re rM �common�left�rightZlvalsZrvalsrg rg rh rV � s, 2$
z
Series.dotc C s
| j |�S )zQ
Matrix multiplication using binary `@` operator in Python>=3.5.
)rV )re rM rg rg rh �
__matmul__*
s zSeries.__matmul__c C s | j tj|��S )zQ
Matrix multiplication using binary `@` operator in Python>=3.5.
)rV r� Z transpose)re rM rg rg rh � __rmatmul__0
s zSeries.__rmatmul__)rY r\ c C s t j| j|||d�S )N)�side�sorter)r6 � searchsortedr� )re r� r` ra rg rg rh rb 6
s zSeries.searchsortedc C sh ddl m} t|ttf�r,| g}|j|� n| |g}tdd� |dd� D ��rZd}t|��||||d�S ) u�
Concatenate two or more Series.
Parameters
----------
to_append : Series or list/tuple of Series
Series to append with self.
ignore_index : bool, default False
If True, the resulting axis will be labeled 0, 1, …, n - 1.
verify_integrity : bool, default False
If True, raise Exception on creating index with duplicates.
Returns
-------
Series
Concatenated Series.
See Also
--------
concat : General function to concatenate DataFrame or Series objects.
Notes
-----
Iteratively appending to a Series can be more computationally intensive
than a single concatenate. A better solution is to append values to a
list and then concatenate the list with the original Series all at
once.
Examples
--------
>>> s1 = pd.Series([1, 2, 3])
>>> s2 = pd.Series([4, 5, 6])
>>> s3 = pd.Series([4, 5, 6], index=[3, 4, 5])
>>> s1.append(s2)
0 1
1 2
2 3
0 4
1 5
2 6
dtype: int64
>>> s1.append(s3)
0 1
1 2
2 3
3 4
4 5
5 6
dtype: int64
With `ignore_index` set to True:
>>> s1.append(s2, ignore_index=True)
0 1
1 2
2 3
3 4
4 5
5 6
dtype: int64
With `verify_integrity` set to True:
>>> s1.append(s2, verify_integrity=True)
Traceback (most recent call last):
...
ValueError: Indexes have overlapping values: [0, 1, 2]
r )�concatc s s | ]}t |tf�V qd S )N)r| r0 )r� r� rg rg rh r� �
s z Series.append.<locals>.<genexpr>ra NzCto_append should be a Series or list/tuple of Series, got DataFrame)� ignore_index�verify_integrity)Zpandas.core.reshape.concatrc r| r� r� �extendr� rd )re Z to_appendrd re rc Z to_concat�msgrg rg rh �append=
s F z
Series.appendc
C s� t |t�std��| }| jj|j�s:| j||ddd�\}}tj|j|j|�\}}t j
dd�� |||�}W dQ R X tj | |�} |j || �}
|
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 Seriesr� F)r rG ru rx )�allN)
r| rU r� rV r� rK r: Z
fill_binopr� r� �errstate�get_op_result_name�_construct_result) re rM �funcr �
fill_valuerN Z this_valsZ
other_valsr� rm �retrg rg rh �_binop�
s
z
Series._binop)r� rm r� c C sv t |t�rR| j|d |d�}| j|d |d�}t |t�s<t�t |t�sJt�||fS | j|| jd�}|j| �}||_|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 )rm ra )rV ) r| r� rl rU r� r� rV r� rm )re r� rm Zres1Zres2r3 rg rg rh rl �
s
zSeries._construct_resultax
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
�compare)rM �
align_axis�
keep_shape�
keep_equalr� c s t � j||||d�S )N)rM rr rs rt )r4 rq )re rM rr rs rt )r5 rg rh rq �
s
FzSeries.comparec
s� |dkrt | jdd�}t�t�r�| jj�j�}tj| ��}g }x�|D ]D}| j||�}�j||�} t j
dd�� |j � || �� W dQ R X qDW n:| j}t j
dd�� � �fdd�| j D �}W dQ R X | j
}t| j�r�nt| j�r�tt| j �|�}| j|||d�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
NF)�compatrx )ri c s g | ]}� |���qS rg rg )r� �lv)rm rM rg rh r� } s z"Series.combine.<locals>.<listcomp>)rV rm )r3 ry r| rU rV rW r: rk �getr� rj rh r� rm r( r* r$ r r� )
re rM rm rn r� �new_namer� �idxrv �rvrg )rm rM rh �combine' s( C
zSeries.combinec C sZ | j j|j �}| j|dd�}|j|dd�}|jjdkrJ|jjdkrJt|�}|jt|�|�S )a�
Combine Series values, choosing the calling Series's values first.
Parameters
----------
other : Series
The value(s) to be combined with the `Series`.
Returns
-------
Series
The result of combining the Series with the other object.
See Also
--------
Series.combine : Perform elementwise operation on two Series
using a given function.
Notes
-----
Result index will be the union of the two indexes.
Examples
--------
>>> s1 = pd.Series([1, np.nan])
>>> s2 = pd.Series([3, 4])
>>> s1.combine_first(s2)
0 1.0
1 4.0
dtype: float64
F)ru �M)rV rW r� ry r� rR �wherer4 )re rM r� rN rg rg rh �
combine_first� s zSeries.combine_firstc C sB t |t�st|�}|j| �}t|�}| jj||d�| _| j� 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| rU Z reindex_liker4 r� Zputmaskr� )re rM r� rg rg rh �update� s D
z
Series.update� quicksort�last)r\ r� � na_positionrd r� c s� t |d�}| j|� |r&| jr&td��� �fdd�}| j} tjt| �tjd�}
t | �} | } t
j t| ��}
|| | �}t |�r�t|�dkr�tdt|�� d���|d }t
|�s�td
��|s�|d d d� }|d k�r | j� }|
| | |
d |�< |
| |
|d �< nF|d
k�r8| j� }|
| | |
|d �< |
| |
d |�< ntd|� ���| j| |
| j|
d�}|�rtt
j t|
��|_|�r�| j|� n|j| dd�S d S )uS
Sort by the values.
Sort a Series in ascending or descending order by some
criterion.
Parameters
----------
axis : {0 or 'index'}, default 0
Axis to direct sorting. The value 'index' is accepted for
compatibility with DataFrame.sort_values.
ascending : bool, default True
If True, sort values in ascending order, otherwise descending.
inplace : bool, default False
If True, perform operation in-place.
kind : {'quicksort', 'mergesort' or 'heapsort'}, default 'quicksort'
Choice of sorting algorithm. See also :func:`numpy.sort` for more
information. 'mergesort' is the only stable algorithm.
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.
.. versionadded:: 1.0.0
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
Series ordered by values.
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 inplace
>>> s.sort_values(ascending=False, inplace=True)
>>> s
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 copyc sD t | � �} t| d| �} y | j�d�S tk
r> | jdd�S X d S )Nr� )r� r� )rP r� �argsortrd )�arr)r� r� rg rh �_try_kind_sort� s
z*Series.sort_values.<locals>._try_kind_sort)ry ra zLength of ascending (z) must be 1 for Seriesr zascending must be booleanNr� r6 zinvalid na_position: )rV � sort_values)r� r� )r! r, Z
_is_cachedr� r� r� �emptyrb Zint32r2 r~ r� r- r' r/ r� rV r9 r� )re r[ � ascendingr\ r� r� rd r� r� r� Z sorted_index�badZgoodry Z argsorted�nr� rg )r� r� rh r� sJ *
zSeries.sort_values)r� r\ r� r� �sort_remainingrd r� c
C s& t |d�}| j|� t| j| |d�}
|dk rB|
j|||d�\} } ntt|
t�rtddlm}
|
j � }|
|j
� ||d�} nBddlm } |r�|
j s�| r�|
j
r�|r�dS | j� S ||
|||d �} t| �} | jj| �} | j � } | jj| �}| j|| d
�}|�rtjt|��|_|�r| j|� n|j| d d �S dS )
u�
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 : int, default 0
Axis to direct sorting. This can only be 0 for Series.
level : int, optional
If not None, sort on values in specified index level(s).
ascending : bool or list 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'}, default 'quicksort'
Choice of sorting algorithm. See also :func:`numpy.sort` for more
information. 'mergesort' is the only stable algorithm. 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.
.. versionadded:: 1.0.0
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
The original Series sorted by the labels.
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
Sort Inplace
>>> s.sort_index(inplace=True)
>>> s
1 c
2 b
3 a
4 d
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\ )r0 N)r� r� r )�lexsort_indexer)Zordersr� )�nargsort)r� r� r� )rV �
sort_index)r� )r! r, rP rV Z sortlevelr| rI �pandas.core.sortingr� Z_sort_levels_monotonicZ_get_codes_for_sortingr� Zis_monotonic_increasingZis_monotonic_decreasingru r& r� r� r� r~ r� rb r9 r� )re r[ r r� r\ r� r� r� rd r� rV r� r� r� r� r� r� r� rg rg rh r� � s@
zSeries.sort_indexc C s� | j }t|�}|j� r`td
| j| jdd�}| }tj|| |d�||< | j|| jd�j | dd�S | jtj||d�| jdd�j | dd�S d S ) 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"}
Has no effect but is accepted for compatibility with numpy.
kind : {'mergesort', 'quicksort', 'heapsort'}, default 'quicksort'
Choice of sorting algorithm. See np.sort for more
information. 'mergesort' is the only stable algorithm.
order : None
Has no effect but is accepted for compatibility with numpy.
Returns
-------
Series
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.
ra r- )rV rm ry )r� )rV r� )r� )rV ry Nr� )
r� r2 r� rU rV rm r� r� r� r� )re r[ r� r� r� r� r� Znotmaskrg rg rh r� �
s
zSeries.argsortr� c C s t j| ||d�j� 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� r7 )r6 �
SelectNSeries�nlargest)re r� r7 rg rg rh r� �
s `zSeries.nlargestc C s t j| ||d�j� 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� r7 )r6 r� � nsmallest)re r� r7 rg rg rh r� C s _zSeries.nsmallestrs c C s: t | jt�st�| jj||�}| j| j||d�j| dd�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, str
Level of the indices to be swapped. Can pass level name as string.
copy : bool, default True
Whether to copy underlying data.
Returns
-------
Series
Series with levels swapped in MultiIndex.
)rV ru � swaplevel)r� )r| rV rI r� r� r� r� r� )re r� �jru r� rg rg rh r� � s zSeries.swaplevelc C s> t | jt�std��| j� }t |jt�s,t�|jj|�|_|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.)r| rV rI rY ru r� �reorder_levels)re r� r� rg rg rh r� � s zSeries.reorder_levels)rd r� c C sh t | � st| � r | j� S tjtj| j��\}}|rFtj t |��}n | j
j |�}| j ||| j
d�}|S )u�
Transform each element of a list-like to a row.
.. versionadded:: 0.25.0
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,
Series, and np.ndarray. The result dtype of the subset rows will
be object. Scalars will be returned unchanged. Empty list-likes will
result in a np.nan for that row.
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
)rV rm )rb r. ru r �exploder� r� r� r~ r� rV r� r� rm )re rd r� �countsrV r� rg rg rh r� � s 6 zSeries.explodec 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.
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� )re r rn r� rg rg rh r� s & zSeries.unstackc s* t � j||d�}| j|| jd�j| dd�S )a�
Map values of Series according to input correspondence.
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
)� na_action)rV �map)r� )r4 Z _map_valuesr� rV r� )re �argr� r� )r5 rg rh r� D s Kz
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.
rg )re r� r� Zsubsetrg rg rh �_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[ z
.. versionadded:: 0.20.0
)rY r[ Zsee_alsor Z versionaddedc
O s� | j |� |d kr t|j� �}| j|f|�|�\}}|d kr�|jdd � |jdd � y| j|f|�|�}W n* tttfk
r� || f|�|�}Y nX |S )NZ_axisZ_level) r, r� r� Z
_aggregate�pop�applyr� r rd )re rm r[ r; r� r� �howrg rg rh r� � s
zSeries.aggregate)rY r[ c s | j |� t� j|f|�|�S )N)r, r4 � transform)re rm r[ r; r� )r5 rg rh r� � s
zSeries.transformc sJ t | �dkr(| j| j| jd�j| dd�S t�ttf�rH| j�f� ���S t�t �rd| j
�f� ���S �sz� r�t�t j � r�� ��fdd�}n�}t j
dd��Z t|t j �r�|| �S t| j�r�t| jd �r�| jj|�}n | jt�j}tj|||d
�}W d Q R X t |��r,t|d t��r,| jtj|�| jd �S | j|| jd �j| dd�S d S )
a
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.
args : tuple
Positional arguments passed to func after the series value.
**kwds
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.
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 )ry rV r� )r� c s �| f� ���S )Nrg )r� )r; rm �kwdsrg rh r e s zSeries.apply.<locals>.frx )ri r� )�convertN)rV )rb r� ry rV r� r| r� r� r� rp Z _try_aggregate_string_functionr� r� rj r* r� r� r� r� r� r Z map_inferrU r� �pdr� )re rm Z
convert_dtyper; r� r Zmappedr� rg )r; rm r� rh r� � s* a
z Series.applyc K sx | j }|dk r| j|� t|t�r8|j|fd|i|��S |rLtd|� d���tjdd�� ||fd|i|��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� zSeries.z! does not implement numeric_only.rx )ri )r� r, r| r< �_reducer� r� rj ) re �oprm r[ r� rC Z filter_typer� Zdelegaterg rg rh r� � s
zSeries._reducec C s: |d kr|r| j � S | S tj| j|dd d�}| j||d�S )NT)Z
allow_fillrn )rV )ru r6 Ztake_1dr� r� )re r� r� ru r� rg rg rh �_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.
Frg )re rX r� r rg rg rh �_needs_reindex_multi� s zSeries._needs_reindex_multirZ )rY rZ r� c s t � j||||||||| |
d�
S )N) rG r[ r ru rn r� �limit� fill_axis�broadcast_axis)r4 rK ) re rM rG r[ r ru rn r� r� r� r� )r5 rg rh rK � s z Series.alignrx )r[ ru r\ r rz c s8 t |�st|�r&t� j|||||d�S | j||d�S 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
----------
axis : {0 or "index"}
Unused. Accepted for compatibility with DataFrame method only.
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.
**kwargs
Additional keyword arguments passed to the function. Only the
"inplace" keyword is used.
Returns
-------
Series
Series with index labels or name altered.
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
)ru r\ r rz )r\ N)rL r) r4 �renamer" )re rV r[ ru r\ r rz )r5 rg rh r� � s Ez
Series.renamea
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\ c s t � j|||d�S )N)r[ r\ )r4 r� )re r� r[ r\ )r5 rg rh r� s zSeries.set_axisrX r_ r` )rY rX r_ r` c s t � jf d|i|��S )NrV )r4 r� )re rV r� )r5 rg rh r� 4 s zSeries.reindex�raisec s t � j|||||||d�S )aE
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, default 0
Redundant for application on Series.
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
Series with specified index labels removed.
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[ rV rZ r r\ rz )r4 r )re r� r[ rV rZ r r\ rz )r5 rg rh r > s `z Series.dropc s t � j||||||d�S )N)r� r� r[ r\ r� �downcast)r4 �fillna)re r� r� r[ r\ r� r� )r5 rg rh r� � s
z
Series.fillna)r� r� c s t � j|d�S )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� )r4 r� )re r� )r5 rg rh r� � s z
Series.pop�padc s t � j||||||d�S )N)�
to_replacer� r\ r� �regexr� )r4 �replace)re r� r� r\ r� r� r� )r5 rg rh r� � s
zSeries.replacec s t � j||||d�S )N)rR �freqr[ rn )r4 rT )re rR r� r[ rn )r5 rg rh rT � s z Series.shiftc s( t � j|d�}|r$|| jj|d�7 }|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)
260
)�deep)r4 � memory_usagerV )re rV r� �v)r5 rg rh r� � s 1zSeries.memory_usagec C s& t j| |�}| j|| jd�j| dd�S )a}
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
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
)rV �isin)r� )r6 r� r� rV r� )re r� r� rg rg rh r� % s 5 z Series.isinc C s. |r| |k}| |k}n| |k}| |k }||@ 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 : bool, default True
Include boundaries.
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 ``False`` boundary values are excluded:
>>> s.between(1, 4, inclusive=False)
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
rg )re r\ r] Z inclusiveZlmaskZrmaskrg rg rh �between_ s B
zSeries.between)�
infer_objects�convert_string�convert_integer�convert_booleanr� c C sv | }|r |j � }t|�r |j� }|s,|s,|rjt|j|||�}y|j|�}W qr tk
rf |j� }Y qrX n|j� }|S )N)r� r. ru r# r� r� rd )re r� r� r� r� Z input_seriesZinferred_dtyper� rg rg rh �_convert_dtypes� s zSeries._convert_dtypesc s
t � j� S )N)r4 r2 )re )r5 rg rh r2 � s z Series.isnac s
t � j� S )N)r4 �isnull)re )r5 rg rh r� � s z
Series.isnullc s
t � j� S )N)r4 r4 )re )r5 rg rh r4 � s z Series.notnac s
t � j� S )N)r4 �notnull)re )r5 rg rh r� � s zSeries.notnullc C sN t |d�}| j|pd� | jr<t| �}|r6| j|� qJ|S n|rBn| j� S dS )a
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'}, default 0
There is only one axis to drop values from.
inplace : bool, default False
If True, do operation inplace and return None.
how : str, optional
Not in use. Kept for compatibility.
Returns
-------
Series
Series with NA entries dropped from it.
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
Keep the Series with valid entries in the same variable.
>>> ser.dropna(inplace=True)
>>> ser
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 N)r! r, r� r5 r9 ru )re r[ r\ r� r� rg rg rh r) � s G
z
Series.dropna�startc C s\ | j }|r|j� }t| jt�s4tdt| j�j� ���| jj||d�}| j ||d�j
| dd�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
zunsupported Type )r� r� )rV � to_timestamp)r� ) r� ru r| rV rL rd r rk r� r� r� )re r� r� ru r� r� rg rg rh r� 1 s zSeries.to_timestampc C sZ | j }|r|j� }t| jt�s4tdt| j�j� ���| jj|d�}| j ||d�j
| dd�S )ay
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.
zunsupported Type )r� )rV � to_period)r� ) r� ru r| rV rK rd r rk r� r� r� )re r� ru r� r� rg rg rh r� N s zSeries.to_periodz&The index (axis labels) of the Series.)r[ r rH �plot)NNNNFF)NN)F)r� )N)N)r N)r )r )r )F)F)N)NFNF)
Nr NTTFFFNN)NNT)N)F)N)T)r6 F)r6 )r T)r T)r )r? r@ )rE N)Nra )ra )ra )r\ N)FF)NN)rU rU )ra FF)N)r TFr� r� FN) r NTFr� r� TFN)r r� N)r� r6 )r� r6 ���r� )r� r� T)Fr� )r� N)N)N)Nr )r )r TNN) r� NNTNNNr N)N)r F)N)Nr NNNFr� )NNNFNN)NNFNFr� )ra Nr N)TF)T)TTTT)r FN)Nr� T)NT)�rk �
__module__� __qualname__�__doc__Z_typr r� Z _metadatar
rp r8 rC Z_internal_names_setZ
_accessorsr7 �
IndexOpsMixinZ
_deprecationsr� �propertyZhasnansrm rO r� r r �divZrdivr} r� r
r� r� r� r� �intr� r� r ry r� rm �setterr� r� r r� r< r� r� r� rH r� r� r� r� r� rl �float� __float__Z__long__�__int__rX r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r �_shared_doc_kwargsr r r r r r r� r r� r� r! r r" Z _shared_docsr r# r. r r] r8 r^ r< r= r> rD rO rQ rS rU rV r^ r_ rb rh rp r r rl r r rq r{ r~ r� r r� r r� r� r� r� r� r� r� r� r� r� Z_agg_see_also_docZ_agg_examples_docr� Zaggr� r� r� r� r� rK r� r r� r� r r� r� r� rT r� r� r� r� r2 r� r4 r� r) r� r� Z _AXIS_ORDERSZ_AXIS_REVERSEDrb Z _AXIS_LENZ_info_axis_numberZ_info_axis_namer Z AxisPropertyrV r; rQ rF rn r= ro �pandasZplottingZ PlotAccessorr� r> rq Z hist_series�hist�
__classcell__rg rg )r5 rh rU � s@
% . 1 * " H J5 (( ' ;
B 8 ! P% - @SN F G( ;> (*)-N T % #< b(R h @*baD -P
D
a
6:P [
)�r� �ior �shutilr �textwrapr Ztypingr r r r r r
r r r
r r� Znumpyr� Zpandas._configr Z pandas._libsr r r r Zpandas._libs.libr Zpandas._typingr r r r r r r Zpandas.compat.numpyr r� Z
pandas.errorsr Zpandas.util._decoratorsr r r Zpandas.util._validatorsr! r" Zpandas.core.dtypes.castr# r$ r% Zpandas.core.dtypes.commonr& r' r( r) r* r+ r, r- r. r/ Zpandas.core.dtypes.genericr0 Z pandas.core.dtypes.inferencer1 Zpandas.core.dtypes.missingr2 r3 r4 r5 r� r� Z pandas.corer6 r7 r8 r9 r: Zpandas.core.accessorr; Zpandas.core.arraysr< Z pandas.core.arrays.categoricalr= Zpandas.core.arrays.sparser> Zpandas.core.common�corer[ r� Zpandas.core.constructionr? r@ rA rB Zpandas.core.genericrC Zpandas.core.indexersrD rE Z pandas.core.indexes.accessorsrF Zpandas.core.indexes.apirG rH rI rJ Zpandas.core.indexes.base�indexesr~ Z pandas.core.indexes.datetimesrK Zpandas.core.indexes.periodrL Z pandas.core.indexes.timedeltasrM Zpandas.core.indexingrN Zpandas.core.internalsrO r� rP Zpandas.core.stringsrQ Zpandas.core.tools.datetimesrR Zpandas.io.formats.format�formats�formatr Zpandas.plottingr� rS r+ rT �__all__r� r� rl r� rU Z_add_numeric_operationsZ#_add_series_or_dataframe_operationsZadd_flex_arithmetic_methodsZ add_special_arithmetic_methodsrg rg rg rh �<module> s� 0 $ 0
|