Python-notes

Python

这个是社长写的b站黑马程序员的python课的笔记，小白们一枚，欢迎大佬指错

字面量

• 字面量
  • 数字
  • 字符串
  • 列表
  • 元组
  • 集合
  • 字典

注释

• 注释在代码中不会被执行

  • # 单行注释（# 和注释内容一般以一个空格隔开）

  • “”" “”"(前后分别用三个引号表示注释)

变量

• 定义格式（变量名 = 变量值）

数据类型

• 字符串
• 整型
• 浮点型
• type()用来得到数据类型，变量没有类型，但是存储的数据有

数据类型转换

• 从文件中读取的数字，默认是字符串，需要转换成数字类型

• input()语句，默认结果是字符串，需要数字结果是也需要转换

• 格式：目标数据类型(待转换数据) 如：int(x)

• 数据类型都可以转换为字符串，但只有是数字的字符串才能转换为整型和浮点型

标识符

• 类，方法，变量的名字

• 只允许出现中，英文，数字，下划线（不推荐使用中文，但是Python支持，数字不允许用在开头）

• 大小写Python可以进行区分

• 大小写不一样不算占用关键字

运算符

• 算术运算符

  • 加减乘除（+，-，*，/）

  • 取整除（//）

  • 取余（%）

  • 指数（**）

• 赋值运算符（把等号右边的结果赋给左边的变量）

  • 在算术运算符后面加上等号（在同一行语句内运算并进行赋值）

字符串扩展

• 单引号，双引号，三引号定义的都是字符串（三引号内容在赋值给变量时变为字符串）

• 单引号定义法可以内含双引号

• 双引号定义法可以包含单引号

• 使用转义字符“\”：如：n ="“66"”

• 字符串拼接（+号在变量数量较多时使用麻烦，局限性高）

  • 加法拼接，如：

    print("xxx" + "xxx" + a)

  • 使用+拼接，只适用于字符串本身进行拼接，无法和其他数据类型进行拼接

