python 面向对象 类的内置方法

class A:
    passa = A()
print(isinstance(a,A))

class A:
    passclass B(A):
    passprint(issubclass(B,A))

#调用str(obj)其实内部就是在调用__str__
#obect内置有一个__str__，调用时，返回调用该方法的对象的内存地址class A:
    def __str__(self):
        return 'This is class A'a = A()
print(str(a))

#将对象转化为供解释器读取的形式class A:
    def __repr__(self):
        return str(self.__dict__)#调用%r和repr，其实都是调用__repr__()#如果类没有str方法，会调用类的repr方法，如果类没有repr，会调用父类的str方法
#反过来如果没有repr方法，不会调用str方法，而会直接调用父类的repr

#析构方法：对象在被销毁的时候运行的函数，解释器会自动执行，一般不用实现

class Person:    def __getitem__(self,key):   # 获取
        return self.__dict__[key]    def __setitem__(self,key,value):    #设置
        self.__dict__[key] = value    def __delitem__(self,key):    #删除
        self.__dict__.pop(key)p = Person()
p['a'] = 1
print(p['a'])
del p['a']
print(p['a'])    #这里会报KeyError

#构造方法
#__init__不是构造方法，而是__new__class A:
    def __new__(cls, *args, **kwargs):
        return object.__new__(A,*args, **kwargs)    #调用object类的__new__方法，返回self#单例模式
#一个类只有一个实例
class A:
    __instance = False    #是否创建了实例的标志位
    def __new__(cls, *args, **kwargs):
        if cls.__instance:
            return cls.__instance
        cls.__instance = object.__new__(A,*args, **kwargs)
        return cls.__instance

#对象后面加括号执行
#如：对象()或类()()class A:
    def __call__(self):
        print('A')a = A()
a()

#使用len()时执行class Life:
    def __init__(self,name,length):
        self.name = name
        self.length = length    def __len__(self):
        return self.lengthhsr = Life('hsr',100)
print(len(hsr))

#对对象进行hash运算
class Student:
    def __init__(self,no,name):
        self.no = no
        self.name = name    def __hash__(self):
        return hash(str(self.no)+self.name)s = Student(102302,'hsr')
print(hash(s))

class Life:
    def __init__(self,name,length):
        self.name = name
        self.length = length    def __len__(self):
        return self.length    def __eq__(self, other):
        return other.length == self.lengthhsr = Life('hsr',100)
ttt = Life('ttt',100)
print(hsr == ttt)