Python基础学习笔记（一）

风於尘

已于 2024-08-04 23:23:05 修改

阅读量1.1k

点赞数 44

分类专栏： python 文章标签： python 学习笔记

于 2024-08-02 13:33:57 首次发布

本文链接：https://blog.csdn.net/fyx_demo/article/details/140870146

版权

python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

一、下载Python
二、变量
三、数据类型
四、运算符
五、语句
六、容器类型
七、函数 function
八、常用API
九、面向对象
十、三大特征：封装、继承、多态
十一、六大原则：
Python基础学习笔记（二）

一、下载Python

官网：https://www.python.org/
下载最新版本：python-3.10.2-amd64.exe
安装：
1. Install Now：快速安装，勾选添加环境变量；
2. Customize Installation：自定义安装，选择安装位置，勾选2、3、4选项；
学习使用：

IDLE字体修改：Options > Configure IDLE 选择字体为 Consolas。

IDLE两种模式：
- 交互模式：直接在IDLE中输入指令，给出一个指令，机器立刻给出一个反馈。
  - 输入 print("Hello World!") 打印hello world；
  - 输入算数自动计算出结果……
  - 输入 import this ，打印Python的禅宗(py的优点等等)。
- 编辑器模式：以 .py 结尾的文件，包含全部代码。
  - 点击 File > New File 创建新文件，文件后缀为 .py 结尾；
  - 输入测试游戏代码，保存 ctrl + s ，点击 Run > Run Module 运行文件；
```
""" 第一个小游戏 """

temp = input("猜数字小游戏,猜猜我想的是哪个数字：")
guess = int(temp)

if guess == 8:
    print("你好棒棒")
    print("猜对了也没奖励！")
else:
    print("猜错了！正确答案是8")

print("游戏结束")
```
  注意：
  
  遵守Python的语法规范，代码样式指导手册PEP8；
  
  官网：https://www.python.org/dev/peps/pep-0008/
BIF内置函数：

