Python List Comprehension Eğitimi

Veri bilimi yaparken, listelerin listelerini okumak, sütun adlarını filtrelemek, bir listeden sesli harfleri kaldırmak veya bir matrisi düzleştirmek isteyebilirsiniz. Kolayca bir lambda fonksiyonu veya for döngüsü kullanabilirsiniz; Bildiğiniz gibi, bunu yapmanın birden fazla yolu var. Bir diğer yol da list comprehension kullanmaktır.

Bu eğitimde son başlığa odaklanacağız:

• Önce Python listelerinin ne olduğuna ve diğer Python veri yapılarıyla nasıl karşılaştırıldığına dair kısa bir özet alacaksınız;
• Ardından Python list comprehension'larına dalacaksınız: Python listelerinin arkasındaki matematik hakkında daha fazla bilgi edinecek, list comprehension'ları nasıl kurabileceğinizi, bunları for döngüleri veya lambda fonksiyonları olarak nasıl yeniden yazabileceğinizi öğreneceksiniz... Bunları sadece okumakla kalmayacak, bazı alıştırmalar da yapacaksınız!
• Temelleri kavradığınızda, koşullar ekleyerek list comprehension'larınızı ince ayar yapmanın zamanı gelmiş olacak: List comprehension'lara koşulları nasıl dahil edebileceğinizi ve birden fazla if koşulunu ve if-else ifadelerini nasıl ele alacağınızı öğreneceksiniz.
• Son olarak, listeler üzerinde birden fazla kez yinelemek için iç içe list comprehension'lara dalacaksınız.

List comprehension'ları yineleyiciler ve üreteçlerle birlikte ele almakla da ilgileniyor musunuz? DataCamp'in Python Data Science Toolbox kursuna göz atın!

Python Listeleri

Şimdiye kadar, birden fazla veri tipine sahip değerlerle muhtemelen uğraştınız. Her bir değeri ayrı bir değişkende sakladınız: her değişken tek bir değeri temsil eder. Ancak veri biliminde, sıklıkla çok sayıda veri noktasıyla çalışırsınız; bu da her bir değeri ayrı bir değişkende saklamaya devam etmeyi zorlaştırır. Bunun yerine, tüm bu değerleri bir Python listesinde saklarsınız.

Listeler Python'daki dört yerleşik veri yapısından biridir. Bildiğiniz diğer veri yapıları arasında demetler (tuple), sözlükler (dictionary) ve kümeler (set) bulunur. Python'da bir liste, örneğin int veya bool'dan farklıdır; çünkü bileşik bir veri tipidir: değerleri listelerde bir araya toplayabilirsiniz. Üstelik bu değerlerin aynı tipte olması gerekmez: boolean, String, integer, ... değerlerinin bir kombinasyonu olabilirler.

Burada önemli olan, listelerin öğelerin veya nesnelerin sıralı koleksiyonları olduğudur. Bu, Python'daki listeleri bir "dizi türü" yapar; çünkü bir dizi gibi davranırlar. Bu da onların yinelenebilir olduğu anlamına gelir; String'ler, demetler veya kümeler diğer dizi örnekleridir.

İpucu: Python listeleri hakkında daha fazla bilgi edinmek, bilginizi test etmek veya pratik yapmak isterseniz, Python listeleriyle ilgili en yaygın soruları buradan inceleyebilirsiniz.

Şimdi, pratik olarak: bir listeyi iki köşeli parantezle oluşturursunuz; Bu parantezlerin içine değerlerinizi virgülle ayırarak yazarsınız. Ardından listenizi bir değişkene atayabilirsiniz. Python listesine koyduğunuz değerler herhangi bir veri tipinde olabilir, hatta listeler bile!

Aşağıdaki liste örneğine bir göz atın:

İpucu: Yukarıdaki DataCamp Light bloğunun içindeki IPython kabuğunda kendi listenizi oluşturun!

Python List Comprehension

Python listelerine dair özeti aklınızda tutarak, Python'da listeleri tanımlamanın ve oluşturmanın zahmetli olabileceğini kolayca görebilirsiniz: tüm değerleri tek tek yazmak oldukça zaman alabilir ve kolayca hata yapabilirsiniz.

