برنامه نویسی شی گرا در پایتون چیست؟ — 6 مزایای استفاده از OOP

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

معرفی زبان برنامه نویسی پایتون

پایتون «Python» یک زبان برنامه نویسی سطح بالا، عمومی‌منظوره، شیءگرا و تفسیرشده است. از ویژگی‌های کلیدی آن می‌توان به خوانایی بالا، سینتکس ساده و روان، و کتابخانه‌های گسترده اشاره کرد. این زبان به دلیل سادگی یادگیری و استفاده، محبوبیت زیادی در بین توسعه‌دهندگان و محققان پیدا کرده است و در طیف وسیعی از کاربردها، از توسعه وب تا هوش مصنوعی و علوم داده، به کار گرفته می‌شود.

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

برنامه نویسی شی گرا در پایتون چیست؟

برنامه نویسی شی گرا در پایتون (Object-Oriented Programming in Python) یک روش «پارادایم» برنامه نویسی است که به شما کمک می‌کند برنامه‌هایتان را طوری سازماندهی کنید که ویژگی‌ها و رفتارهای مرتبط با هم، در قالب «اشیاء» جداگانه گروه‌بندی شوند. به عنوان مثال، یک شیء می‌تواند نمایانگر یک شخص باشد که دارای ویژگی‌هایی مانند نام، سن و آدرس است و رفتارهایی مانند راه رفتن، صحبت کردن، نفس کشیدن و دویدن دارد. یا اینکه می‌تواند نمایانگر یک ایمیل باشد که ویژگی‌هایی مانند لیست گیرندگان، موضوع و بدنه دارد و رفتارهایی مانند افزودن فایل ضمیمه و ارسال کردن.

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

OOP در زبان‌های برنامه نویسی دیگری هم وجود دارد و اغلب گفته می‌شود که حول چهار ستون اصلی بنا شده است:

• کپسوله‌سازی (Encapsulation):  کپسوله‌سازی به شما امکان می‌دهد داده‌ها «ویژگی‌ها» و رفتارها «متدها» را در داخل یک کلاس دسته‌بندی کنید تا یک واحد منسجم ایجاد شود. با تعریف متدهایی برای کنترل دسترسی و تغییر ویژگی‌ها، کپسوله‌سازی به حفظ یکپارچگی داده‌ها و ایجاد کد ماژولار و امن کمک می‌کند.

• ارث بری (Inheritance): ایجاد روابط سلسله مراتبی بین کلاس‌ها را ممکن می‌سازد، به طوری که یک زیرکلاس می‌تواند ویژگی‌ها و متدهای یک کلاس والد را به ارث ببرد. این کار باعث استفاده مجدد از کد و کاهش تکرار می‌شود.

• انتراع (Abstraction): بر پنهان کردن جزئیات پیاده‌سازی و نمایش فقط عملکردهای ضروری یک شیء تمرکز دارد. با اعمال یک رابط کاربری یکنواخت، انتزاع تعامل با اشیاء را ساده می‌کند و به توسعه‌دهندگان اجازه می‌دهد تا بر روی کاری که یک شیء انجام می‌دهد تمرکز کنند، نه اینکه چگونه آن عملکرد را به دست می‌آورد.
• چندریختی (Polymorphism): چند ریختی به شما امکان می‌دهد با اشیاء از انواع مختلف، به عنوان نمونه‌هایی از یک نوع پایه یکسان رفتار کنید، به شرطی که یک رابط کاربری یا رفتار مشترک را پیاده‌سازی کنند. قابلیت «Duck Typing» پایتون آن را به طور ویژه‌ای برای چندریختی مناسب می‌سازد، زیرا به شما اجازه می‌دهد به ویژگی‌ها و متدهای اشیاء دسترسی داشته باشید بدون اینکه نگران کلاس واقعی آن‌ها باشید.

مزایای استفاده از OOP

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

1. قابلیت استفاده مجدد (Reusability)

• کلاس‌ها و شیء‌ها: کلاس‌ها به عنوان قالب برای ایجاد شیءها عمل می‌کنند. این امکان استفاده مجدد از کد را فراهم می‌کند. یک کلاس می‌تواند بارها و بارها برای ایجاد شیءهای مختلف با ویژگی‌های مشابه استفاده شود.
• وراثت: امکان ایجاد کلاس‌های جدید بر اساس کلاس‌های موجود و افزودن ویژگی‌های جدید یا تغییر ویژگی‌های موجود را می‌دهد. این به طور قابل توجهی از تکرار کد جلوگیری می‌کند.

