python之内置模块time模块和datetime模块详解
一、time模块
前言
① timestamp 时间戳，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
② struct_time 时间元组，共有九个元素组。
③ format time 格式化时间，已格式化的结构使时间更具可读性。包括自定义格式和固定格式。
1、时间格式转换图
time常用参数
%a 星期几的简写 %A 星期几的全称 %b 月分的简写 %B 月份的全称 %c 标准的日期的时间串 %C 年份的后两位数字 %d 十进制表示的每月的第几天 %D 月/天/年 %e 在两字符域中，十进制表示的每月的第几天 %F 年-月-日 %g 年份的后两位数字，使用基于周的年 %G 年分，使用基于周的年 %h 简写的月份名 %H 24小时制的小时 %I 12小时制的小时 %j 十进制表示的每年的第几天 %m 十进制表示的月份 %M 十时制表示的分钟数 %n 新行符 %p 本地的AM或PM的等价显示 %r 12小时的时间 %R 显示小时和分钟：hh:mm %S 十进制的秒数 %t 水平制表符 %T 显示时分秒：hh:mm:ss %u 每周的第几天，星期一为第一天 （值从0到6，星期一为0） %U 第年的第几周，把星期日做为第一天（值从0到53） %V 每年的第几周，使用基于周的年 %w 十进制表示的星期几（值从0到6，星期天为0） %W 每年的第几周，把星期一做为第一天（值从0到53） %x 标准的日期串 %X 标准的时间串 %y 不带世纪的十进制年份（值从0到99） %Y 带世纪部分的十制年份 %z，%Z 时区名称，如果不能得到时区名称则返回空字符。 %% 百分号
2、主要time生成方法以及time格式转换方法实例
# -*- coding:utf-8 -*- import time # ①生成timestamp时间戳 time.time() # 1477471508.05 # ②生成struct_time时间元组 time.localtime() # time.struct_time(tm_year=2022, tm_mon=2, tm_mday=14, tm_hour=20, tm_min=47, tm_sec=43, tm_wday=0, tm_yday=45, tm_isdst=0) # ③生成format_time格式化时间 time.strftime("%Y-%m-%d %X") # 或者 time.strftime("%Y-%m-%d %H:%M:%S") # 2022-02-14 20:55:48 # ④struct_time时间元组 to timestamp时间戳 time.mktime(time.localtime()) # 1644843166.0 # ⑤timestamp时间戳 to struct_time时间元组 time.localtime(time.time()) # time.struct_time(tm_year=2016, tm_mon=10, tm_mday=26, tm_hour=16, tm_min=45, tm_sec=8, tm_wday=2, tm_yday=300, tm_isdst=0) # ⑥timestamp时间戳 to struct_time时间元组 格林威治时间(gmtime() 函数将一个时间戳转换为UTC时区（0时区）的struct_time，可选的参数sec表示从1970-1-1以来的秒数。其默认值为time.time()，函数返回time.struct_time类型的对象。) time.gmtime() # time.struct_time(tm_year=2022, tm_mon=2, tm_mday=14, tm_hour=12, tm_min=54, tm_sec=17, tm_wday=0, tm_yday=45, tm_isdst=0) time.gmtime(time.time()) # time.struct_time(tm_year=2016, tm_mon=10, tm_mday=26, tm_hour=8, tm_min=45, tm_sec=8, tm_wday=2, tm_yday=300, tm_isdst=0) # ⑦format_time格式化时间 to struct_time时间元组 time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X') # time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, tm_wday=3, tm_yday=125, tm_isdst=-1) # ⑧struct_time时间元组 to format_time格式化时间 time.strftime("%Y-%m-%d %X", time.localtime()) # 2016-10-26 16:48:41 # ⑨生成固定格式的时间表示格式 time.asctime(time.localtime()) # Mon Feb 14 20:57:08 2022 time.ctime(time.time()) # Wed Oct 26 16:45:08 2016
struct_time时间元组元素结构：
属性 值 tm_year（年） 比如2011 tm_mon（月） 1 - 12 tm_mday（日） 1 - 31 tm_hour（时） 0 - 23 tm_min（分） 0 - 59 tm_sec（秒） 0 - 61 tm_wday（weekday） 0 - 6（0表示周日） tm_yday（一年中的第几天） 1 - 366 tm_isdst（是否是夏令时） 默认为-1
format time格式化时间表示：
| 格式 | 含义 |
| %a | 本地（locale）简化星期名称 |
| %A | 本地完整星期名称 |
| %b | 本地简化月份名称 |
| %B | 本地完整月份名称 |
| %c | 本地相应的日期和时间表示 |
| %d | 一个月中的第几天（01 - 31） |
| %H | 一天中的第几个小时（24小时制，00 - 23） |
| %I | 第几个小时（12小时制，01 - 12） |
| %j | 一年中的第几天（001 - 366） |
| %m | 月份（01 - 12） |
| %M | 分钟数（00 - 59） |
| %p | 本地am或者pm的相应符 |
| %S | 秒（01 - 61） |
| %U | 一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。 |
| %w | 一个星期中的第几天（0 - 6，0是星期天） |
| %W | 和%U基本相同，不同的是%W以星期一为一个星期的开始。 |
| %x | 本地相应日期 |
| %X | 本地相应时间 |
| %y | 去掉世纪的年份（00 - 99） |
| %Y | 完整的年份 |
| %Z | 时区的名字（如果不存在为空字符） |
| %% | ‘%’字符 |
常见结构化时间组合：
print time.strftime("%Y-%m-%d %X") #2016-10-26 20:50:13
3、时间加减:
#timestamp加减单位以秒为单位 import time
t1 = time.time() t2 = t1 + 10 print time.ctime(t1)#Wed Oct 26 21:15:30 2016 print time.ctime(t2)#Wed Oct 26 21:15:40 2016
4、使用strftime()与gmtime()函数将秒（时间戳）转换为时分秒
from time import strftime from time import gmtime strftime("%H:%M:%S", gmtime(5303)) # 01:28:23
5、利用mktime()函数将时间元组转换成时间戳
# coding:UTF-8 import time # 格式化时间 dt = "2023-01-01 10:30:05" # 转换成时间元组 timeArray = time.strptime(dt, "%Y-%m-%d %H:%M:%S") # 转换成时间戳 timestamp = time.mktime(timeArray) print(timestamp) # 1672540205.0
二、datetime模块
前言
①基本的日期和时间类型： datetime 模块提供了各种类用于操作日期和时间，该模块侧重于高效率的格式化时间输出。
② datetime 模块定义了两个常量：
- datetime.MINYEAR ：date对象 和 datetime 对象所能支持的最小年份，object.MINYEAR 的值为 1
- datetime.MAXYEAR ：date对象 和 datetime 对象所能支持的最大年份，object.MAXYEAR 的值为 9999
③ datetime 模块中定义的类：
- datetime.date ：表示日期的类，常用属性：year, month, day
- datetime.time ：表示时间的类，常用属性：hour, minute, second, microsecond, tzinfo
- datetime.datetime ：表示日期和时间的类，常用属性： year, month, day, hour, minute, second, microsecond, tzinfo
- datetime.timedelta ：表示时间间隔，即两个时间点（date，time，datetime）之间的长度
- datetime.tzinfo ：表示时区的基类，为上方的 time 和 datetime 类提供调整的基准
- datetime.timezone ：表示 UTC 时区的固定偏移，是 tzinfo 基类的实现
datetime 模块中常用的类：
| 类名 | 功能说明 |
|---|---|
| date | 日期对象，常用的属性有year，month，day |
| time | 时间对象 |
| datetime | 日期时间对象，常用的属性有hour，minute，second，microsecond |
| timedelta | 时间间隔，即两个时间点之间的长度 |
| tzinfo | 时区信息对象 |
参考博客：datetime 模块详解（基本的日期和时间类型）
1、date类[datatime是一个python模块，data是datatime模块中的一个类]
datetime.date(year, month, day)
静态方法和字段：
date.max、date.min：date对象所能表示的最大、最小日期；
date.resolution：date对象表示日期的最小单位。这里是天。
date.today()：返回一个表示当前本地日期的date对象；
date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；
from datetime import * import time print 'date.max:', date.max print 'date.min:', date.min print 'date.today():', date.today() print 'date.fromtimestamp():', date.fromtimestamp(time.time()) #Output====================== # date.max: 9999-12-31 # date.min: 0001-01-01 # date.today(): 2016-10-26 # date.fromtimestamp(): 2016-10-26
方法和属性:
d1 = date(2011,06,03)#date对象 d1.year、date.month、date.day：年、月、日； d1.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变） d1.timetuple()：返回日期对应的time.struct_time对象； d1.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推； d1.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推； d1.isocalendar()：返回格式如(year，month，day)的元组； d1.isoformat()：返回格式如'YYYY-MM-DD’的字符串； d1.strftime(fmt)：和time模块format相同。
from datetime import * now = date(2016, 10, 26) tomorrow = now.replace(day = 27) print 'now:', now, ', tomorrow:', tomorrow print 'timetuple():', now.timetuple() print 'weekday():', now.weekday() print 'isoweekday():', now.isoweekday() print 'isocalendar():', now.isocalendar() print 'isoformat():', now.isoformat() print 'strftime():', now.strftime("%Y-%m-%d") #Output======================== # now: 2016-10-26 , tomorrow: 2016-10-27 # timetuple(): time.struct_time(tm_year=2016, tm_mon=10, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=300, tm_isdst=-1) # weekday(): 2 # isoweekday(): 3 # isocalendar(): (2016, 43, 3) # isoformat(): 2016-10-26 # strftime(): 2016-10-26
datetime.date类的常用方法
# Python中提供了多个用于对日期和时间进行操作的内置模块：time模块、datetime模块和calendar模块。 # time模块是通过调用C库实现的，所以有些方法在某些平台上可能无法调用，但是其提供的大部分接口与C标准库time.h基本一致。 # datetime模块提供的接口更直观、易用，功能也更加强大。 import datetime import time # datetime.date类的常用方法 # datetime.date类的生成年月日格式的写法, 今日是2020-09-30 周三 ymd = datetime.date.today() print(ymd) # 2020-09-30 print(ymd.strftime('%Y-%m-%d')) # 2020-09-30 print(ymd.strftime('%Y/%m/%d')) # 2020/09/30 print(ymd.isoformat()) # 2020-09-30 默认展示这种方式 print(ymd.year, ymd.month, ymd.day) # 2020 9 30 print(ymd.replace(2020)) # 2020-09-30 print(ymd.replace(2020, 9)) # 2020-09-30 print(ymd.replace(2020, 9, 30)) # 2020-09-30 print(ymd.timetuple()) # time.struct_time(tm_year=2020, tm_mon=9, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=274, tm_isdst=-1) print(ymd.weekday()) # 2 周三属于0-6的2 print(ymd.isoweekday()) # 3 周三属于1-7的3 print(ymd.isocalendar()) # (2020, 40, 3) 第40周的第三天 ymd = datetime.date.fromtimestamp(time.time()) # 2020-09-30 print(ymd) today_ymd_str = datetime.date.today().strftime('%Y-%m-%d') today_zero_timestamp = int(time.mktime(datetime.date.today().timetuple())) print('零点字符串', type(today_ymd_str), today_ymd_str) print('零点时间戳', today_zero_timestamp) ymd_stamp = int(time.mktime(datetime.date.today().timetuple())) # 1612368000 日时间戳， datetime没有给定字符串转换为时间戳的方法还要借助time模块 print('默认生成当日时间戳', ymd_stamp) stamp = int(time.time()) ymd_str1 = datetime.date.fromtimestamp(stamp) # 2021-02-04 print('根据时间戳生成时间字符串', ymd_str1)
今日零点和某一时间节点比如9:30的字符串和时间戳转换
import datetime import time # 今日零点字符串 today_ymd_0001 = time.strftime("%Y-%m-%d") today_ymd_0002 = datetime.date.today().strftime('%Y-%m-%d') # 2021-02-04 today_ymd_0003 = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0).strftime("%Y-%m-%d") # 有year/month/day/hour/minute/second/microsecond 7个参数v print('今日0:00时间字符串: ', today_ymd_0001, today_ymd_0002, today_ymd_0003) # 今日0:00时间字符串: 2021-02-04 2021-02-04 2021-02-04 # 今日零点时间戳 today_000 = int(datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0).timestamp()) print('今日0:00时间戳: ', today_000) # 今日9:30的时间字符串 time_930_str = datetime.datetime.now().replace(hour=9, minute=30, second=0, microsecond=0).strftime("%Y-%m-%d %H:%M:%S") print('今日9:30时间字符串: ', time_930_str, type(time_930_str)) # 今日9:30的时间戳 today_930 = int(datetime.datetime.now().replace(hour=9, minute=30, second=0, microsecond=0).timestamp()) print('今日9:30的时间戳: ', today_930) # 任意字符串转换为时间戳 ymd_stamp = datetime.datetime.strptime("2015-02-28 14:19:05.512", "%Y-%m-%d %H:%M:%S.%f").timestamp() print('datetime.datetime字符串转换为时间戳', ymd_stamp)
计算多少日前的日期timedelta
''' 参数可选、默认值都为0：datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0) ''' import time import datetime today = datetime.date.today() before_year = datetime.date.today() - datetime.timedelta(days=365) before_year_stamp = int(time.mktime(time.strptime(before_year.strftime('%Y-%m-%d'), '%Y-%m-%d'))) print(today, before_year, before_year_stamp) # 2021-02-04 2020-02-05 1580832000
计算日周月年relativedelta
#!/usr/bin/env python # -*- encoding: utf-8 -*- """ """ import datetime import time from dateutil.relativedelta import relativedelta # timedelta 实现不了周月年的减法 def get_days_st_et(days): """ 获取今天之前的日期 :param days: :return: """ pre_day = datetime.date.today() - datetime.timedelta(days=days) pre_day_ts = int(time.mktime(pre_day.timetuple())) pre_day_str = pre_day.strftime("%Y-%m-%d") return pre_day_str, pre_day_ts def get_weeks_st_et(weeks): """ 获取今天之前的日期 :param months: :return: """ pre_day = datetime.date.today() - relativedelta(weeks=weeks) pre_day_ts = int(time.mktime(pre_day.timetuple())) pre_day_str = pre_day.strftime("%Y-%m-%d") return pre_day_str, pre_day_ts def get_months_st_et(months): """ 获取今天之前的日期 :param months: :return: """ pre_day = datetime.date.today() - relativedelta(months=months) pre_day_ts = int(time.mktime(pre_day.timetuple())) pre_day_str = pre_day.strftime("%Y-%m-%d") return pre_day_str, pre_day_ts def get_years_st_et(years): """ 获取今天之前的日期 :param years: :return: """ pre_day = datetime.date.today() - relativedelta(years=years) pre_day_ts = int(time.mktime(pre_day.timetuple())) pre_day_str = pre_day.strftime("%Y-%m-%d") return pre_day_str, pre_day_ts if __name__ == '__main__': # 今日时间戳 today_now = datetime.date.today() today_timestamp = int(time.mktime(today_now.timetuple())) print('今日: {}/{}'.format(today_now, today_timestamp)) # 最近一周 pre_ts, pre_str = get_days_st_et(days=2) print('最近日: {}/{}'.format(pre_ts, pre_str)) # 最近一周 week_ts, week_str = get_weeks_st_et(weeks=1) print('最近周: {}/{}'.format(week_ts, week_str)) # 最近1个月 month_ts, month_str = get_months_st_et(months=1) print('最近月: {}/{}'.format(month_ts, month_str)) # 最近一年 year_ts, year_str = get_years_st_et(years=1) print('最近年: {}/{}'.format(year_ts, year_str))
2、time类
datetime.time(hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] )
静态方法和字段
time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)， time.max = time(23, 59, 59, 999999)；
time.resolution：时间的最小单位，这里是1微秒；
方法和属性
t1 = datetime.time(10,23,15)#time对象 t1.hour、t1.minute、t1.second、t1.microsecond：时、分、秒、微秒； t1.tzinfo：时区信息； t1.replace([ hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )：创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）； t1.isoformat()：返回型如"HH:MM:SS"格式的字符串表示； t1.strftime(fmt)：同time模块中的format；
from datetime import * tm = time(23, 46, 10) print 'tm:', tm print 'hour: %d, minute: %d, second: %d, microsecond: %d' % (tm.hour, tm.minute, tm.second, tm.microsecond) tm1 = tm.replace(hour=20) print 'tm1:', tm1 print 'isoformat():', tm.isoformat() print 'strftime()', tm.strftime("%X") #Output============================================== # tm: 23:46:10 # hour: 23, minute: 46, second: 10, microsecond: 0 # tm1: 20:46:10 # isoformat(): 23:46:10 # strftime() 23:46:10
3、datetime类
datetime相当于date和time结合起来。
datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )
静态方法和字段
datetime.today()：返回一个表示当前本地时间的datetime对象； datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间； datetime.utcnow()：返回一个当前utc时间的datetime对象；#格林威治时间 datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息； datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象； datetime.combine(date, time)：根据date和time，创建一个datetime对象； datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；
from datetime import * import time print 'datetime.max:', datetime.max print 'datetime.min:', datetime.min print 'datetime.resolution:', datetime.resolution print 'today():', datetime.today() print 'now():', datetime.now() print 'utcnow():', datetime.utcnow() print 'fromtimestamp(tmstmp):', datetime.fromtimestamp(time.time()) print 'utcfromtimestamp(tmstmp):', datetime.utcfromtimestamp(time.time()) #output====================== # datetime.max: 9999-12-31 23:59:59.999999 # datetime.min: 0001-01-01 00:00:00 # datetime.resolution: 0:00:00.000001 # today(): 2016-10-26 23:12:51.307000 # now(): 2016-10-26 23:12:51.307000 # utcnow(): 2016-10-26 15:12:51.307000 # fromtimestamp(tmstmp): 2016-10-26 23:12:51.307000 # utcfromtimestamp(tmstmp): 2016-10-26 15:12:51.307000
方法和属性:
dt=datetime.now()#datetime对象 dt.year、month、day、hour、minute、second、microsecond、tzinfo： dt.date()：获取date对象； dt.time()：获取time对象； dt. replace ([ year[ , month[ , day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] ] ] ])： dt. timetuple () dt. utctimetuple () dt. toordinal () dt. weekday () dt. isocalendar () dt. isoformat ([ sep] ) dt. ctime ()：返回一个日期时间的C格式字符串，等效于time.ctime(time.mktime(dt.timetuple()))； dt. strftime (format)
4、timedelta类，时间加减
使用timedelta可以很方便的在日期上做天days，小时hour，分钟，秒，毫秒，微妙的时间计算，如果要计算月份则需要另外的办法。
#coding:utf-8 from datetime import * dt = datetime.now() #日期减一天 dt1 = dt + timedelta(days=-1)#昨天 dt2 = dt - timedelta(days=1)#昨天 dt3 = dt + timedelta(days=1)#明天 delta_obj = dt3-dt print type(delta_obj),delta_obj#<type 'datetime.timedelta'> 1 day, 0:00:00 print delta_obj.days ,delta_obj.total_seconds()#1 86400.0
5、tzinfo时区类
#! /usr/bin/python # coding=utf-8 from datetime import datetime, tzinfo,timedelta """ tzinfo是关于时区信息的类 tzinfo是一个抽象类，所以不能直接被实例化 """ class UTC(tzinfo): """UTC""" def __init__(self,offset = 0): self._offset = offset def utcoffset(self, dt): return timedelta(hours=self._offset) def tzname(self, dt): return "UTC +%s" % self._offset def dst(self, dt): return timedelta(hours=self._offset) #北京时间 beijing = datetime(2011,11,11,0,0,0,tzinfo = UTC(8)) print "beijing time:",beijing #曼谷时间 bangkok = datetime(2011,11,11,0,0,0,tzinfo = UTC(7)) print "bangkok time",bangkok #北京时间转成曼谷时间 print "beijing-time to bangkok-time:",beijing.astimezone(UTC(7)) #计算时间差时也会考虑时区的问题 timespan = beijing - bangkok print "时差:",timespan #Output================== # beijing time: 2011-11-11 00:00:00+08:00 # bangkok time 2011-11-11 00:00:00+07:00 # beijing-time to bangkok-time: 2011-11-10 23:00:00+07:00 # 时差: -1 day, 23:00:00
拓展
1、python中如何对两个时间进行大小比较
一般来说，为了方便查看和理解时间，程序代码中获取到的时间格式为format_time格式化时间。
1）将 format_time格式化时间 转为 struct_time时间元祖。然后根据年月日时分秒各数值在列表中的位置比较时间：
e = time.strptime('2022-06-23 11:07:27', '%Y-%m-%d %X') print(e) # time.struct_time(tm_year=2022, tm_mon=6, tm_mday=23, tm_hour=11, tm_min=7, tm_sec=27, tm_wday=3, tm_yday=174, tm_isdst=-1) print(list(e)) # [2022, 6, 23, 11, 7, 27, 3, 174, -1] f = time.strptime('2022-06-23 11:07:24', '%Y-%m-%d %X') print(f) # time.struct_time(tm_year=2022, tm_mon=6, tm_mday=23, tm_hour=11, tm_min=7, tm_sec=24, tm_wday=3, tm_yday=174, tm_isdst=-1) print(list(f)) # [2022, 6, 23, 11, 7, 24, 3, 174, -1]
2)将 format_time格式化时间 转为 timestame时间戳。时间戳相减得到两个时间相差的秒数，然后可以将其转为其他方便理解的时间：
c = time.mktime(time.strptime('2022-06-23 11:07:27', '%Y-%m-%d %X')) print(c) # 1655953647.0 d = time.mktime(time.strptime('2022-06-23 11:06:24', '%Y-%m-%d %X')) print(d) # 1655953584.0 print(c-d) # 63s
3)将 format_time格式化时间 转为 datetime时间 后进行时间比较。日期对象/日期时间对象是和format_time格式化时间对象显示相同，但是类型不同的时间格式：
import datetime # 日期对象比较 first_date = datetime.date(2022, 2, 22) second_date = datetime.date(2022, 3, 1) print(first_date < second_date) # True # 日期时间对象比较 first_date = datetime.datetime(2022, 2, 22, 12, 5, 0) second_date = datetime.datetime(2022, 3, 1, 12, 5, 0) print(first_date < second_date) # True # 字符串格式（先将str类型转换为datetime类型） strftime1 = datetime.datetime.strptime("2022-02-22", "%Y-%m-%d") strftime2 = datetime.datetime.strptime("2022-03-01", "%Y-%m-%d") print("日期2022-02-22大于2022-03-01：", strftime1 > strftime2) # 日期2022-02-22大于2022-03-01： False
2、计算两个日期间的天数、月数
import datetime def days(start, end): start_day = datetime.datetime.strptime(start, "%Y-%m-%d") end_day = datetime.datetime.strptime(end, "%Y-%m-%d") num = (end_day - start_day).days return num def months(start, end): start_year = datetime.datetime.strptime(start, "%Y-%m-%d").year end_year = datetime.datetime.strptime(end, "%Y-%m-%d").year start_month = datetime.datetime.strptime(start, "%Y-%m-%d").month end_month = datetime.datetime.strptime(end, "%Y-%m-%d").month num = (end_year - start_year) * 12 + (end_month - start_month) return num d = days('2022-09-16', '2023-03-01') # 1 print(d) m = months('2022-09-16', '2023-03-01') # 2 print(m)
3、将12小时制的时间转换为24小时制的时间
from datetime import datetime # 12小时制时间 time_12h_1 = '8:30 PM' time_12h_2 = '12:30 AM' time_12h_3 = '1:30 PM' time_12h_4 = '12:00 AM' # 将12小时制时间转换为24小时制时间 time_24h_1 = datetime.strptime(time_12h_1, '%I:%M %p').strftime('%H:%M') time_24h_2 = datetime.strptime(time_12h_2, '%I:%M %p').strftime('%H:%M') time_24h_3 = datetime.strptime(time_12h_3, '%I:%M %p').strftime('%H:%M') time_24h_4 = datetime.strptime(time_12h_4, '%I:%M %p').strftime('%H:%M') print(time_24h_1) # 20:30 print(time_24h_2) # 00:30 print(time_24h_3) # 13:30 print(time_24h_4) # 00:00
在上述代码中，我们从datetime模块导入datetime类。然后，我们将12小时制的时间表示为字符串'8:30 PM'，并使用strptime()函数将其转换为datetime对象。'%I:%M %p'是表示12小时制时间的格式字符串，其中%I表示小时（12小时制），%M表示分钟，%p表示上午/下午。
接下来，我们使用strftime()函数将datetime对象再次转换为字符串，这次使用'%H:%M'作为格式字符串来表示24小时制的时间。
最后，我们打印转换后的24小时制时间'20:30'。
请注意，strptime()和strftime()函数中的格式字符串中的格式符号都是区分大小写的。%I表示12小时制的小时，%H表示24小时制的小时。
或者：
def convert_24_time(str_time): if str_time[-2:] == "AM" and str_time[:2] == "12": return "00" + str_time[2:-2] elif str_time[-2:] == "AM": return str_time[:-2] elif str_time[-2:] == "PM" and str_time[:2] == "12": return str_time[:-2] else: return str_time(int(str_time[:2]) + 12) + str_time[2:8] if __name__ == '__main__': print(convert_24_time(str_time='12:35AM')) # 00:35 print(convert_24_time(str_time='12:35PM')) # 12:35
去期待陌生，去拥抱惊喜。
