def basic_separators():
    """基礎(chǔ)分隔符使用示例"""
    # 默認(rèn)分隔符（空格）
    print("默認(rèn)分隔符:", "Python", "Java", "C++")  # Python Java C++
    
    # 自定義分隔符
    print("逗號(hào)分隔:", "Python", "Java", "C++", sep=", ")  # Python, Java, C++
    print("豎線分隔:", "Python", "Java", "C++", sep=" | ")  # Python | Java | C++
    print("無分隔符:", "Python", "Java", "C++", sep="")     # PythonJavaC++
    
    # 特殊分隔符
    print("制表符分隔:", "Name", "Age", "City", sep="\t")   # Name    Age     City
    print("換行符分隔:", "Python", "Java", "C++", sep="\n")  # 每個(gè)詞一行

# 執(zhí)行示例
basic_separators()

def line_endings():
    """行結(jié)尾符控制示例"""
    # 默認(rèn)行結(jié)尾符（\n）
    print("第一行")
    print("第二行")
    
    # 無行結(jié)尾符
    print("沒有換行", end="")
    print("繼續(xù)同一行")  # 沒有換行繼續(xù)同一行
    
    # 自定義行結(jié)尾符
    print("以分號(hào)結(jié)束", end="; ")
    print("繼續(xù)分號(hào)分隔")  # 以分號(hào)結(jié)束; 繼續(xù)分號(hào)分隔
    
    # 特殊行結(jié)尾符
    print("Windows行結(jié)尾", end="\r\n")  # CRLF
    print("Unix行結(jié)尾", end="\n")       # LF
    print("Mac經(jīng)典行結(jié)尾", end="\r")    # CR
    
    # 多行輸出控制
    print("進(jìn)度: ", end="")
    for i in range(5):
        print(f"{i+1} ", end="", flush=True)  # 實(shí)時(shí)輸出
        import time
        time.sleep(0.5)
    print()  # 最終換行

line_endings()

def dynamic_separators():
    """動(dòng)態(tài)分隔符生成"""
    data = ["Python", "Java", "C++", "JavaScript", "Go"]
    
    # 根據(jù)數(shù)據(jù)長度動(dòng)態(tài)選擇分隔符
    def smart_separator(items):
        if len(items) <= 3:
            return ", "
        else:
            return " | "
    
    separator = smart_separator(data)
    print("智能分隔:", *data, sep=separator)
    
    # 條件分隔符
    def conditional_separator(index, total):
        if index == total - 1:
            return " 和 "
        elif index == total - 2:
            return ", "
        else:
            return ", "
    
    # 手動(dòng)構(gòu)建輸出
    output_parts = []
    for i, item in enumerate(data):
        if i > 0:
            output_parts.append(conditional_separator(i, len(data)))
        output_parts.append(item)
    
    print("條件分隔:", "".join(output_parts))
    
    # 分隔符映射
    separator_map = {
        0: " → ",
        1: " ? ",
        2: " ? ",
        "default": " | "
    }
    
    for i, item in enumerate(data):
        sep = separator_map.get(i, separator_map["default"])
        print(sep, item, sep="", end="")
    print()

dynamic_separators()

def hierarchical_separators():
    """多級(jí)分隔符系統(tǒng)"""
    # 嵌套數(shù)據(jù)結(jié)構(gòu)
    nested_data = [
        ["Python", "3.9", "Guido van Rossum"],
        ["Java", "17", "James Gosling"],
        ["JavaScript", "ES2022", "Brendan Eich"]
    ]
    
    # 一級(jí)分隔符（行間）
    primary_sep = "\n" + "="*40 + "\n"
    
    # 二級(jí)分隔符（行內(nèi)字段）
    secondary_sep = " | "
    
    # 三級(jí)分隔符（字段內(nèi)）
    tertiary_sep = ": "
    
    # 構(gòu)建輸出
    output_lines = []
    for row in nested_data:
        formatted_fields = []
        for field in row:
            if isinstance(field, str) and " " in field:
                # 包含空格的字段加引號(hào)
                formatted_fields.append(f'"{field}"')
            else:
                formatted_fields.append(str(field))
        
        # 組合字段
        line = secondary_sep.join(
            f"字段{i+1}{tertiary_sep}{value}" 
            for i, value in enumerate(formatted_fields)
        )
        output_lines.append(line)
    
    # 最終輸出
    print(primary_sep.join(output_lines))

hierarchical_separators()

def csv_format_output():
    """CSV格式輸出控制"""
    import csv
    from io import StringIO
    
    data = [
        ["姓名", "年齡", "城市", "職業(yè)"],
        ["張三", "25", "北京", "工程師"],
        ["李四", "30", "上海", "設(shè)計(jì)師"],
        ["王五", "28", "廣州", "產(chǎn)品經(jīng)理"]
    ]
    
    # 自定義CSV格式
    def custom_csv_writer(data, delimiter=',', line_terminator='\n'):
        """自定義CSV寫入器"""
        output = StringIO()
        for row in data:
            # 引用處理
            quoted_row = []
            for field in row:
                if any(c in field for c in [delimiter, '"', '\n', '\r']):
                    quoted_field = '"' + field.replace('"', '""') + '"'
                    quoted_row.append(quoted_field)
                else:
                    quoted_row.append(field)
            
            line = delimiter.join(quoted_row) + line_terminator
            output.write(line)
        
        return output.getvalue()
    
    # 生成不同格式的CSV
    formats = [
        (',', '\n', "標(biāo)準(zhǔn)CSV"),
        (';', '\n', "歐洲CSV"),
        ('\t', '\n', "TSV"),
        ('|', '\r\n', "管道分隔")
    ]
    
    for delimiter, terminator, description in formats:
        csv_content = custom_csv_writer(data, delimiter, terminator)
        print(f"\n{description}:")
        print(repr(csv_content[:100]))  # 顯示前100字符
    
    # 使用csv模塊
    print("\n使用csv模塊:")
    output = StringIO()
    writer = csv.writer(output, delimiter='|', lineterminator='@@')
    writer.writerows(data)
    print("自定義格式:", repr(output.getvalue()))

csv_format_output()

def fixed_width_format():
    """固定寬度格式輸出"""
    data = [
        {"name": "Python", "version": "3.9.0", "creator": "Guido van Rossum"},
        {"name": "Java", "version": "17.0.1", "creator": "James Gosling"},
        {"name": "JavaScript", "version": "ES2022", "creator": "Brendan Eich"}
    ]
    
    # 計(jì)算列寬
    col_widths = {
        "name": max(len(item["name"]) for item in data),
        "version": max(len(item["version"]) for item in data),
        "creator": max(len(item["creator"]) for item in data)
    }
    
    # 表頭
    headers = {"name": "語言", "version": "版本", "creator": "創(chuàng)建者"}
    col_widths = {k: max(col_widths[k], len(headers[k])) for k in col_widths}
    
    # 構(gòu)建分隔線
    separator = "+" + "+".join("-" * (width + 2) for width in col_widths.values()) + "+"
    
    # 輸出表格
    print(separator)
    
    # 表頭行
    header_line = "|"
    for key, width in col_widths.items():
        header_line += f" {headers[key]:^{width}} |"
    print(header_line)
    
    print(separator)
    
    # 數(shù)據(jù)行
    for item in data:
        row_line = "|"
        for key, width in col_widths.items():
            row_line += f" {item[key]:^{width}} |"
        print(row_line)
    
    print(separator)
    
    # 緊湊版本
    print("\n緊湊格式:")
    for item in data:
        print(f"{item['name']:<12} {item['version']:<8} {item['creator']:<20}")

fixed_width_format()

def line_ending_normalization():
    """行結(jié)尾符標(biāo)準(zhǔn)化處理"""
    import os
    import re
    
    # 不同系統(tǒng)的行結(jié)尾符
    line_endings = {
        'unix': '\n',      # LF
        'windows': '\r\n',  # CRLF
        'mac_old': '\r',    # CR (經(jīng)典Mac)
        'default': os.linesep  # 系統(tǒng)默認(rèn)
    }
    
    # 示例文本（混合行結(jié)尾）
    mixed_text = "第一行\(zhòng)n第二行\(zhòng)r\n第三行\(zhòng)r第四行\(zhòng)n"
    print("原始文本（混合行結(jié)尾）:")
    print(repr(mixed_text))
    
    # 標(biāo)準(zhǔn)化到特定格式
    def normalize_line_endings(text, target='unix'):
        """標(biāo)準(zhǔn)化行結(jié)尾符"""
        # 先統(tǒng)一替換為LF
        normalized = re.sub(r'\r\n|\r', '\n', text)
        
        # 轉(zhuǎn)換為目標(biāo)格式
        if target == 'windows':
            normalized = normalized.replace('\n', '\r\n')
        elif target == 'mac_old':
            normalized = normalized.replace('\n', '\r')
        
        return normalized
    
    # 測(cè)試不同目標(biāo)格式
    targets = ['unix', 'windows', 'mac_old']
    for target in targets:
        normalized = normalize_line_endings(mixed_text, target)
        print(f"\n標(biāo)準(zhǔn)化到 {target}:")
        print(repr(normalized))
    
    # 自動(dòng)檢測(cè)和轉(zhuǎn)換
    def auto_detect_convert(text, target='unix'):
        """自動(dòng)檢測(cè)并轉(zhuǎn)換行結(jié)尾"""
        # 檢測(cè)主要行結(jié)尾類型
        lf_count = text.count('\n') - text.count('\r\n')
        crlf_count = text.count('\r\n')
        cr_count = text.count('\r') - text.count('\r\n')
        
        counts = {'LF': lf_count, 'CRLF': crlf_count, 'CR': cr_count}
        dominant = max(counts.items(), key=lambda x: x[1])[0]
        
        print(f"檢測(cè)到主要行結(jié)尾: {dominant} ({counts[dominant]} 處)")
        
        # 轉(zhuǎn)換為目標(biāo)格式
        return normalize_line_endings(text, target)
    
    # 測(cè)試自動(dòng)檢測(cè)
    converted = auto_detect_convert(mixed_text, 'windows')
    print(f"\n轉(zhuǎn)換后文本: {repr(converted)}")

line_ending_normalization()

def file_line_ending_handling():
    """文件行結(jié)尾符處理"""
    import os
    
    # 創(chuàng)建測(cè)試文件（不同行結(jié)尾）
    test_contents = {
        'unix.txt': "LF行1\nLF行2\nLF行3\n",
        'windows.txt': "CRLF行1\r\nCRLF行2\r\nCRLF行3\r\n",
        'mixed.txt': "混合行1\n混合行2\r\n混合行3\r"
    }
    
    for filename, content in test_contents.items():
        with open(filename, 'w', encoding='utf-8', newline='') as f:
            f.write(content)
        print(f"創(chuàng)建文件: {filename}")
    
    # 讀取并檢測(cè)行結(jié)尾
    def detect_file_line_endings(filename):
        """檢測(cè)文件行結(jié)尾類型"""
        with open(filename, 'rb') as f:
            content = f.read()
        
        lf_count = content.count(b'\n') - content.count(b'\r\n')
        crlf_count = content.count(b'\r\n')
        cr_count = content.count(b'\r') - content.count(b'\r\n')
        
        counts = {'LF': lf_count, 'CRLF': crlf_count, 'CR': cr_count}
        return counts
    
    print("\n文件行結(jié)尾檢測(cè):")
    for filename in test_contents.keys():
        counts = detect_file_line_endings(filename)
        print(f"{filename}: {counts}")
    
    # 轉(zhuǎn)換文件行結(jié)尾
    def convert_file_line_endings(filename, target='unix'):
        """轉(zhuǎn)換文件行結(jié)尾"""
        # 讀取原始內(nèi)容
        with open(filename, 'r', encoding='utf-8', newline='') as f:
            content = f.read()
        
        # 標(biāo)準(zhǔn)化行結(jié)尾
        normalized = content.replace('\r\n', '\n').replace('\r', '\n')
        
        if target == 'windows':
            normalized = normalized.replace('\n', '\r\n')
        elif target == 'mac_old':
            normalized = normalized.replace('\n', '\r')
        
        # 寫回文件
        with open(f"converted_{filename}", 'w', encoding='utf-8', newline='') as f:
            f.write(normalized)
        
        return f"converted_{filename}"
    
    # 轉(zhuǎn)換示例
    converted_file = convert_file_line_endings('mixed.txt', 'windows')
    print(f"\n轉(zhuǎn)換后文件: {converted_file}")
    counts = detect_file_line_endings(converted_file)
    print(f"轉(zhuǎn)換后行結(jié)尾: {counts}")

file_line_ending_handling()

def templated_output_system():
    """模板化輸出系統(tǒng)"""
    from string import Template
    import datetime
    
    # 基礎(chǔ)模板
    simple_template = Template("$name 的年齡是 $age 歲，住在 $city")
    
    data = [
        {"name": "張三", "age": 25, "city": "北京"},
        {"name": "李四", "age": 30, "city": "上海"},
        {"name": "王五", "age": 28, "city": "廣州"}
    ]
    
    print("簡(jiǎn)單模板輸出:")
    for person in data:
        print(simple_template.substitute(person))
    
    # 高級(jí)模板 with 條件邏輯
    class SmartTemplate(Template):
        """智能模板支持條件邏輯"""
        def substitute(self, mapping, **kwargs):
            content = super().substitute(mapping, **kwargs)
            # 處理?xiàng)l件邏輯
            content = content.replace('{{if}}', '').replace('{{endif}}', '')
            return content
    
    advanced_template = SmartTemplate("""
$name 的信息:
{{if}}年齡: $age{{endif}}
{{if}}城市: $city{{endif}}
{{if}}職業(yè): $occupation{{endif}}
注冊(cè)時(shí)間: $timestamp
    """)
    
    # 添加時(shí)間戳
    for person in data:
        person['timestamp'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        person['occupation'] = '工程師'  # 統(tǒng)一添加職業(yè)
    
    print("\n高級(jí)模板輸出:")
    for person in data:
        print(advanced_template.substitute(person))
    
    # 文件模板系統(tǒng)
    def load_template(template_file):
        """從文件加載模板"""
        with open(template_file, 'r', encoding='utf-8') as f:
            return Template(f.read())
    
    # 創(chuàng)建模板文件
    with open('person_template.txt', 'w', encoding='utf-8') as f:
        f.write("""
人員信息:
姓名:   $name
年齡:   $age
城市:   $city
職業(yè):   $occupation
時(shí)間:   $timestamp
====================
        """)
    
    # 使用文件模板
    template = load_template('person_template.txt')
    print("\n文件模板輸出:")
    for person in data:
        print(template.substitute(person))

templated_output_system()

def dynamic_format_generator():
    """動(dòng)態(tài)格式生成器"""
    # 根據(jù)數(shù)據(jù)類型自動(dòng)選擇格式
    def auto_format(value):
        """根據(jù)數(shù)據(jù)類型自動(dòng)格式化"""
        if isinstance(value, (int, float)):
            return f"{value:,}"  # 數(shù)字加千位分隔符
        elif isinstance(value, str):
            if len(value) > 20:
                return f"{value[:17]}..."  # 長字符串截?cái)?
            return value
        elif isinstance(value, datetime.datetime):
            return value.strftime('%Y-%m-%d %H:%M:%S')
        elif value is None:
            return "N/A"
        else:
            return str(value)
    
    # 測(cè)試自動(dòng)格式化
    test_data = [
        1234567,
        3.1415926535,
        "這是一個(gè)很長的字符串需要被截?cái)嗵幚?,
        datetime.datetime.now(),
        None,
        ["列表", "數(shù)據(jù)"]
    ]
    
    print("自動(dòng)格式化示例:")
    for item in test_data:
        formatted = auto_format(item)
        print(f"{type(item).__name__:>15}: {formatted}")
    
    # 動(dòng)態(tài)列對(duì)齊
    def smart_alignment(data, headers=None):
        """智能列對(duì)齊"""
        if headers is None:
            headers = [f"列{i+1}" for i in range(len(data[0]))]
        
        # 計(jì)算每列最大寬度
        col_widths = []
        for i in range(len(headers)):
            max_width = len(headers[i])
            for row in data:
                cell_str = auto_format(row[i]) if i < len(row) else ""
                max_width = max(max_width, len(cell_str))
            col_widths.append(max_width + 2)  # 加一些填充
        
        # 輸出表頭
        header_line = ""
        for i, header in enumerate(headers):
            header_line += f"{header:^{col_widths[i]}}"
        print(header_line)
        print("-" * len(header_line))
        
        # 輸出數(shù)據(jù)
        for row in data:
            row_line = ""
            for i, cell in enumerate(row):
                cell_str = auto_format(cell)
                # 數(shù)字右對(duì)齊，文本左對(duì)齊
                if isinstance(cell, (int, float)):
                    row_line += f"{cell_str:>{col_widths[i]}}"
                else:
                    row_line += f"{cell_str:<{col_widths[i]}}"
            print(row_line)
    
    # 測(cè)試智能對(duì)齊
    sample_data = [
        ["Python", 3.9, 1991],
        ["Java", 17, 1995],
        ["JavaScript", 1.8, 1995],
        ["C++", 20, 1985]
    ]
    
    print("\n智能列對(duì)齊:")
    smart_alignment(sample_data, ["語言", "版本", "誕生年份"])

dynamic_format_generator()

def logging_system_formatting():
    """日志系統(tǒng)格式化"""
    import logging
    from logging.handlers import RotatingFileHandler
    
    # 自定義日志格式
    class CustomFormatter(logging.Formatter):
        """自定義日志格式器"""
        def __init__(self, fmt=None, datefmt=None, style='%'):
            super().__init__(fmt, datefmt, style)
            self.separator = " | "
        
        def format(self, record):
            # 原始格式
            original = super().format(record)
            
            # 添加自定義分隔符
            if hasattr(record, 'custom_fields'):
                custom_parts = [f"{k}={v}" for k, v in record.custom_fields.items()]
                custom_str = self.separator.join(custom_parts)
                return f"{original}{self.separator}{custom_str}"
            return original
    
    # 配置日志系統(tǒng)
    logger = logging.getLogger('AppLogger')
    logger.setLevel(logging.DEBUG)
    
    # 文件處理器 with 自定義格式
    file_handler = RotatingFileHandler(
        'app.log',
        maxBytes=1024 * 1024,
        backupCount=5,
        encoding='utf-8'
    )
    
    custom_format = CustomFormatter(
        fmt='%(asctime)s %(levelname)s %(name)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )
    file_handler.setFormatter(custom_format)
    
    logger.addHandler(file_handler)
    
    # 記錄帶自定義字段的日志
    def log_with_fields(level, msg, **fields):
        """記錄帶自定義字段的日志"""
        extra = {'custom_fields': fields}
        if level == 'debug':
            logger.debug(msg, extra=extra)
        elif level == 'info':
            logger.info(msg, extra=extra)
        elif level == 'warning':
            logger.warning(msg, extra=extra)
        elif level == 'error':
            logger.error(msg, extra=extra)
    
    # 測(cè)試日志
    log_with_fields('info', '用戶登錄', user_id=123, ip='192.168.1.1', status='success')
    log_with_fields('error', '數(shù)據(jù)庫連接失敗', db_name='main', attempt=3, timeout=30)
    
    print("日志記錄完成，查看 app.log 文件")
    
    # 顯示日志內(nèi)容
    with open('app.log', 'r', encoding='utf-8') as f:
        print("\n日志文件內(nèi)容:")
        for line in f:
            print(line.strip())

logging_system_formatting()

def data_report_generation():
    """數(shù)據(jù)報(bào)告生成系統(tǒng)"""
    import json
    from datetime import datetime, timedelta
    
    # 模擬數(shù)據(jù)
    sales_data = [
        {"date": "2024-01-01", "product": "A", "quantity": 100, "revenue": 5000},
        {"date": "2024-01-01", "product": "B", "quantity": 75, "revenue": 3750},
        {"date": "2024-01-02", "product": "A", "quantity": 120, "revenue": 6000},
        {"date": "2024-01-02", "product": "B", "quantity": 90, "revenue": 4500},
        {"date": "2024-01-03", "product": "A", "quantity": 80, "revenue": 4000},
        {"date": "2024-01-03", "product": "B", "quantity": 110, "revenue": 5500},
    ]
    
    # 多種格式報(bào)告生成
    def generate_report(data, format_type='text'):
        """生成多種格式報(bào)告"""
        if format_type == 'text':
            return generate_text_report(data)
        elif format_type == 'csv':
            return generate_csv_report(data)
        elif format_type == 'json':
            return generate_json_report(data)
        else:
            raise ValueError(f"不支持的格式: {format_type}")
    
    def generate_text_report(data):
        """生成文本格式報(bào)告"""
        report_lines = []
        report_lines.append("銷售數(shù)據(jù)報(bào)告")
        report_lines.append("=" * 50)
        report_lines.append(f"生成時(shí)間: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        report_lines.append("")
        
        # 匯總信息
        total_quantity = sum(item['quantity'] for item in data)
        total_revenue = sum(item['revenue'] for item in data)
        report_lines.append(f"總銷量: {total_quantity}")
        report_lines.append(f"總收入: ￥{total_revenue:,}")
        report_lines.append("")
        
        # 詳細(xì)數(shù)據(jù)
        report_lines.append("每日銷售詳情:")
        report_lines.append("-" * 40)
        
        current_date = None
        for item in sorted(data, key=lambda x: x['date']):
            if item['date'] != current_date:
                if current_date is not None:
                    report_lines.append("")
                current_date = item['date']
                report_lines.append(f"日期: {current_date}")
                report_lines.append("-" * 20)
            
            line = f"  產(chǎn)品 {item['product']}: 銷量 {item['quantity']:>3}, 收入 ￥{item['revenue']:>6,}"
            report_lines.append(line)
        
        return "\n".join(report_lines)
    
    def generate_csv_report(data):
        """生成CSV格式報(bào)告"""
        import csv
        from io import StringIO
        
        output = StringIO()
        writer = csv.writer(output)
        
        # 表頭
        writer.writerow(['日期', '產(chǎn)品', '銷量', '收入'])
        
        # 數(shù)據(jù)行
        for item in sorted(data, key=lambda x: (x['date'], x['product'])):
            writer.writerow([item['date'], item['product'], item['quantity'], item['revenue']])
        
        # 匯總行
        writer.writerow([])
        total_quantity = sum(item['quantity'] for item in data)
        total_revenue = sum(item['revenue'] for item in data)
        writer.writerow(['總計(jì)', '', total_quantity, total_revenue])
        
        return output.getvalue()
    
    def generate_json_report(data):
        """生成JSON格式報(bào)告"""
        report = {
            "metadata": {
                "generated_at": datetime.now().isoformat(),
                "data_source": "sales_system",
                "record_count": len(data)
            },
            "summary": {
                "total_quantity": sum(item['quantity'] for item in data),
                "total_revenue": sum(item['revenue'] for item in data)
            },
            "details": data
        }
        return json.dumps(report, indent=2, ensure_ascii=False)
    
    # 生成不同格式報(bào)告
    formats = ['text', 'csv', 'json']
    for fmt in formats:
        report = generate_report(sales_data, fmt)
        filename = f'sales_report.{fmt}'
        
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(report)
        
        print(f"生成 {fmt} 格式報(bào)告: {filename}")
        if fmt == 'text':
            print("\n文本報(bào)告預(yù)覽:")
            print(report[:200] + "..." if len(report) > 200 else report)

data_report_generation()

def print_performance_optimization():
    """打印性能優(yōu)化"""
    import time
    import io
    
    # 測(cè)試數(shù)據(jù)
    test_data = [f"行 {i}: 這是一條測(cè)試數(shù)據(jù)" for i in range(10000)]
    
    # 方法1: 直接打印
    start_time = time.time()
    for line in test_data[:1000]:  # 只測(cè)試1000行
        print(line)
    direct_time = time.time() - start_time
    
    # 方法2: 批量構(gòu)建后打印
    start_time = time.time()
    buffer = io.StringIO()
    for line in test_data[:1000]:
        buffer.write(line + '\n')
    print(buffer.getvalue(), end='')
    buffered_time = time.time() - start_time
    
    # 方法3: 使用join
    start_time = time.time()
    print('\n'.join(test_data[:1000]))
    join_time = time.time() - start_time
    
    print(f"\n性能測(cè)試結(jié)果:")
    print(f"直接打印: {direct_time:.4f}秒")
    print(f"緩沖打印: {buffered_time:.4f}秒")
    print(f"join打印: {join_time:.4f}秒")
    print(f"join比直接快: {(direct_time/join_time):.2f}倍")
    
    # 文件寫入性能比較
    start_time = time.time()
    with open('direct.txt', 'w', encoding='utf-8') as f:
        for line in test_data:
            f.write(line + '\n')
    file_direct_time = time.time() - start_time
    
    start_time = time.time()
    with open('buffered.txt', 'w', encoding='utf-8') as f:
        content = '\n'.join(test_data)
        f.write(content)
    file_buffered_time = time.time() - start_time
    
    print(f"\n文件寫入性能:")
    print(f"直接寫入: {file_direct_time:.4f}秒")
    print(f"緩沖寫入: {file_buffered_time:.4f}秒")
    print(f"緩沖比直接快: {(file_direct_time/file_buffered_time):.2f}倍")

print_performance_optimization()

def memory_usage_optimization():
    """內(nèi)存使用優(yōu)化"""
    import sys
    import tracemalloc
    
    # 大型數(shù)據(jù)生成
    large_data = [f"數(shù)據(jù)行 {i} " * 10 for i in range(100000)]
    
    # 方法1: 直接處理（高內(nèi)存）
    tracemalloc.start()
    direct_output = '\n'.join(large_data)
    current, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    print(f"直接join - 當(dāng)前內(nèi)存: {current/1024/1024:.2f}MB, 峰值內(nèi)存: {peak/1024/1024:.2f}MB")
    
    # 方法2: 生成器處理（低內(nèi)存）
    tracemalloc.start()
    def generate_lines():
        for line in large_data:
            yield line + '\n'
    
    # 模擬寫入文件
    with open('generator_output.txt', 'w', encoding='utf-8') as f:
        for line in generate_lines():
            f.write(line)
    
    current, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    print(f"生成器處理 - 當(dāng)前內(nèi)存: {current/1024/1024:.2f}MB, 峰值內(nèi)存: {peak/1024/1024:.2f}MB")
    
    # 方法3: 分批處理
    tracemalloc.start()
    batch_size = 1000
    with open('batched_output.txt', 'w', encoding='utf-8') as f:
        for i in range(0, len(large_data), batch_size):
            batch = large_data[i:i+batch_size]
            content = '\n'.join(batch) + '\n'
            f.write(content)
    
    current, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    print(f"分批處理 - 當(dāng)前內(nèi)存: {current/1024/1024:.2f}MB, 峰值內(nèi)存: {peak/1024/1024:.2f}MB")

memory_usage_optimization()

def professional_output_formatter(data, format_config):
    """
    專業(yè)輸出格式化器
    
    參數(shù):
        data: 要格式化的數(shù)據(jù)
        format_config: 格式配置字典
    """
    default_config = {
        'separator': ', ',
        'line_ending': '\n',
        'encoding': 'utf-8',
        'quote_strings': True,
        'number_format': '{:,}',
        'date_format': '%Y-%m-%d %H:%M:%S'
    }
    
    # 合并配置
    config = {**default_config, **format_config}
    
    def format_value(value):
        """根據(jù)類型格式化值"""
        if isinstance(value, (int, float)):
            return config['number_format'].format(value)
        elif isinstance(value, str):
            if config['quote_strings'] and any(c in value for c in [config['separator'], '"', '\n']):
                return f'"{value.replace(\'"\', \'""\')}"'
            return value
        elif isinstance(value, datetime.datetime):
            return value.strftime(config['date_format'])
        elif value is None:
            return 'NULL'
        else:
            return str(value)
    
    # 構(gòu)建輸出
    if isinstance(data, (list, tuple)):
        formatted_items = []
        for item in data:
            if isinstance(item, (list, tuple)):
                # 處理行數(shù)據(jù)
                formatted_line = config['separator'].join(format_value(x) for x in item)
                formatted_items.append(formatted_line)
            else:
                # 處理單個(gè)值
                formatted_items.append(format_value(item))
        
        return config['line_ending'].join(formatted_items)
    
    else:
        # 處理單個(gè)值
        return format_value(data)

# 使用示例
sample_data = [
    ["Python", 3.9, datetime.datetime.now()],
    ["Java", 17, None],
    ["C++", 20, "包含,逗號(hào)的字符串"]
]

config = {
    'separator': '|',
    'line_ending': '\r\n',
    'quote_strings': True
}

formatted_output = professional_output_formatter(sample_data, config)
print("格式化輸出:")
print(formatted_output)