使用NumPy轻松实现数据输出到txt文件的完整指南从基础操作到高级技巧解决数据保存难题

威震华夏关云长

NumPy是Python中用于科学计算的核心库，提供了高性能的多维数组对象以及用于处理这些数组的工具。在数据分析和科学计算过程中，我们经常需要将处理后的数据保存到文件中，以便后续分析或与其他程序共享。txt文件作为一种简单、通用的文本格式，是数据存储的常用选择。

本文将详细介绍如何使用NumPy将数据输出到txt文件，从最基本的操作到高级技巧，帮助您解决数据保存过程中的各种难题。

NumPy基础回顾

在开始介绍如何将数据输出到txt文件之前，让我们先简要回顾一下NumPy的基础知识。

NumPy的核心是ndarray（N-dimensional array）对象，它是一个快速、灵活的大型数据集容器。我们可以通过多种方式创建NumPy数组：

2. import numpy as np
4. # 从列表创建数组
5. a = np.array([1, 2, 3, 4, 5])
7. # 创建全零数组
8. b = np.zeros((3, 4))
10. # 创建全一数组
11. c = np.ones((2, 3, 4))
13. # 创建随机数组
14. d = np.random.random((2, 2))
16. # 创建序列数组
17. e = np.arange(0, 10, 2)  # [0, 2, 4, 6, 8]
19. print("一维数组:", a)
20. print("二维数组:\n", b)
21. print("三维数组形状:", c.shape)
22. print("随机数组:\n", d)
23. print("序列数组:", e)

复制代码

了解了NumPy数组的基本创建方法后，我们就可以开始学习如何将这些数组保存到txt文件中了。

基础操作：使用savetxt函数

NumPy提供了numpy.savetxt()函数，这是将数组保存到文本文件的最基本方法。

基本用法

savetxt()函数的基本语法如下：

2. numpy.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None)

复制代码

其中：

• fname：文件名或文件句柄
• X：要保存的数组
• fmt：格式字符串，默认为’%.18e’
• delimiter：分隔符，默认为空格
• newline：行分隔符，默认为’\n’
• header：文件头部的字符串
• footer：文件尾部的字符串
• comments：用于标记header和footer的字符，默认为’#’
• encoding：文件编码

让我们看一个最基本的例子：

2. import numpy as np
4. # 创建一个简单的数组
5. data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
7. # 将数组保存到txt文件
8. np.savetxt('simple_data.txt', data)
10. # 读取并显示文件内容
11. with open('simple_data.txt', 'r') as f:
12.     print(f.read())

复制代码

输出结果应该是：

2. 1.000000000000000000e+00 2.000000000000000000e+00 3.000000000000000000e+00
3. 4.000000000000000000e+00 5.000000000000000000e+00 6.000000000000000000e+00
4. 7.000000000000000000e+00 8.000000000000000000e+00 9.000000000000000000e+00

复制代码

指定分隔符

默认情况下，savetxt()使用空格作为分隔符。我们可以通过delimiter参数来指定其他分隔符，例如逗号（CSV格式）：

2. import numpy as np
4. # 创建一个简单的数组
5. data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
7. # 使用逗号作为分隔符保存数组
8. np.savetxt('comma_data.txt', data, delimiter=',')
10. # 读取并显示文件内容
11. with open('comma_data.txt', 'r') as f:
12.     print(f.read())

复制代码

输出结果：

2. 1.000000000000000000e+00,2.000000000000000000e+00,3.000000000000000000e+00
3. 4.000000000000000000e+00,5.000000000000000000e+00,6.000000000000000000e+00
4. 7.000000000000000000e+00,8.000000000000000000e+00,9.000000000000000000e+00

复制代码

指定格式

默认情况下，savetxt()使用科学计数法保存浮点数。我们可以通过fmt参数来指定其他格式：

