Python元编程：非科班转码者的入门指南

关注

原创最新推荐文章于 2026-11-10 11:11:41 发布 1.2w 阅读 AI 写同款· GEO 优化 ›

GitHub Actions 自动化：5 个真实运维提效案例本文以5个真实运维场景为例，系统阐述GitHub Actions在自动化部署、巡检、故障响应、合规审计与多环境发布中的落地实践。从“手动登录服务器”到“提交即自动执行”，通过事件驱动、流水线化设计，实现流程标准化、可追溯与可回滚。建议优先落地定时巡检与故障响应，再推进自动部署与合规审计，最后统一发布审批与一键回滚，逐步构建低成本、高可靠的运维自动化体系。阅读详情

Python元编程：非科班转码者的入门指南

前言

大家好，我是第一程序员（名字大，人很菜）。作为一个非科班转码、正在学习Rust和Python的萌新，最近我开始接触元编程。元编程是一种编程范式，它允许程序在运行时操作代码本身，这听起来就很神奇。今天我想分享一下我对Python元编程的学习心得，希望能给同样是非科班转码的朋友们一些参考。

一、元编程基础

1.1 元编程的概念

元编程是指编写能够操作代码本身的代码，它包括：

运行时代码生成：在程序运行时动态生成代码
代码分析：分析代码的结构和行为
代码修改：在运行时修改代码的行为
元数据操作：操作代码的元数据（如类、函数的属性）

1.2 Python中的元编程特性

Python作为一门动态语言，提供了丰富的元编程特性：

动态类型：变量的类型可以在运行时改变
反射：可以在运行时检查和修改对象的属性和方法
装饰器：可以在不修改原函数代码的情况下增强函数功能
元类：可以控制类的创建过程
内置函数：如type()、getattr()、setattr()等

二、Python元编程常用工具

2.1 装饰器

装饰器是Python中最常用的元编程工具之一，它可以在不修改原函数代码的情况下增强函数的功能。

# 简单的装饰器示例
def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling function: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Function {func.__name__} returned: {result}")
        return result
    return wrapper

@log_decorator
def add(a, b):
    return a + b

result = add(5, 3)
# 输出:
# Calling function: add
# Function add returned: 8

2.2 元类

元类是创建类的类，它可以控制类的创建过程，是Python中最强大的元编程工具之一。

# 简单的元类示例
class Meta(type):
    def __new__(cls, name, bases, dct):
        # 在创建类之前修改类的属性
        dct['added_by_meta'] = True
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    def __init__(self, value):
        self.value = value

obj = MyClass(42)
print(obj.added_by_meta)  # 输出: True

2.3 反射

反射是指在运行时检查和修改对象的属性和方法。

# 反射示例
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"Hello, my name is {self.name}"

person = Person("Alice", 30)

# 检查对象的属性
print(hasattr(person, "name"))  # 输出: True
print(getattr(person, "name"))  # 输出: Alice

# 修改对象的属性
setattr(person, "age", 31)
print(person.age)  # 输出: 31

# 调用对象的方法
method = getattr(person, "greet")
print(method())  # 输出: Hello, my name is Alice

2.4 动态代码执行

Python提供了多种动态执行代码的方式，如exec()、eval()和compile()。

# 动态执行代码示例
# 使用eval执行表达式
result = eval("1 + 2 * 3")
print(result)  # 输出: 7

# 使用exec执行语句
code = """
def multiply(a, b):
    return a * b

print(multiply(5, 6))
"""
exec(code)  # 输出: 30

# 使用compile编译代码
code_obj = compile("print('Hello from compiled code')", "<string>", "exec")
exec(code_obj)  # 输出: Hello from compiled code

三、Python元编程实践

3.1 装饰器的高级应用

# 带参数的装饰器
def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            results = []
            for i in range(n):
                results.append(func(*args, **kwargs))
            return results
        return wrapper
    return decorator

@repeat(3)
def say_hello(name):
    return f"Hello, {name}!"

result = say_hello("Alice")
print(result)  # 输出: ['Hello, Alice!', 'Hello, Alice!', 'Hello, Alice!']

# 类装饰器
class Timer:
    def __init__(self, func):
        self.func = func
    
    def __call__(self, *args, **kwargs):
        import time
        start = time.time()
        result = self.func(*args, **kwargs)
        end = time.time()
        print(f"{self.func.__name__} took {end - start:.4f} seconds")
        return result

@Timer
def slow_function():
    import time
    time.sleep(1)
    return "Done"

result = slow_function()
# 输出: slow_function took 1.0005 seconds

3.2 元类的应用

# 单例模式实现
class Singleton(type):
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Database(metaclass=Singleton):
    def __init__(self, connection_string):
        self.connection_string = connection_string
        print(f"Connecting to database: {connection_string}")

# 创建两个实例，但实际上是同一个对象
db1 = Database("localhost:5432")
db2 = Database("localhost:5432")
print(db1 is db2)  # 输出: True

# 自动注册子类
class PluginRegistry(type):
    plugins = []
    
    def __new__(cls, name, bases, dct):
        new_class = super().__new__(cls, name, bases, dct)
        if name != "Plugin":  # 排除基类
            cls.plugins.append(new_class)
        return new_class

class Plugin(metaclass=PluginRegistry):
    pass

class DatabasePlugin(Plugin):
    pass

class AuthPlugin(Plugin):
    pass

print(PluginRegistry.plugins)  # 输出: [<class '__main__.DatabasePlugin'>, <class '__main__.AuthPlugin'>]

3.3 反射的应用

# 动态加载模块
import importlib

# 动态导入模块
module_name = "math"
math_module = importlib.import_module(module_name)
print(math_module.sqrt(16))  # 输出: 4.0

# 动态调用方法
class Calculator:
    def add(self, a, b):
        return a + b
    
    def subtract(self, a, b):
        return a - b
    
    def multiply(self, a, b):
        return a * b
    
    def divide(self, a, b):
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return a / b

calc = Calculator()

# 动态选择要调用的方法
operation = "add"
method = getattr(calc, operation)
result = method(5, 3)
print(f"5 + 3 = {result}")  # 输出: 5 + 3 = 8

operation = "multiply"
method = getattr(calc, operation)
result = method(5, 3)
print(f"5 * 3 = {result}")  # 输出: 5 * 3 = 15