2. سازماندهی و ساختاردهی کد

• مدولار بودن: کد به اجزاء کوچکتر و قابل مدیریت‌تر تقسیم می‌شود. این ساختار منظم، فهم و نگهداری کد را آسان‌تر می‌کند.
• کاهش پیچیدگی: با تجزیه مشکل به اجزای کوچکتر، پیچیدگی پروژه کاهش می‌یابد.
• افزایش قابلیت نگهداری: کد‌های سازمان‌دهی شده و مدولار، قابلیت نگهداری و اصلاح را افزایش می‌دهند.

3. افزایش قابلیت همکاری

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

4. انعطاف‌پذیری (Flexibility)

• تغییر و توسعه آسان: تغییر و افزودن ویژگی‌های جدید به کد، در برنامه نویسی شی گرا آسان‌تر است. تغییرات در یک بخش از کد، معمولاً تأثیری جزئی بر بخش‌های دیگر دارد.
• مناسب برای پروژه‌های بزرگ: OOP به ویژه برای پروژه‌های بزرگ و پیچیده بسیار مفید است.

5. کاهش خطا (Error Reduction)

• مدیریت داده‌ها: OOP با استفاده از متغیرها و متدها در داخل کلاس‌ها، داده‌ها را به طور ایمن‌تر مدیریت می‌کند و خطاهای مرتبط با داده‌ها را کاهش می‌دهد.
• محدود کردن دسترسی به داده‌ها: می‌توان دسترسی به داده‌ها را محدود کرد و از تغییرات ناخواسته جلوگیری نمود.

6. قابلیت توسعه (Extensibility)

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

چرا پایتون برای OOP مناسب است؟

پایتون به دلیل ویژگی‌های کلیدی خود، زبانی ایده‌آل برای برنامه نویسی شی گرا در پایتون (OOP) محسوب می‌شود. به دلایل زیر:

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

• مکانیزم‌های مدیریت حافظه خودکار (Garbage Collection): پایتون به طور خودکار حافظه را مدیریت می‌کند. این باعث کاهش خطاهای حافظه و افزایش کارایی در برنامه نویسی شی گرا می‌شود. توسعه‌دهندگان نیازی به نگرانی در مورد اختصاص و آزادسازی حافظه ندارند، که می‌تواند تمرکز را بر منطق برنامه نویسی شی گرا قرار دهد.
• کتابخانه‌های قدرتمند: پایتون با داشتن کتابخانه‌های قدرتمند و گسترده، امکان استفاده از ویژگی‌های شی گرا را برای حل مسائل مختلف در زمینه‌های گوناگون مانند تجزیه و تحلیل داده‌ها، یادگیری ماشین، و توسعه وب فراهم می‌کند. این کتابخانه‌ها به طور معمول با استفاده از اصول شی گرایی طراحی شده‌اند و استفاده از آن‌ها به عنوان الگو در پروژه‌های شخصی نیز مفید است.
• نوع‌دهی پویا: نوع‌دهی پویا در پایتون به توسعه‌دهندگان اجازه می‌دهد تا کد را به سرعت و با انعطاف‌پذیری بیشتری بنویسند، بدون نگرانی در مورد نوع متغیرها در مراحل اولیه توسعه. این امر، به ویژه در طراحی اولیه کلاس‌ها و شیءها، می‌تواند مفید باشد.
• رابط‌های دوستانه و قابل فهم: این ویژگی، همراه با سینتکس خوانا، یادگیری پایتون را برای توسعه‌دهندگان جدیدتر آسان‌تر می‌کند و باعث می‌شود که کدهای شی گرا در پایتون به طور کلی قابل فهم‌تر و نگهداری راحت‌تری داشته باشند.

چگونه یک کلاس در پایتون تعریف می‌کنید؟

با برنامه نویسی شی گرا در پایتون، شما یک کلاس را با استفاده از کلمه کلیدی class و به دنبال آن یک نام و یک علامت دونقطه (:) تعریف می‌کنید. سپس از متد ()__init__. برای اعلام اینکه هر نمونه از کلاس باید چه ویژگی‌هایی داشته باشد، استفاده می‌کنید:

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

اما معنی همه این‌ها چیست؟ و اصلا چرا به کلاس‌ها نیاز دارید؟ بیایید یک قدم به عقب برگردیم و استفاده از ساختارهای داده‌ی اولیه و از پیش تعریف‌شده (built-in) را به عنوان یک جایگزین در نظر بگیریم.

ساختارهای داده‌ی اولیه—مانند اعداد، رشته‌ها و لیست‌ها—برای نمایش قطعات اطلاعاتی ساده طراحی شده‌اند، مانند قیمت یک سیب، نام یک شعر، یا رنگ‌های مورد علاقه‌ی شما. اما اگر بخواهید چیزی پیچیده‌تر را نمایش دهید چه؟

به عنوان مثال، ممکن است بخواهید اطلاعات کارمندان یک سازمان را ردیابی کنید. شما باید اطلاعات اولیه‌ی هر کارمند را مانند نام، سن، سمت و سال شروع به کار آن‌ها ذخیره کنید.

یک راه برای انجام این کار، نمایش هر کارمند به صورت یک لیست است:

kirk = ["James Kirk", 34, "Captain", 2265]
spock = ["Spock", 35, "Science Officer", 2254]
mccoy = ["Leonard McCoy", "Chief Medical Officer", 2266]

این رویکرد مشکلاتی هم دارد.

اول اینکه، می‌تواند مدیریت فایل‌های کد بزرگ‌تر را دشوارتر کند. اگر شما در چند خط پایین‌تر از جایی که لیست kirk را تعریف کرده‌اید به kirk[0] اشاره کنید، آیا به خاطر خواهید داشت که عنصری با اندیس 0 نام کارمند است؟

دوم اینکه، اگر کارمندان تعداد عناصر یکسانی در لیست‌های خود نداشته باشند، ممکن است خطا ایجاد شود. در لیست mccoy که در بالا مشاهده می‌کنید، سن وارد نشده است، بنابراین mccoy[1] به جای سن دکتر مک‌کوی، “Chief Medical Officer” را برمی‌گرداند. یک راه عالی برای مدیریت‌پذیرتر و قابل نگهداری‌تر کردن این نوع کدها، استفاده از کلاس‌ها است.

تعریف کلاس

شما تمام تعاریف کلاس را با کلمه کلیدی class شروع می‌کنید، سپس نام کلاس و یک علامت دونقطه (:) را اضافه می‌کنید. پایتون هر کدی را که در زیر تعریف کلاس با تورفتگی (indent) قرار دهید، بخشی از بدنه کلاس در نظر می‌گیرد.

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

class Dog:
    pass

بدنه کلاس Dog از یک دستور واحد تشکیل شده است: کلمه کلیدی pass. برنامه‌نویسان پایتون اغلب از pass به عنوان یک مکان نگهدار (placeholder) استفاده می‌کنند که نشان می‌دهد کد در نهایت در آنجا قرار خواهد گرفت. این به شما امکان می‌دهد این کد را بدون اینکه پایتون خطایی ایجاد کند، اجرا کنید.

کلاس و شیء در پایتون

class Parrot:

    # class attribute
    name = ""
    age = 0

# create parrot1 object
parrot1 = Parrot()
parrot1.name = "Blu"
parrot1.age = 10

# create another object parrot2
parrot2 = Parrot()
parrot2.name = "Woo"
parrot2.age = 15

# access attributes
print(f"{parrot1.name} is {parrot1.age} years old")
print(f"{parrot2.name} is {parrot2.age} years old")

خروجی:

Blu is 10 years old
Woo is 15 years old

در مثال بالا، ما کلاسی با نام Parrot با دو ویژگی: name (نام) و age (سن) ایجاد کردیم. سپس، نمونه‌هایی از کلاس Parrot ایجاد کردیم. در اینجا، parrot1 و parrot2 ارجاع‌ها (یا مقادیری) به اشیاء جدید ما هستند. بعد از آن، با استفاده از نام اشیاء و علامت . (نقطه)، به ویژگی‌های نمونه دسترسی پیدا کردیم و مقادیر مختلفی را به آن‌ها اختصاص دادیم.

وراثت در پایتون

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

مثال1: استفاده از وراثت در پایتون

# base class
class Animal:
    
    def eat(self):
        print( "I can eat!")
    
    def sleep(self):
        print("I can sleep!")

# derived class
class Dog(Animal):
    
    def bark(self):
        print("I can bark! Woof woof!!")

# Create object of the Dog class
dog1 = Dog()

# Calling members of the base class
dog1.eat()
dog1.sleep()

# Calling member of the derived class
dog1.bark();

خروجی:

I can eat!
I can sleep!
I can bark! Woof woof!!

در اینجا، dog1 می‌تواند به اعضای کلاس پایه حیوان دسترسی داشته باشد. این به این دلیل است که کلاس سگ از کلاس حیوان به ارث رسیده است.

کپسوله سازی در پایتون

کپسوله سازی یکی از ویژگی‌های کلیدی برنامه نویسی شی گرا است. کپسوله سازی به بسته‌بندی ویژگی‌ها و روش‌ها (متدها) درون یک کلاس واحد اشاره دارد. این کار از دسترسی و تغییر ویژگی‌ها و روش‌های یک کلاس توسط کلاس‌های بیرونی جلوگیری می‌کند. این موضوع همچنین به پنهان‌سازی داده‌ها کمک می‌کند.

در پایتون، ما از خط زیر برای نشان دادن ویژگی‌های خصوصی استفاده می‌کنیم: یک خط زیر (_) یا دو خط زیر (__) به عنوان پیشوند. برای مثال:

class Computer:

    def __init__(self):
        self.__maxprice = 900

    def sell(self):
        print("Selling Price: {}".format(self.__maxprice))

    def setMaxPrice(self, price):
        self.__maxprice = price

c = Computer()
c.sell()

# change the price
c.__maxprice = 1000
c.sell()

# using setter function
c.setMaxPrice(1000)
c.sell()

خروجی:

Selling Price: 900
Selling Price: 900
Selling Price: 1000

پنهان‌سازی داده در پایتون

پنهان‌سازی داده (Encapsulation) برنامه نویسی شی گرا در پایتون، روشی برای سازماندهی و مدیریت داده‌هاست که در آن جزئیات داخلی یک کلاس از دسترسی مستقیم کاربران خارج می‌شود. این کار باعث افزایش قابلیت نگهداری، امنیت و قابلیت استفاده مجدد کد می‌شود.

اهمیت پنهان‌سازی داده

• حفاظت از داده‌ها: جلوگیری از دستکاری مستقیم متغیرهای داخلی کلاس توسط کدهای خارجی. این امر از بروز خطاهای غیرمنتظره جلوگیری می‌کند و داده‌ها را ایمن‌تر نگه می‌دارد.
• قابلیت نگهداری: تغییر در پیاده‌سازی داخلی کلاس، بدون نیاز به تغییر کدهای استفاده‌کننده از آن، امکان‌پذیر می‌شود.
• مدیریت پیچیدگی: ساختار برنامه را ساده‌تر و قابل فهم‌تر می‌کند.
• تغییر و توسعه آسان: اجازه می‌دهد تا در آینده، ساختار داخلی کلاس بدون بروز خطا در سایر قسمت‌های برنامه تغییر کند.
• افزایش انعطاف‌پذیری: امکان اعمال محدودیت‌ها و قوانین خاص بر دسترسی به داده‌ها.

استفاده از متغیرهای خصوصی در پایتون:

پایتون از روشی غیر از متغیرهای خصوصی در زبان‌های دیگر مانند ++C یا Java استفاده می‌کند. در پایتون، برای اشاره به متغیرهای خصوصی، از یک _ (underscore) در ابتدای نام متغیر استفاده می‌شود. این عمل برای پایتون یک قرارداد است و به معنای واقعی خصوصی نیست.

class MyClass:
    def __init__(self, value):
        self._internal_value = value  # متغیر خصوصی (به طور قراردادی)

    def get_value(self):
        return self._internal_value

    def set_value(self, new_value):
        self._internal_value = new_value

در این مثال، _internal_value به عنوان متغیر خصوصی در نظر گرفته شده است. این متغیر از طریق get_value و set_value قابل دسترسی است. این روش به شما کنترل بیشتری می‌دهد و از دستکاری مستقیم _internal_value توسط کدهای خارجی جلوگیری می‌کند.

مثال‌های عملی از پیاده‌سازی پنهان‌سازی داده:

class BankAccount:
    def __init__(self, initial_balance):
        self._balance = initial_balance  # متغیر خصوصی

    def deposit(self, amount):
        if amount > 0:
            self._balance += amount

    def withdraw(self, amount):
        if amount > 0 and amount <= self._balance:
            self._balance -= amount
        else:
            print("مبلغ نامعتبر یا موجودی کافی نیست.")

    def get_balance(self):
        return self._balance

# استفاده از کلاس
account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # خروجی: 1500
account.withdraw(200)
print(account.get_balance())  # خروجی: 1300
account.withdraw(1500) # خروجی: مبلغ نامعتبر یا موجودی کافی نیست.

در این مثال، _balance یک متغیر خصوصی است. دسترسی مستقیم به آن از خارج از کلاس غیرممکن است. استفاده از روش‌های deposit و withdraw برای تغییر _balance کنترل بیشتری را به ما می‌دهد و از خطاهای احتمالی جلوگیری می‌کند.

روش‌های خاص (Special Methods) در پایتون

روش‌های خاص (Special Methods) در برنامه نویسی شی گرا در پایتون، روش‌هایی هستند که با دو علامت زیردان (دابل اندرلاین) در هر دو طرف نامشان نوشته می‌شوند. این روش‌ها برای تعامل با رفتار داخلی اشیا در پایتون، مانند نحوه نمایش، مقایسه و تبدیل آن‌ها به کار می‌روند.

1. __init__ (ایجاد کننده)

• کاربرد: این روش برای مقداردهی اولیه اشیا استفاده می‌شود. زمانی که شما یک شیء از یک کلاس جدید ایجاد می‌کنید، __init__ به طور خودکار فراخوانی می‌شود.
• پارامترها: معمولاً شامل self (اشاره به خود شیء) و پارامترهای دیگر برای مقداردهی اولیه ویژگی‌های شیء است.

مثال:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

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

my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.name)  # خروجی: Buddy
print(my_dog.breed) # خروجی: Golden Retriever

در این مثال، __init__ نام و نژاد سگ را دریافت می‌کند و ویژگی‌های name و breed را برای شیء my_dog مقداردهی می‌کند.

2. __str__ (نمایش اشیا)

• کاربرد: این روش برای بازگرداندن یک رشته نمایشگر از یک شیء استفاده می‌شود. این روش زمانی فراخوانی می‌شود که از تابع ()str یا زمانی که یک شیء را به عنوان بخشی از یک جمله چاپ می‌کنید، استفاده می‌شود.
• پارامترها: معمولاً شامل self (اشاره به خود شیء) است.

مثال:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def __str__(self):
        return f"Dog named {self.name}, breed {self.breed}"

my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog)  # خروجی: Dog named Buddy, breed Golden Retriever

3. __repr__ (نمایش قابل ارزیابی)

• کاربرد: این روش برای بازگرداندن یک رشته نمایشگر از یک شیء استفاده می‌شود که به عنوان ورودی برای ایجاد مجدد شیء قابل استفاده است. این روش زمانی فراخوانی می‌شود که از تابع ()repr یا ()eval استفاده می‌کنید.
• پارامترها: معمولاً شامل self (اشاره به خود شیء) است.

مثال:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def __repr__(self):
        return f"Dog(name='{self.name}', breed='{self.breed}')"

my_dog = Dog("Buddy", "Golden Retriever")
print(repr(my_dog))  # خروجی: Dog(name='Buddy', breed='Golden Retriever')

__repr__ یک رشته بازگشتی قابل ارزیابی را برمی‌گرداند که با استفاده از آن می‌توانید شیء Dog را دوباره ایجاد کنید. این نکته مهم است که __repr__ باید قابل استفاده در ()eval باشد.

چند مثال ساده از برنامه نویسی شی گرا در پایتون

مثال 1: کلاس برای نمایش اطلاعات یک کتاب

class کتاب:
    def __init__(self, عنوان, نویسنده, سال_انتشار):
        self.عنوان = عنوان
        self.نویسنده = نویسنده
        self.سال_انتشار = سال_انتشار

    def نمایش_اطلاعات(self):
        print(f"عنوان: {self.عنوان}")
        print(f"نویسنده: {self.نویسنده}")
        print(f"سال انتشار: {self.سال_انتشار}")

# ایجاد یک شیء از کلاس کتاب
کتاب1 = کتاب("چگونه ثروتمند شویم", "ناپلئون هیل", 1937)
کتاب1.نمایش_اطلاعات()

مثال 2: کلاس برای محاسبه مساحت و محیط مستطیل

class مستطیل:
    def __init__(self, طول, عرض):
        self.طول = طول
        self.عرض = عرض

    def مساحت(self):
        return self.طول * self.عرض

    def محیط(self):
        return 2 * (self.طول + self.عرض)

# ایجاد یک شیء از کلاس مستطیل
مستطیل1 = مستطیل(5, 10)
print(f"مساحت: {مستطیل1.مساحت()}")
print(f"محیط: {مستطیل1.محیط()}")

سخن آخر

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