Утилиты итерации

Stateful(itr)

Существует несколько способов рассматривать этот обёртку итератора:

1. Он предоставляет изменяемую обёртку вокруг итератора и его состояния итерации.
2. Он преобразует абстракцию типа «итератор» в абстракцию типа «Channel».
3. Это итератор, который изменяется, чтобы стать собственным итератором остатка, каждый раз, когда генерируется элемент.

Stateful предоставляет стандартный интерфейс итератора. Как и другие изменяемые итераторы (например, Base.Channel), если итерация прервана преждевременно (например, с помощью break в цикле for), итерацию можно продолжить с того же места, продолжив итерацию над тем же объектом итератора (в отличие от неизменяемого итератора, который возобновлялся бы с начала).

Примеры

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

julia> isempty(a)
false

julia> popfirst!(a)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

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

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

julia> Iterators.reset!(a); popfirst!(a)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

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

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) # Sum the remaining elements
7

zip(iters...)

Запускает несколько итераторов одновременно, пока какой-либо из них не исчерпается. Тип значений итератора zip представляет собой кортеж значений его под-итераторов.

См. также: enumerate, Base.splat.

Примеры

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)

Итератор, который возвращает (i, x), где i — счётчик, начинающийся с 1, а x — i-е значение из заданного итератора. Это полезно, когда вам нужны не только значения x над которыми вы итерируетесь, но и номер текущей итерации.

Обратите внимание, что i может быть недействительным для индексации iter, или может индексировать другой элемент. Это произойдёт, если iter имеет индексы, которые не начинаются с 1, и может произойти для строк, словарей и т. д. См. метод pairs(IndexLinear(), iter), если вы хотите гарантировать, что i является индексом.

Примеры

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)

Итератор, который возвращает те же элементы, что и iter, но начиная с заданного state.

См. также: Iterators.drop, Iterators.peel, Base.rest.

Примеры

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

countfrom(start=1, step=1)

Итератор, который считает бесконечно, начиная с start и увеличивая на step.

Примеры

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

take(iter, n)

Итератор, генерирующий не более первых n элементов iter.

См. также: drop, peel, first, Base.take!.

Примеры

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)

Итератор, генерирующий элементы из iter до тех пор, пока предикат pred истинен, после чего пропускает все оставшиеся элементы.

Примеры

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)

Итератор, генерирующий все элементы iter кроме первых n.

Примеры

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)

Итератор, пропускающий элементы из iter до тех пор, пока предикат pred истинен, после чего возвращает все оставшиеся элементы.

Примеры

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)

Итератор, который бесконечно циклически перебирает iter. Если iter пусто, то и cycle(iter) будет пусто.

См. также: Iterators.repeated, Base.repeat.

Примеры

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

repeated(x[, n::Int])

Итератор, который бесконечно генерирует значение x. Если указан n, генерирует x раз (эквивалентно take(repeated(x), n)).

См. также: Iterators.cycle, Base.repeat.

Примеры

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

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

product(iters...)

Возвращает итератор над произведением нескольких итераторов. Каждый сгенерированный элемент — кортеж, i-й элемент которого взят из i-го аргументного итератора. Первый итератор меняется быстрее всего.

См. также: zip, Iterators.flatten.

Примеры

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]  # collects a generator involving Iterators.product
true

flatten(iter)

Принимая итератор, который возвращает итераторы, возвращает итератор, который возвращает элементы этих итераторов. Другими словами, элементы аргументного итератора конкатенируются.

Примеры

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

Iterators.flatmap(f, iterators...)

Эквивалентно flatten(map(f, iterators...)).

См. также Iterators.flatten, Iterators.map.

Примеры

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)

Итерироваться по коллекции по n элементов за раз.

Примеры

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

Создаёт ленивое отображение. Это другой синтаксис для записи (f(args...) for args in zip(iterators...)).

Примеры

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

Iterators.filter(flt, itr)

Принимая функцию-предикат flt и итерируемый объект itr, возвращает итерируемый объект, который при итерации возвращает элементы x из itr, удовлетворяющие условию flt(x). Порядок элементов из исходного итератора сохраняется.

Функция является ленивой; то есть, гарантируется, что она вернёт результат за время $Θ(1)$ и использует $Θ(1)$ дополнительной памяти, и flt не будет вызвана при вызове filter. Вызовы flt будут выполняться при итерации по возвращённому итерируемому объекту. Эти вызовы не кешируются, и при повторной итерации будут выполняться заново.

См. Base.filter для жадной реализации фильтрации для массивов.

Примеры

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)]  # collects a generator over Iterators.filter
3-element Vector{Int64}:
 1
 3
 5

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

Принимая функцию от двух аргументов f и итератор itr, возвращает новый итератор, который последовательно применяет f к предыдущему значению и следующему элементу из itr.

Это эффективно ленивая версия Base.accumulate.

Примеры

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)

Принимая итератор itr, возвращает итератор над той же коллекцией, но в обратном порядке. Этот итератор "ленивый", так как он не создаёт копию коллекции для её переворота; см. Base.reverse для жадной реализации.

(По умолчанию это возвращает объект Iterators.Reverse обернувший itr, который является итерируемым, если определены соответствующие методы iterate, но некоторые типы itr могут реализовывать более специализированное поведение Iterators.reverse.)

Не все типы итераторов T поддерживают итерацию в обратном порядке. Если T не поддерживает, то итерация по Iterators.reverse(itr::T) выбросит исключение MethodError из-за отсутствия методов iterate для Iterators.Reverse{T}. (Для реализации этих методов исходный итератор itr::T можно получить из объекта r::Iterators.Reverse{T} с помощью r.itr; в более общем случае, можно использовать Iterators.reverse(r).)

Примеры

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

only(x)

Возвращает единственный элемент коллекции x, или выбросит исключение ArgumentError, если коллекция содержит ноль или несколько элементов.

См. также first, last.

Примеры

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

julia> only("a")
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> only(())
ERROR: ArgumentError: Tuple contains 0 elements, must contain exactly 1 element
Stacktrace:
[...]

julia> only(('a', 'b'))
ERROR: ArgumentError: Tuple contains 2 elements, must contain exactly 1 element
Stacktrace:
[...]

peel(iter)

Возвращает первый элемент и итератор по оставшимся элементам.

Если итератор пуст, возвращает nothing (как и iterate).

См. также: Iterators.drop, Iterators.take.

Примеры

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

julia> a
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

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