import time

## 1. 获取当前时间戳 (自纪元以来的秒数)
current_timestamp = time.time()
print(f"当前时间戳: {current_timestamp}") # 例如: 1715480315.123456

## 2. 将时间戳转换为本地时间的 struct_time 对象
local_time_struct = time.localtime(current_timestamp)
print(f"本地时间元组 (struct_time): {local_time_struct}")
## 访问 struct_time 的属性
print(f"  年份 (tm_year): {local_time_struct.tm_year}")
print(f"  月份 (tm_mon): {local_time_struct.tm_mon}")
print(f"  日期 (tm_mday): {local_time_struct.tm_mday}")
print(f"  小时 (tm_hour): {local_time_struct.tm_hour}")
print(f"  分钟 (tm_min): {local_time_struct.tm_min}")
print(f"  秒数 (tm_sec): {local_time_struct.tm_sec}")
print(f"  星期几 (tm_wday, 周一=0): {local_time_struct.tm_wday}")
print(f"  一年中的第几天 (tm_yday): {local_time_struct.tm_yday}")
print(f"  夏令时 (tm_isdst): {local_time_struct.tm_isdst}")

## 3. 将时间戳转换为 UTC 时间的 struct_time 对象
utc_time_struct = time.gmtime(current_timestamp)
print(f"UTC时间元组 (struct_time): {utc_time_struct}")
print(f"  UTC 年份: {utc_time_struct.tm_year}, UTC 小时: {utc_time_struct.tm_hour}")

## 4. 将本地时间的 struct_time 对象转换回时间戳
timestamp_from_local_struct = time.mktime(local_time_struct)
print(f"从本地时间元组转换回的时间戳: {timestamp_from_local_struct}") # 应与 current_timestamp 非常接近

## 5. 使用 asctime() 获取可读字符串 (不推荐在新代码中使用)
readable_time_asctime = time.asctime(local_time_struct) # 等同于 time.asctime()
print(f"asctime() 格式的时间: {readable_time_asctime}") # 例如: 'Mon May 12 11:18:35 2025'

## 6. 使用 strftime() 将 struct_time 格式化为自定义字符串 (强烈推荐)
formatted_time_custom = time.strftime("%Y-%m-%d %H:%M:%S %A", local_time_struct)
print(f"strftime() 自定义格式化时间: {formatted_time_custom}") # 例如: '2025-05-12 11:18:35 Monday'

## 7. 使用 strptime() 将字符串解析为 struct_time 对象
time_string = "2024-07-20 10:30:00"
format_string = "%Y-%m-%d %H:%M:%S"
parsed_time_struct = time.strptime(time_string, format_string)
print(f"strptime() 解析 '{time_string}' 结果: {parsed_time_struct}")
print(f"  解析得到的年份: {parsed_time_struct.tm_year}")

## 8. 程序暂停
print("程序开始执行...")
time.sleep(1.5) # 暂停1.5秒
print("程序暂停1.5秒后继续执行。")

## 9. 性能计数器 (用于测量小段代码执行时间)
start_perf = time.perf_counter()
## 执行一些操作
for _ in range(100000):
    pass
end_perf = time.perf_counter()
duration_perf = end_perf - start_perf
print(f"高性能计数器测量的操作耗时: {duration_perf:.6f} 秒")

## 10. 进程CPU时间
start_process = time.process_time()
## 执行一些CPU密集型操作
total = 0
for i in range(1000000):
    total += i
end_process = time.process_time()
duration_process = end_process - start_process
print(f"CPU密集型操作的进程耗时: {duration_process:.6f} 秒")

import time

def get_current_time_str(format_str="%Y-%m-%d %H:%M:%S"):
    """
    获取当前本地时间，并按指定格式返回字符串。

    参数:
    format_str (str): strftime 使用的时间格式化字符串。

    返回:
    str: 格式化后的当前时间字符串。
    """
    return time.strftime(format_str, time.localtime())

## 示例使用
print(f"当前日期时间: {get_current_time_str()}") # 输出: 2025-05-12 11:18:35 (示例)
print(f"当前日期 (YYYYMMDD): {get_current_time_str('%Y%m%d')}") # 输出: 20250512 (示例)
print(f"当前时间 (HH-MM-SS): {get_current_time_str('%H-%M-%S')}") # 输出: 11-18-35 (示例)

import time

def measure_execution_time(func, *args, **kwargs):
    """
    测量并打印指定函数执行所需的时间。

    参数:
    func (callable): 需要测量执行时间的函数。
    *args: 传递给 func 的位置参数。
    **kwargs: 传递给 func 的关键字参数。

    返回:
    any: func 的返回值。
    """
    start_time = time.perf_counter() # 使用 perf_counter 更精确
    result = func(*args, **kwargs)
    end_time = time.perf_counter()
    print(f"函数 '{func.__name__}' 执行耗时: {end_time - start_time:.6f} 秒")
    return result

## 示例函数
def example_function(n):
    time.sleep(n) # 模拟耗时操作
    return f"操作完成，参数为 {n}"

## 测量示例函数的执行时间
measure_execution_time(example_function, 0.5)
measure_execution_time(sum, range(1000000))

import time

def timestamp_to_str(ts, format_str="%Y-%m-%d %H:%M:%S"):
    """将时间戳转换为指定格式的本地时间字符串。"""
    return time.strftime(format_str, time.localtime(ts))

def str_to_timestamp(time_str, format_str="%Y-%m-%d %H:%M:%S"):
    """将指定格式的时间字符串转换为本地时间戳。"""
    struct_t = time.strptime(time_str, format_str)
    return time.mktime(struct_t)

## 示例
ts_now = time.time()
print(f"当前时间戳: {ts_now}")

formatted_str = timestamp_to_str(ts_now)
print(f"时间戳 -> 字符串: {formatted_str}")

back_to_ts = str_to_timestamp(formatted_str)
print(f"字符串 -> 时间戳: {back_to_ts}")

from datetime import *
from print_utils import *

# ======== 日期时间操作示例 ========
print_header("1. 获取当前日期时间")
dt_now = datetime.now()  # 本地时区的当前日期时间
print_info(f"当前日期时间 (datetime.now()): {dt_now}")
print_info(f"  年份: {dt_now.year}, 月份: {dt_now.month}, 日期: {dt_now.day}")
print_info(f"  小时: {dt_now.hour}, 分钟: {dt_now.minute}, 秒数: {dt_now.second}, 微秒: {dt_now.microsecond}")

print_header("2. 获取当前UTC日期时间")
utc_now = datetime.now(timezone.utc)  # 获取UTC时区的当前日期时间
print_info(f"当前UTC日期时间 (datetime.now(timezone.utc)): {utc_now}")

print_header("3. 创建特定的日期时间对象")
special_dt = datetime(2025, 1, 1, 12, 0, 0)  # 2025年1月1日12:00:00
print_info(f"特定日期时间对象: {special_dt}")

print_header("4. 创建 date 对象 和 time 对象")
specific_date = date(2025, 10, 20)
print_info(f"特定日期 (date): {specific_date}")
print_info(f"  年份: {specific_date.year}, 月份: {specific_date.month}, 日期: {specific_date.day}")
print_info(f"  星期几 (weekday(), 周一=0): {specific_date.weekday()}")  # 周日是6

specific_time = time(12, 0, 0)
print_info(f"特定时间 (time): {specific_time}")
print_info(f"  小时: {specific_time.hour}, 分钟: {specific_time.minute}, 秒数: {specific_time.second}")

print_header("5. 日期时间格式化 (strftime)")
formatted_dt = dt_now.strftime("%Y年%m月%d日 %H时%M分%S秒 星期%A")
print_info(f"格式化后的日期时间: {formatted_dt}")

print_header("6. 日期时间解析 (strptime)")
parsed_dt = datetime.strptime("2025-10-20 12:00:00", "%Y-%m-%d %H:%M:%S")
print_info(f"解析后的日期时间: {parsed_dt}")

print_header("7. 时间差 (timedelta)")
delta1 = timedelta(days=5, hours=3, minutes=30)
print_info(f"时间差: {delta1}")

print_header("8. 日期时间运算")
future_dt = dt_now + delta1  # 当前时间加五天 3小时 30分钟
print_info(f"未来日期时间: {future_dt}")

past_dt = dt_now - timedelta(weeks=2)
print_info(f"当前时间减去2周后: {past_dt}")

# 计算两个日期时间的差
specific_dt = datetime(2025, 10, 20, 12, 0, 0)  # 2025年10月20日12:00:00
diff_dt = specific_dt - dt_now
print_info(f"两个datetime对象之间的差: {diff_dt}")
print_info(f"  相差天数: {diff_dt.days}")
print_info(f"  相差总秒数: {diff_dt.total_seconds()}")

print_header("9. datetime 与时间戳转换")
current_timestamp = dt_now.timestamp()  # 将本地datetime对象转换为时间戳
print_info(f"当前datetime对象对应的时间戳: {current_timestamp}")

dt_from_ts_local = datetime.fromtimestamp(current_timestamp)  # 从时间戳创建本地datetime对象
print_info(f"从时间戳转换回的本地datetime: {dt_from_ts_local}")

dt_from_ts_utc = datetime.fromtimestamp(current_timestamp, tz=timezone.utc)  # 从时间戳创建UTC datetime对象
print_info(f"从时间戳转换回的UTC datetime: {dt_from_ts_utc}")

print_header("10. 替换日期时间的某些部分")
replaced_dt = dt_now.replace(year=2030, microsecond=0)
print_info(f"替换年份和微秒后的datetime: {replaced_dt}")

print_header("11. 时区处理")
# 创建一个表示东八区的 timezone 对象 (北京时间)
beijing_tz = timezone(timedelta(hours=8), name='Asia/Shanghai')
beijing_now = datetime.now(beijing_tz)
print_info(f"当前北京时间: {beijing_now}")
print_info(f"北京时间的时区信息: {beijing_now.tzinfo}")

# 将一个naive datetime对象转换为aware datetime对象
naive_dt = datetime(2025, 1, 1, 12, 0, 0)
aware_dt_beijing = naive_dt.replace(tzinfo=beijing_tz)  # 假设naive_dt是北京时间
print_info(f"Naive datetime 赋予北京时区: {aware_dt_beijing}")

# 将一个aware datetime对象转换到另一个时区
utc_dt_example = aware_dt_beijing.astimezone(timezone.utc)
print_info(f"北京时间转换为UTC时间: {utc_dt_example}")

from datetime import datetime, timezone

def get_formatted_current_datetime(fmt="%Y-%m-%d %H:%M:%S.%f", use_utc=False):
    """
    获取格式化的当前日期时间字符串。

    参数:
    fmt (str): strftime 使用的时间格式化字符串。
               '%f' 可以用于表示微秒。
    use_utc (bool): 如果为True，则返回UTC时间，否则返回本地时间。

    返回:
    str: 格式化后的当前日期时间字符串。
    """
    if use_utc:
        now_dt = datetime.now(timezone.utc)
    else:
        now_dt = datetime.now()
    return now_dt.strftime(fmt)

## 示例
print(f"本地当前精确时间: {get_formatted_current_datetime()}")
## 输出示例: 2025-05-12 11:18:35.123456
print(f"UTC当前日期 (YYYY-MM-DD): {get_formatted_current_datetime(use_utc=True)}")
## 输出示例: 2025-05-12 (假设当前UTC日期)

from datetime import datetime, timedelta

def calculate_future_past_date(days_offset=0, weeks_offset=0, hours_offset=0, base_date=None):
    """
    根据偏移量计算未来或过去的日期时间。

    参数:
    days_offset (int): 天数偏移，正数表示未来，负数表示过去。
    weeks_offset (int): 周数偏移。
    hours_offset (int): 小时数偏移。
    base_date (datetime, optional): 基准日期时间，默认为当前本地时间。

    返回:
    datetime: 计算后的日期时间对象。
    """
    if base_date is None:
        base_date = datetime.now()
    
    offset = timedelta(days=days_offset, weeks=weeks_offset, hours=hours_offset)
    return base_date + offset

## 示例
one_week_later = calculate_future_past_date(weeks_offset=1)
print(f"一周后的日期时间: {one_week_later.strftime('%Y-%m-%d %H:%M')}")

three_days_ago_noon = calculate_future_past_date(days_offset=-3, base_date=datetime(2025,5,15,12,0,0))
print(f"三天前的中午12点: {three_days_ago_noon.strftime('%Y-%m-%d %H:%M')}")

from datetime import datetime

def parse_date_string_safely(date_str, date_format="%Y-%m-%d"):
    """
    尝试按指定格式解析日期字符串，如果失败则返回None。

    参数:
    date_str (str): 要解析的日期字符串。
    date_format (str): datetime.strptime 使用的日期格式。

    返回:
    datetime.date or None: 解析成功则返回date对象，否则返回None。
    """
    try:
        dt_object = datetime.strptime(date_str, date_format)
        return dt_object.date() # 通常我们只关心日期部分
    except ValueError:
        print(f"错误: 字符串 '{date_str}' 无法匹配格式 '{date_format}'")
        return None

## 示例
valid_date_str = "2024-12-25"
invalid_date_str = "25/12/2024"

parsed_date1 = parse_date_string_safely(valid_date_str)
if parsed_date1:
    print(f"成功解析 '{valid_date_str}': {parsed_date1}")

parsed_date2 = parse_date_string_safely(invalid_date_str) # 格式不匹配
if parsed_date2 is None:
    print(f"解析 '{invalid_date_str}' 失败。")

