Örneklerle Daha İyi Kod İçin 30 Havalı Python İpucu

Python kodlama becerilerine olan talep son yıllarda arttı. Python programlama becerilerinizi geliştirmenize yardımcı olmak için, kodunuzu iyileştirmek amacıyla kullanabileceğiniz 30 havalı Python ipucunu 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 güçlü değilse, Python Becerisi Yol Haritası ile onları keskinleştirebilirsiniz.

#1 Dilimleme

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

"""
!dlroW olleH
"""

Dilimleme, kullanıcılara bir dizinin alt kümesine erişim sağlayan, indekslemeye dayanan bir Python özelliğidir. İndeks, bir dizideki bir öğenin konumudur. Dizi tipi değiştirilebilir (mutable) ise, veriyi çıkarmak ve değiştirmek için dilimlemeyi kullanabilirsiniz. 

Not: Değiştirilemez (immutable) bir dizide de dilimleme kullanabiliriz ancak dilimi değiştirmeye çalışmak TypeError yükseltir. 

Dilimlerin yazım biçimi: sequence[start:stop:step]. start, stop ve step parametrelerinde değer belirtilmezse, varsayılanlar uygulanır. Varsayılanlar: 

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

sequence[start:stop] sağlandığında, döndürülen öğeler başlangıç indeksinden stop - 1'e kadar olacaktır (stop indeksi dahil değildir). 

Negatif indeksler de geçebiliriz; bu, diziyi ters çevirmek için kullanılabilir. Örneğin, 4 öğeli bir listede, 0. indeks aynı zamanda -4 indeksidir ve son indeks aynı zamanda -1'dir. Yukarıdaki örnekte bu bilgi, dizinin step parametresine uygulanmıştır. Sonuç olarak, dizi sonundan 0. indekse doğru geriye doğru yazdırılmıştır.   

#2 Yerinde Değiş Tokuş / 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ş tokuş tuzağına düşmüşsünüz demektir. 

Python'da, otomatik açma ile yinelenebilirleri tek bir atamada 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 birden çok değeri tek bir değişkende toplayabiliriz – bu Python hilesine paketleme (packing) denir. Aşağıda bir paketleme örneği 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 tekniği ortaya çıkarır. Bir dizi değeri bir dizi değişkene atamak için eşzamanlı atamayı kullanabiliriz.

