Chiunque abbia usato Python ha quasi certamente usato le comprensioni di liste, che sono centrali nella sintassi di Python fin dalle prime versioni.
Qualcosa di così comodo si fa gradualmente strada anche in altri linguaggi, Julia compreso.
Per chi programma in Julia, le comprensioni sono un'opzione e non una necessità: di solito ci sono delle alternative (broadcasting, funzioni di ordine superiore, ecc.).
Tuttavia, una comprensione offrirà spesso un modo semplice, leggibile ed efficiente per costruire un array.
Usarle o meno è alla fine una questione di gusto personale, e di come vedi Python rispetto ai linguaggi funzionali.
La sintassi è per lo più una copia diretta di Python, ma con estensioni per array a più dimensioni.
Una sola variabile
Molto pythonico, inclusa la clausola if opzionale.
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 dell'output dipende dai dettagli della comprensione: nei casi semplici è di solito la stessa della collezione di input, ma una clausola if la appiattisce in 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
Più variabili, output di tipo Vector
Come in Python, possiamo avere più clausole for con variabili diverse, con collezioni di input uguali o diverse.
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
Questo equivale a cicli annidati.
L'output è monodimensionale, anche quando l'input è una matrice.
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...)
Più variabili, output multidimensionale
La sezione precedente ha descritto più clausole for separate solo da spazi.
In questa sezione c'è un solo for e le variabili sono separate da virgole.
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)
Ogni variabile della comprensione crea una nuova dimensione nell'output, con una voce per ogni possibile combinazione delle variabili.
Nell'esempio qui sopra, x aumenta scendendo lungo le righe, y aumenta scorrendo le colonne.
Sono possibili dimensioni superiori, con le solite avvertenze sulla leggibilità dell'output.
Espressioni generatore
Le sezioni precedenti si sono concentrate sull'output di tipo array, con la comprensione racchiusa tra parentesi quadre [ ... ].
Quando le parentesi quadre vengono sostituite da parentesi tonde ( ... ), succede qualcosa di diverso: otteniamo una generator expression, un iteratore valutato pigramente che può produrre il valore successivo su richiesta.
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
Quando il risultato di una comprensione viene usato subito per ulteriori elaborazioni, un generatore può essere efficiente in termini di memoria, evitando di dover memorizzare un grande array intermedio.
Un generatore usato come argomento di una funzione non ha bisogno di parentesi aggiuntive.
# 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 sintassi dei generatori è identica a quella delle comprensioni, a parte le parentesi che li racchiudono.
I generatori possono essere comodi anche nei costruttori di dizionari.
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
Esercizio di apprendimento
