Fun with Python Descriptors

Transcription

1 Fun with Python Descriptors Author: Jeff Rush Date: include directive disabled... include:: <s5defs.txt> Overview What are descriptors? Implementation: attribute watcher Implementation: property() builtin Implementation: methods over functions Implementation: StaticMethod builtin Implementation: ClassMethod builtin Lazy Properties Cached Properties What is a Descriptor? only for new-style objects an object that implements magic methods get set delete these methods override normal attribute lookup Why do Descriptors Exist? to simplify the underlying C code make it easier to override attribute lookup Example Uses of Descriptors properties methods static methods class methods super() 1

2 The Descriptor Protocol name # attribute s name doc # attribute s docstring [descriptor]. get (self, obj, type=none) -> value [descriptor]. set (self, obj, value) -> None [descriptor]. delete (self, obj) -> None If both get and set are defined then it is a data descriptor (like simple attributes) If just get are defined then it is a non-data-descriptor (like methods) Attribute Lookup Precedence Rules Important: 1. data descriptors 2. instance variables via dict 3. non-data descriptors 4. getattr method But What About The Old Way? getattr (name) -> value still there in new-style classes getattribute (name) -> value added for new-style classes getattribute is always called; getattr is only called if the name is not found in the instance dictionary. Making a Read-Only Data Descriptor define both get and set have set raise an AttributeError Attribute Lookup Machinery differs between classes, instances and super() search the instance dict then the class s dict then each base class dict excludes metaclasses overriding getattribute breaks descriptors 2

3 Descriptor Machinery for Classes Implemented in type. Example: A.x getattribute descriptor = A. class.x descriptor. get (instance=none, instance_type=self) def getattribute (self, key): v = object. getattribute (self, key) if hasattr(v, get ): return v. get (None, self) return v Descriptor Machinery for Instances Implemented in object. Example: a.x getattribute descriptor = a. class.x descriptor. get (instance=a, instance_type=type(a)) Descriptor Machinery for super() Implemented in super(). getattribute Example: super(a, obj).m() # searches obj. class. mro for (B, A) descriptor = A.m descriptor. get (instance=obj, instance_type=a) Example 1 - Logging Certain Attribute Fetches class RevealAccess(object): def init (self, initvalue=none, name= var ): self.value = initvalue self.name = name def get (self, instance, instance_type): print "Fetching:", self.name return self.value def set (self, instance, value): print "Setting:", self.name self.value = value class TargetClass(object): x = RevealAccess(10, var x ) 3

4 Use of Descriptors in property() builtin class MyClass(object): def x(self): def get(self): return self. x def set(self, value): self. x = value def del(self): del self. x x = property(x.get, x.set, x.del, " x property") Example 2 - Implementation of property class Property(object): def init (self, fget=none, fset=none, fdel=none, doc=none): self.fget = fget self.fset = fset self.fdel = fdel self. doc = doc if instance is None: return self if self.fget is None: raise AttributeError, "unreadable attribute" return self.fget(instance) (continued) Example 2 - cont d def set (self, instance, value): if self.fset is None: raise AttributeError, "can t set attribute" self.fset(instance, value) def delete (self, instance): if self.fdel is None: raise AttributeError, "can t delete attribute" self.fdel(instance) Example 3 - Implementation of Python Methods Python is built upon a function-based environment. features by binding functions into methods. Class dict store methods as functions. class FunctionDesc(object): return types.methodtype(self, instance, instance_type) Non-data descriptors add the object-oriented 4

5 class D(object): def f(self, x): # implicit f = FunctionDesc(codeblock) return x d = D() # D. dict [ f ] <function f> # D.f (unbound method) type(d). dict [ f ]. get (None, self) # d.f (bound method) type(d). dict [ f ]. get (d, type(d)) Example 4 - Implementation of StaticMethod builtin Lack any reference to the class or instance. class StaticMethod(object): def init (self, f): self.f = f return self.f Example 4 - Implementation of ClassMethod builtin Lack any reference to the instance but has one to the class. Useful for alternate class constructors, such as Dict.fromkeys(). class ClassMethod(object): def init (self, f): self.f = f if instance_type is None: instance_type = type(instance) def newfunc(*args): return self.f(instance_type, *args) return newfunc Lazy Properties (No Automatic Updates) from blah import LazyProperty class Point(object): def init (self, x, y): self.x, self.y = x, y def radius(self): 5

6 return sqrt(self.x**2 + self.y**2) radius = LazyProperty(radius) point = Point(1.0, 2.0) print point.radius # computes value and stuffs into dict print point.radius # reuses value already in dict del point.radius print point.radius # computes value and stuffs into dict Lazy Properties Calls with Decorators from blah import LazyProperty class Point: def init (self, x, y): self.x, self.y = x, # <---- def radius(self): return sqrt(self.x**2 + self.y**2) Implementation of Lazy Properties class Lazy(object): def init (self, func, name=none): if name is None: name = func. name self.data = (func, name) def get (self, instance, instance_type): if instance is None: return self func, name = self.data value = func(instance) instance. dict [name] = value return value Cached Properties (with Automatic Updates) from blah import CachedProperty class Point(object): def init (self, x, y): self.x, self.y = x, y x, y ) def radius(self): return math.sqrt(self.x**2 + self.y**2) radius = CachedProperty(radius, x, y ) # <---- 6

7 Implementation of Cached Properties ncaches = 1 class CachedProperty(object): def init (self, func, *names): global ncaches ncaches += 1 self.data = (func, names, "_v_cached_property_key_%s" % ncaches, "_v_cached_property_value_%s" % ncaches) def get (self, instance, instance_type): if instance is None: return self func, names, key_name, value_name = self.data key = names and [getattr(instance, name) for name in names] value = getattr(instance, value_name, self) if value is not self: # We have a cached value if key == getattr(instance, key_name, self): return value # Cache is still good! # We need to compute and cache the value value = func(instance) setattr(instance, key_name, key) setattr(instance, value_name, value) return value Questions? PEP 252: Making Types Look More Like Classes PEP 253: Subtyping Built-in Types DFW Pythoneers - November 25,