Julia: el futuro de la ciencia de datos y el aprendizaje automático

Aprenda Julia para principiantes: explicación del futuro lenguaje de programación de la ciencia de datos y el aprendizaje automático

El lenguaje de programación Julia como el lenguaje de próxima generación para el aprendizaje automático y la ciencia de datos, el desarrollo web, el desarrollo de juegos y más.

Julia es un lenguaje de programación dinámico de alto nivel, diseñado para brindar a los usuarios la velocidad de C/C++ sin dejar de ser tan fácil de usar como Python. Esto significa que los desarrolladores pueden resolver problemas de forma más rápida y eficaz.

Julia es excelente para problemas computacionales complejos. Muchos de los primeros usuarios de Julia se concentraron en dominios científicos como la química, la biología y el aprendizaje automático.

Dicho esto, Julia es un lenguaje de propósito general y puede usarse para tareas como desarrollo web, desarrollo de juegos y más. Muchos ven a Julia como el lenguaje de próxima generación para el aprendizaje automático y la ciencia de datos, incluido el director ejecutivo de Shopify (entre muchos otros).

Cómo descargar el lenguaje de programación Julia ⤵️

Hay dos formas principales de ejecutar Julia: a través de un .jlarchivo en un IDE como VS Code o comando por comando en Julia REPL (Read Evaluate Print Loop). En esta guía, utilizaremos principalmente Julia REPL.

o simplemente diríjase a: https://julialang.org/downloads/

Una vez que haya instalado Julia, debería poder iniciarlo y ver:

Julia 1.7 REPL después de la instalación

Conceptos básicos del lenguaje de programación Julia para principiantes

Antes de que podamos usar Julia para todas las cosas emocionantes para las que se creó, como el aprendizaje automático o la ciencia de datos, primero debemos familiarizarnos con los conceptos básicos del lenguaje.

Comenzaremos repasando variables, tipos y condicionales. Luego, hablaremos sobre bucles, funciones y paquetes. Por último, tocaremos conceptos más avanzados como estructuras y hablaremos sobre recursos de aprendizaje adicionales.

Esta va a ser una gira vertiginosa, ¡así que ponte el cinturón y prepárate! También vale la pena señalar que este tutorial asume que tiene cierta familiaridad básica con la programación.

Una introducción a las variables y tipos de Julia ⌨️

En Julia, las variables se escriben dinámicamente, lo que significa que no necesita especificar el tipo de variable cuando la crea.

julia> a = 10 # Create the variable "a" and assign it the number 10
10

julia> a + 10 # Do a basic math operation using "a"
20

(Tenga en cuenta que en los fragmentos de código, cuando lo ve julia>, significa que el código se está ejecutando en REPL)

Al igual que definimos una variable arriba y le asignamos un entero (número entero), también podemos hacer algo similar para cadenas y otros tipos de variables:

julia> my_string = "Hello freeCodeCamp" # Define a string variable
"Hello freeCodeCamp"

julia> balance = 238.19 # Define a float variable 
238.19

Al crear variables en Julia, el nombre de la variable siempre irá en el lado izquierdo y el valor siempre irá en el lado derecho después del signo igual. También podemos crear nuevas variables basadas en los valores de otras variables:

julia> new_balance = balance + a
248.19

Aquí podemos ver que new_balanceahora es la suma (total) de 238.19 y 10. Tenga en cuenta además que el tipo de new_balancees un flotante (número con precisión decimal) porque cuando sumamos un flotante y un int juntos, automáticamente obtenemos el tipo con mayor precisión, que en este caso es un flotador. Podemos confirmar esto haciendo:

julia> typeof(new_balance)
Float64

Debido a la naturaleza de la tipificación dinámica, las variables en Julia también pueden cambiar de tipo. Esto significa que en un momento holder_balancepodría ser un flotador y luego podría ser una cadena:

julia> holder_balance = 100.34
100.34

julia> holder_balance = "The Type has changed"
"The Type has changed"

julia> typeof(holder_balance)
String

También puede estar emocionado de saber que los nombres de variables en Julia son muy flexibles, de hecho, puede hacer algo como:

julia> 😀 = 10
10

julia> 🥲 = -10
-10

julia> 😀 + 🥲
0

Además de los nombres de variables emoji, también puede usar cualquier otro nombre de variable Unicode, que es muy útil cuando intenta representar ideas matemáticas. Puede acceder a estas variables Unicode haciendo \y luego escribiendo el nombre, seguido de presionar tab:

julia> \sigma # press tab and it will render the symbol

julia> σ = 10 # set sigma equal to 10

En general, el sistema de variables en Julia es flexible y proporciona un gran conjunto de características que facilitan la escritura del código de Julia sin dejar de ser expresivo. Si desea obtener más información sobre las variables en Julia, consulte la documentación de Julia: https://docs.julialang.org/en/v1/manual/variables/

Cómo escribir declaraciones condicionales en Julia 🔀

En la programación, a menudo necesita verificar ciertas condiciones para asegurarse de que se ejecuten líneas específicas de código. Por ejemplo, si escribe un programa bancario, es posible que solo desee permitir que alguien retire dinero si la cantidad que está tratando de retirar es menor que la cantidad que tiene presente en su cuenta.

Veamos un ejemplo básico de una declaración condicional en Julia:

julia> bank_balance = 4583.11
4583.11

julia> withdraw_amount = 250
250

julia> if withdraw_amount <= bank_balance
           bank_balance -= withdraw_amount
           print("Withdrew ", withdraw_amount, " from your account")
       end
Withdrew 250 from your account

Echemos un vistazo más de cerca a algunas partes de la declaración if que pueden diferir de otro código que haya visto: Primero, usamos no :para indicar el final de la línea y tampoco estamos obligados a usar ()alrededor de la declaración (aunque es animado). A continuación, no usamos {}o similares para denotar el final del condicional, sino que usamos la endpalabra clave.

Al igual que usamos la instrucción if, podemos encadenarla con un elseo un elseif:

julia> withdraw_amount = 4600
4600

julia> if withdraw_amount <= bank_balance
           bank_balance -= withdraw_amount
           print("Withdrew ", withdraw_amount, " from your account")
       else
           print("Insufficent balance")
       end
Insufficent balance

Puede leer más sobre el flujo de control y las expresiones condicionales en la documentación de Julia: https://docs.julialang.org/en/v1/manual/control-flow/#man-conditional-e Evaluation

Cómo usar Loops en Julia 🔂

Hay dos tipos principales de bucles en Julia: un bucle for y un bucle while. Al igual que con otros lenguajes, la mayor diferencia es que en un ciclo for, está pasando por una cantidad predefinida de elementos, mientras que en un ciclo while, está iterando hasta que se cambia alguna condición.

Sintácticamente, los bucles en Julia tienen una estructura muy similar a los condicionales if que acabamos de ver:

julia> greeting = ["Hello", "world", "and", "welcome", "to", "freeCodeCamp"] # define greeting, an array of strings
6-element Vector{String}:
 "Hello"
 "world"
 "and"
 "welcome"
 "to"
 "freeCodeCamp"

julia> for word in greeting
           print(word, " ")
       end
Hello world and welcome to freeCodeCamp 

En este ejemplo, primero definimos un nuevo tipo: un vector (también llamado matriz). Esta matriz contiene un montón de cadenas que definimos. El comportamiento es muy similar al de las matrices en otros idiomas, pero vale la pena señalar que las matrices son mutables (lo que significa que puede cambiar la cantidad de elementos en la matriz después de crearla).

Nuevamente, cuando observamos la estructura del ciclo for, puede ver que estamos iterando a través de la greetingvariable. Cada vez, obtenemos una nueva palabra (en este caso) de la matriz y la asignamos a una variable temporal wordque luego imprimimos. Notará que la estructura de este bucle se parece a la declaración if y nuevamente usa la endpalabra clave.

Ahora que exploramos los bucles, cambiemos de marcha y echemos un vistazo a un bucle while en Julia:

julia> while user_input != "End"
           print("Enter some input, or End to quit: ")
           user_input = readline() # Prompt the user for input
       end
Enter some input, or End to quit: hi
Enter some input, or End to quit: test
Enter some input, or End to quit: no
Enter some input, or End to quit: End

Para este ciclo while, lo configuramos para que se ejecute indefinidamente hasta que el usuario escriba la palabra "Fin". Como ya lo ha visto varias veces, la estructura del ciclo debería comenzar a parecerle familiar.

Si desea ver más ejemplos de bucles en Julia, puede consultar la sección de documentación de Julia sobre bucles: https://docs.julialang.org/en/v1/manual/control-flow/#man-loops

Cómo usar funciones en Julia

Las funciones se utilizan para crear varias líneas de código, encadenadas y accesibles cuando se hace referencia a un nombre de función. Primero, veamos un ejemplo de una función básica:

julia> function greet()
           print("Hello new Julia user!")
       end
greet (generic function with 1 method)

julia> greet()
Hello new Julia user!

Las funciones también pueden tomar argumentos, al igual que en otros lenguajes:

julia> function greetuser(user_name)
           print("Hello ", user_name, ", welcome to the Julia Community")
       end
greetuser (generic function with 1 method)

julia> greetuser("Logan")
Hello Logan, welcome to the Julia Community

En este ejemplo, tomamos un argumento y luego agregamos su valor a la impresión. Pero, ¿y si no conseguimos una cuerda?

julia> greetuser(true)
Hello true, welcome to the Julia Community

En este caso, dado que solo estamos imprimiendo, la función continúa funcionando a pesar de no tomar más una cadena y en lugar de tomar un valor booleano (verdadero o falso). Para evitar que esto ocurra, podemos escribir explícitamente los argumentos de entrada de la siguiente manera:

julia> function greetuser(user_name::String)
           print("Hello ", user_name, ", welcome to the Julia Community")
       end
greetuser (generic function with 2 methods)

julia> greetuser("Logan")
Hello Logan, welcome to the Julia Community

Entonces ahora la función está definida para tomar solo una cadena. Probemos esto para asegurarnos de que solo podemos llamar a la función con un valor de cadena:

julia> greetuser(true)
Hello true, welcome to the Julia Community

Espera un segundo, ¿por qué sucede esto? Redefinimos la greetuserfunción, no debería tardar truemás.

Lo que estamos experimentando aquí es una de las características subyacentes más poderosas de Julia: Multiple Dispatch. Julia nos permite definir funciones con el mismo nombre y número de argumentos pero que aceptan tipos diferentes. Esto significa que podemos crear versiones de funciones genéricas o de tipo específico, lo que ayuda enormemente con la legibilidad del código, ya que no es necesario manejar todos los escenarios en una sola función.

Deberíamos confirmar rápidamente que en realidad definimos ambas funciones:

julia> methods(greetuser)
# 2 methods for generic function "greetuser":
[1] greetuser(user_name::String) in Main at REPL[34]:1
[2] greetuser(user_name) in Main at REPL[30]:1

La methodsfunción incorporada es perfecta para esto y nos dice que tenemos dos funciones definidas, con la única diferencia de que una acepta cualquier tipo y la otra solo una cadena.

Vale la pena señalar que dado que definimos una versión especializada que acepta solo una cadena, cada vez que llamamos a la función con una cadena, llamará a la versión especializada. La función más genérica no se llamará cuando se pase una cadena.

A continuación, hablemos sobre la devolución de valores de una función. En Julia, tiene dos opciones, puede usar la returnpalabra clave explícita, o puede optar por hacerlo implícitamente haciendo que la última expresión en la función sirva como valor de retorno así:

julia> function sayhi()
           "This is a test"
           "hi"
       end
sayhi (generic function with 1 method)

julia> sayhi()
"hi"

En el ejemplo anterior, el valor de cadena "hola" se devuelve desde la función, ya que es la última expresión y no hay una declaración de devolución explícita. También podría definir la función como:

julia> function sayhi()
           "This is a test"
          return "hi"
       end
sayhi (generic function with 1 method)

julia> sayhi()
"hi"

En general, desde el punto de vista de la legibilidad, tiene sentido usar la declaración de devolución explícita en caso de que alguien que lea su código no conozca el comportamiento de devolución implícita en las funciones de Julia.

Otra característica útil de las funciones es la capacidad de proporcionar argumentos opcionales:


julia> function sayhello(response="hello")
          return response
       end
sayhello (generic function with 2 methods)

julia> sayhello()
"hello"

julia> sayhello("hi")
"hi"

En este ejemplo, lo definimos responsecomo un argumento opcional para que podamos permitirle usar el comportamiento predeterminado que definimos o podemos anularlo manualmente cuando sea necesario. Estos ejemplos solo rascan la superficie de lo que es posible con funciones en Julia. Si desea leer más sobre todas las cosas geniales que puede hacer, consulte: https://docs.julialang.org/en/v1/manual/functions/

Cómo usar Paquetes en Julia 📦

El administrador de paquetes de Julia y el ecosistema de paquetes son algunas de las características más importantes del lenguaje. De hecho, escribí un artículo completo sobre por qué es una de las características más subestimadas del lenguaje .

Dicho esto, hay dos formas de interactuar con los paquetes en Julia: a través de REPL o usando el paquete Pkg. Nos centraremos principalmente en REPL en esta publicación, ya que es mucho más fácil de usar en mi experiencia.

Una vez que haya instalado Julia, puede ingresar al administrador de paquetes desde REPL escribiendo ].

Modo paquete en Julia REPL

Ahora que estamos en el administrador de paquetes, hay algunas cosas que comúnmente queremos hacer:

  • agregar un paquete
  • quitar un paquete
  • Comprobar lo que ya está instalado

Si desea ver todos los comandos posibles en el REPL, simplemente ingrese al modo Pkg escribiendo ]y luego escriba ?  seguido de la tecla enter/return.

Cómo agregar paquetes de Julia ➕

Agreguemos nuestro primer paquete, Example.jl. Para ello, podemos ejecutar:

(@v1.7) pkg> add Example

que debería proporcionar una salida que se parece a:

(@v1.7) pkg> add Example
Updating registry at `~/.julia/registries/General`
Updating git-repo `https://github.com/JuliaRegistries/General.git`
Updating registry at `~/.julia/registries/JuliaPOMDP`
Updating git-repo `https://github.com/JuliaPOMDP/Registry`
Resolving package versions...
Installed Example ─ v0.5.3
Updating `~/.julia/environments/v1.7/Project.toml`
[7876af07] + Example v0.5.3
Updating `~/.julia/environments/v1.7/Manifest.toml`
[7876af07] + Example v0.5.3
Precompiling project...
1 dependency successfully precompiled in 1 seconds (69 already precompiled)
(@v1.7) pkg>

Por razones de espacio, omitiré más salidas bajo el supuesto de que me sigues.

Cómo verificar el estado del paquete en Julia 🔍

Ahora que creemos que tenemos un paquete instalado, verifiquemos dos veces si realmente está allí escribiendo status(o stde forma abreviada) en el administrador de paquetes:

(@v1.7) pkg> st
Status `~/.julia/environments/v1.7/Project.toml`
[7876af07] Example v0.5.3
[587475ba] Flux v0.12.8

Aquí podemos ver que tengo dos paquetes instalados, Flux y Example. También me da la ruta al archivo que administra mi entorno actual (en este caso, Julia v1.7 global) junto con las versiones de paquetes que tengo instaladas.

Cómo quitar un paquete de Julia 📛

Si quisiera eliminar un paquete de mi entorno activo, como Flux, simplemente puedo escribir remove Flux(o rmcomo abreviatura):

(@v1.7) pkg> rm Flux
Updating `~/.julia/environments/v1.7/Project.toml`
[587475ba] - Flux v0.12.8

Un rápido statusdespués muestra que esto fue exitoso:

(@v1.7) pkg> st
Status `~/.julia/environments/v1.7/Project.toml`
[7876af07] Example v0.5.3

Ahora conocemos los conceptos básicos de trabajar con paquetes. Pero hemos cometido un gran crimen de programación al utilizar nuestro entorno de paquete global.

Cómo usar los paquetes de Julia 📦

Ahora que hemos repasado cómo administrar paquetes, exploremos cómo usarlos. Sencillamente, solo necesita escribir using packageNamepara usar un paquete específico que desee. Una de mis nuevas características favoritas en Julia 1.7 (destacada en esta publicación de blog ) se muestra a continuación:

Imagen capturada por el autor

Si recuerda, eliminamos el paquete Flux y, por supuesto, lo olvidé, así que fui a usarlo y lo cargué escribiendo using Flux. El REPL me solicita automáticamente que lo instale a través de un simple indicador "s/n". Esta es una característica pequeña pero ahorra una gran cantidad de tiempo y una posible confusión.

Vale la pena señalar que hay dos formas de acceder a las funciones exportadas de un paquete: a través de la usingpalabra clave y la importpalabra clave. La gran diferencia es que usingtrae automáticamente todas las funciones al espacio de nombres actual (para lo cual puede pensar en una gran lista de funciones cuyas definiciones conoce Julia), mientras que importle da acceso a todas las funciones pero tiene que prefijar la función con el nombre del paquete como: Flux.gradient()donde Fluxes el nombre del paquete y gradient()es el nombre de una función.


¿Cómo usar Structs en Julia?

Julia no tiene paradigmas de programación orientada a objetos (POO) integrados en el lenguaje como clases. Sin embargo, las estructuras en Julia se pueden usar de manera similar a las clases para crear objetos y tipos personalizados. A continuación, mostraremos un ejemplo básico:

julia> mutable struct dog
           breed::String
           paws::Int
           name::String
           weight::Float64
       end

julia> my_dog = dog("Australian Shepard", 4, "Indy", 34.0)
dog("Australian Shepard", 4, "Indy", 34.0)

julia> my_dog.name
"Indy"

En este ejemplo, definimos una estructura para representar un perro. En la estructura, definimos cuatro atributos que componen el objeto perro. En las líneas siguientes, mostramos el código para crear realmente un objeto de perro y luego acceder a algunos de sus atributos. Tenga en cuenta que no necesita especificar los tipos de los atributos, puede dejarlo más abierto. Para este ejemplo, definimos tipos explícitos para resaltar esa característica.

Notarás que, de forma similar a las clases en Python (y otros lenguajes), no definimos un constructor explícito para crear el objeto perro. Sin embargo, podemos definir uno si fuera útil usarlo:

julia> mutable struct dog
           breed::String
           paws::Int
           name::String
           weight::Float64
           
           function dog(breed, name, weight, paws=4)
               new(breed, paws, name, weight)
           end
       end

julia> new_dog = dog("German Shepard", "Champ", 46)
dog("German Shepard", 4, "Champ", 46.0)

Aquí definimos un constructor y usamos la palabra clave especial newpara crear el objeto al final de la función. También puede crear getters y setters específicamente para el objeto perro haciendo lo siguiente:

julia> function get_name(dog_obj::dog)
           print("The dogs's name is: ", dog_obj.name)
       end
get_name (generic function with 1 method)

julia> get_name(new_dog)
The dogs's name is: Champ

En este ejemplo, la get_namefunción solo toma un objeto de tipo dog. Si intenta pasar algo más, se producirá un error:

julia> get_name("test")
ERROR: MethodError: no method matching get_name(::String)
Closest candidates are:
  get_name(::dog) at REPL[61]:1
Stacktrace:
 [1] top-level scope
   @ REPL[63]:1

Vale la pena señalar que también definimos la estructura para que sea mutable inicialmente para que podamos cambiar los valores de campo después de crear el objeto. Omite la palabra clave mutablesi desea que el estado inicial de los objetos persista.

Las estructuras en Julia no solo nos permiten crear objetos, también estamos definiendo un tipo personalizado en el proceso:

julia> typeof(new_dog)
dog

En general, las estructuras se usan mucho en el ecosistema de Julia y puede obtener más información sobre ellas en los documentos: https://docs.julialang.org/en/v1/base/base/#struct

Recursos adicionales de aprendizaje de programación de Julia 📚

Espero que este tutorial te haya ayudado a ponerte al día con muchas de las ideas centrales del lenguaje Julia. Dicho esto, sé que todavía hay lagunas, ya que esta es una guía extensa pero no completa. Para obtener más información sobre Julia, puede consultar la pestaña de aprendizaje en el sitio web de Julia: https://julialang.org/learning/ que tiene cursos guiados, videos de YouTube y problemas de práctica guiados.

Si tiene otras preguntas o necesita ayuda para comenzar con Julia, no dude en ponerse en contacto conmigo: https://twitter.com/OfficialLoganK

Fuente del artículo original en https://www.freecodecamp.org

#julia #datascience #machinelearning

What is GEEK

Buddha Community

Julia: el futuro de la ciencia de datos y el aprendizaje automático

Lenguaje de programación Julia: el futuro de la ciencia de datos y el aprendizaje automático

Aprenda Julia para principiantes: explicación del futuro lenguaje de programación de la ciencia de datos y el aprendizaje automático

Julia es un lenguaje de programación dinámico de alto nivel, diseñado para brindar a los usuarios la velocidad de C / C ++ sin dejar de ser tan fácil de usar como Python. Esto significa que los desarrolladores pueden resolver problemas de forma más rápida y eficaz.

Julia es excelente para problemas computacionales complejos. Muchos de los primeros en adoptar Julia se concentraron en dominios científicos como la química, la biología y el aprendizaje automático.

Dicho esto, Julia es un lenguaje de propósito general y se puede usar para tareas como desarrollo web, desarrollo de juegos y más. Muchos ven a Julia como el lenguaje de próxima generación para el aprendizaje automático y la ciencia de datos, incluido el CEO de Shopify (entre muchos otros).

Cómo descargar el lenguaje de programación Julia ⤵️

Hay dos formas principales de ejecutar Julia: a través de un .jlarchivo en un IDE como VS Code o comando por comando en Julia REPL (Read Evaluate Print Loop). En esta guía, utilizaremos principalmente Julia REPL.

o simplemente dirígete a: https://julialang.org/downloads/

Una vez que haya instalado Julia, debería poder ejecutarlo y ver:

Julia 1.7 REPL después de la instalación

Conceptos básicos del lenguaje de programación Julia para principiantes

Antes de que podamos usar Julia para todas las cosas interesantes para las que se creó, como el aprendizaje automático o la ciencia de datos, primero debemos familiarizarnos con los conceptos básicos del lenguaje.

Comenzaremos repasando variables, tipos y condicionales. Luego, hablaremos de bucles, funciones y paquetes. Por último, tocaremos conceptos más avanzados como estructuras y hablaremos sobre recursos de aprendizaje adicionales.

Esta será una gira relámpago, ¡así que abróchate el cinturón y prepárate! También vale la pena señalar que este tutorial asume que tiene cierta familiaridad básica con la programación.

Introducción a las variables y tipos de Julia ⌨️

En Julia, las variables se escriben dinámicamente, lo que significa que no es necesario especificar el tipo de variable cuando la crea.

julia> a = 10 # Create the variable "a" and assign it the number 10
10

julia> a + 10 # Do a basic math operation using "a"
20

(Tenga en cuenta que en los fragmentos de código, cuando lo ve julia>, significa que el código se está ejecutando en el REPL)

Al igual que definimos una variable arriba y le asignamos un entero (número entero), también podemos hacer algo similar para cadenas y otros tipos de variables:

julia> my_string = "Hello freeCodeCamp" # Define a string variable
"Hello freeCodeCamp"

julia> balance = 238.19 # Define a float variable 
238.19

Al crear variables en Julia, el nombre de la variable siempre irá en el lado izquierdo y el valor siempre irá en el lado derecho después del signo igual. También podemos crear nuevas variables basadas en los valores de otras variables:

julia> new_balance = balance + a
248.19

Aquí podemos ver que new_balanceahora es la suma (total) de 238.19 y 10. Tenga en cuenta además que el tipo de new_balancees un flotante (número con precisión de lugar decimal) porque cuando agregamos un flotante e int juntos, automáticamente obtenemos el tipo con mayor precisión, que en este caso es un flotador. Podemos confirmar esto haciendo:

julia> typeof(new_balance)
Float64

Debido a la naturaleza de la escritura dinámica, las variables en Julia también pueden cambiar de tipo. Esto significa que en un punto, holder_balancepodría ser un flotante, y luego podría ser una cadena:

julia> holder_balance = 100.34
100.34

julia> holder_balance = "The Type has changed"
"The Type has changed"

julia> typeof(holder_balance)
String

También puede estar emocionado de saber que los nombres de variables en Julia son muy flexibles, de hecho, puede hacer algo como:

julia> 😀 = 10
10

julia> 🥲 = -10
-10

julia> 😀 + 🥲
0

Además de los nombres de las variables emoji, también puede usar cualquier otro nombre de variable Unicode que es muy útil cuando intenta representar ideas matemáticas. Puede acceder a estas variables Unicode haciendo un \y luego escribiendo el nombre, seguido de presionar tabulador:

julia> \sigma # press tab and it will render the symbol

julia> σ = 10 # set sigma equal to 10

En general, el sistema de variables en Julia es flexible y proporciona un gran conjunto de características que facilitan la escritura del código de Julia sin dejar de ser expresivo. Si desea obtener más información sobre las variables en Julia, consulte la documentación de Julia: https://docs.julialang.org/en/v1/manual/variables/

Cómo escribir declaraciones condicionales en Julia 🔀

En programación, a menudo es necesario verificar ciertas condiciones para asegurarse de que se ejecuten líneas específicas de código. Por ejemplo, si escribe un programa bancario, es posible que solo desee permitir que alguien retire dinero si la cantidad que está tratando de retirar es menor que la cantidad que tiene presente en su cuenta.

Veamos un ejemplo básico de una declaración condicional en Julia:

julia> bank_balance = 4583.11
4583.11

julia> withdraw_amount = 250
250

julia> if withdraw_amount <= bank_balance
           bank_balance -= withdraw_amount
           print("Withdrew ", withdraw_amount, " from your account")
       end
Withdrew 250 from your account

Echemos un vistazo más de cerca aquí a algunas partes de la declaración if que podrían diferir de otro código que haya visto: Primero, usamos no :para denotar el final de la línea y tampoco estamos obligados a usar ()alrededor de la declaración (aunque es animado). A continuación, no usamos {}o similares para denotar el final del condicional, en su lugar, usamos la endpalabra clave.

Al igual que usamos la instrucción if, podemos encadenarla con una elseo una elseif:

julia> withdraw_amount = 4600
4600

julia> if withdraw_amount <= bank_balance
           bank_balance -= withdraw_amount
           print("Withdrew ", withdraw_amount, " from your account")
       else
           print("Insufficent balance")
       end
Insufficent balance

Puede leer más sobre el flujo de control y las expresiones condicionales en la documentación de Julia: https://docs.julialang.org/en/v1/manual/control-flow/#man-conditional-evaluation

Cómo usar Loops en Julia 🔂

Hay dos tipos principales de bucles en Julia: un bucle for y un bucle while. Al igual que con otros lenguajes, la mayor diferencia es que en un ciclo for, estás pasando por un número predefinido de elementos mientras que, en un ciclo while, estás iterando hasta que se cambia alguna condición.

Sintácticamente, los bucles en Julia tienen una estructura muy similar a los condicionales if que acabamos de ver:

julia> greeting = ["Hello", "world", "and", "welcome", "to", "freeCodeCamp"] # define greeting, an array of strings
6-element Vector{String}:
 "Hello"
 "world"
 "and"
 "welcome"
 "to"
 "freeCodeCamp"

julia> for word in greeting
           print(word, " ")
       end
Hello world and welcome to freeCodeCamp 

En este ejemplo, primero definimos un nuevo tipo: un vector (también llamado matriz). Esta matriz contiene un montón de cadenas que definimos. El comportamiento es muy similar al de las matrices en otros lenguajes, pero vale la pena señalar que las matrices son mutables (lo que significa que puede cambiar la cantidad de elementos en la matriz después de crearla).

Nuevamente, cuando miramos la estructura del ciclo for, puede ver que estamos iterando a través de la greetingvariable. Cada vez, obtenemos una nueva palabra (en este caso) de la matriz y la asignamos a una variable temporal wordque luego imprimimos. Notará que la estructura de este ciclo es similar a la instrucción if y nuevamente usa la endpalabra clave.

Ahora que exploramos los bucles for, cambiemos de marcha y echemos un vistazo a un bucle while en Julia:

julia> while user_input != "End"
           print("Enter some input, or End to quit: ")
           user_input = readline() # Prompt the user for input
       end
Enter some input, or End to quit: hi
Enter some input, or End to quit: test
Enter some input, or End to quit: no
Enter some input, or End to quit: End

Para este ciclo while, lo configuramos para que se ejecute indefinidamente hasta que el usuario escriba la palabra "Fin". Como ya lo ha visto algunas veces, la estructura del bucle debería empezar a resultarle familiar.

Si desea ver más ejemplos de bucles en Julia, puede consultar la sección de la documentación de Julia sobre bucles: https://docs.julialang.org/en/v1/manual/control-flow/#man-loops

Cómo usar funciones en Julia

Las funciones se utilizan para crear varias líneas de código, encadenadas y accesibles cuando se hace referencia a un nombre de función. Primero, veamos un ejemplo de una función básica:

julia> function greet()
           print("Hello new Julia user!")
       end
greet (generic function with 1 method)

julia> greet()
Hello new Julia user!

Las funciones también pueden tomar argumentos, al igual que en otros lenguajes:

julia> function greetuser(user_name)
           print("Hello ", user_name, ", welcome to the Julia Community")
       end
greetuser (generic function with 1 method)

julia> greetuser("Logan")
Hello Logan, welcome to the Julia Community

En este ejemplo, tomamos un argumento y luego agregamos su valor a la impresión. Pero, ¿y si no obtenemos una cuerda?

julia> greetuser(true)
Hello true, welcome to the Julia Community

En este caso, dado que solo estamos imprimiendo, la función continúa funcionando a pesar de que ya no toma una cadena y en lugar de tomar un valor booleano (verdadero o falso). Para evitar que esto ocurra, podemos escribir explícitamente los argumentos de entrada de la siguiente manera:

julia> function greetuser(user_name::String)
           print("Hello ", user_name, ", welcome to the Julia Community")
       end
greetuser (generic function with 2 methods)

julia> greetuser("Logan")
Hello Logan, welcome to the Julia Community

Entonces ahora la función está definida para tomar solo una cadena. Probemos esto para asegurarnos de que solo podamos llamar a la función con un valor de cadena:

julia> greetuser(true)
Hello true, welcome to the Julia Community

Espera un segundo, ¿por qué sucede esto? Redefinimos la greetuserfunción, no debería tardar truemás.

Lo que estamos experimentando aquí es una de las características subyacentes más poderosas de Julia: Multiple Dispatch. Julia nos permite definir funciones con el mismo nombre y número de argumentos pero que aceptan diferentes tipos. Esto significa que podemos construir versiones de funciones genéricas o de tipo específico, lo que ayuda enormemente con la legibilidad del código, ya que no es necesario manejar todos los escenarios en una función.

Deberíamos confirmar rápidamente que realmente definimos ambas funciones:

julia> methods(greetuser)
# 2 methods for generic function "greetuser":
[1] greetuser(user_name::String) in Main at REPL[34]:1
[2] greetuser(user_name) in Main at REPL[30]:1

La methodsfunción incorporada es perfecta para esto y nos dice que tenemos dos funciones definidas, con la única diferencia de que una toma cualquier tipo y la otra solo una cadena.

Vale la pena señalar que, dado que definimos una versión especializada que acepta solo una cadena, siempre que llamemos a la función con una cadena, llamará a la versión especializada. La función más genérica no se llamará cuando se pase una cadena.

A continuación, hablemos de devolver valores de una función. En Julia, tiene dos opciones, puede usar la returnpalabra clave explícita , o puede optar por hacerlo implícitamente haciendo que la última expresión en la función sirva como valor de retorno así:

julia> function sayhi()
           "This is a test"
           "hi"
       end
sayhi (generic function with 1 method)

julia> sayhi()
"hi"

En el ejemplo anterior, la función devuelve el valor de cadena "hi", ya que es la última expresión y no hay una declaración de retorno explícita. También puede definir la función como:

julia> function sayhi()
           "This is a test"
          return "hi"
       end
sayhi (generic function with 1 method)

julia> sayhi()
"hi"

En general, desde el punto de vista de la legibilidad, tiene sentido usar la declaración de retorno explícita en caso de que alguien que lea su código no sepa sobre el comportamiento de retorno implícito en las funciones de Julia.

Otra característica útil de las funciones es la capacidad de proporcionar argumentos opcionales:


julia> function sayhello(response="hello")
          return response
       end
sayhello (generic function with 2 methods)

julia> sayhello()
"hello"

julia> sayhello("hi")
"hi"

En este ejemplo, lo definimos responsecomo un argumento opcional para que podamos permitirle usar el comportamiento predeterminado que definimos o podemos anularlo manualmente cuando sea necesario. Estos ejemplos solo muestran la superficie de lo que es posible con las funciones en Julia. Si desea leer más sobre todas las cosas interesantes que puede hacer, consulte: https://docs.julialang.org/en/v1/manual/functions/

Cómo usar paquetes en Julia 📦

El administrador de paquetes de Julia y el ecosistema de paquetes son algunas de las características más importantes del lenguaje. De hecho, escribí un artículo completo sobre por qué es una de las características más subestimadas del idioma .

Dicho esto, hay dos formas de interactuar con los paquetes en Julia: a través de REPL o usando el paquete Pkg. Nos centraremos principalmente en el REPL en esta publicación, ya que es mucho más fácil de usar en mi experiencia.

Una vez que haya instalado Julia, puede ingresar al administrador de paquetes desde REPL escribiendo ].

Modo paquete en Julia REPL

Ahora que estamos en el administrador de paquetes, hay algunas cosas que comúnmente queremos hacer:

  • Agregar un paquete
  • Quitar un paquete
  • Comprueba lo que ya está instalado

Si desea ver todos los comandos posibles en el REPL, simplemente ingrese al modo Pkg escribiendo ]y luego escriba ?  seguido de la tecla enter / return.

Cómo agregar paquetes de Julia ➕

Vamos a añadir nuestro primer paquete, Example.jl. Para hacerlo, podemos ejecutar:

(@v1.7) pkg> add Example

que debería proporcionar una salida que se parezca a:

(@v1.7) pkg> add Example
Updating registry at `~/.julia/registries/General`
Updating git-repo `https://github.com/JuliaRegistries/General.git`
Updating registry at `~/.julia/registries/JuliaPOMDP`
Updating git-repo `https://github.com/JuliaPOMDP/Registry`
Resolving package versions...
Installed Example ─ v0.5.3
Updating `~/.julia/environments/v1.7/Project.toml`
[7876af07] + Example v0.5.3
Updating `~/.julia/environments/v1.7/Manifest.toml`
[7876af07] + Example v0.5.3
Precompiling project...
1 dependency successfully precompiled in 1 seconds (69 already precompiled)
(@v1.7) pkg>

Por razones de espacio, omitiré más salidas bajo el supuesto de que usted me está siguiendo.

Cómo verificar el estado del paquete en Julia 🔍

Ahora que creemos que tenemos un paquete instalado, verifiquemos dos veces si realmente está allí escribiendo status(o stpara abreviar) en el administrador de paquetes:

(@v1.7) pkg> st
Status `~/.julia/environments/v1.7/Project.toml`
[7876af07] Example v0.5.3
[587475ba] Flux v0.12.8

Aquí podemos ver que tengo dos paquetes instalados, Flux y Example. También me da la ruta al archivo que administra mi entorno actual (en este caso, Julia global v1.7) junto con las versiones del paquete que he instalado.

Cómo quitar un paquete de Julia 📛

Si quisiera eliminar un paquete de mi entorno activo, como Flux, simplemente puedo escribir remove Flux(o rmcomo abreviatura):

(@v1.7) pkg> rm Flux
Updating `~/.julia/environments/v1.7/Project.toml`
[587475ba] - Flux v0.12.8

Un rápido statusdespués muestra que esto fue exitoso:

(@v1.7) pkg> st
Status `~/.julia/environments/v1.7/Project.toml`
[7876af07] Example v0.5.3

Ahora conocemos los conceptos básicos del trabajo con paquetes. Pero hemos cometido un delito de programación importante al utilizar nuestro entorno de paquete global.

Cómo usar los paquetes de Julia 📦

Ahora que hemos repasado cómo administrar los paquetes, exploremos cómo usarlos. En pocas palabras, solo necesita escribir using packageNamepara usar un paquete específico que desee. Una de mis nuevas funciones favoritas en Julia 1.7 (destacada en esta publicación de blog ) se muestra a continuación:

Imagen capturada por el autor

Si recuerdas, eliminamos el paquete Flux y, por supuesto, lo olvidé, así que fui a usarlo y cargarlo escribiendo using Flux. El REPL me pide automáticamente que lo instale mediante un simple mensaje "y / n". Esta es una característica pequeña pero ahorra una gran cantidad de tiempo y una posible confusión.

Vale la pena señalar que hay dos formas de acceder a las funciones exportadas de un paquete: a través de la usingpalabra clave y la importpalabra clave. La gran diferencia es que usingtrae automáticamente todas las funciones al espacio de nombres actual (para lo cual puede pensar en una gran lista de funciones en las que Julia conoce las definiciones) mientras que importle da acceso a todas las funciones pero tiene que prefijar la función con el nombre del paquete como: Flux.gradient()donde Fluxes el nombre del paquete y gradient()es el nombre de una función.


¿Cómo usar Structs en Julia?

Julia no tiene paradigmas de programación orientada a objetos (OOP) integrados en el lenguaje como clases. Sin embargo, las estructuras en Julia se pueden usar de manera similar a las clases para crear objetos y tipos personalizados. A continuación, mostraremos un ejemplo básico:

julia> mutable struct dog
           breed::String
           paws::Int
           name::String
           weight::Float64
       end

julia> my_dog = dog("Australian Shepard", 4, "Indy", 34.0)
dog("Australian Shepard", 4, "Indy", 34.0)

julia> my_dog.name
"Indy"

En este ejemplo, definimos una estructura para representar a un perro. En la estructura, definimos cuatro atributos que componen el objeto perro. En las líneas siguientes, mostramos el código para crear realmente un objeto perro y luego acceder a algunos de sus atributos. Tenga en cuenta que no necesita especificar los tipos de atributos, podría dejarlo más abierto. Para este ejemplo, definimos tipos explícitos para resaltar esa característica.

Notarás que de manera similar a las clases en Python (y otros lenguajes), no definimos un constructor explícito para crear el objeto perro. Sin embargo, podemos definir uno si sería útil usarlo:

julia> mutable struct dog
           breed::String
           paws::Int
           name::String
           weight::Float64
           
           function dog(breed, name, weight, paws=4)
               new(breed, paws, name, weight)
           end
       end

julia> new_dog = dog("German Shepard", "Champ", 46)
dog("German Shepard", 4, "Champ", 46.0)

Aquí definimos un constructor y usamos la palabra clave especial newpara crear el objeto al final de la función. También puede crear captadores y definidores específicamente para el objeto perro haciendo lo siguiente:

julia> function get_name(dog_obj::dog)
           print("The dogs's name is: ", dog_obj.name)
       end
get_name (generic function with 1 method)

julia> get_name(new_dog)
The dogs's name is: Champ

En este ejemplo, la get_namefunción solo toma un objeto de tipo dog. Si intenta pasar algo más, saldrá un error:

julia> get_name("test")
ERROR: MethodError: no method matching get_name(::String)
Closest candidates are:
  get_name(::dog) at REPL[61]:1
Stacktrace:
 [1] top-level scope
   @ REPL[63]:1

Vale la pena señalar que también definimos la estructura como mutable inicialmente para poder cambiar los valores de campo después de crear el objeto. Omite la palabra clave mutablesi desea que el estado inicial de los objetos persista.

Las estructuras en Julia no solo nos permiten crear objetos, también estamos definiendo un tipo personalizado en el proceso:

julia> typeof(new_dog)
dog

En general, las estructuras se utilizan mucho en todo el ecosistema de Julia y puede obtener más información sobre ellas en los documentos: https://docs.julialang.org/en/v1/base/base/#struct

Recursos adicionales de aprendizaje de programación de Julia 📚

Espero que este tutorial te haya ayudado a ponerte al día con muchas de las ideas centrales del lenguaje Julia. Dicho esto, sé que todavía hay lagunas, ya que esta es una guía extendida pero no completa. Para obtener más información sobre Julia, puede consultar la pestaña de aprendizaje en el sitio web de Julia: https://julialang.org/learning/, que tiene cursos guiados, videos de YouTube y problemas de práctica con mentores.

Si tiene otras preguntas o necesita ayuda para comenzar con Julia, no dude en ponerse en contacto conmigo: https://twitter.com/OfficialLoganK

Fuente: https://www.freecodecamp.org

#julia 

Julia: el futuro de la ciencia de datos y el aprendizaje automático

Aprenda Julia para principiantes: explicación del futuro lenguaje de programación de la ciencia de datos y el aprendizaje automático

El lenguaje de programación Julia como el lenguaje de próxima generación para el aprendizaje automático y la ciencia de datos, el desarrollo web, el desarrollo de juegos y más.

Julia es un lenguaje de programación dinámico de alto nivel, diseñado para brindar a los usuarios la velocidad de C/C++ sin dejar de ser tan fácil de usar como Python. Esto significa que los desarrolladores pueden resolver problemas de forma más rápida y eficaz.

Julia es excelente para problemas computacionales complejos. Muchos de los primeros usuarios de Julia se concentraron en dominios científicos como la química, la biología y el aprendizaje automático.

Dicho esto, Julia es un lenguaje de propósito general y puede usarse para tareas como desarrollo web, desarrollo de juegos y más. Muchos ven a Julia como el lenguaje de próxima generación para el aprendizaje automático y la ciencia de datos, incluido el director ejecutivo de Shopify (entre muchos otros).

Cómo descargar el lenguaje de programación Julia ⤵️

Hay dos formas principales de ejecutar Julia: a través de un .jlarchivo en un IDE como VS Code o comando por comando en Julia REPL (Read Evaluate Print Loop). En esta guía, utilizaremos principalmente Julia REPL.

o simplemente diríjase a: https://julialang.org/downloads/

Una vez que haya instalado Julia, debería poder iniciarlo y ver:

Julia 1.7 REPL después de la instalación

Conceptos básicos del lenguaje de programación Julia para principiantes

Antes de que podamos usar Julia para todas las cosas emocionantes para las que se creó, como el aprendizaje automático o la ciencia de datos, primero debemos familiarizarnos con los conceptos básicos del lenguaje.

Comenzaremos repasando variables, tipos y condicionales. Luego, hablaremos sobre bucles, funciones y paquetes. Por último, tocaremos conceptos más avanzados como estructuras y hablaremos sobre recursos de aprendizaje adicionales.

Esta va a ser una gira vertiginosa, ¡así que ponte el cinturón y prepárate! También vale la pena señalar que este tutorial asume que tiene cierta familiaridad básica con la programación.

Una introducción a las variables y tipos de Julia ⌨️

En Julia, las variables se escriben dinámicamente, lo que significa que no necesita especificar el tipo de variable cuando la crea.

julia> a = 10 # Create the variable "a" and assign it the number 10
10

julia> a + 10 # Do a basic math operation using "a"
20

(Tenga en cuenta que en los fragmentos de código, cuando lo ve julia>, significa que el código se está ejecutando en REPL)

Al igual que definimos una variable arriba y le asignamos un entero (número entero), también podemos hacer algo similar para cadenas y otros tipos de variables:

julia> my_string = "Hello freeCodeCamp" # Define a string variable
"Hello freeCodeCamp"

julia> balance = 238.19 # Define a float variable 
238.19

Al crear variables en Julia, el nombre de la variable siempre irá en el lado izquierdo y el valor siempre irá en el lado derecho después del signo igual. También podemos crear nuevas variables basadas en los valores de otras variables:

julia> new_balance = balance + a
248.19

Aquí podemos ver que new_balanceahora es la suma (total) de 238.19 y 10. Tenga en cuenta además que el tipo de new_balancees un flotante (número con precisión decimal) porque cuando sumamos un flotante y un int juntos, automáticamente obtenemos el tipo con mayor precisión, que en este caso es un flotador. Podemos confirmar esto haciendo:

julia> typeof(new_balance)
Float64

Debido a la naturaleza de la tipificación dinámica, las variables en Julia también pueden cambiar de tipo. Esto significa que en un momento holder_balancepodría ser un flotador y luego podría ser una cadena:

julia> holder_balance = 100.34
100.34

julia> holder_balance = "The Type has changed"
"The Type has changed"

julia> typeof(holder_balance)
String

También puede estar emocionado de saber que los nombres de variables en Julia son muy flexibles, de hecho, puede hacer algo como:

julia> 😀 = 10
10

julia> 🥲 = -10
-10

julia> 😀 + 🥲
0

Además de los nombres de variables emoji, también puede usar cualquier otro nombre de variable Unicode, que es muy útil cuando intenta representar ideas matemáticas. Puede acceder a estas variables Unicode haciendo \y luego escribiendo el nombre, seguido de presionar tab:

julia> \sigma # press tab and it will render the symbol

julia> σ = 10 # set sigma equal to 10

En general, el sistema de variables en Julia es flexible y proporciona un gran conjunto de características que facilitan la escritura del código de Julia sin dejar de ser expresivo. Si desea obtener más información sobre las variables en Julia, consulte la documentación de Julia: https://docs.julialang.org/en/v1/manual/variables/

Cómo escribir declaraciones condicionales en Julia 🔀

En la programación, a menudo necesita verificar ciertas condiciones para asegurarse de que se ejecuten líneas específicas de código. Por ejemplo, si escribe un programa bancario, es posible que solo desee permitir que alguien retire dinero si la cantidad que está tratando de retirar es menor que la cantidad que tiene presente en su cuenta.

Veamos un ejemplo básico de una declaración condicional en Julia:

julia> bank_balance = 4583.11
4583.11

julia> withdraw_amount = 250
250

julia> if withdraw_amount <= bank_balance
           bank_balance -= withdraw_amount
           print("Withdrew ", withdraw_amount, " from your account")
       end
Withdrew 250 from your account

Echemos un vistazo más de cerca a algunas partes de la declaración if que pueden diferir de otro código que haya visto: Primero, usamos no :para indicar el final de la línea y tampoco estamos obligados a usar ()alrededor de la declaración (aunque es animado). A continuación, no usamos {}o similares para denotar el final del condicional, sino que usamos la endpalabra clave.

Al igual que usamos la instrucción if, podemos encadenarla con un elseo un elseif:

julia> withdraw_amount = 4600
4600

julia> if withdraw_amount <= bank_balance
           bank_balance -= withdraw_amount
           print("Withdrew ", withdraw_amount, " from your account")
       else
           print("Insufficent balance")
       end
Insufficent balance

Puede leer más sobre el flujo de control y las expresiones condicionales en la documentación de Julia: https://docs.julialang.org/en/v1/manual/control-flow/#man-conditional-e Evaluation

Cómo usar Loops en Julia 🔂

Hay dos tipos principales de bucles en Julia: un bucle for y un bucle while. Al igual que con otros lenguajes, la mayor diferencia es que en un ciclo for, está pasando por una cantidad predefinida de elementos, mientras que en un ciclo while, está iterando hasta que se cambia alguna condición.

Sintácticamente, los bucles en Julia tienen una estructura muy similar a los condicionales if que acabamos de ver:

julia> greeting = ["Hello", "world", "and", "welcome", "to", "freeCodeCamp"] # define greeting, an array of strings
6-element Vector{String}:
 "Hello"
 "world"
 "and"
 "welcome"
 "to"
 "freeCodeCamp"

julia> for word in greeting
           print(word, " ")
       end
Hello world and welcome to freeCodeCamp 

En este ejemplo, primero definimos un nuevo tipo: un vector (también llamado matriz). Esta matriz contiene un montón de cadenas que definimos. El comportamiento es muy similar al de las matrices en otros idiomas, pero vale la pena señalar que las matrices son mutables (lo que significa que puede cambiar la cantidad de elementos en la matriz después de crearla).

Nuevamente, cuando observamos la estructura del ciclo for, puede ver que estamos iterando a través de la greetingvariable. Cada vez, obtenemos una nueva palabra (en este caso) de la matriz y la asignamos a una variable temporal wordque luego imprimimos. Notará que la estructura de este bucle se parece a la declaración if y nuevamente usa la endpalabra clave.

Ahora que exploramos los bucles, cambiemos de marcha y echemos un vistazo a un bucle while en Julia:

julia> while user_input != "End"
           print("Enter some input, or End to quit: ")
           user_input = readline() # Prompt the user for input
       end
Enter some input, or End to quit: hi
Enter some input, or End to quit: test
Enter some input, or End to quit: no
Enter some input, or End to quit: End

Para este ciclo while, lo configuramos para que se ejecute indefinidamente hasta que el usuario escriba la palabra "Fin". Como ya lo ha visto varias veces, la estructura del ciclo debería comenzar a parecerle familiar.

Si desea ver más ejemplos de bucles en Julia, puede consultar la sección de documentación de Julia sobre bucles: https://docs.julialang.org/en/v1/manual/control-flow/#man-loops

Cómo usar funciones en Julia

Las funciones se utilizan para crear varias líneas de código, encadenadas y accesibles cuando se hace referencia a un nombre de función. Primero, veamos un ejemplo de una función básica:

julia> function greet()
           print("Hello new Julia user!")
       end
greet (generic function with 1 method)

julia> greet()
Hello new Julia user!

Las funciones también pueden tomar argumentos, al igual que en otros lenguajes:

julia> function greetuser(user_name)
           print("Hello ", user_name, ", welcome to the Julia Community")
       end
greetuser (generic function with 1 method)

julia> greetuser("Logan")
Hello Logan, welcome to the Julia Community

En este ejemplo, tomamos un argumento y luego agregamos su valor a la impresión. Pero, ¿y si no conseguimos una cuerda?

julia> greetuser(true)
Hello true, welcome to the Julia Community

En este caso, dado que solo estamos imprimiendo, la función continúa funcionando a pesar de no tomar más una cadena y en lugar de tomar un valor booleano (verdadero o falso). Para evitar que esto ocurra, podemos escribir explícitamente los argumentos de entrada de la siguiente manera:

julia> function greetuser(user_name::String)
           print("Hello ", user_name, ", welcome to the Julia Community")
       end
greetuser (generic function with 2 methods)

julia> greetuser("Logan")
Hello Logan, welcome to the Julia Community

Entonces ahora la función está definida para tomar solo una cadena. Probemos esto para asegurarnos de que solo podemos llamar a la función con un valor de cadena:

julia> greetuser(true)
Hello true, welcome to the Julia Community

Espera un segundo, ¿por qué sucede esto? Redefinimos la greetuserfunción, no debería tardar truemás.

Lo que estamos experimentando aquí es una de las características subyacentes más poderosas de Julia: Multiple Dispatch. Julia nos permite definir funciones con el mismo nombre y número de argumentos pero que aceptan tipos diferentes. Esto significa que podemos crear versiones de funciones genéricas o de tipo específico, lo que ayuda enormemente con la legibilidad del código, ya que no es necesario manejar todos los escenarios en una sola función.

Deberíamos confirmar rápidamente que en realidad definimos ambas funciones:

julia> methods(greetuser)
# 2 methods for generic function "greetuser":
[1] greetuser(user_name::String) in Main at REPL[34]:1
[2] greetuser(user_name) in Main at REPL[30]:1

La methodsfunción incorporada es perfecta para esto y nos dice que tenemos dos funciones definidas, con la única diferencia de que una acepta cualquier tipo y la otra solo una cadena.

Vale la pena señalar que dado que definimos una versión especializada que acepta solo una cadena, cada vez que llamamos a la función con una cadena, llamará a la versión especializada. La función más genérica no se llamará cuando se pase una cadena.

A continuación, hablemos sobre la devolución de valores de una función. En Julia, tiene dos opciones, puede usar la returnpalabra clave explícita, o puede optar por hacerlo implícitamente haciendo que la última expresión en la función sirva como valor de retorno así:

julia> function sayhi()
           "This is a test"
           "hi"
       end
sayhi (generic function with 1 method)

julia> sayhi()
"hi"

En el ejemplo anterior, el valor de cadena "hola" se devuelve desde la función, ya que es la última expresión y no hay una declaración de devolución explícita. También podría definir la función como:

julia> function sayhi()
           "This is a test"
          return "hi"
       end
sayhi (generic function with 1 method)

julia> sayhi()
"hi"

En general, desde el punto de vista de la legibilidad, tiene sentido usar la declaración de devolución explícita en caso de que alguien que lea su código no conozca el comportamiento de devolución implícita en las funciones de Julia.

Otra característica útil de las funciones es la capacidad de proporcionar argumentos opcionales:


julia> function sayhello(response="hello")
          return response
       end
sayhello (generic function with 2 methods)

julia> sayhello()
"hello"

julia> sayhello("hi")
"hi"

En este ejemplo, lo definimos responsecomo un argumento opcional para que podamos permitirle usar el comportamiento predeterminado que definimos o podemos anularlo manualmente cuando sea necesario. Estos ejemplos solo rascan la superficie de lo que es posible con funciones en Julia. Si desea leer más sobre todas las cosas geniales que puede hacer, consulte: https://docs.julialang.org/en/v1/manual/functions/

Cómo usar Paquetes en Julia 📦

El administrador de paquetes de Julia y el ecosistema de paquetes son algunas de las características más importantes del lenguaje. De hecho, escribí un artículo completo sobre por qué es una de las características más subestimadas del lenguaje .

Dicho esto, hay dos formas de interactuar con los paquetes en Julia: a través de REPL o usando el paquete Pkg. Nos centraremos principalmente en REPL en esta publicación, ya que es mucho más fácil de usar en mi experiencia.

Una vez que haya instalado Julia, puede ingresar al administrador de paquetes desde REPL escribiendo ].

Modo paquete en Julia REPL

Ahora que estamos en el administrador de paquetes, hay algunas cosas que comúnmente queremos hacer:

  • agregar un paquete
  • quitar un paquete
  • Comprobar lo que ya está instalado

Si desea ver todos los comandos posibles en el REPL, simplemente ingrese al modo Pkg escribiendo ]y luego escriba ?  seguido de la tecla enter/return.

Cómo agregar paquetes de Julia ➕

Agreguemos nuestro primer paquete, Example.jl. Para ello, podemos ejecutar:

(@v1.7) pkg> add Example

que debería proporcionar una salida que se parece a:

(@v1.7) pkg> add Example
Updating registry at `~/.julia/registries/General`
Updating git-repo `https://github.com/JuliaRegistries/General.git`
Updating registry at `~/.julia/registries/JuliaPOMDP`
Updating git-repo `https://github.com/JuliaPOMDP/Registry`
Resolving package versions...
Installed Example ─ v0.5.3
Updating `~/.julia/environments/v1.7/Project.toml`
[7876af07] + Example v0.5.3
Updating `~/.julia/environments/v1.7/Manifest.toml`
[7876af07] + Example v0.5.3
Precompiling project...
1 dependency successfully precompiled in 1 seconds (69 already precompiled)
(@v1.7) pkg>

Por razones de espacio, omitiré más salidas bajo el supuesto de que me sigues.

Cómo verificar el estado del paquete en Julia 🔍

Ahora que creemos que tenemos un paquete instalado, verifiquemos dos veces si realmente está allí escribiendo status(o stde forma abreviada) en el administrador de paquetes:

(@v1.7) pkg> st
Status `~/.julia/environments/v1.7/Project.toml`
[7876af07] Example v0.5.3
[587475ba] Flux v0.12.8

Aquí podemos ver que tengo dos paquetes instalados, Flux y Example. También me da la ruta al archivo que administra mi entorno actual (en este caso, Julia v1.7 global) junto con las versiones de paquetes que tengo instaladas.

Cómo quitar un paquete de Julia 📛

Si quisiera eliminar un paquete de mi entorno activo, como Flux, simplemente puedo escribir remove Flux(o rmcomo abreviatura):

(@v1.7) pkg> rm Flux
Updating `~/.julia/environments/v1.7/Project.toml`
[587475ba] - Flux v0.12.8

Un rápido statusdespués muestra que esto fue exitoso:

(@v1.7) pkg> st
Status `~/.julia/environments/v1.7/Project.toml`
[7876af07] Example v0.5.3

Ahora conocemos los conceptos básicos de trabajar con paquetes. Pero hemos cometido un gran crimen de programación al utilizar nuestro entorno de paquete global.

Cómo usar los paquetes de Julia 📦

Ahora que hemos repasado cómo administrar paquetes, exploremos cómo usarlos. Sencillamente, solo necesita escribir using packageNamepara usar un paquete específico que desee. Una de mis nuevas características favoritas en Julia 1.7 (destacada en esta publicación de blog ) se muestra a continuación:

Imagen capturada por el autor

Si recuerda, eliminamos el paquete Flux y, por supuesto, lo olvidé, así que fui a usarlo y lo cargué escribiendo using Flux. El REPL me solicita automáticamente que lo instale a través de un simple indicador "s/n". Esta es una característica pequeña pero ahorra una gran cantidad de tiempo y una posible confusión.

Vale la pena señalar que hay dos formas de acceder a las funciones exportadas de un paquete: a través de la usingpalabra clave y la importpalabra clave. La gran diferencia es que usingtrae automáticamente todas las funciones al espacio de nombres actual (para lo cual puede pensar en una gran lista de funciones cuyas definiciones conoce Julia), mientras que importle da acceso a todas las funciones pero tiene que prefijar la función con el nombre del paquete como: Flux.gradient()donde Fluxes el nombre del paquete y gradient()es el nombre de una función.


¿Cómo usar Structs en Julia?

Julia no tiene paradigmas de programación orientada a objetos (POO) integrados en el lenguaje como clases. Sin embargo, las estructuras en Julia se pueden usar de manera similar a las clases para crear objetos y tipos personalizados. A continuación, mostraremos un ejemplo básico:

julia> mutable struct dog
           breed::String
           paws::Int
           name::String
           weight::Float64
       end

julia> my_dog = dog("Australian Shepard", 4, "Indy", 34.0)
dog("Australian Shepard", 4, "Indy", 34.0)

julia> my_dog.name
"Indy"

En este ejemplo, definimos una estructura para representar un perro. En la estructura, definimos cuatro atributos que componen el objeto perro. En las líneas siguientes, mostramos el código para crear realmente un objeto de perro y luego acceder a algunos de sus atributos. Tenga en cuenta que no necesita especificar los tipos de los atributos, puede dejarlo más abierto. Para este ejemplo, definimos tipos explícitos para resaltar esa característica.

Notarás que, de forma similar a las clases en Python (y otros lenguajes), no definimos un constructor explícito para crear el objeto perro. Sin embargo, podemos definir uno si fuera útil usarlo:

julia> mutable struct dog
           breed::String
           paws::Int
           name::String
           weight::Float64
           
           function dog(breed, name, weight, paws=4)
               new(breed, paws, name, weight)
           end
       end

julia> new_dog = dog("German Shepard", "Champ", 46)
dog("German Shepard", 4, "Champ", 46.0)

Aquí definimos un constructor y usamos la palabra clave especial newpara crear el objeto al final de la función. También puede crear getters y setters específicamente para el objeto perro haciendo lo siguiente:

julia> function get_name(dog_obj::dog)
           print("The dogs's name is: ", dog_obj.name)
       end
get_name (generic function with 1 method)

julia> get_name(new_dog)
The dogs's name is: Champ

En este ejemplo, la get_namefunción solo toma un objeto de tipo dog. Si intenta pasar algo más, se producirá un error:

julia> get_name("test")
ERROR: MethodError: no method matching get_name(::String)
Closest candidates are:
  get_name(::dog) at REPL[61]:1
Stacktrace:
 [1] top-level scope
   @ REPL[63]:1

Vale la pena señalar que también definimos la estructura para que sea mutable inicialmente para que podamos cambiar los valores de campo después de crear el objeto. Omite la palabra clave mutablesi desea que el estado inicial de los objetos persista.

Las estructuras en Julia no solo nos permiten crear objetos, también estamos definiendo un tipo personalizado en el proceso:

julia> typeof(new_dog)
dog

En general, las estructuras se usan mucho en el ecosistema de Julia y puede obtener más información sobre ellas en los documentos: https://docs.julialang.org/en/v1/base/base/#struct

Recursos adicionales de aprendizaje de programación de Julia 📚

Espero que este tutorial te haya ayudado a ponerte al día con muchas de las ideas centrales del lenguaje Julia. Dicho esto, sé que todavía hay lagunas, ya que esta es una guía extensa pero no completa. Para obtener más información sobre Julia, puede consultar la pestaña de aprendizaje en el sitio web de Julia: https://julialang.org/learning/ que tiene cursos guiados, videos de YouTube y problemas de práctica guiados.

Si tiene otras preguntas o necesita ayuda para comenzar con Julia, no dude en ponerse en contacto conmigo: https://twitter.com/OfficialLoganK

Fuente del artículo original en https://www.freecodecamp.org

#julia #datascience #machinelearning

Iara  Simões

Iara Simões

1658507700

El poder de la programación de Julia para científicos de datos

Aprenda el poder de la programación de alto rendimiento de Julia para científicos de datos. Este tutorial ofrece una breve descripción de los conceptos básicos de Julia; su sintaxis y características.

Julia es un lenguaje de programación dinámico relativamente nuevo, rápido y de alto nivel. Aunque es un lenguaje de propósito general y se puede usar para escribir todo tipo de aplicaciones, gran parte de su ecosistema de paquetes y características están diseñadas para computación numérica de alto nivel. Julia se basa en varios lenguajes, desde los lenguajes de programación de sistemas de bajo nivel como C hasta lenguajes de escritura dinámica de alto nivel como Python, R y MATLAB. Y esto se refleja en su naturaleza de escritura opcional, su sintaxis y sus características. 

Julia no tiene clases; soluciona esto al admitir la creación rápida de tipos y métodos personalizados para estos tipos. Sin embargo, estas funciones no se limitan a los tipos para los que se crearon y pueden tener muchas versiones, una función denominada despacho múltiple. Admite llamadas directas a funciones C sin ninguna API contenedora, por ejemplo, la palabra clave struct utilizada para definir tipos personalizados. Y en lugar de definir el alcance en función de la sangría como Python, Julia usa la palabra clave end, muy similar a MATLAB. 

Sería ridículo resumir todas sus características e idiosincrasias; puede consultar la página de bienvenida de wiki o docs para obtener una descripción más completa de Julia. Con eso, comencemos nuestro viaje de aprender los conceptos básicos de Julia y luego usarlos para crear soluciones de aprendizaje automático. Pero antes de hacerlo, deberá instalar Julia y configurar un entorno de desarrollo. Aunque Julia viene con su propio REPL, al igual que Python IDLE, usaremos cuadernos Jupyter. Aquí se explica cómo configurar Julia para ejecutarlo en cuadernos Jupyter:

  1. Descarga e instala Julia desde su sitio web .
  2. Abra la línea de comando de Julia.
  3. Ejecute el comando using Pkg(aprenderá más sobre esto más adelante).
  4. Instale el kernel de Julia para Jupyter usando  Pkg.add("IJulia").
  5. Ahora, cuando cree un cuaderno de Júpiter, tendrá la opción de seleccionar a Julia.

Fundamentos de Julia

IO, Variables y Aritmética 

De entrada y salida

Comenzaremos como cada tutorial de programación comienza con la declaración de confianza "Hello World". Para imprimir cosas en la terminal, Julia proporciona el println()método.

 println("Hello World")
 Hello World 

Para recibir información desde la línea de comando, puede usar los métodos (¿inspirados en Java?) readline()y .readlines()

Operadores

Todos los operadores aritméticos se comportan de manera similar a sus contrapartes de Python, excepto el operador exponente **, que se reemplaza por ^en Julia.  

 println(6 + 5)
 println(3 - 8)
 println(5 * 7)
 println(666 / 11)
 println(666 % 11)
 println(2 ^ 10)

 11
 -5
 35
 60.54545454545455
 6
 1024 

Variables

Los nombres de variables en Julia deben comenzar con un guión bajo, un alfabeto o un subconjunto de puntos de código Unicode mayores que 00A0 . Los siguientes caracteres también pueden incluir !y dígitos. Curiosamente, Julia también admite el uso de emojis y operadores como +identificador; tenga en cuenta que el comportamiento de los operadores cambia después de ser utilizado como identificador. Esto sucede porque el +símbolo es originalmente un identificador que se refiere a una función de suma. 

 best_num = 73
 println(typeof(best_num))
 π = 3.1415
 println(typeof(π))
 ????  = "Like a boss"
 println(typeof( ???? ))
 # doesn't work in Jupyter notebooks, try in Julia  CLI
 # + = "Do you know the way?"
 # print(+)

 Int64
 Float64
 String 

Puede obtener más información sobre las convenciones de estilo y nombres de variables de Julia aquí .

Comentarios y cadenas

Al igual que Python, los comentarios de una sola línea se pueden hacer en Julia usando el #símbolo, para comentarios de varias líneas, usa la #=  =#sintaxis.

 # One line comment

 #= Multiple
 line 
 comment=# 

Hay dos formas de definir una cadena en Julia; ya hemos usado comillas simples “ ”, la otra son comillas triples, “”” “””. Existen algunas diferencias funcionales entre las cadenas encerradas entre comillas simples y triples. El mayor es que puede usar comillas dentro de cadenas de comillas triples sin necesidad de escapar.

 "This is a string."
 """Look, Ma! No "errors"! """ 

Las cadenas son indexables y segmentables, pero la indexación comienza en uno. Sí, Julia usa indexación basada en 1, no basada en 0 como Python. Las guerras se libran por cuestiones menores. Además, Julia proporciona palabras clave beginque end pueden usarse como abreviaturas para el primer y último índice.

 println(s[end])
 println(s[begin])
 println(s[begin + 2])
 println(s[2:5])

 .
 T
 i
 his  

Otra cosa a tener en cuenta es ‘ ‘definir un carácter, no una cadena.

 typeof('a')

 Char 

En Julia, el $símbolo se usa para insertar variables en una cadena y para evaluar expresiones dentro de una cadena. 

 name = "Aditya"
 num_articles = 40
 num_papers = 18
 println("Hello, my name is $name.")
 println("I have written $num_articles articles and covered $num_papers research papers.")

 Hello, my name is Aditya.
 I have written 40 articles and covered 18 research papers. 

Hay tres formas de concatenar cadenas en Julia. La primera es utilizar la interpolación de cadenas. 

 s1 = "How many cats "
 s2 = "is too many cats?"
 ???? = 3
 println("$s1$s2")

 "How many cats is too many cats?" 

Otra es usar el método string() que también se puede usar para convertir otras entradas que no son cadenas en cadenas.

 string("I don't know, but ", ????, " is too few.")
 "I don't know, but 3 is too few." 

O usa el *operador. 

s1*s2

Puede obtener más información sobre las cadenas en Julia aquí .

Estructuras de datos 

Julia ofrece tres estructuras de datos, Tuple, Arrays y Dictionaries. Funcionalmente, todos estos actúan como sus contrapartes de Python; solo la sintaxis es un poco diferente.

tuplas

Al igual que Python, las tuplas son inmutables y también tienen una variante similar a un diccionario. Para definir una tupla, una colección ordenada de elementos encerrados en ( )

 animals = ("penguins", "cats", " kangaroo")
 animals[1]

 "penguins" 

Introducidas en Julia 1.0, NamedTuples actúan como tuplas excepto que cada elemento tiene un nombre asociado. Usan una sintaxis especial usando =dentro de una tupla.

 animals = (bird = "ducks", mammal = "cats", marsupial = "kangaroo")
 animals.bird # animals[1] 

Diccionarios

Los diccionarios se utilizan para almacenar conjuntos de datos relacionados entre sí y se pueden crear utilizando la Dict()función y la =>sintaxis.

 contacts  = Dict("Sheldon" => "732-1371", "Ghostbusters" => "555-2368")
 contacts["Elliot"] = "127-0001"
 contacts 

 Dict{String, String} with 2 entries:
   "Sheldon"      => "732-1371"
   "Ghostbusters" => "555-2368" 

El pop!()método se puede utilizar para eliminar elementos de un diccionario.

 pop!(contacts , "Elliot")  #we'll learn about the ! later  
 contacts 

 Dict{String, String} with 2 entries:
   "Sheldon"      => "732-1371"
   "Ghostbusters" => "555-2368" 

arreglos

Las matrices en Julia son colecciones mutables ordenadas que pueden almacenar tipos mixtos. Se pueden indexar, dividir y editar utilizando los métodos  push!()& .pop!()

 HIMYM = ["Ted", "Barney", "Lily", "Marshall", "Robin"]
 fibonacci = [1, 1, 2, 3, 5, 8, 13]
 mix = [7, 3, "Ted", "Robyn"]
 HIMYM[2] = "The Lengend Himself"
 println(HIMYM)

 ["Ted", "The Lengend Himself", "Lily", "Marshall", "Robin"]

 push!(fibonacci, 21)
 push!(fibonacci, 34)
 pop!(fibonacci)
 println(fibonacci)

 9-element Vector{Int64}:
   1
   1
   2
   3
   5
   8
  13
  21

El concepto de copias superficiales y profundas también persiste en Julia, y para copiar un Array, puede usar el copy()método familiar. 

 numbers = fibonacci
 numbers[1] = 404
 println(fibonacci)

 [404, 1, 2, 3, 5, 8, 13, 21]
 fibonacci[1] = 1
 numbers = copy(fibonacci)
 numbers[1] = 404
 println(fibonacci)

 [1, 1, 2, 3, 5, 8, 13, 21] 

Puede leer más sobre las estructuras de datos en Julia aquí .

Bucles y Condicionales

mientras que los bucles

 HIMYM = ["Ted", "Barney", "Lily", "Marshall", "Robin"]
 i = 1
 while i <= length(HIMYM)
     friend = myfriends[i]
     println("Have you met $friend?")
     global i += 1
 end

 Have you met Ted?
 Have you met Robin?
 Have you met Barney?
 Have you met Lily?
 Have you met Marshall? 

para bucles

El ejemplo anterior se puede recrear usando bucles for como

 for friend in HIMYM
     println("Have you met $friend?")
 end 

El verdadero poder de los bucles for sale a la luz cuando se trabaja con datos multidimensionales. Vamos a crear tablas adicionales para ilustrar esto.

 m, n = 5, 5
 A = fill(0, (m, n))
 for j in 1:n
     for i in 1:m
         A[i, j] = i + j
     end
 end
 println(A) 

Aquí hay una sintaxis de Julia relativamente más compacta para escribir bucles for anidados.

 B = fill(0, (m, n))
 for j in 1:n, i in 1:m
     B[i, j] = i + j
 end
 println(B) 

Y por último, la forma más “Julia” usando una comprensión de arreglos.

C = [i + j for i in 1:m, j in 1:n]

Puede obtener más información sobre los bucles en Julia aquí.

Condicionales 

Julia no solo ofrece la sintaxis if-else, sino que también es compatible con la sintaxis del operador ternario que tanto se echa de menos para escribir declaraciones condicionales. 

 x = 7
 y = 3

 if x > y
     x
 else
     y
 end 

es equivalente a 

(x > y) ? x : y

Puede obtener más información sobre las declaraciones de flujo de control aquí .

Funciones

Julia admite tres formas de declarar funciones. El primero utilizó las palabras clave functiony end:

 function sayhi(name)
     println("Hi $name, it's great to see you!")
 end
 function f(x)
     x^2
 end 

Estas funciones también se pueden escribir como funciones de una línea:

 sayhi2(name) = println("Hi $name, it's great to see you!")
 f2(x) = x^2 

o como funciones “anónimas” 

 sayhi3 = name -> println("Hi $name, it's great to see you!")
 f3 = x -> x^2 

Duck-typing en Julia

En Julia, las funciones intentan arreglárselas con cualquier tipo de argumento que se les pase. Por ejemplo, hola funcionará con un número entero y f funcionará con una matriz o una cadena.

 println(hello(55595472))
 A = rand(3, 3)
 println(f(A))
 println(f("hi"))

 Hello 55595472, it's great to see you!
 [1.098291594301114 0.5733286686511377 1.2973169349506042; 1.5089880137440685 1.0767547143728742 1.7354001978884117; 0.6092825261800483 0.5512628958029917 0.958821963007823]
 "hihi" 

Funciones mutantes y no mutantes

