首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享
    首页 > Python3教程 > Python3常用标准库

Python3 日期和时间库 - datetime

datetime是Python处理日期和时间的标准库,为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法,有效的处理和格式化输出,支持时区处理。

获取当前日期和时间

from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now) #2019-02-18 20:45:39.835975
print(type(now)) #<class 'datetime.datetime'>

datetime是模块,datetime模块还包含一个datetime类,通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime,则必须引用全名datetime.datetime。datetime.now()返回当前日期和时间,其类型是datetime。

获取指定日期和时间

from datetime import datetime
dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
print(dt) #2019-02-19 12:20:00

datetime转换为timestamp

我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数),当前时间就是相对于epoch time的秒数,称为timestamp(时间戳)。

from datetime import datetime
dt = datetime.now() # 获取当前datetime
# dt = datetime(2019, 2, 19, 12, 20) # 用指定日期时间创建datetime
t = dt.timestamp() # datetime转换为timestamp
print(t)

Python语言的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。

其他编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的表示方法。

timestamp转换为datetime

使用datetime提供的fromtimestamp()方法

from datetime import datetime
t = 1550494416.590926
print(datetime.fromtimestamp(t)) #2019-02-18 20:53:36.590926

fromtimestamp函数转换是在timestamp和本地时间做转换,utcfromtimestamp函数为转换到UTC标准时区的时间

字符串转换为datetime

通过datetime.strptime()函数实现,需要一个日期和时间的格式化字符串'%Y-%m-%d %H:%M:%S'规定日期和时间部分的格式,参考:python文档

from datetime import datetime
day = datetime.strptime('2019-2-1 19:19:59', '%Y-%m-%d %H:%M:%S')
print(day) #2019-02-01 19:19:59

datetime转换为字符串

datetime对象格式化为字符串是通过strftime()实现的,同样需要一个日期和时间的格式化字符串

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M')) #Mon, Feb 18 21:10

datetime加减

使用timedelta很容易地算出前几天和后几天的时间,加减直接用+和-运算符,需要导入timedelta这个类

 from datetime import datetime, timedelta

now = datetime.now()

print(now) #2019-02-18 21:15:45.731212
print(now + timedelta(hours=10)) #2019-02-19 07:15:45.731212
print(now - timedelta(days=1)) #2019-02-17 21:15:45.731212
print(now + timedelta(days=2, hours=12)) #2019-02-21 09:15:45.731212

本地时间转换为UTC时间

 本地时间是指系统设定时区的时间,如北京时间是UTC+8:00时区的时间,而UTC时间指UTC+0:00时区的时间。

一个datetime类型有一个时区属性tzinfo,默认为None,我们无法区分这个datetime到底是哪个时区,除非强行给datetime设置一个时区

from datetime import datetime, timedelta, timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
print(now) #2019-02-18 22:51:18.786791

dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #2019-02-18 22:51:18.786791+08:00

时区转换

通过utcnow()拿到当前的UTC时间,再转换为任意时区的时间

# 获取UTC时间,并强制设置时区为UTC+0:00:
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print(utc_dt) #2019-02-18 14:51:18.786791+00:00

# astimezone()将转换时区为北京时间:
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
print(bj_dt) #2019-02-18 22:51:18.786791+08:00

# astimezone()将转换时区为东京时间:
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt) #2019-02-18 23:51:18.786791+09:00

# astimezone()bj_dt转换时区为东京时间:
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
print(tokyo_dt2) #2019-02-18 23:51:18.786791+09:00

拿到一个datetime时,要获知其正确的时区,然后强制设置时区,作为基准时间。

利用带时区的datetime,通过astimezone()方法,可以转换到任意时区。

注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime都可以正确转换

datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

Python3 日期和时间库 - datetime-Python3常用标准库-编程文章分享