您现在的位置：程式師世界 >> 編程語言 > >> 更多編程語言 >> Python

go time,python time,datetime

編輯：Python

時間格式

GMT:

格林尼治標准時間

UTC:

協調世界時，又稱世界統一時間、世界標准時間、國際協調時間。

協調世界時是以原子時秒長為基礎，在時刻上盡量接近於世界時的一種時間計量系統。

CST:

CST可視為美國、澳大利亞、古巴或中國的標准時間。

CST可以為如下4個不同的時區的縮寫：

美國中部時間：Central Standard Time (USA) UT-6:00
澳大利亞中部時間：Central Standard Time (Australia) UT+9:30
中國標准時間：China Standard Time UT+8:00
古巴標准時間：Cuba Standard Time UT-4:00

ISO:

是一種時間的表示方法，國際標准化組織的國際標准ISO 8601是日期和時間的表示方法，全稱為《數據存儲和交換形式·信息交換·日期和時間的表示方法》。

說明

UTC+08 就是中國的時間。

python的時間

time

def asctime(p_tuple=None)->string

轉換一個時間元組為字符串, 例如，返回’Sat Jun 06 16:26:11 1998’.

def ctime(seconds=None)->string

時間戳轉化為表示本地時間的字符串，例如，返回’Sat Jun 06 16:26:11 1998’.

def gmtime(seconds=None)->struct_time

時間戳轉化為utc時間結構體，例如

def localtime(seconds=None)->struct_time

時間戳轉化為本地時間結構體

def mktime(struct_time)->second

將struct_time轉為時間戳（秒）

def strftime(format, p_tuple=None)

格式化時間元組或時間結構體為字符串

import time
print(time.strftime("%Y-%m-%S",time.localtime()))
# 2022-06-24

strptime(string, format) -> struct_time

將時間字符串轉化為時間結構體

import time
print(time.strptime("2022-06-24","%Y-%m-%S"))
# time.struct_time(tm_year=2022, tm_mon=6, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=24, tm_wday=2, tm_yday=152, tm_isdst=-1)

def time(),def time_ns()

秒，毫秒，微秒，納秒，進制1k，不再贅述

datetime

datetime庫是time庫的擴展

datetime.date：日期表示類，可以表示年月日等。
datetime.time：時間表示類，可以以時分秒毫秒表示。
datetime.datetime：日期時間有關的類，功能覆蓋date和time類。
datetime.timedelta：有時間間隔有關的類。
datetime.tzinfo：與時區相關的信息表示類。

datetime.datetime類

常用屬性：

.min：返回datetime最小時間對象。
.max：返回datetime最大時間對象。
.year：datetime對象的年屬性值。
.month：datetime對象的月屬性值。
.day：datetime對象的日屬性值。
.hour：datetime對象的時屬性值。
.minute：datetime對象的分屬性值。
.second：datetime對象的屬性值。秒
.microsecond：datetime對象的微秒屬性值。

創建對象：

datetime.datetime.now()：將時間戳轉化為datetime對象，默認時間戳為time.time()
datetime.datetime.utcnow()：同上，轉為utc
datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0)：指定年月日創建datetime對象
datetime.fromtimestamp(timestamp, tz=None)將一個時間戳轉化為一個datetime對象
utcfromtimestamp(timestamp)將utc時間戳轉化為對象

常用方法：

isoformat()：采用ISO 0861標准顯示時間，並返回字符串。
isoweekday：根據日期計算星期並返回（1-7，整型）。
strftime(format)：根據格式化字符串format進行格式化顯示，並返回字符串
isocalendar()：返回（year,第幾周，周幾)
utcnow()：返回utc時間的datetime對象
time()：返回datetime對象對應的時間
date()：返回datetime對象對應的日期
datetime.strptime(cls, date_string, format)：類方法，將字符串格式化為datetime對象
timetuple()：將datetime對象變成時間元組
astimezone(self, tz=None)根據指定的時區參數 tz 返回一個 DateTime 實例
timetz()返回一個time對象，包含datetime對象的時間部分，含tzinfo

import datetime
# 2022-06-20 14:55:31.718297
print(datetime.datetime.utcnow())
# 2022-06-20 22:55:31.718297
print(datetime.datetime.now())
----------------------------------------
now = datetime.datetime.now()
utc_now = datetime.datetime.utcnow()
# 2022-06-20T22:59:11.174310
print(now.isoformat())
---------------------------------------
# 1
print(now.isoweekday())
----------------------------------------
# (2022, 25, 1)
print(now.isocalendar())
---------------------------------------
# 23:04:30.648577
print(now.time())
# 2022-06-20
print(now.date())
---------------------------------------
# 2022
print(now.strftime("%Y"))
--------------------------------------
# time.struct_time(tm_year=2022, tm_mon=6, tm_mday=20, tm_hour=23, tm_min=8, tm_sec=2, tm_wday=0, tm_yday=171, tm_isdst=-1)
print(now.timetuple())
-----------------------------------------
# 2022-06-20 23:09:02.547208+08:00
print(now.astimezone())
----------------------------------------
# 23:22:47.514078
print(now.timetz())

