本页翻译不是最新的。点击此处可查看最新英文版本。

join

使用键变量按行合并两个表或时间表

全页折叠

语法

T = join(Tleft,Tright)
T = join(Tleft,Tright,Name,Value)
[T,iright] = join(___)

说明

T = join(Tleft,Tright) 通过合并来自两个输入的行来组合表或时间表 Tleft 和 Tright。join 函数执行简单形式的联接操作，其中 Tleft 的每行都必须与 Tright 中的一行完全匹配。当键变量中的对应值相同时，行匹配。输出将 Tleft 中的所有行与 Tright 中键变量具有匹配值的行组合在一起。

例如，如果 Tleft 具有名为 Key1 和 Var1 的变量，Tright 具有变量 Key1 和 Var2，则 T=join(Tleft,Tright) 使用 Key1 作为键变量。

The output T has variables Key1, Var1, and Var2, and combines all rows from Tleft with the rows from Tright where Key1 has matching values in Tleft.

默认情况下，键变量是：

  • 在 Tleft 和 Tright 中具有相同名称的变量，如果两个输入均为表，或如果 Tleft 是时间表而 Tright 是表。

  • 行时间的向量，如果 Tleft 和 Tright 均为时间表。

键变量的匹配值在左右输入中的顺序不必相同。此外，Tright 的键变量必须包含 Tleft 的键变量中的所有值。每个值在 Tright 的键变量中只能出现一次，但在 Tleft 的键变量中可以出现多次。因此，联接操作复制 Tright 中与 Tleft 中的多行匹配的任何行。

输入可以是表、时间表或其中之一。

  • 如果 Tleft 是表，则 join 以表的形式返回 T。

  • 如果 Tleft 是时间表，则 join 以时间表的形式返回 T。

示例

T = join(Tleft,Tright,Name,Value) 联接表或时间表，并通过一个或多个 Name,Value 对组参量指定其他选项。

例如，您可以指定将哪些变量用作键变量。

示例

[T,iright] = join(___) 还返回索引向量 iright，这样 iright 中的每个元素标识表 T 中与 Tright 中该行相对应的行。您可将此语法与上述语法中的任何输入参量一起使用。

示例

示例

全部折叠

打开实时脚本

创建表 Tleft。

Tleft = table({'Janice','Jonas','Javier','Jerry','Julie'}',[1;2;1;2;1],...
        'VariableNames',{'Employee' 'Department'})
Tleft=5×2 table
     Employee     Department
    __________    __________

    {'Janice'}        1     
    {'Jonas' }        2     
    {'Javier'}        1     
    {'Jerry' }        2     
    {'Julie' }        1

创建与 Tleft 具有共有变量的表 Tright。

Tright = table([1 2]',{'Mary' 'Mona'}',...
         'VariableNames',{'Department' 'Manager'})
Tright=2×2 table
    Department    Manager 
    __________    ________

        1         {'Mary'}
        2         {'Mona'}

创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用 join 函数，根据键变量 Department 重复表 Tright 中的 Manager 数据并将其追加到表 Tleft 的数据中。

T = join(Tleft,Tright)
T=5×3 table
     Employee     Department    Manager 
    __________    __________    ________

    {'Janice'}        1         {'Mary'}
    {'Jonas' }        2         {'Mona'}
    {'Javier'}        1         {'Mary'}
    {'Jerry' }        2         {'Mona'}
    {'Julie' }        1         {'Mary'}
打开实时脚本

创建表 Tleft。

Tleft = table([5;12;23;2;6],...
        {'cereal';'pizza';'salmon';'cookies';'pizza'},...
        'VariableNames',{'Age','FavoriteFood'},...
        'RowNames',{'Amy','Bobby','Holly','Harry','Sally'})
Tleft=5×2 table
             Age    FavoriteFood
             ___    ____________

    Amy       5     {'cereal' } 
    Bobby    12     {'pizza'  } 
    Holly    23     {'salmon' } 
    Harry     2     {'cookies'} 
    Sally     6     {'pizza'  }

创建与 Tleft 具有一个共有变量的表 Tright。

