unique

唯一值

全页折叠

语法

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

说明

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

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

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

示例

C = unique(A,setOrder) 指定是否以排序顺序或稳定顺序返回 A 的唯一值。

示例

C = unique(___,occurrence) 指定对于上述任一语法，是返回重复值的第一个还是最后一个索引。

C = unique(___,"rows") 将 A 中的每一行视为单个实体，并按排序顺序返回 A 中的唯一行。当输入数据是字符向量元胞数组时，不支持 "rows" 选项。

示例

C = unique(___,"legacy") 保留 R2012b 及更早版本中 unique 函数的行为。不支持将 "legacy" 选项与 TreatMissingAsDistinct 或同时与 setOrder 和 occurrence 参量一起指定。"legacy" 选项不支持 categorical 数组、datetime 数组、duration 数组、calendarDuration 数组、表或时间表。

C = unique(___,TreatMissingAsDistinct=tf) 指定是否将缺失值视为不同的值。 (自 R2026a 起)

示例

[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,:)。

示例

示例

全部折叠

打开实时脚本

创建包含一个重复值的向量。然后，查找该向量的唯一值。

A = [9 2 9 5];
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 的唯一值并返回索引向量 ia 和 ic，使得 C = A(ia) 且 A = C(ic)。 

A = [9 2 9 5];
[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 的随机整数组成的向量。查找该向量中的唯一元素，并返回索引向量 ia 和 ic。

a = randi([1 5],200,1);
[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
打开实时脚本

创建包含一个重复值的向量。通过将集合顺序指定为 "stable"，查找向量中的唯一值，并以它们在向量中出现的相同顺序返回它们。

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

     9     2     5
打开实时脚本

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

A = [5 8 NaN NaN];
C = unique(A)
C = 1×4

     5     8   NaN   NaN

或者，将缺失值的每个实例视为一个重复值 （自 R2026a 开始提供）。

C2 = unique(A,TreatMissingAsDistinct=false)
C2 = 1×3

     5     8   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

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

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

    3.1416
    3.1416
    6.2832
    9.4248
   12.5664
   15.7080
   18.8496
   18.8496

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

Ctol = uniquetol(A)
Ctol = 6×1

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

创建一个字符串数组。查找 A 中包含的唯一字符向量。 

A = ["one" "two" "twenty-two" "One" "two"];
C = unique(A)
C = 1×4 string
    "One"    "one"    "twenty-two"    "two"
打开实时脚本

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

A = ["dog" "cat" "horse" "horse" "dog "];
C = unique(A)
C = 1×4 string
    "cat"    "dog"    "dog "    "horse"

输入参数

全部折叠

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

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

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

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

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

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

  • ne（不等于）

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

C 中返回值的顺序，指定为下表中的值之一。

值描述

"sorted"

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

"stable"

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

示例: C = unique([5 5 3 4],"sorted") 以排序顺序 C = [3 4 5] 形式返回值。

示例: C = unique([5 5 3 4],"stable") 以稳定顺序 C = [5 3 4] 形式返回值。

ia 中返回索引的出现位置，指定为下表中的值之一。

值描述
"first"如果 A 具有重复的值（或行），则 ia 包含重复值首次出现的索引。
"last"如果 A 具有重复的值（或行），则 ia 包含重复值最后一次出现的索引。

示例: [C,ia,ic] = unique([9 9 9],"first") 以 ia = 1 形式返回重复值首次出现的索引。

示例: [C,ia,ic] = unique([9 9 9],"last") 以 ia = 3 形式返回重复值最后一次出现的索引。

自 R2026a 起

将缺失值视为不同值的选项，指定为以下值之一：

  • true 或 1 - 将缺失值视为不同的值。输入数据中的缺失值的每个实例都包含在 C 中。

  • false 或 0 - 将缺失值的每个重复实例视为一个重复项。C 中包含最多一个缺失值。如果输入数据是表，或如果您指定 "rows" 选项，则 C 可能包含多个具有缺失值的行。如果若干行在同一列中具有缺失值，而在其他列中具有匹配的非缺失值，则这些行重复。

示例: C = unique(A,TreatMissingAsDistinct=false) 将缺失值的每个实例视为一个重复项。

数据类型: logical

输出参量

全部折叠

A 的唯一数据，以数组、表或时间表形式返回。C 的类与输入 A 的类相同。C 的形状取决于 A 的形状。

  • 如果您未指定 "rows" 选项，且 A 是行向量，则 C 是行向量。

  • 如果您未指定 "rows" 选项，且 A 是列向量，则 C 是列向量。

  • 如果您未指定 "rows" 选项，则 C 是包含 A 的唯一行的矩阵。

  • 如果 A 是表或时间表，则 C 是与 A 具有相同变量数的表或时间表。

A 的索引，返回含各元素首次复现处的对应索引的列向量。如果您将 occurrence 指定为 "last"，则 ia 包含重复元素最后一次出现的索引。

这些索引通常满足 C = A(ia)。如果 A 是表或时间表，或如果您指定 "rows" 选项，则 C = A(ia,:)。

C 的索引，以列向量形式返回。

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

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

  • 如果 A 是表或时间表，或如果您指定 "rows" 选项，则 A = C(ic,:)。

提示

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

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

扩展功能

全部展开

版本历史记录

在 R2006a 之前推出

全部展开

另请参阅

| | | | | | | | | |