【30天玩转python】高级面向对象编程

高级面向对象编程

面向对象编程（Object-Oriented Programming，简称 OOP）是 Python 的核心编程范式之一。Python 不仅支持基础的面向对象特性，如类和对象，还支持更高级的特性，如继承、多态、封装、抽象以及元类等。这些特性使得 Python 的面向对象编程更具灵活性和可扩展性。

---

1. 类的继承

继承是面向对象编程中一个核心概念，它答应一个类继承另一个类的属性和方法。通过继承，子类可以复用父类的代码，同时也可以添加新的功能，或重写父类的功能。
1.1 单继承

单继承是指一个类只继承一个父类。在 Python 中，使用 class SubClass(ParentClass) 来定义子类。
示例：单继承

1. class Animal:
2.     def __init__(self, name):
3.         self.name = name
5.     def speak(self):
6.         print(f"{self.name} makes a sound.")
8. class Dog(Animal):
9.     def speak(self):
10.         print(f"{self.name} barks.")
12. dog = Dog("Buddy")
13. dog.speak()  # 输出: Buddy barks.

复制代码

1.2 多继承

Python 支持多继承，一个类可以同时继承多个父类。多继承虽然提供了灵活性，但也容易引发复杂性，尤其是涉及到多个父类有雷同方法时。
示例：多继承

1. class Animal:
2.     def move(self):
3.         print("Animal moves.")
5. class Flyer:
6.     def move(self):
7.         print("Flies in the air.")
9. class Bird(Animal, Flyer):
10.     pass
12. bird = Bird()
13. bird.move()  # 输出: Animal moves.

复制代码

Python 中使用 广度优先 算法来处置惩罚方法解析顺序（MRO），因此在继承链中，会优先调用第一个父类中的方法。
1.3 super() 函数

super() 函数用于调用父类的方法，特别是在重写子类中的方法时，可以借助 super() 调用父类的实现。
示例：使用 super() 调用父类方法

1. class Animal:
2.     def __init__(self, name):
3.         self.name = name
5.     def speak(self):
6.         print(f"{self.name} makes a sound.")
8. class Cat(Animal):
9.     def __init__(self, name, color):
10.         super().__init__(name)  # 调用父类的构造方法
11.         self.color = color
13.     def speak(self):
14.         super().speak()  # 调用父类的 speak 方法
15.         print(f"{self.name} meows.")
17. cat = Cat("Whiskers", "Gray")
18. cat.speak()

复制代码

---

2. 抽象类与接口

抽象类是不能被实例化的类，通常用于定义一些通用的接口，子类必须实现这些接口。Python 中可以使用 abc 模块定义抽象类。
2.1 抽象类

通过 abc.ABC 和 @abstractmethod 来定义抽象类及其抽象方法。
示例：定义抽象类

1. from abc import ABC, abstractmethod
3. class Shape(ABC):
4.     @abstractmethod
5.     def area(self):
6.         pass
8.     @abstractmethod
9.     def perimeter(self):
10.         pass
12. class Circle(Shape):
13.     def __init__(self, radius):
14.         self.radius = radius
16.     def area(self):
17.         return 3.14 * self.radius ** 2
19.     def perimeter(self):
20.         return 2 * 3.14 * self.radius
22. circle = Circle(5)
23. print(circle.area())       # 输出: 78.5
24. print(circle.perimeter())  # 输出: 31.4

复制代码

在上面的代码中，Shape 是一个抽象类，定义了 area 和 perimeter 这两个抽象方法，任何继承 Shape 的类必须实现这两个方法。

---

3. 封装与访问控制

封装是面向对象编程的另一个重要特性，它将数据和方法封装在类的内部，并提供对外的访问接口。Python 中使用定名约定来实现差别层次的封装和访问控制。
3.1 私有属性和方法

在 Python 中，以双下划线 __ 开头的属性或方法会被处置惩罚为类的私有属性或方法，无法直接从类外部访问。
示例：私有属性和方法

1. class Person:
2.     def __init__(self, name, age):
3.         self.__name = name  # 私有属性
4.         self.__age = age    # 私有属性
6.     def get_info(self):
7.         return f"Name: {self.__name}, Age: {self.__age}"
9. person = Person("Alice", 30)
10. print(person.get_info())  # 正常访问
11. # print(person.__name)    # 会报错，无法直接访问私有属性

复制代码

Python 通过名称改写机制（name mangling）将私有属性修改为 _ClassName__attribute，因此可以通过这种方式间接访问私有属性，但不发起这样做。

---

4. 多态

多态是指差别的对象可以以统一的接口调用差别的行为。在 Python 中，多态是通过继承和重写来实现的。
示例：多态

1. class Animal:
2.     def speak(self):
3.         raise NotImplementedError("Subclass must implement abstract method")
5. class Dog(Animal):
6.     def speak(self):
7.         return "Woof!"
9. class Cat(Animal):
10.     def speak(self):
11.         return "Meow!"
13. def animal_speak(animal):
14.     print(animal.speak())
16. dog = Dog()
17. cat = Cat()
19. animal_speak(dog)  # 输出: Woof!
20. animal_speak(cat)  # 输出: Meow!

复制代码

无论是 Dog 照旧 Cat，它们都继承自 Animal 并重写了 speak 方法。animal_speak() 函数可以接受任何继承 Animal 的实例，这就是多态的应用。

---

5. 元类

元类是用来创建类的类。在 Python 中，类是对象，而元类就是创建这些类的类。通过元类，开发者可以控制类的创建过程。
5.1 定义元类

可以通过继承 type 来自定义元类，并在类创建时修改类的行为。
示例：自定义元类

1. class Meta(type):
2.     def __new__(cls, name, bases, dct):
3.         print(f"Creating class {name}")
4.         return super().__new__(cls, name, bases, dct)
6. class MyClass(metaclass=Meta):
7.     pass
9. # 创建类 MyClass 时，元类 Meta 的 __new__ 方法会被调用
10. my_instance = MyClass()

复制代码

在上面的示例中，Meta 是一个元类，当 MyClass 被定义时，元类的 __new__ 方法会被调用。元类通常用于框架和库的计划，如 Django、Flask 等都使用了元类的概念。

---

6. 小结

在高级面向对象编程中，Python 提供了强大的功能和灵活性。继承、多态、封装等概念使得代码更易扩展和维护，而抽象类、接口和元类则提供了更深层次的控制能力。通过掌握这些高级 OOP 概念，开发者能够计划出更灵活、更模块化的程序。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。