二、Python变量基础（2）

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]]

输出结果