Pandas 時間序列 - 縱覽與時間戳

依託 NumPy 的 datetime64、timedelta64 等數據類型，pandas 可以處理各種時間序列數據，還能調用 scikits.timeseries 等 Python 支持庫的時間序列功能。

Pandas 支持以下操作：

解析時間格式字符串、np.datetime64、datetime.datetime 等多種時間序列數據。

<code>In [
1
]: 
import
 datetime

In [
2
]: dti = pd.to_datetime([
'1/1/2018'
, np.datetime64(
'2018-01-01'
),
   ...:                       datetime.datetime(
2018
, 
1
, 
1
)])
   ...: 

In [
3
]: dti
Out[
3
]: DatetimeIndex([
'2018-01-01'
, 
'2018-01-01'
, 
'2018-01-01'
], dtype=
'datetime64[ns]'
, freq=
None
)/<code>

生成 DatetimeIndex、TimedeltaIndex、PeriodIndex 等定頻日期與時間段序列。

<code>
In
 [
4
]: dti = pd.date_range(
'2018-01-01' 
, periods=
3
, freq=
'H'
)

In [
5
]: dti
Out[
5
]: 
DatetimeIndex([
'2018-01-01 00:00:00'
, 
'2018-01-01 01:00:00'
,
               
'2018-01-01 02:00:00'
],
              dtype=
'datetime64[ns]'
, freq=
'H'
)/<code>

處理、轉換帶時區的日期時間數據。

<code>
In
 [
6
]: dti = dti.tz_localize(
'UTC'
)

In [
7
]: dti
Out[
7
]: 
DatetimeIndex([
'2018-01-01 00:00:00+00:00'
, 
'2018-01-01 01:00:00+00:00'
,
               
'2018-01-01 02:00:00+00:00'
],
              dtype=
'datetime64[ns, UTC]'
, freq=
'H'
)

In [
8
]: dti.tz_convert(
'US/Pacific'
)
Out[
8
]: 
DatetimeIndex([ 
'2017-12-31 16:00:00-08:00'
, 
'2017-12-31 17:00:00-08:00'
,
               
'2017-12-31 18:00:00-08:00'
],
              dtype=
'datetime64[ns, US/Pacific]'
, freq=
'H'
)/<code>

按指定頻率重採樣，並轉換為時間序列。

<code>
In
 
[9]:
 
idx
 
=
 
pd.date_range('2018-01-01',
 
periods=5,
 
freq='H')

In
 
[10]:
 
ts
 
=
 
pd.Series(range(len(idx)),
 
index=idx)

In
 
[11]:
 
ts
Out[11]:
 
2018 
-01
-01
 
00
:00:00
    
0
2018
-01
-01
 
01
:00:00
    
1
2018
-01
-01
 
02
:00:00
    
2
2018
-01
-01
 
03
:00:00
    
3
2018
-01 
-01
 
04
:00:00
    
4
Freq:
 
H,
 
dtype:
 
int64

In
 
[12]:
 
ts.resample('2H').mean()
Out[12]:
 
2018
-01
-01
 
00
:00:00
    
0.5
2018
-01
-01
 
02
:00:00
    
2.5
2018 
-01
-01
 
04
:00:00
    
4.0
Freq:
 
2H,
 
dtype:
 
float64
/<code>

用絕對或相對時間差計算日期與時間。

<code>
In
 [
13
]: friday = pd.Timestamp(
'2018-01-05'
)

In [
14
]: friday.day_name()
Out[
14
]: 
'Friday'

 
In [
15
]: saturday = friday + pd.Timedelta(
'1 day'
)

In [
16
]: saturday.day_name()
Out[
16
]: 
'Saturday'

 
In [
17
]: monday = friday + pd.offsets.BDay()

In [
18
]: monday.day_name()
Out[ 
18
]: 
'Monday'
/<code>

Pandas 提供了一組精悍、實用的工具集以完成上述操作。

時間序列縱覽

Pandas 支持 4 種常見時間概念：

1. 日期時間（Datetime）：帶時區的日期時間，類似於標準庫的datetime.datetime 。
2. 時間差（Timedelta）：絕對時間週期，類似於標準庫的datetime.timedelta。
3. 時間段（Timespan）：在某一時點以指定頻率定義的時間跨度。
4. 日期偏移（Dateoffset）：與日曆運算對應的時間段，類似 dateutil 的dateutil.relativedelta.relativedelta。

