Коллекции и структуры данных

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

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

Примеры

julia> a = 1:3:20
1:3:19

julia> 4 in a
true

julia> 5 in a
false

julia> missing in [1, 2]
missing

julia> 1 in [2, missing]
missing

julia> 1 in [1, missing]
true

julia> missing in Set([1, 2])
false

julia> (1=>missing) in Dict(1=>10, 2=>20)
missing

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

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

∉(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 элемент за один проход и возвращает их как 2-кортеж.

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

Возвращаемое значение для пустой itr может быть задано с помощью init. Оно должно быть 2-кортежем, у которого первый и второй элементы — нейтральные элементы для 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 (или, что эквивалентно, если входные данные не содержат «отсутствующих» значений), следуя правилам трёхзначной логики.

См. также: 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 (или, что эквивалентно, если входные данные не содержат «отсутствующих» значений), следуя правилам трёхзначной логики.

Примеры

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

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

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

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

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

any!(r, A)

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

Примеры

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

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

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

all(itr) -> Bool

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

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

См. также: 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 (или, что эквивалентно, если входные данные не содержат «отсутствующих» значений), следуя правилам трёхзначной логики.

Примеры

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 всех элементов в коллекции или итераторе. Для словарей возвращает Vector{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::Union{Function, Type}, 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::Union{Function, Type}, 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 не преобразует ключи при вставке, так как это предполагало бы, что объект ключа нигде не ссылался до вставки.

См. также WeakRef.

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::Union{Function, Type}, 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::Union{Function, Type}, collection, key)

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

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

Примеры

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

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

julia> get_square!(squares, 2)
4

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

getkey(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 будет 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.

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

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'
  'b'
  'B'
  'c'

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

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

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

Unicode ∪ можно ввести, набрав \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})

Функция для логического индексирования a = a[m] в place. То есть, 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)}

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