MhP@ SrSSKJr SSKJrJrJrJr SSKrSSK r SSK J r SSK J r JrJrJrJrJrJr SSKrSSKrSSKrSSKJrJr SSKJr SS KJrJrJ r SS K!J"r" SS K#J$r$ SS K%J&r& SS K'J(r( SSK)J*r+ SSK,J-r-J.r.J/r/J0r0J1r1J2r2J3r3 SSK4J5r5J6r6J7r7J8r8 SSK9J:r: SSK;Jr> SSK?J@r@ SSKAJBrBJCrCJDrDJErEJFrFJGrG SSKHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrP SSKQJRrRJSrSJTrT SSKUJVrVJWrW SSKXJYrY SSKZJ[r[J\r\J]r]J^r^ SSK_J`r`JaraJbrcJdrdJereJfrfJgrg SSKhJiri SSKjJkrk SSKlJmrm SSKnJoroJprp SSKqJrrr SS KsJtrt SS!KuJvrv SS"KwJxryJzrzJ{r{ SS#K|J}r}J~r~ SS$KJrJr SS%KJr SS&KJrJrJrJrJrJr SSKJs Js Jar SS'KJr SS(KJrJr SS)KJrJr SS*KJr SS+KJr SS,KJrJr SS-KJr SS.KJr SSKJs Js Jr SS/KJrJrJr SSKr\(aVSS0KJr SS1KJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJr SS2KJr SS3KJr S4/rS5S4S6S7S8S9S4S:S;S<. rS=r"S>S4\aGR\}5rg)?zG Data structure for 1-dimensional cross-sectional and time series data ) annotations)HashableIterableMappingSequenceN)dedent)IO TYPE_CHECKINGAnyCallableLiteralcastoverload)using_copy_on_writewarn_copy_on_write) _get_option)lib propertiesreshape)is_range_indexer)PYPY) REF_COUNT)import_optional_dependency)function)ChainedAssignmentErrorInvalidIndexError_chained_assignment_method_msg_chained_assignment_msg&_chained_assignment_warning_method_msg_chained_assignment_warning_msg _check_cacher)Appender Substitutiondeprecate_nonkeyword_argumentsdoc)find_stack_level)validate_ascendingvalidate_bool_kwargvalidate_percentile)astype_is_view)LossySetitemError"construct_1d_arraylike_from_scalarfind_common_typeinfer_dtype_frommaybe_box_nativemaybe_cast_pointwise_result) is_dict_like is_integer is_iterator is_list_likeis_object_dtype is_scalar pandas_dtypevalidate_all_hashable)CategoricalDtypeExtensionDtype SparseDtype) ABCDataFrame ABCSeries) is_hashable)isnana_value_for_dtypenotnaremove_na_arraylike) algorithmsbasecommonmissingnanopsops roperator)CachedAccessor) SeriesApply)ExtensionArray) ListAccessorStructAccessor)CategoricalAccessor)SparseAccessor) StringDtype)array extract_arraysanitize_array)NDFramemake_doc)disallow_ndim_indexing unpack_1tuple)CombinedDatetimelikeProperties) DatetimeIndexIndex MultiIndex PeriodIndex default_index ensure_index)maybe_droplevels)check_bool_indexercheck_dict_or_set_indexers)SingleArrayManagerSingleBlockManager)selectn) _shared_docs)ensure_key_mappednargsort) StringMethods) to_datetime)INFO_DOCSTRING SeriesInfoseries_sub_kwargs)BlockValuesRefs) AggFuncTypeAnyAll AnyArrayLike ArrayLikeAxisAxisIntCorrelationMethodDropKeepDtypeDtypeObjFilePath Frequency IgnoreRaise IndexKeyFunc IndexLabelLevelMutableMappingT NaPosition NumpySorterNumpyValueArrayLikeQuantileInterpolation ReindexMethodRenamerScalarSelf SingleManagerSortKindStorageOptionsSuffixes 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_reindexc>^U4SjnSTRS3UlU$)z& Install the scalar coercion methods. c>[U5S:XaR[R"STRSTRS3[[ 5S9 T"UR S5$[ST35e)NzCalling zX on a single element Series is deprecated and will raise a TypeError in the future. Use z(ser.iloc[0]) instead stacklevelrzcannot convert the series to )lenwarningswarn__name__ FutureWarningr&iloc TypeError)self converters D/var/www/html/env/lib/python3.13/site-packages/pandas/core/series.pywrapper_coerce_method..wrappersu t9> MM9--./ ))**?A+-  TYYq\* *7 {CDD__)r)rrs` r_coerce_methodrs( EI../r2G Nrc %^\rSrSr%SrSr\\\R4r S\ S'S/r S\ S'SS 1\ R-r1S kr\R"R$\ R$-\"/5-rS r\"\R"R,R.\R"R,RS 9rS \ S'SSSSS\R24GSGSjjrGSHGSISjjr\GSJSj5rSr\GSKSj5rSr\GSLSj5r \GSMSj5r!\GSMSj5r"\GSNSj5r#\#RHGSOSj5r#\S5r%\S5r&\GSPSj5r'\("\R"RRR5\GSQSj55r)GSRGSSS jjr*GSTS!jr+GSUGSVS"jjr,GSHGSWS#jjr-SS$.GSXS%jjr.\/"\05r1\/"\25r3\GSYS&j5r4GSZGS[S)jjr5GSZGS\S*jjr6S+r7S,r8GS]S-jr9GS^S.jr:GS_GS`S0jjr;GSaS1jrGSbGScS5jjr?GSbGScS6jjr@GS_GSdS7jjrA\GSLS8j5rBS9rCGSaS:jrDGSaS;jrEGSaS<jrFGSLU4S=jjrGGSeGSfU4S>jjjrHGSUGSgS?jjrI\JGShS@S@S@S@SA.GSiSCjjj5rK\JGShS@S@S@SD.GSjSEjjj5rK\JGShS@S@S@SF.GSkSGjjj5rKGSUS/\R2S/S/SA.GSlSHjjjrKGSmSIjrL\JGSnGSoSJjj5rM\JGSpGSqSKjj5rMGSrGSsSLjjrM\N"\OSM\PSN\Q"SO5SP9GStGSuSQjj5rRGSvSRjrSGSwSSjrT\JGSxSTj5rU\JS@SU.GSySVjj5rU\V"SWSX/SYSZ9\W4GSxS[jj5rU\R24GSzS\jjrXGS{GS|S]jjrY\("\Q"S^55\("\PS_\O-5SS'SS2S2S2\R2S24GS}S`jj55rZGSTSajr[GSbGS~Sbjjr\GSU4Scjjr]\JS@S@S@Sd.GSSejj5r^\JS@S@Sf.GSSgjj5r^\JS@S@S@Sd.GSShjj5r^SiS/S/Sd.GSU4Sjjjjr^GSGSSkjjr_GSGSSljjr`GSGSSmjjraGSZGSSnjjrb\JGSGSSojj5rc\JGShGSSpjj5rc\JGSGSSqjj5rcGSGSSrjjrcGSGSSsjjrdGSGSSujjre\N"SSvSB\Q"Sw5Sx9GSGSSyjj5rfGSGSSzjjrgGSS{jrhS|riS}rj\N"\R"RSS~9GSGSSjj5rkGSGSSjjrl\N"\PS\Q"S5\OSMS~9GSGSU4Sjjj5rmGSUGSSjjrnGSSjroGSSjrp\JS@S@S@S@S@S@S@S.GSSjj5rq\JS@S@S@S@S@S@S.GSSjj5rq\JS@S@S@S@S@S@S@S.GSSjj5rqS'S2S/SSS/SS.GSSjjrq\JS@S@S@S@S@S@S@S@S.GSSjj5rr\JS@S@S@S@S@S@S@S@S@S. GSSjj5rr\JS@S@S@S@S@S@S@S@S@S. GSSjj5rrS'SS2S/SSS2S/SS. GSU4SjjjrrGSGSSjjrsGSGSSjjrtGSGSSjjru\N"\OSM\Q"S5\Q"S5S9GSGSSjj5rvGSSjrwGS_GSSjjrxGSGSSjjryGSUGSSjjrzGSUGSSjjr{\Q"S5r|\Q"S5r}\N"\PS\OSM\OS(\|\}S9GSGSSjj5r~\~r\N"\PS\OSM\OS(S9GSZGSSjj5r\R2S4SS.GSSjjjrGSSjrGSLSjr\JGShS@S@S@S@S.GSSjjj5r\JGShS@S@S@S@S@S.GSSjjj5r\JGShS@S@S@S@S@S.GSSjjj5rGSUSSS/SSS.GSU4Sjjjjr\("S5\"\OSM\OSSvSvSvS9\("\ GR R5S'SS.GSU4Sjjj555r\N"\ GR\OSM\OSS9GSUSSSSSSSS.GSU4Sjjjj5r\JGShS@S@S@S.GSSjjj5r\JGShS@S@S@S@S.GSSjjj5r\JGShS@S@S@S@S.GSSjjj5r\N"\ GR5\R24\R2S'S2S/S.GSU4Sjjjj5r\JGShS@S@S@S@S@S.GSSjjj5r\JGShS@S@S@S@S@S@S.GSSjjj5r\JGShS@S@S@S@S@S@S.GSSjjj5rGSUS'SSSS/SS.GSU4SjjjjrGSU4Sjjr\N"\40\D6GSGSSjj5rGSSjrGSGSSjjrGSSjrGSGSSjjrGSSjr\N"\ GR&\OSMS~9GSSj5r\N"\ GR&\OSMS~9GSU4Sjj5r\N"\ GR*\OSMS~9GSU4Sjj5r\N"\ GR*\OSMS~9GSU4Sjj5r\JS@S@S@S@S.GSSjj5r\JS@S@S@S.GSSjj5rS'S/SS/S.GSSjjrGSGSSjjrGSHGSSjjrS/rS\ S'\"\5rS'rS\ S'SrS\ S'\GR@"S'SS9r\"S\5r\"S\5r\"S\5r\"S\GRTGRV5r\"S\5r\"S\5r\"S\5r\GRTGRfrSrSrSrGS_GSSjjrGSHGSSjjrGSSjrSSS'S.GSSjjr\("\GRz"SS55GSGSSjj5r\("\GRz"SS55GSGSSjj5r\("\GRz"SS55GSGSSjj5r\("\GRz"SS55GSGSSjj5r\("\GRz"SS55GSGSSjj5r\("\GRz"SS55GSGSSjj5r\("\GRz"GSS55GSGSGSjj5r\("\GRz"GSS55GSGSGSjj5r\("\GRz"GSS55GSGSGSjj5r\r\("\GRz"GSS55GSGSGSjj5r\("\GRz"GSS55GSGSGS jj5r\r\("\GRz"GS S55GSGSGS jj5r\("\GRz"GS S55GSGSGS jj5r\r\r\("\GRz"GSS55GSGSGSjj5r\r\("\GRz"GSS55GSGSGSjj5r\("\GRz"GSS55GSGSGSjj5r\("\GRz"GSS55GSGSGSjj5r\("\GRz"GSS55GSGSGSjj5r\("\GRz"GSS55GSGSGSjj5r\("\GRz"GSS55GSGSGSjj5r\("\GRz"GSS55GSGSGSjj5r\("\GRz"GSS55GSGSGSjj5rS'S2S/SGS .GSGS!jjr\("\"GS"StGS#95S'S/S2GS$.GSGS%jj5r\("\"GS&StGS#95GSGSGS'jj5r\N"\"GS(StGS#95GSGSGS)jj5r\N"\"GS*StGS#95GSGSGS+jj5r\N"\"GS,StGS#95GSGSGS-jj5r\N"\"GS.StGS#95GSGSGS/jj5r\N"\"GS0StGS#95GSGSGS1jj5r\N"\"GS2StGS#95GSGSGS3jj5r\N"\"GS4StGS#95GSGSGS5jj5r\N"\"GS6StGS#95GSGSGS7jj5r\N"\"GS8StGS#95GSGSGS9jj5r\N"\"GS:StGS#95GSGSGS;jj5r\N"\"GSStGS#95GSGSGS?jj5r\N"\"GS@StGS#95GSGSGSAjj5r\N"\"GSBStGS#95GSGSGSCjj5r\N"\"GSDSt55GSGSGSEjj5rGSFrU=r$(ria One-dimensional ndarray with axis labels (including time series). Labels need not be unique but must be a hashable type. The object supports both integer- and label-based indexing and provides a host of methods for performing operations involving the index. Statistical methods from ndarray have been overridden to automatically exclude missing data (currently represented as NaN). Operations between Series (+, -, /, \*, \*\*) align values based on their associated index values-- they need not be the same length. The result index will be the sorted union of the two indexes. Parameters ---------- data : array-like, Iterable, dict, or scalar value Contains data stored in Series. If data is a dict, argument order is maintained. index : array-like or Index (1d) Values must be hashable and have the same length as `data`. Non-unique index values are allowed. Will default to RangeIndex (0, 1, 2, ..., n) if not provided. If data is dict-like and index is None, then the keys in the data are used as the index. If the index is not None, the resulting Series is reindexed with the index values. dtype : str, numpy.dtype, or ExtensionDtype, optional Data type for the output Series. If not specified, this will be inferred from `data`. See the :ref:`user guide ` for more usages. name : Hashable, default None The name to give to the Series. copy : bool, default False Copy input data. Only affects Series or 1d ndarray input. See examples. Notes ----- Please reference the :ref:`User Guide ` for more information. Examples -------- Constructing Series from a dictionary with an Index specified >>> d = {'a': 1, 'b': 2, 'c': 3} >>> ser = pd.Series(data=d, index=['a', 'b', 'c']) >>> ser a 1 b 2 c 3 dtype: int64 The keys of the dictionary match with the Index values, hence the Index values have no effect. >>> d = {'a': 1, 'b': 2, 'c': 3} >>> ser = pd.Series(data=d, index=['x', 'y', 'z']) >>> ser x NaN y NaN z NaN dtype: float64 Note that the Index is first build with the keys from the dictionary. After this the Series is reindexed with the given Index values, hence we get all NaN as a result. Constructing Series from a list with `copy=False`. >>> r = [1, 2] >>> ser = pd.Series(r, copy=False) >>> ser.iloc[0] = 999 >>> r [1, 2] >>> ser 0 999 1 2 dtype: int64 Due to input data type the Series has a `copy` of the original data even though `copy=False`, so the data is unchanged. Constructing Series from a 1d ndarray with `copy=False`. >>> r = np.array([1, 2]) >>> ser = pd.Series(r, copy=False) >>> ser.iloc[0] = 999 >>> r array([999, 2]) >>> ser 0 999 1 2 dtype: int64 Due to input data type the Series has a `view` on the original data, so the data is changed as well. seriesr_namez list[str] _metadatarname>dtcatstrsparsei )r%r_mgrNclU[RLa#[R"S[[ 5S9 OSnSn[ U[[45(aUcUcUSLdUcU(dG[R"S[U5RS[U5RS3[SS9 [5(aURSS9n[R"X5 U(a[R!US U5 gX@lg[ U[$[&[(45n[+US S5n Un [ U[([,R.45(aKUSLaF[5(a7Ub$[1UR2[5U55(aUR5nUcSnU(Ga[ U[[45(dF[7S S S 9n U S:Xa[R8"X5nOU S:Xa[R8"X5nS nO%[5(aU(dURSS9nU(dG[R"S[U5RS[U5RS3[SS9 U(aUR5n[R!US U5 [R"X5 g[ U[5(as[5(adU(d]URSS9nU(dG[R"S[U5RS[U5RS3[SS9 [:R<"XA[U55nUb [?U5nUbURAU5nUc9UbUO [CS5n[EU5(dUb[G[5U5SS9nO/n[ U[H5(a [KS5eSn [ U[&5(aYUbURMUSS9n[5(aURNn URPnOURPR5nSnGO[ U[,R.5(a'[EUR25(a [SS5eGO[ U[$5(aIUc'URTnURVRSS9nGOeURYX%S9nSnURVnGOF[ U[Z5(aUR]XU5upSnSnGO[ U[[45(aUc URTnO2URTR_U5(aU(a [aS5eU(dI[R"S[U5RS[U5RS3[SS9 S nOi[ U[(5(aOS[bRd"U5n[gU5(a-[EU5(dUc[,R2"[5nUc([gU5(dU/n[C[EU55nO&[gU5(a[bRh"X5 [ U[[45(a-UbURMUSUS9nOfU(aUR5nON[kXX55n[7S S S 9n U S:Xa[R8"XU S9nOU S:Xa[R8"X5n[R"X5 X@lURmSU5 U cQU(aIU [,Rn:Xa4UR2U :wa#[R"S[p[ 5S9 ggggg)NzZThe 'fastpath' keyword in pd.Series is deprecated and will be removed in a future version.rFz Passing a z to zK is deprecated and will raise in a future version. Use public APIs instead.deeprdtypezmode.data_managerT)silentblockrRrcompatz8initializing a Series from a MultiIndex is not supportedcopyzVCannot construct a Series from an ndarray with compound dtype. Use DataFrame instead.zkCannot pass both SingleBlockManager `data` argument and a different `index` argument. `copy` must be False.ignore)rerrorsr)refszDtype inference on a pandas object (Series, Index, ExtensionArray) is deprecated. The Series constructor will keep the original dtype in the future. Call `infer_objects` on the result to get the old behavior.)9r no_defaultrrDeprecationWarningr& isinstancerdrctyperrrrU__init__object __setattr__rrr[rLgetattrnpndarrayr*rr7r from_arrayibasemaybe_extract_namer__validate_dtyper^rr@r\NotImplementedErrorastype _references_values ValueErrorrrreindexr _init_dictequalsAssertionErrorcommaybe_iterable_to_listr4require_length_matchrT _set_axisobject_r) rdatarrrrfastpath allow_mgris_pandas_object data_dtypeoriginal_dtypemanagerrs rrSeries.__init__s 3>> ) MM2"+-  H t02DE F F  $,  d!4!4 5T$t*:M:M9NO//' #$$yyey,   T (""4$7 ! %dVUN,KLT7D1  d^RZZ8 9 95 %8%:%:=N4::|E?R$S$S99;D <D d%79K$LMM%&9$Gg%-88ED'-88ED $&&tyyey,  d!4!4 5T$t*:M:M9NO//' yy{   tWd 3   T (  d. / /4G4I4IRV99%9(D  d!4!4 5T$t*:M:M9NO//' ''DJ?   'E  ((/E <".EM!4DE5zzU.),u*=eL dJ ' '%J  dE " " {{5u{5"$$''||||((*D bjj ) )4::!>f % %} yy~~5~1||E|5yy g & &//$u=KDED 13EF G G} ZZ&&u--%>   d!4!4 5T$t*:M:M9NO//' ! n - - --d3DD!!#d)) ( =%%v!#d),E $    $ $T 1 d/1CD E E {{xd{Kyy{!$u;D!"5dCG'!)44TtLG#)44TA$  q%  !&6:;SzzZ' R"/1 (>> s = pd.Series([1, 2, 3]) >>> s.dtype dtype('int64') )rrrs rr Series.dtypesyyrcUR$)z} Return the dtype object of the underlying data. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.dtypes dtype('int64') rrs rdtypes Series.dtypesszzrcUR$)a 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 rr Series.names`zzrcr[U[U5RS3S9 [R USU5 g)Nz.name) error_namer)r8rrrr)rvalues rrrs0e4:3F3F2Gu0MN4%0rc6URR5$)a Return Series as ndarray or ndarray-like depending on the dtype. .. warning:: We recommend using :attr:`Series.array` or :meth:`Series.to_numpy`, depending on whether you need a reference to the underlying data or a NumPy array. Returns ------- numpy.ndarray or ndarray-like See Also -------- Series.array : Reference to the underlying data. Series.to_numpy : A NumPy array representing the underlying data. Examples -------- >>> pd.Series([1, 2, 3]).values array([1, 2, 3]) >>> pd.Series(list('aabc')).values array(['a', 'a', 'b', 'c'], dtype=object) >>> pd.Series(list('aabc')).astype('category').values ['a', 'a', 'b', 'c'] Categories (3, object): ['a', 'b', 'c'] Timezone aware datetime data is converted to UTC: >>> pd.Series(pd.date_range('20130101', periods=3, ... tz='US/Eastern')).values array(['2013-01-01T05:00:00.000000000', '2013-01-02T05:00:00.000000000', '2013-01-03T05:00:00.000000000'], dtype='datetime64[ns]') )rexternal_valuesrs rr Series.valuessPyy((**rc6URR5$)a Return the internal repr of this data (defined by Block.interval_values). This are the values as stored in the Block (ndarray or ExtensionArray depending on the Block class), with datetime64[ns] and timedelta64[ns] wrapped in ExtensionArrays to match Index._values behavior. Differs from the public ``.values`` for certain data types, because of historical backwards compatibility of the public attribute (e.g. period returns object ndarray and datetimetz a datetime64[ns] ndarray for ``.values`` while it returns an ExtensionArray for ``._values`` in those cases). Differs from ``.array`` in that this still returns the numpy array if the Block is backed by a numpy array (except for datetime64 and timedelta64 dtypes), while ``.array`` ensures to always return an ExtensionArray. Overview: dtype | values | _values | array | ----------- | ------------- | ------------- | --------------------- | Numeric | ndarray | ndarray | 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 rrSeries._values?s@yy((**rc[UR[5(agURRR$r)rrrc_blockrrs rrSeries._referencesas- dii!3 4 4yy$$$rc6URR5$r)r array_valuesrs rrR Series.arrayhsyy%%''rrc[R"S[SS9 URR US9n[ U[ R5(a [5(aSURl U$)a Return the flattened underlying data as an ndarray or ExtensionArray. .. deprecated:: 2.2.0 Series.ravel is deprecated. The underlying array is already 1D, so ravel is not necessary. Use :meth:`to_numpy` for conversion to a numpy array instead. Returns ------- numpy.ndarray or ExtensionArray Flattened data of the Series. See Also -------- numpy.ndarray.ravel : Return a flattened array. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.ravel() # doctest: +SKIP array([1, 2, 3]) zSeries.ravel is deprecated. The underlying array is already 1D, so ravel is not necessary. Use `to_numpy()` for conversion to a numpy array instead.rr)orderF) rrrrravelrrrrflags writeable)rr'arrs rr( Series.ravelnsa0      ll  u - c2:: & &+>+@+@"'CII  rc,[UR5$)z" Return the length of the Series. )rrrs r__len__Series.__len__s499~rc[R"S[SS9 URR U5nUR X R SS9n[UR[5(aLURRn[SUR5Ul URRU5 URUSS9$) aX Create a new view of the Series. .. deprecated:: 2.2.0 ``Series.view`` is deprecated and will be removed in a future version. Use :meth:`Series.astype` as an alternative to change the dtype. This function will return a new Series with a view of the same underlying values in memory, optionally reinterpreted with a new data type. The new data type must preserve the same size in bytes as to not cause index misalignment. Parameters ---------- dtype : data type Data type object or one of their string representations. Returns ------- Series A new Series object as a view of the same data in memory. See Also -------- numpy.ndarray.view : Equivalent numpy function to create a new view of the same data in memory. Notes ----- Series are instantiated with ``dtype=float64`` by default. While ``numpy.ndarray.view()`` will return a view with the same data type as the original array, ``Series.view()`` (without specified dtype) will try using ``float64`` and may fail if the original data type size in bytes is not the same. Examples -------- Use ``astype`` to change the dtype instead. zxSeries.view is deprecated and will be removed in a future version. Use ``astype`` as an alternative to change the dtype.rrFrrrnviewmethod)rrrrRr2rrrrrdr!rrr add_reference __finalize__)rr res_valuesres_serblks rr2 Series.viewsP   D   ZZ__U+ ##Jjju#M gll$6 7 7,,%%C-t/?/?@CH HH " "3 '##D#88rcURn[R"X1S9n[5(aF[ UR UR 5(a!UR 5nSURlU$)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 Unused. 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]') rF) rrasarrayrr*rr2r)r*)rrrrr+s r __array__Series.__array__sUhjj-  ^FLL#))%L%L((*C"'CII  r api_versioncJ[S5nURRXS9$)z Provide entry point to the Consortium DataFrame Standard API. This is developed and maintained outside of pandas. Please report any issues to https://github.com/data-apis/dataframe-api-compat. dataframe_api_compatr?)rpandas_standard$convert_to_standard_compliant_column)rr@rBs r__column_consortium_standard__%Series.__column_consortium_standard__s2 ::PQ 0 0 U U V  rcUR/$)z' Return a list of the row axis labels. rrs rr Series.axes's  |rrrc URU$)zs Return the i-th value or values in the Series by location. Parameters ---------- i : int Returns ------- scalar )r)rirs r_ixs Series._ixs1s||ArcURRXS9nURX3RS9nURUlUR U5$)N)rr)r get_slicerrrr6)rslobjrrouts r_slice Series._slice?sNii!!%!3((88(<JJ %%rc[U5 [R"X5nU[La/[ 5(d[ 5(aUR SS9$U$[U5n[U[[45(a [U5n[U5(aLURR(a1[R "S["[%5S9 UR&U$U(aUR)U5$[+U5(a [U5n[-U5(a)[U[.5(dUR)U5nU$[U[.5(aUR;U5$[R<"U5(a@[?URU5n[@RB"U[DS9nURGU5$URIU5$![0[2[44aJ [U[5(a2[UR[65(aUR9U5s$Nf=f)NFrSeries.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`rr)%rbrapply_if_callableEllipsisrrrr6rrrrXr2r_should_fallback_to_positionalrrrr&r _get_valuer3r>sliceKeyErrorrrr\_get_values_tuple_getitem_sliceis_bool_indexerrarr<bool_get_rows_with_mask _get_with)rkey key_is_scalarresults r __getitem__Series.__getitem__Gs"3'##C. (?"$$(:(<(<yyey,,K!# cD%= ) )$C c??tzzHH MM;+- <<$ $ ??3' ' s  s)C s  JsE$:$: 7-  c5 ! !&&s+ +   s # #$TZZ5C**S-C++C0 0~~c""#i):; 7c5))jZ.P.P 11#66  7sG%%AIIcT[U[5(a [S5e[U[5(aUR U5$[ U5(dUR U$[U[[R[[[45(d [U5n[R"USS9nUS:Xa[URR (dUR U$["R$"S[&[)5S9 UR*U$UR U$)NzWIndexing a Series with DataFrame is not supported, use the appropriate DataFrame columnFskipnaintegerrUr)rr<rrr\r4locrrrrLrr[r infer_dtyperrXrrrr&r)rrbkey_types rraSeries._get_withs c< ( (B U # #))#. .c""88C= #bjj.&%PQQs)C??3u5 y ::<<xx}$ ?"/1yy~%xx}rc[R"U6(a0[R"URU5n[ U5 U$[ UR[5(d [S5eURRU5up4URURUUSS9n[ U[5(a%URRUR5 URU5$)N0key of type tuple not found and not a MultiIndexFr1)rany_nonerr<rrWrrr\r[ get_loc_levelrrZradd_referencesr6)rrbrdindexer new_indexnew_sers rr\Series._get_values_tuples << ZZ S 12F "6 *M$**j11MN N"ZZ55c:##DLL$9QV#W gu % % LL ' ' 2##D))rcURRU5nURX"RS9R U5$r)rget_rows_with_maskrrr6)rrtnew_mgrs rr`Series._get_rows_with_masks:))..w7))' )ERRSWXXrFcfU(aURU$URRU5n[U5(aURU$[ UR[ 5(aURnURUn[ U5S:XaURS:XaUS$XCn[Xa5nURXVURSS9n[ U[5(a%URRUR5 URU5$URU$)z Quickly retrieve single value at passed index label. Parameters ---------- label : object takeable : interpret the index as indexers, default False Returns ------- scalar value rrFrrr)rrget_locr2rr\rnlevelsr`rrrZrrsr6r)rlabeltakeablerkmi new_valuesrurvs rrYSeries._get_values <<& &jj  ' c??<<$ $ djj* - -Bc*J:!# a!!}$I(:I''$))%(G#u%% ++DII6''- -99S> !rcSn[(dH[5(a9[R"U5S::a[R "[ [SS9 O[(d[5(d[R"U5nSn[5(d[U5(aUS- nXE::at[5(dE[5(dVURRSRR5(a Sn[R "[[SS9 [!U5 ["R$"X5nUR'5nU[(La [+S5n[-U[*5(a*UR.R1USS 9nUR3XrUS 9$UR5XUS 9 U(aURkSS9 gg![6a [9U5(a`UR.R:(dX R<U'N][R "S [[?5S9 UR3X5 NX R<U'N[@[B[D4a/ UR.RGU5nUR3Xr5 N[HGa]n[-U[J5(a+[-UR.[L5(d [7S 5Ue["RN"U5(a[QUR.U5n[RRT"U[VS 9n[YU5(ap[[U5[[U5:waX[-U[\5(dC[_UR`5(d)URc5SnUR3Xr5 SnAgUReU)USUS9 O![Ha X RfU'Of=fSnAgURiXUS 9 SnAGNFSnAff=f)NTrrrrFgetitemkindrSeries.__setitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To set a value by position, use `ser.iloc[pos] = value`rpr)rrr)6rrsys getrefcountrrrrrr!rblocksr has_referencer rrbrrV%_check_is_chained_assignment_possiblerWrZrr_convert_slice_indexer _set_values_set_with_enginer[r2rXrkr&rrr+r~rrr\r^rarr<r_r4rrr5rnonzero_wherer _set_with_maybe_update_cacher) rrbrrctr ref_countcacher_needs_updatingrterrs r __setitem__Series.__setitem__s5t+--t$) +-CPQ133//$'CI%''M$,?,?Q "$$*,, ((+00>>@@ 3]q #3'##C. $ J J L (?+C c5 ! !jj77)7LG##G#> >C 6  ! !#4 ! 8H !  % %d % 3 !G &#zz@@$)HHSM MMK#5$$S0!& :'89 -jj((-G   W , # 6#u%%jZ.P.PF""3''(S9jjD1!''E c$i/&uf55+DJJ77 "kkmA.G$$W4+KKeTKE(+%*IIcN+s5G# 6s]*GAP3P PAP P(DP3OPO"P!O""P*PPTcnURRU5nURRXBUS9 g)Nr)rr~rsetitem_inplace)rrbrrrks rrSeries._set_with_engineYs/jj  % !!#4!8rc|[U[5(ae[U5(a [U5nURR (dUR XUS9 g[R"USS9nUS:Xa3[R"S[[5S9 URXUS9 gUR XUS9 g)NrFrhrjrr)rrr3rrrX _set_labelsrrlrrrr&r)rrbrrrms rrSeries._set_with_sc5)))) s  s)Czz88   Sd  3 s59H9$ G"/1  $ 7  $ 7rc[R"U5nURRU5nUS:HnUR 5(a[ XS35eUR XBUS9 g)Nz not in indexr)rasarray_tuplesafer get_indexeranyr[r)rrbrrrtmasks rrSeries._set_labelssa##C("jj44S9"} 88::ci[ 67 7 d3rc[U[[45(a URnURR XUS9UlUR 5 g)N)rtrr)rr[rrrsetitemr)rrbrrs rrSeries._set_valuessC cE6? + +++CII%%cT%J  !!#rcU(dURRU5nOUnUR XB5 g![a X RU'gf=f)aH 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)rr~r[rkr)rrrrrks r _set_valueSeries._set_valuesT jj((/ C $ "' s9AAc [USS5SL$)z3Return boolean indicating if self is cached or not._cacherNrrs r _is_cachedSeries._is_cachedstY-T99rc:[USS5nUb US"5nU$)zreturn my cacher or NonerNrr)rcachers r _get_cacherSeries._get_cachers&y$/  AY[F rc,[US5(aU?gg)z Reset the cacher. rN)hasattrrrs r _reset_cacherSeries._reset_cachers 4 # #  $rc^[5(agU[R"U54Ulg)zK Set the _cacher attribute on the calling object with a weakref to cacher. N)rweakrefrefr)ritemrs r_set_as_cachedSeries._set_as_cacheds%  gkk&12 rcgrrs r_clear_item_cacheSeries._clear_item_caches rc>UR(aFUR(a5UR5nUb!UR(aUR SSS9 g[ TU]5$)z; See NDFrame._check_is_chained_assignment_possible.__doc__ referentT)tforce)_is_viewrr_is_mixed_type_check_setitem_copysuperr)rr __class__s rr,Series._check_is_chained_assignment_possiblesQ ==T__""$C3#5#5((:T(Bw<>>rcL>[5(ag[USS5nUbuUS"5nUcU?Oe[U5[U5:Xa.URUR ;aUR USXS9 OURRUSS5 [TU])XUS9 g)z* See NDFrame._maybe_update_cacher.__doc__ Nrrrr)clearverify_is_copyr) rrrrrcolumns_maybe_cache_changed _item_cachepoprr)rrrrrrrs rrSeries._maybe_update_cachers  y$/  #AY[C{LTc#h&499 +C((D(J##F1It4 $ % rc[R"SSU05 URRU5nURRU5nUR XCSS9R USS9$)aZ Repeat elements of a Series. Returns a new Series where each element of the current Series is repeated consecutively a given number of times. Parameters ---------- repeats : int or array of ints The number of repetitions for each element. This should be a non-negative integer. Repeating 0 times will return an empty Series. axis : None Unused. Parameter needed for compatibility with DataFrame. Returns ------- Series Newly created Series with repeated elements. See Also -------- Index.repeat : Equivalent function for Index. numpy.repeat : Similar method for :class:`numpy.ndarray`. Examples -------- >>> s = pd.Series(['a', 'b', 'c']) >>> s 0 a 1 b 2 c dtype: object >>> s.repeat(2) 0 a 0 a 1 b 1 b 2 c 2 c dtype: object >>> s.repeat([1, 2, 3]) 0 a 1 b 1 b 2 c 2 c 2 c dtype: object rrFr1repeatr3)nvvalidate_repeatrrrrr6)rrepeatsrrurs rr Series.repeatsof 2~.JJ%%g. \\((1   5 IVV W  r.)droprrallow_duplicatesrcgrrrlevelrrrrs r reset_indexSeries.reset_index4 r)rrrcgrrrs rrr@rr)rrrcgrrrs rrrLrrc@[US5nU(Ga$[[U55nUb[U[[ 45(dU/nOUnUVs/sHoR RU5PM nn[U5UR R:aUR RU5nU(aX`lg[5(a%URSS9n XilU RUSS9$URURR5USURS9RUSS9$U(a [!S5eU["R$LaUR&cS nO UR&nUR)U5n U R+XUS 9$s snf) 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. .. versionadded:: 1.5.0 Returns ------- Series or DataFrame or None When `drop` is False (the default), a DataFrame is returned. The newly created columns will come first in the DataFrame, followed by the original Series values. When `drop` is True, a `Series` is returned. In either case, if ``inplace=True``, no value is returned. See Also -------- DataFrame.reset_index: Analogous function for DataFrame. Examples -------- >>> s = pd.Series([1, 2, 3, 4], name='foo', ... index=pd.Index(['a', 'b', 'c', 'd'], name='idx')) Generate a DataFrame with default index. >>> s.reset_index() idx foo 0 a 1 1 b 2 2 c 3 3 d 4 To specify the name of the new column use `name`. >>> s.reset_index(name='values') idx values 0 a 1 1 b 2 2 c 3 3 d 4 To generate a new Series with the default set `drop` to True. >>> s.reset_index(drop=True) 0 1 1 2 2 3 3 4 Name: foo, dtype: int64 The `level` parameter is interesting for Series with a multi-level index. >>> arrays = [np.array(['bar', 'bar', 'baz', 'baz']), ... np.array(['one', 'two', 'one', 'two'])] >>> s2 = pd.Series( ... range(4), name='foo', ... index=pd.MultiIndex.from_arrays(arrays, ... names=['a', 'b'])) To remove a specific level from the Index, use `level`. >>> s2.reset_index(level='a') a foo b one bar 0 two bar 1 one baz 2 two baz 3 If `level` is not set, all levels are removed from the Index. >>> s2.reset_index() a b foo 0 bar one 0 1 bar two 1 2 baz one 2 3 baz two 3 rNFrrr3)rrrz>9I" 9Ws$FcP[R"5nUR"S0UD6$)z9 Return a string representation for a particular Series. r)fmtget_series_repr_params to_string)r repr_paramss r__repr__Series.__repr__s$ 002 ~~, ,,rc grr rbufna_rep float_formatheaderrlengthrrmax_rowsmin_rowss rrSeries.to_string rc grrrs rrr rrc [R"UUUUUUUUU U S9 n U R5n [U [5(d*[ S[ [U 5R535eUcU $[US5(aURU 5 g[USSS9n U RU 5 SSS5 g!,(df  g=f)a. Render a string representation of the Series. Parameters ---------- buf : StringIO-like, optional Buffer to write to. na_rep : str, optional String representation of NaN to use, default 'NaN'. float_format : one-parameter function, optional Formatter function to apply to columns' elements if they are floats, default None. header : bool, default True Add the Series header (index name). index : bool, optional Add index (row) labels, default True. length : bool, default False Add the Series length. dtype : bool, default False Add the Series dtype. name : bool, default False Add the Series name if not None. max_rows : int, optional Maximum number of rows to show before truncating. If None, show all. min_rows : int, optional The number of rows to display in a truncated repr (when number of rows is above `max_rows`). Returns ------- str or None String representation of Series if ``buf=None``, otherwise None. 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) rSeriesFormatterrrrrreprrrrropen)rrrrrrrrrrr formatterrdfs rrrsj'' %  $$&&#&&  $T&\%:%: ;<>  ;MsG$$ &!#sW5GGFO665s B;; C rstorage_optionsaExamples -------- >>> 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 | +----+----------+)rr examplesc JUR5R"U4X#US.UD6$)al Print {klass} in Markdown-friendly format. Parameters ---------- buf : str, Path or StringIO-like, optional, default None Buffer to write to. If None, the output is returned as a string. mode : str, optional Mode in which file is opened, "wt" by default. index : bool, optional, default True Add index (row) labels. {storage_options} **kwargs These parameters will be passed to `tabulate `_. Returns ------- str {klass} in Markdown-friendly format. Notes ----- Requires the `tabulate `_ package. {examples} )moderr )r to_markdown)rrrrr kwargss rrSeries.to_markdownns3H}}**   LR  rcR[[UR5[U55$)aj 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 )zipiterrrs ritems Series.itemss64 #T$Z00rcUR$)z Return alias for index. Returns ------- Index Index of the Series. Examples -------- >>> s = pd.Series([1, 2, 3], index=[0, 1, 2]) >>> s.keys() Index([0, 1, 2], dtype='int64') rHrs rr Series.keysszzrcgrrrintos rto_dictSeries.to_dict r)rcgrrrs rrrs rz3.0rr)version allowed_argsrc[R"U5n[UR5(d[ UR[ 5(aU"SUR 555$U"UR 55$)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. 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@# UHupU[U54v M g7fr)r/).0kvs r !Series.to_dict..sL|tq1.q12|s)rstandardize_mappingr5rrr:r)rrinto_cs rrrs^J((. 4:: & &*TZZ*P*PLtzz|LL L$**,' 'rcU[RLa(URnUc [S5nO[ U/5nO [ U/5nUR R U5nURX3RS9nURUSS9$)aa Convert Series to DataFrame. Parameters ---------- name : object, optional The passed name should substitute for the series name (if it has one). Returns ------- DataFrame DataFrame representation of Series. Examples -------- >>> s = pd.Series(["a", "b", "c"], ... name="vals") >>> s.to_frame() vals 0 a 1 b 2 c rrrr3) rrrr^r[r to_2d_mgrr rr6)rrrrr s rrSeries.to_frame#s|4 3>> !99D|'*-TFmGii!!'*  1 1#HH 1 EtJ77rc[US5nU(aUO&URU=(a [5(+5nXlU$)z Set the Series name. Parameters ---------- name : str inplace : bool Whether to modify `self` directly or return a copy. deep : bool|None, default None Whether to do a deep copy, a shallow copy, or Copy on Write(None) r)r(rrr)rrrrrs r _set_nameSeries._set_nameKs8&gy9d499T-O:M:O6O#P 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 >>> ser.groupby(["a", "b", "a", "b"]).mean() a 210.0 b 185.0 Name: Max Speed, dtype: float64 >>> ser.groupby(level=0).mean() Falcon 370.0 Parrot 25.0 Name: Max Speed, dtype: float64 >>> ser.groupby(ser > 100).mean() Max Speed False 25.0 True 370.0 Name: Max Speed, dtype: float64 **Grouping by Indexes** We can groupby different levels of a hierarchical index using the `level` parameter: >>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'], ... ['Captive', 'Wild', 'Captive', 'Wild']] >>> index = pd.MultiIndex.from_arrays(arrays, names=('Animal', 'Type')) >>> ser = pd.Series([390., 350., 30., 20.], index=index, name="Max Speed") >>> ser Animal Type Falcon Captive 390.0 Wild 350.0 Parrot Captive 30.0 Wild 20.0 Name: Max Speed, dtype: float64 >>> ser.groupby(level=0).mean() Animal Falcon 370.0 Parrot 25.0 Name: Max Speed, dtype: float64 >>> ser.groupby(level="Type").mean() Type Captive 210.0 Wild 185.0 Name: Max Speed, dtype: float64 We can also choose to include `NA` in group keys or not by defining `dropna` parameter, the default setting is `True`. >>> ser = pd.Series([1, 2, 3, 3], index=["a", 'a', 'b', np.nan]) >>> ser.groupby(level=0).sum() a 3 b 3 dtype: int64 >>> ser.groupby(level=0, dropna=False).sum() a 3 b 3 NaN 3 dtype: int64 >>> arrays = ['Falcon', 'Falcon', 'Parrot', 'Parrot'] >>> ser = pd.Series([390., 350., 30., 20.], index=arrays, name="Max Speed") >>> ser.groupby(["a", "b", "a", np.nan]).mean() a 210.0 b 350.0 Name: Max Speed, dtype: float64 >>> ser.groupby(["a", "b", "a", np.nan], dropna=False).mean() a 210.0 b 350.0 NaN 20.0 Name: Max Speed, dtype: float64 groupbyc SSKJn UcUc [S5eU(d [S5eURU5nU "UUUUUUUUUS9 $)Nrrz*You have to supply one of 'by' and 'level'z(as_index=False only valid with DataFrame) objrrras_indexsort group_keysobserveddropna)pandas.core.groupby.genericrr_get_axis_number) rbyrrr6r7r8r9r:rs rr3Series.groupby^sdB > =RZHI IFG G$$T*!  rcf[UR5R5RS5$)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)rArsumrrs rcount Series.counts'&T\\"&&(//88rc.URn[U[R5(a[R "X!S9nOUR US9nURU[[U55URSURS9RUSS9$)a Return the mode(s) of the Series. The mode is the value that appears most often. There can be multiple modes. Always returns Series even if only one value is returned. Parameters ---------- dropna : bool, default True Don't consider counts of NaN/NaT. Returns ------- Series Modes of the Series in sorted order. 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 )r:F)rrrrrr3) rrrrrCr_moderrangerrrr6)rr:rr7s rr Series.modesZ fbjj ) )#?JV4J  J(** ! ,tF, +  ,rc >[TU]5$)ay 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[ns] >>> 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[ns, US/Eastern] An Categorical will return categories in the order of appearance and with the same dtype. >>> pd.Series(pd.Categorical(list('baabc'))).unique() ['b', 'a', 'c'] Categories (3, object): ['a', 'b', 'c'] >>> pd.Series(pd.Categorical(list('baabc'), categories=list('abc'), ... ordered=True)).unique() ['b', 'a', 'c'] Categories (3, object): ['a' < 'b' < 'c'] )rrrrs rr Series.unique( s~w~r)keepr ignore_indexcgrrrrKrrLs rdrop_duplicatesSeries.drop_duplicatesi s r)rKrLcgrrrNs rrOrPs r rcgrrrNs rrOrPy r rfirstc>[US5n[TU] US9nU(a[[ U55UlU(aUR U5 gU$)uv 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: object With the 'keep' parameter, the selection behaviour of duplicated values can be changed. The value 'first' keeps the first occurrence for each set of duplicated entries. The default value of keep is 'first'. >>> s.drop_duplicates() 0 llama 1 cow 3 beetle 5 hippo Name: animal, dtype: object The value 'last' for parameter 'keep' keeps the last occurrence for each set of duplicated entries. >>> s.drop_duplicates(keep='last') 1 cow 3 beetle 4 llama 5 hippo Name: animal, dtype: object The value ``False`` for parameter 'keep' discards all sets of duplicated entries. >>> s.drop_duplicates(keep=False) 1 cow 3 beetle 5 hippo Name: animal, dtype: object rrKN)r(rrOr^rr_update_inplace)rrKrrLrdrs rrOrP sPj&gy9(d(3 (V5FL    (MrctURUS9nURX RSS9nURUSS9$)aw 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 rUFr1rr3) _duplicatedrrr6)rrKresrds rrSeries.duplicated sGXD)""3jju"E""4 "==rcURU5n[R"5 [R"S5 UR"X/UQ70UD6nSSS5 WS:XaO[R "S[ U5RS3[[5S9 URR$URU$!,(df  Nr=f)aa Return the row label of the minimum value. If multiple values equal the minimum, the first row label with that value is returned. Parameters ---------- axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. skipna : bool, default True Exclude NA/null values. If the entire Series is NA, the result will be NA. *args, **kwargs Additional arguments and keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- Index Label of the minimum value. Raises ------ ValueError If the Series is empty. See Also -------- numpy.argmin : Return indices of the minimum values along the given axis. DataFrame.idxmin : Return index of first occurrence of minimum over requested axis. Series.idxmax : Return index *label* of the first occurrence of maximum of values. Notes ----- This method is the Series version of ``ndarray.argmin``. This method returns the label of the minimum, while ``ndarray.argmin`` returns the position. To get the position, use ``series.values.argmin()``. Examples -------- >>> s = pd.Series(data=[1, None, 4, 1], ... index=['A', 'B', 'C', 'D']) >>> s A 1.0 B NaN C 4.0 D 1.0 dtype: float64 >>> s.idxmin() 'A' If `skipna` is False and there is an NA value in the data, the function returns ``nan``. >>> s.idxmin(skipna=False) nan rNrThe behavior of zu.idxmin with all-NA values, or any-NA and skipna=False, is deprecated. In a future version this will raise ValueErrorr) r<rcatch_warnings simplefilterargminrrrrr&r _na_valuerrriargsrrKs ridxmin Series.idxmin0 s~$$T*  $ $ &  ! !( + D:4:6:A ' 7 MM"4:#6#6"7855+-  ::'' 'zz!}#' & -C CcURU5n[R"5 [R"S5 UR"X/UQ70UD6nSSS5 WS:XaO[R "S[ U5RS3[[5S9 URR$URU$!,(df  Nr=f)ar Return the row label of the maximum value. If multiple values equal the maximum, the first row label with that value is returned. Parameters ---------- axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. skipna : bool, default True Exclude NA/null values. If the entire Series is NA, the result will be NA. *args, **kwargs Additional arguments and keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- Index Label of the maximum value. Raises ------ ValueError If the Series is empty. See Also -------- numpy.argmax : Return indices of the maximum values along the given axis. DataFrame.idxmax : Return index of first occurrence of maximum over requested axis. Series.idxmin : Return index *label* of the first occurrence of minimum of values. Notes ----- This method is the Series version of ``ndarray.argmax``. This method returns the label of the maximum, while ``ndarray.argmax`` returns the position. To get the position, use ``series.values.argmax()``. Examples -------- >>> s = pd.Series(data=[1, None, 4, 3, 4], ... index=['A', 'B', 'C', 'D', 'E']) >>> s A 1.0 B NaN C 4.0 D 3.0 E 4.0 dtype: float64 >>> s.idxmax() 'C' If `skipna` is False and there is an NA value in the data, the function returns ``nan``. >>> s.idxmax(skipna=False) nan rNrr\zu.idxmax with all-NA values, or any-NA and skipna=False, is deprecated. In a future version this will raise ValueErrorr) r<rr]r^argmaxrrrrr&rr`ras ridxmax Series.idxmax s@$$T*  $ $ &  ! !( + D:4:6:A ' 7 MM"4:#6#6"7855+-  ::'' 'zz!}#' &rec[R"X#5 URRU[ 5S9nUR XDR S9RUSS9$)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. Examples -------- >>> s = pd.Series([0.1, 1.3, 2.7]) >>> s.round() 0 0.0 1 1.0 2 3.0 dtype: float64 )decimals using_cowrroundr3)rvalidate_roundrrmrrrr6)rrkrbrrzs rrm Series.round s]@ $'))//8?R?T/U))' )ERR S  rcgrrrq interpolations rquantileSeries.quantile r rcgrrrqs rrtru  rcgrrrqs rrtru rwrcb[U5 UR5nURXSS9nURS:XaURSS2S4n[ U5(aCUR Ul[U[RS9nURXEUR S9$URS$)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(.5) 2.5 >>> s.quantile([.25, .5, .75]) 0.25 1.75 0.50 2.50 0.75 3.25 dtype: float64 F)rrrs numeric_onlyrNrr)rr) r)rrtndimrr4rr[rfloat64r)rrrrsr rdidxs rrtru s\ A]]_qER ;;! [[A&F ??))FK,C$$VTYY$G G;;q> !rcfURUSSS9upA[U5S:Xa[R$UR [ [RSS9nUR [ [RSS9nUS;d[ U5(a[R"XVX#S9$[SUS 35e) ae 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([.2, .0, .6, .2]) >>> s2 = pd.Series([.3, .6, .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 innerFjoinrrrna_valuer)pearsonspearmankendall)r4 min_periodszHmethod must be either 'pearson', 'spearman', 'kendall', or a callable, 'z' was supplied) alignrrnanto_numpyfloatcallablerGnancorrr)rotherr4rthis this_values other_valuess rcorr Series.corrS sLjjW5jA  t9>66Mmm%"&&umM ~~EBFF~O 7 78F;K;K>>&  x~ '  rrcURUSSS9upA[U5S:Xa[R$UR [ [RSS9nUR [ [RSS9n[ R"XVX#S9$)an 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 rFrrr)rddof)rrrrrrrGnancov)rrrrrrrs rcov Series.cov suNjjW5jA  t9>66Mmm%"&&umM ~~EBFF~O }} ;  rra Difference with previous row >>> s = pd.Series([1, 1, 2, 3, 5, 8]) >>> s.diff() 0 NaN 1 0.0 2 1.0 3 1.0 4 2.0 5 3.0 dtype: float64 Difference with 3rd previous row >>> s.diff(periods=3) 0 NaN 1 NaN 2 NaN 3 2.0 4 4.0 5 6.0 dtype: float64 Difference with following row >>> s.diff(periods=-1) 0 0.0 1 -1.0 2 -1.0 3 -2.0 4 -3.0 5 NaN dtype: float64 Overflow in input dtype >>> s = pd.Series([1, 0], dtype=np.uint8) >>> s.diff() 0 NaN 1 255.0 dtype: float64)r extra_params other_klassrc[R"URU5nURX RSS9R USS9$)aH First discrete difference of element. Calculates the difference of a {klass} element compared with another element in the {klass} (default is element in previous row). Parameters ---------- periods : int, default 1 Periods to shift for calculating difference, accepts negative values. {extra_params} Returns ------- {klass} First differences of the Series. See Also -------- {klass}.pct_change: Percent change over given number of periods. {klass}.shift: Shift index by desired number of periods with an optional time freq. {other_klass}.diff: First discrete difference of object. Notes ----- For boolean dtypes, this uses :meth:`operator.xor` rather than :meth:`operator.sub`. The result is calculated according to current dtype in {klass}, however dtype of the result is always float64. Examples -------- {examples} Fr1diffr3)rCrrrrr6)rperiodsrds rr Series.diff sKjw7  zz FSS T  rc^UR[[URU555$)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 )rrrshift)rlags rautocorrSeries.autocorr5 s#Vyyfdjjo677rc[U[[45(aURR UR5n[ U5[ UR5:d"[ U5[ UR5:a [ S5eURUSS9nURUSS9nURnURnOgURn[R"U5nURSURS:wa%[SURSUR35e[U[5(a=UR[R"XV5URSS9R!USS9$[U[5(a[R"XV5$[U[R"5(a[R"XV5$[%S ['U535e) a 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 alignedFr1rzDot product shape mismatch, z vs dotr3zunsupported type: )rrr<runionrrrrrr<shape Exceptionrrrr6rrr)rrrEleftrightlvalsrvalss rr Series.dotb sd efl3 4 4ZZ%%ekk2F6{S_,F c%++>N0N !;<<<? ?rc$URU5$z2 Matrix multiplication using binary `@` operator. )rrrs r __matmul__Series.__matmul__ sxxrcLUR[R"U55$r)rr transposers r __rmatmul__Series.__rmatmul__ sxx U+,,r)rc>[RRXX#S9$)N)sidesorter)rD IndexOpsMixin searchsorted)rrrrs rrSeries.searchsorted s !!..t.UUrcSSKJn [U[[45(aU/nUR U5 OX/n[ SUSS55(a Sn[U5eU"XRUS9$)Nrconcatc3D# UHn[U[45v M g7fr)rr<)r&xs rr)!Series._append.. sE}!z!l_--}s rzCto_append should be a Series or list/tuple of Series, got DataFrame)rLverify_integrity)pandas.core.reshape.concatrrrrextendrr)r to_appendrLrr to_concatmsgs r_appendSeries._append sn 6 i$ / /I   Y ')I Ey}E E EWCC.  CS  rcomparea Returns ------- Series or DataFrame If axis is 0 or 'index' the result will be a Series. The resulting index will be a MultiIndex with 'self' and 'other' stacked alternately at the inner level. If axis is 1 or 'columns' the result will be a DataFrame. It will have two columns namely 'self' and 'other'. See Also -------- DataFrame.compare : Compare with another DataFrame and show differences. Notes ----- Matching NaNs will not appear as a difference. Examples -------- >>> s1 = pd.Series(["a", "b", "c", "d", "e"]) >>> s2 = pd.Series(["a", "a", "c", "b", "e"]) Align the differences on columns >>> s1.compare(s2) self other 1 b a 3 d b Stack the differences on indices >>> s1.compare(s2, align_axis=0) 1 self b other a 3 self d other b dtype: object Keep all original rows >>> s1.compare(s2, keep_shape=True) self other 0 NaN NaN 1 b a 2 NaN NaN 3 d b 4 NaN NaN Keep all original rows and also all original values >>> s1.compare(s2, keep_shape=True, keep_equal=True) self other 0 a a 1 b a 2 c c 3 d b 4 e e c&>[TU]UUUUUS9$)N)r align_axis keep_shape keep_equal result_names)rr)rrrrrrrs rrSeries.compare s+Tw!!!%   rcUc[URSS9n[U[5(aURR UR5n[ R"X5n[R"[U5[S9n[R"SS9 [U5H1upxURX5n URX5n U"X5Xg'M3 SSS5 O|URn[R"[U5[S9n[R"SS9 URV s/sH o"X5PM sn USS&SSS5 UR n["R$"USS9n [UR[&[(45n [+XRU S9n UR-XUSS 9$!,(df  Nh=fs sn f!,(df  N=f) a Combine the Series with a Series or scalar according to `func`. Combine the Series and `other` using `func` to perform elementwise selection for combined Series. `fill_value` is assumed when value is missing at some index from one of the two objects being combined. Parameters ---------- other : Series or scalar The value(s) to be combined with the `Series`. func : function Function that takes two scalars as inputs and returns an element. fill_value : scalar, optional The value to assume when an index is missing from one Series or the other. The default specifies to use the appropriate NaN value for the underlying dtype of the Series. Returns ------- Series The result of combining the Series with the other object. See Also -------- Series.combine_first : Combine Series values, choosing the calling Series' values first. Examples -------- Consider 2 Datasets ``s1`` and ``s2`` containing highest clocked speeds of different birds. >>> s1 = pd.Series({'falcon': 330.0, 'eagle': 160.0}) >>> s1 falcon 330.0 eagle 160.0 dtype: float64 >>> s2 = pd.Series({'falcon': 345.0, 'eagle': 200.0, 'duck': 30.0}) >>> s2 falcon 345.0 eagle 200.0 duck 30.0 dtype: float64 Now, to combine the two datasets and view the highest speeds of the birds across the two datasets >>> s1.combine(s2, max) duck NaN eagle 200.0 falcon 345.0 dtype: float64 In the previous example, the resulting value for duck is missing, because the maximum of a NaN and a float is a NaN. So, in the example, we set ``fill_value=0``, so the maximum value returned will be the value from some dataset. >>> s1.combine(s2, max, fill_value=0) duck 30.0 eagle 200.0 falcon 345.0 dtype: float64 NFrrrall) try_float) same_dtyper})r@rrrrrrHget_op_result_nameremptyrrerrstate enumerategetrrrmaybe_convert_objectsrQr9r0r)rrfunc fill_valuerunew_namerrKr}lvrvnpvaluesrr7s rcombineSeries.combine, s|P  +DJJuEJ eV $ $ ((5I--d:H#i.?J*' 2FA#2B33B$(LJM3+* I#i.?J*;?<< H*G9G G> G G G"cSSKJn URUR:XaURR UR5(a UR UR 5U5$UR(aQ[UR[5(d2URUSS9up1UR UR 5U5$URRUR5nUnURRUR[U55nURRU5nURUSS9nURUSS9nURRS:Xa%URRS:wa [!U5nU"X1/5nURUSS9nUR#USS 9$) 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 rrouter)rFrM combine_firstr3)rrrrrrr?r rr;rr differencerArrrjr6)rrrrru keep_other keep_thiscombineds rrSeries.combine_first sdX 6 :: $zz  --yye44"":djj++N+N"jjWj= yye44JJ$$U[[1 [[++DJJuT{,CD JJ))*5 ||IE|2 ju 5 ::??c !ekk&6&6#&=&E4-(##IE#:$$T/$BBrc[(dL[5(a=[R"U5[::a[ R "[[SS9 O[(dx[5(diUR5(aT[R"U5n[n[U5(aUS- nX#::a[ R "[[SS9 [U[5(d [U5nURU5n[!U5nUR"R%XAS9UlUR'5 g)a  Modify Series in place using values from passed Series. Uses non-NA values from passed Series to make updates. Aligns on index. Parameters ---------- other : Series, or object coercible into Series Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s.update(pd.Series([4, 5, 6])) >>> s 0 4 1 5 2 6 dtype: int64 >>> s = pd.Series(['a', 'b', 'c']) >>> s.update(pd.Series(['d', 'e'], index=[0, 2])) >>> s 0 d 1 b 2 e dtype: object >>> s = pd.Series([1, 2, 3]) >>> s.update(pd.Series([4, 5, 6, 7, 8])) >>> s 0 4 1 5 2 6 dtype: int64 If ``other`` contains NaNs the corresponding values are not updated in the original Series. >>> s = pd.Series([1, 2, 3]) >>> s.update(pd.Series([4, np.nan, 6])) >>> s 0 4 1 2 2 6 dtype: int64 ``other`` can also be a non-Series object type that is coercible into a Series >>> s = pd.Series([1, 2, 3]) >>> s.update([4, np.nan, 6]) >>> s 0 4 1 2 2 6 dtype: int64 >>> s = pd.Series([1, 2, 3]) >>> s.update({1: 9}) >>> s 0 1 1 9 2 3 dtype: int64 rrr)rnewN)rrrrrrrrr_is_view_after_cow_rulesr!rrrr reindex_likerArputmaskr)rrrrrs rupdate Series.update sFt+--t$ 1 2*  1338U8U8W8W//$'C!IT""Q  :!  %((5ME""4(U|II%%4%;  !!#r)r ascendingrr na_positionrLrbcgrrrrrrrrrLrbs r sort_valuesSeries.sort_values= r)rrrrrLrbcgrrrs rrrKrrcgrrrs rrrYrr quicksortlastcj[US5nURU5 U(aUR(a [S5e[ U5(aC[ [ [U5n[U5S:wa[S[U5S35eUSn[U5nUS;a[SU35eU(a$[ [[X55RnO URn[X[U5U5n [U [U 55(a'U(aURU5$UR!S S 9$UR#URU UR$U S S 9n U(a['[U 55U lU(dU R)US S9$URU 5 g )uv 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 behaviour) >>> s.sort_values(ascending=True) 1 1.0 2 3.0 4 5.0 3 10.0 0 NaN dtype: float64 Sort values descending order >>> s.sort_values(ascending=False) 3 10.0 4 5.0 2 3.0 1 1.0 0 NaN dtype: float64 Sort values putting NAs first >>> s.sort_values(na_position='first') 0 NaN 1 1.0 2 3.0 4 5.0 3 10.0 dtype: float64 Sort a series of strings >>> s = pd.Series(['z', 'b', 'd', 'a', 'c']) >>> s 0 z 1 b 2 d 3 a 4 c dtype: object >>> s.sort_values() 3 a 1 b 4 c 2 d 0 z dtype: object Sort using a key function. Your `key` function will be given the ``Series`` of values and should return an array-like. >>> s = pd.Series(['a', 'B', 'c', 'D', 'e']) >>> s.sort_values() 1 B 3 D 0 a 2 c 4 e dtype: object >>> s.sort_values(key=lambda x: x.str.lower()) 0 a 1 B 2 c 3 D 4 e dtype: object NumPy ufuncs work well here. For example, we can sort by the ``sin`` of the value >>> s = pd.Series([-4, -2, 0, 2, 4]) >>> s.sort_values(key=np.sin) 1 -2 4 4 2 0 0 -4 3 2 dtype: int64 More complicated user-defined functions can be used, as long as they expect a Series and return an array-like >>> s.sort_values(key=lambda x: (np.tan(x.cumsum()))) 0 -4 3 2 4 4 1 -2 2 0 dtype: int64 rzRThis Series is a view of some other array, to sort in-place you must create a copyrzLength of ascending (z) must be 1 for Seriesr)rSrzinvalid na_position: NrFr1rr3)r(r<rrr4rrr_rr'rrgrrhrrVrrrr^r6) rrrrrrrLrbvalues_to_sort sorted_indexrds rrrgsr&gy9 d# t7   " "Xd^Y7I9~" +C N+;;QR"! I&y1 / /4[MBC C !&*;D*FGOON!\\Nd9o{S L#l*; < <++D1199$9' '"" LL &djj.FU#  (\):;FL&&tM&B B V$r)rrrrrsort_remainingrLrbc grr rrrrrrrrrLrbs r sort_indexSeries.sort_index0rr rrrrrrrrLrbc grrrs rrr@rrc grrrs rrrPrrc .>[T U]UUUUUUUUU S9 $)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: object Sort Descending >>> s.sort_index(ascending=False) 4 d 3 a 2 b 1 c dtype: object By default NaNs are put at the end, but use `na_position` to place them at the beginning >>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, np.nan]) >>> s.sort_index(na_position='first') NaN d 1.0 c 2.0 b 3.0 a dtype: object Specify index level to sort >>> arrays = [np.array(['qux', 'qux', 'foo', 'foo', ... 'baz', 'baz', 'bar', 'bar']), ... np.array(['two', 'one', 'two', 'one', ... 'two', 'one', 'two', 'one'])] >>> s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], index=arrays) >>> s.sort_index(level=1) bar one 8 baz one 6 foo one 4 qux one 2 bar two 7 baz two 5 foo two 3 qux two 1 dtype: int64 Does not sort by remaining levels when sorting by levels >>> s.sort_index(level=1, sort_remaining=False) qux one 2 foo one 4 baz one 6 bar one 8 qux two 1 foo two 3 baz two 5 bar two 7 dtype: int64 Apply a key function before sorting >>> s = pd.Series([1, 2, 3, 4], index=['A', 'b', 'C', 'd']) >>> s.sort_index(key=lambda x : x.str.lower()) A 1 b 2 C 3 d 4 dtype: int64 r)rr) rrrrrrrrrLrbrs rrr`s8Jw!#)%"  rcUS:waURU5 URn[U5nUR5(al[R "S[ [5S9 [R"[U5S[RS9nU)n[R"XXUS9Xx'O[R"XRS9nURXpRUR[RSS9n U R!USS 9$) 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 rzThe behavior of Series.argsort in the presence of NA values is deprecated. In a future version, NA values will be ordered last instead of set to -1.rrrF)rrrrargsortr3)r<rr?rrrrr&rfullrintpr rrrr6) rrrr'stablerrrdnotmaskrYs rr Series.argsortsX 2:  ! !$ 'F| 88:: MM-+-  WWSY"'':FeG jjtDFOZZ2F **499BGG%  Y77rcH[R"XUS9R5$)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 nrK)re SelectNSeriesnlargestrrrKs rrSeries.nlargest:s!D$$TT:CCEErcH[R"XUS9R5$)ag 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)rer nsmallestrs rrSeries.nsmallests!B$$TT:DDFFracopy : bool, default True Whether to copy underlying data. .. note:: The `copy` keyword will change behavior in pandas 3.0. `Copy-on-Write `__ will be enabled by default, which means that all methods with a `copy` keyword will use a lazy copy mechanism to defer the copy and ignore the `copy` keyword. The `copy` keyword will be removed in a future version of pandas. You can already get the future behavior and improvements through enabling copy on write ``pd.options.mode.copy_on_write = True``a Examples -------- >>> s = pd.Series( ... ["A", "B", "A", "C"], ... index=[ ... ["Final exam", "Final exam", "Coursework", "Coursework"], ... ["History", "Geography", "History", "Geography"], ... ["January", "February", "March", "April"], ... ], ... ) >>> s Final exam History January A Geography February B Coursework History March A Geography April C dtype: object In the following example, we will swap the levels of the indices. Here, we will swap the levels column-wise, but levels can be swapped row-wise in a similar manner. Note that column-wise is the default behaviour. By not supplying any arguments for i and j, we swap the last and second to last indices. >>> s.swaplevel() Final exam January History A February Geography B Coursework March History A April Geography C dtype: object By supplying one argument, we can choose which index to swap the last index with. We can for example swap the first index with the last one as follows. >>> s.swaplevel(0) January History Final exam A February Geography Final exam B March History Coursework A April Geography Coursework C dtype: object We can also define explicitly which indices we want to swap by supplying values for both i and j. Here, we for example swap the first and second indices. >>> s.swaplevel(0, 1) History Final exam January A Geography Final exam February B History Coursework March A Geography Coursework April C dtype: object)rrrc[UR[5(deURU=(a [ 5(+S9nURR X5UlU$)a> Swap levels i and j in a :class:`MultiIndex`. Default is to swap the two innermost levels of the index. Parameters ---------- i, j : int or str Levels of the indices to be swapped. Can pass level name as string. {extra_params} Returns ------- {klass} {klass} with levels swapped in MultiIndex. {examples} r)rrr\rr swaplevel)rrKjrrds rrSeries.swaplevelsSz$**j1111 B-@-B)BCzz++A1  rc[UR[5(d [S5eUR SS9n[UR[5(deURR U5UlU$)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 ------- type of caller (new object) 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.Nr)rrr\rrreorder_levels)rr'rds rr"Series.reorder_levelscsdJ$**j11MN N%&,, 3333||2259  rc0[UR[5(aURR 5up#O[ U5(aQ[ UR5(a7[R"[R"UR55up#O(UR5nU(aURSS9$U$U(a[[ U55nOURRU5nUR!X%UR"SS9$)u 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 a np.nan for that row. In addition, the ordering of elements in the output will be non-deterministic when exploding sets. Reference :ref:`the user guide ` 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)rFr})rrr:r_exploderr5rexploderr<rrr^rrrr)rrLrcountsrdrs rr&Series.explodesj djj. 1 1!\\224NFF YY?4::66$__RZZ -EFNFFYY[F4@6%%4%0 Lf L (V5EJJ%%f-E  4995 QQrc SSKJn U"XX#5$)af 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. 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*)rrrr7r*s rr*Series.unstacksb 8tJ55rcpURXS9nURX0RSS9RUSS9$)aS Map values of Series according to an input mapping or function. Used for substituting each value in a Series with another value, that may be derived from a function, a ``dict`` or a :class:`Series`. Parameters ---------- arg : function, collections.abc.Mapping subclass or Series Mapping correspondence. na_action : {None, 'ignore'}, default None If 'ignore', propagate NaN values, without passing them to the mapping correspondence. Returns ------- Series Same index as caller. See Also -------- Series.apply : For applying more complex functions on a Series. 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: object ``map`` accepts a ``dict`` or a ``Series``. Values that are not found in the ``dict`` are converted to ``NaN``, unless the dict has a default value (e.g. ``defaultdict``): >>> s.map({'cat': 'kitten', 'dog': 'puppy'}) 0 kitten 1 puppy 2 NaN 3 NaN dtype: object It also accepts a function: >>> s.map('I am a {}'.format) 0 I am a cat 1 I am a dog 2 I am a nan 3 I am a rabbit dtype: object To avoid applying the function to missing values (and keep them as ``NaN``) ``na_action='ignore'`` can be used: >>> s.map('I am a {}'.format, na_action='ignore') 0 I am a cat 1 I am a dog 2 NaN 3 I am a rabbit dtype: object ) na_actionFr1mapr3) _map_valuesrrr6)rargr.rs rr/ Series.map sJ`%%c%?   ::E JWW X  rcU$)z Sub-classes to define. Return a sliced object. Parameters ---------- key : string / list of selections ndim : {1, 2} Requested ndim of result. subset : object, default None Subset to act on. r)rrbr{subsets r_gotitemSeries._gotitemas  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 aggregate)rrsee_alsorcURU5 Uc[UR55n[XX4S9nUR 5nU$)N)rbr)r<dictrrKagg)rrrrbroprds rr7Series.aggregatesE d# < 'D $ > r transform)rrcURU5 [5(d[5(aURSS9OUn[ XQX4S9R 5nU$)NFr)rrbr)r<rrrrKr>)rrrrbrrrds rr>Series.transformsZ d##$$(:(<(< II5I ! S$FPPR rrr)by_rowc :[UUUUUUS9R5$)a Invoke function on values of Series. Can be ufunc (a NumPy function that applies to the entire Series) or a Python function that only works on single values. Parameters ---------- func : function Python function or NumPy ufunc to apply. convert_dtype : bool, default True Try to find better dtype for elementwise function results. If False, leave as dtype=object. Note that the dtype is always preserved for some extension array dtypes, such as Categorical. .. deprecated:: 2.1.0 ``convert_dtype`` has been deprecated. Do ``ser.astype(object).apply()`` instead if you want ``convert_dtype=False``. 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 ) convert_dtyperArbr)rKapply)rrrCrbrArs rrD Series.applys-@  '   %' rc*Uc`Ub$URURR:Xa9[5(aURUS9$U(dUcURUS9$U$[R "UR USSS9nURXASS9$)NrT) allow_fillrFr1)namesrrrrCtake_ndrr)rrurtrrs r_reindex_indexerSeries._reindex_indexer>s ?  DJJ4D4D!D"$$yydy++t|yydy++K'' LL'dt   5 IIrcg)zK Check if we do need a multi reindex; this is for compat with higher dims. Fr)rrr4rs r_needs_reindex_multiSeries._needs_reindex_multiTs r)rrrrcgrrrrrrrrrs rrename Series.rename[ r)rrrrrcgrrrPs rrQrRhrSrcgrrrPs rrQrRurSrrc>UbURU5n[U5(d[U5(a[TU]UUUUUS9$UR XUS9$)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 True Also copy underlying data. .. note:: The `copy` keyword will change behavior in pandas 3.0. `Copy-on-Write `__ will be enabled by default, which means that all methods with a `copy` keyword will use a lazy copy mechanism to defer the copy and ignore the `copy` keyword. The `copy` keyword will be removed in a future version of pandas. You can already get the future behavior and improvements through enabling copy on write ``pd.options.mode.copy_on_write = True`` inplace : bool, default False Whether to return a new Series. If True the value of copy is ignored. level : int or level name, default None In case of MultiIndex, only rename labels in the specified level. errors : {'ignore', 'raise'}, default 'ignore' If 'raise', raise `KeyError` when a `dict-like mapper` or `index` contains labels that are not present in the index being transformed. If 'ignore', existing keys will be renamed and extra keys will be ignored. Returns ------- Series or None Series with index labels or name altered or None if ``inplace=True``. See Also -------- DataFrame.rename : Corresponding DataFrame method. Series.rename_axis : Set the name of the axis. Examples -------- >>> s = pd.Series([1, 2, 3]) >>> s 0 1 1 2 2 3 dtype: int64 >>> s.rename("my_name") # scalar, changes Series.name 0 1 1 2 2 3 Name: my_name, dtype: int64 >>> s.rename(lambda x: x ** 2) # function, changes labels 0 1 1 2 4 3 dtype: int64 >>> s.rename({1: 3, 2: 5}) # mapping, changes labels 0 1 3 2 5 3 dtype: int64 )rrrr)rr)r<rr1r_renamer1)rrrrrrrrs rrQrRskn  ((.D E??l511 7? # >>%t>D Dra 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)rrextended_summary_subaxis_description_sub see_also_subrrc >[TU]XUS9$)Nr[)rset_axis)rlabelsrrrs rr]Series.set_axissBw==rr)rr)rr4rrrlimit tolerancec *>[T U]UUUUUUUS9$)N)rr4rrrr`ra)rr) rrrr4rrrr`rars rrSeries.reindexs0"w!  r)rrrcgrrrmapperrrrrs r rename_axisSeries.rename_axis+rr)rrrrcgrrres rrgrh7rrcgrrres rrgrhCrrc&>[TU]UUUUUS9$)N)rfrrrr)rrg)rrfrrrrrs rrgrhOs+w" #  r)rrrrrcgrrrr^rrrrrrs rr Series.droparr)rrrrrrcgrrrms rrrnorrcgrrrms rrrn}rrraisec *>[TU]UUUUUUUS9$)a2 Return Series with specified index labels removed. Remove elements of a Series based on specifying the index labels. When using a multi-index, labels on different levels can be removed by specifying the level. Parameters ---------- labels : single label or list-like Index labels to drop. axis : {0 or 'index'} Unused. Parameter needed for compatibility with DataFrame. index : single label or list-like Redundant for application on Series, but 'index' can be used instead of 'labels'. columns : single label or list-like No change is made to the Series; use 'index' or 'labels' instead. level : int or level name, optional For MultiIndex, level for which the labels will be removed. inplace : bool, default False If True, do operation inplace and return None. errors : {'ignore', 'raise'}, default 'raise' If 'ignore', suppress error and only existing labels are dropped. Returns ------- Series or None Series with specified index labels removed or None if ``inplace=True``. Raises ------ KeyError If none of the labels are found in the index. See Also -------- Series.reindex : Return only specified index labels of Series. Series.dropna : Return series without null values. Series.drop_duplicates : Return Series with duplicate values removed. DataFrame.drop : Drop specified labels from rows or columns. Examples -------- >>> s = pd.Series(data=np.arange(3), index=['A', 'B', 'C']) >>> s A 0 B 1 C 2 dtype: int64 Drop labels B en C >>> s.drop(labels=['B', 'C']) A 0 dtype: int64 Drop 2nd level label in MultiIndex Series >>> midx = pd.MultiIndex(levels=[['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 )r^rrrrrr)rr) rr^rrrrrrrs rrrns1Bw|  rc>[TU]US9$)a3 Return item and drops from series. Raise KeyError if not found. Parameters ---------- item : label Index of the element that needs to be removed. Returns ------- Value that is popped from series. Examples -------- >>> ser = pd.Series([1, 2, 3]) >>> ser.pop(0) 1 >>> ser 1 2 2 3 dtype: int64 )r)rr)rrrs rr Series.pops2w{{%%rc8[X5RUUUUS9$)N)rmax_colsverbose show_counts)rlrender)rrwrrv memory_usagerxs rinfo Series.infos-$-44# 5  rcU(aUOUR5nURn[R"Xa5n[ U[ 5(aUR X$U5 O[R"U5nU"XdUS9 U(agU$)zv Replaces values in a Series using the fill method specified when no replacement value is given in the replace method )r`rN)rrrF mask_missingrrL_fill_mask_inplace get_fill_func) r to_replacer4rr`rdrrfill_fs r_replace_singleSeries._replace_single"sn !diik##F7 fn - -  % %fT :**62F 6T 2   rchURUS9nU(aX0RRUS9- nU$)a  Return the memory usage of the Series. The memory usage can optionally include the contribution of the index and of elements of `object` dtype. Parameters ---------- index : bool, default True Specifies whether to include the memory usage of the Series index. deep : bool, default False If True, introspect the data deeply by interrogating `object` dtypes for system-level memory consumption, and include it in the returned value. Returns ------- int Bytes of memory consumed. See Also -------- numpy.ndarray.nbytes : Total bytes consumed by the elements of the array. DataFrame.memory_usage : Bytes consumed by a DataFrame. Examples -------- >>> s = pd.Series(range(3)) >>> s.memory_usage() 152 Not including the index gives the size of the rest of the data, which is necessarily smaller: >>> s.memory_usage(index=False) 24 The memory footprint of `object` values is ignored by default: >>> s = pd.Series(["a", "b"]) >>> s.values array(['a', 'b'], dtype=object) >>> s.memory_usage() 144 >>> s.memory_usage(deep=True) 244 r) _memory_usagerrz)rrrr(s rrzSeries.memory_usage8s:b   D  )  ((d(3 3Arc[R"URU5nURX RSS9R USS9$)a Whether elements in Series are contained in `values`. Return a boolean Series showing whether each element in the Series matches an element in the passed sequence of `values` exactly. Parameters ---------- values : set or list-like The sequence of values to test. Passing in a single string will raise a ``TypeError``. Instead, turn a single string into a list of one element. Returns ------- Series Series of booleans indicating if each element is in values. Raises ------ TypeError * If `values` is a string See Also -------- DataFrame.isin : Equivalent method on DataFrame. Examples -------- >>> s = pd.Series(['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 Fr1isinr3)rCrrrrr6)rrrds rr Series.isinnsKRv6  zz FSS T  rcUS:Xa X:nX:*nXE-$US:Xa X:nX:nXE-$US:Xa X:nX:*nXE-$US:Xa X:nX:nXE-$[S5e)aU Return boolean Series equivalent to left <= series <= right. This function returns a boolean vector containing `True` wherever the corresponding Series element is between the boundary values `left` and `right`. NA values are treated as `False`. Parameters ---------- left : scalar or list-like Left boundary. right : scalar or list-like Right boundary. inclusive : {"both", "neither", "left", "right"} Include boundaries. Whether to set each bound as closed or open. .. versionchanged:: 1.3.0 Returns ------- Series Series representing whether each element is between left and right (inclusive). See Also -------- Series.gt : Greater than of series and other. Series.lt : Less than of series and other. Notes ----- This function is equivalent to ``(left <= ser) & (ser <= right)`` Examples -------- >>> s = pd.Series([2, 0, 4, 8, np.nan]) Boundary values are included by default: >>> s.between(1, 4) 0 True 1 False 2 True 3 False 4 False dtype: bool With `inclusive` set to ``"neither"`` boundary values are excluded: >>> s.between(1, 4, inclusive="neither") 0 True 1 False 2 False 3 False 4 False dtype: bool `left` and `right` can be any scalar value: >>> s = pd.Series(['Alice', 'Bob', 'Carol', 'Eve']) >>> s.between('Anna', 'Daniel') 0 False 1 True 2 True 3 False dtype: bool bothrrneitherzJInclusive has to be either string of 'both','left', 'right', or 'neither'.)r)rrr inclusivelmaskrmasks rbetweenSeries.betweensR  LEME }& LELE}' !KEME}) #KELE} 1 rc [U[5(d[S[U535eU(d [ S5e[ U5H_up#[U[ 5(d[SUS[U5S35e[U5S:wdMF[ SUS[U5S35e UVVs/sH1upE[R"X@5[R"XP54PM3 nnnUR5n[U6upx/UQUPV s/sHn [U 5SPM n n [[U 55S :a[U 5n /n [Xx5HkupE[U5(a[!U[U5U S 9nO0[U["5(aUR%U 5nO ['X[S 9nU R)U5 Mm U nUR%U 5n[+[-[U555n [XS S S 2US S S 25HupnUR/XESSS S9nM U$s snnfs sn f![0an[ SUSUS35UeS nAff=f)a Replace values where the conditions are True. Parameters ---------- caselist : A list of tuples of conditions and expected replacements Takes the form: ``(condition0, replacement0)``, ``(condition1, replacement1)``, ... . ``condition`` should be a 1-D boolean array-like object or a callable. If ``condition`` is a callable, it is computed on the Series and should return a boolean Series or array. The callable must not change the input Series (though pandas doesn`t check it). ``replacement`` should be a 1-D array-like object, a scalar or a callable. If ``replacement`` is a callable, it is computed on the Series and should return a scalar or Series. The callable must not change the input Series (though pandas doesn`t check it). .. versionadded:: 2.2.0 Returns ------- Series See Also -------- Series.mask : Replace values where the condition is True. Examples -------- >>> 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 rr)rrrrNrF)rrrrzFailed to apply conditionz and replacement)rrrrrrrrrrVrrr.setr-r6r,r=rpd_arrayappendreversedrFrr)rcaselistnumentry condition replacementdefault conditions replacementsr1 common_dtypes common_dtypeupdated_replacementscounterpositionerrors r case_whenSeries.case_whensj(D))FtH~FVW 4  $H-JCeU++u$B4;-qQ5zQ u%**-e*Q8 . +3  +3& %%i6%%k8 +3  ))+#&> =U|=UW=UV=Uc)#.q1=U V s=! "Q &+M:L#% *-j*G& [))"D)#i. #K Y77"-"4"4\"BK"*;"KK$++K8+H0Lnn\2G5Z1203 "%|DbD'91 ,H !,,q%t' 1 M W2  /z9I(STU s$28H/H5H:: IIIc.[R"U5$r)rUr?rs rr? Series.isnas||D!!rc >[TU]5$)z, Series.isnull is an alias for Series.isna. )risnullrIs rr Series.isnulls w~rc >[TU]5$r)rrArIs rrA Series.notnasw}rc >[TU]5$)z. Series.notnull is an alias for Series.notna. )rnotnullrIs rrSeries.notnulls w  r)rrhowrLcgrrrrrrrLs rr: Series.dropna r)rrrLcgrrrs rr:rrrcF[US5n[US5nURU=(d S5 UR(a [U5nOU(dUR SS9nOUnU(a[ [ U55UlU(aURU5$U$)ur 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., 2., np.nan]) >>> ser 0 1.0 1 2.0 2 NaN dtype: float64 Drop NA values from a Series. >>> ser.dropna() 0 1.0 1 2.0 dtype: float64 Empty strings are not considered NA values. ``None`` is considered an NA value. >>> ser = pd.Series([np.nan, 2, pd.NaT, '', None, 'I stay']) >>> ser 0 NaN 1 2 2 NaT 3 4 None 5 I stay dtype: object >>> ser.dropna() 1 2 3 5 I stay dtype: object rrLrNr) r(r<r rBrr^rrrV)rrrrrLrds rr:rsT&gy9*<H  dia(   (.F- (V5FL ''/ /Mrc0[UR[5(d+[S[ UR5R 35eUR U=(a [5(+S9nURRXS9n[USU5 U$)a Cast to DatetimeIndex of Timestamps, at *beginning* of period. Parameters ---------- freq : str, default frequency of PeriodIndex Desired frequency. how : {'s', 'e', 'start', 'end'} Convention for converting period to timestamp; start of period vs. end. copy : bool, default True Whether or not to return a copy. .. note:: The `copy` keyword will change behavior in pandas 3.0. `Copy-on-Write `__ will be enabled by default, which means that all methods with a `copy` keyword will use a lazy copy mechanism to defer the copy and ignore the `copy` keyword. The `copy` keyword will be removed in a future version of pandas. You can already get the future behavior and improvements through enabling copy on write ``pd.options.mode.copy_on_write = True`` Returns ------- Series with DatetimeIndex Examples -------- >>> idx = pd.PeriodIndex(['2023', '2024', '2025'], freq='Y') >>> s1 = pd.Series([1, 2, 3], index=idx) >>> s1 2023 1 2024 2 2025 3 Freq: 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 r)freqrr) rrr]rrrrr to_timestampsetattr)rrrrnew_objrus rrSeries.to_timestamps}@$**k22/TZZ0@0I0I/JKL L))!C.A.C*C)DJJ+++? ),rc0[UR[5(d+[S[ UR5R 35eUR U=(a [5(+S9nURRUS9n[USU5 U$)a Convert Series from DatetimeIndex to PeriodIndex. Parameters ---------- freq : str, default None Frequency associated with the PeriodIndex. copy : bool, default True Whether or not to return a copy. .. note:: The `copy` keyword will change behavior in pandas 3.0. `Copy-on-Write `__ will be enabled by default, which means that all methods with a `copy` keyword will use a lazy copy mechanism to defer the copy and ignore the `copy` keyword. The `copy` keyword will be removed in a future version of pandas. You can already get the future behavior and improvements through enabling copy on write ``pd.options.mode.copy_on_write = True`` Returns ------- Series Series with index converted to PeriodIndex. Examples -------- >>> idx = pd.DatetimeIndex(['2023', '2024', '2025']) >>> s = pd.Series([1, 2, 3], index=idx) >>> s = s.to_period() >>> s 2023 1 2024 2 2025 3 Freq: Y-DEC, dtype: int64 Viewing the index >>> s.index PeriodIndex(['2023', '2024', '2025'], dtype='period[Y-DEC]') rr)rr) rrrZrrrrr to_periodr)rrrrrus rrSeries.to_periodfs}X$**m44/TZZ0@0I0I/JKL L))!C.A.C*C)DJJ((d(3 ),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[R"X5n[U[5(a!UR U5(d [ S5eUR n[USSS9n[R"XEU5nURXcS9$)Nz3Can only compare identically-labeled Series objectsT extract_numpy extract_ranger) rHrrr _indexed_samerrrS comparison_op_construct_resultrrr<res_namelvaluesrvaluesr7s r _cmp_methodSeries._cmp_methodsx))$6 eV $ $T-?-?-F-FRS S,,TN&&w< %%j%@@rc[R"X5nURUSS9upURn[ USSS9n[R "XEU5nUR XcS9$)NT)align_asobjectrr)rHr _align_for_oprrS logical_oprrs r_logical_methodSeries._logical_methodsd))$6((t(D ,,TN^^Gb9 %%j%@@rchURU5up[RRXU5$r)rrDr _arith_method)rrr<s rrSeries._arith_methods-((/ !!//R@@rcUn[U[5(aURRUR5(dU(aUR[ [ R4;d$UR[ [ R4;a"[R"S[[5S9 UR[ 5nUR[ 5nURUSS9up1X14$)zalign lhs and rhs SerieszOperation between non boolean Series with different indexes will no longer return a boolean result in a future version. Cast both Series to object type to maintain the prior behavior.rFr)rrrrrrrbool_rrrr&rr)rrrrs rrSeries._align_for_ops  eV $ $::$$U[[11!zz&"(();;u{{S@! >*'7'9  ;;v.D!LL0E"jjUj; {rcUnURRUR5(dURXSSS9upQ[R"UR UR U5upg[ R"SS9 U"Xg5nSSS5 [R"X5n URWU 5n [[U 5$!,(df  NF=f)a 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 rF)rrrrrN) rrrrH fill_binoprrrrrrr) rrrrrr this_vals other_valsrdrrQs r_binop Series._binops&zz  --**UgE*RKD #t||U]]J W [[X &)0F'%%d2$$VT2FC  ' &s  C  Cc\[U[5(aWURUSUS9nURUSUS9n[U[5(de[U[5(deX44$[ USS5nUR XR USS9nURU5nX&lU$)z Construct an appropriately-labelled Series from the result of an op. Parameters ---------- result : ndarray or ExtensionArray name : Label Returns ------- Series In the case of __divmod__ or __rdivmod__, a 2-tuple of Series. rrrrNF)rrr) rrrrrrrr6r)rrdrres1res2rrQs rrSeries._construct_result9s fe $ $))&)$)?D))&)$)?DdF++ ++dF++ ++< .jjERt$ rrrrcUbURU5 [R"X5n[U[5(aUR XX4S9$[U[ R[[45(aU[U5[U5:wa [S5eURXRSS9nUR XX4S9nXglU$Ub)[U5(aU"X5$UR!U5nU"X5$)N)rrzLengths must be equalFr)r<rHrrrrrrrrrrrrrr?fillna)rrr<rrrrrds r _flex_methodSeries._flex_method_s    ! !$ '))$6 eV $ $;;u;M M  D%8 9 95zSY& !899%%eZZe%DE[[%[OF#LM%;;d//{{:.d? "reqcBURU[RX#US9$Nr)roperatorrrrrrrs rr Series.eqvs)  8;;e!  rnecBURU[RX#US9$r)rrrrs rr Series.ne'  8;;e!  rlecBURU[RX#US9$r)rrrrs rr Series.lerrltcBURU[RX#US9$r)rrrrs rr Series.ltrrgecBURU[RX#US9$r)rrrrs rr Series.gerrgtcBURU[RX#US9$r)rrrrs rr Series.gtrraddcBURU[RX#US9$r)rrrrs rr Series.add'  8<>D!  rsubcBURU[RX#US9$r)rrrrs rr Series.subr rrsubcBURU[RX#US9$r)rrIrrs rr Series.rsubrrmulcBURU[RX#US9$r)rrrrs rr Series.muls)  8<)>)*HdV#3H:Q|nM//h6v66 6rr)r{)rr=ric [R"SUSS9 [USSS9 UR[R SUUUSS9$) NrrfnameriF none_allowedr_rrrzrir:)rvalidate_logical_funcr(r?rGnananyrrr=rirs rr Series.any;sN   V59FH5A|| MM"   rrc [R"SUSS9 [USSS9 UR[R SUUUSS9$) NrrrEriFrGr_rI)rrJr(r?rGnanallrLs rr Series.allPsN   V59FH5A|| MM"   rminc 2[R"XX#40UD6$r)rUrQrrrirzrs rrQ Series.minc{{4vFvFFrmaxc 2[R"XX#40UD6$r)rUrVrSs rrV Series.maxmrUrrAc 4[R"XX#U40UD6$r)rUrArrrirz min_countrs rrA Series.sumws{{4vYQ&QQrprodc 4[R"XX#U40UD6$r)rUr]rZs rr] Series.prods||DiR6RRrmeanc 2[R"XX#40UD6$r)rUr`rSs rr` Series.mean||DGGGrmedianc 2[R"XX#40UD6$r)rUrdrSs rrd Series.medians~~d&I&IIrsemc 4[R"XX#U40UD6$r)rUrgrrrirrzrs rrg Series.sem{{4v\LVLLrvarc 4[R"XX#U40UD6$r)rUrlris rrl Series.varrkrstdc 4[R"XX#U40UD6$r)rUroris rro Series.stdrkrskewc 2[R"XX#40UD6$r)rUrrrSs rrr Series.skewrcrkurtc 2[R"XX#40UD6$r)rUrurSs rru Series.kurtrcrcumminc8[R"XU/UQ70UD6$r)rUrxrrrirbrs rrx Series.cummin~~d&B4B6BBrcummaxc8[R"XU/UQ70UD6$r)rUr}rzs rr} Series.cummaxr|rcumsumc8[R"XU/UQ70UD6$r)rUrrzs rr Series.cumsumr|rcumprodc8[R"XU/UQ70UD6$r)rUrrzs rrSeries.cumprodst6CDCFCCr)rrrr)r Dtype | Noner bool | Nonerbool | lib.NoDefaultreturnNone)NN)rrr Index | NonerzDtypeObj | None)rzCallable[..., Series])rzCallable[..., DataFrame])rr_)rrx)rr)rrrr)rzBlockValuesRefs | None)rrL)C)r'rrrr)rintr)rrrr)rznpt.DTypeLike | Nonerrrr)r@ str | Nonerr )rz list[Index])r)rKrrrtrr )rPrZrrtrr)rbr)rtznpt.NDArray[np.bool_]rr)F)rr_)rr)T)rr_rr)rr_rr)FTF)rr_rr_rr_rr)rzint | Sequence[int]rrrr).) rr}rLiteral[False]rr~rrrr_rr) rr}r Literal[True]rr~rrrr_rr) rr}rr_rr~rrrr_rr) rIndexLabel | Nonerr_rr~rr_rr_rzDataFrame | Series | None)rr) ..........)rrrrrrrr_rr_rr_r int | Nonerrrr) .........)rzFilePath | WriteBuffer[str]rrrrrr_rr_rr_rrrrrr) NNaNNTTFFFNN)rz"FilePath | WriteBuffer[str] | Nonerrrrrr_rr_rr_rr_rr_rrrrrr)NwtTN) rIO[str] | Nonerrrr_r zStorageOptions | Nonerr)rzIterable[tuple[Hashable, Any]])rr[)rz'type[MutableMappingT] | MutableMappingTrr)rz type[dict]rr:)rrrr)FN)rr_rrrr)rrsrrr6r_r7r_r8r_r9rr:r_rr)r:r_rr)rrr)rKrvrrrLr_rr)rKrvrrrLr_rr)rKrvrr_rLr_r Series | None)rS)rKrvrr)rT)rrsrir_rr)rkrrr)..)rrrrsrrr)rrzSequence[float] | AnyArrayLikersrrr)rrz&float | Sequence[float] | AnyArrayLikersrrzfloat | Series)g?linear)rN)rrr4rurrrr)Nr)rrrrrrrr)r)rrrr)rrrr)rrqrzSeries | np.ndarray)rN)rz$NumpyValueArrayLike | ExtensionArrayrzLiteral['left', 'right']rzNumpySorter | Nonerznpt.NDArray[np.intp] | np.intp)FF)rLr_rr_)rFFr) rrrrsrr_rr_rrrDataFrame | Series)rzSeries | Hashablerz(Callable[[Hashable, Hashable], Hashable]rHashable | Nonerr)rr)rzSeries | Sequence | Mappingrr)rrsrbool | Sequence[bool]rrrrrrrLr_rbrrr)rrsrrrrrrrrrLr_rbrrr)rrsrrrr_rrrrrLr_rbrrr)rrsrrrr_rrrrrLr_rbzValueKeyFunc | Nonerr)rrsrr}rrrrrrrrrr_rLr_rbr|rr)rrsrr}rrrrrrrrrr_rLr_rbr|rr)rrsrr}rrrr_rrrrrr_rLr_rbr|rr)rrsrrrrrr_rrrrrr_rLr_rbzIndexKeyFunc | Nonerr)rrNN) rrsrrr'rrrrr)rS)rrrKzLiteral['first', 'last', 'all']rr)rN)rKr~rr~rrrr)r'zSequence[Level]rr)rLr_rr)rNT)rr}rrr7r_rr)r1zCallable | Mapping | Seriesr.zLiteral['ignore'] | Nonerr)rr)Nr)rrs)rrorrsrr) rrorCrrbztuple[Any, ...]rAzLiteral[False, 'compat']rr)rurrtznpt.NDArray[np.intp] | Nonerrrr)rRenamer | Hashable | Noner Axis | Nonerr_rrr Level | Nonerr{rr)rrrrrr_rrrrrr{rr)rrrrrr_rr_rrrr{rr)rrrrrrrr_rrrr{rr)rrsrrrr)rrr4zReindexMethod | Nonerrrrrz Scalar | Noner`rrr) rfIndexLabel | lib.NoDefaultrrsrr_rrrr) rfrrrsrr_rrrr) rfrrrsrr_rr_rz Self | None)r^r}rrsrr}rr}rrrrrr{rr)r^r}rrsrr}rr}rrrrrr{rr)r^r}rrsrr}rr}rrrr_rr{rr)r^rrrsrrrrrrrr_rr{rr)rrrr )NNNNT) rwrrrrvrrzzbool | str | Nonerxr_rr)r4rrr_)TF)rr_rr_rr)r)rz+Literal['both', 'neither', 'left', 'right']rr)rzlist[tuple[ArrayLike | Callable[[Series], Series | np.ndarray | Sequence[bool]], ArrayLike | Scalar | Callable[[Series], Series | np.ndarray]],]rr) rrsrrr AnyAll | NonerLr_rr) rrsrrrrrLr_rr) rrsrr_rrrLr_rr)NstartN)rzFrequency | Nonerz!Literal['s', 'e', 'start', 'end']rrrr)rrrrrr)rr_)rrrr)rdz'ArrayLike | tuple[ArrayLike, ArrayLike]rrrzSeries | tuple[Series, Series])NNr)rrrz float | Nonerrsrr)rrsrr)rrrrsrir_rzr_)rrsr=r_rir_rr_)rFT)rTF)rrrir_rzr_)NTFr)rrrir_rzr_r[r)NTrF)rrrir_rrrzr_)NT)rrrir_)r __module__ __qualname____firstlineno____doc___typr[rLrr_HANDLED_TYPES__annotations__rrU_internal_names_set _accessorsrDr _hidden_attrs frozenset__pandas_priority__propertyhasnansfgetrrrrrrrr r rrrsetterrrrr"rRr(r.r2r=rErr __float__r__int__rrLrRrerar\r`rYrrrrrrrrrrrrrrrrrrr%_shared_doc_kwargsrfrrrrrr$r:rr1r3rBrrrOrrcrhrmrtrrrrrrrrrrrrrrrr rrrr"r&r*r/r5_agg_see_also_doc_agg_examples_docr7r;r>rDrJrMrQr#r]rrgrrrkrmr{rrzrrrr?rrArr:rrrr _AXIS_LENrrr AxisPropertyrrJrirrYrrOrpandasplotting PlotAccessorrrPrrNrrMr hist_serieshistrrrrrrrrH make_flex_docrrrrrrrr rsubtractrrmultiplyrrdivdividerrdivr"r%r(r+r.r1r4r7r?rVrrrQrVrAr]r`rdrgrlrorrrukurtosisproductrxr}rr__static_attributes__ __classcell__)rs@rrrs&'_B D^RZZ8N O#9Iy$"F+g.I.II/J ((7+@+@@9R=P   ""''    & & . .G "  ),X X  X'X XvSW11$01@O1j & /&&    //b [[11'+'+R++B%% d  &&../ (0(""H 6969vGK9)98C9 9zKO   $u%IS!G   &&:#x'R*(Y'"'"Rj4X99 88@44$$%%<::3  ? ?QV  37 IM   F8 8 t    #"%!$                    "%!$                    !$                 $(Unn!&U U U  U  UU #Ut-#& ""      !                 #& ""  (    !                 "37#'##R /RR! R  R  RRRRRR Rh  )$%67 ! B#15 ' ' '  ' / '  ' ?>' V1@" >   ,/  $VH9 !)()(  )()(V),&8R@D!1< &P R Tjl9%(::; #'),  !       '    N>`QQfRRh$ $ LEH  -B   03 ) -     58/2 1 -     58/7>" 1>"->"  >"F%."& V V "V  V  V v#' . .  .  .  . ` ) + 0b' c0b' R+8+8ZL@\ -     ( (9 *0%) V3V'V# V ( V:VOT '+ GK " Y; = |!)AAJ  !2             EAD ('+ gY gY7gY$ gY  gYRCCJ^$F+."%"%     )                  +."%     )                  +."%     )                  +/$"("#'GG) G  G  G GG!G GR+."%"       )                    +."%"%"       )                    +."%"       )                    $#'+/$"(#"#'O O ! O ) O  O O  O O O !O  O O f$ G8G8G8 G8  G8  G8TCJbFbF ?bF bFJCJaGaG ?aG aGF  ) S 2 4 %GRAE %2= QGP4+ZBRBRL&* 3636$36 36  36v/3S (S ,S   S j    , [! )  '""    C[! )  ' /0  '+      /2nn " G ,4 GG,G G ) G GRJJ-J J  J,,/   !!  (                 ,/   "%!!  (                 ,/   !!  (                 ,0hE! "&hE(hE hE  hE  hEhEhE hEhET $ )*+<= g&&'  > >  >  >>(%4>  )+,>? !'+ "$(    %     "       ,.1    *             .1  "%  *              .1    *                .1^^ nn *          "!  !!!                     !  !!"%!                      !  !!!                     %)i #'%)"%i !i  i ! i # i i i i  i i V&&6 -,- $"#*.        (       .  ,44lL dBH [? [  [zq q qh /89":" /89 :  09:; 09:!;! "%                          !" ]] ]  ]  ] ]H"&18 FF/F F  FP22l8?iL3?L!I$%z%(/O%/  # # & ) E\  .C < =B  3 4C &&//">"> ?D Hn 5F Hn 5F &, /D ?? & &D AAA>!!B$=$EM$ '$L04ST##.ch/0##'    !      1  ch/0 1 ch/0 1 ch/0 1 ch/0 1 ch/0 1 cx01  2 c12  3 cx01  2 H c12  3 cx01##'    !      2  H c12  3 c 845  6 C F c H56  7 D c H56  7 c X67  8 cx01  2 c12  3 cx01  2 c12  3 c(34  5 c 845  6 "'7 '7  '7'7'7Rhu1%&          ' &hu1%&        ' $ %a !" GGG G"G %a !" GGG G"G %a !!" RRR R  R"R &q !"!" SSS S  S#S &q !"" HHH H#H ( #$" JJJ J%J %a !!" MMM M  M"M %a !!" MMM M  M"M %a !!" MMM M  M"M &q !"" HHH H#H &q !"" HHH H#HHG( #$CC%C ( #$CC%C ( #$CC%C )Q  DD!Dr)r __future__rcollections.abcrrrrrrtextwraprtypingr r r r r rrrrnumpyrpandas._configrrpandas._config.configr pandas._libsrrrpandas._libs.libr pandas.compatrpandas.compat._constantsrpandas.compat._optionalrpandas.compat.numpyrr pandas.errorsrrrrrr r!pandas.util._decoratorsr"r#r$r%pandas.util._exceptionsr&pandas.util._validatorsr'r(r)pandas.core.dtypes.astyper*pandas.core.dtypes.castr+r,r-r.r/r0pandas.core.dtypes.commonr1r2r3r4r5r6r7r8pandas.core.dtypes.dtypesr9r:r;pandas.core.dtypes.genericr<r=pandas.core.dtypes.inferencer>pandas.core.dtypes.missingr?r@rArB pandas.corerCrDrErrFrGrHrIpandas.core.accessorrJpandas.core.applyrKpandas.core.arraysrLpandas.core.arrays.arrowrMrNpandas.core.arrays.categoricalrOpandas.core.arrays.sparserPpandas.core.arrays.string_rQpandas.core.constructionrRrrSrTpandas.core.genericrUrVpandas.core.indexersrWrXpandas.core.indexes.accessorsrYpandas.core.indexes.apirZr[r\r]r^r_pandas.core.indexes.basecoreindexesrpandas.core.indexes.multir`pandas.core.indexingrarbpandas.core.internalsrcrdpandas.core.methodsrepandas.core.shared_docsrfpandas.core.sortingrgrhpandas.core.strings.accessorripandas.core.tools.datetimesrjpandas.io.formats.formatioformatsformatrpandas.io.formats.inforkrlrmpandas.plottingrpandas._libs.internalsrnpandas._typingrorprqrrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrr;r__all__rrrrrrrrs#  . ..>. 5 5    50)-?42 I)(6(073&& 6!!!!!!!!!F,9 *  ' FA(<`cDT  `cDr