一般情況下，時間序列主要是 Series 或 DataFrame 的時間型索引，可以用時間元素進行操控。

<code>
In
 
[19]:
 
pd.Series(range(3),
 
index=pd.date_range('2000',
 
freq='D',
 
periods=3))
Out[19]:
 
2000
-01
-01
    
0
2000
-01
-02
    
1
2000
-01
-03
    
2
Freq:
 
D,
  
dtype:
 
int64
/<code>

當然，Series 與 DataFrame 也可以直接把時間序列當成數據。

<code>
In
 
[20]:
 
pd.Series(pd.date_range('2000',
 
freq='D',
 
periods=3))
Out[20]:
 
0
   
2000
-01
-01
1
   
2000
-01
-02
2
   
2000
-01
-03
dtype:
 
datetime64[ns]
/<code>

Series 與 DataFrame 提供了 datetime、timedelta 、Period 擴展類型與專有用法，不過，Dateoffset 則保存為 object。

<code>
In
 
[21]:
 
pd.Series(pd.period_range('1/1/2011',
 
freq='M',
 
periods=3))
Out[21]:
 
0
    
2011
-01
1
    
2011
-02
2
    
2011
-03
dtype:
 
period[M]

In
 
[22]:
 
pd.Series([pd.DateOffset(1),
 
pd.DateOffset(2)])
Out[22]:
 
0 
         

1
    
 
*
 
DateOffsets>
dtype:
 
object

In
 
[23]:
 
pd.Series(pd.date_range('1/1/2011',
 
freq='M',
 
periods=3))
Out[23]:
 
0
   
2011
-01
-31
1
   
2011
-02
-28
2
   
2011
-03
-31 

dtype:
 
datetime64[ns]
/<code>

Pandas 用 NaT 表示日期時間、時間差及時間段的空值，代表了缺失日期或空日期的值，類似於浮點數的 np.nan。

<code>In [24]: pd.Timestamp(pd.NaT)
Out[24]: NaT

In [25]: pd.Timedelta(pd.NaT)
Out[25]: NaT

In [26]: pd.Period(pd.NaT)
Out[26]: NaT

 
In [27]: pd.NaT == pd.NaT
Out[27]: False
/<code>

時間戳 vs. 時間段

時間戳是最基本的時間序列數據，用於把數值與時點關聯在一起。Pandas 對象通過時間戳調用時點數據。

<code>
In
 
[28]
: 
pd
.Timestamp
(datetime.datetime(
2012
, 
5
, 
1
))
Out
 
[28]
: 
Timestamp
(
'2012-05-01 00:00:00'
)

In
 
[29]
: 
pd
.Timestamp
(
'2012-05-01'
)
Out
[29]
: 
Timestamp
(
'2012-05-01 00:00:00'
)

In
 
[30]
: 
pd
.Timestamp
(
2012
, 
5
, 
1
)
Out
[30]
: 
Timestamp
(
'2012-05-01 00:00:00'
)/<code>

不過，大多數情況下，用時間段改變變量更自然。Period 表示的時間段更直觀，還可以用日期時間格式的字符串進行推斷。

示例如下：

<code>
In
 
[31]
: 
pd
.Period
(
'2011-01'
)
Out
[31]
: 
Period
(
'2011-01'
, 
'M'
)

In
 
[32]
: 
pd
.Period
(
'2012-05'
, freq=
'D'
)
Out
[32]
: 
Period
(
'2012-05-01'
, 
'D'
)/<code>

Timestamp 與 Period 可以用作索引。作為索引的 Timestamp 與 Period 列表則被強制轉換為對應的 DatetimeIndex 與 PeriodIndex。

<code>
In
 
[33]:
 
dates
 
=
 
[pd.Timestamp('2012-05-01'),
   
....:
          
pd.Timestamp('2012-05-02'),
   
....:
          
pd.Timestamp('2012-05-03')]
   
....:
 

In
 
[34]:
 
ts
 
=
 
pd.Series(np.random.randn(3),
 
dates)

In
 
[35]:
 
type(ts.index)
Out[35]:
 
pandas.core.indexes.datetimes.DatetimeIndex

In
 
[36]:
 
ts.index
 
Out[36]:
 
DatetimeIndex(['2012-05-01',
 
'2012-05-02'
,
 
'2012-05-03'
],
 
dtype='datetime64[ns]',
 
freq=None)

In
 
[37]:
 
ts
Out[37]:
 
2012
-05
-01
    
0.469112
2012
-05
-02
   
-0.282863
2012
-05
-03
   
-1.509059
dtype:
  
float64

In
 
[38]:
 
periods
 
=
 
[pd.Period('2012-01'),
 
pd.Period('2012-02'),
 
pd.Period('2012-03')]

In
 
[39]:
 
ts
 
=
 
pd.Series(np.random.randn(3),
 
periods)

In
 
[40]:
 
type(ts.index)
Out[40]:
 
pandas.core.indexes.period.PeriodIndex

In
 
[41]:
 
ts.index
Out[41]:
 
PeriodIndex(['2012-01',
 
'2012-02'
 
,
 
'2012-03'
],
 
dtype='period[M]',
 
freq='M')

In
 
[42]:
 
ts
Out[42]:
 
2012
-01
   
-1.135632
2012
-02
    
1.212112
2012
-03
   
-0.173215
Freq:
 
M,
 
dtype:
 
float64
/<code>

Pandas 可以識別這兩種表現形式，並在兩者之間進行轉化。Pandas 後臺用Timestamp 實例代表時間戳，用 DatetimeIndex 實例代表時間戳序列。pandas 用 Period 對象表示符合規律的時間段標量值，用 PeriodIndex 表示時間段序列。未來版本將支持用任意起止時間實現不規律時間間隔。

轉換時間戳

to_datetime 函數用於轉換字符串、紀元式及混合的日期 Series 或日期列表。轉換的是 Series 時，返回的是具有相同的索引的 Series，日期時間列表則會被轉換為 DatetimeIndex：

<code>
In
 
[43]
: 
pd
.to_datetime
(pd.Series([
'Jul 31, 2009'
, 
'2010-01-10'
, None]))
Out
[43]
: 
0
   
2009-07-31
1
   
2010-01-10
2
          
NaT
dtype
: 
datetime64
[ns]

In
  
[44]
: 
pd
.to_datetime
([
'2005/11/23'
, 
'2010.12.31'
])
Out
[44]
: 
DatetimeIndex
([
'2005-11-23'
, 
'2010-12-31'
], dtype=
'datetime64[ns]'
, freq=None)/<code>

解析歐式日期（日-月-年），要用 dayfirst 關鍵字參數：

<code>
In
 
[45]
: 
pd
.to_datetime
([
'04-01-2012 10:00'
], dayfirst=True)
Out
[45]
: 
DatetimeIndex
([
'2012-01-04 10:00:00'
], dtype=
'datetime64[ns]'
, freq=None)

In
  
[46]
: 
pd
.to_datetime
([
'14-01-2012'
, 
'01-14-2012'
], dayfirst=True)
Out
[46]
: 
DatetimeIndex
([
'2012-01-14'
, 
'2012-01-14'
], dtype=
'datetime64[ns]'
, freq=None)/<code>

警告：從上例可以看出，dayfirst 並沒有那麼嚴苛，如果不能把第一個數解析為日，就會以 dayfirst 為 False 進行解析。

to_datetime 轉換單個字符串時，返回的是單個 Timestamp。Timestamp 僅支持字符串輸入，不支持 dayfirst、format 等字符串解析選項，如果要使用這些選項，就要用 to_datetime。

<code>
In
 
[47]
: 
pd
.to_datetime
(
'2010/11/12'
)
Out 
[47]
: 
Timestamp
(
'2010-11-12 00:00:00'
)

In
 
[48]
: 
pd
.Timestamp
(
'2010/11/12'
)
Out
[48]
: 
Timestamp
(
'2010-11-12 00:00:00'
)/<code>

Pandas 還支持直接使用 DatetimeIndex 構建器：

<code>
In
 
[49]
: 
pd
.DatetimeIndex
([
'2018-01-01'
, 
'2018-01-03'
, 
'2018-01-05'
])
Out
[49]
: 
DatetimeIndex
([ 
'2018-01-01'
, 
'2018-01-03'
, 
'2018-01-05'
], dtype=
'datetime64[ns]'
, freq=None)/<code>

創建 DatetimeIndex 時，傳遞字符串 infer 即可推斷索引的頻率。

<code>
In
 
