收集和数据结构

迭代

使用函数实现顺序迭代 '迭代'。一般的"for"周期:

for i in iter   # или "for i = iter"
    # тело
end

转换为

next = iterate(iter)
while next !== nothing
    (i, state) = next
    # тело
    next = iterate(iter, state)
end

"状态"对象可以是任何东西。必须为每个可迭代类型适当地选择它。有关定义自定义可迭代类型的详细信息，请参阅手册中关于迭代接口的部分。

# '基。迭代'-Function

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

继续迭代器执行以获取下一个元素。如果没有剩余元素，则返回"nothing"。否则，返回下一个元素的双元素元组和新的迭代状态。

# '基。IteratorSize'-Type

IteratorSize(itertype::Type) -> IteratorSize

根据迭代器的类型，将返回以下值之一:

SizeUnknown()，如果不能预先确定长度（元素个数）;
'HasLength()`在固定有限长度的情况下;
'哈斯夏普{N}（）`，如果长度是已知的，并且多维形状的定义是可用的（对于数组）;在这种情况下，'N’应该返回维度的数量，并且函数 `axes'对迭代器有效;
'IsInfinite()'如果迭代器无限期地输出值。

默认情况下，值（对于未定义此函数的迭代器）为’HasLength()'。也就是说，大多数迭代器可能实现 '长度'。

此类型通常用于在预先为结果分配空间的算法和逐步调整结果大小的算法之间进行选择。

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

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

# '基。IteratorEltype'—Type

IteratorEltype(itertype::Type) -> IteratorEltype

根据迭代器的类型，将返回以下值之一:

'EltypeUnknown()`，如果迭代器返回的元素类型事先未知;
'HasEltype()`，如果元素类型已知并且 `eltype'返回一个有意义的值。

默认情况下使用`HasEltype()'，因为迭代器可能实现 'eltype'。

这种类型通常用于在预先定义特定类型结果的算法和基于给定值的类型选择结果类型的算法之间进行选择。

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

它由以下类型完全实现:

构造函数和类型

# '基。AbstractRange'-Type

AbstractRange{T} <: AbstractVector{T}

包含类型为`T’的元素的线性范围的超类型。 '单位范围`, 'LinRange'和其他类型是该类型的子类型。

必须为所有子类型定义函数。 '步骤'。因此 'LogRange'不是`AbstractRange`的子类型。

# '基。OrdinalRange'—Type

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

包含类型为"T"的元素和类型为"S"的空格的序数范围的超类型。步骤应始终是 'oneunit'，并且`T’必须是不能包含小于`oneunit’的值的"离散"类型。例如，类型’Integer’或’Date`满足这些要求，但`Float64`没有（因为这种类型可以表示小于`oneunit(Float64)'的值）。 '单位范围`, 'StepRange'和其他类型是这种类型的子类型。

# '基。AbstractUnitRange'—Type

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

具有步长的范围的超类型 oneunit(T)，包含类型为’T’的元素。 'UnitRange'和其他类型是这种类型的子类型。

# '基。StepRange'—Type

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

一个超类型，包含类型为"T"的元素，带有类型为"S"的空格。元素之间的步长是一个常量，范围在`t`类型的`start`和`stop`以及`s`类型的`step`的上下文中定义。 'T’和’S’都不应该属于浮点类型。 A:b:c`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'—Type

UnitRange{T<:Real}

由`t`类型的`start`和’stop’参数化的范围将填充由`1`分隔的元素，从`start’直到超过’stop'。 A：b`与`a`和`b（都是`Integer`）的语法创建了一个`UnitRange'。

例子

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

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

# '基。LinRange`-Type

LinRange{T,L}

在"开始"和"停止"之间有"len"线性间隔的元素的范围。间隔的大小由`len`参数控制，该参数必须是一个`整数'。

例子

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

与之相比 'range'通过直接构造’LinRange`，开销会更低，但浮点错误不会得到纠正。

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

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

另外，请参阅功能说明。 'Logrange'对于具有对数间隔的点。

共享集合

# '基。isempty`-Function

isempty(collection) -> Bool

确定集合是否为空（不包含任何元素）。

如果没有定义相应的迭代器元素，则"isempty(itr)"可以使用状态为"itr"的下一个迭代器元素。 '基地。isdone(itr)方法。有状态迭代器应该实现’isdone，但是在编写应该支持任何类型的迭代器的泛型代码时，避免使用`isempty’可能是可取的。

例子

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

如果没有任务等待根据条件处理，则返回`true`，否则返回’false'。

# '基。isdone'-Function

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

此函数提供了结束迭代器的快速路径的指示。这对于有状态迭代器很有用，如果它们对用户不可用（例如，在`isempty`或`zip’中检查就绪情况时），则不应使用它们的元素。

对于需要此功能的有状态迭代器，必须定义`isdone`方法，该方法根据迭代器是否完成返回true或false。无状态迭代器不需要实现此功能。

如果结果是’missing`，调用者可以继续执行并计算’iterate(x,state)===nothing`以获得特定的响应。

另请参阅说明 '迭代', 'isempty`。

# '基。空！`-Function</no-翻译>

empty!(collection) -> collection

从"集合"中删除所有项目。

例子

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

julia> empty!(A);

julia> A
Dict{String, Int64}()

empty!(c::Channel)

通过调用"空！`为内部缓冲区。返回空通道。

# '基。长度'-Function

length(collection) -> Integer

返回集合中的项数。

使用方法 'lastindex'获取索引集合的最后一个有效索引。

另请参阅说明 '尺寸', 'ndims', 'eachindex'。

例子

julia> length(1:5)
5

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

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

# '基。checked_length'-Function

Base.checked_length(r)

计算"长度（r）"，但如果结果不适合"联合"，则可以在必要时检查溢出错误{Integer(eltype(r)),Int}`.

它由以下类型完全实现:

可迭代集合

# <无翻译>*Base.in*-Function</no-翻译>

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

确定一个项目是否包含在此集合中（即它是 =='到通过迭代集合创建的值之一）。返回’Bool’的值，除非’item’等于 'missing或当’collection`包含`missing`但不包含`item’时（在这种情况下，返回`missing`，即应用https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑]，它对应于行为 '任何`和 ==).

对于某些集合，使用稍微不同的定义。例如, Set'检查是否(`isequal')元素到元素之一。 `Dict'搜索+key⇒value+'的对，并使用 '等效`。

要检查字典中的键，请使用 'haskey'或’k in keys(dict)'。对于上述集合，结果总是’Bool'。

在广播的情况下使用’in。（项目，集合）`或’项目。∈collection`item`和`collection’都是广播的，尽管这种结果通常是不可取的。例如，如果两个参数都是向量（并且维度匹配），则结果是一个向量，指示"项目"集合中的每个值是否包含在"集合"中相应位置的值中。要获得一个向量，指示`items`中的每个值是否包含在’collection`中，请将`collection`括在元组或`Ref`中，如下所示：'in。(items,Ref(collection))`或’items.∈Ref(集合)'。

