Python学习路线 - Python语言基础入门 - 面向对象

Python学习路线 - Python语言基础入门 - 面向对象

    • 初识对象
      • 生活中数据的组织
      • 程序中数据的组织
      • 使用对象组织数据
    • 成员方法
      • 类的定义和使用
      • 成员变量和成员方法
      • 成员方法的定义语法
      • 注意事项
    • 类和对象
      • 现实世界的事物和类
      • 类和对象
      • 在程序中通过类来描述
      • 基于类创建对象
    • 构造方法
      • 属性(成员变量)的赋值
      • 构造方法
      • 构造方法注意事项
    • 其它内置方法
      • 魔术方法
      • __str__字符串方法
      • __lt__小于符号比较方法
      • __le__小于等于比较符号方法
      • __eq__,比较运算符实现方法
    • 封装
      • 面向对象的三大特性
      • 封装
      • 对用户隐藏的属性和行为
      • 私有成员
      • 使用私有成员
      • 案例
    • 继承
      • 继承的引出
      • 单继承
      • 多继承
      • 多继承注意事项
    • 继承 - 复写
      • 复写
      • 调用父类同名成员
    • 类型注解
      • 为什么需要类型注解
      • 类型注解
      • 类型注解的语法
      • 函数(方法)的类型注解 - 形参注解
      • 函数(方法)的类型注解 - 返回值注解
      • Union类型
    • 多态
      • 多态
      • 抽象类(接口)
    • 综合案例

初识对象

生活中数据的组织

学校开学,要求学生填写自己的基础信息,一人发一张白纸,让学生自己填
Python学习路线 - Python语言基础入门 - 面向对象_第1张图片

改为登记表,打印出来让学生自行填写:
Python学习路线 - Python语言基础入门 - 面向对象_第2张图片

程序中数据的组织

在程序中简单使用变量来记录学生信息
Python学习路线 - Python语言基础入门 - 面向对象_第3张图片
在这里插入图片描述
Python学习路线 - Python语言基础入门 - 面向对象_第4张图片
Python学习路线 - Python语言基础入门 - 面向对象_第5张图片
思考
使用变量记录数据太乱了。
如果程序中也和生活中一样

  • 可以设计表格
  • 可以将设计的表格打印出来
  • 可以将打印好的表格供人填写内容

那么数据的组织就非常方便了。

使用对象组织数据

在程序中是可以做到和生活中那样,设计表格、生产表格、填写表格的组织形式的。
1.在程序中设计表格,我们称之为:设计类(class)
在这里插入图片描述

2.在程序中打印生产表格,我们称之为:创建对象
Python学习路线 - Python语言基础入门 - 面向对象_第6张图片

3.在程序中填写表格,我们称之为:对象属性赋值
在这里插入图片描述

总结
1.生活中或是程序中,我们都可以使用设计表格、生产表格、填写表格的形式组织数据
2.进行对比,在程序中:

  • 设计表格,称之为:设计类(class)
  • 打印表格,称之为:创建对象
  • 填写表格,称之为:对象属性赋值
    Python学习路线 - Python语言基础入门 - 面向对象_第7张图片

代码示例:

# 1.设计一个类(类比生活中:设计一张登记表)
class Student:
    name = None         # 记录学生姓名
    gender = None       # 记录学生性别
    nationality = None  # 记录学生国籍
    native_place = None # 记录学生籍贯
    age = None          # 记录学生年龄

# 2.创建一个对象(类比生活中:打印一张登记表)
stu_1 = Student()
# 3.对象属性进行赋值(类比生活中:填写表单)
stu_1.name = "林俊杰"
stu_1.gender = "男"
stu_1.nationality = "中国"
stu_1.native_place = "山东省"
stu_1.age = 31
# 4.获取对象中记录的信息
print(stu_1.name)
print(stu_1.gender)
print(stu_1.nationality)
print(stu_1.native_place)
print(stu_1.age)

Python学习路线 - Python语言基础入门 - 面向对象_第8张图片

成员方法

类的定义和使用

在上一节中,我们简单了解到可以使用类去封装属性,并基于类创建出一个个的对象来使用。
现在我们来看看类的使用语法:
Python学习路线 - Python语言基础入门 - 面向对象_第9张图片

