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

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 и шагом step типа 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, оба Integer, создаёт UnitRange.

Примеры

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

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

LinRange{T,L}

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

Примеры

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

По сравнению с использованием range, прямое создание LinRange должно иметь меньшую нагрузку, но не будет пытаться исправить ошибки с плавающей точкой:

julia> collect(range(-0.1, 0.3, length=5))
5-element 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 для получения последнего допустимого индекса индексируемой коллекции.

См. также: size, ndims, eachindex.

Примеры

julia> length(1:5)
5

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

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

Base.checked_length(r)

Вычисляет length(r), но может проверять ошибки переполнения, где применимо, когда результат не помещается в Union{Integer(eltype(r)),Int}.

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

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

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

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

При векторизации с in.(items, collection) или items .∈ collection, как item, так и collection векторизуются, что часто не соответствует намерениям. Например, если оба аргумента являются векторами (и размерности совпадают), результат — вектор, указывающий, содержится ли каждый элемент в коллекции items в соответствующей позиции in в 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

См. также: insorted, contains, occursin, issubset.

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

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

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

Примеры

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

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

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

eltype(type)

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

См. также: keytype, typeof.

Примеры

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

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

indexin(a, b)

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

См. также: sortperm, findfirst.

Примеры

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

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

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

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

unique(itr)

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

См. также: unique!, allunique.

Примеры

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.

См. также: unique, issorted.

Примеры

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

julia> allunique(a)
true

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

См. также: maximum!, extrema, findmax, argmax.

Примеры

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

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

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

maximum(f, A::AbstractArray; dims)

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

Примеры

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

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

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

maximum!(r, A)

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

Примеры

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

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

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

minimum(f, itr; [init])

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

Значение, возвращаемое для пустого 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).

См. также: minimum!, extrema, findmin, argmin.

Примеры

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

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

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

minimum(f, A::AbstractArray; dims)

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

Примеры

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

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

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

minimum!(r, A)

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

Примеры

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

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

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

extrema(itr) -> 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(f, domain)

Возвращает значение x в области f, для которого f(x) максимален. Если для f(x) существует несколько максимальных значений, то будет найдено первое.

domain должно быть непустым итерируемым объектом.

Значения сравниваются с isless.

Примеры

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

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

argmax(itr)

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

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

Значения сравниваются с isless.

См. также: argmin, findmax.

Примеры

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

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

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

argmax(A; dims) -> indices

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

Примеры

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

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

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

argmin(r::AbstractRange)

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

argmin(f, domain)

Возвращает значение x в области f, для которого f(x) минимален. Если для f(x) существует несколько минимальных значений, то будет найдено первое.

domain должно быть непустым итерируемым объектом.

NaN рассматривается как меньше всех других значений, кроме missing.

Примеры

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

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

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

argmin(itr)

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

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

NaN рассматривается как меньше всех других значений, кроме missing.

См. также: argmax, findmin.

Примеры

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

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

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

argmin(A; dims) -> indices

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

Примеры

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

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

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

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

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

domain должно быть непустым итерируемым объектом.

Значения сравниваются с помощью isless.

Примеры

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

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

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

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

findmax(itr) -> (x, index)

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

См. также: findmin, argmax, maximum.

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

domain должно быть непустым итерируемым объектом.

NaN рассматривается как меньшее, чем все остальные значения, за исключением missing.

Примеры

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

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

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

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

findmin(itr) -> (x, index)

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

См. также: findmax, argmin, minimum.

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

sum(f, itr; [init])

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

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

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

Примеры

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

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

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

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

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

sum(itr; [init])

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

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

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

См. также: reduce, mapreduce, count, union.

Примеры

julia> sum(1:20)
210

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

sum(A::AbstractArray; dims)

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

Примеры

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

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

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

sum(f, A::AbstractArray; dims)

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

Примеры

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

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

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

sum!(r, A)

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

Примеры

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

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

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

prod(f, itr; [init])

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

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

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

Примеры

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

prod(itr; [init])

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

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

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

