Python-面向对象之魔术方法

阅读目录：

　　1、特殊属性：Python的精华之一

　　2、查看属性

　　3、魔术方法

1. 1. 创建，初始化，销毁 （__new__, __init__, __del__）
   2. hash
   3. bool
   4. 可视化
   5. 运算符重载
   6. 可调用对象
   7. 上下文管理
   8. 反射
   9. 描述器
   10. 其他杂项

　　

1、特殊属性：Python的精华之一：

　

属性	含义
__name__	类，函数，方法等的名字，实例没有
__module__	类定义所在的模块名
__class__	对象或类所属的 类
__bases__	类的基类的元组，顺序为它们在基类列表中出现的顺序
__doc__	类，函数的文档字符串，如果没有定义则为None
__mro__	类的mro，class.mro()返回的结果保存在__mro__中
__dict__	类或实例的属性，可写的字典

    测试：

class A:pass

class B(A):
    def bb(self):pass

class C(B, A):
    def cc(self):pass

a = A()
b = B()
c = C()

print(A.__name__)
print(B.__name__)
print(C.__name__)
print(b.bb.__name__)
print('-'*40)
# 因为是在当前类中调用，所以是返回值 __main__
# 如果该模块 a.py 被导入到其他地方，那么打印 就是模块名 a
print(A.__module__)
print(B.__module__)
print(C.__module__)
print('-'*40)
print(A.__bases__)
print(A.__base__)
print(B.__bases__)
print(B.__base__)
print(C.__bases__)
print(C.__base__)
print('-'*40)
print(A.__doc__)
print(a.__doc__)
print(b.bb.__doc__)
print('-'*40)
print(A.mro())
print(A.__mro__)
print(B.mro())
print(B.__mro__)
print(C.mro())
print(C.__mro__)
print('-'*40)
print(A.__dict__)
print(a.__dict__)
print(B.__dict__)
print(b.__dict__)
print(C.__dict__)
print(c.__dict__)

　　结果：

