Python处理文件写入时文件不存在的完整解决方案

def basic_write_operations():
    """基础文件写入操作示例"""
    # 模式 'w' - 如果文件不存在则创建，存在则覆盖
    with open('new_file.txt', 'w', encoding='utf-8') as f:
        f.write("这是新文件的内容\n")
        f.write("第二行内容\n")
    
    print("'w' 模式写入完成")
    
    # 模式 'a' - 如果文件不存在则创建，存在则追加
    with open('append_file.txt', 'a', encoding='utf-8') as f:
        f.write("追加的内容\n")
        f.write("更多追加内容\n")
    
    print("'a' 模式写入完成")
    
    # 模式 'x' - 独占创建，文件存在则失败
    try:
        with open('exclusive_file.txt', 'x', encoding='utf-8') as f:
            f.write("独占创建的内容\n")
        print("'x' 模式写入成功")
    except FileExistsError:
        print("'x' 模式失败：文件已存在")

# 执行示例
basic_write_operations()

def safe_write_with_try_except():
    """使用try-except安全处理文件写入"""
    filename = 'data.txt'
    
    try:
        # 尝试读取文件检查是否存在
        with open(filename, 'r', encoding='utf-8') as f:
            content = f.read()
            print("文件已存在，内容:")
            print(content)
            
    except FileNotFoundError:
        print("文件不存在，创建新文件")
        
        # 安全写入新文件
        try:
            with open(filename, 'w', encoding='utf-8') as f:
                f.write("新文件的内容\n")
                f.write("创建时间: 2024-01-15\n")
            print("新文件创建成功")
            
        except PermissionError:
            print("错误: 没有写入权限")
        except Exception as e:
            print(f"写入文件时发生错误: {e}")
            
    except PermissionError:
        print("错误: 没有读取权限")
    except Exception as e:
        print(f"检查文件时发生错误: {e}")

# 执行示例
safe_write_with_try_except()

from pathlib import Path

def pathlib_file_operations():
    """使用pathlib进行现代文件操作"""
    file_path = Path('data.txt')
    
    # 检查文件是否存在
    if file_path.exists():
        print("文件已存在")
        print(f"文件大小: {file_path.stat().st_size} 字节")
        print(f"修改时间: {file_path.stat().st_mtime}")
        
        # 读取内容
        content = file_path.read_text(encoding='utf-8')
        print("文件内容:")
        print(content)
    else:
        print("文件不存在，创建新文件")
        
        # 确保目录存在
        file_path.parent.mkdir(parents=True, exist_ok=True)
        
        # 写入新文件
        file_path.write_text("使用pathlib创建的内容\n第二行\n", encoding='utf-8')
        print("文件创建成功")
    
    # 更复杂的写入操作
    if not file_path.exists():
        with file_path.open('w', encoding='utf-8') as f:
            f.write("第一行内容\n")
            f.write("第二行内容\n")
            f.write(f"创建时间: {datetime.now().isoformat()}\n")
        
        print("使用open方法创建文件")

# 执行示例
pathlib_file_operations()

