go time,python time,datetime

时间格式 GMT:

格林尼治标准时间

UTC:

协调世界时，又称世界统一时间、世界标准时间、国际协调时间。

协调世界时是以原子时秒长为基础，在时刻上尽量接近于世界时的一种时间计量系统。

CST:

CST可视为美国、澳大利亚、古巴或中国的标准时间。

CST可以为如下4个不同的时区的缩写：

1. 美国中部时间：Central Standard Time (USA) UT-6:00
2. 澳大利亚中部时间：Central Standard Time (Australia) UT+9:30
3. 中国标准时间：China Standard Time UT+8:00
4. 古巴标准时间：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库的扩展

1. datetime.date：日期表示类，可以表示年月日等。
2. datetime.time：时间表示类，可以以时分秒毫秒表示。
3. datetime.datetime：日期时间有关的类，功能覆盖date和time类。
4. datetime.timedelta：有时间间隔有关的类。
5. datetime.tzinfo：与时区相关的信息表示类。

datetime.datetime类

常用属性：

1. .min：返回datetime最小时间对象。
2. .max：返回datetime最大时间对象。
3. .year：datetime对象的年属性值。
4. .month：datetime对象的月属性值。
5. .day：datetime对象的日属性值。
6. .hour：datetime对象的时属性值。
7. .minute：datetime对象的分属性值。
8. .second：datetime对象的属性值。秒
9. .microsecond：datetime对象的微秒属性值。

创建对象：

1. datetime.datetime.now()：将时间戳转化为datetime对象，默认时间戳为time.time()
2. datetime.datetime.utcnow()：同上，转为utc
3. datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0)：指定年月日创建datetime对象
4. datetime.fromtimestamp(timestamp, tz=None)将一个时间戳转化为一个datetime对象
5. utcfromtimestamp(timestamp)将utc时间戳转化为对象

常用方法：

1. isoformat()：采用ISO 0861标准显示时间，并返回字符串。
2. isoweekday：根据日期计算星期并返回（1-7，整型）。
3. strftime(format)：根据格式化字符串format进行格式化显示，并返回字符串
4. isocalendar()：返回（year,第几周，周几)
5. utcnow()：返回utc时间的datetime对象
6. time()：返回datetime对象对应的时间
7. date()：返回datetime对象对应的日期
8. datetime.strptime(cls, date_string, format)：类方法，将字符串格式化为datetime对象
9. timetuple()：将datetime对象变成时间元组
10. astimezone(self, tz=None)根据指定的时区参数 tz 返回一个 DateTime 实例
11. 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:%vn", 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:%02dn", 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:%vn", timestamp1)
    fmt.Printf("current timestamp2:%vn", 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:%02dn", 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

是否相等

1. 判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较。
2. 本方法和用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()

1. 定时器NewTicker是设定每隔多长时间触发的，是连续触发。
2. 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))
}