天天看点
返回

python：日期与时间之datetime模块时间datetime模块datetime.date类datetime.time类datetime.datetime类datetime.timedelta类补充日历模块拓展

时间

1、Python中最常见以及常用的几种时间格式

   ⑴时间戳(timestamp)：时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量

   ⑵时间元组(struct_time)：共有九个元素组

   ⑶格式化时间(format time)：可以格式化为固定或者自定义格式，增加可读性，如2017-11-1

2、时区：世界标准时间UTC(格林威治天文时间)

3、中国时间为：UTC+8，表示东八区

datetime模块

1、datetime模块是time类的升级版，可以分别对date(日期)、time(时间)、datetime(日期时间)等三种单独管理

    ⑴datetime模块下定义了5个类：这里所说的datetime是一个模块(一个Python文件)，这个模块下面包含了五个类

    ⑵其中3个类用于处理日期、时间、日期时间的：date类、time类、datetime类

    ⑶还有两个类是用于处理时间间隔和时区：timedelta类和tzinfo类

2、datetime模块定义了两个常量：datetime.MINYEAR和datetime.MAXYEAR，分别表示datetime所能表示的最小、最大年份

    MINYEAR = 1

    MAXYEAR = 9999

3、datetime.datetime类的应用最为普遍且上面这些类型的对象都是不可变(immutable)的

4、datetime模块下的类：

类名 调用方式       说明
datetime.date   from datetime import date 表示日期的类。常用的属性有year, month, day
datetime.time from datetime import time 表示时间的类。常用的属性有hour, minute, second, microsecond
datetime.datetime  from datetime import datetime 表示日期时间的类。date类和time类的综合
datetime.timedelta from datetime import timedelta 表示时间间隔，即两个时间点之间的长度
datetime.tzinfo  from datetime import tzinfo 与时区有关的相关信息

datetime.date类

1、date对象由year年份、month月份及day日期三部分构成

    ⑴date对象：调用datetime.date类将相当于是创建了一个datetime.date类的实例对象

2、Python也是面向对象编程语言，所以针对类，就会有构造函数，该类的构造函数如下： 

构造函数

datetime.date类的构造函数如下： 

class datetime.date(year, month, day)

参数说明
1、year, month和day都是是必须参数
2、year：表示年，取值范围[MINYEAR, MAXYEAR]
3、month：表示月，取值范围[1, 12]
4、day：一月中第几天，取值范围[1, 指定年份的月份中的天数]

注：当值超过了取值范围，则会触发一个ValueError的异常

例1：初始化一个date对象

from datetime import date

#初始化一个date对象
date = date(2014,2,11)#只能有年月日三个参数

print(date) #返回一个date对象
print(type(date))

"""
2014-02-11
<class 'datetime.date'>
"""

注：

1、这个其实就是使用类中的构造函数__init__方法来实例化一个date对象

2、源码：

class date:
    min: ClassVar[date]
    max: ClassVar[date]
    resolution: ClassVar[timedelta]

    def __init__(self, year: int, month: int, day: int) -> None: ...

datetime.date类的静态属性和方法

以下是datetime.date类的一些(类)静态方法和(类)属性：直接通过类名调用

类方法/属性名称  描述
date.max  date对象所能表示的最大日期：9999-12-31
date.min date对象所能表示的最小日志：00001-01-01
date.resolution date对象表示的日期的最小单位：天
date.today()  返回一个表示当前本地日期的date对象
date.fromtimestamp(timestamp)  根据给定的时间戳，返回一个date对象

例2：datetime.date类的静态方法和属性

from datetime import date

print("datetime.date类的类属性max：",date.max)
print("datetime.date类的类属性min：",date.min)
print("datetime.date类的类属性resoluation：",date.resolution)
print("datetime.date类的静态方法_today",date.today())
print("datetime.date类的静态方法_fromtimestamp",date.fromtimestamp(1117937981))

"""
datetime.date类的类属性max： 9999-12-31
datetime.date类的类属性min： 0001-01-01
datetime.date类的类属性resoluation： 1 day, 0:00:00
datetime.date类的静态方法_today 2020-08-27
datetime.date类的静态方法_fromtimestamp 2005-06-05
"""

datetime.date类对象的方法和属性

