【2】数据结构·序列构成的数组

存储方式分类：容器 vs. 扁平

这种分类依据序列中存储的是对象本身还是对象的引用 A. 📦 容器序列 (Container Sequences) 特点： 存储的是它们包含的对象的引用（即内存地址）。

内容： 序列中的每一项都可以是不同类型的 Python 对象。

主要类型：

列表 (List)：[1, 'a', (3, 4)]

元组 (Tuple)：(1, 'a', [3, 4])

队列 (collections.deque)

总结： 它们是异构（heterogeneous）的，负责管理其内部元素的生命周期。

B. 🧱 扁平序列 (Flat Sequences) 特点： 存储的是值本身，而不是对象的引用。它们在内存中是连续的一块区域。

内容： 序列中的每一项必须是同一种基本类型（如字符、字节或整数）。

主要类型：

字符串 (str)：存储字符码位（Unicode code points）。

字节串 (bytes) 和 字节数组 (bytearray)：存储字节。

数组 (array.array)：存储基本数值类型（如 C 语言的 int、float）。

总结： 它们是同构（homogeneous）的，存储效率更高，特别是对于大量的基本类型数据。

2. 可变性分类：可变 vs. 不可变 这种分类依据序列的内容在创建后是否可以被修改。

A. 🛠️ 可变序列 (Mutable Sequences) 特点： 序列创建后，您可以修改、添加或删除其元素，而其 ID（内存地址）保持不变。

主要类型：

列表 (List)

字节数组 (bytearray)

数组 (array.array)

队列 (collections.deque)

B. 🔒 不可变序列 (Immutable Sequences) 特点： 序列创建后，它的内容不能被修改。任何看似"修改"的操作（如字符串连接）实际上都会创建并返回一个新的序列对象。

主要类型：

字符串 (str)

元组 (Tuple)

字节串 (bytes)

列表推导

用一行代码代替多行 for 循环和 if 条件语句，使代码更具可读性和性能优势。

2. 带有过滤条件（使用 if）

列表推导（List Comprehension）本质上就是把一个完整的循环和条件判断逻辑，以一种更加紧凑和声明式的方式，内嵌到列表的创建过程中

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 期望结果：[4, 16, 36, 64, 100]
## 🚀 列表推导 (List Comprehension)
squared_evens_lc = [
    n ** 2              # 表达式：执行平方操作
    for n in data        # 循环：遍历数据
    if n % 2 == 0        # 条件：筛选出偶数
]

print(f"列表推导结果: {squared_evens_lc}")
# 输出: 列表推导结果: [4, 16, 36, 64, 100]

map / filter 组合实现

## 🧩 map / filter 组合
# 1. 定义过滤函数（或使用 lambda）
def is_even(n):
    return n % 2 == 0

# 2. 定义转换函数（或使用 lambda）
def square(n):
    return n ** 2

# 3. 组合：先过滤，后映射
# filter_result 是一个 filter 对象，它包含所有的偶数
filter_result = filter(is_even, data)

# map_result 是一个 map 对象，它包含所有偶数的平方
map_result = map(square, filter_result)

# 最终转换为列表
squared_evens_mf = list(map_result)

print(f"map/filter 结果: {squared_evens_mf}")
# 输出: map/filter 结果: [4, 16, 36, 64, 100]

简化版（使用 Lambda 函数）

squared_evens_mf_lambda = list(
    map(lambda n: n ** 2,              # 映射操作 (转换)
        filter(lambda n: n % 2 == 0,   # 过滤操作 (筛选)
               data)))

print(f"map/filter (Lambda) 结果: {squared_evens_mf_lambda}")
# 输出: map/filter (Lambda) 结果: [4, 16, 36, 64, 100]

filter() 的主要作用，正如它的名字所示，就是用来过滤（筛选）序列或可迭代对象中的元素，只保留那些满足特定条件的元素。

它会返回一个迭代器 (iterator)，其中只包含通过筛选的元素。 filter() 函数需要两个参数：

filter(function,iterable) function (函数)： 这是一个接受一个参数（序列中的元素）并返回布尔值（True 或 False）的函数。

iterable (可迭代对象)： 任何可迭代对象，比如列表、元组、集合、字符串等。

工作原理： filter() 会依次将 iterable 中的每个元素传递给 function 进行判断：

如果 function 返回 True，则该元素保留在 filter 的结果中。

如果 function 返回 False，则该元素被丢弃。

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 1. 定义一个用于筛选的函数
def is_odd(number):
    """如果数字是奇数则返回 True"""
    return number % 2 != 0

# 2. 使用 filter() 进行过滤
# filter_iterator 是一个 filter 对象，需要用 list() 转换才能看到结果
filter_iterator = filter(is_odd, data)

# 3. 打印最终结果
odd_numbers = list(filter_iterator)

print(f"原始数据: {data}")
print(f"筛选结果: {odd_numbers}")
# 输出: 筛选结果: [1, 3, 5, 7, 9]

map() 的核心作用是进行批量转换（映射）：它将一个指定的函数应用到序列或可迭代对象的所有元素上，并返回一个包含转换结果的迭代器。 map() 函数至少需要两个参数：

map(function,iterable,[iterable 2 ​ ,...]) function (函数)： 这是一个接受一个或多个参数（对应可迭代对象中的元素）并返回转换后结果的函数。

iterable (可迭代对象)： 任何可迭代对象，如列表、元组、范围等。

可选的其它可迭代对象： 如果提供了多个可迭代对象，function 必须能接受相应数量的参数。

工作原理： map() 会依次从 iterable 中取出一个元素，将其传递给 function，然后将 function 的返回值作为结果序列中的新元素。

data = [1, 2, 3, 4, 5]

# 1. 定义一个用于转换的函数
def multiply_by_ten(n):
    return n * 10

# 2. 使用 map() 应用转换
map_iterator = map(multiply_by_ten, data)

# 3. 转换为列表查看结果
result = list(map_iterator)

print(f"原始数据: {data}")
print(f"转换结果: {result}")
# 输出: 转换结果: [10, 20, 30, 40, 50]

list_a = [1, 2, 3]
list_b = [10, 20, 30]

# map 将 zip 行为内嵌：将 list_a[i] 和 list_b[i] 分别作为参数传给 lambda
sum_lists = list(map(lambda x, y: x + y, list_a, list_b))

print(f"列表 A: {list_a}")
print(f"列表 B: {list_b}")
print(f"相加结果: {sum_lists}")
# 输出: 相加结果: [11, 22, 33]

特性 map(func, iterable) 列表推导 [expr for x in iter] 可读性 偏向函数式风格，需要定义外部函数或 lambda。 更具 Pythonic 风格，逻辑集中在一行。 功能 只能转换元素。 可以先过滤（使用 if），再对保留的元素进行转换。 返回值 返回一个迭代器（延迟计算，节省内存）。 直接返回一个完整的列表（立即计算）。

result_lc = [n * 10 for n in data]
# 输出: [10, 20, 30, 40, 50]

笛卡尔积（Cartesian Product）是一个源于数学集合论的概念，但在计算机科学和编程（尤其是数据库和多重循环）中有着非常重要的应用。

简单来说，两个集合 A 和 B 的笛卡尔积，记作 A×B，是所有可能的有序对 (a,b) 的集合，其中第一个元素 a 来自集合 A，第二个元素 b 来自集合 B。 使用嵌套循环来遍历两个或多个列表时，您实际上就是在生成它们的笛卡尔积

colors = ['red', 'blue']
sizes = ['S', 'M', 'L']

# 嵌套循环生成笛卡尔积
products = []
for color in colors:
    for size in sizes:
        products.append((color, size))

# products: [('red', 'S'), ('red', 'M'), ('red', 'L'), ('blue', 'S'), ('blue', 'M'), ('blue', 'L')]

列表推导

# 列表推导实现笛卡尔积
products_lc = [(color, size) for color in colors for size in sizes]