setdiff

两个数据集的差集

全页折叠

语法

C = setdiff(A,B)

C = setdiff(A,B,setOrder)

C = setdiff(A,B,___,'rows')

C = setdiff(A,B,'rows',___)

[C,ia] = setdiff(___)

[C,ia] = setdiff(A,B,'legacy')

[C,ia] = setdiff(A,B,'rows','legacy')

说明

C = setdiff(A,B) 返回 A 中存在但 B 中不存在的数据，不包含重复项。C 是有序的。

如果 A 和 B 为表或时间表，则 setdiff 返回 A 中存在但 B 中不存在的行。对于时间表，setdiff 在确定相等性时会考虑行时间，并按行时间对输出时间表 C 进行排序。

示例

C = setdiff(A,B,setOrder) 以特定顺序返回 C。setOrder 可以是 'sorted' 或 'stable'。

示例

C = setdiff(A,B,___,'rows') 和 C = setdiff(A,B,'rows',___) 将 A 和 B 的每一行都视为单个实体，并返回 A 中存在但 B 中不存在的行，不包括重复项。必须指定 A 和 B，setOrder 是可选的。

'rows' 选项不支持元胞数组，除非其中一个输入项为分类数组或日期时间数组。

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

通常，C = A(ia)。
如果指定了 'rows' 选项，则 C = A(ia,:)。
如果 A 和 B 是表或时间表，则 C = A(ia,:)。

示例

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

'legacy' 选项不支持分类数组、日期时间数组、持续时间数组、表或时间表。

示例

全部折叠

两个向量的差集

打开实时脚本

定义都包含某些值的两个向量。

A = [3 6 2 1 5 1 1]; 
B = [2 4 6];

查找 A 中存在，但 B 中不存在的值。

C = setdiff(A,B)

C = 1×3

     1     3     5

两个表的差集

打开实时脚本

定义都包含某些行的两个表。

A = table([1:5]',["A";"B";"C";"D";"E"],logical([0;1;0;1;0]))

A=5×3 table
    Var1    Var2    Var3 
    ____    ____    _____

     1      "A"     false
     2      "B"     true 
     3      "C"     false
     4      "D"     true 
     5      "E"     false

B = table([1:2:10]',["A";"C";"E";"G";"I"],logical(zeros(5,1)))

B=5×3 table
    Var1    Var2    Var3 
    ____    ____    _____

     1      "A"     false
     3      "C"     false
     5      "E"     false
     7      "G"     false
     9      "I"     false

查找 A 中存在，但 B 中不存在的行。

C = setdiff(A,B)

C=2×3 table
    Var1    Var2    Var3 
    ____    ____    _____

     2      "B"     true 
     4      "D"     true

两个向量的差集以及不同值的索引

打开实时脚本

定义都包含某些值的两个向量。

A = [3 6 2 1 5 1 1]; 
B = [2 4 6];

查找 A 中存在，但 B 中不存在的值以及索引向量 ia，以使 C = A(ia)。

[C,ia] = setdiff(A,B)

C = 1×3

     1     3     5

两个表的差集以及不同行的索引

打开实时脚本

定义表 A，其中包含五个人是否为吸烟者、其年龄和身高信息。

A = table([true;true;false;true;false],[27;52;31;46;35],[74;68;64;61;64], ...
VariableNames=["Smoker" "Age" "Height"], ...
RowNames=["Sanchez" "Brown" "Wu" "Murphy" "Johnson"])

A=5×3 table
               Smoker    Age    Height
               ______    ___    ______

    Sanchez    true      27       74  
    Brown      true      52       68  
    Wu         false     31       64  
    Murphy     true      46       61  
    Johnson    false     35       64

定义一个表 B，其中包含与 A 相同的变量。

B = table([false;true;false;false],[64;68;62;58],[31;47;35;23], ...
VariableNames=["Smoker" "Height" "Age"], ...
RowNames=["Smith" "Cheng" "Lee" "Jones"])

B=4×3 table
             Smoker    Height    Age
             ______    ______    ___

    Smith    false       64      31 
    Cheng    true        68      47 
    Lee      false       62      35 
    Jones    false       58      23

查找 A 中存在，但 B 中不存在的行以及索引向量 ia，以使 C = A(ia,:)。具有相同值但不同行名称的两个行被视为相等。因此，Wu、A(3,:)、Smith 和 B(1,:) 的行是相等的。输出表 C 不包含任何一行。C 的行先按 Smoker 排序，然后按 Age 排序。

[C,ia] = setdiff(A,B)

C=4×3 table
               Smoker    Age    Height
               ______    ___    ______

    Johnson    false     35       64  
    Sanchez    true      27       74  
    Murphy     true      46       61  
    Brown      true      52       68

两个矩阵中的行的差集

打开实时脚本

定义都包含某些行的两个矩阵。

A = [7 9 7; 0 0 0; 7 9 7; 5 5 5; 1 4 5];
B = [0 0 0; 5 5 5];

查找 A 中存在，但 B 中不存在的行以及索引向量 ia，以使 C = A(ia,:)。

[C,ia] = setdiff(A,B,'rows')

C = 2×3

     1     4     5
     7     9     7

具有指定输出顺序的两个向量的差集

打开实时脚本

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

当 C 中的值的顺序很重要时，指定 'stable' 或 'sorted'。

A = [3 6 2 1 5 1 1]; 
B = [2 4 6];
[C,ia] = setdiff(A,B,'stable')

C = 1×3

     3     1     5

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

 [C,ia] = setdiff(A,B,'sorted')

C = 1×3

     1     3     5

包含 NaN 的向量的差集

打开实时脚本

定义两个包含 NaN 的向量。

A = [5 NaN NaN]; 
B = [5 NaN];

计算 A 和 B 的差集。

C = setdiff(A,B)

C = 1×2

   NaN   NaN

setdiff 将 NaN 值视为不同的值。

带有尾随空白的字符向量元胞数组

打开实时脚本

创建字符向量元胞数组 A。

A = {'dog','cat','fish','horse'};

创建字符向量元胞数组 B，其中某些向量带有尾随空白。

B = {'dog ','cat','fish ','horse'};

查找 A 中存在但 B 中不存在的字符向量。

[C,ia] = setdiff(A,B)

C = 1×2 cell
    {'dog'}    {'fish'}

setdiff 将字符向量元胞数组中的尾随空白视为不同的字符。

字符和字符向量元胞数组的差集

打开实时脚本

创建字符向量 A。

A = ['cat';'dog';'fox';'pig'];
class(A)

ans = 
'char'

创建字符向量元胞数组 B。

B={'dog','cat','fish','horse'};
class(B)

ans = 
'cell'

查找 A 中存在但 B 中不存在的字符向量。

C = setdiff(A,B)

C = 2×1 cell
    {'fox'}
    {'pig'}

结果 C 是字符向量元胞数组。

class(C)

ans = 
'cell'

保留 setdiff 的旧版行为

打开实时脚本

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

计算 A 和 B 的差集并保留当前行为。

A = [3 6 2 1 5 1 1]; 
B = [2 4 6];
[C1,ia1] = setdiff(A,B)

C1 = 1×3

     1     3     5

计算 A 和 B 的差集并保留旧版行为。

[C2,ia2] = setdiff(A,B,'legacy')

C2 = 1×3

     1     3     5

ia2 = 1×3

     7     1     5

输入参数

全部折叠

`A,B` — 输入数组
数组

输入数组。如果指定 'rows' 选项，则 A 和 B 的列数必须相同。

A 和 B 必须属于同一类，以下情况例外：

logical、char 和所有数值类可以与 double 数组合并。
字符串数组可以与字符向量和字符向量元胞数组合并。
分类数组可以与字符串标量和字符向量结合使用。
日期和时间和持续时间数组可以与格式化为表示日期和时间的字符串标量和字符向量结合使用。

根据数据类型，对 A 和 B 还有其他要求：

如果 A 和 B 均为有序分类数组，则必须具有相同的类别集（包括其顺序）。如果 A 和 B 都不是有序分类数组，则不必具有相同的类别集，因此可使用类别名称对两者进行比较。在这种情况下，C 的类别中前面是 A 的类别，后面跟有不在 A 中的 B 的类别。类别的顺序与在 A 和 B 中的顺序相同，将使用类别顺序对 C 进行排序。
如果 A 和 B 是表或时间表，则必须具有相同的变量名称（顺序除外）。对于表，将忽略行名称，所以值相同而名称不同的两行将被视为相等。对于时间表，将考虑行时间，所以值相同而时间不同的两行将被视为不相等。
如果 A 和 B 是日期时间数组，则这两个数组必须或者都指定时区，或者都未设置时区。

A 和 B 还可以是具有以下类方法的对象：

sort（或 'rows' 选项的 sortrows）
eq
ne

对象类方法彼此之间必须一致。这些对象包括从相同根类导出的异构数组。例如，A 和 B 可以是图形对象的句柄数组。

`setOrder` — 顺序标志
`'sorted'` (默认) | `'stable'`

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

标志描述

标志	描述
`'sorted'`	按 `sort` 返回的排定顺序返回 `C` 中的值（或行）。示例 C = setdiff([4 1 3 2 5],[2 1],'sorted') C = 3 4 5
`'stable'`	按与 `A` 中相同的顺序返回 `C` 中的值（或行）。示例 C = setdiff([4 1 3 2 5],[2 1],'stable') C = 4 3 5

'sorted'

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

示例

C = setdiff([4 1 3 2 5],[2 1],'sorted')

C =

     3     4     5

'stable'

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

示例

C = setdiff([4 1 3 2 5],[2 1],'stable')

C =

     4     3     5

数据类型: char | string

输出参量

全部折叠

`C` — `A` 和 `B` 的差集
向量 | 矩阵 | 表 | 时间表

A 和 B 的差集，以向量、矩阵、表或时间表的形式返回。如果输入 A 和 B 是表或时间表，则 C 中的变量顺序与 A 中的变量顺序相同。

下面介绍了当输入为向量或矩阵并且未指定 'legacy' 标志时 C 的形状：

如果未指定 'rows' 标志并且 A 为行向量，则 C 为行向量。
如果未指定 'rows' 标志并且 A 不是行向量，则 C 为列向量。
如果指定了 'rows' 标志，则 C 是一个包含 A 中存在，但 B 中不存在的行的矩阵。
如果 A 的所有值（或行）也在 B 中，则 C 为空矩阵。

C 的类与 A 的类相同，除非：

A 是字符数组而 B 是字符向量元胞数组，在这种情况下，C 是字符向量元胞数组。
A 是字符向量、字符向量元胞数组或字符串，而 B 是分类数组，在这种情况下，C 是分类数组。
A 是字符向量元胞数组或单个字符向量，而 B 是日期时间数组，在这种情况下，C 是日期时间数组。
A 是字符向量或字符向量元胞数组，而 B 是字符串数组，在这种情况下，C 是字符串数组。

`ia` — `A` 的索引
列向量

A 的索引，当未指定 'legacy' 标志时以列向量的形式返回。ia 标识 A 中存在，但 B 中不存在的值（或行）。如果有仅在 A 中重复出现的值（或行），则 ia 包含该值（或行）第一次出现位置的索引。

提示

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

扩展功能

全部展开

tall 数组
对行数太多而无法放入内存的数组进行计算。

setdiff 函数支持 tall 数组，但存在以下使用说明和限制：

不支持 'stable' 和 'legacy' 选项。
不支持 'char' 类型的输入。
不支持有序分类数组。

有关详细信息，请参阅tall 数组。

C/C++ 代码生成
使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

用法说明和限制：

代码生成不支持对第一个或第二个参量使用元胞数组。
如果不指定 'rows' 选项：
- 输入 A 和 B 必须为向量。如果指定 'legacy' 选项，则输入 A 和 B 必须为行向量。
- 可变大小行向量的第一个维度必须具有固定长度 1。可变大小列向量的第二个维度必须具有固定长度 1。
- 不要使用 [] 表示空集。需使用 1×0 或 0×1 输入（例如 zeros(1,0)）表示空集。
- 如果指定 'legacy' 选项，则空输出为行向量 1×0，永远不会是 0×0。
如果同时指定 'legacy' 和 'rows' 选项，则输出 ia 为列向量。如果 ia 为空，则它是 0×1。它永远不会是 0×0，即使输出 C 是 0×0。
当 setOrder 不是 'stable' 或当您指定 'legacy' 选项时，输入必须已按升序进行排序。第一个输出 C 按升序排序。
复数输入必须为 single 或 double。
如果一个输入为复数，另一个输入为实数，请执行以下操作之一：
- 将 setOrder 设置为 'stable'。
- 按复数升序（按绝对值）对实数输入进行排序。假设实数输入为 x。使用 sort(complex(x)) 或 sortrows(complex(x))。
请参阅具有零值虚部的复数数据的代码生成 (MATLAB Coder)。

GPU 代码生成
使用 GPU Coder™ 为 NVIDIA® GPU 生成 CUDA® 代码。

请参阅“C/C++ 代码生成”部分中的用法说明和限制。同样的用法说明和限制也适用于 GPU 代码生成。

基于线程的环境
使用 MATLAB® `backgroundPool` 在后台运行代码或使用 Parallel Computing Toolbox™ `ThreadPool` 加快代码运行速度。

setdiff 函数完全支持基于线程的环境。有关详细信息，请参阅在基于线程的环境中运行 MATLAB 函数。

GPU 数组
通过使用 Parallel Computing Toolbox™ 在图形处理单元 (GPU) 上运行来加快代码执行。

setdiff 函数支持 GPU 数组输入，但有以下用法说明和限制：

不支持 'legacy' 标志。
不支持 64 位整数。

有关详细信息，请参阅在 GPU 上运行 MATLAB 函数 (Parallel Computing Toolbox)。

分布式数组
使用 Parallel Computing Toolbox™ 在集群的组合内存中对大型数组进行分区。

setdiff 函数支持分布式数组输入，但有以下用法说明和限制：

不支持 'legacy' 标志。
不支持表、时间表、分类、日期时间和持续时间输入。
当 A 或 B 是字符向量元胞数组时，类型为 char 和 string 的输入不受支持。改为将字符向量输入参量的元胞数组转换为字符串数组。

有关详细信息，请参阅使用分布式数组运行 MATLAB 函数 (Parallel Computing Toolbox)。

版本历史记录

在 R2006a 之前推出

另请参阅

主题

合并分类数组

setdiff

语法

说明

示例

两个向量的差集

两个表的差集

两个向量的差集以及不同值的索引

两个表的差集以及不同行的索引

两个矩阵中的行的差集

具有指定输出顺序的两个向量的差集

包含 NaN 的向量的差集

带有尾随空白的字符向量元胞数组

字符和字符向量元胞数组的差集

保留 setdiff 的旧版行为

输入参数

A,B — 输入数组 数组

setOrder — 顺序标志 'sorted' (默认) | 'stable'

输出参量

C — A 和 B 的差集 向量 | 矩阵 | 表 | 时间表

ia — A 的索引 列向量

提示

扩展功能

tall 数组 对行数太多而无法放入内存的数组进行计算。

C/C++ 代码生成 使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

GPU 代码生成 使用 GPU Coder™ 为 NVIDIA® GPU 生成 CUDA® 代码。

基于线程的环境 使用 MATLAB® backgroundPool 在后台运行代码或使用 Parallel Computing Toolbox™ ThreadPool 加快代码运行速度。

GPU 数组 通过使用 Parallel Computing Toolbox™ 在图形处理单元 (GPU) 上运行来加快代码执行。

分布式数组 使用 Parallel Computing Toolbox™ 在集群的组合内存中对大型数组进行分区。

版本历史记录

另请参阅

主题

`A,B` — 输入数组
数组

`setOrder` — 顺序标志
`'sorted'` (默认) | `'stable'`

`C` — `A` 和 `B` 的差集
向量 | 矩阵 | 表 | 时间表

`ia` — `A` 的索引
列向量

tall 数组
对行数太多而无法放入内存的数组进行计算。

C/C++ 代码生成
使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

GPU 代码生成
使用 GPU Coder™ 为 NVIDIA® GPU 生成 CUDA® 代码。

基于线程的环境
使用 MATLAB® `backgroundPool` 在后台运行代码或使用 Parallel Computing Toolbox™ `ThreadPool` 加快代码运行速度。

GPU 数组
通过使用 Parallel Computing Toolbox™ 在图形处理单元 (GPU) 上运行来加快代码执行。

分布式数组
使用 Parallel Computing Toolbox™ 在集群的组合内存中对大型数组进行分区。