收集和数据结构

迭代

顺序迭代由 迭代功能。将军 为 循环:

for i in iter   # or  "for i = iter"
    # body
end

被翻译成:

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

该 国家 对象可以是任何东西，并且应该为每个可迭代类型适当地选择。查看迭代接口上的手册部分有关定义自定义可迭代类型的更多详细信息。

# *`基地。迭代`*-函数

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

推进迭代器以获得下一个元素。如果没有元素保留, 什么都没有 应归还。否则，应返回下一个元素和新迭代状态的2元组。

# *`基地。迭代器大小`*-类型

IteratorSize(itertype::Type) -> IteratorSize

给定迭代器的类型，返回以下值之一:

* 大名鼎鼎() 如果不能预先确定长度（元素数量）。 * 长() 如果有一个固定的，有限的长度。 * 哈斯夏普{N}() 如果有一个已知的长度加上一个多维形状的概念（如数组）。在这种情况下 N 应该给出维度的数量，并且 轴心函数对迭代器有效。 * IsInfinite() 如果迭代器永远产生值。

默认值（对于未定义此函数的迭代器）为 长(). 这意味着大多数迭代器被假定为实现 长度.

此特性通常用于在为结果预先分配空间的算法和以增量方式调整结果大小的算法之间进行选择。

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

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

# *`基地。迭代器类型`*-类型

IteratorEltype(itertype::Type) -> IteratorEltype

给定迭代器的类型，返回以下值之一:

* 埃尔特皮尤知() 如果迭代器产生的元素类型事先不知道。 * HasEltype() 如果元素类型是已知的，并且 eltype,eltype将返回一个有意义的值。 HasEltype() 是默认值，因为迭代器被假定为实现 eltype,eltype.

此特征通常用于在预先分配特定类型结果的算法和根据产生值的类型选择结果类型的算法之间进行选择。

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

全面实施:

* 抽象,抽象 * 单位范围 * 元组 * 电话号码 * 抽象阵列 * 比特集 * IdDict * Dict,Dict * 弱者,弱者 * 每行 * 抽象字符串 * 套装 * 对 * 命名的,命名的

构造函数和类型

# *`基地。抽象,抽象`*-类型

AbstractRange{T} <: AbstractVector{T}

具有类型元素的线性范围的超类型 T. 单位范围, 林兰格和其他类型是此的子类型。

所有子类型都必须定义 步骤. 因此 罗格兰奇不是 抽象,抽象.

# *`基地。普通范围`*-类型

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

具有类型元素的序数范围的超类型 T 与类型的间距 S. 步骤应该总是精确的倍数 一个单位，和 T 应为"离散"类型，其值不能小于 一个单位. 例如, 整数 或 日期 类型将符合条件，而 漂浮64 不会（因为这种类型可以表示小于 一单元(Float64). 单位范围, 步长,步长，而其他类型是此的子类型。

# *`基地。N.抽象,抽象`*-类型

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

步长为 一个单位(T)与类型的元素 T. 单位范围和其他类型是此的子类型。

# *`基地。步长,步长`*-类型

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

具有类型元素的范围 T 与类型的间距 S. 每个元素之间的步长是恒定的，并且范围以a来定义 开始 和 停止 类型 T 和一个 步骤 类型 S. 都不是 T 也没有 S 应该是浮点类型。语法 a：b：c 与 乙！= 0 和 a, b，而 c 所有整数创建一个 步长,步长.

*例子*

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，填充有由 1 从 开始 直到 停止 被超过。语法 a：b 与 a 和 b 两者兼而有之 整数s创建一个 单位范围.

*例子*

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}

范围与 伦 其之间的线性间隔的元件 开始 和 停止. 间距的大小由 伦，这必须是一个 整数.

*例子*

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

与使用相比 范围，直接构造一个 林兰格 应该有更少的开销，但不会尝试纠正浮点错误:

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

回来吧 真的 如果条件下没有任务正在等待, 错误 否则。

isempty(collection) -> Bool

确定集合是否为空（没有元素）。

警告 isempty(itr) 可能会消耗有状态迭代器的下一个元素 itr 除非适当的 基地。伊斯多内(itr)方法来定义。有状态迭代器_should_实现 伊斯多内，但您可能希望避免使用 [医]空位 在编写应该支持任何迭代器类型的泛型代码时。

*例子*

julia> isempty([])
true

julia> isempty([1 2 3])
false

# *`基地。伊斯多内`*-函数

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

此函数为迭代器完成提供快速路径提示。这对于有状态迭代器非常有用，这些迭代器希望避免在元素不暴露给用户的情况下消耗元素（例如，在检查done-ness时 [医]空位 或 拉链).

想要选择使用此功能的有状态迭代器应该定义一个 伊斯多内 根据迭代器是否完成返回true/false的方法。无状态迭代器不需要实现此功能。

如果结果是 失踪，呼叫者可以继续计算 iterate(x,state)===无 来计算一个明确的答案。

请参阅 迭代, [医空位]

# *`基地。空！`*-函数

empty!(c::Channel)

清空通道 c 通过调用 空！ 在内部缓冲器上。返回空通道。

empty!(collection) -> collection

从a中删除所有元素 收集资料.

*例子*

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,lastindex获取可索引集合的最后一个有效索引。

请参阅: 大小, ndims, 每个索引.

*例子*

julia> length(1:5)
5

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

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

# *`基地。检查_长度`*-函数

Base.checked_length(r)

计算方法 长度(r)，但可能会检查溢出错误在适用的情况下，当结果不适合 工会{Integer(eltype(r)),Int}.

全面实施:

* 抽象,抽象 * 单位范围 * 元组 * 电话号码 * 抽象阵列 * 比特集 * IdDict * Dict * 弱者,弱者 * 抽象字符串 * 套装 * 命名的,命名的

可迭代集合

# *`Base.in`*-函数

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

确定一个项目是否在给定的集合中，因为它是 ==到迭代集合生成的值之一。可以等价地与中缀语法一起使用:

item in collection
item ∈ collection

返回a 布尔 值，除非 项目 是 失踪或 收集资料 包含 失踪 但不是 项目，在这种情况下 失踪 被返回（https://en.wikipedia.org/wiki/Three-valued_logic[三值逻辑]，匹配的行为 任何和 ==). 有些集合遵循略有不同的定义。例如, 套装我们检查该项目是否 等效;等效到元素之一; Dict,Dict`我们找找 `+键⇒值+ 对，和 钥匙 是使用比较 xref:base/base.adoc#Base.isequal[等效;等效.

要测试字典中是否存在键，请使用 哈斯基或 k键(dict). 对于上面提到的集合，结果总是一个 布尔.

当广播与 在。(物品、收藏) 或 物品。∈集合，两者兼而有之 项目 和 收集资料 被广播过来，这通常不是预期的。例如，如果两个参数都是向量（并且维度匹配），则结果是一个向量，指示集合中的每个值是否 项目 是 在 中的相应位置处的值 收集资料. 得到一个向量，指示每个值是否在 项目 是在 收集资料,包装 收集资料 在元组或 参考书 像这样: 在。(项目,Ref(收集)) 或 物品。∈Ref(收集).

请参阅: ∉, [医], 包含, 发生,发生, 伊苏布塞特.

*例子*

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

julia> 4 in a
true

julia> 5 in a
false

julia> missing in [1, 2]
missing

julia> 1 in [2, missing]
missing

julia> 1 in [1, missing]
true

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

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

否定的 ∈ 和 ∋，即检查 项目 不在 收集资料.

当广播与 物品。∉集合，两者兼而有之 项目 和 收集资料 被广播过来，这通常不是预期的。例如，如果两个参数都是向量（并且维度匹配），则结果是一个向量，指示集合中的每个值是否 项目 不在相应位置的值中 收集资料. 得到一个向量，指示每个值是否在 项目 不在 收集资料,包装 收集资料 在元组或 参考书 像这样: 物品。∉Ref(收集).

