python中time模块详解,python datetime 模块

　　一、时间模块介绍时间戳时间戳，表示从1970年1月1日00:00:00开始以秒为单位计算的偏移量。

　　struct_time九元素组时间元组。

　　格式化时间格式化时间，格式化的结构让时间更具可读性。包括自定义格式和固定格式。

　　1.时间格式转换图

　　2.主要时间生成方法和时间格式转换方法示例：# -*-编码：utf-8 -*-

　　导入时间

　　# 生成时间戳时间戳。

　　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)

　　# 生成格式_时间格式时间

　　time.strftime(%Y-%m-%d %X )

　　# 2022-02-14 20:55:48

　　# struct_time时间元组到时间戳时间戳

　　time.mktime(time.localtime())

　　# 1644843166.0

　　#时间戳时间戳到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)

　　#时间戳时间戳到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将时间格式化为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)

　　# 8 struct _ time时间元组到format_time格式时间

　　time.strftime(%Y-%m-%d %X ，time.localtime())

　　# 2016-10-26 16:48:41

　　#生成固定格式的时间表示格式

　　time.asctime(time.localtime())

　　# 2022年2月14日星期一20时57分08秒

　　time.ctime(time.time())

　　# wedect 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(工作日)0-6(0表示星期日)

　　Tm_yday(一年中的某一天)1-366

　　Tm_isdst(是否夏令时)默认为-1。格式化时间意味着：

　　格式

　　意义

　　%a

　　区域设置简化周名

　　%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

　　一年中的周数。星期天是一周的开始。)第一个星期日之前的所有日子都放在第0周。

　　%w

　　星期几(0-6，0是星期天)

　　%W

　　和%U基本一样，除了%W是从周一开始的。

　　%x

　　当地对应日期

　　%X

　　当地对应时间

　　%y

　　世纪之外的年份(00-99)

　　%Y

　　完整年份

　　%Z

　　时区的名称(如果不存在，则为null)

　　%%

　　“%”字符

　　常见的结构化时间组合：

　　print time.strftime(%Y-%m-%d %X )

　　#2016-10-26 20:50:133，时间加减：#时间戳加减单位是秒

　　导入时间

　　t1=time.time()

　　t2=t1 10

　　打印时间. ctime(t1)# 2016年10月26日周三21:15:30

　　print . ctime(T2)# 2016年10月26日星期三21:15:40 II。datetime模块序基本日期和时间类型：datetime模块提供了各种操作日期和时间的类，该模块侧重于高效的格式化时间输出。

　　日期时间模块定义了两个常数：

　　日期时间。MINYEAR :date对象和datetime对象支持的日期最小年份，对象的值。MINYEAR是1个日期时间。MaxYear:Date对象和Datetime对象支持的最大年份，以及对象的值。MAXYEAR是999Datetime模块中定义的类：

　　日期时间。日期：表示日期的类，常用属性：年，月，日日期时间。时间：表示时间的类，常用属性：小时，分钟，秒，微秒，tzinfodatetime.datetime:表示日期和时间的类，常用属性：年、月、日、小时、分钟、秒、微秒、tzinfodatetime.timedelta:表示时间间隔，即两个时间点（日期、时间、日期时间)之间的长度datetime.tzinfo:表示时区的基类，为上方的时间和日期时间类提供调整的基准datetime.timezone:表示协调世界时。亦称协道界时时区的固定偏移，是tzinfo基类的实现参考博客：日期时间模块详解（基本的日期和时间类型)

　　1、日期类[数据时间是一个大蟒模块，数据是数据时间模块中的一个类]日期时间.日期(年、月、日)

　　静态方法和字段：

　　date.max、date.min:日期对象所能表示的最大、最小日期；

　　日期。解决方法：日期对象表示日期的最小单位。这里是天。

　　日期。今天():返回一个表示当前本地日期的日期对象；

　　date . from时间戳(时间戳):根据给定的时间戮，返回一个日期对象；从日期时间导入*

　　导入时间

　　打印"最大日期：",最大日期

　　打印"日期。分钟：",日期。分钟

　　打印date.today():，date.today()

　　打印date.fromtimestamp():，date.fromtimestamp(time.time())

　　#Output======================

　　# date.max: 9999-12-31

　　#日期：分钟：0001-01-01

　　# date.today(): 2016-10-26

　　#日期。fromtimestamp():2016-10-26方法和属性：

　　d1=日期(2011年06月03日)#日期对象

　　d1。年、月、日：年、月、日；

　　d1 .替换(年、月、日):生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。(原有对象仍保持不变)

　　d1.timetuple():返回日期对应的时间结构时间对象；

　　d1.weekday():返回工作日，如果是星期一，返回0;如果是星期2,返回1,以此类推；

