コレクションとデータ構造

反復

逐次反復は iterate 関数で実装されます。一般的な for ループ

for i in iter   # または "for i = iter"
    # body
end

は、次のコードへ変換されます:

next = iterate(iter)
while next !== nothing
    (i, state) = next
    # body
    next = iterate(iter, state)
end

state オブジェクトは何でもよく、反復可能オブジェクトの型に合わせて適切なものを選択します。反復可能な型を独自に定義する方法について詳しくはマニュアルの反復インターフェースの節を参照してください。

このインターフェースは次の型で完全に実装されます:

Base.iterate ── 関数

iterate(iter [, state]) -> Union{Nothing, Tuple{Any, Any}}

反復子を進め、次の要素を取得します。要素が残っていないなら nothing を返すべきで、要素が存在するなら次の要素と新しい反復状態からなる二要素のタプルを返すべきです。

Base.IteratorSize ── 型

IteratorSize(itertype::Type) -> IteratorSize

反復子の型を受け取り、次の値のいずれかを返します:

  • SizeUnknown(): 反復子の長さ (要素数) が事前に分からないとき。
  • HasLength(): 固定された有限の長さが存在するとき。
  • HasShape{N}(): 長さが既知で、次元と形状を持つとき (配列など)。このとき N は次元数を表し、反復子に対する axes が定義される。
  • IsInfinite(): 反復子が無限に値を生成するとき。

この関数を定義しない反復子に対するデフォルト値は HasLength() です。これは、ほとんどの反復子に対して length の実装が仮定されることを意味します。

このトレイトは通常、結果の格納場所を事前にアロケートするアルゴリズムと、結果を段階的にリサイズしていくアルゴリズムのいずれかを選択するために使われます。

julia> Base.IteratorSize(1:5)
Base.HasShape{1}()

julia> Base.IteratorSize((2,3))
Base.HasLength()

Base.IteratorEltype ── 型

IteratorEltype(itertype::Type) -> IteratorEltype

反復子の型を受け取り、次の値のいずれかを返します:

  • EltypeUnknown(): 反復子が生成する要素の型が事前に分からないとき。
  • HasEltype(): 要素型が既知で、eltype が意味のある値を返せるとき。

反復子は eltype を実装すると仮定されるので、IteratorEltype のデフォルト値は HasEltype() です。

このトレイトは通常、特定の要素型を持つ結果を事前にアロケートするアルゴリズムと、生成された値の型に基づいて結果の型を決めるアルゴリズムのいずれかを選択するために使われます。

julia> Base.IteratorEltype(1:5)
Base.HasEltype()

コンストラクタと型

Base.AbstractRange ── 型

AbstractRange{T}

T 型の要素を持つ区間を表す上位型です。UnitRange などを部分型に持ちます。

Base.OrdinalRange ── 型

OrdinalRange{T, S} <: AbstractRange{T}

T 型の要素と S 型の間隔を持つ順序付き区間を表す上位型です。Toneunit(T) より小さい値が存在しない具象型で、間隔は必ず oneunit(T) の倍数である必要があります。例えば IntegerDateT として使えますが、Float64 は (oneunit(Float64) より小さい Float64 型の値が存在するので) 使えません。UnitRangeStepRange を部分型に持ちます。

Base.AbstractUnitRange ── 型

AbstractUnitRange{T} <: OrdinalRange{T, T}

T 型の要素と oneunit(T) の間隔を持つ区間を表す上位型です。UnitRange などを部分型に持ちます。

Base.StepRange ── 型

StepRange{T, S} <: OrdinalRange{T, S}

T 型の要素と S 型の間隔を持つ区間です。各要素間の間隔は定数で、区間は T 型の値 startstop および S 型の値 step で定義されます。T または S を浮動小数点数型にすることはできません。整数 a, b, c (b > 1) に対する a:b:cStepRange を作成します。

julia> collect(StepRange(1, Int8(2), 10))
5-element Array{Int64,1}:
 1
 3
 5
 7
 9

julia> typeof(StepRange(1, Int8(2), 10))
StepRange{Int64,Int8}

julia> typeof(1:3:6)
StepRange{Int64,Int64}

Base.UnitRange ── 型

UnitRange{T<:Real}

T 型の値 startstop でパラメータ化される区間です。from から 1 ずつ増やしていって stop を超えるまでの値を表します。整数 a, b に対する a:b という構文は UnitRange を作成します。

julia> collect(UnitRange(2.3, 5.2))
3-element Array{Float64,1}:
 2.3
 3.3
 4.3

julia> typeof(1:10)
UnitRange{Int64}

Base.LinRange ── 型

LinRange{T}

start から stop まで等間隔に並ぶ len 個の要素からなる区間です。間隔のサイズは len で制御され、この値は Int である必要があります。

julia> LinRange(1.5, 5.5, 9)
9-element LinRange{Float64}:
 1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0,5.5

range を使うのと比べると、直接 LinRange を構築した方がオーバーヘッドは減りますが、浮動小数点数の誤差が修正されなくなります:

julia> collect(range(-0.1, 0.3, length=5))
5-element Array{Float64,1}:
 -0.1
  0.0
  0.1
  0.2
  0.3

julia> collect(LinRange(-0.1, 0.3, 5))
5-element Array{Float64,1}:
 -0.1
 -1.3877787807814457e-17
  0.09999999999999999
  0.19999999999999998
  0.3

コレクション

このインターフェースは次の型で完全に実装されます:

Base.isempty ── 関数

isempty(collection) -> Bool

collection が空 (要素を持たない) かどうかを判定します。

julia> isempty([])
true

julia> isempty([1 2 3])
false
isempty(condition)

指定した条件を待っているタスクが無いなら true を返し、あるなら false を返します。

Base.empty! ── 関数

empty!(collection) -> collection

collection の全ての要素を削除します。

julia> A = Dict("a" => 1, "b" => 2)
Dict{String,Int64} with 2 entries:
  "b" => 2
  "a" => 1

julia> empty!(A);

julia> A
Dict{String,Int64}()

Base.length ── 関数

length(collection) -> Integer

collection の要素数を返します。

添え字アクセス可能なコレクションに対する最後の正当な添え字を取得するには lastindex を使ってください。

julia> length(1:5)
5

julia> length([1, 2, 3, 4])
4

julia> length([1 2; 3 4])
4

反復可能コレクション

Base.in ── 関数

in(item, collection) -> Bool
∈(item, collection) -> Bool
∋(collection, item) -> Bool

itemcollection に含まれるかどうかを判定します。ここで「含まれる」は「コレクションを反復して生成される値のいずれかと == になる」を意味します。基本的に Bool 型の値を返しますが、itemmissing のとき、および collectionmissing を含み item を含まないときは missing を返します (これは三値論理に従った振る舞いであり、any== と同様です)。

一部のコレクションでは定義が少しだけ異なります。例えば Set では、要素のいずれかが itemisequal かどうかが判定されます。また Dict では key=>value の組が検索され、キーの比較には isequal が使われます。辞書のキーが存在するかどうかを判定するには k in keys(dict) または haskey を使ってください。SetDict に対する返り値は必ず Bool 型の値であり、missing は返りません。

要素がコレクションに存在しないことを判定するには を使ってください。!(a in b) とすれば in を否定でき、これは論理的に not in に近い命題を意味します。

in.(items, collection) あるいは items .∈ collection としてブロードキャストすると、itemcollection 両方に関するブロードキャストが起きます。例えば両方の引数が (次元が同じ) ベクトルなら、item の各要素が collection の対応する位置にあるコレクションに含まれるかどうかを示すベクトルが計算されます。しかしこれが意図した動作でない場合はよくあります。items の各要素が collection に含まれるかどうかを示すベクトルを計算するには、in.(items, Ref(collection))items .∈ Ref(collection) のように右辺を Ref (またはタプル) でラップしてください。

julia> a = 1:3:20
1:3:19

julia> 4 in a
true

julia> 5 in a
false

julia> missing in [1, 2]
missing

julia> 1 in [2, missing]
missing

julia> 1 in [1, missing]
true

julia> missing in Set([1, 2])
false

julia> !(21 in a)
true

julia> !(19 in a)
false

julia> [1, 2] .∈ [2, 3]
2-element BitArray{1}:
 0
 0

julia> [1, 2] .∈ ([2, 3],)
2-element BitArray{1}:
 0
 1

Base.:∉ ── 関数

∉(item, collection) -> Bool
∌(collection, item) -> Bool

および の否定です。itemcollection に含まれないかどうかを判定します。

items .∉ collection でブロードキャストすると、itemcollection 両方に関するブロードキャストが起きます。例えば両方の引数が (次元が同じ) ベクトルなら、item の各要素が collection の対応する位置にあるコレクションに含まれないかどうかを示すベクトルが計算されます。しかしこれが意図した動作でない場合はよくあります。items の各要素が collection に含まれないかどうかを示すベクトルを計算するには、items .∉ Ref(collection) のように右辺を Ref (またはタプル) でラップしてください。

julia> 1  2:4
true

julia> 1  1:3
false

julia> [1, 2] .∉ [2, 3]
2-element BitArray{1}:
 1
 1