创建类对象的语法:
在这里插入图片描述
Python学习路线 - Python语言基础入门 - 面向对象_第10张图片

成员变量和成员方法

那么,什么是类的行为(方法)呢?
Python学习路线 - Python语言基础入门 - 面向对象_第11张图片
Python学习路线 - Python语言基础入门 - 面向对象_第12张图片
Python学习路线 - Python语言基础入门 - 面向对象_第13张图片

可以看出,类中:

  • 不仅可以定义属性用来记录数据
  • 也可以定义函数,用来记录行为

其中:

  • 类中定义的属性(变量),我们称之为:程员变量
  • 类中定义的行为(函数),我们称之为:成员方法

成员方法的定义语法

在类中定义成员方法和定义函数基本一致,但仍有细微区别:
在这里插入图片描述
可以看到,在方法定义的参数列表中,有一个:self关键字
self关键字是成员方法定义的时候,必须填写的。

  • 它用来表示类对象自身的意思
  • 当我们使用类对象调用方法的时,self会自动被python传入
  • 在方法内部,想要访问类的成员变量,必须使用self
    在这里插入图片描述

注意事项

self关键字,尽管在参数列表中,但是传参的时候可以忽略它。
如:
Python学习路线 - Python语言基础入门 - 面向对象_第14张图片
可以看到,在传入参数的时候,self是透明的,可以不用理会它。

总结
1.类是由哪两部分组成呢?

  • 类的属性,称之为:成员变量
  • 类的行为,称之为:成员方法

注意:函数是写在类外的,定义在类内部,我们都称之为方法哦
2.类和成员方法的定义语法
Python学习路线 - Python语言基础入门 - 面向对象_第15张图片

3.self的作用

  • 表示类对象本身的意思
  • 只有通过self,成员方法才能访问类的成员变量
  • self出现在形参列表中,但是不占用参数位置,无需理会

代码示例:

"""
演示面向对象类中的成员方法定义和使用
"""

# 定义一个带有成员方法的类
class Student:
    name = None   # 学生的姓名

    def say_hi(self):
        print(f"大家好呀,我是{self.name},欢迎大家多多关照!")

    def say_hi2(self, msg):
        print(f"大家好,我是{self.name},{msg}")

stu = Student()
stu.name = "周杰伦"
stu.say_hi()
stu.say_hi2("哎吆不错")

stu2 = Student()
stu2.name = "林俊杰"
stu2.say_hi()
stu2.say_hi2("小伙子我看好你")

Python学习路线 - Python语言基础入门 - 面向对象_第16张图片

类和对象

现实世界的事物和类

Python学习路线 - Python语言基础入门 - 面向对象_第17张图片
Python学习路线 - Python语言基础入门 - 面向对象_第18张图片
现实世界的事物也有属性和行为,类也有属性和行为。

使用程序中的类,可以完美的描述现实世界的事物

类和对象

基于类创建对象的语法:对象名 = 类名称()
为什么非要创建对象才能使用呢?

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

在程序中通过类来描述

Python学习路线 - Python语言基础入门 - 面向对象_第19张图片

基于类创建对象

Python学习路线 - Python语言基础入门 - 面向对象_第20张图片
这就是面向对象编程:
设计类,基于类创建对象,由对象做具体的工作。

总结
1.现实世界的事物由什么组成?

  • 属性
  • 行为

类也可以包含属性和行为,所以使用类描述现实世界事物是非常合适的
2.类和对象的关系是什么?
类是程序中的“设计图纸”
对象是基于图纸生产的具体实体
3.什么是面向对象编程?
面向对象编程就是,使用对象进行编程。
即,设计类,基于类创建对象,并使用对象来完成具体的工作

代码示例

"""
演示类和对象的关系,即面向对象的编程套路(思想)
"""

# 设计一个闹钟类
class Clock:
    id = None      # 序列化
    price = None   # 价格

    def ring(self):
        import winsound
        winsound.Beep(2000, 3000)

# 构建2个闹钟对象并让其工作
clock1 = Clock()
clock1.id = "003032"
clock1.price = 19.99
print(f"闹钟ID:{clock1.id},价格:{clock1.price}")
clock1.ring()

