Python NumPy数组如何高效导出到MATLAB环境中的实用技巧与完整教程让跨平台数据交换变得简单无缝提升工作效率

威震华夏关云长

引言

在科学计算、数据分析和工程领域中，Python和MATLAB都是广泛使用的工具。Python以其丰富的库生态系统和灵活性著称，而MATLAB则在工程计算和矩阵操作方面具有优势。NumPy作为Python科学计算的核心库，提供了高效的数组操作功能。在实际工作中，我们经常需要在这两个环境之间交换数据，特别是将NumPy数组导出到MATLAB环境中进行进一步分析或可视化。

本文将详细介绍多种将NumPy数组导出到MATLAB的方法，包括使用标准文件格式、专用API和第三方工具等。通过这些方法，您可以实现跨平台数据交换，提高工作效率，确保数据在不同环境间的无缝传输。

方法一：使用scipy.io.savemat/loadmat

SciPy库提供了scipy.io模块，其中的savemat和loadmat函数是Python和MATLAB之间交换数据的标准方法之一。这种方法使用MATLAB的.mat文件格式，可以保存和加载多个变量。

基本用法

首先，确保您已安装SciPy库。如果没有安装，可以使用以下命令安装：

2. pip install scipy

复制代码

下面是一个简单的示例，展示如何将NumPy数组保存为.mat文件：

2. import numpy as np
3. from scipy.io import savemat
5. # 创建一个NumPy数组
6. data = np.random.rand(5, 5)
7. print("NumPy数组:")
8. print(data)
10. # 将数组保存为.mat文件
11. savemat('data.mat', {'array_data': data})
13. print("数据已保存到data.mat文件")

复制代码

在MATLAB中，您可以这样加载这个文件：

2. % 加载.mat文件
3. loaded_data = load('data.mat');
5. % 显示加载的数据
6. disp('从Python加载的数组:');
7. disp(loaded_data.array_data);

复制代码

导出多个数组

您可以在一个.mat文件中保存多个数组：

2. import numpy as np
3. from scipy.io import savemat
5. # 创建多个NumPy数组
6. array1 = np.random.rand(3, 4)
7. array2 = np.random.randint(0, 10, size=(2, 5))
8. array3 = np.linspace(0, 1, 10)
10. # 将多个数组保存到一个.mat文件
11. savemat('multiple_arrays.mat', {
12.     'first_array': array1,
13.     'second_array': array2,
14.     'third_array': array3
15. })
17. print("多个数组已保存到multiple_arrays.mat文件")

复制代码

在MATLAB中加载这些数组：

2. % 加载包含多个数组的.mat文件
3. data = load('multiple_arrays.mat');
5. % 访问各个数组
6. disp('第一个数组:');
7. disp(data.first_array);
9. disp('第二个数组:');
10. disp(data.second_array);
12. disp('第三个数组:');
13. disp(data.third_array);

复制代码

处理复杂数据结构

savemat函数也可以处理更复杂的数据结构，如结构体数组和单元格数组：

2. import numpy as np
3. from scipy.io import savemat
5. # 创建一个结构体数组
6. student1 = {
7.     'name': 'John',
8.     'age': 20,
9.     'grades': np.array([85, 90, 78])
10. }
12. student2 = {
13.     'name': 'Alice',
14.     'age': 22,
15.     'grades': np.array([92, 88, 95])
16. }
18. # 将结构体数组保存为MATLAB结构体
19. savemat('students.mat', {
20.     'students': [student1, student2]
21. })
23. print("结构体数据已保存到students.mat文件")

复制代码

在MATLAB中，这将转换为一个结构体数组：

2. % 加载结构体数据
3. students_data = load('students.mat');
5. % 访问结构体数组
6. disp('第一个学生的姓名:');
7. disp(students_data.students(1).name);
9. disp('第一个学生的成绩:');
10. disp(students_data.students(1).grades);

复制代码

优缺点分析

优点：

• 简单易用，只需要几行代码
• 支持多种数据类型，包括数值数组、结构体等
• 是SciPy库的一部分，不需要额外安装
• 跨平台兼容性好

缺点：

• 对于非常大的数组，可能会遇到性能问题
• 不支持所有Python数据类型
• .mat文件格式在不同MATLAB版本间可能有兼容性问题

