Python面向对象编程：10 大核心知识点 + 实战案例，从类到对象彻底掌握 OOP – 小白编程笔记

一、OOP基础：什么是类？什么是对象？

面向对象编程的核心，就是把现实世界的事物抽象成代码。我们可以用两个核心概念理解：

• 类（class）：相当于「图纸/模板」，定义事物的属性（特征）和方法（行为）
• 对象（object）：根据图纸创建的「具体实例」，是类的实际载体
• 核心关系：一个类可以创建无数个对象，所有对象共享类的结构

最简单的类与对象定义

# 定义类：class + 类名（大驼峰命名是行业惯例）
class Person:
    pass

# 创建对象：类名()
p1 = Person()
p2 = Person()

print(p1)  # 输出对象的内存地址
print(type(p1))  # 验证对象属于 Person 类

二、构造方法 __init__：初始化对象属性

__init__ 是类的构造方法，创建对象时会自动执行，核心作用是给对象初始化属性，是OOP的核心语法。

• 方法名前后必须是双下划线，少一个都会失效
• 第一个参数必须是 self，代表当前对象自己，不能省略
• 通过 self.属性名 定义的是实例属性，每个对象独有

class Person:
    # 构造方法：初始化对象的属性
    def __init__(self, name, age):
        self.name = name  # 实例属性：姓名
        self.age = age    # 实例属性：年龄

# 创建对象时，自动调用__init__，传入对应参数
p1 = Person("小明", 18)
p2 = Person("小红", 20)

# 访问对象的属性
print(p1.name)  # 输出：小明
print(p2.age)   # 输出：20

三、对象方法：让对象拥有行为

类中定义的函数叫做方法，由对象调用，用来表示对象的行为，是类的核心组成部分。对象方法的第一个参数必须是 self，通过它可以访问对象的属性和其他方法。

class Person:
    def __init__(self, name):
        self.name = name

    # 对象方法：第一个参数必须是self
    def speak(self):
        print(f"大家好，我是{self.name}")

    # 方法中可以访问对象的属性
    def introduce(self):
        print(f"我叫{self.name}，很高兴认识大家")

# 创建对象并调用方法
p1 = Person("小明")
p1.speak()       # 执行speak方法
p1.introduce()   # 执行introduce方法

四、三大特性之封装：隐藏细节，保护数据

封装是OOP的三大特性之一，核心是把属性和方法打包到类中，隐藏内部实现细节，只对外提供安全的访问接口，避免数据被随意修改。

私有属性与私有方法（__ 开头）

属性/方法名以 双下划线 __ 开头，就会变成私有成员，外部不能直接访问，只能通过类内部的公共方法访问，这是封装的核心实现。

class Person:
    def __init__(self, name, money):
        self.name = name       # 公共属性，外部可直接访问
        self.__money = money   # 私有属性，__开头，外部不能直接访问

    # 提供公共方法，安全访问私有属性
    def get_money(self):
        return self.__money

    # 提供公共方法，安全修改私有属性（可加校验）
    def set_money(self, new_money):
        if new_money >= 0:
            self.__money = new_money

p1 = Person("小明", 1000)
print(p1.name)          # 正常访问公共属性
# print(p1.__money)     # 报错：AttributeError，不能直接访问私有属性
print(p1.get_money())   # 通过公共方法访问
p1.set_money(2000)      # 通过公共方法修改
print(p1.get_money())

五、三大特性之继承：代码复用，扩展功能

继承是OOP的第二大特性，核心是子类可以复用父类的属性和方法，还能扩展自己的功能，大幅减少重复代码，让程序结构更清晰。

单继承基础语法

# 父类（基类）：定义通用属性和方法
class Person:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"我是{self.name}")

# 子类（派生类）：继承 Person，括号内写父类名
class Student(Person):
    pass

# 子类对象可以直接使用父类的属性和方法
s = Student("小明")
s.speak()  # 调用父类的speak方法

子类重写父类方法

子类可以定义和父类同名的方法，覆盖父类的实现，让子类拥有自己的行为，这是继承的核心技巧。

