Python—基础语法：类和对象（类、方法、属性、实例对象、初始化函数、继承）详细解析
程序员文章站
2022-05-07 17:21:39
...
Python—基础语法：类和对象（类、方法、属性、实例对象、初始化函数、继承）详细解析
在介绍详细方法之前，先附上各种方式的调用语法
类
类是函数包，可以接纳多个函数
class 智能机器人(): #定义类
身高 = 168
体重 = 44 #定义属性值
智商 = 198
def 打招呼(): #定义方法
print('主人你好！')
def 卖萌():
print('主人，求抱抱！')
def 生气():
print('主人，我要报警了！')
print('把类的属性打印出来：')
print(智能机器人.身高) #类调用不同的属性值
print(智能机器人.体重)
print(智能机器人.智商)
智能机器人.打招呼()
智能机器人.卖萌() #类调用不同的方法
智能机器人.生气()
#结果展示
把类的属性打印出来：
168
44
198
主人你好！
主人，求抱抱！
主人，我要报警了！
#调用类属性
class 智能机器人():
身高 = 168
体重 = 44
智商 = 198
def 打招呼():
print('主人你好！')
def 卖萌():
print('主人，求抱抱！')
def 生气():
print('主人，我要报警了！')
@classmethod #声明类方法，只有声明之后，才能使用“智能机器人”这个类中的方法
def 自报信息(cls): #一定要传入参数cls
print('主人，我的基础信息有：')
print('身高：',cls.身高) #cls.身高 则是在调用类属性
print('体重：',cls.体重)
print('智商：',cls.智商)
print('啦啦啦啦，有没有很喜欢我')
智能机器人.自报信息()
智能机器人.打招呼() #智能机器人这个类再调用不同的方法
智能机器人.卖萌()
智能机器人.生气()
#结果展示
主人，我的基础信息有：
身高： 168
体重： 44
智商： 198
啦啦啦啦，有没有很喜欢我
主人你好！
主人，求抱抱！
主人，我要报警了！
#调用类方法
class 成绩单(): #定义类
@classmethod #声明类方法
def 录入成绩单(cls):
cls.学生姓名 = input('请输入学生姓名：')
cls.语文_成绩 = int(input('请输入语文成绩：'))
cls.数学_成绩 = int(input('请输入数学成绩：'))
@classmethod
def 计算平均分(cls):
平均分 = (cls.语文_成绩 + cls.数学_成绩)/2
return 平均分 #因为此方法我们需要调用，所以用return返回结果便于后面的调用
@classmethod
def 评级(cls):
平均分 = cls.计算平均分() #类方法调用其他的方法
if 平均分>=90:
print(cls.学生姓名 + '的评级是：优')
elif 平均分>= 80 and 平均分<90 :
print(cls.学生姓名 + '的评级是：良')
elif 平均分>= 60 and 平均分<80 :
print(cls.学生姓名 + '的评级是：中')
else:
print(cls.学生姓名 + '的评级是：差')
成绩单.录入成绩单()
成绩单.评级()
#结果展示
请输入学生姓名：猫看见
请输入语文成绩：85
请输入数学成绩：76
猫看见的评级是：良
给类方法传参的方式
#外部参数
class 加100类():
def 加100函数(参数):
总和 = 参数 + 100
print('计算结果如下：')
print(总和)
参数 = 1 #外部参数
加100类.加100函数(参数)
#结果展示
计算结果如下：
101
#内部参数
class 加100类():
def 加100函数(参数):
总和 = 参数 + 100
print('计算结果如下：')
print(总和)
参数 = 1 #内部参数
加100类.加100函数(参数)
#结果展示
计算结果如下：
101
#示例二
#内部参数
class 智能机器人():
身高 = 168
体重 = 44
智商 = 198
@classmethod
def 自报信息(cls):
print('主人，我的基础信息有：')
print('身高：',cls.身高) #内部参数
print('体重：',cls.体重)
print('智商：',cls.智商)
print('啦啦啦啦，有没有很喜欢我')
智能机器人.自报信息()
#结果展示
主人，我的基础信息有：
身高： 168
体重： 44
智商： 198
啦啦啦啦，有没有很喜欢我
#同时传入内部和外部参数
class 加100类():
变量 = 100
@classmethod
def 加100函数(cls,参数):
总和 = cls.变量 + 参数
print('加100函数计算结果如下：')
print(总和)
参数 = int(input('请输入一个整数：'))
加100类.加100函数(参数)
#结果展示
请输入一个整数：25
加100函数计算结果如下：
125
增加/修改类属性
#从外部修改类属性
变量1 = 15
变量2 = 'abc'
class 类A():
变量1 = 100
变量1 = 类A.变量1
类A.变量2 = 变量2
print(类A.变量1)
print(类A.变量2)
#结果展示
100
abc
#从内部修改/增加类属性
class 类(): #定义类
@classmethod #声明类方法
def 增加类属性(cls):
cls.变量 = input('请随意输入字符串：') #从内部增加属性
类.增加类属性() #调用类方法
print('打印新增的类属性：')
print(类.变量) #调用属性并打印出来
#结果展示
请随意输入字符串：猫看见
打印新增的类属性：
猫看见
类的实例对象
实例属性和类属性
#实例属性与类属性完全相同
class 类():
变量 = 100
实例1 = 类() # 实例化
实例2 = 类() # 实例化
print(类.变量)
print(实例1.变量)
print(实例2.变量)
#结果展示
100
100
100
#修改或者新增类属性，实例属性也会跟着改变
class 类():
变量 = 100
实例1 = 类() # 实例化
实例2 = 类() # 实例化
print(实例1.变量)
print(实例2.变量)
类.变量 = 'abc' # 修改类属性
print(实例1.变量) # 实例属性同步变化
print(实例2.变量) # 实例属性同步变化
#结果展示
100
100
abc
abc
#实例属性的修改并不会影响到类属性
class 类():
变量 = 100
实例1 = 类() # 实例化
实例2 = 类() # 实例化
print('原先的类属性：')
print(类.变量)
print('原先的实例1属性：')
print(实例1.变量)
print('原先的实例2属性：')
print(实例2.变量)
实例1.变量 = 'abc'
print('--------修改实例1的属性后----------')
print('现在的类属性：')
print(类.变量)
print('现在的实例1属性：')
print(实例1.变量)
print('现在的实例2属性：')
print(实例2.变量)
#结果展示
原先的类属性：
100
原先的实例1属性：
100
原先的实例2属性：
100
--------修改实例1的属性后----------
现在的类属性：
100
现在的实例1属性：
abc
现在的实例2属性：
100
新增实例属性，不能直接用类调取实例属性，因为增加实例属性不影响类
实例方法和类方法
#“重写类方法”分成两个步骤：第一个步骤是在类的外部写一个函数，第二个步骤是把这个新函数的名字赋值给类.原始函数
class 类():
def 原始函数(self):
print('我是原始函数！')
def 新函数(self): #定义新方法
print('我是重写后的新函数!')
a = 类() # 实例化
a.原始函数()
# 用新函数代替原始函数，也就是【重写类方法】
类.原始函数 = 新函数
# 现在原始函数已经被替换了
a.原始函数()
#结果展示
我是原始函数！
我是重写后的新函数!
初始化函数
class 类():
def __init__(self): #写法是固定的
print('实例化成功！')
实例 = 类()
#可以接受参数传递
class 成绩单():
def __init__(self,学生姓名,语文_成绩,数学_成绩): #定义初始化函数
self.学生姓名 = 学生姓名
self.语文_成绩 = 语文_成绩
self.数学_成绩 = 数学_成绩
def 打印成绩单(self):
print(self.学生姓名 + '的成绩单如下：')
print('语文成绩：'+ str(self.语文_成绩))
print('数学成绩：'+ str(self.数学_成绩))
成绩单1 = 成绩单('张三',99,88)
成绩单2 = 成绩单('李四',64,73) #传入参数
成绩单3 = 成绩单('王五',33,22)
成绩单1.打印成绩单()
成绩单2.打印成绩单() #实例对象调用方法
成绩单3.打印成绩单()
#结果展示
张三的成绩单如下：
语文成绩：99
数学成绩：88
李四的成绩单如下：
语文成绩：64
数学成绩：73
王五的成绩单如下：
语文成绩：33
数学成绩：22
类的继承（父类，子类）
百分百继承父类的方法
class 父类():
def __init__(self,参数):
self.变量 = 参数
def 打印属性(self):
print('变量的值是：')
print(self.变量)
class 子类(父类): #继承
pass # pass语句代表“什么都不做”
子类实例 = 子类(2)
子类实例.打印属性()
print('---------此处是分界线----------')
父类实例 = 父类(3)
父类实例.打印属性()
#结果展示
变量的值是：
2
---------此处是分界线----------
变量的值是：
3
在继承的基础上新增方法
class 基础机器人():
def __init__(self,参数):
self.姓名 = 参数
def 自报姓名(self):
print('我是' + self.姓名 + '！')
def 卖萌(self):
print('主人，求抱抱！')
class 高级机器人(基础机器人): #继承
def 高级卖萌(self): #新增方法
print('主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！')
安迪 = 高级机器人('安迪')
安迪.自报姓名()
安迪.卖萌()
安迪.高级卖萌()
#结果展示
我是安迪！
主人，求抱抱！
主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！
覆盖父类方法
class 基础机器人():
def __init__(self,参数):
self.姓名 = 参数
def 自报姓名(self):
print('我是' + self.姓名 + '！')
def 卖萌(self):
print('主人，求抱抱！')
class 高级机器人(基础机器人):
def 自报姓名(self): #覆盖父类的方法
print('我是高级机器人' + self.姓名 + '!')
def 卖萌(self):
print('主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！')
安迪 = 高级机器人('安迪')
安迪.自报姓名()
安迪.卖萌()
#结果展示
我是高级机器人安迪!
主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！
多重继承
class 基础机器人():
def 卖萌(self):
print('主人，求抱抱！')
# 注：因为多重继承要求父类是平等的关系，所以这里的“高级机器人”没有继承“基础机器人”
class 高级机器人():
def 高级卖萌(self):
print('主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！')
class 超级机器人(基础机器人,高级机器人): #多重继承
def 超级卖萌(self):
print('pika, qiu!')
皮卡 = 超级机器人()
皮卡.卖萌()
皮卡.高级卖萌()
皮卡.超级卖萌()
#结果展示
主人，求抱抱！
主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！
pika, qiu!