方法二：使用MATLAB Engine API for Python

MATLAB Engine API for Python是MathWorks官方提供的工具，允许在Python环境中直接调用MATLAB功能。这种方法可以实现Python和MATLAB之间的实时数据交换，无需通过文件系统。

安装和设置

首先，确保您已安装MATLAB。然后，按照以下步骤安装MATLAB Engine API：

1. 找到MATLAB安装目录中的extern/engines/python文件夹
2. 在命令提示符或终端中，导航到该文件夹
3. 运行安装命令：

2. cd /path/to/matlab/extern/engines/python
3. python setup.py install

复制代码

基本数据传输

安装完成后，您可以在Python中启动MATLAB引擎并传输数据：

2. import numpy as np
3. import matlab.engine
5. # 启动MATLAB引擎
6. eng = matlab.engine.start_matlab()
8. # 创建NumPy数组
9. np_array = np.random.rand(5, 5)
10. print("NumPy数组:")
11. print(np_array)
13. # 将NumPy数组转换为MATLAB数组
14. ml_array = matlab.double(np_array.tolist())
16. # 在MATLAB工作空间中创建变量
17. eng.workspace['python_data'] = ml_array
19. # 在MATLAB中执行操作
20. eng.eval('disp(''从Python接收的数组:'');')
21. eng.eval('disp(python_data);')
23. # 在MATLAB中进行计算
24. eng.eval('matlab_result = python_data * 2;')
26. # 将结果传回Python
27. result = eng.workspace['matlab_result']
28. print("\nMATLAB计算结果:")
29. print(np.array(result))
31. # 关闭MATLAB引擎
32. eng.quit()

复制代码

高级用法

MATLAB Engine API还支持更复杂的操作，如调用MATLAB函数和处理多维数组：

2. import numpy as np
3. import matlab.engine
5. # 启动MATLAB引擎
6. eng = matlab.engine.start_matlab()
8. # 创建多维NumPy数组
9. np_3d_array = np.random.rand(3, 4, 5)
11. # 将NumPy数组转换为MATLAB数组
12. ml_3d_array = matlab.double(np_3d_array.tolist(), size=(3, 4, 5))
14. # 在MATLAB工作空间中创建变量
15. eng.workspace['python_3d'] = ml_3d_array
17. # 调用MATLAB函数进行计算
18. eng.eval('max_values = max(python_3d, [], 3);')
20. # 获取结果
21. max_values = eng.workspace['max_values']
22. print("每层的最大值:")
23. print(np.array(max_values))
25. # 使用MATLAB的绘图功能
26. eng.eval('figure;')
27. eng.eval('imagesc(python_3d(:,:,1));')
28. eng.eval('title(''第一层数据的热图'');')
29. eng.eval('colorbar;')
31. # 关闭MATLAB引擎
32. eng.quit()

复制代码

优缺点分析

优点：

• 实时数据交换，无需文件I/O
• 可以直接调用MATLAB函数和工具箱
• 支持复杂的数据类型和结构
• 适合需要频繁交互的应用场景

缺点：

• 需要安装MATLAB和Engine API
• 启动MATLAB引擎需要较长时间
• 占用较多系统资源
• 在某些环境中可能存在许可限制

方法三：使用HDF5格式

HDF5（Hierarchical Data Format version 5）是一种用于存储和组织大量数据的文件格式，支持多种编程语言，包括Python和MATLAB。它特别适合处理大型数据集和复杂的数据结构。

基本概念

HDF5使用类似文件系统的层次结构来组织数据，包括：

• 组（Groups）：类似于文件夹，可以包含数据集和其他组
• 数据集（Datasets）：类似于文件，存储实际的数据
• 属性（Attributes）：存储与组或数据集相关的元数据

使用h5py库

在Python中，我们可以使用h5py库来创建和操作HDF5文件。首先安装h5py：

2. pip install h5py numpy

复制代码

下面是一个使用h5py将NumPy数组保存为HDF5文件的示例：