*例子*

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

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

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

# *`基地。哈斯法斯汀`*-函数

Base.hasfastin(T)

确定是否计算 x元集合 哪里 收藏::T 可以被认为是"快速"操作（典型地是常数或对数复杂度）。定义 hasfastin（x）=hasfastin（typeof（x）） 是为了方便而提供的，以便可以传递实例而不是类型。但是，应该为新类型定义接受类型参数的表单。

默认值为 哈斯法斯汀(T) 是 真的 对于亚型的 抽象集,抽象集, 摘要;摘要和 抽象,抽象和 错误 否则。

# *`基地。eltype,eltype`*-函数

eltype(type)

确定通过迭代给定的集合生成的元素的类型 类型. 对于字典类型，这将是一个 对{KeyType,ValType}. 定义 eltype(x)=eltype(typeof(x)) 是为了方便而提供的，以便可以传递实例而不是类型。但是，应该为新类型定义接受类型参数的表单。

请参阅: 密钥类型, 类型；类型.

*例子*

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

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

# *`基地。索引,索引`*-函数

indexin(a, b)

返回包含第一个索引的数组 b 对于每个值在 a 那是…… b. 输出数组包含 什么都没有 无论在哪里 a 不是 b.

请参阅: 鹿sortperm, [医芬迪斯特].

*例子*

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

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

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

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

# *`基地。独特的`*-函数

unique(A::AbstractArray; dims::Int)

返回的独特区域 A 沿尺寸 暗淡无光.

*例子*

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

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

茱莉亚>独特(A)
2元素向量{Bool}:
 1
 0

julia>唯一(A,dims=2)
2×1×2阵列{Bool, 3}:
[:, :, 1] =
 1
 0

[:, :, 2] =
 1
 0

julia>唯一(A,dims=3)
2×2×1阵列{Bool, 3}:
[:, :, 1] =
 1  1
 0  0

unique(f, itr)

返回一个包含一个值的数组 itr 对于由产生的每个唯一值 f 应用于 itr.

*例子*

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

此功能还可用于提取数组中唯一元素首次出现的_indices_:

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

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

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

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

unique(itr)

返回一个仅包含集合的唯一元素的数组 itr，由 等效;等效和 哈希，以每组等价元素中的第一个最初出现的顺序。将保留输入的元素类型。

请参阅: 独一无二！, 阿鲁尼克, allequal.

*例子*

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

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

# *`基地。独一无二！`*-函数

unique!(A::AbstractVector)

删除由 等效;等效和 哈希，则返回修改后的 A. 独一无二！ 将返回的元素 A 按照它们发生的顺序。如果不关心返回数据的顺序，则调用 （排序！(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

unique!(f, A::AbstractVector)

从中选择一个值 A 对于由产生的每个唯一值 f 应用于 A，则返回修改后的A。

兼容性

Julia1.1此方法自Julia1.1起可用。

*例子*

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

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

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

# *`基地。阿鲁尼克`*-函数

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

回来吧 真的 如果所有值从 itr 与之相比，它们是不同的 等效;等效. 或者如果所有的 [itr中x的f(x)] 是不同的，对于第二种方法。

请注意 allunique(f,itr) 可以打电话 f 少于 长度(itr) 时代。调用的精确数量被视为实现细节。

阿鲁尼克 可以在输入排序时使用专门的实现。

请参阅: 独特的, issorted, allequal.

兼容性

Julia1.11方法 allunique(f,itr) 至少需要Julia1.11。

*例子*

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

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

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

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

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

# *`基地。allequal`*-函数

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

回来吧 真的 如果所有值从 itr 与……相比相等 等效;等效. 或者如果所有的 [itr中x的f(x)] 是相等的，对于第二种方法。

请注意 allequal(f,itr) 可以打电话 f 少于 长度(itr) 时代。调用的精确数量被视为实现细节。

请参阅: 独特的, 阿鲁尼克.

兼容性

朱莉娅1.8 allequal 函数至少需要Julia1.8。

兼容性

Julia1.11方法 allequal(f,itr) 至少需要Julia1.11。

*例子*

julia> allequal([])
true

julia> allequal([1])
true

julia> allequal([1, 1])
true

julia> allequal([1, 2])
false

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

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

# *`基地。减少`*-Method

reduce(op, itr; [init])

减少给定的集合 itr 与给定的二进制运算符 op的. 如果提供，初始值 初始化 必须是中性元素 op的 这将返回空集合。未指明是否 初始化 用于非空集合。

对于空集合，提供 初始化 将是必要的，除了一些特殊情况（例如，当 op的 是…… +, *, 麦克斯, 敏, &, |）当朱莉娅可以确定的中性元素 op的.

某些常用运算符的减少可能有特殊的实现，应该改为使用: 最大值(itr), 最低限额(itr), 总和(itr), prod,prod(itr), 任何(itr), 全部(itr). 有一些有效的方法可以通过调用来连接数组的某些数组减少(``vcat的,arr) 或减少(``hcat,hcat,arr).

减少的关联性取决于实现。这意味着你不能使用非关联操作，如 - 因为未定义是否 减少(-,[1,2,3]) 应评价为 (1-2)-3 或 1-(2-3). 使用方法 福尔德尔或 [医福尔德]而不是保证左或右结合性。

一些操作累积误差。如果减少可以分组执行，并行性会更容易。 Julia的未来版本可能会改变算法。请注意，如果使用有序集合，元素不会重新排序。

*例子*

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

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

# *`基地。减少`*-Method

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

减少2参数函数 f 沿尺寸 A. 暗淡无光 是一个向量，指定要减少的维度和关键字参数 初始化 是在减少中使用的初始值。为 +, *, 麦克斯 和 敏 该 初始化 参数是可选的。

减少的关联性取决于实现;如果您需要特定的关联性，例如从左到右，您应该编写自己的循环或考虑使用 福尔德尔或 [医福尔德]. 请参阅以下文档 减少.

*例子*

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

# *`基地。福尔德尔`*-Method

foldl(op, itr; [init])

像 减少，但具有保证的左结合性。如果提供，关键字参数 初始化 将使用一次。在一般情况下，这将是必要的提供 初始化 使用空集合。

请参阅 地图折叠, [医福尔德], 累积.

*例子*

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)

# *`基地。[医]福尔德`*-Method

foldr(op, itr; [init])

像 减少，但有保证正确的结合性。如果提供，关键字参数 初始化 将使用一次。一般来说，有必要提供 初始化 使用空集合。

*例子*

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

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

# *`基地。最大值`*-函数

maximum(f, A::AbstractArray; dims)

通过调用函数计算最大值 f 在给定维度上的数组的每个元素上。

*例子*

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

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

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

maximum(A::AbstractArray; dims)

计算给定维度上数组的最大值。请参阅 最大(a,b)函数最多取两个或多个参数，可以通过以下方式将其应用于数组 麦克斯（a，b）.

请参阅: 最大！, 极值,极值, 最大,最大, 阿尔马克斯.

*例子*

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

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

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

maximum(itr; [init])

返回集合中最大的元素。

为空返回的值 itr 可以通过指定 初始化. 它必须是一个中性元素 麦克斯 （即它小于或等于任何其他元素），因为它是未指定的 初始化 用于非空集合。

兼容性

Julia1.6关键字参数 初始化 需要Julia1.6或更高版本。

*例子*

julia> maximum(-20.5:10)
9.5

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

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

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

maximum(f, itr; [init])

返回调用函数的最大结果 f 在每个元素 itr.

兼容性

Julia1.6关键字参数 初始化 需要Julia1.6或更高版本。

*例子*

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

通过调用函数计算最小值 f 在给定维度上的数组的每个元素上。

*例子*

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

julia>最小值（abs2，A，dims=1）
1×2矩阵{Int64}:
 1  4

julia>最小值（abs2，A，dims=2）
2×1矩阵{Int64}:
 1
 9

minimum(A::AbstractArray; dims)

