بايثون والأساليب المتقدمة ، وظائف dunder لتحسين البرمجة

بايثون هي لغة برمجة رائعة، وكما يتضح من GitHub جيثب:، هي أيضًا ثاني أكثر اللغات شيوعًا في عام 2022.

تتمثل المزايا الأكثر إثارة للاهتمام في Python في المجتمع الكبير من المبرمجين.

يبدو أن لغة Python لديها حزمة لأي حالة استخدام.

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

الطرق السحرية هي مجموعة من الطرق المسبقةdefinites في Python التي توفر ميزات نحوية خاصة. يتم التعرف عليها بسهولة من خلال الشرطتين في البداية والنهاية ، مثل __init__, __call__, __len__ … إلخ.

الطرق السحرية

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

في هذه المقالة ، سوف نركز على وظائف الغطس القوية. سوف نستكشف الغرض منها ونناقش استخدامها.

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

تذكر أن سحر Python لا يكمن فقط في بساطتها وتعدد استخداماتها ، ولكن أيضًا في ميزاتها القوية مثل وظائف Dunder.

__init__

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

بيتزا كلاس:
    def __init __ (ذاتي ، الحجم ، الطبقة):
        الحجم = الحجم
        self.toppings = الطبقة

# الآن لنقم بإنشاء بيتزا
my_pizza = بيتزا ("كبيرة" ، ["بيبروني" ، "فطر"])

print (my_pizza.size) # هذا سيطبع: كبير
print (my_pizza.toppings) # هذا سيطبع: ['pepperoni'، 'mushrooms']

في هذا المثال ، يتم إنشاء فئة تسمى بيتزا. قمنا بإعداد وظيفة __init__ الخاصة بنا لتضمين المعلمات التي سيتم تحديدها في وقت التهيئة ، وتعيينها كخصائص لعنصرنا المخصص.

هنا ، يتم استخدامه لتمثيل مثيل الفئة. لذلك عندما نكتب self.size = size ، فإننا نقول ، "مرحبًا ، كائن البيتزا هذا له حجم سمة size، وأريد أن يكون مهما كان الحجم الذي قدمته عندما أنشأت الكائن ".

__str__ و __إعداده__

__Str__

هذه هي طريقة بايثون السحرية التي تسمح لنا بذلك definish وصفًا لعنصرنا المخصص.

عند طباعة كائن أو تحويله إلى سلسلة باستخدام str()، بايثون تحقق مما إذا كان لديك defiلقد توصلت إلى طريقة __str__ لفئة هذا الكائن.

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

يمكننا توسيع مثال البيتزا ليشمل وظيفة __str__ على النحو التالي:

class Pizza: def __init __ (self، size، toppings): self.size = size self.toppings = toppings def __str __ (self): return f "A {self.size} pizza with {'،' .join (self.toppings) )} "my_pizza = بيتزا (" كبيرة "، [" بيبروني "،" فطر "]) طباعة (my_pizza) # هذا سيطبع: بيتزا كبيرة مع بيبروني ، فطر

__repr__

تعتبر الوظيفة __str__ طريقة غير رسمية لوصف خصائص الكائن. من ناحية أخرى ، يتم استخدام __repr__ لتقديم وصف أكثر رسمية وتفصيلا ولا لبس فيه للعنصر المخصص.

إذا اتصلت repr() على كائن أو فقط تكتب اسم الكائن في وحدة التحكم ، ستبحث Python عن طريقة __repr__.

Se __str__ لا definite ، سوف تستخدم Python __repr__ كنسخة احتياطية عند محاولة طباعة الكائن أو تحويله إلى سلسلة. لذلك غالبًا ما تكون فكرة جيدة defiإنهاء على الأقل __repr__، حتى لو لم تفعل defiيخرج __str__.

إليك كيف يمكننا ذلك defiينهي __repr__ لمثال البيتزا لدينا:

بيتزا كلاس:
    def __init __ (ذاتي ، الحجم ، الطبقة):
        الحجم = الحجم
        self.toppings = الطبقة

    def __repr __ (ذاتي):
        إرجاع f "بيتزا ('{self.size}'، {self.toppings})"

my_pizza = بيتزا ("كبيرة" ، ["بيبروني" ، "فطر"])
print (repr (my_pizza)) # هذه ستطبع: بيتزا ("كبيرة" ، ["بيبروني" ، "فطر"])

__repr__ يمنحك سلسلة يمكنك تشغيلها كأمر Python لإعادة إنشاء كائن pizza ، بينما __str__ يمنحك وصفًا أكثر إنسانية. آمل أن تساعدك على مضغ هذه الطرق بطريقة أفضل قليلاً!

__يضيف__

في بايثون ، نعلم جميعًا أنه من الممكن إضافة أرقام باستخدام عامل التشغيل +، كما 3 + 5.

