詳解Python常用標準庫之時間模組time和datetime

2022-05-27 18:05:51

time -- 獲取本地時間戳
localtime -- 獲取本地時間元組（UTC）
gmtime -- 獲取時間元組（GMT）
mktime -- 時間元組獲取時間戳
ctime -- 獲取時間字串
asctime -- 時間元組獲取時間字串
strftime -- 格式化時間
strptime -- 格式化時間
sleep -- 時間睡眠
perf_counter -- 時間計時
模擬進度條
程式計時
時間轉換示意圖

datetime時間模組

date類
time類
datetime類
timedelta類

time時間模組

import time

time -- 獲取本地時間戳

時間戳又被稱之為是Unix時間戳，原本是在Unix系統中的計時工具。

它的含義是從1970年1月1日（UTC/GMT的午夜）開始所經過的秒數，不考慮閏秒。UNIX時間戳的 0 按照ISO 8601規範為：1970-01-01T00:00:00Z。

比如：

時間戳 60 表示 1970-01-01T00:01:00Z
時間戳 120 表示 1970-01-01T00:02:00Z
時間戳 3600 表示 1970-01-01T01:00:00Z

小知識：最開始的時候，時間戳的開始年份是1971年，那個時候Unix系統和C語言剛剛誕生，所以時間戳0也就是Unix系統和C語言的生日。那時候的時間位數只有32位元，而且每秒中有60個數位，發現只要兩年多的時間時間戳就能完成一個輪迴，十分的不方便！所以後來的一系列改革，將時間戳的數值改為每秒1個數位，還有一些新的系統可以將時間戳的位數增大，可以讓時間戳的輪迴擴充套件到一百多年，再後來為了方便人們記憶，將時間戳的起始年份定位1970年整。

import time

stamp_time = time.time()
print(stamp_time)  # 1635768368.2838552

localtime -- 獲取本地時間元組（UTC）

引數為時間戳，預設為本地時間戳，獲取時間元組。

時間元組是python中的一個特殊的資料型別type: time.struct_time，但是它和tuple的特性是相同的。

import time

# 時間元組中的值分別表示：
	# tm_year: 年
	# tm_mon: 月
	# tm_mday: 日
	# tm_hour: 時
	# tm_min: 分
	# tm_sec: 秒
	# tm_wday: 周幾（0表示星期一）
	# tm_yday: 一年中的第幾天（從1開始）
	# tm_isdst: 夏令標識（1夏令時、0非夏令時、-1未知）

# 預設當前時間
time_tuple = time.localtime()
print(time_tuple)
# time.struct_time(tm_year=2021, tm_mon=11, tm_mday=1, tm_hour=20, tm_min=7, tm_sec=50, tm_wday=0, tm_yday=305, tm_isdst=0)

# 指定時間戳
time_tuple = time.localtime(3600)
print(time_tuple)
# time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=9, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

有大問題啦！！！

時間戳的起始時間是1970-1-1 0:0:0，這個時候的時間戳是0，那麼時間戳3600就是整整一個小時之後，那麼時間就應該是1970-1-1 0:1:0 才對的呀！怎麼上面的3600確實9點鐘了呢？怎麼起始時間變成了8點了呢？

然後你發現你在中國，時間是北京時間，北京在東八區時區，嘶，怎麼正好也是個八？

是這樣的，按照道理來說的話全世界任何一個地方的時間戳所代表的時間都應該是一樣的，而且時間戳的起始時間確實是 1970-1-1 0:0:0 ，但是這個時間是位於英國的一個叫做格林威治的小鎮的，格林威治有一個天文臺叫做皇家格林尼治天文臺，後來國際上將這個地方的經線作為本初子午線，作為時間計算時間和地理精度的起點。那麼，有時區的存在打破了這個可能，我們在中國，所有的裝置都是按照中國的時區編碼的，中國位於東八區，在時間上比英國快八個小時，所以我們中國的本地時間戳就是 1970-1-1 8:00:00。

gmtime -- 獲取時間元組（GMT）

在不知道這個函數的時候，我就很好奇為什麼localtime的初始時間比格林威治時間要快8小時，現在就明白了：

函數	描述
gmtime	獲取時間元組（GMT格林威治時間）
localtime	獲取時間元組（UTC協調世界時）

