Python(二十七) 类、对象、实例和方法详解

1. 本篇学习范围

本篇专门讲 Python 面向对象中最基础、最核心的内容：

什么是类
什么是对象
什么是实例
什么是属性
什么是方法
self 的作用
__init__ 初始化方法
如何创建多个对象
如何让对象调用方法
类与普通函数、字典的简单对比
常见错误和注意事项

本篇不展开讲：

继承
多态
封装

因为这些内容适合在学生理解“类、对象、实例、方法”之后再学习。

2. 为什么要学习类与对象

在没有学习类之前，我们通常这样保存数据：

name = "张三"
age = 18
score = 90

如果只有一个学生，这样写没问题。

但是如果有多个学生：

name1 = "张三"
age1 = 18
score1 = 90

name2 = "李四"
age2 = 19
score2 = 85

name3 = "王五"
age3 = 17
score3 = 92

变量会越来越多，管理起来很麻烦。

我们也可以用字典保存一个学生：

student = {
    "name": "张三",
    "age": 18,
    "score": 90
}

如果有多个学生，可以用列表保存多个字典：

students = [
    {"name": "张三", "age": 18, "score": 90},
    {"name": "李四", "age": 19, "score": 85},
    {"name": "王五", "age": 17, "score": 92}
]

这种写法可以用，但如果每个学生不仅有数据，还有行为，比如：

自我介绍
修改成绩
判断是否及格
打印学生信息

就会发现，数据和操作数据的函数是分散的。

类与对象的作用，就是把一类事物的数据和行为放在一起管理。

通俗地说：

类让代码更像现实世界。
学生有姓名、年龄、成绩，也会自我介绍、参加考试。

3. 什么是类

类，英文是 class。

类可以理解为一种模板、图纸、说明书。

它描述一类事物共同具有的特征和行为。

例如，学生这一类事物：

共同特征：姓名、年龄、成绩
共同行为：自我介绍、学习、判断是否及格

在 Python 中，可以这样定义一个学生类：

class Student:
    pass

这里：

class 表示定义类。
Student 是类名。
pass 表示暂时什么都不写，只是占位。

类本身只是一个模板，不是具体的学生。

可以这样理解：

Student 类不是张三，也不是李四。
Student 类只是“学生模板”。

4. 什么是对象

对象是根据类创建出来的具体东西。

如果 Student 是学生模板，那么：

张三这个学生是一个对象。
李四这个学生也是一个对象。
王五这个学生也是一个对象。

创建对象的语法：

对象名 = 类名()

示例：

class Student:
    pass

stu = Student()

print(stu)

这里的 stu 就是一个对象。

5. 什么是实例

实例和对象在很多初学场景中可以理解为同一个意思。

更准确地说：

对象是通过类创建出来的实例。

例如：

class Student:
    pass

stu1 = Student()
stu2 = Student()

这里：

Student 是类。
stu1 是 Student 类的一个实例。
stu2 也是 Student 类的一个实例。
stu1 和 stu2 都是对象。

所以在教学中可以这样讲：

类是模板。
对象是用模板创建出来的具体东西。
实例就是某个类创建出来的对象。

6. 类、对象、实例的生活例子

6.1 学生例子

学生类：Student
学生对象：张三、李四、王五
学生实例：张三是 Student 的一个实例

6.2 手机例子

手机设计图：类
你手里的手机：对象
这一台具体手机：实例

6.3 汽车例子

汽车设计图：类
一辆具体的汽车：对象
这辆车就是汽车类的实例

一句话总结：

类是抽象的，对象是具体的。

7. 定义类的基本语法

语法：

class 类名:
    类中的代码

示例：

class Person:
    pass

类名通常使用大驼峰命名法。

大驼峰命名法的意思是：

每个单词首字母都大写。

推荐：

class Student:
    pass

class Teacher:
    pass

class BankAccount:
    pass

class ShoppingCart:
    pass

不推荐：

class student:
    pass

class bank_account:
    pass

虽然有些写法可以运行，但不符合常见代码规范。

8. 创建对象的基本语法

语法：

对象名 = 类名()

示例：

class Student:
    pass

stu = Student()

这里：

Student 是类。
Student() 表示创建对象。
stu 是对象名。

可以创建多个对象：

class Student:
    pass

stu1 = Student()
stu2 = Student()
stu3 = Student()

