集合和資料結構

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}

具有類型 T 元素的範圍的超類型。 UnitRange 和其他類型是此類型的子類型。

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

具有類型 T 元素和間距 (s) 類型為 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}

範圍由類型為 T 的 start 和 stop 參數化，從 start 開始，以 1 的間距填充元素，直到超過 stop。語法 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 控制，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

isempty(collection) -> Bool

判斷集合是否為空（沒有元素）。

範例

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

如果沒有工作在條件上等待，則傳回 true，否則傳回 false。

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

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

判斷一個項目是否在給定的集合中，意思是指它 == 迭代集合所產生的其中一個值。傳回 Bool 值，除非 item 是 missing 或 collection 包含 missing 但不包含 item，這種情況下會傳回 missing（三值邏輯，符合 any 和 == 的行為）。

有些集合遵循略微不同的定義。例如，Set 檢查項目 isequal 是否為其中一個元素；Dict 尋找 key=>value 對，並使用 isequal 比較 key。

若要測試字典中是否存在金鑰，請使用 haskey 或 k in keys(dict)。對於上述集合，結果永遠是 Bool。

當使用 in.(items, collection) 或 items .∈ collection 廣播時，item 和 collection 都會廣播，這通常不是預期結果。例如，如果兩個參數都是向量（且維度相符），結果會是一個向量，指出 collection 中的每個值在 items 中是否 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 進行廣播時，item 和 collection 都會進行廣播，這通常不是預期的結果。例如，如果兩個參數都是向量（且維度匹配），結果將是一個向量，表示 items 中的每個值是否不在 collection 中對應位置的值中。若要取得一個向量，表示 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

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 中的第一個索引，這些值是 b 的成員。輸出陣列包含 nothing，表示 a 不是 b 的成員。

另請參閱：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(itr)

傳回一個陣列，其中只包含集合 itr 的唯一元素，由 isequal 決定，依據每個等效元素組的第一個元素原本出現的順序。輸入的元素類型會被保留。

另請參閱：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(f, itr)

傳回一個陣列，其中包含 itr 的一個值，對應於 f 套用在 itr 元素上所產生的每個唯一值。

範例

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(A::AbstractArray; dims::Int)

傳回 A 沿著維度 dims 的唯一區域。

範例

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, A::AbstractVector)

從 A 中選擇一個值，對應於 f 套用在 A 元素上所產生的每個唯一值，然後傳回修改後的 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

unique!(A::AbstractVector)

移除由 isequal 判斷的重複項目，然後傳回修改後的 A。unique! 會傳回 A 中的元素，依據它們出現的順序。如果你不關心傳回資料的順序，則只要 A 的元素可以排序，呼叫 (sort!(A); unique!(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! is able to process sorted data much more efficiently.

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

allunique(itr) -> Bool

如果 itr 中的所有值在與 isequal 比較時都是不同的，則傳回 true。

另見：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

allequal(itr) -> Bool

如果 itr 中的所有值使用 isequal 進行比較時都相等，則傳回 true。

另見：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

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(*, [2; 3; 4]; init=-1)
-24

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

沿著 A 的維度還原 2 個引數的函數 f。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 將只會使用一次。一般來說，必須提供 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，將只會使用一次。通常，需要提供 init 才能與空集合搭配使用。

範例

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

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

maximum(f, itr; [init])

傳回呼叫 itr 中每個元素的函式 f 的最大結果。

可透過 init 指定空 itr 傳回的值。它必須是 max 的中立元素（即小於或等於任何其他元素），因為無法指定是否會將 init 用於非空集合。

範例

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

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

julia> maximum(sin, Real[]; init=-1.0)  # good, since output of sin is >= -1
-1.0

maximum(itr; [init])

傳回集合中的最大元素。

可透過 init 指定空 itr 傳回的值。它必須是 max 的中立元素（即小於或等於任何其他元素），因為無法指定是否會將 init 用於非空集合。

範例

julia> maximum(-20.5:10)
9.5

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

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

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

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(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!(r, A)

計算 A 在 r 的單一維度上的最大值，並將結果寫入 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, itr; [init])

傳回呼叫函數 f 於 itr 中每個元素的最小結果。

可透過 init 指定空 itr 傳回的值。它必須是 min 的中性元素（亦即大於或等於任何其他元素），因為未指定 init 是否用於非空集合。

範例

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

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

julia> minimum(sin, Real[]; init=1.0)  # good, since output of sin is <= 1
1.0

minimum(itr; [init])

傳回集合中的最小元素。

可透過 init 指定空 itr 傳回的值。它必須是 min 的中性元素（亦即大於或等於任何其他元素），因為未指定 init 是否用於非空集合。

範例

julia> minimum(-20.5:10)
-20.5

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

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

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

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(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!(r, A)

計算 A 在 r 的單例維度上的最小值，並將結果寫入 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(itr; [init]) -> (mn, mx)

在單次傳遞中計算最小值 mn 和最大值 mx 元素，並以 2 元組傳回。

可透過 init 指定空 itr 傳回的值。它必須是 2 元組，其第一和第二個元素分別是 min 和 max 的中性元素（亦即大於/小於或等於任何其他元素）。因此，當 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(f, itr; [init]) -> (mn, mx)

計算應用於 itr 中每個元素的 f 的最小值 mn 和最大值 mx，並將它們作為 2 元組傳回。僅對 itr 執行一次遍歷。

可透過 init 指定傳回給空 itr 的值。它必須是一個 2 元組，其第一和第二個元素分別是 min 和 max 的中性元素（即大於/小於或等於任何其他元素）。它用於非空集合。注意：這表示對於空 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))  # good, since -1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)

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, A::AbstractArray; dims) -> Array{Tuple}