parsed_date3 = parse_date_string_safely("31.01.2023", date_format="%d.%m.%Y")
if parsed_date3:
     print(f"成功解析 '31.01.2023': {parsed_date3}")

from datetime import datetime

def get_difference_between_datetimes(dt1_str, dt2_str, fmt="%Y-%m-%d %H:%M:%S"):
    """
    计算两个日期时间字符串之间的差异。

    参数:
    dt1_str (str): 第一个日期时间字符串。
    dt2_str (str): 第二个日期时间字符串。
    fmt (str): 日期时间字符串的格式。

    返回:
    dict or None: 包含天数、总小时数、总分钟数、总秒数的字典，如果解析失败返回None。
    """
    try:
        dt1 = datetime.strptime(dt1_str, fmt)
        dt2 = datetime.strptime(dt2_str, fmt)
    except ValueError:
        print("日期时间字符串格式错误或无效。")
        return None
        
    # 确保 dt2 总是大于 dt1，如果不是，则交换它们或返回负值
    if dt1 > dt2:
        delta = dt1 - dt2
        sign = -1 # 表示 dt1 在 dt2 之后
    else:
        delta = dt2 - dt1
        sign = 1

    return {
        "days": sign * delta.days,
        "total_hours": sign * (delta.total_seconds() / 3600),
        "total_minutes": sign * (delta.total_seconds() / 60),
        "total_seconds": sign * delta.total_seconds(),
        "timedelta_object": delta if sign == 1 else -delta
    }

## 示例
start_time = "2025-05-10 09:00:00"
end_time = "2025-05-12 11:30:45"

diff = get_difference_between_datetimes(start_time, end_time)
if diff:
    print(f"从 '{start_time}' 到 '{end_time}':")
    print(f"  相差天数: {diff['days']}")
    print(f"  总小时数: {diff['total_hours']:.2f}")
    print(f"  总分钟数: {diff['total_minutes']:.2f}")
    print(f"  总秒数: {diff['total_seconds']:.0f}")
    print(f"  Timedelta对象: {diff['timedelta_object']}")

diff_reverse = get_difference_between_datetimes(end_time, start_time)
if diff_reverse:
    print(f"\n从 '{end_time}' 到 '{start_time}':") # 注意这里是反向的
    print(f"  相差天数: {diff_reverse['days']}") # 将会是负数

import random
from print_utils import *

# =========================================================
# 1.设置随机数种子以获得可复现的结果
# =========================================================
print_header("随机数种子设置")
#random.seed(101)  # 使用特定的种子 -> 为了下面的测试，这里需要注释掉
print_info(f"使用种子101生成的第一个随机数: {random.random()}")
print_info(f"使用种子101生成的第二个随机数: {random.random()}")

#random.seed(101)  # 重置种子 -> 同上，这里需要注释掉
print_info(f"重置种子101后生成的第一个随机数: {random.random()}")  # 输出会和上面第一个相同

# =========================================================
# 2.生成 [0.0 1.0] 之间的随机浮点数
# =========================================================
print_header("生成随机浮点数")
print_info(f"生成的随机浮点数: {random.random()}")

# =========================================================
# 3.生成指定范围内的随机浮点数(只有浮点数会变)
# =========================================================
print_header("生成指定范围内的随机浮点数")
rand_float_range = random.uniform(5.5, 15.5)
print_info(f"生成的随机浮点数 (5~15.5): {rand_float_range}")

# =========================================================
# 4. 生成指定范围内的随机整数
# =========================================================
print_header("生成随机范围的随机整数")
rand_int_range = random.randint(10, 20)
print_info(f"生成的随机整数 (10 到 20): {rand_int_range}")

# =========================================================
# 5. randrange指定步长的随机整数
# =========================================================
print_header("生成指定步长的随机整数")
rand_int_step = random.randrange(0, 100, 5)  # 从0到100中选择一个5的倍数
print_info(f"生成的随机整数 (0 到 100, 步长5): {rand_int_step}")


# =========================================================
# 6.从序列中随机选择一个元素
# =========================================================
print_header("从序列中随机选择一个元素")
my_colors = ['红', '橙', '黄', '绿', '蓝', '紫']
random_color = random.choice(my_colors)
print(f"颜色列表: {my_colors}")
print(f"随机选择的颜色 (choice): {random_color}")

# =========================================================
# 7. 从序列中随机选择k个元素 (可重复，带权重 - choices)
# =========================================================
print_header("从序列中随机选择k个元素 (可重复)")
elements_pool = ['石头', '剪刀', '布']
element_weights = [0.8, 0.1, 0.1] # 石头有80%的概率被选中，剪刀和布各有10%的概率

# 选择1个 (默认k=1)
chosen_one_weighted = random.choices(elements_pool, weights=element_weights)
print_info(f"带权重选择1个元素 (choices): {chosen_one_weighted}")

# 选择5个可重复的元素
chosen_five_weighted = random.choices(elements_pool, weights=element_weights, k=5)
print_info(f"带权重选择5个可重复元素 (choices): {chosen_five_weighted}")


# =========================================================
# 8.随机打乱新序列元素的顺序
# =========================================================
print_header("随机打乱新序列元素的顺序")
game_players = ['玩家A', '玩家B', '玩家C', '玩家D']
print(f"原始玩家顺序: {game_players}")
random.shuffle(game_players) # 直接修改 game_players
print(f"打乱后的玩家顺序 (shuffle): {game_players}")

import random
import string

def generate_simple_random_string(length=10, use_letters=True, use_digits=True, use_punctuation=False):
    """
    生成一个指定长度的简单随机字符串。

    参数:
    length (int): 生成字符串的长度。
    use_letters (bool): 是否包含大小写字母。
    use_digits (bool): 是否包含数字。
    use_punctuation (bool): 是否包含标点符号。

    返回:
    str: 生成的随机字符串。
    """
    char_pool = ""
    if use_letters:
        char_pool += string.ascii_letters
    if use_digits:
        char_pool += string.digits
    if use_punctuation:
        char_pool += string.punctuation
    
    if not char_pool: # 如果用户什么都没选，默认只用小写字母
        char_pool = string.ascii_lowercase
        
    return ''.join(random.choice(char_pool) for _ in range(length))

# 示例
simple_id = generate_simple_random_string(8)
print(f"生成的8位随机ID (字母数字): {simple_id}")

complex_code = generate_simple_random_string(12, use_punctuation=True)
print(f"生成的12位复杂随机码: {complex_code}")

import random
from collections import Counter

def simulate_dice_rolls(num_rolls=100, num_sides=6):
    """
    模拟多次掷骰子并返回每次的结果及统计。

    参数:
    num_rolls (int): 掷骰子的次数。
    num_sides (int): 骰子的面数。

    返回:
    tuple: (包含所有掷骰结果的列表, 结果计数的Counter对象)
    """
    rolls = [random.randint(1, num_sides) for _ in range(num_rolls)]
    counts = Counter(rolls)
    return rolls, counts