A
B
C
bb
----------------------------------------
__main__
__main__
__main__
----------------------------------------
(<class 'object'>,)
<class 'object'>
(<class '__main__.A'>,)
<class '__main__.A'>
(<class '__main__.B'>, <class '__main__.A'>)
<class '__main__.B'>
----------------------------------------
None
None
None
----------------------------------------
[<class '__main__.A'>, <class 'object'>]
(<class '__main__.A'>, <class 'object'>)
[<class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
(<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
----------------------------------------
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
{}
{'__module__': '__main__', 'bb': <function B.bb at 0x0000000002240268>, '__doc__': None}
{}
{'__module__': '__main__', 'cc': <function C.cc at 0x00000000022402F0>, '__doc__': None}
{}

2、查看属性

    方法————————————————————意义
    __dicr__:(double under ---> dunder,双下划线)
            类或实例的属性不一定都在dict中
            print(dir(ClassName)) ---->属性key，放置在列表中，在dict中没有的，都是从objecct中来的,或者继承下来的
            print(ClassName.__dict__)：

            def __dir__(self):# 返回可迭代对象，但是是实例方法，与类没关系，所以，调用类的dir，并没有覆盖，只有实例调用dir才有变化
                return iterableObj

            print(dir()): 当前作用域的标识符，如果在函数中，就是形参的名称，不管是函数还是方法，一般用在模块上
　　测试：

class A:pass

class B(A):
    def bb(self):pass

class C(B, A):
    def __init__(self):
        self.x = 10
    # def __dir__(self):
    #     pass # return None
    pass

#  类只收集类的属性
print(C.__dict__)
print(dir(C)) # 尽可能收集属性key，dict中的也收集过来，还会收集跟当前对象继承的类的属性也会收集过来
###############################################
print('-' * 40)
# 注意self，只影响实例，不影响 类！
# 收集实例的属性，包括类，继承的类的属性
# 没有提供 __dir__(self)
c = C()
print(c.__dict__)
print(dir(c)) # 等价 c.__dir__()
# 提供 __dir__(self)
# def __dir__(self):
    #     pass # return None --------> 报错,要一个可迭代对象
    #     return ('a','b','c') -----> ['a','b','c']
###############################################
print('-' * 40)
# 收集当前作用域的标识符，如果在函数中，就是形参的名称，不管是函数还是方法，一般用在模块上
print(dir()) #而且，只会打印之前的，之后的不会收集到
def foo():
    print(dir())
foo()

def foo(a):
    print(dir())
foo(1)
# 如果a.py被导入，在被导入的地方，a.py中的内容会重载一次，该运行的云行一次，该打印的也会打印
# 在被导入的地方，执行dir(a) 把模块a中的属性（标识符）都打印
# 如果被导入的地方执行dir()， 模块名a 也会被收集
# 如果 from a import C 执行dir()，C也会被收集到，这样就可以用这个类C，否则无法使用
###############################################
print('-' * 40)
c = C()
print(c.__dir__())
# 因为字典的key是类set，所以可以 并集
print(object.__dict__.keys() | c.__class__.__dict__.keys() | c.__dict__.keys())
# 可以看到，两者结果差不多，所以实例收集到的就是这些东西的并集

　　结果：

{'__module__': '__main__', '__init__': <function C.__init__ at 0x00000000029502F0>, '__doc__': None}
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bb']
----------------------------------------
{'x': 10}
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bb', 'x']
----------------------------------------
['A', 'B', 'C', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'c']
[]
['a']
----------------------------------------
['x', '__module__', '__init__', '__doc__', 'bb', '__dict__', '__weakref__', '__repr__', '__hash__', '__str__', '__getattribute__', '__setattr__', '__delattr__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__new__', '__reduce_ex__', '__reduce__', '__subclasshook__', '__init_subclass__', '__format__', '__sizeof__', '__dir__', '__class__']
{'__repr__', '__class__', '__ge__', '__subclasshook__', '__sizeof__', '__hash__', '__le__', '__setattr__', '__reduce_ex__', '__init_subclass__', '__init__', '__module__', '__delattr__', '__new__', '__eq__', '__reduce__', 'x', '__ne__', '__doc__', '__dir__', '__lt__', '__str__', '__gt__', '__format__', '__getattribute__'}

　　总结：
　　　　__dir__:
　　　　　　　　返回类或者对象的所有成员名称列表，dir（）函数就是调用__dir__（）
　　　　　　　　使用实例调用时，如果提供__dir__()，则返回其返回值，要求是可迭代对象
　　　　　　　　如果没有提供__dir__()，则会从实例和类及祖先类中收集信息
　　　　如果dir([obj])参数obj包含方法__dir__() ，该方法将被调用，如果参数obj不含__dir__ ，该方法将最大限度的收集属性信息
　　　　dir(obj) 对于不同类型的对象obj具有不同的行为。

• • • 如果对象是模块对象，返回的列表包含模块的属性名和变量名
    • 如果对象是类型或者类对象，返回的列表包含类的属性名，及它的基类属性名
    • 如果obj 不写，返回列表包含内容不同
      • 在模块中，返回模块的属性和变量名
      • 在函数中，返回本地作用域的变量名
      • 在方法中，返回本地作用域的变量名

3、魔术方法： 处理new是与cls有关，其他的都是属于实例的方法        

　　分类：

1. 1. 创建，初始化，销毁 （__new__, __init__, __del__）
   2. hash
   3. bool
   4. 可视化
   5. 运算符重载
   6. 可调用对象
   7. 上下文管理
   8. 反射
   9. 描述器
   10. 其他杂项

    ①、创建，初始化，销毁：
        __new__:目前写法固定，一般不用自定义,是staticmethod，元类编程时用
　　　　

def __new__(cls, *args, **kwargs):
     return super().__new__(cls)

　　　     

　　　　②、   hash：

class A:pass

class B(A):pass

class C(B):
    def __hash__(self):
        # return 'abc' # 这种是抛异常的，因为hash 返回的是一个数字
        return  hash('abc')
    def __init__(self, name):
        self.name = name
        print("__________________")


c = C('tom')
print(hash(c))

　　　　总结：
　　　　　　hash(z) z 都一样，求得hash应该不变的，幂等性，一般来说，z 不一样，hash应该不一样
                    不同的hash算法，都有hash冲突（因为只有一个hash空间)，不同的z求得同样的hash值。
                    hash空间满了，就会出现hash冲突。
                    出现冲突后，要考虑去重了，如果出现冲突，判断是否eq，如果eq是相等，返回True就会去重。
                    先说hash，再说eq

                    如果不提供hash 和 eq 就用object的hash，但是使用的是内存地址求hash的
                    如果提供eq，不提供hash，默认是hash返回值是None，也就是 不可hash，这个时候提供一个hash方法就可以
                    提供一个__hash__ = None ，就不可hash，list就是这样实现不可hash的

                    如果只提供hash，冲突就用到eq处理，是否相等，再去重


                    先比较is， 在比较== ，is相等，内存地址都一样，就没必要再看==了

         　因此，一般来说，提供__hash__方法是为了作为set或者dict的key，所以去重要同时提供EQ方法
　　　　　　　不可hash对象  isinstance(p1, collections,Hashable) 一定是False
　　　　　　　去重 需要提供__eq__方法
　　　　　　　　　　　　
　　　　　　　　　　　

      ③、bool:
　　　　　　　__bool__内建函数bool()，或者对象放在逻辑表达式的位置，调用这个函数返回布尔值
　　　　　　　　　　　　如果没有定义__bool__（self），就找len()返回长度，非 0 为真，
　　　　　　　　　　　　如果__len__（self）也没有定义，那么所有实例都返回真
            　　　　　如果有，__bool__(self)  类 真， 实例，看里边返回什么（True 还是False，只能返回布尔值)
                     __len__（self）return 整数>=0或者布尔值
                     有了bool 就不看len！，全没有，都是真。
　　　　　　　　　　　　如果len都是等价True，那就看bool返回什么



       ④、可视化：
                __repr__（self）必须是字符串
　　　　　　　　　　　　内建函数repr（）对一个对象获取字符串表达
　　　　　　　　　　　　调用__repr__方法返回字符串表达式，如果__repr__也没有定义，就直接返回object的定义就显示内存地址信息
　　　　　　　　　　　　如果只提供repr，都转为repr
                __str__(self)
　　　　　　　　　　　　str() 函数，format() 函数，print()函数调用，需要返回对象的字符串表达，如果没有定义，就去调用__repr__方法，
　　　　　　　　　　　　返回字符串表达，如果__repr__没有定义，返回内存地址信息
                    直接作用到实例上，用str ，如果没有str，都是repr，如果没有repr，该找str的找str，找repr的如果找不到就去找object，打印内存地址
                    如果都没有，找到的都是内存地址，去父类，或object找的。

                __bytes__(self) return  bytes类型
　　　　　　　　　　　　bytes() 函数调用，返回一个对象的bytes表达，即返回bytes对象
　　　　　　测试：

class A:
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return 'repr name={}'.format(self.name)

    def __str__(self):
        return 'str name={}'.format(self.name)

    def __bytes__(self):
        return self.name.encode()

print(A)
print(A('tom'))
print(str(A('tom')))
print("{}".format(A('jerry')))

print(1,repr(A('tom')))
print(2,repr('{}'.format(A('jerry')))) # 因为先format的,所以先调用str

a = A('tom')
print([a,a]) # print，没有直接作用到实例上
print(str({a, a})) # print，没有直接作用到实例上
print('{}'.format(*{a, a})) # *{a, a} 参数解析 先去重，*{a} 还是a，format直接作用上去

print(bytes(a))

　　　　　　结果：

<class '__main__.A'>
str name=tom
str name=tom
str name=jerry
1 repr name=tom
2 'str name=jerry'
[repr name=tom, repr name=tom]
{repr name=tom}
str name=tom
b'tom'

　　　　注：不能通过print输出，来判断类型，类型判断要用 type 或isinstance


     ⑤、运算符重载：
　　
　　　　　　 __iadd__ 这里的i  就地修改，其他 i也是该意思

            不同类型之间是可以==比较的。

            没有定义的话，是不可以比较大小的，报错

　　　　　　 虽然可以返回其他类型，但是一般返回本类型
　　测试1：减法实现

class A:
    def __init__(self, name, age=18):
        self.name = name
        self.age  = age

    def __sub__(self, other):
        return self.age - other.age

tom = A('tom')
jerry = A('jerry', 20)

# 实现了实例减法
print(tom - jerry)

# 这相当于 tom被重新赋值了，因为没有提供isub
tom -= jerry
print(tom) # -2

###################################################3

class A:
    def __init__(self, name, age=18):
        self.name = name
        self.age  = age

    def __sub__(self, other):
        return self.age - other.age # 这里可以使用-号 是因为作用到age上，而不是self本身上，所以不会出现自己调自己

    def __isub__(self, other):
        return A(self.name,self- other) # 这里调用了sub

tom = A('tom')
jerry = A('jerry', 20)

# 实现了实例减法
print(tom - jerry)

# 这调用了isub 返回一个新的A 实例赋值给tom
# 当然直接使用sub 也可以返回一个A 实例，活学活用
tom -= jerry
print(tom) # -2

　　结果：

-2
-2
-2
<__main__.A object at 0x0000000002928668>

　　测试2：比较大小，使用装饰器，只需要提供两个 比较符号

from functools import total_ordering

@total_ordering
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __hash__(self):
        return hash((self.x , self.y))



    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Point(x, y)

    def __sub__(self, other):
        x = self.x - other.x
        y = self.y - other.y
        return Point(x, y)

    def distance(self):
        pass

    def __eq__(self, other):
        return True
        # if self.x == other.x and self.y == other.y:
        #     return  True
        # else:
        #     return False
    def __gt__(self, other):#这里只是为了测试，数学上比较大小是不对的
        return self.x > other.x

p1 = Point(1,2)
p2 = Point(3,4)
p3 = Point(1,2)

# z调用eq,只能解决等 或 不等，不能解决 谁大谁小
print(p1 == p2)
print(p1 != p2)
print(p1 >= p2)
print(p1 <= p2)
print(p1 > p2)
print(p1 < p2)

　　结果：

True
False
True
True
False
False

　　测试3：不是用装饰器，只需要三个比较符

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __hash__(self):
        return hash((self.x , self.y))



    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Point(x, y)

    def __sub__(self, other):
        x = self.x - other.x
        y = self.y - other.y
        return Point(x, y)

    def distance(self):
        pass

    def __eq__(self, other):
        return True
        # if self.x == other.x and self.y == other.y:
        #     return  True
        # else:
        #     return False
    def __gt__(self, other):#这里只是为了测试，数学上比较大小是不对的
        return self.x > other.x

    def __ge__(self, other):
        return self.x >= other.x

p1 = Point(1,2)
p2 = Point(3,4)
p3 = Point(1,2)

# z调用eq,只能解决等 或 不等，不能解决 谁大谁小
print(p1 == p2)
print(p1 != p2)
print(p1 >= p2)
print(p1 <= p2)
print(p1 > p2)
print(p1 < p2)

　　结果

True
False
False
True
False
True

　　　　　　总结：
　　　　　　　　往往是用面向对象实现类的，需要做大量的运算，而运算符是这种运算在数学上最常见的表达方式
　　　　　　　　通过重载，重新定义 Point + Point
　　　　　　　　提供运算符重载，比直接提供加法方法更加合适该领域内使用者的习惯
　　　　　　　　int类 几乎实现了所有操作符，可以参看
　　　　　　　　只需要三个，是因为，大于可以推断小于等于，以此类推。。。。。。

　　　⑥容器相关方法：
　　