julia> [1, 2] .∉ ([2, 3],)
2-element BitArray{1}:
 1
 0

Base.eltype ── 関数

eltype(type)

type 型のコレクションを反復したときに生成される要素の型を返します。辞書型に対しては Pair{KeyType,ValType} が返り値となります。利便性のため eltype(x) = eltype(typeof(x)) が定義されるので、型ではなくインスタンスを渡すこともできます。ただし新しい型に対しては型を引数に受け取る形式を定義するべきです。

julia> eltype(fill(1f0, (2,2)))
Float32

julia> eltype(fill(0x1, (2,2)))
UInt8

Base.indexin ── 関数

indexin(a, b)

a の各要素の b における添え字からなる配列を返します。a のある要素が b に存在しないときは、出力の配列の対応する要素は nothing となります。

julia> a = ['a', 'b', 'c', 'b', 'd', 'a'];

julia> b = ['a', 'b', 'c'];

julia> indexin(a, b)
6-element Array{Union{Nothing, Int64},1}:
 1
 2
 3
 2
  nothing
 1

julia> indexin(b, a)
3-element Array{Union{Nothing, Int64},1}:
 1
 2
 3

Base.unique ── 関数

unique(itr)

コレクション itr に含まれるユニークな要素だけからなる配列を返します。等価性は isequal で判定され、複数ある要素は最初にある要素だけが残されます。入力の要素型がそのまま出力の要素型となります。

julia> unique([1, 2, 6, 2])
3-element Array{Int64,1}:
 1
 2
 6

julia> unique(Real[1, 1.0, 2])
2-element Array{Real,1}:
 1
 2
unique(f, itr)

f を適用したときにユニークな値を返す itr の要素からなる配列を返します。

julia> unique(x -> x^2, [1, -1, 3, -3, 4])
3-element Array{Int64,1}:
 1
 3
 4
unique(A::AbstractArray; dims::Int)

dims 番目の次元に沿った A のユニークな領域を返します。

julia> A = map(isodd, reshape(Vector(1:8), (2,2,2)))
2×2×2 Array{Bool,3}:
[:, :, 1] =
 1  1
 0  0

[:, :, 2] =
 1  1
 0  0

julia> unique(A)
2-element Array{Bool,1}:
 1
 0

julia> unique(A, dims=2)
2×1×2 Array{Bool,3}:
[:, :, 1] =
 1
 0

[:, :, 2] =
 1
 0

julia> unique(A, dims=3)
2×2×1 Array{Bool,3}:
[:, :, 1] =
 1  1
 0  0

Base.unique! ── 関数

unique!(f, A::AbstractVector)

f を適用したときにユニークな値を返す要素だけが残るよう A を改変し、改変した A を返します。

Julia 1.1

このメソッドは Julia 1.1 以降で利用できます。

julia> unique!(x -> x^2, [1, -1, 3, -3, 4])
3-element Array{Int64,1}:
 1
 3
 4

julia> unique!(n -> n%3, [5, 1, 8, 9, 3, 4, 10, 7, 2, 6])
3-element Array{Int64,1}:
 5
 1
 9

julia> unique!(iseven, [2, 3, 5, 7, 9])
2-element Array{Int64,1}:
 2
 3
unique!(A::AbstractVector)

重複する要素を A から削除し、変更した A を返します。重複は isequal を使って判定され、A の要素は元々の順序が保たれます。返り値のデータの順番を気にしないなら、sort!(A); unique!(A) とすることで格段に速く重複要素の削除を行えます (ただし A がソートできる必要があります)。

julia> unique!([1, 1, 1])
1-element Array{Int64,1}:
 1

julia> A = [7, 3, 2, 3, 7, 5];

julia> unique!(A)
4-element Array{Int64,1}:
 7
 3
 2
 5

julia> B = [7, 6, 42, 6, 7, 42];

julia> sort!(B);  # unique! はソートされたデータをずっと速く処理できる。

julia> unique!(B)
3-element Array{Int64,1}:
  6
  7
 42

Base.allunique ── 関数

allunique(itr) -> Bool

itr が生成する値が全て異なるなら true を返します。比較は isequal で行われます。

julia> a = [1; 2; 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> allunique([a, a])
false

Base.reduce ── メソッド

reduce(op, itr; [init])

二項演算 op を使ってコレクション itr を縮約します。初期値 init が指定されるなら、それは空のコレクションが返す op の単位元である必要があります。init が空でないコレクションで使われるかどうかは規定されません。

空のコレクションに対する値を計算するには基本的に init が必要です。ただし op+, *, max, min, &, | のときは Julia が op の単位元を知っているので例外的に与えなくても構いません。

よく使われる演算を使った縮約は特殊な実装を持つことがあります。maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr) が使えるならそちらを使うべきです。

縮約が結合性を持って実行されるかどうかは実装依存です。これは - のような結合性を持たない演算子を使った縮約が行えないことを意味します。reduce(-,[1,2,3])(1-2)-31-(2-3) のどちらとして評価すべきかが定義されないためです。このような場合には左および右からの結合を保証した縮約演算 foldl および foldr を代わりに使ってください。

演算の中には誤差が堆積するものがあります。縮約をグループごとに実行できると並列性が簡単に達成できます。Julia の将来のバージョンでアルゴリズムが変更される可能性があります。順序付きのコレクションを使っても要素の並べ替えは行われない点に注意してください。

julia> reduce(*, [2; 3; 4])
24

julia> reduce(*, [2; 3; 4]; init=-1)
-24

Base.foldl ── メソッド

foldl(op, itr; [init])

基本的に reduce と同様ですが、左からの連結性を保証して評価を行います。init が与えられると、その値は正確に一度だけ使われます。一般に、空のコレクションに対して正しい値を計算するには init を与える必要があります。

julia> foldl(=>, 1:4)
((1 => 2) => 3) => 4

julia> foldl(=>, 1:4; init=0)
(((0 => 1) => 2) => 3) => 4

Base.foldr ── メソッド

foldr(op, itr; [init])

基本的に reduce と同様ですが、右からの連結性を保証して評価を行います。init が与えられると、その値は正確に一度だけ使われます。一般に、空のコレクションに対して正しい値を計算するには init を与える必要があります。

julia> foldr(=>, 1:4)
1 => (2 => (3 => 4))

julia> foldr(=>, 1:4; init=0)
1 => (2 => (3 => (4 => 0)))

Base.maximum ── 関数

maximum(f, itr)

itr の各要素に f を適用した結果の最大値を返します。

julia> maximum(length, ["Julion", "Julia", "Jule"])
6
maximum(itr)

コレクションの最大要素を返します。

julia> maximum(-20.5:10)
9.5

julia> maximum([1,2,3])
3
maximum(A::AbstractArray; dims)

dims 番目の次元に沿った配列の最大値を計算します。二つ以上の引数から最大値を取る max(a,b) 関数もあり、max.(a,b) とすれば配列に対して要素ごとに最大値を計算できます。

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> maximum(A, dims=1)
1×2 Array{Int64,2}:
 3  4

julia> maximum(A, dims=2)
2×1 Array{Int64,2}:
 2
 4

Base.maximum! ── 関数

maximum!(r, A)

r のシングルトン次元1に関する A の最大値を計算し、結果を r に格納します。

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> maximum!([1; 1], A)
2-element Array{Int64,1}:
 2
 4

julia> maximum!([1 1], A)
1×2 Array{Int64,2}:
 3  4

Base.minimum ── 関数

minimum(f, itr)

itr の各要素に f を適用した結果の最小値を返します。

julia> minimum(length, ["Julion", "Julia", "Jule"])
4
minimum(itr)

コレクションの最小値を返します。

julia> minimum(-20.5:10)
-20.5

julia> minimum([1,2,3])
1
minimum(A::AbstractArray; dims)

dims 番目の次元に沿った配列 A の最小値を計算します。二つ以上の引数から最小値を取る min(a,b) 関数もあり、min.(a,b) とすれば配列に対して要素ごとに最小値を計算できます。

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> minimum(A, dims=1)
1×2 Array{Int64,2}:
 1  2

julia> minimum(A, dims=2)
2×1 Array{Int64,2}:
 1
 3

Base.minimum! ── 関数

minimum!(r, A)

r のシングルトン次元に関する A の最小値を計算し、結果を r に格納します。

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> minimum!([1; 1], A)
2-element Array{Int64,1}:
 1
 3

julia> minimum!([1 1], A)
1×2 Array{Int64,2}:
 1  2

Base.extrema ── 関数

extrema(itr) -> Tuple

itr の最小要素と最大要素を一度の走査で計算し、二要素のタプルとして返します。

julia> extrema(2:10)
(2, 10)

julia> extrema([9,pi,4.5])
(3.141592653589793, 9.0)
extrema(f, itr) -> Tuple

itr の各要素に f を適用した結果の最小値と最大値を計算し、二要素のタプルとして返します。itr は一度だけ走査されます。

Julia 1.2

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

julia> extrema(sin, 0:π)
(0.0, 0.9092974268256817)
extrema(A::AbstractArray; dims) -> Array{Tuple}