另请参阅说明 ∉, 'insorted`, '包含`, '发生', '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

# *'基。:∉'`-Function</no-翻译>

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

否定'∈'和'∋`，即它检查’item`不包含在`集合’中。

广播的情况下使用’项。∉collection`item`和`collection’都是广播的，尽管这种结果通常是不可取的。例如，如果两个参数都是向量（并且大小匹配），则结果是一个向量，指示`items`集合中的每个值未包含在`集合`中相应位置的值中。要获得一个向量，指示`items`中的每个值都不包含在`collection`中，请将`collection`括在元组或`Ref`中，如下所示：`items。∉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

# '基。hasfastin'-Function

Base.hasfastin(T)

定义`x∈collection’的计算，其中’collection::T’可以被认为是"快速"操作（通常具有常数或对数复杂性）。为了方便起见，可以接受’hasfastin(x)=hasfastin(typeof(x))`，以便可以传递实例而不是类型。但是，对于新类型，有必要定义一个接受类型参数的表单。

对于子类型，hasfastin(T)`的默认值为`true '抽象集, 'AbstractDict'和 AbstractRange和`false’否则。

# '基。eltype'-Function

eltype(type)

定义通过迭代此类型`type’的集合创建的项的类型。对于字典类型，使用"对"。{KeyType,ValType}`. 为了方便起见，可以接受’eltype(x)=eltype(typeof(x))`，以便可以传递实例而不是类型。但是，对于新类型，有必要定义一个接受类型参数的表单。

另请参阅说明 'keytype', 'typeof'。

例子

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

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

# *'基。索引`-Function</no-翻译>

indexin(a, b)

返回一个数组，该数组包含`b`中作为`b`成员的`a’中的每个值的第一个索引。在`a`不是`b`成员的所有情况下，输出数组都包含`nothing'。

另请参阅说明 'sortperm`, 'findfirst`。

例子

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

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

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

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

# '基。唯一的'-Function

unique(itr)

根据定义返回仅包含`itr`集合的唯一元素的数组 'isequal'和 'hash'以每组等价元素的第一个元素最初位于的顺序。将保存输入数据元素类型。

另请参阅说明 '独一无二！, '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)

为将`f`函数应用于`itr`元素时创建的每个唯一值返回一个包含`itr`中的一个值的数组。

例子

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

您还可以使用此函数获取数组中唯一元素首次出现的_index_。:

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)

返回"dims"维度的整个长度上的唯一区域"A"。

例子

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

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

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

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

[:, :, 2] =
 1
 0

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

# '基。独一无二！`-Function</no-翻译>

unique!(f, A::AbstractVector)

为将函数`f`应用于`A`的元素时创建的每个唯一值从`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

unique!(A::AbstractVector)

删除使用以下方法定义的重复元素 'isequal'和 hash，然后返回修改后的’a'。 "独一无二！按它们出现的顺序返回`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! может обрабатывать отсортированные данные гораздо эффективнее.

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

# '基。allunique'-Function

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

如果"itr"的所有值在与"itr"进行比较时都能明显区分，则返回"true"。 'isequal'或者如果所有`[f(x)for x in itr]`在第二种方法的情况下是可区分的。

请注意，'allunique（f，itr）`可能会导致`f`一次小于`length（itr）'。调用的确切数量取决于实现。

如果输入数据被排序’allunique’可以使用一个特殊的实现。

另请参阅说明 '独特`, 'issorted', 'allequal'。

兼容性：Julia1.11

对于’allunique（f，itr）方法'，要求Julia的版本不低于1.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'`-Function

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

如果使用"itr"的所有值都相等，则返回"true" 'isequal'或者如果所有`[f(x)for x in itr]`在第二种方法的情况下是相等的。

请注意，`length(f,itr)`可能会导致`f`一次小于`length(itr)'。调用的确切数量取决于实现。

另请参阅说明 '独特`, 'allunique'。

兼容性：Julia1.8

"Allequal’功能需要至少1.8的Julia版本。

兼容性：Julia1.11

对于方法’allequal（f，itr’需要一个不低于1.11的Julia版本。

例子

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

使用指定的二进制运算符’op`将`itr’集合简化为更简单的形式。如果指定了’init’的初始值，则它必须是`op`的中性元素，这是为空集合返回的。没有指定`init`是否用于非空集合。

对于空集合，在某些情况下，有必要指定’init`（例如，如果’op’是运算符之一`+, `*, ` 最大,最小`, &, |), 当Julia可以识别一个中性元素’op’时。

对于某些通用运算符来说，简化为更简单形式的操作可能有特殊的实现，在这种情况下应该使用。: '最大值''(itr), '最低''(itr), '总和''(itr), 'prod''(itr), '任何`'(itr), '全部'(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

# '基。减少`-Method

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

通过`a`的维度减少具有两个参数的函数’f'。 "dims"是一个向量，指示要缩写的维度，命名参数"init"是缩写中使用的初始值。为`+, `*, ` `init`的`max`和’min’参数是可选的。

还原到更简单形式的关联性取决于实现。如果您需要特定的关联性，例如从左到右，您应该编写自己的循环或考虑使用 'foldl'或 'foldr'。请参阅以下文档 '减少'。

例子

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'`-Method

foldl(op, itr; [init])

同样地 'reduce'，但保证从左到右的关联性。如果指定了命名参数’init'，它将被使用一次。通常，要使用空集合，您必须指定`init'。

另请参阅说明 'mapfoldl', `foldr'和 '积累'。

例子

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'`-Method

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

# '基。最大值'-Function

maximum(f, itr; [init])

返回为每个`itr`元素调用`f`函数的最高结果。

为空’itr’返回的值可以在’init’中指定。这应该是`max’的中性元素（即小于或等于任何其他元素的元素），因为没有指定`init`是否用于非空集合。

兼容性：Julia1.6

命名的’init’参数要求Julia版本至少为1.6。

例子

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

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

julia>maximum(sin,Real[];init=-1.0)#很好，因为输出是sin>=-1
-1.0

maximum(itr; [init])

返回集合中最大的项。

为空’itr’返回的值可以在’init’中指定。这应该是`max’的中性元素（即小于或等于任何其他元素的元素），因为没有指定`init`是否用于非空集合。

兼容性：Julia1.6

命名的’init’参数要求Julia版本至少为1.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(A::AbstractArray; dims)

根据指定的维度计算数组的最大值。另请参阅功能说明 max(a,b)，它返回两个（或更多）参数的最大值，并且可以使用’max’逐个元素应用于数组。(a,b)'。

另请参阅说明 '最大！, '极值, '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

# '基。最大！`-Function</no-翻译>

maximum!(r, A)

从"r"的单独测量计算"A"的最大值，并将结果写入"r"。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

例子

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

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

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

# '基。最小`—Function

minimum(f, itr; [init])

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

