Python实现打印输出格式化方法的完全指南

def basic_separators():
    """基础分隔符使用示例"""
    # 默认分隔符（空格）
    print("默认分隔符:", "Python", "Java", "C++")  # Python Java C++
    
    # 自定义分隔符
    print("逗号分隔:", "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")  # 每个词一行

# 执行示例
basic_separators()

def line_endings():
    """行结尾符控制示例"""
    # 默认行结尾符（\n）
    print("第一行")
    print("第二行")
    
    # 无行结尾符
    print("没有换行", end="")
    print("继续同一行")  # 没有换行继续同一行
    
    # 自定义行结尾符
    print("以分号结束", end="; ")
    print("继续分号分隔")  # 以分号结束; 继续分号分隔
    
    # 特殊行结尾符
    print("Windows行结尾", end="\r\n")  # CRLF
    print("Unix行结尾", end="\n")       # LF
    print("Mac经典行结尾", end="\r")    # CR
    
    # 多行输出控制
    print("进度: ", end="")
    for i in range(5):
        print(f"{i+1} ", end="", flush=True)  # 实时输出
        import time
        time.sleep(0.5)
    print()  # 最终换行

line_endings()

def dynamic_separators():
    """动态分隔符生成"""
    data = ["Python", "Java", "C++", "JavaScript", "Go"]
    
    # 根据数据长度动态选择分隔符
    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 ", "
    
    # 手动构建输出
    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():
    """多级分隔符系统"""
    # 嵌套数据结构
    nested_data = [
        ["Python", "3.9", "Guido van Rossum"],
        ["Java", "17", "James Gosling"],
        ["JavaScript", "ES2022", "Brendan Eich"]
    ]
    
    # 一级分隔符（行间）
    primary_sep = "\n" + "="*40 + "\n"
    
    # 二级分隔符（行内字段）
    secondary_sep = " | "
    
    # 三级分隔符（字段内）
    tertiary_sep = ": "
    
    # 构建输出
    output_lines = []
    for row in nested_data:
        formatted_fields = []
        for field in row:
            if isinstance(field, str) and " " in field:
                # 包含空格的字段加引号
                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 = [
        ["姓名", "年龄", "城市", "职业"],
        ["张三", "25", "北京", "工程师"],
        ["李四", "30", "上海", "设计师"],
        ["王五", "28", "广州", "产品经理"]
    ]
    
    # 自定义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', "标准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"}
    ]
    
    # 计算列宽
    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": "创建者"}
    col_widths = {k: max(col_widths[k], len(headers[k])) for k in col_widths}
    
    # 构建分隔线
    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)
    
    # 数据行
    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():
    """行结尾符标准化处理"""
    import os
    import re
    
    # 不同系统的行结尾符
    line_endings = {
        'unix': '\n',      # LF
        'windows': '\r\n',  # CRLF
        'mac_old': '\r',    # CR (经典Mac)
        'default': os.linesep  # 系统默认
    }
    
    # 示例文本（混合行结尾）
    mixed_text = "第一行\n第二行\r\n第三行\r第四行\n"
    print("原始文本（混合行结尾）:")
    print(repr(mixed_text))
    
    # 标准化到特定格式
    def normalize_line_endings(text, target='unix'):
        """标准化行结尾符"""
        # 先统一替换为LF
        normalized = re.sub(r'\r\n|\r', '\n', text)
        
        # 转换为目标格式
        if target == 'windows':
            normalized = normalized.replace('\n', '\r\n')
        elif target == 'mac_old':
            normalized = normalized.replace('\n', '\r')
        
        return normalized
    
    # 测试不同目标格式
    targets = ['unix', 'windows', 'mac_old']
    for target in targets:
        normalized = normalize_line_endings(mixed_text, target)
        print(f"\n标准化到 {target}:")
        print(repr(normalized))
    
    # 自动检测和转换
    def auto_detect_convert(text, target='unix'):
        """自动检测并转换行结尾"""
        # 检测主要行结尾类型
        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"检测到主要行结尾: {dominant} ({counts[dominant]} 处)")
        
        # 转换为目标格式
        return normalize_line_endings(text, target)
    
    # 测试自动检测
    converted = auto_detect_convert(mixed_text, 'windows')
    print(f"\n转换后文本: {repr(converted)}")

