Python基础---全网最全time,datetime,calendar时间模块
目录
一.time时间模块
二.datetime时间模块
三.calendar模块
一.time时间模块
time模块中时间表现的格式主要有三种：
a、timestamp时间戳，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
b、struct_time时间元组，共有九个元素组。
c、format time 格式化时间，已格式化的结构使时间更具可读性。包括自定义格式和固定格式。
time格式转换图
time模块自带的所有函数如图：
下面就注意逐一解释函数功能
| 函数 | 含义 |
| time() | 时间戳，获取从1970.1.1 00:00算起到目前的秒数,可用于计算时间 |
| localtime() | 结构化时间（当地）默认将当前时间time.time()结构化,返回一个struct_time(tm_year,tm_mon,tm_mday,tm_hour,tm_min, tm_sec,tm_wday,tm_yday,tm_isdst) |
| gmtime() | 结构化时间（标准时间UTC）默认将当前时间time.time()结构化 |
| mktime() | 将结构化时间转换为时间戳 |
| strptime() | 将字符串时间转换为结构化时间time.strptime("2019-2-19 13:15:21","%Y-%m-%d %X") |
| strftime() | 将结构化时间转换为字符串时间time.strftime("%Y-%m-%d %X",time.localtime()) |
| asctime() | 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。 如果没有参数传入，将会将time.localtime()作为参数传入。 |
| ctime() | 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为 # None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。 |
| sleep() | 线程推迟指定的时间运行，单位为秒 |
| clock() | 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。 而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行 |
| clock_gettime() | 可以根据需要，获取不同要求的精确时间,提供了纳秒的精确度 |
| monotonic() | 系统从boot后到当前的时间,实际上它指的是系统启动以后流逝的时间 |
结构化时间属性图：
例子
import time
# def asctime(t: Union[_TimeTuple, struct_time] = ...) -> str: ...
# def clock() -> float: ...
# def ctime(secs: Optional[float] = ...) -> str: ...
# def gmtime(secs: Optional[float] = ...) -> struct_time: ...
# def localtime(secs: Optional[float] = ...) -> struct_time: ...
# def mktime(t: Union[_TimeTuple, struct_time]) -> float: ...
# def sleep(secs: float) -> None: ...
# def strftime(format: str, t: Union[_TimeTuple, struct_time] = ...) -> str: ...
# def strptime(string: str, format: str = ...) -> struct_time: ...
# def time() -> float: ...
t1=time.clock()
t=time.time() #时间戳，获取从1970.1.1 00:00算起到目前的秒数
print(t)
t=time.localtime(time.time()) # 结构化时间（当地）默认将当前时间time.time()结构化
print(type(t))
print(t)
print(t.tm_year)
t=time.gmtime(time.time())#3 结构化时间（标准时间UTC）默认将当前时间time.time()结构化
print(t.tm_year)
t=time.mktime(time.localtime())#4 将结构化时间转换为时间戳
print(t)
#6 将字符串时间转换为结构化时间time.strptime("2019-2-18 8:15:21","%Y-%m-%d %X")
# 参数1为字符串时间，参数2为字符串时间对应的格式
t=time.strptime('2019-2-19 8:10:40',"%Y-%m-%d %X")
print(t)
#5 将结构化时间转换为字符串时间time.strftime("%Y-%m-%d %X",time.localtime())
# 参数1为时间格式，参数2为time.localtime()
t = time.strftime("%Y-%m-%d %X",time.localtime())
print(t)
#7 asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。
# 如果没有参数，将会将time.localtime()作为参数传入。
t=time.asctime(time.localtime(time.time()))
print(t)
t=time.asctime((2019,2,18,8,10,40,0,49,-1))
print(t)
#8 ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为
# None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
t=time.ctime()
print(t)
# 线程推迟指定的时间运行，单位为秒。
time.sleep(1)
# 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。
# 而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行
t2=time.clock()
print(t2-t1)
二.datetime时间模块
该模块分为datetime，date，time，timedelta四个大模块
下面分别来讲解各个模块的函数
| 函数 | 说明 |
| today() | 获取当前日期和时间 |
| strftime() | 格式化日期时间 |
| date() | 将日期时间转为日期 |
| time() | 将日期时间转为时间 |
| timestamp() | 将日期时间转为时间戳 |
| now() | 同today |
| utcnow() | UTC日期和时间 |
| fromtimestamp() | 时间戳转为datetime |
| utcfromtimestamp() | 时间戳转为UTCdatetime |
| fromordinal() | 公历序数日期 |
| strptime() | 解析时间格式 |
| date() | 转为date => date() |
| time () | 转为time => time() |
| timestamp() | 转为时间戳 |
| timetuple() | 转为 struct_time |
| utctimetuple() | 转为utc_time |
| replace() | 时间替换 |
| toordinal () | 公历序数 |
| weekday() | 周几 (0:周日) |
| isoweekday() | 周几 (1:周一) |
| isocalendar() | 返回日历年月日 |
| isoformat(sep) | 格式化, sep为时间和日期分隔符 |
| ctime() | 格式化 |
| strftime() | 格式化 |
| combine() | 返回date.year, date.month, date.day, time.hour, time.minute, time.second, time.microsecond |
| timetz() | 转为time() |
| 剩下零散的方法自己查文档 | 剩下零散的方法自己查文档 |
例子
import datetime
# === datetime ===
# datetime 可做字典的键。所有datetime都为True
# year年[MINYEAR, MAXYEAR] / month月[1, 12] / day日[1, 给定年月的最大天数] / hour时[0, 24) / minute[0. 60) / second秒[0, 60) / microsecond微秒[0, 1000000)
# datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
# 类方法
date_time = datetime.datetime.today() # 当前本地日期时间 => datetime(2017, 5, 6, 17, 51, 59, 124232)
date_time = datetime.datetime.now() # 同today
date_time = datetime.datetime.utcnow() # UTC日期和时间
date_time = datetime.datetime.fromtimestamp(time.time()) # 时间戳转为datetime
date_time = datetime.datetime.utcfromtimestamp(time.time()) # 时间戳转为UTCdatetime
date_time = datetime.datetime.fromordinal(21) # 公历序数日期
date_time = datetime.datetime.strptime('Tue Jan 01 00:00:00 2008', '%a %b %d %H:%M:%S %Y') # 解析
print(date_time)
# 实例方法
date = date_time.date() # 转为date => date(2019, 2,19)
time = date_time.time() # 转为time => time(19, 2, 19, 149016)
time_s = date_time.timestamp() # 转为时间戳
struct_time = date_time.timetuple() # 转为 struct_time
struct_time = date_time.utctimetuple()# 转为 utc_time
# replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]]) // 替换
date_time = date_time.replace(year=2017) # => datetime(2018, 5, 6, 19, 10, 46, 149016)
num = date_time.toordinal() # 公历序数
print(str(num)+"------------")
num = date_time.weekday() # 周几 (0:周日)
num = date_time.isoweekday() # 周几 (1:周一)
year, week, weekday = date_time.isocalendar() # (year, week, weekday(1:星期一))
datetime_str = date_time.isoformat(sep='T') # 格式化, sep时间和日期分隔符 => '2017-05-06T19:10:46.149016'
datetime_str = date_time.ctime() # 格式化
datetime_str = date_time.strftime("%Y-%m-%d-%H-%M-%S") # 格式化| 函数 | 说明 |
| max | 最大时间 |
| min | 最早时间 |
| hour | 小时 |
| minute | 分钟 |
| second | 秒钟 |
| microsecond | 微秒钟 |
| isoformat() | 格式化 |
| tzname() | 获得时区名 |
| dst() | 返回DST偏移 |
| replace() | 替换 |
| tzinfo() | 与时区有关的相关信息 |
例子
import datetime
# === time ===
# time可做字典的键, time视为True
# Time表示一天中的本地时间,独立于任何特定的日子
# hour时[0, 24) minute分[0, 60) second秒[0, 60) microsecond微秒[0, 1000000)
# datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
time = datetime.time(18, 30, 59)
time_t = time.min # 最早 => time(0, 0)
time_t = time.max # 最晚 => time(23, 59, 59, 999999)
time_t = time.resolution # 最小差值 => timedelta(0, 0, 1)
num = time.hour
num = time.minute
mum = time.second
mum = time.microsecond
# replace([hour[, minute[, second[, microsecond[, tzinfo]]]]])
time_t = time.replace(hour=17) # 替换
time_s = time.isoformat() # 格式化 => '18:30:59'
time_s = time.strftime("%H-%M-%S") # 格式化
time_d = time.tzname()
| 函数 | 说明 |
| fromtimestamp() | 时间戳转为datetime |
| today() | 当前日期 |
| fromordinal() | 公历序数 |
| year | 年 |
| month | 月 |
| day | 日 |
| ctime() | 格式化 |
| strftime() | 格式化 |
| isoformat() | 格式化为‘YYYY-MM-DD’格式 => |
| toordinal() | date在公历日历中的序数 (从date.min开始数) |
| replace() | 提换 |
| weekday() | 周几 |
| isocalendar() | 返回年, 周数, 周几 |
| isoweekday() | 周几 |
例子
import datetime
# === date ===
# date 可做字典的键, 所有date对象被为True
# year年[MINYEAR, MAXYEAR] / month月[1, 12] / day日[1, 给定年月的最大天数]
# date(year, month, day) # 公历日历中的日期, 两个方向上无限延伸
date = datetime.date(2019, 2, 19)
date = date.min # 最早日期 => date(1, 1, 1)
date = date.max # 最晚日期 => date(9999, 12, 31)
timedelta = date.resolution # 不相等日期之间最小差异 (1天) => timedelta(1)
date_year = date.year # year年 [MINYEAR, MAXYEAR]
date_month = date.month # month月 [1, 12]
date_day = date.day # day日 [1, 给定年月的最大天数]
date = datetime.date.today() # 当前本地日期 (类方法) => date(2019, 2, 18)
date = datetime.date.fromtimestamp(time.time()) # 将时间戳转为日历 (类方法) => date(2019, 2, 18)
date = datetime.date.fromordinal(12) # 返回公历序数日期 (类方法) => date(1, 1, 12)
# 计算
date = date + timedelta # 加 => date(2019, 2, 20)
date = date - timedelta
timedelta = date - timedelta # 日历相减 => timedelta(1)
# replace(year=None, month=None, day=None)
date = date.replace(day=12) # 替换 => date(2019, 2, 18)
num = date.toordinal() # date在公历日历中的序数 (从date.min开始数)
num = date.weekday() # 周几 (0:周日)
num = date.isoweekday() # 周几 (1:周一)
year, week, weekday = date.isocalendar() # 返回年, 周数, 周几 (year, week, weekday) (注:weekday == isoweekday)
date_str = date.isoformat() # 格式化为‘YYYY-MM-DD’格式 => '2017-05-06'
date_str = date.ctime() # 格式化为日期格式 => 'Sat May 6 00:00:00 2017' (注:时分秒均为0, 下同)
date_str = date.strftime("%Y-%m-%d-%H-%M-%S") # 格式化为指定格式
| 函数 | 说明 |
| total_seconds() | 计算时间差的总秒数 |
| days | 获得设置提前天数 |
| seconds | 获得设置提前秒数 |
| microseconds | 获得设置提前微秒数 |
import datetime
datetime_dt = datetime.datetime.today() # 获取当前日期和时间
datetime_str= datetime_dt.strftime("%y /%m") # 格式化日期时间
print(datetime_str)
t_delta=datetime.timedelta(hours=-3)# 时间间隔
datetime_pre = datetime_dt + t_delta # # 将时间提前3小时
print(datetime_pre.ctime())
# 将日期时间转为日期
date = datetime_dt.date()
print("现在是 {}年 {}月 {}日".format(date.year, date.month, date.day))
# 将日期时间转为时间
t = datetime_dt.time()
print("现在是 {}".format(t.isoformat()))
# 将日期时间转为时间戳
t = datetime_dt.timestamp()
print("现在的时间戳: {}".format(t))
# === timedelta ===
# 内部只存储: days日[-999999999, 999999999) / seconds秒 [0, 86399) / microseconds微秒(1E-6秒)[0, 999999)
# milliseconds毫秒(1‰秒)[ == 1000 * microseconds ] / minutes分[ == 60 * seconds] / hours时[ == 3600 * seconds] / weeks周期[ == 7 * days]
# timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0) // 表示时间的间隔
timedelta_temp = datetime.timedelta(seconds=60, minutes=59, hours=23)
date_temp = datetime.date.today() - datetime.timedelta(1)
print("提前一天时间{}".format(date_temp))
#
timedelta = datetime.timedelta(1)
time_total = timedelta.total_seconds() # 计算时间差的总秒数 ( => 86400.0 )
print("一天的时间秒数{}s".format(time_total))
# 计算
boolean = timedelta == timedelta_temp # 时间是否相等 => True
timedelta = timedelta + timedelta_temp # 加上 => timedelta(2)
timedelta = timedelta - timedelta_temp # 减去 => timedelta(1)
timedelta = timedelta * 10 # 乘以 => timedelta(10)
timedelta = timedelta * 0.01 # 乘以浮点数 => timedelta(0, 864)
fnum = timedelta / timedelta_temp # 除以 => 1.0
num = timedelta // timedelta_temp # 商(delta / 整数)(不能除以0) => 1
timedelta = timedelta % timedelta_temp # 余数 => timedelta(0)
num, time_delta = divmod(timedelta, timedelta_temp) # (商, 余数) => (1, datetime.timedelta(0))
timedelta = +timedelta # 内存地址引用(没用)
timedelta = -timedelta # 取反 => timedelta(-1)
timedelta = abs(time_delta) # 绝对值
strs = str(time_delta) # 格式化为[D day[s], ][H]H:MM:SS[.UUUUUU]字符串 => '1 day, 0:00:00'
strs = repr(time_delta) # 格式化为datetime.timedelta(D[, S[, U]])字符串 => 'datetime.timedelta(1)'
datetime模块终于讲完了，泪~~~~~~~~这里说明一下，以上四个小模块有很大的相关关系，很多属性都是相识的，大家使用时查文档就行，不需要记住！！！！！
三.calendar模块
calendar模块包含了Calendar，TextCalendar，HTMLCalendar三个模块
| 函数 | 说明 |
| iterweekdays() | 迭代器,一周的星期数字 => 0 1 2 3 4 5 6 |
| itermonthdates() | 迭代器, x年x月中所有天 ==》2019-2-1 ... |
| itermonthdays2() | 迭代器, x年x月中所有(日,星期) => (1, 0) (2, 1) (3, 2) ... |
| itermonthdays() | 迭代器, x年x月中的所有天 => 1 2 3 ... |
| monthdatescalendar() | 迭代器, x年x月中data(年,月,日)对象 => date(2019, 5, 1) date(2019, 5, 2) ... |
| monthdays2calendar() | 迭代器, x年x月中(日,星期)的周列表 => [(1, 0), (2, 1) ...] [ ... ] ... |
| monthdayscalendar() | 迭代器, x年x月中日的周列表 => [1,2,3 ...] [...] ... |
| yeardatescalendar() | x年所有data(年,月,日)对象的月列表 |
| yeardays2calendar() | x年所有(日,星期)的月列表 |
| yeardayscalendar() | x年所有日的月列表 |
| getfirstweekday | 获取每周第一个工作日 |
| setfirstweekday | 设置每周开始的工作日(默认:0周一,6周日),如设置星期天为第一个工作日(calendar.SUNDAY |
例子
import calendar
def calendar_func():
'''
日历相关的操作
默认星期一作为一周的第一天, 可设置
'''
# === Calendar ===
# Calendar(firstweekday=0) // Calendar对象 firstweekday:一周的第一天,0周一(默认),6周日
calen = calendar.Calendar()
calen_iter = calen.iterweekdays() # 迭代器,一周的星期数字 => 0 1 2 3 4 5 6
calen_iter = calen.itermonthdates(2017, 5) # 迭代器, x年x月中所有天 => 2017-05-01 2017-05-02 017-05-03 ...
calen_iter = calen.itermonthdays2(2017, 5) # 迭代器, x年x月中所有(日,星期) => (1, 0) (2, 1) (3, 2) ...
calen_iter = calen.itermonthdays(2017, 5) # 迭代器, x年x月中的所有天 => 1 2 3 ...
calen_iter = calen.monthdatescalendar(2017, 5) # 迭代器, x年x月中data(年,月,日)对象 => date(2017, 5, 1) date(2017, 5, 2) ...
calen_iter = calen.monthdays2calendar(2017, 5) # 迭代器, x年x月中(日,星期)的周列表 => [(1, 0), (2, 1) ...] [ ... ] ...
calen_iter = calen.monthdayscalendar(2017, 5) # 迭代器, x年x月中日的周列表 => [1,2,3 ...] [...] ...
calen_lists = calen.yeardatescalendar(2017, width=3) # x年所有data(年,月,日)对象的月列表
calen_lists = calen.yeardays2calendar(2017, width=3) # x年所有(日,星期)的月列表
calen_lists = calen.yeardayscalendar(2017, width=3) # x年所有日的月列表
calendar_func()
| 函数 | 说明 |
| formatmonth() | x年x月所有日 |
| formatyear() | x年所有日 |
| formatweek() | 第几周的第几天是星期几==》参数为可迭代对象((a,b)...)表示第啊周第b天是星期几 |
| pryear() | 打印 x年所有日 |
| prmonth() | 打印x年x月所有日 |
| prweek() | 打印x周所有日 |
| 该类继承 了Calendar |
拥有Calendar的所有公共方法 |
例子
import calendar
# === TextCalendar ===
# TextCalendar(firstweekday=0) // 纯文本的日历
calen_text = calendar.TextCalendar()
calen_str = calen_text.formatmonth(2019, 2, w=0, l=0) # x年x月所有日
print(calen_str)
calen_text.prmonth(2019, 2, w=0, l=0) # (打印) x年x月所有日
calen_str = calen_text.formatyear(2019, w=2, l=1, c=6, m=3) # x年所有日
calen_text.pryear(2019, w=2, l=1, c=6, m=3) # (打印) x年所有日| 函数 | 说明（html格式输出） |
| formatmonth() | 返回x年x月所有日表格行 |
| formatyear() | 返回x年所有日表格行 |
| formatweek() | 返回第几周的第几天是星期几==》参数为可迭代对象((a,b)...)表示第啊周第b天是星期几表格行 |
| formatyearpage() | 返回 x年所有日表格行 |
| formatweekheader() | 返回一周的表格行 |
| formatmonthname() | 返回某年某月的表格行 |
| formatweekday() | 返回每周的星期几表格行 |
例子
import calendar
calen_html = calendar.HTMLCalendar()
print(calen_html.formatweekday(5))#返回每周的星期几表格行
print(calen_html.formatweek(((3,6),(2,4))))#返回第几周的第几天是星期几==》参数为可迭代对象((a,b)...)表示第啊周第b天是星期几
print(calen_html.formatweekheader())#返回一周的表格行
print(calen_html.formatmonthname(2019,2))#返回某年某月的表格行月
calen_str = calen_html.formatmonth(2017, 5, withyear=True) # x年x月的所有日
calen_str = calen_html.formatyear(2017, width=3) # x年所有日
calen_str = calen_html.formatyearpage(2017, width=3, css='calendar.css', encoding=None) # (完整编码) x年所有日
print(calen_str)补充
| 函数 | 说明 |
| setfirstweekday() | 设置每周开始的工作日(默认:0周一,6周日),如设置星期天为第一个工作日(calendar.SUNDAY) |
| firstweekday() | 返回每周的第一天的星期 |
| isleap() | x年是否为闰年 |
| leapdays() | x年到y年的闰年数 |
| weekday() | x年x月x日的星期几 |
| weekheader() | 根据输入的名字长度返回7天星期X的缩写情况 |
| monthrange() | x年x月 (星期, 月天数) |
| monthcalendar() | x年x月的月历 |
| prmonth() | x年x月的日历 |
| month() | 月历 |
| prcal() | (打印) 整年日历 |
| calendar() | 整年日历 |
| timegm() | 时间元组 转为 时间戳 |
| timegm() | 时间元组 转为 时间戳 |
| day_name | 迭代器, 星期E名称 |
| day_abbr | 迭代器, 星期E缩写名称 |
| month_name | 迭代器, 月E名称 |
| month_abbr | 迭代器, 月E缩写名称 |
泪~~~~~~~~~~花了半天时间终于把时间模块终于写完了！！
加油！！！
