Collections and Data Structures

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

İteratörü bir sonraki öğeyi elde etmek için ilerletin. Eğer hiçbir öğe kalmadıysa, nothing döndürülmelidir. Aksi takdirde, bir sonraki öğe ve yeni iterasyon durumu içeren 2-tuple döndürülmelidir.

IteratorSize(itertype::Type) -> IteratorSize

Bir iteratörün türü verildiğinde, aşağıdaki değerlerden birini döndür:

• SizeUnknown() eğer uzunluk (öğe sayısı) önceden belirlenemiyorsa.
• HasLength() eğer sabit, sonlu bir uzunluk varsa.
• HasShape{N}() eğer bilinen bir uzunluk artı çok boyutlu şekil kavramı varsa (bir dizi gibi). Bu durumda N, boyut sayısını vermeli ve axes fonksiyonu iteratör için geçerlidir.
• IsInfinite() eğer iteratör sonsuza kadar değerler üretiyorsa.

Varsayılan değer (bu fonksiyonu tanımlamayan iteratörler için) HasLength()'dır. Bu, çoğu iteratörün length uyguladığını varsaydığı anlamına gelir.

Bu özellik genellikle sonuçları için alanı önceden ayıran algoritmalar ile sonuçlarını kademeli olarak yeniden boyutlandıran algoritmalar arasında seçim yapmak için kullanılır.

julia> Base.IteratorSize(1:5)
Base.HasShape{1}()

julia> Base.IteratorSize((2,3))
Base.HasLength()

IteratorEltype(itertype::Type) -> IteratorEltype

Bir iteratörün türü verildiğinde, aşağıdaki değerlerden birini döndür:

• EltypeUnknown() eğer iteratör tarafından üretilen elemanların türü önceden bilinmiyorsa.
• HasEltype() eğer eleman türü biliniyorsa ve eltype anlamlı bir değer döndürecekse.

HasEltype() varsayılan değerdir, çünkü iteratörlerin eltype uyguladığı varsayılmaktadır.

Bu özellik genellikle belirli bir sonuç türü önceden tahsis eden algoritmalar ile üretilen değerlerin türlerine dayalı olarak bir sonuç türü seçen algoritmalar arasında seçim yapmak için kullanılır.

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

AbstractRange{T} <: AbstractVector{T}

T türünden elemanlara sahip lineer aralıklar için süper tür. UnitRange, LinRange ve diğer türler bunun alt türleridir.

Tüm alt türler step tanımlamalıdır. Bu nedenle LogRange AbstractRange'in bir alt türü değildir.

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

T türünde elemanlara sahip sıralı aralıklar için süpertip. Adımlar her zaman oneunit tam katları olmalıdır ve T "kesirli" bir tür olmamalıdır; bu tür, oneunit'ten daha küçük değerler alamaz. Örneğin, Integer veya Date türleri uygunken, Float64 uygun değildir (çünkü bu tür, oneunit(Float64)'ten daha küçük değerleri temsil edebilir). UnitRange, StepRange ve diğer türler bunun alt türleridir.

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

Adım boyutu oneunit(T) olan ve T türünde elemanlar içeren aralıklar için süpertip. UnitRange ve diğer türler bunun alt türleridir.

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

T türünde ve S türünde boşlukları olan elemanlarla aralıklar. Her bir eleman arasındaki adım sabittir ve aralık, T türünde bir start ve stop ile S türünde bir step cinsinden tanımlanır. Ne T ne de S kayan nokta türleri olmalıdır. a:b:c sözdizimi, b != 0 ve a, b ve c tümü tam sayılar olduğunda bir StepRange oluşturur.

Örnekler

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<:Gerçek}

start ve stop türünde T ile parametrelenmiş bir aralık, start'tan başlayarak stop aşılana kadar 1 aralıklarla doldurulmuş elemanlarla. a:b sözdizimi, hem a hem de b Tam Sayı olduğunda bir UnitRange oluşturur.

Örnekler

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 ve stop arasında len lineer olarak dağıtılmış elemanlardan oluşan bir aralık. Aralıkların boyutunu kontrol eden len, bir Integer olmalıdır.

Örnekler

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 kullanmaya kıyasla, doğrudan bir LinRange oluşturmak daha az yük getirmelidir ancak kayan nokta hatalarını düzeltmeye çalışmayacaktır:

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

Logaritmik olarak dağıtılmış noktalar için Logrange ile de bakabilirsiniz.

isempty(collection) -> Bool

Bir koleksiyonun boş olup olmadığını belirleyin (hiç elemanı yoksa).

!!! uyarı isempty(itr) bir durum bilgisi olan itr yineleyicisinin bir sonraki elemanını tüketebilir, uygun bir Base.isdone(itr) yöntemi tanımlanmadıkça. Durum bilgisi olan yineleyiciler isdone uygulamalıdır, ancak herhangi bir yineleyici türünü desteklemesi gereken genel kod yazarken isempty kullanmaktan kaçınmak isteyebilirsiniz.

Örnekler

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

Koşul üzerinde bekleyen hiçbir görev yoksa true, aksi takdirde false döner.

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

Bu fonksiyon, yineleyici tamamlanması için hızlı bir yol ipucu sağlar. Bu, kullanıcıya sunulmayacaksa elemanların tüketilmesini önlemek isteyen durumlu yineleyiciler için yararlıdır (örneğin, isempty veya zip içinde tamamlanma kontrolü yaparken).

Bu özelliği kullanmak isteyen durumlu yineleyiciler, yineleyicinin tamamlanıp tamamlanmadığına bağlı olarak doğru/yanlış döndüren bir isdone yöntemi tanımlamalıdır. Durumsuz yineleyicilerin bu fonksiyonu uygulaması gerekmez.

Sonuç missing ise, çağıranlar kesin bir cevap elde etmek için iterate(x, state) === nothing hesaplamaya devam edebilir.

Ayrıca bkz. iterate, isempty

empty!(koleksiyon) -> koleksiyon

Bir koleksiyondan tüm elemanları kaldırın.

Örnekler

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)

Bir Kanal c'yi içsel tampon üzerinde empty! çağrısı yaparak boşaltın. Boş kanalı döndürün.

length(collection) -> Tam sayı

Koleksiyondaki eleman sayısını döndürür.

İndekslenebilir bir koleksiyonun son geçerli indeksini almak için lastindex kullanın.

Ayrıca bakınız: size, ndims, eachindex.

Örnekler

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)'yi hesaplar, ancak sonuç Union{Integer(eltype(r)),Int} içine sığmadığında, uygun olduğunda taşma hatalarını kontrol edebilir.

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

Bir öğenin verilen koleksiyonda olup olmadığını belirleyin; bu, öğenin koleksiyonu iterasyona tabi tutarak üretilen değerlerden biriyle == eşit olduğu anlamına gelir. Bir Bool değeri döndürün, ancak item missing ise veya collection item hariç missing içeriyorsa, bu durumda missing döndürülür (üç değerli mantık, any ve == işlevinin davranışını yansıtır).

Bazı koleksiyonlar biraz farklı bir tanıma sahiptir. Örneğin, Setler öğenin elemanlardan biriyle isequal olup olmadığını kontrol eder; Dictler key=>value çiftlerini arar ve key isequal kullanılarak karşılaştırılır.

Bir sözlükte bir anahtarın varlığını test etmek için haskey veya k in keys(dict) kullanın. Yukarıda bahsedilen koleksiyonlar için sonuç her zaman bir Bool'dur.

in.(items, collection) veya items .∈ collection ile yayılma (broadcasting) yaparken, hem item hem de collection üzerinde yayılma yapılır; bu genellikle istenen bir durum değildir. Örneğin, her iki argüman da vektörse (ve boyutlar eşleşiyorsa), sonuç, items koleksiyonundaki her değerin collection'daki karşılık gelen pozisyondaki değerde in olup olmadığını belirten bir vektördür. items'deki her değerin collection'da olup olmadığını belirten bir vektör almak için collection'ı bir demet (tuple) veya Ref içine sarın; şöyle: in.(items, Ref(collection)) veya items .∈ Ref(collection).

Ayrıca bakınız: ∉, insorted, contains, occursin, issubset.

Örnekler

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

∉(öğe, koleksiyon) -> Bool
∌(koleksiyon, öğe) -> Bool

∈ ve ∋'nin olumsuzlaması, yani öğenin koleksiyonda olmadığını kontrol eder.

items .∉ koleksiyon ile yayılma (broadcasting) yapıldığında, hem öğe hem de koleksiyon yayılır, bu genellikle istenen bir durum değildir. Örneğin, her iki argüman da vektörse (ve boyutlar eşleşiyorsa), sonuç, items koleksiyonundaki her değerin koleksiyondaki karşılık gelen pozisyondaki değerde olmadığını belirten bir vektördür. items'in koleksiyonda olmadığını belirten bir vektör almak için, koleksiyonu bir demet (tuple) veya Ref içine sarın, şöyle: items .∉ Ref(koleksiyon).

Örnekler

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 içinde x ∈ collection hesaplamasının "hızlı" bir işlem olarak kabul edilip edilemeyeceğini belirleyin (tipik olarak sabit veya logaritmik karmaşıklık). hasfastin(x) = hasfastin(typeof(x)) tanımı, örneklerin türler yerine geçebilmesi için kolaylık sağlamak amacıyla verilmiştir. Ancak, tür argümanı kabul eden form yeni türler için tanımlanmalıdır.