方法	意义
__len__	内建函数len()，返回对象的长度 >= 0，如果把对象当做容器类型看，就如同list或者dict，bool()函数调用的时候，如果没有__bool__（）方法，则会看__len__（）方法是否存在，存在返回非0 为真
__iter__	迭代容器，调用，返回一个新的迭代器对象
__contains__	in成员运算符，没有实现，就调用__iter__方法遍历，所以，可以不实现
__getitem__	实现self[key] 访问，序列对象，key接受整数位索引，或者切片，对于set 和dict，key为hashbale，key不存在引发 KeyError异常
__setitem__	和__getitem__的访问类似，是设置的方法
__missing__	字典或其子类使用__getitem__（）调用时，key不存在执行该方法

　　测试：

class A(dict):
    def __missing__(self, key):
        print('missing key', key)
        return 0

a = A()
print(a['k']) # 如果没有missing方法，报KeyError
print(a.get('k'))

　　结果：

missing key k
0
None

　　空list，set，dict，str等效False：
　　　　　　因为为空，不实现bool（），往往实现len()返回为0 等效False

　　举例：购物车作为容器：

class Cart:
    def __init__(self):
        self.item = []

    def additem(self, item):
        self.item.append(item)

    def getallitem(self):
        return self.item

    def __getitem__(self, index):
        return self.item[index]

    def __iter__(self):
        yield from self.item
        #return iter(self.item)

    def __setitem__(self, key, value):
        self.item[key] = value

    def __str__(self):
        return '{}'.format(self.item)

    def __len__(self):
        return len(self.item)

    def __bool__(self):
        return True

    def __add__(self, other): # car + 5
        self.item.append(other)
        return self



c = Cart()
c.additem(1)
c.additem(2)
c.additem(3)
c.additem(4)


print('----',len(c))
print('++++',bool(Cart))
print(bool(c))

for x in c:
    print(x)

print(3 in c) #  __iter__  不需要contaions


print(c[1]) # getitem

c[2] = 'sdasda' # setitem
print(c)

# 链式加法
print(c + 6)
print(c + 7 + 8 + 9)
print(c.__add__(20).__add__(22))

　　结果：

++++ True
True
1
2
3
4
True
2
[1, 2, 'sdasda', 4]
[1, 2, 'sdasda', 4, 6]
[1, 2, 'sdasda', 4, 6, 7, 8, 9]
[1, 2, 'sdasda', 4, 6, 7, 8, 9, 20, 22]

　　　　⑦ 、可调用对象：

　　　　Python中一切皆对象，函数也不例外。　　　　

def foo():
    print(foo.__module__, foo.__name__)

foo()

#等价于

foo.__call__()

　　　　函数即对象，对象foo加上（），就是调用此函数对象的__call__（）方法
　　　　可调用对象：
　　　　　　

方法	意义
__call__	类中定义一个该方法，实例就可以向函数一样调用

　　可调用对象：定义一个类，并实例化得到其实例，将实例像函数一样调用。

举例：

　　举例：定义一个斐波那契数列，方便调用，计算第n项，并实现了长度，迭代，支持索引

class Fib:
    def __init__(self):
        self.items = [0, 1, 1] # 而且使用了缓存

    def __call__(self, index):
        if index >= len(self.items):#但是注意长度，否则f(10)之后再f(4) 还会执行append
            for i in range(3, index + 1):
                self.items.append(self.items[i-1] + self.items[i-2])
        return self.items[index]

    def __iter__(self):
        yield  from self.items

    def __len__(self):
        return len(self.items)

    def __getitem__(self, item):
        return self.items[item]

    def __str__(self):
        return str(self.items)



f = Fib()
print(f(10))
print(f.items)
28 print(f(4))注意这两项，一个是可调用， 一个是支持索引
29 print(f[4])
print(f.items)
print(len(f))

　　　　⑧、上下文管理：

    　　class A:
        　　pass
    　　with A() as f:
        　　print(f)

    　　　　　　　　3.6 提示少 __enter__， 之前的提示 __exit__，正常情况下，两个一起用
　　
　　
    pt = Point()
    with pt as f:
        print(pt == f)
    如果使用as， 则f 其值为enter的返回值
　　

    参数问题：
        enter方法不可添加参数，因为传不进去，传进去给谁啊？？？，所以。。。。

        exit的参数：excption
               exc_type
               exc_val
               exc_tb
               做一些清理工作

               retrun一个等效True，就可以压制异常，
看图：

        有没有as，都会调 enter  exit，但是里边没法引用，只有with知道，所以给了一个as
        但是这个as，要看enter的返回值怎么写，如果是self，就是实力本身。


        enter做资源申请，exit 做一些清理工作   （区别__del__做资源清零工作）

        实例化，和 实力消亡是一次性的，分别创建和消亡是调用，而with语法可以对一个实例操作很多次。

        使用exit ，保证资源的释放，下次很久之后，再次使用这个对象，在这段长时间中，也不会占用这个资源，比如，文件
　　　　　　但是del，直接消亡了，必须重新实例化。

　　　　上下文管理对象：
　　　　　　当一个对象同时实现了 __enter__  和 __exit__ 方法，它就属于上下文管理的对象
　　　　　　
　　　　　　　enter 和 exit 都是在执行with语句的时候才会执行。
　　　　　　　　
　　　　　　　with可以开启一个上下文运行环境，在执行前做一些准备工作，执行后做一些首尾工作、
　　　　　　
　　　　　　　　注：with 并不开启一个新的作用域。
　　　　

　　　　　　即便调用 sys.exit(100)   0-256,它会退出当前解释器，直接敲，窗口会关闭，但是
　　　　　　遇到with，依然还是会执行 exit语句


