Collections and Data Structures

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} <: AbstractVector{T}

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

Все подтипы должны определять step. Таким образом, LogRange не является подтипом AbstractRange.

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

См. также Logrange для логарифмически распределенных точек.

isempty(collection) -> Bool

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

Примеры

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

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

isdone(itr, [state]) -> Union{Bool, Missing}

Эта функция предоставляет подсказку для быстрого определения завершения итератора. Это полезно для состоящих итераторов, которые хотят избежать потребления элементов, если они не будут представлены пользователю (например, при проверке завершенности в isempty или zip).

Состоящие итераторы, которые хотят воспользоваться этой функцией, должны определить метод isdone, который возвращает true/false в зависимости от того, завершен итератор или нет. Безсостоящие итераторы не обязаны реализовывать эту функцию.

Если результат missing, вызывающие функции могут продолжить и вычислить iterate(x, state) === nothing, чтобы получить определенный ответ.

См. также iterate, isempty

empty!(collection) -> collection

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

Примеры

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} с 2 записями:
  "b" => 2
  "a" => 1

julia> empty!(A);

julia> A
Dict{String, Int64}()

empty!(c::Channel)

Очистите канал c, вызвав empty! на внутреннем буфере. Верните пустой канал.

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

Base.hasfastin(T)

Определите, может ли вычисление x ∈ collection, где collection::T, считаться "быстрой" операцией (обычно с постоянной или логарифмической сложностью). Определение hasfastin(x) = hasfastin(typeof(x)) предоставлено для удобства, чтобы экземпляры могли быть переданы вместо типов. Однако форма, принимающая аргумент типа, должна быть определена для новых типов.

По умолчанию для hasfastin(T) значение true для подтипов AbstractSet, AbstractDict и AbstractRange, и false в противном случае.

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

Смотрите также: 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 и hash, затем возвращает измененный 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! может обрабатывать отсортированные данные гораздо более эффективно.

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

allunique(itr) -> Bool
allunique(f, itr) -> Bool

Возвращает true, если все значения из itr различны при сравнении с isequal. Или если все из [f(x) for x in itr] различны для второго метода.

Обратите внимание, что allunique(f, itr) может вызывать f меньшее количество раз, чем length(itr). Точное количество вызовов считается деталью реализации.

allunique может использовать специализированную реализацию, когда входные данные отсортированы.

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

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

allequal(itr) -> Bool
allequal(f, itr) -> Bool

Возвращает true, если все значения из itr равны при сравнении с isequal. Или если все из [f(x) for x in itr] равны, для второго метода.

Обратите внимание, что allequal(f, itr) может вызывать f меньшее количество раз, чем length(itr). Точное количество вызовов считается деталью реализации.

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

julia> allequal(abs2, [1, -1])
true

reduce(op, itr; [init])

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

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

Сокращения для определенных часто используемых операторов могут иметь специальные реализации и должны использоваться вместо этого: maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr). Существуют эффективные методы для конкатенации определенных массивов массивов, вызывая reduce(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)  # хорошо, так как выход sin >= -1
-1.0

maximum(itr; [init])

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

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

Примеры

julia> maximum(-20.5:10)
9.5

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

julia> maximum(())
ERROR: ArgumentError: reducing over an empty collection is not allowed; 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)  # хорошо, так как выход sin <= 1
1.0

minimum(itr; [init])

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

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

Примеры

julia> minimum(-20.5:10)
-20.5

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

julia> minimum([])
ERROR: ArgumentError: reducing over an empty collection is not allowed; 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))  # хорошо, так как -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)

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

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

Индексы имеют тот же тип, что и те, которые возвращаются функциями keys(itr) и pairs(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) -> индексы

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

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

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

Индексы имеют тот же тип, что и те, которые возвращаются функциями keys(itr) и pairs(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) -> индексы

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

Индексы имеют тот же тип, что и те, что возвращаются функциями keys(itr) и pairs(itr).

См. также: 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 должен быть непустимым итерируемым объектом.

Индексы имеют тот же тип, что и те, которые возвращаются функциями keys(domain) и pairs(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.

Индексы имеют тот же тип, что и те, которые возвращаются функциями keys(itr) и pairs(itr).

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

Вызовите функцию 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, " с ", y), tri, 'a':'z')
1 с a
4 с b
7 с c

map(f, c...) -> коллекция

Преобразуйте коллекцию 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-массив

При работе с многомерными массивами одинаковой 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))  # итерация продолжается, пока 3-й не исчерпан
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: Невозможно вызвать front для пустого кортежа.

tail(x::Tuple)::Tuple

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

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

Примеры

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

julia> Base.tail(())
ERROR: ArgumentError: Невозможно вызвать tail для пустого кортежа.

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 пар key=>value Pairs. Если аргумент похож на массив или является итератором с трейтами HasShape, результат будет иметь ту же форму и количество измерений, что и аргумент.

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

Примеры

Собрать элементы из коллекции UnitRange{Int64}:

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

Собрать элементы из генератора (такой же вывод, как и [x^2 for x in 1:3]):

julia> collect(x^2 for x in 1:3)
3-element Vector{Int64}:
 1
 4
 9

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

