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

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

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

IteratorSize(itertype::Type) -> IteratorSize

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

• SizeUnknown(), если длина (количество элементов) не может быть определена заранее.
• HasLength(), если длина фиксирована и конечна.
• HasShape{N}(), если известна длина плюс понятие многомерной формы (как для массива). В этом случае N должна возвращать количество измерений, а функция axes допустима для итератора.
• IsInfinite(), если итератор генерирует значения бесконечно.

Значение по умолчанию (для итераторов, которые не определяют эту функцию) — HasLength(). Это означает, что большинство итераторов предполагается, что они реализуют length.

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

julia> Base.IteratorSize(1:5)
Base.HasShape{1}()

julia> Base.IteratorSize((2,3))
Base.HasLength()

IteratorEltype(itertype::Type) -> IteratorEltype

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

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

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

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

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

AbstractRange{T} <: AbstractVector{T}

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

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

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

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

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

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

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

Диапазоны с элементами типа T с шагом типа S. Шаг между каждым элементом постоянен, и диапазон определяется начальным и конечным значениями типа T и шагом типа S. Ни T, ни S не должны быть типами с плавающей точкой. Синтаксис a:b:c с b != 0 и a, b и c, все целые числа создают StepRange.

Примеры

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

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

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

UnitRange{T<:Real}

Диапазон, параметризованный начальным и конечным значениями типа T, заполненный элементами, отстоящими на 1 от start до превышения stop. Синтаксис a:b с a и b, оба являющиеся Integer, создаёт UnitRange.

Примеры

julia> collect(UnitRange(2.3, 5.2))
3-element Vector{Float64}:
 2.3
 3.3
 4.3

julia> typeof(1:10)
UnitRange{Int64}

LinRange{T,L}

Диапазон с len линейно расположенными элементами между его start и stop. Размер шага контролируется len, который должен быть типа Integer.

Примеры

julia> LinRange(1.5, 5.5, 9)
9-element LinRange{Float64, Int64}:
 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5

По сравнению с использованием range, непосредственное построение LinRange должно иметь меньшую нагрузку, но не будет пытаться исправить ошибки с плавающей точкой:

julia> collect(range(-0.1, 0.3, length=5))
5-element Vector{Float64}:
 -0.1
  0.0
  0.1
  0.2
  0.3

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

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

isempty(collection) -> Bool

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

Примеры

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

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

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

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

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

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

См. также iterate, isempty

empty!(collection) -> collection

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

Примеры

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

julia> empty!(A);

julia> A
Dict{String, Int64}()

empty!(c::Channel)

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

length(collection) -> Integer

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

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

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

Примеры

julia> length(1:5)
5

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

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

Base.checked_length(r)

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

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

Определить, принадлежит ли элемент данной коллекции в том смысле, что он == одному из значений, сгенерированных при итерации по коллекции. Возвращает логическое значение, за исключением случаев, когда item является missing или collection содержит missing, но не item, в этом случае возвращается missing (трёхзначная логика, соответствие поведению any и ==).

Некоторые коллекции следуют немного другому определению. Например, Set проверяют, равен ли элемент isequal одному из элементов; Dict ищут key=>value пары, и key сравнивается с помощью isequal.

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

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

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

Примеры

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

julia> 4 in a
true

julia> 5 in a
false

julia> missing in [1, 2]
missing

julia> 1 in [2, missing]
missing

julia> 1 in [1, missing]
true

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

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

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

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

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

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

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

Примеры

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

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

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

Base.hasfastin(T)

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

По умолчанию для hasfastin(T) — true для подтипов AbstractSet, AbstractDict и AbstractRange и false в остальных случаях.

eltype(type)

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

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

Примеры

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

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

indexin(a, b)

Возвращает массив, содержащий первый индекс в b для каждого значения в a, которое является членом b. Выходной массив содержит nothing, когда a не является членом b.

См. также: sortperm, findfirst.

Примеры

julia> a = ['a', 'b', 'c', 'b', 'd', 'a'];

julia> b = ['a', 'b', 'c'];

julia> indexin(a, b)
6-element Vector{Union{Nothing, Int64}}:
 1
 2
 3
 2
  nothing
 1

julia> indexin(b, a)
3-element Vector{Union{Nothing, Int64}}:
 1
 2
 3

unique(itr)

Возвращает массив, содержащий только уникальные элементы коллекции itr, определённые по isequal и hash, в порядке первого появления каждого набора эквивалентных элементов. Тип элементов входных данных сохраняется.

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

Примеры

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

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

unique(f, itr)

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

Примеры

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

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

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

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

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

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

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

Возвращает уникальные области A вдоль размерности dims.

Примеры

julia> A = map(isodd, reshape(Vector(1:8), (2,2,2)))
2×2×2 Array{Bool, 3}:
[:, :, 1] =
 1  1
 0  0

[:, :, 2] =
 1  1
 0  0

julia> unique(A)
2-element Vector{Bool}:
 1
 0

julia> unique(A, dims=2)
2×1×2 Array{Bool, 3}:
[:, :, 1] =
 1
 0

[:, :, 2] =
 1
 0

julia> unique(A, dims=3)
2×2×1 Array{Bool, 3}:
[:, :, 1] =
 1  1
 0  0

unique!(f, A::AbstractVector)

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

Примеры

julia> unique!(x -> x^2, [1, -1, 3, -3, 4])
3-element Vector{Int64}:
 1
 3
 4

julia> unique!(n -> n%3, [5, 1, 8, 9, 3, 4, 10, 7, 2, 6])
3-element Vector{Int64}:
 5
 1
 9

julia> unique!(iseven, [2, 3, 5, 7, 9])
2-element Vector{Int64}:
 2
 3

unique!(A::AbstractVector)

Удаляет дублируемые элементы, как определено isequal и hash, затем возвращает измененный A. unique! вернёт элементы A в порядке их появления. Если порядок возвращаемых данных не важен, то вызов (sort!(A); unique!(A)) будет значительно эффективнее, если элементы A могут быть отсортированы.

Примеры

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

julia> A = [7, 3, 2, 3, 7, 5];

julia> unique!(A)
4-element Vector{Int64}:
 7
 3
 2
 5

julia> B = [7, 6, 42, 6, 7, 42];

julia> sort!(B);  # unique! is able to process sorted data much more efficiently.

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

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

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

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

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

См. также: unique, issorted, allequal.

Примеры

julia> allunique([1, 2, 3])
true

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

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

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

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

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

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

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

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

Примеры

julia> allequal([])
true

julia> allequal([1])
true

julia> allequal([1, 1])
true

julia> allequal([1, 2])
false

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

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

reduce(op, itr; [init])

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

foldl(op, itr; [init])

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

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

Примеры

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

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

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

foldr(op, itr; [init])

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

Примеры

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

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

maximum(f, itr; [init])

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

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

Примеры

julia> maximum(length, ["Julion", "Julia", "Jule"])
6

julia> maximum(length, []; init=-1)
-1

julia> maximum(sin, Real[]; init=-1.0)  # good, since output of sin is >= -1
-1.0

maximum(itr; [init])

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

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

Примеры

julia> maximum(-20.5:10)
9.5

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

julia> maximum(())
ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

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

maximum(A::AbstractArray; dims)

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

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

Примеры

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

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

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

maximum(f, A::AbstractArray; dims)

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

Примеры

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

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

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

maximum!(r, A)

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

Примеры

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

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

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

minimum(f, itr; [init])

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

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

Примеры

julia> minimum(length, ["Julion", "Julia", "Jule"])
4

julia> minimum(length, []; init=typemax(Int64))
9223372036854775807

julia> minimum(sin, Real[]; init=1.0)  # good, since output of sin is <= 1
1.0

minimum(itr; [init])

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

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

Примеры

julia> minimum(-20.5:10)
-20.5

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

julia> minimum([])
ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

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

minimum(A::AbstractArray; dims)

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

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

Примеры

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

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

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

minimum(f, A::AbstractArray; dims)

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

Примеры

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

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

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

minimum!(r, A)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

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

extrema!(r, A)

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

Примеры

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

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

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

argmax(r::AbstractRange)

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

argmax(f, domain)

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

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

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

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

Примеры

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

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

argmax(itr)

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

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

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

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

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

Примеры

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

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

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

argmax(A; dims) -> indices

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

Примеры

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

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

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

argmin(r::AbstractRange)

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

argmin(f, domain)

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

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

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

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

Примеры

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

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

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

argmin(itr)

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

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

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

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

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

Примеры

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

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

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

argmin(A; dims) -> indices

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

Примеры

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

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

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

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

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

