python2 九十章 面向对象

面向对象

类的定义和使用

① 定义类的语法：

class 类名称:

        类属性

        类行为

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

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

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

② 创建对象的语法：

对象 = 类名称（）

注意事项：self关键字，尽管在参数列表中，但是传参的时候可以忽略它。

class Student :
    name = None
    def say_hi(self):
        print(f'大家好呀，我是{self.name},请多多关照')

stu1 = Student()
stu1.name = '张三'
stu1.say_hi()

构造方法

python中类可以使用：__init__()方法，称之为构造方法

可以实现：

在创建类对象（构造类）的时候，会自动执行

在创建类对象（构造类）的时候，将传入参数自动传递给__init__()方法使用

class Student:
  
    def __init__(self,name,age,tel):
        self.name = name
        self.age = age
        self.tel = tel

stu = Student('周杰伦',12,'27939268')
print(stu.name) #周杰伦

魔术方法

① __str__字符串方法：有了该方法，输出对象则按照定义的格式输出，否则输出为一串毫无意义的内存地址

class Student:

    def __init__(self,name,age,tel):
        self.name = name
        self.age = age
        self.tel = tel

    def __str__(self):
        return f'student类对象，name{self.name},age:{self.age},tel:{self.tel}'

stu = Student('周杰伦',12,'27939268')
print(stu)
# student类对象，name周杰伦,age:12,tel:27939268

② __lt__小于符号比较方法

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

在该方法内定义比较的规则

class Student:

    def __init__(self,name,age,tel):
        self.name = name
        self.age = age
        self.tel = tel

    def __str__(self):
        return f'student类对象，name{self.name},age:{self.age},tel:{self.tel}'

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

stu1 = Student('周杰伦',12,'27939268')
stu2 =Student('王三',18,'62892378')
print(stu1<stu2)    #True
print(stu1>stu2)    #False

② __le__小于等于符号比较方法

面向对象的三大特性：封装、继承、多态

封装

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

私有成员|变量定义

① 私有成员变量：变量名以__开头（2个下划线）

② 私有成语方法：方法名以__开头（2个下划线）

即可完成私有成员的设置

继承

① 单继承语法：

class 类名( 父类名 )：

        类内容体

② 多继承语法：

class 类名(父类名1，父类名2....)：

        类内容体

注意:多继承中，如果父类有同名方法或属性，先继承的优先级高于后继承

pass关键字的作用：它是一个普通的占位语句，用来保证我们的函数或者方法或者说类定义的完整性，表示无内容，空的意思。

复写

子类继承父类的成员属性和成员方法后，如果对其’不满意‘，那么可以进行复写。

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

调用父类同名成员

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

如果需要调用被复写的父类的成员，需要特殊的调用方式

方式1：

调用父类成员

使用成员变量：父类名.成员变量

使用成员方法：父类名.成员方法( self )

方式2：

使用super()调用父类成员

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

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

类型注解

当我们调用方法，进行传参的时候（快捷键 ctrl + p 弹出提示)，

主要功能：

• 帮助第三方IDE工具对代码进行类型推断，协助做代码提示
• 帮助开发者自身对变量进行类型注释

支持：

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

为变量设置类型注解

基础语法：变量：类型

注意：

① 元组类型设置类型详细注解，需要将每一个元素都标记出来

②字典类型设置类型详细注解，需要两个类型，第一个是key第二个是value

# 基础数据类型注解
var_1: int = 10
var_2: str ='itheima'

# 类对象类型注解
class Student:
    pass
stu: Student = Student()

# 基础容器类型注解
mylist: list = [1, 2, 3]
mydict: dict = {'itheima':666}

# 容器类型详细注解
my_list: list[int] = [1, 2, 3]
my_tuple: tuple[int, str, bool] = (1, 'itheima', True)
my_dict: dict[str, int] = {'itheima':666}

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

语法：

# type ：类型

import json
import random

# 在注释中进行类型注释
var_1 = random.randint(1,10) # type:int
var_2 = json.loads("{'name':'张三'}") # type:dict[str, str]
def func():
    return 10
var_3 = func() # type:int

一般，在无法直接看出变量类型的时候，会添加变量的类型注解。

类型注解的限制

类型注解并不会真正的对类型做验证和判断，也就是说，类型注解仅仅是提示性的，并非绝对性的。数据类型和注解类型无法对应也不会导致错误。

函数（方法）的类型注解-形参注解

语法：

def 函数方法名(形参名：类型，形参名：类型，.....) -> 返回值类型:

        方法体

# 对形参进行类型注解
def add(x: int, y: int):
    return x + y

# 对返回值进行类型注解
def func(data : list) -> list:
    return data

print(add(1, 2))

类型注解

语法：Union[ 类型，.....，类型 ]

Union联合类型注解，在变量注解、函数( 方法 )形参和返回值注解中，均可使用。

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

Union的使用方式：

① 导包：from typing import Union

② 使用：Union[类型,.......,类型]

# 使用Union类型，必须先导包
from typing import Union

my_list: list[Union[int, str]] = [1,2,'itheima','itcast']

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

多态

多态指的是：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态。

同样的行为（函数），传入不同的对象，得到不同的状态。

多态常作用在继承关系上，比如：

① 函数（方法）形参声明接收父类对象

② 实际传入父类的子类对象进行工作

即：

• 以父类做定义声明
• 以子类做实际工作
• 用以获得同一行为，不同状态。

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.speak()

# 演示多态，使用2个子类对象来调用函数
dog = Dog()
cat = Cat()

make_noise(dog) #汪汪汪
make_noise(cat) #喵喵喵

抽象类：含有抽象方法的类称之为抽象类

抽象方法：方法体是空实现的（pass）称之为抽象方法。

class AC:
    def cool_wind(self):
        '''制冷'''
        pass

    def hot_wind(self):
        '''制热'''
        pass
    def swing_l_r(self):
        '''左右摆风'''
        pass
class Midea_AC(AC):
    def cool_wind(self):
        print('美的空调制冷')

    def hot_wind(self):
        print('美的空调制热')

    def sing_l_r(self):
        print('美的空调左右摆风')


class GREE_AC(AC):
    def cool_wind(self):
        print('格林空调制冷')

    def hot_wind(self):
        print('格林空调制热')

    def sing_l_r(self):
        print('格林空调左右摆风')

def make_cool(ac: AC):
    ac.cool_wind()

midea_ac = Midea_AC()
gree_ac = GREE_AC()
make_cool(midea_ac)
make_cool(gree_ac)