Python学习系列 -初探标准库之time和datetime模块

最新推荐文章于 2024-08-29 10:04:09 发布

需要休息的KK.

最新推荐文章于 2024-08-29 10:04:09 发布

阅读量560

点赞数 15

分类专栏：标准库探索文章标签： python 学习开发语言 pycharm 个人开发程序人生自动化

本文链接：https://blog.csdn.net/weixin_54217348/article/details/136307399

版权

标准库探索专栏收录该内容

9 篇文章 0 订阅

订阅专栏

系列文章目录

第一章初始 Python
第二章认识 Python 变量、类型、运算符
 第三章认识条件分支、循环结构
 第四章认识 Python的五种数据结构
 第五章认识 Python 函数、模块
 第六章认识面向对象三大特性
 第七章初探标准库之os库
 第八章初探标准库之pathlib库
 第九章初探标准库之Shutil库
 第十章初探标准库之re库
第十一章初探标准库之time和datetime库

文章目录

文章开篇

Python的魅力，犹如星河璀璨，无尽无边；人生苦短、我用Python！

Python其强大的标准库和丰富的第三方库，恰似一片生机勃勃的森林，为开发者们提供了源源不断的资源和支持；
在这片广袤的“森林”中，隐藏着许多Python标准库中的珍贵模块，如os、sys、re等；它们如同森林中的璀璨明珠，熠熠生辉，为开发者的工作提供着不可或缺的支持；
在Python的生态系统中，有许多备受赞誉的第三方库，如NumPy、Pandas、openpyxl、requests、selenium、pyqt等，这些库如同森林中的珍稀物种，以其独特的功能和卓越的性能，助力开发者们更高效地完成工作;
无论是处理字符串、读写文件这样的基础任务，还是并发编程、数据分析等高级挑战，Python的标准库和三方库都能应对自如，满足各种需求；

文章简介

时间和日期无疑是生活各个方面中最关键的因素之一，因此，记录和跟踪它们变得非常重要；
在软件开发中涉及到时间和日期的场景极为广泛，在Python中主要有time模块和datetime模块；
本文将详尽地探讨Python中的time和datetime模块，揭示它们的内涵，展示如何利用它们执行时间操作和日期处理，并提供丰富的示例代码以及实际应用案例；

时间日期常用格式化代码

参数取值	取值解释	取值范围
%y	两位数的年份表示	00-99
%Y	四位数的年份表示	000-9999
%m	月份	01-12
%d	月中的一天	01-31
%H	24小时制小时数	00-23
%l	12小时制小时数	01-12
%M	分钟数	00-59
%S	秒	00-59
%f	微秒	0-999999
%p	返回上午还是下午	AM; PM
%j	返回当天是当年的第几天	001-366
%w	返回当周是当年的第几周，以周一为第一天	01-52

time模块

time模块用于处理时间，包括获取当前时间、时间的计算、格式化、时间静止等操作；
它以Unix时间戳的形式表示时间，即从1970年1月1日午夜（UTC）以来的秒数；
time模块适用于处理时间的精确度要求不高的情况。

方法	描述
time()	从 Unix 纪元开始到当前时间的秒数
ctime()	以经过的秒数作为参数，返回当前日期和时间
sleep()	在给定的持续时间内停止线程的执行
localtime()	以struct_time格式返回日期和时间
gmtime()	与localtime()类似，返回时间。UTC格式的struct_time
mktime()	ocaltime()的倒数。获取包含9个参数的元组，并返回自epoch pas输出以来经过的秒数
asctime()	获取包含9个参数的元组，并返回表示相同参数的字符串
strftime()	获取包含9个参数的元组，并根据使用的格式代码返回表示相同参数的字符串
strptime()	分析字符串并及时返回。struct_time格式

时间戳，时间元组和时间格式化三者之间的转换如下图：

在这里插入图片描述

struct_time对象具有以下属性

属性	范围
tm_year	0000, …, 2019, …, 9999
tm_mon	1-12
tm_mday	1-31
tm_hour	0-23
tm_min	0-59
tm_sec	0-59
tm_wday	0-6 (从0开始，0代表周一，6代表周日)
tm_yday	1-366
tm_isdst	是否为夏令时制时间，0:否，1:是，-1:未知

time模块方法示例

import time