clock2 = Clock()
clock2.id = "003033"
clock2.price = 21.99
print(f"闹钟ID:{clock2.id},价格:{clock2.price}")
clock2.ring()

Python学习路线 - Python语言基础入门 - 面向对象_第21张图片

构造方法

属性(成员变量)的赋值

Python学习路线 - Python语言基础入门 - 面向对象_第22张图片
上面代码中,为对象的属性赋值需要依次进行,略显繁琐。
有没有更加高效的方式,能够一行代码就完成呢?

思考:
在这里插入图片描述

这个括号,能否像函数(方法)那样,通过传参的形式对属性赋值呢?
可以,需要使用构造方法:init()

构造方法

Python类可以使用:init()方法,称之为构造方法。
可以实现:

  • 在创建类对象(构造类)的时候,会自动执行。
  • 在创建类对象(构造类)的时候,将传入参数自动传递给__init__方法使用。
    Python学习路线 - Python语言基础入门 - 面向对象_第23张图片
    Python学习路线 - Python语言基础入门 - 面向对象_第24张图片

构造方法注意事项

  • 重要的事情说三遍,构造方法名称:init init init , 千万不要忘记init前后都有2个下划线
  • 构造方法也是成员方法,不要忘记在参数列表中提供:self
  • 在构造方法内定义成员变量,需要使用self关键字
    Python学习路线 - Python语言基础入门 - 面向对象_第25张图片
    这是因为:变量是定义在构造方法内部,如果要成为成员变量,需要用self来表示。

总结
1.构造方法的名称是:
init,注意init前后的2个下划线符号
2.构造方法的作用:

  • 构建类对象的时候会自动运行
    = 构建类对象的传参会传递给构造方法,借此特性可以给成员变量赋值
    3.注意事项:
  • 构造方法不要忘记self关键字
  • 在方法内使用成员变量需要使用self

代码示例:

"""
演示类的构造方法
"""
# 演示使用构造方法对成员变量进行赋值
# 构造方法的名称: __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("Student类创建了一个类对象")

stu = Student("周杰伦", 31, "18500006666")
print(stu.name)
print(stu.age)
print(stu.tel)

Python学习路线 - Python语言基础入门 - 面向对象_第26张图片

其它内置方法

魔术方法

上文学习的__init__构造方法,是Python类内置的方法之一。
这些内置的类方法,各自有各自特殊的功能,这些内置方法我们称之为:魔术方法
Python学习路线 - Python语言基础入门 - 面向对象_第27张图片

__str__字符串方法

Python学习路线 - Python语言基础入门 - 面向对象_第28张图片
当类对象需要被转换为字符串之时,会输出如上结构(内存地址)

内存地址没有多大作用,我们可以通过__str__方法,控制类转换为字符串的行为。
Python学习路线 - Python语言基础入门 - 面向对象_第29张图片
Python学习路线 - Python语言基础入门 - 面向对象_第30张图片

__lt__小于符号比较方法

Python学习路线 - Python语言基础入门 - 面向对象_第31张图片

直接对2个对象进行比较是不可以的,但是在类中实现__lt__方法,即可同时完成:小于符号 和 大于符号 2种比较
Python学习路线 - Python语言基础入门 - 面向对象_第32张图片
Python学习路线 - Python语言基础入门 - 面向对象_第33张图片
Python学习路线 - Python语言基础入门 - 面向对象_第34张图片
代码示例:

"""
演示其它内置发方法
"""

class Student:
    def __init__(self, name, age):
        self.name = name  # 学生姓名
        self.age = age    # 学生年龄

    # __str__魔术方法
    def __str__(self):
        return f"Student类对象,name:{self.name},age:{self.age}"

    # __lt__魔术方法
    def __lt__(self, other):
        return self.age < other.age

stu = Student("周杰伦", 31)
# print(stu)
# print(str(stu))
stu2 = Student("林俊杰", 36)
print(stu < stu2)
print(stu > stu2)

Python学习路线 - Python语言基础入门 - 面向对象_第35张图片

__le__小于等于比较符号方法

