Iteration utilities

Stateful(itr)

Es gibt mehrere verschiedene Möglichkeiten, über diesen Iterator-Wrap zu denken:

1. Es bietet einen veränderbaren Wrapper um einen Iterator und seinen Iterationszustand.
2. Es verwandelt eine iteratorähnliche Abstraktion in eine Channel-ähnliche Abstraktion.
3. Es ist ein Iterator, der sich verändert, um sein eigener Rest-Iterator zu werden, wann immer ein Element produziert wird.

Stateful bietet die reguläre Iterator-Schnittstelle. Wie andere veränderbare Iteratoren (z.B. Base.Channel), kann die Iteration, wenn sie vorzeitig gestoppt wird (z.B. durch ein break in einer for Schleife), von derselben Stelle aus fortgesetzt werden, indem man weiterhin über dasselbe Iterator-Objekt iteriert (im Gegensatz dazu würde ein unveränderlicher Iterator von Anfang an neu starten).

Beispiele

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

julia> isempty(a)
false

julia> popfirst!(a)
'a': ASCII/Unicode U+0061 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

julia> collect(Iterators.take(a, 3))
3-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (Kategorie Ll: Buchstabe, Kleinbuchstabe)
 'c': ASCII/Unicode U+0063 (Kategorie Ll: Buchstabe, Kleinbuchstabe)
 'd': ASCII/Unicode U+0064 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

julia> collect(a)
2-element Vector{Char}:
 'e': ASCII/Unicode U+0065 (Kategorie Ll: Buchstabe, Kleinbuchstabe)
 'f': ASCII/Unicode U+0066 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

julia> Iterators.reset!(a); popfirst!(a)
'a': ASCII/Unicode U+0061 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

julia> Iterators.reset!(a, "hello"); popfirst!(a)
'h': ASCII/Unicode U+0068 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

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) # Summe der verbleibenden Elemente
7

zip(iters...)

Führen Sie mehrere Iteratoren gleichzeitig aus, bis einer von ihnen erschöpft ist. Der Werttyp des zip-Iterators ist ein Tupel von Werten seiner Unteriteratoren.

Siehe auch: enumerate, Base.splat.

Beispiele

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)

Ein Iterator, der (i, x) zurückgibt, wobei i ein Zähler ist, der bei 1 beginnt, und x der ite Wert aus dem gegebenen Iterator ist. Es ist nützlich, wenn Sie nicht nur die Werte x, über die Sie iterieren, sondern auch die Anzahl der bisherigen Iterationen benötigen.

Beachten Sie, dass i möglicherweise nicht gültig für die Indizierung von iter ist oder ein anderes Element indiziert. Dies geschieht, wenn iter Indizes hat, die nicht bei 1 beginnen, und kann bei Strings, Dictionaries usw. auftreten. Siehe die Methode pairs(IndexLinear(), iter), wenn Sie sicherstellen möchten, dass i ein Index ist.

Beispiele

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)

Ein Iterator, der dieselben Elemente wie iter liefert, aber ab dem angegebenen state beginnt.

Siehe auch: Iterators.drop, Iterators.peel, Base.rest.

Beispiele

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

countfrom(start=1, step=1)

Ein Iterator, der unendlich zählt, beginnend bei start und um step erhöht.

Beispiele

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

take(iter, n)

Ein Iterator, der höchstens die ersten n Elemente von iter erzeugt.

Siehe auch: drop, peel, first, Base.take!.

Beispiele

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)

Ein Iterator, der Elemente aus iter generiert, solange die Bedingung pred wahr ist, danach werden alle Elemente verworfen.

Beispiele

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)

Ein Iterator, der alle Elemente von iter außer den ersten n Elementen erzeugt.

Beispiele

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)

Ein Iterator, der Elemente aus iter entfernt, solange das Prädikat pred wahr ist, und danach jedes Element zurückgibt.

Beispiele

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])

Ein Iterator, der durch iter für immer zirkuliert. Wenn n angegeben ist, zirkuliert er durch iter so oft. Wenn iter leer ist, sind auch cycle(iter) und cycle(iter, n) leer.

Iterators.cycle(iter, n) ist das faule Äquivalent von Base.repeat(vector, n), während Iterators.repeated(iter, n) das faule Base.fill(item, n) ist.

Beispiele

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])

Ein Iterator, der den Wert x für immer erzeugt. Wenn n angegeben ist, erzeugt er x so oft (entspricht take(repeated(x), n)).

Siehe auch fill und vergleiche Iterators.cycle.

Beispiele

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...)

Gibt einen Iterator über das Produkt mehrerer Iteratoren zurück. Jedes erzeugte Element ist ein Tupel, dessen i-tes Element aus dem i-ten Argument-Iterator stammt. Der erste Iterator ändert sich am schnellsten.

Siehe auch: zip, Iterators.flatten.

Beispiele

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]  # sammelt einen Generator, der Iterators.product verwendet
true

flatten(iter)

Gegeben einen Iterator, der Iteratoren erzeugt, gibt einen Iterator zurück, der die Elemente dieser Iteratoren erzeugt. Anders ausgedrückt, die Elemente des Argument-Iterators werden zusammengefügt.

Beispiele

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']  # sammelt Generatoren, die Iterators.flatten verwenden
6-element Vector{Tuple{Int64, Char}}:
 (0, 'a')
 (0, 'b')
 (0, 'c')
 (1, 'a')
 (1, 'b')
 (1, 'c')

Iterators.flatmap(f, iterators...)

Entspricht flatten(map(f, iterators...)).

Siehe auch Iterators.flatten, Iterators.map.

Beispiele

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 erwartet einheitliche Schnitte, erhielt axes(x) == (1:3,) während der erste (1:2,) hatte
[...]

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)

Iteriere über eine Sammlung n Elemente auf einmal.

Beispiele

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...)

Erstellen Sie eine faule Zuordnung. Dies ist eine andere Syntax, um (f(args...) for args in zip(iterators...)) zu schreiben.

Beispiele

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

Iterators.filter(flt, itr)

Gegeben einer Prädikatsfunktion flt und einem iterierbaren Objekt itr, gibt diese Funktion ein iterierbares Objekt zurück, das bei der Iteration die Elemente x von itr liefert, die flt(x) erfüllen. Die Reihenfolge des ursprünglichen Iterators bleibt erhalten.

Diese Funktion ist lazy; das heißt, es ist garantiert, dass sie in $Θ(1)$ Zeit zurückgibt und $Θ(1)$ zusätzlichen Speicher verwendet, und flt wird nicht durch einen Aufruf von filter aufgerufen. Aufrufe an flt werden gemacht, wenn über das zurückgegebene iterierbare Objekt iteriert wird. Diese Aufrufe werden nicht zwischengespeichert und wiederholte Aufrufe werden gemacht, wenn erneut iteriert wird.

Siehe Base.filter für eine eager Implementierung des Filterns für Arrays.

Beispiele

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)]  # sammelt einen Generator über Iterators.filter
3-element Vector{Int64}:
 1
 3
 5

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

Gegeben eine 2-Argumente-Funktion f und einen Iterator itr, gibt einen neuen Iterator zurück, der f successiv auf den vorherigen Wert und das nächste Element von itr anwendet.

Dies ist effektiv eine faule Version von Base.accumulate.

Beispiele

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)

Gegeben ist ein Iterator itr, dann ist reverse(itr) ein Iterator über dieselbe Sammlung, jedoch in umgekehrter Reihenfolge. Dieser Iterator ist "lazy", da er keine Kopie der Sammlung erstellt, um sie umzukehren; siehe Base.reverse für eine eager Implementierung.

(Im Standardfall gibt dies ein Iterators.Reverse-Objekt zurück, das itr umschließt, welches iterierbar ist, wenn die entsprechenden iterate Methoden definiert sind, aber einige itr-Typen können spezialisiertere Iterators.reverse-Verhaltensweisen implementieren.)

Nicht alle Iterator-Typen T unterstützen die Iteration in umgekehrter Reihenfolge. Wenn T dies nicht tut, wird das Iterieren über Iterators.reverse(itr::T) einen MethodError auslösen, da die fehlenden iterate-Methoden für Iterators.Reverse{T} nicht vorhanden sind. (Um diese Methoden zu implementieren, kann der ursprüngliche Iterator itr::T von einem r::Iterators.Reverse{T}-Objekt durch r.itr abgerufen werden; allgemeiner kann man Iterators.reverse(r) verwenden.)

Beispiele

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

only(x)

Gibt das einzige Element der Sammlung x zurück oder wirft einen ArgumentError, wenn die Sammlung null oder mehrere Elemente hat.

Siehe auch first, last.

Beispiele

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

julia> only("a")
'a': ASCII/Unicode U+0061 (Kategorie Ll: Kleinbuchstabe)

julia> only(())
ERROR: ArgumentError: Tuple enthält 0 Elemente, muss genau 1 Element enthalten
Stacktrace:
[...]

julia> only(('a', 'b'))
ERROR: ArgumentError: Tuple enthält 2 Elemente, muss genau 1 Element enthalten
Stacktrace:
[...]

peel(iter)

Gibt das erste Element und einen Iterator über die verbleibenden Elemente zurück.

Wenn der Iterator leer ist, wird nothing zurückgegeben (wie bei iterate).

Siehe auch: Iterators.drop, Iterators.take.

Beispiele

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

julia> a
'a': ASCII/Unicode U+0061 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

julia> collect(rest)
2-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (Kategorie Ll: Buchstabe, Kleinbuchstabe)
 'c': ASCII/Unicode U+0063 (Kategorie Ll: Buchstabe, Kleinbuchstabe)