✨博文作者：烟雨孤舟
💖 喜欢的可以 点赞 收藏 关注哦~~✍️ 作者简介: 一个热爱大数据的学习者
✍️ 笔记简介：作为大数据爱好者，以下是个人总结的学习笔记，如有错误，请多多指教！
1. 标识符命名规则：
- 只能由 字母、数字、下划线组成
- 不能以数字开头
- 不能使用关键字（如 if、for、class）
- 区分大小写
2.标识符命名规范：
- 变量名使用 小写 + 下划线（snake_case）
- 类名使用大驼峰（CamelCase）
- 常量使用全大写
- 见名知意，不要用单字母
3.常见的数据类型：
- 不可变数据类型：数值、字符串、元组
- 可变数据类型：列表、集合、字典
| 类型名称 | 关键字 | 可变性 | 有序性 | 典型用途 |
|---|---|---|---|---|
| 整数 | int | 不可变 | N/A | 计数、索引 |
| 浮点数 | float | 不可变 | N/A | 科学计算 |
| 布尔 | bool | 不可变 | N/A | 条件判断 |
| 字符串 | str | 不可变 | 有序 | 文本处理 |
| 列表 | list | 可变 | 有序 | 动态数据 |
| 元组 | tuple | 不可变 | 有序 | 固定结构数据 |
| 字典 | dict | 可变 | 有序 (3.7+) | 键值映射、JSON |
| 集合 | set | 可变 | 无序 | 去重、集合运算 |
| 不可变集合 | frozenset | 不可变 | 无序 | 作为字典 key |
4.type 和 isinstance 的区别:
- type()：返回对象的类型、只判断当前类型、不考虑继承关系
- isinstance()：判断是否是某个类型或其子类、会考虑继承关系
type(1) # int类型 isinstance(1, int) # 判断是否是int类型 返回True、False5.字符串定义方式：
- 单引号（‘python’）、双引号（”python“）、三引号(”””python”””)
- 单引号等价双引号都是单行字符串，三引号可换行
- 常见的转义字符串：
- \’ （单引号）\”（双引号） \n（换行） \t（制表符）
6.Python 36 个关键字
| 类别 | 关键字 | 作用 |
|---|---|---|
| 布尔值 | True | 布尔真值 |
| False | 布尔假值 | |
| None | 空值，表示无对象 | |
| 逻辑运算符 | and | 逻辑与 |
| or | 逻辑或 | |
| not | 逻辑非 | |
| 条件控制 | if | 条件判断 |
| elif | 多条件分支 | |
| else | 条件否则 | |
| 循环控制 | for | 循环遍历 |
| while | 条件循环 | |
| break | 跳出循环 | |
| continue | 跳过本次循环 | |
| 函数定义 | def | 定义函数 |
| return | 返回值 | |
| lambda | 定义匿名函数 | |
| 类与对象 | class | 定义类 |
| del | 删除变量或对象引用 | |
| 异常处理 | try | 尝试执行代码 |
| except | 捕获异常 | |
| finally | 无论是否异常都会执行 | |
| raise | 主动抛出异常 | |
| 模块导入 | import | 导入模块 |
| from | 从模块中导入 | |
| as | 起别名 | |
| 作用域名 | global | 声明全局变量 |
| nonlocal | 声明使用外层函数变量 | |
| 异步编程 | async | 定义异步函数 |
| await | 等待异步执行结果 | |
| 其他 | is | 判断是否为同一个对象（身份判断） |
| in | 判断成员是否存在 | |
| yield | 生成器返回值（暂停函数执行） | |
| pass | 占位语句 | |
| assert | 断言判断 |
7.常见的算术运算符：
| 运算符 | 名称 | 示例 | 说明 |
|---|---|---|---|
| + | 加法 | a + b | 两数相加 |
| - | 减法 | a - b | 两数相减 |
| * | 乘法 | a * b | 两数相乘 |
| / | 除法 | a / b | 返回浮点数结果 |
| // | 整除 | a // b | 向下取整 |
| % | 取余 | a % b | 取余数 |
| ** | 幂运算 | a ** b | a 的 b 次方 |
涉及到浮点数的算术运算时，可能会损失精度（计算机底层逻辑是基于二进制来进行存储和处理的， 二进制无法精确表示某些十进制小数）
示例：
print(0.1 + 0.2) # 0.30000000000000004 **# 解决方式（金融场景必须掌握）** # 1.使用 decimal 模块（推荐）， 适用于金额计算 from decimal import Decimal a = Decimal("0.1") b = Decimal("0.2") print(a + b) # 0.3 # 2.使用 round 控制精度，但不适合金融核心计算。 round(0.1 + 0.2, 2)8.常见的赋值运算符：
| 运算符 | 示例 | 等价于 |
|---|---|---|
| = | a = 10 | 将右侧的值赋给左侧变量 |
| += | a += 5 | a = a + 5 |
| -= | a -= 5 | a = a - 5 |
| *= | a *= 5 | a = a * 5 |
| /= | a /= 5 | a = a / 5 |
| //= | a //= 5 | a = a // 5 |
| %= | a %= 5 | a = a % 5 |
| **= | a **= 2 | a = a ** 2 |
9.常见的位运算符：
| 运算符 | 示例 | 等价于 |
|---|---|---|
| &= | a &= b | a = a & b |
| ` | =` | `a |
| ^= | a ^= b | a = a ^ b |
| <<= | a <<= 1 | a = a << 1 |
| >>= | a >>= 1 | a = a >> 1 |
10.常见比较运算符：
| 运算符 | 含义 | 示例 | 结果 |
|---|---|---|---|
| == | 等于 | 3 == 3 | True |
| != | 不等于 | 3 != 2 | True |
| > | 大于 | 5 > 3 | True |
| < | 小于 | 3 < 5 | True |
| >= | 大于等于 | 5 >= 5 | True |
| <= | 小于等于 | 3 <= 5 | True |
| 运算符 | 含义 | 示例 |
|---|---|---|
| is | 是否是同一个对象 | a is b |
| is not | 是否不是同一个对象 | a is not b |
| 运算符 | 含义 |
|---|---|
| in | 是否包含 |
| not in | 是否不包含 |
11.Python 特殊赋值形式：
a, b = 1, 2 # 多变量赋值 a, b = b, a # 变量交换 a = b = c = 10 # 链式赋值 a, b, c = [1, 2, 3] # 解包赋值12.if 控制语句：
定义：if 用于根据条件判断是否执行某段代码。
在 if 中，以下情况会被判断为 False：False、None、0、0.0、""、[]、{}、set()
if 条件1: 代码块1 elif 条件2: 代码块2 else: 代码块3# 条件表达式（三目运算符） # 结果1 if 条件 else 结果2 age = 20 status = "成年" if age >= 18 else "未成年"13.match … case 语句:
定义：用于根据不同模式匹配不同情况执行代码。
match 表达式: case 模式1: 代码块1 case 模式2: 代码块2 case _: 默认代码块status = 200 match status: case 200: print("成功") case 404: print("未找到") case 500: print("服务器错误") case _: print("未知状态")14.while循环：
定义：while 用于在条件为 True 时反复执行代码块。
while 条件表达式: 代码块while 条件表达式: 代码块 else: 代码块 # 如果 while 正常结束（没有被 break 打断），执行 else。被 break 打断，else 不执行。15.for 循环：
定义：用于遍历可迭代对象（iterable）。本质是一种轮询遍历机制，对对象进行逐个处理。
可迭代对象：list、tuple、str、dict、set、range()、生成器
for 变量 in 可迭代对象: 代码块range() 函数： Python 内置函数，用于生成一个整数序列，常用于 for 循环（左闭右开）。
| 参数 | 含义 |
|---|---|
| start | 起始值（默认 0） |
| stop | 结束值（不包含） |
| step | 步长（默认 1） |
range(stop) range(start, stop) range(start, stop, step)示例：
# 遍历字符串 for ch in "hello": print(ch) # 遍历字典 key for k in d.keys(): print(k) # 遍历字典 value for v in d.values(): print(v) # 遍历字典 key 和 value for k, v in d.items(): print(k, v) # enumerate() 获取索引 names = ["Tom", "Jack"] for index, name in enumerate(names): print(index, name) # zip() 多对象同时遍历 a = [1,2,3] b = ["a","b","c"] for x, y in zip(a, b): print(x, y) # for + else for i in range(3): print(i) else: print("循环正常结束") # 没有被 break 打断才执行 else，如果 break 了，else 不执行 # 列表推导式（for 的简写） nums = [x*x for x in range(5)] nums = [] for x in range(5): nums.append(x*x)16.while 和 for的区别：
- while循环：用于在某个条件满足时一直循环，循环的次数通常是未知的，只知道循环开始和结束的条件。
- for循环：用于对一个已知的数据集进行遍历或已知次数的循环（遍历每一个元素）。
| while | for |
|---|---|
| 适合条件不确定次数 | 适合确定次数 |
| 需要手动控制变量 | 自动迭代 |
| 容易写死循环 | 更安全 |
17.python 数据容器：列表、元组、字典、集合、字符串
18.序列：元素按特定顺序排列，并且可以通过索引访问元素的容器类型，称为序列。
19.索引：从前向后（正向索引），从下标0开始；从后向前（反向索引），下标从-1开始。
20.切片：对数据截取其中一部分的操作，列表、字符串、元组都支持切片，左闭右开区间。
语法：nums[start:end:step] start:开始索引，不指定默认为0（第一个元素的索引） end:结束索引，不指定默认为列表长度（查到列表末尾） step:步长，不指定默认为121.列表（list）：列表是 Python 中最常用的可变、有序序列类型。
特点：有序、可变、可重复、可存任意类型
nums = list((1, 2, 3)) # 从元组创建 chars = list("hello") # 从字符串创建 empty = list()语法：
# 访问元素 nums = [10, 20, 30] print(nums[0]) # 10 print(nums[-1]) # 30（倒数第一个） # 切片 nums[0:2] # [10, 20, 30] nums[:1] # [10，20] nums[::2] # 步长为2 # 添加元素 nums.append(4) # 在列表的尾部追加元素 nums.insert(0, 99) # 在指定索引之前，插入该元素 nums.extend([5,6]) # 追加多个元素 # 删除元素 nums.remove(2) # 删除第一个匹配到的值 按照值 nums.pop() # 删除并返回指定位置元素 按照索引 del nums[0] # 修改元素 nums[0] = 100 # 列表推导式 nums = [x*x for x in range(5)]| 分类 | 方法 | 作用 | 示例 |
|---|---|---|---|
| 添加 | append(x) | 末尾添加一个元素 | lst.append(4) |
| 添加 | extend(iterable) | 追加多个元素 | lst.extend([5,6]) |
| 添加 | insert(i, x) | 在指定索引之前插入元素 | lst.insert(0, 99) |
| 删除 | remove(x) | 删除第一个匹配值 | lst.remove(2) |
| 删除 | pop() | 默认删除最后一个元素 | lst.pop() |
| 删除 | pop(i) | 删除指定索引位置元素 | lst.pop(0) |
| 删除 | clear() | 清空列表 | lst.clear() |
| 删除 | del | 删除指定元素或列表 | del lst[0] |
| 查找 | index(x) | 返回元素索引 | lst.index(3) |
| 查找 | count(x) | 统计元素出现次数 | lst.count(2) |
| 排序 | sort() | 原地排序 | lst.sort() |
| 排序 | sort(reverse=True) | 倒序排序 | lst.sort(reverse=True) |
| 排序 | reverse() | 反转列表顺序 | lst.reverse() |
| 复制 | copy() | 浅拷贝 | lst.copy( |
22.解包（Unpacking）：把容器类型（list / tuple / dict / set 等）里的元素“拆开”取出来。
常见用途有：赋值解包、函数参数解包、字典解包。
赋值解包：
# 列表 / 元组可以直接拆开赋值 data = [1, 2, 3] a, b, c = data print(a) # 1 print(b) # 2 print(c) # 3 # 本质：[1,2,3] -> a=1 b=2 c=3 # 如果数量不匹配会报错：ValueError: too many values to unpack星号解包 *：
# 如果元素数量不确定，可以用 *。 data = [1, 2, 3, 4, 5] a, *b = data print(a) # 1 print(b) # [2,3,4,5]函数参数解包 *：
def add(a, b, c): return a + b + c data = [1,2,3] result = add(*data) print(result) # 等价于：add(1,2,3)字典解包 **：
# 字典可以拆成 关键字参数。 def create_user(name, age): print(name, age) data = { "name": "Tom", "age": 18 } create_user(**data) # 等价于：create_user(name="Tom", age=18循环解包：
data = [(1,2), (3,4), (5,6)] for a,b in data: print(a,b)- 组包（packing）：把多个独立的值“打包”成一个容器（通常是 tuple 或 dict）。
a,b,c = 1,2,3 data = a, b, c. # data = (1, 2, 3)# 当函数参数使用 *args 时，Python 会 把多个参数组包成 tuple。 def test(*args): print(args) test(1,2,3). # 输出：(1,2,3)23.列表推导式：使用简洁语法，通过循环 + 表达式 + 可选条件来生成一个新的列表。
基本结构：
[表达式 for 变量 in 可迭代对象] [表达式 for 变量 in 可迭代对象 if 条件] [x for x in range(5)]# [0, 1, 2, 3, 4] [x for x in range(10) if x % 2 == 0]# [0, 2, 4, 6, 8]24.字符串常用方法：
| 方法 | 说明 | 示例 |
|---|---|---|
| upper() | 全部转大写 | "hello".upper() → "HELLO" |
| lower() | 全部转小写 | "HELLO".lower() → "hello" |
| capitalize() | 首字母大写 | "hello".capitalize() → "Hello" |
| title() | 每个单词首字母大写 | "hello world".title() → "Hello World" |
| swapcase() | 大小写互换 | "Hello".swapcase() → "hELLO" |
| 方法 | 说明 |
|---|---|
| find() | 查找字符串，找不到返回 -1 |
| index() | 查找字符串，找不到报错 |
| count() | 统计出现次数 |
| startswith() | 是否以某字符串开头 |
| endswith() | 是否以某字符串结尾 |
| split() | 按分隔符拆分 |
| rsplit() | 从右侧拆分 |
| splitlines() | 按换行拆分 |
| join() | 合并字符串 |
| replace() | 替换字符串 |
| translate() | 字符映射替换 |
| strip() | 去两边空格 |
| lstrip() | 去左边空格 |
| rstrip() | 去右边空格 |
| isdigit() | 是否数字 |
| isalpha() | 是否字母 |
| isalnum() | 是否字母或数字 |
| isspace() | 是否空格 |
| islower() | 是否全小写 |
| isupper() | 是否全大写 |
25.格式化字符串：
format()
name = "Tom" age = 18 print("name:{}, age:{}".format(name, age))f-string（推荐）
name = "Tom" age = 18 print(f"name:{name}, age:{age}")26.元组：可以存储不同的数据类型、元素可以重复、有序、不可以修改（支持索引、切片）
元组名称 =（元素1,元素2,...） 元组名 = tuple([1, 2, 3])注意：单元素元组定义时，需要在末尾加上逗号(’A’,)
说明：在元组解包时使用函数参数解包 **，**代表收集剩余的元素，生成的是一个列表。
27.集合（set）：是一种无序、不重复、可变的数据容器，用于存储唯一元素。
注意：空集合的定义不能使用{},{}是用来定义空字典的；由于集合是无序的，因此不支持下标索引。
注意：集合的元素必须是不可变类型
# 空集合的定义 s = set() # ✅ 正确 s = {} # ❌ 这是空字典常用方法：
| 分类 | 方法 | 作用 | 示例 |
|---|---|---|---|
| 添加 | add(x) | 向集合中添加一个元素 | s1.add('t') |
| 添加 | update(iterable) | 添加多个元素（可迭代对象） | s1.update(['a','b']) |
| 删除 | remove(x) | 删除指定元素（不存在会报错） | s1.remove('a') |
| 删除 | discard(x) | 删除指定元素（不存在不报错） | s1.discard('a') |
| 删除 | pop() | 随机删除并返回一个元素 | s1.pop() |
| 清空 | clear() | 清空集合 | s1.clear() |
| 查找 | in / not in | 判断元素是否存在 | 'a' in s1 |
| 复制 | copy() | 浅拷贝集合 | s2 = s1.copy() |
| 集合运算 | union() / | 并集 | |
| 集合运算 | intersection() / & | 交集 | s1 & s2 |
| 集合运算 | difference() / - | 差集 | s1 - s2 |
| 集合运算 | symmetric_difference() / ^ | 对称差集 | s1 ^ s2 |
| 关系判断 | issubset() | 判断是否为子集 | s1.issubset(s2) |
| 关系判断 | issuperset() | 判断是否为超集 | s1.issuperset(s2) |
| 关系判断 | isdisjoint() | 判断是否无交集 | s1.isdisjoint(s2) |
28.字典（dict）：一种无序、可变、键值对（key:value）存储的数据容器。
特点：键值对（key:value）存储，key 不可重复、可变
注意：key 必须是不可变类型、不可重复，value 可以是任何数据类型的。
注意：字典是没有索引下标的，不能根据索引获取值，只能根据key获取value 逻辑上仍然按“无序容器”理解。
# 空字典的定义 s = dict() s = {}常用方法：
| 分类 | 方法 | 作用 | 示例 |
|---|---|---|---|
| 添加/更新 | update() | 合并字典 | d.update({"a":1}) |
| 获取 | get() | 安全获取值 | d.get("a") |
| 删除 | pop() | 删除并返回值 | d.pop("a") |
| 删除 | popitem() | 删除最后一项 | d.popitem() |
| 遍历 | keys() | 获取所有 key | d.keys() |
| 遍历 | values() | 获取所有 value | d.values() |
| 遍历 | items() | 获取键值对 | d.items() |
| 复制 | copy() | 浅拷贝 | d.copy() |
29.数据容器对比：
| 特性 | 字符串 (str) | 列表 (list) | 元组 (tuple) | 集合 (set) | 字典 (dict) |
|---|---|---|---|---|---|
| 有序性 | 有序 | 有序 | 有序 | 无序 | 有序（Python3.7+） |
| 重复元素 | 允许 | 允许 | 允许 | 不允许 | key不允许重复 |
| 可变性 | 不可变 | 可变 | 不可变 | 可变 | 可变 |
| 索引访问 | 支持 | 支持 | 支持 | 不支持 | 不支持（但支持 key 访问） |
| 切片操作 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 元素类型 | 字符 | 任意 | 任意 | 不可变类型 | key不可变，value任意 |
| 查找效率 | O(n) | O(n) | O(n) | O(1) | O(1) |
| 使用场景 | 文本处理 | 有序集合 | 固定数据 | 去重/查重 | 键值映射 |
30.函数：函数是将一段具有特定功能的代码封装起来，并通过函数名进行调用的代码块。
- 函数需要先定义再执行。
- 函数定义时，内部代码并没有运行，在调用时才执行。
- 函数中通过缩进来描述归属关系关系
基本语法结构：
def 函数名(参数): 函数体 return 返回值| 部分 | 说明 |
|---|---|
| def | 定义函数的关键字 |
| 函数名 | 函数的标识 |
| 参数 | 输入数据（可选） |
| 函数体 | 实现功能的代码 |
| return | 返回结果（可选） |
31.函数参数
- 形参（形式参数）：函数定义时括号里的参数，只能在函数内部使用（局部变量）。
- 实参（实际参数）：函数在实际调用时传递的参数。
- 函数定义时如果有多个参数需要用逗号隔开。
- return 语句只有返回功能，没有输出打印功能，如果要输出需要结合print()函数实现。
- 参数组合使用顺序：**位置参数 → 默认参数 → *args →kwargs
def f(a, b): ... # 位置参数 f(1, 2) # 调用函数时根据函数定义的位置来传递参数，传递顺序要和定义顺序一致。 # 关键字参数 f(a=1, b=2) # 调用函数时根据函数定义时形参名称作为关键字，“键=值”的形式传参，不要求顺序 # 默认参数 def f(a, b=10): # 调用函数时，如果函数没有给参数传值，则参数使用默认值。 ... # 可变参数 def f(*args): # 接收多个位置参数，本质是 tuple（元组） ... def f(**kwargs): # 接收多个关键字参数，本质是 dict（字典） ...可变参数：
# *args（位置可变参数） def f(*args): print(args) f(1, 2, 3) # 输出：(1, 2, 3) # **kwargs（关键字可变参数） def f(**kwargs): print(kwargs) f(a=1, b=2) # {'a': 1, 'b': 2}强制关键字参数:
# 强制 * 后面的参数必须用 key=方式传 def create_user(name, *, age, city): ...参数类型：
普通参数：数字、布尔值、元组、列表、字典、集合等。 特殊参数：函数32.函数注释：
标准Docstring格式如下：
- 功能说明（必须）
- 业务背景 / 实现意图说明（建议）
- 参数说明（必须）
- 返回值说明（必须）
- 异常说明（必须）
- 是否涉及权限、事务、加密等安全操作（视情况）
33.函数的变量作用域：
全局变量：在函数之外定义的变量，称之为全局变量，在整个文件中（包括函数内）都可以使用（通常定义在文件顶部）。
局部变量：在函数内部定义的变量，称之为局部变量，只能在该函数内部使用，外部无法访问。
global：明确告诉python解释器在函数内部使用全局变量，使得可以在函数内部修改全局变量的值。
注意：
- 尽量避免在函数内部使用全局变量。
- 考虑使用函数参数和返回值来传递数据，而不是依赖全局变量。
- global主要用于程序的状态、配置和计数器等场景中。
34.匿名函数(lambda)：是一种没有函数名的简洁函数，通常用于定义简单的一次性函数（单行表达式）。
注意：函数逻辑比较简单（单行表达式）且只在一个地方使用，可以考虑使用匿名函数，简化书写，通常作为高阶函数的参数使用
注意：匿名函数可以返回值也可以不返回值，返回值时不需要return，表达式的值就是它的返回值。
定义：
lambda 参数列表: 函数体 lambda : print('-----') nums = [1, 2, 3] result = list(map(lambda x: x * 2, nums)) # [2, 4, 6]| 特点 | 说明 |
|---|---|
| 无函数名 | 不用 def |
| 单表达式 | 只能写一行逻辑 |
| 自动返回 | 不需要 return |
| 轻量级 | 常用于临时函数 |
35.函数的类型注解：对函数参数和返回值进行类型说明的语法，用于提高代码可读性和可维护性。
def 函数名(参数: 类型) -> 返回类型: ... def add(a: int, b: int) -> int: return a + b容器类型：
# 列表 def f(nums: list[int]) -> list[int]: return nums # 字典 def f(data: dict[str, int]) -> dict[str, int]: return data # 元组 def f() -> tuple[int, str]: return 1, "a" # Optional（可为空） from typing import Optional def f(name: Optional[str]) -> Optional[str]: return name # Union（多种类型） from typing import Union def f(x: Union[int, str]) -> None: ...36.模块（module）：是一个包含 Python 代码的文件（.py），用于组织和复用代码。一个 .py 文件 = 一个模块
模块的核心作用：代码复用、功能划分、避免命名冲突
37.模块的导入
| 导入方式 | 写法 | 调用方式 | 示例 |
|---|---|---|---|
| 标准导入 | import 模块名 | 模块名.函数 | random.randint() |
| 别名导入 | import 模块名 as 别名 | 别名.函数 | rd.randint() |
| 局部导入 | from 模块名 import 函数 | 函数 | randint() |
| 局部别名 | from 模块名 import 函数 as 别名 | 别名 | rint() |
| 全量导入 | from 模块名 import * | 直接用函数 | randint() |
38.自定义模块：自定义模块就是开发者自己编写的 .py 文件，用于封装和复用代码。
# 定义模块 # my_module.py def add(a, b): return a + b def sub(a, b): return a - b # 使用模块 import my_module print(my_module.add(1, 2))- name是 Python 内置变量，表示当前模块的名称
- all_ 用于控制 from xxx import * 时导入哪些内容
| 特性 | name | all |
|---|---|---|
| 类型 | 内置变量 | 可选变量 |
| 作用 | 判断模块执行方式 | 控制 import * |
| 常用程度 | ⭐⭐⭐⭐⭐ | ⭐⭐ |
| 是否必须 | 必须理解 | 很少用 |
39.包（package）：是一个包含多个模块（.py 文件）的目录，用于组织和管理代码。
my_project/ │ ├── utils/ ← 包 │ ├── __init__.py │ ├── math.py │ └── string.py │ ├── services/ ← 包 │ ├── __init__.py │ └── user.py # __init__.py的作用 # 1. 标识该目录为包（旧版本必须） # 2. 初始化包 # 3. 控制导入行为40.模块与包的区别：
| 概念 | 说明 |
|---|---|
| 模块 | 一个 .py 文件 |
| 包 | 一个目录（包含多个模块） |
41.面向对象：面向对象 = 用“类”定义结构，用“对象”承载数据，用“方法”完成行为
面向对象是一种以“对象”为核心，通过类来组织代码的编程思想。
核心概念：
| 概念 | 说明 |
|---|---|
| 类（Class） | 模板/蓝图，定义“这个东西有什么” |
| 对象（Object） | 类的实例，真正的数据载体 |
| 属性（Attribute） | 数据，存数据 |
| 方法（Method） | 行为，操作数据 |
基础示例：
class User: # 类 def __init__(self, name): self.name = name # 属性 def say(self): # 方法 print(self.name) u = User("Tom") # 对象 u.say()构造方法：
def __init__(self, ...): # 作用： # 初始化对象 # 在创建对象时自动执行 # self = 当前对象本身，self 把数据绑定到当前对象面向对象三大特性：封装、继承、多态
self 和 ****init ：
self = 当前对象 # 谁调用，self 就是谁 init 创建对象时自动执行， # 用来初始化属性42.类（class）：用于描述一类事物的结构模板，由属性和方法组成
本质：类 = 属性（数据） + 方法（行为）
语法定义：
class 类名: pass # 创建对象 对象 = 类名() 对象.属性 = 值示例：
class Car: pass c1 = Car() c1.brand = "BMW" c1.name = "X5" c1.price = 500000 # 查看属性 print(c1.__dict__) # 对象的属性本质存储在 __dict__（字典）中 {'brand': 'BMW', 'name': 'X5', 'price': 500000}注意：定义类不推荐使用动态的方法添加属性会导致代码难维护，实际开发应在init中定义。
实际开发类的定义：
class 类名: def __init__(self, 参数列表): self.属性名 = 参数值示例：
class Car: # __init__ 方法是初始化的方法，会在对象创建时自动调用，可以在该方法中为对象设置对应的属性 # self：是第一个参数，表示当前所创建出来的实例对象。 def __init__(self, brand, name, price): self.brand = brand self.name = name self.price = price说明：def 定义在类外面称之为函数，定义在类中的函数称之为方法。
43.实例方法：属于对象的方法，需要通过对象调用，默认第一个参数是 self
语法定义：
class 类名: def __init__(self, 参数列表): self.属性名 = 参数值 def 方法名(self, 参数): ... def 方法名(self, 参数): ... # 创建对象 对象 = 类名(参数列表) 对象.方法名（实参）44.魔法方法：python 中以xxx形式存在的特殊方法，用于让对象支持内置操作（自动调用）
本质：魔法方法 = Python 预定义的“钩子方法”
特点：
- 方法名固定（不能乱写）
- 自动触发（不需要手动调用）
- 让对象“像内置类型一样工作”
常见魔法方法：
| 方法 | 触发方式 |
|---|---|
| init | 创建对象 |
| str | print() |
| repr | 调试输出 |
| len | len() |
| add | + |
| eq | == |
| getitem | obj[] |
| setitem | obj[]= |
| call | obj() |
45.属性：类或对象中用于存储数据的变量
实例属性：实例属性属于每个具体对象的属性，每个对象都是独立的。（各个对象特有的数据）
类属性：类属性属于类本身的属性，所有的实例共享（所有的对象共享的数据或配置）。
| 类型 | 定义位置 | 是否共享 | 修改影响 |
|---|---|---|---|
| 实例属性 | init | 不共享 | 只影响当前对象 |
| 类属性 | 类中 | 共享 | 影响所有对象 |
46.异常（Exception）：程序在运行过程中发生的错误或意外情况
异常的作用：
- 捕获错误
- 防止程序崩溃
- 提高程序稳定性
常见异常示例：
1 / 0 # ZeroDivisionError（除零错误） int("abc") # ValueError（类型转换错误） lst = [1,2] lst[5] # IndexError（索引越界）异常处理（基本结构）：
try: a = int("abc") except ValueError: print("转换失败")完整结构：
try: ... except: ... else: ... finally: ...主动抛出异常：
raise Exception("错误信息")| 结构 | 说明 |
|---|---|
| try | 尝试执行 |
| except | 捕获异常 |
| else | 没有异常时执行 |
| finally | 无论如何都会执行 |
47.异常结构
BaseException │ ├── SystemExit # 退出程序（sys.exit()） ├── KeyboardInterrupt # 用户中断（Ctrl + C） ├── GeneratorExit # 生成器关闭 │ └── Exception # ⭐ 所有业务异常的基类（重点） │ ├── ArithmeticError # 数学运算错误（父类） │ └── ZeroDivisionError # 除零错误 │ ├── LookupError # 查找错误（父类） │ ├── IndexError # 列表/元组索引越界 │ └── KeyError # 字典 key 不存在 │ ├── TypeError # 类型错误（类型不匹配） ├── ValueError # 值错误（值不合法） ├── NameError # 变量未定义 ├── AttributeError # 属性不存在 │ ├── FileNotFoundError # 文件不存在 ├── ImportError # 导入失败 │ └── ModuleNotFoundError # 模块不存在 │ ├── RuntimeError # 运行时错误（状态异常） ├── NotImplementedError # 方法未实现 │ └── AssertionError # 断言失败
