def fix_chinese_garbled(garbled_str):
    """
    修復(fù)中文亂碼 - 最常見情況
    """
    # 方法1: 重新編碼為latin-1，再用UTF-8解碼
    try:
        fixed = garbled_str.encode('latin-1').decode('utf-8')
        return fixed
    except:
        pass
    
    # 方法2: 嘗試cp1252編碼（Windows常用）
    try:
        fixed = garbled_str.encode('cp1252').decode('utf-8')
        return fixed
    except:
        pass
    
    # 方法3: 嘗試gbk編碼
    try:
        fixed = garbled_str.encode('gbk').decode('utf-8')
        return fixed
    except:
        pass
    
    return garbled_str  # 無(wú)法修復(fù)返回原字符串

# 測(cè)試
garbled = 'é???μ??·'
fixed = fix_chinese_garbled(garbled)
print(f"亂碼: {garbled}")
print(f"修復(fù): {fixed}")

import chardet

def auto_fix_garbled(garbled_str):
    """
    使用chardet自動(dòng)檢測(cè)并修復(fù)亂碼
    """
    # 檢測(cè)當(dāng)前編碼
    detected = chardet.detect(garbled_str.encode('latin-1'))
    print(f"檢測(cè)到的編碼: {detected}")
    
    # 嘗試用檢測(cè)到的編碼重新解碼
    if detected['encoding']:
        try:
            # 先編碼為檢測(cè)到的編碼，再用UTF-8解碼
            fixed = garbled_str.encode('latin-1').decode(detected['encoding'])
            return fixed
        except:
            pass
    
    # 嘗試常見編碼
    for encoding in ['utf-8', 'gbk', 'gb2312', 'big5', 'cp936', 'cp1252']:
        try:
            fixed = garbled_str.encode('latin-1').decode(encoding)
            # 驗(yàn)證是否包含中文字符
            if any('\u4e00' <= char <= '\u9fff' for char in fixed):
                return fixed
        except:
            continue
    
    return garbled_str

# 安裝chardet: pip install chardet
garbled = 'é???μ??·'
fixed = auto_fix_garbled(garbled)
print(f"修復(fù)結(jié)果: {fixed}")

def fix_utf8_mojibake(text):
    """
    專門修復(fù)UTF-8 mojibake（UTF-8被錯(cuò)誤解碼為單字節(jié)編碼）
    """
    # 常見模式：UTF-8 -> latin-1/cp1252 -> UTF-8
    # 需要反向操作
    
    # 嘗試1: encode('latin-1').decode('utf-8')
    try:
        return text.encode('latin-1').decode('utf-8')
    except:
        pass
    
    # 嘗試2: encode('cp1252').decode('utf-8')
    try:
        return text.encode('cp1252').decode('utf-8')
    except:
        pass
    
    # 嘗試3: encode('iso-8859-1').decode('utf-8')
    try:
        return text.encode('iso-8859-1').decode('utf-8')
    except:
        pass
    
    return text

# 測(cè)試
test_cases = [
    'é???μ??·',  # 深南電路
    '??3?',       # 名稱
    '1é?±',       # 股票
]

for garbled in test_cases:
    fixed = fix_utf8_mojibake(garbled)
    print(f"{garbled:20} -> {fixed}")

def smart_fix_chinese(text):
    """
    智能修復(fù)中文亂碼
    """
    if not text or not isinstance(text, str):
        return text
    
    # 如果已經(jīng)是中文，直接返回
    if any('\u4e00' <= char <= '\u9fff' for char in text):
        return text
    
    # 嘗試多種編碼組合
    encodings_to_try = [
        ('latin-1', 'utf-8'),
        ('cp1252', 'utf-8'),
        ('iso-8859-1', 'utf-8'),
        ('gbk', 'utf-8'),
        ('gb2312', 'utf-8'),
    ]
    
    for src_enc, dst_enc in encodings_to_try:
        try:
            fixed = text.encode(src_enc).decode(dst_enc)
            # 驗(yàn)證是否包含中文字符
            chinese_count = sum(1 for char in fixed if '\u4e00' <= char <= '\u9fff')
            if chinese_count > 0:
                return fixed
        except (UnicodeEncodeError, UnicodeDecodeError):
            continue
    
    # 如果都失敗，返回原字符串
    return text

