第十三章,面向对象
初识对象
生活中数据的组织
学校开学,要求学生填写自己的基础信息,一人发一张白纸,让学生自己填
我叫林军杰,今年31岁.来自山东省,我是男的,中国人
内容混乱
改为登记表,打印出来让学生自行填写:
姓名 林军杰
姓别 男
国籍 中国
籍贯 山东省
年龄 31
整洁明了
程序中数据的组织
在程序中简单使用变量来记录学生信息
student_1 = {
"姓名":"周杰轮",
"性别":"男",
"国籍":"中国",
"籍贯":"台湾省",
"年龄":33
}
student_2 = "我叫林军杰,今年31岁,男的,来自中国山东省"
student_3 = [
"邓紫旗",
"中国",
"北京市",
26,
"女"
]
混乱、不统一
思考:
使用变量记录数据太乱了。
如果程序中也和生活中一样
- 可以设计表格
- 可以将设计的表格打印出来
- 可以将打印好的表格供人填写内容
那么数据的组织就非常方便了。
使用对象组织数据
在程序中是可以做到和生活中那样,设计表格、生产表格、填写表格的组织形式的。
1.在程序中设计表格,我们称之为:设计类(class)
class Student:
name = None # 记录学生姓名
2.在程序中打印生产表格,我们称之为:创建对象
# 基于类创建对象
stu_1 = Student()
stu_2 = Student()
3.在程序中填写表格,我们称之为:对象属性赋值
stu_1.name = "周杰轮" # 为学生1对象赋予名称属性值
stu_2.name = "林军杰" # 为学生2对象赋予名称属性值
例:
# 1. 设计一个类(类比生活中:设计一张登记表)
class Student:
name = None # 记录学生姓名
gender = None # 记录学生性别
nationality = None # 记录学生国籍
native_place = None # 记录学生籍贯
age = None # 记录学生年龄
# 2. 创建一个对象(类比生活中:打印一张登记表)
stu_1 = Student()
# 3. 对象进行赋值(类比生活中:填写表单)
stu_1.name = "林俊杰"
stu_1.gender = "男"
stu_1.nationality = "中国"
stu_1.native_place = "山东省"
stu_1.age = 31
# 4. 获取对象中记录的信息
print(stu_1.name)
print(stu_1.gender)
print(stu_1.nationality)
print(stu_1.native_place)
print(stu_1.age)
总结
1.生活中或是程序中,我们都可以使用设计表格、生产表格、填写表格的形式组织数据
2.进行对比,在程序中:
- 设计表格,称之为:设计类(class)
- 打印表格,称之为:创建对象
- 填写表格,称之为:对象属性赋值
成员方法
类的定义和使用
在上一节中,我们简单了解到可以使用类去封装属性,并基于类创建出一个个的对象来使用。
现在我们来看看类的使用语法:
class 类名称: class是关键字,表示要定义类了
类的属性 类的属性,即定义在类中的变量(成员变量)
类的行为 类的行为,即定义在类中的函数(成员方法)
创建类对象的语法:
对象 = 类名称()
类(class)
- 属性(数据)
- 行为(函数)
成员变量和成员方法
那么,什么是类的行为(方法)呢?
class Student:
name = None
age = None
def say_hi(self):
print(f"Hello 大家好,我是{self.name}")
stu = Student()
stu.name = "周杰伦"
stu.say_hi()
可以看出,类中:
- 不仅可以定义属性用来记录数据
- 也可以定义函数,用来记录行为
其中:
- 类中定义的属性(变量),我们称之为:成员变量
- 类中定义的行为(函数),我们称之为:成员方法
从今天开始,定义在类内部的函数称之为方法
成员方法的定义语法
在类中定义成员方法和定义函数基本一致,但仍有细微区别:
def 方法名(self,形参1,......,形参N):
方法体
可以看到,在方法定义的参数列表中,有一个:self关键字
self关键字是成员方法定义的时候,必须填写的。
- 它用来表示类对象自身的意思
- 当我们使用类对象调用方法的是,self会自动被python传入
- 在方法内部,想要访问类的成员变量,必须使用self
注意事项
self关键字,尽管在参数列表中,但是传参的时候可以忽略它。
如:
class Student:
name = None
def say_hi(self):
print(f"Hello 大家好,我是{self.name}")
def say_hi2(self, msg):
print(f"Hello 大家好,我是{self.name},{msg}")
stu = Student()
stu.name = "周杰伦"
stu.say_hi() # 调用的时候无需传参
stu.say_hi2("很高兴认识大家") # 调用的时候,需要传msg参数
可以看到,在传入参数的时候,self是透明的,可以不用理会它。
总结
1.类是由哪两部分组成呢?
- 类的属性,称之为:成员变量
- 类的行为,称之为:成员方法
注意:函数是写在类外的,定义在类内部,我们都称之为方法哦
2.类和成员方法的定义语法
class 类名称:
成员变量
def 成员方法(self,参数列表):
成员方法体
对象 = 类名称()
3.self的作用
- 表示类对象本身的意思
- 只有通过self,成员方法才能访问类的成员变量
- self出现在形参列表中,但是不占用参数位置,无需理会
类和对象
现实世界的事物和类
现实事物
- 属性
- 行为
现实世界的事物也有属性和行为,类也有属性和行为。
使用程序中的类,可以完美的描述现实世界的事物
类和对象
基于类创建对象的语法:对象名 = 类名称()
为什么非要创建对象才能使用呢?
类只是一种程序内的“设计图纸”,需要基于图纸生产实体(对象),才能正常工作
这种套路,称之为面向对象编程
基于类创建对象
# 设计一个闹钟类
class Clock:
id = None # 序列号
price = None # 价格
def ring(self):
import winsound
winsound.Beep(2000, 1000)
# 构建两个闹钟对象并让其工作
clock1 = Clock()
clock1.id = "003032"
clock1.price = "19.99"
print(f"闹钟ID:{clock1.id},价格:{clock1.price}")
clock1.ring()
clock2 = Clock()
clock2.id = "003033"
clock2.price = "21.99"
print(f"闹钟ID:{clock2.id},价格:{clock2.price}")
clock2.ring()
这就是面向对象编程:
设计类,基于类创建对象,由对象做具体的工作
总结
1.现实世界的事物由什么组成?
- 属性
- 行为
类也可以包含属性和行为,所以使用类描述现实世界事物是非常合适的
2.类和对象的关系是什么?
类是程序中的“设计图纸”
对象是基于图纸生产的具体实体
3.什么是面向对象编程?
面向对象编程就是,使用对象进行编程。
即,设计类,基于类创建对象,并使用对象来完成具体的工作
构造方法
属性(成员变量)的赋值
class Student:
name = None # 名称
age = None # 年龄
tel = None # 手机号
student1 = Student()
student1.name = "周杰轮"
student1.age = 31
student1.tel = "18012340000"
student2 = Student()
student2.name = "周杰轮"
student2.age = 31
student2.tel = "18012340000"
上述代码中,为对象的属性赋值需要依次进行,略显繁琐。有没有更加高效的方式,能够一行代码就完成呢?
思考:Student()
这个括号,能否像函数(方法)那样,通过传参的形式对属性赋值呢?
可以,需要使用构造方法:__init__()
构造方法
Python类可以使用:__init__()方法,称之为构造方法。
可以实现:
- 在创建类对象(构造类)的时候,会自动执行。
- 在创建类对象(构造类)的时候,将传入参数自动传递给init方法使用。
# 构造方法的名称:__init__
class Student:
# name = None
# age = None
# tel = None
def __init__(self, name, age, tel):
self.name = name
self.age = age
self.tel = tel
print("Student类创建了一个类对象")
stu = Student("周杰伦", 31, "18500006666")
print(stu.name)
print(stu.age)
print(stu.tel)
- 构建类时传入的参数会自动提供给__init__方法
- 构建类的时候__init__方法会自动执行
构造方法注意事项
重要的事情说三遍,构造方法名称:__init__ __init__ __init__,千万不要忘记init前后都有2个下划线
构造方法也是成员方法,不要忘记在参数列表中提供:self
在构造方法内定义成员变量,需要使用self关键字
def __init__(self, name, age, tel):
self.name = name # 名称
self.age = age # 年龄
self.tel = tel # 手机号
这是因为:变量是定义在构造方法内部,如果要成为成员变量、需要用self来表示。
总结
1.构造方法的名称是:
init,注意init前后的2个下划线符号
2.构造方法的作用:
- 构建类对象的时候会自动运行
- 构建类对象的传参会传递给构造方法,借此特性可以给成员变量赋值
3.注意事项:
- 构造方法不要忘记self关键字
- 在方法内使用成员变量需要使用self
练习
学生信息录入
开学了有一批学生信息需要录入系统,请设计一个类,记录学生的:姓名、年龄、地址,这3类信息
请实现:
- 通过for循环,配合input输入语句,并使用构造方法,完成学生信息的键盘录入
- 输入完成后,使用print语句,完成信息的输出
输出示例:
当前录入第1位学生信息,总共需录入10位学生信息
请输入学生姓名:周杰轮
请输入学生年龄:31
请输入学生地址:北京
学生1信息录入完成,信息为:【学生姓名:周杰轮,年龄:31,地址:北京】当前录入第2位学生信息,总共需录入10位学生信息
请输入学生姓名:
参考代码:
class Student:
def __init__(self, name, age, address):
self.name = name
self.age = age
self.address = address
for x in range(1, 11):
print(f"当前录入第{x}名学生信息,总共需录入10名学生信息")
name = input("请输入学生姓名:")
age = input("请输入学生年龄:")
address = input("请输入学生地址:")
student = Student(name, age, address)
print(f"学生{x}信息录入完成,信息为【学生姓名:{student.name},年龄:{student.age},地址:{student.address}】")
其它内置方法
魔术方法
上文学习的 init 构造方法,是Python类内置的方法之一。
这些内置的类方法,各自有各自特殊的功能,这些内置方法我们称之为:魔术方法
魔术方法:
- __init__构造方法
- __str__ 字符串方法
- __It__小于、大于符号比较
- __le__ 小于等于、大于等于符号比较
- __eq__ ==符号比较
魔术方法非常多,学习几个常见的即可
__str__字符串方法
class Student:
def __init__(self, name, age):
self.name = name # 学生姓名
self.age = age # 学生年龄
stu = Student("周杰伦", 31)
print(stu) <main.Student object at 0x0000021606059760>
print(str(stu)) <main.Student object at 0x0000021606059760>
当类对象需要被转换为字符串之时,会输出如上结果(内存地址)
内存地址没有多大作用,我们可以通过__str__方法,控制类转换为字符串的行为。
class Student:
def __init__(self, name, age):
self.name = name # 学生姓名
self.age = age # 学生年龄
def __str__(self):
return f"Student类对象,name:{self.name}, age:{self.age}"
stu = Student("周杰伦", 31)
print(stu) # 结果:Student类对象,name:周杰伦, age:31
print(str(stu)) # 结果:Student类对象,name:周杰伦, age:31
- 方法名:__str__
- 返回值:字符串
- 内容:自行定义
__lt__小于符号比较方法
class Student:
def __init__(self, name, age):
self.name = name # 学生姓名
self.age = age # 学生年龄
stu1 = Student("周杰伦", 31)
stu2 = Student("林俊杰", 36)
print(stu1 < stu2)
# 结果报错 TypeError: '<' not supported between instances of 'Student' and 'Student'
直接对2个对象进行比较是不可以的,但是在类中实现__lt__方法,即可同时完成:小于符号 和 大于符号 2种比较
class Student:
def __init__(self, name, age):
self.name = name # 学生姓名
self.age = age # 学生年龄
def __lt__(self, other):
return self.age < other.age
stu1 = Student("周杰伦", 31)
stu2 = Student("林俊杰", 36)
print(stu1 < stu2) # 结果:True
print(stu1 > stu2) # 结果:Falue
- 方法名:__lt__
- 传入参数:other,另一个类对象
- 返回值:True 或 False
- 内容:自行定义
__le__小于等于比较符号方法
魔术方法:le可用于:=两种比较运算符上。
class Student:
def __init__(self, name, age):
self.name = name # 学生姓名
self.age = age # 学生年龄
def __le__(self, other):
return self.age <= other.age
stu1 = Student("周杰伦", 31)
stu2 = Student("林俊杰", 36)
print(stu1 <= stu2) # 结果:True
print(stu1 >= stu2) # 结果:Falue
- 方法名:__le__
- 传入参数:other,另一个类对象
- 返回值:True 或 False
- 内容:自行定义
__eq__,比较运算符实现方法
class Student:
def __init__(self, name, age):
self.name = name # 学生姓名
self.age = age # 学生年龄
def __eq__(self, other):
return self.age == other.age
stu1 = Student("周杰伦", 36)
stu2 = Student("林俊杰", 36)
print(stu1 == stu2) # 结果:Ture
- 方法名:__eq__
- 传入参数:other,另一个类对象
- 返回值:True 或 False
- 内容:自行定义
不实现_eq 方法,对象之间可以比较,但是是比较内存地址,也即是:不同对象==比较一定是False结果。
实现了eq 方法,就可以按照自己的想法来决定2个对象是否相等了。
总结
方法 功能
__init__ 构造方法,可用于创建类对象的时候设置初始化行为
__sr__ 用于实现类对象转字符串的行为
__It__ 用于2个类对象进行小于或大于比较
__le__ 用于2个类对象进行小于等于或大于等于比较
__eq__ 用于2个类对象进行相等比较
封装
面向对象的三大特性
面向对象编程,是许多编程语言都支持的一种编程思想。
简单理解是:基于模板(类)去创建实体(对象),使用对象完成功能开发。
面向对象包含3大主要特性:
- 封装
- 继承
- 多态
封装
封装表示的是,将现实世界事物的:
- 属性
- 行为
封装到类中,描述为:
- 成员变量
- 成员方法
从而完成程序对现实世界事物的描述
对用户隐藏的属性和行为
现实世界中的事物,有属性和行为。
但是不代表这些属性和行为都是开放给用户使用的。
以手机为例
对用户开放的属性和行为:
- 序列号
- 品牌,型号
- 长宽高
- 上网
- 通话
- 拍照
对用户隐藏的属性和行为:
- 运行电压
- 驱动信息
- 程序调度
- 内存管理
苹果越狱、安卓root,也是为了突破权限使用这些对用户隐藏的属性和行为
私有成员
既然现实事物有不公开的属性和行为,那么作为现实事物在程序中映射的类,也应该支持。
类中提供了私有成员的形式来支持。
- 私有成员变量
- 私有成员方法
定义私有成员的方式非常简单,只需要:
私有成员变量:变量名以__开头(2个下划线)
私有成员方法:方法名以__开头(2个下划线)
即可完成私有成员的设置
class Phone:
__current_voltage = None # 私有成员变量
def __keep_single_core(self):
print("让CPU以单核模式运行") # 私有成员方法
使用私有成员
私有方法无法直接被类对象使用
私有变量无法赋值,也无法获取值
class Phone:
__current_voltage = None # 当前手机运行电压
def __keep_single_core(self):
print("让CPU以单核模式运行")
phone = Phone()
phone.__keep_single_core
print("phone.__current_voltage")
# 报错 AttributeError: 'Phone' object has no attribute '__keep_single_core'. Did you mean: '_Phone__keep_single_core'?
私有成员无法被类对象使用,但是可以被其它的成员使用。
class Phone:
__current_voltage = 0.5 # 当前手机运行电压
def __keep_single_core(self):
print("让CPU以单核模式运行")
def call_by_5g(self):
if self.__current_voltage >= 1:
print("5G通话开启")
else:
self.__keep_single_core()
print("电量不足,无法使用5g通话,并已设置为单核运行进行省电")
phone = Phone()
phone.call_by_5g()
总结
1.封装的概念是指?
将现实世界事物在类中描述为属性和方法,即为封装。
2.什么是私有成员?为什么需要私有成员?
现实事物有部分属性和行为是不公开对使用者开放的。同样在类中描述属性和方法的时候也需要达到这个要求,就需要定义私有成员了
3.如何定义私有成员?
成员变量和成员方法的命名均以_作为开头即可
4.私有成员的访问限制?
- 类对象无法访问私有成员
- 类中的其它成员可以迈问私有成员
思考:
私有成员的定义我们已经了解了,但是:
它有什关网佛聚际的意义吗?
在类中提供仅供内部使用的属性和方法,而不对外开放(类对象无法使用)
练习
设计带有私有成员的手机
设计一个手机类,内部包含:
私有成员变量:__is_5g_enable,类型bool,True表示开启5g,False表示关闭5g
私有成员方法:__check_5g(),会判断私有成员__is_5g_enable的值
- 若为True,打印输出:5g开启
- 若为False,打印输出:5g关闭,使用4g网络
公开成员方法:call_by_5g(),调用它会执行
- 调用私有成员方法:check 5g(),判断5g网络状态
- 打印输出:正在通话中
运行结果:5g关闭,使用4g网络
正在通话中
通过完成这个类的设计和使用,体会封装中私有成员的作用
- 对用户公开的,call_by_5g()方法
- 对用户隐藏的,__is_5g_enable私有变量和__check_5g私有成员
参考代码:
class Phone:
__is_5g_enable = False
def __check_5g(self):
if self.__is_5g_enable:
print("5g开启")
else:
print("5g关闭,使用4g网络")
def call_by_5g(self):
self.__check_5g()
print("正在通话中")
phone = Phone()
phone.call_by_5g()
继承
继承的基础语法
继承的引出
iPhone 6 → iPhone 6s → iPhone 7 → iPhone 8
如果你是设计师,你会如何选择?
1.每一代新款手机,都从零开始出设计图2
2. 基于老款的设计图,修修改改
class Phone:
IMEI =None # 序列号
producer = "HM" # 厂商
def call_by_4g(self):
print("4g通话")
构建Phone2022类,你会选择
1. 从头写一个新的类
2.基于已有的Phone类进行修改
class Phone:
IMEI =None # 序列号
producer = "HM" # 厂商
def call_by_4g(self):
print("4g通话")
def call_by_5g(self):
print("2022年最新5g通话")
我们可以使用继承,来完成此需求
单继承
class Phone:
IMEI =None # 序列号
producer = "HM" # 厂商
def call_by_4g(self):
print("4g通话")
class Phone2022(Phone):
face_id = "10001" # 面部识别ID
def call_by_5g(self):
print("2022年最新5g通话")
class 类名(父类名):
类内容体
继承分为:单继承和多继承
使用如图语法,可以完成类的单继承。
继承表示:将从父类那里继承(复制)来成员变量和成员方法(不含私有)
多继承
Python的类之间也支持多继承,即一个类,可以继承多个父类
class 类名(父类1,父类2,......,父类N):
类内容体
class Phone:
IMEI =None # 序列号
producer = "HM" # 厂商
def call_by_5g(self):
print("5g通话")
class NFCReader:
nfc_type = "第五代"
producer = "HM"
def read_card(self):
print("NFC读卡")
def write_card(self):
print("NFC写卡")
class RemoteControl:
rc_type = "红外遥控"
def control(self):
print("红外遥控开启了")
class MyPhone(Phone, NFCReader, RemoteControl):
pass
phone = MyPhone()
phone.call_by_5g()
phone.read_card()
phone.write_card()
phone.control()
多继承注意事项
多个父类中,如果有同名的成员,那么默认以继承顺序(从左到右)为优先级。
即:先继承的保留,后继承的被覆盖
class Phone:
IMEI =None # 序列号
producer = "ITCAST" # 厂商
def call_by_5g(self):
print("5g通话")
class NFCReader:
nfc_type = "第五代"
producer = "HM"
def read_card(self):
print("NFC读卡")
def write_card(self):
print("NFC写卡")
class RemoteControl:
rc_type = "红外遥控"
def control(self):
print("红外遥控开启了")
class MyPhone(Phone, NFCReader, RemoteControl):
pass
phone = MyPhone()
phone.call_by_5g()
phone.read_card()
phone.write_card()
phone.control()
print(phone.producer) # 输出为ITCAST
总结
1.什么是继承?
继承就是一个类,继承另外一个类的成员变量和成员方法
语法:
class 类(父类,父类2, 父类N):
类内容体
子类构建的类对象,可以
有自己的成员变量和成员方法
使用父类的成员变量和成员方法
2.单继承和多继承
单继承:一个类继承另一个类
多继承:一个类继承多个类,按照顺序从左向右依次继承
多继承中,如果父类有同名方法或属性,先继承的优先级高于后继承
3.pass关键字的作用是什么
pass是占位语句,用来保证函数(方法)或类定义的完整性,表示无内容,空的意思
复写和使用父类成员
复写
子类继承父类的成员属性和成员方法后,如果对其“不满意”,那么可以进行复写。
即:在子类中重新定义同名的属性或方法即可。
class Phone:
IMEI =None # 序列号
producer = "ITCAST" # 厂商
def call_by_5g(self):
print("使用5g网络进行通话")
class MyPhone(Phone):
producer = "ITHEIMA" # 复写父亲的成员属性
def call_by_5g(self):
print("开启CPU单核模式,确保通话的时候省电")
print("使用5g网络进行通话")
print("关闭CPU单核模式,确保性能")
phone = MyPhone()
phone.call_by_5g()
print(phone.producer)
调用父类同名成员
一旦复写父类成员,那么类对象调用成员的时候,就会调用复写后的新成员
如果需要使用被复写的父类的成员,需要特殊的调用方式:
方式1:
调用父类成员
使用成员变量:父类名.成员变量
使用成员方法:父类名.成员方法(self)
方式2:
使用super()调用父类成员
使用成员变量:super().成员变量
使用成员方法:super().成员方法
总结
1.复写表示:
对父类的成员属性或成员方法进行重新定义
2.复写的语法:
在子类中重新实现同名成员方法或成员属性即可
3.在子类中,如何调用父类成员
方式1:
调用父类成员
使用成员变量:父类名.成员变量
使用成员方法:父类名.成员方法(self)
方式2:
使用super()调用父类成员
使用成员变量:super().成员变量
使用成员方法:super().成员方法
注意:只可以在子类内部调用父类的同名成员,子类的实体类对象调用默认是调用子类复写的
类型注解
变量的类型注解
类型注解
Python在3.5版本的时候引入了类型注解,以方便静态类型检查工具,IDE等第三方工具。
类型注解:在代码中涉及数据交互的地方,提供数据类型的注解(显式的说明)。
主要功能:
- 帮助第三方IDE工具(如PyCharm)对代码进行类型推断,协助做代码提示
- 帮助开发者自身对变量进行类型注释
支持:
- 变量的类型注解
- 函数(方法)形参列表和返回值的类型注解
类型注解的语法
为变量设置类型注解
基础语法:变量:类型
基础数据类型注解:
var_1: int = 10
var_2: str = "itheima"
var_3: bool = True
类对象类型注解:
class Student:
pass
stu:Student = Student()
基础容器类型注解:
my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_dict: dict = {"itheima": 666}
容器类型详细注解:
my_list: list[int] = [1, 2, 3]
my_tuple: tuple[int, str, bool] = (1, "itheima", True)
my_dict: dict[str, int] = {"itheima": 666}
注意:
- 元组类型设置类型详细注解,需要将每一个元素都标记出来
- 字典类型设置类型详细注解,需要2个类型,第一个是key第二个是value
除了使用变量:类型,这种语法做注解外,也可以在注释中进行类型注解。
语法:
# type:类型
在注释中进行类型注解
import json
import random
var_1 = random.randint(1, 10) # type: int
var_2 = json.loads('{"name": "zhangsan"}') # type: dict[str, str]
def func():
return
var_3 = func() # type: int
为变量设置注解,显示的变量定义,一般无需注解:
var_1: int = 10
var_2: str = "itheima"
var_3: bool = True
如上述例子,就算不写注解,也明确的知晓变量的类型
一般,无法直接看出变量类型之时会添加变量的类型注解:
import json
import random
var_1: int = random.randint(1, 10)
var_2: dict = json.loads('{"name": "zhangsan"}')
def func():
return
var_3: int = func()
类型注解的限制
类型注解主要功能在于:
- 帮助第三方IDE工具(如PyCharm)对代码进行类型推断,协助做代码提示
- 帮助开发者自身对变量进行类型注释(备注)
并不会真正的对类型做验证和判断。
也就是,类型注解仅仅是提示性的,不是决定性的
var_1: int = "itheima"
var_2: str = 123
如上述例子,是不会报错的哦。
总结
1.什么是类型注解,有什么作用?
在代码中涉及数据交互之时,对数据类型进行显式的说明,可以帮助:
- PyCharm等开发工具对代码做类型推断协助做代码提示
- 开发者自身做类型的备注
2.类型注解支持:
- 变量的类型注解
- 函数(方法)的形参和返回值的类型注解
3.变量的类型注解语法
- 语法1:变量:类型
- 语法2:在注释中,# type:类型
4.注意事项
- 类型注解只是提示性的,并非决定性的。数据类型和注解类型无法对应也不会导致错误
函数(方法)的类型注解
函数(方法)的类型注解 - 形参注解
- 在编写函数(方法),使用形参data的时候,工具没有任何提示
- 在调用函数(方法),传入参数的时候,工具无法提示参数类型
这些都是因为,我们在定义函数(方法)的时候,没有给形参进行注解
函数和方法的形参类型注解语法:
def 函数方法名(形参名:类型,形参名:类型,......):
pass
def add(x: int, y: int):
return x + y
def func(data: list)
pass
函数(方法)的类型注解 - 返回值注解
同时,函数(方法)的返回值也是可以添加类型注解的。
语法如下:
def 函数方法名(形参:类型,......,形参:类型) -> 返回值类型:
pass
def add(x: int, y: int) -> int:
return x + y
def func(data: list[int]) -> list[int]:
return data
总结
1.函数(方法)可以为哪里添加注解?
- 形参的类型注解
- 返回值的类型注解
2.函数(方法)的类型注解语法?
def 函数方法名(形参:类型,......, 形参:类型) -> 返回值类型:
pass
注意,返回值类型注解的符号使用:->
Union类型
下述变量如何进行类型注解:
my_list = [1, 2, "itheima", "itcast"]
my_dict = {"name": "周杰伦", "age": 31}
使用Union[类型,......,类型]
可以定义联合类型注解:
from typing import Union
my_list: list[Union[str, int]] = [1, 2, "itheima", "itcast"]
my_dict: dict[str, Union[str, int]] = {"name": "周杰伦", "age": 31}
Union联合类型注解,在变量注解、函数(方法)形参和返回值注解中,均可使用。
from typing import Union
my_list: list[Union[int, str]] = [1, 2, "itheima", "itcast"]
my_dict: dict[str, Union[str, int]] = {"name": "周杰伦", "age": 31}
def func(data: Union[int, str]) -> Union[int, str]:
pass
总结
1.什么是Union类型?
使用Union可以定义联合类型注解
2.Union的使用方式
- 导包:from typing import Union
- 使用:Union[类型,......,类型]
多态
多态
多态,指的是:多种状态,即完成某个行为时,使用不同的对象会得到不同的状态。
如何理解?
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("汪汪汪")
class Cat(Animal):
def speak(self):
print("喵喵喵")
def make_noise(animal:Animal):
animal.speak()
dog = Dog()
cat = Cat()
make_noise(dog)
make_noise(cat)
同样的行为(函数) 传入不同的对象 得到不同的状态
多态常作用在继承关系上.
比如
- 函数(方法)形参声明接收父类对象
- 实际传入父类的子类对象进行工作
即:
- 以父类做定义声明
- 以子类做实际工作
- 用以获得同一行为,不同状态
抽象类(接口)
细心的同学可能发现了,父类Animal的speak方法,是空实现
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("汪汪汪")
class Cat(Animal):
def speak(self):
print("喵喵喵")
这种设计的含义是:
- 父类用来确定有哪些方法
- 具体的方法实现,由子类自行决定
这种写法,就叫做抽象类(也可以称之为接口)
抽象类:含有抽象方法的类称之为抽象类
抽象方法:方法体是空实现的(pass)称之为抽象方法
为什么要使用抽象类呢?
空调制造标准:
- 可以制冷
- 可以制热
- 左右摆风
提出标准后,不同的厂家各自实现标准的要求。
抽象类就好比定义一个标准,包含了一些抽象的方法,要求子类必须实现。
class AC:
def cool_wind(self):
"""制冷"""
pass
def hot_wind(self):
"""制热"""
pass
def swing_l_r(self):
"""左右摆风"""
pass
class Midea_AC(AC):
def cool_wind(self):
print("美的空调制冷")
def hot_wind(self):
print("美的空调制热")
def swing_l_r(self):
print("美的空调左右摆风")
class GREE_AC(AC):
def cool_wind(self):
print("格力空调制冷")
def hot_wind(self):
print("格力空调制热")
def swing_l_r(self):
print("格力空调左右摆风")
配合多态,完成
- 抽象的父类设计(设计标准)
- 具体的子类实现(实现标准)
def make_cool(ac: AC):
ac.cool_wind()
midea_ac = Midea_AC()
gree_ac = GREE_AC()
make_cool(midea_ac) # 输出:美的空调制冷
make_cool(gree_ac) # 输出:格力空调制冷
总结
1.什么是多态?
多态指的是,同一个行为,使用不同的对象获得不同的状态。
如,定义函数(方法),通过类型注解声明需要父类对象,实际传入子类对象进行工作,从而获得不同的工作状态
2.什么是抽象类(接口)
包含抽象方法的类,称之为抽象类。抽象方法是指:没有具体实现的方法(pass)称之为抽象方法
3.抽象类的作用
多用于做顶层设计(设计标准),以便子类做具体实现。
也是对子类的一种软性约束,要求子类必须复写(实现)父类的一些方法
并配合多态使用,获得不同的工作状态。
综合案例
数据分析案例:
某公司,有2份数据文件,现需要对其进行分析处理,计算每日的销售额并以柱状图表的形式进行展示
数据内容:
2011年1月销售数据.txt
2011年2月销售数据JSON.txt
- 1月份数据是普通文本,使用逗号分割数据记录,从前到后分别是(日期,订单id,销售额,销售省份)
- 2月份数据是JSON数据,同样包含(日期,订单id,销售额,销售省份)
需求分析:
读取数据 → 封装数据对象 → 计算数据对象 → pyecharts绘图
作为面向对象的程序员
我们全程将使用面向对象的思想来进行任务的开发
参考代码:
data_define.py:
"""
数据定义的类
"""
class Record:
def __init__(self, date, order_id, money, province):
self.date = date # 订单日期
self.order_id = order_id # 订单ID
self.money = money # 订单金额
self.province = province # 销售省份
def __str__(self):
return f"{self.date}, {self.order_id}, {self.money}, {self.province}"
file_define.py:
"""
和文件相关的类定义
"""
import json
from data_define import Record
# 先定义一个抽象用来做顶层设计,确定有哪些功能需要实现
class FileReader:
def read_data(self) -> list[Record]:
"""读取文件的数据,读到的每一条数据都转换为Record对象,将它们都封装到list内返回即可"""
pass
class TextFileReader(FileReader):
def __init__(self, path):
(self).path = path # 定义成员变量记录文件的路径
# 复写(实现抽象方法)父类的方法
def read_data(self) -> list[Record]:
f = open(self.path, "r", encoding="UTF-8")
record_list: list[Record] = [ ]
for line in f.readlines():
line = line.strip() # 消除读取到每一行数据中的\n
data_list = line.split(",")
record = Record(data_list[0], data_list[1], int(data_list[2]), data_list[3])
record_list.append(record)
f.close() return
record_list
class JsonFileReader(FileReader):
def __init__(self, path):
(self).path = path # 定义成员变量记录文件的路径
def read_data(self) -> list[Record]:
f = open(self.path, "r", encoding="UTF-8")
record_list: list[Record] = [ ]
for line in f.readlines():
data_dict = json.loads(line)
record = Record(data_dict["date"], data_dict["order_id"], int(data_dict["money"]), data_dict["province"])
record_list.append(record)
f.close()
return record_list
if __name__ == '__main__':
text_file_reader = TextFileReader("D:/2011年1月销售数据.txt")
json_file_reader = JsonFileReader("D:/2011年2月销售数据JSON.txt")
list1 = text_file_reader.read_data()
list2 = json_file_reader.read_data()
for l in list1:
print()
for l in list2:
print(l)
main.py:
"""
实现步骤:
1.设计一个类,可以完成数据的封装
2.设计一个抽象类,定义文件读取的相关功能,并使用子类实现具体功能
3.读取文件,生产数据对象
4.进行数据需求的选辑计算(计算每一天的销售额)
5通过PyEcharts进行图形绘制
"""
from file_define import FileReader,TextFileReader,JsonFileReader
from data_define import Record
from pyecharts.charts import Bar
from pyecharts.options import *
from pyecharts.globals import ThemeType
text_file_reader = TextFileReader("D:/2011年1月销售数据.txt")
json_file_reader = JsonFileReader("D:/2011年2月销售数据JSON.txt")
jan_data: list[Record] = text_file_reader.read_data()
feb_data: list[Record] = json_file_reader.read_data() # 将两个月份的数据合并为1个list来存储
all_data: list[Record] = jan_data + feb_data
# 开始进行数据计算
data_dict = { }
for record in all_data:
if record.date in data_dict.keys():
# 当前日期已经有记录了,所以和老记录做累加即可
data_dict[record.date] += record.money
else:
data_dict[record.date]= record.money
# 可视化图表开放
bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))
bar.add_xaxis(list(data_dict.keys())) # 添加x轴的数据
bar.add_yaxis("销售额", list(data_dict.values()), label_opts=LabelOpts(is_show=False)) # 添加y轴的数据
bar.set_global_opts(
title_opts=TitleOpts(title="每日销售额")
)
bar.render("每日销售额柱状图.html")