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

Итерация

Последовательная итерация реализуется с помощью функции iterate. Общий цикл for:

for i in iter   # или "for i = iter"
    # тело
end

преобразовывается в

next = iterate(iter)
while next !== nothing
    (i, state) = next
    # тело
    next = iterate(iter, state)
end

Объект state может быть любым. Он должен быть выбран соответствующим образом для каждого итерируемого типа. Дополнительные сведения об определении пользовательского итерируемого типа см. в разделе руководства, посвященном интерфейсу итерации.

# Base.iterate — Function

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

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

# Base.IteratorSize — Type

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

# Base.IteratorEltype — Type

IteratorEltype(itertype::Type) -> IteratorEltype

В зависимости от типа итератора возвращается одно из следующих значений:

EltypeUnknown(), если тип элементов, выдаваемых итератором, заранее неизвестен;
HasEltype(), если тип элемента известен и eltype возвращает значимое значение.

HasEltype() используется по умолчанию, поскольку итераторы, предположительно, реализуют eltype.

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

julia> Base.IteratorEltype(1:5)
Base.HasEltype()

Полностью реализуется следующими типами:

AbstractRange
UnitRange
Tuple
Number
AbstractArray
BitSet
IdDict
Dict
WeakKeyDict
EachLine
AbstractString
Set
Pair
NamedTuple

Конструкторы и типы

# Base.AbstractRange — Type

AbstractRange{T}

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

# Base.OrdinalRange — Type

OrdinalRange{T, S} <: AbstractRange{T}

Супертип для диапазонов, содержащих элементы типа T с пространствами типа S. Шаги всегда должны быть кратными oneunit, а T должен быть «дискретным» типом, который не может содержать значения меньше oneunit. Например, типы Integer или Date соответствуют этим требованиям, а Float64 не соответствует (поскольку этот тип может представлять значения меньше oneunit(Float64)). UnitRange, StepRange и другие типы являются подтипами этого типа.

# Base.AbstractUnitRange — Type

AbstractUnitRange{T} <: OrdinalRange{T, T}

Супертип для диапазонов с размером шага oneunit(T), содержащий элементы типа T. UnitRange и другие типы являются подтипами этого типа.

# Base.StepRange — Type

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}

# Base.UnitRange — Type

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}

# Base.LinRange — Type

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

Общие коллекции

# Base.isempty — Function

isempty(collection) -> Bool

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

isempty(itr) может использовать следующий элемент итератора с сохранением состояния itr, если не определен соответствующий метод Base.isdone(itr) или isempty. Поэтому следует избегать использования isempty при написании универсального кода, который должен поддерживать итератор любого типа.

Примеры

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

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

# Base.empty! — Function

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}()

# Base.length — Function

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 — Function

Base.checked_length(r)

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

Полностью реализуется следующими типами:

AbstractRange
UnitRange
Tuple
Number
AbstractArray
BitSet
IdDict
Dict
WeakKeyDict
AbstractString
Set
NamedTuple

Итерируемые коллекции

# Base.in — Function

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 in значение в соответствующей позиции в collection. Чтобы получить вектор, указывающий, входит ли каждое из значений в items в collection, заключите collection в кортеж или Ref следующим образом: in.(items, Ref(collection)) или items .∈ Ref(collection).

См. также описание ∉.

Примеры

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

julia> 4 in a
true

julia> 5 in a
false

julia> missing in [1, 2]
missing

julia> 1 in [2, missing]
missing

julia> 1 in [1, missing]
true

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

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

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

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

См. также описание insorted, contains, occursin, issubset.

# Base.:∉ — Function

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

# Base.eltype — Function

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

# Base.indexin — Function

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

# Base.unique — Function

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

# Base.unique! — Function

unique!(f, A::AbstractVector)

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

Совместимость: Julia 1.1

Этот метод впервые реализован в Julia 1.1.

Примеры

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

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

# Base.allunique — Function

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

# Base.allequal — Function

allequal(itr) -> Bool

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

См. также описание unique, allunique.

Совместимость: Julia 1.8

Для функции allequal требуется версия Julia не ниже 1.8.

Примеры

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

# Base.reduce — Method

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

# Base.reduce — Method

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

# Base.foldl — Method

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)

# Base.foldr — Method

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

# Base.maximum — Function

maximum(f, itr; [init])

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

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

Совместимость: Julia 1.6

