Programlama dili denince akla gelen ilk şeylerden birisi karar yapılarıdır, bunlar koşul yapıları olarak da bilinirler. Bu yapılar aracılığıyla programın işleyişi, yapabileceği işlemler değişkenlerin aldığı değere göre farklılık gösterir ve programın yeteneklerine yetenek katar. Bu yapılardan en çok bilineni if-else if-else üçlüsü olsa da, çoğu programlama dilinde bulunan ikinci karar yapısı ise switch-case’dir. Bu koşul yapısı, kontrol edilen değişkenin veya önermenin aldığı spesifik değerlere göre programın veya fonksiyonun işleyişini değiştirir. Bu yapı genellikle şu şekilde kodlanır:
switch(değişken/ifade){
case durum1: işlem(ler); break;
case durum2: işlem(ler); break;
...
default: işlem(ler); break; //bazı dillerde zorunlu değil
}
Ancak günümüzde programlama dili denince akla gelen ilk dillerden birisi olan Python, yakın geçmişe kadar kullanıcılarına böyle bir yapı sunmamakta idi. Bu tarz bir yapıya ulaşmak isteyen programcılar ya benzeri işlevde olan bir if-elif-else karar yapısı yazmak zorunda kalıyor, ya da çeşitli farklı alternatiflere yöneliyordu. Ancak Python 3.10 sürümünden beri Python dili bu ifadeye muadil bir koşul yapısı sunmaktadır: Match-case.
Match-Case Nedir?
Python diline yeni katılan bir karar yapısı olan match-case, Python’da uzun zamandır eksik olan switch-case mimarisini tam anlamıyla bu dile entegre etmektedir. Bu sayede Python kullanıcıları, tıpkı diğer dillerdeki gibi karar yapıları oluşturup programlarının işleyişini çeşitlendirebilirler. Bu karar yapısının syntax özellikleri şu şekildedir:
match (değişken/ifade):
case değer1:
işlem(ler)
case değer2:
işlem(ler)
...
case _:
işlem(ler)
Bu yapı, Python’daki paragrafların yerine iki nokta (:) kullanılması dışında genel olarak switch-case ile aynı şekilde yazılır ve kullanılır. Kontrol edilecek değişkenin veya ifadenin değeri, match-case yapısı içinde kontrolü edilecek değerlerden herhangi biri ise, o değere atanan işlemler yapılır, aksi takdirde default case olarak geçen “case _” durumunun işlemleri yapılır. Python’da değer durumlarında yapılacak işlemler yazıldıktan sonra sonuna “break” tarzı bir kesme kodu koymaya gerek yoktur.
Match-Case Örnekleri
Python programlama dili içerisinde kullanılabilecek olan match-case yapısının nasıl ve hangi durumlarda kullanıldığına dair birkaç örnek ile bu yapıyı iyice anlamaya çalışalım. Öncelikle basit bir örnekle konuya girelim.
number = 123
match (number%2):
case 0:
print("Çift Sayı")
case 1:
print("Tek Sayı")
Bu örnekteki kod bloğu, “number” sayısal değişkeninin içindeki değerin mod 2’deki değerini (number%2) kontrol etmektedir. Bu değer 0 ise program ekrana “Çift sayı”, 1 ise ekrana “Tek sayı” metnini yazdıracaktır. Bu örnek için 123 mod 2 = 1 olduğu için “case 1” durumu çalışacaktır.
letter = input("Bir harf girin: ")
if not letter.isnumeric():
match (len(letter)):
case 1:
print("Harf: ",letter)
case _:
print("Hata: Harf Değil")
else:
print("Hata: Alfabetik olmayan girdi!")
Yukarıdaki örneğimizde program, kullanıcıdan bir girdi girmesini isteyerek bu girdiyi “letter” değişkenine atamaktadır. Öncelikle letter değişkeninin isnumeric() fonksiyonuyla girilen değerin sayısal/alfanumerik olup olmadığı kontrol edilmekte, değil ise girdinin uzunluğu kontrol edilmektedir. Girdinin uzunluğu 1 ise ekrana girilen harf yazılmakta, değil ise bir hata mesajı yazdırılmaktadır.
Bu örnek için, eğer kullanıcı “a” girerse program ekrana “a” harfini yazacaktır. Aynı kullanıcı programı tekrar çalıştırdığında “ab” girerse “Hata: Harf Değil” mesajı, “3” veya “3f” girerse “Hata: Alfabetik olmayan girdi!” mesajı ekrana yazılacaktır.
Veya (Or) & Eğer (If) İçeren Match-Case
Python dilindeki match-case kullanımı bu tarz basit örneklerle sınırlı değildir. Daha gelişmiş ve etkin bir karar yapısı oluşturmak isteyen yazılımcılar bu yapıyı kontrol ettikleri “case”lere veya (or) mantık kontrolü ekleyerek güçlendirebilirler. Hemen aşağıda bununla ilgili ufak bir örnek bulunmaktadır:
word = "Python"
match(word):
case "Python" | "Python3":
print("It's Python!")
case _:
print("It's something else")
Bu kod bloğunda programdaki word değişkeninin tuttuğu değer kontrol edilmektedir. Eğer bu değer “Python” veya “Python3” ise program ekrana “It’s Python!” mesajını yazdıracak, aksi takdirde “It’s something else” mesajı döndürülecektir.
NOT: Bir değişken aynı anda iki değer tutamayacağı için VE içerikli match-case kontrolü yapmak mümkün değildir.
Ancak bir match-case yapısındaki bir case ile aynı anda birden fazla değişken veya değer durumu kontrol edilebilmektedir. Bunu yapmak için case’ye “if” karar yapısı ve bu yapıyla birlikte kontrol edilebilecek ikinci önermeyi yazmak gerekmektedir.
word = "Python"
version = 3
match(word):
case "Python" if version != 3:
print("It's just Python")
case "Python" if version == 3:
print("It's Python3!")
case _:
print("It's something else")
Bu kod bloğu, bir önceki örneğin biraz daha geliştirilmiş bir versiyonudur. Bu blokta match-case yapısıyla beraber word değişkeninin tuttuğu değer kontrol edilmektedir. Ancak bu yapıda case “Python”dan sonra “if version != 3” karar yapısıyla version değişkeni de kontrole dahil edilmiş olmaktadır. Bu yapıda tuttuğu değerin 3 olup olmamasına göre ekranda “It’s just Python” veya “It’s Python3!” mesajları döndürülecektir. Eğer word değişkeni Python değil ise de default durumu olan “case _” çalışacaktır.
Match-Case ile Dizi Kontrolü
Python dilinde kullanılan match-case yapısı, normal değişkenlerin değerlerinin yanı sıra, kullanıcılarına dizileri kontrol etme imkanı da tanır. Bu tarz bir işlem için kurulacak bir match-case yapısı, dizinin ilk ve son elemanlarının değerini kontrol etme esasına dayanır. Dizi kontrolü yapmak için basit bir örnek aşağıdaki gibidir:
arr = [1,2,3]
match(len(arr)):
case 1:
print(“Tek elemanlı dizi”)
case _:
match(arr):
case [1,*rest_of_arr]:
print(“Bu dizi 1 ile başlar”)
case [*rest_of_arr,2]:
print(“Bu dizi 2 ile biter”)
Bu örnekte bu kez “arr” adını almış bir dizi değişkeni kontrol edilmektedir. Bu değişkenin öncelikle uzunluğu kontrol edilmekte, eğer uzunluğu 1 ise ekrana “Tek elemanlı dizi” mesajı döndürülmektedir. Aksi takdirde bu kez dizinin kendisi kontrol edilmektedir. Bu kontroldeki ilk case, dizinin 1 ile başlayıp başlamadığını kontrol etmekte ve dizinin diğer elemanlarını *rest_of_arr takısı ile temsil etmektedir (bu takının ismi farklı olabilir). İkinci kontrolde ise bu takı bu kez öne atanmakta, ardından yazılan “2” değeriyle dizinin 2 değeri ile bitip bitmediği kontrol edilmektedir. Bu örneğe göre bu dizi 1 ile başladığı için ekrana “Bu dizi 1 ile başlar” mesajı yazılacaktır.
Bir dizinin aynı anda ilk ve son değerlerini kontrol etmek için bu iki case durumu iç içe yazılmalıdır. Ancak bir case içerisinde ilk ve son elemanlar arasındaki herhangi bir değer kontrolü yapılamaz.
case [1,*rest_of_arr]:
match(sequence):
case [*rest_of_arr,2]: ... //çalışır
case [*first_of_arr,3,*last_of_arr]: //hata verir
Buna ek olarak aynı anda baştaki veya sondaki birden fazla değeri de kontrol etmek mümkündür. Yani şu tarz bir ifade çalışacaktır:
case [1,2,*rest_of_arr]: ... //çalışır
Classlar ve Match-Case
Python’da bulunan classlar, match-case yapıları ile kontrol edilebilen yapılar arasındadır. Bunun için önceden bir sınıf üzerinden oluşturulan nesnenin match-case yapısına parametre olarak atılması ve bu nesnenin parametrelerinin kontrol edilecek şekilde bir yapının oluşturulması gerekmektedir. Bu tarz kullanıma bir örnek aşağıdaki gibidir:
class Person:
def __init__(self,name,age,job):
self.name = name
self.age = age
self.job = job
def ageControl(aliasOfPerson):
match(aliasOfPerson):
case Person():
if aliasOfPerson.age < 18:
print(“This person is a child”)
else:
print(“This person is an adult”)
case _:
print(“This is not a person”)
johndoe = Person(“John Doe”,43,”Entrepreneur”)
ageControl(johnDoe)
Önceden tanımlı olan Person classı üzerinden oluşturulmuş “johndoe” nesnesi, kullanım kolaylığı açısından tanımlanış “ageControl” fonksiyonuna parametre olarak atanmıştır. Bu fonksiyonda da bu nesnenin bir Person nesnesi olup olmadığı kontrol edilmiş, ve eğer Person sınıfından türetilmiş ise bu nesnenin tuttuğu “age” parametresi bir if-else karar yapısıyla kontrol edilmiştir. Bu parametrenin aldığı değere göre “This person is a child” veya “This person is an adult” mesajı ekrana yazdırılarak fonksiyon sonlandırılmıştır.
Sözlükler(Dictionary) ve Match-Case
Python dilinde bulunan match-case yapısının bir diğer avantajı da sözlük (dictionary) yapısı ile kullanılabiliyor olmasıdır. Bunun için izlenmesi gereken kullanım yolu aşağıdaki şekildedir:
case {“anahtar1”: değer1, “anahtar2”: değer2, “anahtar3”: değer3,...}:
...
Python programlama dilinin en yeni ve en güçlü yapılarından olan match-case yapısı bu şekilde idi. Bu yapıyı kullanarak programınıza daha iyi karar algoritmaları yazabilir ve programınızın işleyişini iyileştirebilirsiniz.