class Student(Person):
    # 重写父类的speak方法
    def speak(self):
        print(f"我是学生{self.name}，我在学习Python")

s = Student("小明")
s.speak()  # 执行子类重写后的方法

super()：调用父类方法

子类重写方法后，还可以通过 super() 调用父类的原始实现，避免重复编写代码，常用于子类扩展父类功能的场景。

class Student(Person):
    def __init__(self, name, score):
        super().__init__(name)  # 调用父类的构造方法，初始化name
        self.score = score      # 子类新增的属性

    def show(self):
        super().speak()        # 调用父类的speak方法
        print(f"我的成绩是：{self.score}")

s = Student("小明", 99)
s.show()

六、三大特性之多态：同一方法，不同表现

多态是OOP的第三大特性，核心是不同子类对象调用同一个方法，会表现出不同的行为。多态基于继承和方法重写实现，能大幅提升程序的灵活性和可扩展性。

# 父类：定义通用方法
class Animal:
    def shout(self):
        pass

# 子类1：重写shout方法
class Dog(Animal):
    def shout(self):
        print("汪汪汪")

# 子类2：重写shout方法
class Cat(Animal):
    def shout(self):
        print("喵喵喵")

# 同一个函数，接收不同的Animal子类对象，表现出不同行为
def make_shout(animal):
    animal.shout()

make_shout(Dog())  # 输出：汪汪汪
make_shout(Cat())  # 输出：喵喵喵

七、类属性、实例属性、类方法、静态方法

除了实例属性和对象方法，类还支持类属性、类方法和静态方法，用来实现不同的功能需求：

1. 类属性：所有对象共享

类属性定义在类内部、方法外部，属于类本身，所有对象共享同一个值，常用于统计对象数量、定义全局常量。

class Person:
    count = 0  # 类属性：统计创建的对象数量

    def __init__(self):
        Person.count += 1  # 每次创建对象，类属性+1

p1 = Person()
p2 = Person()
print(Person.count)  # 输出：2，所有对象共享类属性

2. 类方法 @classmethod

用 @classmethod 装饰的方法，第一个参数是 cls（代表类本身），可以通过类直接调用，也可以通过对象调用，常用于操作类属性。

class Person:
    @classmethod
    def test(cls):
        print("这是类方法", cls)

Person.test()  # 类直接调用，无需创建对象

3. 静态方法 @staticmethod

用 @staticmethod 装饰的方法，没有默认参数，和类、对象都无关，相当于定义在类内部的普通函数，常用于工具类方法。

class Person:
    @staticmethod
    def test():
        print("这是静态方法，和对象、类都无关")

Person.test()  # 类直接调用

八、综合实战案例：学生管理系统

结合上面所有知识点，我们来实现一个简单的学生管理系统，用类封装学生信息和管理功能，彻底掌握OOP的实际应用。

# 学生类：封装学生的属性和方法
class Student:
    def __init__(self, sid, name, score):
        self.sid = sid    # 学号
        self.name = name  # 姓名
        self.score = score# 成绩

    # 显示学生信息的方法
    def show(self):
        print(f"学号：{self.sid}，姓名：{self.name}，成绩：{self.score}")

# 学生管理类：封装学生的管理功能
class StudentManager:
    def __init__(self):
        self.student_list = []  # 存储所有学生的列表

    # 添加学生
    def add(self, student):
        self.student_list.append(student)
        print(f"成功添加学生：{student.name}")

    # 显示所有学生
    def show_all(self):
        print("\n=== 所有学生信息 ===")
        for s in self.student_list:
            s.show()

# 使用系统
if __name__ == "__main__":
    manager = StudentManager()
    # 添加学生
    manager.add(Student(1, "小明", 99))
    manager.add(Student(2, "小红", 95))
    manager.add(Student(3, "小刚", 90))
    # 显示所有学生
    manager.show_all()

九、高频易错点避坑指南：新手一次性避开

十、核心知识点总结：快速复习

本文是Python零基础入门系列的进阶篇，承接函数进阶内容。更多新手能直接上手的Python教程，可查看往期内容：
Python输入输出与格式化技巧、
Python变量与变量名全解析。