Python Day19 时间模块 和 json模块 及例题分析

一、UUID 模块

用于生成唯一标识符（UUID），常见生成方式及特点：

• uuid1：基于时间戳和 MAC 地址生成，保证唯一性。
• uuid3/uuid5：基于命名空间和哈希计算生成，需传入命名空间（如 uuid1 生成的 UUID）和字符串，相同输入生成相同 UUID。
• uuid4：完全随机生成，随机性强。

示例：

import uuid
# uuid1
print(uuid.uuid1())  # 如：a7375a61-6ced-11f0-b5cc-00e04c9c935c（长度36字符）
# uuid3（需命名空间）
namespace = uuid.uuid1()
print(uuid.uuid3(namespace, '12safasdf56'))  # 基于命名空间和字符串生成
# uuid4
print(uuid.uuid4())  # 随机UUID
print(uuid.uuid4().hex)  # 无连字符的16进制形式（32字符）

二、time 模块

用于时间相关操作，核心函数及时间元组：

1. 核心函数

• sleep(s)：程序暂停s秒（单位：秒）。
• time()：返回当前系统时间戳（距离 1970-01-01 08:00:00 的秒数，精确到纳秒）。
• localtime([timestamp])：返回本地时间元组（默认当前时间，可传入时间戳）。
• mktime(timetuple)：将时间元组转换为对应时间戳。

2. 时间元组

由 9 个元素组成，分别表示：
（年，月，日，时，分，秒，星期，一年中的第几天，是否夏令时）

• 星期：0 = 周一，1 = 周二，…，6 = 周日。
• 访问方式：通过索引（如t[0]）或属性（如t.tm_year）。

示例：

import time
t = time.localtime()  # 当前时间元组
print(t.tm_year)  # 年
print(t.tm_wday)  # 星期（0-6）
print(t.tm_yday)  # 一年中的第几天

3. 时间格式化

• strftime(format, timetuple)：将时间元组格式化为字符串。
• strptime(string, format)：将字符串按格式解析为时间元组。

常用格式符号：

• %Y：四位数年份；%m：两位数月份；%d：两位数日期。
• %H：24 小时制小时；%M：分钟；%S：秒。
• %I：12 小时制小时；%p：AM/PM（配合 % I 使用）。

示例：

t = time.localtime()
print(time.strftime('%Y-%m-%d %H:%M:%S', t))  # 如：2025-07-30 15:30:20
# 字符串转时间元组
t_str = "2000年10月20日11点22分33秒"
t_tuple = time.strptime(t_str, "%Y年%m月%d日%H点%M分%S秒")

三、datetime 模块

提供更优雅的日期时间处理，核心类：datetime（日期 + 时间）、date（日期）、time（时间）、timedelta（时间间隔）。

1. datetime 类（日期 + 时间）

• 创建方式：

  • datetime.now()：当前时间。
  • datetime(年, 月, 日[, 时, 分, 秒, 微秒])：指定时间（至少需年月日）。
  • datetime.fromtimestamp(timestamp)：从时间戳创建。
  • datetime.fromisoformat(iso_str)：从 ISO 格式字符串创建（如"2000-10-10 11:21:33.444"）。

• 属性与操作：

  • 属性：year, month, day, hour, minute, second, weekday()（0 = 周一）。
  • 转换：timetuple()（转时间元组）、timestamp()（转时间戳）。
  • 格式化：strftime(format)（同 time 模块）；strptime(string, format)（解析字符串）。

示例：

from datetime import datetime
dt = datetime.now()
print(dt.strftime('%Y/%m/%d %H:%M:%S'))  # 格式化
dt_str = "2000年10月30日11点30分32秒"
dt = datetime.strptime(dt_str, '%Y年%m月%d日%H点%M分%S秒')

2. date 类（仅日期）

• 创建方式：

  • date.today()：当前日期。
  • date(年, 月, 日)：指定日期。
  • date.fromtimestamp(timestamp)：从时间戳创建。
  • date.fromisoformat(iso_str)：从 ISO 格式字符串创建（如"2000-10-10"）。

• 属性与操作：year, month, day, weekday()，格式化同datetime。

示例：

from datetime import date
d = date.today()
print(d.strftime('%Y/%m/%d'))  # 2025/07/30

3. time 类（仅时间）

• 创建方式：

  • time(时, 分, 秒[, 微秒])：指定时间。
  • time.fromisoformat(iso_str)：从 ISO 格式字符串创建（如"11:20:33.66"）。

