البرمجة كائنية التوجه (OOP) هي منهج رئيسي يستخدم في تطوير البرمجيات.

في هذه المقالة، سنستكشف الأفكار الرئيسية لـ OOP، لا سيما النظر إلى الفئات والكائنات والميراث وتعدد الأشكال في بايثون.

بنهاية هذا الدليل، ستفهم كيفية تنظيم تعليمات Python البرمجية باستخدام مبادئ OOP، مما يجعل برامجك أكثر نمطية وقابلة لإعادة الاستخدام وأسهل في الصيانة.

ما هي البرمجة الشيئية؟

تنظم البرمجة الشيئية (OOP) تصميم البرامج حول البيانات أو الكائنات، بدلاً من الوظائف والمنطق.

الكائن يشبه الحاوية ذات السمات الفريدة (البيانات) والسلوكيات (الوظائف). يركز OOP على عدة مفاهيم أساسية:

التغليف
وهذا يعني تجميع البيانات (السمات) والأساليب (الوظائف) التي تعمل على تلك البيانات في وحدة واحدة تسمى الفئة.

ويتضمن أيضًا تقييد الوصول إلى بعض مكونات الكائن، مما يجعله أكثر أمانًا.

التجريد
هذه هي فكرة إخفاء تفاصيل التنفيذ المعقدة وإظهار الميزات الأساسية للكائن فقط.

يقلل من التعقيد ويسمح للمبرمج بالتركيز على التفاعلات ذات المستوى الأعلى.

الميراث
هذه آلية لإنشاء فئة جديدة (فئة مشتقة) من فئة موجودة (الفئة الأساسية).

الفئة الجديدة ترث السمات والأساليب من الفئة الموجودة.

تعدد الأشكال
هذه هي القدرة على استخدام واجهة واحدة لتمثيل أنواع البيانات المختلفة.

يسمح بمعاملة الكائنات كمثيلات للفئة الأصلية الخاصة بها ويجعل من الممكن تعريف الأساليب في فئة فرعية لها نفس اسم الطريقة في الفئة الأصلية.

أساسيات OOP في بايثون: الفئات والكائنات

في قلب البرمجة الشيئية (OOP) في بايثون توجد الفئات والكائنات.

الفصول
الفصل يشبه مخططًا لإنشاء الكائنات.

يحدد مجموعة من الخصائص (السمات) والإجراءات (الأساليب) التي ستكون للكائنات.

في بايثون، يمكنك إنشاء فصل دراسي باستخدام الكلمة الأساسية class. إليك مثال:

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def start_engine(self):
        print(f"{self.make} {self.model}'s engine started.")

أشياء
الكائن هو مثيل لفئة.

بمجرد تحديد فئة، يمكنك إنشاء كائنات متعددة (مثيلات) منها.

يمكن أن يكون لكل كائن قيمه الفريدة للسمات المحددة في الفئة.

إليك كيفية إنشاء كائن واستخدامه:

my_car = Car("Toyota", "Corolla", 2020)
my_car.start_engine()  # Output: Toyota Corolla's engine started.

في هذا المثال، my_car هو كائن من فئة السيارة.

له قيمه الخاصة للطراز والطراز والسنة، ويمكنك استخدام طرق مثل start_engine.

الميراث في بايثون

يتيح الوراثة لفئة واحدة (الفئة الفرعية) الحصول على سمات وأساليب فئة أخرى (الفئة الأصلية).

يعد هذا أمرًا رائعًا لإعادة استخدام التعليمات البرمجية وإعداد تسلسل هرمي بين الفئات.

إليك مثال:

class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def drive(self):
        print("Driving...")


class Car(Vehicle):
    def __init__(self, make, model, year):
        super().__init__(make, model)
        self.year = year

    def start_engine(self):
        print(f"{self.make} {self.model}'s engine started.")


my_car = Car("Honda", "Civic", 2021)
my_car.drive()  # Output: Driving...
my_car.start_engine()  # Output: Honda Civic's engine started.

في هذا المثال، ترث فئة السيارة من فئة السيارة.

ولهذا السبب، يمكن لفئة السيارة استخدام طريقة القيادة المحددة في فئة السيارة.

طريقة التجاوز
في بعض الأحيان، يحتاج الفصل الفرعي إلى تغيير أو إضافة سلوك الطريقة التي ورثها من الفصل الأصلي.

يتم ذلك من خلال تجاوز الطريقة.

إليك مثال:

class Vehicle:
    def drive(self):
        print("Driving a vehicle...")


class Car(Vehicle):
    def drive(self):
        print("Driving a car...")


my_vehicle = Vehicle()
my_vehicle.drive()  # Output: Driving a vehicle...

my_car = Car()
my_car.drive()  # Output: Driving a car...

في هذا المثال، تتجاوز طريقة القيادة في فئة السيارة طريقة القيادة في فئة السيارة، مما يسمح بسلوك مخصص.

الميراث المتعدد
تدعم بايثون أيضًا الوراثة المتعددة، حيث يمكن أن يرث الفصل من أكثر من فئة أساسية.

إليك مثال:

class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def drive(self):
        print("Driving a vehicle...")


class Electric:
    def charge(self):
        print("Charging...")


class Car(Vehicle):
    def __init__(self, make, model, year):
        super().__init__(make, model)
        self.year = year

    def start_engine(self):
        print(f"{self.make} {self.model}'s engine started.")


class HybridCar(Car, Electric):
    def switch_mode(self):
        print("Switching to electric mode...")


my_hybrid = HybridCar("Toyota", "Prius", 2022)
my_hybrid.start_engine()  # Output: Toyota Prius's engine started.
my_hybrid.drive()  # Output: Driving a vehicle...
my_hybrid.charge()  # Output: Charging...
my_hybrid.switch_mode()  # Output: Switching to electric mode...

في هذا المثال، ترث فئة HybridCar من كل من Car وElectric، مما يسمح لها بالوصول إلى الأساليب من كلا الفئتين الأصليتين.

تعدد الأشكال في بايثون

تعدد الأشكال هو ميزة تسمح للطرق بتنفيذ إجراءات مختلفة بناءً على الكائن الذي تعمل معه، حتى لو كانت هذه الطرق لها نفس الاسم.

هذا مفيد بشكل خاص عند التعامل مع الميراث، لأنه يتيح لك استخدام نفس اسم الطريقة عبر فئات مختلفة بطريقة منطقية لكل فئة.

تعدد الأشكال مع الوظائف
إليك مثال:

class Dog:
    def speak(self):
        return "Woof!"


class Cat:
    def speak(self):
        return "Meow!"


def make_animal_speak(animal):
    print(animal.speak())


dog = Dog()
cat = Cat()

make_animal_speak(dog)  # Output: Woof!
make_animal_speak(cat)  # Output: Meow!

توضح وظيفة make_animal_speak تعدد الأشكال من خلال قبول أي كائن باستخدام طريقة التحدث.

يسمح له هذا بالعمل مع كل من كائنات Dog وCat، على الرغم من الاختلافات بينهما.

تعدد الأشكال مع الأساليب الطبقية
يلعب تعدد الأشكال أيضًا دورًا عند العمل مع الأساليب الموجودة في التسلسل الهرمي للفصل.

إليك مثال:

class Animal:
    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")


class Dog(Animal):
    def speak(self):
        return "Woof!"


class Cat(Animal):
    def speak(self):
        return "Meow!"


animals = [Dog(), Cat()]

for animal in animals:
    print(animal.speak())

في هذا المثال، يعد كل من Dog وCat فئات فرعية من Animal.

يتم تنفيذ طريقة التحدث في كلا الفئتين الفرعيتين، مما يسمح لتعدد الأشكال بأن يصبح ساري المفعول عند التكرار عبر قائمة الحيوانات.

التغليف وإخفاء البيانات

التغليف هو ممارسة دمج البيانات والأساليب التي تعمل على تلك البيانات في وحدة واحدة تسمى فئة.

ويتضمن أيضًا تقييد الوصول إلى أجزاء معينة من الكائن، وهو أمر بالغ الأهمية لحماية البيانات في البرمجة الشيئية (OOP).

السمات الخاصة والعامة
في Python، يمكنك الإشارة إلى أن السمة خاصة عن طريق بدء اسمها بشرطة سفلية.

على الرغم من أن هذا لا يمنع في الواقع الوصول من خارج الفصل، إلا أنه تقليد يشير إلى أنه لا ينبغي الوصول إلى السمة مباشرة.

إليك مثال:

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance  # Private attribute

    def deposit(self, amount):
        self._balance  = amount

    def withdraw(self, amount):
        if amount 



 في هذا المثال، تحتوي فئة الحساب على سمة خاصة _balance، والتي يتم التعامل معها من خلال طرق مثل الإيداع والسحب والحصول على_التوازن. 

لا يُنصح بالوصول المباشر إلى الرصيد من خارج الفصل.



  
  
  مفاهيم OOP المتقدمة


بالنسبة لأولئك الذين يرغبون في تعميق فهمهم للبرمجة الشيئية (OOP) في بايثون، إليك بعض المواضيع المتقدمة:

طرق الفصل

هذه هي الأساليب المرتبطة بالفئة نفسها، وليس بالمثيلات الفردية للفئة. 

يمكنهم تغيير حالة الفصل، مما يؤثر على كافة مثيلات الفصل.


class Car:
    total_cars = 0

    def __init__(self, make, model):
        self.make = make
        self.model = model
        Car.total_cars  = 1

    @classmethod
    def get_total_cars(cls):
        return cls.total_cars





الأساليب الثابتة

هذه هي الأساليب التي تنتمي إلى الفئة ولكنها لا تغير حالة الفئة أو مثيلاتها. 

يتم تعريفها باستخدام مصمم الديكور @staticmethod.


class MathOperations:
    @staticmethod
    def add(x, y):
        return x   y





مصممو العقارات

توفر أدوات تزيين الخصائص في بايثون طريقة لتعريف الحروف، والمحددات، والمحذفات لسمات الفئة بطريقة بايثونية أكثر.


class Employee:
    def __init__(self, name, salary):
        self._name = name
        self._salary = salary

    @property
    def salary(self):
        return self._salary

    @salary.setter
    def salary(self, value):
        if value 



في هذا المثال، يتم الوصول إلى سمة الراتب مثل السمة العادية ولكن تتم إدارتها بواسطة أساليب getter وsetter.



  
  
  خاتمة


 تعد البرمجة الشيئية (OOP) في Python طريقة قوية لتنظيم وإدارة التعليمات البرمجية الخاصة بك. 

 من خلال تعلم مبادئ OOP، مثل الفئات والكائنات والميراث وتعدد الأشكال والتغليف، يمكنك كتابة برامج بايثون جيدة التنظيم وقابلة لإعادة الاستخدام وسهلة الصيانة. 

سواء كنت تعمل على نصوص برمجية صغيرة أو تطبيقات كبيرة، فإن استخدام مبادئ OOP سيساعدك على إنشاء برامج أكثر كفاءة وقابلة للتطوير وقوة.