计算给定维度上数组的最小值。请参阅 最小(a,b)函数取两个或更多参数的最小值，可以通过以下方式将其按元素应用于数组 敏。（a，b）.

请参阅: 最低！, 极值,极值, 芬德明, 阿尔敏.

*例子*

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

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

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

minimum(itr; [init])

返回集合中最小的元素。

为空返回的值 itr 可以通过指定 初始化. 它必须是一个中性元素 敏 (即大于或等于任何其他元素)，因为是否未指明 初始化 用于非空集合。

兼容性

Julia1.6关键字参数 初始化 需要Julia1.6或更高版本。

*例子*

julia> minimum(-20.5:10)
-20.5

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

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

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

minimum(f, itr; [init])

返回调用函数的最小结果 f 在每个元素 itr.

为空返回的值 itr 可以通过指定 初始化. 它必须是一个中性元素 敏 (即大于或等于任何其他元素)，因为是否未指明 初始化 用于非空集合。

兼容性

Julia1.6关键字参数 初始化 需要Julia1.6或更高版本。

*例子*

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

计算的最小值和最大值 f 应用于给定尺寸的每个元素 A.

兼容性

Julia1.2此方法需要Julia1.2或更高版本。

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

计算给定维度上数组的最小和最大元素。

请参阅: 最低限额, 最大值, 极值！.

*例子*

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

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

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

[:, :, 2] =
 (9, 15)

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

计算最小值 锰,锰 和最大 mx 的 f 应用于 itr 并将它们作为2元组返回。只有一个通行证 itr.

为空返回的值 itr 可以通过指定 初始化. 它必须是一个2元组，其第一个和第二个元素是中性元素。 敏 和 麦克斯 分别（即大于/小于或等于任何其他元素）。它用于非空集合。注意：它意味着，对于空 itr，返回值 (mn,mx) 满足 mn≥mx 即使对于非空 itr 它满足 mn≤mx. 这是一个"自相矛盾"但尚未预期的结果。

兼容性

Julia1.2此方法需要Julia1.2或更高版本。

兼容性

Julia1.8关键字参数 初始化 需要Julia1.8或更高版本。

*例子*

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

计算最小值 锰,锰 和最大 mx 元素在一个单一的传递,并返回他们作为一个2元组.

为空返回的值 itr 可以通过指定 初始化. 它必须是一个2元组，其第一个和第二个元素是中性元素。 敏 和 麦克斯 分别（即大于/小于或等于任何其他元素）。因此，当 itr 返回的是空的 (mn,mx) 元组将满足 mn≥mx. 何时 初始化 指定它甚至可以用于非空 itr.

兼容性

Julia1.8关键字参数 初始化 需要Julia1.8或更高版本。

*例子*

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

朱莉娅>极值([9,pi,4.5])
(3.141592653589793, 9.0)

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

# *`基地。极值！`*-函数

extrema!(r, A)

计算的最小值和最大值 A 在单例维度 r，并将结果写入 r.

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。

兼容性

Julia1.8此方法需要Julia1.8或更高版本。

*例子*

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

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

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

# *`基地。阿尔马克斯`*-函数

argmax(A; dims) -> indices

对于数组输入，返回给定维度上最大元素的索引。 南 被视为大于除 失踪.

*例子*

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

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

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

argmax(itr)

返回集合中最大元素的索引或键。如果有多个最大元素，那么将返回第一个。

集合不能为空。

索引的类型与返回的索引的类型相同 钥匙(itr)和 对(itr).

值与 无障碍.

请参阅: 阿尔敏, 最大,最大.

*例子*

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

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

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

argmax(f, domain)

返回值 x 从 域名 为其 f(x) 被最大化。如果有多个最大值 f(x) 然后会找到第一个。

域名 必须是非空的可迭代。

值与 无为.

兼容性

Julia1.7此方法需要Julia1.7或更高版本。

请参阅 阿尔敏, 最大,最大.

*例子*

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

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

argmax(r::AbstractRange)

范围可以有多个最大元素。那样的话 阿尔马克斯 将返回一个最大索引，但不一定是第一个。

# *`基地。阿尔敏`*-函数

argmin(A; dims) -> indices

对于数组输入，返回给定维度上最小元素的索引。 南 被视为小于除 失踪.

*例子*

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

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

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

argmin(itr)

返回集合中最小元素的索引或键。如果有多个最小元素，那么将返回第一个。

集合不能为空。

索引的类型与返回的索引的类型相同 钥匙(itr)和 对(itr).

南 被视为小于除 失踪.

请参阅: 阿尔马克斯, 芬德明.

*例子*

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

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

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

argmin(f, domain)

返回值 x 从 域名 为其 f(x) 被最小化。如果有多个最小值 f(x) 然后会找到第一个。

域名 必须是非空的可迭代。

南 被视为小于除 失踪.

兼容性

Julia1.7此方法需要Julia1.7或更高版本。

请参阅 阿尔马克斯, 芬德明.

*例子*

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

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

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

argmin(r::AbstractRange)

范围可以有多个最小元素。那样的话 阿尔敏 将返回一个最小索引，但不一定是第一个。

# *`基地。最大,最大`*-函数

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

对于数组输入，返回最大化的相应值的codomain和索引中的值 f 在给定的尺寸上。

*例子*

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

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

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

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

对于数组输入，返回给定维度上最大值的值和索引。 南 被视为大于除 失踪.

*例子*

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

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

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

findmax(itr) -> (x, index)

返回集合的最大元素 itr 及其索引或密钥。如果有多个最大元素，那么将返回第一个。值与 无障碍.

索引的类型与返回的索引的类型相同 钥匙(itr)和 对(itr).

请参阅: 芬德明, 阿尔马克斯, 最大值.

*例子*

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

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

朱莉娅>findmax（[1，7，7，NaN]）
（南，4）

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

返回codomain中的一对值（输出 f）和相应值的索引或键在 域名 （输入到 f）这样 f(x) 被最大化。如果有多个极大值点，那么将返回第一个。

域名 必须是非空的可迭代支持 钥匙. 索引的类型与返回的索引的类型相同 密钥(域).

值与 无为.

兼容性

Julia1.7此方法需要Julia1.7或更高版本。

*例子*

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

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

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

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

# *`基地。芬德明`*-函数

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

对于数组输入，返回最小化的相应值的codomain和索引中的值 f 在给定的尺寸上。

*例子*

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

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

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

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

对于数组输入，返回给定维度上最小值的值和索引。 南 被视为小于除 失踪.

*例子*

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

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

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

findmin(itr) -> (x, index)

返回集合的最小元素 itr 及其索引或密钥。如果有多个最小元素，那么将返回第一个。 南 被视为小于除 失踪.

索引的类型与返回的索引的类型相同 钥匙(itr)和 对(itr).

请参阅: 最大,最大, 阿尔敏, 最低限额.

*例子*

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

朱莉娅>findmin([1, 7, 7, 6])
(1, 1)

朱莉娅>findmin（[1，7，7，NaN]）
（南，4）

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

返回codomain中的一对值（输出 f）和相应值的索引或键在 域名 （输入到 f）这样 f(x) 被最小化。如果有多个最小点，那么将返回第一个。

域名 必须是非空的可迭代。

索引的类型与返回的索引的类型相同 密钥(域)和 对（域）.

南 被视为小于除 失踪.

兼容性

Julia1.7此方法需要Julia1.7或更高版本。

*例子*

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

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

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

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

# *`基地。findmax！`*-函数

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

找到最大值 A 和相应的线性索引沿单维 [医]右值 和 林德，并将结果存储在 [医]右值 和 林德. 南 被视为大于除 失踪.

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。

# *`基地。芬德明！`*-函数

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

找到最小 A 和相应的线性索引沿单维 [医]右值 和 林德，并将结果存储在 [医]右值 和 林德. 南 被视为小于除 失踪.

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。

# *`基地。总和`*-函数

sum(f, A::AbstractArray; dims)

求和调用函数的结果 f 在给定维度上的数组的每个元素上。