2. import numpy as np
4. # 创建一个简单的数组
5. data = np.array([[1.1234, 2.5678, 3.9012], [4.3456, 5.7890, 6.1234], [7.5678, 8.9012, 9.3456]])
7. # 使用浮点数格式保存数组，保留两位小数
8. np.savetxt('float_data.txt', data, fmt='%.2f')
10. # 读取并显示文件内容
11. with open('float_data.txt', 'r') as f:
12.     print(f.read())

复制代码

输出结果：

2. 1.12 2.57 3.90
3. 4.35 5.79 6.12
4. 7.57 8.90 9.35

复制代码

我们也可以为不同的列指定不同的格式：

2. import numpy as np
4. # 创建一个简单的数组
5. data = np.array([[1.1234, 2.5678, 3.9012], [4.3456, 5.7890, 6.1234], [7.5678, 8.9012, 9.3456]])
7. # 为不同的列指定不同的格式
8. # 第一列保留两位小数，第二列保留一位小数，第三列使用整数格式
9. np.savetxt('mixed_fmt_data.txt', data, fmt=['%.2f', '%.1f', '%d'])
11. # 读取并显示文件内容
12. with open('mixed_fmt_data.txt', 'r') as f:
13.     print(f.read())

复制代码

输出结果：

2. 1.12 2.6 3
3. 4.35 5.8 6
4. 7.57 8.9 9

复制代码

添加头部和尾部信息

我们可以使用header和footer参数在文件中添加头部和尾部信息：

2. import numpy as np
4. # 创建一个简单的数组
5. data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
7. # 添加头部和尾部信息
8. np.savetxt('header_footer_data.txt', data,
9.            header='This is the header\nColumn1 Column2 Column3',
10.            footer='This is the footer\nEnd of file')
12. # 读取并显示文件内容
13. with open('header_footer_data.txt', 'r') as f:
14.     print(f.read())

复制代码

输出结果：

2. # This is the header
3. # Column1 Column2 Column3
4. 1.000000000000000000e+00 2.000000000000000000e+00 3.000000000000000000e+00
5. 4.000000000000000000e+00 5.000000000000000000e+00 6.000000000000000000e+00
6. 7.000000000000000000e+00 8.000000000000000000e+00 9.000000000000000000e+00
7. # This is the footer
8. # End of file

复制代码

处理一维数组

一维数组是NumPy中最简单的数据结构，我们可以使用savetxt()函数轻松地将其保存到txt文件中：

2. import numpy as np
4. # 创建一个一维数组
5. data_1d = np.array([1, 2, 3, 4, 5])
7. # 保存一维数组
8. np.savetxt('1d_data.txt', data_1d)
10. # 读取并显示文件内容
11. with open('1d_data.txt', 'r') as f:
12.     print(f.read())

复制代码

输出结果：

2. 1.000000000000000000e+00
3. 2.000000000000000000e+00
4. 3.000000000000000000e+00
5. 4.000000000000000000e+00
6. 5.000000000000000000e+00

复制代码

如果我们希望将一维数组保存为行向量而不是列向量，可以将其转换为二维数组：

2. import numpy as np
4. # 创建一个一维数组
5. data_1d = np.array([1, 2, 3, 4, 5])
7. # 将一维数组转换为二维数组（行向量）
8. data_row = data_1d.reshape(1, -1)
10. # 保存为行向量
11. np.savetxt('1d_row_data.txt', data_row)
13. # 读取并显示文件内容
14. with open('1d_row_data.txt', 'r') as f:
15.     print(f.read())

复制代码

输出结果：

2. 1.000000000000000000e+00 2.000000000000000000e+00 3.000000000000000000e+00 4.000000000000000000e+00 5.000000000000000000e+00

复制代码

处理多维数组

NumPy的savetxt()函数只能处理一维和二维数组。如果我们有一个多维数组（三维或更高维），需要先将其转换为二维数组，然后再保存：