• 字符串格式化

  • %s（将内容转换成字符串，放入占位位置）

    • % 占位符
    • s 将变量变成字符串放入占位符所占位置
    • 例：

    message = "Python大数据学科，毕业%s人，平均工资%s" % (class_name, avg_salary)
    

    • 多个占位符，引用变量需要用括号包起来

  • %d（将内容转换成整数，放入占位位置）

  • %f（将内容转换成浮点型，放入占位位置）

  • 格式化的精度控制

    • 示例：%5.2f表示将宽度设置为5位，将小数点精度设置为2，对11.345设置%7.2f后，输出为：[][]11.35。2歌空格不足宽度，小数部分限制2位精度，四舍五入为.35

  • 格式化方式2

    • 通过语法：f"内容{变量}"的格式；来快速格式化

    • 例如：

    print(f"I am {name}, i born in {set_up_year})
    

    • 不会理会类型

    • 不做精度控制

  • 对表达式进行格式化

    • 表达式：一条具有明确执行结果的代码语句

      print("11的结果是：%d" % （11）)

数据输入

• input语句（获取键盘输入）

  • 使用一个变量接收input获取的数据

    input("请告诉我你是谁")

  • input本身就可以输出提示语句

  • input获取的都是字符串类型的数据，键盘输入的都会变成字符串型

布尔类型和比较运算符

• 布尔类型用来表达现实生活中的逻辑真假

  • True表示真，记作1

  • False表示假，记作0

• 例如：

  result = 10 > 5 结果为True

• 比较运算符

  • == 相等

  • != 不等

  • > 大于

  • < 小于

  • >= 大于或等于

  • <= 小于或等于

判断语句

• if语句的基本格式

  • if

    if 判断表达式:
    	条件成立时的语句
    

  • if——else

    if  判断表达式:
        条件成立时的语句
    else:
        不成立时的语句
    

  • if——elif——else

    if  判断表达式:
    	条件成立时的语句
    elif  判断表达式:
    	条件成立时的雨具
    else:
    	条件都不成立时的语句
    

  • 判断语句的嵌套

    • 相同缩进为同一级判断

随机数字

• 随机数字

  import random
  num = random.randint(最小值，最大值)
  

循环语句

while

while  条件表达式:
     条件满足时，执行的语句1
     条件满足时，执行的语句2
     条件满足时，执行的语句3

• 循环需要设置终止条件，否则会陷入死循环

• 循环需要得到布尔类型数据来判断是否执行循环

• while的嵌套循环

• print输出不换行的写法:

  print("hello world", end = ' ')

• \t

  • 缩进符

  • 效果等同于在键盘上按下Tab

for循环

• for 临时变量 in 待处理数据

• 例如：

  name  =  "itheima"
  for  x  in  name:   //把name中的字符挨个取出给x
      print(x)     //打印
  

• 序列类型

  • 待处理数据严格称为序列类型

  • 字符串

  • 列表

  • 元祖

  • 等等

• range语句

  • 语法1

    range (num) //不包含num本身

    • 例如：

      range(5) //取出数据｛0，1，2，3，4｝

  • 语法2

    range(num1,num2)    //获得一个从num1开始，到num2结束的数字序列，不包含num2本身
    
    

  • 语法3

    range(num1,num2,step)    //获得一个从num1开始，到num2结束的数字序列，不包含num2本身
    

    • 该语法数字序列存在步长，以step为准，step默认为1

    • 例如：

      range(5,20,2)

      • 获取的数据为｛5，7，9｝

  • 变量作用域

    • for循环外访问临时变量，实际上可以访问到，但是在编程规范上，不符合规定

• for循环嵌套

continue和break

• continue

  • 终端本次循环，直接进入下一次循环

  • continue之后的循环语句，在本次循环内不再执行

• break

  • 直接结束循环，不再执行本循环的所有语句

函数

• 函数介绍

  • 组织好的，可重复使用的，用来实现特定功能的代码段

  • 函数能减少重复代码，提高开发效率

• 函数的定义

  def  函数名(传入参数)：
  	函数体
  	return    返回值
  

• 函数调用

  函数名（参数）

  • 参数不需要时可以省略

  • 返回值不需要时可以省略

  • 函数必须先定义后使用

• 函数的参数

  • 传入参数

    • 在函数进行计算的时候，接受外部调用提供的数据

    • 例如：

      def  add(x,y):
      
      	result = x + y
      
      	print(f"{x} + {y} = {result}")
      

    • 函数定义中，提供的x和y称为形式参数

    • 函数调用中传入的数据称为实际参数

    • 传入参数数量不受控制，可以没有，也可以有N个

• 函数的返回值

  • 函数在完成调用之后，传回的值

  def  函数（传入参数）
  	函数体
  	return  返回值
  

  • return之后的代码不执行

  • None类型

    • 无返回值的函数，实际上就是反悔了：None这个字面量

    • 没有实际意义，就是返回了一个空值

    • 可以通过return None主动返回，和不写return效果相同

• 函数说明文档

  • 用多行注释的形式，对函数进行说明解释

  • 写在函数体之前

  • :param //解释参数

  • :return//解释返回值

  • 

• 函数的嵌套调用

  • 定义:一个函数里面调用另一个函数

• 变量的作用域

  • 局部变量

    • 定义在函数体内部的变量,只在函数体内生效

  • 全局变量

    • 定义在函数体外的变量,全部函数都可以生效

  • global关键字

    • 让函数内定义的变量也可以定义为全局变量

    def fun():
    	global num
    	num = 100
    

• 函数的多返回值

  def  test_return():
  	return 1,2
  	x,y = test_return()  //x = 1,y = 2
  

• 函数的多种传参方式

  • 位置参数

    • 调用函数时根据函数定义的参数位置来传递参数

  • 关键字参数

    • user_info(age, name)

    • user_info(name = 小明,age = 20) //调用函数时可以不按照固定顺序

    • 函数调用时,可以和位置参数混用,但是位置参数必须在关键字参数的前面

  • 缺省参数

    • 缺省参数也叫默认参数,用于定义函数,为函数提供默认值

    • 当调用函数时,如果没有传递参数,就会默认使用缺省参数对应的值

    • 函数调用时,如果为缺省参数传递值,则在函数内使用传递值,否则使用默认值

    • 例如:

      • def fun(name, age, gender = '男')

  • 不定长参数

    • 位置不定长

      • def fun(*args) //传递进函数的参数不受限
        • 穿进的所有参数都会被args变量收集,会根据参数的位置合并成为一个元组,args是元组类型

    • 关键字不定长

      • def fun (**kwargs): //传入函数的数量同样不受限
        • 参数是键值对的情况下,所有的键值对都会被kwargs接受,同时根据键值对组成字典

• 匿名函数

  • 函数作为参数传递

    • 这是一种计算逻辑的传递,而不是数据的传递

    • 例如:

      def fun(compute):  //若不传入compute,则fun无法调用compute
      	result = compute(1,2)
      	print(result)
      def compute(x, y):
      	return x + y
       	fun(compute)
      

  • lambda匿名函数

    • def关键字,定义带名称的函数

    • lambda关键字,定义无名称的函数

      def  fun(compute):
      	result = compute(1,2)
      	print(f"{result}")
      	fun(lambda x, y:x + y)
      

    • 无法写多行代码

数据容器

• 一种可以容纳多分数据的数据类型,容纳的每一份数据称之为1个元素,没一个元素,可以存储任意类型的数据

5类数据容器

列表(list)

• 列表的定义

  • 一次性存储多个数据

  • 以 [] 作为标识

  • 列表内每一个元素之间,都好隔开

  • 定义变量

    • 变量名 = ["小明","小红","小敏","大壮"]

  • 列表支持嵌套

    • my_list = [[1,2,3],[4,5,6]]

  • 同一列表支持不同元素的数据类型不一样

    • my_list = ["小明",666,True]

• 列表的下标索引

  • 从前向后,从0开始

  • my_list = [1,2,3,4]

  • my_list[0] = 1

  • 支持反向索引(从后向前,从-1开始)

    • my_list[-1] = 4

  • 嵌套的列表同样支持下标索引

    • my_list = [[1,2,3,4],[5,6,7,8]]

    • my_list[1][1] = 6

  • 通过下标索引取数据,一定不能超出范围

• 列表的常用操作(方法)

  • 方法的定义

    • 

    • 

  • 方法的使用

    student = Student()
    num = student.add(1,2)
    

  • 查询某元素的下标

    • 语法:

      列表.index(元素)

    • 找不到元素就会报错ValueError

  • 插入

    • 语法:

      列表.insert(下标,元素)

    • 在指定的下标位置,插入指定的元素

  • 删除

    • 语法1:

      del 列表[下标]

    • 语法2:

      列表.pop(下标)

      • 将删除元素从列表中取出,并且该元素可以赋值给变量

    • 不依靠下标删除指定元素

      列表.remove(元素)

      • 从前到后移除第一个对应的元素

  • 清空

    • 语法:

      列表.clear()

  • 修改

    列表[下标] = 值

  • 追加

    • 语法:

      列表.append(元素)

      • 将元素插入到列表尾部

    • 语法2:

      列表.extend(其他数据容器)

      • 在列表后追加其他的数据容器

  • 统计个数

    • 语法1:

      列表.count(元素)

      • 统计某元素在列表内的数量

    • 语法2:

      len(列表)

      • 统计容器内有多少元素

• 列表的遍历

  • 将容器内元素依次取出进行处理

  • 通过控制下标索引来控制循环

  • while循环遍历

    • 可以通过条件控制实现无限循环

    • 适用于任何想要的循环场景

    index = 0
    while index < len(列表) :
    	element = 列表[index]
    	index += 1
    

  • for循环遍历

    • 理论上不可以实现无限循环,因为遍历的容器容量不是无限的

    • 适用于遍历数据容器的场景或简单的固定次数的循环场景

    for element in my_list
    	print(f"列表的元素有:{element}")
    

元组(tuple)

• 元组一旦定义完成,就不可以修改

• 定义元组使用小括号,使用逗号隔开各个数据,数据类型可以不同

• 定义元组变量

  • 方式1

    变量名称 = (元素1,元素2,.......,元素n)

  • 方式2

    变量名称 = tuple()

  • t4 = ("hello") //定义的是字符串

  • t4 = ("hello",) //定义的是元组,用逗号标识出来了

• 元组的操作方法

  • index() //查找

  • len() //统计元素个数

  • count() //统计某元素在列表内的个数

字符串(str)

• 字符串可以存放任意数量的字符

• 字符串同样支持下标

• 字符串不支持修改操作,为只读数据容器

• 操作方法

  • 字符串.index() //查找

  • 字符串.replace(字符串1,字符串2) //替换

    • 将字符串内的全部字符串1,替换成字符串2

    • 不是修改字符串本身,而是得到了一个新字符串

  • 字符串.split(分隔符字符串) //分割

    • 按照指定的分隔符字符串,将字符串划分为多个字符串,并存入列表对象中

    • 字符串本身不变,而是得到一个列表对象

  • 字符串.strip() //规整

    • 去除前后空格

  • 字符串.strip(字符串) //去除指定字符

    • 去除前后指定字符串

    • 例子:

      • my_list = "12hello world21

      • print(my_list.strip("12)) //结果:“hello world”

      • 传入的是"12",其实就是"1","2"都会去除,按照单个字符

  • 字符串.count() //统计某字符出现的次数

  • len(字符串) //统计字符串长度

• 支持循环遍历

集合(set)

• 不支持元素重复

• 定义格式

  • 变量名称 = {元素,元素,元素}

  • 变量名称 = set() //定义一个空集合

• 常用操作

  • 集合不支持下表索引访问

  • 集合名称.add(元素) //添加元素

  • 集合名称.remove(元素) //移除元素

  • 集合名称.pop() //从集合中随机取出一个元素

  • 集合名称.clear() //清空集合

  • 集合1.difference(集合2) //取出集合1和集合2的差集

    • 得到一个新的集合,集合1和集合2不变

  • 集合1.difference_update(集合2) //消除2个集合的差集

    • 对比集合1和集合2,在集合1内.删除与集合2相同的元素

  • 集合1.union(集合2) //2个集合合并

    • 将集合1和集合2合并

  • len(集合) //统计集合的元素数量

  • 集合的遍历

    • 集合不支持下标索引,只能使用for循环
      • for x in 集合名称

字典(dict)

• 通过key找到value

• 字典的定义,同样使用{},不过存储的元素是一个个键值对

• 语法:

  • {key:value,key:value,key:value,......,key:value}

  • 字典名称 = {}或者字典名称 = dict{} //定义一个空的字典

• 字典键值对的key不可以重复

• 字典可以嵌套

  • my_dict = {1:{1:a,2:b},2:{3:c,4:d}

• key和value可以是任意数据类型

• 字典基本操作

  • 变量名称 = 字典名称[key] //字典中数据的获取

  • 字典[key] = value //元素的新增和修改

    • 如果key不存在,就新增元素

    • 如果key存在,则修改该key对应的value

  • 字典.pop[key] //获取key对应的value,并在字典中删除这个键值对

  • 变量.clear() //清空字典

  • 字典.keys() //获取全部的key

  • 遍历

    keys = my_dict.keys()
    for key in keys:  //通过获取全部的key,利用for循环遍历字典,等价于for key in 字典名称
    

    • 不支持while循环

  • len(字典名称) //统计字典的元素数量

数据容器的通用操作

• len() //求容器长度

• max() //求容器中最大元素

• min() //求容器中最小元素

• 通用类型转换

  • list()

  • str()

  • tuple()

  • ste()

  • 转换后字典丢失value

• sorted(容器名称,[reverse = True])

  • 给定容器进行排序,reverse默认是False,True是将结果进行反转

  • 排序后存入列表中

  • 排序后字典丢失value

• 字符串大小比较

  • 基于ASCII码值进行比较

  • 一位位进行比较

  • 长的大于短的

  • 

• 序列

  • 内容连续,有序,可以使用下标索引的数据容器

  • 列表,元组,字符串均可以视作序列

  • 切片操作

    • 从一个序列中,取出一个子序列

    • 语法:序列[起始下标:结束下标:步长]

    • 起始和结束不写表示从头到尾

    • 结束下标(不含)表示何处结束,可以留空,留空视作到结尾

    • 步长

      • 1:逐个选择,可以省略不写

      • 2:每隔一个取出

      • N:每次跳过N-1个取出

      • 步长为负,反向取出

文件

文件编码

• 计算机只能识别0和1,通过文件编码技术,将丰富的文件内容转换成0和1存储在硬盘中

• 编码技术

  • 将内容翻译成二进制,以及将二进制翻译回可识别内容

  • UTF-8全球通用的编码格式

  • GBK

  • Big5

文件的读取操作

• open(目标文件名(可以包含文件所在的具体路径),mode(打开文件的模式),encoding = "编码格式")

  • mode

    • r以只读方式打开

    • w打开一个文件只用于写入,如果文件存在则打开文件,并从头开始编辑,原有的内容会被删除,如果文件不存在,就创建新文件

    • a如果该文件存在,新的内容将会被写入到已有内容之后,如果文件不存在,创建新的文件进行写入

• 例如:

  f = open('python.txt','r',encoding = "UTF-8")

  • encoding的位置不是第三位,不能使用位置参数,用关键字参数直接指定

  • f是open函数的文件对象

• 文件访问后,无论后面如何使用方法,都会续接上一次读取文件的方法

• read()方法

  • 文件对象.read(num)

  • num表示要从文件中读取的数据的长度(单位是字节),如果没有传入num,就表示读取文件中所有的数据

• readlines()方法

  • 文件对象.readlines()

  • 按照行读取文件,并返回一个列表,列表元素是每一行的数据

• readline()方法

  • 一次读取一行内容

• for循环读取文件行

  • for line in open(目标文件,mode)

  • 文件每一行默认就是一个元素,不需要用readline()循环读取

• close()关闭文件对象

  • 文件变量.close()

  • 释放内存,停止文件占用

• time.sleep(所需时间) //暂停程序,并设置暂停时间

• with open() as f: //在对文件完成操作之后,自动close文件,避免遗忘

文件的写入操作

• f.write()

  • 文件写入

• f.flush()

  • 内容刷新

• 调用write时,内容并未真正写入文件,而是会积攒在程序的内存中,称之为缓冲区

• 当调用flush的时候,内容会真正写入文件,这样可以避免频繁调用

文件的追加写入

• 在打开文件时mode使用"a",其他操作和文件写入相同

异常

定义

• 程序运行过程中出现了错误

异常的捕获

• 为什么要捕获异常

  • 遇到异常,一般有两种情况

    • 程序崩

    • 溃对bug进行提醒,程序继续进行

• 捕获异常

  • 语法 1:捕获所有的异常

    try:
    	可能出现错误的代码
    except:
    	如果出现异常执行的代码
    

    • 或者

    try:
    	可能出现错误的代码
    except Exception as e:
    	如果出现异常执行的代码
    

  • 语法2:捕获指定的异常

    try:
    	可能出现错误的代码
    except NameError as e:  //NameError可以是任意异常,e是存储异常信息的变量
    	如果出现异常执行的代码
    

  • 语法3:捕获多个异常

    try:
    	可能出现错误的代码
    except (NameError,ZeroDivisionError) as e:
    	如果出现异常执行的代码
    

• 异常else

  try:
  	可能出现错误的代码
  except:
  	如果出现异常执行的代码
  else:
  	如果没有异常,执行else中的代码
  

• 异常finally

  try:
  	可能出现错误的代码
  except:
  	如果出现异常执行的代码
  else: 
  	如果没有异常,执行else中的代码
  finally:
  	有无异常都会执行,经常用于文件的关闭
  

异常的传递

• 

模块和包

模块(Module)

• 模块就是一个Python文件,其中包含类和方法,通过导入可以使用这些

• 模块的导入

  • [form 模块名] import [模块|类|变量|函数|*][as 别名]

  • 常用组合形式:

  • 例如

    import time
    print("开始")
    #让程序暂停1秒
    time.sleep(1)
    print("结束")
    

    • 或者

    from time import * //   *号就是导入该模块的全部功能,使用from可以在后面代码中直接使用模块中的方法,而直接使用import需要用.来调用
    print("你好")
    sleep(5)
    print("我好")
    

    • 或者

    import time as t  //给time模块一个别名,后续使用模块用别名代替
    print("开始")
    \#让程序暂停1秒
    t.sleep(1)
    print("结束")
    

• 自定义模块

  • 定义一个模块

    • 创建一个Python文件,书写函数和方法

  • 通过导入模块语句导入

• 当导入多个模块的时候,切模块内有同名功能,当调用这个同名功能的时候,调用到的是后面导入的模块的功能

• 测试模块

  • 在实际开发中,开发人员会自行在Python文件中添加一些测试信息,就会产生一个问题,导入该模块时,这些测试信息会被调用

  • 解决方案:

    if _name_ = '_main_'

• _all_ = ['方法名称']

  • 在使用*导入所有方法的时候，只有在all里的才能被导入

包

• 包就是文件夹，其中包含多个Python模块，并且而外包含一个_int_.py文件

• 自定义包

  • 创建步骤

• 导入包

  • 导入包

    • import 包名称

  • 导入包的模块

    • import 包名称.模块名称

    • form package import moudual

• 安装第三方包

  • 第三方包

  • 安装

    • pip install 包名称

    • 通过国内镜像下载

      • 清华大学网站下载：

      • pip install -i https://pypi.tuna.tsinghua.edu.cn/simple matplotlib

JSON数据格式

• json是一种轻量级的数据交互格式

• 本质上是一个带有特定格式的字符串

• 主要功能

  • 在各个编程语言中流通的数据格式,负责不同的编程语言中的数据传递和交互

• python数据和JSON数据的相互转换

  • python转json

    import json
    data = {"a":1,"b":2,"c":3,"d":4}
    json_str = json.dumps(data)  如果有中文的话-->  json_str = json.dumps(data, ensure_ascii=False)
    print(type(json_str))
    print(json_str)
    

  • json转python

    data = '{"a":1,"b":2,"c":3,"d":4}'
    l = json.loads(data)
    print(type(l))
    print(l)
    

pyecharts模块

• [画廊]

• 基础折线图

  from pyecharts.chart import Line
  line.Line()
  line.add_xaxis(["x","y","z"])
  line.add_yaxis("GDP",[a, b, c])
  line.render()
  

• 全局配置

  • set_global_opts

• 数据处理

  • 通过json模块进行数据处理

类与对象

• 对象

  • 

• 类的成员方法

  class  类名称:
  	类的属性  //成员变量
  	## 类的行为`  //成员方法，就是函数，在类内叫方法
  	def  方法名（self, 形参1，形参2:
  		方法体
  

构造方法

• _init_()

  • 在创建类对象的时候，会自动执行

  • 在创建类对象的时候，将传入参数自动传递给_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")
    

魔术方法

_init_

_str_字符串方法

• 直接输出类对象只会输出为内存地址，通过字符串方法，控制类转换为字符串输出

class  Student:
	def _init_(self,name,age,tel):
		self.name = name
		self.age = age
	def _str_(self):
		return f"Student类对象,name = {self.name},age = {self.age}"
student = Student("周杰伦",11)
print(student)    //结果：Student类对象,name = 周杰伦,age = 11
print(str(student))    //结果：Student类对象,name = 周杰伦,age = 11

lt

• 可以让对象之间进行 < 或者 > 比较

class  Student:
	def _init_(self,name,age,tel):
		self.name = name
		self.age = age
	def _lt_(self.other):
		return self.age < other.age
stu = Student("周杰伦",11)
stu1 = Student("林俊杰",13)
print(stu < stu1)  //结果:True
print(stu > stu1)  //结果:False

_le_

• 可以让对象之间进行 <= 或者 >= 比较

class  Student:
	def _init_(self,name,age,tel):
		self.name = name
		self.age = age
	def _lt_(self.other):
		return self.age <= other.age
stu = Student("周杰伦",11)
stu1 = Student("林俊杰",13)
print(stu <= stu1)  //结果:True
print(stu >= stu1)  //结果:False  

_eq_

• 可以让对象之间进行 == 比较

class  Student:
	def _init_(self,name,age,tel):
		self.name = name
		self.age = age
	def _lt_(self.other):
		return self.age == other.age
stu = Student("周杰伦",11)
stu1 = Student("林俊杰",13)
print(stu == stu1)  //结果:False

封装

• 私有成员变量

  class Phone:
  	__current_voltage = 0.5  //在定义变量名时,前面加上__
  

• 私有成员方法

  class Phone:
  	__current_voltage = 0.5
      def __kepp_single_core(self):  //在定义方法名时,前面加上__
          print("让CPU以单核模式运行")
  

• 私有的成员变量和成员方法只有类内部可以使用

继承

继承的基础语法

• 单继承

class phone2022(phone):
    face_id = True
    
    def call_by_5G(self):
        print()

• 多继承

class HUAWEI(phone,NFC,RemoteControl):
    

复写和使用父类成员

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

class Phone:  //父类
	IMEI = None
	producer = "ITCATS"
	
	def call_by_5G(self):
		print("父类的5G通话")

class MyPhone(Phone):  //继承
	producer = "ITHEIMA"  //复写父类属性
	
	def call_by_5G(self):  //复写父类方法
		print("子类的5G通话")

• 调用父类同名成员

  • 方式1

    • 调用父类成员

      • 使用成员变量

        父类名.成员变量

      • 使用成员方法

        父类名.成员方法(self)

    class Phone:  //父类
    	IMEI = None
    	producer = "ITCATS"
    	
    	def call_by_5G(self):
    		print("父类的5G通话")
    
    class MyPhone(Phone):  //继承
    	producer = "ITHEIMA"  //复写父类属性
    	
    	def call_by_5G(self):  //复写父类方法
    		print(f"父类的品牌是:{Phone.producer}")
    		Phone.call_by_5G(self)
            
            print("子类的5G通话")
    

  • 方式2

    • 使用super()调用父类成员

      • 使用成员变量

        super().成员变量

      • 使用成员方法

        super().成员方法()

    class Phone:  //父类
    	IMEI = None
    	producer = "ITCATS"
    	
    	def call_by_5G(self):
    		print("父类的5G通话")
    
    class MyPhone(Phone):  //继承
    	producer = "ITHEIMA"  //复写父类属性
    	
    	def call_by_5G(self):  //复写父类方法
    		print(f"父类的品牌是:{super().producer}")
    		super().call_by_5G(self)
    		
    		print("子类的5G通话")
    

类型注解

• 类型注解:在代码中设计数据交互的地方,提供数据类型的注解(显示说明)

变量的类型注解

## 变量类型注解
var_1: int = 10
var_2: float = 3.1415926
var_3: bool = True
var_4: str = "itheima"
## 基础容器类型注解
my_list: list = [1,2,3]
my_tuple: tuple = (1,2,3)
my_set: set = {1,2,3}
my_dict: dict = {"itheima":666}
my_str: str = "itheima"
## 容器类型详细注解
my_list: list[int] = [1,2,3]
my_tuple: tuple[str,int,boll] = ("itheima",2,True)
my_set: set[int] = {1,2,3}
my_dict: dict[str,int] = {"itheima":666}

class Student:
	pass
stu: Student = Student()

• 除了在代码中使用注解,注释中也可以进行类型注解

class Student:
	pass
	
var_1 = random.randint(1,10)		# type: int
var_2 = json.loads(data)		# type: dict[str,int]
var_3 = func()		# type: int

函数(方法)的类型注解

• 对函数(方法)的形参进行类型注解

def 函数方法名(形参名: 类型, 形参名: 类型,....):
	pass

• 对函数(方法)的返回值进行类型注解

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

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

dog = Dog()
cat = Cat()

make_noise(dog)		# 输出: 汪汪汪
make_noise(cat)		# 输出: 喵喵喵

抽象类(接口)

• 在上文Animal父类中,父类的成员方法是空实现,父类来确定有哪些方法,具体的方法实现,由子类自行决定,这种写法,就叫做抽象类

## 抽象类
class AC:
	## 抽象方法
	def cool_wind(self):
		"""制冷"""
		pass
		
	def hot_wind(self):
		"""制热"""
		pass
		
	def wind(self):
		"""左右摆风"""
		pass

dict: dict = {“itheima”:666}
my_str: str = “itheima”

容器类型详细注解

my_list: list[int] = [1,2,3]
my_tuple: tuple[str,int,boll] = (“itheima”,2,True)
my_set: set[int] = {1,2,3}
my_dict: dict[str,int] = {“itheima”:666}

```python
class Student:
	pass
stu: Student = Student()

• 除了在代码中使用注解,注释中也可以进行类型注解

class Student:
	pass
	
var_1 = random.randint(1,10)		# type: int
var_2 = json.loads(data)		# type: dict[str,int]
var_3 = func()		# type: int

函数(方法)的类型注解

• 对函数(方法)的形参进行类型注解

def 函数方法名(形参名: 类型, 形参名: 类型,....):
	pass

• 对函数(方法)的返回值进行类型注解

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

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

dog = Dog()
cat = Cat()

make_noise(dog)		# 输出: 汪汪汪
make_noise(cat)		# 输出: 喵喵喵

抽象类(接口)

• 在上文Animal父类中,父类的成员方法是空实现,父类来确定有哪些方法,具体的方法实现,由子类自行决定,这种写法,就叫做抽象类

## 抽象类
class AC:
	## 抽象方法
	def cool_wind(self):
		"""制冷"""
		pass
		
	def hot_wind(self):
		"""制热"""
		pass
		
	def wind(self):
		"""左右摆风"""
		pass