• Saltar al contenido principal
  • Skip to secondary menu
  • Saltar a la barra lateral principal
  • Saltar al pie de página
  • Inicio
  • Secciones
    • Ciencia de datos
    • Criptografía
    • Herramientas
    • Machine Learning
    • Noticias
    • Opinión
    • Productividad
    • Programación
      • JavaScript
      • Julia
      • Matlab
      • Python
      • R
  • Programación
    • JavaScript
    • Julia
    • Matlab
    • Python
    • R
  • Noticias
  • Boletín
  • Contacto
  • Tienda
    • Libros
    • Equipamiento de oficina
    • Equipamiento en movilidad
    • Tiendas afiliadas
      • AliExpress
      • Amazon
      • Banggood
      • GeekBuying
      • Lenovo

Analytics Lane

Ciencia e ingeniería de datos aplicada

  • Ciencia de datos
  • Machine Learning
  • Python
  • Pandas
  • NumPy
  • Matlab
  • Julia
  • Excel
  • IA Generativa

Estructuras en Julia (7ª parte – ¡Hola Julia!)

agosto 4, 2020 Por Daniel Rodríguez Deja un comentario
Tiempo de lectura: 6 minutos

Hasta este momento en todas las entradas solamente se han utilizado los tipos de datos disponibles de forma nativa en Julia. A pesar de existir una gran calidad de tipos, no son suficientes para subir cualquier situación. Por lo que puede ser necesario crear tipos de datos personalizados. Algo que se puede conseguir mediante el uso de las estructuras en Julia.

Tabla de contenidos

  • 1 Creación de una estructura en Julia
  • 2 Estructuras mutables
  • 3 Estructura dentro de estructuras
  • 4 Tipos de datos dentro de las estructuras
  • 5 Sobrecarga de funciones
  • 6 Sobrecarga de operadores
  • 7 Tipos mutables y no mutables en funciones
  • 8 Retornar tipos
  • 9 Constructores
  • 10 Muchas posibilidades con las estructuras en Julia
  • 11 Publicaciones de la serie ¡Hola Julia!

Creación de una estructura en Julia

Cuando necesitamos un tipo de dato personalizado podemos recurrir a las estructuras. Estas se crean con la palabra reservada struct seguida del nombre que se le queremos asignar. En las siguientes líneas, hasta que se encuentra la palabra end, enumeramos todos las propiedades que deseamos incluir en la estructura. Por ejemplo, si queremos crear un tipo Punto en un espacio bidimensional solamente hay que escribir.

struct Punto
    x
    y
end

En donde la estructura contiene dos propiedades x e y. Para crear un objeto de este tipo solamente hay que llamar a la estructura seguida de las propiedades entre paréntesis. Usando la notación punto para acceder a cada uno de los elementos.

p = Punto(3, 4)

p.x # 3
p.y # 4

Publicidad


Estructuras mutables

Por defecto las estructuras son inmutables, por lo que sí intentamos cambiar el valor de una propiedad de una estructura tendremos un error. Esto es, al escribir p.x = 2 en el caso anterior Julia nos dará un error del tipo setfield! immutable struct of type Punto cannot be changed.

Tutorial de Mypy para Principiantes
En Analytics Lane
Tutorial de Mypy para Principiantes

La solución es usar el modificador mutable antes de definir la estructura, con lo que se podrán cambiar los valores de las propiedades.

mutable struct PuntoMutable
    x
    y
end

p = PuntoMutable(3, 4)

p.y = 3

En este ejemplo vemos que el punto creado inicialmente como (3, 4) se puede convertir sin problemas en (3, 3). Ya que ahora la estructura es mutable.

Estructura dentro de estructuras

Las estructuras también se pueden usar dentro de otras estructuras, lo que facilita la creación de tipos más complejos. Por ejemplo, podemos crear un objeto rectángulo donde tenemos el ancho, alto y objeto punto que defina la posición inicial.

struct Rectángulo
    ancho
    alto
    posición
end

r = Rectángulo(10, 20, Punto(2,3))

Publicidad


Tipos de datos dentro de las estructuras

En el ejemplo anterior posición es un punto porque lo hemos usado así, pero no se ha indicado de forma explícita. Por lo que también se podría crear el rectángulo de la siguiente forma r = Rectángulo(10, 20, 2) aunque sea el uso que deseamos para el tipo. Por fortuna es posible seleccionar los tipos de datos que queremos para cada propiedad. En este caso, tanto ancho como alto son números y posición es un Punto. Así se puede crear un nuevo tipo con estas definiciones.

struct RectánguloTipos
    ancho::Number
    alto::Number
    posición::Punto
end

r = RectánguloTipos(10, 20, Punto(2,3))

Ahora, si se intenta crear un RectánguloTipos con la expresión r = RectánguloTipos(10, 20, 2) Julia no lo permitirá. Generando el siguiente error MethodError: Cannot `convert` an object of type Int64 to an object of type Punto. Algo que nos puede evitar muchos problemas cuando alguien use nuestra estructura y espere que en posición se encuentre un Punto y no una cadena de texto o un valor real.

Sobrecarga de funciones

Es posible definir diferentes implementaciones de una función para operar con diferentes tipos de datos. Lo que nos ofrece una capa de abstracción. Al escribir una función que requiere un tipo de dato y otra que requiera otra Julia se encargará de ejecutar la correcta en cada momento. O de indicarnos que no existe una versión compatible. Por ejemplo, si queremos representar la posición de un punto, sea este de tipo Punto o de tipo Rectángulo se puede usar el siguiente código.

function imprimePunto(p::Punto)
    println("La coordenada es ($(p.x),$(p.y))")
end

function imprimePunto(p::Rectángulo)
    println("La coordenada es ($(p.posición.x),$(p.posición.y))")
end

imprimePunto(Punto(3, 4))
imprimePunto(Rectángulo(4, 5, Punto(1, 1)))
La coordenada es (3,4)
La coordenada es (1,1)

Aunque posiblemente la mejor implementación sea que imprimePunto para el tipo Rectángulo llame a la versión de Punto. Lo que hace el código más fácil de mantener al no duplicar líneas.

function imprimePunto(p::Rectángulo)
    imprimePunto(p.posición)
end

Publicidad


Sobrecarga de operadores

También se puede sobrecargar los operadores como suma, multiplicación, etc. Para ello es enserio importar desde Base el operador u operadores que necesitemos. Luego simplemente la definición del operador para el tipo se hace igual que como una función, usando como nombre el operador. Así para definir el operador multiplicación de un Punto solo hay que hacer lo siguiente.

import Base.*

function *(p::Punto, x::Number)
    Punto(p.x * x, p.y * x)
end

Punto(1,1) * 2 # (2, 2)

Tipos mutables y no mutables en funciones

Al ver por primera vez las funciones ya explicamos la diferencia entre los tipos mutables y no mutables. Si se pasa un tipo mutables esta podrá modificar el valor de la variable y este cambio se verá fuera de la función. Por lo que es necesario tener cuidado a la hora de trabajar con tipos mutables. Por ejemplo, se le puede sumar a un punto una posición con la siguiente función

function sumaPuntos(p::PuntoMutable, δx, δy)
    p.x += δx
    p.y += δy
end

p = PuntoMutable(1,1)
sumaPuntos(p, 2, 2)
p # (3, 3)

Observando en este caso que el valor de p al salir de sumaPuntos no es (1, 1), sino que (3, 3). Ya que el valor se ha cambiado dentro de la función.

Para evitar este comportamiento se puede usar la función deepcopy(p), lo que creará una copia profunda del dato. Es decir, una nueva instancia de este con los mismos valores.

p1 = PuntoMutable(2,2)
p2 = deepcopy(p1)
p1 ≡ p2 # False (no es el mismo objeto)
p2 == p2 # True (pero tienen los mismos valores)

Publicidad


Retornar tipos

Las funciones de Julia también pueden retornar tipos de datos que son creado por nosotros. Podemos crear una función para crear el punto medio de dos puntos y que esta retorna un nuevo Punto.

function puntoMedio(p1::Punto, p2::Punto)::Punto
    Punto((p1.x + p2.x)/2, (p1.y + p2.y)/2)
end

puntoMedio(Punto(0,0), Punto(2,2)) # (1.0, 1.0)

En este caso no es necesario que indicar que tiene que retornar un tipo Punto, ya que por defecto devuelve un tipo Any. Pero puede simplificar la lectura del código.

Constructores

Las estructuras tienen un constructor por defecto que crea Julia, simplemente los tipos seguidos de comas. Pero puede ser que el comportamiento que deseemos para nuestro tipo. Podemos pensar en valores por defecto o calculados. En estos casos hay que recurrir a los constructores. Los cuales son funciones con el nombre del tipo que se escriben dentro de la estructura.

struct Punto
    x
    y
     
    function Punto(x::Number=0, y::Number=0)
        new(x,y)
    end
end

Punto(1) # (1, 0)

Quizás lo más importante es que para crear el tipo dentro del constructor hay que llamar a new dentro de la función y no al tipo. Además de esto, al definir valores por defecto, evitamos que sea necesario incluir toda la información.

Esto se puede extender al tipo Rectángulo para crear dos constructores, uno que función con Punto y otro que funcione con cuatro números.

struct RectánguloTipos
    ancho::Number
    alto::Number
    posición::Punto
    
    function RectánguloTipos(ancho::Number=5, alto::Number=5, posición::Punto=Punto())
        new(ancho, alto, posición)
    end
    
    function RectánguloTipos(ancho::Number=5, alto::Number=5, x::Number=0, y::Number=0)
        new(ancho, alto, Punto(x, y))
    end
end

RectánguloTipos(10, 2, Punto(1,2))
RectánguloTipos(10, 2, 2, 2)

Publicidad


Muchas posibilidades con las estructuras en Julia

Las estructuras en Julia es un recurso que ofrece muchas posibilidades a los usuarios. Crear nuestros propios tipos de datos nos puede ayudar a crear mejores programas.

