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

Итерация

Последовательная итерация реализуется функцией 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}}

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

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

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] =
  true   true
 false  false

[:, :, 2] =
  true   true
 false  false

julia> unique(A)
2-element Array{Bool,1}:
  true
 false

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

[:, :, 2] =
  true
 false

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

Base.unique!Функция

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

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

Примеры

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

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

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)

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 для каждого элемента 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

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}:
  true
 false
 false
  true

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}:
 true  false
 true  false

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}:
  true
 false
 false
  true

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}:
 true  false
 true  false

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> x = zeros(3);

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

julia> x
3-element Array{Float64,1}:
 2.0
 4.0
 6.0

Base.mapreduceМетод

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

Применить функцию f к каждому элементу в itr, а затем выполнить операцию reduce над результатом с использованием бинарной функции 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

Ассоциативность операции reduce зависит от реализации. Кроме того, некоторые реализации могут повторно использовать возвращаемое значение 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.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"

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.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, b::NamedTuple)

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

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

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

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

Примеры

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

Base.valtypeФункция

valtype(type)

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

Примеры

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

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

• IdDict
• Dict
• WeakKeyDict

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

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

Коллекции, похожие на множества

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

Примеры

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

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

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

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

Очереди с двойным концом

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

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