Iteration utilities

Stateful(itr)

Il existe plusieurs façons de penser à cet enveloppeur d'itérateur :

1. Il fournit un enveloppeur mutable autour d'un itérateur et de son état d'itération.
2. Il transforme une abstraction semblable à un itérateur en une abstraction semblable à un Channel.
3. C'est un itérateur qui se muta pour devenir son propre itérateur de reste chaque fois qu'un élément est produit.

Stateful fournit l'interface d'itérateur régulière. Comme d'autres itérateurs mutables (par exemple, Base.Channel), si l'itération est arrêtée prématurément (par exemple, par un break dans une boucle for), l'itération peut être reprise au même endroit en continuant à itérer sur le même objet itérateur (en revanche, un itérateur immuable redémarrerait depuis le début).

Exemples

julia> a = Iterators.Stateful("abcdef");

julia> isempty(a)
false

julia> popfirst!(a)
'a': ASCII/Unicode U+0061 (catégorie Ll : Lettre, minuscule)

julia> collect(Iterators.take(a, 3))
3-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (catégorie Ll : Lettre, minuscule)
 'c': ASCII/Unicode U+0063 (catégorie Ll : Lettre, minuscule)
 'd': ASCII/Unicode U+0064 (catégorie Ll : Lettre, minuscule)

julia> collect(a)
2-element Vector{Char}:
 'e': ASCII/Unicode U+0065 (catégorie Ll : Lettre, minuscule)
 'f': ASCII/Unicode U+0066 (catégorie Ll : Lettre, minuscule)

julia> Iterators.reset!(a); popfirst!(a)
'a': ASCII/Unicode U+0061 (catégorie Ll : Lettre, minuscule)

julia> Iterators.reset!(a, "hello"); popfirst!(a)
'h': ASCII/Unicode U+0068 (catégorie Ll : Lettre, minuscule)

julia> a = Iterators.Stateful([1,1,1,2,3,4]);

julia> for x in a; x == 1 || break; end

julia> peek(a)
3

julia> sum(a) # Somme des éléments restants
7

zip(iters...)

Exécute plusieurs itérateurs en même temps, jusqu'à ce que l'un d'eux soit épuisé. Le type de valeur de l'itérateur zip est un tuple de valeurs de ses sous-itérateurs.

Voir aussi : enumerate, Base.splat.

Exemples

julia> a = 1:5
1:5

julia> b = ["e","d","b","c","a"]
5-element Vector{String}:
 "e"
 "d"
 "b"
 "c"
 "a"

julia> c = zip(a,b)
zip(1:5, ["e", "d", "b", "c", "a"])

julia> length(c)
5

julia> first(c)
(1, "e")

enumerate(iter)

Un itérateur qui produit (i, x) où i est un compteur commençant à 1, et x est la i-ème valeur de l'itérateur donné. C'est utile lorsque vous avez besoin non seulement des valeurs x sur lesquelles vous itérez, mais aussi du nombre d'itérations jusqu'à présent.

Notez que i peut ne pas être valide pour indexer iter, ou peut indexer un élément différent. Cela se produira si iter a des indices qui ne commencent pas à 1, et peut se produire pour des chaînes de caractères, des dictionnaires, etc. Consultez la méthode pairs(IndexLinear(), iter) si vous souhaitez vous assurer que i est un index.

Exemples

julia> a = ["a", "b", "c"];

julia> for (index, value) in enumerate(a)
           println("$index $value")
       end
1 a
2 b
3 c

julia> str = "naïve";

julia> for (i, val) in enumerate(str)
           print("i = ", i, ", val = ", val, ", ")
           try @show(str[i]) catch e println(e) end
       end
i = 1, val = n, str[i] = 'n'
i = 2, val = a, str[i] = 'a'
i = 3, val = ï, str[i] = 'ï'
i = 4, val = v, StringIndexError("naïve", 4)
i = 5, val = e, str[i] = 'v'

rest(iter, state)

Un itérateur qui produit les mêmes éléments que iter, mais en commençant à l'état donné.

Voir aussi : Iterators.drop, Iterators.peel, Base.rest.

Exemples

julia> collect(Iterators.rest([1,2,3,4], 2))
3-element Vector{Int64}:
 2
 3
 4

countfrom(start=1, step=1)

Un itérateur qui compte indéfiniment, en commençant à start et en incrémentant de step.

Exemples

julia> for v in Iterators.countfrom(5, 2)
           v > 10 && break
           println(v)
       end
5
7
9

take(iter, n)

Un itérateur qui génère au maximum les n premiers éléments de iter.

Voir aussi : drop, peel, first, Base.take!.

Exemples

julia> a = 1:2:11
1:2:11

