Julia Language
Comprensiones

Comprensión de matriz

Sintaxis basica

Las comprensiones de matriz de Julia usan la siguiente sintaxis:

[expression for element = iterable]

Tenga en cuenta que al igual que con for bucles , todos = , in , y ∈ son aceptados para la comprensión.

¡Esto es aproximadamente equivalente a crear una matriz vacía y usar un bucle for para push! artículos para ello.

result = []
for element in iterable
    push!(result, expression)
end

sin embargo, el tipo de comprensión de una matriz es lo más estrecho posible, lo que es mejor para el rendimiento.

Por ejemplo, para obtener una matriz de los cuadrados de los enteros de 1 a 10 , se puede usar el siguiente código.

squares = [x^2 for x=1:10]

Este es un reemplazo limpio y conciso para la versión más larga for -loop.

squares = []
for x in 1:10
    push!(squares, x^2)
end

Comprensión de matriz condicional

Antes de la Julia 0.5, no hay forma de usar condiciones dentro de la comprensión de la matriz. Pero, ya no es cierto. En Julia 0.5 podemos usar las condiciones dentro de condiciones como las siguientes:

julia> [x^2 for x in 0:9 if x > 5] 
4-element Array{Int64,1}:
 36
 49
 64
 81

La fuente del ejemplo anterior se puede encontrar aquí .

Si nos gustaría utilizar la comprensión de la lista anidada:

julia>[(x,y) for x=1:5 , y=3:6 if y>4 && x>3 ]
4-element Array{Tuple{Int64,Int64},1}:
 (4,5)
 (5,5)
 (4,6)
 (5,6)

Comprensiones de matrices multidimensionales.

Anidado for bucles se puede usar para iterar sobre varios iterables únicos.

result = []
for a = iterable_a
    for b = iterable_b
        push!(result, expression)
    end
end

De manera similar, se pueden suministrar múltiples especificaciones de iteración a una comprensión de matriz.

[expression for a = iterable_a, b = iterable_b]

Por ejemplo, lo siguiente puede usarse para generar el producto cartesiano de 1:3 y 1:2 .

julia> [(x, y) for x = 1:3, y = 1:2]
3×2 Array{Tuple{Int64,Int64},2}:
 (1,1)  (1,2)
 (2,1)  (2,2)
 (3,1)  (3,2)

Las comprensiones de matrices multidimensionales aplanadas son similares, excepto que pierden la forma. Por ejemplo,

julia> [(x, y) for x = 1:3 for y = 1:2]
6-element Array{Tuple{Int64,Int64},1}:
 (1, 1)
 (1, 2)
 (2, 1)
 (2, 2)
 (3, 1)
 (3, 2)

Es una variante aplanada de las anteriores. La diferencia sintáctica es que se usa un adicional for lugar de una coma.

Comprensiones de generador

Las comprensiones de generadores siguen un formato similar a las comprensiones de matrices, pero usan paréntesis () lugar de corchetes [] .

(expression for element = iterable)

Dicha expresión devuelve un objeto Generator .

julia> (x^2 for x = 1:5)
Base.Generator{UnitRange{Int64},##1#2}(#1,1:5)

Argumentos de la función

Las comprensiones del generador pueden proporcionarse como el único argumento de una función, sin la necesidad de un conjunto adicional de paréntesis.

julia> join(x^2 for x = 1:5)
"1491625"

Sin embargo, si se proporciona más de un argumento, la comprensión del generador requiere su propio conjunto de paréntesis.

julia> join(x^2 for x = 1:5, ", ")
ERROR: syntax: invalid iteration specification

julia> join((x^2 for x = 1:5), ", ")
"1, 4, 9, 16, 25"