Сборки и структуры данных

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

Переместить итератор, чтобы получить следующий элемент. Если больше элементов нет, следует вернуть nothing. В противном случае должен быть возвращён 2-кортеж из следующего элемента и нового состояния итерации.

IteratorSize(itertype::Type) -> IteratorSize

Учитывая тип итератора, вернуть одно из следующих значений:

• SizeUnknown() если длина (количество элементов) не может быть определена заранее.
• HasLength() если длина фиксированная и конечная.
• HasShape{N}() если известна длина плюс представление многомерной формы (как для массива). В этом случае N должно возвращать количество измерений, а функция axes допустима для итератора.
• IsInfinite() если итератор генерирует значения бесконечно.

Значение по умолчанию (для итераторов, не определяющих эту функцию) — HasLength(). Это означает, что большинство итераторов предполагается, что реализуют length.

Этот признак обычно используется для выбора между алгоритмами, которые предварительно выделяют память для своего результата, и алгоритмами, которые увеличивают свой результат по мере необходимости.

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

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

IteratorEltype(itertype::Type) -> IteratorEltype

Учитывая тип итератора, вернуть одно из следующих значений:

• EltypeUnknown() если тип элементов, возвращаемых итератором, заранее неизвестен.
• HasEltype() если тип элемента известен и eltype вернёт осмысленное значение.

HasEltype() является значением по умолчанию, поскольку итераторы предполагается, что реализуют eltype.

Этот признак обычно используется для выбора между алгоритмами, которые предварительно выделяют результат определённого типа, и алгоритмами, которые выбирают тип результата на основе типов генерируемых значений.

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

AbstractRange{T}

Супертип для диапазонов с элементами типа T. UnitRange и другие типы являются подтипами этого.

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

Супертип для порядковых диапазонов с элементами типа T с шагом(ами) типа S. Шаги всегда должны быть точными кратными oneunit, и T должен быть «дискретным» типом, который не может иметь значения меньше, чем oneunit. Например, типы Integer или Date подходят, тогда как Float64 нет (поскольку этот тип может представлять значения меньше, чем oneunit(Float64). UnitRange, StepRange и другие типы являются подтипами этого.

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

Супертип для диапазонов с шагом oneunit(T) с элементами типа T. UnitRange и другие типы являются подтипами этого.

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

Диапазоны с элементами типа T с шагом типа S. Шаг между каждым элементом постоянен, и диапазон определяется начальным start и конечным stop типа T и шагом типа S. Ни T, ни S не должны быть типами с плавающей точкой. Синтаксис a:b:c с b > 1 и a, b, и c целыми числами создаёт StepRange.

Примеры

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

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

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

UnitRange{T<:Real}

Диапазон, параметризованный начальным start и конечным stop типа T, заполненный элементами с шагом 1 от start до превышения stop . Синтаксис a:b с a и b целыми числами создаёт UnitRange.

Примеры

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

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

LinRange{T}

Диапазон с len линейно распределёнными элементами между его началом start и концом stop. Величина шага контролируется len, которое должно быть типа Int.

Примеры

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

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

isempty(collection) -> Bool

Определить, пуста ли коллекция (не имеет элементов).

Примеры

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

Вернуть true если задачи не ожидают условия, false в противном случае.

empty!(collection) -> collection

Удалить все элементы из collection.

Примеры

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

julia> empty!(A);

julia> A
Dict{String, Int64}()

length(collection) -> Integer

Возвращает количество элементов в коллекции.

Используйте lastindex, чтобы получить последний допустимый индекс индексируемой коллекции.

Примеры

julia> length(1:5)
5

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

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

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

Определяет, содержится ли элемент в данной коллекции в том смысле, что он == одному из значений, сгенерированных при итерации по коллекции. Возвращает значение Bool, за исключением случаев, когда item является missing или collection содержит missing, но не item, в этом случае возвращается missing (трёхзначная логика, соответствующая поведению any и ==).

Некоторые коллекции следуют несколько иному определению. Например, Set проверяют, равен ли элемент isequal одному из элементов. Dict ищут key=>value пары, а ключ сравнивается с использованием isequal. Для проверки наличия ключа в словаре используйте haskey или k in keys(dict). Для этих коллекций результат всегда является Bool и никогда missing.

Для определения того, не содержится ли элемент в данной коллекции, см. :∉. Вы также можете инвертировать in с помощью !(a in b), что логически аналогично "not in".

При широковещательной передаче с in.(items, collection) или items .∈ collection, оба item и collection передаются широко, что часто не является желаемым результатом. Например, если оба аргумента являются векторами (и размерности совпадают), результат — вектор, указывающий, равен ли каждый элемент в коллекции items элементу в соответствующей позиции в collection. Чтобы получить вектор, указывающий, содержится ли каждый элемент в items в collection, оберните collection в кортеж или Ref следующим образом: in.(items, Ref(collection)) или items .∈ Ref(collection).

Примеры

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> !(21 in a)
true

julia> !(19 in a)
false

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

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

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

Отрицание ∈ и ∋, т. е. проверяет, что item не содержится в collection.

При широковещательной передаче с items .∉ collection, оба item и collection передаются широко, что часто не является желаемым результатом. Например, если оба аргумента являются векторами (и размерности совпадают), результат — вектор, указывающий, не содержится ли каждый элемент в коллекции items в элементе в соответствующей позиции в collection. Чтобы получить вектор, указывающий, не содержится ли каждый элемент в items в collection, оберните collection в кортеж или Ref следующим образом: items .∉ Ref(collection).

Примеры

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

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

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

eltype(type)

Определяет тип элементов, генерируемых при итерации по коллекции данного type. Для словарей типов это будет Pair{KeyType,ValType}. Определение eltype(x) = eltype(typeof(x)) предоставлено для удобства, чтобы можно было передавать экземпляры вместо типов. Однако форма, принимающая аргумент типа, должна быть определена для новых типов.

Примеры

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

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

indexin(a, b)

Возвращает массив, содержащий первый индекс в b для каждого значения в a, являющегося элементом b. Массив вывода содержит nothing всякий раз, когда a не является элементом b.

Примеры

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

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

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

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

unique(itr)

Возвращает массив, содержащий только уникальные элементы коллекции itr, как определяется isequal, в порядке их первоначального появления. Тип элементов входных данных сохраняется.

Примеры

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

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

unique(f, itr)

Возвращает массив, содержащий одно значение из itr для каждого уникального значения, полученного в результате применения f к элементам itr.

Примеры

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

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

Возвращает уникальные области A вдоль размерности dims.

Примеры

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

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

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

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

[:, :, 2] =
 1
 0

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

unique!(f, A::AbstractVector)

Выбирает одно значение из A для каждого уникального значения, полученного в результате применения f к элементам A, а затем возвращает изменённый A.

Примеры

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

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

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

unique!(A::AbstractVector)

Удаляет повторяющиеся элементы, как определено isequal, затем возвращает изменённый A. unique! вернёт элементы A в порядке их появления. Если порядок возвращаемых данных не важен, то вызов (sort!(A); unique!(A)) будет значительно эффективнее, если элементы A можно отсортировать.

Примеры

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

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

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

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

julia> sort!(B);  # unique! is able to process sorted data much more efficiently.

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

allunique(itr) -> Bool

Возвращает true, если все значения из itr являются уникальными при сравнении с isequal.

Примеры

julia> a = [1; 2; 3]
3-element Vector{Int64}:
 1
 2
 3

julia> allunique([a, a])
false

reduce(op, itr; [init])

Уменьшите заданную коллекцию itr с помощью заданного бинарного оператора op. Если задано, начальное значение init должно быть нейтральным элементом для op, которое будет возвращено для пустых коллекций. Не определено, используется ли init для непустых коллекций.

Для пустых коллекций потребуется предоставление init, за исключением некоторых особых случаев (например, когда op является одним из +, *, max, min, &, |) когда Julia может определить нейтральный элемент op.

Уменьшения для некоторых часто используемых операторов могут иметь специальные реализации и должны использоваться вместо них: maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr).