为空’itr’返回的值可以在’init’中指定。这应该是`min’的中性元素（即大于或等于任何其他元素的元素），因为没有指定`init`是否用于非空集合。

兼容性：Julia1.6

命名的’init’参数要求Julia版本至少为1.6。

例子

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

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

julia> minimum(sin, Real[]; init=1.0)  # хороший, поскольку вывод sin <= 1
1.0

minimum(itr; [init])

返回集合中的最小项目。

为空’itr’返回的值可以在’init’中指定。这应该是`min’的中性元素（即大于或等于任何其他元素的元素），因为没有指定`init`是否用于非空集合。

兼容性：Julia1.6

命名的’init’参数要求Julia版本至少为1.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(A::AbstractArray; dims)

根据指定的维度计算数组的最小值。另请参阅功能说明 min(a,b)，它返回两个（或更多）参数的最小值，并且可以使用’min逐元素应用于数组。(a,b)'。

另请参阅说明 '最低！, '极值, 'findmin', 'argmin'。

例子

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

julia>最小值(A,dims=1)
1×2矩阵{Int64}:
 1  2

julia>最小值（A，dims=2）
2×1矩阵{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

# '基。最低！`-Function</no-翻译>

minimum!(r, A)

从"r"的单独测量计算"A"的最小值，并将结果写入"r"。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

例子

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

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

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

# '基。极值`-Function</no-翻译>

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

一次计算最小值（mn）和最大值（mx）元素，将它们作为双元素元组返回。

为空’itr’返回的值可以在’init’中指定。它应该是一个双元素元组，其中第一个和第二个元素分别对于`min`和`max`是中性的（即大于/小于或等于任何其他元素）。结果，如果’itr’为空，则返回的元组`(mn,mx)`匹配条件’mn≥mx'。如果设置了’init’参数，它甚至可以用于非空的’itrs'。

兼容性：Julia1.8

命名的’init’参数要求Julia版本至少为1.8。

例子

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`是中性的（即大于/小于或等于任何其他元素）。用于非空集合。注意。假定对于空’itrs`返回值`(mn,mx)对应于条件`mn≥mx，尽管对于非空`itrs`它对应于条件`mn≤mx'。这是一个"自相矛盾"但预期的结果。

兼容性：Julia1.2

此方法需要至少1.2的Julia版本。

兼容性：Julia1.8

命名的’init’参数要求Julia版本至少为1.8。

例子

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

julia> extrema(sin, Real[]; init = (1.0, -1.0))  # хороший, поскольку –1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)

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

根据指定的维度计算最小和最大数组元素。

另请参阅说明 '最低', '最大`, '极值！`.

例子

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

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

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

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

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

计算将函数`f`应用于给定维度`A’中的每个元素的最小和最大结果。

兼容性：Julia1.2

此方法需要至少1.2的Julia版本。

# '基。极值！`-Function</no-翻译>

extrema!(r, A)

从"r"的单独测量计算"A"的最小值和最大值，并将结果写入"r"。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

兼容性：Julia1.8

此方法需要至少1.8的Julia版本。

例子

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'-Function

argmax(r::AbstractRange)

范围可以包含多个最大元素。在这种情况下，'argmax’返回最大索引，但不一定是第一个。

argmax(f, domain)

返回`f(x)最大化的`域`中的值`x。如果`f(x)`的多个最大值可用，则会找到第一个值。

'域’必须是非空的可迭代集合。

这些值使用"isless"进行比较。

兼容性：Julia1.7

此方法需要Julia至少1.7的版本。

另请参阅说明 `argmin'和 'findmax'。

例子

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

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

argmax(itr)

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

集合不应为空。

索引与方法返回的索引的类型相同。 '钥匙(itr)`和 `pairs(itr)'。

这些值使用"isless"进行比较。

另请参阅说明 'argmin`, 'findmax'。

例子

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

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

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

argmax(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'-Function

argmin(r::AbstractRange)

范围可以包含几个最小元素。在这种情况下，'argmin’返回最小索引，但不一定是第一个。

argmin(f, domain)

从"域"返回"x"的值，其中"f(x)"被最小化。如果有多个最小值可用于’f(x)`，那么将找到第一个值。

'域’必须是非空的可迭代集合。

值’NaN’被视为低于除`missing’之外的所有其他值。

兼容性：Julia1.7

此方法需要Julia至少1.7的版本。

另请参阅说明 `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)

返回集合中最小元素的索引或键。如果有几个最小元素可用，则将返回第一个值。

集合不应为空。

索引与方法返回的索引的类型相同。 '钥匙(itr)`和 `pairs(itr)'。

值’NaN’被视为低于除`missing’之外的所有其他值。

另请参阅说明 'argmax', 'findmin'。

例子

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

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

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

argmin(A; dims) -> indices

对于数组的输入数据，它根据指定的维度返回最小元素的索引。值’NaN’被视为低于除`missing’之外的所有其他值。

例子

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

朱莉娅>argmin（A，dims=1）
1×2矩阵{CartesianIndex{2}}:
 CartesianIndex(1,1)CartesianIndex(1,2)

朱莉娅>argmin（A，dims=2）
2×1矩阵{CartesianIndex{2}}:
 CartesianIndex(1,1)
 CartesianIndex(2,1)

# '基。findmax'-Function

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

返回由"f(x)"最大化的域中的值（输出数据"f"）以及"域"中此值的索引或键（"f"的输入数据）组成的对。如果有多个最大值可用，则将返回第一个值。

'domain’必须是非空的可迭代集合，支持 '钥匙'。索引与方法返回的索引的类型相同。 '密钥（域）`。

这些值使用"isless"进行比较。

兼容性：Julia1.7

此方法需要Julia至少1.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)

findmax(itr) -> (x, index)

返回’itr’集合的最大元素及其索引或键。如果有多个maximum元素可用，将返回第一个值。这些值使用"isless"进行比较。

索引与方法返回的索引的类型相同。 '钥匙(itr)`和 `pairs(itr)'。

另请参阅说明 'findmin', 'argmax', '最大值'。

例子

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'-Function

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

返回由域中的值（输出数据`f`）组成的对，其中`f（x）`被最小化，以及该值在`域’中的索引或键（`f`的输入数据）。如果有几个最小值可用，则将返回第一个值。

'域’必须是非空的可迭代集合。

索引与方法返回的索引的类型相同。 '钥匙(域)`和 '对（域’。

值’NaN’被视为低于除`missing’之外的所有其他值。

兼容性：Julia1.7

此方法需要Julia至少1.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)

findmin(itr) -> (x, index)

返回’itr’集合的最小元素及其索引或键。如果有几个最小元素可用，则将返回第一个值。值’NaN’被视为低于除`missing’之外的所有其他值。

索引与方法返回的索引的类型相同。 '钥匙(itr)`和 `pairs(itr)'。

另请参阅说明 'findmax', 'argmin`, '最小'。

例子

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！`-Function</no-翻译>

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

找到"A"的最大值和相应的线性索引，分别为"rval"和"rind"，将结果存储在"rval"和"rind"中。值’NaN’被视为大于除`missing’之外的所有其他值。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

# '基。芬德明！`-Function</no-翻译>

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

查找单个维度`rval`和`rind`的最小值`A`和相应的线性索引，将结果存储在`rval`和`rind’中。值’NaN’被视为低于除`missing’之外的所有其他值。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

# *'基。sum'`-Function

sum(f, itr; [init])

总结了`itr`的每个元素的调用函数`f’的结果。

对于小于系统字大小的有符号整数，返回类型`Int`，对于小于系统字大小的无符号整数，返回类型’UInt'。对于其余的参数，有一个通用的返回类型，所有参数都被提升到该类型。

为空’itr’返回的值可以在’init’中指定。这必须是加法操作的零元素（例如零），因为没有指定`init`是否用于非空集合。

兼容性：Julia1.6

命名的’init’参数要求Julia版本至少为1.6。

例子

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

注意对于具有小整数类型eltype的数组，`sum(A)`和`reduce(+,A)`之间的重要区别。

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

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

在第一种情况下，整数值被扩展到系统字的大小，因此结果是128。在第二种情况下，没有这样的扩展发生，并且整数值的溢出产生结果—128。

sum(itr; [init])

返回集合中所有项的总和。

为空’itr’返回的值可以在’init’中指定。这必须是加法操作的零元素（例如零），因为没有指定`init`是否用于非空集合。

兼容性：Julia1.6

命名的’init’参数要求Julia版本至少为1.6。

另请参阅说明 '减少', 'mapreduce`, '计数', '联盟'。

例子

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

# '基。总和！`-Function</no-翻译>

sum!(r, A)

通过"r"的各个维度总结"A"的元素，并将结果写入"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'-Function

prod(f, itr; [init])

返回`f`和`itr’的每个元素的乘积。

为空’itr’返回的值可以在’init’中指定。这必须是单个乘法元素（例如，一个），因为没有指定`init`是否用于非空集合。

兼容性：Julia1.6

命名的’init’参数要求Julia版本至少为1.6。

例子

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

prod(itr; [init])

返回集合中所有项的乘积。

为空’itr’返回的值可以在’init’中指定。这必须是单个乘法元素（例如，一个），因为没有指定`init`是否用于非空集合。

兼容性：Julia1.6

命名的’init’参数要求Julia版本至少为1.6。

另请参阅说明 '减少', '累积', '任何`。

例子

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

朱莉娅>prod（A，dims=1）
1×2矩阵{Int64}:
 3  8

朱莉娅>prod（A，dims=2）
2×1矩阵{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

# '基。刺激！`-Function</no-翻译>

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

检查逻辑集合的任何元素是否为’true`，一旦检测到`itr`中的`true’的第一个值，就返回’true'（根据缩写方案计算）。要使用缩写方案计算`false`，请使用 '全部`。

如果输入数据包含值 missing,missing’返回，前提是所有非缺失值都是’false（如果输入数据不包含值’true`，则相同），根据https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑]。

另请参阅说明 '全部`, '计数', '和`, [|](数学，md#基地。:

), [||](math.md#

例子

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`的任何元素返回值`true`，一旦找到`itr`中的第一个元素`p`返回`true`（根据缩写方案计算），则返回’true'。要使用缩写方案计算`false`，请使用 '全部`。

例子

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

# '基。任何！`-Function</no-翻译>

any!(r, A)

检查"r"的单个测量值"A"中的任何值是否等于"true"，并将结果写入"r"。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

例子

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

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

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

# '基。所有`-Method</no-翻译>

all(itr) -> Bool

检查逻辑集合的所有元素是否为’true`，一旦检测到`itr`中的`false’的第一个值，就返回’false'（根据缩写方案计算）。要使用缩写方案计算`true`，请使用 '任何`。

如果输入数据包含值 missing,missing’返回，前提是所有非缺失值都是’true（如果输入数据不包含值’false`，则相同），根据https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑]。

