Сборники и структуры данных

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

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

IteratorSize(itertype::Type) -> IteratorSize

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

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

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

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

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

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

IteratorEltype(itertype::Type) -> IteratorEltype

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

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

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

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

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

AbstractRange{T}

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

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

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

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

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

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

Диапазоны с элементами типа T с шагом типа S. Шаг между каждым элементом постоянен, и диапазон определяется в терминах start и stop типа T и step типа S. Ни T , ни S не должны быть типами с плавающей точкой. Синтаксис a:b:c с b > 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}

Диапазон, параметризованный start и stop типа 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 линейно размещенными элементами между его start и stop. Размер шага определяется 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

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

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

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

isempty(collection) -> Bool

Определить, является ли сборник пустым (не имеет элементов).

Примеры

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

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

empty!(collection) -> collection

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

Примеры

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

julia> empty!(A);

julia> A
Dict{String,Int64}()

length(collection) -> Integer

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

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

Примеры

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.

Чтобы определить, не содержится ли элемент в данной коллекции, см. :∉. Вы также можете инвертировать значение in с помощью !(a in b), что логически аналогично "не содержится в".

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

Примеры

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

julia> 4 in a
true

julia> 5 in a
false

julia> missing in [1, 2]
missing

julia> 1 in [2, missing]
missing

julia> 1 in [1, missing]
true

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

julia> !(21 in a)
true

julia> !(19 in a)
false

julia> [1, 2] .∈ [2, 3]
2-element BitArray{1}:
 0
 0

julia> [1, 2] .∈ ([2, 3],)
2-element BitArray{1}:
 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 BitArray{1}:
 1
 1

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

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

Уменьшите заданный набор itr с помощью заданного бинарного оператора op. Если указано начальное значение 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, совпадающие последовательности могут перекрывать индексы в исходной строке, в противном случае они должны быть из непересекающихся диапазонов символов.

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

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

Примеры

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

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

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

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)

Вернуть копию коллекции 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)

Обновить коллекцию 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)

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

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

haskey(collection, key) -> Bool

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

Примеры

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

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

get(collection, key, default)

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

sizehint!(s, n)

Предложить коллекции s зарезервировать память для не менее 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 не является массивом, порядок сохраняется. Обратите внимание, что в этом случае важна кратность элементов.

Примеры

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

Примеры

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

isdisjoint(v1, v2) -> Bool

Возвращает, являются ли коллекции v1 и v2 непересекающимися, т.е. пусто ли их пересечение.

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

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

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

Примеры

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

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

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

julia> popat!(a, 4)
ERROR: BoundsError: attempt to access 3-element Array{Int64,1} at index [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, indices, [replacement]) -> items

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

Чтобы вставить 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 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)}

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