Lecturas
Lectura: «Julia Documentation» ―Varios
Fuente: http://docs.julialang.org/en/stable.
Blah, blah, blah, …
Lectura: «Julia ― Future Python» ―Mosin Hasan
Fuente(s):
Section 1: Introducción
Introducción y Julia versus Python
Introducción a Julia
- Combinación de simplicidad, poder y eficiencia en un único lenguaje
- Diseñado para cómputo científico, esto include: machine learning, data mining, álgebra lineal a gran scala, cómputo paralelo y distribuido.
- Es un lenguaje de código abierto (open source) con una licencia liberal.
- Proporciona la velocidad de C a la vez que el dinamismo de Ruby.
- Proporciona macros reales al estilo de Lisp.
- Facilita el uso de las matemáticas al igual que Matlab.
- Plantea una solución de compromiso entre la programación general tipo Python, y la facilidad de programación estadística tipo R.
- Proporciona facilidades para la manipulación de cadenas de caracteres tipo Perl.
- Es compilado JIT, pero también puede ser usado de modo interactivo.
- Puede invocar código en Python, C, Fortran, etc.
Julia versus Python
- Es más rápido
- Tiene un gestor de paquetes más amigable (
pkg
vspip
) - Es más versátil (proporcionando FFI a través de
PyCall
,RCall
yccall
), para hacer uso y/o para convertir de código. - Posee gestión automática de memoria.
- Proporciona facilidades para la paralelización.
- Soporta despacho múltiple (multiple dispatch).
Python es mejor que Julia
- Soporte de la comunidad
- Abundacia de librerías (aunque
PyCall
,RCall
yccall
, puede ayudar). - Es cada día más rápido (aunque no tanto).
- El coste de arranque (startup overhead) es menor.
- Es más maduro.
- Es versátil a través de diferentes dominios (Web, ML, IoT, etc).
Transición fácil
- Julia parece un lenguaje interpretado, lo que facilita su transición desde Matlab y/o Python.
- Julia se ejecuta como un lenguaje compilado, lo que le da su rapidez gracias a su compilador JIT.
Julia Case Studies
- Pfizer usa Julia para crear simulaciones hasta 175x veces más rápido usando GPU.
- El Instituto Nacional de Investigaciones Espaciales (INPE) de Brasil ha seleccionado a Julia en algunos de sus proyectos.
- Los investigadores que trabajan con el supercomputador del NERSC (650.000 núcleos) utilizan Julia para el análisis de imágenes astronómicas.
- Los ingenieros de Fugro Roames hacen aprendizaje automático en Julia para detectar fallos en la red.
- Glaciologists usa para calcular el grosor de las placas de hielo en mapas.
- Los investigadores de Cisco usan aprendizaje automático en Julia para mejorar la seguridad en la red.
- Los robotistas del MIT usan Julia para subir escaleras, caminar en terrenos accidentados y difíciles.
Instalación de Julia
- Julia soporta Linux, Windows y MacOS.
- La versión libre puede ser descargada en https://julialang.org/downloads
- Existe una versión propietaria en https://juliacomputing.com/products/juliapro
- Por omisión, Julia proporciona una versión tipo shell, además de un notebook basado en Jupyter.
- Para instalarlo, se debe introducir:
Pkg.add("IJulia")
. - Para ejecutarlo, se debe introducir:
Notepad()
.
- Para instalarlo, se debe introducir:
- Existe un entorno integrado de desarrollo llamado Juno, en: https://junolab.org.
Section 2: Programación básica
Imprimiendo y leyendo valores en pantalla
-
Una vez instalado Julia podremos ejecutar su REPL, escribiendo lo siguiente en el indicador del sistema:
PS C:\> julia _ _ _ _(_)_ | Documentation: https://docs.julialang.org (_) | (_) (_) | _ _ _| |_ __ _ | Type "?" for help, "]?" for Pkg help. | | | | | | |/ _` | | | | |_| | | | (_| | | Version 1.5.0 (2020-08-01) _/ |\__'_|_|_|\__'_| | Official https://julialang.org/ release |__/ | julia>
-
Al igual que en Python, su REPL puede funcionar como una calculadora:
julia> 1 + 1 2 julia> 2 * 2 4 julia> 9 % 2 1 julia> 10 ^ 2 100
-
El final de la línea coincide con el fin de sentencia, pero podremos agregar “;” para escribir varias sentencias en una misma línea:
julia> 2 * 8; 3 * 3 9
-
Al igual que en Matlab, las sentencias finalizadas con “;” se ejecutan sin imprimir su resultado en el REPL. Por lo que, podremos silenciar nuestras operaciones, añadiendo el final de sentencia (";") de manera explícita:
julia> 2 * 8; 3 * 3; julia>
-
Al igual que en Python, las asignación de variables es muy simple:
julia> x = 123 123
-
Julia soporta identificadores en Unicode (codificados en UTF-8), tanto como nombres de variables, como para constantes:
julia> π π = 3.1415926535897...
-
Para utilizar una función matemática, debemos escribir su nombre seguido de una lista de parámetros actuales encerrados entre paréntesis “(” y “)”:
julia> sin(π/2) 1.0
-
Y además, podremos usar funciones para imprimir en una misma línea (con la función
print
) o en varias líneas (conprintln
):julia> print("Hello, "); print("world!") Hello, world! julia> println("Hello, "); println("world!") Hello, world! julia>
-
Y por supuesto, podemos imprimir (hacer uso de) el contenido de nuestras variables:
julia> print(x) 123
-
En Julia, las variables tienen un tipo, y asociado a éste, las variables también tienen un tamaño:
julia> x = 1; y = 1.0; z = 1 + 2im 1 + 2im julia> typeof(x) Int64 julia> typeof(y) Float64 julia> typeof(z) Complex{Int64} julia> sizeof(x) 8 julia> sizeof(y) 8 julia> sizeof(z) 16
-
Julia también tienen comentarios de línea que comienzan con “#”:
julia> print(typeof(x)) # Imprime el tipo de la variable "x" Int64
-
Para hacer comentarios multilínea usamos “#=” y “=#”:
julia> #= Hola, mundo! =# julia>
-
Las cadenas de caracteres se encierran entre comillas dobles “"”, y al igual que el resto de valores, se pueden imprimir:
julia> println("Hello, world!") Hello, world! julia>
-
También podremos leer una línea desde la pantalla (cónsola, terminal) de Julia:
julia> msg = readline() Hello, world! "Hello, world!" julia> print(msg) Hello, world!
-
Las cadenas de caracteres también soportan Unicode:
julia> print("你好朱莉婭!") 你好朱莉婭!
-
Incluso, se pueden construir expresiones con cadenas de caracteres, aunque no todos los operadores están disponibles:
julia> x = "Hello"; y = "world"; julia> x * ", " * y * "!" "Hello, world!" julia> x^2 "HelloHello" julia>
-
Para convertir un número almacenado como cadena de caracteres a número en un tipo dado (p.e.
Int
), podremos usar la funciónparse()
:julia> x = "5" "5" julia> x ^ 2 "55" julia> y = parse(Int, x) 5 julia> y ^ 2 25 julia>
-
Pero si no sabemos cómo funciona la función
parse()
u otras funciones disponibles, podremos pedir ayuda escribiendo “? parse”:help?> parse search: parse tryparse partialsortperm partialsortperm! pairs skipchars partialsort partialsort! parentindices parse(type, str; base) Parse a string as a number. For Integer types, a base can be specified (the default is 10). For floating-point types, the string is parsed as a decimal floating-point number. Complex types are parsed from decimal strings of the form "R±Iim" as a Complex(R,I) of the requested type; "i" or "j" can also be used instead of "im", and "R" or "Iim" are also permitted. If the string does not contain a valid number, an error is raised. │ Julia 1.1 │ │ parse(Bool, str) requires at least Julia 1.1. Examples ≡≡≡≡≡≡≡≡≡≡ julia> parse(Int, "1234") 1234 julia> parse(Int, "1234", base = 5) 194 julia> parse(Int, "afc", base = 16) 2812 julia> parse(Float64, "1.2e-3") 0.0012 julia> parse(Complex{Float64}, "3.2e-1 + 4.5im") 0.32 + 4.5im
NB. Nótese que al escribir el carácter “?” en el indicador del REPL de Julia, dicho indicador cambiará a
help?>
, mientras que desaparecerá el carácter “?” que hemos introducido. -
Algo similar pasa con el carácter “;”, que nos permitirá ejecutar un comando disponible en nuestro sistema operativo. Por ejemplo, al ingresar “; date” (sin comillas), se mostrará algo como esto:
shell> date Tue Aug 25 14:24:28 Hora de verano romance 2020
NB. Aquí el indicador se modifica por
shell>
.
Manipulación de caracteres y cadenas de caracteres
Caracteres
-
Al igual que el lenguaje C, Julia proporciona un tipo de dato carácter, que se inicializa con literales delimitados entre comillas simples “’”:
julia> x = 'A' 'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
-
En Julia los caracteres son del tipo
Char
y, al tratarse de caracteres unicode, tienen un tamaño de 4 bytes:julia> typeof(x) Char julia> sizeof(x) 4
-
Para asignar un carácter cuyo punto de código (code point) está más allá de los caracteres disponibles en nuestros teclados, podemos asignar su literal code point equivalente. Por ejemplo, para asignar el carácter
U+03B1
debemos usar:julia> a = '\u03B1' 'α': Unicode U+03B1 (category Ll: Letter, lowercase)
-
También podremos utilizar las secuencias de escape disponibles en otros lenguajes de programación:
julia> '\e' '\e': ASCII/Unicode U+001B (category Cc: Other, control) julia> '\\' '\\': ASCII/Unicode U+005C (category Po: Punctuation, other)
-
Los caracteres pueden convertirse a enteros, o estos a caracteres, mediante las funciones
Int()
yChar()
:julia> Int(x) 65 julia> Char(65) 'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase) julia> Char(0x03B1) 'α': Unicode U+03B1 (category Ll: Letter, lowercase)
Cadenas de caracteres
-
Las cadenas de caracteres son secuencias finitas de caracteres, y sus literales se delimitan con comillas dobles:
julia> s = "Hello, world!" "Hello, world!"
-
En donde, cada carácter puede ser accedido de manera individual mediante subíndices, que comienzan por la posición 1:
julia> s[1] 'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase)
-
En cualquier caso, las cadenas de caracteres en Julia son _inmutables:
julia> s[1] = 'h' ERROR: MethodError: no method matching setindex!(::String, ::Char, ::Int64) Stacktrace: [1] top-level scope at REPL[40]:1
-
También disponemos de dos identificadores:
begin
yend
, que denotan a las posiciones inicial y final de la cadena:julia> s[begin] 'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase) julia> s[end] '!': ASCII/Unicode U+0021 (category Po: Punctuation, other)
-
Las cadena de caracteres pueden ser accedidas mediantes rangos completos de posiciones, llamados slices. La operación de acceso a un rango de posiciones o slice, se denomina slicing y devuelve un subconjunto de la cadena accedida:
julia> s[begin:5] "Hello" julia> s[8:end-1] "world"
-
Por supuesto, en el contexto del slicing de cadenas de caracteres la expresión
s[begin:end]
devuelve la cadena de entradas
completa:julia> s[begin:end] "Hello, world!"
-
Otra manera de obtener una subcadena de caracteres, consiste en invocar la función
SubString
con los parámetros del slice. Por ejemplo, podremos obtener el mismo resultado des[begin:5]
, haciendo la siguiente llamada:julia> SubString(s, 1, 5) "Hello"
-
Otra función útil que trabaja sobre cadenas de caracteres es la función
string()
, que permite obtener una cadena de caracteres equivalente a lo que muestra la funciónprint()
en pantalla:julia> print(1, "Hello", 4) 1Hello4 julia> string(1, "Hello", 4) "1Hello4"
-
También podremos conocer la longitud de una cadena de caracteres, usando la función
length()
:julia> length(s) 13
-
Existen muchas funciones para el tratamiento de caracteres, como son:
findfirst()
,occursin()
,firstindex()
,lastindex()
, entre otras:julia> firstindex(s) 1 julia> lastindex(s) 13 julia> eachindex(s) # devuelve un iterador con la lista de # índices de la cadena de caracteres Base.EachStringIndex{String}("Hello, world!") julia> findfirst("world", s) 8:12 julia> occursin("world", s) true
-
Pero también existen algunos operadores como
*
y^
, que permiten realizar determinas operaciones sobre cadenas de caracteres:julia> "Hello," * " world!" # concatenación de cadenas de caracteres "Hello, world!" julia> "-" ^ 20 # duplicación de cadenas de caracteres "--------------------"
Secuencias de bytes
-
Las secuencias de bytes se pueden representar mediante secuencias delimitadas por
b""
:julia> b"Go!" 3-element Base.CodeUnits{UInt8,String}: 0x47 0x6f 0x21