Для аргумента ключевого слова init требуется версия не ниже Julia 1.6.

Примеры

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

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

Совместимость: Julia 1.6

Для аргумента ключевого слова init требуется версия не ниже Julia 1.6.

Примеры

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

# Base.maximum! — Function

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

# Base.minimum — Function

minimum(f, itr; [init])

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

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

Совместимость: Julia 1.6

Для аргумента ключевого слова init требуется версия не ниже Julia 1.6.

Примеры

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

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

Совместимость: Julia 1.6

Для аргумента ключевого слова init требуется версия не ниже Julia 1.6.

Примеры

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

# Base.minimum! — Function

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

# Base.extrema — Function

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

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

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

Совместимость: Julia 1.8

Для аргумента ключевого слова init требуется версия не ниже Julia 1.8.

Примеры

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

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

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

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

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

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

Совместимость: Julia 1.2

Для этого метода требуется версия не ниже Julia 1.2.

Совместимость: Julia 1.8

Для аргумента ключевого слова init требуется версия не ниже Julia 1.8.

Примеры

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.

Совместимость: Julia 1.2

Для этого метода требуется версия не ниже Julia 1.2.

# Base.extrema! — Function

extrema!(r, A)

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

Совместимость: Julia 1.8

Для этого метода требуется версия не ниже Julia 1.8.

Примеры

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)

# Base.argmax — Function

argmax(r::AbstractRange)

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

argmax(f, domain)

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

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

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

Совместимость: Julia 1.7

Для этого метода требуется версия не ниже Julia 1.7.

См. также описание 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)

# Base.argmin — Function

argmin(r::AbstractRange)

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

argmin(f, domain)

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

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

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

Совместимость: Julia 1.7

Для этого метода требуется версия не ниже Julia 1.7.

См. также описание 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)

# Base.findmax — Function

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

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

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

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

Совместимость: Julia 1.7

Для этого метода требуется версия не ниже Julia 1.7.

Примеры

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

# Base.findmin — Function

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

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

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

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

Совместимость: Julia 1.7

Для этого метода требуется версия не ниже Julia 1.7.

Примеры

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

# Base.findmax! — Function

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

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

# Base.findmin! — Function

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

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

# Base.sum — Function

sum(f, itr; [init])

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

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

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

Совместимость: Julia 1.6

Для аргумента ключевого слова init требуется версия не ниже Julia 1.6.

Примеры

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

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

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

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

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

sum(itr; [init])

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

Совместимость: Julia 1.6

Для аргумента ключевого слова init требуется версия не ниже Julia 1.6.

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

# Base.sum! — Function

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

# Base.prod — Function

prod(f, itr; [init])

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

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

Совместимость: Julia 1.6

Для аргумента ключевого слова init требуется версия не ниже Julia 1.6.

Примеры

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

prod(itr; [init])

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

Совместимость: Julia 1.6

Для аргумента ключевого слова init требуется версия не ниже Julia 1.6.

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

# Base.prod! — Function

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

# Base.any — Method

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

# Base.any — Method

any(p, itr) -> Bool

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

Примеры

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

# Base.any! — Function

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

# Base.all — Method

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

# Base.all — Method

all(p, itr) -> Bool

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

Примеры

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

# Base.all! — Function

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

# Base.count — Function

count([f=identity,] itr; init=0) -> Integer

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

Совместимость: Julia 1.6

В Julia 1.6 добавлено ключевое слово 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 1.3

Для этого метода требуется версия Julia не ниже 1.3.

Совместимость: Julia 1.7

Для использования символа в качестве шаблона требуется версия Julia не ниже 1.7.

Примеры

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 1.5

В Julia 1.5 добавлено ключевое слово dims.

Совместимость: Julia 1.6

В Julia 1.6 добавлено ключевое слово init.

Примеры

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

# Base.foreach — Function

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

# Base.map — Function

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))  # выполняет итерацию вплоть до исчерпания третьего элемента.
3-element Vector{Float64}:
   2.0
  13.0
 102.0

# Base.map! — Function

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 1.2

Для map!(f, values(dict::AbstractDict)) требуется версия не ниже Julia 1.2.

Примеры

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

# Base.mapreduce — Method

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

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

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

Совместимость: Julia 1.2

Для mapreduce с несколькими итераторами требуется версия не ниже Julia 1.2.

Примеры

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

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

