代码收藏家技术教程 2024-12-16

[Python] 类和对象：从基础到高级

文章目录

1. 什么是类和对象？

2. 定义类和创建对象

3. 类的属性和方法

4. 类的高级功能

5. 继承与多态

6. 封装与私有化

7. 组合与协作

8. 类的设计原则

总结

Python是一种面向对象编程（Object-Oriented Programming, OOP）的语言，这意味着它提供了用类和对象的方式来组织和管理代码的能力。在实际开发中，类和对象是实现代码模块化、重用性和可扩展性的核心。本文将从零开始，详细讲解Python中类和对象的概念、语法以及高级用法，助你掌握这项核心技能。

1. 什么是类和对象？

**类（Class）**是对象的蓝图或模板。它定义了对象的属性和行为。
**对象（Object）**是类的实例（Instance），通过类实例化而来。

用一个简单的比喻：

类是“模具”，定义了物体的形状和特性。

对象是用模具生产出来的“产品”，每个产品有相同的结构，但可以有不同的特性。

2. 定义类和创建对象

2.1 定义类

在Python中，使用class关键字定义类。一个最简单的类如下：

class Person:
    pass  # 空类，暂时不定义任何属性或方法

2.2 创建对象

使用类名加括号即可创建对象。例如：

person1 = Person()  # 创建一个Person类的实例
person2 = Person()  # 创建另一个实例

print(person1)  # 输出类似 <__main__.Person object at 0x...>
print(person2)  # 输出类似 <__main__.Person object at 0x...>

虽然person1和person2都是Person类的实例，但它们是不同的对象，有各自的内存地址。

3. 类的属性和方法

3.1 属性

属性是类中定义的数据。可以是类属性（共享）或实例属性（独立）。

class Person:
    species = "Homo sapiens"  # 类属性

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

3.2 方法

方法是类中定义的函数，用于描述对象的行为。
特殊方法__init__用于初始化对象的实例属性。

class Person:
    species = "Homo sapiens"

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

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

使用类的属性和方法：

person1 = Person("Alice", 30)
person2 = Person("Bob", 25)

# 访问实例属性
print(person1.name)  # 输出：Alice
print(person2.age)   # 输出：25

# 调用实例方法
print(person1.greet())  # 输出：Hello, my name is Alice and I am 30 years old.

4. 类的高级功能

4.1 类属性和实例属性的区别

class Test:
    class_attr = "I am a class attribute"

    def __init__(self):
        self.instance_attr = "I am an instance attribute"

# 类属性可以通过类或实例访问
print(Test.class_attr)  # I am a class attribute
obj = Test()
print(obj.class_attr)   # I am a class attribute

# 实例属性只能通过实例访问
print(obj.instance_attr)  # I am an instance attribute

4.2 类方法和静态方法

类方法使用@classmethod装饰器定义，操作类本身。

静态方法使用@staticmethod装饰器定义，与类或实例无关。

class MyClass:
    class_attr = "class attribute"

    @classmethod
    def class_method(cls):
        return f"Accessed {cls.class_attr} from class method"

    @staticmethod
    def static_method():
        return "This is a static method"

print(MyClass.class_method())  # 调用类方法
print(MyClass.static_method()) # 调用静态方法

4.3 魔术方法

魔术方法（Magic Methods）是以__开头和结尾的特殊方法，可以重载内置运算符或实现协议。

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(4, 5)
print(v1 + v2)  # 输出：Vector(6, 8)

5. 继承与多态

5.1 继承

继承（Inheritance）允许一个类基于另一个类创建。子类会继承父类的属性和方法。

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!

5.2 多态

多态（Polymorphism）允许调用同一接口的不同实现。

animals = [Dog("Buddy"), Cat("Kitty")]
for animal in animals:
    print(animal.speak())

6. 封装与私有化

封装（Encapsulation）是一种数据隐藏机制，通过将属性或方法定义为私有来限制访问。

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

account = BankAccount(100)
account.deposit(50)
print(account.get_balance())  # 输出：150

7. 组合与协作

除了继承，组合也是一种构建复杂类的常用方法。

class Engine:
    def start(self):
        return "Engine started"

class Car:
    def __init__(self, brand):
        self.brand = brand
        self.engine = Engine()  # 组合

    def start(self):
        return f"{self.brand} car: {self.engine.start()}"

car = Car("Toyota")
print(car.start())  # Toyota car: Engine started