Tutorial de programación en Julia para principiantes

¿Cómo instalar y ejecutar Julia? 

Instalar Julia es muy sencillo. Descarga el instalador para tu sistema operativo en esta página del sitio web de Julia y marca la casilla para añadir Julia al PATH del sistema. Si escribes julia en la línea de comandos y obtienes la siguiente salida, todo está funcionando correctamente.

Instalación y ejecución del lenguaje de programación Julia

Tanto PyCharm como VSCode ofrecen plugins de Julia con soporte para resaltado de código y depuración. Sin embargo, como muchos científicos de datos prefieren trabajar en JupyterLab, también es fácil añadir un kernel de Julia a JupyterLab. Tras entrar en el prompt de julia en el terminal, basta con introducir estas dos líneas:

using Pkg
add("IJulia")

El código añade el paquete IJulia a la instalación de Julia del sistema. Reinicia cualquier sesión abierta de JupyterLab y deberías ver la opción de Julia en el Launcher.

Julia ejecutándose en JupyterLab

Sintaxis básica de Julia

En esta sección veremos los fundamentos de la sintaxis de Julia, incluidas variables, tipos de datos, operadores, vectores y más.

Operadores  

En programación, hay caracteres especiales llamados operadores que representan procesos matemáticos o lógicos concretos. A continuación verás los operadores más habituales, como suma, resta, multiplicación, división y más. 

Nota: En Julia, los comentarios se escriben con el carácter #. Todo lo que escribas tras el # será ignorado por el programa (hasta el final de la línea).

# Addition in Julia
37 + 73

110

# Subtraction in Julia
17 - 19

-2

# Multiplication in Julia
29 * 33

957

# Division in Julia
22 / 7

3.142857142857143

# Backwards division in Julia, the above is equal to 0 / 5.
5 \ 0

0

# The remainder operator in Julia 
98456 % 23

16

# Raising to the power 2 (squaring)
(22 / 7) ^ 2

9.877551020408163

# Raising to the power 3 (cubing)
-7 ^ 3

-343

# Raising to the power 0.5 (square-rooting)
(355 / 133) ^ 0.5

1.633760365638372

Variables

En programación usamos variables para almacenar información. Gracias a ellas es fácil referirse a una información mediante un nombre. Por ejemplo, aquí guardamos el número 73 en una variable llamada a, y la cadena “Hello world!” en la variable “word” (veremos los distintos tipos de datos de Julia en la siguiente sección). Escribir el nombre de la variable en la línea de comandos imprime su valor.

# Storing the number 73 in a variable a
a = 73
a

73

# Storing "Hello world!" in word
word = "Hello world!"
word

Hello world!

Todos los operadores y funciones de Julia funcionan igual con variables.

# Multiplying two numeric variables
a = 73
b = 37
a * b

2701

Puedes usar cualquier carácter alfanumérico en los nombres de variables, incluidos guiones bajos. Aun así, hay ciertas convenciones al nombrarlas en Julia. Los nombres de variables:

• usan lower_snake_case (minúsculas y palabras separadas por guiones bajos)
• no pueden empezar por un número.

Introducción a los tipos de datos en Julia 

Los tipos de datos le indican al programa qué valores puede tomar una variable y qué operadores matemáticos o lógicos se pueden usar sin provocar un error. En Julia hay varios tipos; a continuación tienes los más básicos.

Puedes imprimir el tipo de una variable con la función typeof():

# Getting the type of 3.14
typeof(3.14)

Float64

Al realizar operaciones en Julia, debes tener en cuenta las consecuencias de mezclar tipos. Por ejemplo, multiplicar un flotante y un entero devuelve un flotante.

# Bank balance as an integer
balance = 100

# Interest rate as a float
interest_rate = 1.05

# Interest rate as a float
new_balance = balance * interest_rate

typeof(new_balance)

Float64

En cambio, operar con cadenas y tipos numéricos suele dar error, como en el siguiente caso.

# Bank balance as an integer
balance = 100

# Interest rate as a string
interest_rate = “5%”

# Interest rate as a float
new_balance = balance * interest_rate

ERROR: MethodError:
no method matching *(::Int64, ::String)

Convertir tipos de datos en Julia 

Es posible convertir distintos tipos de datos mediante funciones incluidas en Julia. A continuación, una tabla con conversiones habituales. 

Trabajar con caracteres y cadenas en Julia 

Ya vimos los tipos de datos carácter y cadena en la sección anterior; ahora profundizaremos en operaciones comunes con ambos. Recuerda: una cadena es una serie ordenada de caracteres o texto entre comillas dobles. 

# A string is a series of characters
word = "Hello world!"
word

"Hello world!"

Para escribir una cadena multilínea, puedes usar comillas triples:

multi_line = """
   This is a
   multi-line string.
"""
print(multi_line)

This is a
multi-line string.

Puedes extraer información y atributos de las cadenas de varias formas. Por ejemplo, el indexado con corchetes permite extraer caracteres individuales o rangos de caracteres según su posición. En este ejemplo, 1:3 denota la secuencia de números del 1 al 3, ambos incluidos.

text = "Julia is a high-level, dynamic programming language"
# Extracting the first character in text based on its index
text[1]

'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

# Extracting the first three characters in text based on its index
text[1:3]

"Jul"

Arriba hemos puesto 1 entre corchetes y ha devuelto el primer carácter. Alternativamente, puedes usar el operador especial begin:

# Extracting the first character in text with the begin operator
text[begin]

'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

Cuando extraes un único carácter de una cadena, su tipo de dato será Char.

# Extract the type of the fourth character
typeof(text[4])

Char

# Extract the type of the fourth character
typeof(text[4])

En cambio, cuando haces un corte (slice) de más de un carácter, la salida vuelve a ser una cadena. 

# Extract the type of the first 5 characters
typeof(text[begin:5])

String

Arriba estamos extrayendo los cinco primeros caracteres de text. Ten en cuenta que ambos índices a cada lado de los dos puntos son inclusivos. A diferencia de Python, no se admiten índices negativos. En su lugar, usarás el operador end con un número negativo. Por ejemplo, para obtener el tercer carácter desde el final de la cadena, puedes escribir lo siguiente. 

# Third from the end of the string
text[end-2]

'a': ASCII/Unicode U+0067 (category Ll: Letter, lowercase)

Operaciones comunes con cadenas en Julia 

Puedes usar la función length() para contar el número de caracteres de una cadena.

# Count the number of characters in a string
length(text)

51

Una tarea habitual es combinar dos o más cadenas. Puedes hacerlo con la función string(), pasando las cadenas separadas por comas.

# Creating one string from "Julia", "is", "awesome"
string("Julia ", "is ", "awesome!")

"Julia is awesome!"

También puedes usar el operador * (multiplicación) para unir cadenas.

# Creating one string by multiplying strings
"73 " * "is " * "the " * "best " * "prime."

"73 is the best prime."

En ambos casos, recuerda dejar un espacio entre palabras. Otra forma de unir cadenas es repitiendo una cadena varias veces. Así se hace con el operador ^ (exponenciación):

# Creating one string with the exponentiation operator
"Three times the fun!" ^ 3

"Three times the fun! Three times the fun! Three times the fun!"

Arrays en Julia 

Otro tipo de dato muy común en Julia, y en otros lenguajes, son los arrays (así se llaman en Julia). Un array es una lista de valores entre corchetes []. Se nombran de forma distinta según sus dimensiones. 

• Los arrays unidimensionales se llaman vectores.
• Los bidimensionales se llaman matrices.
• Los de tres dimensiones o más se llaman simplemente arrays.

En este tutorial nos centraremos exclusivamente en los vectores. Se crean pasando elementos entre corchetes, como verás abajo.

# Define a three-integer vector
x = [1, 2, 3]

3-element Vector{Int64}:
1
2
3

# Get the type of x
typeof(x)

Vector{Int64} (alias for Array{Int64, 1})

El vector x tiene tipo Vector, que es un alias de un array unidimensional (como indica la salida alias for Array{In664, 1}). Todos sus elementos son de tipo Int64. Pero no siempre es obligatorio que todos sean del mismo tipo. Por ejemplo, aquí tienes un vector con elementos de distintos tipos. 

# Define a vector with various data types
array = [1, "Hello", 22/7]

3-element Vector{Any}:
1
"Hello"
3.142857142857143

Como ves, el vector muestra Any entre llaves, lo que indica múltiples tipos de datos. Incluso puedes introducir vectores dentro de otros vectores.

# Define a vector with various data types, including another vector
array = [1, 2, 3, ["Hello", 73]]

4-element Array{Any,1}:
1
2
3
Any["Hello", 73]

La función length() funciona igual con vectores que con cadenas: cuenta el número de elementos del array.

# Get the length of a vector
length(array)

3

Las reglas de indexado también son similares: aquí indexamos el primer y el segundo elemento del array.

# Get the first element of a vector
array = [1, "Hello", 22/7]
array[begin]

1

# Get the last element of a vector
array[end-1]

"Hello"

Operadores booleanos y comparaciones numéricas 

Los lenguajes de programación usan valores booleanos para implementar lógica. Un booleano solo puede tener dos valores: true o false. Son especialmente útiles al trabajar con comparaciones numéricas y operadores booleanos. Veamos primero las comparaciones numéricas.

Operadores de comparación numérica en Julia

En la siguiente tabla encontrarás los operadores de comparación numérica más utilizados en Julia. Como verás en los ejemplos, puedes comparar booleanos, objetos numéricos y más usando estos operadores.  Ten en cuenta que puedes usar uno o dos símbolos para escribir menor/mayor o igual que. Para la versión de un símbolo, escribe \le y TAB o \ge y TAB.

Operadores booleanos en Julia

Además de las comparaciones numéricas, existen operadores booleanos —como y/o—. Sirven para combinar dos o más expresiones booleanas en una sola. A continuación verás los más comunes y cómo se usan. 

Sintaxis intermedia de Julia

Sentencias condicionales en Julia

Con valores y operadores booleanos puedes escribir sentencias condicionales. Por ejemplo: si algo se evalúa como true, realiza una operación; si es false, realiza otra. A estas sentencias se las llama if/else. Así se escriben:

if true
   print("Do something")
else
   print("Do something else")
end

Siempre que la condición tras la palabra clave if se evalúe como true, se ejecutará el bloque if; en caso contrario, se ejecutará el bloque else. Este ejemplo muestra una condición que comprueba si un número es par o impar.

number = 5

if number % 2 == 0
   print("The number is even")
else
   print("The number is odd")
end

The number is odd

En la expresión tras if usamos el operador módulo, %, para comprobar si el número devuelve 0 como resto al dividirlo entre 2. Se evalúa como falso porque el resto de dividir 5 entre 2 es 1. Por lo tanto, se ejecuta la cláusula else. Ahora usemos lo aprendido sobre operadores booleanos y condicionales para escribir un programa que compruebe si un número es positivo, negativo o cero. 

number = 0

if number > 0
   print("The number is positive.")
elseif number == 0
   print("The number is equal to zero.")
else
   print("The number is negative.")

end

The number is equal to zero.

Añadimos la nueva condición con la cláusula elseif. Se usa cuando hay que comprobar dos o más condiciones en orden exacto. 

Bucles for 

Un bucle for se utiliza para iterar y realizar operaciones sobre cada elemento de una secuencia (cadena, vector, tupla, conjunto, etc.) en orden. La sintaxis es sencilla en Julia. Por ejemplo, creemos un bucle que imprima cada elemento de un vector:

languages = ["Julia", "Python", "R"]

for lang = languages
   println(lang)

end

Julia
Python
R

El bucle comienza con la palabra clave for. Luego elegimos un nombre de variable temporal: en este caso, lang, cuyo valor cambia al recorrer el vector languages. Para indicar que iteramos sobre languages, escribimos su nombre tras el operador de asignación =.

Dentro del bucle usamos la función println() para imprimir cada elemento de languages, representado por la variable temporal lang. Se llama temporal porque no es accesible una vez termina el bucle.

Nota: La diferencia entre print() y println() es que println() imprime cada elemento en una línea nueva.

Puedes usar todo lo aprendido hasta ahora dentro de bucles for. Por ejemplo, creemos un array de 10 enteros e imprimamos solo los impares:

integers_vector = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i = integers_vector
   # Print only odd numbers
   if i % 2 == 1
       println(i)
   end
end

1
3
5
7
9

No olvides cerrar tanto el bucle for como la sentencia if con end.

También puedes iterar sobre cadenas, ya que son secuencias. Aquí, por ejemplo, imprimimos cada letra de la cadena "Julia".

for letter = "Julia"
   println(letter)

end

J
u
l
i
a

Instalar paquetes en Julia 

Todos los operadores (+, -, *, ^), funciones (print(), println(), typeof()) y palabras clave (for, if, else) que hemos usado vienen con la instalación de Julia. Sin embargo, ese código base no basta para resolver todos los problemas. Necesitamos instalar paquetes para cargar herramientas y funciones con funcionalidad adicional. Los paquetes son bibliotecas de código (escrito por otras personas) que podemos añadir a nuestra instalación de Julia para resolver problemas concretos.

Por ejemplo, instalaremos dos paquetes llamados DataFrames y CSV, que ayudan a manipular información en archivos CSV. Así es como se hace:

using Pkg
Pkg.add("DataFrames")
Pkg.add("CSV")

Pkg es el gestor de paquetes global de Julia. Su función add() añade nuevos paquetes a la instalación. Para importar todos los nombres de funciones de las bibliotecas, las cargamos con la palabra clave using al principio de nuestros scripts.

using DataFrames
using CSV

Usaremos sus funciones en la siguiente sección.

Primeros pasos con DataFrames 

Un DataFrame es un tipo de dato especial en lenguajes para ciencia de datos como Julia, Python o R, diseñado para trabajar con tablas. El formato más popular para almacenar tablas es CSV (comma-separated values). La librería DataFrame nos ofrece herramientas para cargar estos archivos y manipular la información.

Importar archivos CSV

