unique

唯一值

全页折叠

语法

C = unique(A)
C = unique(A,setOrder)
C = unique(A,occurrence)
C = unique(A,setOrder,occurrence)
C = unique(A,___,'rows')
C = unique(A,'rows',___)
[C,ia,ic] = unique(___)
[C,ia,ic] = unique(A,'legacy')
[C,ia,ic] = unique(A,'rows','legacy')
[C,ia,ic] = unique(A,occurrence,'legacy')
[C,ia,ic] = unique(A,'rows',occurrence,'legacy')

说明

C = unique(A) 返回与 A 中相同的数据，但是不包含重复项。C 已排序。

  • 如果 A 是表或时间表，则 unique 按排序顺序返回 A 中的唯一行。对于时间表，当确定行是否唯一时，unique 会考虑行时间和行值，并按行时间对输出时间表 C 排序。

  • 如果 A 是分类数组，则排序顺序由类别的顺序确定。

示例

C = unique(A,setOrder) 以特定顺序返回 A 的唯一值。setOrder 可以是 'sorted'（默认值）或 'stable'。

示例

C = unique(A,occurrence) 指定遇到重复值时应返回哪个索引。occurrence 可以是 'first'（默认值）或 'last'。

C = unique(A,setOrder,occurrence) 指定顺序以及在遇到重复值时返回哪个索引。 (自 R2025a 起)

C = unique(A,___,'rows') 和 C = unique(A,'rows',___) 将 A 中的每一行视为单个实体，并按排序顺序返回 A 中的唯一行。必须指定 A，而 setOrder 和/或 occurrence 是可选的。

'rows' 选项不支持元胞数组。

示例

[C,ia,ic] = unique(___) 支持任何上述语法，且可返回索引向量 ia 和 ic。

  • 如果 A 是向量，则 C = A(ia) 且 A = C(ic)。

  • 如果 A 是矩阵或数组，则 C = A(ia) 且 A(:) = C(ic)。

  • 如果指定了 'rows' 选项，则 C = A(ia,:) 且 A = C(ic,:)。

  • 如果 A 是表或时间表，则 C = A(ia,:) 且 A = C(ic,:)。

[C,ia,ic] = unique(A,'legacy')、[C,ia,ic] = unique(A,'rows','legacy')、[C,ia,ic] = unique(A,occurrence,'legacy') 和 [C,ia,ic] = unique(A,'rows',occurrence,'legacy') 保留 R2012b 和早期版本中 unique 函数的行为。

'legacy' 选项不支持 categorical 数组、datetime 数组、duration 数组、calendarDuration 数组、表或时间表。

示例

示例

全部折叠

打开实时脚本

定义包含一个重复值的向量。 

A = [9 2 9 5];

计算 A 的唯一值。 

C = unique(A)
C = 1×3

     2     5     9
打开实时脚本

创建一个包含某些重复数据的表。 

Name = {'Fred';'Betty';'Bob';'George';'Jane'};
Age = [38;43;38;40;38];
Height = [71;69;64;67;64];
Weight = [176;163;131;185;131];
A = table(Age,Height,Weight,'RowNames',Name)
A=5×3 table
              Age    Height    Weight
              ___    ______    ______

    Fred      38       71       176  
    Betty     43       69       163  
    Bob       38       64       131  
    George    40       67       185  
    Jane      38       64       131

查找 A 的唯一行。unique 按排序顺序（依次按第一个变量 Age 和第二个变量 Height 排序）返回 A 的行。

C = unique(A)
C=4×3 table
              Age    Height    Weight
              ___    ______    ______

    Bob       38       64       131  
    Fred      38       71       176  
    George    40       67       185  
    Betty     43       69       163

在第一个变量 Age 中查找具有唯一值的表行。如果只希望一个表变量包含唯一值，可以使用 unique 返回的索引从表中提取这些行。

[C,ia] = unique(A.Age);
B = A(ia,:)
B=3×3 table
              Age    Height    Weight
              ___    ______    ______

    Fred      38       71       176  
    George    40       67       185  
    Betty     43       69       163
打开实时脚本

定义包含一个重复值的向量。 

A = [9 2 9 5];

计算 A 的唯一值以及索引向量 ia 和 ic，这样 C = A(ia) 和 A = C(ic)。 

