from datetime import datetime, timedelta

# 當(dāng)前時間
now = datetime.now()
print(f"當(dāng)前時間: {now}")

# 創(chuàng)建特定時間
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):
        """時間單位轉(zhuǎn)換"""
        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天結(jié)算周期
    }
    
    # 轉(zhuǎn)換為秒
    if from_unit in fin_units:
        seconds = value * fin_units[from_unit]
    else:
        seconds = value * TimeConverter.UNITS[from_unit]
    
    # 轉(zhuǎn)換為目標單位
    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

# 創(chuàng)建帶時區(qū)時間
utc_time = datetime.now(pytz.utc)
print(f"UTC時間: {utc_time}")

# 轉(zhuǎn)換時區(qū)
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):
    """計算全球化會議時間"""
    # 本地時間轉(zhuǎn)UTC
    local = pytz.timezone(local_tz)
    utc_time = local.localize(local_time).astimezone(pytz.utc)
    
    # 為每個參與者轉(zhuǎn)換時間
    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

# 創(chuàng)建時間序列
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)

# 時區(qū)轉(zhuǎn)換
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'):
    """時間序列分析"""
    # 轉(zhuǎn)換為時間序列
    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()  # 趨勢
    }
    
    # 季節(jié)性分解
    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交易日數(shù)量: {len(trading_days)}")

def business_days_between(start, end):
    """計算工作日天數(shù)"""
    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月工作日天數(shù): {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):
        """格式化時間戳"""
        # 轉(zhuǎn)換為秒.納秒
        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():
    """天文時間轉(zhuǎn)換"""
    # 創(chuàng)建時間對象
    t = astro_time.Time('2023-04-15 12:00:00', format='iso', scale='utc')
    
    # 轉(zhuǎn)換為儒略日
    jd = t.jd
    print(f"儒略日: {jd}")
    
    # 轉(zhuǎn)換為修正儒略日
    mjd = t.mjd
    print(f"修正儒略日: {mjd}")
    
    # 轉(zhuǎn)換為不同時間尺度
    t_tai = t.tai
    print(f"國際原子時: {t_tai.iso}")
    
    # 轉(zhuǎn)換為不同歷法
    t_julian = t.datetime
    print(f"儒略歷: {t_julian}")
    
    return jd, mjd

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

class ExperimentTimer:
    """物理實驗時間同步系統(tǒng)"""
    def __init__(self, reference_time=None):
        self.reference = reference_time or time.time()
        self.offsets = {}
    
    def sync_device(self, device_id, device_time):
        """同步設(shè)備時間"""
        current_time = time.time()
        offset = current_time - device_time
        self.offsets[device_id] = offset
        return offset
    
    def get_device_time(self, device_id, timestamp):
        """轉(zhuǎn)換設(shè)備時間到系統(tǒng)時間"""
        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()

# 同步設(shè)備
device1_time = time.time() - 0.5  # 模擬設(shè)備時間偏差
exp.sync_device('sensor1', device1_time)

# 轉(zhuǎn)換設(shè)備時間
device_timestamp = time.time() - 0.3
system_time = exp.get_device_time('sensor1', device_timestamp)
print(f"設(shè)備時間 {device_timestamp} -> 系統(tǒng)時間 {system_time}")

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

import numpy as np

def vectorized_time_conversion(timestamps, from_tz, to_tz):
    """向量化時區(qū)轉(zhuǎn)換"""
    # 創(chuàng)建時間索引
    index = pd.DatetimeIndex(timestamps)
    
    # 本地化
    if from_tz:
        index = index.tz_localize(from_tz)
    
    # 轉(zhuǎn)換時區(qū)
    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):
    """快速日期解析"""
    # 預(yù)編譯解析器
    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("解析結(jié)果:", parsed)

# 性能優(yōu)化
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:
    """分布式系統(tǒng)向量時鐘"""
    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  # 發(fā)生在之前
        elif greater and not less:
            return 1   # 發(fā)生在之后
        elif less and greater:
            return 0   # 同時
        else:
            return None # 并發(fā)

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

# 節(jié)點1發(fā)生事件
event1 = clock1.increment()
print("節(jié)點1時鐘:", event1)

# 節(jié)點2發(fā)生事件
event2 = clock2.increment()
print("節(jié)點2時鐘:", event2)

# 節(jié)點1接收節(jié)點2時鐘
clock1.update(event2)
print("節(jié)點1更新后:", clock1.clock)

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