指定された次元に関する最小値と最大値を計算します。

julia> A = reshape(Vector(1:2:16), (2,2,2))
2×2×2 Array{Int64,3}:
[:, :, 1] =
 1  5
 3  7

[:, :, 2] =
  9  13
 11  15

julia> extrema(A, dims = (1,2))
1×1×2 Array{Tuple{Int64,Int64},3}:
[:, :, 1] =
 (1, 7)

[:, :, 2] =
 (9, 15)
extrema(f, A::AbstractArray; dims) -> Array{Tuple}

A の指定された次元の各要素に f を適用した結果の最小値と最大値を計算します。

Julia 1.2

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

Base.argmax ── 関数

argmax(itr) -> Integer

コレクションの最大要素の添え字を返します。最大要素が複数あるなら、その中で一番小さい添え字が返ります。

コレクションが空であってはいけません。

julia> argmax([8,0.1,-9,pi])
1

julia> argmax([1,7,7,6])
2

julia> argmax([1,7,7,NaN])
4
argmax(A; dims) -> indices

入力された配列に対して、指定された次元に関する最大要素の添え字を返します。NaN は他のどんな値よりも大きいものとして扱われます。

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 1.0  2.0
 3.0  4.0

julia> argmax(A, dims=1)
1×2 Array{CartesianIndex{2},2}:
 CartesianIndex(2, 1)  CartesianIndex(2, 2)

julia> argmax(A, dims=2)
2×1 Array{CartesianIndex{2},2}:
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

Base.argmin ── 関数

argmin(itr) -> Integer

コレクションの最小要素の添え字を返します。最小要素が複数あるなら、その中で一番小さい添え字を返します。

コレクションが空であってはいけません。

julia> argmin([8,0.1,-9,pi])
3

julia> argmin([7,1,1,6])
2

julia> argmin([7,1,1,NaN])
4
argmin(A; dims) -> indices

入力された配列に対して、指定された次元に関する最小要素の添え字を返します。NaN は他のどんな値よりも小さいものとして扱われます。

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 1.0  2.0
 3.0  4.0

julia> argmin(A, dims=1)
1×2 Array{CartesianIndex{2},2}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)

julia> argmin(A, dims=2)
2×1 Array{CartesianIndex{2},2}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)

Base.findmax ── 関数

findmax(itr) -> (x, index)

コレクション itr の最大要素とその添え字を返します。最大要素が複数あるなら、最初のものを返します。itrNaN が含まれるなら、NaN とその添え字が返ります。返り値は max と同様です。

コレクションは空であってはいけません。

julia> findmax([8,0.1,-9,pi])
(8.0, 1)

julia> findmax([1,7,7,6])
(7, 2)

julia> findmax([1,7,7,NaN])
(NaN, 4)
findmax(A; dims) -> (maxval, index)

配列の入力に対して、指定された次元に関する最大値とその添え字を返します。NaN は任意の値より大きいものとして扱われます。

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 1.0  2.0
 3.0  4.0

julia> findmax(A, dims=1)
([3.0 4.0], CartesianIndex{2}[CartesianIndex(2, 1) CartesianIndex(2, 2)])

julia> findmax(A, dims=2)
([2.0; 4.0], CartesianIndex{2}[CartesianIndex(1, 2); CartesianIndex(2, 2)])

Base.findmin ── 関数

findmin(itr) -> (x, index)

コレクション itr の最小要素とその添え字を返します。最小要素が複数あるなら、最初のものを返します。itrNaN が含まれるなら、NaN とその添え字が返ります。返り値は min と同様です。

コレクションは空であってはいけません。

julia> findmin([8,0.1,-9,pi])
(-9.0, 3)

julia> findmin([7,1,1,6])
(1, 2)

julia> findmin([7,1,1,NaN])
(NaN, 4)
findmin(A; dims) -> (minval, index)

配列の入力に対して、指定された次元に関する最小値とその添え字を返します。NaN は任意の値より小さいものとして扱われます。

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 1.0  2.0
 3.0  4.0

julia> findmin(A, dims=1)
([1.0 2.0], CartesianIndex{2}[CartesianIndex(1, 1) CartesianIndex(1, 2)])

julia> findmin(A, dims=2)
([1.0; 3.0], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 1)])

Base.findmax! ── 関数

findmax!(rval, rind, A) -> (maxval, index)

rvalrind のシングルトン次元に関する A の最大値と対応する線形添え字を計算し、結果を rvalrind に保存します。NaN は任意の値より大きいものとして扱われます。

Base.findmin! ── 関数

findmin!(rval, rind, A) -> (minval, index)

rvalrind のシングルトン次元に関する A の最小値と対応する線形添え字を計算し、結果を rvalrind に保存します。NaN は任意の値より小さいものとして扱われます。

Base.sum ── 関数

sum(f, itr)

itr の各要素に f を適用した結果の和を返します。

返り値の型は、f を適用した結果が全てシステムのワードサイズより小さい符号付き整数なら Int となり、全てシステムのワードサイズより小さい符号無し整数なら UInt となります。それ以外の場合には f が返す値を昇格した型の値が返ります。

julia> sum(abs2, [2; 3; 4])
29

小さな整数型の配列に対する sum(A)reduce(+, A) の重要な違いに注意してください:

julia> sum(Int8[100, 28])
128

julia> reduce(+, Int8[100, 28])
-128

前者では配列に含まれる整数がシステムのワードサイズに広げられるので 128 が結果となります。これに対して後者では型が広げられないので、整数がオーバフローした -128 が結果となります。

sum(itr)

コレクションの要素の和を返します。

返り値の型は、コレクションの要素が全てシステムのワードサイズより小さい符号付き整数なら Int となり、全てシステムのワードサイズより小さい符号無し整数なら UInt となります。それ以外の場合にはコレクションの要素を昇格した型の値が返ります。

julia> sum(1:20)
210
sum(A::AbstractArray; dims)

指定した次元に関する配列の要素の和を計算します。

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> sum(A, dims=1)
1×2 Array{Int64,2}:
 4  6

julia> sum(A, dims=2)
2×1 Array{Int64,2}:
 3
 7

Base.sum! ── 関数

sum!(r, A)

r のシングルトン次元に関する A の要素の和を計算し、結果を r に格納します。

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> sum!([1; 1], A)
2-element Array{Int64,1}:
 3
 7

julia> sum!([1 1], A)
1×2 Array{Int64,2}:
 4  6

Base.prod ── 関数

prod(f, itr)

itr の各要素に対して f を適用した結果の積を返します。

返り値の型は、f を適用した結果が全てシステムのワードサイズより小さい符号付き整数なら Int となり、全てシステムのワードサイズより小さい符号無し整数なら UInt となります。それ以外の場合には f が返す値を昇格した型の値が返ります。

julia> prod(abs2, [2; 3; 4])
576
prod(itr)

コレクションの各要素の積を返します。

返り値の型は、コレクションの要素が全てシステムのワードサイズより小さい符号付き整数なら Int となり、全てシステムのワードサイズより小さい符号無し整数なら UInt となります。それ以外の場合にはコレクションの要素を昇格した型の値が返ります。

julia> prod(1:20)
2432902008176640000
prod(A::AbstractArray; dims)

指定された次元に関する配列要素の積を返します。

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> prod(A, dims=1)
1×2 Array{Int64,2}:
 3  8

julia> prod(A, dims=2)
2×1 Array{Int64,2}:
  2
 12

Base.prod! ── 関数

prod!(r, A)

r のシングルトン次元に関する A の要素の積を計算し、結果を r に格納します。

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> prod!([1; 1], A)
2-element Array{Int64,1}:
  2
 12

julia> prod!([1 1], A)
1×2 Array{Int64,2}:
 3  8

Base.any ── メソッド

any(itr) -> Bool

真偽値のコレクションが true を含むかどうかを判定します。itr から true が得られた時点で true を返します (短絡評価が行われます)。

入力に値 missing が含まれるときは、missing でない全ての値が false のとき (言い換えると、入力に true が含まれないとき) missing を返します。これは三値論理に従った振る舞いです。

julia> a = [true,false,false,true]
4-element Array{Bool,1}:
 1
 0
 0
 1

julia> any(a)
true

julia> any((println(i); v) for (i, v) in enumerate(a))
1
true

julia> any([missing, true])
true

julia> any([false, missing])
missing

Base.any ── メソッド

any(p, itr) -> Bool

述語 pitr の要素のいずれかに対して true を返すかどうかを判定します。ptrue となる itr の要素が見つかった時点で true を返します (短絡評価が行われます)。

p が返す値 missing が含まれるときは、missing でない全ての値が false のとき (言い換えると、入力に true が含まれないとき) missing を返します。これは三値論理に従った振る舞いです。

julia> any(i->(4<=i<=6), [3,5,7])
true

julia> any(i -> (println(i); i > 3), 1:10)
1
2
3
4
true

julia> any(i -> i > 0, [1, missing])
true

julia> any(i -> i > 0, [-1, missing])
missing

julia> any(i -> i > 0, [-1, 0])
false

Base.any! ── 関数

any!(r, A)

