Python全栈开发——面向对象进阶（一切皆对象）

#isinstance(obj,cls)  检查obj是否是类cls的对象
class Foo:
    pass
f=Foo()
print(isinstance(f,Foo))    #True

#issubclass(sub,super)  检查sub是否是super的子类
class Bar(Foo):
    pass
print(issubclass(Bar,Foo))   #Ture

class Foo:
    def __init__(self,y):
        self.y=y
    #有__getattribute__，则__getattr__不会触发
    #实际上只有触发AttributeError时，才会触发
    def __getattr__(self, item):
        print(‘getattr‘)

    #实例化访问时，不管存不存在属性，都会调用
    def __getattribute__(self, item):
        print(‘getattribute‘)
f=Foo(3)
f.c       #  getattribute
f.y       #  getattribute

#通过字典形式访问才会触发，和内置attr差不多
class Foo:
    def __getitem__(self, item):
        print(‘getitem‘)

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

    def __delitem__(self, key):
        print(‘delitem‘)

f=Foo()
f[‘l‘]=‘k‘    #setitem
print(f.__dict__)  #{‘l‘: ‘k‘}
f[‘l‘]        #getitem
del f[‘ff‘]   #delitem

class Foo:
    def __str__(self):
        return ‘str‘

    def __repr__(self):
        return ‘repr‘

x=Foo()
print(x)    #str

x=‘{0}-{0}-{0}‘.format(‘d‘)
print(x)   #d-d-d

Date_geshi={
    ‘ymd‘:‘{0.year}-{0.month}-{0.day}‘,
    ‘ydm‘:‘{0.year}-{0.day}-{0.month}‘,
    ‘mdy‘:‘{0.month}-{0.day}-{0.year}‘,
}
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    #定制格式
    def __format__(self, format_spec=‘ymd‘):
        if format_spec not in Date_geshi:
            print(‘没有该格式‘)
            format_spec = ‘ymd‘
        print(format_spec)   #  ymd
        return Date_geshi[format_spec].format(self)

d=Date(2016,12,23)
d1=d.__format__(‘hgfh‘)
print(d1)    #  2016-12-23
print(format(d,‘mdy‘))   #相当于执行  d.__format__(‘mdy‘)
#  12-23-2016

class Foo: 
    #设置之后，class没有__dict__属性了
    #也限制了创建，只能定义你定义的属性
    #只能定义__slots__提供的name,age
    __slots__ = [‘name‘,‘age‘]

f=Foo()
f.name=13

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

f=Foo()
f()     #__call__

class FBIF:
    def __init__(self,_a,_b):
        self.__a=_a
        self.__b=_b
    def __iter__(self):
        return self
    def __next__(self):
        self.__a,self.__b=self.__b,self.__b+self.__a
        return self.__a
f=FBIF(1,1)
print(next(f))
print(next(f))
print(‘---------------->‘)
for i in f:
    print(i)
    if i>100:
        raise StopIteration(‘ffff‘)