# 測(cè)試
garbled = 'é???μ??·'
fixed = smart_fix_chinese(garbled)
print(f"原始: {garbled}")
print(f"修復(fù): {fixed}")

def fix_file_encoding(input_file, output_file, src_encoding='latin-1', dst_encoding='utf-8'):
    """
    修復(fù)文件編碼問題
    """
    try:
        # 讀取文件（用錯(cuò)誤的編碼）
        with open(input_file, 'r', encoding=src_encoding, errors='replace') as f:
            content = f.read()
        
        # 寫入文件（用正確的編碼）
        with open(output_file, 'w', encoding=dst_encoding) as f:
            f.write(content)
        
        print(f"? 文件編碼已修復(fù): {input_file} -> {output_file}")
        return True
    except Exception as e:
        print(f"? 修復(fù)失敗: {e}")
        return False

# 使用示例
# fix_file_encoding('garbled.txt', 'fixed.txt')

import json
import redis

class ChineseRedisClient:
    """支持中文亂碼自動(dòng)修復(fù)的Redis客戶端"""
    
    def __init__(self, host='localhost', port=6379, db=0):
        self.client = redis.Redis(host=host, port=port, db=db)
    
    def get_fixed(self, key):
        """
        獲取并自動(dòng)修復(fù)中文亂碼
        """
        value = self.client.get(key)
        if value is None:
            return None
        
        # 如果是bytes，先解碼
        if isinstance(value, bytes):
            value = value.decode('utf-8', errors='replace')
        
        # 修復(fù)亂碼
        fixed_value = smart_fix_chinese(value)
        
        return fixed_value
    
    def set_fixed(self, key, value):
        """
        設(shè)置值，確保正確編碼
        """
        if isinstance(value, str):
            # 確保是UTF-8編碼
            value = value.encode('utf-8')
        self.client.set(key, value)

# 使用示例
if __name__ == "__main__":
    # 模擬從Redis讀取亂碼數(shù)據(jù)
    garbled_data = 'é???μ??·'
    print(f"亂碼數(shù)據(jù): {garbled_data}")
    
    fixed_data = smart_fix_chinese(garbled_data)
    print(f"修復(fù)后: {fixed_data}")
    
    # 驗(yàn)證
    if fixed_data == '深南電路':
        print("? 修復(fù)成功!")
    else:
        print(f"? 修復(fù)可能不完全: {fixed_data}")

import json
import chardet