# time()方法示例
# 返回当前时间的时间戳（从 Unix 纪元开始到当前时间的秒数）
print("从 Unix 纪元开始到当前时间的秒数：", time.time())  # 从 Unix 纪元开始到当前时间的秒数： 1708916427.194825


# ctime()方法示例
# 将一个时间戳转换为一个可读的字符串，该字符串表示本地时间
timestamp = time.time()
ctime_string = time.ctime(timestamp)
print(f"以可读格式表示的当前时间: {ctime_string}")   # Mon Feb 26 12:3:33 2024


# sleep()方法示例
# 暂停程序执行指定的秒数
print("开始...")
time.sleep(5)  # 暂停5秒
print("结束...")


# localtime()方法示例
# 将时间戳转换为本地时间，返回一个 time.struct_time 对象
local_time = time.localtime()
print(type(local_time), local_time)  # <class 'time.struct_time'> time.struct_time(tm_year=2024, tm_mon=2, tm_mday=26, tm_hour=12, tm_min=10, tm_sec=3, tm_wday=0, tm_yday=57, tm_isdst=0)
print("年：", local_time.tm_year)     # 年： 2024
print("月：", local_time.tm_mon)      # 月： 2
print("日：", local_time.tm_mday)     # 日： 26
print("时：", local_time.tm_hour)     # 时： 12
print("分：", local_time.tm_min)      # 分： 4
print("秒：", local_time.tm_sec)      # 秒： 32
print("周：", local_time.tm_wday)     # 周： 0（0-6，0是周一）
print("一年当中的第几天：", local_time.tm_yday)  # 一年当中的第几天： 57
print("是否为夏令时制：", local_time.tm_isdst)  # 0（0：否，1：是，-1：未知）


# gmtime()方法示例
# 将一个时间戳转换为一个 time.struct_time 对象，表示UTC时间（即格林威治标准时间
timestamp = time.time()
print(type(timestamp), timestamp)   # <class 'float'> 1708921103.8252318
gmtime_struct = time.gmtime(timestamp)
print(type(gmtime_struct), gmtime_struct)   # <class 'time.struct_time'> time.struct_time(tm_year=2024, tm_mon=2, tm_mday=26, tm_hour=4, tm_min=18, tm_sec=42, tm_wday=0, tm_yday=57, tm_isdst=0)


# mktime()方法示例
# 将一个 time.struct_time 对象转换为一个时间戳
struct_time = time.struct_time((2023, 7, 6, 12, 30, 15, 0, 186, -1))
print(type(struct_time), struct_time)   # <class 'time.struct_time'> time.struct_time(tm_year=2023, tm_mon=7, tm_mday=6, tm_hour=12, tm_min=30, tm_sec=15, tm_wday=0, tm_yday=186, tm_isdst=-1)
timestamp = time.mktime(struct_time)
print(type(timestamp), timestamp)   # <class 'float'> 1688617815.0


# asctime()方法示例
# 将一个 time.struct_time 对象转换为一个可读的字符串，表示本地时间。
struct_time = time.localtime()
print(type(struct_time), struct_time)   # <class 'time.struct_time'> time.struct_time(tm_year=2024, tm_mon=2, tm_mday=26, tm_hour=12, tm_min=20, tm_sec=32, tm_wday=0, tm_yday=57, tm_isdst=0)
asctime_string = time.asctime(struct_time)
print(type(asctime_string), asctime_string) # <class 'str'> Mon Feb 26 12:20:32 2024


# strftime()方法示例
# 将 time.struct_time 对象格式化为字符串，可以按照指定格式进行
local_time = time.localtime()
formatted_time = time.strftime("%Y-%m-%d", local_time)
print(f"格式化后本地时间: {formatted_time}")    # 格式化后本地时间: 2024-02-26
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", local_time)
print(f"格式化后本地时间: {formatted_time}")    # 格式化后本地时间: 2024-02-26 12:10:51


# strptime()方法示例
# 将字符串解析为 time.struct_time 对象，需要指定字符串的格式
time_string = "2024-02-26 12:01:38"
time_struct = time.strptime(time_string, "%Y-%m-%d %H:%M:%S")
print("将字符串日期时间转换time_struct对象：", time_struct)  # 将字符串日期时间转换time_struct对象： time.struct_time(tm_year=2024, tm_mon=2, tm_mday=26, tm_hour=12, tm_min=1, tm_sec=38, tm_wday=0, tm_yday=57, tm_isdst=-1)