domain должен быть непустым итерируемым объектом, поддерживающим keys. Индексы имеют тот же тип, что и возвращаемые keys(domain).

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

Примеры

julia> findmax(identity, 5:9)
(9, 5)

julia> findmax(-, 1:10)
(-1, 1)

julia> findmax(first, [(1, :a), (3, :b), (3, :c)])
(3, 2)

julia> findmax(cos, 0:π/2:2π)
(1.0, 1)

findmax(itr) -> (x, index)

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

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

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

Примеры

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

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

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

findmax(A; dims) -> (maxval, index)

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

Примеры

julia> findmin(identity, 5:9)
(5, 1)

julia> findmin(-, 1:10)
(-10, 10)

julia> findmin(first, [(2, :a), (2, :b), (3, :c)])
(2, 1)

julia> findmin(cos, 0:π/2:2π)
(-1.0, 3)

findmin(itr) -> (x, index)

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

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

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

Примеры

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

julia> findmin([1, 7, 7, 6])
(1, 1)

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

findmin(A; dims) -> (minval, index)

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

sum(f, itr; [init])

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

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

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

Примеры

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

Обратите внимание на важное различие между sum(A) и reduce(+, A) для массивов с целочисленным типом элементов малого размера:

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

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

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

sum(itr; [init])

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

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

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

См. также: reduce, mapreduce, count, union.

Примеры

julia> sum(1:20)
210

julia> sum(1:20; init = 0.0)
210.0

sum(A::AbstractArray; dims)

Суммирует элементы массива по заданным измерениям.

Примеры

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

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

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

sum(f, A::AbstractArray; dims)

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

Примеры

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

julia> sum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 10  20

julia> sum(abs2, A, dims=2)
2×1 Matrix{Int64}:
  5
 25

sum!(r, A)

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

Примеры

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

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

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

prod(f, itr; [init])

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

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

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

Примеры

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

prod(itr; [init])

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

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

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

См. также: reduce, cumprod, any.

Примеры

julia> prod(1:5)
120

julia> prod(1:5; init = 1.0)
120.0

prod(A::AbstractArray; dims)

Перемножает элементы массива по заданным измерениям.

Примеры

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

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

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

prod(f, A::AbstractArray; dims)

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

Примеры

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

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

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

prod!(r, A)

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

Примеры

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

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

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

any(itr) -> Bool

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

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

См. также: all, count, sum, |, , ||.

Примеры

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> any(a)
true

julia> any((println(i); v) for (i, v) in enumerate(a))
1
true

julia> any([missing, true])
true

julia> any([false, missing])
missing

any(p, itr) -> Bool

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

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

Примеры

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

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

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

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

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

any!(r, A)

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

Примеры

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

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

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

all(itr) -> Bool

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

Если вход содержит значения missing, верните missing, если все ненулевые значения true (или, что эквивалентно, если вход не содержит ни одного false значения), следуя логике трёхзначной логики.

См. также: all!, any, count, &, , &&, allunique.

Примеры

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> all(a)
false

julia> all((println(i); v) for (i, v) in enumerate(a))
1
2
false

julia> all([missing, false])
false

julia> all([true, missing])
missing

all(p, itr) -> Bool

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

Если вход содержит значения missing, верните missing, если все ненулевые значения true (или, что эквивалентно, если вход не содержит ни одного false значения), следуя логике трёхзначной логики.

Примеры

julia> all(i->(4<=i<=6), [4,5,6])
true

julia> all(i -> (println(i); i < 3), 1:10)
1
2
3
false

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

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

julia> all(i -> i > 0, [1, 2])
true

all!(r, A)

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

Примеры

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

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

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

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

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

См. также: any, sum.

Примеры

julia> count(i->(4<=i<=6), [2,3,4,5,6])
3

julia> count([true, false, true, true])
3

julia> count(>(3), 1:7, init=0x03)
0x07

count(
    pattern::Union{AbstractChar,AbstractString,AbstractPattern},
    string::AbstractString;
    overlap::Bool = false,
)

Возвращает количество совпадений для pattern в string. Это эквивалентно вызову length(findall(pattern, string)), но более эффективно.

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

Примеры

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

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

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

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

Подсчитайте количество элементов в A, для которых f возвращает true по заданным измерениям.

Примеры

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

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

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

foreach(f, c...) -> Nothing

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