!!! предупреждение Ключи могут быть изменяемыми, но если вы измените сохраненные ключи, хеш-таблица может стать внутренне несогласованной, в этом случае Dict не будет работать должным образом. IdDict может быть альтернативой, если вам нужно изменять ключи.

IdDict([itr])

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

В приведенном ниже примере ключи 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 для пары ключ => значение

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

PersistentDict

PersistentDict — это словарь, реализованный как хеш-массив, отображаемый в три, который оптимален для ситуаций, когда вам нужна постоянство; каждая операция возвращает новый словарь, отдельный от предыдущего, но основная реализация эффективна по использованию пространства и может делить хранилище между несколькими отдельными словарями.

PersistentDict(KV::Pair)

Примеры

julia> dict = Base.PersistentDict(:a=>1)
Base.PersistentDict{Symbol, Int64} с 1 записью:
  :a => 1

julia> dict2 = Base.delete(dict, :a)
Base.PersistentDict{Symbol, Int64}()

julia> dict3 = Base.PersistentDict(dict, :a=>2)
Base.PersistentDict{Symbol, Int64} с 1 записью:
  :a => 2

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
    # значение по умолчанию вычисляется здесь
    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 (категория Ll: буква, строчная)

julia> getkey(D, 'd', 'a')
'a': ASCII/Unicode U+0061 (категория Ll: буква, строчная)

delete!(collection, key)

Удалите отображение для данного ключа в коллекции, если таковое имеется, и верните коллекцию.

Примеры

julia> d = Dict("a"=>1, "b"=>2)
Dict{String, Int64} с 2 записями:
  "b" => 2
  "a" => 1

julia> delete!(d, "b")
Dict{String, Int64} с 1 записью:
  "a" => 1

julia> delete!(d, "b") # d остается без изменений
Dict{String, Int64} с 1 записью:
  "a" => 1

pop!(коллекция, ключ[, по умолчанию])

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

Примеры

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) и pairs(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 для любой коллекции, которая сопоставляет набор ключей с набором значений. Это включает массивы, где ключами являются индексы массива. Когда записи хранятся внутренне в хэш-таблице, как в случае с Dict, порядок, в котором они возвращаются, может варьироваться. Но keys(a), values(a) и pairs(a) все итерируют a и возвращают элементы в одном и том же порядке.

Примеры

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(initial::Face, others::Face...)

Объединяет свойства начального лица initial и других, при этом более поздние лица имеют приоритет.

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; first::Bool=false, shrink::Bool=true) -> s

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

Если first равно true, то любое дополнительное пространство резервируется перед началом коллекции. Таким образом, последующие вызовы pushfirst! (вместо push!) могут стать быстрее. Указание этого ключевого слова может привести к ошибке, если коллекция не упорядочена или если pushfirst! не поддерживается для этой коллекции.

Если shrink=true (по умолчанию), емкость коллекции может быть уменьшена, если ее текущая емкость больше n.

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

IdSet{T}([itr])
IdSet()

IdSet{T}() создает множество (см. Set), используя === в качестве равенства с значениями типа T.

В приведенном ниже примере все значения равны по isequal, поэтому они перезаписываются в обычном Set. IdSet сравнивает по === и таким образом сохраняет 3 различных значения.

Примеры

julia> Set(Any[true, 1, 1.0])
Set{Any} с 1 элементом:
  1.0

julia> IdSet{Any}(Any[true, 1, 1.0])
IdSet{Any} с 3 элементами:
  1.0
  1
  true

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

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

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

Юникод ∩ можно ввести, написав \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

in!(x, s::AbstractSet) -> Bool

Если x находится в s, верните true. Если нет, добавьте x в s и верните false. Это эквивалентно in(x, s) ? true : (push!(s, x); false), но может иметь более эффективную реализацию.

Смотрите также: in, push!, Set

Примеры

julia> s = Set{Any}([1, 2, 3]); in!(4, s)
false

julia> length(s)
4

julia> in!(0x04, s)
true

julia> s
Set{Any} with 4 elements:
  4
  2
  3
  1

⊈(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

issetequal(x)

Создайте функцию, которая сравнивает свой аргумент с x, используя issetequal, т.е. функцию, эквивалентную y -> issetequal(y, x). Возвращаемая функция имеет тип Base.Fix2{typeof(issetequal)}, который можно использовать для реализации специализированных методов.

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

isdisjoint(x)

Создайте функцию, которая сравнивает свой аргумент с x, используя isdisjoint, т.е. функцию, эквивалентную y -> isdisjoint(y, x). Возвращаемая функция имеет тип Base.Fix2{typeof(isdisjoint)}, который можно использовать для реализации специализированных методов.

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!(коллекция) -> элемент

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

См. также: 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!(коллекция, ключ[, по умолчанию])

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

Примеры

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!(коллекция, элементы...) -> коллекция

Вставляет один или несколько элементов в начало коллекции.

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

Примеры

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

popfirst!(коллекция) -> элемент

Удаляет первый элемент из коллекция.

Эта функция называется 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: индексы должны быть уникальными и отсортированными
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]. То есть 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

Пара(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"

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

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