time模块应用案例

1.倒计时

def countdown_timer(seconds):
    """倒计时定时器函数"""
    while seconds > 0:
        mins, secs = divmod(seconds, 60)
        timer = '{:02d}:{:02d}'.format(mins, secs)
        print("倒计时：", timer)
        time.sleep(1)
        seconds -= 1
    print("倒计时结束！")

# 用户输入倒计时的秒数
try:
    countdown_seconds = int(input("请输入倒计时的秒数: "))
    countdown_timer(countdown_seconds)
    # 可以在倒计时结束后执行其他操作，比如打印消息或播放提醒声音
    print("时间到了，请执行相应的操作！")
except ValueError:
    print("请输入一个有效的数字！")

2.记录代码执行时间


def measure_execution_time(func):
    """测量函数执行时间的装饰器"""
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        elapsed_time = end_time - start_time
        print(f"函数 {func.__name__} 执行时间：{elapsed_time:.6f} 秒")
        return result
    return wrapper

@measure_execution_time
def complex_operation():
    """一个复杂的操作，例如大量计算或数据处理"""
    # 这里是一些模拟的复杂操作
    sum_result = 0
    for i in range(1000000):
        sum_result += i ** 2  # 平方计算
    return sum_result

# 调用被装饰的函数
complex_operation()

datetime模块

用于处理日期和时间的核心模块，提供了表示日期、时间、时间间隔的类和函数；

在这里插入图片描述

datetime.date类

类别	方法或属性	解释
实例属性	date.year	年份
	date.month	月份
	date.day	日份
实例方法	date.today()	返回当前日期
	date.replace(year, month, day)	依据关键字给出的新值，返回一个新的日期
	date.weekday()	返回一星期中的第几天，其中星期一是0，星期日是6
	date.isoweekday()	返回一星期中的第几天，其中星期一是1，星期日是7
	date. timetuple()	返回一个time.struct_time对象，但时间的部分值为0
	date.ctime()	返回表示日期的字符串, 如：‘Fri Dec 2 00:00:00 2022’
	date.isoformat()	返回YYYY-MM-DD格式的日期字符串, 如’2022-12-02’
	date.isocalendar()	返回一个元祖，具有属性year-年, week-一年中的第几周(1-52), weekday-这一周的第几天(1-7), 每一年年初的前几天有可能会并入上一年计算，输出为52周
操作	diff_days = (date1 - date2).days	(datetime.date.today() - datetime.date(2022, 1, 1)).days

datetime.date类的三个属性

from datetime import date

print(date.year)    # <attribute 'year' of 'datetime.date' objects>
print(date.month)   # <attribute 'month' of 'datetime.date' objects>
print(date.day)     # <attribute 'day' of 'datetime.date' objects>

datetime.date类的构造器

from datetime import date

# 根据传递的参数进行构造对象
date1 = date(2024, 12, 31)
print(type(date1), date1)           # <class 'datetime.date'> 2024-12-31

# 使用今天的日期构造对象
date_today = date.today()
print(type(date_today), date_today) # <class 'datetime.date'> 2024-02-26

date.replace(year, month, day) 依据关键字给出的新值，返回一个新的日期

from datetime import date

date_today = date.today()
replace_date = date_today.replace(2022, 2, 2)

print(type(date_today), date_today)     # <class 'datetime.date'> 2024-02-26
print(type(replace_date), replace_date) # <class 'datetime.date'> 2022-02-02

datetime.date类的星期几获取方式
isoweekday() 返回一星期中的第几天，其中星期一是1，星期日是7
weekday() 返回一星期中的第几天，其中星期一是0，星期日是6

from datetime import date

date_today = date.today()   # 2024-02-26

print("查询星期几：", date_today.isoweekday())    # 查询星期几： 1
print("查询星期几：", date_today.weekday())       # 查询星期几： 0

date.timetuple() 为了兼容time.localtime()方法返回一个time.struct_time对象；
但有关时间的部分元素值为0

from datetime import date

date_today = date.today()

print(date_today.timetuple())   # time.struct_time(tm_year=2024, tm_mon=2, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=57, tm_isdst=-1)
print(date_today.ctime())       # Mon Feb 26 00:00:00 2024