print(stu1)
print(stu2)
print(stu3)

这三个对象来自同一个类，但它们是三个不同的对象。

可以这样理解：

一个类可以创建多个对象。
一个模板可以造出多个实物。

9. 对象属性

属性就是对象身上的数据。

例如，一个学生对象可以有：

姓名
年龄
成绩
班级

给对象添加属性的语法：

对象名.属性名 = 属性值

示例：

class Student:
    pass

stu = Student()

stu.name = "张三"
stu.age = 18
stu.score = 90

print(stu.name)
print(stu.age)
print(stu.score)

输出：

张三
18
90

这里：

stu.name 是对象 stu 的 name 属性。
stu.age 是对象 stu 的 age 属性。
stu.score 是对象 stu 的 score 属性。

10. 不同对象可以有不同属性值

同一个类创建出来的对象，可以有不同的属性值。

class Student:
    pass

stu1 = Student()
stu1.name = "张三"
stu1.age = 18

stu2 = Student()
stu2.name = "李四"
stu2.age = 19

print(stu1.name, stu1.age)
print(stu2.name, stu2.age)

输出：

张三 18
李四 19

说明：

stu1 和 stu2 都是 Student 对象。
但是它们各自保存自己的 name 和 age。

这就是对象的意义：

同一类事物，有共同结构，但每个具体对象可以有自己的数据。

11. 什么是方法

方法就是定义在类里面的函数。

普通函数写在类外面：

def say_hello():
    print("你好")

方法写在类里面：

class Student:
    def say_hello(self):
        print("你好")

通俗理解：

属性表示对象有什么。
方法表示对象能做什么。

例如学生对象：

属性：姓名、年龄、成绩
方法：自我介绍、学习、判断是否及格

12. 定义方法的基本语法

语法：

class 类名:
    def 方法名(self):
        方法中的代码

示例：

class Student:
    def say_hello(self):
        print("大家好，我是一个学生")

调用方法：

stu = Student()
stu.say_hello()

完整代码：

class Student:
    def say_hello(self):
        print("大家好，我是一个学生")

stu = Student()
stu.say_hello()

输出：

大家好，我是一个学生

13. self 是什么

self 是学习类和对象时最重要的概念之一。

先看代码：

class Student:
    def introduce(self):
        print("我的名字是", self.name)

stu = Student()
stu.name = "张三"
stu.introduce()

输出：

我的名字是 张三

这里的 self 表示当前调用方法的对象。

可以这样记：

谁调用方法，self 就是谁。

例如：

class Student:
    def introduce(self):
        print("我的名字是", self.name)

stu1 = Student()
stu1.name = "张三"

stu2 = Student()
stu2.name = "李四"

stu1.introduce()
stu2.introduce()

输出：

我的名字是 张三
我的名字是 李四

当执行：

stu1.introduce()

此时 self 就是 stu1。

当执行：

stu2.introduce()

此时 self 就是 stu2。

14. self 不是关键字

严格来说，self 不是 Python 关键字。

下面的代码也能运行：

class Student:
    def introduce(this):
        print("大家好")

stu = Student()
stu.introduce()

但是非常不推荐这样写。

Python 社区约定：

实例方法的第一个参数统一写 self。

所以教学和开发中都应该写：

class Student:
    def introduce(self):
        print("大家好")

记忆：

self 不是硬性关键字，但必须按习惯写成 self。

15. 方法中访问对象属性

在类的方法中，访问对象属性要写：

self.属性名

示例：

class Student:
    def introduce(self):
        print(f"大家好，我叫{self.name}，今年{self.age}岁")

stu = Student()
stu.name = "张三"
stu.age = 18

stu.introduce()

输出：

大家好，我叫张三，今年18岁

如果不写 self：

class Student:
    def introduce(self):
        print(name)  # 错误

Python 会认为 name 是一个普通变量，而不是对象属性。

正确写法：

class Student:
    def introduce(self):
        print(self.name)

16. init 初始化方法

前面我们这样给对象添加属性：

stu = Student()
stu.name = "张三"
stu.age = 18

这种写法可以运行，但不够方便。

如果每创建一个对象都要手动添加属性，会很麻烦。

Python 提供了一个特殊方法：__init__()。

它通常用来在创建对象时初始化属性。

示例：

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

stu = Student("张三", 18)

print(stu.name)
print(stu.age)

输出：

张三
18

当执行：

stu = Student("张三", 18)

Python 会自动调用 __init__() 方法。

可以这样理解：

__init__ 是对象创建时自动执行的初始化方法。
它常用来给对象准备初始数据。

17. init 的执行过程

代码：

class Student:
    def __init__(self, name, age):
        print("正在初始化对象")
        self.name = name
        self.age = age

stu = Student("张三", 18)

输出：

正在初始化对象

创建对象时：

Student("张三", 18)

Python 会做几件事：

1. 创建一个新的 Student 对象。
2. 自动调用 __init__ 方法。
3. 把新对象传给 self。
4. 把 "张三" 传给 name。
5. 把 18 传给 age。
6. 在对象中保存 name 和 age 属性。

所以：

self.name = name
self.age = age

就是把传进来的数据保存到对象身上。

18. 初始化多个属性

示例：

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

    def introduce(self):
        print(f"我叫{self.name}，今年{self.age}岁，成绩是{self.score}分")

stu = Student("张三", 18, 90)
stu.introduce()

输出：

我叫张三，今年18岁，成绩是90分

这里：

name、age、score 是创建对象时传入的数据。
self.name、self.age、self.score 是保存在对象上的属性。

19. 参数名和属性名可以不同

通常我们会写：

self.name = name

左边和右边名字一样，比较好理解。

但它们也可以不同：

class Student:
    def __init__(self, student_name):
        self.name = student_name

stu = Student("张三")
print(stu.name)

输出：

张三

解释：

student_name 是参数名。
self.name 是对象属性名。

教学中推荐初学者先使用同名写法：

self.name = name

因为更直观。

20. 实例属性

实例属性就是属于具体对象的属性。

对象也叫实例，所以实例属性也可以理解为对象属性。

示例：

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

stu1 = Student("张三", 18)
stu2 = Student("李四", 19)

print(stu1.name)
print(stu2.name)

输出：

张三
李四

这里的 name 和 age 都是实例属性。

每个对象都有自己的一份数据。

stu1.name 和 stu2.name 互不影响。

21. 实例方法

实例方法就是属于对象的方法。

实例方法的特点：

定义在类里面。
第一个参数是 self。
通过对象调用。
可以访问对象自己的属性。

示例：

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def show_info(self):
        print(f"姓名：{self.name}，成绩：{self.score}")

stu = Student("张三", 90)
stu.show_info()

输出：

姓名：张三，成绩：90

这里的 show_info() 就是实例方法。

22. 方法可以有参数

方法除了 self，还可以有其他参数。

示例：修改成绩。

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def update_score(self, new_score):
        self.score = new_score

stu = Student("张三", 80)

stu.update_score(95)

print(stu.score)

输出：

这里：

self 表示当前对象。
new_score 表示调用方法时传入的新成绩。

调用：

stu.update_score(95)

只需要传入 95，不需要手动传入 self。

Python 会自动把 stu 传给 self。

23. 方法可以有返回值

方法和普通函数一样，也可以使用 return 返回结果。

示例：判断成绩是否及格。

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def is_passed(self):
        return self.score >= 60

stu1 = Student("张三", 90)
stu2 = Student("李四", 55)

print(stu1.is_passed())
print(stu2.is_passed())

输出：

True
False

方法中的：

return self.score >= 60

会返回一个布尔值。

24. 方法中调用其他方法

一个方法可以调用同一个对象中的另一个方法。

调用时使用：

self.方法名()

示例：

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def is_passed(self):
        return self.score >= 60

    def show_result(self):
        if self.is_passed():
            print(f"{self.name}考试通过")
        else:
            print(f"{self.name}考试不通过")

stu = Student("张三", 90)
stu.show_result()

输出：

张三考试通过

这里：

self.is_passed()

表示当前对象调用自己的 is_passed() 方法。

25. 对象方法会影响对象自己的属性

方法可以修改当前对象的属性。

示例：

class Counter:
    def __init__(self):
        self.count = 0

    def add_one(self):
        self.count += 1

counter = Counter()

counter.add_one()
counter.add_one()
counter.add_one()

print(counter.count)

输出：

这里：

counter 对象有一个 count 属性。
每调用一次 add_one()，count 就加 1。

26. 多个对象互不影响

