python time包精讲及异常处理

# 查看时间常量
import time

print("本地时区与utc差值（秒）：", time.timezone)       # 东8区输出 -28800
print("夏令时时区与utc差值（秒）：", time.altzone)    # 东8区夏令时输出 -32400
print("是否启用夏令时：", time.daylight)             # 国内无夏令时，输出 0
print("每秒时钟滴答数：", time.clocks_per_sec)       # 输出 1000000

# 全量时钟函数示例
import time

# 1. 时间戳与结构化时间互转
ts = time.time()
st_local = time.localtime(ts)
st_utc = time.gmtime(ts)
ts_back = time.mktime(st_local)  # 本地结构化时间转回时间戳
print(f"原时间戳：{ts:.6f}，转回后：{ts_back:.6f}")  # 精度一致

# 2. 纳秒级计时（避免浮点误差）
start_ns = time.perf_counter_ns()
time.sleep(0.1)
end_ns = time.perf_counter_ns()
print(f"耗时（纳秒）：{end_ns - start_ns}")  # 输出≈100000000纳秒

# 3. 线程cpu时间
import threading
def thread_func():
    start = time.thread_time_ns()
    for i in range(1000000):
        pass
    end = time.thread_time_ns()
    print(f"线程cpu耗时：{end - start} 纳秒")

t = threading.thread(target=thread_func)
t.start()
t.join()

# 4. 查看时钟信息
for clock_name in ["time", "perf_counter", "monotonic", "process_time"]:
    info = time.get_clock_info(clock_name)
    print(f"\n{clock_name} 时钟信息：")
    print(f"  分辨率：{info.resolution} 秒")
    print(f"  是否单调：{info.monotonic}")
    print(f"  是否可调：{info.adjustable}")

# 全量占位符示例
st = time.localtime()

# 1. 微秒级格式化（python扩展）
time_micro = time.strftime("%y-%m-%d %h:%m:%s.%f", st)
print("微秒级时间：", time_micro)  # 输出：2026-03-03 14:30:45.123456

# 2. 时区偏移（±hhmm）
time_tz = time.strftime("%y-%m-%d %h:%m:%s %z", st)
print("带时区偏移的时间：", time_tz)  # 输出：2026-03-03 14:30:45 +0800

# 3. 年内第几周（周一为起点）
week_info = time.strftime("今年第%w周（周一为起点）", st)
print(week_info)  # 输出：今年第09周（周一为起点）

# 4. 本地默认格式
local_date = time.strftime("%x", st)
local_time = time.strftime("%x", st)
print("本地日期格式：", local_date)  # 输出：03/03/26
print("本地时间格式：", local_time)  # 输出：14:30:45

# sleep 高级用法：分段休眠（避免长时间阻塞）
def safe_sleep(total_seconds, chunk=0.1):
    """
    分段休眠，避免单次休眠过长导致程序无法中断
    :param total_seconds: 总休眠时间
    :param chunk: 每次休眠的小时间段
    """
    remaining = total_seconds
    while remaining > 0:
        sleep_time = min(chunk, remaining)
        time.sleep(sleep_time)
        remaining -= sleep_time
        # 可在此处添加中断逻辑（如检测信号）
        print(f"剩余休眠时间：{remaining:.2f} 秒")

# 测试分段休眠（总休眠1秒，每次休眠0.1秒）
print("开始分段休眠...")
safe_sleep(1.0)
print("分段休眠结束！")

# tzset 用法（仅linux/macos）
import os
if os.name == "posix":
    # 设置时区为纽约（西5区）
    os.environ["tz"] = "america/new_york"
    time.tzset()
    print("纽约时间：", time.strftime("%y-%m-%d %h:%m:%s %z", time.localtime()))
    # 恢复时区为上海
    os.environ["tz"] = "asia/shanghai"
    time.tzset()
    print("上海时间：", time.strftime("%y-%m-%d %h:%m:%s %z", time.localtime()))
else:
    print("⚠️ windows不支持tzset()，建议用datetime模块处理时区")

# 跨平台高精度休眠（补偿windows休眠精度）
def high_precision_sleep(seconds):
    """
    高精度休眠，适配windows系统的低精度sleep
    :param seconds: 目标休眠时间（秒）
    """
    start = time.perf_counter()
    while time.perf_counter() - start < seconds:
        # 空循环等待，直到达到目标时间
        pass

# 测试高精度休眠（休眠0.001秒=1毫秒）
import datetime
start = datetime.datetime.now()
high_precision_sleep(0.001)
end = datetime.datetime.now()
actual = (end - start).total_seconds()
print(f"目标休眠：0.001秒，实际休眠：{actual:.6f}秒")

# 优化前：循环内频繁调用计时函数
def slow_timer():
    start = time.perf_counter()
    for i in range(1000000):
        current = time.perf_counter()  # 100万次函数调用，耗时高
    end = time.perf_counter()
    print(f"优化前耗时：{end - start:.6f}秒")