# Base.mapfoldl — Method

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

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

# Base.mapfoldr — Method

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

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

# Base.first — Function

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 1.6

Для этого метода требуется версия не ниже Julia 1.6.

Примеры

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)
"∀ϵ≠"

# Base.last — Function

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 1.6

Для этого метода требуется версия не ниже Julia 1.6.

Примеры

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"

# Base.front — Function

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.

# Base.tail — Function

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.

# Base.step — Function

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

# Base.collect — Method

collect(collection)

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

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

Примеры

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

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

# Base.collect — Method

collect(element_type, collection)

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

Примеры

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

# Base.filter — Function

filter(f, a)

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

Совместимость: Julia 1.4

Для поддержки a в качестве кортежа требуется версия не ниже Julia 1.4.

См. также описание 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]

Совместимость: Julia 1.9

Для этого метода требуется версия Julia не ниже 1.9.

filter(f, d::AbstractDict)

Возвращает копию d, удаляет элементы, для которых f равно false. Функции f передается key=>value пар.

Примеры

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

julia> filter(p->isodd(p.first), d)
Dict{Int64, String} with 1 entry:
  1 => "a"

filter(f, itr::SkipMissing{<:AbstractArray})

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

Совместимость: Julia 1.2

Для этого метода требуется версия не ниже Julia 1.2.

Примеры

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

# Base.filter! — Function

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"

# Base.replace — Method

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 1.7

Для замены элементов Tuple требуется версия 1.7.

Примеры

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

# Base.replace — Method

replace(new::Function, A; [count::Integer])

Возвращает копию A, где каждое из значений x в A заменяется на new(x). Если указывается count, заменяется в общей сложности не более count значений (замены определяются как new(x) !== x).

Совместимость: Julia 1.7

Для замены элементов Tuple требуется версия 1.7.

Примеры

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

# Base.replace! — Function

replace!(A, old_new::Pair...; [count::Integer])

Для каждой пары old=>new в old_new все вхождения A в коллекции old заменяется на new. Равенство определяется с помощью isequal. Если указывается count, заменяется в общей сложности не более count вхождений. See also replace.

Примеры

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

julia> replace!(Set([1, 2, 3]), 1=>0)
Set{Int64} with 3 elements:
  0
  2
  3

replace!(new::Function, A; [count::Integer])

Каждый элемент x в коллекции A заменяется на new(x). Если указывается count, заменяется в общей сложности не более count значений (замены определяются как new(x) !== x).

Примеры

julia> replace!(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Vector{Int64}:
 2
 2
 6
 4

julia> replace!(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64, Int64} with 2 entries:
  3 => 4
  1 => 3

julia> replace!(x->2x, Set([3, 6]))
Set{Int64} with 2 elements:
  6
  12

# Base.rest — Function

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.

Совместимость: Julia 1.6

Для Base.rest требуется версия не ниже Julia 1.6.

См. также описание 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 — Function

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

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

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

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

Совместимость: Julia 1.9

Для Base.split_rest требуется версия не ниже Julia 1.9.

См. также описание 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]))

Индексируемые коллекции

# Base.getindex — Function

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

# Base.setindex! — Function

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

