Python（四）

本文最后更新于：2024年5月25日 晚上

面向对象编程

Python面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它通过将数据和方法绑定成一个对象来实现程序设计和代码重用的思想。Python从设计之初就已经是一门面向对象的语言，因此在Python中创建类和对象是非常容易的。

基本概念

类是定义对象的模板，包含了对象的属性和方法。类通过继承、多态等机制实现代码的复用和扩展。

对象是类的实例，每个对象都有其独特的属性和方法。对象可以通过类进行实例化。

属性是对象的数据部分，可以通过类中的__init__方法进行初始化。

方法是类中定义的函数，用于操作对象的属性。方法可以访问和修改对象的状态。

继承是指一个类可以继承另一个类的属性和方法，从而实现代码的复用。

多态是指不同类的对象可以对同一消息做出响应，即同一接口下不同的实现方式。

创建类和对象

在Python中创建类和对象的步骤如下：

使用关键字class来定义一个类。类名通常以大写字母开头，并且每个单词的首字母都大写。

1
2
3
4
class Person:
    def __init__(self, name, age):
        self.name  = name
        self.age  = age

使用类名加上括号来创建对象实例。

1
p1 = Person("张三", 30)

可以通过对象实例访问其属性和方法。

1
2
print(p1.name )  # 输出: 张三
print(p1.age )   # 输出: 30

特殊方法

Python中的类还有一些特殊方法，如__init__、__str__、__repr__等，这些方法用于初始化对象、返回字符串表示形式等。

例如，__init__方法用于初始化对象：

1
2
3
4
class Person:
    def __init__(self, name, age):
        self.name  = name
        self.age  = age

__str__方法用于返回对象的字符串表示形式：

1
2
3
4
5
6
7
class Person:
    def __init__(self, name, age):
        self.name  = name
        self.age  = age

    def __str__(self):
        return f"{self.name } is {self.age } years old."

继承和多态

继承允许新创建的类继承现有类的属性和方法，从而避免重复代码。多态则是指不同类的对象可以对同一消息做出响应。

例如，假设有一个基类Animal，以及一个继承自Animal的子类Dog：

1
2
3
4
5
6
7
class Animal:
    def sound(self):
        print("The animal makes a sound.")

class Dog(Animal):
    def sound(self):
        print("The dog barks.")

在这个例子中，Dog类通过继承Animal类并覆盖sound方法，实现了多态。

总结

Python面向对象编程通过类和对象的概念，将数据和行为封装在一起，使得代码更加模块化、易于维护和扩展。通过学习和掌握面向对象编程的基本概念和技巧，可以有效地提高编程能力和项目开发效率。

类和对象的高级特性

在Python中，面向对象编程（OOP）具有许多高级特性，这些特性使得类和对象的功能更加强大和灵活。以下是一些主要的高级特性：

  1. 特殊方法：
    • __init__：构造函数，用于初始化对象。
    • __str__：返回对象的字符串表示形式。
    • __repr__：返回对象的描述性字符串表示形式。
    • __len__：返回对象的长度。
    • __add__、__sub__、__mul__、__div__、__mod__、__pow__：分别对应加、减、乘、除、取模、幂运算。
    • __eq__、__ne__、__lt__、__gt__、__le__、__ge__：分别对应等于、不等于、小于、大于、小于等于、大于等于。
    • __call__：使对象可以像函数一样被调用。
  2. 访问控制：
    • 属性装饰器（getter、setter、deleter）用于控制属性的读写权限。
  3. 继承和多态：
    • 继承机制允许一个类继承另一个类的属性和方法。
    • 多态是指不同类的对象可以通过相同的接口进行操作。
  4. 类方法和静态方法：
    • 类方法是在类级别上操作的方法，可以通过类本身或类的实例调用。类方法使用 @classmethod 装饰器来定义，并且第一个参数是类本身（通常命名为 cls）。
    • 静态方法是与类相关的方法，但不需要类的实例即可调用。静态方法使用 @staticmethod 装饰器来定义。
  5. 数据封装：
    • 数据封装是将数据（属性）和操作数据的代码（方法）捆绑在一起，使得对象的内部状态对外部隐藏，从而提高了代码的安全性和可维护性。
  6. 多重继承：
    • 多重继承允许一个类同时继承多个基类的属性和方法。
  7. 元类：
    • 元类是创建类的类，可以用来定义如何创建类本身。元类可以用来实现更复杂的类创建逻辑，如自动注册类实例等。
  8. 单例模式：
    • 单例模式确保一个类只有一个实例，并提供一个全局访问点来获取这个唯一实例。
  9. 迭代器和生成器：
    • 迭代器用于逐个访问序列中的元素，生成器则用于延迟计算，节省内存。
  10. 上下文管理器：
    • 上下文管理器用于资源管理，如文件打开、锁定等。
  11. 协程：
    • 协程是一种轻量级线程，用于非阻塞的并发编程。
  12. 闭包：
    • 闭包用于保存函数局部变量的引用，以便在函数外部访问这些变量。
  13. 内存管理：
    • Python提供了垃圾回收机制来自动管理内存，减少内存泄漏的风险。

