U
|
¬ý°dX ã @ sÊ d dl mZ d dlmZmZmZmZ d dlmZmZm Z d dl
|
Z
|
d dl Z d dl mZmZ d dlmZmZmZmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$ d dl%m&Z& d dl'm(Z(m)Z)m*Z*m+Z+m,Z, d d l-m.Z. d d
|
l/m0Z0 d d l1m2Z2 d d l3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZB d d lCmDZDmEZE d dlFmGZG d dlHmIZJ d dlKmLZL d dlMmN mOZP d dlQmRZR d dlSmTZTmUZU erÀd dlVmWZW d dlHmXZX ed d ZYdGdddddZZdHdddd d Z[G d d d eJj\eJj]Z^d dd d d!dd"d#dd#d#d$d%d"d&d'Z_dId(d#d)d#d*d+d,Z`dJd#dd-d.d/Zadddd0d1d2Zbd3d4 ZcdKdd#dd5d6d7Zdd8d8ddd9d:d;Zed<d<d#d=d>d?Zfd@dA Zgd<d<dBdCddDdEdFZhdS )Lé )Ú annotations)ÚdatetimeÚtimeÚ timedeltaÚtzinfo)Ú TYPE_CHECKINGÚIteratorÚcastN)ÚlibÚtslib)Ú
|
BaseOffsetÚNaTÚNaTTypeÚ
|
ResolutionÚ TimestampÚastype_overflowsafeÚfieldsÚget_resolutionÚget_supported_resoÚget_unit_from_dtypeÚints_to_pydatetimeÚis_date_array_normalizedÚis_supported_unitÚ is_unitlessÚnormalize_i8_timestampsÚnpy_unit_to_abbrevÚ timezonesÚ to_offsetÚtz_convert_from_utcÚ tzconversion)Úabbrev_to_npy_unit)ÚDateTimeErrorChoicesÚIntervalClosedTypeÚ TimeAmbiguousÚTimeNonexistentÚnpt)ÚPerformanceWarning)Úfind_stack_level)Úvalidate_inclusive)Ú DT64NS_DTYPEÚ INT64_DTYPEÚ is_bool_dtypeÚis_datetime64_any_dtypeÚis_datetime64_dtypeÚis_datetime64tz_dtypeÚis_dtype_equalÚis_extension_array_dtypeÚis_float_dtypeÚis_object_dtypeÚis_period_dtypeÚ is_sparseÚis_string_dtypeÚis_timedelta64_dtypeÚ pandas_dtype)ÚDatetimeTZDtypeÚExtensionDtype)Úisna)Ú datetimelike)Úgenerate_regular_range)Úget_period_alias)ÚDayÚTick©Ú DataFrame©Ú PeriodArrayÚnsú tzinfo | NoneÚstr©ÚtzÚunitc C s* | dkrt d| d¡S t| |dS dS )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
|
NúM8[ú]rG )ÚnpÚdtyper8 rG © rN úSd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/arrays/datetimes.pyÚ tz_to_dtype` s rP )ÚnameÚfieldc s fdd}| |_ ||_t|S )Nc sÆ | ¡ } | jkrt d¡r^| j}d}|rD|j}| d| dd¡¡}tj| | j|| j d}ntj
|
| | j d}|S | j kr tj | | j d}| j |d d}n"tj
|
| | j d}| j |d dd}|S ) N)ÚstartÚendé Z startingMonthÚmonth©Úreso©Ú
|
fill_valueÚfloat64)rZ Úconvert)Ú_local_timestampsÚ _bool_opsÚendswithÚfreqÚkwdsÚgetr Zget_start_end_fieldÚfreqstrÚ_cresoZget_date_fieldÚ _object_opsÚget_date_name_fieldÚ_maybe_mask_results)ÚselfÚvaluesr` Zmonth_kwra Úresult©rR rN rO Úft s6
|
|
ÿ
|
ÿz_field_accessor.<locals>.f)Ú__name__Ú__doc__Úproperty)rQ rR Z docstringrl rN rk rO Ú_field_accessors s "rp c s¶ e Zd ZU dZdZe dd¡ZeejfZ e
|
Z dZ e dddd Zd
|
d d d dddgZded< ddgZded< ddddddd d d d d d!d"d#d$d%gZded&< d'd(d)gZded*< ee e e d+g Zded,< d-d.d/d0d1d2d3d4d5d6d7g Zded8< d9Zd:ed;< d<Zd=ed>< eZed?d@ Zed<efdAd=d dB fdCdD Z ed<dEdFdGdHdIdJZ ed<dEe j e j dEdEdKdLdGdMdGdGdNdOdPdQZ edËd<dSdGdNdTdUdVd dWdXdYZ!dZdd[d\Z"d]dd^d_Z#d`ddadbZ$dZd]dcdddeZ%e d:ddfdgZ&e dhddidjZ'e'j(dkdj Z'e dhddldmZ)e dGddndoZ*e dpddqdrZ+dÌdAd fdsdt Z,duddvdwZ-dÍdGdH fdydz Z.dd<d{d|d}d~ddZ/dGdddZ0d`dddZ1d dd
dZ2ddddZ3d dddZ4e5j6dÎdNdTd dddZ7d}dddZ8d dddZ9dÏddddZ:dÐd}dddZ;dÑd}dddZ<e d}dddZ=e d}dddZ>e d}dddZ?d dd¡d¢Z@eAdd£d¤ZBeAdd¥d¦ZCeAdd§d¨ZDeAdd©dªZEeAdd«d¬ZFeAddd®ZGeAd$d¯d°ZHeAd%dd±ZId²ZJeAd d³eJZKeKZLeKZMeAd d´dµZNeNZOeAd!d¶d·ZPeAd"d¸d¹ZQeQZRdºZSeAd
|
d
|
eSjTd»d¼ZUeAd d eSjTd½d¼ZVeAd d d¾ZWeAd d d¿ZXeAdddÀZYeAdddÁZZeAdddÂZ[dÃddÄdÅZ\dÒdÇdGdGdÈdÉdÊZ] Z^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
|
Z datetimearrayr rD )r Ú
|
datetime64Údateztype[Timestamp])Úreturnc C s t S ©N)r ©rh rN rN rO Ú _scalar_typeÄ s zDatetimeArray._scalar_typeÚ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` rH re ÚyearrV ÚdayÚhourÚminuteÚsecondÚweekdayÚ dayofweekÚ day_of_weekÚ dayofyearÚ day_of_yearÚquarterÚ days_in_monthÚ daysinmonthÚ microsecondÚ
|
nanosecondÚ
|
_field_opsrs r ÚtimetzÚ
|
_other_opsrI Ú_datetimelike_opsÚ to_periodÚ tz_localizeÚ
|
tz_convertÚ normalizeÚstrftimeÚroundÚfloorÚceilÚ
|
month_nameÚday_nameÚas_unitÚ_datetimelike_methodsiè znp.dtype | DatetimeTZDtypeÚ_dtypeNzBaseOffset | NoneÚ_freqc C s t |j t |}|S ru )Ú_validate_dt64_dtyperM )Úclsri rM rN rN rO Ú_validate_dtype s
|
z DatetimeArray._validate_dtypeú
|
np.ndarray)ri r` rt c sr t |tjst|jdks tt |tjrF||jks8tt|rZtn|jt|jksZtt
|
||¡}||_ |S )NÚM) Ú
|
isinstancerL ÚndarrayÚAssertionErrorÚkindrM r rd r ÚsuperÚ _simple_newr )r¡ ri r` rM rj ©Ú __class__rN rO rª s zDatetimeArray._simple_newF©rM ÚcopyÚbool©r® c C s | j |||dS )Nr )Ú_from_sequence_not_strict)r¡ ZscalarsrM r® rN rN rO Ú_from_sequence! s z DatetimeArray._from_sequenceÚraise)rM r® rH r` ÚdayfirstÚ yearfirstÚ ambiguousz'str | BaseOffset | lib.NoDefault | Noner# )r® r` r´ rµ r¶ c C sh |dk} |t jk r|nd}t |¡\}}
|
|dk} |t jkr@d}n
|
t |¡}t|}t||| }d} |dk rt|t j
|
rt |¡d } n|j } t ||||||| d\} }}t||| |dk rÈ| rÈtdt |||
|
¡\}}
|
| râd}t | j
|
¡d }t||}| j| ||d}| dk r,| |j kr,| | ¡}|dkrR|dk rR| j|||d n|
|
rdt|j|_|S )z\
|
A non-strict version of _from_sequence, called from DatetimeIndex.__new__.
|
Nr ©r® rH r´ rµ r¶ Úout_unitz^Passed data is timezone-aware, incompatible with 'tz=None'. Use obj.tz_localize(None) instead.©r` rM )r¶ )r
|
Ú
|
no_defaultÚdtlZmaybe_infer_freqr Ú maybe_get_tzr Ú_validate_tz_from_dtyper¥ rL rM Z datetime_datarI Ú_sequence_to_dt64nsÚ
|
ValueErrorZvalidate_inferred_freqrP rª r Z_validate_frequencyr Ú inferred_freqr )r¡ ÚdatarM r® rH r` r´ rµ r¶ Z explicit_noneZ
|
freq_inferÚexplicit_tz_nonerI ZsubarrrÀ Ú data_unitÚ
|
data_dtyperj rN rN rO r± % sR
|
|
ù
|
ÿ
|
|
z'DatetimeArray._from_sequence_not_strictÚboth©rI r$ r" ú
|
str | None)r r¶ Ú nonexistentÚ inclusiverI rt c
|
C st t |¡}|d kr2tdd |||fD r2tdt ||||¡dkrNtdt|}|d k rft|}|d k rvt|}|tks|tkrtd|
|
d k r¨|
|
dkr¬tdnd }
|
|d k rÊ|
|
d k rÊ|j |
|
d
|
d }|d k rè|
|
d k rè|j |
|
d
|
d }t
|
| \} } t |||\}}t |||}|d k rj|d kr(d n|j } |d kr<d n|j }t|| |||||}t|||||||}|d k rxt|tr¨|d k r| d ¡}|d k r¨| d ¡}t|trÈt|||||
|
d }n,t|||||
|
d }tjdd |D tjd}|d k r|j n|j }|d k r®|d kr®t |¡sFt|
|
}tj |||||d}|d k r^| |||¡}|d k r®| |||¡}n6tj d|j |j |dd|j }|j dkr®| d¡}||krÒ| sF| sF|dd
}ntt|j }t|j }| rò| sF| s t!|r |d |kr |dd
}| sFt!|rF|d |krF|d d
}| "d|
|
d¡}t#||
|
d }| j$|||dS )Nc s s | ]}|d kV qd S ru rN ©Ú.0ÚxrN rN rO Ú <genexpr> s z0DatetimeArray._generate_range.<locals>.<genexpr>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ÚusrD z+'unit' must be one of 's', 'ms', 'us', 'ns'rD F)Zround_okrÆ ©rS rT ÚperiodsÚoffsetrI c S s g | ]
|
}|j qS rN )Ú_valuerÊ rN rN rO Ú
|
<listcomp>Ã s z1DatetimeArray._generate_range.<locals>.<listcomp>©rM ©r¶ rÈ Úcresor Úint64Úi8é éÿÿÿÿz datetime64[rK r¹ )%r» Zvalidate_periodsÚanyr¿ ÚcomZcount_not_noner r r r r( Ú_maybe_normalize_endpointsÚ_infer_tz_from_endpointsrH Ú_maybe_localize_pointr¥ r> r r? r< Ú_generate_rangerL ÚarrayrÚ r Úis_utcr r Útz_localize_to_utcZlinspacerÕ rM ÚastypeÚlenÚviewrP rª )r¡ rS rT rÓ r` rH r r¶ rÈ rÉ rI Zleft_inclusiveZright_inclusiveZstart_tzZend_tzZi8valuesZxdrZ endpoint_tzrÙ Zstart_i8Zend_i8Ú dt64_valuesrM rN rN rO rã v sÀ
|
ÿ
|
|
ÿ ÿ
|
|
|
|
|
ÿ û
|
|
|
ÿÿ
|
|
|
|
z DatetimeArray._generate_rangez np.datetime64c C sP t || js |tk r td| |¡ |tkr>t |j| j¡S | | j¡j
|
S d S )Nz 'value' should be a Timestamp.) r¥ rw r r¿ Ú_check_compatible_withrL rr rÕ rI r Zasm8©rh ÚvaluerN rN rO Ú _unbox_scalarû s
|
zDatetimeArray._unbox_scalarzTimestamp | NaTTypec C s t || jdS )N©rH )r rH rì rN rN rO Ú_scalar_from_string s z!DatetimeArray._scalar_from_stringÚNonec C s |t kr d S | |¡ d S ru )r Ú_assert_tzawareness_compat)rh ÚotherrN rN rO rë s z$DatetimeArray._check_compatible_with)rÌ rt c C s" | d¡}tj|| j| jd}|S )NrÛ )rX rH )ré r Z_from_value_and_resord rH )rh rÌ rí ÚtsrN rN rO Ú _box_func s
|
zDatetimeArray._box_funcc C s | 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 rv rN rN rO rM s zDatetimeArray.dtyperE c C s t | jddS )zÌ
|
Return the timezone.
|
|
Returns
|
-------
|
datetime.tzinfo, pytz.tzinfo.BaseTZInfo, dateutil.tz.tz.tzfile, or None
|
Returns None when the array is tz-naive.
|
rH N)ÚgetattrrM rv rN rN rO rH . s zDatetimeArray.tzc C s t dd S )NzNCannot directly set timezone. Use tz_localize() or tz_convert() as appropriate)ÚAttributeErrorrì rN rN rO rH ; s ÿc C s | j S )z(
|
Alias for tz attribute
|
rï rv rN rN rO r C s zDatetimeArray.tzinfoc C s t | j| j| jdS )zN
|
Returns True if all of the dates are at midnight ("no time")
|
rW )r Úasi8rH rd rv rN rN rO Ú is_normalizedJ s zDatetimeArray.is_normalizedr c C s t | j| j| jdS )NrW )r rø rH rd rv rN rN rO Ú_resolution_objQ s z DatetimeArray._resolution_objc s |d kr| j rt}t j|dS )Nr× )rH Úobjectr© Ú __array__)rh rM r« rN rO rü X s zDatetimeArray.__array__r c c s | j dkr(tt| D ]}| | V qnl| j}t| }d}|| d }t|D ]D}|| }t|d | |}t|||
| jd| jd}|E dH qNdS )zt
|
Return an iterator over the boxed values
|
|
Yields
|
------
|
tstamp : Timestamp
|
rÜ i' Ú timestamp)rH ÚboxrX N)ÚndimÚrangerè rø Úminr rH rd ) rh ÚirÁ ÚlengthÚ chunksizeÚchunksZstart_iZend_iZ convertedrN rN rO Ú__iter___ s"
|
|
üzDatetimeArray.__iter__Tc sT t |}t|| jr$|r | ¡ S | S t|trt|tsHt j||dS | j d kr\t
|
dn2t |j ¡}t | j||d}t| j||| jdS n´| j d krÚt|rÚt|sÚtt|rÚt | j|dd}t| j||jdS | j d k röt|röt
|
dnN| j d kr,t|r,|| jkr,t|r,t
|
dnt|rD| j|jdS tj | ||¡S ) Nr° zCannot use .astype to convert from timezone-naive dtype to timezone-aware dtype. Use obj.tz_localize instead or series.dt.tz_localize instead©rM 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` )r7 r/ rM r® r¥ r9 r8 r© rç rH Ú TypeErrorrL rF r Ú_ndarrayÚtyperª r` r- r r r r3 r r» ZDatetimeLikeArrayMixin)rh rM r® Znp_dtypeZ
|
res_valuesr« rN rO rç | sV
|
|
|
ÿ ÿþý
|
üÿÿþýüÿ
|
zDatetimeArray.astype)Úna_repÚ date_formatz str | floatznpt.NDArray[np.object_])r rt c K s0 ddl m} || |}tj| j| j||| jdS )Nr )Ú!get_format_datetime64_from_values)rH Úformatr rX )Zpandas.io.formats.formatr r Zformat_array_from_datetimerø rH rd )rh r r Úkwargsr ÚfmtrN rN rO Ú_format_native_types s
|
ÿz"DatetimeArray._format_native_typesc C s6 t |tjrt|}t|ds"dS |j}t | j|¡S )Nr F)r¥ rL rr r Úhasattrr r Ú
|
tz_compare)rh ró Úother_tzrN rN rO Ú _has_same_tzÐ s
|
zDatetimeArray._has_same_tzc C sb t |dd }t |dd }t|r(|jj}|tkr2n,| jd krN|d k r^tdn|d kr^tdd S )Nr rM z;Cannot compare tz-naive and tz-aware datetime-like objects.z:Cannot compare tz-naive and tz-aware datetime-like objects)rö r. rM rH r r )rh ró r Z other_dtyperN rN rO rò Û s
|
ÿÿz(DatetimeArray._assert_tzawareness_compatc C sÌ t |trt| jd k r$| d ¡}n| }z| |¡ |j¡}W nb tk
|
r t j
|
dt t d | d¡| }t| |¡ | j¡}t| s| | j¡ Y S Y n(X tj||jd}| jd k rÈ| | j¡}|S )NzCNon-vectorized DateOffset being applied to Series or DatetimeIndex.©Ú
|
stacklevelÚOr× )r¥ r? r§ rH r Z _apply_arrayré rM ÚNotImplementedErrorÚwarningsÚwarnr& r' rç r
|
r² r rI rè rq rª )rh rÔ ri rj rN rN rO Ú _add_offsetó s(
|
ý
|
zDatetimeArray._add_offsetznpt.NDArray[np.int64]c C s0 | j dkst | j ¡r | jS t| j| j | jdS )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.
|
NrW )rH r rå rø r rd rv rN rN rO r] s z DatetimeArray._local_timestampsc C s> t |¡}| jdkr tdt|| jd}| j| j|| jdS )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')
|
Nz?Cannot convert tz-naive timestamps, use tz_localize to localizerÆ r ) r r¼ rH r rP rI rª r r` )rh rH rM rN rN rO r s @
|
|
ÿzDatetimeArray.tz_convert)r¶ rÈ rt c C sê d}||kr t |ts td| jdk rP|dkrFt| j| j| jd}qrtdn"t |¡}t
|
j | j|||| jd}| d| j d¡}t|| j d }d}t |¡sºt| d
|
krÂt|d sÂ| j}n|dkrÚ| jdkrÚ| j}| j|||d 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 Z shift_forwardZshift_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Ø rJ rK rÆ rÜ r r )r¥ r r¿ rH r rø rd r r r¼ r ræ ré rI rP rå rè r: r` rª )rh rH r¶ rÈ Znonexistent_optionsZ new_datesrM r` rN rN rO r k s:
|
ÿÿ
|
|
|
û"zDatetimeArray.tz_localizec C s t | j| j| jdS )zx
|
Return an ndarray of datetime.datetime objects.
|
|
Returns
|
-------
|
numpy.ndarray
|
)rH rX ©r rø rH rd rv rN rN rO Ú to_pydatetime' s zDatetimeArray.to_pydatetimec C sZ t | j| j| jd}| | jj¡}t| j||jd}| d¡}| jdk rV|
|
| 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× ÚinferN) r rø rH rd ré r rM r
|
rª Z
|
_with_freqr )rh Z
|
new_valuesrê ZdtarN rN rO r 1 s &
|
|
zDatetimeArray.normalizerC c C sx ddl m} | jdk r(tjdtt d |dkrd| jp:| j}|dkrLt dt
|
|}|dkr`|}|}|j | j || jdS )ax
|
Cast to PeriodArray/Index at a particular frequency.
|
|
Converts DatetimeArray/Index to PeriodArray/Index.
|
|
Parameters
|
----------
|
freq : str or Offset, optional
|
One of pandas' :ref:`offset strings <timeseries.offset_aliases>`
|
or an Offset object. Will be inferred by default.
|
|
Returns
|
-------
|
PeriodArray/Index
|
|
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 rB NzNConverting to PeriodArray/Index representation will drop timezone information.r z8You must pass a freq argument as current index has none.rï ) Úpandas.core.arraysrC rH r r Ú UserWarningr' rc rÀ r¿ r= Z_from_datetime64r )rh r` rC ÚresrN rN rO r ` s$ ,
|
ü ÿzDatetimeArray.to_periodc C s. | ¡ }tj|d|| jd}| j|dd}|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='M', 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='M', periods=3)
|
>>> idx
|
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'],
|
dtype='datetime64[ns]', freq='M')
|
>>> 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='M', periods=3)
|
>>> idx
|
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'],
|
dtype='datetime64[ns]', freq='M')
|
>>> idx.month_name(locale='pt_BR.utf8') # doctest: +SKIP
|
Index(['Janeiro', 'Fevereiro', 'Março'], dtype='object')
|
r ©ÚlocalerX NrY ©r] r rf rd rg ©rh r$ ri rj rN rN rO r « s 1 ÿzDatetimeArray.month_namec C s. | ¡ }tj|d|| jd}| j|dd}|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 r# NrY r% r& rN rN rO r ä s 1 ÿzDatetimeArray.day_namec C s | ¡ }t|d| jdS )zr
|
Returns numpy array of :class:`datetime.time` objects.
|
|
The time part of the Timestamps.
|
r ©rþ rX ©r] r rd ©rh Z
|
timestampsrN rN rO r s
|
zDatetimeArray.timec C s t | j| jd| jdS )z
|
Returns numpy array of :class:`datetime.time` objects with timezones.
|
|
The time part of the Timestamps.
|
r r' r rv rN rN rO r + s zDatetimeArray.timetzc C s | ¡ }t|d| jdS )z«
|
Returns numpy array of python :class:`datetime.date` objects.
|
|
Namely, the date part of Timestamps without time and
|
timezone information.
|
rs r' r( r) rN rN rO rs 4 s zDatetimeArray.daterA c C sN ddl m} | ¡ }tj|| jd}||dddgdd}| jrJd |j| j< |S )
|
aö
|
Calculate year, week, and day according to the ISO 8601 standard.
|
|
.. versionadded:: 1.1.0
|
|
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 ZUInt32)ÚcolumnsrM N) ÚpandasrA r] r Zbuild_isocalendar_sarrayrd Z_hasnaZilocZ_isnan)rh rA ri ZsarrayZiso_calendar_dfrN rN rO Ú isocalendarC s " ÿ zDatetimeArray.isocalendarÚYa´
|
The year of the datetime.
|
|
Examples
|
--------
|
>>> datetime_series = pd.Series(
|
... pd.date_range("2000-01-01", periods=3, freq="Y")
|
... )
|
>>> 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
|
r¤ a·
|
The month as January=1, December=12.
|
|
Examples
|
--------
|
>>> datetime_series = pd.Series(
|
... pd.date_range("2000-01-01", periods=3, freq="M")
|
... )
|
>>> 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
|
Ú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
|
Ú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
|
ÚmaË
|
The minutes of the datetime.
|
|
Examples
|
--------
|
>>> datetime_series = pd.Series(
|
... pd.date_range("2000-01-01", periods=3, freq="T")
|
... )
|
>>> 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Ï 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Ñ 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
|
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
|
ZdowZdoyz.
|
The ordinal day of the year.
|
Úqz*
|
The quarter of the date.
|
Zdimz2
|
The number of days in the month.
|
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])
|
Úfirst)Z first_or_lastÚlasta
|
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])
|
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])
|
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])
|
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])
|
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="Y")
|
>>> idx
|
DatetimeIndex(['2012-12-31', '2013-12-31', '2014-12-31'],
|
dtype='datetime64[ns]', freq='A-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
|
znpt.NDArray[np.float64]c C sÖ t | j¡}t | j¡}t | j¡}|dk }|| d8 < || d7 < |t d| d d ¡ d| t |d ¡ t |d ¡ t |d
|
¡ d | j| jd | j d | j
|
d d | j d d d 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Ü rU é iÉ é im é éd i g C:Aé< i i@B i Ê;é ) rL Úasarrayr rV r Zfixr r r r r r )rh r rV r ZtestarrrN rN rO Úto_julian_dateo s@ ÿþ ý ü ûúÿþ ý üùùÿz DatetimeArray.to_julian_daterÜ Úint)ÚddofÚkeepdimsÚskipnac
|
C sR ddl m} | jjj dd¡}t |¡}|j| j |¡|d} | j |||||dS )aÉ
|
Return sample standard deviation over requested axis.
|
|
Normalized by N-1 by default. This can be changed using the ddof argument
|
|
Parameters
|
----------
|
axis : int optional, default None
|
Axis for the function to be applied on.
|
For `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
|
r )ÚTimedeltaArrayrr Z timedelta64r× )ÚaxisÚoutr> r? r@ )
|
r rA r rM rQ ÚreplacerL rª ré Ústd)
|
rh rB rM rC r> r? r@ rA Z dtype_strZtdarN rN rO rE s
|
!
|
zDatetimeArray.std)NFr³ r³ rÅ )N)T)r³ r³ )N)N)N)NNNrÜ FT)_rm Ú
|
__module__Ú __qualname__rn Z_typrL rr Z_internal_fill_valuer Z_recognized_scalarsr, Z_is_recognized_dtypeZ_infer_matchesro rw r^ Ú__annotations__re r r r r Z__array_priority__r r) Z_default_dtypeÚ classmethodr¢ rª r² r
|
rº r± rã rî rð rë rõ rM rH Úsetterr rù rú rü r rç r r rò r r] r r» Z ravel_compatr r r r r r r r rs r- rp r rV r r r r r r Z_dayofweek_docr r
r r r r r r Z _is_month_docr rx ry rz r{ r| r} r~ r< rE Ú __classcell__rN rN r« rO rq sÊ
|
"
|
ù ð ÿ
|
õ
|
üö P ö ô
|
G ÿ L ü <
|
/K99 -ýýýýýýýý" ýýý,
|
ÿ
|
ÿý*ý*ý,ý,ý*% ùrq Fr³ r· r¯ r# rÇ c C sÚ d}t j| |dd\} }t| tr(| j}t| ||d\} }t| dd}t} |dk rdt d| d¡} t
|
|s~t |s~t |r,d}t j| dd d
|
kr¢| tj¡} n|dk rÜ|d krÜtj| td }
|
t |
|
|¡} | t¡|dfS t| ||dd \} } |r | r | j dks t| t¡|dfS | r&| }| j }t|rLt|| j}| j} n&t |rLt| d| } | j }t |}t |s¶t |}t |}t d| d¡}t!| |dd} t |}d}| j j"dkrà| | j #d¡¡} | j }d}|dk r0| j$}| j%dkr| &¡ } t'j(| d¡|||d} | |¡} | )|¡} | j |ksFt| j | } n&| j t*krh| jtjdd} | | ¡} |r| +¡ } t| tj,stt-| | j j.dks¬t| j dks¼tt t | j sÐt| ||fS )aÿ
|
Parameters
|
----------
|
data : list-like
|
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[ns]``.
|
tz : tzinfo or None
|
Either the user-provided tzinfo or one inferred from the data.
|
inferred_freq : Tick or None
|
The inferred frequency of the sequence.
|
|
Raises
|
------
|
TypeError : PeriodDType data is passed
|
Nrq )Zcls_namerï rM rJ rK F)r@ Úintegerr³ r× )r´ rµ Ú allow_objectrÛ r r ú>ú<rÜ )r¶ rÙ r° r¤ ÚM8)/r» Z!ensure_arraylike_for_datetimeliker¥ rq r` Úmaybe_convert_dtyperö r) rL rM r2 r5 r4 r
|
Z infer_dtyperç rÚ r; rû r Zarray_to_datetime_with_tzré Úobjects_to_datetime64nsr§ r. Ú_maybe_infer_tzrH r r- r r r r r Ú byteorderZ newbyteorderÚshaperÿ Zravelr ræ Zreshaper* r® r¦ r
|
r¨ )rÁ r® rH r´ rµ r¶ r¸ rÀ rÄ Z out_dtypeZobj_dataZi8dataÚ inferred_tzrj Z new_dtyperà Znew_resoZnew_unitrU rN rN rO r¾  s $ ÿ
|
|
ÿþý ü
|
|
|
|
|
|
ÿ
|
|
|
r¾ r£ r! )rÁ ÚutcÚerrorsrM c C s |dks t tj| dtjd} tj| ||||d\}}|dk rL| d¡|fS t|r\||fS t|rz|rp||fS t |nt |dS )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.
|
|
Returns
|
-------
|
result : ndarray
|
np.int64 dtype if returned values represent UTC timestamps
|
np.datetime64[ns] if returned values represent wall times
|
object if mixed timezones
|
inferred_tz : tzinfo or None
|
|
Raises
|
------
|
ValueError : if data cannot be converted to datetimes
|
)r³ ÚignoreZcoerceF)r® rM )rX rW r´ rµ NrÛ )
|
r§ rL rä Úobject_r Zarray_to_datetimeré r- r2 r )rÁ r´ rµ rW rX rM rj Z tz_parsedrN rN rO rR Y s$ # û
|
|
rR )r® rH c C s t | ds| |fS t| jr2| t¡ d¡} d}ndt| jsFt| jrZtd| j dn<t | jrntdn(t
|
| jrt | jst j | t jd} 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
|
rM rÛ Fzdtype z& cannot be converted to datetime64[ns]zFPassing PeriodDtype data is invalid. Use `data.to_timestamp()` insteadr× )r r1 rM rç r) ré r6 r+ r r3 r0 r. rL rä rZ )rÁ r® rH rN rN rO rQ ¡ s
|
|
|
ÿrQ )rH rV rt c C s< | dkr|} n*|dkrn t | |¡s8td| 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
|
Nzdata is already tz-aware z , unable to set specified tz: )r r r )rH rV rN rN rO rS × s ÿrS c C s | dk rt | } t| t d¡r,d}t|t| tjrN| jdks^tt| r^t| tjt fsntd| dt
|
| ddrt t | } t t | j¡d} | 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
|
NrP 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'.rH rï )r7 r/ rL rM r¿ r¥ r¨ r r r8 rö r r Ztz_standardizerH )rM ÚmsgrN rN rO r õ s* ÿ
|
ÿþ
|
þý
|
ÿ
|
r )rH r rt c C s¦ | dk r¢t | tr6zt | ¡} W n tk
|
r4 Y nX t| dd}|dk rv|dk rft ||¡sftd|rrtd|}|dk r¢t | r¢|dk r¢t ||¡s¢td|S )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
|
NrH z-cannot supply both a tz and a dtype with a tzz3Cannot pass both a timezone-aware dtype and tz=NonezHcannot supply both a tz and a timezone-naive dtype (i.e. datetime64[ns]))
|
r¥ rF r8 Zconstruct_from_stringr rö r r r¿ r- )rM rH r ZdtzrN rN rO r½ + s&
|
ÿr½ r )rS rT rH rt c
|
C s zt | |¡}W n, tk
|
r< } ztd|W 5 d}~X Y nX t |¡}t |¡}|dk rx|dk rxt ||¡stdn |dk r|}|S )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 Z infer_tzinfor§ r r¼ r )rS rT rH rV ÚerrrN rN rO rá ` s ÿþ
|
|
|
rá zTimestamp | None©rS rT r c C s, |r$| d k r| ¡ } |d k r$| ¡ }| |fS ru )r r] rN rN rO rà s rà c C sV |dkrR|dk rR|dkr |nd}||dd}t |ts>|dkrF||d< | jf |} | 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
|
is_none : argument that should be None
|
is_not_none : argument that should not be None
|
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
|
Nr F)r¶ rÈ rH rH )r¥ r? r )rô Zis_noneZ is_not_noner` rH r¶ rÈ Z localize_argsrN rN rO râ s râ z
|
int | Noner rÒ c c s t |}t| } | tk r$| |¡} nd} t|}|tk rD| |¡}nd}| rb| | ¡sb| | ¡} n|rz| |¡sz| |¡}|dkr|| k r|jdkrd}d}|dkr´| |d | }| dkrÌ||d | } tt| } tt|}| }|jdkr@||kr|V ||krq| |¡ |¡}||kr8t
|
d| d|}qðnP||kr|V ||kr^q| |¡ |¡}||krt
|
d| d|}q@dS )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 Z is_on_offsetZ rollforwardÚrollbackÚnr Ú_applyr¿ )rS rT rÓ rÔ rI ÚcurZ next_daterN rN rO rã ¹ sP
|
|
|
|
|
|
|
|
|
rã )rD )N)Fr³ F)N)F)iÚ
|
__future__r r r r r Útypingr r r r ÚnumpyrL Z pandas._libsr
|
r Zpandas._libs.tslibsr r r r r r r r r r r r r r r r r r r r Zpandas._libs.tslibs.dtypesr Zpandas._typingr! r" r# r$ r% Z pandas.errorsr& Zpandas.util._exceptionsr' Zpandas.util._validatorsr( Zpandas.core.dtypes.commonr) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 Zpandas.core.dtypes.dtypesr8 r9 Zpandas.core.dtypes.missingr: r r; r» Zpandas.core.arrays._rangesr< Zpandas.core.commonÚcoreÚcommonrß Zpandas.tseries.frequenciesr= Zpandas.tseries.offsetsr> r? r, rA rC Z _midnightrP rp Z TimelikeOpsZ DatelikeOpsrq r¾ rR rQ rS r r½ rá rà râ rã rN rN rN rO Ú<module> sz X D
|
( 8ø úH6 7 ÿ5+ !
|
