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

# Base.Iterators.Stateful — Type

Stateful(itr)

Эту оболочку итератора можно рассматривать несколькими разными способами.

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

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) # Суммировать оставшиеся элементы
7

# Base.Iterators.zip — Function

zip(iters...)

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

Функция zip упорядочивает вызовы вложенных итераторов таким образом, что итераторы с сохранением состояния не будут продолжать работу, когда другой итератор заканчивает работу в текущей итерации.

Функция 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")

# Base.Iterators.enumerate — Function

enumerate(iter)

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

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

Примеры

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'

# Base.Iterators.rest — Function

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

# Base.Iterators.countfrom — Function

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 — Function

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

# Base.Iterators.takewhile — Function

takewhile(pred, iter)

Итератор, создающий элемент из iter, пока предикат pred имеет значение true, а после этого отбрасывающий каждый элемент.

Совместимость: Julia 1.4

Для этой функции требуется версия Julia не ниже 1.4.

Примеры

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

# Base.Iterators.drop — Function

drop(iter, n)

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

Примеры

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

# Base.Iterators.dropwhile — Function

dropwhile(pred, iter)

Итератор, отбрасывающий элемент из iter, пока предикат pred имеет значение true, а после этого возвращающий каждый элемент.

Совместимость: Julia 1.4

Для этой функции требуется версия Julia не ниже 1.4.

Примеры

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

# Base.Iterators.cycle — Function

cycle(iter[, n::Int])

Итератор, выполняющий вечный цикл по iter. Если n задано, то цикл по iter повторяется указанное количество раз. Если объект iter пустой, пустыми будут и cycle(iter), и cycle(iter, n).

Iterators.cycle(iter, n) — это отложенный эквивалент Base.repeat(vector, n), в то время как Iterators.repeated(iter, n) — отложенный эквивалент Base.fill(item, n).

Совместимость: Julia 1.11

Метод cycle(iter, n) был добавлен в Julia 1.11.

Примеры

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

# Base.Iterators.repeated — Function

repeated(x[, n::Int])

Итератор, постоянно создающий значение x. Если n указано, создает x указанное число раз (эквивалент take(repeated(x), n)).

См. также описание fill и сравните с Iterators.cycle.

Примеры

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]

# Base.Iterators.product — Function

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]  # собирает генератор, включающий Iterators.product
true

# Base.Iterators.flatten — Function

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']  # собирает генераторы, включающие Iterators.flatten
6-element Vector{Tuple{Int64, Char}}:
 (0, 'a')
 (0, 'b')
 (0, 'c')
 (1, 'a')
 (1, 'b')
 (1, 'c')

# Base.Iterators.flatmap — Function

Iterators.flatmap(f, iterators...)

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

См. также описание Iterators.flatten и Iterators.map.

Совместимость: Julia 1.9

Эта функция была добавлена в Julia 1.9.

Примеры

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

# Base.Iterators.partition — Function

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]

# Base.Iterators.map — Function

Iterators.map(f, iterators...)

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

Совместимость: Julia 1.6

Для этой функции требуется версия Julia не ниже 1.6.

Примеры

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

# Base.Iterators.filter — Function

Iterators.filter(flt, itr)

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

Эта функция является отложенной, то есть гарантируется, что она будет возвращена за время , будет использовать дополнительное пространство , а flt не будет вызываться вызовом filter. Будут выполнены вызовы flt при итерации возвращенного итерируемого объекта. Эти вызовы не кэшируются, и будут выполнены повторные вызовы при повторной итерации.

Последующие отложенные преобразования итератора, возвращаемого из filter, такие как выполняемые посредством Iterators.reverse или cycle, также будут откладывать вызовы flt до тех пор, пока не будут выполнен сбор или итерация по возвращаемому итерируемому объекту. Если предикат фильтра недетерминированный или его возвращаемые значения зависят от порядка итерации по элементам itr, композиция с отложенными преобразованиями может привести к неожиданному поведению. Если это нежелательно, убедитесь в том, что flt является чистой функцией, или соберите промежуточные итераторы filter перед дальнейшими преобразованиями.

См. 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)]  # собирает генератор для Iterators.filter
3-element Vector{Int64}:
 1
 3
 5

# Base.Iterators.accumulate — Function

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

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

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

Совместимость: Julia 1.5

Именованный аргумент init был добавлен в Julia 1.5.

Примеры

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

# Base.Iterators.reverse — Function

Iterators.reverse(itr)

Если задан итератор itr, то reverse(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

# Base.Iterators.only — Function

only(x)

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

См. также описание first и last.

Совместимость: Julia 1.4

Для этого метода требуется версия Julia не ниже 1.4.

Примеры

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:
[...]

# Base.Iterators.peel — Function

peel(iter)

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

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

Совместимость: Julia 1.7

Если итератор пуст, в предыдущих версиях выдается ошибка BoundsError.

См. также описание 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)