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

Итерация

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

Примеры

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

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

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

Base.UnitRangeТип

UnitRange{T<:Real}

Диапазон, параметризованный start и stop типа T, заполненный элементами, отстоящими на 1 от start до тех пор, пока не будет превышен stop. Синтаксис a:b с a и b оба Integer создают UnitRange.

Примеры

julia> collect(UnitRange(2.3, 5.2))
3-element Array{Float64,1}:
 2.3
 3.3
 4.3

julia> typeof(1:10)
UnitRange{Int64}

Base.LinRangeТип

LinRange{T}

Диапазон с len линейно расположенными элементами между его start и stop. Размер шага контролируется len, который должен быть Int.

Примеры

julia> LinRange(1.5, 5.5, 9)
9-element LinRange{Float64}:
 1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0,5.5

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

Base.isemptyФункция

isempty(collection) -> Bool

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

Примеры

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

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

Base.empty!Функция

empty!(collection) -> collection

Удаляет все элементы из collection.

Примеры

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

julia> empty!(A);

julia> A
Dict{String,Int64} with 0 entries

Base.lengthФункция

length(collection) -> Integer

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

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

Примеры

julia> length(1:5)
5

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

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

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

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

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

Base.inФункция

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

Определить, содержится ли элемент в заданном множестве, в смысле, что он == одному из значений, сгенерированных при итерации по множеству. Возвращает значение Bool, за исключением случаев, когда item является missing или collection содержит missing, но не item, в этом случае возвращается missing (трёхзначная логика, соответствующая поведению any и ==).

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

Примеры

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

julia> 4 in a
true

julia> 5 in a
false

julia> missing in [1, 2]
missing

julia> 1 in [2, missing]
missing

julia> 1 in [1, missing]
true

julia> missing in Set([1, 2])
false

Base.:∉Функция

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

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

Примеры

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

Base.eltypeФункция

eltype(type)

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

Примеры

julia> eltype(fill(1f0, (2,2)))
Float32

julia> eltype(fill(0x1, (2,2)))
UInt8

Base.indexinФункция

indexin(a, b)

Возвращает массив, содержащий первый индекс в b для каждого значения в a, которое является членом b. Массив вывода содержит nothing в тех местах, где a не является членом b.

Примеры

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

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

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

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

Base.uniqueФункция

unique(itr)

Возвращает массив, содержащий только уникальные элементы коллекции itr, определённые по isequal, в порядке, в котором они впервые появляются. Тип элементов входных данных сохраняется.

Примеры

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

julia> unique(Real[1, 1.0, 2])
2-element Array{Real,1}:
 1
 2

unique(f, itr)

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

Примеры

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

unique(A::AbstractArray; dims::Int)

Возвращает уникальные области A по размерности dims.

Примеры

julia> A = map(isodd, reshape(Vector(1:8), (2,2,2)))
2×2×2 Array{Bool,3}:
[:, :, 1] =
 1  1
 0  0

[:, :, 2] =
 1  1
 0  0

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

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

[:, :, 2] =
 1
 0

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

Base.unique!Функция

unique!(f, A::AbstractVector)

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

Примеры

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

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

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

unique!(A::AbstractVector)

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

Примеры

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

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

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

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

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

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

Base.alluniqueФункция

allunique(itr) -> Bool

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

Примеры

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

julia> allunique([a, a])
false

Base.reduceМетод

reduce(op, itr; [init])

Свести данную коллекцию 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(f, itr)

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

Примеры

julia> maximum(length, ["Julion", "Julia", "Jule"])
6

maximum(itr)

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

Примеры

julia> maximum(-20.5:10)
9.5

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

maximum(A::AbstractArray; dims)

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

Примеры

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

julia> maximum(A, dims=1)
1×2 Array{Int64,2}:
 3  4

julia> maximum(A, dims=2)
2×1 Array{Int64,2}:
 2
 4

Base.maximum!Функция

maximum!(r, A)

Вычислите максимальное значение A по одиночным измерениям r, и запишите результаты в r.

Примеры

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

julia> maximum!([1; 1], A)
2-element Array{Int64,1}:
 2
 4

julia> maximum!([1 1], A)
1×2 Array{Int64,2}:
 3  4

Base.minimumФункция

minimum(f, itr)

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

Примеры

julia> minimum(length, ["Julion", "Julia", "Jule"])
4

minimum(itr)

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

Примеры

julia> minimum(-20.5:10)
-20.5

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

minimum(A::AbstractArray; dims)

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

Примеры

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

julia> minimum(A, dims=1)
1×2 Array{Int64,2}:
 1  2

julia> minimum(A, dims=2)
2×1 Array{Int64,2}:
 1
 3

Base.minimum!Функция

minimum!(r, A)

Вычислите минимальное значение A по одиночным измерениям r, и запишите результаты в r.

Примеры

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

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

julia> minimum!([1 1], A)
1×2 Array{Int64,2}:
 1  2

Base.extremaФункция

extrema(itr) -> Tuple

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

Примеры

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

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

extrema(f, itr) -> Tuple

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

Примеры

julia> extrema(sin, 0:π)
(0.0, 0.9092974268256817)

extrema(A::AbstractArray; dims) -> Array{Tuple}

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

Примеры

julia> A = reshape(Vector(1:2:16), (2,2,2))
2×2×2 Array{Int64,3}:
[:, :, 1] =
 1  5
 3  7

[:, :, 2] =
  9  13
 11  15

julia> extrema(A, dims = (1,2))
1×1×2 Array{Tuple{Int64,Int64},3}:
[:, :, 1] =
 (1, 7)

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

extrema(f, A::AbstractArray; dims) -> Array{Tuple}

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

Base.argmaxФункция

argmax(itr) -> Integer

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

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

Примеры

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

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

julia> argmax([1,7,7,NaN])
4

argmax(A; dims) -> indices

Для массива-входа возвращает индексы максимальных элементов по заданным измерениям. NaN рассматривается как большее всех остальных значений.

Примеры

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 1.0  2.0
 3.0  4.0

julia> argmax(A, dims=1)
1×2 Array{CartesianIndex{2},2}:
 CartesianIndex(2, 1)  CartesianIndex(2, 2)

julia> argmax(A, dims=2)
2×1 Array{CartesianIndex{2},2}:
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

Base.argminФункция

argmin(itr) -> Integer

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

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

Примеры

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

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

julia> argmin([7,1,1,NaN])
4

argmin(A; dims) -> indices

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

Примеры

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 1.0  2.0
 3.0  4.0

julia> argmin(A, dims=1)
1×2 Array{CartesianIndex{2},2}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)

julia> argmin(A, dims=2)
2×1 Array{CartesianIndex{2},2}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)

Base.findmaxФункция

findmax(itr) -> (x, index)

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

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

Примеры

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

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

julia> findmax([1,7,7,NaN])
(NaN, 4)

findmax(A; dims) -> (maxval, index)

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

Примеры

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 1.0  2.0
 3.0  4.0

julia> findmax(A, dims=1)
([3.0 4.0], CartesianIndex{2}[CartesianIndex(2, 1) CartesianIndex(2, 2)])

julia> findmax(A, dims=2)
([2.0; 4.0], CartesianIndex{2}[CartesianIndex(1, 2); CartesianIndex(2, 2)])

Base.findminФункция

findmin(itr) -> (x, index)

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

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

Примеры

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

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

julia> findmin([7,1,1,NaN])
(NaN, 4)

findmin(A; dims) -> (minval, index)

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

Примеры

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 1.0  2.0
 3.0  4.0

julia> findmin(A, dims=1)
([1.0 2.0], CartesianIndex{2}[CartesianIndex(1, 1) CartesianIndex(1, 2)])

julia> findmin(A, dims=2)
([1.0; 3.0], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 1)])

Base.findmax!Функция

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

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

Base.findmin!Функция

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

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

Base.sumФункция

sum(f, itr)

Суммирует результаты вызова функции f для каждого элемента 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}:
 1
 0
 0
 1

julia> any(a)
true

julia> any((println(i); v) for (i, v) in enumerate(a))
1
true

julia> any([missing, true])
true

julia> any([false, missing])
missing

Base.anyМетод

any(p, itr) -> Bool

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

Если вход содержит значения missing, возвращает missing если все значения, отличные от пропущенных, являются false (или, что эквивалентно, если вход не содержит true значение), следуя принципу трёхзначной логики.

Примеры

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

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

julia> any(i -> i > 0, [1, missing])
true

julia> any(i -> i > 0, [-1, missing])
missing

julia> any(i -> i > 0, [-1, 0])
false

Base.any!Функция

any!(r, A)

Проверяет, содержатся ли среди значений A по единственным измерениям r значения true, и записывает результаты в r.

Примеры

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

julia> any!([1; 1], A)
2-element Array{Int64,1}:
 1
 1

julia> any!([1 1], A)
1×2 Array{Int64,2}:
 1  0

Base.allМетод

all(itr) -> Bool

Проверяет, являются ли все элементы булевой коллекции true, возвращая false как только встречается первое false значение в itr (короткое замыкание).

Если вход содержит значения missing, возвращает missing если все значения, отличные от пропущенных, являются true (или, что эквивалентно, если вход не содержит false значение), следуя принципу трёхзначной логики.

Примеры

julia> a = [true,false,false,true]
4-element Array{Bool,1}:
 1
 0
 0
 1

julia> all(a)
false

julia> all((println(i); v) for (i, v) in enumerate(a))
1
2
false

julia> all([missing, false])
false

julia> all([true, missing])
missing

Base.allМетод

all(p, itr) -> Bool

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

Если вход содержит значения missing, возвращает missing если все значения, отличные от пропущенных, являются true (или, что эквивалентно, если вход не содержит false значение), следуя принципу трёхзначной логики.

Примеры

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

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

julia> all(i -> i > 0, [1, missing])
missing

julia> all(i -> i > 0, [-1, missing])
false

julia> all(i -> i > 0, [1, 2])
true

Base.all!Функция

all!(r, A)

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

Примеры

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

julia> all!([1; 1], A)
2-element Array{Int64,1}:
 0
 0

julia> all!([1 1], A)
1×2 Array{Int64,2}:
 1  0

Base.countФункция

count(p, itr) -> Integer
count(itr) -> Integer

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

Примеры

julia> count(i->(4<=i<=6), [2,3,4,5,6])
3

julia> count([true, false, true, true])
3

count(
    pattern::Union{AbstractString,Regex},
    string::AbstractString;
    overlap::Bool = false,
)

Возвращает количество совпадений для pattern в string. Это эквивалентно вызову length(findall(pattern, string)), но более эффективно.

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

Base.anyМетод

any(p, itr) -> Bool

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

Если вход содержит значения missing, возвращает missing если все значения, отличные от пропущенных, являются false (или, что эквивалентно, если вход не содержит true значение), следуя принципу трёхзначной логики.

Примеры

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

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

julia> any(i -> i > 0, [1, missing])
true

julia> any(i -> i > 0, [-1, missing])
missing

julia> any(i -> i > 0, [-1, 0])
false

Base.allМетод

all(p, itr) -> Bool

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

Если вход содержит значения missing, возвращает missing если все значения, отличные от пропущенных, являются true (или, что эквивалентно, если вход не содержит false значение), следуя принципу трёхзначной логики.

Примеры

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

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

julia> all(i -> i > 0, [1, missing])
missing

julia> all(i -> i > 0, [-1, missing])
false

julia> all(i -> i > 0, [1, 2])
true

Base.foreachФункция

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

Вызывает функцию f для каждого элемента итерируемого объекта c. Для нескольких итерируемых аргументов f вызывается поэлементно. foreach следует использовать вместо map, когда результаты f не нужны, например, в foreach(println, array).

Примеры

julia> a = 1:3:7;

julia> foreach(x -> println(x^2), a)
1
16
49

Base.mapФункция

map(f, c...) -> collection

Преобразует коллекцию c путём применения f к каждому элементу. Для нескольких аргументов-коллекций применяйте f поэлементно.

См. также: mapslices

Примеры

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

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

Base.map!Функция

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

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

Примеры

julia> a = zeros(3);

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

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

map!(f, values(dict::AbstractDict))

Изменяет dict путем преобразования каждого значения из val в f(val). Обратите внимание, что тип dict изменить нельзя: если f(val) не является экземпляром типа ключа dict, то он будет преобразован в тип ключа, если это возможно, а в противном случае произойдёт ошибка.

Примеры

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

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

Base.mapreduceМетод

mapreduce(f, op, itrs...; [init])

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

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

Примеры

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

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

Base.mapfoldlМетод

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

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

Base.mapfoldrМетод

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

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

Base.firstФункция

first(coll)

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

Примеры

julia> first(2:2:10)
2

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

first(s::AbstractString, n::Integer)

Получить строку, состоящую из первых n символов s.

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

Base.lastФункция

last(coll)

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

Примеры

julia> last(1:2:10)
9

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

last(s::AbstractString, n::Integer)

Получить строку, состоящую из последних n символов s.

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

Base.frontФункция

front(x::Tuple)::Tuple

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

Примеры

julia> Base.front((1,2,3))
(1, 2)

julia> Base.front(())
ERROR: ArgumentError: Cannot call front on an empty tuple.

Base.tailФункция

tail(x::Tuple)::Tuple

Возвращает Tuple, состоящую из всех компонентов x кроме первого.

Примеры

julia> Base.tail((1,2,3))
(2, 3)

julia> Base.tail(())
ERROR: ArgumentError: Cannot call tail on an empty tuple.

Base.stepФункция

step(r)

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

Примеры

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

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

Base.collectМетод

collect(collection)

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

Примеры

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

Base.collectМетод

collect(element_type, collection)

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

Примеры

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

Base.filterФункция

filter(f, a::AbstractArray)

Возвращает копию a, удаляя элементы, для которых f равно false. Функция f получает один аргумент.

Примеры

julia> a = 1:10
1:10

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

filter(f, d::AbstractDict)

Возвращает копию d, удаляя элементы, для которых f равно false. Функция f получает пары key=>value.

Примеры

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

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

filter(f, itr::SkipMissing{<:AbstractArray})

Возвращает вектор, похожий на массив, обернутый заданным SkipMissing итератором, но с удалением всех отсутствующих элементов и тех, для которых f возвращает false.

Примеры

julia> x = [1 2; missing 4]
2×2 Array{Union{Missing, Int64},2}:
 1         2
  missing  4

julia> filter(isodd, skipmissing(x))
1-element Array{Int64,1}:
 1

Base.filter!Функция

filter!(f, a::AbstractVector)

Обновляет a, удаляя элементы, для которых f равно false. Функция f получает один аргумент.

Примеры

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

filter!(f, d::AbstractDict)

Обновить d, удаляя элементы, для которых f является false. Функция f получает key=>value пары.

Пример

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

julia> filter!(p->isodd(p.first), d)
Dict{Int64,String} with 2 entries:
  3 => "c"
  1 => "a"

Base.replaceМетод

replace(A, old_new::Pair...; [count::Integer])

Возвращает копию коллекции A, в которой для каждой пары old=>new в old_new, все вхождения old заменяются на new. Равенство определяется с помощью isequal. Если count указано, то заменяется не более count вхождений в общей сложности.

Тип элементов результата выбирается с использованием повышения (см. promote_type) на основе типа элементов A и типов значений new в парах. Если count опущено, а тип элементов A является Union, тип элементов результата не будет включать одиночные типы, которые заменяются значениями другого типа: например, Union{T,Missing} станет T, если missing заменится.

См. также replace!.

Примеры

julia> replace([1, 2, 1, 3], 1=>0, 2=>4, count=2)
4-element Array{Int64,1}:
 0
 4
 1
 3

