القائمة الرئيسية

الصفحات

دورة البرمجة بلغة بايثون - الدرس الرابع والثلاثون (البرمجة الشيئية OOP)

دورة البرمجة بلغة بايثون - الدرس الرابع والثلاثون (البرمجة الشيئية OOP)


دورة البرمجة بلغة بايثون - الدرس الرابع والثلاثون (البرمجة الشيئية OOP)

بايثون هي لغة برمجة متعددة النماذج. تدعم مناهج البرمجة المختلفة.


أحد الأساليب الشائعة لحل مشكلة البرمجة هو إنشاء كائنات. يُعرف هذا باسم البرمجة الشيئية (OOP).


الكائن له خاصيتان:

  • السمات
  • السلوك

لنأخذ مثالا:

يمكن أن يكون الببغاء كائنًا ، حيث يمتلك الخصائص التالية:

  • الاسم والعمر واللون كسمات
  • الغناء والرقص كسلوك

يركز مفهوم OOP في بايثون على إنشاء كود قابل لإعادة الاستخدام. يُعرف هذا المفهوم أيضًا باسم DRY  (Don't Repeat Yourself). اي (لا تكرر نفسك).


في بايثون ، يتبع مفهوم OOP بعض المبادئ الأساسية:


الكلاس

الكلاس عبارة عن مخطط للكائن.


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


يمكن أن يكون مثال فئة الببغاء:

class Parrot:
    pass

هنا ، نستخدم الكلمة الأساسية للفصل لتعريف فئة فارغة Parrot. من الكلاس، نبني الأمثلة. المثيل هو كائن محدد تم إنشاؤه من فئة معينة.


الكائن

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


يمكن أن يكون مثال كائن فئة الببغاء:

obj = Parrot()

هنا ، obj هو كائن من فئة Parrot.


افترض أن لدينا تفاصيل عن الببغاوات. الآن ، سوف نوضح كيفية بناء فئة وأشياء من الببغاوات.


مثال 1: إنشاء فئة وكائن في بايثون

class Parrot:

    # class attribute
    species = "bird"

    # instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age

# instantiate the Parrot class
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)

# access the class attributes
print("Blu is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))

# access the instance attributes
print("{} is {} years old".format( blu.name, blu.age))
print("{} is {} years old".format( woo.name, woo.age))

الناتج

Blu is a bird
Woo is also a bird
Blu is 10 years old
Woo is 15 years old


في البرنامج أعلاه ، أنشأنا كلاساً باسم Parrot. ثم نحدد السمات. السمات هي سمة مميزة للكائن.


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


بعد ذلك ، نقوم بإنشاء حالات من فئة Parrot. هنا ، blu و woo مراجع (قيمة) لكائناتنا الجديدة.


يمكننا الوصول إلى سمة class باستخدام أنواع __class __. سمات الفئة هي نفسها لجميع مثيلات الكلاس. وبالمثل ، فإننا نصل إلى سمات المثيل باستخدام blu.name و blu.age. ومع ذلك ، تختلف سمات المثال لكل مثيل للفئة.


لمعرفة المزيد حول الفئات والكائنات ، انتقل إلى Python Classes and Objects


الطرق

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


مثال 2: إنشاء الطرق في بايثون

class Parrot:
    
    # instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # instance method
    def sing(self, song):
        return "{} sings {}".format(self.name, song)

    def dance(self):
        return "{} is now dancing".format(self.name)

# instantiate the object
blu = Parrot("Blu", 10)

# call our instance methods
print(blu.sing("'Happy'"))
print(blu.dance())


الناتج

Blu sings 'Happy'
Blu is now dancing


في البرنامج أعلاه ، نحدد دالتين وهما sing و dance. هذه تسمى دوال المثيل لأنه يتم استدعاؤها على كائن مثيل ، مثل blu.


التوريث

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


مثال 3: استخدام الوراثة في بايثون

# parent class
class Bird:
    
    def __init__(self):
        print("Bird is ready")

    def whoisThis(self):
        print("Bird")

    def swim(self):
        print("Swim faster")

# child class
class Penguin(Bird):

    def __init__(self):
        # call super() function
        super().__init__()
        print("Penguin is ready")

    def whoisThis(self):
        print("Penguin")

    def run(self):
        print("Run faster")

peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()


الناتج

Bird is ready
Penguin is ready
Penguin
Swim faster
Run faster


في البرنامج أعلاه ، أنشأنا فئتين ، أي Bird (فئة الوالدين) و Penguin (فئة الأطفال). يرث الفصل الفرعي وظائف فئة الأصل. يمكننا أن نرى هذا من الدالة swim.


مرة أخرى ، قام الكلاس بتعديل سلوك الكلاس الرئيسي. يمكننا رؤية هذا من خلال طريقة whoisThis. علاوة على ذلك ، نقوم بتوسيع وظائف الفئة الأصلية ، من خلال إنشاء دالة run جديدة.


بالإضافة إلى ذلك ، نستخدم الدالة super داخل دالة __init __ . هذا يسمح لنا بتشغيل دالة __init __  للفئة الأصل داخل الفصل الفرعي.


التغليف

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


مثال 4: تغليف البيانات في بايثون

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


في البرنامج أعلاه ، حددنا كلاس الكمبيوتر.


استخدمنا دالة __init __  لتخزين الحد الأقصى لسعر بيع الكمبيوتر. حاولنا تعديل السعر. ومع ذلك ، لا يمكننا تغييره لأن بايثون تتعامل مع السعر__maxprice كسمات خاصة.


كما هو موضح ، لتغيير القيمة ، يتعين علينا استخدام دالة setter ، مثل setMaxPrice التي تأخذ السعر كمعامل.


تعدد الأشكال

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


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


مثال 5: استخدام تعدد الأشكال في بايثون

class Parrot:

    def fly(self):
        print("Parrot can fly")
    
    def swim(self):
        print("Parrot can't swim")

class Penguin:

    def fly(self):
        print("Penguin can't fly")
    
    def swim(self):
        print("Penguin can swim")

# common interface
def flying_test(bird):
    bird.fly()

#instantiate objects
blu = Parrot()
peggy = Penguin()

# passing the object
flying_test(blu)
flying_test(peggy)


الناتج

Parrot can fly
Penguin can't fly


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


لاستخدام تعدد الأشكال ، أنشأنا واجهة مشتركة ، مثل دالة fly_test التي تأخذ أي كائن وتستدعي دالة الكائن fly. وهكذا ، عندما مررنا كائني blu و peggy في دالة fly_test ، كان يعمل بفعالية.


نقاط أساسية يجب تذكرها:

  • البرمجة الشيئية تجعل البرنامج سهل الفهم وكذلك فعال.
  • نظرًا لأن الفصل الدراسي قابل للمشاركة ، يمكن إعادة استخدام الكود.
  • البيانات آمنة ومأمونة مع استخراج البيانات.
  • يسمح تعدد الأشكال بالواجهة نفسها لكائنات مختلفة ، لذلك يمكن للمبرمجين كتابة كود فعال.


reaction:
Ahmed Taher
Ahmed Taher
مدون من العراق . احب البرمجة وكل ما يتعلق بالشبكات والسيرفرات وامن المعلومات . واسعى الى توفير جميع المصادر والمواد للامتحانات الدولية.

تعليقات