計算應用於 A 給定維度中每個元素的 f 的最小值和最大值。

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(r::AbstractRange)

範圍可以有多個最大元素。在這種情況下，argmax 將傳回一個最大索引，但不一定是第一個。

argmax(f, domain)

傳回 domain 中 f(x) 達到最大值的 x 值。如果 f(x) 有多個最大值，則將找到第一個。

domain 必須是一個非空的迭代器。

值與 isless 比較。

另請參閱 argmin、findmax。

範例

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

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

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

argmin(r::AbstractRange)

範圍可能有多個最小元素。在這種情況下，argmin 會傳回一個最小索引，但未必是第一個。

argmin(f, domain)

從 domain 傳回一個值 x，使 f(x) 最小化。如果 f(x) 有多個最小值，則會找出第一個。

domain 必須是一個非空的迭代器。

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

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

傳回對偶值，一個在陪域中（f 的輸出），另一個在 domain 中（f 的輸入）對應值的索引，使 f(x) 最大化。如果有多個最大點，則會傳回第一個。

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)

findmax(itr) -> (x, index)

傳回集合 itr 的最大元素及其索引或金鑰。如果有多個最大元素，則會傳回第一個。值與 isless 比較。

另請參閱：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(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(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);;])

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

傳回共域中數值（f 的輸出）和 domain 中對應數值的索引（f 的輸入）的配對，使得 f(x) 最小化。如果有多個最小點，則會傳回第一個。

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)

findmin(itr) -> (x, index)

傳回集合 itr 的最小元素及其索引或鍵。如果有多個最小元素，則會傳回第一個。NaN 被視為小於所有其他值，但 missing 除外。

另請參閱：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(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(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);;])

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

對 itr 中每個元素呼叫函數 f，並對呼叫結果求和。

對於小於系統字元組大小的帶正負號整數，回傳類型為 Int；對於小於系統字元組大小的無正負號整數，回傳類型為 UInt。對於所有其他引數，會找到一個所有引數都提升到該類型的共用回傳類型。

可透過 init 指定空 itr 的回傳值。它必須是加法單位元（即零），因為未指定 init 是否用於非空集合。

範例

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; [init])

回傳集合中所有元素的總和。

對於小於系統字元組大小的帶正負號整數，回傳類型為 Int；對於小於系統字元組大小的無正負號整數，回傳類型為 UInt。對於所有其他引數，會找到一個所有引數都提升到該類型的共用回傳類型。

可透過 init 指定空 itr 的回傳值。它必須是加法單位元（即零），因為未指定 init 是否用於非空集合。

另請參閱：reduce、mapreduce、count、union。

範例

julia> sum(1:20)
210

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

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

傳回套用至 `itr` 中每個元素的 `f` 乘積。

對於小於系統字元組大小的帶正負號整數，回傳類型為 Int；對於小於系統字元組大小的無正負號整數，回傳類型為 UInt。對於所有其他引數，會找到一個所有引數都提升到該類型的共用回傳類型。

可透過 `init` 指定傳回空 `itr` 的值。它必須為乘法單位 (即一)，因為未指定 `init` 是否用於非空集合。

範例

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

prod(itr; [init])

傳回集合中所有元素的乘積。

對於小於系統字元組大小的帶正負號整數，回傳類型為 Int；對於小於系統字元組大小的無正負號整數，回傳類型為 UInt。對於所有其他引數，會找到一個所有引數都提升到該類型的共用回傳類型。

