在上一篇文章中,我们已经掌握了Python函数的进阶知识——函数作用域、递归函数,以及函数的综合运用,能够通过函数封装重复代码、实现复杂逻辑。但随着程序规模的扩大,仅靠函数很难实现代码的高效组织与复用,此时就需要引入更高级的编程思想——面向对象编程(OOP)。
面向对象编程是Python的核心编程思想之一,它将数据和操作数据的函数封装在一起,形成“类与对象”,让代码更具模块化、可扩展性和可维护性,也是后续学习Python高级开发(如框架、项目开发)的基础。本文将延续前文的学习节奏,从面向对象的核心概念(类、对象)、类的定义与使用、面向对象的三大核心特性(封装、继承、多态),到综合实战案例,帮你快速入门面向对象编程,同时衔接前文的函数知识,让新手能够循序渐进、稳步提升。
需要注意的是:面向对象编程并非否定函数,而是将函数(在面向对象中称为“方法”)与数据结合,形成更灵活、更易维护的代码结构。前文所学的函数知识,都是面向对象编程的基础,学好函数,能让你更快掌握面向对象的核心用法。
一、面向对象核心概念:类与对象(必学)
面向对象编程的核心是“类”和“对象”,这两个概念是理解面向对象的基础,我们可以结合生活中的场景,轻松理解它们的含义——就像“汽车”和“我的私家车”:
- 汽车:是一个类,它是一个抽象的概念,定义了汽车的共同特征(如颜色、品牌、排量)和共同行为(如行驶、刹车、鸣笛);
- 我的私家车:是一个对象,它是“汽车”这个类的具体实例,拥有具体的特征(红色、丰田、1.5T)和具体的行为(能行驶、能刹车)。
简单来说:类是抽象的模板,定义了一类事物的共同特征和行为;对象是类的具体实例,是模板的具体实现,拥有类定义的所有特征和行为。
(一)类与对象的核心区别
1. 类是抽象的,不占用内存;对象是具体的,占用内存(每个对象都是独立的,拥有自己的属性和方法);
2. 一个类可以创建多个对象(如“汽车”类可以创建无数辆具体的汽车),多个对象可以共享类的方法,但拥有各自的属性值;
3. 类定义了“是什么”和“能做什么”,对象则是“具体是什么”和“具体做什么”。
(二)类的定义与对象的创建(基础语法)
Python中,用class关键字定义类,类名遵循Python命名规范(首字母大写,后续单词首字母大写,如Car、Student),便于区分类和普通函数/变量。对象的创建则是通过“类名+括号”的方式,类似函数调用。
1. 类的基础定义语法
# 类的基础语法class 类名: # 类的属性(特征):用于存储数据,类似变量 属性名1 = 属性值1 属性名2 = 属性值2 # 类的方法(行为):用于操作数据,本质是类内部的函数 def 方法名(self, 参数1, 参数2, ...): 方法体(具体逻辑) (可选)return 返回值# 说明:# 1. class:定义类的关键字,后面跟类名和冒号;# 2. 属性:类内部定义的变量,用于描述类的特征,可分为“类属性”(所有对象共享)和“实例属性”(每个对象独有);# 3. 方法:类内部定义的函数,用于描述类的行为,第一个参数必须是self(代表当前对象,无需手动传入,Python自动传递);# 4. self:是类中方法的第一个参数,用于指代当前对象,通过self可以访问对象的属性和其他方法。2. 对象的创建与使用语法
# 1. 定义类(以“学生”类为例,衔接前文学生成绩案例)class Student: # 类属性:所有学生共享的属性(如学校名称) school = "XX中学" # 实例方法:第一个参数必须是self def introduce(self): # 通过self访问对象的实例属性 print(f"大家好,我叫{self.name},今年{self.age}岁,来自{self.school}")# 2. 创建对象(类名+括号,类似函数调用)student1 = Student() # 创建第一个学生对象student2 = Student() # 创建第二个学生对象# 3. 给对象添加实例属性(每个对象独有,可动态添加)student1.name = "张三"student1.age = 18student1.score = 88 # 额外添加成绩属性,与前文案例衔接student2.name = "李四"student2.age = 17student2.score = 92# 4. 调用对象的方法(无需传入self参数)student1.introduce() # 输出:大家好,我叫张三,今年18岁,来自XX中学student2.introduce() # 输出:大家好,我叫李四,今年17岁,来自XX中学# 5. 访问对象的属性和类属性print(student1.name) # 访问实例属性,输出:张三print(student1.school) # 访问类属性,输出:XX中学print(Student.school) # 类也可以直接访问类属性,输出:XX中学(三)类属性与实例属性的区别(重点)
在上面的案例中,我们接触了两种属性:类属性和实例属性,两者的区别的是新手的高频易错点,必须重点掌握:
1. 类属性
- 定义位置:在类的内部、所有方法的外部;
- 特点:所有对象共享,修改类属性,所有对象的类属性都会同步修改;
- 访问方式:对象.类属性 或 类名.类属性(推荐用类名访问,更清晰)。
2. 实例属性
- 定义位置:在类的方法内部(通过self.属性名定义)或对象创建后动态添加;
- 特点:每个对象独有,修改一个对象的实例属性,不影响其他对象;
- 访问方式:只能通过对象.实例属性访问,不能通过类名访问。
实操案例:区分类属性与实例属性
class Student: # 类属性:所有学生共享 school = "XX中学" # 实例方法:在方法内部定义实例属性 def __init__(self, name, age): # self.属性名 = 参数,定义实例属性(每个对象独有) self.name = name self.age = age# 创建对象(传入参数,初始化实例属性)student1 = Student("张三", 18)student2 = Student("李四", 17)# 访问类属性print(Student.school) # 输出:XX中学print(student1.school) # 输出:XX中学print(student2.school) # 输出:XX中学# 修改类属性(通过类名修改)Student.school = "YY中学"print(student1.school) # 输出:YY中学(所有对象同步修改)print(student2.school) # 输出:YY中学# 访问实例属性print(student1.name) # 输出:张三print(student2.name) # 输出:李四# 修改实例属性(仅影响当前对象)student1.age = 19print(student1.age) # 输出:19print(student2.age) # 输出:17(不受影响)# 错误:通过类名访问实例属性# print(Student.name) # 报错:AttributeError(类不能访问实例属性)(四)初始化方法__init__(核心方法)
在上面的案例中,我们用到了__init__方法,它是Python类中的初始化方法(也叫构造方法),是类中最常用的方法,核心作用是:在创建对象时,自动初始化对象的实例属性,避免每次创建对象后都手动添加实例属性。
__init__方法的特点:
1. 方法名必须是__init__(前后各两个下划线,不能写错);
2. 第一个参数必须是self,代表当前对象;
3. 创建对象时,会自动调用该方法,无需手动调用;
4. 可以通过__init__方法的参数,给对象初始化不同的实例属性值。
实操案例:用__init__方法初始化实例属性
# 定义学生类,用__init__初始化实例属性(衔接前文成绩案例)class Student: # 类属性 school = "XX中学" # 初始化方法:创建对象时自动调用,传入name、age、score参数 def __init__(self, name, age, score): # 初始化实例属性 self.name = name # 姓名 self.age = age # 年龄 self.score = score# 成绩(与前文成绩管理案例衔接) # 实例方法:判断成绩等级(复用前文函数逻辑) def judge_score_level(self): if self.score >= 90: return "优秀" elif self.score >= 80: return "良好" elif self.score >= 60: return "及格" else: return "不及格" # 实例方法:打印学生完整信息 def show_info(self): level = self.judge_score_level() # 调用类内部的方法 print(f"姓名:{self.name},年龄:{self.age}岁,学校:{self.school},成绩:{self.score}分,等级:{level}")# 创建对象:传入参数,自动调用__init__方法初始化属性student1 = Student("张三", 18, 88)student2 = Student("李四", 17, 92)student3 = Student("王五", 18, 59)# 调用对象的方法student1.show_info() # 输出:姓名:张三,年龄:18岁,学校:XX中学,成绩:88分,等级:良好student2.show_info() # 输出:姓名:李四,年龄:17岁,学校:XX中学,成绩:92分,等级:优秀student3.show_info() # 输出:姓名:王五,年龄:18岁,学校:XX中学,成绩:59分,等级:不及格说明:通过__init__方法,我们可以在创建对象时直接传入属性值,无需手动添加,同时在类内部的方法中,通过self可以调用其他方法(如show_info调用judge_score_level),实现了代码的封装与复用,比单纯使用函数更具模块化。
二、面向对象三大核心特性(重点进阶)
面向对象编程有三大核心特性:封装、继承、多态,这三大特性是面向对象编程的灵魂,能够让代码更具复用性、可扩展性和灵活性。我们结合实操案例,逐一讲解,重点掌握封装和继承,多态作为入门了解即可。
(一)封装(最基础、最常用)
1. 封装的核心概念
封装的核心是“隐藏细节、暴露接口”,即将对象的属性和方法封装在类内部,不允许外部直接访问和修改对象的属性,而是通过类提供的公共方法(接口)来访问和修改,这样可以保证数据的安全性,避免数据被误修改,同时简化外部使用方式。
简单来说:就像手机——我们不需要知道手机内部的芯片、电路如何工作(隐藏细节),只需通过屏幕、按键等接口操作手机(暴露接口),这就是封装的思想。
2. 封装的实现方式(Python特色)
Python中没有严格的“私有属性/方法”语法,但可以通过“属性名/方法名前加两个下划线__”的方式,实现“伪私有”(让外部无法直接访问,只能在类内部访问),从而实现封装。
常见封装操作:
- 私有属性:__属性名,只能在类内部访问,外部无法直接访问;
- 公共方法:提供getter(获取属性值)和setter(修改属性值)方法,供外部访问和修改私有属性。
实操案例:实现封装(学生成绩保护)
# 封装案例:学生类,保护成绩属性(不允许外部直接修改成绩)class Student: def __init__(self, name, age, score): self.name = name self.age = age # 私有属性:__score,外部无法直接访问 self.__score = score # getter方法:获取私有属性__score的值(暴露接口) def get_score(self): return self.__score # setter方法:修改私有属性__score的值(暴露接口,同时添加验证逻辑) def set_score(self, new_score): # 验证成绩的合法性(0-100之间的整数),保证数据安全 if isinstance(new_score, int) and 0 <= new_score <= 100: self.__score = new_score print(f"成绩修改成功,新成绩:{self.__score}分") else: print("成绩输入错误,请输入0-100之间的整数!") # 公共方法:判断成绩等级 def judge_score_level(self): # 类内部可以访问私有属性 if self.__score >= 90: return "优秀" elif self.__score >= 80: return "良好" elif self.__score >= 60: return "及格" else: return "不及格"# 创建对象student = Student("张三", 18, 88)# 访问属性print(student.name) # 输出:张三(公共属性,可直接访问)# print(student.__score) # 报错:AttributeError(私有属性,外部无法直接访问)# 通过getter方法获取私有属性print(student.get_score()) # 输出:88# 通过setter方法修改私有属性student.set_score(92) # 输出:成绩修改成功,新成绩:92分student.set_score(105) # 输出:成绩输入错误,请输入0-100之间的整数!# 查看修改后的成绩等级print(student.judge_score_level()) # 输出:优秀说明:通过封装,我们将成绩属性设置为私有,避免外部直接修改,同时通过setter方法添加了成绩合法性验证,保证了数据的安全性;外部只需通过getter和setter方法访问、修改成绩,简化了使用方式,这就是封装的核心价值。
(二)继承(提升代码复用性)
1. 继承的核心概念
继承是指“一个类(子类)继承另一个类(父类)的属性和方法”,子类可以直接使用父类的属性和方法,同时可以定义自己的属性和方法,实现“代码复用”。简单来说:就像儿子继承父亲的财产,儿子可以直接使用父亲的财产,同时可以拥有自己的财产。
继承的核心优势:减少代码冗余,提升代码复用性,同时实现代码的扩展(子类可以在父类的基础上添加新功能)。
相关概念:
- 父类(基类):被继承的类,如“Person(人)”类;
- 子类(派生类):继承父类的类,如“Student(学生)”类、“Teacher(老师)”类,Student和Teacher都是Person的子类。
2. 继承的基础语法
# 继承基础语法class 父类名: # 父类的属性和方法 父类属性 = 属性值 def 父类方法(self): 方法体# 子类继承父类:class 子类名(父类名)class 子类名(父类名): # 子类可以继承父类的所有属性和方法 # 子类可以定义自己的属性和方法(扩展功能) 子类属性 = 属性值 def 子类方法(self): 方法体 # 子类可以重写父类的方法(修改父类方法的逻辑) def 父类方法(self): 新的方法体3. 实操案例:继承的使用(衔接学生、老师案例)
# 父类:Person(人),定义人的共同属性和方法class Person: def __init__(self, name, age, gender): self.name = name self.age = age self.gender = gender # 父类方法:自我介绍 def introduce(self): print(f"大家好,我叫{self.name},今年{self.age}岁,性别:{self.gender}")# 子类1:Student(学生),继承Person类class Student(Person): # 子类初始化方法:调用父类的初始化方法,同时添加自己的属性 def __init__(self, name, age, gender, score): # 调用父类的__init__方法,继承父类的属性 super().__init__(name, age, gender) # 子类自己的属性 self.score = score # 子类自己的方法:判断成绩等级 def judge_score_level(self): if self.score >= 90: return "优秀" elif self.score >= 80: return "良好" elif self.score >= 60: return "及格" else: return "不及格" # 重写父类的introduce方法(修改逻辑,添加成绩信息) def introduce(self): level = self.judge_score_level() print(f"大家好,我叫{self.name},今年{self.age}岁,性别:{self.gender},成绩:{self.score}分,等级:{level}")# 子类2:Teacher(老师),继承Person类class Teacher(Person): def __init__(self, name, age, gender, subject): # 调用父类的初始化方法 super().__init__(name, age, gender) # 子类自己的属性:科目 self.subject = subject # 子类自己的方法:上课 def teach(self): print(f"{self.name}老师,教授{self.subject}科目,正在上课!")# 使用子类对象# 1. 学生对象student = Student("张三", 18, "男", 88)student.introduce() # 调用重写后的方法,输出:大家好,我叫张三,今年18岁,性别:男,成绩:88分,等级:良好print(student.judge_score_level()) # 调用子类自己的方法,输出:良好# 2. 老师对象teacher = Teacher("李老师", 35, "女", "Python")teacher.introduce() # 调用父类的方法,输出:大家好,我叫李老师,今年35岁,性别:女teacher.teach() # 调用子类自己的方法,输出:李老师老师,教授Python科目,正在上课!核心说明:
1. super()函数:用于调用父类的方法(如__init__),让子类继承父类的属性和方法,避免重复编写代码;
2. 方法重写:子类可以重写父类的方法(方法名与父类一致),修改方法的逻辑,实现子类的个性化需求;
3. 继承的传递性:如果子类A继承父类B,父类B继承父类C,那么子类A会继承父类B和C的所有属性和方法。
(三)多态(入门了解)
1. 多态的核心概念
多态的核心是“同一方法,不同实现”,即不同的子类继承同一个父类后,重写父类的同一个方法,当调用该方法时,会根据对象的类型,执行不同的方法逻辑。简单来说:同一个方法,作用在不同的对象上,产生不同的效果。
多态的前提:必须有继承关系,且子类重写了父类的方法。
2. 实操案例:多态的简单实现
# 父类:Animal(动物)class Animal: def speak(self): # 父类方法,子类将重写该方法 pass# 子类1:Dog(狗)class Dog(Animal): def speak(self): print("汪汪汪!")# 子类2:Cat(猫)class Cat(Animal): def speak(self): print("喵喵喵!")# 子类3:Bird(鸟)class Bird(Animal): def speak(self): print("叽叽叽!")# 定义一个函数,接收Animal类型的对象,调用speak方法def animal_speak(animal): animal.speak() # 同一方法,不同对象执行不同逻辑# 创建不同的动物对象dog = Dog()cat = Cat()bird = Bird()# 调用函数,体现多态animal_speak(dog) # 输出:汪汪汪!animal_speak(cat) # 输出:喵喵喵!animal_speak(bird) # 输出:叽叽叽!说明:animal_speak函数接收的是Animal类型的对象,但传入不同的子类对象(Dog、Cat、Bird)时,会执行不同的speak方法逻辑,这就是多态的体现。多态让代码更具灵活性,后续学习框架开发时会频繁用到。
三、面向对象综合实战案例
结合本文的面向对象核心知识点(类与对象、封装、继承、多态),以及前文的函数、流程控制知识,编写一个综合实战案例——“学生成绩管理系统(面向对象版)”,升级前文的函数版系统,实现数据封装、代码复用,巩固面向对象编程的核心用法。
# 综合实战案例:学生成绩管理系统(面向对象版)# 需求:1. 封装学生类,保护成绩属性,提供成绩验证;# 2. 封装管理类,实现学生信息的添加、查询、修改、删除、统计功能;# 3. 利用继承、封装特性,实现代码复用和数据安全;# 4. 提供菜单交互,循环使用系统。# 1. 学生类(Student):封装学生信息,实现成绩保护class Student: def __init__(self, name, age, score): self.name = name self.age = age # 私有属性:成绩,通过getter和setter访问、修改 self.__score = score # getter方法:获取成绩 def get_score(self): return self.__score # setter方法:修改成绩,添加验证 def set_score(self, new_score): if isinstance(new_score, int) and 0 <= new_score <= 100: self.__score = new_score return True # 修改成功,返回True else: return False # 修改失败,返回False # 方法:判断成绩等级 def get_score_level(self): if self.__score >= 90: return "优秀" elif self.__score >= 80: return "良好" elif self.__score >= 60: return "及格" else: return "不及格" # 方法:返回学生完整信息 def get_info(self): return f"姓名:{self.name},年龄:{self.age}岁,成绩:{self.__score}分,等级:{self.get_score_level()}"# 2. 管理类(StudentManager):封装学生管理功能class StudentManager: def __init__(self): # 实例属性:存储所有学生对象(列表) self.student_list = [] # 方法1:添加学生 def add_student(self): name = input("请输入学生姓名:").strip() if not name: print("姓名不能为空!") return # 验证年龄 try: age = int(input("请输入学生年龄:").strip()) if age <= 0: print("年龄必须是正整数!") return except ValueError: print("年龄输入错误,请输入整数!") return # 验证成绩 try: score = int(input("请输入学生成绩(0-100):").strip()) if not (0 <= score <= 100): print("成绩必须在0-100之间!") return except ValueError: print("成绩输入错误,请输入整数!") return # 创建学生对象,添加到列表 student = Student(name, age, score) self.student_list.append(student) print("学生信息添加成功!") # 方法2:查询学生 def search_student(self): if not self.student_list: print("未录入任何学生信息!") return name = input("请输入要查询的学生姓名:").strip() # 遍历学生列表,查找学生 for student in self.student_list: if student.name == name: print("\n查询结果:") print(student.get_info()) return print(f"未找到姓名为{name}的学生!") # 方法3:修改学生成绩 def modify_student_score(self): if not self.student_list: print("未录入任何学生信息!") return name = input("请输入要修改成绩的学生姓名:").strip() for student in self.student_list: if student.name == name: try: new_score = int(input("请输入新的成绩(0-100):").strip()) # 调用学生对象的setter方法修改成绩 if student.set_score(new_score): print("成绩修改成功!") print(f"修改后信息:{student.get_info()}") else: print("成绩输入错误,请输入0-100之间的整数!") except ValueError: print("成绩输入错误,请输入整数!") return print(f"未找到姓名为{name}的学生!") # 方法4:删除学生 def delete_student(self): if not self.student_list: print("未录入任何学生信息!") return name = input("请输入要删除的学生姓名:").strip() for student in self.student_list: if student.name == name: self.student_list.remove(student) print("学生信息删除成功!") return print(f"未找到姓名为{name}的学生!") # 方法5:成绩统计 def count_score(self): if not self.student_list: print("未录入任何学生信息!") return total = len(self.student_list) excellent = 0 # 优秀 good = 0 # 良好 pass_score = 0 # 及格 fail = 0 # 不及格 for student in self.student_list: level = student.get_score_level() if level == "优秀": excellent += 1 elif level == "良好": good += 1 elif level == "及格": pass_score += 1 else: fail += 1 # 打印统计结果 print("\n" + "="*50) print("学生成绩统计结果") print("="*50) print(f"总人数:{total}人") print(f"优秀:{excellent}人,占比:{excellent/total*100:.1f}%") print(f"良好:{good}人,占比:{good/total*100:.1f}%") print(f"及格:{pass_score}人,占比:{pass_score/total*100:.1f}%") print(f"不及格:{fail}人,占比:{fail/total*100:.1f}%") print("="*50) # 方法6:查看所有学生信息 def show_all_students(self): if not self.student_list: print("未录入任何学生信息!") return print("\n所有学生信息:") print("="*50) for i, student in enumerate(self.student_list, start=1): print(f"{i}. {student.get_info()}") print("="*50)# 3. 主程序:菜单交互def main(): # 创建管理对象 manager = StudentManager() while True: print("\n" + "="*50) print("学生成绩管理系统(面向对象版)") print("1. 添加学生信息") print("2. 查看所有学生信息") print("3. 查询学生信息") print("4. 修改学生成绩") print("5. 删除学生信息") print("6. 成绩等级统计") print("7. 退出系统") print("="*50) choice = input("请输入操作序号(1-7):").strip() if choice == "1": manager.add_student() elif choice == "2": manager.show_all_students() elif choice == "3": manager.search_student() elif choice == "4": manager.modify_student_score() elif choice == "5": manager.delete_student() elif choice == "6": manager.count_score() elif choice == "7": print("感谢使用,退出系统!") break else: print("输入错误,请输入1-7之间的序号!")# 启动程序if __name__ == "__main__": main()案例说明:该案例是前文“学生成绩管理系统(函数版)”的升级版本,核心是用面向对象编程思想重构代码——将学生信息封装成Student类(实现成绩保护、成绩等级判断),将管理功能封装成StudentManager类(实现添加、查询、修改等功能),通过类与对象的结合,实现了代码的模块化、可维护性和数据安全性。同时,案例衔接了前文的成绩管理需求,让新手能够对比函数版和面向对象版的区别,深刻理解面向对象编程的优势。
四、面向对象高频易错点总结(新手必看)
面向对象编程是Python入门的一个难点,新手容易在类与对象、属性、继承等细节上踩坑,总结5个高频易错点,帮你避坑:
1. self参数错误:类中方法的第一个参数必须是self,调用方法时无需手动传入self,否则会报参数不匹配错误;
2. 类属性与实例属性混淆:类属性是所有对象共享的,实例属性是每个对象独有的,不要通过对象修改类属性(会变成对象的实例属性);
3. __init__方法写错:初始化方法的名字必须是__init__(前后各两个下划线),少写或多写下划线都会导致方法无法自动调用;
4. 继承时未调用父类初始化方法:子类继承父类后,若重写了__init__方法,未用super()调用父类的__init__方法,会导致父类的属性无法继承;
5. 私有属性访问错误:外部无法直接访问类的私有属性(__属性名),必须通过类提供的getter/setter方法访问、修改,否则会报AttributeError。
五、总结与后续学习指引
本文重点讲解了Python面向对象编程的核心知识,从类与对象的基础概念、定义与使用,到面向对象的三大核心特性(封装、继承、多态),再到综合实战案例,完整覆盖了新手入门面向对象必备的知识点,同时衔接了前文的函数知识,形成了更完整的Python入门知识体系。通过本文的学习,你能够掌握面向对象编程的核心思想,学会用类与对象组织代码,编写更规范、更灵活、更易维护的Python程序。
回顾本文核心内容:
1. 类与对象:类是抽象模板,对象是类的具体实例,用class定义类,用“类名+括号”创建对象;
2. 初始化方法__init__:创建对象时自动调用,用于初始化对象的实例属性,简化对象创建过程;