datetime.date類

方法，屬性與datetime.datetime相同

datetime.time類

一般不用

datetime.timedelta類

允許對時間加減了

import datetime
now = datetime.datetime.now()
# 2022-06-20 23:16:56.884229
print(now)
live = now + datetime.timedelta(seconds=10)
# 2022-06-20 23:17:06.884229
print(live)
# False
var = now > live
print(var)

datetime.tzinfo類

timezone類繼承與基類tzinfo，它的每個實例都表示一個由UTC的固定偏移量定義的時區。

from datetime import datetime, timezone, timedelta
tz1 = timezone(timedelta(hours=3), name='East 3')
dt = datetime(2019, 11, 21, 15, 12, 52, tzinfo = tz1)
# dt = datetime.datetime(2019, 11, 21, 15, 12, 52, tzinfo=datetime.timezone(datetime.timedelta(seconds=10800), 'East 3'))
dt.tzname()
# 'East 3'
timezone.utc
# datetime.timezone.utc

go的時間

time包提供了時間的顯示和測量用的函數。日歷的計算采用的是公歷。

時間類型

time.Time類型表示時間。

func timeDemo() {

now := time.Now() //獲取當前時間
fmt.Printf("current time:%v\n", now)
year := now.Year() //年
month := now.Month() //月
day := now.Day() //日
hour := now.Hour() //小時
minute := now.Minute() //分鐘
second := now.Second() //秒
fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

時間戳

時間戳是自1970年1月1日（08:00:00GMT）至當前時間的總毫秒數。它也被稱為Unix時間戳（UnixTimestamp）。

func timestampDemo() {

now := time.Now() //獲取當前時間
timestamp1 := now.Unix() //時間戳
timestamp2 := now.UnixNano() //納秒時間戳
fmt.Printf("current timestamp1:%v\n", timestamp1)
fmt.Printf("current timestamp2:%v\n", timestamp2)
}

使用time.Unix()函數可以將時間戳轉為時間格式。

func timestampDemo2(timestamp int64) {

timeObj := time.Unix(timestamp, 0) //將時間戳轉為時間格式
fmt.Println(timeObj)
year := timeObj.Year() //年
month := timeObj.Month() //月
day := timeObj.Day() //日
hour := timeObj.Hour() //小時
minute := timeObj.Minute() //分鐘
second := timeObj.Second() //秒
fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

舉例

func main(){

now:=time.Now().Unix()
// 1655739004
fmt.Println(now)
timeObj:=time.Unix(now,0)
// 2022-06-20 23:30:04 +0800 CST
fmt.Println(timeObj)
}

時間間隔

time.Duration是time包定義的一個類型，它代表兩個時間點之間經過的時間，以納秒為單位。time.Duration表示一段時間間隔，可表示的最長時間段大約290年。

const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)

時區

Go 語言中使用 location 來映射具體的時區。時區（Time Zone）是根據世界各國家與地區不同的經度而劃分的時間定義，全球共分為24個時區。中國差不多跨5個時區，但為了使用方便只用東八時區的標准時即北京時間為准。

// timezoneDemo 時區示例
func timezoneDemo() {

// 中國沒有夏令時，使用一個固定的8小時的UTC時差。
// 對於很多其他國家需要考慮夏令時。
secondsEastOfUTC := int((8 * time.Hour).Seconds())
// FixedZone 返回始終使用給定區域名稱和偏移量(UTC 以東秒)的 Location。
beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)
// 如果當前系統有時區數據庫，則可以加載一個位置得到對應的時區
// 加載紐約所在的時區
newYork, err := time.LoadLocation("America/New_York") // UTC-05:00
// 加載上海所在的時區
shanghai, err := time.LoadLocation("Asia/Shanghai") // UTC+08:00
// 加載東京所在的時區
tokyo, err := time.LoadLocation("Asia/Tokyo") // UTC+09:00
// 創建時間對象需要指定位置。常用的位置是 time.Local（當地時間） 和 time.UTC（UTC時間）。
timeInLocal := time.Date(2009, 1, 1, 20, 0, 0, 0, time.Local)
timeInUTC := time.Date(2009, 1, 1, 12, 0, 0, 0, time.UTC)
sameTimeInBeijing := time.Date(2009, 1, 1, 20, 0, 0, 0, beijing)
sameTimeInNewYork := time.Date(2009, 1, 1, 7, 0, 0, 0, newYork)
// 北京時間（東八區）比UTC早8小時，所以上面兩個時間看似差了8小時，但表示的是同一個時間
timesAreEqual := timeInUTC.Equal(sameTimeInBeijing)
// true
fmt.Println(timesAreEqual)
// 紐約（西五區）比UTC晚5小時，所以上面兩個時間看似差了5小時，但表示的是同一個時間
timesAreEqual = timeInUTC.Equal(sameTimeInNewYork)
// true
fmt.Println(timesAreEqual)
}