hasfastin(T) için varsayılan değer, AbstractSet, AbstractDict ve AbstractRange alt türleri için true ve aksi takdirde false'dır.

eltype(type)

Verilen type türündeki bir koleksiyonu iterasyona tabi tutarak üretilen elemanların türünü belirler. Sözlük türleri için bu, bir Pair{KeyType,ValType} olacaktır. eltype(x) = eltype(typeof(x)) tanımı, türler yerine örneklerin geçilebilmesi için kolaylık sağlamak amacıyla verilmiştir. Ancak, bir tür argümanı kabul eden form yeni türler için tanımlanmalıdır.

Ayrıca bakınız: keytype, typeof.

Örnekler

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

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

indexin(a, b)

b içinde bir üye olan a'daki her değer için b'deki ilk indeksi içeren bir dizi döndürür. Çıktı dizisi, a'nın b'nin bir üyesi olmadığı yerlerde nothing içerir.

Ayrıca bakınız: sortperm, findfirst.

Örnekler

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)

Koleksiyon itr'nin yalnızca benzersiz elemanlarını içeren bir dizi döndürür; bu elemanlar isequal ve hash tarafından belirlenir ve her bir eşdeğer eleman setinin ilk ortaya çıktığı sıraya göre sıralanır. Girişin eleman türü korunur.

Ayrıca bkz: unique!, allunique, allequal.

Örnekler

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'den elde edilen her benzersiz değer için f uygulanarak bir değer içeren bir dizi döndürür.

Örnekler

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

Bu işlevsellik, bir dizideki benzersiz elemanların ilk oluşumlarının indekslerini çıkarmak için de kullanılabilir:

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'nın dims boyutu boyunca benzersiz bölgelerini döndürür.

Örnekler

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'dan f uygulanarak üretilen her benzersiz değer için A'dan bir değer seçer ve ardından değiştirilmiş A'yı döndürür.

Örnekler

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 ve hash tarafından belirlenen tekrar eden öğeleri kaldırın, ardından değiştirilmiş A'yı döndürün. unique!, A'nın öğelerini meydana geldikleri sırayla döndürecektir. Eğer döndürülen verinin sırası ile ilgilenmiyorsanız, (sort!(A); unique!(A)) çağrısı, A'nın öğeleri sıralanabiliyorsa çok daha verimli olacaktır.

Örnekler

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! sıralı verileri çok daha verimli bir şekilde işleyebilir.

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

allunique(itr) -> Bool
allunique(f, itr) -> Bool

itr'den tüm değerlerin isequal ile karşılaştırıldığında farklı olması durumunda true döner. İkinci yöntem için ise [f(x) for x in itr]'nin tüm elemanlarının farklı olması durumunda true döner.

allunique(f, itr)'nin length(itr) kadar çağrılmayabileceğini unutmayın. Çağrıların kesin sayısı bir uygulama detayı olarak kabul edilir.

allunique, girdi sıralı olduğunda özel bir uygulama kullanabilir.

Ayrıca bakınız: unique, issorted, allequal.

Örnekler

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'den alınan tüm değerler isequal ile karşılaştırıldığında eşitse true döner. İkinci yöntem içinse, [f(x) for x in itr]'nin tüm elemanları eşitse.

allequal(f, itr)'nin f'yi length(itr) kadar çağırmayabileceğini unutmayın. Çağrıların kesin sayısı bir uygulama detayı olarak kabul edilir.

Ayrıca bakınız: unique, allunique.

Örnekler

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

Verilen koleksiyonu itr verilen ikili operatör op ile azaltın. Eğer sağlanmışsa, başlangıç değeri init op için nötr bir eleman olmalı ve boş koleksiyonlar için döndürülmelidir. init'in boş olmayan koleksiyonlar için kullanılıp kullanılmayacağı belirsizdir.

Boş koleksiyonlar için, init sağlamak gerekli olacaktır, bazı özel durumlar dışında (örneğin, op +, *, max, min, &, |'den biri olduğunda) Julia op'nin nötr elemanını belirleyebilir.

Belirli yaygın kullanılan operatörler için azaltmaların özel uygulamaları olabilir ve bunun yerine kullanılmalıdır: maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr). Belirli dizi dizilerini birleştirmek için reduce(vcat, arr) veya reduce(hcat, arr) çağrısını yaparak verimli yöntemler vardır.

Azaltmanın birleşim özelliği uygulamaya bağlıdır. Bu, - gibi birleşim özelliği taşımayan işlemleri kullanamayacağınız anlamına gelir çünkü reduce(-,[1,2,3])'ün (1-2)-3 veya 1-(2-3) olarak değerlendirilip değerlendirilmeyeceği belirsizdir. Garantili soldan veya sağdan birleşim özelliği için foldl veya foldr kullanın.

Bazı işlemler hata biriktirir. Paralellik, azaltmanın gruplar halinde yürütülmesi daha kolay olursa daha kolay olacaktır. Julia'nın gelecekteki sürümleri algoritmayı değiştirebilir. Sıralı bir koleksiyon kullanıyorsanız, elemanlar yeniden sıralanmaz.

Örnekler

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

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

reduce(f, A::AbstractArray; dims=:, [init])

A'n boyutları boyunca f 2-argümanlı fonksiyonunu azalt. dims, azaltılacak boyutları belirten bir vektördür ve init anahtar kelime argümanı, azaltmalarda kullanılacak başlangıç değeridir. +, *, max ve min için init argümanı isteğe bağlıdır.

Azaltmanın birleşim özelliği uygulamaya bağlıdır; belirli bir birleşim özelliğine ihtiyacınız varsa, örneğin soldan sağa, kendi döngünüzü yazmalısınız veya foldl veya foldr kullanmayı düşünmelisiniz. reduce için belgeleri inceleyin.

Örnekler

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 ile benzer, ancak sol birleştirmenin garantisi vardır. Sağlanan takdirde, init anahtar kelime argümanı tam olarak bir kez kullanılacaktır. Genel olarak, boş koleksiyonlarla çalışmak için init sağlamanız gerekecektir.

Ayrıca bkz. mapfoldl, foldr, accumulate.

Örnekler

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 ile benzer, ancak sağdan birleştirme garantisi vardır. Sağlanan init anahtar kelime argümanı tam olarak bir kez kullanılacaktır. Genel olarak, boş koleksiyonlarla çalışmak için init sağlamak gerekecektir.

Örnekler

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

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

maximum(f, itr; [init])

Herhangi bir itr elemanında f fonksiyonunu çağırarak elde edilen en büyük sonucu döndürür.

Boş itr için döndürülen değer init ile belirtilebilir. Bu, max için nötr bir eleman olmalıdır (yani, diğer herhangi bir elemandan küçük veya ona eşit olmalıdır) çünkü init'in boş olmayan koleksiyonlar için kullanılıp kullanılmayacağı belirtilmemiştir.

Örnekler

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

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

julia> maximum(sin, Real[]; init=-1.0)  # iyi, çünkü sin'in çıktısı >= -1
-1.0

maximum(itr; [init])

Bir koleksiyondaki en büyük öğeyi döndürür.

Boş itr için döndürülen değer init ile belirtilebilir. Bu, max için nötr bir eleman olmalıdır (yani, diğer herhangi bir elemandan küçük veya ona eşit olmalıdır) çünkü init'in boş olmayan koleksiyonlar için kullanılıp kullanılmayacağı belirtilmemiştir.

Örnekler

julia> maximum(-20.5:10)
9.5

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

julia> maximum(())
HATA: ArgumentError: boş bir koleksiyon üzerinde azaltma yapmak izin verilmez; azaltıcıya `init` sağlamayı düşünün
Yığın izi:
[...]

julia> maximum((); init=-Inf)
-Inf

maximum(A::AbstractArray; dims)

Verilen boyutlar üzerinde bir dizinin maksimum değerini hesaplayın. İki veya daha fazla argümanın maksimumunu almak için max(a,b) fonksiyonuna da bakın; bu, dizilere max.(a,b) ile eleman bazında uygulanabilir.

Ayrıca bakınız: maximum!, extrema, findmax, argmax.

Örnekler

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)

Verilen boyutlar üzerinde bir dizi içindeki her bir eleman için f fonksiyonunu çağırarak maksimum değeri hesaplayın.

Örnekler

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'nın r'nin tekil boyutları üzerindeki maksimum değerini hesaplayın ve sonuçları r'ye yazın.

!!! uyarı Herhangi bir değiştirilmiş argümanın, başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

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

Herhangi bir itr elemanında f fonksiyonunu çağırarak elde edilen en küçük sonucu döndürür.

Boş itr için döndürülen değer init ile belirtilebilir. Bu, min için nötr bir eleman olmalıdır (yani, diğer herhangi bir elemandan büyük veya ona eşit olmalıdır) çünkü init'in boş olmayan koleksiyonlar için kullanılıp kullanılmayacağı belirtilmemiştir.

Örnekler

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

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

julia> minimum(sin, Real[]; init=1.0)  # iyi, çünkü sin'in çıktısı <= 1
1.0

minimum(itr; [init])

Bir koleksiyondaki en küçük öğeyi döndürür.

