import pytz
from datetime import datetime

# 創(chuàng)建時區(qū)對象
utc = pytz.utc
shanghai = pytz.timezone('Asia/Shanghai')
new_york = pytz.timezone('America/New_York')

# 時區(qū)關鍵屬性
print(f"上海時區(qū): {shanghai}")
print(f"時區(qū)名稱: {shanghai.zone}")
print(f"UTC偏移: {shanghai.utcoffset(datetime.now())}")
print(f"夏令時規(guī)則: {shanghai.dst(datetime.now())}")

# 查看所有時區(qū)
all_timezones = pytz.all_timezones
print(f"總時區(qū)數(shù): {len(all_timezones)}")
print("常見時區(qū)示例:")
for tz in ['UTC', 'Asia/Shanghai', 'Europe/London', 'America/New_York']:
    print(f"- {tz}")

# 創(chuàng)建原始時間
naive_dt = datetime(2023, 12, 15, 14, 30)

# 本地化（添加時區(qū)）
localized_sh = shanghai.localize(naive_dt)
print(f"上海時間: {localized_sh}")

# 轉(zhuǎn)換為其他時區(qū)
ny_time = localized_sh.astimezone(new_york)
print(f"紐約時間: {ny_time}")

# UTC轉(zhuǎn)換
utc_time = localized_sh.astimezone(utc)
print(f"UTC時間: {utc_time}")

def convert_time(source_time, source_tz, target_tz):
    """安全時區(qū)轉(zhuǎn)換"""
    # 確保時區(qū)感知
    if source_time.tzinfo is None:
        source_time = source_tz.localize(source_time)
    
    return source_time.astimezone(target_tz)

# 使用示例
source = datetime(2023, 12, 15, 14, 30)
target = convert_time(source, shanghai, new_york)
print(f"轉(zhuǎn)換結(jié)果: {source} [上海] -> {target} [紐約]")

# 創(chuàng)建跨越夏令時的日期
london = pytz.timezone('Europe/London')

# 夏令時開始前 (2023年3月25日)
pre_dst = datetime(2023, 3, 25, 12, 0)
pre_dst = london.localize(pre_dst)
print(f"夏令時前: {pre_dst} (UTC偏移: {pre_dst.utcoffset()})")

# 夏令時開始后 (2023年3月26日)
post_dst = datetime(2023, 3, 26, 12, 0)
post_dst = london.localize(post_dst)
print(f"夏令時后: {post_dst} (UTC偏移: {post_dst.utcoffset()})")

def handle_ambiguous_time(dt, tz):
    """處理模糊時間（夏令時結(jié)束）"""
    try:
        return tz.localize(dt, is_dst=None)  # 嚴格模式
    except pytz.AmbiguousTimeError:
        # 選擇較早時間（標準時間）
        return tz.localize(dt, is_dst=False)
    except pytz.NonExistentTimeError:
        # 處理不存在時間（夏令時開始）
        return tz.localize(dt + timedelta(hours=1), is_dst=True)

# 測試模糊時間 (倫敦夏令時結(jié)束)
ambiguous_dt = datetime(2023, 10, 29, 1, 30)
try:
    # 直接嘗試會報錯
    london.localize(ambiguous_dt, is_dst=None)
except pytz.AmbiguousTimeError:
    print("檢測到模糊時間")
    
# 安全處理
safe_dt = handle_ambiguous_time(ambiguous_dt, london)
print(f"處理結(jié)果: {safe_dt}")

# 方法1: 使用pytz
aware_dt = shanghai.localize(datetime(2023, 12, 15, 14, 30))

# 方法2: 使用datetime替換
aware_dt2 = datetime(2023, 12, 15, 14, 30, tzinfo=shanghai)

# 方法3: 使用ISO格式
aware_dt3 = datetime.fromisoformat("2023-12-15T14:30:00+08:00")

# 方法4: 使用dateutil
from dateutil import tz
aware_dt4 = datetime(2023, 12, 15, 14, 30, tzinfo=tz.gettz('Asia/Shanghai'))

# 時區(qū)感知比較
dt1 = shanghai.localize(datetime(2023, 12, 15, 14, 30))
dt2 = new_york.localize(datetime(2023, 12, 15, 1, 30))

print(f"時間相等: {dt1 == dt2}")  # False
print(f"時間順序: {dt1 > dt2}")   # True

# 時區(qū)感知運算
duration = timedelta(hours=8)
new_time = dt1 + duration
print(f"8小時后: {new_time}")

# 跨時區(qū)運算
new_time_ny = new_time.astimezone(new_york)
print(f"紐約時間: {new_time_ny}")

