Örneklerle Daha İyi Kod İçin 30 Havalı Python Püf Noktası

Python kodlama becerilerine olan talep son yıllarda arttı. Python programlama becerilerinizi geliştirmenize yardımcı olmak için, kodunuzu iyileştirmek üzere kullanabileceğiniz 30 havalı Python püf noktasını derledik. Önümüzdeki 30 gün boyunca her gün bir tane öğrenmeye çalışın ve kodunuzun sınıfının en iyisi olduğundan emin olmak için Python en iyi uygulamaları yazımıza göz atın. 

Python becerileriniz yeterince iyi değilse, Python Beceri Yolu ile onları keskinleştirebilirsiniz.

Diziler ve Veri Yapısı Püf Noktaları

#1 Dilimleme

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

Dilimleme, kullanıcıların bir dizinin alt kümesine erişmesine olanak tanımak için indekslemeye dayanan bir Python özelliğidir. İndeks, bir dizideki bir öğenin konumudur. Eğer dizi türü değiştirilebilir (mutable) ise, verileri çıkarmak ve değiştirmek için dilimlemeyi kullanabilirsiniz. 

Not: Değiştirilemeyen (immutable) bir dizi üzerinde de dilimleme yapabiliriz, ancak dilimi değiştirmeye çalışmak TypeError yükseltir. 

Dilimlerin uygulandığı biçim şudur: sequence[start:stop:step]. start, stop ve step parametrelerinde değer belirtilmezse, dizi varsayılanları uygular. Varsayılanlar şunlardır: 

• "start" varsayılanı 0’dır 
• "stop" varsayılanı dizinin uzunluğudur
• "step" belirtilmezse varsayılanı 1’dir. 

sequence[start:stop] verildiğinde, döndürülen öğeler başlangıç indeksinden stop - 1’e kadar olur (stop indeksi dahil değildir). 

Ayrıca, diziyi tersine çevirmek için kullanılabilecek negatif indeksler de geçirebiliriz. Örneğin, 4 öğeli bir listede 0. indeks aynı zamanda -4 indeksidir ve son indeks de -1’dir. Yukarıdaki örnek kodda, bu bilgi dizinin step parametresine uygulandı. Sonuç olarak, dize dizinin sonundan 0 indeksine doğru geriye doğru yazdırıldı.   

#2 Yerinde değiştirme / eşzamanlı atama

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

İlk izleniminiz b değerinin 12 yerine 7 olacağı yönündeyse, yerinde değiştirme tuzağına düşmüşsünüzdür. 

Python’da, tek bir atamada yinelemelileri otomatik açma ile değişkenlere açabiliriz. Örneğin: 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

Ayrıca * kullanarak birkaç değeri tek bir değişkende toplayabiliriz – bu Python püf noktası paketleme (packing) olarak adlandırılır. Aşağıda paketlemeye bir örnek vardır.  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

Otomatik paketleme ve açmayı birleştirmek, eşzamanlı atama olarak bilinen bir tekniği ortaya çıkarır. Bir dizi değeri bir dizi değişkene atamak için eşzamanlı atamayı kullanabiliriz.

#3 Listeler ve tuple’lar 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""

Çoğu Python programcısı liste veri yapısını bilir. Aynısı tuple’lar için söylenemez. Her ikisi de yinelenebilir, indekslemeye izin verir ve heterojen veri tiplerini saklayabilir. Ancak bazı durumlarda liste yerine tuple kullanımı tercih edilebilir. 

Öncelikle, listeler değiştirilebilirdir; yani istediğimiz gibi değiştirebiliriz: 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

Öte yandan tuple’lar değiştirilemezdir; onları değiştirmeye çalışmak TypeError yükseltir. 

Bu nedenle, Python veriler için gereken doğru bellek bloğunu ayırabildiğinden tuple’lar bellek açısından daha verimlidir. Buna karşılık, bir listede, listeyi genişletebileceğimiz ihtimaline karşı fazladan bellek ayrılmalıdır – buna dinamik bellek tahsisi denir. 

Kısacası; Verilerin değişmesini istemediğiniz senaryolarda, bellek nedenleriyle liste yerine tuple tercih edilmelidir. Tuple’lar listelerden ayrıca daha hızlıdır. 

Bu eğitimde Python Veri Yapıları hakkında daha fazla bilgi edinin. 

#4 Üreteçler (Generators)

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

Liste üreteçleri, başka bir yinelemeden liste oluşturmanın Pythonik yoludur – for döngüsü kullanmaktan çok daha hızlıdır. Peki köşeli parantezleri []’den ()’e yanlışlıkla değiştirirseniz ne olur? Bir üreteç nesnesi elde edersiniz.

Python’da, liste üreteci mantığıyla yuvarlak parantezler, üreteç nesnesi olarak bilinen şeyi oluşturur. Üreteçler özel bir tür yineleyicidir. Listelerden farklı olarak, öğelerini saklamazlar. Bunun yerine, her öğeyi sırayla üretmek için talimatları ve yinelemelerin mevcut durumunu saklarlar.

Her öğe, tembel değerlendirme adlı bir teknik kullanılarak yalnızca talep edildiğinde üretilir. Bir üreteç kullanmanın başlıca faydası, tüm dizinin bir kerede oluşturulmaması nedeniyle daha az bellek kullanmasıdır. 

#5 Adlandırma çakışması (Aliasing) 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python nesne yönelimli bir programlama dilidir – her şey bir nesnedir. Dolayısıyla, bir nesneyi bir tanımlayıcıya atamak, o nesneye bir başvuru oluşturmaktır. 

Bir tanımlayıcıyı başka bir tanımlayıcıya atadığımızda, aynı nesneye başvuru yapan iki tanımlayıcı elde ederiz. Bu, aliasing (ad paylaşımı) olarak bilinen bir kavramdır. Bir alias’taki değişiklikler diğerini etkiler. Bazen bu davranış istenir, ancak çoğu zaman hazırlıksız yakalanırız. 

Bundan kaçınmanın bir yolu, değiştirilebilir nesneler kullanırken aliasing’den kaçınmaktır. Bir başka çözüm de başvuru yerine orijinal nesnenin bir klonunu oluşturmaktır. 

Bir klon oluşturmanın en basit yolu dilimlemeden yararlanmaktır: 

b = a[:] 

Bu, b tanımlayıcısında yeni bir liste nesnesine başvuru oluşturacaktır. 

Verileri başka bir tanımlayıcıya atarken list(a) çağırmak ve copy() yöntemini kullanmak gibi başka birçok çözüm de üretebilirsiniz. 

#6 ‘not’ işleci

a = []
print(not a)

"""
True
"""

Sıradaki Python ipucumuz, veri yapınızın boş olup olmadığını kontrol etmenin en kolay yolu olan not işlemcisini kullanmaktır. Python’un yerleşik not işleci, ifade doğru değilse True döndürür; aksi halde False döndürür – yani Boole ifadelerinin ve nesnelerin doğruluk değerini tersine çevirir.  

Başka bir kullanımını if deyiminde görebilirsiniz: 

if not a:
    # do something... 

a True olduğunda not işleci False döndürür ve tersi de geçerlidir. 

Bunu kavramak biraz zordur, bu yüzden denemekten çekinmeyin.

String ve Çıktı Püf Noktaları

#7 F-string’ler

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

Bazen bir string nesnesini biçimlendirmemiz gerekebilir; Python 3.6, bu süreci basitleştirmek için f-string adlı havalı bir özellik getirdi. Yeni yöntemi daha iyi anlamak için, önceki sürümlerde dizelerin nasıl biçimlendirildiğini bilmek faydalıdır. 

Eskiden dizeler şu şekilde biçimlendirilirdi: 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

Özetle, yeni biçimlendirme yöntemi daha hızlı, daha okunaklı, daha öz ve hata yapması daha zordur.

F-string’lerin bir başka kullanım alanı da bir tanımlayıcı adını değeriyle birlikte yazdırmaktır. Bu özellik Python 3.8’de tanıtıldı.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Daha fazlasını öğrenmek için Python’da F-string Biçimlendirme eğitimine göz atın. 

#8 print() fonksiyonunun ‘end’ parametresi

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

Çoğunlukla, print ifadesini isteğe bağlı parametrelerinden herhangi birini tanımlamadan kullanırız. Sonuç olarak, birçok Python geliştiricisi çıktıyı belli ölçüde kontrol edebileceğinizin farkında değildir.

Değiştirebileceğimiz isteğe bağlı parametrelerden biri end’dir. end parametresi, bir print çağrısının sonunda ne gösterileceğini belirtir. 

end’in varsayılanı, Python’a yeni bir satır başlatmasını söyleyen "\n"’dir. Yukarıdaki kodda bunu boşluk olarak değiştirdik. Böylece listemizdeki tüm öğeler aynı satırda yazdırıldı.

#9 Tuple’a ekleme

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

Tuple’ların değiştirilemez olduğunu zaten biliyoruz – bkz. Python püf noktası #3 Listeler ve Tuple’lar. Bir tuple’ın durumunu değiştirmeye çalışmak TypeError fırlatır. Ancak bir tuple nesnesini, bağları değiştirilemeyen nesnelere sahip bir adlar dizisi olarak düşünürseniz, duruma farklı bakabilirsiniz.

Tuple’ımızın ilk iki öğesi tamsayı – bunlar değiştirilemezdir. Son öğe ise Python’da değiştirilebilir bir nesne olan listedir.

Listemizi, bağının değiştirilemeyeceği bir dizideki başka bir ad olarak kabul edersek, listenin tuple içinden yine de değiştirilebileceğini fark ederiz.

Bunu pratikte yapmanızı önerir miyiz? Muhtemelen hayır, ama bilmekte fayda var!

#10 Sözlükleri birleştirme

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

Python 3.9 ve sonrasında, sözlükleri | (bit düzeyinde VEYA) ile birleştirmek mümkündür. Bu Python püf noktası hakkında söylenecek çok fazla şey yok; sadece çok daha okunaklı bir çözümdür! 

Kod Stili ve Söz Dizimi Püf Noktaları

#11 Üçlü (ternary) işleç / koşul ifadeleri 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

Yukarıdaki kodda, üçlü işleç olarak bilinen yapıyı görüyorsunuz – başka adlarla koşullu ifade olarak da anılır. Bir koşul True veya False olduğuna göre şeyleri değerlendirmek için üçlü işleçler kullanırız.

Kodumuzu başka bir şekilde de yazabilirdik:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Her iki kod da aynı çıktıyı üretse de, üçlü koşulun çok daha kısa ve daha net kod yazmamıza olanak verdiğine dikkat edin. Python geliştiricilerinin daha ‘Pythonik’ dediği yol budur. 

#12 Listelerden yinelenenleri kaldırma

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

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

Bir listeden yinelenen öğeleri kaldırmanın en basit yolu, listeyi bir kümeye (gerekirse tekrar listeye) dönüştürmektir.

Değiştirilebilirlik açısından bakıldığında, kümeler ve listeler Python’da oldukça benzerdir. Her iki veri yapısına da istediğimiz gibi öğe ekleyip çıkarabiliriz, ancak yine de birbirlerinden oldukça farklıdırlar.

Listeler sıralıdır, sıfır tabanlı indekslidir ve değiştirilebilirdir. Kümeler sırasız ve indekssizdir. Kümedeki öğeler değiştirilemez türden olmalıdır, her ne kadar kümenin kendisi değiştirilebilir olsa da – bir öğeye indeksle erişmeye veya bir öğeyi değiştirmeye çalışmak hata yükseltir.

Kümeler ve listeler arasındaki bir diğer önemli fark da kümelerin yinelenen öğe içerememesidir. İşte bu, listemizden yinelenenleri kaldırmamıza yardımcı oldu.

#13 Tek başına alt çizgi 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

Alt çizgi (_) Python’da yasal bir tanımlayıcıdır; dolayısıyla bir nesneye başvuru olarak kullanılabilir. Ancak alt çizginin başka bir sorumluluğu daha vardır: son değerlendirmenin sonucunu saklamak.

Dokümantasyonda, "etkileşimli yorumlayıcının son değerlendirmenin sonucunu _ değişkeninde kullanılabilir hale getirdiği (print gibi yerleşik işlevlerle birlikte builtins modülünde saklanır)" ifade edilir.

İlk satırda alt çizgiye bir nesne atamadığımız için hata aldık. Ancak 1 + 2’nin çıktısını hesapladığımızda, etkileşimli yorumlayıcı sonucu bizim için _ tanımlayıcısında sakladı. 