julia> collect(a)
6-element Vector{Int64}:
  1
  3
  5
  7
  9
 11

julia> collect(Iterators.take(a,3))
3-element Vector{Int64}:
 1
 3
 5

takewhile(pred, iter)

Un itérateur qui génère des éléments de iter tant que le prédicat pred est vrai, ensuite, il ignore chaque élément.

Exemples

julia> s = collect(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> collect(Iterators.takewhile(<(3),s))
2-element Vector{Int64}:
 1
 2

drop(iter, n)

Un itérateur qui génère tous les éléments sauf les premiers n éléments de iter.

Exemples

julia> a = 1:2:11
1:2:11

julia> collect(a)
6-element Vector{Int64}:
  1
  3
  5
  7
  9
 11

julia> collect(Iterators.drop(a,4))
2-element Vector{Int64}:
  9
 11

dropwhile(pred, iter)

Un itérateur qui supprime les éléments de iter tant que le prédicat pred est vrai, puis retourne chaque élément.

Exemples

julia> s = collect(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> collect(Iterators.dropwhile(<(3),s))
3-element Vector{Int64}:
 3
 4
 5

cycle(iter[, n::Int])

Un itérateur qui parcourt iter indéfiniment. Si n est spécifié, alors il parcourt iter ce nombre de fois. Lorsque iter est vide, cycle(iter) et cycle(iter, n) le sont aussi.

Iterators.cycle(iter, n) est l'équivalent paresseux de Base.repeat(vector, n), tandis que Iterators.repeated(iter, n) est le Base.fill(item, n) paresseux.

Exemples

julia> for (i, v) in enumerate(Iterators.cycle("hello"))
           print(v)
           i > 10 && break
       end
hellohelloh

julia> foreach(print, Iterators.cycle(['j', 'u', 'l', 'i', 'a'], 3))
juliajuliajulia

julia> repeat([1,2,3], 4) == collect(Iterators.cycle([1,2,3], 4))
true

julia> fill([1,2,3], 4) == collect(Iterators.repeated([1,2,3], 4))
true

repeated(x[, n::Int])

Un itérateur qui génère la valeur x indéfiniment. Si n est spécifié, génère x ce nombre de fois (équivalent à take(repeated(x), n)).

Voir aussi fill, et comparer Iterators.cycle.

Exemples

julia> a = Iterators.repeated([1 2], 4);

julia> collect(a)
4-element Vector{Matrix{Int64}}:
 [1 2]
 [1 2]
 [1 2]
 [1 2]

julia> ans == fill([1 2], 4)
true

julia> Iterators.cycle([1 2], 4) |> collect |> println
[1, 2, 1, 2, 1, 2, 1, 2]

product(iters...)

Renvoie un itérateur sur le produit de plusieurs itérateurs. Chaque élément généré est un tuple dont l'élément i vient de l'itérateur d'argument i. Le premier itérateur change le plus rapidement.

Voir aussi : zip, Iterators.flatten.

Exemples

julia> collect(Iterators.product(1:2, 3:5))
2×3 Matrix{Tuple{Int64, Int64}}:
 (1, 3)  (1, 4)  (1, 5)
 (2, 3)  (2, 4)  (2, 5)

julia> ans == [(x,y) for x in 1:2, y in 3:5]  # collecte un générateur impliquant Iterators.product
true

flatten(iter)

Étant donné un itérateur qui produit des itérateurs, renvoie un itérateur qui produit les éléments de ces itérateurs. En d'autres termes, les éléments de l'itérateur d'argument sont concaténés.

Exemples

julia> collect(Iterators.flatten((1:2, 8:9)))
4-element Vector{Int64}:
 1
 2
 8
 9

julia> [(x,y) for x in 0:1 for y in 'a':'c']  # collecte des générateurs impliquant Iterators.flatten
6-element Vector{Tuple{Int64, Char}}:
 (0, 'a')
 (0, 'b')
 (0, 'c')
 (1, 'a')
 (1, 'b')
 (1, 'c')

Iterators.flatmap(f, iterators...)

Équivalent à flatten(map(f, iterators...)).

Voir aussi Iterators.flatten, Iterators.map.

Exemples

julia> Iterators.flatmap(n -> -n:2:n, 1:3) |> collect
9-element Vector{Int64}:
 -1
  1
 -2
  0
  2
 -3
 -1
  1
  3

julia> stack(n -> -n:2:n, 1:3)
ERROR: DimensionMismatch: stack expects uniform slices, got axes(x) == (1:3,) while first had (1:2,)
[...]

julia> Iterators.flatmap(n -> (-n, 10n), 1:2) |> collect
4-element Vector{Int64}:
 -1
 10
 -2
 20

julia> ans == vec(stack(n -> (-n, 10n), 1:2))
true

partition(collection, n)

Itérer sur une collection n éléments à la fois.

Exemples

julia> collect(Iterators.partition([1,2,3,4,5], 2))
3-element Vector{SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}}:
 [1, 2]
 [3, 4]
 [5]

Iterators.map(f, iterators...)

Créez un mappage paresseux. C'est une autre syntaxe pour écrire (f(args...) for args in zip(iterators...)).

Exemples

julia> collect(Iterators.map(x -> x^2, 1:3))
3-element Vector{Int64}:
 1
 4
 9

Iterators.filter(flt, itr)

Étant donné une fonction prédicat flt et un objet itérable itr, renvoie un objet itérable qui, lors de l'itération, produit les éléments x de itr qui satisfont flt(x). L'ordre de l'itérateur original est préservé.

Cette fonction est paresseuse ; c'est-à-dire qu'elle garantit de renvoyer en $Θ(1)$ temps et d'utiliser $Θ(1)$ espace supplémentaire, et flt ne sera pas appelé par une invocation de filter. Des appels à flt seront effectués lors de l'itération sur l'objet itérable retourné. Ces appels ne sont pas mis en cache et des appels répétés seront effectués lors de la réitération.

Voir Base.filter pour une implémentation avide du filtrage pour les tableaux.

Exemples

julia> f = Iterators.filter(isodd, [1, 2, 3, 4, 5])
Base.Iterators.Filter{typeof(isodd), Vector{Int64}}(isodd, [1, 2, 3, 4, 5])

julia> foreach(println, f)
1
3
5

julia> [x for x in [1, 2, 3, 4, 5] if isodd(x)]  # collecte un générateur sur Iterators.filter
3-element Vector{Int64}:
 1
 3
 5

Iterators.accumulate(f, itr; [init])

Étant donné une fonction à 2 arguments f et un itérateur itr, renvoie un nouvel itérateur qui applique successivement f à la valeur précédente et au prochain élément de itr.

C'est effectivement une version paresseuse de Base.accumulate.

Exemples

julia> a = Iterators.accumulate(+, [1,2,3,4]);

julia> foreach(println, a)
1
3
6
10

julia> b = Iterators.accumulate(/, (2, 5, 2, 5); init = 100);

julia> collect(b)
4-element Vector{Float64}:
 50.0
 10.0
  5.0
  1.0

Iterators.reverse(itr)

Étant donné un itérateur itr, alors reverse(itr) est un itérateur sur la même collection mais dans l'ordre inverse. Cet itérateur est "paresseux" en ce sens qu'il ne fait pas de copie de la collection pour l'inverser ; voir Base.reverse pour une implémentation avide.

(Par défaut, cela renvoie un objet Iterators.Reverse enveloppant itr, qui est itérable si les méthodes iterate correspondantes sont définies, mais certains types itr peuvent implémenter des comportements Iterators.reverse plus spécialisés.)

Tous les types d'itérateurs T ne prennent pas en charge l'itération dans l'ordre inverse. Si T ne le fait pas, alors itérer sur Iterators.reverse(itr::T) lancera une MethodError en raison des méthodes iterate manquantes pour Iterators.Reverse{T}. (Pour implémenter ces méthodes, l'itérateur original itr::T peut être obtenu à partir d'un objet r::Iterators.Reverse{T} par r.itr ; plus généralement, on peut utiliser Iterators.reverse(r).)

Exemples

julia> foreach(println, Iterators.reverse(1:5))
5
4
3
2
1

only(x)

Renvoie le seul et unique élément de la collection x, ou lève une ArgumentError si la collection contient zéro ou plusieurs éléments.

Voir aussi first, last.

Exemples

julia> only(["a"])
"a"

julia> only("a")
'a': ASCII/Unicode U+0061 (catégorie Ll: Lettre, minuscule)

julia> only(())
ERREUR : ArgumentError: Le tuple contient 0 éléments, doit contenir exactement 1 élément
Traceback :
[...]

julia> only(('a', 'b'))
ERREUR : ArgumentError: Le tuple contient 2 éléments, doit contenir exactement 1 élément
Traceback :
[...]

peel(iter)

Renvoie le premier élément et un itérateur sur les éléments restants.

Si l'itérateur est vide, renvoie nothing (comme iterate).

Voir aussi : Iterators.drop, Iterators.take.

Exemples

julia> (a, rest) = Iterators.peel("abc");

julia> a
'a': ASCII/Unicode U+0061 (catégorie Ll : Lettre, minuscule)

julia> collect(rest)
2-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (catégorie Ll : Lettre, minuscule)
 'c': ASCII/Unicode U+0063 (catégorie Ll : Lettre, minuscule)