class GlobalScheduler:
    """全球會議調(diào)度系統(tǒng)"""
    def __init__(self):
        self.user_timezones = {}
    
    def add_user(self, user_id, timezone):
        """添加用戶時區(qū)"""
        self.user_timezones[user_id] = pytz.timezone(timezone)
    
    def find_meeting_time(self, users, duration_hours=1):
        """尋找共同可用時間"""
        # 獲取所有用戶時區(qū)
        timezones = [self.user_timezones[uid] for uid in users]
        
        # 找到重疊的工作時間 (示例算法)
        base_time = datetime.now(pytz.utc).replace(hour=0, minute=0, second=0)
        best_time = None
        max_overlap = 0
        
        # 檢查未來7天
        for day in range(7):
            candidate = base_time + timedelta(days=day)
            
            # 檢查每個小時段
            for hour in range(7, 19):  # 7AM-7PM
                start = candidate.replace(hour=hour)
                end = start + timedelta(hours=duration_hours)
                
                # 檢查是否在所有時區(qū)都是工作時間
                valid = True
                for tz in timezones:
                    local_start = start.astimezone(tz)
                    local_end = end.astimezone(tz)
                    
                    # 檢查是否在工作時間 (9AM-5PM)
                    if not (9 <= local_start.hour < 17 and 9 <= local_end.hour < 17):
                        valid = False
                        break
                
                if valid:
                    return start  # 找到第一個合適時間
        
        return None  # 未找到合適時間

# 使用示例
scheduler = GlobalScheduler()
scheduler.add_user('Alice', 'America/New_York')
scheduler.add_user('Bob', 'Europe/London')
scheduler.add_user('Charlie', 'Asia/Shanghai')

meeting_time = scheduler.find_meeting_time(['Alice', 'Bob', 'Charlie'])
print(f"會議時間 (UTC): {meeting_time}")

import schedule
import time

def timezone_aware_job():
    """時區(qū)感知任務"""
    now = datetime.now(pytz.utc)
    print(f"任務執(zhí)行時間 (UTC): {now}")

# 創(chuàng)建調(diào)度器
scheduler = schedule.Scheduler()

# 紐約時間每天9:00執(zhí)行
ny_tz = pytz.timezone('America/New_York')
ny_time = ny_tz.localize(datetime.now().replace(hour=9, minute=0, second=0))

# 轉(zhuǎn)換為UTC
utc_time = ny_time.astimezone(pytz.utc)

# 添加任務
scheduler.every().day.at(utc_time.strftime('%H:%M')).do(timezone_aware_job)

# 運行調(diào)度器
while True:
    scheduler.run_pending()
    time.sleep(60)

class TradingHours:
    """全球交易時間處理器"""
    MARKET_HOURS = {
        'NYSE': ('America/New_York', (9, 30), (16, 0)),  # 9:30 AM - 4:00 PM
        'LSE': ('Europe/London', (8, 0), (16, 30)),      # 8:00 AM - 4:30 PM
        'TSE': ('Asia/Tokyo', (9, 0), (15, 0)),         # 9:00 AM - 3:00 PM
        'SHSE': ('Asia/Shanghai', (9, 30), (15, 0))      # 9:30 AM - 3:00 PM
    }
    
    def is_market_open(self, exchange, dt=None):
        """檢查市場是否開放"""
        dt = dt or datetime.now(pytz.utc)
        tz_name, start_time, end_time = self.MARKET_HOURS[exchange]
        tz = pytz.timezone(tz_name)
        
        # 轉(zhuǎn)換為市場時區(qū)
        market_time = dt.astimezone(tz)
        
        # 檢查時間
        market_start = market_time.replace(hour=start_time[0], minute=start_time[1], second=0)
        market_end = market_time.replace(hour=end_time[0], minute=end_time[1], second=0)
        
        # 檢查是否為工作日
        if market_time.weekday() >= 5:  # 周六日
            return False
        
        return market_start <= market_time <= market_end

# 使用示例
trader = TradingHours()
ny_time = datetime(2023, 12, 15, 14, 30, tzinfo=pytz.utc)  # UTC時間
print(f"紐交所開放: {trader.is_market_open('NYSE', ny_time)}")
print(f"上交所開放: {trader.is_market_open('SHSE', ny_time)}")

def convert_trade_time(trade_time, source_exchange, target_exchange):
    """轉(zhuǎn)換交易時間到另一交易所時區(qū)"""
    trader = TradingHours()
    source_tz = pytz.timezone(trader.MARKET_HOURS[source_exchange][0])
    target_tz = pytz.timezone(trader.MARKET_HOURS[target_exchange][0])
    
    # 確保時區(qū)感知
    if trade_time.tzinfo is None:
        trade_time = source_tz.localize(trade_time)
    
    return trade_time.astimezone(target_tz)

# 使用示例
ny_trade = datetime(2023, 12, 15, 10, 30)  # 紐約時間10:30 AM
ny_trade = pytz.timezone('America/New_York').localize(ny_trade)

