《Python模块与日期处理全攻略：从封装代码到玩转时间，提升开发效率的终极指南！》

第1节 自定义模块与包

1 自定义模块

什么是模块

• 循环：重复执行的代码，且有规律
• 函数：将具有独立性功能的代码进行封装，以便后续复用/调用，解耦代码
• 模块：可以定函数、类和变量、也可以包含可执行的代码。可以把模块理解为更高级的函数-复用。一般而言我们会把一系列的功能封装到模块中，方便外界调用/复用。模块可以将程序代码进行组合和封装，提高代码的可维护性和可复用性。
• 表现：一个.py文件就是一个模块。

创建模块

# my_math.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        # 抛出异常
        raise ValueError("除数不能为零")
    return a / b

导入模块

（1）在另一个Python文件中，直接导入模块

import 模块名称

# main.py
import my_math
print(my_math.add(1,3))
print(my_math.subtract(3,1))

使用别名导入（就是给模块另起名字，一旦使用别名，本身的名称就不可用）

import 模块名称 as 别名

# main.py
import my_math as mm
print(mm.add(1,3))
print(mm.subtract(3,1))

（2）直接从模块中导入需要的对象（函数、变量、类）

from 模块 import 对象,对象...

# main.py
from my_math import add, subtract,multiply,divide
print(add(1,3))
print(subtract(4,1))

好处就是可以不用通过模块名称来去调用

坏处：

• 容易混淆，到底属于模块中的内容，还是当前定义的内容
• 少量代码编写时（简单的脚本文件），但是在大型项目中，不推荐的。

# main.py
from my_math import add, subtract,multiply,divide
def add(a,b):
    return 666

print(add(1,3))
print(subtract(4,1))

（3）导入模块所有的对象

from 模块 import *

# main.py
from my_math import *

print(add(1,3))
print(subtract(4,1))

• 不推荐，理由同上

模块中__name__的属性

• 每个Python模块都有一个内置属性 __name__。当模块被直接运行时，__name__的值为__main__；当模块被导入时，__name__的值为模块名称。
• 所谓的导入模块，就是先让模块的代码跑一遍，再去执行当前代码。

# my_math.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        # 抛出异常
        raise ValueError("除数不能为零")
    return a / b

# print(__name__)

# 当直接执行my_math.py文件时 则执行下面if中的内容
# 当my_math.py被导入时，则下面if中的内容不执行
if __name__ == "__main__":
    print(f"测试：{add(1,1)}")
    print(f"测试：{subtract(1,1)}")

2 自定义包

什么是包

包是一种管理Python模块的方式，它实际上就是一个包含多个模块的目录。包目录下必须有一个__init__.py的文件，该文件就是用来标记当前目录是一个普通文件夹还是一个包。

在大型项目开发中，代码功能其实可以分为这么几类：model、view、controller、DB

创建包

创建一个名为my_package的包，目录结构：

my_package
	__init__.py
    ModelC.py
    ModelD.py

# ModelC.py
def show_modelC():
    print("show_modelC run...")

# ModelD.py
def show_modelD():
    print("show_modelD run...")

导入包中的模块

（1）相对导入

在包内，模块之间进行相互导入。【导包时，严禁相关导入，否则出现递归异常】

# ModelD.py
from . import ModelC
def show_modelD():
    print("show_modelD run...")
    ModelC.show_modelC()

（2）绝对导入

在包外，其他的模块中进行导入

# main.py
from my_package import ModelC, ModelD
ModelC.show_modelC()
ModelD.show_modelD()

__init__的作用

• 标识一个目录是Python包
• 可以在其中定义包的初始化代码：导入包中的模块，使模块在包被导入时可用。

# __init__.py
from . import ModelC
from . import ModelD

# main.py
import my_package
my_package.ModelC.show_modelC()
my_package.ModelD.show_modelD()

__init__中的__all__变量

它是一个字符串列表，指定当前使用 from 包 import *时应该导入的模块，做记录/指定导入。

# main.py
from my_package import *
ModelC.show_modelC()
ModelD.show_modelD()
print(dir())