Python'da list comprehension'lar şu şekilde kurulur:

list_variable = [x for x in iterable]

Peki Python'da bu yapıların formül gibi görünen bu kurulumuna nasıl ulaşırsınız? Biraz daha derine inelim.

Python'da List Comprehension: Matematik

Neyse ki Python bunun için bir çözüm sunar: bunu yapmak için matematiksel bir gösterimi uygulamanıza olanak tanır: list comprehension.

Hatırlayın, matematikte listeleri (veya kümeleri, demetleri, vektörleri) tanımlamanın yaygın yolları şunlardır:

S = {x² : x in {0 ... 9}}
V = (1, 2, 4, 8, ..., 2¹²)
M = {x | x in S and x even}

Başka bir deyişle, yukarıdaki tanımların size aslında şunları söylediğini görürsünüz:

• S dizisi, 0 ile 9 dahil arasındaki değerlerin ikinin kuvvetine yükseltildiği bir dizidir.
• Öte yandan V dizisi, 2 değerinin belirli bir kuvvete yükseltildiği değerleri içerir. Dizideki ilk eleman için bu 0, ikincisi için 1'dir ve böyle devam eder, 12'ye kadar.
• Son olarak M dizisi, S dizisindeki öğeleri içerir ancak yalnızca çift olanları.

Yukarıdaki tanımlar başınızı ağrıtıyorsa, bu tanımların üreteceği gerçek listelere bir bakın:

S = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
V = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096}
M = {0, 4, 16, 36, 64}

Her listenin sonucunu ve içlerinde tanımlanan işlemleri açıkça görüyorsunuz!

Artık listelerin arkasındaki matematiğin bir kısmını anladığınıza göre, Python'da listeleri oluşturmanın bu matematiksel gösterimini list comprehension'ları kullanarak çevirebilir veya uygulayabilirsiniz! Aşağıdaki kod satırlarına bir göz atın:

Bunların hepsi az önce gördüğünüz matematiksel tanımlara oldukça benziyor, değil mi?

Bu noktada biraz kaybolduysanız endişelenmeyin; Matematik dahisi olmasanız bile, bu list comprehension'lar üzerine düşünmek için zaman ayırırsanız oldukça kolaydır. Yukarıdaki kod bloğunda gördüğünüz Python koduna ikinci, daha dikkatli bir bakış atın.

Kodun size şunları söylediğini göreceksiniz:

• S listesi, ilk bölümde okuduğunuz köşeli parantezlerle oluşturulmuştur. Bu parantezlerin içinde 10. kuvvete yükseltilen bir x öğesi görürsünüz. Şimdi, kaça (ve hangi değerlere!) 2'nin kuvvetini uygulamanız gerektiğini bilmeniz gerekir. Bu, range(10) içinde belirlenir. Tüm bunları dikkate alarak, 0'dan 9'a kadar tüm sayıları 2'nin kuvvetine yükselteceğinizi çıkarabilirsiniz.
• V listesi, belirli bir kuvvete yükseltilen taban değer 2'yi içerir. Tıpkı önceki gibi, şimdi bunun için hangi kuvvetin yani i'nın kullanılacağını bilmeniz gerekir. Bu durumda i'nin range(13)'ün parçası olduğunu görürsünüz; bu da 0'dan başlayıp 12'ye kadar gittiğiniz anlamına gelir. Tüm bunlar, listenizin 13 değer içereceği anlamına gelir — bu değerler 2'nin 0, 1, 2, ... 12'ye kadar olan kuvvetleridir.
• Son olarak M listesi, yalnızca 2'ye kalansız bölünebilen S'nin öğelerini içerir. Modülonun 0 olması gerekir. Başka bir deyişle, M listesi S listesinde saklanan uygun değerlerle oluşturulur.

Hepsi yazılı olarak görünce çok daha mantıklı geliyor, değil mi?

Özet ve Pratik

Kısacası, tüm bu kod satırlarında tekrar eden birkaç öğe olduğunu görürsünüz:

• Python listelerinin imzası olan köşeli parantezler;
• Bir liste öğesini simgeleyen bir değişkenin ardından gelen for anahtar sözcüğü; ve
• Bir dizinin (liste de olabilir!) ardından gelen in anahtar sözcüğü.

