Collections and Data Structures

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

이터레이터를 진행하여 다음 요소를 얻습니다. 남은 요소가 없으면 nothing이 반환되어야 합니다. 그렇지 않으면 다음 요소와 새로운 반복 상태의 2-튜플이 반환되어야 합니다.

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의 간격을 가진 범위입니다. 각 요소 간의 단계는 일정하며, 범위는 타입 T의 start와 stop, 그리고 타입 S의 step으로 정의됩니다. 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로 매개변수화된 범위로, start에서 시작하여 stop을 초과할 때까지 1 간격으로 요소로 채워집니다. 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}

start와 stop 사이에 len 개의 선형으로 간격이 있는 요소를 가진 범위입니다. 간격의 크기는 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

로그arithmically 간격이 있는 점에 대해서는 Logrange도 참조하세요.

isempty(collection) -> Bool

컬렉션이 비어 있는지(요소가 없는지) 확인합니다.

!!! 경고 isempty(itr)는 적절한 Base.isdone(itr) 메서드가 정의되지 않은 경우 상태가 있는 반복자 itr의 다음 요소를 소비할 수 있습니다. 상태가 있는 반복자는 isdone을 구현해야 하지만, 모든 반복자 유형을 지원해야 하는 일반 코드를 작성할 때 isempty 사용을 피하고 싶을 수 있습니다.

예제

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

조건에 대기 중인 작업이 없으면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

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

이 함수는 반복자 완료에 대한 빠른 경로 힌트를 제공합니다. 이는 사용자가 노출되지 않을 요소가 소비되는 것을 피하고자 하는 상태 기반 반복자에 유용합니다(예: isempty 또는 zip에서 완료 여부를 확인할 때).

이 기능을 선택하고자 하는 상태 기반 반복자는 반복자가 완료되었는지 여부에 따라 true/false를 반환하는 isdone 메서드를 정의해야 합니다. 상태가 없는 반복자는 이 함수를 구현할 필요가 없습니다.

결과가 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의 각 값이 collection의 해당 위치에 있는 값에 in인지 여부를 나타내는 벡터입니다. 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 모두 브로드캐스트되므로, 이는 종종 의도한 바가 아닙니다. 예를 들어, 두 인수가 벡터이고(차원이 일치하는 경우) 결과는 collection의 해당 위치에 있는 값이 아닌 items의 각 값이 아닌지를 나타내는 벡터입니다. 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)

collection::T에서 x ∈ collection 계산이 "빠른" 작업(일반적으로 상수 또는 로그 복잡도)으로 간주될 수 있는지 여부를 결정합니다. 편의를 위해 hasfastin(x) = hasfastin(typeof(x))가 제공되므로 인스턴스를 타입 대신 전달할 수 있습니다. 그러나 타입 인수를 수용하는 형태는 새로운 타입에 대해 정의되어야 합니다.

hasfastin(T)의 기본값은 AbstractSet, AbstractDict 및 AbstractRange의 하위 타입에 대해 true이며, 그렇지 않은 경우 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의 첫 번째 인덱스를 포함하는 배열을 반환합니다. 출력 배열은 a가 b의 구성원이 아닐 경우 nothing을 포함합니다.

참고: 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)

차원 dims을 따라 A의 고유한 영역을 반환합니다.

예제

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에서 하나의 값을 선택한 다음 수정된 A를 반환합니다.

예제

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

itr의 모든 값이 isequal로 비교했을 때 서로 다르면 true를 반환합니다. 두 번째 방법의 경우 [f(x) for x in itr]의 모든 값이 서로 다르면 true를 반환합니다.

allunique(f, itr)는 f를 length(itr)보다 적은 횟수만큼 호출할 수 있습니다. 호출 횟수는 구현 세부사항으로 간주됩니다.

allunique는 입력이 정렬되어 있을 때 특수화된 구현을 사용할 수 있습니다.

참고: unique, issorted, allequal.

예제

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

itr의 모든 값이 isequal로 비교했을 때 같으면 true를 반환합니다. 두 번째 방법의 경우 [f(x) for x in itr]의 모든 값이 같으면 true를 반환합니다.

allequal(f, itr)는 length(itr)보다 적은 횟수로 f를 호출할 수 있습니다. 호출 횟수는 구현 세부사항으로 간주됩니다.

참고: unique, allunique.

예제

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

주어진 이진 연산자 op로 주어진 컬렉션 itr을 축소합니다. 제공된 경우, 초기 값 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])

2-인수 함수 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으로 지정할 수 있습니다. init은 max에 대한 중립 요소여야 하며(즉, 다른 어떤 요소보다 작거나 같아야 함) init이 비어 있지 않은 컬렉션에 사용되는지는 명시되지 않았습니다.

예제

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으로 지정할 수 있습니다. init은 max에 대한 중립 요소여야 하며(즉, 다른 모든 요소보다 작거나 같아야 함) 빈 컬렉션에 대해 init이 사용되는지는 명시되지 않았습니다.

예제

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에 기록합니다.

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 때 동작이 예기치 않게 될 수 있습니다.

예제

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> 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으로 지정할 수 있습니다. init은 min에 대한 중립 요소여야 하며(즉, 다른 모든 요소보다 크거나 같아야 함) 빈 컬렉션이 아닌 경우 init이 사용되는지는 명시되어 있지 않습니다.

예제

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에 기록합니다.

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 경우 예상치 못한 동작이 발생할 수 있습니다.

예제

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 요소를 모두 계산하고, 이를 2-튜플로 반환합니다.

빈 itr에 대해 반환되는 값은 init으로 지정할 수 있습니다. 이는 min 및 max에 대한 중립 요소인 첫 번째 및 두 번째 요소를 가진 2-튜플이어야 합니다(즉, 다른 모든 요소보다 크거나 작거나 같아야 함). 결과적으로, itr이 비어 있을 때 반환된 (mn, mx) 튜플은 mn ≥ mx를 만족합니다. init이 지정되면 비어 있지 않은 itr에 대해서도 사용할 수 있습니다.

예제

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)

각 요소에 대해 f를 적용하여 최소값 mn과 최대값 mx를 계산하고 이를 2-튜플로 반환합니다. itr에 대해 한 번만 통과합니다.

빈 itr에 대해 반환되는 값은 init으로 지정할 수 있습니다. 이는 각각 min과 max에 대한 중립 요소인 첫 번째 및 두 번째 요소를 가진 2-튜플이어야 합니다(즉, 다른 어떤 요소보다 크거나 작거나 같아야 함). 이는 비어 있지 않은 컬렉션에 사용됩니다. 주의: 이는 빈 itr에 대해 반환된 값 (mn, mx)가 mn ≥ mx를 만족함을 의미하지만, 비어 있지 않은 itr에 대해서는 mn ≤ mx를 만족합니다. 이는 "역설적"이지만 예상되는 결과입니다.

예제

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}

주어진 차원에서 A의 각 요소에 적용된 f의 최소값과 최대값을 계산합니다.

extrema!(r, A)

r의 단일 차원에서 A의 최소값과 최대값을 계산하고 결과를 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로 비교됩니다.

자세한 내용은 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)

f(x)가 최소화되는 domain에서 값을 x로 반환합니다. f(x)에 대해 여러 개의 최소값이 있는 경우 첫 번째 값이 찾아집니다.

domain은 비어 있지 않은 반복 가능해야 합니다.

NaN은 missing을 제외한 모든 다른 값보다 작게 처리됩니다.

자세한 내용은 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의 출력)과 해당 값의 domain에서의 인덱스 또는 키(즉, f의 입력)를 반환하여 f(x)가 최대화되도록 합니다. 최대점이 여러 개일 경우, 첫 번째 점이 반환됩니다.

domain은 keys를 지원하는 비어 있지 않은 반복 가능 객체여야 합니다. 인덱스는 keys(domain)에서 반환된 것과 동일한 유형입니다.

값은 isless로 비교됩니다.

예제

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의 출력)과 해당 값의 인덱스 또는 키를 반환합니다. 이 값은 domain(즉, f의 입력)에서 f(x)가 최소화되는 지점입니다. 최소 지점이 여러 개일 경우, 첫 번째 지점이 반환됩니다.

domain은 비어 있지 않은 반복 가능 객체여야 합니다.

인덱스는 keys(domain) 및 pairs(domain)에서 반환되는 것과 동일한 유형입니다.

NaN은 missing을 제외한 모든 다른 값보다 작게 처리됩니다.

예제

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으로 지정할 수 있습니다. 이는 덧셈 항등원(즉, 0)이어야 하며, init이 비어 있지 않은 컬렉션에 사용되는지 여부는 명시되지 않았습니다.

예제

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

작은 정수 엘타입을 가진 배열에 대해 sum(A)와 reduce(+, A)의 중요한 차이를 주목하세요:

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

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

전자의 경우, 정수는 시스템 단어 크기로 확장되므로 결과는 128입니다. 후자의 경우, 그러한 확장이 발생하지 않으며 정수 오버플로우로 인해 -128이 됩니다.

sum(itr; [init])

모음의 모든 요소의 합계를 반환합니다.

반환 유형은 시스템 단어 크기보다 작은 부호 있는 정수의 경우 Int이고, 시스템 단어 크기보다 작은 부호 없는 정수의 경우 UInt입니다. 다른 모든 인수에 대해서는 모든 인수가 승격되는 공통 반환 유형이 발견됩니다.

빈 itr에 대해 반환되는 값은 init으로 지정할 수 있습니다. 이는 덧셈 항등원(즉, 0)이어야 하며, init이 비어 있지 않은 컬렉션에 사용되는지 여부는 명시되지 않았습니다.

참고: 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])

itr의 각 요소에 적용된 f의 곱을 반환합니다.

반환 타입은 시스템 단어 크기보다 작은 부호 있는 정수의 경우 Int이고, 시스템 단어 크기보다 작은 부호 없는 정수의 경우 UInt입니다. 모든 다른 인수에 대해서는 모든 인수가 승격되는 공통 반환 타입이 찾아집니다.

빈 itr에 대해 반환되는 값은 init으로 지정할 수 있습니다. 이는 곱셈 항등원(즉, 1)이어야 하며, init이 비어 있지 않은 컬렉션에 사용되는지 여부는 명시되지 않았습니다.

예제

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

prod(itr; [init])

모음의 모든 요소의 곱을 반환합니다.

반환 유형은 시스템 단어 크기보다 작은 부호 있는 정수의 경우 Int이고, 시스템 단어 크기보다 작은 부호 없는 정수의 경우 UInt입니다. 모든 다른 인수에 대해서는 모든 인수가 승격되는 공통 반환 유형이 찾아집니다.

빈 itr에 대해 반환되는 값은 init으로 지정할 수 있습니다. 이는 곱셈 항등원(즉, 1)이어야 하며, init이 비어 있지 않은 컬렉션에 사용되는지 여부는 명시되지 않았습니다.

참고: 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인지 테스트하고, itr에서 첫 번째 true 값을 찾는 즉시 true를 반환합니다(단락 회로). false에 대해 단락 회로를 사용하려면 all을 사용하십시오.

입력에 missing 값이 포함되어 있으면, 모든 비어 있지 않은 값이 false인 경우(또는 입력에 true 값이 포함되어 있지 않은 경우) missing을 반환하며, 이는 삼값 논리를 따릅니다.

또한 참조: all, count, sum, |, , ||.

예제

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가 itr의 어떤 요소에 대해 true를 반환하는지 확인하고, p가 true를 반환하는 itr의 첫 번째 항목을 만나는 즉시 true를 반환합니다(단락 회로). false에 대해 단락 회로를 사용하려면 all을 사용하십시오.

입력에 missing 값이 포함되어 있으면, 모든 비어 있지 않은 값이 false인 경우(또는 입력에 true 값이 포함되어 있지 않은 경우) missing을 반환하며, 삼값 논리를 따릅니다.

예제

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의 단일 차원에 따라 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인지 테스트하고, itr에서 첫 번째 false 값이 발견되는 즉시 false를 반환합니다(단락 회로). true에 대해 단락 회로를 사용하려면 any를 사용하십시오.

입력에 missing 값이 포함되어 있으면, 모든 비어 있지 않은 값이 true인 경우(또는 입력에 false 값이 포함되어 있지 않은 경우) missing을 반환하며, 이는 삼값 논리를 따릅니다.

또한 참조: 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가 itr의 모든 요소에 대해 true를 반환하는지 확인하고, p가 false를 반환하는 itr의 첫 번째 항목을 만나는 즉시 false를 반환합니다(단락 회로). true에 대해 단락 회로를 사용하려면 any를 사용하세요.

입력에 missing 값이 포함되어 있으면, 모든 비어 있지 않은 값이 true인 경우(또는 입력에 false 값이 포함되어 있지 않은 경우) missing을 반환하며, 삼값 논리를 따릅니다.

예제

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의 단일 차원에 있는 모든 값이 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

f 함수가 true를 반환하는 itr의 요소 수를 계산합니다. f가 생략되면 itr에서 true 요소의 수를 계산합니다(불리언 값의 컬렉션이어야 함). init은 선택적으로 카운팅을 시작할 값을 지정하며, 따라서 출력 유형도 결정합니다.

참고: 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> 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=:)

주어진 차원에 대해 f가 true를 반환하는 A의 요소 수를 계산합니다.

예제

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를 호출합니다. 여러 개의 iterable 인자가 있을 경우, f는 요소별로 호출되며, 어떤 iterator가 끝나면 반복이 중지됩니다.

foreach는 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번째가 소진될 때까지 반복
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> 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> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
14

축소의 결합성은 구현에 따라 다릅니다. 또한, 일부 구현에서는 itr에 여러 번 나타나는 요소에 대해 f의 반환 값을 재사용할 수 있습니다. 모든 값에 대해 f를 호출하고 왼쪽 또는 오른쪽 결합성을 보장하려면 mapfoldl 또는 mapfoldr를 사용하십시오.

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)

iterable 컬렉션 itr의 첫 번째 n 요소를 가져오거나, itr가 충분히 길지 않은 경우 더 적은 요소를 가져옵니다.

참고: startswith, Iterators.take.

예제

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)

문자열 s의 처음 n 문자로 구성된 문자열을 가져옵니다.

예제

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)

iterable 컬렉션 itr의 마지막 n 요소를 가져오거나, itr가 충분히 길지 않은 경우 더 적은 요소를 가져옵니다.

예제

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)

문자열 s의 마지막 n 문자로 구성된 문자열을 가져옵니다.

예제

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

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

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

front(x::Tuple)::Tuple

x의 마지막 구성 요소를 제외한 모든 구성 요소로 이루어진 Tuple을 반환합니다.

참고: 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

x의 첫 번째 구성 요소를 제외한 모든 요소로 구성된 Tuple을 반환합니다.

참고: 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를 반환합니다. 사전의 경우 key=>value Pair로 이루어진 Vector를 반환합니다. 인수가 배열과 유사하거나 HasShape 특성을 가진 반복자인 경우, 결과는 인수와 동일한 형태와 차원 수를 가집니다.

comprehensions에서 generator expression을 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는 하나의 인수를 받습니다.

참고: filter!, Iterators.filter.

예제

julia> a = 1:10
1:10

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

filter(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]

filter(f, d::AbstractDict)

f가 false인 요소를 제거하고 d의 복사본을 반환합니다. 함수 f는 key=>value 쌍을 전달받습니다.

예제

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

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

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

주어진 SkipMissing 반복기로 감싸인 배열과 유사한 벡터를 반환하지만, 모든 결측값과 f가 false를 반환하는 요소는 제거됩니다.

예제

julia> x = [1 2; missing 4]
2×2 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 발생까지만 대체됩니다.

결과의 요소 유형은 A의 요소 유형과 쌍의 new 값의 유형을 기반으로 하여 승격(promote)을 사용하여 선택됩니다(자세한 내용은 promote_type 참조). count가 생략되고 A의 요소 유형이 Union인 경우, 다른 유형의 값으로 대체되는 단일 유형은 결과의 요소 유형에 포함되지 않습니다: 예를 들어, Union{T,Missing}는 missing이 대체되면 T가 됩니다.

또한 replace!, splice!, delete!, insert!도 참조하십시오.

예제

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를 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

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

각 쌍 old=>new에 대해 old_new에서, 컬렉션 A에서 old의 모든 발생을 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])

컬렉션 A의 각 요소 x를 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])

특정 반복 상태 itr_state에서 시작하여 collection의 꼬리를 가져오는 일반 함수입니다. collection이 Tuple인 경우 Tuple을 반환하고, collection이 AbstractArray인 경우 AbstractVector의 하위 유형을 반환하며, collection이 AbstractString인 경우 AbstractString의 하위 유형을 반환하고, 그렇지 않으면 임의의 반복자를 반환하며 Iterators.rest(collection[, itr_state])로 대체됩니다.

사용자 정의 컬렉션 유형에 대해 오버로드하여 최종 위치에서 할당 시 슬러핑의 동작을 사용자 지정할 수 있습니다. 예: a, b... = collection.

참고: 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)

특정 반복 상태 itr_state에서 시작하여 collection의 꼬리를 분할하는 일반 함수입니다. 두 개의 새로운 컬렉션으로 구성된 튜플을 반환합니다. 첫 번째 컬렉션은 마지막 n개의 요소를 제외한 꼬리의 모든 요소를 포함하고, 두 번째 컬렉션은 마지막 n개의 요소로 구성됩니다.

첫 번째 컬렉션의 유형은 일반적으로 Base.rest의 유형을 따르지만, 기본 사례는 게으르지 않고 벡터로 즉시 수집됩니다.

사용자 정의 컬렉션 유형에 대해 오버로드할 수 있으며, 이는 비최종 위치에서 할당 시 슬러핑의 동작을 사용자 정의하는 데 사용됩니다. 예: a, b..., c = collection.

참고: 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...)

주어진 값(value)을 컬렉션 내의 주어진 키(key) 또는 인덱스(index)에 저장합니다. 구문 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) -> 정수
firstindex(collection, d) -> 정수

collection의 첫 번째 인덱스를 반환합니다. d가 주어지면, 차원 d에서 collection의 첫 번째 인덱스를 반환합니다.

구문 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가 주어지면, 차원 d에서 collection의 마지막 인덱스를 반환합니다.

구문 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

AbstractDict{K, V}

키가 K 유형이고 값이 V 유형인 사전과 유사한 유형의 슈퍼타입입니다. Dict, IdDict 및 기타 유형은 이의 하위 유형입니다. AbstractDict{K, V}는 Pair{K, V}의 반복자여야 합니다.

Dict([itr])

Dict{K,V}()는 타입 K의 키와 타입 V의 값을 가진 해시 테이블을 생성합니다. 키는 isequal로 비교되고 hash로 해시됩니다.

단일 iterable 인수를 주면, 인수에 의해 생성된 2-튜플 (key,value)에서 키-값 쌍을 가져오는 Dict를 생성합니다.

예제

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는 객체 ID로 해시하므로 3개의 서로 다른 키를 유지합니다.

예제

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)

key => value 쌍에 대한 ImmutableDict에 새 항목을 만듭니다.

• (key => value) in dict를 사용하여 이 특정 조합이 속성 집합에 있는지 확인합니다.
• get(dict, key, default)를 사용하여 특정 키에 대한 가장 최근 값을 검색합니다.

PersistentDict

PersistentDict는 해시 배열 매핑 트리로 구현된 사전으로, 지속성이 필요한 상황에 최적화되어 있습니다. 각 작업은 이전 것과 분리된 새로운 사전을 반환하지만, 기본 구현은 공간 효율적이며 여러 개의 별도 사전 간에 저장소를 공유할 수 있습니다.

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

collection에 key가 존재하면 해당 매핑을 삭제하고 반환하고, 그렇지 않으면 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> 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)

키-값 쌍의 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> 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> 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

컬렉션 s가 최소 n개의 요소를 위한 용량을 예약하도록 제안합니다. 즉, s에 많은 값을 푸시해야 할 것으로 예상되는 경우, 미리 한 번에 예약함으로써 점진적인 재할당의 비용을 피할 수 있습니다. 이는 성능을 향상시킬 수 있습니다.

first가 true인 경우, 추가 공간은 컬렉션의 시작 전에 예약됩니다. 이렇게 하면 이후의 pushfirst! 호출(대신 push! 사용) 속도가 빨라질 수 있습니다. 이 키워드를 제공하면 컬렉션이 정렬되지 않았거나 pushfirst!가 이 컬렉션에 대해 지원되지 않는 경우 오류가 발생할 수 있습니다.

shrink=true(기본값)인 경우, 현재 용량이 n보다 클 경우 컬렉션의 용량이 줄어들 수 있습니다.

또한 resize!를 참조하십시오.

성능 모델에 대한 노트

sizehint!를 지원하는 타입의 경우,

1. push! 및 append! 메서드는 일반적으로 추가 저장소를 미리 할당할 수 있지만(필수는 아님) 그렇게 할 수 있습니다. Base에 구현된 타입의 경우, 일반적으로 그렇게 하며, 일반적인 사용 사례에 최적화된 휴리스틱을 사용합니다.
2. sizehint!는 이 미리 할당을 제어할 수 있습니다. 다시 말해, 일반적으로 Base의 타입에 대해 그렇게 합니다.
3. empty!는 이러한 종류의 미리 할당을 지원하는 타입에 대해 거의 비용이 들지 않으며(O(1))입니다.

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

배열의 키 유형을 반환합니다. 이는 keys(...)의 결과의 eltype와 같으며, 주로 사전 인터페이스와의 호환성을 위해 제공됩니다.

예제

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

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

keytype(type)

사전 유형의 키 유형을 가져옵니다. eltype와 유사하게 동작합니다.

예제

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

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

배열의 값 유형을 반환합니다. 이는 eltype와 동일하며 주로 사전 인터페이스와의 호환성을 위해 제공됩니다.

예제

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

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) is false
false

julia> NaN in s # isequal(NaN, NaN) is true
true

BitSet([itr])

주어진 반복 가능한 객체에 의해 생성된 정수 Int의 정렬된 집합을 구성하거나 빈 집합을 구성합니다. 비트 문자열로 구현되었으며, 따라서 조밀한 정수 집합을 위해 설계되었습니다. 집합이 희소할 경우(예: 몇 개의 매우 큰 정수를 포함하는 경우) 대신 Set를 사용하십시오.

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

IdSet{T}()는 T 유형의 값에 대해 동등성으로 ===를 사용하여 집합(see Set)을 구성합니다.

아래 예제에서 값들은 모두 isequal이므로 일반 Set에서 덮어씌워집니다. IdSet은 ===로 비교하므로 3개의 서로 다른 값을 보존합니다.

예제

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

모든 인수에서 고유한 요소를 포함하는 객체를 생성합니다.

첫 번째 인수는 반환되는 컨테이너의 종류를 제어합니다. 이것이 배열인 경우, 요소가 처음 나타나는 순서를 유지합니다.

유니코드 ∪는 Julia REPL에서 \cup를 입력한 후 탭을 눌러 입력할 수 있으며, 많은 편집기에서도 가능합니다. 이것은 중위 연산자로, 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...)

모든 인수에 나타나는 요소를 포함하는 집합을 구성합니다.

첫 번째 인수는 반환되는 컨테이너의 종류를 제어합니다. 이것이 배열인 경우, 요소가 처음 나타나는 순서를 유지합니다.

유니코드 ∩는 Julia REPL에서 \cap을 입력한 후 탭을 눌러 입력할 수 있으며, 많은 편집기에서도 가능합니다. 이는 중위 연산자로, s ∩ itr과 같이 사용할 수 있습니다.

또한 setdiff, isdisjoint, issubset, issetequal도 참조하십시오.

예제

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의 각 iterable의 각 요소를 (제자리에서) 제거합니다. 배열로 순서를 유지합니다.

!!! 경고 어떤 변형된 인수가 다른 인수와 메모리를 공유할 때 동작이 예기치 않게 될 수 있습니다.

예시

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

s에 x가 있으면 true를 반환합니다. 그렇지 않으면 x를 s에 추가하고 false를 반환합니다. 이는 in(x, s) ? true : (push!(s, x); false)와 동등하지만, 더 효율적인 구현이 있을 수 있습니다.

참고: in, push!, Set

예제

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)} 유형이며, 이는 특수화된 메서드를 구현하는 데 사용할 수 있습니다.

isdisjoint(a, b) -> Bool

컬렉션 a와 b가 서로 겹치지 않는지 확인합니다. isempty(a ∩ b)와 동등하지만 가능한 경우 더 효율적입니다.

참고: intersect, isempty, issetequal.

예제

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)} 유형이며, 특수화된 메서드를 구현하는 데 사용할 수 있습니다.

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

collection에 key가 존재하면 해당 매핑을 삭제하고 반환하고, 그렇지 않으면 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> 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

collection의 시작 부분에 하나 이상의 items를 삽입합니다.

이 함수는 많은 다른 프로그래밍 언어에서 unshift라고 불립니다.

예제

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

popfirst!(collection) -> item

collection에서 첫 번째 item을 제거합니다.

이 함수는 많은 다른 프로그래밍 언어에서 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)

주어진 index에 item을 a에 삽입합니다. index는 결과적으로 a에서 item의 인덱스입니다.

참고: 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]. 즉, 길이가 같은 벡터 a와 m에 대해 keepat!(a, m)을 사용하면, 해당 인덱스에서 m이 false인 a의 모든 요소가 제거됩니다.

예제

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

항목을 제거하지 않고 인덱스 n 앞에 replacement를 삽입하려면 splice!(collection, n:n-1, replacement)를 사용하세요.

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

지정된 인덱스에서 항목을 제거하고, 제거된 항목을 포함하는 컬렉션을 반환합니다. 이후 항목은 남은 간격을 채우기 위해 왼쪽으로 이동합니다. 지정된 경우, 정렬된 컬렉션의 대체 값이 제거된 항목 대신 삽입됩니다. 이 경우, indices는 AbstractUnitRange여야 합니다.

인덱스 n 앞에 항목을 제거하지 않고 replacement를 삽입하려면 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> 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

개별 항목을 collection에 추가하려면 push!를 사용하세요. 이 항목들은 다른 컬렉션에 이미 포함되어 있지 않아야 합니다. 앞선 예제의 결과는 push!([1, 2, 3], 4, 5, 6)와 동일합니다.

성능 모델에 대한 참고 사항은 sizehint!를 참조하세요.

벡터에 대해서는 vcat, 집합에 대해서는 union!, 반대 순서에 대해서는 prepend! 및 pushfirst!를 참조하세요.

prepend!(a::Vector, collections...) -> collection

각 collections의 요소를 a의 시작 부분에 삽입합니다.

collections가 여러 개의 컬렉션을 지정할 경우, 순서가 유지됩니다: collections[1]의 요소가 a의 가장 왼쪽에 나타나고, 그 다음으로 이어집니다.

예제

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

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

인덱스 가능한 컨테이너를 동일한 데이터의 사전 뷰로 변환합니다. 기본 데이터의 키 공간을 수정하면 이 객체가 무효화될 수 있습니다.