　　举例： 类做装饰器，类装饰器和函数装饰器同时使用顺序问题！！！！

####################################################################

import  time
import datetime
from  functools import wraps, update_wrapper

def timeit(fn):
    @wraps(fn)#  update_wrapper(wapper)(fn)
    def wrapper(*args, **kwargs):
        start = datetime.datetime.now()
        ret = fn(*args, **kwargs)
        delta = (datetime.datetime.now() - start).total_seconds()
        print(delta)
        return ret
    return wrapper

@timeit
def add(x, y):
    time.sleep(1)
    return x + y

#####################################################################
class TimeIt:
    def __init__(self):
        pass

    def __enter__(self):
        self.start = datetime.datetime.now()
        return  self

    def __exit__(self, exc_type, exc_val, exc_tb):
        delta = (datetime.datetime.now() - self.start).total_seconds()
        print(delta)

with TimeIt() as f:
    print('*', add(4, 5))
    # 此 add 非彼 add，这里只看print('*', add(4, 5))执行了多少秒，
    # 也就是with开始后，进入enter到退出exit执行了多少秒
######################################实现对象的可调用################################
class TimeIt:
    def __init__(self, fn):
        self.fn = fn

    def __enter__(self):
        self.start = datetime.datetime.now()
        return  self

    def __exit__(self, exc_type, exc_val, exc_tb):
        delta = (datetime.datetime.now() - self.start).total_seconds()
        print(delta)

    def __call__(self, *args, **kwargs):
        return self.fn(*args, **kwargs)

f = TimeIt(add)
print('*', f(4, 5))

######################################类作为装饰器################################

class TimeIt:
    def __init__(self, fn):
        self.fn = fn

    def __enter__(self):
        self.start = datetime.datetime.now()
        return  self

    def __exit__(self, exc_type, exc_val, exc_tb):
        delta = (datetime.datetime.now() - self.start).total_seconds()
        print(delta)

    def __call__(self, *args, **kwargs):
        start = datetime.datetime.now()
        ret = self.fn(*args, **kwargs)
        delta = (datetime.datetime.now() - start).total_seconds()
        print(delta)
        return ret

@TimeIt # add=TimeIt(add) 一看发现 是 实例化
def add(x, y):
    time.sleep(1)
    return x + y

add(4, 5) # 相当于实例 调用，如果作为一个计时器的还，进调用开始计时，退出调用，结束计时

##################  处理字符串文档  ################################
class TimeIt:
    ''' this is class'''
    def __init__(self, fn):
        # 方法 1
        # self.__doc__ = fn.__doc__
        # self.__name__ = fn.__doc__
        # 方法 2
        # update_wrapper(self, fn)
        # 方法 3 这里并不是装饰器，使用的是等价方式。
        wraps(fn)(self)
        self.fn = fn

    def __enter__(self):
        self.start = datetime.datetime.now()
        return  self

    def __exit__(self, exc_type, exc_val, exc_tb):
        delta = (datetime.datetime.now() - self.start).total_seconds()
        print(delta)

    def __call__(self, *args, **kwargs):
        start = datetime.datetime.now()
        ret = self.fn(*args, **kwargs)
        delta = (datetime.datetime.now() - start).total_seconds()
        print(delta)
        return ret

@TimeIt # add=TimeIt(add) 一看发现 是 实例化
def add(x, y):
    '''this is add function'''
    time.sleep(1)
    return x + y

print(add.__doc__)


# 此时，上面这个例子的类，可以做装饰器，又可以用在上下文管理。都实现了同样的功能




############# 两个装饰器同时使用 ############################
import  time
import datetime
from  functools import wraps, update_wrapper

def timeit(fn):
    @wraps(fn)#  update_wrapper(wapper)(fn)
    def wrapper(*args, **kwargs):
        start = datetime.datetime.now()
        ret = fn(*args, **kwargs)
        delta = (datetime.datetime.now() - start).total_seconds()
        print('{}  tooks {}'.format(fn.__name__, delta), '==+++++++=')
        return ret
    return wrapper

class TimeIt:
    def __init__(self, fn):
        self.__fn = fn

    def __call__(self, *args, **kwargs):
        start = datetime.datetime.now()
        ret = self.__fn(*args, **kwargs)
        delta = (datetime.datetime.now() - start).total_seconds()
        print('{}  tooks {}'.format(self.__fn.__name__, delta), '===============')
        return ret

@timeit #  add=timeit(add)=wrapper
@TimeIt # add=TimeIt(add)
def add(x, y):
    '''this is add function'''
    time.sleep(1)
    return x + y

add(4, 5)

　　　　　　如下是正确的：因为通过wraps装饰器，给self提供了一个__name__属性

import  time
import datetime
from  functools import wraps, update_wrapper

def timeit(fn):
    @wraps(fn)#  update_wrapper(wapper)(fn)
    def wrapper(*args, **kwargs):
        start = datetime.datetime.now()
        ret = fn(*args, **kwargs)
        delta = (datetime.datetime.now() - start).total_seconds()
        print('{}  tooks {}'.format(fn.__name__, delta), '==+++++++=')
        return ret
    return wrapper