# 优化后：仅在循环前后调用
def fast_timer():
    start = time.perf_counter()
    for i in range(1000000):
        pass
    end = time.perf_counter()
    print(f"优化后耗时：{end - start:.6f}秒")

slow_timer()
fast_timer()

import functools

# 预编译格式化函数
@functools.lru_cache(maxsize=none)
def get_formatter(format_str):
    """缓存格式化函数，避免重复解析格式字符串"""
    def formatter(struct_time):
        return time.strftime(format_str, struct_time)
    return formatter

# 测试批量格式化（10万次）
format_str = "%y-%m-%d %h:%m:%s"
formatter = get_formatter(format_str)
st = time.localtime()

start = time.perf_counter()
for i in range(100000):
    formatter(st)
end = time.perf_counter()
print(f"批量格式化耗时：{end - start:.6f}秒")

# 健壮的时间解析函数
def safe_strptime(time_str, format_str, default=none):
    """
    安全的时间解析函数，捕获异常并返回默认值
    :param time_str: 时间字符串
    :param format_str: 格式字符串
    :param default: 解析失败时的默认值
    :return: struct_time 或 default
    """
    try:
        return time.strptime(time_str, format_str)
    except valueerror as e:
        print(f"时间解析失败：{e}，使用默认值")
        return default
    except typeerror as e:
        print(f"参数类型错误：{e}，使用默认值")
        return default

# 测试异常场景
# 1. 格式不匹配
invalid_format = safe_strptime("2026-03-03", "%y/%m/%d", time.localtime())
print("格式不匹配时的默认值：", time.strftime("%y-%m-%d", invalid_format))

# 2. 无效时间戳
try:
    time.localtime(1e30)  # 超出范围的时间戳
except valueerror as e:
    print(f"无效时间戳：{e}")
    # 回退到当前时间
    st = time.localtime()
    print("回退到当前时间：", time.strftime("%y-%m-%d", st))

# 3. 安全休眠
def safe_sleep(seconds):
    if not isinstance(seconds, (int, float)):
        raise typeerror("休眠时间必须是数值类型")
    if seconds < 0:
        raise valueerror("休眠时间不能为负数")
    time.sleep(seconds)

# 测试安全休眠
try:
    safe_sleep(-1)
except valueerror as e:
    print(f"休眠异常：{e}")

import time
import statistics

class performancetester:
    """
    基于time包的高精度性能测试框架
    """
    def __init__(self, func, warmup=100, runs=1000):
        """
        :param func: 要测试的函数
        :param warmup: 预热次数（避免冷启动影响）
        :param runs: 测试次数
        """
        self.func = func
        self.warmup = warmup
        self.runs = runs
        self.timings = []

    def run(self, *args, **kwargs):
        """执行性能测试"""
        # 预热
        for _ in range(self.warmup):
            self.func(*args, **kwargs)
        
        # 正式测试（纳秒级计时）
        for _ in range(self.runs):
            start = time.perf_counter_ns()
            self.func(*args, **kwargs)
            end = time.perf_counter_ns()
            self.timings.append(end - start)
        
        # 计算统计结果
        return {
            "mean": statistics.mean(self.timings) / 1e6,  # 平均耗时（毫秒）
            "median": statistics.median(self.timings) / 1e6,  # 中位数（毫秒）
            "min": min(self.timings) / 1e6,  # 最小耗时（毫秒）
            "max": max(self.timings) / 1e6,  # 最大耗时（毫秒）
            "std": statistics.stdev(self.timings) / 1e6  # 标准差（毫秒）
        }

# 测试示例：排序函数性能
def test_func():
    lst = [i for i in range(1000)]
    lst.sort()

# 初始化测试器（预热100次，测试1000次）
tester = performancetester(test_func, warmup=100, runs=1000)
# 执行测试
results = tester.run()
# 输出结果
print("性能测试结果（毫秒）：")
for key, value in results.items():
    print(f"  {key}: {value:.6f}")

import time
import requests

def check_time_sync(ntp_server="pool.ntp.org", timeout=5):
    """
    校验本地时间与ntp服务器的同步性
    :param ntp_server: ntp服务器地址
    :param timeout: 超时时间
    :return: 时间差（秒），正数表示本地时间快，负数表示慢
    """
    try:
        # 从ntp服务器获取utc时间（简化版，实际需用ntplib库）
        # 此处用http api模拟
        response = requests.get(f"http://{ntp_server}/time", timeout=timeout)
        ntp_utc_ts = float(response.text)
        # 本地utc时间戳
        local_utc_ts = time.time() + time.timezone  # 本地时间戳 - 时区差 = utc时间戳
        # 计算时间差
        time_diff = local_utc_ts - ntp_utc_ts
        print(f"本地utc时间戳：{local_utc_ts:.6f}")
        print(f"ntp utc时间戳：{ntp_utc_ts:.6f}")
        print(f"时间差：{time_diff:.6f} 秒")
        return time_diff
    except exception as e:
        print(f"时间同步校验失败：{e}")
        return none

# 测试时间同步（需替换为真实ntp api）
# check_time_sync()