Collections and Data Structures

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

イテレータを進めて次の要素を取得します。要素が残っていない場合は、nothingが返されるべきです。そうでなければ、次の要素と新しいイテレーション状態の2タプルが返されるべきです。

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

IteratorEltype(itertype::Type) -> IteratorEltype

イテレータの型が与えられたとき、次のいずれかの値を返します：

• EltypeUnknown() イテレータによって生成される要素の型が事前に知られていない場合。
• HasEltype() 要素の型が知られており、eltype が意味のある値を返す場合。

HasEltype() はデフォルトであり、イテレータは eltype を実装していると仮定されます。

この特性は、特定の型の結果を事前に割り当てるアルゴリズムと、生成される値の型に基づいて結果の型を選択するアルゴリズムを選択するために一般的に使用されます。

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

AbstractRange{T} <: AbstractVector{T}

型 T の要素を持つ線形範囲のスーパタイプ。 UnitRange、LinRange およびその他の型はこれのサブタイプです。

すべてのサブタイプは step を定義する必要があります。したがって、LogRange は AbstractRange のサブタイプではありません。

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

要素の型 T と間隔の型 S を持つ順序範囲のスーパークラス。ステップは常に oneunit の正確な倍数である必要があり、T は "離散的" 型でなければならず、oneunit より小さい値を持つことはできません。例えば、Integer や Date 型は適格ですが、Float64 は適格ではありません（この型は oneunit(Float64) より小さい値を表すことができるため）。UnitRange、StepRange、およびその他の型はこのサブタイプです。

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

ステップサイズが oneunit(T) で、要素の型が T の範囲のスーパークラスです。 UnitRange および他の型はそのサブタイプです。

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

要素の型が T で間隔の型が S の範囲。各要素間のステップは一定で、範囲は型 T の start と stop、および型 S の step に基づいて定義されます。T も S も浮動小数点型であってはなりません。a:b:c という構文は、b != 0 であり、a、b、c がすべて整数である場合に StepRange を作成します。

例

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

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

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

UnitRange{T<:Real}

start と stop の型 T によってパラメータ化された範囲で、start から stop を超えるまで 1 ずつ間隔を空けた要素で満たされています。a:b という構文は、a と b の両方が Integer の場合に UnitRange を作成します。

例

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

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

LinRange{T,L}

start と stop の間に len 個の線形に間隔を空けた要素を持つ範囲。間隔のサイズは len によって制御され、Integer でなければなりません。

例

julia> LinRange(1.5, 5.5, 9)
9-element LinRange{Float64, Int64}:
 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 Vector{Float64}:
 -0.1
  0.0
  0.1
  0.2
  0.3

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

対数間隔の点については Logrange も参照してください。

isempty(condition)

条件に待機しているタスクがない場合は true を返し、そうでない場合は false を返します。

isempty(collection) -> Bool

コレクションが空であるかどうかを判断します（要素がない）。

例

julia> isempty([])
true

julia> isempty([1 2 3])
false

isdone(itr, [state]) -> Union{Bool, Missing}

この関数は、イテレータの完了に関する高速パスのヒントを提供します。これは、ユーザーに公開されない要素が消費されるのを避けたい状態を持つイテレータにとって便利です（例えば、isemptyやzipで完了状態を確認する際など）。

この機能を利用したい状態を持つイテレータは、イテレータが完了しているかどうかに応じて真/偽を返すisdoneメソッドを定義する必要があります。状態を持たないイテレータは、この関数を実装する必要はありません。

結果がmissingの場合、呼び出し元はiterate(x, state) === nothingを計算して明確な答えを得ることができます。

関連情報としては、iterate、isemptyがあります。

empty!(c::Channel)

チャンネル c の内部バッファに対して empty! を呼び出すことで、チャンネルを空にします。空のチャンネルを返します。

empty!(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}()

length(collection) -> Integer

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

インデックス可能なコレクションの最後の有効なインデックスを取得するには、lastindexを使用してください。

参照: size, ndims, eachindex.

例

julia> length(1:5)
5

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

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

Base.checked_length(r)

length(r)を計算しますが、結果がUnion{Integer(eltype(r)),Int}に収まらない場合は、適用可能な場合にオーバーフローエラーをチェックすることがあります。

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

指定されたコレクションにアイテムが含まれているかどうかを判断します。これは、コレクションを反復処理して生成された値のいずれかに対して==であるという意味です。中置構文でも同様に使用できます：

item in collection
item ∈ collection

Bool値を返しますが、itemがmissingであるか、collectionがmissingを含んでいるがitemを含まない場合は、missingが返されます（三値論理、anyおよび==の動作に一致します）。一部のコレクションは、わずかに異なる定義に従います。たとえば、Setはアイテムが要素のいずれかにisequalであるかどうかを確認します。Dictはkey=>valueペアを探し、keyはisequalを使用して比較されます。

辞書内のキーの存在をテストするには、haskeyまたはk in keys(dict)を使用します。上記のコレクションについては、結果は常にBoolです。

in.(items, collection)またはitems .∈ collectionでブロードキャストすると、itemsとcollectionの両方がブロードキャストされますが、これはしばしば意図したものではありません。たとえば、両方の引数がベクトルで（次元が一致する場合）、結果はコレクションitemsの各値がcollectionの対応する位置の値にinであるかどうかを示すベクトルになります。itemsの各値がcollectionに含まれているかどうかを示すベクトルを取得するには、collectionをタプルまたはRefでラップします。次のようにします：in.(items, Ref(collection))またはitems .∈ Ref(collection)。

関連項目：∉、insorted、contains、occursin、issubset。

例

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> (1=>missing) in Dict(1=>10, 2=>20)
missing

julia> [1, 2] .∈ [2, 3]
2-element BitVector:
 0
 0

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

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

∈ と ∋ の否定、すなわち item が collection に含まれていないことをチェックします。

items .∉ collection でブロードキャストすると、items と collection の両方がブロードキャストされるため、しばしば意図したものとは異なります。たとえば、両方の引数がベクトルで（次元が一致する場合）、結果は collection の対応する位置の値に items の各値が含まれていないかどうかを示すベクトルになります。items の各値が collection に含まれていないかどうかを示すベクトルを取得するには、collection をタプルまたは Ref でラップします。例えば、items .∉ Ref(collection) のようにします。

例

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

julia> [1, 2] .∉ [2, 3]
2-element BitVector:
 1
 1

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

Base.hasfastin(T)

collection::T に対する計算 x ∈ collection が「高速」な操作（通常は定数または対数の複雑さ）と見なされるかどうかを判断します。便利のために、インスタンスを型の代わりに渡すことができるように hasfastin(x) = hasfastin(typeof(x)) という定義が提供されています。ただし、型引数を受け取る形式は新しい型のために定義する必要があります。

hasfastin(T) のデフォルトは、AbstractSet、AbstractDict、および AbstractRange のサブタイプに対しては true であり、それ以外は false です。

eltype(type)

与えられた type のコレクションを反復処理することによって生成される要素の型を決定します。辞書型の場合、これは Pair{KeyType,ValType} になります。便利のために、eltype(x) = eltype(typeof(x)) という定義が提供されているので、インスタンスを型の代わりに渡すことができます。ただし、型引数を受け取る形式は新しい型のために定義する必要があります。

参照: keytype, typeof.

例

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

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

indexin(a, b)

bのメンバーであるaの各値に対する最初のインデックスを含む配列を返します。出力配列は、aがbのメンバーでない場合はnothingを含みます。

関連情報: sortperm, findfirst.

例

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

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

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

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

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 Vector{Bool}:
 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

unique(f, itr)

itrの要素に適用されたfによって生成された各ユニークな値に対して、itrから1つの値を含む配列を返します。

例

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

この機能は、配列内のユニークな要素の最初の出現のインデックスを抽出するためにも使用できます：

julia> a = [3.1, 4.2, 5.3, 3.1, 3.1, 3.1, 4.2, 1.7];

julia> i = unique(i -> a[i], eachindex(a))
4-element Vector{Int64}:
 1
 2
 3
 8

julia> a[i]
4-element Vector{Float64}:
 3.1
 4.2
 5.3
 1.7

julia> a[i] == unique(a)
true

unique(itr)

コレクション itr のユニークな要素のみを含む配列を返します。これは isequal と hash によって決定され、同等の要素の最初の出現順に表示されます。入力の要素型は保持されます。

