import sys

def basic_redirection():
    """基礎(chǔ)輸出重定向示例"""
    # 保存原始標(biāo)準(zhǔn)輸出
    original_stdout = sys.stdout
    
    try:
        # 重定向到文件
        with open('output.txt', 'w', encoding='utf-8') as f:
            sys.stdout = f
            print("這條消息將寫入文件")
            print("當(dāng)前時(shí)間:", "2024-01-15 10:30:00")
            print("狀態(tài): 正常")
    
    finally:
        # 恢復(fù)標(biāo)準(zhǔn)輸出
        sys.stdout = original_stdout
    
    print("這條消息將顯示在控制臺(tái)")

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

def print_file_parameter():
    """使用print函數(shù)的file參數(shù)進(jìn)行重定向"""
    # 直接重定向到文件
    with open('direct_output.txt', 'w', encoding='utf-8') as f:
        print("直接使用file參數(shù)", file=f)
        print("多行輸出示例", file=f)
        print("結(jié)束輸出", file=f)
    
    # 同時(shí)輸出到控制臺(tái)和文件
    with open('dual_output.txt', 'w', encoding='utf-8') as f:
        print("同時(shí)輸出到文件和屏幕:")
        for i in range(3):
            msg = f"消息 {i+1}"
            print(msg)  # 輸出到控制臺(tái)
            print(msg, file=f)  # 輸出到文件
    
    print("所有操作完成")

print_file_parameter()

def stderr_redirection():
    """標(biāo)準(zhǔn)錯(cuò)誤輸出重定向"""
    import sys
    
    # 保存原始stderr
    original_stderr = sys.stderr
    
    try:
        # 重定向stderr到文件
        with open('error_log.txt', 'w', encoding='utf-8') as f:
            sys.stderr = f
            # 模擬錯(cuò)誤輸出
            print("這是一條錯(cuò)誤消息", file=sys.stderr)
            print("程序遇到問題", file=sys.stderr)
            # 模擬異常
            try:
                1 / 0
            except Exception as e:
                print(f"捕獲到異常: {e}", file=sys.stderr)
    
    finally:
        # 恢復(fù)stderr
        sys.stderr = original_stderr
    
    print("錯(cuò)誤日志已保存到文件")

stderr_redirection()

class RedirectOutput:
    """輸出重定向上下文管理器"""
    def __init__(self, stdout=None, stderr=None, mode='w', encoding='utf-8'):
        self.stdout_file = stdout
        self.stderr_file = stderr
        self.mode = mode
        self.encoding = encoding
        self.original_stdout = None
        self.original_stderr = None
        self.stdout_handle = None
        self.stderr_handle = None
    
    def __enter__(self):
        import sys
        
        # 保存原始輸出
        self.original_stdout = sys.stdout
        self.original_stderr = sys.stderr
        
        # 設(shè)置新的輸出
        if self.stdout_file:
            if isinstance(self.stdout_file, str):
                self.stdout_handle = open(self.stdout_file, self.mode, encoding=self.encoding)
                sys.stdout = self.stdout_handle
            else:
                sys.stdout = self.stdout_file
        
        if self.stderr_file:
            if isinstance(self.stderr_file, str):
                self.stderr_handle = open(self.stderr_file, self.mode, encoding=self.encoding)
                sys.stderr = self.stderr_handle
            else:
                sys.stderr = self.stderr_file
        
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        import sys
        
        # 恢復(fù)原始輸出
        if self.original_stdout:
            sys.stdout = self.original_stdout
        if self.original_stderr:
            sys.stderr = self.original_stderr
        
        # 關(guān)閉文件句柄
        if self.stdout_handle:
            self.stdout_handle.close()
        if self.stderr_handle:
            self.stderr_handle.close()
        
        return False  # 不抑制異常

# 使用示例
def context_manager_example():
    """上下文管理器使用示例"""
    with RedirectOutput('output_ctx.txt', 'error_ctx.txt'):
        print("普通輸出到文件")
        print("另一條輸出消息", file=sys.stdout)
        print("錯(cuò)誤信息", file=sys.stderr)
    
    print("回到控制臺(tái)輸出")

context_manager_example()

class MultiOutput:
    """多目標(biāo)輸出重定向"""
    def __init__(self, *outputs):
        self.outputs = outputs
    
    def write(self, message):
        for output in self.outputs:
            output.write(message)
    
    def flush(self):
        for output in self.outputs:
            if hasattr(output, 'flush'):
                output.flush()

