Документация Engee

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

Итерация

Последовательная итерация реализуется с помощью функции iterate. Общий цикл for:

for i in iter   # или "for i = iter"
    # тело
end

преобразовывается в

next = iterate(iter)
while next !== nothing
    (i, state) = next
    # тело
    next = iterate(iter, state)
end

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

iterate(iter [, state]) -> Union{Nothing, Tuple{Any, Any}}

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

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()
IteratorEltype(itertype::Type) -> IteratorEltype

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

  • EltypeUnknown(), если тип элементов, выдаваемых итератором, заранее неизвестен;

  • HasEltype(), если тип элемента известен и eltype возвращает значимое значение.

HasEltype() используется по умолчанию, поскольку итераторы предположительно реализуют eltype.

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

julia> Base.IteratorEltype(1:5)
Base.HasEltype()

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

Конструкторы и типы

AbstractRange{T} <: AbstractVector{T}

Супертип для линейных диапазонов, содержащих элементы типа T. UnitRange, LinRange и другие типы являются подтипами этого типа.

Для всех подтипов должна быть определена функция step. Поэтому LogRange не является подтипом AbstractRange.

OrdinalRange{T, S} <: AbstractRange{T}

Супертип для порядковых диапазонов, содержащих элементы типа T с пространствами типа S. Шаги всегда должны быть кратными oneunit, а T должен быть «дискретным» типом, который не может содержать значения меньше oneunit. Например, типы Integer или Date соответствуют этим требованиям, а Float64 не соответствует (поскольку этот тип может представлять значения меньше oneunit(Float64)). UnitRange, StepRange и другие типы являются подтипами этого типа.

AbstractUnitRange{T} <: OrdinalRange{T, T}

Супертип для диапазонов с размером шага oneunit(T), содержащий элементы типа T. UnitRange и другие типы являются подтипами этого типа.

StepRange{T, S} <: OrdinalRange{T, S}

Супертип, содержащий элементы типа T с пространством типа S. Шаг между элементами является константой, а диапазон определяется в контексте start и stop типа T и step типа S. Ни T, ни S не должны принадлежать к типам с плавающей запятой. Синтаксис a:b:c с b != 0 и целочисленными алгоритмами a, b и c создает StepRange.

Примеры

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

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

julia> typeof(1:3:6)
StepRange{Int64, Int64}
UnitRange{T<:Real}

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

Примеры

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

julia> typeof(1:10)
UnitRange{Int64}
LinRange{T,L}

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

Примеры

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

В сравнении с range при прямом построении LinRange накладные расходы будут ниже, но ошибки с плавающей запятой не исправляются.

julia> collect(range(-0.1, 0.3, length=5))
5-element Vector{Float64}:
 -0.1
  0.0
  0.1
  0.2
  0.3

julia> collect(LinRange(-0.1, 0.3, 5))
5-element Vector{Float64}:
 -0.1
 -1.3877787807814457e-17
  0.09999999999999999
  0.19999999999999998
  0.3

Кроме того, см. описание функции Logrange для точек с логарифмическими интервалами.

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

isempty(collection) -> Bool

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

isempty(itr) может использовать следующий элемент итератора с сохранением состояния itr, если не определен соответствующий Base.isdone(itr) метод. Итераторы с сохранением состояния должны реализовывать isdone, но может быть желательно избегать использования isempty при написании универсального кода, который должен поддерживать любой тип итератора.

Примеры

julia> isempty([])
true

julia> isempty([1 2 3])
false
isempty(condition)

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

isdone(itr, [state]) -> Union{Bool, Missing}

Эта функция предоставляет указание быстрого пути для завершения итератора. Это полезно для итераторов с сохранением состояния, элементы которых не должны использоваться, если они не будут доступны пользователю (например, при проверке готовности в isempty или zip).

Для итераторов с сохранением состояния, которым требуется эта возможность, должен быть определен метод isdone, который возвращает значение true или false в зависимости от того, завершен ли итератор. Для итераторов без сохранения состояния реализовывать эту функцию не требуется.

Если результатом является missing, вызывающая сторона может продолжить выполнение и вычислить iterate(x, state) === nothing, чтобы получить определенный ответ.

См. также описание iterate, isempty.

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}()
empty!(c::Channel)

Очищает канал c, вызывая empty! для внутреннего буфера. Возвращает пустой канал.

length(collection) -> Integer

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

Используйте lastindex для получения последнего допустимого индекса индексируемой коллекции.

См. также описание size, ndims, eachindex.

Примеры

julia> length(1:5)
5

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

julia> length([1 2; 3 4])
4
Base.checked_length(r)

Вычисляет length(r), но может при необходимости проверять ошибки переполнения, если результат не помещается в Union{Integer(eltype(r)),Int}.

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

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

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

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

Для некоторых коллекций используется немного другое определение. Например, Set проверяет, равен ли (isequal) элемент одному из элементов. Dict выполняет поиск пар key=>value и сопоставляет ключ (key), используя isequal.

Чтобы проверить наличие ключа в словаре, используйте haskey или k in keys(dict). Для приведенных выше коллекций результатом всегда является Bool.

В случае трансляции с помощью in.(items, collection) или items .∈ collection транслируются как item, так и collection, хотя зачастую такой результат нежелателен. Например, если оба аргумента представляют собой векторы (и размеры совпадают), результат представляет собой вектор, указывающий, включено ли каждое из значений в коллекции items in значение в соответствующей позиции в collection. Чтобы получить вектор, указывающий для каждого из значений в items, входит ли оно в collection, заключите collection в кортеж или Ref следующим образом: in.(items, Ref(collection)) или items .∈ Ref(collection).

См. также описание ∉, insorted, contains, occursin, issubset.

Примеры

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

julia> (1=>missing) in Dict(1=>10, 2=>20)
missing

julia> [1, 2] .∈ [2, 3]
2-element BitVector:
 0
 0

julia> [1, 2] .∈ ([2, 3],)
2-element BitVector:
 0
 1
∉(item, collection) -> Bool
∌(collection, item) -> Bool

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

В случае трансляции с помощью items .∉ collection транслируются как item, так и collection, хотя зачастую такой результат нежелателен. Например, если оба аргумента представляют собой векторы (и размеры совпадают), результат представляет собой вектор, указывающий для каждого из значений в коллекции items, что оно не входит в значение в соответствующей позиции в collection. Чтобы получить вектор, указывающий, что каждое из значений в items не входит в collection, заключите collection в кортеж или Ref следующим образом: items .∉ Ref(collection).

Примеры

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

julia> [1, 2] .∉ [2, 3]
2-element BitVector:
 1
 1

julia> [1, 2] .∉ ([2, 3],)
2-element BitVector:
 1
 0
Base.hasfastin(T)

Определяет для вычисления x ∈ collection, где collection::T можно считать «быстрой» операцией (обычно с константной или логарифмической сложностью). Для удобства принято, что hasfastin(x) = hasfastin(typeof(x)), чтобы вместо типов можно было передавать экземпляры. Однако для новых типов необходимо определить форму, которая принимает аргумент типа.

Значением по умолчанию для hasfastin(T) является true для подтипов AbstractSet, AbstractDict и AbstractRange и false в противном случае.

eltype(type)

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

См. также описание keytype, typeof.

Примеры

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

julia> eltype(fill(0x1, (2,2)))
UInt8
indexin(a, b)

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

См. также описание sortperm, findfirst.

Примеры

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

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

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

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

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

См. также описание unique!, allunique, allequal.

Примеры

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

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

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

Примеры

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

Эту функцию также можно использовать для получения индексов первых вхождений уникальных элементов в массиве:

julia> a = [3.1, 4.2, 5.3, 3.1, 3.1, 3.1, 4.2, 1.7];

julia> i = unique(i -> a[i], eachindex(a))
4-element Vector{Int64}:
 1
 2
 3
 8

julia> a[i]
4-element Vector{Float64}:
 3.1
 4.2
 5.3
 1.7

julia> a[i] == unique(a)
true
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 Vector{Bool}:
 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
unique!(f, A::AbstractVector)

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

Совместимость: Julia 1.1

Этот метод впервые реализован в Julia 1.1.

Примеры

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

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

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

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

Примеры

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

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

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

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

julia> sort!(B);  # unique! может обрабатывать отсортированные данные гораздо эффективнее.

julia> unique!(B)
3-element Vector{Int64}:
  6
  7
 42
allunique(itr) -> Bool
allunique(f, itr) -> Bool

Возвращает true, если все значения из itr четко различимы при сравнении с isequal либо если различимы все [f(x) for x in itr] в случае со вторым методом.

Обратите внимание, что allunique(f, itr) может вызывать f меньше, чем length(itr) раз. Точное количество вызовов зависит от реализации.

Если входные данные отсортированы, allunique может использовать специальную реализацию.

См. также описание unique, issorted, allequal.

Совместимость: Julia 1.11

Для метода allunique(f, itr) требуется версия Julia не ниже 1.11.

Примеры

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

julia> allunique([1, 2, 1, 2])
false

julia> allunique(Real[1, 1.0, 2])
false

julia> allunique([NaN, 2.0, NaN, 4.0])
false

julia> allunique(abs, [1, -1, 2])
false
allequal(itr) -> Bool
allequal(f, itr) -> Bool

Возвращает true, если все значения из itr равны при сравнении с помощью isequal либо если равны все [f(x) for x in itr] в случае со вторым методом.

Обратите внимание, что allequal(f, itr) может вызывать f меньше, чем length(itr) раз. Точное количество вызовов зависит от реализации.

См. также описание unique, allunique.

Совместимость: Julia 1.8

Для функции allequal требуется версия Julia не ниже 1.8.
Совместимость: Julia 1.11

Для метода allequal(f, itr) требуется версия Julia не ниже 1.11.

Примеры

julia> allequal([])
true

julia> allequal([1])
true

julia> allequal([1, 1])
true

julia> allequal([1, 2])
false

julia> allequal(Dict(:a => 1, :b => 1))
false

julia> allequal(abs2, [1, -1])
true
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(``vcat, arr) или reduce(``hcat, arr).

Ассоциативность операции приведения к более простому виду не зависит от реализации. Это означает, что нельзя использовать неассоциативные операции, такие как -, поскольку не определено, следует ли вычислять 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
reduce(f, A::AbstractArray; dims=:, [init])

Сокращает функцию f с двумя аргументами по измерениям A. dims — это вектор, указывающий сокращаемые измерения, а именованный аргумент init представляет собой начальное значение для использования в сокращениях. Для +, *, max и min аргумент init является необязательным.

Ассоциативность приведения к более простому виду зависит от реализации. Если нужна конкретная ассоциативность, например слева направо, следует написать свой собственный цикл или рассмотреть возможность использования foldl или foldr. См. документацию по reduce.

Примеры

julia> a = reshape(Vector(1:16), (4,4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> reduce(max, a, dims=2)
4×1 Matrix{Int64}:
 13
 14
 15
 16

julia> reduce(max, a, dims=1)
1×4 Matrix{Int64}:
 4  8  12  16
foldl(op, itr; [init])

Аналогично reduce, но с гарантированной ассоциативностью слева направо. Если указан именованный аргумент init, он будет использоваться ровно один раз. Как правило, для работы с пустыми коллекциями необходимо указывать init.

См. также описание mapfoldl, foldr и accumulate.

Примеры

julia> foldl(=>, 1:4)
((1 => 2) => 3) => 4

julia> foldl(=>, 1:4; init=0)
(((0 => 1) => 2) => 3) => 4

julia> accumulate(=>, (1,2,3,4))
(1, 1 => 2, (1 => 2) => 3, ((1 => 2) => 3) => 4)
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)))
maximum(f, itr; [init])

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

Значение, возвращаемое для пустого itr, можно указать в init. Это должен быть нейтральный элемент для max (то есть элемент, который меньше любого другого элемента или равен ему), поскольку не указано, используется ли init для непустых коллекций.

Совместимость: Julia 1.6

Для именованного аргумента init требуется версия Julia не ниже 1.6.

Примеры

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

julia> maximum(length, []; init=-1)
-1

julia> maximum(sin, Real[]; init=-1.0)  # хороший, поскольку вывод sin >= –1
-1.0
maximum(itr; [init])

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

Значение, возвращаемое для пустого itr, можно указать в init. Это должен быть нейтральный элемент для max (то есть элемент, который меньше любого другого элемента или равен ему), поскольку не указано, используется ли init для непустых коллекций.

Совместимость: Julia 1.6

Для именованного аргумента init требуется версия Julia не ниже 1.6.

Примеры

julia> maximum(-20.5:10)
9.5

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

julia> maximum(())
ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

julia> maximum((); init=-Inf)
-Inf
maximum(A::AbstractArray; dims)

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

См. также описание maximum!, extrema, findmax, argmax.

Примеры

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

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

julia> maximum(A, dims=2)
2×1 Matrix{Int64}:
 2
 4
maximum(f, A::AbstractArray; dims)

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

Примеры

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

julia> maximum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 9  16

julia> maximum(abs2, A, dims=2)
2×1 Matrix{Int64}:
  4
 16
maximum!(r, A)

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

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

Примеры

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

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

julia> maximum!([1 1], A)
1×2 Matrix{Int64}:
 3  4
minimum(f, itr; [init])

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

Значение, возвращаемое для пустого itr, можно указать в init. Это должен быть нейтральный элемент для min (то есть элемент, который больше любого другого элемента или равен ему), поскольку не указано, используется ли init для непустых коллекций.

Совместимость: Julia 1.6

Для именованного аргумента init требуется версия Julia не ниже 1.6.

Примеры

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

julia> minimum(length, []; init=typemax(Int64))
9223372036854775807

julia> minimum(sin, Real[]; init=1.0)  # хороший, поскольку вывод sin <= 1
1.0
minimum(itr; [init])

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

Значение, возвращаемое для пустого itr, можно указать в init. Это должен быть нейтральный элемент для min (то есть элемент, который больше любого другого элемента или равен ему), поскольку не указано, используется ли init для непустых коллекций.

Совместимость: Julia 1.6

Для именованного аргумента init требуется версия Julia не ниже 1.6.

Примеры

julia> minimum(-20.5:10)
-20.5

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

julia> minimum([])
ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

julia> minimum([]; init=Inf)
Inf
minimum(A::AbstractArray; dims)

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

См. также описание minimum!, extrema, findmin, argmin.

Примеры

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

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

julia> minimum(A, dims=2)
2×1 Matrix{Int64}:
 1
 3
minimum(f, A::AbstractArray; dims)

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

Примеры

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

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

julia> minimum(abs2, A, dims=2)
2×1 Matrix{Int64}:
 1
 9
minimum!(r, A)

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

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

Примеры

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

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

julia> minimum!([1 1], A)
1×2 Matrix{Int64}:
 1  2
extrema(itr; [init]) -> (mn, mx)

За один проход вычисляет как минимальный (mn), так и максимальный (mx) элементы, возвращая их как двухэлементный кортеж.

