Python进行时间单位换算的完全指南

from datetime import datetime, timedelta

# 当前时间
now = datetime.now()
print(f"当前时间: {now}")

# 创建特定时间
specific_time = datetime(2023, 12, 31, 23, 59, 59)
print(f"特定时间: {specific_time}")

# 时间运算
tomorrow = now + timedelta(days=1)
last_week = now - timedelta(weeks=1)
print(f"明天: {tomorrow}, 上周: {last_week}")

# 时间差计算
time_diff = tomorrow - now
print(f"时间差: {time_diff.total_seconds()}秒")

class TimeConverter:
    """时间单位换算器"""
    UNITS = {
        'ns': 1e-9,
        'μs': 1e-6,
        'ms': 1e-3,
        's': 1,
        'min': 60,
        'h': 3600,
        'd': 86400,
        'w': 604800,
        'y': 31536000  # 365天年
    }
    
    def convert(value, from_unit, to_unit):
        """时间单位转换"""
        seconds = value * TimeConverter.UNITS[from_unit]
        return seconds / TimeConverter.UNITS[to_unit]

# 使用示例
print("1天等于多少小时:", TimeConverter.convert(1, 'd', 'h'))  # 24.0
print("1周等于多少秒:", TimeConverter.convert(1, 'w', 's'))    # 604800.0

def financial_time_conversion(value, from_unit, to_unit):
    """金融时间换算"""
    # 金融时间单位
    fin_units = {
        'trading_day': 6.5 * 3600,  # 6.5小时交易日
        'business_day': 8 * 3600,    # 8小时工作日
        'settlement_cycle': 3 * 86400  # 3天结算周期
    }
    
    # 转换为秒
    if from_unit in fin_units:
        seconds = value * fin_units[from_unit]
    else:
        seconds = value * TimeConverter.UNITS[from_unit]
    
    # 转换为目标单位
    if to_unit in fin_units:
        return seconds / fin_units[to_unit]
    else:
        return seconds / TimeConverter.UNITS[to_unit]

# 使用示例
print("2个交易日等于多少小时:", financial_time_conversion(2, 'trading_day', 'h'))  # 13.0

from datetime import datetime
import pytz

# 创建带时区时间
utc_time = datetime.now(pytz.utc)
print(f"UTC时间: {utc_time}")

# 转换时区
ny_tz = pytz.timezone('America/New_York')
ny_time = utc_time.astimezone(ny_tz)
print(f"纽约时间: {ny_time}")

# 处理夏令时
tz = pytz.timezone('Europe/London')
pre_dst = datetime(2023, 3, 25, 12, 0, tzinfo=pytz.utc).astimezone(tz)
post_dst = datetime(2023, 3, 26, 12, 0, tzinfo=pytz.utc).astimezone(tz)
print(f"夏令时前: {pre_dst} (UTC偏移: {pre_dst.utcoffset()})")
print(f"夏令时后: {post_dst} (UTC偏移: {post_dst.utcoffset()})")

def global_meeting_time(local_time, local_tz, participants):
    """计算全球化会议时间"""
    # 本地时间转UTC
    local = pytz.timezone(local_tz)
    utc_time = local.localize(local_time).astimezone(pytz.utc)
    
    # 为每个参与者转换时间
    results = {}
    for person, tz_name in participants.items():
        tz = pytz.timezone(tz_name)
        person_time = utc_time.astimezone(tz)
        results[person] = person_time
    
    return results

# 使用示例
meeting_time = datetime(2023, 12, 15, 14, 0)  # 本地时间
participants = {
    'John': 'America/New_York',
    'Sarah': 'Europe/London',
    'Yuki': 'Asia/Tokyo'
}

global_times = global_meeting_time(meeting_time, 'Asia/Shanghai', participants)
for person, time in global_times.items():
    print(f"{person} 时间: {time.strftime('%Y-%m-%d %H:%M %Z%z')}")

import pandas as pd

# 创建时间序列
date_rng = pd.date_range(start='2023-01-01', end='2023-01-10', freq='D')
time_series = pd.Series(range(len(date_rng)), index=date_rng)

# 时间重采样
resampled = time_series.resample('3D').sum()
print("3天重采样:\n", resampled)

# 时区转换
time_series_utc = time_series.tz_localize('UTC')
time_series_ny = time_series_utc.tz_convert('America/New_York')
print("纽约时间序列:\n", time_series_ny.head())

