Python面向对象编程：类与对象的基础知识-CFANZ编程社区

面向对象编程（Object-Oriented Programming，简称OOP）是一种重要的编程范式，它以“对象”为核心，将数据和操作数据的方法绑定在一起。Python作为一种多范式编程语言，天然支持面向对象编程，并且提供了简洁的语法来定义类和创建对象。

以下是关于Python中类与对象的基础知识的详细讲解：

1. 类与对象的基本概念

类（Class）：类是抽象的概念，用于描述具有相同属性和行为的对象的模板或蓝图。
对象（Object）：对象是类的具体实例，包含具体的数据和行为。

类的定义

在Python中，使用class关键字定义一个类。类名通常采用驼峰命名法（CamelCase），例如MyClass。

class Person:
    # 初始化方法（构造函数）
    def __init__(self, name, age):
        self.name = name  # 属性
        self.age = age    # 属性

    # 方法
    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

创建对象

通过类名加括号的方式创建对象，相当于调用类的构造函数。

# 创建Person类的两个实例
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

# 调用对象的方法
person1.greet()  # 输出: Hello, my name is Alice and I am 25 years old.
person2.greet()  # 输出: Hello, my name is Bob and I am 30 years old.

2. 类的组成部分

一个类通常由以下几个部分组成：

属性（Attributes）：用于存储对象的状态或数据。
- 实例属性：每个对象独有的属性，如self.name。
- 类属性：所有对象共享的属性，定义在类内但不在任何方法中。
方法（Methods）：定义在类中的函数，用于表示对象的行为。
- 实例方法：作用于实例对象，第一个参数通常是self。
- 类方法：作用于类本身，使用@classmethod装饰器定义，第一个参数是cls。
- 静态方法：不依赖于类或实例，使用@staticmethod装饰器定义。

示例代码

class Circle:
    # 类属性
    pi = 3.14159

    # 初始化方法
    def __init__(self, radius):
        self.radius = radius  # 实例属性

    # 实例方法
    def area(self):
        return Circle.pi * self.radius ** 2

    # 类方法
    @classmethod
    def set_pi(cls, new_pi):
        cls.pi = new_pi

    # 静态方法
    @staticmethod
    def is_valid_radius(radius):
        return radius > 0

# 使用类属性、实例方法、类方法和静态方法
circle = Circle(5)
print(circle.area())  # 输出: 78.53975 (面积计算)

Circle.set_pi(3.14)  # 修改类属性
print(Circle.pi)     # 输出: 3.14

print(Circle.is_valid_radius(-1))  # 输出: False

3. 继承与多态

继承是面向对象编程的重要特性之一，允许子类继承父类的属性和方法，并可以扩展或重写它们。

继承的实现

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

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

# 子类
class Dog(Animal):
    def speak(self):
        print(f"{self.name} says Woof!")

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

# 多态示例
animals = [Dog("Buddy"), Cat("Kitty")]
for animal in animals:
    animal.speak()
# 输出:
# Buddy says Woof!
# Kitty says Meow!

关键点

继承：子类通过class Subclass(BaseClass)继承父类。
重写：子类可以覆盖父类的方法以实现特定行为。
多态：不同子类对同一方法有不同的实现，但可以通过统一接口调用。

4. 封装与访问控制

封装是指将数据（属性）和操作数据的方法绑定在一起，并通过访问控制限制外部对内部数据的直接访问。

私有属性与方法

在Python中，通过在属性或方法名称前加双下划线__实现私有化。

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

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited {amount}. New balance: {self.__balance}")
        else:
            print("Invalid amount.")

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrew {amount}. New balance: {self.__balance}")
        else:
            print("Insufficient funds or invalid amount.")

    def get_balance(self):  # 提供访问私有属性的接口
        return self.__balance

# 使用封装
account = BankAccount("Alice", 1000)
account.deposit(500)       # 输出: Deposited 500. New balance: 1500
account.withdraw(200)      # 输出: Withdrew 200. New balance: 1300
print(account.get_balance())  # 输出: 1300
# print(account.__balance)  # 报错：无法直接访问私有属性

5. 特殊方法（魔术方法）

Python中有一些以双下划线开头和结尾的方法（如__init__、__str__），称为特殊方法或魔术方法。这些方法允许我们自定义类的行为。

常见的特殊方法

__init__：初始化方法。
__str__：定义对象的字符串表示形式。
__repr__：定义对象的开发者友好的表示形式。
__add__：定义对象的加法行为。
__len__：定义对象的长度。

示例代码

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

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

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

# 使用特殊方法
p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1)         # 输出: Point(1, 2)
print(p1 + p2)    # 输出: Point(4, 6)