chore: automated publish

Author: github-actions[bot]

public/blog/2025-04-10/index.pdf

@@ -0,0 +1,139 @@
+\title{"Python 中的装饰器原理与高级用法解析"}
+\author{"叶家炜"}
+\date{"Apr 10, 2025"}
+\maketitle
+在软件开发中，\textbf{代码复用}与\textbf{逻辑解耦}是永恒的追求。Python 通过装饰器（Decorator）提供了一种优雅的解决方案，使得开发者能够在\textbf{不修改原函数代码}的前提下为其添加新功能。这种机制本质上是面向切面编程（AOP）思想的体现——将横切关注点（如日志记录、性能分析）与核心业务逻辑分离。对于已掌握函数和面向对象基础的 Python 开发者而言，深入理解装饰器将显著提升代码设计能力。\par
+\chapter{装饰器基础}
+装饰器的核心语法 \verb!@decorator! 看似神秘，实则是一种语法糖。其本质是将函数作为参数传递给装饰器函数，并返回一个新的函数对象。例如以下代码展示了最简单的装饰器实现：\par
+\begin{lstlisting}[language=python]
+def simple_decorator(func):
+    def wrapper():
+        print("Before function call")
+        func()
+        print("After function call")
+    return wrapper
+
+@simple_decorator
+def greet():
+    print("Hello!")
+\end{lstlisting}
+当调用 \verb!greet()! 时，实际执行的是 \verb!simple_decorator(greet)()!。这里的关键在于理解装饰器的\textbf{执行时机}：装饰过程发生在函数\textbf{定义阶段}而非调用阶段。这意味着无论 \verb!greet! 是否被调用，装饰器代码都会在模块加载时执行。\par
+\chapter{装饰器核心原理}
+\section{函数作为一等公民}
+Python 中函数具有\textbf{一等公民}身份，这意味着函数可以像普通变量一样被传递、修改和返回。装饰器正是利用这一特性，将目标函数 \verb!func! 作为参数输入，在内部定义一个包含增强逻辑的 \verb!wrapper! 函数，最终返回这个新函数。\par
+\section{闭包的魔法}
+装饰器的状态保存依赖于\textbf{闭包}机制。闭包使得内部函数 \verb!wrapper! 能够访问外部函数 \verb!simple_decorator! 的命名空间，即使外部函数已执行完毕。例如在以下代码中：\par
+\begin{lstlisting}[language=python]
+def counter_decorator(func):
+    count = 0
+    def wrapper():
+        nonlocal count
+        count += 1
+        print(f"Call count: {count}")
+        return func()
+    return wrapper
+\end{lstlisting}
+\verb!wrapper! 函数通过 \verb!nonlocal! 关键字捕获并修改了外层作用域的 \verb!count! 变量，实现了调用计数功能。这种闭包特性是装饰器能够实现状态保持的核心机制。\par
+\section{多层装饰器的执行顺序}
+当多个装饰器堆叠使用时，其执行顺序遵循\textbf{洋葱模型}。例如对于 \verb!@decorator1 @decorator2 def func()! 的写法，实际等价于 \verb!func = decorator1(decorator2(func))!。装饰过程从最内层开始，执行时则从外层向内层逐层调用。这种特性在 Web 框架的中间件系统中被广泛应用。\par
+\chapter{进阶装饰器技术}
+\section{处理函数参数}
+通用装饰器需要处理被装饰函数的各种参数形式，此时应使用 \verb!*args! 和 \verb!**kwargs! 接收所有位置参数和关键字参数：\par
+\begin{lstlisting}[language=python]
+def args_decorator(func):
+    def wrapper(*args, **kwargs):
+        print(f"Arguments received: {args}, {kwargs}")
+        return func(*args, **kwargs)
+    return wrapper
+\end{lstlisting}
+这里的 \verb!*args! 会将所有位置参数打包为元组，\verb!**kwargs! 则将关键字参数打包为字典。在调用原函数时需要使用解包语法 \verb!func(*args, **kwargs)! 以保证参数正确传递。\par
+\section{参数化装饰器}
+当装饰器本身需要接收参数时，需采用三层嵌套结构：\par
+\begin{lstlisting}[language=python]
+def repeat(n):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            results = []
+            for _ in range(n):
+                results.append(func(*args, **kwargs))
+            return results
+        return wrapper
+    return decorator
+\end{lstlisting}
+使用时写作 \verb!@repeat(3)!，其执行流程为：\par
+\begin{itemize}
+\item \verb!repeat(3)! 返回 \verb!decorator! 函数
+\item \verb!decorator! 接收被装饰函数 \verb!func!
+\item 最终的 \verb!wrapper! 函数实现具体逻辑
+\end{itemize}
+\section{类实现装饰器}
+通过实现 \verb!__call__! 方法，类也可以作为装饰器使用。这种方式特别适合需要维护复杂状态的场景：\par
+\begin{lstlisting}[language=python]
+class ClassDecorator:
+    def __init__(self, func):
+        self.func = func
+        self.call_count = 0
+
+    def __call__(self, *args, **kwargs):
+        self.call_count += 1
+        print(f"Call {self.call_count}")
+        return self.func(*args, **kwargs)
+\end{lstlisting}
+类装饰器在初始化阶段 \verb!__init__! 接收被装饰函数，后续每次调用触发 \verb!__call__! 方法。相较于函数式装饰器，类装饰器能更直观地管理状态数据。\par
+\chapter{高级应用场景}
+\section{缓存与记忆化}
+\verb!functools.lru_cache! 是标准库中基于装饰器的缓存实现典型代表。其核心原理是通过字典缓存函数参数与返回值的映射。以下简化实现展示了基本思路：\par
+\begin{lstlisting}[language=python]
+from functools import wraps
+
+def simple_cache(func):
+    cache = {}
+    @wraps(func)
+    def wrapper(*args):
+        if args in cache:
+            return cache[args]
+        result = func(*args)
+        cache[args] = result
+        return result
+    return wrapper
+\end{lstlisting}
+\verb!@wraps(func)! 的作用是保留原函数的元信息，避免因装饰器导致函数名（\verb!__name__!）等属性被覆盖。\par
+\section{异步函数装饰器}
+在异步编程中，装饰器需要返回协程对象并正确处理 \verb!await! 表达式：\par
+\begin{lstlisting}[language=python]
+def async_timer(func):
+    async def wrapper(*args, **kwargs):
+        start = time.time()
+        result = await func(*args, **kwargs)
+        print(f"Cost {time.time() - start:.2f}s")
+        return result
+    return wrapper
+\end{lstlisting}
+与同步装饰器的区别在于：\par
+\begin{itemize}
+\item 使用 \verb!async def! 定义包装函数
+\item 调用被装饰函数时使用 \verb!await!
+\item 装饰器本身不涉及事件循环的管理
+\end{itemize}
+\chapter{陷阱与最佳实践}
+\section{异常处理}
+装饰器可能无意中屏蔽被装饰函数的异常。正确的做法是在包装函数中捕获并重新抛出异常：\par
+\begin{lstlisting}[language=python]
+def safe_decorator(func):
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            print(f"Error occurred: {e}")
+            raise
+    return wrapper
+\end{lstlisting}
+通过 \verb!raise! 不带参数的写法可以保留原始异常堆栈信息，便于调试。\par
+\section{性能优化}
+过度嵌套装饰器会导致函数调用链增长。在性能敏感的场景中，可以通过以下方式优化：\par
+\begin{itemize}
+\item 使用 \verb!functools.wraps! 减少属性查找开销
+\item 将装饰器实现为类并重载 \verb!__get__! 方法实现描述符协议
+\item 避免在装饰器内部进行复杂初始化操作
+\end{itemize}
+装饰器体现了 Python 「显式优于隐式」的设计哲学。通过显式的语法标记，既实现了强大的元编程能力，又保持了代码的可读性。在进阶学习中，可以探索装饰器与元类的协同使用——元类控制类的创建过程，而装饰器则更专注于修改现有类或方法的行为。标准库中的 \verb!@dataclass! 装饰器便是两者结合的典范，它通过类装饰器自动生成 \verb!__init__! 等方法，显著减少样板代码。\par

public/blog/2025-04-10/index.tex

@@ -0,0 +1 @@
+a01590ccd75ac0bcab3f5395188a63739d9c7437c36e568934aa605276087b42