Python面向对象编程基础教程：从入门到实践-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00851/article/details/148523925

Python面向对象编程基础教程：从入门到实践

python-cheatsheet All-inclusive Python cheatsheet 项目地址: https://gitcode.com/gh_mirrors/pyt/python-cheatsheet

面向对象编程(Object-Oriented Programming, OOP)是现代编程语言中最重要的编程范式之一。Python作为一门多范式语言，对OOP提供了全面支持。本文将系统介绍Python中面向对象编程的四大核心概念：封装、继承、多态和抽象，帮助初学者掌握Python OOP的基础知识。

封装(Encapsulation)：保护数据安全

封装是OOP的基础概念之一，它通过隐藏对象的内部实现细节，仅暴露必要的接口来与外界交互。在Python中，封装主要通过命名约定来实现，而不是像Java等语言那样严格的访问控制。

Python中的访问控制

Python使用下划线前缀来表示变量和方法的访问级别：

公共成员(Public)：没有下划线前缀，可以在任何地方访问
受保护成员(Protected)：单下划线前缀(如_var)，约定只能在类及其子类中访问
私有成员(Private)：双下划线前缀(如__var)，Python会进行名称改写(name mangling)，只能在类内部访问

class BankAccount:
    def __init__(self):
        self._protected_balance = 100  # 受保护属性
        self.__private_pin = "1234"    # 私有属性
        
    def get_balance(self):
        return self._protected_balance
        
account = BankAccount()
print(account.get_balance())  # 正确: 通过方法访问受保护属性
print(account._protected_balance)  # 可以访问但不推荐
print(account.__private_pin)  # 报错: 无法直接访问私有属性

封装的优势在于：

防止外部代码随意修改对象内部状态
使代码更易于维护和修改
减少模块间的耦合度

继承(Inheritance)：代码复用与扩展

继承允许我们基于现有类创建新类，新类会继承父类的属性和方法，同时可以添加或修改功能。这是实现代码复用的重要手段。

继承的基本用法

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

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

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

dog = Dog("阿黄")
cat = Cat("小花")
print(dog.speak())  # 输出: 阿黄说: 汪汪!
print(cat.speak())  # 输出: 小花说: 喵喵!

继承的类型

Python支持多种继承方式：

单继承：一个子类继承一个父类
多重继承：一个子类继承多个父类
多级继承：形成继承链，如A→B→C

# 多重继承示例
class Flyable:
    def fly(self):
        return "我能飞!"

class Swimmable:
    def swim(self):
        return "我能游泳!"

class Duck(Flyable, Swimmable):
    pass

duck = Duck()
print(duck.fly())   # 输出: 我能飞!
print(duck.swim())  # 输出: 我能游泳!

使用继承时要注意：

优先使用组合而非继承
避免过深的继承层次
多重继承可能导致"菱形继承"问题

多态(Polymorphism)：同一接口不同实现

多态允许不同类的对象对同一消息做出不同的响应。在Python中，多态主要通过方法重写和鸭子类型实现。

方法重写实现多态

class Shape:
    def area(self):
        pass

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

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
        
    def area(self):
        return 3.14 * self.radius ** 2

shapes = [Rectangle(4,5), Circle(7)]
for shape in shapes:
    print(f"面积: {shape.area()}")  # 同一方法不同实现

鸭子类型(Duck Typing)

Python更推崇"鸭子类型"的多态实现方式： "如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子"

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

class Person:
    def speak(self):
        return "你好!"

def make_sound(obj):
    print(obj.speak())

make_sound(Dog())    # 输出: 汪汪!
make_sound(Person()) # 输出: 你好!

抽象(Abstraction)：简化复杂系统

抽象是通过隐藏不必要的细节，仅展示关键特征来处理复杂性的方法。在Python中，可以使用抽象基类(ABC)来实现抽象。

使用abc模块创建抽象类

from abc import ABC, abstractmethod

class Database(ABC):
    @abstractmethod
    def connect(self):
        pass
        
    @abstractmethod
    def query(self, sql):
        pass

class MySQL(Database):
    def connect(self):
        return "MySQL连接建立"
        
    def query(self, sql):
        return f"执行MySQL查询: {sql}"

# db = Database()  # 报错: 不能实例化抽象类
mysql = MySQL()
print(mysql.connect())
print(mysql.query("SELECT * FROM users"))

抽象的优势：