Python Kalıtım: Yeniden Kullanılabilir Kod için En İyi Uygulamalar

Python Kalıtımının Temelleri

Kalıtım, bir sınıfın (alt sınıf olarak adlandırılır) başka bir sınıftan (üst sınıf olarak adlandırılır) öznitelik ve metotlar türetmesine olanak tanıyan nesne yönelimli programlamanın (OOP) temel dayanaklarından biridir. Bu özellik kodun yeniden kullanımı için merkezidir ve bakımı kolaylaştırır; ölçeklenebilir ve verimli programlar geliştirmeyi mümkün kılar.

Üst ve alt sınıfları tanımlamak

Daha ileri gitmeden önce üst ve alt sınıflar arasındaki ilişkiyi inceleyelim.

Üst sınıf

Üst sınıfla başlayalım. Üst sınıf, alt sınıfların türetildiği temel sınıftır. Ortak öznitelik ve metotları kapsüller.

Python kullanarak üst sınıfı şu şekilde tanımlarız:

class ParentClass:
    def __init__(self, attributes):
        # Initialize attributes
        pass

    def method(self):
        # Define behavior
        passAltyapı:

Alt sınıf 

Bir alt sınıf, üst sınıftan öznitelik ve metotları devralır. Böylece üst sınıfta tanımlanan işlevselliği kullanabilir. Aşağıdaki kod bir alt sınıfın bir üst sınıftan öznitelik ve metotları nasıl devraldığını gösterir:

class ChildClass(ParentClass):
    def additional_method(self):
        # Define new behavior
        passAltyapı:

Bu basit söz dizimi, alt sınıfın üst sınıfta tanımlanan işlevselliği kullanmasına ve genişletmesine olanak tanır.

Bir üst sınıf ve bir alt sınıf oluşturma

Pratik bir örnek olarak, üst sınıf olarak Person ve alt sınıf olarak Student sınıflarını oluşturalım.

Üst sınıfı oluşturma

Person sınıfı ortak öznitelikler ve bilgileri görüntülemek için bir metot içerir:    

# Defining the Parent Class
class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id
    def display_info(self):
        return f"Name: {self.name}, ID: {self.id}"Altyapı:

Alt sınıfı oluşturma

Student sınıfı Person'dan kalıtım alır ve study adlı yeni bir metot ekler.

# Defining the Child Class
class Student(Person):
    def study(self):
        return f"{self.name} is studying."Altyapı:

Üst ve alt sınıfları test edelim.

# Creating and Testing Instances
student = Student("Samuel", 102)
print(student.display_info())  
print(student.study())      Altyapı:

Name: Samuel, ID: 102
Samuel is studying.Altyapı:

Burada olanlar şunlar:

1. Student sınıfı, name ve id'yi başlatmak için Person'ın __init__ metodunu kullanır.

2. study metodu, işlevselliği genişleten, Student sınıfına özgüdür.

3. display_info metodu doğrudan Person'dan kalıtılır.

Python'da Kalıtım Türleri

Python'da kalıtım, sınıfların diğer sınıflardan öznitelik ve davranışları devralmasına olanak tanır; bu da daha önce bahsettiğimiz gibi kodun yeniden kullanımını ve temiz tasarımı teşvik eder. Bu bölümde, tekli, çoklu, hiyerarşik ve hibrit kalıtım gibi Python kalıtım türlerini ayrı kategoriler olarak ele alacağız.

Tekli kalıtım

Tekli kalıtım, bir alt sınıfın tek bir üst sınıftan kalıtım almasıyla gerçekleşir ve alt sınıfın üst sınıfın işlevselliğini genişletmesine olanak tanır. Bu, bir nesne türünün daha geniş bir kategoriyle ortak özellikleri paylaştığı, ancak ek öznitelik veya davranışlara da ihtiyaç duyduğu durumlarda kullanışlıdır.

Önceden ele almaya başladığım örnek tekli kalıtımdı, ancak şimdi biraz daha yakından bakalım: Bir okul yönetim sisteminde öğrenciler, öğretmenler ve personel dahil tüm bireyler name ve ID gibi bazı ortak bilgilere sahiptir. Ancak öğrencilerin notlar ve kayıtlı dersler gibi akademik kayıtları da vardır. Tekli kalıtımı kullanarak, ortak öznitelikler için bir Person sınıfı oluşturabilir ve bunu akademik ayrıntılar için bir Student sınıfıyla genişletebiliriz.

Tekli kalıtım. Görsel: Yazar

Yukarıdaki senaryoya iyi bir örnek:

class Person:
    """Represents a general person with basic details."""
    def __init__(self, name, id):
        self.name = name
        self.id = id

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}"

class Student(Person):
    """Represents a student, extending the Person class to include academic details."""
    def __init__(self, name, id, grade, courses):
        super().__init__(name, id)
        self.grade = grade
        self.courses = courses

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}, Courses: {', '.join(self.courses)}"

# Example usage in a school system
student = Student("Samuel", 5678, "B+", ["Math", "Physics", "Computer Science"])
print(student.get_details())Altyapı:

Name: Samuel, ID: 5678, Grade: B+, Courses: Math, Physics, Computer ScienceAltyapı:

Student sınıfı, Person sınıfından get_details() metodunu devralır, ancak bunu grade ve courses bilgilerini dahil edecek şekilde genişletir. Bu, tekli kalıtımın modüler kodu nasıl teşvik ettiğine iyi bir örnektir.

Çoklu kalıtım

Çoklu kalıtım, bir bakıma soy ağacı gibi, bir alt sınıfın birden fazla üst sınıftan kalıtım almasına ve her birinden öznitelik ve davranışları birleştirmesine olanak tanır. Bu durum potansiyel çatışmalara yol açabilir; Python bunları metot çözümleme sırası (MRO) ile çözer.

Çoklu kalıtım. Görsel: Yazar

Şuna bir bakın:

class Person:
    def get_details(self):
        return "Details of a person."

class Athlete:
    def get_skill(self):
        return "Athletic skills."

class Student(Person, Athlete):
    pass

# Example usage
student = Student()
print(student.get_details())
print(student.get_skill())Altyapı:

Details of a person.
Athletic skills.Altyapı:

Student sınıfının hem Person hem de Athlete'dan öznitelik ve metotlar devraldığını görüyoruz. Ek bir çaba harcamadan, Student sınıfı Person üst sınıfından get_details() metoduna ve Athlete üst sınıfından get_skill() metoduna erişir. Etkili bir şekilde birden fazla kaynaktaki işlevleri birleştiriyoruz.

Ancak birden fazla sınıftan kalıtım almak çatışmalara yol açabilir. Ya her iki üst sınıf da aynı adlı bir metot veya öznitelik tanımlarsa? Daha önce metot çözümleme sırasından bahsetmiştim; şimdi biraz daha açıklayayım. Metot çözümleme sırası, metotlar ve öznitelikler aranırken sınıfların hangi sırayla taranacağını belirler. MRO, derinlik öncelikli ve soldan sağa bir yaklaşımı izler.

Bir sınıfın MRO'sunu __mro__ özniteliği veya mro() metoduyla görüntüleyebilirsiniz:

print(Student.__mro__)Altyapı:

(<class '__main__.Student'>, <class '__main__.Person'>, <class '__main__.Athlete'>, <class 'object'>)Altyapı:

Çok seviyeli, hiyerarşik ve hibrit kalıtım

Python daha karmaşık kalıtım yapıları da destekler. Bu daha karmaşık fikirleri aynı örnek üzerinden göstereceğim.

Çok seviyeli kalıtım