2. import numpy as np
4. # 创建一个三维数组
5. data_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
6. print("原始三维数组形状:", data_3d.shape)
8. # 将三维数组转换为二维数组
9. data_2d = data_3d.reshape(-1, data_3d.shape[-1])
10. print("转换后的二维数组形状:", data_2d.shape)
12. # 保存转换后的二维数组
13. np.savetxt('3d_to_2d_data.txt', data_2d, fmt='%d')
15. # 读取并显示文件内容
16. with open('3d_to_2d_data.txt', 'r') as f:
17.     print(f.read())

复制代码

输出结果：

2. 原始三维数组形状: (2, 2, 2)
3. 转换后的二维数组形状: (4, 2)
4. 1 2
5. 3 4
6. 5 6
7. 7 8

复制代码

处理结构化数组

NumPy支持结构化数组，即可以包含不同数据类型的数组。我们可以使用savetxt()函数保存结构化数组，但需要一些额外的处理：

2. import numpy as np
4. # 创建一个结构化数组
5. dtype = [('name', 'U10'), ('age', 'i4'), ('weight', 'f4')]
6. data_structured = np.array([('Alice', 25, 55.5), ('Bob', 30, 70.2), ('Charlie', 35, 65.7)], dtype=dtype)
8. print("结构化数组:")
9. print(data_structured)
11. # 提取各个字段
12. names = data_structured['name']
13. ages = data_structured['age']
14. weights = data_structured['weight']
16. # 将字段组合成二维数组
17. combined_data = np.column_stack((names, ages, weights))
19. # 保存结构化数组
20. np.savetxt('structured_data.txt', combined_data, fmt=['%s', '%d', '%.1f'])
22. # 读取并显示文件内容
23. with open('structured_data.txt', 'r') as f:
24.     print("\n保存后的内容:")
25.     print(f.read())

复制代码

输出结果：

2. 结构化数组:
3. [('Alice', 25, 55.5) ('Bob', 30, 70.2) ('Charlie', 35, 65.7)]
5. 保存后的内容:
6. Alice 25 55.5
7. Bob 30 70.2
8. Charlie 35 65.7

复制代码

处理大数据量

当处理大量数据时，直接将整个数组保存到文件可能会消耗大量内存。在这种情况下，我们可以考虑分批处理数据：

2. import numpy as np
4. # 创建一个大型数组
5. large_data = np.random.random((10000, 10))
7. # 分批保存数据
8. batch_size = 1000
9. for i in range(0, large_data.shape[0], batch_size):
10.     batch = large_data[i:i+batch_size]
11.     # 如果是第一批，使用'w'模式创建新文件；否则使用'a'模式追加数据
12.     mode = 'w' if i == 0 else 'a'
13.     with open('large_data.txt', mode) as f:
14.         np.savetxt(f, batch, fmt='%.4f')
16. # 验证文件行数
17. with open('large_data.txt', 'r') as f:
18.     line_count = sum(1 for _ in f)
19. print(f"文件行数: {line_count}")

复制代码

高级技巧：自定义输出格式

有时候，我们需要更加灵活地控制输出格式。在这种情况下，我们可以使用Python的文件操作和NumPy的数组操作结合来实现：

2. import numpy as np
4. # 创建一个数组
5. data = np.array([[1.1234, 2.5678, 3.9012], [4.3456, 5.7890, 6.1234], [7.5678, 8.9012, 9.3456]])
7. # 自定义格式保存
8. with open('custom_format_data.txt', 'w') as f:
9.     # 写入头部信息
10.     f.write("Custom formatted data\n")
11.     f.write("Column1\tColumn2\tColumn3\n")
12.     f.write("----------------------\n")
13.    
14.     # 写入数据
15.     for row in data:
16.         # 格式化每一行
17.         formatted_row = [f"{val:.2f}" for val in row]
18.         # 使用制表符连接并写入文件
19.         f.write("\t".join(formatted_row) + "\n")
21. # 读取并显示文件内容
22. with open('custom_format_data.txt', 'r') as f:
23.     print(f.read())

复制代码

输出结果：

2. Custom formatted data
3. Column1        Column2        Column3
4. ----------------------
5. 1.12        2.57        3.90
6. 4.35        5.79        6.12
7. 7.57        8.90        9.35

