Ë
|
nñúh#k ã óB d dl mZ d dlmZmZmZ d dlmZmZmZ d dl Z d dl
|
Z d dl m Z d dlmZmZ d dlmZmZmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$ d dl%m&Z& d d l'm(Z( d d
|
l)m*Z* d d l+m,Z, d d l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 d d l4m5Z5m6Z6m7Z7 d dl8m9Z9 d dl:m;Z< d dl=m>Z> d dl?m@c mAZB d dlCmDZD d dlEmFZFmGZG er&d dlHmIZI d dlJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZR d dlSmTZT d dl:mUZU dZVed,d-d« ZWed,d.d« ZW d/ d0dZWd1d2dZX G d d e<j² e<j´ « Z[d dd d d dd d3d!Z\ d4d"Z] d5 d6d#Z^d1d7d$Z_d8d%Z`d& Za d9 d:d'Zb d;d(Zc d<d)Zd d=d*Ze d>d+Zfy)?é )Ú annotations)ÚdatetimeÚ timedeltaÚtzinfo)Ú TYPE_CHECKINGÚcastÚoverloadN)Úusing_string_dtype)ÚlibÚtslib)Ú
|
BaseOffsetÚNaTÚNaTTypeÚ
|
ResolutionÚ TimestampÚastype_overflowsafeÚfieldsÚget_resolutionÚget_supported_dtypeÚget_unit_from_dtypeÚints_to_pydatetimeÚis_date_array_normalizedÚis_supported_dtypeÚ is_unitlessÚnormalize_i8_timestampsÚ timezonesÚ to_offsetÚtz_convert_from_utcÚ tzconversion)Úabbrev_to_npy_unit)ÚPerformanceWarning)Úfind_stack_level)Úvalidate_inclusive)Ú DT64NS_DTYPEÚ INT64_DTYPEÚ is_bool_dtypeÚis_float_dtypeÚis_string_dtypeÚ pandas_dtype)ÚDatetimeTZDtypeÚExtensionDtypeÚ PeriodDtype)Úisna)Ú datetimelike)Úgenerate_regular_range)Úget_period_alias)ÚDayÚTick)ÚIterator)Ú ArrayLikeÚDateTimeErrorChoicesÚDtypeObjÚIntervalClosedTypeÚSelfÚ TimeAmbiguousÚTimeNonexistentÚnpt©Ú DataFrame©Ú PeriodArrayi' c ó y ©N© ©ÚtzÚunits úOH:\Change_password\venv_build\Lib\site-packages\pandas/core/arrays/datetimes.pyÚ tz_to_dtyperG _ ó àó c ó y rA rB rC s rF rG rG d rH rI c óR | t j d| d« S t | |¬« S )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[ú]rC )ÚnpÚdtyper* rC s rF rG rG i s- ð
|
zÜxx#dV 1 Ó&Ð&ä "¨4Ô0Ð0rI c ó@ fd}| |_ ||_ t |« S )Nc ó | j « }| j v r£j d« rn| j }d}|r.|j }|j d|j dd« « }t j || j || j ¬« }|S t j || j ¬« }|S | j v r7t j || j ¬« }| j |d ¬« }|S t j || j ¬« }| j |d d¬« }|S ) N)ÚstartÚendé Ú startingMonthÚmonth©Úreso©Ú
|
fill_valueÚfloat64)rZ Úconvert)Ú_local_timestampsÚ _bool_opsÚendswithÚfreqÚkwdsÚgetr Úget_start_end_fieldÚfreqstrÚ_cresoÚget_date_fieldÚ _object_opsÚget_date_name_fieldÚ_maybe_mask_results)ÚselfÚvaluesr` Úmonth_kwra ÚresultÚfields rF Úfz_field_accessor.<locals>.f s+ ø Ø×'Ñ'Ó)à DNNÑ "ð ~~Ð .Ô/ØyyØ ÙØ 99DØ #xx¨¸¿¹À'È2Ó9NÓ OHä ×3Ñ3ØE 4§<¡<°ÀÇ Á ôð Mô ×.Ñ.¨v°uÀ4Ç;Á;ÔOð Mà D×$Ñ$Ñ $Ü×/Ñ/°¸ÀDÇKÁKÔPFØ×-Ñ-¨fÀÐ-ÓFFð ô ×*Ñ*¨6°5¸t¿{¹{ÔKFØ×-Ñ-Ø 4°ð .ó Fð rI )Ú__name__Ú__doc__Úproperty)Únamern Ú docstringro s ` rF Ú_field_accessorru ~ s# ø ô ðD AJØAIÜ A;ÐrI c ó e Zd ZU dZdZ ej dd« Zeej fZ d Z
|
dZ e dzd« Z g d¢Zd ed
|
< d d gZd ed < g d¢Zd ed< g d¢Zd ed< eez ez ez dgz Zd ed< g d¢Zd ed< dZded< dZded< eZed{d « Zed « Zedef d| fd « Z edd d d}d!« Z edd e j> e j> d d d"d# d~d$« Z e ddd% dd&« Z!dd'Z"dd(Z#dd)Z$dd*Z%e d
d+« Z&e dd,« Z'e'jP d- « Z'e dd.« Z)e dd/« Z*e dd0« Z+dd fd1 Z,dd2Z-dd} fd3 Z.ddd4 dd5Z/dd6Z0dd7Z1dd8Z2dd9Z3dd:Z4e5jl d dd;« Z7dd<Z8dd=Z9ddd>Z:ddd?Z;ddd@Z<e ddA« Z=e ddB« Z>e ddC« Z?ddDZ@ eAdEdFdG« ZB eAdHdIdJ« ZC eAdKdLdM« ZD eAdNdOdP« ZE eAdQdRdS« ZF eAdTdUdV« ZG eAdWdXdY« ZH eAdZdd[« ZId\ZJ eAd]d^eJ« ZKeKZLeKZM eAd_d`da« ZNeNZO eAdbdcdd« ZP eAdedfdg« ZQeQZRdhZS eAdidieSj© dj¬k« « ZU eAdldleSj© dm¬k« « ZV eAdndndo« ZW eAdpdpdq« ZX eAdrdrds« ZY eAdtdtdu« ZZ eAdvdvdw« Z[ddxZ\ d ddyZ] xZ^S )Ú 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'))
|
<DatetimeArray>
|
['2023-01-01 00:00:00', '2023-01-02 00:00:00']
|
Length: 2, dtype: datetime64[ns]
|
Ú datetimearrayr Únsc óR t j | d« xs t | t « S ©NÚM)r Ú is_np_dtypeÚ
|
isinstancer* )Úxs rF ú<lambda>zDatetimeArray.<lambda>Ö s# ¤S§_¡_°Q¸Ó%<ò &Ä
|
Ø ?óA rI )r Ú
|
datetime64Údatec ó t S rA )r ©rj s rF Ú _scalar_typezDatetimeArray._scalar_typeÛ s äÐrI )Úis_month_startÚ is_month_endÚis_quarter_startÚis_quarter_endÚ is_year_startÚ is_year_endÚ is_leap_yearz list[str]r^ r` rD rg )ÚyearrV ÚdayÚhourÚminuteÚsecondÚweekdayÚ dayofweekÚ day_of_weekÚ dayofyearÚ day_of_yearÚquarterÚ days_in_monthÚ daysinmonthÚ microsecondÚ
|
nanosecondÚ
|
_field_ops)r ÚtimeÚtimetzÚ
|
_other_opsrE Ú_datetimelike_ops) Ú to_periodÚ tz_localizeÚ
|
tz_convertÚ normalizeÚstrftimeÚroundÚfloorÚceilÚ
|
month_nameÚday_nameÚas_unitÚ_datetimelike_methodsiè ú)np.dtype[np.datetime64] | DatetimeTZDtypeÚ_dtypeNúBaseOffset | NoneÚ_freqc óf t j |d¬« dvrt | j ||¬« S )NT©Úskipna)r r ©rO )r Ú infer_dtypeÚ
|
ValueErrorÚ_from_sequence)ÚclsÚscalarsrO s rF Ú _from_scalarszDatetimeArray._from_scalars s4 ä ??7¨4Ô 0Ð8RÑ Rô Ð Ø×!Ñ! '°Ð!Ó7Ð7rI c ó* t |« }t |j « t |t j « r |j |k7 r t d« |S t j
|
|j « d }||j k7 r t d« |S )Nz'Values resolution does not match dtype.r )Ú_validate_dt64_dtyperO r~ rN r¶ Ú datetime_datarE )r¸ rk rO Úvunits rF Ú_validate_dtypez DatetimeArray._validate_dtype# s ô % UÓ+Ü V\\Ô*Ü eRXXÔ &Ø||uÒ$Ü Ð!JÓKÐKð
|
ô ×$Ñ$ V§\¡\Ó2°1Ñ5EØ
|
|
Ò"Ü Ð!JÓKÐKØ rI c óH t |t j « sJ |j dk( sJ t |t j « r ||j k( sJ t |« r&J |j t |j « k( sJ t | % ||« }||_
|
|S r{ ) r~ rN ÚndarrayÚkindrO r re r ÚsuperÚ _simple_newr° )r¸ rk r` rO rm Ú __class__s rF rÄ zDatetimeArray._simple_new2 s ø ô &¤"§*¡*Ô-Ð-Ð-ØzzSÒ Ð Ð Ü eRXXÔ &ØFLLÒ(Ð (Ð(Ü" 5Ô)Ð )Ð)ð <<Ô#6°v·|±|Ó#DÒDÐ DÐDäÑ$ V¨UÓ3Ø Ø rI F©rO Úcopyc ó* | j |||¬« S ©NrÆ )Ú_from_sequence_not_strict)r¸ r¹ rO rÇ s rF r· z DatetimeArray._from_sequenceG s à×,Ñ,¨W¸EÈÐ,ÓMÐMrI Úraise)rO rÇ rD r` ÚdayfirstÚ yearfirstÚ ambiguousc ó |du } |t j u rd}nt j |« }t |« }t ||| « }d}
|
|t j |« }
|
t j ||d¬« \ }}d} t |t « r |j } t |||||||
|
¬« \ } }t ||| « | | r t d« t j | j « d } t# || « }| j% | | |¬« }|
|
|
|
|j& k7 r|j) |
|
« }d|i}|j+ ||« |S ) z\
|
A non-strict version of _from_sequence, called from DatetimeIndex.__new__.
|
Nrw )Úcls_name©rÇ rD rÌ rÍ rÎ Úout_unitz^Passed data is timezone-aware, incompatible with 'tz=None'. Use obj.tz_localize(None) instead.r ©r` rO rÎ )r Ú
|
no_defaultr Ú maybe_get_tzr¼ Ú_validate_tz_from_dtypeÚdtlÚ dtype_to_unitÚ!ensure_arraylike_for_datetimeliker~ rw r` Ú_sequence_to_dt64r¶ rN r½ rO rG rÄ rE r« Ú_maybe_pin_freq)r¸ ÚdatarO rÇ rD r` rÌ rÍ rÎ Úexplicit_tz_nonerE Ú inferred_freqÚsubarrÚ data_unitÚ
|
data_dtyperm Ú validate_kwdss rF rÊ z'DatetimeArray._from_sequence_not_strictK s] ð& :ÐØ Ñ ØBä×'Ñ'¨Ó+Bä$ UÓ+ä $ U¨BÐ0@Ó AàØ Ð Ü×$Ñ$ UÓ+Dä×:Ñ:Ø $ ô
|
|
dð Ü dMÔ *Ø IIMä&Ø ØØØ Ø Ø Øô
|
|
ô rÐ+;Ô<Ø >Ñ .Ü ð5óð ô
|
×$Ñ$ V§\¡\Ó2°1Ñ5 Ü YÓ/
|
Ø ¨mÀ: ÓNØ Ð ¨¯ © Ò 3à^^ DÓ)Fà$ iÐ0 Ø× Ñ t ]Ô3Ø rI ©rE c
|
óÒ t j |« }| t d |||fD « « r t d« t j
|
||||« dk7 r t d« t |« }| t |« }| t |« }|t u s|t u r t d« |
|
|
|
dvr t d« d}
|
||j |
|
d ¬
|
« }||j |
|
d ¬
|
« }t | « \ } } t |||« \ }}t |||« }| t |||||« }t |||||« }|'t |t « r&||j! d « }||j! d « }t |t" « rt% |||||
|
¬ « } nMt' |||||
|
¬ « }t) j* |D cg c] }|j, c}t( j. ¬ « } | |j0 n |j0 }|Ô|Òt3 j4 |« s%t7 |
|
« }t9 j: | ||||¬« } ||j! |||« }||j! |||« }nmt= t> |« }t) j@ d|j, |j, z
|
|d¬ « |j, z } | jB dk7 r| jE d« } ||k( r
|
| sj| sh| dd } nbt |« j, }t |« j, }| r| s4| stG | « r | d |k( r| dd } | stG | « r | d |k( r| d d } | jI d|
|
d« }tK ||
|
¬ « }| jM |||¬« S c c}w )Nc 3 ó$ K | ] }|d u
|
y wrA rB )Ú.0r s rF ú <genexpr>z0DatetimeArray._generate_range.<locals>.<genexpr> s è ø Ò I¨a T¤ Ñ Iùs z1Must provide freq argument if no data is suppliedé zVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedz$Neither `start` nor `end` can be NaT)ÚsÚmsÚusry z+'unit' must be one of 's', 'ms', 'us', 'ns'ry F)Úround_okrã )rR rS ÚperiodsÚoffsetrE r´ ©rÎ Ú nonexistentÚcresor Úint64Úi8é éÿÿÿÿz datetime64[rM rÓ )'r× Úvalidate_periodsÚanyr¶ ÚcomÚcount_not_noner r r r« r# Ú_maybe_normalize_endpointsÚ_infer_tz_from_endpointsÚ_maybe_localize_pointr~ r1 r¢ r2 r/ Ú_generate_rangerN ÚarrayÚ_valuerò rD r Úis_utcr r Útz_localize_to_utcr ÚintÚlinspacerO ÚastypeÚlenÚviewrG rÄ )r¸ rR rS rí r` rD r¤ rÎ rð Ú inclusiverE Úleft_inclusiveÚright_inclusiveÚi8valuesÚxdrr Ú endpoint_tzrñ Ústart_i8Úend_i8Ú dt64_valuesrO s rF rý z DatetimeArray._generate_range s| ô ×&Ñ& wÓ/Ø <CÑ I°G¸UÀCÐ3HÔ IÔ IÜ Ð PÓQÐ Qä × Ñ e S¨'°4Ó 8¸AÒ =Ü ð<óð ô à Ð Ü eÓ$Eà ?ÜC.Cà C<3¤#:Ü Ð CÓDÐ Dà Ð ØÐ2Ñ2Ü Ð!NÓOÐOàDà Ð ØMM $°MÓ7EØ ?Ø++d¨U+Ó3Cä*<¸YÓ*GÑ'Ü/°°s¸IÓF
|
sÜ % e¨S°"Ó 5à >ä)¨%°°r¸9ÀkÓREÜ'¨¨T°2°yÀ+ÓNCà Ñ ô $¤Ô$ØÐ$Ø !× -Ñ -¨dÓ 3EØ?Ø //¨$Ó/Cä$¤Ô%Ü1°%¸¸gÀtÐRVÔWä%Ø S°'À$ÈTôô 88°sÖ$;°! Q§X£XÒ$;Ä2Ç8Á8ÔLà&+Ð&7%((¸S¿V¹VKà~ +Ð"5Ü ×'Ñ'¨Ô+ô /¨tÓ 4EÜ +× >Ñ >Ø ØØ"+Ø$/Ø #ô Hð Ð$Ø !× -Ñ -¨b°)¸[Ó IEØ?Ø //¨"¨i¸ÓECô 3 Ó(Gä Aszz¨E¯L©LÑ 8¸'ÈÔQØ,,ñ ð ð ~~ Ò%ð $??¨4Ó0à C<Ù!©/Ø# A b>ä Ó'×.Ñ.HÜ s^×*Ñ*FÙ!© Ù%¬#¨h¬-¸HÀQ¹KÈ8Ò<SØ '¨¨|HÙ&¬3¨x¬=¸XÀb¹\ÈVÒ=SØ '¨¨}Hà mm k°$°°qÐ$9Ó: ÜB TÔ*Ø{°¸UÓCÐCùòi %<s Æ#M$c ó$ t || j « s|t ur t d« | j |« |t u r*t j |j | j « S |j | j « j S )Nz 'value' should be a Timestamp.) r~ r
r r¶ Ú_check_compatible_withrN r rÿ rE r« Úasm8©rj Úvalues rF Ú _unbox_scalarzDatetimeArray._unbox_scalar sl Ü% ×!2Ñ!2Ô3¸ÄSÑ8HÜ Ð =Ó>Ð >Ø ×#Ñ# EÔ*Ø C<Ü== § ¡ ¨t¯y©yÓ9Ð 9à== §¡Ó+×0Ñ0Ð 0rI c ó0 t || j ¬« S )N©rD )r rD r s rF Ú_scalar_from_stringz!DatetimeArray._scalar_from_string s Ü 4§7¡7Ô+Ð+rI c ó8 |t u ry | j |« y rA )r Ú_assert_tzawareness_compat)rj Úothers rF r z$DatetimeArray._check_compatible_with s Ø C<Ø Ø ×'Ñ'¨Õ.rI c ó |j d« }t j || j | j ¬« }|S )Nró )rX rD )r r Ú_from_value_and_resore rD )rj r r Útss rF Ú _box_funczDatetimeArray._box_func# s0 àt Ü × +Ñ +¨E¸¿ ¹ ÈÏÉÔ PØ rI c ó | j S )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.
|
)r® r s rF rO zDatetimeArray.dtype) s ð. {{ÐrI c ó0 t | j dd« S )aô
|
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
|
rD N)ÚgetattrrO r s rF rD zDatetimeArray.tzB s ô> tzz 4¨Ó.Ð.rI c ó t d« )NzNCannot directly set timezone. Use tz_localize() or tz_convert() as appropriate)ÚAttributeErrorr s rF rD zDatetimeArray.tzc s ô ð -ó
|
ð
|
rI c ó | j S )z(
|
Alias for tz attribute
|
r r s rF r zDatetimeArray.tzinfok s ð
|
wwrI c óZ t | j | j | j ¬« S )zN
|
Returns True if all of the dates are at midnight ("no time")
|
rW )r Úasi8rD re r s rF Ú is_normalizedzDatetimeArray.is_normalizedr s ô
|
(¨¯ © °4·7±7ÀÇÁÔMÐMrI c óZ t | j | j | j ¬« S )NrW )r r' rD re r s rF Ú_resolution_objz DatetimeArray._resolution_objy s ä dii¨¯©°t·{±{ÔCÐCrI c óN || j rt }t | ||¬« S rÉ )rD ÚobjectrÃ Ú __array__)rj rO rÇ rÅ s rF r- zDatetimeArray.__array__ s( ø Ø =TWWäEäwÑ u°4Ð Ó8Ð8rI c # óh K | j dkD r!t t | « « D ] }| | y| j }t | « }t }||z dz }t |« D ]I }||z }t |dz |z |« }t ||| | j d| j ¬« }|E d{ K y7 w)zt
|
Return an iterator over the boxed values
|
|
Yields
|
------
|
tstamp : Timestamp
|
rô Ú timestamp)rD ÚboxrX N) ÚndimÚranger r' Ú_ITER_CHUNKSIZEÚminr rD re ) rj ÚirÜ ÚlengthÚ chunksizeÚchunksÚstart_iÚend_iÚ converteds rF Ú__iter__zDatetimeArray.__iter__ s è ø ð 99q=Ü3t9Ó%ò Ø1g ñ ð 99DÜYFÜ'IØ Ñ)¨QÑ.Fä6]ò %Øi-ÜQ U iÑ /°Ó8Ü .Ø Ð'ØwwØ#Ø ô ð %×$Ñ$ñ %ð %ús B&B2Â(B0Â)B2c ó t |« }|| j k( r|r| j « S | S t |t « rt |t
|
« st | ||¬« S | j t d« t j |j « }t | j ||¬« }t | « j ||| j ¬« S | j jt# j$ |d« rTt' |« sIt) |« r>t | j |d¬« }t | « j ||j ¬« S | j !t# j$ |d« r t d« | j ;t# j$ |d« r%|| j k7 rt' |« r t d« t |t* « r | j- |j ¬ « S t. j0 j | ||« S )
|
N©rÇ zCannot use .astype to convert from timezone-naive dtype to timezone-aware dtype. Use obj.tz_localize instead or series.dt.tz_localize instead©rO r` r| Tr´ zCannot 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) rO rÇ r~ r+ r* rà r rD Ú TypeErrorrN Ústrr Ú_ndarrayÚtyperÄ r` r r} r r r, r¡ r× ÚDatetimeLikeArrayMixin)rj rO rÇ Únp_dtypeÚ
|
res_valuesrÅ s rF r zDatetimeArray.astype¤ s¿ ø ô
|
UÓ#à DJJÒ ÙØyy{Ð"ØKä ~Ô .Ü e¤_Ô5ä w~ e°$~Ó7Ð7Ø ô ð4óð ô 88 E§I¡IÓ.Ü 0°· ± ÀÈtÔ T
|
ÜDz×-Ñ-¨jÀÈDÏIÉIÐ-ÓVÐVð GGOÜ sÔ+Ü Ô&Ü" 5Ô)ô -¨T¯]©]¸EÈÔMJÜ:×)Ñ)¨*¸J×<LÑ<LÐ)ÓMÐ Mð WWÐ ¤S§_¡_°U¸CÔ%@ô ðCóð ð GGOÜ sÔ+ØÒ#ÜEÔ"äð6óð ô
|
{Ô +Ø>> u§z¡z>Ó2Ð 2Ü×)Ñ)×0Ñ0°°u¸dÓCÐCrI )Úna_repÚ date_formatc ó || j rd}t j | j | j ||| j
|
¬« S )Nz%Y-%m-%d)rD ÚformatrG rX )Ú_is_dates_onlyr Úformat_array_from_datetimer' rD re )rj rG rH Úkwargss rF Ú_format_native_typesz"DatetimeArray._format_native_typesê sA ð Ð 4×#6Ò#6à$Kä×/Ñ/Ø II$''¨+¸fÈ4Ï;É;ô
|
ð
|
rI c ó¾ t |t j « r t |« }t |d« sy|j
|
}t j | j
|
|« S )Nr F)r~ rN r r Úhasattrr r Ú
|
tz_compare)rj r Úother_tzs rF Ú _has_same_tzzDatetimeArray._has_same_tzø sG ä eR]]Ô +ä eÓ$EäuhÔ'ØØ<<Ü×#Ñ# D§K¡K°Ó:Ð:rI c óä t |dd « }t |dd « }t |t « r|j j }|t
|
u ry | j | t d« y | t d« y )Nr rO z;Cannot compare tz-naive and tz-aware datetime-like objects.z:Cannot compare tz-naive and tz-aware datetime-like objects)r" r~ r* rO rD r r@ )rj r rR Ú other_dtypes rF r z(DatetimeArray._assert_tzawareness_compat s ä5 (¨DÓ1Ü e W¨dÓ3 ä k¤?Ô 3à {{~~HØ C<à Ø WW_ØÐ#Ü ØQóð ð $ð Ð ÜØLóð ð rI c ó0 t |t « rJ | j | j d « }n| } |j |j
|
« }|j j dk( r|j |j « }t | « j ||j ¬« }|j r|j « }d |_ | j |j | j « }|S # t $ r t j dt t# « ¬« | j% d« |z }t | « j' |« j) | j* « }t- | « s |j | j « cY S Y |S w xY w)Nr5 r´ zCNon-vectorized DateOffset being applied to Series or DatetimeIndex.©Ú
|
stacklevelÚO)r~ r2 rD r¢ Ú _apply_arrayrB rO r r rC rÄ r¤ r° ÚNotImplementedErrorÚwarningsÚwarnr! r" r r· r« rE r )rj rî rk rF rm s rF Ú _add_offsetzDatetimeArray._add_offset s] Ü f¤dÔ+Ð+Ð+à 77Ð Ø×%Ñ% dÓ+FàFð 5Ø ×,Ñ,¨V¯_©_Ó=JØ× Ñ ×$Ñ$¨Ò+ð (__¨V¯\©\Ó :
|
ô $Z×+Ñ+¨J¸j×>NÑ>NÐ+ÓOFØ× Ò Ø ×)Ñ)Ó+Ø # àwwÐ"Ø ×+Ñ+¨D¯G©GÓ4à øô- #ò 3Ü MMØUÜ"Ü+Ó-õ ð
|
SÓ)¨FÑ2Jä$Z×.Ñ.¨zÓ:×BÑBÀ4Ç9Á9ÓMFÜt9à ×)Ñ)¨$¯'©'Ó2Ò2ð ð ð- 3ús ´AC5 Ã5BFÆFc óÈ | j t j | j « r | j S t | j | j | j
|
¬« S )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.
|
rW )rD r r r' r re r s rF r] z DatetimeArray._local_timestampsE sC ð 77?i× .Ñ .¨t¯w©wÔ 7à99Ð Ü" 4§9¡9¨d¯g©g¸D¿K¹KÔHÐHrI c óØ t j |« }| j t d« t || j
|
¬« }| j | j || j ¬« S )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 localizerã r? ) r rÕ rD r@ rG rE rÄ rB r` )rj rD rO s rF r£ zDatetimeArray.tz_convertQ s` ô@ × #Ñ # BÓ 'à 77?äØQóð ô
|
B T§Y¡YÔ/Ø× Ñ § ¡ °UÀÇÁÐ ÓKÐKrI c ó d}||vrt |t « s t d« | j :|-t | j
|
| j | j ¬« }nNt d« t j |« }t j | j
|
|||| j ¬« }|j d| j d« }t || j ¬ « }d}t j |« s t! | « d
|
k( rt# |d « s | j$ }n|| j | j$ }| j' |||¬ « S ) aÌ
|
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]
|
)rË r Ú shift_forwardÚshift_backwardzoThe nonexistent argument must be one of 'raise', 'NaT', 'shift_forward', 'shift_backward' or a timedelta objectNrW z,Already tz-aware, use tz_convert to convert.rï rL rM rã rô r r? )r~ r r¶ rD r r' re r@ r rÕ r r r rE rG r r r- r` rÄ ) rj rD rÎ rð Únonexistent_optionsÚ new_datesÚnew_dates_dt64rO r` s rF r¢ zDatetimeArray.tz_localize s4 ðd RÐØ Ð 1Ñ 1¼*Ø ô;
|
ô ð%óð ð 77Ð ØzÜ /°· ± ¸4¿7¹7ÈÏÉÔ U ä Ð NÓOÐOä×'Ñ'¨Ó+Bô %×7Ñ7Ø ØØ#Ø 'Økkô Ið # ¨#¨d¯i©i¨[¸Ð(:Ó;ÜB T§Y¡YÔ/àÜ × Ñ BÔ ¤C¨£I°¢N¼4ÀÈqÑ@QÔ;Rð 99DØ ZDGGOà99DØ× Ñ °eÀ$Ð ÓGÐGrI c óZ t | j | j | j ¬« S )a¥
|
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)
|
)rD rX ©r r' rD re r s rF Ú to_pydatetimezDatetimeArray.to_pydatetimeY s ô " $§)¡)°·±¸d¿k¹kÔJÐJrI c ód t | j | j | j ¬« }|j | j
|
j « }t | « j ||j ¬« }|j d« }| j |j | j « }|S )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)
|
rW r´ Úinfer) r r' rD re r rB rO rC rÄ Ú
|
_with_freqr¢ )rj Ú
|
new_valuesr Údtas rF r¤ zDatetimeArray.normalizek s
ôL -¨T¯Y©Y¸¿¹ÀdÇkÁkÔR
|
Ø oo d§m¡m×&9Ñ&9Ó: ä4j×$Ñ$ [¸ ×8IÑ8IÐ$ÓJØnnWÓ%Ø 77Ð Ø// $§'¡'Ó*CØ
|
rI c óÒ ddl m} | j $t j dt
|
t « ¬« || j xs | j }t | j t « r5t | j d« r t | j « j }| t d« t! |« }||}|} |j" | j$ || j ¬« S )a
|
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 <timeseries.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]')
|
r r> zNConverting to PeriodArray/Index representation will drop timezone information.rW Ú_period_dtype_codez8You must pass a freq argument as current index has none.r )Úpandas.core.arraysr? rD r\ r] Ú UserWarningr" rd rÞ r~ r` r rP r, Ú_freqstrr¶ r0 Ú_from_datetime64rB )rj r` r? Úress rF r¡ zDatetimeArray.to_period sÍ õX 3à 77Ð Ü MMð2äÜ+Ó-õ ð <Ø<<Ò5 4×#5Ñ#5DÜ$))¤ZÔ0´WØ Ð/ô6ô # 4§9¡9Ó-×6Ñ6à|Ü ØNóð ô # 4Ó(Cð {ØàDØ+{×+Ñ+¨D¯M©M¸4ÀDÇGÁGÔLÐLrI c óô | j « }t j |d|| j ¬« }| j |d¬« }t « r'ddlm}m} || |t j ¬« ¬« S |S ) u
|
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')
|
r© ©ÚlocalerX NrY r ©Ú StringDtyperþ ©Úna_valuer´ © r] r rh re ri r
|
Úpandasrz rþ rN Únan©rj rx rk rm rz Úpd_arrays rF r© zDatetimeArray.month_nameè so ðb ×'Ñ'Ó)ä×+Ñ+Ø L¨°d·k±kô
|
ð ×)Ñ)¨&¸TÐ)ÓBÜ Ô ÷ ñ
|
F©+¼r¿v¹vÔ*FÔGÐ GØ rI c óô | j « }t j |d|| j ¬« }| j |d¬« }t « r'ddlm}m} || |t j ¬« ¬« S |S ) u
|
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')
|
rª rw NrY r ry r{ r´ r} r s rF rª zDatetimeArray.day_name( so ðb ×'Ñ'Ó)ä×+Ñ+Ø J v°D·K±Kô
|
ð ×)Ñ)¨&¸TÐ)ÓBÜ Ô ÷ ñ
|
F©+¼r¿v¹vÔ*FÔGÐ GØ rI c óR | j « }t |d| j ¬« S )aî
|
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)
|
r ©r0 rX ©r] r re ©rj Ú
|
timestampss rF r zDatetimeArray.timei s& ð@ ×+Ñ+Ó-
|
ä! *°&¸t¿{¹{ÔKÐKrI c ó\ t | j | j d| j ¬« S )aQ
|
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)
|
r r rh r s rF r zDatetimeArray.timetz s! ô< " $§)¡)¨T¯W©W¸&ÀtÇ{Á{ÔSÐSrI c óR | j « }t |d| j ¬« S )a5
|
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)
|
r r r
r s rF r zDatetimeArray.date s& ðB ×+Ñ+Ó-
|
ä! *°&¸t¿{¹{ÔKÐKrI c óØ ddl m} | j « }t j || j
|
¬« } ||g d¢d¬« }| j rd|j | j < |S )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
|
r r< rW )r Úweekr ÚUInt32)ÚcolumnsrO N) r~ r= r] r Úbuild_isocalendar_sarrayre Ú_hasnaÚilocÚ_isnan)rj r= rk ÚsarrayÚiso_calendar_dfs rF Ú isocalendarzDatetimeArray.isocalendarÒ sa õ@ %à×'Ñ'Ó)Ü×0Ñ0°¸d¿k¹kÔJÙ#Ø Ò 3¸8ô
|
ð ;;Ø04O× Ñ §¡Ñ -Ø Ð rI r ÚYaµ
|
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
|
rV r| 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
|
r ÚDa©
|
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
|
r ÚhaÇ
|
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
|
r ÚmaÍ
|
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
|
r ré aË
|
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
|
r rë aô
|
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
|
r aû
|
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
|
r Údowr Údoya
|
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')
|
r Úqax
|
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')
|
r Údima
|
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])
|
r Úfirst)Ú first_or_lastr Úlastr a
|
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])
|
r a
|
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])
|
r a~
|
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])
|
r a{
|
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])
|
r a
|
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 ó t j | j « }t j | j « }t j | j « }|dk }||xx dz cc< ||xx dz cc< |t j
|
d|z dz
|
dz « z d|z z t j |dz « z t j |d z « z
|
t j |d
|
z « z d z | j | j d z z | j d z z | j d z dz z | j d z dz z dz z 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
|
rè rô rT é iÉ é im é éd i g C:Aé< i i@B i Ê;é ) rN Úasarrayr rV r Úfixr§ r r r r r )rj r rV r Útestarrs rF Úto_julian_datez DatetimeArray.to_julian_date5 sM ô zz$))Ó$Ü
|
|
4::Ó&ÜjjÓ"Ø!)Ø W Ñ Ø g"Ñ à ÜffcEk CÑ'¨1Ñ,Ó-ñ .àDjñ ô hhtaxÓ ñ !ô hhtczÓ"ñ #ô
|
hhtczÓ"ñ #ð ñ ð Ø++ Ñ"ñ#à++ Ñ$ñ%ð ×"Ñ" TÑ)¨EÑ1ñ2ð // DÑ(¨5Ñ0ñ 1ð ññ ð
|
rI c ó ddl m} | j j j j dd« }t j |« }|j | j j |« |¬« } | j |||||¬« S )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´ )ÚaxisÚoutÚddofÚkeepdimsr³ )
|
rq r¬ rB rO rs ÚreplacerN rÄ r Ústd)
|
rj r® rO r¯ r° r± r³ r¬ Ú dtype_strÚtdas
|
rF r³ zDatetimeArray.stdX sx õd 6ð MM×'Ñ'×,Ñ,×4Ñ4°\À=ÓQ ÜÓ#à ×(Ñ(¨¯ © ×);Ñ);¸EÓ)BÈ%Ð(ÓPàwwD c°¸xÐPVwÓWÐWrI )Úreturnztype[Timestamp])rO r6 r¶ r8 )rk znpt.NDArray[np.datetime64]r` r¯ rO r r¶ r8 )rÇ Úbool) rÇ r· r` z'str | BaseOffset | lib.NoDefault | NonerÌ r· rÍ r· rÎ r9 r¶ r8 )NFrË rË Úboth)rí ú
|
int | Noner¤ r· rÎ r9 rð r: r r7 rE ú
|
str | Noner¶ r8 )r¶ ú np.datetime64)r¶ úTimestamp | NaTType)r¶ ÚNone)r r» r¶ r¼ )r¶ r )r¶ ú tzinfo | None)r¶ r· )r¶ r )NN)r¶ ú
|
np.ndarray)r¶ r3 )T)rG z str | floatr¶ únpt.NDArray[np.object_])rî r r¶ r8 )r¶ znpt.NDArray[np.int64])r¶ r8 )rË rË )rÎ r9 rð r: r¶ r8 )r¶ rÀ rA )r¶ r? )r¶ r= )r¶ znpt.NDArray[np.float64])NNNrô FT)r° r r± r· r³ r· )_rp Ú
|
__module__Ú __qualname__rq Ú_typrN r Ú_internal_fill_valuer Ú_recognized_scalarsÚ_is_recognized_dtypeÚ_infer_matchesrr r
r^ Ú__annotations__rg r r r r¬ Ú__array_priority__r° r$ Ú_default_dtypeÚ classmethodrº r¿ rÄ r· r rÔ rÊ rý r r r r rO rD Úsetterr r( r* r- r< r rN rS r r^ r] r£ r× Ú ravel_compatr¢ ri r¤ r¡ r© rª r r r r ru r rV r r r r r r Ú_dayofweek_docr r r r r r r r Ú _is_month_docrJ r r r r r r r rª r³ Ú __classcell__)rÅ s @rF rw rw ¨ s( ø
ñ(ðT DØ(2==¨°Ó5ÐØ# R§]¡]Ð3Ðñ Ðð 8Nà òó ðò Iyó ð % d^KÓ+ò J ó ò$ 7J Ó6à[Ñ 9Ñ,¨zÑ9¸V¸HÑDð yó ò (Ð9ó ð$ Ðð
|
6Ó5Ø #EÐ Ó#Ø!Nàò8ó ð8ð ñ ó ð ð ð #'Ø;Gð à*ðð ðð 9ð ð
|
|
ô ó ðð( Ø.2Àô Nó ðNð ð
|
ØØ >>Ø8;¿¹Ø Ø Ø#*ñAð
|
ð Að 6ðAð ðAð ðAð !ðAð
|
òAó ðAðF ð Ø Ø#*Ø'.Ø(.ðzDð ñzDð ð zDð ðzDð !ðzDð %ðzDð &ðzDð ðzDð
|
òzDó ðzDó~1ó,ó/óð òó ðð* ò /ó ð /ð@ YYñ
|
ó ð
|
ð òó ðð òNó ðNð òDó ðDö 9ó%ö:ADðN (-¸$ñ
|
Ø$ð
|
à ó
|
ó ;óó0%óT
|
IóJLðX ×Ñð $+Ø'.ð vHð !ðvHð %ð vHð
|
|
ò vHó ðvHóvKó$-ô^IMô\>ô@?ðB ò!Ló ð!LðF ò Tó ð Tð> ò"Ló ð"LóH) ñV ØØ ð ó Dñ. ØØ ð ó Eñ. Ø Ø ð ó Cñ. ØØ ð ó Dñ. ØØ ð óFñ. ØØ ð óFñ. "ØØ ð óKñ. !ØØ ð óJð.!NñD " -°¸ÓGKØIØGá!ØØ ð ó Kð: IÙ ØØ ð ó Gñ: $ØØ ð óMð( Kð+MñX %ØÐ*¨M×,@Ñ,@ÈwÐ,@Ó,WóNñ #ب ×(<Ñ(<È6Ð(<Ó(RóLñ 'ØØð% ó)ÐñT %ØØð% ó)NñT $ØØð' ó+MñX "ØØð' ó+KñX #ØØð$ ó(LóT
|
ðJ ØØ ØØ Øð:Xð
|
ð :Xð ð :Xð ÷:XrI rw FrË rÑ c ó t | ||¬« \ } }t | dd« }|d}t j d| d« }|t k( s t |« rît t j | « } d}t j | d¬« d k( r | j t j « } n|G|d
|
k( rBt j | t ¬ « } t j | |||t |« ¬ « }
|
|
|
|fS t! | ||d|xs d¬ « \ } } d}|r| r| }
|
|
|
|fS | r| }| }
|
|
|
|fS t# | |||¬« \ }
|
} |
|
|fS | j }t% |t& « r3t t( | « } t+ || j, « }| j. }
|
nÀt j0 |d« rIt% | t( « r | j. } t t j | « } t# | |||¬« \ }
|
}na| j t2 k7 r#| j t j d¬« } d}t t j | « } | j5 |« }
|
|r|
|
j7 « }
|
t% |
|
t j « sJ t9 |
|
« « |
|
j j: dk( sJ |
|
j dk7 sJ t= |
|
j « sJ |
|
|fS )aQ
|
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 rO Nry rL rM Fr² ÚintegerrË r´ )rD rÌ rÍ rñ )rÌ rÍ Ú allow_objectrÒ )rD rÇ rÎ r| r> ÚM8) Úmaybe_convert_dtyper" rN rO r, r( r rÁ r rµ r rò r§ r Úarray_to_datetime_with_tzr Úobjects_to_datetime64Ú_construct_from_dt64_naiver~ r* rw Ú_maybe_infer_tzrD rB r} r% r rÇ rC r r )rÜ rÇ rD rÌ rÍ rÎ rÒ rá Ú out_dtypeÚobj_datarm r; Ú inferred_tzÚ_s rF rÚ rÚ s ôL % T¨4°BÔ7JD$Üw¨Ó-JàÐØÜ3xj¨Ð*Ó+IàVÒ¨zÔ :ô BJJ Ó%ØÜ ??4¨Ô .°)Ò ;à;;rxxÓ(DØ ^ ¨WÒ 4Üzz $¬fÔ5HÜ×4Ñ4ØØØ!Ø#Ü(¨Ó2ô Fð 2:Ð ä%:ØØ!Ø#Ø "Ø!Ò) Tô &Ñ "I{ð DÙkð #ð 2:Ð ñ Ø Ø"ð 2:Ð ô 7Ø "¨4¸9ô ð 2:Ð àZZ
|
ô *oÔ.äM 4Ó(Ü R §¡Ó )Ø ä SÔ )ä dMÔ *Ø==DäBJJ Ó%Ü1Ø Rd¨iô
|
ð ::Ò $Ø;;rxx¨e;Ó4DØDÜBJJ Ó%Ø9Ó%á Ø ä fbjjÔ )Ð7¬4°«<Ó7Ð )Ø <<× Ñ Ò #Ð#Ð #Ø <<4Ò Ð Ð Ü fllÔ +Ð+Ð +Ø 2:ÐrI c óX | j }t |« st |« }t | |d¬« } d}| j j dk( r8| j | j j d« « } | j }d}|| j }| j dkD r| j « } t |« }t j | j d« |||¬« } | j |« } | j |« } | j |k( sJ | j « | }||fS )zP
|
Convert datetime64 data to a supported dtype, localizing if necessary.
|
FrÆ ú>ú<rô ró )rÎ rñ )rO r r r Ú byteorderr Ú newbyteorderÚshaper1 Úravelr r r r Úreshape)rÜ rD rÇ rÎ Ú new_dtyperã rà rm s rF rØ rØ s
|
ð
|
|
IÜ iÔ (ä'¨ Ó2 Ü" 4¨y¸uÔEØà zz×ÑsÒ"ð {{4::×2Ñ2°3Ó7Ó8ØJJ Øà ~ð
|
|
Ø 99q=Ø::<Dä'¨ Ó2 Ü×.Ñ.Ø IIdOR¨9¸Iô
|
ð yyÓ#Ø||EÓ"à ::Ò "Ð. D§J¡JÓ.Ð "Ø Fà 4<ÐrI c
|
óJ |dv sJ t j | t j ¬« } t j | ||||t |« ¬« \ }}|||fS |j j dk( r||fS |j t k( r|r||fS t d« t |« )a|
|
Convert data to array of timestamps.
|
|
Parameters
|
----------
|
data : np.ndarray[object]
|
dayfirst : bool
|
yearfirst : bool
|
utc : bool, default False
|
Whether to convert/localize timestamps to UTC.
|
errors : {'raise', 'ignore', 'coerce'}
|
allow_object : bool
|
Whether to return an object-dtype ndarray instead of raising if the
|
data contains more than one timezone.
|
out_unit : str, default "ns"
|
|
Returns
|
-------
|
result : ndarray
|
np.datetime64[out_unit] if returned values represent wall times or UTC
|
timestamps.
|
object if mixed timezones
|
inferred_tz : tzinfo or None
|
If not None, then the datetime64 values in `result` denote UTC timestamps.
|
|
Raises
|
------
|
ValueError : if data cannot be converted to datetimes
|
TypeError : When a type cannot be converted to datetime
|
)rË ÚignoreÚcoercer´ )ÚerrorsÚutcrÌ rÍ rñ r| z!DatetimeIndex has mixed timezones)
|
rN r§ Úobject_r Úarray_to_datetimer rO r r, r@ ) rÜ rÌ rÍ rë rê rÓ rÒ rm Ú tz_parseds rF r× r× C s½ ðN Ð2Ñ 2Ð2Ð 2ô ::d¤"§*¡*Ô -Dä ×/Ñ/Ø ØØ ØØÜ Ó*ô ÑFIð Ð ð yÐ Ð Ø × Ñ cÒ !ØyÐ Ð Ø Ò ñ Ø9Ð$Ð $ÜÐ;Ó<Ð<ô Ó Ð rI c óD t | d« s| |fS t | j « r*| j t « j d« } d}| |fS t j | j d« st | j « rt d| j d« t | j t « r t d« t | j t « rAt | j t « s't j | t j ¬« } d}| |fS ) a\
|
Convert data based on dtype conventions, issuing
|
errors where appropriate.
|
|
Parameters
|
----------
|
data : np.ndarray or pd.Index
|
copy : bool
|
tz : tzinfo or None, default None
|
|
Returns
|
-------
|
data : np.ndarray or pd.Index
|
copy : bool
|
|
Raises
|
------
|
TypeError : PeriodDType data is passed
|
rO ró Fr zdtype z& cannot be converted to datetime64[ns]zFPassing PeriodDtype data is invalid. Use `data.to_timestamp()` insteadr´ )rP r' rO r r$ r r r} r& r@ r~ r, r+ r* rN rþ rì )rÜ rÇ rD s rF rÕ rÕ sí ô( 4Ô !àTzÐädjjÔ!ð
|
{{<Ó(×-Ñ-¨dÓ3Øð& :Ðô#
|
SÔ )¬]¸4¿:¹:Ô-Fä& §¡ Ð,RÐSÓTÐTÜ DJJ¤ Ô ,ô Ø Tó
|
ð
|
ô
|
DJJ¤Ô /¼
|
Ø
|
|
Oô9ô xx¤B§J¡JÔ/Øà :ÐrI c ój | |} | S | | S t j | |« st d| d| « | S )aV
|
If a timezone is inferred from data, check that it is compatible with
|
the user-provided timezone, if any.
|
|
Parameters
|
----------
|
tz : tzinfo or None
|
inferred_tz : tzinfo or None
|
|
Returns
|
-------
|
tz : tzinfo or None
|
|
Raises
|
------
|
TypeError : if both timezones are present but do not match
|
zdata is already tz-aware z , unable to set specified tz: )r rQ r@ )rD rÜ s rF rÙ rÙ Å sc ð$
|
zØ ð Ið
|
Ð Ø ð Iô × !Ñ ! " kÔ 2ÜØ'¨ }ð 5!Ø!# ð &ó
|
ð
|
ð IrI c óÒ | ät | « } | t j d« k( r d}t |« t | t j « r| j
|
dk7 s+t | « r t | t j t f« st d| d« t | dd« rDt t | « } t | j t j | j « ¬« } | S ) a£
|
Check that a dtype, if passed, represents either a numpy datetime64[ns]
|
dtype or a pandas DatetimeTZDtype.
|
|
Parameters
|
----------
|
dtype : object
|
|
Returns
|
-------
|
dtype : None, numpy.dtype, or DatetimeTZDtype
|
|
Raises
|
------
|
ValueError : invalid dtype
|
|
Notes
|
-----
|
Unlike _validate_tz_from_dtype, this does _not_ allow non-existent
|
tz errors to go through
|
NrÔ zhPassing in 'datetime64' dtype with no precision is not allowed. Please pass in 'datetime64[ns]' instead.r| z Unexpected value for 'dtype': 'ze'. Must be 'datetime64[s]', 'datetime64[ms]', 'datetime64[us]', 'datetime64[ns]' or DatetimeTZDtype'.rD )rE rD )r) rN rO r¶ r~ r r r* r" r rE r Útz_standardizerD )rO Úmsgs rF r¼ r¼ ã sÔ ð, ÐÜ UÓ#Ø BHHTNÒ "ð;ð ô S/Ð !ô ubhhÔ 'ØsÒ"Ô*<¸UÔ*CÜE¤B§H¡H¬oÐ#>Ô?Ü Ø1°%°ð 98ð 8óð ô 5$ Ô %ô ¨%Ó0EÜ#ØZZ¤I×$<Ñ$<¸U¿X¹XÓ$FôEð LrI c ól | ¢t | t « r t j | « } t | dd« }|2|!t j ||« s t d« |r t d« |}|9t j | d« r#|!t j ||« s t d« |S # t $ r Y w xY w)aÍ
|
If the given dtype is a DatetimeTZDtype, extract the implied
|
tzinfo object from it and check that it does not conflict with the given
|
tz.
|
|
Parameters
|
----------
|
dtype : dtype, str
|
tz : None, tzinfo
|
explicit_tz_none : bool, default False
|
Whether tz=None was passed explicitly, as opposed to lib.no_default.
|
|
Returns
|
-------
|
tz : consensus tzinfo
|
|
Raises
|
------
|
ValueError : on tzinfo mismatch
|
NrD z-cannot supply both a tz and a dtype with a tzz3Cannot pass both a timezone-aware dtype and tz=Noner| zHcannot supply both a tz and a timezone-naive dtype (i.e. datetime64[ns])) r~ rA r* Úconstruct_from_stringr@ r" r rQ r¶ r r} )rO rD rÝ Údtzs rF rÖ rÖ
|
sÊ ð. ÐÜ eSÔ !ð Ü'×=Ñ=¸eÓDô eT 4Ó(Ø ?Ø~¤i×&:Ñ&:¸2¸sÔ&CÜ Ð!PÓQÐQÙ Ü Ð!VÓWÐWØBà >coo¨e°SÔ 9ð ~¤i×&:Ñ&:¸2¸sÔ&CÜ ðAóð ð
|
Iøô/ ò ñ
|
ð ús B' Â' B3Â2B3c ó t j | |« }t j |« }t j |« }|%|#t j
|
||« s t d« |S ||}|S # t $ r}t d« |d}~ww xY w)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_tzinfoÚAssertionErrorr@ rÕ rQ )rR rS rD rÜ Úerrs rF rû rû P
|
s ð,Ü ×,Ñ,¨U°CÓ8 ô ×(Ñ(¨Ó5KÜ × Ñ Ó #Bà ~+Ð1Ü×#Ñ# K°Ô4Ü Ð!SÓTÐ Tð
|
Ið
|
Ð Ø à Iøô! ò äØ Ló
|
àð ûðús A/ Á/ B Á8 BÂB c óV |r$| | j « } ||j « }| |fS rA )r¤ )rR rS r¤ s rF rú rú {
|
s3 ñ Ø Ð ØOOÓ%Eà ?Ø--/Cà #:ÐrI c ó | D| j 8|dk7 r|nd}||dd}t |t « s|||d< | j di |¤} | S )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
|
Nrk F)rÎ rð rD rD rB )r r~ r2 r¢ )r r` rD rÎ rð Ú localize_argss rF rü rü
|
s_ ð,
|
~"))Ð+ð "+¨gÒ!5I¸5 Ø&/À ÐSWÑX Ü dDÔ ! T \Ø"$M$Ñ Ø R^^Ñ ,mÑ ,Ø IrI c # óT K t |« }t | « } | t ur| j |« } nd} t |« }|t ur|j |« }nd}| r#|j | « s|j | « } n$|r"|j |« s|j |« }||| k r|j dk\ rd}d}| | |dz
|
|z z }| ||dz
|
|z z
|
} t t | « } t t |« }| }|j dk\ rO||k rI| ||k( ry|j |« }|j |« }||k rt d| d« |}||k rHyy||k\ rI| ||k( ry|j |« }|j |« }||k\ rt d| d« |}||k\ rHyyw)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
|
Nr rô zOffset z did not increment datez did not decrement date) r r r r« Ú is_on_offsetÚ rollforwardÚrollbackÚnr Ú_applyr¶ )rR rS rí rî rE ÚcurÚ next_dates rF rý rý ©
|
sæ è ø ô@ vÓ Fô eÓ EØ CÑØ dÓ#àô C.CØ
|
#~Økk$Ó àá V×(Ñ(¨Ô/ð ×"Ñ" 5Ó)á V×(Ñ(¨Ô-ð oocÓ"ð 3 ;¨6¯8©8°qª=ØØà
|
{ð w { fÑ,Ñ,à }ð w { fÑ,Ñ,ä EÓ "EÜ
|
y#Ó
|
Cà
|
CØ xx1}ØSjØIàczð ð cÓ*IØ!×)Ñ)¨$Ó/IØCÒ Ü 7¨6¨(Ð2IÐ!JÓKÐKØCð Sjð SjØIàczð ð cÓ*IØ!×)Ñ)¨$Ó/IØCÒ Ü 7¨6¨(Ð2IÐ!JÓKÐKØCð Sjùs EF(ÅAF(Æ&F().)rD r rE rA r¶ r* )rD r½ rE rA r¶ znp.dtype[np.datetime64])ry )rD r¾ rE rA r¶ r rA )rs rA rn rA rt rº )rÜ r4 rÇ r· rD r¾ rÌ r· rÍ r· rÎ r9 rÒ rº )
|
rÜ r¿ rD r¾ rÇ r· rÎ r9 r¶ ztuple[np.ndarray, bool])FrË Fry )
|
rÜ r¿ rë r· rê r5 rÓ r· rÒ rA )rÇ r· rD r¾ )rD r¾ rÜ r¾ r¶ r¾ )F)rD r¾ rÝ r· r¶ r¾ )rR r rS r rD r¾ r¶ r¾ )rR úTimestamp | NonerS r r¤ r· )r r r¶ r )
|
rR r rS r rí r¹ rî r rE rA )gÚ
|
__future__r r r r Útypingr r r r\ ÚnumpyrN Úpandas._configr
|
Ú pandas._libsr r Úpandas._libs.tslibsr r r r r r r r r r r r r r r r r r r Úpandas._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- rq r. r× Úpandas.core.arrays._rangesr/ Úpandas.core.commonÚcoreÚcommonrø Úpandas.tseries.frequenciesr0 Úpandas.tseries.offsetsr1 r2 Úcollections.abcr3 Úpandas._typingr4 r5 r6 r7 r8 r9 r: r; r~ r= r? r3 rG ru Ú TimelikeOpsÚ DatelikeOpsrw rÚ rØ r× rÕ rÙ r¼ rÖ rû rú rü rý rB rI rF ú<module>r sº ðÝ "÷ñ ÷
|
ñ ó
|
ã å -÷÷÷ ÷ ÷ ÷ ñ õ* :Ý ,Ý 4Ý 6÷÷ ÷ñ õ
|
,å 2Ý =ß Ð å 7÷ñ
|
Ý(÷ ÷ ó õ !Ý.ð ð
|
óó
|
ðð
|
óó
|
ðð
|
$(ð1Øð1Ø ð1à.ó1ô*%ôTj XCOO S§_¡_ô j Xðh? Ø ØØØ &Ø ñ{Ø
|
ð{ð ð{ð ð {ð
|
ð {ð ð {ð ð{ð ó{ð|)Ø
|
ð)Ø *ð)Ø26ð)ØCPð)à ó)ð` Ø#*Ø ØðG Ø
|
ðG ð
|
ð G ð
|
!ð G ð ð G ð óG ôT1ópò<5ðr 8=ð2Ø ð2Ø04ð2àó2ðj(Ø ð(Ø$ð(Ø*7ð(àó(ðV
|
Ø ð
|
Ø"2ð
|
Ø?Có
|
ð Øð àó ðBl Ø ðl à ðl ð ðl ð ð l ð ô l rI
|