# __init__.py
__all__ = ["ModelC", "ModelD"]

第2节 内置模块：日期和时间处理

1 time模块

time 模块提供了与时间相关的函数，可用于获取当前时间、延迟程序执行、进行时间格式转换等操作。

时间获取

时间延迟

时间格式转换

时区相关

其他

常量

1. 获取当前时间戳

时间戳是一个浮点数，表示从 1970 年 1 月 1 日午夜（UTC）开始到当前时刻所经过的秒数。使用 time.time() 函数可以获取当前的时间戳。

import time
current_time = time.time()
print(current_time)
# 获取当前结构化时间
local_time = time.localtime()
print(local_time)
# 将结构化时间转换为格式化字符串
sft = time.strftime("%Y-%m-%d %H:%M:%S", local_time)
print(sft)

2. 暂停程序执行

time.sleep(seconds) 函数可以让程序暂停执行指定的秒数，常用于模拟耗时操作或设置定时任务。

import time
for i in range(3, 0, -1):
    print(i)
    time.sleep(1)

3. 将时间戳转换为结构化时间

time.localtime([timestamp]) 函数可以将时间戳转换为本地时间的结构化时间对象。如果不提供时间戳参数，则默认使用当前时间戳。

import time
# 获取当前时间戳
current_time = time.time()
current_time = 10000
local_time = time.localtime(current_time)
print(local_time)

4. 将结构化时间转换为格式化字符串

time.strftime(format, [t]) 函数可以将结构化时间对象转换为指定格式的字符串。format 参数是一个字符串，用于指定输出的时间格式；t 参数是一个可选的结构化时间对象，如果不提供，则默认使用当前时间。

sft = time.strftime("%Y-%m-%d %H:%M:%S", local_time)

5. 将格式化字符串转换为结构化时间

time.strptime(string, format) 函数可以将格式化的时间字符串转换为结构化时间对象。string 参数是要转换的时间字符串，format 参数是该字符串的格式。

import time
time_string = "2024-10-01 12:30:30"
strcut_time = time.strptime(time_string, "%Y-%m-%d %H:%M:%S")
print(strcut_time)
print(strcut_time.tm_year)
print(strcut_time.tm_mon)

6. 计算程序执行时间

可以结合 time.time() 函数来计算程序中某段代码的执行时间。

import time
start_time = time.time()
for i in range(1000000):
    pass
end_time = time.time()
print(end_time - start_time)

2 datetime模块

datetime 模块是 Python 标准库中用于处理日期和时间的重要模块，它提供了多种类和函数来帮助开发者进行日期和时间的计算、格式化、解析等操作。

（1）date 类

date 类用于表示日期，包含年、月、日信息。

属性：

• year：年份
• month：月份（1 - 12）
• day：日期（1 - 31）

方法：

• today()：返回当前本地日期
• fromisoformat(date_string)：从 ISO 格式的字符串创建 date 对象
• weekday()：返回星期几（0 表示周一，6 表示周日）
• isoweekday()：返回星期几（1 表示周一，7 表示周日）

代码示例：

import datetime
# 获取当前日期
today = datetime.date.today()
print(today)
print(today.year)
print(today.month)
print(today.day)
# 从ISO格式化字符串创建日期
date_str = "2024-04-28"
new_date = datetime.date.fromisoformat(date_str)
print(new_date)

# 获取星期几
print(today.weekday()) # 0 周一
print(new_date.weekday())# 6 周天
print(today.isoweekday())
print(new_date.isoweekday())

（2）time类

time 类用于表示时间，包含时、分、秒、微秒和时区信息。

属性：

• hour：小时（0 - 23）
• minute：分钟（0 - 59）
• second：秒（0 - 59）
• microsecond：微秒（0 - 999999）
• tzinfo：时区信息

方法：

• isoformat()：返回 ISO 格式的时间字符串

代码示例：

import datetime
# 创建时间对象
time_obj = datetime.time(14,30,15)
# print(time_obj + "")
print(time_obj.hour)
print(time_obj.minute)

