# 重构前的冗长函数示例
def process_data(data):
    cleaned_data = remove_invalid_chars(data)
    sorted_data = sort_by_date(cleaned_data)
    summarized_data = summarize_stats(sorted_data)
    return generate_report(summarized_data)

# 重构后的抽离方法
def clean_data(data):
    return remove_invalid_chars(data)

def sort_data(data):
    return sort_by_date(data)

def summarize_statistics(data):
    return summarize_stats(data)

def process_data(data):
    cleaned = clean_data(data)
    sorted_data = sort_data(cleaned)
    stats = summarize_statistics(sorted_data)
    return generate_report(stats)

# 重构前
class OrderProcessor:
    def __init__(self, order):
        self.order = order
    
    def process(self):
        total = self.calculate_total()
        self.send_email_notification(total)
    
    def calculate_total(self):
        # 计算订单总价
        pass
    
    def send_email_notification(self, total):
        # 发送包含总价的邮件通知
        pass

# 重构后
class OrderCalculator:
    def __init__(self, order):
        self.order = order
    
    def calculate_total(self):
        # 现仅专注于计算订单总价
        pass

class NotificationService:
    def __init__(self, order, total):
        self.order = order
        self.total = total
    
    def send_email_notification(self):
        # 现仅专注于发送邮件通知
        pass

# 新的流程协调
order_calculator = OrderCalculator(order)
total = order_calculator.calculate_total()
notifier = NotificationService(order, total)
notifier.send_email_notification()

from abc import ABC, abstractmethod

# 抽象基类定义
class AnimalSounds(ABC):
    @abstractmethod
    def make_sound(self):
        pass

# 具体子类实现
class Dog(AnimalSounds):
    def make_sound(self):
        return "Woof!"

class Cat(AnimalSounds):
    def make_sound(self):
        return "Meow!"

# 若增加更多动物声音，只需创建新子类，无需修改原有代码
class Cow(AnimalSounds):
    def make_sound(self):
        return "Moo!"

# 使用时无需关心具体动物类型
animals = [Dog(), Cat(), Cow()]
for animal in animals:
    print(animal.make_sound())

class Quadrilateral:
    def __init__(self, side1, side2, side3, side4):
        self.sides = [side1, side2, side3, side4]

    def perimeter(self):
        return sum(self.sides)

class Rectangle(Quadrilateral):
    def __init__(self, width, height):
        super().__init__(width, height, width, height)

class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)  # 正方形的所有边长相等，符合LSP

# 示例中，Square可以替代Rectangle而不影响程序正确运行
shapes = [Rectangle(5, 7), Square(6)]
for shape in shapes:
    print(shape.perimeter())

# 重构前的“坏味道”代码片段
def process_orders(order_list):
    total = 0
    for order in order_list:
        total += order['amount']
        
        payment_system.process_payment(order)
        shipping_service.ship_products(order)
        notification_service.send_confirmation(order)
    
    return total

# 重构后，识别并拆分职责
def calculate_total(order_list):
    return sum(order['amount'] for order in order_list)

def process_order(order):
    payment_system.process_payment(order)
    shipping_service.ship_products(order)
    notification_service.send_confirmation(order)

def process_all_orders(order_list):
    total = calculate_total(order_list)
    for order in order_list:
        process_order(order)
    return total

pip install pylint
pylint your_module.py

# 重构前
def calculate_discounted_price(items):
    grand_total = 0
    for item in items:
        unit_price = item.price
        quantity = item.quantity
        if item.is_bestseller:
            discount_rate = get_special_discount_rate(item.category)
            unit_price *= (1 - discount_rate)
        tax_amount = unit_price * quantity * TAX_RATE
        line_total = unit_price * quantity + tax_amount
        grand_total += line_total
    return grand_total

# 重构后，提取出计算折扣价格的方法
def calculate_item_total(item):
    unit_price = item.price
    if item.is_bestseller:
        discount_rate = get_special_discount_rate(item.category)
        unit_price *= (1 - discount_rate)
    tax_amount = unit_price * item.quantity * TAX_RATE
    return unit_price * item.quantity + tax_amount

def calculate_discounted_price(items):
    grand_total = sum(calculate_item_total(item) for item in items)
    return grand_total

# 重构前
class ShoppingCart:
    def __init__(self, items):
        self.items = items
        self.tax_rate = get_tax_rate()

    def calculate_total(self):
        grand_total = 0
        for item in self.items:
            grand_total += self.calculate_item_total(item)
        return grand_total * (1 + self.tax_rate)

    def calculate_item_total(self, item):
        # 包含商品价格计算、折扣处理等复杂逻辑
        pass

# 重构后，提取出ItemTotalCalculator类
class ItemTotalCalculator:
    def __init__(self, tax_rate):
        self.tax_rate = tax_rate

    def calculate(self, item):
        # 商品价格计算、折扣处理等逻辑移到这里
        pass

class ShoppingCart:
    def __init__(self, items):
        self.items = items
        self.tax_calculator = ItemTotalCalculator(get_tax_rate())

    def calculate_total(self):
        item_totals = [self.tax_calculator.calculate(item) for item in self.items]
        return sum(item_totals) * (1 + self.tax_calculator.tax_rate)

