Инструменты итерации

Base.Iterators.StatefulТип

Stateful(itr)

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

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

Stateful предоставляет обычный интерфейс итератора. Как и другие изменяемые итераторы (например, 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 Array{Char,1}:
 'b'
 'c'
 'd'

julia> collect(a)
2-element Array{Char,1}:
 'e'
 'f'

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

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

julia> Base.peek(a)
3

julia> sum(a) # Sum the remaining elements
7

Base.Iterators.zipФункция

zip(iters...)

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

Примечание: zip упорядочивает вызовы под-итераторов таким образом, что изменяемые итераторы не будут продвигаться, когда другой итератор завершается в текущей итерации.

Примеры

julia> a = 1:5
1:5

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

julia> c = zip(a,b)
Base.Iterators.Zip{Tuple{UnitRange{Int64},Array{String,1}}}((1:5, ["e", "d", "b", "c", "a"]))

julia> length(c)
5

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

Base.Iterators.enumerateФункция

enumerate(iter)

Итератор, который возвращает (i, x), где i — счётчик, начинающийся с 1, а x — i-ый элемент из заданного итератора. Это полезно, когда вам нужны не только значения x над которыми вы итерируете, но и номер текущей итерации. Обратите внимание, что i может быть недействительным для индексации iter, а также возможно, что x != iter[i], если у 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

Base.Iterators.restФункция

rest(iter, state)

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

Примеры

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

Base.Iterators.countfromФункция

countfrom(start=1, step=1)

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

Примеры

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

Base.Iterators.takeФункция

take(iter, n)

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

Примеры

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

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

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

Base.Iterators.dropФункция

drop(iter, n)

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

Примеры

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

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

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

Base.Iterators.cycleФункция

cycle(iter)

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

Примеры

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

Base.Iterators.repeatedФункция

repeated(x[, n::Int])

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

Примеры

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

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

Base.Iterators.productФункция

product(iters...)

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

Примеры

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

Base.Iterators.flattenФункция

flatten(iter)

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

Примеры

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

Base.Iterators.partitionФункция

partition(collection, n)

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

Примеры

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

Base.Iterators.filterФункция

Iterators.filter(flt, itr)

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

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

См. Base.filter для жадного (eager) варианта фильтрации массивов.

Примеры

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

julia> foreach(println, f)
1
3
5

Base.Iterators.reverseФункция

Iterators.reverse(itr)

Принимая итератор itr, reverse(itr) — итератор над той же коллекцией, но в обратном порядке.

Этот итератор «ленивый» в том смысле, что он не создаёт копию коллекции для её переворота; см. Base.reverse для жадной (eager) реализации.

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

Примеры

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