関連情報: unique!, allunique, allequal.

例

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

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

unique!(A::AbstractVector)

isequal および hash によって決定される重複アイテムを削除し、修正された A を返します。unique! は、A の要素を発生する順序で返します。返されるデータの順序を気にしない場合は、(sort!(A); unique!(A)) を呼び出す方が、A の要素がソート可能である限り、はるかに効率的です。

例

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

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

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

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

julia> sort!(B);  # unique! はソートされたデータをより効率的に処理できます。

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

unique!(f, A::AbstractVector)

Aの要素に適用されたfによって生成された各ユニークな値に対してAから1つの値を選択し、修正されたAを返します。

例

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

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

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

allunique(itr) -> Bool
allunique(f, itr) -> Bool

itrからのすべての値がisequalで比較したときに異なる場合はtrueを返します。あるいは、2番目のメソッドの場合、[f(x) for x in itr]のすべてが異なる場合です。

allunique(f, itr)は、fをlength(itr)回未満呼び出す場合があります。呼び出しの正確な回数は実装の詳細と見なされます。

alluniqueは、入力がソートされている場合に特化した実装を使用することがあります。

関連情報: unique, issorted, allequal.

例

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

julia> allunique([1, 2, 1, 2])
false

julia> allunique(Real[1, 1.0, 2])
false

julia> allunique([NaN, 2.0, NaN, 4.0])
false

julia> allunique(abs, [1, -1, 2])
false

allequal(itr) -> Bool
allequal(f, itr) -> Bool

itrのすべての値がisequalで比較したときに等しい場合、または、2番目のメソッドの場合、[f(x) for x in itr]のすべてが等しい場合にtrueを返します。

allequal(f, itr)は、fをlength(itr)回未満呼び出す場合があります。呼び出しの正確な回数は実装の詳細と見なされます。

関連: unique, allunique.

例

julia> allequal([])
true

julia> allequal([1])
true

julia> allequal([1, 1])
true

julia> allequal([1, 2])
false

julia> allequal(Dict(:a => 1, :b => 1))
false

julia> allequal(abs2, [1, -1])
true

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(vcat, arr) または reduce(hcat, arr) を呼び出すことです。

縮約の結合性は実装に依存します。これは、- のような非結合的な操作を使用できないことを意味します。なぜなら、reduce(-,[1,2,3]) が (1-2)-3 または 1-(2-3) と評価されるべきかは未定義だからです。左または右の結合性が保証されるためには、代わりに foldl または foldr を使用してください。

いくつかの操作は誤差を蓄積します。縮約がグループで実行できる場合、並列処理が容易になります。将来のバージョンの Julia ではアルゴリズムが変更される可能性があります。順序付きコレクションを使用する場合、要素は再配置されないことに注意してください。

例

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

julia> reduce(*, Int[]; init=1)
1

reduce(f, A::AbstractArray; dims=:, [init])

2引数関数 f を A の次元に沿って縮小します。dims は縮小する次元を指定するベクトルであり、キーワード引数 init は縮小に使用する初期値です。+、*、max および min の場合、init 引数はオプションです。

縮小の結合性は実装に依存します。特定の結合性、例えば左から右への結合性が必要な場合は、自分自身のループを書くか、foldl または foldr の使用を検討してください。reduce のドキュメントを参照してください。

例

julia> a = reshape(Vector(1:16), (4,4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> reduce(max, a, dims=2)
4×1 Matrix{Int64}:
 13
 14
 15
 16

julia> reduce(max, a, dims=1)
1×4 Matrix{Int64}:
 4  8  12  16

foldl(op, itr; [init])

reduceと同様ですが、左結合性が保証されています。指定された場合、キーワード引数initは正確に1回使用されます。一般的に、空のコレクションで作業するにはinitを提供する必要があります。

他にもmapfoldl、foldr、accumulateを参照してください。

例

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

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

julia> accumulate(=>, (1,2,3,4))
(1, 1 => 2, (1 => 2) => 3, ((1 => 2) => 3) => 4)

foldr(op, itr; [init])

reduceと同様ですが、右結合性が保証されています。指定された場合、キーワード引数initは正確に1回使用されます。一般的に、空のコレクションで作業するにはinitを提供する必要があります。

例

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

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

maximum(f, A::AbstractArray; dims)

与えられた次元にわたって配列の各要素に関数 f を適用することによって最大値を計算します。

例

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

julia> maximum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 9  16

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

maximum(A::AbstractArray; dims)

与えられた次元にわたって配列の最大値を計算します。二つ以上の引数の最大値を取るためのmax(a,b)関数も参照してください。これはmax.(a,b)を介して配列に要素ごとに適用できます。

参照: maximum!, extrema, findmax, argmax。

例

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

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

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

maximum(itr; [init])

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

空の itr に対して返される値は init によって指定できます。これは max にとって中立的な要素でなければなりません（すなわち、他のどの要素よりも小さいか等しい必要があります）。init が非空のコレクションに対して使用されるかどうかは未定義です。

例

julia> maximum(-20.5:10)
9.5

julia> maximum([1,2,3])
3

julia> maximum(())
ERROR: ArgumentError: empty collection に対しての還元は許可されていません; reducer に `init` を供給することを検討してください
Stacktrace:
[...]

julia> maximum((); init=-Inf)
-Inf

maximum(f, itr; [init])

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

空の itr に対して返される値は init によって指定できます。これは max に対して中立的な要素でなければならず（すなわち、他のどの要素よりも小さいか等しい）、非空のコレクションに対して init が使用されるかどうかは未定義です。

例

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

julia> maximum(length, []; init=-1)
-1

julia> maximum(sin, Real[]; init=-1.0)  # 良い、sin の出力は >= -1 であるため
-1.0

maximum!(r, A)

Aの単一次元にわたる最大値を計算し、結果をrに書き込みます。

例

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

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

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

minimum(f, A::AbstractArray; dims)

与えられた次元にわたって配列の各要素に関数 f を適用することによって最小値を計算します。

例

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

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

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

minimum(A::AbstractArray; dims)

与えられた次元にわたる配列の最小値を計算します。二つ以上の引数の最小値を取るためのmin(a,b)関数も参照してください。これはmin.(a,b)を介して配列に要素ごとに適用できます。

参照: minimum!, extrema, findmin, argmin.

例

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

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

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

minimum(itr; [init])

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

空の itr に対して返される値は init によって指定できます。これは min に対して中立的な要素でなければなりません（すなわち、他のどの要素よりも大きいか等しいものでなければなりません）。init が非空のコレクションに対して使用されるかどうかは未定義です。

例

julia> minimum(-20.5:10)
-20.5

julia> minimum([1,2,3])
1

julia> minimum([])
ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

julia> minimum([]; init=Inf)
Inf

minimum(f, itr; [init])

itrの各要素に対して関数fを呼び出した結果の最小値を返します。

空のitrに対して返される値はinitで指定できます。initはminの中立要素でなければならず（すなわち、他のどの要素よりも大きいか等しい必要があります）、非空のコレクションに対してinitが使用されるかどうかは未定義です。

例

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

julia> minimum(length, []; init=typemax(Int64))
9223372036854775807

julia> minimum(sin, Real[]; init=1.0)  # 良い、sinの出力は<= 1
1.0

minimum!(r, A)

Aの単一次元にわたる最小値を計算し、結果をrに書き込みます。

例

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

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

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

extrema(f, A::AbstractArray; dims) -> Array{Tuple}

与えられた次元の A の各要素に適用された f の最小値と最大値を計算します。

extrema(A::AbstractArray; dims) -> Array{Tuple}

与えられた次元にわたる配列の最小および最大要素を計算します。

参照: minimum, maximum, extrema!.

例

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, itr; [init]) -> (mn, mx)

itrの各要素に適用されたfの最小値mnと最大値mxの両方を計算し、それらを2タプルとして返します。itrに対しては1回のパスのみが行われます。

空のitrに対して返される値はinitによって指定できます。これは、最初の要素と2番目の要素がそれぞれminとmaxの中立要素である2タプルでなければなりません（すなわち、他のどの要素よりも大きい/小さいか等しい）。これは非空のコレクションに使用されます。注意: これは、空のitrに対して返される値(mn, mx)がmn ≥ mxを満たすことを意味しますが、非空のitrに対してはmn ≤ mxを満たします。これは「逆説的」ですが、期待される結果です。

例

julia> extrema(sin, 0:π)
(0.0, 0.9092974268256817)

julia> extrema(sin, Real[]; init = (1.0, -1.0))  # 良好、なぜなら -1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)

extrema(itr; [init]) -> (mn, mx)

単一のパスで最小値 mn と最大値 mx の両方の要素を計算し、それらを2タプルとして返します。

空の itr に対して返される値は init によって指定できます。これは、最初の要素と第二の要素がそれぞれ min と max の中立要素である2タプルでなければなりません（すなわち、他のどの要素よりも大きい/小さいか等しい）。その結果、itr が空の場合、返される (mn, mx) タプルは mn ≥ mx を満たします。init が指定されている場合、非空の itr に対しても使用できます。

例

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

julia> extrema([9,pi,4.5])
(3.141592653589793, 9.0)

julia> extrema([]; init = (Inf, -Inf))
(Inf, -Inf)

extrema!(r, A)

Aの最小値と最大値をrの単一次元にわたって計算し、結果をrに書き込みます。

例

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

julia> extrema!([(1, 1); (1, 1)], A)
2-element Vector{Tuple{Int64, Int64}}:
 (1, 2)
 (3, 4)

julia> extrema!([(1, 1);; (1, 1)], A)
1×2 Matrix{Tuple{Int64, Int64}}:
 (1, 3)  (2, 4)

argmax(A; dims) -> indices

配列入力の場合、指定された次元にわたる最大要素のインデックスを返します。NaNは、missingを除くすべての値よりも大きいと見なされます。

例

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

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

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

argmax(itr)

コレクション内の最大要素のインデックスまたはキーを返します。最大要素が複数ある場合は、最初のものが返されます。

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

インデックスはkeys(itr)およびpairs(itr)によって返されるものと同じ型です。

値はislessで比較されます。

関連項目: argmin, findmax.

例

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

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

julia> argmax([1, 7, 7, NaN])
4

argmax(f, domain)

f(x) が最大化される domain からの値 x を返します。f(x) の最大値が複数ある場合は、最初のものが見つかります。

domain は空でない反復可能なものでなければなりません。

値は isless で比較されます。

関連情報として argmin、findmax を参照してください。

例

julia> argmax(abs, -10:5)
-10

julia> argmax(cos, 0:π/2:2π)
0.0

argmax(r::AbstractRange)

範囲は複数の最大要素を持つことがあります。その場合、argmaxは最大のインデックスを返しますが、必ずしも最初のものではありません。

argmin(A; dims) -> indices

配列入力の場合、指定された次元にわたる最小要素のインデックスを返します。NaNは、missingを除くすべての値よりも小さいと見なされます。

例

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

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

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

argmin(itr)

コレクション内の最小要素のインデックスまたはキーを返します。最小要素が複数ある場合は、最初のものが返されます。

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

インデックスは、keys(itr) および pairs(itr) によって返されるものと同じ型です。

NaN は missing を除くすべての値よりも小さいと見なされます。

関連項目: argmax, findmin.

例

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

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

julia> argmin([7, 1, 1, NaN])
4

argmin(f, domain)

f(x) が最小化される domain からの値 x を返します。f(x) の最小値が複数ある場合は、最初のものが見つかります。

domain は空でない iterable でなければなりません。

NaN は missing を除くすべての値よりも小さいと見なされます。

関連情報として argmax、findmin を参照してください。

例

julia> argmin(sign, -10:5)
-10

julia> argmin(x -> -x^3 + x^2 - 10, -5:5)
5

julia> argmin(acos, 0:0.1:1)
1.0

argmin(r::AbstractRange)

範囲は複数の最小要素を持つことがあります。その場合、argminは最小のインデックスを返しますが、必ずしも最初のものではありません。

findmax(f, A; dims) -> (f(x), index)

配列入力の場合、指定された次元にわたって f を最大化する対応する値のコドメイン内の値とインデックスを返します。

例

julia> A = [-1.0 1; -0.5 2]
2×2 Matrix{Float64}:
 -1.0  1.0
 -0.5  2.0

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

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

findmax(A; dims) -> (maxval, index)

配列入力の場合、指定された次元における最大値とインデックスを返します。NaNはmissingを除くすべての値よりも大きいと見なされます。

例

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 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);;])

