آموزش وراثت در پایتون + نکات ارث بری

آموزش وراثت در پایتون
مقالات پایتون
مدت زمان مطالعه : دقیقه
  • 0 نفر پسندیدند
  • ذخیره کردن
  • 1908
فهرست
  • ارث‌بری چندگانه در پایتون
  • Composition در پایتون
  • Super در پایتون
  • سخن پایانی

آموزش وراثت در پایتون + نکات ارث بری

وراثت در پایتون یک مفهوم اساسی در برنامه‌نویسی شی‌گرا است که به شما امکان می‌دهد کلاس‌های جدیدی را بر اساس کلاس‌های موجود ایجاد کنید. وراثت در پایتون، شما را قادر می‌سازد تا دوباره از کدها استفاده کنید، کدهای تکراری را کاهش دهید و سلسله مراتبی از کلاس‌ها ایجاد کنید که ویژگی‌ها و متدهای مشترکی دارند.

با وراثت در پایتون، می‌توانید به راحتی کلاس‌های تخصصی ایجاد کنید که عملکرد کلاس‌های والد خود را به ارث برده و در عین حال ویژگی‌های منحصربه‌فرد خود را اضافه کنید. وراثت در پایتون به شما در ساخت سیستم‌های نرم‌افزاری پیچیده و حل مشکلات دنیای واقعی کمک می‌کند. چه مبتدی باشید و چه یک برنامه‌نویس با تجربه، درک وراثت در پایتون برای تسلط بر برنامه‌نویسیِ شی‌گرا و ارتقای مهارت‌های کدنویسی خود به سطحی بالاتر ضروری است.

اولین قدم در استفاده از وراثت در پایتون، تعریف کلاس والد یا سوپرکلاس است. این کلاس حاوی ویژگی‌ها و متدهایی است که توسط کلاس فرزند به ارث می‌رسد. در اینجا مثالی از یک کلاس والد برای درک بهتر وراثت در پایتون آمده است:

class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species

    def eat(self):
        print(f"{self.name} is eating.")

در این مثال یک کلاس والد به نام Animal تعریف کرده‌ایم که دارای دو ویژگی (name و species) و متدی به نام eat() است. هنگامی که کلاس والد تعریف شد، می‌توانیم یک کلاس فرزند ایجاد کنیم که از کلاس والد ارث می‌برد. برای این کار یک کلاس جدید تعریف می‌کنیم که بعد از نام کلاس فرزند، نام کلاس والد داخل پرانتز قرار می‌گیرد. در اینجا نمونه‌ای از کلاس فرزند آورده شده است که از کلاس والد Animal ارث می‌برد:

class Cat(Animal):
    def meow(self):
        print(f"{self.name} says meow.")

کلاس Cat یک متد اضافی به نام meow() دارد که میو گربه را چاپ می‌کند. اکنون که هر دو کلاس والد و فرزند را تعریف کرده‌ایم، می‌توانیم یک شی از کلاس فرزند ایجاد کنیم و ببینیم که چگونه ویژگی‌ها و متدها را از کلاس والد به ارث می‌برد. به این مثال توجه کنید:

cat = Cat("Fluffy", "Domestic Shorthair")
print(cat.name)
cat.eat()
cat.meow()

در این مثال، یک شی از کلاس Cat به نام cat با نام “Fluffy” و گونه‌ی “Domestic Shorthair” ساخته‌ایم. سپس ویژگی نام شی cat را می‌نامیم که “Fluffy” را برمی‌گرداند. همچنین متد eat() و متد meow() را روی شی cat فراخوانی می‌کنیم.

خروجی کدِ ما این خواهد بود:

Fluffy
Fluffy is eating.
Fluffy says meow.

همانطور که می‌بینید، شی Cat ویژگی‌های name و species را از کلاس والد Animal به ارث برده است و همچنین متد ()meow خود را دارد. متد eat() از کلاس Animal با استفاده از شی cat فراخوانی شد که به گربه اجازه می‌داد غذا بخورد.

یکی از مزایای وراثت در پایتون، امکان نادیده گرفتن متدها از کلاس والد در کلاس فرزند است. این بدان معنی است که کلاس فرزند می‌تواند رفتار یک متد به ارث رسیده از کلاس والد را تغییر دهد یا جایگزین کند. برای درک بهتر این ویژگیِ وراثت در پایتون، به مثال زیر دقت کنید:

class Dog(Animal):
    def bark(self):
        print(f"{self.name} says woof.")

    def eat(self):
        print(f"{self.name} is eating dog food.")

در این مثال یک کلاس فرزند به نام Dog تعریف کرده‌ایم که از کلاس والد Animal نیز ارث می‌برد. کلاس Dog متد bark() خود را دارد که در واقع واق‌واقِ سگ را چاپ می‌کند. همچنین با افزودن عبارت “dog food”  به خروجی، متد eat() را از کلاس والد لغو می‌کند. هنگامی که یک شی از کلاس Dog ایجاد می‌کنیم و متد ()eat را فراخوانی می‌کنیم، خروجی عبارت اضافه شده را شامل می‌شود:

dog = Dog("Buddy", "Golden Retriever")
dog.eat()

خروجی کد بالا این خواهد بود:

Buddy is eating dog food.

همانطور که می‌بینید، کلاس Dog با تغییر رفتار خود، متد ()eat را از کلاس والد Animal لغو کرده است.

ارث‌بری چندگانه در پایتون

وراثت در پایتون تنها به این خلاصه نمی‌شود. پایتون همچنین امکان ارث بردن چندگانه دارد، به این معنی که یک کلاس فرزند می‌تواند از چندین کلاس والد ارث‌بری کند. در این موارد می‌توانید از ویژگی ارث‌بری چندگانه‌ی وراثت در پایتون استفاده کنید. برای درک بهتر به مثال زیر توجه کنید:

class DomesticatedAnimal(Animal):
    def groom(self):
        print(f"{self.name} is being groomed.")

class DomesticCat(Cat, DomesticatedAnimal):
    pass

در این مثال، ما یک کلاس والد جدید به نام DomesticatedAnimal تعریف کرده‌ایم که متد مخصوص به خود به نام ()groom را دارد. ما همچنین یک کلاس فرزند جدید به نام DomesticCat تعریف کرده‌ایم که از هر دو کلاس والد Cat و DomesticatedAnimal ارث می‌برد.

کلاس DomesticCat هیچ متد یا ویژگی دیگری ندارد، بنابراین می‌توانیم به سادگی از کلمه کلیدی pass برای نشان دادن خالی بودن کلاس استفاده کنیم.

اکنون، وقتی یک شی از کلاس DomesticCat ایجاد می‌کنیم و متدهای ارثی آن را فراخوانی می‌کنیم، خروجی شامل متد meow() از کلاس والد Cat و متد ()groom از کلاس والد DomesticatedAnimal خواهد بود:

domestic_cat = DomesticCat("Fluffy", "Domestic Shorthair")
domestic_cat.meow()
domestic_cat.groom()

خروجی کد فوق به این شکل است:

Fluffy says meow.
Fluffy is being groomed.

همانطور که در بالا می‌بینید، شی DomesticCat متد meow() را از کلاس والد Cat و متد ()groom را از کلاس والد DomesticatedAnimal به ارث برده است.

Composition در پایتون

Composition یا ترکیب پایتون مفهومی در برنامه‌نویسی شی‌گرا است که به شما امکان می‌دهد با ترکیب اشیاء ساده‌تر، اشیاء پیچیده ایجاد کنید. در ترکیب‌بندی، یک کلاس شامل نمونه‌ای از کلاس دیگر به عنوان متغیر عضو است و از متدهای آن شی برای دستیابی به عملکرد خود استفاده می‌کند. Composition اغلب به عنوان جایگزینی برای وراثت در پایتون استفاده می‌شود، زیرا امکان انعطاف‌پذیری بیشتر و کد پویاتر را فراهم می‌کند. با Composition در پایتون، می‌توانید اشیایی ایجاد کنید که از اشیاء دیگر تشکیل شده‌اند و با تعویض اجزای مختلف، رفتار برنامه خود را تغییر دهید. کاری که با وراثت در پایتون قابل انجام نیست.

برای درک نحوه عملکرد ترکیب در پایتون، اجازه دهید یک مثال بزنیم:

class Engine:
    def start(self):
        print("Engine started.")

    def stop(self):
        print("Engine stopped.")


class Car:
    def __init__(self):
        self.engine = Engine()

    def drive(self):
        self.engine.start()
        print("Car is driving.")

    def stop(self):
        self.engine.stop()
        print("Car has stopped.")

در این مثال دو کلاس موتور و خودرو داریم. کلاس Engine دارای دو متد start() و stop() است که با روشن یا خاموش شدن موتور پیام‌ها را چاپ می‌کند.

کلاس Car دارای یک متغیر به نام engine است که نمونه‌ای از کلاس Engine است. هنگامی که یک شی جدید Car ایجاد می‌کنیم، متد __init__() فراخوانی می‌شود که یک نمونه جدید از کلاس Engine ایجاد می‌کند و آن را به متغیر engine اختصاص می‌دهد.

کلاس Car نیز دو متد drive() و stop() دارد. متد drive() متد start() شی Engine را فراخوانی می‌کند و سپس پیامی مبنی بر رانندگی ماشین چاپ می‌کند. متد stop() متد stop() شی Engine را فراخوانی می‌کند و سپس پیامی مبنی بر توقف خودرو چاپ می‌کند.

استفاده از ترکیب در این روش به ما اجازه می‌دهد تا اشیاء پیچیده‌تری را از اجزای ساده‌تر ایجاد کنیم. با استفاده از آبجکت Engine به عنوان متغیر عضو شی Car، می‌توانیم در صورت نیاز مجدداً از کلاس Engine در اشیاء دیگر استفاده کنیم و به راحتی می‌توانیم با تغییر شی Engine، رفتار آبجکت Car را تغییر دهیم.

Super در پایتون

super() یک تابع داخلی در پایتون است که به شما امکان می‌دهد متدی را از یک کلاس والد در یک زیرکلاس فراخوانی کنید. از این امکان زمانی استفاده می‌شود که می‌خواهید عملکرد یک متد تعریف‌شده در کلاس والد را بدون لغو کامل آن گسترش دهید.

در برنامه نویسیِ شی‌گرا، وقتی یک زیرکلاس از یک کلاس والد مشتق می‌شود، تمام ویژگی‌ها و متدهای کلاس والد را به ارث می‌برد. اگر یک متد در کلاس والد نیاز به بازنویسی در زیر کلاس داشته باشد، زیرکلاس می‌تواند به سادگی متدی را با همان نام تعریف کند. با این حال، گاهی اوقات ممکن است بخواهید عملکرد روش والد را بدون تعویض کامل آن گسترش دهید. اینجاست که super() وارد می‌شود.

super() به شما امکان می‌دهد متد والد را در زیرکلاس فراخوانی کنید و سپس عملکردهای دیگری را به آن اضافه کنید. تابع super() دو آرگومان می‌گیرد: اولی زیرکلاسی است که متد والد را فراخوانی می‌کند و دومی نمونه زیرکلاس است. به کد زیر توجه کنید:

class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        print("Animal sound")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    
    def make_sound(self):
        super().make_sound()
        print("Bark")

در این مثال یک کلاس والد به نام Animal داریم که متدی به نام make_sound() دارد. ما همچنین یک زیرکلاس به نام Dog داریم که از Animal ارث می‌برد. کلاس Dog متد ()make_sound مخصوص به خود را دارد که متد make_sound() کلاس Animal را با استفاده از super() فرا می‌خواند و سپس صدای “Bark” را به آن اضافه می‌کند.

وقتی یک شی Dog ایجاد می‌کنیم و متد make_sound() آن را فراخوانی می‌کنیم، متد make_sound() از کلاس Animal را با استفاده از super() فراخوانی می‌کند که “Animal sound”را چاپ می‌کند و سپس “Bark” را چاپ می‌کند.

my_dog = Dog("Fido", "Labrador")
my_dog.make_sound() # Output: Animal sound\nBark

استفاده از super() می‌تواند به شما کمک کند از تکرار کد در زیرکلاسِ خود جلوگیری کنید و تغییر رفتار متدهای کلاس والد را آسان‌تر می‌کند. همچنین به شما امکان می‌دهد متدهای کلاس والد را که ممکن است از زیرکلاس به آنها دسترسی نداشته باشید، فراخوانی کنید.

Override در پایتون

در پایتون، Override یا جایگزینی متد مفهومی در برنامه نویسیِ شی‌گرا است که در آن یک زیرکلاس می‌تواند پیاده‌سازیِ خود را از روشی که قبلاً در کلاس والدِ آن تعریف شده است، ارائه دهد. هنگامی که یک زیرکلاس متدی را با همان نام متد در کلاس والد تعریف می‌کند، متد زیرکلاس متد والد را لغو می‌کند. به این معنی که وقتی متد بر روی نمونه‌ای از کلاس فرعی فراخوانی می‌شود، متد زیرکلاس به جای متد والد اجرا می‌شود.

در اینجا یک مثال از روش overriding در پایتون آورده شده است:

class Animal:
    def make_sound(self):
        print("Animal sound")

class Dog(Animal):
    def make_sound(self):
        print("Bark")

my_dog = Dog()
my_dog.make_sound() # Output: Bark

در این مثال، ما یک کلاس والد به نام Animal با متدی به نام make_sound() داریم که”Animal sound” را چاپ می‌کند. ما همچنین یک زیرکلاس به نام Dog داریم که از Animal ارث می‌برد و متدmake_sound()  را با پیاده‌سازی خودش لغو می‌کند که “Bark” را چاپ می‌کند. هنگامی که یک شی Dog  ایجاد می‌کنیم و متد make_sound() را فراخوانی می‌کنیم، متد make_sound() از کلاسDog  را اجرا می‌کند که “Bark” را چاپ می‌کند.

سخن پایانی

همانطور که دیدید، وراثت در پایتون یک مفهوم اساسی است که به شما اجازه می‌دهد کلاس‌ها را به صورت هرمی سازماندهی کنید. با استفاده از وراثت در پایتون، یک کلاس می‌تواند تمام ویژگی‌ها و رفتارهای یک کلاس والد را به ارث ببرد. وراثت در پایتون بسیار قدرتمند است و به شما این امکان را می‌دهد تا کدهای تکراری را کاهش و شفافیت آن را افزایش دهید. وراثت در پایتون همچنین برنامه‌های شما را کارآمدتر خواهد کرد. با تعریف کلاس‌های والد و ایجاد کلاس‌های فرزند که از آن‌ها ارث می‌برند، می‌توانید رفتار برنامه‌های خود را سفارشی کنید و در صورت نیاز قابلیت‌های جدیدی اضافه کنید.

منابع:

w3schools.com

javatpoint.com

 

چه امتیازی به این مقاله میدهید

جالب نبود

متوسط

خوب

خیلی خوب

خیلی عالیه

مدیر سایت

نویسنده

مدیر سایت

دیدگاه ها
0 دیدگاه