# 字節(jié)碼基礎(chǔ)概念演示
import dis
import types
from opcode import opname, opmap

class BytecodeFundamentals:
    """字節(jié)碼基礎(chǔ)概念演示類"""
    
    def explain_bytecode_concept(self):
        """解釋字節(jié)碼的基本概念"""
        concepts = {
            "字節(jié)碼定義": "Python源代碼編譯后的中間表示形式",
            "文件擴(kuò)展名": ".pyc (編譯后的Python文件)",
            "執(zhí)行環(huán)境": "Python虛擬機(jī)(PVM)",
            "指令特點(diǎn)": "基于棧的操作、平臺無關(guān)、比源代碼更接近機(jī)器碼",
            "查看工具": "dis模塊(反匯編器)"
        }
        
        print("Python字節(jié)碼核心概念:")
        for concept, description in concepts.items():
            print(f"  ? {concept}: {description}")
        
        return concepts
    
    def demonstrate_compilation_process(self):
        """演示編譯過程"""
        print("\n=== Python代碼編譯過程 ===")
        
        # 源代碼
        source_code = """
def calculate(x, y):
    result = x + y * 2
    return result
"""
        print("1. 源代碼:")
        print(source_code)
        
        # 編譯為字節(jié)碼
        code_obj = compile(source_code, '<string>', 'exec')
        print("2. 編譯為代碼對象")
        
        # 提取函數(shù)的代碼對象
        for const in code_obj.co_consts:
            if isinstance(const, types.CodeType):
                func_code = const
                break
        
        print("3. 代碼對象信息:")
        print(f"   函數(shù)名: {func_code.co_name}")
        print(f"   參數(shù)數(shù)量: {func_code.co_argcount}")
        print(f"   局部變量: {func_code.co_varnames}")
        print(f"   常量: {func_code.co_consts}")
        
        print("4. 字節(jié)碼指令:")
        dis.dis(func_code)

# 字節(jié)碼指令集概述
class BytecodeInstructionSet:
    """字節(jié)碼指令集分析"""
    
    @staticmethod
    def show_instruction_categories():
        """顯示指令分類"""
        print("\n=== 字節(jié)碼指令分類 ===")
        
        categories = {
            "棧操作指令": [
                "LOAD_FAST", "LOAD_CONST", "LOAD_GLOBAL",
                "STORE_FAST", "POP_TOP", "DUP_TOP"
            ],
            "算術(shù)運(yùn)算指令": [
                "BINARY_ADD", "BINARY_SUBTRACT", "BINARY_MULTIPLY",
                "BINARY_TRUE_DIVIDE", "INPLACE_ADD"
            ],
            "比較運(yùn)算指令": [
                "COMPARE_OP", "IS_OP", "CONTAINS_OP"
            ],
            "控制流指令": [
                "JUMP_FORWARD", "JUMP_ABSOLUTE", 
                "POP_JUMP_IF_FALSE", "POP_JUMP_IF_TRUE"
            ],
            "函數(shù)調(diào)用指令": [
                "CALL_FUNCTION", "CALL_METHOD", 
                "RETURN_VALUE", "YIELD_VALUE"
            ],
            "容器操作指令": [
                "BUILD_LIST", "BUILD_TUPLE", 
                "BUILD_MAP", "BUILD_SET"
            ]
        }
        
        for category, instructions in categories.items():
            print(f"\n{category}:")
            for instr in instructions:
                if instr in opmap:
                    opcode = opmap[instr]
                    print(f"  {instr:<20} (操作碼: {opcode:3d})")

def demo_fundamentals():
    """演示字節(jié)碼基礎(chǔ)"""
    fundamentals = BytecodeFundamentals()
    fundamentals.explain_bytecode_concept()
    fundamentals.demonstrate_compilation_process()
    
    BytecodeInstructionSet.show_instruction_categories()

if __name__ == "__main__":
    demo_fundamentals()

# dis模塊深度探索
import dis
import sys
from types import CodeType, FunctionType

class DisModuleExplorer:
    """dis模塊功能探索器"""
    
    def demonstrate_basic_disassembly(self):
        """演示基本反匯編功能"""
        print("=== 基本反匯編功能 ===")
        
        # 簡單的函數(shù)定義
        def simple_function(a, b):
            c = a + b
            return c * 2
        
        print("源代碼:")
        print("  def simple_function(a, b):")
        print("      c = a + b")
        print("      return c * 2")
        
        print("\n反匯編結(jié)果:")
        dis.dis(simple_function)
    
    def analyze_code_object(self):
        """分析代碼對象結(jié)構(gòu)"""
        print("\n=== 代碼對象結(jié)構(gòu)分析 ===")
        
        def sample_function(x, y=10):
            z = x + y
            for i in range(3):
                z += i
            return z
        
        # 獲取代碼對象
        code_obj = sample_function.__code__
        
        print("代碼對象屬性:")
        attributes = [
            ('co_name', '函數(shù)名'),
            ('co_argcount', '參數(shù)數(shù)量'),
            ('co_nlocals', '局部變量數(shù)量'),
            ('co_stacksize', '棧大小'),
            ('co_flags', '標(biāo)志位'),
            ('co_code', '字節(jié)碼序列'),
            ('co_consts', '常量元組'),
            ('co_names', '名稱元組'),
            ('co_varnames', '變量名元組'),
            ('co_filename', '文件名'),
            ('co_firstlineno', '第一行號'),
            ('co_lnotab', '行號表'),
            ('co_freevars', '自由變量'),
            ('co_cellvars', '單元格變量')
        ]
        
        for attr, description in attributes:
            if hasattr(code_obj, attr):
                value = getattr(code_obj, attr)
                print(f"  {attr:<15} {description}: {value}")
    
    def demonstrate_advanced_dis_features(self):
        """演示高級dis功能"""
        print("\n=== 高級dis功能 ===")
        
        def complex_function(data):
            result = []
            for item in data:
                if item % 2 == 0:
                    result.append(item ** 2)
                else:
                    result.append(item * 3)
            return sum(result)
        
        # 1. 顯示字節(jié)碼指令
        print("1. 標(biāo)準(zhǔn)反匯編:")
        dis.dis(complex_function)
        
        # 2. 獲取指令列表
        print("\n2. 指令列表:")
        instructions = dis.get_instructions(complex_function)
        for instr in instructions:
            print(f"   {instr.opname:<20} {instr.arg:>4} {instr.argval}")
        
        # 3. 顯示堆棧效果
        print("\n3. 堆棧效果分析:")
        self._show_stack_effect(complex_function)
    
    def _show_stack_effect(self, func):
        """顯示指令的堆棧效果"""
        code_obj = func.__code__
        bytecode = code_obj.co_code
        
        print(f"函數(shù): {func.__name__}, 所需棧大小: {code_obj.co_stacksize}")
        
        # 簡化的堆棧效果分析
        stack_effect = {
            'LOAD_FAST': 1,      # 推入一個值
            'LOAD_CONST': 1,     # 推入一個值  
            'STORE_FAST': -1,    # 彈出一個值
            'BINARY_ADD': -1,    # 彈出兩個值，推入一個值
            'RETURN_VALUE': -1,  # 彈出一個值
        }
        
        instructions = list(dis.get_instructions(func))
        current_stack = 0
        max_stack = 0
        
        print("  指令執(zhí)行過程中的堆棧變化:")
        for instr in instructions:
            effect = stack_effect.get(instr.opname, 0)
            current_stack += effect
            max_stack = max(max_stack, current_stack)
            
            print(f"    {instr.opname:<20} 堆棧效果: {effect:>+2}, 當(dāng)前堆棧: {current_stack:>2}")
        
        print(f"  最大堆棧深度: {max_stack}")

# 字節(jié)碼可視化工具
class BytecodeVisualizer:
    """字節(jié)碼可視化工具"""
    
    @staticmethod
    def show_bytecode_hex(code_obj):
        """顯示字節(jié)碼的十六進(jìn)制表示"""
        print("\n=== 字節(jié)碼十六進(jìn)制表示 ===")
        
        bytecode = code_obj.co_code
        print(f"字節(jié)碼長度: {len(bytecode)} 字節(jié)")
        print("十六進(jìn)制:", bytecode.hex())
        
        # 解析字節(jié)碼序列
        print("\n字節(jié)碼解析:")
        i = 0
        while i < len(bytecode):
            opcode = bytecode[i]
            opname_str = opname[opcode] if opcode < len(opname) else f"UNKNOWN({opcode})"
            
            if opcode >= dis.HAVE_ARGUMENT:
                arg = bytecode[i+1] + (bytecode[i+2] << 8)
                print(f"  偏移 {i:3d}: {opname_str:<20} 參數(shù): {arg:5d}")
                i += 3
            else:
                print(f"  偏移 {i:3d}: {opname_str:<20}")
                i += 1

def demo_dis_module():
    """演示dis模塊功能"""
    explorer = DisModuleExplorer()
    explorer.demonstrate_basic_disassembly()
    explorer.analyze_code_object()
    explorer.demonstrate_advanced_dis_features()
    
    # 可視化演示
    def sample_func():
        return 42
    
    visualizer = BytecodeVisualizer()
    visualizer.show_bytecode_hex(sample_func.__code__)

if __name__ == "__main__":
    demo_dis_module()

# 字節(jié)碼指令深度解析
import dis
from opcode import opmap, opname

class BytecodeInstructionAnalyzer:
    """字節(jié)碼指令深度分析器"""
    
    def analyze_common_instructions(self):
        """分析常見指令"""
        print("=== 常見字節(jié)碼指令分析 ===")
        
        instructions_analysis = {
            "LOAD_FAST": {
                "功能": "加載局部變量到棧頂",
                "參數(shù)": "局部變量索引",
                "棧效果": "+1",
                "示例": "加載函數(shù)參數(shù)或局部變量"
            },
            "LOAD_CONST": {
                "功能": "加載常量到棧頂", 
                "參數(shù)": "常量元組索引",
                "棧效果": "+1",
                "示例": "加載數(shù)字、字符串等常量"
            },
            "LOAD_GLOBAL": {
                "功能": "加載全局變量到棧頂",
                "參數(shù)": "全局名稱索引", 
                "棧效果": "+1",
                "示例": "加載全局函數(shù)或變量"
            },
            "STORE_FAST": {
                "功能": "存儲棧頂值到局部變量",
                "參數(shù)": "局部變量索引",
                "棧效果": "-1", 
                "示例": "保存計(jì)算結(jié)果到變量"
            },
            "BINARY_ADD": {
                "功能": "二進(jìn)制加法運(yùn)算",
                "參數(shù)": "無",
                "棧效果": "-1",
                "示例": "執(zhí)行 a + b 操作"
            },
            "CALL_FUNCTION": {
                "功能": "調(diào)用函數(shù)",
                "參數(shù)": "參數(shù)數(shù)量",
                "棧效果": "-(參數(shù)數(shù)量), +1",
                "示例": "調(diào)用函數(shù)或方法"
            },
            "RETURN_VALUE": {
                "功能": "從函數(shù)返回值",
                "參數(shù)": "無", 
                "棧效果": "-1",
                "示例": "函數(shù)返回語句"
            }
        }
        
        for instr, info in instructions_analysis.items():
            print(f"\n{instr}:")
            for key, value in info.items():
                print(f"  {key}: {value}")
    
    def demonstrate_instruction_sequences(self):
        """演示指令序列模式"""
        print("\n=== 常見指令序列模式 ===")
        
        # 模式1: 變量賦值
        print("1. 變量賦值模式:")
        def assignment_pattern():
            x = 10
            y = 20
            z = x + y
        
        dis.dis(assignment_pattern)
        
        # 模式2: 條件判斷
        print("\n2. 條件判斷模式:")
        def condition_pattern(a, b):
            if a > b:
                return a
            else:
                return b
        
        dis.dis(condition_pattern)
        
        # 模式3: 循環(huán)結(jié)構(gòu)
        print("\n3. 循環(huán)結(jié)構(gòu)模式:")
        def loop_pattern(n):
            total = 0
            for i in range(n):
                total += i
            return total
        
        dis.dis(loop_pattern)
    
    def show_opcode_statistics(self):
        """顯示操作碼統(tǒng)計(jì)"""
        print("\n=== 操作碼統(tǒng)計(jì) ===")
        
        def complex_example(data):
            results = []
            for item in data:
                if isinstance(item, (int, float)):
                    squared = item ** 2
                    results.append(squared)
                elif isinstance(item, str):
                    results.append(item.upper())
            return results
        
        # 統(tǒng)計(jì)指令使用頻率
        from collections import Counter
        
        instructions = list(dis.get_instructions(complex_example))
        opcode_counter = Counter(instr.opname for instr in instructions)
        
        print("指令使用頻率:")
        for opcode, count in opcode_counter.most_common():
            print(f"  {opcode:<20}: {count:>2} 次")

# 指令執(zhí)行模擬器
class InstructionSimulator:
    """字節(jié)碼指令執(zhí)行模擬器"""
    
    def __init__(self):
        self.stack = []
        self.locals = {}
        self.consts = []
        self.names = []
    
    def simulate_instructions(self, instructions):
        """模擬指令執(zhí)行"""
        print("\n=== 指令執(zhí)行模擬 ===")
        
        for instr in instructions:
            print(f"執(zhí)行: {instr.opname:<20} | 棧: {self.stack}")
            
            if instr.opname == "LOAD_CONST":
                self.stack.append(instr.argval)
            elif instr.opname == "STORE_FAST":
                self.locals[instr.argval] = self.stack.pop()
            elif instr.opname == "LOAD_FAST":
                self.stack.append(self.locals[instr.argval])
            elif instr.opname == "BINARY_ADD":
                b = self.stack.pop()
                a = self.stack.pop()
                self.stack.append(a + b)
            elif instr.opname == "RETURN_VALUE":
                result = self.stack.pop()
                print(f"返回結(jié)果: {result}")
                return result
        
        return None

def demo_instruction_analysis():
    """演示指令分析"""
    analyzer = BytecodeInstructionAnalyzer()
    analyzer.analyze_common_instructions()
    analyzer.demonstrate_instruction_sequences()
    analyzer.show_opcode_statistics()
    
    # 指令模擬演示
    print("\n" + "="*50)
    
    def simple_calculation():
        a = 5
        b = 3
        c = a + b
        return c
    
    simulator = InstructionSimulator()
    simulator.consts = simple_calculation.__code__.co_consts
    simulator.names = simple_calculation.__code__.co_names
    
    instructions = list(dis.get_instructions(simple_calculation))
    # 過濾掉設(shè)置相關(guān)的指令，只關(guān)注核心計(jì)算
    core_instructions = [instr for instr in instructions 
                        if instr.opname in ['LOAD_CONST', 'STORE_FAST', 'LOAD_FAST', 'BINARY_ADD', 'RETURN_VALUE']]
    
    simulator.simulate_instructions(core_instructions)

if __name__ == "__main__":
    demo_instruction_analysis()

# 控制結(jié)構(gòu)字節(jié)碼分析
import dis
from collections import defaultdict

