python学习之zip（）和map（）

一、zip

`zip()` 是Python中的一个内置函数，它用于将多个可迭代对象（如列表、元组、字符串等）中对应的元素打包成一个个元组，然后返回由这些元组组成的迭代器。简单来说，`zip()` 可以把多个序列中的元素配对。

### 函数定义：

```python
zip(*iterables)
```

- `*iterables`：一个或多个可迭代对象。

### 返回值：

- 返回一个迭代器`Zip`，它生成元组，每个元组包含来自每个可迭代对象的元素。

### 使用示例：

#### 示例 1：基本使用

```python
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：使用不同长度的可迭代对象

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

# 较短的可迭代对象耗尽后，不再产生新的元组
zipped = zip(a, b)
print(list(zipped))  # 输出: [(1, 4), (2, 5)]
```

#### 示例 3：解压缩

```python
zipped = [(1, 'a'), (2, 'b'), (3, 'c')]

# 可以使用 * 来解压缩
unzipped = zip(*zipped)
print(list(unzipped))  # 输出: [(1, 2, 3), ('a', 'b', 'c')]
```

#### 示例 4：与 `map()` 结合使用

```python
numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)

# 同时迭代原始列表和平方列表
print(list(zip(numbers, squared)))  # 输出: [(1, 1), (2, 4), (3, 9), (4, 16)]
```

#### 示例 5：使用 `itertools.zip_longest`

在`itertools`模块中有一个`zip_longest`函数，它类似于`zip`，但可以处理可迭代对象长度不同的情况：

```python
from itertools import zip_longest

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

zipped = zip_longest(a, b, fillvalue='missing')
print(list(zipped))  # 输出: [(1, 4), (2, 5), (3, 6), (None, 7)]
```

`zip()` 函数非常有用，特别是在需要并行迭代多个序列时。它简洁地实现了元素的配对，减少了编写循环和索引的需要。此外，`zip()` 与列表推导式、`map()` 等结合使用可以编写出非常清晰和高效的代码。

二、map（）

`map()` 是Python中的一个内置函数，它用于将一个给定的函数应用于可迭代对象（如列表、元组、字符串等）的每个元素，返回一个由这些函数调用结果组成的迭代器。

### 函数定义：

```python
map(function, *iterables)
```

- `function`：这是要应用于每个元素的函数或可调用对象。
- `*iterables`：这是一个或多个可迭代对象，它们的元素将被传递给函数。

### 返回值：

- 返回一个迭代器`Map`，它生成从可迭代对象中提取的元素经过 `function` 处理后的结果。

### 使用示例：

#### 示例 1：基本使用

```python
numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared))  # 输出: [1, 4, 9, 16]

print(squared)#输出：<map object at 0x0000020C35A99E08>

```

#### 示例 2：使用内置函数

```python
words = ['  hello', 'world  ', ' python']
stripped = map(str.strip, words)
print(list(stripped))  # 输出: ['hello', 'world', 'python']
```

#### 示例 3：并行迭代多个序列

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

# 将两个序列中的元素相加
sums = map(lambda x, y: x + y, a, b)
print(list(sums))  # 输出: [5, 7, 9]
```

#### 示例 4：使用 `map()` 和 `zip()`

```python
pairs = [(1, 'a'), (2, 'b'), (3, 'c')]

# 使用 zip(*pairs) 来解包每个元组中的元素，使其成为 lambda 函数的参数
sums = map(lambda x, y: x + len(str(y)), *zip(*pairs))

print(list(sums))  # 输出: [2, 4, 5]
```

这里的 `zip(*pairs)` 将 `pairs` 列表中的元组解包，创建一个新的迭代器，其中包含元组中对应的元素。然后，我们将这个迭代器解包（使用星号 `*`），作为参数传递给 `lambda` 函数。

- `zip(*pairs)` 的效果是将 `pairs` 中的元组转换为一个迭代器，其中包含 `(1, 2, 3)` 和 `('a', 'b', 'c')`。
- `map()` 函数随后将这些序列作为参数传递给 `lambda` 函数，`lambda x, y: x + len(str(y))` 计算每个整数和对应字符的长度之和。

这样，`map()` 函数和 `lambda` 表达式就可以正确地为每个元组生成期望的和了。
 

### 注意事项：

- `map()` 总是返回一个迭代器，如果你需要列表，可以使用 `list()` 来转换。
- `map()` 可以与 lambda 匿名函数结合使用，以便在不定义显式函数的情况下快速应用简单的函数。
- 当映射的函数需要多个参数时，`map()` 可以与 `zip()` 结合使用，以并行迭代多个序列。
- `map()` 是一个惰性操作（lazy operation），即它不会立即计算结果，而是在迭代时才计算。

`map()` 函数是函数式编程范式的一部分，它提供了一种优雅且Pythonic的方式来处理数据集合的转换。