同一个类创建出来的多个对象，各自保存自己的实例属性。

class Counter:
    def __init__(self):
        self.count = 0

    def add_one(self):
        self.count += 1

c1 = Counter()
c2 = Counter()

c1.add_one()
c1.add_one()
c2.add_one()

print(c1.count)
print(c2.count)

输出：

2
1

说明：

c1 和 c2 是两个不同对象。
c1.count 和 c2.count 互不影响。

27. 对象的身份 id

每个对象在内存中都有自己的身份。

可以使用 id() 查看对象身份。

class Student:
    pass

stu1 = Student()
stu2 = Student()

print(id(stu1))
print(id(stu2))

输出会是两个不同的数字。

这说明：

stu1 和 stu2 是两个不同对象。

也可以使用 is 判断两个变量是否指向同一个对象。

class Student:
    pass

stu1 = Student()
stu2 = Student()
stu3 = stu1

print(stu1 is stu2)
print(stu1 is stu3)

输出：

False
True

解释：

stu1 和 stu2 是两个不同对象。
stu3 和 stu1 指向同一个对象。

28. 类中的代码缩进

类中的方法必须写在类的缩进内部。

正确：

class Student:
    def say_hello(self):
        print("你好")

错误：

class Student:
    pass

def say_hello(self):
    print("你好")

第二段代码中的 say_hello 是普通函数，不是 Student 类的方法。

调用：

stu = Student()
stu.say_hello()

会报错。

教学提示：

看一个函数是不是方法，关键看它有没有缩进在 class 里面。

29. 类中的方法顺序

一般建议把 __init__ 写在类的前面。

常见顺序：

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def show_info(self):
        print(self.name, self.score)

    def is_passed(self):
        return self.score >= 60

这样读代码时，先看到对象初始化了哪些属性，再看对象有哪些方法。

30. 打印对象

默认打印对象时，输出通常不太直观。

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

stu = Student("张三")
print(stu)

输出类似：

<__main__.Student object at 0x...>

这表示它是一个 Student 对象，以及它在内存中的大致位置。

如果只是教学基础，可以先告诉学生：

看到这种输出，说明打印的是对象本身，不是对象的某个属性。

如果想打印姓名，应该写：

print(stu.name)

输出：

张三

31. str 方法简单了解

如果希望打印对象时显示更友好的内容，可以定义 __str__ 方法。

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

    def __str__(self):
        return f"学生：{self.name}，年龄：{self.age}"

stu = Student("张三", 18)
print(stu)

输出：

学生：张三，年龄：18

注意：

__str__ 必须返回字符串。

错误写法：

def __str__(self):
    print(self.name)

正确写法：

def __str__(self):
    return self.name

32. 对象列表

实际开发中，经常会把多个对象放到列表中。

示例：

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def show_info(self):
        print(f"{self.name}: {self.score}")

students = [
    Student("张三", 90),
    Student("李四", 85),
    Student("王五", 78)
]

for stu in students:
    stu.show_info()

输出：

张三: 90
李四: 85
王五: 78

解释：

students 是列表。
列表里的每一个元素都是 Student 对象。
for 循环取出每个对象，再调用对象的方法。

33. 筛选对象列表

可以根据对象属性筛选对象。

示例：找出及格学生。

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def is_passed(self):
        return self.score >= 60

students = [
    Student("张三", 90),
    Student("李四", 55),
    Student("王五", 78)
]

passed_students = []

for stu in students:
    if stu.is_passed():
        passed_students.append(stu)

for stu in passed_students:
    print(stu.name)

输出：

张三
王五

也可以使用列表推导式：

passed_students = [stu for stu in students if stu.is_passed()]

教学时建议先讲普通循环，再讲推导式。

34. 修改对象列表中的对象

列表中保存的是对象。

当我们取出对象并修改属性时，原对象会被修改。

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

students = [
    Student("张三", 90),
    Student("李四", 55)
]

students[1].score = 75

print(students[1].score)

输出：

也可以通过方法修改：

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def update_score(self, new_score):
        self.score = new_score

students = [
    Student("张三", 90),
    Student("李四", 55)
]

students[1].update_score(75)

print(students[1].score)

输出：

35. 类和字典的简单对比

保存一个学生，可以用字典：

student = {
    "name": "张三",
    "age": 18,
    "score": 90
}