r のシングルトン次元に沿って Atrue の要素を持つかどうかを判定し、結果を r に格納します。

julia> A = [true false; true false]
2×2 Array{Bool,2}:
 1  0
 1  0

julia> any!([1; 1], A)
2-element Array{Int64,1}:
 1
 1

julia> any!([1 1], A)
1×2 Array{Int64,2}:
 1  0

Base.all ── メソッド

all(itr) -> Bool

真偽値のコレクションが全て true かどうかを判定します。itr から false が得られた時点で false を返します (短絡評価が行われます)。

入力に値 missing が含まれるときは、missing でない全ての値が true のとき (言い換えると、入力に false が含まれないとき) missing を返します。これは三値論理に従った振る舞いです。

julia> a = [true,false,false,true]
4-element Array{Bool,1}:
 1
 0
 0
 1

julia> all(a)
false

julia> all((println(i); v) for (i, v) in enumerate(a))
1
2
false

julia> all([missing, false])
false

julia> all([true, missing])
missing

Base.all ── メソッド

all(p, itr) -> Bool

述語 pitr の要素の全てに対して true を返すかどうかを判定します。pfalse となる itr の要素が見つかった時点で false を返します (短絡評価が行われます)。

p が返す値 missing が含まれるときは、missing でない全ての値が true のとき (言い換えると、入力に false が含まれないとき) missing を返します。これは三値論理に従った振る舞いです。

julia> all(i->(4<=i<=6), [4,5,6])
true

julia> all(i -> (println(i); i < 3), 1:10)
1
2
3
false

julia> all(i -> i > 0, [1, missing])
missing

julia> all(i -> i > 0, [-1, missing])
false

julia> all(i -> i > 0, [1, 2])
true

Base.all! ── 関数

all!(r, A)

r のシングルトン次元に沿って A の要素が全て false かどうかを判定し、結果を r に格納します。

julia> A = [true false; true false]
2×2 Array{Bool,2}:
 1  0
 1  0

julia> all!([1; 1], A)
2-element Array{Int64,1}:
 0
 0

julia> all!([1 1], A)
1×2 Array{Int64,2}:
 1  0

Base.count ── 関数

count(p, itr) -> Integer
count(itr) -> Integer

述語 ptrue を返す itr の要素の個数を返します。p が与えられないなら、itr に含まれる true の個数を返します (このとき itr は真偽値の配列である必要があります)。

julia> count(i->(4<=i<=6), [2,3,4,5,6])
3

julia> count([true, false, true, true])
3
count(pattern::Union{AbstractString,Regex},
      string::AbstractString;
      overlap::Bool = false)

string に含まれる pattern とのマッチの個数を返します。length(findall(pattern, string)) と等価ですが、ずっと高速です。

overlap=true だと、マッチするシーケンスが string 内で重なることが許可されます。そうでなければ、マッチは重ならない区間を占める必要があります。

count([f=identity,] A::AbstractArray; dims=:)

ftrue を返す A の要素の個数を、指定した次元に沿って数えて返します。

Julia 1.5

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

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> count(<=(2), A, dims=1)
1×2 Array{Int64,2}:
 1  1

julia> count(<=(2), A, dims=2)
2×1 Array{Int64,2}:
 2
 0

Base.any ── メソッド

any(p, itr) -> Bool

述語 pitr の要素のいずれかに対して true を返すかどうかを判定します。ptrue となる itr の要素が見つかった時点で true を返します (短絡評価が行われます)。

p が返す値に missing が含まれるときは、missing でない全ての値が false のとき (言い換えると、入力に true が含まれないとき) missing を返します。これは三値論理に従った振る舞いです。

julia> any(i->(4<=i<=6), [3,5,7])
true

julia> any(i -> (println(i); i > 3), 1:10)
1
2
3
4
true

julia> any(i -> i > 0, [1, missing])
true

julia> any(i -> i > 0, [-1, missing])
missing

julia> any(i -> i > 0, [-1, 0])
false

Base.all ── メソッド

all(p, itr) -> Bool

述語 pitr の要素の全てに対して true を返すかどうかを判定します。pfalse となる itr の要素が見つかった時点で false を返します (短絡評価が行われます)。

p が返す値に missing が含まれるときは、missing でない全ての値が true のとき (言い換えると、入力に false が含まれないとき) missing を返します。これは三値論理に従った振る舞いです。

julia> all(i->(4<=i<=6), [4,5,6])
true

julia> all(i -> (println(i); i < 3), 1:10)
1
2
3
false

julia> all(i -> i > 0, [1, missing])
missing

julia> all(i -> i > 0, [-1, missing])
false

julia> all(i -> i > 0, [1, 2])
true

Base.foreach ── 関数

foreach(f, c...) -> Nothing

反復可能オブジェクト c の各要素に対して関数 f を呼び出します。引数に複数の反復可能オブジェクトを与えると、それぞれから要素を一つずつ取ったものが f の引数となります。f の返り値が必要ないときは map ではなく foreach を使うべきです (例えば foreach(println, array) など)。

julia> a = 1:3:7;

julia> foreach(x -> println(x^2), a)
1
16
49

Base.map ── 関数

map(f, c...) -> collection

コレクション c を各要素に f を適用することで変形します。引数に複数のコレクションを与えると、それぞれから要素を一つずつ取ったものが f の引数となります。

mapslices も参照してください。

julia> map(x -> x * 2, [1, 2, 3])
3-element Array{Int64,1}:
 2
 4
 6

julia> map(+, [1, 2, 3], [10, 20, 30])
3-element Array{Int64,1}:
 11
 22
 33

Base.map! ── 関数

map!(function, destination, collection...)

map と同様ですが、結果を新しいコレクションにして返すのではなく destination に格納します。desitination は一つ目のコレクションと同じかそれより大きいサイズを持つ必要があります。

julia> a = zeros(3);

julia> map!(x -> x * 2, a, [1, 2, 3]);

julia> a
3-element Array{Float64,1}:
 2.0
 4.0
 6.0
map!(f, values(dict::AbstractDict))

dict の全てのバリューを val から f(val) に置き換えることで dict を変形します。dict の型は変えられないことに注意してください。f(val)dict のバリュー型のインスタンスでないときは変換が行われ、変換できなければエラーが発生します。

Julia 1.2

map!(f, values(dict::AbstractDict)) は Julia 1.2 以降でサポートされます。

julia> d = Dict(:a => 1, :b => 2)
Dict{Symbol,Int64} with 2 entries:
  :a => 1
  :b => 2

julia> map!(v -> v-1, values(d))
Base.ValueIterator for a Dict{Symbol,Int64} with 2 entries. Values:
  0
  1

Base.mapreduce ── メソッド

mapreduce(f, op, itrs...; [init])

関数 fitrs の各要素に適用し、その結果を二項関数 op で縮約します。初期値 init が指定されるなら、それは空のコレクションが返す op の単位元である必要があります。init が空でないコレクションで使われるかどうかは規定されません。一般に、空のコレクションに対する値を計算するには init が必要です。

mapreduce は機能的に reduce(op, map(f, itr); init=init) を呼び出すのと等価ですが、途中でコレクションを作成する必要がないので一般に動作が高速です。reducemap のドキュメントも参照してください。

Julia 1.2

mapreduce に複数の反復子を渡す機能は Julia 1.2 以降でサポートされます。

julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
14

縮約が結合性を持って実行されるかどうかは実装依存です。加えて、実装は itr に複数含まれる要素に対する f の返り値を計算せずに使い回す可能性があります。左または右の結合性および全ての要素に対して f が呼ばれることを保証するには、mapfoldl または mapfoldr を使ってください。

Base.mapfoldl ── メソッド

mapfoldl(f, op, itr; [init])

mapreduce と同様ですが、foldl のように左結合性が保証されます。キーワード引数 init が指定されるなら、init はちょうど一度だけ使われます。一般に、空のコレクションに対する値を計算するには init が必要です。

Base.mapfoldr ── メソッド

mapfoldr(f, op, itr; [init])

mapreduce と同様ですが、foldr のように右結合性が保証されます。キーワード引数 init が指定されるなら、init はちょうど一度だけ使われます。一般に、空のコレクションに対する値を計算するには init が必要です。

Base.first ── 関数

first(coll)

反復可能コレクションの最初の要素を取得します。AbstractRange に対しては、たとえそれが空であったとしても開始点を返します。

julia> first(2:2:10)
2

julia> first([1; 2; 3; 4])
1
first(s::AbstractString, n::Integer)

s の最初の n 文字からなる文字列を返します。

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

Base.last ── 関数

last(coll)

順序付きコレクションの最後の要素を O(1) の時間で計算できるなら、それを計算して返します。この関数は lastindex を使って最後の添え字を取得します。AbstractRange に対しては、たとえそれが空であったとしても終了点を返します。

julia> last(1:2:10)
9

julia> last([1; 2; 3; 4])
4
last(s::AbstractString, n::Integer)

s の最後の n 文字からなる文字列を返します。

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

Base.front ── 関数

front(x::Tuple)::Tuple

x の最後以外の要素からなる Tuple を返します。

julia> Base.front((1,2,3))
(1, 2)

julia> Base.front(())
ERROR: ArgumentError: Cannot call front on an empty tuple.

Base.tail ── 関数

tail(x::Tuple)::Tuple

x の最初以外の要素からなる Tuple を返します。

julia> Base.tail((1,2,3))
(2, 3)

julia> Base.tail(())
ERROR: ArgumentError: Cannot call tail on an empty tuple.

Base.step ── 関数

step(r)

AbstractRange オブジェクトのステップサイズを取得します。

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

julia> step(range(2.5, stop=10.9, length=85))
0.1

Base.collect ── メソッド

collect(collection)

コレクションまたは反復子に含まれる全ての要素からなる Array を返します。辞書に対しては Pair{KeyType, ValType} の配列を返します。引数が配列の仲間または HasShape トレイトを実装した反復子なら、引数と同じ形状と次元数を持った配列が返ります。

julia> collect(1:2:13)
7-element Array{Int64,1}:
  1
  3
  5
  7
  9
 11
 13

Base.collect ── メソッド

collect(element_type, collection)

コレクションまたは反復可能オブジェクトに含まれる全ての要素からなる指定された要素型の Array を返します。返り値の形状と次元数は collection と一致します。

julia> collect(Float64, 1:2:5)
3-element Array{Float64,1}:
 1.0
 3.0
 5.0

Base.filter ── 関数

filter(f, a)

ffalse を返す要素を取り除いた a のコピーを返します。f は単一の引数を受け取ります。

Julia 1.4

filtera にタプルを渡す機能は Julia 1.4 以降でサポートされます。

julia> a = 1:10
1:10

julia> filter(isodd, a)
5-element Array{Int64,1}:
 1
 3
 5
 7
 9
filter(f, d::AbstractDict)

ffalse を返す要素を取り除いた d のコピーを返します。fkey=>value という組を受け取ります。

julia> d = Dict(1=>"a", 2=>"b")
Dict{Int64,String} with 2 entries:
  2 => "b"
  1 => "a"

julia> filter(p->isodd(p.first), d)
Dict{Int64,String} with 1 entry:
  1 => "a"
filter(f, itr::SkipMissing{<:AbstractArray})

与えられた SkipMissing 型の反復子がラップする配列と相似なベクトルであって欠損要素および ffalse を返す要素を取り除かれたものを返します。

Julia 1.2

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

julia> x = [1 2; missing 4]
2×2 Array{Union{Missing, Int64},2}:
 1         2
  missing  4

julia> filter(isodd, skipmissing(x))
1-element Array{Int64,1}:
 1

Base.filter! ── 関数

filter!(f, a)

コレクション a から ffalse を返す要素を取り除き、結果で a を更新します。関数 f は一つの引数を受け取ります。

julia> filter!(isodd, Vector(1:10))
5-element Array{Int64,1}:
 1
 3
 5
 7
 9
filter!(f, d::AbstractDict)

d から ffalse を返す要素を取り除き、結果で d を更新します。関数 fkey=>value という組を受け取ります。

julia> d = Dict(1=>"a", 2=>"b", 3=>"c")
Dict{Int64,String} with 3 entries:
  2 => "b"
  3 => "c"
  1 => "a"

julia> filter!(p->isodd(p.first), d)
Dict{Int64,String} with 2 entries:
  3 => "c"
  1 => "a"

Base.replace ── メソッド

replace(A, old_new::Pair...; [count::Integer])

コレクション A のコピーを作成し、old_new に含まれる組 old=>new それぞれについてコピーに含まれる oldnew に置き換え、コピーを返します。等価性は isequal で判定されます。count が指定されると、置換を最大でも count 回だけ行います。

返り値の要素型は A の要素型と組 old_new に含まれる new から昇格 (promote_type) で決められます。count が省略され、かつ A の要素型がシングルトン型を含む Union だと、シングルトン型の値が他の型に置き換わったときに返り値の要素型からシングルトン型が削除されます。例えば要素型が Union{T,Missing} のとき missingT 型の値に置換すると、返り値の要素型は T になります。

replace! も参照してください。

julia> replace([1, 2, 1, 3], 1=>0, 2=>4, count=2)
4-element Array{Int64,1}:
 0
 4
 1
 3

julia> replace([1, missing], missing=>0)
2-element Array{Int64,1}:
 1
 0

Base.replace ── メソッド

replace(new::Function, A; [count::Integer])

A の各要素 xnew(x) で置き換えたコピーを返します。count が指定されると、置換を最大でも count 回だけ行います (new(x) !== x のとき置換が起こったとカウントされます)。