另请参阅说明 '全部！, '任何, '计数', &, &&, '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
错误

朱莉娅>所有([失踪,错误])
错误

朱莉娅>所有([真的,失踪])
失踪

# '基。所有`-Method</no-翻译>

all(p, itr) -> Bool

确定谓词`p`是否为`itr`的所有元素返回值`true`，一旦找到`itr`中的第一个元素就返回`false`，对于该元素，p`返回`false'（根据缩写方案计算）。要使用缩写方案计算`true，请使用 '任何`。

例子

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

# '基。全部！`-Function</no-翻译>

all!(r, A)

检查"r"的单个测量值"A"中的所有值是否为"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

# '基。计数'-Function

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

计算`itr`中函数`f`返回`true’的元素数。如果跳过’f`，则计算`itr`中`true’元素的数量（应该是布尔值的集合）。 'init’另外指定计数开始的值，因此也确定输出的类型。

兼容性：Julia1.6

在Julia1.6中添加了命名的’init’参数。

另请参阅说明 '任何`, '总和'。

例子

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

返回从"模式"到"字符串"的匹配数。这相当于调用`length(findall(pattern,string))`，但效率更高。

使用’overlap=true'，允许匹配序列与源字符串中的索引重叠，否则它们必须来自不同的字符范围。

兼容性：Julia1.3

此方法需要1.3或更高版本的Julia。

兼容性：Julia1.7

要使用符号作为模板，需要至少1.7的Julia版本。

例子

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=:)

计算函数`f`根据指定的测量值返回`true`的`A`中元素的数量。

兼容性：Julia1.5

在Julia1.5中添加了命名参数"dims"。

兼容性：Julia1.6

在Julia1.6中添加了命名的’init’参数。

例子

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'-Function

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

为迭代对象`c`的每个元素调用函数`f'。如果有多个可迭代参数，则会执行对"f"的元素调用，并且迭代在任何迭代器的末尾停止。

应该使用`foreach’而不是 'map'，如果`f`的结果不是必需的，例如，在`foreach（println，array）'中。

例子

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

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

朱莉娅>res
3元素向量{Int64}:
  1
 16
 49

julia>foreach（（x，y）->println（x，"with"，y），tri，'a'：'z'）
1与a
4与b
7与c

# '基。map'-Function

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

通过将`f`应用于每个元素来转换集合`c'。如果指定了多个集合参数，则会零碎地应用`f`，并且在用尽其中任何一个参数时终止过程。

另请参阅说明 '地图！, 'foreach', 'mapreduce, '地图单', '拉链', '迭代器。地图'。

例子

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'它们必须具有相同的轴 `轴'，结果将有相同的。

另请参阅功能说明 '广播'，这允许大小不匹配。

例子

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

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

julia> map(+, [1 2; 3 4], [1,10,100,1000], zeros(3,1))  # выполняет итерацию вплоть до исчерпания третьей коллекции
3-element Vector{Float64}:
   2.0
  13.0
 102.0

# '基。地图！`-Function</no-翻译>

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

同样地 'map'，但结果保存在`destination’中，而不是新集合中。 "目的地"必须至少是最小集合的大小。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

另请参阅说明 '地图', 'foreach', '拉链', '复制！`.

例子

julia> a = zeros(3);

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

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

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

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

通过将每个值从"val"转换为"f（val）"来修改"dict"。请注意，`dict`的类型不能更改：如果’f（val）`不是值类型`dict’的实例，那么如果可能，它将转换为值类型;否则，返回错误。

兼容性：Julia1.2

为’地图！(f,values(dict::AbstractDict))'需要至少1.2的Julia版本。

例子

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'-Method

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

将函数`f’应用于’itrs’中的每个元素，然后使用二进制函数`op’将结果简化为更简单的形式。如果指定了值’init`，则它必须是`op’的中性元素，这是为空集合返回的。没有指定`init`是否用于非空集合。通常，要使用空集合，您必须指定`init'。

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

兼容性：Julia1.2

对于具有多个迭代器的`mapreduce'，需要至少1.2的Julia版本。

例子

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

减少到更简单形式的关联性取决于实现。此外，一些实现可能会重用返回值`f`，它在`itr’中多次出现。改为使用 'mapfoldl'或 `mapfoldr'保证从左到右或从右到左的关联性，并为每个值调用`f'。

# '基。mapfoldl'-Method

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

同样地 'mapreduce'，但有保证从左到右的结合性，如 'foldl'。如果指定了命名参数’init`，它将被使用一次。通常，要使用空集合，您必须指定`init'。

# '基。mapfoldr'-Method

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

同样地 'mapreduce'，但有保证从右到左的关联性，如 'foldr'。如果指定了命名参数’init'，它将被使用一次。通常，要使用空集合，您必须指定`init'。

# '基。第一个'-Function

first(coll)

检索迭代集合的第一个元素。返回范围的起点 'AbstractRange'，即使它是空的。

另请参阅说明 '只', 'firstindex', '最后`。

例子

julia> first(2:2:10)
2

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

first(itr, n::Integer)

检索迭代`itr`集合的前`n`个元素，如果`itr`不够长，则检索更少的元素。

另请参阅说明 '起点', '迭代器。取'。

兼容性：Julia1.6

此方法需要至少1.6的Julia版本。

例子

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)
"∀ϵ≠"

# '基。最后`-Function

last(coll)

获取有序集合的最后一个元素，如果它可以在O（1）时间内计算。这是通过调用来实现的 'lastindex'以便获取最新的索引。返回范围的终点 'AbstractRange'，即使它是空的。

另请参阅说明 '第一`和 'endswith'。

例子

julia> last(1:2:10)
9

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

last(itr, n::Integer)

检索迭代`itr`集合的最后一个`n`元素，或者如果`itr`不够长，则检索更少的元素。

兼容性：Julia1.6

此方法需要至少1.6的Julia版本。

例子

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"

# '基。前面'-Function

front(x::Tuple)::Tuple

返回元组’Tuple'，它包括`x`的所有组件，除了最后一个。

另请参阅说明 '第一`, '尾巴'。

例子

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

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

# '基。尾'-Function

tail(x::Tuple)::Tuple

返回元组’Tuple'，它包括除第一个之外的所有`x’组件。

另请参阅说明 '正面`, '休息', '第一`, '迭代器。剥'。

例子

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

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

# '基。步骤'-Function

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

# '基。收集`-Method</no-翻译>

collect(collection)

返回包含集合或迭代器中所有元素的数组。对于字典，返回"向量"对的向量 'Pair''key=>value`。如果参数类似于数组或类型为迭代器 'HasShape'，结果将具有与参数相同的形状和相同数量的维度。

被使用内含物用于转换生成器表达式在`数组’中。因此，_在生成器中，您可以使用方括号中的条目而不是调用’collect';请参阅第二个例子。

例子

从集合中收集物品`单位范围{Int64}`:

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

从生成器中收集元素（与`[x^2for x in1:3]'的结果相同）:

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

# '基。收集`-Method</no-翻译>

collect(element_type, collection)

返回具有给定元素类型的数组，包含集合或可迭代对象的所有元素。结果具有与"集合"相同的形状和相同数量的维度。

例子

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

# '基。过滤器'-Function

filter(f, a)

返回集合`a`的副本，删除`f`为`false’的元素。函数’f’被传递一个参数。

兼容性：Julia1.4

要支持`a’作为元组，需要至少1.4的Julia版本。

另请参阅说明 '过滤器！`, '迭代器。过滤器'。

例子

julia> a = 1:10
1:10

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

filter(f)

创建一个使用`f`函数过滤其参数的函数 'filter'，即相当于`x->filter(f,x)`的函数。

返回的函数类型为"Base"。修正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

此方法需要至少1.9的Julia版本。

filter(f, d::AbstractDict)

返回`d’的副本，删除`f`为`false’的元素。 'Key=>value'对传递给’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, itr::SkipMissing{<:AbstractArray})

返回一个类似于指定迭代器`SkipMissing`中包含的数组的向量，但所有缺失的元素以及`f`返回值`false`的元素都将被删除。

兼容性：Julia1.2

此方法需要至少1.2的Julia版本。

例子

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

# '基。过滤器！`-Function</no-翻译>

filter!(f, a)

通过删除`f`为`false`的项目来更新集合`a'。函数’f’被传递一个参数。

例子

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

filter!(f, d::AbstractDict)

通过删除`f`为`false`的元素来更新`d'。 'Key=>value'对传递给’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"

# '基。替换'-Method

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

返回集合`A’的副本，其中对于’old_new’中的每对'old=>new，所有出现的`old`都被替换为`new'。平等是用 '等效。如果指定了’count`，则替换总共不超过`count’的出现。

使用promotion选择结果元素的类型（请参阅 'promote_type')，考虑到元素类型`A`和值类型`new`成对。如果省略了`count’并且’A’的元素是`Union’类型，则结果元素的类型不包括单个类型，这些类型由另一种类型的值替换：例如，'Union{T,Missing}如果`missing’被替换，`变为’T'。

另请参阅说明 '替换！, '剪接！, '删除！和 '插入！.

兼容性：Julia1.7

需要版本1.7来替换`元组`元素。

例子

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’的副本，其中`a`中的’x’的每个值都被`new(x)替换。如果指定了’count，则总共不超过`count’值被替换（替换被定义为`new(x)!==x')。

兼容性：Julia1.7

需要版本1.7来替换`元组`元素。

例子

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

# '基。替换！`-Function</no-翻译>

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

对于’old_new’中的每对'old=>new'，将集合`A`中所有出现的`old`替换为`new`。相等定义使用 '等效`。如果指定了’count`，则替换总共不超过`count’的出现。请参阅 '替换'。

例子

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

朱莉娅>更换！（套([1, 2, 3]), 1=>0)
套装{Int64} 有3个元素:
  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

# '基。rest'-Function

Base.rest(collection[, itr_state])

一个通用函数，用于接受’集合’的最后一个元素，从特定的迭代状态`itr_state’开始。返回`Tuple`如果`collection`是`Tuple`，子类型`AbstractVector`如果`collection`是`AbstractArray`，子类型`AbstractString`如果`collection`是`AbstractString`，否则回滚到`Iterators的任意迭代器。rest(collection[,itr_state])'。

您可以重载用户定义的集合类型以自定义行为。完全在赋值中读取在最终位置，例如'a，b。.. =集合'。

