Pythonda Liste Kısaltmaları

Ara 092017

Pythonda Liste Kısaltmaları

Liste kısaltmaları (list comprehensions), Python diliyle basit, kolay anlaşılır ve hızlı bir şekilde listeler oluşturmamızı sağlar.

Liste Kısaltmaları

Örneğin 0 ile 10 arasındaki ( 0 ve 10 dahil) tam sayıların karelerini hesaplayıp, sonuçları bir liste haline getirelim.

Bu işlemin en basit yöntemi for döngüsü kullanmaktır.

s1=[]
for n in range(11):
    s1.append(n**2)
print(s1)

s1=[]

for n in range(11):

s1.append(n**2)

print(s1)

Aynı listeyi list ve map fonksiyonları kullanarak da oluşturabiliriz:

s2=list(map(lambda n: n**2, range(11)))
print(s2)

1 2	s2=list(map(lambda n: n**2, range(11))) print(s2)

Üçüncü yöntemimiz ise liste kısaltması kullanmaktır:

s3=[n**2 for n in range(11)]
print(s3)

1 2	s3=[n**2 for n in range(11)] print(s3)

Her üç yöntemin sonucu da aynıdır:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Şimdi 5 ile 18 arasındaki (5 ve 18 dahil) sayılarla 2’nin üssünü hesaplayalım:

s1=[]
for n in range(5,19):
    s1.append(2**n)

s2=list(map(lambda n: 2**n, range(5,19)))

s3=[2**n for n in range(5,19)]
print(s1); print(s2); print(s3)

s1=[]

for n in range(5,19):

s1.append(2**n)

s2=list(map(lambda n: 2**n, range(5,19)))

s3=[2**n for n in range(5,19)]

print(s1); print(s2); print(s3)

Sonuçlar aynı:

[32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]
[32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]
[32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]

[32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]

3 ile 28 arasındaki çift sayılar:

s1=[]
for n in range(3,28):
    if n % 2 == 0:
        s1.append(n)
s2=list(filter(lambda n:n%2==0,range (3,28)))
s3=[n for n in range(3,28) if n % 2 == 0]
print(s1); print(s2); print(s3)

s1=[]

for n in range(3,28):

if n % 2 == 0:

s1.append(n)

s2=list(filter(lambda n:n%2==0,range (3,28)))

s3=[n for n in range(3,28) if n % 2 == 0]

print(s1); print(s2); print(s3)

Sonuçlar aynı:

[4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26]
[4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26]
[4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26]

[4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26]

2 ile 24 arasındaki tek sayılar için liste kısaltması:

s =[n for n in range(2,25) if n % 2 == 1]
print(s)

1 2	s =[n for n in range(2,25) if n % 2 == 1] print(s)

Sonuçlar:

[3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23]

1	[3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23]

Kısacası yinelenebilir (iterable) bir nesneden bir liste oluşturmak istediğimizde:

[x for x in yinelenebilir]

1	[x for x in yinelenebilir]

Liste kısaltmamıza filtre uygulamak içinse if anahtar sözcüğünü kullanıyoruz:

[x for x in yinelenebilir if kosul]

1	[x for x in yinelenebilir if kosul]

Bir önceki yazımda liste kısaltmalarının for döngülerinden ve map() fonksiyonundan daha hızlı çalıştığını belirtmiştim.

Şimdi bu kıyaslamayı basit bir örnek üzerinden kendimiz yapalım. Kıyaslama işleminde bir dekoratör fonksiyonu kullanalım.

import time

def dekorator(func):

    def ara_func():
        t0 = time.time()
        func()
        dt = time.time()-t0
        print(f"{func.__name__} Süre: {dt}")

    return ara_func

N=10000000

@dekorator
def for_fonk():
    liste = []
    for n in range(N):
        liste.append(n**3)
    return liste

@dekorator
def map_fonk():
    liste = list(map(lambda n: n**3, range(N)))
    return liste

@dekorator
def lcomp_fonk():
    liste = [n**3 for n in range(N)]
    return liste

for_fonk()
map_fonk()
lcomp_fonk()

import time

def dekorator(func):

def ara_func():

t0 = time.time()

func()

dt = time.time()-t0

print(f"{func.__name__} Süre: {dt}")

return ara_func

N=10000000

@dekorator

def for_fonk():

liste = []

for n in range(N):

liste.append(n**3)

return liste

@dekorator

def map_fonk():

liste = list(map(lambda n: n**3, range(N)))

return liste

@dekorator

def lcomp_fonk():

liste = [n**3 for n in range(N)]

return liste

for_fonk()

map_fonk()

lcomp_fonk()

Sonuç:

for_fonk Süre: 7.299371004104614
map_fonk Süre: 7.067672967910767
lcomp_fonk Süre: 5.921266555786133

for_fonk Süre: 7.299371004104614

map_fonk Süre: 7.067672967910767

lcomp_fonk Süre: 5.921266555786133

Elbette bu sonuçlar betiği çalıştırdığınız bilgisayarın çalışma hızına da bağlıdır ama, aynı işlemin farklı yöntemlerle uygulanmasının farklı süreler aldığını açıkça görebiliyoruz.

Eğer yazdığınız kodlar çalışma hızına duyarlı ise, kesinlikle liste kısaltması kullanmanızı öneriyorum. Eğer böyle bir kaygınız yoksa ve Python konusunda çok fazla deneyiminiz bulunmuyorsa, for yöntemini kullanın. Böylece map veya liste kısaltmasının içeriğini algılamak için çaba sarfetmenize gerek kalmaz.

Şahsen ben, bu konuda Guido van Rossum’a katılıyorum: Eğer çok özel nedenleriniz yoksa lambda, map, filter ve reduce gibi ek araçlara ihtiyacınız olmayacaktır.

Ahmet Aksoy

Referanslar:

Python Dilinde Lambda, Map, Filter ve Reduce

python Yanıt yok »

Ara 082017

Python Dilinde Lambda, Map, Filter ve Reduce

İşler hep Guido van Rossum’un istediği gibi gitseydi, Python dilinde lambda, map, filter ve reduce kavramları olmayacaktı. Ama bazı gruplardan gelen talepler ağır bastı; sonuç olarak lambda, map ve filter Python çekirdeğinde varlıklarını sürdürmeye devam ederken, sadece reduce functools modülüne kaydırıldı.

Rossum’un bu terimlere karşı çıkmasının gerekçeleri şunlardı:

- Liste kısaltmaları (list comprehensions) lambda, map, filter ve reduce yerine daha güçlü bir şekilde kullanılabilir.
- Liste kısaltmaları daha açık ve anlaşılırdır.
- Python yaklaşımına aykırı bir şekilde, aynı soruna yönelik birden fazla Python çözüm yöntemi olacaktır.

Liste kısaltmaları for döngülerine kıyasla % 35, map fonksiyonuna kıyasla %45 daha hızlı çalışmaktadır. Dolayısıyla kodlama yaparken bu ayrıntıları da bilmekte yarar var.

lambda Fonksiyonu

kare = lambda x : x*x

1	kare = lambda x : x*x

ile

def kare(x): return(x*x)

1	def kare(x): return(x*x)

fonksiyonları aynı işleve sahiptir.
İlkinde anonim bir fonksiyon tanımlayıp, bu fonksiyonu kare değişkenine atıyoruz. Diğerinde ise doğrudan bir fonksiyon tanımlıyoruz.

map Fonksiyonu

map fonksiyonu 2 argüman alır. İlk argüman bir fonksiyon, ikinci argüman ise bir dizilimdir (sequence). map fonksiyonu ilk argüman olarak verilen fonksiyona dizilim elemanlarının her birini argüman olarak atar ve sonuçları bir map nesnesi olarak geri döndürür.

m = map(lambda x: x*x*x, [1,2,3,4,5])
print(list(m))

1 2	m = map(lambda x: xxx, [1,2,3,4,5]) print(list(m))

Sonuçlar:

[1, 8, 27, 64, 125]

1	[1, 8, 27, 64, 125]

filter Fonksiyonu

Bu fonksiyon da tıpkı map gibi ilk argüman olarak bir fonksiyon, ikinci argüman olarak bir dizilim alır. Ancak geriye sadece, fonksiyona uygulandığında True değer üreten dizilim elemanlarını döndürür.
Aşağıdaki kod satırları 1 ila 20 arasındaki sayılardan 3’e tam olarak bölünenleri geri döndürmektedir.

liste = list(range(1,21))
f = filter(lambda x: x%3==0, liste)
print(liste)
print(list(f))

liste = list(range(1,21))

f = filter(lambda x: x%3==0, liste)

print(liste)

print(list(f))

Sonuçlar:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
[3, 6, 9, 12, 15, 18]

1 2	[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] [3, 6, 9, 12, 15, 18]

reduce Fonksiyonu

Bu fonksiyon functools modülünde yer alır ve geriye tek bir sonuç döndürür.
Örneğin 1 ile 100 arasındaki sayıların toplamını bulalım:

from functools import reduce
r = reduce(lambda x+y: x+y, range(1,1001))
print(r)

from functools import reduce

r = reduce(lambda x+y: x+y, range(1,1001))

print(r)

Sonuç:

500500

500500

Bir sonraki yazımda liste kısaltmaları (list comprehensions) konusunu ele alacağım.

Ahmet Aksoy

Referanslar: