Ë
|
nñúhº ã óØ d dl mZ d dlZd dlZd dlmZ d dlZd dlZ d dl
|
Z
|
d dl m Z m Z mZmZmZ d dlmZmZmZmZmZmZ d dlmZ d dlm 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' d d l(m)Z)m*Z* d dl+m,c m-Z. d dl/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5 d dl6m7Z7 er"d dl8m9Z9 d dl:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZB d dlCmDZDmEZE d dlFmGZG d ZH e5e)j e)j D cg c] } | dvr|
|
c} z e)d¬« e5dge)d¬« e5g d ¢e)j z e)« G d d e3« « « « ZL d#dd d$d ZM d% d&d!ZNd'd"ZOyc c} w )(é )Ú annotationsN)Ú TYPE_CHECKING)ÚNaTÚPeriodÚ TimestampÚindexÚlib)Ú
|
ResolutionÚTickÚ TimedeltaÚperiods_per_dayÚ timezonesÚ to_offset)Úprefix_mapping)Úcache_readonlyÚdoc)Úfind_stack_level)Ú is_scalar)ÚDatetimeTZDtype)Ú ABCSeries)Úis_valid_na_for_dtype)Ú DatetimeArrayÚ tz_to_dtype)ÚIndexÚmaybe_extract_name)ÚDatetimeTimedeltaMixin)Ú inherit_names)Úto_time)ÚHashable)ÚDtypeÚDtypeObjÚ FrequencyÚIntervalClosedTypeÚSelfÚ TimeAmbiguousÚTimeNonexistentÚnpt)Ú DataFrameÚ PeriodIndex)ÚOFFSET_TO_PERIOD_FREQSTRc ó2 d|v rÀt |d t « s|j d« }t |t « sD|j d« }|j d« }t j |t |« |¬« }n3|}dD ], }||v s|| t ||« k( sJ |j |« . | j |fi |¤}|S t j « 5 t j d« | j | fi |¤}ddd« |S # 1 sw Y S xY w)zu
|
This is called upon unpickling, rather than the default which doesn't
|
have arguments and breaks __new__
|
ÚdataÚtzÚfreq)Údtyper. )r- r. ÚignoreN) Ú
|
isinstanceÚ DatetimeIndexÚpopr Ú _simple_newr ÚgetattrÚwarningsÚcatch_warningsÚ simplefilterÚ__new__)ÚclsÚdr, r- r. ÚdtaÚkeyÚresults úPH:\Change_password\venv_build\Lib\site-packages\pandas/core/indexes/datetimes.pyÚ_new_DatetimeIndexr@ I s ð
|
{: a¨¡i´ Ô?àuuV}Ü$¤ Ô.ð tBØ55=DÜ ×+Ñ+¨D¼ ÀB»ÈdÔSCàCØ%ò ð !8Ø S6¤W¨S°#Ó%6Ò6Ð6Ð6ØEE#Jð ð ! Ñ*¨Ñ*ð Mô × $Ñ $Ó &ñ +ô × !Ñ ! (Ô +Ø S[[ Ñ*¨Ñ*F÷ +ð M÷ +ð Mús Ã)D Ä D)Ú tz_localizeÚ
|
tz_convertÚstrftimeT)ÚwrapÚ is_normalized)Úcache)r- Útzinfor/ Ú to_pydatetimeÚdateÚtimeÚtimetzÚstdc ó e Zd ZU dZdZeZdZed%d« Z de
|
d< de
|
d< de
|
d < e ej « d&d
|
« Z e ej « d'd « Z e ej « d( d)d « Z e ej « d*d+d« Z e ej « d&d« Z e ej" « d,d« Zed-d« Zdej* ej* ej* ej* d dddddf d.dZed/d« Zd Zd0dZed « Zd/ fd Zd1dZ d2d3dZ d4d Z d5 fd Z d6d Z d Z! e e"jF « d7 fd « Z#d8d!Z$ed9d"« Z%d:d;d#Z& d< d=d$Z' xZ(S )>r2 a=
|
Immutable ndarray-like of datetime64 data.
|
|
Represented internally as int64, and which can be boxed to Timestamp objects
|
that are subclasses of datetime and carry metadata.
|
|
.. versionchanged:: 2.0.0
|
The various numeric date/time attributes (:attr:`~DatetimeIndex.day`,
|
:attr:`~DatetimeIndex.month`, :attr:`~DatetimeIndex.year` etc.) now have dtype
|
``int32``. Previously they had dtype ``int64``.
|
|
Parameters
|
----------
|
data : array-like (1-dimensional)
|
Datetime-like data to construct index with.
|
freq : str or pandas offset object, optional
|
One of pandas date offset strings or corresponding objects. The string
|
'infer' can be passed in order to set the frequency of the index as the
|
inferred frequency upon creation.
|
tz : pytz.timezone or dateutil.tz.tzfile or datetime.tzinfo or str
|
Set the Timezone of the data.
|
normalize : bool, default False
|
Normalize start/end dates to midnight before generating date range.
|
|
.. deprecated:: 2.1.0
|
|
closed : {'left', 'right'}, optional
|
Set whether to include `start` and `end` that are on the
|
boundary. The default includes boundary points on either end.
|
|
.. deprecated:: 2.1.0
|
|
ambiguous : 'infer', bool-ndarray, 'NaT', 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.
|
dayfirst : bool, default False
|
If True, parse dates in `data` with the day first order.
|
yearfirst : bool, default False
|
If True parse dates in `data` with the year first order.
|
dtype : numpy.dtype or DatetimeTZDtype or str, default None
|
Note that the only NumPy dtype allowed is `datetime64[ns]`.
|
copy : bool, default False
|
Make a copy of input ndarray.
|
name : label, default None
|
Name to be stored in the index.
|
|
Attributes
|
----------
|
year
|
month
|
day
|
hour
|
minute
|
second
|
microsecond
|
nanosecond
|
date
|
time
|
timetz
|
dayofyear
|
day_of_year
|
dayofweek
|
day_of_week
|
weekday
|
quarter
|
tz
|
freq
|
freqstr
|
is_month_start
|
is_month_end
|
is_quarter_start
|
is_quarter_end
|
is_year_start
|
is_year_end
|
is_leap_year
|
inferred_freq
|
|
Methods
|
-------
|
normalize
|
strftime
|
snap
|
tz_convert
|
tz_localize
|
round
|
floor
|
ceil
|
to_period
|
to_pydatetime
|
to_series
|
to_frame
|
month_name
|
day_name
|
mean
|
std
|
|
See Also
|
--------
|
Index : The base pandas Index type.
|
TimedeltaIndex : Index of timedelta64 data.
|
PeriodIndex : Index of Period data.
|
to_datetime : Convert argument to datetime.
|
date_range : Create a fixed-frequency DatetimeIndex.
|
|
Notes
|
-----
|
To learn more about the frequency strings, please see `this link
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
|
|
Examples
|
--------
|
>>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"])
|
>>> idx
|
DatetimeIndex(['2020-01-01 10:00:00+00:00', '2020-02-01 11:00:00+00:00'],
|
dtype='datetime64[ns, UTC]', freq=None)
|
Ú datetimeindexTc ó" t j S ©N)ÚlibindexÚDatetimeEngine©Úselfs r? Ú _engine_typezDatetimeIndex._engine_type s ä×&Ñ&Ð&ó r Ú_dataÚ_valueszdt.tzinfo | Noner- c ó| | j j |« }t || j |j ¬« S )N)Únamer/ )rW rC r rZ r/ )rT Ú date_formatÚarrs r? rC zDatetimeIndex.strftime s- àjj×!Ñ! +Ó.ÜStyy°· ± Ô:Ð:rV c ó | j j |« }t | « j || j | j
|
¬« S )N©rZ Úrefs)rW rB Útyper4 rZ Ú _references)rT r- r\ s r? rB zDatetimeIndex.tz_convert s< àjj×#Ñ# BÓ'ÜDz×%Ñ% c°· ± À×@PÑ@PÐ%ÓQÐQrV Úraisec ó | j j |||« }t | « j || j ¬« S ©N©rZ )rW rA r` r4 rZ )rT r- Ú ambiguousÚ nonexistentr\ s r? rA zDatetimeIndex.tz_localize s: ð jj×$Ñ$ R¨°KÓ@ÜDz×%Ñ% c°· ± Ð%Ó:Ð:rV Nc ó ddl m} | j j |« } |j || j
|
¬« S )Nr )r) re )Úpandas.core.indexes.apir) rW Ú to_periodr4 rZ )rT r. r) r\ s r? rj zDatetimeIndex.to_period( s2 å7àjj×"Ñ" 4Ó(Ø&{×&Ñ& s°·±Ô;Ð;rV c óx | j j « }t j || j ¬« S rd )rW Úto_julian_dater r4 rZ )rT r\ s r? rl z DatetimeIndex.to_julian_date/ s+ àjj×'Ñ'Ó)Ü× Ñ ¨4¯9©9Ô5Ð5rV c óX | j j « }|j | « S rP )rW Ú isocalendarÚ set_index)rT Údfs r? rn zDatetimeIndex.isocalendar4 s# à ZZ× #Ñ #Ó %Ø||DÓ!Ð!rV c ó. | j j S rP )rW Ú_resolution_objrS s r? rr z DatetimeIndex._resolution_obj9 s àzz×)Ñ)Ð)rV Fc
|
óÌ |t j ur2t j d| j dt
|
t « ¬« |t j ur2t j d| j dt
|
t « ¬« t |« r| j |« t | || « } t |t « rK|t j u r9|t j u r'| %|
|
r|j « }| j || ¬« S t j || |
|
|||||¬« } d } |
|
s"t |t t f« r |j" } | j | | | ¬« }|S )NzThe 'closed' keyword in zD construction is deprecated and will be removed in a future version.)Ú
|
stacklevelzThe 'normalize' keyword in re )r/ Úcopyr- r. ÚdayfirstÚ yearfirstrf r^ )r Ú
|
no_defaultr6 ÚwarnÚ__name__Ú FutureWarningr r Ú_raise_scalar_data_errorr r1 r ru r4 Ú_from_sequence_not_strictr r ra )r: r, r. r- Ú normalizeÚclosedrf rv rw r/ ru rZ Údtarrr_ Úsubarrs r? r9 zDatetimeIndex.__new__@ sM ð Ñ 'ä MMØ*¨3¯<©<¨.ð 9Fð Fä Ü+Ó-õ ð CNNÑ *ä MMØ-¨c¯l©l¨^ð <Fð Fä Ü+Ó-õ ô T?Ø × (Ñ (¨Ô .ô " $¨¨cÓ2ô t]Ô +ØÑ&ØcnnÑ$Ø ñ Øyy{Ø?? 4¨d?Ó3Ð 3ä ×7Ñ7Ø ØØØØØ Ø Ø ô
|
ð Ù
|
4¬%´Ð);Ô<Ø×#Ñ#Dà ¨T¸ Ó=Ø rV c óî t | j t « rFt | j « }|t j
|
d¬« z t j
|
d¬« k7 ry| j j S )z
|
Return a boolean if we are only dates (and don't have a timezone)
|
|
Returns
|
-------
|
bool
|
é )Údaysr F)r1 r. r r ÚdtÚ timedeltarX Ú_is_dates_only)rT Údeltas r? r z DatetimeIndex._is_dates_only
sR ô dii¤Ô &Ü diiÓ(Eàr||¨Ô+Ñ+¬r¯|©|ÀÔ/CÒCØ à||×*Ñ*Ð*rV c ó\ | j | j d}t t | « |fd fS )N)r, rZ )rW rZ r@ r` )rT r; s r? Ú
|
__reduce__zDatetimeIndex.__reduce__ s) ØZZ¨¯©Ñ 3Ü!¤D¨£J° ?°DÐ8Ð8rV c óf | j t |t « S t j |d« S )zF
|
Can we compare values of the given dtype to our own?
|
ÚM)r- r1 r r Ú is_np_dtype)rT r/ s r? Ú_is_comparable_dtypez"DatetimeIndex._is_comparable_dtype s, ð 77Ð ä e¤_Ó5Ð 5äu cÓ*Ð*rV c ó@ ddl m} || j ¬« fdS )Nr )Úget_format_datetime64)Ú is_dates_onlyc ó d | « dS )Nú'© )ÚxÚ formatters r? ú<lambda>z/DatetimeIndex._formatter_func.<locals>.<lambda>® s ø 1Y q\N¨!Ð, rV )Úpandas.io.formats.formatr r )rT r r s @r? Ú_formatter_funcz DatetimeIndex._formatter_func§ s ø õ Cá)¸×8KÑ8KÔL Û,Ð,rV c óN | j ?t j | j « s t j | j « sy|j ?t j |j « s t j |j « syt | |« S )NF)r- r Úis_utcÚis_fixed_offsetÚsuperÚ_can_range_setop)rT ÚotherÚ __class__s r? r z DatetimeIndex._can_range_setop³ sw ø ð GGÐ Ü ×$Ñ$ T§W¡WÔ-Ü ×-Ñ-¨d¯g©gÔ6àà HHÐ Ü ×$Ñ$ U§X¡XÔ.Ü ×-Ñ-¨e¯h©hÔ7àÜwÑ'¨Ó.Ð.rV c ól | j j « }t | j j « }||z }| j dk( r|dz }nQ| j dk( r|}n?| j dk( r|dz }n*| j dk( r|dz }nt | j « d|| j < |S )z}
|
Return the number of microseconds since midnight.
|
|
Returns
|
-------
|
ndarray[int64_t]
|
Únsiè ÚusÚmsÚsé@B éÿÿÿÿ)rW Ú_local_timestampsr Ú_cresoÚunitÚNotImplementedErrorÚ_isnan)rT ÚvaluesÚppdÚfracÚmicross r? Ú_get_time_microsz DatetimeIndex._get_time_microsÆ s¦ ð ×-Ñ-Ó/ä djj× /Ñ /Ó0à|Ø 99Ò ØT\FØ YY$Ò ØFØ YY$Ò ØD[FØ YY#Ò ØIÑ%Fä% d§i¡iÓ0Ð 0à t{{ÑØ rV c ól t |« }| j j « }t | « D ]a \ }}|}|j |« sD|j |« }|j |« }t ||z
|
« t ||z
|
« k r|}n|}|||< c t j || j ¬« S )a=
|
Snap time stamps to nearest occurring frequency.
|
|
Returns
|
-------
|
DatetimeIndex
|
|
Examples
|
--------
|
>>> idx = pd.DatetimeIndex(['2023-01-01', '2023-01-02',
|
... '2023-02-01', '2023-02-02'])
|
>>> idx
|
DatetimeIndex(['2023-01-01', '2023-01-02', '2023-02-01', '2023-02-02'],
|
dtype='datetime64[ns]', freq=None)
|
>>> idx.snap('MS')
|
DatetimeIndex(['2023-01-01', '2023-01-01', '2023-02-01', '2023-02-01'],
|
dtype='datetime64[ns]', freq=None)
|
re ) r rW ru Ú enumerateÚ is_on_offsetÚrollbackÚ rollforwardÚabsr2 r4 rZ )rT r. r< ÚiÚvr¥ Út0Út1s r? ÚsnapzDatetimeIndex.snapá s¬ ô( àjjooÓ ä dOò DAqØAØ×$Ñ$ QÔ'Ø]] 1Ó%Ø×%Ñ% aÓ(Üq2v;¤ R¨!¡V£Ò,ØAàAØCFð ô ×(Ñ(¨°4·9±9Ð(Ó=Ð=rV c óZ t j |j |j « }t ||¬« }|j |j
|
}}|j |j « }|j |j « }|j | j t d« ||fS )aP
|
Calculate datetime bounds for parsed time string and its resolution.
|
|
Parameters
|
----------
|
reso : Resolution
|
Resolution provided by parsed string.
|
parsed : datetime
|
Datetime from parsed string.
|
|
Returns
|
-------
|
lower, upper: pd.Timestamp
|
)r. zSThe index must be timezone aware when indexing with a date string with a UTC offset)
|
r* ÚgetÚ attr_abbrevr Ú
|
start_timeÚend_timerA rG r- Ú
|
ValueError)rT ÚresoÚparsedr. ÚperÚstartÚends r? Ú_parsed_string_to_boundsz&DatetimeIndex._parsed_string_to_bounds s ô (×+Ñ+¨D×,<Ñ,<¸d×>NÑ>NÓOÜV $Ô'Ø^^ S§\¡\sð ×!Ñ! &§-¡-Ó0ØoofmmÓ,à ==Ð $ØwwÜ ð;óð ð czÐrV c ó¬ t | |« \ }}t |« }| j '|j |j | j « }||fS rP )r Ú_parse_with_resor r- rG rA )rT ÚlabelrÄ rà r s r? rÊ z DatetimeIndex._parse_with_reso. sS ø Ü wÑ/°Ó6 ä6Ó"à 77Ð 6§=¡=Ð#8ð ×'Ñ'¨¯©Ó0Fàt|ÐrV c óv | j j |« y# t $ r}t |« |d}~ww xY w)zU
|
Check for mismatched-tzawareness indexing and re-raise as KeyError.
|
N)rW Ú_assert_tzawareness_compatÚ TypeErrorÚKeyError)rT r= Úerrs r? Ú _disallow_mismatched_indexingz+DatetimeIndex._disallow_mismatched_indexing; s5 ð
|
)à JJ× 1Ñ 1°#Õ 6øÜò )Ü3- SÐ (ûð )ús 8§ 3³8c ó | j |« |}t || j « rt }t || j
|
j « r | j |« t |« }nät |t « rM | j |« \ }}| j |« | j |« r | j! ||« S |}nt |t" j$ « r7t' dt) | « j* dt) |« j* « t |t" j, « r| j/ |« S t |« t1 j2 | |« S # t t j f$ r}t |« |d}~ww xY w# t $ r}t |« |d}~ww xY w# t $ r}t |« |d}~ww xY w)zm
|
Get integer location for requested label
|
|
Returns
|
-------
|
loc : int
|
Nz Cannot index z with )Ú_check_indexing_errorr r/ r r1 rW Ú_recognized_scalarsrÑ r ÚstrrÊ r ÚpytzÚNonExistentTimeErrorrÏ Ú_can_partial_date_sliceÚ_partial_date_slicer
r rÎ r` rz rJ Úindexer_at_timer Úget_loc)rT r= Úorig_keyrÄ rà rÐ s r? rÛ zDatetimeIndex.get_locF s ð ×"Ñ" 3Ô'àÜ d§j¡jÔ 1ÜCä c4::×9Ñ9Ô :à × .Ñ .¨sÔ 3ÜC.Cä SÔ !ð -Ø #× 4Ñ 4°SÓ 9 ð × .Ñ .¨vÔ 6à×+Ñ+¨DÔ1ð1Ø ×3Ñ3°D¸&ÓAÐAð Cä R\\Ô *äØ ¤ T£
|
× 3Ñ 3Ð 4°F¼4À»9×;MÑ;MÐ:NÐOóð ô RWWÔ %Ø×'Ñ'¨Ó,Ð ,ô 3-Ð ð .Ü== sÓ+Ð +øô5 ¤× 9Ñ 9Ð:ò -Ü sm¨Ð,ûð -ûô ò 1Ü" 3-¨SÐ0ûð1ûô( ò .Ü8Ó$¨#Ð -ûð .úsH Á>E( Â5F ÅF2 Å(FÆ F Æ FÆ F/Æ F*Æ*F/Æ2 G Æ; GÇG c ó
|
t |t j « r3t |t j « st |« j « }t | ||« }| j j |« t |« S rP )
|
r1 r
rI Údatetimer rH r Ú_maybe_cast_slice_boundrW rÍ )rT rË Úsider s r? rß z%DatetimeIndex._maybe_cast_slice_boundz sc ø ô eRWWÔ %¬j¸ÄÇ Á Ô.Lô eÓ$×2Ñ2Ó4EäÑ/°°tÓ<Ø
|
|
×-Ñ-¨eÔ4ÜÓ Ð rV c ó$ t |t j « r>t |t j « r$||dk7 r t d« | j ||« S t |t j « st |t j « r t d« d d} ||« s ||« s | j rt j | |||« S t j d« }d}|-| j |d« }|| k }||| k( j « z }|0| j |d« }| |k |z }||| k( j « z }|s t d « |j « d
|
dd|
} t | « t | « k( r t d« S | S ) aÐ
|
Return indexer for specified label slice.
|
Index.slice_indexer, customized to handle time slicing.
|
|
In addition to functionality provided by Index.slice_indexer, does the
|
following:
|
|
- if both `start` and `end` are instances of `datetime.time`, it
|
invokes `indexer_between_time`
|
- if `start` and `end` are both either string or None perform
|
value-based selection in non-monotonic cases.
|
|
Nr z)Must have step size of 1 with time slicesz'Cannot mix time and non-time slice keysc ó0 | d uxr t | t « S rP )r1 rÕ )Úpoints r? Úcheck_str_or_nonez6DatetimeIndex.slice_indexer.<locals>.check_str_or_none s Ø Ð$ÒC¬Z¸¼sÓ-CÐ)CÐ CrV TÚleftÚrightzcValue based partial slicing on non-monotonic DatetimeIndexes with non-existing keys is not allowed.r ©ÚreturnÚbool)r1 r
rJ r Úindexer_between_timerÏ Úis_monotonic_increasingr Ú slice_indexerÚnpÚarrayrß ÚanyÚnonzeroÚlenÚslice)
|
rT rÆ rÇ Ústeprä ÚmaskÚin_indexÚ start_castedÚ
|
end_castedÚindexers
|
r? rì zDatetimeIndex.slice_indexer s ô" eRWWÔ %¬*°S¼"¿'¹'Ô*BØÐ D¨A¢IÜ Ð!LÓMÐMØ×,Ñ,¨U°CÓ8Ð 8ä eRWWÔ %¬°C¼¿¹Ô)AÜÐDÓEÐ Eó Dñ eÔ $Ù Ô%Ø×+Ò+ä×&Ñ& t¨U°C¸Ó>Ð >äxx~ØØ Ð Ø ×7Ñ7¸¸vÓFLØ 4Ñ'DØ ¨Ñ-×2Ñ2Ó4Ñ 4Hà ?Ø ×5Ñ5°c¸7ÓCJØJÑ&¨$Ñ.DØ tÑ+×0Ñ0Ó2Ñ 2HáÜð9óð ð ,,. Ñ#¡F d FÑ+Ü w<3t9Ò $Ü;Ð àNrV c ó y)NÚ
|
datetime64r rS s r? Ú inferred_typezDatetimeIndex.inferred_typeÅ s ð rV c óp |r t d« t |t « r ddlm} ||« j « }|j rA| j t d« | j |j « j « }n| j « }t |« }||k( j « d S )aW
|
Return index locations of values at particular time of day.
|
|
Parameters
|
----------
|
time : datetime.time or str
|
Time passed in either as object (datetime.time) or as string in
|
appropriate format ("%H:%M", "%H%M", "%I:%M%p", "%I%M%p",
|
"%H:%M:%S", "%H%M%S", "%I:%M:%S%p", "%I%M%S%p").
|
|
Returns
|
-------
|
np.ndarray[np.intp]
|
|
See Also
|
--------
|
indexer_between_time : Get index locations of values between particular
|
times of day.
|
DataFrame.at_time : Select values at particular time of day.
|
|
Examples
|
--------
|
>>> idx = pd.DatetimeIndex(["1/1/2020 10:00", "2/1/2020 11:00",
|
... "3/1/2020 10:00"])
|
>>> idx.indexer_at_time("10:00")
|
array([0, 2])
|
z 'asof' argument is not supportedr )Úparsez Index must be timezone aware.) r« r1 rÕ Údateutil.parserrý rJ rG r- r rB r± Ú_time_to_microsrð )rT rJ Úasofrý Ú time_microsr° s r? rÚ z DatetimeIndex.indexer_at_timeË s ñ8 Ü%Ð&HÓIÐ Iä dCÔ Ý -á;×#Ñ#Ó%Dà ;;ØwwÜ Ð!@ÓAÐAØ //¨$¯+©+Ó6×GÑGÓIKà ×/Ñ/Ó1KÜ Ó&ØvÑ%×.Ñ.Ó0°Ñ3Ð3rV c óø t |« }t |« }| j « }t |« }t |« }|r|rt j x}} nX|r!t j }t j
|
} n5|r!t j
|
}t j } nt j
|
x}} ||k rt j }
|
nt j }
|
|
|
|||« | ||« « } | j « d S )an
|
Return index locations of values between particular times of day.
|
|
Parameters
|
----------
|
start_time, end_time : datetime.time, str
|
Time passed either as object (datetime.time) or as string in
|
appropriate format ("%H:%M", "%H%M", "%I:%M%p", "%I%M%p",
|
"%H:%M:%S", "%H%M%S", "%I:%M:%S%p","%I%M%S%p").
|
include_start : bool, default True
|
include_end : bool, default True
|
|
Returns
|
-------
|
np.ndarray[np.intp]
|
|
See Also
|
--------
|
indexer_at_time : Get index locations of values at particular time of day.
|
DataFrame.between_time : Select values between particular times of day.
|
|
Examples
|
--------
|
>>> idx = pd.date_range("2023-01-01", periods=4, freq="h")
|
>>> idx
|
DatetimeIndex(['2023-01-01 00:00:00', '2023-01-01 01:00:00',
|
'2023-01-01 02:00:00', '2023-01-01 03:00:00'],
|
dtype='datetime64[ns]', freq='h')
|
>>> idx.indexer_between_time("00:00", "2:00", include_end=False)
|
array([0, 1])
|
r ) r r± rÿ ÚoperatorÚleÚltÚand_Úor_rð ) rT rÀ rÁ Ú include_startÚ include_endr Ú start_microsÚ
|
end_microsÚlopÚropÚjoin_oprô s r? rê z"DatetimeIndex.indexer_between_timeø sË ôD ZÓ(
|
Ü8Ó$Ø×+Ñ+Ó- Ü& zÓ2 Ü$ XÓ.
|
á [Ü Ð #C#Ù Ü++CÜ++CÙ Ü++CÜ++Cä Ð #C#à Ò !Ü mmGä llGás<¨Ó5±s¸;È
|
Ó7SÓTà||~aÑ Ð rV )rè z type[libindex.DatetimeEngine])rè r )rè r$ )rb rb )rf r% rg r& rè r$ rP )rè r) )rè r( )rè r
|
)r. zFrequency | lib.NoDefaultr~ zbool | lib.NoDefaultrf r% rv ré rw ré r/ z Dtype | Noneru ré rZ úHashable | Nonerè r$ rç )r/ r! rè ré )rè znpt.NDArray[np.int64])ÚS)r. r" rè r2 )rà r
|
rÄ z dt.datetime)rË rÕ )rè ÚNone)rà rÕ )NNN)rè rÕ )F)r ré rè únpt.NDArray[np.intp])TT)r ré r ré rè r ))rz Ú
|
__module__Ú __qualname__Ú__doc__Ú_typr Ú _data_clsÚ!_supports_partial_string_indexingÚpropertyrU Ú__annotations__r rC rB rA rj rl rn r rr r rx r9 r r r r r r± r¼ rÈ rÊ rÑ rÛ r rß rì rû rÚ rê Ú __classcell__)r s @r? r2 r2 j s ø
ñ4~ð@ Dà IØ(,Ð%à ò'ó ð'ð ÓØ ÓØÓñ
|
× Ñ Ó ò;ó !ð;ñ × !Ñ !Ó"òRó #ðRñ × "Ñ "Ó#ð $+Ø'.ð ;ð !ð;ð %ð ;ð
|
|
ò ;ó $ð;ñ × Ñ Ó!ó<ó "ð<ñ × %Ñ %Ó&ò6ó 'ð6ñ × "Ñ "Ó#ò"ó $ð"ð ò*ó ð*ð Ø*-¯.©.Ø >>Ø*-¯.©.Ø~~Ø#*Ø Ø Ø "ØØ $ðAð (ðAð
|
(ð Að !ðAð ðAð ðAð ðAð ðAð ðAð
|
óAðJ ò+ó ð+ò 9ó+ð ñ-ó ð-õ/ó&ô6#>óP#õJ ó )ò2.ñh Ð × 7Ñ 7Ó8ô ó 9ð ó;ð~ ò ó ð ô
|
+4ð\ UYð:!Ø37ð:!ØMQð:!à ÷:!rV r2 )rª c ó¢ |t j || |« rd}t j d| |||||||d| ¤}
|
t j |
|
|¬« S )aE
|
Return a fixed frequency DatetimeIndex.
|
|
Returns the range of equally spaced time points (where the difference between any
|
two adjacent points is specified by the given frequency) such that they all
|
satisfy `start <[=] x <[=] end`, where the first one and the last one are, resp.,
|
the first and last time points in that range that fall on the boundary of ``freq``
|
(if given as a frequency string) or that are valid for ``freq`` (if given as a
|
:class:`pandas.tseries.offsets.DateOffset`). (If exactly one of ``start``,
|
``end``, or ``freq`` is *not* specified, this missing parameter can be computed
|
given ``periods``, the number of timesteps in the range. See the note below.)
|
|
Parameters
|
----------
|
start : str or datetime-like, optional
|
Left bound for generating dates.
|
end : str or datetime-like, optional
|
Right bound for generating dates.
|
periods : int, optional
|
Number of periods to generate.
|
freq : str, Timedelta, datetime.timedelta, or DateOffset, default 'D'
|
Frequency strings can have multiples, e.g. '5h'. See
|
:ref:`here <timeseries.offset_aliases>` for a list of
|
frequency aliases.
|
tz : str or tzinfo, optional
|
Time zone name for returning localized DatetimeIndex, for example
|
'Asia/Hong_Kong'. By default, the resulting DatetimeIndex is
|
timezone-naive unless timezone-aware datetime-likes are passed.
|
normalize : bool, default False
|
Normalize start/end dates to midnight before generating date range.
|
name : str, default None
|
Name of the resulting DatetimeIndex.
|
inclusive : {"both", "neither", "left", "right"}, default "both"
|
Include boundaries; Whether to set each bound as closed or open.
|
|
.. versionadded:: 1.4.0
|
unit : str, default None
|
Specify the desired resolution of the result.
|
|
.. versionadded:: 2.0.0
|
**kwargs
|
For compatibility. Has no effect on the result.
|
|
Returns
|
-------
|
DatetimeIndex
|
|
See Also
|
--------
|
DatetimeIndex : An immutable container for datetimes.
|
timedelta_range : Return a fixed frequency TimedeltaIndex.
|
period_range : Return a fixed frequency PeriodIndex.
|
interval_range : Return a fixed frequency IntervalIndex.
|
|
Notes
|
-----
|
Of the four parameters ``start``, ``end``, ``periods``, and ``freq``,
|
exactly three must be specified. If ``freq`` is omitted, the resulting
|
``DatetimeIndex`` will have ``periods`` linearly spaced elements between
|
``start`` and ``end`` (closed on both sides).
|
|
To learn more about the frequency strings, please see `this link
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
|
|
Examples
|
--------
|
**Specifying the values**
|
|
The next four examples generate the same `DatetimeIndex`, but vary
|
the combination of `start`, `end` and `periods`.
|
|
Specify `start` and `end`, with the default daily frequency.
|
|
>>> pd.date_range(start='1/1/2018', end='1/08/2018')
|
DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
|
'2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
|
dtype='datetime64[ns]', freq='D')
|
|
Specify timezone-aware `start` and `end`, with the default daily frequency.
|
|
>>> pd.date_range(
|
... start=pd.to_datetime("1/1/2018").tz_localize("Europe/Berlin"),
|
... end=pd.to_datetime("1/08/2018").tz_localize("Europe/Berlin"),
|
... )
|
DatetimeIndex(['2018-01-01 00:00:00+01:00', '2018-01-02 00:00:00+01:00',
|
'2018-01-03 00:00:00+01:00', '2018-01-04 00:00:00+01:00',
|
'2018-01-05 00:00:00+01:00', '2018-01-06 00:00:00+01:00',
|
'2018-01-07 00:00:00+01:00', '2018-01-08 00:00:00+01:00'],
|
dtype='datetime64[ns, Europe/Berlin]', freq='D')
|
|
Specify `start` and `periods`, the number of periods (days).
|
|
>>> pd.date_range(start='1/1/2018', periods=8)
|
DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
|
'2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
|
dtype='datetime64[ns]', freq='D')
|
|
Specify `end` and `periods`, the number of periods (days).
|
|
>>> pd.date_range(end='1/1/2018', periods=8)
|
DatetimeIndex(['2017-12-25', '2017-12-26', '2017-12-27', '2017-12-28',
|
'2017-12-29', '2017-12-30', '2017-12-31', '2018-01-01'],
|
dtype='datetime64[ns]', freq='D')
|
|
Specify `start`, `end`, and `periods`; the frequency is generated
|
automatically (linearly spaced).
|
|
>>> pd.date_range(start='2018-04-24', end='2018-04-27', periods=3)
|
DatetimeIndex(['2018-04-24 00:00:00', '2018-04-25 12:00:00',
|
'2018-04-27 00:00:00'],
|
dtype='datetime64[ns]', freq=None)
|
|
**Other Parameters**
|
|
Changed the `freq` (frequency) to ``'ME'`` (month end frequency).
|
|
>>> pd.date_range(start='1/1/2018', periods=5, freq='ME')
|
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31', '2018-04-30',
|
'2018-05-31'],
|
dtype='datetime64[ns]', freq='ME')
|
|
Multiples are allowed
|
|
>>> pd.date_range(start='1/1/2018', periods=5, freq='3ME')
|
DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
|
'2019-01-31'],
|
dtype='datetime64[ns]', freq='3ME')
|
|
`freq` can also be specified as an Offset object.
|
|
>>> pd.date_range(start='1/1/2018', periods=5, freq=pd.offsets.MonthEnd(3))
|
DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
|
'2019-01-31'],
|
dtype='datetime64[ns]', freq='3ME')
|
|
Specify `tz` to set the timezone.
|
|
>>> pd.date_range(start='1/1/2018', periods=5, tz='Asia/Tokyo')
|
DatetimeIndex(['2018-01-01 00:00:00+09:00', '2018-01-02 00:00:00+09:00',
|
'2018-01-03 00:00:00+09:00', '2018-01-04 00:00:00+09:00',
|
'2018-01-05 00:00:00+09:00'],
|
dtype='datetime64[ns, Asia/Tokyo]', freq='D')
|
|
`inclusive` controls whether to include `start` and `end` that are on the
|
boundary. The default, "both", includes boundary points on either end.
|
|
>>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive="both")
|
DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03', '2017-01-04'],
|
dtype='datetime64[ns]', freq='D')
|
|
Use ``inclusive='left'`` to exclude `end` if it falls on the boundary.
|
|
>>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive='left')
|
DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03'],
|
dtype='datetime64[ns]', freq='D')
|
|
Use ``inclusive='right'`` to exclude `start` if it falls on the boundary, and
|
similarly ``inclusive='neither'`` will exclude both `start` and `end`.
|
|
>>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive='right')
|
DatetimeIndex(['2017-01-02', '2017-01-03', '2017-01-04'],
|
dtype='datetime64[ns]', freq='D')
|
|
**Specify a unit**
|
|
>>> pd.date_range(start="2017-01-01", periods=10, freq="100YS", unit="s")
|
DatetimeIndex(['2017-01-01', '2117-01-01', '2217-01-01', '2317-01-01',
|
'2417-01-01', '2517-01-01', '2617-01-01', '2717-01-01',
|
'2817-01-01', '2917-01-01'],
|
dtype='datetime64[s]', freq='100YS-JAN')
|
ÚD)rÆ rÇ Úperiodsr. r- r~ Ú inclusiverª re r )ÚcomÚany_noner Ú_generate_ranger2 r4 ) rÆ rÇ r r. r- r~ rZ r rª Úkwargsr s r? Ú
|
date_ranger$ 5 sm ðp | W¨e°SÔ9Øä × )Ñ )ð
|
ØØ ØØ Ø ØØØ ñ
|
ð ñ
|
Eô × $Ñ $ U°Ð $Ó 6Ð6rV c
|
ó2 | d} t | « t |t « r)|j d« r |xs d}t | ||¬« }n|s|rd| } t | « t d | ||||||| d|
|
¤S # t
|
t f$ r} d| } t | « | d} ~ ww xY w)
|
a
|
Return a fixed frequency DatetimeIndex with business day as the default.
|
|
Parameters
|
----------
|
start : str or datetime-like, default None
|
Left bound for generating dates.
|
end : str or datetime-like, default None
|
Right bound for generating dates.
|
periods : int, default None
|
Number of periods to generate.
|
freq : str, Timedelta, datetime.timedelta, or DateOffset, default 'B'
|
Frequency strings can have multiples, e.g. '5h'. The default is
|
business daily ('B').
|
tz : str or None
|
Time zone name for returning localized DatetimeIndex, for example
|
Asia/Beijing.
|
normalize : bool, default False
|
Normalize start/end dates to midnight before generating date range.
|
name : str, default None
|
Name of the resulting DatetimeIndex.
|
weekmask : str or None, default None
|
Weekmask of valid business days, passed to ``numpy.busdaycalendar``,
|
only used when custom frequency strings are passed. The default
|
value None is equivalent to 'Mon Tue Wed Thu Fri'.
|
holidays : list-like or None, default None
|
Dates to exclude from the set of valid business days, passed to
|
``numpy.busdaycalendar``, only used when custom frequency strings
|
are passed.
|
inclusive : {"both", "neither", "left", "right"}, default "both"
|
Include boundaries; Whether to set each bound as closed or open.
|
|
.. versionadded:: 1.4.0
|
**kwargs
|
For compatibility. Has no effect on the result.
|
|
Returns
|
-------
|
DatetimeIndex
|
|
Notes
|
-----
|
Of the four parameters: ``start``, ``end``, ``periods``, and ``freq``,
|
exactly three must be specified. Specifying ``freq`` is a requirement
|
for ``bdate_range``. Use ``date_range`` if specifying ``freq`` is not
|
desired.
|
|
To learn more about the frequency strings, please see `this link
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
|
|
Examples
|
--------
|
Note how the two weekend days are skipped in the result.
|
|
>>> pd.bdate_range(start='1/1/2018', end='1/08/2018')
|
DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
|
'2018-01-05', '2018-01-08'],
|
dtype='datetime64[ns]', freq='B')
|
Nz>freq must be specified for bdate_range; use date_range insteadÚCzMon Tue Wed Thu Fri)ÚholidaysÚweekmaskz!invalid custom frequency string: zZa custom frequency string is required when holidays or weekmask are passed, got frequency )rÆ rÇ r r. r- r~ rZ r r )rÎ r1 rÕ Ú
|
startswithr rÏ r r$ ) rÆ rÇ r r. r- r~ rZ r( r' r r# ÚmsgrÐ s r? Ú bdate_ranger+ þ sÙ ðP |ØNÜnÐ ä$Ô § ¡ °Ô!5ð +Ø Ò8Ð#8HÜ! $Ñ'°ÀHÔMDñ
|
Xð 2Ø26°ð 9ð ô oÐ ä ð
|
ØØ ØØ Ø ØØ Øñ
|
ð ñ
|
ð
|
øô )Ð$ò +Ø5°d°VÐ<CÜ S/ sÐ *ûð +ús ²A1 Á1B BÂBc ó | j dz dz d| j z z | j z }d|z | j z S )Né< r¦ )ÚhourÚminuteÚsecondÚ microsecond)Útime_objÚsecondss r? rÿ rÿ e sB ØmmbÑ 2Ñ%¨¨X¯_©_Ñ(<Ñ<¸x¿¹ÑNGØ wÑ ×!5Ñ!5Ñ 5Ð5rV )NNNNNFNÚboth)
|
r~ ré rZ r r r# rª z
|
str | Nonerè r2 )
|
NNNÚBNTNNNr4 ) r z
|
int | Noner. zFrequency | dt.timedeltar~ ré rZ r r r# rè r2 )r2 zdt.timerè Úint)PÚ
|
__future__r rÞ r
r Útypingr r6 Únumpyrí rÖ Ú pandas._libsr r r r rQ r Úpandas._libs.tslibsr
|
r r r r r Úpandas._libs.tslibs.offsetsr Úpandas.util._decoratorsr r Úpandas.util._exceptionsr Úpandas.core.dtypes.commonr Úpandas.core.dtypes.dtypesr Úpandas.core.dtypes.genericr Úpandas.core.dtypes.missingr Ú pandas.core.arrays.datetimesr r Úpandas.core.commonÚcoreÚcommonr Úpandas.core.indexes.baser r Ú pandas.core.indexes.datetimeliker Ú pandas.core.indexes.extensionr Úpandas.core.tools.timesr Úcollections.abcr Úpandas._typingr r! r" r# r$ r% r& r' Úpandas.core.apir( r) Úpandas._libs.tslibs.dtypesr* r@ Ú
|
_field_opsÚ_datetimelike_methodsÚ _bool_opsr2 r$ r+ rÿ )Úmethods 0r? ú<module>rS s ðÝ "ã Û Ý Û ã Û ÷õ ÷÷ õ 7÷õ 5å /Ý 5Ý 0Ý <÷÷ !Ð ÷õ DÝ 7Ý +áÝ(÷ ÷ ó ÷õ
|
@ò ñB Ø× Ñ ð $×9Ñ9öà Ø ÐBÑ Bò òñð Ø ô ñ Ð -°tÔ<Ùò ð × Ñ ñ
|
ð ó ô o
|
!Ð*ó o
|
!ó ó =ó ð2o
|
!ðf Ø Ø Ø Ø ØØ Ø$*ðF7ð ñF7ð ð F7ð ðF7ð "ðF7ð ðF7ð óF7ðT Ø Ø Ø%(Ø ØØ Ø Ø Ø$*ðdð ðdð #ð dð ð dð ðdð "ðdð ódôN6ùòs s à E'
|
