Python 面向对象程序设计

引言

面向对象编程（Object-Oriented Programming, OOP）是一种编程范式，它通过“对象”来组织代码，使代码更加模块化、可复用和易于维护。Python 是一种支持面向对象编程的语言，本文将详细介绍 Python 中的面向对象编程概念和技术，包括类和对象的定义、创建实例、构造器、成员访问、继承等。

1 面向对象概述

面向对象编程的核心概念是类（Class）和对象（Object）。类是对象的蓝图，定义了对象的属性和方法。对象是类的实例，具有类中定义的属性和方法。

基本概念：

• 类（Class）：定义了一组对象的共同特征和行为。
• 对象（Object）：类的实例，具有类中定义的属性和方法。
• 属性（Attribute）：对象的状态信息，通常为变量。
• 方法（Method）：对象的行为，通常为函数。

2 定义类

在 Python 中，可以使用 class 关键字定义一个类。类中可以包含属性和方法。

示例：

# 定义一个简单的类
class Dog:
    # 类属性
    species = "Canis familiaris"

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

    # 实例方法
    def description(self):
        return f"{self.name} is {self.age} years old."

    # 另一个实例方法
    def speak(self, sound):
        return f"{self.name} says {sound}"

3 创建类的实例

创建类的实例时，需要调用类的构造器（即 __init__ 方法）并传递必要的参数。

示例：

# 创建 Dog 类的实例
my_dog = Dog("Buddy", 3)

# 访问实例属性
print(my_dog.name)  # 输出 Buddy
print(my_dog.age)   # 输出 3

# 调用实例方法
print(my_dog.description())  # 输出 Buddy is 3 years old.
print(my_dog.speak("Woof Woof"))  # 输出 Buddy says Woof Woof

4 创建 __init__() 方法

__init__ 方法是类的构造器，用于初始化对象的属性。当创建类的实例时，会自动调用 __init__ 方法。

示例：

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

    def introduce(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."

# 创建 Person 类的实例
person1 = Person("Alice", 25)
print(person1.introduce())  # 输出 Hello, my name is Alice and I am 25 years old.

5 创建类的成员并访问

类的成员包括属性和方法。可以在类中定义属性，并在对象中访问它们。

示例：

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0  # 默认值

    def get_description(self):
        return f"{self.year} {self.make} {self.model}"

    def read_odometer(self):
        return f"This car has {self.odometer_reading} miles on it."

# 创建 Car 类的实例
my_car = Car("Toyota", "Corolla", 2020)
print(my_car.get_description())  # 输出 2020 Toyota Corolla
print(my_car.read_odometer())   # 输出 This car has 0 miles on it.

6 访问限制

在 Python 中，可以通过命名约定来实现访问限制。常用的访问修饰符有：

• 公有（Public）：默认情况下，所有属性和方法都是公有的。
• 私有（Private）：以双下划线 __ 开头的属性或方法是私有的，只能在类内部访问。
• 受保护（Protected）：以单下划线 _ 开头的属性或方法是受保护的，虽然可以从外部访问，但建议不要直接访问。

示例：

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

# 创建 BankAccount 类的实例
account = BankAccount(1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance())  # 输出 1300

7 创建用于计算的属性

可以使用 @property 装饰器创建计算属性，这些属性在访问时会动态计算其值。

示例：

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def area(self):
        return 3.14 * self.radius ** 2

    @property
    def circumference(self):
        return 2 * 3.14 * self.radius

# 创建 Circle 类的实例
circle = Circle(5)
print(circle.area)         # 输出 78.5
print(circle.circumference)  # 输出 31.4

8 为属性添加安全保护机制

可以使用 @property 和 @属性名.setter 装饰器为属性添加访问控制，确保属性值的有效性。

示例：

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @property
    def width(self):
        return self._width

    @width.setter
    def width(self, value):
        if value > 0:
            self._width = value
        else:
            raise ValueError("Width must be positive")

    @property
    def height(self):
        return self._height

    @height.setter
    def height(self, value):
        if value > 0:
            self._height = value
        else:
            raise ValueError("Height must be positive")

    @property
    def area(self):
        return self.width * self.height

# 创建 Rectangle 类的实例
rect = Rectangle(10, 5)
print(rect.area)  # 输出 50

# 尝试设置无效的宽度
try:
    rect.width = -10
except ValueError as e:
    print(e)  # 输出 Width must be positive

9 继承的基本语法

继承允许一个类（子类）继承另一个类（父类）的属性和方法。这有助于代码重用和扩展。

示例：

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 和 Cat 类的实例
dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.speak())  # 输出 Buddy says Woof!
print(cat.speak())  # 输出 Whiskers says Meow!

10 方法重写

在子类中可以重写父类的方法，以提供特定于子类的实现。

示例：

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

    def speak(self):
        return f"{self.name} makes a sound."

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 和 Cat 类的实例
dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.speak())  # 输出 Buddy says Woof!
print(cat.speak())  # 输出 Whiskers says Meow!

11 派生类中调用基类的 __init__() 方法

在派生类中可以调用基类的 __init__() 方法，以初始化从基类继承来的属性。

示例：

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

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 调用基类的构造器
        self.breed = breed

    def speak(self):
        return f"{self.name} (a {self.breed}) says Woof!"

# 创建 Dog 类的实例
dog = Dog("Buddy", "Golden Retriever")
print(dog.speak())  # 输出 Buddy (a Golden Retriever) says Woof!

结论

本文详细介绍了 Python 中的面向对象编程概念和技术，包括类和对象的定义、创建实例、构造器、成员访问、继承等。通过掌握这些知识，你可以编写出更高效、更灵活的 Python 代码。