# 示例
rolls_100, counts_100 = simulate_dice_rolls(100)
print(f"\n模拟掷100次6面骰子:")
# print(f"  所有结果: {rolls_100}") # 列表可能太长，选择性打印
print(f"  结果统计: {counts_100}")
print(f"  最常出现的点数: {counts_100.most_common(1)}")

import random

def get_weighted_reward(rewards_with_weights):
    """
    根据权重从奖励列表中随机抽取一个奖励。

    参数:
    rewards_with_weights (dict): 一个字典，键是奖励，值是对应的权重 (整数或浮点数)。
                                 例如: {'金币': 50, '装备': 30, '药水': 20}

    返回:
    any: 抽中的奖励。
    """
    if not rewards_with_weights:
        return None # 或者抛出异常
        
    population = list(rewards_with_weights.keys())
    weights = list(rewards_with_weights.values())
    
    return random.choices(population, weights=weights, k=1)[0]

# 示例
daily_rewards = {
    '100 金币': 60,
    '小体力药剂': 25,
    '随机材料包': 10,
    '稀有装备碎片': 5
}

print("\n模拟每日签到奖励抽取5次:")
for day in range(1, 6):
    reward = get_weighted_reward(daily_rewards)
    print(f"  第 {day} 天签到获得: {reward}")

import random
from datetime import date, timedelta

def get_random_date(start_date_str, end_date_str, date_format="%Y-%m-%d"):
    """
    在给定的开始日期和结束日期之间生成一个随机日期。

    参数:
    start_date_str (str): 开始日期字符串。
    end_date_str (str): 结束日期字符串。
    date_format (str): 日期字符串的格式。

    返回:
    datetime.date: 生成的随机日期对象，如果日期解析失败则返回None。
    """
    try:
        start_dt = date.strptime(start_date_str, date_format)
        end_dt = date.strptime(end_date_str, date_format)
    except ValueError:
        print("日期格式错误或日期无效。")
        return None

    if start_dt > end_dt:
        print("开始日期不能晚于结束日期。")
        return None

    time_between_dates = end_dt - start_dt
    days_between_dates = time_between_dates.days
    if days_between_dates < 0: return None # 再次检查以防万一

    random_number_of_days = random.randrange(days_between_dates + 1) # 加1使结束日期也可能被选中
    random_date = start_dt + timedelta(days=random_number_of_days)
    
    return random_date

# 示例
start = "2024-01-01"
end = "2024-12-31"
random_birthday = get_random_date(start, end)
if random_birthday:
    print(f"\n在 {start} 和 {end} 之间随机生成的生日: {random_birthday.strftime('%Y年%m月%d日')}")

invalid_start = "2025-01-01"
get_random_date(invalid_start, end) # 会打印错误信息

from print_utils import *
import os

# ============== 目录操作 ==============
print_header("目录操作")
current_directory = os.getcwd()
print_info(f"当前工作目录: {current_directory}")

new_dir_name = "my_test_directory"
if not os.path.exists(new_dir_name):
    os.mkdir(new_dir_name)  # 创建单级目录
    print_info(f"目录 '{new_dir_name}' 已创建。")

multi_level_dir = os.path.join("parent_dir", "child_dir")  # 推荐使用 os.path.join
os.makedirs(multi_level_dir, exist_ok=True)  # 递归创建，存在亦可
print_info(f"多级目录 '{multi_level_dir}' 已创建或已存在。")

print_info(f"当前目录内容: {os.listdir('.')[:5]}")  # 列出当前目录内容 (最多显示5个)

# ============== 路径操作 (os.path) ==============
print_header("路径操作 (os.path)")
file_path_str = "/usr/local/bin/python_script.py"  # 示例路径
print_info(f"处理路径: '{file_path_str}'")
print_info(f"  目录名: {os.path.dirname(file_path_str)}")  # 输出: /usr/local/bin
print_info(f"  文件名: {os.path.basename(file_path_str)}")  # 输出: python_script.py
print_info(f"  扩展名: {os.path.splitext(file_path_str)[1]}")  # 输出: .py
print_info(f"  分割 (主体, 扩展名): {os.path.splitext(file_path_str)}")  # 输出: ('/usr/local/bin/python_script', '.py')

path1 = "projects"
path2 = "my_project"
filename = "main.py"
full_project_path = os.path.join(current_directory, path1, path2, filename)
print_info(f"使用 os.path.join 拼接的路径: {full_project_path}")

# ============== 文件操作 ==============
print_header("文件操作")
test_file_name = "temp_file.txt"
with open(test_file_name, "w") as f:
    f.write("Hello from os module example!")

if os.path.exists(test_file_name):
    print_info(f"文件 '{test_file_name}' 存在。")
    print_info(f"  是否是文件: {os.path.isfile(test_file_name)}")
    print_info(f"  文件大小: {os.path.getsize(test_file_name)} 字节")

    renamed_file_name = "renamed_temp_file.txt"
    os.rename(test_file_name, renamed_file_name)  # 重命名
    print_info(f"文件已重命名为: '{renamed_file_name}'")

    os.remove(renamed_file_name)  # 删除文件
    print_info(f"文件 '{renamed_file_name}' 已删除。")
else:
    print_info(f"文件 '{test_file_name}' 不存在。")

# ============== 环境变量 ==============
print_header("环境变量")
python_path = os.environ.get('PYTHONPATH')  # 获取环境变量
print_info(f"环境变量 PYTHONPATH: {python_path if python_path else '未设置'}")
# os.environ['MY_CUSTOM_VAR'] = 'my_value' # 设置环境变量 (仅对当前进程及其子进程有效)

# ============== 执行系统命令 ==============
print_header("执行系统命令")
# print_info("执行系统命令 'ls -l' (或 'dir' on Windows):")
# return_code = os.system("ls -l" if os.name != 'nt' else "dir") # os.name 可以判断操作系统
# print_info(f"命令执行完毕，返回码: {return_code}")
print_info("更好的方式是使用 subprocess 模块，它提供了更强的控制能力和安全性。")

# ============== 清理创建的目录 ==============
# 使用更加优雅的方式去递归删除：(shutil.rmtree)
import shutil
def remove_directory(directory_path):
    if os.path.exists(directory_path):
        shutil.rmtree(directory_path)
        print_info(f"目录 '{directory_path}' 已成功删除。")
    else:
        print_info(f"目录 '{directory_path}' 不存在。")
remove_directory("parent_dir")

from print_utils import *
import os
import shutil

# --- 准备测试环境 ---
src_dir = "shutil_source_dir"
dst_dir_base = "shutil_dest_base"
os.makedirs(src_dir, exist_ok=True)
os.makedirs(dst_dir_base, exist_ok=True)

