# 基本的文件打開模式
file = open('filename.txt', 'r')    # 只讀模式
file = open('filename.txt', 'w')    # 寫入模式（覆蓋）
file = open('filename.txt', 'a')    # 追加模式
file = open('filename.txt', 'r+')   # 讀寫模式

with open('filename.txt', 'r') as file:
    content = file.read()
    # 文件會(huì)自動(dòng)關(guān)閉

def simple_copy(source_file, destination_file):
    """
    最簡(jiǎn)單的文件復(fù)制函數(shù)
    
    Args:
        source_file (str): 源文件路徑
        destination_file (str): 目標(biāo)文件路徑
    """
    try:
        with open(source_file, 'r') as src:
            content = src.read()
        
        with open(destination_file, 'w') as dst:
            dst.write(content)
            
        print(f"? 文件已成功從 {source_file} 復(fù)制到 {destination_file}")
        
    except FileNotFoundError:
        print(f"? 錯(cuò)誤：源文件 {source_file} 未找到")
    except PermissionError:
        print(f"? 錯(cuò)誤：沒有權(quán)限訪問文件")
    except Exception as e:
        print(f"? 發(fā)生未知錯(cuò)誤：{e}")

# 使用示例
if __name__ == "__main__":
    # 創(chuàng)建測(cè)試文件
    with open('test_source.txt', 'w') as f:
        f.write("這是測(cè)試內(nèi)容\nHello World!\nPython文件操作")
    
    # 執(zhí)行復(fù)制
    simple_copy('test_source.txt', 'test_destination.txt')

def chunked_copy(source_file, destination_file, chunk_size=1024*1024):
    """
    分塊讀取的文件復(fù)制函數(shù)
    
    Args:
        source_file (str): 源文件路徑
        destination_file (str): 目標(biāo)文件路徑
        chunk_size (int): 每次讀取的字節(jié)數(shù)，默認(rèn)1MB
    """
    try:
        with open(source_file, 'rb') as src, open(destination_file, 'wb') as dst:
            while True:
                chunk = src.read(chunk_size)
                if not chunk:
                    break
                dst.write(chunk)
                
        print(f"? 文件已成功從 {source_file} 復(fù)制到 {destination_file}")
        
    except FileNotFoundError:
        print(f"? 錯(cuò)誤：源文件 {source_file} 未找到")
    except PermissionError:
        print(f"? 錯(cuò)誤：沒有權(quán)限訪問文件")
    except Exception as e:
        print(f"? 發(fā)生未知錯(cuò)誤：{e}")

# 使用示例
chunked_copy('large_file.bin', 'large_file_copy.bin')

import os
import shutil
from pathlib import Path

class FileCopier:
    """文件復(fù)制器類"""
    
    def __init__(self):
        self.copied_bytes = 0
        self.total_bytes = 0
    
    def copy_with_progress(self, source_file, destination_file, show_progress=True):
        """
        帶進(jìn)度顯示的文件復(fù)制
        
        Args:
            source_file (str): 源文件路徑
            destination_file (str): 目標(biāo)文件路徑
            show_progress (bool): 是否顯示進(jìn)度
        """
        try:
            # 檢查源文件是否存在
            if not os.path.exists(source_file):
                raise FileNotFoundError(f"源文件不存在: {source_file}")
            
            # 獲取文件大小
            self.total_bytes = os.path.getsize(source_file)
            
            # 如果目標(biāo)文件存在，詢問是否覆蓋
            if os.path.exists(destination_file):
                response = input(f"?? 目標(biāo)文件 {destination_file} 已存在，是否覆蓋？(y/n): ")
                if response.lower() != 'y':
                    print("? 操作已取消")
                    return False
            
            # 執(zhí)行復(fù)制
            self._copy_file(source_file, destination_file, show_progress)
            
            print(f"\n? 文件復(fù)制完成！")
            print(f"?? 源文件: {source_file}")
            print(f"?? 目標(biāo)文件: {destination_file}")
            print(f"?? 文件大小: {self._format_bytes(self.total_bytes)}")
            
            return True
            
        except FileNotFoundError as e:
            print(f"? 錯(cuò)誤：{e}")
        except PermissionError:
            print(f"? 錯(cuò)誤：沒有權(quán)限訪問文件")
        except KeyboardInterrupt:
            print("\n?? 用戶中斷了操作")
        except Exception as e:
            print(f"? 發(fā)生未知錯(cuò)誤：{e}")
        
        return False
    
    def _copy_file(self, source_file, destination_file, show_progress):
        """執(zhí)行文件復(fù)制的核心方法"""
        chunk_size = 1024 * 64  # 64KB chunks
        self.copied_bytes = 0
        
        with open(source_file, 'rb') as src, open(destination_file, 'wb') as dst:
            while True:
                chunk = src.read(chunk_size)
                if not chunk:
                    break
                
                dst.write(chunk)
                self.copied_bytes += len(chunk)
                
                if show_progress and self.total_bytes > 0:
                    self._show_progress()
    
    def _show_progress(self):
        """顯示復(fù)制進(jìn)度"""
        if self.total_bytes > 0:
            progress = (self.copied_bytes / self.total_bytes) * 100
            bar_length = 30
            filled_length = int(bar_length * progress // 100)
            bar = '█' * filled_length + '-' * (bar_length - filled_length)
            
            print(f'\r進(jìn)度: |{bar}| {progress:.1f}% ({self._format_bytes(self.copied_bytes)}/{self._format_bytes(self.total_bytes)})', 
                  end='', flush=True)
    
    def _format_bytes(self, bytes_count):
        """格式化字節(jié)大小顯示"""
        for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
            if bytes_count < 1024.0:
                return f"{bytes_count:.1f}{unit}"
            bytes_count /= 1024.0
        return f"{bytes_count:.1f}PB"

# 使用示例
def main():
    copier = FileCopier()
    
    # 創(chuàng)建測(cè)試文件
    test_content = "這是一個(gè)測(cè)試文件的內(nèi)容\n" * 1000
    with open('test_large.txt', 'w', encoding='utf-8') as f:
        f.write(test_content)
    
    # 執(zhí)行復(fù)制
    copier.copy_with_progress('test_large.txt', 'test_large_copy.txt')

if __name__ == "__main__":
    main()

import glob
import os
from pathlib import Path

class BatchFileCopier(FileCopier):
    """批量文件復(fù)制器"""
    
    def copy_files_by_pattern(self, pattern, destination_dir):
        """
        根據(jù)模式批量復(fù)制文件
        
        Args:
            pattern (str): 文件匹配模式，如 "*.txt"
            destination_dir (str): 目標(biāo)目錄
        """
        files = glob.glob(pattern)
        if not files:
            print(f"? 沒有找到匹配的文件: {pattern}")
            return False
        
        # 確保目標(biāo)目錄存在
        os.makedirs(destination_dir, exist_ok=True)
        
        print(f"?? 找到 {len(files)} 個(gè)文件需要復(fù)制")
        
        success_count = 0
        for file_path in files:
            filename = os.path.basename(file_path)
            dest_path = os.path.join(destination_dir, filename)
            
            print(f"\n?? 正在復(fù)制: {file_path}")
            if self.copy_with_progress(file_path, dest_path, show_progress=False):
                success_count += 1
        
        print(f"\n?? 批量復(fù)制完成！成功: {success_count}/{len(files)}")
        return success_count == len(files)
    
    def copy_directory(self, source_dir, destination_dir, recursive=True):
        """
        復(fù)制整個(gè)目錄
        
        Args:
            source_dir (str): 源目錄
            destination_dir (str): 目標(biāo)目錄
            recursive (bool): 是否遞歸復(fù)制子目錄
        """
        source_path = Path(source_dir)
        dest_path = Path(destination_dir)
        
        if not source_path.exists():
            print(f"? 源目錄不存在: {source_dir}")
            return False
        
        if not source_path.is_dir():
            print(f"? 源路徑不是目錄: {source_dir}")
            return False
        
        # 創(chuàng)建目標(biāo)目錄
        dest_path.mkdir(parents=True, exist_ok=True)
        
        copied_files = 0
        total_files = 0
        
        # 遍歷源目錄
        for item in source_path.rglob('*') if recursive else source_path.iterdir():
            if item.is_file():
                total_files += 1
                relative_path = item.relative_to(source_path)
                dest_item = dest_path / relative_path
                
                # 創(chuàng)建必要的子目錄
                dest_item.parent.mkdir(parents=True, exist_ok=True)
                
                print(f"?? 正在復(fù)制: {item}")
                if self.copy_with_progress(str(item), str(dest_item), show_progress=False):
                    copied_files += 1
        
        print(f"\n?? 目錄復(fù)制完成！成功: {copied_files}/{total_files}")
        return copied_files == total_files

# 使用示例
def batch_example():
    copier = BatchFileCopier()
    
    # 創(chuàng)建測(cè)試文件
    os.makedirs('test_folder', exist_ok=True)
    for i in range(5):
        with open(f'test_folder/file_{i}.txt', 'w') as f:
            f.write(f"這是第{i}個(gè)測(cè)試文件")
    
    # 批量復(fù)制特定類型文件
    copier.copy_files_by_pattern('test_folder/*.txt', 'backup_folder')
    
    # 復(fù)制整個(gè)目錄
    copier.copy_directory('test_folder', 'full_backup')

if __name__ == "__main__":
    batch_example()

import hashlib

class VerifiedFileCopier(BatchFileCopier):
    """帶驗(yàn)證的文件復(fù)制器"""
    
    def get_file_hash(self, file_path, algorithm='md5'):
        """
        計(jì)算文件的哈希值
        
        Args:
            file_path (str): 文件路徑
            algorithm (str): 哈希算法
        
        Returns:
            str: 文件哈希值
        """
        hash_obj = hashlib.new(algorithm)
        
        with open(file_path, 'rb') as f:
            for chunk in iter(lambda: f.read(4096), b""):
                hash_obj.update(chunk)
        
        return hash_obj.hexdigest()
    
    def copy_with_verification(self, source_file, destination_file, verify=True):
        """
        帶驗(yàn)證的文件復(fù)制
        
        Args:
            source_file (str): 源文件路徑
            destination_file (str): 目標(biāo)文件路徑
            verify (bool): 是否驗(yàn)證文件完整性
        """
        # 先執(zhí)行普通復(fù)制
        if not self.copy_with_progress(source_file, destination_file):
            return False
        
        # 如果需要驗(yàn)證
        if verify:
            print("?? 正在校驗(yàn)文件完整性...")
            try:
                source_hash = self.get_file_hash(source_file)
                dest_hash = self.get_file_hash(destination_file)
                
                if source_hash == dest_hash:
                    print("? 文件完整性校驗(yàn)通過")
                    return True
                else:
                    print("? 文件完整性校驗(yàn)失敗")
                    return False
                    
            except Exception as e:
                print(f"? 校驗(yàn)過程中發(fā)生錯(cuò)誤: {e}")
                return False
        
        return True

# 使用示例
def verification_example():
    copier = VerifiedFileCopier()
    
    # 創(chuàng)建測(cè)試文件
    with open('verify_test.txt', 'w') as f:
        f.write("這是用于驗(yàn)證的測(cè)試文件內(nèi)容" * 100)
    
    # 帶驗(yàn)證的復(fù)制
    copier.copy_with_verification('verify_test.txt', 'verify_test_copy.txt')

if __name__ == "__main__":
    verification_example()

import shutil
import os

def optimized_copy(source_file, destination_file):
    """
    使用shutil進(jìn)行高效文件復(fù)制
    
    Args:
        source_file (str): 源文件路徑
        destination_file (str): 目標(biāo)文件路徑
    """
    try:
        # 對(duì)于小文件，直接復(fù)制
        file_size = os.path.getsize(source_file)
        
        if file_size < 1024 * 1024:  # 小于1MB
            shutil.copy2(source_file, destination_file)
        else:
            # 對(duì)于大文件，使用copyfileobj
            with open(source_file, 'rb') as src, open(destination_file, 'wb') as dst:
                shutil.copyfileobj(src, dst, length=64*1024)  # 64KB緩沖區(qū)
        
        print(f"? 文件復(fù)制完成")
        return True
        
    except Exception as e:
        print(f"? 復(fù)制失敗: {e}")
        return False

import concurrent.futures
import os
from pathlib import Path

class ParallelFileCopier(VerifiedFileCopier):
    """并行文件復(fù)制器"""
    
    def copy_files_parallel(self, file_pairs, max_workers=4):
        """
        并行復(fù)制多個(gè)文件
        
        Args:
            file_pairs (list): 源文件和目標(biāo)文件的元組列表
            max_workers (int): 最大工作線程數(shù)
        """
        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
            # 提交所有任務(wù)
            future_to_pair = {
                executor.submit(self.copy_with_progress, src, dst, False): (src, dst)
                for src, dst in file_pairs
            }
            
            # 收集結(jié)果
            completed = 0
            total = len(file_pairs)
            
            for future in concurrent.futures.as_completed(future_to_pair):
                src, dst = future_to_pair[future]
                try:
                    result = future.result()
                    if result:
                        completed += 1
                        print(f"? 完成: {src} -> {dst}")
                    else:
                        print(f"? 失敗: {src} -> {dst}")
                except Exception as e:
                    print(f"? 復(fù)制 {src} 時(shí)發(fā)生錯(cuò)誤: {e}")
            
            print(f"\n?? 并行復(fù)制完成！成功: {completed}/{total}")

# 使用示例
def parallel_example():
    copier = ParallelFileCopier()
    
    # 準(zhǔn)備測(cè)試文件
    test_files = []
    for i in range(10):
        filename = f'parallel_test_{i}.txt'
        with open(filename, 'w') as f:
            f.write(f"這是第{i}個(gè)并行測(cè)試文件" * 50)
        test_files.append((filename, f'parallel_copy_{i}.txt'))
    
    # 并行復(fù)制
    copier.copy_files_parallel(test_files, max_workers=3)

if __name__ == "__main__":
    parallel_example()

import logging
import time
from enum import Enum

class CopyResult(Enum):
    SUCCESS = "success"
    FILE_NOT_FOUND = "file_not_found"
    PERMISSION_DENIED = "permission_denied"
    DISK_FULL = "disk_full"
    INTERRUPTED = "interrupted"
    UNKNOWN_ERROR = "unknown_error"

class RobustFileCopier(ParallelFileCopier):
    """健壯的文件復(fù)制器"""
    
    def __init__(self, retry_attempts=3, retry_delay=1):
        super().__init__()
        self.retry_attempts = retry_attempts
        self.retry_delay = retry_delay
        self.logger = self._setup_logger()
    
    def _setup_logger(self):
        """設(shè)置日志記錄器"""
        logger = logging.getLogger('FileCopier')
        logger.setLevel(logging.INFO)
        
        handler = logging.StreamHandler()
        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        
        return logger
    
    def copy_with_retry(self, source_file, destination_file):
        """
        帶重試機(jī)制的文件復(fù)制
        
        Args:
            source_file (str): 源文件路徑
            destination_file (str): 目標(biāo)文件路徑
        """
        for attempt in range(self.retry_attempts):
            try:
                self.logger.info(f"嘗試復(fù)制 {source_file} 到 {destination_file} (第{attempt+1}次)")
                
                if self.copy_with_progress(source_file, destination_file):
                    self.logger.info("? 文件復(fù)制成功")
                    return CopyResult.SUCCESS
                
            except FileNotFoundError:
                self.logger.error(f"? 源文件未找到: {source_file}")
                return CopyResult.FILE_NOT_FOUND
                
            except PermissionError:
                self.logger.error(f"? 權(quán)限不足: {source_file}")
                return CopyResult.PERMISSION_DENIED
                
            except OSError as e:
                if "No space left on device" in str(e):
                    self.logger.error("? 磁盤空間不足")
                    return CopyResult.DISK_FULL
                else:
                    self.logger.error(f"? 系統(tǒng)錯(cuò)誤: {e}")
                    
            except KeyboardInterrupt:
                self.logger.warning("?? 用戶中斷操作")
                return CopyResult.INTERRUPTED
                
            except Exception as e:
                self.logger.error(f"? 未知錯(cuò)誤: {e}")
                
                if attempt < self.retry_attempts - 1:
                    self.logger.info(f"等待 {self.retry_delay} 秒后重試...")
                    time.sleep(self.retry_delay)
                else:
                    return CopyResult.UNKNOWN_ERROR
        
        return CopyResult.UNKNOWN_ERROR

# 使用示例
def robust_example():
    copier = RobustFileCopier(retry_attempts=3, retry_delay=2)
    
    # 創(chuàng)建測(cè)試文件
    with open('robust_test.txt', 'w') as f:
        f.write("這是健壯性測(cè)試文件" * 100)
    
    # 執(zhí)行帶重試的復(fù)制
    result = copier.copy_with_retry('robust_test.txt', 'robust_test_copy.txt')
    print(f"復(fù)制結(jié)果: {result.value}")

if __name__ == "__main__":
    robust_example()

import datetime
import gzip

class LogRotator(RobustFileCopier):
    """日志文件輪轉(zhuǎn)器"""
    
    def rotate_log(self, log_file, backup_count=5, compress=True):
        """
        輪轉(zhuǎn)日志文件
        
        Args:
            log_file (str): 日志文件路徑
            backup_count (int): 保留的備份數(shù)量
            compress (bool): 是否壓縮舊日志
        """
        if not os.path.exists(log_file):
            self.logger.info(f"日志文件不存在: {log_file}")
            return
        
        # 創(chuàng)建時(shí)間戳
        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        
        # 備份當(dāng)前日志
        backup_name = f"{log_file}.{timestamp}"
        if self.copy_with_retry(log_file, backup_name) != CopyResult.SUCCESS:
            return
        
        # 壓縮備份文件（如果需要）
        if compress:
            compressed_name = f"{backup_name}.gz"
            try:
                with open(backup_name, 'rb') as f_in:
                    with gzip.open(compressed_name, 'wb') as f_out:
                        shutil.copyfileobj(f_in, f_out)
                os.remove(backup_name)  # 刪除未壓縮的備份
                backup_name = compressed_name
            except Exception as e:
                self.logger.error(f"壓縮失敗: {e}")
        
        # 清理舊的備份文件
        self._cleanup_old_backups(log_file, backup_count, compress)
        
        # 清空原日志文件
        try:
            with open(log_file, 'w'):
                pass  # 清空文件
            self.logger.info("? 日志輪轉(zhuǎn)完成")
        except Exception as e:
            self.logger.error(f"清空日志文件失敗: {e}")
    
    def _cleanup_old_backups(self, log_file, backup_count, compress):
        """清理舊的備份文件"""
        pattern = f"{log_file}.*"
        if compress:
            pattern += ".gz"
        
        backups = glob.glob(pattern)
        backups.sort(reverse=True)  # 按時(shí)間倒序排列
        
        # 刪除超出保留數(shù)量的備份
        for old_backup in backups[backup_count:]:
            try:
                os.remove(old_backup)
                self.logger.info(f"刪除舊備份: {old_backup}")
            except Exception as e:
                self.logger.error(f"刪除備份失敗 {old_backup}: {e}")

# 使用示例
def log_rotation_example():
    rotator = LogRotator()
    
    # 創(chuàng)建模擬日志文件
    with open('app.log', 'w') as f:
        f.write("這是應(yīng)用日志內(nèi)容\n" * 1000)
    
    # 執(zhí)行日志輪轉(zhuǎn)
    rotator.rotate_log('app.log', backup_count=3, compress=True)

if __name__ == "__main__":
    log_rotation_example()

import json
import yaml

class ConfigBackupManager(RobustFileCopier):
    """配置文件備份管理器"""
    
    def backup_configs(self, config_paths, backup_dir="config_backup"):
        """
        備份多個(gè)配置文件
        
        Args:
            config_paths (list): 配置文件路徑列表
            backup_dir (str): 備份目錄
        """
        # 創(chuàng)建備份目錄
        os.makedirs(backup_dir, exist_ok=True)
        
        # 創(chuàng)建備份信息文件
        backup_info = {
            "timestamp": datetime.datetime.now().isoformat(),
            "configs": {},
            "system_info": {
                "platform": os.name,
                "cwd": os.getcwd()
            }
        }
        
        success_count = 0
        for config_path in config_paths:
            if os.path.exists(config_path):
                filename = os.path.basename(config_path)
                backup_path = os.path.join(backup_dir, filename)
                
                # 執(zhí)行備份
                result = self.copy_with_retry(config_path, backup_path)
                if result == CopyResult.SUCCESS:
                    success_count += 1
                    
                    # 記錄配置文件信息
                    backup_info["configs"][filename] = {
                        "original_path": config_path,
                        "backup_path": backup_path,
                        "size": os.path.getsize(config_path),
                        "modified_time": os.path.getmtime(config_path)
                    }
        
        # 保存?zhèn)浞菪畔?
        info_file = os.path.join(backup_dir, "backup_info.json")
        with open(info_file, 'w') as f:
            json.dump(backup_info, f, indent=2, default=str)
        
        print(f"? 配置文件備份完成！成功: {success_count}/{len(config_paths)}")
        print(f"?? 備份位置: {os.path.abspath(backup_dir)}")
    
    def restore_config(self, backup_dir, config_name):
        """
        恢復(fù)配置文件
        
        Args:
            backup_dir (str): 備份目錄
            config_name (str): 配置文件名
        """
        backup_path = os.path.join(backup_dir, config_name)
        if not os.path.exists(backup_path):
            print(f"? 備份文件不存在: {backup_path}")
            return False
        
        # 從備份信息中獲取原始路徑
        info_file = os.path.join(backup_dir, "backup_info.json")
        if os.path.exists(info_file):
            with open(info_file, 'r') as f:
                backup_info = json.load(f)
            
            original_path = backup_info.get("configs", {}).get(config_name, {}).get("original_path")
            if original_path:
                return self.copy_with_retry(backup_path, original_path) == CopyResult.SUCCESS
        
        print("? 無法確定原始路徑，請(qǐng)手動(dòng)指定")
        return False

# 使用示例
def config_backup_example():
    manager = ConfigBackupManager()
    
    # 創(chuàng)建測(cè)試配置文件
    test_configs = ['app.conf', 'database.yml', 'settings.json']
    for config in test_configs:
        with open(config, 'w') as f:
            if config.endswith('.json'):
                json.dump({"setting": "value"}, f)
            elif config.endswith('.yml'):
                f.write("setting: value\n")
            else:
                f.write("setting=value\n")
    
    # 執(zhí)行備份
    manager.backup_configs(test_configs)
    
    # 模擬恢復(fù)
    # manager.restore_config('config_backup', 'app.conf')

if __name__ == "__main__":
    config_backup_example()

# 推薦的錯(cuò)誤處理模式
try:
    # 文件操作
    pass
except FileNotFoundError:
    # 處理文件不存在
    pass
except PermissionError:
    # 處理權(quán)限問題
    pass
except OSError as e:
    # 處理系統(tǒng)相關(guān)錯(cuò)誤
    pass
except Exception as e:
    # 處理其他異常
    pass

with open('file.txt', 'r') as f:
    content = f.read()
# 文件自動(dòng)關(guān)閉