假期（面向对象相关）

"""
一、isinstance(obj,cls) 和 issubclass(sub,super)
isinstance(obj,cls) 检查obj是否是类cls的对象
class Bar(object):
pass
class Foo(object):
pass
obj = Foo()
print(isinstance(obj,Foo))     #True
print(isinstance(obj,Bar))     #False
issubclass(sub,super) 检查sub类是否是super类的子类（派生类）
class Bar(object):
pass
class Foo(Bar):
pass
class Te(object):
pass
print(issubclass(Foo,Bar))    #True
print(issubclass(Te,Bar))     #False
"""
"""
二、反射：通过字符串的方式操作对象相关的属性，python中的一切事物都是对象，都可以使用反射
hasattr(object,name) 判断object中有没有一个name字符串对应的方法或者是属性
getattr(object,name,default=None)  从object中获取name属性，如果没有返回默认值None
setattr(obj,x,y) 给obj对象设置属性x=y
delattr(obj,x) 删除对象obj里的x属性
类也是对象，也可以有这四个方法
使用方法测试：
class Foo(object):
name = "我是你的什么啊？"
def __init__(self,addr):
self.addr = addr
obj = Foo("去你大爷的")
print(hasattr(obj,"name"))    #True
print(getattr(obj,"name"))    #我是你的什么啊？
setattr(obj,"sb",True)
print(obj.__dict__)           #{'addr': '去你大爷的', 'sb': True}
delattr(obj,"sb")
print(obj.__dict__)           #{'addr': '去你大爷的'}
反射当前模块成员：
import sys
def s1():
print("s1")
def s2():
print("s2")
this_module = sys.modules[__name__]
print(hasattr(this_module,"s1"))
使用反射的好处：
实现代码的可插拔机制；在导入模块方面经常使用反射；动态的导入模块

三、__setattr__,__delattr__,__getattr__;
#__setattr__添加/修改属性会触发它的执行
#__delattr__删除属性的时候会触发
#__getattr__只有在使用点调用属性且属性不存在的时候才会触发

四、二次加工标准类型（包装）
class List(list): #继承list所有的属性，也可以派生出自己新的，比如append和mid
def append(self, p_object):
' 派生自己的append：加上类型检查'
if not isinstance(p_object,int):
raise TypeError('must be int')
super().append(p_object)        #调用父类的append方法
@property
def mid(self):
'新增自己的属性'
index=len(self)//2
return self[index]
实现授权的关键点就是覆盖__getattr__方法
import time
class FileHandle:
def __init__(self,filename,mode='r',encoding='utf-8'):
self.file=open(filename,mode,encoding=encoding)
def write(self,line):
t=time.strftime('%Y-%m-%d %T')
self.file.write('%s %s' %(t,line))

def __getattr__(self, item):
return getattr(self.file,item)

f1=FileHandle('b.txt','w+')
f1.write('你好啊')
f1.seek(0)
print(f1.read())
f1.close()

五、__getattribute__:
和__getattr__类似，不过不管是否存在都会执行
class Foo:
def __init__(self,x):
self.x = x
def __getattribute__(self, item):
print("我总会执行")
obj = Foo(10)
print(obj.x)
print(obj.xxx)
！当getattr和getattribute同事存在的时候只执行getattribute，除非抛出异常，两者一起执行

六、描述符（__get__,__set__,__delete__）:
什么是描述符：描述符的本质就是一个新式类，在这个新式类中至少实现了__get__(),__set__(),__delete__()中的一个
这也被称为描述符协议
__get__():调用一个属性的时候触发
__set__():为一个属性赋值的时候触发
__delete__():删除属性的时候触发
class Foo:   #这个类称为描述符
def __get__(self, instance, owner):
pass
def __set__(self, instance, value):
pass
def __delete__(self, instance):
pass
描述符的作用：用来代理另外一个类的属性（必须把描述符定义为这个类的类属性，不能定义到构造方法中）
分类：
数据描述符：至少实现了__get__() 和__set__()方法
非数据描述符：没有实现__set__()方法
注意事项：
1、描述符本身应该定义为新式类，被代理的类也应该是新式类
2、必须定义为类属性，不能定义到构造函数中
3、要严格遵循优先级，优先级由高到低分别是(类属性，数据描述符，实例属性，非数据描述符，找不到的时候触发__getattr__())
描述符的使用：
描述符的总结：

六、property：
一个静态属性property本质就实现了get，set，delete三种方法
用法一：
class Foo:
@property
def AAA(self):
print("get的时候运行")
@AAA.setter
def AAA(self,value):
print("set的时候运行",value)
@AAA.deleter
def AAA(self):
print("delete 的时候运行")
obj = Foo()
obj.AAA  #get
obj.AAA = "aaa"   #set
del obj.AAA    #delete
用法二：
class Foo:
def get_AAA(self):
print("get的时候yunx")
def set_AAA(self,value):
print("set 的时候运行")
def delete_AAA(self):
print("delete的时候运行")
AAA=property(get_AAA,set_AAA,delete_AAA)    #内置的property三个参数必须与get，set，delete一一对应

七、__setitem__,__getitem__,__delitem__:
示例代码;
class Foo:
def __init__(self,name):
self.name = name
def __getitem__(self, item):
print(self.__dict__[item])
def __setitem__(self, key, value):
self.__dict__[key] = value
def __delitem__(self, key):
print("del obj 时执行")
def __delattr__(self, item):
print("del obj 执行，")
self.__dict__.pop(item)
obj = Foo("sb")
obj["age"] = 18
obj["age1"] = 19
del obj.age1
del obj["age"]
obj["name"] = "alex"
print(obj.__dict__)

八、__str__,__repr__,__format__:
改变对象的字符串显示__str__,__repr__,当你打印对象的时候假如里面没有这两个方法，那么打印出来的你是看不懂的
自定义格式化字符串：__format__
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
- 示例：
format_dict={
'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
}
class School:
def __init__(self,name,addr,type):
self.name=name
self.addr=addr
self.type=type

def __repr__(self):
return 'School(%s,%s)' %(self.name,self.addr)
def __str__(self):
return '(%s,%s)' %(self.name,self.addr)

def __format__(self, format_spec):
if not format_spec or format_spec not in format_dict:
format_spec='nat'
fmt=format_dict[format_spec]
return fmt.format(obj=self)
s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1))
print('from str: ',str(s1))
print(s1)

print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))

九、__slots__:
在类中写一个slots，在吧类中的某些字段写在里面，外部才可以访问，不写访问不到

十、__next__和__iter__实现迭代器协议
模拟实现range方法：
class Range:
def __init__(self,n,stop,step):
self.n=n
self.stop=stop
self.step=step

def __next__(self):
if self.n >= self.stop:
raise StopIteration
x=self.n
self.n+=self.step
return x

def __iter__(self):
return self

for i in Range(1,7,3): #
print(i)

十一、__doc__
- 显示描述信息，即注释信息
- 无法被继承

十二、__module__和__class__
- __module__  表示当前操作的对象在哪个摸快
- __class__表示当前操作的对象的类是什么

十三、__del__：
- 析构方法：当对象在内存中被释放时执行这段代码
- 比如在数据库链接中关闭数据库，文件操作中的close操作

十四、__enter__和__exit__：
__enter__在进来的时候执行
__exit__在出去的时候执行
- 对象调用前后执行这两个方法

十五、__call__方法：
- 对象后边＋括号自动触发执行
- 构造方法的执行是由创建对象触发的，即对象=类名();而对于__call__方法是对象()或者类()()

十六、metaclass
exec：三个参数       字符串形式的命令  全局作用域  局部作用域
exec会在指定的局部作用域内执行字符串内的代码，除非明确地使用global关键字
- 类也是对象
- 什么是元类
- 元类是类的类，类的模板
- 元类是用来控制如何创建类的，正如类是创建对象的模板一样，而元类的主要目的是为了控制类的创建行为元类的实例化的结
果为我们用class定义的类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是 type 类的一个实例)type是python的一
个内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象
- 创建类的两张方式：
- 方式一：使用class关键字
- 方式二：手动模拟class创建类的过程
- 类名
- 类的父类
- 类体
#类名
class_name='Chinese'
#类的父类
class_bases=(object,)
#类体
class_body=
country='China'
"
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
"
- 一个类没有声明自己的元类，默认它的元类就是type，除了使用元类type，用户也可以通过继承type俩自定义元类
- #元类控制类的实例化过程：
1 类()，调用元类.__call__()
2 在1的方法中调用：
类.__new__() #返回类的对象obj
类.__init__(obj,...) #为对象进行初始化

- 元类控制类本身的产生过程

"""