MhhlSSKJr SSKJrJrJr SSKJrJrJr SSK r SSK r SSK J r Jr SSKJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJ r J!r!J"r" SSK#J$r$ SSK%J&r& SS K'J(r( SS K)J*r* SS K+J,r,J-r-J.r.J/r/J0r0J1r1 SS K2J3r3J4r4J5r5 SS K6J7r7 SSK8J9r: SSK;Js J?r@ SSKAJBrB SSKCJDrDJErE \(a&SSKFJGrG SSKHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrP SSKQJRrR SSK8JSrS SrT\S+S,Sjj5rU\S+S-Sjj5rUS.S/SjjrUS0S1SjjrV"SS\:R\:R5rYSSSSSSS.S2S jjrZS3S!jr[S4S5S"jjr\S0S6S#jjr]S7S$jr^S%r_S8S9S&jjr`S:S'jraS;S(jrbS) annotations)datetime timedeltatzinfo) TYPE_CHECKINGcastoverloadN)libtslib) BaseOffsetNaTNaTType Resolution Timestampastype_overflowsafefieldsget_resolutionget_supported_dtypeget_unit_from_dtypeints_to_pydatetimeis_date_array_normalizedis_supported_dtype is_unitlessnormalize_i8_timestamps timezones to_offsettz_convert_from_utc tzconversion)abbrev_to_npy_unit)PerformanceWarning)find_stack_level)validate_inclusive) DT64NS_DTYPE INT64_DTYPE is_bool_dtypeis_float_dtypeis_string_dtype pandas_dtype)DatetimeTZDtypeExtensionDtype PeriodDtype)isna) datetimelike)generate_regular_range)get_period_alias)DayTick)Iterator) ArrayLikeDateTimeErrorChoicesDtypeObjIntervalClosedTypeSelf TimeAmbiguousTimeNonexistentnpt DataFrame PeriodArrayi'cgNtzunits N/var/www/html/env/lib/python3.13/site-packages/pandas/core/arrays/datetimes.py tz_to_dtyperF]cgr@rArBs rErFrFbrGrHcNUc[R"SUS35$[XS9$)z Return a datetime64[ns] dtype appropriate for the given timezone. Parameters ---------- tz : tzinfo or None unit : str, default "ns" Returns ------- np.dtype or Datetime64TZDType M8[]rB)npdtyper)rBs rErFrFgs+ zxx#dV1 &&"00rHc>^U4SjnXlX#l[U5$)Nc~>UR5nTUR;aTRS5(apURnSnU(a.URnUR SUR SS55n[ R"UTURX0RS9nU$[ R"UTURS9nU$TUR;a2[ R"UTURS9nURUSS9nU$[ R"UTURS9nURUSSS9nU$) N)startend startingMonthmonthreso fill_valuefloat64)rYconvert)_local_timestamps _bool_opsendswithfreqkwdsgetrget_start_end_fieldfreqstr_cresoget_date_field _object_opsget_date_name_field_maybe_mask_results)selfvaluesr_month_kwr`resultfields rEf_field_accessor..f}s,'') DNN "~~.//yy99D#xx'29NOH33E4<< M ..vu4;;OM D$$ $//DKKPF--f-FF **65t{{KF--4.F rH)__name____doc__property)namerm docstringrns ` rE_field_accessorru|s DJI A;rHc &^\rSrSr%SrSr\R"SS5r\ \R4r Sr Sr \ S|Sj5r/S QrS \S 'S S /rS \S'/SQrS \S'/SQrS \S'\\-\-\-S/-rS \S'/SQrS \S'SrS\S'SrS\S'\r\S}Sj5r\S5r\S\4S~U4Sjjj5r\SS S!.SS"jj5r\SS \R@\R@S S S#S$.SS%jj5r!\SSS&.SS'jjj5r"SS(jr#SS)jr$SS*jr%SS+jr&\ SS,j5r'\ SS-j5r(\(RRS.5r(\ SS/j5r*\ SS0j5r+\ SS1j5r,SSU4S2jjjr-SS3jr.SSU4S4jjjr/SSS5.SS6jjr0SS7jr1SS8jr2SS9jr3SS:jr4SS;jr5\6RnSSS<jj5r8SS=jr9SS>jr:SSS?jjr;SSS@jjr\ SSCj5r?\ SSDj5r@SSEjrA\B"SFSGSH5rC\B"SISJSK5rD\B"SLSMSN5rE\B"SOSPSQ5rF\B"SRSSST5rG\B"SUSVSW5rH\B"SXSYSZ5rI\B"S[SS\5rJS]rK\B"S^S_\K5rL\LrM\LrN\B"S`SaSb5rO\OrP\B"ScSdSe5rQ\B"SfSgSh5rR\RrSSirT\B"SjSj\TRSkSl95rV\B"SmSm\TRSnSl95rW\B"SoSoSp5rX\B"SqSqSr5rY\B"SsSsSt5rZ\B"SuSuSv5r[\B"SwSwSx5r\SSyjr]SSSzjjr^S{r_U=r`$) DatetimeArraya Pandas ExtensionArray for tz-naive or tz-aware datetime data. .. warning:: DatetimeArray is currently experimental, and its API may change without warning. In particular, :attr:`DatetimeArray.dtype` is expected to change to always be an instance of an ``ExtensionDtype`` subclass. Parameters ---------- values : Series, Index, DatetimeArray, ndarray The datetime data. For DatetimeArray `values` (or a Series or Index boxing one), `dtype` and `freq` will be extracted from `values`. dtype : numpy.dtype or DatetimeTZDtype Note that the only NumPy dtype allowed is 'datetime64[ns]'. freq : str or Offset, optional The frequency. copy : bool, default False Whether to copy the underlying array of values. Attributes ---------- None Methods ------- None Examples -------- >>> pd.arrays.DatetimeArray._from_sequence( ... pd.DatetimeIndex(['2023-01-01', '2023-01-02'], freq='D')) ['2023-01-01 00:00:00', '2023-01-02 00:00:00'] Length: 2, dtype: datetime64[ns] datetimearrayr nsc^[R"US5=(d [U[5$NM)r is_np_dtype isinstancer))xs rEDatetimeArray.s&S__Q%<&  ?A&rH)r datetime64datec[$r@)rris rE _scalar_typeDatetimeArray._scalar_typesrH)is_month_start is_month_endis_quarter_startis_quarter_end is_year_start is_year_end is_leap_yearz list[str]r]r_rCrf)yearrUdayhourminutesecondweekday dayofweek day_of_week dayofyear day_of_yearquarter days_in_month daysinmonth microsecond nanosecond _field_ops)rtimetimetz _other_opsrD_datetimelike_ops) to_period tz_localize tz_convert normalizestrftimeroundfloorceil month_nameday_nameas_unit_datetimelike_methodsi)np.dtype[np.datetime64] | DatetimeTZDtype_dtypeNBaseOffset | None_freqc^[R"USS9S;a[eURXS9$)NTskipna)rrrN)r infer_dtype ValueError_from_sequence)clsscalarsrNs rE _from_scalarsDatetimeArray._from_scalarss2 ??74 08R R !!'!77rHc:[U5n[UR5 [U[R5(aURU:wa [ S5eU$[R "UR5SnX2R :wa [ S5eU$)Nz'Values resolution does not match dtype.r)_validate_dt64_dtyperNrrMr datetime_datarD)rrjrNvunits rE_validate_dtypeDatetimeArray._validate_dtype!s%U+V\\* eRXX & &||u$ !JKK%  $$V\\215E " !JKK rHch>[U[R5(deURS:Xde[U[R5(a$X1R:Xde[ U5(aeO%UR [UR5:Xde[TU]%X5nX$l U$r|) rrMndarraykindrNrrdrsuper _simple_newr)rrjr_rNrl __class__s rErDatetimeArray._simple_new0s&"**----zzS   eRXX & &LL( (("5)) )))<<#6v||#DD DD$V3  rHFrNcopyc"URXUS9$Nr)_from_sequence_not_strict)rrrNrs rErDatetimeArray._from_sequenceEs,,W,MMrHraise)rNrrCr_dayfirst yearfirst ambiguousc USLn U[RLaSnO[R"U5n[ U5n[ X$U 5nSn Ub[ R"U5n [ R"XSS9upSn [U[5(a URn [UUUUUUU S9up[ X$U 5 UbU (a [S5e[R"U R 5Sn [#XM5nUR%XUS9nU b XR&:waUR)U 5nSU0nUR+UU5 U$) zL A non-strict version of _from_sequence, called from DatetimeIndex.__new__. Nrw)cls_namerrCrrrout_unitz^Passed data is timezone-aware, incompatible with 'tz=None'. Use obj.tz_localize(None) instead.rr_rNr)r no_defaultr maybe_get_tzr_validate_tz_from_dtypedtl dtype_to_unit!ensure_arraylike_for_datetimelikerrwr__sequence_to_dt64rrMrrNrFrrDr_maybe_pin_freq)rdatarNrrCr_rrrexplicit_tz_nonerD inferred_freqsubarr data_unit data_dtyperl validate_kwdss rEr'DatetimeArray._from_sequence_not_strictIsP&:  B''+B$U+ $U0@ A  $$U+D::   dM * * IIM&   +;< >.5  $$V\\215  / :N   3^^D)F$i0 t]3 rHrDc 0[R"U5nUc$[SX1U455(a [S5e[R "XX45S:wa [S5e[ U5nUb [U5nUb [U5nU[Ld U[La [S5eU bU S;a [S5eOSn UbURU S S 9nUbURU S S 9n[U 5up[XU5up[XU5nUb[XXWU5n[X$XWU5nUGb0[U[5(a(UbUR!S5nUbUR!S5n[U["5(a [%XX4U S 9n OH['XX4U S 9n[(R*"UVs/sHoR,PM sn[(R.S 9n Ub UR0O UR0nUbkUch[2R4"U5(d#[7U 5n[8R:"U UUUUS9n UbUR!XWU5nUbUR!XWU5nOl[=[>U5n[(R@"SUR,UR,- USS 9UR,-n U RBS:waU RES5n X:XaU (d U (dU SSn O[U5R,n[U5R,nU (aU (dJU (d[GU 5(aU SU:XaU SSn U (d[GU 5(aU SU:XaU SSn U RISU S35n[KXZS 9nURMUUUS9$s snf)Nc3(# UHoSLv M g7fr@rA).0rs rE 0DatetimeArray._generate_range..sI3HaT 3Hsz1Must provide freq argument if no data is suppliedzVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedz$Neither `start` nor `end` can be NaT)smsusrzz+'unit' must be one of 's', 'ms', 'us', 'ns'rzF)round_okr)rQrRperiodsoffsetrDrr nonexistentcresorint64i8z datetime64[rLr)'rvalidate_periodsanyrcomcount_not_nonerrr rr"_maybe_normalize_endpoints_infer_tz_from_endpoints_maybe_localize_pointrr0rr1r._generate_rangerMarray_valuerrCris_utcrrtz_localize_to_utcrintlinspacerNastypelenviewrFr)rrQrRrr_rCrrr inclusiverDleft_inclusiveright_inclusivei8valuesxdrr endpoint_tzrstart_i8end_i8 dt64_valuesrNs rErDatetimeArray._generate_rangesq&&w/ )%rkRE'2+NC  $$$$!--d3E?//$/C$%%1%gRVW%'T88s$;s!XXs$;288L&+&7%((SVVK~+"5 ''++/t4E+>> "+$/#  H$!--b[IE?//"EC 3(G AszzELL8'Q,, ~~%$??40 <!/#Ab> '..Hs^**F!%#h--HQK8 > ##E* C<==tyy9 9==+00 0rHc([XRS9$)NrC)rrCrs rE_scalar_from_string!DatetimeArray._scalar_from_strings77++rHc:U[LagURU5 gr@)r _assert_tzawareness_compat)riothers rEr$DatetimeArray._check_compatible_withs C<  ''.rHczURS5n[R"X RURS9nU$)Nr)rWrC)rr_from_value_and_resordrC)rirrtss rE _box_funcDatetimeArray._box_func!s.t   + +E  P rHcUR$)a The dtype for the DatetimeArray. .. warning:: A future version of pandas will change dtype to never be a ``numpy.dtype``. Instead, :attr:`DatetimeArray.dtype` will always be an instance of an ``ExtensionDtype`` subclass. Returns ------- numpy.dtype or DatetimeTZDtype If the values are tz-naive, then ``np.dtype('datetime64[ns]')`` is returned. If the values are tz-aware, then the ``DatetimeTZDtype`` is returned. )rrs rErNDatetimeArray.dtype's.{{rHc0[URSS5$)aD Return the timezone. Returns ------- datetime.tzinfo, pytz.tzinfo.BaseTZInfo, dateutil.tz.tz.tzfile, or None Returns None when the array is tz-naive. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[ns, UTC] >>> s.dt.tz datetime.timezone.utc For DatetimeIndex: >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", ... "2/1/2020 11:00:00+00:00"]) >>> idx.tz datetime.timezone.utc rCN)getattrrNrs rErCDatetimeArray.tz@s>tzz4..rHc[S5e)NzNCannot directly set timezone. Use tz_localize() or tz_convert() as appropriate)AttributeErrorrs rErCr2as -  rHcUR$)z Alias for tz attribute r"rs rErDatetimeArray.tzinfois wwrHcT[URURURS9$)z> Returns True if all of the dates are at midnight ("no time") rV)rasi8rCrdrs rE is_normalizedDatetimeArray.is_normalizedps ( 477MMrHcT[URURURS9$)NrV)rr8rCrdrs rE_resolution_objDatetimeArray._resolution_objwsdiit{{CCrHcR>UcUR(a[n[TU] XS9$r)rCobjectr __array__)rirNrrs rEr@DatetimeArray.__array__~s& =TWWEw u 88rHc#d# URS:a"[[U55H nXv M gURn[U5n[nX4-S-n[U5HEnX-n[ US-U-U5n[ X&UURSURS9nUShvN MG gN 7f)zL Return an iterator over the boxed values Yields ------ tstamp : Timestamp r timestamp)rCboxrWN) ndimrangerr8_ITER_CHUNKSIZEminrrCrd) riirlength chunksizechunksstart_iend_i converteds rE__iter__DatetimeArray.__iter__s 99q=3t9%g &99DYF'I)Q.F6]-QUi/8.'ww#  %$$#%sB"B0$B.% B0c`>[U5nXR:XaU(aUR5$U$[U[5(a[U[ 5(d [ TU]XS9$URc [S5e[R"UR5n[URX2S9n[U5RXAUR S9$URcs["R$"US5(aW['U5(dG[)U5(a7[URUSS9n[U5RXDRS9$URb'["R$"US5(a [S5eURcF["R$"US5(a*XR:wa['U5(a [S5e[U[*5(aUR-UR S 9$[.R0RXU5$) NrzCannot use .astype to convert from timezone-naive dtype to timezone-aware dtype. Use obj.tz_localize instead or series.dt.tz_localize insteadrNr_r}TrzCannot use .astype to convert from timezone-aware dtype to timezone-naive dtype. Use obj.tz_localize(None) or obj.tz_convert('UTC').tz_localize(None) instead.z]Casting to unit-less dtype 'datetime64' is not supported. Pass e.g. 'datetime64[ns]' instead.)r_)r(rNrrr*r)rr rC TypeErrorrMstrr_ndarraytyperr_r r~rrr+rrDatetimeLikeArrayMixin)rirNrnp_dtype res_valuesrs rEr DatetimeArray.astypes U# JJ yy{"K ~ . .e_55w~e~77 488EII.0T Dz--jDII-VV GGOs++&&"5))-T]]EMJ:))*>uzz>2 2))00dCCrH)na_rep date_formatc UcUR(aSn[R"URURX!UR S9$)Nz%Y-%m-%d)rCformatr]rW)_is_dates_onlyr format_array_from_datetimer8rCrd)rir]r^kwargss rE_format_native_types"DatetimeArray._format_native_typess?  4#6#6$K// II$''+4;;  rHc[U[R5(a [U5n[ US5(dgUR n[ R"UR U5$)NrF)rrMrrhasattrrr tz_compare)rir'other_tzs rE _has_same_tzDatetimeArray._has_same_tzsM eR]] + +e$Euh''<<##DKK::rHc[USS5n[USS5n[U[5(aURRnU[ LagURcUb [ S5egUc [ S5eg)NrrNz;Cannot compare tz-naive and tz-aware datetime-like objects.z:Cannot compare tz-naive and tz-aware datetime-like objects)r1rr)rNrCr rU)rir'ri other_dtypes rEr&(DatetimeArray._assert_tzawareness_compats5(D1eWd3 k? 3 3{{~~H C<  WW_#Q$ L rHcJ[U[5(aeURbURS5nOUnUR UR 5nUR RS:XaURUR 5n[U5RX3R S9nUR(aUR5nSUl URbURUR5nU$![a [R"S[ [#5S9 UR%S5U-n[U5R'U5R)UR*5n[-U5(dURUR5s$U$f=f)NrIrzCNon-vectorized DateOffset being applied to Series or DatetimeIndex. stacklevelO)rr1rCr _apply_arrayrWrNrrrXrrrNotImplementedErrorwarningswarnr r!r rrrDr)rirrjr[rls rE _add_offsetDatetimeArray._add_offsets`fd++++ 77 %%d+FF 5,,V__=J$$+(__V\\: $Z++J>N>N+OF))+# ww"++DGG4 -# 3 MMU"+-  S)F2J$Z..z:BB499MFt99))$''22 - 3sAC>>BF"!F"cURb%[R"UR5(a UR$[ URURUR S9$)z Convert to an i8 (unix-like nanosecond timestamp) representation while keeping the local timezone and not using UTC. This is used to calculate time-of-day information as if the timestamps were timezone-naive. rV)rCrr r8rrdrs rEr\DatetimeArray._local_timestampsCsF 77?i..tww7799 "499dggDKKHHrHc[R"U5nURc [S5e[ XR S9nUR URX RS9$)a Convert tz-aware Datetime Array/Index from one time zone to another. Parameters ---------- tz : str, pytz.timezone, dateutil.tz.tzfile, datetime.tzinfo or None Time zone for time. Corresponding timestamps would be converted to this time zone of the Datetime Array/Index. A `tz` of None will convert to UTC and remove the timezone information. Returns ------- Array or Index Raises ------ TypeError If Datetime Array/Index is tz-naive. See Also -------- DatetimeIndex.tz : A timezone that has a variable offset from UTC. DatetimeIndex.tz_localize : Localize tz-naive DatetimeIndex to a given time zone, or remove timezone from a tz-aware DatetimeIndex. Examples -------- With the `tz` parameter, we can change the DatetimeIndex to other time zones: >>> dti = pd.date_range(start='2014-08-01 09:00', ... freq='h', periods=3, tz='Europe/Berlin') >>> dti DatetimeIndex(['2014-08-01 09:00:00+02:00', '2014-08-01 10:00:00+02:00', '2014-08-01 11:00:00+02:00'], dtype='datetime64[ns, Europe/Berlin]', freq='h') >>> dti.tz_convert('US/Central') DatetimeIndex(['2014-08-01 02:00:00-05:00', '2014-08-01 03:00:00-05:00', '2014-08-01 04:00:00-05:00'], dtype='datetime64[ns, US/Central]', freq='h') With the ``tz=None``, we can remove the timezone (after converting to UTC if necessary): >>> dti = pd.date_range(start='2014-08-01 09:00', freq='h', ... periods=3, tz='Europe/Berlin') >>> dti DatetimeIndex(['2014-08-01 09:00:00+02:00', '2014-08-01 10:00:00+02:00', '2014-08-01 11:00:00+02:00'], dtype='datetime64[ns, Europe/Berlin]', freq='h') >>> dti.tz_convert(None) DatetimeIndex(['2014-08-01 07:00:00', '2014-08-01 08:00:00', '2014-08-01 09:00:00'], dtype='datetime64[ns]', freq='h') z?Cannot convert tz-naive timestamps, use tz_localize to localizerrT) rrrCrUrFrDrrWr_)rirCrNs rErDatetimeArray.tz_convertOs\@ # #B ' 77?Q  BYY/ UKKrHcSnX4;a [U[5(d [S5eURb8Uc*[ UR URUR S9nOM[S5e[R"U5n[R"UR UUUUR S9nURSURS35n[XRS 9nSn[R"U5(d"[!U5S :Xa [#US 5(d UR$nOUcURc UR$nUR'XgUS 9$) a4 Localize tz-naive Datetime Array/Index to tz-aware Datetime Array/Index. This method takes a time zone (tz) naive Datetime Array/Index object and makes this time zone aware. It does not move the time to another time zone. This method can also be used to do the inverse -- to create a time zone unaware object from an aware object. To that end, pass `tz=None`. Parameters ---------- tz : str, pytz.timezone, dateutil.tz.tzfile, datetime.tzinfo or None Time zone to convert timestamps to. Passing ``None`` will remove the time zone information preserving local time. ambiguous : 'infer', 'NaT', bool array, default 'raise' When clocks moved backward due to DST, ambiguous times may arise. For example in Central European Time (UTC+01), when going from 03:00 DST to 02:00 non-DST, 02:30:00 local time occurs both at 00:30:00 UTC and at 01:30:00 UTC. In such a situation, the `ambiguous` parameter dictates how ambiguous times should be handled. - 'infer' will attempt to infer fall dst-transition hours based on order - bool-ndarray where True signifies a DST time, False signifies a non-DST time (note that this flag is only applicable for ambiguous times) - 'NaT' will return NaT where there are ambiguous times - 'raise' will raise an AmbiguousTimeError if there are ambiguous times. nonexistent : 'shift_forward', 'shift_backward, 'NaT', timedelta, default 'raise' A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST. - 'shift_forward' will shift the nonexistent time forward to the closest existing time - 'shift_backward' will shift the nonexistent time backward to the closest existing time - 'NaT' will return NaT where there are nonexistent times - timedelta objects will shift nonexistent times by the timedelta - 'raise' will raise an NonExistentTimeError if there are nonexistent times. Returns ------- Same type as self Array/Index converted to the specified time zone. Raises ------ TypeError If the Datetime Array/Index is tz-aware and tz is not None. See Also -------- DatetimeIndex.tz_convert : Convert tz-aware DatetimeIndex from one time zone to another. Examples -------- >>> tz_naive = pd.date_range('2018-03-01 09:00', periods=3) >>> tz_naive DatetimeIndex(['2018-03-01 09:00:00', '2018-03-02 09:00:00', '2018-03-03 09:00:00'], dtype='datetime64[ns]', freq='D') Localize DatetimeIndex in US/Eastern time zone: >>> tz_aware = tz_naive.tz_localize(tz='US/Eastern') >>> tz_aware DatetimeIndex(['2018-03-01 09:00:00-05:00', '2018-03-02 09:00:00-05:00', '2018-03-03 09:00:00-05:00'], dtype='datetime64[ns, US/Eastern]', freq=None) With the ``tz=None``, we can remove the time zone information while keeping the local time (not converted to UTC): >>> tz_aware.tz_localize(None) DatetimeIndex(['2018-03-01 09:00:00', '2018-03-02 09:00:00', '2018-03-03 09:00:00'], dtype='datetime64[ns]', freq=None) Be careful with DST changes. When there is sequential data, pandas can infer the DST time: >>> s = pd.to_datetime(pd.Series(['2018-10-28 01:30:00', ... '2018-10-28 02:00:00', ... '2018-10-28 02:30:00', ... '2018-10-28 02:00:00', ... '2018-10-28 02:30:00', ... '2018-10-28 03:00:00', ... '2018-10-28 03:30:00'])) >>> s.dt.tz_localize('CET', ambiguous='infer') 0 2018-10-28 01:30:00+02:00 1 2018-10-28 02:00:00+02:00 2 2018-10-28 02:30:00+02:00 3 2018-10-28 02:00:00+01:00 4 2018-10-28 02:30:00+01:00 5 2018-10-28 03:00:00+01:00 6 2018-10-28 03:30:00+01:00 dtype: datetime64[ns, CET] In some cases, inferring the DST is impossible. In such cases, you can pass an ndarray to the ambiguous parameter to set the DST explicitly >>> s = pd.to_datetime(pd.Series(['2018-10-28 01:20:00', ... '2018-10-28 02:36:00', ... '2018-10-28 03:46:00'])) >>> s.dt.tz_localize('CET', ambiguous=np.array([True, True, False])) 0 2018-10-28 01:20:00+02:00 1 2018-10-28 02:36:00+02:00 2 2018-10-28 03:46:00+01:00 dtype: datetime64[ns, CET] If the DST transition causes nonexistent times, you can shift these dates forward or backwards with a timedelta object or `'shift_forward'` or `'shift_backwards'`. >>> s = pd.to_datetime(pd.Series(['2015-03-29 02:30:00', ... '2015-03-29 03:30:00'])) >>> s.dt.tz_localize('Europe/Warsaw', nonexistent='shift_forward') 0 2015-03-29 03:00:00+02:00 1 2015-03-29 03:30:00+02:00 dtype: datetime64[ns, Europe/Warsaw] >>> s.dt.tz_localize('Europe/Warsaw', nonexistent='shift_backward') 0 2015-03-29 01:59:59.999999999+01:00 1 2015-03-29 03:30:00+02:00 dtype: datetime64[ns, Europe/Warsaw] >>> s.dt.tz_localize('Europe/Warsaw', nonexistent=pd.Timedelta('1h')) 0 2015-03-29 03:30:00+02:00 1 2015-03-29 03:30:00+02:00 dtype: datetime64[ns, Europe/Warsaw] )rr shift_forwardshift_backwardzoThe nonexistent argument must be one of 'raise', 'NaT', 'shift_forward', 'shift_backward' or a timedelta objectNrVz,Already tz-aware, use tz_convert to convert.rrKrLrrrrT)rrrrCrr8rdrUrrrr rrDrFr rr,r_r) rirCrrnonexistent_options new_datesnew_dates_dt64rNr_s rErDatetimeArray.tz_localizes8dR  1* ; ; %  77 z/ 477U  NOO''+B%77 #'kk I##dii[(:;BYY/   B  CIN4q@Q;R;R99D ZDGGO99D$GGrHcT[URURURS9$)aE Return an ndarray of ``datetime.datetime`` objects. Returns ------- numpy.ndarray Examples -------- >>> idx = pd.date_range('2018-02-27', periods=3) >>> idx.to_pydatetime() array([datetime.datetime(2018, 2, 27, 0, 0), datetime.datetime(2018, 2, 28, 0, 0), datetime.datetime(2018, 3, 1, 0, 0)], dtype=object) )rCrWrr8rCrdrs rE to_pydatetimeDatetimeArray.to_pydatetimeWs "$))dkkJJrHcX[URURURS9nUR UR R 5n[U5RX"R S9nURS5nURbURUR5nU$)a Convert times to midnight. The time component of the date-time is converted to midnight i.e. 00:00:00. This is useful in cases, when the time does not matter. Length is unaltered. The timezones are unaffected. This method is available on Series with datetime values under the ``.dt`` accessor, and directly on Datetime Array/Index. Returns ------- DatetimeArray, DatetimeIndex or Series The same type as the original data. Series will have the same name and index. DatetimeIndex will have the same name. See Also -------- floor : Floor the datetimes to the specified freq. ceil : Ceil the datetimes to the specified freq. round : Round the datetimes to the specified freq. Examples -------- >>> idx = pd.date_range(start='2014-08-01 10:00', freq='h', ... periods=3, tz='Asia/Calcutta') >>> idx DatetimeIndex(['2014-08-01 10:00:00+05:30', '2014-08-01 11:00:00+05:30', '2014-08-01 12:00:00+05:30'], dtype='datetime64[ns, Asia/Calcutta]', freq='h') >>> idx.normalize() DatetimeIndex(['2014-08-01 00:00:00+05:30', '2014-08-01 00:00:00+05:30', '2014-08-01 00:00:00+05:30'], dtype='datetime64[ns, Asia/Calcutta]', freq=None) rVrinfer) rr8rCrdrrWrNrXr _with_freqr)ri new_valuesrdtas rErDatetimeArray.normalizeisL-TYYdkkR  oodmm&9&9: 4j$$[8I8I$JnnW% 77 //$''*C rHcSSKJn URb"[R"S[ [ 5S9 UcUR=(d URn[UR[5(a:[URS5(a[UR5RnUc [S5e[!U5nUcUnUnUR""UR$XRS9$)az Cast to PeriodArray/PeriodIndex at a particular frequency. Converts DatetimeArray/Index to PeriodArray/PeriodIndex. Parameters ---------- freq : str or Period, optional One of pandas' :ref:`period aliases ` or an Period object. Will be inferred by default. Returns ------- PeriodArray/PeriodIndex Raises ------ ValueError When converting a DatetimeArray/Index with non-regular values, so that a frequency cannot be inferred. See Also -------- PeriodIndex: Immutable ndarray holding ordinal values. DatetimeIndex.to_pydatetime: Return DatetimeIndex as object. Examples -------- >>> df = pd.DataFrame({"y": [1, 2, 3]}, ... index=pd.to_datetime(["2000-03-31 00:00:00", ... "2000-05-31 00:00:00", ... "2000-08-31 00:00:00"])) >>> df.index.to_period("M") PeriodIndex(['2000-03', '2000-05', '2000-08'], dtype='period[M]') Infer the daily frequency >>> idx = pd.date_range("2017-01-01", periods=2) >>> idx.to_period() PeriodIndex(['2017-01-01', '2017-01-02'], dtype='period[D]') rr=zNConverting to PeriodArray/Index representation will drop timezone information.rp_period_dtype_codez8You must pass a freq argument as current index has none.r")pandas.core.arraysr>rCrurv UserWarningr!rcrrr_r rgr+_freqstrrr/_from_datetime64rW)rir_r>ress rErDatetimeArray.to_periodsX 3 77  MM2+-   <<<54#5#5D$))Z00W /66#499-66| N#4(C{D++DMM4GGLLrHcUR5n[R"USXRS9nUR USS9nU$)uV Return the month names with specified locale. Parameters ---------- locale : str, optional Locale determining the language in which to return the month name. Default is English locale (``'en_US.utf8'``). Use the command ``locale -a`` on your terminal on Unix systems to find your locale language code. Returns ------- Series or Index Series or Index of month names. Examples -------- >>> s = pd.Series(pd.date_range(start='2018-01', freq='ME', periods=3)) >>> s 0 2018-01-31 1 2018-02-28 2 2018-03-31 dtype: datetime64[ns] >>> s.dt.month_name() 0 January 1 February 2 March dtype: object >>> idx = pd.date_range(start='2018-01', freq='ME', periods=3) >>> idx DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'], dtype='datetime64[ns]', freq='ME') >>> idx.month_name() Index(['January', 'February', 'March'], dtype='object') Using the ``locale`` parameter you can set a different locale language, for example: ``idx.month_name(locale='pt_BR.utf8')`` will return month names in Brazilian Portuguese language. >>> idx = pd.date_range(start='2018-01', freq='ME', periods=3) >>> idx DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'], dtype='datetime64[ns]', freq='ME') >>> idx.month_name(locale='pt_BR.utf8') # doctest: +SKIP Index(['Janeiro', 'Fevereiro', 'Março'], dtype='object') rlocalerWNrXr\rrgrdrhrirrjrls rErDatetimeArray.month_namesJb'')++ Lkk ))&T)B rHcUR5n[R"USXRS9nUR USS9nU$)uK Return the day names with specified locale. Parameters ---------- locale : str, optional Locale determining the language in which to return the day name. Default is English locale (``'en_US.utf8'``). Use the command ``locale -a`` on your terminal on Unix systems to find your locale language code. Returns ------- Series or Index Series or Index of day names. Examples -------- >>> s = pd.Series(pd.date_range(start='2018-01-01', freq='D', periods=3)) >>> s 0 2018-01-01 1 2018-01-02 2 2018-01-03 dtype: datetime64[ns] >>> s.dt.day_name() 0 Monday 1 Tuesday 2 Wednesday dtype: object >>> idx = pd.date_range(start='2018-01-01', freq='D', periods=3) >>> idx DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03'], dtype='datetime64[ns]', freq='D') >>> idx.day_name() Index(['Monday', 'Tuesday', 'Wednesday'], dtype='object') Using the ``locale`` parameter you can set a different locale language, for example: ``idx.day_name(locale='pt_BR.utf8')`` will return day names in Brazilian Portuguese language. >>> idx = pd.date_range(start='2018-01-01', freq='D', periods=3) >>> idx DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03'], dtype='datetime64[ns]', freq='D') >>> idx.day_name(locale='pt_BR.utf8') # doctest: +SKIP Index(['Segunda', 'Terça', 'Quarta'], dtype='object') rrNrXrrs rErDatetimeArray.day_namesJb'')++ JvKK ))&T)B rHcLUR5n[USURS9$)aF Returns numpy array of :class:`datetime.time` objects. The time part of the Timestamps. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[ns, UTC] >>> s.dt.time 0 10:00:00 1 11:00:00 dtype: object For DatetimeIndex: >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", ... "2/1/2020 11:00:00+00:00"]) >>> idx.time array([datetime.time(10, 0), datetime.time(11, 0)], dtype=object) rrDrWr\rrdri timestampss rErDatetimeArray.timeXs&@++- !*&t{{KKrHcV[URURSURS9$)a Returns numpy array of :class:`datetime.time` objects with timezones. The time part of the Timestamps. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[ns, UTC] >>> s.dt.timetz 0 10:00:00+00:00 1 11:00:00+00:00 dtype: object For DatetimeIndex: >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", ... "2/1/2020 11:00:00+00:00"]) >>> idx.timetz array([datetime.time(10, 0, tzinfo=datetime.timezone.utc), datetime.time(11, 0, tzinfo=datetime.timezone.utc)], dtype=object) rrrrs rErDatetimeArray.timetz|s!<"$))TWW&t{{SSrHcLUR5n[USURS9$)a Returns numpy array of python :class:`datetime.date` objects. Namely, the date part of Timestamps without time and timezone information. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[ns, UTC] >>> s.dt.date 0 2020-01-01 1 2020-02-01 dtype: object For DatetimeIndex: >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", ... "2/1/2020 11:00:00+00:00"]) >>> idx.date array([datetime.date(2020, 1, 1), datetime.date(2020, 2, 1)], dtype=object) rrrrs rErDatetimeArray.dates&B++- !*&t{{KKrHcSSKJn UR5n[R"X R S9nU"U/SQSS9nUR (aSURUR'U$)a Calculate year, week, and day according to the ISO 8601 standard. Returns ------- DataFrame With columns year, week and day. See Also -------- Timestamp.isocalendar : Function return a 3-tuple containing ISO year, week number, and weekday for the given Timestamp object. datetime.date.isocalendar : Return a named tuple object with three components: year, week and weekday. Examples -------- >>> idx = pd.date_range(start='2019-12-29', freq='D', periods=4) >>> idx.isocalendar() year week day 2019-12-29 2019 52 7 2019-12-30 2020 1 1 2019-12-31 2020 1 2 2020-01-01 2020 1 3 >>> idx.isocalendar().week 2019-12-29 52 2019-12-30 1 2019-12-31 1 2020-01-01 1 Freq: D, Name: week, dtype: UInt32 rr;rV)rweekrUInt32)columnsrNN) pandasr<r\rbuild_isocalendar_sarrayrd_hasnailoc_isnan)rir<rjsarrayiso_calendar_dfs rE isocalendarDatetimeArray.isocalendars_@ %'')00kkJ# 38  ;;04O  -rHrYa The year of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="YE") ... ) >>> datetime_series 0 2000-12-31 1 2001-12-31 2 2002-12-31 dtype: datetime64[ns] >>> datetime_series.dt.year 0 2000 1 2001 2 2002 dtype: int32 rUr}a The month as January=1, December=12. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="ME") ... ) >>> datetime_series 0 2000-01-31 1 2000-02-29 2 2000-03-31 dtype: datetime64[ns] >>> datetime_series.dt.month 0 1 1 2 2 3 dtype: int32 rDa The day of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="D") ... ) >>> datetime_series 0 2000-01-01 1 2000-01-02 2 2000-01-03 dtype: datetime64[ns] >>> datetime_series.dt.day 0 1 1 2 2 3 dtype: int32 rha The hours of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="h") ... ) >>> datetime_series 0 2000-01-01 00:00:00 1 2000-01-01 01:00:00 2 2000-01-01 02:00:00 dtype: datetime64[ns] >>> datetime_series.dt.hour 0 0 1 1 2 2 dtype: int32 rma The minutes of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="min") ... ) >>> datetime_series 0 2000-01-01 00:00:00 1 2000-01-01 00:01:00 2 2000-01-01 00:02:00 dtype: datetime64[ns] >>> datetime_series.dt.minute 0 0 1 1 2 2 dtype: int32 rra The seconds of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="s") ... ) >>> datetime_series 0 2000-01-01 00:00:00 1 2000-01-01 00:00:01 2 2000-01-01 00:00:02 dtype: datetime64[ns] >>> datetime_series.dt.second 0 0 1 1 2 2 dtype: int32 rra The microseconds of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="us") ... ) >>> datetime_series 0 2000-01-01 00:00:00.000000 1 2000-01-01 00:00:00.000001 2 2000-01-01 00:00:00.000002 dtype: datetime64[ns] >>> datetime_series.dt.microsecond 0 0 1 1 2 2 dtype: int32 ra The nanoseconds of the datetime. Examples -------- >>> datetime_series = pd.Series( ... pd.date_range("2000-01-01", periods=3, freq="ns") ... ) >>> datetime_series 0 2000-01-01 00:00:00.000000000 1 2000-01-01 00:00:00.000000001 2 2000-01-01 00:00:00.000000002 dtype: datetime64[ns] >>> datetime_series.dt.nanosecond 0 0 1 1 2 2 dtype: int32 a The day of the week with Monday=0, Sunday=6. Return the day of the week. It is assumed the week starts on Monday, which is denoted by 0 and ends on Sunday which is denoted by 6. This method is available on both Series with datetime values (using the `dt` accessor) or DatetimeIndex. Returns ------- Series or Index Containing integers indicating the day number. See Also -------- Series.dt.dayofweek : Alias. Series.dt.weekday : Alias. Series.dt.day_name : Returns the name of the day of the week. Examples -------- >>> s = pd.date_range('2016-12-31', '2017-01-08', freq='D').to_series() >>> s.dt.dayofweek 2016-12-31 5 2017-01-01 6 2017-01-02 0 2017-01-03 1 2017-01-04 2 2017-01-05 3 2017-01-06 4 2017-01-07 5 2017-01-08 6 Freq: D, dtype: int32 rdowrdoya The ordinal day of the year. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[ns, UTC] >>> s.dt.dayofyear 0 1 1 32 dtype: int32 For DatetimeIndex: >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", ... "2/1/2020 11:00:00+00:00"]) >>> idx.dayofyear Index([1, 32], dtype='int32') rqax The quarter of the date. Examples -------- For Series: >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "4/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-04-01 11:00:00+00:00 dtype: datetime64[ns, UTC] >>> s.dt.quarter 0 1 1 2 dtype: int32 For DatetimeIndex: >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", ... "2/1/2020 11:00:00+00:00"]) >>> idx.quarter Index([1, 1], dtype='int32') rdima The number of days in the month. Examples -------- >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"]) >>> s = pd.to_datetime(s) >>> s 0 2020-01-01 10:00:00+00:00 1 2020-02-01 11:00:00+00:00 dtype: datetime64[ns, UTC] >>> s.dt.daysinmonth 0 31 1 29 dtype: int32 a Indicates whether the date is the {first_or_last} day of the month. Returns ------- Series or array For Series, returns a Series with boolean values. For DatetimeIndex, returns a boolean array. See Also -------- is_month_start : Return a boolean indicating whether the date is the first day of the month. is_month_end : Return a boolean indicating whether the date is the last day of the month. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> s = pd.Series(pd.date_range("2018-02-27", periods=3)) >>> s 0 2018-02-27 1 2018-02-28 2 2018-03-01 dtype: datetime64[ns] >>> s.dt.is_month_start 0 False 1 False 2 True dtype: bool >>> s.dt.is_month_end 0 False 1 True 2 False dtype: bool >>> idx = pd.date_range("2018-02-27", periods=3) >>> idx.is_month_start array([False, False, True]) >>> idx.is_month_end array([False, True, False]) rfirst) first_or_lastrlastra Indicator for whether the date is the first day of a quarter. Returns ------- is_quarter_start : Series or DatetimeIndex The same type as the original data with boolean values. Series will have the same name and index. DatetimeIndex will have the same name. See Also -------- quarter : Return the quarter of the date. is_quarter_end : Similar property for indicating the quarter end. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> df = pd.DataFrame({'dates': pd.date_range("2017-03-30", ... periods=4)}) >>> df.assign(quarter=df.dates.dt.quarter, ... is_quarter_start=df.dates.dt.is_quarter_start) dates quarter is_quarter_start 0 2017-03-30 1 False 1 2017-03-31 1 False 2 2017-04-01 2 True 3 2017-04-02 2 False >>> idx = pd.date_range('2017-03-30', periods=4) >>> idx DatetimeIndex(['2017-03-30', '2017-03-31', '2017-04-01', '2017-04-02'], dtype='datetime64[ns]', freq='D') >>> idx.is_quarter_start array([False, False, True, False]) ra Indicator for whether the date is the last day of a quarter. Returns ------- is_quarter_end : Series or DatetimeIndex The same type as the original data with boolean values. Series will have the same name and index. DatetimeIndex will have the same name. See Also -------- quarter : Return the quarter of the date. is_quarter_start : Similar property indicating the quarter start. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> df = pd.DataFrame({'dates': pd.date_range("2017-03-30", ... periods=4)}) >>> df.assign(quarter=df.dates.dt.quarter, ... is_quarter_end=df.dates.dt.is_quarter_end) dates quarter is_quarter_end 0 2017-03-30 1 False 1 2017-03-31 1 True 2 2017-04-01 2 False 3 2017-04-02 2 False >>> idx = pd.date_range('2017-03-30', periods=4) >>> idx DatetimeIndex(['2017-03-30', '2017-03-31', '2017-04-01', '2017-04-02'], dtype='datetime64[ns]', freq='D') >>> idx.is_quarter_end array([False, True, False, False]) ra~ Indicate whether the date is the first day of a year. Returns ------- Series or DatetimeIndex The same type as the original data with boolean values. Series will have the same name and index. DatetimeIndex will have the same name. See Also -------- is_year_end : Similar property indicating the last day of the year. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> dates = pd.Series(pd.date_range("2017-12-30", periods=3)) >>> dates 0 2017-12-30 1 2017-12-31 2 2018-01-01 dtype: datetime64[ns] >>> dates.dt.is_year_start 0 False 1 False 2 True dtype: bool >>> idx = pd.date_range("2017-12-30", periods=3) >>> idx DatetimeIndex(['2017-12-30', '2017-12-31', '2018-01-01'], dtype='datetime64[ns]', freq='D') >>> idx.is_year_start array([False, False, True]) ra{ Indicate whether the date is the last day of the year. Returns ------- Series or DatetimeIndex The same type as the original data with boolean values. Series will have the same name and index. DatetimeIndex will have the same name. See Also -------- is_year_start : Similar property indicating the start of the year. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> dates = pd.Series(pd.date_range("2017-12-30", periods=3)) >>> dates 0 2017-12-30 1 2017-12-31 2 2018-01-01 dtype: datetime64[ns] >>> dates.dt.is_year_end 0 False 1 True 2 False dtype: bool >>> idx = pd.date_range("2017-12-30", periods=3) >>> idx DatetimeIndex(['2017-12-30', '2017-12-31', '2018-01-01'], dtype='datetime64[ns]', freq='D') >>> idx.is_year_end array([False, True, False]) ra Boolean indicator if the date belongs to a leap year. A leap year is a year, which has 366 days (instead of 365) including 29th of February as an intercalary day. Leap years are years which are multiples of four with the exception of years divisible by 100 but not by 400. Returns ------- Series or ndarray Booleans indicating if dates belong to a leap year. Examples -------- This method is available on Series with datetime values under the ``.dt`` accessor, and directly on DatetimeIndex. >>> idx = pd.date_range("2012-01-01", "2015-01-01", freq="YE") >>> idx DatetimeIndex(['2012-12-31', '2013-12-31', '2014-12-31'], dtype='datetime64[ns]', freq='YE-DEC') >>> idx.is_leap_year array([ True, False, False]) >>> dates_series = pd.Series(idx) >>> dates_series 0 2012-12-31 1 2013-12-31 2 2014-12-31 dtype: datetime64[ns] >>> dates_series.dt.is_leap_year 0 True 1 False 2 False dtype: bool c[R"UR5n[R"UR5n[R"UR5nUS:nX==S-ss'X$==S- ss'U[R "SU-S- S- 5-SU--[R "US- 5-[R "US - 5- [R "US - 5-S -URURS - -URS - -URS - S- -URS - S- -S- -$)z Convert Datetime Array to float64 ndarray of Julian Dates. 0 Julian date is noon January 1, 4713 BC. https://en.wikipedia.org/wiki/Julian_day rrrSiimdigC:A<ii@Biʚ;) rMasarrayrrUrfixrrrrrr)rirrUrtestarrs rEto_julian_dateDatetimeArray.to_julian_date$sIzz$))$ 4::&jj"!)   " ffcEkC'1,- .Dj hhtax  !hhtcz"  # hhtcz"  #    ++"#++$%""T)E12//D(50 1   rHcSSKJn URRRR SS5n[ R"U5nURURRU5US9n U RXXEUS9$)a  Return sample standard deviation over requested axis. Normalized by `N-1` by default. This can be changed using ``ddof``. Parameters ---------- axis : int, optional Axis for the function to be applied on. For :class:`pandas.Series` this parameter is unused and defaults to ``None``. ddof : int, default 1 Degrees of Freedom. The divisor used in calculations is `N - ddof`, where `N` represents the number of elements. skipna : bool, default True Exclude NA/null values. If an entire row/column is ``NA``, the result will be ``NA``. Returns ------- Timedelta See Also -------- numpy.ndarray.std : Returns the standard deviation of the array elements along given axis. Series.std : Return sample standard deviation over requested axis. Examples -------- For :class:`pandas.DatetimeIndex`: >>> idx = pd.date_range('2001-01-01 00:00', periods=3) >>> idx DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03'], dtype='datetime64[ns]', freq='D') >>> idx.std() Timedelta('1 days 00:00:00') r)TimedeltaArrayr timedelta64r)axisoutddofkeepdimsr) rrrWrNrsreplacerMrrstd) rirrNrrrrr dtype_strtdas rErDatetimeArray.stdGstd 6MM'',,44\=Q #((););E)B%(PwwDPVwWWrHrA)returnztype[Timestamp])rNr5rr7)rjznpt.NDArray[np.datetime64]r_rrNrrr7)rbool) rrr_z'str | BaseOffset | lib.NoDefault | Nonerrrrrr8rr7)NFrrboth)r int | Nonerrrr8rr9rr6rD str | Nonerr7)r np.datetime64)rTimestamp | NaTType)rNone)rrrr)rr)r tzinfo | None)rr)rr)NN)r np.ndarray)rr2)T)r]z str | floatrnpt.NDArray[np.object_])rr rr7)rznpt.NDArray[np.int64])rr7)rr)rr8rr9rr7)rrr@)rr>)rr<)rznpt.NDArray[np.float64])NNNrFT)rr rrrr)arp __module__ __qualname____firstlineno__rq_typrMr_internal_fill_valuer_recognized_scalars_is_recognized_dtype_infer_matchesrrrr]__annotations__rfrrrr__array_priority__rr#_default_dtype classmethodrrrrr rrrrr#rr,rNrCsetterrr9r<r@rPr rdrjr&rwr\rr ravel_compatrrrrrrrrrrrurrUrrrrrr_dayofweek_docrrrrrrrr _is_month_docr`rrrrrrrrr__static_attributes__ __classcell__)rs@rErwrws8(T D==5#R]]38N Iy%d^K+J $7J 6[ 9,z9VHDy (9 $ 65#E #!N88  #';G * 9   (.2NN  >>8;#*A  A6AAA!A AAF #*'.(.zD zD zDzD!zD%zD&zDzD zDzD~1,/  *//@YY   NN DD 99%:ADADN(-$  $     ;0%T IJLX $+'. vH!vH% vH  vHvHvK$-^IM\7r7r!L!LFTT>"L"LH)V    D.    E.     C.    D.  F.  F."  K.!  J.!ND"-GKIG!  K:I  G:$  M( K+MX%*M,@,@w,@,WN# (<(<6(<(RL'% )T%% )NT$' +MX"' +KX#$ (LT J :X  :X  :X:X:XrHrwFrrc [XUS9up[USS5nUcSn[R"SUS35nU[:Xd[ U5(a[ [RU5nSn[R"USS9S :Xa UR[R5nOUbCUS :Xa=[R"U[S 9n [R"U UUU[U5S 9n X4$[!UUUSU=(d SS 9upSnU(a U (aU n X4$U (aU nU n X4$[#XXS9upX4$URn[%U[&5(a2[ [(U5n[+X R,5nUR.n O[R0"US5(aH[%U[(5(a UR.n[ [RU5n[#XXS9upO_UR[2:wa UR[RSS9nSn[ [RU5nUR5U5n U(aU R75n [%U [R5(d[9U 55eU RR:S:XdeU RS:wde[=U R5(deX4$)a Parameters ---------- data : np.ndarray or ExtensionArray dtl.ensure_arraylike_for_datetimelike has already been called. copy : bool, default False tz : tzinfo or None, default None dayfirst : bool, default False yearfirst : bool, default False ambiguous : str, bool, or arraylike, default 'raise' See pandas._libs.tslibs.tzconversion.tz_localize_to_utc. out_unit : str or None, default None Desired output resolution. Returns ------- result : numpy.ndarray The sequence converted to a numpy array with dtype ``datetime64[unit]``. Where `unit` is "ns" unless specified otherwise by `out_unit`. tz : tzinfo or None Either the user-provided tzinfo or one inferred from the data. Raises ------ TypeError : PeriodDType data is passed r"rNNrzrKrLFrintegerrr)rCrrr)rr allow_objectr)rCrrr}rSM8)maybe_convert_dtyper1rMrNr?r'rrr rr rrr array_to_datetime_with_tzrobjects_to_datetime64_construct_from_dt64_naiverr)rw_maybe_infer_tzrCrWr~r$rrrXrr)rrrCrrrrr out_dtypeobj_datarlrO inferred_tz_s rErrsL%TB7JDw-J3xj*+IVz::BJJ% ??4 .) ;;;rxx(D ^ W 4zz$f5H44!#(2 F: %:!#"!)T & "IDk#:  " : 74 : ZZ *o..M4( R ) S ) ) dM * *==DBJJ%1 d  :: $;;rxxe;4DDBJJ%9%  fbjj ) )74<7 ) <<   ## # <<4   fll + ++ + :rHcZURn[U5(d[U5n[XSS9nSnURRS:Xa8UR URR S55nURnSnUb~URnURS:aUR5n[U5n[R"URS5XUS9nURU5nURU5nURU:XdUR5eUnXr4$)zH Convert datetime64 data to a supported dtype, localizing if necessary. Fr>??1%988  5$ % % %0E#ZZI$<$cooeS99~i&:&:2&C&C A I/    sC CCc0[R"X5n[R"U5n[R"U5nUb,Ub)[R "X25(d [S5eU$UbUnU$![an[S5UeSnAff=f)a{ If a timezone is not explicitly given via `tz`, see if one can be inferred from the `start` and `end` endpoints. If more than one of these inputs provides a timezone, require that they all agree. Parameters ---------- start : Timestamp end : Timestamp tz : tzinfo or None Returns ------- tz : tzinfo or None Raises ------ TypeError : if start and end timezones do not agree z>Start and end cannot both be tz-aware with different timezonesNz0Inferred time zone not equal to passed time zone)r infer_tzinfoAssertionErrorrUrrh)rQrRrCrerrs rErr? s,,,U8 ((5K    #B ~+1##K44 !ST T5 I   I!  L  sA:: B BBcbU(a&UbUR5nUbUR5nX4$r@)r)rQrRrs rErrj s1  OO%E ?--/C :rHcUbJURc=US:waUOSnX4SS.n[U[5(dUcX%S'UR"S0UD6nU$)a Localize a start or end Timestamp to the timezone of the corresponding start or end Timestamp Parameters ---------- ts : start or end Timestamp to potentially localize freq : Tick, DateOffset, or None tz : str, timezone object or None ambiguous: str, localization behavior for ambiguous times nonexistent: str, localization behavior for nonexistent times Returns ------- ts : Timestamp NrF)rrrCrCrA)rrr1r)r+r_rCrr localize_argss rErrw s\, ~"))+"+g!5I5 &/SWX dD ! !T\"$$  ^^ ,m , IrHc## [U5n[U5nU[LaURU5nOSn[U5nU[LaURU5nOSnU(a(UR U5(dUR U5nO.U(a'UR U5(dUR U5nUcX:aURS:aSnSnUc XS- U--nUc XS- U-- n[[U5n[[U5nUnURS:aPXQ::aJUv XQ:XagURU5nURU5nXe::a[SUS35eUnXQ::aMIggXQ:aJUv XQ:XagURU5nURU5nXe:a[SUS35eUnXQ:aMIgg7f)a: Generates a sequence of dates corresponding to the specified time offset. Similar to dateutil.rrule except uses pandas DateOffset objects to represent time increments. Parameters ---------- start : Timestamp or None end : Timestamp or None periods : int or None offset : DateOffset unit : str Notes ----- * This method is faster for generating weekdays than dateutil.rrule * At least two of (start, end, periods) must be specified. * If both start and end are specified, the returned dates will satisfy start <= date <= end. Returns ------- dates : generator object NrrzOffset z did not increment datez did not decrement date) rrr r is_on_offset rollforwardrollbacknr_applyr)rQrRrrrDcur next_dates rErr s@v F e E C d# C.C #~kk$ V((//""5) V((--ooc"3;688q= {{f,, }{f,, E "E y# C C xx1}jIz c*I!))$/I 76(2I!JKKCjjIz c*I!))$/I 76(2I!JKKCjsE-G1AGG).)rCrrDrVrr))rCrrDrVrznp.dtype[np.datetime64])rz)rCrrDrVrrr@)rsrVrmrVrtr)rr3rrrCrrrrrrr8rr) rrrCrrrrr8rztuple[np.ndarray, bool])FrFrz) rrrrrr4rrrrV)rrrCr)rCrrrrr)F)rCrrrrr)rQrrRrrCrrr)rQTimestamp | NonerRr*rr)r+r*rr*) rQr*rRr*rrrr rDrV)e __future__rrrrtypingrrr runumpyrM pandas._libsr r pandas._libs.tslibsr r rrrrrrrrrrrrrrrrrpandas._libs.tslibs.dtypesr pandas.errorsr pandas.util._exceptionsr!pandas.util._validatorsr"pandas.core.dtypes.commonr#r$r%r&r'r(pandas.core.dtypes.dtypesr)r*r+pandas.core.dtypes.missingr,rr-rpandas.core.arrays._rangesr.pandas.core.commoncorecommonrpandas.tseries.frequenciesr/pandas.tseries.offsetsr0r1collections.abcr2pandas._typingr3r4r5r6r7r8r9r:rr<r>rGrFru TimelikeOps DatelikeOpsrwrrrrrrrrrrrrArHrErAs"  *:,46 ,2= 7 (   !.     $(11 1.1*%T[XCOOS__[XJ?&{ { {  {  {  {{{|) )*)26)CP))`#*G G   G ! G  G G T1p<5r8=220422j( ($(*7((V   "2 ?C Bl l ll  l  lrH