Çok seviyeli kalıtım, bir alt sınıfın başka bir alt sınıftan, o alt sınıfın ise bir üst sınıftan kalıtım aldığı durumdur. Bu, bir kalıtım zinciri oluşturur.

Çok seviyeli kalıtım. Görsel: Yazar

İşte iyi bir örnek:

class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}"

class Student(Person):
    def __init__(self, name, id, grade):
        super().__init__(name, id)
        self.grade = grade

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}"

class GraduateStudent(Student):
    def __init__(self, name, id, grade, thesis_title):
        super().__init__(name, id, grade)
        self.thesis_title = thesis_title

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}, Thesis: {self.thesis_title}"

# Example usage
grad_student = GraduateStudent("Charlie", 91011, "A", "AI in Healthcare")
print(grad_student.get_details())Altyapı:

Name: Charlie, ID: 91011, Grade: A, Thesis: AI in HealthcareAltyapı:

Burada zincirdeki her sınıf yeni bir şey ekler: Person ad ve ID'leri yönetir, Student notları dahil eder ve GraduateStudent tezi tanıtır. super().__init__() sayesinde, başlatma mantığını kopyalamadan yeniden kullanırız. Verimlidir, düzenlidir ve ben buna “kalıtım merdiveni” diyorum; her basamağın çalışmasını sağlar.

Hiyerarşik kalıtım

Hiyerarşik kalıtımda, birden fazla alt sınıf tek bir üst sınıftan kalıtım alır; bu da benzersiz özniteliklere sahip alt sınıflar arasında ortak davranış sağlar.

Hiyerarşik kalıtım. Görsel: Yazar

Birlikte iyi bir örneğe bakalım:

class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}"

class Student(Person):
    def __init__(self, name, id, grade):
        super().__init__(name, id)
        self.grade = grade

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}"

class Teacher(Person):
    def __init__(self, name, id, subject):
        super().__init__(name, id)
        self.subject = subject

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Subject: {self.subject}"

# Example usage
student = Student("Samuel", 5678, "B+")
teacher = Teacher("Dr. Smith", 1234, "Math")
print(student.get_details())  
print(teacher.get_details())Altyapı:

Name: Samuel, ID: 5678, Grade: B+
Dr. Smith, ID: 1234, Subject: MathAltyapı:

Burada Person sınıfı temel görevi görür; ortak öznitelik ve metotları (name, id ve get_details) sunar. Student ve Teacher sınıfları ise kendi benzersiz özelliklerini (grade ve subject) ekleyerek bu işlevselliği genişletir ve bağlamlarına uygun olacak şekilde get_details metodunu özelleştirir.

Bu yaklaşımla, paylaşılan işlevsellik tek bir yerde (Person sınıfı) kalır; özelleşmiş davranışlar ise alt sınıflarda düzenli biçimde kapsüllenir.

Hibrit kalıtım

Hibrit kalıtım, çok seviyeli veya çoklu kalıtım gibi birden fazla kalıtım türünü birleştirerek daha karmaşık ilişkileri modellemeye yarar.

Hibrit kalıtım. Görsel: Yazar

Hibrit kalıtımın karmaşıklığını gösteren bir örneğe bakalım.

# Base class
class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id

    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}"

# Intermediate class inheriting from the base class
class Employee(Person):
    def __init__(self, name, id, position):
        super().__init__(name, id)
        self.position = position

    def get_position(self):
        return f"Position: {self.position}"

# Another independent base class
class Athlete:
    def __init__(self, sport):
        self.sport = sport

    def get_sport(self):
        return f"Sport: {self.sport}"

# Derived class combining Employee and Athlete
class Student(Employee, Athlete):
    def __init__(self, name, id, position, grade, sport):
        Employee.__init__(self, name, id, position)
        Athlete.__init__(self, sport)
        self.grade = grade

    def get_grade(self):
        return f"Grade: {self.grade}"

