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

Итерация

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

for i in iter   # or  "for i = iter"
    # body
end

переводится в:

next = iterate(iter)
while next !== nothing
    (i, state) = next
    # body
    next = iterate(iter, state)
end

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

Base.iterateФункция

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

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

Base.IteratorSizeТип

IteratorSize(itertype::Type) -> IteratorSize

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

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

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

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

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

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

Base.IteratorEltypeТип

IteratorEltype(itertype::Type) -> IteratorEltype

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

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

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

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

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

Полностью реализовано:

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

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

Base.AbstractRangeТип

AbstractRange{T}

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

Base.OrdinalRangeТип

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

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

Base.AbstractUnitRangeТип

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

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

Base.StepRangeТип

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

Диапазоны с элементами типа T с шагом типа S. Шаг между каждым элементом постоянен, и диапазон определяется начальным start и конечным stop типа T и шагом типа 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}

Base.UnitRangeТип

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}

Base.LinRangeТип

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

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

Base.isemptyФункция

isempty(collection) -> Bool

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

Примеры

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

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

Base.empty!Функция

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

Base.lengthФункция

length(collection) -> Integer

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

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

Примеры

julia> length(1:5)
5

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

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

Полностью реализовано:

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

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

Base.inФункция

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

Base.:∉Функция

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

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

Примеры

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

Base.eltypeФункция

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

Base.indexinФункция

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

Base.uniqueФункция

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

Base.unique!Функция

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

Base.alluniqueФункция

allunique(itr) -> Bool

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

Примеры

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

julia> allunique([a, a])
false

Base.reduceМетод

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

Base.foldlМетод

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

Base.foldrМетод

foldr(op, itr; [init])

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

Примеры

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

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

Base.maximumФункция

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

Base.maximum!Функция

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

Base.minimumФункция

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

Base.minimum!Функция

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

Base.extremaФункция

extrema(itr) -> Tuple

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

Примеры

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

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

extrema(f, itr) -> Tuple

Вычислите минимальное и максимальное значение f, применённое к каждому элементу в itr, и верните их как 2-кортеж. Только один проход по 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.

Base.argmaxФункция

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)

Base.argminФункция

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)

Base.findmaxФункция

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

Base.findminФункция

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

Base.findmax!Функция

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

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

Base.findmin!Функция

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

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

Base.sumФункция

sum(f, itr)

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

Тип возвращаемого значения — 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

Base.sum!Функция

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

Base.prodФункция

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

Base.prod!Функция

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

Base.anyМетод

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

Base.anyМетод

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

Base.any!Функция

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

Base.allМетод

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

Base.allМетод

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

Base.all!Функция

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

Base.countФункция

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

Base.anyМетод

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

Base.allМетод

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

Base.foreachФункция

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

Base.mapФункция

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

Base.map!Функция

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, то он будет преобразован в тип ключа, если это возможно, а в противном случае произойдёт ошибка.

Примеры

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

julia> map!(v -> v-1, values(d)) Dict{Symbol,Int64} с 2 записями: :a => 0 :b => 1 ```

Base.mapreduceМетод

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 для каждого значения.

Base.mapfoldlМетод

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

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

Base.mapfoldrМетод

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

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

Base.firstФункция

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

Base.lastФункция

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"

Base.frontФункция

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.

Base.tailФункция

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.

Base.stepФункция

step(r)

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

Примеры

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

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

Base.collectМетод

collect(collection)

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

Примеры

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

Base.collectМетод

collect(element_type, collection)

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

Примеры

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

Base.filterФункция

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

Base.filter!Функция

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"

Base.replaceМетод

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

Base.replaceМетод

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

Base.replace!Функция

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([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([6, 12])

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

Base.getindexФункция

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

Base.setindex!Функция

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

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

Base.firstindexФункция

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

Base.lastindexФункция

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

Полностью реализовано:

• Array
• BitArray
• AbstractArray
• SubArray

Частично реализовано:

• AbstractRange
• UnitRange
• Tuple
• AbstractString
• Dict
• IdDict
• WeakKeyDict
• NamedTuple

Словари

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

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

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

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

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

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

Base.AbstractDictТип

AbstractDict{K, V}

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

Base.DictТип

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

Base.IdDictТип

IdDict([itr])

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

См. Dict для дополнительной информации.

Base.WeakKeyDictТип

WeakKeyDict([itr])

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

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

Base.ImmutableDictТип

ImmutableDict

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

ImmutableDict(KV::Pair)

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

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

Base.haskeyФункция

haskey(collection, key) -> Bool

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

Примеры

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

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

Base.getМетод

get(collection, key, default)

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

Примеры

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

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

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

Base.getФункция

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

Base.get!Метод

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

Base.get!Метод

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

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

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

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

Base.getkeyФункция

getkey(collection, key, default)

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

Примеры

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

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

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

Base.delete!Функция

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

Base.pop!Метод

pop!(collection, key[, default])

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

Примеры

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

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

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

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

Base.keysФункция

keys(iterator)

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

Base.valuesФункция

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

Base.pairsФункция

pairs(collection)

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

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.

Base.mergeФункция

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)

Base.merge!Метод

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

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

Примеры

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

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

julia> merge!(d1, d2);

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

Base.merge!Метод

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

Base.sizehint!Функция

sizehint!(s, n)

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

Base.keytypeФункция

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

Base.valtypeФункция

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

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

Примеры

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

valtype(type)

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

Примеры

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

Полностью реализовано в:

• IdDict
• Dict
• WeakKeyDict

Частично реализовано в:

• BitSet
• Set
• EnvDict
• Array
• BitArray
• ImmutableDict
• Iterators.Pairs

Коллекции-множества

Base.AbstractSetТип

AbstractSet{T}

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

Base.SetТип

Set([itr])

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

Base.BitSetТип

BitSet([itr])

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

Base.unionФункция

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([2, 3, 1])

Base.union!Функция

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

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

Примеры

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

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

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

Base.intersectФункция

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

Base.setdiffФункция

setdiff(s, itrs...)

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

Примеры

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

Base.setdiff!Функция

setdiff!(s, itrs...)

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

Примеры

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

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

julia> a
Set([4])

Base.symdiffФункция

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]))
0-element Array{Int64,1}

Base.symdiff!Функция

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

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

Base.intersect!Функция

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

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

Base.issubsetФункция

issubset(a, b)
⊆(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

Base.:⊈Функция

⊈(a, b)
⊉(b, a)

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

Примеры

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

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

Base.:⊊Функция

⊊(a, b)
⊋(b, a)

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

Примеры

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

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

Base.issetequalФункция

issetequal(a, b)

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

Примеры

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

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

Полностью реализовано в:

• BitSet
• Set

Частично реализовано:

• Array

Очереди с двусторонним доступом (Dequeues)

Base.push!Функция

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

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

Примеры

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

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

Base.pop!Функция

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([2, 1])

julia> pop!(S)
2

julia> S
Set([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

Base.pushfirst!Функция

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

Base.popfirst!Функция

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

Base.insert!Функция

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

Base.deleteat!Функция

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

Base.splice!Функция

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

Base.resize!Функция

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

Base.append!Функция

append!(collection, collection2) -> collection.

Добавляет элементы collection2 в конец collection.

Примеры

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

Base.prepend!Функция

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

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

Примеры

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

Полностью реализовано:

• Vector (также известен как одномерный Array)
• BitVector (также известен как одномерный BitArray)

Дополнительные коллекции

Base.PairТип

Pair(x, y)
x => y

Создаёт объект Pair с типом Pair{typeof(x), typeof(y)}. Элементы хранятся в полях first и second. К ним также можно получить доступ с помощью итерации.

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

Base.Iterators.PairsТип

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

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