可透過 `init` 指定傳回空 `itr` 的值。它必須為乘法單位 (即一)，因為未指定 `init` 是否用於非空集合。

另請參閱：reduce、cumprod、any。

範例

julia> prod(1:5)
120

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

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(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!(r, A)

在 `r` 的單一維度上對 `A` 的元素進行相乘，並將結果寫入 `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，並在遇到 itr 中第一個 p 傳回 true 的項目時傳回 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 中沿著 r 的單元維度中是否有任何值為 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，並在遇到 itr 中第一個 p 傳回 false 的項目時傳回 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,] 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

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

傳回 string 中與 pattern 相符的次數。這等於呼叫 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,] A::AbstractArray; dims=:)

計算 A 中 f 在給定維度上傳回 true 的元素數量。

範例

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

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

對可迭代物件 c 的每個元素呼叫函式 f。對於多個可迭代物件引數，f 會逐元素呼叫，且在任何反覆運算器完成時停止反覆運算。

當不需要 f 的結果時，應使用 foreach 取代 map，例如在 foreach(println, array) 中。

範例

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, c...) -> collection

透過對每個元素套用 f 來轉換集合 c。對於多個集合引數，逐元素套用 f，並在其中任何一個耗盡時停止。

另請參閱 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, 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))  # iterates until 3rd is exhausted
3-element Vector{Float64}:
   2.0
  13.0
 102.0

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

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

透過將每個值從 val 轉換為 f(val) 來修改 dict。請注意，無法變更 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

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

還原的關聯性取決於實作。此外，某些實作可能會重複使用 f 的傳回值，以供在 itr 中多次出現的元素。改用 mapfoldl 或 mapfoldr 以保證左或右關聯性，並呼叫每個值的 f。

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

如同 mapreduce，但保證左關聯性，如同 foldl。如果提供，關鍵字引數 init 將會使用一次。一般而言，需要提供 init 才能處理空集合。

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

如同 mapreduce，但保證右關聯性，如同 foldr。如果提供，關鍵字引數 init 將會使用一次。一般而言，需要提供 init 才能處理空集合。

first(coll)

取得可迭代集合的第一個元素。傳回 AbstractRange 的開始點，即使它是空的。

另請參閱：only、firstindex、last。

範例

julia> first(2:2:10)
2

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

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(s::AbstractString, n::Integer)

取得由 s 的前 n 個字元組成的字串。

範例

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

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

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

last(coll)

取得已排序集合的最後一個元素，如果可以在 O(1) 時間內計算的話。這是透過呼叫 lastindex 來取得最後一個索引來完成的。傳回 AbstractRange 的終點，即使它是空的。

另請參閱 first、endswith。

範例

julia> last(1:2:10)
9

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

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(s::AbstractString, n::Integer)

取得由 s 的最後 n 個字元組成的字串。

範例

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

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

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

front(x::Tuple)::Tuple

傳回一個 Tuple，包含 x 的所有組成部分，但最後一個組成部分除外。

另請參閱：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

傳回一個 Tuple，包含 x 的所有組成部分，但第一個組成部分除外。

另請參閱：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(collection)

傳回集合或反覆運算器中所有項目的 Array。對於字典，傳回 Vector{Pair{KeyType, ValType}}。如果參數類似陣列或是有 HasShape 特質的反覆運算器，結果將與參數有相同的形狀和維度數。

由理解式使用來將產生器轉換成 Array。

範例

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

julia> [x^2 for x in 1:8 if isodd(x)]
4-element Vector{Int64}:
  1
  9
 25
 49

collect(element_type, collection)

傳回集合或可迭代物件中所有項目的 Array，其元素類型為給定類型。結果與 collection 有相同的形狀和維度數。

範例

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

filter(f, a)

傳回集合 a 的副本，移除 f 為 false 的元素。函式 f 傳入一個參數。

另請參閱：filter!、Iterators.filter。

範例

julia> a = 1:10
1:10

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

filter(f)

建立一個函式，使用 filter 以函式 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, 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, 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, a)

更新集合 a，移除 f 為 false 的元素。函數 f 傳入一個參數。

範例

julia> filter!(isodd, Vector(1:10))
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"

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

傳回集合 A 的副本，其中 old_new 中的每個對 old=>new，old 的所有出現都會被 new 取代。等號由 isequal 決定。如果指定 count，則總共最多取代 count 個出現。

結果的元素類型使用提升（請參閱 promote_type）根據 A 的元素類型和對中 new 值的類型進行選擇。如果省略 count 且 A 的元素類型為 Union，則結果的元素類型將不包含被不同類型值取代的單例類型：例如，如果取代 missing，則 Union{T,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 的副本，其中 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!(A, old_new::Pair...; [count::Integer])

對於 old_new 中的每對 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

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

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 開始，分割 collection 尾部的通用函數。傳回兩個新集合的元組。第一個集合包含尾部所有元素，除了最後 n 個元素，這些元素組成第二個集合。

第一個集合的類型通常遵循 Base.rest，但退回情況不是延遲的，而是急切地收集到向量中。

可為使用者定義的集合類型超載，以自訂在非最後位置中 slurping in assignments 的行為，例如 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，則傳回 collection 沿維度 d 的第一個索引。

語法 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，則傳回 collection 沿維度 d 的最後一個索引。

語法 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 雜湊鍵。

給定一個單一的可迭代參數，建構一個 Dict，其鍵值對取自參數產生的 2 元組 (key,value)。

範例

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。在下方的範例中，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)

在 ImmutableDict 中為 key => value 對建立新項目

• 使用 (key => value) in dict 來查看此特定組合是否在屬性設定中
• 使用 get(dict, key, default) 來擷取特定金鑰的最新值

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

傳回儲存在給定金鑰中的值，或在沒有金鑰對應時傳回 f()。使用 get! 也會將預設值儲存在字典中。

這旨在使用 do 區塊語法來呼叫

get(dict, key) do
    # default value calculated here
    time()
end

get!(collection, key, 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

get!(f::Union{Function, Type}, collection, 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

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

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 is left unchanged
Dict{String, Int64} with 1 entry:
  "a" => 1

pop!(collection, key[, 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(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

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 Vector{Int64}:
 2
 3

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 開始計算，不論 A 的索引為何。

指定 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 的配對。這包括陣列，其中鍵是陣列索引。

範例

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

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(a::NamedTuple, iterable)

將可迭代的鍵值對詮釋為命名元組，並執行合併。

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

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

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

建議集合 s 保留至少 n 個元素的容量。也就是說，如果您預期將必須將許多值推送到 s，您可以透過一次性預先執行此操作來避免遞增重新配置的成本；這可以提升效能。

另請參閱 resize!。

效能模型的注意事項

對於支援 sizehint! 的類型，

1. push! 和 append! 方法通常可以（但不需要）預先配置額外的儲存空間。對於在 Base 中實作的類型，它們通常會使用針對一般使用案例最佳化的啟發法來執行此操作。

2. sizehint! 可以控制此預先配置。同樣地，它通常會對 Base 中的類型執行此操作。

3. 對於支援此類預先配置的類型，empty! 幾乎沒有成本（且為 O(1)）。

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

傳回陣列的金鑰類型。這等於 keys(...) 結果的 eltype，主要是為了與字典介面相容而提供。

範例

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

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

keytype(type)

取得字典類型的金鑰類型。行為類似於 eltype。

範例

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

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

傳回陣列的值類型。這與 eltype 相同，主要是為了相容字典介面而提供。

範例

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

valtype(type)

取得字典類型的值類型。行為類似於 eltype。

範例

julia> valtype(Dict(Int32(1) => "foo"))
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。

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

建立一個物件，包含所有引數中所有相異的元素。

第一個引數控制傳回哪一種容器。如果這是一個陣列，它會維持元素第一次出現的順序。

Unicode ∪ 可以透過在 Julia REPL 中輸入 \cup 然後按 Tab 鍵來輸入，許多編輯器也支援。這是一個中綴運算子，允許 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::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 然後按 Tab 鍵來輸入，許多編輯器也支援。這是一個中綴運算子，允許 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

使用 in 判斷 a 的每個元素是否也在 b 中。

另請參閱 ⊊、⊈、∩、∪、contains。

範例

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

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

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

⊈(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 的子集，但不等於 b。

另請參閱 issubset (⊆)、⊈。

範例

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

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

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

在 collection 中插入一個或多個 items。如果 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) -> 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

pop!(collection, key[, 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

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

在 collection 的開頭插入一個或多個 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 插入 a 中的指定 index。index 是 item 在結果 a 中的索引。

另請參閱：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, 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

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:
[...]

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

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

邏輯索引 a = a[m] 的原地版本。亦即，在長度相等的向量 a 和 m 上的 keepat!(a, m) 會移除 a 中所有在對應索引處 m 為 false 的元素。

範例

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

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

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

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

使用 push! 將個別項目新增到 collection，這些項目本身不在其他集合中。前一個範例的結果等同於 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 物件，其類型為 Pair{typeof(x), typeof(y)}。這些元素儲存在 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"

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

將可編製索引的容器轉換為同一個資料的字典檢視。修改基礎資料的鍵值空間可能會使這個物件失效。