掌握Python 这10个OOP技术，代码想写不好都难！

最新推荐文章于 2026-06-15 23:46:24 发布

原创

最新推荐文章于 2026-06-15 23:46:24 发布 · 1k 阅读

文章标签：

#python #开发语言

本文详细介绍了Python面向对象编程的10大关键技术，包括SOLID设计原则、@classmethod和@staticmethod的使用、装饰器的深入应用、继承与多态、插件化设计、元类与自定义类创建、descriptors属性控制、数据类高效利用、并发编程优化及property属性管理。通过这些技术，开发者可以写出更健壮、可维护和高效的Python代码。

2、使用@classmethod与@staticmethod 🎛️

7、使用 descriptors 精细化属性控制 🔒

10、使用property优雅管理属性 🏠

10.1 property装饰器基础

10.2 属性访问控制

10.3 自定义setter与getter

11、总结 🚀

关注我，Python学习不迷路，喜欢的给个赞和转发

1、面向对象设计原则 🛠️

1.1 SOLID原则简介

SOLID是面向对象设计的五大原则，由Robert C. Martin提出，每个字母分别代表单一职责原则（SRP）、开放封闭原则（OCP）、里氏替换原则（LSP）、接口隔离原则（ISP）和依赖倒置原则（DIP）。遵循这些原则可以构建出更健壮、可维护和可扩展的软件系统。

1.2 单一职责原则(SRP)

单一职责原则强调每个类或模块应该只有一个改变的原因。这意味着一个类只负责一个功能领域，如果需要修改，原因应该是这个功能领域的变更。例如，一个User类仅负责用户数据的存储和检索，而不涉及业务逻辑。

class User:
    def __init__(self, id, name):
        self.id = id
        self.name = name

    def get_user_info(self):
        return {"id": self.id, "name": self.name}

1.3 开放封闭原则(OCP)

开放封闭原则提倡软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。即在不修改原有代码的基础上，通过添加新的代码来增强功能。这通常通过继承和接口实现。

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

# 新增圆形无需修改Rectangle
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * (self.radius ** 2)

1.4 里氏替换原则(LSP)

里氏替换原则指出，在软件中，子类型必须能够替换掉它们的父类型，而不会影响程序的正确性。换句话说，使用父类的地方，都能透明地使用其子类的对象，不会引发异常或错误行为。

class Bird:
    def fly(self):
        print("Flying...")

class Pigeon(Bird):
    def fly(self):
        super().fly()  # 继承并可能增强功能

bird = Bird()
pigeon = Pigeon()

bird.fly()  # 输出: Flying...
pigeon.fly()  # 输出: Flying...

1.5 接口隔离原则(ISP)

接口隔离原则建议客户端不应依赖它不需要的接口。接口应该尽可能细化，以保证客户端仅依赖于它实际使用的功能。这可以通过定义多个专门的接口而不是一个庞大臃肿的接口来实现。

from typing import Protocol

class Drawable(Protocol):
    def draw(self):
        ...

class Printable(Protocol):
    def print_details(self):
        ...

class Shape(Drawable, Printable):
    def draw(self):
        print("Drawing the shape...")

    def print_details(self):
        print("Printing shape details...")

1.6 依赖倒置原则(DIP)

依赖倒置原则倡导高层模块不应依赖于低层模块，二者都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。这通常通过依赖注入等方式实现。

from abc import ABC, abstractmethod

class Notification(ABC):
    @abstractmethod
    def send(self, message: str):
        pass

class EmailNotification(Notification):
    def send(self, message: str):
        print(f"Sending email: {message}")

class SMSNotification(Notification):
    def send(self, message: str):
        print(f"Sending SMS: {message}")

class NotificationService:
    def __init__(self, notification: Notification):
        self.notification = notification

    def notify_user(self, user_id: int, message: str):
        self.notification.send(message)
        
# 使用时 ，选择具体的通知方式
service = NotificationService(EmailNotification())
service.notify_user(1, "Hello, this is an email notification.")

遵循这些原则，你的Python代码将更加健壮、灵活，且易于维护。

2、使用@classmethod与@staticmethod 🎛️

2.1 类方法优化代码结构

类方法通过@classmethod装饰器定义，它接收一个隐含的参数cls ，代表类本身而不是类的实例。这种方法适用于那些操作属于类级别而非特定实例的功能，比如工厂方法或者处理类变量。它有助于减少代码冗余，提高代码的组织性和可读性。

class Pizza:
    toppings = ["cheese", "tomato"]

    @classmethod
    def add_default_topping(cls, topping):
        cls.toppings.append(topping)

    @classmethod
    def get_available_toppings(cls):
        return cls.toppings

Pizza.add_default_topping("mushroom")
print(Pizza.get_available_toppings())  # 输出: ['cheese', 'tomato', 'mushroom']

2.2 静态方法提升模块性

静态方法通过@staticmethod装饰器定义，它不接收隐含的self或cls参数。这类方法通常与类的实例无关，可以视为与类关联的函数，用于组织逻辑或提供工具函数，提升代码模块化。

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

result = MathUtils.add(5, 3)
print(result)  # 输出: 8

2.3 实例方法与类方法对比应用

实例方法直接操作实例变量，通过self引用实例本身。类方法则操作类变量，通过cls引用类。选择哪种方法取决于操作的数据范围和目的。静态方法则独立于类实例和类变量，适用于通用函数。

• 实例方法示例:

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        return self.balance

account = BankAccount()
print(account.deposit(100))  # 输出: 100

• 类方法与实例方法对比:

class Counter:
    count = 0

    def __init__(self):
        Counter.increment_count()

    @classmethod
    def increment_count(cls):
        cls.count += 1

    def show_count(self):
        print(f"Instance Count: {self.count}")

counter1 = Counter()
counter2 = Counter()
counter1.show_count()  # 输出: Instance Count: 2

在这个例子中，increment_count作为类方法，每次创建Counter实例时都会增加类变量count的值，体现了类方法在管理类状态上的作用，而show_count作为实例方法，展示了当前实例对应的类变量值，但不会直接修改类变量。

关注我，Python学习不迷路，喜欢的给个赞和转发