El tipo de dato Missing de Julia (13ª parte – ¡Hola Julia!)

En Julia existe un tipo de dato especial que se usa para indicar que no existe un valor para el registro: Missing. No es un tipo que se usa para reemplazar a NaN, ya que este valor también existe, sino que indica explícitamente la falta de un dato. El tipo de dato Missing de Julia es especial como podemos ver a continuación.

Crear un registro de tipo Missing

Para crea un registro de tipo Missing solamente se tienen que escribir missing y asignarlo a una variable a un registro de una matriz. Siendo un tipo de dato diferente a los que se ha visto en las entradas anteriores. Lo que se puede comprobar usando la función typeof() sobre missing y NaN, en el primer caso se obtiene como respuesta Missing, mientras que el segundo generalmente se obtendrá Float64.

typeof(missing) # Missing
typeof(NaN) # Float64

Por otro lado, si necesitamos que un registro de un vector, matriz o DataFrame sea Missing solo hay que escribir la palabra missing en lugar de un valor numérico o de otro tipo.

x = [1, 2, missing]

3-element Array{Union{Missing, Int64},1}:
 1
 2
  missing

Nótese que Julia nos indica que el tipo de dato del vector de ejemplo es la unión de Missing e Int64, el tipo de dato usado el resto del vector.

En Analytics Lane

Los récords con asterisco, o la épica del titular sin contexto – El bestiario de los indicadores económicos absurdos (parte 8 y final)

Comprobar si un valor es de tipo Missing

Si tenemos un dato se puede comprobar si este es de tipo Missing mediante la función ismissing(). Una función que devuelve verdadero en caso de que el valor sea Missing y falso en el resto de los casos. Teniendo en cuenta que la comprobación la hace a nivel de objeto, por lo que el resultado para un vector con uno o más registros Missing será falso. Siendo necesario usar la versión de la función finalizada en punto para comprobar el contenido del objeto. Lo que se puede ver en el siguiente ejemplo.

ismissing(1) # false
ismissing(missing) # true
ismissing([1, 2, missing]) # false
ismissing.([1, 2, missing]) # [false, false, true]
ismissing([missing, missing]) # false

Propagación de valores Missing

El tipo de dato Missing se propaga de una forma similar a los valores NaN. Prácticamente toda operación en la que se vea involucrado un valor de este tipo tiene como resultado missing, sea esta una comparación, una operación algebraica o una función. Por ejemplo, todas las líneas del siguiente ejemplo tienen como resultado missing.

missing == 1
missing == missing

missing + 1

sin(missing)

Un resultado que solamente es diferente en los operadores lógicos, donde el resultado dependerá del resto de valores y del operador. Por ejemplo, con en el caso del operador | el resultado es verdadero si el otro término es verdadero y missing en el caso de que sea falso.

missing | true # true
missing | false # missing

En los operadores lógicos como && p || no se puede usar este tipo de datos, obteniéndose siempre un error en tiempo de ejecución.

missing || true 

TypeError: non-boolean (Missing) used in boolean context

Evitar valores Missing

En muchas ocasiones vamos a necesitar realizar operaciones sin tener en cuenta los valores perdidos. Por ejemplo, si queremos sumar los valores de un vector, pero esto contiene uno o más de estos datos. Para esto se puede usar la función skipmissing() con la que se puede eliminar los valores Missing de un objeto. Por ejemplo, para un vector se puede usar skipmissing() junto a collect().

collect(skipmissing([1, missing, 2, missing]))

2-element Array{Int64,1}:
 1
 2

En este ejemplo se ha eliminado del valore missing de un vector quedándose únicamente con los valores enteros. Siendo el tipo de dato del objeto resultante Int64, no una unión de tipos.

Otra opción evitar los valores con tipo Missing puede ser la función replace(), con la que se puede reemplazar un valor por otro como puede ser un NaN o un número.

replace([1.0, missing, 2.0, missing], missing=>NaN)
replace([1.0, missing, 2.0, missing], missing=>0)

Algo que también se puede obtener con coalesce.()

coalesce.([1.0, missing, 2.0, missing], NaN)
coalesce.([1.0, missing, 2.0, missing], 0)

El tipo de dato Missing en DataFrames

Tal como se ha comentado anteriormente, y visto en la entrada anterior, el tipo de dato Missing también se puede usar en un DataFrame. Aunque el tipo de dato debe permitirlo, algo que se puede comprobar porque el tipo de dato termina con el símbolo ?. Algo que se puede ver en el siguiente ejemplo.

df = DataFrame(a=[1,2,missing], b=["a", "b", missing])

3×2 DataFrame
│ Row │ a       │ b       │
│     │ Int64?  │ String? │
├─────┼─────────┼─────────┤
│ 1   │ 1       │ a       │
│ 2   │ 2       │ b       │
│ 3   │ missing │ missing │

Los valores se pueden reemplazar con el método replace(), aunque el tipo de dato seguirá indicando que puede contener valores perdidos con el ?.

Si se crea un DataFrame de cero sin valores missing en una columna, no se puede asignar un valor de este tipo. Ya que el tipo no lo permite.

df = DataFrame(a=[1,2,3], b=["a", "b", "c"])
df.a[3] = missing

MethodError: Cannot `convert` an object of type Missing to an object of type Int64

Es necesario indicar que una columna va a poder tener este tipo de valores, algo que se puede hacer con la función allowmissing().

df = DataFrame(a=allowmissing([1,2,3]), b=["a", "b", "c"])
df.a[3] = missing

3×2 DataFrame
│ Row │ a       │ b      │
│     │ Int64?  │ String │
├─────┼─────────┼────────┤
│ 1   │ 1       │ a      │
│ 2   │ 2       │ b      │
│ 3   │ missing │ c      │

Una función que se puede aplicar solamente a una columna como en el ejemplo, o a todo el DataFrame.

df = allowmissing(df)

3×2 DataFrame
│ Row │ a       │ b       │
│     │ Int64?  │ String? │
├─────┼─────────┼─────────┤
│ 1   │ 1       │ a       │
│ 2   │ 2       │ b       │
│ 3   │ missing │ c       │

Lo que también se tiene que hacer con los vectores para que sea posible insertar un valor missing. Por ejemplo, si se intenta reemplazar un valor por missing en un vector creado con allowmissing() es posible hacerlo sin problemas.

x = [1,2,3]
y = allowmissing(x)

y[3] = missing

Pero si se intenta en un vector normal creado sin valores missing obtendremos un error.

x[3] = missing

MethodError: Cannot `convert` an object of type Missing to an object of type Int64

El tipo de dato Missing en funciones

En el caso de las funciones, si indicamos el tipo de dato, es necesario señalar explícitamente que el dato que la función recibe es una unión para que esta pueda recibir un tipo missing. Así una función de la que se espera un valor entero, no puede recibir un valor missing.

function suma(x:Int64)
    return x + 1
end

suma(missing)

syntax: "x:Int64" is not a valid function argument name

Es necesario indicar explícitamente que el valor es la unión de Missing con el tipo esperado en la función.

function suma(x::Union{Missing, Int64})
    return x + 1
end

suma(missing)

missing

Algo que no aplica si no se define el tipo.

function suma(x)
    return x + 1
end

suma(missing)

missing

El tipo de dato Missing de Julia es especial

Lo que hemos visto en esta ocasión es un nuevo tipo de dato que no suele existir en otros lenguajes de programación. El tipo Missing al ser un tipo de dato y no un valor, como es el caso de NaN, permite que el código sea más robusto ya que para usarlos es necesario indicarlo explícitamente.

Publicaciones de la serie ¡Hola Julia!

1. ¡Hola Julia!
2. Primeros pasos con Julia
3. Cadenas de texto en Julia
4. Bucles en Julia
5. Funciones en Julia
6. Vectores, tuplas y diccionarios en Julia
7. Estructuras en Julia
8. Utilizar los tipos en Julia
9. Tipos de datos en Julia
10. Tipos y funciones paramétricos en Julia
11. Introducción a los DataFrames en Julia
12. Obtener información básica de los DataFrames de Julia
13. El tipo de dato Missing de Julia
14. Columnas en DataFrames de Julia
15. Filas en DataFrames de Julia
16. Combinar DataFrames en Julia
17. Guardar y leer archivos CSV en Julia
18. Guardar y leer archivos Excel en Julia
19. Introducción a Genie
20. Libros sobre Julia