2.9 高级变量
关于 集合（Set）、元组（Tuple）、列表（List）、字典（Dict） 四者之间相互转换的经典案例，通过 list()、tuple()、set()、dict() 四个核心函数实现无缝切换：
| 函数 | 作用 | 输入要求 |
| list() | 转列表（保留顺序，允许重复） | 可迭代对象（如集合、元组、字典键/值） |
| tuple() | 转元组（不可变，保留顺序） | 同 list() |
| set() | 转集合（无序，去重） | 可迭代对象（如列表、元组） |
| dict() | 转字典（需键值对结构） | 键值对组成的可迭代对象（如列表的元组） |
字典转换：dict() 只能处理键值对结构（如 [(k1, v1), (k2, v2)] 或 zip(keys, values)）。
集合去重：转换为集合时，重复元素会被自动过滤。
数据兼容：字典的键必须为不可变类型（如字符串、数字、元组），值可以是任意类型。
"""1. 列表 ↔ 元组 ↔ 集合
a. 列表 → 元组 → 集合"""
print("1. 列表 ↔ 元组 ↔ 集合")
# 变量集合、元组、列表、字典转换示例
# 初始列表（含重复元素）
my_list = [1, 2, 2, 3, 4, 4]# 列表 → 元组（保留顺序，允许重复）
my_tuple = tuple(my_list)
print("元组:", my_tuple) # 输出: (1, 2, 2, 3, 4, 4)# 元组 → 集合（无序、去重）
my_set = set(my_tuple)
print("集合:", my_set) # 输出: {1, 2, 3, 4}# 集合 → 列表（去重后的列表）
new_list = list(my_set)
print("去重列表:", new_list) # 输出: [1, 2, 3, 4]"""b. 集合 → 元组 → 列表"""
# 初始集合
my_set = {5, 6, 7}# 集合 → 元组（无序性保留）
my_tuple = tuple(my_set)
print("元组:", my_tuple) # 输出可能为: (5, 6, 7) 或其他顺序# 元组 → 列表（允许后续修改）
new_list = list(my_tuple)
new_list.append(8)
print("新列表:", new_list) # 输出类似: [5, 6, 7, 8]"""2. 字典 ↔ 列表/元组
a. 字典 → 列表/元组（提取键、值或键值对）"""
print("2. 字典 ↔ 列表/元组")
# 初始字典
my_dict = {"name": "Alice", "age": 25, "city": "New York"}# 提取键的列表
keys_list = list(my_dict.keys())
print("键列表:", keys_list) # 输出: ['name', 'age', 'city']# 提取值的元组
values_tuple = tuple(my_dict.values())
print("值元组:", values_tuple) # 输出: ('Alice', 25, 'New York')# 提取键值对的元组列表
items_list = list(my_dict.items())
print("键值对列表:", items_list)
# 输出: [('name', 'Alice'), ('age', 25), ('city', 'New York')]"""b. 列表/元组 → 字典（需键值对结构）"""
# 方法1：列表/元组元素为键值对元组
pairs = [("a", 1), ("b", 2), ("c", 3)]
new_dict1 = dict(pairs)
print("字典1:", new_dict1) # 输出: {'a': 1, 'b': 2, 'c': 3}# 方法2：两个列表合并为字典（需 zip）
keys = ["x", "y", "z"]
values = [10, 20, 30]
new_dict2 = dict(zip(keys, values)) # 使用zip
print("字典2:", new_dict2) # 输出: {'x': 10, 'y': 20, 'z': 30}"""3. 集合 ↔ 字典（需特殊处理）
a. 集合 → 字典（需构造键值对）"""
print("3. 集合 ↔ 字典（需特殊处理）a. 集合 → 字典（需构造键值对")
# 集合元素作为键，值为默认值
my_set = {"apple", "banana", "cherry"}
default_value = 0
my_dict = {key: default_value for key in my_set}
print("字典:", my_dict) # 输出: {'banana': 0, 'apple': 0, 'cherry': 0}"""b. 字典 → 集合（提取键或值）"""
# 提取键的集合
my_dict = {"a": 1, "b": 2, "c": 3}
keys_set = set(my_dict.keys())
print("键集合:", keys_set) # 输出: {'a', 'b', 'c'}# 提取值的集合
values_set = set(my_dict.values())
print("值集合:", values_set) # 输出: {1, 2, 3}"""4. 混合转换（综合案例"""
print("4. 混合转换（综合案例")
# 初始数据：学生成绩列表（姓名, 分数）
scores_list = [("Alice", 90), ("Bob", 85), ("Charlie", 92)]# 转换为字典（姓名作为键）
scores_dict = dict(scores_list)
print("成绩字典:", scores_dict)
# 输出: {'Alice': 90, 'Bob': 85, 'Charlie': 92}# 提取分数集合（去重）
scores_set = set(score for name, score in scores_list)
print("分数集合:", scores_set) # 输出: {90, 85, 92}# 提取姓名元组
names_tuple = tuple(name for name, score in scores_list)
print("姓名元组:", names_tuple) # 输出: ('Alice', 'Bob', 'Charlie')# 将字典键转换为列表
names_list = list(scores_dict.keys())
print("姓名列表:", names_list) # 输出: ['Alice', 'Bob', 'Charlie']结果：
2.10 列表推导
列表推导类似于循环，对比列表推导式和循环结构。列表推导（List Comprehension）是 Python 中一种简洁高效的语法，用于快速创建列表。
（1）简洁的语法来创建，相比传统的for循环，列表推导通常只需要一行代码就能完成列表的创建，这样代码更简洁，可读性更高。
（2）执行效率可能也是一个优势，列表推导在底层实现上可能比普通的for循环更快，因为它是用C语言实现的，而普通循环是解释执行的
"""1. 代码简洁性：减少冗余代码
传统循环 vs 列表推导式"""# 列表推导式（一行代码）
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print("列表推导式结果:", even_squares)
# 输出: [4, 16, 36, 64, 100]# 传统循环：生成1~10的偶数平方列表
even_squares = []
for x in range(1, 11):if x % 2 == 0:even_squares.append(x**2)
print(even_squares)
# 输出[4, 16, 36, 64, 100]# 列表推导式（一行替代）
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(even_squares)
# 输出[4, 16, 36, 64, 100]""" 2. 执行效率更高,列表推导式在底层实现上经过优化，通常比等效的 for 循环执行更快 """import timeit# 传统循环
time_loop = timeit.timeit('result = []; [result.append(x**2) for x in range(1000) if x%2==0]',number=10000
)# 列表推导式
time_comp = timeit.timeit('[x**2 for x in range(1000) if x%2==0]',number=10000
)print(f"循环耗时: {time_loop:.4f}s") # 示例结果: 0.85s
print(f"推导式耗时: {time_comp:.4f}s") # 示例结果: 0.45s"""3. 可读性强：逻辑一目了然
列表推导式语法结构清晰，将“生成逻辑”集中在一行，便于快速理解意图。"""
words = ["apple", "banana", "cherry", "date"]
# 传统循环
filtered_words = []
for word in words:if len(word) > 5:filtered_words.append(word.upper())# 列表推导式
filtered_words = [word.upper() for word in words if len(word) > 5]"""4. 灵活性：支持复杂逻辑
列表推导式支持多层循环、嵌套条件和表达式，灵活处理多种场景。"""
# 生成坐标点 (x,y)，其中x和y均为偶数
coordinates = [(x, y) for x in range(1, 5) if x % 2 == 0for y in range(1, 5) if y % 2 == 0]
print(coordinates) # 输出: [(2,2), (2,4), (4,2), (4,4)]coordinates = []
for x in range(1, 5):if x % 2 == 0:for y in range(1,5):if y % 2 == 0:coordinates.append((x, y))print(coordinates) # 输出: [(2,2), (2,4), (4,2), (4,4)]"""5. 替代 map 和 filter，代码更 Pythonic
列表推导式可替代 map() 和 filter() 函数，使代码更符合 Python 的简洁风格。"""
# 使用 map 和 filter
numbers = [1, 2, 3, 4, 5]
squared_evens = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)))
print(squared_evens) # 输出:[4, 16]# 列表推导式
squared_evens = [x**2 for x in numbers if x % 2 == 0]
print(squared_evens)
输出结果：
2.11Python数组（array）
Python 中数组（Array）的系统学习指南，涵盖 列表（动态数组）、array 模块数组 和 NumPy 数组的用法，本次主要介绍列表动态数组和array模块数组，NumPy数组将在下一阶段学习中介绍
（1）Python 列表（List）——动态数组
列表是 Python 内置的灵活动态数组，支持任意数据类型，无需预定义长度。
列表动态数组具有动态扩展/收缩、元素类型不限和支持索引、切片。增删改查
# 1. 创建列表
my_list = [1, 2, 3, "apple", True]
print("初始列表:", my_list) # 输出: [1, 2, 3, 'apple', True]# 2. 访问元素
print("第二个元素:", my_list[1]) # 输出: 2
print("倒数第一个元素:", my_list[-1]) # 输出: True# 3. 修改元素
my_list[3] = "banana"
print("修改后列表:", my_list) # 输出: [1, 2, 3, 'banana', True]# 4. 添加元素
my_list.append(4) # 尾部添加
my_list.insert(0, "start") # 插入到索引0
print("添加后列表:", my_list) # 输出: ['start', 1, 2, 3, 'banana', True, 4]# 5. 删除元素
my_list.pop() # 删除最后一个元素
del my_list[0] # 删除索引0的元素
print("删除后列表:", my_list) # 输出: [1, 2, 3, 'banana', True]# 6. 切片操作
sub_list = my_list[1:4] # 索引1到3
print("切片子列表:", sub_list) # 输出: [2, 3, 'banana']结果：
（2）array模块数组（严格类型数组）
array模块提供类型严格限制的数组，元素必须为相同类型，性能优于列表。
其特点是元素类型固定，支持数组基本操作
import array# 1. 创建整型数组（类型码 'i'）
arr = array.array('i', [1, 2, 3, 4, 5])
print("初始数组:", arr) # 输出: array('i', [1, 2, 3, 4, 5])# 2. 访问元素
print("第三个元素:", arr[2]) # 输出: 3# 3. 修改元素
arr[3] = 10
print("修改后数组:", arr) # 输出: array('i', [1, 2, 3, 10, 5])# 4. 添加元素
arr.append(6) # 尾部添加
arr.extend([7, 8]) # 扩展多个元素
print("添加后数组:", arr) # 输出: array('i', [1, 2, 3, 10, 5, 6, 7, 8])# 5. 删除元素
arr.pop() # 删除最后一个元素
arr.remove(10) # 删除值为10的元素
print("删除后数组:", arr) # 输出: array('i', [1, 2, 3, 5, 6, 7])# 6. 类型码参考表
# 'i': 整型, 'f': 浮点型, 'd': 双精度浮点型, 'u': Unicode字符
结果：
（3）NumPy数组（高性能多维度数组）
NumPy 是科学计算的核心库，提供高性能多维数组和向量化运算。
其具有多维数组支持、高效的数值计算、广播机制、矩阵运算与丰富的数学函数库
import numpy as np# 1. 创建一维数组
np_arr = np.array([1, 2, 3, 4])
print("一维数组:", np_arr) # 输出: [1 2 3 4]# 2. 创建二维数组
matrix = np.array([[1, 2], [3, 4], [5, 6]])
print("二维数组:\n", matrix)
# 输出:
# [[1 2]
# [3 4]
# [5 6]]# 3. 访问元素
print("第一行:", matrix[0]) # 输出: [1 2]
print("第二行第一列:", matrix[1, 0]) # 输出: 3# 4. 修改元素
matrix[2, 1] = 10
print("修改后数组:\n", matrix)
# 输出:
# [[ 1 2]
# [ 3 4]
# [ 5 10]]# 5. 数组运算（向量化）
squared = np_arr ** 2
print("平方运算:", squared) # 输出: [ 1 4 9 16]# 6. 广播机制（数组与标量运算）
result = matrix * 2
print("广播乘法:\n", result)
# 输出:
# [[ 2 4]
# [ 6 8]
# [10 20]]# 7. 形状变换
reshaped = matrix.reshape(2, 3)
print("重塑形状:\n", reshaped)
# 输出:
# [[ 1 2 3]
# [ 4 5 10]]# 8. 数学函数
sin_values = np.sin(matrix)
print("正弦值:\n", sin_values)
# 输出（示例）:
# [[ 0.84147098 0.90929743]
# [ 0.14112001 -0.7568025 ]
# [-0.95892427 0.54402111]]
输出结果
 ---- OpenGL-ES Shader语言语法)