1、一个类中肯定会定义很多类方法和类属性等：我们实例化一个date类或返回一个date类对象后，就可以使用

    ⑴类外："实例名.类方法名"或"实例名.类属性名"来调用类方法和类属性。这里肯定是类外调用

    ⑵类中："self.类方法名"或"类名.类属性"

    ⑶这个是Python类的通用方法、属性

2、以下方法和属性需要通过：datetime.date类的实例对象调用(date对象)

对象方法/属性名称 描述(d表示实例对象)
d.year 年
d.month 月
d.day 日
d.isoformat() 返回格式如'YYYY-MM-DD'的字符串
d.strftime(format) 传入任意格式符，可以输出对应格式的日期表示形式
d.replace(year=,month=,day=)  生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性(原有对象仍保持不变)
d.timetuple()  返回时间元组struct_time格式的日期
d.toordinal() 返回日期是是自 0001-01-01 开始的第多少天
d.weekday()     返回日期是星期几，[0, 6]，0表示星期一
d.isoweekday() 返回日期是星期几，[1, 7], 1表示星期一
d.isocalendar() 返回一个元组，格式为：(year,week,weekday)。week：一年中的第几周，weekday：当前日期是星期几

例3： 实例对象的属性

from datetime import date

now = date.today()
#now = date(2020,12,12)
print("当前时间的date对象为：",now) 
print(type(now))#返回一个date对象

print("实例对象date的year属性：",now.year)
print("实例对象date的month属性：",now.month)
print("实例对象date的day属性：",now.day)

"""
当前时间的date对象为： 2020-08-27
<class 'datetime.date'>
实例对象date的year属性： 2020
实例对象date的month属性： 8
实例对象date的day属性： 27
"""

例3_1：实例对象的replace()方法

from datetime import date

today = date.today()  #返回当前日期

print("当前日期为：",today)

new_day = today.replace(2019,1,1) #新生成一个date对象：年月日
new_day1 = today.replace(2019,1) #新生成一个date对象：年月
new_day2 = today.replace(month=2,day=2) #新生成一个date对象：月日
print("新生成的date对象为：",new_day)
print("新生成的date1对象为：",new_day1)
print("新生成的date2对象为：",new_day2)

print("旧的date对象不变：",today)

"""
当前日期为： 2020-08-27
新生成的date对象为： 2019-01-01
新生成的date1对象为： 2019-01-27
新生成的date2对象为： 2020-02-02
旧的date对象不变： 2020-08-27
"""

例3_2：实例对象的strftime()和isoformat()方法

from datetime import date

today = date.today()  #返回当前日期
print("当前日期为：",today)

new_day = today.strftime("%Y/%m/%d")    #重新格式化日期格式：返回自定义格式的时间字符串
new_day1 = today.strftime("%Y{0}%m{1}%d{2}").format("年","月","日")
print(new_day)
print(new_day1)

new_day2 = today.isoformat()#再次重新格式化日期格式：这个方法是写死了格式的-
print(new_day2)

"""
当前日期为： 2020-08-27
2020/08/27
2020年08月27日
2020-08-27
"""

例3_3：实例对象的timetuple()方法

from datetime import date
import time

today = date.today()    #返回当前日期
print("当前日期为：",today)

new_day = today.timetuple()
print(new_day)
#这里可以使用time类下面的方法将一个时间元组的值转化为字符串型的时间值
print(time.strftime("%Y-%m-%d %H:%M:%S", new_day))

"""
当前日期为： 2020-08-27
time.struct_time(tm_year=2020, tm_mon=8, tm_mday=27, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=240, tm_isdst=-1)
2020-08-27 00:00:00
"""

datetime.time类

datetime模块下的time类由：hour小时、minute分钟、second秒、microsecond毫秒和tzinfo五部分组成

构造函数

datetime.time类的构造函数如下：

class datetime.time(hour, minute, second, microsecond, tzinfo)

参数说明：
1、hour为必须参数，其他为可选参数。各参数的取值范围为：
2、hour：表示小时，取值范围[0, 23]
3、minute：表示分钟，取值范围[0, 59]
4、second：表示秒数，取值范围[0, 59]
5、microsecond：表示毫秒数，取值范围[0, 1000000]
6、tzinfo：表示当前时区，tzinfo的子类对象，如timezone类的实例

