Iteration utilities

Stateful(itr)

Bu iterator sarmalayıcı hakkında düşünmenin birkaç farklı yolu vardır:

1. Bir iterator ve onun yineleme durumunun etrafında değiştirilebilir bir sarmalayıcı sağlar.
2. Bir iterator benzeri soyutlamayı Channel benzeri bir soyutlamaya dönüştürür.
3. Bir öğe üretildiğinde kendi dinlenme iteratoru haline gelmek için değişen bir iterator'dur.

Stateful, normal iterator arayüzünü sağlar. Diğer değiştirilebilir iteratorlar (örneğin, Base.Channel) gibi, yineleme erken durdurulursa (örneğin, bir break ile bir for döngüsünde), yineleme aynı iterator nesnesi üzerinden devam edilerek aynı yerden yeniden başlatılabilir (bu, değiştirilemez bir iteratorun başlangıçtan yeniden başlamasıyla karşılaştırıldığında).

Örnekler

julia> a = Iterators.Stateful("abcdef");

julia> isempty(a)
false

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

julia> collect(Iterators.take(a, 3))
3-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (kategori Ll: Harf, küçük)
 'c': ASCII/Unicode U+0063 (kategori Ll: Harf, küçük)
 'd': ASCII/Unicode U+0064 (kategori Ll: Harf, küçük)

julia> collect(a)
2-element Vector{Char}:
 'e': ASCII/Unicode U+0065 (kategori Ll: Harf, küçük)
 'f': ASCII/Unicode U+0066 (kategori Ll: Harf, küçük)

julia> Iterators.reset!(a); popfirst!(a)
'a': ASCII/Unicode U+0061 (kategori Ll: Harf, küçük)

julia> Iterators.reset!(a, "hello"); popfirst!(a)
'h': ASCII/Unicode U+0068 (kategori Ll: Harf, küçük)

julia> a = Iterators.Stateful([1,1,1,2,3,4]);

julia> for x in a; x == 1 || break; end

julia> peek(a)
3

julia> sum(a) # Kalan öğeleri topla
7

zip(iters...)

Birden fazla iteratörü aynı anda çalıştırır, bunlardan herhangi biri tükenene kadar. zip iteratörünün değer türü, alt iteratörlerinin değerlerinin bir demetidir.

Ayrıca bakınız: enumerate, Base.splat.

Örnekler

julia> a = 1:5
1:5

julia> b = ["e","d","b","c","a"]
5-element Vector{String}:
 "e"
 "d"
 "b"
 "c"
 "a"

julia> c = zip(a,b)
zip(1:5, ["e", "d", "b", "c", "a"])

julia> length(c)
5

julia> first(c)
(1, "e")

enumerate(iter)

Bir iterator, (i, x) çiftlerini döndürür; burada i 1'den başlayan bir sayıcıdır ve x verilen iterator'dan i'nci değerdir. Üzerinde döngü yaptığınız değerler x'in yanı sıra, şu ana kadar kaç kez döngü yapıldığını bilmeniz gerektiğinde kullanışlıdır.

Dikkat edin ki i, iter için geçerli bir indeks olmayabilir veya farklı bir öğeyi indeksleyebilir. Bu, iter'in indekslerinin 1'den başlamadığı durumlarda meydana gelebilir ve dizeler, sözlükler vb. için de olabilir. i'nin bir indeks olmasını istiyorsanız pairs(IndexLinear(), iter) yöntemine bakın.

Örnekler

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

julia> for (index, value) in enumerate(a)
           println("$index $value")
       end
1 a
2 b
3 c

julia> str = "naïve";

julia> for (i, val) in enumerate(str)
           print("i = ", i, ", val = ", val, ", ")
           try @show(str[i]) catch e println(e) end
       end
i = 1, val = n, str[i] = 'n'
i = 2, val = a, str[i] = 'a'
i = 3, val = ï, str[i] = 'ï'
i = 4, val = v, StringIndexError("naïve", 4)
i = 5, val = e, str[i] = 'v'