line_ending_normalization()

def file_line_ending_handling():
    """文件行结尾符处理"""
    import os
    
    # 创建测试文件（不同行结尾）
    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"创建文件: {filename}")
    
    # 读取并检测行结尾
    def detect_file_line_endings(filename):
        """检测文件行结尾类型"""
        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文件行结尾检测:")
    for filename in test_contents.keys():
        counts = detect_file_line_endings(filename)
        print(f"{filename}: {counts}")
    
    # 转换文件行结尾
    def convert_file_line_endings(filename, target='unix'):
        """转换文件行结尾"""
        # 读取原始内容
        with open(filename, 'r', encoding='utf-8', newline='') as f:
            content = f.read()
        
        # 标准化行结尾
        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}"
    
    # 转换示例
    converted_file = convert_file_line_endings('mixed.txt', 'windows')
    print(f"\n转换后文件: {converted_file}")
    counts = detect_file_line_endings(converted_file)
    print(f"转换后行结尾: {counts}")

file_line_ending_handling()

def templated_output_system():
    """模板化输出系统"""
    from string import Template
    import datetime
    
    # 基础模板
    simple_template = Template("$name 的年龄是 $age 岁，住在 $city")
    
    data = [
        {"name": "张三", "age": 25, "city": "北京"},
        {"name": "李四", "age": 30, "city": "上海"},
        {"name": "王五", "age": 28, "city": "广州"}
    ]
    
    print("简单模板输出:")
    for person in data:
        print(simple_template.substitute(person))
    
    # 高级模板 with 条件逻辑
    class SmartTemplate(Template):
        """智能模板支持条件逻辑"""
        def substitute(self, mapping, **kwargs):
            content = super().substitute(mapping, **kwargs)
            # 处理条件逻辑
            content = content.replace('{{if}}', '').replace('{{endif}}', '')
            return content
    
    advanced_template = SmartTemplate("""
$name 的信息:
{{if}}年龄: $age{{endif}}
{{if}}城市: $city{{endif}}
{{if}}职业: $occupation{{endif}}
注册时间: $timestamp
    """)
    
    # 添加时间戳
    for person in data:
        person['timestamp'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        person['occupation'] = '工程师'  # 统一添加职业
    
    print("\n高级模板输出:")
    for person in data:
        print(advanced_template.substitute(person))
    
    # 文件模板系统
    def load_template(template_file):
        """从文件加载模板"""
        with open(template_file, 'r', encoding='utf-8') as f:
            return Template(f.read())
    
    # 创建模板文件
    with open('person_template.txt', 'w', encoding='utf-8') as f:
        f.write("""
人员信息:
姓名:   $name
年龄:   $age
城市:   $city
职业:   $occupation
时间:   $timestamp
====================
        """)
    
    # 使用文件模板
    template = load_template('person_template.txt')
    print("\n文件模板输出:")
    for person in data:
        print(template.substitute(person))

templated_output_system()

def dynamic_format_generator():
    """动态格式生成器"""
    # 根据数据类型自动选择格式
    def auto_format(value):
        """根据数据类型自动格式化"""
        if isinstance(value, (int, float)):
            return f"{value:,}"  # 数字加千位分隔符
        elif isinstance(value, str):
            if len(value) > 20:
                return f"{value[:17]}..."  # 长字符串截断
            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)
    
    # 测试自动格式化
    test_data = [
        1234567,
        3.1415926535,
        "这是一个很长的字符串需要被截断处理",
        datetime.datetime.now(),
        None,
        ["列表", "数据"]
    ]
    
    print("自动格式化示例:")
    for item in test_data:
        formatted = auto_format(item)
        print(f"{type(item).__name__:>15}: {formatted}")
    
    # 动态列对齐
    def smart_alignment(data, headers=None):
        """智能列对齐"""
        if headers is None:
            headers = [f"列{i+1}" for i in range(len(data[0]))]
        
        # 计算每列最大宽度
        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))
        
        # 输出数据
        for row in data:
            row_line = ""
            for i, cell in enumerate(row):
                cell_str = auto_format(cell)
                # 数字右对齐，文本左对齐
                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)
    
    # 测试智能对齐
    sample_data = [
        ["Python", 3.9, 1991],
        ["Java", 17, 1995],
        ["JavaScript", 1.8, 1995],
        ["C++", 20, 1985]
    ]
    
    print("\n智能列对齐:")
    smart_alignment(sample_data, ["语言", "版本", "诞生年份"])