foreach следует использовать вместо map, когда результаты f не нужны, например, в foreach(println, array).

Примеры

julia> tri = 1:3:7; res = Int[];

julia> foreach(x -> push!(res, x^2), tri)

julia> res
3-element Vector{Int64}:
  1
 16
 49

julia> foreach((x, y) -> println(x, " with ", y), tri, 'a':'z')
1 with a
4 with b
7 with c

map(f, c...) -> collection

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

См. также map!, foreach, mapreduce, mapslices, zip, Iterators.map.

Примеры

julia> map(x -> x * 2, [1, 2, 3])
3-element Vector{Int64}:
 2
 4
 6

julia> map(+, [1, 2, 3], [10, 20, 30, 400, 5000])
3-element Vector{Int64}:
 11
 22
 33

map(f, A::AbstractArray...) -> N-array

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

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

Примеры

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

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

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

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

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

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

Примеры

julia> a = zeros(3);

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

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

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

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

Изменяет dict, преобразуя каждое значение из val в f(val). Обратите внимание, что тип dict не может быть изменён: если f(val) не является экземпляром типа значения dict, то он будет преобразован в тип значения, если это возможно, а иначе будет выведено сообщение об ошибке.

Примеры

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

julia> map!(v -> v-1, values(d))
ValueIterator for a Dict{Symbol, Int64} with 2 entries. Values:
  0
  1

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

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

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

Примеры

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

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

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

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

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

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

first(coll)

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

См. также: only, firstindex, last.

Примеры

julia> first(2:2:10)
2

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

first(itr, n::Integer)

Получить первые n элементы итерируемой коллекции itr, или меньше элементов, если itr недостаточно длинна.

См. также: startswith, Iterators.take.

Примеры

julia> first(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "foo"
 "bar"

julia> first(1:6, 10)
1:6

julia> first(Bool[], 1)
Bool[]

first(s::AbstractString, n::Integer)

Получить строку, состоящую из первых n символов s.

Примеры

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

last(coll)

Получить последний элемент упорядоченной коллекции, если его можно вычислить за O(1) времени. Это достигается с помощью вызова lastindex для получения последнего индекса. Возвращает конечную точку AbstractRange, даже если она пустая.

См. также first, endswith.

Примеры

julia> last(1:2:10)
9

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

last(itr, n::Integer)

Получить последние n элементы итерируемой коллекции itr, или меньше элементов, если itr недостаточно длинна.

Примеры

julia> last(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "bar"
 "qux"

julia> last(1:6, 10)
1:6

julia> last(Float64[], 1)
Float64[]

last(s::AbstractString, n::Integer)

Получить строку, состоящую из последних n символов s.

Примеры

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

front(x::Tuple)::Tuple

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

См. также: first, tail.

Примеры

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

julia> Base.front(())
ERROR: ArgumentError: Cannot call front on an empty tuple.

tail(x::Tuple)::Tuple

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

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

Примеры

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

julia> Base.tail(())
ERROR: ArgumentError: Cannot call tail on an empty tuple.

step(r)

Получить шаг объекта AbstractRange.

Примеры

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

julia> step(range(2.5, stop=10.9, length=85))
0.1

collect(collection)

Возвращает Array всех элементов в коллекции или итераторе. Для словарей возвращает Vector key=>value пар. Если аргумент подобен массиву или является итератором с признаком HasShape, результат будет иметь ту же форму и количество измерений, что и аргумент.

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

Примеры

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

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

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

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

collect(element_type, collection)

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

Примеры

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

filter(f, a)

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

См. также: filter!, Iterators.filter.

Примеры

julia> a = 1:10
1:10

julia> filter(isodd, a)
5-element Vector{Int64}:
 1
 3
 5
 7
 9

filter(f)

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

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

Примеры

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

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

filter(f, d::AbstractDict)

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

Примеры

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

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

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

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

Примеры

julia> x = [1 2; missing 4]
2×2 Matrix{Union{Missing, Int64}}:
 1         2
  missing  4

julia> filter(isodd, skipmissing(x))
1-element Vector{Int64}:
 1

filter!(f, a)

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

Примеры

julia> filter!(isodd, Vector(1:10))
5-element Vector{Int64}:
 1
 3
 5
 7
 9

filter!(f, d::AbstractDict)

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

Примеры

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

julia> filter!(p->isodd(p.first), d)
Dict{Int64, String} with 2 entries:
  3 => "c"
  1 => "a"

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

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

Тип элемента результата выбирается с помощью повышения (см. promote_type) на основе типа элемента A и типов значений new в парах. Если count опущено и тип элемента A является Union, тип элемента результата не будет включать одиночные типы, которые заменяются значениями другого типа: например, Union{T,Missing} станет T, если missing заменяется.

См. также replace!, splice!, delete!, insert!.

Примеры

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

julia> replace([1, missing], missing=>0)
2-element Vector{Int64}:
 1
 0

replace(new::Union{Function, Type}, A; [count::Integer])

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

Примеры

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

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

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

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

Примеры

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

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

replace!(new::Union{Function, Type}, A; [count::Integer])

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

Примеры

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

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

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

Base.rest(collection[, itr_state])

Обобщенная функция для получения хвоста collection, начиная с определенного состояния итерации itr_state. Возвращает Tuple, если collection сам является Tuple, подтипом AbstractVector, если collection является AbstractArray, подтипом AbstractString, если collection является AbstractString, и произвольным итератором, в противном случае возвращая Iterators.rest(collection[, itr_state]).

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

См. также: first, Iterators.rest, Base.split_rest.

Примеры

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

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

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

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

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

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

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

См. также: Base.rest.

Примеры

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

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

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

getindex(collection, key...)

Извлечение значения(ей) по заданному ключу или индексу в коллекции. Синтаксис a[i,j,...] компилятором преобразуется в getindex(a, i, j, ...).

См. также get, keys, eachindex.

Примеры

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

julia> getindex(A, "a")
1

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

Запись заданного значения по заданному ключу или индексу в коллекции. Синтаксис a[i,j,...] = x компилятором преобразуется в (setindex!(a, x, i, j, ...); x).

Примеры

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

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

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

Возвращает первый индекс collection. Если задан d, возвращает первый индекс collection по размерности d.

Синтаксисы A[begin] и A[1, begin] эквивалентны соответственно A[firstindex(A)] и A[1, firstindex(A, 2)].

См. также: first, axes, lastindex, nextind.

Примеры

julia> firstindex([1,2,4])
1

julia> firstindex(rand(3,4,5), 2)
1

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

Возвращает последний индекс collection. Если задан d, возвращает последний индекс collection по размерности d.

Синтаксисы A[end] и A[end, end] эквивалентны соответственно A[lastindex(A)] и A[lastindex(A, 1), lastindex(A, 2)].

См. также: axes, firstindex, eachindex, prevind.

Примеры

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

julia> lastindex(rand(3,4,5), 2)
4

AbstractDict{K, V}

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

Dict([itr])

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

Принимая единственный аргумент-итерируемый объект, создаёт Dict, пары ключ-значение которого взяты из 2-х кортежей (key,value), сгенерированных аргументом.

Примеры

julia> Dict([("A", 1), ("B", 2)])
Dict{String, Int64} with 2 entries:
  "B" => 2
  "A" => 1

В качестве альтернативы можно передать последовательность аргументов-пар.

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

IdDict([itr])

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

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

Примеры

julia> Dict(true => "yes", 1 => "no", 1.0 => "maybe")
Dict{Real, String} with 1 entry:
  1.0 => "maybe"

julia> IdDict(true => "yes", 1 => "no", 1.0 => "maybe")
IdDict{Any, String} with 3 entries:
  true => "yes"
  1.0  => "maybe"
  1    => "no"

WeakKeyDict([itr])

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

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

См. также WeakRef.

ImmutableDict

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

ImmutableDict(KV::Pair)

Создать новую запись в ImmutableDict для пары key => value

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

PersistentDict

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

PersistentDict(KV::Pair)

Примеры

julia> dict = Base.PersistentDict(:a=>1)
Base.PersistentDict{Symbol, Int64} with 1 entry:
  :a => 1

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

julia> dict3 = Base.PersistentDict(dict, :a=>2)
Base.PersistentDict{Symbol, Int64} with 1 entry:
  :a => 2

haskey(collection, key) -> Bool

Определите, содержит ли коллекция отображение для данного key.

Примеры

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

get(collection, key, default)

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

Примеры

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

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

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

get(f::Union{Function, Type}, collection, key)

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

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

get(dict, key) do
    # default value calculated here
    time()
end

get!(collection, key, default)

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

Примеры

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

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

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

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

get!(f::Union{Function, Type}, collection, key)

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

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

Примеры

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

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

julia> get_square!(squares, 2)
4

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

getkey(collection, key, default)

Возвращает ключ, соответствующий аргументу key, если он существует в collection, в противном случае возвращает default.

Примеры

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> getkey(D, 'a', 1)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> getkey(D, 'd', 'a')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

delete!(collection, key)

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

Примеры

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

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

julia> delete!(d, "b") # d is left unchanged
Dict{String, Int64} with 1 entry:
  "a" => 1

pop!(collection, key[, default])

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

Примеры

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

julia> pop!(d, "a")
1

julia> pop!(d, "d")
ERROR: KeyError: key "d" not found
Stacktrace:
[...]

julia> pop!(d, "e", 4)
4

keys(iterator)

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

values(iterator)

Для итератора или коллекции, имеющей ключи и значения, возвращает итератор по значениям. По умолчанию эта функция просто возвращает свой аргумент, так как элементы общего итератора обычно считаются его «значениями».

Примеры

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

julia> values(d)
ValueIterator for a Dict{String, Int64} with 2 entries. Values:
  2
  1

julia> values([2])
1-element Vector{Int64}:
 2

values(a::AbstractDict)

Возвращает итератор по всем значениям в коллекции. collect(values(a)) возвращает массив значений. Когда значения хранятся внутри хэш-таблицы, как в случае с Dict, порядок, в котором они возвращаются, может меняться. Но keys(a) и values(a) оба итерируют a и возвращают элементы в том же порядке.

Примеры

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} with 2 entries:
  'a' => 2
  'b' => 3

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

pairs(IndexLinear(), A)
pairs(IndexCartesian(), A)
pairs(IndexStyle(A), A)

Итератор, который обращается к каждому элементу массива A, возвращая i => x, где i — индекс для элемента, а x = A[i]. Идентично pairs(A), за исключением того, что можно выбрать стиль индекса. Также аналогично enumerate(A), за исключением того, что i будет корректным индексом для A, тогда как enumerate всегда считает с 1 независимо от индексов A.

Указание IndexLinear() гарантирует, что i будет целым числом; указание IndexCartesian() гарантирует, что i будет Base.CartesianIndex; указание IndexStyle(A) выбирает стиль индексирования, определённый для массива A.

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

Примеры

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

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

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

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

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

pairs(collection)

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

Примеры

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

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

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

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

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

merge(initial::Face, others::Face...)

Объединяет свойства грани initial и others, причём грани, указанные позже, имеют приоритет.

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

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

Примеры

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

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

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

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

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

Создаёт новую именованную кортеж, объединяя два или более существующих, слева направо. Объединение происходит слева направо, между парами именованных кортежей, и поэтому порядок полей, присутствующих как в левом, так и в правом именованных кортежах, занимает то же место, что и в левом именованном кортеже. Однако значения берутся из соответствующих полей в правом именованном кортеже, содержащем это поле. Поля, присутствующие только в правом именованном кортеже пары, добавляются в конец. Реализован запасной вариант для случая, когда предоставлен только один именованный кортеж, с сигнатурой merge(a::NamedTuple).

Примеры

julia> merge((a=1, b=2, c=3), (b=4, d=5))
(a = 1, b = 4, c = 3, d = 5)

julia> merge((a=1, b=2), (b=3, c=(d=1,)), (c=(d=2,),))
(a = 1, b = 3, c = (d = 2,))

merge(a::NamedTuple, iterable)

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

julia> merge((a=1, b=2, c=3), [:b=>4, :d=>5])
(a = 1, b = 4, c = 3, d = 5)

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

Создаёт объединённую коллекцию из заданных коллекций. Если необходимо, типы результирующей коллекции будут повышены для соответствия типам объединённых коллекций. Значения с одинаковым ключом будут объединены с помощью функции комбинирования. Курированная форма mergewith(combine) возвращает функцию (args...) -> mergewith(combine, args...).

Метод merge(combine::Union{Function,Type}, args...) в качестве псевдонима mergewith(combine, args...) всё ещё доступен для обратной совместимости.

Примеры

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

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

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

julia> ans == mergewith(+)(a, b)
true

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

Обновляет коллекцию парами из других коллекций. См. также merge.

Примеры

julia> d1 = Dict(1 => 2, 3 => 4);

julia> d2 = Dict(1 => 4, 4 => 5);

julia> merge!(d1, d2);

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 4
  1 => 4

mergewith!(combine, d::AbstractDict, others::AbstractDict...) -> d
mergewith!(combine)
merge!(combine, d::AbstractDict, others::AbstractDict...) -> d

Обновить коллекцию парами из других коллекций. Значения с одинаковым ключом будут объединены с помощью функции комбинирования. Замыкающая форма mergewith!(combine) возвращает функцию (args...) -> mergewith!(combine, args...).

Метод merge!(combine::Union{Function,Type}, args...) как псевдоним для mergewith!(combine, args...) по-прежнему доступен для обратной совместимости.

Примеры

julia> d1 = Dict(1 => 2, 3 => 4);

julia> d2 = Dict(1 => 4, 4 => 5);

julia> mergewith!(+, d1, d2);

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 4
  1 => 6

julia> mergewith!(-, d1, d1);

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 0
  3 => 0
  1 => 0

julia> foldl(mergewith!(+), [d1, d2]; init=Dict{Int64, Int64}())
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 0
  1 => 4

sizehint!(s, n; first::Bool=false, shrink::Bool=true) -> s

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

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

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

См. также resize!.

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

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

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

2. sizehint! может контролировать это предварительное выделение. Опять же, это обычно выполняется для типов в Base.

3. empty! практически бесплатно (и O(1)) для типов, которые поддерживают этот вид предварительного выделения.

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

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

Примеры

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

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

keytype(type)

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

Примеры

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

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

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

Примеры

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

valtype(type)

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

Примеры

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

AbstractSet{T}

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

Set{T} <: AbstractSet{T}

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

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

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

Примеры

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

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

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

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

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

BitSet([itr])

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

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

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

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

Примеры

julia> Set(Any[true, 1, 1.0])
Set{Any} with 1 element:
  1.0

julia> IdSet{Any}(Any[true, 1, 1.0])
IdSet{Any} with 3 elements:
  1.0
  1
  true

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

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

setdiff(s, itrs...)

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

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

Примеры

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

setdiff!(s, itrs...)

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

Примеры

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

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

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

symdiff(s, itrs...)

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

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

Примеры

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

julia> symdiff([1,2,1], [2, 1, 2])
Int64[]

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

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

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

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

issubset(a, b) -> Bool
⊆(a, b) -> Bool
⊇(b, a) -> Bool

Определяет, является ли каждый элемент a также элементом b, используя in.

См. также ⊊, ⊈, ∩, ∪, contains.

Примеры

julia> issubset([1, 2], [1, 2, 3])
true

julia> [1, 2, 3] ⊆ [1, 2]
false

julia> [1, 2, 3] ⊇ [1, 2]
true

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

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

См. также: in, push!, Set

Примеры

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

julia> length(s)
4

julia> in!(0x04, s)
true

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

issetequal(a, b) -> Bool

Определяет, имеют ли a и b одинаковые элементы. Эквивалентно a ⊆ b && b ⊆ a, но более эффективно, когда возможно.

См. также: isdisjoint, union.

Примеры

julia> issetequal([1, 2], [1, 2, 3])
false

julia> issetequal([1, 2], [2, 1])
true

issetequal(x)

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

isdisjoint(a, b) -> Bool

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

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

Примеры

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

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

isdisjoint(x)

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

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

Вставьте один или несколько items в collection. Если collection — упорядоченный контейнер, элементы вставляются в конец (в указанном порядке).

Примеры

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

Если collection упорядочен, используйте append! для добавления всех элементов другого набора в него. Результат предыдущего примера эквивалентен append!([1, 2, 3], [4, 5, 6]). Для объектов AbstractSet вместо этого можно использовать union!.

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

См. также pushfirst!.

pop!(collection) -> item

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

См. также: popfirst!, popat!, delete!, deleteat!, splice! и push!.

Примеры

julia> A=[1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> pop!(A)
3

julia> A
2-element Vector{Int64}:
 1
 2

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

julia> pop!(S)
2

julia> S
Set{Int64} with 1 element:
  1

julia> pop!(Dict(1=>2))
1 => 2

pop!(collection, key[, default])

Удалить и вернуть сопоставление для key, если оно существует в collection, в противном случае вернуть default или выбросить ошибку, если default не указано.

Примеры

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

julia> pop!(d, "a")
1

julia> pop!(d, "d")
ERROR: KeyError: key "d" not found
Stacktrace:
[...]

julia> pop!(d, "e", 4)
4

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

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

См. также: pop!, popfirst!, deleteat!, splice!.

Примеры

julia> a = [4, 3, 2, 1]; popat!(a, 2)
3

julia> a
3-element Vector{Int64}:
 4
 2
 1

julia> popat!(a, 4, missing)
missing

julia> popat!(a, 4)
ERROR: BoundsError: attempt to access 3-element Vector{Int64} at index [4]
[...]

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

Вставить один или несколько items в начало collection.

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

Примеры

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

popfirst!(collection) -> item

Удалить первый item из collection.

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

См. также: pop!, popat!, delete!.

Примеры

julia> A = [1, 2, 3, 4, 5, 6]
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

julia> popfirst!(A)
1

julia> A
5-element Vector{Int64}:
 2
 3
 4
 5
 6

insert!(a::Vector, index::Integer, item)

Вставить item в a по заданному index. index — это индекс item в результирующем a.

См. также: push!, replace, popat!, splice!.

Примеры

julia> insert!(Any[1:6;], 3, "here")
7-element Vector{Any}:
 1
 2
  "here"
 3
 4
 5
 6

deleteat!(a::Vector, i::Integer)

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

См. также: keepat!, delete!, popat!, splice!.

Примеры

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

deleteat!(a::Vector, inds)

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

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

Примеры

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

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

julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
ERROR: ArgumentError: indices must be unique and sorted
Stacktrace:
[...]

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

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

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

Примеры

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

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

Встроенная версия логического индексирования a = a[m]. То есть, применение keepat!(a, m) к векторам одинаковой длины a и m удалит все элементы из a, для которых значение m в соответствующем индексе равно false.

Примеры

julia> a = [:a, :b, :c];

julia> keepat!(a, [true, false, true])
2-element Vector{Symbol}:
 :a
 :c

julia> a
2-element Vector{Symbol}:
 :a
 :c

splice!(a::Vector, index::Integer, [replacement]) -> item

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

См. также: replace, delete!, deleteat!, pop!, popat!.

Примеры

julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
2

julia> A
5-element Vector{Int64}:
 6
 5
 4
 3
 1

julia> splice!(A, 5, -1)
1

julia> A
5-element Vector{Int64}:
  6
  5
  4
  3
 -1

julia> splice!(A, 1, [-1, -2, -3])
6

julia> A
7-element Vector{Int64}:
 -1
 -2
 -3
  5
  4
  3
 -1

Чтобы вставить replacement перед индексом n без удаления элементов, используйте splice!(collection, n:n-1, replacement).

splice!(a::Vector, indices, [replacement]) -> items

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

Чтобы вставить replacement перед индексом n без удаления элементов, используйте splice!(collection, n:n-1, replacement).

Примеры

julia> A = [-1, -2, -3, 5, 4, 3, -1]; splice!(A, 4:3, 2)
Int64[]

julia> A
8-element Vector{Int64}:
 -1
 -2
 -3
  2
  5
  4
  3
 -1

resize!(a::Vector, n::Integer) -> Vector

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

Примеры

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

julia> a = resize!([6, 5, 4, 3, 2, 1], 8);

julia> length(a)
8

julia> a[1:6]
6-element Vector{Int64}:
 6
 5
 4
 3
 2
 1

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

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

Примеры

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

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

Используйте push!, чтобы добавлять отдельные элементы в collection, которые сами не являются коллекциями. Результат предыдущего примера эквивалентен push!([1, 2, 3], 4, 5, 6).

См. sizehint! для информации о модели производительности.

См. также vcat для векторов, union! для множеств и prepend! и pushfirst! для добавления в обратном порядке.

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

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

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

Примеры

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

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

Pair(x, y)
x => y

Создать объект Pair с типом Pair{typeof(x), typeof(y)}. Элементы хранятся в полях first и second. Они также могут быть доступны с помощью итерации (но Pair обрабатывается как один "скаляр" для операций векторизации).

См. также Dict.

Примеры

julia> p = "foo" => 7
"foo" => 7

julia> typeof(p)
Pair{String, Int64}

julia> p.first
"foo"

julia> for x in p
           println(x)
       end
foo
7

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

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

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