python's twenty_fourth day for me 内置方法

str  repr：

1，当需要使用__str__的场景时找不到__str__就找__repr__

2，当需要使用__repr__的场景时找不到__repr__的时候就找父类的repr.

3，双下repr是双下str的备胎。

class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return "Teacher's object %s" % self.name
    def __repr__(self):
        return "repr function %s" % self.name
a = Teacher('alex',30)
b = Teacher('egon',20)
print(a)            #  先找__str__，若有就执行，若没有就找__repr__，再没有就找object里的__str__返回内存地址。
print(repr(a))          # 先找__repr_-，若有就执行，若没有则找object里的__repr__返回内存地址。

len() 和 obj.__len__()　　的返回值是一致的。

len() 的结果是依赖obj.__len__().

class A:
    def __len__(self):
        return 1    # 自定返回值。
def len(obj):
    return obj.__len__()
a = A()
print(a.__len__())
print(len(a))

## 归一化z设计的原因：更接近面向函数编程。

format   __format__()：

class School:
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr
    def __format__(self, format_spec):
        if not format_spec or format_spec not in format_dict:  # 如果没传参数或穿的参数不在format_dict中
            format_spec = 'nat'         # 形参 format_spec = 'nat'
        fmt = format_dict[format_spec]      # 将字典中的格式赋值给一个fmt变量
        return fmt.format(obj = self)       
s = School('oldboy','beijing')
print(format(s,'nat'))      # oldboy-beijing
print(format(s,'tan'))      # oldboy:beijing

__call__:　　对象名() 相当于调用类内置的__call__

　　　　一个对象是否可调用，完全取决于这个对象对应的类是否实现了__call__.

callable:　　查看对象可否调用，返回bool值。

class Teacher:
    def __call__(self):
        print(123)
    def call(self):
        print(321)
t = Teacher()
t()    # 123     # 相当于调用类内的__call__方法。
print(callable(Teacher))    # True
print(callable(t))    # True

__eq__:　　==  是由  __eq__  的返回值来决定的。

class A:
    def __eq__(self, other):
        if self.__dict__ == other.__dict__:
            return True
        else:
            return False
a = A()
b = A()
print(a == b)
a.name = 'alex'
b.name = 'egon'
print(a == b)

__del__  析构方法：在删除一个对象的时候做一些收尾工作。

class A:
    def __init__(self):
        # pass
        self.f = open('文件',encoding='utf-8',mode='w')
    def __del__(self):
        self.f.close()
        print('执行我啦')
a = A()
del a       # 因为有del
print(a)
print('aaa')
#  所以先执行__del__方法，后执行print

__new__ 构造方法:

　　　　1，实例化的时候　　2，在创建对象的过程使用__new__　　3，后面才是__init__初始化。

*****设计模式  ——  单例模式：就是一个类就只能创建一个空间共对象使用。(只能有一个实例)

class A:
    __instance = None
    def __new__(cls,*args,**kwargs):
        if cls.__instance is None:
            obj = object.__new__(cls)
            cls.__instance = obj
        return cls.__instance
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(self.name)
a = A('顾清秋',17)
a.hobby = 'Music'
b = A('顾小白',17)
print(a)        # <__main__.A object at 0x000001EF20F69898>
print(b)        # <__main__.A object at 0x000001EF20F69898>
print(a.name)   # 顾小白
print(b.name)   # 顾小白
print(b.hobby)
#  只能创建一个内存空间，后面实例化的会把前面实例化的完全覆盖。

item :　　（__getitem__，__setitem__，__delitem__）

class Foo:
    def __init__(self,name):
        self.name = name
    def __getitem__(self, item):
        return self.__dict__[item]
    def __setitem__(self, key, value):
        self.__dict__[key] = value
    def __delitem__(self, key):
        self.__dict__.pop(key)
f = Foo('顾清秋')
print(f.name)   # 顾清秋
print(f['name'])    # 顾清秋       相当于执行了__getitem__方法
print(f.__dict__)   # {'name': '顾清秋'}
f['age'] = 17       # 相当于执行了 __setitem__方法
print(f.__dict__)   # {'age': 17, 'name': '顾清秋'}
del f['age']        # 相当于执行了 __delitem__方法
print(f.__dict__)   # {'name': '顾清秋'}

__delattr__:

class Foo:
    def __init__(self,name):
        self.name = name
    def __delattr__(self, item):
        print('del obj.key时，我执行了')
        self.__dict__.pop(item)
f = Foo('顾小白')
del f.name      # 相当于执行了__delattr__方法
# delattr(f,'name')