class ControlStructureAnalyzer:
    """控制結(jié)構(gòu)字節(jié)碼分析器"""
    
    def analyze_conditional_statements(self):
        """分析條件語句的字節(jié)碼"""
        print("=== 條件語句字節(jié)碼分析 ===")
        
        # if-else 結(jié)構(gòu)
        def if_else_example(x):
            if x > 0:
                return "positive"
            else:
                return "non-positive"
        
        print("1. if-else 結(jié)構(gòu):")
        dis.dis(if_else_example)
        
        # if-elif-else 結(jié)構(gòu)  
        def if_elif_else_example(x):
            if x > 0:
                return "positive"
            elif x < 0:
                return "negative" 
            else:
                return "zero"
        
        print("\n2. if-elif-else 結(jié)構(gòu):")
        dis.dis(if_elif_else_example)
        
        # 條件表達(dá)式
        def conditional_expression(x):
            return "even" if x % 2 == 0 else "odd"
        
        print("\n3. 條件表達(dá)式:")
        dis.dis(conditional_expression)
    
    def analyze_loop_structures(self):
        """分析循環(huán)結(jié)構(gòu)的字節(jié)碼"""
        print("\n=== 循環(huán)結(jié)構(gòu)字節(jié)碼分析 ===")
        
        # for 循環(huán)
        def for_loop_example(items):
            total = 0
            for item in items:
                total += item
            return total
        
        print("1. for 循環(huán):")
        dis.dis(for_loop_example)
        
        # while 循環(huán)
        def while_loop_example(n):
            i = 0
            total = 0
            while i < n:
                total += i
                i += 1
            return total
        
        print("\n2. while 循環(huán):")
        dis.dis(while_loop_example)
        
        # 列表推導(dǎo)式
        def list_comprehension_example(items):
            return [x * 2 for x in items if x > 0]
        
        print("\n3. 列表推導(dǎo)式:")
        dis.dis(list_comprehension_example)
    
    def analyze_function_calls(self):
        """分析函數(shù)調(diào)用的字節(jié)碼"""
        print("\n=== 函數(shù)調(diào)用字節(jié)碼分析 ===")
        
        def helper_function(x):
            return x * 2
        
        def function_call_example(a, b):
            result1 = helper_function(a)
            result2 = helper_function(b)
            return result1 + result2
        
        print("函數(shù)調(diào)用模式:")
        dis.dis(function_call_example)
        
        # 方法調(diào)用
        def method_call_example():
            text = "hello"
            return text.upper().lower()
        
        print("\n方法調(diào)用鏈:")
        dis.dis(method_call_example)
    
    def demonstrate_bytecode_patterns(self):
        """演示字節(jié)碼模式識別"""
        print("\n=== 字節(jié)碼模式識別 ===")
        
        patterns = {
            "變量賦值": ["LOAD_CONST", "STORE_FAST"],
            "二元運(yùn)算": ["LOAD_FAST", "LOAD_FAST", "BINARY_*", "STORE_FAST"],
            "函數(shù)調(diào)用": ["LOAD_GLOBAL", "LOAD_FAST", "CALL_FUNCTION", "STORE_FAST"],
            "條件跳轉(zhuǎn)": ["LOAD_FAST", "COMPARE_OP", "POP_JUMP_IF_FALSE"],
            "循環(huán)結(jié)構(gòu)": ["SETUP_LOOP", "GET_ITER", "FOR_ITER"]
        }
        
        print("常見字節(jié)碼模式:")
        for pattern_name, instruction_sequence in patterns.items():
            print(f"  {pattern_name}: {' → '.join(instruction_sequence)}")

# 性能模式分析
class PerformancePatternAnalyzer:
    """性能模式分析器"""
    
    @staticmethod
    def compare_efficient_vs_inefficient():
        """比較高效與低效代碼的字節(jié)碼"""
        print("\n=== 高效 vs 低效代碼字節(jié)碼比較 ===")
        
        # 低效版本
        def inefficient_loop(n):
            result = []
            for i in range(n):
                result.append(i * 2)
            return result
        
        # 高效版本  
        def efficient_loop(n):
            return [i * 2 for i in range(n)]
        
        print("1. 低效循環(huán)版本:")
        dis.dis(inefficient_loop)
        
        print("\n2. 高效列表推導(dǎo)式版本:")
        dis.dis(efficient_loop)
        
        # 分析差異
        print("\n主要差異:")
        differences = [
            "列表推導(dǎo)式避免了方法調(diào)用開銷",
            "減少了局部變量的使用", 
            "更少的指令數(shù)量",
            "更好的內(nèi)存分配模式"
        ]
        
        for diff in differences:
            print(f"  ? {diff}")

def demo_control_structures():
    """演示控制結(jié)構(gòu)分析"""
    analyzer = ControlStructureAnalyzer()
    analyzer.analyze_conditional_statements()
    analyzer.analyze_loop_structures() 
    analyzer.analyze_function_calls()
    analyzer.demonstrate_bytecode_patterns()
    
    PerformancePatternAnalyzer.compare_efficient_vs_inefficient()

if __name__ == "__main__":
    demo_control_structures()

# 高級語言特性字節(jié)碼分析
import dis
import functools
from contextlib import contextmanager

class AdvancedFeatureAnalyzer:
    """高級語言特性字節(jié)碼分析器"""
    
    def analyze_decorators(self):
        """分析裝飾器的字節(jié)碼"""
        print("=== 裝飾器字節(jié)碼分析 ===")
        
        def simple_decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kwargs):
                print(f"調(diào)用函數(shù): {func.__name__}")
                return func(*args, **kwargs)
            return wrapper
        
        @simple_decorator
        def decorated_function(x):
            return x * 2
        
        print("裝飾器函數(shù):")
        dis.dis(simple_decorator)
        
        print("\n被裝飾的函數(shù):")
        dis.dis(decorated_function)
        
        # 顯示裝飾器應(yīng)用過程
        print("\n裝飾器應(yīng)用等價代碼:")
        def equivalent_code():
            def original_function(x):
                return x * 2
            
            # 手動應(yīng)用裝飾器
            decorated = simple_decorator(original_function)
            return decorated
        
        dis.dis(equivalent_code)
    
    def analyze_generators(self):
        """分析生成器的字節(jié)碼"""
        print("\n=== 生成器字節(jié)碼分析 ===")
        
        def simple_generator(n):
            for i in range(n):
                yield i * 2
        
        def equivalent_loop(n):
            result = []
            for i in range(n):
                result.append(i * 2)
            return result
        
        print("1. 生成器函數(shù):")
        dis.dis(simple_generator)
        
        print("\n2. 等效循環(huán)函數(shù):")
        dis.dis(equivalent_loop)
        
        # 分析生成器特性
        gen_code = simple_generator.__code__
        print(f"\n生成器特性:")
        print(f"  協(xié)程標(biāo)志: {gen_code.co_flags & 0x100 != 0}")
        print(f"  生成器標(biāo)志: {gen_code.co_flags & 0x20 != 0}")
        print(f"  包含 YIELD_VALUE 指令: {'YIELD_VALUE' in [instr.opname for instr in dis.get_instructions(simple_generator)]}")
    
    def analyze_context_managers(self):
        """分析上下文管理器的字節(jié)碼"""
        print("\n=== 上下文管理器字節(jié)碼分析 ===")
        
        @contextmanager
        def simple_context():
            print("進(jìn)入上下文")
            try:
                yield "resource"
            finally:
                print("退出上下文")
        
        def use_context_manager():
            with simple_context() as resource:
                print(f"使用資源: {resource}")
                return resource.upper()
        
        print("上下文管理器使用:")
        dis.dis(use_context_manager)
        
        # 顯示等效的try-finally結(jié)構(gòu)
        print("\n等效的try-finally結(jié)構(gòu):")
        def equivalent_try_finally():
            manager = simple_context()
            resource = manager.__enter__()
            try:
                print(f"使用資源: {resource}")
                result = resource.upper()
            finally:
                manager.__exit__(None, None, None)
            return result
        
        dis.dis(equivalent_try_finally)
    
    def analyze_class_definitions(self):
        """分析類定義的字節(jié)碼"""
        print("\n=== 類定義字節(jié)碼分析 ===")
        
        class SimpleClass:
            class_attribute = "class_value"
            
            def __init__(self, value):
                self.instance_attribute = value
            
            def method(self):
                return self.instance_attribute * 2
        
        print("類定義字節(jié)碼:")
        dis.dis(SimpleClass)
        
        # 分析方法調(diào)用
        print("\n實(shí)例方法調(diào)用:")
        def method_call_demo():
            obj = SimpleClass("test")
            return obj.method()
        
        dis.dis(method_call_demo)