#14 Değerleri yok saymak için alt çizgi

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

Python ipucu #13’te, etkileşimli yorumlayıcının son değerlendirmenin sonucunu alt çizgi (_) tanımlayıcısında kullanılabilir kıldığını gördük; ancak tek kullanım alanı bu değildir.

Programın ilerleyen bir noktasında umursamadığımız veya kullanmayacağımız nesneleri temsil etmek için de kullanabiliriz. Bu önemlidir; çünkü alt çizgi (_) yerine bir tanımlayıcı kullanmak, programımızı lint ederken F841 hatası verecektir. F841 hatası, programda atanan ancak kullanılmayan yerel bir değişken adı olduğunu belirtir ki bu kötü bir uygulamadır.

#15 Sonda alt çizgi

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

Son iki püf noktasından devamla, Python’da alt çizgi (_) kullanımının bir diğer amacı Python anahtar sözcükleriyle çakışmaları önlemektir. 

PEP 8, sonda tek alt çizginin "Python anahtar sözcükleriyle çakışmaları önlemek için geleneksel olarak kullanılması" gerektiğinden bahseder. Ayrıca, "kısaltma veya yazım bozulması kullanmaktansa tek bir sonda alt çizgi eklemenin genellikle daha iyi olduğunu" belirtir. Dolayısıyla list_, lst’den daha iyidir.

#16 Başta alt çizgi

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

Deneyimli Python programcılarının sıkça bir tanımlayıcıya veya metoda başında alt çizgi eklediğini görürsünüz – ve bunun iyi bir nedeni vardır.

Bir tanımlayıcıya veya metoda eklenen baştaki alt çizgi, gizli bir anlama sahiptir: bu değişken veya metod yalnızca dahili kullanım içindir. Özünde, Python tarafından zorlanmayan ancak PEP 8’de tanımlanmış diğer programcılara bir bilgilendirmedir. Bu nedenle, baştaki alt çizgiler zayıf bir göstergedir.

Java’nın aksine, Python’da özel ve genel değişkenler arasında güçlü bir ayrım yoktur. Başka bir deyişle, yalnızca Python topluluğu buna anlam yüklediği için anlamlıdır. Dahil edilmeleri programınızın davranışını etkilemez.

#17 Görsel alt çizgi

Alt çizgi üzerine son ipucu; Şimdiye kadar alt çizgi için üç farklı kullanım alanını ele aldık, ancak Python’da Alt Çizginin (_) Rolü eğitimimizi inceleyerek daha fazlasını öğrenebilirsiniz. 

number = 1_500_000
print(number)

"""
15000000
"""

Alt çizgiyi kullanmanın bir başka yolu da tamsayı, kayan nokta ve karmaşık sayı sabitlerinde basamak gruplaması için görsel ayırıcı olarak kullanmaktır – bu özellik Python 3.6’da tanıtıldı. 

Fikir, uzun sabitlerin veya değeri parçalara net bir şekilde ayrılması gereken sabitlerin okunabilirliğini artırmaktı – detaylar için PEP 515’i okuyabilirsiniz.

Kod Stili ve Söz Dizimi Püf Noktaları

#18 __name__ == “__main__” 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

Bu söz dizimini birçok Python programında görmüş olma olasılığınız yüksektir; Python, "__main__" adlı özel bir ad kullanır ve çalıştırılan Python dosyası ana program ise bunu __name__ adlı tanımlayıcıya atar.

Ekran görüntüsünde gösterilen modülü (Python dosyası) başka bir modüle içe aktarmaya ve o dosyayı çalıştırmaya karar verirsek, kodumuzdaki ifadenin doğruluğu false olur. Çünkü başka bir modülden içe aktardığımızda, __name__ tanımlayıcısı modülün (Python dosyasının) adına ayarlanır. 

#19 ‘setdefault’ yöntemi 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""

Bir sözlükte çeşitli anahtarlar için değer belirlemek isteyebilirsiniz. Örneğin, bir derlemdeki kelimelerin sayısını takip ederken. Bunu yapmanın yaygın yolu şöyledir: 

1. Anahtarın sözlükte olup olmadığını kontrol edin
2. Varsa, değeri 1 artırın.
3. Yoksa, ekleyin ve değeri 1 olarak ayarlayın.

Kodda görünümü şöyledir:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Bunu daha öz bir şekilde yapmak için sözlük nesnenizde setdefault() yöntemini kullanabilirsiniz.

Yönteme geçirilen ilk argüman, varlığını kontrol etmek istediğimiz anahtardır. İkinci argüman ise, anahtar sözlükte zaten yoksa anahtarın ayarlanacağı değerdir – anahtar varsa yöntem anahtar değerini döndürür. Dolayısıyla değişmez.

Program Yapısı Püf Noktaları

#20 Regex eşleştirme

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

Düzenli ifadeler, aramak istediğiniz bir metin desenini belirtmenize olanak tanır; Çoğu kişi CTRL + F (Windows) ile bir şeyleri arayabileceğimizi bilir, ancak tam olarak ne aradığınızı bilmiyorsanız nasıl bulabilirsiniz? Yanıt, desenleri aramaktır.  

Örneğin, Birleşik Krallık numaraları benzer bir deseni izler: Başta sıfır ve ardından on rakam veya sıfır yerine +44 ve ardından on rakam – ikincisi uluslararası biçimde olduğunu gösterir. 

Düzenli ifadeler büyük zaman kazandırır. Görselimizdeki örnekleri regex yerine kurallarla yakalamak isteseydik, 10+ satır kod tutabilirdi. 

Düzenli ifadelerin nasıl çalıştığını öğrenmek, kod yazmasanız bile çok önemlidir. Çoğu modern metin düzenleyici ve kelime işlemci, bul ve değiştir özelliklerinde düzenli ifadeleri kullanmanıza izin verir.

#21 Regex pipe

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

Düzenli ifadelerde pipe (|) adlı özel bir karakter vardır; birden çok ifadeden birini eşleştirmenize olanak tanır ve her yerde kullanılabilir. Benzer birçok deseniniz olduğunda son derece kullanışlıdır.

Örneğin, 'Superman', 'Superwoman' ve 'Superhuman' aynı öneke sahiptir. Dolayısıyla, tekrar eden desen kısmını korumak ve farklı olması gereken kısımları değiştirmek için pipe’ı kullanabilirsiniz. Yine size değerli zaman kazandırır.

Dikkat edilmesi gereken nokta: Eşleştirmek istediğiniz ifadelerin tümü aynı metinde geçiyorsa, eşleşecek metnin ilk oluşumu döndürülür – örn. "Superwoman, Superman, Superhuman içeren bir örnek metin" Superwoman’ı döndürür.

#22 print() fonksiyonunun ‘sep’ parametresi

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""

print() fonksiyonunun tüm yeteneklerinden haberdar olmayan Python programcılarının sayısı ürkütücü; Eğer ilk programınız “Hello World” idiyse, print() muhtemelen Python öğrenirken ele aldığınız ilk yerleşik işlevlerden biriydi. print()’i ekranda biçimlendirilmiş mesajlar göstermek için kullanırız, ancak print() fonksiyonunda bundan çok daha fazlası var. 

Yukarıdaki kodda, biçimlendirilmiş mesajımızı göstermenin farklı yollarını gösterdik. sep parametresi, birden fazla nesne dahil edersek, nesnelerin nasıl ayrılması gerektiğini belirtmemize olanak tanıyan print() fonksiyonunda isteğe bağlı bir argümandır. 

Varsayılan ayrım boşluktur, ancak print ifadelerimizle bu işlevi değiştirdik – birinde sep "" olarak ayarlı ve diğerinde sep "." olarak ayarlı.

#23 Lambda fonksiyonları 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

Lambda fonksiyonları, Python ile yapabileceğiniz orta-ileri seviye şeylere götürür – bu kursla Orta Düzey Python öğrenin. İlk bakışta karmaşık görünürler, ancak oldukça basittirler.

Örnek kodumuzda yalnızca bir argüman kullandık, ancak istersek birden fazlasını da kullanabilirdik:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

Özünde, lambda anahtar sözcüğü tek satırda küçük, kısıtlı, anonim fonksiyonlar oluşturmamıza izin verir. Bunlar, def anahtar sözcüğüyle bildirilen normal bir fonksiyon gibi davranır, tek farkları adlarının olmamasıdır.

#24 ‘swapcase’ yöntemi

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

swapcase() yöntemi, bir string nesnesine uygulanarak büyük harfleri küçük, küçük harfleri büyük yapmak için tek satırda kullanılabilir. swapcase() yönteminin çok fazla kullanım alanı yoktur ama bilmek güzeldir.

#25 ‘isalnum’ yöntemi

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Diyelim ki kullanıcıların parola girmesini gerektiren bir program oluşturuyoruz ve parolanın harf ve sayı kombinasyonu içermesi gerekiyor. Bunu, string örneği üzerinde isalnum() çağırarak tek satırda yapabiliriz.

Yöntem, tüm karakterlerin alfabenin (A-Za-z) ve sayısal karakterlerin (0-9) parçası olup olmadığını kontrol eder. Boşluk veya sembol (!#%$&? vb.) False döndürür.

#26 İstisna (exception) yönetimi

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""

Python programları hata ile karşılaştığında sonlanır.

Bazen, özellikle son kullanıcı kodumuzla etkileşime giriyorsa, bu davranışı istemeyiz. Böyle bir durumda kodumuzun erkenden sonlanması ne kadar kötü olurdu?

İstisnai durumlarla nasıl başa çıkılacağına dair birkaç düşünce okulu vardır. Çoğu Python programcısı genellikle izin istemektense af dilemenin daha kolay olduğu düşüncesini benimser. Bu, çeşitli istisnai durumlara karşı zaman harcamak yerine, bir hatayı çevreleyen ve onu ele alabilen bağlam sağlayarak yakalamayı tercih edecekleri anlamına gelir. Bu düşüncenin arkasındaki fikir, tüm olası istisnai durumlara karşı önlem almaya çalışmanın zaman kaybı olduğudur.

Ancak bu, yalnızca bir sorun ortaya çıktıktan sonra onunla başa çıkacak bir mekanizma olduğunda geçerlidir.

#27 Listelerdeki farkları belirleme

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

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

Python’da iki liste arasındaki farkı karşılaştırmak için üç farklı yöntem burada. 

Not: list_1’in list_2’nin bir alt kümesi olduğunu kesin olarak bilmiyorsanız, çözüm 1 diğer iki çözümle aynı değildir.

#28 Args ve kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

*args ve **kwargs’ı, fonksiyonumuzun kaç değişken beklemesi gerektiğini bilmediğimizde bir fonksiyona parametre olarak kullanırız. 

*args parametresi, fonksiyona anahtarsız (yani, ilettiğimiz parametrelerin ilişkili bir adına ihtiyaç duymadığı) değişken sayıda parametre aktarmamıza olanak tanır. Öte yandan, **kwargs parametresi, fonksiyona isteğe bağlı sayıda anahtarlı parametre aktarmamıza olanak verir.

Aslında, *args ve **kwargs kelimeleri o kadar da sihirli değildir: gerçek sihir yıldız işaretlerindedir (*). Bu, yıldızlardan sonra herhangi bir kelimeyi kullanabileceğimiz anlamına gelir, ancak args ve kwargs kullanımının yaygın bir uygulama olduğunu ve Python geliştiricileri arasında benimsendiğini unutmayın. 

#29 Üç nokta (ellipsis)

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Üç nokta, Python’da (...) dizisiyle veya nesnenin kendisi (Ellipsis) çağrılarak elde edilen bir nesnedir.

En dikkat çekici kullanımı, NumPy’de çok boyutlu dizilere erişmek ve dilimlemek içindir; örneğin:

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

Üç noktanın bir başka kullanım alanı da uygulanmamış bir fonksiyonda yer tutucu olarak kullanmaktır. 

Bu, Ellipsis, ... veya pass kullanabileceğiniz ve hepsinin geçerli olacağı anlamına gelir.

#30 Liste üreteci

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Son Python püf noktamız, başka bir diziden liste oluşturmanın zarif bir yolu olan liste üreteçleri. Yukarıdaki kodda yaptığımız gibi gelişmiş mantık ve filtreleme yapmanıza olanak tanırlar.

Aynı hedefe ulaşmanın başka yolları da vardır; örneğin, aşağıdaki gibi bir lambda fonksiyonu kullanabilirdik:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Ancak birçok Python geliştiricisi bu çözümün, liste üretecine kıyasla çok daha az okunabilir olduğunu savunacaktır.