[50]
: 
pd
.DatetimeIndex
([
'2018-01-01'
, 
'2018-01-03'
, 
'2018-01-05'
], freq=
'infer'
)
Out
[50]
: 
DatetimeIndex
([
'2018-01-01'
, 
'2018-01-03'
, 
'2018-01-05'
], dtype=
'datetime64[ns]'
, freq=
'2D'
)/<code>

提供格式參數

要實現精準轉換，除了傳遞 datetime 字符串，還要指定 format 參數，指定此參數還可以加速轉換速度。

<code>
In
 
[51]
: 
pd
.to_datetime
(
'2010/11/12'
, format=
'%Y/%m/%d'
)
Out
[51]
: 
Timestamp
(
'2010-11-12 00:00:00'
)

In
 
[52]
: 
pd
.to_datetime
(
'12-11-2010 00:00'
, format=
'%d-%m-%Y %H:%M'
)
Out
[52]
: 
Timestamp
(
'2010-11-12 00:00:00'
)/<code>

要了解更多 format 選項，請參閱 Python 日期時間文檔。

用多列組合日期時間

0.18.1 版新增。

Pandas 還可以把 DataFrame 裡的整數或字符串列組合成 Timestamp Series。

<code>
In
 
[53]:
 
df
 
=
 
pd.DataFrame({'year':
 
[2015,
 
2016
],
   
....:
                    
'month'
:
 
[2,
 
3
],
   
....:
                    
'day'
:
 
[4,
 
5 
],
   
....:
                    
'hour'
:
 
[2,
 
3
]})
   
....:
 

In
 
[54]:
 
pd.to_datetime(df)
Out[54]:
 
0
   
2015
-02
-04
 
02
:00:00
1
   
2016
-03
-05
 
03
:00:00
dtype: 
 
datetime64[ns]
/<code>

只傳遞組合所需的列也可以。

<code>
In
 
[55]
: 
pd
.to_datetime
(
df
[[
'year'
, 
'month'
, 
'day'
]
])
Out
[55]
: 
0   2015
-02-04
1   2016
-03-05
dtype
: 
datetime64
[ns]
/<code>

pd.to_datetime 查找列名裡日期時間組件的標準名稱，包括：

• 必填：year、month、day
• 可選：hour、minute、second、millisecond、microsecond、nanosecond

無效數據

不可解析時，默認值 errors='raise' 會觸發錯誤：

<code>
In
 
[2]
: 
pd
.to_datetime
([
'2009/07/31'
, 
'asd'
], errors=
'raise'
)
ValueError
: 
Unknown
 
string
 
format
/<code>

errors='ignore' 返回原始輸入：

<code>
In
 
[56]
: 
pd
.to_datetime
([
'2009/07/31'
, 
'asd'
], errors=
'ignore' 
)
Out
[56]
: 
Index
([
'2009/07/31'
, 
'asd'
], dtype=
'object'
)/<code>

errors='coerce' 把無法解析的數據轉換為 NaT，即不是時間（Not a Time）：

<code>
In
 
[57]
: 
pd
.to_datetime
([
'2009/07/31'
, 
'asd'
], errors=
'coerce'
)
Out
[57]
: 
DatetimeIndex
([
'2009-07-31'
, 
'NaT'
], dtype=
'datetime64[ns]'
, freq=None)/<code>

紀元時間戳

pandas 支持把整數或浮點數紀元時間轉換為 Timestamp 與 DatetimeIndex。鑑於 Timestamp 對象內部存儲方式，這種轉換的默認單位是納秒。不過，一般都會用指定其它時間單位 unit 來存儲紀元數據，紀元時間從 origin 參數指定的時點開始計算。

<code>
In
 
[58]
: 
pd
.to_datetime
([
1349720105
, 
1349806505
, 
1349892905
,
   ....:                 
1349979305
, 
1350065705
], unit=
's'
)
   ....: 
Out
[58]
: 
DatetimeIndex
([
'2012-10-08 18:15:05'
, 
'2012-10-09 18:15:05'
,
               
'2012-10-10 18:15:05'
, 
'2012-10-11 18:15:05'
,
               
'2012-10-12 18:15:05'
],
              dtype=
'datetime64[ns]'
, freq=None)

In 
 
[59]
: 
pd
.to_datetime
([
1349720105100
, 
1349720105200
, 
1349720105300
,
   ....:                 
1349720105400
, 
1349720105500
], unit=
'ms'
)
   ....: 