2. import numpy as np
3. import h5py
5. # 创建NumPy数组
6. array1 = np.random.rand(100, 100)
7. array2 = np.random.randint(0, 100, size=(50, 50))
8. array3 = np.linspace(0, 10, 1000)
10. # 创建HDF5文件
11. with h5py.File('data.h5', 'w') as f:
12.     # 创建组
13.     group = f.create_group('numpy_arrays')
14.    
15.     # 添加数据集
16.     group.create_dataset('random_floats', data=array1)
17.     group.create_dataset('random_integers', data=array2)
18.     group.create_dataset('linspace', data=array3)
19.    
20.     # 添加属性
21.     group.attrs['description'] = 'NumPy arrays exported from Python'
22.     group.attrs['creation_date'] = '2023-11-15'
24. print("数据已保存到data.h5文件")

复制代码

在MATLAB中读取HDF5文件

在MATLAB中，您可以使用内置的HDF5函数来读取这些数据：

2. % 打开HDF5文件
3. file_id = H5F.open('data.h5', 'H5F_ACC_RDONLY', 'H5P_DEFAULT');
5. % 打开组
6. group_id = H5G.open(file_id, '/numpy_arrays');
8. % 读取数据集
9. dataset_id1 = H5D.open(group_id, 'random_floats');
10. random_floats = H5D.read(dataset_id1);
11. H5D.close(dataset_id1);
13. dataset_id2 = H5D.open(group_id, 'random_integers');
14. random_integers = H5D.read(dataset_id2);
15. H5D.close(dataset_id2);
17. dataset_id3 = H5D.open(group_id, 'linspace');
18. linspace = H5D.read(dataset_id3);
19. H5D.close(dataset_id3);
21. % 读取属性
22. attr_id = H5A.open(group_id, 'description');
23. description = H5A.read(attr_id);
24. H5A.close(attr_id);
26. % 关闭所有资源
27. H5G.close(group_id);
28. H5F.close(file_id);
30. % 显示数据
31. disp('描述:');
32. disp(description);
34. disp('随机浮点数数组大小:');
35. disp(size(random_floats));
37. disp('随机整数数组大小:');
38. disp(size(random_integers));
40. disp('线性空间数组长度:');
41. disp(length(linspace));

复制代码

MATLAB还提供了更高级的函数来简化HDF5文件的操作：

2. % 使用高级函数读取HDF5文件
3. data = h5read('data.h5', '/numpy_arrays/random_floats');
5. % 显示数据信息
6. h5disp('data.h5');
8. % 读取所有变量
9. info = h5info('data.h5');
10. for i = 1:length(info.Groups(1).Datasets)
11.     dataset_name = info.Groups(1).Datasets(i).Name;
12.     full_path = ['/numpy_arrays/' dataset_name];
13.     data = h5read('data.h5', full_path);
14.     disp(['数据集 ' dataset_name ' 的大小: ' num2str(size(data))]);
15. end

复制代码

优缺点分析

优点：

• 支持非常大的数据集（可达TB级别）
• 高效的存储和访问机制
• 跨平台兼容性好
• 支持复杂的数据结构和元数据
• 并行I/O支持

缺点：

• 学习曲线较陡峭
• 文件格式相对复杂
• 需要额外的库（h5py）
• 对于小型数据集可能过于复杂

方法四：使用CSV或文本文件

对于简单的数据交换，使用CSV（逗号分隔值）或其他文本格式是一种简单而通用的方法。这种方法不需要特殊的库，几乎所有数据处理工具都支持这些格式。

基本方法

使用NumPy的savetxt函数可以将数组保存为文本文件：

2. import numpy as np
4. # 创建NumPy数组
5. data = np.random.rand(5, 5)
6. print("原始数组:")
7. print(data)
9. # 保存为CSV文件
10. np.savetxt('data.csv', data, delimiter=',')
11. print("数据已保存为CSV文件")
13. # 保存为制表符分隔的文本文件
14. np.savetxt('data.txt', data, delimiter='\t')
15. print("数据已保存为制表符分隔的文本文件")

复制代码

在MATLAB中，您可以使用csvread或load函数来读取这些文件：

2. % 读取CSV文件
3. csv_data = csvread('data.csv');
4. disp('从CSV文件读取的数据:');
5. disp(csv_data);
7. % 读取制表符分隔的文本文件
8. txt_data = load('data.txt');
9. disp('从文本文件读取的数据:');
10. disp(txt_data);

复制代码

处理大型数组

对于大型数组，可以使用更高效的方法：

2. import numpy as np
4. # 创建大型NumPy数组
5. large_data = np.random.rand(1000, 1000)
7. # 使用更高效的格式保存
8. np.save('large_data.npy', large_data)  # NumPy的二进制格式
9. print("大型数组已保存为NumPy二进制格式")
11. # 如果需要文本格式，可以使用压缩
12. np.savetxt('large_data.csv.gz', large_data, delimiter=',')
13. print("大型数组已保存为压缩的CSV格式")

复制代码

在MATLAB中，读取大型数组可能需要特殊处理：

2. % 读取大型CSV文件（使用文本扫描以提高效率）
3. file_id = fopen('large_data.csv');
4. large_data = textscan(file_id, '%f %f %f %f %f', 'Delimiter', ',', 'HeaderLines', 0);
5. fclose(file_id);
7. % 将单元格数组转换为矩阵
8. large_data = cell2mat(large_data);
9. disp(['读取的大型数组大小: ' num2str(size(large_data))]);

复制代码

优缺点分析

优点：

• 简单易用，不需要特殊库
• 人类可读的格式
• 几乎所有数据处理工具都支持
• 适合小型到中型数据集

缺点：

• 对于大型数组效率较低
• 文件大小通常比二进制格式大
• 可能丢失精度（特别是对于浮点数）
• 不支持复杂的数据结构

性能比较和最佳实践

不同的数据交换方法在性能、易用性和功能方面各有优势。本节将对这些方法进行比较，并提供一些最佳实践建议。

不同方法的性能对比

让我们通过一个简单的基准测试来比较不同方法的性能：

2. import numpy as np
3. import time
4. from scipy.io import savemat
5. import h5py
6. import matlab.engine
8. # 创建测试数据
9. test_sizes = [(100, 100), (1000, 1000), (5000, 5000)]
10. results = {}
12. # 启动MATLAB引擎（仅用于MATLAB Engine API测试）
13. print("启动MATLAB引擎...")
14. eng = matlab.engine.start_matlab()
16. for size in test_sizes:
17.     print(f"\n测试数组大小: {size}")
18.     data = np.random.rand(*size)
19.    
20.     # 测试scipy.io.savemat
21.     start_time = time.time()
22.     savemat(f'test_scipy_{size[0]}x{size[1]}.mat', {'data': data})
23.     scipy_time = time.time() - start_time
24.    
25.     # 测试HDF5
26.     start_time = time.time()
27.     with h5py.File(f'test_hdf5_{size[0]}x{size[1]}.h5', 'w') as f:
28.         f.create_dataset('data', data=data)
29.     hdf5_time = time.time() - start_time
30.    
31.     # 测试CSV
32.     start_time = time.time()
33.     np.savetxt(f'test_csv_{size[0]}x{size[1]}.csv', data, delimiter=',')
34.     csv_time = time.time() - start_time
35.    
36.     # 测试MATLAB Engine API
37.     start_time = time.time()
38.     ml_data = matlab.double(data.tolist())
39.     eng.workspace['test_data'] = ml_data
40.     engine_time = time.time() - start_time
41.    
42.     # 存储结果
43.     results[size] = {
44.         'scipy': scipy_time,
45.         'hdf5': hdf5_time,
46.         'csv': csv_time,
47.         'engine': engine_time
48.     }
49.    
50.     print(f"scipy.io.savemat: {scipy_time:.4f} 秒")
51.     print(f"HDF5: {hdf5_time:.4f} 秒")
52.     print(f"CSV: {csv_time:.4f} 秒")
53.     print(f"MATLAB Engine: {engine_time:.4f} 秒")
55. # 关闭MATLAB引擎
56. eng.quit()
58. # 显示结果摘要
59. print("\n性能比较摘要:")
60. for size, times in results.items():
61.     print(f"\n数组大小: {size}")
62.     fastest = min(times.items(), key=lambda x: x[1])
63.     print(f"最快的方法: {fastest[0]} ({fastest[1]:.4f} 秒)")
64.     for method, time in times.items():
65.         print(f"{method}: {time:.4f} 秒")

复制代码

大数据集处理技巧

当处理大型数据集时，以下技巧可以提高效率：