def analyze_time_series(data, freq='D'):
    """时间序列分析"""
    # 转换为时间序列
    ts = pd.Series(data['value'], index=pd.to_datetime(data['timestamp']))
    
    # 重采样到指定频率
    ts_resampled = ts.resample(freq).mean()
    
    # 时间特征提取
    ts_features = {
        'mean': ts_resampled.mean(),
        'std': ts_resampled.std(),
        'min': ts_resampled.min(),
        'max': ts_resampled.max(),
        'trend': ts_resampled.diff().mean()  # 趋势
    }
    
    # 季节性分解
    from statsmodels.tsa.seasonal import seasonal_decompose
    decomposition = seasonal_decompose(ts_resampled.fillna(0), model='additive')
    
    return ts_features, decomposition

# 使用示例
data = {
    'timestamp': pd.date_range(start='2023-01-01', periods=100, freq='H'),
    'value': np.random.rand(100) * 10
}
features, decomposition = analyze_time_series(data, freq='6H')
print("时间序列特征:", features)

import pandas_market_calendars as mcal

def get_trading_days(exchange, start, end):
    """获取交易日历"""
    calendar = mcal.get_calendar(exchange)
    schedule = calendar.schedule(start_date=start, end_date=end)
    return schedule.index

# 使用示例
trading_days = get_trading_days('NYSE', '2023-01-01', '2023-03-31')
print(f"NYSE交易日数量: {len(trading_days)}")

def business_days_between(start, end):
    """计算工作日天数"""
    from pandas.tseries.offsets import BDay
    return len(pd.date_range(start, end, freq=BDay()))

# 使用示例
start = datetime(2023, 1, 1)
end = datetime(2023, 1, 31)
print(f"1月工作日天数: {business_days_between(start, end)}")

class HighPrecisionTimer:
    """高精度金融时间戳"""
    def __init__(self):
        self.start = time.perf_counter_ns()
    
    def timestamp(self):
        """获取纳秒级时间戳"""
        return time.perf_counter_ns() - self.start
    
    def format_timestamp(self, ts):
        """格式化时间戳"""
        # 转换为秒.纳秒
        seconds = ts // 1_000_000_000
        nanoseconds = ts % 1_000_000_000
        return f"{seconds}.{nanoseconds:09d}"
    
    def trade_timestamp(self):
        """生成交易时间戳"""
        now = datetime.utcnow()
        return f"{now.strftime('%Y%m%d-%H%M%S')}.{now.microsecond:06d}"

# 使用示例
timer = HighPrecisionTimer()
time.sleep(0.001)
ts = timer.timestamp()
print(f"高精度时间戳: {timer.format_timestamp(ts)}")
print(f"交易时间戳: {timer.trade_timestamp()}")

import astropy.time as astro_time

def convert_astronomical_times():
    """天文时间转换"""
    # 创建时间对象
    t = astro_time.Time('2023-04-15 12:00:00', format='iso', scale='utc')
    
    # 转换为儒略日
    jd = t.jd
    print(f"儒略日: {jd}")
    
    # 转换为修正儒略日
    mjd = t.mjd
    print(f"修正儒略日: {mjd}")
    
    # 转换为不同时间尺度
    t_tai = t.tai
    print(f"国际原子时: {t_tai.iso}")
    
    # 转换为不同历法
    t_julian = t.datetime
    print(f"儒略历: {t_julian}")
    
    return jd, mjd

# 使用示例
jd, mjd = convert_astronomical_times()

class ExperimentTimer:
    """物理实验时间同步系统"""
    def __init__(self, reference_time=None):
        self.reference = reference_time or time.time()
        self.offsets = {}
    
    def sync_device(self, device_id, device_time):
        """同步设备时间"""
        current_time = time.time()
        offset = current_time - device_time
        self.offsets[device_id] = offset
        return offset
    
    def get_device_time(self, device_id, timestamp):
        """转换设备时间到系统时间"""
        offset = self.offsets.get(device_id, 0)
        return timestamp + offset
    
    def precise_delay(self, delay_seconds):
        """高精度延时"""
        start = time.perf_counter()
        while time.perf_counter() - start < delay_seconds:
            pass

# 使用示例
exp = ExperimentTimer()

