数据容器是存储和管理数据的核心工具，其核心作用是 “批量存储数据”，数据容器包括（列表、元组、字典）。
列表
列表是 Python 最常用的容器，能存储任意类型数据（数字、字符串、甚至其他容器），支持增删改查，适合需要动态调整的数据集。
列表创建方式：
# 空列表 list1 = [] # 普通列表（混合类型） list2 = [1, "Python", True, [2, 3]] # 快速生成列表（range/列表推导式） list3 = list(range(1, 6)) # [1,2,3,4,5] list4 = [x*2 for x in range(3)] # [0,2,4]列表的常用方法：
# append(val)：末尾添加单个元素。 #参数：val（要添加的任意类型元素） list2.append(10) # extend(iterable)：末尾追加可迭代对象（如列表、元组） # 参数：iterable（可迭代对象，元素会被逐个加入列表） list2.extend([6, 7]) # insert(index, val)：指定位置插入元素 # 参数1：index（插入的目标索引，原索引及之后元素后移） # 参数2：val（要插入的任意类型元素） list2.insert(1, "Java") # pop(index)：删除指定索引元素，默认删除最后一个 # 参数：index（可选，要删除的元素索引，默认-1） # 返回值：被删除的元素 deleteVal = list2.pop(0) # remove(val)：删除第一个匹配的元素 # 参数：val（要删除的元素值，需存在于列表中） list2.remove(2) # index(val)：查找元素首次出现的索引 # 参数：val（要查找的元素值，需存在于列表中） # 返回值：元素对应的索引 index1 = list2.index("Python") # sort()：对列表原地排序（修改原列表） # 可选参数：reverse=True/False（默认为True，升序排列，false是降序排列）、 key（排序的依据函数） list3.sort() # sorted()：返回排序后的新列表（不修改原列表） # 参数：iterable（要排序的列表），其他参数同sort() new_sorted_list = sorted(list, reverse=True) # len(list)：获取列表长度 # 参数：list（目标列表） # 返回值：列表中元素的个数 list_length = len(list2)注意：
1. 索引大于列表长度，在使用时会越界产生报错，因此使用索引时需先判断索引范围；
2.嵌套列表可通过多层索引访问，例如：list2[3][1]→ 取子列表 [2,3] 的第二个元素 3。
元组
元组时不可修改的有序集合，也可以说是 “只读版的列表”，一旦创建无法修改元素，性能优于列表，适合存储固定不变的数据（如坐标、函数返回多值）。
创建方式：
# 普通元组 tuple1 = (1, 2, "test") # 空元组 tuple2 = () # 元组中只包含一个元素时必须在后面加逗号，否则会被视为普通变量 tuple3 = (5,) # 正确 tuple4 = (5) # 错误，实际是整数5 # 省略括号（元组打包） （不推荐使用） tuple5 = 10, 20, 30元组的常用方法和函数：
# index(val)：查找元素首次出现的索引 # 参数：val（要查找的元素值，需存在于元组中） # 返回值：元素对应的索引 index_result = tuple1.index(2) # count(val)：统计元素出现的次数 # 参数：val（要统计的元素值） # 返回值：元素在元组中出现的次数 count_result = tuple1.count(1) # len(tuple)：获取元组的长度（元素个数） # 参数：tuple（目标元组） # 返回值：元组的元素数量 tuple_length = len(tuple1) # 解包：将元组元素依次赋值给多个变量 # 规则：变量数量需与元组元素数量一致 a, b, c = tuple1注意：
1.不可修改仅指 “元素本身”（此部分牵扯到数据容器在内存的存储方式）：若元组嵌套列表，列表内部可修改（如t = (1, [2,3]); t[1].append(4)合法）；
2.函数返回多值本质是元组：def func(): return 1,2 → a,b = func()等价于接收元组；
3.元组可作为字典的键（列表不行）：dict_key = {(1,2): "value"}合法。
字典
字典是键值对的无序集合，字典以 “键 - 值（key-value）” 为单位存储数据，键唯一且不可变（字符串 / 数字 / 元组），值可任意修改）。
创建方式：
# 普通字典 dict1 = {"name": "张三", "age": 20, "gender": "男"} # 空字典 dict2 = {} # 字典推导式 dict3 = {x: x*2 for x in range(3)} # {0:0, 1:2, 2:4} # 从键值对列表创建 dict4 = dict([("a", 1), ("b", 2)])常用方法和函数：
# 1. 准备一个示例字典来解释其函数和方法 dict1 = {"name": "张三", "age": 20, "gender": "男"} # 初始字典 # keys()：获取所有键（返回可迭代的dict_keys对象） # 无参数 keys_result = dict1.keys() # 执行后keys_result → dict_keys(['name', 'age', 'gender']) # 可转成列表使用：list(keys_result) → ['name', 'age', 'gender'] # values()：获取所有值（返回可迭代的dict_values对象） # 无参数 values_result = dict1.values() # 执行后values_result → dict_values(['张三', 20, '男']) # items()：获取所有键值对（返回包含(key,value)元组的可迭代对象） # 无参数 items_result = dict1.items() # 执行后items_result → dict_items([('name', '张三'), ('age', 20), ('gender', '男')]) # keys、values、items常用于遍历中： for key in dict1.keys(): print(key) for value in dict1.values(): print(value) for k, v in dict1.items(): print(f"{k}: {v}") # get(key, 默认值)：获取指定键的值，键不存在时返回默认值 # 参数1：key（要查找的键） # 参数2：默认值（可选，键不存在时返回，默认None） height = dict1.get("height", 170) # 执行后height → 170（因为dict1中无"height"键，返回默认值170） # pop(key)：删除指定键，并返回对应的值 # 参数：key（要删除的键，需存在于字典中） # 返回值：被删除键对应的value pop_value = dict1.pop("age") # 执行后dict1 → {"name": "张三", "gender": "男"}，pop_value → 20 # update(dict)：批量更新/添加键值对 # 参数：dict（包含要更新/添加的键值对的字典） dict1.update({"age": 21, "city": "北京"}) # 执行后dict1 → {"name": "张三", "gender": "男", "age": 21, "city": "北京"} # len(dict)：获取字典中键值对的数量 # 参数：目标字典 length = len(dict1) # 执行后length → 4（当前dict1有4个键值对）注意：
1.键必须是唯一的，重复定义键会产生覆盖（如{"a":1, "a":2}最终是{"a":2}）；
2.键是不可变的，且列表不能作为键，因为列表是可变的，元组可以；
3.字典是无序的：不依赖索引顺序来进行查找，按键查找才是最快最便捷的方式。
列表、元组、字典的对比：
函数
函数是将 “特定逻辑” 封装成独立模块，实现代码复用、降低冗余的核心机制，核心是 “定义 - 调用” 的闭环。
其中涉及的一些概念：
封装：将一段重复执行的代码包裹成函数，调用时只需写函数名，无需重复写代码；
形参：函数定义时的参数（占位符），如def add(a, b)中的 a、b；
实参：函数调用时传入的具体值，如add(1,2)中的 1、2；
返回值：函数执行后输出的结果（通过return关键字），无 return 则返回None。
函数的定义与调用
# 定义函数： def 函数名(形参): 逻辑体 return def add(a, b): #两数相加 result = a + b return result # 返回计算结果 # 调用函数：函数名(实参) res = add(3, 5) # 实参3、5传给形参a、b，res接收返回值8 print(res) # 输出8函数的参数传递
1.位置参数（默认）
按 “形参定义顺序” 传入实参，顺序错误会导致结果异常，即函数可以有多个参数，每个参数之间用逗号‘，’隔开，这些参数在调用传入实参时会被位置参数按顺序接收。
2.关键字参数
按 “键 = 值” 形式传参，无需关注顺序，可读性更高，直接使用 ‘形参名字=实参’ 进行传参。
3.可变参数，也叫不定长参数
*args：接收任意数量的位置参数，打包成元组；
**kwargs：接收任意数量的关键字参数，打包成字典；
#不定长参数，会将接收到的参数打包成元组使用 def sum_all(*args): total = 0 for num in args: total += num return total print(sum_all(1,2,3)) # 输出6，args=(1,2,3) #不定长关键字参数，将接收到的参数打包成字典使用 def print_kwargs(**kwargs): for k, v in kwargs.items(): print(f"{k}: {v}") print_kwargs(name="赵六", city="上海") # kwargs={"name":"赵六","city":"上海"}函数嵌套
函数内部可定义 / 调用另一个函数，内层函数可访问外层函数的变量（闭包基础）。
def outer_func(a): # 内层函数 def inner_func(b): return a + b # 访问外层函数的变量a # 调用内层函数 return inner_func(5) print(outer_func(3)) # 输出8：3+5注意：
1.函数内部定义的变量默认是 “局部变量”，仅在函数内生效；如需使用全局变量，需加global进行声明；
2.函数也可作为参数传递，可传给其他函数；
3.一定避免重复定义函数，同名函数会覆盖之前的定义，需注意命名唯一性。并且尽量将函数的名字命名得和功能有联系。