def multi_output_example():
    """多目標(biāo)輸出示例"""
    # 創(chuàng)建多個(gè)輸出目標(biāo)
    with open('file1.txt', 'w', encoding='utf-8') as f1, \
         open('file2.txt', 'w', encoding='utf-8') as f2:
        
        # 創(chuàng)建多目標(biāo)輸出對象
        multi = MultiOutput(sys.stdout, f1, f2)
        
        # 臨時(shí)重定向
        original_stdout = sys.stdout
        sys.stdout = multi
        
        try:
            print("這條消息將同時(shí)輸出到:")
            print("1. 控制臺(tái)")
            print("2. file1.txt")
            print("3. file2.txt")
            
        finally:
            sys.stdout = original_stdout
    
    print("恢復(fù)單目標(biāo)輸出")

multi_output_example()

def real_time_logging():
    """實(shí)時(shí)日志重定向系統(tǒng)"""
    import time
    from datetime import datetime
    
    class TimestampedOutput:
        """帶時(shí)間戳的輸出重定向"""
        def __init__(self, filename):
            self.filename = filename
            self.file = open(filename, 'a', encoding='utf-8')
        
        def write(self, message):
            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            log_message = f"[{timestamp}] {message}"
            self.file.write(log_message)
            self.file.flush()  # 確保實(shí)時(shí)寫入
        
        def flush(self):
            self.file.flush()
        
        def close(self):
            self.file.close()
    
    # 使用示例
    log_output = TimestampedOutput('app.log')
    
    # 重定向輸出
    original_stdout = sys.stdout
    sys.stdout = log_output
    
    try:
        # 模擬應(yīng)用輸出
        for i in range(5):
            print(f"應(yīng)用日志消息 {i+1}")
            time.sleep(1)  # 模擬處理時(shí)間
        
        print("任務(wù)完成")
    
    finally:
        sys.stdout = original_stdout
        log_output.close()
    
    print("日志記錄完成，查看 app.log 文件")

real_time_logging()

def rotating_log_system():
    """循環(huán)日志文件系統(tǒng)"""
    import os
    from datetime import datetime
    
    class RotatingFileOutput:
        """循環(huán)文件輸出"""
        def __init__(self, base_filename, max_size=1024 * 1024, backup_count=5):
            self.base_filename = base_filename
            self.max_size = max_size
            self.backup_count = backup_count
            self.current_file = None
            self.current_size = 0
            self.open_file()
        
        def open_file(self):
            """打開當(dāng)前日志文件"""
            if self.current_file:
                self.current_file.close()
            
            self.current_file = open(self.base_filename, 'a', encoding='utf-8')
            self.current_size = os.path.getsize(self.base_filename)
        
        def write(self, message):
            """寫入消息，處理文件循環(huán)"""
            # 檢查文件大小
            if self.current_size + len(message) > self.max_size:
                self.rotate_file()
            
            self.current_file.write(message)
            self.current_size += len(message)
            self.current_file.flush()
        
        def rotate_file(self):
            """循環(huán)日志文件"""
            self.current_file.close()
            
            # 重命名現(xiàn)有備份文件
            for i in range(self.backup_count - 1, 0, -1):
                old_file = f"{self.base_filename}.{i}"
                new_file = f"{self.base_filename}.{i+1}"
                if os.path.exists(old_file):
                    os.rename(old_file, new_file)
            
            # 重命名當(dāng)前文件
            os.rename(self.base_filename, f"{self.base_filename}.1")
            
            # 創(chuàng)建新文件
            self.open_file()
        
        def flush(self):
            if self.current_file:
                self.current_file.flush()
        
        def close(self):
            if self.current_file:
                self.current_file.close()
    
    # 使用示例
    rotating_output = RotatingFileOutput('app.log', max_size=100, backup_count=3)
    
    original_stdout = sys.stdout
    sys.stdout = rotating_output
    
    try:
        for i in range(20):
            print(f"日志消息 {i+1}: 這是一條測試日志消息")
        
        print("所有日志消息寫入完成")
    
    finally:
        sys.stdout = original_stdout
        rotating_output.close()
    
    print("循環(huán)日志測試完成")
    print("生成的文件:")
    for file in os.listdir('.'):
        if file.startswith('app.log'):
            size = os.path.getsize(file)
            print(f"  {file}: {size} 字節(jié)")

rotating_log_system()

