在matlab中创建类似字典的数据结构方式_Python

matlab中创建类似字典的数据结构

Matlab中创建struct：

				?

									d = struct('a','1','b','2')

在Matlab中通过字符串形式的fieldname来查找value（Using Dynamic FielNames）：

				?

									d.('a')

									d.('b')

在Matlab中修改已经存在的field的value：

				?

									d.('b')='9'

在Matlab中添加新的field：

				?

									d.('c')='3'

在Matlab中删除stuct的field：

				?

									d=struct('b', '9','c', '3', 'a', '1')

									d=rmfield(b,'9')

在Matlab中删除struct所有field：

				?

									d=struct()

matlab基本数据结构说明

Matlab作为早期的科研软件之一，对数据的处理有强大的功能。最近需要做信号处理相关的部分，将之前对Matlab不熟悉的数据操作熟悉一下。

最后准备附上Numpy中对两者之间基本操作的比较。

1、基本数据结构总览（仅含常用类型）

在matlab中创建类似字典的数据结构方式

2、数值类型基本操作

2.1 数据变量的创建

double是Matlab的默认数据类型，基本上可以满足大部分的计算任务。single和double的创建方式一致

				?

									%% 创建数组

									x = 10;

									Y = double(x);  % 转换为double型数组

									y = 10;

									%% 查看数据类型

									class(Y)

2.2 查看数据类型和值

函数名称	函数功能
isinteger	确定输入是否为整数数组
isfloat	确定输入是否为浮点数组
isnumeric	确定输入是否为数值数组
isnan	确定那些数组为NaN
class	查看数据类型

注：以上函数的返回值均为0（结果为假）或1（结果为真）

3、字符和字符串

3.1 字符串创建

				?

									% 创建字符串

									str = "Hello, world"

									>>> str =

									"Hello, world"

									% 创建字符串数组

									str = ["Mercury" "Gemini" "Apollo";

									       "Skylab" "Skylab B" "ISS"]

									>>> str = 2x3 string

									    "Mercury"    "Gemini"      "Apollo"

									    "Skylab"     "Skylab B"    "ISS"

									% 传入参数转换为字符串数组

									str = string(A)   % 将输入的数组转换为字符串数组

									str = string(A, datetFmt)   % 将传入的A转换指定的时间格式，所以传入的A是datetime或者duration

A的输入格式决定了如何将A转换字符串数组

输入类型	转换说明	示例输入	示例输出
char	每一行变为字符串的一个标量	1×3 char array 'foo'	1×1 string array "foo"
cell	元胞数组的每一个元素都转换为1 * 1的字符串	{137,'foo'}	["137" "foo"]
数值数组	相当于compose的%g格式	[137 3.1e-3 8.5e-6]	["137" "0.0031" "8.5e-06"]
datetime	要指定格式和区域设置	datetime(2020,6,1)	"01-Jun-2020"
逻辑数组	logical 函数不接受字符串输入，因此转换是单向的。	logical([0 1])	["false" "true"]

注：在matlab中要区分字符和字符串的差异。

示例：

				?

									% A表示的是字符向量

									A = 'Four score and seven years ago'

									c = size(A)   

									>>> c = 1×2

									     1    30

									str = string(A)

									s = size(str)

									>>> s = 1×2

									     1     1

									% 通过strlength可求的str中字符串的长度

									n = strlength(str)

									>>> n = 30

									% 转换元胞数组

									A = {'Mercury','Gemini','Apollo';...

									     'Skylab','Skylab B','ISS'}

									>>> A = 2x3 cell

									    {'Mercury'}    {'Gemini'  }    {'Apollo'}

									    {'Skylab' }    {'Skylab B'}    {'ISS'   }

									str = string(A)

									>>> str = 2x3 string

									    "Mercury"    "Gemini"      "Apollo"

									    "Skylab"     "Skylab B"    "ISS"

									% 转换表示数字的字符串

									str = ["256","3.1416","8.9e-3"]

									>>> str = 1x3 string

									    "256"    "3.1416"    "8.9e-3"

									X = double(str)

									>>> X = 1×3

									  256.0000    3.1416    0.0089

									Y = str2double(str)

									>>>Y = 1×3

									  256.0000    3.1416    0.0089

注：

1、erase可以删除字符串中的指定符号

2、str2double适用于输入参数可能是字符串数组、字符向量或字符向量元胞数组，本质上说明str2double对字符串的转换有更加广泛的适用

3.2 字符串数组的访问

按照数组访问的方式对字符串进行访问，可通过下标的方式对数组进行切片和访问。

4、结构体

结构体数组是使用名为字段的数据容器将相关数据组合在一起的数据类型。每个字段都可以包含任意类型的数据。可以使用structName.fieldName 格式的圆点表示法来访问字段中的数据。

形式上和Python的字典的创建方式类似。但是数组的维度取决于对应值的形式，通过字段名的方式对相应的value进行访问。

4.1 创建结构体

				?

									%% 创建一个字段的结构体

									field = 'f';

									value = {'some text';

									         [10, 20, 30];

									         magic(5)};

									s = struct(field,value)

									% 查看每个元素在内容

									>>> ans =

									'some text'

									ans = 1×3

									    10    20    30

									ans = 5×5

									    17    24     1     8    15

									    23     5     7    14    16

									     4     6    13    20    22

									    10    12    19    21     3

									    11    18    25     2     9

									%% 创建多个字段的结构体

									field1 = 'f1';  value1 = zeros(1,10);

									field2 = 'f2';  value2 = {'a', 'b'};

									field3 = 'f3';  value3 = {pi, pi.^2};

									field4 = 'f4';  value4 = {'fourth'};

									s = struct(field1,value1,field2,value2,field3,value3,field4,value4)

									>>> s=1×2 struct array with fields:

									    f1

									    f2

									    f3

									    f4

									% 输出上述字段的结果

									>>> s(1)

									ans = struct with fields:

									    f1: [0 0 0 0 0 0 0 0 0 0]

									    f2: 'a'

									    f3: 3.1416

									    f4: 'fourth'

									>>> s(2)

									ans = struct with fields:

									    f1: [0 0 0 0 0 0 0 0 0 0]

									    f2: 'b'

									    f3: 9.8696

									    f4: 'fourth'

									%% 创建空字段的结构体

									s = struct('f1','a','f2',[])

									>>> s = struct with fields:

									    f1: 'a'

									    f2: []

									%% 创建包含元胞数组的字段

									field = 'mycell';

									value = {{'a','b','c'}};

									s = struct(field,value)

									>>> s = struct with fields:

									    mycell: {'a'  'b'  'c'}

注：创建多个字段的结构体时value2 和 value3 的元胞数组是 1×2 数组，因此 s 也是 1×2 数组。因为 value1 是数值数组而不是元胞数组，所以 s(1).f1 和 s(2).f1 具有相同的内容。

类似地，因为 value4 的元胞数组具有单一元素，所以 s(1).f4 和 s(2).f4 具有相同的内容。

4.2 结构体中的函数

函数名称	函数功能
struct	创建按结构体数组
fieldnames	结构体的字段名称
getfield	胡哦去结构体数组字段
isfield	确定输入是否为结构体数组字段
orderfields	结构体数组的字段顺序
rmfield	删除结构体中的字段
setfield	为结构体数组字段赋值
table2struct	将表转换为结构体数组
struct2table	将结构体数组转换为表
cell2struct	将元胞数组转换为结构体数组
struct2cell	将结构体转换为元胞数组

5 元胞数组

5.1 创建与访问

创建空字符串

				?

									a = cell()

									a = {}

5.2 转换和检查数据类型

从元胞转换

函数名称	函数功能
cell2mat	将元胞数组转换为普通数组
cell2struct	将元胞数组转换为结构体

注：

元胞数组中的结构体转换为结构体数组时，结构体必须包含相同的字段（结构体的类型有点像Python中的键值的方式，只是访问的方式不同）

转换为元胞

函数名称	函数功能
cellstr	将字符向量转变为元胞数组
mat2cell	将数组转换包含子数组的元胞数组.原始数组可通过参数dimNDist划分为更小的数组。
num2cell	将数组转换为相同大小的元胞数组
struct2cell	将结构体转换为元胞数组
table2cell	将表转换为元胞数组。元胞数组中不含字段名称。通过fieldnames函数可以得到原始结构体的字段名称

5.3 元胞数组的操作

将元胞添加到元胞数组

				?

									C = {1, 2, 3}

									>>> C=1×3 cell array

									    {[1]}    {[2]}    {[3]}

									C{4,4} = 44

									>>> C=4×4 cell array

									    {[       1]}    {[       2]}    {[       3]}    {0x0 double}

									    {0x0 double}    {0x0 double}    {0x0 double}    {0x0 double}

									    {0x0 double}    {0x0 double}    {0x0 double}    {0x0 double}

									    {0x0 double}    {0x0 double}    {0x0 double}    {[      44]}

对元胞数组的访问

对元胞切片用圆括号（）来访问
使用花括号{}对特定的内容进行访问

				?

									C = {'one', 'twC=2×3 cell array

									>>> C=2×3 cell array

									    {'one'}    {'two'}    {'three'}

									    {[  1]}    {[  2]}    {[    3]}

通过（）切片

				?

									upperLeft = C(1:2,1:2)

									>>> upperLeft=2×2 cell array

									    {'one'}    {'two'}

									    {[  1]}    {[  2]}

通过切片修改值

				?

									% 修改第1行 1，2，3列的值

									C(1,1:3) = {'first','second','third'}

									>>> C=2×3 cell array

									    {'first'}    {'second'}    {'third'}

									    {[    1]}    {[     2]}    {[    3]}

将元胞中的数值数据抓换为数值数组

				?

									numericCells = C(2,1:3)

									>>> numericCells=1×3 cell array

									    {[1]}    {[2]}    {[3]}

									numericVector = cell2mat(numericCells)

									>>> numericVector = 1×3

									     1     2     3

通过{}对元胞的特定内容访问 / 或者修改特定内容的值

				?

									% 访问元胞的值

									last = C{2,3}

									>>> last = 3

									C{2,3} = 300

									>>> C=2×3 cell array

									    {'first'}    {'second'}    {'third'}

									    {[    1]}    {[     2]}    {[  300]}

访问某一行的值并保存到数值数组中

				?

									% 访问数组中某一行的值并转换为数值数组

									nums = [C{2,:}]

									>>> nums = 1×3

									     1     2   300

访问元胞的多级索引

				?

									myNum = [1, 2, 3];

									myCell = {'one', 'two'};

									myStruct.Field1 = ones(3);

									myStruct.Field2 = 5*ones(5);

									C = {myNum, 100*myNum;

									     myCell, myStruct}

									>>> C=2×2 cell array

									    {[ 1 2 3]}    {[100 200 300]}

									    {1x2 cell}    {1x1 struct   }

									% 访问元胞的内容

									C{1,2}

									>>> ans = 1×3

									   100   200   300

									c{1, 2}(1, 2)

									>>> ans = 2

									C{2,1}{1,2}

									>>> ans = 'two'