dynamic_format_generator()

def logging_system_formatting():
    """日志系统格式化"""
    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
    
    # 配置日志系统
    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)
    
    # 测试日志
    log_with_fields('info', '用户登录', user_id=123, ip='192.168.1.1', status='success')
    log_with_fields('error', '数据库连接失败', db_name='main', attempt=3, timeout=30)
    
    print("日志记录完成，查看 app.log 文件")
    
    # 显示日志内容
    with open('app.log', 'r', encoding='utf-8') as f:
        print("\n日志文件内容:")
        for line in f:
            print(line.strip())

logging_system_formatting()

def data_report_generation():
    """数据报告生成系统"""
    import json
    from datetime import datetime, timedelta
    
    # 模拟数据
    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},
    ]
    
    # 多种格式报告生成
    def generate_report(data, format_type='text'):
        """生成多种格式报告"""
        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):
        """生成文本格式报告"""
        report_lines = []
        report_lines.append("销售数据报告")
        report_lines.append("=" * 50)
        report_lines.append(f"生成时间: {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("")
        
        # 详细数据
        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"  产品 {item['product']}: 销量 {item['quantity']:>3}, 收入 ¥{item['revenue']:>6,}"
            report_lines.append(line)
        
        return "\n".join(report_lines)
    
    def generate_csv_report(data):
        """生成CSV格式报告"""
        import csv
        from io import StringIO
        
        output = StringIO()
        writer = csv.writer(output)
        
        # 表头
        writer.writerow(['日期', '产品', '销量', '收入'])
        
        # 数据行
        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(['总计', '', total_quantity, total_revenue])
        
        return output.getvalue()
    
    def generate_json_report(data):
        """生成JSON格式报告"""
        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)
    
    # 生成不同格式报告
    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} 格式报告: {filename}")
        if fmt == 'text':
            print("\n文本报告预览:")
            print(report[:200] + "..." if len(report) > 200 else report)

data_report_generation()

def print_performance_optimization():
    """打印性能优化"""
    import time
    import io
    
    # 测试数据
    test_data = [f"行 {i}: 这是一条测试数据" for i in range(10000)]
    
    # 方法1: 直接打印
    start_time = time.time()
    for line in test_data[:1000]:  # 只测试1000行
        print(line)
    direct_time = time.time() - start_time
    
    # 方法2: 批量构建后打印
    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性能测试结果:")
    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():
    """内存使用优化"""
    import sys
    import tracemalloc
    
    # 大型数据生成
    large_data = [f"数据行 {i} " * 10 for i in range(100000)]
    
    # 方法1: 直接处理（高内存）
    tracemalloc.start()
    direct_output = '\n'.join(large_data)
    current, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    print(f"直接join - 当前内存: {current/1024/1024:.2f}MB, 峰值内存: {peak/1024/1024:.2f}MB")
    
    # 方法2: 生成器处理（低内存）
    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"生成器处理 - 当前内存: {current/1024/1024:.2f}MB, 峰值内存: {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"分批处理 - 当前内存: {current/1024/1024:.2f}MB, 峰值内存: {peak/1024/1024:.2f}MB")

memory_usage_optimization()

def professional_output_formatter(data, format_config):
    """
    专业输出格式化器
    
    参数:
        data: 要格式化的数据
        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):
        """根据类型格式化值"""
        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)
    
    # 构建输出
    if isinstance(data, (list, tuple)):
        formatted_items = []
        for item in data:
            if isinstance(item, (list, tuple)):
                # 处理行数据
                formatted_line = config['separator'].join(format_value(x) for x in item)
                formatted_items.append(formatted_line)
            else:
                # 处理单个值
                formatted_items.append(format_value(item))
        
        return config['line_ending'].join(formatted_items)
    
    else:
        # 处理单个值
        return format_value(data)

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

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

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