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

Son yıllarda Python kodlama becerilerine olan talep arttı. Python programlama becerilerinizi geliştirmenize yardımcı olmak için, kodunuzu iyileştirmenize yarayacak 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 yeterli seviyede değilse, Python Programming beceri yolumuzla onları keskinleştirebilirsiniz.

Sıra ve Veri Yapısı İpuçları

#1 Dilimleme

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

"""
!dlroW olleH
"""

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

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

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

• "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). 

Negatif indeksler de geçebiliriz; bunlar diziyi ters çevirmek için kullanılabilir. Örneğin, 4 öğeli bir listede 0. indeks aynı zamanda -4 indeksidir ve son indeks de -1’dir. Yukarıdaki örnekte bu bilgi dizinin step parametresine uygulanmıştır. Sonuç olarak, dize sondan başlayarak 0. indekse kadar tersten yazdırılmıştır.   

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

Python’da yinelemeleri otomatik açma ile 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 denir. 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 tekniği ortaya çıkarır. Bir dizi değeri bir dizi değişkene atamak için eşzamanlı atamayı kullanabiliriz.

#3 Liste vs. demet (tuple) 

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ına aşinadır. Aynı şeyi demetler için söyleyemeyiz. Her ikisi de yinelenebilirdir, indekslemeye izin verir ve heterojen veri türlerini saklayabilir. Ancak demetin listeye tercih edilebileceği durumlar vardır. 

Ö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 veriler için gereken doğru bellek bloğunu ayırabilir. Buna karşılık, listede olası uzatmalara karşı fazladan bellek ayrılmalıdır – buna dinamik bellek ayırma denir. 

Kısaca: Verinin değişmesini istemediğiniz senaryolarda, bellek nedenleriyle liste yerine demet tercih edilmelidir. Demetler 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 [] yerine yanlışlıkla () yaparsanız ne olur? Bir üreteç nesnesi elde edersiniz.

Python’da liste üreteci mantığıyla yuvarlak parantezler, üreteç nesnesi denen şeyi oluşturur. Üreteçler özel bir yinelenebilir türüdür. Listelerden farklı olarak, öğelerini saklamazlar. Bunun yerine, her öğeyi sırayla üretme talimatlarını ve yinelemenin mevcut durumunu saklarlar.

Her öğe yalnızca talep üzerine, tembel değerlendirme adı verilen bir teknikle üretilir. Bu Python ipucunun ana faydası, tüm dizi tek seferde oluşturulmadığı 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 (referans) 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 denir. Bir rumuzdaki değişiklik diğerini etkiler. Bazen bu davranış istenir, ancak çoğu zaman bizi gafil avlar. 

Bunu aşmanın bir yolu, değiştirilebilir nesnelerde rumuzlamadan kaçınmaktır. Başka bir çözüm, referans yerine özgün 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 referans oluşturur. 

list(a) çağırmak ve copy() yöntemini kullanmak gibi birçok başka çö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ı not işleciyle kontrol etmenin en kolay yoludur. Python’un yerleşik not işleci, ifade doğru değilse True döner; aksi halde False döner – Boole ifadelerinin ve nesnelerin doğruluk değerini tersine çevirir.  

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

if not a:
    # do something... 

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

Kafada oturtması biraz zordur; deneyin.

Dize ve Çıktı İpuçları

#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 dize nesnesini biçimlendirmemiz gerekebilir; Python 3.6, bu süreci basitleştiren f-string adlı havalı bir özellik getirdi. Yeni yöntemin değerini daha iyi anlamak için, öncesinde dizelerin nasıl biçimlendirildiğini bilmek faydalıdır. 

