Пропущенные значения

Julia поддерживает представление пропущенных значений в статистическом смысле. Это используется в ситуациях, когда для переменной в наблюдении нет значения, но теоретически существует действительное значение. Пропущенные значения представляются объектом missing, который является единственным экземпляром типа Missing. missing эквивалентен NULL в SQL и NA в R и ведет себя подобно им в большинстве ситуаций.

Распространение пропущенных значений

missing значения автоматически распространяются при передаче их в стандартные математические операторы и функции. Для этих функций неопределённость значения одного из операндов приводит к неопределённости результата. На практике это означает, что математическая операция, включающая в себя missing значение, обычно возвращает missing:

julia> missing + 1
missing

julia> "a" * missing
missing

julia> abs(missing)
missing

Поскольку missing является обычным объектом Julia, это правило распространения работает только для функций, которые выбрали его реализацию. Это можно достичь, например:

• добавив специальный метод для аргументов типа Missing,
• принимая аргументы этого типа и передавая их функциям, которые их распространяют (например, стандартные математические операторы).

Пакеты должны учитывать, целесообразно ли распространять пропущенные значения при определении новых функций и определять соответствующие методы, если это необходимо. Передача missing значения функции, у которой нет метода, принимающего аргументы типа Missing , вызывает MethodError, как и для любого другого типа.

Функции, которые не распространяют missing значения, можно настроить на это, обернув их в функцию passmissing из пакета Missings.jl. Например, f(x) становится passmissing(f)(x).

Операторы равенства и сравнения

Стандартные операторы равенства и сравнения следуют правилу распространения, представленному выше: если любой из операндов является missing, то результат является missing. Вот несколько примеров:

julia> missing == 1
missing

julia> missing == missing
missing

julia> missing < 1
missing

julia> 2 >= missing
missing

Обратите внимание, что missing == missing возвращает missing, поэтому == нельзя использовать для проверки отсутствия значения. Чтобы проверить, является ли x missing, используйте ismissing(x).

Специальные операторы сравнения isequal и === являются исключениями из правила распространения. Они всегда возвращают Bool значение, даже при наличии missing значений, рассматривая missing как равное missing и отличное от любого другого значения. Поэтому их можно использовать для проверки, является ли значение missing:

julia> missing === 1
false

julia> isequal(missing, 1)
false

julia> missing === missing
true

julia> isequal(missing, missing)
true

Оператор isless — ещё одно исключение: missing считается большим, чем любое другое значение. Этот оператор используется sort!, поэтому missing значения размещаются после всех других значений:

julia> isless(1, missing)
true

julia> isless(missing, Inf)
false

julia> isless(missing, missing)
false

Логические операторы

Логические (или булевы) операторы |, & и xor — это ещё один особый случай, поскольку они распространяют missing значения только тогда, когда это логически необходимо. Для этих операторов неопределённость результата зависит от конкретной операции. Это соответствует хорошо известным правилам трёхзначной логики, которые реализуются, например, NULL в SQL и NA в R. Это абстрактное определение соответствует достаточно естественному поведению, которое лучше всего объяснить на конкретных примерах.

Давайте проиллюстрируем этот принцип на примере логического оператора «или» |. Согласно правилам булевой логики, если один из операндов является true, значение другого операнда не влияет на результат, который всегда будет true:

julia> true | true
true

julia> true | false
true

julia> false | true
true

Исходя из этого наблюдения, можно заключить, что если один из операндов является true, а другой missing, то результат будет true независимо от неопределённости фактического значения одного из операндов. Если бы мы могли наблюдать фактическое значение второго операнда, оно могло бы быть только true или false, и в обоих случаях результат был бы true. Следовательно, в этом конкретном случае пропущенность не распространяется:

julia> true | missing
true

julia> missing | true
true

Напротив, если один из операндов является false, результат может быть либо true, либо false, в зависимости от значения другого операнда. Таким образом, если этот операнд является missing, результат должен быть missing:

julia> false | true
true

julia> true | false
true

julia> false | false
false

julia> false | missing
missing

julia> missing | false
missing

Поведение логического оператора «и» & аналогично оператору |, с той разницей, что пропущенность не распространяется, когда один из операндов является false. Например, когда это относится к первому операнду:

julia> false & false
false

julia> false & true
false

julia> false & missing
false

С другой стороны, пропущенность распространяется, когда один из операндов является true, например, первый:

julia> true & true
true

julia> true & false
false

julia> true & missing
missing

Наконец, логический оператор «исключающее или» xor всегда распространяет missing значения, поскольку оба операнда всегда влияют на результат. Также обратите внимание, что оператор отрицания ! возвращает missing, когда операнд является missing, как и другие унарные операторы.

Операторы управления потоком и короткого замыкания

Операторы управления потоком, включая if, while и тернарный оператор x ? y : z, не допускают пропущенных значений. Это связано с неопределенностью того, будет ли фактическое значение true или false, если мы сможем его наблюдать. Это означает, что нам неизвестно, как программа должна себя вести. В этом случае TypeError вызывается сразу же, как только missing значение встречается в этом контексте:

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

По той же причине, в отличие от логических операторов, представленных выше, операторы короткого замыкания && и || не допускают missing значений в ситуациях, когда значение операнда определяет, оценивается ли следующий операнд или нет. Например:

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

В отличие от этого, ошибка не генерируется, когда результат может быть определен без missing значений. Это происходит, когда код прерывается перед оценкой missing операнда и когда missing операнд является последним:

julia> true && missing
missing

julia> false && missing
false

Массивы с пропущенными значениями

Массивы, содержащие пропущенные значения, могут быть созданы так же, как и другие массивы:

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

Как показывает этот пример, тип элементов таких массивов — Union{Missing, T}, а T — тип ненулевых значений. Это отражает тот факт, что элементы массива могут быть либо типа T (здесь Int64), либо типа Missing . Этот вид массива использует эффективное хранение памяти, эквивалентное Array{T} , содержащему фактические значения, дополненное Array{UInt8} , указывающим на тип элемента (т. е. является ли он Missing или T).

Массивы, допускающие пропущенные значения, могут быть созданы со стандартной синтаксической конструкцией. Используйте Array{Union{Missing, T}}(missing, dims) для создания массивов, заполненных пропущенными значениями:

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

Массив с типом элементов, допускающим missing элементы (например, Vector{Union{Missing, T}} ), который не содержит missing элементов, может быть преобразован в массив типа, который не допускает missing элементов (например, Vector{T} ) с помощью convert. Если массив содержит missing значения, при преобразовании генерируется MethodError:

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

Пропускание пропущенных значений

Поскольку missing значения распространяются при использовании стандартных математических операторов, функции редукции возвращают missing при вызове на массивах, содержащих пропущенные значения:

julia> sum([1, missing])
missing

В этой ситуации используйте функцию skipmissing для пропуска пропущенных значений:

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

Эта удобная функция возвращает итератор, который эффективно фильтрует missing значения. Поэтому ее можно использовать с любой функцией, поддерживающей итераторы:

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

Объекты, созданные путем вызова skipmissing на массиве, могут быть индексированы с использованием индексов из родительского массива. Индексы, соответствующие пропущенным значениям, не являются допустимыми для этих объектов, и при попытке их использования выбрасывается ошибка (они также пропускаются keys и eachindex):

julia> x[1]
3

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

Это позволяет функциям, работающим с индексами, работать в сочетании с skipmissing. Это особенно актуально для функций поиска и нахождения. Эти функции возвращают индексы, действительные для объекта, возвращаемого skipmissing, и также являются индексами соответствующих элементов в родительском массиве:

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

julia> findfirst(!iszero, x)
1

julia> argmax(x)
1

Используйте collect, чтобы извлечь значения, отличные от missing , и сохранить их в массив:

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

Логические операции над массивами

Трехзначная логика, описанная выше для логических операторов, также используется логическими функциями, применяемыми к массивам. Таким образом, проверки на равенство массивов с использованием оператора == возвращают missing всякий раз, когда результат не может быть определен без знания фактического значения элемента missing. На практике это означает, что возвращается missing, если все не пропущенные значения сравниваемых массивов равны, но один или оба массива содержат пропущенные значения (возможно, в разных позициях):

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

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

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

Что касается отдельных значений, используйте isequal, чтобы рассматривать значения missing как равные другим значениям missing, но отличные от значений, не являющихся пропущенными:

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

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

Функции any и all также следуют правилам трехзначной логики. Таким образом, возвращают missing, когда результат не может быть определен:

julia> all([true, missing])
missing

julia> all([false, missing])
false

julia> any([true, missing])
true

julia> any([false, missing])
missing