Boş itr için döndürülen değer init ile belirtilebilir. Bu, min için nötr bir eleman olmalıdır (yani, diğer herhangi bir elemandan büyük veya ona eşit olmalıdır) çünkü init'in boş olmayan koleksiyonlar için kullanılıp kullanılmayacağı belirsizdir.

Örnekler

julia> minimum(-20.5:10)
-20.5

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

julia> minimum([])
HATA: ArgumentError: boş bir koleksiyon üzerinde azaltma yapmak mümkün değildir; azaltıcıya `init` sağlamayı düşünün
Stacktrace:
[...]

julia> minimum([]; init=Inf)
Inf

minimum(A::AbstractArray; dims)

Verilen boyutlar üzerinde bir dizinin minimum değerini hesaplar. İki veya daha fazla argümanın minimumunu almak için min(a,b) fonksiyonuna da bakın; bu, dizilere min.(a,b) ile eleman bazında uygulanabilir.

Ayrıca bakınız: minimum!, extrema, findmin, argmin.

Örnekler

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)

Verilen boyutlar üzerinde bir dizi içindeki her bir eleman üzerinde f fonksiyonunu çağırarak minimum değeri hesaplar.

Örnekler

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'nın r'nin tekil boyutları üzerindeki minimum değerini hesaplayın ve sonuçları r'ye yazın.

!!! uyarı Herhangi bir değiştirilmiş argümanın başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

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)

Tek bir geçişte hem minimum mn hem de maksimum mx öğesini hesaplayın ve bunları 2-tuple olarak döndürün.

Boş itr için döndürülen değer init ile belirtilebilir. Bu, min ve max için nötr öğeler olan bir 2-tuple olmalıdır (yani, diğer herhangi bir öğeden büyük/küçük veya eşit olan). Sonuç olarak, itr boş olduğunda döndürülen (mn, mx) tuple'ı mn ≥ mx koşulunu sağlayacaktır. init belirtildiğinde, boş olmayan itr için bile kullanılabilir.

Örnekler

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)

itr'deki her bir elemana uygulanan f'nin hem minimum mn hem de maksimum mx değerlerini hesaplayın ve bunları 2-tuple olarak döndürün. itr üzerinde yalnızca bir geçiş yapılır.

Boş itr için döndürülen değer init ile belirtilebilir. Bu, min ve max için nötr elemanlar olan bir 2-tuple olmalıdır (yani, diğer herhangi bir elemandan büyük/küçük veya eşit olan). Bu, boş olmayan koleksiyonlar için kullanılır. Not: Bu, boş itr için döndürülen değerin (mn, mx)'nin mn ≥ mx koşulunu sağladığını, oysa boş olmayan itr için mn ≤ mx koşulunu sağladığını ima eder. Bu "paradoksal" ama yine de beklenen bir sonuçtur.

Örnekler

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

julia> extrema(sin, Real[]; init = (1.0, -1.0))  # iyi, çünkü -1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)

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

Verilen boyutlar üzerinde bir dizinin minimum ve maksimum elemanlarını hesaplar.

Ayrıca bakınız: minimum, maximum, extrema!.

Örnekler

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}

Verilen boyutlardaki A'nın her bir elemanına uygulanan f'nin minimum ve maksimumunu hesaplar.

extrema!(r, A)

A'nın r'nin tekil boyutları üzerindeki minimum ve maksimum değerini hesaplayın ve sonuçları r'ye yazın.

!!! uyarı Herhangi bir değiştirilmiş argümanın başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

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)

Aralıklar birden fazla maksimum elemana sahip olabilir. Bu durumda argmax maksimum bir indeks döndürecektir, ancak mutlaka ilk olanı değil.

argmax(f, domain)

f(x)'in maksimize edildiği domain'den bir değer x döndürür. Eğer f(x) için birden fazla maksimum değer varsa, ilki bulunacaktır.

domain boş olmayan bir iterable olmalıdır.

Değerler isless ile karşılaştırılır.

Ayrıca bkz. argmin, findmax.

Örnekler

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

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

argmax(itr)

Bir koleksiyondaki en büyük elemanın indeksini veya anahtarını döndürür. Eğer birden fazla en büyük eleman varsa, ilk olanı döndürülür.

Koleksiyon boş olmamalıdır.

İndeksler, keys(itr) ve pairs(itr) tarafından döndürülenlerle aynı türdendir.

Değerler isless ile karşılaştırılır.

Ayrıca bakınız: argmin, findmax.

Örnekler

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

Bir dizi girişi için, verilen boyutlar üzerindeki maksimum elemanların indekslerini döndürün. NaN, diğer tüm değerlerden (istisna: missing) daha büyük olarak kabul edilir.

Örnekler

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)

Aralıklar birden fazla minimal elemana sahip olabilir. Bu durumda argmin, minimal bir indeks döndürecektir, ancak mutlaka ilk olanı değil.

argmin(f, domain)

f(x)'in en küçük olduğu domain'den bir değer x döndürür. Eğer f(x) için birden fazla en küçük değer varsa, ilki bulunacaktır.

domain boş olmayan bir yineleyici olmalıdır.

NaN, missing hariç tüm diğer değerlerden daha küçük olarak kabul edilir.

Ayrıca bkz. argmax, findmin.

Örnekler

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)

Bir koleksiyondaki en küçük elemanın indeksini veya anahtarını döndürür. Eğer birden fazla en küçük eleman varsa, ilk olanı döndürülür.

Koleksiyon boş olmamalıdır.

İndeksler, keys(itr) ve pairs(itr) tarafından döndürülenlerle aynı türdedir.

NaN, missing hariç tüm diğer değerlerden daha küçük olarak kabul edilir.

Ayrıca bakınız: argmax, findmin.

Örnekler

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

Bir dizi girişi için, verilen boyutlar üzerinde minimum elemanların indekslerini döndürün. NaN, missing hariç tüm diğer değerlerden daha küçük olarak kabul edilir.

Örnekler

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)

Bir değer çiftini döndürür; bu değer, f'nin kodomaininde (çıkışları) ve domain'deki (girişleri) karşılık gelen değerin indeksini veya anahtarını içerir, böylece f(x) maksimize edilir. Birden fazla maksimum nokta varsa, ilk olanı döndürülecektir.

domain, keys destekleyen boş olmayan bir iterable olmalıdır. İndeksler, keys(domain) tarafından döndürülenlerle aynı türdedir.

Değerler isless ile karşılaştırılır.

Örnekler

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)

Koleksiyon itr'nin en büyük elemanını ve indeksini veya anahtarını döndürür. Eğer birden fazla en büyük eleman varsa, ilk olanı döndürülür. Değerler isless ile karşılaştırılır.

İndeksler, keys(itr) ve pairs(itr) tarafından döndürülenlerle aynı türdendir.

Ayrıca bakınız: findmin, argmax, maximum.

Örnekler

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)

Bir dizi girişi için, verilen boyutlar üzerinde maksimumun değerini ve indeksini döndürür. NaN, diğer tüm değerlerden (boş değerler hariç) daha büyük olarak kabul edilir.

Örnekler

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)

Bir dizi girişi için, verilen boyutlar üzerinde f'yi maksimize eden karşılık gelen değerin kodomandaki değerini ve indeksini döndürür.

Örnekler

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)

Bir değer çiftini döndürür; bu değer, f'nin kodomaininde (çıkışları) ve f'ye karşılık gelen değerin domain'deki (girişleri) indeks veya anahtarıdır, böylece f(x) en aza indirilir. Birden fazla minimal nokta varsa, ilk olanı döndürülecektir.

domain boş olmayan bir iterable olmalıdır.

İndeksler, keys(domain) ve pairs(domain) tarafından döndürülenlerle aynı türdedir.

NaN, missing hariç tüm diğer değerlerden daha küçük olarak kabul edilir.

Örnekler

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)

Koleksiyon itr'nin en küçük elemanını ve indeksini veya anahtarını döndürür. Eğer birden fazla en küçük eleman varsa, ilk olanı döndürülür. NaN, missing hariç tüm diğer değerlerden daha küçük olarak kabul edilir.

İndeksler, keys(itr) ve pairs(itr) tarafından döndürülenlerle aynı türdedir.

Ayrıca bakınız: findmax, argmin, minimum.

Örnekler

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)

Bir dizi girişi için, verilen boyutlar üzerinde minimumun değerini ve indeksini döndürür. NaN, missing hariç tüm diğer değerlerden daha küçük olarak kabul edilir.

Örnekler

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)

Dizi girişi için, verilen boyutlar üzerinde f'yi minimize eden karşılık gelen değerin kodomainedeki değerini ve indeksini döndürür.

Örnekler

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'nın maksimumunu ve rval ve rind'eki karşılık gelen lineer indeksleri bulur ve sonuçları rval ve rind'e kaydeder. NaN, missing hariç tüm diğer değerlerden daha büyük olarak kabul edilir.

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

A'n minimum'unu ve rval ve rind'in tekil boyutları boyunca karşılık gelen lineer indeksini bulur ve sonuçları rval ve rind'e kaydeder. NaN, missing hariç tüm diğer değerlerden daha küçük olarak kabul edilir.

!!! uyarı Herhangi bir değiştirilmiş argümanın, başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

sum(f, itr; [init])

itr'nin her bir elemanında f fonksiyonunu çağırmanın sonuçlarını toplayın.

Dönüş tipi, sistem kelime boyutundan daha küçük işaretli tam sayılar için Int, işaretsiz tam sayılar için ise UInt'dir. Tüm diğer argümanlar için, tüm argümanların terfi ettirildiği ortak bir dönüş tipi bulunur.

Boş itr için döndürülecek değer init ile belirtilebilir. Bu, toplama kimliği (yani sıfır) olmalıdır çünkü init'in boş olmayan koleksiyonlar için kullanılıp kullanılmadığı belirtilmemiştir.

Örnekler

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

Küçük tam sayı el tipi olan diziler için sum(A) ve reduce(+, A) arasındaki önemli farkı not edin:

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

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

İlk durumda, tam sayılar sistem kelime boyutuna genişletilir ve bu nedenle sonuç 128'dir. İkincisinde, böyle bir genişletme gerçekleşmez ve tam sayı taşması -128 sonucunu verir.

sum(itr; [init])

Bir koleksiyondaki tüm elemanların toplamını döndürür.

Dönüş tipi, sistem kelime boyutundan daha küçük işaretli tam sayılar için Int, işaretsiz tam sayılar için ise UInt'dir. Diğer tüm argümanlar için, tüm argümanların terfi ettirildiği ortak bir dönüş tipi bulunur.

Boş itr için döndürülen değer init ile belirtilebilir. Bu, toplama kimliği (yani sıfır) olmalıdır çünkü init'in boş olmayan koleksiyonlar için kullanılıp kullanılmadığı belirtilmemiştir.

Ayrıca bakınız: reduce, mapreduce, count, union.

Örnekler

julia> sum(1:20)
210

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

sum(A::AbstractArray; dims)

Verilen boyutlar üzerinde bir dizinin elemanlarını toplayın.

Örnekler

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)

Bir dizinin her bir elemanına f fonksiyonunu çağırarak elde edilen sonuçları verilen boyutlar üzerinde toplayın.

Örnekler

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'nın elemanlarını r'nin tekil boyutları boyunca toplayın ve sonuçları r'ye yazın.

!!! uyarı Herhangi bir değiştirilmiş argümanın, başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

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'deki her bir elemana uygulanan f'nin çarpımını döndürür.

Dönüş tipi, sistem kelime boyutundan daha küçük işaretli tam sayılar için Int, işaretsiz tam sayılar için ise UInt'dir. Tüm diğer argümanlar için, tüm argümanların terfi ettirildiği ortak bir dönüş tipi bulunur.

Boş itr için döndürülen değer init ile belirtilebilir. Bu, çarpan kimliği (yani bir) olmalıdır çünkü init'in boş olmayan koleksiyonlar için kullanılıp kullanılmadığı belirtilmemiştir.

Örnekler

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

prod(itr; [init])

Bir koleksiyonun tüm elemanlarının çarpımını döndürür.

Dönüş tipi, sistem kelime boyutundan daha küçük işaretli tam sayılar için Int, işaretsiz tam sayılar için ise UInt'dir. Diğer tüm argümanlar için, tüm argümanların terfi ettirildiği ortak bir dönüş tipi bulunur.

Boş itr için döndürülen değer init ile belirtilebilir. Bu, çarpan kimliği (yani bir) olmalıdır, çünkü init'in boş olmayan koleksiyonlar için kullanılıp kullanılmadığı belirtilmemiştir.

Ayrıca bakınız: reduce, cumprod, any.

Örnekler

julia> prod(1:5)
120

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

prod(A::AbstractArray; dims)

Verilen boyutlar üzerinde bir dizinin elemanlarını çarpın.

Örnekler

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)

Verilen boyutlar üzerinde bir dizinin her bir elemanına f fonksiyonunu çağırarak elde edilen sonuçları çarpın.

Örnekler

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'nın elemanlarını r'nin tekil boyutları boyunca çarpın ve sonuçları r'ye yazın.

!!! uyarı Herhangi bir değiştirilmiş argümanın, başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

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

Bir boolean koleksiyonundaki herhangi bir elemanın true olup olmadığını test eder, itr içinde ilk true değeri bulunduğunda true döner (kısa devre). false üzerinde kısa devre yapmak için all kullanın.

Girdi missing değerleri içeriyorsa, tüm eksik olmayan değerler false ise (veya eşdeğer olarak, girdi true değeri içermiyorsa) missing döner, üç değerli mantık izlenir.

Ayrıca bakınız: all, count, sum, |, , ||.

Örnekler

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

itr'deki herhangi bir öğe için p'nin true döndürüp döndürmediğini belirleyin, p'nin true döndürdüğü itr'deki ilk öğe ile karşılaşıldığında true döndürerek (kısa devre). false için kısa devre yapmak için all kullanın.

Girdi missing değerleri içeriyorsa, tüm eksik olmayan değerler false ise (veya eşdeğer olarak, girdi true değeri içermiyorsa) missing döndürün, üç değerli mantık izleyerek.

Örnekler

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 içindeki herhangi bir değerin r'nin tekil boyutları boyunca true olup olmadığını test eder ve sonuçları r'ye yazar.

!!! uyarı Herhangi bir değiştirilmiş argümanın, başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

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

Bir boolean koleksiyonundaki tüm elemanların true olup olmadığını test eder, itr içinde ilk false değeri ile karşılaşıldığında false döner (kısa devre). true üzerinde kısa devre yapmak için any kullanın.

Girdi missing değerleri içeriyorsa, tüm eksik olmayan değerler true ise (veya eşdeğer olarak, girdi false değeri içermiyorsa) missing döner, üç değerli mantık izlenir.

Ayrıca bakınız: all!, any, count, &, , &&, allunique.

Örnekler

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

itr'deki tüm elemanlar için p'nin true döndürüp döndürmediğini belirleyin, p'nin false döndürdüğü ilk öğe ile karşılaşıldığında false döndürerek (kısa devre). true için kısa devre yapmak için any kullanın.

Girdi missing değerleri içeriyorsa, tüm eksik olmayan değerler true ise (veya eşdeğer olarak, girdi false değeri içermiyorsa) missing döndürün, üç değerli mantık izleyerek.

Örnekler

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 içindeki tüm değerlerin r'nin tekil boyutları boyunca true olup olmadığını test eder ve sonuçları r'ye yazar.

Örnekler

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 içinde f fonksiyonunun true döndürdüğü elemanların sayısını sayar. f atlandığında, itr içindeki true elemanların sayısını sayar (bu, boolean değerlerden oluşan bir koleksiyon olmalıdır). init isteğe bağlı olarak saymaya başlanacak değeri belirtir ve dolayısıyla çıktı türünü de belirler.

Ayrıca bakınız: any, sum.

Örnekler

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 için string içinde eşleşme sayısını döndürür. Bu, length(findall(pattern, string)) çağrısına eşdeğerdir ancak daha verimlidir.

Eğer overlap=true ise, eşleşen diziler orijinal string içinde indeksleri örtüşecek şekilde izin verilir, aksi takdirde ayrı karakter aralıklarından olmalıdır.

Örnekler

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 içindeki f'nin true döndürdüğü elemanların sayısını verilen boyutlar üzerinde sayar.

Örnekler

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...) -> Hiçbir şey

Fonksiyon f'yi iterable c'nin her bir elemanı üzerinde çağırır. Birden fazla iterable argümanı için, f eleman bazında çağrılır ve herhangi bir iterator bittiğinde iterasyon durur.

foreach, f'nin sonuçlarının gerekli olmadığı durumlarda map yerine kullanılmalıdır; örneğin foreach(println, array).

Örnekler

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, " ile ", y), tri, 'a':'z')
1 ile a
4 ile b
7 ile c

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

Koleksiyon c'yi her bir elemana f uygulayarak dönüştür. Birden fazla koleksiyon argümanı için, f'yi eleman bazında uygula ve herhangi biri tükenene kadar dur.

Ayrıca bkz. map!, foreach, mapreduce, mapslices, zip, Iterators.map.

Örnekler

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

Aynı ndims boyutlarına sahip çok boyutlu diziler üzerinde işlem yaparken, hepsinin aynı axes boyutlarına sahip olması gerekir ve sonuç da öyle olacaktır.

Ayrıca, boyutları uyuşmayan dizilere izin veren broadcast fonksiyonuna da bakın.

Örnekler

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

julia> map(+, [1 2; 3 4], zeros(2,1))
HATA: BoyutUyumsuzluğu

julia> map(+, [1 2; 3 4], [1,10,100,1000], zeros(3,1))  # 3. dizi tükenene kadar iterasyon yapar
3-elemanlı Vektör{Float64}:
   2.0
  13.0
 102.0

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

map gibi, ancak sonucu yeni bir koleksiyona değil destination'a kaydeder. destination, en küçük koleksiyon kadar büyük olmalıdır.

Ayrıca bakınız: map, foreach, zip, copyto!.

Örnekler

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'i val'dan f(val)'e dönüştürerek değiştirir. dict'in türünün değiştirilemeyeceğini unutmayın: eğer f(val) dict'in değer türünün bir örneği değilse, mümkünse değer türüne dönüştürülecek ve aksi takdirde bir hata verecektir.

Örnekler

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

Fonksiyonu f'yi itrs içindeki her bir eleman(lar)a uygular ve ardından sonucu ikili fonksiyon op ile azaltır. Eğer sağlanmışsa, init op için nötr bir eleman olmalı ve boş koleksiyonlar için döndürülmelidir. init'in boş olmayan koleksiyonlar için kullanılıp kullanılmadığı belirsizdir. Genel olarak, boş koleksiyonlarla çalışmak için init sağlamak gerekecektir.

mapreduce fonksiyonel olarak reduce(op, map(f, itr); init=init) çağrısına eşdeğerdir, ancak genellikle daha hızlı çalışır çünkü ara bir koleksiyon oluşturulmasına gerek yoktur. reduce ve map için belgeleri inceleyin.

Örnekler

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

Azaltmanın birleşim özelliği uygulamaya bağlıdır. Ayrıca, bazı uygulamalar itr içinde birden fazla kez görünen elemanlar için f'nin döndürdüğü değeri yeniden kullanabilir. Her değer için f'nin çağrılmasını garanti etmek ve soldan veya sağdan birleşim özelliği için mapfoldl veya mapfoldr kullanın.

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

mapreduce ile benzer, ancak foldl gibi sol birleştirmenin garantisi vardır. Eğer sağlanmışsa, anahtar kelime argümanı init tam olarak bir kez kullanılacaktır. Genel olarak, boş koleksiyonlarla çalışmak için init sağlamanız gerekecektir.

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

foldr gibi, ancak sağdan birleştirme garantisi ile, mapreduce gibi. Eğer sağlanırsa, anahtar kelime argümanı init tam olarak bir kez kullanılacaktır. Genel olarak, boş koleksiyonlarla çalışmak için init sağlamanız gerekecektir.

first(coll)

Bir yineleyici koleksiyonun ilk öğesini alır. Boş olsa bile bir AbstractRange başlangıç noktasını döndürür.

Ayrıca bakınız: only, firstindex, last.

Örnekler

julia> first(2:2:10)
2

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

first(itr, n::Integer)

İterable koleksiyon itr'nin ilk n elemanını alır veya itr yeterince uzun değilse daha az eleman alır.

Ayrıca bakınız: startswith, Iterators.take.

Örnekler

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'ninci n karakterden oluşan bir dize döndürür.

Örnekler

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

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

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

last(coll)

Sıralı bir koleksiyonun son elemanını alır, eğer O(1) zamanında hesaplanabiliyorsa. Bu, son indeksi almak için lastindex çağrılarak gerçekleştirilir. Boş olsa bile bir AbstractRange son noktasını döndürür.

Ayrıca first, endswith ile de bakabilirsiniz.

Örnekler

julia> last(1:2:10)
9

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

last(itr, n::Integer)

İterable koleksiyon itr'nin son n elemanını alır veya itr yeterince uzun değilse daha az eleman alır.

Örnekler

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'nin son n karakterinden oluşan bir dize alır.

Örnekler

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

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

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

front(x::Tuple)::Tuple

x'in son bileşeni hariç tüm bileşenlerini içeren bir Tuple döndürür.

Ayrıca bkz: first, tail.

Örnekler

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

julia> Base.front(())
HATA: ArgumentError: Boş bir tuple üzerinde front çağrısı yapılamaz.

tail(x::Tuple)::Tuple

x'in ilk bileşeni hariç tüm bileşenlerini içeren bir Tuple döndürür.

Ayrıca bakınız: front, rest, first, Iterators.peel.

Örnekler

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

julia> Base.tail(())
HATA: ArgumentError: Boş bir tuple üzerinde tail çağrısı yapılamaz.

step(r)

Bir AbstractRange nesnesinin adım boyutunu alır.

Örnekler

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)

Bir koleksiyondan veya iteratörden tüm öğelerin bir Array'ini döndürür. Sözlükler için, key=>value Pair çiftlerinin bir Vector'ını döndürür. Argüman dizi benzeri veya HasShape özelliğine sahip bir iteratör ise, sonuç argümanla aynı şekle ve boyut sayısına sahip olacaktır.

Comprehensions tarafından bir generator expression 'ı bir Array'e dönüştürmek için kullanılır. Bu nedenle, generator'lar üzerinde, collect çağırmak yerine köşeli parantez notasyonu kullanılabilir, ikinci örneğe bakın.

Örnekler

Bir UnitRange{Int64} koleksiyonundan öğeleri toplayın:

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

Bir generator'dan öğeleri toplayın (aynı çıktı [x^2 for x in 1:3] ile):

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

collect(element_type, collection)

Verilen eleman türüne sahip bir Array döndürür, bu da bir koleksiyondaki veya yineleyicideki tüm öğeleri içerir. Sonuç, collection ile aynı şekle ve boyut sayısına sahiptir.

Örnekler

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

filter(f, a)

f'nin false olduğu elemanları çıkararak a koleksiyonunun bir kopyasını döndürür. f fonksiyonuna bir argüman geçirilir.

Ayrıca bakınız: filter!, Iterators.filter.

Örnekler

julia> a = 1:10
1:10

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

filter(f)

f fonksiyonunu kullanarak argümanlarını filtreleyen bir fonksiyon oluşturun, yani x -> filter(f, x) fonksiyonuna eşdeğer bir fonksiyon.

Dönen fonksiyon Base.Fix1{typeof(filter)} türündedir ve özel yöntemler uygulamak için kullanılabilir.

Örnekler

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'nin false olduğu elemanları kaldırarak d'nin bir kopyasını döndürür. f fonksiyonuna key=>value çiftleri geçirilir.

Örnekler

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

Verilen SkipMissing iteratörü tarafından sarılmış diziye benzer bir vektör döndürür, ancak tüm eksik öğeler ve f'nin false döndürdüğü öğeler kaldırılır.

Örnekler

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)

Koleksiyonu a güncelleyin, f'nin false olduğu elemanları kaldırın. f fonksiyonuna bir argüman geçilir.

Örnekler

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

filter!(f, d::AbstractDict)

d'yi güncelleyin, f'nin false olduğu elemanları kaldırın. f fonksiyonu anahtar=>değer çiftlerini alır.

Örnekler

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

Koleksiyonu A'nın bir kopyasını döndürür; burada, old=>new çiftlerinden her biri için, old'un tüm örnekleri new ile değiştirilir. Eşitlik isequal kullanılarak belirlenir. Eğer count belirtilmişse, o zaman toplamda en fazla count örneği değiştirilir.

Sonucun eleman tipi, A'nın eleman tipi ve çiftlerdeki new değerlerinin tiplerine dayanarak terfi kullanılarak seçilir (bkz. promote_type). Eğer count atlanırsa ve A'nın eleman tipi bir Union ise, sonuçtaki eleman tipi, farklı bir tipteki değerlerle değiştirilen tekil tipleri içermeyecektir: örneğin, Union{T,Missing} eğer missing bir değerle değiştirilirse T haline gelecektir.

Ayrıca bkz. replace!, splice!, delete!, insert!.

Örnekler

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'yi, A'deki her x değeri new(x) ile değiştirildiği bir kopyasını döndürün. Eğer count belirtilmişse, o zaman toplamda en fazla count değeri değiştirilir (değiştirmeler new(x) !== x olarak tanımlanır).

Örnekler

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, eski_yeni::Pair...; [sayı::Integer])

Her eski=>yeni çifti için eski_yeni içinde, koleksiyon A'daki tüm eski örneklerini yeni ile değiştirin. Eşitlik isequal kullanılarak belirlenir. Eğer sayı belirtilmişse, o zaman toplamda en fazla sayı örneğini değiştirin. Ayrıca replace'ye de bakın.

Örnekler

julia> replace!([1, 2, 1, 3], 1=>0, 2=>4, sayı=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])

Koleksiyondaki her bir x elemanını new(x) ile değiştirir. Eğer count belirtilmişse, toplamda en fazla count değerini değiştirir (değiştirmeler new(x) !== x olarak tanımlanır).

Örnekler

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

Belirli bir yineleme durumu itr_state ile collection'ın sonunu almak için genel bir işlev. Eğer collection kendisi bir Tuple ise bir Tuple, collection bir AbstractArray ise AbstractVector'ın bir alt türü, collection bir AbstractString ise AbstractString'in bir alt türü ve aksi takdirde Iterators.rest(collection[, itr_state])'ye geri dönen bir rastgele yineleyici döner.

Kullanıcı tanımlı koleksiyon türleri için, son pozisyondaki atama sırasında yutma davranışını özelleştirmek için aşırı yüklenebilir, örneğin a, b... = collection.

Ayrıca bakınız: first, Iterators.rest, Base.split_rest.

Örnekler

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)

Belirli bir yineleme durumu itr_state'den başlayarak collection'ın kuyruğunu ayırmak için genel bir işlev. İki yeni koleksiyonun bir demetini döndürür. İlk koleksiyon, son n eleman hariç kuyruğun tüm elemanlarını içerirken, ikinci koleksiyonu oluşturur.

İlk koleksiyonun türü genellikle Base.rest türünü takip eder, ancak yedek durum tembel değildir, bunun yerine bir vektöre hevesle toplanır.

Kullanıcı tanımlı koleksiyon türleri için, a, b..., c = collection gibi son konumda atama sırasında yutma davranışını özelleştirmek için aşırı yüklenebilir.

Ayrıca bakınız: Base.rest.

Örnekler

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(koleksiyon, anahtar...)

Verilen anahtar veya indeks içindeki koleksiyonda saklanan değer(ler)i alır. a[i,j,...] sözdizimi derleyici tarafından getindex(a, i, j, ...) olarak dönüştürülür.