def filtered_output_redirection():
    """過濾式輸出重定向"""
    class FilteredOutput:
        """帶過濾功能的輸出重定向"""
        def __init__(self, output, filter_func=None):
            self.output = output
            self.filter_func = filter_func or (lambda x: True)
        
        def write(self, message):
            if self.filter_func(message):
                self.output.write(message)
        
        def flush(self):
            if hasattr(self.output, 'flush'):
                self.output.flush()
    
    # 使用示例
    def contains_error(message):
        """過濾包含錯(cuò)誤關(guān)鍵詞的消息"""
        error_keywords = ['error', 'fail', 'exception', '警告']
        return any(keyword in message.lower() for keyword in error_keywords)
    
    # 創(chuàng)建錯(cuò)誤日志文件
    with open('error_only.log', 'w', encoding='utf-8') as error_file:
        filtered_output = FilteredOutput(error_file, contains_error)
        
        original_stdout = sys.stdout
        sys.stdout = filtered_output
        
        try:
            print("這是一條普通信息")
            print("發(fā)現(xiàn)錯(cuò)誤: 文件未找到")
            print("操作完成")
            print("警告: 內(nèi)存使用率高")
            print("正常結(jié)束")
        
        finally:
            sys.stdout = original_stdout
    
    print("過濾輸出完成")
    print("錯(cuò)誤日志內(nèi)容:")
    with open('error_only.log', 'r', encoding='utf-8') as f:
        print(f.read())

filtered_output_redirection()

def buffered_output_redirection():
    """緩沖輸出重定向優(yōu)化"""
    class BufferedOutput:
        """緩沖輸出提高性能"""
        def __init__(self, output, buffer_size=8192):
            self.output = output
            self.buffer_size = buffer_size
            self.buffer = []
            self.current_size = 0
        
        def write(self, message):
            self.buffer.append(message)
            self.current_size += len(message)
            
            if self.current_size >= self.buffer_size:
                self.flush()
        
        def flush(self):
            if self.buffer:
                full_message = ''.join(self.buffer)
                self.output.write(full_message)
                if hasattr(self.output, 'flush'):
                    self.output.flush()
                self.buffer = []
                self.current_size = 0
        
        def close(self):
            self.flush()
            if hasattr(self.output, 'close'):
                self.output.close()
    
    # 性能測試
    import time
    
    # 無緩沖寫入
    start_time = time.time()
    with open('unbuffered.txt', 'w', encoding='utf-8') as f:
        for i in range(10000):
            f.write(f"行 {i}: 測試數(shù)據(jù)\n")
    unbuffered_time = time.time() - start_time
    
    # 緩沖寫入
    start_time = time.time()
    with open('buffered.txt', 'w', encoding='utf-8') as raw_file:
        buffered_file = BufferedOutput(raw_file, buffer_size=8192)
        for i in range(10000):
            buffered_file.write(f"行 {i}: 測試數(shù)據(jù)\n")
        buffered_file.close()
    buffered_time = time.time() - start_time
    
    print(f"無緩沖時(shí)間: {unbuffered_time:.4f}秒")
    print(f"緩沖時(shí)間: {buffered_time:.4f}秒")
    print(f"性能提升: {(unbuffered_time/buffered_time):.2f}倍")

buffered_output_redirection()

def subprocess_output_redirection():
    """子進(jìn)程輸出重定向"""
    import subprocess
    
    # 重定向子進(jìn)程輸出到文件
    with open('subprocess_output.txt', 'w', encoding='utf-8') as f:
        result = subprocess.run(
            ['python', '-c', 'print("子進(jìn)程輸出"); import sys; sys.stderr.write("子進(jìn)程錯(cuò)誤\\n")'],
            stdout=f,
            stderr=subprocess.STDOUT,  # 合并標(biāo)準(zhǔn)錯(cuò)誤到標(biāo)準(zhǔn)輸出
            text=True
        )
    
    print("子進(jìn)程執(zhí)行完成")
    print("輸出文件內(nèi)容:")
    with open('subprocess_output.txt', 'r', encoding='utf-8') as f:
        print(f.read())
    
    # 捕獲子進(jìn)程輸出到變量
    result = subprocess.run(
        ['python', '-c', 'print("捕獲的輸出"); import sys; sys.stderr.write("捕獲的錯(cuò)誤\\n")'],
        capture_output=True,
        text=True
    )
    
    print(f"標(biāo)準(zhǔn)輸出: {result.stdout}")
    print(f"標(biāo)準(zhǔn)錯(cuò)誤: {result.stderr}")
    print(f"返回碼: {result.returncode}")

subprocess_output_redirection()

def pipeline_output_redirection():
    """管道輸出重定向"""
    import subprocess
    
    # 創(chuàng)建管道處理鏈
    process1 = subprocess.Popen(
        ['python', '-c', 'for i in range(5): print(f"數(shù)據(jù) {i}")'],
        stdout=subprocess.PIPE,
        text=True
    )
    
    process2 = subprocess.Popen(
        ['python', '-c', '''
import sys
for line in sys.stdin:
    processed = line.strip().upper()
    print(f"處理后的: {processed}")
        '''],
        stdin=process1.stdout,
        stdout=subprocess.PIPE,
        text=True
    )
    
    # 獲取最終輸出
    output, errors = process2.communicate()
    
    print("管道處理結(jié)果:")
    print(output)
    
    # 保存到文件
    with open('pipeline_result.txt', 'w', encoding='utf-8') as f:
        f.write(output)
    
    print("結(jié)果已保存到 pipeline_result.txt")

pipeline_output_redirection()

def logging_system_integration():
    """日志系統(tǒng)與輸出重定向集成"""
    import logging
    from logging.handlers import RotatingFileHandler
    
    # 配置日志系統(tǒng)
    logger = logging.getLogger('AppLogger')
    logger.setLevel(logging.DEBUG)
    
    # 文件處理器
    file_handler = RotatingFileHandler(
        'app.log',
        maxBytes=1024 * 1024,  # 1MB
        backupCount=5,
        encoding='utf-8'
    )
    file_handler.setLevel(logging.DEBUG)
    
    # 控制臺(tái)處理器
    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.INFO)
    
    # 格式化
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(formatter)
    console_handler.setFormatter(formatter)
    
    # 添加處理器
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)
    
    # 使用日志系統(tǒng)
    logger.debug("調(diào)試信息")
    logger.info("一般信息")
    logger.warning("警告信息")
    logger.error("錯(cuò)誤信息")
    logger.critical("嚴(yán)重錯(cuò)誤")
    
    print("日志記錄完成")
    
    # 查看日志文件內(nèi)容
    print("\n日志文件內(nèi)容:")
    with open('app.log', 'r', encoding='utf-8') as f:
        for line in f:
            print(line.strip())

logging_system_integration()

def multithreaded_output_redirection():
    """多線程環(huán)境下的輸出重定向"""
    import threading
    import time
    from concurrent.futures import ThreadPoolExecutor
    
    class ThreadSafeOutput:
        """線程安全的輸出重定向"""
        def __init__(self, output):
            self.output = output
            self.lock = threading.Lock()
        
        def write(self, message):
            with self.lock:
                self.output.write(message)
        
        def flush(self):
            with self.lock:
                if hasattr(self.output, 'flush'):
                    self.output.flush()
    
    def worker(thread_id, output):
        """工作線程函數(shù)"""
        for i in range(5):
            message = f"線程 {thread_id} - 消息 {i+1}\n"
            output.write(message)
            time.sleep(0.1)
    
    # 創(chuàng)建線程安全輸出
    with open('thread_output.txt', 'w', encoding='utf-8') as f:
        thread_safe_output = ThreadSafeOutput(f)
        
        # 使用線程池
        with ThreadPoolExecutor(max_workers=3) as executor:
            futures = []
            for i in range(3):
                future = executor.submit(worker, i, thread_safe_output)
                futures.append(future)
            
            # 等待所有任務(wù)完成
            for future in futures:
                future.result()
    
    print("多線程輸出完成")
    print("輸出文件內(nèi)容:")
    with open('thread_output.txt', 'r', encoding='utf-8') as f:
        print(f.read())

multithreaded_output_redirection()

def performance_optimization():
    """輸出重定向性能優(yōu)化"""
    import time
    import io
    
    # 測試不同輸出方法的性能
    test_data = [f"測試行 {i}\n" for i in range(10000)]
    
    # 方法1: 直接文件寫入
    start_time = time.time()
    with open('direct_write.txt', 'w', encoding='utf-8') as f:
        for line in test_data:
            f.write(line)
    direct_time = time.time() - start_time
    
    # 方法2: 字符串IO緩沖
    start_time = time.time()
    buffer = io.StringIO()
    for line in test_data:
        buffer.write(line)
    with open('buffered_write.txt', 'w', encoding='utf-8') as f:
        f.write(buffer.getvalue())
    buffered_time = time.time() - start_time
    
    # 方法3: 批量寫入
    start_time = time.time()
    with open('batch_write.txt', 'w', encoding='utf-8') as f:
        batch_size = 1000
        for i in range(0, len(test_data), batch_size):
            batch = ''.join(test_data[i:i+batch_size])
            f.write(batch)
    batch_time = time.time() - start_time
    
    print("性能測試結(jié)果:")
    print(f"直接寫入: {direct_time:.4f}秒")
    print(f"緩沖寫入: {buffered_time:.4f}秒")
    print(f"批量寫入: {batch_time:.4f}秒")
    print(f"批量比直接快: {(direct_time/batch_time):.2f}倍")

performance_optimization()

def error_handling_recovery():
    """輸出重定向錯(cuò)誤處理與恢復(fù)"""
    class SafeOutputRedirect:
        """安全的輸出重定向"""
        def __init__(self, filename):
            self.filename = filename
            self.original_stdout = None
            self.file = None
        
        def __enter__(self):
            try:
                self.original_stdout = sys.stdout
                self.file = open(self.filename, 'w', encoding='utf-8')
                sys.stdout = self.file
                return self
            except Exception as e:
                print(f"重定向失敗: {e}")
                if self.original_stdout:
                    sys.stdout = self.original_stdout
                raise
        
        def __exit__(self, exc_type, exc_val, exc_tb):
            if self.original_stdout:
                sys.stdout = self.original_stdout
            if self.file:
                try:
                    self.file.close()
                except Exception as e:
                    print(f"文件關(guān)閉錯(cuò)誤: {e}")
            
            if exc_type:
                print(f"操作過程中發(fā)生錯(cuò)誤: {exc_val}")
            
            return False  # 不抑制異常
    
    # 使用示例
    try:
        with SafeOutputRedirect('safe_output.txt'):
            print("安全重定向測試")
            print("多條消息")
            # 模擬錯(cuò)誤
            # raise ValueError("測試錯(cuò)誤")
            print("正常結(jié)束")
    
    except Exception as e:
        print(f"捕獲到異常: {e}")
    
    finally:
        print("回到控制臺(tái)輸出")
    
    # 驗(yàn)證文件內(nèi)容
    try:
        with open('safe_output.txt', 'r', encoding='utf-8') as f:
            content = f.read()
            print("文件內(nèi)容:")
            print(content)
    except FileNotFoundError:
        print("文件不存在")

error_handling_recovery()

def professional_output_redirect(output_file, error_file=None, buffer_size=8192):
    """
    專業(yè)輸出重定向模板
    
    參數(shù):
        output_file: 輸出文件路徑
        error_file: 錯(cuò)誤文件路徑（可選）
        buffer_size: 緩沖區(qū)大小
    """
    import sys
    from threading import Lock
    
    class ProfessionalRedirect:
        def __init__(self):
            self.output_handle = open(output_file, 'w', encoding='utf-8')
            self.error_handle = open(error_file, 'w', encoding='utf-8') if error_file else None
            self.buffer_size = buffer_size
            self.stdout_buffer = []
            self.stderr_buffer = []
            self.stdout_lock = Lock()
            self.stderr_lock = Lock()
            self.original_stdout = sys.stdout
            self.original_stderr = sys.stderr
        
        def write_stdout(self, message):
            with self.stdout_lock:
                self.stdout_buffer.append(message)
                if sum(len(m) for m in self.stdout_buffer) >= self.buffer_size:
                    self.flush_stdout()
        
        def write_stderr(self, message):
            with self.stderr_lock:
                self.stderr_buffer.append(message)
                if sum(len(m) for m in self.stderr_buffer) >= self.buffer_size:
                    self.flush_stderr()
        
        def flush_stdout(self):
            if self.stdout_buffer:
                content = ''.join(self.stdout_buffer)
                self.output_handle.write(content)
                self.output_handle.flush()
                self.stdout_buffer = []
        
        def flush_stderr(self):
            if self.stderr_buffer and self.error_handle:
                content = ''.join(self.stderr_buffer)
                self.error_handle.write(content)
                self.error_handle.flush()
                self.stderr_buffer = []
        
        def close(self):
            self.flush_stdout()
            self.flush_stderr()
            self.output_handle.close()
            if self.error_handle:
                self.error_handle.close()
            sys.stdout = self.original_stdout
            sys.stderr = self.original_stderr
    
    return ProfessionalRedirect()

# 使用示例
redirector = professional_output_redirect('output.log', 'error.log', 4096)
sys.stdout = redirector.write_stdout
sys.stderr = redirector.write_stderr

try:
    # 業(yè)務(wù)邏輯
    print("業(yè)務(wù)輸出")
    print("更多內(nèi)容")
    
finally:
    redirector.close()