类的内置方法

__str__和__repr__

改变对象的字符串显示__str__,__repr__

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



s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1))    ---from repr:  School(oldboy1,北京)
print('from str: ',str(s1))      ---from str:  (oldboy1,私立)
print(s1.__str__())              ---(oldboy1,私立)
print(s1)                        ---(oldboy1,私立)
---------------------------------------------------------------------

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

class B:
    def __str__(self):
        return 'str : class B'

    def __repr__(self):
        return 'repr : class B'


b = B()
print('%s' % b)
print('%r' % b)
---------------------------------------------------------------------

# %s str() 直接打印 实际上都是走的__str__
# %r repr() 实际上都是走的__repr__
# repr 是str的备胎，但str不能做repr的备胎，如果__str__没有被定义,那么就会使用__repr__来代替输出，反之不行

# print(obj)/'%s'%obj/str(obj)的时候，实际上是内部调用了obj.__str__方法，如果str方法有，那么他返回的必定是一个字符串
# 如果没有__str__方法，会先找本类中的__repr__方法，再没有再找父类中的__str__。
# repr(),只会找__repr__,如果没有找父类的

__del__

析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:

    def __del__(self):
        print('执行我啦')

f1=Foo()
del f1
print('------->')

#输出结果
执行我啦
------->

__call__

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print('__call__')


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

__len__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __len__(self):
        print(self.__dict__)
        return len(self.__dict__)

a = A()  
print(len(a))
---------------------------------

{'b': 2, 'a': 1}

2

item系列

__getitem__\__setitem__\__delitem__

以字典样式访问

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __getitem__(self, item):
        if hasattr(self,item):
            return  self.__dict__[item]
    def __setitem__(self, key, value):
        self.__dict__[key] = value
    def __delitem__(self, key):
        del self.__dict__[key]
f = Foo("alex",28)
print(f["name"])
# print(f.name)

f["love"] = "play"
print(f["love"])

del f["age"]
# del f.age
print(f["age"])

 __eq__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __eq__(self,obj):
        if  self.a == obj.a and self.b == obj.b:
            return True
a = A()
b = A()
print(a == b)  # 其实比较的是内存地址，通过__eq__,将返回True