julia> replace(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Array{Int64,1}:
 2
 2
 6
 4

julia> replace(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64,Int64} with 2 entries:
  3 => 4
  1 => 3

Base.replace! ── 関数

replace!(A, old_new::Pair...; [count::Integer])

old_new に含まれる組 old=>new のそれぞれについて、コレクション A に含まれる oldnew で置き換えます。等価性は isequal で判定されます。count が指定されると、置換は最大でも count 回だけ行われます。replace も参照してください。

julia> replace!([1, 2, 1, 3], 1=>0, 2=>4, count=2)
4-element Array{Int64,1}:
 0
 4
 1
 3

julia> replace!(Set([1, 2, 3]), 1=>0)
Set{Int64} with 3 elements:
  0
  2
  3
replace!(new::Function, A; [count::Integer])

コレクション A の各要素 xnew(x) で置き換えます。count が指定されると、置換を最大でも count 回だけ行います (new(x) !== x のとき置換が起こったとカウントされます)。

julia> replace!(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Array{Int64,1}:
 2
 2
 6
 4

julia> replace!(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64,Int64} with 2 entries:
  3 => 4
  1 => 3

julia> replace!(x->2x, Set([3, 6]))
Set{Int64} with 2 elements:
  6
  12

添え字アクセス可能なコレクション

このインターフェースは次の型で完全に実装されます:

次の型で部分的に実装されます:

Base.getindex ── 関数

getindex(collection, key...)

コレクションの指定されたキーまたは添え字に対応する値を取得します。構文 a[i,j,...] はコンパイラによって getindex(a, i, j, ...) に変換されます。

julia> A = Dict("a" => 1, "b" => 2)
Dict{String,Int64} with 2 entries:
  "b" => 2
  "a" => 1

julia> getindex(A, "a")
1

Base.setindex! ── 関数

setindex!(collection, value, key...)

コレクションの指定されたキーまたは添え字に対応する値を設定します。構文 a[i,j,...] = x はコンパイラによって (setindex!(a, x, i, j, ...); x) に変換されます。

Base.firstindex ── 関数

firstindex(collection) -> Integer
firstindex(collection, d) -> Integer

collection の最初の添え字を返します。d が与えられるなら、collectiond 番目の次元に関する最初の添え字を返します。

julia> firstindex([1,2,4])
1

julia> firstindex(rand(3,4,5), 2)
1

Base.lastindex ── 関数

lastindex(collection) -> Integer
lastindex(collection, d) -> Integer

collection の最後の添え字を返します。d が与えられるなら、collectiond 番目の次元に関する最後の添え字を返します。

構文 A[end]A[end, end]A[lastindex(A)]A[lastindex(A, 1), lastindex(A, 2)] にそれぞれ展開されます。

julia> lastindex([1,2,4])
3

julia> lastindex(rand(3,4,5), 2)
4

辞書

標準的な辞書は Dict です。Dict の実装はキーのハッシュ関数に hash を使い、等価性の判定に isequal を使います。この二つの関数を独自の型に定義すればハッシュテーブルに格納されるときの振る舞いをオーバーライドできます。

IdDict はオブジェクトの ID をキーに使う特殊なハッシュテーブルです。

WeakKeyDict はオブジェクトの弱参照 (weak reference) をキーとするハッシュテーブルの実装であり、キーが参照するオブジェクトに対するガベージコレクトが許可されます。Dict と同様 WeakKeyDicthash でハッシュを計算し isequal で等価性を判定しますが、Dict と異なり要素を挿入するときキーの変換を行いません。

Dict=> で作った (一つ以上の) 組オブジェクトをコンストラクタに渡すことで構築します。例えば Dict("A"=>1, "B"=>2) とします。この呼び出しは渡されたキーとバリューから型を推論するので、Dict("A"=>1, "B"=>2) では Dict{STring, Int64} となります。型を明示的に指定するには Dict{KeyType,ValueType}(...) を使ってください。例えば Dict{String,Int32}("A"=>1, "B"=>2) とします。

辞書はジェネレータを使っても作成できます。例えば Dict(i => f(i) for i = 1:10) とします。

D が辞書のとき、構文 D[x] はキー x に対応するバリューが存在するならそれを返し、存在しないならエラーを送出します。また構文 D[x] = yx => y というキーとバリューの組を D に保存します (そのときキー x に対応する既存のバリューを置き換えます)。D[...] に複数の引数を与えるとタプルに変換されます: 例えば D[x,y] とすると、タプル (x,y) に対応するバリューが参照されます。

このインターフェースは次の型で完全に実装されます:

次の型で部分的に実装されます:

Base.AbstractDict ── 型

AbstractDict(K, V)

K 型のキーと V 型のバリューを持つ辞書とみなせる型を表す上位型です。DictIdDict などを部分型に持ちます。AbstractDict{K, V} 型の値は Pair{K, V} 型の値を生成する反復子であるべきです。

Base.Dict ── 型

Dict([itr])

Dict{K,V}()K 型のキーと V 型のバリューを持つハッシュテーブルを構築します。キーは isequal で比較され、hash でハッシュされます。

引数に単一の反復可能オブジェクトを与えると、その引数が生成する二要素のタプル (key,value) をキーとバリューの組とした Dict が構築されます。

julia> Dict([("A", 1), ("B", 2)])
Dict{String,Int64} with 2 entries:
  "B" => 2
  "A" => 1

複数の組を引数に与えることもできます:

julia> Dict("A"=>1, "B"=>2)
Dict{String,Int64} with 2 entries:
  "B" => 2
  "A" => 1

Base.IdDict ── 型

IdDict([itr])

IdDict{K,V}() はオブジェクトの ID をハッシュに使うハッシュテーブルを構築します。K 型のキーと V 型のバリューを持ち、キー同士およびバリュー同士は === で等価性が判定されます。

詳しくは Dict を参照してください。

Base.WeakKeyDict ── 型

WeakKeyDict([itr])

WeakKeyDict() はキーが弱参照 (weak reference) であるハッシュテーブルを構築します。弱参照が指すオブジェクトは、弱参照によって参照されるにもかかわらず、ガベージコレクトが許可されます。

詳しくは Dict を参照してください。なお Dict と異なり、WeakKeyDict は挿入するキーを変換しません。

Base.ImmutableDict ── 型

ImmutableDict

ImmutableDict は不変連結リストとして実装される辞書です。いくつかの挿入を一度だけ行うことで構築される小さい辞書に適しています。ImmutableDict が持つ値は削除できませんが、既存の値と同じキーを持つ値を挿入して部分的に書き換えたり隠したりすることは可能です2

ImmutableDict(KV::Pair)

key => value を使って ImmutableDict を作成します。

  • 特定のキーとバリューの組が辞書に含まれるかどうかを判定するには (key => value) in dict を使ってください。
  • キーに対して最後に設定されたバリューを取得するには get(dict, key, default) を使ってください。

Base.haskey ── 関数

haskey(collection, key) -> Bool

collectionkey に対応するマッピングを持つかどうかを判定します。

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char,Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

Base.get ── 関数

get(collection, key, default)

key に対応するバリューを collection が持つならそれを返し、持たないなら default を返します。

julia> d = Dict("a"=>1, "b"=>2);

julia> get(d, "a", 3)
1

julia> get(d, "c", 3)
3
get(f::Function, collection, key)

key に対応するバリューを collection が持つならそれを返し、持たないなら f() を返します。get! を使うと加えてデフォルト値を保存できます。

このメソッドは do ブロック構文を使って呼び出すことが意図されています:

get(dict, key) do
    # デフォルトの値をここで計算する
    time()
end

Base.get! ── メソッド

get!(collection, key, default)

key に対応するバリューを collection が持つならそれを返し、持たないなら key => defaultcollection に追加した上で default を返します。

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> get!(d, "a", 5)
1

julia> get!(d, "d", 4)
4

julia> d
Dict{String,Int64} with 4 entries:
  "c" => 3
  "b" => 2
  "a" => 1
  "d" => 4

Base.get! ── メソッド

get!(f::Function, collection, key)

key に対応するバリューを collection が持つならそれを返し、持たないなら key => f()collection に追加した上で f() を返します。

このメソッドは do ブロック構文を使って呼び出すことが意図されています:

get!(dict, key) do
    # デフォルトの値をここで計算する。
    time()
end

Base.getkey ── 関数

getkey(collection, key, default)

key に対応するバリューが collection に存在するなら key を返し、存在しないなら default を返します。

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char,Int64} with 2 entries:
  'a' => 2
  'b' => 3

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

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

Base.delete! ── 関数

delete!(collection, key)

key に対するマッピングが collection に存在するなら、それを削除します。collection を返します。

julia> d = Dict("a"=>1, "b"=>2)
Dict{String,Int64} with 2 entries:
  "b" => 2
  "a" => 1

julia> delete!(d, "b")
Dict{String,Int64} with 1 entry:
  "a" => 1

julia> delete!(d, "b") # d は変更されない。
Dict{String,Int64} with 1 entry:
  "a" => 1

Base.pop! ── メソッド

pop!(collection, key[, default])

key に対するマッピングが collection に存在するなら、それを collection から削除して返します。存在しないなら default を返しますが、default が指定されていなければエラーを送出します。

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> pop!(d, "a")
1

julia> pop!(d, "d")
ERROR: KeyError: key "d" not found
Stacktrace:
[...]

julia> pop!(d, "e", 4)
4

Base.keys ── 関数

keys(iterator)

キーとバリューを持つ反復子またはコレクション (配列や辞書) を受け取り、キーに対する反復子を返します。

Base.values ── 関数

values(iterator)

キーとバリューを持つ反復子またはコレクションを受け取り、バリューに対する反復子を返します。一般に反復子は “バリュー” を返すのが通常の動作なので、この関数のデフォルトの動作は引数をそのまま返すだけです。

julia> d = Dict("a"=>1, "b"=>2);

julia> values(d)
Base.ValueIterator for a Dict{String,Int64} with 2 entries. Values:
  2
  1

julia> values([2])
1-element Array{Int64,1}:
 2
values(a::AbstractDict)

コレクション内の全てのバリューに対する反復子を返します。collect(values(a)) はバリューからなる配列を返します。Dict のようにバリューが内部でハッシュテーブルとして保存される場合は、返り値の反復子から得られるバリューの順序は規定されません。ただし keys(a)values(a) が同じ順番で a を反復し値を返すことは保証されています。

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char,Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> collect(values(D))
2-element Array{Int64,1}:
 2
 3

Base.pairs ── 関数

pairs(collection)

キーの集合をバリューの集合に対応付ける任意のコレクションを受け取り、key => value という組を返す反復子を返します。配列を渡すこともでき、その場合は配列の添え字がキーとなります。

pairs(IndexLinear(), A)
pairs(IndexCartesian(), A)
pairs(IndexStyle(A), A)

「配列 A の各要素の添え字 i と値 x = A[i] に対して i => x を返す反復子」を返します。添え字の形式が指定できることを除けば pairs(A) と同じです。enumerate(A) とも似ていますが、pairs を使うと i は必ず A の有効な添え字となります。これに対して enumerateA が使う添え字の形式に関わらず 1 からカウントを始めます。

IndexLinear() を指定すると i を必ず整数にできます。IndexCartesian() を指定すると iCartesianIndex となり、IndexStyle(A) を指定すると配列 A のネイティブな添え字形式が選択されます。

pairs 関数に渡した配列の境界を変更すると、pairs が返す反復子は無効になります。

julia> A = ["a" "d"; "b" "e"; "c" "f"];

julia> for (index, value) in pairs(IndexStyle(A), A)
           println("$index $value")
       end
1 a
2 b
3 c
4 d
5 e
6 f

julia> S = view(A, 1:2, :);

julia> for (index, value) in pairs(IndexStyle(S), S)
           println("$index $value")
       end
CartesianIndex(1, 1) a
CartesianIndex(2, 1) b
CartesianIndex(1, 2) d
CartesianIndex(2, 2) e

IndexStyle, axes も参照してください。

Base.merge ── 関数

merge(d::AbstractDict, others::AbstractDict...)

与えられた複数のコレクションを合併した一つのコレクションを構築します。必要なら、構築されるコレクションの型は合併されるコレクションの型を全て保持できるよう昇格されます。同じキーが複数のコレクションに含まれる場合は、そのキーを含むコレクションの中で最後にあるものが持つバリューを採用します。

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String,Float64} with 2 entries:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String,Int64} with 2 entries:
  "bar" => 4711
  "baz" => 17

julia> merge(a, b)
Dict{String,Float64} with 3 entries:
  "bar" => 4711.0
  "baz" => 17.0
  "foo" => 0.0

julia> merge(b, a)
Dict{String,Float64} with 3 entries:
  "bar" => 42.0
  "baz" => 17.0
  "foo" => 0.0
merge(a::NamedTuple, bs::NamedTuple...)

複数の名前付きタプルを合併して新しい名前付きタプルを作成します。合併は左結合で行われます。左から右に、名前付きタプルの組ごとに合併を行うので、一番左の名前付きタプルに含まれるフィールドは返り値でも同じ順序で並びます。ただしフィールドのバリューは、そのフィールドを持つ最も右の名前付きタプルにおける値となります。引数に名前付きタプルが一つだけ与えられた場合の merge(a::NamedTuple) というシグネチャを持つメソッドもフォールバックとして実装されます。

Julia 1.1

三つ以上の NamedTuplemerge するには Julia 1.1 以上が必要です。