Out
[59]
: 
DatetimeIndex
([
'2012-10-08 18:15:05.100000'
, 
'2012-10-08 18:15:05.200000'
,
               
'2012-10-08 18:15:05.300000'
, 
'2012-10-08 18:15:05.400000'
,
               
'2012-10-08 18:15:05.500000'
],
              dtype=
'datetime64[ns]'
, freq=None)/<code>

用帶 tz 參數的紀元時間戳創建 Timestamp 或 DatetimeIndex 時，要先把紀元時間戳轉化為 UTC，然後再把結果轉換為指定時區。不過這種操作方式現在已經廢棄了，對於其它時區 Wall Time 裡的紀元時間戳，建議先把紀元時間戳轉換為無時區時間戳，然後再把時區本地化。

<code>
In
 
[60]
: 
pd
.Timestamp
(
1262347200000000000
)
.tz_localize
(
'US/Pacific'
)
Out
[60]
: 
Timestamp
(
'2010-01-01 12:00:00-0800'
, tz=
'US/Pacific'
)

In
 
[61]
: 
pd
.DatetimeIndex
([
1262347200000000000
])
.tz_localize
(
'US/Pacific'
)
Out
[61]
: 
DatetimeIndex
([
'2010-01-01 12:00:00-08:00'
], dtype=
'datetime64[ns, US/Pacific]'
, freq=None)/<code>

注意：紀元時間取整到最近的納秒。

警告:Python 浮點數只精確到 15 位小數，因此，轉換浮點紀元時間可能會導致不精準或失控的結果。轉換過程中，免不了會對高精度 Timestamp 取整，只有用 int64 等定寬類型才有可能實現極其精準的效果。

In [62]: pd.to_datetime([1490195805.433, 1490195805.433502912], unit='s')
Out[62]: DatetimeIndex(['2017-03-22 15:16:45.433000088', '2017-03-22 >15:16:45.433502913'], dtype='datetime64[ns]', freq=None)
In [63]: pd.to_datetime(1490195805433502912, unit='ns')
Out[63]: Timestamp('2017-03-22 15:16:45.433502912')

參閱：應用 origin 參數

把時間戳轉換為紀元

反轉上述操作，把 Timestamp 轉換為 unix 紀元：

<code>
In
 [
64
]: stamps = pd.date_range(
'2012-10-08 18:15:05'
, periods=
4
, freq=
'D'
)

In [
65
]: stamps
Out[
65
]: 
DatetimeIndex([
'2012-10-08 18:15:05'
, 
'2012-10-09 18:15:05'
,
               
'2012-10-10 18:15:05'
,  
'2012-10-11 18:15:05'
],
              dtype=
'datetime64[ns]'
, freq=
'D'
)/<code>

首先與紀元開始時點（1970 年 1 月 1 日午夜，UTC）相減，然後以 1 秒為時間單位（unit='1s'）取底整除。

<code>
In
 
[66]
: (stamps - pd.Timestamp(
"1970-01-01"
))  
Out
[66]
: 
Int64Index
([
1349720105
, 
1349806505
, 
1349892905
, 
1349979305
], dtype=
'int64'
)/<code>

應用 `origin` 參數

0.20.0 版新增。

origin 參數可以指定 DatetimeIndex 的備選開始時點。例如，把1960-01-01作為開始日期：

<code>
In
  
[67]
: 
pd
.to_datetime
([
1
, 
2
, 
3
], unit=
'D'
, origin=pd.Timestamp(
'1960-01-01'
))
Out
[67]
: 
DatetimeIndex
([
'1960-01-02'
, 
'1960-01-03'
, 
'1960-01-04'
], dtype=
'datetime64[ns]'
, freq=None)/<code>

默認值為 origin='unix'，即 1970-01-01 00:00:00，一般把這個時點稱為 unix 紀元 或 POSIX 時間。

<code>
In
 
[68]
: 
pd
.to_datetime
([
1
, 
2
, 
3
], unit= 
'D'
)
Out
[68]
: 
DatetimeIndex
([
'1970-01-02'
, 
'1970-01-03'
, 
'1970-01-04'
], dtype=
'datetime64[ns]'
, freq=None)/<code>

生成時間戳範圍

DatetimeIndex、Index 構建器可以生成時間戳索引，此處要提供 datetime 對象列表。

<code>In [
69
]: dates = [datetime.datetime(
2012
, 
5
, 
1
),
   ....:          datetime.datetime(
2012
, 
5
, 
2
),
   ....:          datetime.datetime(
2012
, 
5
, 
3
)]
   ....: 

 
In [
70
]: 
index 
 = pd.DatetimeIndex(dates)

In [
71
]: 
index
Out[
71
]: DatetimeIndex([
'2012-05-01'
, 
'2012-05-02'
, 
'2012-05-03'
], dtype=
'datetime64[ns]'
, freq=None)

 
In [
72
]: 
index
 = pd.Index(dates)

In [
73
]: 
index
Out[
73
]: DatetimeIndex([
'2012-05-01'
, 
'2012-05-02'
, 
'2012-05-03'
], dtype=
'datetime64[ns]'
, freq=None)/<code>

實際工作中，經常要生成含大量時間戳的超長索引，一個個輸入時間戳又枯燥，又低效。如果時間戳是定頻的，用 date_range() 與 bdate_range() 函數即可創建DatetimeIndex。date_range 默認的頻率是日曆日，bdate_range 的默認頻率是工作日：

<code>In [74]: 
start
 = datetime.datetime( 
2011
, 
1
, 
1
)

In
 [
75
]: 
end
 = datetime.datetime(
2012
, 
1
, 
1
)

In
 [
76
]: 
index
 = pd.date_range(
start
, 
end
)

In
 [
77
]: 
index
Out
[
77
]: 
DatetimeIndex([
'2011-01-01'
, 
'2011-01-02'
, 
'2011-01-03'
, 
'2011-01-04'
,
               
'2011-01-05'
, 
'2011-01-06'
,  
'2011-01-07'
, 
'2011-01-08'
,
               
'2011-01-09'
, 
'2011-01-10'
,
               ...
               
'2011-12-23'
, 
'2011-12-24'
, 
'2011-12-25'
, 
'2011-12-26'
,
               
'2011-12-27'
, 
'2011-12-28'
, 
'2011-12-29'
, 
'2011-12-30'
,
               
'2011-12-31'
, 
'2012-01-01'
],
              dtype=
'datetime64[ns]'
, 
length
=
366
, freq=
'D'
)

In
 [
78
]: 
index
 = pd.bdate_range(
start
, 
end
)

In
 [
79
]:  
index
Out
[
79
]: 
DatetimeIndex([
'2011-01-03'
, 
'2011-01-04'
, 
'2011-01-05'
, 
'2011-01-06'
,
               
'2011-01-07'
, 
'2011-01-10'
, 
'2011-01-11'
, 
'2011-01-12'
,
               
'2011-01-13'
, 
'2011-01-14'
,
               ...
               
'2011-12-19'
, 
'2011-12-20'
, 
'2011-12-21'
, 
'2011-12-22'
,
               
'2011-12-23'
, 
'2011-12-26'
, 
'2011-12-27'
, 
'2011-12-28'
,
               
'2011-12-29'
, 
'2011-12-30'
],
              dtype=
'datetime64[ns]'
, 
length
= 
260
, freq=
'B'
)/<code>

date_range、bdate_range 等便捷函數可以調用各種頻率別名：

<code>
In
 
[80]
: 
pd
.date_range
(start, periods=
1000
, freq=
'M'
)
Out
[80]
: 
DatetimeIndex
([
'2011-01-31'
, 
'2011-02-28'
, 
'2011-03-31'
, 
'2011-04-30'
,
               
'2011-05-31'
, 
'2011-06-30'
, 
'2011-07-31'
, 
'2011-08-31'
,
               
'2011-09-30'
, 
'2011-10-31'
,
               ...
               
'2093-07-31'
, 
'2093-08-31' 
, 
'2093-09-30'
, 
'2093-10-31'
,
               
'2093-11-30'
, 
'2093-12-31'
, 
'2094-01-31'
, 
'2094-02-28'
,
               
'2094-03-31'
, 
'2094-04-30'
],
              dtype=
'datetime64[ns]'
, length=
1000
, freq=
'M'
)

In
 
[81]
: 
pd
.bdate_range
(start, periods=
250
, freq=
'BQS'
)
Out
[81]
: 
DatetimeIndex
([
'2011-01-03'
, 
'2011-04-01'
, 
'2011-07-01'
, 
'2011-10-03'
,
               
'2012-01-02' 
, 
'2012-04-02'
, 
'2012-07-02'
, 
'2012-10-01'
,
               
'2013-01-01'
, 
'2013-04-01'
,
               ...
               
'2071-01-01'
, 
'2071-04-01'
, 
'2071-07-01'
, 
'2071-10-01'
,
               
'2072-01-01'
, 
'2072-04-01'
, 
'2072-07-01'
, 
'2072-10-03'
,
               
'2073-01-02'
, 
'2073-04-03'
],
              dtype=
'datetime64[ns]'
, length=
250
, freq=
'BQS-JAN'
)/<code>

date_range 與 bdate_range 通過指定 start、end、period 與 freq 等參數，簡化了生成日期範圍這項工作。開始與結束日期是必填項，因此，不會生成指定範圍之外的日期。

<code>
In
 
[82]
:  
pd
.date_range
(start, end, freq=
'BM'
)
Out
[82]
: 
DatetimeIndex
([
'2011-01-31'
, 
'2011-02-28'
, 
'2011-03-31'
, 
'2011-04-29'
,
               
'2011-05-31'
, 
'2011-06-30'
, 
'2011-07-29'
, 
'2011-08-31'
,
               
'2011-09-30'
, 
'2011-10-31'
, 
'2011-11-30'
, 
'2011-12-30'
],
              dtype=
'datetime64[ns]'
, freq=
'BM'
)

In
 
[83]
: 
pd
.date_range
(start, end, freq=
'W'
)
 
Out
[83]
: 
DatetimeIndex
([
'2011-01-02'
, 
'2011-01-09'
, 
'2011-01-16'
, 
'2011-01-23'
,
               
'2011-01-30'
, 
'2011-02-06'
, 
'2011-02-13'
, 
'2011-02-20'
,
               
'2011-02-27'
, 
'2011-03-06'
, 
'2011-03-13'
, 
'2011-03-20'
,
               
'2011-03-27'
, 
'2011-04-03'
, 
'2011-04-10'
, 
'2011-04-17'
,
               
'2011-04-24'
, 
'2011-05-01'
, 
'2011-05-08'
, 
'2011-05-15'
,
               
'2011-05-22'
, 
'2011-05-29'
,  
'2011-06-05'
, 
'2011-06-12'
,
               
'2011-06-19'
, 
'2011-06-26'
, 
'2011-07-03'
, 
'2011-07-10'
,
               
'2011-07-17'
, 
'2011-07-24'
, 
'2011-07-31'
, 
'2011-08-07'
,
               
'2011-08-14'
, 
'2011-08-21'
, 
'2011-08-28'
, 
'2011-09-04'
,
               
'2011-09-11'
, 
'2011-09-18'
, 
'2011-09-25'
, 
'2011-10-02'
,
               
'2011-10-09'
, 
'2011-10-16'
, 
'2011-10-23'
, 
'2011-10-30'
,
               
'2011-11-06'
, 
'2011-11-13'
, 
'2011-11-20'
,  
'2011-11-27'
,
               
'2011-12-04'
, 
'2011-12-11'
, 
'2011-12-18'
, 
'2011-12-25'
,
               
'2012-01-01'
],
              dtype=
'datetime64[ns]'
, freq=
'W-SUN'
)

In
 
[84]
: 
pd
.bdate_range
(end=end, periods=
20
)
Out
[84]
: 
DatetimeIndex
([
'2011-12-05'
, 
'2011-12-06'
, 
'2011-12-07'
, 
'2011-12-08'
,
               
'2011-12-09'
, 
'2011-12-12'
, 
'2011-12-13'
, 
'2011-12-14'
,
               
'2011-12-15'
,  
'2011-12-16'
, 
'2011-12-19'
, 
'2011-12-20'
,
               
'2011-12-21'
, 
'2011-12-22'
, 
'2011-12-23'
, 
'2011-12-26'
,
               
'2011-12-27'
, 
'2011-12-28'
, 
'2011-12-29'
, 
'2011-12-30'
],
              dtype=
'datetime64[ns]'
, freq=
'B'
)

In
 
[85]
: 
pd
.bdate_range
(start=start, periods=
20
)
Out
[85]
: 
DatetimeIndex
([
'2011-01-03'
, 
'2011-01-04'
, 
'2011-01-05'
, 
'2011-01-06'
,
                
'2011-01-07'
, 
'2011-01-10'
, 
'2011-01-11'
, 
'2011-01-12'
,
               
'2011-01-13'
, 
'2011-01-14'
, 
'2011-01-17'
, 
'2011-01-18'
,
               
'2011-01-19'
, 
'2011-01-20'
, 
'2011-01-21'
, 
'2011-01-24'
,
               
'2011-01-25'
, 
'2011-01-26'
, 
'2011-01-27'
, 
'2011-01-28'
],
              dtype=
'datetime64[ns]'
, freq=
'B'
)/<code>

