Julia Language
Comprensioni

Array comprehension

Sintassi di base

La comprensione dell'array di Julia utilizza la seguente sintassi:

[expression for element = iterable]

Si noti che, come for cicli for , tutti i valori = , in e ∈ sono accettati per la comprensione.

Ciò equivale approssimativamente alla creazione di un array vuoto e all'utilizzo di un ciclo for da push! oggetti ad esso.

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

tuttavia, il tipo di comprensione dell'array è il più stretto possibile, il che è migliore per le prestazioni.

Ad esempio, per ottenere una matrice dei quadrati degli interi da 1 a 10 , è possibile utilizzare il codice seguente.

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

Si tratta di un sostituto pulito e conciso per la versione più lunga for -loop.

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

Comprensione dell'array condizionale

Prima di Julia 0.5, non c'è modo di usare le condizioni all'interno della comprensione dell'array. Ma non è più vero. In Julia 0.5 possiamo usare le condizioni in condizioni come le seguenti:

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

La fonte dell'esempio sopra può essere trovata qui .

Se vorremmo usare la comprensione delle liste annidate:

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)

Comprensioni di array multidimensionali

Annidati for i loop possono essere utilizzati per iterare su un certo numero di iterables unici.

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

Allo stesso modo, possono essere fornite specifiche di iterazione multiple a una comprensione dell'array.

[expression for a = iterable_a, b = iterable_b]

Ad esempio, per generare il prodotto cartesiano di 1:3 e 1:2 possibile utilizzare quanto segue.

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)

Le comprensioni multidimensionali di array appiattite sono simili, tranne per il fatto che perdono la forma. Per esempio,

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)

è una variante appiattita di quanto sopra. La differenza sintattica è che viene aggiunto un ulteriore for anziché una virgola.

Comprensioni del generatore

Le comprensioni dei generatori seguono un formato simile alle comprensioni degli array, ma usano parentesi () invece di parentesi quadre [] .

(expression for element = iterable)

Tale espressione restituisce un oggetto Generator .

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

Argomenti della funzione

Le comprensioni del generatore possono essere fornite come l'unico argomento di una funzione, senza la necessità di un set aggiuntivo di parentesi.

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

Tuttavia, se viene fornito più di un argomento, la comprensione del generatore richiede il proprio insieme di parentesi.

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"