1. Python’da Fonksiyonlar (Python functions)
Python’da fonksiyonlar sadece çalıştırıldığı/çağrıldığı zaman belirli görevleri yerine getiren ve bir değer üreten/döndüren kod bloklarıdır. Benzer işlevleri yerine getirecek tekrar eden kodlar yerine, söz konusu işlevi bir fonksiyonda tanımlamak projelerinizin okunabilirliğini/anlaşılabilirliğini arttırır. Fonksiyonlar Python’da (birçok programlama dilinde olduğu gibi) çok yaygın kullanılan yöntemlerdendir. Bununla birlikte makine öğrenmesi, veri işleme vb. veri bilimi alanlarında fonksiyonlar tekrar eden görevleri yerine getirdikleri için sıklıkla kullanılırlar.
Aşağıda basit bir fonksiyon örneği yazılmış ve çağrılmıştır.
#fonksiyon adı my_function; dilerseniz başka bir isim de kullanabilirsiniz.
def my_function():
print("Bu metin fonksiyon çağrıldığı zaman fonksiyonda üretilen bir çıktıdır.")
my_function() #Sonuç: Bu metin fonksiyon çağrıldığı zaman fonksiyonda üretilen bir çıktıdır.
print("___________\n")
def my_function():
print("Fonksiyon çağrılmadığı zaman fonksiyonda bir çıktı üretilmez.")
#my_function() #Sonuç: Fonksiyon çağrılmadığı için çalışmayacaktır. Dolayısıyla konsola ikinci bir sonuç yazdırılmayacaktır.
Bir fonksiyona, fonksiyon adından sonra gelen parantezlerin içinde argüman/parametre tanımlanabilir. Bir fonksiyon çok sayıda argüman/parametre içerebilir. Fonksiyonlarda argüman ve parametre aynı ifadelerdir. Argüman ya da parametre fonksiyona gönderilen bilgidir ve fonksiyonun bir girdisidir. Fonksiyonun döndürdüğü değer ise fonksiyonun çıktısıdır.
Fonksiyonların çalışma ilkesi matematikteki fonksiyonlara benzer. Örneğin f(x)=3+2x fonksiyonunda x alternatif değerleri için f(x) fonksiyonu çıktılar/sonuçlar üretir. Bu fonksiyonu Python’da aşağıda gösterildiği gibi kodlayabiliriz.
#x bir parametredir.
def my_simple_function(x):
sabit = 3
y = sabit + 2*x
print(y)
#Yukarıdaki fonksiyon aşağıda üç farklı x değeri için çağrılmıştır.
my_simple_function(2) #Sonuç/Fonksiyon Çıktısı: 7
my_simple_function(3) #Sonuç/Fonksiyon Çıktısı: 9
my_simple_function(4) #Sonuç/Fonksiyon Çıktısı: 11
2. Python’da Fonksiyon Parametreleri/Argümanları
Python’da fonksiyonlar sayısal olabileceği gibi, string ya da mantıksal değişkenlerden de oluşabilir. String bir girdisi olan aşağıdaki fonksiyonu inceleyebilirsiniz.
#fname bir parametredir.
def my_family_function(fname):
lname = "Kutlu"
print(fname + " " + lname)
#Yukarıdaki fonksiyon aşağıda üç farklı görev için çağrılmıştır.
my_family_function("İshak") #Sonuç/Fonksiyon Çıktısı: İshak Kutlu #Bu görevde fonksiyonun girdisi "İshak" ifadesidir. Fonksiyonda fname=ishak olmaktadır.
my_family_function("Zeliha") #Sonuç/Fonksiyon Çıktısı: Zeliha Kutlu #Bu görevde fonksiyonun girdisi "Zeliha" ifadesidir. Fonksiyonda fname=Zeliha olmaktadır.
my_family_function("Elif Mira") #Sonuç/Fonksiyon Çıktısı: Elif Mira Kutlu #Bu görevde fonksiyonun girdisi "Elif Mira" ifadesidir. Fonksiyonda fname=Elif Mira olmaktadır.
Yukarıdaki fonksiyonun “fname” adında bir adet parametresi vardır. Fonksiyonun parametrelerinin parantez içinde belirtildiğine ve parantezin kapatılmasından sonra ise fonksiyonun sonunda iki nokta “:” olduğuna dikkat ediniz. Ayrıca fonksiyonun komutlarının içe doğru girintili bir şekilde başlaması gerektiğini de belirtmekte yarar var.
İki parametreye/argümana sahip bir fonksiyonun çalışma ilkelerini kavramak için aşağıdaki örneği inceleyebilirsiniz.
#fname ve lname birer parametredir.
#Fonksiyonun 2 argümanı/parametresi olduğu için kullanılacağı zaman iki parametre girdisi olmalıdır. Tek parametre ile çalışmaz.
def my_act_function(fname, lname):
print(fname + " " + lname)
#Yukarıdaki fonksiyon aşağıda üç farklı görev için çağrılmıştır.
my_act_function("Bruce", "Willis") #Sonuç/Fonksiyon Çıktısı: Bruce Willis
my_act_function("Angelina", "Jolie") #Sonuç/Fonksiyon Çıktısı: Angelina Jolie
my_act_function("Denzel","Washington") #Sonuç/Fonksiyon Çıktısı: Denzel Washington
#my_act_function("Russel") #Sonuç: TypeError: my_act_function() missing 1 required positional argument: 'lname'
Aşağıda gösterildiği gibi bir fonksiyona girdi olarak list, set, tuple gibi liste tipi değişkenlerin değerleri gönderilebilir ve fonksiyon liste tipi değişkenin eleman sayısı kadar sonuç döndürebilir.
def my_mat_function(myParameter):
for x in myParameter:
print(5*x)
myValues = [2, 3, 4]
my_mat_function(myValues)
#Sonuç/Fonksiyon Çıktısı:
#10
#15
#20
print("___________\n")
def my_function(myParameter):
for x in myParameter:
print(x)
myCarList = ["Volvo", "Jaguar", "BMW"]
myCountryList = ["Almanya", "İngiltere", "Norveç"]
my_function(myCarList)
#Sonuç/Fonksiyon Çıktısı:
#Volvo
#Jaguar
#BMW
print("___\n")
my_function(myCountryList)
#Sonuç/Fonksiyon Çıktısı:
#Almanya
#İngiltere
#Norveç
Bir fonksiyon, (print yerine) “return” ifadesiyle bir değer döndürebilir.
def my_function(x): return 2 * x + x**2 #x**2 ifadesi x kare anlamına gelir. print(my_function(1)) #Sonuç: 3 print(my_function(2)) #Sonuç: 8 print(my_function(3)) #Sonuç: 15
Not: Python sürümlerine göre değişmekle birlikte “return” ifadesi “print” ifadesinde olduğu gibi her zaman konsola yazdırmayabilir. Ancak bu durum fonksiyonun return komutuyla bir değer döndürdüğü gerçeğini değiştirmez.
Bir fonksiyonun içeriği boş ise Python hata verir. Herhangi bir sebeple boş bir fonksiyon kullanılması gerektiğinde Python’un hata vermemesi için fonksiyonun içine “pass” ifadesi eklenebilir.
def myfunction():
pass
3. Python’da Arbitraj Parametresi (arbitrary parameter)
Eğer fonksiyona ne kadar parametre gönderileceğini bilmiyorsanız, fonksiyona parametre adından önce “*” işaretini eklemeniz yeterlidir (arbitrary parameter).
def my_function(*cars):
print("Favori otomobilim " + cars[2] +".") #Sonuç: Favori otomobilim Peugeot.
my_function("Volvo", "Opel", "Peugeot") #Parametre grubu bir tür tuple içinde temsil edilmiş oldu.
Yukarıdaki fonksiyonda parametrelerin sırası önemlidir; sıfırıncı sırada Volvo, birinci sırda Opel ve ikinci sırada ise Peugeot vardır.
4. Python’da Keyword Arbitraj Parametresi (keyword arbitrary parameter)
Fonksiyona girdi olarak gönderilecek parametreler aşağıda gösterildiği gibi “key = value “ şeklinde ifade edilebilir. Böylece parametrelerin sırasının herhangi bir önemi kalmaz. Bu yöntem keyword parametre (keyword parameter) ya da keyword argüman (keyword arguments) olarak adlandırılabilir.
def my_function(car1, car2, car3):
print("Favori otomobilim " + car1 +".") #Sonuç: Favori otomobilim Volvo. Fonksiyonda car1 yerine car2 yazılırsa sonuç Opel olur.
my_function(car1 = "Volvo", car2 = "Opel", car3 = "Peugeot")
Eğer fonksiyona ne kadar keyword parametresi gönderileceğini bilmiyorsanız, fonksiyona parametre adından önce “**” işaretini eklemeniz yeterlidir (arbitrary keyword parameter). Böylece yukarıdaki fonksiyon aşağıdaki şekilde kullanılabilir.
def my_function(**car):
print("Favori otomobilim " + car["car2"] +".") #Sonuç: Favori otomobilim Opel. Fonksiyonda "car2" yerine car3 yazılırsa sonuç Peugeot olur.
my_function(car1 = "Volvo", car2 = "Opel", car3 = "Peugeot")
Not: Çift asteriks “**” olduğuna dikkat edin.
5. Python’da Varsayılan Parametre (default parameter)
Fonksiyona aşağıda gösterildiği gibi varsayılan (default) bir parametre atayabilirsiniz.
def my_function(car = "Volvo"):
print("Favori otomobilim " + car +".")
my_function("Renault") #Sonuç/Fonksiyon Çıktısı: Favori otomobilim Renault.
my_function("Nissan") #Sonuç/Fonksiyon Çıktısı: Favori otomobilim Nissan.
my_function() #Sonuç/Fonksiyon Çıktısı: Favori otomobilim Volvo. #Fonksiyon çağrılırken bir girdi değer gönderilmediyse fonksiyon, varsayılan girdi değeri üzerinden çalışır.
my_function("Hyundai") #Sonuç/Fonksiyon Çıktısı: Favori otomobilim Hyundai.
6. Python’da Yineleme Fonksiyonu (recursion function)
Fonksiyonların kullanımına bir örnek olması amacıyla aşağıda ise spesifik bir (tri_recursion) yineleme (recursion) fonksiyonu yer almaktadır.
def tri_recursion(k):
if(k > 0):
result = k + tri_recursion(k - 1)
print(result)
else:
result = 0
return result
tri_recursion(5)
#Sonuç:
"""
1
3
6
10
15
"""
print("___________\n")
#Yukarıdaki tri_recursion fonksiyonunun yineleme süreci aşağıda gösterilmiştir.
print("k = 0 :", 0)
print("k = 1 :", 1 + 0)
print("k = 2 :", 2 + 1 + 0)
print("k = 3 :", 3 + 2 + 1 + 0)
print("k = 4 :", 4 + 3 + 2 + 1 + 0)
print("k = 5 :", 5 + 4 + 3 + 2 + 1 + 0)
7. Python’da Lambda Fonksiyonu
Lambda fonksiyonu özelleştirilmiş küçük (ancak çok kullanışlı) bir fonksiyon türüdür. Diğer fonksiyonlar gibi çok sayıda parametresi olabilir, ancak tek bir ifadeye (expression) sahip olabilir.
Aşağıda normal bir fonksiyonun lambda fonksiyonuna dönüştürülmüş formunu inceleyebilirsiniz.
def my_function(a): #Fonksiyon adı my_function, parametresi ise a.
return 2 * a + a**2 #Çıktı fonksiyonumuz: 2 * a + a**2 ifadesidir.
print(my_function(3)) # Fonksiyonunun 3 değeri için çağrılması/çalıştırılması ve fonksiyon çıktısının/ifadesinin (expression) konsola yazdırılması
#Sonuç/Fonksiyon Çıktısı: 15
print("___________\n")
myLambda = lambda a: 2 * a + a**2 # Çıktı fonksiyonumuz: 2 * a + a**2 ifadesidir. #Fonksiyon adı ise myLambda, , parametresi ise a.
print(myLambda(3)) # Lambda fonksiyonunun 3 değeri için çağrılması/çalıştırılması ve fonksiyon çıktısının/ifadesinin (expression) konsola yazdırılması
#Sonuç/Fonksiyon Çıktısı: 15
Lambda fonksiyonu yukarıda görüldüğü gibi tek satırlık bir fonksiyondur. Normal bir fonksiyonun çıktı fonksiyonu ve parametresiyle aynıdır.
Lambda fonksiyonları da diğer fonksiyonlar gibi birden çok parametreye sahip olabilir.
#parametre sayısı 2
myLambda2 = lambda a, b: a * b + a**b # Çıktı fonksiyonumuz: a * b + a**b ifadesidir. #Fonksiyon adı ise myLambda2, , parametreleri ise a ve b.
print(myLambda2(2, 3)) #Sonuç/Fonksiyon Çıktısı: 14
print("___________\n")
#parametre sayısı 3
myLambda3 = lambda a, b, c: a + b - c # Çıktı fonksiyonumuz: a + b - c ifadesidir. #Fonksiyon adı ise myLambda3, , parametreleri ise a, b ve c.
print(myLambda3(10, 15, 20)) #Sonuç/Fonksiyon Çıktısı: 5
Lambda fonksiyonları başka bir fonksiyonun içine konumlandırılabilir.
#Bir fonksiyonun içine konumlanmış lambda fonksiyonu def my_function(n): return lambda a : a * n x = my_function(2) # n=2 için my_function fonksiyonun kısmi değeri, yani a * 2 Burada x ifadesinin sanki yeni bir fonksiyon gibi davranacağı açıkça görülmektedir. ''' print (x) #Sonuç: <function my_function.<locals>.<lambda> at 0x00000220DDAB9790> şeklinde bir uyarı alırsınız. Yani my_function parametresi n=2 tanımlı olmasına rağmen, #my_function'ın sonuç üretmesi için my_function içinde konumlanan lambda fonksiyonunun parametresi a'nın da tanımlı olması gerekir. #Ancak my_function fonksiyonuna herhangi bir a değeri gönderilmedi. ''' print(x(5)) # x ifadesi a * 2 gibi bir denkleme eşit. Bu durumda gönderilen 5 değeri a için kullanılacaktır. #Sonuç/Fonksiyon Çıktısı: 10
8. Python’da Sınıfları ve Nesneleri Anlamak (class and objects)
Python’da nesne (object) yönelimli bir programlama dilidir. Python’da neredeyse her şey özellikleri/değişkenleri (attributes/variables) ve metotları (methods) olan bir nesnedir. Nesneler özelliklerini ve metotlarını sınıflardan alırlar. Diğer bir ifadeyle nesneler sınıflar yardımıyla oluşturulabilir. Aşağıda özellikleri x ve y olarak tanımlanmış basit bir sınıf vardır.
#Aşağıdaki sınıfı çalıştırdığınızda konsolda herhangi bir şey yazdırılmaz.
class MyClass(): #Sınıflar class ifadesi ile başlar. MyClass gibi sizin adlandırdığınız bir sınıf ismi ile devam eder. Son olarak parantezler ve iki nokta eklenir.
#Sınıfın içine yazılacak kodlar belirli bir girintiden sonra başlamalıdır. Sola yaslı olursa Python hata verir.
x = "İshak Kutlu" #Bu bir özellik
y = 37 #Bu da bir özellik
#Not: Sınıf içindeki kodları yazdıktan sonra, yeni kodları normal bir şekilde sola yaslı yazabilirsiniz.
Yukarıdaki MyClass sınıfı kullanılarak aşağıda gösterildiği gibi bir “a” nesnesi tanımlanabilir.
#Aşağıdaki sınıfı çalıştırdığınızda konsolda herhangi bir şey yazdırılmaz.
class MyClass(): #Sınıflar class ifadesi ile başlar. MyClass gibi sizin adlandırdığınız bir sınıf ismi ile devam eder. Son olarak parantezler ve iki nokta eklenir.
#Sınıfın içine yazılacak kodlar belirli bir girintiden sonra başlamalıdır. Sola yaslı olursa Python hata verir.
x = "İshak Kutlu" #Bu bir özellik
y = 37 #Bu da bir özellik
#Not: Sınıf içindeki kodları yazdıktan sonra, yeni kodları normal bir şekilde sola yaslı yazabilirsiniz.
a = MyClass() #a ifadesinin sınıfını MyClass yaptık. Böylece “a” ifadesini/değişkenini Python’un nezdinde nesne yapmış olduk.
“a“ nesnesi MyClass sınıfının bir üyesi olduğu için onun tüm özelliklerini (ve varsa metotlarını) kullanabilir. Yukarıdaki MyClass sınıfının sadece özellikleri vardır. Bu durumda “a” nesnesi MyClass sınıfının x ve y özelliklerini aşağıda gösterildiği gibi kullanabilir.
class MyClass(): #Sınıflar class ifadesi ile başlar. MyClass gibi sizin adlandırdığınız bir sınıf ismi ile devam eder. Son olarak parantezler ve iki nokta eklenir.
#Sınıfın içine yazılacak kodlar belirli bir girintiden sonra başlamalıdır. Sola yaslı olursa Python hata verir.
x = "İshak Kutlu" #Bu bir özellik
y = 37 #Bu da bir özellik
#Not: Sınıf içindeki kodları yazdıktan sonra, yeni kodları normal bir şekilde sola yaslı yazabilirsiniz.
a = MyClass() #a ifadesini MyClass sınıfını kullanarak nesne yapmış olduk. Sonrasında “a” ifadesi için MyClass sınıfının özellikleri kullanılabilir.
#Bir sınıfın özelliğini kullanabilmek için "NesneAdı"ndan sonra "nokta" koyunuz ve sonrasında özelliği yazınız. Örnek a.x ya da a.y gibi.
print(a.x) #Sonuç: İshak Kutlu # İpucu: a ifadesinden sonra nokta eklerseniz, a nesnesi MyClass sınıfına ait olduğu için x ve y özelliklerini görebilirsiniz.
print(a.y) #Sonuç: 37
Metot ise sınıf içinde tanımlanan bir fonksiyona verilen isimdir. Yukarıdaki MyClass sınıfına aşağıda gösterildiği gibi basit bir fonksiyon/metot ilave edilmiştir.
class MyClass(): #Sınıflar class ifadesi ile başlar. MyClass gibi sizin adlandırdığınız bir sınıf ismi ile devam eder. Son olarak parantezler ve iki nokta eklenir.
#Sınıfın içine yazılacak kodlar belirli bir girintiden sonra başlamalıdır. Sola yaslı olursa Python hata verir.
x = "İshakKutlu" #Bu bir özellik
#x = "İshak Kutlu" #String ifadede boşluk (yani alfabetik olmayan karakter) varsa MyFunc fonksiyonun davranışını test edebilirsiniz.
#x = 125 x ifadesine integer bir değer atanması durumunda MyFunc metodunun davranışını test edebilirsiniz.
y = 37 #Bu da bir özellik
def MyFunc(self): #def ve self ifadeleri olmak zorundadır. MyFunc ismini dilediğiniz bir isim yapabilirsiniz. Sonda iki nokta olmak zorundadır.
x = str(self.x) #Aşağıda işlenecek veri kesinlikle string olmak zorundadır. Bu yüzden veri önce stringe dönüştürülür.
if x.isalpha() == False: # Bir üst satırda stringe çevrilen verinin tümüyle alfabetik karakterlerden oluşup oluşmadığı kontrol edilir. Alfabetik değilse verinin alfabetik olmadığı konsola yazdırılır.
print("Bu metot sadece alfabetik karakterler içeren ifadelerde kullanılabilir!")
if x.isalpha() == True: # Veriyi stringe dönüştürülmüştü. Eğer veri tümüyle alfabetik karakterlerden oluşuyorsa karakterleri büyük harfe dönüştürür.
print(self.x.upper())
#Not: Sınıf içindeki kodları yazdıktan sonra, yeni kodları normal bir şekilde sola yaslı yazabilirsiniz.
print("___________\n")
a = MyClass() #a ifadesini MyClass sınıfını kullanarak nesne yapmış olduk.
#Bir sınıfın özelliklerini kullanabilmek için değişkenin sınıfının belirtilmesinden sonraki satırlarda, söz konusu değişken için sınıfın tüm özelliklerini ve metotlarını kullanabilirsiniz.
#Bir sınıfın özelliğini kullanabilmek için "NesneAdı"ndan sonra "nokta" koyunuz ve sonrasında özelliği yazınız. Örnek a.x ya da a.y gibi.
print(a.x) #Sonuç: İshak Kutlu # İpucu: a ifadesinden sonra nokta eklerseniz, a nesnesi MyClass sınıfına ait olduğu için x ve y özelliklerini görebilirsiniz.
print(a.y) #Sonuç: 37
a.MyFunc() #Sonuç: İSHAKKUTLU # Alternatif Sonuç: Bu metot sadece alfabetik karakterler içeren ifadelerde kullanılabilir!
# Not: MyFunc, MyClass sınıfının x özelliğinin alfabetik karakterlerini büyük harfe dönüştürüyor.
# a değişkeninde "İshakKutlu" gibi string bir değer olmasa da bu değeri x özelliğinin kullanıldığı MyFunc fonksiyonunun çıktısından alıyor.
print("___________\n")
#Aynı sınıfı kullanarak başka bir nesnenin oluşturulması
b = MyClass() #b ifadesini MyClass sınıfını kullanarak nesne yapmış olduk.
print(b.x) #Sonuç: İshak Kutlu
print(b.y) #Sonuç: 37
b.MyFunc() #Sonuç: İSHAKKUTLU # Alternatif Sonuç: Bu metot sadece alfabetik karakterler içeren ifadelerde kullanılabilir!
Yukarıdaki örneklerde özetle sınıf oluşturmayı, sınıfın içinde özellikleri ve metotları tanımlamayı ve bir değişkeni belirli bir sınıfa üye yaparak onu nesne yapmayı, sınıfın özelliklerini ve metotlarını nesneyle kullanmayı inceledik. Ayrıca MyClass sınıfının tüm özellikleri ve metotları ile (b gibi) başka nesneler/değişkenler için de yeniden kullanılabilir olduğunu, dolayısıyla sınıfın genel bir görevi olduğunu gördük.
O halde Python’da sınıf, özellikleri ve metotları ile benzer niteliklere sahip nesneleri oluşturan yeniden kullanılabilir genelleştirilmiş kod blokları olarak tanımlanabilir. Bu tanımda geçen ”sınıf”, “özellikler”, “metotlar”, “yeniden kullanılabilir” ve “genelleştirilmiş” ifadelerinin biraz daha detaylı incelenmesinde yarar var.
“Bird” isminde bir sınıf tanımlandığı varsayımında, kuşların uçması/uçamaması, kanatlara sahip olması, yırtıcı ya da evcil olması ve kuş olması gibi ortak nitelikleri/nicelikleri sınıf içinde “özellik/öznitelik/değişken” (attribute/variable) olarak belirtilebilir. Bu özellikler kartal için geçerli olabileceği gibi bir muhabbet kuşu için de geçerli olacağı için “genelleştirilmiş”tir. Ancak kartal ve muhabbet kuşu arasında, evcil ya da yırtıcı olma veya uçabilme ya da uçamama gibi farklı özellikler de olacaktır. Benzer şekilde bir kartalın ya da muhabbet kuşunun dişil veya eril olması gibi farklılıklar da olabilir. Bu farklılıklar doğrudan özellik ile belirtilebileceği gibi sınıfın içinde tanımlanan fonksiyonlar yardımıyla da ifade edilebilir. Bu çerçevede “metot”, yukarıda da belirtildiği gibi bir sınıfın içinde tanımlanan fonksiyondan başka bir şey değildir. “Bird” isimli sınıfın kodlarında herhangi bir değişiklik yapmadan, bir kartal ya da muhabbet kuşu için doğrudan kullanılabilir olması “yeniden kullanılabilirliğe” işaret eder. Kartal ya da muhabbet kuşu “Bird” sınıfına atanarak onun birer nesnesi olurlar. Bir sınıfın nesneleri de o sınıfın tüm özelliklerini ve metotlarını kullanabilir.
Aşağıda, açıklamaları kodların içinde yapılmış olan, kartal ve muhabbet kuşunun “Bird” sınıfı ile basit bir kullanımı bulunmaktadır. Kodları, çalıştırdıktan sonra incelemeniz önerilir.
print("______________________Bird SINIFI______________________\n")
#Kuş sınıfı
class Bird: #Sınıf tanımlarken "class" ifadesi, boşluk "Sinif_Ismi" ve iki nokta olmalıdır. Sınıfın özellikleri ve metotları içe girinti verilerek yazılır.
#özellikler/öznitelikler (attributes)
#özellikler nesne ile doğrudan kullanılabileceği gibi aşağıda gösterildiği gibi fonksiyon aracılığıyla da kullanılabilir.
attr_kanat = "kanatlara sahiptir"
attr_vahsi = "yırtıcıdır"
attr_evcil = "evcildir"
#Sınıf içinde kullanılan bir fonksiyon, metot olarak adlandırılır. Metotların içinde kullanılan özellikler yukarıda tanımlanmıştır.
#Metotları nesnelerin davranışları olarak düşünebilirsiniz. Çünkü bir metodun/fonksiyonun girdisi, metot içinde işlenerek bir çıktıya/davranışa dönüşecektir.
#vahşi metodu
def vahsi_func(self, myObje): #myObje fonksiyonun/metodun bir değişkenidir. Çalışma ilkesi daha önce fonksiyon konusunda açıklanmıştı. Self değişkeni kullanılmak zorundadır.
print("Bir", myObje, self.attr_vahsi + ".") #Özellik kullanılırken Self değişkeni ile kullanır.
#evcil metodu
def evcil_func(self, myObje): #myObje fonksiyonun/metodun bir değişkenidir. Çalışma ilkesi daha önce fonksiyon konusunda açıklanmıştı. Self değişkeni kullanılmak zorundadır.
print("Bir", myObje, self.attr_evcil + ".") #Özellik kullanılırken Self değişkeni ile kullanır.
#Sınıf burada bitiyor. Bundan sonraki satırlarda yer alan kodlar sınıfa ait olmayan normal kodlardır.
#_______________________________________
print("___________KARTAL\n")
#Nesne örneği (myKartal'ın sınıfının belirtilmesi)
myKartal = Bird() #myKartal değişkeninin "Bird" sınıfına üye yapılması ve onun nesnesi haline gelmesi. Artık myKartal değişkeni Bird sınıfının tüm özelliklerini ve metotlarını kullanabilir.
#myKartal ifadesini Bird sınıfı içinde onun kimliği olarak da düşünebilirsiniz.
#myKartal, artık "Bird" sınıfının üyesi olduğuna göre onun özelliklerine erişebilir.
print(myKartal.attr_kanat) #Sonuç: kanatlara sahiptir
print(myKartal.attr_vahsi) #Sonuç: yırtıcıdır
myKartal.vahsi_func("kartal") #"kartal" değişkeni, myObje değişkeni ile vahsi_func içine aktarılacaktır.
print("___________MUHABBET KUŞU\n")
#Nesne örneği (myMuhabbetKusu'ın sınıfının belirtilmesi)
myMuhabbetKusu = Bird() #myMuhabbetKusu değişkeninin "Bird" sınıfına üye yapılması ve nesne haline gelmesi. Artık myMuhabbetKusu değişkeni Bird sınıfının tüm özelliklerini ve metotlarını kullanabilir.
#myMuhabbetKusu ifadesini Bird sınıfı içinde onun kimliği olarak da düşünebilirsiniz.
#myMuhabbetKusu, artık "Bird" sınıfının üyesi olduğuna göre onun özelliklerine erişebilir.
print(myMuhabbetKusu.attr_kanat) #Sonuç: kanatlara sahiptir
print(myMuhabbetKusu.attr_evcil) #Sonuç: evcildir
myMuhabbetKusu.evcil_func("muhabbet kuşu") #"muhabbet kuşu" değişkeni, myObje değişkeni ile evcil_func içine aktarılacaktır.
Yukarıdaki örneği pekiştirmek amacıyla, açıklamaları kodların içinde yapılmış olan yukarıdaki örneğe göre biraz daha detaylandırılmış aşağıdaki sınıf çalışmasını, kodları çalıştırdıktan sonra incelemeniz önerilir.
print("______________________Bird_2 SINIFI______________________\n")
#Sınıf (class)
class Bird_2:
#öznitelikler (attributes)
attr_kus = "kuştur"
attr_ureme = "memeli değildir"
attr_kanat = "kanatlara sahiptir."
attr_disil = "dişildir"
attr_eril = "erildir"
attr_vahsi = "yırtıcıdır"
attr_evcil = "evcildir"
attr_ucar = "uçabilir"
attr_ucamaz = "uçamaz"
#Kuşların ortak özellikleri metodu
def ortak_func(self, myObje):
print("Bir", myObje, self.attr_kus +".")
print("Bir", myObje, self.attr_ureme + ".")
print("Bir", myObje, self.attr_kanat + ".")
print("Bir", myObje, self.attr_disil, "ya da", self.attr_eril + ".")
#Sınıf içinde kullanılan bir fonksiyon, metot olarak adlandırılır.
#vahşi metodu
def vahsi_func(self, myObje):
print("Bir", myObje, self.attr_vahsi + ".")
#evcil metodu
def evcil_func(self, myObje):
print("Bir", myObje, self.attr_evcil + ".")
#uçar/uçamaz metodu
def ucar_ucamaz_func(self, myObje, ucarmi = 1): #Varsayılan parametre 1, yani uçar.
if ucarmi == 1: #ucarmi parametresinin değeri 1 ise o nesnenin/kuş türünün uçabildiğini ifade eder.
print("Bir", myObje, self.attr_ucar + ".")
else: #ucarmi parametresinin değeri 1 değil ise o nesnenin/kuş türünün uçamadığını ifade eder.
print("Bir", myObje, self.attr_ucamaz + ".")
#Sınıf burada bitiyor. Bundan sonraki satırlarda yer alan kodlar sınıfa ait olmayan normal kodlardır.
#_______________________________________
print("________________________KARTAL ÖRNEĞİ\n")
#Nesne örneği
myKartal = Bird_2()
print("___________Sınıfın Birkaç Özelliği Nedir?\n")
#Sınıfın özelliklerine erişme
print(myKartal.attr_kus)
print(myKartal.attr_vahsi)
print(myKartal.attr_kanat)
print("___________Genel Özellikleri Nedir?\n")
#Metotları objelerle kullanma
myKartal.ortak_func("kartal") #"kartal" değişkeni, myObje değişkeni ile ortak_func içine aktarılacaktır.
print("___________Yırtıcı mı Evcil mi?\n")
myKartal.vahsi_func("kartal") #"kartal" değişkeni, myObje değişkeni ile vahsi_func içine aktarılacaktır.
print("___________Uçabilir mi?\n")
myKartal.ucar_ucamaz_func("kartal", 1) #"kartal" değişkeni myObje değişkeniyle, 1 değeri ise ucarmi değişkeniyle ucar_ucamaz_func içine aktarılacaktır.
print("________________________MUHABBET KUŞU ÖRNEĞİ\n")
#Başka bir nesne örneği
myMuhabbetKusu = Bird_2()
print("___________Sınıfın Birkaç Özelliği Nedir?\n")
#Sınıfın özelliklerine erişme
print(myMuhabbetKusu.attr_kus)
print(myMuhabbetKusu.attr_evcil)
print(myMuhabbetKusu.attr_kanat)
print("___________Genel Özellikleri Nedir?\n")
#Metotları objelerle kullanma
myMuhabbetKusu.ortak_func("muhabbet kuşu") #"muhabbet kuşu" değişkeni, myObje değişkeni ile ortak_func içine aktarılacaktır.
print("___________Yırtıcı mı Evcil mi?\n")
myMuhabbetKusu.evcil_func("muhabbet kuşu") #"muhabbet kuşu" değişkeni, myObje değişkeni ile vahsi_func içine aktarılacaktır.
print("___________Uçabilir mi?\n")
myMuhabbetKusu.ucar_ucamaz_func("muhabbet kuşu", 0) #"muhabbet kuşu" değişkeni myObje değişkeniyle, 0 değeri ise ucarmi değişkeniyle ucar_ucamaz_func içine aktarılacaktır.
#myMuhabbetKusu.ucar_ucamaz_func("muhabbet kuşu") # 1 veya 1'den farklı bir değer olması gereken ucarmi değişkeni belirtilmedi. Metodun varsayılan değeri 1 olduğu için sonuç da "uçabilir" olacak.
Sınıflara dahil olmakla birer nesne olan değişkenlerin (myKartal, myMuhabbetKusu gibi) isimleri birer kimlik, sınıf içinde tanımlanan (kanatlı olması, kuş, eril, dişil gibi) niteliklerden/niceliklerden aldıkları birer özellik ve sınıf içinde tanımlanan (vahsi_func, evcil_func, ucar_ucamaz_func gibi) metotların çıktıları ise birer davranış olarak değerlendirilebilir. Kısaca, yukarıdaki örnekte de özetlendiği gibi nesnelerin kimlikleri, özellikleri ve davranışları vardır.
Sınıf ve nesne konusu Python’un “string”, “boolean”, “list” gibi kendi kütüphanelerinde yer alan değişken tipleri üzerinden de incelenebilir. Söz gelimi myList = [“Volvo”, “Opel”, “Honda”] şeklinde bir değişken tanımlandığında, Python myList değişkenini “list” sınıfına ait bir nesne olarak görüyor. Köşeli parantezler, elemanlar arasında bulunan virgüller vb. kriterler ile sınıf deklarasyonu açıkça yapılmamasına rağmen, Python onun “list” sınıfına ait olduğunu anlıyor. Örneğin len(myList) şeklinde bir komut yazıldığında, Python “list” sınıfının “len” fonksiyonunu/metodunu çağırmak suretiyle myList nesnesinin eleman sayısını hesaplıyor. Örneğe göre devam edilirse “list” sınıfına ait myList nesnesiyle, “string” sınıfına ait olan “upper” metodunu kullanmak istediğimizde, “list” sınıfının içinde “upper” metodu tanımlı olmadığı için Python hata verecektir. Ancak myList = “İshak Kutlu” şeklinde bir tanımlama yapılırsa, Python, myList isimli değişkeni “string” sınıfına dahil edecektir. myList = “İshak Kutlu” satırından sonra kullanılan upper.MyList komutu, Python tarafından işlenerek, “string” sınıfında yer alan “upper” metodu aracılığıyla nesneye uygulanacaktır.
myList = ["Volvo", "Opel", "Ford"] #myList "list" bir değişken
print(len(myList)) #Sonuç: 3
#print(myList.upper()) #Sonuç: AttributeError: 'list' object has no attribute 'upper'
print("___________\n")
myList = "İshak Kutlu" #myList artık "string" bir değişken
print(myList.upper()) #Sonuç: İSHAK KUTLU
İshak Kutlu, Veri Bilimi İçin Python Notları