在IDLE中输入：dir(__builtins__) 查看Python的所有内置函数，例如：print()、input() 等；
在 Python 中可以通过 help() 内置函数或者 __doc__ 属性查看某个函数的说明文档，如下代码所示：
```
# 查看 print() 内置函数的说明文档
help(print)
print(print.__doc__)
```
Python的注释：
- 单行注释：使用 # 开头，例如：# 单行注释；
- 多行注释：使用三个连续的引号 ''' 或者 """ 作开头和结尾，也叫长字符串，不支持嵌套。

为自定义函数设置说明文档：

当使用 help() 内置函数或者 __doc__ 属性即可查看的说明文档

# 定义一个比较数字大小的函数
def num_max(num1, num2):
    """
    比较两个数字的大小
    :param num1:形参1，数字1
    :param num2:形参2，数字2
    :return:大的数字，max_num = num1 if num1 > num2 else num2
    """
    max_num = num1 if num1 > num2 else num2
    return max_num

help(num_max)
print(num_max.__doc__)

二、变量

变量：关联一个对象的标识符。以字母(区分大小写)、数字、下划线组成，但不能以数字开头，支持中文。

格式一：变量名 = 变量值，例如：x = 3；
格式二：变量名1, 变量名2 = 变量值1, 变量值2，例如：x, y = 3, 4；
格式三：变量名1 = 变量名2 = 变量值，例如：x = y = 3；
使用变量：例如：print(x) ，即可输出变量的值；
变量删除：del 语句：
- 格式：del 变量名1，变量名2 ……
- 作用：删除变量，接触与对象的关联
- 自动化内存管理的引用计数：每个对象记录着被变量引用的次数，次数为 0 时自动销毁。

两个值互换：

x = 3
y = 5
# 方式一
z = x
x = y
y = z
print(x, y)
5 3		# 输出结果

# 方式二，变量的格式二
x, y = y, x
print(x, y)
5 3		# 输出结果

三、数据类型

核心数据类型：
- 变量没有数据类型，但关联的对象有类型；
- 使用 type 函数查看类型。
空对象：None

作用：
- 占位
- 接触与对象的绑定关系
整形：int
浮点型：float
- 小数：0.1
- 科学计数法：e/E±指数，例如：1.23e-2 (等于0.0123) 、1.234e5 (等于123400.0)
字符串：str
复数（特定运算中涉及）：complex
- 由实部和虚部组成的数字；
- 虚部以 j 或 J 结尾；
- 字面值：1j、1+1j。
布尔：bool
类型转换：

格式：数据类型(变量值)，例如：int(“50”)、str(100)等等。

四、运算符

算术运算符：+ 、- 、* 、/ (整除)、// (地板除，结果不含小数)、%、** (幂运算，次方)。
增强运算符：+=、-=、*=、/=等，与算术运算符个数一致。
比较运算符：< 、<= 、> 、>= 、== 、!= ，返回一个布尔值。
逻辑运算符：and、or、not
- 短路运算：一旦结果确定，后面语句不执行，例如：1>2 and input(“请输入”) == “”
身份运算符：is、is not
优先级：（由上至下，算术 --> 身份）

五、语句

行
1. 物理行：实际代码行数，一个物理行可包括多个逻辑行，使用分号分割；
2. 逻辑行：对应一条指令，建议一个物理行对应一个逻辑行；
3. 换行：
  - 隐式换行：使用括号，所有的括号中内容随意换行；
  - 显示换行：使用折行符 \ 换行，必须放在行的末尾；
pass 语句：用于填充语法空白；
选择语句：
- if elif else语句：注意缩进，冒号
```
if 条件1:
    满足条件1时执行
elif 条件2:
    满足条件2时执行
else:
    都不满足时执行
```
- 真值表达式：如果变量有值（不是None、“”、False），则为True。
- 条件表达式 (三元表达式)：根据条件，去为变量赋值，例如：x = 2 if 2 > 1 else 1。
循环语句：
- while语句：
```
while 条件:
    循环体
#   break
else:
    不满足条件
```
- for语句：遍历可迭代元素
```
for 变量名 in 可迭代对象:
    循环体
else:
```
- range函数：整数生成器，倒序时步长取负值
  - 接收三个参数，分别是：开始、结束、步长，含开始不含结尾。开始默认值 0，步长间隔默认值 1；
  - range(1, 5, 1)，指生成1、2、3、4 的整数；
  - range(1, 5)，参数代表开始、结束，步长间隔取默认值；
  - range(5)，指生成0、1、2、3、4 的整数，其他参数取默认值；
跳转语句：只存在循环语句中
- break语句：跳出循环
- continue语句：跳出本轮循环

六、容器类型

通用操作：
- 加法操作：使用加号将多个字符串拼接为一个字符串，字符串间可简写忽略加号；
- 乘法操作：字符串乘以数字，实现重复多少次此字符串；
- 比较运算：==、!=、<、>等，按编码大小比较；
- 索引操作：格式：容器[整数]，根据索引获取指定位置字符串，索引从零开始；
```
aa = "hello world"
print(aa[4])
o   # 输出结果
```
- 内建函数：
  - len函数，获取序列的长度：
    - 正向索引：len(字符串) - 1，从 0 开始；
    - 反向索引：- len(字符串)，从 -1 开始。
  - max函数，最大值；
  - min函数，最小值；
  - sum函数，求和；
- 切片操作：slice、split，格式：容器[开始：结束：间隔]，包含开始，不包含结尾；
```
aa = "hello world"
print(aa[1:6])
ello        # 输出结果，正常输出

print('{!r}'.format(aa[1:6]))
'ello '     # 输出结果，格式化为带引号输出

print(aa[:3])     # 前三个，简写
print(aa[-3:])     # 后三个，简写
print(aa[::-1])     # 倒序输出
print(aa[::1])     # 正序输出
```
- 包含：in、not in，例如：“ell” in “hello” ，结果为布尔值 True；
字符串 str：由一系列字符组成，存储的是字符的编码值！
- id函数：返回对象真实内存地址；
- ord函数：返回字符对应的 Unicode 编码值，例如：ord(“s”)；
- chr函数：返回整数对应的字符串，例如：chr(114)；
- 单引号 Single quotes：'hello world'；
- 双引号 Double quotes："hello world"；
- 三引号 Triple quoted ：长字符串，实现换行字符串
```
triple_quotes = '''hello world'''
triple_quotes = """hello world"""
```
- 转义字符：用于表示一些不能直接显示的ASCII字符，使用 \ 开头；
- 原始字符串：表示字符串中没有转义符
  
  转义字符需要正常使用，不作为转义字符时，可以在前面加上r，转义不生效；
```
print("D:\one\two\three")
D:\one  wo  hree    # 输出结果

print(r"D:\one\two\three")
D:\one\two\three    # 输出结果
```
- 字符串格式化：
  - 格式："…%s…%d…%f…"%(变量1, 变量2, 变量3)，运行时会自动将变量插入对应位置中；
  - 使用 % 类型码占位，%s 指字符串，%d 指整数，%f 指小数；
  - %2s 指规定占位符长度为 2，%.2f 指保留 2 位小数（四舍、六入、五平分）
列表 list：由一系列变量组成的可变序列容器
- 格式一：容器名 = []，内部放对象，使用逗号分隔；
- 格式二：容器名 = list()，参数放可迭代对象，将对象按索引分为多个对象；
- 添加：append函数；
- 插入：insert函数，参数一为下标，参数二为插入对象；
- 修改：容器名[索引] = 数据值，也可以使用切片修改多个值，如：list01[2] = “你好”、list01[-2:] = [1, 2]；
- 删除：remove函数，参数为元素；或使用 del 语句，根据索引，切片删除；
- 循环：for语句；
  - 建议使用索引操作，因为切片会创建新的列表，浪费内存；
  - 正序：range(len(列表名))，通过索引才能操作每一项数据；
  - 倒序：range(len(列表名) - 1, -1, -1)
- 深浅拷贝：
  - 浅拷贝：list中的copy函数，或使用切片操作，浅拷贝等于切片；
  - 深拷贝：导入 import copy，使用copy.deepcopy(列表)；优点：不影响原数据；缺点：占内存；
  - 区别：浅拷贝只复制新列表，重新引用已有的变量；深拷贝则是复制所有的列表及存储的变量；
- 循环删除：使用倒序删除，否则会有漏删、下标越界问题出现；
- 列表推导式：简洁方式构建列表；
  - 格式一：变量 = [表达式 for 变量 in 可迭代对象]
  - 格式二：变量 = [表达式 for 变量 in 可迭代对象 if 条件]，if条件不满足则丢弃当前项；
  - 例如：list2 = [item for item in list1]、list2 = [item for item in list1 if item > 20]
- 列表与字符串的转换：
  - 列表转字符串：join函数，例如：result = “连接符”.join()；
  - 字符串转列表：split函数，例如：list01 = “字符串”.split(“分隔符”)；
元组 tuple：由变量组成的不可变序列，无法增删改；
- 格式一：tuple1 = ()，注意：一个大小的元组创建：tuple1 = (元素, )，不写逗号表示元素原始的类型；
- 格式二：tuple1 = tuple(可迭代对象)；
- 格式三：tuple1 = 100, 200, 300，可省略括号，不建议；
- 查询：x, y = tuple1，指将元组中数据前两位赋值给 x 和 y；
  - **变量交换的本质 **就是创建元组，例如：x, y = (y, x)
  - 格式化字符串的本质 就是创建元组，例如：“…%s…%d…” % (name, age)
- 索引
- 切片
- 循环
字典 dict：由键值对组成的可变散列容器，无序的；优点：查改最快；
- 格式一：dict1 = {}，键值对使用冒号分隔，例如：“name” : “Bob”；
- 格式二：dict1 = dict( 可迭代对象 )，格式：dict1 = dict([(“name”, “zs”), (“age”, 23)])，建议使用方括号；
- 字典转列表：list(dict1)，结果只会将键存储进列表，值将会丢弃；
- 添加 / 修改：字典名[“键”] = 值，如果键不存在则添加，存在则是修改；例如：dict1[“name”] = “zs”
- 查询：字典名[“键”]，根据键获取值，如果键不存在则报错
  - 获取键：for 键 in 字典名
  - 获取值：for 值 in 字典名.values()
  - 获取键值对：
    - for kv in 字典名.items()，获得的是元组；
    - for 键, 值 in 字典名.items()，分别获取键和值；
- 删除：del语句，例如：del dict1[“name”]，如果键存在则删除，如果键不存在则报错；
- 字典推导式：建议转换可迭代对象为字典；
  - 格式一：变量 = {键 : 值 for 变量 in 可迭代对象}
  - 格式二：变量 = {键 : 值 for 变量 in 可迭代对象 if 条件}
集合 set：由不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器，即只有键的字典；
- 格式一：set1 = {“值1”, “值2”}，此方式不能创建空集合；
- 格式二：set1 = set(可迭代对象)，唯一的创建空集合方式；
- 增加：add函数，例如：set1.add(“key”)；
- 删除：
  - remove函数，存在则删除，否则报错；先判断在删除！！！
  - discard函数，存在则删除，不存在不报错！
- 数学运算：
  - 交集 & ：取出两个集合中相同的元素；set1 & set2
  - 并集 | ：取出两个集合中不重复的元素；set1 | set2
  - 补集 ^ ：取出两个集合中除去相同的元素后剩余的元素；set1 ^ set2
  - 减法 - ：取出集合 1 有的而集合 2 没有的，set1 - set2
  - 子集 < ：判断集合 2 是否包含集合 1 ，set1 < set2
  - 超集 > ：判断集合 1 是否包含集合 2 ，set1 > set2
固定集合 frozenset：不可变的集合；
- 用于对列表的去重复，相对来说节省内存；

嵌套循环 for for：外层循环一次，内层循环一轮；

列表排序：

list1 = [55, 66, 99, 54, 33, 98, 15, 22, 78]
# 排序
for i in range(len(list1) - 1):
    for j in range(i + 1, len(list1)):
        if list1[i] > list1[j]:
            list1[i], list1[j] = list1[j], list1[i]

列表推导式嵌套循环：实现列表的全排列；

# 制作扑克牌
numbers = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
colors = ["黑桃♠", "梅花♣", "方块♦", "红桃♥"]

puker = [i+j for i in numbers for j in colors]
puker.append("大王🃏")
puker.append("小王🃏")

七、函数 function

定义函数：
- 格式一：def 函数名(): 函数体
- 格式二：def 函数名( 形式参数 ): 函数体
- 格式三：def 函数名( 形式参数 ): 函数体 return 返回值
- 在函数体第一行使用注释说明函数的作用；
调用函数：就近原则，重复的函数优先调用近的；
- 格式一：函数名()
- 格式二：函数名( 实际参数 )
- 格式三：变量 = 函数名( 实际参数 )，接收返回值，默认值为None；
内存图：
- 函数加载：将函数代码存储到内存代码区；
- 调用函数：在内存中开辟一块空间 (栈帧)，存储函数中定义的变量；
- 调用结束：栈帧释放；
传参说明：
- 不可变类型的数据 (数值型、布尔值bool、空值None、字符串str、元组tuple、固定集合frozenset)，函数内部不会改变原数据的值；
- 可变类型的数据 (列表list、字典dict、集合set)，函数内部可以改变原数据的值；
作用域：变量起作用的范围
- 全局作用域 global：整个文件中可用，若在函数中，可使用 global 关键字声明变量为全局；
- 局部作用域 local：只能在函数中使用，调用结束销毁；
- 外部嵌套作用域 enclosing：函数嵌套；
- 内置模块作用域 builtin：builtins.py文件，优先级很高；
变量的查找规则：
- 由内到外：局部 – 外部嵌套 – 全局 – 内置模块；
函数参数：

实际参数：
- 位置实参：
  
  调用函数时，实参根据位置与形参对应；
  - 序列实参：例如：fun01(*list01)
    - 使用 * 拆分序列元素，再根据位置与形参对应；
    - 作用：参数过多时，可以通过容器传递信息；
    - 只要是可迭代对象都可以拆分！但是传递散列无意义，无法正确对应位置关系；
- 关键字实参：
  
  实参根据名称与形参进行对应；可读性提高，例如：fun01(p1=“”, p2=0, p3=0.0)
  - 字典实参：例如：fun01(**dict01)
    - 根据键对应实参名称去对应；
    - 使用 ** 拆分序列元素，再根据键名对应实参名称去对应值；
形式参数：
- 缺省参数：默认参数，例如：fun01()；
```
def fun01(p1="", p2=0, p3=2.0):
```
- 实参可以不传递，采用默认值；
  - 必须 从右往左 依次存在，否则报错；
  - 关键字实参 + 默认参数：实现随意传参，例如：fun01(p2 = 100)，p1, p3取默认值；
- 位置形参：
  - 实参必须传递；
  - 星号元组形参：
```
def fun01(*args):
    pass
fun01(1,2,3,5,9)
```
    - 使用 * 将实参合并为一个元组；只能有一个参数！
    - 作用：位置实参数量不限个数；
- 命名关键字形参：
```
def fun01(*args, p1, p2):	# 可以使用默认参数赋值
    
def fun01(p1, *, p2):		# 注意：p1可使用位置形参，p2必须使用关键字形参
```
  - 星号元组形参后面的参数；
  - 要求实参必须是关键字实参；例如：fun01(1,2,3,5,p1=7,p2=9)；
  - 双星号字典形参：
```
def fun01(**kwargs):
```
    - 目的：使关键字实参不限制数量；
- 万能参数写法：
```
def fun01(*args, **kwargs):
    pass
```

八、常用API

官网文档：https://docs.python.org/zh-cn/3.10/

菜鸟教程：https://www.runoob.com/python3/python3-tutorial.html/

九、面向对象

抽象：类别，例如：狗类

具体：个体，例如：哈士奇

程序的设计：先有对象，再有类；

编写的代码：先有类，再有对象；

面向过程：function 称为（函数）

面向对象：function 称为（方法）

类的创建：

成员变量：数据，例如：名字、年龄、性别等；
成员方法：行为，例如：吃饭、洗澡、玩游戏等；

格式：

class 类名:
    def __init__(self, 成员变量……):
        self.实例变量 = 参数
    def 成员方法:
        ……

class Dog:
	def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print(self.name, "吃饭")

创建对象：
- 格式：对象名 = 类名(参数)，也称为：对象名 = 构造函数(参数)
  - 构造函数：__init__ 方法，创建对象时自动调用，没有成员变量时可以省略不写；
- 调用类的方法：对象名 . 方法名()
```
dog01 = Dog("小白", 5, "雌")		# 创建对象
dog01.eat()		# 调用类中的方法
```
- 内存图：
  - 首先根据变量的数据个数来开辟内存空间；
  - self 指向的是开辟空间的内存位置，可以通过 print(id(self)) 查看地址值，结果与创建的对象地址值相同！！

所有的函数每次调用都会开启一个栈帧，调用结束，栈帧销毁；
调用方法默认会将自身的对象 self 传入方法中，例如：dog01.eat() 等价于 dog01.eat(dog01)；

实例成员：
- 实例变量：
  - 创建：对象.变量名，例如：self.name = name
  - 调用：对象.变量名，例如：dog01.name = “tom”
- 说明：
  - 首次赋值为创建，再次赋值为修改；
  - 通常在构造函数中创建；
  - 每个对象存储一份，通过对象的地址访问；
  - __dict__ 用于访问类中所有的数据，返回一个字典，例如：dog01.__dict__；不建议赋值操作；
实例方法：
- 语法：
  - 定义：def 方法名(self, 参数列表): 方法体
  - 调用：对象地址.方法名(参数列表)；
  - 使用类名访问实例方法，例如：Dog.eat(dog01)；不建议使用！！
- 说明：

实例方法至少有一个形参，第一个参数绑定调用这个方法的对象，一般命名为self；
- 无论创建多少对象，方法只有一份，且被所有对象共享。
作用：表示对象的行为；

类成员：

类变量：

位置：类中方法外；

调用：类名.变量名；

class Cat:
    total_money = 1000

Cat.total_money = 0		# 调用

类方法：

格式：普通方法上添加注解：@classmethod，默认接收一个参数 cls 为当前的类名；
作用：操作类变量；

@classmethod 作用：调用类方法时，隐式传递类；

class Cat:
    total_money = 1000
    
    @classmethod
    def print_money(cls):
        print(Cat.total_money - 500)  # 操作类变量，类名.变量名
        print(cls.total_money - 500)  # 接收的参数就是当前的类名！
        
Cat.print_money()		# 调用

特点：
- 随类的加载而加载；
- 优先于对象存在；
- 所有对象可以共享类变量 / 类方法；
- 只能有一份；

静态方法：
1. 语法：
  1. 定义
```
@staticmethod
def 方法名(参数):
    方法体
```
  2. 调用：类名.方法名()，不建议通过对象访问静态方法；
2. 说明：
  1. 使用 @staticmethod 修饰的目的是该方法不需要隐式 ( 默认的参数 ) 的传参；
  2. 静态方法不能访问实例成员和类成员；
3. 作用：
  - 常常用于封装工具函数；

十、三大特征：封装、继承、多态

封装：
1. 数据角度：
  - 定义：将一些基本数据类型复合成一个自定义类型；
  - 优势：
    - 将数据与对数据的操作相关联；
    - 代码可读性更高；
2. 行为角度：
  - 定义：类外提供必要的功能，隐藏实现的细节；
  - 优势：
    - 简化编程，使用者无需知道具体的实现细节，只需调用对外提供的功能；
  - 私有成员：
    - 作用：无需向类外提供的成员
    - 做法：
      - 命名使用双下划线开头；例如：self.__age
        
        障眼法：访问时，实际是 _类名 + 私有变量名 ( _Wife__age )，不建议这样访问；
      - 定义公开的读取方法，判断数据内容；get***()
      - 定义公开的写入方法，写入时做判断；set***()
      - 类变量指向 property() 对象，格式：类变量 = property(get**, set**)，将对数据的操作转为对方法的操作；
      - 最终版本：
        
        get方法：添加注解 @property，同时方法名与实例变量一致；
        set方法：添加注解 @变量名.setter，同时方法名与实例变量一致；
        
        class Student: def __init__(self, name): self.name = name @property def name(self): return self.__name @name.setter def name(self, name): self.__name = name
3. 设计角度：
  - 定义：
    - 分而治之：大需求分解为许多个类，各自处理一个独立的功能；
    - 变而疏之：变化的地方独立封装，避免影响其他类；
    - 高内聚：类中各个方法都在完成一项任务（单一职责）
    - 低耦合：类与类的关联性与依赖度要低（每个类独立）
  - 优势：便于分工，便于复用，可扩展性强；
继承：重写现有类的功能，并在此基础上进行扩展；

格式：class 类名( 父类类名 ): ……

优点：提升代码复用性；

缺点：耦合度高，父类变化直接影响子类；
1. 语法角度：
  - 继承方法：子类可以使用父类的方法；
  - 继承数据：
    - 子类没有构造函数，将会使用父类的构造函数；
    - 子类有构造函数，将会覆盖父类的构造函数；
    - 需要使用父类的构造函数，使用 super().__init() 调用父类的构造函数；
  - 重写：
    - 子类实现父类中相同的方法 (方法名、参数) ，在调用该方法时，实际调用的是子类重写的方法；
    - 内置可重写函数：以双下划线开头，双下划线结尾的是系统定义的成员；
      - 转换字符串：
        
        __str__() 函数：将对象转换为字符串显示，对人友好的；类似toString方法；
        
        __repr__() 函数：将对象转换为字符串显示，对解释器友好的；搭配 eval 函数
        
        eval() 函数：将字符串作为python代码执行（python的灵活之处）
        
        print(eval('3+5*3')) # 直接将字符串作为代码运行，输出结果 car1 = Car('吉利汽车', 50000) car2 = eval(car1.__repr__()) # 克隆对象
      - 运算符重载：运算后返回新对象地址
        
        __add__(self, rhs)：对象之间相加的方法，self + rhs；
        
        __sub__(self, rhs)：减法，self - rhs；
        
        __mul__(self, rhs)：乘法，self * rhs；
        
        __truediv__(self, rhs)：除法，self / rhs；
        
        __floordiv__(self, rhs)：除法 (地板除) ，self // rhs；
        
        __mod__(self, rhs)：取模 (求余) ，self % rhs；
        
        __pow__(self, rhs)：幂，self ** rhs；
        
        class Vector1: def __init__(self, x = 0): self.x = x def __add__(self, rhs): # 重写 return Vector1(self.x + rhs.x)
      - 复合运算符重载：运算后返回原对象地址，原来的基础上做运算！
        
        __iadd__(self, rhs)：加等于，self += rhs；
        
        其他运算符与上类似，在普通运算符方法前加 i 即为复合运算符方法……
        
        class Vector1: def __init__(self, x = 0): self.x = x def __iadd__(self, rhs): # 重写 self.x += rhs.x return self
      - 比较运算符重载：
        
        __eq__(self, rhs)：比较，self == rhs；常用方法eq；
        == 和 is 的区别：
        ==：判断的是 __eq__() 方法中的内容；
        is：判断的是地址值，两个对象的 id(对象) 方法；
      - 反向运算符重载：
        
        __radd__(self, rhs)：加法，self + rhs；
        
        class Vector1: def __init__(self, x = 0): self.x = x def __radd__(self, rhs): # 重写 return self.x + rhs print(v01 + 10) # 重写了__add__()可用 print(10 + v01) # 报错，10不能重写__add__()，只能对象去重写__radd__()
2. 设计角度：
  1. 定义：将相关类的共性进行抽象，同一概念，隔离变化；
  2. 适用性：
3. 内置函数：
  - type(对象)：判读对象的类型；
  - isinstance(对象，类型)：XX对象是否是一种XX类型；
  - issubclass(类型，类型)：XX类型是否是一种 XX类型；
  - ==：XX对象是否是 XX类型；
4. 多继承：
  1. 定义：一个子类同时继承两个以上的父类；被多个变化所隔离，不是代码的复用！
  2. 注意：
    - 如果父级别有多个重名方法，调用时使用的时继承列表最左边的类的方法；
    - 如果想要使用其他父类的方法，则使用类名访问，例如：B.fun01(self)；
    - 同名方法解析顺序，使用 mro() 函数查看；
多态：
1. 语法角度
2. 设计角度：
  - 定义：父类的同一种动作或行为，在不同的子类上有不同的实现；
  - 作用：