Значение, возвращаемое для пустого itr, можно указать в init. Это должен быть двухэлементный кортеж, в котором первый и второй элементы являются нейтральными для min и max соответственно (то есть больше/меньше или равны любому другому элементу). Как следствие, если itr является пустым, возвращаемый кортеж (mn, mx) соответствует условию mn ≥ mx. Если аргумент init задан, его можно использовать даже для непустых itr.

Совместимость: Julia 1.8

Для именованного аргумента init требуется версия Julia не ниже 1.8.

Примеры

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

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

julia> extrema([]; init = (Inf, -Inf))
(Inf, -Inf)
extrema(f, itr; [init]) -> (mn, mx)

Вычисляет как минимальный (mn), так и максимальный (mx) результат применения функции f к каждому элементу в itr и возвращает их как двухэлементный кортеж. Выполняет только один проход по itr.

Значение, возвращаемое для пустого itr, можно указать в init. Это должен быть двухэлементный кортеж, в котором первый и второй элементы являются нейтральными для min и max соответственно (то есть больше/меньше или равны любому другому элементу). Используется для непустых коллекций. Примечание. Предполагается, что для пустых itr возвращаемое значение (mn, mx) соответствует условию mn ≥ mx, даже притом что для непустых itr оно соответствует условию mn ≤ mx. Это «парадоксальный», однако ожидаемый результат.

Совместимость: Julia 1.2

Для этого метода требуется версия Julia не ниже 1.2.
Совместимость: Julia 1.8

Для именованного аргумента init требуется версия Julia не ниже 1.8.

Примеры

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

julia> extrema(sin, Real[]; init = (1.0, -1.0))  # хороший, поскольку –1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)
extrema(A::AbstractArray; dims) -> Array{Tuple}

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

См. также описание minimum, maximum, extrema!.

Примеры

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.

Совместимость: Julia 1.2

Для этого метода требуется версия Julia не ниже 1.2.

 
extrema!(r, A)

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

Если какой-либо измененный аргумент размещается в одной области памяти с любым другим аргументом, поведение может быть непредвиденным.
Совместимость: Julia 1.8

Для этого метода требуется версия Julia не ниже 1.8.

Примеры

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

julia> extrema!([(1, 1); (1, 1)], A)
2-element Vector{Tuple{Int64, Int64}}:
 (1, 2)
 (3, 4)

julia> extrema!([(1, 1);; (1, 1)], A)
1×2 Matrix{Tuple{Int64, Int64}}:
 (1, 3)  (2, 4)
argmax(r::AbstractRange)

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

argmax(f, domain)

Возвращает значение x из domain, для которого максимизируется f(x). Если доступно несколько максимальных значений для f(x), то будет найдено первое значение.

domain должно быть непустой итерируемой коллекцией.

Значения сравниваются с помощью isless.

Совместимость: Julia 1.7

Для этого метода требуется версия Julia не ниже 1.7.

См. также описание argmin и findmax.

Примеры

julia> argmax(abs, -10:5)
-10

julia> argmax(cos, 0:π/2:2π)
0.0
argmax(itr)

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

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

Индексы имеют тот же тип, что и индексы, возвращаемые методами keys(itr) и pairs(itr).

Значения сравниваются с помощью isless.

См. также описание argmin, findmax.

Примеры

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 обрабатывается как большее, чем все остальные значения, кроме missing.

Примеры

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

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

julia> argmax(A, dims=2)
2×1 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)
argmin(r::AbstractRange)

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

argmin(f, domain)

Возвращает значение x из domain, для которого f(x) минимизируется. Если доступно несколько минимальных значений для f(x), то будет найдено первое значение.

domain должно быть непустой итерируемой коллекцией.

Значение NaN обрабатывается как меньшее, чем все остальные значения, кроме missing.

Совместимость: Julia 1.7

Для этого метода требуется версия Julia не ниже 1.7.

См. также описание argmax и findmin.

Примеры

julia> argmin(sign, -10:5)
-10

julia> argmin(x -> -x^3 + x^2 - 10, -5:5)
5

julia> argmin(acos, 0:0.1:1)
1.0
argmin(itr)

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

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

Индексы имеют тот же тип, что и индексы, возвращаемые методами keys(itr) и pairs(itr).

Значение NaN обрабатывается как меньшее, чем все остальные значения, кроме missing.

См. также описание argmax, findmin.

Примеры

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 обрабатывается как меньшее, чем все остальные значения, кроме missing.

Примеры

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

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

julia> argmin(A, dims=2)
2×1 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)
findmax(f, domain) -> (f(x), index)

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

domain должно быть непустой итерируемой коллекцией, поддерживающей keys. Индексы имеют тот же тип, что и индексы, возвращаемые методом keys(domain).

Значения сравниваются с помощью isless.

Совместимость: Julia 1.7

Для этого метода требуется версия Julia не ниже 1.7.

Примеры

julia> findmax(identity, 5:9)
(9, 5)

julia> findmax(-, 1:10)
(-1, 1)

julia> findmax(first, [(1, :a), (3, :b), (3, :c)])
(3, 2)

julia> findmax(cos, 0:π/2:2π)
(1.0, 1)
findmax(itr) -> (x, index)

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

Индексы имеют тот же тип, что и индексы, возвращаемые методами keys(itr) и pairs(itr).

См. также описание findmin, argmax, maximum.

Примеры

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 обрабатывается как большее, чем все остальные значения, кроме missing.

Примеры

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 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);;])
findmax(f, A; dims) -> (f(x), index)

Для входных данных массива возвращает значение в области значений, при котором f максимизируется по указанным измерениям, и его индекс.

Примеры

julia> A = [-1.0 1; -0.5 2]
2×2 Matrix{Float64}:
 -1.0  1.0
 -0.5  2.0

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

julia> findmax(abs2, A, dims=2)
([1.0; 4.0;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 2);;])
findmin(f, domain) -> (f(x), index)

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

domain должно быть непустой итерируемой коллекцией.

Индексы имеют тот же тип, что и индексы, возвращаемые методами keys(domain) и pairs(domain).

Значение NaN обрабатывается как меньшее, чем все остальные значения, кроме missing.

Совместимость: Julia 1.7

Для этого метода требуется версия Julia не ниже 1.7.

Примеры

julia> findmin(identity, 5:9)
(5, 1)

julia> findmin(-, 1:10)
(-10, 10)

julia> findmin(first, [(2, :a), (2, :b), (3, :c)])
(2, 1)

julia> findmin(cos, 0:π/2:2π)
(-1.0, 3)
findmin(itr) -> (x, index)

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

Индексы имеют тот же тип, что и индексы, возвращаемые методами keys(itr) и pairs(itr).

См. также описание findmax, argmin, minimum.

Примеры

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

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

julia> findmin([1, 7, 7, NaN])
(NaN, 4)
findmin(A; dims) -> (minval, index)

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

Примеры

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 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);;])
findmin(f, A; dims) -> (f(x), index)

Для входных данных массива возвращает значение в области значений, при котором f минимизируется по указанным измерениям, и его индекс.

Примеры

julia> A = [-1.0 1; -0.5 2]
2×2 Matrix{Float64}:
 -1.0  1.0
 -0.5  2.0

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

julia> findmin(abs2, A, dims=2)
([1.0; 0.25;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 1);;])
findmax!(rval, rind, A) -> (maxval, index)

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

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

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

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

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

 
sum(f, itr; [init])

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

Для целых чисел со знаком меньше размера системного слова возвращается тип Int, а для целых чисел без знака меньше размера системного слова — тип UInt. Для остальных аргументов находится общий возвращаемый тип, до которого продвигаются все аргументы.

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

Совместимость: Julia 1.6

Для именованного аргумента init требуется версия Julia не ниже 1.6.

Примеры

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

Обратите внимание на важное отличие sum(A) от reduce(+, A) для массивов с небольшим целочисленным типом eltype.

julia> sum(Int8[100, 28])
128

julia> reduce(+, Int8[100, 28])
-128

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

sum(itr; [init])

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

Для целых чисел со знаком меньше размера системного слова возвращается тип Int, а для целых чисел без знака меньше размера системного слова — тип UInt. Для остальных аргументов находится общий возвращаемый тип, до которого продвигаются все аргументы.

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

Совместимость: Julia 1.6

Для именованного аргумента init требуется версия Julia не ниже 1.6.

См. также описание reduce, mapreduce, count, union.

Примеры

julia> sum(1:20)
210

julia> sum(1:20; init = 0.0)
210.0
sum(A::AbstractArray; dims)

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

Примеры

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

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

julia> sum(A, dims=2)
2×1 Matrix{Int64}:
 3
 7
sum(f, A::AbstractArray; dims)

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

Примеры

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

julia> sum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 10  20

julia> sum(abs2, A, dims=2)
2×1 Matrix{Int64}:
  5
 25
sum!(r, A)

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

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

Примеры

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

julia> sum!([1; 1], A)
2-element Vector{Int64}:
 3
 7

julia> sum!([1 1], A)
1×2 Matrix{Int64}:
 4  6
prod(f, itr; [init])

Возвращает произведение f и каждого элемента itr.

Для целых чисел со знаком меньше размера системного слова возвращается тип Int, а для целых чисел без знака меньше размера системного слова — тип UInt. Для остальных аргументов находится общий возвращаемый тип, до которого продвигаются все аргументы.

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

Совместимость: Julia 1.6

Для именованного аргумента init требуется версия Julia не ниже 1.6.

Примеры

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

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

Для целых чисел со знаком меньше размера системного слова возвращается тип Int, а для целых чисел без знака меньше размера системного слова — тип UInt. Для остальных аргументов находится общий возвращаемый тип, до которого продвигаются все аргументы.

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

Совместимость: Julia 1.6

Для именованного аргумента init требуется версия Julia не ниже 1.6.

См. также описание reduce, cumprod, any.

Примеры

julia> prod(1:5)
120

julia> prod(1:5; init = 1.0)
120.0
prod(A::AbstractArray; dims)

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

Примеры

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

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

julia> prod(A, dims=2)
2×1 Matrix{Int64}:
  2
 12
prod(f, A::AbstractArray; dims)

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

Примеры

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

julia> prod(abs2, A, dims=1)
1×2 Matrix{Int64}:
 9  64

julia> prod(abs2, A, dims=2)
2×1 Matrix{Int64}:
   4
 144
prod!(r, A)

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

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

Примеры

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

julia> prod!([1; 1], A)
2-element Vector{Int64}:
  2
 12

julia> prod!([1 1], A)
1×2 Matrix{Int64}:
 3  8
any(itr) -> Bool

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

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

См. также описание all, count, sum, [|](math.md#Base.:

), [||](math.md#

).

Примеры

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 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
any(p, itr) -> Bool

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

Если входные данные содержат значения 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
any!(r, A)

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

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

Примеры

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

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

julia> any!([1 1], A)
1×2 Matrix{Int64}:
 1  0
all(itr) -> Bool

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

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

См. также описание all!, any, count, &, &&, allunique.

Примеры

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 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
all(p, itr) -> Bool

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

Если входные данные содержат значения 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
all!(r, A)

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

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

Примеры

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

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

julia> all!([1 1], A)
1×2 Matrix{Int64}:
 1  0
count([f=identity,] itr; init=0) -> Integer

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

Совместимость: Julia 1.6

Именованный аргумент init был добавлен в Julia 1.6.

См. также описание any, sum.

Примеры

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

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

julia> count(>(3), 1:7, init=0x03)
0x07
count(
	pattern::Union{AbstractChar,AbstractString,AbstractPattern},
    string::AbstractString;
    overlap::Bool = false,
)

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

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

Совместимость: Julia 1.3

Для этого метода требуется версия Julia не ниже 1.3.
Совместимость: Julia 1.7

Для использования символа в качестве шаблона требуется версия Julia не ниже 1.7.

Примеры

julia> count('a', "JuliaLang")
2

julia> count(r"a(.)a", "cabacabac", overlap=true)
3

julia> count(r"a(.)a", "cabacabac")
2
count([f=identity,] A::AbstractArray; dims=:)

Подсчитывает количество элементов в A, для которых функция f возвращает true по заданным измерениям.

Совместимость: Julia 1.5

Именованный аргумент dims был добавлен в Julia 1.5.
Совместимость: Julia 1.6

Именованный аргумент init был добавлен в Julia 1.6.

Примеры

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

julia> count(<=(2), A, dims=1)
1×2 Matrix{Int64}:
 1  1

julia> count(<=(2), A, dims=2)
2×1 Matrix{Int64}:
 2
 0
foreach(f, c...) -> Nothing

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

foreach следует использовать вместо map, если результаты f не требуются, например, в foreach(println, array).

Примеры

julia> tri = 1:3:7; res = Int[];

julia> foreach(x -> push!(res, x^2), tri)

julia> res
3-element Vector{Int64}:
  1
 16
 49

julia> foreach((x, y) -> println(x, " with ", y), tri, 'a':'z')
1 with a
4 with b
7 with c
map(f, c...) -> collection

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

См. также описание map!, foreach, mapreduce, mapslices, zip, Iterators.map.

Примеры

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

julia> map(+, [1, 2, 3], [10, 20, 30, 400, 5000])
3-element Vector{Int64}:
 11
 22
 33
map(f, A::AbstractArray...) -> N-array

При выполнении действий с многомерными массивами одинаковой размерности ndims у них должны быть одинаковые оси axes, и такие же будут у результата.

См. также описание функции broadcast, допускающей несоответствие размеров.

Примеры

