Python'da Nesne Yönelimli Programlama: Kapsamlı Bir Rehber

Nesneleri örneklemek

Bir nesne örneklemek için sınıf adını yazıp iki parantez açın. Nesneyi takip etmek için bunu bir değişkene atayabilirsiniz.

ozzy = Dog()

Ve yazdırın:

print(ozzy)

<__main__.Dog object at 0x111f47278>

Bir sınıfa öznitelik eklemek

ozzy’yi yazdırdıktan sonra, bu nesnenin bir köpek olduğu açıktır. Ancak henüz hiçbir öznitelik eklemediniz. Dog sınıfına bir ad ve yaş verelim:

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

Gördüğünüz gibi, artık self’ten sonra iki argüman alıyor: name ve age. Bunlar sırasıyla self.name ve self.age’e atanıyor. Artık ad ve yaşı olan yeni bir ozzy nesnesi oluşturabilirsiniz:

ozzy = Dog("Ozzy", 2)

Python’da bir nesnenin özniteliklerine erişmek için nokta gösterimini kullanabilirsiniz. Bu, nesnenin adını yazıp bir nokta ve özniteliğin adını ekleyerek yapılır

print(ozzy.name)

print(ozzy.age)

Ozzy
2

Bunu daha uzun bir cümlede de birleştirebilirsiniz:

print(ozzy.name + " is " + str(ozzy.age) + " year(s) old.")

Ozzy is 2 year(s) old.

Burada str() işlevi, bir tamsayı olan age özniteliğini, print() içinde kullanabilmeniz için metne dönüştürmek üzere kullanılıyor.

Bir sınıfta yöntemler tanımlama

Artık bir Dog sınıfınız var; adı ve yaşı var ve bunları takip edebiliyorsunuz, fakat aslında bir şey yapmıyor. İşte burada örnek yöntemler devreye giriyor. Sınıfı yeniden yazarak bir bark() yöntemi ekleyebilirsiniz. def anahtar sözcüğünün ve self argümanının tekrar kullanıldığına dikkat edin.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

bark yöntemi, yeni bir ozzy nesnesi örneklendirdikten sonra nokta gösterimiyle çağrılabilir. Yöntem ekrana "bark bark!" yazdırmalıdır. .bark() içindeki parantezlere dikkat edin. Bir yöntemi çağırırken her zaman kullanılırlar. Bu örnekte boştur; çünkü bark() yöntemi herhangi bir argüman almaz.

ozzy = Dog("Ozzy", 2)

ozzy.bark()

bark bark!

Daha önce ozzy’yi nasıl yazdırdığınızı hatırlıyor musunuz? Aşağıdaki kod, Dog sınıfında doginfo() yöntemiyle bu işlevi uygular. Ardından farklı özelliklere sahip bazı nesneler örneklendirir ve bu yöntemi onlar üzerinde çağırırsınız.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

ozzy = Dog("Ozzy", 2)
skippy = Dog("Skippy", 12)
filou = Dog("Filou", 8)

ozzy.doginfo()
skippy.doginfo()
filou.doginfo()

Ozzy is 2 year(s) old.
Skippy is 12 year(s) old.
Filou is 8 year(s) old.

Gördüğünüz gibi, nokta gösterimiyle doginfo() yöntemini nesneler üzerinde çağırabilirsiniz. Yanıt artık yöntemi hangi Dog nesnesi üzerinde çağırdığınıza bağlıdır.

Köpekler yaşlandığı için, yaşlarını buna göre ayarlayabilmeniz güzel olurdu. Ozzy az önce 3 oldu, hadi yaşını değiştirelim.

ozzy.age = 3

print(ozzy.age)

3

Bir özniteliğe yeni bir değer atamak kadar kolay. Bunu Dog sınıfında bir birthday() yöntemi olarak da uygulayabilirsiniz:

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

ozzy = Dog("Ozzy", 2)

print(ozzy.age)

2

ozzy.birthday()

print(ozzy.age)

3

Artık köpeğin yaşını elle değiştirmenize gerek yok. Doğum günü olduğunda birthday() yöntemini çağırmanız yeterli. 

Yöntemlere argüman aktarmak

Köpeklerimizin birer dostu olmasını istiyorsunuz. Bu isteğe bağlı olmalı; zira her köpek aynı derecede sosyal değildir. Aşağıdaki setBuddy() yöntemine bakın. Her zamanki gibi self ve ayrıca buddy argümanlarını alır. Bu durumda buddy başka bir Dog nesnesi olacaktır. self.buddy özniteliğini buddy’ye ve buddy.buddy özniteliğini self’e ayarlayın. Bu, ilişkinin karşılıklı olduğu anlamına gelir; dostunuzun dostusunuz. Bu örnekte Filou, Ozzy’nin dostu olacaktır; bu da Ozzy’nin otomatik olarak Filou’nun dostu olması demektir. Bunu bir yöntem tanımlamak yerine öznitelikleri elle de ayarlayabilirsiniz; fakat her seferinde bir yerine iki satır kod yazmanız gerekir. Python’da argümanın türünü belirtmenize gerek olmadığını unutmayın. Bu Java olsaydı, gerekli olurdu.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

    def setBuddy(self, buddy):
        self.buddy = buddy
        buddy.buddy = self

Artık yöntemi nokta gösterimiyle çağırabilir ve ona başka bir Dog nesnesi geçebilirsiniz. Bu durumda Ozzy’nin dostu Filou olacaktır:

ozzy = Dog("Ozzy", 2)
filou = Dog("Filou", 8)

ozzy.setBuddy(filou)

