U
|
¬ý°dx ã @ s d dl mZ d dlZd dlZd dlmZmZ d dlZd dl Z
|
d dl Z d dl m Z mZmZmZmZ d dlmZmZmZmZ d dlmZ d dlmZm Z m Z m Z m Z m Z m!Z! d dl"m#Z#m$Z$ d d l%m&Z&m'Z'm(Z( d d
|
l)m*Z* d d l+m,Z, d d l-m.Z.m/Z/ d dl0m1 m2Z3 d d l4m5Z5m6Z6 d dl7m8Z8 d dl9m:Z: d dl;m<Z< erPd dl=m>Z>m?Z? dd Z@e:e.jAdd e.jBD e.dde:dge.dde:ddd d d d d d!d"g e.jC e.G d#d$ d$e8ZDd:dd'd(d)d*d+d$d,d-d.ZEd;d0d1d(d)d*d$d2d3d4ZFd5d6d7d8d9ZGdS )<é )Ú annotationsN)Ú TYPE_CHECKINGÚHashable)ÚNaTÚPeriodÚ TimestampÚindexÚlib)Ú
|
ResolutionÚperiods_per_dayÚ timezonesÚ to_offset)Úprefix_mapping)ÚDtypeÚDtypeObjÚ FrequencyÚIntervalClosedTypeÚ TimeAmbiguousÚTimeNonexistentÚnpt)Úcache_readonlyÚdoc)Úis_datetime64_dtypeÚis_datetime64tz_dtypeÚ is_scalar)Ú ABCSeries)Úis_valid_na_for_dtype)Ú DatetimeArrayÚ tz_to_dtype)ÚIndexÚmaybe_extract_name)ÚDatetimeTimedeltaMixin)Ú inherit_names)Úto_time)Ú DataFrameÚ PeriodIndexc C sÊ d|krt |d ts| d¡}t |tsT| d¡}| d¡}tj|t||d}n6|}dD ],}||kr\|| t||ks~t| |¡ q\| j|f|}n,t ¡ t
|
d¡ | j | f|}W 5 Q R X |S )zu
|
This is called upon unpickling, rather than the default which doesn't
|
have arguments and breaks __new__
|
ÚdataÚtzÚfreq)Údtyper( )r' r( Úignore) Ú
|
isinstanceÚ DatetimeIndexÚpopr Ú _simple_newr ÚgetattrÚAssertionErrorÚwarningsÚcatch_warningsÚ simplefilterÚ__new__)ÚclsÚdr& r' r( ÚdtaÚkeyÚresult© r: úTd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/indexes/datetimes.pyÚ_new_DatetimeIndexF s
|
|
|
|
|
|
r< c C s g | ]}|d kr|qS ))Ú tz_localizeÚ
|
tz_convertÚstrftimer: )Ú.0Úmethodr: r: r; Ú
|
<listcomp>i s þrB T)ÚwrapÚ is_normalized)Úcacher' Útzinfor) Ú to_pydatetimeZ_format_native_typesÚdateÚtimeÚtimetzZstdc s& e Zd ZU dZdZeZdZeddddZ de
|
d < d
|
e
|
d < e ej d dd dZ e ej d dddZ e ejdZddd dddZe ejd[ddddZe ejd ddd Ze ejd dd d Zed dd!d"Zdejejd#ddd#d#dd#df d$d%dd%d%d&d%d'd d( d)d*Zed%dd+d,Zd-d. Zd/d%d0d1d2Zed3d4 Zd%d fd5d6 Zd7dd8d9Z d\d;d d<d=d>Z d d?d@dAdBZ dCdD fdEdF Z dGddHdIZ dJdK Z!e e"j#dCdL fdMdN Z#d]dOdPZ$edCddQdRZ%d^d%dSdTdUdVZ&d_d%d%dSdWdXdYZ' Z(S )`r, u!
|
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.
|
closed : {'left', 'right'}, optional
|
Set whether to include `start` and `end` that are on the
|
boundary. The default includes boundary points on either end.
|
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
|
weekofyear
|
week
|
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>`__.
|
Z datetimeindexTz type[libindex.DatetimeEngine]©Úreturnc C s t jS ©N)ÚlibindexZDatetimeEngine©Úselfr: r: r; Ú _engine_typeü s zDatetimeIndex._engine_typer Ú_datazdt.tzinfo | Noner' r c C s | j |¡}t|| jtdS )N)Únamer) )rR r? r rS Úobject)rP Z date_formatÚarrr: r: r; r? s zDatetimeIndex.strftimec C s$ | j |¡}t| j|| j| jdS )N©rS Úrefs)rR r> Útyper. rS Ú _references)rP r' rU r: r: r; r> s zDatetimeIndex.tz_convertÚraiser r )Ú ambiguousÚ nonexistentrL c C s$ | j |||¡}t| j|| jdS ©N©rS )rR r= rX r. rS )rP r' r[ r\ rU r: r: r; r= s zDatetimeIndex.tz_localizeNr% c C s( ddl m} | j |¡}|j|| jdS )Nr )r% r^ )Zpandas.core.indexes.apir% rR Ú to_periodr. rS )rP r( r% rU r: r: r; r_ s zDatetimeIndex.to_periodc C s | j ¡ }tj|| jdS r] )rR Úto_julian_dater r. rS )rP rU r: r: r; r` ! s
|
z DatetimeIndex.to_julian_dater$ c C s | j ¡ }| | ¡S rM )rR Ú isocalendarZ set_index)rP Zdfr: r: r; ra & s
|
zDatetimeIndex.isocalendarr
|
c C s | j jS rM )rR Ú_resolution_objrO r: r: r; rb + s z DatetimeIndex._resolution_objFzFrequency | lib.NoDefaultÚboolz Dtype | Noner ) r( Ú normalizer[ ÚdayfirstÚ yearfirstr) ÚcopyrS rL c
|
C s¨ t |r| |¡ t| || } t|tr^|tjkr^|tjkr^| d kr^|
|
rP| ¡ }| j|| dS tj || |
|
|||||d} d } |
|
st|t
|
t fr|j } | j| | | d}|S )Nr^ )r) rg r' r( re rf r[ rV ) r Z_raise_scalar_data_errorr r+ r r Ú
|
no_defaultrg r. Z_from_sequence_not_strictr r rY )r5 r& r( r' rd Úclosedr[ re rf r) rg rS ÚdtarrrW Zsubarrr: r: r; r4 2 s:
|
ÿþýüø
|
zDatetimeIndex.__new__c C s ddl m} | jdko || jS )z
|
Return a boolean if we are only dates (and don't have a timezone)
|
|
Returns
|
-------
|
bool
|
r )Ú is_dates_onlyN)Úpandas.io.formats.formatrk r' Z_values)rP rk r: r: r; Ú_is_dates_onlyf s z DatetimeIndex._is_dates_onlyc C s | j | jd}tt| |fd fS )N)r& rS )rR rS r< rX )rP r6 r: r: r; Ú
|
__reduce__v s zDatetimeIndex.__reduce__r )r) rL c C s | j dk rt|S t|S )zF
|
Can we compare values of the given dtype to our own?
|
N)r' r r )rP r) r: r: r; Ú_is_comparable_dtypez s
|
z"DatetimeIndex._is_comparable_dtypec s$ ddl m} || jd fddS )Nr )Úget_format_datetime64)Zis_dates_only_c s d | dS )Nú'r: )Úx©Ú formatterr: r; Ú<lambda> ó z/DatetimeIndex._formatter_func.<locals>.<lambda>)rl rp rm )rP rp r: rs r; Ú_formatter_func s z DatetimeIndex._formatter_funcc sX | j d k r&t | j ¡s&t | j ¡s&dS |j d k rLt |j ¡sLt |j ¡sLdS t |¡S )NF)r' r Zis_utcZis_fixed_offsetÚsuperÚ_can_range_setop)rP Úother©Ú __class__r: r; ry s ÿ
|
þ
|
ýÿ
|
þ
|
ýz DatetimeIndex._can_range_setopznpt.NDArray[np.int64]c C s | j ¡ }t| j j}|| }| jdkr2|d }nB| jdkrB|}n2| jdkrV|d }n | jdkrj|d }n
|
t| jd|| j< |S )z}
|
Return the number of microseconds since midnight.
|
|
Returns
|
-------
|
ndarray[int64_t]
|
Únsiè ÚusÚmsÚsé@B éÿÿÿÿ)rR Z_local_timestampsr Z_cresoÚunitÚNotImplementedErrorZ_isnan)rP ÚvaluesZppdÚfracÚmicrosr: r: r; Ú_get_time_micros¤ s
|
|
|
|
|
|
|
|
|
|
z DatetimeIndex._get_time_microsÚSr )r( rL c C s t |}| j ¡ }t| D ]T\}}|}| |¡sf| |¡}| |¡}t|| t|| k rb|}n|}|||< qtj || j
|
dS )zy
|
Snap time stamps to nearest occurring frequency.
|
|
Returns
|
-------
|
DatetimeIndex
|
r^ ) r rR rg Ú enumerateZ is_on_offsetÚrollbackZ rollforwardÚabsr, r. rS )rP r( r7 ÚiÚvr Út0Út1r: r: r; Úsnap¿ s
|
|
|
|
|
zDatetimeIndex.snapz dt.datetime)ÚresoÚparsedc C sX t ||jd}|j|j }}| |j¡}| |j¡}|jdk rP| jdkrPtd||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( NzSThe index must be timezone aware when indexing with a date string with a UTC offset)r Z attr_abbrevÚ
|
start_timeÚend_timer= rF r' Ú
|
ValueError)rP r r ZperÚstartÚendr: r: r; Ú_parsed_string_to_boundsÜ s
|
|
ÿz&DatetimeIndex._parsed_string_to_boundsÚstr)Úlabelc s@ t |¡\}}t|}| jd k r8|jd kr8| | j¡}||fS rM )rx Ú_parse_with_resor r' rF r= )rP r r r r{ r: r; r s
|
z DatetimeIndex._parse_with_resoÚNonec
|
C sB z| j |¡ W n, tk
|
r< } zt||W 5 d}~X Y nX dS )zU
|
Check for mismatched-tzawareness indexing and re-raise as KeyError.
|
N)rR Ú_assert_tzawareness_compatÚ TypeErrorÚKeyError)rP r8 Úerrr: r: r; Ú _disallow_mismatched_indexing s z+DatetimeIndex._disallow_mismatched_indexingc
|
C sx | |¡ |}t|| jr t}t|| jjr@| |¡ t|}nöt|t ræz|
|
|¡\}}W n2 t t j fk
|
r } zt||W 5 d}~X Y nX | |¡ | |¡ràz| ||¡W S tk
|
rÞ } zt||W 5 d}~X Y nX |}nPt|tjrtdt| j dt|j n t|tjr.| |¡S t|zt | |¡W S tk
|
rr } zt||W 5 d}~X Y nX dS )zm
|
Get integer location for requested label
|
|
Returns
|
-------
|
loc : int
|
Nz Cannot index z with )Z_check_indexing_errorr r) r r+ rR Z_recognized_scalarsr¢ r r r r ÚpytzZNonExistentTimeErrorr Z_can_partial_date_sliceZ_partial_date_sliceÚdtÚ timedeltar rX Ú__name__rI Úindexer_at_timer Úget_loc)rP r8 Zorig_keyr r r¡ r: r: r; r¨ s<
|
|
|
|
|
|
ÿ
|
zDatetimeIndex.get_loc)Úsidec sF t |tjr$t |tjs$t| ¡ }t ||¡}| j |¡ t|S rM )
|
r+ r¤ rH Údatetimer rG rx Ú_maybe_cast_slice_boundrR r )rP r r© r{ r: r; r« L s
|
z%DatetimeIndex._maybe_cast_slice_boundc
|
C s> t |tjr<t |tjr<|dk r0|dkr0td| ||¡S t |tjsTt |tjr\tddddd}||s||s| jrt | |||¡S t
|
d ¡}t
|
d ¡}|dk rÈ| |d
|
¡}|| k}|| k}|dk rô| |d ¡}| |k|@ }|| k|B }| ¡ std | ¡ d dd|
} t| t| kr6tdS | S dS )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.
|
|
Né z)Must have step size of 1 with time slicesz'Cannot mix time and non-time slice keysrc rK c S s | d k ot | t S rM )r+ r )Zpointr: r: r; Úcheck_str_or_noneq s z6DatetimeIndex.slice_indexer.<locals>.check_str_or_noneTÚleftÚrightzcValue based partial slicing on non-monotonic DatetimeIndexes with non-existing keys is not allowed.r )r+ r¤ rI r Úindexer_between_timer Zis_monotonic_increasingr Ú slice_indexerÚnpÚarrayr« ÚanyÚnonzeroÚlenÚslice)
|
rP r r Ústepr ÚmaskZ
|
raise_maskZ start_castedZ
|
end_castedZindexerr: r: r; r± X s@ ÿþý
|
|
|
ÿzDatetimeIndex.slice_indexerc C s dS )NZ
|
datetime64r: rO r: r: r; Ú inferred_type s zDatetimeIndex.inferred_typeznpt.NDArray[np.intp])ÚasofrL c C sx |r t dt|tr.ddlm} || ¡ }|jrX| jdkrFtd| |j¡
|
¡ }n|
|
¡ }t |}||k ¡ d S )av
|
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.
|
z 'asof' argument is not supportedr )ÚparseNz Index must be timezone aware.) r r+ r Zdateutil.parserr¼ rI rF r' r r> r Ú_time_to_microsrµ )rP rI r» r¼ Ú time_microsr r: r: r; r§ s
|
|
z DatetimeIndex.indexer_at_time)Ú include_startÚ include_endrL c C s¢ t |}t |}| ¡ }t|}t|}|r<|r<tj }} n.|rNtj}tj} n |r`tj}tj} n
|
tj }} ||krztj}
|
ntj}
|
|
|
|||| ||} | ¡ d S )aÎ
|
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.
|
r ) r# r r½ ÚoperatorÚleÚltÚand_Úor_rµ ) rP r r r¿ rÀ r¾ Z start_microsZ
|
end_microsZlopZropZjoin_opr¹ r: r: r; r° Ã s&
|
z"DatetimeIndex.indexer_between_time)rZ rZ )N)r )NNN)F)TT))r¦ Ú
|
__module__Ú __qualname__Ú__doc__Z_typr Z _data_clsZ!_supports_partial_string_indexingÚpropertyrQ Ú__annotations__r r? r> r= r_ r` ra r rb r rh r4 rm rn ro rw ry r r r r r¢ r¨ r! r« r± rº r§ r° Ú __classcell__r: r: r{ r; r, g st
|
u ü ô 4
|
$ 4
|
?' ÿr, FÚboth)r rc r r z
|
str | None)rd rS Ú inclusiver rL c K sJ |dkrt || |¡rd}tjf | |||||||d| }
|
tj|
|
|dS )a4
|
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, 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 ``'M'`` (month end frequency).
|
|
>>> pd.date_range(start='1/1/2018', periods=5, freq='M')
|
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31', '2018-04-30',
|
'2018-05-31'],
|
dtype='datetime64[ns]', freq='M')
|
|
Multiples are allowed
|
|
>>> pd.date_range(start='1/1/2018', periods=5, freq='3M')
|
DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
|
'2019-01-31'],
|
dtype='datetime64[ns]', freq='3M')
|
|
`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='3M')
|
|
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="100AS", 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='100AS-JAN')
|
NÚD)r r Úperiodsr( r' rd rÍ r r^ )ÚcomZany_noner Z_generate_ranger, r. ) r r rÏ r( r' rd rS rÍ r Úkwargsrj r: r: r; Ú
|
date_rangeö s 9ø ÷ rÒ ÚBz
|
int | Noner )rÏ r( rd rS rÍ rL c
|
K s¼ |dkrd} t | t|tr| d¡rz |p0d}t| ||d}W q tt fk
|
r~ } zd| } t| | W 5 d} ~ X Y qX n|s|rd| } t| tf | ||||||| d|
|
S ) 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' rd rS rÍ )r r+ r Ú
|
startswithr r r rÒ ) r r rÏ r( r' rd rS rÖ rÕ rÍ rÑ Úmsgr¡ r: r: r; Ú bdate_range¿ s4 H
|
ÿø ÷rÙ zdt.timeÚint)Útime_objrL c C s, | j d d d| j | j }d| | j S )Né< r )ÚhourÚminuteÚsecondÚ microsecond)rÛ Úsecondsr: r: r; r½ & s r½ )NNNNNFNrÌ )
|
NNNrÓ NTNNNrÌ )HÚ
|
__future__r rª r¤ rÁ Útypingr r r1 Únumpyr² r£ Z pandas._libsr r r r rN r Zpandas._libs.tslibsr
|
r r r Zpandas._libs.tslibs.offsetsr Zpandas._typingr r r r r r r Zpandas.util._decoratorsr r Zpandas.core.dtypes.commonr r r Zpandas.core.dtypes.genericr Zpandas.core.dtypes.missingr Z pandas.core.arrays.datetimesr r Zpandas.core.commonÚcoreÚcommonrÐ Zpandas.core.indexes.baser r Z pandas.core.indexes.datetimeliker! Z pandas.core.indexes.extensionr" Zpandas.core.tools.timesr# Zpandas.core.apir$ r% r< Z
|
_field_opsZ_datetimelike_methodsZ _bool_opsr, rÒ rÙ r½ r: r: r: r; Ú<module> s $ !þÿø
|
÷ õ ó z ø
|
ö K ög
|
