Python’da Filtre (Filter)

filter, bazı ölçütlere göre, bir sıralı yapıdaki (liste gibi) öğeleri atmak/tutmak için kullanılır. Önce örneklere bakalım:

isimler = ['Fred', 'Wilma', 'Barney']

def uzun_isimler(isimler):
    return len(isimler) > 5

list(filter(uzun_isimler, isimler))
# Çıktı: ['Barney']

[isim for isim in isimler if len(isim) > 5] # eşdeğer liste üreteci
# Çıktı: ['Barney']

from itertools import ifilter
ifilter(uzun_isimler, isimler)       # generator (python 3.x filter yapısına benzer)
# Çıktı: <itertools.ifilter at 0x4197e10>
list(ifilter(long_name, names)) # filter ve liste'ye eş değer
# Çıktı: ['Barney']

(isim for isim in isimler if len(isim) > 5) # generator'e eşdeğer
# Çıktı: <generator object <genexpr> at 0x0000000003FD5D38>

# python 2.x versionları için future_builtin fonksyionu ile:

from future_builtins import filter
filter(uzun_isimler, isimler)       # itertools.ifilter ile aynı
# Çıktı: <itertools.ifilter at 0x3eb0ba8>

filter(uzun_isimler, isimler)        # generator döndürür
# Çıktı: <filter at 0x1fc6e443470>
list(filter(long_name, names))  # cast to list
# Çıktı: ['Barney']

(isim for isim in isimler if len(isim) > 5) # generator deyimine eşdeğer
# Çıktı: <generator object <genexpr> at 0x000001C6F49BF4C0>

Sözdizimi 

• filter(fonksiyon, yinelenebilir)
• itertools.ifilter(fonksiyon, yinelenebilir)
• future_builtins.filter(fonksiyon, yinelenebilir)
• itertools.ifilterfalse(fonksiyon, yinelenebilir)
• itertools.filterfalse(fonksiyon, yinelenebilir)

Parametre 

• fonksiyon | koşulu belirleyen ve filtreleme için kimlik işlevini kullanan çağrılabilir (yalnızca konumsal)
• yinelenebilir | filtre uygulanacak yinelenebilir (yalnızca konumsal)

Çoğu durumda filter‘a göre bir liste üreteci veya generator ifadesi daha okunabilir, daha güçlü ve daha verimli olabilir.

Kısa devre kontrolü olarak filter

filter (python 3.x) ve ifilter (python 2.x) bir generatör döndürür, böylece or veya and gibi bir kısa test oluştururken çok kullanışlı olabilirler: 

# gerçek ugulamalarda tavsiye edilmez ama örnek açısından yararlı:
from itertools import ifilter as filter

from future_builtins import filter

100’den küçük ilk öğeyi bulmak için:

araba_dukkani = [('Toyota', 1000), ('lastik', 80), ('Porsche', 5000)]

def kucuk_degeri_bul(isim_deger_tuple):
    print('Kontrol {0}, {1}$'.format(*isim_deger_tuple)
    return isim_deger_tuple[1] < 100

next(filter(kucuk_degeri_bul, araba_dukkani))

# Print: Kontrol Toyota, 1000$
#        Kontrol lastik, 80$
# Çıktı: ('lastik', 80)

–next işlevi, bir sonraki (bu durumda ilk) öğeyi verir. Kısa devre dememizin sebebi budur.

Fonksiyonsuz Filtre Uygulama

İşlev parametresi yerine None kimlik işlevi de kullanılabilir. Böylece None değeri olan tüm öğeler atılır – 0’a dikkat: 

list(filter(None, [1, 0, 2, [], '', 'a']))  # 0, [] ve '' atar   
# Çıktı: [1, 2, 'a']

[i for i in [1, 0, 2, [], '', 'a'] if i] # eşdeğer liste üreteci 

(i for i in [1, 0, 2, [], '', 'a'] if i) # eşdeğer generator deyimi

filterfalse ve ifilterfalse işlevleri

itertools-modulü içinde filter’a tamamlayıcı olarak düşünebileceğimiz bir işlev daha bulunur vardır: 

from itertools import ifilterfalse as filterfalse

from itertools import filterfalse

tam olarak filter generatörü gibi çalışır, ancak yalnızca False öğeleri tutar:

# işlevsiz kullanım (None):
list(filterfalse(None, [1, 0, 2, [], '', 'a']))  # 1, 2, 'a' yı kaldırır
# Çıktı: [0, [], '']

İşlevli kullanım 

isimler = [‘Fred’, ‘Wilma’, ‘Barney’]

def uzun_isimler(isimler):
	return len(isimler) > 5

list(filterfalse(uzun_isimler, isimler)) # Çıktıt: [‘Fred’, ‘Wilma’]

.next ile kısa devre kullanımı

araba_dukkani = [('Toyota', 1000), ('lastik', 80), ('Porsche', 5000)]
def kucuk_deger_bul(isim_deger_tuple):
    print('Kontrol {0}, {1}$'.format(*isim_deger_tuple)
    return isim_deger_tuple[1] < 100
next(filterfalse(kucuk_deger_bul, araba_dukkani))
# Print: Kontrol Toyota, 1000$
# Çıktı: ('Toyota', 1000)

Eşdeğer bir generatör deyimi

araba_dukkani = [('Toyota', 1000), ('lastik', 80), ('Porsche', 5000)] 
generator = (oge for oge in araba_dukkani if not oge[1] < 100)
next(generator)

Temel map, itertools.imap, ve future_builtins map kullanımı

Python yerleşik işlevleri arasında, map, işlevsel programlama için kullanılan en basit metottur. map() bir yinelemedeki her öğeye belirtilen bir işlevi uygular:

isimler = ['Fred', 'Wilma', 'Barney']

map(len, isimler)  # map Python 3.x'te bir class (sınıf); bu sınıfın objeleri yinelenebilir
# Çıktı: <map object at 0x00000198B32E2CF8>

Python 3 uyumlu map, future_builtins modülüne de dahildir

from future_builtins import map  
map(len, isimler)                  
# Çıktı: <itertools.imap instance at 0x3eb0a20>

Alternatif olarak, Python 2’de bir generatör almak için itertools ile gelen imap kullanabilirsiniz

map(len, isimler)   # map() liste döndürür
# Çıktı: [4, 5, 6]

from itertools import imap
imap(len, isimler)  # itertools.imap() generator döndürür 
# Çıktı: <itertools.imap at 0x405ea20>

Python 2 ve 3 arasındaki farkları kaldırmak için sonuç listeye dönüştürülebilir: 

list(map(len, isimler))
# Çıktı: [4, 5, 6]

map() eşdeğer bir liste üreteci veya generatör ifadesi ile değiştirilebilir:

[len(oge) for oge in isimler] # Python 2.x map() kullanımına eşdeğer
# Çıktı: [4, 5, 6]

(len(oge) for oge in isimler) # Python 3.x map() kullanımına eşdeğer
# Çıktı: <generator object <genexpr> at 0x00000195888D5FC0>