# 字節(jié)碼優(yōu)化分析
class BytecodeOptimizationAnalyzer:
    """字節(jié)碼優(yōu)化分析器"""
    
    @staticmethod
    def demonstrate_constant_folding():
        """演示常量折疊優(yōu)化"""
        print("\n=== 常量折疊優(yōu)化 ===")
        
        # 常量表達(dá)式會在編譯時計(jì)算
        def with_constant_folding():
            return 10 + 20 * 3  # 編譯時計(jì)算為70
        
        def without_constant_folding(a, b, c):
            return a + b * c  # 運(yùn)行時計(jì)算
        
        print("1. 常量折疊優(yōu)化:")
        dis.dis(with_constant_folding)
        
        print("\n2. 無常量折疊:")
        dis.dis(without_constant_folding)
        
        print(f"\n常量折疊結(jié)果: {with_constant_folding()}")
    
    @staticmethod
    def demonstrate_peephole_optimizations():
        """演示窺孔優(yōu)化"""
        print("\n=== 窺孔優(yōu)化 ===")
        
        # 元組代替列表
        def tuple_vs_list():
            # 這些會在編譯時優(yōu)化
            a = [1, 2, 3]  # 可能被優(yōu)化為元組
            b = (1, 2, 3)
            return a, b
        
        print("元組/列表優(yōu)化:")
        dis.dis(tuple_vs_list)
        
        # 字符串連接優(yōu)化
        def string_optimization():
            # 字符串連接優(yōu)化
            return "hello" + " " + "world"  # 編譯時連接
        
        print("\n字符串連接優(yōu)化:")
        dis.dis(string_optimization)

def demo_advanced_features():
    """演示高級特性分析"""
    analyzer = AdvancedFeatureAnalyzer()
    analyzer.analyze_decorators()
    analyzer.analyze_generators()
    analyzer.analyze_context_managers()
    analyzer.analyze_class_definitions()
    
    BytecodeOptimizationAnalyzer.demonstrate_constant_folding()
    BytecodeOptimizationAnalyzer.demonstrate_peephole_optimizations()

if __name__ == "__main__":
    demo_advanced_features()

# 字節(jié)碼性能分析與優(yōu)化
import dis
import timeit
from collections import Counter

class BytecodePerformanceAnalyzer:
    """字節(jié)碼性能分析器"""
    
    def __init__(self):
        self.performance_data = {}
    
    def analyze_instruction_costs(self):
        """分析指令執(zhí)行成本"""
        print("=== 指令執(zhí)行成本分析 ===")
        
        # 基于經(jīng)驗(yàn)的指令相對成本
        instruction_costs = {
            "LOAD_FAST": 1.0,      # 快速局部變量訪問
            "LOAD_CONST": 1.0,     # 快速常量訪問
            "LOAD_GLOBAL": 3.0,    # 較慢的全局變量訪問
            "STORE_FAST": 1.0,     # 快速局部變量存儲
            "BINARY_ADD": 2.0,     # 算術(shù)運(yùn)算
            "CALL_FUNCTION": 10.0, # 函數(shù)調(diào)用開銷
            "IMPORT_NAME": 50.0,   # 導(dǎo)入操作很昂貴
            "BUILD_LIST": 5.0,     # 容器構(gòu)建
            "FOR_ITER": 3.0,       # 迭代開銷
        }
        
        print("指令相對執(zhí)行成本:")
        for instr, cost in sorted(instruction_costs.items(), key=lambda x: x[1], reverse=True):
            print(f"  {instr:<20}: {cost:>5.1f}")
    
    def compare_performance_patterns(self):
        """比較性能模式"""
        print("\n=== 性能模式比較 ===")
        
        # 模式1: 局部變量 vs 全局變量
        global_var = 100
        
        def use_global():
            return global_var * 2  # 使用全局變量
        
        def use_local():
            local_var = 100
            return local_var * 2   # 使用局部變量
        
        print("1. 全局變量 vs 局部變量:")
        print("   全局變量版本:")
        dis.dis(use_global)
        print("   局部變量版本:")  
        dis.dis(use_local)
        
        # 性能測試
        global_time = timeit.timeit(use_global, number=100000)
        local_time = timeit.timeit(use_local, number=100000)
        
        print(f"   性能比較: 全局={global_time:.4f}s, 局部={local_time:.4f}s")
        print(f"   局部變量快 {global_time/local_time:.1f}x")
        
        # 模式2: 函數(shù)調(diào)用開銷
        def small_function(x):
            return x + 1
        
        def with_function_calls(n):
            total = 0
            for i in range(n):
                total += small_function(i)  # 頻繁函數(shù)調(diào)用
            return total
        
        def without_function_calls(n):
            total = 0
            for i in range(n):
                total += i + 1  # 內(nèi)聯(lián)操作
            return total
        
        print("\n2. 函數(shù)調(diào)用開銷:")
        n = 1000
        with_calls_time = timeit.timeit(lambda: with_function_calls(n), number=1000)
        without_calls_time = timeit.timeit(lambda: without_function_calls(n), number=1000)
        
        print(f"   性能比較: 有調(diào)用={with_calls_time:.4f}s, 無調(diào)用={without_calls_time:.4f}s")
        print(f"   內(nèi)聯(lián)操作快 {with_calls_time/without_calls_time:.1f}x")
    
    def profile_function_bytecode(self, func, *args):
        """分析函數(shù)的字節(jié)碼性能特征"""
        print(f"\n=== 函數(shù)字節(jié)碼性能分析: {func.__name__} ===")
        
        # 分析指令分布
        instructions = list(dis.get_instructions(func))
        opcode_distribution = Counter(instr.opname for instr in instructions)
        
        print("指令分布:")
        total_instructions = len(instructions)
        for opcode, count in opcode_distribution.most_common():
            percentage = count / total_instructions * 100
            print(f"  {opcode:<20}: {count:>3} ({percentage:5.1f}%)")
        
        # 識別性能敏感指令
        expensive_ops = ['CALL_FUNCTION', 'CALL_METHOD', 'LOAD_GLOBAL', 'IMPORT_NAME', 'BUILD_LIST']
        expensive_count = sum(opcode_distribution.get(op, 0) for op in expensive_ops)
        
        print(f"\n性能分析:")
        print(f"  總指令數(shù): {total_instructions}")
        print(f"  昂貴指令數(shù): {expensive_count}")
        print(f"  昂貴指令比例: {expensive_count/total_instructions*100:.1f}%")
        
        if expensive_count / total_instructions > 0.3:
            print("  ??  警告: 高比例昂貴指令，可能存在性能問題")
        else:
            print("  ? 指令分布良好")
        
        return opcode_distribution

