Python liste anlama gösterimini kullanma

iş

Python’da, yeni bir liste oluştururken liste anlama gösterimini kullanmak kolaydır.(List comprehensions)

Bu yazıda, önce aşağıdakileri tartışacağız

  • Temel liste anlama gösterimi türü
  • Koşullu dallanma ile anlama gösterimini if ​​ile listeleyin
  • Üçlü operatörlerle kombinasyon (eğer başka bir işlem gibiyse)
  • zip(),enumerate()Bunlarla kombinasyon
  • iç içe liste dahil etme gösterimi

Daha sonra, örnek kod ile liste anlama gösterimi kümesini açıklayacağız.

  • dahil etme gösterimini ayarla(Set comprehensions)
  • sözlük ekleme gösterimi(Dict comprehensions)
  • jeneratör tipi(Generator expressions)

Temel liste anlama gösterimi türü

Liste anlama notasyonu aşağıdaki gibi yazılır.

[Expression for Any Variable Name in Iterable Object]

Liste, tanımlama grubu veya aralık gibi yinelenebilir bir nesnenin her öğesini isteğe bağlı bir değişken adıyla alır ve bir ifadeyle değerlendirir. Öğe olarak değerlendirme sonucunu içeren yeni bir liste döndürülür.

Bir eşdeğer for ifadesi ile birlikte bir örnek verilmiştir.

squares = [i**2 for i in range(5)]
print(squares)
# [0, 1, 4, 9, 16]

squares = []
for i in range(5):
    squares.append(i**2)

print(squares)
# [0, 1, 4, 9, 16]

Aynı işlem map() ile de yapılabilir, ancak basitliği ve netliği nedeniyle liste anlama notasyonu tercih edilir.

Koşullu dallanma ile anlama gösterimini if ​​ile listeleyin

if ile koşullu dallanma da mümkündür. if’yi postfix’e aşağıdaki gibi yazın.

[Expression for Any Variable Name in Iterable Object if Conditional Expression]

Yalnızca koşullu ifadesi doğru olan yinelenebilir nesnenin öğeleri ifade tarafından değerlendirilir ve öğeleri sonuç olan yeni bir liste döndürülür.

Koşullu ifadede herhangi bir değişken adını kullanabilirsiniz.

Bir eşdeğer for ifadesi ile birlikte bir örnek verilmiştir.

odds = [i for i in range(10) if i % 2 == 1]
print(odds)
# [1, 3, 5, 7, 9]

odds = []
for i in range(10):
    if i % 2 == 1:
        odds.append(i)

print(odds)
# [1, 3, 5, 7, 9]

Aynı işlem filter() ile de yapılabilir, ancak basitliği ve netliği nedeniyle liste anlama notasyonu tercih edilir.

Üçlü operatörlerle kombinasyon (eğer başka bir işlem gibiyse)

Yukarıdaki örnekte, yalnızca kriterleri karşılayan öğeler işlenir ve kriterleri karşılamayanlar yeni listeden çıkarılır.

Koşullara bağlı olarak işlemi değiştirmek istiyorsanız veya koşulu sağlamayan öğeleri farklı şekilde işlemek istiyorsanız, sanki else’de olduğu gibi, üçlü operatörü kullanın.

Python’da üçlü operatör aşağıdaki gibi yazılabilir.

Value When True if Conditional Expression else Value When False

Bu, aşağıda gösterildiği gibi liste anlama notasyonunun ifade kısmında kullanılır.

[Value When True if Conditional Expression else Value When False for Any Variable Name in Iterable Object]

Bir eşdeğer for ifadesi ile birlikte bir örnek verilmiştir.

odd_even = ['odd' if i % 2 == 1 else 'even' for i in range(10)]
print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

odd_even = []
for i in range(10):
    if i % 2 == 1:
        odd_even.append('odd')
    else:
        odd_even.append('even')

print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

Doğru ve yanlış değerler için rastgele değişken isimleri kullanarak ifadeler yazmak da mümkündür.

Koşul sağlanırsa, bazı işlemler yapılır, aksi takdirde orijinal yinelenebilir nesnenin değeri değişmeden kalır.

odd10 = [i * 10 if i % 2 == 1 else i for i in range(10)]
print(odd10)
# [0, 10, 2, 30, 4, 50, 6, 70, 8, 90]

Zip() ve numaralandırma() ile kombinasyon

for deyiminde sıklıkla kullanılan kullanışlı işlevler arasında, birden çok yinelenebilir öğeyi birleştiren zip() ve dizini ile birlikte bir değer döndüren numaralandırma() bulunur.

Elbette, zip() ve enumerate()’yi liste anlama notasyonu ile kullanmak mümkündür. Bu özel bir sözdizimi değildir ve for deyimi ile yazışmayı düşünürseniz zor değildir.

Zip() örneği.

l_str1 = ['a', 'b', 'c']
l_str2 = ['x', 'y', 'z']

l_zip = [(s1, s2) for s1, s2 in zip(l_str1, l_str2)]
print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

l_zip = []
for s1, s2 in zip(l_str1, l_str2):
    l_zip.append((s1, s2))

print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

Numaralandırma () örneği.

l_enu = [(i, s) for i, s in enumerate(l_str1)]
print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

l_enu = []
for i, s in enumerate(l_str1):
    l_enu.append((i, s))

print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

Fikir, if kullanırken öncekiyle aynıdır.

l_zip_if = [(s1, s2) for s1, s2 in zip(l_str1, l_str2) if s1 != 'b']
print(l_zip_if)
# [('a', 'x'), ('c', 'z')]

Her eleman, yeni bir elemanı hesaplamak için de kullanılabilir.

l_int1 = [1, 2, 3]
l_int2 = [10, 20, 30]

l_sub = [i2 - i1 for i1, i2 in zip(l_int1, l_int2)]
print(l_sub)
# [9, 18, 27]

iç içe liste dahil etme gösterimi

Döngüler için yuvalama gibi, liste anlama gösterimi de yuvalanabilir.

[Expression for Variable Name 1 in Iterable Object 1
    for Variable Name 2 in Iterable Object 2
        for Variable Name 3 in Iterable Object 3 ... ]

Kolaylık sağlamak için satır sonları ve girintiler eklenmiştir, ancak dilbilgisi için gerekli değildir; tek bir satırda devam ettirilebilirler.

Bir eşdeğer for ifadesi ile birlikte bir örnek verilmiştir.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

flat = [x for row in matrix for x in row]
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

flat = []
for row in matrix:
    for x in row:
        flat.append(x)

print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Birden fazla değişken kullanmak da mümkündür.

cells = [(row, col) for row in range(3) for col in range(2)]
print(cells)
# [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]

Ayrıca koşullu dallanma da yapabilirsiniz.

cells = [(row, col) for row in range(3)
         for col in range(2) if col == row]
print(cells)
# [(0, 0), (1, 1)]

Her yinelenebilir nesne için koşullu olarak dallandırmak da mümkündür.

cells = [(row, col) for row in range(3) if row % 2 == 0
         for col in range(2) if col % 2 == 0]
print(cells)
# [(0, 0), (2, 0)]

dahil etme gösterimini ayarla(Set comprehensions)

Liste anlama gösterimindeki köşeli parantezleri [] küme parantezleri {} olarak değiştirmek bir küme (küme türü nesne) oluşturur.

{Expression for Any Variable Name in Iterable Object}

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

sözlük ekleme gösterimi(Dict comprehensions)

Sözlükler (dict tipi nesneler) de anlama notasyonu ile oluşturulabilir.

{} ve ifade bölümünde anahtarı ve değeri anahtar: değer olarak belirtin.

{Key: Value for Any Variable Name in Iterable Object}

Anahtar ve değer için herhangi bir ifade belirtilebilir.

l = ['Alice', 'Bob', 'Charlie']

d = {s: len(s) for s in l}
print(d)
# {'Alice': 5, 'Bob': 3, 'Charlie': 7}

Anahtarlar ve değerler listesinden yeni bir sözlük oluşturmak için zip() işlevini kullanın.

keys = ['k1', 'k2', 'k3']
values = [1, 2, 3]

d = {k: v for k, v in zip(keys, values)}
print(d)
# {'k1': 1, 'k2': 2, 'k3': 3}

jeneratör tipi(Generator expressions)

Liste anlama gösterimindeki köşeli parantezler [] yuvarlak parantez () olarak kullanılırsa, bir tanımlama grubu yerine bir üreteç döndürülür. Buna jeneratör ifadeleri denir.

Liste anlama gösterimi örneği.

l = [i**2 for i in range(5)]

print(l)
# [0, 1, 4, 9, 16]

print(type(l))
# <class 'list'>

Bir jeneratör ifadesi örneği. Jeneratörü olduğu gibi yazdırırsanız () içeriğini yazdırmaz, ancak bir for ifadesi ile çalıştırırsanız içeriği alabilirsiniz.

g = (i**2 for i in range(5))

print(g)
# <generator object <genexpr> at 0x10af944f8>

print(type(g))
# <class 'generator'>

for i in g:
    print(i)
# 0
# 1
# 4
# 9
# 16

Üretici ifadeleri ayrıca, liste anlama gösteriminin yanı sıra if kullanarak koşullu dallanma ve iç içe yerleştirmeye de izin verir.

g_cells = ((row, col) for row in range(0, 3)
           for col in range(0, 2) if col == row)

print(type(g_cells))
# <class 'generator'>

for i in g_cells:
    print(i)
# (0, 0)
# (1, 1)

Örneğin, liste anlama notasyonu kullanılarak çok sayıda eleman içeren bir liste oluşturulur ve daha sonra bir for ifadesi ile döngülenirse, liste anlama notasyonu kullanılırsa tüm elemanları içeren liste başlangıçta oluşturulur. Öte yandan, bir üreteç ifadesi kullanırsanız, döngü her tekrarlandığında, öğeler birer birer oluşturulur, böylece kullanılan bellek miktarı azalır.

Oluşturucu ifadesi işlevin tek argümanıysa, yuvarlak parantezler () atlanabilir.

print(sum([i**2 for i in range(5)]))
# 30

print(sum((i**2 for i in range(5))))
# 30

print(sum(i**2 for i in range(5)))
# 30

İşlem hızına gelince, liste anlama gösterimi, tüm öğeler işlendiğinde genellikle üretici gösteriminden daha hızlıdır.

Ancak, örneğin all() veya any() ile karar verirken, sonuç false veya true olduğunda belirlenir, bu nedenle oluşturucu ifadeleri kullanmak, liste anlama gösterimini kullanmaktan daha hızlı olabilir.

Tuple anlama notasyonu yoktur, ancak tuple() argümanı olarak bir jeneratör ifadesi kullanırsanız, anlama notasyonunda bir Tuple oluşturabilirsiniz.

t = tuple(i**2 for i in range(5))

print(t)
# (0, 1, 4, 9, 16)

print(type(t))
# <class 'tuple'>