兼容性：Julia1.6

的’基地。rest’需要至少1.6的Julia版本。

另请参阅说明 '第一`, '迭代器。休息`, '基地。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])

# '基。split_rest'-Function

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

一个通用函数，用于分离’集合’的结尾，从特定的迭代状态`itr_state’开始。返回两个新集合的元组。第一个包含结尾的所有元素，除了组成第二个集合的`n`最后一个元素。

第一个集合的类型一般对应于类型 '基地。rest'，除了备份选项不是延迟的，而是可以快速形成一个向量。

您可以重载用户定义的集合类型以自定义行为。完全在赋值中读取在非有限位置，例如'a，b。..，c=集合`。

兼容性：Julia1.9

的’基地。split_rest’需要至少1.9的Julia版本。

另请参阅说明 '基地。休息'。

例子

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

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

朱莉娅>第一，基地。split_rest(a,1,状态)
(1, ([3, 2], [4]))

索引集合

# '基。getindex`-Function

getindex(collection, key...)

检索集合中指定的键或索引存储的值。语法'a[i,j,...]'被编译器转换为'getindex(a,i,j,...)`.

另请参阅说明 '得到', '钥匙`和 'eachindex'。

例子

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

julia> getindex(A, "a")
1

# '基。setindex！`-Function</no-翻译>

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'-Function

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

返回’集合’的第一个索引。如果设置了参数’d`，则按维度`d`返回’集合’的第一个索引。 A[begin]`和`A[1,begin]`的语法分别降级为`a[firstindex(A)]`和`A[1,firstindex(A,2)]。

另请参阅说明 '第一`, '轴', 'lastindex', '下一个'。

例子

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

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

# '基。lastindex'-Function

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

返回’集合’的最后一个索引。如果设置了参数’d`，则按维度`d`返回’集合’的最后一个索引。 A[end]`和`A[end,end]`的语法分别降级为`A[lastindex(A)]`和`A[lastindex(A,1),lastindex(A,2)]。

另请参阅说明 '轴', 'firstindex', '每个索引`, 'prevind'。

例子

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

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

它由以下类型完全实现:

部分由以下类型实现:

'抽象范围`
'单位范围`
'元组'
'抽象字符串'
'Dict'
'IdDict'
'弱者'
'命名'

<无翻译>

字典

'Dict'是一个标准的字典。其实施使用 'hash'作为密钥和 `isequal'来定义平等。为自定义类型定义这两个函数，以重新定义它们在哈希表中的存储方式。

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

'WeakKeyDict'是哈希表的实现，其中键是对对象的弱引用，因此可以被垃圾收集，即使这是由哈希表中的引用指示的。与`Dict’一样，此类型使用’hash’进行散列，使用`isequal’进行相等。与`Dict’不同，它不会在插入时转换键。

对象 'Dict'可以通过将使用`=>构造的对象对传递给构造函数来创建 'Dict'’+Dict("A"⇒1,"B"⇒2)+. 此调用将尝试从键和值推断类型信息（例如，在本例中，创建了一个"Dict"{String, Int64}`). 要显式指定类型，请使用语法'+Dict{KeyType,ValueType}(…)+. 例如’Dict{String,Int32}（"A"=>1，"B"=>2）。

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

如果指定了字典’D`，语法`D[x]返回键`x`的值（如果存在），或者它返回错误，并且`D[x]=y`在`D`中保存键值对+x⇒y+（替换键`x’的所有现有值）。 `+D[的多个参数。..]+'转换为元组。例如，语法’D[x,y]'等效于’D[(x,y)]，即它指的是一个键为元组`(x,y)`的值。

# '基。AbstractDict'-Type

AbstractDict{K, V}

类似字典的类型的超类型，键像’K’和值像’V'。 'Dict', 'IdDict'和其他类型是这种类型的子类型。 '摘要{K, V}'必须是迭代器’对{K, V}`.

# '基。Dict'-Type

Dict([itr])

'Dict{K,V}(``用类型为`K`的键和类型为’V’的值构建哈希表。键进行比较使用 'isequal'并使用散列 '哈希'。

如果传递了单个可迭代参数，则创建 `Dict'，其键值对取自参数生成的双元素元组'(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

键可以是可变的，但是如果您更改存储的键，哈希表可能会变得内部不一致，在这种情况下，`Dict`将无法正常工作。如果您需要更改密钥，另一种选择可能是 'IdDict'。

# '基。IdDict'-Type

IdDict([itr])

'IdDict{K,V}('执行哈希表的构造使用 `objectid'作为散列和==='作为相等运算符，具有类型为`K’的键和类型为`V’的值。有关更多参考信息，请参阅说明 'Dict'。集的此函数的版本 — 'IdSet'。

在下面的例子中，所有的’Dict’键都是’isequal'，并且以相同的方式进行散列，因此它们被复盖。 'IdDict’对对象ID执行散列，从而存储三个不同的键。

例子

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'-Type

WeakKeyDict([itr])

WeakKeyDict()构建一个哈希表，其中键是对启用垃圾回收的对象的弱引用，即使该引用存在于哈希表中。

有关其他参考信息，请参阅说明 'Dict'。请注意，与 Dict,'WeakKeyDict’在插入时不转换键，因为这要求在插入之前不在任何地方引用键对象。

另请参阅说明 'WeakRef'。

# *'基。ImmutableDict'`-Type

ImmutableDict

'ImmutableDict’是一个实现为不可变链表的字典，它最适合基于多个单独插入创建的小型字典。请注意，不能删除该值，尽管可以通过插入具有相同键的新值来部分重新定义和隐藏该值。

ImmutableDict(KV::Pair)

在`ImmutableDict`中为`key=>value'对创建一个新条目

在dict+中使用+(key⇒value)来检查此特定组合是否包含在属性集中。;
使用’get(dict,key,default)'获取特定键的最新值。

# '基。PersistentDict'-Type

PersistentDict

"PersistentDict"是一个字典，作为映射到哈希数组的前缀树实现，最适合需要数据保留的情况。每个操作都会返回一个与前一个无关的新字典，但基本实现占用的空间很小，并且允许为几个单独的字典共享内存。

它是一个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}()

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

# '基。haskey'-Function

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

# '基。获取'-Function

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()。要将默认值保存在字典中，请使用 '得到！.

假设使用`do`块语法的默认值调用此函数。,

get(dict, key) do
    # вычисленного здесь.
    time()
end

# '基。得到！`-Function</no-翻译>

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'-Function

getkey(collection, key, default)

如果`key`参数存在于`collection`中，则返回与`key’参数对应的键；否则，返回’default'。

例子

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

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

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

# '基。删除！`-Function</no-翻译>

delete!(collection, key)

删除集合中给定键的映射（如果有），并返回集合。

例子

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

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

julia> delete!(d, "b") # d остается без изменений
Dict{String, Int64} with 1 entry:
  "a" => 1

# '基。爸爸！`-Method</no-翻译>

pop!(collection, key[, default])

如果`key’存在于`collection`中，则删除并返回`key`的映射，否则返回`default`，如果未设置’default’值，则返回错误。

例子

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

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

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

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

# '基。键'-Function

keys(iterator)

对于包含键和值（例如，数组和字典）的迭代器或集合，返回基于键的迭代器。

# '基。值'-Function

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)`和`pairs(a)`遍历’a’并以相同的顺序返回元素。

例子

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

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

# '基。pairs'-Function

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’保证是 '基地。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'和 '轴'。

pairs(collection)

对于将一组键映射到一组值的任何集合，返回对`key=>value的迭代器。其中包括键是数组索引的数组。如果元素存储在哈希表中，就像`Dict`的情况一样，它们可以以不同的顺序返回。但是’keys(a)，`values(a)`和`pairs(a)`遍历’a’并以相同的顺序返回元素。

例子

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

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

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

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

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

# '基。合并'-Function

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

结合字体"初始"和"其他"的属性，后者优先。

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)`的备份选项。

兼容性：Julia1.1

要组合三个或更多的"NamedTuple"元组，需要至少1.1的Julia版本。

例子

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'-Function

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

基于指定的集合创建组合集合。如有必要，将提升生成集合的类型，以便将组合集合的类型放入其中。具有相同键的值将使用组合器函数进行组合。 Curried形式’mergewith(combine)返回函数'+(args…）→mergewith（合并，args。..)+.

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

兼容性：Julia1.5

Mergewith需要1.5或更高的Julia版本。

例子

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

# '基。合并！`-Function</no-翻译>

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

# '基。梅格威斯！`-Function</no-翻译>

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

使用来自其他集合的对更新集合。具有相同键的值将使用组合器函数进行组合。 Curried形式的’mergewith！(combine)返回函数'+(args…）→mergewith！（结合，args。..)+.

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

兼容性：Julia1.5

为’mergewith！'要求Julia版本不低于1.5。

例子

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

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

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

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

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

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

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

# '基。sizehint！`-Function</no-翻译>

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

建议为"s"系列中的至少"n"项预留容量。也就是说，如果您期望必须向`s`发送大量值，则可以通过提前执行一次来避免额外重新分配的成本。这可以提高性能。

如果’first’为’true'，则在开始集合之前保留任何额外空间。这使您可以加快后续调用’pushfirst！（而不是’推！). 如果集合未排序或"pushfirst!"，则使用此命名参数可能会导致错误""不支持她。

使用’shrink=true'（默认），如果其当前容量大于`n'，则可以减少收集容量。

另请参阅说明 '调整大小！`.

性能模型注意事项

对于支持`sizehint的类型！`,

"推！'方法’和’追加！一般来说，它们可以（但不一定）预先分配额外的存储。对于在’Base’中实现的类型，这通常使用针对标准场景优化的启发式机制来完成。
'sizehint！'可以控制这样的预分配。同样，这通常是为’Base’中的类型完成的。
""空！对于支持这种预分配的类型，'实际上是免费的（O（1））。

兼容性：Julia1.11

在Julia1.11版本中添加了参数"shrink"和"first"。

# '基。keytype'-Function

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

返回数组的键类型。这相当于 `eltype'的结果'keys(...)'并且主要是为了确保与字典接口的兼容性而提供的。

例子

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

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

兼容性：Julia1.2

在数组的情况下，此函数需要至少1.2的Julia版本。

keytype(type)

获取字典类型的键类型。它的工作原理类似 'eltype'。

例子

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

# '基。valtype'-Function

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

返回数组的值类型。完全一样 'eltype'，主要是为了与字典接口兼容而提供的。

例子

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

兼容性：Julia1.2

在数组的情况下，此函数需要至少1.2的Julia版本。

valtype(type)

获取字典类型的值类型。它的工作原理类似 'eltype'。

例子

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

它由以下类型完全实现:

'Dict'
'IdDict'
'弱者'

部分由以下类型实现:

'设置'
'比特集'
'IdSet'
'环境'
'数组'
'比特阵列'
'ImmutableDict`
'持久罪'
'迭代器。对`

集合，如集合

# '基。AbstractSet'-Type

AbstractSet{T}

一个类型的超类型，如元素类型为`T’的集合。 '设置', 'BitSet'和其他类型是这种类型的子类型。

# '基。设置'-Type</no-翻译>

Set{T} <: AbstractSet{T}

"Set"集合是可变容器，提供快速成员资格测试。

Set有效地实现了’in`，`union`和`intersect’等set操作。根据元素的"等效"定义，"集合"中的元素是唯一的。 '集合`中元素的顺序只是一个实现特性，不能依赖。

另请参阅说明 '抽象集`, '比特集', '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) имеет значение false
false

julia> NaN in s # isequal(NaN, NaN) имеет значение true
true

# '基。BitSet'-Type

BitSet([itr])

创建由给定的可迭代对象或空集生成的"Int"类型元素的排序集。它被实现为一个位字符串，因此，面向密集的整数集。如果集合是稀疏的（例如，它将只包含几个非常大的整数），请使用 '设置'。

# '基。IdSet'-Type

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

Id集{T}（）创建一个集合（见 'Set')，使用`===`作为相等运算符，值如’T'。

在下面的示例中，所有值都是’isequal`，因此它们在常规`Set’中被复盖。 'IdSet`使用'==='执行比较，因此存储三个不同的值。

例子

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'`-Function

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

创建一个对象，该对象包含来自所有参数的所有唯一元素。

第一个参数确定将返回哪种类型的容器。如果它是一个数组，它保留元素的原始顺序。

Unicode字符'∪'可以通过键入`\cup`然后在REPL Julia以及许多其他编辑器中按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

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

# '基。联合！`-Function</no-翻译>

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'-Function

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

创建一个包含在所有参数中出现的此类元素的集合。

第一个参数确定将返回哪种类型的容器。如果它是一个数组，它保留元素的原始顺序。

Unicode字符'∩'可以通过键入`\cap`然后在REPL Julia以及许多其他编辑器中按TAB键来输入。这是一个允许`s∩itr’的中缀运算符。

另请参阅说明 'setdiff', 'isdisjoint`, `issubset'和 'issetequal'。

兼容性：Julia1.8

从Julia1.8开始，intersect返回一个结果，其元素类型对应于两个输入对象的高级元素类型。

例子

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'-Function

setdiff(s, itrs...)

创建一组包含在`s`中的元素，但不包含在`itrs’中的任何可迭代集合中。使用数组保留顺序。

另请参阅说明 'setdiff！`, 'union'和 '相交'。

例子

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

# '基。setdiff！`-Function</no-翻译>

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`-Function

symdiff(s, itrs...)

执行构造传输集合中元素的对称差异。如果’s’不是’AbstractSet'，则保留顺序。

另请参阅说明 'symdiff！`, 'setdiff', 'union'和 '相交'。

例子

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

# '基。赛姆迪夫！`-Function</no-翻译>

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

建立传输集的对称差异，并用结果复盖"s"。如果’s’是数组，则保留顺序。请注意，在这种情况下，元素的多样性很重要。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

# '基。机密数据库！`-Function</no-翻译>

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

