🚀 go-pugleaf

Wielkie dzięki super opis.



On 29 Lis, 12:52, Rob Wolfe <r...@smsnet.pl> wrote:
> ak3031884 <ak3031...@gmail.com> writes:
> > Tak ten przykład podoba mi sie i pokazuje słuszność stosowania __set__
> > i __get__, aczkolwiek w  "starym stylu klas" można to też ładnie
> > napisać.
>
> > Powiedzcie mi jeszcze jaka jest różnica między funkcjami
> > object.__getattr__(self, name) a   def __get__(self, obj, cls):
> > object.__setattr__(self, name, value) a def __set__(self, obj, value):
>
> > czytająchttp://docs.python.org/reference/datamodel.htmljakoś nie
> > bardzo pojąłem wielkość różnicy tych funkcji.
>
> Jeśli masz ambicję zrozumienia deskryptorów, to musisz przeczytać opis
> (najlepszy w sieci, napisany przez twórcę tej koncepcji),
> do którego link już Ci został podany:http://users.rcn.com/python/download/Descriptor.htm
>
> Gdy tam zajrzysz, to znajdziesz kluczową definicję dla zrozumienia
> tego mechanizmu:
>
> def __getattribute__(self, key):
>     "Emulate type_getattro() in Objects/typeobject.c"
>     v = object.__getattribute__(self, key)
>     if hasattr(v, '__get__'):
>        return v.__get__(None, self)
>     return v
>
> Kluczowa zasada to kolejność wywołań:
> 1. __getattribute__ jest wołana zawsze jako pierwsza
> 2. __get__ jest wołana tylko dla atrybutów, które mają
>    zdefiniowaną taką metodę, czyli są deskryptorami
> 3. __getattr__ jest wołana zawsze jako ostatnia
>   i tylko wtedy, gdy powyższy mechanizm nie był w stanie
>   odnaleźć składowej
>
> Czyli gdy mamy zdefiniowaną tylko `__getattribute__`,
> to wołana jest zawsze:
>
> class A(object):
>     def __init__(self):
>         self.x = 99
>
>     def __getattribute__(self, name):
>         print '__getattribute__: %r' % name
>         v = object.__getattribute__(self, name)
>         if hasattr(v, '__get__'):
>             return v.__get__(None, self)
>         return v
>
> >>> a = A()
> >>> a.x
>
> __getattribute__: 'x'
> 99>>> a.y
>
> __getattribute__: 'y'
> Traceback (most recent call last):
>   File "<stdin>", line 1, in <module>
>   File "/tmp/python-4766uIx.py", line 7, in __getattribute__
> AttributeError: 'A' object has no attribute 'y'
>
> Gdy mamy zdefiniowaną `__getattr__`, to wołana jest tylko
> przy odwołaniu do *niezdefiniowanej* składowej:
>
> class B(object):
>     def __init__(self):
>         self.x = 99
>
>     def __getattr__(self, name):
>         print '__getattr__: %r' % name
>         if name == 'y':
>             return self.x * 10  # odwolanie do self.x nie powoduje zapetlenia
>         raise AttributeError('%r object has no attribute %r'
>                              % (self.__class__.__name__, name))
>
> >>> b = B()
> >>> b.x
> 99
> >>> b.y
>
> __getattr__: 'y'
> 990>>> b.z
>
> __getattr__: 'z'
> Traceback (most recent call last):
>   File "<stdin>", line 1, in <module>
>   File "/tmp/python-4766gSA.py", line 10, in __getattr__
> AttributeError: 'B' object has no attribute 'z'
>
> Gdy mamy zdefiniowane zarówno `__getattribute__` jak i `__getattr__`,
> to wywoływane są w z góry przyjętej kolejności, czyli na początku
> `__getattribute__`, a na końcu `__getattr__` (gdy jest odwołanie
> do *niezdefiniowanej* składowej):
>
> class C(object):
>     def __init__(self):
>         self.x = 99
>
>     def __getattribute__(self, name):
>         print '__getattribute__: %r' % name
>         v = object.__getattribute__(self, name)
>         if hasattr(v, '__get__'):
>             return v.__get__(None, self)
>         return v
>
>     def __getattr__(self, name):
>         print '__getattr__: %r' % name
>         if name == 'y':
>             return self.x * 10  # odwolanie do self.x nie powoduje zapetlenia
>         raise AttributeError('%r object has no attribute %r'
>                              % (self.__class__.__name__, name))
>
> >>> c = C()
> >>> c.x
>
> __getattribute__: 'x'
> 99>>> c.y
>
> __getattribute__: 'y'
> __getattr__: 'y'
> __getattribute__: 'x'
> 990>>> c.z
>
> __getattribute__: 'z'
> __getattr__: 'z'
> __getattribute__: '__class__'
> Traceback (most recent call last):
>   File "<stdin>", line 1, in <module>
>   File "/tmp/python-4766tcG.py", line 17, in __getattr__
> AttributeError: 'C' object has no attribute 'z'
>
> I teraz, gdy do tej klasy dorzucimy definicję `__get__`, to co się stanie?
> Mogą się dziać dziwne rzeczy, gdyż `__get__` w takim przypadku nie ma
> najmniejszego sensu:
>
> class D(object):
>     def __init__(self):
>         self.x = 99
>
>     def __getattribute__(self, name):
>         print '__getattribute__: %r' % name
>         v = object.__getattribute__(self, name)
>         if hasattr(v, '__get__'):
>             return v.__get__(None, self)
>         return v
>
>     def __get__(self, instance, owner):
>         print '__get__: %r' % owner
>         return self.x
>
>     def __getattr__(self, name):
>         print '__getattr__: %r' % name
>         if name == 'y':
>             return self.x * 10  # odwolanie do self.x nie powoduje zapetlenia
>         raise AttributeError('%r object has no attribute %r'
>                              % (self.__class__.__name__, name))
>
> >>> d = D()
> >>> d.x
>
> __getattribute__: 'x'
> 99>>> d.y
>
> __getattribute__: 'y'
> __getattr__: 'y'
> __getattribute__: 'x'
> 990>>> d.z
>
> __getattribute__: 'z'
> __getattr__: 'z'
> __getattribute__: '__class__'
> Traceback (most recent call last):
>   File "<stdin>", line 1, in <module>
>   File "/tmp/python-4766U7Y.py", line 21, in __getattr__
>   File "/tmp/python-4766U7Y.py", line 9, in __getattribute__
> TypeError: unbound method __get__() must be called with D instance as first argument (got NoneType instance instead)
>
> Zgodnie z dokumentacją [1]_ ma sens tylko dla:
> """
> The following methods (przyp. tlum. __get__, __set__, __delete__) only
> apply when an instance of the class containing the method
> (a so-called descriptor class) appears in the class dictionary of
> another new-style class, known as the owner class.
> """
>
> czyli po naszemu:
>
> """
> Metody __get__, __set__ i __delete__ mają zastosowanie wtedy i tylko wtedy,
> gdy instancja klasy zawierająca te metody (tzw. deskryptor) stanowi składową
> innej klasy nowego stylu.
> """
>
> W związku z tym deskryptor ma sens w takim przypadku jak ten, gdzie mamy
> oddzielną klasę definiującą składową i jakąś klasę zawierjącą
> tę składową:
>
> class E(object):
>     def __init__(self, val):
>         self.val = val
>
>     def __get__(self, instance, owner):
>         print '__get__: %r' % owner.__class__.__name__
>         return self.val
>
> class F(object):
>     def __init__(self):
>         self.x = E(99)
>
>     def __getattribute__(self, name):
>         print '__getattribute__: %r' % name
>         v = object.__getattribute__(self, name)
>         if hasattr(v, '__get__'):
>             return v.__get__(None, self)
>         return v
>
>     def __getattr__(self, name):
>         print '__getattr__: %r' % name
>         if name == 'y':
>             return self.x * 10  # odwolanie do self.x nie powoduje zapetlenia
>         raise AttributeError('%r object has no attribute %r'
>                              % (self.__class__.__name__, name))
>
> >>> f = F()
> >>> f.x
>
> __getattribute__: 'x'
> __getattribute__: '__class__'
> __get__: 'F'
> 99>>> f.y
>
> __getattribute__: 'y'
> __getattr__: 'y'
> __getattribute__: 'x'
> __getattribute__: '__class__'
> __get__: 'F'
> 990>>> f.z
>
> __getattribute__: 'z'
> __getattr__: 'z'
> __getattribute__: '__class__'
> Traceback (most recent call last):
>   File "<stdin>", line 1, in <module>
>   File "/tmp/python-4766uPl.py", line 26, in __getattr__
> AttributeError: 'F' object has no attribute 'z'
>
> A teraz poćwicz ten temat tak z tydzień w różnych wariantach
> i jest pewna szansa, że coś się zacznie klarować. ;)
>
> .. [1]http://docs.python.org/reference/datamodel.html?highlight=__getattr__...
>
> RW