julia> merge((a=1, b=2, c=3), (b=4, d=5))
(a = 1, b = 4, c = 3, d = 5)
julia> merge((a=1, b=2), (b=3, c=(d=1,)), (c=(d=2,),))
(a = 1, b = 3, c = (d = 2,))
merge(a::NamedTuple, iterable)

キーとバリューの組を生成する反復可能オブジェクトを名前付きタプルとして解釈し、合併を行います。

julia> merge((a=1, b=2, c=3), [:b=>4, :d=>5])
(a = 1, b = 4, c = 3, d = 5)

Base.mergewith ── 関数

mergewith(combine, d::AbstractDict, others::AbstractDict...)
mergewith(combine)
merge(combine, d::AbstractDict, others::AbstractDict...)

与えられたコレクションを合併して新しいコレクションを構築します。必要なら、返り値のコレクションの型は合併するコレクションの型を全て保持できるよう昇格されます。同じキーを持つバリューは combine 関数を使って合成されます。カリー化された mergewith(combine) は関数 (args...) -> mergewith(combine, args...) を返します。

merge(combine::Union{Function,Type}, args...)mergewith(combine, args...) の別名であり、後方互換性のために提供されます。

Julia 1.5

mergewith は Julia 1.5 以降でサポートされます。

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String,Float64} with 2 entries:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String,Int64} with 2 entries:
  "bar" => 4711
  "baz" => 17

julia> mergewith(+, a, b)
Dict{String,Float64} with 3 entries:
  "bar" => 4753.0
  "baz" => 17.0
  "foo" => 0.0

julia> ans == mergewith(+)(a, b)
true

Base.merge! ── 関数

merge!(d::AbstractDict, others::AbstractDict...)

他のコレクションに含まれる組を使ってコレクション d を更新します。merge も参照してください。

julia> d1 = Dict(1 => 2, 3 => 4);

julia> d2 = Dict(1 => 4, 4 => 5);

julia> merge!(d1, d2);

julia> d1
Dict{Int64,Int64} with 3 entries:
  4 => 5
  3 => 4
  1 => 4

Base.mergewith! ── 関数

mergewith!(combine, d::AbstractDict, others::AbstractDict...) -> d
mergewith!(combine)
merge!(combine, d::AbstractDict, others::AbstractDict...) -> d

他のコレクションに含まれる組を使ってコレクション d を更新します。同じキーを持つバリューは combine 関数を使って合成されます。カリー化された mergewith!(combine) は関数 (args...) -> mergewith!(combine, args...) を返します。

merge!(combine::Union{Function,Type}, args...)mergewith!(combine, args...) の別名であり、後方互換性のために提供されます。

Julia 1.5

mergewith! は Julia 1.5 以降でサポートされます。

julia> d1 = Dict(1 => 2, 3 => 4);

julia> d2 = Dict(1 => 4, 4 => 5);

julia> mergewith!(+, d1, d2);

julia> d1
Dict{Int64,Int64} with 3 entries:
  4 => 5
  3 => 4
  1 => 6

julia> mergewith!(-, d1, d1);

julia> d1
Dict{Int64,Int64} with 3 entries:
  4 => 0
  3 => 0
  1 => 0

julia> foldl(mergewith!(+), [d1, d2]; init=Dict{Int64,Int64}())
Dict{Int64,Int64} with 3 entries:
  4 => 5
  3 => 0
  1 => 4

Base.sizehint! ── 関数

sizehint!(s, n)

コレクション s に対して最低でも n 要素の容量を確保するよう提案します。これによって性能が向上する可能性があります。

Base.keytype ── 関数

keytype(T::Type{<:AbstractArray})
keytype(A::AbstractArray)

配列型のキーの型を返します。これは keys(...)eltype を適用した結果と等しく、主に辞書型のインターフェースとの互換性のために提供されます。

julia> keytype([1, 2, 3]) == Int
true

julia> keytype([1 2; 3 4])
CartesianIndex{2}
Julia 1.2

配列に対する keytype は Julia 1.2 以降でサポートされます。

keytype(type)

辞書型のキーの型を返します。振る舞いは eltype と同様です。

julia> keytype(Dict(Int32(1) => "foo"))
Int32

Base.valtype ── 関数

valtype(T::Type{<:AbstractArray})
valtype(A::AbstractArray)

配列型のバリューの型を返します。これは eltype に等しく、主に辞書型のインターフェースとの互換性のために提供されます。

julia> valtype(["one", "two", "three"])
String
Julia 1.2

配列に対する valtype は Julia 1.2 以降でサポートされます。

valtype(type)

辞書型のバリューの型を返します。振る舞いは eltype と同様です。

julia> valtype(Dict(Int32(1) => "foo"))
String

集合に似たコレクション

このインターフェースは次の型で完全に実装されます:

次の型で部分的に実装されます:

Base.AbstractSet ── 型

AbstractSet(T)

T 型の要素を持つ集合に似た型を表す上位型です。部分型に SetBitSet があります。

Base.Set ── 型

Set([itr])

反復可能オブジェクト itr から生成される値を使って Set を構築します。itr が指定されなければ空の Set を構築します。疎な整数集合や任意のオブジェクトを含む集合に対しては Set を使うべきです。

Base.BitSet ── 型

BitSet([itr])

反復可能オブジェクト itr から生成される値を使って Int の集合を構築します。ビット列として実装されるので、密な整数集合に適しています。集合が疎 (例えば少数の非常に大きい整数を格納するだけ) なら Set を使ってください。

Base.union ── 関数

union(s, itrs...)
∪(s, itrs...)

和集合を構築します。配列では順序が保たれます。

julia> union([1, 2], [3, 4])
4-element Array{Int64,1}:
 1
 2
 3
 4

julia> union([1, 2], [2, 4])
3-element Array{Int64,1}:
 1
 2
 4

julia> union([4, 2], 1:2)
3-element Array{Int64,1}:
 4
 2
 1

julia> union(Set([1, 2]), 2:3)
Set{Int64} with 3 elements:
  2
  3
  1

Base.union! ── 関数

union!(s::Union{AbstractSet,AbstractVector}, itrs...)

引数の和集合を構築し、その結果で s を更新します。配列では順序が保たれます。

julia> a = Set([1, 3, 4, 5]);

julia> union!(a, 1:2:8);

julia> a
Set{Int64} with 5 elements:
  7
  4
  3
  5
  1

Base.intersect ── 関数

intersect(s, itrs...)
∩(s, itrs...)

共通部分集合を構築します。配列では順序が保たれます。

julia> intersect([1, 2, 3], [3, 4, 5])
1-element Array{Int64,1}:
 3

julia> intersect([1, 4, 4, 5, 6], [4, 6, 6, 7, 8])
2-element Array{Int64,1}:
 4
 6

julia> intersect(Set([1, 2]), BitSet([2, 3]))
Set{Int64} with 1 element:
  2

Base.setdiff ── 関数

setdiff(s, itrs...)

s に含まれ itrs のいずれにも含まれない要素からなる集合を構築します。配列では順序が保たれます。

julia> setdiff([1,2,3], [3,4,5])
2-element Array{Int64,1}:
 1
 2

Base.setdiff! ── 関数

setdiff!(s, itrs...)

itrs 内の反復可能オブジェクトに含まれる要素を s から (インプレースに) 取り除きます。配列では順序が保たれます。

julia> a = Set([1, 3, 4, 5]);

julia> setdiff!(a, 1:2:6);

julia> a
Set{Int64} with 1 element:
  4

Base.symdiff ── 関数

symdiff(s, itrs...)

与えられた集合の対称差を構築します。sAbstractSet でないなら順序が保たれます。要素が重複するたびに結果に含まれるかどうかが変わることに注意してください。

julia> symdiff([1,2,3], [3,4,5], [4,5,6])
3-element Array{Int64,1}:
 1
 2
 6

julia> symdiff([1,2,1], [2, 1, 2])
2-element Array{Int64,1}:
 1
 2

julia> symdiff(unique([1,2,1]), unique([2, 1, 2]))
Int64[]

Base.symdiff! ── 関数

symdiff!(s::Union{AbstractSet,AbstractVector}, itrs...)

与えられた集合の対称差を構築し、結果で s を更新します。s が配列なら順序が保たれます。要素が重複するたびに結果に含まれるかどうかが変わることに注意してください。

Base.intersect! ── 関数

intersect!(s::Union{AbstractSet,AbstractVector}, itrs...)

与えられた集合全ての共通部分集合を構築し、結果で s を更新します。配列では順序が保たれます。

Base.issubset ── 関数

issubset(a, b) -> Bool
⊆(a, b) -> Bool
⊇(b, a) -> Bool

任意の a の要素が b の要素かどうかを判定します。要素が集合に属するかどうかの判定には in が使われます。

julia> issubset([1, 2], [1, 2, 3])
true

julia> [1, 2, 3]  [1, 2]
false

julia> [1, 2, 3]  [1, 2]
true

Base.:⊈ ── 関数

⊈(a, b) -> Bool
⊉(b, a) -> Bool

の否定です。つまり、ab の部分集合でないかどうかを判定します。

julia> (1, 2)  (2, 3)
true

julia> (1, 2)  (1, 2, 3)
false

Base.:⊊ ── 関数