def atomic_write_operations():
    """原子文件写入操作"""
    import tempfile
    import os
    
    def atomic_write(filename, content, encoding='utf-8'):
        """
        原子写入文件
        先写入临时文件，然后重命名，避免写入过程中断导致文件损坏
        """
        # 创建临时文件
        temp_file = None
        try:
            # 在相同目录创建临时文件
            temp_file = tempfile.NamedTemporaryFile(
                mode='w', 
                encoding=encoding,
                dir=os.path.dirname(filename),
                delete=False
            )
            
            # 写入内容
            temp_file.write(content)
            temp_file.close()
            
            # 原子替换原文件
            os.replace(temp_file.name, filename)
            print(f"原子写入完成: {filename}")
            
        except Exception as e:
            # 清理临时文件
            if temp_file and os.path.exists(temp_file.name):
                os.unlink(temp_file.name)
            raise e
    
    # 使用原子写入
    try:
        content = "原子写入的内容\n第二行\n第三行"
        atomic_write('atomic_data.txt', content)
        
    except Exception as e:
        print(f"原子写入失败: {e}")
    
    # 带备份的原子写入
    def atomic_write_with_backup(filename, content, encoding='utf-8'):
        """带备份的原子写入"""
        backup_file = filename + '.bak'
        
        # 如果原文件存在，创建备份
        if os.path.exists(filename):
            os.replace(filename, backup_file)
        
        try:
            atomic_write(filename, content, encoding)
            # 成功后删除备份
            if os.path.exists(backup_file):
                os.unlink(backup_file)
                
        except Exception as e:
            # 失败时恢复备份
            if os.path.exists(backup_file):
                os.replace(backup_file, filename)
            raise e
    
    # 测试带备份的写入
    try:
        content = "带备份的原子写入内容"
        atomic_write_with_backup('backup_data.txt', content)
        print("带备份的原子写入完成")
        
    except Exception as e:
        print(f"带备份的原子写入失败: {e}")

# 执行示例
atomic_write_operations()

def file_locking_mechanism():
    """文件锁机制实现"""
    import fcntl  # Unix系统文件锁
    import time
    
    def write_with_lock(filename, content, timeout=10):
        """使用文件锁进行安全写入"""
        start_time = time.time()
        
        while time.time() - start_time < timeout:
            try:
                with open(filename, 'a+', encoding='utf-8') as f:  # 使用a+模式创建文件
                    # 获取独占锁
                    fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
                    
                    # 检查文件内容（如果需要）
                    f.seek(0)
                    existing_content = f.read()
                    
                    # 写入新内容
                    f.seek(0)
                    f.truncate()  # 清空文件
                    f.write(content)
                    
                    # 释放锁会在文件关闭时自动进行
                    print(f"写入完成: {filename}")
                    return True
                    
            except BlockingIOError:
                # 文件被锁定，等待重试
                print("文件被锁定，等待...")
                time.sleep(0.1)
            except FileNotFoundError:
                # 文件不存在，尝试创建
                try:
                    with open(filename, 'x', encoding='utf-8') as f:
                        f.write(content)
                    print(f"创建并写入: {filename}")
                    return True
                except FileExistsError:
                    # 在创建过程中文件被其他进程创建
                    continue
            except Exception as e:
                print(f"写入错误: {e}")
                return False
        
        print("获取文件锁超时")
        return False
    
    # 测试文件锁
    success = write_with_lock('locked_file.txt', "使用文件锁写入的内容\n")
    print(f"写入结果: {'成功' if success else '失败'}")
    
    # Windows平台替代方案
    def windows_file_lock(filename, content):
        """Windows平台文件锁模拟"""
        try:
            # 使用独占模式打开文件
            with open(filename, 'w', encoding='utf-8') as f:
                # 在Windows上，简单的打开操作就提供了基本的独占性
                f.write(content)
                print("Windows文件写入完成")
                return True
                
        except PermissionError:
            print("文件被其他进程锁定")
            return False
        except Exception as e:
            print(f"写入错误: {e}")
            return False
    
    # 根据平台选择方法
    if os.name == 'posix':  # Unix/Linux/Mac
        write_with_lock('unix_file.txt', "Unix系统内容\n")
    elif os.name == 'nt':   # Windows
        windows_file_lock('windows_file.txt', "Windows系统内容\n")

# 执行示例
file_locking_mechanism()

