Etiquetas con nombres

Muchos lenguajes tienen una forma, como null o none, de indicar un valor que no existe. Como Julia está diseñado para manejar grandes volúmenes de datos (a menudo desordenados), tiene varias formas de representar la nada.

El objetivo general es marcar los valores faltantes o sospechosos a medida que aparecen, y luego continuar sin lanzar una excepción.

nothing

Si un valor realmente no existe, se representa con nothing. Esto es probablemente lo más parecido a lo que harían C (NULL) o Python (None).

julia> n = nothing

julia> isnothing(n)
true

julia> typeof(n)
Nothing

Así que nothing es un valor singleton de tipo Nothing, y podemos comprobarlo.

Un uso común de nothing es como valor de retorno (o no-valor) de funciones que se usan solo por sus efectos secundarios (imprimir, configurar la red, o lo que sea).

missing

Para situaciones en las que un valor existe en teoría, pero no sabemos cuál es, se usa missing. Por ejemplo, al contar vehículos que viajan por una carretera, puede que los observadores humanos necesiten un descanso o que los sensores automáticos fallen, pero el tráfico sigue fluyendo.

Así, missing es un marcador de posición que advierte a las personas que deben decidir cómo manejar ese hueco en los datos.

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

julia> typeof(mv)
Vector{Union{Missing, Int64}} (alias for Array{Union{Missing, Int64}, 1})

julia> ismissing.(mv)  # broadcast function, displays as 1 for true, 0 for false
3-element BitVector:
 0
 0
 1

Pocos lenguajes más tienen esta funcionalidad incorporada, pero hay análogos cercanos: NA en R o NULL en SQL.

Por lo general, las expresiones devuelven missing de forma predeterminada si hay valores missing presentes. Si quieres que estos valores se ignoren, usa la función skipmissing() para dejarlo explícito:

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

julia> sum(mv)  # missing in, missing out
missing

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

julia> collect(skipmissing(mv))
2-element Vector{Int64}:
 1
 2

julia> sum(skipmissing(mv))  # functions like sum() can work with iterators
3

Como skipmissing crea un iterador, envuélvelo en collect() si necesitas un vector.

A veces es útil reemplazar los valores missing con algún valor predeterminado. La macro @coalesce() es útil para esto, ya que devuelve el primer valor que no sea missing (o missing si no hay nada más).

julia> str = ["I", "exist", missing]
3-element Vector{Union{Missing, String}}:
 "I"
 "exist"
 missing

julia> [@coalesce(s, "-") for  s in str]
3-element Vector{String}:
 "I"
 "exist"
 "-"

NaN

Abreviatura de «Not a Number», NaN señala un problema de cálculo en situaciones donde se esperaba un número.

julia> v = [0, 1, -1]
3-element Vector{Int64}:
  0
  1
 -1

julia> v / 0
3-element Vector{Float64}:
 NaN
  Inf
 -Inf
 
julia> sum(v / 0)
NaN

Cualquier tipo de cálculo sobre datos que incluyan un NaN dará como resultado NaN.

Actualmente no hay una función especial para eliminar los valores NaN, pero la función estándar filter() puede hacerlo de forma bastante sencilla. Solo se copiarán al array de resultados los valores para los cuales cierta condición dada sea true:

julia> filter(!isnan, [1, 2, NaN])
2-element Vector{Float64}:
 1.0
 2.0