本期导读
大家好，我是欧K。
本期为大家带来Python基础系列面向对象部分的内容，包括类和对象的理解、实例的创建与调用，以及子类继承和多态等等，希望对你有所帮助。
在介绍python面向对象编程之前，先来了解几个术语：
- 类: 用来描述具有相同的属性和方法的对象的集合，它定义了该集合中每个对象所共有的属性和方法。
- 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
- 类变量：类变量在整个实例化的对象中是公用的，类变量定义在类中且在函数体之外，类变量通常不作为实例变量使用。
- 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
- 方法：类中定义的函数。
- 实例化：创建一个类的实例，类的具体对象。
- 对象：通过类定义的数据结构实例，对象包括数据成员（类变量和实例变量）和方法。
- 继承：即一个派生类继承基类的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
- 多态：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖，也称为方法的重写。
一个简单的实例：
# 创建一个学生类 class Student: course_count = 4 # 类变量 # 定义学生属性（构造函数） def __init__(self, name, number): self.name = name # 实例变量 self.number = number # 实例变量 # 定义方法 def show(self): print(f'姓名: {self.name}，学号: {self.number}') # 实例化 stu1 = Student('当打之年','001') stu1.show() print(f'共 {stu1.course_count} 门课程') # 姓名: 当打之年，学号: 001 # 共 4 门课程 stu2 = Student('欧K','002') stu2.show() print(f'共 {stu2.course_count} 门课程') # 姓名: 欧K，学号: 002 # 共 4 门课程
1. 类
1.1 创建
语法格式：
class ClassName: '''变量''' '''方法''' pass
class 是关键字，表示类。例如 class Student 即创建了一个 Student 类。
1.2 数据成员
数据成员包括：变量和方法。
1.2.1 变量：
类变量：定义在类中且在函数体之外，在实例化对象中是公有的。
course_count = 4 # 类变量
实例变量：在类的内部，但是在类的其他成员方法之外声明，在实例化对象中是私有的。
def __init__(self, name, number): self.name = name # 实例变量 self.number = number # 实例变量
本例是通过构造函数来声明，类变量和实例变量的区别很大，访问方式也也不一样。
1.2.2 方法：
类中定义的函数：
# 定义方法 def show(self): print(f'姓名: {self.name}，学号: {self.number}')
初始化时的构造函数也是一种方法。
提示：
在对象的方法里面都有一个self参数, 比如__init__(self), show(self)。 这里的self是指对象本身而非类本身。
构造方法__init__(self,....)：在生成对象时调用，可以用来进行一些初始化操作，不需要显示去调用，系统会默认去执行。构造方法支持重载，如果用户自己没有重新定义构造方法，系统就自动执行默认的构造方法。
1.4 私有/公有
类里面的私有属性和私有方法以双下划线__开头。私有属性或方法不能在类的外部被使用或直接访问，公有属性和公有方法可以在类的外部被使用或直接访问。
def __init__(self, name, number, score): self.name = name # 实例变量 self.number = number # 实例变量 self.__score = score # 私有变量 # 实例化 stu1 = Student('当打之年','001',90) print(stu1.name) # 当打之年 print(stu1.__score) # AttributeError: 'Student' object has no attribute '__score'
2. 对象/实例
2.1 创建（类的实例化） 实例化两个Student对象：
# 实例化 stu1 = Student('当打之年','001') stu2 = Student('欧K','002')
实例化需要传入相应的参数。
2.2 调用
调用一般指类方法的调用：
# 实例化 stu1 = Student('当打之年','001') stu1.show() print(f'共 {stu1.course_count} 门课程') # 姓名: 当打之年，学号: 001 # 共 4 门课程 stu2 = Student('欧K','002') stu2.show() print(f'共 {stu2.course_count} 门课程') # 姓名: 欧K，学号: 002 # 共 4 门课程
直接通过实例对象调用即可。print语句中使用了f-string格式化，具体用法可参考下面这篇文章(点击跳转)：技巧 | 5000字超全解析Python三种格式化输出方式【% / format / f-string】
2.2.1 @classmethod（类方法）
@classmethod将函数定义为类方法，函数可通过类和实例调用：声明前：
def get_course_count(self): print(f'共 {self.course_count} 门课程') # 实例化 stu1 = Student('当打之年','001') stu1.get_course_count() # 共 4 门课程 Student.get_course_count() # TypeError: get_course_count() missing 1 required positional argument: 'self'
声明后：
@classmethod def get_course_count(cls): print(f'共 {self.course_count} 门课程') # 实例化 stu1 = Student('当打之年','001') stu1.get_course_count() # 共 4 门课程 Student.get_course_count() # 共 4 门课程
这里的cls和self相似，是惯用写法，均可用其他字符代替。
2.2.2 @staticmethod（静态函数）
@staticmethod 将函数定义为静态函数，类和实例都可以访问，但是静态函数无法访问类变量：
@staticmethod def student_info(a,b,c): print(f'姓名: {a}，学号: {b}，共 {c} 门课程') # 姓名: 当打之年，学号: 001，共 4 门课程 print(f'姓名: {a}，学号: {b}，共 {course_count} 门课程') # 错误 # 实例化 stu1 = Student('当打之年','001') stu1.student_info('当打之年','001',4) # 姓名: 当打之年，学号: 001，共 4 门课程
course_count为类变量，直接访问会报错，此外静态函数参数个数没有要求，可有可无。
2.2.3 @property（伪装）
@property 将函数伪装成属性：
@property def get_student_info(self): print(f'姓名: {self.name}，学号: {self.number}，共 {self.course_count} 门课程') # 实例化 stu1 = Student('当打之年','001') stu1.get_student_info() # TypeError: 'NoneType' object is not callable stu1.get_student_info # 姓名: 当打之年，学号: 001，共 4 门课程
此时的get_student_info函数被伪装成实例属性（类似变量）而不在是函数，所以通过函数调用的方式会报错，可直接通过属性调用。
3. 继承
面向对象的编程带来的最大好处之一就是代码的复用，实现这种复用的方法之一是通过继承。先定义一个基类（父类），再按通过class子类名（父类名）来创建子类，这样子类就可以从父类那里获得其已有的属性与方法。
3.1 子类
语法格式（单继承、多继承）：
# 单继承 class ChildClassName(FatherClassName): '''变量''' '''方法''' pass # 多继承 class ChildClassName(FatherClassName1,FatherClassName2,...): '''变量''' '''方法''' pass 父类：大学学生类，子类：某专业学生类 # 创建一个大学学生类 class CollegeStudent: print('我是父类') # 定义学生属性（构造函数） def __init__(self, name, number): self.name = name # 实例变量 self.number = number # 实例变量 # 定义方法 def show(self): print(f'姓名: {self.name}，学号: {self.number}') # 创建某专业学生子类 class Student(CollegeStudent): print('我是子类') pass # 实例化 stu1 = Student('当打之年','001') stu1.show() # 姓名: 当打之年，学号: 001
3.2 派生
派生就是子类在继承父类的基础上衍生出新的属性或者方法。即子类中有，父类中没有；或子类定义与父类重名的东西。子类也叫派生类。
3.2.1 增加属性：
# 创建某专业学生子类 class Student(CollegeStudent): def __init__(self, name, number, score): CollegeStudent.__init__(self, name, number) self.score = score # 实例变量 # 定义方法 def show_score(self): print(f'姓名: {self.name}，学号: {self.number}，成绩: {self.score}') # 实例化 stu1 = Student('当打之年','001',99) stu1.show() # 姓名: 当打之年，学号: 001 stu1.show_score() # 姓名: 当打之年，学号: 001，成绩: 99
stu1.show()是调用父类方法，stu1.show_score()是调用子类新增的方法。
3.2.2 方法重写：
# 创建某专业学生子类 class Student(CollegeStudent): def __init__(self, name, number, score): CollegeStudent.__init__(self, name, number) self.score = score # 实例变量 # 重写方法 def show(self): print(f'姓名: {self.name}，学号: {self.number}，成绩: {self.score}') # 实例化 stu1 = Student('当打之年','001',99) stu1.show() # 姓名: 当打之年，学号: 001，成绩: 99
父类和子类中都有show()方法，子类中show()方法是对父类该方法的重写（重定义）。
3.2.3 super()关键字：
如果父类方法被重写，但是还需要调用父类方法的话，可以使用super()关键字。
# 创建某专业学生子类 class Student(CollegeStudent): def __init__(self, name, number, score): CollegeStudent.__init__(self, name, number) self.score = score # 实例变量 # 重写方法 def show(self): super().show() '''其他代码''' # 实例化 stu1 = Student('当打之年','001',99) stu1.show() # 姓名: 当打之年，学号: 001
4. 多态
Python中的变量是弱类型的，对于弱类型的语言来说，变量并没有声明类型，因此，同一个变量完全可以在不同的时间引用不同的对象，当同一个变量在调用不同的方法时，完全可能呈现多种行为（具体呈现出哪种行为由该变量所引用的对象决定），即多种形态。
4.1 方法多态
创建两个类：学生类、教师类
# 创建学生类 class Student: def __init__(self, name, number, score): self.name = name # 实例变量 self.number = number # 实例变量 self.score = score # 私有变量 def show(self): print(f'学生姓名: {self.name}，学号: {self.number}，成绩: {self.score}') # 创建教师类 class Teacher: def __init__(self, name, number): self.name = name # 实例变量 self.number = number # 实例变量 def show(self): print(f'教师姓名: {self.name}，工号: {self.number}') # 实例化学生对象 stu1 = Student('当打之年','001',99) stu1.show() # 学生姓名: 当打之年，学号: 001，成绩: 99 # 实例化教师对象 tec1 = Teacher('Python','t101') tec1.show() # 教师姓名: Python，工号: t101
两个类都具有show()方法，但是实现的功能不一样，即同一种方法不同的功能。
4.2 运算符多态
加法多态：
def add(data1, data2): return data1 + data2 print(add(3, 5)) # 8 print(add('Python ', '当打之年')) # Python 当打之年
上述定义的加法运算符我们不用关心两个参数data1和data2具体是什么类型，只要是支持加法运算的对象就可以，即可以是多种形态的对象。
4.3 运算符重载
以加法、减法重载为例：
# 运算符类 class Operate: def __init__(self, data): self.data = data # 内置魔法函数 def __repr__(self): # 消除两边的尖括号 return f'Operate({self.data})' # 制定self + other规则 def __add__(self, other): a = self.data + other.data return Operate(a) # 制定self - other规则 def __sub__(self, other): a = self.data - other.data return Operate(a) r1 = Operate(100) r2 = Operate(300) r3 = r1 + r2 # Operate(400) print(r3) r4 = r3 - r2 # Operate(100)
所有重载方法的名称前后都有两个下划线字符，以便把同类中定义的变量名区别开来。
5. 总结
两个核心：类、对象。
三大特征 ：封装、继承、多态。
重点注意继承和多态，旨在提高代码的复用性以及灵活性。
END
以上就是本期为大家整理的全部内容了，赶快练习起来吧，喜欢的朋友可以
点赞、点在看
也可以分享到朋友圈让更多人知道哦