Por convención, las funciones seguidas de !alteran sus argumentos y las funciones sin !don't. Esta no es una regla fija para todas las funciones; es solo una forma mejor y más fácil de diferenciar funciones mutantes.

 v = [3, 5, 2]
 sort(v)
 println(v)

 [3, 5, 2] 

sort(v)devuelve una matriz ordenada, pero vpermanece sin cambios. Por otro lado, sort!(v) modifica los contenidos de v, que ahora están ordenados dentro de la matrizv

 sort!(v)
 println(v)

 [2, 3, 5] 

Funciones de orden superior

Las funciones de orden superior son funciones que toman otra función como argumento. Repasemos dos de las funciones de orden superior que ofrece Julia: mapa y transmisión.

map()aplica la función a cada elemento de la estructura de datos que se le pasa.

 println(map(x -> x^3, [1, 2, 3]))

 [1, 8, 27]

broadcast()es una versión más generalizada de map(); puede hacer todo lo que map()puede hacer y más. Ambas funciones aplican una función a través de una estructura de datos. La diferencia entre los dos es cómo tratan las matrices multidimensionales. 

 println(map(+, 9, [2,2,2]))
 println(broadcast(+, 9, [2,2,2]))

 [11]
 [11, 11, 11] 

map()combina primero las columnas que luego se usan como argumentos para la función dada; por otro lado, broadcast()hace una aplicación por elementos de la función dada. Además, broadcast()también tiene una sintaxis más concisa usando el .operador que nos permite escribir expresiones complejas por elementos de forma más natural.  

 A = [i + 3*j for j in 0:2, i in 1:3]
 println(A .+ 2 .* f.(A) ./ A)
 # instead of
 println(broadcast(x -> x + 2 * f(x) / x, A))


 [3.0 6.0 9.0; 12.0 15.0 18.0; 21.0 24.0 27.0]
 [3.0 6.0 9.0; 12.0 15.0 18.0; 21.0 24.0 27.0] 

Puedes leer más sobre funciones en Julia aquí .

Trabajando con Paquetes en Julia

Julia tiene más de 2000 paquetes, lo que parece mucho, pero en comparación con la friolera de 1,37,000 de Python, el ecosistema de paquetes aún tiene que crecer. Dicho esto, Julia tiene llamadas de función de primera clase a otros lenguajes; estos proporcionan interfaces de funciones externas. Puede llamar fácilmente a Python o R, por ejemplo, con PyCallo Rcall. Esto permite a los desarrolladores usar su paquete/biblioteca favorito de confianza de otros idiomas. Para ver todos los paquetes disponibles, consulta:

Para usar un paquete en una instalación de Julia, deberá usar el administrador de paquetes Pkg, para agregarlo explícitamente. Ya tienes instalado el paquete “IJulia” al principio del artículo. Ahora veamos brevemente uno de los mejores paquetes de Julia que he encontrado en mi experiencia limitada: el paquete Plots.jl que permite a los desarrolladores cambiar entre backends mientras usan la misma API sin problemas.

Ilustraremos esto usando los backends GR y Plotly, pero primero, agreguemos el paquete e “importémoslo” usando el usingcomando “ ”.  

 using Pkg
 Pkg.add("Plots")
 using Plots 

y cree algunos datos ficticios para trazar.

 price = [14.4, 14.5, 14.8, 15.2, 15.5, 15.8]
 quantity = [45000, 20000, 15000, 5000, 400, 17]
 Pkg.add("GR")
 gr() #switching backend
 plot(quantity, price, label="line")  
 scatter!(quantity, price, label="points")  

Fíjate cómo usamos scatter!()y no scatter(); si tuviéramos que usar la variante no mutante, crearía una nueva gráfica con solo la gráfica de dispersión.

 Pkg.add("PlotlyJS")
 plotlyjs() #switching backend 

Puede obtener el cuaderno Jupyter con el código anterior aquí . No pude hacer que Julia trabajara en Colab; avísame si tienes suerte.

última época

Este artículo dio una breve descripción de la sintaxis básica y las características de Julia. Entre los que cubrió, algunas cosas son extremadamente útiles e intuitivas. Como el uso del !símbolo para indicar funciones mutantes o el compacto. sintaxis de símbolos del método broadcast(). Por otro lado, también hay algunas opciones repulsivas como el uso de *para concatenar cadenas o el uso de engorroso =>en los diccionarios. (Todo esto proviene de una perspectiva muy sesgada por Python). Dicho esto, Julia promete mucho en su capacidad para interactuar con otros lenguajes sin problemas y ejecutar incluso código desvectorizado tan rápido como C. Además, aún es temprano en su proceso de desarrollo, no tiene ni una década. Evolucionará durante la próxima década más o menos. 

Fuente del artículo original en https://analyticsindiamag.com

#julia #datascience #machinelearning

joe biden

1617255938

¿Cómo migrar los buzones de correo de Exchange a la nube de Office 365?

Si tiene problemas para migrar los buzones de correo de Exchange a Office 365, debe leer este artículo para saber cómo migrar los buzones de correo de Exchange EDB a Office 365. Al migrar a Office 365, los usuarios pueden acceder a sus buzones de correo desde cualquier lugar y desde cualquier dispositivo.

En esta publicación, explicaremos las razones detrás de esta migración y una solución profesional para migrar de Exchange a Office 365.

Razones para migrar Exchange Server a la nube de Office 365

Office 365 apareció por primera vez en 2011 y, dado que se considera la mejor plataforma para aquellas organizaciones que desean administrar todo su sistema de correo electrónico en la nube. Estas son las características clave de Office 365:

  1. Permite trabajar desde cualquier lugar y desde cualquier lugar.
  2. No se preocupe por el spam y el malware.
  3. La seguridad proporcionada por Office 365 es altamente confiable.
  4. Controla el costo total y brinda flexibilidad financiera.
  5. Todas las actualizaciones y mejoras son administradas por Microsoft.

¿Cómo migrar los buzones de correo de Exchange a Office 365?

Hay varias formas manuales de migrar los buzones de correo de Exchange EDB a Office 365, pero para evitar estos complicados y prolongados procedimientos, presentamos una solución de terceros, es decir, la herramienta de migración de Exchange, que es automatizada y directa para la migración de Exchange a Office 365. La herramienta funciona rápidamente y migra todos los elementos del buzón de Exchange Server a Office 365.

La herramienta de migración de Datavare Exchange es demasiado fácil de usar y ofrece pasos sencillos para migrar EDB a Office 365:

  1. Descargue e instale el software en su sistema.
  2. Agregue el archivo EDB de Exchange con el botón Examinar.
  3. Seleccione exportar a buzones de correo de Office 365.
  4. Proporcione los detalles de inicio de sesión de la cuenta de Office 365.
  5. Seleccione la carpeta y presione el botón Finalizar.

Por lo tanto, todos sus buzones de correo de Exchange EDB ahora se migran a Office 365.
Nota: puede usar filtros para migrar los elementos de datos deseados de la cuenta de Exchange a la de Office 365

Líneas finales

Este blog le indica una solución profesional para la migración de buzones de correo de Exchange a la cuenta de Office 365. Dado que las soluciones manuales son complicadas, sugerimos la herramienta de migración de Exchange, que es demasiado simple de usar. Los usuarios no se enfrentan a problemas al operar el programa. La mejor parte de este software es que no necesita habilidades técnicas para realizar la migración. Se puede comprender el funcionamiento del software descargando la versión de demostración que permite la migración de los primeros 50 elementos por carpeta.

Más información:- https://www.datavare.com/software/edb-migration.html

#herramienta de migración de intercambio #migración de intercambio #migrar buzones de correo de exchange

joe biden

1617257581

Software de restauración de Exchange para restaurar sin problemas PST en Exchange Server

¿Quiere restaurar los buzones de correo de PST a Exchange Server? Entonces, estás en la página correcta. Aquí, lo guiaremos sobre cómo puede restaurar fácilmente mensajes y otros elementos de PST a MS Exchange Server.

Muchas veces, los usuarios necesitan restaurar los elementos de datos de PST en Exchange Server, pero debido a la falta de disponibilidad de una solución confiable, los usuarios no pueden obtener la solución. Háganos saber primero sobre el archivo PST y MS Exchange Server.

Conozca PST y Exchange Server

PST es un formato de archivo utilizado por MS Outlook, un cliente de correo electrónico de Windows y muy popular entre los usuarios domésticos y comerciales.

Por otro lado, Exchange Server es un poderoso servidor de correo electrónico donde todos los datos se almacenan en un archivo EDB. Los usuarios generalmente guardan la copia de seguridad de los buzones de correo de Exchange en el archivo PST, pero muchas veces, los usuarios deben restaurar los datos del archivo PST en Exchange. Para resolver este problema, estamos aquí con una solución profesional que discutiremos en la siguiente sección de esta publicación.

Un método profesional para restaurar PST a Exchange Server

No le recomendamos que elija una solución al azar para restaurar los datos de PST en Exchange Server. Por lo tanto, al realizar varias investigaciones, estamos aquí con una solución inteligente y conveniente, es decir, Exchange Restore Software. Es demasiado fácil de manejar por todos los usuarios y restaurar cómodamente todos los datos del archivo PST a Exchange Server.

Funciones principales ofrecidas por Exchange Restore Software

El software es demasiado simple de usar y se puede instalar fácilmente en todas las versiones de Windows. Con unos pocos clics, la herramienta puede restaurar los elementos del buzón de Exchange.

No es necesario que MS Outlook restaure los datos PST en Exchange. Todos los correos electrónicos, contactos, notas, calendarios, etc. se restauran desde el archivo PST a Exchange Server.

Todas las versiones de Outlook son compatibles con la herramienta, como Outlook 2019, 2016, 2013, 2010, 2007, etc. La herramienta proporciona varios filtros mediante los cuales se pueden restaurar los datos deseados desde un archivo PST a Exchange Server. El programa se puede instalar en todas las versiones de Windows como Windows 10, 8.1, 8, 7, XP, Vista, etc.

Descargue la versión de demostración del software de restauración de Exchange y analice el funcionamiento del software restaurando los primeros 50 elementos por carpeta.

Líneas finales

No existe una solución manual para restaurar los buzones de correo de Exchange desde el archivo PST. Por lo tanto, hemos explicado una solución fácil e inteligente para restaurar datos de archivos PST en Exchange Server. Simplemente puede usar este software y restaurar todos los datos de PST a Exchange Server.

Más información:- https://www.datavare.com/software/exchange-restore.html

#intercambio de software de restauración #intercambio de restauración #buzón del servidor de intercambio #herramienta de restauración de intercambio