复制代码

高级技巧：使用压缩文件

为了节省存储空间，我们可以将数据保存到压缩文件中。NumPy的savetxt()函数不支持直接保存到压缩文件，但我们可以结合Python的gzip或zipfile模块来实现：

2. import numpy as np
3. import gzip
5. # 创建一个数组
6. data = np.random.random((100, 10))
8. # 保存到gzip压缩文件
9. with gzip.open('compressed_data.txt.gz', 'wt') as f:
10.     np.savetxt(f, data, fmt='%.4f')
12. # 读取压缩文件并验证
13. with gzip.open('compressed_data.txt.gz', 'rt') as f:
14.     loaded_data = np.loadtxt(f)
15.     print("加载的数据形状:", loaded_data.shape)
16.     print("前5行数据:")
17.     print(loaded_data[:5])

复制代码

高级技巧：处理缺失值

在实际数据处理中，我们经常会遇到缺失值（NaN）。NumPy的savetxt()函数可以处理NaN值，但我们需要指定适当的格式：

2. import numpy as np
4. # 创建一个包含NaN值的数组
5. data_with_nan = np.array([[1.1, 2.2, np.nan], [4.4, np.nan, 6.6], [np.nan, 8.8, 9.9]])
7. # 保存包含NaN值的数组
8. np.savetxt('nan_data.txt', data_with_nan, fmt='%.2f')
10. # 读取并显示文件内容
11. with open('nan_data.txt', 'r') as f:
12.     print(f.read())

复制代码

输出结果：

2. 1.10 2.20 nan
3. 4.40 nan 6.60
4. nan 8.80 9.90

复制代码

如果我们想用特定的字符串（如”NA”或”NULL”）替代NaN，可以在保存前进行替换：

2. import numpy as np
4. # 创建一个包含NaN值的数组
5. data_with_nan = np.array([[1.1, 2.2, np.nan], [4.4, np.nan, 6.6], [np.nan, 8.8, 9.9]])
7. # 将NaN替换为特定字符串
8. data_str = data_with_nan.astype(str)
9. data_str[data_str == 'nan'] = 'NA'
11. # 保存处理后的数据
12. with open('nan_replaced_data.txt', 'w') as f:
13.     for row in data_str:
14.         f.write(' '.join(row) + '\n')
16. # 读取并显示文件内容
17. with open('nan_replaced_data.txt', 'r') as f:
18.     print(f.read())

复制代码

输出结果：

2. 1.1 2.2 NA
3. 4.4 NA 6.6
4. NA 8.8 9.9

复制代码

高级技巧：追加数据到现有文件

有时候，我们需要将数据追加到现有文件中，而不是覆盖它。这可以通过使用Python的文件操作和NumPy结合来实现：

2. import numpy as np
4. # 创建第一个数组
5. data1 = np.array([[1, 2, 3], [4, 5, 6]])
7. # 保存第一个数组
8. with open('append_data.txt', 'w') as f:
9.     f.write("First dataset:\n")
10.     np.savetxt(f, data1, fmt='%d')
12. # 创建第二个数组
13. data2 = np.array([[7, 8, 9], [10, 11, 12]])
15. # 追加第二个数组
16. with open('append_data.txt', 'a') as f:
17.     f.write("\nSecond dataset:\n")
18.     np.savetxt(f, data2, fmt='%d')
20. # 读取并显示文件内容
21. with open('append_data.txt', 'r') as f:
22.     print(f.read())

复制代码

输出结果：

2. First dataset:
3. 1 2 3
4. 4 5 6
6. Second dataset:
7. 7 8 9
8. 10 11 12

复制代码

实际应用案例：保存实验数据

让我们通过一个实际案例来展示如何使用NumPy保存实验数据。假设我们进行了一系列实验，记录了时间、温度和压力数据：