src_file = os.path.join(src_dir, "original_file.txt")
with open(src_file, "w") as f:
    f.write("源文件测试")

print_info(f"准备的源文件: {src_file}")

# 1. 复制文件
# shutil.copy(src, dst) 或 shutil.copy2(src, dst)
# 如果dst是一个目录，文件会被复制到该目录下并保持原名
# 如果dst是一个文件名，则文件会被复制并重命名为dst
copied_file_path = os.path.join(dst_dir_base, "copied_file.txt")
shutil.copy2(src_file, copied_file_path) # copy2 保留更多元数据
print_info(f"文件 '{src_file}' 已使用 copy2 复制到 '{copied_file_path}'")

# 2. 复制目录树
# shutil.copytree(src, dst)
# dst 必须是不存在的目录，copytree 会创建它
copied_tree_path = os.path.join(dst_dir_base, "copied_source_tree")
if os.path.exists(copied_tree_path): # 先清理，防止上次运行残留
    shutil.rmtree(copied_tree_path)
shutil.copytree(src_dir, copied_tree_path)
print_info(f"目录树 '{src_dir}' 已复制到 '{copied_tree_path}'")

# 3. 移动文件或目录
# shutil.move(src, dst)
moved_file_destination_dir = os.path.join(dst_dir_base, "moved_files_here")
os.makedirs(moved_file_destination_dir, exist_ok=True)
moved_file_path = shutil.move(copied_file_path, moved_file_destination_dir) # 移动文件
print_info(f"文件 '{copied_file_path}' 已移动到 '{moved_file_path}'") # move返回目标路径

moved_tree_path_new_name = os.path.join(dst_dir_base, "moved_source_tree_new_name")
shutil.move(copied_tree_path, moved_tree_path_new_name) # 移动并重命名目录
print_info(f"目录 '{copied_tree_path}' 已移动并重命名为 '{moved_tree_path_new_name}'")

# 4. 删除目录树
# shutil.rmtree(path) - 非常危险，会无提示删除所有内容
dir_to_delete_completely = os.path.join(dst_dir_base, "temp_delete_me")
os.makedirs(os.path.join(dir_to_delete_completely, "subdir"), exist_ok=True) # 创建一些内容
with open(os.path.join(dir_to_delete_completely, "file.txt"), "w") as f: f.write("temp")
print_info(f"准备删除目录: {dir_to_delete_completely}")
shutil.rmtree(dir_to_delete_completely)
print_info(f"目录 '{dir_to_delete_completely}' 已使用 rmtree 删除。")

# 5. 创建压缩包
# shutil.make_archive(base_name, format, root_dir)
# base_name 是不带扩展名的归档文件名
# format 是归档格式，如 'zip', 'tar', 'gztar', 'bztar'
# root_dir 是要压缩的根目录
archive_output_name = os.path.join(dst_dir_base, "my_archive") # 生成 my_archive.zip
shutil.make_archive(archive_output_name, 'zip', src_dir)
print_info(f"目录 '{src_dir}' 已压缩为 '{archive_output_name}.zip'")

# --- 清理测试环境 ---
shutil.rmtree(src_dir)
shutil.rmtree(dst_dir_base)
print_info("\nshutil 测试环境已清理。")

from print_utils import *
from pathlib import Path
import os  # 用于获取当前目录等辅助操作
import shutil  # 用于演示后清理目录

# =============================================================
# 0. pathlib 模块演示准备
# =============================================================
print_header("pathlib 模块功能演示")
# 创建一个临时的演示工作目录
DEMO_ROOT_DIR_NAME: str = "pathlib_demo_space"  # 演示目录名称
DEMO_ROOT_PATH: Path = Path.cwd() / DEMO_ROOT_DIR_NAME  # 使用 / 拼接


def setup_demo_environment(base_path: Path) -> None:
    """
    准备演示环境：创建目录结构和文件
    """
    print_info(f"创建演示环境于 {base_path}")
    if base_path.exists():
        shutil.rmtree(base_path)  # 递归删除清理旧环境
    base_path.mkdir(parents=True, exist_ok=True)  # Parents=True 确保父目录也创建 exist_ok=True 避免重复创建

    (base_path / "documents").mkdir()  # 创建 文件 目录
    (base_path / "images").mkdir()  # 创建 图片 目录
    (base_path / "archives").mkdir()  # 创建 压缩包 目录

    (base_path / "main_script.py").write_text("# 主脚本")  # 创建主脚本文件
    (base_path / "readme.md").write_text("# 项目说明")  # 创建项目说明文件
    (base_path / "data.csv").write_text("name,age\nJohn,30\nJane,25")  # 创建数据文件
    (base_path / "documents" / "report.pdf").write_text("# 报告")  # 创建文档文件
    (base_path / "images" / "logo.png").write_text("# 图片")  # 创建图片文件
    (base_path / "archives" / "archive.zip").write_text("# 压缩包")  # 创建压缩包文件

    # 在documents下递归创建三层目录结构的数字txt文件
    import random

    # 创建三层目录结构的数字文件
    for i in range(3):  # 第一层
        first_dir = base_path / "documents" / f"level_{i + 1}"
        first_dir.mkdir(exist_ok=True)

        for j in range(3):  # 第二层
            second_dir = first_dir / f"sublevel_{j + 1}"
            second_dir.mkdir(exist_ok=True)

            for k in range(5):  # 第三层，每个第三层目录创建5个文件
                file_num = random.randint(1, 100)
                (second_dir / f"file_{file_num}.txt").write_text(f"# 第{i + 1}层第{j + 1}子层的数字文件 {file_num}")

    print_success(f"演示环境准备完成于 {base_path}")


def cleanup_demo_environment(base_path: Path) -> None:
    """
    清理演示环境
    """
    print_info(f"清理演示环境于 {base_path}")
    if base_path.exists():
        shutil.rmtree(base_path)  # 递归删除演示目录
        print_success(f"演示环境清理完成，清理路径为 => {base_path}")


# =============================================================
# 1. Path 对象创建与基本属性
# =============================================================
def demo_path_creation_and_attributes(base_path: Path) -> None:
    print_subheader("1. Path 对象创建与基本属性")

    # 从字符串创建 Path 对象
    p1: Path = Path("/usr/local/bin")  # 绝对路径(示例)
    p2: Path = base_path / "main_script.py"  # 相对路径(示例)

    print_info(f"Path 对象 p1: {p1}")
    print_info(f"Path 对象 p2: {p2}")

    # 基本属性
    print_info(f"p1 是否为绝对路径: {p1.is_absolute()}")
    print_info(f"p2 是否为绝对路径: {p2.is_absolute()}")

    # 下面都以 p2 来做为演示
    print_info(f"p2 的文件名: {p2.name}")
    print_info(f"p2 的后缀: {p2.suffix}")
    print_info(f"p2 的父目录: {p2.parent}")
    print_info(f"p2 的祖先目录: {p2.parents}")
    print_info(f"p2 的绝对路径: {p2.resolve()}")
    print_info(f"p2 的规范化路径: {p2.as_posix()}")  # 用于跨平台路径表示
    print_info(f"p2 的网络路径: {p2.as_uri()}")  # 用于网络路径表示
    for i, parent_dir in enumerate(p2.parents):
        print_info(f"p2 的第 {i + 1} 个祖先目录: {parent_dir}")

    # 当前工作目录和用户主目录
    cwd_path: Path = Path.cwd()
    home_path: Path = Path.home()
    print_info(f"当前工作目录 (Path.cwd()): {cwd_path}")
    print_info(f"用户主目录 (Path.home()): {home_path}")