julia> replace([1, missing], missing=>0)
2-element Array{Int64,1}:
 1
 0

Base.replaceМетод

replace(new::Function, A; [count::Integer])

Возвращает копию A, где каждое значение x в A заменяется на new(x). Если count указано, то заменяется не более count значений в общей сложности (замены определены как new(x) !== x).

Примеры

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

julia> replace(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64,Int64} with 2 entries:
  3 => 4
  1 => 3

Base.replace!Функция

replace!(A, old_new::Pair...; [count::Integer])

Для каждой пары old=>new в old_new, заменить все вхождения old в коллекции A на new. Равенство определяется с помощью isequal. Если count указано, то заменяется не более count вхождений в общей сложности. См. также replace.

Примеры

julia> replace!([1, 2, 1, 3], 1=>0, 2=>4, count=2)
4-element Array{Int64,1}:
 0
 4
 1
 3

julia> replace!(Set([1, 2, 3]), 1=>0)
Set([0, 2, 3])

replace!(new::Function, A; [count::Integer])

Заменить каждый элемент x в коллекции A на new(x). Если count указано, то заменяется не более count значений в общей сложности (замены определяются как new(x) !== x).

Примеры

julia> replace!(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Array{Int64,1}:
 2
 2
 6
 4

julia> replace!(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64,Int64} with 2 entries:
  3 => 4
  1 => 3

julia> replace!(x->2x, Set([3, 6]))
Set([6, 12])

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

Base.getindexФункция

getindex(collection, key...)

Получить сохраненное значение(я) по заданному ключу или индексу в коллекции. Синтаксис a[i,j,...] компилятором преобразуется в getindex(a, i, j, ...).

Примеры

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

julia> getindex(A, "a")
1

Base.setindex!Функция

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

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

Base.firstindexФункция

firstindex(collection) -> Integer
firstindex(collection, d) -> Integer

Возвращает первый индекс collection. Если d задано, возвращает первый индекс collection по размерности d.

Примеры

julia> firstindex([1,2,4])
1

julia> firstindex(rand(3,4,5), 2)
1

Base.lastindexФункция

lastindex(collection) -> Integer
lastindex(collection, d) -> Integer

Возвращает последний индекс collection. Если d задано, возвращает последний индекс collection по размерности d.

Синтаксисы A[end] и A[end, end] сводятся к A[lastindex(A)] и A[lastindex(A, 1), lastindex(A, 2)], соответственно.

Примеры

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

julia> lastindex(rand(3,4,5), 2)
4

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

• Array
• BitArray
• AbstractArray
• SubArray

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

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

Словари

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

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

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

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

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

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

Base.AbstractDictТип

AbstractDict{K, V}

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

Base.DictТип

Dict([itr])

Dict{K,V}() строит хеш-таблицу с ключами типа K и значениями типа V. Ключи сравниваются с помощью isequal и хешируются с помощью hash.

При задании единственного итерируемого аргумента создает Dict, пары ключ-значение которого берутся из 2-кортежей (key,value) , сгенерированных аргументом.

Примеры

julia> Dict([("A", 1), ("B", 2)])
Dict{String,Int64} with 2 entries:
  "B" => 2
  "A" => 1

В качестве альтернативы можно передать последовательность аргументов-пар.

julia> Dict("A"=>1, "B"=>2)
Dict{String,Int64} with 2 entries:
  "B" => 2
  "A" => 1

Base.IdDictТип

IdDict([itr])

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

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

Base.WeakKeyDictТип

WeakKeyDict([itr])

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

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

Base.ImmutableDictТип

ImmutableDict

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

ImmutableDict(KV::Pair)

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

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

Base.haskeyФункция

haskey(collection, key) -> Bool

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

Примеры

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

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

Base.getМетод

get(collection, key, default)

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

Примеры

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

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

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

Base.getФункция

get(collection, key, default)

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

Примеры

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

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

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

get(f::Function, collection, key)

Возвращает значение, сохраненное для данного ключа, или, если отображение для ключа отсутствует, возвращает f(). Используйте get!, чтобы также сохранить значение по умолчанию в словаре.

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

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

Base.get!Метод

get!(collection, key, default)

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

Примеры

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

julia> get!(d, "a", 5)
1

julia> get!(d, "d", 4)
4

julia> d
Dict{String,Int64} with 4 entries:
  "c" => 3
  "b" => 2
  "a" => 1
  "d" => 4

Base.get!Метод

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

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

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

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

Base.getkeyФункция

getkey(collection, key, default)

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

Примеры

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

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

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

Base.delete!Функция

delete!(collection, key)

Удаляет отображение для данного ключа в коллекции и возвращает коллекцию.

Примеры

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

julia> delete!(d, "b")
Dict{String,Int64} with 1 entry:
  "a" => 1

Base.pop!Метод

pop!(collection, key[, default])

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

Примеры

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

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

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

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

Base.keysФункция

keys(iterator)

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

Base.valuesФункция

values(iterator)

Для итератора или коллекции, имеющей ключи и значения, возвращает итератор по значениям. По умолчанию эта функция просто возвращает свой аргумент, так как элементы общего итератора обычно считаются его «значениями».

Примеры

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

julia> values(d)
Base.ValueIterator for a Dict{String,Int64} with 2 entries. Values:
  2
  1

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

values(a::AbstractDict)

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

Примеры

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

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

Base.pairsФункция

pairs(collection)

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

pairs(IndexLinear(), A)
pairs(IndexCartesian(), A)
pairs(IndexStyle(A), A)

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

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

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

Примеры

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

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

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

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

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

Base.mergeФункция

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

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

merge(a::NamedTuple, iterable)

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

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

Base.merge!Метод

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

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

Примеры

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

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

julia> merge!(d1, d2);

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

Base.merge!Метод

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

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

Примеры

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

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

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

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

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

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

Base.sizehint!Функция

sizehint!(s, n)

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

Base.keytypeФункция

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

Возвращает тип ключа массива. Он равен eltype результата keys(...), и предоставляется в основном для совместимости с интерфейсом словаря.

Примеры

julia> keytype([1, 2, 3]) == Int
true

julia> keytype([1 2; 3 4])
CartesianIndex{2}

keytype(type)

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

Примеры

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

Base.valtypeФункция

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

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

Примеры

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

valtype(type)

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

Примеры

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

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

• IdDict
• Dict
• WeakKeyDict

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

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

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

Base.AbstractSetТип

AbstractSet{T}

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

Base.SetТип

Set([itr])

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

Base.BitSetТип

BitSet([itr])

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

Base.unionФункция

union(s, itrs...)
∪(s, itrs...)

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

Примеры

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

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

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

julia> union(Set([1, 2]), 2:3)
Set([2, 3, 1])

Base.union!Функция

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

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

Примеры

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

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

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

Base.intersectФункция

intersect(s, itrs...)
∩(s, itrs...)

Построить пересечение множеств. Сохранять порядок с массивами.

Примеры

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

julia> intersect([1, 4, 4, 5, 6], [4, 6, 6, 7, 8])
2-element Array{Int64,1}:
 4
 6

julia> intersect(Set([1, 2]), BitSet([2, 3]))
Set([2])

Base.setdiffФункция

setdiff(s, itrs...)

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

Примеры

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

Base.setdiff!Функция

setdiff!(s, itrs...)

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

Примеры

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

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

julia> a
Set([4])

Base.symdiffФункция

symdiff(s, itrs...)

Построить симметрическую разность элементов в переданных множествах. Когда s не является 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) -> Bool
⊆(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) -> Bool
⊉(b, a) -> Bool

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

Примеры

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

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

Base.:⊊Функция

⊊(a, b) -> Bool
⊋(b, a) -> Bool

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

Примеры

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

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

Base.issetequalФункция

issetequal(a, b) -> Bool

Определите, содержат ли 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> A = [-1, -2, -3, 5, 4, 3, -1]; 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. Также к ним можно получить доступ через итерацию (но Pair рассматривается как один «скаляр» для операций трансляции).

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

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