Eskiden dizeler şö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, 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
"""

Opsiyonel parametrelerini tanımlamadan bir print ifadesi kullanmak oldukça yaygındır. Sonuç olarak, pek çok Python geliştiricisi çıktıyı bir dereceye kadar kontrol edebileceğinizin farkında değildir.

Değiştirebileceğimiz opsiyonel 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 ekleme

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 ipucu #3 Liste vs. Demet. Bir demetin durumunu değiştirmeye çalışmak TypeError fırlatır. Ancak bir demet nesnesini, değiştirilemeyen biçimde nesnelere bağlı adların bir dizisi olarak düşünürseniz, işler farklı görünebilir.

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ğlanan bir dizideki başka bir ad olarak düşünürsek, listenin demetin içinden yine de değiştirilebildiğ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üzeyi Veya) ile birleştirmek mümkündür. Bu Python ipucuyla ilgili söylenecek çok şey yok; çok daha okunaklı bir çözümdür! 

Kod Stili ve Sözdizimi İpuçları

#11 Üçlü (ternary) operatör / koşullu ifadeler 

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

print(name)

"""
John
"""

Yukarıdaki kodda üçlü operatör olarak bilinen şeyi görüyorsunuz – başka adlarla koşullu ifade olarak da anılır. Üçlü operatörleri, bir koşulun True ya da False olmasına göre değerlendirme yapmak için kullanırız.

Kodu başka nasıl yazabilirdik:

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

print(name)
"""
John
"""

Her iki kod da aynı çıktıyı üretse de, üçlü koşullu ifadenin çok daha kısa ve net kod yazmamızı sağladığına dikkat edin. Pythonistler buna daha “Pythonik” yol der. 

#12 Listelerden kopyaları 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ürmek (gerekirse tekrar listeye çevirmek)dir.

Değiştirilebilirlik açısından setler ve listeler Python’da oldukça benzerdir. Her iki veri yapısına da dilediğimiz gibi öğe ekleyip çıkarabiliriz, ancak aralarında büyük farklar vardır.

Listeler sıralıdır, sıfır tabanlı indekslenir ve değiştirilebilirdir. Setler sırasızdır ve indekslenmez. Setin öğeleri değiştirilemez türden olmalıdır, setin kendisi değiştirilebilir olsa da – bir öğeyi indeksle almaya veya değiştirmeye çalışmak hata yükseltir.

Setlerle listeler arasındaki bir diğer önemli fark, setlerin yinelenen öğe içerememesidir. Bu sayede listemizdeki yinelenen öğeleri kaldırabildik.

#13 Bağımsız 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 sorumluluğu daha vardır: son değerlendirmenin sonucunu saklamak.

Dokümantasyonda, “etkileşimli yorumlayıcı, son değerlendirmenin sonucunu _ değişkeninde kullanılabilir kılar. (Yerleşik fonksiyonlar gibi builtins modülünde saklanır.)” denir.

İlk satırda alt çizgiye bir nesne atamadığımız için hata aldık. Ancak 1 + 2 çı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; ama kullanım alanı bununla sınırlı değildir.

Ayrıca, 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ına yol açar. F841 hatası, programda yerel bir değişken adının atandığını ancak kullanılmadığını belirtir; bu da kötü bir uygulamadır.

#15 Sonda alt çizgi

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

Son iki ipucundan devamla, Python’un alt çizgi (_) kullanımının bir diğer amacı, Python anahtar sözcükleriyle çakışmayı önlemektir. 

PEP 8, sonda alt çizginin “Python anahtar sözcükleriyle çakışmayı önlemek için geleneksel olarak kullanılması” gerektiğini belirtir. Ayrıca “genellikle kısaltma ya da yazım bozumu yerine tek bir sonda alt çizgi eklemek daha iyidir. Bu nedenle list_, lst’den daha iyidir” der.

#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 alt çizgi öneki koyduğunu görürsünüz – ve bunun iyi bir nedeni vardır.

Bir tanımlayıcıya veya yönteme önek olarak konan alt çizginin gizli bir anlamı vardır: bu değişken veya yöntem yalnızca dahili kullanım içindir. Esasen, bu PEP 8’de tanımlanmış bir sorumluluk reddidir; Python tarafından zorlanmaz. Dolayısıyla, öndeki alt çizgiler zayıf bir göstergedir.

Java’nın aksine Python’da özel (private) ve genel (public) değişkenler arasında güçlü bir ayrım yoktur. Başka bir deyişle, anlamı yalnızca Python topluluğu ona anlam atfettiği için vardır. Dahil edilmeleri programlarınızın davranışını etkilemez.

#17 Alt çizgi görseli

Alt çizgilere dair son ipucu; şimdiye kadar alt çizginin üç farklı kullanımını ele aldık, ancak Python’da Alt Çizginin Rolü eğitimimizden daha fazlasını öğrenebilirsiniz. 

number = 1_500_000
print(number)

"""
15000000
"""

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

Fikir, uzun sabitlerin okunabilirliğini artırmak ya da değeri açıkça parçalara ayrılması gereken sabitler için yardımcı olmaktı – PEP 515’te daha fazlasını okuyabilirsiniz.

Kod Stili ve Sözdizimi İpuçları

#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 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ü başka bir modüle (Python dosyası) 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 bir değer ayarlamak isteyebilirsiniz. Örneğin, bir derlemdeki (corpus) kelimelerin sayımları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.

Koddaki hali şöyledir:

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

Bunu daha öz ş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 zaten yoksa ayarlanacak değerdir – anahtar varsa, yöntem anahtarın değerini döner; yani değişmez.

Program Yapısı İpuçları

#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 için bir metin deseni belirtmenizi sağlar; Çoğu kişi CTRL + F (Windows) 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 ardından on rakam ya da sıfır yerine +44 ve on rakam – ikincisi uluslararası biçimi gösterir. 

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

Düzenli ifadelerin nasıl çalıştığını öğrenmek, kod yazmasanız bile ö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 (|) adı verilen özel bir karakter vardır; birçok ifadeden birini eşleştirmenizi sağlar ve her yerde kullanılabilir. Benzer kalıplarınız olduğunda son derece kullanışlıdır.

Örneğin, ‘Superman’, ‘Superwoman’ ve ‘Superhuman’ aynı öneke sahiptir. Dolayısıyla, yineleyen kısmı korumak ve farklı olmasını istediğiniz kısımları değiştirmek için pipe’tan yararlanabilirsiniz. Yine size değerli zaman kazandırır.

Dikkat edilmesi gereken nokta: Eşleştirmek istediğiniz tüm ifadeler aynı metinde geçiyorsa, eşleşecek ilk metin dönülür – örn. “An example text containing Superwoman, Superman, Superhuman,” metni 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 tam yeteneklerinden haberdar olmayan Python programcılarının sayısı ürkütücü; Eğer ilk programınız “Hello World” ise, print() fonksiyonu muhtemelen Python öğrenirken ele aldığınız ilk yerleşik fonksiyonlardandır. print() ile biçimlendirilmiş mesajları ekranda gösteririz; ancak print() fonksiyonunda bundan fazlası var. 

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

Varsayılan olarak aralarına boşluk konur, ancak print deyimlerimizle bu işlevi değiştirdik – birinde sep "" olarak ve diğerinde "." olarak ayarlanmıştır.

#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 yapabileceklerinizde sizi orta-ileri seviyeye taşır – bu kursla Orta Seviye 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. def anahtar sözcüğüyle bildirilen normal bir fonksiyon gibi davranırlar; ancak bu fonksiyonların adı yoktur.

#24 ‘swapcase’ yöntemi

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

"""
sOmE rAndOm StRInG
"""

swapcase() yöntemi bir dize nesnesine uygulanır ve tek satırda büyük harfleri küçük, küçük harfleri büyük yapmamızı sağlar. swapcase() için çok fazla kullanım senaryosu yoktur, ancak 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; ancak parolanın harf ve sayı kombinasyonu içermesi gerekiyor. Bunu, dize örneğinde isalnum() çağırarak tek satırda yapabiliriz.

Yöntem, tüm karakterlerin alfabetik (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 yakalama

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 sonlanır.

Bazen bu davranışı istemeyiz; örneğin, kodumuzla etkileşime giren bir son kullanıcı olduğunda. Böyle bir durumda kodumuzun erken sonlanması ne kadar kötü olurdu?

İstisnai durumlarla nasıl başa çıkılacağı konusunda birkaç görüş vardır. Çoğu Python programcısı genellikle, izin istemektense affını dilemenin daha kolay olduğu fikrini benimser. Bu, istisnayı ele alabilecek çevreleyen bağlamı sağlayarak yükseltilen hatayı yakalamayı tercih edecekleri anlamına gelir. Bu düşüncenin ardındaki fikir, çeşitli istisnai durumlara karşı koruma sağlamaya çalışarak zaman kaybetmenin anlamı olmadığıdır.

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

#27 Listelerdeki farkları bulma

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ırmanın üç farklı yöntemi 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 parametrelerini, fonksiyonumuzun kaç değişken beklemesi gerektiğini bilmediğimizde kullanırız. 

*args parametresi, anahtarsız olduğunda (yani iletilen parametrelerin ilişkili bir ada ihtiyacı olmadığında) değişken sayıda parametre geçmemize izin verir. Öte yandan **kwargs parametresi, fonksiyona keyfi sayıda anahtarlı parametre geçmemizi sağlar.

Gerçekte, *args ve **kwargs sözcükleri o kadar da sihirli değildir: asıl sihir yıldızlardadır (*). Bu, yıldızlardan sonra herhangi bir sözcüğü kullanabileceğimiz anlamına gelir; ancak args ve kwargs kullanımı yaygın bir uygulamadır ve Python geliştiricileri arasında benimsenmiştir. 

#29 Üç nokta (ellipsis)

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Ellipsis, üç nokta (...) yazarak veya nesnenin kendisini (Ellipsis) çağırarak kullanılabilen bir Python nesnesidir.

En dikkat çekici kullanımı NumPy’da ç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]]
"""

Ancak Ellipsis’in bir başka kullanımı da uygulanmamış bir fonksiyonda yer tutucu olarak kullanmaktır. 

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

#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 gerçekleştirmenize 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 okunaklı olduğunu savunacaktır.