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

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

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

IteratorSize(itertype::Type) -> IteratorSize

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

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

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

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

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

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

IteratorEltype(itertype::Type) -> IteratorEltype

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

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

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

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

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

AbstractRange{T}

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

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

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

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

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

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

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

Примеры

julia> collect(StepRange(1, Int8(2), 10))
5-element Array{Int64,1}:
 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 Array{Float64,1}:
 2.3
 3.3
 4.3

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

LinRange{T}

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

Примеры

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

isempty(collection) -> Bool

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

Примеры

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

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

empty!(collection) -> collection

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

Примеры

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

julia> empty!(A);

julia> A
Dict{String,Int64} with 0 entries

length(collection) -> Integer

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

Используйте lastindex, чтобы получить последний допустимый индекс индексируемой коллекции.

Примеры

julia> length(1:5)
5

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

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

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

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

Некоторые наборы следуют несколько другому определению. Например, Set проверяют, равен ли элемент isequal одному из элементов. Dict ищут key=>value пары, а ключ сравнивается с помощью isequal. Чтобы проверить наличие ключа в словаре, используйте haskey или k in keys(dict). Для этих наборов результат всегда Bool и никогда missing.

Примеры

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

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

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

Примеры

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

eltype(type)

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

Примеры

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

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

indexin(a, b)

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

Примеры

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

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

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

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

unique(itr)

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

Примеры

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

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

unique(f, itr)

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

Примеры

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

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 Array{Bool,1}:
 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 Array{Int64,1}:
 1
 3
 4

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

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

unique!(A::AbstractVector)

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

Примеры

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

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

julia> unique!(A)
4-element Array{Int64,1}:
 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 Array{Int64,1}:
  6
  7
 42

allunique(itr) -> Bool

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

Примеры

julia> a = [1; 2; 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> allunique([a, a])
false

reduce(op, itr; [init])

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

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

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

Ассоциативность сокращения зависит от реализации. Это означает, что вы не можете использовать неассоциативные операции, такие как -, потому что не определено, должна ли операция reduce(-,[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

foldl(op, itr; [init])

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

Примеры

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

julia> foldl(=>, 1:4; init=0)
(((0 => 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)

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

Примеры

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

maximum(itr)

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

Примеры

julia> maximum(-20.5:10)
9.5

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

maximum(A::AbstractArray; dims)

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

Примеры

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

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

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

maximum!(r, A)

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

Примеры

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

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

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

minimum(f, itr)

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

Примеры

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

minimum(itr)

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

Примеры

julia> minimum(-20.5:10)
-20.5

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

minimum(A::AbstractArray; dims)

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

Примеры

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

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

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

minimum!(r, A)

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

Примеры

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

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

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

extrema(itr) -> Tuple

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

Примеры

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

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

extrema(f, itr) -> Tuple

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

Примеры

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

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

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

Примеры

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.

argmax(itr) -> Integer

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

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

Примеры

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 рассматривается как больше всех остальных значений.

Примеры

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

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

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

argmin(itr) -> Integer

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

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

Примеры

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 рассматривается как меньше всех остальных значений.

Примеры

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

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

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

findmax(itr) -> (x, index)

Возвращает максимальный элемент коллекции itr и его индекс. Если максимальных элементов несколько, возвращается первый. Если какой-либо элемент данных равен NaN, возвращается этот элемент. Результат согласуется с max.

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

Примеры

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 рассматривается как больше всех остальных значений.

Примеры

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 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)])

findmin(itr) -> (x, index)

Возвращает минимальный элемент коллекции itr и его индекс. Если минимальных элементов несколько, возвращается первый. Если какой-либо элемент данных равен NaN, возвращается этот элемент. Результат согласуется с min.

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

Примеры

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

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

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

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

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

Примеры

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 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)])

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

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

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

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

sum(f, itr)

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

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

Примеры

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)

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

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

Примеры

julia> sum(1:20)
210

sum(A::AbstractArray; dims)

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

Примеры

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

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

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

sum!(r, A)

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

Примеры

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

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

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

prod(f, itr)

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

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

Примеры

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

prod(itr)

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

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

Примеры

julia> prod(1:20)
2432902008176640000

prod(A::AbstractArray; dims)

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

Примеры

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

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

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

prod!(r, A)

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

Примеры

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

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

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

any(itr) -> Bool

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

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

Примеры

julia> a = [true,false,false,true]
4-element Array{Bool,1}:
 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 (короткое замыкание).

Если входные данные содержат значения 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 Array{Bool,2}:
 1  0
 1  0

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

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

all(itr) -> Bool

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

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

Примеры

julia> a = [true,false,false,true]
4-element Array{Bool,1}:
 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 (короткое замыкание).

Если входные данные содержат значения 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 Array{Bool,2}:
 1  0
 1  0

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

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

count(p, itr) -> Integer
count(itr) -> Integer

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

Примеры

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

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

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

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

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

any(p, itr) -> Bool

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

Если входные данные содержат значения 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

all(p, itr) -> Bool

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

Если входные данные содержат значения 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

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

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

Примеры

julia> a = 1:3:7;

julia> foreach(x -> println(x^2), a)
1
16
49

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

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

См. также: mapslices

Примеры

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

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

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

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

Примеры

julia> a = zeros(3);

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

julia> a
3-element Array{Float64,1}:
 2.0
 4.0
 6.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))
Base.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, даже если он пустой.

Примеры

julia> first(2:2:10)
2

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

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, даже если он пустой.

Примеры

julia> last(1:2:10)
9

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

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 , кроме последнего.

Примеры

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 , кроме первого.

Примеры

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

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

step(r)

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

Примеры

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

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

collect(collection)

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

Примеры

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

collect(element_type, collection)

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

Примеры

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

filter(f, a::AbstractArray)

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

Примеры

julia> a = 1:10
1:10

julia> filter(isodd, a)
5-element Array{Int64,1}:
 1
 3
 5
 7
 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> x = [1 2; missing 4]
2×2 Array{Union{Missing, Int64},2}:
 1         2
  missing  4

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

filter!(f, a::AbstractVector)

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

Примеры

julia> filter!(isodd, Vector(1:10))
5-element Array{Int64,1}:
 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!.

Примеры

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

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

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

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

Примеры

julia> replace(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Array{Int64,1}:
 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 Array{Int64,1}:
 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 Array{Int64,1}:
 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

getindex(collection, key...)

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

Примеры

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

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

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

Примеры

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)], соответственно.

Примеры

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}() создаёт хеш-таблицу, использующую идентификатор объекта как хеш и === как равенство с ключами типа K и значениями типа V.

Для получения дополнительной помощи см. Dict.

WeakKeyDict([itr])

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

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

ImmutableDict

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

ImmutableDict(KV::Pair)

Создать новую запись в неизменяемом словаре для пары ключ => значение

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

haskey(collection, key) -> Bool

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

Примеры

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

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

get(collection, key, default)

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

Примеры

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

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

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

get(collection, key, default)

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

Примеры

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

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

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

get(f::Function, collection, key)

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

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

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

get!(collection, key, default)

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

Примеры

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

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

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

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

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

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

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

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

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)
Base.ValueIterator for a Dict{String,Int64} with 2 entries. Values:
  2
  1

julia> values([2])
1-element Array{Int64,1}:
 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 Array{Int64,1}:
 2
 3

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

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

Указание IndexLinear() гарантирует, что i будет целым числом; указание IndexCartesian() гарантирует, что i будет 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)

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

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

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

Примеры

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(combine, d::AbstractDict, others::AbstractDict...)

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

Примеры

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" => 4753.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)

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

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

Обновляет коллекцию парами из других коллекций. Значения с одинаковым ключом будут объединены с использованием функции объединения.

Примеры

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 => 6

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

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

sizehint!(s, n)

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

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([itr])

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

BitSet([itr])

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

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

Создаёт объединение множеств. Сохраняет порядок для массивов.

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

Постройте пересечение множеств. Сохраняйте порядок с массивами.

Примеры

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

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

julia> intersect(Set([1, 2]), BitSet([2, 3]))
Set{Int64} with 1 element:
  2

setdiff(s, itrs...)

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

Примеры

julia> setdiff([1,2,3], [3,4,5])
2-element Array{Int64,1}:
 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, порядок сохраняется. Обратите внимание, что в этом случае важность элементов важна.

Примеры

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

julia> symdiff([1,2,1], [2, 1, 2])
2-element Array{Int64,1}:
 1
 2

julia> symdiff(unique([1,2,1]), unique([2, 1, 2]))
0-element Array{Int64,1}

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.

Примеры

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

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

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

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

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

Примеры

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

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

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

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

Примеры

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

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

issetequal(a, b) -> Bool

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

Примеры

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

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

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

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

Примеры

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

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

pop!(collection) -> item

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

Примеры

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

julia> pop!(A)
3

julia> A
2-element Array{Int64,1}:
 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

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

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

Примеры

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

popfirst!(collection) -> item

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

Примеры

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

julia> popfirst!(A)
1

julia> A
5-element Array{Int64,1}:
 2
 3
 4
 5
 6

insert!(a::Vector, index::Integer, item)

Вставьте item в a на заданный index. index - индекс item в результирующем a.

Примеры

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

deleteat!(a::Vector, i::Integer)

Удалите элемент по заданному i и верните изменённый a. Последующие элементы смещаются для заполнения образовавшейся пустоты.

Примеры

julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
5-element Array{Int64,1}:
 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 Array{Int64,1}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], [true, false, true, false, true, false])
3-element Array{Int64,1}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
ERROR: ArgumentError: indices must be unique and sorted
Stacktrace:
[...]

splice!(a::Vector, index::Integer, [replacement]) -> item

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

Примеры

julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
2

julia> A
5-element Array{Int64,1}:
 6
 5
 4
 3
 1

julia> splice!(A, 5, -1)
1

julia> A
5-element Array{Int64,1}:
  6
  5
  4
  3
 -1

julia> splice!(A, 1, [-1, -2, -3])
6

julia> A
7-element Array{Int64,1}:
 -1
 -2
 -3
  5
  4
  3
 -1

Чтобы вставить replacement перед индексом n без удаления каких-либо элементов, используйте splice!(collection, n:n-1, replacement).

splice!(a::Vector, range, [replacement]) -> items

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

Чтобы вставить replacement перед индексом n без удаления каких-либо элементов, используйте splice!(collection, n:n-1, replacement).

Примеры

julia> A = [-1, -2, -3, 5, 4, 3, -1]; splice!(A, 4:3, 2)
0-element Array{Int64,1}

julia> A
8-element Array{Int64,1}:
 -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 Array{Int64,1}:
 6
 5
 4

julia> a = resize!([6, 5, 4, 3, 2, 1], 8);

julia> length(a)
8

julia> a[1:6]
6-element Array{Int64,1}:
 6
 5
 4
 3
 2
 1

append!(collection, collection2) -> collection.

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

Примеры

julia> append!([1],[2,3])
3-element Array{Int64,1}:
 1
 2
 3

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

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

prepend!(a::Vector, items) -> collection

Вставьте элементы items в начало a.

Примеры

julia> prepend!([3],[1,2])
3-element Array{Int64,1}:
 1
 2
 3

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

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

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