魔术方法:__le__可用于:<=、>=两种比较运算符上。
Python学习路线 - Python语言基础入门 - 面向对象_第36张图片
在这里插入图片描述
代码示例:

"""
演示其它内置发方法
"""

class Student:
    def __init__(self, name, age):
        self.name = name  # 学生姓名
        self.age = age    # 学生年龄

    # __str__魔术方法
    def __str__(self):
        return f"Student类对象,name:{self.name},age:{self.age}"

    # __lt__魔术方法
    def __lt__(self, other):
        return self.age < other.age

    # __le__魔术方法
    def __le__(self, other):
        return self.age <= other.age

stu = Student("周杰伦", 31)
# print(stu)
# print(str(stu))
stu2 = Student("林俊杰", 36)
print(stu <= stu2)
print(stu >= stu2)

Python学习路线 - Python语言基础入门 - 面向对象_第37张图片

eq,比较运算符实现方法

Python学习路线 - Python语言基础入门 - 面向对象_第38张图片

不实现__eq__方法,对象之间可以比较,但是是比较内存地址,也即是:不同对象==比较一定是False结果。

实现了__eq__方法,就可以按照自己的想法来决定2个对象是否相等了。

代码示例:

"""
演示其它内置发方法
"""

class Student:
    def __init__(self, name, age):
        self.name = name  # 学生姓名
        self.age = age    # 学生年龄

    # __str__魔术方法
    def __str__(self):
        return f"Student类对象,name:{self.name},age:{self.age}"

    # __lt__魔术方法
    def __lt__(self, other):
        return self.age < other.age

    # __le__魔术方法
    def __le__(self, other):
        return self.age <= other.age

    # __eq__魔术方法
    def __eq__(self, other):
        return self.age == other.age

stu = Student("周杰伦", 31)
# print(stu)
# print(str(stu))
stu2 = Student("林俊杰", 31)
# print(stu <= stu2)
# print(stu >= stu2)

print(stu == stu2)

Python学习路线 - Python语言基础入门 - 面向对象_第39张图片

总结
Python学习路线 - Python语言基础入门 - 面向对象_第40张图片

封装

面向对象的三大特性

面向对象编程,是许多编程语言都支持的一种编程思想。
简单理解是:基于模板(类)去创建实体(对象),使用对象完成功能开发。

面向对象包含3大主要特征

  • 封装
  • 继承
  • 多态

封装

Python学习路线 - Python语言基础入门 - 面向对象_第41张图片
封装表示的是,将现实世界实物的:

  • 属性
  • 行为

封装到类中,描述为:

  • 成员变量
  • 成员方法

从而完成程序对现实世界事物的描述。

对用户隐藏的属性和行为

现实世界中的事物,有属性和行为。
但是不代表这些属性和行为都是开放给用户使用的。
Python学习路线 - Python语言基础入门 - 面向对象_第42张图片
苹果越狱、安卓root,也是为了突破权限使用这些对用户隐藏的属性和行为。

私有成员

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

类中提供了私有成员的形式来支持。

  • 私有成员变量
  • 私有成员方法

定义私有成员的方式非常简单,只需要:

  • 私有成员变量:变量名以__开头(2个下划线)
  • 私有成员方法:方法名以__开头(2个下划线)
    即可完成私有成员的设置
    Python学习路线 - Python语言基础入门 - 面向对象_第43张图片

私有方法无法直接被类对象使用
Python学习路线 - Python语言基础入门 - 面向对象_第44张图片

私有变量无法赋值,也无法获取值
Python学习路线 - Python语言基础入门 - 面向对象_第45张图片
在这里插入图片描述

代码示例:

"""
演示面向对象封装思想中私有成员的使用
"""

# 定义一个类,内含私有成员变量和私有成员方法
class Phone:

    __current_voltage = None  # 当前手机运行电压

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


phone = Phone()
# phone.__keep_single_core()
print(phone.__current_voltage)

Python学习路线 - Python语言基础入门 - 面向对象_第46张图片
Python学习路线 - Python语言基础入门 - 面向对象_第47张图片

使用私有成员

私有成员无法被类对象使用,但是可以被其它的成员使用。
Python学习路线 - Python语言基础入门 - 面向对象_第48张图片
Python学习路线 - Python语言基础入门 - 面向对象_第49张图片
代码示例:

