2.1 面向对象
文章目录
-
- 初始对象
- 成员方法
- 构造方法
- 其他内置方法
- 封装
- 继承
-
- 继承的基础语法
-
- pass
- 复写和使用父类成员
- 类型注解
-
- 变量的类型注解
- 函数（方法）的类型注解
- Union类型
- 多态
初始对象
样例：
# 定义类
class Student:
name = None
gender = None
# 创建对象
stu_1 = Student()
stu_2 = Student()
# 赋值对象
stu_1.name = '张三'
stu_2.name = '李四'
# 输出信息
print(stu_1.name)
输出结果：
成员方法
类其实分为两部分：1.属性，也就是数据存放处。2.是行为，也就是类内部的函数。
# 定义类
class Student:
name = None
def say_hi(self):
print(f"hello 大家好，我是{self.name}")
# 创建对象
stu_1 = Student()
stu_2 = Student()
# 赋值对象
stu_1.name = '张三'
stu_2.name = '李四'
# 输出信息
print(stu_1.name)
stu_2.say_hi()
输出结果：
构造方法
Python类可以使用：__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("构造完成")
# 创建对象，并构造对象
stu_1 = Student("张三",18,"13910000000")
# 输出信息
print(f"我是{stu_1.name},我的年龄是{stu_1.age},我的电话是{stu_1.tel}")
输出结果：
其他内置方法
魔术方法（内置方法）：
- __init__：构造方法，详情见上。
- __str__：字符串方法
样例：
# 定义类
class Student:
name = None
age = None
tel = None
def __init__(self,name,age,tel):
self.name = name
self.age = age
self.tel = tel
print("构造完成")
def __str__(self):
return f"我叫{self.name},我的年龄是{self.age},我的电话是{self.tel}" # 注意的是，我们是将此处变成一个字符串
# 创建对象，并构造对象
stu_1 = Student("张三",18,"13910000000")
# 使用将类对象转化为字符串
print(stu_1)
print(str(stu_1))
输出结果：
- __lt__:小于大于符号比较
样例：
# 定义类
class Student:
name = None
age = None
tel = None
# 构造方法
def __init__(self,name,age,tel):
self.name = name
self.age = age
self.tel = tel
# 转换成字符串的方法
def __str__(self):
return f"我叫{self.name},我的年龄是{self.age},我的电话是{self.tel}"
# 比较的方法，注意的是统一使用<
def __lt__(self, other):
return self.age < other.age
# 创建对象，并构造对象
stu_1 = Student("张三",18,"13910000000")
stu_2 = Student("李四",24,"13800000000")
# 比较大小
print(stu_1<stu_2)
print(stu_1>stu_2)
输出样例：
4. __le__:小于等于、大于等于符号比较
样例：
class Student:
name = None
age = None
tel = None
# 构造方法
def __init__(self,name,age,tel):
self.name = name
self.age = age
self.tel = tel
# 转换成字符串的方法
def __str__(self):
return f"我叫{self.name},我的年龄是{self.age},我的电话是{self.tel}"
# 比较的方法，注意的是统一使用<
def __lt__(self, other):
return self.age < other.age
# 小于等于大于等于
def __le__(self, other):
return self.age<=other.age
# 创建对象，并构造对象
stu_1 = Student("张三",18,"13910000000")
stu_2 = Student("李四",24,"13800000000")
# 比较大小
print(stu_1<stu_2)
print(stu_1>stu_2)
print(stu_1<=stu_2)
print(stu_1>=stu_2)
输出结果：
5. __eq__:==符号比较
# 定义类
class Student:
name = None
age = None
tel = None
# 构造方法
def __init__(self,name,age,tel):
self.name = name
self.age = age
self.tel = tel
print("构造完成")
# 转换成字符串的方法
def __str__(self):
return f"我叫{self.name},我的年龄是{self.age},我的电话是{self.tel}"
# 比较的方法，注意的是统一使用<
def __lt__(self, other):
return self.age < other.age
# 小于等于大于等于
def __le__(self, other):
return self.age<=other.age
def __eq__(self, other):
return self.age==other.age
# 创建对象，并构造对象
stu_1 = Student("张三",18,"13910000000")
stu_2 = Student("李四",24,"13800000000")
# 使用将类对象转化为字符串
print(stu_1)
print(str(stu_1))
# 比较大小
print(stu_1<stu_2)
print(stu_1>stu_2)
print(stu_1<=stu_2)
print(stu_1>=stu_2)
print(stu_1==stu_2)
输出结果：
封装
封装描述的是：
将现实世界的 属性，行为封装到类中，描述为成员对象，成员方法从而完成对现实世界的描述。
但是现实世界中也存在着私有成员，就是有一些东西仅仅只能是开发者了解，但是使用者并不能进行使用。这就涉及到了私有成员，以及私有方法。
具体的命名方式：
在私有成员对象的变量名前加上__
在私有成员方法名前加上__
相对应的对象或方法就会变成私有的。
私有成员的访问限制：
类对象无法访问私有成员对象。
类中的其他成员可以访问类对象。
class Phone:
__is_5g_enable = None # 私有成员对象
def __init__(self,tag): # 构造函数
self.__is_5g_enable = tag
print("构造完成")
def __check_5g(self): # 私有方法
if self.__is_5g_enable==True :
print("打开了5g")
else:
print("没有打开5g")
def call_by_5g(self): # 公有方法
self.__check_5g()
print("正在通话中")
tel1 = Phone(True)
tel1.call_by_5g()
输出结果：
继承
继承的基础语法
单继承：
class 类名(父类名):
类的新内容体
多继承：
class 类名(父类名1,父类名2……):
类的新内容体
样例：
class Phone:
is_4g_enable = True
def check_4g(self):
if self.is_4g_enable == True:
print("4g打开")
# 单继承
class Phone2022(Phone):
is_5g_enable = True
def check_5g(self):
if self.is_5g_enable == True:
print("2022年新功能：5g打开了")
Phone = Phone2022()
Phone.check_4g()
Phone.check_5g()
# 多继承 pass代表着这个类是空的，即是这个内内部的内容仅有继承的，没有其他的
class open_4g:
is_4g_enable = True
def check_4g(self):
if self.is_4g_enable == True:
print("2023年新功能：4g打开")
class open_5g:
is_5g_enable = True
def check_5g(self):
if self.is_5g_enable == True:
print("2023年新功能：5g打开了")
class Phone2023(open_4g, open_5g):
pass
Phone1 = Phone2023()
Phone1.check_4g()
Phone1.check_5g()
多继承当中，如果父类拥有两个或以上的同名属性，那么按照先继承的属性（函数，）来运行。
pass
值得关注的是pass这个关键字：占位语句，空的意思
复写和使用父类成员
复写样例：实际上就是在子类中进行重新定义
class Phone :
producer = "ISN"
def check_5g(self):
print("5g没有打开")
class Myphone(Phone) :
producer = "III"
def check_5g(self):
print("5g打开了")
phone = Myphone()
print(phone.producer)
phone.check_5g()
输出结果：
调用父类成员
方法一：
父类名.成员变量
父类名.成员方法
方法二：
super().成员变量
super().成员方法
样例：
class Phone :
producer = "ISN"
def check_5g(self):
print("5g没有打开")
class Myphone(Phone) :
producer = "III"
def check_5g(self):
# 方法一
print(Phone.producer)
# 方法二
super().check_5g()
print("5g打开了")
phone = Myphone()
print(phone.producer)
phone.check_5g()
输出结果：
类型注解
变量的类型注解
语法1：
变量：类型
语法2：
变量 # type ：类型
样例：
# 方法一：
my_list :list[int,str,float] =[1,'12',0.0]
# 方法二：
my_tuple = {1,'12',0.0} # type: tuple[int,str,float]
类型注解只是提示性的，非决定性的，数据类型和注解类型不匹配也不会导致错误。
函数（方法）的类型注解
对形参进行类型注解：
样例：
def add(x:int,y:int):
return x+y
对函数返回值进行类型注解：
样例：
def add(x,y) ->int :
return x+y
类型注解只是提示性的，非决定性的，数据类型和注解类型不匹配也不会导致错误。
Union类型
Union实际上就是定义一个联合的类型注解。
Union的使用：
导包：
from typing import Union
使用：
Union[类型·····类型]
样例：
from typing import Union
def add(x,y) ->Union[int,str] :
return x+y
此函数代表着函数返回的类型要么是int要么是str，二者都有可能。
多态
关于多态的理解：
class Animal :
def speak(self):
pass
class Cat(Animal):
def speak(self):
print("喵喵喵")
class Dog(Animal):
def speak(self):
print("汪汪汪")
def make_noise(animal:Animal):
animal.speak()
cat =Cat()
dog =Dog()
make_noise(cat)
make_noise(dog)
小总结一下，所谓多态实际上就是完成某个行为时，不同的对象会得到不同的状态。
即同样的行为（make_noise函数），传入的对象不同，得到不同的状态。
而这种思想常用于抽象类（也可以称之为接口）当中：
抽象类：含有抽象方法的类。
抽象方法：方法体时空实现（pass）称之为抽象方法。