软工计算1作业hw4,lab04,proj1,proj2的笔记 20240417

1.python 中的zip函数

Python 中的 zip 函数是一个非常有用的内置函数，它用于将多个可迭代对象（如列表、元组等）的元素配对，然后返回一个由这些配对元素组成的元组的列表。简单来说，zip 可以把多个序列“压缩”成一个序列的序列。

语法

zip(iterable, ...)

参数

• iterable: 一个或多个可迭代对象。

返回值

zip 函数返回一个 zip 对象，它是一个迭代器。这个迭代器提供了一个简便的方法来获取元组列表，其中每个元组包含来自每个可迭代对象的下一个元素。

使用示例

示例 1：简单的配对

a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9]

zipped = zip(a, b, c)
print(list(zipped))  # 输出: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

示例 2：不同长度的可迭代对象

如果提供的可迭代对象长度不同，zip 会根据最短的可迭代对象长度停止生成元组。

a = [1, 2, 3]
b = [4, 5]

zipped = zip(a, b)
print(list(zipped))  # 输出: [(1, 4), (2, 5)]

示例 3：解包

zip 通常与解包一起使用，可以方便地将配对的元素分别赋值给不同的变量。

a = [1, 2, 3]
b = [4, 5, 6]

for one, two in zip(a, b):
    print(one, two)
# 输出:
# 1 4
# 2 5
# 3 6

示例 4：使用 * 运算符

* 运算符可以用于解包 zip 对象，将配对的元素分别赋值给多个变量。

a = [1, 2, 3]
b = [4, 5, 6]

for one, two in zip(a, b):
    print(one, two)

# 也可以这样写：
for *pair, (one, two) in zip(*[iter(list(zipped))]*2):
    print(one, two)

zip 对象本身是可迭代的，但通常我们会将其转换为列表或其他形式以便于使用。如果不需要迭代多次，直接使用 zip 对象也是可行的。

使用范例：
在Python中，return [[i, j] for i, j in zip(lst1, lst2)] 这行代码使用了列表推导式（list comprehension）来创建一个新的列表，这个列表由一些子列表组成。每个子列表包含两个元素，分别来自两个不同的列表 lst1 和 lst2。

解释

• [[i, j] for i, j in zip(lst1, lst2)]：这是一个列表推导式，它遍历由 zip(lst1, lst2) 生成的元组序列。
• zip(lst1, lst2)：zip 函数将 lst1 和 lst2 的元素配对，生成一个元组序列。如果 lst1 和 lst2 的长度不同，zip 会停止在最短的列表结束时。
• for i, j in zip(lst1, lst2)：这是一个循环，它遍历 zip 函数生成的元组序列。每个元组包含两个元素，分别赋值给变量 i 和 j。i 来自 lst1，j 来自 lst2。
• [[i, j]]：对于每个元组，列表推导式创建一个新的子列表，包含 i 和 j 这两个元素。

例子

假设我们有两个列表 lst1 和 lst2，它们的内容如下：

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]

执行 return [[i, j] for i, j in zip(lst1, lst2)] 将产生以下结果：

[[1, 4], [2, 5], [3, 6]]

这个结果是一个列表，包含三个子列表。每个子列表都包含了 lst1 和 lst2 中对应位置的元素。

应用场景

这种列表推导式通常用于需要将两个或多个序列中的元素进行配对处理的情况。例如，当你需要将两个列表中的相同位置的元素组合起来进行某种计算或比较时，就可以使用这种方法。

return [[i, j] for i, j in zip(lst1, lst2)] 和 return zip(lst1, lst2) 这两行代码都使用了 zip 函数，但它们的返回值和使用方式有所不同：

return [[i, j] for i, j in zip(lst1, lst2)]

这行代码使用了列表推导式，它遍历 zip(lst1, lst2) 生成的元组序列，并为每一对元素创建一个新的列表（即子列表）。这个子列表包含两个元素，分别是来自 lst1 和 lst2 的对应元素。最终，这个表达式返回的是一个列表，其中包含了所有这些子列表。

示例：

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
result = [[i, j] for i, j in zip(lst1, lst2)]
print(result)  # 输出: [[1, 4], [2, 5], [3, 6]]

return zip(lst1, lst2)

这行代码直接返回了 zip 函数的结果，即一个 zip 对象。zip 对象是一个迭代器，它按顺序提供来自多个可迭代对象的元素组合。当你对这个迭代器进行迭代时，它会逐个提供包含所有可迭代对象中下一个元素的元组。

示例：

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
result = zip(lst1, lst2)
print(list(result))  # 输出: [(1, 4), (2, 5), (3, 6)]

return [[i, j] for i, j in zip(lst1, lst2)]和return zip(lst1,lst2)的主要区别

1. 返回类型：

   • 使用列表推导式 [[i, j] for i, j in zip(lst1, lst2)] 返回的是一个列表（List），列表中的每个元素是一个包含两个元素的子列表。
   • 直接使用 zip(lst1, lst2) 返回的是一个 zip 对象，它是一个迭代器（Iterator）。

2. 内存使用：

   • 列表推导式会立即创建一个包含所有配对元素的新列表，这可能会消耗更多的内存，特别是当处理大量数据时。
   • zip 对象则是一种惰性（lazy）计算方式，它只在需要时生成元组，因此对内存的使用更加高效。

3. 使用场景：

   • 如果你需要一个实际的列表来存储配对的元素，或者你需要多次访问这些配对的元素，使用列表推导式可能更合适。
   • 如果你只需要迭代一次这些配对的元素，或者你想要节省内存，直接使用 zip 对象可能更合适。

4. 可读性：

   • 列表推导式通常被认为在代码可读性方面更直观，因为它直接创建了一个列表。
   • zip 对象则可能需要额外的解释，特别是对于那些不熟悉迭代器和惰性计算概念的开发者。

选择使用哪一种方式取决于你的具体需求和偏好。