2. import numpy as np
3. import datetime
5. # 生成模拟实验数据
6. num_points = 100
7. time_data = np.linspace(0, 10, num_points)  # 时间点（0到10秒）
8. temp_data = 25 + 5 * np.sin(time_data) + np.random.normal(0, 0.5, num_points)  # 温度数据
9. pressure_data = 1013 + 20 * np.cos(time_data) + np.random.normal(0, 1, num_points)  # 压力数据
11. # 组合数据
12. experiment_data = np.column_stack((time_data, temp_data, pressure_data))
14. # 添加实验元数据
15. experiment_date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
16. experimenter = "Dr. Smith"
17. experiment_conditions = "Room temperature, atmospheric pressure"
19. # 保存实验数据
20. with open('experiment_data.txt', 'w') as f:
21.     # 写入元数据
22.     f.write(f"# Experiment Data\n")
23.     f.write(f"# Date: {experiment_date}\n")
24.     f.write(f"# Experimenter: {experimenter}\n")
25.     f.write(f"# Conditions: {experiment_conditions}\n")
26.     f.write(f"# Columns: Time(s), Temperature(C), Pressure(hPa)\n")
27.     f.write("#" + "-"*50 + "\n")
28.    
29.     # 写入数据
30.     np.savetxt(f, experiment_data, fmt=['%.2f', '%.2f', '%.1f'])
32. # 读取并显示文件内容的前几行
33. with open('experiment_data.txt', 'r') as f:
34.     lines = f.readlines()
35.     for i, line in enumerate(lines):
36.         if i < 10:  # 只显示前10行
37.             print(line, end='')
38.         elif i == 10:
39.             print("... (truncated) ...")
40.             break

复制代码

输出结果类似于：

2. # Experiment Data
3. # Date: 2023-07-25 14:30:45
4. # Experimenter: Dr. Smith
5. # Conditions: Room temperature, atmospheric pressure
6. # Columns: Time(s), Temperature(C), Pressure(hPa)
7. #--------------------------------------------------
8. 0.00 25.32 1032.5
9. 0.10 25.81 1031.8
10. 0.20 26.29 1030.5
11. 0.30 26.77 1028.8
12. 0.40 27.21 1026.7
13. 0.50 27.61 1024.2
14. 0.60 27.96 1021.5
15. 0.70 28.25 1018.6
16. 0.80 28.48 1015.6
17. ... (truncated) ...

复制代码

实际应用案例：保存机器学习数据集

在机器学习项目中，我们经常需要保存和加载数据集。让我们看一个如何使用NumPy保存机器学习数据集的例子：

2. import numpy as np
4. # 生成模拟的机器学习数据集
5. num_samples = 1000
6. num_features = 5
8. # 生成特征数据
9. X = np.random.random((num_samples, num_features))
11. # 生成标签数据（二分类问题）
12. y = np.random.randint(0, 2, num_samples)
14. # 添加一些特征名称
15. feature_names = [f"Feature_{i+1}" for i in range(num_features)]
17. # 保存数据集
18. with open('ml_dataset.txt', 'w') as f:
19.     # 写入数据集信息
20.     f.write("# Machine Learning Dataset\n")
21.     f.write(f"# Number of samples: {num_samples}\n")
22.     f.write(f"# Number of features: {num_features}\n")
23.     f.write(f"# Features: {', '.join(feature_names)}\n")
24.     f.write("# Format: [Features], Label\n")
25.     f.write("#" + "-"*50 + "\n")
26.    
27.     # 合并特征和标签
28.     dataset = np.column_stack((X, y))
29.    
30.     # 写入数据
31.     np.savetxt(f, dataset, fmt=['%.4f'] * num_features + ['%d'])
33. # 读取并显示文件内容的前几行
34. with open('ml_dataset.txt', 'r') as f:
35.     lines = f.readlines()
36.     for i, line in enumerate(lines):
37.         if i < 10:  # 只显示前10行
38.             print(line, end='')
39.         elif i == 10:
40.             print("... (truncated) ...")
41.             break

复制代码

输出结果类似于：

