集合和数据结构

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}

类型 T 的步长为 oneunit(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 开始直到超过 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 控制，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

确定项目是否在给定集合中，从迭代集合生成的 value 中的某个值与它 == 的意义上说。返回一个 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 进行广播时，item 和 collection 都将在其上进行广播，这通常不是预期的结果。例如，如果两个参数都是向量（并且维度匹配），则结果将是一个向量，指示集合 items 中的每个值是否在 collection 中对应位置的值中。要获得一个向量，指示 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 中每个在 b 中的值的第一个索引。输出数组在 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(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 中的每个值，对应于对 itr 的元素应用 f 生成的每个唯一值。

示例

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 中选择一个值，对应于对 A 的元素应用 f 生成的每个唯一值，然后返回修改后的 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 的元素。如果您不关心返回数据的顺序，则调用 (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! 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 未指定。

对于空集合，除了某些特殊情况（例如，当 op 是 +、*、max、min、&、| 中的一个时，Julia 可以确定 op 的中性元素）之外，提供 init 是必要的。

某些常用运算符的归约可能具有特殊的实现，应使用它们代替：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 的最大结果。

对于空 itr 返回的值可以通过 init 指定。它必须是 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])

返回集合中的最大元素。

对于空 itr 返回的值可以通过 init 指定。它必须是 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])

返回对 itr 中的每个元素调用函数 f 的最小结果。

对于空 itr 返回的值可以通过 init 指定。它必须是 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])

返回集合中的最小元素。

对于空 itr 返回的值可以通过 init 指定。它必须是 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 元组返回。

itr 为空时返回的值可以通过 init 指定。它必须是一个二元组，其第一个和第二个元素分别是 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)

计算 f 应用于 itr 中每个元素的最小值 mn 和最大值 mx，并将它们作为二元组返回。itr 只进行一次遍历。

itr 为空时返回的值可以通过 init 指定。它必须是一个二元组，其第一个和第二个元素分别是 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}

计算 f 应用于 A 给定维度中的每个元素的最小值和最大值。

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 中的值 x，其中 f(x) 被最大化。如果 f(x) 有多个最大值，那么将找到第一个值。

domain 必须是非空的 iterable。

值使用 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 必须是非空的 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(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 的输出）的值和对应值的索引（f 的输入）对，使得 f(x) 被最大化。如果有多个最大点，则返回第一个点。

domain 必须是非空的 iterable。

值使用 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 的输出）的值和对应值的索引（f 的输入）对，使得 f(x) 被最小化。如果有多个最小点，则返回第一个点。

domain 必须是非空的 iterable。

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

将函数 f 对 itr 中每个元素的调用结果求和。

对于小于系统字长的有符号整数，返回类型为 Int；对于小于系统字长的无符号整数，返回类型为 UInt。对于所有其他参数，找到一个所有参数都被提升到的公共返回类型。

itr 为空时返回的值可以通过 init 指定。它必须是加法单位元（即零），因为它未指定 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。对于所有其他参数，找到一个所有参数都被提升到的公共返回类型。

itr 为空时返回的值可以通过 init 指定。它必须是加法单位元（即零），因为它未指定 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])

返回 f 应用于 itr 中每个元素的结果的乘积。

对于小于系统字长的有符号整数，返回类型为 Int；对于小于系统字长的无符号整数，返回类型为 UInt。对于所有其他参数，找到一个所有参数都被提升到的公共返回类型。

itr 为空时返回的值可以通过 init 指定。它必须是乘法单位元（即一），因为它未指定 init 是否用于非空集合。

示例

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

prod(itr; [init])

返回集合中所有元素的乘积。

对于小于系统字长的有符号整数，返回类型为 Int；对于小于系统字长的无符号整数，返回类型为 UInt。对于所有其他参数，找到一个所有参数都被提升到的公共返回类型。

itr 为空时返回的值可以通过 init 指定。它必须是乘法单位元（即一），因为它未指定 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)

将 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 值，则如果所有非 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 值，则如果所有非 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 值，则如果所有非 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 值，则如果所有非 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

计算itr中函数f返回true的元素个数。如果省略f，则计算itr中true元素的个数（itr应该是一个布尔值集合）。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))

通过将dict中的每个值从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])

对itrs中的每个元素(s)应用函数f，然后使用二元函数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中多次出现的元素。如果要保证左结合性或右结合性，并且要为每个值调用f，请使用mapfoldl或mapfoldr。

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，该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，该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，该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次出现。

结果的元素类型是使用基于A的元素类型以及对中的new值的类型的提升（参见promote_type）来选择的。如果省略了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])

用于获取collection从特定迭代状态itr_state开始的尾部的通用函数。如果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)

用于拆分collection从特定迭代状态itr_state开始的尾部的通用函数。返回两个新集合的元组。第一个集合包含尾部的所有元素，但最后n个元素除外，它们构成第二个集合。

第一个集合的类型通常与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，则返回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)

返回为给定键存储的值，如果不存在该键的映射，则存储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

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

getkey(collection, key, default)

如果在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])

删除并返回key 的映射（如果存在于collection 中），否则返回default，或者如果未指定default，则抛出错误。

示例

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

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

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

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

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

确定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

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

删除并返回key 的映射（如果存在于collection 中），否则返回default，或者如果未指定default，则抛出错误。

示例

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

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

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

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

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)

在给定index处将item插入到a中。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

删除指定索引处的项目，并返回包含已删除项目的集合。后续项目将向左移位以填补由此产生的间隙。如果指定了，则来自有序集合的替换值将被拼接到已删除项目的位

要在不删除任何项目的情况下在索引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{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"

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

将可索引容器转换为相同数据的字典视图。修改基础数据的键空间可能会使此对象失效。