# joindataframe
使用键变量按行合并两个表
函数库: TyBase
# 语法
T = joindataframe(Tleft,Tright)
T = joindataframe(Tleft,Tright;key=value)
T,iright = joindataframe(___)
# 说明
T = joindataframe(Tleft,Tright) 使用键变量合并表或时间表 Tleft 和 Tright。两个表中同名的所有变量均为键变量。当右表中存在与左表中的键变量值匹配的键变量时，则表联接操作会将右表中对应的行追加到左表。例如，如果 Tleft 具有名为 Key1 和 Var1 的变量，Tright 具有变量 Key1 和 Var2，则 T=joindataframe(Tleft,Tright) 使用 Key1 作为键变量。示例
左表和右表中键变量的匹配值不必按相同顺序排列。此外，Tright 的键变量必须包含 Tleft 的键变量中的所有值。每个值在 Tright 的键变量中只能出现一次，但在 Tleft 的键变量中可以出现多次。
输入可以是表、时间表或其中之一。
如果 Tleft 是表，则 joindataframe 以表的形式返回 T。
如果 Tleft 是时间表，则 joindataframe 以时间表的形式返回 T。
Tleft 和 Tright 的行标签向量可以用作键变量。行标签是表的行名称或时间表的行时间。
T = joindataframe(Tleft,Tright,key=value) 联接表或时间表，并通过一个或多个 key=value 对组参数指定其他选项。示例
例如，您可以指定将哪些变量用作键变量。
T,iright = joindataframe(___) 还返回索引向量 iright，这样 iright 中的每个元素标识表 T 中与 Tright 中该行相对应的行。您可以将此语法与前面语法中的任何输入参数结合使用。示例
# 示例
将一个表中的值追加到另一个表
创建表 Tleft1。
using TyBase
Tleft1 = DataFrame(
"Employee" => ["Janice", "Jonas", "Javier", "Jerry", "Julie"],
"Department" => [1; 2; 1; 2; 1],
)
Tleft1 =
5×2 DataFrame
Row │ Employee Department
│ String Int64
─────┼──────────────────────
1 │ Janice 1
2 │ Jonas 2
3 │ Javier 1
4 │ Jerry 2
5 │ Julie 1
创建与 Tleft1 具有共有变量的表 Tright1。
Tright1 = DataFrame("Department" => [1; 2], "Manager" => ["Mary"; "Mona"])
Tright1 =
2×2 DataFrame
Row │ Department Manager
│ Int64 String
─────┼─────────────────────
1 │ 1 Mary
2 │ 2 Mona
创建新表 T1，其中包含表 Tleft1 和 Tright1 的数据。使用 joindataframe 函数，根据键变量 Department 重复表 Tright1 中的 Manager 数据并将其追加到表 Tleft1 的数据中。
T1 = joindataframe(Tleft1, Tright1)
T1 =
5×3 DataFrame
Row │ Employee Department Manager
│ String Int64 String?
─────┼───────────────────────────────
1 │ Janice 1 Mary
2 │ Jonas 2 Mona
3 │ Javier 1 Mary
4 │ Jerry 2 Mona
5 │ Julie 1 Mary
合并包含一个共有变量的表
创建表 Tleft。
using TyBase
Tleft = DataFrame(
"Row" => ["Amy", "Bobby", "Holly", "Harry", "Sally"],
"Age" => [5; 12; 23; 2; 6],
"FavoriteFood" => ["cereal"; "pizza"; "salmon"; "cookies"; "pizza"],
)
Tleft =
5×3 DataFrame
Row │ Row Age FavoriteFood
│ String Int64 String
─────┼─────────────────────────────
1 │ Amy 5 cereal
2 │ Bobby 12 pizza
3 │ Holly 23 salmon
4 │ Harry 2 cookies
5 │ Sally 6 pizza
创建与 Tleft 具有一个共有变量的表 Tright。
Tright = DataFrame(
"FavoriteFood" => ["cereal"; "cookies"; "pizza"; "salmon"; "cake"],
"Calories" => [110; 160; 140; 367; 243],
"NutritionGrade" => ["B"; "D"; "B-"; "A"; "C-"],
)
Tright =
5×3 DataFrame
Row │ FavoriteFood Calories NutritionGrade
│ String Int64 String
─────┼────────────────────────────────────────
1 │ cereal 110 B
2 │ cookies 160 D
3 │ pizza 140 B-
4 │ salmon 367 A
5 │ cake 243 C-
创建新表 T，其中包含表 Tleft 和 Tright 的数据。共同的变量 FavoriteFood 用作 joindataframe 函数的键变量。
T = joindataframe(Tleft, Tright)
T =
5×5 DataFrame
Row │ Row Age FavoriteFood Calories NutritionGrade
│ String Int64 String Int64? String?
─────┼───────────────────────────────────────────────────────
1 │ Amy 5 cereal 110 B
2 │ Bobby 12 pizza 140 B-
3 │ Holly 23 salmon 367 A
4 │ Harry 2 cookies 160 D
5 │ Sally 6 pizza 140 B-
表 T 不包含表 Tright 最后一行有关 'cake' 的信息，因为表 Tleft 中没有对应的项。
通过指定一个键变量来合并表
创建表 Tleft。
using TyBase
Tleft = DataFrame(
"Var1" => [10; 4; 2; 3; 7], "Var2" => [5; 4; 9; 6; 1], "Var3" => [10; 3; 8; 8; 4]
)
Tleft =
5×3 DataFrame
Row │ Var1 Var2 Var3
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 10 5 10
2 │ 4 4 3
3 │ 2 9 8
4 │ 3 6 8
5 │ 7 1 4
创建表 Tright，使表 Tright 中 Var2 的内容与表 Tleft 中 Var2 的内容相同。
Tright = DataFrame("Var1" => [6; 1; 1; 6; 8], "Var2" => [5; 4; 9; 6; 1])
Tright =
5×2 DataFrame
Row │ Var1 Var2
│ Int64 Int64
─────┼──────────────
1 │ 6 5
2 │ 1 4
3 │ 1 9
4 │ 6 6
5 │ 8 1
创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用表 Tleft 和 Tright 中的 Var2 作为 joindataframe 函数的键变量。
T = joindataframe(Tleft, Tright; keys="Var2")
T =
5×4 DataFrame
Row │ Var1_Tleft Var2 Var3 Var1_Tright
│ Int64 Int64 Int64 Int64?
─────┼───────────────────────────────────────
1 │ 10 5 10 6
2 │ 4 4 3 1
3 │ 2 9 8 1
4 │ 3 6 8 6
5 │ 7 1 4 8
joindataframe 为非键变量 Var1 添加一个唯一的后缀，以区分表 Tleft 和 Tright 中的数据。
仅保留非键变量的一份副本
创建一个新表，其中包含表 Tleft 和 Tright 的数据。如果两个表中有任何同名的非键变量，仅保留其在表 Tleft 中的副本。
创建表 Tleft。
using TyBase
Tleft = DataFrame("Var1" => [10; 4; 2; 3; 7], "Var2" => [5; 4; 9; 6; 1])
Tleft =
5×2 DataFrame
Row │ Var1 Var2
│ Int64 Int64
─────┼──────────────
1 │ 10 5
2 │ 4 4
3 │ 2 9
4 │ 3 6
5 │ 7 1
创建表 Tright，使表 Tright 中 Var2 的内容与表 Tleft 中 Var2 的内容相同。
Tright = DataFrame(
"Var1" => [6; 1; 1; 6; 8], "Var2" => [5; 4; 9; 6; 1], "Var3" => [10; 3; 8; 8; 4]
)
Tright =
5×3 DataFrame
Row │ Var1 Var2 Var3
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 6 5 10
2 │ 1 4 3
3 │ 1 9 8
4 │ 6 6 8
5 │ 8 1 4
创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用 Var2 作为 joindataframe 函数的键变量，并且仅保留表 Tleft 中 Var1 的副本。T 的输出表不包含表 Tright 中的 Var1 数据。
T = joindataframe(Tleft, Tright; keys="Var2", keeponecopy="Var1")
T =
5×3 DataFrame
Row │ Var1 Var2 Var3
│ Int64 Int64 Int64?
─────┼──────────────────────
1 │ 10 5 10
2 │ 4 4 3
3 │ 2 9 8
4 │ 3 6 8
5 │ 7 1 4
使用行名称作为键变量来合并表
创建表 Tleft。
using TyBase
Tleft = DataFrame(
"Row" => ["Smith"; "Johnson"; "Williams"; "Jones"; "Brown"],
"Gender" => ["M"; "M"; "F"; "F"; "F"],
"Age" => [38; 43; 38; 40; 49],
)
Tleft =
5×3 DataFrame
Row │ Row Gender Age
│ String String Int64
─────┼─────────────────────────
1 │ Smith M 38
2 │ Johnson M 43
3 │ Williams F 38
4 │ Jones F 40
5 │ Brown F 49
创建表 Tright，使 Tleft 和 Tright 的行一一对应。
Tright = DataFrame(
"Row" => ["Brown"; "Johnson"; "Jones"; "Smith"; "Williams"],
"Height" => [64; 69; 67; 71; 64],
"Weight" => [119; 163; 133; 176; 131],
"BloodPressure" => [[122, 80], [109, 77], [117, 75], [124, 93], [125, 83]],
)
Tright =
5×4 DataFrame
Row │ Row Height Weight BloodPressure
│ String Int64 Int64 Vector{Int64}
─────┼─────────────────────────────────────────
1 │ Brown 64 119 [122, 80]
2 │ Johnson 69 163 [109, 77]
3 │ Jones 67 133 [117, 75]
4 │ Smith 71 176 [124, 93]
5 │ Williams 64 131 [125, 83]
创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用行名称向量作为键变量。（表行名称向量的名称是 "Row"。）
T = joindataframe(Tleft, Tright; keys="Row")
T =
5×6 DataFrame
Row │ Row Gender Age Height Weight BloodPressure
│ String String Int64 Int64? Int64? Vector{Int64}?
─────┼─────────────────────────────────────────────────────────
1 │ Smith M 38 71 176 [124, 93]
2 │ Johnson M 43 69 163 [109, 77]
3 │ Williams F 38 64 131 [125, 83]
4 │ Jones F 40 67 133 [117, 75]
5 │ Brown F 49 64 119 [122, 80]
T 中行的顺序与 Tleft 相同。
使用左键变量和右键变量来合并表
创建表 Tleft。
using TyBase
Tleft = DataFrame(
"Var1" => [10; 4; 2; 3; 7], "Var2" => [5; 4; 9; 6; 1], "Var3" => [10; 3; 8; 8; 4]
)
Tleft =
5×3 DataFrame
Row │ Var1 Var2 Var3
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 10 5 10
2 │ 4 4 3
3 │ 2 9 8
4 │ 3 6 8
5 │ 7 1 4
创建表 Tright，使表 Tright 中 Var2 的内容与表 Tleft 中 Var1 的内容相同，但顺序不同。
Tright = DataFrame("Var1" => [6; 1; 1; 6; 8], "Var2" => [2; 3; 4; 7; 10])
Tright =
5×2 DataFrame
Row │ Var1 Var2
│ Int64 Int64
─────┼──────────────
1 │ 6 2
2 │ 1 3
3 │ 1 4
4 │ 6 7
5 │ 8 10
创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用表 Tleft 中的 Var1 和表 Tright 中的 Var2 作为 joindataframe 函数的键变量。
T, iright = joindataframe(Tleft, Tright; leftkeys=1, rightkeys=2, nargout=2)
T =
5×4 DataFrame
Row │ Var1_Tleft Var2 Var3 Var1_Tright
│ Int64 Int64 Int64 Int64?
─────┼───────────────────────────────────────
1 │ 10 5 10 8
2 │ 4 4 3 1
3 │ 2 9 8 6
4 │ 3 6 8 1
5 │ 7 1 4 6
iright =
5-element Vector{Union{Missing, Int64}}:
5
3
1
2
4
T 是 Tleft 和 Tright(iright;leftkeys=1) 的水平串联。
合并时间表
创建两个时间表，它们的行时间相同，但变量不同。
using TyBase
Tleft = DataFrame(;
Time=Hour.(1:5), Traffic=[0.8, 0.9, 0.1, 0.7, 0.9], Noise=[0, 1, 1.5, 2, 2.3]
)
Tleft =
5×3 DataFrame
Row │ Time Traffic Noise
│ Hour Float64 Float64
─────┼───────────────────────────
1 │ 1 hour 0.8 0.0
2 │ 2 hours 0.9 1.0
3 │ 3 hours 0.1 1.5
4 │ 4 hours 0.7 2.0
5 │ 5 hours 0.9 2.3
Tright = DataFrame(; Time=Hour.(1:5), Distance=[0.88, 0.86, 0.91, 0.9, 0.86])
Tright =
5×2 DataFrame
Row │ Time Distance
│ Hour Float64
─────┼───────────────────
1 │ 1 hour 0.88
2 │ 2 hours 0.86
3 │ 3 hours 0.91
4 │ 4 hours 0.9
5 │ 5 hours 0.86
合并两个时间表。joindataframe 使用行时间作为键变量。
T = joindataframe(Tleft, Tright)
T =
5×4 DataFrame
Row │ Time Traffic Noise Distance
│ Hour Float64 Float64 Float64?
─────┼─────────────────────────────────────
1 │ 1 hour 0.8 0.0 0.88
2 │ 2 hours 0.9 1.0 0.86
3 │ 3 hours 0.1 1.5 0.91
4 │ 4 hours 0.7 2.0 0.9
5 │ 5 hours 0.9 2.3 0.86
合并时间表和表
创建一个时间表和一个表。
using TyBase
Tleft = DataFrame(;
Time=Second.(1:10),
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 =
10×3 DataFrame
Row │ Time Measurements Device
│ Second Float64 Char
─────┼──────────────────────────────────
1 │ 1 second 0.13 A
2 │ 2 seconds 0.22 B
3 │ 3 seconds 0.31 A
4 │ 4 seconds 0.42 B
5 │ 5 seconds 0.53 A
6 │ 6 seconds 0.57 B
7 │ 7 seconds 0.67 A
8 │ 8 seconds 0.81 B
9 │ 9 seconds 0.9 A
10 │ 10 seconds 1.0 B
Tright = DataFrame(; Device=['A'; 'B'], Accuracy=[0.023; 0.037])
Tright =
2×2 DataFrame
Row │ Device Accuracy
│ Char Float64
─────┼──────────────────
1 │ A 0.023
2 │ B 0.037
合并时间表和表。Device 是键变量，因为 Tleft 和 Tright 中都存在具有该名称的变量。T 是一个时间表。
T = joindataframe(Tleft, Tright)
T =
10×4 DataFrame
Row │ Time Measurements Device Accuracy
│ Second Float64 Char Float64?
─────┼────────────────────────────────────────────
1 │ 1 second 0.13 A 0.023
2 │ 2 seconds 0.22 B 0.037
3 │ 3 seconds 0.31 A 0.023
4 │ 4 seconds 0.42 B 0.037
5 │ 5 seconds 0.53 A 0.023
6 │ 6 seconds 0.57 B 0.037
7 │ 7 seconds 0.67 A 0.023
8 │ 8 seconds 0.81 B 0.037
9 │ 9 seconds 0.9 A 0.023
10 │ 10 seconds 1.0 B 0.037
# 输入参数
Tleft - 左表表 | 时间表
左表，指定为表或时间表。对于所有键变量，Tleft 的每一行都必须与 Tright 中的一行完全匹配。
Tright - 右表表 | 时间表
右表，指定为表或时间表。对于所有键变量，Tright 的每一行都必须与 Tleft 中的一行完全匹配。
# 名称-值对组参数
指定可选的、以逗号分隔的 Key=Value 对组参数。Key 为参数名称，Value 为对应的值。您可采用任意顺序指定多个名称-值对组参数，如 Key1=Value1,...,KeyN=ValueN 所示。
示例： keys="2" 使用 Tleft 中的第二个变量和 Tright 中的第二个变量作为键变量。
keys - 用作键值的变量正整数向量 | Symbol向量 | 字符串向量 | 列矩阵 | 行矩阵 | 元组
用作键值的变量，指定为逗号分隔的对组，包含 keys 和一个正整数、正整数向量、字符串数组或逻辑向量。
您不能将 keys 名称-值对组参数与 leftkeys 和 rightkeys 名称-值对组参数配合使用。
来自输入表或时间表的行标签向量可以用作键，既可以单独使用，也可以与其他键变量组合使用。行标签是表的行名称或时间表的行时间。要将此向量用作键，请将其指定为 "Row"（如果是表的行名称）、行时间的时间表向量的名称。
为了实现向后兼容，当 Tleft 和 Tright 是具有行名称的表时，您也可以将 keys 的值指定为 "RowNames"。但是，最佳做法是将 keys 的值指定为行名称向量的名称。
示例： Keys=[1 3] 使用 Tleft 和 Tright 的第一个和第三个变量作为键变量。
示例： Keys={"X","Y"} 使用 Tleft 和 Tright 中名为 X 和 Y 的变量作为键变量。
示例： 如果 Tleft 和 Tright 均为具有行名称的表，则 Keys="Row" 使用 Tleft 和 Tright 的行名称向量作为键变量。
leftkeys - Tleft 中要用作键变量的变量正整数向量 | Symbol向量 | 字符串向量 | 列矩阵 | 行矩阵 | 元组
用作 Tleft 中的键值的变量，指定为以逗号分隔的对组，其中包含 leftkeys 和一个正整数、正整数向量、字符串数组或逻辑向量。
必须将 leftkeys 名称-值对组参数与 rightkeys 名称-值对组参数结合使用。leftkeys 和 rightkeys 必须指定相同数量的键变量。joindataframe 根据键值的顺序为 Tleft 和 Tright 中的键值配对。
来自输入表或时间表的行标签向量可以用作键，既可以单独使用，也可以与其他键变量组合使用。行标签是表的行名称或时间表的行时间。要将此向量用作键，请将其指定为 "Row"（如果是表的行名称）、行时间的时间表向量的名称。
示例： leftkeys=1 仅使用 Tleft 中的第一个变量作为键变量。
rightkeys - Tright 中要用作键变量的变量正整数向量 | Symbol向量 | 字符串向量 | 列矩阵 | 行矩阵 | 元组
用作 Tright 中的键值的变量，指定为以逗号分隔的对组，其中包含 rightkeys 和一个正整数、正整数向量、字符串数组或逻辑向量。
必须将 rightkeys 名称-值对组参数与 leftkeys 名称-值对组参数结合使用。leftkeys 和 rightkeys 必须指定相同数量的键变量。joindataframe 根据键值的顺序为 Tleft 和 Tright 中的键值配对。
来自输入表或时间表的行标签向量可以用作键，既可以单独使用，也可以与其他键变量组合使用。行标签是表的行名称或时间表的行时间。要将此向量用作键，请将其指定为 "Row"（如果是表的行名称）、行时间的时间表向量的名称。
示例： rightkeys=3 仅使用 Tright 中的第三个变量作为键变量。
LeftVariables - 要包含在 T 中的来自 Tleft 的变量正整数向量 | Symbol向量 | 字符串向量 | 列矩阵 | 行矩阵 | 元组
要包含在 T 中的来自 Tright 的变量，指定为逗号分隔的对组，包含 RightVariables 和一个正整数、正整数向量、字符串数组或逻辑向量。
可以使用 RightVariables 在 T 中包含或排除键变量和非键变量。但是，您不能包含 Tright 中的行名称或行时间，因为它们不是变量。
默认情况下，joindataframe 包含 Tright 中除键变量以外的所有变量。
RightVariables - 要包含在 T 中的来自 Tright 的变量正整数向量 | Symbol向量 | 字符串向量 | 列矩阵 | 行矩阵 | 元组
要包含在 T 中的来自 Tright 的变量，指定为逗号分隔的对组，包含 RightVariables 和一个正整数、正整数向量、字符串数组或逻辑向量。
可以使用 RightVariables 在 T 中包含或排除键变量和非键变量。但是，您不能包含 Tright 中的行名称或行时间，因为它们不是变量。
默认情况下，joindataframe 包含 Tright 中除键变量以外的所有变量。
keeponecopy - joindataframe 仅保留其在 Tleft 中的副本的变量Symbol向量 | 字符串向量 | 列矩阵 | 行矩阵 | 元组
joindataframe 仅保留其在 Tleft 中的副本的变量，指定为逗号分隔的对组，其中包含 keeponecopy 和用于指定变量名称的字符串数组。
键变量在 T 中只出现一次，但如果 Tleft 和 Tright 中包含同名的非键变量，则 joindataframe 默认情况下会在 T 中同时保留两者的副本。可以使用 keeponecopy 名称-值对组只保留 Tleft 中的副本。
示例： keeponecopy="Var2" 仅保留 Tleft 中非键变量 Var2 的副本。
# 输出参数
T - Tleft 和 Tright 的合并数据表 | 时间表
Tleft 和 Tright 的合并数据，以表或时间表形式返回。表 T 包含 Tleft 中的所有行，且显示顺序也相同。
joindataframe 通过水平串联 Tleft(:,LeftVars) 和 Tright(iright,RightVars) 来创建 T。默认情况下，LeftVars 为 Tleft 的所有变量，RightVars 为 Tright 的所有非键变量。否则，LeftVars 包含 'LeftVariables' 名称-值对组参数所指定的变量，RightVars 包含 'RightVariables' 名称-值对组参数所指定的变量。
如果 Tleft 和 Tright 包含同名的非键变量，joindataframe 会在 T 中为对应的变量名称添加唯一性后缀，除非您指定了 'KeepOneCopy' 名称-值对组参数。
如果 Tleft 是表，则 T 也是表。如果 Tleft 是时间表，而 Tright 是时间表或表，则 T 是时间表。
iright - Tright 的索引列向量
Tright 的索引，以列向量形式返回。iright 的每个元素标识 Tright 中与输出表或时间表 T 中的行对应的行。
# 详细信息
# 键变量
用于在输入表 Tleft 与 Tright 之间匹配和合并数据的变量。
# 键值
Tleft 或 Tright 的键变量中的值。
# 算法
joindataframe 函数首先查找一个或多个键变量。然后，joindataframe 使用键变量查找输入表 Tright 中与输入表 Tleft 中每一行匹配的行，并且合并这些行，以在输出表 T 中创建相应行。
如果 Tleft 和 Tright 中的键值之间存在一对一映射关系，joindataframe 会对 Tright 中的数据排序，并将其追加至表 Tleft。
如果 Tleft 和 Tright 中的键值之间存在多对一映射关系，joindataframe 会对 Tright 中的数据进行排序和复写操作，然后再将其追加至表 Tleft。
如果 Tright 的某个键变量中的数据与 Tleft 中的键值无映射关系，则 joindataframe 不会将该数据包含在输出表 T 中。