date.isoformat() 返回YYYY-MM-DD格式的字符串

from datetime import date

date_today = date.today()
date_str = date_today.isoformat()

print(type(date_str), date_str) # <class 'str'> 2024-02-26

date.isocalendar() 返回一个元祖；
具有属性year-年, week-一年中的第几周(1-52), weekday-这一周的第几天(1-7)；
每一年年初的前几天有可能会并入上一年计算，输出为52周；

from datetime import date

date_today = date.today()
calendar_date = date_today.isocalendar()

print(type(calendar_date), calendar_date)   # <class 'tuple'> (2024, 9, 1)

计算两个日期之间的天数间隔

from datetime import date

date1 = date(2024, 2, 29)
date2 = date(2024, 1, 31)
diff_days = (date1 - date2).days

print("两个日期的天数差异：", diff_days)    # 29

日期的比较

from datetime import date

date1 = date(2024, 1, 28)
date2 = date(2024, 1, 28)
date3 = date(2024, 2, 20)

# __eq__ 等于运算
print(date1 == date2)       # True
print(date1.__eq__(date2))  # True

# __gt__ 大于运算
print(date1 > date3)        # False
print(date1.__gt__(date3))  # False

# __ge__ 大于等于运算
print(date1 >= date2)       # True
print(date1.__ge__(date2))  # True

# __lt__ 小于运算
print(date2 < date3)        # True
print(date2.__lt__(date3))  # True

# __le__ 小于等于运算
print(date1 <= date3)       # True
print(date1.__le__(date3))  # True

print(date1 != date2)       # False
print(date1.__ne__(date2))  # False

datetime.time类

类别	方法或属性	解释
实例属性	time.hour	时
	time.minute	分
	time.second	秒
	time.microsecond	微秒
	time.tzinfo	时间元组
实例方法	time.replace([hour[, minute[, second[, microsecond[, tzinfo]]]]])	返回具有相同值的time
	time.isoformat()	返回以ISO 8601 格式HH:MM:SS.mmmmmm表示间的字符串

datetime.time类的属性

from datetime import time

print(time.hour)        # <attribute 'hour' of 'datetime.time' objects>
print(time.minute)      # <attribute 'minute' of 'datetime.time' objects>
print(time.second)      # <attribute 'second' of 'datetime.time' objects>
print(time.microsecond) # <attribute 'microsecond' of 'datetime.time' objects>
print(time.tzinfo)      # <attribute 'tzinfo' of 'datetime.time' objects>

datetime.time类的构造器

from datetime import time

# 默认构造器，全是0
time1 = time()
print(type(time1), time1)    # <class 'datetime.time'> 00:00:00

# 根据传递的参数进行构造对象
time2 = time(15, 15, 15)
print(time2.hour)           # 15
print(time2.minute)         # 15
print(time2.second)         # 15
print(time2.microsecond)    # 0
print(type(time2), time2)   # <class 'datetime.time'> 15:15:15
print(type(time2), time2)   # <class 'datetime.time'> 15:15:15

datetime.time.replace 方法更改时、分、秒

from datetime import time

time3 = time(15, 15, 15)

h_changed = time3.replace(hour=16)
print(type(h_changed), h_changed)   # <class 'datetime.time'> 16:15:15

m_changed = h_changed.replace(minute=16)
print(type(m_changed), m_changed)   # <class 'datetime.time'> 16:16:15

s_changed = m_changed.replace(second=16)
print(type(s_changed), s_changed)   # <class 'datetime.time'> 16:16:16

datetime.time.strftime 方法格式化时间

from datetime import time

time4 = time(15, 15, 15)

formatted_time = time4.strftime('%H:%M:%S %p')  # 使用 12 小时制表示时间
print(formatted_time)   # 15:15:15 PM

formatted_time = time4.strftime('%I:%M:%S %p')  # 使用 12 小时制表示时间
print(formatted_time)   # 03:15:15 PM

datetime.time.isoformat 获取 ISO 格式的时间字符串

from datetime import time

time5 = time(15, 15, 15)

print(time5.isoformat("hours")) # 15
print(time5.isoformat("minutes")) # 15:15
print(time5.isoformat("seconds")) # 15:15:15
print(time5.isoformat("milliseconds")) # 15:15:15.00
print(time5.isoformat("microseconds")) # 15:15:15.000000