findmax(itr) -> (x, index)

コレクション itr の最大要素とそのインデックスまたはキーを返します。最大要素が複数ある場合は、最初のものが返されます。値は isless で比較されます。

インデックスは keys(itr) および pairs(itr) によって返されるのと同じ型です。

他にも: findmin, argmax, maximum.

例

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(f, domain) -> (f(x), index)

fの出力（コドメイン内の値）と、fの入力（ドメイン内の値）に対応するインデックスまたはキーのペアを返します。f(x)が最大化されるようなものです。最大点が複数ある場合は、最初のものが返されます。

domainは、keysをサポートする非空のイテラブルでなければなりません。インデックスは、keys(domain)によって返されるものと同じ型です。

値はislessで比較されます。

例

julia> findmax(identity, 5:9)
(9, 5)

julia> findmax(-, 1:10)
(-1, 1)

julia> findmax(first, [(1, :a), (3, :b), (3, :c)])
(3, 2)

julia> findmax(cos, 0:π/2:2π)
(1.0, 1)

findmin(f, A; dims) -> (f(x), index)

配列入力の場合、指定された次元にわたって f を最小化する対応する値のコドメイン内の値とインデックスを返します。

例

julia> A = [-1.0 1; -0.5 2]
2×2 Matrix{Float64}:
 -1.0  1.0
 -0.5  2.0

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

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

findmin(A; dims) -> (minval, index)

配列入力の場合、指定された次元における最小値とインデックスを返します。NaNはmissingを除くすべての値よりも小さいと見なされます。

例

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 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);;])

findmin(itr) -> (x, index)

コレクション itr の最小要素とそのインデックスまたはキーを返します。最小要素が複数ある場合は、最初のものが返されます。NaN は missing を除くすべての値よりも小さいと見なされます。

インデックスは keys(itr) および pairs(itr) によって返されるものと同じ型です。

関連項目: findmax, argmin, minimum.

例

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

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

julia> findmin([1, 7, 7, NaN])
(NaN, 4)

findmin(f, domain) -> (f(x), index)

fの出力（コドメイン内の値）と、fの入力（ドメイン内の値）に対応するインデックスまたはキーのペアを返します。f(x)が最小化されるような値です。最小点が複数ある場合は、最初のものが返されます。

domainは空でないイテラブルでなければなりません。

インデックスはkeys(domain)およびpairs(domain)によって返されるものと同じ型です。

NaNはmissingを除くすべての値よりも小さいと見なされます。

例

julia> findmin(identity, 5:9)
(5, 1)

julia> findmin(-, 1:10)
(-10, 10)

julia> findmin(first, [(2, :a), (2, :b), (3, :c)])
(2, 1)

julia> findmin(cos, 0:π/2:2π)
(-1.0, 3)

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

Aの最大値と対応する線形インデックスをrvalとrindの単一次元に沿って見つけ、結果をrvalとrindに格納します。NaNはmissingを除くすべての値よりも大きいと見なされます。

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

Aの最小値と対応する線形インデックスをrvalとrindの単一次元に沿って見つけ、結果をrvalとrindに格納します。NaNはmissingを除くすべての他の値よりも小さいと見なされます。

sum(f, A::AbstractArray; dims)

配列の各要素に対して関数 f を呼び出した結果を、指定された次元にわたって合計します。

例

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

julia> sum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 10  20

julia> sum(abs2, A, dims=2)
2×1 Matrix{Int64}:
  5
 25

sum(A::AbstractArray; dims)

指定された次元に沿って配列の要素を合計します。

例

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

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

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

sum(itr; [init])

コレクション内のすべての要素の合計を返します。

返り値の型は、システムのワードサイズ未満の符号付き整数の場合は Int、システムのワードサイズ未満の符号なし整数の場合は UInt です。その他のすべての引数については、すべての引数が昇格される共通の返り値の型が見つかります。

空の itr に対して返される値は init によって指定できます。これは加法的単位元（すなわちゼロ）でなければならず、init が非空のコレクションに使用されるかどうかは未定義です。

参照: reduce, mapreduce, count, union.

例

julia> sum(1:20)
210

julia> sum(1:20; init = 0.0)
210.0

sum(f, itr; [init])

itrの各要素に対して関数fを呼び出した結果を合計します。

返り値の型は、システムのワードサイズ未満の符号付き整数の場合はInt、システムのワードサイズ未満の符号なし整数の場合はUIntです。その他の引数については、すべての引数が昇格される共通の返り値の型が見つかります。

空のitrに対して返される値はinitで指定できます。initは加法的単位（すなわちゼロ）でなければならず、非空のコレクションに対してinitが使用されるかどうかは未定義です。

例

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

小さな整数のeltypeを持つ配列に対するsum(A)とreduce(+, A)の重要な違いに注意してください：

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

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

前者の場合、整数はシステムのワードサイズに拡張されるため、結果は128になります。後者の場合、そのような拡張は行われず、整数のオーバーフローが-128になります。

sum!(r, A)

Aの要素をrの単一次元にわたって合計し、結果をrに書き込みます。

例

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

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

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

prod(f, A::AbstractArray; dims)

与えられた次元にわたって配列の各要素に対して関数 f を呼び出した結果を掛け算します。

例

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

julia> prod(abs2, A, dims=1)
1×2 Matrix{Int64}:
 9  64

julia> prod(abs2, A, dims=2)
2×1 Matrix{Int64}:
   4
 144

prod(A::AbstractArray; dims)

指定された次元にわたって配列の要素を乗算します。

例

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

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

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

prod(itr; [init])

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

返り値の型は、システムのワードサイズ未満の符号付き整数の場合は Int、システムのワードサイズ未満の符号なし整数の場合は UInt です。その他の引数については、すべての引数が昇格される共通の返り値の型が見つかります。

空の itr に対して返される値は init によって指定できます。これは乗法的単位（すなわち1）でなければならず、init が非空のコレクションに使用されるかどうかは未定義です。

参照: reduce, cumprod, any.

例

julia> prod(1:5)
120

julia> prod(1:5; init = 1.0)
120.0

prod(f, itr; [init])

itrの各要素に適用されたfの積を返します。

返り値の型は、システムワードサイズ未満の符号付き整数の場合はInt、システムワードサイズ未満の符号なし整数の場合はUIntです。その他の引数については、すべての引数が昇格される共通の返り値の型が見つかります。

空のitrに対して返される値はinitによって指定できます。initは乗法的単位（すなわち1）でなければならず、非空のコレクションに対してinitが使用されるかどうかは未定義です。

例

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

prod!(r, A)

Aの要素をrの単一次元にわたって乗算し、結果をrに書き込みます。

例

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

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

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

any(itr) -> Bool

ブールコレクションの要素のいずれかが true であるかをテストし、itr 内で最初の true 値が見つかった時点で true を返します（ショートサーキット）。false でショートサーキットするには、all を使用してください。

入力に missing 値が含まれている場合、すべての非欠損値が false である場合（または同等に、入力に true 値が含まれていない場合）には missing を返します。これは 三値論理 に従います。

関連項目: all, count, sum, |, ||.

例

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 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

any(p, itr) -> Bool

述語 p が itr の任意の要素に対して true を返すかどうかを判断し、p が true を返す itr の最初のアイテムに出会った時点で true を返します（ショートサーキット）。false に対してショートサーキットを行うには、all を使用してください。

入力に 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

any!(r, A)

Aの単一次元に沿った値の中にtrueがあるかどうかをテストし、結果をrに書き込みます。

例

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

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

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

all(itr) -> Bool

ブールコレクションのすべての要素が true であるかどうかをテストし、itr で最初の false 値が見つかるとすぐに false を返します（ショートサーキット）。true でショートサーキットするには、any を使用してください。

入力に missing 値が含まれている場合、すべての非欠損値が true である場合（または同等に、入力に false 値が含まれていない場合）には missing を返します。これは 三値論理 に従います。

関連項目: all!, any, count, &, &&, allunique.

例

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 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

all(p, itr) -> Bool

述語 p が itr のすべての要素に対して true を返すかどうかを判断し、p が false を返す最初のアイテムが itr で見つかった時点で false を返します（ショートサーキット）。true でショートサーキットするには、any を使用してください。

入力に 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

all!(r, A)

Aのすべての値がrの単一次元に沿ってtrueであるかどうかをテストし、結果をrに書き込みます。

例

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

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

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

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

f が true を返す A の要素の数を、指定された次元にわたってカウントします。

例

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

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

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

count(
    pattern::Union{AbstractChar,AbstractString,AbstractPattern},
    string::AbstractString;
    overlap::Bool = false,
)

patternがstring内で一致する回数を返します。これはlength(findall(pattern, string))を呼び出すのと同等ですが、より効率的です。

overlap=trueの場合、一致するシーケンスは元の文字列内のインデックスで重複することが許可されます。そうでない場合は、互いに重ならない文字範囲からでなければなりません。

例

julia> count('a', "JuliaLang")
2

julia> count(r"a(.)a", "cabacabac", overlap=true)
3

julia> count(r"a(.)a", "cabacabac")
2

count([f=identity,] itr; init=0) -> Integer

f が true を返す itr の要素の数をカウントします。f が省略された場合、itr の true 要素の数をカウントします（これはブール値のコレクションである必要があります）。init はカウントを開始する値を指定するオプションであり、出力の型も決定します。

参照: any, sum.

例

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

julia> count([true, false, true, true])
3

julia> count(>(3), 1:7, init=0x03)
0x07

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

イテラブル c の各要素に対して関数 f を呼び出します。複数のイテラブル引数がある場合、f は要素ごとに呼び出され、いずれかのイテレータが終了するとイテレーションは停止します。

f の結果が必要ない場合は、foreach(println, array) のように map の代わりに foreach を使用するべきです。

例

julia> tri = 1:3:7; res = Int[];

julia> foreach(x -> push!(res, x^2), tri)

julia> res
3-element Vector{Int64}:
  1
 16
 49

julia> foreach((x, y) -> println(x, " with ", y), tri, 'a':'z')
1 with a
4 with b
7 with c

map(f, A::AbstractArray...) -> N-array

同じ ndims を持つ多次元配列に作用する場合、それらはすべて同じ axes を持たなければならず、結果も同様になります。

サイズが不一致の broadcast も参照してください。

例

julia> map(//, [1 2; 3 4], [4 3; 2 1])
2×2 Matrix{Rational{Int64}}:
 1//4  2//3
 3//2  4//1

julia> map(+, [1 2; 3 4], zeros(2,1))
ERROR: DimensionMismatch

julia> map(+, [1 2; 3 4], [1,10,100,1000], zeros(3,1))  # 3番目が尽きるまで反復
3-element Vector{Float64}:
   2.0
  13.0
 102.0

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

コレクション c を変換し、各要素に f を適用します。複数のコレクション引数がある場合、要素ごとに f を適用し、いずれかが尽きた時点で停止します。

結果の要素型は collect と同様の方法で決定されます。

他に map!、foreach、mapreduce、mapslices、zip、Iterators.map も参照してください。

例

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

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

map!(f, values(dict::AbstractDict))

dictを修正し、各値をvalからf(val)に変換します。dictの型は変更できないことに注意してください：f(val)がdictの値の型のインスタンスでない場合、可能であれば値の型に変換され、それ以外の場合はエラーが発生します。

例

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

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

map!(function, array)

mapと同様ですが、結果を同じ配列に格納します。

例

julia> a = [1 2 3; 4 5 6];

julia> map!(x -> x^3, a);

julia> a
2×3 Matrix{Int64}:
  1    8   27
 64  125  216

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

mapと同様ですが、新しいコレクションではなくdestinationに結果を格納します。destinationは最小のコレクションと同じかそれ以上の大きさでなければなりません。

参照: map, foreach, zip, copyto!.

例

julia> a = zeros(3);

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

julia> a
3-element Vector{Float64}:
 2.0
 4.0
 6.0

julia> map!(+, zeros(Int, 5), 100:999, 1:3)
5-element Vector{Int64}:
 101
 103
 105
   0
   0

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

関数 f を itrs の各要素に適用し、その後、結果を二項関数 op を使用して縮約します。提供されている場合、init は空のコレクションに対して返される op の中立要素でなければなりません。init が非空のコレクションに使用されるかどうかは不明です。一般的に、空のコレクションで作業するには init を提供する必要があります。

mapreduce は、reduce(op, map(f, itr); init=init) を呼び出すのと機能的に同等ですが、中間コレクションを作成する必要がないため、一般的に実行速度が速くなります。reduce と map のドキュメントを参照してください。

例

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

縮約の結合性は実装に依存します。さらに、一部の実装では、itr に複数回現れる要素に対して f の戻り値を再利用する場合があります。すべての値に対して f を呼び出し、左または右の結合性を保証するには、mapfoldl または mapfoldr を使用してください。

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

mapreduceと同様ですが、foldlのように左結合性が保証されています。提供された場合、キーワード引数initは正確に1回使用されます。一般的に、空のコレクションで作業するにはinitを提供する必要があります。

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

mapreduceと同様ですが、foldrのように右結合性が保証されています。提供された場合、キーワード引数initは正確に1回使用されます。一般的に、空のコレクションで作業するにはinitを提供する必要があります。

first(s::AbstractString, n::Integer)

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

例

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

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

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

first(itr, n::Integer)

イテラブルコレクション itr の最初の n 要素を取得します。itr が十分に長くない場合は、より少ない要素が返されます。

関連: startswith, Iterators.take.

例

julia> first(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "foo"
 "bar"

julia> first(1:6, 10)
1:6

julia> first(Bool[], 1)
Bool[]

first(coll)

イテラブルコレクションの最初の要素を取得します。空であってもAbstractRangeの開始点を返します。

関連情報: only, firstindex, last.

例

julia> first(2:2:10)
2

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

last(s::AbstractString, n::Integer)

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

例

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

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

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

last(itr, n::Integer)

イテラブルコレクション itr の最後の n 要素を取得します。itr が十分に長くない場合は、より少ない要素が返されます。

例

julia> last(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "bar"
 "qux"

julia> last(1:6, 10)
1:6

julia> last(Float64[], 1)
Float64[]

last(coll)

順序付きコレクションの最後の要素を取得します。これはO(1)時間で計算できる場合に限ります。これは、lastindexを呼び出して最後のインデックスを取得することで実現されます。空であっても、AbstractRangeの終点を返します。

他にもfirst、endswithがあります。

例

julia> last(1:2:10)
9

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

front(x::Tuple)::Tuple

xの最後の要素を除いたすべての要素からなるTupleを返します。

参照: first, tail.

例

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

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

tail(x::Tuple)::Tuple

xの最初のコンポーネントを除くすべてのコンポーネントからなるTupleを返します。

関連情報: front, rest, first, Iterators.peel.

例

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

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

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

collect(iterator)

コレクションまたはイテレータ内のすべてのアイテムの Array を返します。辞書の場合、key=>value Pair の Vector を返します。引数が配列のようであるか、HasShape 特性を持つイテレータである場合、結果は引数と同じ形状および次元数になります。

comprehensions によって generator expression を Array に変換するために使用されます。したがって、ジェネレータに対して、角括弧の表記法を使用して collect を呼び出す代わりに使用できます。2番目の例を参照してください。

返される配列の要素型は、収集された値の型に基づいています。ただし、イテレータが空である場合、返される（空の）配列の要素型は型推論によって決定されます。

例

UnitRange{Int64} コレクションからアイテムを収集します：

julia> collect(1:3)
3-element Vector{Int64}:
 1
 2
 3

ジェネレータからアイテムを収集します（出力は [x^2 for x in 1:3] と同じです）：

julia> collect(x^2 for x in 1:3)
3-element Vector{Int64}:
 1
 4
 9

結果の型が型推論に依存する空のイテレータを収集します：

julia> [rand(Bool) ? 1 : missing for _ in []]
Union{Missing, Int64}[]

イテレータが空でない場合、結果の型は値のみに依存します：

julia> [rand(Bool) ? 1 : missing for _ in [""]]
1-element Vector{Int64}:
 1

collect(element_type, collection)

指定された要素型のコレクションまたはイテラブル内のすべてのアイテムを持つArrayを返します。結果はcollectionと同じ形状と次元数を持ちます。

例

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

filter(f, itr::SkipMissing{<:AbstractArray})

与えられた SkipMissing イテレータでラップされた配列に似たベクトルを返しますが、すべての欠損要素と f が false を返す要素は削除されます。

例

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

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

filter(f, d::AbstractDict)

dのコピーを返し、fがfalseである要素を削除します。関数fにはkey=>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)

関数 f を使用して引数をフィルタリングする関数を作成します。これは、x -> filter(f, x) に相当する関数です。

返される関数は Base.Fix1{typeof(filter)} 型であり、特化したメソッドを実装するために使用できます。

例

julia> (1, 2, Inf, 4, NaN, 6) |> filter(isfinite)
(1, 2, 4, 6)

julia> map(filter(iseven), [1:3, 2:4, 3:5])
3-element Vector{Vector{Int64}}:
 [2]
 [2, 4]
 [4]

filter(f, a)

コレクション a のコピーを返し、f が false の要素を削除します。関数 f には1つの引数が渡されます。

参照: filter!, Iterators.filter.

例

julia> a = 1:10
1:10

julia> filter(isodd, a)
5-element Vector{Int64}:
 1
 3
 5
 7
 9

filter!(f, d::AbstractDict)

dを更新し、fがfalseである要素を削除します。関数fにはkey=>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"

filter!(f, a)

コレクション a を更新し、f が false の要素を削除します。関数 f には1つの引数が渡されます。

例

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

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

コレクション A のコピーを返します。ここで、old_new の各ペア old=>new に対して、すべての old の出現が new に置き換えられます。等価性は isequal を使用して決定されます。count が指定されている場合、合計で最大 count 回の出現を置き換えます。

結果の要素型は、A の要素型とペアの new 値の型に基づいて昇格を使用して選択されます（promote_type を参照）。count が省略され、A の要素型が Union の場合、異なる型の値で置き換えられる単一型は結果の要素型に含まれません。たとえば、Union{T,Missing} は missing が置き換えられると T になります。

他にも replace!、splice!、delete!、insert! を参照してください。

例

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

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

replace(new::Union{Function, Type}, A; [count::Integer])

Aの各値xをnew(x)で置き換えたコピーを返します。countが指定されている場合、合計で最大countの値を置き換えます（置き換えはnew(x) !== xとして定義されます）。

例

julia> replace(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Vector{Int64}:
 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

replace!(new::Union{Function, Type}, A; [count::Integer])

コレクション A の各要素 x を new(x) で置き換えます。count が指定されている場合、合計で最大 count の値を置き換えます（置き換えは new(x) !== x と定義されます）。

例

julia> replace!(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Vector{Int64}:
 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

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

各ペア old=>new に対して、コレクション A 内の old のすべての出現を new に置き換えます。等価性は isequal を使用して決定されます。count が指定されている場合、合計で最大 count 回の出現を置き換えます。詳細は replace を参照してください。

例

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

julia> replace!(Set([1, 2, 3]), 1=>0)
Set{Int64} with 3 elements:
  0
  2
  3

Base.rest(collection[, itr_state])

特定のイテレーション状態 itr_state から始めて collection の末尾を取得するための汎用関数。collection 自体が Tuple の場合は Tuple を返し、collection が AbstractArray の場合は AbstractVector のサブタイプを返し、collection が AbstractString の場合は AbstractString のサブタイプを返し、それ以外の場合は任意のイテレーターを返し、Iterators.rest(collection[, itr_state]) にフォールバックします。

ユーザー定義のコレクションタイプに対してオーバーロードすることで、最終位置での スラープによる代入 の動作をカスタマイズできます。例えば、a, b... = collection のように。

参照: first, Iterators.rest, Base.split_rest.

例

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> first, state = iterate(a)
(1, 2)

julia> first, Base.rest(a, state)
(1, [3, 2, 4])

Base.split_rest(collection, n::Int[, itr_state]) -> (rest_but_n, last_n)

コレクションの末尾を特定のイテレーション状態 itr_state から分割するための汎用関数。2つの新しいコレクションのタプルを返します。最初のコレクションには末尾のすべての要素が含まれますが、n 個の最後の要素は含まれず、これが2番目のコレクションを構成します。

最初のコレクションの型は一般的に Base.rest の型に従いますが、フォールバックケースは遅延ではなく、ベクターに即座に収集されます。

ユーザー定義のコレクション型に対してオーバーロードすることができ、非最終位置での スラープによる代入 の動作をカスタマイズできます。例えば、a, b..., c = collection のように。

参照: Base.rest.

例

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> first, state = iterate(a)
(1, 2)

julia> first, Base.split_rest(a, 1, state)
(1, ([3, 2], [4]))

getindex(collection, key...)

指定されたキーまたはインデックス内のコレクションに格納されている値を取得します。構文 a[i,j,...] はコンパイラによって getindex(a, i, j, ...) に変換されます。

他にも get, keys, eachindex を参照してください。

例

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

julia> getindex(A, "a")
1

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

指定されたキーまたはインデックス内のコレクションに指定された値を格納します。構文 a[i,j,...] = x はコンパイラによって (setindex!(a, x, i, j, ...); x) に変換されます。

例

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

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

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

collectionの最初のインデックスを返します。dが指定されている場合は、次元dに沿ったcollectionの最初のインデックスを返します。

構文A[begin]およびA[1, begin]は、それぞれA[firstindex(A)]およびA[1, firstindex(A, 2)]に変換されます。

参照: first, axes, lastindex, nextind.

例

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

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

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

collectionの最後のインデックスを返します。dが指定されている場合は、次元dに沿ったcollectionの最後のインデックスを返します。

構文A[end]およびA[end, end]は、それぞれA[lastindex(A)]およびA[lastindex(A, 1), lastindex(A, 2)]に変換されます。

参照: axes, firstindex, eachindex, prevind.

例

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

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

AbstractDict{K, V}

キーの型が K で値の型が V の辞書のような型のスーパタイプです。 Dict、IdDict およびその他の型はこれのサブタイプです。 AbstractDict{K, V} は Pair{K, V} のイテレータであるべきです。

Dict([itr])

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

単一のイテラブル引数を与えると、引数によって生成された 2-タプル (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

IdDict([itr])

IdDict{K,V}() は、objectid をハッシュとして、=== を等価性として使用し、型 K のキーと型 V の値を持つハッシュテーブルを構築します。さらなるヘルプについては Dict を参照し、これのセットバージョンについては IdSet を参照してください。

以下の例では、Dict のキーはすべて isequal であり、したがって同じようにハッシュされ、上書きされます。IdDict はオブジェクトIDでハッシュされるため、3つの異なるキーを保持します。

例

julia> Dict(true => "yes", 1 => "no", 1.0 => "maybe")
Dict{Real, String} with 1 entry:
  1.0 => "maybe"

julia> IdDict(true => "yes", 1 => "no", 1.0 => "maybe")
IdDict{Any, String} with 3 entries:
  true => "yes"
  1.0  => "maybe"
  1    => "no"

WeakKeyDict([itr])

WeakKeyDict() は、キーがオブジェクトへの弱い参照であるハッシュテーブルを構築します。これにより、ハッシュテーブル内で参照されていても、オブジェクトはガーベジコレクトされる可能性があります。

さらなるヘルプについては Dict を参照してください。なお、Dict とは異なり、WeakKeyDict は挿入時にキーを変換しません。これは、キーオブジェクトが挿入前にどこにも参照されていなかったことを意味します。

また、WeakRef も参照してください。

ImmutableDict

ImmutableDictは、不変のリンクリストとして実装された辞書であり、多くの個別の挿入を通じて構築される小さな辞書に最適です。値を削除することはできませんが、同じキーで新しい値を挿入することで部分的に上書きしたり隠したりすることができます。

ImmutableDict(KV::Pair)

key => valueペアのためにImmutableDictに新しいエントリを作成します。

• (key => value) in dictを使用して、この特定の組み合わせがプロパティセットにあるかどうかを確認します。
• get(dict, key, default)を使用して、特定のキーに対する最新の値を取得します。

PersistentDict

PersistentDictは、ハッシュ配列マップトライとして実装された辞書で、永続性が必要な状況に最適です。各操作は前の辞書とは別の新しい辞書を返しますが、基盤となる実装は空間効率が良く、複数の別々の辞書間でストレージを共有することがあります。

PersistentDict(KV::Pair)

例

julia> dict = Base.PersistentDict(:a=>1)
Base.PersistentDict{Symbol, Int64} with 1 entry:
  :a => 1

julia> dict2 = Base.delete(dict, :a)
Base.PersistentDict{Symbol, Int64}()

julia> dict3 = Base.PersistentDict(dict, :a=>2)
Base.PersistentDict{Symbol, Int64} with 1 entry:
  :a => 2

haskey(collection, key) -> Bool

コレクションが指定された key に対するマッピングを持っているかどうかを判断します。

例

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

get(f::Union{Function, Type}, collection, key)

指定されたキーに対して保存されている値を返します。キーに対するマッピングが存在しない場合は、f()を返します。デフォルト値を辞書に保存するには、get!を使用してください。

これはdoブロック構文を使用して呼び出すことを意図しています。

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

get(collection, key, default)

指定されたキーに対して保存されている値を返すか、キーに対するマッピングが存在しない場合は指定されたデフォルト値を返します。

例

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

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

julia> get(d, "c", 3)
3

get!(f::Union{Function, Type}, collection, key)

指定されたキーに対して保存されている値を返します。キーに対するマッピングが存在しない場合は、key => f()を保存し、f()を返します。

これはdoブロック構文を使用して呼び出すことを意図しています。

例

julia> squares = Dict{Int, Int}();

julia> function get_square!(d, i)
           get!(d, i) do
               i^2
           end
       end
get_square! (generic function with 1 method)

julia> get_square!(squares, 2)
4

julia> squares
Dict{Int64, Int64} with 1 entry:
  2 => 4

get!(collection, key, default)

指定されたキーに対して保存されている値を返します。キーに対するマッピングが存在しない場合は、key => defaultを保存し、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

getkey(collection, key, default)

引数 key に一致するキーが collection に存在する場合はそのキーを返し、そうでない場合は 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)

delete!(collection, key)

コレクション内の指定されたキーに対するマッピングを削除し、コレクションを返します。

例

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

pop!(collection, key[, default])

collectionにkeyが存在する場合は、そのマッピングを削除して返します。存在しない場合は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

keys(iterator)

キーと値を持つイテレータまたはコレクション（例：配列や辞書）に対して、キーのイテレータを返します。

values(a::AbstractDict)

コレクション内のすべての値に対するイテレータを返します。collect(values(a))は値の配列を返します。値がハッシュテーブルに内部的に格納されている場合、Dictのように、返される順序は異なる場合があります。しかし、keys(a)、values(a)、およびpairs(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 Vector{Int64}:
 2
 3

values(iterator)

キーと値を持つイテレータまたはコレクションに対して、値のイテレータを返します。この関数はデフォルトで引数をそのまま返します。一般的なイテレータの要素は通常「値」と見なされるためです。

例

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

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

julia> values([2])
1-element Vector{Int64}:
 2

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

配列 A の各要素にアクセスするイテレータで、i => x を返します。ここで i は要素のインデックスで、x = A[i] です。pairs(A) と同じですが、インデックスのスタイルを選択できます。また、enumerate(A) に似ていますが、i は A の有効なインデックスであり、enumerate は常に1からカウントします。

IndexLinear() を指定すると、i は整数になります。IndexCartesian() を指定すると、i は Base.CartesianIndex になります。IndexStyle(A) を指定すると、配列 A のネイティブインデックススタイルとして定義されているものが選択されます。

基になる配列の境界を変更すると、このイテレータは無効になります。

例

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 を参照してください。

pairs(collection)

任意のコレクションに対して key => value ペアのイテレータを返します。これは、キーが配列のインデックスである配列を含みます。エントリが内部的にハッシュテーブルに格納されている場合、例えば Dict の場合、返される順序は異なる場合があります。しかし、keys(a)、values(a) および pairs(a) はすべて a を反復処理し、同じ順序で要素を返します。

例

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

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

julia> foreach(println, pairs(["a", "b", "c"]))
1 => "a"
2 => "b"
3 => "c"

julia> (;a=1, b=2, c=3) |> pairs |> collect
3-element Vector{Pair{Symbol, Int64}}:
 :a => 1
 :b => 2
 :c => 3

julia> (;a=1, b=2, c=3) |> collect
3-element Vector{Int64}:
 1
 2
 3

merge(initial::StyledStrings.Face, others::StyledStrings.Face...)

initial フェイスと others のプロパティをマージし、後のフェイスが優先されます。

これは、複数のフェイスのスタイルを組み合わせ、継承を解決するために使用されます。

merge(a::NamedTuple, iterable)

イテラブルなキー-バリューのペアを名前付きタプルとして解釈し、マージを実行します。

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

merge(a::NamedTuple, bs::NamedTuple...)

二つ以上の既存の名前付きタプルを左結合的にマージして新しい名前付きタプルを構築します。マージは、名前付きタプルのペア間で左から右へ進行し、最も左と最も右の名前付きタプルの両方に存在するフィールドの順序は、最も左の名前付きタプルで見つかった位置と同じになります。ただし、値はそのフィールドを含む最も右の名前付きタプルの一致するフィールドから取得されます。ペアの最も右の名前付きタプルにのみ存在するフィールドは、最後に追加されます。シグネチャ merge(a::NamedTuple) を持つ単一の名前付きタプルが供給された場合のフォールバックが実装されています。

例

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(d::AbstractDict, others::AbstractDict...)

与えられたコレクションからマージされたコレクションを構築します。必要に応じて、結果のコレクションの型はマージされたコレクションの型に合わせて昇格されます。同じキーが別のコレクションに存在する場合、そのキーの値は最後にリストされたコレクションにある値になります。同じキーを持つ値のカスタム処理については、mergewithも参照してください。

例

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

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

与えられたコレクションからマージされたコレクションを構築します。必要に応じて、結果のコレクションの型はマージされたコレクションの型に合わせて昇格されます。同じキーを持つ値は、コンバイナ関数を使用して結合されます。カリー化された形式 mergewith(combine) は、関数 (args...) -> mergewith(combine, args...) を返します。

メソッド merge(combine::Union{Function,Type}, args...) は、後方互換性のために mergewith(combine, args...) のエイリアスとしてまだ利用可能です。

例

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

julia> mergewith(-, Dict(), Dict(:a=>1))  # キーが両方に存在する場合のみ結合関数が使用される
Dict{Any, Any} with 1 entry:
  :a => 1

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

他のコレクションからペアを使ってコレクションを更新します。詳細は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

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

他のコレクションからのペアでコレクションを更新します。同じキーを持つ値は、コンバイナ関数を使用して結合されます。カリー形式の mergewith!(combine) は、関数 (args...) -> mergewith!(combine, args...) を返します。

メソッド merge!(combine::Union{Function,Type}, args...) は mergewith!(combine, args...) のエイリアスとして、後方互換性のためにまだ利用可能です。

例

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

sizehint!(s, n; first::Bool=false, shrink::Bool=true) -> s

コレクション s が少なくとも n 要素の容量を確保することを提案します。つまり、s に多くの値をプッシュする必要があると予想される場合、最初に一度だけ行うことで、段階的な再割り当てのコストを回避できます。これにより、パフォーマンスが向上する可能性があります。

first が true の場合、追加のスペースはコレクションの開始前に予約されます。この方法により、後続の pushfirst!（push! の代わりに）呼び出しが速くなる可能性があります。このキーワードを指定すると、コレクションが順序付けられていない場合や、pushfirst! がこのコレクションでサポートされていない場合にエラーが発生することがあります。

shrink=true（デフォルト）である場合、コレクションの現在の容量が n より大きい場合、コレクションの容量が減少する可能性があります。

詳細は resize! を参照してください。

パフォーマンスモデルに関するノート

sizehint! をサポートする型について、

1. push! および append! メソッドは、一般的に（ただし必ずしも必要ではありません）追加のストレージを事前に割り当てることがあります。Base に実装された型の場合、通常はそうであり、一般的な使用ケースに最適化されたヒューリスティックを使用します。
2. sizehint! はこの事前割り当てを制御することがあります。再度言いますが、通常は Base の型に対してこれを行います。
3. empty! は、この種の事前割り当てをサポートする型に対してほぼコストがかからず（O(1)）、非常に効率的です。

keytype(type)

辞書型のキータイプを取得します。eltypeと似た動作をします。

例

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

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

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

例

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

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

valtype(type)

辞書型の値の型を取得します。eltypeと似た動作をします。

例

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

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

配列の値の型を返します。これはeltypeと同じであり、主に辞書インターフェースとの互換性のために提供されています。

例

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

AbstractSet{T}

型 T の要素を持つ集合のような型のスーパタイプです。 Set、BitSet およびその他の型はこのサブタイプです。

Set{T} <: AbstractSet{T}

Setは、迅速なメンバーシップテストを提供する可変コンテナです。

Setは、in、union、intersectなどの集合演算の効率的な実装を持っています。Set内の要素は、要素のisequalの定義によって決定されるユニークなものです。Set内の要素の順序は実装の詳細であり、信頼することはできません。

参照: AbstractSet, BitSet, Dict, push!, empty!, union!, in, isequal

例

julia> s = Set("aaBca")
Set{Char} with 3 elements:
  'a'
  'c'
  'B'

julia> push!(s, 'b')
Set{Char} with 4 elements:
  'a'
  'b'
  'B'
  'c'

julia> s = Set([NaN, 0.0, 1.0, 2.0]);

julia> -0.0 in s # isequal(0.0, -0.0) is false
false

julia> NaN in s # isequal(NaN, NaN) is true
true

BitSet([itr])

与えられた反復可能オブジェクトによって生成された Int のソートされたセットを構築するか、空のセットを構築します。ビット文字列として実装されており、したがって密な整数セットのために設計されています。セットがスパースである場合（たとえば、非常に大きな整数をいくつか保持する場合）、代わりに Set を使用してください。

IdSet{T}([itr])
IdSet()

IdSet{T}() は、型 T の値に対して === を等価性として使用してセット（Set を参照）を構築します。

以下の例では、値はすべて isequal であるため、通常の Set では上書きされます。IdSet は === で比較するため、3つの異なる値を保持します。

例

julia> Set(Any[true, 1, 1.0])
Set{Any} with 1 element:
  1.0

julia> IdSet{Any}(Any[true, 1, 1.0])
IdSet{Any} with 3 elements:
  1.0
  1
  true

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

すべての引数からの異なる要素を含むオブジェクトを構築します。

最初の引数は、返されるコンテナの種類を制御します。これが配列である場合、要素が最初に現れる順序を維持します。

Unicode ∪ は、Julia REPLで \cup と書いてタブを押すことで入力でき、多くのエディタでも同様です。これは中置演算子であり、s ∪ itr のように使用できます。

他にも unique、intersect、isdisjoint、vcat、Iterators.flatten を参照してください。

例

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

julia> union([4 2 3 4 4], 1:3, 3.0)
4-element Vector{Float64}:
 4.0
 2.0
 3.0
 1.0

julia> (0, 0.0) ∪ (-0.0, NaN)
3-element Vector{Real}:
   0
  -0.0
 NaN

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

union!(s::IntDisjointSet{T}, x::T, y::T)

xを含む部分集合とyを含む部分集合を1つにマージし、新しい集合のルートを返します。

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

渡された集合のunionを構築し、結果でsを上書きします。配列の順序を維持します。

例

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

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

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

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

すべての引数に現れる要素を含む集合を構築します。

最初の引数は、返されるコンテナの種類を制御します。これが配列である場合、要素が最初に現れる順序を維持します。

Unicode ∩ は、Julia REPLで \cap と書いてからタブを押すことで入力できます。また、多くのエディタでも同様です。これは中置演算子であり、s ∩ itr のように使用できます。

他にも setdiff、isdisjoint、issubset、issetequal を参照してください。

例

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

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

julia> intersect(1:16, 7:99)
7:16

julia> (0, 0.0) ∩ (-0.0, 0)
1-element Vector{Real}:
 0

julia> intersect(Set([1, 2]), BitSet([2, 3]), 1.0:10.0)
Set{Float64} with 1 element:
  2.0

setdiff(s, itrs...)

sの要素のうち、itrsのいずれかに含まれない要素の集合を構築します。配列の順序を維持します。

setdiff!、union、およびintersectも参照してください。

例

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

setdiff!(s, itrs...)

セットsから、itrsの各イテラブルの各要素を（インプレースで）削除します。配列を使用して順序を維持します。

例

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

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

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

symdiff(s, itrs...)

渡された集合の要素の対称差を構築します。sがAbstractSetでない場合、順序は保持されます。

他にも symdiff!、setdiff、union および intersect を参照してください。

例

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

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

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

渡された集合の対称差を構築し、結果でsを上書きします。sが配列の場合、順序は保持されます。この場合、要素の重複が重要です。

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

渡されたすべての集合を交差させ、結果でsを上書きします。配列の順序を維持します。

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

aのすべての要素がbにも含まれているかどうかを判断します。 inを使用してください。

他にも⊊、⊈、∩、∪、containsがあります。

例

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

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

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

in!(x, s::AbstractSet) -> Bool

sにxが含まれている場合はtrueを返します。そうでない場合は、xをsに追加してfalseを返します。これはin(x, s) ? true : (push!(s, x); false)と同等ですが、より効率的な実装がされている可能性があります。

参照: in, push!, Set

例

julia> s = Set{Any}([1, 2, 3]); in!(4, s)
false

julia> length(s)
4

julia> in!(0x04, s)
true

julia> s
Set{Any} with 4 elements:
  4
  2
  3
  1

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

⊆ と ⊇ の否定、すなわち a が b の部分集合でないことをチェックします。

関連情報として issubset (⊆)、⊊ を参照してください。

例

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

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

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

aがbの部分集合であるが、等しくはないかどうかを判断します。

関連情報としてissubset (⊆)、⊈を参照してください。

例

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

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

issetequal(x)

引数を x と比較する関数を作成します issetequal を使用して、すなわち y -> issetequal(y, x) に相当する関数です。返される関数は Base.Fix2{typeof(issetequal)} 型であり、特化したメソッドを実装するために使用できます。

issetequal(a, b) -> Bool

a と b が同じ要素を持っているかどうかを判断します。a ⊆ b && b ⊆ a と同等ですが、可能な場合はより効率的です。

関連: isdisjoint, union.

例

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

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

isdisjoint(x)

引数を x と比較する関数を作成します。これは isdisjoint を使用し、すなわち y -> isdisjoint(y, x) と同等の関数です。返される関数は Base.Fix2{typeof(isdisjoint)} 型であり、特化したメソッドを実装するために使用できます。

isdisjoint(a, b) -> Bool

コレクション a と b が互いに素であるかどうかを判断します。isempty(a ∩ b) と同等ですが、可能な場合はより効率的です。

関連: intersect, isempty, issetequal.

例

julia> isdisjoint([1, 2], [2, 3, 4])
false

julia> isdisjoint([3, 1], [2, 4])
true

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

1つ以上のitemsをcollectionに挿入します。collectionが順序付きコンテナである場合、アイテムは最後に（指定された順序で）挿入されます。

例

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

collectionが順序付きである場合、append!を使用して別のコレクションのすべての要素を追加します。前の例の結果は、append!([1, 2, 3], [4, 5, 6])と同等です。AbstractSetオブジェクトの場合は、union!を代わりに使用できます。

パフォーマンスモデルに関する注意については、sizehint!を参照してください。

また、pushfirst!も参照してください。

pop!(collection, key[, default])

collectionにkeyが存在する場合は、そのマッピングを削除して返します。存在しない場合は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

pop!(collection) -> item

collectionからアイテムを削除し、それを返します。collectionが順序付きコンテナである場合、最後のアイテムが返されます。順序なしコンテナの場合は、任意の要素が返されます。

参照: popfirst!, popat!, delete!, deleteat!, splice!, および push!。

例

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

julia> pop!(A)
3

julia> A
2-element Vector{Int64}:
 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

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

指定された i のアイテムを削除し、それを返します。次のアイテムは、結果として生じる隙間を埋めるためにシフトされます。i が a の有効なインデックスでない場合、default を返すか、default が指定されていない場合はエラーをスローします。

関連項目: pop!, popfirst!, deleteat!, splice!.

例

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

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

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

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

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

コレクションの先頭に1つ以上のitemsを挿入します。

この関数は多くの他のプログラミング言語ではunshiftと呼ばれています。

例

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

popfirst!(collection) -> item

collectionから最初のitemを削除します。

この関数は多くの他のプログラミング言語ではshiftと呼ばれています。

参照: pop!, popat!, delete!.

例

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

julia> popfirst!(A)
1

julia> A
5-element Vector{Int64}:
 2
 3
 4
 5
 6

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

itemを指定されたindexでaに挿入します。indexは結果のaにおけるitemのインデックスです。

参照: push!, replace, popat!, splice!.

例

julia> insert!(Any[1:6;], 3, "here")
7-element Vector{Any}:
 1
 2
  "here"
 3
 4
 5
 6

deleteat!(a::Vector, inds)

inds で指定されたインデックスのアイテムを削除し、修正された a を返します。後続のアイテムは、結果として生じた隙間を埋めるためにシフトされます。

inds は、イテレータまたはソートされていてユニークな整数インデックスのコレクション、または a と同じ長さのブールベクターで、true が削除するエントリを示すことができます。

例

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

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

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

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

指定された i のアイテムを削除し、修正された a を返します。後続のアイテムは、結果として生じる隙間を埋めるためにシフトされます。

参照: keepat!, delete!, popat!, splice!.

例

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

keepat!(a::Vector, m::AbstractVector{Bool})
keepat!(a::BitVector, m::AbstractVector{Bool})

論理インデックスのインプレースバージョン a = a[m]。つまり、長さが等しいベクトル a と m に対して keepat!(a, m) を実行すると、対応するインデックスで m が false の a のすべての要素が削除されます。

例

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

julia> keepat!(a, [true, false, true])
2-element Vector{Symbol}:
 :a
 :c

julia> a
2-element Vector{Symbol}:
 :a
 :c

keepat!(a::Vector, inds)
keepat!(a::BitVector, inds)

inds で指定されていないすべてのインデックスのアイテムを削除し、修正された a を返します。保持されるアイテムは、結果の隙間を埋めるためにシフトされます。

inds は、ソートされていてユニークな整数インデックスのイテレータでなければなりません。詳細は deleteat! を参照してください。

例

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

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

指定されたインデックスでアイテムを削除し、削除されたアイテムを含むコレクションを返します。以降のアイテムは、結果として生じる隙間を埋めるために左にシフトされます。指定された場合、順序付きコレクションからの置換値が削除されたアイテムの代わりに挿入されます。この場合、indicesはAbstractUnitRangeでなければなりません。

アイテムを削除せずにインデックスnの前にreplacementを挿入するには、splice!(collection, n:n-1, replacement)を使用します。

例

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

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

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

指定されたインデックスのアイテムを削除し、削除されたアイテムを返します。以降のアイテムは、結果として生じた隙間を埋めるために左にシフトされます。指定された場合、順序付きコレクションからの置換値が削除されたアイテムの代わりに挿入されます。

参照: replace, delete!, deleteat!, pop!, popat!。

例

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

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

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

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

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

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

アイテムを削除せずにインデックス n の前に replacement を挿入するには、splice!(collection, n:n-1, replacement) を使用します。

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

aをn要素を含むようにサイズ変更します。nが現在のコレクションの長さより小さい場合、最初のn要素が保持されます。nが大きい場合、新しい要素が初期化されることは保証されません。

例

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

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

julia> length(a)
8

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

append!(collection, collections...) -> collection.

順序付きコンテナ collection に、各 collections の要素をその末尾に追加します。

例

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

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

個々のアイテムを collection に追加するには、push! を使用します。これらは他のコレクションに既に含まれていない必要があります。前の例の結果は push!([1, 2, 3], 4, 5, 6) と同等です。

パフォーマンスモデルに関する注意については、sizehint! を参照してください。

ベクトルについては vcat、集合については union!、逆順については prepend! と pushfirst! も参照してください。

prepend!(a::Vector, collections...) -> collection

各 collections の要素を a の先頭に挿入します。

collections が複数のコレクションを指定する場合、順序は維持されます： collections[1] の要素が a の最も左に表示され、その後に続きます。

例

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

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

Pair(x, y)
x => y

型 Pair{typeof(x), typeof(y)} の Pair オブジェクトを構築します。要素は first と second フィールドに格納されます。また、反復処理を通じてアクセスすることもできます（ただし、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

julia> replace.(["xops", "oxps"], "x" => "o")
2-element Vector{String}:
 "oops"
 "oops"

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

インデックス可能なコンテナを同じデータの辞書ビューに変換します。基になるデータのキー空間を変更すると、このオブジェクトが無効になる可能性があります。