4 《类class-cls =模板 —实例化— <对象self =复制品》
（1）类元素的【替换和新增】
1 ## 1. 类
2 #（1）类元素的【替换和新增】
3 class Bi():
4 h1 = 100
5 h2 = -5.83
6 h3 = 'abc'
7 Bi.h1 = 99
8 Bi.h4 = '新增一个变量'
9 print(Bi.h1)
10 print(Bi.h4)
11 print('
')
12
（2）调用 类【对象.属性】【对象.方法】
1 # （2）调用 类【对象.属性】【对象.方法】
2 ## 智能机器人
3 class Ai():
4 胸围 = 33 # 定义属性
5 腰围 = 44
6 def 卖萌(): # 定义方法
7 print('主人，求抱抱！')
8 def 奔跑():
9 print('我奔跑……哎呦喂！撞了。')
10 print(Ai.胸围) # 调用属性
11 print(Ai.腰围)
12 Ai.卖萌() # 调用方法
13 Ai.奔跑()
14 print('
')
（3）【类函数】-内部属性调用：@classmethod函数声明
1 # （1）【类函数】-内部属性调用：@classmethod函数声明
2 class Ab():
3 变量1 = 100
4 变量2 = 200
5 @classmethod # 声明函数1是类方法，才能使用class的变量
6 def 函数1(cls): # cls是class的简写，函数1的第一个参数必须是cls
7 print(cls.变量1) # 使用class的变量，必须注明出处，不能侵犯版权
8 print(cls.变量2)
9 def 函数2(): # 【不需要】使用类属性
10 print('不需要加@classmethod和上面三处cls。')
11 Ab.函数1()
12 Ab.函数2()
13 print('
')
14
15 ## 智能机器人
16 class Ai():
17 胸围 = 33 # 定义属性
18 腰围 = 44
19 臀围 = 55
20 def 函数1(): # 定义方法
21 print('不需要加@classmethod和上面三处cls。')
22 @classmethod # 声明函数1是类方法，才能使用class的变量
23 def 自报三围(cls): # cls是class的简写，函数1的第一个参数必须是cls
24 print('主人，我的三围是：')
25 # 使用class的变量，必须注明出处，不能侵犯版权
26 print('胸围：' + str(cls.胸围))
27 print('腰围：' + str(cls.腰围))
28 print('臀围：' + str(cls.臀围))
29 print('哈哈哈哈哈，下面粗上面细，我长得像个圆锥。')
30 Ai.函数1() # 调用方法
31 Ai.自报三围() # 调用方法
32 print('
')
（4）【类函数】-外部参数传递+修改
1 # （2）【类函数】-外部参数传递+修改
2 class 类():
3 def 函数(a):
4 总和 = a + 100
5 print('计算结果如下：')
6 print(总和)
7 ## 【类函数】外部参数修改
8 a = int(input('输入一个整数:'))
9 类.函数(a)
10 print('
')
实例：内部属性调用@classmethod & 外部参数传递
A. 外部参数传递
B. 内部属性调用@classmethod + 修改cls.a
1 # （3）实例：内部属性调用@classmethod & 外部参数传递
2 # A.外部参数
3 诗 = ['《卜算子》','我住长江头，','君住长江尾。','日日思君不见君，','共饮长江水。']
4 class 念诗类():
5 def 念诗函数(参数):
6 print('你要念诗给:'+a+'听！')
7 for i in 诗:
8 print(i)
9 a=input('给谁念诗：') # 外部参数修改，直接传递
10 念诗类.念诗函数(诗)
11 print('
')
12
13 # B.内部属性调用@classmethod + 修改cls.a= & 外部参数传递
14 class 念诗类():
15 诗 = ['《卜算子》','我住长江头，','君住长江尾。','日日思君不见君，','共饮长江水。']
16 @classmethod
17 def 念诗函数(cls):
18 ## 【类函数】内部修改参数+cls
19 cls.a = input('请输入你想给谁念诗：')
20 print('念给' + cls.a + '的诗：')
21 for i in cls.诗:
22 print(i)
23 念诗类.念诗函数()
24 print('
')
（5）两种方法对比：【直接使用类】、【实例化对象】
A. 直接使用类
1 # 1. 直接使用类
2 class 成绩单():
3 @classmethod
4 def 录入成绩单(cls):
5 cls.学生姓名 = input('请输入学生姓名：')
6 cls.语文_成绩 = int(input('请输入语文成绩：'))
7 cls.数学_成绩 = int(input('请输入数学成绩：'))
8 @classmethod
9 def 打印成绩单(cls):
10 print(cls.学生姓名 + '的成绩单如下：')
11 print('语文成绩：'+ str(cls.语文_成绩))
12 print('数学成绩：'+ str(cls.数学_成绩))
13 成绩单.录入成绩单()
14 成绩单.打印成绩单()
15 print('
')
B. 实例化之后
1 # 2. 实例化之后
2 # （1）实例化对象 和 直接使用类 的对比
3 class 成绩单(): # ①不用再写@classmethod
4 def 录入成绩单(self): # ②cls变成self
5 # ③cls.变成self.
6 self.学生姓名 = input('请输入学生姓名：')
7 self.语文_成绩 = int(input('请输入语文成绩：'))
8 self.数学_成绩 = int(input('请输入数学成绩：'))
9
10 def 打印成绩单(self):
11 print(self.学生姓名 + '的成绩单如下：')
12 print('语文成绩：'+ str(self.语文_成绩))
13 print('数学成绩：'+ str(self.数学_成绩))
14 成绩单1 = 成绩单() # ④创建实例对象：成绩单1
15 成绩单1.录入成绩单() # ⑤实例化后使用
16 成绩单1.打印成绩单()
17 print('
')
C. 改变实例/对象方法【类.原始函数=新函数】
（实例化后是对象，对象只能调用方法，类可以改变方法）
1 # （2）改变实例的方法【类.原始函数=新函数】
2 class 幸运():
3 def 好运翻倍(self):
4 print('我是原始函数')
5 print('翻了888倍：' + str(self.y*888))
6 def a(self):
7 print('我是新函数')
8 print('翻了666倍：'+str(self.y *666))
9 幸运.y=int(input('请输入一个整数。'))
10 实例 = 幸运() # 实例化
11 实例.好运翻倍() # 对象.原始函数
12 幸运.好运翻倍=a # 类.原始函数 = 新函数
13 实例.好运翻倍() # 对象.新函数
（6）给类“传递参数”/ 生成不同实例：【初始化实例__init__(self)】
A. 【打印成绩单】
1 # 初始化函数__init__(self)，生成不同的实例
2 # (1)打印成绩单
3 class 成绩单():
4 def __init__(self,学生姓名,语文_成绩,数学_成绩):
5 self.学生姓名 = 学生姓名
6 self.语文_成绩 = 语文_成绩
7 self.数学_成绩 = 数学_成绩
8 def 打印成绩单(self):
9 print(self.学生姓名 + '的成绩单如下：')
10 print('语文成绩：'+ str(self.语文_成绩))
11 print('数学成绩：'+ str(self.数学_成绩))
12 成绩单1 = 成绩单('张三',99,88) # 实例化
13 成绩单2 = 成绩单('李四',64,73)
14 成绩单3 = 成绩单('王五',33,22)
15 成绩单1.打印成绩单()
16 成绩单2.打印成绩单()
17 成绩单3.打印成绩单()
B. 【99乘法表】
1 # (2)99乘法表
2 class 乘法表():
3 def __init__(self):
4 self.k=int(input('输入整数1-10:'))
5 # 内部定义属性
6 def 打印(self):
7 # k是init部门的员工，用的时候要和它的上司init说一下
8 # ix是自己部门员工，不用加前缀
9 for i in range(1,self.k+1):
10 for x in range(1,i+1):
11 print('%d*%d=%d'%(i,x,i*x),end=' ')
12 print(' ')
13 结果 = 乘法表() # 实例化
14 结果.打印()
（7）类的“同级调用”---【返回值return】
### 同级调用：
### 分为2大类：见【血量游戏-项目1-2种封装】
##### 1.def函数之间：全封装函数def-- 函数的同级调用：函数名(a,b,...)
##### 2.封装成类class-函数def-- 类函数的同级调用：self.函数名(a,b,...)
# 注意def时第一个位置是self：函数名(self,a,b,...)
A. 【打印成绩单】
1 ##（1）打印成绩单
2 class 成绩单():
3 @classmethod
4 def 录入成绩单(cls):
5 cls.学生姓名 = input('请输入学生姓名：')
6 cls.语文_成绩 = int(input('请输入语文成绩：'))
7 cls.数学_成绩 = int(input('请输入数学成绩：'))
8 @classmethod
9 def 打印成绩单(cls):
10 print(成绩单.学生姓名 + '的成绩单如下：')
11 print('语文成绩：'+ str(成绩单.语文_成绩))
12 print('数学成绩：' + str(成绩单.语文_成绩))
13 @classmethod
14 def 打印平均分(cls):
15 平均分 = (cls.语文_成绩 + cls.数学_成绩) / 2
16 return 平均分
17 print('平均分：' + str(成绩单.平均分))
18 @classmethod
19 def 评级(cls):
20 平均分=cls.打印平均分() # 同级调用
21 if 平均分>=90:
22 print('评级：优')
23 else:
24 print('评级：差')
25 成绩单.录入成绩单()
26 成绩单.打印成绩单()
27 成绩单.打印平均分()
28 成绩单.评级()
29 # elif 80<=平均分<90:
30 # print('评级：优')
31 # elif 60<=平均分<80:
32 # print('评级：中')
B. 【成绩单是否及格】
1 ##（2）是否及格
2 class 成绩单():
3 @classmethod
4 def 录入成绩单(cls):
5 cls.学生姓名 = input('请输入学生姓名：')
6 cls.成绩 = int(input('请输入考试成绩：'))
7 @classmethod
8 def 计算是否及格(cls):
9 if cls.成绩 >= 60:
10 return '及格'
11 else:
12 return '不及格'
13 @classmethod
14 def 考试结果(cls):
15 结果=cls.计算是否及格() # 同级调用
16 if 结果=='及格':
17 print(cls.学生姓名+'同学考试通过啦！')
18 else:
19 print(cls.学生姓名 + '同学需要补考！')
20 成绩单.录入成绩单()
21 成绩单.计算是否及格()
22 成绩单.考试结果()
C. 【人事系统管理】
1 # （3）人事系统管理
2 class hrSystem:
3 list=['bob', 'candy', 'jony', 'kelly']
4 name = ''
5 salary = 0
6 kpi = 0 # 员工绩效 kpi
7 @classmethod ### A. 录入
8 def record(cls, name, salary, kpi):
9 cls.name = name
10 cls.salary = salary
11 cls.kpi = kpi
12 @classmethod ### B. 检查
13 def check_name(cls):
14 if cls.name in cls.list:
15 print('
录入正确！')
16 return 1 # return 必须写在最后
17 else:
18 print('
录入错误！spy不是本公司员工！')
19 return 0
20 @classmethod ### C. 打印
21 def print_record(cls):
22 if cls.check_name(): # 同级调用，链接return返回值！
23 print(cls.name + '的工作信息如下：')
24 print('本月工资：' + str(cls.salary))
25 print('本年绩效：' + str(cls.kpi))
26 else:
27 exit() # 不是员工无奖励，结束程序
28 @classmethod ### D. 奖励
29 def kpi_reward(cls):
30 final_kpi=cls.kpi
31 if final_kpi > 95:
32 print('恭喜'+cls.name+'拿到明星员工奖杯！')
33 elif 80 <= final_kpi <= 95:
34 print('恭喜' + cls.name + '拿到优秀员工奖杯！')
35 else:
36 print('很遗憾,'+cls.name+',希望来年勇创佳绩！')
37 hrSystem.record('bob', 13000, 98)
38 hrSystem.print_record()
39 # check_name()通过print_record()调用
40 # 所以不用写hrSystem.check_name()！！！
41 hrSystem.kpi_reward()
42 hrSystem.record('candy', 8000, 89)
43 hrSystem.print_record()
44 hrSystem.kpi_reward()
45 hrSystem.record('k', 8000, 75)
46 hrSystem.print_record()
47 hrSystem.kpi_reward()
（7）改装模板---类的“继承”：【子类】重写/添加【父类】
A. 【打印成绩单】
1 ## （1）成绩单
2 #【父类】
3 class 成绩单_旧():
4 def __init__(self,学生姓名,语文_成绩,数学_成绩):
5 self.学生姓名 = 学生姓名
6 self.语文_成绩 = 语文_成绩
7 self.数学_成绩 = 数学_成绩
8 def 打印成绩单(self):
9 print(self.学生姓名 + '的成绩单如下：')
10 print('语文成绩：'+ str(self.语文_成绩))
11 print('数学成绩：'+ str(self.数学_成绩))
12 def 打印平均分(self):
13 平均分 = (self.语文_成绩 + self.数学_成绩)/2
14 print(self.学生姓名 + '的平均分是：' + str(平均分))
15 实例_旧 = 成绩单_旧('王明明',99,88)
16 实例_旧.打印成绩单()
17 实例_旧.打印平均分()
18 print('
')
19 #【子类】
20 class 成绩单_新(成绩单_旧):
21 def 打印总分(self):
22 总分 = self.语文_成绩 + self.数学_成绩
23 print(self.学生姓名 + '的总分是：' + str(总分))
24 实例_新 = 成绩单_新('王明明',90,80)
25 实例_新.打印成绩单()
26 实例_新.打印平均分()
27 实例_新.打印总分()
28 print('
')
B. 【机器人】
1 ## （2）机器人
2 #【父类】
3 class 基础机器人():
4 def __init__(self,参数):
5 self.姓名 = 参数
6 def 自报姓名(self):
7 print('我是' + self.姓名 + '！')
8 def 卖萌(self):
9 print('主人，求抱抱！')
10 鲁宾 = 基础机器人('鲁宾')
11 鲁宾.自报姓名()
12 鲁宾.卖萌()
13 print('
')
14 #【子类】
15 class 高级机器人(基础机器人):
16 def __init__(self, 参数, 参数1):# 重写父类初始化函数
17 self.姓名 = 参数
18 self.智商 = str(参数1)
19 def 自报姓名(self): # 重写父类方法
20 print('我'+self.姓名 + ',智商是'+self.智商)
21 def 高级卖萌(self): # 添加新功能
22 print('主人，我爱你！')
23 安迪 = 高级机器人('安迪',180)
24 安迪.自报姓名()
25 安迪.高级卖萌()
C. 【多类继承】
1 # （3）多类继承
2 class 基础机器人():
3 def 卖萌(self):
4 print('主人，求抱抱！')
5 class 高级机器人():
6 def 高级卖萌(self):
7 print('主人，我爱你！')
8 class 超级机器人(基础机器人, 高级机器人):
9 def 超级卖萌(self):
10 print('pika, qiu!')
11 print(''' /\_)o<
12 | \
13 | O . O|
14 \_____/''')
15 皮卡 = 超级机器人()
16 皮卡.卖萌()
17 皮卡.高级卖萌()
18 皮卡.超级卖萌()
D. 【出租车计费】
1 # （4）出租车计费
2 #【父类】
3 class 出租车():
4 def __init__(self,x1,x2,x3,x4):
5 self.name=x1
6 self.单价=x2
7 self.起步 = x3
8 self.起步费 = x4
9 def 计费(self):
10 self.record()
11 self.output()
12 def record(self):
13 print(self.name + '每公里收费' + str(self.单价) + '元，',end='')
14 print('起步'+str(self.起步)+'公里,起步费'+str(self.起步费)+'元',end='')
15 self.num = float(input('
行程公里数:'))
16 def output(self):
17 if self.num<=self.起步:
18 print('按起步费算:'+str(self.起步费))
19 else:
20 money=self.起步费+(self.num-3)*self.单价
21 print('车费是:'+str(money)+'
')
22 # money是本部员工,num/单价/最低费用是别部员工
23 a = 出租车('张三', 2.5, 3.0, 15)
24 a.计费()
25 #【子类】
26 class 电动车(出租车): # 重新定义父类初始化函数
27 def __init__(self,x1,x2,x3,x4):
28 self.name = x1
29 self.单价 = 0.8*x2
30 self.起步 = x3
31 self.起步费 = 0.8*x4
32 b = 电动车('李四',2.5,3.0,15)
33 b.计费()
实例：【调查问卷系统】（考虑不同问题、参与人数）
1 # （5）问卷调查类
2 # 【父类】
3 class Survey():
4 def __init__(self,question):
5 self.question = question
6 self.list= []
7 print(self.question)
8 def store_response(self,a):
9 self.list.append(a)
10 f=Survey('你最喜欢的美食？') # 实例化
11 ### 父类外面的循环
12 # while True:
13 # a=input('请回答，按 q 键退出：')
14 # if a=='q':
15 # break
16 # f.store_response(a) # 调用父类函数a=new
17 # for i in f.response: # 实例.属性[]
18 # print('美食:'+i)
19 # print('
')
20
21 # 【子类】
22 class New(Survey):
23 def __init__(self,question):
24 Survey.__init__(self,question) # 调用父类方法
25 self.dict={}
26 def store_response(self,n,j):
27 self.dict[n]=j # 添加字典的键和值
28 h=New('你的籍贯地是哪？')
29 ### 子类外面的循环
30 while True:
31 j=input('请回答，按 q 键退出：')
32 if j=='q':
33 break
34 n=input('输入姓名:')
35 h.store_response(n,j) # 调用父类函数a=new
36 # for i in h.dict(): # 实例.属性{}
37 # print(i+':'+h.dict[i])
38 for n,j in h.dict.items(): # 同时取键：值
39 print(n+':'+j)