# Example usage
student = Student("Samuel", 1234, "Intern", "A", "Soccer")
print(student.get_details())  # From Person
print(student.get_position())  # From Employee
print(student.get_grade())  # From Student
print(student.get_sport())  # From AthleteAltyapı:

Name: Samuel, ID: 1234
Position: Intern
Grade: A
Sport: SoccerAltyapı:

Student sınıfı bu örnekte, hibrit kalıtımı, hem Employee'dan (kendisi de Person'dan kalıtım alır) hem de Athlete'tan öznitelik ve metotlar devralarak gösterir. Bu durum hiyerarşik kalıtımı (Employee'ın Person'dan kalıtım aldığı) ve çoklu kalıtımı (Student'ın hem Employee hem de Athlete'tan kalıtım aldığı) birleştirir.

Python'da Kalıtımın Faydaları

Şimdi güçlü ve zayıf yönlerine bakalım: 

Kalıtımın faydaları

1. Yeniden kullanılabilirlik: Kalıtımla, üst sınıfta bir kez yazdığınız kodu alt sınıflarda yeniden kullanabilirsiniz. Örneğin, FullTimeEmployee ve Contractor, Employee üst sınıfından get_details() metodunu devralabilir.

2. Sadelik: Kalıtım, ilişkileri net biçimde modeller. İyi bir örnek, FullTimeEmployee sınıfının Employee üst sınıfının bir “türü” olmasıdır.

3. Ölçeklenebilirlik: Ayrıca mevcut kodu etkilemeden yeni özellikler veya alt sınıflar eklemeyi sağlar. Örneğin, alt sınıf olarak yeni bir Intern sınıfını kolayca ekleyebiliriz.

Kalıtımın olası sınırlamaları

1. Karmaşıklık: Bu şaşırtıcı olmayacak, ancak çok fazla kalıtım seviyesi kodun izlenmesini zorlaştırabilir. Örneğin, bir Employee'ın Manager, Engineer, Intern gibi çok sayıda alt sınıfı varsa kafa karıştırıcı hale gelebilir.

2. Bağımlılık: Bir üst sınıfta yapılan değişiklikler istemeden tüm alt sınıfları etkileyebilir. Örneğin Employee'ı değiştirirseniz, FullTimeEmployee veya Contractor'ı bozabilirsiniz.

3. Yanlış kullanım: Kalıtımı en uygun yöntem olmadığı durumlarda kullanmak tasarımları karmaşıklaştırabilir. Sırf move() metodunu yeniden kullanmak için Car'ın Boat'tan kalıtım aldığı bir çözüm oluşturmak istemezsiniz. Bu ilişki mantıklı değildir.

İleri Düzey Python Kalıtım Teknikleri

Kalıtımın temellerini incelediğimize göre, şimdi bazı ileri düzey tekniklere bakalım. Metot geçersiz kılma, super(), soyut temel sınıflar ve çok biçimlilik gibi teknikler kod esnekliğini artırır ve daha gelişmiş tasarım kalıplarına imkan tanır. 

Python'da metotları geçersiz kılma

Metot geçersiz kılma, bir alt sınıfın, üst sınıfında zaten tanımlanmış bir metot için özel bir uygulama sağlamasına olanak tanır. Bu, devralınan davranış alt sınıfın gereksinimlerini tam olarak karşılamadığında kullanışlıdır.

class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id
    
    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}"

class Student(Person):
    def __init__(self, name, id, grade):
        super().__init__(name, id)
        self.grade = grade
    
    # Overriding the get_details method
    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}"

# Example usage
student = Student("Samuel", 1234, "A")
print(student.get_details())Altyapı:

Name: Samuel, ID: 1234, Grade: AAltyapı:

Burada Student sınıfı, Person sınıfındaki get_details() metodunu kendi özgül uygulamasını sağlamak için geçersiz kılar. Bu, alt sınıfın aynı metot adını izlerken kendi davranışına sahip olmasına olanak tanır.