Ассоциативность уменьшения зависит от реализации. Это означает, что вы не можете использовать неассоциативные операции, такие как -, потому что неопределено, должна ли 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

foldl(op, itr; [init])

Подобно reduce, но с гарантированной левой ассоциативностью. Если предоставлено, ключевое слово init будет использовано ровно один раз. В общем случае необходимо предоставить init для работы с пустыми коллекциями.

Примеры

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

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

foldr(op, itr; [init])

Подобно reduce, но с гарантированной правой ассоциативностью. Если предоставлено, ключевое слово init будет использовано ровно один раз. В общем случае необходимо предоставить init для работы с пустыми коллекциями.

Примеры

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

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

maximum(f, itr; [init])

Возвращает наибольший результат вызова функции f для каждого элемента itr.

Значение, возвращаемое для пустой itr, может быть задано с помощью init. Оно должно быть нейтральным элементом для max (т.е. которое меньше или равно любому другому элементу), так как не определено, используется ли init для непустых коллекций.

Примеры

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

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

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

maximum(itr; [init])

Возвращает наибольший элемент в коллекции.

Значение, возвращаемое для пустой itr, может быть задано с помощью init. Оно должно быть нейтральным элементом для max (т.е. которое меньше или равно любому другому элементу), так как не определено, используется ли init для непустых коллекций.

Примеры

julia> maximum(-20.5:10)
9.5

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

julia> maximum(())
ERROR: ArgumentError: reducing over an empty collection is not allowed
Stacktrace:
[...]

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

maximum(A::AbstractArray; dims)