Ve bu, bu bölümün başında gördüğünüz kod parçasıyla sonuçlanır:

list_variable = [x for x in iterable]

Şimdi Python'da list comprehension'larla başlama sırası sizde! Daha önce gördüğünüz matematiksel listelere yakın duralım:

List Comprehension Şunun Yerine...

List comprehension, for döngülerine, lambda fonksiyonlarına ve map(), filter() ve reduce() fonksiyonlarına tam bir alternatiftir. Dahası, bazıları için list comprehension'ı anlamak ve pratikte kullanmak daha da kolay olabilir! Bununla ilgili daha fazlasını bir sonraki bölümde okuyacaksınız!

Ancak Python'da fonksiyonlar ve lambda fonksiyonları hakkında daha fazla bilgi edinmek isterseniz, Python Fonksiyonları Eğitimimize göz atın.

For Döngüleri

Bildiniz gibi, for döngülerini bir kod bloğunu sabit sayıda kez tekrarlamak için kullanırsınız. List comprehension'lar, daha derli toplu oldukları için aslında for döngülerine iyi bir alternatiftir. 0'dan 10'a (10 hariç) kadar bir aralık olarak tanımlanan numbers değişkeniyle başlayan aşağıdaki örneği düşünün.

Unutmayın ki range() fonksiyonuna verdiğiniz sayı, sıfırdan başlayarak üretmek istediğiniz tamsayıların sayısıdır. Bu, range(10)'un [0,1,2,3,4,5,6,7,8,9] döndüreceği anlamına gelir.

# Initialize `numbers`
numbers = range(10)

Artık numbers içindeki her eleman üzerinde bir işlem yapmak isterseniz, bunu şöyle bir for döngüsüyle yapabilirsiniz:

# Initialize `new_list`
new_list = []

# Add values to `new_list`
for n in numbers:
    if n%2==0:
        new_list.append(n**2)

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Bu gayet güzel, ancak şimdi, aynı şeyi daha derli toplu bir gösterimle yaptığınız aşağıdaki list comprehension örneğini düşünün:

# Create `new_list` 
new_list = [n**2 for n in numbers if n%2==0]

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

List comprehension ile for döngüsünün performans farkını küçük bir testle inceleyelim: Bunu, küçük Python kod parçalarını basit şekilde zamanlamak için kullanabileceğiniz timeit kütüphanesiyle çok hızlı kurabilirsiniz. Bu durumda test edeceğiniz küçük kod parçaları, kolaylık olması için power_two() adlı bir fonksiyona koyacağınız for döngüsü ve yukarıda yazdığınız list comprehension olacaktır.

Not ayrıca dikkate almak istediğiniz yürütme sayısını da geçirirsiniz. Bu örnekte number argümanında 10000 olarak ayarlanmıştır.

# Import `timeit`
import timeit

# Print the execution time
print(timeit.timeit('[n**2 for n in range(10) if n%2==0]', number=10000))

0.05234622399802902

# Define `power_two()` 
def power_two(numbers):
    for n in numbers:
        if n%2==0:
            new_list.append(n**2)
    return new_list

# Print the execution time 
print(timeit.timeit('power_two(numbers)', globals=globals(), number=10000))

0.07795589299712447

Not bu son kod parçasında, kodun geçerli global ad alanınızda yürütülmesine neden olacak globals argümanını da eklediğinizi unutmayın. Bu, yukarıdaki örnekteki power_two() gibi Kullanıcı Tanımlı Bir Fonksiyonunuz (UDF) varsa son derece kullanışlıdır. Alternatif olarak bir içe aktarma ifadesi içeren bir setup parametresi de geçebilirsiniz. Bununla ilgili daha fazlasını burada okuyabilirsiniz.

İpucu: Python'da döngüler hakkında daha fazla bilgi için DataCamp'in Döngüler (Loops) in Python eğitimine göz atın.

Lambda Fonksiyonları ile map(), filter() ve reduce()