# =================================输出结果=================
r"""
  1. Path 对象创建与基本属性
 INFO: Path 对象 p1: \usr\local\bin
 INFO: Path 对象 p2: D:\python\PythonStudy\pathlib_demo_space\main_script.py
 INFO: p1 是否为绝对路径: False
 INFO: p2 是否为绝对路径: True
 INFO: p2 的文件名: main_script.py
 INFO: p2 的后缀: .py
 INFO: p2 的父目录: D:\python\PythonStudy\pathlib_demo_space
 INFO: p2 的祖先目录: <WindowsPath.parents>
 INFO: p2 的绝对路径: D:\python\PythonStudy\pathlib_demo_space\main_script.py
 INFO: p2 的规范化路径: D:/python/PythonStudy/pathlib_demo_space/main_script.py
 INFO: p2 的网络路径: file:///D:/python/PythonStudy/pathlib_demo_space/main_script.py
 INFO: p2 的第 1 个祖先目录: D:\python\PythonStudy\pathlib_demo_space
 INFO: p2 的第 2 个祖先目录: D:\python\PythonStudy
 INFO: p2 的第 3 个祖先目录: D:\python
 INFO: p2 的第 4 个祖先目录: D:\
 INFO: 当前工作目录 (Path.cwd()): D:\python\PythonStudy
 INFO: 用户主目录 (Path.home()): C:\Users\Prorise
"""


# ==============================输出结果====================================


# =============================================================
# 2. 路径拼接与解析
# =============================================================


def demo_path_joining_and_resolution(base_path: Path) -> None:
    """演示路径的拼接和解析。"""
    print_subheader("2. 路径拼接与解析")

    part1 = base_path
    part2: str = "documents"
    part3: str = "report_final.docx"

    # 使用 / 操作符拼接
    joined_path1 = Path = part1 / part2 / part3
    print_info(f"使用 / 操作符拼接: {joined_path1}")

    # 使用 joinPath () 方法拼接
    joined_path2 = part1.joinpath(part2, part3)
    print_info(f"使用 joinPath () 方法拼接: {joined_path2}")

    # 获取绝对路径
    #  前面我们创建了 base_path / "readme.md" 所以他应该是存在的
    readme_path: Path = base_path / "readme.md"
    if readme_path.exists():
        print_info(f"  'readme.md' 的相对路径: {readme_path}")
        print_info(f"  'readme.md' 的绝对路径 (absolute()): {readme_path.absolute()}")
        print_info(f"  'readme.md' 的解析后绝对路径 (resolve()): {readme_path.resolve()}")
    else:
        print_warning(f" 'readme.md' 不存在，无法进行绝对路径解析。")


# 输出结果
r"""
 INFO: 使用 / 操作符拼接: D:\python\PythonStudy\pathlib_demo_space\documents\report_final.docx
 INFO: 使用 joinPath () 方法拼接: D:\python\PythonStudy\pathlib_demo_space\documents\report_final.docx
 INFO:   'readme.md' 的相对路径: D:\python\PythonStudy\pathlib_demo_space\readme.md
 INFO:   'readme.md' 的绝对路径 (absolute()): D:\python\PythonStudy\pathlib_demo_space\readme.md
 INFO:   'readme.md' 的解析后绝对路径 (resolve()): D:\python\PythonStudy\pathlib_demo_space\readme.md
"""


# =============================================================
# 3. 检查路径类型和状态
# =============================================================
def demo_path_type_checks(base_path: Path) -> None:
    """演示检查路径的类型和状态。"""
    print_subheader("3. 检查路径类型和状态")

    file_p: Path = base_path / "readme.md"
    dir_p: Path = base_path / "documents"
    non_existent_p: Path = base_path / "non_existent_file.tmp"

    print_info(f"路径 '{file_p.name}':")
    print(f"  - 是否存在 (exists()): {file_p.exists()}")  # True
    print(f"  - 是否是文件 (is_file()): {file_p.is_file()}")  # True
    print(f"  - 是否是目录 (is_dir()): {file_p.is_dir()}")  # False

    print_info(f"路径 '{dir_p.name}':")
    print(f"  - 是否存在 (exists()): {dir_p.exists()}")  # True
    print(f"  - 是否是文件 (is_file()): {dir_p.is_file()}")  # False
    print(f"  - 是否是目录 (is_dir()): {dir_p.is_dir()}")  # True

    print_info(f"路径 '{non_existent_p.name}':")
    print(f"  - 是否存在 (exists()): {non_existent_p.exists()}")  # False


# =============================================================
# 4. 文件和目录操作
# =============================================================
def demo_file_directory_operations(base_path: Path) -> None:
    """演示文件的创建、读写和目录的创建、遍历。"""
    print_subheader("4. 文件和目录操作")

    # 创建新目录
    new_sub_dir: Path = base_path / "new_app_data" / "config"
    try:
        # parents=True: 如果父目录不存在，则一并创建
        # exist_ok=True: 如果目录已存在，不抛出错误
        new_sub_dir.mkdir(parents=True, exist_ok=True)
        print_success(f"  目录 '{new_sub_dir}' 已创建 (或已存在)。")

        # 在新目录中创建并写入文件
        config_file: Path = new_sub_dir / "settings.json"
        sample_json_data: str = '{"theme": "dark", "version": "1.0"}'
        config_file.write_text(sample_json_data, encoding="utf-8")
        print_success(f"  文件 '{config_file.name}' 已创建并写入内容。")

        # 读取文件内容
        read_data: str = config_file.read_text(encoding="utf-8")
        print_info(f"  从 '{config_file.name}' 读取的内容: {read_data}")

        # 重命名文件
        renamed_config_file: Path = new_sub_dir / "settings_v2.json"
        config_file.rename(renamed_config_file)
        print_success(f"  文件已重命名为: '{renamed_config_file.name}'")
        print_info(f"  旧路径 '{config_file}' 是否还存在: {config_file.exists()}")  # False
        print_info(f"  新路径 '{renamed_config_file}' 是否存在: {renamed_config_file.exists()}")  # True

        # 删除文件
        renamed_config_file.unlink(missing_ok=True)  # missing_ok=True: 如果文件不存在不报错
        print_warning(f"  文件 '{renamed_config_file.name}' 已删除。")

        # 删除空目录
        if new_sub_dir.is_dir(): new_sub_dir.rmdir()  # 只能删除空目录
        print_warning(f"  空目录 '{new_sub_dir}' 已删除。")
        # 如果要删除包含父目录的整个空结构，需要逐级删除或使用 shutil.rmtree 建议直接使用 shutil.rmtree
        if new_sub_dir.parent.is_dir() and not list(new_sub_dir.parent.iterdir()):
            new_sub_dir.parent.rmdir()
            print_warning(f"  空目录 '{new_sub_dir.parent}' 已删除。")


    except Exception as e:
        print_error(f"  文件/目录操作时发生错误: {e}")


