面向对象

在程序中设计表格，称之为设计类（class）
class Student:
name=None # 记录学生姓名
在程序中打印生产表格，称之为创建对象

基于创建对象

stu_1=student()
stu_2=student()
在程序中填写表格，称之为对象属性赋值
stu_1.name='周杰伦' # 为学生1对象赋予名称属性
stu_2.nqme='林军杰' # 为学生2对象赋予名称属性
成员变量
类的使用语法：
class 类名称： # class 是关键字，表示要定义类了
类的属性 # 类的属性，即定义在类中的变量（成员变量）
类的行为 # 类的行为，即定义在类中的函数（成员方法）
创建类对象的语法：
对象=类名称（）
成员方法的定义语法：
def 方法名（self，形参1，。。。。，形参N）：
方法体
案例：
class Student：
name=None
age=None
def say_hi(self)
print(f"Hi大家好，我是{self.name}")
self关键字，尽管在参数列表中，但是传参的时候可以忽略它
注意：
在方法定义的参数列表中，有一个self关键字，其是成员方法定义的时候必须填写的
1，它表示类对象自身的意思；2，当我们使用类对象调用方法时，self会自动被python传入；3，在方法内部，想要访问类的成员变量，必须使用self
类与对象
类只是一种程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作，这种套路称之为“面向对象编程”
先设计一个类，然后找到一个类对象，让对象去进行工作
构造方法：
python类可以使用：_ init ()方法，称之为构造方法
可以实现：1，在创建类对象（构造类）的时候，会自动执行；2，在创建对象（构造类）的时候，将传入参数自动传递给 init _方法使用
案例：
class Student：
name = None
age = None
tel = None
del init(self,name,age,tel)
self.name=name
self.age=age
self.tel=tel
print("Student类创建了一个对象")
stu=Student("周杰伦”，31，“1850000666")
其他内置方法：
_ str _字符串方法:
案例：
class Student：
def init(self):
self.name=name
self.age=age
student=Student('周杰伦',18)
print(student) # 结果：<main.student object at 0x0000002200CFD7040>
print(str(student)) # 结果：<main.student object at 0x0000002200CFD7040>
当类对象需要被转换为字符串时，会输出如上结果（内存地址）
但是内存地址没有多大作用，我们可以通过__str__方法，控制类转换为字符串的行为
class Student：
def init(self):
self.name=name
self.age=age
def str(self):
return f"studentl类对象，name={self.name},age={self.age}"
student=Student('周杰伦',18)
print(student) # 结果：Student类对象，name="周杰伦",age=18
print(str(student)) # 结果：Student类对象，name="周杰伦",age=18
_ lt _小于符号比较方法：
class Student：
def init(self):
self.name=name
self.age=age
stu1=Student("周杰伦",31)
stu2=Student(”林军杰",13)
print(stu1<stu2)
以上程序由于无法比较，因此会报错
使用案例：
class Student：
def init(self):
self.name=name
self.age=age
def lt(self,other):
return self.age< other.age
stu1=Student("周杰伦",31)
stu2=Student(”林军杰",13)
print(stu1<stu2) # False
_ le _可用于<=、>=两种比较运算符；传入参数other，另一个类对象；返回值：True或False；内容:自定义
class Student：
def init(self):
self.name=name
self.age=age
def le(self,other):
return self.age<= other.age
stu1=Student("周杰伦",31)
stu2=Student(”林军杰",13)
print(stu1<=stu2) # False
_ eq 可用于判断两个数是否相等（）；传入参数：other，另一个类对象；返回值：True或False；内容：自行定义
class Student：
def init(self):
self.name=name
self.age=age
def eq(self,other):
return self.age other.age
stu1=Student("周杰伦",31)
stu2=Student(”林军杰",13)
print(stu1==stu2) # False
封装
封装：将现实世界事物在类中描述为属性和方法。
私有成员：现实事物有部分属性和行为是不公开对使用者开发的。同样在类中描述属性和方法的时候也需要达到这个要求，就需要定义私有成员了。
类中提供了私有成员的形式来支持：1，私有成员变量；2，私有成员方法
定义私有成员的方式：1，私有成员变量：变量名以 开头（两个下划线）2，私有成员方法：方法名 _开头（两个下划线）
class phone：
IMEI = None
produce = None
__current_voltage = None # 私有成员变量
def call_by_5g(self):
print("5g通话已开启)
def __keep_sing(self):
print("让CPU以单核模式运行以节省电量) # 私有成员方法
私有成员变量和私有成员方法无法被类对象进行使用，但可以被其他的成员使用
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_sore()
print("电量不足，无法使用5g通话，并已设置为单核运行进行省电。")
继承
继承：就是一个类，继承另外一个类的成员和方法
单继承语法:
class 类名（父类名[被继承的类]）:
类内容体
多继承语法：
class 类名（父类1，父类2，父类3.....）：
类内容体
多继承情况下，按照继承的顺序，谁优先谁的优先级最高
pass 关键字：占位语句，保证语法的完整性，表示无内容，空的意思
复写和使用父类成员：
复写：子类继承父类的成员属性和成员方法后，如果对其"不满足"，那么可以进行复写，即：在子类中重新定义同名的属性或方法即可
案例：
class phone:
IMEI=None
producer="ITCAST"
def call_by_5g(self):
print("父类的5g通话")
class Myphone(phone):
producer="ITHEIMA" # 复写父类属性
def call_by_5g(self):
pinrt("子类5g通话") 复写父类方法
调用父类同名成员：一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员，如果需要使用被复写的父类成员，需要特殊的调用方式(在子类当中调用)：
方式1：调用父类成员；使用成员变量：父类名.成员变量；使用成员方法：父类名.成员方法(self)
方式2：使用super()调用父类成员；使用成员变量：super().成员变量；使用成员方法：super().成员方法()
类型注解
类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显示的说明）
功能：1，帮助第三方IDE工具（如pycharm）对代码进行类型推断，协助做代码提示；2，帮助开发者自身对变量进行类型注释
支持：变量的类型注释；函数（方法）形参列表和返回的类型注解
为变量设置类型注解；基础语法：变量：类型
案例：
var_1: int = 10;var_2 : flaot = 3.14;var_3:bool = True
class Student:
pass
stu:Student=Student()
在注释中进行类型注解：语法：# type：类型
class Student：
pass
var_1=random,randint(1,10) # type:int
var_2=json,loads(data) # type:dict[str:int]
var_3=func() # type:Student
一般，无法直接看出变量类型之时，会添加变量的类型注解；注意：类型注解只是提示性不是决定性的。数据类型和注解类型无法对应也不会导致错误
函数（方法）的类型注解：
def 函数方法名（形参名：类型，形参名：类型,........）:
pass
函数（方法）的返回值添加类型注解：
def 函数方法名（形参：类型，........，形参：类型）->返回值类型：
pass
Union类型：
使用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}
多态
多态：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态
以父类做声明，以子类做实际工作，以获得同一行为，不同状态
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对象"""
animal.speak()
dog=Dog()
Cat=Cat()
make_noise(dog) # 输出：汪汪汪
make_noise(cat) # 输出：喵喵喵
抽象类：含有抽象方法的类；抽象方法：方法是空实现的（pass）
抽象类的作用：用于做顶层设计（设计标准），以便子类做具体实现，也是对之类的一种软性约束，要求子类必须复写（实现）父类的一些方法，并且配合多态去使用