白骑士的Python教学进阶篇 2.1 面向对象编程（OOP）

白骑士所长

已于 2024-06-29 12:41:27 修改

阅读量1k

点赞数 33

分类专栏： Python 教学文章标签： python 开发语言

于 2024-06-28 13:32:42 首次发布

本文链接：https://blog.csdn.net/JeremyTC/article/details/140040876

版权

教学同时被 2 个专栏收录

224 篇文章 2 订阅

订阅专栏

Python

41 篇文章 0 订阅

订阅专栏

系列目录

上一篇：白骑士的Python教学基础篇 1.5 数据结构

面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它通过类和对象的概念来组织代码。OOP不仅使代码更具结构性和可读性，还促进了代码的重用和扩展。本文将详细介绍OOP的几个关键概念：类与对象、属性与方法、继承与多态、魔术方法与运算符重载。

类与对象

在面向对象编程中，类是对象的蓝图或模板，它定义了一类对象的共同属性和方法。对象是类的实例，通过类来创建对象。类与对象的关系类似于模具和制品，类是抽象的概念，而对象是具体的存在。

类的定义与对象的创建

在Python中，可以使用 ‘class’ 关键字定义类，使用类名加括号创建对象。下面是一个简单的例子：

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"{self.name} is barking.")

# 创建对象
dog1 = Dog("Buddy", 3)
dog2 = Dog("Lucy", 5)

# 调用对象的方法
dog1.bark()
dog2.bark()

在这个例子中，‘Dog’ 是一个类，‘dog1’ 和 ‘dog2’ 是 ‘Dog’ 类的实例（对象）。‘__init__’ 方法是类的构造方法，在创建对象时自动调用，用于初始化对象的属性。

属性与方法

属性是对象的状态或数据，方法是对象的行为或功能。类中的属性和方法定义了该类对象的特征和能力。

属性

属性分为实例属性和类属性。实例属性属于对象，每个对象有自己独立的一份。类属性属于类，所有对象共享同一份。

class Dog:
    species = "Canis familiaris"  # 类属性（犬属）

    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age  # 实例属性

# 创建对象
dog1 = Dog("Buddy", 3)
dog2 = Dog("Lucy", 5)

# 访问属性
print(dog1.name)  # Buddy
print(dog2.age)  # 5
print(Dog.species)  # Canis familiaris

方法

方法是定义在类内部的函数，分为实例方法、类方法和静态方法。实例方法操作实例属性，类方法操作类属性，静态方法既不操作实例属性也不操作类属性。

class Dog:
    species = "Canis familiaris"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):  # 实例方法
        print(f"{self.name} is barking.")

    @classmethod
    def get_species(cls):  # 类方法
        return cls.species

    @staticmethod
    def is_dog_older_than(dog, age):  # 静态方法
        return dog.age > age

# 调用方法
dog1 = Dog("Buddy", 3)
dog1.bark()  # Buddy is barking.
print(Dog.get_species())  # Canis familiaris
print(Dog.is_dog_older_than(dog1, 2))  # True

继承与多态

继承是面向对象编程的一个重要特性，它允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用。多态是指同一方法在不同对象上具有不同表现形式的能力。

继承

通过继承，子类可以扩展或修改父类的行为，而无需从头开始编写代码。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

# 创建对象
dog = Dog("Buddy")
cat = Cat("Kitty")

# 调用方法
print(dog.speak())  # Buddy says Woof!
print(cat.speak())  # Kitty says Meow!

在这个例子中，‘Dog’ 和 ’Cat‘ 类继承自 ’Animal‘ 类，并分别实现了自己的 ’speak‘ 方法。

多态

多态使得同一方法可以作用于不同类型的对象上，表现出不同的行为。多态的实现依赖于继承和方法重写。

def make_animal_speak(animal):
    print(animal.speak())

# 调用函数
make_animal_speak(dog)  # Buddy says Woof!
make_animal_speak(cat)  # Kitty says Meow!

在这个例子中，‘make_animal_speak’ 函数接受一个 ‘Animal’ 对象，并调用它的 ‘speak’ 方法。由于 ‘Dog’ 和 ‘Cat’ 类重写了 ‘speak’ 方法，不同的对象表现出不同的行为，这就是多态。

魔术方法与运算符重载

魔术方法（Magic Methods），也称为双下划线方法（Dunder Methods），是特殊的方法，它们以双下划线开头和结尾，提供了许多高级功能，例如运算符重载、对象的自定义行为等。

常见的魔术方法

‘__init__(self, ...)‘：构造方法，初始化对象。

’__str__(self)’：定义对象的字符串表示，用于 ‘print’ 函数。

‘__repr__(self)‘：定义对象的官方字符串表示，用于调试和开发。

’__add__(self, other)’：定义加法运算符 ‘+’ 的行为。

‘__len__(self)‘：定义内置函数 ‘len()’ 的行为。

’__getitem__(self, key)’：定义索引操作的行为。

运算符重载

运算符重载允许开发者定义自定义对象的运算符行为。

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

# 创建对象
v1 = Vector(2, 3)
v2 = Vector(4, 5)

# 运算符重载
v3 = v1 + v2

# 打印结果
print(v3)  # Vector(6, 8)

在这个例子中，‘Vector‘ 类重载了加法运算符 ’+‘，使得两个向量对象可以相加。