# 同步设备
device1_time = time.time() - 0.5  # 模拟设备时间偏差
exp.sync_device('sensor1', device1_time)

# 转换设备时间
device_timestamp = time.time() - 0.3
system_time = exp.get_device_time('sensor1', device_timestamp)
print(f"设备时间 {device_timestamp} -> 系统时间 {system_time}")

# 高精度延时
exp.precise_delay(0.0001)  # 100微秒延时

import numpy as np

def vectorized_time_conversion(timestamps, from_tz, to_tz):
    """向量化时区转换"""
    # 创建时间索引
    index = pd.DatetimeIndex(timestamps)
    
    # 本地化
    if from_tz:
        index = index.tz_localize(from_tz)
    
    # 转换时区
    if to_tz:
        index = index.tz_convert(to_tz)
    
    return index

# 使用示例
timestamps = pd.date_range('2023-01-01', periods=1000000, freq='S')
converted = vectorized_time_conversion(timestamps, 'UTC', 'Asia/Shanghai')

# 性能对比
%timeit [pd.Timestamp(ts).tz_convert('Asia/Shanghai') for ts in timestamps]  # 慢
%timeit vectorized_time_conversion(timestamps, 'UTC', 'Asia/Shanghai')       # 快

import dateutil.parser

def fast_date_parsing(dates):
    """快速日期解析"""
    # 预编译解析器
    parser = dateutil.parser.parser()
    
    # 批量解析
    return [parser.parse(d) for d in dates]

# 自定义格式解析
def parse_custom_format(dates, fmt):
    """自定义格式快速解析"""
    # 使用datetime.strptime
    return [datetime.strptime(d, fmt) for d in dates]

# 使用示例
date_strings = ['2023-01-01', '2023-02-15', '2023-12-31']
parsed = fast_date_parsing(date_strings)
print("解析结果:", parsed)

# 性能优化
large_dates = [f"2023-{m:02d}-{d:02d}" for m in range(1,13) for d in range(1,29)]
%timeit fast_date_parsing(large_dates)  # 使用dateutil
%timeit parse_custom_format(large_dates, '%Y-%m-%d')  # 自定义格式

import ntplib
from datetime import datetime, timezone

def sync_ntp_time(server='pool.ntp.org'):
    """NTP时间同步"""
    client = ntplib.NTPClient()
    response = client.request(server, version=3)
    
    # 获取时间
    ntp_time = datetime.fromtimestamp(response.tx_time, tz=timezone.utc)
    local_time = datetime.now(timezone.utc)
    
    # 计算偏移
    offset = (local_time - ntp_time).total_seconds()
    return ntp_time, offset

# 使用示例
ntp_time, offset = sync_ntp_time()
print(f"NTP时间: {ntp_time}, 本地偏移: {offset:.6f}秒")

class VectorClock:
    """分布式系统向量时钟"""
    def __init__(self, node_id, nodes):
        self.node_id = node_id
        self.clock = {node: 0 for node in nodes}
    
    def increment(self):
        """本地事件递增"""
        self.clock[self.node_id] += 1
        return self.clock.copy()
    
    def update(self, received_clock):
        """更新时钟"""
        for node in self.clock:
            self.clock[node] = max(self.clock[node], received_clock.get(node, 0))
        self.clock[self.node_id] += 1  # 接收事件递增
        return self.clock.copy()
    
    def compare(self, other_clock):
        """比较时钟"""
        less = all(self.clock[node] <= other_clock[node] for node in self.clock)
        greater = all(self.clock[node] >= other_clock[node] for node in self.clock)
        
        if less and not greater:
            return -1  # 发生在之前
        elif greater and not less:
            return 1   # 发生在之后
        elif less and greater:
            return 0   # 同时
        else:
            return None # 并发

# 使用示例
nodes = ['node1', 'node2', 'node3']
clock1 = VectorClock('node1', nodes)
clock2 = VectorClock('node2', nodes)

# 节点1发生事件
event1 = clock1.increment()
print("节点1时钟:", event1)

# 节点2发生事件
event2 = clock2.increment()
print("节点2时钟:", event2)

# 节点1接收节点2时钟
clock1.update(event2)
print("节点1更新后:", clock1.clock)

# 比较事件顺序
print("事件1 vs 事件2:", clock1.compare(event2))  # 1 (事件1在事件2后)