# =============================================================
# 5. 目录遍历与文件搜索 (glob, rglob, iterdir)
# =============================================================
def demo_directory_iteration(base_path: Path) -> None:
    """演示遍历目录内容和使用 glob 搜索文件。"""
    print_subheader("5. 目录遍历与文件搜索")

    print_info(f"遍历 '{base_path / 'documents'}' 目录 (iterdir()):")
    docs_dir: Path = base_path / "documents"
    if docs_dir.is_dir():
        for item in docs_dir.iterdir():  # 只遍历当前目录下的内容
            item_type = "[目录]" if item.is_dir() else "[文件]"
            print(f" {item_type} {item.name}")
    
    # 使用 glob 搜索当前目录下的 .txt 文件
    print_info(f"\n在 '{base_path / 'documents'}' 目录下搜索所有 .txt 文件 (glob('*.txt')):")
    for txt_file in docs_dir.glob("*.txt"):
        print(f"  [文件] {txt_file.name}") #  这里按照道理来说他只能访问到level的目录，他的里面是下一级的子目录，所以是没有文件的
    
    # 使用 rglob 递归搜索所有子目录中的 .txt 文件
    print_info(f"\n在 '{base_path / 'documents'}' 及其所有子目录下搜索 .txt 文件 (rglob('*.txt')):")
    for txt_file in docs_dir.rglob("*.txt"): # 而 rglob 可以递归搜索所有子目录中的文件
        # 显示相对于 docs_dir 的路径
        rel_path = txt_file.relative_to(docs_dir)
        print(f"  [文件] {rel_path}")


if __name__ == '__main__':
    # 准备演示环境
    setup_demo_environment(DEMO_ROOT_PATH)

    # 清理演示环境
    # cleanup_demo_environment(DEMO_ROOT_PATH)

    # 演示Pathlib的所有操作属性
    # demo_path_creation_and_attributes(DEMO_ROOT_PATH)

    # 演示路径拼接与解析
    # demo_path_joining_and_resolution(DEMO_ROOT_PATH)

    # 演示检查路径的类型和状态
    # demo_path_type_checks(DEMO_ROOT_PATH)

    # 演示文件和目录操作
    # demo_file_directory_operations(DEMO_ROOT_PATH)

    # 演示目录遍历与文件搜索
    demo_directory_iteration(DEMO_ROOT_PATH)

from print_utils import *
from pathlib import Path
from typing import List, Generator # 用于类型注解

def find_files_by_extension(directory: Path, extension: str) -> Generator[Path, None, None]:
    """
    递归查找指定目录下具有特定扩展名的所有文件。

    参数:
        directory (Path): 要搜索的根目录。
        extension (str): 文件扩展名 (例如: ".txt", ".jpg")，注意包含点。

    返回:
        Generator[Path, None, None]: 一个生成器，逐个产生找到的文件路径对象。
    """
    print_info(f"在目录 '{directory}' 中递归查找所有 '{extension}' 文件...")
    if not directory.is_dir():
        print_error(f"错误: '{directory}' 不是一个有效的目录。")
        return
        
    # Path.rglob() 返回一个生成器
    for file_path in directory.rglob(f"*{extension}"): # 例如 "*.txt"
        if file_path.is_file(): # 确保是文件，因为 rglob 也可能匹配到带 .txt 后缀的目录名
            yield file_path

if __name__ == "__main__": # 仅在此场景独立运行时执行
    # 创建一些临时文件用于演示 find_files_by_extension
    _demo_search_path = Path.cwd() / "pathlib_find_demo"
    _demo_search_path.mkdir(exist_ok=True)
    (_demo_search_path / "doc1.txt").write_text("text content 1")
    (_demo_search_path / "image.png").touch()
    (_demo_search_path / "subfolder").mkdir(exist_ok=True)
    (_demo_search_path / "subfolder" / "doc2.txt").write_text("text content 2")
    (_demo_search_path / "subfolder" / "another.log").touch()
    (_demo_search_path / "archive.txt.gz").touch() # 注意这个后缀是 .gz

    print_header("find_files_by_extension 函数演示")
    found_files: List[Path] = list(find_files_by_extension(_demo_search_path, ".txt"))
    
    if found_files:
        print_success(f"找到以下 .txt 文件 (共 {len(found_files)} 个):")
        for f_path in found_files:
            print(f"  - {f_path}")
    else:
        print_warning("未找到任何 .txt 文件。")
    
    # 清理
    import shutil
    if _demo_search_path.exists():
        shutil.rmtree(_demo_search_path)
        print_info(f"已清理演示目录: {_demo_search_path}")

from print_utils import *
from pathlib import Path
from typing import Union # 用于类型注解

def ensure_directory_exists(dir_path: Union[str, Path]) -> Path:
    """
    确保指定的目录路径存在，如果不存在则创建它 (包括所有必需的父目录)。

    参数:
        dir_path (Union[str, Path]): 要确保存在的目录路径 (可以是字符串或Path对象)。

    返回:
        Path: 对应的Path对象。

    引发:
        OSError: 如果路径存在但不是一个目录，或者创建失败且非权限问题。
    """
    path_obj = Path(dir_path)
    print_info(f"检查并确保目录 '{path_obj}' 存在...")
    try:
        path_obj.mkdir(parents=True, exist_ok=True)
        # parents=True: 如果父目录不存在，一并创建。
        # exist_ok=True: 如果目录已存在，不引发 FileExistsError。
        print_success(f"目录 '{path_obj}' 现在已存在。")
        return path_obj
    except OSError as e: # 更广泛地捕获可能的OS错误，如权限问题
        print_error(f"创建目录 '{path_obj}' 时发生错误: {e}")
        raise # 将异常重新抛出，让调用者处理