class ChineseGarbledFixer:
    """中文亂碼修復(fù)工具類"""
    
    @staticmethod
    def diagnose(text):
        """
        診斷亂碼問題
        """
        print("=" * 60)
        print("中文亂碼診斷")
        print("=" * 60)
        print(f"輸入: {repr(text)}")
        print(f"長(zhǎng)度: {len(text)} 字符")
        
        # 檢測(cè)編碼
        detected = chardet.detect(text.encode('latin-1'))
        print(f"\n檢測(cè)結(jié)果:")
        print(f"  編碼: {detected['encoding']}")
        print(f"  置信度: {detected['confidence']:.2%}")
        
        # 檢查是否包含中文字符
        has_chinese = any('\u4e00' <= char <= '\u9fff' for char in text)
        print(f"  包含中文: {has_chinese}")
        
        if not has_chinese:
            print(f"\n  ? 當(dāng)前字符串不包含中文字符，可能是亂碼")
        
        # 嘗試修復(fù)
        print(f"\n嘗試修復(fù):")
        fixed = ChineseGarbledFixer.fix(text)
        print(f"  修復(fù)結(jié)果: {repr(fixed)}")
        
        has_chinese_fixed = any('\u4e00' <= char <= '\u9fff' for char in fixed)
        print(f"  修復(fù)后包含中文: {has_chinese_fixed}")
        
        print("=" * 60)
        return fixed
    
    @staticmethod
    def fix(text):
        """
        修復(fù)亂碼
        """
        if not text or not isinstance(text, str):
            return text
        
        # 如果已經(jīng)有中文，直接返回
        if any('\u4e00' <= char <= '\u9fff' for char in text):
            return text
        
        # 嘗試多種編碼組合
        encodings = [
            ('latin-1', 'utf-8'),
            ('cp1252', 'utf-8'),
            ('iso-8859-1', 'utf-8'),
            ('gbk', 'utf-8'),
            ('gb2312', 'utf-8'),
            ('big5', 'utf-8'),
        ]
        
        for src_enc, dst_enc in encodings:
            try:
                fixed = text.encode(src_enc).decode(dst_enc)
                # 驗(yàn)證是否包含足夠的中文字符
                chinese_count = sum(1 for char in fixed if '\u4e00' <= char <= '\u9fff')
                if chinese_count > 0:
                    print(f"    ? {src_enc} -> {dst_enc}: {repr(fixed[:30])}")
                    return fixed
            except (UnicodeEncodeError, UnicodeDecodeError) as e:
                print(f"    ? {src_enc} -> {dst_enc}: {e}")
                continue
        
        print(f"    ? 所有嘗試都失敗，返回原字符串")
        return text
    
    @staticmethod
    def fix_json(json_str):
        """
        修復(fù)JSON中的中文亂碼
        """
        try:
            # 先嘗試標(biāo)準(zhǔn)解析
            return json.loads(json_str)
        except json.JSONDecodeError:
            # 修復(fù)亂碼后再解析
            fixed_str = ChineseGarbledFixer.fix(json_str)
            try:
                return json.loads(fixed_str)
            except json.JSONDecodeError as e:
                print(f"JSON解析失敗: {e}")
                raise

# 使用示例
if __name__ == "__main__":
    # 測(cè)試數(shù)據(jù)
    test_data = [
        'é???μ??·',  # 深南電路
        '{"name": "é???μ??·", "code": "002916"}',
        '??3?',       # 名稱
        '1é?±',       # 股票
    ]
    
    fixer = ChineseGarbledFixer()
    
    for data in test_data:
        print(f"\n原始數(shù)據(jù): {repr(data)}")
        fixed = fixer.fix(data)
        print(f"修復(fù)后: {repr(fixed)}")
        
        # 如果是JSON，嘗試解析
        if data.startswith('{'):
            try:
                json_data = fixer.fix_json(data)
                print(f"JSON解析: {json_data}")
            except Exception as e:
                print(f"JSON解析失敗: {e}")

garbled = 'é???μ??·'
fixed = garbled.encode('latin-1').decode('utf-8')
print(fixed)  # 輸出: 深南電路

# 1. 存儲(chǔ)時(shí)確保UTF-8編碼
import json

def save_to_redis_properly(key, data):
    """正確保存數(shù)據(jù)到Redis"""
    # 序列化為JSON（UTF-8）
    json_str = json.dumps(data, ensure_ascii=False)
    # 編碼為UTF-8 bytes
    redis_client.set(key, json_str.encode('utf-8'))

def read_from_redis_properly(key):
    """正確從Redis讀取數(shù)據(jù)"""
    # 讀取bytes
    value_bytes = redis_client.get(key)
    if value_bytes:
        # 解碼為UTF-8字符串
        json_str = value_bytes.decode('utf-8')
        # 解析JSON
        return json.loads(json_str)
    return None

# 2. 讀取時(shí)自動(dòng)修復(fù)
def safe_read_from_redis(key):
    """安全讀取，自動(dòng)修復(fù)亂碼"""
    value_bytes = redis_client.get(key)
    if not value_bytes:
        return None
    
    # 嘗試UTF-8解碼
    try:
        json_str = value_bytes.decode('utf-8')
        return json.loads(json_str)
    except (UnicodeDecodeError, json.JSONDecodeError):
        # 如果失敗，嘗試修復(fù)亂碼
        try:
            # 先用latin-1解碼，再用UTF-8編碼
            garbled = value_bytes.decode('latin-1')
            fixed = garbled.encode('latin-1').decode('utf-8')
            return json.loads(fixed)
        except Exception as e:
            print(f"修復(fù)失敗: {e}")
            raise