Python NumPy - 数组的分割 split 函数拆分数组

👋 大家好，欢迎来到我的技术博客！ 📚 在这里，我会分享学习笔记、实战经验与技术思考，力求用简单的方式讲清楚复杂的问题。 🎯 本文将围绕NumPy这个话题展开，希望能为你带来一些启发或实用的参考。 🌱 无论你是刚入门的新手，还是正在进阶的开发者，希望你都能有所收获！

文章目录

• Python NumPy – 数组的分割 split 函数拆分数组 🧮
• • 🔍 什么是数组分割？
  • 📚 基础分割函数
  • • array_split() 函数
    • split() 函数
    • hsplit() 和 vsplit() 函数
  • 🎯 高级分割技巧
  • • 指定分割位置
    • 多维数组的复杂分割
  • 🔄 实际应用场景
  • • 数据批处理
    • 图像处理中的切片
  • 📊 性能优化技巧
  • • 内存友好的分割
  • 🎨 可视化分割过程
  • 🔧 错误处理和最佳实践
  • • 异常处理
    • 性能比较
  • 🌟 特殊分割场景
  • • 条件分割
    • 时间序列分割
  • 🧩 复杂数据结构分割
  • 🎪 自定义分割函数
  • 📈 分割结果验证
  • 🔗 相关资源推荐
  • 🧠 最佳实践总结
  • • 选择合适的分割函数
    • 注意事项
    • 性能优化建议
  • 🎯 实际应用案例
  • 🏁 总结

Python NumPy – 数组的分割 split 函数拆分数组 🧮

在数据科学和机器学习的世界中，NumPy 作为 Python 最重要的科学计算库之一，为我们提供了强大的数组操作功能。其中，数组的分割操作是日常开发中经常遇到的需求。今天，我们将深入探讨 NumPy 中的各种分割函数，帮助你掌握如何高效地拆分数组。

🔍 什么是数组分割？

数组分割是指将一个大的数组按照特定规则拆分成多个较小的子数组的过程。这在处理大型数据集、并行计算、数据预处理等场景中非常有用。NumPy 提供了多种分割函数来满足不同的需求。

📚 基础分割函数

array_split() 函数

array_split() 是最通用的分割函数，它允许我们将数组分割成指定数量的子数组。

import numpy as np

# 创建一个一维数组
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print("原始数组:", arr)

# 将数组分割成3个子数组
result = np.array_split(arr, 3)
print("分割结果:")
for i, sub_arr in enumerate(result):
print(f"子数组 {i+1}: {sub_arr}")

需要注意的是，当数组长度不能被分割数量整除时，array_split() 会尽可能均匀地分配元素。

split() 函数

split() 函数与 array_split() 类似，但它要求分割点必须能够整除原数组：

# 创建一个可以整除的数组
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])

# 使用 split 分割成4个相等的部分
try:
result = np.split(arr, 4)
print("使用 split 分割成功:")
for i, sub_arr in enumerate(result):
print(f"子数组 {i+1}: {sub_arr}")
except ValueError as e:
print(f"分割失败: {e}")

# 尝试用 split 分割不能整除的情况
arr2 = np.array([1, 2, 3, 4, 5, 6, 7])
try:
result = np.split(arr2, 3)
except ValueError as e:
print(f"分割失败: {e}")

hsplit() 和 vsplit() 函数

对于二维数组，我们还有更专门的水平分割和垂直分割函数：

# 创建一个二维数组
arr_2d = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
print("原始二维数组:")
print(arr_2d)

# 水平分割 (按列分割)
h_result = np.hsplit(arr_2d, 2)
print("\\n水平分割结果:")
for i, sub_arr in enumerate(h_result):
print(f"水平子数组 {i+1}:")
print(sub_arr)

# 垂直分割 (按行分割)
v_result = np.vsplit(arr_2d, 3)
print("\\n垂直分割结果:")
for i, sub_arr in enumerate(v_result):
print(f"垂直子数组 {i+1}:")
print(sub_arr)