Tal vez la única mala noticia es que Julia, hoy en día, no cuenta con clases en el sentido de programación orientada a objetos. El paradigma principal es la sobrecarga de funciones para trabajar de forma coherente con los datos.

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

¿Te ha parecido de utilidad el contenido?

¡Puntúalo entre una y cinco estrellas!

Puntuación promedio 0 / 5. Votos emitidos: 0

Ya que has encontrado útil este contenido...

¡Síguenos en redes sociales!

¡Siento que este contenido no te haya sido útil!

¡Déjame mejorar este contenido!

Dime, ¿cómo puedo mejorar este contenido?

Publicidad


Publicaciones relacionadas

  • Tutorial de Mypy para Principiantes
  • Semana sin nuevas publicaciones
  • Combinar gráficos con FacetGrid: Cómo analizar tendencias complejas en múltiples paneles con Seaborn
  • Introducción a igraph en R (Parte 6): Centralidad de Katz en grafos
  • Cómo modificar los mensajes de commit en Git
  • Optimización de memoria en Pandas: Usar tipos de datos personalizados para manejar grandes conjuntos de datos
  • Introducción a igraph en R (Parte 7): Centralidad de Bonacich
  • ¡Analytics Lane cumple siete años!
  • Sincronizar múltiples ejes con twinx(): Comparación de datos con diferentes escalas en un solo gráfico con Matplotlib

Publicado en: Julia

Interacciones con los lectores

Deja una respuesta Cancelar la respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

I accept the Terms and Conditions and the Privacy Policy

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Barra lateral principal

Suscríbete a nuestro boletín

Suscríbete al boletín semanal para estar al día de todas las publicaciones.

Política de Privacidad

Analytics Lane en redes sociales

  • Amazon
  • Bluesky
  • Facebook
  • GitHub
  • Instagram
  • Mastodon
  • Pinterest
  • RSS
  • Telegram
  • Tumblr
  • Twitter
  • YouTube

Publicidad

Entradas recientes

Variables globales en Python: Problemas y cómo evitarlos

mayo 12, 2025 Por Daniel Rodríguez

Los valores numéricos en los ordenadores: Entendiendo enteros, flotantes y más

mayo 9, 2025 Por Daniel Rodríguez

Introducción a igraph en R (Parte 8): PageRank

mayo 7, 2025 Por Daniel Rodríguez

Publicidad

Es tendencia

  • Método del codo (Elbow method) para seleccionar el número óptimo de clústeres en K-means publicado el junio 9, 2023 | en Ciencia de datos
  • Seleccionar la opción para compactar la base de datos en Microsoft SQL Server Manager Studio Reducir el tamaño en SQL Server de una base de datos publicado el febrero 10, 2023 | en Herramientas
  • Operaciones de filtrado de DataFrame con Pandas en base a los valores de las columnas publicado el mayo 10, 2019 | en Python
  • Diferencias entre CPU, GPU, TPU y NPU publicado el abril 19, 2023 | en Herramientas
  • Variables globales en Python: Problemas y cómo evitarlos publicado el mayo 12, 2025 | en Python

Publicidad

Lo mejor valorado

4.9 (24)

Seleccionar filas y columnas en Pandas con iloc y loc

4.6 (16)

Archivos JSON con Python: lectura y escritura

4.4 (14)

Ordenación de diccionarios en Python mediante clave o valor

4.7 (13)

Operaciones de filtrado de DataFrame con Pandas en base a los valores de las columnas

4.5 (10)

Diferencias entre var y let en JavaScript

Publicidad

Comentarios recientes

  • Daniel Rodríguez en Tutorial de Mypy para Principiantes
  • Javier en Tutorial de Mypy para Principiantes
  • javier en Problemas con listas mutables en Python: Cómo evitar efectos inesperados
  • soldado en Numpy básico: encontrar la posición de un elemento en un Array de Numpy
  • plataformas AéReas en Numpy básico: encontrar la posición de un elemento en un Array de Numpy

Publicidad


Footer

Analytics Lane

  • Acerca de Analytics Lane
  • Boletín de noticias
  • Contacto
  • Libros
  • Lo más popular
  • Noticias
  • Tienda
  • Tiendas afiliadas

Secciones

  • Ciencia de datos
  • Criptografía
  • Herramientas
  • Machine Learning
  • Opinión
  • Productividad
  • Programación
  • Reseñas

Sobre de Analytics Lane

En Analytics Lane tratamos de explicar los principales conceptos de la ciencia e ingeniería de datos con un enfoque práctico. Los principales temas tratados son ciencia de datos, ingeniería de datos, inteligencia artificial, machine learning, deep learning y criptografía. Además, también se habla de los principales lenguajes de programación y herramientas utilizadas por los científicos e ingenieros de datos.

Copyright © 2018-2025 Analytics Lane ·Términos y condiciones ·Política de Cookies ·Política de Privacidad ·Herramientas de privacidad ·Contacto