python元编程笔记

原创 已于 2025-06-20 10:33:42 修改 · 197 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #笔记 #开发语言

于 2025-06-18 17:31:10 首次发布

第九章 元编程

9.1 给函数添加一个包装

简单案例

# 使用装饰器 给函数增加一个包装层添加额外的处理(如记录日志、计时统计)

import time
from functools import wraps

# 定义装饰器：用于统计函数执行时间
def timethis(func):
    @wraps(func)
    # 装饰器内部的代码一般会涉及创建一个新的函数,利用*args 和**kwargs来接受任意的参数
    # 装饰器一般来说不会修改调用签名,也不会修改被包装函数返回的结果
    def wrapper(*args, **kwargs):
        start = time.time()                 # 记录开始时间
        result = func(*args, **kwargs)      # 执行原函数
        end = time.time()                   # 记录结束时间
        print(f'{func.__name__} 耗时: {end - start:.6f} 秒')  # 输出耗时信息
        return result
    return wrapper


# 使用装饰器修饰 countdown 函数
@timethis
def countdown(n):
    while n > 0:
        n -= 1


# 主程序入口
if __name__ == '__main__':
    # 调用测试
    countdown(100000)      
    countdown(10000000)

装饰器的使用

# 装饰器就是一个函数,它可以接受一个函数作为输入并返回一个新的函数作为输出
# 如下两个操作时相同的
@timethis 
def countdown(n): 
     ...

def countdown(n):
    ...
countdown = timethis(countdown)

# Python 中的内置装饰器（如 @staticmethod、@classmethod 和 @property）本质上与我们自定义的装饰器工作方式一致
class A:
    @classmethod
    def method(cls):
        pass
# 上述代码是等价的
class B:
    def method(cls):
        pass

method = classmethod(method)

class C:
    @staticmethod
    def method(x):
        print(x)
# 等价于
class C:
    def method(x):
        print(x)

    method = staticmethod(method)

9.2 编写装饰器时如何保存函数的元数据

# 使用wrap保留函数上如函数名、文档字符串、函数注解以及调用签名等重要的元数据 
import time
from functools import wraps

def timethis(func):
    # 使用functools.wraps可以保留被装饰函数的元数据
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()           
        result = func(*args, **kwargs)  
        end = time.time()             
        print(f'{func.__name__} {end - start}')  
        return result
    return wrapper


# 定义测试函数 countdown
@timethis
def countdown(n: int):
    """
	Counts down
    """
    while n > 0:
        n -= 1


# 主程序入口
if __name__ == '__main__':
    # 测试调用
    countdown(100000)       # 示例输出: countdown 0.008917808532714844
    
    # 检查装饰器对元信息的影响
    print(countdown.__name__)     # 输出函数的名字: 'countdown'
    print(countdown.__doc__)      # 输出函数的文档字符串(函数开头使用""""""包裹的字符串): '\n\tCounts down\n\t'
    print(countdown.__annotations__)  # 输出表示函数参数和返回值的类型注解: {'n': <class 'int'>}

技巧

# 如果没有使用@wraps 会丢失相关的信息
print(countdown.__doc__) # 输出为空
print(countdown.__annotations__) # 输出{} 


# 通过__wrapped__属性直接访问被包装的函数
countdown. wrapped (100000)

signature()的使用

# wraps 用于保留函数的元数据（名字、文档、注解），而signature用于获取/设置函数的参数签名信息
# signature()返回一个 Signature 对象，完整描述了函数的参数结构
from functools import wraps
from inspect import signature

# 示例函数
def foo(a: int, b: str) -> None:
    pass

# 不带 wraps 的装饰器
def deco1(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

# 带 wraps 的装饰器
def deco2(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

# 使用装饰器
@deco1
def bar(x: float):
    pass

@deco2
def baz(y: bool):
    pass

print(signature(bar))
# 输出: (*args, **kwargs) ← 看不到原始参数信息！

print(signature(baz))
# 输出: (y: bool) ← 成功保留了原始签名！

9.3 对装饰器进行解包装

# 绕过装饰器直接访问原始函数
from functools import wraps


# 定义一个装饰器
def somedecorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper


# 使用装饰器
@somedecorator
def add(x, y):
    return x + y


# 主程序入口
if __name__ == '__main__':
    # 通过 __wrapped__ 获取原始函数并调用
    orig_add = add.__wrapped__
    result = orig_add(3, 4)  # 预期输出: 7
    # 不会输出 Before function call之类的话

    # 输出结果
    print("Result:", result)  # 输出: Result: 7

处理同时使用多个装饰器

from functools import wraps

def decorator1(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print('Decorator 1')
        return func(*args, **kwargs)
    return wrapper

def decorator2(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print('Decorator 2')
        return func(*args, **kwargs)
    return wrapper

@decorator1
@decorator2
def add(x, y):
    return x + y
# 等价于add = decorator1(decorator2(add))
# 所以函数调用顺序是 add() → decorator1.wrapper() → decorator2.wrapper() → add()

print(add(2, 3)) # 输出 Decorator 1 Decorator 2 5 
# 此时add.__wrapped__ 只会返回最外层装饰器（即 decorator1）的 wrapper 函数所包装的那个函数 —— 也就是 decorator2(wrapper)
# 当函数被多个装饰器修饰时，__wrapped__ 的行为是未定义的 ，不同版本或实现可能会有不同的结果
print(add.__wrapped__(2, 3)) # 输出 5

9.4 定义一个可接受参数的装饰器

# 编写一个为函数添加日志功能的装饰器 但是又允许用于指定日志等级比提供其余参数
from functools import wraps
import logging


# 设置基本的日志配置
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# 最外层的 logged()函数接受所需的参数,并让它们对装饰器的内层函数可见
def logged(level, name=None, message=None):
    def decorate(func):
        log_name = name if name else func.__module__
        log = logging.getLogger(log_name)
        log_message = message if message else func.__name__
        # 内层装饰器接受一个函数并给它加上一个包装层
        @wraps(func)
        def wrapper(*args, **kwargs):
            log.log(level, log_message)
            return func(*args, **kwargs)
        return wrapper
    return decorate


# 示例用法 1：只指定日志等级
@logged(logging.DEBUG)
def add(x, y):
    return x + y


# 示例用法 2：指定日志等级和日志器名称
@logged(logging.CRITICAL, 'example')
def spam():
    print('Spam!')


# 主程序入口
if __name__ == '__main__':
    # 调用 add 函数，会打印日志
    result = add(2, 3)  # 输出: DEBUG - __main__ - add
    print("add(2, 3) =", result)  # 输出: add(2, 3) = 5

    # 调用 spam 函数，会打印日志和 "Spam!"
    spam()  
    # 输出:
    # CRITICAL - example - spam
    # Spam!

装饰器调用顺序

# 编写一个装饰器涉及调用的顺序
def decorator(x, y, z):
    def decorate(func):
        def wrapper(*args, **kwargs):
            print(f"Decorator args: x={x}, y={y}, z={z}")
            print(f"Calling function {func.__name__}")
            return func(*args, **kwargs)
        return wrapper
    return decorate


@decorator(10, 20, 30)
def func(a, b):
    pass

# 等价写法是func = decorator(10, 20, 30)(func)
# decorator(x, y, z)将返回一个装饰器 然后使用decorate(func)会返回一个包装函数 会真正的执行函数并添加功能

9.5 定义一个属性可由用户修改的装饰器

# 编写一个可以让用户调整属性的装饰器
# 引入了访问器函数(accessor function)
# 通过使用nolocal声明全局变量

from functools import wraps, partial
import logging

# 工具装饰器函数：将函数作为属性附加到对象上
def attach_wrapper(obj, func=None):
    if func is None:
        # 如果只提供了 obj，返回一个偏函数，等待后续的func 
        return partial(attach_wrapper, obj)
    # 将func绑定为obj的一个属性 属性名为func.__name__
    setattr(obj, func.__name__, func) 
    # 返回函数本身，不影响装饰器链式调用
    return func


# 为任意函数添加日志记录功能，并允许在运行时动态修改日志级别和日志信息
# level 是日志级别，name 是日志记录器名称，message 是日志信息
# 未指定 name 和 message，则默认使用函数所属模块和函数名
def logged(level, name=None, message=None):

    def decorate(func):
        logname = name if name else func.__module__
        log = logging.getLogger(logname)
        logmsg = message if message else func.__name__

        @wraps(func)
        def wrapper(*args, **kwargs):
            log.log(level, logmsg)
            return func(*args, **kwargs)
	    
        # 访问器函数
        @attach_wrapper(wrapper)
        def set_level(newlevel):
            # 使用nolocal表示不要创建新的局部变量 而是使用decorate函数闭包中的logmsg
            nonlocal level
            level = newlevel

        # 访问器函数    
        @attach_wrapper(wrapper)
        def set_message(newmsg):
            nonlocal logmsg
            logmsg = newmsg

        return wrapper
    return decorate


# 示例函数1：带DEBUG级别的日志
@logged(logging.DEBUG)
def add(x, y):
    return x + y


# 示例函数2：带CRITICAL级别的日志，并指定logger名称为'example'
@logged(logging.CRITICAL, 'example')
def spam():
    print('Spam!')

# 启用基础日志配置（在交互式环境中通常会调用）
logging.basicConfig(level=logging.DEBUG)

# 测试add函数
print(add(2, 3))  # 应输出DEBUG日志并返回5

# 修改日志消息内容
add.set_message('Add called')
print(add(2, 3))  # 应输出更新后的DEBUG日志并返回5

# 修改日志级别为WARNING
add.set_level(logging.WARNING)
print(add(2, 3))  # 应输出WARNING级别的日志并返回5

访问器可以跨越多个装饰器层进行传播

# 9.2装饰器代码回顾
def timethis(func):
    # 使用functools.wraps可以保留被装饰函数的元数据
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()           
        result = func(*args, **kwargs)  
        end = time.time()             
        print(f'{func.__name__} {end - start}')  
        return result
    return wrapper

# 下述例子说明了访问器函数可以跨越多个装饰器进行传播
# 调换两个装饰器的顺序也可以
# 访问器函数之所以能跨越多个装饰器进行传播，是因为在使用 @wraps(func) 的前提下，装饰器返回的新函数保留了原函数的所有属性（包括附加的方法），使得这些方法可以在最外层被调用。
@timethis 
@logged(logging.DEBUG) 
def countdown(n): 
     while n > 0: 
          n -= 1

if __name__ == '__main__':
    # 第一次调用
    countdown(10000000)
    # 输出 DEBUG: main : countdown countdown 0.8198461532592773 
    # 修改日志级别和消息
    countdown.set_level(logging.WARNING)
    countdown.set_message("Counting down to zero")
    countdown(10000000)
    # 输出WARNING: main : Counting down to zero countdown 0.8225970268249512

使用访问器函数返回内部的状态值

def logged(level, name=None, message=None):
    def decorate(func):
        logname = name if name else func.__module__
        log = logging.getLogger(logname)
        logmsg = message if message else func.__name__

        @wraps(func)
        def wrapper(*args, **kwargs):
            log.log(level, logmsg)
            return func(*args, **kwargs)

        @attach_wrapper(wrapper)
        def set_level(newlevel):
            nonlocal level
            level = newlevel

        @attach_wrapper(wrapper)
        def set_message(newmsg):
            nonlocal logmsg
            logmsg = newmsg
# 新增代码部分
        # 添加 get_level
        @attach_wrapper(wrapper)
        def get_level():
            return level

        # 添加 get_message
        @attach_wrapper(wrapper)
        def get_message():
            return logmsg

        return wrapper
    return decorate

# 使用代码示例
@logged(logging.INFO)
def say_hello():
    print("Hello!")

# 获取当前状态
print(say_hello.get_level())       # 输出: 20 (即 logging.INFO)
print(say_hello.get_message())     # 输出: 'say_hello'

# 修改状态
say_hello.set_level(logging.WARNING)
say_hello.set_message("Greeting called")

# 再次查看
print(say_hello.get_level())       # 输出: 30 (即 logging.WARNING)
print(say_hello.get_message())     # 输出: 'Greeting called'

直接暴露属性和访问器对比

当我们使用装饰器且希望暴露一些内部状态或者提供修改接口时，有两种常见的思路：直接暴露属性或者使用访问器函数，直接暴露属性示例如下。

@wraps(func)
def wrapper(*args, **kwargs):
    wrapper.log.log(wrapper.level, wrapper.logmsg)
    return func(*args, **kwargs)

# 直接设置属性
wrapper.level = level
wrapper.logmsg = logmsg
wrapper.log = log

这样简单直观，易于读取状态。但是这些属性只存在于当前装饰器返回的函数对象上，如果你在它外面再加一层装饰器（例如 @timethis），那么最外层函数就无法访问这些属性。

Python笔记之异步编程
K
11-18 1210
本章节详细讲解Python中的异步编程，涵盖异步I/O、协程（asyncio模块）以及异步任务与事件循环的相关概念。异步编程是一种处理I/O密集型任务的有效方式，可以显著提高程序的并发能力，尤其是在处理大量I/O操作时。Python的asyncio模块为我们提供了对异步编程的支持，使得编写异步代码变得更加简洁。# 定义协程函数print("协程开始")await asyncio.sleep(2) # 模拟异步I/O操作print("协程结束")# 运行协程运行结果协程开始(等待2秒)协程结束。
python基础知识笔记
qq_47541315的博客
10-01 3万+
python基础语法知识总结笔记，视频看的是b站的黑马程序员8天学会Python基础。
Python 编程笔记（本人出品，必属精品）
一些笔记
12-06 2558
有关python 的下载安装，以及一些基础知识。对网络资源的一个小小整理~ 笔者根据自己的使用经验，又进行了扩充，一直在用，所以会一直更新！！
Python编程学习笔记
qq_38324605的博客
11-14 1127
python编程学习笔记
Python3 笔记：Python3 在线工具、Python在线编程
Catherine_优快云_的博客
05-03 5285
在没有安装Python的情况下，想试试在线编程的，推荐以下三款工具： 1、W3Cschool Python 3 在线工具 www.w3cschool.cn/tryrun/runcode?lang=python3 2、Python3 在线工具www.jyshare.com/compile/9/ 3、Python在线编程www.sciclass.cn/python
Python一级考试笔记
m0_46403734的博客
02-16 3805
Python常见的几种编程环境：IDLE（自带）、Visual Studio Code、Jupyter、pyCharm；python版本：python3 和 python2（版本之间互不兼容）IDLE的两种开发模式：交互模式、文件模式Python中保留字是指被编程语言所保留的特殊单词，这些单词有着特定的含义和功能，不能被用作变量名、函数名或类名等标识符。
Python基础笔记（全）
热门推荐
Noria107的博客
02-08 4万+
零、python前言 （一）解释器 计算机不能直接理解任何除机器语言以外的语言，必须要把程序语言翻译成机器语言，计算机才能执行程序。 编译器：将其他语言翻译成机器语言的工具 编译器翻译的方式：编译，解释。 两种方式的区别在于翻译时间点的不同。当编译器以解释方式运行的时候，也称之为解释器 编译型语言：程序执行之前需要有一个专门的编译过程，把程序编译成为机器语言的文件，运行时不需要重新翻译，直接使用编译的结果就行了。程序执行效率高，依赖编译器，跨平台性差些。 解释型语言：解释型语言编写的程序不进行预先编
python学习笔记
qq_63176683的博客
07-24 3335
python学习笔记
Python 高级编程笔记之类别
Teman的博客
03-16 3014
目录： 子类化内建类型 访问超类中的方法-super 描述符 & 属性 元编程 主要内容：1.子类化内建类型# -*- coding:utf-8 -*- class Folder(list): def __init__(self, name): self.name = name def dir(self): print "I am : %s" % sel
Python入门学习笔记（pdf文件）
qq_45580875的博客
12-29 830
Python入门
python网络编程笔记上传
06-03
python网络编程笔记上传
python核心编程笔记
12-21
在《Python核心编程笔记》中，我们关注的是Python解释器的一些选项、基本语法、数据类型以及控制流程。 1. Python解释器选项： - `-d`：启用调试输出，这对于调试Python程序非常有用。 - `-O`：生成优化的字节码...
Python非常详细编程笔记.zip_python 详细笔记_python编程
09-19
这份“Python非常详细编程笔记”涵盖了Python的基础到进阶知识，是学习Python编程的理想资源。以下将详细介绍其中可能涵盖的一些核心知识点： 1. **Python基础知识**：这包括Python的安装、环境配置以及开发工具的...
精选资源
《Python数学编程》学习笔记源代码1-5.7z
04-27
《Python数学编程》是一本深度探索如何利用Python进行数学计算和建模的书籍。学习笔记源代码1-5.7z这个压缩包包含了作者在阅读和实践这本书籍内容时所编写的代码示例，覆盖了从第一天到第五天的学习内容。这些源代码...
Python编程笔记典藏.zip
08-15
《Python编程笔记典藏》是一部精心编纂的Python学习资源集，旨在为Python编程爱好者及开发者提供一站式的知识宝库。该典藏汇集了从基础语法到高级进阶的详尽笔记，内容覆盖Python语言的核心概念、数据结构、函数编程...
MobaXterm 高效运维实战：从入门到进阶的 Linux 运维 “瑞士军刀” 用法
最新发布
hy行者勇哥的博客
12-18 552
MobaXterm 作为 Linux 运维的 “全能工具包”，不仅集成了 SSH 终端、SFTP 文件传输、X11 图形转发等基础功能，更隐藏着批量执行、宏命令、会话分组等高级特性，能轻松解决新手常遇到的 “重复操作繁琐”“多服务器切换麻烦”“文件传输低效” 等痛点。本文用 “运维指挥中心” 的通俗比喻，拆解 MobaXterm 的核心架构，针对 Linux 运维中的高频问题，分享可直接上手的高级技巧与自动化脚本案例，帮助新手快速从 “手动跑腿” 升级为 “高效指挥”，大幅提升运维效率。
[Python实战] 解决Outlook同步中的字符编码问题：表情符号也能正确处理了！
每日出拳老爷子的博客
12-16 212
摘要：本文分享了在使用Python同步Outlook会议信息时遇到的GBK编码问题解决方案。当处理包含表情符号（如📧）的会议内容时，Flask返回JSON会报"'gbk' codec can't encode"错误。作者通过封装ensure_utf8函数对文本进行UTF-8编码处理，同时建议设置Flask响应头编码为UTF-8和调整控制台输出编码，有效解决了特殊字符导致的编码异常问题。文章提供了从问题分析到完整解决方案的实践过程，适用于处理Python中的Unicode编码问题。
《Python实战小课：爬虫工具场景——开启数据抓取之旅》导读
2501_93253814的博客
12-15 2646
本文介绍了Python爬虫技术在三大场景中的应用：行业资讯爬取、学术文献摘要获取和电商评价收集。针对行业资讯，详细解析了从网页请求到数据存储的全流程；在学术文献方面，重点阐述了如何构建搜索请求和提取关键信息；对于电商评价，则说明了数据定位和清洗方法。文章还探讨了爬虫优化策略及反爬机制应对方案，为数据获取工作提供了实用指南。通过系统学习这些技术，读者可以提升数据采集能力，为商业决策、学术研究和市场分析提供有力支持。
Windows11系统安装Isaac Sim和Isaac Lab记录
weixin_65198494的博客
12-13 517
本文介绍了在Windows 11系统上安装IsaacSim和IsaacLab的完整流程。硬件配置为RTX4060显卡、32GB内存，软件环境包括NVIDIA驱动591.44、CUDA12.8、PyTorch2.7.0和Python3.11。安装IsaacSim5.1的主要步骤包括：更新GPU驱动、安装CUDA、创建conda虚拟环境、开启长路径支持、更新pip后安装IsaacSim pip包。IsaacLab安装则需要克隆GitHub仓库，通过安装脚本完成。最后通过运行验证脚本确认安装成功。
Python核心编程笔记
Python核心笔记是对Python编程语言深入学习的一份详细文档，涵盖了从基础到高级的主题。文档的作者阿King在前言中表达了对Python的理解，强调Python是一种解释性的、支持面向对象的高级语言，具备简单且强大的特性，...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值