Python基础 ( 十 ) —— 面向对象补充1（其他的内置__XXX__方法）

class A:
    def __init__(self, x):
        self.x = x
    def __getattr__(self, item):
        print('执行getattr')
    def __getattribute__(self, item):
        print('执行getattribute')
        raise AttributeError('交给我小弟getattr去做')

a = A(1)
a.xx

class A:
    def __setitem__(self, key, value):
        print('__setitem__被执行')
        self.__dict__[key] = value
    def __getitem__(self, item):
        print('__getitem__被执行')
        return self.__dict__[item]
    def __delitem__(self, key):
        print('__delitem__被执行')
        self.__dict__.pop(key)
a = A()
print(a.__dict__)
a['name'] = 'alex'                      #触发__setitem__
a['age'] = 18                           #触发__setitem__
print(a.__dict__)
del a['name']                           #触发__delitem__
print(a.__dict__)
print(a['age'])                         #触发__getitem__

class A:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):
        return '自定的实例显示方法%s %s' %(self.name, self.age)
a = A('alex', 18)
print(a)                        # print实际会触发 str(a) --> 也就是a.__str__，打印出a.__str__的返回值
#通过以下例子就可以看出来
class B(list):
    def __str__(self):
        return '我自定的显示'
print(B('abcdef'))
#如果再怀疑print()是否真的触发了__str__ 可以去终端试试(终端定义类的或者函数的时候会进入 ... 为开头的模式，定义完成后连续两下Enter就可退出)
#事实证明，自己定义的__str__在print（）后才触发, 并且str(a) 其实就是在调用a.__str__

class Date:
    def __init__(self,year, mon, day):
        self.year = year
        self.mon = mon
        self.day = day
date = Date(2019, 10, 9)
print("{0.mon}-{0.day}-{0.year}".format(date))                 #调用实例对象属性的format格式化

class Date:
    format_dic = {
        'm-d-y': '{0.mon}-{0.day}-{0.year}',
        'y:m:d': '{0.year}:{0.mon}:{0.day}'
    }
    def __init__(self,year, mon, day):
        self.year = year
        self.mon = mon
        self.day = day
    def __format__(self, format_spec):
        if not format_spec or (format_spec not in self.format_dic):
            print('使用默认格式')
            fm = '{0.year} {0.mon} {0.day}'
            return fm.format(self)
　　　　　print('使用指定格式')
        fm = self.format_dic[format_spec]
        return fm.format(self)

date = Date(2019, 10, 9)
print(format(date))
print(format(date, 'm-d-y'))

class Foo:
    #创建单个属性
    # __slots__ = 'name'            #相当于属性字典里的 {'name':None}
    #若创建多个属性
    __slots__ = ['name', 'age']     #相当于属性字典里的 {'name':None, 'age':None}
f1 = Foo()
f1.name = 'alex'
# print(f1.__dict__)                #会报错，用了__slots__生成的实例对象，已经不再有__dict__属性
#f1.age = 18                        #会报错，已经无法增加新的属性，因为本质上是在调用__setattr__，而这需要操作__dict__属性字典
print(f1.__slots__, Foo.__slots__)  #这时候已经没有实例的属性字典了，他俩一样
print(f1.name)
print(f1.__slots__)

class Foo:
    def __init__(self, n):
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.n >= 5:
            raise StopIteration('迭代完毕')
        else:
            self.n += 1
            return self.n

f = Foo(0)
#迭代完毕后继续迭代会raise StopIteration('迭代完毕') 错误
# f.__next__()
# f.__next__()
# f.__next__()
# f.__next__()
# f.__next__()
# f.__next__()
#用 for 则会自动停止，处理好你这个错误： 用了 try: except StopIteration : ；详情看迭代器那章
for i in f:                         #相当于iter(f) == f.__iter__(), 然后  f.__iter__().__next__() = i
    print(i)

class Foo:

    def __enter__(self):
        print('enter触发')
        return self                 #如果不返回对象，这个对象就不会赋值给下面的f

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit触发')

with Foo() as f:                    #在这里触发__enter__, 并把Foo()实例化出来的对象传给__enter__;也就是f=Foo().__enter__();而不是认为做了f=Foo()--》特别注意！！
    print(f)                        #在下面的代码块执行完毕后触发__exit__
print('这时已经触发完__exit__')

class Foo:

    def __enter__(self):
        print('enter触发')
        return self                 

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit触发')
        print(exc_type)
        print(exc_val)
        print(exc_tb)

with Foo() as f:
    print(不存在的变量)              #这里触发__exit__
    print(f)
print('这时已经触发完__exit__')

class Foo:

    def __enter__(self):
        print('enter触发')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit触发')
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        return True

with Foo() as f:
    print(不存在的变量)                           #这里触发__exit__
    print(f)
    print("你看，异常被吃了，这里没有继续执行")
print('这时已经触发完__exit__')

class Desc:
    def __init__(self, name):                     #为了记录被代理的变量的名字, 如这里的 'x'
        self.name = name

    def __get__(self, instance, owner):           #这里的instance 就是实例t ;owner 为拥有这个实例的类TestDesc
        print("get!!!!")
        print("self=", self)
        print("instance=", instance)
        print("owner=", owner)
        print('*'*50, "\n")
        #return '返回值:{}'.format(instance.__dict__[self.name])

    def __set__(self, instance, value):            #value 为你设置的值
        print("set!!!!")
        print("self=", self)
        print("instance=", instance)
        print("value=", value)
        print('*'*50, "\n")
        #下面使用可以看出，实例t的字典里并没有设置的值，所以这里可以手动把值添加到字典中
        # instance.__dict__[self.name] = value

    def __delete__(self, instance):
        print("delete!!!!")
        print("self=", self)
        print("instance=", instance)
        print('*' * 50, "\n")


class TestDesc:
    x = Desc('x')                        #通俗的说就是在TestDesc这个类中，用Desc去描述x属性；相当于x代理给了Desc
    y = 1
    def __init__(self, n):
        self.x = n                      #不会存于实例的字典中，但是会存于类的字典中

t = TestDesc('__set__ 里面的value就是这个')  #触发__set__:
print(t.__dict__)                            #实例的字典里没x
print(t.x)                                   #触发__get__:当实例化对象属性(等于描述符的那个属性)被调用时
print(TestDesc.x)                            #通过类调用也会触发__get__，只是instance值为None
t.x = '这个值传入__set__中'                  #触发__set__:当实例化对象设置描述符属性时候触发，如上面的x=Desc()
del t.x                                      #触发__delete__
print(TestDesc.__dict__)                     #类的字典里有x