def multiprocess_file_safety():
    """多进程环境下的文件安全写入"""
    import multiprocessing
    import time
    
    def worker_process(process_id, lock, output_file):
        """工作进程函数"""
        for i in range(5):
            # 模拟一些处理
            time.sleep(0.1)
            
            # 获取锁保护文件写入
            with lock:
                try:
                    with open(output_file, 'a', encoding='utf-8') as f:
                        timestamp = time.time()
                        message = f"进程 {process_id} - 迭代 {i} - 时间 {timestamp:.6f}\n"
                        f.write(message)
                        print(f"进程 {process_id} 写入完成")
                        
                except Exception as e:
                    print(f"进程 {process_id} 写入错误: {e}")
    
    # 创建进程锁
    manager = multiprocessing.Manager()
    lock = manager.Lock()
    
    output_file = 'multiprocess_output.txt'
    
    # 清理旧文件（如果存在）
    if os.path.exists(output_file):
        os.remove(output_file)
    
    # 创建多个进程
    processes = []
    for i in range(3):
        p = multiprocessing.Process(
            target=worker_process,
            args=(i, lock, output_file)
        )
        processes.append(p)
        p.start()
    
    # 等待所有进程完成
    for p in processes:
        p.join()
    
    print("所有进程完成")
    
    # 显示结果
    if os.path.exists(output_file):
        with open(output_file, 'r', encoding='utf-8') as f:
            content = f.read()
            print("最终文件内容:")
            print(content)
    
    # 统计结果
    if os.path.exists(output_file):
        with open(output_file, 'r', encoding='utf-8') as f:
            lines = f.readlines()
            print(f"总行数: {len(lines)}")
            
            # 按进程统计
            process_counts = {}
            for line in lines:
                if line.startswith('进程'):
                    parts = line.split(' - ')
                    process_id = int(parts[0].split()[1])
                    process_counts[process_id] = process_counts.get(process_id, 0) + 1
            
            print("各进程写入行数:", process_counts)

# 执行示例
multiprocess_file_safety()

def multithreaded_file_safety():
    """多线程环境下的文件安全写入"""
    import threading
    import queue
    import time
    
    class ThreadSafeFileWriter:
        """线程安全的文件写入器"""
        def __init__(self, filename, max_queue_size=1000):
            self.filename = filename
            self.write_queue = queue.Queue(max_queue_size)
            self.stop_event = threading.Event()
            self.worker_thread = None
            
        def start(self):
            """启动写入线程"""
            self.worker_thread = threading.Thread(target=self._write_worker)
            self.worker_thread.daemon = True
            self.worker_thread.start()
        
        def stop(self):
            """停止写入线程"""
            self.stop_event.set()
            if self.worker_thread:
                self.worker_thread.join()
        
        def write(self, message):
            """写入消息（线程安全）"""
            try:
                self.write_queue.put(message, timeout=1)
                return True
            except queue.Full:
                print("写入队列已满")
                return False
        
        def _write_worker(self):
            """写入工作线程"""
            # 确保文件存在
            if not os.path.exists(self.filename):
                with open(self.filename, 'w', encoding='utf-8') as f:
                    f.write("文件头\n")
            
            while not self.stop_event.is_set() or not self.write_queue.empty():
                try:
                    # 获取消息
                    message = self.write_queue.get(timeout=0.1)
                    
                    # 写入文件
                    with open(self.filename, 'a', encoding='utf-8') as f:
                        f.write(message + '\n')
                    
                    self.write_queue.task_done()
                    
                except queue.Empty:
                    continue
                except Exception as e:
                    print(f"写入错误: {e}")
    
    def writer_thread(thread_id, writer):
        """写入线程函数"""
        for i in range(10):
            message = f"线程 {thread_id} - 消息 {i} - 时间 {time.time():.6f}"
            success = writer.write(message)
            if not success:
                print(f"线程 {thread_id} 写入失败")
            time.sleep(0.05)
    
    # 使用线程安全写入器
    output_file = 'threadsafe_output.txt'
    
    # 清理旧文件
    if os.path.exists(output_file):
        os.remove(output_file)
    
    writer = ThreadSafeFileWriter(output_file)
    writer.start()
    
    try:
        # 创建多个写入线程
        threads = []
        for i in range(3):
            t = threading.Thread(target=writer_thread, args=(i, writer))
            threads.append(t)
            t.start()
        
        # 等待写入线程完成
        for t in threads:
            t.join()
        
        # 等待队列清空
        writer.write_queue.join()
        
    finally:
        writer.stop()
    
    print("所有线程完成")
    
    # 显示结果
    if os.path.exists(output_file):
        with open(output_file, 'r', encoding='utf-8') as f:
            content = f.read()
            print("最终文件内容:")
            print(content)
            
            # 统计行数
            lines = content.split('\n')
            print(f"总行数: {len([l for l in lines if l.strip()])}")

# 执行示例
multithreaded_file_safety()

def logging_system_implementation():
    """完整的日志系统实现"""
    import logging
    from logging.handlers import RotatingFileHandler
    from datetime import datetime
    
    class SafeRotatingFileHandler(RotatingFileHandler):
        """安全的循环文件处理器"""
        def __init__(self, filename, **kwargs):
            # 确保目录存在
            os.makedirs(os.path.dirname(os.path.abspath(filename)), exist_ok=True)
            super().__init__(filename, **kwargs)
        
        def _open(self):
            """安全打开文件"""
            try:
                return super()._open()
            except FileNotFoundError:
                # 创建文件
                with open(self.baseFilename, 'w', encoding='utf-8'):
                    pass
                return super()._open()
    
    def setup_logging_system():
        """设置日志系统"""
        # 创建日志目录
        log_dir = 'logs'
        os.makedirs(log_dir, exist_ok=True)
        
        # 主日志文件
        main_log = os.path.join(log_dir, 'application.log')
        
        # 配置日志
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            handlers=[
                SafeRotatingFileHandler(
                    main_log,
                    maxBytes=1024 * 1024,  # 1MB
                    backupCount=5,
                    encoding='utf-8'
                ),
                logging.StreamHandler()  # 同时输出到控制台
            ]
        )
        
        return logging.getLogger('Application')
    
    def test_logging_system():
        """测试日志系统"""
        logger = setup_logging_system()
        
        # 记录不同级别的消息
        logger.debug("调试信息")
        logger.info("一般信息")
        logger.warning("警告信息")
        logger.error("错误信息")
        logger.critical("严重错误")
        
        # 记录带上下文的信息
        try:
            # 模拟错误
            result = 1 / 0
        except Exception as e:
            logger.exception("除零错误发生")
        
        # 性能日志
        start_time = time.time()
        time.sleep(0.1)  # 模拟工作
        end_time = time.time()
        logger.info(f"操作完成，耗时: {(end_time - start_time)*1000:.2f}ms")
    
    # 运行测试
    test_logging_system()
    print("日志系统测试完成")
    
    # 检查日志文件
    log_file = 'logs/application.log'
    if os.path.exists(log_file):
        with open(log_file, 'r', encoding='utf-8') as f:
            lines = f.readlines()
            print(f"日志文件行数: {len(lines)}")
            print("最后5行日志:")
            for line in lines[-5:]:
                print(line.strip())

# 执行示例
logging_system_implementation()

