On this page

Python 面向对象

category: 编程语言

Python 面向对象编程(OOP)全面指南

面向对象编程(Object-Oriented Programming)是Python的核心编程范式之一。以下是Python OOP的详细说明：

1. 类与对象基础

类定义与实例化

class Dog:
    """狗类"""
    
    # 类属性（所有实例共享）
    species = "Canis familiaris"
    
    # 初始化方法（构造函数）
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age
    
    # 实例方法
    def bark(self):
        return f"{self.name} says woof!"

# 创建实例
my_dog = Dog("Buddy", 5)
print(my_dog.bark())  # "Buddy says woof!"
print(my_dog.species) # "Canis familiaris"

类与实例的关系

  • 类：对象的蓝图/模板
  • 对象：类的具体实例
  • 属性：对象的状态（数据）
  • 方法：对象的行为（函数）

2. 类组件详解

类属性 vs 实例属性

class Circle:
    # 类属性
    pi = 3.14159
    
    def __init__(self, radius):
        # 实例属性
        self.radius = radius
    
    def area(self):
        return self.pi * self.radius ** 2

c1 = Circle(5)
c2 = Circle(10)
print(c1.pi)  # 3.14159 (通过实例访问类属性)
print(Circle.pi)  # 3.14159 (通过类访问)

实例方法、类方法、静态方法

class MyClass:
    def instance_method(self):
        """实例方法，可访问实例和类"""
        return f"instance method called {self}"
    
    @classmethod
    def class_method(cls):
        """类方法，可访问类但不可访问实例"""
        return f"class method called {cls}"
    
    @staticmethod
    def static_method():
        """静态方法，不能访问类或实例"""
        return "static method called"

obj = MyClass()
print(obj.instance_method())
print(MyClass.class_method())
print(MyClass.static_method())

3. 面向对象三大特性

1. 封装

class BankAccount:
    def __init__(self, account_holder, balance=0):
        self._account_holder = account_holder  # 受保护属性
        self.__balance = balance  # 私有属性
    
    # 公开方法访问私有属性
    def get_balance(self):
        return self.__balance
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return True
        return False
    
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return True
        return False

account = BankAccount("Alice", 1000)
print(account.get_balance())  # 1000
account.deposit(500)
print(account.get_balance())  # 1500

2. 继承

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("子类必须实现此方法")

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

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

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

3. 多态

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

animal_sound(Dog("Buddy"))  # "Buddy says woof!"
animal_sound(Cat("Whiskers"))  # "Whiskers says meow!"

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

常用魔术方法

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages
    
    # 字符串表示
    def __str__(self):
        return f"{self.title} by {self.author}"
    
    def __repr__(self):
        return f"Book('{self.title}', '{self.author}', {self.pages})"
    
    # 长度
    def __len__(self):
        return self.pages
    
    # 比较
    def __eq__(self, other):
        return self.title == other.title and self.author == other.author

book = Book("Python", "Guido", 300)
print(str(book))  # "Python by Guido"
print(len(book))  # 300

运算符重载

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

v1 = Vector(2, 4)
v2 = Vector(1, 3)
print(v1 + v2)  # Vector(3, 7)
print(v1 * 3)   # Vector(6, 12)

5. 高级OOP概念

多重继承

class Flyable:
    def fly(self):
        return "I can fly!"

class Swimmable:
    def swim(self):
        return "I can swim!"

class Duck(Flyable, Swimmable):
    pass

duck = Duck()
print(duck.fly())   # "I can fly!"
print(duck.swim())  # "I can swim!"

方法解析顺序(MRO)

print(Duck.__mro__)  # 显示方法解析顺序

抽象基类(ABC)

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    
    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

# shape = Shape()  # 报错，不能实例化抽象类
rect = Rectangle(4, 5)
print(rect.area())  # 20

属性装饰器

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def celsius(self):
        """获取摄氏温度"""
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        """设置摄氏温度"""
        if value < -273.15:
            raise ValueError("温度不能低于绝对零度")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        """计算华氏温度（只读属性）"""
        return (self._celsius * 9/5) + 32

temp = Temperature(25)
print(temp.fahrenheit)  # 77.0
temp.celsius = 30
print(temp.fahrenheit)  # 86.0

6. 设计模式实现

单例模式

class Singleton:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

a = Singleton()
b = Singleton()
print(a is b)  # True

工厂模式

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

def get_pet(pet="dog"):
    pets = {
        "dog": Dog(),
        "cat": Cat()
    }
    return pets.get(pet, Dog())

pet = get_pet("cat")
print(pet.speak())  # "Meow!"

7. 最佳实践

  1. 遵循SOLID原则：

    • 单一职责原则
    • 开闭原则
    • 里氏替换原则
    • 接口隔离原则
    • 依赖倒置原则

  2. 命名约定：

    • 类名使用PascalCase
    • 方法和变量使用snake_case
    • 私有成员使用_前缀
    • 避免名称冲突使用__前缀（名称修饰）

  3. 组合优于继承：

    class Engine:
    def start(self):
        return "Engine started"
   
class Car:
    def __init__(self):
        self.engine = Engine()
       
    def start(self):
        return self.engine.start()

  4. 文档字符串：

    class MyClass:
    """类的简要描述
       
    详细描述...
    """
       
    def my_method(self, param1):
        """方法的描述
           
        Args:
            param1: 参数1的描述
               
        Returns:
            返回值的描述
        """
        pass

8. 实际应用示例

电子商务系统

class Product:
    def __init__(self, id, name, price):
        self.id = id
        self.name = name
        self.price = price
    
    def __str__(self):
        return f"{self.name} (${self.price:.2f})"

class ShoppingCart:
    def __init__(self):
        self.items = []
    
    def add_item(self, product, quantity=1):
        self.items.append({"product": product, "quantity": quantity})
    
    def total(self):
        return sum(item["product"].price * item["quantity"] for item in self.items)
    
    def __str__(self):
        if not self.items:
            return "购物车为空"
        return "\n".join(
            f"{item['product']} x{item['quantity']}" 
            for item in self.items
        ) + f"\n总计: ${self.total():.2f}"

# 使用示例
iphone = Product(1, "iPhone 13", 999.99)
macbook = Product(2, "MacBook Pro", 1999.99)

cart = ShoppingCart()
cart.add_item(iphone, 2)
cart.add_item(macbook)

print(cart)
"""
iPhone 13 ($999.99) x2
MacBook Pro ($1999.99) x1
总计: $3999.97
"""

9. 常见错误

  1. 忘记self参数：

    class MyClass:
    def method():  # 缺少self
        pass

  2. 混淆类属性和实例属性：

    class MyClass:
    items = []  # 类属性
       
    def add(self, item):
        self.items.append(item)  # 所有实例共享

  3. 不正确的继承：

    class A: pass
class B: pass
class C(A, B): pass
   
# 菱形继承问题
class D(A): pass
class E(A): pass
class F(D, E): pass

  4. 过度使用继承：

    # 错误：不合理的继承关系
class Employee: pass
class Manager(Employee, Database, Logger): pass

总结

Python面向对象编程提供了强大的工具来组织代码：

特性描述
类与对象数据与行为的封装
继承代码重用和层次结构
多态统一接口不同实现
封装数据隐藏和保护
魔术方法自定义类行为
设计模式解决常见问题的模板

掌握OOP可以让你构建更模块化、可维护和可扩展的Python应用程序。合理使用类和对象，遵循设计原则，能够显著提高代码质量。