2. # Machine Learning Dataset
3. # Number of samples: 1000
4. # Number of features: 5
5. # Features: Feature_1, Feature_2, Feature_3, Feature_4, Feature_5
6. # Format: [Features], Label
7. #--------------------------------------------------
8. 0.1234 0.5678 0.9012 0.3456 0.7890 1
9. 0.2345 0.6789 0.0123 0.4567 0.8901 0
10. 0.3456 0.7890 0.1234 0.5678 0.9012 1
11. 0.4567 0.8901 0.2345 0.6789 0.0123 0
12. 0.5678 0.9012 0.3456 0.7890 0.1234 1
13. 0.6789 0.0123 0.4567 0.8901 0.2345 0
14. 0.7890 0.1234 0.5678 0.9012 0.3456 1
15. 0.8901 0.2345 0.6789 0.0123 0.4567 0
16. 0.9012 0.3456 0.7890 0.1234 0.5678 1
17. ... (truncated) ...

复制代码

常见问题和解决方案

问题1：如何保存复数数组？

NumPy的savetxt()函数不能直接保存复数数组。我们需要将复数分解为实部和虚部：

2. import numpy as np
4. # 创建一个复数数组
5. complex_data = np.array([1+2j, 3+4j, 5+6j])
7. # 将复数分解为实部和虚部
8. real_part = complex_data.real
9. imag_part = complex_data.imag
11. # 合并实部和虚部
12. combined_data = np.column_stack((real_part, imag_part))
14. # 保存复数数据
15. with open('complex_data.txt', 'w') as f:
16.     f.write("# Complex Data\n")
17.     f.write("# Format: Real Part, Imaginary Part\n")
18.     np.savetxt(f, combined_data, fmt='%.2f')
20. # 读取并显示文件内容
21. with open('complex_data.txt', 'r') as f:
22.     print(f.read())

复制代码

输出结果：

2. # Complex Data
3. # Format: Real Part, Imaginary Part
4. 1.00 2.00
5. 3.00 4.00
6. 5.00 6.00

复制代码

问题2：如何保存布尔数组？

布尔数组需要先转换为整数或字符串，然后再保存：

2. import numpy as np
4. # 创建一个布尔数组
5. bool_data = np.array([True, False, True, False, True])
7. # 方法1：转换为整数
8. bool_as_int = bool_data.astype(int)
9. np.savetxt('bool_as_int.txt', bool_as_int, fmt='%d')
11. # 方法2：转换为字符串
12. bool_as_str = bool_data.astype(str)
13. with open('bool_as_str.txt', 'w') as f:
14.     for val in bool_as_str:
15.         f.write(val + '\n')
17. # 读取并显示文件内容
18. print("布尔数组保存为整数:")
19. with open('bool_as_int.txt', 'r') as f:
20.     print(f.read())
22. print("布尔数组保存为字符串:")
23. with open('bool_as_str.txt', 'r') as f:
24.     print(f.read())

复制代码

输出结果：

2. 布尔数组保存为整数:
3. 1
4. 0
5. 1
6. 0
7. 1
9. 布尔数组保存为字符串:
10. True
11. False
12. True
13. False
14. True

复制代码

问题3：如何保存日期时间数组？

日期时间数组需要先转换为字符串，然后再保存：

2. import numpy as np
3. import datetime
5. # 创建一个日期时间数组
6. dates = np.array([
7.     datetime.datetime(2023, 1, 1),
8.     datetime.datetime(2023, 1, 2),
9.     datetime.datetime(2023, 1, 3),
10.     datetime.datetime(2023, 1, 4),
11.     datetime.datetime(2023, 1, 5)
12. ])
14. # 将日期时间转换为字符串
15. date_str = np.array([d.strftime('%Y-%m-%d') for d in dates])
17. # 保存日期时间数据
18. with open('datetime_data.txt', 'w') as f:
19.     f.write("# Date Data\n")
20.     f.write("# Format: YYYY-MM-DD\n")
21.     for d in date_str:
22.         f.write(d + '\n')
24. # 读取并显示文件内容
25. with open('datetime_data.txt', 'r') as f:
26.     print(f.read())

