1. 闭包和装饰器
闭包
概念：闭包是一个函数，它能够引用在其外部定义的非全局变量，并且可以将这些变量传递到其他函数中。
示例：下面是一个简单的闭包示例，其中outer_function返回了一个内部函数inner_function，并且inner_function引用了x这个外部变量。
def outer_function(x):
def inner_function(y):
return x + y
return inner_function
closure = outer_function(10)
result = closure(5) # 这里的10来自于外部函数
print(result) # 输出15
闭包的构成条件
- 在函数嵌套(函数里面再定义函数)的前提下
- 内部函数使用了外部函数的变量(还包括外部函数的参数
- 外部函数返回了内部函数
闭包的使用
应用：闭包常用于创建工厂函数，生成具有特定行为或配置的函数。
商业案例：假设您正在编写一个购物网站，您可以使用闭包来创建不同的运费计算器，每个计算器根据不同的规则计算运费。
def shipping_calculator(rate):
def calculate_shipping(weight):
return weight * rate
return calculate_shipping
standard_shipping = shipping_calculator(2.5) # 创建标准运费计算器
express_shipping = shipping_calculator(5.0) # 创建快递运费计算器
cost1 = standard_shipping(10) # 计算10磅包裹的标准运费
cost2 = express_shipping(10) # 计算10磅包裹的快递运费
print(f"标准运费：${cost1}")
print(f"快递运费：${cost2}")
修改闭包内使用的外部变量
注意：默认情况下，闭包内不能修改外部变量的值。如果要修改，需要使用nonlocal关键字。
def outer_function():
x = 10
def inner_function():
nonlocal x
x += 5
return x
return inner_function
closure = outer_function()
result = closure()
print(result) # 输出15
2. 装饰器
概念：装饰器是一种Python函数，用于修改其他函数的行为，通常用于增强或包装函数。
示例：以下是一个简单的装饰器示例，它用于记录函数的执行时间。
import time
def timing_decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"{func.__name__} 执行时间：{end_time - start_time}秒")
return result
return wrapper
@timing_decorator
def slow_function():
time.sleep(2)
slow_function() # 输出 slow_function 执行时间：2.0000040531158447秒
装饰器的使用
应用：装饰器通常用于日志记录、性能分析、授权等方面。
商业案例：假设您正在开发一个Web应用程序，您可以使用装饰器来记录请求处理时间。
from flask import Flask
app = Flask(__name__)
def timing_decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"{func.__name__} 执行时间：{end_time - start_time}秒")
return result
return wrapper
@app.route('/')
@timing_decorator
def hello_world():
return 'Hello, World!'
if __name__ == '__main__':
app.run()
通用装饰器的使用
概念：通用装饰器是可以应用于任何函数的装饰器，不限于特定函数或参数。
def universal_decorator(func):
def wrapper(*args, **kwargs):
# 在调用函数前的处理
result = func(*args, **kwargs)
# 在调用函数后的处理
return result
return wrapper
@universal_decorator
def example_function():
pass
多个装饰器的使用
应用：您可以同时使用多个装饰器，它们将按照从上到下的顺序应用于函数。
@decorator1
@decorator2
def my_function():
pass
带有参数的装饰器
概念：装饰器可以接受参数，这使得它们更加灵活。
def parameterized_decorator(parameter):
def decorator(func):
def wrapper(*args, **kwargs):
# 使用参数来定制装饰器的行为
result = func(*args, **kwargs)
return result
return wrapper
return decorator
@parameterized_decorator("参数值")
def example_function():
pass
类装饰器的使用
应用：您可以创建一个类装饰器，类装饰器需要实现__init__和__call__方法。
class ClassDecorator:
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
# 在调用函数前的处理
result = self.func(*args, **kwargs)
# 在调用函数后的处理
return result
@ClassDecorator
def example_function():
pass
这些是Python中闭包和装饰器的关键知识点和用法。闭包允许您创建函数工厂，而装饰器允许您修改函数的行为
3. property属性
3.1 property属性的概念
概念：property属性是一种Python中的特性（attribute），它允许您在访问对象的属性时执行自定义的方法，而不是直接访问属性的值。这使得您可以控制属性的访问和赋值行为。
3.2 property属性的使用
示例：以下是一个使用property属性的示例，用于控制一个类中的属性访问和修改。
class Temperature:
def __init__(self, celsius):
self._celsius = celsius
@property
def celsius(self):
return self._celsius
@celsius.setter
def celsius(self, value):
if value < -273.15:
raise ValueError("温度不能低于绝对零度")
self._celsius = value
@property
def fahrenheit(self):
return self._celsius * 9/5 + 32
# 使用property属性
temp = Temperature(25)
print(f"摄氏度：{temp.celsius}")
print(f"华氏度：{temp.fahrenheit}")
temp.celsius = 30 # 修改属性值
print(f"摄氏度：{temp.celsius}")
3.3 property属性的商业案例
商业案例：假设您正在开发一个电子商务平台，需要确保商品的价格不会低于成本价。您可以使用property属性来实现价格属性，以便在访问和修改价格时执行验证和限制。
class Product:
def __init__(self, name, cost_price, selling_price):
self.name = name
self._cost_price = cost_price
self._selling_price = selling_price
@property
def cost_price(self):
return self._cost_price
@cost_price.setter
def cost_price(self, value):
if value < 0:
raise ValueError("成本价不能为负数")
self._cost_price = value
@property
def selling_price(self):
return self._selling_price
@selling_price.setter
def selling_price(self, value):
if value < self.cost_price:
raise ValueError("销售价不能低于成本价")
self._selling_price = value
@property
def profit_margin(self):
return self.selling_price - self.cost_price
# 使用property属性
product = Product("商品A", 50, 80)
print(f"成本价：${product.cost_price}")
print(f"销售价：${product.selling_price}")
print(f"利润：${product.profit_margin}")
product.cost_price = 60 # 修改成本价
product.selling_price = 90 # 修改销售价
print(f"成本价：${product.cost_price}")
print(f"销售价：${product.selling_price}")
print(f"利润：${product.profit_margin}")
4. with 语句和上下文管理
4.1 with 语句和上下文管理的概念
概念：with语句用于创建一个上下文管理器，允许您在进入和退出上下文时执行特定操作。它通常用于资源管理，如文件处理或数据库连接。
4.2 with 语句和上下文管理的使用
示例：以下是一个使用with语句的示例，用于安全地打开和关闭文件。
# 打开文件的常规方式
file = open("example.txt", "r")
try:
data = file.read()
finally:
file.close()
# 使用with语句
with open("example.txt", "r") as file:
data = file.read()
4.3 with 语句和上下文管理的商业案例
商业案例：假设您正在开发一个数据库应用程序，需要确保在每次查询后关闭数据库连接以释放资源。您可以使用with语句来实现上下文管理器，确保在进入和退出上下文时打开和关闭数据库连接。
class DatabaseConnection:
def __init__(self, db_name):
self.db_name = db_name
def __enter__(self):
self.connection = create_database_connection(self.db_name)
return self.connection
def __exit__(self, exc_type, exc_value, traceback):
if self.connection:
self.connection.close()
# 使用上下文管理器
with DatabaseConnection("my_database") as db:
result = db.query("SELECT * FROM customers")
# 处理查询结果
# 在退出上下文后，数据库连接将自动关闭
5. 生成器
5.1 生成器的概念
概念：生成器是一种特殊类型的迭代器，它允许您按需生成值，而不是一次性生成所有值。这节省了内存并提高了性能。
5.2 生成器的使用
示例：以下是一个简单的生成器示例，用于生成斐波那契数列。
def fibonacci_generator():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# 使用生成器
fib = fibonacci_generator()
for _ in range(10):
print(next(fib))
5.3 生成器的商业案例
商业案例：假设您正在开发一个日志分析工具，需要处理大型日志文件并逐行分析。使用生成器可以逐行读取日志文件，而不必将整个文件加载到内存中。
def log_reader(log_file):
with open(log_file, "r") as file:
for line in file:
yield line.strip()
# 使用生成器逐行读取日志文件
for log_entry in log_reader("app.log"):
# 分析日志条目
6. 深拷贝和浅拷贝
6.1 深拷贝和浅拷贝的概念
概念：深拷贝和浅拷贝是用于创建对象副本的不同方式。浅拷贝创建一个新对象，但它仅复制原始对象中的元素的引用。深拷贝创建一个新对象，并递归复制原始对象及其所有子对象。
6.2 深拷贝和浅拷贝的使用
示例：以下是一个使用浅拷贝和深拷贝的示例。
import copy
# 浅拷贝
original_list = [[1, 2, 3], [4, 5, 6]]
shallow_copy = copy.copy(original_list)
shallow_copy[0][0] = 100 # 修改副本中的元素
print(original_list) # 输出 [[100, 2, 3], [4, 5, 6]]
# 深拷贝
original_list = [[1, 2, 3], [4, 5, 6]]
deep_copy = copy.deepcopy(original_list)
deep_copy[0][0] = 100 # 修改副本中的元素
print(original_list) # 输出 [[1, 2, 3], [4, 5, 6]]
6.3 深拷贝和浅拷贝的商业案例
商业案例：假设您正在开发一个项目管理应用程序，需要复制项目对象以创建新的项目。项目对象可能包括任务列表，每个任务又包含子任务。在这种情况下，您可以使用深拷贝来创建新的项目，确保每个项目都是独立的。
import copy
class Task:
def __init__(self, name):
self.name = name
self.subtasks = []
class Project:
def __init__(self, name):
self.name = name
self.tasks = []
def add_task(self, task):
self.tasks.append(task)
def clone(self):
return copy.deepcopy(self)
# 创建原始项目
original_project = Project("Project A")
task1 = Task("Task 1")
task2 = Task("Task 2")
task1.subtasks.append(Task("Subtask 1"))
original_project.add_task(task1)
original_project.add_task(task2)
# 克隆项目
new_project = original_project.clone()
new_project.name = "Project B"
# 修改克隆后的项目不会影响原始项目
new_project.tasks[0].subtasks[0].name = "Updated Subtask"
print(original_project.tasks[0].subtasks[0].name) # 输出 "Subtask 1"
这些知识点包括property属性、with语句和上下文管理、生成器、深拷贝和浅拷贝，是Python编程中非常有用的概念。它们可以帮助您更有效地管理属性、资源、数据生成和对象复制。