См. также: reduce, cumprod, any.

Примеры

julia> prod(1:5)
120

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

prod(A::AbstractArray; dims)

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

Примеры

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

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

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

prod(f, A::AbstractArray; dims)

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

Примеры

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

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

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

prod!(r, A)

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

Примеры

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

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

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

any(itr) -> Bool

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

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

См. также: all, count, sum, |, , ||.

Примеры

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

julia> any(a)
true

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

julia> any([missing, true])
true

julia> any([false, missing])
missing

any(p, itr) -> Bool

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

Если входные данные содержат значения 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 и записать результаты в 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 (короткое замыкание). Чтобы использовать короткое замыкание на true, используйте any.

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

См. также: all!, any, count, &, , &&, allunique.

Примеры

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

julia> all(a)
false

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

julia> all([missing, false])
false

julia> all([true, missing])
missing

all(p, itr) -> Bool

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

Если вход содержит значения 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 необязательно задаёт значение, с которого начинать отсчёт, и тем самым также определяет тип результата.

См. также: any, sum.

Примеры

julia> count(i->(4<=i<=6), [2,3,4,5,6])
3

julia> count([true, false, true, true])
3

julia> count(>(3), 1:7, init=0x03)
0x07

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

Возвратить количество совпадений для 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

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

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

foreach следует использовать вместо map, когда результаты f не нужны, например, в foreach(println, array).

Примеры

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

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

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

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

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

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

См. также map!, foreach, mapreduce, mapslices, zip, Iterators.map.

Примеры

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

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

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

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

См. также: map, foreach, zip, copyto!.

Примеры

julia> a = zeros(3);

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

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

first(coll)

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

См. также: only, firstindex, last.

Примеры

julia> first(2:2:10)
2

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

first(itr, n::Integer)

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

См. также: startswith, Iterators.take.

Примеры

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

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

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

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

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

Примеры

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

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

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

last(coll)

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

См. также first, endswith.

Примеры

julia> last(1:2:10)
9

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

last(itr, n::Integer)

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

Примеры

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

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

julia> last(Float64[], 1)
Float64[]

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

Получить строку, состоящую из последних 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.

См. также: first, tail.

Примеры

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

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

tail(x::Tuple)::Tuple

Возвращает Tuple, состоящую из всех компонентов, кроме первого, из x.

См. также: front, rest, first, Iterators.peel.

Примеры

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

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

step(r)

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

Примеры

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

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

collect(collection)

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

Используется выражениями со списками для преобразования генератора в Array.

Примеры

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

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

collect(element_type, collection)

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

Примеры

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

filter(f, a)

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

См. также: filter!, Iterators.filter.

Примеры

julia> a = 1:10
1:10

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

filter(f, 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!, splice!, delete!, insert!.

Примеры

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

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

replace(new::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.

См. также: first, Iterators.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])

getindex(collection, key...)

Получение значения(й), хранящихся по заданному ключу или индексу в коллекции. Синтаксис a[i,j,...] преобразуется компилятором в getindex(a, i, j, ...).

См. также get, keys, eachindex.

Примеры

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

julia> getindex(A, "a")
1

setindex!(collection, value, key...)

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

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

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

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

См. также: first, axes, lastindex, nextind.

Примеры

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

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

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

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

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

См. также: axes, firstindex, eachindex, prevind.

Примеры

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

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

AbstractDict{K, V}

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

Dict([itr])

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

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

Примеры

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

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

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

IdDict([itr])

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

Для дополнительной помощи см. Dict. В примере ниже, все ключи Dict являются isequal и поэтому хешируются одинаково, поэтому они перезаписываются. IdDict хеширует по идентификатору объекта, и, таким образом, сохраняет 3 различных ключа.

Примеры

julia> Dict(true => "yes", 1 => "no", 1.0 => "maybe")
Dict{Real, String} with 1 entry:
  1.0 => "maybe"

julia> IdDict(true => "yes", 1 => "no", 1.0 => "maybe")
IdDict{Any, String} with 3 entries:
  true => "yes"
  1.0  => "maybe"
  1    => "no"

WeakKeyDict([itr])

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

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

ImmutableDict

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

ImmutableDict(KV::Pair)

Добавление новой записи в ImmutableDict для пары key => value

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

haskey(collection, key) -> Bool

Определяет, имеет ли коллекция отображение для данного key.

Примеры

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

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

get(collection, key, default)

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

Примеры

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

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

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

get(f::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(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.

pairs(collection)

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

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

merge(a::NamedTuple, iterable)

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

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

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

julia> merge!(d1, d2);

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

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

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

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

Примеры

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

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

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

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

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

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

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

sizehint!(s, n)

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

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

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

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

2. sizehint! может контролировать это предварительное выделение. Опять же, он обычно делает это для типов в Base.

3. 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 для разреженных множеств целых чисел или множеств произвольных объектов.

См. также: push!, empty!, union!, in.

BitSet([itr])

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

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

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

См. также: intersect, isdisjoint, vcat, Iterators.flatten.

Примеры

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

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

См. также: setdiff, isdisjoint, issubset, issetequal.

Примеры

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. Сохранять порядок с массивами.

См. также setdiff!, union и intersect.

Примеры

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

setdiff!(s, itrs...)

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

Примеры

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

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

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

symdiff(s, itrs...)

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

См. также symdiff!, setdiff, union и intersect.

Примеры

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

julia> symdiff([1,2,1], [2, 1, 2])
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.

См. также ⊊, ⊈, ∩, ∪, contains.

Примеры

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

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

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

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

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

См. также issubset (⊆), ⊊.

Примеры

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

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

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

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

См. также issubset (⊆), ⊈.

Примеры

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

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

issetequal(a, b) -> Bool

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

См. также: isdisjoint, union.

Примеры

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

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

isdisjoint(v1, v2) -> Bool

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

См. также: issetequal, intersect.

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! для замечаний о модели производительности.

См. также pushfirst!.

pop!(collection) -> item

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

См. также: popfirst!, popat!, delete!, deleteat!, splice! и push!.

Примеры

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

julia> pop!(A)
3

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

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

julia> pop!(S)
2

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

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

pop!(collection, key[, default])

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

Примеры

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

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

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

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

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

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

См. также: pop!, popfirst!, deleteat!, splice!.

Примеры

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

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

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

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

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

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

Эта функция называется unshift во многих других языках программирования.

Примеры

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

popfirst!(collection) -> item

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

Эта функция называется shift во многих других языках программирования.

См. также: pop!, popat!, delete!.

Примеры

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

julia> popfirst!(A)
1

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

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

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

См. также: push!, replace, popat!, splice!.

Примеры

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

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

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

См. также: delete!, popat!, splice!.

Примеры

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

deleteat!(a::Vector, inds)

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

inds может быть итератором или коллекцией отсортированных и уникальных целых индексов, или булевым вектором той же длины, что и a, где true указывает на удаляемые элементы.

Примеры

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

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

julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
ERROR: ArgumentError: indices must be unique and sorted
Stacktrace:
[...]

keepat!(a::Vector, inds)

Удалить элементы по всем индексам, которые не указаны в inds, и вернуть измененный a Элементы, которые сохраняются, смещаются, чтобы заполнить образовавшиеся пробелы.

inds должен быть итератором отсортированных и уникальных целых индексов. См. также deleteat!.

Примеры

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

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

Функция для удаления элементов с использованием логических индексов 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

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

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

См. также: replace, delete!, deleteat!, pop!, popat!.

Примеры

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

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

julia> splice!(A, 5, -1)
1

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

julia> splice!(A, 1, [-1, -2, -3])
6

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

Для вставки 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! для заметок по модели производительности.

См. также vcat для векторов, union! для множеств и prepend! и pushfirst! для обратного порядка.

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

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

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

Примеры

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

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

Pair(x, y)
x => y

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

См. также Dict.

Примеры

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

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

julia> p.first
"foo"

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

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

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