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.
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!
- ¡Hola Julia!
- Primeros pasos con Julia
- Cadenas de texto en Julia
- Bucles en Julia
- Funciones en Julia
- Vectores, tuplas y diccionarios en Julia
- Estructuras en Julia
- Utilizar los tipos en Julia
- Tipos de datos en Julia
- Tipos y funciones paramétricos en Julia
- Introducción a los DataFrames en Julia
- Obtener información básica de los DataFrames de Julia
- El tipo de dato Missing de Julia
- Columnas en DataFrames de Julia
- Filas en DataFrames de Julia
- Combinar DataFrames en Julia
- Guardar y leer archivos CSV en Julia
- Guardar y leer archivos Excel en Julia
- Introducción a Genie
- Libros sobre Julia
Deja una respuesta