الصفات والتعامل مع البروتوكول في بيثون

النظر في التعليمات البرمجية التالية:

class Foo: def __init__(self): self.bar = 'hello!' foo = Foo() print(foo.bar) 

اليوم سوف نحلل الإجابة على السؤال: "ماذا يحدث بالضبط عندما نكتب foo.bar ؟"

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

 >>> foo = Foo() >>> foo.__dict__ {'bar': 'hello!'} 

لنبدأ بمحاولة صياغة هذه الفرضية (غير المكتملة):

foo.bar مكافئ لـ foo .__ dict __ ['bar'] .

في حين يبدو مثل الحقيقة:

 >>> foo = Foo() >>> foo.__dict__['bar'] 'hello!' 

لنفترض الآن أنك تدرك بالفعل أنه يمكن تعريف السمات الديناميكية في الفصول الدراسية:

 >>> class Foo: ... def __init__(self): ... self.bar = 'hello!' ... ... def __getattr__(self, item): ... return 'goodbye!' ... ... foo = Foo() >>> foo.bar 'hello!' >>> foo.baz 'goodbye!' >>> foo.__dict__ {'bar': 'hello!'} 

حسنًا ... حسنًا. يمكن ملاحظة أن __getattr__ يمكن أن تحاكي الوصول إلى السمات "المزيفة" ، لكنها لن تعمل إذا كان هناك بالفعل متغير مُعلن (مثل foo.bar يُرجع "مرحبًا!" وليس "وداعًا!" ). يبدو أن كل شيء أكثر تعقيدًا مما بدا في البداية.

وبالفعل: هناك طريقة سحرية تسمى كلما حاولنا الحصول على سمة ، ولكن ، كما هو موضح أعلاه ، ليست هذه __getattr__ . تسمى الطريقة التي يطلق عليها __getattribute__ ، وسنحاول فهم كيف تعمل بالضبط من خلال مراقبة المواقف المختلفة.

حتى الآن ، نقوم بتعديل فرضيتنا على النحو التالي:

foo.bar مكافئ لـ foo .__ getattribute __ ('bar') ، والذي يعمل تقريبًا مثل هذا:

 def __getattribute__(self, item): if item in self.__dict__: return self.__dict__[item] return self.__getattr__(item) 

سنختبرها عن طريق تطبيق هذه الطريقة (تحت اسم مختلف) ونطلق عليها مباشرة:

 >>> class Foo: ... def __init__(self): ... self.bar = 'hello!' ... ... def __getattr__(self, item): ... return 'goodbye!' ... ... def my_getattribute(self, item): ... if item in self.__dict__: ... return self.__dict__[item] ... return self.__getattr__(item) >>> foo = Foo() >>> foo.bar 'hello!' >>> foo.baz 'goodbye!' >>> foo.my_getattribute('bar') 'hello!' >>> foo.my_getattribute('baz') 'goodbye!' 

يبدو صحيحا ، أليس كذلك؟

حسنًا ، كل ما تبقى هو التحقق من أن مهمة المتغيرات مدعومة ، وبعد ذلك يمكنك العودة إلى المنزل ... -

 >>> foo.baz = 1337 >>> foo.baz 1337 >>> foo.my_getattribute('baz') = 'h4x0r' SyntaxError: can't assign to function call 

لعنة.

إرجاع my_getattribute كائن. يمكننا تغييره إذا كان قابلاً للتغيير ، لكن لا يمكننا استبداله بمستخدم آخر باستخدام مشغل المهمة. ماذا تفعل؟ بعد كل شيء ، إذا كان foo.baz مكافئًا لاستدعاء دالة ، فكيف يمكننا تعيين قيمة جديدة لسمة من حيث المبدأ؟

عندما ننظر إلى تعبير مثل foo.bar = 1 ، هناك ما هو أكثر من مجرد استدعاء دالة للحصول على قيمة foo.bar . يبدو أن تعيين قيمة إلى سمة يختلف اختلافًا أساسيًا عن الحصول على قيمة سمة. والحقيقة: يمكننا تنفيذ __setattr__ لرؤية هذا:

 >>> class Foo: ... def __init__(self): ... self.__dict__['my_dunder_dict'] = {} ... self.bar = 'hello!' ... ... def __setattr__(self, item, value): ... self.my_dunder_dict[item] = value ... ... def __getattr__(self, item): ... return self.my_dunder_dict[item] >>> foo = Foo() >>> foo.bar 'hello!' >>> foo.bar = 'goodbye!' >>> foo.bar 'goodbye!' >>> foo.baz Traceback (most recent call last): File "<pyshell#75>", line 1, in <module> foo.baz File "<pyshell#70>", line 10, in __getattr__ return self.my_dunder_dict[item] KeyError: 'baz' >>> foo.baz = 1337 >>> foo.baz 1337 >>> foo.__dict__ {'my_dunder_dict': {'bar': 'goodbye!', 'baz': 1337}} 

هناك أمران يجب ملاحظتهما بخصوص هذا الرمز:

1. __setattr__ لا يوجد لديه نظير __getattribute__ (أي ، طريقة __setattribute__ السحرية غير موجودة).
2. يتم استدعاء __setattr__ داخل __init__ ، وهذا هو السبب في أننا مجبرون على فعل الذات. __ dict __ ['my_dunder_dict'] = {} بدلاً من self.my_dunder_dict = {} . خلاف ذلك ، سنواجه العودية لانهائية.