Ayrıca bkz. get, keys, eachindex.

Örnekler

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

Verilen değeri bir koleksiyondaki belirtilen anahtar veya indeks içinde saklayın. a[i,j,...] = x sözdizimi derleyici tarafından (setindex!(a, x, i, j, ...); x) şeklinde dönüştürülür.

Örnekler

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(koleksiyon) -> Tam Sayı
firstindex(koleksiyon, d) -> Tam Sayı

koleksiyon'un ilk indeksini döndürür. Eğer d verilmişse, koleksiyon'un d boyutundaki ilk indeksini döndürür.

A[begin] ve A[1, begin] sözdizimleri sırasıyla A[firstindex(A)] ve A[1, firstindex(A, 2)]'ye dönüşür.

Ayrıca bakınız: first, axes, lastindex, nextind.

Örnekler

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

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

lastindex(koleksiyon) -> Tam Sayı
lastindex(koleksiyon, d) -> Tam Sayı

koleksiyon'un son indeksini döndürür. Eğer d verilmişse, koleksiyon'un d boyutundaki son indeksini döndürür.

A[end] ve A[end, end] sözdizimleri sırasıyla A[lastindex(A)] ve A[lastindex(A, 1), lastindex(A, 2)]'ye dönüşür.

Ayrıca bkz: axes, firstindex, eachindex, prevind.

Örnekler

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

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

AbstractDict{K, V}

Anahtarları K türünde ve değerleri V türünde olan sözlük benzeri türler için üst tür. Dict, IdDict ve diğer türler bunun alt türleridir. Bir AbstractDict{K, V}, Pair{K, V}'nin bir yineleyicisi olmalıdır.

Dict([itr])

Dict{K,V}() bir K türünde anahtarlar ve V türünde değerler içeren bir hash tablosu oluşturur. Anahtarlar isequal ile karşılaştırılır ve hash ile hashlenir.

Tek bir iterable argüman verildiğinde, argümandan üretilen 2-tuple (anahtar,değer) çiftlerinden oluşan bir Dict oluşturur.

Örnekler

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

Alternatif olarak, bir dizi çift argüman da geçirilebilir.

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

!!! uyarı Anahtarların değiştirilebilir olmasına izin verilir, ancak eğer saklanan anahtarları değiştirirseniz, hash tablosu içsel olarak tutarsız hale gelebilir; bu durumda Dict düzgün çalışmayacaktır. Anahtarları değiştirmek zorundaysanız IdDict alternatif olabilir.

IdDict([itr])

IdDict{K,V}() bir hash tablosu oluşturur ve objectid hash olarak ve === eşitlik olarak kullanılır; anahtarlar K türünde ve değerler V türündedir. Daha fazla yardım için Dict ve bunun set versiyonu için IdSet kısmına bakın.

Aşağıdaki örnekte, Dict anahtarları tümü isequal olduğundan, aynı şekilde hashlenirler ve bu nedenle üzerine yazılırlar. IdDict ise nesne kimliğine göre hashler ve böylece 3 farklı anahtarı korur.

Örnekler

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() bir hash tablosu oluşturur; burada anahtarlar, bir hash tablosunda referans verilse bile çöp toplayıcı tarafından toplanabilecek nesnelere zayıf referanslardır.

Daha fazla yardım için Dict bölümüne bakın. Not: Dict'ın aksine, WeakKeyDict anahtarları ekleme sırasında dönüştürmez, çünkü bu, anahtar nesnesinin eklemeden önce hiçbir yerde referans verilmediği anlamına gelir.

Ayrıca bkz. WeakRef.

ImmutableDict

ImmutableDict, birçok bireysel ekleme ile oluşturulan küçük sözlükler için optimal olan, değiştirilemez bir bağlı liste olarak uygulanmış bir sözlüktür. Bir değeri kaldırmak mümkün değildir, ancak aynı anahtarla yeni bir değer ekleyerek kısmen geçersiz kılınabilir ve gizlenebilir.

ImmutableDict(KV::Pair)

key => value çifti için ImmutableDict içinde yeni bir giriş oluşturun

• bu belirli kombinasyonun özellikler kümesinde olup olmadığını görmek için (key => value) in dict kullanın
• belirli bir anahtar için en son değeri almak için get(dict, key, default) kullanın

PersistentDict

PersistentDict, bir hash array mapped trie olarak uygulanmış bir sözlüktür ve kalıcılık gerektiğinde optimaldir; her işlem, önceki sözlükten ayrı yeni bir sözlük döndürür, ancak temel uygulama alan verimlidir ve birden fazla ayrı sözlük arasında depolama paylaşabilir.

PersistentDict(KV::Pair)

Örnekler

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(koleksiyon, anahtar) -> Bool

Bir koleksiyonun belirli bir anahtar için bir eşleme olup olmadığını belirleyin.

Örnekler

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)

Verilen anahtar için saklanan değeri döndürür veya anahtar için bir eşleme yoksa verilen varsayılan değeri döndürür.

Örnekler

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)

Verilen anahtar için saklanan değeri döndürür, eğer anahtar için bir eşleme yoksa f() döndürür. Varsayılan değeri sözlükte saklamak için get! kullanın.

Bu, do blok sözdizimi kullanılarak çağrılması amaçlanmıştır.

get(dict, key) do
    # varsayılan değer burada hesaplanır
    time()
end

get!(koleksiyon, anahtar, varsayılan)

Verilen anahtar için saklanan değeri döndür, ya da eğer anahtar için bir eşleme yoksa, anahtar => varsayılan sakla ve varsayılanı döndür.

Örnekler

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)

Verilen anahtar için saklanan değeri döndürün veya anahtar için bir eşleme yoksa, key => f() saklayın ve f() döndürün.

Bu, do bloğu sözdizimi kullanılarak çağrılması amaçlanmıştır.

Örnekler

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(koleksiyon, anahtar, varsayılan)

Anahtar anahtar ile eşleşen anahtarı koleksiyon içinde varsa döndür, aksi takdirde varsayılan döndür.

Örnekler

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 (kategori Ll: Harf, küçük)

julia> getkey(D, 'd', 'a')
'a': ASCII/Unicode U+0061 (kategori Ll: Harf, küçük)

delete!(koleksiyon, anahtar)

Verilen anahtar için bir koleksiyondaki eşlemeyi siler, varsa, ve koleksiyonu döner.

Örnekler

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 değişmeden kalır
Dict{String, Int64} with 1 entry:
  "a" => 1

pop!(koleksiyon, anahtar[, varsayılan])

Eğer koleksiyon içinde mevcutsa anahtar için eşlemeyi sil ve döndür, aksi takdirde varsayılanı döndür veya varsayılan belirtilmemişse bir hata fırlat.

Örnekler

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

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

julia> pop!(d, "d")
HATA: KeyError: anahtar "d" bulunamadı
Stacktrace:
[...]

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

keys(iterator)

Anahtarlar ve değerler (örneğin diziler ve sözlükler) içeren bir yineleyici veya koleksiyon için, anahtarlar üzerinde bir yineleyici döndürür.

values(iterator)

Anahtarları ve değerleri olan bir iterator veya koleksiyon için, değerlere yönelik bir iterator döndürür. Bu fonksiyon, genel bir iteratorun elemanları genellikle "değerleri" olarak kabul edildiğinden, varsayılan olarak argümanını basitçe döndürür.

Örnekler

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)

Bir koleksiyondaki tüm değerler üzerinde bir yineleyici döndürür. collect(values(a)) bir değerler dizisi döndürür. Değerler bir hash tablosunda saklandığında, Dict durumunda olduğu gibi, döndürülen sıranın değişebileceğini unutmayın. Ancak keys(a), values(a) ve pairs(a) hepsi a üzerinde yineleme yapar ve elemanları aynı sırada döndürür.

Örnekler

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)

Dizi A'nın her bir elemanına erişen bir iteratör, i => x döndürür; burada i elemanın indeksi ve x = A[i]'dir. pairs(A) ile aynı, tek farkı indeks stilinin seçilebilmesidir. Ayrıca enumerate(A) ile de benzer, ancak i A için geçerli bir indeks olacaktır, oysa enumerate her zaman 1'den sayar, A'nın indekslerine bakılmaksızın.

IndexLinear() belirtmek, i'nin bir tam sayı olmasını garanti eder; IndexCartesian() belirtmek, i'nin bir Base.CartesianIndex olmasını garanti eder; IndexStyle(A) belirtmek, dizi A için tanımlanmış olan yerel indeksleme stilini seçer.

Temel dizinin sınırlarının değiştirilmesi bu iteratörü geçersiz kılacaktır.

Örnekler

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

Ayrıca bkz. IndexStyle, axes.

pairs(collection)

Herhangi bir koleksiyondaki anahtar => değer çiftleri üzerinde bir yineleyici döndürür; bu, bir dizi gibi bir anahtar kümesini bir değer kümesine eşleyen koleksiyonları içerir. Anahtarlar dizi indeksleri olduğunda diziler de buna dahildir. Girişler dahili olarak bir hash tablosunda saklandığında, Dict gibi, döndürülen sıranın değişebileceğini unutmayın. Ancak keys(a), values(a) ve pairs(a) hepsi a üzerinde yineleme yapar ve öğeleri aynı sırada döndürür.

Örnekler

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 yüzünün ve diğerlerinin özelliklerini birleştirir, daha sonraki yüzler önceliğe sahiptir.

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

Verilen koleksiyonlardan birleştirilmiş bir koleksiyon oluşturur. Gerekirse, sonuçta oluşan koleksiyonun türleri, birleştirilen koleksiyonların türlerini karşılamak için yükseltilecektir. Aynı anahtar başka bir koleksiyonda mevcutsa, o anahtar için değer, listelenen son koleksiyondaki değeri olacaktır. Aynı anahtara sahip değerlerin özel işlenmesi için mergewith kısmına da bakınız.

Örnekler

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

İki veya daha fazla mevcut named tuple'ı soldan sağa doğru birleştirerek yeni bir named tuple oluşturur. Birleştirme, named tuple çiftleri arasında soldan sağa doğru gerçekleşir ve bu nedenle en soldaki ve en sağdaki named tuple'larda bulunan alanların sırası, en soldaki named tuple'da bulundukları konumu alır. Ancak, değerler, o alanı içeren en sağdaki named tuple'daki eşleşen alanlardan alınır. Bir çiftin yalnızca en sağdaki named tuple'ında bulunan alanlar sona eklenir. Sadece bir tane named tuple sağlandığında bir yedekleme uygulanır; imzası merge(a::NamedTuple) şeklindedir.

Örnekler

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)

Bir anahtar-değer çiftleri iterable'ını adlandırılmış bir demet olarak yorumlayın ve birleştirme işlemi gerçekleştirin.

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

Verilen koleksiyonlardan birleştirilmiş bir koleksiyon oluşturun. Gerekirse, sonuç koleksiyonunun türleri birleştirilen koleksiyonların türlerini karşılamak için yükseltilecektir. Aynı anahtara sahip değerler, birleştirici fonksiyon kullanılarak birleştirilecektir. Curry biçimi mergewith(combine) fonksiyonu (args...) -> mergewith(combine, args...) döndürür.

merge(combine::Union{Function,Type}, args...) metodu, geriye dönük uyumluluk için mergewith(combine, args...)'nin bir takma adı olarak hala mevcuttur.

Örnekler

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

Diğer koleksiyonlardan çiftlerle koleksiyonu güncelle. Ayrıca bkz. merge.

Örnekler

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

Diğer koleksiyonlardan çiftlerle koleksiyonu güncelleyin. Aynı anahtara sahip değerler, birleştirici fonksiyon kullanılarak birleştirilecektir. Curry'li form mergewith!(combine) fonksiyonu (args...) -> mergewith!(combine, args...) döndürür.

merge!(combine::Union{Function,Type}, args...) metodu, mergewith!(combine, args...)'in bir takma adı olarak geriye dönük uyumluluk için hala mevcuttur.

Örnekler

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

Koleksiyon s'nin en az n eleman için kapasite ayırmasını önerir. Yani, s'ye birçok değer ekleyeceğinizi düşünüyorsanız, bunu önceden bir kez yaparak artan yeniden tahsisat maliyetinden kaçınabilirsiniz; bu performansı artırabilir.

Eğer first true ise, o zaman ek alan koleksiyonun başlangıcından önce ayrılır. Bu şekilde, push! yerine pushfirst! çağrıları daha hızlı hale gelebilir. Bu anahtar kelimeyi sağlamak, koleksiyon sıralı değilse veya pushfirst! bu koleksiyon için desteklenmiyorsa bir hataya neden olabilir.

Eğer shrink=true (varsayılan), koleksiyonun mevcut kapasitesi n'den büyükse kapasitesi azaltılabilir.

Ayrıca resize! bakınız.

Performans modeli hakkında notlar

sizehint! destekleyen türler için,

1. push! ve append! yöntemleri genellikle (ancak zorunlu değildir) ek depolama önceden ayırabilir. Base içinde uygulanan türler için genellikle bunu yapar, genel bir kullanım durumu için optimize edilmiş bir sezgi kullanarak.
2. sizehint! bu ön tahsisi kontrol edebilir. Yine, genellikle Base içindeki türler için bunu yapar.
3. empty!, bu tür ön tahsisi destekleyen türler için neredeyse maliyetsizdir (ve O(1)).

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

Bir dizinin anahtar türünü döndürür. Bu, keys(...) sonucunun eltype ile eşdeğerdir ve esasen sözlük arayüzü ile uyumluluk için sağlanmıştır.

Örnekler

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

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

keytype(type)

Bir sözlük türünün anahtar türünü alır. eltype ile benzer şekilde davranır.

Örnekler

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

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

Bir dizinin değer türünü döndürür. Bu, eltype ile aynıdır ve esasen sözlük arayüzü ile uyumluluk için sağlanmıştır.

Örnekler

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

valtype(type)

Bir sözlük türünün değer türünü alır. eltype ile benzer şekilde davranır.

Örnekler

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

AbstractSet{T}

T türünden elemanlara sahip olan set-benzeri türler için süpertip. Set, BitSet ve diğer türler bunun alt türleridir.

Set{T} <: AbstractSet{T}

Setler, hızlı üyelik testi sağlayan değiştirilebilir konteynerlerdir.

Setler, in, union ve intersect gibi küme işlemlerinin verimli uygulamalarına sahiptir. Bir Set içindeki elemanlar, elemanların isequal tanımına göre benzersizdir. Bir Set içindeki elemanların sırası, bir uygulama ayrıntısıdır ve güvenilir değildir.

Ayrıca bakınız: AbstractSet, BitSet, Dict, push!, empty!, union!, in, isequal

Örnekler

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

Verilen iterable nesne tarafından üretilen sıralı bir Int kümesi oluşturur veya boş bir küme döner. Bit dizesi olarak uygulanmıştır ve bu nedenle yoğun tam sayı kümeleri için tasarlanmıştır. Küme seyrek olacaksa (örneğin, birkaç çok büyük tam sayı tutuyorsa), bunun yerine Set kullanın.

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

IdSet{T}() bir küme oluşturur (bkz. Set) ve T türündeki değerlerle eşitlik için === kullanır.

Aşağıdaki örnekte, değerlerin hepsi isequal olduğu için sıradan Set içinde üzerine yazılır. IdSet ise === ile karşılaştırma yapar ve böylece 3 farklı değeri korur.

Örnekler

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

Tüm argümanlardan tüm farklı öğeleri içeren bir nesne oluşturur.

İlk argüman, hangi türde bir konteyner döndürüleceğini kontrol eder. Eğer bu bir dizi ise, öğelerin ilk göründüğü sırayı korur.

Unicode ∪, Julia REPL'de \cup yazıp ardından tab tuşuna basarak ve birçok editörde yazılabilir. Bu, s ∪ itr şeklinde kullanılan bir infiks operatördür.

Ayrıca unique, intersect, isdisjoint, vcat, Iterators.flatten ile de ilgili.

Örnekler

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

Geçilen kümelerin union birleşimini oluşturur ve s'yi sonuçla günceller. Dizilerle sıralamayı korur.

!!! uyarı Herhangi bir değiştirilmiş argümanın başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

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

Tüm argümanlarda bulunan öğeleri içeren küme oluşturur.

İlk argüman, hangi tür konteynerin döndürüleceğini kontrol eder. Eğer bu bir dizi ise, öğelerin ilk göründüğü sırayı korur.

Unicode ∩ Julia REPL'de \cap yazıp ardından tab tuşuna basarak ve birçok editörde yazılabilir. Bu, s ∩ itr şeklinde kullanılabilen bir infiks operatördür.

Ayrıca setdiff, isdisjoint, issubset, issetequal ile de ilgili.

Örnekler

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 kümesindeki ancak itrs içindeki herhangi bir iterable'da olmayan elemanların kümesini oluşturur. Dizilerle sıralamayı korur.

Ayrıca bkz. setdiff!, union ve intersect.

Örnekler

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

setdiff!(s, itrs...)

Küme s'den (yerinde) itrs'den her bir iterable'ın her bir elemanını çıkarın. Dizilerle sıralamayı koruyun.

!!! uyarı Herhangi bir değiştirilmiş argümanın başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

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

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

julia> a
Set{Int64} with 1 element:
  4

symdiff(s, itrs...)

Geçilen kümelerdeki elemanların simetrik farkını oluşturur. s bir AbstractSet değilse, sıralama korunur.

Ayrıca bkz. symdiff!, setdiff, union ve intersect.

Örnekler

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

Geçilen kümelerin simetrik farkını oluşturur ve s'yi sonuçla günceller. s bir dizi olduğunda, sıralama korunur. Bu durumda, elemanların çokluluğu önemlidir.

!!! uyarı Herhangi bir değiştirilmiş argümanın başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

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

Geçerli tüm küme kesişimlerini alır ve sonucu s ile değiştirir. Dizilerle sıralamayı korur.

!!! uyarı Herhangi bir değiştirilmiş argümanın, diğer herhangi bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

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

Her a'nın her bir elemanının b'de de bulunup bulunmadığını in kullanarak belirleyin.

Ayrıca ⊊, ⊈, ∩, ∪, contains ile de bakabilirsiniz.

Örnekler

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

Eğer x s içinde ise, true döner. Aksi takdirde, x'i s'ye ekler ve false döner. Bu, in(x, s) ? true : (push!(s, x); false) ile eşdeğerdir, ancak daha verimli bir uygulamaya sahip olabilir.

Ayrıca bakınız: in, push!, Set

Örnekler

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

⊆ ve ⊇'nin olumsuzlaması, yani a'nın b'nin alt kümesi olmadığını kontrol eder.

Ayrıca bkz. issubset (⊆), ⊊.

Örnekler

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

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

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

a'n b'ye eşit olmayan bir alt kümesi olup olmadığını belirler.

Ayrıca bkz. issubset (⊆), ⊈.

Örnekler

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

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

issetequal(a, b) -> Bool

a ve b'nin aynı elemanlara sahip olup olmadığını belirler. a ⊆ b && b ⊆ a ile eşdeğerdir ancak mümkün olduğunda daha verimlidir.

Ayrıca bakınız: isdisjoint, union.

Örnekler

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

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

issetequal(x)

x argümanını issetequal kullanarak karşılaştıran bir fonksiyon oluşturun, yani y -> issetequal(y, x) fonksiyonuna eşdeğer bir fonksiyon. Döndürülen fonksiyon Base.Fix2{typeof(issetequal)} türündedir ve özel yöntemleri uygulamak için kullanılabilir.

isdisjoint(a, b) -> Bool

Koleksiyonların a ve b ayrık olup olmadığını belirleyin. isempty(a ∩ b) ile eşdeğerdir ancak mümkün olduğunda daha verimlidir.

Ayrıca bkz: intersect, isempty, issetequal.

Örnekler

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

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

isdisjoint(x)

x ile isdisjoint kullanarak argümanını karşılaştıran bir fonksiyon oluşturun, yani y -> isdisjoint(y, x) ile eşdeğer bir fonksiyon. Döndürülen fonksiyon Base.Fix2{typeof(isdisjoint)} türündedir ve özel yöntemleri uygulamak için kullanılabilir.

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

Bir veya daha fazla items'ı collection'a ekleyin. Eğer collection sıralı bir konteyner ise, öğeler sona (verilen sırada) eklenir.

Örnekler

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

Eğer collection sıralı ise, başka bir koleksiyonun tüm elemanlarını eklemek için append! kullanın. Önceki örneğin sonucu, append!([1, 2, 3], [4, 5, 6]) ile eşdeğerdir. AbstractSet nesneleri için, bunun yerine union! kullanılabilir.

Performans modeli hakkında notlar için sizehint! bakın.

Ayrıca pushfirst! ile ilgili de bilgi edinin.

pop!(koleksiyon) -> öğe

koleksiyon içinden bir öğe çıkarır ve onu döndürür. Eğer koleksiyon sıralı bir konteyner ise, son öğe döndürülür; sırasız konteynerler için ise rastgele bir öğe döndürülür.

Ayrıca bakınız: popfirst!, popat!, delete!, deleteat!, splice!, ve push!.

Örnekler

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!(koleksiyon, anahtar[, varsayılan])

Eğer koleksiyon içinde mevcutsa anahtar için eşlemeyi sil ve döndür, aksi takdirde varsayılanı döndür veya varsayılan belirtilmemişse bir hata fırlat.

Örnekler

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

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

julia> pop!(d, "d")
HATA: KeyError: anahtar "d" bulunamadı
Stacktrace:
[...]

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

popat!(a::Vector, i::Integer, [default])

Verilen i'deki öğeyi kaldırır ve onu döndürür. Sonraki öğeler, oluşan boşluğu doldurmak için kaydırılır. i, a için geçerli bir indeks değilse, default'u döndürür veya default belirtilmemişse bir hata fırlatır.

Ayrıca bakınız: pop!, popfirst!, deleteat!, splice!.

Örnekler

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)
HATA: BoundsError: 3-element Vector{Int64} üzerinde [4] indeksine erişim denemesi
[...]

pushfirst!(koleksiyon, öğeler...) -> koleksiyon

Bir veya daha fazla öğeyi koleksiyonun başına ekler.

Bu işlev birçok diğer programlama dilinde unshift olarak adlandırılır.

Örnekler

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

popfirst!(koleksiyon) -> öğe

Koleksiyondan ilk öğeyi çıkarır.

Bu işlev birçok diğer programlama dilinde shift olarak adlandırılır.

Ayrıca bakınız: pop!, popat!, delete!.

Örnekler

julia> A = [1, 2, 3, 4, 5, 6]
6-elemanlı Vektör{Int64}:
 1
 2
 3
 4
 5
 6

julia> popfirst!(A)
1

julia> A
5-elemanlı Vektör{Int64}:
 2
 3
 4
 5
 6

insert!(a::Vector, index::Integer, item)

Bir item'i verilen index'te a'ya ekleyin. index, item'in sonuçta oluşan a içindeki indeksidir.

Ayrıca bakınız: push!, replace, popat!, splice!.

Örnekler

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

deleteat!(a::Vector, i::Integer)

Verilen i'deki öğeyi kaldırır ve değiştirilmiş a'yı döndürür. Sonraki öğeler, oluşan boşluğu doldurmak için kaydırılır.

Ayrıca bakınız: keepat!, delete!, popat!, splice!.

Örnekler

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

deleteat!(a::Vector, inds)

Verilen inds tarafından belirtilen indekslerdeki öğeleri kaldırır ve değiştirilmiş a'yı döndürür. Sonraki öğeler, oluşan boşluğu doldurmak için kaydırılır.

inds, ya bir yineleyici ya da sıralı ve benzersiz tam sayı indekslerinden oluşan bir koleksiyon ya da a ile aynı uzunlukta ve true değerinin silinecek girişleri gösterdiği bir boolean vektörü olabilir.

Örnekler

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))
HATA: ArgumentError: indeksler benzersiz ve sıralı olmalıdır
Stacktrace:
[...]

keepat!(a::Vector, inds)
keepat!(a::BitVector, inds)

Verilen inds tarafından belirtilmeyen tüm indekslerdeki öğeleri kaldırın ve değiştirilmiş a'yı döndürün. Korunan öğeler, sonuçta oluşan boşlukları doldurmak için kaydırılır.

!!! uyarı Herhangi bir değiştirilmiş argümanın başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

inds, sıralı ve benzersiz tam sayı indekslerinin bir yineleyicisi olmalıdır. Ayrıca bkz. deleteat!.

Örnekler

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

Yerinde mantıksal indeksleme versiyonu a = a[m]. Yani, eşit uzunluktaki a ve m vektörlerinde keepat!(a, m) işlemi, m'nin karşılık gelen indekste false olduğu tüm a elemanlarını kaldırır.

Örnekler

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

Verilen indeksteki öğeyi kaldırır ve kaldırılan öğeyi döndürür. Sonraki öğeler, oluşan boşluğu doldurmak için sola kaydırılır. Belirtilirse, sıralı bir koleksiyondan gelen yer tutucu değerler, kaldırılan öğenin yerine yerleştirilecektir.

Ayrıca bakınız: replace, delete!, deleteat!, pop!, popat!.

Örnekler

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

Herhangi bir öğeyi kaldırmadan replacement'ı bir indeks n'den önce eklemek için splice!(collection, n:n-1, replacement) kullanın.

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

Belirtilen indekslerdeki öğeleri kaldırır ve kaldırılan öğeleri içeren bir koleksiyonu döndürür. Sonraki öğeler, oluşan boşlukları doldurmak için sola kaydırılır. Belirtilmişse, sıralı bir koleksiyondan gelen yer tutucu değerler kaldırılan öğelerin yerine yerleştirilecektir; bu durumda, indices bir AbstractUnitRange olmalıdır.

Herhangi bir öğeyi kaldırmadan bir indeks n öncesine replacement eklemek için splice!(collection, n:n-1, replacement) kullanın.

Örnekler

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'yı n eleman içerecek şekilde yeniden boyutlandırır. Eğer n, mevcut koleksiyon uzunluğundan küçükse, ilk n eleman korunur. Eğer n daha büyükse, yeni elemanların başlatılacağı garanti edilmez.

Örnekler

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.

Sıralı bir konteyner collection için, her collections'ın elemanlarını sonuna ekleyin.

Örnekler

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'a, başka bir koleksiyonda zaten bulunmayan bireysel öğeleri eklemek için push! kullanın. Önceki örneğin sonucu, push!([1, 2, 3], 4, 5, 6) ile eşdeğerdir.

Performans modeli hakkında notlar için sizehint! bakın.

Ayrıca, vektörler için vcat, kümeler için union! ve ters sıradaki işlemler için prepend! ve pushfirst! ile ilgili daha fazla bilgiye bakın.

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

Her collections içindeki her bir öğeyi a'nın başına ekleyin.

collections birden fazla koleksiyon belirttiğinde, sıralama korunur: collections[1]'in öğeleri a'da en solda yer alacak ve devam edecektir.

Örnekler

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 nesnesini Pair{typeof(x), typeof(y)} türü ile oluşturun. Elemanlar first ve second alanlarında saklanır. Ayrıca yine de yineleme yoluyla erişilebilirler (ancak bir Pair, yayılma işlemleri için tek bir "skalar" olarak değerlendirilir).

Ayrıca bkz. Dict.

Örnekler

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

Bir indekslenebilir konteyneri aynı verinin bir Sözlük görünümüne dönüştürür. Temel verinin anahtar alanını değiştirmek bu nesneyi geçersiz kılabilir.