例4：

from datetime import time

Time = time(5)  #这里也是相当于实例化一个time
print("只有小时数：",Time)

Time1 = time(hour=5,minute=12,second=12,microsecond=121212)
print("完整：",Time1)
print(type(Time1))  #返回一致time

"""
只有小时数： 05:00:00
完整： 05:12:12.121212
<class 'datetime.time'>
"""

datetime.time类的静态属性

1、以下是datetime.time类的一些(类)静态属性：直接通过类名调用

类方法/属性名称 描述
time.max time类所能表示的最大时间：time(23, 59, 59, 999999)
time.min  time类所能表示的最小时间：time(0, 0, 0, 0)
time.resolution 时间的最小单位，即两个不同时间的最小差值：1微秒

例5：

from datetime import time

print(time.max)
print(time.min)
print(time.resolution)

"""
23:59:59.999999
00:00:00
0:00:00.000001
"""

datetime.time类对象的方法和属性

1、也是实例化一个类对象后(time类)或返回一个time类对象后，通过其实例名来调用

2、以下方法和属性需要通过：datetime.time类的实例对象调用

对象方法/属性名称  描述
t.hour 时
t.minute   分
t.second  秒
t.microsecond  微秒
t.isoformat() 返回一个‘HH:MM:SS.%f’格式的时间字符串
t.strftime() 返回指定格式的时间字符串，与time模块的strftime(format, struct_time)功能相同
t.tzinfo   时区信息
t.replace(hour,minute,second,microsecond,tzinfo) 创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性(原有对象仍保持不变)

例6：time对象常用属性

from datetime import time

Time = time(22, 23, 23, 111)  #实例化一个time对象：Time
print("时间：",Time)

print("实例对象的hour属性：",Time.hour)
print("实例对象的minute属性：",Time.minute)
print("实例对象的second属性：",Time.second)
print("实例对象的microsecond属性：",Time.microsecond)
print("实例对象的tzinfo属性：",Time.tzinfo) #实例化时没有指明所用时区，因此为None

"""
#time类就没有返回当前时间的属性或方法了？
时间： 22:23:23.000111
实例对象的hour属性： 22
实例对象的minute属性： 23
实例对象的second属性： 23
实例对象的microsecond属性： 111
实例对象的tzinfo属性： None
"""

例6_1：

from datetime import time

Time = time(22, 23, 3, 111)  #实例化一个time对象：Time
print("时间：",Time)

#strftime()方法：根据传入的格式来输出时间字符串
print("指定格式：",Time.strftime("%H-%M-%S.%f"))
print("指定格式：",Time.strftime("%H{0}%M{1}%S{2}").format("时","分","秒")) #可以不格式化毫秒

#isoformat()：输出固定格式的字符串
print("固定格式：",Time.isoformat())

#replace()：生成新的time对象
print("生成新的time对象：",Time.replace(hour=3))
print("生成新的time对象：",Time.replace(3,3,3,33))

"""
时间： 22:23:03.000111
指定格式： 22-23-03.000111
指定格式： 22时23分03秒
固定格式： 22:23:03.000111
生成新的time对象： 03:23:03.000111
生成新的time对象： 03:03:03.000033
"""

datetime.datetime类

1、datetime模块下的datetime类是Python处理日期和时间的标准库。datetime类是date类与time类的结合体，包括date类与time类的所有信息

构造函数

datetime.datetime类的构造函数如下：

datetime.datetime (year, month, day, hour, minute, second, microsecond, tzinfo)

例7：实例化一个datetime对象

from datetime import datetime

now = datetime(2020,8,27,12,12,12,1111)#实例化一个datetime对象
print("当前日期为：",now)
print(type(now))

now1 = datetime(year=2020,month=8,day=27) #年月日为必填参数，其余未传入时默认为0
print("当前日期为：",now1)

"""
当前日期为： 2020-08-27 12:12:12.001111
<class 'datetime.datetime'>
当前日期为： 2020-08-27 00:00:00
"""

datetime.datetime类的静态属性

1、以下是datetime.datetime类的一些(类)静态方法和属性：直接通过类名调用