多态性

在Python中实现多态性主要通过以下几种方式：

  1. 方法重写：子类可以重写父类中的同名方法，从而实现不同的行为。
  2. 接口（或抽象基类）：定义一个接口，子类必须实现这些方法。然后，可以编写接受接口的代码，这样就可以在运行时根据对象的实际类型调用相应的方法。
  3. 鸭子类型多态：只要一个对象具有某些特定的方法或属性，就可以被当作另一个对象使用，而无需考虑它们的具体类型。

下面提供一个具体的示例来说明如何在Python中实现多态性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 定义一个动物类
class Animal:
    def __init__(self, name):
        self.name  = name

    # 定义一个叫方法
    def speak(self):
        print(f"{self.name } says something")

# 定义一个猫类，继承自动物类，并重写speak方法
class Cat(Animal):
    def __init__(self, name):
        super().__init__(name)

    # 重写speak方法
    def speak(self):
        print(f"{self.name } meows")

# 定义一个狗类，继承自动物类，并重写speak方法
class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)

    # 重写speak方法
    def speak(self):
        print(f"{self.name } barks")

# 创建猫和狗的实例
cat = Cat("Kitty")
dog = Dog("Barky")

# 调用speak方法
cat.speak ()
dog.speak ()

在这个示例中，我们定义了一个Animal类和两个子类Cat和Dog。每个子类都重写了speak方法，以实现不同的行为。当我们创建猫和狗的实例并调用speak方法时，Python会自动调用正确的实现方式，从而实现多态性。

这种方式不需要显式地声明接口，只需关注对象的接口即可。

继承机制

Python中的继承机制是面向对象编程（OOP）三大特性之一，允许子类继承父类的属性和方法，从而实现代码的重用和扩展。在Python中，子类通过class关键字和父类名定义，可以支持单继承和多继承。

如何工作
  1. 单继承：子类继承一个父类的所有属性和方法。
    子类可以通过父类名来访问父类的成员，也可以使用super()函数调用父类的同名方法。
  2. 多继承：子类可以同时继承多个父类的属性和方法，这种机制在某些情况下可以简化代码，但也容易导致混乱和复杂性。
  3. 方法解析顺序（MRO）：在多继承的情况下，Python采用广度优先的顺序来解析方法调用，这意味着如果多个父类中有同名方法，Python会按照从左到右的顺序查找并调用相应的方法。
优点
  1. 代码复用：继承机制极大地提高了代码的复用性，使得子类可以继承父类和祖类的方法以及属性。
  2. 模块化和层次化：继承可以创建类体系，提高代码的模块化和层次化，有助于实现更清晰的设计。
  3. 易于扩展：通过继承，新类可以轻松添加或修改继承自父类的成员，方便进行功能的扩展和修改。
缺点
  1. 违背直观思维：继承表达的是一种“是”什么的关系，而不是“包含”什么的关系，这可能会让一些初学者感到困惑。
  2. 多重继承的复杂性：虽然多重继承可以简化代码，但它也容易导致混乱和复杂性，特别是在处理同名方法时。
  3. 子类化内置类型的缺点：子类化内置类型可能会破坏内置类型的行为，导致不可预测的结果。

Python中的继承机制通过允许子类继承父类的属性和方法，极大地提高了代码的复用性和模块化。

类定义的三种方法

在Python中，__init__、__str__和__repr__方法是类定义中的特殊方法，分别用于对象的初始化、字符串表示形式和如何重新创建对象。

  1. __init__ 方法：
    • 作用：__init__方法是一个特殊的函数，当创建一个类的新实例时，Python解释器会自动调用它。它的主要目的是初始化对象的状态，即设置对象的属性或执行必要的设置操作。
    • 使用场景：在每次创建新对象时，都可以通过__init__方法进行初始化设定。例如，可以在这个方法中为对象设置初始值、连接数据库等。
  2. __str__ 方法：
    • 作用：__str__方法用于定义一个对象的字符串表示形式。当我们通过使用print函数或将对象转换为字符串时，Python会调用这个方法来获取对象的字符串表示。
    • 使用场景：通常用于生成用户友好的输出，或者当需要将对象转换为字符串以便于阅读和传输时。
  3. __repr__ 方法：
    • 作用：__repr__方法返回一个字符串，该字符串描述了如何重新创建该对象。如果你将这个字符串传递给eval()函数，你将得到与原始对象相同的值。
    • 使用场景：当需要精确地描述如何重新创建对象时使用。例如，在调试过程中，开发者可能需要看到一个对象的详细信息，以便于复现问题或进行进一步的操作。

总结来说，__init__用于对象的初始化，__str__用于生成用户友好的字符串表示，而__repr__则用于生成可以重新创建对象的字符串表示。

Python
#类（class） #面向对象编程
Python（四）
https://forever0823.github.io/2024/05/25/class/
作者
Alan
发布于
2024年5月25日
许可协议