Средства итерации

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 для жадного (eager) варианта фильтрации для массивов.

Примеры

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 для жадного (eager) варианта.

(По умолчанию возвращает объект 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)