[C, ia, ic] = unique(A)
C = 1×3

     2     5     9


ia = 3×1

     2
     4
     1


ic = 4×1

     3
     1
     3
     2
打开实时脚本

创建一个包含某些重复行的 10×3 矩阵。 

A = randi(3,10,3)
A = 10×3

     3     1     2
     3     3     1
     1     3     3
     3     2     3
     2     3     3
     1     1     3
     1     2     3
     2     3     2
     3     3     2
     3     3     1

基于前两列的数据查找 A 中的唯一行。指定三个输出以返回索引向量 ia 和 ic。

[C,ia,ic] = unique(A(:,1:2),'rows')
C = 7×2

     1     1
     1     2
     1     3
     2     3
     3     1
     3     2
     3     3


ia = 7×1

     6
     7
     3
     5
     1
     4
     2


ic = 10×1

     5
     7
     3
     6
     4
     1
     2
     4
     7
     7

使用 ia 对 A 进行索引并检索包含前两列中元素的唯一组合的行。

uA = A(ia,:)
uA = 7×3

     1     1     3
     1     2     3
     1     3     3
     2     3     3
     3     1     2
     3     2     3
     3     3     1
打开实时脚本

查找向量中的唯一元素，然后使用 accumarray 计算每个唯一元素出现的次数。

创建一个由 1 到 5 的随机整数组成的向量。

a = randi([1 5],200,1);

查找向量中的唯一元素。返回索引向量 ia 和 ic。

[C,ia,ic] = unique(a);

计算 C 中的每个元素在 a 中出现的次数。将 ic 指定为 accumarray 的第一个输入，将 1 指定为第二个输入，以便函数计算 ic 中的重复下标。汇总结果。

a_counts = accumarray(ic,1);
value_counts = [C, a_counts]
value_counts = 5×2

     1    46
     2    36
     3    38
     4    39
     5    41
打开实时脚本

使用 setOrder 参量指定 C 中值的排序方式。

如果您想要 C 中的值与 A 中的值顺序相同，请指定 'stable'。 

A = [9 2 9 5];
[C, ia, ic] = unique(A,'stable')
C = 1×3

     9     2     5


ia = 3×1

     1
     2
     4


ic = 4×1

     1
     2
     1
     3

此外，还可以指定 'sorted' 顺序。 

[C, ia, ic] = unique(A,'sorted')
C = 1×3

     2     5     9


ia = 3×1

     2
     4
     1


ic = 4×1

     3
     1
     3
     2
打开实时脚本

定义包含缺失值的向量。 

A = [5 8 NaN NaN];

查找向量中的唯一值。unique 将每个缺失值实例视为不同值。

C = unique(A)
C = 1×4

     5     8   NaN   NaN
打开实时脚本

创建向量 x。通过变换和取消变换 x 来获取第二个向量 y。此变换会向 y 中引入舍入误差。

x = (1:6)'*pi;
y = 10.^log10(x);

通过取差值来验证 x 和 y 不同。

x-y
ans = 6×1
10-14 ×

    0.0444
         0
         0
         0
         0
   -0.3553

使用 unique 找出串联向量 [x;y] 中的唯一元素。unique 函数执行精确比较，并确定 x 中有些值与 y 中的值不完全相等。这些值与那些在 x-y 中具有非零差分的元素是同一批元素。因此，c 中包含一些貌似重复的值（实际上有细微差异）。

c = unique([x;y])
c = 8×1

    3.1416
    3.1416
    6.2832
    9.4248
   12.5664
   15.7080
   18.8496
   18.8496

使用 uniquetol 应用一个较小的容差执行比较。uniquetol 会将处于容差范围内的元素视为相等。

C = uniquetol([x;y])
C = 6×1

    3.1416
    6.2832
    9.4248
   12.5664
   15.7080
   18.8496
打开实时脚本

创建字符向量元胞数组。 

A = {'one','two','twenty-two','One','two'};

查找 A 中包含的唯一字符向量。 

C = unique(A)
C = 1×4 cell
    {'One'}    {'one'}    {'twenty-two'}    {'two'}
打开实时脚本

创建一个字符串数组，其中一些字符串具有尾随空白。

A = ["dog" "cat" "horse" "horse" "dog "];

查找字符串数组中的唯一字符串。unique 将具有尾随空白的字符串视为不同字符串。