"""
演示面向对象封装思想中私有成员的使用
"""

# 定义一个类,内含私有成员变量和私有成员方法
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_core()
            print("电量不足,无法使用5g通话,并已设置为单核运行进行省电。")


phone = Phone()
phone.call_by_5g()

Python学习路线 - Python语言基础入门 - 面向对象_第50张图片
总结
1.封装的概念是指?
将现实世界事物在类中描述为属性和方法,即为封装。
2.什么是私有成员?为什么需要私有成员?
现实事物有部分属性和行为是不公开对使用者开放的。同样在类中描述属性和方法的时候也需要达到这个要求,就需要定义私有成员了
3.如何定义私有成员?
成员变量和成员方法的命名均以__作为开头即可
4.私有成员的访问限制?

  • 类对象无法访问私有成员
  • 类中的其它成员可以访问私有成员

私有成员的定义我们已经了解了,但是:
它有什么实际的意义吗?

在类中提供仅供内部使用的属性和方法,而不对外开放(类对象无法使用)

案例

设计带有私有成员的手机

设计一个手机类,内部包含:

  • 私有成员变量:__is_5g_enable,类型bool,True表示开启5g,False表示关闭5g
  • 私有成员方法:__check_5g(),会判断私有成员__is_5g_enable的值
    • 若为True,打印输出:5g开启
    • 若为False,打印输出:5g关闭,使用4g网络
  • 公开成员方法:call_by_5g(),调用它会执行
    • 调用私有成员方法:__check_5g(),判断5g网络状态
    • 打印输出:正在通话中
      运行结果:
      Python学习路线 - Python语言基础入门 - 面向对象_第51张图片

通过完成这个类的设计和使用,体会封装中私有成员的作用

  • 对用户公开的,call_by_5g()方法
  • 对用户隐藏的,__is_5g_enable私有变量和__check_5g私有成员

代码示例:

"""
讲解面向对象-封装特性练习题
设计带有私有成员的手机
"""

# 设计一个类,用来描述手机
class Phone:

    # 提供私有成员变量:__is_5g_enable
    __is_5g_enable = True  # 5g状态

    # 提供私有成员方法:__check_5g()
    def __check_5g(self):
        if self.__is_5g_enable:
            print("5g开启")
        else:
            print("5g关闭,使用4g网络")

    # 提供公开成员方法:call_by_5g()
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")

phone = Phone()
phone.call_by_5g()

Python学习路线 - Python语言基础入门 - 面向对象_第52张图片

继承

继承的引出

Python学习路线 - Python语言基础入门 - 面向对象_第53张图片

如果你是设计师,你会如何选择?
1.每一代新款手机,都从零开始出设计图
2.基于老款的设计图,修修改改

Python学习路线 - Python语言基础入门 - 面向对象_第54张图片
构建Phone2022类,你会选择
1.从头写一个新的类
2.基于已有的Phone类进行修改

单继承

Python学习路线 - Python语言基础入门 - 面向对象_第55张图片
语法:
Python学习路线 - Python语言基础入门 - 面向对象_第56张图片
继承分为:单继承和多继承
使用如图语法,可以完成类的单继承。
继承表示:将从父类那里继承(复制)来成员变量和成员方法(不含私有)

代码示例:

"""
演示面向对象:继承的基础语法
"""

# 演示单继承
class Phone:
    IMEI = None  # 序列号
    producer = "MRY"  # 厂商

    def call_by_4g(self):
        print("4g通话")

class Phone2023(Phone):
    face_id = "10001"  # 面部识别ID

    def call_by_5g(self):
        print("2023年新功能:5g通话")

phone = Phone2023()
print(phone.producer)
print(phone.face_id)
phone.call_by_4g()
phone.call_by_5g()

Python学习路线 - Python语言基础入门 - 面向对象_第57张图片

多继承

Python的类之间也支持多继承,既一个类,可以继承多个父类。
Python学习路线 - Python语言基础入门 - 面向对象_第58张图片
在这里插入图片描述
Python学习路线 - Python语言基础入门 - 面向对象_第59张图片

多继承注意事项

