Introducción a Julia¶

Vamos a dar una breve introducción al lenguaje Julia

1. Primitivas, funciones básicas y operdores¶

El comando para mostrar un resultado en pantalla es println(), como se ve a continuación

In [1]:

println("Hello Julia!")

Hello Julia!

Los comentarios de una sola linea empiezan con #, mientras que los multilinea empiezan con #= y terminan con =#

In [2]:

println("Este si")
# println("Este no")
#=
println("Mucho menos")
println("estos dos")
=#

Este si

Existen tambien varios tipos de números, pasando por los enteros, punto flotante, complejos y racionales

In [3]:

# Int64
3

# Float64
3.2

# Complex{Int64}
2 + 1im

# Rational{Int64}
2//3

Out[3]:

2//3

También como tal se pueden aplicar las diferentes operaciones entre números

In [4]:

+ 1 # => 2
- 1 # => 7
* 2 # => 20
/ 5 # => 7.0
/ 2 # => 2.5
div(5, 2) # => 2
\ 35 # => 7.0
^ 2 # => 4
% 10 # => 2

Out[4]:

También se pueden aplicar las operaciones binarias o bitwise

In [5]:

~2 # => -3   # not
& 5 # => 1 # and
| 4 # => 6 # or
$ 4 # => 6 # xor
>>> 1 # => 1 # corrimeinto lógico a la derecha
>> 1  # => 1 # corrimeinto aritmético a la derecha
<< 1  # => 4 # corrimeinto lógico/aritmético a la izquierda

Out[5]:

Los valores booleanos son true y false, sin mayúscula inicial, y se presentan a continuación

In [6]:

!true # => false
!false # => true
== 1 # => true
== 1 # => false
!= 1 # => false
!= 1 # => true
< 10 # => true
> 10 # => false
<= 2 # => true
>= 2 # => true

Out[6]:

true

Otra característica es que los comparadores se pueden poner encadenados

In [7]:

1 < 2 < 3 # => true
2 < 3 < 2 # => false

Out[7]:

false

Las cadenas van entre comilla doble, los caracteres en comilla sencilla y se puede usar la interpolación de cadenas, a continuación se muestran dos maneras de poner valores en estas

In [8]:

@printf "%d is less than %f" 4.5 5.3 # => "5 is less than 5.300000"
"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"

5 is less than

Out[8]:

"2 + 2 = 4"

5.300000

2. Variables y colecciones¶

Las variables no necesariamente deben ser tipadas, por lo que no deben instanciarse antes de asignarlas

In [9]:

some_var = 5
some_var

Out[9]:

Lo cual no significa que acceder a una variable antes de asignarla no genere un error (de paso se muestra el manejo de errores)

In [10]:

try
    some_other_var # => ERROR: some_other_var no definida
catch e
    println(e)
end

UndefVarError(:some_other_var)

Para las listas hay que tener en cuenta que el indice va desde 1 hasta n

In [11]:

a = Int64[]  # arreglo vacio
push!(a,1)   # => [1]
push!(a,2)   # => [1,2]
a[1]

Out[11]:

La instanciación puede indicar el tipo o dejarlo de manera automática

In [12]:

b = [4, 5, 6]     # => Int64 [4, 5, 6]
b = [4; 5; 6]     # => Int64 [4, 5, 6]
b = Int8[4, 5, 6] # => Int8  [4, 5, 6]
b[1]   # => 4
b[end] # => 6

Out[12]:

El signo de exclamación ! al final de una función indica que esta modifica el estado de los parámetros

In [13]:

arr = [5,4,6]
sort(arr)  # => [4,5,6]; arr es [5,4,6]
sort!(arr) # => [4,5,6]; arr es [4,5,6]

Out[13]:

3-element Array{Int64,1}:
 4
 5
 6

Los arreglos pueden ser creados a partir de rangos, y para acceder a estos puede igual hacerse por rangos (slice)

In [14]:

a = [1:5;] # => Int64 [1,2,3,4,5]
a[1:3]     # => [1, 2, 3]
a[2:end]   # => [2, 3, 4, 5]

Out[14]:

4-element Array{Int64,1}:
 2
 3
 4
 5

Los métodos más comunes para listas son:

push!(arr, elm): agrega el elemento elm al final del arreglo arr
pop!(arr): elimina y retorna el elemento final del arreglo arr
shift!(arr): elimina y retorna el primer elemento del arreglo arr
unshift!(arr, elm): agrega el elemento elm al principio del arreglo arr
sort!(arr): ordena de forma ascendente el arreglo arr
splice!(arr, pos): elimina y retorna el elemento del arreglo arr en la posición pos
append!(arr1, arr2): concatena los arreglos arr1 y arr2
in(elm, arr): revisa si el elemento elm pertence al arreglo arr
lenght(arr): devuelve la cantidad de elementos en el arreglo arr

Las tuplas se comportan de manera similar a las listas, con la excepción de que son inmutables.

In [15]:

tupla = (1, 2, 3)
otra_tupla = 1, 2, 3

Out[15]:

(1,2,3)

Para el uso de diccionarios, su instanciación puede ser vacía o con objetos

In [16]:

empty_dict = Dict() # instanciación vacía
filled_dict = Dict("one"=> 1, "two"=> 2, "three"=> 3) # instanciación con elementos

Out[16]:

Dict{ASCIIString,Int64} with 3 entries:
  "two"   => 2
  "one"   => 1
  "three" => 3

Para acceder a las llaves y valores como listas de un diccionario

In [17]:

keys(filled_dict)
values(filled_dict)

Out[17]:

Base.ValueIterator for a Dict{ASCIIString,Int64} with 3 entries. Values:
  2
  1
  3

Se puede saber si una llave o una llave-valor hacen parte del diccionario

In [18]:

in(("one" => 1), filled_dict) # => true
in(("two" => 3), filled_dict) # => false
haskey(filled_dict, "one") # => true
haskey(filled_dict, 1) # => false

Out[18]:

false

Se pueden hacer listas desordenadas sin elementos repetidos de la siguiente forma

In [19]:

empty_set = Set() # => Set{Any}()
filled_set = Set([1,2,2,3,4]) # => Set{Int64}(1,2,3,4)

Out[19]:

Set([4,2,3,1])

Sobre estos elementos se pueden hacer operaciones de conjuntos como los que se muestran a continuación

In [20]:

other_set = Set([3, 4, 5, 6]) # => Set{Int64}(6,4,5,3)
intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
setdiff(Set([1,2,3,4]),Set([2,3,5])) # => Set{Int64}(1,4)

Out[20]:

Set([4,1])

3. Control de flujo¶

Para las estructuras if-else no afecta la identación, y se muestra de la siguiente forma

In [21]:

some_var = 5

if some_var > 10
    println("some_var is totally bigger than 10.")
elseif some_var < 10
    println("some_var is smaller than 10.")
else
    println("some_var is indeed 10.")
end

some_var is smaller than 10.

El ciclo for actua sobre iterables (Range, Array, Set, Dict y AbstractString)

In [22]:

for animal=["dog", "cat", "mouse"]
    println("$animal is a mammal")
end

dog is a mammal
cat is a mammal
mouse is a mammal

En los diccionarios se puede iterar sobre la llave-valor (se puede usar indiferentemente el = o el in)

In [23]:

for (k,v) in Dict("dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal")
    println("$k is a $v")
end

mouse is a mammal
cat is a mammal
dog is a mammal

El ciclo while se realiza de la siguiente manera

In [24]:

x = 0
while x < 4
    println(x)
    x += 1
end

4. Funciones¶

Las funciones retornan la última sentencia

In [26]:

function add(x, y)
    println("x is $x and y is $y")
    x + y
end

add(1,3)

x is 1 and y is 3

Out[26]:

Se pueden hacer funciones como asignaciones también

In [27]:

f_add(x, y) = x + y # => "f (generic function with 1 method)"
f_add(3, 4) # => 7

Out[27]:

Para devolver varios valores se pueden usar tuplas

In [28]:

f(x, y) = x + y, x - y
f(3, 4) # => (7, -1)

Out[28]:

(7,-1)

Para tener una cantidad indefinida de valores se puede usar el operador splat

In [30]:

function varargs(args...)
    println(args)
end

varargs(1,2)
varargs(1,2,3,4)

(1,2)
(1,2,3,4)

Este operador también se puede usar para "distribuir" los argumentos

In [31]:

add([5,6]...) # esto es equivalente a add(5,6)
x = (5,6)     # => (5,6)
add(x...)     # esto es equivalente a add(5,6)

x is 5 and y is 6

Out[31]:

x is 5 and y is 6

Para los valores por defecto como argumentos como para la elección del parámetro

In [34]:

function defaults(a,b,x=5,y=6)
    return "$a $b and $x $y"
end
defaults(1,2)
defaults(1,2,3)


function keyword_args(;k1=4,name2="hello") # importante el ;
    return Dict("k1"=>k1,"name2"=>name2)
end
keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]

Out[34]:

Dict{ASCIIString,Any} with 2 entries:
  "name2" => "ness"
  "k1"    => 4

In [ ]: