Python学习（十四）—— 高级面向对象程序设计

isinstance(obj,cls)和 issubclass(sub,super)

isinstance(obj,cls)检查对象obj是否是类cls的对象

issubclass(sub,super)检查类sub是否是类super的派生类

#isinstance
class Foo:
    pass
f = Foo()
print(isinstance(f,Foo))
# True

#issubclass
class Bar(Foo):
    pass
print(issubclass(Bar,Foo))
# True

class Foo:
    pass
class Bar(Foo):
    pass
b1 = Bar()
print(isinstance(b1,Foo))
# True
print(type(b1))
# <class '__main__.Bar'>

反射

什么是反射？

反射的概念有Smith在1982年首次提出，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（反省）。这一概念首先被程序语言的设计领域所采用，并在Lisp和面向对象方面取得了成绩。

四个可以实现自省的函数

下列方法适用于类和对象

判断是否包含某个数据属性或函数属性，没有则返回False

class Agency:
    def __init__(self,name,addr):
        self.name =  name
        self.addr = addr

    def sell(self):
        print("%s is selling an apartment"%self.name)

    def rent(self):
        print("%s is renting an apartment" % self.name)

a1 = Agency("Lianjia","downstairs")
print(a1.__dict__)
# {'name': 'Lianjia', 'addr': 'downstairs'}
print(hasattr(a1,"name"))
print(hasattr(a1,"sell"))
# True
# True

查找包含的某个数据属性或函数属性，没有则报错，Default = None

print(getattr(a1,"name"))
print(getattr(a1,"sell"))
func = getattr(a1,"sell")
func()
# Lianjia
# <bound method Agency.sell of <__main__.Agency object at 0x000001D350437C50>>
# Lianjia is selling an apartment
print(getattr(a1,"buy"))
# Wrong

添加或修改某个数据属性或函数属性

setattr(a1,"name","Jinxiu")
print(getattr(a1,"name"))
# Jinxiu
setattr(a1,"run",True)
print(a1.__dict__)
# {'name': 'Jinxiu', 'addr': 'downstairs', 'run': True}

删除某个数据属性或函数属性

delattr(a1,"run")
print(a1.__dict__)
# {'name': 'Jinxiu', 'addr': 'downstairs'}

 为什么需要使用反射？

可以事先定义好接口，接口只在被完成后才会真正执行，这实现了即插即用，其实是一种“后期绑定”。即可以事先将主要逻辑写好（只定义接口），然后后期再去实现接口的功能。

动态导入模块

调到顶层模块

module_m = __import__("m.test")
print(module_m)
# <module 'm' (namespace)> #不管多少层，都返回最顶层模块
module_m.test1()
# Wrong
module_m.test.test1()
# test1

调到所需模块

import importlib
m = importlib.import_module("m.test")
print(m)
# <module 'm.test' from 'D:\PythonStudy\Python全栈\day26\m\test.py'>

类的内置attr属性

class Foo:
    x = 10
    def __init__(self,y):
        self.y = y
    def __getattr__(self,item):
        print("getattr is running")

f = Foo(5)
print(f.x)
print(f.y)
f.selqengelegngq
# 10
# 5
# getattr is running

#删除会触发delattr
class Foo:
    x = 10
    def __init__(self,y):
        self.y = y
    def __delattr__(self,item):
        print("delattr is running")

f = Foo(5)
del f.x
print(f.__dict__)
# delattr is running
# {'y': 5}
del f.y
# delattr is running

# 只要设置属性就会触发，死循环
class Foo:
    x = 10
    def __init__(self,y):
        self.y = y
    def __setattr__(self,key,value):
        # self.key = value 只要设置就会触发，死循环
        self.__dict__[key] = value #新增不会触发
        print("setattr is running")
f1 = Foo(5)
print(f1.__dict__)
# setattr is running
# {'y': 5}
f1.z= 8
print(f1.__dict__)
# setattr is running
# {'y': 5, 'z': 8}

这些属性都是系统内置的，自己定义后会使用自己定义的函数， 否则就使用内置的函数

 二次加工标准类型（包装）

包装：Python为大家提供了标准数据类型，以及丰富的内置方法，其实在很多场景下我们都需要基于标准数据类型来定制我们的数据类型，新增/改写方法，这就用到了我们刚学的继承/派生只是（其他的标准类型均可以通过下面的方式进行二次加工）