class TimeIt:
    def __init__(self, fn):
        wraps(fn)(self) # self.__name__ = fn.__name__   这是 给了实例一个__name__属性
        self.__fn = fn

    def __call__(self, *args, **kwargs):
        start = datetime.datetime.now()
        ret = self.__fn(*args, **kwargs)
        delta = (datetime.datetime.now() - start).total_seconds()
        print('{}  tooks {}'.format(self.__fn.__name__, delta), '===============')
        return ret

@timeit #  add=timeit(add) # 此时， add是一个实例
@TimeIt # add=TimeIt(add) 一看发现 是 实例化
def add(x, y):
    '''this is add function'''
    time.sleep(1)
    return x + y

add(4, 5)

　　　　　　　　上下文应用场景：

1. 1. 1. 增强功能：在代码执行的前后增加代码，以增强其功能，类似装饰器的功能
      2. 资源管理：打开了资源管理需要关闭，例如文件对象，网络连接，数据库连接
      3. 权限验证：在执行代码之前，做权限的验证，在__enter__中处理　　

　　　　　** contextlib.contextmanager　　　
　　　　　　　　它是一个装饰器实现上下文管理，装饰一个函数，而不用像类一样实现__enter__和__exit__方法
　　　　　　　　对下面的函数要求，必须有yield，也就是这个函数必须返回一个生成器，且只有yield一个值
　　　　　　　　也就是这个装饰器接受一个生成器对象作为参数。

　　　　　　举例：

import contextlib

@contextlib.contextmanager
def foo():
    print('enter')
    yield
    print('exit')

with foo() as f:
    print(f)
print('-----------------------------')
@contextlib.contextmanager
def foo():
    print('enter')
    yield 5
    print('exit')

with foo() as f:
    print(f)

　　　　　　结果：

enter
None
exit
-----------------------------
enter
5
exit

        只要后面能加括号就能调用！！！！！！

        inspect他看一下类的签名，可调用对象才有签名

　　⑨、反射：
　　　　概念：
　　　　　　运行时区别于编译时，指的是程序被加载到内存中执行的时候。
　　　　　　反射，reflection，指的是运行时获取类型定义信息。
　　　　　　一个对象能够在运行时，能够像照镜子一样，反射出其类型信息。
　　　　　　简单说在Python中，能够通过一个对象，找出其type，class，attribute，或method的能力
　　　　　　称为反射或者自省
　　　　　　具有反射能力的函数有，type(), isinstance(),callable(),dir(),getattr()
　　    编译时：

   　　 运行时：

        解释器直接运行，或者 转换为.exe 文件直接运行。

　　　　反射相关的函数和方法：
　　　　　　需求：有一个Point类，查看他的属性，并修改它，动态为实例增加属性
　　　　　　测试：

########################################### 简单的使用内建函数 ####################################
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return 'Point {}, {}'.format(self.x, self.y)

p = Point(4, 5)
print(p)
print(p.__dict__)
p.__dict__['y'] = 16
print(p.__dict__)
print(dir(p)) #  拿到的都是字符串
print(p.__dir__())

print('-' * 40)
for n in dir(p):
    print(getattr(p, n)) # p.n的意思，但是n是字符串，只不过通过点调用不用加引号
    print()

print('-' * 40)
if hasattr(p, 'x'):
    print(getattr(p, 'y'))

print(getattr(p, 'o', 100000))# 如果没有可以提供一个默认值

setattr(p, 'b', 1000)
print(p.__dict__)

　　　　　　结果:

D:python3.7python.exe E:/code_pycharm/code_test_daye/a测试.py
Point 4, 5
{'x': 4, 'y': 5}
{'x': 4, 'y': 16}
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'x', 'y']
['x', 'y', '__module__', '__init__', '__str__', '__dict__', '__weakref__', '__doc__', '__repr__', '__hash__', '__getattribute__', '__setattr__', '__delattr__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__new__', '__reduce_ex__', '__reduce__', '__subclasshook__', '__init_subclass__', '__format__', '__sizeof__', '__dir__', '__class__']
----------------------------------------
<class '__main__.Point'>

<method-wrapper '__delattr__' of Point object at 0x0000000001D65400>

{'x': 4, 'y': 16}

<built-in method __dir__ of Point object at 0x0000000001D65400>

None

<method-wrapper '__eq__' of Point object at 0x0000000001D65400>

<built-in method __format__ of Point object at 0x0000000001D65400>

<method-wrapper '__ge__' of Point object at 0x0000000001D65400>

<method-wrapper '__getattribute__' of Point object at 0x0000000001D65400>

<method-wrapper '__gt__' of Point object at 0x0000000001D65400>

<method-wrapper '__hash__' of Point object at 0x0000000001D65400>

<bound method Point.__init__ of <__main__.Point object at 0x0000000001D65400>>

<built-in method __init_subclass__ of type object at 0x0000000000482AC8>

<method-wrapper '__le__' of Point object at 0x0000000001D65400>

<method-wrapper '__lt__' of Point object at 0x0000000001D65400>

__main__

<method-wrapper '__ne__' of Point object at 0x0000000001D65400>

<built-in method __new__ of type object at 0x000007FEE0208EC0>

<built-in method __reduce__ of Point object at 0x0000000001D65400>

<built-in method __reduce_ex__ of Point object at 0x0000000001D65400>

<method-wrapper '__repr__' of Point object at 0x0000000001D65400>

<method-wrapper '__setattr__' of Point object at 0x0000000001D65400>

<built-in method __sizeof__ of Point object at 0x0000000001D65400>

<bound method Point.__str__ of <__main__.Point object at 0x0000000001D65400>>

<built-in method __subclasshook__ of type object at 0x0000000000482AC8>

None

4

16

----------------------------------------
16
100000
{'x': 4, 'y': 16, 'b': 1000}

Process finished with exit code 0

　　　　　　测试2：给实例，类分别动态添加属性

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

setattr(Point, 'show', lambda self:print(self.x, self.y)) # 定义一个类属性

p = Point(4, 5)

p.show() # 或者
getattr(p, 'show')()

setattr(p, 'show', lambda self:print(self, '---------'))# 在实例上定义了一个方法
getattr(p, 'show')(p) # p.show(p) # 可以看出，定义在实例上，没有绑定实例需要手动传入

　　　　　　结果2：

D:python3.7python.exe E:/code_pycharm/code_test_daye/a测试.py
4 5
4 5
<__main__.Point object at 0x0000000002978320> ---------

Process finished with exit code 0

　　   　　这种动态增加属性的方式 和装饰器修饰一个类，Mixin方式的差异

　　　　　装饰器和Mixin 定义时决定，而且不能修改实例属性而反射，可以运行时定义，修改类 或 实例的属性。

　　　　　装饰器在定义时，加载到内存中的时候，就已经将原函数修饰了

　　　　　Mixin类，是一种继承类，需要之前就定义好。对一些方法增强或者覆盖掉了。

　　　　　这种动态增删属性的方式，是运行时改变类或者实例的方式。
　　
　　　　　　因此，反射能力具有更大的灵活性。
　　
　　　　　　在 if __name__ == '__main__': 下面可以对类进行属性的增删，但是添加装饰器？？Mixin类？？肯定不行啊！！！！

　　　　举例：使用类封装实现一个命令分发器：

########################### 命令分发器#################################
# 简单实现 函数注册，并且传入参数
class Dispatcher:
    def __init__(self):
        pass

    def reg(self, cmd, fn):
        setattr(self, cmd, fn)

    def run(self, *args, **kwargs):
        while True:
            cmd = input('>>>').strip()
            if cmd == '':
                break
            else:
                getattr(self, cmd, lambda :print('unkonw'))(*args, **kwargs)

def add(x, y):
    print(x + y)

def sub(x, y):
    print(x - y)

dis = Dispatcher()
dis.reg('add', add)
dis.reg('sub', sub)
dis.run(4, y = 5)

# # 实现函数注册，并且传入参数
class Dispatcher:
    def __init__(self):
        # self.commands = {}
        pass

    def reg(self, cmd):# 风险，万一人家实例本身有相同的属性名，这样就会冲突，覆盖，最好的方式是使用一个字典存
        def wrapper(fn):
            setattr(self, cmd, fn)
            return fn
        return wrapper

    def run(self, *args, **kwargs):
        while True:
            cmd = input('>>>').strip()
            if cmd == '':
                break
            else:
                getattr(self, cmd, lambda :print('unkonw'))(*args, **kwargs)

dis = Dispatcher()

# 这样的话，加载的时候，函数已经被注册进去了，运行的时候，根据cmd直接调用
@dis.reg('add') # add = dis.reg('add')(add)
def add(x, y):
    print(x + y)

@dis.reg('sub') # add = dis.reg('add')(add)
def sub(x, y):
    print(x - y)

dis.run(4, y = 5)

　　　　反射相关的魔术方：都是实例相关的与类没有关系 self
　　　　　　　__getattr__, __setattr__, __delattr__

　　　　　　单独使用__getattr__:


　　　　　　　　测试 ：__setattr__


　　　　　　　　容易犯的递归调用！！！！！！！！！！！！
    　　


　　　　　　　　　　　　正常使用：只要是 点 属性的方式，都会到__setattr__设置，包括等价方式setattr(self, 'y', y) #self.y = y
　　
　　　　　　　　　　　　比较灵活的使用：

　　　　　　　　　　
　　　　　　　测试：　__delattr__的使用：


　　　　　　测试：__getattribute__

 
    
　　　　　　总结：

　　　　　　
　　　　　　属性查找顺序：（没有描述器）
　　　　　　　　　实例调用__getattribute__() ---> instance.__dict__ ---> instance.__class__.__dict__
　　　　　　　　　---> 继承的祖先类(直到object)的__dict__ ——> 最后调用__getattr__()

　　　　　　　　　　当找不到属性后，没有__getattr__就抛异常，有，就先不抛，进入，处理之后，如果不需要抛，那就不会再抛异常，如果没处理了，异常抛出去，结束属性查找

　　　　***   前后都有下划线，解释器管的

   　　　　⑩、描述器：Descriptors
　　　　　　描述器的表现：
　　　　用到三个方法：__get__()  __set__(), __delete__()
　　　　　　 测试： 只测get，而且x都是作为类属性来测试

class A:
    def __init__(self):
        print('A() init')
        self.a1 = 100

    def __get__(self, instance, owner):
        print('****************************')
        print(1, self)
        print(1, instance)
        print(1, owner)
        print('****************************')

        return self

    def __set__(self, instance, value):
        print('****************************')
        print(2, self)
        print(2, instance)
        print(2, value)
        print('****************************')

    def __delete__(self, instance):
        print(3, self)
        print(3, instance)

    def __repr__(self):
        return '<A 实例 {}>'.format(self.a1)

class B:
    x = A()
    def __int__(self):
        print('B() init')

print(B.x) # 就会触发__get__
print(B.x.a1)

print('---' * 50)
b = B()
print(b.x)
print(b.x.a1)

　　　　　　　结果：

D:python3.7python.exe E:/code_pycharm/code_test_daye/a测试.py
A() init
****************************
1 <A 实例 100>
1 None
1 <class '__main__.B'>
****************************
<A 实例 100>
****************************
1 <A 实例 100>
1 None
1 <class '__main__.B'>
****************************
100
------------------------------------------------------------------------------------------------------------------------------------------------------
****************************
1 <A 实例 100>
1 <__main__.B object at 0x0000000002938400>
1 <class '__main__.B'>
****************************
<A 实例 100>
****************************
1 <A 实例 100>
1 <__main__.B object at 0x0000000002938400>
1 <class '__main__.B'>
****************************
100

Process finished with exit code 0

　　　　　　

　　　　　　　测试：　非数据描述器

###非数据描述器
class A:
    x = 1000000000
    def __init__(self):
        print('A() init')
        self.a1 = 100

    def __get__(self, instance, owner):
        print('****************************')
        print(1, self)
        print(1, instance)
        print(1, owner)
        print('****************************')
        # return self

    # def __set__(self, instance, value):
    #     print('\\\\\\\\\\\\\\\')
    #     print(2, self)
    #     print(2, instance) # B的实例
    #     print(2, value)
    #     print('\\\\\\\\\\\\\\\')

    def __repr__(self):
        return '<A 实例 {}>'.format(self.a1)

class B:
    x = A()
    def __init__(self):
        print('B() init')
        self.x = 1000

b = B()
print(b.__dict__)
print(B.__dict__)

print(b.x) # 实例的x

print(B.x) # 类的x

非数据描述器，如果类访问 类属性，直接跳到 描述器的get
如果实例调用 ，先找自己有没有，没有在找 类的， 再跳到描述器的get

　　　　　　　结果：

A() init
B() init
{'x': 1000}
{'__module__': '__main__', 'x': <A 实例 100>, '__init__': <function B.__init__ at 0x0000000002960400>, '__dict__': <attribute '__dict__' of 'B' objects>, '__weakref__': <attribute '__weakref__' of 'B' objects>, '__doc__': None}
1000
****************************
1 <A 实例 100>
1 None
1 <class '__main__.B'>
****************************
None

　　　　　　　测试：数据描述器

###################数据描述器

class A:
    x = 1000000000
    def __init__(self):
        print('A() init')
        self.a1 = 100

    def __get__(self, instance, owner):
        print('****************************')
        print(1, self)
        print(1, instance)
        print(1, owner)
        print('****************************')
        return self

    def __set__(self, instance, value):
        print('\\\\\\\\\\\\\\\')
        print(2, self)
        print(2, instance) # B的实例
        print(2, value)
        print('\\\\\\\\\\\\\\\')

    def __repr__(self):
        return '<A 实例 {}>'.format(self.a1)

class B:
    x = A()
    def __init__(self):
        print('B() init')
        self.x = 1000
        self.__dict__['y'] = 20000

b = B()
print(b.__dict__)
print(B.__dict__)


# 实例：
print(b.x ) # 数据描述器，优先使用描述器的 数据
print(b.y) #不同命，正常访问

　　　　　　　　结果：

A() init
B() init
\\\\\\\
2 <A 实例 100>
2 <__main__.B object at 0x0000000002958400>
2 1000
\\\\\\\
{'y': 20000}
{'__module__': '__main__', 'x': <A 实例 100>, '__init__': <function B.__init__ at 0x0000000002950488>, '__dict__': <attribute '__dict__' of 'B' objects>, '__weakref__': <attribute '__weakref__' of 'B' objects>, '__doc__': None}
****************************
1 <A 实例 100>
1 <__main__.B object at 0x0000000002958400>
1 <class '__main__.B'>
****************************
<A 实例 100>
20000

　　　　　总结：

1. 1. 描述器的定义：

   　　　　　　　　只实现了get，就是非数据描述器，实现了，get 和 set 或 delete 就是数据描述器

　　　　　　Python中的描述器：
　　　　　　
　　　　　　　　描述器在 Python中应用非常广泛，Python的方法（包括staticmethod() 和classmethod都实现为非数据描述器，
　　　　　　　　因此，实例可以重新定义和覆盖方法。这允许单个实例获取与同一类的其他实例不同的行为
　　　　　　　　
　　　　　　　　property() 函数实现为一个数据描述器，因此，实例不能覆盖属性的行为，

　　　　实现了：classmethod()， staticmethod()

##### staticmethod
class StaticMethod: # 非数据描述器
    def __init__(self, fn):
        self.fn = fn

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

class B:
    def __init__(self):
        pass

    @StaticMethod # foo = StaticMethod(foo)
    def foo():
        print('static method')


B.foo() # 直接打印

############# classmethod
class ClassMethod: # 非数据描述器
    def __init__(self, fn):
        self.fn = fn

    def __get__(self, instance, owner):
        ret =  partial(self.fn, owner)
        return ret

class B:
    def __init__(self):
        pass

    @ClassMethod # foo = ClassMethod(foo)
    def foo(cls):
        print('class method')


B.foo() # 直接打印

 　　　　　　如果是保护变量，或者 私有变量，直接加到属性列表中