1. 使用二进制格式：对于大型数组，二进制格式（如HDF5或.mat）通常比文本格式更高效。

2. import numpy as np
3. import h5py
5. # 创建大型数组
6. large_array = np.random.rand(10000, 10000)
8. # 使用HDF5的压缩功能
9. with h5py.File('compressed_large_array.h5', 'w') as f:
10.     f.create_dataset('large_array', data=large_array, compression='gzip', compression_opts=9)

复制代码

1. 分块处理：对于非常大的数组，考虑分块处理和存储。

2. import numpy as np
3. import h5py
5. # 创建非常大的数组（这里使用较小的数组作为示例）
6. very_large_array = np.random.rand(20000, 20000)
8. # 分块保存
9. chunk_size = 5000
10. with h5py.File('chunked_large_array.h5', 'w') as f:
11.     # 创建可扩展的数据集
12.     maxshape = (None, very_large_array.shape[1])
13.     chunks = (chunk_size, very_large_array.shape[1])
14.     dset = f.create_dataset('chunked_array',
15.                            shape=(0, very_large_array.shape[1]),
16.                            maxshape=maxshape,
17.                            chunks=chunks,
18.                            compression='gzip')
19.    
20.     # 分块写入数据
21.     for i in range(0, very_large_array.shape[0], chunk_size):
22.         end = min(i + chunk_size, very_large_array.shape[0])
23.         # 扩展数据集
24.         dset.resize((end, very_large_array.shape[1]))
25.         # 写入数据块
26.         dset[i:end, :] = very_large_array[i:end, :]

复制代码

1. 使用内存映射：对于非常大的数组，使用内存映射可以避免一次性加载整个数组到内存。

2. import numpy as np
4. # 创建大型数组并保存为内存映射文件
5. large_array = np.random.rand(10000, 10000)
6. np.save('large_array_mmap.npy', large_array)
8. # 使用内存映射加载数据
9. mmap_array = np.load('large_array_mmap.npy', mmap_mode='r')
11. # 现在可以按需访问数据，而不需要一次性加载整个数组
12. subset = mmap_array[1000:2000, 1000:2000]
13. print("子集形状:", subset.shape)

复制代码

内存优化建议

1. 选择适当的数据类型：使用最小的数据类型来满足您的精度需求。

2. import numpy as np
4. # 使用默认数据类型（float64）
5. array_float64 = np.random.rand(1000, 1000)
6. print("float64数组大小 (MB):", array_float64.nbytes / (1024 * 1024))
8. # 使用较小的数据类型（float32）
9. array_float32 = np.random.rand(1000, 1000).astype(np.float32)
10. print("float32数组大小 (MB):", array_float32.nbytes / (1024 * 1024))
12. # 如果数据是整数，使用整数类型
13. array_int32 = np.random.randint(0, 1000, size=(1000, 1000), dtype=np.int32)
14. print("int32数组大小 (MB):", array_int32.nbytes / (1024 * 1024))

复制代码

1. 删除不需要的变量：在处理大型数据集时，及时删除不再需要的变量以释放内存。

2. import numpy as np
3. import gc
5. # 创建大型数组
6. large_array = np.random.rand(10000, 10000)
8. # 处理数据
9. processed_data = large_array * 2
11. # 删除原始数组以释放内存
12. del large_array
13. gc.collect()  # 强制垃圾回收
15. print("处理后数据形状:", processed_data.shape)

复制代码

1. 使用生成器：对于可以逐块处理的数据，使用生成器可以减少内存使用。

2. import numpy as np
4. def array_generator(total_size, chunk_size):
5.     """生成大型数组的块"""
6.     for i in range(0, total_size, chunk_size):
7.         end = min(i + chunk_size, total_size)
8.         yield np.random.rand(end - i, 1000)
10. # 处理大型数组而不一次性加载到内存
11. total_size = 100000
12. chunk_size = 10000
13. result = np.zeros((total_size, 1000))
15. current_row = 0
16. for chunk in array_generator(total_size, chunk_size):
17.     # 处理每个块
18.     processed_chunk = chunk * 2
19.    
20.     # 将结果存储在预分配的数组中
21.     end_row = current_row + processed_chunk.shape[0]
22.     result[current_row:end_row, :] = processed_chunk
23.     current_row = end_row
25. print("结果数组形状:", result.shape)

复制代码

常见问题和解决方案

在将NumPy数组导出到MATLAB时，可能会遇到各种问题。本节将讨论一些常见问题及其解决方案。

数据类型不匹配

Python和MATLAB支持的数据类型不完全相同，这可能导致类型不匹配问题。

问题：NumPy的复数数组在MATLAB中可能无法正确识别。

2. import numpy as np
3. from scipy.io import savemat
5. # 创建复数数组
6. complex_array = np.random.rand(5, 5) + 1j * np.random.rand(5, 5)
7. print("Python中的复数数组:")
8. print(complex_array)
9. print("数据类型:", complex_array.dtype)
11. # 直接保存
12. savemat('complex_data.mat', {'complex_array': complex_array})

复制代码

解决方案：确保复数数组以MATLAB可识别的格式保存。

2. import numpy as np
3. from scipy.io import savemat
5. # 创建复数数组
6. complex_array = np.random.rand(5, 5) + 1j * np.random.rand(5, 5)
8. # 确保数据类型是complex128（MATLAB的复数格式）
9. complex_array = complex_array.astype(np.complex128)
11. # 保存时指定复数格式
12. savemat('complex_data_fixed.mat', {'complex_array': complex_array},
13.         do_compression=True, oned_as='row')

复制代码

在MATLAB中验证：

2. % 加载复数数据
3. data = load('complex_data_fixed.mat');
5. % 检查数据类型
6. disp('数据类型:');
7. disp(class(data.complex_array));
9. % 检查是否为复数
10. disp('是否为复数:');
11. disp(iscomplex(data.complex_array));
13. % 显示数据
14. disp('复数数组:');
15. disp(data.complex_array(1:3, 1:3));

复制代码

维度顺序问题

NumPy使用行优先（C风格）的内存布局，而MATLAB使用列优先（Fortran风格）的布局，这可能导致数组在传输后看起来被转置。

问题：NumPy数组在MATLAB中显示为转置。

2. import numpy as np
3. from scipy.io import savemat
5. # 创建一个明显的非对称数组
6. asymmetric_array = np.array([[1, 2, 3], [4, 5, 6]])
7. print("Python中的原始数组:")
8. print(asymmetric_array)
10. # 保存数组
11. savemat('asymmetric_data.mat', {'asymmetric_array': asymmetric_array})

复制代码

解决方案：在保存前转置数组，或在MATLAB中加载后转置。

2. import numpy as np
3. from scipy.io import savemat
5. # 创建一个明显的非对称数组
6. asymmetric_array = np.array([[1, 2, 3], [4, 5, 6]])
7. print("Python中的原始数组:")
8. print(asymmetric_array)
10. # 方法1：在保存前转置
11. transposed_array = asymmetric_array.T
12. savemat('asymmetric_data_transposed.mat', {'asymmetric_array': transposed_array})
14. # 方法2：使用oned_as参数
15. savemat('asymmetric_data_oned.mat', {'asymmetric_array': asymmetric_array}, oned_as='column')

复制代码

在MATLAB中验证：

2. % 加载数据
3. data_transposed = load('asymmetric_data_transposed.mat');
4. data_oned = load('asymmetric_data_oned.mat');
6. % 显示转置后的数据
7. disp('方法1（Python中转置）:');
8. disp(data_transposed.asymmetric_array);
10. % 显示使用oned_as参数的数据
11. disp('方法2（使用oned_as参数）:');
12. disp(data_oned.asymmetric_array);

复制代码

特殊值处理

NumPy和MATLAB对特殊值（如NaN、Inf）的处理方式可能不同。

问题：特殊值在传输后可能丢失或改变。

2. import numpy as np
3. from scipy.io import savemat
5. # 创建包含特殊值的数组
6. special_array = np.array([1.0, np.nan, np.inf, -np.inf, 2.0])
7. print("Python中的特殊值数组:")
8. print(special_array)
10. # 保存数组
11. savemat('special_values.mat', {'special_array': special_array})

复制代码

解决方案：确保特殊值以MATLAB可识别的格式保存。

2. import numpy as np
3. from scipy.io import savemat
5. # 创建包含特殊值的数组
6. special_array = np.array([1.0, np.nan, np.inf, -np.inf, 2.0], dtype=np.float64)
8. # 保存数组，确保使用IEEE浮点格式
9. savemat('special_values_fixed.mat', {'special_array': special_array},
10.         format='5')  # 使用MATLAB v5格式，确保兼容性

复制代码

在MATLAB中验证：

2. % 加载特殊值数据
3. data = load('special_values_fixed.mat');
5. % 显示数据
6. disp('特殊值数组:');
7. disp(data.special_array);
9. % 检查特殊值
10. disp('NaN索引:');
11. disp(isnan(data.special_array));
13. disp('Inf索引:');
14. disp(isinf(data.special_array));
16. disp('-Inf索引:');
17. disp(data.special_array == -Inf);

复制代码

结构体和单元格数组处理

Python的字典和列表与MATLAB的结构体和单元格数组不完全对应，这可能导致数据结构在传输后发生变化。

问题：Python的嵌套字典在MATLAB中可能无法正确转换为结构体。

2. import numpy as np
3. from scipy.io import savemat
5. # 创建嵌套字典
6. nested_dict = {
7.     'person1': {
8.         'name': 'John',
9.         'age': 30,
10.         'scores': np.array([85, 90, 78])
11.     },
12.     'person2': {
13.         'name': 'Alice',
14.         'age': 25,
15.         'scores': np.array([92, 88, 95])
16.     }
17. }
19. # 尝试保存嵌套字典
20. try:
21.     savemat('nested_dict.mat', {'people': nested_dict})
22.     print("嵌套字典保存成功")
23. except Exception as e:
24.     print(f"保存嵌套字典时出错: {e}")

复制代码

解决方案：将嵌套字典转换为MATLAB兼容的结构。

2. import numpy as np
3. from scipy.io import savemat
5. # 创建嵌套字典
6. nested_dict = {
7.     'person1': {
8.         'name': 'John',
9.         'age': 30,
10.         'scores': np.array([85, 90, 78])
11.     },
12.     'person2': {
13.         'name': 'Alice',
14.         'age': 25,
15.         'scores': np.array([92, 88, 95])
16.     }
17. }
19. # 转换为MATLAB兼容的结构
20. matlab_struct = []
21. for person_key, person_data in nested_dict.items():
22.     person_struct = {
23.         'name': person_data['name'],
24.         'age': person_data['age'],
25.         'scores': person_data['scores']
26.     }
27.     matlab_struct.append(person_struct)
29. # 保存转换后的结构
30. savemat('people_struct.mat', {'people': matlab_struct})
31. print("结构体数据保存成功")

复制代码

在MATLAB中验证：

2. % 加载结构体数据
3. data = load('people_struct.mat');
5. % 显示结构体信息
6. disp('结构体数组长度:');
7. disp(length(data.people));
9. % 显示第一个人的信息
10. disp('第一个人的姓名:');
11. disp(data.people(1).name);
13. disp('第一个人的年龄:');
14. disp(data.people(1).age);
16. disp('第一个人的分数:');
17. disp(data.people(1).scores);

复制代码

结论

本文详细介绍了将Python NumPy数组导出到MATLAB环境的多种方法，包括使用scipy.io的.savemat/.loadmat函数、MATLAB Engine API for Python、HDF5格式以及CSV/文本文件。每种方法都有其优缺点，适用于不同的场景。

对于简单的数据交换，scipy.io.savemat/loadmat是最直接的选择，它易于使用且支持多种数据类型。如果需要在Python和MATLAB之间进行实时交互，MATLAB Engine API提供了强大的功能，但需要更多的系统资源。对于大型数据集，HDF5格式是最佳选择，它支持高效存储和访问复杂的数据结构。而CSV或文本文件则适合简单的数据交换和人类可读的需求。

在实际应用中，选择哪种方法取决于您的具体需求，包括数据大小、复杂性、性能要求以及工作流程。通过本文提供的技巧和最佳实践，您可以实现Python和MATLAB之间的无缝数据交换，提高工作效率，充分利用这两个强大工具的优势。

无论您是研究人员、数据分析师还是工程师，掌握这些数据交换技巧都将帮助您更有效地在Python和MATLAB环境中工作，实现跨平台的数据分析和可视化。