3. 三大核心特性:封装(隐藏细节、暴露接口)、继承(代码复用、扩展功能)、多态(同一方法、不同实现);
4. 综合运用:结合类与对象、封装、继承,编写实用的面向对象程序,提升代码的模块化和可维护性。
后续学习指引:
1. 多动手练习:将本文的案例反复运行、修改,尝试添加新功能(如添加老师管理功能、成绩排序功能),加深对面向对象的理解;
2. 熟练掌握三大特性:重点练习封装和继承,尝试编写多继承(一个子类继承多个父类)的案例,了解多继承的注意事项;
3. 学习面向对象进阶知识:掌握类方法、静态方法、属性装饰器(@property),进一步优化面向对象代码;
4. 学习模块与包:将面向对象的类封装成模块,实现更高效的代码复用,为后续大型项目开发打下基础;
5. 实战项目练习:尝试用面向对象编程思想编写简单的实战项目(如通讯录管理系统、图书管理系统),提升综合开发能力。
面向对象编程是Python编程的重要里程碑,也是从“新手”到“进阶开发者”的关键一步。只要多练习、多总结,熟练掌握类与对象的用法和三大核心特性,就能轻松应对后续更复杂的编程场景,为成为Python开发者打下更坚实的基础。
💻 配套实训环境与动手练习
本文涉及的相关技术指令、开发环境与工具链已内置在边学边练在线实验室中,无需繁琐安装配置,随时在浏览器中实践体验: