Julia Language
Expresiones

algorithm C Language C++ Git MATLAB Language matplotlib Python Language R Language Regular Expressions tensorflow
Buscar..


Introducción a las expresiones

Las expresiones son un tipo específico de objeto en Julia. Puede pensar que una expresión representa un fragmento de código Julia que aún no se ha evaluado (es decir, ejecutado). Luego hay funciones y operaciones específicas, como eval() que evaluarán la expresión.

Por ejemplo, podríamos escribir un guión o ingresar al intérprete lo siguiente: julia> 1 + 1 2

Una forma de crear una expresión es mediante la sintaxis :() . Por ejemplo: 

julia> MyExpression = :(1+1)
:(1 + 1)
julia> typeof(MyExpression)
Expr

Ahora tenemos un objeto de tipo Expr . Una vez que se acaba de formar, no hace nada, solo se sienta como cualquier otro objeto hasta que se actúe. En este caso, podemos evaluar esa expresión usando la función eval() : 

julia> eval(MyExpression)
2

Así, vemos que los dos siguientes son equivalentes: 

1+1
eval(:(1+1))

¿Por qué querríamos pasar por una sintaxis mucho más complicada en eval(:(1+1)) si solo queremos encontrar qué es igual a 1 + 1? La razón básica es que podemos definir una expresión en un punto de nuestro código, potencialmente modificarla más tarde y luego evaluarla en un punto posterior. Esto puede potencialmente abrir nuevas y poderosas capacidades al programador Julia. Las expresiones son un componente clave de la metaprogramación en Julia.

Creando expresiones

Hay varios métodos diferentes que se pueden usar para crear el mismo tipo de expresión. Las expresiones introducidas mencionan la sintaxis :() . Quizás el mejor lugar para comenzar, sin embargo, es con cuerdas. Esto ayuda a revelar algunas de las similitudes fundamentales entre las expresiones y las cadenas en Julia.

Crear Expresión desde Cadena

De la documentación de Julia:

Cada programa de Julia comienza la vida como una cadena.

En otras palabras, cualquier script de Julia simplemente se escribe en un archivo de texto, que no es más que una cadena de caracteres. Del mismo modo, cualquier comando de Julia ingresado en un intérprete es solo una cadena de caracteres. El rol de Julia o cualquier otro lenguaje de programación es interpretar y evaluar cadenas de caracteres de una manera lógica y predecible, de modo que esas cadenas de caracteres puedan usarse para describir lo que el programador desea que la computadora realice.

Por lo tanto, una forma de crear una expresión es usar la función parse() aplicada a una cadena. La siguiente expresión, una vez evaluada, asignará el valor de 2 al símbolo x . 

MyStr = "x = 2"
MyExpr = parse(MyStr)
julia> x
ERROR: UndefVarError: x not defined
eval(MyExpr)
julia> x
2

Crear expresión usando :() Sintaxis 

MyExpr2 = :(x = 2)
julia> MyExpr == MyExpr2
true

Tenga en cuenta que con esta sintaxis, Julia tratará automáticamente los nombres de los objetos como referentes a símbolos. Podemos ver esto si miramos los args de la expresión. (Consulte Campos de objetos de expresión para obtener más detalles sobre el campo args en una expresión). 

julia> MyExpr2.args
2-element Array{Any,1}:
  :x
 2

Crear expresión usando la función Expr() 

MyExpr3 = Expr(:(=), :x, 2)
MyExpr3 == MyExpr

Esta sintaxis se basa en la notación de prefijo . En otras palabras, el primer argumento de la función Expr() especificada es el head o el prefijo. Los restantes son los arguments de la expresión. El head determina qué operaciones se realizarán en los argumentos.

Para más detalles sobre esto, vea Campos de objetos de expresión.

Al usar esta sintaxis, es importante distinguir entre el uso de objetos y símbolos para objetos. Por ejemplo, en el ejemplo anterior, la expresión asigna el valor de 2 al símbolo :x , una operación perfectamente sensible. Si usáramos x en una expresión como esa, obtendríamos el resultado sin sentido: 

julia> Expr(:(=), x, 5)
:(2 = 5)

Del mismo modo, si examinamos los args vemos: 

julia> Expr(:(=), x, 5).args
2-element Array{Any,1}:
 2
 5

Por lo tanto, la función Expr() no realiza la misma transformación automática en símbolos que la sintaxis :() para crear expresiones.

Crea expresiones multilínea usando quote...end 

MyQuote = 
quote
    x = 2
    y = 3
end
julia> typeof(MyQuote)
Expr

Tenga en cuenta que con quote...end podemos crear expresiones que contengan otras expresiones en su campo args : 

julia> typeof(MyQuote.args[2])
Expr

Consulte Campos de objetos de expresión para obtener más información sobre este campo args .

Más sobre la creación de expresiones

Este ejemplo solo proporciona los conceptos básicos para crear expresiones. Consulte también, por ejemplo, Interpolación y expresiones y Campos de objetos de expresión para obtener más información sobre cómo crear expresiones más complejas y avanzadas.

Campos de objetos de expresión

Como se menciona en las expresiones de Introducción a Expresiones , son un tipo específico de objeto en Julia. Como tales, tienen campos. Los dos campos más utilizados de una expresión son su head y sus args . Por ejemplo, considere la expresión 

MyExpr3 = Expr(:(=), :x, 2)

discutido en la creación de expresiones . Podemos ver la head y args siguiente manera: 

julia> MyExpr3.head
:(=)

julia> MyExpr3.args
2-element Array{Any,1}:
  :x
 2

Las expresiones se basan en la notación de prefijo . Como tal, el head generalmente especifica la operación que se realizará en los args . La cabeza tiene que ser de Julia Symbol .

Cuando una expresión es para asignar un valor (cuando se evalúa), generalmente usará un encabezado de :(=) . Por supuesto, hay variaciones obvias a esto que se pueden emplear, por ejemplo: 

ex1 = Expr(:(+=), :x, 2)

: llamada para cabezas de expresión

Otra head común para las expresiones es :call . P.ej 

ex2 = Expr(:call, :(*), 2, 3)
eval(ex2) ## 6

Siguiendo las convenciones de la notación de prefijo, los operadores se evalúan de izquierda a derecha. Por lo tanto, esta expresión aquí significa que llamaremos la función que se especifica en el primer elemento de args en los elementos posteriores. Igualmente podríamos tener: 

julia> ex2a = Expr(:call, :(-), 1, 2, 3)
:(1 - 2 - 3)

U otras funciones potencialmente más interesantes, por ejemplo, 

julia> ex2b = Expr(:call, :rand, 2,2)
:(rand(2,2))

julia> eval(ex2b)
2x2 Array{Float64,2}:
 0.429397  0.164478
 0.104994  0.675745

Determinación automática de la head cuando se utiliza :() notación de creación de expresión

Tenga en cuenta que :call se usa implícitamente como encabezado en ciertas construcciones de expresiones, por ejemplo, 

julia> :(x + 2).head
:call

Por lo tanto, con la sintaxis :() para crear expresiones, Julia buscará determinar automáticamente la cabeza correcta a usar. Similar: 

julia> :(x = 2).head
:(=)

De hecho, si no está seguro de cuál es la cabeza correcta que debe usar para una expresión que está formando, por ejemplo, Expr() esta puede ser una herramienta útil para obtener sugerencias e ideas sobre qué usar.

Interpolación y Expresiones

La creación de expresiones menciona que las expresiones están estrechamente relacionadas con las cadenas. Como tales, los principios de interpolación dentro de las cadenas también son relevantes para las expresiones. Por ejemplo, en la interpolación de cadenas básica, podemos tener algo como: 

n = 2
julia> MyString = "there are $n ducks"
"there are 2 ducks"

Usamos el signo $ para insertar el valor de n en la cadena. Podemos usar la misma técnica con expresiones. P.ej 

a = 2
ex1 = :(x = 2*$a)  ##     :(x = 2 * 2)
a = 3
eval(ex1)
x # 4

Contraste esto este: 

a = 2
ex2 = :(x = 2*a) # :(x = 2a)
a = 3
eval(ex2)
x # 6

Así, con el primer ejemplo, establecemos por adelantado el valor de a que se utilizará en el momento en que se evalúa la expresión. Con el segundo ejemplo, sin embargo, el compilador Julia solo se ve a a de encontrar su valor en el momento de la evaluación de nuestra expresión.

Referencias externas sobre expresiones

Hay una serie de recursos web útiles que pueden ayudarlo a mejorar su conocimiento de las expresiones en Julia. Éstos incluyen:

SO Publicaciones:



Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow