实例对象属性寻找的顺序如下：
① 首先访问 getattribute() 魔法方法（隐含默认调用，无论何种情况，均会调用此方法）
② 去实例对象t中查找是否具备该属性： t.dict 中查找，每个类和实例对象都有一个 dict 的属性
③ 若在 t.dict 中找不到对应的属性， 则去该实例的类中寻找，即 t.class.dict
④ 若在实例的类中也招不到该属性，则去父类中寻找，即 t.class.bases.__dict__中寻找
⑤ 若以上均无法找到，则会调用 getattr 方法，执行内部的命令（若未重载 getattr 方法，则直接报错：AttributeError)
以上几个流程，即完成了属性的寻找。
注意: 第④步，一个类一旦重载了 getattribute() 方法，如果找不到属性，则必须要手动加入第④步，否则无法进入到 第⑤步 (getattr)的。可以用super解决
class Test:
def __getattr__(self, name):
print(‘__getattr__‘)
def __getattribute__(self, name):
print(‘__getattribute__‘)
super().__getattribute__(name)
def __setattr__(self, name, value):
print(‘__setattr__‘)
def __delattr__(self, name):
print(‘__delattr__‘)
>>> t=Test()
>>> t.x
__getattribute__
__getattr__
某个类，只要是内部定义了方法 get, set, delete 中的一个或多个，就可以称为描述符
class Desc(object):
def __get__(self, instance, owner):
print("__get__...")
print("self : \t\t", self)
print("instance : \t", instance)
print("owner : \t", owner)
print(‘=‘*40, "\n")
def __set__(self, instance, value):
print(‘__set__...‘)
print("self : \t\t", self)
print("instance : \t", instance)
print("value : \t", value)
print(‘=‘*40, "\n")
class TestDesc(object):
x = Desc()
#以下为测试代码
t = TestDesc()
t.x
#以下为输出信息：
__get__...
self : <__main__.Desc object at 0x0000000002B0B828>
instance : <__main__.TestDesc object at 0x0000000002B0BA20>
owner : <class ‘__main__.TestDesc‘>
注意: 查找顺序问题：当Python解释器发现实例对象的字典中，有与描述符同名的属性时，描述符优先，会覆盖掉实例属性。
属性查询优先级小总结
① getattribute()， 无条件调用
② 数据描述符：由 ① 触发调用 （若人为的重载了该 getattribute() 方法，可能会导致无法调用描述符）
③ 实例对象的字典（若与描述符对象同名，会被覆盖哦）
④ 类的字典
⑤ 非数据描述符
⑥ 父类的字典
⑦ getattr() 方法
__ new __(cls[, ...])
new 是在一个对象实例化的时候所调用的第一个方法
它的第一个参数是这个类，其他的参数是用来直接传递给 init 方法
new 决定是否要使用该 init 方法，因为 new 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 new 没有返回实例对象，则 init 不会被调用
new 主要是用于继承一个不可变的类型比如一个 tuple 或者 string
__ init __(self[, ...])
构造器，当一个实例被创建的时候调用的初始化方法
__ del __(self)
析构器，当一个实例被销毁的时候调用的方法
__ call __(self[, args...])
允许一个类的实例像函数一样被调用：x(a, b) 调用 x.call(a, b)
__ len __(self)
定义当被 len() 调用时的行为
__ repr __(self)
定义当被 repr() 调用或者直接执行对象时的行为
__ str __(self)
定义当被 str() 调用或者打印对象时的行为
__ bytes __(self)
定义当被 bytes() 调用时的行为
__ hash __(self)
定义当被 hash() 调用时的行为
__ bool __(self)
定义当被 bool() 调用时的行为，应该返回 True 或 False
__ format __(self, format_spec)
定义当被 format() 调用时的行为
class Student(object):
def __init__(self, name, scores):
self.name = name
self.scores = scores
# 索引的是学生的成绩
def __getitem__(self, index): # 1).索引值的获取
print(index, type(index))
return self.scores[index]
def __setitem__(self, key, value): # 2). 索引值的重新赋值
self.scores[key] = value
def __delitem__(self, key): # 3). 删除索引值
del self.scores[key]
def __mul__(self, other): # 4). 实现*的效果， 具体返回什么取决于代码的业务需求
"""对于学生的每一门成绩乘3"""
return [i*other for i in self.scores]
def __add__(self, other): # 5). 连接的时候必须是同一种数据；类型
# 将两个学生的成绩拼接起来
return self.scores + other.scores
def __contains__(self, item): # 6). 判断某个元素是否存在于这个对象中?
return item in self.scores
def __iter__(self): # 7). 迭代， 使得该对象可以实现for循环
# 将列表转换为迭代的类型， 可以for循环, 一定要返回iter类型的数据；
return iter(self.scores)
def __lt__(self, other): # 8). 比较两个对象的大小；
return (sum(self.scores)/3) < (sum(other.scores)/3)
liming = Student(‘liming‘, [100, 89, 100])
# # 1).索引值的获取
# print(liming[0])
# print(liming[1])
# print(liming[2])
#
# # 2).索引值的重新赋值
# liming[0] = 90
# print(liming[0])
#
# # 3). 删除索引值
# del liming[0]
# # print(liming[:2])
#
# # 1).切片值的获取
# print(liming[:2])
# print(liming[-2:])
#
#
# # 2).切片值的重新赋值
# liming[:2] = [10, 10]
# print(liming.scores)
#
# # 3). 删除切片值
# del liming[:2]
# print(liming.scores)
#
# # 4). 判断是否可以重复？
# print(liming * 3)
#
# # 5). 连接？
xiaohong = Student(‘小红‘, [100, 90, 90])
# print(xiaohong + liming)
#
#
#
# # 6). 成员操作符? 判断是否在对象里面存在?
# print(100 in xiaohong)
# print(101 in xiaohong)
# print(101 not in xiaohong)
#
#
# # 7). 实现for循环?
# for item in liming:
# print(item)
# 8). 比较对象的大小？
# print(liming > xiaohong)
print(liming < xiaohong)
原文：https://www.cnblogs.com/lyalong/p/14109061.html