C = unique(A)
C = 1×4 string
    "cat"    "dog"    "dog "    "horse"
打开实时脚本

在代码中使用 'legacy' 标志以保留 R2012b 和早期版本中 unique 的行为。

计算 A 的唯一元素并保留当前行为。 

A = [9 2 9 5];
[C1, ia1, ic1] = unique(A)
C1 = 1×3

     2     5     9


ia1 = 3×1

     2
     4
     1


ic1 = 4×1

     3
     1
     3
     2

计算 A 的唯一元素并保留旧版行为。 

[C2, ia2, ic2] = unique(A, 'legacy')
C2 = 1×3

     2     5     9


ia2 = 1×3

     2     4     3


ic2 = 1×4

     3     1     3     2

输入参数

全部折叠

输入数据，指定为数组、表或时间表。

  • 如果 A 是表，则 unique 不会考虑行名称。值相同而名称不同的两行将被视为相等。

  • 如果 A 是时间表，则 unique 会考虑行时间。值相同而时间不同的两行不会被视为相等。

  • 如果 A 是分类数组，则排序顺序由类别的顺序确定。要查看分类数组的排序顺序，请使用 categories 函数。

A 也可以是具有以下类方法的对象：

  • sort（如果指定 'rows' 选项，则为 sortrows）

  • ne（不等于）

方法不能具有冲突的行为或结果。sort 或 sortrows 必须使用稳定的排序算法。例如，可以将 A 指定为派生自公共根类的异构数组，例如图形对象数组。

顺序标志以 'sorted' 或 'stable' 指定，指示 C 中值（或行）的顺序。

标志描述

'sorted'

按 sort 返回的排定顺序返回 C 中的值（或行）。

示例

C = unique([5 5 3 4],'sorted')
C =

     3     4     5

'stable'

按与 A 中相同的顺序返回 C 中的值（或行）。

示例

C = unique([5 5 3 4],'stable')
C =

     5     3     4

数据类型: char | string

出现次数标志，指定为 'first' 或 'last'，指示在 A 中发现重复值时，ia 是包含第一个索引还是最后一个索引。

出现次数标志含义
'first'如果 A 中有重复的值（或行），则 ia 包含第一次出现重复值的索引。例如：[C,ia,ic] = unique([9 9 9],'first') 返回 ia = 1。这是默认行为。
'last'如果 A 中有重复的值（或行），则 ia 包含最后一次出现重复值的索引。例如：[C,ia,ic] = unique([9 9 9],'last','legacy') 返回 ia = 3。这是指定了 'legacy' 标志时的默认行为。

数据类型: char | string

输出参量

全部折叠

A 的唯一数据，以数组形式返回。C 的类与输入 A 的类相同。C 的形状取决于输入是向量还是矩阵：

  • 如果未指定 'rows' 标志并且 A 为行向量，则 C 为行向量。

  • 如果未指定 'rows' 标志并且 A 不是行向量，则 C 为列向量。

  • 如果指定了 'rows' 标志，则 C 是一个包含 A 的唯一行的矩阵。

A 的索引，返回含各元素首次复现处的对应索引的列向量。如果指定了 'legacy' 标志，则 ia 是一个行向量，它包含元素最后复现处的对应索引。

这些索引通常满足 C = A(ia)。如果 A 是一个表，或者如果指定了 'rows' 选项，则 C = A(ia,:)。

C 的索引，当未指定 'legacy' 标志时以列向量的形式返回。ic 包含满足以下属性的索引。

  • 如果 A 是向量，则 A = C(ic)。

  • 如果 A 是矩阵或数组，则 A(:) = C(ic)。

  • 如果 A 是一个表，或者如果指定了 'rows' 选项，则 A = C(ic,:)。

提示

  • 使用 uniquetol，可以利用容差查找唯一的浮点数。

  • 要查找表或时间表中与变量子集相关的唯一行，可以使用列下标。例如，可以使用 unique(A(:,vars))，其中 vars 为正整数、正整数向量、变量名称、变量名称元胞数组或逻辑向量。您也可以使用 vartype 创建一个下标，以选择指定类型的变量。

扩展功能

全部展开

版本历史记录

在 R2006a 之前推出

全部展开

另请参阅

| | | | | | | | |