Buraya kadar Python'un dil yapısını anlattık, güzel hoş ama asıl önemli noktaya şu ana kadar değinmedik. Bu Python'un eğlenceli yanı neresi? Python'u eğlenceli yapan bir program yazarken sürekli olarak karşılaştığımız bazı ufak tefek problemlerin çözümüne getiriği farklı yaklaşımdır. Şimdi bu yaklaşımın bize sağladığı güzellikleri bir inceleyelim.
List Comprehensions (Liste Yorumlama)
Liste yorumlama (ne yazık ki tam ve anlamlı bir türkçe karşılık bulamadım) Python'un belki de en farklı özelliklerinden biridir. Liste türü veriler üzerinde pratik olarak filtreleme düzenleme yapmamızı sağlar. Örneğin sıradan bir programlama mantığıyla bir sayılardan oluşan bir listenin belirli koşullara uyan elemanlarını bir işleme tabi tutmak istediğimizde (örneğin sayılardan oluşan bir listenin tek sayı elemanlarının karesini almak istersek) yazacağımız kod aşağı yukarı şöyle olacaktır:
kare_listesi = []
"""
Unutmayın, Python'da değişkenler kullanılmadan önce
ilklendirilmelidir (Initialization).
"""
for sayi in range(10):
if sayi % 2:
"""
Sayı ikiye tam olarak bölünmezse tek sayıdır, 1 döndürür.
"""
kare_listesi.append((sayi,sayi**2))
#**operatörü sayının belirtilen kuvvetini döndürür.
print kare_listesi
Aynı sorunu liste yorumlama kullanarak çözdüğümüzde ise tüm iş tek satırda halledilir:
kare_listesi = [(sayi, sayi**2) for sayi in range(10) if sayi%2]
print kare_listesi
Şimdi bu kodu parçalayalım. Daha soyut bir gösterimle liste yorumlama şu şekilde tanımlanabilir:
<değişkene uygulanacak işlem> for <değişken> in <liste> if <koşul>
İlk bölüm değişkene uygulanacak işlemi tanımlar. Bu bölümde standart Python operatörlerinin yanında kendi tanımlayacağımız bir fonksiyonu da kullanmak mümkündür. Liste yorumu sonucunda birden fazla değer döndürmek te mümkündür. Bu durumda döndüreceğimiz değerleri parantezlerin içine alarak bir tüp haline getirmemiz gerekir. Örneğimizde sayının kendisi ve karesi parantezlerin içine alınarak bir tüp oluşturacak şekilde döndürülmektedir.
İkinci bölüm for anahtar sözcüğü yardımıyla üzerinde işlem yapacağımız listeyi tanımlar. Burada da normal bir liste, bir tüp veya listeleri taklit eden kendine özgü bir veri tipi kullanmamız mümkündür. Aynen sıradan bir for döngüsünde olduğu gibi listemizin elemanları sırayla değişkene atanır.
Üçüncü bölüm ise her liste yorumlama işleminde bulunması mecburi olmayan test bölümüdür. Bu bölüme yazacağımız ifade ile listeyi belirli bir koşula göre filtrelememiz mümkündür. Buraya da diğer bölümlerde olduğu gibi bir python ifadesi veya fonksiyonu yazabiliriz. Fonksiyonun veya ifadenin döndürdüğü değerin Python tarafından tanımlanan doğruluk değerine ("", 0, None ve () gibi ifadeler için yanlış geri kalan çoğu ifade için doğru değeri kabul edilmiştir) göre liste elemanı ilk aşamadaki işleme sokulup, sonuç olarak döndürülür veya döndürülmez.
İlk bakışta tuhaf gözükse de liste yorumlama işlemi hem döngülerinizde daha sadece ve okunabilir bir görünüm elde etmenizi sağlayacak, hem de kodunuzu daha modüler bir şekle sokmanız yönünde sizi zorlayacaktır.
Çoklu Atama (Multiple Assignments)
Fonksiyon tanımları bölümünde gördüğümüz gibi Python fonksiyonları bazen birden fazla değer döndürebilir. Bu durumda fonksiyonun tü çıktısını tek bir değişkene atayarak çıktıyı bir tüp şeklinde kullanabileceğimiz gibi çoklu atama yöntemiyle çıktının her bir elemanını ayrı bir değişkene de atamamız mümkündür. Özellikle birden fazla sonuç döndüren ve sonuçların kendilerinin de bir liste yapısı oluşturduğu !getopt! gibi kütüphaneleri kullanırken bu yönteme başvurmak neredeyse mecburiyettir. Çoklu atama, atama operatörünün (=) iki tarafına da virgülle ayrılmış şekilde birden fazla değer yazarak yapılır. Örneğin:
a, b, c = 1, 2, 3
Tabiiki değerler her zaman elle yazılmış olmak zorunda değildir. Örneğin bir programın stanard girdi, standart çıktı ve standart hata çıktılarını programımızdaki değişkenlere atamamızı sağlayan popen3 komutunun döndürdüğü 3 ayrı değişkeni kodumuzdaki 3 ayrı değişkene atamak için de bu yazımı kullanabiliriz. Örneğin:
import os
ls_stdin, ls_stdout, ls_stderr = os.popen3("/bin/ls")
...
lambda Formları
lambda formları özellikle Lisp kültüründen olanların oldukça yakından tanıdığı bir fonksiyon biçimidir. lambda formları basit fonksiyonlar olarak tanımlanabilir. Özellikle kodun içinde ufak tefek ve o anki duruma özgü işlemler yapmak için lambda formları kullanılabilir. Örneğin bir lambda tanımını kodun içerisinde koşula bağlı bir şekilde yaparak duruma göre değişen bir fonksiyon elde etmek mümkündür. Bir lambda formu şu şekilde tanımlanır:
lambda <parametreler>: <tek satırlık komut>
Dinamik olarak tanımlanan lambda formlarını liste yorumlama özellikleriyle birleştirerek kodu sadeleştirmek mümkündür.
map(), filter(), reduce() ve enumerate()
map() ve filter() fonksiyonları temelde liste yorumları ile aynı işi yapmaya yararlar. map() fonksiyonu bir fonksiyon ve bir liste olmak üzere iki parametre alır ve sözkonusu fonksiyonu listenin her elemanı üzerinde teker teker çalıştırarak sonucu döndürür. filter() fonksiyonu ise verdiğimiz fonksiyonu ikinci parametresi olan liste üzerinde uygulayarak doğruluk değeri testi yapar ve doğru değeri döndüren elemanlardan oluşan bir listeyi sonuç olarak döndürür. Bu iki fonksiyonu map(<fonksiyon>, filter(<test fonksiyonu>, liste)) şeklinde kullanarak liste yorumlama işlemini taklit etmek mümkündür. Fakat liste yorumları kodu daha okunabilir kıldığından Python'un liste yorumlarını desteklemeyen 2.0'dan önceki sürümleri ile uyumluluğun hedeflendiği durumlar haricinde pek kullanılmazlar.
reduce() fonksiyonu ise diğerlerine oranla daha ilginç bir fonksiyondur. Bir fonksiyon ve bir liste olmak üzere iki parametre alır. Önce listenin birinci ve ikinci elemanları fonksiyona parametre olarak geçirilir. Bu işlemin sonucu alınarak üçüncü eleman ile, sonra da her işlemin sonucu listenin bir sonraki elemanı ile fonksiyona parametre olarak geçirilir ve son elemandan sonra fonksiyonun döndürdüğü değer reduce() fonksiyonunun sonucu olarak döndürülür. Mecburi olmayan üçüncü bir parametre ise ilk değerdir ve listenin en başına yerleştirilerek ilk eleman ile birlikte işleme girmesi sağlanır. Bu fonksiyon özellikle bir listeden düzenli bir veri yapısı oluşturmak gerektiğinde oldukça kullanışlıdır. Örneğin liste yorumlamaları sırasında sonuç olarak elde ettiğimiz listeyi bir sözlük biçimine çevirmek istersek şöyle bir kod yazmamız yeterli olacaktır:
def sozlugeEkle(sozluk, tup):
"""
Bu fonksiyon parametre olarak aldığı sözlüğe
iki elemanlı tüpteki değerleri anahtar:değer
biçiminde ekler
"""
sozluk[tup[0]] = tup[1]
return sozluk
kare_listesi = [(sayi, sayi**2) for sayi in range(10) if sayi%2]
kare_sozlugu = reduce(sozlugeEkle, kare_listesi, {})
"""
Fonksiyon ilk parametre olarak verilerin ekleneceği
sözlüğü aldığından reduce fonksiyonuna üçüncü parametre
olarak boş bir sözlük geçiriyoruz. Bu sayede fonksiyonumuz
şu şekilde çağırılacaktır:
sozlugeEkle({}, (1,1))
sozlugeEkle({1:1}, (3,9))
...
"""
print kare_sozlugu
enumerate() fonksiyonu ise Python 2.3 ile duyurulmuş, diğerlerine oranla yeni bir fonksiyondur. Bu fonksiyon parametre olarak bir liste alır ve listenin her elemanını numaralandırarak bir enumerate nesnesi döndürür. Bu nesneyi diğer herhangi bir liste gibi döngülerde kullanmak mümkündür. Elde edeceğimiz değer her liste elemanı için (<sıra numarası>, <eleman>) şeklinde bir çifttir. Bu sayede örneğin bir listenin elemanlarını numaralandırarak yazdırmamız gerektiğinde kodumuz oldukça sadeleşmiş olacaktır. enumerate() fonksiyonunun güzelliği şu şekilde daha iyi anlaşılabilir:
liste = ["Sıfır","Bir", "İki", "Üç", "Dört", "Beş", "Altı", "Yedi", "Sekiz", "Dokuz"]
#Eski usül eleman yazdırma
for i in range(len(liste)):
print i, "=", liste
#Enumerate ile yazdırma
for i, eleman in enumerate(liste):
print i, "=", eleman
Sonuçta enumerate() kullanılarak yazılan kodun çok daha anlaşılır olacağı ortadadır.
