Toute personne ayant utilisé Python a presque certainement utilisé des compréhensions de listes, qui sont au cœur de la syntaxe de Python depuis les premières versions.
Une fonctionnalité aussi pratique finit peu à peu par se frayer un chemin dans d'autres langages, dont Julia.
Pour les programmeurs Julia, les compréhensions sont une option plutôt qu'une nécessité, car il existe généralement des alternatives (broadcasting, fonctions d'ordre supérieur, etc.).
Cependant, une compréhension offre souvent un moyen simple, lisible et performant de construire un tableau. Son usage relève en fin de compte du goût personnel, et de ton rapport à Python par opposition aux langages fonctionnels.
La syntaxe est pour l'essentiel une copie directe de celle de Python, mais avec des extensions pour les tableaux de dimension supérieure.
Une seule variable
Très pythonique, y compris la clause if optionnelle.
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 forme de la sortie dépend des détails de la compréhension : elle est généralement identique à celle de la collection d'entrée dans les cas simples, mais aplatie en un Vector par une clause if.
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
Plusieurs variables, sortie en Vector
Comme en Python, on peut avoir plusieurs clauses for avec des variables différentes, sur des collections d'entrée identiques ou différentes.
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
Cela équivaut à des boucles imbriquées. La sortie est unidimensionnelle, même avec une matrice en entrée.
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...)
Plusieurs variables, sortie multidimensionnelle
La section précédente décrivait plusieurs clauses for séparées uniquement par des espaces.
Dans cette section, il n'y a qu'un seul for et les variables sont séparées par des virgules.
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)
Chaque variable de la compréhension crée une nouvelle dimension dans la sortie, avec un élément pour chaque combinaison possible des variables.
Dans l'exemple ci-dessus, x augmente en descendant le long des lignes, y augmente en parcourant les colonnes. Des dimensions supérieures sont possibles, avec les avertissements habituels sur la lisibilité de la sortie.
Expressions génératrices
Les sections précédentes se sont concentrées sur la sortie sous forme de tableau, avec la compréhension placée entre crochets [ ... ].
Quand on remplace les crochets par des parenthèses ( ... ), il se passe quelque chose de différent : on obtient une generator expression, c'est-à-dire un itérateur évalué paresseusement qui peut produire la valeur suivante à la demande.
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
Quand le résultat d'une compréhension est immédiatement utilisé pour un traitement ultérieur, un générateur peut être économe en mémoire, ce qui évite de stocker un grand tableau intermédiaire.
Un générateur utilisé comme argument de fonction n'a pas besoin de parenthèses supplémentaires.
# 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 syntaxe d'un générateur est identique à celle d'une compréhension, à l'exception des crochets qui l'entourent.
Les générateurs peuvent aussi être pratiques dans les constructeurs de dictionnaires.
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
Exercice d'apprentissage
