反復ユーティリティ

Base.Iterators.Stateful ── 型

Stateful(itr)

この反復子ラッパーのとらえ方はいくつかあります:

  1. Stateful は反復子と反復状態を包む可変ラッパーです。
  2. Stateful は反復子に似た抽象化を Channel に似た抽象化に変換します。
  3. Stateful は反復子であり、要素を生成するたびに自身を残りの部分を表す反復子に改変します。

Stateful は通常の反復子インターフェースを提供します。ただし Channel といった他の可変反復子と同様に、反復が (for ループ中の break などで) 通常よりも早く中断した場合には、その後に同じ反復子オブジェクトに対して反復を行うと中断した位置から反復が再開します (これに対して、不変な反復子では最初から反復が始まります)。

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 Array{Char,1}:
 '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 Array{Char,1}:
 'e': ASCII/Unicode U+0065 (category Ll: Letter, lowercase)
 'f': ASCII/Unicode U+0066 (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 ── 関数

zip(iters...)

複数の反復子を同時に反復します。反復はいずれかの反復子が終わるまで続きます。zip が返す反復子から生成される値の型は、内部の反復子それぞれが生成する値の型からなるタプルです。

情報

zip が内部に持つ反復子のいずれかが終了したとき、ステートフルな反復子が他にあったとしても、それらに対して終了した反復子より多く iterate が呼び出されることはありません。

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)
zip(1:5, ["e", "d", "b", "c", "a"])

julia> length(c)
5

julia> first(c)
(1, "e")

Base.Iterators.enumerate ── 関数

enumerate(iter)

(i, x) という値を生成する反復子です。i1 から始まるカウンターで、x は引数に渡される反復子の i 番目の値を表します。この関数は反復する値 x だけではなく反復の回数も必要なときに有用です。iiter に対する正当な添え字であるとは限らない点に注意してください。例えば iter の添え字が 1 から始まらないときは x != iter[i] となります。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

Base.Iterators.rest ── 関数

rest(iter, state)

iter と同じ要素を生成する反復子です。ただし状態が state から始まります。

julia> collect(Iterators.rest([1,2,3,4], 2))
3-element Array{Int64,1}:
 2
 3
 4

Base.Iterators.countfrom ── 関数

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 ── 関数

take(iter, n)

iter から最大で n 要素を生成する反復子です。

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.takewhile ── 関数

takewhile(pred, iter)

述語 predtrue を返す限り iter から要素を生成し続ける反復子です。predfalse を返すと、それ以降の要素は全て捨てられます。

Julia 1.4

この関数は Julia 1.4 以降でサポートされます。

julia> s = collect(1:5)
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

julia> collect(Iterators.takewhile(<(3),s))
2-element Array{Int64,1}:
 1
 2

Base.Iterators.drop ── 関数

drop(iter, n)

iter の最初の n 要素を除いた要素を生成する反復子です。

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.dropwhile ── 関数

dropwhile(pred, iter)

述語 predtrue を返す要素を iter の先頭から取り除いてできる反復子です。最初に false を返した要素およびそれより後ろの要素は全て生成されます。

Julia 1.4

この関数は Julia 1.4 以降でサポートされます。

julia> s = collect(1:5)
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

julia> collect(Iterators.dropwhile(<(3),s))
3-element Array{Int64,1}:
 3
 4
 5

Base.Iterators.cycle ── 関数

cycle(iter)

iter を永遠に反復する反復子です。iter が空のときは cycle(iter) も空となります。

julia> for (i, v) in enumerate(Iterators.cycle("hello"))
           print(v)
           i > 10 && break
       end
hellohelloh

Base.Iterators.repeated ── 関数

repeated(x[, n::Int])

x を永遠に生成し続ける反復子です。n が指定されるなら xn 回だけ生成する反復子となります (このとき 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)

反復子を生成する反復子 iter を受け取り、iter の各要素が生成する値を生成する反復子を返します。別の言い方をすると、引数に受け取った反復子の要素を “連結” します。

julia> collect(Iterators.flatten((1:2, 8:9)))
4-element Array{Int64,1}:
 1
 2
 8
 9

Base.Iterators.partition ── 関数

partition(collection, n)

collection の要素を n 個ずつまとめて反復します。

julia> collect(Iterators.partition([1,2,3,4,5], 2))
3-element Array{SubArray{Int64,1,Array{Int64,1},Tuple{UnitRange{Int64}},true},1}:
 [1, 2]
 [3, 4]
 [5]

Base.Iterators.filter ── 関数

Iterators.filter(flt, itr)

述語関数 flt と反復子 itr を受け取り、itr が生成する要素 x の中で flt(x) が成り立つものだけを生成する反復子を返します。元の反復子における要素の順序は保存されます。

この関数は遅延評価を行います: \(Θ(1)\) の時間と \(Θ(1)\) の空間を使って値を返すこと、そして filter を呼んだだけでは flt が呼ばれないことが保証されています。flt が呼び出されるのは返り値の反復子を反復したときです。また flt の呼び出しはキャッシュされず、もう一度反復すると flt が再度呼び出されます。

配列に対する積極的な filter の実装については Base.filter を参照してください。

julia> f = Iterators.filter(isodd, [1, 2, 3, 4, 5])
Base.Iterators.Filter{typeof(isodd),Array{Int64,1}}(isodd, [1, 2, 3, 4, 5])

julia> foreach(println, f)
1
3
5

Base.Iterators.accumulate ── 関数

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

二引数関数 f と反復子 itr を受け取り、直前に生成した値と itr の次の要素に f を適用した値を生成する反復子を返します。

事実上、これは Base.accumulate の遅延評価バージョンです。

Julia 1.5

キーワード引数 init は Julia 1.5 で追加されました。

julia> f = Iterators.accumulate(+, [1,2,3,4]);

julia> foreach(println, f)
1
3
6
10

julia> f = Iterators.accumulate(+, [1,2,3]; init = 100);

julia> foreach(println, f)
101
103
106

Base.Iterators.reverse ── 関数

Iterators.reverse(itr)

反復子 itr を受け取り、それを逆順に反復する反復子を返します。

この関数が返す反復子は遅延評価を行うので、逆順に反復するときにコレクションのコピーは作成されません。積極評価を行いたいなら Base.reverse を使ってください。

全ての反復子型 T が逆順の反復をサポートするわけではありません。T が逆順の反復をサポートしない型のとき、Iterators.reverse(itr::T) の返り値を反復しようとすると、Iterators.Reverse{T} 型に対する iterate が存在しないという旨の MethodError が発生します (この型に対する iterate メソッドの実装で r = Iterators.reverse(itr) から元の反復子 itr::T を取得するには r.itr とします)。

julia> foreach(println, Iterators.reverse(1:5))
5
4
3
2
1

Base.Iterators.only ── 関数

only(x)

x が持つ唯一の要素を返します。x がゼロ個もしくは複数個の要素を持つときは ArgumentError を送出します。

first, last も参照してください。

Julia 1.4

このメソッドは Julia 1.4 以降でサポートされます。

Base.Iterators.peel ── 関数

peel(iter)

反復子の最初の要素と、残りの部分を反復する反復子を返します。

julia> (a, rest) = Iterators.peel("abc");

julia> a
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> collect(rest)
2-element Array{Char,1}:
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)

日本語 Julia 書籍 (Amazon アソシエイト)
1 から始める Julia プログラミング
Julia プログラミングクックブック―言語仕様からデータ分析、機械学習、数値計算まで
スタンフォード ベクトル・行列からはじめる最適化数学