Para este tutorial importaremos el conjunto de datos diamonds. El archivo diamonds.csv tiene este aspecto:

Accede aquí al conjunto de datos diamonds

La primera línea se llama cabecera y contiene los nombres de las columnas. Carguémoslo con los paquetes CSV y DataFrames.

# Load in the diamonds DataFrame
diamonds = DataFrame(CSV.File("data/diamonds.csv"))
typeof(diamonds)

DataFrame

Pasamos la ruta del archivo CSV a CSV.File(), que a su vez se pasa a la función DataFrame(). La salida de typeof() confirma que la operación ha sido correcta.

Manipulación sencilla de datos 

Lo primero que conviene hacer con un DataFrame nuevo es imprimir algunas filas para ver su estructura. Puedes hacerlo con la función first().

# Print the first 7 rows of diamond
first(diamonds, 7)

7 × 10 DataFrame

Primeras 7 filas del conjunto de datos diamonds

La función first() devuelve las primeras n filas de un DataFrame. Como vemos, hay 6 columnas numéricas y 3 categóricas (texto). El índice también cuenta como columna en los DataFrames de Julia. 

También existe la función last(), similar a first(). Ya te imaginas lo que hace por el nombre: sí, obtiene las últimas n filas.

Otra función útil es size(). Imprime el número de filas y columnas de un DataFrame.

# Print the dimensions of diamonds
size(diamonds)

(10000, 10)

El nuestro tiene 10 000 filas y 10 columnas (incluido el índice). A simple vista no podemos abarcar 10k filas, así que usamos estadísticas descriptivas para hacernos una idea de la distribución de las columnas. Para ello, utilizamos la función describe()

# Summary statistics of diamonds using describe()
describe(diamonds)

10 × 7 DataFrame

Salida de la función describe()

La salida es una tabla resumen con 7 columnas. Las columnas min, max, mean y median solo aplican a columnas numéricas. En la columna eltype puedes ver los tipos de datos de cada columna en diamonds. Los números junto a String se refieren a la longitud de la cadena más larga en esa columna.

También puedes usar la siguiente sintaxis para seleccionar columnas individuales del DataFrame.

# Extracting the first 10 rows of the cut column
diamonds[:, :cut][begin:10]

10-element PooledArrays.PooledArray{String15,UInt32,1,Array{UInt32,1}}:

"Ideal"
"Ideal"
"Ideal"
"Premium"
"Fair"
"Premium"
"Very Good"
"Ideal"
"Ideal"
"Premium"

El primer colon dentro de los corchetes selecciona todas las filas. Después, especificamos el nombre de la columna tras una coma y otro colon (sin comillas). Luego, indexamos el array devuelto para seleccionar las diez primeras filas. Para simplificar aún más el código anterior, podemos seleccionar directamente las diez primeras filas dentro de los primeros corchetes, así:

# Extracting the first 10 rows of the cut column
diamonds[1:10, :carat]

10-element PooledArrays.PooledArray{String15,UInt32,1,Array{UInt32,1}}:

"Ideal"
"Ideal"
"Ideal"
"Premium"
"Fair"
"Premium"
"Very Good"
"Ideal"
"Ideal"
"Premium"

Para seleccionar varias columnas, coloca los nombres de columna (con dos puntos) dentro de corchetes.

# Extracting the first 5 rows of the cut, carat, price columns
diamonds[1:5, [:carat, :cut, :price]]

5 × 3 DataFrame

Las primeras 5 filas y 3 columnas del conjunto diamonds

Ejecutemos describe() solo sobre las columnas numéricas

# Running describe on numeric columns only
describe(diamonds[:, [:carat, :depth, :table, :price, :x, :y]])

Ejecutar describe() solo en columnas numéricas

Para ver el DataFrame ordenado en orden ascendente según una columna, usa la función sort():

# Sort diamonds and see the first 5 rows
sorted_diamonds = sort(diamonds, :price)
first(sorted_diamonds, 5)

Tabla ordenada

Para ordenar en descendente, envuelve la función order() alrededor del nombre de la columna.

# Sort diamonds in descending order and see the first 5 rows
sorted_diamonds = sort(diamonds, order(:price, rev=true))
first(sorted_diamonds, 5)

Tabla ordenada en descendente

¡Genial! Ya puedes cargar DataFrames y hacer una exploración básica.

Aprende más sobre Julia 

Aunque Julia es un lenguaje joven, ya existen muchos recursos para dominarlo. Aquí tienes algunos para impulsar tus habilidades:

• El auge de Julia — ¿merece la pena aprenderlo en 2022?
• Pasar de MATLAB a Julia
• Echa un vistazo a nuestras chuletas, que cubren todas las herramientas y tecnologías de datos, incluida Julia
• Descubre nuestro curso Introduction to Julia