Python对象的属性访问过程详解

class A(object):
  a = 'a'

class B(A):
  b = 'b'

class C(B):
  class_field = 'class field'
  def __getattr__(self, f):
    print('Method {}.__getattr__ has been called.'.format(
      self.__class__.__name__))
    return f
c = C()
print c.a
print c.b
print c.class_field
print c.c

a
b
class field
Method C.__getattr__ has been called.
c

> class Test(object):
    pass
> test = Test()
# 查看类属性
> dir(Test)
['__class__','__delattr__','__dict__','__doc__','__format__',
'__getattribute__', '__hash__', '__init__', '__module__',
 '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
 '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
 '__weakref__']
# 查看实例属性
> dir(test)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', 
'__getattribute__', '__hash__', '__init__', '__module__',
 '__new__', '__reduce__', '__reduce_ex__', '__repr__',
 '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 
 '__weakref__']

> class Spring(object):
...   season = "the spring of class"
... 

# 查看Spring类保存的属性
> Spring.__dict__
dict_proxy({'__dict__': <attribute '__dict__' of 'Spring' objects>, 
'season': 'the spring of class', 
'__module__': '__main__', 
'__weakref__': <attribute '__weakref__' of 'Spring' objects>, 
'__doc__': None})

# 通过两种方法访问类属性
> Spring.__dict__['season']
'the spring of class'
> Spring.season
'the spring of class'

> s = Spring()
# 实例属性的__dict__是空的
> s.__dict__
{}
# 其实是指向的类属性
> s.season
'the spring of class'

# 建立实例属性
> s.season = "the spring of instance"
# 这样，实例属性里面就不空了。这时候建立的实例属性和类属性重名，并且把它覆盖了
> s.__dict__
{'season': 'the spring of instance'}
> s.__dict__['season']
'the spring of instance'
> s.season
'the spring of instance'

# 类属性没有受到实例属性的影响
> Spring.__dict__['season']
'the spring of class'
> Spring.__dict__
dict_proxy({'__dict__': <attribute '__dict__' of 'Spring' objects>, 'season': 'the spring of class', '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Spring' objects>, '__doc__': None})

# 如果将实例属性删除,又会调用类属性
> del s.season
> s.__dict__
{}
> s.season
'the spring of class'

# 自定义实例属性，对类属性没有影响
> s.lang = "python"
> s.__dict__
{'lang': 'python'}
> s.__dict__['lang']
'python'

# 修改类属性
> Spring.flower = "peach"
> Spring.__dict__
dict_proxy({'__module__': '__main__', 
'flower': 'peach', 
'season': 'the spring of class', 
'__dict__': <attribute '__dict__' of 'Spring' objects>, '__weakref__': <attribute '__weakref__' of 'Spring' objects>, '__doc__': None})
> Spring.__dict__['flower']
'peach'
# 实例中的__dict__并没有变化
> s.__dict__
{'lang': 'python'}
# 实例中找不到flower属性，调用类属性
> s.flower
'peach'

# 定义类
> class Spring(object):
...   def tree(self, x):
...     self.x = x
...     return self.x
... 
# 方法tree在__dict__里面
> Spring.__dict__
dict_proxy({'__dict__': <attribute '__dict__' of 'Spring' objects>, 
'__weakref__': <attribute '__weakref__' of 'Spring' objects>, 
'__module__': '__main__', 
'tree': <function tree at 0xb748fdf4>, 
'__doc__': None})
> Spring.__dict__['tree']
<function tree at 0xb748fdf4>

# 建立实例，但是__dict__中没有方法 
> t = Spring()
> t.__dict__
{}

# 执行方法
> t.tree("xiangzhangshu")
'xiangzhangshu'
# 实例方法(t.tree('xiangzhangshu'))的第一个参数(self，但没有写出来)绑定实例 t，透过 self.x 来设定值，即给 t.__dict__添加属性值。
> t.__dict__
{'x': 'xiangzhangshu'}
# 如果没有将x 赋值给 self 的属性，而是直接 return，结果发生了变化
> class Spring(object):
...   def tree(self, x):
...     return x
> s = Spring()
> s.tree("liushu")
'liushu'
> s.__dict__
{}

# 在类中定义__slots__属性就是说这个类中所有实例的属性都在这儿了，如果几百万个实例同时活动，能节省大量内存
> class Spring(object):
...   __slots__ = ("tree", "flower")
... 
# 仔细看看 dir() 的结果，还有__dict__属性吗？没有了，的确没有了。也就是说__slots__把__dict__挤出去了，它进入了类的属性。
> dir(Spring)
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', 'flower', 'tree']
> Spring.__slots__
('tree', 'flower')
# 实例化
> t = Spring()
> t.__slots__
('tree', 'flower')

