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

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

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

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 Vector{Float64}:
 -0.1
  0.0
  0.1
  0.2
  0.3

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

isempty(collection) -> Bool

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

Примеры

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

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

empty!(collection) -> collection

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

Примеры

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

julia> empty!(A);

julia> A
Dict{String, Int64}()

length(collection) -> Integer

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

Используйте lastindex для получения последнего допустимого индекса индексируемой коллекции.

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

Примеры

julia> length(1:5)
5

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

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

Base.checked_length(r)

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

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

Определить, содержится ли элемент в данной коллекции в том смысле, что он == одному из значений, сгенерированных при итерации по коллекции. Возвращает значение 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

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

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

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

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

Примеры

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

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

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

eltype(type)

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

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

Примеры

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

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

indexin(a, b)

Возвращает массив, содержащий первый индекс в b для каждого значения в 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, allequal.

Примеры

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

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

unique(f, itr)

Возвращает массив, содержащий одно значение из itr для каждого уникального значения, полученного при применении 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, allequal.

Примеры

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

julia> allunique(a)
true

julia> allunique([a, a])
false

allequal(itr) -> Bool

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

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

Примеры

julia> allequal([])
true

julia> allequal([1])
true

julia> allequal([1, 1])
true

julia> allequal([1, 2])
false

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

reduce(op, itr; [init])

Уменьшите заданный набор 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 для работы с пустыми наборами.

См. также mapfoldl, foldr, accumulate.

Примеры

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

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

julia> accumulate(=>, (1,2,3,4))
(1, 1 => 2, (1 => 2) => 3, ((1 => 2) => 3) => 4)

foldr(op, itr; [init])

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

Примеры

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

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

maximum(f, itr; [init])

Возвращает наибольший результат вызова функции 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: MethodError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

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

maximum(A::AbstractArray; dims)

Вычисляет максимальное значение массива по заданным измерениям. Также см. функцию max(a,b) для нахождения максимального значения из двух или более аргументов, которая может применяться поэлементно к массивам с помощью max.(a,b).

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

Примеры

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

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

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

maximum(f, A::AbstractArray; dims)

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

Примеры

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

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

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

maximum!(r, A)

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

Примеры

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

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

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

minimum(f, itr; [init])

Возвращает наименьший результат вызова функции 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: MethodError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

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

minimum(A::AbstractArray; dims)

Вычисляет минимальное значение массива по заданным измерениям. Также см. функцию min(a,b) для нахождения минимального значения из двух или более аргументов, которая может применяться поэлементно к массивам с помощью min.(a,b).

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

Примеры

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

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

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

minimum(f, A::AbstractArray; dims)

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

Примеры

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

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

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

minimum!(r, A)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

Возвращаемое значение для пустого itr может быть задано init. Оно должно быть парой, чьи первые и вторые элементы — нейтральные элементы для min и max соответственно (т.е., которые больше или меньше или равны любому другому элементу). Оно используется для непустых коллекций. Примечание: это подразумевает, что для пустого itr, возвращаемое значение (mn, mx) удовлетворяет mn ≥ mx, даже если для непустого itr оно удовлетворяет mn ≤ mx. Это «парадоксальный», но всё же ожидаемый результат.

Примеры

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

julia> extrema(sin, Real[]; init = (1.0, -1.0))  # good, since -1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)

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

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

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

Примеры

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

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

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

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

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

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

extrema!(r, A)

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

Примеры

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

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

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

argmax(r::AbstractRange)

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

argmax(f, domain)

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

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

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

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

Примеры

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

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

argmax(itr)

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

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

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

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

Примеры

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

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

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

argmax(A; dims) -> indices

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

Примеры

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

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

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

argmin(r::AbstractRange)

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

argmin(f, domain)

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

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

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

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

Примеры

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

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

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

argmin(itr)

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

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

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

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

Примеры

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

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

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

argmin(A; dims) -> indices

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

Примеры

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

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

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

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

Возвращает пару из значения в кодомене (выходов f) и индекса соответствующего значения в 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(f, A::AbstractArray...) -> N-array

При работе с многомерными массивами одинаковой ndims размерности, все они должны иметь одинаковый axes, и результат тоже.

См. также broadcast, которое позволяет использовать массивы с несовпадающими размерами.

Примеры

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

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

julia> map(+, [1 2; 3 4], [1,10,100,1000], zeros(3,1))  # iterates until 3rd is exhausted
3-element Vector{Float64}:
   2.0
  13.0
 102.0

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

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

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

Примеры

julia> a = zeros(3);

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

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

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

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

Изменяет dict, преобразовывая каждое значение из val в f(val). Обратите внимание, что тип dict изменить нельзя: если 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 и другие типы являются подтипами этого. 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)

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

Примеры

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

Создаёт новую именованную кортеж, объединяя два или более существующих, в левоассоциативном порядке. Объединение происходит слева направо между парами именованных кортежей, поэтому порядок полей, присутствующих как в левом, так и в правом именованных кортежах, сохраняет то же положение, что и в левом именованном кортеже. Однако значения берутся из соответствующих полей в правом именованном кортеже, содержащем это поле. Поля, присутствующие только в правом именованном кортеже пары, добавляются в конец. Реализован 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) возвращает функцию (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...)

Создаёт объект, содержащий все уникальные элементы из всех аргументов.

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

Символы Юникода ∪ можно набрать, написав \cup и нажав Tab в REPL Julia, а также во многих редакторах. Это инфиксный оператор, позволяющий s ∪ itr.

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

Примеры

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

julia> union([4 2 3 4 4], 1:3, 3.0)
4-element Vector{Float64}:
 4.0
 2.0
 3.0
 1.0

julia> (0, 0.0) ∪ (-0.0, NaN)
3-element Vector{Real}:
   0
  -0.0
 NaN

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

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

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

Примеры

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

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

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

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

Создаёт множество, содержащее элементы, присутствующие во всех аргументах.

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

Символы Юникода ∩ можно набрать, написав \cap и нажав Tab в REPL Julia, а также во многих редакторах. Это инфиксный оператор, позволяющий s ∩ itr.

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

Примеры

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

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

julia> intersect(1:16, 7:99)
7:16

julia> (0, 0.0) ∩ (-0.0, 0)
1-element Vector{Real}:
 0

julia> intersect(Set([1, 2]), BitSet([2, 3]), 1.0:10.0)
Set{Float64} with 1 element:
  2.0

setdiff(s, itrs...)

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

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

Примеры

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

setdiff!(s, itrs...)

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

Примеры

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

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

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

symdiff(s, itrs...)

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

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

Примеры

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

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

Определяет, являются ли коллекции a и b непересекающимися. Эквивалентно isempty(a ∩ b), но более эффективно, когда это возможно.

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

Примеры

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

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

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

Вставить один или несколько 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!(Any[1:6;], 3, "here")
7-element Vector{Any}:
 1
 2
  "here"
 3
 4
 5
 6

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)
keepat!(a::BitVector, inds)

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

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

Примеры

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

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

Функция для индексации по логическим значениям, действующая in-place. То есть, применение a = 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 должна быть AbstractUnitRange.

Чтобы вставить 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)}

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