# 實(shí)時性能監(jiān)控
class RuntimePerformanceMonitor:
    """運(yùn)行時性能監(jiān)控器"""
    
    @staticmethod
    def monitor_bytecode_execution(func, *args, **kwargs):
        """監(jiān)控字節(jié)碼執(zhí)行性能"""
        import cProfile
        import pstats
        import io
        
        print(f"\n=== 運(yùn)行時性能監(jiān)控: {func.__name__} ===")
        
        # 使用cProfile進(jìn)行分析
        pr = cProfile.Profile()
        pr.enable()
        
        result = func(*args, **kwargs)
        
        pr.disable()
        s = io.StringIO()
        ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
        ps.print_stats(10)  # 顯示前10個最耗時的函數(shù)
        
        print(s.getvalue())
        return result
    
    @staticmethod
    def analyze_memory_usage_pattern():
        """分析內(nèi)存使用模式"""
        print("\n=== 內(nèi)存使用模式分析 ===")
        
        def memory_intensive():
            # 創(chuàng)建大量臨時對象
            result = []
            for i in range(1000):
                # 每次迭代創(chuàng)建新列表
                temp_list = [j for j in range(i % 100)]
                result.append(temp_list)
            return result
        
        def memory_efficient():
            # 更高效的內(nèi)存使用
            result = []
            for i in range(1000):
                # 重用模式或使用生成器
                result.append(i % 100)
            return result
        
        print("內(nèi)存密集型模式:")
        dis.dis(memory_intensive)
        
        print("\n內(nèi)存高效模式:")
        dis.dis(memory_efficient)

def demo_performance_analysis():
    """演示性能分析"""
    analyzer = BytecodePerformanceAnalyzer()
    analyzer.analyze_instruction_costs()
    analyzer.compare_performance_patterns()
    
    # 分析具體函數(shù)
    def sample_function(data):
        results = []
        for item in data:
            if item > 0:
                results.append(item ** 2)
        return sum(results)
    
    analyzer.profile_function_bytecode(sample_function)
    
    # 運(yùn)行時監(jiān)控
    RuntimePerformanceMonitor.analyze_memory_usage_pattern()

if __name__ == "__main__":
    demo_performance_analysis()

# 高級字節(jié)碼技巧：動態(tài)代碼操作
import dis
import types
import inspect
from opcode import opmap, opname

class DynamicBytecodeManipulator:
    """動態(tài)字節(jié)碼操作器"""
    
    def demonstrate_code_object_creation(self):
        """演示代碼對象創(chuàng)建"""
        print("=== 動態(tài)創(chuàng)建代碼對象 ===")
        
        # 手動創(chuàng)建簡單的代碼對象
        try:
            # 字節(jié)碼序列 (簡化版本)
            # LOAD_CONST 0 (42)
            # RETURN_VALUE
            bytecode = bytes([
                opmap['LOAD_CONST'], 0, 0,  # 加載常量0
                opmap['RETURN_VALUE']       # 返回值
            ])
            
            # 創(chuàng)建代碼對象
            code_obj = types.CodeType(
                0,                          # 參數(shù)數(shù)量
                0,                          # 位置參數(shù)數(shù)量  
                0,                          # 關(guān)鍵字參數(shù)數(shù)量
                1,                          # 局部變量數(shù)量
                64,                         # 棧大小
                67,                         # 標(biāo)志位
                bytecode,                   # 字節(jié)碼
                (42,),                      # 常量 (42)
                (),                         # 名稱
                (),                         # 變量名
                '<dynamic>',                # 文件名
                'dynamic_func',             # 函數(shù)名
                1,                          # 第一行號
                b''                         # 行號表
            )
            
            # 創(chuàng)建函數(shù)對象
            dynamic_func = types.FunctionType(code_obj, {})
            
            print("動態(tài)創(chuàng)建的函數(shù):")
            result = dynamic_func()
            print(f"執(zhí)行結(jié)果: {result}")
            
            print("\n字節(jié)碼:")
            dis.dis(dynamic_func)
            
        except Exception as e:
            print(f"動態(tài)創(chuàng)建失敗: {e}")
    
    def demonstrate_bytecode_patching(self):
        """演示字節(jié)碼修補(bǔ)"""
        print("\n=== 字節(jié)碼修補(bǔ) ===")
        
        def original_function(x):
            return x * 2
        
        print("原始函數(shù):")
        dis.dis(original_function)
        print(f"原始執(zhí)行: original_function(5) = {original_function(5)}")
        
        # 修補(bǔ)字節(jié)碼：將乘法改為加法
        try:
            original_code = original_function.__code__
            original_bytecode = bytearray(original_code.co_code)
            
            # 查找 BINARY_MULTIPLY 指令并替換為 BINARY_ADD
            for i in range(0, len(original_bytecode), 2):
                if original_bytecode[i] == opmap['BINARY_MULTIPLY']:
                    original_bytecode[i] = opmap['BINARY_ADD']
                    break
            
            # 創(chuàng)建新的代碼對象
            patched_code = types.CodeType(
                original_code.co_argcount,
                original_code.co_posonlyargcount,
                original_code.co_kwonlyargcount,
                original_code.co_nlocals,
                original_code.co_stacksize,
                original_code.co_flags,
                bytes(original_bytecode),
                original_code.co_consts,
                original_code.co_names,
                original_code.co_varnames,
                original_code.co_filename,
                original_code.co_name + "_patched",
                original_code.co_firstlineno,
                original_code.co_lnotab
            )
            
            # 創(chuàng)建修補(bǔ)后的函數(shù)
            patched_function = types.FunctionType(
                patched_code, 
                original_function.__globals__,
                original_function.__name__ + "_patched"
            )
            
            print("\n修補(bǔ)后的函數(shù):")
            dis.dis(patched_function)
            print(f"修補(bǔ)后執(zhí)行: patched_function(5) = {patched_function(5)}")
            
        except Exception as e:
            print(f"字節(jié)碼修補(bǔ)失敗: {e}")
    
    def create_optimized_function(self, original_func):
        """創(chuàng)建優(yōu)化版本的函數(shù)"""
        print(f"\n=== 為 {original_func.__name__} 創(chuàng)建優(yōu)化版本 ===")
        
        # 分析原始函數(shù)
        original_instructions = list(dis.get_instructions(original_func))
        
        print("原始函數(shù)分析:")
        expensive_ops = ['LOAD_GLOBAL', 'CALL_FUNCTION']
        expensive_count = sum(1 for instr in original_instructions if instr.opname in expensive_ops)
        print(f"  昂貴操作數(shù)量: {expensive_count}")
        
        # 這里可以實(shí)施具體的優(yōu)化策略
        # 例如：緩存全局變量、內(nèi)聯(lián)小函數(shù)等
        
        return original_func  # 返回優(yōu)化后的函數(shù)

# 字節(jié)碼調(diào)試工具
class BytecodeDebugger:
    """字節(jié)碼調(diào)試工具"""
    
    @staticmethod
    def trace_bytecode_execution(func, *args, **kwargs):
        """跟蹤字節(jié)碼執(zhí)行"""
        print(f"\n=== 字節(jié)碼執(zhí)行跟蹤: {func.__name__} ===")
        
        old_trace = sys.gettrace()
        
        def trace_calls(frame, event, arg):
            if event == 'line' and frame.f_code == func.__code__:
                # 獲取當(dāng)前指令
                code_obj = frame.f_code
                bytecode = code_obj.co_code
                offset = frame.f_lasti
                
                if offset < len(bytecode):
                    opcode = bytecode[offset]
                    opname_str = opname[opcode] if opcode < len(opname) else f"UNKNOWN({opcode})"
                    
                    # 顯示堆棧和局部變量
                    stack_size = len(frame.f_stack) if hasattr(frame, 'f_stack') else 0
                    locals_str = {k: v for k, v in frame.f_locals.items() if not k.startswith('_')}
                    
                    print(f"  行 {frame.f_lineno:3d} | 指令 {offset:3d}: {opname_str:<20} | "
                          f"棧大小: {stack_size:2d} | 局部變量: {locals_str}")
            
            return trace_calls
        
        sys.settrace(trace_calls)
        try:
            result = func(*args, **kwargs)
            return result
        finally:
            sys.settrace(old_trace)

def demo_advanced_techniques():
    """演示高級技巧"""
    manipulator = DynamicBytecodeManipulator()
    manipulator.demonstrate_code_object_creation()
    manipulator.demonstrate_bytecode_patching()
    
    # 優(yōu)化示例函數(shù)
    def sample_to_optimize(n):
        total = 0
        for i in range(n):
            # 模擬一些計(jì)算
            squared = i * i
            total += squared
        return total
    
    manipulator.create_optimized_function(sample_to_optimize)
    
    # 執(zhí)行跟蹤演示
    print("\n" + "="*60)
    
    def function_to_trace(x, y):
        a = x + y
        b = a * 2
        c = b - x
        return c
    
    BytecodeDebugger.trace_bytecode_execution(function_to_trace, 5, 3)

if __name__ == "__main__":
    demo_advanced_techniques()

"""
完整的字節(jié)碼分析工具
集成反匯編、性能分析、優(yōu)化建議等功能
"""

import dis
import timeit
import inspect
from collections import Counter, defaultdict
from typing import Dict, List, Any, Tuple
import sys

class ComprehensiveBytecodeAnalyzer:
    """綜合字節(jié)碼分析器"""
    
    def __init__(self):
        self.analysis_results = {}
        self.performance_data = {}
    
    def analyze_function(self, func, func_name: str = None) -> Dict[str, Any]:
        """全面分析函數(shù)"""
        if func_name is None:
            func_name = func.__name__
        
        print(f"\n{'='*60}")
        print(f"綜合分析: {func_name}")
        print(f"{'='*60}")
        
        analysis = {
            'function_name': func_name,
            'code_object': func.__code__,
            'basic_info': self._get_basic_info(func),
            'instruction_analysis': self._analyze_instructions(func),
            'performance_characteristics': self._analyze_performance(func),
            'optimization_suggestions': self._generate_optimization_suggestions(func)
        }
        
        self.analysis_results[func_name] = analysis
        self._print_analysis_report(analysis)
        
        return analysis
    
    def _get_basic_info(self, func) -> Dict[str, Any]:
        """獲取基本信息"""
        code_obj = func.__code__
        
        return {
            'filename': code_obj.co_filename,
            'first_lineno': code_obj.co_firstlineno,
            'arg_count': code_obj.co_argcount,
            'local_count': code_obj.co_nlocals,
            'stack_size': code_obj.co_stacksize,
            'flags': code_obj.co_flags,
            'constants': code_obj.co_consts,
            'names': code_obj.co_names,
            'variables': code_obj.co_varnames
        }
    
    def _analyze_instructions(self, func) -> Dict[str, Any]:
        """分析指令"""
        instructions = list(dis.get_instructions(func))
        opcode_distribution = Counter(instr.opname for instr in instructions)
        
        # 指令分類
        categories = {
            'load_operations': ['LOAD_FAST', 'LOAD_CONST', 'LOAD_GLOBAL', 'LOAD_NAME'],
            'store_operations': ['STORE_FAST', 'STORE_NAME', 'STORE_GLOBAL'],
            'arithmetic_operations': ['BINARY_ADD', 'BINARY_SUBTRACT', 'BINARY_MULTIPLY', 'BINARY_TRUE_DIVIDE'],
            'control_flow': ['JUMP_FORWARD', 'JUMP_ABSOLUTE', 'POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE'],
            'function_calls': ['CALL_FUNCTION', 'CALL_METHOD'],
            'expensive_operations': ['CALL_FUNCTION', 'CALL_METHOD', 'LOAD_GLOBAL', 'IMPORT_NAME', 'BUILD_LIST', 'BUILD_MAP']
        }
        
        category_counts = {}
        for category, ops in categories.items():
            category_counts[category] = sum(opcode_distribution.get(op, 0) for op in ops)
        
        return {
            'total_instructions': len(instructions),
            'opcode_distribution': dict(opcode_distribution),
            'category_counts': category_counts,
            'expensive_ops_ratio': category_counts['expensive_operations'] / len(instructions) if instructions else 0
        }
    
    def _analyze_performance(self, func) -> Dict[str, Any]:
        """分析性能特征"""
        # 簡單的性能測試
        try:
            # 準(zhǔn)備測試參數(shù)
            test_args = self._generate_test_arguments(func)
            
            # 執(zhí)行時間測試
            timer = timeit.Timer(lambda: func(*test_args))
            execution_time = timer.timeit(number=1000) / 1000  # 平均執(zhí)行時間
            
            return {
                'estimated_execution_time': execution_time,
                'performance_rating': self._rate_performance(execution_time),
                'memory_usage_hint': self._estimate_memory_usage(func)
            }
        except:
            return {
                'estimated_execution_time': None,
                'performance_rating': '未知',
                'memory_usage_hint': '無法估計(jì)'
            }
    
    def _generate_test_arguments(self, func):
        """生成測試參數(shù)"""
        # 簡化的參數(shù)生成邏輯
        sig = inspect.signature(func)
        test_args = []
        
        for param in sig.parameters.values():
            if param.annotation in (int, float):
                test_args.append(42)
            elif param.annotation == str:
                test_args.append("test")
            elif param.annotation == list:
                test_args.append([1, 2, 3])
            else:
                test_args.append(None)
        
        return test_args
    
    def _rate_performance(self, execution_time: float) -> str:
        """評估性能等級"""
        if execution_time < 0.0001:
            return "優(yōu)秀"
        elif execution_time < 0.001:
            return "良好" 
        elif execution_time < 0.01:
            return "一般"
        else:
            return "需要優(yōu)化"
    
    def _estimate_memory_usage(self, func) -> str:
        """估計(jì)內(nèi)存使用"""
        code_obj = func.__code__
        
        # 基于指令類型和數(shù)量簡單估計(jì)
        instructions = list(dis.get_instructions(func))
        memory_ops = sum(1 for instr in instructions if instr.opname in ['BUILD_LIST', 'BUILD_MAP', 'BUILD_SET'])
        
        if memory_ops > 10:
            return "高內(nèi)存使用"
        elif memory_ops > 5:
            return "中等內(nèi)存使用"
        else:
            return "低內(nèi)存使用"
    
    def _generate_optimization_suggestions(self, func) -> List[str]:
        """生成優(yōu)化建議"""
        suggestions = []
        instruction_analysis = self._analyze_instructions(func)
        
        # 基于分析結(jié)果生成建議
        expensive_ratio = instruction_analysis['expensive_ops_ratio']
        if expensive_ratio > 0.3:
            suggestions.append("減少全局變量訪問和函數(shù)調(diào)用")
        
        if instruction_analysis['category_counts']['load_operations'] > 20:
            suggestions.append("考慮重用局部變量減少加載操作")
        
        if instruction_analysis['category_counts']['function_calls'] > 5:
            suggestions.append("內(nèi)聯(lián)小函數(shù)或使用方法緩存")
        
        # 基于具體指令模式的建議
        instructions = list(dis.get_instructions(func))
        instruction_sequence = [instr.opname for instr in instructions]
        
        # 檢查常見的優(yōu)化機(jī)會
        if 'LOAD_GLOBAL' in instruction_sequence and instruction_sequence.count('LOAD_GLOBAL') > 3:
            suggestions.append("緩存頻繁訪問的全局變量到局部變量")
        
        if instruction_sequence.count('BUILD_LIST') > 2:
            suggestions.append("考慮使用列表推導(dǎo)式或生成器表達(dá)式")
        
        if not suggestions:
            suggestions.append("代碼已經(jīng)相當(dāng)優(yōu)化")
        
        return suggestions
    
    def _print_analysis_report(self, analysis: Dict[str, Any]):
        """打印分析報告"""
        basic_info = analysis['basic_info']
        instr_analysis = analysis['instruction_analysis']
        performance = analysis['performance_characteristics']
        
        print("\n?? 基本信息:")
        print(f"  文件: {basic_info['filename']}")
        print(f"  行號: {basic_info['first_lineno']}")
        print(f"  參數(shù): {basic_info['arg_count']}, 局部變量: {basic_info['local_count']}")
        print(f"  棧大小: {basic_info['stack_size']}")
        
        print("\n?? 指令分析:")
        print(f"  總指令數(shù): {instr_analysis['total_instructions']}")
        print(f"  昂貴操作比例: {instr_analysis['expensive_ops_ratio']:.1%}")
        
        print("  指令分布:")
        for opcode, count in sorted(instr_analysis['opcode_distribution'].items(), 
                                  key=lambda x: x[1], reverse=True)[:10]:
            percentage = count / instr_analysis['total_instructions'] * 100
            print(f"    {opcode:<20}: {count:>3} ({percentage:5.1f}%)")
        
        print("\n? 性能特征:")
        if performance['estimated_execution_time']:
            print(f"  估計(jì)執(zhí)行時間: {performance['estimated_execution_time']:.6f}s")
        print(f"  性能評級: {performance['performance_rating']}")
        print(f"  內(nèi)存使用: {performance['memory_usage_hint']}")
        
        print("\n?? 優(yōu)化建議:")
        for i, suggestion in enumerate(analysis['optimization_suggestions'], 1):
            print(f"  {i}. {suggestion}")
        
        print("\n" + "="*60)
    
    def compare_functions(self, func1, func2, name1: str = "函數(shù)1", name2: str = "函數(shù)2"):
        """比較兩個函數(shù)"""
        print(f"\n{'='*60}")
        print(f"函數(shù)比較: {name1} vs {name2}")
        print(f"{'='*60}")
        
        analysis1 = self.analyze_function(func1, name1)
        analysis2 = self.analyze_function(func2, name2)
        
        # 比較關(guān)鍵指標(biāo)
        print("\n?? 關(guān)鍵指標(biāo)比較:")
        metrics = [
            ('總指令數(shù)', analysis1['instruction_analysis']['total_instructions'], 
             analysis2['instruction_analysis']['total_instructions']),
            ('昂貴操作比例', analysis1['instruction_analysis']['expensive_ops_ratio'],
             analysis2['instruction_analysis']['expensive_ops_ratio']),
        ]
        
        if (analysis1['performance_characteristics']['estimated_execution_time'] and 
            analysis2['performance_characteristics']['estimated_execution_time']):
            metrics.append(
                ('執(zhí)行時間', analysis1['performance_characteristics']['estimated_execution_time'],
                 analysis2['performance_characteristics']['estimated_execution_time'])
            )
        
        for metric, value1, value2 in metrics:
            if value1 is not None and value2 is not None:
                if value1 < value2:
                    winner = f"{name1} 更好"
                elif value1 > value2:
                    winner = f"{name2} 更好" 
                else:
                    winner = "平局"
                
                print(f"  {metric}: {name1}={value1}, {name2}={value2} → {winner}")

# 使用示例和演示
def demo_comprehensive_analyzer():
    """演示綜合分析器"""
    analyzer = ComprehensiveBytecodeAnalyzer()
    
    # 示例函數(shù)1: 相對高效的實(shí)現(xiàn)
    def efficient_sum(n):
        return sum(i * i for i in range(n) if i % 2 == 0)
    
    # 示例函數(shù)2: 相對低效的實(shí)現(xiàn)  
    def inefficient_sum(n):
        total = 0
        for i in range(n):
            if i % 2 == 0:
                total = total + i * i
        return total
    
    # 分析單個函數(shù)
    analyzer.analyze_function(efficient_sum, "高效求和")
    
    # 比較兩個函數(shù)
    analyzer.compare_functions(efficient_sum, inefficient_sum, "高效版本", "低效版本")
    
    # 分析更復(fù)雜的函數(shù)
    def complex_operation(data):
        results = {}
        for key, values in data.items():
            if values:
                processed = [v * 2 for v in values if v > 0]
                results[key] = sum(processed) / len(processed) if processed else 0
        return results
    
    analyzer.analyze_function(complex_operation, "復(fù)雜操作")

if __name__ == "__main__":
    demo_comprehensive_analyzer()

"""
字節(jié)碼分析最佳實(shí)踐和代碼質(zhì)量檢查
"""

import ast
import inspect
from typing import List, Dict, Any

class BytecodeBestPractices:
    """字節(jié)碼分析最佳實(shí)踐"""
    
    def __init__(self):
        self.practices = self._initialize_best_practices()
    
    def _initialize_best_practices(self) -> List[Dict[str, Any]]:
        """初始化最佳實(shí)踐"""
        return [
            {
                "category": "性能優(yōu)化",
                "practices": [
                    "優(yōu)先使用局部變量而非全局變量",
                    "避免在循環(huán)中創(chuàng)建不必要的臨時對象", 
                    "使用列表推導(dǎo)式代替顯式循環(huán)",
                    "緩存頻繁訪問的全局變量",
                    "使用生成器處理大數(shù)據(jù)集"
                ]
            },
            {
                "category": "內(nèi)存管理",
                "practices": [
                    "及時釋放不再需要的大對象",
                    "使用適當(dāng)?shù)臄?shù)據(jù)結(jié)構(gòu)減少內(nèi)存開銷",
                    "避免不必要的容器拷貝",
                    "使用__slots__減少類實(shí)例內(nèi)存占用"
                ]
            },
            {
                "category": "代碼結(jié)構(gòu)",
                "practices": [
                    "保持函數(shù)簡潔，單一職責(zé)",
                    "避免過深的嵌套結(jié)構(gòu)",
                    "使用裝飾器謹(jǐn)慎，注意性能影響",
                    "合理使用上下文管理器"
                ]
            },
            {
                "category": "字節(jié)碼分析",
                "practices": [
                    "定期使用dis模塊分析關(guān)鍵函數(shù)",
                    "關(guān)注LOAD_GLOBAL和CALL_FUNCTION指令數(shù)量",
                    "分析循環(huán)體內(nèi)的指令模式",
                    "比較不同實(shí)現(xiàn)的字節(jié)碼差異"
                ]
            }
        ]
    
    def check_function_against_practices(self, func) -> Dict[str, List[str]]:
        """檢查函數(shù)是否符合最佳實(shí)踐"""
        results = {
            "符合": [],
            "警告": [],
            "需改進(jìn)": []
        }
        
        try:
            # 獲取字節(jié)碼分析
            instructions = list(dis.get_instructions(func))
            opcode_sequence = [instr.opname for instr in instructions]
            
            # 檢查1: 全局變量使用
            global_loads = opcode_sequence.count('LOAD_GLOBAL')
            if global_loads > 5:
                results["需改進(jìn)"].append(f"頻繁使用全局變量 ({global_loads}次LOAD_GLOBAL)")
            elif global_loads > 2:
                results["警告"].append(f"較多全局變量使用 ({global_loads}次LOAD_GLOBAL)")
            else:
                results["符合"].append("全局變量使用合理")
            
            # 檢查2: 函數(shù)調(diào)用頻率
            function_calls = opcode_sequence.count('CALL_FUNCTION')
            if function_calls > 10:
                results["需改進(jìn)"].append(f"高頻率函數(shù)調(diào)用 ({function_calls}次CALL_FUNCTION)")
            elif function_calls > 5:
                results["警告"].append(f"較多函數(shù)調(diào)用 ({function_calls}次CALL_FUNCTION)")
            else:
                results["符合"].append("函數(shù)調(diào)用頻率適當(dāng)")
            
            # 檢查3: 循環(huán)結(jié)構(gòu)優(yōu)化
            if 'SETUP_LOOP' in opcode_sequence:
                loop_start = opcode_sequence.index('SETUP_LOOP')
                # 簡單檢查循環(huán)體內(nèi)的操作
                loop_ops = opcode_sequence[loop_start:loop_start+10]  # 檢查前10個指令
                expensive_in_loop = sum(1 for op in loop_ops if op in ['LOAD_GLOBAL', 'CALL_FUNCTION'])
                
                if expensive_in_loop > 3:
                    results["需改進(jìn)"].append("循環(huán)體內(nèi)包含昂貴操作")
                elif expensive_in_loop > 1:
                    results["警告"].append("循環(huán)體內(nèi)有較多昂貴操作")
                else:
                    results["符合"].append("循環(huán)結(jié)構(gòu)優(yōu)化良好")
            
            # 檢查4: 常量使用
            const_loads = opcode_sequence.count('LOAD_CONST')
            if const_loads > 20:
                results["警告"].append(f"較多常量加載 ({const_loads}次LOAD_CONST)")
            else:
                results["符合"].append("常量使用合理")
                
        except Exception as e:
            results["需改進(jìn)"].append(f"分析過程中出錯: {e}")
        
        return results
    
    def generate_practices_report(self):
        """生成最佳實(shí)踐報告"""
        print("=== Python字節(jié)碼優(yōu)化最佳實(shí)踐 ===")
        
        for category in self.practices:
            print(f"\n{category['category']}:")
            for practice in category['practices']:
                print(f"  ? {practice}")

# 代碼質(zhì)量檢查器
class CodeQualityChecker:
    """代碼質(zhì)量檢查器"""
    
    @staticmethod
    def analyze_code_quality(func) -> Dict[str, Any]:
        """分析代碼質(zhì)量"""
        print(f"\n=== 代碼質(zhì)量分析: {func.__name__} ===")
        
        quality_report = {
            "complexity": CodeQualityChecker._calculate_complexity(func),
            "efficiency": CodeQualityChecker._assess_efficiency(func),
            "maintainability": CodeQualityChecker._assess_maintainability(func),
            "bytecode_metrics": CodeQualityChecker._get_bytecode_metrics(func)
        }
        
        # 打印報告
        print(f"復(fù)雜度評分: {quality_report['complexity']}/10 (越低越好)")
        print(f"效率評分: {quality_report['efficiency']}/10 (越高越好)")
        print(f"可維護(hù)性: {quality_report['maintainability']}/10 (越高越好)")
        
        # 字節(jié)碼指標(biāo)
        metrics = quality_report['bytecode_metrics']
        print(f"字節(jié)碼指標(biāo):")
        print(f"  總指令數(shù): {metrics['total_instructions']}")
        print(f"  昂貴指令比例: {metrics['expensive_ratio']:.1%}")
        print(f"  函數(shù)調(diào)用次數(shù): {metrics['function_calls']}")
        
        return quality_report
    
    @staticmethod
    def _calculate_complexity(func) -> float:
        """計(jì)算代碼復(fù)雜度"""
        # 簡化的復(fù)雜度計(jì)算
        instructions = list(dis.get_instructions(func))
        control_flow_ops = ['JUMP_FORWARD', 'JUMP_ABSOLUTE', 'POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE']
        
        control_count = sum(1 for instr in instructions if instr.opname in control_flow_ops)
        total_instructions = len(instructions)
        
        complexity = (control_count / total_instructions * 100) if total_instructions > 0 else 0
        return min(10, complexity / 10)  # 歸一化到0-10
    
    @staticmethod
    def _assess_efficiency(func) -> float:
        """評估效率"""
        instructions = list(dis.get_instructions(func))
        expensive_ops = ['LOAD_GLOBAL', 'CALL_FUNCTION', 'BUILD_LIST', 'BUILD_MAP']
        
        expensive_count = sum(1 for instr in instructions if instr.opname in expensive_ops)
        total_instructions = len(instructions)
        
        efficiency_ratio = 1 - (expensive_count / total_instructions) if total_instructions > 0 else 1
        return efficiency_ratio * 10  # 轉(zhuǎn)換為0-10分
    
    @staticmethod
    def _assess_maintainability(func) -> float:
        """評估可維護(hù)性"""
        # 基于一些啟發(fā)式規(guī)則
        score = 10.0  # 初始分?jǐn)?shù)
        
        instructions = list(dis.get_instructions(func))
        total_instructions = len(instructions)
        
        # 指令數(shù)量懲罰
        if total_instructions > 50:
            score -= 2
        elif total_instructions > 100:
            score -= 4
        
        # 復(fù)雜控制流懲罰
        control_flow_ops = ['JUMP_FORWARD', 'JUMP_ABSOLUTE', 'POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE']
        control_count = sum(1 for instr in instructions if instr.opname in control_flow_ops)
        if control_count > 10:
            score -= 2
        
        return max(0, score)
    
    @staticmethod
    def _get_bytecode_metrics(func) -> Dict[str, Any]:
        """獲取字節(jié)碼指標(biāo)"""
        instructions = list(dis.get_instructions(func))
        opcode_sequence = [instr.opname for instr in instructions]
        
        expensive_ops = ['LOAD_GLOBAL', 'CALL_FUNCTION', 'IMPORT_NAME']
        expensive_count = sum(1 for op in opcode_sequence if op in expensive_ops)
        
        return {
            'total_instructions': len(instructions),
            'expensive_ratio': expensive_count / len(instructions) if instructions else 0,
            'function_calls': opcode_sequence.count('CALL_FUNCTION')
        }

def demonstrate_best_practices():
    """演示最佳實(shí)踐"""
    practices = BytecodeBestPractices()
    
    # 測試函數(shù)
    def sample_function(data):
        results = []
        for item in data:
            if item > 0:
                squared = item * item
                results.append(squared)
        return sum(results)
    
    # 檢查最佳實(shí)踐符合度
    print("最佳實(shí)踐符合度檢查:")
    results = practices.check_function_against_practices(sample_function)
    
    for category, items in results.items():
        print(f"\n{category}:")
        for item in items:
            print(f"  ? {item}")
    
    # 代碼質(zhì)量分析
    CodeQualityChecker.analyze_code_quality(sample_function)
    
    # 生成最佳實(shí)踐報告
    print("\n" + "="*60)
    practices.generate_practices_report()

if __name__ == "__main__":
    demonstrate_best_practices()