也可以用类：

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

student = Student("张三", 18, 90)

对比：

对比项	字典	类和对象
保存数据	可以	可以
表达结构	较松散	更清晰
保存行为	不方便	可以把方法写进类
适合场景	简单键值数据	有固定结构和行为的事物

教学总结：

只是临时保存简单数据，可以用字典。
如果一类事物既有数据又有行为，适合用类。

36. 类和函数的简单对比

函数适合表示一个独立动作。

def add(a, b):
    return a + b

类适合表示一类事物。

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def is_passed(self):
        return self.score >= 60

简单判断：

只有一个动作，用函数。
有一类对象，并且对象有数据和行为，用类。

37. 方法和函数的区别

对比项	函数	方法
定义位置	通常定义在类外	定义在类内
调用方式	`函数名()`	`对象.方法名()`
是否有 self	普通函数没有固定 self	实例方法第一个参数是 self
常见用途	完成独立任务	操作对象自己的数据

函数示例：

def say_hello():
    print("你好")

say_hello()

方法示例：

class Student:
    def say_hello(self):
        print("你好")

stu = Student()
stu.say_hello()

38. 一个完整教学案例：学生类

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

    def introduce(self):
        print(f"大家好，我叫{self.name}，今年{self.age}岁")

    def show_score(self):
        print(f"{self.name}的成绩是{self.score}分")

    def update_score(self, new_score):
        self.score = new_score

    def is_passed(self):
        return self.score >= 60

stu = Student("张三", 18, 90)

stu.introduce()
stu.show_score()

stu.update_score(95)
stu.show_score()

print(stu.is_passed())

输出：

大家好，我叫张三，今年18岁
张三的成绩是90分
张三的成绩是95分
True

这个例子中：

Student 是类。
stu 是对象，也是 Student 的实例。
name、age、score 是实例属性。
introduce、show_score、update_score、is_passed 是实例方法。
self 表示当前对象 stu。

39. 一个完整教学案例：计数器类

class Counter:
    def __init__(self):
        self.count = 0

    def add(self):
        self.count += 1

    def reset(self):
        self.count = 0

    def show(self):
        print(f"当前计数：{self.count}")

counter = Counter()

counter.show()
counter.add()
counter.add()
counter.show()
counter.reset()
counter.show()

输出：

当前计数：0
当前计数：2
当前计数：0

这个例子适合说明：

对象可以保存状态。
方法可以修改对象的状态。

40. 一个完整教学案例：商品类

class Product:
    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock

    def show_info(self):
        print(f"商品：{self.name}，价格：{self.price}，库存：{self.stock}")

    def sell(self, count):
        if count <= self.stock:
            self.stock -= count
            print(f"卖出 {count} 件")
        else:
            print("库存不足")

    def total_value(self):
        return self.price * self.stock

apple = Product("苹果", 5, 100)

apple.show_info()
apple.sell(3)
apple.show_info()
print(apple.total_value())

输出：

商品：苹果，价格：5，库存：100
卖出 3 件
商品：苹果，价格：5，库存：97
485

这个例子中：

name、price、stock 是商品的数据。
show_info、sell、total_value 是商品的行为。

41. 常见错误 1：方法忘记写 self

错误写法：

class Student:
    def introduce():
        print("大家好")

stu = Student()
stu.introduce()

会报错。

原因：

实例方法的第一个参数应该是 self。
对象调用方法时，Python 会自动把对象传给 self。

正确写法：

class Student:
    def introduce(self):
        print("大家好")

stu = Student()
stu.introduce()

42. 常见错误 2：访问属性忘记 self

错误写法：

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

    def introduce(self):
        print(name)

正确写法：

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

    def introduce(self):
        print(self.name)

在方法内部访问实例属性，要写 self.属性名。

43. 常见错误 3：init 写错

正确写法：

def __init__(self):
    pass

错误写法：

def _init_(self):
    pass

错误写法：

def init(self):
    pass

__init__ 左右两边都是两个下划线。

如果写错，Python 不会把它当成初始化方法。

44. 常见错误 4：创建对象时参数数量不对

代码：

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

正确：

stu = Student("张三", 18)

错误，少传参数：

stu = Student("张三")

错误，多传参数：

stu = Student("张三", 18, 90)

注意：