ولكن لدينا أيضا الملكية (وأصدقائه). ديكور يسمح للطرق أن تعمل كسمات.

دعونا نحاول أن نفهم كيف يحدث هذا.

 >>> class Foo(object): ... def __getattribute__(self, item): ... print('__getattribute__ was called') ... return super().__getattribute__(item) ... ... def __getattr__(self, item): ... print('__getattr__ was called') ... return super().__getattr__(item) ... ... @property ... def bar(self): ... print('bar property was called') ... return 100 >>> f = Foo() >>> f.bar __getattribute__ was called bar property was called 

للمتعة فقط ، ماذا لدينا في f .__ dict__ ؟

 >>> f.__dict__ __getattribute__ was called {} 

لا يوجد مفتاح شريط في __dict__ ، لكن __getattr__ لا يتم استدعاءه لسبب ما. WAT؟

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

 >>> Foo.__dict__ mappingproxy({'__dict__': <attribute '__dict__' of 'Foo' objects>, '__doc__': None, '__getattr__': <function Foo.__getattr__ at 0x038308A0>, '__getattribute__': <function Foo.__getattribute__ at 0x038308E8>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Foo' objects>, 'bar': <property object at 0x0381EC30>}) 

مفتاح الشريط موجود بالفعل في قاموس سمة الفصل. لفهم كيف يعمل __getattribute__ ، نحتاج إلى الإجابة على السؤال: من الذي __getattribute__ يسمى من قبل - فئة أم مثيل؟

 >>> f.__dict__['bar'] = 'will we see this printed?' __getattribute__ was called >>> f.bar __getattribute__ was called bar property was called 100 

يمكن ملاحظة أن أول شيء يتم التحقق منه في فئة __dict__ ، أي لها أولوية على المثال.

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

تلبية بروتوكول واصف :

descr .__ get __ (self، obj، type = None) -> value

descr .__ set __ (self، obj، value) -> None

descr .__ delete __ (self، obj) -> None

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

إذا أعلن كائن عن __get __ () و __set __ () ، فسيطلق عليه واصف البيانات. تسمى واصفات تطبيق فقط __get __ () واصفات غير البيانات.

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

لإنشاء واصف بيانات للقراءة فقط ، قم بتعريف كل من __get __ () و __set __ () ، حيث يرمي __set __ () على AttributeError عند الاتصال به. تطبيق __set __ () هذا يكفي لإنشاء واصف بيانات.

باختصار ، إذا أعلنت أيًا من هذه الطرق __get__ أو __set__ أو __delete__ ، فأنت تنفذ الدعم لبروتوكول الواصف. وهذا هو بالضبط ما يفعله مصمم الممتلكات : فهو يعلن عن واصف للقراءة فقط سيتم استدعاؤه في __getattribute__ .

آخر تغيير في تطبيقنا:

foo.bar مكافئ لـ foo .__ getattribute __ ('bar') ، والذي يعمل تقريبًا مثل هذا:

 def __getattribute__(self, item): if item in self.__class__.__dict__: v = self.__class__.__dict__[item] elif item in self.__dict__: v = self.__dict__[item] else: v = self.__getattr__(item) if hasattr(v, '__get__'): v = v.__get__(self, type(self)) return v 

دعنا نحاول التوضيح في الممارسة:

 class Foo: class_attr = "I'm a class attribute!" def __init__(self): self.dict_attr = "I'm in a dict!" @property def property_attr(self): return "I'm a read-only property!" def __getattr__(self, item): return "I'm dynamically returned!" def my_getattribute(self, item): if item in self.__class__.__dict__: print('Retrieving from self.__class__.__dict__') v = self.__class__.__dict__[item] elif item in self.__dict__: print('Retrieving from self.__dict__') v = self.__dict__[item] else: print('Retrieving from self.__getattr__') v = self.__getattr__(item) if hasattr(v, '__get__'): print("Invoking descriptor's __get__") v = v.__get__(self, type(self)) return v 

 >>> foo = Foo() ... ... print(foo.class_attr) ... print(foo.dict_attr) ... print(foo.property_attr) ... print(foo.dynamic_attr) ... ... print() ... ... print(foo.my_getattribute('class_attr')) ... print(foo.my_getattribute('dict_attr')) ... print(foo.my_getattribute('property_attr')) ... print(foo.my_getattribute('dynamic_attr')) I'm a class attribute! I'm in a dict! I'm a read-only property! I'm dynamically returned! Retrieving from self.__class__.__dict__ I'm a class attribute! Retrieving from self.__dict__ I'm in a dict! Retrieving from self.__class__.__dict__ Invoking descriptor's __get__ I'm a read-only property! Retrieving from self.__getattr__ I'm dynamically returned! 

نحن فقط خدش سطح تنفيذ السمة في بيثون قليلا. على الرغم من أن المحاولة الأخيرة لمحاكاة foo.bar صحيحة بشكل عام ، ضع في اعتبارك أنه قد تكون هناك دائمًا تفاصيل صغيرة يتم تنفيذها بطريقة مختلفة.

آمل أنه بالإضافة إلى معرفة كيفية عمل السمات ، تمكنت أيضًا من إيصال جمال اللغة التي تشجعك على التجربة. سداد بعض ديون المعرفة اليوم.