# 通过类赋予属性值
> Spring.tree = "liushu"
# tree这个属性是只读的, 实例不能修改
> t.tree = "guangyulan"
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
AttributeError: 'Spring' object attribute 'tree' is read-only
> t.tree
'liushu'

# 对于用类属性赋值的属性，只能用来修改
> Spring.tree = "guangyulan"
> t.tree
'guangyulan'

# 对于没有用类属性赋值的属性，可以通过实例来修改
> t.flower = "haitanghua"
> t.flower
'haitanghua'
# 实例属性的值并没有传回到类属性，你也可以理解为新建立了一个同名的实例属性
> Spring.flower
<member 'flower' of 'Spring' objects>
# 如果再给类属性赋值
> Spring.flower = "ziteng"
> t.flower
'ziteng'

__setattr__(self,name,value)：如果要给 name 赋值，就调用这个方法。
__getattr__(self,name)：如果 name 被访问，同时它不存在的时候，此方法被调用。
__getattribute__(self,name)：当 name被访问时自动被调用（注意：这个仅能用于新式类），无论 name 是否存在，都要被调用。
__delattr__(self,name)：如果要删除 name，这个方法就被调用。
> class A(object):
...   def __getattr__(self, name):
...     print "You use getattr"
...   def __setattr__(self, name, value):
...     print "You use setattr"
...     self.__dict__[name] = value
# a.x，按照本节开头的例子，是要报错的。但是，由于在这里使用了__getattr__(self, name) 方法，当发现 x 不存在于对象的__dict__中的时候，就调用了__getattr__，即所谓“拦截成员”。
> a = A()
> a.x
You use getattr

# 给对象的属性赋值时候，调用了__setattr__(self, name, value)方法，这个方法中有一句 self.__dict__[name] = value，通过这个语句，就将属性和数据保存到了对象的__dict__中
> a.x = 7
You use setattr

# 测试__getattribute__(self,name)
> class B(object):
...   def __getattribute__(self, name):
...     print "you are useing getattribute"
...     return object.__getattribute__(self, name)
# 返回的内容用的是 return object.__getattribute__(self, name)，而没有使用 return self.__dict__[name]。因为如果用这样的方式，就是访问 self.__dict__，只要访问这个属性，就要调用`getattribute``，这样就导致了无限递归

# 访问不存在的成员，可以看到，已经被__getattribute__拦截了，虽然最后还是要报错的。
> b = B()
> b.y
you are useing getattribute
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 File "<stdin>", line 4, in __getattribute__
AttributeError: 'B' object has no attribute 'y'

class Vector(object):
  def __init__(self, x, y):
    # 使用两个前导下划线，把属性标记为私有
    self.__x = float(x)
    self.__y = float(y)
  
  # porperty装饰器把读值方法标记为特性
  @property
  def x(self):
    return self.__x
    
  @property
  def y(self):
    return self.__y
    
vector = Vector(3,4)
print(vector.x, vector.y)

class Rectangle(object):
  """
  the width and length of Rectangle
  """
  def __init__(self):
    self.width = 0
    self.length = 0

  def setSize(self, size):
    self.width, self.length = size
  def getSize(self):
    return self.width, self.length

if __name__ == "__main__":
  r = Rectangle()
  r.width = 3
  r.length = 4
  print r.getSize()  # (3,4)
  r.setSize( (30, 40) )
  print r.width  # 30
  print r.length  # 40

class Rectangle(object):
  """
  the width and length of Rectangle
  """
  def __init__(self):
    self.width = 0
    self.length = 0

  def setSize(self, size):
    self.width, self.length = size
  def getSize(self):
    return self.width, self.length
  # 使用property方法将函数封装为属性，更优雅
  size = property(getSize, setSize)

if __name__ == "__main__":
  r = Rectangle()
  r.width = 3
  r.length = 4
  print r.size   # (30, 40)
  r.size = 30, 40
  print r.width  # 30
  print r.length  # 40

class NewRectangle(object):
  def __init__(self):
    self.width = 0
    self.length = 0
  
  def __setattr__(self, name, value):
    if name == 'size':
      self.width, self, length = value
    else:
      self.__dict__[name] = value
      
  def __getattr__(self, name):
    if name == 'size':
      return self.width, self.length
    else:
      raise AttrubuteErrir
      
if __name__ == "__main__":
  r = Rectangle()
  r.width = 3
  r.length = 4
  print r.size   # (30, 40)
  r.size = 30, 40
  print r.width  # 30
  print r.length  # 40

class A(object):
  author = "qiwsir"
  def __getattr__(self, name):
    if name != "author":
      return "from starter to master."

if __name__ == "__main__":
  a = A()
  print a.author # qiwsir
  print a.lang # from starter to master.