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

Итерация

Последовательная итерация реализуется методами start(), done() и next(). Общий for цикл:

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

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

state = start(I)
while !done(I, state)
    (i, state) = next(I, state)
    # body
end

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

Base.startФункция

start(iter) -> state

Получение начального состояния итерации для объекта итерируемого объекта.

Примеры

julia> start(1:5)
1

julia> start([1;2;3])
1

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

Base.doneФункция

done(iter, state) -> Bool

Проверка, закончена ли итерация.

Примеры

julia> done(1:5, 3)
false

julia> done(1:5, 5)
false

julia> done(1:5, 6)
true

Base.nextФункция

next(iter, state) -> item, state

Для данного итерируемого объекта и состояния итерации возвращает текущий элемент и следующее состояние итерации.

Примеры

julia> next(1:5, 3)
(3, 4)

julia> next(1:5, 5)
(5, 6)

Base.iteratorsizeФункция

iteratorsize(itertype::Type) -> IteratorSize

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

• SizeUnknown() если длина (количество элементов) не может быть определена заранее.

• HasLength() если длина фиксирована и конечна.

• HasShape() если известна длина плюс понятие многомерной формы (как для массива). В этом случае функция size допустима для итератора.

• IsInfinite() если итератор генерирует значения бесконечно.

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

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

julia> Base.iteratorsize(1:5)
Base.HasShape()

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

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

• Range

• UnitRange

• Tuple

• Number

• AbstractArray

• IntSet

• ObjectIdDict

• Dict

• WeakKeyDict

• EachLine

• AbstractString

• Set

Общие сборки

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

Для упорядоченных, индексируемых сборок возвращает максимальный индекс i, для которого getindex(collection, i) допустимо. Для неупорядоченных сборок возвращает количество элементов.

Примеры

julia> length(1:5)
5

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

Base.endofФункция

endof(collection) -> Integer

Возвращает последний индекс сборки.

Пример

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

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

• Range

• UnitRange

• Tuple

• Number

• AbstractArray

• IntSet

• ObjectIdDict

• Dict

• WeakKeyDict

• AbstractString

• Set

Итерируемые сборки

Base.inФункция

in(item, collection) -> Bool
∈(item,collection) -> Bool
∋(collection,item) -> Bool
∉(item,collection) -> Bool
∌(collection,item) -> Bool

Определение, содержится ли элемент в данной сборке в том смысле, что он == одному из значений, генерируемых при итерации по сборке. Для некоторых сборок требуется немного другое определение; например, Set проверяют, соответствует ли элемент isequal одному из элементов. Dict ищут (key,value) пары, и ключ сравнивается с помощью isequal. Для проверки наличия ключа в словаре используйте haskey или k in keys(dict).

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

julia> 4 in a
true

julia> 5 in a
false

Base.eltypeФункция

eltype(type)

Определение типа элементов, генерируемых при итерации по сборке данного type. Для ассоциативных типов сборок это будет Pair{KeyType,ValType}. Определение eltype(x) = eltype(typeof(x)) предоставляется для удобства, так что экземпляры могут быть переданы вместо типов. Однако форма, принимающая аргумент типа, должна быть определена для новых типов.

julia> eltype(ones(Float32,2,2))
Float32

julia> eltype(ones(Int8,2,2))
Int8

Base.indexinФункция

indexin(a, b)

Возвращает вектор, содержащий наибольший индекс в b для каждого значения в a, которое является членом b. Вектор вывода содержит 0, где a не является членом b.

Примеры

julia> a = ['a', 'b', 'c', 'b', 'd', 'a'];

julia> b = ['a','b','c'];

julia> indexin(a,b)
6-element Array{Int64,1}:
 1
 2
 3
 2
 0
 1

julia> indexin(b,a)
3-element Array{Int64,1}:
 6
 4
 3

Base.findinФункция

findin(a, b)

Возвращает индексы элементов в сборке a, которые встречаются в сборке b.

Примеры

julia> a = collect(1:3:15)
5-element Array{Int64,1}:
  1
  4
  7
 10
 13

julia> b = collect(2:4:10)
3-element Array{Int64,1}:
  2
  6
 10

