PiG fdZddlmZddlmZmZmZmZmZddl Z ddl Z ddl Z ddl m Z ddlmZmZmZmZmZmZmZddlZddlZddlmZmZmZddlmZdd lm Z dd l!m"Z"m#Z#dd l$m%Z%dd l&m'Z(dd l)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4ddl5m6Z6ddl7m8Z8m9Z9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBmCZCddlDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMddlNmOZOddlPmQZQmRZRddlSmTZTddlUmVZVmWZWmXZXmYZYddlZm[Z[m\Z\m]Z^m_Z_m`Z`maZaddlbmcZcddldmeZeddlfmgZgddlhmiZimjZjddlkmlZlddlmmnZndd lompZqmrZrmsZsdd!ltmuZudd"lvmwZwmxZxdd#lymzZzdd$l{m|Z|m}Z}m~Z~mZmZmZmZddlmcmcm\Zdd%lmZdd&lmZmZdd'lmZdd(lmZdd)lmZdd*lmZmZdd+lmZdd,lmZddlmcmcmZdd-lmZddlZerXdd.lmZdd/lmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd0lmZdd1lmZd2gZd3d2d4d5d6d7d2d8d9d: Ze4d;Gd<d2e\jeuZdS)=zG Data structure for 1-dimensional cross-sectional and time series data ) annotations)CallableHashableIterableMappingSequenceN)dedent)IO TYPE_CHECKINGAnyLiteralSelfcastoverload)lib propertiesreshape)is_range_indexer)CHAINED_WARNING_DISABLED) REF_COUNTREF_COUNT_METHOD)import_optional_dependency)function)ChainedAssignmentErrorInvalidIndexErrorPandas4Warning)%_chained_assignment_method_update_msg_chained_assignment_msg)Appenderdeprecate_nonkeyword_argumentsdoc set_module)find_stack_level)validate_ascendingvalidate_bool_kwargvalidate_percentile)astype_is_view)LossySetitemError"construct_1d_arraylike_from_scalarfind_common_typeinfer_dtype_frommaybe_box_nativemaybe_unbox_numpy_scalar) is_dict_likeis_float is_integer is_iterator is_list_likeis_object_dtype is_scalar pandas_dtypevalidate_all_hashable)ExtensionDtype) ABCDataFrame ABCSeries) is_hashable)isnana_value_for_dtypenotnaremove_na_arraylike) algorithmsbasecommonnanopsops roperator)Accessor) SeriesApply)ExtensionArray) ListAccessorStructAccessor)CategoricalAccessor)SparseAccessor)array extract_arraysanitize_array)NDFrame)disallow_ndim_indexing unpack_1tuple)CombinedDatetimelikeProperties) DatetimeIndexIndex MultiIndex PeriodIndex default_index ensure_indexmaybe_sequence_to_range)maybe_droplevels)check_bool_indexercheck_dict_or_set_indexers)SingleBlockManager)selectn) _shared_docs)ensure_key_mappednargsort) StringMethods) to_datetime) SeriesInfo)BlockValuesRefs)! AggFuncTypeAnyAll AnyArrayLike ArrayLikeArrowArrayExportableArrowStreamExportableAxisAxisIntCorrelationMethodDropKeepDtypeDtypeObjFilePath Frequency IgnoreRaise IndexKeyFunc IndexLabelLevelListLikeMutableMappingT NaPosition NumpySorterNumpyValueArrayLikeQuantileInterpolation ReindexMethodRenamerScalarSortKindStorageOptionsSuffixes ValueKeyFunc WriteBuffernpt DataFrame SeriesGroupBySeriesindexz{0 or 'index'}zXaxis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame.z[inplace : bool, default False If True, performs operation inplace and returns None. np.ndarrayz index : array-like, optional New labels for the index. Preferably an Index object to avoid duplicating data. axis : int or str, optional Unused.) axesklassaxes_single_argaxisinplaceunique duplicated optional_byoptional_reindexpandasc eZdZUdZdZeeejfZ de d<dgZ de d<ddhe j zZ hd Zejje jzegzZd Zeejjjejjj Zd e d < dddZ dddZddZeddZdZedd Zd!Zedd#Zedd%Zedd&Z edd'Z!e!j"dd)Z!ed*Z#ed+Z$edd-Z%e&ejj'jedd/Z'dd1Z( ddd4Z)edd6Z*ddd<Z+ddd?Z,d@Z-dAZ.ddDZ/ddGZ0dddJZ1ddKZ2ddLZ3ddMZ4ddNZ5ddOZ6dddPZ7dddSZ8e9 ddTdTdTdTdUdd^Z:e9 ddTdTdTd_ddaZ:e9 ddTdTdTdbddcZ: ddHe;j<dHdHdUddfZ:ddhZ=e9 ddTdTdTdTdTdTdTdTdTdi ddsZ>e9dTdTdTdTdTdTdTdTdTdi dduZ>e?e@dvdjgdwx ddd|Z>e9 ddTdTdTd}ddZAe9dTdTdTd}d dZAe9dTdTdTd}d dZAe?e@dvdjgdx d d dZAd dZBd dZCe9ddZDe9dTdddZDeEdddZDe;j<fddZFeGddZHdddZIe&eJde&eKdeLze?e@gddx dddZMddZNdddZOdfd ZPe9dTdTdTdddZQe9dTdTdddZQe9dTdTdTdddZQddHdHddfdZQdddZRdddZSdddZTdddZUe9 d d!dZVe9 dd"dZVe9 d d#dÄZV d$d#dƄZV d%d&d̄ZW d'd(dτZXd)d*dфZYd)d+dӄZZd,dքZ[dׄZ\d؄Z] d-d.dZ^dd/dZ_ d0d1fd Z` dd2dZad3dZbd4dZce9dTdTdTdTdTdTdTdd5dZde9dTdTdTdTdTdTdd6dZde9dTdTdTdTdTdTdTdd7dZdd7dzdHdddHddd8dZde9dTdTdTdTdTdTdTdTdd9dZee9dTdTdTdTdTdTdTdTdTd d:d Zee9dTdTdTdTdTdTdTdTdTd d;d Zed7ddzdHdddzdHdd d<fd Ze d=d>dZf d?d@dZg d?d@dZhdde;j<fdAdZidBdZjddCdZk dDdEdZl dFdGd#ZmddHd%ZneJd&ZoeJd'ZpdIdJd(ZqeqZr ddKd*Zs dLd,d-dMd2ZtdNd5Zudd6Zve9 ddTdTdTdTd7dOd=Zwe9 ddTdTdTdTdTd>dPd?Zw dde;j<dHdd@d>dQfdAZwd7e;j<dBdRfdCZx ddde;j<dddddDdSfdHZye9 ddTdTdTdIdTdLZze9 ddTdTdTdTdMdUdNZze9 ddTdTdTdTdMdVdPZze;j<fe;j<d7e;j<dHdMdVfdQZze9 ddTdTdTdTdTdRdWdVZ{e9 ddTdTdTdTdTdTdWdXdXZ{e9 ddTdTdTdTdTdTdWdYdYZ{ dd7ddddHdZdWdYfd[Z{dZfd] Z| d[d\dcZ}d]d^deZ~d3dfZ d_d`djZdadmZd3dnZee jeLdopd3fdq Zd3fdr Zee jeLdopd3fds Ze9dTdTdTdTdtdbdwZe9dTdTdTdxdcdyZd7dHddHdtdddzZdd{e;j<fdedZde;j<fdfdZdgZde d<eeZd7Zde d<dZde d<ejd7dZedgeZedeZedeZedejjZedeZedeZedeZejjZdZdZdZddgdZddhdZdidZddd7ddJdZ djdkdZe&ejdddjdldZdjdldZe&ejdddjdldZdjdldZe&ejdddjdldZdjdldZe&ejdddjdldZe&ejdddjdldZeZe&ejdddjdldZ djdkdZeZe&ejdddjdldZdjdldZeZeZe&ejdddjdldZeZe&ejdddjdldZe&ejdddjdldZdjdldZe&ejdddjdldZe&ejdddjdldZe&ejdddjdldZe&ejdddjdldZe&ejdddjdldZd7dzdHdddmdÄZd7dHdzdĜdndƄZe?e@dvgdǬx dodndȄZe?e@dvgdɬx dpdqdʄZe?e@dvgdˬx dpdqd̄Ze?e@dvgdͬx drdsdτZe?e@dvgdЬx drdsdфZe?e@dvgdҬx dpdtdӄZe?e@dvgdԬx dpdtdՄZe?e@dvgd֬x dudvdׄZe?e@dvgdجx dudvdلZe?e@dvgdڬx dudvdۄZe?e@dvgdܬx dpdqd݄Ze?e@dvgdެx dpdqd߄ZeZeZؐddwdZِddwdZڐddwdZېddwdZ܈xZS(xra One-dimensional ndarray with axis labels (including time series). Labels need not be unique but must be a hashable type. The object supports both integer- and label-based indexing and provides a host of methods for performing operations involving the index. Statistical methods from ndarray have been overridden to automatically exclude missing data (currently represented as NaN). Operations between Series (+, -, /, \*, \*\*) align values based on their associated index values-- they need not be the same length. The result index will be the sorted union of the two indexes. Parameters ---------- data : array-like, Iterable, dict, or scalar value Contains data stored in Series. If data is a dict, argument order is maintained. Unordered sets are not supported. index : array-like or Index (1d) Values must be hashable and have the same length as `data`. Non-unique index values are allowed. Will default to RangeIndex (0, 1, 2, ..., n) if not provided. If data is dict-like and index is None, then the keys in the data are used as the index. If the index is not None, the resulting Series is reindexed with the index values. dtype : str, numpy.dtype, or ExtensionDtype, optional Data type for the output Series. If not specified, this will be inferred from `data`. See the :ref:`user guide ` for more usages. name : Hashable, default None The name to give to the Series. copy : bool, default None Whether to copy input data, only relevant for array, Series, and Index inputs (for other input, e.g. a list, a new array is created anyway). Defaults to True for array input and False for Index/Series. Even when False for Index/Series, a shallow copy of the data is made. Set to False to avoid copying array input at your own risk (if you know the input data won't be modified elsewhere). Set to True to force copying Series/Index input up front. See Also -------- DataFrame : Two-dimensional, size-mutable, potentially heterogeneous tabular data. Index : Immutable sequence used for indexing and alignment. Notes ----- Please reference the :ref:`User Guide ` for more information. Examples -------- Constructing Series from a dictionary with an Index specified >>> d = {"a": 1, "b": 2, "c": 3} >>> ser = pd.Series(data=d, index=["a", "b", "c"]) >>> ser a 1 b 2 c 3 dtype: int64 The keys of the dictionary match with the Index values, hence the Index values have no effect. >>> d = {"a": 1, "b": 2, "c": 3} >>> ser = pd.Series(data=d, index=["x", "y", "z"]) >>> ser x NaN y NaN z NaN dtype: float64 Note that the Index is first built with the keys from the dictionary. After this the Series is reindexed with the given Index values, hence we get all NaN as a result. Constructing Series from a list with `copy=False`. >>> r = [1, 2] >>> ser = pd.Series(r, copy=False) >>> ser.iloc[0] = 999 >>> r [1, 2] >>> ser 0 999 1 2 dtype: int64 Due to input data type the Series has a `copy` of the original data even though `copy=False`, so the data is unchanged. Constructing Series from a 1d ndarray with `copy=False`. >>> r = np.array([1, 2]) >>> ser = pd.Series(r, copy=False) >>> ser.iloc[0] = 999 >>> r array([999, 2]) >>> ser 0 999 1 2 dtype: int64 Due to input data type the Series has a `view` on the original data, so the data is changed as well. seriesr_namez list[str] _metadatarname>dtcatstrsparsei )r!r]_mgrNdtype Dtype | Nonecopy bool | NonereturnNonec d}t|tr|||dus|}|sGtjdt |jdt |jdt d|d}tj ||||_ dSt|ttj fr>|dur:|"t|jt!|r|}d}|d}t|trc|sa|d}|sItjdt |jdt |jdt dd}t#j||t |}|t'|}|||}|E||nt+d }t-|s|t/t!|d }ng}t|t0rt3d d}t|t4r"|||}|s|j}nt|tj r%t-|jrt;d nt|t<r[|$|j}|j d}nb|!|}|j }|"d rd}n-t|tFr|$|||\}}d}d}nt|tr||j}n+|j%|r|rtMd |sItjdt |jdt |jdt dd}nct|trnMtOj(|}tS|r*t-|s|tjtT}|/tS|s|g}t+t-|}n$tS|rtOj+||t|trU|:t|jt!|sd}||}|r|d}n)tY||||}tj-|||}tj ||||_ |.d |dS)NFz Passing a z to zK is deprecated and will raise in a future version. Use public APIs instead. stackleveldeepTrcompatz8initializing a Series from a MultiIndex is not supportedzVCannot construct a Series from an ndarray with compound dtype. Use DataFrame instead.zkCannot pass both SingleBlockManager `data` argument and a different `index` argument. `copy` must be False.r)refs)/ isinstancer]warningswarntype__name__rrrO__init__rrGnpndarrayr'rr5ibasemaybe_extract_namerX_validate_dtyperWlenr<rUNotImplementedErrorrTastype _references ValueErrorrrrreindex_has_no_referencer _init_dictequalsAssertionErrorcommaybe_iterable_to_listr2objectrequire_length_matchrN from_array _set_axis)selfdatarrrr allow_mgrrs f/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/pandas/core/series.pyrzSeries.__init__qs t/ 0 0   $,  /d!4//$t**:M///# 99%9((D  T4 ( ( (DI F d^RZ8 9 9 !5  =N4:|E?R?R$S$S=99;;D D <D d. / / ! !99%9((D ! /d!4//$t**:M///# ! 'dDJJ??   ''E  ((//E <".EEM!4D4DE5zz U.),u*=*=eLLL dJ ' ' %J  dE " "7 ) {{5)) (' bj ) )1 )4: !> f % %) )} y~~5~11||E**y))!,,! D g & & )//$u==KD%EDD 0 1 1 )} Z&&u--  %>  ! /d!4//$t**:M///# ! n - - ) -d33DD!! )#d)) ) (( =%% v!#d)),,EE $   2  $T5 1 1 1 d. / / I %dj,u2E2EFF! D{{{// ,yydy++!$ud;;D%0u4HHHDt$$$  q%     rr Index | NoneDtypeObj | Nonec|rPtt|}t|}nH|5t |s|t t|d}ng}|}ntdg}}t|||}|r|| |}|j |j fS)aM Derive the "_mgr" and "index" attributes of a new Series from a dictionary input. Parameters ---------- data : dict or dict-like Data used to populate the new Series. index : Index or None, default None Index for the new Series: if None, use dict keys. dtype : np.dtype, ExtensionDtype, or None, default None The dtype for the new Series: if None, infer from data. Returns ------- _data : BlockManager for the new Series index : index for the new Series NFrr)rr) rYtuplekeyslistvaluesrr<r5rWrrrr)rrrrrrss rrzSeries._init_dict s.  0 +5+=+=>>D$++--((FF  5zz U.+L,?,?NNNDD(++R&D 6U 3 3 3  !E% %  Avqwrc tdd}||j|nd}|||}t ||js||g}|S)a Export the pandas Series as an Arrow C stream PyCapsule. This relies on pyarrow to convert the pandas Series to the Arrow format (and follows the default behavior of ``pyarrow.Array.from_pandas`` in its handling of the index, i.e. to ignore it). This conversion is not necessarily zero-copy. Parameters ---------- requested_schema : PyCapsule, default None The schema to which the dataframe should be casted, passed as a PyCapsule containing a C ArrowSchema representation of the requested schema. Returns ------- PyCapsule pyarrowz16.0.0 min_versionN)r)rDataType_import_from_c_capsulerLr ChunkedArray chunked_array__arrow_c_stream__)rrequested_schemaparcas rrzSeries.__arrow_c_stream__<s(( x H H H + K . ./? @ @ @ XXdX & &"bo.. (!!2$''B$$&&&r type[Series]ctSN)rrs r _constructorzSeries._constructor]s rct||}d|_t|tur|S||SNr)r _from_mgrrrr)rmgrrsers r_constructor_from_mgrzSeries._constructor_from_mgrasOs.. ::  J  %%%rCallable[..., DataFrame]cddlm}|S)z} Used when a manipulation result has one higher dimension as the original, such as Series.to_frame() rr)pandas.core.framer)rrs r_constructor_expanddimzSeries._constructor_expanddimns 0/////rcddlm}|j||j}t |t ur|S||S)Nrrr)rrrrrrr)rrrrdfs r_constructor_expanddim_from_mgrz&Series._constructor_expanddim_from_mgrxs[////// Y 38 4 4 4 ::  I**2...rboolc|jjSr)r _can_hold_nars rrzSeries._can_hold_nas y%%rrqc|jjS)a Return the dtype object of the underlying data. See Also -------- Series.dtypes : Return the dtype object of the underlying data. Series.astype : Cast a pandas object to a specified dtype dtype. Series.convert_dtypes : Convert columns to the best possible dtypes using dtypes supporting pd.NA. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.dtype dtype('int64') )rrrs rrz Series.dtypes$yrc|jS)a Return the dtype object of the underlying data. See Also -------- DataFrame.dtypes : Return the dtypes in the DataFrame. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.dtypes dtype('int64') rrs rdtypesz Series.dtypess zrc|jS)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' )rrs rrz Series.names bzrvaluect|t|jdt|d|dS)Nz.name) error_namer)r6rrr __setattr__)rrs rrz Series.namesEe4::3F0M0M0MNNNN4%00000rc4|jS)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 ['a', 'a', 'b', 'c'] Length: 4, dtype: str >>> pd.Series(list("aabc")).astype("category").values ['a', 'a', 'b', 'c'] Categories (3, str): ['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.000000', '2013-01-02T05:00:00.000000', '2013-01-03T05:00:00.000000'], dtype='datetime64[us]') )rexternal_valuesrs rrz Series.valuessRy((***rc4|jS)aT 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 | NumpyExtensionArray | Category | Categorical | Categorical | Categorical | dt64[ns] | ndarray[M8ns] | DatetimeArray | DatetimeArray | dt64[ns tz] | ndarray[M8ns] | DatetimeArray | DatetimeArray | td64[ns] | ndarray[m8ns] | TimedeltaArray| TimedeltaArray | Period | ndarray[obj] | PeriodArray | PeriodArray | Nullable | EA | EA | EA | )rinternal_valuesrs r_valueszSeries._valuess@y((***rrec$|jjjSr)r_blockrrs rrzSeries._references7sy$$rrGc8|j}|Sr)r array_values)rarrs rrLz Series.array;si$$&& rintc*t|jS)z2 Return the length of the Series. )rrrs r__len__zSeries.__len__Ds49~~rnpt.DTypeLike | Nonerc|j}|tj||}ntj|||}|dur|S|dust |j|jr |}d|j_|S)a\ Return the values as a NumPy array. Users should not call this directly. Rather, it is invoked by :func:`numpy.array` and :func:`numpy.asarray`. Parameters ---------- dtype : str or numpy.dtype, optional The dtype to use for the resulting NumPy array. By default, the dtype is inferred from the data. copy : bool or None, optional See :func:`numpy.asarray`. Returns ------- numpy.ndarray The values in the series converted to a :class:`numpy.ndarray` with the specified `dtype`. See Also -------- array : Create a new array from data. Series.array : Zero-copy view to the array backing the Series. Series.to_numpy : Series method for similar behavior. Examples -------- >>> ser = pd.Series([1, 2, 3]) >>> np.asarray(ser) array([1, 2, 3]) For timezone-aware data, the timezones may be retained with ``dtype='object'`` >>> tzser = pd.Series(pd.date_range("2000", periods=2, tz="CET")) >>> np.asarray(tzser, dtype="object") array([Timestamp('2000-01-01 00:00:00+0100', tz='CET'), Timestamp('2000-01-02 00:00:00+0100', tz='CET')], dtype=object) Or the values may be localized to UTC and the tzinfo discarded with ``dtype='datetime64[ns]'`` >>> np.asarray(tzser, dtype="datetime64[ns]") # doctest: +ELLIPSIS array(['1999-12-31T23:00:00.000000000', ...], dtype='datetime64[ns]') Nr)rrTF) r rasarrayrLr'rviewflags writeable)rrrrrs r __array__zSeries.__array__Lsh <*V5111CC(6T:::C 4<<J 5==N6<CC=((**C"'CI  r list[Index]c|jgS)z7 Return a list of the row axis labels. rrs rrz Series.axess  |rrirrmr c|j|S)z Return the i-th value or values in the Series by location. Parameters ---------- i : int Returns ------- scalar )r )rrrs r_ixsz Series._ixss|Arslobjslicec|j||}|||j}|j|_||S)N)rr)r get_slicerrr __finalize__)rrrrouts r_slicez Series._slicesUi!!%d!33((38(<<J %%%rct|tj||}|tur|dSt |}t |ttfrt|}n|r| |St|rt|}t|dr{ | |}|S#tttf$rIt |tr1t |jt"r||cYSYnwxYwt |t&r||Stj|rEt-|j|}t/j|t2}||S||S)NFr) allow_slicer)r\rapply_if_callableEllipsisrr4rrrrQ _get_valuer1r:KeyError TypeErrorrrrU_get_values_tupler _getitem_sliceis_bool_indexerr[rrr_get_rows_with_mask _get_with)rkey key_is_scalarresults r __getitem__zSeries.__getitem__s"3'''#C.. (??99%9(( (!# cD%= ) ) ($$CC  (??3'' ' s   s))C s . . . 7 7-- i):; 7 7 7c5))7jZ.P.P7 11#66666  7 c5 ! ! ,&&s++ +  s # # 1$TZ55C*S---C++C00 0~~c"""sCAD=<D=ct|trtdt|tr||S|j|S)NzWIndexing a Series with DataFrame is not supported, use the appropriate DataFrame column)rr8r,rr-loc)rr2s rr1zSeries._get_withs` c< ( ( /B U # # /))#.. .x}rr2rctj|r0tj|j|}t ||St |jtstd|j |\}}| |j||d}t |tr|j |j ||S)N0key of type tuple not found and not a MultiIndexFrr)rany_nonerrr rPrrrUr+ get_loc_levelrr radd_referencesr#)rr2r4indexer new_indexnew_sers rr-zSeries._get_values_tuples <  Z S 122F "6 * * *M$*j11 OMNN N"Z55c::##DL$9QV#WW gu % % 3 L ' ' 2 2 2##D)))rr>npt.NDArray[np.bool_]c|j|}|||j|Sr)rget_rows_with_maskrrr#)rr>new_mgrs rr0zSeries._get_rows_with_masksA)..w77))' )EERRSWXXXrFtakeablecL|r |j|S|j|}t|r |j|St |jt r|j}|j|}t |dkr|jdkr|dS||}t||}| |||j d}t |tr|j |j ||S|j|S)z Quickly retrieve single value at passed index label. Parameters ---------- label : object takeable : interpret the index as indexers, default False Returns ------- scalar value rFrrr)r rget_locr0rrUrnlevelsrZrrr rr=r#iloc)rlabelrEr7mi new_valuesr?r@s rr*zSeries._get_values"  '<& &j  '' c?? %<$ $ dj* - - "Bc*J:!## a!!}$3I(E::I'')$)%(G#u%% 7 ++DI666''-- -9S> !rctsRtj|tkr5t j|s!t jttdt|t j ||}|turtd}t|tr2|j|d}|||S |||dS#t&$r||j|<YdSt*t,t.f$r4|j|}|||YdSt2$rm}t|t4r*t|jt6st'd|t j|rt;|j|}t=j|t@}tC|rtE|tE|kr_t|tFsJtI|j%s6|&d}|||Yd}~dS |'||d n#t2$r ||j(|<YnwxYwYd}~dS|)||Yd}~dSd}~wwxYw) Nrrgetitemkindr9rrTr)*rsys getrefcountrris_local_in_caller_framerrrrr\r(r)r rr_convert_slice_indexer _set_values_set_with_enginer+r7r,rr(rIrrrUr/r[rrrr2rrr3rnonzero_whererK _set_with)rr2rr>errs r __setitem__zSeries.__setitem__.s' t$$ 11#:V;;1 +-CPQ #3'''#C.. (??++C c5 ! ! 4j77)7LLG##GU33 30 +  ! !#u - - - - - " " ""DHSMMMM:'89 - - -j((--G   We , , , , , , # +# +# +#u%% jZ.P.P F"3'' +(S99jD111!'' E c$ii//&uf550+DJ770"kkmmA.G$$We444FFFFF+KKeTK::::(+++%*DIcNNN+sE*********G# +sPC66K  AK  K  D K2J  K J# K"J##K,KK cp|j|}|j||dSr)rrIrsetitem_inplace)rr2rr7s rrYzSeries._set_with_enginess7j  %% !!#u-----rct|trJt|rt|}|||dSr)rrr1r _set_labelsrr2rs rr\zSeries._set_withysQc5))))) s   s))C e$$$$$rctj|}|j|}|dk}|rt ||d|||dS)Nz not in index)rasarray_tuplesafer get_indexeranyr+rX)rr2rr>masks rrbzSeries._set_labelssw#C(("j44S99"} 88:: 8c$i66677 7 %(((((rct|ttfr|j}|j|||_dS)N)r>r)rrTrr rsetitemrcs rrXzSeries._set_valuess? cE6? + + +CI%%c%?? rc|s7 |j|}n#t$r||j|<YdSwxYw|}|||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)rrIr+r7rX)rrLrrEr7s r _set_valuezSeries._set_valuesx  j((//   "'  C e$$$$$s 77repeatsint | Sequence[int]ctjdd|i|j|}|j|}|||d|dS)a Repeat elements of a Series. Returns a new Series where each element of the current Series is repeated consecutively a given number of times. Parameters ---------- repeats : int or array of ints The number of repetitions for each element. This should be a non-negative integer. Repeating 0 times will return an empty Series. axis : None Unused. Parameter needed for compatibility with DataFrame. Returns ------- Series Newly created Series with repeated elements. See Also -------- Index.repeat : Equivalent function for Index. numpy.repeat : Similar method for :class:`numpy.ndarray`. Examples -------- >>> s = pd.Series(["a", "b", "c"]) >>> s 0 a 1 b 2 c dtype: str >>> s.repeat(2) 0 a 0 a 1 b 1 b 2 c 2 c dtype: str >>> s.repeat([1, 2, 3]) 0 a 1 b 1 b 2 c 2 c 2 c dtype: str rFr:repeatmethod)nvvalidate_repeatrrrr rr#)rrnrr?rNs rrrz Series.repeats~f 2~...J%%g.. \((11   95 IIVV W   r.)droprrallow_duplicateslevelrvrwLiteral[False]rwrrxrcdSrrqrryrwrrrxs r reset_indexzSeries.reset_indexs Cr)rrrx Literal[True]cdSrrqr|s rr}zSeries.reset_indexs r)rwrrxcdSrrqr|s rr}zSeries.reset_index srIndexLabel | NoneDataFrame | Series | Noneclt|d}|rtt}|gt|tt fs|g}n|}fd|D}t|jjkrj|}|r|_n d}||_| dS|rtd|tj urjd }nj}|} | ||| SdS) 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). allow_duplicates : bool, default False Allow duplicate column labels to be created. Returns ------- Series or DataFrame or None When `drop` is False (the default), a DataFrame is returned. The newly created columns will come first in the DataFrame, followed by the original Series values. When `drop` is True, a `Series` is returned. In either case, if ``inplace=True``, no value is returned. See Also -------- DataFrame.reset_index: Analogous function for DataFrame. Examples -------- >>> s = pd.Series( ... [1, 2, 3, 4], ... name="foo", ... index=pd.Index(["a", "b", "c", "d"], name="idx"), ... ) Generate a DataFrame with default index. >>> s.reset_index() idx foo 0 a 1 1 b 2 2 c 3 3 d 4 To specify the name of the new column use `name`. >>> s.reset_index(name="values") idx values 0 a 1 1 b 2 2 c 3 3 d 4 To generate a new Series with the default set `drop` to True. >>> s.reset_index(drop=True) 0 1 1 2 2 3 3 4 Name: foo, dtype: int64 The `level` parameter is interesting for Series with a multi-level index. >>> arrays = [ ... np.array(["bar", "bar", "baz", "baz"]), ... np.array(["one", "two", "one", "two"]), ... ] >>> s2 = pd.Series( ... range(4), ... name="foo", ... index=pd.MultiIndex.from_arrays(arrays, names=["a", "b"]), ... ) To remove a specific level from the Index, use `level`. >>> s2.reset_index(level="a") a foo b one bar 0 two bar 1 one baz 2 two baz 3 If `level` is not set, all levels are removed from the Index. >>> s2.reset_index() a b foo 0 bar one 0 1 bar two 1 2 baz one 2 3 baz two 3 rNcDg|]}j|Srq)r_get_level_number).0levrs r z&Series.reset_index..s)VVVCdj::3??VVVrFrr}rsz>$9I" trrcBtj}|jdi|S)zI Return a string representation for a particular Series. rq)fmtget_series_repr_params to_string)r repr_paramss r__repr__zSeries.__repr__s*022 t~,, ,,,r) na_rep float_formatheaderrlengthrrmax_rowsmin_rowsbufrr str | Nonerrr int | Nonerc dSrrq rrrrrrrrrrrs rrzSeries.to_strings crFilePath | WriteBuffer[str]c dSrrqrs rrzSeries.to_strings srrr) allowed_argsrNaNT"FilePath | WriteBuffer[str] | Nonec tj||||||||| |  } | } t| ts$t dt | j|| St|dr| | n?t|dd5} | | dddn #1swxYwYdS)aq 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. See Also -------- Series.to_dict : Convert Series to dict object. Series.to_frame : Convert Series to DataFrame object. Series.to_markdown : Print Series in Markdown-friendly format. Series.to_timestamp : Cast to DatetimeIndex of Timestamps. Examples -------- >>> ser = pd.Series([1, 2, 3]).to_string() >>> ser '0 1\n1 2\n2 3' ) rrrrrrrrrz.result must be of type str, type of result is Nwritewzutf-8)encoding) rSeriesFormatterrrrrrrhasattrropen)rrrrrrrrrrr formatterr4fs rrzSeries.to_strings<~' %    $$&&&#&&  : $V 5::  ;M S' " " IIf    c3111 Q               ts(C  CCmoderstorage_optionsrrStorageOptions | Nonec dSrrqrrrrrkwargss r to_markdownzSeries.to_markdown)s crIO[str]c dSrrqrs rrzSeries.to_markdown4rrIO[str] | Nonec dSrrqrs rrzSeries.to_markdown?s Srrwtc J|j|f|||d|S)aN Print Series in Markdown-friendly format. Parameters ---------- buf : str, Path or StringIO-like, optional, default None Buffer to write to. If None, the output is returned as a string. mode : str, optional Mode in which file is opened, "wt" by default. index : bool, optional, default True Add index (row) labels. storage_options : dict, optional Extra options that make sense for a particular storage connection, e.g. host, port, username, password, etc. For HTTP(S) URLs the key-value pairs are forwarded to ``urllib.request.Request`` as header options. For other URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more details, and for more examples on storage options refer `here `_. **kwargs These parameters will be passed to `tabulate `_. Returns ------- str Series in Markdown-friendly format. See Also -------- Series.to_frame : Rrite a text representation of object to the system clipboard. Series.to_latex : Render Series to LaTeX-formatted table. Notes ----- Requires the `tabulate `_ package. 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)rrrs rrzSeries.to_markdownJs@Z+t}}*  %  LR   rIterable[tuple[Hashable, Any]]cdtt|jt|dS)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 Tstrict)zipiterrrs ritemsz Series.itemss)64 ##T$ZZ====rrTc|jS)ap Return alias for index. Returns ------- Index Index of the Series. See Also -------- Series.index : The index (axis labels) of the Series. Examples -------- >>> s = pd.Series([1, 2, 3], index=[0, 1, 2]) >>> s.keys() Index([0, 1, 2], dtype='int64') rrs rrz Series.keyss &zrinto'type[MutableMappingT] | MutableMappingTrycdSrrqrrs rto_dictzSeries.to_dicts #r)r type[dict]dictcdSrrqrs rrzSeries.to_dicts:=#rctj|}t|jst |jt r'|d|DS||S)a Convert Series to {label -> value} dict or dict-like object. Parameters ---------- into : class, default dict The collections.abc.MutableMapping 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.MutableMapping Key-value representation of Series. See Also -------- Series.to_list: Converts Series to a list of the values. Series.to_numpy: Converts Series to NumPy ndarray. Series.array: ExtensionArray of the data backing this 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(into=OrderedDict) OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)]) >>> dd = defaultdict(list) >>> s.to_dict(into=dd) defaultdict(, {0: 1, 1: 2, 2: 3, 3: 4}) c3>K|]\}}|t|fVdSr)r,)rkvs r z!Series.to_dict..s4LLtq!1.q112LLLLLLr)rstandardize_mappingr3rrr7r)rrinto_cs rrzSeries.to_dicts{P(.. 4: & & (*TZ*P*P (6LLtzz||LLLLL L6$**,,'' 'rc,|tjur*|j}|td}n!t |g}nt |g}|j|}|||j}| |dS)aB Convert Series to DataFrame. Parameters ---------- name : object, optional The passed name should substitute for the series name (if it has one). Returns ------- DataFrame DataFrame representation of Series. See Also -------- Series.to_dict : Convert Series to dict object. Examples -------- >>> s = pd.Series(["a", "b", "c"], name="vals") >>> s.to_frame() vals 0 a 1 b 2 c NrGrrrs) rrrrWrTr to_2d_mgrrrr#)rrcolumnsrrs rrzSeries.to_frame s: 3> ! !9D|'**--TFmmGi!!'**  1 1#CH 1 E EtJ777r,ArrowArrayExportable | ArrowStreamExportablecBtdd}t||j|jfs[t |ds5t |ds%t dt |jd||}n|}| }|S)a Construct a Series from an array-like Arrow object. This function accepts any Arrow-compatible array-like object implementing the `Arrow PyCapsule Protocol`_ (i.e. having an ``__arrow_c_array__`` or ``__arrow_c_stream__`` method). This function currently relies on ``pyarrow`` to convert the object in Arrow format to pandas. .. _Arrow PyCapsule Protocol: https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html .. versionadded:: 3.0 Parameters ---------- data : pyarrow.Array or Arrow-compatible object Any array-like object implementing the Arrow PyCapsule Protocol (i.e. has an ``__arrow_c_array__`` or ``__arrow_c_stream__`` method). Returns ------- Series See Also -------- DataFrame.from_arrow : Construct a DataFrame from an Arrow object. Examples -------- >>> import pyarrow as pa >>> arrow_array = pa.array([1, 2, 3]) >>> pd.Series.from_arrow(arrow_array) 0 1 1 2 2 3 dtype: int64 rz14.0.0r__arrow_c_array__rzxExpected an Arrow-compatible array-like object (i.e. having an '_arrow_c_array__' or '__arrow_c_stream__' method), got 'z ' instead.) rrArrayrrr,rrr to_pandas)clsrrpa_arrayrs r from_arrowzSeries.from_arrow8sR( x H H H$2? ;<< 122 4!566   8T +888 ''--HHH  "" rcht|d}|r|n|d}||_|S)z Set the Series name. Parameters ---------- name : str inplace : bool Whether to modify `self` directly or return a copy. rFr)r%rr)rrrrs r _set_namezSeries._set_namevs;&gy998dd499%9#8#8 ra 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 We can pass a list of values to group the Series data by custom labels: >>> ser.groupby(["a", "b", "a", "b"]).mean() a 210.0 b 185.0 Name: Max Speed, dtype: float64 Grouping by numeric labels yields similar results: >>> ser.groupby([0, 1, 0, 1]).mean() 0 210.0 1 185.0 Name: Max Speed, dtype: float64 We can group by a level of the index: >>> ser.groupby(level=0).mean() Falcon 370.0 Parrot 25.0 Name: Max Speed, dtype: float64 We can group by a condition applied to the Series values: >>> 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 We can also group by the 'Type' level of the hierarchical index to get the mean speed for each type: >>> 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 To include `NA` values in the group keys, set `dropna=False`: >>> ser.groupby(level=0, dropna=False).sum() a 3 b 3 NaN 3 dtype: int64 We can also group by a custom list with NaN values to handle missing group labels: >>> 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 groupby)rbyryas_indexsort group_keysobserveddropnarc |ddlm}||td|std|||||||||S)Nrrz*You have to supply one of 'by' and 'level'z(as_index=False only valid with DataFrame)objrryrrrrr)pandas.core.groupby.genericrr,) rrryrrrrrrs rrzSeries.groupbysxz >===== =RZHII I HFGG G}!    rctt|jdS)a Return number of non-NA/null observations in the Series. Returns ------- int Number of non-null values in the Series. See Also -------- DataFrame.count : Count non-NA cells for each column or row. Examples -------- >>> s = pd.Series([0.0, 1.0, np.nan]) >>> s.count() 2 int64)r-r=r sumrrs rcountz Series.counts6&(dl(;(;(?(?(A(A(H(H(Q(QRRRrcJ|j}t|tjrt j||\}}n||}||tt||j d|j  |dS)ac Return the mode(s) of the Series. The mode is the value that appears most often. There can be multiple modes. Always returns Series even if only one value is returned. Parameters ---------- dropna : bool, default True Don't consider counts of NaN/NaT. Returns ------- Series Modes of the Series in sorted order. See Also -------- numpy.mode : Equivalent numpy function for computing median. Series.sum : Sum of the values. Series.median : Median of the values. Series.std : Standard deviation of the values. Series.var : Variance of the values. Series.min : Minimum value. Series.max : Maximum value. Examples -------- >>> s = pd.Series([2, 4, 2, 2, 4, None]) >>> s.mode() 0 2.0 dtype: float64 More than one mode: >>> s = pd.Series([2, 4, 8, 2, 4, None]) >>> s.mode() 0 2.0 1 4.0 dtype: float64 With and without considering null value: >>> s = pd.Series([2, 4, None, None, 4, None]) >>> s.mode(dropna=False) 0 NaN dtype: float64 >>> s = pd.Series([2, 4, None, None, 4, None]) >>> s.mode() 0 4.0 dtype: float64 )rF)rrrrrrs) r rrrr?r_moderrangerrrr#)rrr res_values_s rrz Series.mode-sn fbj ) ) 5&OF6BBBMJV44J  J((* !  ,tF, + +  ,rricDtS)a Return unique values of Series object. Uniques are returned in order of appearance. Hash table-based unique, therefore does NOT sort. Returns ------- ndarray or ExtensionArray The unique values returned as a NumPy array. See Notes. See Also -------- Series.drop_duplicates : Return Series with duplicate values removed. unique : Top-level unique method for any 1-d array-like object. Index.unique : Return Index with unique values from an Index object. Notes ----- Returns the unique values as a NumPy array. In case of an extension-array backed Series, a new :class:`~api.extensions.ExtensionArray` of that type with just the unique values is returned. This includes * Categorical * Period * Datetime with Timezone * Datetime without Timezone * Timedelta * Interval * Sparse * IntegerNA See Examples section. Examples -------- >>> pd.Series([2, 1, 3, 3], name="A").unique() array([2, 1, 3]) >>> pd.Series([pd.Timestamp("2016-01-01") for _ in range(3)]).unique() ['2016-01-01 00:00:00'] Length: 1, dtype: datetime64[us] >>> pd.Series( ... [pd.Timestamp("2016-01-01", tz="US/Eastern") for _ in range(3)] ... ).unique() ['2016-01-01 00:00:00-05:00'] Length: 1, dtype: datetime64[us, US/Eastern] A Categorical will return categories in the order of appearance and with the same dtype. >>> pd.Series(pd.Categorical(list("baabc"))).unique() ['b', 'a', 'c'] Categories (3, str): ['a', 'b', 'c'] >>> pd.Series( ... pd.Categorical(list("baabc"), categories=list("abc"), ordered=True) ... ).unique() ['b', 'a', 'c'] Categories (3, str): ['a' < 'b' < 'c'] )superrr __class__s rrz Series.uniquessBww~~r)keepr ignore_indexrrorcdSrrqrrrrs rdrop_duplicateszSeries.drop_duplicatess r)rrcdSrrqrs rrzSeries.drop_duplicatess sr Series | NonecdSrrqrs rrzSeries.drop_duplicatess rfirstct|d}t|}|r!tt ||_|r||dS|S)u] Return Series with duplicate values removed. Parameters ---------- keep : {'first', 'last', ``False``}, default 'first' Method to handle dropping duplicates: - 'first' : Drop duplicates except for the first occurrence. - 'last' : Drop duplicates except for the last occurrence. - ``False`` : Drop all duplicates. inplace : bool, default ``False`` If ``True``, performs operation inplace and returns None. ignore_index : bool, default ``False`` If ``True``, the resulting axis will be labeled 0, 1, …, n - 1. .. versionadded:: 2.0.0 Returns ------- Series or None Series with duplicates dropped or None if ``inplace=True``. See Also -------- Index.drop_duplicates : Equivalent method on Index. DataFrame.drop_duplicates : Equivalent method on DataFrame. Series.duplicated : Related method on Series, indicating duplicate Series values. Series.unique : Return unique values as an array. Examples -------- Generate a Series with duplicated entries. >>> s = pd.Series( ... ["llama", "cow", "llama", "beetle", "llama", "hippo"], name="animal" ... ) >>> s 0 llama 1 cow 2 llama 3 beetle 4 llama 5 hippo Name: animal, dtype: str With the 'keep' parameter, the selection behavior 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 llama 1 cow 3 beetle 5 hippo Name: animal, dtype: str 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 llama 5 hippo Name: animal, dtype: str The value ``False`` for parameter 'keep' discards all sets of duplicated entries. >>> s.drop_duplicates(keep=False) 1 cow 3 beetle 5 hippo Name: animal, dtype: str rrN)r%rrrWrr_update_inplace)rrrrr4rs rrzSeries.drop_duplicatessrl&gy99((d(33  6(V55FL     ( ( (4Mrc||}|||jd}||dS)a_ Indicate duplicate Series values. Duplicated values are indicated as ``True`` values in the resulting Series. Either all duplicates, all except the first or all except the last occurrence of duplicates can be indicated. Parameters ---------- keep : {'first', 'last', False}, default 'first' Method to handle dropping duplicates: - 'first' : Mark duplicates as ``True`` except for the first occurrence. - 'last' : Mark duplicates as ``True`` except for the last occurrence. - ``False`` : Mark all duplicates as ``True``. Returns ------- Series[bool] Series indicating whether each value has occurred in the preceding values. See Also -------- Index.duplicated : Equivalent method on pandas.Index. DataFrame.duplicated : Equivalent method on pandas.DataFrame. Series.drop_duplicates : Remove duplicate values from Series. Examples -------- By default, for each set of duplicated values, the first occurrence is set on False and all others on True: >>> animals = pd.Series(["llama", "cow", "llama", "beetle", "llama"]) >>> 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 rFr:rrs) _duplicatedrrr#)rrresr4s rrzSeries.duplicated+ sPXD))""3dju"EE""4 "===rrlskipnacj||}|j||g|Ri|}|j|S)a Return the row label of the minimum value. If multiple values equal the minimum, the first row label with that value is returned. Parameters ---------- axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. skipna : bool, default True Exclude NA/null values. If the entire Series is NA, or if ``skipna=False`` and there is an NA value, this method will raise a ``ValueError``. *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' )_get_axis_numberargminrrrrargsrrKs ridxminz Series.idxmin{ sHp$$T**t{49$999&99z$rcj||}|j||g|Ri|}|j|S)a Return the row label of the maximum value. If multiple values equal the maximum, the first row label with that value is returned. Parameters ---------- axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. skipna : bool, default True Exclude NA/null values. If the entire Series is NA, or if ``skipna=False`` and there is an NA value, this method will raise a ``ValueError``. *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' )rargmaxrr s ridxmaxz Series.idxmax sHr$$T**t{49$999&99z$rdecimalsctj||t|dkr|St |jrS|j}tj|fdd}| ||j d |dS|j }|||j  |dS) a 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. Series.dt.round : Round values of data to the specified freq. Notes ----- For values exactly halfway between rounded decimal values, pandas rounds to the nearest even value (e.g. -0.5 and 0.5 round to 0.0, 1.5 and 2.5 round to 2.0, etc.). Examples -------- >>> s = pd.Series([-0.5, 0.1, 2.5, 1.3, 2.7]) >>> s.round() 0 -0.0 1 0.0 2 2.0 3 1.0 4 3.0 dtype: float64 rc$t|Sr)round)xrs rzSeries.round..% sU1h5G5GrF)convertr:rrs)rr)ruvalidate_roundrrr3rr r map_inferrrr#rrrr)rrr rrr4rDs ` rrz Series.round sT $''' t99>>99;;  4: & & \F]6+G+G+G+GQVWWWF$$V4:E$JJWWWX )//8/44))' )EERR S   rqfloat interpolationr}cdSrrqrrrs rquantilezSeries.quantile. s rSequence[float] | AnyArrayLikecdSrrqrs rrzSeries.quantile3 s r&float | Sequence[float] | AnyArrayLikefloat | SeriescdSrrqrs rrzSeries.quantile: s r?linearct||}|||d}|jdkr|jdddf}t |rD|j|_t|tj }| |||jSt|jdS)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) * (x-i)/(j-i)`, where `(x-i)/(j-i)` is the fractional part of the index surrounded by `i > 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(0.5) 2.5 >>> s.quantile([0.25, 0.5, 0.75]) 0.25 1.75 0.50 2.50 0.75 3.25 dtype: float64 F)rr numeric_onlyrNrrrr) r&rrndimrKr2rrTrfloat64rr-)rrrrr4idxs rrzSeries.quantileA s\ A]]__q ERR ;!  [A&F ?? <)FK,,,C$$V3TY$GG G,FKN;; ;rpearsonotherrtrn min_periodsc||d\}}t|dkr tjS|t tjd}|t tjd}|dvst |r)tj||||}t|}|Std|d ) a Compute correlation with `other` Series, excluding missing values. The two `Series` objects are not required to be the same length and will be aligned internally before the correlation function is applied. Parameters ---------- other : Series Series with which to compute the correlation. method : {'pearson', 'kendall', 'spearman'} or callable Method used to compute correlation: - pearson : Standard correlation coefficient - kendall : Kendall Tau correlation coefficient - spearman : Spearman rank correlation - callable: Callable with input two 1d ndarrays and returning a float. .. warning:: Note that the returned matrix from corr will have 1 along the diagonals and will be symmetric regardless of the callable's behavior. min_periods : int, optional Minimum number of observations needed to have a valid result. Returns ------- float Correlation with other. See Also -------- DataFrame.corr : Compute pairwise correlation between columns. DataFrame.corrwith : Compute pairwise correlation with another DataFrame or Series. Notes ----- Pearson, Kendall and Spearman correlation are currently computed using pairwise complete observations. * `Pearson correlation coefficient `_ * `Kendall rank correlation coefficient `_ * `Spearman's rank correlation coefficient `_ Automatic data alignment: as with all pandas operations, automatic data alignment is performed for this method. ``corr()`` automatically considers values with matching indices. Examples -------- >>> def histogram_intersection(a, b): ... v = np.minimum(a, b).sum().round(decimals=1) ... return v >>> s1 = pd.Series([0.2, 0.0, 0.6, 0.2]) >>> s2 = pd.Series([0.3, 0.6, 0.0, 0.1]) >>> s1.corr(s2, method=histogram_intersection) 0.3 Pandas auto-aligns the values with matching indices >>> s1 = pd.Series([1, 2, 3], index=[0, 1, 2]) >>> s2 = pd.Series([1, 2, 3], index=[2, 1, 0]) >>> s1.corr(s2) -1.0 If the input is a constant array, the correlation is not defined in this case, and ``np.nan`` is returned. >>> s1 = pd.Series([0.45, 0.45]) >>> s1.corr(s1) nan innerjoinrFrna_valuer)r+spearmankendall)rtr-zHmethod must be either 'pearson', 'spearman', 'kendall', or a callable, 'z' was supplied) alignrrnanto_numpyrcallablerBnancorrr-r)rr,rtr-this this_values other_valuesr4s rcorrz Series.corr sZjjWj55 e t99>>6Mmm%"&umMM ~~EBF~OO 7 7 78F;K;K 7^\&kF.f55FM ' ' ' '   rrGddofcb||d\}}t|dkr tjS|t tjd}|t tjd}t j||||}t|}|S)aF Compute covariance with Series, excluding missing values. The two `Series` objects are not required to be the same length and will be aligned internally before the covariance is calculated. Parameters ---------- other : Series Series with which to compute the covariance. min_periods : int, optional Minimum number of observations needed to have a valid result. ddof : int, default 1 Delta degrees of freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. Returns ------- float Covariance between Series and other normalized by N-1 (unbiased estimator). See Also -------- DataFrame.cov : Compute pairwise covariance of columns. Examples -------- >>> s1 = pd.Series([0.90010907, 0.13484424, 0.62036035]) >>> s2 = pd.Series([0.12528585, 0.26962463, 0.51111198]) >>> s1.cov(s2) -0.01685762652715874 r/r0rFr2)r-r?) r6rrr7r8rrBnancovr-)rr,r-r?r;r<r=r4s rcovz Series.cov sNjjWj55 e t99>>6Mmm%"&umMM ~~EBF~OO  ;T   *&11 rperiodscJtj|s2t|r|stdt j|j|}|||j d |dS)a First discrete difference of Series elements. Calculates the difference of a Series element compared with another element in the Series (default is element in previous row). Parameters ---------- periods : int, default 1 Periods to shift for calculating difference, accepts negative values. Returns ------- Series First differences of the Series. See Also -------- Series.pct_change: Percent change over given number of periods. Series.shift: Shift index by desired number of periods with an optional time freq. DataFrame.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 Series, however dtype of the result is always float64. Examples -------- 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 zperiods must be an integerFr:diffrs) rr0r/rr?rEr rrrr#)rrCr4s rrEz Series.diff sZ~g&& ?W%% ?'*<*<*>*> ? !=>>>w77  $*//++%!  ,tF, + + ,rlagcx|tt||S)a Compute the lag-N autocorrelation. This method computes the Pearson correlation between the Series and its shifted self. Parameters ---------- lag : int, default 1 Number of lags to apply before performing autocorrelation. Returns ------- float The Pearson correlation between self and self.shift(lag). See Also -------- Series.corr : Compute the correlation between two Series. Series.shift : Shift index by desired number of periods. DataFrame.corr : Compute pairwise correlation of columns. DataFrame.corrwith : Compute pairwise correlation between rows or columns of two DataFrame objects. Notes ----- If the Pearson correlation is not well defined return 'NaN'. Examples -------- >>> s = pd.Series([0.25, 0.5, 0.2, -0.05]) >>> s.autocorr() # doctest: +ELLIPSIS 0.10355... >>> s.autocorr(lag=2) # doctest: +ELLIPSIS -0.99999... If the Pearson correlation is not well defined, then 'NaN' is returned. >>> s = pd.Series([1, 0, 0, 0]) >>> s.autocorr() nan )r>rrshift)rrFs rautocorrzSeries.autocorri s+Vyyfdjjoo66777rAnyArrayLike | DataFrameSeries | np.ndarraycft|ttfr|j|j}t |t |jks%t |t |jkrt d||}||}|j}|j}nV|j}tj |}|j d|j dkrtd|j d|j t|trot|jgt|j}|tj|||jd||d St|trtj||}nOt|tjrtj||}nt+d t-|t/|S) a2 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`. 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 alignedrrzDot product shape mismatch, z vs F)rrrdotrszunsupported type: )rrr8runionrrrrrrshape Exceptionr*rrrrMrr#rr,rr-) rr,rAleftrightlvalsrvals common_typer4s rrMz Series.dot sd efl3 4 4 Z%%ek22F6{{S__,,F c%+>N>N0N0N !;<<<<e>>?? ?'///rc,||SzB Matrix multiplication using binary `@` operator. )rMrr,s r __matmul__zSeries.__matmul__ sxxrcP|tj|SrW)rMr transposerXs r __rmatmul__zSeries.__rmatmul__ s xx U++,,,rrQ$NumpyValueArrayLike | ExtensionArraysideLiteral['left', 'right']sorterNumpySorter | Nonenpt.NDArray[np.intp] | np.intpcHtj||||S)a Find indices where elements should be inserted to maintain order. Find the indices into a sorted Series `self` such that, if the corresponding elements in `value` were inserted before the indices, the order of `self` would be preserved. .. note:: The Series *must* be monotonically sorted, otherwise wrong locations will likely be returned. Pandas does *not* check this for you. Parameters ---------- value : array-like or scalar Values to insert into `self`. side : {'left', 'right'}, optional If 'left', the index of the first suitable location found is given. If 'right', return the last such index. If there is no suitable index, return either 0 or N (where N is the length of `self`). sorter : 1-D array-like, optional Optional array of integer indices that sort `self` into ascending order. They are typically the result of ``np.argsort``. Returns ------- int or array of int A scalar or array of insertion points with the same shape as `value`. See Also -------- sort_values : Sort by the values along either axis. numpy.searchsorted : Similar method from NumPy. Notes ----- Binary search is used to find the required insertion points. Examples -------- >>> ser = pd.Series([1, 2, 3]) >>> ser 0 1 1 2 2 3 dtype: int64 >>> ser.searchsorted(4) np.int64(3) >>> ser.searchsorted([0, 4]) array([0, 3]) >>> ser.searchsorted([1, 3], side="left") array([0, 2]) >>> ser.searchsorted([1, 3], side="right") array([1, 3]) >>> ser = pd.Series(pd.to_datetime(["3/11/2000", "3/12/2000", "3/13/2000"])) >>> ser 0 2000-03-11 1 2000-03-12 2 2000-03-13 dtype: datetime64[us] >>> ser.searchsorted("3/14/2000") np.int64(3) >>> ser = pd.Categorical( ... ["apple", "bread", "bread", "cheese", "milk"], ordered=True ... ) >>> ser ['apple', 'bread', 'bread', 'cheese', 'milk'] Categories (4, str): ['apple' < 'bread' < 'cheese' < 'milk'] >>> ser.searchsorted("bread") np.int64(1) >>> ser.searchsorted(["bread"], side="right") array([3]) If the values are not monotonically sorted, wrong locations may be returned: >>> ser = pd.Series([2, 1, 3]) >>> ser 0 2 1 1 2 3 dtype: int64 >>> ser.searchsorted(1) # doctest: +SKIP 0 # wrong result, correct would be 1 )r^r`)r@ IndexOpsMixin searchsorted)rrr^r`s rrezSeries.searchsorted s%x!..tUf.UUUr to_appendc,ddlm}|||g|S)Nrconcat)r)pandas.core.reshape.concatri)rrfrris r_append_internalzSeries._append_internalT s.555555vtY'lCCCCrrX align_axis keep_shape keep_equal result_namesrDataFrame | SeriescPt|||||S)a Compare to another Series and show the differences. Parameters ---------- other : Series Object to compare with. align_axis : {{0 or 'index', 1 or 'columns'}}, default 1 Determine which axis to align the comparison on. * 0, or 'index' : Resulting differences are stacked vertically with rows drawn alternately from self and other. * 1, or 'columns' : Resulting differences are aligned horizontally with columns drawn alternately from self and other. keep_shape : bool, default False If true, all rows and columns are kept. Otherwise, only the ones with different values are kept. keep_equal : bool, default False If true, the result keeps values that are equal. Otherwise, equal values are shown as NaNs. result_names : tuple, default ('self', 'other') Set the dataframes names in the comparison. 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: str Keep all original rows >>> s1.compare(s2, keep_shape=True) self other 0 NaN NaN 1 b a 2 NaN NaN 3 d b 4 NaN NaN Keep all original rows and also all original values >>> s1.compare(s2, keep_shape=True, keep_equal=True) self other 0 a a 1 b a 2 c c 3 d b 4 e e )r,rlrmrnro)rcompare)rr,rlrmrnrors rrrzSeries.compareY s4~ww!!!%    rSeries | Hashablefunc(Callable[[Hashable, Hashable], Hashable] fill_valueHashable | Nonec|t|jd}ttr|jj}t j|}tj t|t}tj d5t|D]@\}}|||} ||} | | ||<A dddn #1swxYwYn||j}tj t|t}tj d5fd|jD|dd<dddn #1swxYwY|j}|j|} || | j||dS) 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 not present at some index from one of the two Series 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 NFrrignoreallc(g|]}|Srqrq)rlvrtr,s rrz"Series.combine.. s# H H HRb% H H Hr)rrrr)r<rrrrrNrCget_op_result_nameremptyrrerrstate enumerategetr rrL_cast_pointwise_resultr) rr,rtrvr?new_namerNrr*r}rvrs `` rcombinezSeries.combine sIP  +DJuEEEJ eV $ $ ! ((55I-dE::H#i..???J*** 1 1' 2211FAs#z22B3 33B$(DRLLJqMM1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 I#i..???J*** I I H H H H H4< H H H 111  I I I I I I I I I I I I I I IyHZ66zBB   " !   s%!AC??DDE55E9<E9c ddlm}|j|jkrG|j|jr(|||S|j|j}|}|j|jt|}|j|}| |}| |}|jj dkrG|jj dkr7t|}tjdtt!|||g}| |}||dS)a Update null elements with value in the same location in 'other'. Combine two Series objects by filling null values in one Series with non-null values from the other Series. Result index will be the union of the two indexes. Parameters ---------- other : Series The value(s) to be used for filling null values. Returns ------- Series The result of combining the provided Series with the other object. See Also -------- Series.combine : Perform element-wise operation on two Series using a given function. Examples -------- >>> s1 = pd.Series([1, np.nan]) >>> s2 = pd.Series([3, 4, 5]) >>> s1.combine_first(s2) 0 1.0 1 4.0 2 5.0 dtype: float64 Null values still persist if the location of that null value does not exist in `other` >>> s1 = pd.Series({"falcon": np.nan, "eagle": 160.0}) >>> s2 = pd.Series({"eagle": 200.0, "duck": 30.0}) >>> s1.combine_first(s2) duck 30.0 eagle 160.0 falcon NaN dtype: float64 rrhMzSilently casting non-datetime 'other' to datetime in Series.combine_first is deprecated and will be removed in a future version. Explicitly cast before calling combine_first instead.r combine_firstrs)rjrirrrrir;rN differencer=rrRrcrrrr#r#)rr,rir?r; keep_other keep_thiscombineds rrzSeries.combine_first( siX 655555 : $ $z  -- 5yye444J$$U[11 [++DJuT{{,CDD J))*55 ||I&& j)) :?c ! !ek&6#&=&=&&E M)+--    64-((##I..$$T/$BBBrSeries | Sequence | MappingctsRtj|tkr5t j|s!t jttdt|tst|}| |}t|}|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 Other Series that provides values to update the current Series. See Also -------- Series.combine : Perform element-wise operation on two Series using a given function. Series.transform: Modify a Series using a function. 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: str >>> 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 rr)rinewN)rrTrUrrrVrrrrrr reindex_liker=rputmask)rr,ris rupdatez Series.updateu sT( !""*-*Ft*L*L" 9*  %(( "5MME""4((U||I%%4U%;; r)r ascendingrrR na_positionrr2rbool | Sequence[bool]rRrrrzrcdSrrqrrrrrRrrr2s r sort_valueszSeries.sort_values r)rrrRrrr2cdSrrqrs rrzSeries.sort_values srcdSrrqrs rrzSeries.sort_values r quicksortlastValueKeyFunc | Nonect|d}||t|r[ttt |}t |dkr tdt |d|d}t|}|dvrtd||r)ttt||j }n|j }t||t ||} t| t | r-|r||S|d S||j | |j| d } |r!t%t | | _|s| |d S|| d S)u1 Sort by the values. Sort a Series in ascending or descending order by some criterion. Parameters ---------- axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. ascending : bool or list of bools, default True If True, sort values in ascending order, otherwise descending. inplace : bool, default False If True, perform operation in-place. kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort' Choice of sorting algorithm. See also :func:`numpy.sort` for more information. 'mergesort' and 'stable' are the only stable algorithms. na_position : {'first' or 'last'}, default 'last' Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at the end. ignore_index : bool, default False If True, the resulting axis will be labeled 0, 1, …, n - 1. key : callable, optional If not None, apply the key function to the series values before sorting. This is similar to the `key` argument in the builtin :meth:`sorted` function, with the notable difference that this `key` function should be *vectorized*. It should expect a ``Series`` and return an array-like. Returns ------- Series or None Series ordered by values or None if ``inplace=True``. See Also -------- Series.sort_index : Sort by the Series indices. DataFrame.sort_values : Sort DataFrame by the values along either axis. DataFrame.sort_index : Sort DataFrame by indices. Examples -------- >>> s = pd.Series([np.nan, 1, 3, 10, 5]) >>> s 0 NaN 1 1.0 2 3.0 3 10.0 4 5.0 dtype: float64 Sort values ascending order (default behavior) >>> s.sort_values(ascending=True) 1 1.0 2 3.0 4 5.0 3 10.0 0 NaN dtype: float64 Sort values descending order >>> s.sort_values(ascending=False) 3 10.0 4 5.0 2 3.0 1 1.0 0 NaN dtype: float64 Sort values putting NAs first >>> s.sort_values(na_position="first") 0 NaN 1 1.0 2 3.0 4 5.0 3 10.0 dtype: float64 Sort a series of strings >>> s = pd.Series(["z", "b", "d", "a", "c"]) >>> s 0 z 1 b 2 d 3 a 4 c dtype: str >>> s.sort_values() 3 a 1 b 4 c 2 d 0 z dtype: str 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: str >>> s.sort_values(key=lambda x: x.str.lower()) 0 a 1 B 2 c 3 D 4 e dtype: str 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 rrGzLength of ascending (z) must be 1 for Seriesr)rrzinvalid na_position: Frr:rrsN)r%rr2rrrrrr$rr`r rarrrrrrWr#) rrrrrRrrr2values_to_sort sorted_indexr4s rrzSeries.sort_values sr&gy99 d###  " " %Xd^Y77I9~~"" RC NNRRR"! I&y11 / / /B[BBCC C  *!&*;D#*F*FGGONN!\Nd9oo{SS L#l*;*; < < ) 2++D11199%9(( ("" L &dj.FU#    <(\):):;;FL C&&tM&BB B V$$$tr)rryrrRrsort_remainingrr2rruc dSrrq rrryrrrRrrrr2s r sort_indexzSeries.sort_indexs sr rryrrrRrrrr2c dSrrqrs rrzSeries.sort_indexs rc dSrrqrs rrzSeries.sort_indexs rIndexKeyFunc | Nonec Xt|||||||||  S)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 : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. level : int, optional If not None, sort on values in specified index level(s). ascending : bool or list-like of bools, default True Sort ascending vs. descending. When the index is a MultiIndex the sort direction can be controlled for each level individually. inplace : bool, default False If True, perform operation in-place. kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort' Choice of sorting algorithm. See also :func:`numpy.sort` for more information. 'mergesort' and 'stable' are the only stable algorithms. For DataFrames, this option is only applied when sorting on a single column or label. na_position : {'first', 'last'}, default 'last' If 'first' puts NaNs at the beginning, 'last' puts NaNs at the end. Not implemented for MultiIndex. sort_remaining : bool, default True If True and sorting by level and index is multilevel, sort by other levels too (in order) after sorting by specified level. ignore_index : bool, default False If True, the resulting axis will be labeled 0, 1, …, n - 1. key : callable, optional If not None, apply the key function to the index values before sorting. This is similar to the `key` argument in the builtin :meth:`sorted` function, with the notable difference that this `key` function should be *vectorized*. It should expect an ``Index`` and return an ``Index`` of the same shape. Returns ------- Series or None The original Series sorted by the labels or None if ``inplace=True``. See Also -------- DataFrame.sort_index: Sort DataFrame by the index. DataFrame.sort_values: Sort DataFrame by the value. Series.sort_values : Sort Series by the value. Examples -------- >>> s = pd.Series(["a", "b", "c", "d"], index=[3, 2, 1, 4]) >>> s.sort_index() 1 c 2 b 3 a 4 d dtype: str Sort Descending >>> s.sort_index(ascending=False) 4 d 3 a 2 b 1 c dtype: str 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: str 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)rr) rrryrrrRrrrr2rs rrzSeries.sort_indexsBJww!!#)%"   rorderstablec|dkr|||j|}|||j|jt jd}||dS)a Return the integer indices that would sort the Series values. Override ndarray.argsort. Argsorts the value, omitting NA/null values, and places the result in the same locations as the non-NA values. Parameters ---------- axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. kind : {'mergesort', 'quicksort', 'heapsort', 'stable'}, default 'quicksort' Choice of sorting algorithm. See :func:`numpy.sort` for more information. 'mergesort' and 'stable' are the only stable algorithms. order : None Has no effect but is accepted for compatibility with numpy. stable : None Has no effect but is accepted for compatibility with numpy. Returns ------- Series[np.intp] Positions of values within the sort order with -1 indicating nan values. See Also -------- numpy.ndarray.argsort : Returns the indices that would sort this array. Examples -------- >>> s = pd.Series([3, 2, 1]) >>> s.argsort() 0 2 1 1 2 0 dtype: int64 rerQF)rrrrargsortrs) rrLrrrrrintpr#)rrrRrrr4rs rrzSeries.argsort{sX 2::  ! !$ ' ' '###.. $*49BG%   Y777rnLiteral['first', 'last', 'all']cTtj|||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 rr)r^ SelectNSeriesnlargestrrrs rrzSeries.nlargests)R$TQT:::CCEEErcTtj|||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)r^r nsmallestrs rrzSeries.nsmallests)P$TQT:::DDFFFrrejbool | lib.NoDefaultc||t|jtsJ|d}|j|||_|S)a Swap levels i and j in a :class:`MultiIndex`. Default is to swap the two innermost levels of the index. Parameters ---------- i, j : int or str Levels of the indices to be swapped. Can pass level name as string. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. Returns ------- Series Series with levels swapped in MultiIndex. See Also -------- DataFrame.swaplevel : Swap levels i and j in a :class:`DataFrame`. Series.reorder_levels : Rearrange index levels using input order. MultiIndex.swaplevel : Swap levels i and j in a :class:`MultiIndex`. Examples -------- >>> s = pd.Series( ... ["A", "B", "A", "C"], ... index=[ ... ["Final exam", "Final exam", "Coursework", "Coursework"], ... ["History", "Geography", "History", "Geography"], ... ["January", "February", "March", "April"], ... ], ... ) >>> s Final exam History January A Geography February B Coursework History March A Geography April C dtype: str In the following example, we will swap the levels of the indices. Here, we will swap the levels column-wise, but levels can be swapped row-wise in a similar manner. Note that column-wise is the default behavior. By not supplying any arguments for i and j, we swap the last and second to last indices. >>> s.swaplevel() Final exam January History A February Geography B Coursework March History A April Geography C dtype: str By supplying one argument, we can choose which index to swap the last index with. We can for example swap the first index with the last one as follows. >>> s.swaplevel(0) January History Final exam A February Geography Final exam B March History Coursework A April Geography Coursework C dtype: str We can also define explicitly which indices we want to swap by supplying values for both i and j. Here, we for example swap the first and second indices. >>> s.swaplevel(0, 1) History Final exam January A Geography Final exam February B History Coursework March A Geography Coursework April C dtype: str Fr)_check_copy_deprecationrrrUr swaplevel)rrrrr4s rrzSeries.swaplevelsbn $$T***$*j11111&&z++Aq11  rSequence[Level]ct|jtstd|d}t|jtsJ|j||_|S)a 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 ------- Series Type of caller with index as MultiIndex (new object). See Also -------- DataFrame.reorder_levels : Rearrange index or column levels using input ``order``. Examples -------- >>> arrays = [ ... np.array(["dog", "dog", "cat", "cat", "bird", "bird"]), ... np.array(["white", "black", "white", "black", "white", "black"]), ... ] >>> s = pd.Series([1, 2, 3, 3, 5, 2], index=arrays) >>> s dog white 1 black 2 cat white 3 black 3 bird white 5 black 2 dtype: int64 >>> s.reorder_levels([1, 0]) white dog 1 black dog 2 white cat 3 black cat 3 white bird 5 black bird 2 dtype: int64 z/Can only reorder levels on a hierarchical axis.Fr)rrrUrPrreorder_levels)rrr4s rrzSeries.reorder_levelsspZ$*j11 OMNN N&&&, 33333|22599  rct|jtr|j\}}nt |rCt |jr/tjtj |j\}}n.| }|r| dn|S|rtt |}n|j|}||||jdS)uJ Transform each element of a list-like to a row. Parameters ---------- ignore_index : bool, default False If True, the resulting index will be labeled 0, 1, …, n - 1. Returns ------- Series Exploded lists to rows; index will be duplicated for these rows. See Also -------- Series.str.split : Split string values on specified separator. Series.unstack : Unstack, a.k.a. pivot, Series with MultiIndex to produce DataFrame. DataFrame.melt : Unpivot a DataFrame from wide format to long format. DataFrame.explode : Explode a DataFrame from list-like columns to long format. Notes ----- This routine will explode list-likes including lists, tuples, sets, Series, and np.ndarray. The result dtype of the subset rows will be object. Scalars will be returned unchanged, and empty list-likes will result in an np.nan for that row. In addition, the ordering of elements in the output will be non-deterministic when exploding sets. Reference :ref:`the user guide ` for more examples. Examples -------- >>> s = pd.Series([[1, 2, 3], "foo", [], [3, 4]]) >>> s 0 [1, 2, 3] 1 foo 2 [] 3 [3, 4] dtype: object >>> s.explode() 0 1 0 2 0 3 1 foo 2 NaN 3 3 3 4 dtype: object T)rwFrH)rrr7r _exploderr3rexploderrrr}rWrrrrr)rrrcountsr4rs rrzSeries.explodesj dj. 1 1 M!\2244NFFF YY M?4:66 M$_RZ -E-EFFNFFFYY[[F4@L6%%4%000f L  .(V55EEJ%%f--E  u495 QQQrc*ddlm}|||||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. sort : bool, default True Sort the level(s) in the resulting MultiIndex columns. Returns ------- DataFrame Unstacked Series. See Also -------- DataFrame.unstack : Pivot the MultiIndex of a DataFrame. Notes ----- Reference :ref:`the user guide ` for more examples. Examples -------- >>> s = pd.Series( ... [1, 2, 3, 4], ... index=pd.MultiIndex.from_product([["one", "two"], ["a", "b"]]), ... ) >>> s one a 1 b 2 two a 3 b 4 dtype: int64 >>> s.unstack(level=-1) a b one 1 2 two 3 4 >>> s.unstack(level=0) one two a 1 3 b 2 4 r)unstack)pandas.core.reshape.reshaper)rryrvrrs rrzSeries.unstack]s-l 877777wtUJ555r"Callable | Mapping | Series | None na_actionLiteral['ignore'] | NoneengineCallable | Nonec |Qd|vr>|d}tjdtt nt d|t |st dt|dst d||j ||d |||d k }t|tst||j |j }||d St |rtj|fi|}|||}|||j d|d S)aH Map values of Series according to an input mapping or function. Used for substituting each value in a Series with another value, that may be derived from a function, a ``dict`` or a :class:`Series`. Parameters ---------- func : function, collections.abc.Mapping subclass or Series Function or mapping correspondence. na_action : {None, 'ignore'}, default None If 'ignore', propagate NaN values, without passing them to the mapping correspondence. engine : decorator, optional Choose the execution engine to use to run the function. Only used for functions. If ``map`` is called with a mapping or ``Series``, an exception will be raised. If ``engine`` is not provided the function will be executed by the regular Python interpreter. Options include JIT compilers such as Numba, Bodo or Blosc2, which in some cases can speed up the execution. To use an executor you can provide the decorators ``numba.jit``, ``numba.njit``, ``bodo.jit`` or ``blosc2.jit``. You can also provide the decorator with parameters, like ``numba.jit(nogit=True)``. Not all functions can be executed with all execution engines. In general, JIT compilers will require type stability in the function (no variable should change data type during the execution). And not all pandas and NumPy APIs are supported. Check the engine documentation for limitations. .. versionadded:: 3.0.0 **kwargs Additional keyword arguments to pass as keywords arguments to `arg`. .. versionadded:: 3.0.0 Returns ------- Series Same index as caller. See Also -------- Series.apply : For applying more complex functions on a Series. Series.replace: Replace values given in `to_replace` with `value`. DataFrame.apply : Apply a function row-/column-wise. DataFrame.map : 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: str ``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: str 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: str 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: str For categorical data, the function is only applied to the categories: >>> s = pd.Series(list("cabaa")) >>> s.map(print) c a b a a 0 None 1 None 2 None 3 None 4 None dtype: object >>> s_cat = s.astype("category") >>> s_cat.map(print) # function called once per unique category a b c 0 None 1 None 2 None 3 None 4 None dtype: object NargzoThe parameter `arg` has been renamed to `func`, and it will stop being supported in a future version of pandas.rz The `func` parameter is requiredzAThe engine argument can only be specified when func is a function__pandas_udf__zNot a valid engine: rqry)rrtr r decoratorskip_nar'maprs)rFr:)poprrrr#rr9rrrrrrrr# functoolspartial _map_valuesr)rrtrrrr4rNs rrz Series.mapsL <zz%(( O"/11 !!CDDD  D>>  W6#344 D !B!B!BCCC*.. !X- /Fff-- JdjtyIII&&tE&:: : D>> 5$T44V44D%%di%@@   4:E JJWW X   rrc|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. rq)rr2r(subsets r_gotitemzSeries._gotitemHs  rz 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 c|||!t|}t||||}|}|S)a Aggregate using one or more operations over the specified axis. Parameters ---------- func : function, str, list or dict Function to use for aggregating the data. If a function, must either work when passed a Series or when passed to Series.apply. Accepted combinations are: - function - string function name - list of functions and/or function names, e.g. ``[np.sum, 'mean']`` - dict of axis labels -> functions, function names or list of such. axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. *args Positional arguments to pass to `func`. **kwargs Keyword arguments to pass to `func`. Returns ------- scalar, Series or DataFrame The return can be: * scalar : when Series.agg is called with single function * Series : when DataFrame.agg is called with a single function * DataFrame : when DataFrame.agg is called with several functions See Also -------- Series.apply : Invoke function on a Series. Series.transform : Transform function producing a Series with like indexes. Notes ----- The aggregation operations are always performed over an axis, either the index (default) or the column axis. This behavior is different from `numpy` aggregation functions (`mean`, `median`, `prod`, `sum`, `std`, `var`), where the default is to compute the aggregation of the flattened array, e.g., ``numpy.mean(arr_2d)`` as opposed to ``numpy.mean(arr_2d, axis=0)``. `agg` is an alias for `aggregate`. Use the alias. Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See :ref:`gotchas.udf-mutation` for more details. A passed user-defined-function will be passed a Series for evaluation. If ``func`` defines an index relabeling, ``axis`` must be ``0`` or ``index``. 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 N)r r)rrrrFagg)rrtrr ropr4s r aggregatezSeries.aggregateus]X d### < ''D t$v > > > rrfc|||d}t||||}|S)a! Call ``func`` on self producing a Series with the same axis shape as self. Parameters ---------- func : function, str, list-like or dict-like Function to use for transforming the data. If a function, must either work when passed a Series or when passed to Series.apply. If func is both list-like and dict-like, dict-like behavior takes precedence. Accepted combinations are: - function - string function name - list-like of functions and/or function names, e.g. ``[np.exp, 'sqrt']`` - dict-like of axis labels -> functions, function names or list-like of such axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. *args Positional arguments to pass to `func`. **kwargs Keyword arguments to pass to `func`. Returns ------- Series A Series that must have the same length as self. Raises ------ ValueError : If the returned Series has a different length than self. See Also -------- Series.agg : Only perform aggregating type operations. Series.apply : Invoke function on a Series. Notes ----- Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See :ref:`gotchas.udf-mutation` for more details. Examples -------- >>> df = pd.DataFrame({"A": range(3), "B": range(1, 4)}) >>> df A B 0 0 1 1 1 2 2 2 3 >>> df.transform(lambda x: x + 1) A B 0 1 2 1 2 3 2 3 4 Even though the resulting Series must have the same length as the input Series, it is possible to provide several input functions: >>> s = pd.Series(range(3)) >>> s 0 0 1 1 2 2 dtype: int64 >>> s.transform([np.sqrt, np.exp]) sqrt exp 0 0.000000 1.000000 1 1.000000 2.718282 2 1.414214 7.389056 You can call transform on a GroupBy object: >>> df = pd.DataFrame( ... { ... "Date": [ ... "2015-05-08", ... "2015-05-07", ... "2015-05-06", ... "2015-05-05", ... "2015-05-08", ... "2015-05-07", ... "2015-05-06", ... "2015-05-05", ... ], ... "Data": [5, 8, 6, 1, 50, 100, 60, 120], ... } ... ) >>> df Date Data 0 2015-05-08 5 1 2015-05-07 8 2 2015-05-06 6 3 2015-05-05 1 4 2015-05-08 50 5 2015-05-07 100 6 2015-05-06 60 7 2015-05-05 120 >>> df.groupby("Date")["Data"].transform("sum") 0 55 1 108 2 66 3 121 4 55 5 108 6 66 7 121 Name: Data, dtype: int64 >>> df = pd.DataFrame( ... { ... "c": [1, 1, 1, 2, 2, 2, 2], ... "type": ["m", "n", "o", "m", "m", "n", "n"], ... } ... ) >>> df c type 0 1 m 1 1 n 2 1 o 3 2 m 4 2 m 5 2 n 6 2 n >>> df["size"] = df.groupby("c")["type"].transform(len) >>> df c type size 0 1 m 3 1 1 n 3 2 1 o 3 3 2 m 4 4 2 m 4 5 2 n 4 6 2 n 4 Fr)rtr r)rrrF transform)rrtrr rrr4s rrzSeries.transformsS\ d###iiUi##St$vFFFPPRR rrqr)by_rowr tuple[Any, ...]rLiteral[False, 'compat']c Nt|||||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. args : tuple Positional arguments passed to func after the series value. by_row : False or "compat", default "compat" If ``"compat"`` and func is a callable, func will be passed each element of the Series, like ``Series.map``. If func is a list or dict of callables, will first try to translate each func into pandas methods. If that doesn't work, will try call to apply again with ``by_row="compat"`` and if that fails, will call apply again with ``by_row=False`` (backward compatible). If False, the func will be passed the whole Series at once. ``by_row`` has no effect when ``func`` is a string. .. versionadded:: 2.1.0 **kwargs Additional keyword arguments passed to func. Returns ------- Series or DataFrame If func returns a Series object the result will be a DataFrame. See Also -------- Series.map: For element-wise operations. Series.agg: Only perform aggregating type operations. Series.transform: Only perform transforming type operations. Notes ----- Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See :ref:`gotchas.udf-mutation` for more details. Examples -------- Create a series with typical summer temperatures for each city. >>> s = pd.Series([20, 21, 12], index=["London", "New York", "Helsinki"]) >>> s London 20 New York 21 Helsinki 12 dtype: int64 Square the values by defining a function and passing it as an argument to ``apply()``. >>> def square(x): ... return x**2 >>> s.apply(square) London 400 New York 441 Helsinki 144 dtype: int64 Square the values by passing an anonymous function as an argument to ``apply()``. >>> s.apply(lambda x: x**2) London 400 New York 441 Helsinki 144 dtype: int64 Define a custom function that needs additional positional arguments and pass these additional arguments using the ``args`` keyword. >>> def subtract_custom_value(x, custom_value): ... return x - custom_value >>> s.apply(subtract_custom_value, args=(5,)) London 15 New York 16 Helsinki 7 dtype: int64 Define a custom function that takes keyword arguments and pass these arguments to ``apply``. >>> def add_custom_values(x, **kwargs): ... for month in kwargs: ... x += kwargs[month] ... return x >>> s.apply(add_custom_values, june=30, july=20, august=25) London 95 New York 96 Helsinki 87 dtype: int64 Use a function from the Numpy library. >>> s.apply(np.log) London 2.995732 New York 3.044522 Helsinki 2.484907 dtype: float64 )rr r)rFapply)rrtr rrs rrz Series.apply`s6l      %''  rr?npt.NDArray[np.intp] | Nonec|-||j|jjkr|dStj|j|dd}|||dS)NFrT) allow_fillrvr:)namesrrr?take_ndr r)rr?r>rNs r_reindex_indexerzSeries._reindex_indexerss ?  DJ4D!D!D99%9(( (' L'dt     95 IIIrcdS)zc Check if we do need a multi reindex; this is for compat with higher dims. Frq)rrrtrys r_needs_reindex_multizSeries._needs_reindex_multis ur)rrryerrorsRenamer | Hashable | None Axis | None Level | NonerrtcdSrrqrrrrrryrs rrenamez Series.renames r)rrrryrcdSrrqrs rrz Series.renames rryc|||||}t|st|r%t ||||S|||S)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 ` for more. Parameters ---------- index : scalar, hashable sequence, dict-like or function optional Functions or dict-like are transformations to apply to the index. Scalar or hashable sequence-like will alter the ``Series.name`` attribute. axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. inplace : bool, default False Whether to return a new Series. If True the value of copy is ignored. level : int or level name, default None In case of MultiIndex, only rename labels in the specified level. errors : {'ignore', 'raise'}, default 'ignore' If 'raise', raise `KeyError` when a `dict-like mapper` or `index` contains labels that are not present in the index being transformed. If 'ignore', existing keys will be renamed and extra keys will be ignored. Returns ------- Series A shallow copy with index labels or name altered, or the same object if ``inplace=True`` and index is not a dict or callable else None. See Also -------- DataFrame.rename : Corresponding DataFrame method. Series.rename_axis : Set the name of the axis. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s 0 1 1 2 2 3 dtype: int64 >>> s.rename("my_name") # scalar, changes Series.name 0 1 1 2 2 3 Name: my_name, dtype: int64 >>> s.rename(lambda x: x**2) # function, changes labels 0 1 1 2 4 3 dtype: int64 >>> s.rename({1: 3, 2: 5}) # mapping, changes labels 0 1 3 2 5 3 dtype: int64 N)rryrrS)rrr9r.r_renamer)rrrrrryrrs rrz Series.renamesn $$T***  ((..D E?? :l511 : 77?? # >>%>99 9rrrcLt|||S)a Assign desired index to given axis. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. Indexes for row labels can be changed by assigning a list-like or Index. Parameters ---------- labels : list-like or Index The values for the new index. axis : {0 or 'index'}, default 0 The axis to update. The value 0 identifies the rows. For `Series` this parameter is unused and defaults to 0. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. Returns ------- Series A shallow copy of the object with axis altered to the given index. See Also -------- Series.rename_axis : Alter the name of the index. 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 r)rset_axis)rlabelsrrrs rrzSeries.set_axisxs%nwwT===r)rrtrryrvlimit toleranceReindexMethod | None Scalar | Nonerc Tt|||||||S)a " Conform Series to new index with optional filling logic. Places NA/NaN in locations having no value in the previous index. A new object is produced unless the new index is equivalent to the current one and ``copy=False``. Parameters ---------- index : scalar, list-like, dict-like or function, optional A scalar, list-like, dict-like or functions transformations to apply to that axis' values. axis : {0 or 'index'}, default 0 The axis to rename. For `Series` this parameter is unused and defaults to 0. method : {{None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}} Method to use for filling holes in reindexed DataFrame. Please note: this is only applicable to DataFrames/Series with a monotonically increasing/decreasing index. * None (default): don't fill gaps * pad / ffill: Propagate last valid observation forward to next valid. * backfill / bfill: Use next valid observation to fill gap. * nearest: Use nearest valid observations to fill gap. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. level : int or name Broadcast across a level, matching Index values on the passed MultiIndex level. fill_value : scalar, default np.nan Value to use for missing values. Defaults to NaN, but can be any "compatible" value. limit : int, default None Maximum number of consecutive elements to forward or backward fill. tolerance : optional Maximum distance between original and new labels for inexact matches. The values of the index at the matching locations most satisfy the equation ``abs(index[indexer] - target) <= tolerance``. Tolerance may be a scalar value, which applies the same tolerance to all values, or list-like, which applies variable tolerance per element. List-like includes list, tuple, array, Series, and must be the same size as the index and its dtype must exactly match the index's type. Returns ------- Series Series with changed index. See Also -------- DataFrame.set_index : Set row labels. DataFrame.reset_index : Remove row labels or move them to new columns. DataFrame.reindex_like : Change to same indices as other DataFrame. Examples -------- ``DataFrame.reindex`` supports two calling conventions * ``(index=index_labels, columns=column_labels, ...)`` * ``(labels, axis={{'index', 'columns'}}, ...)`` We *highly* recommend using keyword arguments to clarify your intent. Create a DataFrame with some fictional data. >>> index = ["Firefox", "Chrome", "Safari", "IE10", "Konqueror"] >>> columns = ["http_status", "response_time"] >>> df = pd.DataFrame( ... [[200, 0.04], [200, 0.02], [404, 0.07], [404, 0.08], [301, 1.0]], ... columns=columns, ... index=index, ... ) >>> df http_status response_time Firefox 200 0.04 Chrome 200 0.02 Safari 404 0.07 IE10 404 0.08 Konqueror 301 1.00 Create a new index and reindex the DataFrame. By default values in the new index that do not have corresponding records in the DataFrame are assigned ``NaN``. >>> new_index = ["Safari", "Iceweasel", "Comodo Dragon", "IE10", "Chrome"] >>> df.reindex(new_index) http_status response_time Safari 404.0 0.07 Iceweasel NaN NaN Comodo Dragon NaN NaN IE10 404.0 0.08 Chrome 200.0 0.02 We can fill in the missing values by passing a value to the keyword ``fill_value``. Because the index is not monotonically increasing or decreasing, we cannot use arguments to the keyword ``method`` to fill the ``NaN`` values. >>> df.reindex(new_index, fill_value=0) http_status response_time Safari 404 0.07 Iceweasel 0 0.00 Comodo Dragon 0 0.00 IE10 404 0.08 Chrome 200 0.02 >>> df.reindex(new_index, fill_value="missing") http_status response_time Safari 404 0.07 Iceweasel missing missing Comodo Dragon missing missing IE10 404 0.08 Chrome 200 0.02 We can also reindex the columns. >>> df.reindex(columns=["http_status", "user_agent"]) http_status user_agent Firefox 200 NaN Chrome 200 NaN Safari 404 NaN IE10 404 NaN Konqueror 301 NaN Or we can use "axis-style" keyword arguments >>> df.reindex(["http_status", "user_agent"], axis="columns") http_status user_agent Firefox 200 NaN Chrome 200 NaN Safari 404 NaN IE10 404 NaN Konqueror 301 NaN To further illustrate the filling functionality in ``reindex``, we will create a DataFrame with a monotonically increasing index (for example, a sequence of dates). >>> date_index = pd.date_range("1/1/2010", periods=6, freq="D") >>> df2 = pd.DataFrame( ... {"prices": [100, 101, np.nan, 100, 89, 88]}, index=date_index ... ) >>> df2 prices 2010-01-01 100.0 2010-01-02 101.0 2010-01-03 NaN 2010-01-04 100.0 2010-01-05 89.0 2010-01-06 88.0 Suppose we decide to expand the DataFrame to cover a wider date range. >>> date_index2 = pd.date_range("12/29/2009", periods=10, freq="D") >>> df2.reindex(date_index2) prices 2009-12-29 NaN 2009-12-30 NaN 2009-12-31 NaN 2010-01-01 100.0 2010-01-02 101.0 2010-01-03 NaN 2010-01-04 100.0 2010-01-05 89.0 2010-01-06 88.0 2010-01-07 NaN The index entries that did not have a value in the original data frame (for example, '2009-12-29') are by default filled with ``NaN``. If desired, we can fill in the missing values using one of several options. For example, to back-propagate the last valid value to fill the ``NaN`` values, pass ``bfill`` as an argument to the ``method`` keyword. >>> df2.reindex(date_index2, method="bfill") prices 2009-12-29 100.0 2009-12-30 100.0 2009-12-31 100.0 2010-01-01 100.0 2010-01-02 101.0 2010-01-03 NaN 2010-01-04 100.0 2010-01-05 89.0 2010-01-06 88.0 2010-01-07 NaN Please note that the ``NaN`` value present in the original DataFrame (at index value 2010-01-03) will not be filled by any of the value propagation schemes. This is because filling while reindexing does not look at DataFrame values, but only compares the original and desired indexes. If you do want to fill in the ``NaN`` values present in the original DataFrame, use the ``fillna()`` method. See the :ref:`user guide ` for more. )rrtryrvrrr)rr) rrrrtrryrvrrrs rrzSeries.reindexs:Dww!   r)rrrmapperIndexLabel | lib.NoDefaultcdSrrqrrrrrrs r rename_axiszSeries.rename_axisrr)rrrrcdSrrqrs rr zSeries.rename_axisrr Self | NonecdSrrqrs rr zSeries.rename_axiss crcPt|||||S)a Set the name of the axis for the index. Parameters ---------- mapper : scalar, list-like, optional Value to set the axis name attribute. Use either ``mapper`` and ``axis`` to specify the axis to target with ``mapper``, or ``index``. index : scalar, list-like, dict-like or function, optional A scalar, list-like, dict-like or functions transformations to apply to that axis' values. axis : {0 or 'index'}, default 0 The axis to rename. For `Series` this parameter is unused and defaults to 0. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. inplace : bool, default False Modifies the object directly, instead of creating a new Series or DataFrame. Returns ------- Series, or None The same type as the caller or None if ``inplace=True``. See Also -------- Series.rename : Alter Series index labels or name. DataFrame.rename : Alter DataFrame index labels or name. Index.rename : Set new names on index. Examples -------- >>> s = pd.Series(["dog", "cat", "monkey"]) >>> s 0 dog 1 cat 2 monkey dtype: str >>> s.rename_axis("animal") animal 0 dog 1 cat 2 monkey dtype: str )rrrrr)rr )rrrrrrrs rr zSeries.rename_axiss6Jww"" #   r)rrrryrrIndexLabel | ListLikercdSrrqrrrrrryrrs rrwz Series.drop rr)rrrryrrcdSrrqrs rrwz Series.droprrcdSrrqrs rrwz Series.drop'rrraisec Tt|||||||S)a& Return Series with specified index labels removed. Remove elements of a Series based on specifying the index labels. When using a multi-index, labels on different levels can be removed by specifying the level. Parameters ---------- labels : single label or list-like Index labels to drop. axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. index : single label or list-like Redundant for application on Series, but 'index' can be used instead of 'labels'. columns : single label or list-like No change is made to the Series; use 'index' or 'labels' instead. level : int or level name, optional For MultiIndex, level for which the labels will be removed. inplace : bool, default False If True, do operation inplace and return None. errors : {'ignore', 'raise'}, default 'raise' If 'ignore', suppress error and only existing labels are dropped. Returns ------- Series or None Series with specified index labels removed or None if ``inplace=True``. Raises ------ KeyError If none of the labels are found in the index. See Also -------- Series.reindex : Return only specified index labels of Series. Series.dropna : Return series without null values. Series.drop_duplicates : Return Series with duplicate values removed. DataFrame.drop : Drop specified labels from rows or columns. Examples -------- >>> s = pd.Series(data=np.arange(3), index=["A", "B", "C"]) >>> s A 0 B 1 C 2 dtype: int64 Drop labels B and C >>> s.drop(labels=["B", "C"]) A 0 dtype: int64 Drop 2nd level label in MultiIndex Series >>> midx = pd.MultiIndex( ... levels=[["llama", "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 llama 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) llama speed 45.0 length 1.2 cow speed 30.0 length 1.5 falcon speed 320.0 length 0.3 dtype: float64 )rrrrryrr)rrw) rrrrrryrrrs rrwz Series.drop4s:@ww||   ritemcbtt|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 ------- scalar Value that is popped from series. See Also -------- Series.drop: Drop specified values from Series. Series.drop_duplicates: Return Series with duplicate values removed. Examples -------- >>> ser = pd.Series([1, 2, 3]) >>> ser.pop(0) 1 >>> ser 1 2 2 3 dtype: int64 )r)r-rr)rrrs rrz Series.pops%>(  (>(>???rverbosemax_cols memory_usagebool | str | None show_countscPt||||||S)a} Print a concise summary of a Series. This method prints information about a Series including the index dtype, non-NA values and memory usage. Parameters ---------- verbose : bool, optional Whether to print the full summary. By default, the setting in ``pandas.options.display.max_info_columns`` is followed. buf : writable buffer, defaults to sys.stdout Where to send the output. By default, the output is printed to sys.stdout. Pass a writable buffer if you need to further process the output. max_cols : int, optional Unused, exists only for compatibility with DataFrame.info. memory_usage : bool, str, optional Specifies whether total memory usage of the Series elements (including the index) should be displayed. By default, this follows the ``pandas.options.display.memory_usage`` setting. True always show memory usage. False never shows memory usage. A value of 'deep' is equivalent to "True with deep introspection". Memory usage is shown in human-readable units (base-2 representation). Without deep introspection a memory estimation is made based in column dtype and number of rows assuming values consume the same memory amount for corresponding dtypes. With deep memory introspection, a real memory usage calculation is performed at the cost of computational resources. See the :ref:`Frequently Asked Questions ` for more details. show_counts : bool, optional Whether to show the non-null counts. By default, this is shown only if the DataFrame is smaller than ``pandas.options.display.max_info_rows`` and ``pandas.options.display.max_info_columns``. A value of True always shows the counts, and False never shows the counts. Returns ------- None This method prints a summary of a Series and returns None. See Also -------- Series.describe: Generate descriptive statistics of Series. Series.memory_usage: Memory usage of Series. Examples -------- >>> int_values = [1, 2, 3, 4, 5] >>> text_values = ["alpha", "beta", "gamma", "delta", "epsilon"] >>> s = pd.Series(text_values, index=int_values) >>> s.info() Index: 5 entries, 1 to 5 Series name: None Non-Null Count Dtype -------------- ----- 5 non-null str dtypes: str(1) memory usage: 106.0 bytes Prints a summary excluding information about its values: >>> s.info(verbose=False) Index: 5 entries, 1 to 5 dtypes: str(1) memory usage: 106.0 bytes Pipe output of Series.info to buffer instead of sys.stdout, get buffer content and writes to a text file: >>> import io >>> buffer = io.StringIO() >>> s.info(buf=buffer) >>> s = buffer.getvalue() >>> with open("df_info.txt", "w", encoding="utf-8") as f: # doctest: +SKIP ... f.write(s) 260 The `memory_usage` parameter allows deep introspection mode, specially useful for big Series and fine-tune memory optimization: >>> random_strings_array = np.random.choice(["a", "b", "c"], 10**6) >>> s = pd.Series(np.random.choice(["a", "b", "c"], 10**6)) >>> s.info() RangeIndex: 1000000 entries, 0 to 999999 Series name: None Non-Null Count Dtype -------------- ----- 1000000 non-null str dtypes: str(1) memory usage: 8.6 MB >>> s.info(memory_usage="deep") RangeIndex: 1000000 entries, 0 to 999999 Series name: None Non-Null Count Dtype -------------- ----- 1000000 non-null str dtypes: str(1) memory usage: 8.6 MB )rrrr)rdrender)rrrrrrs rinfoz Series.infos8h$ --44# 5   rrcr||}|r||j|z }|S)at 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() 156 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 ['a', 'b'] Length: 2, dtype: str >>> s.memory_usage() 150 >>> s.memory_usage(deep=True) 150 r) _memory_usagerr)rrrrs rrzSeries.memory_usage:sEf   D  ) )  4 ((d(33 3Arctj|j|}|||jd|dS)an 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( ... ["llama", "cow", "llama", "beetle", "llama", "hippo"], name="animal" ... ) >>> s.isin(["cow", "llama"]) 0 True 1 True 2 True 3 False 4 True 5 False Name: animal, dtype: bool To invert the boolean values, use the ``~`` operator: >>> ~s.isin(["cow", "llama"]) 0 False 1 False 2 False 3 True 4 False 5 True Name: animal, dtype: bool Passing a single string as ``s.isin('llama')`` will raise an error. Use a list of one element instead: >>> s.isin(["llama"]) 0 True 1 False 2 True 3 False 4 True 5 False Name: animal, dtype: bool Strings and integers are distinct and are therefore not comparable: >>> pd.Series([1]).isin(["1"]) 0 False dtype: bool >>> pd.Series([1.1]).isin(["1.1"]) 0 False dtype: bool Fr:isinrs)r?r"r rrr#)rrr4s rr"z Series.isinrsRTv66  tz FFSS T   rboth inclusive+Literal['both', 'neither', 'left', 'right']c|dkr ||k}||k}nH|dkr ||k}||k}n5|dkr ||k}||k}n"|dkr ||k}||k}ntd||zS)a Return boolean Series equivalent to left <= series <= right. This function returns a boolean vector containing `True` wherever the corresponding Series element is between the boundary values `left` and `right`. NA values are treated as `False`. Parameters ---------- left : scalar or list-like Left boundary. right : scalar or list-like Right boundary. inclusive : {"both", "neither", "left", "right"} Include boundaries. Whether to set each bound as closed or open. Returns ------- Series Series representing whether each element is between left and right (inclusive). See Also -------- Series.gt : Greater than of series and other. Series.lt : Less than of series and other. Notes ----- This function is equivalent to ``(left <= ser) & (ser <= right)`` Examples -------- >>> s = pd.Series([2, 0, 4, 8, np.nan]) Boundary values are included by default: >>> s.between(1, 4) 0 True 1 False 2 True 3 False 4 False dtype: bool With `inclusive` set to ``"neither"`` boundary values are excluded: >>> s.between(1, 4, inclusive="neither") 0 True 1 False 2 False 3 False 4 False dtype: bool `left` and `right` can be any scalar value: >>> s = pd.Series(["Alice", "Bob", "Carol", "Eve"]) >>> s.between("Anna", "Daniel") 0 False 1 True 2 True 3 False dtype: bool r#rQrRneitherzJInclusive has to be either string of 'both','left', 'right', or 'neither'.)r)rrQrRr$lmaskrmasks rbetweenzSeries.betweensN   DLEEMEE & DLE5LEE ' ! !4KEEMEE ) # #4KE5LEE1  u}rcaselistlist[tuple[ArrayLike | Callable[[Series], Series | np.ndarray | Sequence[bool]], ArrayLike | Scalar | Callable[[Series], Series | np.ndarray]],]c t|tstdt||st dt |D]s\}}t|t s#td|dt|dt|dkr#t d|dt|dtfd|D}d }t|d d i\}}d g||D}tt|dkrt|}g} t||d D]\} } t| r t| t| |} n>> c = pd.Series([6, 7, 8, 9], name="c") >>> a = pd.Series([0, 0, 1, 2]) >>> b = pd.Series([0, 3, 4, 5]) >>> c.case_when( ... caselist=[ ... (a.gt(0), a), # condition, replacement ... (b.gt(0), b), ... ] ... ) 0 6 1 3 2 1 3 2 Name: c, dtype: int64 z4The caselist argument should be a list; instead got zIprovide at least one boolean condition, with a corresponding replacement.z Argument z must be a tuple; instead got .rzE must have length 2; a condition and replacement; instead got length cjg|]/\}}tj|tj|f0Srq)rr()r condition replacementrs rrz$Series.case_when..lsQ   ' ;%i66%k488    rFrrTc8g|]}t|dSr)r+)rrs rrz$Series.case_when..us&VVVc)#..q1VVVrrGr)rrrrrerN)r,rrryzFailed to apply conditionz and replacement)rrr,rrrrrrrsetr*r4r)r9rpd_arrayappendrreversedrirP)rr+numentrydefault conditions replacements common_dtypes common_dtypeupdated_replacementsr0r1counterpositionerrors` r case_whenzSeries.case_whensCt(D)) WtH~~WW  4  $H--  JCeU++ QQQ4;;QQQ5zzQ 888*-e**888     +3    )))''#&#>#>#> LVV=U|=UW=UVVV s=!! " "Q & &+M::L#% *-j,t*T*T*T 9 9& ;[))L"D)#i.. ###KK Y77L"-"4"4\"B"BKK"*;l"K"K"KK$++K8888/Lnn\22GJ!+R4403 Xj))8L+A+A$1 1 1   ,Hi !,,[q%t'    UUU(UUU sI J'I>>Jc*tj|S)a Detect missing values. Return a boolean same-sized Series indicating if the values are NA. NA values, such as None or :attr:`numpy.NaN`, get mapped to True values. Everything else gets mapped to False values. Characters such as empty strings ``''`` or :attr:`numpy.inf` are not considered NA values. Returns ------- Series Mask of bool values for each element in Series that indicates whether an element is an NA value. See Also -------- DataFrame.isna : Detect missing values. DataFrame.isnull : Alias of isna. Series.notna : Boolean inverse of isna. DataFrame.notna : Boolean inverse of isna. Series.notnull : Alias of notna. DataFrame.notnull : Alias of notna. Series.dropna : Omit axes labels with missing values. DataFrame.dropna : Omit axes labels with missing values. isna : Top-level isna. Examples -------- Show which entries in a Series are NA. >>> ser = pd.Series([5, 6, np.nan]) >>> ser 0 5.0 1 6.0 2 NaN dtype: float64 >>> ser.isna() 0 False 1 False 2 True dtype: bool )rOr;rs rr;z Series.isnasX|D!!!rr)rcDtS)z< Series.isnull is an alias for Series.isna. )risnullrs rrFz Series.isnulls ww~~rcDtS)a3 Detect existing (non-missing) values. Return a boolean same-sized Series indicating if the values are not NA. Non-missing values get mapped to True. Characters such as empty strings ``''`` or :attr:`numpy.inf` are not considered NA values. NA values, such as None or :attr:`numpy.NaN`, get mapped to False values. Returns ------- Series Mask of bool values for each element in Series that indicates whether an element is not an NA value. See Also -------- Series.isna : Detect missing values. DataFrame.isna : Detect missing values. Series.isnull : Alias of isna. DataFrame.isnull : Alias of isna. DataFrame.notna : Boolean inverse of isna. DataFrame.notnull : Alias of notna. Series.dropna : Omit axes labels with missing values. DataFrame.dropna : Omit axes labels with missing values. notna : Top-level notna. Examples -------- Show which entries in a Series are not NA. >>> ser = pd.Series([5, 6, np.nan]) >>> ser 0 5.0 1 6.0 2 NaN dtype: float64 >>> ser.notna() 0 True 1 True 2 False dtype: bool )rr=rs rr=z Series.notnasXww}}rcDtS)z> Series.notnull is an alias for Series.notna. )rnotnullrs rrIzSeries.notnulls ww   r)rrhowrrJ AnyAll | NonecdSrrqrrrrJrs rrz Series.dropnas r)rrJrcdSrrqrMs rrz Series.dropna s srcLt|d}t|d}||pd|jrt|}n|s|d}n|}|r!t t ||_|r||S|S)u, Return a new Series with missing values removed. See the :ref:`User Guide ` for more on which values are considered missing, and how to work with missing data. Parameters ---------- axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. inplace : bool, default False If True, do operation inplace and return None. how : str, optional Not in use. Kept for compatibility. ignore_index : bool, default ``False`` If ``True``, the resulting axis will be labeled 0, 1, …, n - 1. .. versionadded:: 2.0.0 Returns ------- Series or None Series with NA entries dropped from it or None if ``inplace=True``. See Also -------- Series.isna: Indicate missing values. Series.notna : Indicate existing (non-missing) values. Series.fillna : Replace missing values. DataFrame.dropna : Drop rows or columns which contain NA values. Index.dropna : Drop missing indices. Examples -------- >>> ser = pd.Series([1.0, 2.0, np.nan]) >>> ser 0 1.0 1 2.0 2 NaN dtype: float64 Drop NA values from a Series. >>> ser.dropna() 0 1.0 1 2.0 dtype: float64 Empty strings are not considered NA values. ``None`` is considered an NA value. >>> ser = pd.Series([np.nan, 2, pd.NaT, "", None, "I stay"]) >>> ser 0 NaN 1 2 2 NaT 3 4 None 5 I stay dtype: object >>> ser.dropna() 1 2 3 5 I stay dtype: object rrrFr) r%rrr>rrWrrr)rrrrJrr4s rrz Series.dropnasT&gy99*<HH  dia(((   (..FF YYEY**FFF  6(V55FL  ''// /MrstartfreqFrequency | None!Literal['s', 'e', 'start', 'end']c<||t|jts)t dt |jj|d}|j||}t|d||S)a. Cast to DatetimeIndex of Timestamps, at *beginning* of period. This can be changed to the *end* of the period, by specifying `how="e"`. 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 False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. Returns ------- Series with DatetimeIndex Series with the PeriodIndex cast to DatetimeIndex. See Also -------- Series.to_period: Inverse method to cast DatetimeIndex to PeriodIndex. DataFrame.to_timestamp: Equivalent method for DataFrame. Examples -------- >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y") >>> s1 = pd.Series([1, 2, 3], index=idx) >>> s1 2023 1 2024 2 2025 3 Freq: Y-DEC, dtype: int64 The resulting frequency of the Timestamps is `YearBegin` >>> s1 = s1.to_timestamp() >>> s1 2023-01-01 1 2024-01-01 2 2025-01-01 3 Freq: YS-JAN, dtype: int64 Using `freq` which is the offset that the Timestamps will have >>> s2 = pd.Series([1, 2, 3], index=idx) >>> s2 = s2.to_timestamp(freq="M") >>> s2 2023-01-31 1 2024-01-31 2 2025-01-31 3 Freq: YE-JAN, dtype: int64 unsupported Type Fr)rQrJr) rrrrVr,rrr to_timestampsetattr)rrQrJrnew_objr?s rrVzSeries.to_timestampwsL $$T***$*k22 MKTZ0@0@0IKKLL L)))''J++3+?? ),,,rc:||t|jts)t dt |jj|d}|j|}t|d||S)a Convert Series from DatetimeIndex to PeriodIndex. Parameters ---------- freq : str, default None Frequency associated with the PeriodIndex. copy : bool, default False This keyword is now ignored; changing its value will have no impact on the method. .. deprecated:: 3.0.0 This keyword is ignored and will be removed in pandas 4.0. Since pandas 3.0, this method always returns a new object using a lazy copy mechanism that defers copies until necessary (Copy-on-Write). See the `user guide on Copy-on-Write `__ for more details. Returns ------- Series Series with index converted to PeriodIndex. See Also -------- DataFrame.to_period: Equivalent method for DataFrame. Series.dt.to_period: Convert DateTime column values. Examples -------- >>> idx = pd.DatetimeIndex(["2023", "2024", "2025"]) >>> s = pd.Series([1, 2, 3], index=idx) >>> s = s.to_period() >>> s 2023 1 2024 2 2025 3 Freq: Y-DEC, dtype: int64 Viewing the index >>> s.index PeriodIndex(['2023', '2024', '2025'], dtype='period[Y-DEC]') rUFr)rQr) rrrrSr,rrr to_periodrW)rrQrrXr?s rrZzSeries.to_periodsf $$T***$*m44 MKTZ0@0@0IKKLL L)))''J((d(33 ),,,rz!list[Literal['index', 'columns']] _AXIS_ORDERSz Literal[0]_info_axis_numberzLiteral['index']_info_axis_nameaG The index (axis labels) of the Series. The index of a Series is used to label and identify each element of the underlying data. The index can be thought of as an immutable ordered set (technically a multi-set, as it may contain duplicate labels), and is used to index and align data in pandas. Returns ------- Index The index labels of the Series. See Also -------- Series.reindex : Conform Series to new index. Index : The base pandas index type. Notes ----- For more information on pandas indexing, see the `indexing user guide `__. Examples -------- To create a Series with a custom index and view the index labels: >>> cities = ['Kolkata', 'Chicago', 'Toronto', 'Lisbon'] >>> populations = [14.85, 2.71, 2.93, 0.51] >>> city_series = pd.Series(populations, index=cities) >>> city_series.index Index(['Kolkata', 'Chicago', 'Toronto', 'Lisbon'], dtype='object') To change the index labels of an existing Series: >>> city_series.index = ['KOL', 'CHI', 'TOR', 'LIS'] >>> city_series.index Index(['KOL', 'CHI', 'TOR', 'LIS'], dtype='object') )rr!rrplotrstructrc,tj||}t|tr$||st d|j}t|dd}tj|||}| |||S)Nz3Can only compare identically-labeled Series objectsT extract_numpy extract_rangerr,) rCr~rr _indexed_samerr rM comparison_op_construct_resultrr,rres_namelvaluesrvaluesrs r _cmp_methodzSeries._cmp_methodFs)$66 eV $ $ TT-?-?-F-F TRSS S,TNNN&w<< %%jxu%MMMrctj||}||d\}}|j}t |dd}tj|||}||||S)NT)align_asobjectrard)rCr~ _align_for_opr rM logical_oprgrhs r_logical_methodzSeries._logical_methodSsy)$66((t(DD e,TNNN^GWb99 %%jxu%MMMrct||\}}tj|||Sr)ror@rd _arith_method)rr,rs rrszSeries._arith_method]s4((// e!//eR@@@rrnc||}t|tr|j|js|ri|jt t jfvs|jt t jfvrn4|t }|t }| |\}}||fS)zalign lhs and rhs Series) rrrrrrrbool_rr6)rrRrnrQs rrozSeries._align_for_opas  eV $ $ 0:$$U[11 0! 5z&"();;;u{S@@ ${{622 % V 4 4"jj// eU{rc|}|j|js|||d\}}tj|j|j|\}}t jd5|||}dddn #1swxYwYtj||} | || |} tt| 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 outer)ryr1ryrzN) rrr6rC fill_binopr rrr~rgrr) rr,rtryrvr; this_vals other_valsr4rr$s r_binopz Series._binop{s&z  -- G**U%g*FFKD% #t|U]J W W : [X & & & 1 1T)Z00F 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1%dE22$$VT599FC   s5 BBBr4'ArrayLike | tuple[ArrayLike, ArrayLike]Series | tuple[Series, Series]ct|trn||d||}||d||}t|tsJt|tsJ||fSt |dd}|||j|d}||}||}||_|S)ah Construct an appropriately-labelled Series from the result of an op. Parameters ---------- result : ndarray or ExtensionArray name : Label other : Series, DataFrame or array-like Returns ------- Series In the case of __divmod__ or __rdivmod__, a 2-tuple of Series. rrdrGrNF)rrr) rrrgrgetattrrrr#r)rr4rr,res1res2rr$s rrgzSeries._construct_results( fe $ $ ))&)$e)LLD))&)$e)LLDdF++ + ++dF++ + ++$< ..djERRt$$u%% rryrvrc|||tj||}t|tr|||||St|t jtttfrnt|t|krtd| ||jd}|||||}||_|St|t rFt#d|jdd|jdd|0t)|r |||S||}|||S) N)ryrvzLengths must be equalF)rSeries.rz. does not support a DataFrame `other`. Use df.z(ser) instead.)rrCr~rrr{rrrrrGrrrrrr8r,rstripr;fillna)rr,rryrvrrir4s r _flex_methodzSeries._flex_methods    ! !$ ' ' ')$66 eV $ $ #;;ub*;MM M  D%H I I #5zzSYY&& !8999%%eTZe%DDE[[%J[OOF#FLM | , , #J"+++C00JJ#%;#4#4S#9#9JJJ  %;;02dJ///{{:..2dE?? "r float | NonecJ||tj|||S)a Return Equal to of series and other, element-wise (binary operator `eq`). Equivalent to ``series == other``, but with support to substitute a fill_value for missing data in either one of the inputs. Parameters ---------- other : object When a Series is provided, will align on indexes. For all other types, will behave the same as ``==`` but with possibly different results due to the other arguments. level : int or name Broadcast across a level, matching Index values on the passed MultiIndex level. fill_value : None or float value, default None (NaN) Fill existing missing (NaN) values, and any new element needed for successful Series alignment, with this value before computation. If data in both corresponding Series locations is missing the result of filling (at that location) will be missing. axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. Returns ------- Series The result of the operation. See Also -------- Series.ge : Return elementwise Greater than or equal to of series and other. Series.le : Return elementwise Less than or equal to of series and other. Series.gt : Return elementwise Greater than of series and other. Series.lt : Return elementwise Less than of series and other. Examples -------- >>> a = pd.Series([1, 1, 1, np.nan], index=["a", "b", "c", "d"]) >>> a a 1.0 b 1.0 c 1.0 d NaN dtype: float64 >>> b = pd.Series([1, np.nan, 1, np.nan], index=["a", "b", "d", "e"]) >>> b a 1.0 b NaN d 1.0 e NaN dtype: float64 >>> a.eq(b, fill_value=0) a True b False c False d False e False dtype: bool r)roperatoreqrr,ryrvrs rrz Series.eqs/D  8;e !   rnecJ||tj|||SNr)rrrrs rrz Series.ne+,  8;e !   rcJ||tj|||S)aZ Return Less than or equal to of series and other, element-wise (binary operator `le`). Equivalent to ``series <= other``, but with support to substitute a fill_value for missing data in either one of the inputs. Parameters ---------- other : object When a Series is provided, will align on indexes. For all other types, will behave the same as ``==`` but with possibly different results due to the other arguments. level : int or name Broadcast across a level, matching Index values on the passed MultiIndex level. fill_value : None or float value, default None (NaN) Fill existing missing (NaN) values, and any new element needed for successful Series alignment, with this value before computation. If data in both corresponding Series locations is missing the result of filling (at that location) will be missing. axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. Returns ------- Series The result of the operation. See Also -------- Series.ge : Return elementwise Greater than or equal to of series and other. Series.lt : Return elementwise Less than of series and other. Series.gt : Return elementwise Greater than of series and other. Series.eq : Return elementwise equal to of series and other. Examples -------- >>> a = pd.Series([1, 1, 1, np.nan, 1], index=['a', 'b', 'c', 'd', 'e']) >>> a a 1.0 b 1.0 c 1.0 d NaN e 1.0 dtype: float64 >>> b = pd.Series([0, 1, 2, np.nan, 1], index=['a', 'b', 'c', 'd', 'f']) >>> b a 0.0 b 1.0 c 2.0 d NaN f 1.0 dtype: float64 >>> a.le(b, fill_value=0) a False b True c True d False e False f True dtype: bool r)rrlers rrz Series.le1s/@  8;e !   rltcJ||tj|||Sr)rrrrs rrz Series.lturrcJ||tj|||S)a] Return Greater than or equal to of series and other, element-wise (binary operator `ge`). Equivalent to ``series >= other``, but with support to substitute a fill_value for missing data in either one of the inputs. Parameters ---------- other : object When a Series is provided, will align on indexes. For all other types, will behave the same as ``==`` but with possibly different results due to the other arguments. level : int or name Broadcast across a level, matching Index values on the passed MultiIndex level. fill_value : None or float value, default None (NaN) Fill existing missing (NaN) values, and any new element needed for successful Series alignment, with this value before computation. If data in both corresponding Series locations is missing the result of filling (at that location) will be missing. axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. Returns ------- Series The result of the operation. See Also -------- Series.gt : Greater than comparison, element-wise. Series.le : Less than or equal to comparison, element-wise. Series.lt : Less than comparison, element-wise. Series.eq : Equal to comparison, element-wise. Series.ne : Not equal to comparison, element-wise. Examples -------- >>> a = pd.Series([1, 1, 1, np.nan, 1], index=["a", "b", "c", "d", "e"]) >>> a a 1.0 b 1.0 c 1.0 d NaN e 1.0 dtype: float64 >>> b = pd.Series([0, 1, 2, np.nan, 1], index=["a", "b", "c", "d", "f"]) >>> b a 0.0 b 1.0 c 2.0 d NaN f 1.0 dtype: float64 >>> a.ge(b, fill_value=0) a True b True c False d False e True f False dtype: bool r)rrgers rrz Series.ge{s/B  8;e !   rgtcJ||tj|||Sr)rrrrs rrz Series.gtrrcJ||tj|||S)a# Return Addition of series and other, element-wise (binary operator `add`). Equivalent to ``series + other``, but with support to substitute a fill_value for missing data in either one of the inputs. Parameters ---------- other : Series or scalar value With which to compute the addition. level : int or name Broadcast across a level, matching Index values on the passed MultiIndex level. fill_value : None or float value, default None (NaN) Fill existing missing (NaN) values, and any new element needed for successful Series alignment, with this value before computation. If data in both corresponding Series locations is missing the result of filling (at that location) will be missing. axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. Returns ------- Series The result of the operation. See Also -------- Series.radd : Reverse of the Addition operator, see `Python documentation `_ for more details. Examples -------- >>> a = pd.Series([1, 1, 1, np.nan], index=["a", "b", "c", "d"]) >>> a a 1.0 b 1.0 c 1.0 d NaN dtype: float64 >>> b = pd.Series([1, np.nan, 1, np.nan], index=["a", "b", "d", "e"]) >>> b a 1.0 b NaN d 1.0 e NaN dtype: float64 >>> a.add(b, fill_value=0) a 2.0 b 1.0 c 1.0 d 1.0 e NaN dtype: float64 r)rraddrs rrz Series.add/t  8:D!   rsubcJ||tj|||Sr)rrrrs rrz Series.sub ,  8`_ for more details. Examples -------- >>> a = pd.Series([1, 1, 1, np.nan], index=["a", "b", "c", "d"]) >>> a a 1.0 b 1.0 c 1.0 d NaN dtype: float64 >>> b = pd.Series([1, np.nan, 1, np.nan], index=["a", "b", "d", "e"]) >>> b a 1.0 b NaN d 1.0 e NaN dtype: float64 >>> a.multiply(b, fill_value=0) a 1.0 b 0.0 c 0.0 d 0.0 e NaN dtype: float64 >>> a.mul(5, fill_value=0) a 5.0 b 5.0 c 5.0 d 0.0 dtype: float64 r)rrmulrs rrz Series.muls/L  8`_ for more details. Examples -------- >>> a = pd.Series([1, 1, 1, np.nan], index=["a", "b", "c", "d"]) >>> a a 1.0 b 1.0 c 1.0 d NaN dtype: float64 >>> b = pd.Series([1, np.nan, 1, np.nan], index=["a", "b", "d", "e"]) >>> b a 1.0 b NaN d 1.0 e NaN dtype: float64 >>> a.divide(b, fill_value=0) a 1.0 b inf c inf d 0.0 e NaN dtype: float64 r)rrtruedivrs rrzSeries.truedivjs0v  8#5Zd!   rrtruedivcJ||tj|||Sr)rrDrrs rrzSeries.rtruedivs.  9%UzPT!   rfloordivcJ||tj|||Sr)rrrrs rrzSeries.floordivs-  8$Ejt!   r rfloordivcJ||tj|||Sr)rrDrrs rrzSeries.rfloordivs.  9&e QU!   rcJ||tj|||S)a  Return Modulo of series and other, element-wise (binary operator `mod`). Equivalent to ``series % other``, but with support to substitute a fill_value for missing data in either one of the inputs. Parameters ---------- other : Series or scalar value Series with which to compute modulo. level : int or name Broadcast across a level, matching Index values on the passed MultiIndex level. fill_value : None or float value, default None (NaN) Fill existing missing (NaN) values, and any new element needed for successful Series alignment, with this value before computation. If data in both corresponding Series locations is missing the result of filling (at that location) will be missing. axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. Returns ------- Series The result of the operation. See Also -------- Series.rmod : Reverse of the Modulo operator, see `Python documentation `_ for more details. Examples -------- >>> a = pd.Series([1, 1, 1, np.nan], index=["a", "b", "c", "d"]) >>> a a 1.0 b 1.0 c 1.0 d NaN dtype: float64 >>> b = pd.Series([1, np.nan, 1, np.nan], index=["a", "b", "d", "e"]) >>> b a 1.0 b NaN d 1.0 e NaN dtype: float64 >>> a.mod(b, fill_value=0) a 0.0 b NaN c NaN d 0.0 e NaN dtype: float64 r)rrmodrs rrz Series.modrrrmodcJ||tj|||Sr)rrDrrs rrz Series.rmodrrpowcJ||tj|||Sr)rrrrs rrz Series.powrrrpowcJ||tj|||Sr)rrDrrs rrz Series.rpow rrdivmodc@||t|||Sr)rrrs rrz Series.divmods*  6:D!   rrdivmodcJ||tj|||Sr)rrDrrs rrzSeries.rdivmods-  9$Ejt!   r)rrr& filter_typer&c $|j}|||t|tr|j|fd|i|} n<|r/|jjdvr!d} |dvrd} td|d| d |d ||fd|i|} t| } | S) z Perform a reduction operation. If we have an ndarray as a value, then simply perform the operation, otherwise delegate to the object. Nriufcbr&)rhr{ bool_onlyrz does not allow =z with non-numeric dtypes.) r rrrG_reducerrRr,r-) rrrrrr&rkwdsdelegater4kwd_names rrzSeries._reduces$<    ! !$ ' ' ' h / / 9%X%dBB6BTBBFF  w > >)>))*H/d//H//|///R888488F)&11 r)rrrrc tjd|dt|dd|tjd|||dS) ak Return whether any element is True, potentially over an axis. Returns False unless there is at least one element within a series or along a Dataframe axis that is True or equivalent (e.g. non-zero or non-empty). Parameters ---------- axis : {0 or 'index', 1 or 'columns', None}, default 0 Indicate which axis or axes should be reduced. For `Series` this parameter is unused and defaults to 0. * 0 / 'index' : reduce the index, return a Series whose index is the original column labels. * 1 / 'columns' : reduce the columns, return a Series whose index is the original index. * None : reduce all axes, return a scalar. bool_only : bool, default False Include only boolean columns. Not implemented for Series. skipna : bool, default True Exclude NA/null values. If the entire row/column is NA and skipna is True, then the result will be False, as for an empty row/column. If skipna is False, then NA are treated as True, because these are not equal to zero. **kwargs : any, default None Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- Series or scalar If axis=None, then a scalar boolean is returned. Otherwise a Series is returned with index matching the index argument. See Also -------- numpy.any : Numpy version of this method. Series.any : Return whether any element is True. Series.all : Return whether all elements are True. DataFrame.any : Return whether any element is True over requested axis. DataFrame.all : Return whether all elements are True over requested axis. Examples -------- **Series** For Series input, the output is a scalar indicating whether any element is True. >>> pd.Series([False, False]).any() False >>> pd.Series([True, False]).any() True >>> pd.Series([], dtype="float64").any() False >>> pd.Series([np.nan]).any() False >>> pd.Series([np.nan]).any(skipna=False) True **DataFrame** Whether each column contains at least one True element (the default). >>> df = pd.DataFrame({"A": [1, 2], "B": [0, 2], "C": [0, 0]}) >>> df A B C 0 1 0 0 1 2 2 0 >>> df.any() A True B True C False dtype: bool Aggregating over the columns. >>> df = pd.DataFrame({"A": [True, False], "B": [1, 2]}) >>> df A B 0 True 1 1 False 2 >>> df.any(axis="columns") 0 True 1 True dtype: bool >>> df = pd.DataFrame({"A": [True, False], "B": [1, 0]}) >>> df A B 0 True 1 1 False 0 >>> df.any(axis="columns") 0 True 1 False dtype: bool Aggregating over the entire DataFrame with ``axis=None``. >>> df.any(axis=None) True `any` for an empty DataFrame is an empty Series. >>> pd.DataFrame([]).any() Series([], dtype: bool) rqrhfnamerF none_allowedrrrr&rr)ruvalidate_logical_funcr%rrBnananyrrrrrs rrhz Series.anyLsap  V59999FH5AAAA|| M"    rr{c tjd|dt|dd|tjd|||dS) a Return whether all elements are True, potentially over an axis. Returns True unless there at least one element within a series or along a Dataframe axis that is False or equivalent (e.g. zero or empty). Parameters ---------- axis : {0 or 'index', 1 or 'columns', None}, default 0 Indicate which axis or axes should be reduced. For `Series` this parameter is unused and defaults to 0. * 0 / 'index' : reduce the index, return a Series whose index is the original column labels. * 1 / 'columns' : reduce the columns, return a Series whose index is the original index. * None : reduce all axes, return a scalar. bool_only : bool, default False Include only boolean columns. Not implemented for Series. skipna : bool, default True Exclude NA/null values. If the entire row/column is NA and skipna is True, then the result will be True, as for an empty row/column. If skipna is False, then NA are treated as True, because these are not equal to zero. **kwargs : any, default None Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- Series or scalar If axis=None, then a scalar boolean is returned. Otherwise a Series is returned with index matching the index argument. See Also -------- Series.all : Return True if all elements are True. DataFrame.any : Return True if one (or more) elements are True. Examples -------- **Series** >>> pd.Series([True, True]).all() True >>> pd.Series([True, False]).all() False >>> pd.Series([], dtype="float64").all() True >>> pd.Series([np.nan]).all() True >>> pd.Series([np.nan]).all(skipna=False) True **DataFrames** Create a DataFrame from a dictionary. >>> df = pd.DataFrame({"col1": [True, True], "col2": [True, False]}) >>> df col1 col2 0 True True 1 True False Default behaviour checks if values in each column all return True. >>> df.all() col1 True col2 False dtype: bool Specify ``axis='columns'`` to check if values in each row all return True. >>> df.all(axis="columns") 0 True 1 False dtype: bool Or ``axis=None`` for whether every value is True. >>> df.all(axis=None) False rqr{rrFrrr)rurr%rrBnanallrs rr{z Series.allsaz  V59999FH5AAAA|| M"    rminc .tj|f|||d|S)a Return the minimum of the values over the requested axis. If you want the *index* of the minimum, use ``idxmin``. This is the equivalent of the ``numpy.ndarray`` method ``argmin``. Parameters ---------- axis : {index (0)} Axis for the function to be applied on. For `Series` this parameter is unused and defaults to 0. For DataFrames, specifying ``axis=None`` will apply the aggregation across both axes. .. versionadded:: 2.0.0 skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Additional keyword arguments to be passed to the function. Returns ------- scalar or Series (if level specified) The minimum of the values in the Series. See Also -------- numpy.min : Equivalent numpy function for arrays. Series.min : Return the minimum. Series.max : Return the maximum. Series.idxmin : Return the index of the minimum. Series.idxmax : Return the index of the maximum. DataFrame.min : Return the minimum over the requested axis. DataFrame.max : Return the maximum over the requested axis. DataFrame.idxmin : Return the index of the minimum over the requested axis. DataFrame.idxmax : Return the index of the maximum over the requested axis. Examples -------- >>> idx = pd.MultiIndex.from_arrays( ... [["warm", "warm", "cold", "cold"], ["dog", "falcon", "fish", "spider"]], ... names=["blooded", "animal"], ... ) >>> s = pd.Series([4, 2, 0, 8], name="legs", index=idx) >>> s blooded animal warm dog 4 falcon 2 cold fish 0 spider 8 Name: legs, dtype: int64 >>> s.min() 0 rrr&)rOrrrrr&rs rrz Series.min75F{  F  IO   rmaxc .tj|f|||d|S)a Return the maximum of the values over the requested axis. If you want the *index* of the maximum, use ``idxmax``. This is the equivalent of the ``numpy.ndarray`` method ``argmax``. Parameters ---------- axis : {index (0)} Axis for the function to be applied on. For `Series` this parameter is unused and defaults to 0. For DataFrames, specifying ``axis=None`` will apply the aggregation across both axes. .. versionadded:: 2.0.0 skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Additional keyword arguments to be passed to the function. Returns ------- scalar or Series (if level specified) The maximum of the values in the Series. See Also -------- numpy.max : Equivalent numpy function for arrays. Series.min : Return the minimum. Series.max : Return the maximum. Series.idxmin : Return the index of the minimum. Series.idxmax : Return the index of the maximum. DataFrame.min : Return the minimum over the requested axis. DataFrame.max : Return the maximum over the requested axis. DataFrame.idxmin : Return the index of the minimum over the requested axis. DataFrame.idxmax : Return the index of the maximum over the requested axis. Examples -------- >>> idx = pd.MultiIndex.from_arrays( ... [["warm", "warm", "cold", "cold"], ["dog", "falcon", "fish", "spider"]], ... names=["blooded", "animal"], ... ) >>> s = pd.Series([4, 2, 0, 8], name="legs", index=idx) >>> s blooded animal warm dog 4 falcon 2 cold fish 0 spider 8 Name: legs, dtype: int64 >>> s.max() 8 r)rOrrs rrz Series.max~rrr min_countc 0tj|f||||d|S)a Return the sum of the values over the requested axis. This is equivalent to the method ``numpy.sum``. Parameters ---------- axis : {index (0)} Axis for the function to be applied on. For `Series` this parameter is unused and defaults to 0. .. warning:: The behavior of DataFrame.sum with ``axis=None`` is deprecated, in a future version this will reduce over both axes and return a scalar To retain the old behavior, pass axis=0 (or do not pass axis). .. versionadded:: 2.0.0 skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. Not implemented for Series. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. **kwargs Additional keyword arguments to be passed to the function. Returns ------- scalar or Series (if level specified) Sum of the values for the requested axis. See Also -------- numpy.sum : Equivalent numpy function for computing sum. Series.mean : Mean of the values. Series.median : Median of the values. Series.std : Standard deviation of the values. Series.var : Variance of the values. Series.min : Minimum value. Series.max : Maximum value. Examples -------- >>> idx = pd.MultiIndex.from_arrays( ... [["warm", "warm", "cold", "cold"], ["dog", "falcon", "fish", "spider"]], ... names=["blooded", "animal"], ... ) >>> s = pd.Series([4, 2, 0, 8], name="legs", index=idx) >>> s blooded animal warm dog 4 falcon 2 cold fish 0 spider 8 Name: legs, dtype: int64 >>> s.sum() 14 By default, the sum of an empty or all-NA Series is ``0``. >>> pd.Series([], dtype="float64").sum() # min_count=0 is the default 0.0 This can be controlled with the ``min_count`` parameter. For example, if you'd like the sum of an empty series to be NaN, pass ``min_count=1``. >>> pd.Series([], dtype="float64").sum(min_count=1) nan Thanks to the ``skipna`` parameter, ``min_count`` handles all-NA and empty series identically. >>> pd.Series([np.nan]).sum() 0.0 >>> pd.Series([np.nan]).sum(min_count=1) nan rrr&r)rOrrrrr&rrs rrz Series.sums<x{  %       rprodc 0tj|f||||d|S)a Return the product of the values over the requested axis. By default, missing values are skipped. To include them in the calculation, set ``skipna`` parameter to False. Parameters ---------- axis : {index (0)} Axis for the function to be applied on. For `Series` this parameter is unused and defaults to 0. .. warning:: The behavior of DataFrame.prod with ``axis=None`` is deprecated, in a future version this will reduce over both axes and return a scalar To retain the old behavior, pass axis=0 (or do not pass axis). .. versionadded:: 2.0.0 skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. Not implemented for Series. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. **kwargs Additional keyword arguments to be passed to the function. Returns ------- scalar Value containing the calculation referenced in the description. See Also -------- Series.sum : Return the sum. Series.min : Return the minimum. Series.max : Return the maximum. Series.idxmin : Return the index of the minimum. Series.idxmax : Return the index of the maximum. DataFrame.sum : Return the sum over the requested axis. DataFrame.min : Return the minimum over the requested axis. DataFrame.max : Return the maximum over the requested axis. DataFrame.idxmin : Return the index of the minimum over the requested axis. DataFrame.idxmax : Return the index of the maximum over the requested axis. Examples -------- By default, the product of an empty or all-NA Series is ``1`` >>> pd.Series([], dtype="float64").prod() 1.0 This can be controlled with the ``min_count`` parameter >>> pd.Series([], dtype="float64").prod(min_count=1) nan Thanks to the ``skipna`` parameter, ``min_count`` handles all-NA and empty series identically. >>> pd.Series([np.nan]).prod() 1.0 >>> pd.Series([np.nan]).prod(min_count=1) nan r)rOrrs rrz Series.prod*s<X|  %       rmeanc .tj|f|||d|S)a Return the mean of the values over the requested axis. Parameters ---------- axis : {index (0)} Axis for the function to be applied on. For `Series` this parameter is unused and defaults to 0. For DataFrames, specifying ``axis=None`` will apply the aggregation across both axes. .. versionadded:: 2.0.0 skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Additional keyword arguments to be passed to the function. Returns ------- scalar or Series (if level specified) Mean of the values for the requested axis. See Also -------- numpy.median : Equivalent numpy function for computing median. Series.sum : Sum of the values. Series.median : Median of the values. Series.std : Standard deviation of the values. Series.var : Variance of the values. Series.min : Minimum value. Series.max : Maximum value. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.mean() 2.0 r)rOrrs rrz Series.means5d|  F  IO   rmedianc .tj|f|||d|S)a Return the median of the values over the requested axis. Parameters ---------- axis : {index (0)} Axis for the function to be applied on. For `Series` this parameter is unused and defaults to 0. For DataFrames, specifying ``axis=None`` will apply the aggregation across both axes. .. versionadded:: 2.0.0 skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Additional keyword arguments to be passed to the function. Returns ------- scalar or Series (if level specified) Median of the values for the requested axis. See Also -------- numpy.median : Equivalent numpy function for computing median. Series.sum : Sum of the values. Series.median : Median of the values. Series.std : Standard deviation of the values. Series.var : Variance of the values. Series.min : Minimum value. Series.max : Maximum value. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.median() 2.0 With a DataFrame >>> df = pd.DataFrame({"a": [1, 2], "b": [2, 3]}, index=["tiger", "zebra"]) >>> df a b tiger 1 2 zebra 2 3 >>> df.median() a 1.5 b 2.5 dtype: float64 Using axis=1 >>> df.median(axis=1) tiger 1.5 zebra 2.5 dtype: float64 In this case, `numeric_only` should be set to `True` to avoid getting an error. >>> df = pd.DataFrame({"a": [1, 2], "b": ["T", "Z"]}, index=["tiger", "zebra"]) >>> df.median(numeric_only=True) a 1.5 dtype: float64 r)rOrrs rrz Series.medians5^~  F  IO   rsemc 0tj|f||||d|S)a Return unbiased standard error of the mean over requested axis. Normalized by N-1 by default. This can be changed using the ddof argument Parameters ---------- axis : {index (0)} This parameter is unused and defaults to 0. skipna : bool, default True Exclude NA/null values. If an entire row/column is NA, the result will be NA. ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. numeric_only : bool, default False Include only float, int, boolean columns. Not implemented for Series. **kwargs : Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- scalar or Series (if level specified) Unbiased standard error of the mean over requested axis. See Also -------- scipy.stats.sem : Compute standard error of the mean. Series.std : Return sample standard deviation over requested axis. Series.var : Return unbiased variance over requested axis. Series.mean : Return the mean of the values over the requested axis. Series.median : Return the median of the values over the requested axis. Series.mode : Return the mode(s) of the Series. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> round(s.sem(), 6) 0.57735 rrr?r&)rOrrrrr?r&rs rrz Series.sem s<d{  %       rvarc 0tj|f||||d|S)a Return unbiased variance over requested axis. Normalized by N-1 by default. This can be changed using the ddof argument. Parameters ---------- axis : {index (0)} For `Series` this parameter is unused and defaults to 0. .. warning:: The behavior of DataFrame.var with ``axis=None`` is deprecated, in a future version this will reduce over both axes and return a scalar To retain the old behavior, pass axis=0 (or do not pass axis). skipna : bool, default True Exclude NA/null values. If an entire row/column is NA, the result will be NA. ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. numeric_only : bool, default False Include only float, int, boolean columns. Not implemented for Series. **kwargs : Additional keywords passed. Returns ------- scalar or Series (if level specified) Unbiased variance over requested axis. See Also -------- numpy.var : Equivalent function in NumPy. Series.std : Returns the standard deviation of the Series. DataFrame.var : Returns the variance of the DataFrame. DataFrame.std : Return standard deviation of the values over the requested axis. Examples -------- >>> df = pd.DataFrame( ... { ... "person_id": [0, 1, 2, 3], ... "age": [21, 25, 62, 43], ... "height": [1.61, 1.87, 1.49, 2.01], ... } ... ).set_index("person_id") >>> df age height person_id 0 21 1.61 1 25 1.87 2 62 1.49 3 43 2.01 >>> df.var() age 352.916667 height 0.056367 dtype: float64 Alternatively, ``ddof=0`` can be set to normalize by N instead of N-1: >>> df.var(ddof=0) age 264.687500 height 0.042275 dtype: float64 r)rOrrs rrz Series.varC s<\{  %       rstdc 0tj|f||||d|S)a8 Return sample standard deviation. Normalized by N-1 by default. This can be changed using the ddof argument. Parameters ---------- axis : {index (0)} This parameter is unused and defaults to 0. skipna : bool, default True Exclude NA/null values. If Series is NA, the result will be NA. ddof : int, default 1 Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. numeric_only : bool, default False Not implemented for Series. **kwargs : Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- scalar Standard deviation over all values in the Series. See Also -------- numpy.std : Compute the standard deviation along the specified axis. Series.var : Return unbiased variance over requested axis. Series.sem : Return unbiased standard error of the mean over requested axis. Series.mean : Return the mean of the values over the requested axis. Series.median : Return the median of the values over the requested axis. Series.mode : Return the mode(s) of the Series. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.std() 1.0 Alternatively, ``ddof=0`` can be set to normalize by $N$ instead of $N-1$: >>> s.std(ddof=0) 0.816496580927726 r)rOrrs rrz Series.std s<n{  %       rskewc .tj|f|||d|S)a@ Return unbiased skew over requested axis. Normalized by N-1. Parameters ---------- axis : {index (0)} This parameter is unused and defaults to 0. skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Unused. **kwargs Additional keyword arguments to be passed to the function. Returns ------- scalar Unbiased skew of the Series. See Also -------- Series.var : Return unbiased variance over requested axis. Series.std : Return unbiased standard deviation over requested axis. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.skew() 0.0 r)rOrrs rrz Series.skew s5R|  F  IO   rkurtc .tj|f|||d|S)a_ Return unbiased kurtosis over requested axis. Kurtosis obtained using Fisher's definition of kurtosis (kurtosis of normal == 0.0). Normalized by N-1. Parameters ---------- axis : {index (0)} Axis for the function to be applied on. For `Series` this parameter is unused and defaults to 0. For DataFrames, specifying ``axis=None`` will apply the aggregation across both axes. .. versionadded:: 2.0.0 skipna : bool, default True Exclude NA/null values when computing the result. numeric_only : bool, default False Include only float, int, boolean columns. **kwargs Additional keyword arguments to be passed to the function. Returns ------- scalar Unbiased kurtosis. See Also -------- Series.skew : Return unbiased skew over requested axis. Series.var : Return unbiased variance over requested axis. Series.std : Return unbiased standard deviation over requested axis. Examples -------- >>> s = pd.Series([1, 2, 2, 3], index=["cat", "dog", "dog", "mouse"]) >>> s cat 1 dog 2 dog 2 mouse 3 dtype: int64 >>> s.kurt() 1.5 r)rOrrs rrz Series.kurt!s5p|  F  IO   rc0tj|||g|Ri|S)a Return cumulative minimum over a Series. Returns a Series of the same size containing the cumulative minimum. Parameters ---------- axis : {0 or 'index'}, default 0 This parameter is unused and defaults to 0. skipna : bool, default True If the entire series is NA, the result will be NA. *args, **kwargs Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- Series Return cumulative minimum of the Series. See Also -------- core.window.expanding.Expanding.min : Similar functionality but ignores ``NaN`` values. Series.min : Return the minimum value of the Series. Series.cummax : Return cumulative maximum. Series.cumsum : Return cumulative sum. Series.cumprod : Return cumulative product. Examples -------- >>> s = pd.Series([2, np.nan, 5, -1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 -1.0 4 0.0 dtype: float64 By default, NA values are ignored. >>> s.cummin() 0 2.0 1 NaN 2 2.0 3 -1.0 4 -1.0 dtype: float64 To include NA values in the operation, use ``skipna=False`` >>> s.cummin(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64 )rOcumminrrrr rs rrz Series.cumminF!)|~dD&B4BBB6BBBrc0tj|||g|Ri|S)a Return cumulative maximum over a Series. Returns a Series of the same size containing the cumulative maximum. Parameters ---------- axis : {0 or 'index'}, default 0 This parameter is unused and defaults to 0. skipna : bool, default True Exclude NA/null values. If the series is NA, the result is NA. *args, **kwargs Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- Series Return cumulative maximum of Series. See Also -------- core.window.expanding.Expanding.max : Similar functionality but ignores ``NaN`` values. Series.max : Return the maximum over a Series. Series.cummin : Return cumulative minimum. Series.cumsum : Return cumulative sum. Series.cumprod : Return cumulative product. Examples -------- >>> s = pd.Series([2, np.nan, 5, -1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 -1.0 4 0.0 dtype: float64 By default, NA values are ignored. >>> s.cummax() 0 2.0 1 NaN 2 5.0 3 5.0 4 5.0 dtype: float64 To include NA values in the operation, use ``skipna=False`` >>> s.cummax(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64 )rOcummaxrs rrz Series.cummax!rrc0tj|||g|Ri|S)a Return cumulative sum over a Series. Returns a Series of the same size containing the cumulative sum. Parameters ---------- axis : {0 or 'index'}, default 0 This parameter is unused and defaults to 0. skipna : bool, default True Exclude NA/null values. If entire series is NA, the result will be NA. *args, **kwargs Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- Series Return cumulative sum of Series. See Also -------- core.window.expanding.Expanding.sum : Similar functionality but ignores ``NaN`` values. Series.sum : Return the sum over Series. Series.cummax : Return cumulative maximum. Series.cummin : Return cumulative minimum. Series.cumprod : Return cumulative product. Examples -------- >>> s = pd.Series([2, np.nan, 5, -1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 -1.0 4 0.0 dtype: float64 By default, NA values are ignored. >>> s.cumsum() 0 2.0 1 NaN 2 7.0 3 6.0 4 6.0 dtype: float64 To include NA values in the operation, use ``skipna=False`` >>> s.cumsum(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64 )rOcumsumrs rrz Series.cumsum!s)z~dD&B4BBB6BBBrc0tj|||g|Ri|S)a, Return cumulative product over a Series. Returns a Series of the same size containing the cumulative product. Parameters ---------- axis : {0 or 'index'}, default 0 This parameter is unused and defaults to 0. skipna : bool, default True Exclude NA/null values. If entire Series is NA, the result will be NA. *args, **kwargs Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- Series Return cumulative product of Series. See Also -------- core.window.expanding.Expanding.prod : Similar functionality but ignores ``NaN`` values. Series.prod : Return the product over Series. Series.cummax : Return cumulative maximum. Series.cummin : Return cumulative minimum. Series.cumsum : Return cumulative sum. Examples -------- >>> s = pd.Series([2, np.nan, 5, -1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 -1.0 4 0.0 dtype: float64 By default, NA values are ignored. >>> s.cumprod() 0 2.0 1 NaN 2 10.0 3 -10.0 4 -0.0 dtype: float64 To include NA values in the operation, use ``skipna=False`` >>> s.cumprod(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64 )rOcumprodrs rrzSeries.cumprod"s)|tT6CDCCCFCCCr)NNNNN)rrrrrr)NN)rrrrrrr)rr)rr)rr)rrq)rr)rrrr)rre)rrG)rr)rrrrrr)rrr3)rrrrmrr )rr rrmrr)r2r)r>rArr)F)rEr)rr)rErrr)rnrorrrr).) ryrvrwrzrrwrrzrxrrr) ryrvrwr~rrwrrzrxrrr) ryrvrwrrrwrr~rxrrr) ryrrwrrrwrrrxrrr)rr)rrrrrrrrrrrrrrrrrr)rrrrrrrrrrrrrrrrrr) NrNTTFFFNN)rrrrrrrrrrrrrrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr)NrTN)rr)rrT)rrrry)rrrr)rrrr)rrrr)rrrr)NNTTTTT)ryrrrrrrrrrrrrr)T)rrrr)rri)rrorrzrrrr)rrorr~rrrr)rrorrrrrr)r)rrorr)rT)rrlrrrr)rrrr)..)rrrr}rr)rrrr}rr)rr rr}rr!)r#r$)r+N)r,rrtrnr-rrr)NrG)r,rr-rr?rrr)rG)rCrrr)rFrrr)r,rJrrK)rQN)rr]r^r_r`rarrb)rfrrrrr)rGFFrX) r,rrlrlrmrrnrrorrrp)r,rsrtrurvrwrr)rr)r,rrr)rrlrrrrzrRrrrzrrr2rrr)rrlrrrr~rRrrrzrrr2rrr)rrlrrrrrRrrrzrrr2rrr)rrlrrrrrRrrrzrrr2rrr)rrlryrvrrrr~rRrrrzrrrrr2rurr)rrlryrvrrrrzrRrrrzrrrrr2rurr)rrlryrvrrrrrRrrrzrrrrr2rurr)rrlryrrrrrrRrrrzrrrrr2rrr)rrNN) rrlrRrrrrrrr)rr)rrrrrr)rrwrrwrrrr)rrrr)rrrr)reNT)ryrvrvrwrrrr)NNN)rtrrrrrrr)rr)Nr)rrl)rtrfrrlrrp)rq)rtrfr rrrrrp)r?rr>rrr)rrrrrrrr~ryrrrtrr)rrrrrrrrzryrrrtrr)rrrrrrrrryrrrtrr)rrlrrrr)rrrtrrrryrrvrrrrr) rrrrlrrrr~rr) rrrrlrrrrzrr) rrrrlrrrrrr )rrrrlrrrrryrrr~rrtrr)rrrrlrrrrryrrrzrrtrr)rrrrlrrrrryrrrrrtrr)rrrr )NNNNT) rrrrrrrrrrrr)TF)rrrrrr)r#)r$r%rr)r+r,rr) rrlrrzrJrKrrrr) rrlrr~rJrKrrrr) rrlrrrJrKrrrr)rQrRrJrSrrrr)rQrrrrr)rnr)r,rrr)r4r|rrr,rJrr})NNr)ryrrvrrrlrr)rrlrr)rrrrlrrr&r)rrlrrrrrr)rFT)rTF)rrrrr&r)NTFr)rrrrr&rrr)rrrrr&rrr )NTrGF)rrrrr?rr&r)rrlrrrr)r __module__ __qualname____doc___typrTrGrr_HANDLED_TYPES__annotations__rrO_internal_names_set _accessorsr@rd _hidden_attrs frozenset__pandas_priority__propertyhasnansfgetrrrrrrrrrrrsetterrr rrrLrrrrr%r5r1r-r0r*r^rYr\rbrXrmrrrr}rrrrr rrrrrrr classmethodrrr r__shared_doc_kwargsrrrrrrr rrrr>rBrErIrMrYr\rerkrrrrrrrrrrrrrrrr_agg_see_also_doc_agg_examples_docrrrrrrrrrr rwrrrr"r*rCr;r!rFr=rIrrVrZr[r _AXIS_LENr\r]r AxisPropertyrrErbrrRrrJrrplotting PlotAccessorr^rKrrIr_rHr hist_serieshistrlrqrsror{rgrrrC make_flex_docrrrrrrrrsubtractrrmultiplyrrdivdividerrdivrrrrrrrrrrhr{rrrrrrrrrrrkurtosisproductrrrr __classcell__)rs@rrrs"jjX D^RZ8NOOO#9I$$$$"F+g.II///J (7+@@99R==P h "'   & .G "  V!V!V!V!V!rSW/////f''''BX & & &X / / /&&&X&X&X"000X0d [111[1(+(+X(+T++X+B%%%X%Xd &.// X0/GK@@@@@JX     &&&&&.#.#.#`   ****(YYYY'"'"'"'"'"RC+C+C+C+J.... % % % %))))@@@@ %%%%%<8 8 8 8 8 t  #"%!$X  "%!$X !$X$(Un!&UUUUUUt---- #& ""     X  #& ""     X $#fe_; 37#'##XXXXXt14 X 14 X 14 X$#fe_= #15 L L L L L `>>>>@*X,/=====X=9=/(/(/(/(/(/(b),)8)8)8)8)8V;;;[;z     Xj l l nn^Xl9%(::;;##%<%<%<9 #'    <;_nnf @SSSS*D,D,D,D,D,LA A A A A A F"% X"%TWX"%sQTX!" ````````DN>N>N>N>N>`: : : : : x; ; ; ; ; z8 8 8 8 8 tEHX03X 58/2X58/7><><><><>7>7>7>7>7>7>7>zj !'+%(^"$( j j j j j j j j X.1%( X.1%("%X.1%(X.1^K n%(^K K K K K K K K Z), '*),!!     X ), '*),!"%!     X ), '*),!!     X )-h '+)-"%h h h h h h h h T@@@@@@F $"#*. y y y y y v66666pM M M M fBH YYYYYvvvvvr,",",","^ S/8999     :9 ,,,,,,^ S09:::!!!!!;:! "%  X  X!" \\\\\\F"&18%(^ MMMMMb %(^:::::|8?iL????L!!I$%%%%%(/O//// #J # & ) ) ) E\ (5- ( (C $6 7 7B (5- . .C 8FFO8 9 9D Xh / /F Xh / /F 8FL ) )D ? &D N N NNNNAAA4 ! ! ! ! !D))))V04ST######@##' D D D D D LXch//00    10 B B B B B HXch//00    10 C C C C C JXch//00    10 < < < < < |Xc1122    32 Xcx0011    21 H Xc1122    32 ##' H H H H H TH Xc1122    32 = = = = = ~ C F Xc H5566    76 D Xc H5566    76 Xc X6677    87 < < < < < |Xc1122    32 Xcx0011    21 Xc1122    32 Xc(3344    54 Xc 84455    65 "******` A A A A A A F$#N&PUVVV e e e e WVe N$#N&PUVVV" D D D D WVD L$#N&PUVVV" D D D D WVD L$#N&PUVVV!" b b b b WVb H$#N&PVWWW!" R R R R XWR h$#N&PVWWW" 3 3 3 3 XW3 j$#fXH " N N N N N `$#N&PUVVV!" 8 8 8 8 WV8 t$#N&PUVVV!" T T T T WVT l$#N&PUVVV!" = = = = WV= ~$#N&PVWWW" * * * * XW* X$#N&PVWWW" 9 9 9 9 XW9 vHG>C>C>C>C>C@>C>C>C>C>C@=C=C=C=C=C~>D>D>D>D>D>D>D>D>Dr)r __future__rcollections.abcrrrrrrrrTtextwrapr typingr r r r rrrrnumpyr pandas._libsrrrpandas._libs.libr pandas.compatrpandas.compat._constantsrrpandas.compat._optionalrpandas.compat.numpyrru pandas.errorsrrrpandas.errors.cowrrpandas.util._decoratorsrr r!r"pandas.util._exceptionsr#pandas.util._validatorsr$r%r&pandas.core.dtypes.astyper'pandas.core.dtypes.castr(r)r*r+r,r-pandas.core.dtypes.commonr.r/r0r1r2r3r4r5r6pandas.core.dtypes.dtypesr7pandas.core.dtypes.genericr8r9pandas.core.dtypes.inferencer:pandas.core.dtypes.missingr;r<r=r> pandas.corer?r@rArrBrCrDpandas.core.accessorrEpandas.core.applyrFpandas.core.arraysrGpandas.core.arrays.arrowrHrIpandas.core.arrays.categoricalrJpandas.core.arrays.sparserKpandas.core.constructionrLr5rMrNpandas.core.genericrOpandas.core.indexersrPrQpandas.core.indexes.accessorsrRpandas.core.indexes.apirSrTrUrVrWrXrYpandas.core.indexes.basecoreindexesrpandas.core.indexes.multirZpandas.core.indexingr[r\pandas.core.internalsr]pandas.core.methodsr^pandas.core.shared_docsr_pandas.core.sortingr`rapandas.core.strings.accessorrbpandas.core.tools.datetimesrcpandas.io.formats.formatioformatsformatrpandas.io.formats.infordpandas.plottingrpandas._libs.internalsrepandas._typingrfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrr__all__rrdrrqrrrPs/ #"""""  .-----222222?>>>>>......   544444                      544444*)))))))))))------?>>>>>444444 ('''''IHHHHH)(((((((((((666666544444''''''000000766666333333&&&&&&&&&&&&':666666""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""H,+++++999999 *  ' FA8 HYEDYEDYEDYEDYEDT YEDYEDYEDYEDYEDr