　　d1.isoweekday():返回工作日，如果是星期一，返回1;如果是星期2,返回2,以此类推；

　　d1.isocalendar():返回格式如（年、月、日)的元组；

　　d1.isoformat():返回格式如年-月-日的字符串；

　　d1.strftime(fmt):和时间模块格式相同从日期时间导入*

　　现在=日期(2016,10,26)

　　明天=现在。替换（第27天)

　　打印现在：,现在，,明天：,明天

　　打印timetuple():，now.timetuple()

　　打印weekday():，now.weekday()

　　打印isoweekday():，now.isoweekday()

　　打印isocalendar():，now.isocalendar()

　　打印isoformat():，now.isoformat()

　　打印strftime():，now.strftime(%Y-%m-%d )

　　# Output========================

　　#现在：2016-10-26,明天：2016-10-27

　　# time tuple():时间。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日期时间。日期类的常用方法# Python中提供了多个用于对日期和时间进行操作的内置模块：时间模块、日期时间模块和日历模块。

　　#时间模块是通过调用C库实现的，所以有些方法在某些平台上可能无法调用，但是其提供的大部分接口与C标准库时间。h基本一致。

　　#日期时间模块提供的接口更直观、易用，功能也更加强大。

　　导入日期时间

　　导入时间

　　#日期时间。日期类的常用方法

　　#日期时间。日期类的生成年月日格式的写法，今日是2020-09-30 周三

　　ymd=datetime.date.today()

　　印刷(ymd) # 2020-09-30

　　打印(ymd。strftime( % Y-% m-% d )# 2020-09-30

　　打印(ymd。strftime( % Y/% m/% d )# 2020/09/30

　　打印(ymd。isoformat())# 2020-09-30默认展示这种方式

　　打印(年、月、日)# 2020 9 30

　　打印(ymd.replace(2020)) # 2020-09-30

　　打印(ymd.replace(2020，9)) # 2020-09-30

　　print(ymd.replace(2020，9，30)) # 2020-09-30

　　打印(ymd。时间元组())#时间。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)

　　打印(ymd . week())# 2周三属于0-6的2

　　print(ymd.isoweekday()) # 3周三属于1-7的3

　　print(ymd.isocalendar()) # (2020，40，3)第40周的第三天

　　ymd=日期时间。约会。从时间戳(时间。时间())# 2020-09-30

　　打印(ymd)

　　今天_ ymd _ str=日期时间。约会。今天.strftime(%Y-%m-%d )

　　今天_零_时间戳=int(时间。mktime(日期时间。约会。今天.timetuple()))

　　打印(零点字符串，type(today_ymd_str)，today_ymd_str)

　　打印(零点时间戳，今天_零_时间戳)

　　ymd _ stamp=int(time。mktime(日期时间。约会。今天.timetuple())) # 1612368000日时间戳，日期时间没有给定字符串转换为时间戳的方法还要借助时间模块

　　打印(默认生成当日时间戳，ymd_stamp)

　　stamp=int(time.time())

　　ymd _ str 1=日期时间。约会。自时间戳(戳)# 2021-02-04

　　打印(根据时间戳生成时间字符串，ymd_str1)今日零点和某一时间节点比如9:30的字符串和时间戳转换导入日期时间

　　导入时间

　　# 今日零点字符串

　　today _ ymd _ 0001=时间。strftime( % Y-% m-% d )

　　today_ymd_0002=日期时间。日期。今天()。strftime( % Y-% m-% d )# 2021-02-04

　　今天_ ymd _ 0003=日期时间。日期时间。现在().替换（小时=0,分钟=0,秒=0,微秒=0)。strftime(%Y-%m-%d) #有年/月/日/小时/分钟/秒/微秒七个参数v

　　打印(今日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(日期时间。日期时间。现在().替换（小时=0,分钟=0,秒=0,微秒=0)。时间戳())

　　打印(今日0:00时间戳： ，today_000)

　　# 今日9:30的时间字符串

　　time _ 930 _ str=日期时间。日期时间。现在().替换（小时=9,分钟=30,秒=0,微秒=0)。strftime(%Y-%m-%d %H:%M:%S )

　　打印(今日9:30时间字符串： ,时间_ 930 _字符串，类型（时间_ 930 _字符串))

　　# 今日9:30的时间戳

　　today _ 930=int(日期时间。日期时间。现在().替换（小时=9,分钟=30,秒=0,微秒=0)。时间戳())

　　打印(今日9:30的时间戳： ，today_930)

　　# 任意字符串转换为时间戳

　　ymd _ stamp=日期时间。日期时间。strptime( 2015-02-28 14:19:05.512 ， %Y-%m-%d %H:%M:%S.%f ).时间戳()