mktime -- 時間元組獲取時間戳

注意：

引數必須是時間元組time.struct_time 或者元組 tuple 型別；
元組中的元素一個也不能少，必須九個元素都存在；
得到的時間戳只收到前六個值的影響，即：年月日時分秒；
時間元組中的時間表示，最小時間不能低於當地的最小時間戳；
時間元組中的時間表示，單位可以超出原本的範圍，比如秒滿60進1，我們將秒寫成100，系統也不會報錯，但是時間上會自動的將多出的時間進位。但是數位也不能過大，因為資料型別的大小是有極限的。
mktime返回的數值是浮點型的，但是精度只能到1；

import time

# 在中國的最小時間單位
tst = (1970, 1, 1, 8, 0, 0, 0, 0, 0)
time_stamp = time.mktime(tst)
print(time_stamp)  # 0.0

ctime -- 獲取時間字串

引數預設為本地時間戳，獲取的資料型別是 str，這個時間字串不像時間元組是一個單獨的資料型別。

import time

# 時間字串中的含義是：
	# Mon Nov  1 21:34:39 2021
    # 星期 月   日 時 分 秒  年

# 預設為本地時間戳
time_char = time.ctime()
print(time_char)  # Mon Nov  1 21:34:39 2021

# 指定時間戳
time_char = time.ctime(0)
print(time_char)  # Thu Jan  1 08:00:00 1970

asctime -- 時間元組獲取時間字串

注意，asctime有弊端，看下例：

import time

tst = (1970, 1, 1, 8, 24, 61, 1, 0, 0)
time_char = time.asctime(tst)
print(time_char)  # Tue Jan  1 08:24:61 1970

tst = (1970, 1, 1, 8, 24, 61, 2, 0, 0)
time_char = time.asctime(tst)
print(time_char)  # Tue Jan  1 08:24:61 1970

看上面的例子，時間元組變成時間字串的時候，會將星期的資料也讀取到，但是卻不會分辨資料是否正確，所以asctime並不常用。

如果要將一個不確定正確性的時間元組變成時間字串的話，先通過 mktime 獲取時間戳（mktime可以分辨出正確的時間資訊），然後在將時間戳通過 ctime 變成時間字串。

strftime -- 格式化時間

格式化時間，按照指定的格式（一段格式化字串，就像字串的格式化一樣）將時間元組變成時間字串。

我們先來學習一下時間預留位置的含義是什麼：

注意！！！這些預留位置的大小寫的含義是不同的：

預留位置	含義
%Y	以十進位制數位表示以世紀為單位的年份（四位數）
%y	以十進位制數位表示年份（兩位數）
%m	以十進位制數位表示月份
%D	以月/日/年(兩位數)的格式表示年月日
%d	以十進位制數位表示日期
%H	以十進位制數位表示二十四小時制的時
%M	以十進位制數位表示分鐘
%S	以十進位制數位表示秒
%z	與UTC的時區偏移
%a	區域設定的縮寫工作日名稱
%A	區域設定的完整工作日名稱
%b	區域設定的縮寫月份名稱
%B	區域設定的完整月份名稱
%c	語言環境的適當日期和時間表示
%I	以十進位制數表示十二小時制的時（大寫 ‘愛’）
%p	語言環境的等效值：AM 或者 PM

現在根據使用時間預留位置用字串格式化將時間元組變成字串。

import time

# 注意，如果格式化字串中出現中文字元，只能在linux系統下執行，windows下不能解析，直接報錯。

tst = (1970, 1, 1, 8, 0, 0, 0, 0, 0)
time_tuple = time.strftime('%Y-%m-%d-%H-%m-%S',tst)
print(time_tuple)  # 1970-01-01-08-01-00

# 有中文在windows下報錯
tst = (1970, 1, 1, 8, 0, 0, 0, 0, 0)
time_tuple = time.strftime('%Y-%m哈哈-%d-%H-%m-%S',tst)
print(time_tuple)  # 1970-01-01-08-01-00

strptime -- 格式化時間

格式化時間，通過格式化字串將一個字串中的時間變成時間元組。

import time

# 格式化字串要和原字串一模一樣，只是將需要提出的部分使用預留位置替換
char = '2000年10月30日一個偉大的中國少年在三晉大地誕生了'
format_char = '%Y年%m月%d日一個偉大的中國少年在三晉大地誕生了'

