go time,python time,datetime事件模块详解

时间格式

GMT

GMT是格林尼治标准时间（Greenwich Mean Time）的缩写。它是以英国伦敦格林尼治天文台所在地的本地时间为基准的标准时间，通常用于衡量其他时区的时间偏移量。GMT被认为是世界标准时间的基准。

在格林尼治标准时间中，太阳每天在正午时分（12:00）时经过格林尼治子午线（0度经线）。由于地球的自转和其它因素，其他时区的时间会相应地与GMT产生偏移。例如，德国位于GMT+1时区，因此当GMT显示正午时，德国的当地时间为下午1点。

GMT在历史上曾经是全球通用的标准时间，但后来由于地球自转速率的微小变化以及时间测量技术的进步，国际原子时（International Atomic Time，TAI）和协调世界时（Coordinated Universal Time，UTC）被引入作为更精确的时间标准。尽管GMT目前已被UTC取代，但这两者在常规使用中没有实际差异，因此人们经常将GMT和UTC视为同一概念。

UTC

UTC是协调世界时（Coordinated Universal Time）的缩写。它是一种标准的时间系统，用于为全球提供统一的时间标准，以便协调跨国界的时间记录和通信。

UTC是由原子钟提供的高度精确的时间测量，它基于国际原子时（International Atomic Time，TAI），而TAI则是由多个原子钟的平均值计算得出的。原子钟的稳定性非常高，可以提供极为准确的时间，因此UTC成为全球通用的标准时间。

与GMT相比，UTC具有更高的精确度，并且不会受到地球自转速率微小变化的影响。因此，自从引入UTC作为全球标准时间后，许多国家和地区都以UTC作为其基准时间，并根据UTC的偏移量来设定本地的时区时间。

需要注意的是，UTC与格林尼治标准时间（GMT）在大部分时候是相同的，它们之间最多只有几毫秒的差异。这是因为为了保持UTC的稳定性，当地的时钟会根据需要进行微调，以确保与国际原子时保持同步。因此，通常我们将UTC和GMT视为几乎相同的概念，只有在精确科学测量和计算时才需要考虑微小的差异。

CST

CST是指中央标准时间（Central Standard Time）的缩写。中央标准时间是北美洲、中美洲和一些加勒比海岛屿等地区使用的一个标准时间。

具体来说，中央标准时间（CST）是以美国的中央时区为基准的时间。它距离格林尼治标准时间（GMT）向西经过6个时区，即GMT-6。在夏令时期间，该地区会调整为中央夏令时（Central Daylight Time，CDT），此时偏移量变为GMT-5。

以下是一些使用中央标准时间（CST）的地区和国家：

1. 美国：中部和部分东部州，如德克萨斯州、伊利诺伊州、密苏里州、明尼苏达州、威斯康星州等。

2. 加拿大：部分省份，如马尼托巴省、萨斯喀彻温省、艾伯塔省等。

3. 墨西哥：部分地区，如锡那罗亚州、尤卡坦州、坎佩切州等。

4. 中美洲国家：洪都拉斯、尼加拉瓜、危地马拉、萨尔瓦多等。

请注意，CST和CDT这样的时区缩写只是标示地区的标准时间和夏令时的概念，并不具体指代某个国家或城市。具体使用中央标准时间的地区会根据各自的规定和需求进行时间调整和使用。

ISO

ISO时区是指国际标准化组织（International Organization for Standardization，ISO）所定义的时区标准。ISO 时区代码是一套用于标识世界各个时区的简短字母代码，旨在提供一种统一的方法来表示全球范围内的不同时区。

ISO 时区代码由三个大写字母组成，其格式如下：

1. 第一个字母表示地理区域（通常是大洲或地区的首字母）。
2. 第二个字母表示特定国家或地区内的子区域。
3. 第三个字母表示夏令时的使用情况（如果适用），通常用"S"表示使用夏令时，用"W"表示不使用夏令时。

以下是一些常见的ISO时区代码示例：

• UTC：协调世界时（Coordinated Universal Time），即格林尼治标准时间（GMT）。
• GMT：格林尼治标准时间，与UTC相同。
• EST：东部标准时间（Eastern Standard Time），例如美国东部地区。
• PST：太平洋标准时间（Pacific Standard Time），例如美国西部地区。
• CET：中欧标准时间（Central European Time），例如德国、法国等国家。
• JST：日本标准时间（Japan Standard Time），日本的标准时间。

ISO时区代码的使用有助于在计算机系统和全球通信中标准化时间的表示，使得跨时区的时间转换更加方便和准确。这些代码还广泛应用于软件开发、数据库管理、航空航天等领域，以确保不同系统和应用程序之间的时间一致性。

UTC+8

中国的标准时间采用中国标准时间（China Standard Time，CST），也称为北京时间（Beijing Time，BJT）。中国标准时间是以中国的首都北京为基准的标准时间，其时区代码为UTC+8。

UTC+8意味着当格林尼治标准时间（GMT）显示为中午12:00时，中国的标准时间为下午8:00。中国的整个大陆地区都采用中国标准时间，包括北京、上海、广州等主要城市以及其他各省市自治区。

值得注意的是，中国不实行夏令时制度，因此在整个年份里，中国的标准时间保持不变，始终处于UTC+8时区。这样的时区统一使得全国范围内的时间保持一致，不会有夏令时调整导致的时间变化。

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

dateutil

1. 能够快速计算出相对时间例如下周、下个月、明年
2. 对指定两个日期或者日期对象进行计算出相对间隔
3. 能对多种时区文件进行解析例如UTC时区、tzinfo时区、Windows注册表时区
4. 支持包括RFC或者其他任何字符串格式的日期进行解析

安装

pip install python-dateutil

dateutil 模块提供主要的方法

dateutil.parser.parse(string)将字符串解析成

1. string 可以为任何一个字符串
2. 时间字符串形式可以有逗号、斜杠、横杆等

datetimedateutil.rrule.rrule() 将参数输出datetime.datetime格式的时间

rrule方法参数说明

参数	含义
freq	单位，可选的值为YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY,，MINUTELY,SECONDLY
dtstart	开始时间，时间格式datetime.datatime类型
interval	间隔
wkst	周开始时间
count	生产时间的个数
until	结束时间，时间格式为datetime.dateatime类型
bysetpos	必须为整数或者整数序列，设置匹配的周期频率
bymonth	设置匹配的月份
bymonthday	设置匹配每月的日期
byyearday	设置匹配每年的天数
byaster	设置匹配的复活节，星期天为0
byweekno	设置匹配第几周
byweekday	MO,TU,WE,TH,FR,SA,SU
byhour	设置匹配小时
byminute	设置匹配分钟
bysecond	设置匹配秒数
cache	必须为布尔值，其实很启动缓存

dateutil.relativedelta.relativedelta()时间偏移量

参数	说明
year, month, day, hour, minute, second, microsecond	绝对单位，不会执行运算，会直接替换原始日期时间对应的值
years, months, weeks, days, hours, minutes, seconds, microseconds	相对信息，可以为正数或复负数，会对原始日期时间进行相对值进行计算
weekday	工作日增量值，可以为正数或者负数，例如MO(1),0=MO
leepdays	给定日期中计算出润日
yearday,nlyearday	设置年份为闰年或者非闰年，转换成日/月/闰日

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)

	// 上面两个时间看似差了8小时，但表示的是同一个时间
	timesAreEqual := timeInUTC.Equal(sameTimeInBeijing)
	// true
	fmt.Println(timesAreEqual)

	// 上面两个时间看似差了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))
}