Python 学习第6天:面向对象基础,新手最容易卡住的一关

大家好，我是大华！

Python 的学习来到了第6天，面向对象基础。

为什么要用面向对象？

因为程序一旦变得复杂之后，用面向对象能把数据和行为收拢在一起，代码不会那么容易乱。通过封装、继承和多态，可以让代码变得更好维护、更好扩展。

一、核心理念：万物皆对象

面向对象编程的核心思想是：把数据和操作数据的方法封装在一起，形成一个对象。

假设你有一个小狗的类。这个类可以包含小狗的各种属性，比如狗的名字、年龄。里面还可以定义各种方法，比如让小狗躺着或者坐着。

二、三大核心概念

1. 类与对象

类： 是蓝图或模板，定义了这个类的对象将拥有什么属性（数据）和方法（函数）。对象： 是根据类创建出来的具体实例，拥有类中定义的属性和方法，但每个对象的数据可以独立不同。

基本语法：

# 定义一个类class Dog:    # 初始化方法（构造方法）    def __init__(self, name, age):        # self 代表当前对象的引用        self.name = name  # 实例属性        self.age = age    # 实例方法    def bark(self):        print(f"{self.name} 在汪汪叫！")    def get_human_age(self):        return self.age * 7# 创建对象（实例化）my_dog = Dog("阿黄", 3)your_dog = Dog("小黑", 5)# 访问属性和调用方法print(my_dog.name)  # 输出：阿黄print(your_dog.age) # 输出：5my_dog.bark()       # 输出：阿黄 在汪汪叫！print(f"{my_dog.name} 的人类年龄约是 {my_dog.get_human_age()} 岁")

输出结果

阿黄5阿黄 在汪汪叫！阿黄 的人类年龄约是 21 岁

__init__ 是类的构造方法，在对象创建的那一刻自动执行，用来给对象初始化属性。

例如：

• • self.name = name
• • self.age = age

表示：把传进来的数据，绑定到当前这个对象身上。

self 并不是关键字，而是一个约定俗成的名字，你可以写成其它的，比如 this，但在 python 里一般都会写 self。它始终指向“当前正在使用的那个对象”，用来区分不同实例的数据。

2. 封装

把数据（属性）和操作数据的方法（函数）打包在一起，并隐藏内部实现的细节。

通过公有方法来访问和修改私有属性，可以有效控制数据的合法性。

class BankAccount:    def __init__(self, owner, balance=0):        self.owner = owner        # 在属性名前加两个下划线 __ 表示私有属性（约定上的私有，并不是绝对不可访问）        self.__balance = balance    # 存款    def deposit(self, amount):        if amount > 0:            self.__balance += amount            print(f"成功存款 {amount}。当前余额：{self.__balance}")        else:            print("存款金额必须大于0")    # 取款    def withdraw(self, amount):        if 0 < amount <= self.__balance:            self.__balance -= amount            print(f"成功取款 {amount}。当前余额：{self.__balance}")            return amount        else:            print("取款失败，余额不足或金额无效")            return 0    def get_balance(self):        """查询余额的公有方法"""        return self.__balance# 使用account = BankAccount("小明", 1000)account.deposit(500)   # 成功存款 500。当前余额：1500account.withdraw(200)  # 成功取款 200。当前余额：1300# print(account.__balance) # 错误！AttributeError，无法直接访问私有属性print(account.get_balance()) # 通过公有方法访问：1300

输出结果

成功存款 500。当前余额：1500成功取款 200。当前余额：13001300

在这个例子中，__balance 被设计为私有属性，外面的代码无法直接随意修改余额，只能通过 deposit、withdraw 这些公有方法来操作。

这样做的好处是：

• • 防止外部直接篡改数据，保证数据安全性
• • 所有对余额的修改都经过校验逻辑，避免出现非法状态
• • 使用者只需要关心怎么用，不用关心内部怎么实现

3. 继承

一个类可以继承另一个类的属性和方法，从而实现代码重用和层次化分类。父类（基类）：被继承的类。子类（派生类）：继承的类。

# 父类class Animal:    def __init__(self, name):        self.name = name    def eat(self):        print(f"{self.name} 在吃东西。")# 子类继承父类class Cat(Animal):    def __init__(self, name, color):        # 调用父类的初始化方法        super().__init__(name)        self.color = color    # 子类特有的方法    def meow(self):        print(f"{self.name}（{self.color}）在喵喵叫~")# 使用my_cat = Cat("咪咪", "橘色")my_cat.eat()   # 继承自父类的方法：咪咪 在吃东西。my_cat.meow()  # 子类自己的方法：咪咪（橘色）在喵喵叫~

输出结果

咪咪 在吃东西。咪咪（橘色）在喵喵叫~

在这个例子中，Cat 并没有从零开始实现所有功能，而是继承了 Animal 的属性和方法。因此：

• • Cat 自动拥有了 name 属性
• • 也可以直接使用父类中的 eat() 方法
• • 只需要关注自己独有的特性，比如 color 和 meow()

super().__init__(name) 的作用是：调用父类的构造方法，完成父类部分的初始化，避免重复写相同代码。

继承的核心价值在于：

• • 提高代码复用率
• • 建立清晰的是什么的层次关系（Cat 是一种 Animal）
• • 让代码结构更清楚、可扩展性更强

4. 多态

不同类的对象对同一方法调用做出不同响应。这种情况一般通过方法重写来实现。

class Animal:    def speak(self):        pass  # 父类定义规范，具体由子类实现class Dog(Animal):    def speak(self):        return "汪汪！"class Cat(Animal):    def speak(self):        return "喵喵~"def animal_talk(animal_obj):    # 传入的对象只要有 speak 方法即可，不关心具体是什么类    print(animal_obj.speak())# 多态的体现dog = Dog()cat = Cat()animal_talk(dog)  # 输出：汪汪！animal_talk(cat)  # 输出：喵喵~

输出结果

汪汪！喵喵~

在这个例子中，animal_talk() 并不关心传进来的对象到底是 Dog 还是 Cat，它只负责调用 speak() 方法。

关键点在于：同样是 speak()，不同对象，给出的行为却不一样。

这就是多态的本质：同一接口，不同实现；同一调用，不同行为。

Animal 中的 speak() 相当于一个规范或者约定，具体怎么说话，由子类自己决定，这就是方法重写。

在 Python 中，多态并不依赖严格的继承关系，只要对象具备相同的方法，就可以被当成同一类来使用，这种特性也叫：

鸭子类型（Duck Typing）

“如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子。”

多态的价值在于：

• • 解耦代码，减少 if / else 判断
• • 提高扩展性，新增类型时不需要修改原有逻辑
• • 让代码更符合“对扩展开放，对修改关闭”的设计原则

今天的学习内容先到这里。感谢你的观看，如果有不对或者需要补充的地方，欢迎指正。

如果你觉得文章写的还不错，不妨点赞、推荐，转发给你的朋友看一下。