Lambda fonksiyonları "anonim fonksiyonlar" ya da "isimsiz fonksiyonlar" olarak da adlandırılır. Bu, bu tür fonksiyonları yalnızca oluşturuldukları anda kullandığınız anlamına gelir. Lambda fonksiyonları adlarını, bu fonksiyonları standart def anahtar sözcüğü yerine bildirmek için kullanılan lambda anahtar sözcüğünden alır.

Bu fonksiyonları genellikle map(), filter() ve reduce() fonksiyonlarıyla birlikte kullanırsınız.

Lambda Fonksiyonlarıyla Birlikte map()'in Nasıl Yerine Geçilir

map() ile bir lambda fonksiyonunun birleşimini aşağıdaki örnekteki gibi yeniden yazabilirsiniz:

# Initialize the `kilometer` list 
kilometer = [39.2, 36.5, 37.3, 37.8]

# Construct `feet` with `map()`
feet = map(lambda x: float(3280.8399)*x, kilometer)

# Print `feet` as a list 
print(list(feet))

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

Artık önceki bölümde okuduğunuz bileşenleri dikkate alarak, feet değişkenini tanımlayan bu fonksiyonlar kombinasyonunu list comprehension'larla kolayca değiştirebilirsiniz:

• Köşeli parantezlerle başlayın.
• Ardından köşeli parantezlerin içine lambda fonksiyonunun gövdesini ekleyin: float(3280.8399)*x.
• Daha sonra for anahtar sözcüğünü ekleyin ve lambda fonksiyonunun gövdesini ekleyerek zaten referans verdiğiniz dizi öğesi x'i tekrarladığınızdan emin olun.
• x'in nereden geldiğini belirtmeyi unutmayın: in anahtar sözcüğünü ve ardından x'i alacağınız diziyi ekleyin. Bu durumda, kilometer listesinin öğelerini dönüştüreceksiniz.

Tüm bunları yaparsanız aşağıdaki sonucu elde edersiniz:

# Convert `kilometer` to `feet` 
feet = [float(3280.8399)*x for x in kilometer]

# Print `feet`
print(feet)

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

filter() ve Lambda Fonksiyonlarından List Comprehension'lara

Artık map() fonksiyonunu bir lambda fonksiyonuyla ne kadar kolay dönüştürebildiğinizi gördüğünüze göre, Python filter() fonksiyonunu içeren kodu da ele alabilir ve onu da yeniden yazabilirsiniz.

Aşağıdaki örneği düşünün:

# Map the values of `feet` to integers 
feet = list(map(int, feet))

# Filter `feet` to only include uneven distances 
uneven = filter(lambda x: x%2, feet)

# Check the type of `uneven`
type(uneven)

# Print `uneven` as a list
print(list(uneven))

[122375, 124015]

Yukarıdaki örnekteki kod satırlarını yeniden yazmak için, hem feet hem de uneven değişkenlerinde saklanan iki list comprehension kullanabilirsiniz.

Önce, feet listesinin öğelerini tamsayıya dönüştürmek için kullandığınız map() fonksiyonunu yeniden yazın. Ardından filter() fonksiyonunu ele alın: lambda fonksiyonunun gövdesini alın, x ve feet'i mantıksal olarak bağlamak için for ve in anahtar sözcüklerini kullanın:

# Constructing `feet` 
feet = [int(x) for x in feet]

# Print `feet`
print(feet)

# Get all uneven distances
uneven = [x%2 for x in feet]

# Print `uneven`
print(uneven)

[128608, 119750, 122375, 124015]
[0, 0, 1, 1]

Reduce reduce() ve Python'da Lambda Fonksiyonları

Son olarak, reduce() fonksiyonuyla kullanılan lambda fonksiyonlarını da daha derli toplu kod satırlarına dönüştürebilirsiniz. Aşağıdaki örneğe bakın:

# Import `reduce` from `functools` 
from functools import reduce

# Reduce `feet` to `reduced_feet`
reduced_feet = reduce(lambda x,y: x+y, feet)

# Print `reduced_feet`
print(reduced_feet)

[128608, 119750, 122375, 124015]
494748

Not Python 3'te reduce() fonksiyonu functools paketine taşınmıştır. Bu nedenle, yukarıdaki kod örneğinde olduğu gibi modülü kullanmak için içe aktarmanız gerekir.

