'''
1、什么是继承
    继承是一种新建类的方式，新建的类称之为子类，被继承的类称之为基类、父类、超类
    继承描述的是一种“遗传”的关系:子类可以重用父类的属性

在python中的继承注意两点：
   1. 在python中支持一个子类同时继承多个父类，
   2. python中类分为两种：
            新式类：但凡继承object的类，以及该类的子类。。。都是新式类
                在python3中一个类如果没有继承人类类，默认继承object类，即python3中所有的类都是新式类

            经典类: 没有继承object的类，以及该类的子类。。。都是经典类
                在python2中才区分新式类与经典类

2、为何要用继承
     减少代码冗余

3、如何用继承

class Parent1(object):
    pass
class Parent2:
    pass
class Subclass1(Parent1,Parent2):
    pass
print(Subclass1.__bases__)


# 2、在继承的背景下，属性查找的优先级
      #当类是经典类时，多继承的情况下，在要查找的属性不存在时，会按照深度优先的方式查找下去
      #当类是新式类时，多继承的情况下，在要查找的属性不存在时，会按照广度优先的方式查找下去

class People:
    __country='China' #_People__country='China'
    __n=111           #_People__n=111

    def __init__(self,name):
        self.__name=name #self._People__name=name

    def run(self):
        print('%s is running' %self.__name) #self._People__name

print(People.__country)

obj=People('egon')
print(obj.__name)
print(obj.run)
obj.run()

print(People.__dict__)
print(People._People__country)
print(obj.__dict__)
print(obj._People__name)

@timer  #@timer就等同于cal=timer(cal)
def cal(array):
    res=0
    for i in array:
        res+=i
    return res

cal(range(10))

__str__：在对象被打印时自动触发，然后将该绑定方法的返回值(必须是字符串类型)当做本次打印的结果
class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self):
        return '<name:%s age:%s>' %(self.name,self.age)

obj1=People('egon',18)
obj2=People('lxx',38)

print(obj1) #print(obj1.__str__())
print(obj2) #print(obj2.__str__())

__del__：在对象被删除前自动触发, 在该方法内应该执行与该对象有关的系统资源的回收操作
class Foo:
    def __init__(self,filename,encoding='utf-8'):
        self.f=open(filename,'r',encoding=encoding)

    def __del__(self):
        # print('run.....')
        self.f.close()

obj=Foo()
del obj #obj.__del__()

#obj.__del__()

import  time
def Foo():
    print('------')

def test(func):
    print(func)
    start_time=time.time()
    func()
    stop_time=time.time()
    print('func_runtime %s' %(stop_time-start_time))

Foo()
test(Foo)  #修改函数调用方式

def run():
    print('from_run')

run()

def test():
    yield 1 #暂停，入口
    print('from_run')
    yield 2
    print('from_run')

t=test() 产生生成器对象
#唤醒迭代器
t.__next__()
next(t)  # yield10
t.send('123')

age=10
res=True if age>10 else False
# if 形式三元表达式
l=['a' for i in range(10)]  #列表解析
g_l=('a' for i in range(10)) #生成器表达式
print(l)
def test():
    for i in range(4):
        yield 1

t=test()

hasattr(object,name)
判断object中有没有一个name字符串对应的方法或属性

getattr(object,name,default=None)
从对象中获取命名属性;getattr(x， 'y')等价于x.y。
当给出一个默认参数时，当属性没有给出时，返回该参数
不存在，在这种情况下就会引发异常。

setattr(x,y,v)
将给定对象上的命名属性设置为指定值。
setattr(x， 'y'， v)等于' x.y = v

delattr(x,y)
从给定对象中删除命名属性。
delattr(x， 'y')等价于' del x.y'

module_abc=__import__('dic.a.b.c')#从字符串中提取文件名
# module_abc 拿到最顶层dic模块
module_abc.a.b.c

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

    def __getattr__(self, item):
        print('----> from getattr:你找的属性不存在')


    def __setattr__(self, key, value):
        print('----> from setattr')
        # self.key=value #这就无限递归了,你好好想想
        # self.__dict__[key]=value #应该使用它

    def __delattr__(self, item):
        print('----> from delattr')
        # del self.item #无限递归了
        self.__dict__.pop(item)

#__setattr__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)

#__delattr__删除属性的时候会触发
f1.__dict__['a']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)

#__getattr__只有在使用调用属性且属性不存在的时候才会触发
f1.xxxxxx

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 write(self,line):
        print('---------',line)
        t=time.strftime('%Y-%m-%d %X')
        self.file.write('%s %s' %(t,line))

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

    # def read(self):
    #     pass


f1=FileHandle('a.txt','r+')
print(f1.__dict__)
print('——————>',f1.read) # 触发 getattr
# print(f1.write)
f1.write('11111111211111\n')
# f1.seek(0)
# sys_f=open('b.txt','w+')
#授权的方式主要在于__getattr__将没有定义的方法映射到真正的内建函数file里面

class List:
    def __init__(self,seq,permission=False):
        self.seq=seq
        self.permission=permission
    def clear(self):
        if not self.permission:
            raise PermissionError('not allow the operation')
        self.seq.clear()

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

    def __str__(self):
        return str(self.seq)
l=List([1,2,3])
# l.clear() #此时没有权限，抛出异常


l.permission=True
print(l)
l.clear()
print(l)

#基于授权，获得insert方法
l.insert(0,-123)
print(l)

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattr__(self, item):
        print('执行的是我')
        # return self.__dict__[item]

f1=Foo(10)
print(f1.x)
f1.xxxxxx #不存在的属性访问，触发__getattr__

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattribute__(self, item):
        print('不管是否存在,我都会执行')

f1=Foo(10)
f1.x
f1.xxxxxx

__getattribute__

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattr__(self, item):
        print('执行的是我')
        # return self.__dict__[item]
    def __getattribute__(self, item):
        print('不管是否存在,我都会执行')
        raise AttributeError('哈哈')

f1=Foo(10)
f1.x
f1.xxxxxx

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

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
#疑问:何时,何地,会触发这三个方法的执行

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

    def __set__(self, instance, value):
        print('---set方法')
        instance.__dict__['x']=value

    def __delete__(self, instance):
        print('---delete方法')

class Bar:
    x=Foo()#定义成另外一个类的类属性
    def __init__(self,n):
        self.x=n

b1=Bar(10)
print(b1.__dict__)

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

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

class Type:
    def __init__(self,key,expected_type):
        self.key=key
        self.expected_type=expected_type

    def __get__(self, instance, owner):
        print('get_methods')
        # print('getinstance参数[%s]'%instance)
        # print('owner参数[%s]'%owner)
        return instance.__dict__[self.key]

    def __set__(self, instance, value):
        print('set_methods')
        # print('setinstance参数[%s]' % instance)
        # print('value参数[%s]' % value)
        if not isinstance(value,self.expected_type) :
            # print('你传入的类型不是字符串，错误')
            # return
            raise TypeError('你传入的不是字符串')
        instance.__dict__[self.key]=value

    def __delete__(self, instance):
        print('delete_methods')
        # print('instance_arg[%s]'%instance)
        instance.__dict__.pop(self.key)

class People:
    name=Type('name',str)
    age=Type(18,int)
    def __init__(self,name,age,salary):
        self.name=name
        self.age=age
        self.salary=salary

p1=People('egon',18,33.3)
p1.name='alex'
print(p1.__dict__)
p1.age

class Foo:
    def __getitem__(self, item):
        print('getitem')
        return self.__dict__[item]

    def __setitem__(self, key, value):
        print('setitem')
        self.__dict__[key]=value

    def __delitem__(self, key):
        print('delitem')
        self.__dict__.pop(key)

#字典操作触发 item
#. 触发  attr
f1= Foo()
print(f1.__dict__)
f1['name']='egon'
f1['22']='2222'

print(f1.__dict__)

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[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alx'
print(f1.__dict__)

#实现类型检测功能

#第一关：
class People:
    def __init__(self,name):
        self.name=name

    @property
    def name(self):
        return self.name

# p1=People('alex') #property自动实现了set和get方法属于数据描述符,比实例属性优先级高,所以你这面写会触发property内置的set,抛出异常


#第二关：修订版

class People:
    def __init__(self,name):
        self.name=name #实例化就触发property

    @property
    def name(self):
        # return self.name #无限递归
        print('get------>')
        return self.DouNiWan

    @name.setter
    def name(self,value):
        print('set------>')
        self.DouNiWan=value

    @name.deleter
    def name(self):
        print('delete------>')
        del self.DouNiWan

p1=People('alex') #self.name实际是存放到self.DouNiWan里
print(p1.name)
print(p1.name)
print(p1.name)
print(p1.__dict__)

p1.name='egon'
print(p1.__dict__)

del p1.name
print(p1.__dict__)


#第三关:加上类型检查
class People:
    def __init__(self,name):
        self.name=name #实例化就触发property

    @property
    def name(self):
        # return self.name #无限递归
        print('get------>')
        return self.DouNiWan

    @name.setter
    def name(self,value):
        print('set------>')
        if not isinstance(value,str):
            raise TypeError('必须是字符串类型')
        self.DouNiWan=value

    @name.deleter
    def name(self):
        print('delete------>')
        del self.DouNiWan

p1=People('alex') #self.name实际是存放到self.DouNiWan里
p1.name=1

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 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)

'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))

class Foo:
    __slots__='x'


f1=Foo()
f1.x=1
f1.y=2#报错
print(f1.__slots__) #f1不再有__dict__

class Bar:
    __slots__=['x','y']

n=Bar()
n.x,n.y=1,2
n.z=3#报错

class Foo:
    __slots__=['name','age']

f1=Foo()
f1.name='alex'
f1.age=18
print(f1.__slots__)

f2=Foo()
f2.name='egon'
f2.age=19
print(f2.__slots__)

print(Foo.__dict__)
#f1与f2都没有属性字典__dict__了,统一归__slots__管,节省内存