Peki neden geçersiz kılarız? Çünkü devralınan davranışı özelleştirmek ve üst sınıf metodunun işlevselliğini alt sınıfın özgün gereksinimlerine uyarlamak isteriz.

Üst sınıf başlatma için super() kullanma

super() fonksiyonu, alt sınıftan üst sınıftaki metotları çağırmak için kullanılır. Bu, özellikle __Init__() yapıcı metodu gibi bir üst sınıf metodunun işlevselliğini genişletmek veya değiştirmek istediğinizde kullanışlıdır.

Peki neden super() fonksiyonunu kullanırız? Çünkü üst sınıfın yapıcısını çağırıp başlatmak ve üst sınıfın adını açıkça yazmaktan kaçınmak isteriz. Bu, özellikle çoklu kalıtım durumlarında faydalıdır.

class Person:
    def __init__(self, name, id):
        self.name = name
        self.id = id

class Student(Person):
    def __init__(self, name, id, grade):
        # Using super() to initialize the parent class
        super().__init__(name, id)
        self.grade = grade

# Example usage
student = Student("Samuel", 5678, "B+")
print(student.name)
print(student.id)
print(student.grade)Altyapı:

Samuel
5678
B+Altyapı:

Student sınıfı burada, Person üst sınıfının __init__ metodunu çağırmak için super().__init__(name, id) kullanır; böylece name ve id özniteliklerini başlatmak için kodu tekrarlaması gerekmez. Alt sınıf daha sonra Student sınıfına özgü bir grade özniteliği ekler.

Soyut temel sınıflar (ABC)

Soyut temel sınıf (ABC), doğrudan nesne oluşturmak için kullanılamayan bir sınıftır. Diğer sınıfların uygulaması gereken ortak bir metot kümesi tanımlamak için tasarlanmıştır. Yani ABC'ler, belirli metotların alt sınıflarda her zaman bulunmasını sağlamak istediğinizde kullanışlıdır.

from abc import ABC, abstractmethod

class Person(ABC):
    @abstractmethod
    def get_details(self):
        pass

class Student(Person):
    def __init__(self, name, id, grade):
        self.name = name
        self.id = id
        self.grade = grade
    
    def get_details(self):
        return f"Name: {self.name}, ID: {self.id}, Grade: {self.grade}"

# Example usage
student = Student("Hamilton", 7890, "A-")
print(student.get_details())Altyapı:

Name: Hamilton, ID: 7890, Grade: A-Altyapı:

Person sınıfı burada, herhangi bir alt sınıfın get_details() metodunu uygulamasını gerektiren soyut bir sınıftır. Bu metot daha sonra Student adlı alt sınıf tarafından uygulanır.

Çok biçimlilik

Çok biçimlilik çok şekillilik demektir. Python'da, farklı sınıfların aynı metot adını kullanmasına, ancak her birinin bu metodu farklı bir şekilde uygulamasına olanak tanır.

Çok biçimlilik, farklı sınıflara ait nesnelerle, bu sınıfların davranışları farklı olsa bile, çalışabilen kod yazmamıza yardımcı olur:

class Person:
    def get_details(self):
        return "Details of a person."

class Student(Person):
    def get_details(self):
        return "Details of a student."

class Teacher(Person):
    def get_details(self):
        return "Details of a teacher."

# Example usage
def print_details(person):
    print(person.get_details())

student = Student()
teacher = Teacher()

print_details(student) 
print_details(teacher) Altyapı:

Details of a student.
Details of a teacher.Altyapı:

Bu örnekte, print_details() fonksiyonu Person türündeki herhangi bir nesneyi kabul edebilir, ancak nesne bir Student mı yoksa Teacher mı olduğuna bağlı olarak uygun get_details() metodunu çağırır.

Yaygın Hatalar ve En İyi Uygulamalar

Kalıtım güçlü olmakla birlikte, yanlış kullanımı da kolaydır. Bu fikirlerden en iyi şekilde yararlanmanıza yardımcı olacak bazı öneriler paylaşacağım.

