Python 类（class）+ 接口（interface）零基础通俗教程

第一部分：Python 类（class）基础到进阶

一、先搞懂：类 和 对象 是什么

通俗理解

• 类：一张模板 / 图纸，定义一类事物有什么特征、能做什么事
• 对象：按照模板造出来的具体实物

举例子：人类 是类（模板），你、我、张三 就是一个个对象。类规定：人有名字、年龄（特征），会走路、说话（行为）。

面向对象核心

把 ** 数据（属性）和功能（方法）** 打包在一起，方便管理、复用代码。

二、第一个最简单的类

基础语法

# 定义类，关键字 class + 类名（规范：首字母大写）
class Person:
    # 暂时不写内容，pass 占位
    pass

# 用类 创建 对象（实例化）
p1 = Person()
p2 = Person()

print(p1)
print(p2)

运行结果会显示两个独立的对象地址，说明：同一个类可以创建无数个独立对象。

三、构造方法 init 给对象加属性

关键知识点

1. __init__：构造方法，创建对象时自动执行
2. self：固定第一个参数，代表当前自己这个对象
3. 用 self.变量名 给对象绑定独有特征（实例属性）

范例：给人类添加名字、年龄

class Person:
    # 初始化方法，创建对象自动触发
    def __init__(self, name, age):
        # self.name = 实例属性，每个对象自己独有
        self.name = name
        self.age = age

# 创建对象，传参给 __init__
p1 = Person("李四", 22)
p2 = Person("王五", 30)

# 直接访问对象的属性
print(p1.name, p1.age)
print(p2.name, p2.age)

输出：

李四 22
王五 30

四、实例方法：给对象添加行为

知识点

写在类里面、带 self 的函数 = 实例方法只有对象能调用，方法里可以使用自己的属性。

范例：人会说话、自我介绍

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

    # 自定义实例方法
    def say_hello(self):
        print(f"大家好，我是{self.name}，今年{self.age}岁")

# 使用
p1 = Person("赵六", 25)
# 对象调用方法
p1.say_hello()

输出：大家好，我是赵六，今年25岁

五、类属性：所有对象共享的数据

区别

• 实例属性：self.xxx，每个对象不一样（名字、年龄）
• 类属性：写在类内部、方法外面，所有对象共用一份

范例

class Person:
    # 类属性：全局共享
    species = "人类"

    def __init__(self, name, age):
        # 实例属性：各自独有
        self.name = name
        self.age = age

p1 = Person("小明", 18)
p2 = Person("小红", 19)

# 访问类属性
print(p1.species)
print(p2.species)

# 修改类属性，所有对象都会变
Person.species = "高级人类"
print(p1.species)

六、封装：私有属性 & 私有方法

知识点

Python 没有绝对私有，用双下划线 __ 开头，变成「伪私有」作用：保护关键数据，防止外部随意篡改。

范例

class Person:
    def __init__(self, name, id_card):
        self.name = name
        # 私有属性，外部不能直接访问
        self.__id_card = id_card

    # 提供公开方法，间接使用私有数据
    def show_id(self):
        print(f"身份证后4位：{self.__id_card[-4:]}")

p1 = Person("张三", "110101199001011234")
print(p1.name)
# 报错：无法直接访问私有属性
# print(p1.__id_card)

# 通过方法安全使用
p1.show_id()

七、继承：代码快速复用

通俗理解

新建一个子类，直接继承父类的所有属性和方法，不用重复写代码。

• 父类（父模板）：公共通用代码
• 子类（子模板）：在父类基础上，加自己独有的功能

基础继承范例

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

    def sleep(self):
        print(f"{self.name} 正在睡觉")

# 学生类 继承 人类
class Student(Person):
    # 子类独有方法
    def study(self):
        print(f"{self.name} 正在写代码")

# 子类对象，能直接用父类的方法
s1 = Student("小周")
s1.sleep()   # 继承父类
s1.study()   # 自己独有

进阶：super () 重写构造方法

子类需要扩展属性时，用 super() 调用父类逻辑：

class Student(Person):
    def __init__(self, name, school):
        # 先执行父类的初始化
        super().__init__(name)
        # 扩展自己的属性
        self.school = school

    def info(self):
        print(f"姓名：{self.name}，学校：{self.school}")

s1 = Student("小周", "理工大学")
s1.info()

八、多态：不同子类，同一个方法不同效果

通俗理解

父类定义统一方法，每个子类重写这个方法，运行时表现不一样。

范例

class Animal:
    def cry(self):
        pass

class Dog(Animal):
    def cry(self):
        print("汪汪汪")

class Cat(Animal):
    def cry(self):
        print("喵喵喵")

# 同一个方法，不同对象效果不同
d = Dog()
c = Cat()
d.cry()
c.cry()

九、常用魔术方法（必学）

类里以 __xxx__ 包裹的内置方法，自带特殊功能。

1. str 打印对象自定义内容

不加 __str__，打印对象只会显示内存地址，非常不友好。

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

    # 打印对象时自动执行
    def __str__(self):
        return f"人物：{self.name}"

p1 = Person("老李")
print(p1)

2. del 对象销毁时自动执行

class Person:
    def __del__(self):
        print("对象被销毁了")

p = Person()
del p

十、综合完整案例（实战级）

整合属性、方法、封装，完整可直接使用：

# 图书管理小案例
class Book:
    # 类属性
    category = "书籍"

    def __init__(self, title, price):
        self.title = title
        # 私有价格
        self.__price = price

    # 查询价格
    def get_price(self):
        return self.__price

    # 书籍介绍
    def intro(self):
        print(f"书名：{self.title}，分类：{self.category}，售价：{self.get_price()}")

# 实例化使用
b1 = Book("Python入门", 59)
b2 = Book("数据分析实战", 79)

b1.intro()
b2.intro()

---

第二部分：Python 中类似 interface 的实现方案

Python 没有专门的 interface 关键字（不像 Java/Go 有原生接口），但提供了 3 种完美替代接口的方案，完全能实现规定类必须实现哪些方法，不实现就报错的接口核心功能。

一、先搞懂：接口是干嘛的？

接口 = 一份硬性合同 / 规矩

1. 只规定必须实现哪些方法，不写方法具体逻辑；
2. 任何类想用这个接口，必须老老实实实现所有方法；
3. 不实现就直接报错，保证代码规范。

举例：规定所有交通工具必须实现 run() 方法，汽车、自行车都必须实现，适配前面学的继承与多态。

二、方案 1：最简伪接口（普通基类，新手首选）

用普通父类模拟接口，空方法主动抛异常，子类必须重写。优点：无需导入库、写法简单缺点：仅在调用方法时才报错，不会提前拦截

# 定义接口规范
class VehicleInterface:
    def run(self):
        raise NotImplementedError("子类必须重写 run 方法")

# 合规子类
class Car(VehicleInterface):
    def run(self):
        print("汽车公路行驶")

class Bike(VehicleInterface):
    def run(self):
        print("自行车骑行")

car = Car()
car.run()
bike = Bike()
bike.run()

错误示例（不实现方法）：

class Plane(VehicleInterface):
    pass

p = Plane()
p.run()  # 运行时报错

三、方案 2：官方标准接口（abc 抽象基类，项目推荐）

Python 内置 abc 模块，是工业级标准抽象接口：

1. 未实现抽象方法，直接无法实例化对象，强制校验；
2. 企业开发通用规范，约束性最强。

from abc import ABC, abstractmethod

# 抽象接口类
class AnimalInterface(ABC):
    @abstractmethod
    def cry(self):
        pass

    @abstractmethod
    def run(self):
        pass

# 完整实现，合法
class Dog(AnimalInterface):
    def cry(self):
        print("汪汪汪")
    def run(self):
        print("狗子奔跑")

dog = Dog()
dog.cry()

错误示例（缺方法直接无法创建对象）：

class Cat(AnimalInterface):
    def cry(self):
        print("喵喵喵")

cat = Cat()  # 直接报错，无法实例化

四、方案 3：灵活接口 Protocol（鸭子类型，3.8+）

无需强制继承，只要类拥有对应方法，就自动匹配接口，轻量化、高灵活。

from typing import Protocol

# 定义接口协议
class WorkInterface(Protocol):
    def work(self):
        ...

# 无需继承，只要有 work 方法就符合规范
class Student:
    def work(self):
        print("学生学习")

class Teacher:
    def work(self):
        print("老师授课")

# 统一多态调用
def do_work(obj: WorkInterface):
    obj.work()

do_work(Student())
do_work(Teacher())

五、三种接口方案选用规则

1. 新手小脚本、快速开发 → 普通基类伪接口
2. 正式项目、团队规范、强约束 → abc 抽象基类（首选）
3. 灵活解耦、不想强制继承 → typing.Protocol

---

整体核心总结

类核心知识点

1. class 定义类，类名() 实例化生成对象；
2. __init__ 构造方法初始化属性，self 指代当前实例；
3. 实例属性独属于单个对象，类属性全局共享；
4. 双下划线 __ 实现私有封装，保护内部数据；
5. 三大特性：封装、继承、多态，是面向对象核心；
6. super() 复用父类代码，魔术方法定制对象底层行为。

接口核心知识点

1. Python 无原生 interface 关键字，但可完全等效实现；
2. 接口作用：统一方法规范、强制约束子类、适配多态；
3. ABC + @abstractmethod 是最标准的官方抽象接口写法；
4. 类 + 抽象接口组合，是中大型项目 OOP 标准写法。