Python Yineleyiciler ve Üreteçler Eğitimi

Yineleyiciler (iterators), üzerinde yinelenebilen nesnelerdir. Python programlama dilinin ortak bir özelliği olarak döngüler ve liste üreteçleri (list comprehensions) için ustaca kullanılırlar. Bir yineleyici türetebilen herhangi bir nesneye yinelenebilir (iterable) denir. 

Bir yineleyici oluşturmak için epeyce emek gerekir. Örneğin, her yineleyici nesnesinin uygulaması bir __iter__() ve __next__() yönteminden oluşmalıdır. Yukarıdaki önkoşula ek olarak, uygulamanın nesnenin iç durumunu takip edecek bir yöntemi olmalı ve artık değer döndürülemediğinde StopIteration istisnasını yükseltmelidir. Bu kurallara yineleyici protokolü denir. 

Kendi yineleyicinizi uygulamak uzun bir süreçtir ve her zaman gerekli değildir. Daha basit bir alternatif, bir üreteç nesnesi kullanmaktır. Üreteçler, yield anahtar sözcüğünü kullanarak bir seferde bir değer döndürülebilen bir yineleyici iade eden özel bir işlev türüdür. 

Hangi senaryolarda bir yineleyici uygulamak ya da bir üreteç kullanmak gerektiğini ayırt edebilmek, bir Python programcısı olarak becerilerinizi geliştirir. Bu eğitimin geri kalanında, iki nesne arasındaki farkları vurgulayacağız; bu da çeşitli durumlar için en uygun olanı seçmenize yardımcı olacaktır. 

Sözlük

Python Yineleyiciler & Yinelenebilirler

Yinelenebilirler, üyelerini birer birer döndürebilen nesnelerdir – yani üzerlerinde yinelenebilir. Listeler, demetler ve kümeler gibi popüler yerleşik Python veri yapıları yinelenebilirdir. Dizgeler ve sözlükler gibi diğer veri yapıları da yinelenebilir kabul edilir: bir dizge karakterleri üzerinde yineleme üretebilir, bir sözlüğün anahtarları üzerinde de yinelenebilir. Genel kural olarak, bir for döngüsünde üzerinde yinelenebilen herhangi bir nesneyi yinelenebilir olarak düşünün. 

Örneklerle Python yinelenebilirlerini keşfetme

Tanımlara göre tüm yineleyicilerin aynı zamanda yinelenebilir olduğu sonucuna varabiliriz. Ancak her yinelenebilir mutlaka bir yineleyici değildir. Bir yinelenebilir, ancak üzerinde yinelenmeye başlandığında bir yineleyici üretir.

Bu işlevselliği göstermek için bir yinelenebilir olan bir liste örneği oluşturacak ve listedeki yerleşik iter() işlevini çağırarak bir yineleyici elde edeceğiz. 

list_instance = [1, 2, 3, 4]
print(iter(list_instance))

"""
<list_iterator object at 0x7fd946309e90>
"""

Listenin tek başına bir yineleyici olmamasına rağmen, iter() işlevini çağırmak onu bir yineleyiciye dönüştürür ve yineleyici nesnesini döndürür.

Tüm yinelenebilirlerin yineleyici olmadığını göstermek için aynı liste nesnesini oluşturup, bir yineleyicideki bir sonraki öğeyi döndürmek için kullanılan next() işlevini çağırmayı deneyeceğiz.  

list_instance = [1, 2, 3, 4]
print(next(list_instance))
"""
--------------------------------------------------------------------
TypeError                         Traceback (most recent call last)
<ipython-input-2-0cb076ed2d65> in <module>()
    3 print(iter(list_instance))
    4
----> 5 print(next(list_instance))
TypeError: 'list' object is not an iterator
"""

Yukarıdaki kodda, listedeki next() işlevini çağırmaya çalışmanın bir TypeError oluşturduğunu görebilirsiniz – Python'da İstisna ve Hata Yönetimi hakkında daha fazla bilgi edinin. Bu davranış, basitçe, bir liste nesnesinin yinelenebilir olması ve yineleyici olmaması gerçeğinden kaynaklanır. 

Örneklerle Python yineleyicilerini keşfetme

Dolayısıyla amaç bir liste üzerinde yinelenmekse, önce bir yineleyici nesnesi üretilmelidir. Ancak ondan sonra listenin değerleri arasında yinelemeyi yönetebiliriz.

# instantiate a list object
list_instance = [1, 2, 3, 4]

# convert the list to an iterator
iterator = iter(list_instance)

# return items one at a time
print(next(iterator))
print(next(iterator))
print(next(iterator))
print(next(iterator))
"""
1
2
3
4
"""

Python, bir yinelenebilir nesne üzerinde döngü kurmaya çalıştığınızda otomatik olarak bir yineleyici nesne üretir. 

# instantiate a list object
list_instance = [1, 2, 3, 4]

# loop through the list
for item in list_instance:
  print(item)
"""
1
2
3
4
"""

StopIteration istisnası yakalandığında döngü sona erer.

Bir yineleyiciden elde edilen değerlere yalnızca soldan sağa erişilebilir. Geliştiricilerin bir yineleyicide geriye doğru ilerlemesini sağlayan bir previous() işlevi Python'da yoktur. 

Yineleyicilerin tembel doğası

Aynı yinelenebilir nesneye dayalı birden çok yineleyici tanımlamak mümkündür. Her yineleyici kendi ilerleme durumunu korur. Dolayısıyla, bir yinelenebilir nesnenin birden çok yineleyici örneğini tanımlayarak, bir örneğin sonuna kadar yinelerken diğer örnek başlangıçta kalabilir.

list_instance = [1, 2, 3, 4]
iterator_a = iter(list_instance)
iterator_b = iter(list_instance)
print(f"A: {next(iterator_a)}")
print(f"A: {next(iterator_a)}")
print(f"A: {next(iterator_a)}")
print(f"A: {next(iterator_a)}")
print(f"B: {next(iterator_b)}")
"""
A: 1
A: 2
A: 3
A: 4
B: 1
"""

iterator_b'nin serinin ilk öğesini yazdırdığına dikkat edin.

Bu nedenle, yineleyicilerin tembel bir doğaya sahip olduğunu söyleyebiliriz: bir yineleyici oluşturulduğunda, öğeler ancak talep edildiğinde sunulur. Başka bir deyişle, listemizin öğeleri, onları açıkça next(iter(list_instance)) ile istediğimizde döndürülür. 

Bununla birlikte, bir yineleyicinin tüm değerleri, yineleyici nesnesi üzerinde yerleşik bir yinelenebilir veri yapısı kapsayıcısı (örn. list(), set(), tuple()) çağrılarak bir seferde çıkarılabilir; bu da yineleyiciyi tüm öğelerini bir kerede üretmeye zorlar.

# instantiate iterable
list_instance = [1, 2, 3, 4]

# produce an iterator from an iterable
iterator = iter(list_instance)
print(list(iterator))
"""
[1, 2, 3, 4]
"""

Bu yaklaşım, her öğenin bir kerede üretilmesini ve bellekte tutulmasını zorladığı için büyük yineleyicilerde önerilmez; tembel değerlendirmenin amacını boşa çıkarır.

Bir veri kümesi belleğe rahatça sığamayacak kadar büyük olduğunda veya tam teşekküllü bir yineleyici sınıfı yazmadan tembel yineleme istediğinizde, genellikle bir üreteç daha uygundur.

Python Üreteçleri

Bir yineleyici uygulamanın en pratik alternatifi bir üreteç kullanmaktır. Üreteçler sıradan Python işlevlerine benziyor gibi görünse de farklıdır. Öncelikle, bir üreteç nesnesi öğeleri doğrudan döndürmez. Bunun yerine, öğeleri anlık olarak üretmek için yield anahtar sözcüğünü kullanır. Bu nedenle, bir üretecin tembel değerlendirmeden yararlanan özel bir işlev türü olduğunu söyleyebiliriz.

Üreteçler, tipik bir yinelenebilirden bekleneceği gibi içeriklerini bellekte saklamaz. Örneğin, amaç pozitif bir tamsayının tüm bölenlerini bulmak olsaydı, genellikle aşağıdaki gibi geleneksel bir işlev uygularız (bu eğitimde Python İşlevleri hakkında daha fazla bilgi edinin):  

def factors(n):
  factor_list = []
  for val in range(1, n+1):
      if n % val == 0:
          factor_list.append(val)
  return factor_list

