史上最全的Python面向对象知识点疏理("Python面向对象编程：史上最全知识点梳理与详解")

原创

ithorizon 7个月前 (10-20) 阅读数 29 #后端开发

Python面向对象编程：史上最全知识点梳理与详解

一、面向对象编程概述

面向对象编程（OOP）是一种编程范式，它将程序设计中的数据和对数据的操作封装在一起，形成“对象”。Python 是一种赞成面向对象编程的语言，具有类和对象的概念。以下是面向对象编程的核心知识点。

二、类与对象

类（Class）是面向对象编程的基础，它定义了一组具有相同属性和方法的对象。对象（Object）是类的实例，具有类定义的属性和方法。

2.1 类的定义


class MyClass:
    def __init__(self, value):
        self.value = value
    def display(self):
        print(self.value)

在上面的代码中，我们定义了一个名为 MyClass 的类，它有一个构造函数 __init__ 和一个方法 display。

2.2 创建对象


obj = MyClass(10)
obj.display()

创建对象时，会调用类的构造函数，并将对象赋给变量 obj。然后，我们可以调用对象的 display 方法。

三、类的属性和方法

类中的属性和方法是面向对象编程的核心概念。

3.1 类的属性

类的属性是类中定义的数据，它们用于存储对象的状态。类的属性可以是变量或常量。


class Person:
    species = "Human"  # 类变量
    def __init__(self, name):
        self.name = name  # 实例变量
p1 = Person("Alice")
print(p1.name)  # 输出: Alice
print(Person.species)  # 输出: Human

3.2 类的方法

类的方法是类中定义的函数，它们用于操作类的属性。


class Person:
    def __init__(self, name):
        self.name = name
    def say_hello(self):
        print(f"Hello, my name is {self.name}")
p1 = Person("Alice")
p1.say_hello()  # 输出: Hello, my name is Alice

四、继承与多态

继承和多态是面向对象编程的两大特性，它们促使代码更加模块化和可重用。

4.1 继承

继承允许子类继承父类的属性和方法。


class Animal:
    def speak(self):
        pass
class Dog(Animal):
    def speak(self):
        print("Woof!")
class Cat(Animal):
    def speak(self):
        print("Meow!")
dog = Dog()
cat = Cat()
dog.speak()  # 输出: Woof!
cat.speak()  # 输出: Meow!

4.2 多态

多态是指同一个操作作用于不同的对象时，会产生不同的执行于是。


def make_speak(animal):
    animal.speak()
make_speak(dog)  # 输出: Woof!
make_speak(cat)  # 输出: Meow!

五、封装与解耦

封装是指将对象的实现细节隐藏起来，只暴露必要的接口。解耦是指缩减不同模块之间的依存关系。

5.1 封装


class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.__odometer_reading = 0  # 私有属性
    def get_odometer_reading(self):
        return self.__odometer_reading
    def update_odometer(self, mileage):
        if mileage >= self.__odometer_reading:
            self.__odometer_reading = mileage
        else:
            raise ValueError("You can't roll back an odometer!")
car = Car("Tesla", "Model S", 2020)
print(car.get_odometer_reading())  # 输出: 0
car.update_odometer(23)
print(car.get_odometer_reading())  # 输出: 23

5.2 解耦

解耦可以通过使用接口、抽象类、依存注入等技术实现。


from abc import ABC, abstractmethod
class Engine(ABC):
    @abstractmethod
    def start(self):
        pass
class DieselEngine(Engine):
    def start(self):
        print("Diesel engine started")
class Car:
    def __init__(self, engine: Engine):
        self.engine = engine
    def start_engine(self):
        self.engine.start()
diesel_engine = DieselEngine()
car = Car(diesel_engine)
car.start_engine()  # 输出: Diesel engine started

六、其他面向对象编程知识点

除了上述核心知识点外，还有一些其他重要的面向对象编程概念。

6.1 类的静态方法和类方法


class MyClass:
    @staticmethod
    def static_method():
        print("Static method")
    @classmethod
    def class_method(cls):
        print(f"Class method, class: {cls.__name__}")
MyClass.static_method()  # 输出: Static method
MyClass.class_method()  # 输出: Class method, class: MyClass

6.2 属性装饰器


class Person:
    def __init__(self, name):
        self._name = name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, value):
        if not value:
            raise ValueError("Name cannot be empty")
        self._name = value
p1 = Person("Alice")
print(p1.name)  # 输出: Alice
p1.name = "Bob"
print(p1.name)  # 输出: Bob

6.3 Mixin

Mixin 是一种特殊类型的类，它用于组合多个类的功能。


class JsonMixin:
    def to_json(self):
        return json.dumps(self.__dict__)
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
class Employee(Person, JsonMixin):
    def __init__(self, name, age, employee_id):
        super().__init__(name, age)
        self.employee_id = employee_id
employee = Employee("Alice", 30, "E123")
print(employee.to_json())  # 输出: {"name": "Alice", "age": 30}