第七章：面向对象编程

面向对象编程（Object-Oriented Programming，简称 OOP）是一种编程范式，它将程序结构化为对象的集合，每个对象包含数据和操作这些数据的方法。本章将介绍 Python 中的面向对象编程，包括类与对象、继承与多态、特殊方法与运算符重载等内容。

1. 类与对象

1.1 类的定义与实例化

在 Python 中，类是通过 class 关键字定义的。类是一种模板，用于创建对象。对象是类的实例，包含了类的属性和方法。

# 定义一个简单的类
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

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

# 实例化一个对象
my_dog = Dog("Buddy", 3)

# 访问对象的属性和方法
print(my_dog.name)       # 输出: Buddy
print(my_dog.age)        # 输出: 3
print(my_dog.bark())     # 输出: Buddy is barking.

1.2 类的属性与方法

类的属性是存储在类中的变量，用于保存对象的状态。而方法是定义在类中的函数，用于执行某些操作。

class Car:
    wheels = 4  # 类属性

    def __init__(self, make, model):
        self.make = make  # 实例属性
        self.model = model  # 实例属性

    def drive(self):
        return f"The {self.make} {self.model} is driving."

1.3 self 参数的使用

self 参数是指向实例本身的引用，用于访问实例的属性和方法。

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

    def meow(self):
        return f"{self.name} says meow."

my_cat = Cat("Whiskers")
print(my_cat.meow())  # 输出: Whiskers says meow.

2. 继承与多态

2.1 继承的基本概念

继承是一种面向对象编程的特性，允许一个类（子类）继承另一个类（父类）的属性和方法。继承可以实现代码的重用和扩展。

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

    def speak(self):
        pass

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

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

dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.speak())  # 输出: Buddy barks.
print(cat.speak())  # 输出: Whiskers meows.

2.2 方法重写与多态

方法重写是指在子类中重新定义父类的方法。多态性是指可以通过父类的引用调用子类的方法。

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

animal_sound(dog)  # 输出: Buddy barks.
animal_sound(cat)  # 输出: Whiskers meows.

2.3 使用 super() 函数

super() 函数用于调用父类的构造函数或方法。

class Parent:
    def greet(self):
        return "Hello from Parent"

class Child(Parent):
    def greet(self):
        parent_greet = super().greet()
        return f"{parent_greet} and Hello from Child"

child = Child()
print(child.greet())  # 输出: Hello from Parent and Hello from Child

3. 特殊方法与运算符重载

3.1 常见的特殊方法

特殊方法是以双下划线开头和结尾的方法，用于实现特定的操作，如初始化对象、字符串表示等。

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __str__(self):
        return f"'{self.title}' by {self.author}"

    def __len__(self):
        return len(self.title)

book = Book("1984", "George Orwell")
print(book)       # 输出: '1984' by George Orwell
print(len(book))  # 输出: 4

3.2 运算符重载的实现

运算符重载是指定义特殊方法，使得自定义对象可以使用内置运算符。

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 __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(5, 7)
v3 = v1 + v2
print(v3)  # 输出: Vector(7, 10)

以上就是本章的内容，通过学习面向对象编程，读者可以更好地组织和管理代码，使代码更加简洁和模块化。在接下来的章节中，我们将深入探讨 Python 的更多高级功能和应用。