#3 Listeler vs. Demetler (Tuples) 

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ı şeyi demetler için söyleyemeyiz. İkisi de yinelenebilirdir, indekslemeye izin verir ve heterojen veri tiplerini saklayabilir. Ancak bazı durumlarda liste yerine demet 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]
"""

Demetler ise değiştirilemezdir; yani onları değiştirmeye çalışmak bir TypeError yükseltir. 

Bu nedenle, demetler daha bellek verimlidir; çünkü Python veri için gereken doğru bellek bloğunu ayırabilir. Liste söz konusu olduğunda ise, genişletebileceğimiz ihtimaline karşı fazladan bellek ayrılması gerekir – buna dinamik bellek ayırma denir. 

Kısaca; Verinin değişmemesini istediğiniz senaryolarda, bellek açısından liste yerine demet tercih edilmelidir. Demetler ayrıca listelerden 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 (list comprehension), başka bir yinelenebilirden liste oluşturmanın Pythonik yoludur – for döngüsü kullanmaktan çok daha hızlıdır. Peki köşeli parantezleri [] yanlışlıkla () ile değiştirirseniz ne olur? Bir üreteç nesnesi elde edersiniz.

Python'da, liste üretecine benzer mantıkla yazılmış yuvarlak parantezler bir üreteç nesnesi oluşturur. Üreteçler özel bir tür yinelenebilirdir. Listelerden farklı olarak öğelerini saklamazlar; bunun yerine her öğeyi sırayla üretmek için talimatları ve yinelemenin mevcut durumunu saklarlar.

Her öğe, tembel değerlendirme adı verilen bir teknikle yalnızca talep üzerine üretilir. Bu Python ipucunun başlıca faydası, tüm diziyi bir kerede oluşturmadığı için daha az bellek kullanmasıdır. 

#5 Rumuzlama (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şvuran iki tanımlayıcı elde ederiz. Bu kavrama rumuzlama (aliasing) denir. Bir rumuzdaki değişiklik 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 nesnelerle çalışırken rumuzlamadan uzak durmaktır. Başka bir çözüm, 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şturur. 

Başka çözümler de üretebilirsiniz; örneğin veriyi başka bir tanımlayıcıya atarken list(a) çağırmak ve copy() yöntemini kullanmak gibi. 

#6 ‘not’ Operatörü

a = []
print(not a)

"""
True
"""

Sıradaki Python ipucumuz, veri yapınızın boş olup olmadığını not operatörünü kullanarak kontrol etmenin en kolay yoludur. Python'un yerleşik not operatörü, ifade doğru değilse True, aksi halde False döndürür – 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 operatörü False döndürür; tersi durumda ise True. 

Kafayı biraz karıştırabilir; denemekte fayda var. 

#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 gerekir; bu süreci basitleştirmek için Python 3.6, f-string’ler adlı harika bir özellik getirdi. Yeni yöntemi daha iyi takdir etmek için eski biçimlendirme yönteminin nasıl çalıştığını bilmek faydalıdır. 

Eskiden dizgiler şöyle 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 yolu daha hızlı, daha okunaklı, daha öz ve hata yapması daha zordur.

F-string’lerin bir başka kullanımı 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ı 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ı parametrelerini tanımlamadan kullanırız. Bu nedenle birçok Python geliştiricisi çıktıyı bir dereceye kadar kontrol edebileceğinizi bilmez.

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 satıra geçmesini 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 Demete Eklemek

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

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

Demetlerin değiştirilemez olduğunu biliyoruz – bkz. Python hilesi #3 Listeler vs. Demetler. Bir demetin durumunu değiştirmeye çalışmak TypeError fırlatır. Ancak bir demet nesnesini, değiştirilemeyen bir şekilde nesnelere bağlı adlar dizisi olarak düşünürseniz farklı görebilirsiniz.

Demetimizin ilk iki öğesi tamsayıdır – değiştirilemezler. Son öğe ise Python’da değiştirilebilir bir nesne olan listedir.

Listemizi, değiştirilemeyen bir nesneye bağlı bir ad olarak düşünürsek, listenin demetin içinden hâlâ 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 hilesi hakkında söylenecek çok fazla şey yok; sadece çok daha okunabilir bir çözümdür!  

#11 Üçlü Operatör / Koşullu İfadeler 

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

print(name)

"""
John
"""

Yukarıdaki kodda, üçlü operatör olarak bilinen (başka adlarla koşullu ifade) bir yapı görüyorsunuz. Üçlü operatörleri, bir koşulun True ya da False olmasına dayalı değerlendirmeler için kullanırız.

Aynı kodu şu şekilde de yazabilirdik:

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

print(name)
"""
John
"""

İki kod da aynı çıktıyı üretse de, üçlü koşullu ifadenin çok daha kısa ve net bir yazıma izin verdiğine dikkat edin. Python geliştiricileri buna daha “Pythonik” yaklaşım der. 

#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 listedeki yinelenen öğeleri kaldırmanın en basit yolu, listeyi bir kümeye dönüştürmektir (isterseniz sonra tekrar listeye çevirebilirsiniz).

Değiştirilebilirlik açısından, kümeler ve listeler Python’da oldukça benzerdir. Her iki veri yapısında da öğe ekleyip kaldırabiliriz, ancak yine de oldukça farklıdırlar.

Listeler sıralıdır, sıfır tabanlı indekslenir ve değiştirilebilirdir. Kümeler sırasız ve indekssizdir. Kümelerdeki öğeler değiştirilemez türde olmalıdır; kümenin kendisi değiştirilebilir olsa da bir öğeyi indeksle almak ya da bir öğeyi değiştirmek hata doğurur.

Kümeler ile listeler arasındaki bir diğer önemli fark, kümelerin yinelenen öğe içerememesidir. Bu sayede listemizdeki yinelenenleri kaldırabildik.

#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şvurmak için kullanılabilir. Ancak alt çizginin başka bir görevi daha vardır: son değerlendirmenin sonucunu saklamak.

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

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

#14 Değerleri Yoksaymak 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 kullanım alanı bununla sınırlı 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 ve onu kullanmamak, programı lint ederken F841 hatası üretir. F841 hatası, yerel bir değişken adının atandığını ancak programda kullanılmadığını belirtir ki bu kötü bir pratiktir.

#15 Sonda Alt Çizgi

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

Son iki hiledeki alt çizgi (_) kullanımından devam edersek, bir diğer amacı da Python anahtar sözcükleriyle çakışmaları önlemektir. 

PEP 8, sonda alt çizginin "Python anahtar sözcükleriyle çakışmaları önlemek için gelenek gereği kullanılmasını" önerir. Ayrıca "kısaltma ya da yazım bozulması kullanmaktansa sona tek bir alt çizgi eklemenin genellikle daha iyi olduğunu" belirtir. Bu nedenle list_, lst’den daha iyidir.

#16 Önde Alt Çizgi

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

Deneyimli Python programcılarının bir tanımlayıcıya veya yöntem adına sıklıkla bir alt çizgi öneki getirdiğini görürsünüz – haklı bir sebeple.

Bir tanımlayıcıya veya yönteme getirilen alt çizgi, gizli bir anlama sahiptir: bu değişken veya yöntem yalnızca dahili kullanım içindir. Esasen, PEP 8’de tanımlanmış ama Python tarafından zorlanmayan bir uyarıdır. Dolayısıyla öndeki alt çizgiler zayıf bir göstergedir.

Java’dan farklı olarak Python’da özel (private) ve genel (public) değişkenler arasında güçlü bir ayrım yoktur. Başka bir deyişle, bu anlam sadece Python topluluğu böyle kabul ettiği için vardır. Varlıkları programlarınızın davranışını etkilemez.

#17 Alt Çizgi Görseli

Alt çizgi ile ilgili son ipucu; şimdiye dek üç farklı kullanım alanını gördük, ancak Python’da Alt Çizginin (_) Rolü hakkındaki eğitimimize göz atarak daha fazlasını öğrenebilirsiniz. 

number = 1_500_000
print(number)

"""
15000000
"""

Alt çizgiyi, tamsayı, kayan noktalı ve karmaşık sayı sabitlerinde rakam gruplaması için görsel bir ayraç olarak da kullanabiliriz – bu özellik Python 3.6’da tanıtıldı. 

Fikir, uzun sabitlerin veya değeri bölümlere ayrılarak okunması gereken sabitlerin okunabilirliğini artırmaktı – ayrıntılar için PEP 515’e bakabilirsiniz.

#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özdizimini birçok Python programında görmüş olma olasılığınız yüksektir; Python, "__main__" adlı özel bir isim kullanır ve çalıştırılan Python dosyası ana program ise bunu __name__ tanımlayıcısına atar.

Ekran görüntüsündeki modülü (Python dosyasını) başka bir modüle içe aktarıp 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 adına (Python dosyası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ükteki çeşitli anahtarlar için değerler ayarlamak isteyebilirsiniz. Örneğin bir derlemedeki sözcüklerin sayımlarını izlerken. Bunu yapmanın yaygın yolu şöyledir: 

1. Anahtar sözlükte var mı kontrol edin
2. Varsa değeri 1 artırın.
3. Yoksa ekleyin ve değeri 1 yapın.

Kodda şöyle görünür:

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, kontrol etmek istediğimiz anahtardır. İkinci argüman ise anahtar sözlükte yoksa atanacak değerdir – anahtar varsa yöntem mevcut değeri döndürür; böylece değişmez.

#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, aranacak bir metin deseni belirtmenizi sağlar; Çoğu kişi CTRL + F ile arama yapabildiğimizi bilir, ancak tam olarak ne aradığınızı bilmiyorsanız nasıl bulabilirsiniz? Yanıt, desen aramaktır.  

Örneğin, Birleşik Krallık numaraları benzer bir deseni izler: Başta bir sıfır ve onu izleyen on rakam ya da sıfır yerine +44 ve on rakam – ikinci örnek uluslararası formatı işaret eder. 

Düzenli ifadeler büyük zaman kazandırır. Görselimizdeki örnekleri regex yerine kurallarla yakalamaya çalışsaydık, 10’dan fazla satır kod gerekebilirdi. 

Kod yazmasanız bile düzenli ifadelerin nasıl çalıştığını öğrenmek çok önemlidir. Çoğu modern metin düzenleyici ve kelime işlemci, bul ve değiştir özelliklerinde düzenli ifadeler 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ştirmenizi sağlar ve her yerde kullanılabilir. Benzer desenleriniz olduğunda son derece kullanışlıdır.

Örneğin, 'Superman', 'Superwoman' ve 'Superhuman' aynı öneke sahiptir. Dolayısıyla, yinelenen deseni korumak ve farklı olması gereken bölümü değiştirmek için pipe’tan yararlanabilirsiniz. Yine size değerli zaman kazandırır.

İnce nokta: Eşleştirmek istediğiniz ifadelerin tümü aynı metinde geçiyorsa, eşleşen ilk metin döndürülür – örn. "Superwoman, Superman, Superhuman içeren bir örnek metin" ifadesi 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 “Hello World” ilk programınız idiyse, print() fonksiyonu muhtemelen Python öğrenirken ele aldığınız ilk yerleşik fonksiyonlardan 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ı farklı şekillerde göstermeyi gösterdik. sep parametresi, birden fazla nesne yazdırdığımızda aralarına hangi ayıracın konacağını belirtmemizi sağlayan isteğe bağlı bir argümandır. 

Varsayılan olarak araya boşluk konur; ancak print ifadelerimizde bu davranışı değiştirdik – birinde sep "", diğerinde "." olarak ayarlandı.

#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 daha orta-ileri seviye şeylere kapı aralar – bu kursla Orta Düzey Python öğrenin. İlk bakışta karmaşık görünürler ama oldukça basittirler.

Örnek kodumuzda tek bir argüman kullandık, ancak istersek birden çok argüman 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üğü ile tanımlanan normal fonksiyonlar gibi davranır; tek fark, bu fonksiyonların bir adı olmamasıdır.

#24 ‘swapcase’ Yöntemi

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

"""
sOmE rAndOm StRInG
"""

swapcase() yöntemi bir string nesnesine uygulanır; tek satırda büyük harfleri küçük, küçük harfleri büyük harfe çevirir. swapcase() yöntemi için çok fazla kullanım alanı yoktur ama bilmekte fayda var.

#25 ‘isalnum’ Yöntemi

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

"""
True
"""

Bir program yazdığımızı ve kullanıcıların bir parola girmesi gerektiğini, ancak bunun harf ve sayı kombinasyonundan oluşması gerektiğini varsayalım. Bunu, string örneğinde isalnum() çağırarak tek satırda yapabiliriz.

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

#26 İstisna 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ı bir hatayla karşılaştıklarında sona erer.

Bazen bu davranışı istemeyiz; örneğin son kullanıcı kodumuzla etkileşim hâlindeyse. Böyle bir durumda kodumuzun erken sonlanması ne kadar kötü olurdu?

İstisnai durumlarla nasıl başa çıkılacağına dair birkaç yaklaşım vardır. Çoğu Python programcısı genellikle, izin istemektense af dilemenin daha kolay olduğu düşüncesini benimser. Bu, çeşitli istisnai durumların hepsine karşı koruma sağlamaya çalışmak yerine, istisnayı yakalayıp onu ele alabilecek bağlamı sağlamayı tercih edecekleri anlamına gelir. Bu yaklaşımın arkasındaki fikir, her olası istisnai duruma karşı zaman kaybetmenin anlamlı olmamasıdır.

Ancak bu, 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]
"""

İki liste arasındaki farkları 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 & 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ğimiz durumlarda parametre olarak kullanırız. 

*args parametresi, anahtarsız (yani, geçilen parametrelerin ilişkili bir ada ihtiyaç duymadığı) argümanları değişken sayıda bir fonksiyona iletmemizi sağlar. Öte yandan **kwargs parametresi, anahtarlı argümanları keyfi sayıda bir fonksiyona iletmemizi mümkün kılar.

Aslında, *args ve **kwargs sözcükleri sihirli değildir: gerçek sihir yıldız işaretlerindedir (*). Yani yıldızlardan sonra herhangi bir sözcüğü kullanabilirdik; ancak args ve kwargs kullanımı yaygın bir pratiktir ve Python geliştiricileri arasında yerleşmiştir. 

#29 Üç Nokta (Ellipsis)

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Ellipsis, üç nokta (...) yazarak ya da nesnenin kendisini (Ellipsis) çağırarak elde edilen bir Python nesnesidir.

En bilinen kullanımı, NumPy’de çok boyutlu dizilere erişmek ve dilimlemektir; ö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]]
"""

Ellipsis’in bir diğer kullanımı ise, uygulanmamış bir fonksiyonda yer tutucu olarak kullanmaktır. 

Yani Ellipsis, ... veya pass yazabilirsiniz; hepsi geçerlidir.

#30 Liste Üreteci (List Comprehension)

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

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

Son Python ipucumuz, 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ızı sağlarlar.

Aynı amaca 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 savunur.

Daha fazlasını öğrenmek için Python Liste Üreteçleri eğitimine göz atın.