class List(list):
    pass
l1 = list("Hello World!")
print(l1,type(l1))
l1 = List("Hello World!")
print(l1,type(l1))
# ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!'] <class 'list'>
# ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!'] <class '__main__.List'>

class List(list):
    def append(self,p_obj):
        if type(p_obj) is str:
            super().append(p_obj) #list.append(self,p_obj)
        else:
            print("Only string input is tactic")

l1 = List("Hello World!")
l1.append("wewn")
print(l1)
# ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!', 'wewn']

授权：授权是包装的一个特性，包装一个类型通常是对已存在的类型的一些定制，这种做法可以新建、修改或删除原有产品的功能。其他的则保持原样。授权的过程，即是所有更新的功能都是由新类的某部分来处理，但已存在的功能就授权给对象的默认属性。

实现授权的关键点就是覆盖__getattr__方法

class FileHandle():
    def __init__(self,filename,mode="r",encoding ="utf-8"):
        self.file = open(filename,mode,encoding=encoding)
        self.mode = mode
        self.encoding = encoding
    def __getattr__(self,item):
        return getattr(self.file,item)

f1 = FileHandle("a.txt","w+")
f1.write("11111
")
print(f1.__dict__)
print("==>",f1.read) #触发__getattr__
# {'file': <_io.TextIOWrapper name='a.txt' mode='w+' encoding='utf-8'>, 'mode': 'w+', 'encoding': 'utf-8'}
# ==> <built-in method read of _io.TextIOWrapper object at 0x00000145B83DC708>

f1.write("abc
")
f1.seek(0)
print(f1.read())
# 11111
# abc

import time
class FileHandle():
    def __init__(self,filename,mode="r",encoding ="utf-8"):
        self.file = open(filename,mode,encoding=encoding)
        self.mode = mode
        self.encoding = encoding
    def __getattr__(self,item):
        return getattr(self.file,item)
    def write(self,item):
        t = time.strftime("%Y-%m-%d %X")
        self.file.write("%s %s"%(t,item))

f1 = FileHandle("a.txt","w+")
f1.write("11111
")
f1.write("x
")
f1.write("y
")
f1.seek(0)
print(f1.read())
# 2020-03-13 20:56:30 11111
# 2020-03-13 20:56:30 x
# 2020-03-13 20:56:30 y

 

__getattribute__

优先级高于__getattr__

class Foo:
    def __init__(self,x):
        self.x = x
    def __getattr__(self,item):
        print("getattr is running")
    def __getattribute__(self,item):
        print("getattribute is running")
f1 = Foo(1)
f1.x
# getattribute is running
f1.y
# getattribute is running

与raise AttributeError 结合使用，可以给getattr传递信息（即调用getattr）

class Foo:
    def __init__(self,x):
        self.x = x
    def __getattr__(self,item):
        print("getattr is running")
    def __getattribute__(self,item):
        print("getattribute is running")
        raise AttributeError("Not Existed")
f1 = Foo(1)
f1.x
# getattribute is running
# getattr is running
f1.y
# getattribute is running
# getattr is running

描述符  

 1 描述符是什么:描述符本质就是一个新式类,在这个新式类中,至少实现了__get__(),__set__(),__delete__()中的一个,这也被称为描述符协议
__get__():调用一个属性时,触发
__set__():为一个属性赋值时,触发
__delete__():采用del删除属性时,触发

class Foo: #在python3中Foo是新式类,它实现了三种方法,这个类就被称作一个描述符
    def __get__(self, instance, owner):
        pass
    def __set__(self, instance, value):
        pass
    def __delete__(self, instance):
        pass

2 描述符是干什么的:描述符的作用是用来代理另外一个类的属性的(必须把描述符定义成这个类的类属性，不能定义到构造函数中)

class Foo:
    def __get__(self, instance, owner):
        print('触发get')
    def __set__(self, instance, value):
        print('触发set')
    def __delete__(self, instance):
        print('触发delete')

#包含这三个方法的新式类称为描述符,由这个类产生的实例进行属性的调用/赋值/删除,并不会触发这三个方法
f1=Foo()
f1.name='egon'
f1.name
del f1.name

#描述符Str
class Str:
    def __get__(self, instance, owner):
        print('Str调用')
    def __set__(self, instance, value):
        print('Str设置...')
    def __delete__(self, instance):
        print('Str删除...')

#描述符Int
class Int:
    def __get__(self, instance, owner):
        print('Int调用')
    def __set__(self, instance, value):
        print('Int设置...')
    def __delete__(self, instance):
        print('Int删除...')

class People:
    name=Str()
    age=Int()
    def __init__(self,name,age): #name被Str类代理,age被Int类代理,
        self.name=name
        self.age=age

#何地？：定义成另外一个类的类属性

#何时？：且看下列演示

p1=People('alex',18)
# Str设置...
# Int设置...

#描述符Str的使用
p1.name
p1.name='egon'
del p1.name
# Str调用
# Str设置...
# Str删除...

#描述符Int的使用
p1.age
p1.age=18
del p1.age
# Int调用
# Int设置...
# Int删除...

#我们来瞅瞅到底发生了什么
print(p1.__dict__)
print(People.__dict__)
# {}
# {'__module__': '__main__', 'name': <__main__.Str object at 0x0000015757DC79E8>, 'age': <__main__.Int object at 0x0000015757DB1E80>, '__init__': <function People.__init__ at 0x0000015766F2A7B8>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}

#补充
print(type(p1) == People) #type(obj)其实是查看obj是由哪个类实例化来的
print(type(p1).__dict__ == People.__dict__)
# True
# True
#疑问:何时,何地,会触发这三个方法的执行

3 描述符分两种
　　—— 数据描述符:至少实现了__get__()和__set__()

class Foo:
    def __set__(self, instance, value):
         print('set')
    def __get__(self, instance, owner):
         print('get')

　　—— 非数据描述符:没有实现__set__()

class Foo: 
    def __get__(self, instance, owner):
        print('get')

4 注意事项:
一、描述符本身应该定义成新式类,被代理的类也应该是新式类
二、必须把描述符定义成这个类的类属性，不能为定义到构造函数中
三、要严格遵循该优先级,优先级由高到底分别是
　　1.类属性

#描述符Str
class Str:
    def __get__(self, instance, owner):
        print('Str调用')
    def __set__(self, instance, value):
        print('Str设置...')
    def __delete__(self, instance):
        print('Str删除...')

class People:
    name=Str()
    def __init__(self,name,age): #name被Str类代理,age被Int类代理,
        self.name=name
        self.age=age


#基于上面的演示,我们已经知道,在一个类中定义描述符它就是一个类属性,存在于类的属性字典中,而不是实例的属性字典

#那既然描述符被定义成了一个类属性,直接通过类名也一定可以调用吧,没错
People.name #恩,调用类属性name,本质就是在调用描述符Str,触发了__get__()

People.name='egon' #那赋值呢,我去,并没有触发__set__()
del People.name #赶紧试试del,我去,也没有触发__delete__()
# Str调用
#结论:描述符对类没有作用-------->错

'''
原因:描述符在使用时被定义成另外一个类的类属性,因而类属性比二次加工的描述符伪装而来的类属性有更高的优先级
People.name #恩,调用类属性name,找不到就去找描述符伪装的类属性name,触发了__get__()

People.name='egon' #那赋值呢,直接赋值了一个类属性,它拥有更高的优先级,相当于覆盖了描述符,肯定不会触发描述符的__set__()
del People.name #同上
'''

　　2.数据描述符

#描述符Str
class Str:
    def __get__(self, instance, owner):
        print('Str调用')
    def __set__(self, instance, value):
        print('Str设置...')
    def __delete__(self, instance):
        print('Str删除...')

class People:
    name=Str()
    def __init__(self,name,age): #name被Str类代理,age被Int类代理,
        self.name=name
        self.age=age


p1=People('egon',18)

#如果描述符是一个数据描述符(即有__get__又有__set__),那么p1.name的调用与赋值都是触发描述符的操作,于p1本身无关了,相当于覆盖了实例的属性
p1.name='egonnnnnn'
p1.name
print(p1.__dict__)#实例的属性字典中没有name,因为name是一个数据描述符,优先级高于实例属性,查看/赋值/删除都是跟描述符有关,与实例无关了
del p1.name
# Str设置...
# Str设置...
# Str调用
# {'age': 18}
# Str删除...

　　3.实例属性

class Foo:
    def func(self):
        print('我胡汉三又回来了')
f1=Foo()
f1.func() #调用类的方法,也可以说是调用非数据描述符
#函数是一个非数据描述符对象(一切皆对象么)
print(dir(Foo.func))
print(hasattr(Foo.func,'__set__'))
print(hasattr(Foo.func,'__get__'))
print(hasattr(Foo.func,'__delete__'))
# 我胡汉三又回来了
# ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
# False
# True
# False
#有人可能会问,描述符不都是类么,函数怎么算也应该是一个对象啊,怎么就是描述符了
#笨蛋哥,描述符是类没问题,描述符在应用的时候不都是实例化成一个类属性么
#函数就是一个由非描述符类实例化得到的对象
#没错，字符串也一样

f1.func='这是实例属性啊'
print(f1.func)
#这是实例属性啊
del f1.func #删掉了非数据
f1.func()
# 我胡汉三又回来了

class Foo:
    def __set__(self, instance, value):
        print('set')
    def __get__(self, instance, owner):
        print('get')
class Room:
    name=Foo()
    def __init__(self,name,width,length):
        self.name=name
        self.width=width
        self.length=length


#name是一个数据描述符,因为name=Foo()而Foo实现了get和set方法,因而比实例属性有更高的优先级
#对实例的属性操作,触发的都是描述符的
r1=Room('厕所',1,1)
r1.name
r1.name='厨房'

class Foo:
    def __get__(self, instance, owner):
        print('get')
class Room:
    name=Foo()
    def __init__(self,name,width,length):
        self.name=name
        self.width=width
        self.length=length


#name是一个非数据描述符,因为name=Foo()而Foo没有实现set方法,因而比实例属性有更低的优先级
#对实例的属性操作,触发的都是实例自己的
r1=Room('厕所',1,1)
r1.name
r1.name='厨房'
# set
# get
# set

　　4.非数据描述符

class Foo:
    def func(self):
        print('我胡汉三又回来了')

    def __getattr__(self, item):
        print('找不到了当然是来找我啦',item)
f1=Foo()

f1.xxxxxxxxxxx
# 找不到了当然是来找我啦 xxxxxxxxxxx

　　5.找不到的属性触发__getattr__()

5 描述符使用

众所周知，python是弱类型语言，即参数的赋值没有类型限制，下面我们通过描述符机制来实现类型限制

#描述符进行类型检测
class Typed:
    def __init__(self,key):
        self.key  = key
    def __get__(self,instance,owner):
        print("get method")
        # print("instance参数[%s]"%instance)
        # print("owner参数[%s]" %owner)
        return instance.__dict__[self.key]
    def __set__(self, instance, value):
        print("set method")
        # print("instance参数[%s]" % instance)
        # print("value参数[%s]" % value)
        if not isinstance(value,str):
            # print("请传入字符串")
            # return
            raise TypeError("你传入的不是字符串")
        instance.__dict__[self.key] = value
    def __delete__(self,instance):
        print("delete method")
        # print("instance参数[%s]" % instance)
        instance.__dict__.pop(self.key)


class People:
    name = Typed("name") #触发了Typed的set
    def __init__(self,name,age,salary):
        self.name = name #触发set
        self.age = age
        self.salary = salary

p1 = People("Jenny",20,30.5)
p1.name
print(p1.name)
# set method
# get method
# get method
# Jenny
print(p1.__dict__)
p1.name  = "ALLY"
print(p1.__dict__)
# {'name': 'Jenny', 'age': 20, 'salary': 30.5}
# set method
# {'name': 'ALLY', 'age': 20, 'salary': 30.5}
del p1.name
print(p1.__dict__)
# delete method
# {'age': 20, 'salary': 30.5}
p1.name = 18
print(p1.__dict__)
# # set method
# # 请传入字符串
# # {'age': 20, 'salary': 30.5}
# set method
#     raise TypeError("你传入的不是字符串")
# TypeError: 你传入的不是字符串

#没有类型检测
# def test(x):
#     print("===>",x)
# test("ally")
# test(1)
# # ===> ally
# # ===> 1

大刀阔斧之后我们已然能实现功能了，但是问题是，如果我们的类有很多属性，你仍然采用在定义一堆类属性的方式去实现

也可以一步到位

class Typed:
    def __init__(self,key,expected_type):
        self.key  = key
        self.expected_type = expected_type
    def __get__(self,instance,owner):
        print("get method")
        # print("instance参数[%s]"%instance)
        # print("owner参数[%s]" %owner)
        return instance.__dict__[self.key]
    def __set__(self, instance, value):
        print("set method")
        # print("instance参数[%s]" % instance)
        # print("value参数[%s]" % value)
        if not isinstance(value,self.expected_type):
            # print("请传入字符串")
            # return
            raise TypeError("你传入的不是",self.expected_type)
        instance.__dict__[self.key] = value
    def __delete__(self,instance):
        print("delete method")
        # print("instance参数[%s]" % instance)
        instance.__dict__.pop(self.key)


class People:
    name = Typed("name",str) #触发了Typed的set
    age = Typed("age", int)
    salary = Typed("salary", float)
    def __init__(self,name,age,salary):
        self.name = name #触发set
        self.age = age
        self.salary = salary

p1 = People("Jenny",20,30.5)
# p2 = People('Arron',"twenty",15)
p3 = People("Fahrenheit",30,"40")

 与装饰器结合使用

class Typed:
    def __init__(self,key,expected_type):
        self.key  = key
        self.expected_type = expected_type
    def __get__(self,instance,owner):
        return instance.__dict__[self.key]
    def __set__(self, instance, value):
        if not isinstance(value,self.expected_type):
            # print("请传入字符串")
            # return
            raise TypeError("%s你传入的不是%s"%(self.key,self.expected_type))
        instance.__dict__[self.key] = value
    def __delete__(self,instance):
        instance.__dict__.pop(self.key)

def deco(**kwargs):
    def wrapper(obj):
        for key,value in kwargs.items():
            setattr(obj,key,Typed(key,value))
        return obj
    return wrapper

@deco(name=str,age=int,gender=str,salary=float)
class People:
    def __init__(self,name,age,gender,salary):
        self.name = name #触发set
        self.age = age
        self.gender = gender
        self.salary = salary

p1 = People("Jenny",20,"female",90)
print(People.__dict__)
p2 = People('Arron',"twenty","male",500)

6 描述符总结

描述符是可以实现大部分python类特性中的底层魔法,包括@classmethod,@staticmethd,@property甚至是__slots__属性

描述父是很多高级库和框架的重要工具之一,描述符通常是使用到装饰器或者元类的大型框架中的一个组件.

7 利用描述符原理完成一个自定制@property,实现延迟计算（本质就是把一个函数属性利用装饰器原理做成一个描述符：类的属性字典中函数名为key，value为描述符类产生的对象）

class Lazyproperty:
    def __init__(self,func):
        print("------",func)
        self.func = func

class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length
    @Lazyproperty #area = Lazyproperty(area)
    def area(self):
        return self.width*self.length
r1 = Room("Bedroom",3,5)
# ------ <function Room.area at 0x000001B7043AA598>

class Lazyproperty:
    def __init__(self,func):
        print("------",func)
        self.func = func
    def __get__(self,instance,owner):
        print("get")
        res = self.func(instance)
        return res
class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length

    @Lazyproperty #area = Lazyproperty(area)
    def area(self):
        return self.width*self.length
r1 = Room("Bedroom",3,5)
print(r1.__dict__)
print(r1.area)
# ------ <function Room.area at 0x000001DA1DA5A620>
# {'name': 'Bedroom', 'width': 3, 'length': 5}
# get
# 15

class Lazyproperty:
    def __init__(self,func):
        self.func = func
    def __get__(self,instance,owner):
        if instance is None:
            return self
        res = self.func(instance)
        setattr(instance,self.func.__name__,res)
        return res
class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length
    @Lazyproperty #area = Lazyproperty(area)
    def area(self):
        return self.width*self.length
r1 = Room("Bedroom",3,5)
print(r1.__dict__)
# {'name': 'Bedroom', 'width': 3, 'length': 5}
print(r1.area)
# 15
print(r1.__dict__)
# {'name': 'Bedroom', 'width': 3, 'length': 5, 'area': 15}

8 利用描述符原理完成一个自定制@classmethod

9 利用描述符原理完成一个自定制的@staticmethod

__enter__和__exit__ 

在操作文件时可以用

with open("a.txt") as f:
   "代码块"

上述叫做上下文管理协议，即with语句，为了让一个对象兼容

with obj ==>触发obj.__enter__(),拿到返回值

as f ===>f = 返回值

with obj as f <===>f = obj.__enter__()

执行代码块：
1、无异常，整个代码块运行完毕后去触发__exit__,它的三个参数都为None

2、有异常，从异常出现的位置直接触发__exit__

　　a.如果__exit__的返回值为True，代表吞掉异常

　　b.如果__exit__的返回值不为True，代表吐出异常

　　c.__exit__运行完毕就代表了整个with语句执行完毕

class Open:
    def __init__(self,name):
        self.name = name
    def __enter__(self):
        print("enter is running")
        return self
    def __exit__(self,exc_type,exc_val,exc_tb):
        print("exit is running")
# f1 = Open("a.txt") 不能这样使用
with Open("a.txt") as f: #触发enter,拿到enter return的结果
    print(f.name)
    print("====>")
    print("====>")
    print("====>")

print("*******")
# enter is running #enter在打开时运行
# a.txt
# ====>
# ====>
# ====>
# exit is running #exit在文件运行后运行
# *******

class Open:
    def __init__(self,name):
        self.name = name
    def __enter__(self):
        print("enter is running")
        return self
    def __exit__(self,exc_type,exc_val,exc_tb):
        print("exit is running")
        print(exc_type)
        print(exc_val)
        print(exc_tb)
# f1 = Open("a.txt") 不能这样使用
with Open("a.txt") as f: #触发enter,拿到enter return的结果
    print(f.name)
    print(f.x)
    print(f)
# exit的三个信息在触发异常时分别代表异常的种类、值和traceback信息
# exit的三个信息在无异常时返回None

加上return True就可以不报错

class Open:
    def __init__(self,name):
        self.name = name
    def __enter__(self):
        print("enter is running")
        return self
    def __exit__(self,exc_type,exc_val,exc_tb):
        print("exit is running")
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        return True #这样就不会报错了
# f1 = Open("a.txt") 不能这样使用
with Open("a.txt") as f: #触发enter,拿到enter return的结果
    print(f.name)
    print(f.x) #触发exit函数了
    print(f) #exit执行完毕就结束了，不会继续运行with语句了
# enter is running
# a.txt
# exit is running
# <class 'AttributeError'>
# 'Open' object has no attribute 'x'
# <traceback object at 0x000001CCFCC810C8>

用途：

1、使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无需手动

2、在需要管理一些资源比如文件、网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，你无需再去关注该问题，大有用处

类的装饰器 

  回顾一下函数装饰器

#函数装饰器
def deco(func):
    print("=====")
    return func
@deco #fun = deco(fun)
def fun():
    print("*****")
# =====
fun()
# *****

类的装饰器

#类装饰器
def deco(obj):
    print("=====")
    return obj

@deco #Foo = deco(Foo)
class Foo:
    print("$$$$$")
f1 = Foo()
print(f1)
# $$$$$
# =====
# <__main__.Foo object at 0x0000024FE9D052B0>

装饰器增强版

def typed(**kwargs):
    def deco(obj):
        for key,value in kwargs.items():
            setattr(obj,key,value)
        return obj
    return deco

@typed(x = 1, y = 2, z= 3) #1.typed(x = 1, y = 2, z= 3) 2.@deco Foo=deco(foo)
class Foo:
    pass
print(Foo.x,Foo.y,Foo.z)
# 1 2 3

@typed(name = "alex")
class Bar:
    pass
print(Bar.name)
# alex

装饰器增强

回到描述器应用

class Typed:
    def __init__(self,key,expected_type):
        self.key  = key
        self.expected_type = expected_type
    def __get__(self,instance,owner):
        return instance.__dict__[self.key]
    def __set__(self, instance, value):
        if not isinstance(value,self.expected_type):
            # print("请传入字符串")
            # return
            raise TypeError("%s你传入的不是%s"%(self.key,self.expected_type))
        instance.__dict__[self.key] = value
    def __delete__(self,instance):
        instance.__dict__.pop(self.key)

def deco(**kwargs):
    def wrapper(obj):
        for key,value in kwargs.items():
            setattr(obj,key,Typed(key,value))
        return obj
    return wrapper

@deco(name=str,age=int,gender=str,salary=float)
class People:
    def __init__(self,name,age,gender,salary):
        self.name = name #触发set
        self.age = age
        self.gender = gender
        self.salary = salary

p1 = People("Jenny",20,"female",90)
print(People.__dict__)
p2 = People('Arron',"twenty","male",500)

结合装饰器应用

getitem 、setitem  和delitem 

item只适合于字典的操作，attr适合用.方式操作

class Foo:
    def __getitem__(self,item):
        print("getitem",item)
    def __setitem__(self,key,value):
        self.__dict__[key]=value
        print("setitem")
    def __delitem__(self,key):
        print("delitem")
        self.__dict__.pop(key)

f = Foo()
f["name"] = "Jenny"
f["age"] = 18
f["gender"] = "female"
print(f.__dict__)
# setitem
# setitem
# {'name': 'Jenny', 'age': 18}
del f.age
print(f.__dict__)
{'name': 'Jenny'}
del f["name"]
# delitem
f.gender
f["gender"]
# getitem gender

 

str和repr 

改变对象的字符串显示，使用print

# 定义str
class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return "名字是%s,年纪是%s"%(self.name,self.age)

f = Foo("Jenny",18)
print(f)
# 名字是Jenny,年纪是18

# 不定义str
class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
f = Foo("Jenny", 18)
print(f)
# <__main__.Foo object at 0x00000242D9E4FB70>

repr用于解释器中

 二者共存的效果

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return self.name
    def __repr__(self):
        return "名字是%s,年纪是%s"%(self.name,self.age)

f = Foo("Jenny",18)  #str(f)= f.__str__ 找不到才=> f.__repr__
print(f)
# Jenny

自定义format

# 不定义自身的format函数
class Date:
    def __init__(self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day
d1= Date(2018,10,26)
x = "{0.year}{0.mon}{0.day}".format(d1)
print(x)
# 20181026

# 定义自身的format函数
format_dic = {
    "ymd":"{0.year}{0.mon}{0.day}",
    "mdy":"{0.mon}:{0.day}:{0.year}",
    "dmy":"{0.day}-{0.mon}-{0.year}"
}
class Date:
    def __init__(self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day
    def __format__(self,format_spec):
        print("running")
        if not format_spec or format_spec not in format_dic:
            format_spec = "ymd"
        fm = format_dic[format_spec]
        return fm.format(self)

d1= Date(2018,10,26)
print(format(d1))
print(format(d1,"mdy"))
# running
# 20181026
# running
# 10:26:2018

slots属性

1.slots是什么？ 是一个类变量，变量值可以是列表、元组或可迭代对象，也可以是一个字符串（意味着所有实例只有一个数据属性）

2.引子：使用点来访问属性本质就是在访问类或者对象的__dict__属性字典（类的字典是共享的，而每个实例的是独立的）

3.为何使用__slots__：字典会占用大量内存，如果你有一个属性很少的类，但是有很多实例，为了节省内存可以使用__slots__取代实例的__dict__。

当你定义__slots__后，__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建，而不是为每个实例定义一个字典，这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给实例添加新的属性了，是能使用在__slots__中定义的那些属性名。

4.注意：__slots__的很多特性都依赖于普通的基于字典的实现。另外，定义了__slots__后的类不再支持一些普通类特性了，比如多继承。大部分情况，你应该只在那些经常被使用到的用作数据结构的类上定义__slots__，比如：在程序中需要创建某个类的几百万个实例对象。

关于__slots__的常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这种目的，但这不是它的使用初衷，更多是作为一个内存优化的工具。

class Foo:
    __slots__ = "name"
f1 = Foo()
f1.name = "Dragon"
print(f1.name)
# Dragon
# f1.age = 18 #已经没有fi.__dict__了
# # Wrong

class Foo:
    __slots__ = ["name","age"]
f1 = Foo()
f1.name = "Dragon"
f1.age = 18
print(f1.__slots__)
print(f1.age)
# ['name', 'age']
# 18
f2 = Foo()
f2.age = 90
print(f2.age)
# 90

doc属性

获取文档信息，该属性无法被继承

class Foo:
    "描述信息"
    pass
print(Foo.__doc__)
# 描述信息

__module__和  __class__ 

__module__查看来自哪个模块

__class__查看来自哪个类

from aa.bb import Foo
f1 = Foo()
print(f1.__module__)
print(f1.__class__)
# ABCD
# aa.bb #模块信息
# <class 'aa.bb.Foo'> #类信息

__del__析构方法 

当对象在内存中被释放时，自动触 发执行。

注：此方法一般无需定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交由Python解释器执行的，所以析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:
    def __init__(self,name):
        self.name = name
    def __del__(self):
        print("del is running")
f1=Foo("alex")
del f1
print("=====>")
# del is running #删除实例所以触发__del__
# =====> #执行完毕继续运行后面的程序

del只在实例被删除的时候被触发，而不是属性被删除就触发

class Foo:
    def __init__(self,name):
        self.name = name
    def __del__(self):
        print("del is running")
f1=Foo("alex")
del f1.name
print("=====>")
# =====> #没有先触发__del__而是先执行后面的程序
# del is running #整个程序执行完毕内存释放所以__del__运行

__call__ 

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名(); 对于__call__方法的执行是由对象后加括号触发的，即：对象()或者类()

class Foo:
    def __call__(self):
        print("ABCD")
f1 = Foo() #创建了实例
f1() # Foo下的__call__
# ABCD

__next__ 和__iter__实现迭代器协议

从迭代器协议讲起

class Foo:
    def __init__(self,n):
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        self.n += 1
        return self.n
f1= Foo(10)
print(f1.__next__())
print(f1.__next__())
print(next(f1))
print(next(f1))
# 11
# 12
# 13
# 14

class Fib:
    def __init__(self):
        self._a = 1
        self._b = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self._a > 100:
            raise StopIteration("终止")
        self._a, self._b = self._b, self._a + self._b
        return self._a
f1 = Fib()
print(next(f1))
print(next(f1))
print(next(f1))
print(next(f1))
print(next(f1))
print(next(f1))
print("====>")
for i in f1:
    print(i)
# 1
# 2
# 3
# 5
# 8
# 13
# ====>
# 21
# 34
# 55
# 89
# 144

property补充

class Foo:
    @property
    def AAA(self):
        print('get AAA')
    @AAA.setter
    def AAA(self,value):
        print("set AAA")
    @AAA.deleter
    def AAA(self):
        print("delete AAA")

f1=Foo()
f1.AAA='aaa'
del f1.AAA
# set AAA
# delete AAA

这种效果也一样

class Foo:
    def get_AAA(self): #这几个函数的顺序不可改变
        print('get AAA')
    def set_AAA(self,value):
        print("set AAA")
    def del_AAA(self):
        print("delete AAA")
    AAA=property(get_AAA,set_AAA,del_AAA)
f1=Foo()
f1.AAA='aaa'
del f1.AAA
# set AAA
# delete AAA

metaclass 元类

1、引子

Python中一切皆对象，类本身也是一个对象。当使用关键字class时，python解释器在加载class的时候就会创建出一个对象（这里的对象指的是类而非类的示例）

class Foo:
    pass
f1 = Foo()
print(type(Foo))
print(type(f1))
# <class 'type'> #类的类就是type
# <class '__main__.Foo'> #表示obj对象由Foo类创建

2、什么是元类

元类是类的类，是类的模板

元类是用来控制如何创建类的，正如类是创建对象的模板一样

元类的示例为类，正如类的实例为对象

type是python内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象

3、创建类的两种方式

class Foo:
    def __init__(self,name):
        self.name = name
print(Foo)
def __init__(self,name):
    self.name = name
def test(self):
    print("test------")
FFo = type("FFo",(object,),{"x":1,"__init__":__init__,"test":test})
print(FFo)
# <class '__main__.Foo'>
# <class '__main__.FFo'>
f1 = FFo("alex")
print(f1.x)
# 1
f1.test()
# test------

4、一个类没有声明自己的元类，则默认其元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类

class MyType(type):
    def __init__(self,a,b,c):
        print("我的元类")
        print(a) #类名
        print(b) #继承的东西
        print(c) #属性字典
    def __call__(self, *args, **kwargs):
        print("====>")
        obj = object.__new__(self) #object.__new__(Foo)->f1
        self.__init__(obj,*args, **kwargs) #Foo.__init__(f1,*args, **kwargs)
        return obj
class Foo(metaclass=MyType): #MyType("Foo",(object,),{})触发init
    def __init__(self,name):
        self.name = name
print(Foo)
f1=Foo("alex")
print(f1.__dict__)
# 我的元类
# Foo
# ()
# {'__module__': '__main__', '__qualname__': 'Foo', '__init__': <function Foo.__init__ at 0x0000025E46C79598>}
# <class '__main__.Foo'>
# ====>
# {'name': 'alex'}