julia> map(//, [1 2; 3 4], [4 3; 2 1])
2×2 Matrix{Rational{Int64}}:
 1//4  2//3
 3//2  4//1

julia> map(+, [1 2; 3 4], zeros(2,1))
ERROR: DimensionMismatch

julia> map(+, [1 2; 3 4], [1,10,100,1000], zeros(3,1))  # выполняет итерацию вплоть до исчерпания третьей коллекции
3-element Vector{Float64}:
   2.0
  13.0
 102.0
map!(function, destination, collection...)

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

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

См. также описание map, foreach, zip, copyto!.

Примеры

julia> a = zeros(3);

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

julia> a
3-element Vector{Float64}:
 2.0
 4.0
 6.0

julia> map!(+, zeros(Int, 5), 100:999, 1:3)
5-element Vector{Int64}:
 101
 103
 105
   0
   0
map!(f, values(dict::AbstractDict))

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

Совместимость: Julia 1.2

Для map!(f, values(dict::AbstractDict)) требуется версия Julia не ниже 1.2.

Примеры

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

julia> map!(v -> v-1, values(d))
ValueIterator for a Dict{Symbol, Int64} with 2 entries. Values:
  0
  1
mapreduce(f, op, itrs...; [init])

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

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

Совместимость: Julia 1.2

Для mapreduce с несколькими итераторами требуется версия Julia не ниже 1.2.

Примеры

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

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

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

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

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

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

first(coll)

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

См. также описание only, firstindex, last.

Примеры

julia> first(2:2:10)
2

julia> first([1; 2; 3; 4])
1
first(itr, n::Integer)

Получает первые n элементов итерируемой коллекции itr или меньшее число элементов, если itr имеет недостаточную длину.

См. также описание startswith, Iterators.take.

Совместимость: Julia 1.6

Для этого метода требуется версия Julia не ниже 1.6.

Примеры

julia> first(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "foo"
 "bar"

julia> first(1:6, 10)
1:6

julia> first(Bool[], 1)
Bool[]
first(s::AbstractString, n::Integer)

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

Примеры

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

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

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

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

См. также описание first и endswith.

Примеры

julia> last(1:2:10)
9

julia> last([1; 2; 3; 4])
4
last(itr, n::Integer)

Получает последние n элементов итерируемой коллекции itr или меньшее число элементов, если itr имеет недостаточную длину.

Совместимость: Julia 1.6

Для этого метода требуется версия Julia не ниже 1.6.

Примеры

julia> last(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "bar"
 "qux"

julia> last(1:6, 10)
1:6

julia> last(Float64[], 1)
Float64[]
last(s::AbstractString, n::Integer)

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

Примеры

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

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

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

Возвращает кортеж Tuple, включающий все компоненты x, кроме последнего.

См. также описание first, tail.

Примеры

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

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

Возвращает кортеж Tuple, включающий все компоненты x, кроме первого.

См. также описание front, rest, first, Iterators.peel.

Примеры

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

julia> Base.tail(())
ERROR: ArgumentError: Cannot call tail on an empty tuple.
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
collect(collection)

Возвращает массив Array со всеми элементами в коллекции или итераторе. Для словарей возвращает вектор Vector пар Pair key=>value. Если аргумент аналогичен массиву или является итератором с типажом HasShape, результат будет иметь ту же форму и то же количество измерений, что и аргумент.

Используется включениями для преобразования выражения генератора в Array. Таким образом, в генераторах можно использовать запись в квадратных скобках вместо вызова collect; см. второй пример.

Примеры

Сбор элементов из коллекции UnitRange{Int64}:

julia> collect(1:3)
3-element Vector{Int64}:
 1
 2
 3

Сбор элементов из генератора (тот же результат, что и для [x^2 for x in 1:3]):

julia> collect(x^2 for x in 1:3)
3-element Vector{Int64}:
 1
 4
 9
collect(element_type, collection)

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

Примеры

julia> collect(Float64, 1:2:5)
3-element Vector{Float64}:
 1.0
 3.0
 5.0
filter(f, a)

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

Совместимость: Julia 1.4

Для поддержки a в качестве кортежа требуется версия Julia не ниже 1.4.

См. также описание filter!, Iterators.filter.

Примеры

julia> a = 1:10
1:10

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

Создает функцию, которая фильтрует свои аргументы с помощью функции f, используя filter, т. е. функцию, эквивалентную x -> filter(f, x).

Возвращаемая функция имеет тип Base.Fix1{typeof(filter)} и может использоваться для реализации специализированных методов.

Примеры

julia> (1, 2, Inf, 4, NaN, 6) |> filter(isfinite)
(1, 2, 4, 6)

julia> map(filter(iseven), [1:3, 2:4, 3:5])
3-element Vector{Vector{Int64}}:
 [2]
 [2, 4]
 [4]
Совместимость: Julia 1.9

Для этого метода требуется версия Julia не ниже 1.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, но при этом все отсутствующие элементы (missing), а также элементы, для которых f возвращает значение false, удаляются.

Совместимость: Julia 1.2

Для этого метода требуется версия Julia не ниже 1.2.

Примеры

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

julia> filter(isodd, skipmissing(x))
1-element Vector{Int64}:
 1
filter!(f, a)

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

Примеры

julia> filter!(isodd, Vector(1:10))
5-element Vector{Int64}:
 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"
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!, splice!, delete! и insert!.

Совместимость: Julia 1.7

Для замены элементов Tuple требуется версия 1.7.

Примеры

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

julia> replace([1, missing], missing=>0)
2-element Vector{Int64}:
 1
 0
replace(new::Union{Function, Type}, A; [count::Integer])

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

Совместимость: Julia 1.7

Для замены элементов Tuple требуется версия 1.7.

Примеры

julia> replace(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Vector{Int64}:
 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
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 Vector{Int64}:
 0
 4
 1
 3

julia> replace!(Set([1, 2, 3]), 1=>0)
Set{Int64} with 3 elements:
  0
  2
  3
replace!(new::Union{Function, Type}, 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 Vector{Int64}:
 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{Int64} with 2 elements:
  6
  12
Base.rest(collection[, itr_state])

Универсальная функция для принятия последних элементов collection, начиная с конкретного состояния итерации itr_state. Возвращает Tuple, если collection является Tuple, подтип AbstractVector, если collection является AbstractArray, подтип AbstractString, если collection является AbstractString, и в ином случае — произвольный итератор, который откатывается до Iterators.rest(collection[, itr_state]).

Можно перегрузить для определенных пользователем типов коллекций, чтобы настроить поведение считывания целиком в присваиваниях в конечном расположении, например a, b... = collection.

Совместимость: Julia 1.6

Для Base.rest требуется версия Julia не ниже 1.6.

См. также описание first, Iterators.rest, Base.split_rest.

Примеры

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> first, state = iterate(a)
(1, 2)

julia> first, Base.rest(a, state)
(1, [3, 2, 4])
Base.split_rest(collection, n::Int[, itr_state]) -> (rest_but_n, last_n)

Универсальная функция для разделения конца collection, начиная с конкретного состояния итерации itr_state. Возвращает кортеж двух новых коллекций. Первая содержит все элементы конца, кроме n последних, которые составляют вторую коллекцию.

Тип первой коллекции в целом соответствует типу Base.rest, за исключением того, что резервный вариант не является отложенным, а может быстро формироваться в вектор.

Можно перегрузить для определенных пользователем типов коллекций, чтобы настроить поведение считывания целиком в присваиваниях в неконечном расположении, например a, b..., c = collection.

Совместимость: Julia 1.9

Для Base.split_rest требуется версия Julia не ниже 1.9.

См. также описание Base.rest.

Примеры

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> first, state = iterate(a)
(1, 2)

julia> first, Base.split_rest(a, 1, state)
(1, ([3, 2], [4]))

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

getindex(collection, key...)

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

См. также описание get, keys и eachindex.

Примеры

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

julia> getindex(A, "a")
1
setindex!(collection, value, key...)

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

Примеры

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

julia> setindex!(a, 2, "b")
Dict{String, Int64} with 2 entries:
  "b" => 2
  "a" => 1
firstindex(collection) -> Integer
firstindex(collection, d) -> Integer

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

Синтаксис A[begin] и A[1, begin] понижается до A[firstindex(A)] и A[1, firstindex(A, 2)] соответственно.

См. также описание first, axes, lastindex, nextind.

Примеры

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

julia> firstindex(rand(3,4,5), 2)
1
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)] соответственно.

См. также описание axes, firstindex, eachindex, prevind.

Примеры

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

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

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

Частично реализуется следующими типами:

Словари

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

AbstractDict{K, V}

Супертип для типов, аналогичных словарям, с ключами типа K и значениями типа V. Dict, IdDict и другие типы являются подтипами этого типа. AbstractDict{K, V} должен быть итератором Pair{K, V}.

Dict([itr])

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

Если передан один итерируемый аргумент, создает Dict, пары «ключ-значение» которого берутся из двухэлементных кортежей (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

Ключи могут быть изменяемыми, но если вы измените сохраненные ключи, хэш-таблица может стать внутренне противоречивой и в этом случае Dict будет работать некорректно. Если вам необходимо изменять ключи, альтернативой может быть IdDict.

 
IdDict([itr])

IdDict{K,V}() выполняет построение хэш-таблицы, используя objectid как хэш и === как оператор равенства, с ключами типа K и значениями типа V. Дополнительную справочную информацию см. в описании Dict. Версия этой функции для множеств — IdSet.

В следующем примере все ключи Dict являются isequal и хэшируются одинаковым образом, поэтому они перезаписываются. IdDict выполняет хэширование по идентификатору объекта, таким образом сохраняя три различных ключа.

Примеры

julia> Dict(true => "yes", 1 => "no", 1.0 => "maybe")
Dict{Real, String} with 1 entry:
  1.0 => "maybe"

julia> IdDict(true => "yes", 1 => "no", 1.0 => "maybe")
IdDict{Any, String} with 3 entries:
  true => "yes"
  1.0  => "maybe"
  1    => "no"
WeakKeyDict([itr])

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

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

См. также описание WeakRef.

ImmutableDict

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

ImmutableDict(KV::Pair)

Создание новой записи в ImmutableDict для пары key => value

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

  • используйте get(dict, key, default), чтобы получить последнее значение для конкретного ключа.

PersistentDict

PersistentDict — это словарь, реализованный в виде префиксного дерева, сопоставленного с хэш-массивом, что оптимально подходит для ситуаций, когда требуется сохранение данных. Каждая операция возвращает новый словарь, который не связан с предыдущим, но базовая реализация занимает мало места и позволяет совместно использовать память для нескольких отдельных словарей.

Работает как IdDict.

 
PersistentDict(KV::Pair)

Примеры

julia> dict = Base.PersistentDict(:a=>1)
Base.PersistentDict{Symbol, Int64} with 1 entry:
  :a => 1

julia> dict2 = Base.delete(dict, :a)
Base.PersistentDict{Symbol, Int64}()

julia> dict3 = Base.PersistentDict(dict, :a=>2)
Base.PersistentDict{Symbol, Int64} with 1 entry:
  :a => 2
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
get(collection, key, default)

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

Совместимость: Julia 1.7

Для кортежей и числовых значений эта функция требует версию не ниже Julia 1.7.

Примеры

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

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

julia> get(d, "c", 3)
3
get(f::Union{Function, Type}, collection, key)

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

Предполагается, что эта функция вызывается с использованием значения по умолчанию синтаксиса блока do,

get(dict, key) do
    # вычисленного здесь.
    time()
end
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
get!(f::Union{Function, Type}, collection, key)

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

Предполагается, что эта функция вызывается с использованием синтаксиса блока do.

Примеры

julia> squares = Dict{Int, Int}();

julia> function get_square!(d, i)
           get!(d, i) do
               i^2
           end
       end
get_square! (generic function with 1 method)

julia> get_square!(squares, 2)
4

julia> squares
Dict{Int64, Int64} with 1 entry:
  2 => 4
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)
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

julia> delete!(d, "b") # d остается без изменений
Dict{String, Int64} with 1 entry:
  "a" => 1
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
keys(iterator)

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

values(iterator)

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

Примеры

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

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

julia> values([2])
1-element Vector{Int64}:
 2
values(a::AbstractDict)

Возвращает итератор по всем значениям в коллекции. collect(values(a)) возвращает массив значений. Если значения хранятся в хэш-таблице, как в случае с Dict, они могут возвращаться в разном порядке. Но keys(a), values(a) и pairs(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 Vector{Int64}:
 2
 3
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 гарантированно будет Base.CartesianIndex; при указании IndexStyle(A) выбирается любой стиль, определенный как собственный стиль индексирования для массива A.

При изменении границ базового массива этот итератор становится недопустимым.

Примеры

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

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

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

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

См. также описание IndexStyle и axes.

pairs(collection)

Возвращает итератор по парам key => value для любой коллекции, которая сопоставляет набор ключей с набором значений. К ним относятся массивы, в которых ключами являются индексы массива. Если элементы хранятся в хэш-таблице, как в случае с Dict, они могут возвращаться в разном порядке. Но keys(a), values(a) и pairs(a) выполняют итерацию по a и возвращают элементы в одном и том же порядке.

Примеры

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

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

julia> foreach(println, pairs(["a", "b", "c"]))
1 => "a"
2 => "b"
3 => "c"

julia> (;a=1, b=2, c=3) |> pairs |> collect
3-element Vector{Pair{Symbol, Int64}}:
 :a => 1
 :b => 2
 :c => 3

julia> (;a=1, b=2, c=3) |> collect
3-element Vector{Int64}:
 1
 2
 3
merge(initial::Face, others::Face...)

Объединяет свойства шрифта initial и others, причем последние имеют приоритет.

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

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

Примеры

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(a::NamedTuple, bs::NamedTuple...)

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

Совместимость: Julia 1.1

Для объединения трех или более кортежей NamedTuple требуется версия Julia не ниже 1.1.

Примеры

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)
mergewith(combine, d::AbstractDict, others::AbstractDict...)
mergewith(combine)
merge(combine, d::AbstractDict, others::AbstractDict...)

Создает объединенную коллекцию на основе заданных коллекций. При необходимости типы результирующей коллекции продвигаются, чтобы в них помещались типы объединяемых коллекций. Значения с тем же ключом будут объединены с помощью функции объединителя. Каррированная форма mergewith(combine) возвращает функции (args...) -> mergewith(combine, args...).

Метод merge(combine::Union{Function,Type}, args...) как псевдоним mergewith(combine, args...) по-прежнему доступен для обратной совместимости.

Совместимость: Julia 1.5

Для mergewith требуется версия Julia не ниже 1.5.

Примеры

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> mergewith(+, a, b)
Dict{String, Float64} with 3 entries:
  "bar" => 4753.0
  "baz" => 17.0
  "foo" => 0.0

julia> ans == mergewith(+)(a, b)
true
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
mergewith!(combine, d::AbstractDict, others::AbstractDict...) -> d
mergewith!(combine)
merge!(combine, d::AbstractDict, others::AbstractDict...) -> d

Обновляет коллекцию с использованием пар из других коллекций. Значения с тем же ключом будут объединены с помощью функции объединителя. Каррированная форма mergewith!(combine) возвращает функции (args...) -> mergewith!(combine, args...).

Метод merge!(combine::Union{Function,Type}, args...) как псевдоним mergewith!(combine, args...) по-прежнему доступен для обратной совместимости.

Совместимость: Julia 1.5

Для mergewith! требуется версия Julia не ниже 1.5.

Примеры

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

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

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

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

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

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

julia> foldl(mergewith!(+), [d1, d2]; init=Dict{Int64, Int64}())
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 0
  1 => 4
sizehint!(s, n; first::Bool=false, shrink::Bool=true) -> s

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

Если first равно true, любое дополнительное пространство резервируется перед началом коллекции. Это позволяет ускорить последующие вызовы pushfirst! (вместо push!). Использование этого именованного аргумента может привести к ошибке, если коллекция не упорядочена или pushfirst! не поддерживается для нее.

При shrink=true (по умолчанию) емкость коллекции может быть уменьшена, если ее текущая емкость больше n.

См. также описание resize!.

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

Для типов, поддерживающих sizehint!,

  1. методы push! и append! в общем случае могут (но необязательно) предварительно выделять дополнительное хранилище. Для типов, реализованных в Base, это обычно делается с использованием эвристического механизма, оптимизированного для стандартных сценариев.

  2. sizehint! может контролировать такое предварительное выделение. Опять-таки, обычно это делается для типов в Base.

  3. empty! практически бесплатно (O(1)) для типов, поддерживающих такое предварительное выделение.

Совместимость: Julia 1.11

Аргументы shrink и first были добавлены в версии Julia 1.11.

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

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

Примеры

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

julia> keytype([1 2; 3 4])
CartesianIndex{2}
Совместимость: Julia 1.2

В случае с массивами для этой функции требуется версия Julia не ниже 1.2.

 
keytype(type)

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

Примеры

julia> keytype(Dict(Int32(1) => "foo"))
Int32
valtype(T::Type{<:AbstractArray})
valtype(A::AbstractArray)

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

Примеры

julia> valtype(["one", "two", "three"])
String
Совместимость: Julia 1.2

В случае с массивами для этой функции требуется версия Julia не ниже 1.2.

 
valtype(type)

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

Примеры

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

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

Частично реализуется следующими типами:

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

AbstractSet{T}

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

Set{T} <: AbstractSet{T}

Множества Set являются изменяемыми контейнерами, которые обеспечивают быстрое тестирование членства.

В Set эффективно реализованы такие операции с множествами, как in, union и intersect. Элементы в Set уникальны согласно определению isequal для элементов. Порядок элементов в Set — это лишь особенность реализации, и на нее нельзя полагаться.

См. также описание AbstractSet, BitSet, Dict, push!, empty!, union!, in, isequal

Примеры

julia> s = Set("aaBca")
Set{Char} with 3 elements:
  'a'
  'c'
  'B'

julia> push!(s, 'b')
Set{Char} with 4 elements:
  'a'
  'b'
  'B'
  'c'

julia> s = Set([NaN, 0.0, 1.0, 2.0]);

julia> -0.0 in s # isequal(0.0, -0.0) имеет значение false
false

julia> NaN in s # isequal(NaN, NaN) имеет значение true
true
BitSet([itr])

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

IdSet{T}([itr])
IdSet()

IdSet{T}() создает множество (см. Set), используя === как оператор равенства, со значениями типа T.

В приведенном ниже примере все значения isequal, поэтому они перезаписываются в обычном Set. IdSet выполняет сравнение с помощью ===, поэтому три разных значения сохраняются.

Примеры

julia> Set(Any[true, 1, 1.0])
Set{Any} with 1 element:
  1.0

julia> IdSet{Any}(Any[true, 1, 1.0])
IdSet{Any} with 3 elements:
  1.0
  1
  true
union(s, itrs...)
∪(s, itrs...)

Создает объект, который содержит все уникальные элементы из всех аргументов.

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

Символ Юникода ∪ можно ввести, набрав \cup, а затем нажав клавишу TAB в REPL Julia, а также во многих других редакторах. Это инфиксный оператор, допускающий s ∪ itr.

См. также описание unique, intersect, isdisjoint, vcat, Iterators.flatten.

Примеры

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

julia> union([4 2 3 4 4], 1:3, 3.0)
4-element Vector{Float64}:
 4.0
 2.0
 3.0
 1.0

julia> (0, 0.0) ∪ (-0.0, NaN)
3-element Vector{Real}:
   0
  -0.0
 NaN

julia> union(Set([1, 2]), 2:3)
Set{Int64} with 3 elements:
  2
  3
  1
union!(s::Union{AbstractSet,AbstractVector}, itrs...)

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

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

Примеры

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

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

julia> a
Set{Int64} with 5 elements:
  5
  4
  7
  3
  1
intersect(s, itrs...)
∩(s, itrs...)

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

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

Символ Юникода ∩ можно ввести, набрав \cap, а затем нажав клавишу TAB в REPL Julia, а также во многих других редакторах. Это инфиксный оператор, допускающий s ∩ itr.

См. также описание setdiff, isdisjoint, issubset и issetequal.

Совместимость: Julia 1.8

Начиная с версии Julia 1.8 intersect возвращает результат с типом элементов, соответствующим продвинутым типам элементов двух входных объектов.

Примеры

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

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

julia> intersect(1:16, 7:99)
7:16

julia> (0, 0.0) ∩ (-0.0, 0)
1-element Vector{Real}:
 0

julia> intersect(Set([1, 2]), BitSet([2, 3]), 1.0:10.0)
Set{Float64} with 1 element:
  2.0
setdiff(s, itrs...)

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

См. также описание setdiff!, union и intersect.

Примеры

julia> setdiff([1,2,3], [3,4,5])
2-element Vector{Int64}:
 1
 2
setdiff!(s, itrs...)

Удаляет из множества s (на месте) все элементы, входящие в итерируемые коллекции в itrs. Порядок сохраняется с помощью массивов.

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

Примеры

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

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

julia> a
Set{Int64} with 1 element:
  4
symdiff(s, itrs...)

Выполняет построение симметричной разности элементов в переданных множествах. Если s не является AbstractSet, порядок сохраняется.

См. также описание symdiff!, setdiff, union и intersect.

Примеры

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

julia> symdiff([1,2,1], [2, 1, 2])
Int64[]
symdiff!(s::Union{AbstractSet,AbstractVector}, itrs...)

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

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

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

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

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

 
issubset(a, b) -> Bool
⊆(a, b) -> Bool
⊇(b, a) -> Bool

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

См. также описание ⊊, ⊈, ∩, ∪, contains.

Примеры

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

julia> [1, 2, 3] ⊆ [1, 2]
false

julia> [1, 2, 3] ⊇ [1, 2]
true
in!(x, s::AbstractSet) -> Bool

Если x входит в s, возвращает true. В противном случае помещает x в s и возвращает false. Это равносильно in(x, s) ? true : (push!(s, x); false), но может иметь более эффективную реализацию.

См. также описание in, push!, Set

Совместимость: Julia 1.11

Для этой функции требуется версия Julia не ниже 1.11.

Примеры

julia> s = Set{Any}([1, 2, 3]); in!(4, s)
false

julia> length(s)
4

julia> in!(0x04, s)
true

julia> s
Set{Any} with 4 elements:
  4
  2
  3
  1
⊈(a, b) -> Bool
⊉(b, a) -> Bool

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

См. также описание issubset (⊆), ⊊.

Примеры

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

julia> (1, 2) ⊈ (1, 2, 3)
false
⊊(a, b) -> Bool
⊋(b, a) -> Bool

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

См. также описание issubset (⊆), ⊈.

Примеры

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

julia> (1, 2) ⊊ (1, 2)
false
issetequal(a, b) -> Bool

Определяет, содержат ли a и b одинаковые элементы. Эквивалентно a ⊆ b && b ⊆ a, однако может быть более эффективно.

См. также описание isdisjoint, union.

Примеры

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

julia> issetequal([1, 2], [2, 1])
true
issetequal(x)

Создает функцию, аргумент которой сравнивается с x через issetequal, т. е. функцию, эквивалентную y -> issetequal(y, x). Возвращаемая функция имеет тип Base.Fix2{typeof(issetequal)} и может использоваться для реализации специализированных методов.

Совместимость: Julia 1.11

Для этой функции требуется версия Julia не ниже 1.11.

 
isdisjoint(a, b) -> Bool

Определяет, являются ли коллекции a и b непересекающимися. Эквивалентно isempty(a ∩ b), однако может быть более эффективно.

См. также описание intersect, isempty, issetequal.

Совместимость: Julia 1.5

Для этой функции требуется версия Julia не ниже 1.5.

Примеры

julia> isdisjoint([1, 2], [2, 3, 4])
false

julia> isdisjoint([3, 1], [2, 4])
true
isdisjoint(x)

Создает функцию, аргумент которой сравнивается с x через isdisjoint, т. е. функцию, эквивалентную y -> isdisjoint(y, x). Возвращаемая функция имеет тип Base.Fix2{typeof(isdisjoint)} и может использоваться для реализации специализированных методов.

Совместимость: Julia 1.11

Для этой функции требуется версия Julia не ниже 1.11.

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

Частично реализуется следующими типами:

Двусторонние очереди

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

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

Примеры

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

Если коллекция collection упорядочена, используйте append! для добавления в нее всех элементов другой коллекции. Результат в предыдущем примере эквивалентен append!([1, 2, 3], [4, 5, 6]). Для объектов AbstractSet можно использовать union!.

Примечания по модели производительности см. в sizehint!.

См. также описание pushfirst!.

pop!(collection) -> item

Удаляет элемент в collection и возвращает его. Если collection является упорядоченным контейнером, возвращается последний элемент; в случае с неупорядоченными контейнерами возвращается произвольный элемент.

См. также описание popfirst!, popat!, delete!, deleteat!, splice! и push!.

Примеры

julia> A=[1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> pop!(A)
3

julia> A
2-element Vector{Int64}:
 1
 2

julia> S = Set([1, 2])
Set{Int64} with 2 elements:
  2
  1

julia> pop!(S)
2

julia> S
Set{Int64} with 1 element:
  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
popat!(a::Vector, i::Integer, [default])

Удаляет элемент по указанному i и возвращает его. Последующие элементы смещаются, чтобы заполнить получившийся в результате промежуток. Если i не является допустимым индексом для a, возвращается default, либо возникает ошибка, если default не указано.

См. также описание pop!, popfirst!, deleteat!, splice!.

Совместимость: Julia 1.5

Эта функция впервые реализована в Julia 1.5.

Примеры

julia> a = [4, 3, 2, 1]; popat!(a, 2)
3

julia> a
3-element Vector{Int64}:
 4
 2
 1

julia> popat!(a, 4, missing)
missing

julia> popat!(a, 4)
ERROR: BoundsError: attempt to access 3-element Vector{Int64} at index [4]
[...]
pushfirst!(collection, items...) -> collection

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

Во многих других языках программирования эта функция называется unshift.

Примеры

julia> pushfirst!([1, 2, 3, 4], 5, 6)
6-element Vector{Int64}:
 5
 6
 1
 2
 3
 4
popfirst!(collection) -> item

Удаляет первый элемент item из collection.

Во многих других языках программирования эта функция называется shift.

См. также описание pop!, popat!, delete!.

Примеры

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

julia> popfirst!(A)
1

julia> A
5-element Vector{Int64}:
 2
 3
 4
 5
 6
insert!(a::Vector, index::Integer, item)

Вставляет элемент item в a по индексу index. index — это индекс элемента item в результирующем a.

См. также описание push!, replace, popat!, splice!.

Примеры

julia> insert!(Any[1:6;], 3, "here")
7-element Vector{Any}:
 1
 2
  "here"
 3
 4
 5
 6
deleteat!(a::Vector, i::Integer)

Удаляет элемент по указанному индексу i и возвращает измененный массив a. Последующие элементы смещаются, чтобы заполнить получившийся в результате промежуток.

См. также описание keepat!, delete!, popat!, splice!.

Примеры

julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
5-element Vector{Int64}:
 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 Vector{Int64}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], [true, false, true, false, true, false])
3-element Vector{Int64}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
ERROR: ArgumentError: indices must be unique and sorted
Stacktrace:
[...]
keepat!(a::Vector, inds)
keepat!(a::BitVector, inds)

Удаляет элементы по всем индексам, которые не заданы в inds, и возвращает измененный массив a. Сохраняемые элементы смещаются, чтобы заполнить получившийся в результате промежуток.

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

inds должен быть итератором сортированных и уникальных целочисленных индексов. См. также описание deleteat!.

Совместимость: Julia 1.7

Эта функция впервые реализована в Julia 1.7.

Примеры

julia> keepat!([6, 5, 4, 3, 2, 1], 1:2:5)
3-element Vector{Int64}:
 6
 4
 2
keepat!(a::Vector, m::AbstractVector{Bool})
keepat!(a::BitVector, m::AbstractVector{Bool})

Выполняемая на месте версия логического индексирования a = a[m]. То есть вызов keepat!(a, m) для векторов одинаковой длины a и m удаляет все элементы из a, для которых по соответствующему индексу в m находится false.

Примеры

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

julia> keepat!(a, [true, false, true])
2-element Vector{Symbol}:
 :a
 :c

julia> a
2-element Vector{Symbol}:
 :a
 :c
splice!(a::Vector, index::Integer, [replacement]) -> item

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

См. также описание replace, delete!, deleteat!, pop!, popat!.

Примеры

julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
2

julia> A
5-element Vector{Int64}:
 6
 5
 4
 3
 1

julia> splice!(A, 5, -1)
1

julia> A
5-element Vector{Int64}:
  6
  5
  4
  3
 -1

julia> splice!(A, 1, [-1, -2, -3])
6

julia> A
7-element Vector{Int64}:
 -1
 -2
 -3
  5
  4
  3
 -1

Чтобы вставить replacement перед индексом n, не удаляя элементы, используйте splice!(collection, n:n-1, replacement).

splice!(a::Vector, indices, [replacement]) -> items

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

Чтобы вставить replacement перед индексом n, не удаляя элементы, используйте splice!(collection, n:n-1, replacement).

Если какой-либо измененный аргумент размещается в одной области памяти с любым другим аргументом, поведение может быть непредвиденным.
Совместимость: Julia 1.5

В версиях до Julia 1.5 аргумент indices всегда должен иметь тип UnitRange.
Совместимость: Julia 1.8

В версиях до Julia 1.8 при вставке заменяющих значений аргумент indices всегда должен иметь тип UnitRange.

Примеры

julia> A = [-1, -2, -3, 5, 4, 3, -1]; splice!(A, 4:3, 2)
Int64[]

julia> A
8-element Vector{Int64}:
 -1
 -2
 -3
  2
  5
  4
  3
 -1
resize!(a::Vector, n::Integer) -> Vector

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

Примеры

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

julia> a = resize!([6, 5, 4, 3, 2, 1], 8);

julia> length(a)
8

julia> a[1:6]
6-element Vector{Int64}:
 6
 5
 4
 3
 2
 1
append!(collection, collections...) -> collection.

Для упорядоченного контейнера collection добавляет элементы каждой коллекции в collections в конце.

Совместимость: Julia 1.6

Для указания нескольких коллекций, которые требуется присоединить, необходима версия Julia не ниже 1.6.

Примеры

julia> append!([1], [2, 3])
3-element Vector{Int64}:
 1
 2
 3

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

Используйте push! для добавления отдельных элементов в collection, которые еще не включены в другую коллекцию. Результат в предыдущем примере эквивалентен push!([1, 2, 3], 4, 5, 6).

Примечания по модели производительности см. в sizehint!.

См. также vcat для векторов, union! для множеств и prepend! и pushfirst! (обратный порядок).

prepend!(a::Vector, collections...) -> collection

Вставляет элементы из каждой коллекции в collections в начало a.

Если в collections указано несколько коллекций, порядок сохраняется: элементы collections[1] будут самыми левыми в a и т. д.

Совместимость: Julia 1.6

Для указания нескольких коллекций, которые требуется присоединить в начале, необходима версия Julia не ниже 1.6.

Примеры

julia> prepend!([3], [1, 2])
3-element Vector{Int64}:
 1
 2
 3

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

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

  • Vector (или одномерный массив Array)

  • BitVector (или одномерный массив BitArray)

Полезные коллекции

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

julia> replace.(["xops", "oxps"], "x" => "o")
2-element Vector{String}:
 "oops"
 "oops"
Base.Pairs(values, keys) <: AbstractDict{eltype(keys), eltype(values)}

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