import pytz
from datetime import datetime

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

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

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

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

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

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

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

def convert_time(source_time, source_tz, target_tz):
    """安全時(shí)區(qū)轉(zhuǎn)換"""
    # 確保時(shí)區(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)建跨越夏令時(shí)的日期
london = pytz.timezone('Europe/London')

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

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

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

# 測(cè)試模糊時(shí)間 (倫敦夏令時(shí)結(jié)束)
ambiguous_dt = datetime(2023, 10, 29, 1, 30)
try:
    # 直接嘗試會(huì)報(bào)錯(cuò)
    london.localize(ambiguous_dt, is_dst=None)
except pytz.AmbiguousTimeError:
    print("檢測(cè)到模糊時(shí)間")
    
# 安全處理
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'))

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

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

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

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

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

# 使用示例
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"會(huì)議時(shí)間 (UTC): {meeting_time}")

import schedule
import time

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

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

# 紐約時(shí)間每天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)

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

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

class TradingHours:
    """全球交易時(shí)間處理器"""
    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):
        """檢查市場(chǎng)是否開(kāi)放"""
        dt = dt or datetime.now(pytz.utc)
        tz_name, start_time, end_time = self.MARKET_HOURS[exchange]
        tz = pytz.timezone(tz_name)
        
        # 轉(zhuǎn)換為市場(chǎng)時(shí)區(qū)
        market_time = dt.astimezone(tz)
        
        # 檢查時(shí)間
        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時(shí)間
print(f"紐交所開(kāi)放: {trader.is_market_open('NYSE', ny_time)}")
print(f"上交所開(kāi)放: {trader.is_market_open('SHSE', ny_time)}")

def convert_trade_time(trade_time, source_exchange, target_exchange):
    """轉(zhuǎn)換交易時(shí)間到另一交易所時(shí)區(qū)"""
    trader = TradingHours()
    source_tz = pytz.timezone(trader.MARKET_HOURS[source_exchange][0])
    target_tz = pytz.timezone(trader.MARKET_HOURS[target_exchange][0])
    
    # 確保時(shí)區(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)  # 紐約時(shí)間10:30 AM
ny_trade = pytz.timezone('America/New_York').localize(ny_trade)

sh_trade = convert_trade_time(ny_trade, 'NYSE', 'SHSE')
print(f"紐約交易時(shí)間: {ny_trade}")
print(f"上海對(duì)應(yīng)時(shí)間: {sh_trade}")

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

# 使用示例
import pandas as pd

# 創(chuàng)建多時(shí)區(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)

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

def analyze_by_timezone(df, time_col, value_col):
    """按原始時(shí)區(qū)分組分析"""
    # 提取原始時(shí)區(qū)
    df['original_tz'] = df[time_col].apply(lambda x: x.tzinfo.zone)
    
    # 轉(zhuǎn)換為本地時(shí)間
    df['local_time'] = df[time_col].apply(lambda x: x.tz_convert(x.tzinfo).time())
    
    # 按時(shí)區(qū)和小時(shí)分組
    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("按時(shí)區(qū)分組分析:")
print(result)

import psycopg2
from psycopg2 import sql

def setup_database_timezone():
    """配置數(shù)據(jù)庫(kù)時(shí)區(qū)"""
    conn = psycopg2.connect(dbname='test', user='postgres', password='password')
    cur = conn.cursor()
    
    # 設(shè)置數(shù)據(jù)庫(kù)時(shí)區(qū)為UTC
    cur.execute("SET TIME ZONE 'UTC';")
    
    # 創(chuàng)建帶時(shí)區(qū)的時(shí)間戳字段
    cur.execute("""
        CREATE TABLE events (
            id SERIAL PRIMARY KEY,
            name VARCHAR(100),
            event_time TIMESTAMPTZ NOT NULL
        )
    """)
    
    # 插入時(shí)區(qū)感知時(shí)間
    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ù)庫(kù)讀取
def read_events_in_timezone(target_tz):
    """在特定時(shí)區(qū)讀取事件"""
    conn = psycopg2.connect(dbname='test', user='postgres', password='password')
    cur = conn.cursor()
    
    # 轉(zhuǎn)換時(shí)區(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("上海時(shí)間事件:")
for name, time in events:
    print(f"{name}: {time}")

from pymongo import MongoClient
import pytz

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

# 使用示例
store_datetime_with_timezone()

# 始終以UTC存儲(chǔ)時(shí)間
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ù)用戶時(shí)區(qū)顯示時(shí)間"""
    return event_time.astimezone(user_tz).strftime('%Y-%m-%d %H:%M %Z')

# 錯(cuò)誤做法
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è)務(wù)邏輯處理
        return tz.localize(dt, is_dst=False)

def safe_time_compare(dt1, dt2):
    """安全比較時(shí)間"""
    # 確保時(shí)區(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)時(shí)區(qū)（簡(jiǎn)化版）"""
        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': '會(huì)議', '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:
    """時(shí)區(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'):
        """在特定時(shí)區(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()

# 記錄日志（不同時(shí)區(qū)）
logger.log("系統(tǒng)啟動(dòng)", timezone='Asia/Shanghai')
logger.log("用戶登錄", datetime(2023, 12, 15, 9, 30), 'America/New_York')
logger.log("錯(cuò)誤發(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í)間

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

    返回:
        標(biāo)準(zhǔn)化UTC時(shí)間

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