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

Итерация

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

Примеры

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!(f, A::AbstractVector)

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

Примеры

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

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

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

unique!(A::AbstractVector)

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

Примеры

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

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

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

julia> B = [7, 6, 42, 6, 7, 42];

julia> sort!(B);  # unique! is able to process sorted data much more efficiently.

julia> unique!(B)
3-element Array{Int64,1}:
  6
  7
 42

Base.alluniqueФункция

allunique(itr) -> Bool

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

Примеры

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

julia> allunique([a, a])
false

Base.reduceМетод

reduce(op, itr; [init])

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

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

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

Ассоциативность редукции зависит от реализации. Это означает, что вы не можете использовать неассоциативные операции, такие как -, потому что неопределено, должно ли быть вычислено reduce(-,[1,2,3]) как (1-2)-3 или 1-(2-3) . Используйте foldl или foldr вместо этого для гарантированной левой или правой ассоциативности.

Некоторые операции накапливают ошибку. Параллелизм будет проще, если редукцию можно выполнить группами. Будущие версии Julia могут изменить алгоритм. Обратите внимание, что элементы не переупорядочиваются, если вы используете упорядоченную коллекцию.

Примеры

julia> reduce(*, [2; 3; 4])
24

julia> reduce(*, [2; 3; 4]; init=-1)
-24

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> 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(IndexLinear(), A)
pairs(IndexCartesian(), A)
pairs(IndexStyle(A), A)

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

Указание IndexLinear() гарантирует, что i будет целым числом; указание IndexCartesian() гарантирует, что i будет CartesianIndex; указание IndexStyle(A) выбирает тот, который был определен как родной стиль индексирования для массива A.

Изменение границ базового массива сделает этот итератор недействительным.

Примеры

julia> A = ["a" "d"; "b" "e"; "c" "f"];

julia> for (index, value) in pairs(IndexStyle(A), A)
           println("$index $value")
       end
1 a
2 b
3 c
4 d
5 e
6 f

julia> S = view(A, 1:2, :);

julia> for (index, value) in pairs(IndexStyle(S), S)
           println("$index $value")
       end
CartesianIndex(1, 1) a
CartesianIndex(2, 1) b
CartesianIndex(1, 2) d
CartesianIndex(2, 2) e

См. также: IndexStyle, axes.

pairs(collection)

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

Base.mergeФункция

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

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

Примеры

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String,Float64} with 2 entries:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String,Int64} with 2 entries:
  "bar" => 4711
  "baz" => 17

julia> merge(a, b)
Dict{String,Float64} with 3 entries:
  "bar" => 4711.0
  "baz" => 17.0
  "foo" => 0.0

julia> merge(b, a)
Dict{String,Float64} with 3 entries:
  "bar" => 42.0
  "baz" => 17.0
  "foo" => 0.0

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

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

Примеры

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String,Float64} with 2 entries:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String,Int64} with 2 entries:
  "bar" => 4711
  "baz" => 17

julia> merge(+, a, b)
Dict{String,Float64} with 3 entries:
  "bar" => 4753.0
  "baz" => 17.0
  "foo" => 0.0

merge(a::NamedTuple, bs::NamedTuple...)

Создаёт новую именованную кортеж, объединяя два или более существующих, в левоассоциативном порядке. Объединение происходит слева направо, между парами именованных кортежей, и поэтому порядок полей, присутствующих как в левом, так и в правом именованных кортежах, занимает то же положение, что и в левом именованном кортеже. Однако значения берутся из соответствующих полей в правом именованном кортеже, содержащем это поле. Поля, присутствующие только в правом именованном кортеже пары, добавляются в конец. Реализован бэкап для случая, когда предоставлен только один именованный кортеж, с сигнатурой merge(a::NamedTuple).

Примеры

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

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

merge(a::NamedTuple, iterable)

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

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

Base.merge!Метод

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

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

Примеры

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

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

julia> merge!(d1, d2);

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

Base.merge!Метод

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

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

Примеры

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

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

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

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

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

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

Base.sizehint!Функция

sizehint!(s, n)

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

Base.keytypeФункция

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

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