在编程的世界里，代码重构是一项至关重要的技能。它不仅能提高代码的可读性和可维护性，还能提升软件的性能和稳定性。从新手到高手，学会有效的代码重构技巧是必经之路。下面，我将通过5个真实的代码重构案例，与大家分享一些实用的技巧。
案例一：从冗长函数到模块化设计
问题描述：一个复杂的函数中包含了过多的逻辑，导致可读性极低，且难以维护。
重构前：
def calculate_salary(employee):
if employee.is_full_time:
salary = employee.basic_salary + (employee.basic_salary * 0.1)
else:
salary = employee.basic_salary
if employee.has_bonus:
salary += employee.bonus
return salary
重构后：
def calculate_bonus_salary(employee):
return employee.basic_salary * 1.1
def calculate_final_salary(employee):
if employee.is_full_time:
return calculate_bonus_salary(employee)
else:
return employee.basic_salary
def calculate_bonus(employee):
if employee.has_bonus:
return employee.bonus
return 0
技巧分享：将复杂的函数拆分为多个小的、功能单一的函数，可以提高代码的可读性和可维护性。
案例二：从循环到递归
问题描述：一个循环中包含了大量的重复逻辑，导致代码冗余。
重构前：
def print_numbers(n):
for i in range(n):
print(i)
重构后：
def print_numbers(n):
if n > 0:
print_numbers(n - 1)
print(n - 1)
技巧分享：在合适的场景下，使用递归可以简化代码，但需注意递归的效率和栈溢出问题。
案例三：从重复代码到模板方法
问题描述：多个函数中存在重复的代码段。
重构前：
def process_employee(employee):
print("Processing employee: ", employee.name)
print("Employee ID: ", employee.id)
def process_customer(customer):
print("Processing customer: ", customer.name)
print("Customer ID: ", customer.id)
重构后：
class EntityProcessor:
def process(self, entity):
print("Processing entity: ", entity.name)
print("Entity ID: ", entity.id)
def process_employee(employee):
processor = EntityProcessor()
processor.process(employee)
def process_customer(customer):
processor = EntityProcessor()
processor.process(customer)
技巧分享：使用模板方法模式可以减少重复代码，提高代码的可复用性。
案例四：从面向过程到面向对象
问题描述：一个函数中包含了大量的业务逻辑，导致可读性和可维护性较差。
重构前：
def calculate_order_total(order):
total = 0
for item in order.items:
total += item.price * item.quantity
return total
重构后：
class Order:
def __init__(self, items):
self.items = items
def calculate_total(self):
return sum(item.price * item.quantity for item in self.items)
def calculate_order_total(order):
return order.calculate_total()
技巧分享：将业务逻辑封装到对象中，可以提高代码的可读性和可维护性。
案例五：从全局变量到依赖注入
问题描述：多个函数中使用了全局变量，导致代码难以维护。
重构前：
database = Database()
def save_employee(employee):
database.save(employee)
def update_employee(employee):
database.update(employee)
def delete_employee(employee):
database.delete(employee)
重构后：
class Database:
def save(self, entity):
pass
def update(self, entity):
pass
def delete(self, entity):
pass
class EmployeeRepository:
def __init__(self, database):
self.database = database
def save(self, employee):
self.database.save(employee)
def update(self, employee):
self.database.update(employee)
def delete(self, employee):
self.database.delete(employee)
技巧分享：使用依赖注入可以降低全局变量的使用，提高代码的可测试性和可维护性。
通过以上5个案例，相信大家已经对代码重构有了更深入的了解。在实际开发过程中，不断练习和总结，才能成为一名真正的代码高手。