def data_export_system():
    """安全的数据导出系统"""
    import csv
    import json
    from datetime import datetime
    
    class DataExporter:
        """数据导出器"""
        def __init__(self, output_dir='exports'):
            self.output_dir = output_dir
            os.makedirs(output_dir, exist_ok=True)
        
        def export_csv(self, data, filename, headers=None):
            """导出CSV文件"""
            filepath = os.path.join(self.output_dir, filename)
            
            # 安全写入CSV
            try:
                with open(filepath, 'x', encoding='utf-8', newline='') as f:
                    writer = csv.writer(f)
                    
                    if headers:
                        writer.writerow(headers)
                    
                    for row in data:
                        writer.writerow(row)
                
                print(f"CSV导出成功: {filepath}")
                return True
                
            except FileExistsError:
                print(f"文件已存在: {filepath}")
                return False
            except Exception as e:
                print(f"CSV导出失败: {e}")
                return False
        
        def export_json(self, data, filename):
            """导出JSON文件"""
            filepath = os.path.join(self.output_dir, filename)
            
            # 使用原子写入
            try:
                # 先写入临时文件
                temp_file = filepath + '.tmp'
                with open(temp_file, 'x', encoding='utf-8') as f:
                    json.dump(data, f, indent=2, ensure_ascii=False)
                
                # 原子替换
                os.replace(temp_file, filepath)
                
                print(f"JSON导出成功: {filepath}")
                return True
                
            except FileExistsError:
                print(f"文件已存在: {filepath}")
                return False
            except Exception as e:
                # 清理临时文件
                if os.path.exists(temp_file):
                    os.remove(temp_file)
                print(f"JSON导出失败: {e}")
                return False
        
        def export_with_timestamp(self, data, base_filename, format='csv'):
            """带时间戳的导出"""
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            filename = f"{base_filename}_{timestamp}.{format}"
            
            if format == 'csv':
                return self.export_csv(data, filename)
            elif format == 'json':
                return self.export_json(data, filename)
            else:
                print(f"不支持的格式: {format}")
                return False
    
    # 使用数据导出器
    exporter = DataExporter('data_exports')
    
    # 示例数据
    sample_data = [
        ['姓名', '年龄', '城市'],
        ['张三', 25, '北京'],
        ['李四', 30, '上海'],
        ['王五', 28, '广州']
    ]
    
    # 导出CSV
    success = exporter.export_csv(
        sample_data[1:],  # 数据行
        'users.csv',
        headers=sample_data[0]  # 表头
    )
    
    # 导出JSON
    json_data = [
        {'name': '张三', 'age': 25, 'city': '北京'},
        {'name': '李四', 'age': 30, 'city': '上海'},
        {'name': '王五', 'age': 28, 'city': '广州'}
    ]
    
    success = exporter.export_json(json_data, 'users.json')
    
    # 带时间戳导出
    success = exporter.export_with_timestamp(
        sample_data[1:],
        'users_backup',
        format='csv'
    )
    
    # 列出导出文件
    print("导出文件列表:")
    for file in os.listdir('data_exports'):
        if file.endswith(('.csv', '.json')):
            filepath = os.path.join('data_exports', file)
            size = os.path.getsize(filepath)
            print(f"  {file}: {size} 字节")

# 执行示例
data_export_system()

def comprehensive_error_handling():
    """完整的文件操作错误处理"""
    class FileOperationError(Exception):
        """文件操作错误基类"""
        pass
    
    class FileExistsError(FileOperationError):
        """文件已存在错误"""
        pass
    
    class FilePermissionError(FileOperationError):
        """文件权限错误"""
        pass
    
    class FileSystemError(FileOperationError):
        """文件系统错误"""
        pass
    
    class SafeFileWriter:
        """安全的文件写入器"""
        def __init__(self, max_retries=3, retry_delay=0.1):
            self.max_retries = max_retries
            self.retry_delay = retry_delay
        
        def write_file(self, filename, content, mode='x', encoding='utf-8'):
            """安全写入文件"""
            for attempt in range(self.max_retries):
                try:
                    with open(filename, mode, encoding=encoding) as f:
                        f.write(content)
                    return True
                    
                except FileExistsError:
                    raise FileExistsError(f"文件已存在: {filename}")
                    
                except PermissionError:
                    if attempt == self.max_retries - 1:
                        raise FilePermissionError(f"没有写入权限: {filename}")
                    time.sleep(self.retry_delay)
                    
                except OSError as e:
                    if attempt == self.max_retries - 1:
                        raise FileSystemError(f"文件系统错误: {e}")
                    time.sleep(self.retry_delay)
                    
                except Exception as e:
                    if attempt == self.max_retries - 1:
                        raise FileOperationError(f"未知错误: {e}")
                    time.sleep(self.retry_delay)
            
            return False
        
        def write_file_with_fallback(self, filename, content, **kwargs):
            """带回退机制的写入"""
            try:
                return self.write_file(filename, content, **kwargs)
                
            except FileExistsError:
                # 生成带时间戳的回退文件名
                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
                base_name, ext = os.path.splitext(filename)
                fallback_filename = f"{base_name}_{timestamp}{ext}"
                
                print(f"文件已存在，使用回退文件名: {fallback_filename}")
                return self.write_file(fallback_filename, content, **kwargs)
    
    # 使用安全写入器
    writer = SafeFileWriter(max_retries=3)
    
    # 测试各种场景
    test_cases = [
        ('test_file.txt', '测试内容', 'x'),  # 正常创建
        ('test_file.txt', '重复内容', 'x'),  # 文件已存在
        ('/root/protected.txt', '权限测试', 'x'),  # 权限错误（Unix）
    ]
    
    for filename, content, mode in test_cases:
        try:
            print(f"\n尝试写入: {filename}")
            success = writer.write_file(filename, content, mode)
            if success:
                print("写入成功")
            else:
                print("写入失败")
                
        except FileExistsError as e:
            print(f"文件存在错误: {e}")
            # 尝试使用回退机制
            try:
                success = writer.write_file_with_fallback(filename, content, mode=mode)
                if success:
                    print("回退写入成功")
            except Exception as fallback_error:
                print(f"回退也失败: {fallback_error}")
                
        except FilePermissionError as e:
            print(f"权限错误: {e}")
            
        except FileSystemError as e:
            print(f"系统错误: {e}")
            
        except FileOperationError as e:
            print(f"操作错误: {e}")
            
        except Exception as e:
            print(f"未知错误: {e}")

# 执行示例
comprehensive_error_handling()

def file_operation_monitoring():
    """文件操作监控与回滚"""
    class FileOperationMonitor:
        """文件操作监控器"""
        def __init__(self):
            self.operations = []  # 记录所有文件操作
            self.backup_files = {}  # 备份文件映射
        
        def backup_file(self, filename):
            """备份文件"""
            if os.path.exists(filename):
                backup_path = filename + '.backup'
                shutil.copy2(filename, backup_path)
                self.backup_files[filename] = backup_path
                return backup_path
            return None
        
        def record_operation(self, op_type, filename, **kwargs):
            """记录文件操作"""
            operation = {
                'type': op_type,
                'filename': filename,
                'timestamp': time.time(),
                'kwargs': kwargs
            }
            self.operations.append(operation)
        
        def safe_write(self, filename, content, **kwargs):
            """安全写入文件"""
            # 备份原文件
            backup_path = self.backup_file(filename)
            
            try:
                # 记录操作
                self.record_operation('write', filename, content=content[:100])
                
                # 执行写入
                with open(filename, 'w', encoding='utf-8') as f:
                    f.write(content)
                
                return True
                
            except Exception as e:
                # 回滚：恢复备份
                if backup_path and os.path.exists(backup_path):
                    shutil.copy2(backup_path, filename)
                    print(f"回滚: 恢复 {filename} 从备份")
                
                # 清理备份
                if backup_path and os.path.exists(backup_path):
                    os.remove(backup_path)
                
                raise e
        
        def rollback(self):
            """回滚所有操作"""
            print("执行回滚操作...")
            success_count = 0
            
            for operation in reversed(self.operations):
                try:
                    if operation['type'] == 'write':
                        filename = operation['filename']
                        if filename in self.backup_files:
                            backup_path = self.backup_files[filename]
                            if os.path.exists(backup_path):
                                shutil.copy2(backup_path, filename)
                                success_count += 1
                                print(f"回滚写入: {filename}")
                    
                    # 可以添加其他操作类型的回滚逻辑
                    
                except Exception as e:
                    print(f"回滚失败 {operation['type']} {operation['filename']}: {e}")
            
            # 清理所有备份
            for backup_path in self.backup_files.values():
                if os.path.exists(backup_path):
                    try:
                        os.remove(backup_path)
                    except:
                        pass
            
            print(f"回滚完成，成功恢复 {success_count} 个文件")
    
    # 使用监控器
    monitor = FileOperationMonitor()
    
    try:
        # 执行一系列文件操作
        test_files = ['test1.txt', 'test2.txt', 'test3.txt']
        
        for i, filename in enumerate(test_files):
            content = f"测试文件 {i+1} 的内容\n" * 10
            
            # 备份并写入
            monitor.safe_write(filename, content)
            print(f"写入成功: {filename}")
        
        # 模拟错误，触发回滚
        raise Exception("模拟的业务逻辑错误")
        
    except Exception as e:
        print(f"发生错误: {e}")
        monitor.rollback()
    
    finally:
        # 清理测试文件
        for filename in test_files:
            if os.path.exists(filename):
                os.remove(filename)
                print(f"清理: {filename}")

# 执行示例
file_operation_monitoring()

def professional_file_writer():
    """
    专业文件写入模板
    包含错误处理、重试机制、并发安全等最佳实践
    """
    class ProfessionalFileWriter:
        def __init__(self, max_retries=3, retry_delay=0.1):
            self.max_retries = max_retries
            self.retry_delay = retry_delay
        
        def write_file(self, filename, content, mode='x', encoding='utf-8'):
            """安全写入文件"""
            for attempt in range(self.max_retries):
                try:
                    # 确保目录存在
                    os.makedirs(os.path.dirname(os.path.abspath(filename)), exist_ok=True)
                    
                    with open(filename, mode, encoding=encoding) as f:
                        f.write(content)
                    
                    # 验证写入结果
                    if self._verify_write(filename, content, encoding):
                        return True
                    else:
                        raise FileSystemError("写入验证失败")
                        
                except FileExistsError:
                    if mode == 'x':  # 独占模式不允许文件存在
                        raise
                    # 其他模式可以继续尝试
                    time.sleep(self.retry_delay)
                    
                except (PermissionError, OSError) as e:
                    if attempt == self.max_retries - 1:
                        raise
                    time.sleep(self.retry_delay)
                    
                except Exception as e:
                    if attempt == self.max_retries - 1:
                        raise
                    time.sleep(self.retry_delay)
            
            return False
        
        def _verify_write(self, filename, expected_content, encoding='utf-8'):
            """验证写入结果"""
            try:
                with open(filename, 'r', encoding=encoding) as f:
                    actual_content = f.read()
                return actual_content == expected_content
            except:
                return False
        
        def atomic_write(self, filename, content, encoding='utf-8'):
            """原子写入"""
            import tempfile
            
            # 创建临时文件
            temp_file = tempfile.NamedTemporaryFile(
                mode='w', delete=False, encoding=encoding
            )
            
            try:
                # 写入临时文件
                with temp_file:
                    temp_file.write(content)
                
                # 原子替换
                os.replace(temp_file.name, filename)
                return True
                
            except Exception as e:
                # 清理临时文件
                if os.path.exists(temp_file.name):
                    os.remove(temp_file.name)
                raise e
            
            finally:
                # 确保临时文件被清理
                if os.path.exists(temp_file.name):
                    try:
                        os.remove(temp_file.name)
                    except:
                        pass
    
    # 使用示例
    writer = ProfessionalFileWriter()
    
    try:
        success = writer.write_file(
            'professional_output.txt',
            '专业写入的内容\n第二行\n',
            mode='x'
        )
        print(f"写入结果: {'成功' if success else '失败'}")
        
    except Exception as e:
        print(f"写入失败: {e}")
        
        # 尝试原子写入作为回退
        try:
            success = writer.atomic_write(
                'professional_output.txt',
                '原子写入的内容\n'
            )
            print(f"原子写入结果: {'成功' if success else '失败'}")
        except Exception as atomic_error:
            print(f"原子写入也失败: {atomic_error}")

# 执行示例
professional_file_writer()