Вычисляет максимальное значение массива по заданным измерениям. См. также функцию max(a,b) для определения максимума двух или более аргументов, которые могут быть применены поэлементно к массивам через max.(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(f, A::AbstractArray; dims)

Вычисляет максимальное значение вызова функции f для каждого элемента массива по заданным измерениям.

Примеры

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

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

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

maximum!(r, A)

Вычисляет максимальное значение A по одиночным измерениям r, и записывает результаты в r.

Примеры

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

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

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

minimum(f, itr; [init])

Возвращает наименьший результат вызова функции f для каждого элемента itr.

Значение, возвращаемое для пустой itr, может быть задано с помощью init. Оно должно быть нейтральным элементом для min (т.е. которое больше или равно любому другому элементу), так как не определено, используется ли init для непустых коллекций.

Примеры

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

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

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

minimum(itr; [init])

Возвращает наименьший элемент в коллекции.

Значение, возвращаемое для пустой itr, может быть задано с помощью init. Оно должно быть нейтральным элементом для min (т.е. которое больше или равно любому другому элементу), так как не определено, используется ли init для непустых коллекций.

Примеры

julia> minimum(-20.5:10)
-20.5

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

julia> minimum([])
ERROR: ArgumentError: reducing over an empty collection is not allowed
Stacktrace:
[...]

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

minimum(A::AbstractArray; dims)

Вычисляет минимальное значение массива по заданным измерениям. См. также функцию min(a,b) для определения минимума двух или более аргументов, которые могут быть применены поэлементно к массивам через min.(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(f, A::AbstractArray; dims)

Вычисляет минимальное значение вызова функции f для каждого элемента массива по заданным измерениям.

Примеры

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

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

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

minimum!(r, A)

Вычисляет минимальное значение A по одиночным измерениям r, и записывает результаты в r.

Примеры

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

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

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

extrema(itr) -> Tuple

Вычисляет минимальный и максимальный элемент за один проход и возвращает их как пару.

Примеры

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

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

extrema(f, itr) -> Tuple

Вычисляет минимальное и максимальное значение f, применённое к каждому элементу в itr, и возвращает их как пару. Только один проход осуществляется по itr.

Примеры

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

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.

argmax(r::AbstractRange)

Диапазоны могут иметь несколько максимальных элементов. В этом случае argmax вернёт максимальный индекс, но не обязательно первый.

argmax(itr)

Возвращает индекс или ключ максимального элемента в коллекции. Если есть несколько максимальных элементов, возвращается первый.

Коллекция не должна быть пустой.

Примеры

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 рассматривается как большее, чем все остальные значения.

Примеры

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

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

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

argmin(r::AbstractRange)

Диапазоны могут иметь несколько минимальных элементов. В этом случае argmin вернёт минимальный индекс, но не обязательно первый.

argmin(itr)

Возвращает индекс или ключ минимального элемента в коллекции. Если есть несколько минимальных элементов, возвращается первый.

Коллекция не должна быть пустой.

Примеры

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 рассматривается как меньшее, чем все остальные значения.

Примеры

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

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

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

findmax(itr) -> (x, index)

Возвращает максимальный элемент коллекции itr и его индекс или ключ. Если есть несколько максимальных элементов, возвращается первый. Если любой элемент данных равен NaN, возвращается этот элемент. Результат соответствует max.

Коллекция не должна быть пустой.

Примеры

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 рассматривается как большее, чем все остальные значения.

Примеры

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

findmin(itr) -> (x, index)

Возвращает минимальный элемент коллекции itr и его индекс или ключ. Если есть несколько минимальных элементов, возвращается первый. Если любой элемент данных равен NaN, возвращается этот элемент. Результат соответствует min.

Коллекция не должна быть пустой.

Примеры

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

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

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

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

Для массива ввода возвращает значение и индекс минимума по заданным измерениям. NaN рассматривается как меньшее, чем все остальные значения.

Примеры

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

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

Находит максимальное значение A и соответствующий линейный индекс по одиночным измерениям rval и rind, и сохраняет результаты в rval и rind. NaN рассматривается как большее, чем все остальные значения.

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

Находит минимальное значение A и соответствующий линейный индекс по одиночным измерениям rval и rind, и сохраняет результаты в rval и rind. NaN рассматривается как меньшее, чем все остальные значения.

sum(f, itr; [init])

Суммирует результаты вызова функции f для каждого элемента itr.

Тип возвращаемого значения — Int для целых знаков с знаком меньше размера машинного слова и UInt для целых знаков без знака меньше размера машинного слова. Для всех остальных аргументов находится общий тип возвращаемого значения, к которому все аргументы приводятся.

Значение, возвращаемое для пустой itr, может быть задано init. Оно должно быть аддитивным идентитетом (т.е. нулём), так как не определено, используется ли init для непустых коллекций.

Примеры

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

Обратите внимание на важное различие между sum(A) и reduce(+, A) для массивов с целым типом элементов малого размера:

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

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

В первом случае целые числа расширяются до размера машинного слова, поэтому результат равен 128. Во втором случае такого расширения не происходит, и переполнение целых чисел приводит к значению -128.

sum(itr; [init])

Возвращает сумму всех элементов в коллекции.

Тип возвращаемого значения — Int для целых знаков с знаком меньше размера машинного слова и UInt для целых знаков без знака меньше размера машинного слова. Для всех остальных аргументов находится общий тип возвращаемого значения, к которому все аргументы приводятся.

Значение, возвращаемое для пустой itr, может быть задано init. Оно должно быть аддитивным идентитетом (т.е. нулём), так как не определено, используется ли init для непустых коллекций.

Примеры

julia> sum(1:20)
210

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

sum(A::AbstractArray; dims)

Суммирует элементы массива по заданным измерениям.

Примеры

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

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

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

sum(f, A::AbstractArray; dims)

Суммирует результаты вызова функции f для каждого элемента массива по заданным измерениям.

Примеры

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

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

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

sum!(r, A)

Суммирует элементы A по одиночным измерениям r, и записывает результаты в r.

Примеры

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

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

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

prod(f, itr; [init])

Возвращает произведение f для каждого элемента itr.

Тип возвращаемого значения — Int для целых знаков с знаком меньше размера машинного слова и UInt для целых знаков без знака меньше размера машинного слова. Для всех остальных аргументов находится общий тип возвращаемого значения, к которому все аргументы приводятся.

Значение, возвращаемое для пустой itr, может быть задано init. Оно должно быть мультипликативным идентитетом (т.е. единицей), так как не определено, используется ли init для непустых коллекций.

Примеры

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

prod(itr; [init])

Возвращает произведение всех элементов коллекции.

Тип возвращаемого значения — Int для целых чисел со знаком, меньших размера машинного слова, и UInt для целых чисел без знака, меньших размера машинного слова. Для всех остальных аргументов находится общий тип возвращаемого значения, к которому все аргументы приводятся.

Значение, возвращаемое для пустой itr коллекции, может быть задано init. Оно должно быть мультипликативной единицей (т.е. единицей), так как неявно, используется ли init для непорожних коллекций.

Примеры

julia> prod(1:5)
120

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

prod(A::AbstractArray; dims)

Умножение элементов массива по заданным измерениям.

Примеры

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

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

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

prod(f, A::AbstractArray; dims)

Умножение результатов вызова функции f для каждого элемента массива по заданным измерениям.

Примеры

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

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

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

prod!(r, A)

Умножение элементов A по одиночным измерениям r, и запись результатов в r.

Примеры

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

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

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

any(itr) -> Bool

Проверка, являются ли какие-либо элементы булевой коллекции true, возвращая true как только встретится первое true значение в itr (короткое замыкание).

Если входные данные содержат значения missing, возвращается missing , если все значения, кроме пропущенных, являются false (или, что эквивалентно, если ввод не содержит значения true), следуя трёхзначной логике.

Примеры

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> any(a)
true

julia> any((println(i); v) for (i, v) in enumerate(a))
1
true

julia> any([missing, true])
true

julia> any([false, missing])
missing

any(p, itr) -> Bool

Определите, возвращает ли предикат p true для каких-либо элементов itr, возвращая true как только будет встречен первый элемент в itr, для которого p возвращает true (короткое замыкание).

Если входные данные содержат значения missing, возвращается missing , если все значения, кроме пропущенных, являются false (или, что эквивалентно, если ввод не содержит значение true ), следуя трёхзначной логике.

Примеры

julia> any(i->(4<=i<=6), [3,5,7])
true

julia> any(i -> (println(i); i > 3), 1:10)
1
2
3
4
true

julia> any(i -> i > 0, [1, missing])
true

julia> any(i -> i > 0, [-1, missing])
missing

julia> any(i -> i > 0, [-1, 0])
false

any!(r, A)

Проверка, есть ли какие-либо значения в A по одиночным измерениям r, которые равны true, и запись результатов в r.

Примеры

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

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

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

all(itr) -> Bool

Проверка, что все элементы булевой коллекции являются true, возвращая false как только встретится первое false значение в itr (короткое замыкание).

Если входные данные содержат значения missing, возвращается missing , если все значения, кроме пропущенных, являются true (или, что эквивалентно, если ввод не содержит значение false ), следуя трёхзначной логике.

Примеры

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> all(a)
false

julia> all((println(i); v) for (i, v) in enumerate(a))
1
2
false

julia> all([missing, false])
false

julia> all([true, missing])
missing

all(p, itr) -> Bool

Определите, возвращает ли предикат p значение true для всех элементов itr, возвращая false как только будет встречен первый элемент в itr, для которого p возвращает false (короткое замыкание).

Если входные данные содержат значения missing, возвращается missing , если все значения, кроме пропущенных, являются true (или, что эквивалентно, если ввод не содержит значение false ), следуя трёхзначной логике.

Примеры

julia> all(i->(4<=i<=6), [4,5,6])
true

julia> all(i -> (println(i); i < 3), 1:10)
1
2
3
false

julia> all(i -> i > 0, [1, missing])
missing

julia> all(i -> i > 0, [-1, missing])
false

julia> all(i -> i > 0, [1, 2])
true

all!(r, A)

Проверка, что все значения в A по одиночным измерениям r равны true, и запись результатов в r.

Примеры

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

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

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

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

Подсчёт количества элементов в itr , для которых функция f возвращает true. Если f опущено, подсчитывается количество true элементов в itr (которая должна быть коллекцией булевых значений). 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{AbstractString,AbstractPattern},
    string::AbstractString;
    overlap::Bool = false,
)

Возвращает количество совпадений для pattern в string. Это эквивалентно вызову length(findall(pattern, string)), но более эффективно.

Если overlap=true, совпадающие последовательности могут перекрывать индексы в исходной строке, в противном случае они должны быть из непересекающихся диапазонов символов.

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

Подсчёт количества элементов в A , для которых f возвращает true по заданным измерениям.

Примеры

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

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

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

any(p, itr) -> Bool

Определите, возвращает ли предикат p значение true для каких-либо элементов itr, возвращая true как только будет встречен первый элемент в itr, для которого p возвращает true (короткое замыкание).

Если входные данные содержат значения missing, возвращается missing , если все значения, кроме пропущенных, являются false (или, что эквивалентно, если ввод не содержит значение true ), следуя трёхзначной логике.

Примеры

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

all(p, itr) -> Bool

Определить, возвращает ли предикат p значение true для всех элементов itr, возвращая false как только будет встречен первый элемент в itr, для которого p возвращает false (короткое замыкание).

Если входные данные содержат значения missing, вернуть missing если все значения, отличные от отсутствующих, равны true (или эквивалентно, если входные данные не содержат значения false), следуя трёхзначной логике.

Примеры

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

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

Вызвать функцию f для каждого элемента итерируемого объекта c. Для нескольких итерируемых аргументов f вызывается поэлементно. foreach следует использовать вместо map, когда результаты f не требуются, например, в foreach(println, array).

Примеры

julia> a = 1:3:7;

julia> foreach(x -> println(x^2), a)
1
16
49

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

Преобразовать коллекцию c путём применения f к каждому элементу. Для нескольких аргументов-коллекций, применение f поэлементно.

См. также: mapslices

Примеры

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

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

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

Как map, но сохраняет результат в destination вместо новой коллекции. destination должна быть как минимум не меньше первой коллекции.

Примеры

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

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

Изменяет dict, преобразуя каждое значение из val в f(val). Обратите внимание, что тип dict не может быть изменён: если f(val) не является экземпляром типа значения dict, то он будет преобразован к типу значения, если это возможно, а в противном случае будет выведено сообщение об ошибке.

Примеры

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

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

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

Применить функцию f к каждому элементу(ам) в itrs, а затем свести результат с помощью бинарной функции op. Если задан, init должен быть нейтральным элементом для op, который будет возвращён для пустых коллекций. Не определено, используется ли init для непустых коллекций. В целом, будет необходимо предоставить init для работы с пустыми коллекциями.

mapreduce функционально эквивалентно вызову reduce(op, map(f, itr); init=init), но в целом будет выполняться быстрее, поскольку не нужно создавать промежуточную коллекцию. См. документацию для reduce и map.

Примеры

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

Ассоциативность сокращения зависит от реализации. Кроме того, некоторые реализации могут повторно использовать возвращаемое значение f для элементов, которые появляются несколько раз в itr. Используйте mapfoldl или mapfoldr вместо этого для гарантированной левой или правой ассоциативности и вызова f для каждого значения.

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

Как mapreduce, но с гарантированной левой ассоциативностью, как в foldl. Если указан, ключевой аргумент init будет использован ровно один раз. В целом, будет необходимо предоставить init для работы с пустыми коллекциями.

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

Как mapreduce, но с гарантированной правой ассоциативностью, как в foldr. Если указан, ключевой аргумент init будет использован ровно один раз. В целом, будет необходимо предоставить init для работы с пустыми коллекциями.

first(coll)

Получить первый элемент итерируемой коллекции. Возвратить начальную точку AbstractRange, даже если она пуста.

Примеры

julia> first(2:2:10)
2

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

first(itr, n::Integer)

Получить первые n элементы итерируемой коллекции itr, или меньше элементов, если v недостаточно длинна.

Примеры

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)