*例子*

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

朱莉娅>总和（abs2，A，dims=1）
1×2矩阵{Int64}:
 10  20

朱莉娅>总和（abs2，A，dims=2）
2×1矩阵{Int64}:
  5
 25

sum(A::AbstractArray; dims)

在给定的维度上和数组的元素。

*例子*

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

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

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

sum(itr; [init])

返回集合中所有元素的总和。

返回类型为 Int型 对于小于系统字大小的有符号整数，以及 UInt的 对于小于系统字大小的无符号整数。对于所有其他参数，找到一个通用的返回类型，所有参数都被提升到该类型。

为空返回的值 itr 可以通过指定 初始化. 它必须是加性身份（即零），因为它是未指定的 初始化 用于非空集合。

兼容性

Julia1.6关键字参数 初始化 需要Julia1.6或更高版本。

请参阅: 减少, [医mapreduce], 计数, 工会.

*例子*

julia> sum(1:20)
210

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

sum(f, itr; [init])

求和调用函数的结果 f 在每个元素 itr.

为空返回的值 itr 可以通过指定 初始化. 它必须是加性标识（即零），因为它是未指定的 初始化 用于非空集合。

兼容性

Julia1.6关键字参数 初始化 需要Julia1.6或更高版本。

*例子*

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

注意两者之间的重要区别 总和(A) 和 减少(+,A) 对于具有小整数eltype的数组:

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

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

在前一种情况下，整数被加宽到系统字大小，因此结果是128。在后一种情况下，不发生这种扩宽，整数溢出导致-128。

# *`基地。总和！`*-函数

sum!(r, A)

和元素的 A 在单例维度 r，并将结果写入 r.

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。

*例子*

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

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

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

# *`基地。prod,prod`*-函数

prod(f, A::AbstractArray; dims)

将调用函数的结果相乘 f 在给定维度上的数组的每个元素上。

*例子*

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

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

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

prod(A::AbstractArray; dims)

将数组的元素在给定的维度上相乘。

*例子*

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

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

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

prod(itr; [init])

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

为空返回的值 itr 可以通过指定 初始化. 它必须是乘法身份（即一个），因为它是未指定的 初始化 用于非空集合。

兼容性

Julia1.6关键字参数 初始化 需要Julia1.6或更高版本。

请参阅: 减少, 综合指数, 任何.

*例子*

julia> prod(1:5)
120

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

prod(f, itr; [init])

返回的产品 f 应用于 itr.

为空返回的值 itr 可以通过指定 初始化. 它必须是乘法身份（即一个），因为它是未指定的 初始化 用于非空集合。

兼容性

Julia1.6关键字参数 初始化 需要Julia1.6或更高版本。

*例子*

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

# *`基地。刺激！`*-函数

prod!(r, A)

乘元素 A 在单例维度 r，并将结果写入 r.

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。

*例子*

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

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

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

# *`基地。任何`*-Method

any(itr) -> Bool

测试布尔集合的任何元素是否 真的，返回 真的 只要第一个 真的 价值 itr 遇到（短路）。到短路上 错误，使用 全部.

如果输入包含 失踪值，返回 失踪 如果所有非缺失值为 错误 （或者等价地，如果输入包含no 真的 值），以下https://en.wikipedia.org/wiki/Three-valued_logic[三值逻辑]。

请参阅: 全部, 计数, 总和, [|]（/base/math#Base。:

), [||](/基数/数学#

*例子*

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

# *`基地。任何`*-Method

any(p, itr) -> Bool

判断谓词是否 p 申报表 真的 对于任何元素 itr，返回 真的 只要第一个项目在 itr 为其 p 申报表 真的 遇到（短路）。到短路上 错误，使用 全部.

*例子*

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 是 真的，并将结果写入 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

# *`基地。全部`*-Method

all(itr) -> Bool

测试布尔集合的所有元素是否 真的，返回 错误 只要第一个 错误 价值 itr 遇到（短路）。到短路上 真的，使用 任何.

如果输入包含 失踪值，返回 失踪 如果所有非缺失值为 真的 （或者等价地，如果输入包含no 错误 值），以下https://en.wikipedia.org/wiki/Three-valued_logic[三值逻辑]。

请参阅: 全部！, 任何, 计数, &, &&, 阿鲁尼克.

*例子*

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

# *`基地。全部`*-Method

all(p, itr) -> Bool

判断谓词是否 p 申报表 真的 对于所有元素 itr，返回 错误 只要第一个项目在 itr 为其 p 申报表 错误 遇到（短路）。到短路上 真的，使用 任何.

*例子*

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 是 真的，并将结果写入 r.

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。

*例子*

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

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

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

# *`基地。计数`*-函数

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

计算中元素的数量 A 为其 f 申报表 真的 在给定的尺寸上。

兼容性

朱莉娅1.5 暗淡无光 在Julia1.5中添加了关键字。

兼容性

朱莉娅1.6 初始化 在Julia1.6中添加了关键字。

*例子*

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

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

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

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

返回匹配的数量 模式 在 字符串. 这相当于调用 长度（findall（模式，字符串）） 但更有效率。

如果 重叠=真，允许匹配序列在原始字符串中重叠索引，否则它们必须来自不相交的字符范围。

兼容性

Julia1.3此方法至少需要Julia1.3。

兼容性

Julia1.7使用角色作为模式至少需要Julia1.7。

*例子*

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

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

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

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

计算中元素的数量 itr 其功能 f 申报表 真的. 如果 f 被省略，计算 真的 元素在 itr （应该是布尔值的集合）。 初始化 可选地指定从开始计数的值，因此也确定输出类型。

兼容性

朱莉娅1.6 初始化 在Julia1.6中添加了关键字。

请参阅: 任何, 总和.

*例子*

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

# *`基地。n.前,前`*-函数

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

调用函数 f 在iterable的每个元素上 c. 对于多个可迭代参数, f 被称为elementwise，当任何迭代器完成时迭代停止。 n.前,前 应该使用而不是 地图当结果 f 不需要，例如 foreach（println，数组）.

*例子*

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

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

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

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

# *`基地。地图`*-函数

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

当作用于相同的多维数组 ndims，他们必须都有相同的 轴心，而答案也会。

请参阅 广播，这允许不匹配的大小。

*例子*

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

变换集合 c 通过申请 f 到每个元件。对于多个集合参数，应用 f elementwise，并在他们中的任何一个耗尽时停止。

结果的元素类型以与in相同的方式确定 收集资料.

请参阅 地图！, n.前,前, [医mapreduce], 地图单, 拉链, 迭代器。地图.

*例子*

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

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

# *`基地。地图！`*-函数

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

修改/修改 dict,dict 通过将每个值从 瓦尔 到 f(val). 请注意， dict,dict 无法更改：如果 f(val) 不是值类型的实例 dict,dict 然后，如果可能的话，它将被转换为值类型，否则会引发错误。

兼容性

朱莉娅1.2 地图！(f,values(dict::AbstractDict)) 需要Julia1.2或更高版本。

*例子*

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

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

map!(function, array)

像 地图，但将结果存储在同一个数组中。

兼容性

Julia1.12此方法需要Julia1.12或更高版本。若要支持以前的版本，请使用等效版本 地图！（函数，数组，数组）.

*例子*

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

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

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

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

像 地图，但将结果存储在 目的地 而不是一个新的集合。 目的地 必须至少与最小集合一样大。

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。

请参阅: 地图, n.前,前, 拉链, 收到！.

*例子*

julia> a = zeros(3);

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

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

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

# *`基地。[医]mapreduce`*-Method

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

应用功能 f 每个元素 itrs,itrs，然后使用二进制函数减少结果 op的. 如果提供, 初始化 必须是中性元素 op的 这将返回空集合。未指明是否 初始化 用于非空集合。在一般情况下，这将是必要的提供 初始化 使用空集合。

[医mapreduce]在功能上等同于调用 reduce(op,map(f,itr);init=init)，但通常会更快地执行，因为不需要创建中间集合。请参阅以下文档 减少和 地图.

兼容性

朱莉娅1.2 [医]mapreduce 使用多个迭代器需要Julia1.2或更高版本。

*例子*

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

减少的关联性取决于实现。此外，一些实现可以重用 f 对于多次出现在 itr. 使用方法 地图折叠或 地图折叠而不是保证左或右结合和调用 f 为了每一个价值。

# *`基地。地图折叠`*-Method

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

像 [医mapreduce]，但有保证的左结合性，如 福尔德尔. 如果提供，关键字参数 初始化 将使用一次。在一般情况下，这将是必要的提供 初始化 使用空集合。

# *`基地。地图折叠`*-Method

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

像 [医mapreduce]，但有保证正确的结合性，如 [医福尔德]. 如果提供，关键字参数 初始化 将使用一次。在一般情况下，这将是必要的提供 初始化 使用空集合。

# *`基地。第一个`*-函数

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

获取由第一个字符串组成的字符串 n 的字符 s.

*例子*

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

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

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

first(itr, n::Integer)

获得第一个 n 可迭代集合的元素 itr，或更少的元素，如果 itr 还不够长。

请参阅: 开始，开始, 迭代器。以.

兼容性

Julia1.6此方法至少需要Julia1.6。

*例子*

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

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

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

first(coll)

获取可迭代集合的第一个元素。返回一个开始点 抽象,抽象即使是空的。

请参阅: 只有, 第一索引, 最后一次.

*例子*

julia> first(2:2:10)
2

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

# *`基地。最后一次`*-函数

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

获取由最后一个字符串组成的字符串 n 的字符 s.

*例子*

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

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

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

last(itr, n::Integer)

得到最后一个 n 可迭代集合的元素 itr，或更少的元素，如果 itr 还不够长。

兼容性

Julia1.6此方法至少需要Julia1.6。

*例子*

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

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

朱莉娅>最后(Float64[],1)
浮标64[]

last(coll)

获取有序集合的最后一个元素，如果它可以在O（1）时间内计算。这是通过调用来完成的 lastindex,lastindex来获取最后一个索引。返回一个结束点 抽象,抽象即使是空的。

请参阅 第一个, 结束，结束.

*例子*

julia> last(1:2:10)
9

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

# *`基地。正面`*-函数

front(x::Tuple)::Tuple

返回a 元组 由除最后一个组件外的所有组件组成 x.

请参阅: 第一个, 尾巴.

*例子*

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

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

# *`基地。尾巴`*-函数

tail(x::Tuple)::Tuple

返回a 元组 由除第一个组件外的所有组件组成 x.

请参阅: 正面, 休息, 第一个, 迭代器。果皮.

*例子*

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

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

# *`基地。步骤`*-函数

step(r)

得到一个步长 抽象,抽象对象。

*例子*

julia> step(1:10)
1

julia>步骤(1:2:10)
2

julia>步骤(2.5:0.3:10.9)
0.3

julia>步骤（范围（2.5，停止=10.9，长度=85））
0.1

# *`基地。收集资料`*-Method

collect(iterator)

返回 阵列 集合或迭代器中的所有项。对于字典，返回一个 向量资料 的 键=>值 哈斯夏普特性，结果将具有与参数相同的形状和维度数。

使用的理解转生成器表达式转换成 阵列. 因此，on generators，可以使用方括号表示法而不是调用 收集资料，见第二个例子。

返回数组的元素类型基于收集的值的类型。但是，如果迭代器为空，则返回（空）数组的元素类型由类型推断确定。

*例子*

从 单位范围{Int64} 收集资料:

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

从生成器收集项目（输出与 [x^2为x在1:3]):

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

收集结果类型依赖于类型推断的空迭代器:

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

当迭代器非空时，结果类型仅取决于值:

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

# *`基地。收集资料`*-Method

collect(element_type, collection)

返回 阵列 使用集合或可迭代的所有项的给定元素类型。结果的形状和尺寸数与 收集资料.

*例子*

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

# *`基地。过滤器`*-函数

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

返回一个类似于给定包裹的数组的向量 跳板,跳板 迭代器，但所有缺少的元素和那些 f 申报表 错误 移走。

兼容性

Julia1.2此方法需要Julia1.2或更高版本。

*例子*

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

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

filter(f, d::AbstractDict)

交回 d，删除其中的元素 f 是 错误. 的功能 f 通过了 键=>值 对。

*例子*

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

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

filter(f)

创建一个函数，用函数过滤其参数 f 使用 过滤器，即等价于 x->过滤器(f,x).

返回的函数是类型 基地。修正1{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]

兼容性

Julia1.9此方法至少需要Julia1.9。

filter(f, a)

交回托收副本 a，删除其中的元素 f 是 错误. 的功能 f 通过一个参数。

兼容性

Julia1.4支持 a 作为元组至少需要Julia1.4。

请参阅: 过滤器！, 迭代器。过滤器.

*例子*

julia> a = 1:10
1:10

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

# *`基地。过滤器！`*-函数

filter!(f, d::AbstractDict)

更新资料 d，删除其中的元素 f 是 错误. 的功能 f 通过了 键=>值 对。

*例子*

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

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

filter!(f, a)

更新收集 a，删除其中的元素 f 是 错误. 的功能 f 通过一个参数。

*例子*

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

# *`基地。更换/更换`*-Method

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

交回托收副本 A 在哪里，每对 旧=>新 在 旧的新的,所有出现的 老 被替换为 新的. 平等是用 等效;等效. 如果 计数 被指定，则最多替换 计数 总共发生。

使用promotion选择结果的元素类型（请参阅 promote_type)基于元素类型的 A 及有关 新的 成对的值。如果 计数 被省略和元素类型 A 是一个 工会，结果的元素类型将不包括用不同类型的值替换的单例类型：例如, 工会{T,Missing} 将成为 T 如果 失踪 被取代。

请参阅 替换！, 剪接！, 删除！, 插入！.

兼容性

Julia1.7版本1.7需要替换a的元素 元组.

*例子*

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

# *`基地。更换/更换`*-Method

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

交回 A 其中每个值 x 在 A 被替换为 新(x). 如果 计数 被指定，则最多替换 计数 总计值（替换定义为 新的（x）！==x).

兼容性

Julia1.7版本1.7需要替换a的元素 元组.

*例子*

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

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

# *`基地。替换！`*-函数

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

替换每个元素 x 在集合中 A 由 新(x). 如果 计数 被指定，则最多替换 计数 总计值（替换定义为 新的（x）！==x).

*例子*

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

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

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

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

对于每对 旧=>新 在 旧的新的，替换所有出现的 老 在集合中 A 由 新的. 平等是用 等效;等效. 如果 计数 被指定，则最多替换 计数 总共发生。请参阅 更换/更换.

*例子*

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

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

# *`基地。休息`*-函数

Base.rest(collection[, itr_state])

取尾的通用函数 收集资料，从特定的迭代状态开始 itr_state. 返回a 元组，如果 收集资料 本身就是一个 元组,的亚型 [医]文摘，如果 收集资料 是一个 抽象阵列,的亚型 抽象字符串 如果 收集资料 是一个 抽象字符串，和一个任意迭代器，回退到 迭代器。rest(集合[,itr_state])，否则。

可以重载用户定义的集合类型，以自定义功能#destructuring-assignment在最后的位置，就像 a，b。.. =集合.

兼容性

朱莉娅1.6 基地。休息 至少需要Julia1.6。

请参阅: 第一个, 迭代器。休息, 基地。分裂,分裂.

*例子*

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. 返回两个新集合的元组。第一个包含尾部的所有元素，但 n 最后一个，构成第二个集合。

第一个集合的类型通常遵循 基地。休息，除了回退案例不是懒惰的，而是急切地收集到一个向量中。

可以重载用户定义的集合类型，以自定义在作业中slurping在非最终位置，像 a，b。..，c=集合.

