Julia Language
Compréhensions

Compréhension de tableau

Syntaxe de base

Les tableaux de Julia utilisent la syntaxe suivante:

[expression for element = iterable]

Notez que, comme for boucles , tous les éléments = , in et ∈ sont acceptés pour la compréhension.

Cela équivaut à peu près à créer un tableau vide et à utiliser une boucle for pour push! articles à elle.

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

Cependant, le type de compréhension du tableau est aussi étroit que possible, ce qui est préférable pour les performances.

Par exemple, pour obtenir un tableau des carrés des entiers compris entre 1 et 10 , le code suivant peut être utilisé.

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

Ceci est un remplacement clair et concis pour la version longue for -loop.

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

Compréhension des tableaux conditionnels

Avant le Julia 0.5, il n'y a aucun moyen d'utiliser les conditions dans les compréhensions du tableau. Mais ce n'est plus vrai. Dans Julia 0.5, nous pouvons utiliser les conditions dans des conditions telles que les suivantes:

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

La source de l'exemple ci-dessus peut être trouvée ici .

Si nous aimerions utiliser la compréhension des listes imbriquées:

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)

Compréhensions multidimensionnelles

Emboîtés for les boucles peuvent être utilisées pour itérer sur un certain nombre de iterables uniques.

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

De même, plusieurs spécifications d'itération peuvent être fournies à une compréhension de tableau.

[expression for a = iterable_a, b = iterable_b]

Par exemple, les éléments suivants peuvent être utilisés pour générer le produit cartésien de 1:3 et 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)

La compréhension des tableaux multidimensionnels aplatis est similaire, sauf qu'ils perdent leur forme. Par exemple,

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)

est une variante aplatie de ce qui précède. La différence syntaxique est qu’un supplément for est utilisé à la place d’une virgule.

Compréhension de générateur

Les compréhensions des générateurs suivent un format similaire à celui des compréhensions de tableaux, mais utilisent des parenthèses () au lieu de crochets [] .

(expression for element = iterable)

Une telle expression renvoie un objet Generator .

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

Arguments de fonction

Les compréhensions génératrices peuvent être fournies comme le seul argument d'une fonction, sans avoir besoin d'un ensemble supplémentaire de parenthèses.

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

Cependant, si plusieurs arguments sont fournis, la compréhension du générateur nécessite son propre ensemble de parenthèses.

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"