En esta entrada y la siguiente nos vamos a para un momento en conceptos teóricos sobre los tipos de datos en Julia. Creo que es importante conocer cómo funcionan los tipos de datos para poder sacar un mayor provecho de las posibilidades que nos ofrece el lenguaje.
Comprobar el tipo de una variable
Si tenemos una variable en nuestro espacio de trabajo podemos comprobar el tipo al que pertenece con la función typeof(). Una función que nos devolverá el identificador del tipo de dato, lo que se puede obtener tanto sobre constantes o variables.
typeof(1) # Int64
typeof(π) # Irrational{:π}
typeof(1.0) # Float64Asignación de los tipos de datos en Julia
Como hemos visto en las entradas anteriores el operador para indicar el tipo de dato en Julia es ::. Generalmente indicamos el nombre de una variable seguido del operador y el tipo de dato. Lo que hace realmente el operador es comprobar que el valor a la izquierda es del tipo indicado, por eso la siguiente línea produce un error.
12::Float64 TypeError: in typeassert, expected Float64, got Int64
En este caso lo que hemos intentado comprobar si el número entero 12 es de tipo real de 64 bits, lo que no es cierto ya que es un número entero. Pero, cuando es necesarios, podemos convertir unos tipos en otros.
Conversión y promoción de tipos
La función que podemos utilizará para convertir un tipo de dato en otra es convert(). A la que es necesario indicarle dos parámetros, en primer lugar el tipo al que deseamos convertir el dato y en segundo el dato. Aunque hay que tener en cuenta que es una función de conversión, si no es posible transformar un dato en otro obtendremos un error.
convert(Float64, 12) # 12.0
convert(Float64, π) # 3.141592653589793
convert(Int64, 12.0) # 12
convert(Int64, π) # MethodError: no method matching Int64(::Irrational{:π})En la primera línea de este ejemplo se transforman un entero en real, en la segunda un tipo irracional en un real, en la tercera se convierte un real, para el que existe una representación como entero, en entero y en la última tenemos un error porque no se puede convertir un valor irracional ene entero sin pérdida de resolución. En este punto es importante notar que si el dato no se puede transformar tendremos un error y no un dato con pérdida de resolución.
Usar la función convert() puede ser un poco tedioso, por lo que se puede realizar las conversiones utilizando solamente el tipo de dato como función. Obteniendo el mismo efecto que en el ejemplo anterior.
Float64(12) Float64(π) Int64(12.0)
Además de las conversiones existen las promociones que es lo que se utiliza cuando se opera con valores de diferente tipo. En este caso se se llevan todos los datos al de mayor precisión. Por ejemplo, al escribir la operación x = 2 * π el resultado en la variable x es de tipo Float64, a pesar de que 2 en un entero y π es irracional. Como hemos visto la operación se realiza de forma automática, aunque la podemos forzar mediante la función promote(), la cual devuelve una tupla con los valores promocionados al tipo de mayor resolución en la que se pueden representar todos los datos. Por ejemplo, x = promote(2, π, im) devuelve una tupla de tipo Complex{Int64} ya que el tercer valor es de tipo complejo.
Afortunadamente no es necesario que nos preocupemos de la promoción de tipos ya que Julia lo hace automáticamente cuando es necesario.
Tipos de datos abstractos
En Julia los tipos de datos son objetos, por eso unos heredan de otros. Por ejemplo, el tipo Int64 hereda de Signed, este a su vez hereda de Real que hereda de Number el cual tiene hereda del tipo base Any.
En este árbol hay tipos de datos que son abstractos como es el caso de Signed, Real y Number. Lo que significa que no se pueden existir instancias de objetos de este tipo. Un concepto que conciso para los que estén familiarizados con los conceptos de la programación orientada a objetos (POO). Para los que no están facilitados con la POO, los tipos abstractos solo son un “nombre” que permite agrupar a diferentes subtipos, pero puede usarse como una anotación de tipo.
Esto es algo que se puede ver en el siguiente ejemplo.
n::Integer = 12 typeof(n) # Int64
El valor que devuelve typeof es Int64 no Integer porque este ultimo es abstracto. Pero este código no permite evitar que se asigne un valor real a n, ya que ningún Float hereda de Integer.
n::Integer = 12.10 # InexactError: Int64(12.1)
Tipos definidos por el usuario
Como ya hemos visto al hablar de las estructuras es posible crear tipos de datos en Julia personalizados, combinando los tipos de datos del lenguaje. Siguiendo con el ejemplo de la entrada anterior, se puede crear un tipo de dato Punto con dos valores reales.
struct Punto
x::Float64
y::Float64
end
p = Punto(1, 2)Las estructuras de Julia son como objetos sin métodos lenguajes como C# o Java. Formados únicamente por propiedades.
A diferencia de otros lenguajes orientados a objetos como Python o Java, donde se llama a una función de un objeto como mediante la notación punto object.func(args) en Julia usa la sintaxis func(object, args). Una notación similar a las clases S3 de R. Esto es así porque Julia no tiene clases, por lo que se mantienen separados los datos de las funciones.
Si necesitamos conocer el nombre de las propiedades de una estructura podemos usar la función fieldnames. Aplicándolo a la estructura de ejemplo se puede usar fieldnames(Punto) o fieldnames(typeof(p)) para obtener (:x, :y).
¿Cuándo dos valores son iguales o diferentes?
En Julia existen dos operadores de comparación. El primero eso == y nos indica si los dos valores son iguales. Por otro lado, existe un operador con tres signos de igualdad === que comprueba si los dos son el mismo objeto. Por ejemplo, si comparamos un valor entero son su versión real == devolverá verdadero, mientras que === devolverá falso.
10 == Float64(10) # true 10 === Float64(10) # false
En el caso de estructuras la comparación es más compleja. Ya que dependerá de si el tipo es mutable o no. En el caso de las estructuras inmutables Julia optimiza los recursos y si se crea dos objetos iguales usará la misma instancia, por eso tanto el operador == como === devuelven el valor verdadero.
struct Punto
x::Float64
y::Float64
end
p1 = Punto(1, 2)
p2 = Punto(1, 2)
p1 == p2 # true
p1 === p2 # truePor otro lado, cuando es mutable en cada ocasión se crea un objeto diferente, por lo que ambos operadores devuelven falso en esta ocasión.
mutable struct PuntoMutable
x::Float64
y::Float64
end
p1 = PuntoMutable(1, 2)
p2 = PuntoMutable(1, 2)
p1 == p2 # false
p1 === p2 # falseEsto es así porque los objetos son objetos diferentes, aunque los datos sean los mismos, y no se ha definido una función para el operador de comparación. Algo que se puede hacer fácilmente como se muestra a continuación.
function Base.:(==)(p1::PuntoMutable, p2::PuntoMutable)
return p1.x == p2.x && p1.y == p2.y
end
p1 == p2 # trueUnión de tipos
Anteriormente hemos creado dos tipos de datos que implementan un punto: Puntoy PuntoMutable. En el caso de que queremos hacer una operación sobre ellos es necesario sobrecargar el operador para todos los casos posibles. Esto es:
import Base.:+ +(p::Punto, q::Punto) = Punto(p.x + q.x, p.y + q.y) +(p::PuntoMutable, q::PuntoMutable) = Punto(p.x + q.x, p.y + q.y) +(p::Punto, q::PuntoMutable) = Punto(p.x + q.x, p.y + q.y) +(p::PuntoMutable, q::Punto) = Punto(p.x + q.x, p.y + q.y) p1 = Punto(1, 2) p2 = PuntoMutable(3, 4) p1 + p2 # Punto(4.0, 6.0)
Pero esto puede ser un poco tediosos, ya que es necesario escribir el mismo método cuatro veces. Esto se puede simplificar definiendo una unión de tipos, para que así se puede usar uno u otro de forma indiferente en las definiciones. En nuestro caso podemos crear la unión MiPunto que se puede usar como un tipo a la hora de definir funciones.
MiPunto = Union{Punto, PuntoMutable}
+(p::MiPunto, q::MiPunto) = Punto(p.x + q.x, p.y + q.y)
p1 + p2Esto no es solo útil para la sobrecarga de operadores, sino que también para las funciones.
Conclusiones
Hoy hemos visto más en profundidad los tipos de datos en Julia. Cómo heredan unos de otros y cómo podemos comparar que dos datos son el mismo. Finalmente hemos visto por que en las estructuras mutables cuando definimos dos con los mismos valores Julia nos indica que son iguales y el mismo objeto. Mientras que si son inmutables la comparación es siempre falsa, salvo que se defina sobrescriba el operador de igualdad.
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