Tright = table({'cereal';'cookies';'pizza';'salmon';'cake'},...
         [110;160;140;367;243],...
         {'B';'D';'B-';'A';'C-'},...
         'VariableNames',{'FavoriteFood','Calories','NutritionGrade'})
Tright=5×3 table
    FavoriteFood    Calories    NutritionGrade
    ____________    ________    ______________

    {'cereal' }       110           {'B' }    
    {'cookies'}       160           {'D' }    
    {'pizza'  }       140           {'B-'}    
    {'salmon' }       367           {'A' }    
    {'cake'   }       243           {'C-'}

创建新表 T，其中包含表 Tleft 和 Tright 的数据。共同的变量 FavoriteFood 用作 join 函数的键变量。

T = join(Tleft,Tright)
T=5×4 table
             Age    FavoriteFood    Calories    NutritionGrade
             ___    ____________    ________    ______________

    Amy       5     {'cereal' }       110           {'B' }    
    Bobby    12     {'pizza'  }       140           {'B-'}    
    Holly    23     {'salmon' }       367           {'A' }    
    Harry     2     {'cookies'}       160           {'D' }    
    Sally     6     {'pizza'  }       140           {'B-'}

表 T 不包含表 Tright 最后一行有关 'cake' 的信息，因为表 Tleft 中没有对应的项。

打开实时脚本

创建表 Tleft。

Tleft = table([10;4;2;3;7],[5;4;9;6;1],[10;3;8;8;4])
Tleft=5×3 table
    Var1    Var2    Var3
    ____    ____    ____

     10      5       10 
      4      4        3 
      2      9        8 
      3      6        8 
      7      1        4

创建表 Tright，使表 Tright 中 Var2 的内容与表 Tleft 中 Var2 的内容相同。

Tright = table([6;1;1;6;8],[5;4;9;6;1])
Tright=5×2 table
    Var1    Var2
    ____    ____

     6       5  
     1       4  
     1       9  
     6       6  
     8       1

创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用表 Tleft 和 Tright 中的 Var2 作为 join 函数的键变量。

T = join(Tleft,Tright,'Keys','Var2')
T=5×4 table
    Var1_Tleft    Var2    Var3    Var1_Tright
    __________    ____    ____    ___________

        10         5       10          6     
         4         4        3          1     
         2         9        8          1     
         3         6        8          6     
         7         1        4          8

join 为非键变量 Var1 添加一个唯一的后缀，以区分表 Tleft 和 Tright 中的数据。

打开实时脚本

创建一个新表，其中包含表 Tleft 和 Tright 的数据。如果两个表中有任何同名的非键变量，仅保留其在表 Tleft 中的副本。

创建表 Tleft。

Tleft = table([10;4;2;3;7],[5;4;9;6;1])
Tleft=5×2 table
    Var1    Var2
    ____    ____

     10      5  
      4      4  
      2      9  
      3      6  
      7      1

创建表 Tright，使表 Tright 中 Var2 的内容与表 Tleft 中 Var2 的内容相同。

Tright = table([6;1;1;6;8],[5;4;9;6;1],[10;3;8;8;4])
Tright=5×3 table
    Var1    Var2    Var3
    ____    ____    ____

     6       5       10 
     1       4        3 
     1       9        8 
     6       6        8 
     8       1        4

创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用 Var2 作为 join 函数的键变量，并且仅保留表 Tleft 中 Var1 的副本。T 的输出表不包含表 Tright 中的 Var1 数据。

T = join(Tleft,Tright,'Keys','Var2','KeepOneCopy','Var1')
T=5×3 table
    Var1    Var2    Var3
    ____    ____    ____

     10      5       10 
      4      4        3 
      2      9        8 
      3      6        8 
      7      1        4
打开实时脚本

创建表 Tleft。

Tleft = table(['M';'M';'F';'F';'F'],[38;43;38;40;49],...
        'VariableNames',{'Gender' 'Age'},...
        'RowNames',{'Smith' 'Johnson' 'Williams' 'Jones' 'Brown'})
Tleft=5×2 table
                Gender    Age
                ______    ___

    Smith         M       38 
    Johnson       M       43 
    Williams      F       38 
    Jones         F       40 
    Brown         F       49

创建表 Tright，使 Tleft 和 Tright 的行一一对应。

Tright = table([64;69;67;71;64],...
         [119;163;133;176;131],...
         [122 80; 109 77; 117 75; 124 93; 125 83],...
         'VariableNames',{'Height' 'Weight' 'BloodPressure'},...
         'RowNames',{'Brown' 'Johnson' 'Jones' 'Smith' 'Williams'})
Tright=5×3 table
                Height    Weight    BloodPressure
                ______    ______    _____________

    Brown         64       119       122     80  
    Johnson       69       163       109     77  
    Jones         67       133       117     75  
    Smith         71       176       124     93  
    Williams      64       131       125     83

创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用行名称向量作为键变量。（表行名称向量的名称是 'Row'，如 Tleft.Properties.DimensionNames{1} 所示。）

T = join(Tleft,Tright,'Keys','Row')
T=5×5 table
                Gender    Age    Height    Weight    BloodPressure
                ______    ___    ______    ______    _____________

    Smith         M       38       71       176       124     93  
    Johnson       M       43       69       163       109     77  
    Williams      F       38       64       131       125     83  
    Jones         F       40       67       133       117     75  
    Brown         F       49       64       119       122     80

T 中行的顺序与 Tleft 相同。

打开实时脚本

创建表 Tleft。

Tleft = table([10;4;2;3;7],[5;4;9;6;1],[10;3;8;8;4])
Tleft=5×3 table
    Var1    Var2    Var3
    ____    ____    ____

     10      5       10 
      4      4        3 
      2      9        8 
      3      6        8 
      7      1        4

创建表 Tright，使表 Tright 中 Var2 的内容与表 Tleft 中 Var1 的内容相同，但顺序不同。

Tright = table([6;1;1;6;8],[2;3;4;7;10])
Tright=5×2 table
    Var1    Var2
    ____    ____

     6        2 
     1        3 
     1        4 
     6        7 
     8       10

创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用表 Tleft 中的 Var1 和表 Tright 中的 Var2 作为 join 函数的键变量。

[T,iright] = join(Tleft,Tright,'LeftKeys',1,'RightKeys',2)
T=5×4 table
    Var1_Tleft    Var2    Var3    Var1_Tright
    __________    ____    ____    ___________

        10         5       10          8     
         4         4        3          1     
         2         9        8          6     
         3         6        8          1     
         7         1        4          6     


iright = 5×1

     5
     3
     1
     2
     4

T 是 Tleft 和 Tright(iright,1) 的水平串联。

打开实时脚本

创建两个时间表，它们的行时间相同，但变量不同。