# 获取ISO格式的时间字符串
iso_time = time_obj.isoformat()
print(iso_time + "")

（3）datetime 类

datetime 类结合了 date 和 time 的功能，用于表示日期和时间。

属性：包含 date 和 time 的所有属性。

方法：

• now()：返回当前本地日期和时间
• utcnow()：返回当前 UTC 日期和时间
• fromisoformat(date_string)：从 ISO 格式的字符串创建 datetime 对象
• strftime(format)：根据指定格式将 datetime 对象转换为字符串
• strptime(date_string, format)：根据指定格式将字符串解析为 datetime 对象

代码示例：

import datetime
# 获取当前时间（本地）
now = datetime.datetime.now()
print(now)

# 获取当前 UTC 日期和时间
utc_now = datetime.datetime.now(datetime.UTC)
print(utc_now)

# 从ISO格式字符串创建datetime对象
datetime_str = "2024-12-25 14:30:15"
new_datetime = datetime.datetime.fromisoformat(datetime_str)
print(new_datetime)
print(new_datetime.year)

# 将datetime对象转字符串 2024/5/30
formatted_str = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_str)

# 将字符串解析为datetime对象
s = datetime.datetime.strptime("2024-12-25 14:30:15", "%Y-%m-%d %H:%M:%S")
print(s)

（4）timedelta类

timedelta 类表示两个日期或时间之间的差值。

属性：

• days：天数
• seconds：秒数（不包含天数）
• microseconds：微秒数

方法：支持与 date、datetime 对象进行加减运算

代码示例：

import datetime
# 创建timedelta对象 把差值当成一个对象
delta = datetime.timedelta(days=5, hours=3)
print(delta)

now = datetime.datetime.now()

# 计算未来5天3小时是什么时候
future = now - delta
print(now)
print(future)

# 计算时间差
time_diff = future - now
print(time_diff)
print(time_diff.days)

（5）timezone 类

timezone 类是 tzinfo 的具体实现，用于表示固定偏移量的时区。

方法：

• utc：表示 UTC 时区的常量

代码示例：

# 暂时不管

（6）常量数据

• MAXYEAR：date 和 datetime 对象支持的最大年份，通常为 9999。
• MINYEAR：date 和 datetime 对象支持的最小年份，通常为 1。

代码示例：

import datetime
print(datetime.MAXYEAR)

（7）格式化代码

在 strftime 和 strptime 方法中，常用的格式化代码如下：

3 calendar模块

calendar 模块提供了与日历相关的功能，可用于生成日历、处理日期和星期等。

（1）日历生成类

（2）日历相关函数

（3）常量

1. 获取指定年份和月份的日历

使用 calendar.month(year, month) 函数可以获取指定年份和月份的日历。

import calendar
cal = calendar.month(2025, 5)
print(cal)

2. 判断是否为闰年

calendar.isleap(year) 函数可以判断指定的年份是否为闰年。

import calendar
print(calendar.isleap(2025))
print(calendar.isleap(2020))

3. 获取指定年份的周数

calendar.monthcalendar(year, month) 函数返回一个列表，其中每个元素都是一个代表一周的列表，列表中的元素是该周的日期。通过这个函数可以获取指定年份和月份的周数信息。

4. 获取指定日期是星期几

calendar.weekday(year, month, day) 函数可以获取指定日期是星期几，返回值为 0（星期一）到 6（星期日）。

import calendar
weeks = calendar.monthcalendar(2025,5)
# print(weeks)
for week in weeks:
    print(week)

5. 打印全年日历

calendar.prcal(year) 函数可以打印出指定年份的全年日历。

import calendar
calendar.prcal(2025)

6. 生成指定年份的日历数据

calendar.Calendar() 类可以用于生成指定年份的日历数据，通过迭代该类的实例可以获取每个月的日历信息。

import calendar
# 创建日历的对象
cal = calendar.Calendar()

# 遍历2025年每个月的日历信息
for month in range(1, 13):
    month_cal = cal.monthdatescalendar(2025, month)
    for week in month_cal:
        for day in week:
            print(day) # datetime.date()对象