创建对象时传入的参数，要和 __init__ 除 self 外的参数对应。

45. 常见错误 5：把类名和对象名混淆

示例：

class Student:
    pass

stu = Student()

这里：

Student 是类名。
stu 是对象名。

错误理解：

认为 Student 和 stu 是一样的。

它们不一样。

类是模板，对象是实例。

46. 常见错误 6：对象还没创建就使用

错误写法：

class Student:
    pass

stu.name = "张三"  # 错误

原因：

stu 这个对象还没有被创建。

正确写法：

class Student:
    pass

stu = Student()
stu.name = "张三"

47. 常见错误 7：方法缩进错误

错误写法：

class Student:
    pass

def introduce(self):
    print("大家好")

这里 introduce 不属于 Student 类。

正确写法：

class Student:
    def introduce(self):
        print("大家好")

48. 常见错误 8：把 self 当成需要手动传入的参数

定义：

class Student:
    def introduce(self):
        print("大家好")

正确调用：

stu = Student()
stu.introduce()

不需要写：

stu.introduce(stu)  # 不推荐，也通常会导致参数错误

记住：

self 由 Python 自动传入。
调用实例方法时，不需要手动传 self。

49. 常见错误 9：在 init 中漏写属性

错误写法：

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

    def introduce(self):
        print(self.name, self.age)

stu = Student("张三")
stu.introduce()

会报错。

原因：

__init__ 中没有给对象创建 age 属性。
introduce 方法却访问了 self.age。

正确写法：

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

    def introduce(self):
        print(self.name, self.age)

stu = Student("张三", 18)
stu.introduce()

50. 常见错误 10：对象属性名写不一致

错误写法：

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

    def introduce(self):
        print(self.student_name)

会报错。

原因：

初始化时创建的是 self.name。
方法中访问的是 self.student_name。
两个名字不一致。

正确写法：

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

    def introduce(self):
        print(self.name)

51. 注意事项 1：属性尽量在 init 中统一定义

虽然 Python 允许在类外给对象添加属性：

class Student:
    pass

stu = Student()
stu.name = "张三"

但是教学和实际开发中，更推荐：

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

stu = Student("张三")

好处：

类的结构更清楚。
对象创建时就有完整数据。
不容易漏写属性。

52. 注意事项 2：方法名要表达动作

方法表示对象能做什么，所以方法名通常使用动词或动词短语。

推荐：

show_info()
update_score()
is_passed()
calculate_area()

不推荐：

info()
score()
data()

好的方法名能让代码更容易读懂。

53. 注意事项 3：类名和对象名要有区别

推荐：

class Student:
    pass

student = Student()

或者：

stu = Student()

不推荐：

class Student:
    pass

Student = Student()

这样会把类名覆盖掉，容易造成严重混乱。

54. 注意事项 4：一个类只描述一类事物

类应该表达清楚的一类对象。

例如：

class Student:
    pass

class Product:
    pass

class Counter:
    pass

不推荐把很多无关内容都塞进一个类。

例如，一个 Student 类里不应该同时处理商品库存、银行账户、天气查询等无关逻辑。

教学中可以这样说：

类要像现实世界中的一种事物。

55. 注意事项 5：方法不要做太多事情

一个方法最好完成一个明确的小任务。

推荐：

def update_score(self, new_score):
    self.score = new_score

def is_passed(self):
    return self.score >= 60

不推荐一个方法里又修改成绩、又打印信息、又保存文件、又统计排名。

简单原则：

一个方法只做一件主要事情。

56. 课堂练习 1：定义一个 Person 类

要求：

定义 Person 类。
在 __init__ 中设置 name 和 age。
定义 introduce() 方法，打印自我介绍。

参考答案：

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

    def introduce(self):
        print(f"大家好，我叫{self.name}，今年{self.age}岁")

person = Person("张三", 18)
person.introduce()

57. 课堂练习 2：定义一个 Student 类

要求：

有 name 和 score 两个属性。
有 show_info() 方法。
有 is_passed() 方法，返回是否及格。

参考答案：

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def show_info(self):
        print(f"{self.name}的成绩是{self.score}")

    def is_passed(self):
        return self.score >= 60

stu = Student("张三", 90)
stu.show_info()
print(stu.is_passed())

58. 课堂练习 3：定义一个 Rectangle 类

要求：

有 width 和 height 两个属性。
有 area() 方法，返回面积。
有 perimeter() 方法，返回周长。

参考答案：

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return (self.width + self.height) * 2

rect = Rectangle(3, 4)

print(rect.area())
print(rect.perimeter())

59. 课堂练习 4：定义一个 Counter 类

要求：

初始计数为 0。
有 add() 方法，每次调用计数加 1。
有 reset() 方法，把计数清零。
有 show() 方法，打印当前计数。

参考答案：

class Counter:
    def __init__(self):
        self.count = 0

    def add(self):
        self.count += 1

    def reset(self):
        self.count = 0

    def show(self):
        print(self.count)

counter = Counter()
counter.add()
counter.add()
counter.show()
counter.reset()
counter.show()

60. 课堂练习 5：定义一个 Product 类

要求：

有 name、price、stock 三个属性。
有 show_info() 方法，显示商品信息。
有 sell(count) 方法，卖出指定数量商品。
如果库存不足，打印 "库存不足"。

参考答案：

class Product:
    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock

    def show_info(self):
        print(f"商品：{self.name}，价格：{self.price}，库存：{self.stock}")

    def sell(self, count):
        if count <= self.stock:
            self.stock -= count
            print(f"卖出 {count} 件")
        else:
            print("库存不足")

product = Product("苹果", 5, 100)
product.show_info()
product.sell(3)
product.show_info()

61. 课堂练习 6：对象列表

要求：

创建三个学生对象。
把它们放入列表。
使用循环打印每个学生的信息。

参考答案：

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def show_info(self):
        print(f"{self.name}: {self.score}")

students = [
    Student("张三", 90),
    Student("李四", 85),
    Student("王五", 78)
]

for stu in students:
    stu.show_info()

62. 课堂练习 7：判断代码输出

阅读代码，判断输出结果：

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

    def say_name(self):
        print(self.name)

stu1 = Student("张三")
stu2 = Student("李四")

stu1.say_name()
stu2.say_name()

答案：

张三
李四

解释：

stu1 调用方法时，self 是 stu1。
stu2 调用方法时，self 是 stu2。

63. 课堂练习 8：找错误

下面代码有什么问题？

class Student:
    def show_info():
        print("学生信息")

stu = Student()
stu.show_info()

答案：

show_info 方法少写了 self 参数。

正确写法：

class Student:
    def show_info(self):
        print("学生信息")

stu = Student()
stu.show_info()

64. 课堂练习 9：找错误

下面代码有什么问题？

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

    def show_info(self):
        print(name)

stu = Student("张三")
stu.show_info()

答案：

方法中访问实例属性时，应该写 self.name。

正确写法：

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

    def show_info(self):
        print(self.name)

stu = Student("张三")
stu.show_info()

65. 课堂练习 10：补全代码

补全代码，让程序输出：

小明正在学习 Python

题目：

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

    def study(self, subject):
        # 请补全这里

stu = Student("小明")
stu.study("Python")

参考答案：

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

    def study(self, subject):
        print(f"{self.name}正在学习 {subject}")

stu = Student("小明")
stu.study("Python")

66. 教学总结

类、对象、实例和方法是学习 Python 面向对象的基础。

一句话总结：

类是模板，对象是实例，属性是数据，方法是行为。

核心知识：

使用 class 定义类。
使用 对象名 = 类名() 创建对象。
对象也叫实例。
属性表示对象保存的数据。
方法表示对象能执行的行为。
实例方法的第一个参数是 self。
self 表示当前调用方法的对象。
__init__ 用来初始化对象属性。
访问实例属性要写 self.属性名。
调用实例方法使用 对象.方法名()。

最常用代码模板：

class 类名:
    def __init__(self, 参数1, 参数2):
        self.属性1 = 参数1
        self.属性2 = 参数2

    def 方法名(self):
        方法中的代码

对象名 = 类名(参数1, 参数2)
对象名.方法名()

学生类模板：

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def show_info(self):
        print(f"{self.name}: {self.score}")

stu = Student("张三", 90)
stu.show_info()

课堂记忆口诀：

类是图纸，对象是实物。
实例就是具体对象。
属性保存数据，方法执行动作。
self 代表当前对象。
init 初始化属性。

最后记住：

当一类事物有固定的数据和行为时，就可以考虑使用类来表示。