Получить строку, состоящую из первых n символов s.

Примеры

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

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

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

last(coll)

Получить последний элемент упорядоченной коллекции, если он может быть вычислен за O(1) времени. Это достигается вызовом lastindex для получения последнего индекса. Возвратить конечную точку AbstractRange, даже если она пуста.

Примеры

julia> last(1:2:10)
9

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

last(itr, n::Integer)

Получить последние n элементы итерируемой коллекции itr, или меньше элементов, если v недостаточно длинна.

Примеры

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)

Получить строку, состоящую из последних n символов s.

Примеры

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

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

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

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.

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.

step(r)

Получить шаг объекта AbstractRange.

Примеры

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

julia> step(range(2.5, stop=10.9, length=85))
0.1

collect(collection)

Возвращает Array всех элементов в коллекции или итераторе. Для словарей возвращает Pair{KeyType, ValType}. Если аргумент является массивоподобным или итератором с атрибутом HasShape, результат будет иметь такую же форму и количество измерений, как и аргумент.

Примеры

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

collect(element_type, collection)

Возвращает Array с заданным типом элемента всех элементов в коллекции или итерируемом объекте. Результат имеет такую же форму и количество измерений, как и collection.

Примеры

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

filter(f, a)

Возвращает копию коллекции a, удаляя элементы, для которых f является false. Функция f получает один аргумент.

Примеры

julia> a = 1:10
1:10

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

filter(f, d::AbstractDict)

Возвращает копию d, удаляя элементы, для которых f является false. Функция f получает key=>value пары.

Примеры

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

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

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

Возвращает вектор, похожий на массив, обернутый данным SkipMissing итератором, но с удалёнными всеми отсутствующими элементами и теми, для которых f возвращает false.

Примеры

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

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

filter!(f, a)

Обновляет коллекцию a, удаляя элементы, для которых f является false. Функция f получает один аргумент.

Примеры

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

filter!(f, d::AbstractDict)

Обновляет d, удаляя элементы, для которых f является false. Функция f получает key=>value пары.

Пример

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

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

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

Возвращает копию коллекции A где для каждой пары old=>new в old_new, все вхождения old заменяются на new. Равенство определяется с помощью isequal. Если count указано, то заменяется не более count вхождений в целом.

Тип элемента результата выбирается с использованием повышения (см. promote_type) на основе типа элемента A и типов значений new в парах. Если count опущено, и тип элемента A является Union, тип элемента результата не будет включать типы-сингултоны, которые заменяются значениями другого типа: например, Union{T,Missing} станет T, если missing заменяется.

См. также replace!.

Примеры

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

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

replace(new::Function, A; [count::Integer])

Возвращает копию A где каждое значение x в A заменяется на new(x). Если count указано, то заменяется не более count значений в целом (замены определяются как new(x) !== x).

Примеры

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

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

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

Для каждой пары old=>new в old_new, заменяет все вхождения old в коллекции A на new. Равенство определяется с помощью isequal. Если count указано, то заменяется не более count вхождений в целом. См. также replace.

Примеры

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

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

replace!(new::Function, A; [count::Integer])

Заменяет каждый элемент x в коллекции A на new(x). Если count указано, то заменяется не более count значений в целом (замены определяются как new(x) !== x).

Примеры

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

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

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

Base.rest(collection[, itr_state])

Обобщенная функция для получения хвоста collection, начиная с определенного состояния итерации itr_state. Возвращает Tuple, если collection сам является Tuple, подтипом AbstractVector, если collection является AbstractArray, подтипом AbstractString если collection является AbstractString, и произвольным итератором, возвращая Iterators.rest(collection[, itr_state]) в противном случае. Может быть перегружен для типов пользовательских коллекций для настройки поведения слива в назначениях, например, a, b... = collection.

Примеры

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

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!(collection, value, key...)

Сохранение заданного значения по данному ключу или индексу в коллекции. Синтаксис a[i,j,...] = x преобразуется компилятором в (setindex!(a, x, i, j, ...); x).

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

Возвращает первый индекс collection. Если d задан, возвращает первый индекс collection по измерению d.

Примеры

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

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

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

Возвращает последний индекс collection. Если d задан, возвращает последний индекс collection по измерению d.

Синтаксисы A[end] и A[end, end] сводятся к A[lastindex(A)] и A[lastindex(A, 1), lastindex(A, 2)] соответственно.

Примеры

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

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

AbstractDict{K, V}

Надтип для словарей с ключами типа K и значениями типа V. Dict, IdDict и другие типы являются подтипами этого. AbstractDict{K, V} должен быть итератором Pair{K, V}.

Dict([itr])

Dict{K,V}() создаёт хеш-таблицу с ключами типа K и значениями типа V. Ключи сравниваются с помощью isequal и хешируются с помощью hash.

При задании единственного итерируемого аргумента создаёт Dict, пары ключ-значение которого берутся из 2-кортежей (key,value) , сгенерированных аргументом.

Примеры

julia> Dict([("A", 1), ("B", 2)])
Dict{String, Int64} with 2 entries:
  "B" => 2
  "A" => 1

В качестве альтернативы можно передать последовательность аргументов пар.

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

IdDict([itr])

IdDict{K,V}() создаёт хеш-таблицу, используя идентификатор объекта в качестве хеша и === в качестве условия равенства, с ключами типа K и значениями типа V.

См. Dict для дополнительной информации.

WeakKeyDict([itr])

WeakKeyDict() создаёт хеш-таблицу, где ключи являются слабыми ссылками на объекты, которые могут быть удалены сборщиком мусора, даже если на них есть ссылка в хеш-таблице.

См. Dict для дополнительной информации. Обратите внимание, в отличие от Dict, WeakKeyDict не преобразует ключи при вставке, так как это предполагало бы, что объект ключа нигде не ссылается до вставки.

ImmutableDict

ImmutableDict — словарь, реализованный как неизменяемый связанный список, что оптимально для небольших словарей, которые создаются при многочисленных отдельных вставках. Обратите внимание, что удалить значение невозможно, хотя его можно частично переопределить и скрыть, вставив новое значение с тем же ключом.

ImmutableDict(KV::Pair)

Создайте новую запись в ImmutableDict для пары key => value.

• используйте (key => value) in dict чтобы узнать, присутствует ли эта комбинация в наборе свойств;
• используйте get(dict, key, default) чтобы получить последнее значение для определённого ключа.

haskey(collection, key) -> Bool

Определить, содержит ли коллекция сопоставление для данного key.

Примеры

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

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

get(collection, key, default)

Возвращает сохранённое значение для данного ключа или заданное значение по умолчанию, если для ключа нет сопоставления.

Примеры

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

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

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

get(collection, key, default)

Возвращает сохранённое значение для данного ключа или заданное значение по умолчанию, если для ключа нет сопоставления.

Примеры

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

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

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

get(f::Function, collection, key)

Возвращает сохранённое значение для данного ключа, или если сопоставления для ключа нет, возвращает f(). Используйте get!, чтобы также сохранить значение по умолчанию в словаре.

Предполагается вызов с использованием синтаксиса блока do.

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

get!(collection, key, default)

Возвращает сохранённое значение для данного ключа, или если сопоставления для ключа нет, сохраняет key => default, и возвращает default.

Примеры

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

julia> get!(d, "a", 5)
1

julia> get!(d, "d", 4)
4

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

get!(f::Function, collection, key)

Возвращает сохранённое значение для данного ключа, или если сопоставления для ключа нет, сохраняет key => f(), и возвращает f().

Предполагается вызов с использованием синтаксиса блока do.

Примеры

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

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

julia> get_square!(squares, 2)
4

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

getkey(collection, key, default)

Возвращает ключ, соответствующий аргументу key , если он существует в collection, в противном случае возвращает default.

Примеры

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

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

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

delete!(collection, key)

Удаляет сопоставление для данного ключа в коллекции, если оно есть, и возвращает коллекцию.

Примеры

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

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

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

pop!(collection, key[, default])

Удаляет и возвращает сопоставление для key , если оно существует в collection, в противном случае возвращает default, или выбрасывает ошибку, если default не указан.

Примеры

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

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

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

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

keys(iterator)

Для итератора или коллекции, имеющей ключи и значения (например, массивы и словари), возвращает итератор по ключам.

values(iterator)

Для итератора или коллекции, имеющей ключи и значения, возвращает итератор по значениям. По умолчанию эта функция просто возвращает свой аргумент, так как элементы общего итератора обычно рассматриваются как его "значения".

Примеры

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

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

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

values(a::AbstractDict)

Возвращает итератор по всем значениям в коллекции. collect(values(a)) возвращает массив значений. Когда значения хранятся во внутренней хеш-таблице, как в случае с Dict, порядок их возврата может отличаться. Но keys(a) и values(a) оба итерируют a и возвращают элементы в том же порядке.

Примеры

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

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

pairs(collection)

Возвращает итератор по парам key => value для любой коллекции, которая сопоставляет набор ключей набору значений. Это включает массивы, где ключами являются индексы массива.

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, axes.

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

Создаёт новую именованную кортеж, объединяя два или более существующих, слева направо. Объединение происходит слева направо между парами именованных кортежей, поэтому порядок полей, присутствующих как в левом, так и в правом именованных кортежах, занимает то же место, что и в левом именованном кортеже. Однако значения берутся из соответствующих полей в правом именованном кортеже, который содержит это поле. Поля, присутствующие только в правом именованном кортеже пары, добавляются в конец. Реализован fallback для случая, когда предоставлен только один именованный кортеж, с сигнатурой merge(a::NamedTuple).

Примеры

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

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

merge(a::NamedTuple, iterable)

Интерпретирует итерируемый набор пар ключ-значение как именованный кортеж и выполняет объединение.

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

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

Создаёт объединённую коллекцию из заданных коллекций. При необходимости типы результирующей коллекции будут приведены для соответствия типам объединённых коллекций. Значения с одинаковым ключом будут объединены с помощью функции-комбинатора. Функция mergewith(combine), возвращаемая в curried форме, возвращает функцию (args...) -> mergewith(combine, args...).

Метод merge(combine::Union{Function,Type}, args...) как алиас mergewith(combine, args...) все ещё доступен для обратной совместимости.

Примеры

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

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

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

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

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

Обновляет коллекцию парами из других коллекций. См. также merge.

Примеры

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

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

julia> merge!(d1, d2);

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

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

Обновляет коллекцию парами из других коллекций. Значения с одинаковым ключом будут объединены с помощью функции-комбинатора. Функция mergewith!(combine), возвращаемая в curried форме, возвращает функцию (args...) -> mergewith!(combine, args...).

Метод merge!(combine::Union{Function,Type}, args...) как алиас mergewith!(combine, args...) все ещё доступен для обратной совместимости.

Примеры

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

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

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

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

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

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

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

sizehint!(s, n)

Предлагает коллекции s зарезервировать емкость как минимум для n элементов. Это может улучшить производительность.

Примечания по модели производительности

Для типов, которые поддерживают sizehint!,

1. push! и append! методы, как правило, могут (но не обязаны) предварительно выделить дополнительную

память. Для типов, реализованных в Base, они обычно это делают, используя эвристику, оптимизированную для общего случая.

1. sizehint! может контролировать эту предварительную аллокацию. Опять же, это обычно делается для типов в

Base.

1. empty! практически не имеет стоимости (и O(1)) для типов, которые поддерживают этот вид предварительной аллокации.

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

Возвращает тип ключа массива. Это равно типу eltype результата keys(...), и предоставляется в основном для совместимости с интерфейсом словаря.

Примеры

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

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

keytype(type)

Получает тип ключа типа словаря. Ведёт себя аналогично eltype.

Примеры

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

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

Возвращает тип значения массива. Идентично eltype, и предоставляется в основном для совместимости с интерфейсом словаря.

Примеры

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

valtype(type)

Получает тип значения типа словаря. Ведёт себя аналогично eltype.

Примеры

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

AbstractSet{T}

Супертип для типов, похожих на множества, элементы которых имеют тип T. Set, BitSet и другие типы являются подтипами этого.

Set([itr])

Создаёт Set из значений, сгенерированных заданным итерируемым объектом, или пустое множество. Следует использовать вместо BitSet для разреженных множеств целых чисел или для множеств произвольных объектов.

BitSet([itr])

Создаёт отсортированное множество Int из значений, сгенерированных заданным итерируемым объектом, или пустое множество. Реализовано как битовая строка и поэтому предназначено для плотных множеств целых чисел. Если множество будет разреженным (например, содержит несколько очень больших целых чисел), используйте Set вместо него.

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

Создаёт объединение множеств. Сохраняет порядок с массивами.

Примеры

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

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

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

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

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

Создаёт объединение переданных множеств и перезаписывает s результатом. Сохраняет порядок с массивами.

Примеры

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

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

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

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

Создаёт пересечение множеств. Сохраняет порядок с массивами.

Примеры

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

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

julia> intersect(Set([1, 2]), BitSet([2, 3]))
Set{Int64} with 1 element:
  2

setdiff(s, itrs...)

Создаёт множество элементов в s, но не в переданных итерируемых объектах в itrs. Сохраняет порядок с массивами.

Примеры

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

setdiff!(s, itrs...)

Удаляет из множества s (на месте) каждый элемент каждого итерируемого объекта из itrs. Сохраняет порядок с массивами.

Примеры

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

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

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

symdiff(s, itrs...)

Создаёт симметричную разность элементов переданных множеств. Если s не является AbstractSet, порядок сохраняется. Обратите внимание, что в этом случае важность множественности элементов.

Примеры

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])
2-element Vector{Int64}:
 1
 2

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

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

Создаёт симметричную разность переданных множеств и перезаписывает s результатом. Если s является массивом, порядок сохраняется. Обратите внимание, что в этом случае важность множественности элементов.

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

Пересекает все переданные множества и перезаписывает s результатом. Сохраняет порядок с массивами.

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

Определяет, является ли каждый элемент a также элементом b, используя in.

Примеры

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

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

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

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

Отрицание ⊆ и ⊇, т.е. проверяет, что a не является подмножеством b.

Примеры

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(a, b) -> Bool

Определяет, имеют ли a и b одинаковые элементы. Эквивалентно a ⊆ b && b ⊆ a, но более эффективно, когда это возможно.

Примеры

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

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

isdisjoint(v1, v2) -> Bool

Возвращает, являются ли коллекции v1 и v2 непересекающимися, т.е. является ли их пересечение пустым.

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

Вставляет один или несколько items в collection. Если collection является упорядоченным контейнером, элементы вставляются в конец (в указанном порядке).

Примеры

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

Если collection упорядочен, используйте append! для добавления всех элементов другой коллекции в него. Результат предыдущего примера эквивалентен append!([1, 2, 3], [4, 5, 6]). Для объектов AbstractSet вместо этого можно использовать union!.

См. sizehint! для информации о модели производительности.

pop!(collection) -> item

Удаляет элемент из collection и возвращает его. Если collection является упорядоченным контейнером, возвращается последний элемент; для неупорядоченных контейнеров возвращается произвольный элемент.

Примеры

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

julia> pop!(A)
3

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

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

julia> pop!(S)
2

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

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

pop!(collection, key[, default])

Удалить и вернуть отображение для key, если оно существует в collection, в противном случае вернуть default, или выбросить ошибку, если default не указано.

Примеры

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

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

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

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

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

Удалить элемент по заданному i и вернуть его. Последующие элементы сдвигаются, чтобы заполнить образовавшийся пробел. Если i не является допустимым индексом для a, вернуть default, или выбросить ошибку, если default не указано. См. также deleteat! и splice!.

Примеры

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

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

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

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

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

Вставить один или несколько items в начало collection.

Примеры

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

popfirst!(collection) -> item

Удалить первый item из collection.

Примеры

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

julia> popfirst!(A)
1

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

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

Вставить item в a по заданному index. index - индекс item в результирующем a.

Примеры

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

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

Удалить элемент по заданному i и вернуть изменённый a. Последующие элементы сдвигаются, чтобы заполнить образовавшийся пробел.

Примеры

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

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

Удалить элемент по заданному индексу и вернуть удалённый элемент. Последующие элементы смещаются влево, чтобы заполнить образовавшийся пробел. Если указано, значения замещения из упорядоченной коллекции будут вставлены вместо удалённого элемента.

Примеры

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

Для вставки replacement перед индексом n без удаления элементов используйте splice!(collection, n:n-1, replacement).

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

Удалить элементы по указанным индексам и вернуть коллекцию, содержащую удалённые элементы. Последующие элементы смещаются влево, чтобы заполнить образовавшиеся пробелы. Если указаны, значения замещения из упорядоченной коллекции будут вставлены вместо удалённых элементов; в этом случае indices должен быть UnitRange.

Для вставки replacement перед индексом n без удаления элементов используйте splice!(collection, n:n-1, replacement).

Примеры

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

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

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

Изменить размер a на n элементов. Если n меньше текущей длины коллекции, будут сохранены первые n элементов. Если n больше, новые элементы не гарантированно будут инициализированы.

Примеры

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

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

julia> length(a)
8

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

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

Для упорядоченной контейнера collection добавить элементы каждой collections в конец.

Примеры

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

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

Используйте push! для добавления отдельных элементов в collection, которые сами по себе не являются коллекциями. Результат предыдущего примера эквивалентен push!([1, 2, 3], 4, 5, 6).

См. sizehint! для заметок о модели производительности.

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

Вставить элементы каждой collections в начало a.

Когда collections указывает на несколько коллекций, порядок сохраняется: элементы collections[1] будут отображаться слева в a, и так далее.

Примеры

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

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

Pair(x, y)
x => y

Создать объект Pair с типом Pair{typeof(x), typeof(y)}. Элементы хранятся в полях first и second. К ним также можно получить доступ с помощью итерации (но Pair рассматривается как один «скаляр» для операций с широковещательной передачей).

См. также: Dict

Примеры

julia> p = "foo" => 7
"foo" => 7

julia> typeof(p)
Pair{String, Int64}

julia> p.first
"foo"

julia> for x in p
           println(x)
       end
foo
7

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

Преобразует индексируемый контейнер в представление «словарь» тех же данных. Изменение пространства ключей базовых данных может сделать этот объект недействительным.