面向对象程序设计

class是关键字，表示要定义类了

类的属性，即定义在类中的变量（成员变量）

类的行为，即定义在类中的函数（成员方法）

self关键字是成员方法定义的时候，必须填写的。

1. 它用来表示类对象自身的意思
2. 当我们使用类对象调用方法时，self会自动被py传入
3. 在方法内部，想要访问类的成员变量，必须使用self

class Student:
    name=None
    age=None
    
    def fun(self):
        print(self.name)#访问类中的成员变量，需要用self访问

__init__() 构造方法

可以实现：

在创建类对象是会自动执行，将参数自动传递给__init__()方法使用

class Student:
    def __init__(self,name,age,id):
        self.name=name
        self.age=age
        self.id=id
        print('创建对象自动调用此方法')

student1=Student('zhangsan',19,'0001')

类内置方法（魔术方法）:

__str__:

控制类转换成字符串的行为

class Student:
    def __init__(self,name,age,id):
        self.name=name
        self.age=age
        self.id=id
        print('创建对象自动调用此方法')

    def __str__(self):
        return f'name:{self.name},age:{self.age}'

student1=Student('zhangsan',19,'0001')

print(str(student1))
#name:zhangsan,age:19

#若不写__str__方法，则输出的是地址值

__lt__:

直接比较两个对象是不可以的，但是在类中实现__lt__()方法的符号比较，即可同时完成<  > 两种比较

class Student:
    def __init__(self,name,age,id):
        self.name=name
        self.age=age
        self.id=id
        print('创建对象自动调用此方法')

    def __lt__(self,other):
        return self.age<other.age

student1=Student('zhangsan',19,'0001')
student2=Student('zhangsan',20,'0001')

print(student1>student2)
#False

__le__:

判断小于等于

格式与lt方法类似

__eq__:

若没有写eq方法，比较两个对象相等时，返回False，因为自动比较的是内存地址值。

class Student:
    def __init__(self,name,age,id):
        self.name=name
        self.age=age
        self.id=id
        print('创建对象自动调用此方法')

    def __eq__(self,other):
        return self.name==other.name

student1=Student('zhangsan',19,'0001')
student2=Student('zhangsn',19,'0001')

print(student1==student2)
#False

封装

私有成员命名，在名称前以__开头。

类对象无法访问私有成员

类中的其他成员可以访问私有成员

class Phone:
    __current_voltage=0

    def __keep_single_core(self):
        print('让CPU以单核模式运行')

    def call_by_5g(self):
        if self.__current_voltage>=1:
            print('5g开启')
        else:
            self.__keep_single_core()
ph1=Phone()
ph1.call_by_5g()

#让CPU以单核模式运行

继承：

继承有单继承和多继承。

多继承注意事项：

多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级。

即先继承的保留，后继承的覆盖

pass关键字的作用：

占位语句，保证类定义的完整性。

复写父类成员：在子类中重新定义同名的属性或方法即可。

调用父类同名成员：

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员

若需要使用被复写的父类的成员，需要特殊的方式。

方式一：
使用成员变量：父类名.成员变量

使用成员方法：父类名.成员方法（self）

方式二：

使用super（）调用父类成员

使用成员变量：super().成员变量

使用成员方法：super().成员方法

注意：只可以在子类内部调用父类的同名成员，子类的实体类对象调用默认是调用子类复写的

class Human:
    name='zhangsan'
    nation='China'
    def fun(self):
        print(f"{self.name}在{self.nation}诞生")

class student(Human):
    def fun(self):
        super().fun()
        print(f"{self.name}在{self.nation}诞生")

stu1=student()
stu1.fun()

#zhangsan在China诞生
#zhangsan在China诞生

类型注解

主要功能：帮助第三方工具对代码进行类型推断，协助代码作提示。

变量类型注解的两种形式：

1. 变量：类型=值

2.  在注释中，#type：类型

函数的类型注解-形参注解：

def  函数方法名（形参名：类型，形参名：类型.........）->类型：

        pass

前面对传入的形参进行注解，后面为返回值进行注解

Union联合类型：

使用Union可以定义联合类型注解

先导包： from typing import Union

使用：UNion[类型，.......，类型]

from typing import Union

my_list:list[Union[str,int]]=[1,2,'skcm','uisj']

def func(data:Union[int,str])->Union[int,str]:
    pass

它并不会真正的对类型做验证和判断，类型注解仅仅是提示性的，不是决定性的。

多态：

同一个行为，使用不同的对象获得不同的状态。

class voice:    #抽象类
    def ani_voice(self):
        pass
    #抽象方法

class Dog(voice):
    def ani_voice(self):
        print('汪汪汪')

class Cat(voice):
    def ani_voice(self):
        print('喵喵喵')

def fun(voi:voice):
    voi.ani_voice()
    
dog=Dog()
cat=Cat()
fun(dog)
fun(cat)

抽象类（接口）：

包含抽象方法的类，叫做抽象类，抽象方法是指没有具体实现的方法（pass）称之为抽象方法。

class voice:    #抽象类
    def ani_voice(self):
        pass
    #抽象方法

class dog(voice):
    def ani_voice(self):
        print('汪汪汪')

class cat(voice):
    def ani_voice(self):
        print('喵喵喵')