十五天Python系统学习教程第十天-优快云博客

📅 Day 10 详细学习计划：Python面向对象编程深入与项目实战

学习目标
✅ 掌握Python OOP高级特性（对比Java的继承/多态/接口）
✅ 理解Python特有的元类与描述符机制
✅ 实现设计模式在Python中的独特应用
✅ 完成ORM框架核心模块开发

一、Python与Java OOP核心差异对比

特性	Java	Python	关键差异
继承机制	单继承+接口多实现	多继承（MRO算法）	Python支持混入类（Mixin）
访问控制	`public/protected/private`	命名约定（`_protected`/`__private`）	Python无严格访问限制
抽象类	`abstract class` + `abstract method`	`abc.ABC` + `@abstractmethod`	Python需手动装饰
接口	`interface`关键字	抽象类/协议（Protocol）	Python鸭子类型优先
类方法	`static`方法	`@classmethod`装饰器	显式接收`cls`参数

二、Python高级OOP特性

2.1 属性控制（对比Java的getter/setter）

class User:  
    def __init__(self, name):  
        self._name = name  # 受保护属性  

    @property  
    def name(self):        # Getter（类似Java的getName）  
        return self._name.upper()  

    @name.setter  
    def name(self, value): # Setter（类似Java的setName）  
        if len(value) < 3:  
            raise ValueError("名字太短")  
        self._name = value  

user = User("Alice")  
user.name = "Bob"  # 自动调用setter

2.2 描述符协议（类似Java的PropertyDescriptor）

class PositiveNumber:  
    def __set_name__(self, owner, name):  
        self.name = name  

    def __get__(self, instance, owner):  
        return instance.__dict__[self.name]  

    def __set__(self, instance, value):  
        if value <= 0:  
            raise ValueError("必须为正数")  
        instance.__dict__[self.name] = value  

class Order:  
    price = PositiveNumber()  # 描述符应用  

order = Order()  
order.price = 100  # 合法  
order.price = -50  # 抛出ValueError

三、设计模式Python实现

3.1 工厂模式（对比Java的工厂类）

class PaymentMethod:  
    @classmethod  
    def create(cls, method_type):  
        if method_type == "wechat":  
            return WechatPay()  
        elif method_type == "alipay":  
            return Alipay()  
        raise ValueError("未知支付方式")  

class WechatPay:  
    def pay(self, amount):  
        print(f"微信支付: {amount}元")  

payment = PaymentMethod.create("wechat")

3.2 观察者模式（利用Python弱引用）

from weakref import WeakSet  

class NewsPublisher:  
    def __init__(self):  
        self._subscribers = WeakSet()  

    def subscribe(self, subscriber):  
        self._subscribers.add(subscriber)  

    def notify(self, news):  
        for sub in self._subscribers:  
            sub.update(news)  

class Subscriber:  
    def update(self, news):  
        print(f"收到新闻: {news}")  

publisher = NewsPublisher()  
sub = Subscriber()  
publisher.subscribe(sub)  
publisher.notify("Python 3.12发布!")

四、实战项目：微型ORM框架开发

4.1 需求分析

实现类到数据库表的映射
支持字段类型验证
生成CRUD SQL语句
提供查询API链式调用

4.2 核心实现

模型基类定义：

class ModelMeta(type):  
    def __new__(cls, name, bases, attrs):  
        fields = {}  
        for key, value in attrs.items():  
            if isinstance(value, Field):  
                fields[key] = value  
        attrs['_fields'] = fields  
        return super().__new__(cls, name, bases, attrs)  

class Model(metaclass=ModelMeta):  
    def __init__(self, **kwargs):  
        for name, field in self._fields.items():  
            value = kwargs.get(name, field.default)  
            setattr(self, name, value)  

    def save(self):  
        columns = ', '.join(self._fields.keys())  
        placeholders = ', '.join(['%s'] * len(self._fields))  
        sql = f"INSERT INTO {self.__class__.__name__} ({columns}) VALUES ({placeholders})"  
        print("执行SQL:", sql)

字段类型定义：

class Field:  
    def __init__(self, type_, default=None):  
        self.type = type_  
        self.default = default  

class IntegerField(Field):  
    def __init__(self, default=0):  
        super().__init__(int, default)  

class CharField(Field):  
    def __init__(self, max_length=255, default=''):  
        super().__init__(str, default)  
        self.max_length = max_length

用户模型示例：

class User(Model):  
    id = IntegerField()  
    name = CharField(max_length=50)  
    email = CharField(max_length=100)  

user = User(name="Alice", email="alice@example.com")  
user.save()  # 输出: INSERT INTO User (id, name, email) VALUES (%s, %s, %s)

五、Java开发者注意事项

类型系统差异

Python无编译期类型检查，需在运行时验证字段类型

def __setattr__(self, name, value):  
    if name in self._fields:  
        field = self._fields[name]  
        if not isinstance(value, field.type):  
            raise TypeError(f"{name} 必须是 {field.type} 类型")  
    super().__setattr__(name, value)

元类（Metaclass）应用
- Java注解处理器类似功能，但Python元类更灵活
- 慎用元类，优先使用类装饰器实现类似功能

多继承问题

使用super()遵循方法解析顺序（MRO）

class A:  
    def method(self):  
        print("A")  

class B(A):  
    def method(self):  
        super().method()  
        print("B")

六、扩展练习

实现查询构造器

class Query:  
    def __init__(self, model_class):  
        self.model = model_class  
        self._filters = []  

    def filter(self, **kwargs):  
        for key, value in kwargs.items():  
            self._filters.append(f"{key} = {value!r}")  
        return self  

    def build(self):  
        where = " AND ".join(self._filters)  
        return f"SELECT * FROM {self.model.__name__} WHERE {where}"  

query = Query(User).filter(name="Alice", email__contains="example")  
print(query.build())  # SELECT * FROM User WHERE name = 'Alice' AND email__contains = 'example'

添加数据库连接池

from queue import Queue  

class ConnectionPool:  
    def __init__(self, size=5):  
        self._pool = Queue(size)  
        for _ in range(size):  
            self._pool.put(create_connection())  

    def get_conn(self):  
        return self._pool.get()  

    def release_conn(self, conn):  
        self._pool.put(conn)

实现事务管理

class Transaction:  
    def __enter__(self):  
        self.conn = get_connection()  
        self.conn.begin()  
        return self.conn  

    def __exit__(self, exc_type, exc_val, exc_tb):  
        if exc_type:  
            self.conn.rollback()  
        else:  
            self.conn.commit()

通过第十天的学习，您将深入掌握：
1️⃣ Python OOP的高级特性与Java的差异
2️⃣ 元编程在框架开发中的应用
3️⃣ ORM核心原理与实现方法
4️⃣ Python设计模式的独特实现方式

本篇的分享就到这里了，感谢观看，如果对你有帮助，别忘了点赞+收藏+关注。