descriptor

I understand that __dict__ in obj.__dict__ is a descriptor attribute of type(obj) , so the lookup for obj.__dict__ is type(obj).__dict__['__dict__'].__get__(obj) . From https://stackoverflow.com/a/46576009 It's tempting to say that __dict__ has to be a descriptor because implementing it as a __dict__ entry would require you to find the __dict__ before you can find the __dict__ , but Python already bypasses normal attribute lookup to find __dict__ when looking up other attributes , so that's not quite as compelling as it initially sounds. If the descriptors were replaced with a '__dict__' key

I created a class String() with __get__() , __set__() , and a method to_db() ; however, when I do name = String() , I can't do self.name.to_db() because it's calling to_db() on the value returned by __get__() , not the object " name ". class String(object): def __init__(self, value=None): if value: self.value = str(value) def __get__(self, instance, owner): return self.value def __set__(self, instance, value): self.value = str(value) def to_db(self): return {'type':'string', 'value': self.value} class Example(object): name = String() age = Integer() def __init__(self,name,age): self.name =

I want to create a decorator that works like a property, only it calls the decorated function only once, and on subsequent calls always return the result of the first call. An example: def SomeClass(object): @LazilyInitializedProperty def foo(self): print "Now initializing" return 5 >>> x = SomeClass() >>> x.foo Now initializing 5 >>> x.foo 5 My idea was to write a custom decorator for this. So i started, and this is how far I came: class LazilyInitializedProperty(object): def __init__(self, function): self._function = function def __set__(self, obj, value): raise AttributeError("This property

The question refers to which one is preferable to be used in which use case, not about the technical background. In python, you can control the access of attributes via a property , a descriptor , or magic methods . Which one is most pythonic in which use case? All of them seem to have the same effect (see the examples below). I am looking for an answer like: Property : Should be used in case of … Descriptor : In the case of … it should be used instead of a property. Magic method : Only use if …. Example A use case would be an attribute that might not be able to be set in the __init__ method,

Possible Duplicate: When and why might I assign an instance of a descriptor class to a class attribute in Python rather than use a property? I'm confused as to when to use a property vs a descriptor. I read that a property is a specialized descriptor. Can someone please post how this works? You should read the docs on what descriptors actually are. The Cliff's Notes version: descriptors are a low-level mechanism that lets you hook into an object's attributes being accessed. Properties are a high-level application of this; that is, properties are implemented using descriptors. Or, better yet,

I want to create an object in python that has a few attributes and I want to protect myself from accidentally using the wrong attribute name. The code is as follows: class MyClass( object ) : m = None # my attribute __slots__ = ( "m" ) # ensure that object has no _m etc a = MyClass() # create one a.m = "?" # here is a PROBLEM But after running this simple code, I get a very strange error: Traceback (most recent call last): File "test.py", line 8, in <module> a.m = "?" AttributeError: 'test' object attribute 'm' is read-only Is there any wise programmer who can spare a bit of their time and

I have this code; class NumberDescriptor(object): def __get__(self, instance, owner): name = (hasattr(self, "name") and self.name) if not name: name = [attr for attr in dir(owner) if getattr(owner,attr) is self][0] self.name = name return getattr(instance, '_' + name) def __set__(self,instance, value): name = (hasattr(self, "name") and self.name) if not name: owner = type(instance) name = [attr for attr in dir(owner) if getattr(owner,attr) is self][0] self.name = name setattr(instance, '_' + name, int(value)) class Insan(object): yas = NumberDescriptor() a = Insan() print a.yas a.yas = "osman"