　　打印(日期时间.日期时间字符串转换为时间戳，ymd_stamp)计算多少日前的日期时间增量

　　参数可选、默认值都为0:datetime.timedelta(天=0,秒=0,微秒=0,毫秒=0,分钟=0,小时=0,周=0)

　　导入时间

　　导入日期时间

　　今天=日期时间。日期。今天()

　　before _ year=日期时间。约会。今天()-日期时间。时间增量(天数=365)

　　before _ year _ stamp=int(time。mktime(时间。strptime(before _ year。strftime( %Y-%m-%d )， %Y-%m-%d ))

　　打印（今天，年前，年前戳)

　　# 2021-02-04 2020-02-05 1580832000计算日周月年relativedelta#！/usr/bin/env python

　　# -*-编码：utf-8 -*-

　　导入日期时间

　　导入时间

　　从dateutil.relativedelta导入相对delta

　　#时间增量实现不了周月年的减法

　　def get_days_st_et(天数):

　　获取今天之前的日期

　　：参数天数：

　　：返回：

　　前一天=日期时间。约会。今天()-日期时间。时间增量(天数=天)

　　pre _ day _ ts=int(time。mktime(pre _ day。时间元组()))

　　前一天。strftime( % Y-% m-% d )

　　返回前一天字符串，前一天分时（同timesharing）

　　def get_weeks_st_et周):

　　获取今天之前的日期

　　：参数月份：

　　：返回：

　　前一天=日期时间。约会。today()-相对增量(周=周)

　　pre _ day _ ts=int(time。mktime(pre _ day。时间元组()))

　　前一天。strftime( % Y-% m-% d )

　　返回前一天字符串，前一天分时（同timesharing）

　　def get_months_st_et(月):

　　获取今天之前的日期

　　：参数月份：

　　：返回：

　　前一天=日期时间。约会。today()-相对增量(月=月)

　　pre _ day _ ts=int(time。mktime(pre _ day。时间元组()))

　　前一天。strftime( % Y-% m-% d )

　　返回前一天字符串，前一天分时（同timesharing）

　　def get_years_st_et(年):

　　获取今天之前的日期

　　：参数年：

　　：返回：

　　前一天=日期时间。约会。today()-相对增量(年=年)

　　pre _ day _ ts=int(time。mktime(pre _ day。时间元组()))

　　前一天。strftime( % Y-% m-% d )

　　返回前一天字符串，前一天分时（同timesharing）

　　if __name__==__main__ :

　　# 今日时间戳

　　今天_现在=日期时间。日期。今天()

　　today _时间戳=int(时间。mktime(today _ now。时间元组()))

　　打印(今日： {}/{}.格式（今天_现在，今天_时间戳))

　　# 最近一周

　　pre_ts，pre_str=get_days_st_et(days=2)

　　打印(最近日： {}/{}.格式（前ts，前str))

　　# 最近一周

　　week_ts，week _ str=get _ weeks _ ST _ et(weeks=1)

　　打印(最近周： {}/{}.格式(周ts，周str))

　　# 最近一个月

　　month_ts，month _ str=get _ months _ ST _ et(months=1)

　　打印(最近月： {}/{}.格式(月_ts，月_str))

　　# 最近一年

　　year_ts，year _ str=get _ years _ ST _ et(years=1)

