Iteration utilities
Base.Iterators.Stateful — Type
Stateful(itr)このイテレーターラッパーについては、いくつかの異なる捉え方があります。
- イテレーターとその反復状態を、可変なラッパーで包むもの。
- イテレーターのような抽象を、
Channelのような抽象に変換するもの。 - 要素を生成するたびに自身を残りのイテレーターへと変化させるイテレーター。
Statefulは、標準的なイテレーターインターフェースを提供します。他の可変イテレーター(例:Base.Channel)と同様に、反復を途中で停止した場合(たとえば、forループ内でbreakを使った場合)、同じイテレーターオブジェクトで反復を続ければ、停止した位置から再開できます(不変イテレーターの場合は、先頭から再開します)。
Examples
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
7Base.Iterators.zip — Function
zip(iters...)複数のイテレータを同時に実行し、いずれかが終了するまで続けます。zip の値の型は、そのサブイテレータの値を要素とするタプルです。
関連項目: enumerate、Base.splat。
Examples
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)メソッドを参照してください。
Examples
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から開始します。この状態は、iterate(iter[, state])を1回以上呼び出すことで到達できる状態でなければなりません。
関連項目: Iterators.drop、Iterators.peel、Base.rest。
Examples
julia> iter = [1,2,3,4];
julia> val, state = iterate(iter)
(1, 2)
julia> collect(Iterators.rest(iter, state))
3-element Vector{Int64}:
2
3
4Base.Iterators.countfrom — Function
countfrom(start=1, step=1)startから始まり、stepずつ増加しながら無限に数え続けるイテレータ。
Examples
julia> for v in Iterators.countfrom(5, 2)
v > 10 && break
println(v)
end
5
7
9Base.Iterators.take — Function
take(iter, n)iter の要素を先頭から最大 n 個生成するイテレータ。
関連項目: drop, peel, first, Base.take!.
Examples
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
5Base.Iterators.takewhile — Function
takewhile(pred, iter)述語 pred が真である間、iter から要素を生成し、その後はすべての要素を破棄するイテレーターです。
Examples
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
2Base.Iterators.drop — Function
drop(iter, n)n の最初の要素を除いたすべての要素を生成するイテレータです。iter
Examples
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
11Base.Iterators.dropwhile — Function
dropwhile(pred, iter)述語 pred が真である間、iter から要素を取り除き、その後はすべての要素を返すイテレータです。
Examples
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
5Base.Iterators.findeach — Function
findeach(f, it)
findeach(it)pairs(it) のキーと値のペアから、f(value) が true を返す場合に、すべてのキーを生成するイテレーターです。
f が指定されていない場合、デフォルトは identity です。
Iterators.findeach は、findall に相当する遅延評価版です。
Examples
julia> collect(Iterators.findeach(isodd, Dict(2 => 3, 3 => 2)))
1-element Vector{Int64}:
2
julia> only(Iterators.findeach(==(1), [3,6,2,1]))
4Base.Iterators.nth — Function
nth(n::Integer)渡された任意のイテレータから、n 番目の要素を取得する関数を返します。Base.Fix2(nth, n) または itr -> nth(itr, n) と同等です。
Examples
julia> fifth_element = Iterators.nth(5)
(::Base.Fix2{typeof(Base.Iterators.nth), Int64}) (generic function with 2 methods)
julia> fifth_element(reshape(1:30, (5,6)))
5
julia> map(fifth_element, ("Willis", "Jovovich", "Oldman"))
('i', 'v', 'a')nth(itr, n::Integer)反復可能なコレクションのn番目の要素を取得します。要素が存在しない場合は、BoundsError[@ref]をスローします。Stateful[@ref]イテレーターは進みます。
Examples
julia> Iterators.nth(2:2:10, 4)
8
julia> Iterators.nth(reshape(1:30, (5,6)), 6)
6
julia> stateful = Iterators.Stateful(1:10); Iterators.nth(stateful, 7)
7
julia> first(stateful)
8Base.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)の遅延評価版です。
Examples
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))
trueBase.Iterators.repeated — Function
repeated(x[, n::Int])値 x を無限に生成するイテレーターです。n を指定すると、その回数だけ x を生成します(take(repeated(x), n) と同等です)。
fill も参照してください。また、Iterators.cycle と比較してください。
Examples
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。
Examples
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
trueBase.Iterators.flatten — Function
flatten(iter)イテレータを生成するイテレータを受け取り、それらのイテレータの要素を生成するイテレータを返します。言い換えると、引数のイテレータが生成する要素を連結します。
Examples
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')Base.Iterators.flatmap — Function
Iterators.flatmap(f, iterators...)flatten(map(f, iterators...))と同等です。
関連項目:Iterators.flatten、Iterators.map。
Examples
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))
trueBase.Iterators.partition — Function
partition(collection, n)コレクションを、1回につきn個の要素ずつ反復処理します。
Examples
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...)) を記述する別の構文です。
Examples
julia> collect(Iterators.map(x -> x^2, 1:3))
3-element Vector{Int64}:
1
4
9Base.Iterators.filter — Function
Iterators.filter(flt, itr)述語関数 flt と反復可能オブジェクト itr を受け取り、反復時に itr の要素 x のうち、flt(x) を満たすものを返す反復可能オブジェクトを返します。元のイテレーターの順序は保持されます。
この関数は 遅延評価 されます。つまり、$Θ(1)$ 時間で返り、追加で使用する領域は $Θ(1)$ であることが保証されます。また、filter の呼び出し時に flt が呼び出されることはありません。flt は、返された反復可能オブジェクトを反復するときに呼び出されます。これらの呼び出しはキャッシュされないため、再度反復すると再び呼び出されます。
filter が返すイテレーターに対して、Iterators.reverse や cycle が行うような 遅延評価 の変換を続けて適用した場合も、返された反復可能オブジェクトを収集または反復するまで、flt の呼び出しは遅延されます。フィルター述語が非決定的である場合や、その戻り値が itr の要素を反復する順序に依存する場合、遅延変換を組み合わせると予期しない動作になることがあります。これを避けるには、flt が純粋関数であることを確認するか、後続の変換を行う前に中間の filter イテレーターを収集してください。
配列に対するフィルタリングの即時評価版については、Base.filter を参照してください。
Examples
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
5Base.Iterators.accumulate — Function
Iterators.accumulate(f, itr; [init])2引数関数 f とイテレータ itr を受け取り、直前の値と itr の次の要素に f を順次適用する、新しいイテレータを返します。
これは実質的に、Base.accumulate の遅延評価版です。
Examples
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.0Base.Iterators.reverse — Function
Iterators.reverse(itr)イテレータ itr が与えられたとき、reverse(itr) は同じコレクションを逆順にたどるイテレータです。このイテレータは「遅延」型であり、逆順にするためにコレクションのコピーを作成しません。コピーを作成する実装については、Base.reverse を参照してください。
(デフォルトでは、itr をラップする Iterators.Reverse オブジェクトを返します。このオブジェクトは、対応する iterate メソッドが定義されていれば反復可能ですが、一部の itr 型では、より特化した Iterators.reverse の動作が実装されている場合があります。)
すべてのイテレータ型 T が逆順の反復をサポートしているわけではありません。T がサポートしていない場合、Iterators.reverse(itr::T) を反復すると、Iterators.Reverse{T} に必要な iterate メソッドがないため、MethodError がスローされます。(これらのメソッドを実装するには、r::Iterators.Reverse{T} オブジェクトから r.itr によって元のイテレータ itr::T を取得できます。より一般的には、Iterators.reverse(r) を使用できます。)
Examples
julia> foreach(println, Iterators.reverse(1:5))
5
4
3
2
1Base.Iterators.only — Function
only(x)コレクション x の要素が1つだけならそれを返し、要素が0個または複数ある場合は ArgumentError をスローします。
Examples
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など)を返します。
関連項目: Iterators.drop、Iterators.take。
Examples
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)