复制代码

输出结果：

2. # Date Data
3. # Format: YYYY-MM-DD
4. 2023-01-01
5. 2023-01-02
6. 2023-01-03
7. 2023-01-04
8. 2023-01-05

复制代码

问题4：如何保存大型数组而不会导致内存不足？

对于非常大的数组，我们可以使用分批处理的方法：

2. import numpy as np
4. # 创建一个大型数组
5. large_array = np.random.random((100000, 10))  # 100,000行 x 10列
7. # 分批保存大型数组
8. batch_size = 10000  # 每批10,000行
9. with open('large_array_data.txt', 'w') as f:
10.     for i in range(0, large_array.shape[0], batch_size):
11.         batch = large_array[i:i+batch_size]
12.         np.savetxt(f, batch, fmt='%.4f')
13.         print(f"Saved batch {i//batch_size + 1}/{(large_array.shape[0]-1)//batch_size + 1}")
15. print("Large array saved successfully.")

复制代码

问题5：如何保存多个数组到同一个文件？

我们可以通过以下方法将多个数组保存到同一个文件：

2. import numpy as np
4. # 创建三个数组
5. array1 = np.array([1, 2, 3])
6. array2 = np.array([4, 5, 6])
7. array3 = np.array([7, 8, 9])
9. # 方法1：水平堆叠
10. horizontal_stack = np.hstack((array1, array2, array3))
11. np.savetxt('multiple_arrays_horizontal.txt', horizontal_stack.reshape(1, -1), fmt='%d')
13. # 方法2：垂直堆叠
14. vertical_stack = np.vstack((array1, array2, array3))
15. np.savetxt('multiple_arrays_vertical.txt', vertical_stack, fmt='%d')
17. # 方法3：使用分隔符标记不同数组
18. with open('multiple_arrays_separated.txt', 'w') as f:
19.     np.savetxt(f, array1.reshape(1, -1), fmt='%d')
20.     f.write("\n--- Array 2 ---\n")
21.     np.savetxt(f, array2.reshape(1, -1), fmt='%d')
22.     f.write("\n--- Array 3 ---\n")
23.     np.savetxt(f, array3.reshape(1, -1), fmt='%d')
25. # 读取并显示文件内容
26. print("水平堆叠:")
27. with open('multiple_arrays_horizontal.txt', 'r') as f:
28.     print(f.read())
30. print("\n垂直堆叠:")
31. with open('multiple_arrays_vertical.txt', 'r') as f:
32.     print(f.read())
34. print("\n使用分隔符:")
35. with open('multiple_arrays_separated.txt', 'r') as f:
36.     print(f.read())

复制代码

输出结果：

2. 水平堆叠:
3. 1 2 3 4 5 6 7 8 9
5. 垂直堆叠:
6. 1 2 3
7. 4 5 6
8. 7 8 9
10. 使用分隔符:
11. 1 2 3
12. --- Array 2 ---
13. 4 5 6
14. --- Array 3 ---
15. 7 8 9

复制代码

总结

本文详细介绍了如何使用NumPy将数据输出到txt文件，从基础操作到高级技巧。我们学习了：

1. 使用savetxt()函数的基本方法，包括指定分隔符和格式
2. 如何处理一维、二维和多维数组
3. 如何处理结构化数组和包含不同数据类型的数组
4. 如何处理大数据量和缺失值
5. 如何自定义输出格式和追加数据到现有文件
6. 通过实际案例展示了如何保存实验数据和机器学习数据集
7. 解决了常见问题，如保存复数数组、布尔数组、日期时间数组等

通过掌握这些技巧，您应该能够轻松地将NumPy数组保存到txt文件中，满足各种数据保存需求。无论是简单的数据导出还是复杂的数据处理任务，NumPy都提供了强大而灵活的工具来帮助您完成工作。

希望这篇文章对您有所帮助！如果您有任何问题或需要进一步的指导，请随时参考NumPy官方文档或寻求社区支持。