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

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)

Итератор, генерирующий все элементы, кроме первых 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

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[, 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> 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

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]

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

Принимая функцию с 2 аргументами 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)