sh_trade = convert_trade_time(ny_trade, 'NYSE', 'SHSE')
print(f"紐約交易時間: {ny_trade}")
print(f"上海對應時間: {sh_trade}")

def normalize_timezone(df, time_col, target_tz='UTC'):
    """標準化DataFrame時區(qū)"""
    # 轉(zhuǎn)換為時區(qū)感知
    if df[time_col].dt.tz is None:
        # 假設為UTC（實際應用中需根據(jù)數(shù)據(jù)源確定）
        df[time_col] = df[time_col].dt.tz_localize('UTC')
    
    # 轉(zhuǎn)換為目標時區(qū)
    df[time_col] = df[time_col].dt.tz_convert(target_tz)
    return df

# 使用示例
import pandas as pd

# 創(chuàng)建多時區(qū)數(shù)據(jù)
data = {
    'timestamp': [
        datetime(2023, 12, 15, 9, 30, tzinfo=pytz.timezone('America/New_York')),
        datetime(2023, 12, 15, 14, 30, tzinfo=pytz.timezone('Europe/London')),
        datetime(2023, 12, 15, 22, 30, tzinfo=pytz.timezone('Asia/Shanghai'))
    ],
    'value': [100, 200, 300]
}
df = pd.DataFrame(data)

# 標準化為UTC
df_normalized = normalize_timezone(df, 'timestamp', 'UTC')
print("標準化后數(shù)據(jù):")
print(df_normalized)

def analyze_by_timezone(df, time_col, value_col):
    """按原始時區(qū)分組分析"""
    # 提取原始時區(qū)
    df['original_tz'] = df[time_col].apply(lambda x: x.tzinfo.zone)
    
    # 轉(zhuǎn)換為本地時間
    df['local_time'] = df[time_col].apply(lambda x: x.tz_convert(x.tzinfo).time())
    
    # 按時區(qū)和小時分組
    result = df.groupby(['original_tz', df['local_time'].apply(lambda x: x.hour)])[value_col].mean()
    return result

# 使用示例
result = analyze_by_timezone(df, 'timestamp', 'value')
print("按時區(qū)分組分析:")
print(result)

import psycopg2
from psycopg2 import sql

def setup_database_timezone():
    """配置數(shù)據(jù)庫時區(qū)"""
    conn = psycopg2.connect(dbname='test', user='postgres', password='password')
    cur = conn.cursor()
    
    # 設置數(shù)據(jù)庫時區(qū)為UTC
    cur.execute("SET TIME ZONE 'UTC';")
    
    # 創(chuàng)建帶時區(qū)的時間戳字段
    cur.execute("""
        CREATE TABLE events (
            id SERIAL PRIMARY KEY,
            name VARCHAR(100),
            event_time TIMESTAMPTZ NOT NULL
        )
    """)
    
    # 插入時區(qū)感知時間
    event_time = datetime.now(pytz.utc)
    cur.execute(
        sql.SQL("INSERT INTO events (name, event_time) VALUES (%s, %s)"),
        ('Meeting', event_time)
    )
    
    conn.commit()
    cur.close()
    conn.close()

# 從數(shù)據(jù)庫讀取
def read_events_in_timezone(target_tz):
    """在特定時區(qū)讀取事件"""
    conn = psycopg2.connect(dbname='test', user='postgres', password='password')
    cur = conn.cursor()
    
    # 轉(zhuǎn)換時區(qū)
    cur.execute("""
        SELECT name, event_time AT TIME ZONE %s AS local_time
        FROM events
    """, (target_tz,))
    
    results = cur.fetchall()
    cur.close()
    conn.close()
    return results

# 使用示例
setup_database_timezone()
events = read_events_in_timezone('Asia/Shanghai')
print("上海時間事件:")
for name, time in events:
    print(f"{name}: {time}")

from pymongo import MongoClient
import pytz

def store_datetime_with_timezone():
    """存儲帶時區(qū)的時間"""
    client = MongoClient('localhost', 27017)
    db = client['test_db']
    collection = db['events']
    
    # 創(chuàng)建時區(qū)感知時間
    event_time = datetime.now(pytz.utc)
    
    # 插入文檔
    collection.insert_one({
        'name': 'Product Launch',
        'time': event_time
    })
    
    # 查詢并轉(zhuǎn)換時區(qū)
    shanghai_tz = pytz.timezone('Asia/Shanghai')
    for doc in collection.find():
        # 轉(zhuǎn)換時區(qū)
        utc_time = doc['time']
        sh_time = utc_time.astimezone(shanghai_tz)
        print(f"事件時間 (上海): {sh_time}")

# 使用示例
store_datetime_with_timezone()

# 始終以UTC存儲時間
def save_event(event_time):
    if event_time.tzinfo is None:
        event_time = pytz.utc.localize(event_time)
    else:
        event_time = event_time.astimezone(pytz.utc)
    db.save(event_time)

def display_time(event_time, user_tz):
    """根據(jù)用戶時區(qū)顯示時間"""
    return event_time.astimezone(user_tz).strftime('%Y-%m-%d %H:%M %Z')

# 錯誤做法
dt = datetime(2023, 12, 15, tzinfo=pytz.timezone('Asia/Shanghai'))

# 正確做法
dt = pytz.timezone('Asia/Shanghai').localize(datetime(2023, 12, 15))

def handle_dst_transition(dt, tz):
    try:
        return tz.localize(dt, is_dst=None)
    except (pytz.AmbiguousTimeError, pytz.NonExistentTimeError):
        # 使用業(yè)務邏輯處理
        return tz.localize(dt, is_dst=False)

def safe_time_compare(dt1, dt2):
    """安全比較時間"""
    # 確保時區(qū)感知
    if dt1.tzinfo is None:
        dt1 = pytz.utc.localize(dt1)
    if dt2.tzinfo is None:
        dt2 = pytz.utc.localize(dt2)

    # 轉(zhuǎn)換為UTC比較
    return dt1.astimezone(pytz.utc) < dt2.astimezone(pytz.utc)

class GlobalEventSystem:
    """全球事件排序系統(tǒng)"""
    def __init__(self):
        self.events = []
    
    def add_event(self, event, location):
        """添加事件（帶位置）"""
        tz = pytz.timezone(self._location_to_tz(location))
        if not event['time'].tzinfo:
            event['time'] = tz.localize(event['time'])
        self.events.append(event)
    
    def get_ordered_events(self):
        """獲取全局排序事件"""
        # 轉(zhuǎn)換為UTC排序
        utc_events = [{
            'event': e,
            'utc_time': e['time'].astimezone(pytz.utc)
        } for e in self.events]
        
        # 排序
        sorted_events = sorted(utc_events, key=lambda x: x['utc_time'])
        return [e['event'] for e in sorted_events]
    
    def _location_to_tz(self, location):
        """位置轉(zhuǎn)時區(qū)（簡化版）"""
        mapping = {
            'New York': 'America/New_York',
            'London': 'Europe/London',
            'Shanghai': 'Asia/Shanghai',
            'Tokyo': 'Asia/Tokyo'
        }
        return mapping.get(location, 'UTC')

# 使用示例
system = GlobalEventSystem()

# 添加全球事件
system.add_event({'name': '會議', 'time': datetime(2023, 12, 15, 9, 30)}, 'New York')
system.add_event({'name': '發(fā)布', 'time': datetime(2023, 12, 15, 14, 30)}, 'London')
system.add_event({'name': '上線', 'time': datetime(2023, 12, 15, 22, 30)}, 'Shanghai')

# 獲取全局排序
ordered = system.get_ordered_events()
print("全局事件順序:")
for event in ordered:
    print(f"{event['name']}: {event['time']}")

class TimezoneAwareLogger:
    """時區(qū)感知日志系統(tǒng)"""
    def __init__(self, default_tz='UTC'):
        self.default_tz = pytz.timezone(default_tz)
        self.logs = []
    
    def log(self, message, timestamp=None, timezone=None):
        """記錄日志"""
        if timestamp is None:
            timestamp = datetime.now(pytz.utc)
        elif timestamp.tzinfo is None:
            tz = pytz.timezone(timezone) if timezone else self.default_tz
            timestamp = tz.localize(timestamp)
        
        self.logs.append({
            'message': message,
            'timestamp': timestamp,
            'timezone': timestamp.tzinfo.zone
        })
    
    def display_logs(self, target_tz='UTC'):
        """在特定時區(qū)顯示日志"""
        target_tz = pytz.timezone(target_tz)
        for log in self.logs:
            local_time = log['timestamp'].astimezone(target_tz)
            print(f"[{local_time}] {log['message']}")

# 使用示例
logger = TimezoneAwareLogger()

# 記錄日志（不同時區(qū)）
logger.log("系統(tǒng)啟動", timezone='Asia/Shanghai')
logger.log("用戶登錄", datetime(2023, 12, 15, 9, 30), 'America/New_York')
logger.log("錯誤發(fā)生", timezone='Europe/London')

# 在UTC查看
print("UTC日志:")
logger.display_logs('UTC')

# 在紐約查看
print("\n紐約日志:")
logger.display_logs('America/New_York')

def process_event_time(event_time, event_tz):
    """
    處理事件時間

    參數(shù):
        event_time: 事件時間 (datetime對象)
        event_tz: 事件時區(qū) (字符串或tzinfo)

    返回:
        標準化UTC時間

    注意:
        如果event_time未指定時區(qū)，使用event_tz本地化
    """
    # 實現(xiàn)代碼