ولكن ماذا لو أردنا إضافة مثيلات لبعض العناصر المخصصة؟

وظيفة الغطس __add__ يسمح لنا بفعل ذلك بالضبط. يعطينا القدرة على definish سلوك المشغل + على العناصر الشخصية لدينا.

من أجل الاتساق ، دعنا نفترض أننا نريد ذلك defiإنهاء سلوك + على مثال البيتزا لدينا. لنفترض أنه عندما نضيف اثنين أو أكثر من البيتزا معًا ، فسوف يتم دمج جميع طبقاتها تلقائيًا. إليك ما قد يبدو عليه الأمر:

بيتزا كلاس:
    def __init __ (ذاتي ، الحجم ، الطبقة):
        الحجم = الحجم
        self.toppings = الطبقة

    def __add __ (النفس ، أخرى):
        إذا لم يكن الأمر كذلك (أخرى ، بيتزا):
            رفع TypeError ("يمكنك فقط إضافة بيتزا أخرى!")
        new_toppings = self.toppings +other.toppings
        إرجاع البيتزا (الحجم الذاتي ، new_toppings)

# دعونا نصنع اثنين من البيتزا
pizza1 = بيتزا ("كبيرة" ، ["بيبروني" ، "فطر"])
pizza2 = بيتزا ("كبيرة" ، ["زيتون" ، "أناناس"])

# والآن دعونا "نضيفها"
مجتمعة_بيتزا = بيتزا 1 + بيتزا 2

print (Combined_pizza.toppings) # هذا سيطبع: ["بيبروني" ، "فطر" ، "زيتون" ، "أناناس"]

على غرار dunder __add__، يمكننا أيضا defiإنهاء وظائف حسابية أخرى مثل __sub__ (بالطرح باستخدام عامل التشغيل -) و __mul__ (للضرب باستخدام عامل التشغيل *).

__لين__

هذا الأسلوب الغامض يسمح لنا defiما الانتهاء من وظيفة len() يجب إرجاع العناصر المخصصة لدينا.

يستخدم بايثون len() للحصول على طول أو حجم بنية البيانات مثل قائمة أو سلسلة.

في سياق مثالنا ، يمكننا القول أن "طول" البيتزا هو عدد الإضافات التي تحتوي عليها. إليك كيف يمكننا تنفيذه:

بيتزا كلاس:
    def __init __ (ذاتي ، الحجم ، الطبقة):
        الحجم = الحجم
        self.toppings = الطبقة

    def __len __ (النفس):
        عودة لين (إضافات ذاتية)

# لنقم بإنشاء بيتزا
my_pizza = بيتزا ("كبيرة" ، ["بيبروني" ، "فطر" ، "زيتون"])

print (len (my_pizza)) # هذا سوف يطبع: 3

في طريقة __len__ ، نرجع طول القائمة فقط toppings. الآن، len(my_pizza) سيخبرنا عن عدد الإضافات الموجودة عليه my_pizza.

__المتر__

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

للقيام بذلك ، يجب علينا أيضًا defiإنهاء الوظيفة __next__، يستخدم هذا ل definish السلوك الذي يجب أن يُرجع القيمة التالية في التكرار. يجب أن يشير أيضًا إلى ما يمكن تكراره في الحدث بعدم وجود المزيد من العناصر في التسلسل. نحقق ذلك عادةً من خلال طرح استثناء StopIteration.

بالنسبة لمثال البيتزا لدينا ، لنفترض أننا نريد تكرار الطبقة العلوية. يمكننا أن نجعل فئة البيتزا الخاصة بنا قابلة للتكرار defiطريقة nendo __iter__:

بيتزا كلاس:
    def __init __ (ذاتي ، الحجم ، الطبقة):
        الحجم = الحجم
        self.toppings = الطبقة

    def __iter __ (ذاتي):
        النفس.ن = 0
        العودة الذاتية

    def __next __ (ذاتي):
        إذا self.n <len (إضافات ذاتية):
            النتيجة = self.toppings [self.n]
            self.n + = 1
            نتيجة العودة
        آخر:
            رفع StopIteration

# لنقم بإنشاء بيتزا
my_pizza = بيتزا ("كبيرة" ، ["بيبروني" ، "فطر" ، "زيتون"])

# والآن دعونا نكررها
لتتصدر في my_pizza:
    طباعة (تحتل المرتبة الأولى)

في هذه الحالة ، تستدعي حلقة for __iter__، الذي يهيئ العداد (self.n) ويعيد كائن البيتزا نفسه (self).

ثم ، تستدعي حلقة for __next__ للحصول على كل تحتل المرتبة الأولى على التوالي.

عندما __next__ أعاد كل التوابل ، StopIteration تقوم بإلقاء استثناء وتعرف الحلقة for الآن أنه لا يوجد المزيد من الإضافات وبالتالي ستجهض عملية التكرار.

Ercole Palmeri