多个父类中,如果有同名的成员,那么默认以继承顺序(从左到右)为优先级。
即:先继承的保留,后继承的被覆盖
Python学习路线 - Python语言基础入门 - 面向对象_第60张图片
总结
1.什么是继承?
继承就是一个类,继承另外一个类的成员变量和成员方法
语法:
在这里插入图片描述

子类构建的类对象,可以

  • 有自己的成员变量和成员方法
  • 使用父类的成员变量和成员方法

2.单继承和多继承
单继承:一个类继承另一个类
多继承:一个类继承多个类,按照顺序从左向右依次继承
多继承中,如果父类有同名方法或属性,先继承的优先级高于后继承
3.pass关键字的作用是什么
pass是占位语句,用来保证函数(方法)或类定义的完整性,表示无内容,空的意思

代码示例:

"""
演示面向对象:继承的基础语法
"""

# 演示单继承
class Phone:
    IMEI = None  # 序列号
    producer = "MRY"  # 厂商

    def call_by_4g(self):
        print("4g通话")

# 演示多继承
class NFCReader:
    nfc_type = "第五代"
    producer = "XM"

    def read_card(self):
        print("NFC读卡")

    def write_card(self):
        print("NFC写卡")

class RemoteControl:
    rc_type = "红外遥控"

    def control(self):
        print("红外遥控开启了")

class MyPhone(Phone, NFCReader, RemoteControl):
    pass

phone = MyPhone()
phone.call_by_4g()
phone.read_card()
phone.write_card()
phone.control()

# 演示多继承下,父类成员名一致的场景
print(phone.producer)

Python学习路线 - Python语言基础入门 - 面向对象_第61张图片

继承 - 复写

复写

子类继承父类的成员属性和成员方法后,如果对其"不满意",那么可以进行复写。
即:在子类中重新定义同名的属性或方法即可。
Python学习路线 - Python语言基础入门 - 面向对象_第62张图片

代码示例:


class Phone:
    IMEI = None        # 序列号
    producer = "MRY"   # 厂商

    def call_by_5g(self):
        print("使用5g网络进行通话")

# 定义子类,复写父类成员
class MyPhone(Phone):
    producer = "xm123"

    def call_by_5g(self):
        print("开启CPU单核模式,确保通话的时候省电")
        print("使用5g网络进行通话")
        print("关闭CPU单核模式,确保性能")


phone = MyPhone()
phone.call_by_5g()
print(phone.producer)

Python学习路线 - Python语言基础入门 - 面向对象_第63张图片

调用父类同名成员

一旦复写父类成员,那么类对象调用成员的时候,就会调用复写的新成员。
如果需要使用被复写的父类的成员,需要特殊的调用方式:
方式一:

  • 调用父类成员
    使用成员变量:父类名.成员变量
    使用成员方法:父类名.成员方法(self)

方式二:

  • 使用super()调用父类成员
    使用成员变量:super().成员变量
    使用成员方法:super().成员方法()

Python学习路线 - Python语言基础入门 - 面向对象_第64张图片
注意:
只能在子类内调用父类的同名成员。
子类的类对象直接调用会调用子类复写的成员

总结
1.复写表示:
对父类的成员属性或成员方法进行重新定义
2.复写的语法:
在子类中重新实现同名成员方法或成员属性即可
3.在子类中,如何调用父类成员

Python学习路线 - Python语言基础入门 - 面向对象_第65张图片
Python学习路线 - Python语言基础入门 - 面向对象_第66张图片
注意:只可以在子类内部调用父类的同名成员,子类的实体类对象调用默认是调用子类复写的

代码示例:

class Phone:
    IMEI = None        # 序列号
    producer = "MRY"   # 厂商

    def call_by_5g(self):
        print("使用5g网络进行通话")

# 定义子类,复写父类成员
class MyPhone(Phone):
    producer = "xm123"

    def call_by_5g(self):
        print("开启CPU单核模式,确保通话的时候省电")
        # 方式一
        print(f"父类的厂商是:{Phone.producer}")
        Phone.call_by_5g(self)
        # 方式二
        print(f"父类的厂商是:{super().producer}")
        super().call_by_5g()
        print("关闭CPU单核模式,确保性能")


