python笔记 基础语法·第13课 【“类”与“对象”的使用，“类”的实例化，初始化函数__init__(self)，类的继承，出租车计费代码】

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/weixin_41665477/article/details/99770256

类和对象

*【类】是【对象】的模版
有了图纸，可以批量制造物品。可以以“类”为模版，生成多个【实例对象】。
【实例化】：指从【类】变成【实例对象】的过程
示例1（多份成绩单录入）：

class 成绩单():
def 录入成绩单(self):
self.学生姓名 = input('请输入学生姓名：')
self.语文_成绩 = int(input('请输入语文成绩：'))
self.数学_成绩 = int(input('请输入数学成绩：'))
def 打印成绩单(self):
print(self.学生姓名 + '的成绩单如下：')
print('语文成绩：'+ str(self.语文_成绩))
print('数学成绩：'+ str(self.数学_成绩))
成绩单1 = 成绩单()             # 实例化，得到实例对象“成绩单1”
成绩单2 = 成绩单()             # 实例化，得到实例对象“成绩单2”
成绩单3 = 成绩单()             # 实例化，得到实例对象“成绩单2”

类的实例化

【实例化格式】 实例化后再使用和直接使用是不同的
示例2：

#直接使用格式
class 类A():
变量 1 = 100
变量 2 = 200
#此行留空
@classmethod      #需要声明
def 函数1(cls)：    #默认参数为 cls
print(cls,变量1)
print(cls,变量2)
类A.函数1()

#实例化后再使用
class 类A():
变量 1 = 'abc'
#此行留空
def 函数1(self)：    #不需要@classmenthod声明；默认参数为self
print('已经完成了实例化！')
print('类属性的值是'+ self.变量1)
a = 类A()    #先进行实例化；用【实例（变量）名=类()】的方式，为类创建一个实例
a.函数1()    #实例化后再使用；用【实例（变量）名.函数】的方式调用对应的实例

b = 类A()      #可以实例化多个不同的实例
b.函数1()      #实例化后再使用

以上说明
a = 类A() 用【实例（变量）名=类()】的方式，为类创建一个实例
a.函数1() 用【实例（变量）名.函数】的方式调用对应的实例
示例3（多份成绩单录入）：

#直接使用类
class 成绩单():
@classmethod
def 录入成绩单(cls):
cls.学生姓名 = input('请输入学生姓名：')
cls.语文_成绩 = int(input('请输入语文成绩：'))
cls.数学_成绩 = int(input('请输入数学成绩：'))

@classmethod
def 打印成绩单(cls):
print(cls.学生姓名 + '的成绩单如下：')
print('语文成绩：'+ str(cls.语文_成绩))
print('数学成绩：'+ str(cls.数学_成绩))

成绩单.录入成绩单()
成绩单.打印成绩单()

#实例化之后
class 成绩单():   # ①不用再写@classmethod
def 录入成绩单(self):  # ②cls变成self
self.学生姓名 = input('请输入学生姓名：')  # ③cls.变成self.
self.语文_成绩 = int(input('请输入语文成绩：'))
self.数学_成绩 = int(input('请输入数学成绩：'))

def 打印成绩单(self):
print(self.学生姓名 + '的成绩单如下：')
print('语文成绩：'+ str(self.语文_成绩))
print('数学成绩：'+ str(self.数学_成绩))

成绩单1 = 成绩单() # ④创建实例对象：成绩单1
成绩单1.录入成绩单() # ⑤实例化后使用
成绩单1.打印成绩单()

成绩单2 = 成绩单() # ④创建实例对象：成绩单1
成绩单2.录入成绩单() # ⑤实例化后使用
成绩单2.打印成绩单()

实例属性和类属性

二者关系：类和示例，就像母体和复制品的关系，类实例化多个实例之后，实例将100%获得类的属性，即【实例属性=类属性】
属性更改1：类的属性如果更改，则实例的属性也同步更改。
示例4：

class 类():
变量 = 100
实例1 = 类() # 实例化
实例2 = 类() # 实例化
print(实例1.变量)
print(实例2.变量)
类.变量 = 'abc'   # 修改类属性
print(实例1.变量)   # 实例属性同步变化
print(实例2.变量)   # 实例属性同步变化

属性更改2：如果更改某个实例的属性，则类的属性和其他实例的属性不会发生变化。
示例5：

class 类():
变量 = 100
实例1 = 类() # 实例化
实例2 = 类() # 实例化
print('原先的类属性：')
print(类.变量)
print('原先的实例1属性：')
print(实例1.变量)
print('原先的实例2属性：')
print(实例2.变量)
实例1.变量 = 'abc'
print('实例1的属性已经更改')
print(实例2.变量)

示例6：

class 类():
变量1 = 100
实例 = 类() # 实例化
类.变量2 = 'abc' # 新增类属性
print(实例.变量1)        #输出100
print(实例.变量2)        #输出abc（说明实例的参数发生了变化）

class 类():
变量1 = 100
实例 = 类() # 实例化
实例.变量2 = 'abc' # 新增实例属性
print(类.变量2)             #报错（说明类的参数不变）

实例方法和类方法

【重写类方法】
第一步：在类的外部写一个函数
第二步：把新函数的名字赋值给【类.原始函数】
示例7：

class 类():
def 原始函数(self):
print('我是原始函数！')
def 新函数(self):
print('我是重写后的新函数!')
a = 类()                            # 实例化
a.原始函数()                    #用新函数代替原始函数，也就是【重写类方法】
类.原始函数 = 新函数      #现在原始函数已经被替换了
a.原始函数()

【注意】这里的赋值是替换方法，不是调用函数，因此不加括号
示例8：

class 幸运():
def 好运翻倍(self):
print('好的，我把它存了起来，然后翻了888倍还给你：' + str(self.幸运数*888))
def 好运加倍(self):
print('我是重新写后的函数')
print('好的，我把它存下来， 然后翻了666倍还给你：'+str(self.幸运数*666))
幸运.幸运数 = int(input('你的幸运数是多少？请输入一个整数。'))
实例 = 幸运()           # 实例化
幸运.好运翻倍 = 好运加倍   #用新函数代替原始函数
实例.好运翻倍()

【注意】可以重写类的（函数）方法，不可重新实例的（函数）方法，函数（方法）是传承“类”的函数（方法），因此不可更改
示例9（错误代码）：

class 幸运():
def 好运翻倍(self):
print('好的，我把它存了起来，然后翻了888倍还给你：' + str(self.幸运数*888))
def 新好运翻倍(self):
print('我是重写后的新函数!')
print('好的，我把它存了起来，然后翻了666倍还给你：' + str(self.幸运数*666))
幸运.幸运数 = int(input('你的幸运数是多少？请输入一个整数。'))
实例 = 幸运()  # 实例化
实例.好运翻倍 = 新好运翻倍    # 尝试重写实例方法，将会报错
实例.好运翻倍()

初始化函数

初始化函数定义：当你创建一个实例的时候，这个函数就会被调用。
示例10：

class 类():
def __init__(self):
print('实例化成功！')
实例 = 类()

上面的代码在执行实例 = 类() 的语句时，就自动调用了__init__(self)函数。
示例11：

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.打印成绩单()

以上代码利用初始化函数，def init(self, 学生姓名 , 语文_成绩, 数学_成绩)，为下面每个实例自动创建多个示例属性，self.学生姓名、self.语文_成绩、self.数学_成绩。

初始化函数打印乘法口诀表

示例13：

#方式一（传统）
for i in range(1,10):
for x in range(1,i+1):
print( '%d X %d = %d' % (i ,x ,i*x) ,end = '  ' )
print('  ')

#方式二（初始化函数）
class 乘法表():
def __init__(self,number):                   #初始化函数
self.number = number

def 打印(self):
for i in range(1,self.number+1):
for x in range(1,i+1):
print( '%d X %d = %d' % (i ,x ,i*x) ,end = '  ' )
print('  ')

三三乘法表 = 乘法表(3)
三三乘法表.打印()

五五乘法表 = 乘法表(5)
五五乘法表.打印()

类的继承

类的继承：类的继承很大程度是为了避免重复性劳动。例如当需要写一个新的类，如果有很多代码和旧的类相同，有很多代码和旧的类不同，就可以用类的继承来避免重复写代码。
示例14（考试成绩）：

#方式一：有两个类的传统代码方式
class 成绩单_旧():
def __init__(self,学生姓名,语文_成绩,数学_成绩):
self.学生姓名 = 学生姓名
self.语文_成绩 = 语文_成绩
self.数学_成绩 = 数学_成绩

def 打印成绩单(self):
print(self.学生姓名 + '的成绩单如下：')
print('语文成绩：'+ str(self.语文_成绩))
print('数学成绩：'+ str(self.数学_成绩))

def 打印平均分(self):
平均分 = (self.语文_成绩 + self.数学_成绩)/2
print(self.学生姓名 + '的平均分是：' + str(平均分))

class 成绩单_新():
def __init__(self,学生姓名,语文_成绩,数学_成绩):
self.学生姓名 = 学生姓名
self.语文_成绩 = 语文_成绩
self.数学_成绩 = 数学_成绩

def 打印成绩单(self):
print(self.学生姓名 + '的成绩单如下：')
print('语文成绩：'+ str(self.语文_成绩))
print('数学成绩：'+ str(self.数学_成绩))

def 打印平均分(self):
平均分 = (self.语文_成绩 + self.数学_成绩)/2
print(self.学生姓名 + '的平均分是：' + str(平均分))

def 打印总分(self):
总分 = self.语文_成绩 + self.数学_成绩
print(self.学生姓名 + '的总分是：' + str(总分))

实例_旧 = 成绩单_旧('王明明',99,88)
实例_旧.打印成绩单()
实例_旧.打印平均分()

实例_新 = 成绩单_新('王明明',99,88)
实例_新.打印成绩单()
实例_新.打印平均分()
实例_新.打印总分()

#方式二：使用类的传承代码方式
class 成绩单_旧():
def __init__(self,学生姓名,语文_成绩,数学_成绩):
self.学生姓名 = 学生姓名
self.语文_成绩 = 语文_成绩
self.数学_成绩 = 数学_成绩
def 打印成绩单(self):
print(self.学生姓名 + '的成绩单如下：')
print('语文成绩：'+ str(self.语文_成绩))
print('数学成绩：'+ str(self.数学_成绩))
def 打印平均分(self):
平均分 = (self.语文_成绩 + self.数学_成绩)/2
print(self.学生姓名 + '的平均分是：' + str(平均分))
class 成绩单_新(成绩单_旧):       # 类的继承，格式为【class 新类(旧类)】
pass
新1 = 成绩单_新('王明明',99,88)
新1.打印平均分()
新1.打印成绩单()

【父类】及【子类】

父类：python中，统一把旧的类称之为【父类】
子类：统一把新写的类，称为【子类】，子类可以在父类的基础上改造类的方法（函数），因此说，子类继承父类。
标准书写格式：

class 父类():
def __init__(self,参数):      #初始化
self.变量 = 参数
def 打印属性(self):
print('变量的值是：')
print(self.变量)
class 子类(父类):
pass                  # pass语句代表“什么都不做”
子类实例 = 子类(2)
子类实例.打印属性()

示例15：

class 基础机器人():
def __init__(self,参数):
self.姓名 = 参数
def 自报姓名(self):
print('我是' + self.姓名 + '！')
def 卖萌(self):
print('主人，求抱抱！')
class 高级机器人(基础机器人):
def 高级卖萌(self):
print('主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！')
安迪 = 高级机器人('安迪')
安迪.自报姓名()
安迪.卖萌()
安迪.高级卖萌()

多重传承

子类从【一个父类】继承类方法，我们叫做“单继承”。
“多重继承”就是一个子类从【多个父类】中继承类方法。
格式是class 子类(父类1,父类2,……)

class 基础机器人():
def 卖萌(self):
print('主人，求抱抱！')
# 注：因为多重继承要求父类是平等的关系，所以这里的“高级机器人”没有继承“基础机器人”
class 高级机器人():
def 高级卖萌(self):
print('主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！')
class 超级机器人(基础机器人,高级机器人):
def 超级卖萌(self):
print('pika, qiu!')
print('''　           　へ　　　　　／|
/＼7　　　∠＿/
/　│　　／　／
│　Z＿,＜　／　　/`ヽ''')
安迪 = 超级机器人()
安迪.超级卖萌()
安迪.卖萌()
安迪.高级卖萌()

出租车计费代码

简单计费模式

class 出租车():
def __init__(self,单价,起步公里,起步价):
self.单价=单价
self.起步公里=起步公里
self.起步价=起步价
def 计费(self):
公里数 = float(input('请输入行程公里数：'))
if 公里数<= self.起步公里:
费用 = self.起步价
else:
费用 = 15 + (公里数-3)*self.单价
print('费用一共是：' + str(费用) + '元')
小王的出租车 = 出租车(2.5,3,15)
小王的出租车.计费()

“类”的继承模式

class 出租车():
def __init__(self,参数1,参数2,参数3):
self.每公里费用 = 参数1
self.最低公里 = 参数2
self.最低费用 = 参数3

def 计费(self):
self.记录行程()
self.统计费用()
self.结算信息()

def 记录行程(self):
self.公里数 = float(input('请输入行程公里数：'))
print('您的行程公里数是'+str(self.公里数)+'公里')

def 统计费用(self):
if self.公里数<= self.最低公里:
费用 = self.最低费用
else:
费用 = 15 + (self.公里数-3)*self.每公里费用
print('费用一共是：' + str(self.统计费用) + '元')
def 结算信息(self):
结算信息 = self.统计费用
print('费用一共是：' + str(self.结算信息) + '元')
wang = 出租车(2.5,3,15)
wang.记录行程()
wang.统计费用()
wang.结算信息()