• 属性：hour, minute, second, microsecond，格式化同datetime。

示例：

from datetime import time
t = time(11, 22, 33)
print(t.strftime('%H:%M:%S'))  # 11:22:33

4. timedelta 类（时间间隔）

表示一段时间，支持与日期 / 时间对象的加减运算。

• 创建方式：timedelta(days=0, seconds=0, minutes=0, hours=0, weeks=0)。

• 属性：

  • days：间隔的总天数。
  • seconds：非整天部分的秒数。
  • total_seconds()：总秒数。

• 运算：

  • 日期 / 时间对象 ± timedelta → 新日期 / 时间。
  • 两个日期 / 时间对象相减 → timedelta。

示例：

from datetime import datetime, timedelta
now = datetime.now()
# 3天后的时间
three_days_later = now + timedelta(days=3)
# 计算活了多少天
birthday = date(2000, 12, 11)
days_alive = (date.today() - birthday).days

四、copy 模块

用于对象拷贝，区分浅拷贝和深拷贝：

• 浅拷贝（copy.copy ()）：

  • 对不可变类型（如 int、str）：值拷贝（新对象）。
  • 对可变类型（如 list、dict）及自定义对象：地址拷贝（共享内部引用）。

• 深拷贝（copy.deepcopy ()）：

  • 递归拷贝所有元素，可变类型和自定义对象均生成新对象，不共享引用。

示例：

import copy
class Dog:
    def __init__(self, name):
        self.name = name

ls = [1, 2, 3, Dog('枯矾')]
shallow = copy.copy(ls)
deep = copy.deepcopy(ls)

ls[-1].name = "帕莎"
print(shallow[-1].name)  # 帕莎（浅拷贝共享引用）
print(deep[-1].name)     # 枯矾（深拷贝独立）

五、json 模块

处理 JSON 格式数据（跨语言数据交换），涉及序列化（Python→JSON）和反序列化（JSON→Python）。

1. 数据类型对应关系

2. 序列化（dumps/dump）

• json.dumps(obj, ...)：将 Python 对象转为 JSON 字符串。
• json.dump(obj, fp, ...)：将 Python 对象写入文件（JSON 格式）。

关键参数：

• ensure_ascii=False：保留非 ASCII 字符（如中文）。
• indent=N：设置缩进，格式化输出。
• default：处理无法序列化的对象（如 datetime），需返回可序列化值。
• cls：自定义 Encoder 类（继承json.JSONEncoder，重写default方法）。

示例：

import json
from datetime import date

data = [{'name': '张三', 'birthday': date(2000, 10, 10)}]

# 自定义处理日期
def convert(d):
    if isinstance(d, date):
        return d.strftime('%Y/%m/%d')

json_str = json.dumps(data, ensure_ascii=False, indent=2, default=convert)
print(json_str)

3. 反序列化（loads/load）

• json.loads(string)：将 JSON 字符串转为 Python 对象。
• json.load(fp)：从文件读取 JSON 并转为 Python 对象。

关键参数：

• object_hook：将 JSON 对象转为自定义类实例（如 User）。

示例：

class User:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

json_data = '[{"name":"小怪","age":20,"gender":"男"}]'
# 转为User对象列表
users = json.loads(json_data, object_hook=lambda d: User(**d))

一、时间日期计算

1. 获取最近 7 天日期列表

import time

def get_last_week():
    """返回最近7天的日期列表，格式为YYYY-MM-DD"""
    week_days = []
    current_time = time.time()
    for i in range(7):
        day_time = current_time - (24 * 60 * 60 * i)  # 计算前i天的时间戳
        week_days.append(time.strftime("%Y-%m-%d", time.localtime(day_time)))
    return week_days

2. 计算两个时间点的时间差

from datetime import datetime

def time_diff(tm1, tm2):
    """计算两个时间点的差值，返回格式为'X小时Y分钟Z秒'"""
    tm1 = datetime.strptime(tm1, "%H:%M:%S")
    tm2 = datetime.strptime(tm2, "%H:%M:%S")
    td = abs(tm2 - tm1)  # 时间差
    total_seconds = td.total_seconds()
    hours = total_seconds // 3600
    minutes = (total_seconds % 3600) // 60
    seconds = total_seconds % 60
    return f"{hours}小时{minutes}分钟{seconds}秒"

3. 计算两个日期间的星期日列表

from datetime import datetime, timedelta

def sunday_list(tm1, tm2):
    """返回两个日期之间所有星期日的日期列表"""
    tm1 = datetime.strptime(tm1, "%Y-%m-%d")
    tm2 = datetime.strptime(tm2, "%Y-%m-%d")
    start, end = min(tm1, tm2), max(tm1, tm2)
    sundays = []
    
    # 找到第一个星期日
    current = start + timedelta(days=(6 - start.weekday()) % 7)
    while current < end:
        sundays.append(current.strftime("%Y-%m-%d"))
        current += timedelta(days=7)
    return sundays

4. 计算存活天数

from datetime import datetime

def live_days(birthday: str):
    """计算从出生日期到现在的天数"""
    birth = datetime.strptime(birthday, "%Y-%m-%d").date()
    now = datetime.now().date()
    return (now - birth).days

5. 生成随机日期（1900-2100 年）

import random
from datetime import datetime, timedelta

def random_date(start_day="1900-01-01", end_day="2100-12-31"):
    """生成指定范围内的随机有效日期"""
    start = datetime.strptime(start_day, "%Y-%m-%d").date()
    end = datetime.strptime(end_day, "%Y-%m-%d").date()
    days_diff = (end - start).days
    random_days = random.randint(0, days_diff)
    return (start + timedelta(days=random_days)).strftime("%Y-%m-%d")

二、JSON 序列化与反序列化

1. 普通数据序列化

import json

data = {
    "name": "张三",
    "age": 30,
    "city": "河南郑州",
    "skills": ["Python", "JavaScript", "Data Science"],
    "is_student": False,
    (1,): 1  # 元组键会被跳过（非JSON可序列化类型）
}

# 序列化（处理中文、跳过不可序列化的键、格式化输出）
json_str = json.dumps(data, ensure_ascii=False, skipkeys=True, indent=2)
print(json_str)

2. 学生对象序列化与反序列化

import json
from datetime import date, datetime

class Student:
    def __init__(self, name, age, birth: date):
        self.name = name
        self.age = age
        self.birth = birth
    
    def __repr__(self):
        return f"{self.__class__.__name__}{self.__dict__}"

# 自定义序列化函数
def convert_date(obj):
    if isinstance(obj, (date, datetime)):
        return obj.strftime('%Y/%m/%d')
    raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")

# 写入文件
def save_students(students, filename="students.json"):
    with open(filename, "w", encoding="utf-8") as f:
        json.dump([vars(s) for s in students], f, ensure_ascii=False, indent=2, default=convert_date)

# 读取文件并反序列化
def load_students(filename="students.json"):
    def parse_date(dct):
        if 'birth' in dct:
            dct['birth'] = datetime.strptime(dct['birth'], '%Y/%m/%d').date()
        return Student(**dct)
    
    with open(filename, "r", encoding="utf-8") as f:
        return [parse_date(item) for item in json.load(f)]

# 使用示例
if __name__ == "__main__":
    students = [
        Student("小魑", 20, date(2004, 2, 5)),
        Student("小魅", 21, date(2009, 7, 9)),
    ]
    save_students(students)
    loaded = load_students()
    print(loaded)

三、日历显示

from datetime import date

def show_calendar(year, month):
    """显示指定年月的日历"""
    # 获取当月天数
    if month in [1, 3, 5, 7, 8, 10, 12]:
        max_day = 31
    elif month in [4, 6, 9, 11]:
        max_day = 30
    else:  # 2月
        is_leap = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
        max_day = 29 if is_leap else 28
    
    # 计算当月第一天是星期几（0=周一，6=周日）
    first_day = date(year, month, 1)
    first_weekday = (first_day.weekday() + 1) % 7  # 转换为0=周日，6=周六
    
    # 打印表头
    print("日\t一\t二\t三\t四\t五\t六")
    
    # 打印前导空格
    print("\t" * first_weekday, end="")
    
    # 打印日期
    for day in range(1, max_day + 1):
        print(day, end="\t")
        if (day + first_weekday) % 7 == 0:  # 每周换行
            print()
    print()  # 最后换行

四、使用示例

if __name__ == "__main__":
    # 1. 获取最近7天
    print("最近7天:", get_last_week())
    
    # 2. 计算时间差
    print("时间差:", time_diff("12:30:00", "14:45:30"))
    
    # 3. 星期日列表
    print("星期日列表:", sunday_list("2023-09-28", "2023-10-10"))
    
    # 4. 存活天数
    print("存活天数:", live_days("2000-01-01"))
    
    # 5. 随机日期
    print("随机日期:", random_date())
    
    # 6. 显示日历
    show_calendar(2025, 7)