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

Итерация

Последовательная итерация реализована функцией 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 и типом step. Ни T, ни S не должны быть типами с плавающей точкой. Синтаксис a:b:c с b > 1 и a, b, и c в виде целых чисел создаёт диапазон StepRange.

Примеры

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

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

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

Base.UnitRangeТип

UnitRange{T<:Real}

Диапазон, параметризованный начальным и конечным значением типа start и stop, заполненный элементами, отстоящими друг от друга на 1 от start до stop. Синтаксис a:b с a и b в виде целых чисел создаёт диапазон 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.

Примеры

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

Определить, содержится ли элемент в данной коллекции в том смысле, что он == одному из значений, полученных при итерации по коллекции. Возвращает логическое значение, за исключением случаев, когда 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 если все значения, не являющиеся 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> 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

Base.mapreduceМетод

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

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

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