Итерационные утилиты

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

zip(iters...)

Для набора итерируемых объектов возвращает итерируемый набор кортежей, где i-й кортеж содержит i-й компонент каждого входного итерируемого объекта.

Обратите внимание, что zip является собственным обратным элементом: collect(zip(zip(a...)...)) == collect(a).

Пример

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.Zip2{UnitRange{Int64},Array{String,1}}(1:5, String["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. См. метод enumerate(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

enumerate(IndexLinear(), A)
enumerate(IndexCartesian(), A)
enumerate(IndexStyle(A), A)

Итератор, который обращается к каждому элементу массива A, возвращая (i, x), где i — индекс элемента, а x = A[i]. Это похоже на enumerate(A), за исключением того, что i всегда будет допустимым индексом для A.

Указание IndexLinear() гарантирует, что i будет целым числом; указание IndexCartesian() гарантирует, что i будет CartesianIndex; указание IndexStyle(A) выбирает тот стиль индексации, который был определен как основной для массива A.

Примеры

julia> A = ["a" "d"; "b" "e"; "c" "f"];

julia> for (index, value) in enumerate(IndexStyle(A), A)
           println("$index $value")
       end
1 a
2 b
3 c
4 d
5 e
6 f

julia> S = view(A, 1:2, :);

julia> for (index, value) in enumerate(IndexStyle(S), S)
           println("$index $value")
       end
CartesianIndex{2}((1, 1)) a
CartesianIndex{2}((2, 1)) b
CartesianIndex{2}((1, 2)) d
CartesianIndex{2}((2, 2)) e

Обратите внимание, что enumerate(A) возвращает i как счётчик (всегда начинающийся с 1), тогда как enumerate(IndexLinear(), A) возвращает i как индекс (начиная с первого линейного индекса A, который может или не может быть 1).

См. также: IndexStyle, indices.

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

rest(iter, state)

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

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

countfrom(start=1, step=1)

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

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 бесконечно.

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]