⊊(a, b) -> Bool
⊋(b, a) -> Bool

ab の部分集合であり、かつ b と等しくないかどうかを判定します。

julia> (1, 2)  (1, 2, 3)
true

julia> (1, 2)  (1, 2)
false

Base.issetequal ── 関数

issetequal(a, b) -> Bool

ab が同じ要素を持つかどうかを判定します。a ⊆ b && b ⊆ a と等価ですが、可能な場合には高速な実装が使われます。

julia> issetequal([1, 2], [1, 2, 3])
false

julia> issetequal([1, 2], [2, 1])
true

Base.isdisjoint ── 関数

isdisjoint(v1, v2) -> Bool

v1v2 が互いに素かどうか、つまり共通部分集合が空かどうかを判定します。

Julia 1.5

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

デキュー

このインターフェースは次の型で完全に実装されます:

Base.push! ── 関数

push!(collection, items...) -> collection

collectionitems を挿入します。items は一つ以上の要素を表します。collection が順序を持つコンテナなら、要素は最後に (与えられた順番で) 挿入されます。

julia> push!([1, 2, 3], 4, 5, 6)
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

他のコレクションに含まれる要素を全て加えるには、そのコレクションが順序を持つなら append! を使ってください。例えば append!([1, 2, 3], [4, 5, 6]) とすれば上の例と同じになります。AbstractSet オブジェクトに対しては union! が利用できます。

Base.pop! ── 関数

pop!(collection) -> item

collection から要素を一つ取り除き、取り除いた要素を返します。collection が順序を持つコンテナなら、最後の要素が返ります。

julia> A=[1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> pop!(A)
3

julia> A
2-element Array{Int64,1}:
 1
 2

julia> S = Set([1, 2])
Set{Int64} with 2 elements:
  2
  1

julia> pop!(S)
2

julia> S
Set{Int64} with 1 element:
  1

julia> pop!(Dict(1=>2))
1 => 2
pop!(collection, key[, default])

key に対するマッピングが collection に存在するなら、それを collection から削除して返します。存在しないなら default を返しますが、default が指定されなければエラーを送出します。

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> pop!(d, "a")
1

julia> pop!(d, "d")
ERROR: KeyError: key "d" not found
Stacktrace:
[...]

julia> pop!(d, "e", 4)
4

Base.popat! ── 関数

popat!(a::Vector, i::Integer, [default])

位置 i にある要素を削除して返します。削除によってできる空間は i より後ろにある要素をそれぞれ一つ上に移動させることで埋められます。ia に対する正当な添え字でないなら default を返しますが、default が指定されなければエラーを送出します。deleteat!splice! も参照してください。

Julia 1.5

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

julia> a = [4, 3, 2, 1]; popat!(a, 2)
3

julia> a
3-element Array{Int64,1}:
 4
 2
 1

julia> popat!(a, 4, missing)
missing

julia> popat!(a, 4)
ERROR: BoundsError: attempt to access 3-element Array{Int64,1} at index [4]
[...]

Base.pushfirst! ── 関数

pushfirst!(collection, items...) -> collection

collection の先頭に items を挿入します。items は一つ以上の要素を表します。

julia> pushfirst!([1, 2, 3, 4], 5, 6)
6-element Array{Int64,1}:
 5
 6
 1
 2
 3
 4

Base.popfirst! ── 関数

popfirst!(collection) -> item

collection の最初の要素を削除して返します。

julia> A = [1, 2, 3, 4, 5, 6]
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

julia> popfirst!(A)
1

julia> A
5-element Array{Int64,1}:
 2
 3
 4
 5
 6

Base.insert! ── 関数

insert!(a::Vector, index::Integer, item)

itema の位置 index に挿入します。この関数が返ると、a の位置 index の要素は item となります。

julia> insert!([6, 5, 4, 2, 1], 4, 3)
6-element Array{Int64,1}:
 6
 5
 4
 3
 2
 1

Base.deleteat! ── 関数

deleteat!(a::Vector, i::Integer)

位置 i の要素を a から削除し、変更された a を返します。削除によってできる空間は i より後ろの要素をそれぞれ一つ上に移動させることで埋められます。

julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
5-element Array{Int64,1}:
 6
 4
 3
 2
 1
deleteat!(a::Vector, inds)

inds が示す位置にある要素を a から削除し、変更された a を返します。削除によってできる空間は i より後ろの要素をそれぞれ一つ上に移動させることで埋められます。

inds として渡せるのはユニークかつソート済みの整数からなる反復子またはコレクション、あるいは a と同じ長さの真偽値ベクトルです。真偽値ベクトルでは true が削除すべき要素を表します。

julia> deleteat!([6, 5, 4, 3, 2, 1], 1:2:5)
3-element Array{Int64,1}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], [true, false, true, false, true, false])
3-element Array{Int64,1}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
ERROR: ArgumentError: indices must be unique and sorted
Stacktrace:
[...]

Base.splice! ── 関数

splice!(a::Vector, index::Integer, [replacement]) -> item

位置 index にある要素を a から削除し、削除した要素を返します。削除によってできる空間は i より後ろの要素をそれぞれ一つ上に移動させることで埋められます。replacement が指定されると、削除した位置に replacement が接合 (splice) されます。

julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
2

julia> A
5-element Array{Int64,1}:
 6
 5
 4
 3
 1

julia> splice!(A, 5, -1)
1

julia> A
5-element Array{Int64,1}:
  6
  5
  4
  3
 -1

julia> splice!(A, 1, [-1, -2, -3])
6

julia> A
7-element Array{Int64,1}:
 -1
 -2
 -3
  5
  4
  3
 -1

splice!(collection, n:n-1, replacement) を使うと、要素を削除することなく位置 n の前に replacement を挿入できます。

splice!(a::Vector, indices, [replacement]) -> items

コレクションによって指定される位置にある要素を削除し、削除された要素からなるコレクションを返します。削除によって生まれる空間は以降の要素を上に移動させることで埋められます。replacement が指定されると、削除した部分に replacement が接合 (splice) されます。なお replacement を指定するときは indicesUnitRange である必要があります。

splice!(collection, n:n-1, replacement) を使うと、要素を削除することなく位置 n の前に replacement を挿入できます。

Julia 1.5

Julia 1.5 より前のバージョンでは、indicesUnitRange である必要があります。

julia> A = [-1, -2, -3, 5, 4, 3, -1]; splice!(A, 4:3, 2)
Int64[]

julia> A
8-element Array{Int64,1}:
 -1
 -2
 -3
  2
  5
  4
  3
 -1

Base.resize! ── 関数

resize!(a::Vector, n::Integer) -> Vector

a のサイズを変更して要素数を n にします。n が現在の長さより小さいなら、最初の n 要素が保持されます。n が現在の長さより大きいなら、新しい要素が初期化される保証はありません。

julia> resize!([6, 5, 4, 3, 2, 1], 3)
3-element Array{Int64,1}:
 6
 5
 4

julia> a = resize!([6, 5, 4, 3, 2, 1], 8);

julia> length(a)
8

julia> a[1:6]
6-element Array{Int64,1}:
 6
 5
 4
 3
 2
 1

Base.append! ── 関数

append!(collection, collection2) -> collection

順序付きコンテナ collection の終わりに collection2 の要素を付け足します。

julia> append!([1],[2,3])
3-element Array{Int64,1}:
 1
 2
 3

julia> append!([1, 2, 3], [4, 5, 6])
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

コレクションに入っていない要素を collection に追加するには push! を使ってください。例えば上の例は push!([1, 2, 3], 4, 5, 6) と書けます。

Base.prepend! ── 関数

prepend!(a::Vector, items) -> collection

a の最初に items の要素を挿入します。

julia> prepend!([3],[1,2])
3-element Array{Int64,1}:
 1
 2
 3

ユーティリティコレクション

Base.Pair ── 型

Pair(x, y)
x => y

Pair(typeof(x), typeof(y)) 型の Pair オブジェクトを構築します。二つの要素はそれぞれ firstsecond というフィールドに保存されます。フィールドには反復でアクセスできます (ただし Pair はブロードキャストで “スカラー” として扱われます)。

Dict も参照してください。

julia> p = "foo" => 7
"foo" => 7

julia> typeof(p)
Pair{String,Int64}

julia> p.first
"foo"

julia> for x in p
           println(x)
       end
foo
7

Base.Iterators.Pairs ── 型

Iterators.Pairs(values, keys) <: AbstractDict{eltype(keys), eltype(values)}

添え字アクセス可能なコンテナを同じデータに対する辞書ビューに変形します。内部データのキー空間を変更すると、この関数が返すオブジェクトが無効になる可能性があります。


  1. 訳注: シングルトン次元とは大きさが 1 の次元のこと。maximum!(zeros(1,3,1), rand(3,3,3)) のように r が複数のシングルトン次元を持っていてもよい。[return]

  2. 訳注: 既存の ImmutableDict の値を書き換えるには、新しい ImmutableDict の構築が必要になる。例えば d = Base.ImmutableDict(:a => "a"); d = Base.ImmutableDict(d, :a => "new a") とする。[return]


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