Yukarıdaki kod parçası oldukça uzun, değil mi?

Bu kodu yeniden yazalım!

Dikkatli olun! y'yi kullanamayacağınızı hesaba katmanız gerekir. List comprehension'lar, bu eğitimdeki çok sayıda örnekte gördüğünüz x gibi yalnızca tek bir öğeyle çalışır.

Bunu nasıl çözeceksiniz?

Böyle durumlarda, sum() gibi toplama (aggregate) fonksiyonları işe yarayabilir:

# Construct `reduced_feet`
reduced_feet = sum([x for x in feet])

# Print `reduced_feet`
print(reduced_feet)

494748

Not düşündüğünüzde, bir lambda fonksiyonuyla birlikte reduce() fonksiyonunu yeniden yazarken toplama fonksiyonlarını kullanmak mantıklıdır: sorgunuzu çalıştırdıktan sonra geri aldığınız kayıt sayısını sınırlamak için SQL'de toplama fonksiyonlarını kullanmanıza çok benzer. Bu durumda, feet içindeki öğeleri toplamak ve yalnızca tek bir kesin değer elde etmek için sum() fonksiyonunu kullanırsınız!

Bu yaklaşım SQL'de her zaman en performanslı olmayabilir olsa da, Python'da kesinlikle tercih edilmesi gereken yoldur!

Koşullu List Comprehension'lar

Artık Python'da list comprehension'ların temellerini anladığınıza göre, koşulların yardımıyla comprehension'larınızın kontrol akışını ayarlamanın zamanı geldi.

# Define `uneven`
uneven = [x/2 for x in feet if x%2==0]

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Not Yukarıdaki kod bloğunu bir Python for döngüsüyle kolayca yeniden yazabilirsiniz!

# Initialize and empty list `uneven` 
uneven = []

# Add values to `uneven` 
for x in feet:
    if x % 2 == 0:
        x = x / 2
        uneven.append(x)

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Birden Fazla If Koşulu

Artık koşulları nasıl ekleyebileceğinizi anladığınıza göre, aşağıdaki for döngüsünü koşullu bir list comprehension'a dönüştürme zamanı.

divided = []

for x in range(100):
    if x%2 == 0 :
        if x%6 == 0:
            divided.append(x)

Dikkat edin, aşağıdaki for döngüsünde iki koşul var! Bunu nasıl çözeceğinizi dikkatlice düşünün.

divided = [x for x in range(100) if x % 2 == 0 if x % 6 == 0]

print(divided)

[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

If-Else Koşulları

Elbette, birden fazla koşul içeren ifadelerle çalışmak çok daha yaygındır. Doğru, if'i daha sık elif ve else ile birlikte görürsünüz. Peki, kodunuzu yeniden yazmayı planlıyorsanız bunu nasıl ele alırsınız?

Böyle daha karmaşık bir koşulun for döngüsündeki aşağıdaki örneğine bakın:

[x+1 if x >= 120000 else x+5 for x in feet]

[128609, 119755, 122376, 124016]

Şimdi, yukarıdaki kod parçasının yeniden yazılmış hali olan aşağıdaki kod bloğuna bakın:

for x in feet:  
    if x >= 120000:
        x + 1
    else: 
        x+5

Gördüğünüz gibi bu, temelde aynı kod ancak yeniden yapılandırılmış: sondaki for x in feet artık for döngüsünü başlatır. Sonrasında if x >= 120000 koşulunu ve bu koşul True ise çalıştırmak istediğiniz kod satırını eklersiniz: x + 1. Koşul bunun yerine False ise, list comprehension'ınızdaki son kısım yürütülür: x+5.

İç İçe List Comprehension'lar

Koşullara ek olarak, list comprehension'larınızı diğer list comprehension'ların içine yerleştirerek de ayarlayabilirsiniz. Bu, listelerin listeleriyle çalışmak istediğinizde kullanışlıdır: örneğin listelerin listelerini üretmek, listelerin listelerini döndürmek (transpose) veya listelerin listelerini normal listelere düzleştirmek, iç içe list comprehension'larla son derece kolaylaşır.

Aşağıdaki örneğe bakın:

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

# Flatten `list_of_list`
[y for x in list_of_list for y in x]

[1, 2, 3, 4, 5, 6, 7, 8]

list_of_list değişkenine oldukça basit bir liste listesi atarsınız. Sonraki satırda, normal bir liste döndüren bir list comprehension yürütürsünüz. Aslında olan şey, list_of_list içindeki iç listelerin (x) liste öğelerini (y) almanız ve x'te yer alan bu y liste öğelerinin bir listesini döndürmenizdir.

İç içe list comprehension örneğinde kullanılan anahtar sözcüklerin ve öğelerin çoğunun, basit list comprehension örneklerinde kullandıklarınıza benzer olduğunu görürsünüz:

• Köşeli parantezler
• Listelerin listesinin bir öğesini (x) ve iç listenin bir öğesini (y) simgeleyen bir değişkenin ardından gelen iki for anahtar sözcüğü; ve
• Bir listeler listesi (list_of_list) ve bir liste öğesinin (x) ardından gelen iki in anahtar sözcüğü.

Bileşenlerin çoğu sadece iki kez kullanılır ve bir seviye yukarıya (ya da aşağıya, bakış açınıza göre!) gidersiniz.

Alışmak biraz zaman alır ama oldukça basit, değil mi?

Şimdi, iç içe list comprehension mantığını iki çift köşeli parantez kullanarak da değiştirebileceğinizi gösteren başka bir örneği ele alalım:

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

[[row[i] for row in matrix] for i in range(3)]

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

Şimdi pratik: Yukarıdaki kod bloğunu iç içe for döngüsüne dönüştürün. Bu alıştırmayı nasıl ele alacağınıza dair ipuçlarına ihtiyacınız olursa, bu eğitimin önceki bölümlerine gidin.

transposed = []

for i in range(3):
     transposed_row = []
     for row in matrix:
            transposed_row.append(row[i])
     transposed.append(transposed_row)

Ayrıca iç içe list comprehension'ları, aslında bir matris olan bir listeler listesi oluşturmanız gerektiğinde de kullanabilirsiniz. Aşağıdaki örneğe göz atın:

matrix = [[0 for col in range(4)] for row in range(3)]

matrix

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

İpucu: Python'da döngü becerilerinizi pratiğe dökün ve yukarıdaki kod bloğunu iç içe for döngüsüne çevirin!

Çözümü aşağıda bulabilirsiniz.

for x in range(3):
    nested = []
    matrix.append(nested)
    for row in range(4):
        nested.append(0)

Biraz daha fazlasını yapmak isterseniz, bu for döngüsünü while döngüsüne çevirmeye çalışın. Çözümü aşağıda bulabilirsiniz:

x = 0
matrix =[]

while x < 3:
    nested = []
    y = 0
    matrix.append(nested)
    x = x+1
    while y < 4:
        nested.append(0)
        y= y+1

Son olarak, feet listenizdeki girişleri tamsayıya dönüştürmek için int() gibi fonksiyonları da kullanabileceğinizi bilmek iyidir. [int(x) for x in feet]'i başka bir list comprehension içine alarak, listenizden kolayca bir matris ya da listelerin listesi oluşturursunuz:

[[int(x) for x in feet] for x in feet]

[[128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015]]

Veri Bilimi için Python'u Ustalaşın

Tebrikler! Bu eğitimde sonuna geldiniz; burada Python'da veri bilimi için sıkça kullanılan bir mekanizma olan list comprehension'ları ele aldınız. Artık bu mekanizmanın nasıl çalıştığını anladığınıza göre, sözlük, küme, ... comprehension'larını da ele almaya hazırsınız!

Python becerilerinizi her gün DataCamp'in günlük pratik modu ile geliştirebileceğinizi unutmayın! Kontrol panelinizde bulabilirsiniz. Günlük pratik modunu henüz bilmiyorsanız, buradan okuyun! Ve DataCamp'in tam Python kurs kataloğunu burada keşfedin.

List comprehension'lar kodumuzu daha özlü hale getirebilse de, nihai kodumuzun mümkün olduğunca okunabilir olmasını sağlamak önemlidir; bu nedenle, kullanıcı dostu olması için çok uzun tek satırlık kodlardan kaçınılmalıdır.