rest(iter, state)

Verilen state'den başlayarak iter ile aynı öğeleri veren bir yineleyici.

Ayrıca bakınız: Iterators.drop, Iterators.peel, Base.rest.

Örnekler

julia> collect(Iterators.rest([1,2,3,4], 2))
3-element Vector{Int64}:
 2
 3
 4

countfrom(start=1, step=1)

Sonsuz sayan, start'ten başlayarak ve step kadar artırarak sayan bir yineleyici.

Örnekler

julia> for v in Iterators.countfrom(5, 2)
           v > 10 && break
           println(v)
       end
5
7
9

take(iter, n)

iter'in en fazla n elemanını üreten bir iteratördür.

Ayrıca bakınız: drop, peel, first, Base.take!.

Örnekler

julia> a = 1:2:11
1:2:11

julia> collect(a)
6-element Vector{Int64}:
  1
  3
  5
  7
  9
 11

julia> collect(Iterators.take(a,3))
3-element Vector{Int64}:
 1
 3
 5

takewhile(pred, iter)

Bir iteratör, pred koşulu doğru olduğu sürece iter'den elemanlar üretir, sonrasında her elemanı atar.

Örnekler

julia> s = collect(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> collect(Iterators.takewhile(<(3),s))
2-element Vector{Int64}:
 1
 2

drop(iter, n)

Bir iteratör, iter'in ilk n elemanını hariç tutarak tüm elemanlarını üretir.

Örnekler

julia> a = 1:2:11
1:2:11

julia> collect(a)
6-element Vector{Int64}:
  1
  3
  5
  7
  9
 11

julia> collect(Iterators.drop(a,4))
2-element Vector{Int64}:
  9
 11

dropwhile(pred, iter)

Bir iteratör, pred koşulu doğru olduğu sürece iter'den elemanları atar, sonrasında her elemanı döner.

Örnekler

julia> s = collect(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> collect(Iterators.dropwhile(<(3),s))
3-element Vector{Int64}:
 3
 4
 5

cycle(iter[, n::Int])

Sonsuz bir şekilde iter üzerinden dönen bir iteratördür. Eğer n belirtilmişse, o zaman iter üzerinden o kadar kez döner. iter boş olduğunda, cycle(iter) ve cycle(iter, n) de boştur.

Iterators.cycle(iter, n) Base.repeat(vector, n)'nin tembel eşdeğeridir, oysa Iterators.repeated(iter, n) tembel Base.fill(item, n)'dir.

Örnekler

julia> for (i, v) in enumerate(Iterators.cycle("hello"))
           print(v)
           i > 10 && break
       end
hellohelloh

julia> foreach(print, Iterators.cycle(['j', 'u', 'l', 'i', 'a'], 3))
juliajuliajulia

julia> repeat([1,2,3], 4) == collect(Iterators.cycle([1,2,3], 4))
true

julia> fill([1,2,3], 4) == collect(Iterators.repeated([1,2,3], 4))
true

repeated(x[, n::Int])

Sonsuz bir şekilde x değerini üreten bir iteratör. Eğer n belirtilirse, x o kadar kez üretilir (bu, take(repeated(x), n) ile eşdeğerdir).

Ayrıca fill ve Iterators.cycle ile karşılaştırın.

Örnekler

julia> a = Iterators.repeated([1 2], 4);

julia> collect(a)
4-element Vector{Matrix{Int64}}:
 [1 2]
 [1 2]
 [1 2]
 [1 2]

julia> ans == fill([1 2], 4)
true

julia> Iterators.cycle([1 2], 4) |> collect |> println
[1, 2, 1, 2, 1, 2, 1, 2]

product(iters...)

Birden fazla iteratörün çarpımını döndüren bir iteratör. Üretilen her bir eleman, i'nci elemanı i'nci argüman iteratöründen gelen bir tuple'dır. İlk iteratör en hızlı değişir.

Ayrıca bkz: zip, Iterators.flatten.

Örnekler

julia> collect(Iterators.product(1:2, 3:5))
2×3 Matrix{Tuple{Int64, Int64}}:
 (1, 3)  (1, 4)  (1, 5)
 (2, 3)  (2, 4)  (2, 5)

julia> ans == [(x,y) for x in 1:2, y in 3:5]  # Iterators.product içeren bir jeneratörü toplar
true

flatten(iter)

Bir iteratörün iteratörler ürettiği durumlarda, bu iteratörlerin elemanlarını üreten bir iteratör döndürün. Başka bir deyişle, argüman iteratörünün elemanları birleştirilir.

Örnekler

julia> collect(Iterators.flatten((1:2, 8:9)))
4-element Vector{Int64}:
 1
 2
 8
 9

julia> [(x,y) for x in 0:1 for y in 'a':'c']  # Iterators.flatten içeren jeneratörleri toplar
6-element Vector{Tuple{Int64, Char}}:
 (0, 'a')
 (0, 'b')
 (0, 'c')
 (1, 'a')
 (1, 'b')
 (1, 'c')

Iterators.flatmap(f, iterators...)

flatten(map(f, iterators...)) ile eşdeğerdir.

Ayrıca bkz. Iterators.flatten, Iterators.map.

Örnekler

julia> Iterators.flatmap(n -> -n:2:n, 1:3) |> collect
9-element Vector{Int64}:
 -1
  1
 -2
  0
  2
 -3
 -1
  1
  3

julia> stack(n -> -n:2:n, 1:3)
HATA: DimensionMismatch: stack uniform dilimler bekliyor, axes(x) == (1:3,) iken ilki (1:2,) aldı.
[...]

julia> Iterators.flatmap(n -> (-n, 10n), 1:2) |> collect
4-element Vector{Int64}:
 -1
 10
 -2
 20

julia> ans == vec(stack(n -> (-n, 10n), 1:2))
true

partition(koleksiyon, n)

Bir koleksiyonu n eleman halinde yineleyin.

Örnekler

julia> collect(Iterators.partition([1,2,3,4,5], 2))
3-element Vector{SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}}:
 [1, 2]
 [3, 4]
 [5]

Iterators.map(f, iterators...)

Tembel bir eşleme oluşturur. Bu, (f(args...) for args in zip(iterators...)) yazmanın başka bir sözdizimidir.

Örnekler

julia> collect(Iterators.map(x -> x^2, 1:3))
3-element Vector{Int64}:
 1
 4
 9

Iterators.filter(flt, itr)

Bir predikat fonksiyonu flt ve bir iterable nesne itr verildiğinde, flt(x) koşulunu sağlayan itr'nin elemanlarını döndüren bir iterable nesne döner. Orijinal iteratorün sırası korunur.

Bu fonksiyon tembeldir; yani, $Θ(1)$ zamanında döneceği ve $Θ(1)$ ek alan kullanacağı garanti edilir ve filter çağrısı ile flt çağrılmayacaktır. flt'ye yapılan çağrılar, döndürülen iterable nesne üzerinde yineleme yapılırken gerçekleştirilecektir. Bu çağrılar önbelleğe alınmaz ve tekrar eden çağrılar, yineleme sırasında yapılacaktır.

!!! uyarı filter'den dönen iterator üzerinde yapılan sonraki tembel dönüşümler, Iterators.reverse veya cycle gibi, flt çağrılarını, döndürülen iterable nesne üzerinde toplama veya yineleme yapılana kadar geciktirecektir. Eğer filtre predikatı belirsizse veya döndürdüğü değerler itr'nin elemanları üzerindeki yineleme sırasına bağlıysa, tembel dönüşümlerle bileşim, şaşırtıcı davranışlara yol açabilir. Bu istenmiyorsa, ya flt'nin saf bir fonksiyon olduğundan emin olun ya da daha fazla dönüşümden önce ara filter iteratorlerini toplayın.

Diziler için eager bir filtreleme uygulaması için Base.filter kısmına bakın.

Örnekler

julia> f = Iterators.filter(isodd, [1, 2, 3, 4, 5])
Base.Iterators.Filter{typeof(isodd), Vector{Int64}}(isodd, [1, 2, 3, 4, 5])

julia> foreach(println, f)
1
3
5

julia> [x for x in [1, 2, 3, 4, 5] if isodd(x)]  # Iterators.filter üzerinde bir jeneratörü toplar
3-element Vector{Int64}:
 1
 3
 5

Iterators.accumulate(f, itr; [init])

İki argümanlı f fonksiyonu ve bir iterator itr verildiğinde, f'yi önceki değere ve itr'nin bir sonraki elemanına ardışık olarak uygulayan yeni bir iterator döndürür.

Bu, etkili bir şekilde Base.accumulate fonksiyonunun tembel bir versiyonudur.

Örnekler

julia> a = Iterators.accumulate(+, [1,2,3,4]);

julia> foreach(println, a)
1
3
6
10

julia> b = Iterators.accumulate(/, (2, 5, 2, 5); init = 100);

julia> collect(b)
4-element Vector{Float64}:
 50.0
 10.0
  5.0
  1.0

Iterators.reverse(itr)

Bir iterator itr verildiğinde, reverse(itr) aynı koleksiyon üzerinde ancak ters sırada bir iterator döndürür. Bu iterator "tembel"dir; tersine çevirmek için koleksiyonun bir kopyasını oluşturmaz; bunun için hevesli bir uygulama için Base.reverse kısmına bakın.

(Varsayılan olarak, bu itr'yi saran bir Iterators.Reverse nesnesi döndürür; bu nesne, ilgili iterate yöntemleri tanımlıysa yine de yineleyebilir, ancak bazı itr türleri daha özel Iterators.reverse davranışlarını uygulayabilir.)

Tüm iterator türleri T ters sıra ile yinelemeyi desteklemez. Eğer T desteklemiyorsa, Iterators.reverse(itr::T) üzerinde yineleme yapmak, Iterators.Reverse{T} için eksik iterate yöntemleri nedeniyle bir MethodError fırlatır. (Bu yöntemleri uygulamak için, orijinal iterator itr::T, r::Iterators.Reverse{T} nesnesinden r.itr ile elde edilebilir; daha genel olarak, Iterators.reverse(r) kullanılabilir.)

Örnekler

julia> foreach(println, Iterators.reverse(1:5))
5
4
3
2
1

only(x)

Koleksiyon x'in tek ve yegâne elemanını döndürür veya koleksiyonun sıfır veya birden fazla elemanı varsa ArgumentError fırlatır.

Ayrıca bkz. first, last.

Örnekler

julia> only(["a"])
"a"

julia> only("a")
'a': ASCII/Unicode U+0061 (kategori Ll: Küçük harf, harf)

julia> only(())
HATA: ArgumentError: Tuple 0 eleman içeriyor, tam olarak 1 eleman içermelidir
Yığın izi:
[...]

julia> only(('a', 'b'))
HATA: ArgumentError: Tuple 2 eleman içeriyor, tam olarak 1 eleman içermelidir
Yığın izi:
[...]

peel(iter)

İlk öğeyi ve kalan öğeler üzerinde bir iteratör döndürür.

Eğer iteratör boşsa nothing döner (tıpkı iterate gibi).

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

Örnekler

julia> (a, rest) = Iterators.peel("abc");

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

julia> collect(rest)
2-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (kategori Ll: Harf, küçük)
 'c': ASCII/Unicode U+0063 (kategori Ll: Harf, küçük)