if __name__ == "__main__": # 仅在此场景独立运行时执行
    print_header("ensure_directory_exists 函数演示")
    
    new_data_path_str = "project_alpha/raw_data/year_2025"
    
    # 演示使用字符串路径
    created_path_obj: Path = ensure_directory_exists(new_data_path_str)
    print_info(f"返回的 Path 对象: {created_path_obj}")
    print_info(f"  该路径是否是目录: {created_path_obj.is_dir()}")

    # 演示使用已存在的路径 (应该不会报错)
    ensure_directory_exists(created_path_obj)
    
    # 清理 (如果需要)
    import shutil
    # 要删除 project_alpha，需要先删除其父目录 (如果它是唯一的)
    # 或者直接删除 project_alpha (如果它是顶层创建的)
    top_level_created_dir = Path("project_alpha")
    if top_level_created_dir.exists():
        shutil.rmtree(top_level_created_dir)
        print_info(f"已清理演示目录: {top_level_created_dir}")

import zipfile
import os

# --- 准备测试文件 ---
zip_test_dir = "zip_test_files"
os.makedirs(zip_test_dir, exist_ok=True)
file1_path = os.path.join(zip_test_dir, "doc1.txt")
file2_path = os.path.join(zip_test_dir, "image.jpg") # 模拟文件
with open(file1_path, "w") as f: f.write("This is document one.")
with open(file2_path, "w") as f: f.write("Fake image data.")

zip_filename = "my_documents.zip"

# 1. 创建 ZIP 文件并添加文件
print(f"创建 ZIP 文件: {zip_filename}")
with zipfile.ZipFile(zip_filename, mode='w', compression=zipfile.ZIP_DEFLATED) as zf:
    zf.write(file1_path, arcname="text_files/document1.txt") # arcname 指定在zip中的路径和名称
    zf.write(file2_path, arcname="images/photo.jpg")
    zf.writestr("manuals/readme.txt", "This is a readme file created directly in zip.") # 直接写入字符串内容
print("ZIP 文件创建完成。")

# 2. 读取 ZIP 文件内容
print(f"\n读取 ZIP 文件 '{zip_filename}' 的内容:")
with zipfile.ZipFile(zip_filename, mode='r') as zf:
    print("  文件列表 (namelist):")
    for name in zf.namelist():
        print(f"    - {name}")
    
    print("\n  文件详细信息 (infolist):")
    for zipinfo in zf.infolist():
        print(f"    - 文件名: {zipinfo.filename}, 大小: {zipinfo.file_size} bytes, 修改日期: {zipinfo.date_time}")

    # 读取特定文件内容
    try:
        readme_content = zf.read("manuals/readme.txt")
        print(f"\n  'manuals/readme.txt' 的内容: {readme_content.decode('utf-8')}")
    except KeyError:
        print("  'manuals/readme.txt' 未在压缩包中找到。")


# 3. 解压 ZIP 文件
extract_to_dir = "extracted_zip_contents"
os.makedirs(extract_to_dir, exist_ok=True) # 确保解压目录存在
print(f"\n解压 ZIP 文件 '{zip_filename}' 到 '{extract_to_dir}':")
with zipfile.ZipFile(zip_filename, mode='r') as zf:
    zf.extractall(path=extract_to_dir)
    # # 或者只解压特定文件
    # zf.extract("images/photo.jpg", path=os.path.join(extract_to_dir, "specific_image"))
print(f"ZIP 文件解压完成。查看 '{extract_to_dir}' 目录。")

# --- 清理 ---
os.remove(zip_filename)
shutil.rmtree(zip_test_dir)
shutil.rmtree(extract_to_dir)
print("\nzipfile 测试环境已清理。")

import tarfile
import os
import shutil # 用于清理

# --- 准备测试文件 ---
tar_test_dir = "tar_test_files"
os.makedirs(tar_test_dir, exist_ok=True)
os.makedirs(os.path.join(tar_test_dir, "subdir"), exist_ok=True) # 创建子目录

file_content1 = "Content for tar file 1."
file_content2 = "Content for tar file 2, in a subdirectory."
path_file1 = os.path.join(tar_test_dir, "data.txt")
path_file2 = os.path.join(tar_test_dir, "subdir", "notes.log")

with open(path_file1, "w") as f: f.write(file_content1)
with open(path_file2, "w") as f: f.write(file_content2)

tar_gz_filename = "my_archive.tar.gz" # 创建 .tar.gz 格式的压缩包

# 1. 创建 TAR 归档文件 (例如 .tar.gz)
print(f"创建 TAR.GZ 文件: {tar_gz_filename}")
# mode 'w:gz' 表示以 gzip 压缩方式写入
with tarfile.open(tar_gz_filename, mode='w:gz') as tf:
    tf.add(tar_test_dir, arcname="archive_root") # 添加整个目录，arcname指定其在压缩包内的根名称
    # # 或者分别添加文件
    # tf.add(path_file1, arcname="text_files/data_document.txt")
    # tf.add(path_file2, arcname="logs/important_notes.log")
print("TAR.GZ 文件创建完成。")

# 2. 读取 TAR 归档文件内容
print(f"\n读取 TAR 文件 '{tar_gz_filename}' 的内容:")
with tarfile.open(tar_gz_filename, mode='r:gz') as tf: # 'r:gz' 表示以 gzip 方式读取
    print("  文件列表 (getnames):")
    for name in tf.getnames():
        print(f"    - {name}")
    
    print("\n  文件详细信息 (getmembers):")
    for tarinfo in tf.getmembers():
        type_str = "DIR" if tarinfo.isdir() else ("FILE" if tarinfo.isfile() else "OTHER")
        print(f"    - 名称: {tarinfo.name}, 类型: {type_str}, 大小: {tarinfo.size}, 修改时间: {tarinfo.mtime}")

    # 读取特定文件内容 (不解压到磁盘)
    try:
        member_to_read = "archive_root/subdir/notes.log" # 假设这是压缩包内的路径
        if member_to_read in tf.getnames():
            extracted_file_obj = tf.extractfile(member_to_read)
            if extracted_file_obj:
                content_bytes = extracted_file_obj.read()
                print(f"\n  '{member_to_read}' 的内容: {content_bytes.decode('utf-8')}")
                extracted_file_obj.close()
        else:
            print(f"  文件 '{member_to_read}' 在归档中未找到。")
            
    except KeyError as e:
        print(f"  读取归档成员时出错: {e}")


# 3. 解压 TAR 归档文件
extract_tar_to_dir = "extracted_tar_contents"
os.makedirs(extract_tar_to_dir, exist_ok=True)
print(f"\n解压 TAR 文件 '{tar_gz_filename}' 到 '{extract_tar_to_dir}':")
with tarfile.open(tar_gz_filename, mode='r:gz') as tf:
    tf.extractall(path=extract_tar_to_dir)
print(f"TAR 文件解压完成。查看 '{extract_tar_to_dir}' 目录。")

# --- 清理 ---
os.remove(tar_gz_filename)
shutil.rmtree(tar_test_dir)
shutil.rmtree(extract_tar_to_dir)
print("\ntarfile 测试环境已清理。")