　　打印(最近年： {}/{}.format(year_ts，year _ str)2，时间类日期时间.时间(小时[,分钟[,秒[,微秒[，tzinfo] ] ])

　　静态方法和字段

　　time.min、time.max:时间类所能表示的最小、最大时间。其中，time.min=time(0，0，0，0)，time.max=time(23，59，59，999999)；

　　时间分辨率：时间的最小单位，这里是一微秒；方法和属性

　　t1=datetime.time(10，23，15)#time对象

　　t1。小时、t1。分钟、t1。秒、t1。微秒：时、分、秒、微秒；

　　t1.tzinfo:时区信息；

　　t1.replace([小时[,分钟[,秒[,微秒[，tzinfo] ]):创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变);

　　t1.isoformat():返回型如时：分：秒格式的字符串表示；

　　t1.strftime(fmt):同时间模块中的格式；从日期时间导入*

　　tm=时间(23,46,10)

　　打印tm:，tm

　　打印小时：%d，分钟：%d，秒：%d，微秒：% d“%(时，分，秒，微秒)

　　tm1=tm.replace(小时=20)

　　打印" tm1:"，tm1

　　打印isoformat():，tm.isoformat()

　　print strftime()，tm.strftime(%X )

　　# Output===================================

　　# tm: 23:46:10

　　#小时：23分钟：46秒：10微秒：0

　　# tm1: 20:46:10

　　# isoformat(): 23:46:10

　　# strftime() 23:46:103，日期时间类日期时间相当于日期和时间结合起来。

　　日期时间.日期时间(年、月、日[、小时[、分钟[、秒[、微秒[、tzinfo] ])

　　静态方法和字段

　　datetime.today():返回一个表示当前本地时间的日期时间对象；

　　datetime.now([tz]):返回一个表示当前本地时间的日期时间对象，如果提供了参数tz，则获取坦桑尼亚参数所指时区的本地时间；

　　datetime.utcnow():返回一个当前美国联合技术公司时间的日期时间对象；#格林威治时间

　　datetime.fromtimestamp(时间戳[，tz]):根据时间戮创建一个日期时间对象，参数坦桑尼亚指定时区信息；

　　datetime.utcfromtimestamp(时间戳):根据时间戮创建一个日期时间对象；

　　datetime.combine(日期，时间):根据日期和时间，创建一个日期时间对象；

　　datetime.strptime(date_string，format):将格式字符串转换为日期时间对象；从日期时间导入*

　　导入时间

　　打印datetime.max:“”，datetime.max

　　打印"日期时间。分钟：",日期时间。分钟

　　打印datetime.resolution:“”，datetime.resolution

　　打印今天():，datetime.today()

　　print now():，datetime.now()

　　打印utcnow():，datetime.utcnow()

　　打印fromtimestamp(tmstmp):，datetime。fromtimestamp(时间。时间())

　　打印utcfromtimestamp(tmstmp):，datetime。utcfromtimestamp(时间。时间())

　　#output======================

　　#日期时间。最大值：9999-12-31 23:59:59.999999

　　#日期时间。分钟：0001-01-01 00:00:00

　　#日期时间。分辨率：0:00:00.000001

　　#今日():2016-10-26 23:12:51.307000

　　# now():2016-10-26 23:12:51.307000

　　# utc now():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对象

　　年、月、日、小时、分钟、秒、微秒、tzinfo:

　　日期():获取日期对象；

　　dt.time():获取时间对象；

　　dt .替换([年[,月[,日[,小时[,分钟[,秒[,微秒[，tzinfo] ] ]):

　　dt .时间线()

　　dt .utctimetuple()

　　dt .toordinal()

　　dt .工作日()

　　dt .等日历

　　dt .等格式([ sep])

　　dt .ctime():返回一个日期时间的C格式字符串，等效于时间。ctime(时间。mktime(dt。时间元组()))；

　　dt .strftime(格式)4、时间增量类，时间加减使用时间增量可以很方便的在日期上做天天，小时小时，分钟，秒，毫秒，微妙的时间计算，如果要计算月份则需要另外的办法。

　　#编码：utf-8

　　从日期时间导入*

　　dt=datetime.now()

　　#日期减一天

　　dt1=dt时间增量（天数=-1)#昨天

　　dt2=dt -时间增量(天数=1)#昨天

　　dt3=dt时间增量（天数=1)#明天

　　delta_obj=dt3-dt

　　打印类型(delta_obj)，delta _ obj # type 日期时间。时间增量 1天，0:00:00

　　打印delta_obj.days，delta_obj。total _ seconds()# 1 86400.05、tzinfo时区类#!/usr/bin/python

　　#编码=utf-8

　　从日期时间导入日期时间、tzinfo、时间增量

　　tzinfo是关于时区信息的类

　　tzinfo是一个抽象类，所以不能直接被实例化

　　协调世界时。亦称COORDINATED UNIVERSAL TIME类(tzinfo):

　　 UTC

　　def __init__(self，offset=0):

　　自我. offset=偏移量

　　定义utcoffset(自身，dt):

　　返回时间增量（小时=自身. offset)

　　def tzname(self，dt):

　　返回UTC % s“% self”._偏移

　　def dst(self，dt):

　　返回时间增量（小时=自身. offset)

　　#北京时间

　　北京=日期时间(2011，11，11，0，0，0，tzinfo=UTC(8))

　　打印"北京时间：",北京

　　#曼谷时间

　　曼谷=日期时间(2011，11，11，0，0，0，tzinfo=UTC(7))

　　打印"曼谷时间",曼谷

　　#北京时间转成曼谷时间

　　打印"北京时间到曼谷时间："，beijing.astimezone(UTC(7))

　　#计算时间差时也会考虑时区的问题

　　北京-曼谷

　　打印时差：，timespan

　　#Output==================

　　#北京时间：2011-11-11 00:00:00 08:00

　　#曼谷时间2011年11月11日00:00:00 07:00

　　#北京-时间到曼谷-时间：2011年11月10日23:00:00 07:00

　　# 时差：-1天23:00:00

　　去期待陌生，去拥抱惊喜。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。