AI辅助的效能度量：从写得多快到改得多快

# 用户信息和订单信息混在一起
class User:
    def __init__(self):
        self.name = ""
        self.email = ""
        self.order_id = ""
        self.order_amount = 0
        self.order_status = ""

# 需求变更：用户可以有多个订单
# 需要修改User类的所有字段
# IMR = 80%

# 用户和订单分离
class User:
    def __init__(self):
        self.name = ""
        self.email = ""
        self.orders = []  # 已经是列表

class Order:
    def __init__(self):
        self.id = ""
        self.amount = 0
        self.status = ""

# 需求变更：用户可以有多个订单
# 无需修改，原本就支持
# IMR = 0%

# 知识半衰期短（需要频繁查阅文档）
def process(x, y, z):
    if z:
        return x + y
    else:
        return x - y

# 知识半衰期长（自解释）
def calculate_total_price(base_price, tax_amount, include_tax):
    """Calculate final price including or excluding tax."""
    if include_tax:
        return base_price + tax_amount
    else:
        return base_price

class RefactoringCostPredictor:
    def predict(self, code_snippet, context):
        features = {
            'coupling_score': self.analyze_coupling(code_snippet),
            'complexity_score': self.calculate_complexity(code_snippet),
            'test_coverage': self.check_test_coverage(code_snippet),
            'documentation_score': self.analyze_documentation(code_snippet),
            'team_familiarity': self.analyze_git_history(code_snippet)
        }
        
        # AI模型预测
        cost_estimate = self.ml_model.predict(features)
        
        return {
            'estimated_hours': cost_estimate.hours,
            'risk_level': cost_estimate.risk,
            'confidence': cost_estimate.confidence,
            'recommendations': cost_estimate.suggestions
        }

class AIImpactAnalyzer:
    def analyze(self, code_change):
        # 静态分析
        static_impact = self.static_analysis(code_change)
        
        # AI语义分析
        semantic_impact = self.ai_semantic_analysis(code_change)
        
        # 行为影响预测
        behavioral_impact = self.predict_behavioral_changes(code_change)
        
        return {
            'files_affected': static_impact.files,
            'functions_affected': static_impact.functions,
            'tests_to_update': static_impact.tests,
            'semantic_risks': semantic_impact.risks,
            'behavioral_changes': behavioral_impact.predictions,
            'overall_risk_score': self.calculate_risk(static_impact, semantic_impact)
        }

class MaintainabilityPredictor:
    def calculate_index(self, code_module):
        """
        计算可维护性指数（0-100）
        """
        factors = {
            'readability': self.score_readability(code_module),
            'modularity': self.score_modularity(code_module),
            'testability': self.score_testability(code_module),
            'documentability': self.score_documentation(code_module),
            'changeability': self.score_changeability(code_module)
        }
        
        # 加权平均
        weights = {
            'readability': 0.25,
            'modularity': 0.25,
            'testability': 0.20,
            'documentability': 0.15,
            'changeability': 0.15
        }
        
        index = sum(factors[k] * weights[k] for k in factors)
        return index

def calc_price(items, user):
    total = 0
    for item in items:
        p = item.price
        if user.vip:
            p *= 0.9
        if item.category == 'electronics':
            p *= 0.95
        if datetime.now().weekday() == 2:
            p *= 0.98
        total += p
    return total

class PriceCalculator:
    def __init__(self):
        self.discount_strategies = []
    
    def add_strategy(self, strategy):
        self.discount_strategies.append(strategy)
    
    def calculate(self, items, user):
        total = sum(item.base_price for item in items)
        
        for strategy in self.discount_strategies:
            total = strategy.apply(total, items, user)
        
        return total

# 折扣策略
def vip_discount(total, items, user):
    return total * user.vip_level.discount_rate

def category_discount(total, items, user):
    electronics = [i for i in items if i.category == 'electronics']
    return total - sum(i.base_price * 0.05 for i in electronics)

def weekday_discount(total, items, user):
    if datetime.now().weekday() == 2:
        return total * 0.98
    return total