缺失值

Julia支持在统计意义上表示缺失值。这适用于观测值中变量没有可用值，但理论上存在有效值的情况。缺失值通过 失踪对象，它是类型的单例实例 失踪. 失踪 相当于https://en.wikipedia.org/wiki/NULL_(SQL)[NULL 在SQL]和https://cran.r-project.org/doc/manuals/r-release/R-lang.html#NA-handling[脧锚脧赂`呐` 在R]中，并且在大多数情况下表现得像它们。

缺失值的传播

失踪 值_propagate_自动传递给标准数学运算符和函数。对于这些函数，其中一个操作数的值的不确定性导致结果的不确定性。在实践中，这意味着涉及一个数学运算 失踪 值一般返回 失踪:

julia> missing + 1
missing

julia> "a" &ast; missing
missing

julia> abs(missing)
missing

自 失踪 是一个普通的Julia对象，此传播规则仅适用于选择实现此行为的函数。这可以通过以下方式实现:

*添加为类型参数定义的特定方法 失踪, *接受这种类型的参数，并将它们传递给传播它们的函数（如标准数学运算符）。

包应该考虑在定义新函数时传播缺失值是否有意义，并在这种情况下适当地定义方法。通过a 失踪 没有接受类型参数的方法的函数的值 失踪 抛出一个 方法；方法，就像任何其他类型一样。

不传播的函数 失踪 值可以通过将它们包装在 [医]传道者 所提供的功能https://github.com/JuliaData/Missings.jl[Missings.jl]包裹。例如, f(x) 成为 密码(f)(x).

相等和比较运算符

标准相等和比较运算符遵循上面提出的传播规则：如果任何操作数是 失踪，结果是 失踪. 这里有几个例子:

julia> missing == 1
missing

julia> missing == missing
missing

julia> missing < 1
missing

julia> 2 >= missing
missing

特别要注意的是 失踪==失踪 申报表 失踪，所以 == 不能用于测试是否缺少值。测试是否 x 是 失踪，使用 ismissing(x).

特殊比较运算符 等效;等效和 ===是传播规则的例外。他们总会回来的。 布尔 值，即使在存在 失踪 价值观，考虑 失踪 等于 失踪 而作为不同于任何其他值。因此，它们可用于测试值是否为 失踪:

julia> missing === 1
false

julia> isequal(missing, 1)
false

julia> missing === missing
true

julia> isequal(missing, missing)
true

该 无为运算符是另一个例外: 失踪 被认为大于任何其他值。此运算符由 排序！，因此放置 失踪 所有其他值之后的值:

julia> isless(1, missing)
true

julia> isless(missing, Inf)
false

julia> isless(missing, missing)
false

逻辑运算符

逻辑（或布尔）运算符[|](/base/math#Base.:

), &和 异或是另一种特殊情况，因为它们只传播 失踪 逻辑上需要时的值。对于这些运算符，结果是否不确定，取决于特定的操作。这遵循了https://en.wikipedia.org/wiki/Three-valued_logic[three-valued logic]由例如实现。 NULL 在SQL和 呐 在R.这个抽象的定义对应于一个相对自然的行为，最好通过具体的例子来解释。

让我们用逻辑"或"运算符来说明这个原则[|]（/base/math#Base。:

). 遵循布尔逻辑的规则，如果其中一个操作数是 真的，另一个操作数的值对结果没有影响，这将始终是 真的:

julia> true | true
true

julia> true | false
true

朱莉娅>假/真
真的

基于这一观察，我们可以得出结论，如果其中一个操作数是 真的 而另一个 失踪，我们知道结果是 真的 尽管其中一个操作数的实际值存在不确定性。如果我们能够观察到第二个操作数的实际值，它只能是 真的 或 错误 在这两种情况下，结果都是 真的. 因此，在这种特殊情况下，missingness不会传播_not_:

julia> true | missing
true

julia> missing | true
true

相反，如果其中一个操作数是 错误，结果可能是 真的 或 错误 取决于其他操作数的值。因此，如果该操作数是 失踪，结果必须是 失踪 也:

julia> false | true
true

julia> true | false
true

julia> false | false
false

julia> false | missing
missing

julia> missing | false
missing

逻辑"and"运算符的行为 &与 | 运算符，其区别在于当其中一个操作数为 错误. 例如，当这是第一个操作数的情况:

julia> false & false
false

julia> false & true
false

julia> false & missing
false

另一方面，当其中一个操作数为 真的，例如第一个:

julia> true & true
true

julia> true & false
false

julia> true & missing
missing

最后，"独占或"逻辑运算符 异或总是传播 失踪 值，因为两个操作数总是对结果有影响。另请注意，否定运算符 !回报 失踪 当操作数为 失踪，就像其他一元运算符一样。

控制流和短路操作符

控制流运算符，包括 如果, 而和三元运算符 x？ y：z 不允许缺失值。这是因为实际价值是否会是不确定性 真的 或 错误 如果我们能观察到的话。这意味着我们不知道程序应该如何表现。在这种情况下，一个 打字错误被抛出，只要一个 失踪 值在此上下文中遇到:

julia> if missing
           println("here")
       end
ERROR: TypeError: non-boolean (Missing) used in boolean context

出于同样的原因，与上面提出的逻辑运算符相反，短路布尔运算符 &&和[||](/基数/数学#

）不允许 失踪 操作数的值决定是否计算下一个操作数的情况下的值。例如:

julia> missing || false
ERROR: TypeError: non-boolean (Missing) used in boolean context

julia> missing && false
ERROR: TypeError: non-boolean (Missing) used in boolean context

julia> true && missing && false
ERROR: TypeError: non-boolean (Missing) used in boolean context

相反，当结果可以在没有 失踪 价值观。这是当代码短路评估之前的情况 失踪 操作数，以及当 失踪 操作数是最后一个:

julia> true && missing
missing

julia> false && missing
false

具有缺失值的数组

包含缺失值的数组可以像其他数组一样创建:

julia> [1, missing]
2-element Vector{Union{Missing, Int64}}:
 1
  missing

如本示例所示，此类数组的元素类型为 工会{Missing, T}，与 T 非缺失值的类型。这反映了数组条目可以是任何类型的事实 T （这里, Int64)或类别 失踪. 这种阵列使用相当于一个高效的内存存储 数组{T} 持有实际值与 数组{UInt8} 指示条目的类型（即是否为 失踪 或 T).

可以使用标准语法构造允许缺失值的数组。使用方法 阵列{Union{Missing, T}}(失踪,dims) 创建填充有缺失值的数组:

julia> Array{Union{Missing, String}}(missing, 2, 3)
2×3 Matrix{Union{Missing, String}}:
 missing  missing  missing
 missing  missing  missing

使用说明 unef 或 类似的 目前可能会给出一个填充有 失踪，但这不是获得这样一个数组的正确方法。使用a 失踪 构造函数如上所示。

一个元素类型允许的数组 失踪 参赛作品(例如 向量资料{Union{Missing, T}}）不含任何 失踪 条目可以转换为不允许的数组类型 失踪 参赛作品(例如 向量{T})使用 转换/转换. 如果数组包含 失踪 价值观，a 方法；方法 在转换过程中抛出:

julia> x = Union{Missing, String}["a", "b"]
2-element Vector{Union{Missing, String}}:
 "a"
 "b"

julia> convert(Array{String}, x)
2-element Vector{String}:
 "a"
 "b"

julia> y = Union{Missing, String}[missing, "b"]
2-element Vector{Union{Missing, String}}:
 missing
 "b"

julia> convert(Array{String}, y)
ERROR: MethodError: Cannot `convert` an object of type Missing to an object of type String

跳过缺失值

自 失踪 值与标准数学运算符传播，减少函数返回 失踪 当调用包含缺失值的数组时:

julia> sum([1, missing])
missing

在这种情况下，使用 跳板,跳板跳过缺失值的函数:

julia> sum(skipmissing([1, missing]))
1

这个方便函数返回一个迭代器，它过滤掉 失踪 有效率的价值。因此，它可以与任何支持迭代器的函数一起使用:

julia> x = skipmissing([3, missing, 2, 1])
skipmissing(Union{Missing, Int64}[3, missing, 2, 1])

julia> maximum(x)
3

julia> sum(x)
6

julia> mapreduce(sqrt, +, x)
4.146264369941973

通过调用创建的对象 跳板,跳板 可以使用父数组中的索引对数组进行索引。对应于缺失值的索引对这些对象无效，并且在尝试使用它们时会抛出错误（它们也被跳过 钥匙 和 每个索引):

julia> x[1]
3

julia> x[2]
ERROR: MissingException: the value at index (2,) is missing
[...]

这允许对索引进行操作的函数与 跳板,跳板. 搜索和查找功能尤其如此。这些函数返回对返回的对象有效的索引 跳板,跳板，并且也是父数组中匹配项的索引_:

julia> findall(==(1), x)
1-element Vector{Int64}:
 4

julia> findfirst(!iszero, x)
1

julia> argmax(x)
1

使用方法 收集资料提取非-失踪 值并将它们存储在数组中:

julia> collect(x)
3-element Vector{Int64}:
 3
 2
 1

对数组的逻辑运算

上面针对逻辑运算符描述的三值逻辑也被应用于数组的逻辑函数所使用。因此，数组相等性测试使用 ==运算符返回 失踪 当结果不能确定不知道的实际值 失踪 进入。在实践中，这意味着 失踪 如果比较数组的所有非缺失值相等，但其中一个或两个数组包含缺失值（可能位于不同位置），则返回:

julia> [1, missing] == [2, missing]
false

julia> [1, missing] == [1, missing]
missing

julia>[1,2,missing]==[1,missing,2]
失踪

至于单个值，使用 等效;等效治疗 失踪 与其他值相等 失踪 值，但与非缺失值不同:

julia> isequal([1, missing], [1, missing])
true

julia> isequal([1, 2, missing], [1, missing, 2])
false

功能 任何和 全部还要遵循三值逻辑的规则。因此，返回 失踪 当结果无法确定时:

julia> all([true, missing])
missing

julia> all([false, missing])
false

julia> any([true, missing])
true

julia> any([false, missing])
missing