datetime.datetime日期时间类

类别	方法或属性	解释
实例属性	year	年
	month	月
	day	日
	hour	时
	minute	分
	second	秒
	microsecond	微秒
	tzinfo	时间元祖
实例方法	datetime.now()	返回当前日期时间datetime对象
	datetime.replace()	返回具有相同属性的 datetime
	datetime.date()	返回具有相同年、月和日的date对象
	datetime.time()	返回具有相同小时、分钟、秒和微秒的time对象
	datetime.timestamp()	返回对应于datetime实例的POSIX时间戳
	datetime.weekday()	返回一星期中的第几天，其中星期一是0，星期日是6
	datetime.isoweekday()	返回一星期中的第几天，其中星期一是1，星期日是7
	datetime.isocalendar()	回一个元素，具有属性year-年, week-一年中的第几周(1-52), weekday-这一周的第几天(1-7), 每一年年初的前几天有可能会并入上一年计算，输出为52周
	datetime.ctime()	返回一个表示日期和时间的字符串

datetime.datetime类的属性

from datetime import datetime

print(datetime.year)        # <attribute 'year' of 'datetime.date' objects>
print(datetime.month)       # <attribute 'month' of 'datetime.date' objects>
print(datetime.day)         # <attribute 'day' of 'datetime.date' objects>
print(datetime.hour)        # <attribute 'hour' of 'datetime.datetime' objects>
print(datetime.minute)      # <attribute 'minute' of 'datetime.datetime' objects>
print(datetime.second)      # <attribute 'second' of 'datetime.datetime' objects>
print(datetime.microsecond) # <attribute 'microsecond' of 'datetime.datetime' objects>
print(datetime.tzinfo)      # <attribute 'tzinfo' of 'datetime.datetime' objects>

datetime.datetime类的构造器

from datetime import datetime

# 根据传递的参数进行构造对象
date_time1 = datetime(2024, 2, 26, 15, 50, 50, 123)
print(type(date_time1), date_time1) # <class 'datetime.datetime'> 2024-02-26 15:50:50.000123

# 使用当前的日期时间构造对象
date_time2 = datetime.now()
print(type(date_time2), date_time2) # <class 'datetime.datetime'> 2024-02-26 15:52:12.601106

print(date_time2.year)          # 2024
print(date_time2.month)         # 2
print(date_time2.day)           # 26
print(date_time2.hour)          # 15
print(date_time2.minute)        # 52
print(date_time2.second)        # 12
print(date_time2.microsecond)   # 601106

datetime.datetime类获取年月日时分秒周

from datetime import datetime

date_time3 = datetime.now()

date1 = date_time3.date()
print(type(date1), date1)    # <class 'datetime.date'> 2024-02-26

time1 = date_time3.time()
print(type(time1), time1)    # <class 'datetime.time'> 15:53:54.664787

time2 = date_time3.timestamp()
print(type(time2), time2)   # <class 'float'> 1708934900.001793

week1 = date_time3.isoweekday()
print(type(week1), week1)   # <class 'int'> 1

week2 = date_time3.weekday()
print(type(week2), week2)   # <class 'int'> 0

datetime.timedelta类

timedelta对象表示一个时间段，即两个日期 (date) 或日期时间 (datetime) 之间的差值；
目前支持参数:weeks、days、hours、minutes、seconds、milliseconds、microseconds；
可以进行加减乘除运算的，它的实例化方法和datetime对象很类似此类中包含如下属性：