Geçersiz kılınmış metotlarla sürprizleri önleme

Bir alt sınıf üst sınıfından bir metodu geçersiz kıldığında, davranış değişebilir.

Örneğin, üst sınıf Employee'ın bir calculate_pay() metodu varsa ve Manager alt sınıfı bunu tüm senaryoları hesaba katmadan geçersiz kılarsa, hatalı maaş hesaplamalarına yol açabilir.

Bu durumda en iyi uygulama, geçersiz kılınan metotları her zaman kapsamlı şekilde test etmek ve davranışlarını belgelendirmektir.

Kalıtım ve bileşim arasında seçim yapmak

Bu makale kalıtımla ilgili olsa da her zaman doğru yaklaşım değildir. Bazen, sınıfları genişletmek yerine nesneleri bir araya getirerek oluşturduğunuz bileşim (composition), yaptığınız işe daha iyi uyabilir.

Farkları en temel düzeyde damıtacak olursak, şöyle düşünün:

• Kalıtım şunu ifade eder: “-dır/-dir” ilişkileri. Örneğin, bir Manager bir Employee'dır.

• Bileşim şunu ifade eder: “-e/ -a sahip olma” ilişkileri. Örneğin, bir Car'ın bir Engine'i vardır.

Peki bileşimin en iyi yaklaşım olduğunu nasıl anlarsınız? İlişki kesin olarak hiyerarşik değilse ve/veya sınıflar arasındaki sıkı bağımlılığı azaltmak istediğinizde bileşimi kullanın; ayrıca sınıflar arasındaki bağları gevşetmek istediğinizde bileşimi tercih edin.

Ya da şöyle de diyebiliriz: Kalıtım ilişkileri modellemeye odaklanırken, bileşim işlevselliğe odaklanır. Yardımcı olması için şunu düşünün:

• Nesneler doğal olarak hiyerarşik olduğunda kalıtımı kullanın. Örneğin, Animal > Bird > Parrot.

• Nesneler işlevselliği paylaşıyor ancak ilişkili değilse bileşimi kullanın. Örneğin, bir Printer ve Scanner her ikisi de bir DeviceManager kullanır.

Derin kalıtım zincirlerinden kaçının

Derin kalıtım zincirleri (birçok seviyeli üst-alt ilişki) kodunuzu okumayı ve bakımını zorlaştırabilir. Bu sorunludur; çünkü üst sınıftaki değişiklikler istemeden pek çok alt sınıfı etkileyebilir. Ayrıca hata ayıklama zorlaşır; çünkü davranış birden çok seviyeye yayılmıştır.

Bu durumda en iyi uygulama, hiyerarşileri sığ tutmaktır. Ayrıca, (daha önce bahsettiğim) bileşimi kullanmayı değerlendirin veya zincir çok derinleşiyorsa onu ayrı hiyerarşilere bölün.

Sonuç

Kalıtım, yeniden kullanılabilir, modüler ve ölçeklenebilir kod oluşturmanızı sağlayan nesne yönelimli programlamanın önemli bir dayanağıdır. Kalıtımda ustalaşırsanız, karmaşık sistemleri basitleştirmenin kolaylaştığını göreceksiniz.

Anlayışınızı derinleştirmenin iyi bir yolu, projelerinizde kalıtım yapıları kurmayı denemektir. Basit başlayın, sonra pratikte nasıl çalıştıklarını görmek için daha karmaşık hiyerarşilerle deney yapın.

Daha da derinlemesine keşfetmek isterseniz, kalıtım ve diğer kavramları daha iyi anlamak için Programming Paradigm Concepts kursumuza göz atabilirsiniz. Python Developer kariyer yolumuz da yazılım geliştirme için sizi donatacak kapsamlı bir programlama becerileri yolu sunan iyi bir kaynaktır.