python如何合并不等长的数组

Python 合并不等长的数组的方法包括使用itertools.zip_longest、使用pandas、使用NumPy等。其中，itertools.zip_longest 是最常用的方法之一，因为它能处理不等长的数组并填充缺失值。

一、使用itertools.zip_longest

itertools.zip_longest 是 Python 标准库中的一个工具，专门用于处理不等长的可迭代对象。它可以将短的可迭代对象用填充值补齐，从而生成长度相同的迭代器。

from itertools import zip_longest
array1 = [1, 2, 3]
array2 = [4, 5, 6, 7, 8]
merged = list(zip_longest(array1, array2, fillvalue=None))
print(merged)

在上面的代码中，我们使用 zip_longest 将两个不等长的数组合并，并将较短数组的缺失部分用 None 填充。结果是一个包含元组的列表，每个元组包含来自两个数组的相应元素。

二、使用pandas

pandas 是一个强大的数据处理库，尤其擅长处理表格数据。通过将数组转换为 DataFrame，可以轻松处理不等长数组的合并。

import pandas as pd
array1 = [1, 2, 3]
array2 = [4, 5, 6, 7, 8]
df = pd.DataFrame({'col1': pd.Series(array1), 'col2': pd.Series(array2)})
print(df)

在这个示例中，我们将两个数组转换为 Series，并通过字典传递给 DataFrame 构造函数。pandas 会自动对齐长度，并用 NaN 填充缺失值。

三、使用NumPy

NumPy 是一个科学计算库，提供了丰富的数组操作功能。虽然 NumPy 数组需要相同的长度，但可以通过对象数组来处理不等长数组。

import numpy as np
array1 = np.array([1, 2, 3], dtype=object)
array2 = np.array([4, 5, 6, 7, 8], dtype=object)
merged = np.empty((2, max(len(array1), len(array2))), dtype=object)
merged[0, :len(array1)] = array1
merged[1, :len(array2)] = array2
print(merged)

在这个示例中，我们创建了一个空的对象数组，并分别将两个不等长的数组填充到其中。这样可以保留原数组的长度信息。

四、使用自定义函数

有时，使用内置函数可能无法满足特定需求，可以编写自定义函数来处理不等长数组的合并。

def merge_arrays(*arrays, fillvalue=None):
    max_len = max(len(arr) for arr in arrays)
    merged = []
    for i in range(max_len):
        merged.append([arr[i] if i < len(arr) else fillvalue for arr in arrays])
    return merged
array1 = [1, 2, 3]
array2 = [4, 5, 6, 7, 8]
array3 = [9, 10]
merged = merge_arrays(array1, array2, array3, fillvalue=0)
print(merged)

在这个示例中，我们编写了一个名为 merge_arrays 的函数，它接受多个数组作为输入，并使用 fillvalue 参数填充缺失值。该函数首先计算所有输入数组的最大长度，然后在每个位置创建包含相应元素的列表。

五、使用内置的列表推导式

列表推导式是一种简洁的列表创建方式，可以用于处理不等长数组的合并。

array1 = [1, 2, 3]
array2 = [4, 5, 6, 7, 8]
merged = [[array1[i] if i < len(array1) else None, array2[i] if i < len(array2) else None] for i in range(max(len(array1), len(array2)))]
print(merged)

在这个示例中，我们使用列表推导式生成一个包含元组的列表，每个元组包含来自两个数组的相应元素，并用 None 填充较短数组的缺失部分。

六、使用itertools.chain

itertools.chain 是一个强大的工具，可以将多个可迭代对象连接成一个长的可迭代对象。虽然它不直接处理不等长数组的合并，但可以用于预处理数组。

from itertools import chain
array1 = [1, 2, 3]
array2 = [4, 5, 6, 7, 8]
merged = list(chain(array1, array2))
print(merged)

在这个示例中，我们将两个数组连接成一个长的数组，虽然没有处理不等长数组的对齐问题，但对于某些应用场景可能是一个合适的选择。

七、使用map和zip

map 和 zip 是 Python 内置的高阶函数，可以用于处理不等长数组的合并。

array1 = [1, 2, 3]
array2 = [4, 5, 6, 7, 8]
merged = list(map(lambda x, y: (x, y), array1 + [None] * (len(array2) - len(array1)), array2))
print(merged)

在这个示例中，我们使用 map 和 zip 函数将两个数组合并，并用 None 填充较短数组的缺失部分。

八、使用循环和条件语句

循环和条件语句是最基本的编程结构，可以用于手动处理不等长数组的合并。

array1 = [1, 2, 3]
array2 = [4, 5, 6, 7, 8]
merged = []
for i in range(max(len(array1), len(array2))):
    elem1 = array1[i] if i < len(array1) else None
    elem2 = array2[i] if i < len(array2) else None
    merged.append((elem1, elem2))
print(merged)

在这个示例中，我们使用循环和条件语句逐个处理数组元素，并用 None 填充较短数组的缺失部分。

九、使用functools.reduce

functools.reduce 是一个强大的工具，用于对序列执行累积操作。虽然它不直接用于不等长数组的合并，但可以用于预处理数组。

from functools import reduce
array1 = [1, 2, 3]
array2 = [4, 5, 6, 7, 8]
merged = reduce(lambda acc, elem: acc + [elem], array1 + array2, [])
print(merged)

在这个示例中，我们使用 reduce 函数将两个数组连接成一个长的数组，虽然没有处理不等长数组的对齐问题，但对于某些应用场景可能是一个合适的选择。

十、使用collections.deque

collections.deque 是一个双端队列，可以用于处理不等长数组的合并。

from collections import deque
array1 = deque([1, 2, 3])
array2 = deque([4, 5, 6, 7, 8])
max_len = max(len(array1), len(array2))
merged = []
for _ in range(max_len):
    elem1 = array1.popleft() if array1 else None
    elem2 = array2.popleft() if array2 else None
    merged.append((elem1, elem2))
print(merged)