🎯 高级分割技巧

指定分割位置

除了指定分割的数量，我们还可以直接指定分割的位置：

# 创建一个较大的数组
arr = np.arange(1, 11) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("原始数组:", arr)

# 在指定位置分割
indices = [2, 5, 8]
result = np.split(arr, indices)
print("在指定位置分割:")
for i, sub_arr in enumerate(result):
print(f"子数组 {i+1}: {sub_arr}")

多维数组的复杂分割

对于多维数组，我们可以进行更加复杂的分割操作：

# 创建一个三维数组
arr_3d = np.random.randint(1, 10, (2, 3, 4))
print("三维数组形状:", arr_3d.shape)
print("三维数组内容:")
print(arr_3d)

# 沿着不同轴进行分割
# axis=0 表示沿着第一个维度分割
split_axis0 = np.array_split(arr_3d, 2, axis=0)
print(f"\\n沿 axis=0 分割后的子数组数量: {len(split_axis0)}")
print("第一个子数组形状:", split_axis0[0].shape)

# axis=1 表示沿着第二个维度分割
split_axis1 = np.array_split(arr_3d, 3, axis=1)
print(f"\\n沿 axis=1 分割后的子数组数量: {len(split_axis1)}")
print("第一个子数组形状:", split_axis1[0].shape)

🔄 实际应用场景

让我们通过一些实际的例子来看看数组分割的强大之处：

数据批处理

在机器学习中，我们经常需要将大数据集分割成小批次进行训练：

# 模拟训练数据
train_data = np.random.rand(1000, 10) # 1000个样本，每个样本10个特征
batch_size = 32

# 将数据分割成批次
batches = np.array_split(train_data, len(train_data) // batch_size)
print(f"总共有 {len(batches)} 个批次")

# 查看前几个批次的信息
for i, batch in enumerate(batches[:3]):
print(f"批次 {i+1} 形状: {batch.shape}")

# 处理最后一个可能较小的批次
if len(train_data) % batch_size != 0:
print(f"最后一个批次大小: {batches[–1].shape[0]}")

图像处理中的切片

在图像处理中，我们可能需要将大图像分割成小块进行处理：

# 模拟一张 8×8 的灰度图像
image = np.random.randint(0, 256, (8, 8))
print("原始图像:")
print(image)

# 将图像分割成 2×2 的小块
rows_split = np.array_split(image, 2, axis=0)
blocks = []
for row_chunk in rows_split:
col_split = np.array_split(row_chunk, 2, axis=1)
blocks.extend(col_split)

print(f"\\n分割成 {len(blocks)} 个小块:")
for i, block in enumerate(blocks):
print(f"块 {i+1}:")
print(block)
print()

📊 性能优化技巧

在处理大型数组时，合理的分割策略可以显著提升性能：

内存友好的分割

# 创建一个大型数组
large_array = np.random.rand(1000000)

# 方法1：一次性分割所有部分（可能消耗大量内存）
def split_all_at_once(arr, n_parts):
return np.array_split(arr, n_parts)

# 方法2：逐个处理分割部分（内存友好）
def process_splits_iteratively(arr, n_parts):
splits = np.array_split(arr, n_parts)
results = []
for split_part in splits:
# 对每个分割部分进行处理
processed = np.sum(split_part) # 示例处理
results.append(processed)
return results

# 测试两种方法
import time

start_time = time.time()
result1 = split_all_at_once(large_array, 100)
time1 = time.time() – start_time

start_time = time.time()
result2 = process_splits_iteratively(large_array, 100)
time2 = time.time() – start_time

print(f"一次性分割耗时: {time1:.4f} 秒")
print(f"迭代处理耗时: {time2:.4f} 秒")

🎨 可视化分割过程

让我们通过一个简单的可视化来理解分割过程：

渲染错误: Mermaid 渲染失败: Parse error on line 2: graph TD A[原始数组 [1,2,3,4,5,6,7,8]] – ——————-^ Expecting 'SQE', 'DOUBLECIRCLEEND', 'PE', '-)', 'STADIUMEND', 'SUBROUTINEEND', 'PIPE', 'CYLINDEREND', 'DIAMOND_STOP', 'TAGEND', 'TRAPEND', 'INVTRAPEND', 'UNICODE_TEXT', 'TEXT', 'TAGSTART', got 'SQS'

🔧 错误处理和最佳实践

在使用分割函数时，需要注意以下几点：

异常处理

def safe_split(array, indices_or_sections, axis=0):
"""
安全的数组分割函数
"""
try:
if isinstance(indices_or_sections, int):
# 如果是整数，检查是否能整除
if len(array) % indices_or_sections != 0:
print(f"警告: 数组长度 {len(array)} 不能被 {indices_or_sections} 整除")

result = np.split(array, indices_or_sections, axis=axis)
return result

except ValueError as e:
print(f"分割错误: {e}")
# 使用 array_split 作为备选方案
print("使用 array_split 进行不等分割…")
return np.array_split(array, indices_or_sections, axis=axis)

# 测试安全分割函数
test_array = np.arange(10)
print("测试数组:", test_array)

# 正常情况
result1 = safe_split(test_array, 2)
print("正常分割结果:", [arr.tolist() for arr in result1])

# 不等分割情况
result2 = safe_split(test_array, 3)
print("不等分割结果:", [arr.tolist() for arr in result2])

性能比较

import timeit

# 创建测试数组
test_arrays = {
'small': np.random.rand(100),
'medium': np.random.rand(10000),
'large': np.random.rand(1000000)
}

# 测试不同分割函数的性能
def performance_test():
for size_name, arr in test_arrays.items():
print(f"\\n{size_name.upper()} 数组 ({len(arr)} 元素):")

# 测试 array_split
time_array_split = timeit.timeit(
lambda: np.array_split(arr, 10),
number=1000
)

# 测试 split (仅当能整除时)
if len(arr) % 10 == 0:
time_split = timeit.timeit(
lambda: np.split(arr, 10),
number=1000
)
print(f" split(): {time_split:.6f} 秒")

print(f" array_split(): {time_array_split:.6f} 秒")

performance_test()

🌟 特殊分割场景

条件分割

有时我们需要根据条件来分割数组：

# 根据值的大小进行分割
data = np.array([1, 2, 5, 8, 3, 9, 4, 7, 6])
sorted_data = np.sort(data)
print("排序后数据:", sorted_data)

# 找到分割点
thresholds = [3, 6]
split_points = np.searchsorted(sorted_data, thresholds)
print("分割点索引:", split_points)

# 进行分割
segments = np.split(sorted_data, split_points)
print("条件分割结果:")
for i, segment in enumerate(segments):
range_desc = "低" if i == 0 else "中" if i == 1 else "高"
print(f" {range_desc}值段: {segment}")

时间序列分割

在时间序列分析中，我们经常需要按时间段分割数据：

# 模拟时间序列数据
dates = np.arange('2023-01', '2024-01', dtype='datetime64[D]')
values = np.cumsum(np.random.randn(len(dates))) + 100

print(f"时间序列范围: {dates[0]} 到 {dates[–1]}")
print(f"数据点数量: {len(dates)}")

# 按季度分割
quarters = ['2023-01', '2023-04', '2023-07', '2023-10', '2024-01']
quarter_indices = [np.searchsorted(dates, np.datetime64(q)) for q in quarters[:–1]]

quarterly_data = np.split(values, quarter_indices)
quarterly_dates = np.split(dates, quarter_indices)

print("\\n季度分割结果:")
for i, (q_dates, q_values) in enumerate(zip(quarterly_dates, quarterly_data)):
quarter_num = i + 1
print(f" Q{quarter_num}: {len(q_dates)} 天数据")
print(f" 起始日期: {q_dates[0] if len(q_dates) > 0 else 'N/A'}")
print(f" 结束日期: {q_dates[–1] if len(q_dates) > 0 else 'N/A'}")
print(f" 平均值: {np.mean(q_values):.2f}" if len(q_values) > 0 else " 无数据")

🧩 复杂数据结构分割

对于包含复杂数据结构的数组，分割操作需要特别注意：

# 创建包含结构化数据的数组
dt = np.dtype([('name', 'U10'), ('age', 'i4'), ('score', 'f4')])
structured_data = np.array([
('Alice', 25, 85.5),
('Bob', 30, 92.0),
('Charlie', 22, 78.5),
('Diana', 28, 96.0),
('Eve', 35, 88.5)
], dtype=dt)

print("结构化数据:")
for record in structured_data:
print(f" {record['name']}, {record['age']}岁, 分数: {record['score']}")

# 按记录数量分割
split_data = np.array_split(structured_data, 2)
print("\\n分割后的数据:")
for i, part in enumerate(split_data):
print(f" 部分 {i+1}:")
for record in part:
print(f" {record['name']}, {record['age']}岁, 分数: {record['score']}")

🎪 自定义分割函数

有时候内置的分割函数无法满足特殊需求，我们可以创建自定义分割函数：

def custom_split_by_value(arr, value):
"""
根据特定值分割数组
"""
# 找到所有匹配值的索引
indices = np.where(arr == value)[0]

# 添加起始和结束位置
split_indices = np.concatenate(([0], indices + 1, [len(arr)]))

# 移除重复的索引
split_indices = np.unique(split_indices)

# 进行分割
segments = []
for i in range(len(split_indices) – 1):
start_idx = split_indices[i]
end_idx = split_indices[i + 1]
if start_idx < end_idx: # 确保片段不为空
segments.append(arr[start_idx:end_idx])

return segments

# 测试自定义分割函数
test_array = np.array([1, 2, 3, 0, 4, 5, 0, 6, 7, 8])
print("测试数组:", test_array)

result = custom_split_by_value(test_array, 0)
print("按值 0 分割的结果:")
for i, segment in enumerate(result):
print(f" 段 {i+1}: {segment}")

📈 分割结果验证

确保分割结果正确性是非常重要的：

def validate_split(original_array, split_result, axis=0):
"""
验证分割结果是否正确
"""
# 重新拼接分割后的数组
recombined = np.concatenate(split_result, axis=axis)

# 检查形状是否一致
shape_match = original_array.shape == recombined.shape
print(f"形状匹配: {shape_match}")

# 检查内容是否一致
content_match = np.array_equal(original_array, recombined)
print(f"内容匹配: {content_match}")

# 显示统计信息
total_elements_original = original_array.size
total_elements_split = sum(arr.size for arr in split_result)
print(f"原始元素总数: {total_elements_original}")
print(f"分割后元素总数: {total_elements_split}")

return shape_match and content_match

# 测试验证函数
test_array = np.random.rand(4, 6)
print("原始数组形状:", test_array.shape)

# 进行分割
split_result = np.array_split(test_array, 3, axis=1)
print(f"分割成 {len(split_result)} 个部分")

# 验证分割结果
is_valid = validate_split(test_array, split_result, axis=1)
print(f"分割验证结果: {'通过' if is_valid else '失败'}")

🔗 相关资源推荐

在学习 NumPy 数组分割的过程中，以下资源可能会对你有所帮助：

• NumPy 官方文档 – Array manipulation routines 提供了关于数组操作的完整参考
• SciPy Lecture Notes 包含了丰富的科学计算教程
• Python Data Science Handbook 是一本优秀的数据科学入门书籍

🧠 最佳实践总结

通过以上详细的介绍和示例，我们可以总结出以下最佳实践：

选择合适的分割函数

注意事项

性能优化建议

🎯 实际应用案例

让我们通过一个完整的实际案例来展示数组分割的强大功能：

class DataProcessor:
"""
数据处理器类，演示数组分割的实际应用
"""

def __init__(self, data):
self.data = np.array(data)
self.processed_batches = []

def create_batches(self, batch_size, shuffle=True):
"""
创建数据批次
"""
# 复制数据以避免修改原始数据
working_data = self.data.copy()

# 如果需要打乱数据
if shuffle:
np.random.shuffle(working_data)

# 计算批次数量
n_batches = len(working_data) // batch_size

# 分割成批次
if n_batches > 0:
batches = np.array_split(
working_data[:n_batches * batch_size],
n_batches
)

# 处理剩余数据
remaining = working_data[n_batches * batch_size:]
if len(remaining) > 0:
batches.append(remaining)
else:
batches = [working_data]

self.batches = batches
return batches

def process_batches(self, processing_function):
"""
处理所有批次
"""
results = []
for i, batch in enumerate(self.batches):
print(f"处理批次 {i+1}/{len(self.batches)}, 大小: {len(batch)}")
processed_batch = processing_function(batch)
results.append(processed_batch)
self.processed_batches.append({
'batch_id': i,
'original_size': len(batch),
'processed_data': processed_batch
})

return results

def get_statistics(self):
"""
获取处理统计信息
"""
if not self.processed_batches:
return "尚未处理任何数据"

stats = {
'total_batches': len(self.processed_batches),
'total_records': sum(b['original_size'] for b in self.processed_batches),
'average_batch_size': np.mean([b['original_size'] for b in self.processed_batches]),
'min_batch_size': min(b['original_size'] for b in self.processed_batches),
'max_batch_size': max(b['original_size'] for b in self.processed_batches)
}

return stats

# 使用示例
# 创建模拟数据
sample_data = np.random.randn(1000, 5) # 1000个样本，5个特征
processor = DataProcessor(sample_data)

# 创建批次
batches = processor.create_batches(batch_size=100, shuffle=True)
print(f"创建了 {len(batches)} 个批次")

# 定义处理函数
def sample_processing_function(batch):
"""示例处理函数：计算每行的均值"""
return np.mean(batch, axis=1)

# 处理批次
results = processor.process_batches(sample_processing_function)

# 查看统计信息
stats = processor.get_statistics()
print("\\n处理统计信息:")
for key, value in stats.items():
if isinstance(value, float):
print(f" {key}: {value:.2f}")
else:
print(f" {key}: {value}")

🏁 总结

NumPy 的数组分割功能为我们提供了强大而灵活的数据处理能力。从基础的 split() 和 array_split() 函数，到专门的 hsplit() 和 vsplit()，再到高级的自定义分割策略，我们可以根据具体需求选择最合适的方法。

关键要点回顾：

✅ 选择合适的函数 – 根据需求选择 split、array_split 或其他专用函数 ✅ 注意轴参数 – 多维数组分割时正确指定分割轴 ✅ 处理边界情况 – 考虑空数组、不等分割等情况 ✅ 优化性能 – 合理管理内存和计算资源 ✅ 验证结果 – 确保分割和重组后的数据完整性

通过掌握这些分割技巧，你可以更高效地处理各种数据分析任务，无论是机器学习中的批量处理，还是科学计算中的数据分块，都能得心应手地应对。

记住，实践是最好的老师。建议你在自己的项目中尝试使用这些分割技术，并根据具体需求进行调整和优化。随着经验的积累，你会发现数组分割将成为你数据处理工具箱中不可或缺的重要工具！ 💪

🙌 感谢你读到这里！ 🔍 技术之路没有捷径，但每一次阅读、思考和实践，都在悄悄拉近你与目标的距离。 💡 如果本文对你有帮助，不妨 👍 点赞、📌 收藏、📤 分享 给更多需要的朋友！ 💬 欢迎在评论区留下你的想法、疑问或建议，我会一一回复，我们一起交流、共同成长 🌿 🔔 关注我，不错过下一篇干货！我们下期再见！✨