Artık Ozzy’nin dostu hakkında bilgi almak istiyorsanız, nokta gösterimini iki kez kullanabilirsiniz: Önce Ozzy’nin dostuna başvurmak, sonra da onun özniteliğine başvurmak için.

print(ozzy.buddy.name)
print(ozzy.buddy.age)

Filou
8

Bunun Filou için de yapılabileceğine dikkat edin.

print(filou.buddy.name)
print(filou.buddy.age)

Ozzy
2

Dostun yöntemleri de çağrılabilir. doginfo()’ya aktarılan self argümanı artık ozzy.buddy, yani filou’dur.

 ozzy.buddy.doginfo()

Filou is 8 year(s) old.

Python OOP Örneği

Nesne yönelimli programlamanın Python’da işe yarayabileceği bir örnek, Python ve Finans: Algoritmik Alım Satım eğitimimizdir. Bu eğitimde, bir hisse senedi portföyü için alım satım stratejisinin nasıl kurulacağını açıklıyoruz. Strateji, hisse fiyatının hareketli ortalamasına dayanır. signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:] koşulu sağlanırsa bir sinyal oluşturulur. Bu sinyal, hissenin gelecekteki fiyat değişimi için bir öngörüdür. Aşağıdaki kodda önce başlatma, ardından hareketli ortalama hesaplama ve sinyal üretimi olduğunu göreceksiniz. Bu nesne yönelimli olmayan kod, tek seferde çalıştırılan büyük bir bloktur. Örnekte Apple’ın sembolü olan aapl kullandığımıza dikkat edin. Bunu farklı bir hisse için yapmak isteseydiniz, kodu yeniden yazmanız gerekirdi.

# Initialize
short_window = 40
long_window = 100
signals = pd.DataFrame(index=aapl.index)
signals['signal'] = 0.0

# Create short simple moving average over the short window
signals['short_mavg'] = aapl['Close'].rolling(window=short_window, min_periods=1, center=False).mean()

# Create long simple moving average over the long window
signals['long_mavg'] = aapl['Close'].rolling(window=long_window, min_periods=1, center=False).mean()

# Create signals
signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:], 1.0, 0.0)   

# Generate trading orders
signals['positions'] = signals['signal'].diff()

# Print `signals`
print(signals)

Nesne yönelimli bir yaklaşımda, yalnızca başlatma ve sinyal üretim kodunu bir kez yazmanız gerekir. Ardından, strateji hesaplamak istediğiniz her hisse için yeni bir nesne oluşturur ve onun üzerinde generate_signals() yöntemini çağırırsınız. OOP kodunun yukarıdaki koda çok benzediğine, yalnızca self’in eklendiğine dikkat edin.

class MovingAverage():

    def __init__(self, symbol, bars, short_window, long_window):
        self.symbol = symbol
        self.bars = bars
        self.short_window = short_window
        self.long_window = long_window

    def generate_signals(self):
        signals = pd.DataFrame(index=self.bars.index)
        signals['signal'] = 0.0

        signals['short_mavg'] = bars['Close'].rolling(window=self.short_window, min_periods=1, center=False).mean()
        signals['long_mavg'] = bars['Close'].rolling(window=self.long_window, min_periods=1, center=False).mean()

        signals['signal'][self.short_window:] = np.where(signals['short_mavg'][self.short_window:] > signals['long_mavg'][self.short_window:], 1.0, 0.0)   

        signals['positions'] = signals['signal'].diff()   

        return signals

Artık yalnızca istediğiniz parametrelerle bir nesne örnekleyip onun için sinyaller üretebilirsiniz.

apple = MovingAverage('aapl', aapl, 40, 100)
print(apple.generate_signals())

Bunu başka bir hisse için yapmak çok kolay hale gelir. Farklı bir sembolle yeni bir nesne örneklemek yeterlidir.

microsoft = MovingAverage('msft', msft, 40, 100)
print(microsoft.generate_signals())

Python'da Nesne Yönelimli Programlama: Özet

Python’daki temel OOP kavramlarının bazılarını ele aldık. Artık sınıf ve yöntemleri nasıl tanımlayacağınızı, nesneleri nasıl örnekleyeceğinizi, özniteliklerini nasıl ayarlayacağınızı ve örnek yöntemleri nasıl çağıracağınızı biliyorsunuz. Bu beceriler, veri bilimci olarak kariyerinizde işinize yarayacaktır. Python ile çalışmak için gereken temel kavramları genişletmek isterseniz, Veri Bilimi için Orta Düzey Python kursumuza göz atın.

OOP ile, programınız büyüdükçe kodunuzun karmaşıklığı artacaktır. Farklı sınıflar, alt sınıflar, nesneler, kalıtım, örnek yöntemler ve daha fazlası olacaktır. Karmaşık kalıtım senaryoları için çoklu kalıtımı ve super()’ı öğrenin. Kodunuzu düzenli ve okunaklı tutmak isteyeceksiniz. Bunu yapmak için tasarım kalıplarını takip etmek önerilir. Bunlar, kötü tasarımdan kaçınmaya yönelik ilke setlerini temsil eden tasarım prensipleridir. Her biri, Python OOP’de sıkça tekrar eden belirli bir sorunu temsil eder ve o sorunun tekrar tekrar kullanılabilecek çözümünü açıklar. Bu OOP tasarım kalıpları birkaç kategoriye ayrılabilir: yaratıcı kalıplar, yapısal kalıplar ve davranışsal kalıplar. Yalnızca bir sınıfın tek bir örneğinin oluşturulmasını garanti etmek istediğinizde kullanılabilecek tekil nesne (singleton) yaratıcı bir kalıba örnektir. Bir koleksiyondaki tüm nesneleri dolaşmak için kullanılan bir Python yineleyicisi ise davranışsal bir kalıba örnektir.