反射等一系列内置函数

hasattr(obj,"name")

getattr(obj,"name",default = xx)

setattr(obj,"name", '')

delattr(obj,'name')

在文件中用反射

def sa_hi():
    print('Nihao a')

isinstance(obj,cls)  #判断一个对象是否是一个类的对象,也可以判断是否是父类的，反应族谱关系
x = 111
print(isinstance(x,int)) #x是int的实例化，判断x是否是int的对象

issubclass(sub,super) 判断sub是否是super的子类

class Foo():
    pass

class Fpp(Foo):
    pass

print(issubclass(Fpp,Foo))

__getattribute__ 是大哥，__getattr__是小弟
raise AttributeError 是抛出异常

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

    def __getattr__(self, item):
        print("this is getattr")

    def __getattribute__(self, item):
        print('this is get attribute')
        raise AttributeError("快去叫attr")


f1 = Foo('yishu')

f1.name
f1.xxxx

item系列

class Foo():
    def __getitem__(self, item):
        print('getitem')
        # return

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

f1 = Foo()
f1['name'] = 'yishu'
print(f1.__dict__)  #{'name': 'yishu'}

del f1.name
print(f1.__dict__)
setitem
{'name': 'yishu'}
{}
.的方式操作属性，就是和attr打交道，中括号和item相关。

class Foo:
    def __str__(self):  #控制打印信息
        return 'str'
    pass
f1 = Foo()
print(f1)
print(f1)  ----print触发str(f1) --->f1.__str__()

def __repr__ 在解释器中触发
class Foo():
    def __repr__(self):
        return 'fsagfs'
    pass


f1 = Foo()
print(f1)  #fsagfs
print调的本质是f1.__str__，如果找不到str，就回去找repr作为替代品

class Foo():
    def __str__(self):
        return 'gao'  #必须return字符串
    def __repr__(self):
        return 'fsagfs' #必须return字符串
    pass


f1 = Foo()
print(f1)  #return 'gao'优先执行__str__

自定制format格式
复习 format
x = '{0} {0} {0}'.format('yishu')
print(x)  #yishu yishu yishu

class Date():
    def __init__(self,year,mon,day):
        self.year = year
        self.month = mon
        self.day = day

d1 = Date(2018,4,12)
x = '{0.day}:{0.month}:{0.year}'.format(d1)
print(x)   #12:4:2018

class PrinDate:
    def __init__(self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day


    def __format__(self, format_spec):
        format_dict = {
            'ymd': '{0.year}/{0.mon}/{0.day}',
            'y:m:d' : '{0.year}:{0.mon}:{0.day}'
        }

        if not format_spec or format_spec not in format_dict:
            format_spec = 'ymd'

        return format_dict[format_spec].format(self)

d1 = PrinDate(2018,4,12)
print(d1)

print(format(d1,'fsdf'))

----------------------__slots__---------------------

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

f1 = Foo()
f1.name = 'yishu'
f1.age = '26'
print(f1.name)

--------------------__module__,__class__---------------
查看某个实例由哪个模块产生，由哪个类产生

---------------------__del__-----------------------------
析构方法，当对象在内存中被释放时，自动触发执行。就是删除整个实例时执行。

class Foo:

    def __del__(self):
        print("chanshuneicun")

f1 = Foo()  #实例化之后，文件执行完毕，释放内存，进行垃圾回收，触发。所以需要先存到变量中。
------------------—__call__------------------

class Foo:
    def __call__(self, *args, **kwargs):
        print("zhixng")

f1 = Foo()
f1()
#类后面的括号实质上是运行上一级类的__call__方法
#f1实例是类Foo产生，但是原本Foo没有call方法，可以添加。
#那么，Foo也是一个实例，它的类有call方法，所以可以在后面加上括号。
-------------------__next__和 __iter__--------------------------
我们知道for循环是调用了数组列表等内部的__iter__，把他们变成了可迭代对象之后，再调用__next__函数。
那么，如何自己构造一个迭代器呢？
class Foo:
    def __init__(self,n):
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        self.n += 1
        if self.n == 100:
            raise StopIteration
        return self.n

f1 = Foo(90)
for i in f1:  #本质上就是执行__next__
    print(i)
------------------------fibarray--------------------

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

    def __iter__(self):
        return self

    def __next__(self):
        self._a, self._b = self._b,self._a + self._b
        if self._a >100:
            raise StopIteration
            print('zz')
        return self._a

f1 = Fib()
print(f1.__next__())
print(f1.__next__())
for i in f1:
    print(i)