phone = MyPhone()
phone.call_by_5g()
print(phone.producer)

Python学习路线 - Python语言基础入门 - 面向对象_第67张图片

类型注解

为什么需要类型注解

在PyCharm中编写代码,我们经常能够见到如下提示:
Python学习路线 - Python语言基础入门 - 面向对象_第68张图片

自动提示可用方法
思考,为什么PyCharm工具能够做到这一点?
它是如何知道这个对象有append方法?

因为:PyCharm确定这个对象,是list类型

同样,我们换一份代码:
定义一个函数func,接收一个参数data
你会发现,PyCharm不会在做出任何提示了
Python学习路线 - Python语言基础入门 - 面向对象_第69张图片

思考,为什么PyCharm工具无法提示了?

因为:PyCharm不确定这个对象是什么类型

又或者当我们调用方法,进行传参的时候(快捷键ctrl+p弹出提示):
Python学习路线 - Python语言基础入门 - 面向对象_第70张图片
为什么内置模块random的方法可以提示类型
自己定义的就不可以?

因为PyCharm无法通过代码
确定应传入什么类型
我们需要使用类型注解

类型注解

Python在3.5版本的时候引入了类型注解,以方便静态类型检查工具,IDE等第三方工具。
类型注解:在代码中涉及数据交互的地方,提供数据类型的注解(显式的说明)。
主要功能:

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

支持:

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

类型注解的语法

为变量设置类型注解

基础语法:变量: 类型

Python学习路线 - Python语言基础入门 - 面向对象_第71张图片
Python学习路线 - Python语言基础入门 - 面向对象_第72张图片
Python学习路线 - Python语言基础入门 - 面向对象_第73张图片
Python学习路线 - Python语言基础入门 - 面向对象_第74张图片
注意

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

除了使用 变量:类型,这种语法做注解外,也可以在注释中进行类型注解。
语法:
在这里插入图片描述
Python学习路线 - Python语言基础入门 - 面向对象_第75张图片
为变量设置注解,显示的变量定义,一般无序注解
Python学习路线 - Python语言基础入门 - 面向对象_第76张图片
如图,就算不写注解,也明确的知晓变量的类型

Python学习路线 - Python语言基础入门 - 面向对象_第77张图片
一般,无法直接看出变量类型之时
会添加变量的类型注解

类型注解主要功能在于:

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

并不会真正的对类型做验证和判断。
也就是,类型注解仅仅是提示性的,不是决定性的
在这里插入图片描述

如图代码,是不会报错的哦。

总结
1.什么是类型注解,有什么作用?
在代码中涉及数据交互之时,对数据类型进行显式的说明,可以帮助:

  • PyCharm等开发工具对代码做类型推断协助做代码提示
  • 开发者自身做类型的备注

2.类型注解支持:

  • 变量的类型注解
  • 函数(方法)的形参和返回值的类型注解

3.变量的类型注解语法

  • 语法1: 变量: 类型
  • 语法2: 在注释中,# type: 类型

4.注意事项

  • 类型注解只是提示性的,并非决定性的。数据类型和注解类型无法对应也不会导致错误

代码示例:

"""
演示变量的类型注解
"""
import json
import random

# 基础数据类型注解
var_1: int = 10
var_2: str = "mry"
var_3: bool = True

# 类对象类型注解
class Student:
    pass

stu: Student = Student()

# 基础容器类型注解
my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_dict: dict = {"mry", 6666}

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

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

# 类型注解的限制
var_4: int = "mry"
var_5: str = 123

函数(方法)的类型注解 - 形参注解

Python学习路线 - Python语言基础入门 - 面向对象_第78张图片
Python学习路线 - Python语言基础入门 - 面向对象_第79张图片

如图所示:

  • 在编写函数(方法),使用形参data的时候,工具没有任何提示
  • 在调用函数(方法),传入参数的时候,工具无法提示参数类型

这些都是因为,我们在定义函数(方法)的时候,没有给形参进行注解

函数和方法的形参类型注解语法:
在这里插入图片描述
在这里插入图片描述
Python学习路线 - Python语言基础入门 - 面向对象_第80张图片
在这里插入图片描述
Python学习路线 - Python语言基础入门 - 面向对象_第81张图片

