Python笔记08-面向对象

类只是一种程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作
这种套路，称之为：面向对象编程

类和对象

定义类的语法如下：

class 类名称:  class是关键字，表示要定义类了
      类的属性  类的属性，即定义在类中的变量（成员变量）
      类的行为    类的行为，即定义在类中的函数（成员方法）

创建实例的语法：

对象名= 类名称（）   如： user = User()

类中：
不仅可以定义属性用来记录数据
也可以定义函数，用来记录行为
其中：
类中定义的属性（变量），我们称之为：成员变量
类中定义的行为（函数），我们称之为：成员方法

示例：

class Stu:
    name = None
    age = None
    def say_hi(self):
        print(f"Hi大家好，我是{self.name}")

stu = Stu()
stu.name="zhang"
stu.say_hi()

在类中定义成员方法和定义函数基本一致，但仍有细微区别：
可以看到，在方法定义的参数列表中，有一个：self关键字
self关键字是成员方法定义的时候，必须填写的。
它用来表示类对象自身的意思
当我们使用类对象调用方法的是，self会自动被python传入
在方法内部，想要访问类的成员变量，必须使用self
self关键字，尽管在参数列表中，但是传参的时候可以忽略它

构造方法

可以通过 需构造方法：init() 来直接为属性赋值，而不用挨个手工赋值。

class Stu:
    name = None
    age = None
    def say_hi(self):
        print(f"Hi大家好，我是{self.name}")
    def __init__(self,name,age):
        self.name=name
        self.age=age

stu = Stu("zhang",18)
stu.say_hi()

构造方法的名称是：init，注意init前后的2个下划线符号
构造方法的作用：
构建类对象的时候会自动运行
构建类对象的传参会传递给构造方法，借此特性可以给成员变量赋值
注意事项：
构造方法不要忘记self关键字
在方法内使用成员变量需要使用self

内置方法

上文学习的__init__ 构造方法，是Python类内置的方法之一。
这些内置的类方法，各自有各自特殊的功能，这些内置方法我们称之为：魔术方法

str

当类对象需要被转换为字符串之时，会输出如上结果（内存地址）

内存地址没有多大作用，我们可以通过__str__方法，控制类转换为字符串的行为。

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
stu = Student("zhang",18)  #<__main__.Student object at 0x000002400CA789D0>
print(stu)

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("zhang",18)  #Student类的对象，name=zhangage=18
print(stu)

lt
直接对2个对象进行比较是不可以的，但是在类中实现__lt__方法，即可同时完成：小于符号 和 大于符号 2种比较

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}"
    def __lt__(self, other):
        return self.age<other.age

stu = Student("zhang",18)  #Student类的对象，name=zhangage=18
#rint(stu)
stu2 = Student("lisa",19)  
print(stu<stu2)#True

le
魔术方法：__le__可用于：<=、>=两种比较运算符上

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}"
    def __lt__(self, other):
        return self.age<other.age
    def __le__(self, other):
        return self.age<=other.age

stu = Student("zhang",18)  #Student类的对象，name=zhangage=18
#rint(stu)
stu2 = Student("lisa",18)
print(stu<=stu2)#true

eq
不实现__eq__方法，对象之间可以比较，但是是比较内存地址，也即是：不同对象==比较一定是False结果。
实现了__eq__方法，就可以按照自己的想法来决定2个对象是否相等了。

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}"
    def __lt__(self, other):
        return self.age<other.age
    def __le__(self, other):
        return self.age<=other.age
    def __eq__(self, other):
        return self.name==other.name and self.age == other.age

stu = Student("zhang",18)  #Student类的对象，name=zhangage=18
#rint(stu)
stu2 = Student("zhang",18)
print(stu==stu2)#true
stu2 = Student("zhang",19)
print(stu==stu2)#false

封装

面向对象编程，是许多编程语言都支持的一种编程思想。
简单理解是：基于模板（类）去创建实体（对象），使用对象完成功能开发。
面向对象包含3大主要特性：封装、继承、多态

封装表示的是，将现实世界事物的：属性、行为
封装到类中，描述为：成员变量、成员方法
从而完成程序对现实世界事物的描述

既然现实事物有不公开的属性和行为，那么作为现实事物在程序中映射的类，也应该支持。

类中提供了私有成员的形式来支持 ：私有成员变量、私有成员方法
定义私有成员的方式非常简单，只需要：
私有成员变量：变量名以__开头（2个下划线）
私有成员方法：方法名以__开头（2个下划线）
即可完成私有成员的设置

class Student:
    name=None
    age=None
    __money=None
    def __init__(self,name,age,money):
        self.name=name
        self.age=age
        self.__money=money
    def add_money(self,add_money):
        self.__money+=add_money
    
    def __show_money(self ):
        print(self.__money)
    def show_money2(self ):
        print("showmoney2:",self.__money)

stu = Student("zhangsan",19,200)
stu.add_money(100)#只能通过非私有方法去操作私有成员
stu.show_money2() #  300
stu.name="lisa" 
stu.__money=1000 # 不报错无效
stu.show_money2() # 300

继承

继承分为：单继承和多继承
继承表示：将从父类那里继承（复制）来成员变量和成员方法（不含私有），不用再重新定义。

class ClasA (ClassB) # 单继承
class ClasA (ClassB,ClassC,ClassD) #多继承，即一个类，可以继承多个父类

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

子类构建的类对象，可以：
有自己的成员变量和成员方法
使用父类的非私有成员变量和成员方法

pass是占位语句，用来保证函数（方法）或类定义的完整性，表示无内容，空的意思

class LittleStudent(Student):
    littleState=None
    def __init__(self,name,age,lstate):
        self.name=name
        self.age=age
        self.littleState=lstate
lstu=LittleStudent("zhang",10,"little")
lstu.add_money(100)#TypeError: unsupported operand type(s) for +=: 'NoneType' and 'int'
lstu.show_money2()

重写
子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写。
即：在子类中重新定义同名的属性或方法即可。

class Car:
    color="红色"
    length=3.6
    def show_info(self):
        print("汽车信息：color：",self.color,";length：",self.length)
class BMW(Car):
    color="蓝色"
    def show_info(self):
        print("BMW信息：color：",self.color,";length：",self.length)

bmw=BMW()
bmw.show_info()#BMW信息：color： 蓝色 ;length： 3.6

只能在子类内调用父类的同名成员。
子类的类对象直接调用会调用子类复写的成员

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员
如果需要使用被复写的父类的成员，需要特殊的调用方式:
调用父类成员
使用成员变量：父类名.成员变量
使用成员方法：父类名.成员方法(self)
使用super()调用父类成员
使用成员变量：super().成员变量
使用成员方法：super().成员方法()

class Car:
    color="红色"
    length=3.6
    def show_info(self):
        print("汽车信息：color：",self.color,";length：",self.length)
class BMW(Car):
    color = "蓝色"
    def show_info(self):
        Car.show_info() #汽车信息：color： 蓝色 ;length： 3.6
        print(super().color)#红色
        print("BMW信息：color：",self.color,";length：",self.length)

bmw=BMW()
bmw.show_info()#BMW信息：color： 红色 ;length： 3.6

类型注解

为什么PyCharm工具能够正确的提示方法的参数类型、方法名称的？
它是如何知道这个对象有append方法？
因为：PyCharm确定这个对象的类型，是list类型
同样，我们换一份代码：

定义一个函数func，接收一个参数data
PyCharm不会在做出任何提示了

为什么内置模块random的方法可以提示类型
自己定义的就不可以？

因为PyCharm无法通过代码
确定应传入什么类型

Python在3.5版本的时候引入了类型注解，以方便静态类型检查工具，IDE等第三方工具。
类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显式的说明）。
主要功能：
帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示
帮助开发者自身对变量进行类型注释
支持：
变量的类型注解
函数（方法）形参列表和返回值的类型注解

变量的类型注解
语法

变量: 类型

元组类型设置类型详细注解，需要将每一个元素都标记出来
字典类型设置类型详细注解，需要2个类型，第一个是key第二个是value

print("="*20)#false
var1:int =10
var2:bool=False
var3:str="123"
stu:Student = Student()
my_list:list=[1,2,3]
my_tuple:tuple=(1,2,3)
my_set:set[int]={2,3,4}#容器类型详细注解
my_tuple2:tuple[int,str,bool]=(1,"123",False) #容器类型详细注解

除了使用 变量: 类型， 这种语法做注解外，也可以在注释中进行类型注解。
语法：# type:类型

var3 =10 # type:int
my_dict={"zhang":18} #type:dict[str,int]

一般，无法直接看出变量类型之时会添加变量的类型注解
var4:Student=func()

类型注解主要功能在于：
帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示
帮助开发者自身对变量进行类型注释（备注）
并不会真正的对类型做验证和判断。
也就是，类型注解仅仅是提示性的，不是决定性的
如下代码，是不会报错的哦。

var1:int ="123123"

函数（方法）形参列表和返回值的类型注解

在编写函数（方法），使用形参data的时候，工具没有任何提示
在调用函数（方法），传入参数的时候，工具无法提示参数类型
这些都是因为，我们在定义函数（方法）的时候，没有给形参进行注解
函数和方法的形参类型注解语法

def test_type(a:int,b:int,c:int,d:int):
    pass
def add(a:int,b:int):
    return a+b    

同时，函数（方法）的返回值也是可以添加类型注解的。
语法如下

def add(a:int,b:int)->int:
    return a+b
print(add(1,2))

Union类型
使用Union[类型, …, 类型]
可以定义联合类型注解
Union联合类型注解，在变量注解、函数（方法）形参和返回值注解中，均可使用。

多态

多态，指的是：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态
多态常作用在继承关系上.比如
函数(方法)形参声明接收父类对象
实际传入父类的子类对象进行工作
即:
以父类做定义声明
以子类做实际工作
用以获得同一行为, 不同状态

这种设计的含义是：
父类用来确定有哪些方法
具体的方法实现，由子类自行决定
这种写法，就叫做抽象类（也可以称之为接口）
抽象类：含有抽象方法的类称之为抽象类
抽象方法：方法体是空实现的（pass）称之为抽象方法