类属性、类方法 描述
datetime.today()  返回一个表示当前本地时间的datetime对象
datetime.now([tz])  返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间
datetime.utcnow() 返回一个当前utc时间的datetime对象；#格林威治时间
datetime.fromtimestamp(timestamp[, tz])  根据时间戮创建一个datetime对象，参数tz指定时区信息
datetime.utcfromtimestamp(timestamp) 根据时间戮创建一个datetime对象(utc)
datetime.combine(date, time)   根据date和time，创建一个datetime对象
datetime.strptime(date_string, format) 将格式字符串转换为datetime对象

datetime.datetime类方法

1、直接通过类名调用

today()

1、today()方法的语法如下：datetime.datetime.today()

2、此语法中datetime.datetime指的是datetime模块中的datetime类

3、返回值：返回一个表示当前本地时间的datetime对象

例8：

import datetime

now = datetime.datetime.today()
print("当前时间为：",now)
print(type(now))

"""
当前时间为： 2020-08-27 14:12:01.679698
<class 'datetime.datetime'>
"""

例8_1：

from datetime import datetime

now = datetime.today()
print("当前时间为：",now)

#当前时间为： 2020-08-27 14:11:06.903158

now()

1、now()方法的语法如下：datetime.datetime.now([tz])

2、此语法中datetime.datetime指的是datetime模块中的datetime类

3、如果提供参数tz，就获取tz参数所指时区的本地时间(now是本地时间，可以认为是你电脑现在的时间)

4、返回值：返回当前指定的本地时间，一个datetime对象

例9：

from datetime import datetime

print("当前时间为：",datetime.now())

#当前时间为： 2018-08-19 19:07:33.719778

utcnow()

1、utcnow()方法的语法如下：datetime.datetime.utcnow()

2、此语法中datetime.datetime指的是datetime模块中的datetime类

3、返回值：返回一个当前utc时间的datetime对象

例10：

from datetime import datetime

print("当前时间为：",datetime.utcnow())
print("当前时间为：",datetime.now())

"""
当前时间为： 2020-08-27 06:15:31.312575
当前时间为： 2020-08-27 14:15:31.312575
"""

fromtimestamp()

1、fromtimestamp()方法的语法如下：datetime.datetime.fromtimestamp(timestamp[,tz]

2、此语法中datetime.datetime指的是datetime模块中的datetime类

3、参数tz表示指定的时区信息，参数timestamp表示需要转换的时间戳

4、返回值：将一个时间戳形式的时间转换为可读形式，返回一个datetime对象

例11：

from datetime import datetime
import time

now = time.time()
print("当前时间戳：",now)

Time = datetime.fromtimestamp(now)
print("当前时间为：",Time)

print("当前时间为：",datetime.fromtimestamp(1583355285))

"""
当前时间戳： 1598509379.9748611
当前时间为： 2020-08-27 14:22:59.974861
当前时间为： 2020-03-05 04:54:45
"""

combine()

1、combine()方法的语法如下：datetime.datetime.combine(date, time)

2、此语法中datetime.datetime指的是datetime模块中的datetime类

3、参数date表示一个date对象，参数time表示一个time对象

4、返回值：根据date和time，创建一个datetime对象

例12：

import datetime

Date = datetime.date.today()
print("当前日期为：",Date)

Time = datetime.time(12,12,12,122)
print("当前时间为：",Time)

now = datetime.datetime.combine(Date,Time)
print("当前日期时间为：",now)

"""
当前日期为： 2020-08-27
当前时间为： 12:12:12.000122
当前日期时间为： 2020-08-27 12:12:12.000122
"""

strptime()

1、作用：将时间型字符串格式化为datetime对象

2、strptime()方法的语法如下：datetime.datetime.strptime(date_string,format)

3、此语法中datetime.datetime指的是datetime模块中的datetime类

4、参数date_string指日期字符串，format为格式方式

5、返回值：返回一个datetime对象

例13：

from datetime import datetime

"""
1、strptime()方法将一个字符串时间格式化为一个datetime对象
2、目标格式中传入了.%f属性时，传入的时间字符串中必须含有毫秒(必须为对应关系)
3、目标格式中未传入了.%f属性时，传入的时间字符串中不能含有毫秒(必须为对应关系)
"""
time1 = datetime.strptime("2018-08-19 19:23:57.1111", "%Y-%m-%d %H:%M:%S.%f")
print(time1)
print(type(time1))

time2 = datetime.strptime("2018-08-19 19:23:57", '%Y-%m-%d %H:%M:%S')
print(time2)

"""
2018-08-19 19:23:57.111100
<class 'datetime.datetime'>
2018-08-19 19:23:57
"""

例13_1：

import datetime

input_date = str(input("-----："))

try:
    date = datetime.datetime.strptime(input_date, '%Y-%m-%d %H:%M:%S')
    print("当前输入的时间值为：", date)
except:
    print("传入的时间值错误")

print("时间值校验完成")

"""
-----：2020-11-15 13:22:23
当前输入的时间值为： 2020-11-15 13:22:23
时间值校验完成

-----：2020-11-15 13:22:23.000
传入的时间值错误
时间值校验完成

-----：2020/11/15 13:22:23
传入的时间值错误
时间值校验完成
"""

datetime类对象的方法和属性

1、实例化一个类对象(datetime类)或返回一个datetime类对象后，通过其实例名来调用

2、以下方法和属性需要通过：datetime.datetime类的实例对象调用

3、datetime.datetime类的类方法或属性返回的如果是一个datetime对象，那这个datetime对象又有自己的方法或属性

    ⑴一般而言，在Python中返回值是一个对象，那么这个对象都有自己的方法或属性

对象方法 描述(dt表示datetime类的实例对象)
dt.year, dt.month, dt.day 年、月、日
dt.hour, dt.minute, dt.second 时、分、秒
dt.microsecond, dt.tzinfo 微秒、时区信息
dt.date() 获取datetime对象对应的date对象
dt.time() 获取datetime对象对应的time对象， tzinfo 为None
dt.timetuple() 返回datetime对象对应的tuple（不包括tzinfo）
dt.timetz() 获取datetime对象对应的time对象，tzinfo与datetime对象的tzinfo相同
dt.utctimetuple() 返回datetime对象对应的utc时间的tuple（不包括tzinfo）
dt.toordinal() 同date对象
dt.weekday() 同date对象
dt.isocalendar() 同date对象
dt.isoformat([sep])     返回一个‘%Y-%m-%d
dt.ctime()     等价于time模块的time.ctime(time.mktime(d.timetuple()))
dt.strftime(format) 返回指定格式的时间字符串
dt.replace(year, month, day, hour,minute,second, microsecond, tzinfo) 生成并返回一个新的datetime对象

strftime()

1、作用：将datetime对象格式化为字符串

2、strftime()方法的语法如下：dt.strftime(format)

3、此语法中datetime.datetime指的是datetime模块中的datetime类

4、dt表示datetime类的实例对象，参数format为格式化方式

3、返回值：返回一个时间字符串

例14：

from datetime import datetime

"""
1、strftime方法将一个datetime对象格式化为一个字符串时间
2、目标格式中传入了.%f属性时，输出的时间值中将会有毫秒
3、目标格式中未传入了.%f属性时，输出的时间值中将不会有毫秒
"""
now = datetime.now()
print("当前时间",now)
print(type(now))

time1 = now.strftime("%Y-%m-%d %H:%M:%S.%f")
print(time1)

time2 = now.strftime('%Y-%m-%d %H:%M:%S')
print(time2)
print(type(time1))

"""
当前时间 2020-08-27 14:48:01.711876
<class 'datetime.datetime'>
2020-08-27 14:48:01.711876
2020-08-27 14:48:01
<class 'str'>
"""

例15：

import datetime,time

today = datetime.datetime.now()

print(today.year)
print(today.hour)
print(today.date())
print(today.time())


'''
上面函数的输出结果为：
2018
17
2018-08-25
17:01:33.202716
'''

datetime.timedelta类

1、timedelta对象表示两个不同时间之间的差值

    ⑴datetime.timedelta对象代表两个时间之间的时间差，两个date、time或datetime对象相减就可以返回一个timedelta对象

2、如果使用time模块对时间进行算术运行，只能将字符串格式的时间和struct_time格式的时间对象先转换为时间戳格式

    ⑴然后对该时间戳加上或减去n秒，最后再转换回struct_time格式或字符串格式，这显然很不方便

3、而datetime模块提供的timedelta类可以让我们很方面的对datetime.date, datetime.time和datetime.datetime对象做算术运算

    ⑴且两个时间之间的差值单位也更加容易控制。这个差值的单位可以是：天、秒、微秒、毫秒、分钟、小时、周

构造函数

datetime.timedelta类的构造函数如下：

datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
#天、秒、微秒、毫秒、分钟、小时、周

注：

1、所有参数都是默认参数，默认值为0

2、参数的值可以是整数或浮点数，也可以是正数或负数(正数表示加，负数表示减)

3、针对时间存储，timedelta内部只能存储days，seconds，microseconds，其他参数的值会自动按如下规则进行转换：

    ⑴millisecond毫秒）转换成1000 microseconds（微秒）

    ⑵minute转换成60 seconds

    ⑶hour转换成3600 seconds

    ⑷week转换成7 days

例16：

from datetime import timedelta

# 实例化一个时间段值：1周2天3小时4分钟5秒777毫秒666微秒
time1 = timedelta(days=2, seconds=5, microseconds=666, milliseconds=777, minutes=4, hours=3, weeks=1)
print(time1)
print(type(time1))

time2 = timedelta(days=2, hours=1)
print(time2)


"""
9 days, 3:04:05.777666
<class 'datetime.timedelta'>
2 days, 1:00:00
感觉其作用就是实例化一个时间段值，然后可能根据这个时间段值来进行时间的加减
"""

例16_1：日期时间差

import datetime

Date = datetime.datetime.today()
print("当前日期：",Date)

Date1 = datetime.datetime(2020,8,20,12,12,12)
print("过去日期为：",Date1)

d = Date - Date1  #这里以datetime对象为例，date对象与time对象也是可以相减的
print("日期差为：",d)
print(type(d))

"""
当前日期： 2020-08-27 15:01:28.856253
过去日期为： 2020-08-20 12:12:12
日期差为： 7 days, 2:49:16.856253
<class 'datetime.timedelta'>
"""

例16_1：时间间隔

import datetime

#print(datetime.timedelta(365).total_seconds())  #一年中共有多少秒

today = datetime.datetime.now()
print("当前时间：",today)

three_day_later = today + datetime.timedelta(3)   #3天后
print(three_day_later)
print(type(three_day_later)) #还是一个datetime对象

three_day_befor = today - datetime.timedelta(days = 3)   #3天前
#three_day_befor = today + datetime.timedelta(-3)
print(three_day_befor)

three_hours_later = today + datetime.timedelta(hours=3)   #3小时后
print(three_hours_later)

new_day = today + datetime.timedelta(days=1,minutes=22,seconds=30,milliseconds=2)   #1天22分钟30秒2毫秒后
print(new_day)


"""
当前时间： 2020-08-27 15:07:15.893238
2020-08-30 15:07:15.893238
<class 'datetime.datetime'>
2020-08-24 15:07:15.893238
2020-08-27 18:07:15.893238
2020-08-28 15:29:45.895238
"""

datetime.timedelta类的类属性

1、以下是datetime.timedelta类的一些(类)属性：直接通过类名调用

类属性名称   描述
timedelta.min  timedelta(-999999999)
timedelta.max  timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
timedelta.resolution  timedelta(microseconds=1)

datetime.timedelta类对象的方法和属性

1、实例化一个类对象后(timedelta类)或返回一个timedelta类对象后，通过其实例名来调用

2、以下方法和属性需要通过：datetime.timedelta类的实例对象调用

实例方法/属性名称  描述(td表示timedelta类的实例对象)
td.days  天 [-999999999, 999999999]：返回时间差的天部分
td.seconds  秒 [0, 86399]：返回之间差的时分秒部分(转换为秒返回)
td.microseconds 微秒 [0, 999999]
td.total_seconds()  时间差中包含的总秒数
datetime.datetime.now()   返回当前本地时间（datetime.datetime对象实例）
datetime.datetime.fromtimestamp(timestamp)   返回指定时间戳对应的时间（datetime.datetime对象实例）
datetime.timedelta()     返回一个时间间隔对象，可以直接与datetime.datetime对象做加减操作

例17：

from datetime import datetime, timedelta
 
future = datetime.strptime("2020-02-01 08:00:00", "%Y-%m-%d %H:%M:%S")
now = datetime.now()
 
TimeEquation = now - future
print(TimeEquation)            #返回两个时间差的天、时分秒部分：49 days, 5:58:56.887765
print(TimeEquation.days)    #只返回两个时间差的天数部分：49
print(TimeEquation.seconds)    #只返回两个时间差的时分秒部分(换算为秒返回)：21536=(5*60*60)+(58*60)+56
print(TimeEquation.seconds/60/60)#只返回两个时间差的时分秒部分(换算为小时返回)：5.982222222222222=5+(59/60)
 
print(TimeEquation.total_seconds())
#返回两个时间差的总秒数(将相差天、时、分、秒都转为秒)：4255136.887765=(48*24*60*60)+(5*60*60)+(58*60)+56
 
"""
49 days, 5:58:56.887765
49
21536
5.982222222222222
4255136.887765
"""

补充

计算两个时间的时间差

其本上常用的类有：datetime和timedelta两个。它们之间可以相互加减。每个类都有一些方法和属性可以查看具体的值

    ⑴datetime可以查看：天数(day)，小时数(hour)，星期几(weekday())等

    ⑵timedelta可以查看：天数(days)，秒数(seconds)等

例18：

from datetime import datetime,timedelta

future = datetime.strptime("2019-02-01 08:00:00","%Y-%m-%d %H:%M:%S")
now = datetime.now()

TimeEquation = future - now      #计算时间差
#print(TimeEquation)              #145 days, 20:50:32.599774

hours = TimeEquation.seconds/60/60
minutes = (TimeEquation.seconds - hours*60*60)/60
seconds = TimeEquation.seconds - hours*60*60 - minutes * 60

print("今天是：",now.strftime("%Y-%m-%d %H:%M:%S"))
print("距离2019-02-01，还剩下%d天" % TimeEquation.days)
print(TimeEquation.days,hours ,minutes,seconds)


"""
今天是： 2018-09-08 11:42:38
距离2019-02-01，还剩下145天
145 20.289166666666667 0.0 0.0
"""

Python中的时区转换

1、在Python中将一个时区的时间转换成另一个时区的时间，比较常用的方法是：结合使用datetime模块和pytz模块，一般步骤为

    ⑴使用datetime模块来获取一个时间对象(datetime对象)

    ⑵使用pytz模块来创建一个将要转换到的时区对象

    ⑶使用datetime对象方法astimezone()方法来进行转换

2、在介绍时区转换前需要介绍两个时间概念：

    ⑴navie时间：获取的时间对象不知道自己的时间表示的是哪个时区的(如：使用datetime.now()方法获取的时间对象就不知道当前表示的是哪个时区)

    ⑵aware时间：获取的时间对象知道自己的时间表示的是哪个时区的

例19：

from datetime import datetime,timedelta,timezone
import pytz

now = datetime.now()
print(now)

utc_timezone = pytz.timezone("UTC")#使用pytz.timezone()方法来创建一个时区对象
utc_now = now.astimezone(utc_timezone)#使用astimezone()方法来将时间转换为另一个时区的时间
print(utc_now)

"""
2020-03-31 12:53:43.762358
ValueError: astimezone() cannot be applied to a naive datetime
"""

注：

1、从上面例子的输出可以看出，在进行时区转换时(now.astimezone(utc_timezone))，报错了，这是因为：

    ⑴在使用datetime.now()获取的时间对象是一个navie时间，即不知道自己的时间表示的是哪个时区。既然不知道自己的时间当前在哪个时区，那肯定是不能将当前时间转化为另一个时区的时间的

    ⑵要解决这个问题，因此需要将使用datetime.now()获取的这个时间加上一个时区标志

    ⑶要给一个无时区标志的时间加上一个时区标志，那就可以用到datetime对象下的replace()方法了

2、pytz.timezone(‘时区名’)：此方法能获取一个tzinfo对象，该对象可在datetime生成时间中以参数的形式放入，即可生成对应时区的时间

3、astimezone()：datetime对象方法，用于将一个时区的时间转为另一个时区的时间。这个方法只能别aware类型时间调用，不能被navie类型的时间调用

4、replace()：datetime对象方法，可以将一个时间的某些属性进行修改

5、因此正确的将一个时区的时间转为另一个时区的时间，可以使用下面这种方法

例19_1：

from datetime import datetime,timedelta,timezone
import pytz

now = datetime.now()
print(now)

utc_timezone = pytz.timezone("UTC")

now = now.replace(tzinfo=pytz.timezone("Asia/Shanghai"))
print(now)

utc_now = now.astimezone(utc_timezone)
print(utc_now)

"""
2020-03-31 13:09:37.666740
2020-03-31 13:09:37.666740+08:06
2020-03-31 05:03:37.666740+00:00
"""

注："+08:06"表示的是当前时区的时间相对于UTC时间相差了多少

日历模块

1、此模块的函数都是日历相关的，例如打印某月的字符月历

2、星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数

calendar()

1、语法：calendar.calendar(year,w=2,l=1,c=6)

2、作用：返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数

例20：

import calendar

print(calendar.calendar(1993))

"""
上面代码的输出结果为：
                                1993

      January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3       1  2  3  4  5  6  7       1  2  3  4  5  6  7
 4  5  6  7  8  9 10       8  9 10 11 12 13 14       8  9 10 11 12 13 14
11 12 13 14 15 16 17      15 16 17 18 19 20 21      15 16 17 18 19 20 21
18 19 20 21 22 23 24      22 23 24 25 26 27 28      22 23 24 25 26 27 28
25 26 27 28 29 30 31                                29 30 31

       April                      May                       June
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
          1  2  3  4                      1  2          1  2  3  4  5  6
 5  6  7  8  9 10 11       3  4  5  6  7  8  9       7  8  9 10 11 12 13
12 13 14 15 16 17 18      10 11 12 13 14 15 16      14 15 16 17 18 19 20
19 20 21 22 23 24 25      17 18 19 20 21 22 23      21 22 23 24 25 26 27
26 27 28 29 30            24 25 26 27 28 29 30      28 29 30
                          31
下面的月份就不写了
"""

month()

1、语法：calendar.month(year,month,w=2,l=1)

2、返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数

例21：

import calendar

print(calendar.month(1993,7))

"""
上面代码的输出结果为：
     July 1993
Mo Tu We Th Fr Sa Su
          1  2  3  4
 5  6  7  8  9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31
"""

isleap()

1、语法：calendar.isleap(year)

2、返回值：是闰年返回True，否则为false

例22： 

import calendar

month = calendar.isleap(1993)

if month == False:
    print("1993年不是闰年")

#上面代码的输出结果为：1993年不是闰年

leapdays()

1、语法：calendar.leapdays(y1,y2)

2、返回值：返回在Y1，Y2两年之间的闰年总数

例23：

import calendar

print(calendar.leapdays(2008,2018))

#上面代码的输出结果为：3

注：calendar模块中还有其他的一些函数，由于这个模块用的不是很多，多以就不一一列举了

拓展

UTC time

Coordinated Universal Time，世界协调时，又称 格林尼治天文时间、世界标准时间。与UTC time对应的是各个时区的local time

    ⑴东N区的时间比UTC时间早N个小时，因此UTC time + N小时即为东N区的本地时间

    ⑵西N区时间比UTC时间晚N个小时，即 UTC time - N小时 即为西N区的本地时间

    ⑶中国在东8区，因此比UTC时间早8小时，可以以UTC+8进行表示

按天生成日志

例24：

import os
import datetime,time

def make_dir():
    get_file_path = os.path.realpath(__file__)
    get_file_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(get_file_path))))
    make_file_path = os.path.join(get_file_dir+"{}".format(str(datetime.datetime.now().year)
    + "_" + str(datetime.datetime.now().month) + "_" + str(datetime.datetime.now().day)))
    make_file_name = make_file_path + "_log.txt"
    print(make_file_name)
    return make_file_name


def open_file(log_file_path):
    log_file = open(log_file_path,"w")
    return log_file


if __name__ == "__main__":
    make_file_name = make_dir()
    open_file(make_file_name)


"""
F:\2019_6_26_log.txt
"""
python3 Python 时间、日期 datetime
上一篇: 阿里巴巴产品实习生N天
下一篇: Python-基础知识学习之时间、日期（time、datetime）

继续阅读