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

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 != 0 и a, b, и c целыми числами создаёт StepRange.

Примеры

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

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

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

UnitRange{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 пары, и key сравниваются с помощью isequal.

Для проверки наличия ключа в словаре используйте haskey или k in keys(dict). Для упомянутых выше коллекций результат всегда Bool.

При трансляции с 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> (1=>missing) in Dict(1=>10, 2=>20)
missing

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

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

См. также: 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

Эта функциональность также может быть использована для извлечения индексов первых появлений уникальных элементов в массиве:

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

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

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

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

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

Возвращает уникальные области 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> allunique([1, 2, 3])
true

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

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

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

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

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

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

Для некоторых часто используемых операторов могут быть специальные реализации, которые следует использовать вместо них: maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr). Существуют эффективные методы для конкатенации определённых массивов массивов, вызывая reduce(vcat, arr) или reduce(hcat, arr).

Ассоциативность редукции зависит от реализации. Это означает, что вы не можете использовать неассоциативные операции, такие как -, потому что не определено, должна ли reduce(-,[1,2,3]) вычисляться как (1-2)-3 или 1-(2-3). Используйте foldl или foldr для гарантированной левой или правой ассоциативности.

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

Примеры

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

julia> reduce(*, [2; 3; 4]; init=-1)
-24

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

Применяет 2-аргументную функцию f по измерениям A. dims - вектор, определяющий измерения для сокращения, и ключевой аргумент init - начальное значение для использования в редукциях. Для +, *, max и min аргумент init является необязательным.

Ассоциативность редукции зависит от реализации; если вам нужна определённая ассоциативность, например, слева направо, вы должны написать свою собственную петлю или рассмотреть использование foldl или foldr. См. документацию для reduce.

Примеры

julia> a = reshape(Vector(1:16), (4,4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> reduce(max, a, dims=2)
4×1 Matrix{Int64}:
 13
 14
 15
 16

julia> reduce(max, a, dims=1)
1×4 Matrix{Int64}:
 4  8  12  16

foldl(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 из domain, для которого 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 из domain, для которого 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);;])

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

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

Примеры

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

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

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

findmin(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);;])

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

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

Примеры

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

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

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

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

Примеры

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

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

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

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

Подсчитывает количество элементов в 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)

Создает функцию, которая фильтрует свои аргументы с помощью функции f используя filter, т.е. эквивалентная функция x -> filter(f, x).

Возвращаемая функция имеет тип Base.Fix1{typeof(filter)}, который можно использовать для реализации специализированных методов.

Примеры

julia> (1, 2, Inf, 4, NaN, 6) |> filter(isfinite)
(1, 2, 4, 6)

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

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, Base.split_rest.

Примеры

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

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

julia> first, Base.rest(a, state)
(1, [3, 2, 4])

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

Общая функция для разделения хвоста collection, начиная с определённого состояния итерации itr_state. Возвращает кортеж из двух новых коллекций. Первый содержит все элементы хвоста, кроме n последних, которые составляют вторую коллекцию.

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

Может быть перегружена для пользовательских типов коллекций, чтобы настроить поведение «всасывания» в присваиваниях в неконечной позиции, как a, b..., c = collection.

См. также: Base.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.split_rest(a, 1, 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).

Примеры

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

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

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

Возвращает первый индекс 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(collection)

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

Примеры

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

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 будет Base.CartesianIndex; указание IndexStyle(A) выбирает тот, который определён как родной стиль индексирования для массива A.

Изменение границ базового массива сделает этот итератор недействительным.

Примеры

julia> A = ["a" "d"; "b" "e"; "c" "f"];

julia> for (index, value) in pairs(IndexStyle(A), A)
           println("$index $value")
       end
1 a
2 b
3 c
4 d
5 e
6 f

julia> S = view(A, 1:2, :);

julia> for (index, value) in pairs(IndexStyle(S), S)
           println("$index $value")
       end
CartesianIndex(1, 1) a
CartesianIndex(2, 1) b
CartesianIndex(1, 2) d
CartesianIndex(2, 2) e

См. также IndexStyle, axes.

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

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

Примеры

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

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

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

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

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

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

Предложить, чтобы коллекция s зарезервировала ёмкость как минимум для n элементов. То есть, если вы ожидаете, что вам придётся добавить много значений в s, можно избежать затрат на пошаговое перераспределение, выполнив его один раз заранее; это может улучшить производительность.

См. также resize!.

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

Для типов, которые поддерживают 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{T} <: AbstractSet{T}

Set — это изменяемые контейнеры, обеспечивающие быстрый поиск принадлежности элементов.

Set имеют эффективные реализации операций над множествами, такие как in, union и intersect. Элементы в Set уникальны, как определено в определении элементов isequal. Порядок элементов в Set является реализационной деталью и не может использоваться для предсказания.

См. также: AbstractSet, BitSet, Dict, push!, empty!, union!, in, isequal

Примеры

julia> s = Set("aaBca")
Set{Char} with 3 elements:
  'a'
  'c'
  'B'

julia> push!(s, 'b')
Set{Char} with 4 elements:
  'a'
  'c'
  'b'
  'B'

julia> s = Set([NaN, 0.0, 1.0, 2.0]);

julia> -0.0 in s # isequal(0.0, -0.0) is false
false

julia> NaN in s # isequal(NaN, NaN) is true
true

BitSet([itr])

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

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

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

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

Символы Юникода ∪ можно набрать, написав \cup и нажав Tab в Julia REPL и во многих редакторах. Это инфиксный оператор, позволяющий 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...)

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

Примеры

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

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

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

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

Создайте множество, содержащее те элементы, которые встречаются во всех аргументах.

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

Unicode ∩ можно набрать, написав \cap, а затем нажав клавишу Tab в Julia REPL и во многих редакторах. Это инфиксный оператор, позволяющий 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])
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. Последующие элементы смещаются, чтобы заполнить образовавшийся пробел.

См. также: keepat!, 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]. То есть, 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 должен быть 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

julia> replace.(["xops", "oxps"], "x" => "o")
2-element Vector{String}:
 "oops"
 "oops"

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

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