Cualquiera que haya usado Python casi con seguridad ha usado comprensiones de arrays, que han sido parte central de la sintaxis de Python desde sus primeras versiones.
Algo tan cómodo poco a poco se abre camino en otros lenguajes, incluido Julia.
Para quienes programan en Julia, las comprensiones son una opción y no una necesidad, ya que normalmente hay alternativas (broadcasting, funciones de orden superior, etc.).
Sin embargo, una comprensión suele ofrecer una forma simple, legible y con buen rendimiento de construir un array. Al final, usarlas es cuestión de gusto personal y de cómo te sientes respecto a Python frente a los lenguajes funcionales.
La sintaxis es en gran medida una copia directa de Python, pero con extensiones para arrays de más dimensiones.
Una sola variable
Muy al estilo Python, incluida la cláusula if opcional.
julia> [x^2 for x in 1:3]
3-element Vector{Int64}:
1
4
9
julia> [x^2 for x in 1:3 if isodd(x^2)]
2-element Vector{Int64}:
1
9
La forma de la salida depende de los detalles de la comprensión: normalmente es la misma que la de la colección de entrada en los casos simples, pero una cláusula if la aplana a un Vector.
julia> m
2×3 Matrix{Int64}:
1 2 3
4 5 6
julia> [x^2 for x in m]
2×3 Matrix{Int64}:
1 4 9
16 25 36
julia> [x^2 for x in m if isodd(x^2)]
3-element Vector{Int64}:
1
25
9
Varias variables, salida de tipo Vector
Como en Python, podemos tener varias cláusulas for con variables distintas, y con colecciones de entrada iguales o diferentes.
julia> [x * y for x in 1:3 for y in 4:6]
9-element Vector{Int64}:
4
5
6
8
10
12
12
15
18
julia> [x * y for x in 1:3 for y in 4:6 if isodd(x * y)]
2-element Vector{Int64}:
5
15
Esto equivale a bucles anidados.
La salida es unidimensional, incluso cuando la entrada es una matriz.
julia> m
2×3 Matrix{Int64}:
1 2 3
4 5 6
julia> [x*y for x in m for y in m]
36-element Vector{Int64}:
1
4
2
5
(truncated output...)
Varias variables, salida multidimensional
La sección anterior describió varias cláusulas for separadas únicamente por espacios.
En esta sección hay un solo for y las variables van separadas por comas.
julia> [(x, y) for x in 1:3, y in 4:6]
3×3 Matrix{Tuple{Int64, Int64}}:
(1, 4) (1, 5) (1, 6)
(2, 4) (2, 5) (2, 6)
(3, 4) (3, 5) (3, 6)
Cada variable de la comprensión crea una nueva dimensión en la salida, con una entrada para cada combinación posible de las variables.
En el ejemplo anterior, x aumenta a lo largo de las filas y y a lo largo de las columnas.
Es posible usar más dimensiones, con las advertencias habituales sobre la legibilidad de la salida.
Expresiones generadoras
Las secciones anteriores se centraron en la salida de tipo array, con la comprensión colocada dentro de corchetes [ ... ].
Cuando los corchetes se reemplazan por paréntesis ( ... ), pasa algo diferente: obtenemos una generator expression, un iterador de evaluación perezosa que puede producir el siguiente valor cuando se lo pide.
julia> g = ((x, y) for x in 1:3, y in 4:6)
Base.Generator{Base.Iterators.ProductIterator{Tuple{UnitRange{Int64}, UnitRange{Int64}}}, var"#9#10"}(var"#9#10"(), Base.Iterators.ProductIterator{Tuple{UnitRange{Int64}, UnitRange{Int64}}}((1:3, 4:6)))
# Indexing fails with a generator, the entries don't exist yet
julia> g[1, 2]
ERROR: MethodError: no method matching getindex(::Base.Generator{Base.Iterators.ProductIterator{Tuple{UnitRange{…}, UnitRange{…}}}, var"#9#10"}, ::Int64, ::Int64)
# conversion to array
julia> collect(g)
3×3 Matrix{Tuple{Int64, Int64}}:
(1, 4) (1, 5) (1, 6)
(2, 4) (2, 5) (2, 6)
(3, 4) (3, 5) (3, 6)
# generators are mainly designed for iteration
julia> [i * j for (i, j) in g]
3×3 Matrix{Int64}:
4 5 6
8 10 12
12 15 18
Cuando el resultado de una comprensión se usa de inmediato para seguir procesando, un generador puede ser eficiente en el uso de memoria, ya que evita tener que almacenar un array intermedio grande.
Un generador que se usa como argumento de una función no necesita paréntesis adicionales.
# inefficient
julia> v = [x^2 for x in 1:1e6];
julia> sum(v)
3.333338333335e17
# better - use a generator
julia> sum(x^2 for x in 1:1e6)
3.3333383333312755e17
La sintaxis de un generador es idéntica a la de una comprensión, salvo por los corchetes que la rodean.
Los generadores también pueden resultar cómodos en los constructores de diccionarios.
julia> Dict(x => x^2 for x in 1:5)
Dict{Int64, Int64} with 5 entries:
5 => 25
4 => 16
2 => 4
3 => 9
1 => 1
Ejercicio de aprendizaje