Traffic = [0.8 0.9 0.1 0.7 0.9]';
Noise = [0 1 1.5 2 2.3]';
Tleft = timetable(hours(1:5)',Traffic,Noise)
Tleft=5×2 timetable
    Time    Traffic    Noise
    ____    _______    _____

    1 hr      0.8         0 
    2 hr      0.9         1 
    3 hr      0.1       1.5 
    4 hr      0.7         2 
    5 hr      0.9       2.3 


Distance = [0.88 0.86 0.91 0.9 0.86]';
Tright = timetable(hours(1:5)',Distance)
Tright=5×1 timetable
    Time    Distance
    ____    ________

    1 hr      0.88  
    2 hr      0.86  
    3 hr      0.91  
    4 hr       0.9  
    5 hr      0.86

合并两个时间表。join 使用行时间作为键变量。

T = join(Tleft,Tright)
T=5×3 timetable
    Time    Traffic    Noise    Distance
    ____    _______    _____    ________

    1 hr      0.8         0       0.88  
    2 hr      0.9         1       0.86  
    3 hr      0.1       1.5       0.91  
    4 hr      0.7         2        0.9  
    5 hr      0.9       2.3       0.86
打开实时脚本

创建一个时间表和一个表。

Measurements = [0.13 0.22 0.31 0.42 0.53 0.57 0.67 0.81 0.90 1.00]';
Device = ['A';'B';'A';'B';'A';'B';'A';'B';'A';'B'];
Tleft = timetable(seconds(1:10)',Measurements,Device)
Tleft=10×2 timetable
     Time     Measurements    Device
    ______    ____________    ______

    1 sec         0.13          A   
    2 sec         0.22          B   
    3 sec         0.31          A   
    4 sec         0.42          B   
    5 sec         0.53          A   
    6 sec         0.57          B   
    7 sec         0.67          A   
    8 sec         0.81          B   
    9 sec          0.9          A   
    10 sec           1          B   


Device = ['A';'B'];
Accuracy = [0.023;0.037];
Tright = table(Device,Accuracy)
Tright=2×2 table
    Device    Accuracy
    ______    ________

      A        0.023  
      B        0.037

合并时间表和表。Device 是键变量，因为 Tleft 和 Tright 中都存在具有该名称的变量。T 是一个时间表。

T = join(Tleft,Tright)
T=10×3 timetable
     Time     Measurements    Device    Accuracy
    ______    ____________    ______    ________

    1 sec         0.13          A        0.023  
    2 sec         0.22          B        0.037  
    3 sec         0.31          A        0.023  
    4 sec         0.42          B        0.037  
    5 sec         0.53          A        0.023  
    6 sec         0.57          B        0.037  
    7 sec         0.67          A        0.023  
    8 sec         0.81          B        0.037  
    9 sec          0.9          A        0.023  
    10 sec           1          B        0.037

输入参数

全部折叠

左表，指定为表或时间表。对于所有键变量，Tleft 的每一行都必须与 Tright 中的一行完全匹配。

右表，指定为表或时间表。对于所有键变量，Tright 的每一行都必须与 Tleft 中的一行完全匹配。

名称-值参数

全部折叠

将可选的参量对组指定为 Name1=Value1,...,NameN=ValueN，其中 Name 是参量名称，Value 是对应的值。名称-值参量必须出现在其他参量之后，但参量对组的顺序无关紧要。

在 R2021a 之前，使用逗号分隔每个名称和值，并用引号将 Name 引起来。

示例: 'Keys',2 使用 Tleft 中的第二个变量和 Tright 中的第二个变量作为键变量。

用作键值的变量，指定为逗号分隔的对组，包含 'Keys' 和一个正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

您不能将 'Keys' 名称-值对组参量与 'LeftKeys' 和 'RightKeys' 名称-值对组参量配合使用。

来自输入表或时间表的行标签向量可以用作键，既可以单独使用，也可以与其他键变量组合使用。行标签是表的行名称或时间表的行时间。要将此向量用作键，请将其指定为 'Row'（如果是表的行名称）、行时间的时间表向量的名称，或者 T.Properties.DimensionNames{1} 的值，其中 T 是表或时间表。

为了实现向后兼容，当 Tleft 和 Tright 是具有行名称的表时，您也可以将 'Keys' 的值指定为 'RowNames'。但是，最佳做法是将 'Keys' 的值指定为行名称向量的名称。

示例: 'Keys',[1 3] 使用 Tleft 和 Tright 的第一个和第三个变量作为键变量。

示例: 'Keys',{'X','Y'} 使用 Tleft 和 Tright 中名为 X 和 Y 的变量作为键变量。

示例: 如果 Tleft 和 Tright 均为具有行名称的表，则 'Keys','Row' 使用 Tleft 和 Tright 的行名称向量作为键变量。

用作 Tleft 中的键值的变量，指定为逗号分隔的对组，包含 'LeftKeys' 和一个正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

必须将 'LeftKeys' 名称-值对组参量与 'RightKeys' 名称-值对组参量结合使用。'LeftKeys' 和 'RightKeys' 必须指定相同数量的键变量。join 根据键值的顺序为 Tleft 和 Tright 中的键值配对。

来自输入表或时间表的行标签向量可以用作键，既可以单独使用，也可以与其他键变量组合使用。行标签是表的行名称或时间表的行时间。要将此向量用作键，请将其指定为 'Row'（如果是表的行名称）、行时间的时间表向量的名称，或者 T.Properties.DimensionNames{1} 的值，其中 T 是表或时间表。

示例: 'LeftKeys',1 仅使用 Tleft 中的第一个变量作为键变量。

用作 Tright 中的键值的变量，指定为逗号分隔的对组，包含 'RightKeys' 和一个正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

必须将 'RightKeys' 名称-值对组参量与 'LeftKeys' 名称-值对组参量结合使用。'LeftKeys' 和 'RightKeys' 必须指定相同数量的键变量。join 根据键值的顺序为 Tleft 和 Tright 中的键值配对。

来自输入表或时间表的行标签向量可以用作键，既可以单独使用，也可以与其他键变量组合使用。行标签是表的行名称或时间表的行时间。要将此向量用作键，请将其指定为 'Row'（如果是表的行名称）、行时间的时间表向量的名称，或者 T.Properties.DimensionNames{1} 的值，其中 T 是表或时间表。

示例: 'RightKeys',3 仅使用 Tright 中的第三个变量作为键变量。

要包含在 T 中的来自 Tleft 的变量，指定为逗号分隔的对组，包含 'LeftVariables' 和一个正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

可以使用 'LeftVariables' 在 T 中包含或排除键变量和非键变量。但是，您不能包含 Tleft 中的行名称或行时间，因为它们不是变量。

默认情况下，join 包含来自 Tleft 的所有变量。

要包含在 T 中的来自 Tright 的变量，指定为逗号分隔的对组，包含 'RightVariables' 和一个正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

可以使用 'RightVariables' 在 T 中包含或排除键变量和非键变量。但是，您不能包含 Tright 中的行名称或行时间，因为它们不是变量。

默认情况下，join 包含 Tright 中除键变量以外的所有变量。

join 仅保留其在 Tleft 中的副本的变量，指定为逗号分隔的对组，其中包含 'KeepOneCopy' 和一个用于指定变量名称的字符串数组、字符向量、字符向量元胞数组或 pattern 标量。

键变量在 T 中只出现一次，但如果 Tleft 和 Tright 中包含同名的非键变量，则 join 默认情况下会在 T 中同时保留两者的副本。可以使用 'KeepOneCopy' 名称-值对组只保留 Tleft 中的副本。

示例: 'KeepOneCopy',Var2 仅保留 Tleft 中非键变量 Var2 的副本。

输出参量

全部折叠

Tleft 和 Tright 的合并数据，以表或时间表形式返回。表 T 包含 Tleft 中的所有行，且显示顺序也相同。

join 通过水平串联 Tleft(:,LeftVars) 和 Tright(iright,RightVars) 来创建 T。默认情况下，LeftVars 为 Tleft 的所有变量，RightVars 为 Tright 的所有非键变量。否则，LeftVars 包含 'LeftVariables' 名称-值对组参量所指定的变量，RightVars 包含 'RightVariables' 名称-值对组参量所指定的变量。

如果 Tleft 和 Tright 包含同名的非键变量，join 会在 T 中为对应的变量名称添加唯一性后缀，除非您指定了 'KeepOneCopy' 名称-值对组参量。

如果 Tleft 是表，则 T 也是表。如果 Tleft 是时间表，而 Tright 是时间表或表，则 T 是时间表。

您可以在 T 中存储描述、变量单位、变量名称和行名称等附加元数据。有关详细信息，请参阅 table 或 timetable 的“属性”部分。

Tright 的索引，以列向量形式返回。iright 的每个元素标识 Tright 中与输出表或时间表 T 中的行对应的行。

详细信息

全部折叠

算法

join 函数首先查找一个或多个键变量。然后，join 使用键变量查找输入表 Tright 中与输入表 Tleft 中每一行匹配的行，并且合并这些行，以在输出表 T 中创建相应行。

  • 如果 Tleft 和 Tright 中的键值之间存在一对一映射关系，join 会对 Tright 中的数据排序，并将其追加至表 Tleft。

  • 如果 Tleft 和 Tright 中的键值之间存在多对一映射关系，join 会对 Tright 中的数据进行排序和复写操作，然后再将其追加至表 Tleft。

  • 如果 Tright 的某个键变量中的数据与 Tleft 中的键值无映射关系，则 join 不会将该数据包含在输出表 T 中。

扩展功能

全部展开

版本历史记录

在 R2013b 中推出

另请参阅

函数

实时编辑器任务