通过交集组合所有传递的集合，并用结果复盖"s"。使用数组保留顺序。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

# '基。issubset'-Function

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!'-Function</no-翻译>

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

如果`s’中包含’x`，则返回’true'。否则，它将`x’放入’s`并返回`false'。这是否等同于’in（x，s）'？真：（推！(s,x);false)`，但可能具有更有效的实现。

另请参阅说明 '在', '推！`, '设置'

兼容性：Julia1.11

此功能要求Julia的版本不低于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

# *'基。:⊈'`-Function</no-翻译>

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

否定'⊆'和'⊇`，即检查’a`不是’b’的子集。

另请参阅说明 issubset('iss`), ⊊.

例子

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

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

# *'基。:⊊'`-Function</no-翻译>

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

确定`a’是否是`b`的子集，但不等于它。

另请参阅说明 issubset('iss`), ⊈.

例子

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

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

# '基。issetequal'-Function

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

issetequal(x)

创建一个函数，其参数通过"x"进行比较 'issetequal'，即相当于`y->issetequal(y,x)`的函数。返回的函数类型为"Base"。修正2{typeof(issetequal)}`并可用于实施专门的方法。

兼容性：Julia1.11

此功能要求Julia的版本不低于1.11。

# '基。isdisjoint'-Function

isdisjoint(a, b) -> Bool

确定集合`a`和’b’是否不相交。它相当于’isempty(a∩b)'，但它可能更有效率。

另请参阅说明 '相交', '空位`, 'issetequal'。

兼容性：Julia1.5

此功能需要1.5或更高的Julia版本。

例子

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

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

isdisjoint(x)

创建一个函数，其参数通过"x"进行比较 'isdisjoint'，即相当于`y->isdisjoint(y,x)`的函数。返回的函数类型为"Base"。修正2{typeof(isdisjoint)}`并可用于实施专门的方法。

兼容性：Julia1.11

此功能需要Julia至少1.11的版本。

它由以下类型完全实现:

'设置'
'比特集'
'IdSet'

部分由以下类型实现:

'数组'

双向队列

# '基。推！`-Function</no-翻译>

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

将一个或多个"项"插入到"集合"中。如果’集合`是一个有序的容器，则将项目插入到末尾（按指定的顺序）。

例子

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

如果`集合’是有序的，请使用 '追加！将另一个集合的所有元素添加到其中。在前面的例子中的结果相当于’append！([1, 2, 3], [4, 5, 6]). 对于’AbstractSet’对象，您可以使用 '联合！`.

有关性能模型的说明，请参阅 'sizehint！`.

另请参阅说明 '推！`.

# '基。爸爸！`-Function</no-翻译>

pop!(collection) -> item

删除"集合"中的项目并返回它。如果’collection’是有序容器，则返回最后一个元素；对于无序容器，则返回任意元素。

另请参阅说明 'popfirst！, 'popat！, '删除！, '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

pop!(collection, key[, default])

如果`key’存在于`collection`中，则删除并返回`key`的映射，否则返回`default`，如果未设置’default’值，则返回错误。

例子

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

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

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

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

# '基。波帕特！`-Function</no-翻译>

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

通过指定的`i`删除元素并返回它。随后的元素被移位以填充所产生的间隙。如果’i’不是`a’的有效索引，则返回’default`，或者如果未指定`default’则发生错误。

另请参阅说明 '啪！, 'popfirst！, '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]
[...]

# '基。先推！`-Function</no-翻译>

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

在"集合"的开头插入一个或多个"项"元素。

在许多其他编程语言中，此函数称为"unshift"。

例子

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

# '基。第一个！`-Function</no-翻译>

popfirst!(collection) -> item

从"集合"中删除第一个"项目"元素。

在许多其他编程语言中，此函数称为"shift"。

另请参阅说明 '啪！, 'popat！, '删除！`.

例子

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

# '基。插入！`-Function</no-翻译>

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

通过索引`index`将元素`item`插入到`a`中。 'index’是`item`元素在结果’a’中的索引。

另请参阅说明 '推！, '替换', 'popat！, '剪接！`.

例子

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

# '基。deleteat！`-Function</no-翻译>

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

删除指定索引`i`处的元素，并返回修改后的数组`a`。随后的元素被移位以填充所产生的间隙。

另请参阅说明 'keepat！, '删除！, 'popat！, '剪接！.

例子

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！`-Function</no-翻译>

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

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

逻辑索引的现场版本是’a=a[m]`。即呼叫’keepat！(a,m)`对于相同长度的向量`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

# '基。剪接！`-Function</no-翻译>

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

删除指定索引处的项并返回已删除的项。随后的元素向左移位以填充由此产生的间隙。如果指定了有序集合中的替换值，则插入它们而不是删除的元素。

另请参阅说明 '替换', '删除！, 'deleteat！, '啪！, '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`之前插入`替换’而不删除元素，请使用’splice！（集合，n：n-1，替换）`。

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

删除指定索引处的项并返回包含已删除项的集合。随后的元素向左移动以填充由此产生的间隙。如果指定了有序集合中的替换值，则插入它们而不是删除的项;在这种情况下，`indexes`应该是’AbstractUnitRange’类型。

要在索引`n`之前插入`替换’而不删除元素，请使用’splice！（集合，n：n-1，替换）`。

如果任何修改的参数被放置在与任何其他参数相同的内存区域中，则行为可能是意外的。

兼容性：Julia1.5

在Julia1.5之前的版本中，'indexes`参数必须始终为`UnitRange’类型。

兼容性：Julia1.8

在Julia1.8之前的版本中，插入替换值时，'indexes’参数必须始终为`UnitRange’类型。

例子

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

# '基。调整大小！`-Function</no-翻译>

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

朱莉娅>长度(a)
8

朱莉娅>a[1:6]
6元素向量{Int64}:
 6
 5
 4
 3
 2
 1

# '基。追加！`-Function</no-翻译>

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

对于有序容器`"集合"将每个集合的元素添加到末尾的"集合"中。

兼容性：Julia1.6

要指定要附加的多个集合，您需要至少1.6的Julia版本。

例子

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！和 '推！'（倒序）。

# '基。准备！`-Function</no-翻译>

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

在`a’开头的`collections’中插入每个集合中的项目。

如果在`collections`中指定了多个集合，则保留顺序：`collections[1]`的元素将是`a`中最左边的，依此类推。

兼容性：Julia1.6

要在开始时指定要附加的多个集合，您需要至少1.6的Julia版本。

例子

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

它由以下类型完全实现:

'向量'（或一维数组 `数组')
'BitVector`（或一维数组 'BitArray')

有用的集合

# '核心。对'-Type</no-翻译>

Pair(x, y)
x => y

创建’Pair’类型的’Pair’对象{typeof(x), typeof(y)}`. 元素存储在"第一"和"第二"字段中。它们也可以通过迭代访问（但`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"

# '基。对'-Type</no-翻译>

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

将索引容器转换为相同数据的字典表示形式。由于基础数据的键空间发生变化，此对象可能会变得无效。