0.23.0 版新增。

指定 start、end、periods 即可生成從 start 開始至 end 結束的等距日期範圍，這個日期範圍包含了 start 與 end，生成的 DatetimeIndex 裡的元素數量為 periods 的值。

<code>
In
 
[86] 
: 
pd
.date_range
(
'2018-01-01'
, 
'2018-01-05'
, periods=
5
)
Out
[86]
: 
DatetimeIndex
([
'2018-01-01'
, 
'2018-01-02'
, 
'2018-01-03'
, 
'2018-01-04'
,
               
'2018-01-05'
],
              dtype=
'datetime64[ns]'
, freq=None)

In
 
[87]
: 
pd
.date_range
(
'2018-01-01'
, 
'2018-01-05'
, periods=
10
)
Out
[87]
: 
DatetimeIndex
([
'2018-01-01 00:00:00' 
, 
'2018-01-01 10:40:00'
,
               
'2018-01-01 21:20:00'
, 
'2018-01-02 08:00:00'
,
               
'2018-01-02 18:40:00'
, 
'2018-01-03 05:20:00'
,
               
'2018-01-03 16:00:00'
, 
'2018-01-04 02:40:00'
,
               
'2018-01-04 13:20:00'
, 
'2018-01-05 00:00:00'
],
              dtype=
'datetime64[ns]'
, freq=None)/<code>

自定義頻率範圍

設定 weekmask 與 holidays 參數，bdate_range 還可以生成自定義頻率日期範圍。這些參數只用於傳遞自定義字符串。

<code>In [88]: weekmask = 'Mon Wed Fri'

In [89]: holidays = [datetime.datetime(2011, 1, 5), datetime.datetime(2011, 3, 14)]

In [90]: pd.bdate_range(
start
, 
end
, freq=
'C'
, weekmask=weekmask, holidays=holidays)
Out
[
90
]: 
DatetimeIndex([
'2011-01-03'
, 
'2011-01-07'
, 
'2011-01-10'
, 
'2011-01-12' 
,
               
'2011-01-14'
, 
'2011-01-17'
, 
'2011-01-19'
, 
'2011-01-21'
,
               
'2011-01-24'
, 
'2011-01-26'
,
               ...
               
'2011-12-09'
, 
'2011-12-12'
, 
'2011-12-14'
, 
'2011-12-16'
,
               
'2011-12-19'
, 
'2011-12-21'
, 
'2011-12-23'
, 
'2011-12-26'
,
               
'2011-12-28'
, 
'2011-12-30'
],
              dtype=
'datetime64[ns]'
, 
length
=
154
, freq=
'C'
)

In
 [
91
]: pd.bdate_range(
start
, 
end
, freq=
'CBMS' 
, weekmask=weekmask)
Out
[
91
]: 
DatetimeIndex([
'2011-01-03'
, 
'2011-02-02'
, 
'2011-03-02'
, 
'2011-04-01'
,
               
'2011-05-02'
, 
'2011-06-01'
, 
'2011-07-01'
, 
'2011-08-01'
,
               
'2011-09-02'
, 
'2011-10-03'
, 
'2011-11-02'
, 
'2011-12-02'
],
              dtype=
'datetime64[ns]'
, freq=
'CBMS'
)/<code>

參閱：自定義工作日

時間戳的界限

Pandas 時間戳的最低單位為納秒，64 位整數顯示的時間跨度約為 584 年，這就是Timestamp 的界限：

<code>
In
 
[92] 
: 
pd
.Timestamp
.min
Out
[92]
: 
Timestamp
(
'1677-09-21 00:12:43.145225'
)

In
 
[93]
: 
pd
.Timestamp
.max
Out
[93]
: 
Timestamp
('
2262
-
04
-
11
 
23
:
47
:
16.85477580
/<code>

好吧，夥伴們，我知道你們都會了，畢竟你們都是如此聰慧！

更多的python相關學習教程也會繼續更新，有給大家整理全套的python教程和人工智能

全套視頻教程，夥伴們有要學的，評論留言回覆：python/人工智能，即可領取！