Python面向对象程序设计
- 1,初识类和对象
- 2,类的定义和使用
- 3,构造方法
- 4,常用的类内置方法
-
- [4.1,字符串方法:`str `](#4.1,字符串方法:
__str__
) - 4.2,是否小于:`lt`
- 4.3,是否小于等于:`le`
- 4.4,是否相等:`eq`
- [4.1,字符串方法:`str `](#4.1,字符串方法:
- 5,面向对象的特性:封装
- 6,面向对象的特性:继承
- 7,Python类型注解
- 8,面向对象的特性:多态
1,初识类和对象
设想这样一种场景:学校里每个学生都有各自的姓名、性别、班级、籍贯、年龄等个人信息。如果把每个人的信息写在一张纸上,组织起来就会非常混乱,因此在生活中常使用表格来记录学生的信息。
程序中,为了追求一种更简洁高效的数据表示形式,我们可以通过设计类、创建对象、给对象的属性赋值
的方法来组织数据。使用程序中的类可以完美的描述现实世界的事物。
- 设计一个类:类比整个学生群体
- 创建一个对象:类比某一位学生
- 对象属性赋值:类比填入某一位学生的信息
设计类,基于类创建对象,由对象做具体的工作,此即为面向对象编程
2,类的定义和使用
定义类和创建类对象的语法如下:
bash
# 定义类的语法
class 类名称:
类的属性
# 类中定义成员方法
def 方法名(self,形参1,......,形参N)
方法体
# 创建类对象的语法
对象 = 类名称()
- class是关键字,表示要定义类
- 类的
属性
,即定义在类中的变量(成员变量
) - 类的
行为
,即定义在类中的方法(成员方法
) - 类中可以定义属性来记录数据,定义函数来记录行为
self表示类对象自身
,当我们使用类对象调用方法时,self会自动被python传入self是成员方法定义的时候,必须填写的
在方法内部想要访问类的属性,必须使用self
- self关键字在方法的参数列表中,但传参的时候可以忽略它
案例演示:
python
# 设计一个类
class Student:
# 各属性的初始值设置空值
name = None # 记录学生姓名
gender = None # 记录学生性别
nationality = None # 记录学生国籍
native_place = None # 记录学生籍贯
age = None # 记录学生年龄
# 类的行为
def say_hello1(self):
# 成员方法的参数中self是必须的
# 在方法内部想要访问类的属性,必须使用self
print(f"Hi,大家好,我是{self.name}")
def say_hello2(self, msg):
print(f"Hi,{msg}")
# 创建一个对象
stu1 = Student()
# 对象属性赋值
stu1.name = "小明"
stu1.gender = "男"
stu1.nationality = "中国"
stu1.native_place = "山东省"
stu1.age = 18
# 获取对象中记录的信息
print(f"学生姓名是:{stu1.name},学生性别是:{stu1.gender},学生年龄是:{stu1.age}")
# 调用类内部的方法
stu1.say_hello1()
stu1.say_hello2("很高兴认识大家")
运行结果如下:
3,构造方法
前面我们学习了对象属性的赋值(如下图),显然之前的赋值方式略显繁琐,需要写很多行。
实际有一种更高效的传参方式:
- 在创建对象的时候,像函数一样通过传参的形式对属性赋值,此即为构造方法。
Python类可以使用:
__init__()方法
,称之为构造方法,它可以实现:
- 在创建类对象的时候,会自动执行
- 在创建类对象的时候,将传入参数自动传递给
__init__()
方法使用 - 构造方法也是成员方法,不要忘记在参数列表中提供:
self
案例演示
python
"""
演示类的构造方法
"""
class Student:
# 此处成员变量的定义可省略,因为_init_方法会自动执行赋值,赋值的同时成员变量也被定义了
name = None
age = None
tel = None
def __init__(self, name, age, tel):
self.name = name # 表示内部的name属性等于外部传入的name
self.age = age
self.tel = tel
print("Student类创建了一个类对象")
# 使用构造方法创建类对象
stu = Student("小白",21,"13256666666")
print(stu.name)
print(stu.age)
运行结果如下:
4,常用的类内置方法
前面的__init__
构造方法,是Python类内置的方法之一。这些内置的方法,各自有各自特殊的功能,这些内置方法我们称之为:魔术方法。
方法 | 功能 |
---|---|
__init__ |
构造方法,可用于创建类对象的时候设置初始化行为 |
__str__ |
用于实现类对象转字符串的行为 |
__lt__ |
用于两个类对象进行小于或大于比较 |
__le__ |
用于两个类对象进行小于等于或大于等于比较 |
__eq__ |
用于两个类对象进行相等比较 |
4.1,字符串方法:__str__
__str__
是一个特殊方法(也称为魔术方法或双下方法),它定义了当对象需要被转换成字符串表示时应该如何做。
未定义__str__方法时,直接将对象打印输出或者将对象转为字符串输出,会输出对象的地址,代码示例如下:
python
class Student:
def __init__(self, name, age, tel):
self.name = name # 表示内部的name属性等于外部传入的name
self.age = age
self.tel = tel
print("Student类创建了一个类对象")
stu = Student("小白",21,"13256666666")
# 直接将对象打印
print(stu)
# 将对象转为字符串打印输出
print(str(stu))
运行结果:
有时我们为了打印的时候显示对象中存储的数据内容,就可以通过定义
___str__
方法,控制类转换为字符串的行为。代码示例如下:
python
class Student:
def __init__(self, name, age, tel):
self.name = name # 表示内部的name属性等于外部传入的name
self.age = age
self.tel = tel
# __str__魔术方法
def __str__(self):
return f"Student类对象,name:{self.name},age:{self.age},tel:{self.tel}"
stu = Student("小白",21,"13256666666")
# 打印输出
print(stu)
print(str(stu))
定义了魔术方法__str__后打印对象时就不再输出对象的内存地址 :
4.2,是否小于:__lt__
直接对两个对象进行比较大小是不可以的,但是在类中定义__lt__
方法,即可同时完成:小于符号和大于符号两种比较。
案例演示:
python
class Student:
def __init__(self, name, age, tel):
self.name = name # 表示内部的name属性等于外部传入的name
self.age = age
self.tel = tel
# __str__魔术方法
def __str__(self):
return f"Student类对象,name:{self.name},age:{self.age},tel:{self.tel}"
# __lt__魔术方法,other表示另外一个需要比较的类的对象
def __lt__(self, other):
return f"是否小于:{self.age < other.age}" # 返回一个布尔值
stu1 = Student("小白",21,"13256666666")
stu2 = Student("小青",20,"13256666666")
stu3 = Student("小黄",20,"13256666666")
# 是否小于
print(stu1 < stu2)
print(stu1 > stu2)
运行结果:
注意:如果不定义__str__
,直接两个对象比较会报错。
4.3,是否小于等于:__le__
在类中定义__le__
方法即可同时完成:小于等于符号和大于等于符号两种比较。
案例演示:
python
class Student:
def __init__(self, name, age, tel):
self.name = name # 表示内部的name属性等于外部传入的name
self.age = age
self.tel = tel
# __str__魔术方法
def __str__(self):
return f"Student类对象,name:{self.name},age:{self.age},tel:{self.tel}"
# __lt__魔术方法,other表示另外一个需要比较的类的对象
def __lt__(self, other):
return f"是否小于:{self.age < other.age}" # 返回一个布尔值
# __le__魔术方法:是否小于等于
def __le__(self, other):
return f"是否小于等于:{self.age <= other.age}"
# __eq__魔术方法:比较是否等于
def __eq__(self, other):
return f"是否等于:{self.age == other.age}"
stu1 = Student("小白",21,"13256666666")
stu2 = Student("小青",20,"13256666666")
stu3 = Student("小黄",20,"13256666666")
# 是否小于
print(stu1 < stu2) # False
print(stu1 > stu2) # True
# 是否小于等于
print(stu2 <= stu3)
print(stu2 >= stu3)
运行结果如下:
4.4,是否相等:__eq__
如果再类定义的时候没有定义__eq__
方法,使用"=="比较的话比较的是内存地址。
python
class Student:
def __init__(self, name, age, tel):
self.name = name # 表示内部的name属性等于外部传入的name
self.age = age
self.tel = tel
# __str__魔术方法
def __str__(self):
return f"Student类对象,name:{self.name},age:{self.age},tel:{self.tel}"
# __lt__魔术方法,other表示另外一个需要比较的类的对象
def __lt__(self, other):
return f"是否小于:{self.age < other.age}" # 返回一个布尔值
# __le__魔术方法:是否小于等于
def __le__(self, other):
return f"是否小于等于:{self.age <= other.age}"
stu1 = Student("小黄",20,"13256666666")
stu2 = Student("小黄",20,"13256666666")
# 是否相等
print(stu1 == stu2)
运行结果如下:
如果类定义的时候定义了__eq__
方法,就可以按照__eq__
方法定义的比较规则实现比较对象存储的内容。
python
class Student:
def __init__(self, name, age, tel):
self.name = name # 表示内部的name属性等于外部传入的name
self.age = age
self.tel = tel
# __str__魔术方法
def __str__(self):
return f"Student类对象,name:{self.name},age:{self.age},tel:{self.tel}"
# __lt__魔术方法,other表示另外一个需要比较的类的对象
def __lt__(self, other):
return f"是否小于:{self.age < other.age}" # 返回一个布尔值
# __le__魔术方法:是否小于等于
def __le__(self, other):
return f"是否小于等于:{self.age <= other.age}"
# __eq__魔术方法:比较是否等于
def __eq__(self, other):
return f"年龄是否等于:{self.age == other.age}"
stu1 = Student("小黄",20,"13256666666")
stu2 = Student("小黄",20,"13256666666")
# 是否相等
print(stu1 == stu2)
运行结果如下:
5,面向对象的特性:封装
在日常生活中,当消费者使用手机、电视、洗衣机的时候,只需知道如何使用,而不必知晓其内部工作原理。此即为封装思想的体现:
在类中提供仅供内部使用的属性和方法,而不对外开放。
类中通过私有成员
的形式来实现属性和行为的封装:
- 私有成员变量:变量以
__
开头(两个下划线) - 私有成员方法:方法名以
__
开头(两个下划线) 类对象无法访问私有成员
私有成员可以被类内部的其他成员使用
代码示例一:
python
class Phone:
__current_voltage = None # 当前手机运行电压
def __keep_single_core(self): # 表示使cpu单核运行
print("让CPU以单核模式运行")
phone = Phone()
phone.__keep_single_core() # 报错
print(phone.__current_voltage) # 报错
运行结果如下:(类对象无法访问私有成员
)
代码示例二:私有成员可以被类内部的其他成员使用
python
class Phone:
__current_voltage = 1 # 当前手机运行电压
def __keep_single_core(self): # 表示使cpu单核运行
print("让CPU以单核模式运行")
def call_by_5g(self): # 电压大于1可以进行5g通话
if self.__current_voltage >= 1:
print("5g通话已开启")
else:
# 调用私有成员方法
self.__keep_single_core()
print("电压不足,无法使用5g童话,CPU已转为单核")
phone = Phone()
phone.call_by_5g()
运行结果如下:
6,面向对象的特性:继承
为了促进了代码的复用和模块化,我们引入继承,通过继承一个基类,子类可以继承基类的所有特性,同时还可以添加新的特性或者覆盖基类中的方法。
6.1,继承的基础语法
继承语法:
bash
class 类名(父类名):
类内容体
Python中继承可以分为单继承和多继承
多继承的多个父类中,如果有同名的成员,默认继承顺序以从左到右为优先级
- 可以使用pass关键字做填充,补全语法
代码示例一 :单继承
演示一个手机类和新手机类之间的继承关系:
python
# 手机类
class Phone:
seriesID = None
producer = "phone"
def call_by_4g(self):
print("4g通话")
# 新手机类单继承父类(手机类)
class phone2024(Phone):
# 面部识别ID(新属性)
face_id = "10001"
# 5g通话(新方法)
def call_by_5g(self):
print("5g童话")
phone = phone2024()
# 打印父类中定义过子类中没有定义的属性
print(f"phone.producer:{phone.producer}")
# 调用父类中定义过子类中没有定义的方法
phone.call_by_4g()
# 调用子类中新定义的方法
phone.call_by_5g()
运行结果如下 :
代码示例二:多继承
某些手机比如小米手机可以实现手机、NFC读卡器和红外遥控器...等功能。
因此我们可以定义一个小米手机类去继承手机类、NFC读卡器类和红外遥控器类。
python
# 手机类
class Phone:
seriesID = None
producer = "phone"
def call_by_4g(self):
print("4g通话")
# NFC读卡器类
class NFCReader:
nfc_type = "第五代"
producer = "NFCReader"
def read_card(self):
print("NFC读卡")
def write_card(self):
print("NFC写卡")
# 红外遥控类
class RemoteControl:
rc_type = "红外遥控"
def control(self):
print("红外遥控开启了")
# 多继承
class XiaomiPhone(Phone, RemoteControl,NFCReader):
# pass关键字用于不全语法。(不想添加语句,又要避免语法错误)
pass
phone = XiaomiPhone()
# 4g通话
phone.call_by_4g()
# NFC写卡
phone.write_card()
# 红外遥控
phone.control()
# 父类Phone和父类NFCReader里都有producter,但此处打印输出的是Phone中的producter
# 因为多继承的多个父类中,如果有同名的成员,默认继承顺序以从左到右为优先级
print(phone.producer)
运行结果如下:
6.2,复写父类成员
子类继承父类的成员属性和成员方法后,如果对其"不满意",那么可以进行复写 。(即:在子类中重新定义
同名的属性或方法即可。)
代码示例如下:
python
# 手机类
class Phone:
seriesID = None
producer = "phone"
def call_by_5g(self):
print("5g通话")
# 定义子类,复写父类成员
class MyPhone(Phone):
# 复写父类的成员属性
producer = "iphone"
# 复写父类的成员方法
def call_by_5g(self):
print("*****开始******")
print("使用5g网络进行通话")
print("*****结束*****")
phone = MyPhone()
phone.call_by_5g()
print(phone.producer)
运行结果如下:
6.3,调用父类成员
一旦复写父类成员,类对象调用成员的时候就会调用复写后的新成员,如果需要使用被复写的父类的成员,需要特殊的调用方式。
语法1:
bash
# 使用成员变量
父类名.成员变量
# 使用成员方法
父类名.成员方法(self)
语法2:
bash
# 使用成员变量
super().成员变量
# 使用成员方法
super().成员方法
代码示例一:(语法1)
python
# 手机类
class Phone:
seriesID = None
producer = "phone"
def call_by_5g(self):
print("父类方法:5g通话")
# 定义子类,复写父类成员
class MyPhone(Phone):
# 复写父类的成员属性
producer = "iphone"
# 复写父类的成员方法
def call_by_5g(self):
print("*****开始******")
print(f"父类的厂商是:{Phone.producer}") # 调用父类成员属性
Phone.call_by_5g(self) # 调用父类成员方法
print("*****结束*****")
phone = MyPhone()
# 调用父类成员
print(f"打印父类producer:{Phone.producer}")
phone.call_by_5g()
运行结果如下:
代码示例二:(语法2)
python
# 手机类
class Phone:
seriesID = None
producer = "phone"
def call_by_5g(self):
print("父类方法:5g通话")
# 定义子类,复写父类成员
class MyPhone(Phone):
# 复写父类的成员属性
producer = "iphone"
# 复写父类的成员方法
def call_by_5g(self):
print("*****开始******")
print(f"父类的厂商是:{super().producer}") # 调用父类成员属性
super().call_by_5g() # 调用父类成员方法(无需传入self)
print("*****结束*****")
phone = MyPhone()
# 调用父类成员
phone.call_by_5g()
运行结果如下:
7,Python类型注解
一般,无法直接看出变量类型的时候会添加变量的类型注解。
类型注解是在代码中涉及数据交互的地方提供数据类型的显式说明。
在Pycharm中编写代码,经常会对可用的方法给出提示,这就是类型注解。如下图所示:
类型注解的主要功能在于:
- 帮助第三方IDE工具(如Pycharm)对代码进行类型推断,协助做代码提示
- 帮助开发者对变量进行类型注释,可以理解为一种备注
- 类型注解支持:变量的类型注解、方法的类型注解和返回值的类型注解
- 需要注意的是,
类型注解仅仅是提示性的,而不是决定性的
,类型注解和实际代码不同不会报错
7.1,变量的类型注解
类型注解语法一:变量:类型
类型注解语法二:通过注释进行类型注解:# type:类型
案例演示:(类型注解语法一 )
python
# 基础数据类型注解(实际开发中一般无需注解,因为可以看出数据的类型)
var_1:int = 10
var_2:float = 3.1415
var_3:bool = True
var_4:str = "HELLO"
# 类对象类型注解
class Student:
# pass关键字用于补全语法
pass
# stu对象是Student类型
stu: Student = Student()
# 容器类型注解
my_list:list = [1,2,3]
my_tuple: tuple = (1,2,3)
my_set: set = {1,2,3}
my_dict:dict = {"1":"hello"}
my_str:str = "HELLO"
# 容器类型详细注解(Python3.9以上支持)
my_list2: list[int] = [1,2,3]
my_tuple2: tuple[int, str, bool] = (1,"Hi",True)
my_dict2: dict[str,int] = {"IT":666}
案例演示:(类型注解语法二)
python
import json
import random
# 在注释中进行变量类型注解
var_1 = random.randint(1,10) # type:int
# json.loads()可用于将JSON 格式的字符串转换为字典
var_2 = json.loads('{"name":"Alice"}') # type:dict[str,str]
print(var_2)
def func():
return 10
# 标明var_3是int类型
var_3 = func() # type:int
7.2,方法的类型注解
为方法做类型注解,可以分为:为方法形参进行类型注解
和为方法返回值进行类型注解
。
方法形参类型注解语法:
bash
def 函数方法名(形参名:类型,形参名:类型......):
pass
代码示例如下:
返回值的类型注解语法:
bash
def 函数方法名(形参:类型,......,形参:类型) ->返回值类型:
pass
代码示例如下:
python
"""
演示对返回值进行类型注解
"""
def func(data:list) -> list: # 此处标注方法返回值为list类型
return data
print(func([1,2,3,4,5])) # 运行结果:[1, 2, 3, 4, 5]
7.3,Union联合类型注解
在某些情形下,使用普通类型注解可以很好的描述数据。示例如下:
python
# 如下数据,类型注解可以很好的描述
my_list:list[int] = [1,2,3]
my_dict:dict[str, int] = {"age":11,"num":3}
但某些数据,使用普通类型注解无法很好的描述,示例如下 :(各种数据类型混合在一起 )
python
myList = [1,2,"Hello","World"]
myDict2 = {"name":"小黄","age":11}
对于各种数据类型混装到一起的数据,就可以使用Union联合类型注解
。使用Union数据类型必须先导包。
导包:
from typing import Union
Union联合类型注解语法:Union[类型,...,类型]
代码示例如下:
python
# 导包
from typing import Union
# 变量的Union联合类型注解
# myList内部str和int型的数据都可以
myList:list[Union[str, int]] = [1,2,"Hello","World"]
# myDict内部的key值是str类型,value值是str或int类型都可以
myDict:dict[str, Union[str, int]] = {"name":"小黄","age":11}
# 方法中使用Union联合类型注解
# 传入的参数data可以是字符串也可以是数字;返回值可以是int也可以是str
def func(data:Union[int,str]) -> Union[int,str]:
# 函数体为空,使用pass关键字补全语法
pass
我们在调用func函数
的时候,在Pycharm中使用快捷键ctrl+P
就可以看到参数类型的要求,如下图所示:
8,面向对象的特性:多态
多态是指多种状态 。即完成某个行为(函数)时,
使用不同的对象会得到不同的状态
。
多态常作用于继承关系上。比如:
- 定义方法时通过类型注解声明接受父类对象,实际传入子类对象进行工作
- 即以父类做定义声明,以子类做实际工作,用以获得同一行为的不同状态
案例演示:
python
"""
演示面向对象的多态性
"""
class Animal:
# 定义一个方法
def speak(self):
pass
class Dog(Animal):
# 复写父类方法
def speak(self):
print("汪汪汪")
class Cat(Animal):
def speak(self):
print("喵喵喵")
# 制造点噪音,需要传入Animal对象
def make_noise(animal:Animal):
animal.speak()
# 演示多态,使用2个不同的子类对象来调用函数,获得不同的状态
dog = Dog()
cat = Cat()
make_noise(dog)
make_noise(cat)
运行结果如下:
简而言之,对象的多态性即:父类的引用指向子类的对象。
抽象类和抽象方法
抽象方法: 方法体是空实现的(pass)称之为抽象方法。
如上面代码中的Animal中的speak方法
抽象类: 含有抽象方法的类即为抽象类。如上面代码中的Animal类
- 抽象类用于做顶层设计,就好比定义一个标准,其中包含了一些抽象方法(未实现的方法)
抽象类的子类必须复写或实现父类所有的抽象方法,否则它们自己也会被视为抽象类
案例演示:
python
# 定义一个空调的抽象类(相当于制定标准)
class AC:
def cool_wind(self):
"""制冷"""
pass
def hot_wind(self):
"""制热"""
pass
def swing_wind(self):
"""摆风"""
pass
# 定义一个美的空调子类,作为空调抽象类AC的子类
class Media_AC(AC):
# 子类需要复写抽象父类中的方法
def cool_wind(self):
print("美的空调制冷")
def hot_wind(self):
print("美的空调制热")
def swing_wind(self):
print("美的空调摆风")
# 定义一个格力空调子类,作为空调抽象类AC的子类
class Gree_AC(AC):
# 子类需要复写抽象父类中的方法
def cool_wind(self):
print("格力空调制冷")
def hot_wind(self):
print("格力空调制热")
def swing_wind(self):
print("格力空调摆风")
# 制造冷风
def make_cool(ac:AC): # 需要传入的参数为AC空调对象
ac.cool_wind()
# 创建类对象
media_ac = Media_AC()
gree_ac = Gree_AC()
# 传入子类对象,调用make_cool函数,演示多态
make_cool(media_ac)
make_cool(gree_ac)
运行结果如下: