class Foo(object):
 def __init__(self,a):
 if isinstance(a,int):
  self.__a = a
 else:
  raise TypeError("Must be an int")

 def set_a(self,val):
 if isinstance(val,int):
  self.__a = val
 else:
  raise TypeError("Must be an int")

 def get_a(self):
 return self.__a

f = Foo(1)
print f.get_a() #1
print f._Foo__a #1,還是能訪問到= =
f._Foo__a = 'test'
print f.get_a() #test,還是改變了__a的值,而且不是int型
print f._Foo__a #test

class Foo(object):
 a = 1
f = Foo()
print f.a #1,實(shí)例屬性中沒有a屬性,所以到Foo.__dict__中查找
print Foo.a #1
print f.__dict__ #{}
f.a = 2  #增加一個(gè)名為a的實(shí)例屬性
print f.a #2,搜索屬性時(shí)先在實(shí)例字典中查找,然后再去類的字典中查找,在實(shí)例的__dict__中找到了..
print Foo.a #1
print f.__dict__ #{'a': 2}

class descriptor(object):
 def __init__(self,val):
 self.val = val
 def __get__(self,obj,type = None):
 print 'get',
 return self.val
 def __set__(self,obj,val):
 print 'set',val
 self.val = val
 def __delete__(self,obj):
 raise AttributeError("Can't delete attribute")
class Foo(object):
 a = descriptor(0)

f = Foo()
print f.a #get 0
print Foo.a #get 0
print f.__dict__ #{}
f.a = 2  #set 2,并沒有增加實(shí)例屬性
print f.a #get 2
print Foo.a #get 2
print f.__dict__ #{}

class descriptor(object):
 def __init__(self,val):
  self.val = val

 def __get__(self, obj, objtype):
  print 'get',
  return self.val

 def __set__(self, obj, val):
  print 'set'
  self.val = val

class Foo(object):
 x = descriptor(0)
 y = 0

f = Foo()
'''描述符覆蓋默認(rèn)的訪問行為'''
print f.x   #get 0,調(diào)用的是描述符的__get__函數(shù)
print f.__dict__ #{}
f.x = 1    #set,調(diào)用的是描述符的__set__函數(shù)
print f.x   #get 1
print f.__dict__ #{},即使賦值也沒有增加實(shí)例屬性...,是不是覆蓋了默認(rèn)行為- -
f.y = 2    
print f.__dict__ #{'y': 2},因?yàn)闆]有與y同名的描述符對象...

class descriptor(object):
 def __init__(self,val = 0):
  self.val = val

 def __get__(self, obj, objtype):
  print '__get__',
  return self.val

 def __set__(self, obj, val):
  self.val = val

class Foo(object):
 a = descriptor()#數(shù)據(jù)描述符
f = Foo()
f.a = 1    #不會增加實(shí)例屬性,會調(diào)用descriptor.__set__方法,數(shù)據(jù)描述符的優(yōu)先級比實(shí)例屬性高
print f.a   #__get__ 1,調(diào)用的是descriptor.__get__方法
print f.__dict__ #{}

f.__dict__['a'] = 2   #增加一個(gè)與數(shù)據(jù)描述符同名的實(shí)例屬性
print f.__dict__   #{'a': 2}
print f.a     #__get__ 1,正常使用,調(diào)用的仍是描述符的__get__方法
print f.__dict__['a']  #2,這個(gè)時(shí)候就是實(shí)例屬性了...

class descriptor(object):
 def __init__(self,val = 0):
  self.val = val

 def __get__(self, obj, objtype):
  print '__get__',
  return self.val

class Foo(object):
 a = descriptor()#非數(shù)據(jù)描述符,沒有__set__
f = Foo()
print f.a   #__get__ 0,調(diào)用descriptor.__get__方法
f.a = 1    #增加實(shí)例屬性,因?yàn)閷?shí)例屬性的優(yōu)先級比非數(shù)據(jù)描述符高
print f.a   #1,不會調(diào)用descriptor.__get__方法,實(shí)例屬性的優(yōu)先級比非數(shù)據(jù)描述符高
print f.__dict___ #{'a': 1},增加了實(shí)例屬性a

class data_descriptor(object):#數(shù)據(jù)描述符
 def __init__(self,val):
  self.val = val

 def __get__(self, obj,type = None):
  print 'data get'
  return self.val

 def __set__(self, obj, value):
  if not isinstance(value,int):#賦值時(shí)可以類型檢查啊
   raise ValueError('value must be int')
  self.val = value

class non_data_descriptor(object):#非數(shù)據(jù)描述符
 def __init__(self,val):
  self.val = val

 def __get__(self,obj,type = None):
  print 'non data get'
  return self.val

class Foo(object):
 data = data_descriptor(0)
 non_data = non_data_descriptor(1)

f = Foo()
print f.__dict__ #{}
print f.data  #data get,0
print f.non_data #non data get,1
f.data = 2   #數(shù)據(jù)描述符優(yōu)先級較高,不會創(chuàng)建實(shí)例屬性,而是調(diào)用描述符的__set__方法
f.non_data = 3  #增加了與非數(shù)據(jù)描述符同名的實(shí)例屬性

print f.__dict__ #{'non_data': 3}
print f.data  #data get,2 調(diào)用數(shù)據(jù)描述符的__get__()方法
print f.non_data #3,非數(shù)據(jù)描述符優(yōu)先級比實(shí)例屬性低
print Foo.non_data #non data get 1,利用類屬性查找還是可以訪問非數(shù)據(jù)描述符的,非數(shù)據(jù)描述符值未改變

class Foo(object):
 def __init__(self):
  self.x = 1
  self.y = 2

 def __getattribute__(self,keys = None):#這樣優(yōu)先級鏈，描述符什么的就都沒用了。。。。
  return 'test'

f = Foo()
print f.x,f.y,f.z #test,test,test,優(yōu)先級鏈?zhǔn)裁吹亩紱]用啦= =

def __getattribute__(self, key):
 "Emulate type_getattro() in Objects/typeobject.c"
 v = object.__getattribute__(self, key)
 if hasattr(v, '__get__'):#如果v定義了__get__方法的話,優(yōu)先調(diào)用v.__get__ 
  return v.__get__(None, self)
 return v

class descriptor(object):
 def __init__(self, initval=None, name='var'):
  self.val = initval
  self.name = name

 def __get__(self, obj, objtype):
  print 'get', self.name,
  return self.val

 def __set__(self, obj, val):
  print 'set', self.name,val
  self.val = val

class Foo(object):
 x = descriptor(10, 'var "x"')
 y = 5

m = Foo()
'''訪問m.x的三種方法'''
print m.x       #get var "x",10
print type(m).__dict__['x'].__get__(m,type(m)) #m.x會轉(zhuǎn)化為這種形式,等價(jià)于m.x
print m.__getattribute__('x')  #等價(jià)于m.x,因?yàn)閤定義了__get__方法,調(diào)用x的__get__方法,上面已經(jīng)給出了__getattribute__的實(shí)現(xiàn)原理
'''設(shè)置m.x的值'''
m.x = 20        #set var "x" 20
type(m).__dict__['x'].__set__(m,20) #m.x = 20會轉(zhuǎn)化為此種形式,等價(jià)于m.x = 20

print m.x       #get var "x",20
print m.y       #5
#print type(m).__dict__['y'].__get__(m,type(m)) #error,AttributeError: 'int' object has no attribute '__get__'
print m.__getattribute__('y')  #5,等價(jià)于m.y

class Foo(object):
 y = descriptor(0)
 def __init__(self):
  self.x = descriptor(1)  #實(shí)例屬性的描述符是不會自動調(diào)用對應(yīng)的描述符方法的...
b = Foo()
print "X is %s, Y is %s" % (b.x, b.y)#X is <__main__.descriptor object at 0x10432c250>, Y is 0
print "Y is %s"%b.y.__get__(b)  #需要自己調(diào)用__get__方法,解釋器不會自己調(diào)用的

class descriptor(object):
 def __init__(self, default):
  self.value = default

 def __get__(self, instance, owner):
  return self.value

 def __set__(self, instance, value):
  self.value = value

class Foo(object):
 bar = descriptor(5) 

f = Foo()
g = Foo()
print "f.bar is %s g.bar is %s" % (f.bar, g.bar) #f.bar is 5 g.bar is 5
f.bar = 10          #調(diào)用__set__函數(shù)
print "f.bar is %s g.bar is %s" % (f.bar, g.bar) #f.bar is 10 g.bar is 10

from weakref import WeakKeyDictionary
class descriptor(object):
 def __init__(self, default):
  self.default = default
  self.data = WeakKeyDictionary()

 def __get__(self, instance, owner):# instance = x,owner = type(x)
  # we get here when someone calls x.d, and d is a descriptor instance
  return self.data.get(instance, self.default)

 def __set__(self, instance, value):
  # we get here when someone calls x.d = val, and d is a descriptor instance
  self.data[instance] = value

class Foo(object):
 bar = descriptor(5)

f = Foo()
g = Foo()
print "f.bar is %s g.bar is %s" % (f.bar, g.bar) #f.bar is 5 g.bar is 5
print "Setting f.bar to 10"
f.bar = 10
print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar) ##f.bar is 10 g.bar is 5

class descriptor(object):
 def __init__(self, label):#label為給實(shí)例增加的實(shí)例屬性名
  self.label = label
 def __get__(self, instance, owner):
  #dict.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
  return instance.__dict__.get(self.label) #獲取與描述符同名的實(shí)例屬性的值 

 def __set__(self, instance, value):
  #注意這里,要這么寫,不能寫instance.x = val這種形式,這樣會形成自身的循環(huán)調(diào)用
  instance.__dict__[self.label] = value  #修改與描述符同名的實(shí)例屬性的值 

class Foo(list):
 x = descriptor('x') #注意這個(gè)初始化值為要給實(shí)例增加的實(shí)例屬性名，要和描述符對象同名。
 y = descriptor('y')

f1 = Foo()
f2 = Foo()
print f1.__dict__ #{}
print f1.x,f2.x,f1.y,f2.y#None None None None,此時(shí)尚未增加實(shí)例屬性,需要調(diào)用__set__方法建立一個(gè)與描述符同名的實(shí)例屬性
#print Foo.__dict__
f1.x = 1
f1.y = 2
f2.x = 3
f2.y = 4   
print f1.__dict__ #{'y': 2, 'x': 1} #增加了的實(shí)例屬性
print f1.x,f1.y,f2.x,f2.y #1 2 3 4 

class Foo(list):
 x = descriptor('x')
 y = descriptor('y')
 def __init__(self):
  self.x = 1 #調(diào)用的是描述符的__set__方法,與描述符同名的實(shí)例屬性增加完畢....
  self.y = 2
f = Foo()
print f.x,f.y 

class descriptor(object):
 def __init__(self, label):
  self.label = label
 def __get__(self, instance, owner):
  return instance.__dict__.get(self.label) 

 def __set__(self, instance, value):
  if not isinstance(value,int):
   raise ValueError('must be int')
  instance.__dict__[self.label] = value 

class Foo(object):
 x = descriptor('y') #應(yīng)該改為Descriptor('x'),與實(shí)例同名
 def __init__(self,val = 0):
  self.x = val

f = Foo()
print f.x #0
f.y = 'a' #繞過了描述符的__set__方法...未進(jìn)行類型檢查,此時(shí)x為非法值啊,是不是很坑...
print f.x #a

class Foo(object):
 x = descriptor('x')
 def __init__(self,val = 0):
  self.x = val

f = Foo()
f.x = 'a'#ValueError: must be int

f.__dict__['x'] = 'a'
print f.x #a,還是繞過了__set__方法,未進(jìn)行類型檢查,還是非法值啊...哈哈- -

from weakref import WeakKeyDictionary
class CallbackProperty(object):
  def __init__(self, default=None):
    self.data = WeakKeyDictionary()
    self.default = default
    self.callbacks = WeakKeyDictionary()

  def __get__(self, instance, owner):
    if instance is None:
      return self    
    return self.data.get(instance, self.default)

  def __set__(self, instance, value):#每次改變值的時(shí)候都會調(diào)用low_balance_warning函數(shù)
    for callback in self.callbacks.get(instance, []):
      # alert callback function of new value
      callback(value)
    self.data[instance] = value

  def add_callback(self, instance, callback):
    """Add a new function to call everytime the descriptor within instance updates"""
    if instance not in self.callbacks:
      self.callbacks[instance] = [] #實(shí)例->[方法,]
    self.callbacks[instance].append(callback)

class BankAccount(object):
  balance = CallbackProperty(0)

def low_balance_warning(value):
  if value < 100:
    print "You are now poor"
  else:
    print 'You are now rich!!!'

def check(value):
  print 'You have %s money, Good Luck!!!'%value

ba = BankAccount()
BankAccount.balance.add_callback(ba, low_balance_warning)
BankAccount.balance.add_callback(ba, check)

ba.balance = 5000          # You are now rich!!! You have 5000 money, Good Luck!!!
print "Balance is %s" % ba.balance  # Balance is 5000
ba.balance = 99           # You are now poor  You have 99 money, Good Luck!!!
print "Balance is %s" % ba.balance  # Balance is 99

class descriptor(object):
  def __init__(self,val):
    self.val = val

  def __get__(self, obj,type = None):
    return self.val

  def __set__(self, obj, value):
    raise Exception('read only')

class Foo(object):
  d = descriptor(1)

d = Foo()
print d.d #1
d.d = 2  #觸發(fā)異常,read only