julia> findin(a,b) # 10 is the only common element
1-element Array{Int64,1}:
 4

Base.uniqueФункция

unique(itr)

Возвращает массив, содержащий одно значение из itr для каждого уникального значения, как определено в isequal.

julia> unique([1; 2; 2; 6])
3-element Array{Int64,1}:
 1
 2
 6

unique(f, itr)

Возвращает массив, содержащий одно значение из itr для каждого уникального значения, полученного в результате применения f к элементам itr.

julia> unique(isodd, [1; 2; 2; 6])
2-element Array{Int64,1}:
 1
 2

unique(itr[, dim])

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

julia> A = map(isodd, reshape(collect(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, 2)
2×1×2 Array{Bool,3}:
[:, :, 1] =
  true
 false

[:, :, 2] =
  true
 false

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

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, v0, itr)

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

Для некоторых часто используемых операторов существуют специальные реализации, которые следует использовать вместо стандартных: 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(*, 1, [2; 3; 4])
24

Base.reduceМетод

reduce(op, itr)

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

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

Base.foldlМетод

foldl(op, v0, itr)

Как reduce, но с гарантированной левой ассоциативностью. v0 будет использоваться ровно один раз.

julia> foldl(-, 1, 2:5)
-13

Base.foldlМетод

foldl(op, itr)

Как foldl(op, v0, itr), но используя первый элемент itr в качестве v0. В общем случае это нельзя использовать с пустыми коллекциями (см. reduce(op, itr)).

julia> foldl(-, 2:5)
-10

Base.foldrМетод

foldr(op, v0, itr)

Как reduce, но с гарантированной правой ассоциативностью. v0 будет использоваться ровно один раз.

julia> foldr(-, 1, 2:5)
-1

Base.foldrМетод

foldr(op, itr)

Как foldr(op, v0, itr), но используя последний элемент itr в качестве v0. В общем случае это нельзя использовать с пустыми коллекциями (см. reduce(op, itr)).

julia> foldr(-, 2:5)
-2

Base.maximumМетод

maximum(itr)

Возвращает наибольший элемент в коллекции.

julia> maximum(-20.5:10)
9.5

julia> maximum([1,2,3])
3

Base.maximumМетод

maximum(A, 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, 1)
1×2 Array{Int64,2}:
 3  4

julia> maximum(A, 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

Base.minimumМетод

minimum(A, 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, 1)
1×2 Array{Int64,2}:
 1  2

julia> minimum(A, 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)

Base.extremaМетод

extrema(A, dims) -> Array{Tuple}

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

Пример

julia> A = reshape(collect(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, (1,2))
1×1×2 Array{Tuple{Int64,Int64},3}:
[:, :, 1] =
 (1, 7)

[:, :, 2] =
 (9, 15)

Base.indmaxФункция

indmax(itr) -> Integer

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

Коллекция не должна быть пустой.

Примеры

julia> indmax([8,0.1,-9,pi])
1

julia> indmax([1,7,7,6])
2

julia> indmax([1,7,7,NaN])
2

Base.indminФункция

indmin(itr) -> Integer

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

Коллекция не должна быть пустой.

Примеры

julia> indmin([8,0.1,-9,pi])
3

julia> indmin([7,1,1,6])
2

julia> indmin([7,1,1,NaN])
2

Base.findmaxМетод

findmax(itr) -> (x, index)

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

Коллекция не должна быть пустой.

Примеры

julia> findmax([8,0.1,-9,pi])
(8.0, 1)

julia> findmax([1,7,7,6])
(7, 2)

julia> findmax([1,7,7,NaN])
(7.0, 2)

Base.findmaxМетод

findmax(A, region) -> (maxval, index)

Для массива-входа возвращает значение и индекс максимума в заданной области.

Примеры

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

julia> findmax(A,1)
([3 4], [2 4])

julia> findmax(A,2)
([2; 4], [3; 4])

Base.findminМетод

findmin(itr) -> (x, index)

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

Коллекция не должна быть пустой.

Примеры

julia> findmin([8,0.1,-9,pi])
(-9.0, 3)

julia> findmin([7,1,1,6])
(1, 2)

julia> findmin([7,1,1,NaN])
(1.0, 2)

Base.findminМетод

findmin(A, region) -> (minval, index)

Для входного массива возвращает значение и индекс минимума в заданном регионе.

Примеры

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

julia> findmin(A, 1)
([1 2], [1 3])

julia> findmin(A, 2)
([1; 3], [1; 2])

Base.findmax!Функция

findmax!(rval, rind, A, [init=true]) -> (maxval, index)

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

Base.findmin!Функция

findmin!(rval, rind, A, [init=true]) -> (minval, index)

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

Base.sumФункция

sum(f, itr)

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

julia> sum(abs2, [2; 3; 4])
29

sum(itr)

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

julia> sum(1:20)
210

sum(A, dims)

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

Примеры

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

julia> sum(A, 1)
1×2 Array{Int64,2}:
 4  6

julia> sum(A, 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.

julia> prod(abs2, [2; 3; 4])
576

prod(itr)

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

julia> prod(1:20)
2432902008176640000

prod(A, dims)

Умножение элементов массива по заданным измерениям.

Примеры

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

julia> prod(A, 1)
1×2 Array{Int64,2}:
 3  8

julia> prod(A, 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 (короткое замыкание).

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

Base.anyМетод

any(A, dims)

Проверка, являются ли какие-либо значения по заданным измерениям массива true.

Примеры

julia> A = [true false; true false]
2×2 Array{Bool,2}:
 true  false
 true  false

julia> any(A, 1)
1×2 Array{Bool,2}:
 true  false

julia> any(A, 2)
2×1 Array{Bool,2}:
 true
 true

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 (короткое замыкание).

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

Base.allМетод

all(A, dims)

Проверка, являются ли все значения по заданным измерениям массива true.

Примеры

julia> A = [true false; true true]
2×2 Array{Bool,2}:
 true  false
 true   true

julia> all(A, 1)
1×2 Array{Bool,2}:
 true  false

julia> all(A, 2)
2×1 Array{Bool,2}:
 false
  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 (короткое замыкание).

julia> any(i->(4<=i<=6), [3,5,7])
true

julia> any(i -> (println(i); i > 3), 1:10)
1
2
3
4
true

Base.allМетод

all(p, itr) -> Bool

Определение, возвращает ли предикат p значение true для всех элементов itr, возвращая false как только будет встречен первый элемент в itr, для которого p возвращает false (короткое замыкание).

julia> all(i->(4<=i<=6), [4,5,6])
true

julia> all(i -> (println(i); i < 3), 1:10)
1
2
3
false

Base.foreachФункция

foreach(f, c...) -> Void

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

Примеры

julia> map(x -> x * 2, [1, 2, 3])
3-element Array{Int64,1}:
 2
 4
 6

julia> map(+, [1, 2, 3], [10, 20, 30])
3-element Array{Int64,1}:
 11
 22
 33

map(f, x::Nullable)

Возвращает f, применённое к значению x, если оно есть, как Nullable. Если x равно null, то возвращает значение null типа Nullable{S}. S гарантированно является либо Union{}, либо конкретным типом. Выбор между ними — деталь реализации, но обычно выбирается вариант, максимизирующий производительность. Если x имеет значение, то тип возвращаемого значения гарантированно будет типа Nullable{typeof(f(x))}.

Base.map!Функция

map!(function, destination, collection...)

Аналогично map, но результат сохраняется в destination вместо создания новой коллекции. destination должна быть не меньше, чем первая коллекция.

Пример

julia> x = zeros(3);

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

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

Base.mapreduceМетод

mapreduce(f, op, v0, itr)

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

mapreduce функционально эквивалентна вызову reduce(op, v0, map(f, itr)), но, как правило, выполняется быстрее, так как не нужно создавать промежуточную коллекцию. См. документацию по reduce и map.

julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
14

Ассоциативность сворачивания зависит от реализации. Кроме того, некоторые реализации могут повторно использовать возвращаемое значение f для элементов, которые появляются несколько раз в itr. Используйте mapfoldl или mapfoldr для гарантированной левой или правой ассоциативности и вызова f для каждого значения.

Base.mapreduceМетод

mapreduce(f, op, itr)

Аналогично mapreduce(f, op, v0, itr). В общем случае это нельзя использовать с пустыми коллекциями (см. reduce(op, itr)).

Base.mapfoldlМетод

mapfoldl(f, op, v0, itr)

Аналогично mapreduce, но с гарантированной левой ассоциативностью, как в foldl. v0 будет использовано ровно один раз.

Base.mapfoldlМетод

mapfoldl(f, op, itr)

Аналогично mapfoldl(f, op, v0, itr), но с использованием первого элемента itr как v0. В общем случае это нельзя использовать с пустыми коллекциями (см. reduce(op, itr)).

Base.mapfoldrМетод

mapfoldr(f, op, v0, itr)

Аналогично mapreduce, но с гарантированной правой ассоциативностью, как в foldr. v0 будет использовано ровно один раз.

Base.mapfoldrМетод

mapfoldr(f, op, itr)

Аналогично mapfoldr(f, op, v0, itr), но с использованием первого элемента itr как v0. В общем случае это нельзя использовать с пустыми коллекциями (см. reduce(op, itr)).

Base.firstФункция

first(coll)

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

julia> first(2:2:10)
2

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

Base.lastФункция

last(coll)

Получить последний элемент упорядоченной коллекции, если его можно вычислить за O(1) времени. Это достигается вызовом endof для получения последнего индекса. Возвращает конечную точку Range даже если она пустая.

julia> last(1:2:10)
9

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

Base.stepФункция

step(r)

Получить шаг размера объекта Range.

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

julia> step(linspace(2.5,10.9,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.issubsetМетод

issubset(a, b)
⊆(a,b) -> Bool
⊈(a,b) -> Bool
⊊(a,b) -> Bool

Определите, является ли каждый элемент a также элементом b, используя in.

Примеры

julia> issubset([1, 2], [1, 2, 3])
true

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

Base.filterФункция

filter(function, collection)

Возвращает копию collection, удаляя элементы, для которых function является false. Для ассоциативных коллекций функция получает два аргумента (ключ и значение).

Примеры

julia> a = 1:10
1:10

julia> filter(isodd, a)
5-element Array{Int64,1}:
 1
 3
 5
 7
 9

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

julia> filter((x,y)->isodd(x), d)
Dict{Int64,String} with 1 entry:
  1 => "a"

filter(p, x::Nullable)

Возвращает null, если либо x равно null, либо p(get(x)) ложно, и x в противном случае.

Base.filter!Функция

filter!(function, collection)

Обновляет collection, удаляя элементы, для которых function является false. Для ассоциативных коллекций функция получает два аргумента (ключ и значение).

Пример

julia> filter!(isodd, collect(1:10))
5-element Array{Int64,1}:
 1
 3
 5
 7
 9

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

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

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

• Array

• BitArray

• AbstractArray

• SubArray

• ObjectIdDict

• Dict

• WeakKeyDict

• AbstractString

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

• Range

• UnitRange

• Tuple

Связанные коллекции

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

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

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

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.

При передаче единственного итерируемого аргумента, создаётся 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.ObjectIdDictТип

ObjectIdDict([itr])

ObjectIdDict() создает хеш-таблицу, где ключи всегда являются идентификаторами объектов. В отличие от Dict он не параметризуется по типу ключа и значению, поэтому его eltype всегда Pair{Any,Any}.

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

Base.WeakKeyDictТип

WeakKeyDict([itr])

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

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

Base.haskeyФункция

haskey(collection, key) -> Bool

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

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

julia> haskey(a,'a')
true

julia> haskey(a,'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(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> a = Dict('a'=>2, 'b'=>3)
Dict{Char,Int64} with 2 entries:
  'b' => 3
  'a' => 2

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

julia> getkey(a,'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:
 [1] pop!(::Dict{String,Int64}, ::String) at ./dict.jl:539

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

Base.keysФункция

keys(a::Associative)

Возвращает итератор по всем ключам в коллекции. collect(keys(a)) возвращает массив ключей. Поскольку ключи хранятся во внутренней хеш-таблице, порядок их возврата может изменяться. Но keys(a) и values(a) оба итерируют a и возвращают элементы в том же порядке.

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

julia> collect(keys(a))
2-element Array{Char,1}:
 'b'
 'a'

Base.valuesФункция

values(a::Associative)

Возвращает итератор по всем значениям в коллекции. collect(values(a)) возвращает массив значений. Поскольку значения хранятся во внутренней хеш-таблице, порядок их возврата может изменяться. Но keys(a) и values(a) оба итерируют a и возвращают элементы в том же порядке.

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

julia> collect(values(a))
2-element Array{Int64,1}:
 3
 2

Base.mergeФункция

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

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

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::Associative, others::Associative...)

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

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

Base.merge!Функция

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

Обновляет коллекцию парами из других коллекций. См. также 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

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

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

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

Слияние изменений в текущую ветку

Внутренняя реализация слияния. Возвращает true если слияние прошло успешно, в противном случае false

merge!(repo::GitRepo; kwargs...) -> Bool

Выполнить слияние git в репозитории repo, объединив коммиты с расходящейся историей в текущую ветку. Возвращает true если слияние прошло успешно, false если нет.

Ключевые аргументы:

• committish::AbstractString="": Объединить указанные коммиты в committish.

• branch::AbstractString="": Объединить ветку branch и все её коммиты с момента расхождения с текущей веткой.

• fastforward::Bool=false: Если fastforward равно true, объединить только если слияние является быстрым (голова текущей ветки является предком коммитов, которые необходимо слить), иначе отказаться от слияния и вернуть false. Это эквивалентно опции командной строки git --ff-only.

• merge_opts::MergeOptions=MergeOptions(): checkout_opts задаёт параметры слияния, такие как стратегия слияния в случае конфликтов.

• checkout_opts::CheckoutOptions=CheckoutOptions(): checkout_opts задаёт параметры для шага проверки состояния.

Эквивалентно git merge [--ff-only] [<committish> | <branch>].

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

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

• ObjectIdDict

• Dict

• WeakKeyDict

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

• IntSet

• Set

• EnvHash

• Array

• BitArray

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

Base.SetТип

Set([itr])

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

Base.IntSetТип

IntSet([itr])

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

Base.unionФункция

union(s1,s2...)
∪(s1,s2...)

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

Примеры

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

Base.union!Функция

union!(s, iterable)

Объединить каждый элемент iterable в множество s на месте.

Base.intersectФункция

intersect(s1,s2...)
∩(s1,s2)

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

Base.setdiffФункция

setdiff(a, b)

Создать множество элементов в a но не в b. Сохраняет порядок с массивами. Обратите внимание, что оба аргумента должны быть коллекциями, и оба будут перебираться. В частности, setdiff(set,element) где element является потенциальным членом set, не будет работать в общем случае.

Пример

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

Base.setdiff!Функция

setdiff!(s, iterable)

Удалить каждый элемент iterable из множества s на месте.

Base.symdiffФункция

symdiff(a, b, rest...)

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

Пример

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

Base.symdiff!Метод

symdiff!(s, n)

Множество s изменяется на месте, чтобы переключить включение целого числа n.

Base.symdiff!Метод

symdiff!(s, itr)

Для каждого элемента в itr, переключить включение в множество s на месте.

Base.symdiff!Метод

symdiff!(s, itr)

Для каждого элемента в itr, переключить включение в множество s на месте.

Base.intersect!Функция

intersect!(s1::IntSet, s2::IntSet)

Пересечь множества s1 и s2 и перезаписать множество s1 результатом. При необходимости s1 будет расширено до размера s2.

Base.issubsetФункция

issubset(A, S) -> Bool
⊆(A,S) -> Bool

Возвращает true если A является подмножеством или равно S.

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

• IntSet

• 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 и вернуть его.

Примеры

julia> A=[1, 2, 3, 4, 5, 6]
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

julia> pop!(A)
6

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

Base.unshift!Функция

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

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

Пример

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

Base.shift!Функция

shift!(collection) -> item

Удалить первый item из collection.

Пример

julia> A = [1, 2, 3, 4, 5, 6]
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

julia> shift!(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:
 [1] _deleteat!(::Array{Int64,1}, ::Tuple{Int64,Int64}) at ./array.jl:926
 [2] deleteat!(::Array{Int64,1}, ::Tuple{Int64,Int64}) at ./array.jl:913

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)