tst = time.strptime(char, format_char)
print(tst)

sleep -- 時間睡眠

等待指定秒數的時間：

import time

print('開始睡覺')
time.sleep(2)
print('睡了兩秒鐘，神清氣爽')

perf_counter -- 時間計時

用於計算程式執行的時間

import time

# perf_counter 用於計算程式執行的時間

# 記錄開始時間
start_time = time.perf_counter()

# 程式執行
for i in range(10000):
    pass

# 記錄時間
end_time = time.perf_counter()

# windows系統直接拿到第二次的值就可以了，不用減去第一次的值也行
print(end_time, '秒')  # 0.0003918 秒
print(end_time - start_time, '秒')  # 0.0003916 秒

如果使用多次perf_counter()函數，直接輸出其的值是距第一次使用的時間長度：

import time

time1 = time.perf_counter()
time.sleep(1)
time2 = time.perf_counter()
print(time2)

time.sleep(2)
time3 = time.perf_counter()
print(time3)

time.sleep(3)
time4 = time.perf_counter()
print(time4)

"""
結果：
1.0002558
3.0048941
6.019172
"""

注意：windows系統下使用perf_counter()函數可以直接輸出耗時長度，每次的耗時預設都是距離第一次使用perf_counter()函數的時間長度；如果在linux系統下使用perf_counter()函數則必須要使用第二次的結果減去之前的結果，因為在linux系統中perf_counter()函數的值和time()函數的值都是一樣的，那就是返回一個時間戳。

使用time.time()計算時間

import time

# perf_counter 用於計算程式執行的時間

# 記錄開始時間
start_time = time.time()

# 程式執行
for i in range(10000):
    pass

# 記錄時間
end_time = time.time()

print(end_time - start_time, '秒')  # 0.001001119613647461 秒

耗時短的計時推薦使用pref_counter，耗時長的推薦使用time。

模擬進度條

# 1、定義進度條樣式
print('[%-50s]' % ('###########'))
print('[%-50s]' % ('###################'))
print('[%-50s]' % ('###########################'))
print('[%-50s]' % ('####################################'))
print('[%-50s]' % ('########################################'))

# 2、讓進度條動起來
import time

progress_char = ''
for i in range(50):
    progress_char += '#'
    time.sleep(0.05)  # 延時看起來不是很快
    # end使不能換行，r使進度條不斷重新整理，保持在同一行顯示；
    print('r[%-50s]' % (progress_char), end='')
print('n')

# 3、根據檔案的大小調整進度條的進度
import time

def progress(percent):
    """控制進度條的顯示
    引數是下載的百分比，用來控制進度條的進展
    """
    # 如果百分比超過了1，說明資料已經接受完畢
    if percent > 1:
        percent = 1

    # 列印對應的進度條效果
    char = '#' * int(percent * 50)
    print('r[%-50s]%d%%' % (char, int(percent * 100)), end='')


# 已下的大小
rec_size = 0

# 下載檔案的大小
total_size = 102400

# 模擬下載過程
while rec_size < total_size:
    rec_size += 10240  # 下載速度
    time.sleep(0.05)  # 模擬網路延遲
    percent = rec_size / total_size  # 計算下載的進度（百分比）
    # 呼叫進度條
    progress(percent)

程式計時

在學習了perf_counter計時後，我們知道有很多種方法可以用於計時：

1.time函數：返回當前時間戳，使用time函數計時是獲取兩個節點各自的時間戳，然後計算其之間的差值，即為耗時時長。

優點：計算的是真實世界中的時間長度，而且計時本身不消耗計算機資源，計算長時間的程式優勢較大；
缺點：time函數的時間獲取來源於計算機本身的時間，如果在計時途中計算機的時間發生變化，比如人為的調快一小時，那麼計時就會比正確的時間慢一個小時的時間。

2.perf_counter函數：是time模組中專門用於效能計時的函數，具有高解析度的時鐘，已測量短持續的時間。

優點：是專門用於效能計時的函數，精確度高，適合計算耗時短的程式；
缺點：專門用於計時的函數，計時本身就會消耗計算機資源，所以計時過長難免會有一定的影響；

3.process_time函數：用於評測處理時間，計算核心和使用者空間CPU時間之和，這個時間不包含程式阻塞的時間，比如time.sleep()、input()等。

優點：專門用於計算程式本身內在的時間消耗，排除外來因素、提升系統本身效率、優化程式使用；

import time


def loop():
    time.sleep(1)
    input('請輸入：')  # 這個位置人為數三秒回車執行
    num = 10 ** 8
    for _ in range(num):
        pass
    time.sleep(1)


# time.time
start_time = time.time()
loop()
end_time = time.time()
print(start_time)  # 1640270620.4077902
print(end_time)  # 1640270628.1165576
print(end_time - start_time)  # 7.708767414093018

# time.perf_counter
start_time = time.perf_counter()
loop()
end_time = time.perf_counter()
print(start_time)  # 3e-07
print(end_time)  # 7.823952
print(end_time - start_time)  # 7.8239517

# time.process_time
start_time = time.process_time()
loop()
end_time = time.process_time()
print(start_time)  # 3.234375
print(end_time)  # 4.8125
print(end_time - start_time)  # 1.578125

除此之外，python3.7之後，新增了精確到納秒的函數:

time.time_ns()
time.perf_counter_ns()
time.process_time_ns()

還有標準庫timeit用於程式的效能計時。

時間轉換示意圖

在上述的幾種型別中存在時間轉換的問題，詳情和之間的關係可以參考下圖：

datetime時間模組

import datatime

datatime模組重新封裝了time模組，提供更多的介面。

date類

date類專門用於描述日期，範例化物件時必須填入引數，分別表示：年、月、日，返回datetime.date物件。

datetime.date(year, month, day)

from datetime import date

date_o = date(2022, 3, 1)

print(date_o)
print(type(date_o))

"""
結果：
2022-03-01
<class 'datetime.date'>
"""

常用屬性

屬性	作用
year	date物件表示的具體年份（範例化物件呼叫達到效果）；
month	date物件表示的具體月份（範例化物件呼叫達到效果）；
day	date物件表示的具體日（範例化物件呼叫達到效果）；
max	date類能夠表示的最大日期；
min	date類能夠表示的最小日期；
resolution	date類能夠表示的最小單位；

常用方法

注意，以下方法如果可以返回新的物件，使用物件呼叫時，返回新的物件，原物件不變；如果根據物件值返回對應的值，則使用類呼叫達不到目標效果；

方法	作用
today()	返回本地日期物件；
fromtimestamp(time_stamp)	給定時間戳返回日期物件；
replace(y, m, d)	給定年月日返回日期物件；
timetuple()	返回本地當前時間元組time.struct_time物件;
weekday()	返回星期序號，星期一返回0；
isoweekday()	返回星期序號，星期一返回1；
isocalendar()	返回元組，表示日期的年份、第幾周、第幾周之後的第幾天；
isoformat()	返回時間字串；
strftime()	格式化日期，參考time.strftime()；

time類

time類是datetime模組中專門用於描述時間的類，四個引數：hour、minute、second、microsecond預設都為0。

datetime.time(hour=0, minute=0, second=0, microsecond=0)

from datetime import time

time_0 = time()

print(time_0)
print(type(time_0))

"""
結果：
00:00:00
<class 'datetime.time'>
"""

time的屬性和date類的屬性方法基本相同，可以參考使用；

datetime類

相同於date和time兩個類的結合，使用基本相同；

timedelta類

timedelta類用於時間運算，類的引數有datetime模組支援的所有時間單位，使用其它的時間和日期物件可以和timedelta物件進行時間加減運算，注意在範例化時使用關鍵字傳參；

from datetime import datetime
from datetime import timedelta

# 日期物件
datetime_o = datetime(2000, 10, 30, 14, 40, 6)
print(datetime_o)

# ## 假設我們要計算這個時間5天4小時23分6秒之後的時間

# 範例化 5天4小時23分6秒 的timedelta物件
timedelta_o = timedelta(days=5, hours=4, minutes=23, seconds=6)

# 將時間物件和timedelta物件相加
datetime_o += timedelta_o
print(datetime_o)

"""
結果：
2000-10-30 14:40:06
2000-11-04 19:03:12
"""

到此這篇關於詳解Python常用標準庫之時間模組time和datetime的文章就介紹到這了,更多相關Python time datetime內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！