兼容性

朱莉娅1.9 基地。分裂,分裂 至少需要Julia1.9。

请参阅: 基地。休息.

*例子*

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,getindex`*-函数

getindex(collection, key...)

检索存储在集合中给定键或索引处的值。语法 a[i,j,...] 由编译器转换为 getindex（a，i，j，。..).

请参阅 获取, 钥匙, 每个索引.

*例子*

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

julia> getindex(A, "a")
1

# *`基地。setindex！`*-函数

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

返回的第一个索引 收集资料. 如果 d 给出，返回第一个索引 收集资料 沿尺寸 d.

语法 A[开始] 和 A[1,开始] 下至 A[第一索引(A)] 和 A[1,第一索引(A,2)]，分别。

请参阅: 第一个, 轴心, lastindex,lastindex, 下一篇.

*例子*

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

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

# *`基地。lastindex,lastindex`*-函数

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

返回的最后一个索引 收集资料. 如果 d 给出，返回的最后一个索引 收集资料 沿尺寸 d.

语法 A[完] 和 A[完，完] 下至 A[lastindex(a)] 和 A[lastindex(A,1),lastindex(A,2)]，分别。

请参阅: 轴心, 第一索引, 每个索引, 上一页.

*例子*

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

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

全面实施:

* 阵列 * 比特阵列 * 抽象阵列 * 子阵列

部分由:

* 抽象范围 * 单位范围 * 元组 * 抽象字符串 * Dict,Dict * IdDict * 弱者,弱者 * 命名的,命名的

字典

Dict是标准字典。其实施使用 哈希作为密钥的散列函数，以及 等效;等效来确定平等。为自定义类型定义这两个函数，以复盖它们在哈希表中的存储方式。

IdDict是一个特殊的哈希表，其中键始终是对象标识。

弱者,弱者是一个哈希表实现，其中键是对对象的弱引用，因此即使在哈希表中引用也可能被垃圾收集。像 Dict,Dict 它使用 哈希 用于散列和 等效;等效 为了平等，不像 Dict,Dict 它不会在插入时转换键。

Dict,Dicts可以通过传递用 => 到一个 Dict,Dict构造函数: Dict("A"=>1,"B"=>2). 此调用将尝试从键和值推断类型信息（即此示例创建 Dict,Dict{String, Int64}). 要显式指定类型，请使用以下语法 Dict{KeyType,ValueType}(...). 例如, Dict{String,Int32}("A"=>1,"B"=>2).

字典也可以用生成器创建。例如, Dict(i=>f(i)for i=1:10).

给定一本字典 D，语法 D[x] 返回key的值 x （如果存在）或抛出错误，并且 D[x]=y 存储键值对 x=>y 在 D （替换键的任何现有值 x). 多个参数 D[。..] 被转换为元组；例如，语法 D[x,y] 相当于 D[(x,y)]，即它指的是元组键入的值 (x,y).

# *`基地。摘要;摘要`*-类型

AbstractDict{K, V}

类型键的类字典类型的超类型 K 和类型的值 V. Dict,Dict, IdDict和其他类型是此的子类型。一个 摘要;摘要{K, V} 应该是一个迭代器 对{K, V}.

# *`基地。Dict`*-类型

Dict([itr])

Dict{K,V}() 构造具有类型键的哈希表 K 和类型的值 V. 键进行比较 等效;等效和散列 哈希.

给定一个可迭代的参数，构造一个 Dict,Dict其键值对取自2元组 （键，值） 由参数产生的。

*例子*

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

警告键被允许是可变的，但是如果你改变了存储的键，哈希表可能会在内部不一致，在这种情况下 Dict,Dict 将无法正常工作。 IdDict可以是一个替代方案，如果你需要改变键。

# *`基地。IdDict`*-类型

IdDict([itr])

IdDict{K,V}() 使用以下方法构造哈希表 对象,对象作为哈希和 === 与类型键相等 K 和类型的值 V. 见 Dict,Dict进一步的帮助和 Id集为本的设定版本。

在下面的例子中， Dict,Dict 钥匙都是 等效;等效 因此得到哈希相同，所以他们得到复盖。该 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以获得进一步的帮助。注意，不像 Dict,Dict, 弱者,弱者 在插入时不转换键，因为这意味着键对象在插入之前的任何地方都没有引用。

请参阅 弱href.

# *`基地。拢潞ImmutableDict`*-类型

ImmutableDict

拢潞ImmutableDict 是一个实现为不可变链表的字典，这对于在许多单个插入上构建的小型字典来说是最佳的。请注意，无法删除值，尽管可以通过插入具有相同键的新值来部分复盖和隐藏该值。

ImmutableDict(KV::Pair)

在 拢潞ImmutableDict 对于一个 键=>值 对

*使用 (键=>值)在dict 要查看此特定组合是否在属性集中 *使用 get（dict，key，default） 检索特定键的最新值

# *`基地。持续的,持续的`*-类型

PersistentDict

持续的,持续的 是作为哈希数组映射trie实现的字典，这对于需要持久性的情况是最佳的，每个操作返回一个与前一个单独的新字典，但底层实现是空间效率高的，可能跨多个单独的字典共享存储。

请注意，它的行为就像一个IdDict。

PersistentDict(KV::Pair)

*例子*

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

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

朱莉娅>dict3=基地。PersistentDict（dict，：a=>2）
基地。持续的,持续的{Symbol, Int64} 有1个条目:
  ：a=>2

# *`基地。哈斯基`*-函数

haskey(collection, key) -> Bool

确定集合是否具有给定映射 钥匙.

*例子*

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

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

# *`基地。获取`*-函数

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

返回为给定键存储的值，或者如果不存在键的映射，则返回 f(). 使用方法 得到！还要将默认值存储在字典中。

这是用来调用的 做 块语法

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

get(collection, key, default)

返回为给定键存储的值，如果不存在键的映射，则返回给定的默认值。

兼容性

Julia1.7对于元组和数字，此函数至少需要Julia1.7。

*例子*

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()，并返回 f().

这是用来调用的 做 块语法。

*例子*

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

julia>函数get_square！（d，i）
           得到！(d,i)做
               i^2
           结束
       结束
get_square！ （泛型功能与1方法）

朱莉娅>get_square！(正方形,2)
4

朱莉娅>广场
Dict,Dict{Int64, Int64} 有1个条目:
  2 => 4

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

# *`基地。盖基`*-函数

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

# *`基地。爸爸！`*-Method

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(a::AbstractDict)

返回集合中所有值的迭代器。 收集(值(a)) 返回一个值数组。当值在内部存储在哈希表中时，就像以下情况一样 Dict,Dict，它们返回的顺序可能会有所不同。但是 钥匙(a), 价值(a) 和 对(a) 所有迭代 a 并以相同的顺序返回元素。

*例子*

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

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

values(iterator)

对于具有键和值的迭代器或集合，返回值的迭代器。这个函数只是默认返回它的参数，因为一般迭代器的元素通常被认为是它的"值"。

*例子*

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

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

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

# *`基地。对,对`*-函数

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

访问数组每个元素的迭代器 A，返回 i=>x，在哪里 i 是元素的索引和 x=A[i]. 相同于 对(A)，除了索引的样式可以选择。也类似于 枚举(A)，除了 i 将是一个有效的索引 A，而 枚举 无论 A.

指定 索引线()确保 i 将是一个整数;指定 IndexCartesian()确保 i 将是一个 基地。[医CartesianIndex]；指定 索引样式(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

请参阅 索引样式, 轴心.

pairs(collection)

返回迭代器 键=>值 对任何将一组键映射到一组值的集合。这包括数组，其中键是数组索引。当条目在内部存储在哈希表中时，就像以下情况一样 Dict,Dict，它们返回的顺序可能会有所不同。但是 钥匙(a), 价值(a) 和 对(a) 所有迭代 a 并以相同的顺序返回元素。

*例子*

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

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

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

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

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

# *`基地。合并；合并`*-函数

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

合并的属性 初始 脸和 其他，后脸优先。

这用于组合多个面的样式，并解决继承。

merge(a::NamedTuple, iterable)

将键值对的可迭代解释为命名元组，并执行合并。

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

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

通过以左关联方式合并两个或多个现有元组来构造一个新的命名元组。合并在命名元组对之间从左到右进行，因此在最左边和最右边的命名元组中存在的字段顺序与在最左边的命名元组中找到的位置相同。但是，值取自包含该字段的最右侧命名元组中的匹配字段。只有在对的最右边命名元组中存在的字段被附加在末尾。当仅提供具有签名的单个命名元组时，将实现回退 合并(A::NamedTuple).

兼容性

Julia1.1合并3个或更多 命名的,命名的 至少需要Julia1.1。

*例子*

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

julia> merge((a=1, b=2), (b=3, c=(d=1,)), (c=(d=2,),))
(a = 1, b = 3, c = (d = 2,))

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

从给定集合构造合并集合。如有必要，将提升生成集合的类型以适应合并集合的类型。如果同一个键存在于另一个集合中，则该键的值将是它在列出的最后一个集合中具有的值。请参阅 合并,合并用于自定义处理具有相同键的值。

*例子*

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

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

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

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

# *`基地。合并,合并`*-函数

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

从给定集合构造合并集合。如有必要，将提升生成集合的类型以适应合并集合的类型。具有相同键的值将使用组合器函数进行组合。咖喱表格 合并(合并) 返回函数 (args...）->mergewith（合并，args。..).

方法 合并(合并::联合{Function,Type},args...) 作为别名 mergewith（结合，args。..) 仍然可用于向后兼容性。

兼容性

朱莉娅1.5 合并,合并 需要Julia1.5或更高版本。

*例子*

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

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

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

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

julia> mergewith(-, Dict(), Dict(:a=>1))  # Combining function only used if key is present in both
Dict{Any, Any} with 1 entry:
  :a => 1

# *`基地。合并！`*-函数

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

使用来自其他集合的对更新集合。请参阅 合并；合并.

*例子*

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

使用来自其他集合的对更新集合。具有相同键的值将使用组合器函数进行组合。咖喱表格 梅格威斯！(合并) 返回函数 (args...）->mergewith！（结合，args。..).

方法 合并！(合并::联合{Function,Type},args...) 作为别名 mergewith！（结合，args。..) 仍然可用于向后兼容性。

兼容性

朱莉娅1.5 梅格威斯！ 需要Julia1.5或更高版本。

*例子*

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

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

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

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

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

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

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

# *`基地。sizehint！`*-函数

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

建议集合 s 至少预留容量 n 元素。也就是说，如果你期望你将不得不将很多价值推向 s，您可以通过预先执行一次来避免增量重新分配的成本;这可以提高性能。

如果 第一个 是 真的，然后在收集开始之前保留任何额外的空间。这样，后续调用 先推！ （而不是 推！）可能会变得更快。提供此关键字可能会导致错误，如果集合未排序或如果 先推！ 不支持此集合。

如果 收缩=真 （默认值），如果集合的当前容量大于集合的容量，集合的容量可能会减少 n.

请参阅 调整大小！.

*性能模型注意事项*

对于支持的类型 sizehint！,

推！ 和 追加！ 方法通常可以（但不是必需的）预分配额外的存储。对于在 基地，他们通常这样做，使用针对一般用例优化的启发式。
sizehint！ 可以控制这种预分配。同样，它通常对以下类型执行此操作 基地.
空！ 对于支持这种预分配的类型来说，几乎是免费的（和O（1））。

兼容性

朱莉娅1.11 收缩,收缩 和 第一个 在Julia1.11中添加了参数。

# *`基地。密钥类型`*-函数

keytype(type)

获取字典类型的键类型。行为类似于 eltype,eltype.

*例子*

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

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

返回数组的键类型。这等于 eltype,eltype的结果 键（。..)，并且主要是为了与字典接口兼容而提供的。

*例子*

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

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

兼容性

Julia1.2对于数组，此函数至少需要Julia1.2。

# *`基地。[医]valtype`*-函数

valtype(type)

获取字典类型的值类型。行为类似于 eltype,eltype.

*例子*

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

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

返回数组的值类型。这与 eltype,eltype并且主要是为了与字典接口兼容而提供的。

*例子*

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

兼容性

Julia1.2对于数组，此函数至少需要Julia1.2。

全面实施:

* Dict,Dict * IdDict * 弱者,弱者

部分由:

* 套装 * 比特集 * Id集 * 环境,环境 * 阵列 * 比特阵列 * 拢潞ImmutableDict * 持续的,持续的 * 迭代器。对,对

集状集合

# *`基地。抽象集,抽象集`*-类型

AbstractSet{T}

类集合类型的超类型，其元素是类型的 T. 套装, 比特集和其他类型是此的子类型。

# *`基地。套装`*-类型

Set{T} <: AbstractSet{T}

套装s是提供快速成员资格测试的可变容器。

套装s有集操作的高效实现，如 在, 工会 和 相交点. A中的元素 套装 是唯一的，由元素的定义决定 等效;等效. 元素在a中的顺序 套装 是一个实现细节，不能依赖。

请参阅: 抽象集,抽象集, 比特集, Dict,Dict, 推！, 空！, 联合！, 在, 等效;等效

*例子*

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型s由给定的可迭代对象或空集生成。实现为比特串，因此设计用于密集整数集。如果集合将是稀疏的（例如，持有几个非常大的整数），请使用 套装代替。

# *`基地。Id集`*-类型

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

Id集{T}（）构造一个集合（参见 套装)使用 === 与类型值相等 T.

在下面的示例中，这些值都是 等效;等效 所以他们在平凡中被复盖 套装. 该 Id集 比较： === 因此保留了3个不同的值。

兼容性

Julia1.11在Julia1.11及更高版本中导出。

*例子*

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

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

# *`基地。工会`*-函数

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

构造一个包含来自所有参数的所有不同元素的对象。

第一个参数控制返回的容器类型。如果这是一个数组，它会保持元素首次出现的顺序。

统一码 ∪ 可以通过书写打字 \杯 然后在Julia REPL和许多编辑器中按tab键。这是一个中缀运算符，允许 s∪itr.

请参阅 独特的, 相交点, isdisjoint, vcat的, 迭代器。展平.

*例子*

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

朱莉娅> (0, 0.0) ∪ (-0.0, 南）
3元素向量{Real}:
   0
  -0.0
 南

茱莉亚>联合(集([1, 2]), 2:3)
套装{Int64} 有3个元素:
  2
  3
  1

# *`基地。联合！`*-函数

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

合并包含 x 其中包含 y 成一个并返回新集的根。

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

建造 工会传入集和复盖 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...)

构造包含出现在所有参数中的元素的集合。

第一个参数控制返回的容器类型。如果这是一个数组，它会保持元素首次出现的顺序。

统一码 ∩ 可以通过书写打字 \帽 然后在Julia REPL和许多编辑器中按tab键。这是一个中缀运算符，允许 s∩itr.

请参阅 塞特迪夫, isdisjoint, 伊苏布塞特, 伊塞特平等.

兼容性

Julia1.8自Julia1.8intersect返回一个结果，其中包含两个输入的类型提升eltypes的eltype

*例子*

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,itrs. 与数组保持顺序。

请参阅 setdiff！, 工会和 相交点.

*例子*

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

# *`基地。setdiff！`*-函数

setdiff!(s, itrs...)

从集合中删除 s （就地）每个可迭代的每个元素 itrs,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 不是一个 抽象集,抽象集，顺序保持。

请参阅 symdiff！, setdiff, 工会和 相交点.

*例子*

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，使用 在.

请参阅 ⊊, ⊈, ∩, ∪, 包含.

*例子*

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

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

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

# *`Base.in！`*-函数

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

如果 x 是在 s，返回 真的. 如果没有，推 x 进入 s 然后回来 错误. 这相当于 在（x，s）？真：（推！(s,x);假)，但可能有一个更有效的实现。

请参阅: 在, 推！, 套装

兼容性

Julia1.11此功能至少需要1.11。

*例子*

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

julia> length(s)
4

julia> in!(0x04, s)
true

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

# *`基地。:⊈`*-函数

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

否定的 ⊆ 和 ⊇，即检查 a 不是 b.

请参阅 伊苏布塞特 (⊆), ⊊.

*例子*

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

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

# *`基地。:⊊`*-函数

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

确定是否 a 是一个子集，但不等于, b.

请参阅 伊苏布塞特 (⊆), ⊈.

*例子*

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

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

# *`基地。伊塞特平等`*-函数

issetequal(x)

创建一个函数，将其参数与 x 使用 伊塞特平等，即等价于 y->issetequal(y,x). 返回的函数是类型 基地。修正2{typeof(issetequal)}，从而可用于实施专门的方法。

兼容性

Julia1.11此功能至少需要Julia1.11。

issetequal(a, b) -> Bool

确定是否 a 和 b 有相同的元素。相当于 a＜b&&b＞a 但在可能的情况下更有效率。

请参阅: isdisjoint, 工会.

*例子*

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

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

# *`基地。isdisjoint`*-函数

isdisjoint(x)

创建一个函数，将其参数与 x 使用 isdisjoint，即等价于 y->isdisjoint(y,x). 返回的函数是类型 基地。修正2{typeof(isdisjoint)}，从而可用于实施专门的方法。

兼容性

Julia1.11此功能至少需要Julia1.11。

isdisjoint(a, b) -> Bool

确定集合是否 a 和 b 是不相交的。相当于 isempty(a≠b) 但在可能的情况下更有效率。

请参阅: 相交点, [医空位], 伊塞特平等.

兼容性

Julia1.5此功能至少需要Julia1.5。

*例子*

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

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

全面实施:

* 套装 * 比特集 * Id集

部分由:

* 阵列

出让,出让

# *`基地。推！`*-函数

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

插入一个或多个 项目 在 收集资料. 如果 收集资料 是一个有序的容器，项目被插入在最后（以给定的顺序）。

*例子*

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

如果 收集资料 被订购，使用 追加！将另一个集合的所有元素添加到其中。上述示例的结果相当于 追加！([1, 2, 3], [4, 5, 6]). 为 抽象集,抽象集 对象, 联合！可以代替使用。

见 sizehint！有关性能模型的注释。

请参阅 先推！.

# *`基地。爸爸！`*-函数

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

pop!(collection) -> item

删除项目 收集资料 把它还给我。如果 收集资料 是有序容器，返回最后一项；对于无序容器，返回任意元素。

请参阅: 第一个！, 波帕特！, 删除！, deleteat！, 剪接！，和 推！.

*例子*

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

julia> pop!(A)
3

julia> A
2-element Vector{Int64}:
 1
 2

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

julia> pop!(S)
2

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

julia> pop!(Dict(1=>2))
1 => 2

# *`基地。波帕特！`*-函数

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

删除给定的项目 i 把它还给我。随后的项目被移位以填充所产生的间隙。何时 i 不是有效的索引 a，返回 违约情况，或抛出一个错误，如果 违约情况 未指定。

请参阅: 爸爸！, 第一个！, deleteat！, 剪接！.

兼容性

Julia1.5此功能自Julia1.5起可用。

*例子*

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

插入一个或多个 项目 在开始 收集资料.

此函数被调用 取消换档 在许多其他编程语言中。

*例子*

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

# *`基地。第一个！`*-函数

popfirst!(collection) -> item

删除第一个 项目 从 收集资料.

此函数被调用 轮班 在许多其他编程语言中。

请参阅: 爸爸！, 波帕特！, 删除！.

*例子*

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)

插入 项目 进入 a 在给定的 索引. 索引 是索引的 项目 在由此产生的 a.

请参阅: 推！, 更换/更换, 波帕特！, 剪接！.

*例子*

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

# *`基地。deleteat！`*-函数

deleteat!(a::Vector, inds)

删除由 inds，并返回修改后的 a. 随后的项目被移位以填充所产生的间隙。 inds 可以是迭代器或排序和唯一整数索引的集合，也可以是与 a 与 真的 指示要删除的条目。

*例子*

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

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

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

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

删除给定的项目 i 并返回修改后的 a. 随后的项目被移位以填充所产生的间隙。

请参阅: keepat！, 删除！, 波帕特！, 剪接！.

*例子*

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

# *`基地。keepat！`*-函数

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

逻辑索引的就地版本 a=a[m]. 那就是, keepat！(a,m) 在相等长度的向量上 a 和 m 将删除所有元素 a 为其 m 在相应的索引是 错误.

*例子*

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

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

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

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

删除所有索引中没有由 inds，并返回修改后的 a. 保持的项目被移动以填补由此产生的空白。

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。

inds 必须是排序和唯一整数索引的迭代器。请参阅 deleteat！.

兼容性

Julia1.7此功能自Julia1.7起可用。

*例子*

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

# *`基地。剪接！`*-函数

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

删除指定索引处的项，并返回包含已删除项的集合。随后的项目被左移以填补由此产生的空白。如果指定，则将拼接有序集合中的替换值以代替已删除的项；在这种情况下, 指数 必须是一个 N.抽象,抽象.

要插入 更换 在索引之前 n 在不删除任何项目的情况下，使用 剪接！(集合,n:n-1,替换).

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。

兼容性

茱莉亚1.5之前的茱莉亚1.5, 指数 必须永远是一个 单位范围.

兼容性

茱莉亚1.8之前的茱莉亚1.8, 指数 必须是一个 单位范围 如果拼接在替换值。

*例子*

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

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

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

移除给定索引处的项，并返回移除的项。随后的项目被左移以填补由此产生的空白. 如果指定，则将拼接有序集合中的替换值以代替已删除的项目。

请参阅: 更换/更换, 删除！, deleteat！, 爸爸！, 波帕特！.

*例子*

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

朱莉娅>A
5元素向量{Int64}:
 6
 5
 4
 3
 1

茱莉亚>剪接！（A，5，-1）
1

朱莉娅>A
5元素向量{Int64}:
  6
  5
  4
  3
 -1

茱莉亚>剪接！（一, 1, [-1, -2, -3])
6

朱莉娅>A
7元素向量{Int64}:
 -1
 -2
 -3
  5
  4
  3
 -1

要插入 更换 在索引之前 n 在不删除任何项目的情况下，使用 剪接！(集合,n:n-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.

对于已订购的容器 收集资料，添加每个元素 馆藏资料 到最后。

兼容性

Julia1.6指定要追加的多个集合至少需要Julia1.6。

*例子*

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

使用方法 推！将个别项目加入 收集资料 它们还没有在另一个收藏中。上述示例的结果相当于 推！([1, 2, 3], 4, 5, 6).

见 sizehint！有关性能模型的注释。

请参阅 vcat的为向量, 联合！对于集，和 准备！和 先推！为相反的顺序。

# *`基地。准备！`*-函数

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

插入每个元素 馆藏资料 到开始 a.

何时 馆藏资料 指定多个集合，顺序保持： 收藏品[1] 将出现在最左边 a，等等。

兼容性

Julia1.6指定要预先添加的多个集合至少需要Julia1.6。

*例子*

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

全面实施:

* 向量资料 （又名1维 阵列) * 比特克托 （又名1维 比特阵列)

公用事业集合

# *`核心。对`*-类型

Pair(x, y)
x => y

建造一个 对 类型的对象 对{typeof(x), typeof(y)}. 元素存储在字段中 第一个 和 第二. 它们也可以通过迭代访问（但a 对 被视为用于广播操作的单个"标量"）。

请参阅 Dict,Dict.

*例子*

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

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

julia> p.first
"foo"

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

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

# *`基地。对,对`*-类型

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

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