函数(方法)的类型注解 - 返回值注解

同时,函数(方法)的返回值也是可以添加类型注解的。
语法如下:
在这里插入图片描述
Python学习路线 - Python语言基础入门 - 面向对象_第82张图片
Python学习路线 - Python语言基础入门 - 面向对象_第83张图片
总结
1.函数(方法)可以为哪里添加注解?
形参的类型注解
返回值的类型注解
2.函数(方法)的类型注解语法?
在这里插入图片描述
注意,返回值类型注解的符号使用: ->

代码示例:

"""
演示对函数(方法)进行类型注解
"""

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

add()

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

func()

Union类型

Python学习路线 - Python语言基础入门 - 面向对象_第84张图片
Python学习路线 - Python语言基础入门 - 面向对象_第85张图片
使用Union[类型,…,类型]
可以定义联合类型注解

Union联合类型注解,在变量注解、函数(方法)形参和返回值注解中,均可以使用。
在这里插入图片描述
总结
1.什么是Union类型?
使用Union可以定义联合类型注解
2.Union的使用方式

  • 导包:from typing import Union
  • 使用:Union[类型, …, 类型]

代码示例:

"""
演示Union联合类型注解
"""
# 使用Union类型,必须先导包
from typing import Union

my_list: list[int, str] = [1, 2, "mry", "xm"]

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

func()

多态

多态

多态,指的是:多种状态,即完成某个行为时,使用不同的对象会得到不同的状态。
如何理解?
Python学习路线 - Python语言基础入门 - 面向对象_第86张图片
同样的行为(函数),传入不同的对象,得到不同的状态。

Python学习路线 - Python语言基础入门 - 面向对象_第87张图片
多态常作用在继承关系上。

比如:

  • 函数(方法)形参声明接收父类对象
  • 实际传入父类的子类对象进行工作

即:

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

抽象类(接口)

细心的同学可能发现了,父类Animal的speak方法,是空实现
Python学习路线 - Python语言基础入门 - 面向对象_第88张图片
这种设计的含义是:

  • 父类用来确定有哪些方法
  • 具体的方法实现,由子类自行决定

这种写法,就叫做抽象类(也可以称之为接口)

抽象类:含有抽象方法的类称之为抽象类
抽象方法:方法体是空实现的(pass)称之为抽象方法

为什么要使用抽象类呢?
Python学习路线 - Python语言基础入门 - 面向对象_第89张图片
提出标准后
不同的厂家各自实现标准的要求。

抽象类就好比定义一个标准,
包含了一些抽象的方法,要求子类必须实现。
Python学习路线 - Python语言基础入门 - 面向对象_第90张图片
Python学习路线 - Python语言基础入门 - 面向对象_第91张图片
Python学习路线 - Python语言基础入门 - 面向对象_第92张图片
配合多态,完成

  • 抽象的父类设计(设计标准)
  • 具体的子类实现(实现标准)

Python学习路线 - Python语言基础入门 - 面向对象_第93张图片
总结
1.什么是多态?
多态指的是,同一个行为,使用不同的对象获得不同的状态。
如,定义函数(方法),通过类型注解声明需要父类对象,实际传入子类对象进行工作,从而获得不同的工作状态
2.什么是抽象类(接口)
包含抽象方法的类,称之为抽象类。抽象方法是指:没有具体实现的方法(pass)称之为抽象方法
3.抽象类的作用
多用于做顶层设计(设计标准),以便子类做具体实现。
也是对子类的一种软性约束,要求子类必须复写(实现)父类的一些方法
并配合多态使用,获得不同的工作状态。

代码示例:

"""
演示面向对象的多态特性以及抽象类(接口)的使用
"""

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

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

make_noise(dog)
make_noise(cat)

# 演示抽象类
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 swing_l_r(self):
        print("美的空调左右摆风")

class GREE_AC(AC):
    def cool_wind(self):
        print("格力空调制冷")

    def hot_wind(self):
        print("格力空调制热")

    def swing_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)

Python学习路线 - Python语言基础入门 - 面向对象_第94张图片

综合案例


你可能感兴趣的:(Python,python)