# 重构前，存在重复计算折扣逻辑
def calculate_employee_salary(employee):
    base_salary = employee.base_pay
    bonus = calculate_bonus(employee)
    discounted_bonus = apply_discount(bonus, employee.discount_rate)
    return base_salary + discounted_bonus

def calculate_contractor_fee(contractor):
    fee = contractor.hourly_rate * contractor.hours_worked
    bonus = calculate_bonus(contractor)
    # 注意此处的折扣逻辑与上一个函数重复
    discounted_bonus = apply_discount(bonus, contractor.discount_rate)
    return fee + discounted_bonus

# 重构后，提取重复逻辑为公用函数
def calculate_total_compensation(worker, base_amount):
    bonus = calculate_bonus(worker)
    discounted_bonus = apply_discount(bonus, worker.discount_rate)
    return base_amount + discounted_bonus

def calculate_employee_salary(employee):
    return calculate_total_compensation(employee, employee.base_pay)

def calculate_contractor_fee(contractor):
    return calculate_total_compensation(contractor, contractor.hourly_rate * contractor.hours_worked)

# 重构前，直接访问类的私有属性
class BankAccount:
    def __init__(self, initial_balance):
        self.balance = initial_balance

# 直接修改账户余额
account = BankAccount(1000)
account.balance -= 500  # 不安全的操作，没有进行余额校验

# 重构后，封装字段
class BankAccount:
    def __init__(self, initial_balance):
        self.__balance = initial_balance

    @property
    def balance(self):
        return self.__balance

    @balance.setter
    def balance(self, new_balance):
        if new_balance >= 0:
            self.__balance = new_balance
        else:
            raise ValueError("Balance cannot be negative")

account = BankAccount(1000)
try:
    account.balance -= 500  # 通过setter方法进行余额修改，若有异常会被捕获
except ValueError as e:
    print(f"Error: {e}")

# 重构前，一次性加载所有文件内容到内存
def read_large_file(file_path):
    with open(file_path, 'r') as file:
        lines = file.readlines()
    return [process_line(line) for line in lines]

# 重构后，使用生成器逐行读取和处理文件
def read_large_file_generator(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield process_line(line)

# 使用生成器的方式节约内存
for processed_line in read_large_file_generator('large_file.txt'):
    do_something_with(processed_line)

# 重构前，使用for循环创建一个平方数列表
squares = []
for i in range(10):
    squares.append(i**2)

# 重构后，使用列表推导式
squares = [i**2 for i in range(10)]

// 举例：在PyCharm中提取方法
// 原始代码：
def complex_function(some_list):
    result = []
    for item in some_list:
        if is_valid(item):
            transformed_item = transform_item(item)
            result.append(transformed_item)
    return result

// 在PyCharm中选中相关代码，然后使用重构菜单提取方法：
// 新代码：
def process_item(item):
    if is_valid(item):
        return transform_item(item)

def complex_function(some_list):
    result = [process_item(item) for item in some_list if process_item(item) is not None]
    return result

// 假设使用`refactor-python`移除重复代码：
$ refactor-python --remove-duplicates path/to/project

// 进行大规模重构时，可能还需要配合配置文件和脚本来定制化操作

import unittest
from my_module import complex_function

class TestComplexFunction(unittest.TestCase):
    def test_complex_function(self):
        input_data = [1, 2, 3, 4]
        expected_output = [transformed_1, transformed_2, transformed_3, transformed_4]
        self.assertEqual(complex_function(input_data), expected_output)

if __name__ == '__main__':
    unittest.main()

# 原始线性搜索示例（时间复杂度O(n)）
def linear_search(data, target):
    for index, value in enumerate(data):
        if value == target:
            return index
    return -1

# 重构为二分查找（时间复杂度O(log n)，前提：数据已排序）
def binary_search(sorted_data, target):
    left, right = 0, len(sorted_data) - 1
    while left <= right:
        mid = (left + right) // 2
        if sorted_data[mid] == target:
            return mid
        elif sorted_data[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# 同步网络请求示例
import requests

def sync_fetch(url):
    response = requests.get(url)
    return response.text

# 异步网络请求示例（重构后）
import asyncio
from aiohttp import ClientSession

async def async_fetch(url):
    async with ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

git checkout -b refactor-feature
# 开始重构...
git add modified_files.py
git commit -m "重构：将巨大函数extract_to_new_method"
# 继续重构...
git add more_changes.py
git commit -m "重构：引入新的类结构以分离职责"

git push origin refactor-feature

# 更新前（旧类）
class HugeClass:
    """
    这是一个包含众多功能的巨大类，需要重构以提高可读性和可维护性。
    ...
    """

# 更新后（新类）
class SmallClassA:
    """
    从前的HugeClass的一部分，现在专门负责处理A类任务。
    ...
    """

class SmallClassB:
    """
    从前的HugeClass的另一部分，专注于处理B类任务。
    ...
    """