時間操作

加

func main() {

now := time.Now()
later := now.Add(time.Hour) // 當前時間加1小時後的時間
fmt.Println(later)
}

減

func (t Time) Sub(u Time) Duration

是否相等

判斷兩個時間是否相同，會考慮時區的影響，因此不同時區標准的時間也可以正確比較。
本方法和用t==u不同，這種方法還會比較地點和時區信息。

 func (t Time) Equal(u Time) bool

是否在前

 func (t Time) Before(u Time) bool

是否在後

func (t Time) After(u Time) bool

定時器

After函數

返回一個time.C管道，time.Duration後會在此管道中放入一個時間點

func After(d Duration) <-chan Time {

return NewTimer(d).C
}

Tick函數

func Tick(d Duration) <-chan Time {

if d <= 0 {

return nil
}
return NewTicker(d).C
}
func tickDemo() {

ticker := time.Tick(time.Second) //定義一個1秒間隔的定時器
for i := range ticker {

fmt.Println(i)//每秒都會執行的任務
}
}

NewTimer()

計時器NewTimer是等待多長時間觸發的，只觸發一次

func NewTimer(d Duration) *Timer {

c := make(chan Time, 1)
t := &Timer{

C: c,
r: runtimeTimer{

when: when(d),
f: sendTime,
arg: c,
},
}
startTimer(&t.r)
return t
}

NewTicker()

定時器NewTicker是設定每隔多長時間觸發的，是連續觸發。
ticker只要定義完成，從此刻開始計時，不需要任何其他的操作，每隔固定時間都會觸發。

func NewTicker(d Duration) *Ticker {

if d <= 0 {

panic(errors.New("non-positive interval for NewTicker"))
}
c := make(chan Time, 1)
t := &Ticker{

C: c,
r: runtimeTimer{

when: when(d),
period: int64(d),
f: sendTime,
arg: c,
},
}
startTimer(&t.r)
return t
}

AfterFunc

等待時間函數AfterFunc是在After基礎上加了一個回調函數

time.AfterFunc(time.Second*1, F)

時間格式化

time.Format函數能夠將一個時間對象格式化輸出為指定布局的文本表示形式，需要注意的是 Go 語言中時間格式化的布局不是常見的Y-m-d H:M:S，而是使用 2006-01-02 15:04:05.000（記憶口訣為2006 1 2 3 4 5）。

// formatDemo 時間格式化
func formatDemo() {

now := time.Now()
// 格式化的模板為 2006-01-02 15:04:05
// 24小時制
fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))
// 12小時制
fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))
// 小數點後寫0，因為有3個0所以格式化輸出的結果也保留3位小數
fmt.Println(now.Format("2006/01/02 15:04:05.000")) // 2022/02/27 00:10:42.960
// 小數點後寫9，會省略末尾可能出現的0
fmt.Println(now.Format("2006/01/02 15:04:05.999")) // 2022/02/27 00:10:42.96
// 只格式化時分秒部分
fmt.Println(now.Format("15:04:05"))
// 只格式化日期部分
fmt.Println(now.Format("2006.01.02"))
}

解析字符串格式的時間

對於從文本的時間表示中解析出時間對象，time包中提供了time.Parse和time.ParseInLocation兩個函數。

其中time.Parse在解析時不需要額外指定時區信息。

// parseDemo 指定時區解析時間
func parseDemo() {

// 在沒有時區指示符的情況下，time.Parse 返回UTC時間
timeObj, err := time.Parse("2006/01/02 15:04:05", "2022/10/05 11:25:20")
if err != nil {

fmt.Println(err)
return
}
fmt.Println(timeObj) // 2022-10-05 11:25:20 +0000 UTC
// 在有時區指示符的情況下，time.Parse 返回對應時區的時間表示
// RFC3339 = "2006-01-02T15:04:05Z07:00"
timeObj, err = time.Parse(time.RFC3339, "2022-10-05T11:25:20+08:00")
if err != nil {

fmt.Println(err)
return
}
fmt.Println(timeObj) // 2022-10-05 11:25:20 +0800 CST
}

// parseDemo 解析時間
func parseDemo() {

now := time.Now()
fmt.Println(now)
// 加載時區
loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {

fmt.Println(err)
return
}
// 按照指定時區和指定格式解析字符串時間
timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", "2022/10/05 11:25:20", loc)
if err != nil {

fmt.Println(err)
return
}
fmt.Println(timeObj)
fmt.Println(timeObj.Sub(now))
}