Данное значение сохраняется в данном ключе или индексе в коллекции. Синтаксис +a[i,j,…] = x+is converted by the compiler to(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

# Base.firstindex — Function

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

# Base.lastindex — Function

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

Полностью реализуется следующими типами:

Частично реализуется следующими типами:

AbstractRange
UnitRange
Tuple
AbstractString
Dict
IdDict
WeakKeyDict
NamedTuple

Словари

Dict является стандартным словарем. Его реализация использует hash в качестве функции хэширования для ключа и isequal для определения равенства. Определите эти две функции для пользовательских типов, чтобы переопределить способ их хранения в хэш-таблице.

IdDict является специальной хэш-таблицей, где ключи всегда представляют собой идентификаторы объектов.

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

Объекты Dict могут быть созданы путем передачи пар объектов, построенных с помощью =>, в конструктор Dict: Dict("A"=>1, "B"=>2). Этот вызов попытается вывести информацию о типе из ключей и значений (например, в данном примере создается Dict{String, Int64}). Для явного указания типов используйте синтаксис Dict{KeyType,ValueType}(...). Например, Dict{String,Int32}("A"=>1, "B"=>2).

Словари также могут быть созданы с помощью генераторов. Например, Dict(i => f(i) for i = 1:10).

Если задан словарь D, синтаксис D[x] возвращает значение ключа x (если он существует) или выдает ошибку, а D[x] = y сохраняет пару ключ-значение x => y в D (заменяя все существующие значения для ключа x). Несколько аргументов для D[...] преобразуются в кортежи. Например, синтаксис D[x,y] эквивалентен D[(x,y)], т. е. ссылается на значение, ключом которого является кортеж (x,y).

# Base.AbstractDict — Type

AbstractDict{K, V}

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

# Base.Dict — Type

Dict([itr])

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

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

# Base.IdDict — Type

IdDict([itr])

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

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

Примеры

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"

# Base.WeakKeyDict — Type

WeakKeyDict([itr])

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

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

# Base.ImmutableDict — Type

ImmutableDict

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

ImmutableDict(KV::Pair)

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

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

# Base.haskey — Function

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

# Base.get — Function

get(collection, key, default)

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

Совместимость: Julia 1.7

Для кортежей и числовых значений эта функция требует версию не ниже Julia 1.7.

Примеры

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

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

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

get(f::Function, collection, key)

Возвращает значение, сохраненное для данного ключа, или, если нет сопоставления для ключа, возвращает f(). Использует get! для сохранения значений по умолчанию в словаре.

Предполагается, что эту функцию можно вызвать с помощью значения по умолчанию синтаксиса блока do,

get(dict, key) do
    # вычисленное здесь.
    time()
end

# Base.get! — Function

get!(collection, key, default)

Возвращает значение, сохраненное для данного ключа, или, если нет сопоставления для ключа, сохраняет key => default и возвращается default.

Примеры

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

julia> get!(d, "a", 5)
1

julia> get!(d, "d", 4)
4

julia> d
Dict{String, Int64} with 4 entries:
  "c" => 3
  "b" => 2
  "a" => 1
  "d" => 4

get!(f::Function, collection, key)

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

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

Примеры

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

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

julia> get_square!(squares, 2)
4

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

# Base.getkey — Function

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)

# Base.delete! — Function

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 остается без изменений
Dict{String, Int64} with 1 entry:
  "a" => 1

# Base.pop! — Method

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

# Base.keys — Function

keys(iterator)

Для итератора или коллекции, которая содержит ключи и значения (например, массивы и словари), возвращается итератор на основе ключей.

# Base.values — Function

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

# Base.pairs — Method

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

# Base.pairs — Method

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.

# Base.merge — Function

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 1.1

Для объединения 3 или более NamedTuple требуется версия не ниже Julia 1.1.

Примеры

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)

# Base.mergewith — Function

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 1.5

Для mergewith требуется версия не ниже Julia 1.5.

Примеры

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

# Base.merge! — Function

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

# Base.mergewith! — Function

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 1.5

Для mergewith! требуется версия не ниже Julia 1.5.

Примеры

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

# Base.sizehint! — Function

sizehint!(s, n) -> s

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

См. также описание resize!.

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

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

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

# Base.keytype — Function

keytype(T::Type{<:AbstractArray})
keytype(A::AbstractArray)

Возвращает тип ключа массива. Это равноценно eltype результата keys(...), и предоставляется в основном в целях обеспечения совместимости со словарным интерфейсом.

Примеры

julia> keytype([1, 2, 3]) == Int
true

julia> keytype([1 2; 3 4])
CartesianIndex{2}

Совместимость: Julia 1.2

В случае с массивами для этой функции требуется версия Julia не ниже 1.2.

keytype(type)

Получает тип ключа для типа словаря. Действует аналогично eltype.

Примеры

julia> keytype(Dict(Int32(1) => "foo"))
Int32

# Base.valtype — Function

valtype(T::Type{<:AbstractArray})
valtype(A::AbstractArray)

Возвращает тип значения для массива. Это идентично eltype и предоставляется в основном в целях обеспечения совместимости с интерфейсом словаря.

Примеры

julia> valtype(["one", "two", "three"])
String

Совместимость: Julia 1.2

В случае с массивами для этой функции требуется версия Julia не ниже 1.2.

valtype(type)

Получает тип значения для типа словаря. Действует аналогично eltype.

Примеры

julia> valtype(Dict(Int32(1) => "foo"))
String

Полностью реализуется следующими типами:

IdDict
Dict
WeakKeyDict

Частично реализуется следующими типами:

BitSet
Set
EnvDict
Array
BitArray
ImmutableDict
Iterators.Pairs

Коллекции подобные множествам

# Base.AbstractSet — Type

AbstractSet{T}

Супертип для множественных типов, элементы которого относятся к типу T. Set, BitSet и другие типы являются подтипами этого типа.

# Base.Set — Type

Set{T} <: AbstractSet{T}

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

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

См. также описание AbstractSet, BitSet, Dict, push!, empty!, union!, in, isequal

Примеры

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

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

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

julia> -0.0 in s # isequal(0.0, -0.0) имеет значение false
false

julia> NaN in s # isequal(NaN, NaN) имеет значение true
true

# Base.BitSet — Type

BitSet([itr])

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

# Base.union — Function

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

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

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

Символ Юникод ∪ можно ввести, написав \cup, а затем нажав кнопку TAB в REPL Julia, а также в различных редакторах. Это инфиксный оператор, разрешающий s ∪ itr.

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

Примеры

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

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

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

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

# Base.union! — Function

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

# Base.intersect — Function

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

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

Символ Юникод ∩ можно ввести, написав \cap, а затем нажав кнопку TAB в REPL Julia, а также в различных редакторах. Это инфиксный оператор, разрешающий s ∩ itr.

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

Совместимость: Julia 1.8

Начиная с версии Julia 1.8 объединение по пересечению возвращает результат с типом eltype для eltype с повышением уровня типа для двух вводов

Примеры

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

# Base.setdiff — Function

setdiff(s, itrs...)

Выполняет построение набора элементов в s, но не в любых итерируемых коллекциях в itrs. Порядок сохраняется с помощью массивов.

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

Примеры

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

# Base.setdiff! — Function

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

# Base.symdiff — Function

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

# Base.symdiff! — Function

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

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

# Base.intersect! — Function

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

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

# Base.issubset — Function

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

# Base.:⊈ — Function

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

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

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

Примеры

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

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

# Base.:⊊ — Function

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

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

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

Примеры

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

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

# Base.issetequal — Function

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

# Base.isdisjoint — Function

isdisjoint(a, b) -> Bool

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

См. также описание intersect, isempty, issetequal.

Совместимость: Julia 1.5

Для этой функции требуется версия не ниже Julia 1.5.

Примеры

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

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

Полностью реализуется следующими типами:

BitSet
Set

Частично реализуется следующими типами:

Array

Двусторонние очереди

# Base.push! — Function

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]). For AbstractSet objects, union!, его можно использовать вместо этого примера.

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

См. также описание pushfirst!.

# Base.pop! — Function

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

Примеры

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

# Base.popat! — Function

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

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

См. также описание pop!, popfirst!, deleteat!, splice!.

Совместимость: Julia 1.5

Эта функция впервые реализована в Julia 1.5.

Примеры

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]
[...]

# Base.pushfirst! — Function

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

# Base.popfirst! — Function

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

# Base.insert! — Function

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

# Base.deleteat! — Function

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:
[...]

# Base.keepat! — Function

keepat!(a::Vector, inds)
keepat!(a::BitVector, inds)

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

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

Совместимость: Julia 1.7

Эта функция впервые реализована в Julia 1.7.

Примеры

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

# Base.splice! — Function

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 1.5

До Julia 1.5 indices всегда должен был быть UnitRange.

Совместимость: Julia 1.8

До Julia 1.8 indices всегда должен был быть UnitRange, если выполнялась вставка заменяющих значений.

Примеры

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

# Base.resize! — Function

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

# Base.append! — Function

append!(collection, collections...) -> collection.

Для упорядоченных контейнеров collection следует добавить элементы каждой collections в конце контейнера.

Совместимость: Julia 1.6

Для указания нескольких коллекций, которые требуется присоединить, необходима версия не ниже Julia 1.6.

Примеры

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! (обратный порядок).

# Base.prepend! — Function

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

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

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

Совместимость: Julia 1.6

Для указания нескольких коллекций, которые требуется присоединить в начале, необходима версия не ниже Julia 1.6.

Примеры

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

Полностью реализуется следующими типами:

Vector (или одномерный массив Array)
BitVector (или одномерный массив BitArray)

Полезные коллекции

# Core.Pair — Type

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"

# Base.Pairs — Type

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

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