days:天数
microseconds：微秒数(>=0并且<1秒）
seconds：秒数(>=0并且<1天）

from datetime import timedelta, datetime

now = datetime.now()
print("类型：", type(now))     # <class 'datetime.datetime'>
print("当前时间日期：", now)    # 当前时间日期： 2024-02-26 19:46:36.190050

print(now + timedelta(hours=4))         # 加上4小时，结果：2024-02-26 23:46:36.190050
print(now + timedelta(minutes=4))       # 加上4分钟，结果：2024-02-26 19:50:36.190050
print(now + timedelta(seconds=4))       # 加上4秒级，结果：2024-02-26 19:46:40.190050
print(now + timedelta(microseconds=4))  # 加上4微妙，结果：2024-02-26 19:46:36.190054
print(now + timedelta(weeks=2))     # 加上2礼拜，结果：2024-03-11 19:46:36.190050
print(now - timedelta(hours=-10))   # 减去10小时，结果：2024-02-27 05:46:36.190050
print(now - timedelta(seconds=500)) # 减去500秒，结果：2024-02-26 19:38:16.190050

# 两个时间日期对象的差值
delta = datetime(2024, 2, 26) - datetime(2024, 10, 25, 20, 30)
print(delta)                # -243 days, 3:30:00
print(delta.days)           # -243
print(delta.seconds)        # 12600
print(delta.microseconds)   # 0

真实案例封装

创建一个简单的日程提醒程序，可以添加、查看和删除日程事件，还可以设置提醒时间

from datetime import datetime

# 日程事件数据结构
schedule = []

def add_event(event, date):
    schedule.append({"event": event, "date": date})

def view_schedule():
    for item in schedule:
        print(f"事件: {item['event']}, 日期和时间: {item['date']}")

def main():
    while True:
        print("\n日程提醒程序")
        print("1. 添加事件")
        print("2. 查看日程")
        print("3. 退出")
        choice = input("请选择操作: ")

        if choice == "1":
            event = input("请输入事件名称: ")
            date_str = input("请输入日期和时间 (YYYY-MM-DD HH:MM): ")
            date = datetime.strptime(date_str, "%Y-%m-%d %H:%M")
            add_event(event, date)
            print("事件已添加!")

        elif choice == "2":
            print("\n日程安排:")
            view_schedule()

        elif choice == "3":
            break

if __name__ == "__main__":
    main()

根据当前日期时间自定义修改年、月、日、时、分、秒和格式


import datetime

from dateutil.relativedelta import relativedelta


def generate_datetime(year: int = None, month: int = None, day: int = None,
                      hour: int = None, minute: int = None, second: int = None) -> datetime:
    """
    根据当前日期时间自定义修改年、月、日、时、分、秒和格式
    :param year:    非必填项，年份控制
    :param month:   非必填项，月份控制
    :param day:     非必填项，日份控制
    :param hour:    非必填项，小时控制
    :param minute:  非必填项，分钟控制
    :param second:  非必填项，秒数控制
    :return: 默认以XXXX-XX-XX XX:XX:XX格式返回当前日期时间
    """
    # 获取当前日期时间
    current_datetime = datetime.datetime.now().replace(microsecond=0)
    if year:
        current_datetime = current_datetime + relativedelta(years=year)
    if month:
        current_datetime = current_datetime + relativedelta(months=month)
    if day:
        current_datetime = current_datetime + relativedelta(days=day)
    if hour:
        current_datetime = current_datetime + relativedelta(hours=hour)
    if minute:
        current_datetime = current_datetime + relativedelta(minutes=minute)
    if second:
        current_datetime = current_datetime + relativedelta(seconds=second)

    return current_datetime


if __name__ == '__main__':
    g_datetime = generate_datetime()
    print("默认返回：", type(g_datetime), g_datetime)  # 默认返回： <class 'datetime.datetime'> 2024-02-26 16:52:49

    g_datetime = generate_datetime(year=1, month=1, day=1, hour=1, minute=1, second=1)
    print("自定义返回：", type(g_datetime), g_datetime)   # 自定义返回： <class 'datetime.datetime'> 2025-03-27 17:53:50

    g_datetime = generate_datetime(year=-1, month=-1, day=-1, hour=-1, minute=-1, second=-1)
    print("自定义返回：", type(g_datetime), g_datetime)  # 自定义返回： <class 'datetime.datetime'> 2023-01-25 15:51:48

    print(g_datetime.strftime("%Y%m%d"))    # 20230125

总结

Python的time和datetime模块分别用于处理时间戳和基本时间操作，以及更丰富的日期和时间处理功能。结合两者，可以有效处理与时间相关的任务，包括时间测量和复杂的日期时间操作。根据需要，选择适当的模块来满足日期和时间的表示、处理和计算。

需要休息的KK.

关注

15
点赞
踩
10

收藏

觉得还不错? 一键收藏
打赏
1
评论
Python学习系列 -初探标准库之time和datetime模块

一文通晓Python的time与datetime模块，彻底告别日期时间处理的困扰。文末更有自定义修改年、月、日、时、分、秒以及格式化当前日期时间的代码封装，助你轻松应对各种时间处理需求。
复制链接

扫一扫