print(factors(20))
"""
[1, 2, 4, 5, 10, 20]
"""

Yukarıdaki kod, bölenlerin tamamını bir liste olarak döndürür. Ancak, geleneksel bir Python işlevi yerine bir üreteç kullanıldığında farkına dikkat edin:

def factors(n):
  for val in range(1, n+1):
      if n % val == 0:
          yield val
print(factors(20))

"""
<generator object factors at 0x7fd938271350>
"""

yield anahtar sözcüğünü return yerine kullandığımız için, çalıştırmadan sonra işlevden çıkılmaz. Özünde, Python'a geleneksel bir işlev yerine bir üreteç nesnesi oluşturmasını söyledik; bu da üreteç nesnesinin durumunun izlenmesini sağlar. 

Sonuç olarak, serinin öğelerini birer birer göstermek için tembel yineleyici üzerinde next() işlevini çağırmak mümkündür. 

def factors(n):
  for val in range(1, n+1):
      if n % val == 0:
          yield val
         
factors_of_20 = factors(20)
print(next(factors_of_20))

"""
1
"""

Bir üreteç oluşturmanın bir başka yolu da üreteç kavrayışıdır (generator comprehension). Üreteç ifadeleri, liste üreteçlerine benzer bir sözdizimini benimser; tek fark köşeli parantez yerine yuvarlak parantez kullanmasıdır.

factor_gen = (val for val in range(1, 21) if 20 % val == 0)
print(list(factor_gen))
"""
[1, 2, 4, 5, 10, 20]
"""

Python’un yield Anahtar Sözcüğünü Keşfetme

yield anahtar sözcüğü, bir üreteç işlevinin akışını kontrol eder. return kullanıldığında görüldüğü gibi işlevden çıkmak yerine, yield işlevden döner ancak yerel değişkenlerinin durumunu hatırlar.

yield çağrısından döndürülen üreteç bir değişkene atanabilir ve next() işleviyle üzerinde yinelenebilir – bu da işlevi karşılaştığı ilk yield anahtar sözcüğüne kadar çalıştırır. yield noktasına ulaşıldığında işlevin yürütülmesi askıya alınır. Bu olduğunda, işlevin durumu kaydedilir. Böylece, işlevin yürütmesini dilediğimiz zaman kaldığı yerden sürdürebiliriz. 

İşlev, yield çağrısından itibaren devam edecektir. Örneğin: 

def yield_multiple_statements():
  yield "This is the first statement"
  yield "This is the second statement"  
  yield "This is the third statement"
  yield "This is the last statement. Don't call next again!"
example = yield_multiple_statements()
print(next(example))
print(next(example))
print(next(example))
print(next(example))
print(next(example))
"""
This is the first statement
This is the second statement
This is the third statement
This is the last statement. Don't call next again or else!
--------------------------------------------------------------------
StopIteration                  Traceback (most recent call last)
<ipython-input-25-4aaf9c871f91> in <module>()
    11 print(next(example))
    12 print(next(example))
---> 13 print(next(example))
StopIteration:
"""

Yukarıdaki kodda, üreteç dört yield çağrısına sahipken biz beş kez next çağırıyoruz ve bu da bir StopIteration istisnası oluşturuyor. Bu davranış, üretecimizin sonsuz bir seri olmamasından dolayı, beklenenden fazla çağrı yapılmasının üreteci tüketmesi nedeniyle gerçekleşir.

Özet 

Özetlemek gerekirse, yineleyiciler üzerinde yinelenebilen nesnelerdir ve üreteçler tembel değerlendirmeden yararlanan özel işlevlerdir. Kendi yineleyicinizi uygulamak, bir __iter__() ve __next__() yöntemi oluşturmanızı gerektirirken, bir üreteç Python işlevinde veya kavrayışında yield anahtar sözcüğü kullanılarak uygulanabilir. 

Karmaşık durum koruma davranışına sahip bir nesneye ihtiyaç duyduğunuzda veya __next__(), __iter__() ve __init__() dışında başka yöntemler de sunmak istediğinizde özel bir yineleyiciyi üreteceğe tercih edebilirsiniz. Öte yandan, üreteç, içeriklerini bellekte tutmadıkları için büyük veri kümeleriyle çalışırken veya bir yineleyici uygulamak gerekli olmadığında tercih edilebilir.