双下方法

双下方法

# 总结
# 一个对象之所以可以使用len()函数,根本原因是这个对象从输入的类中有__len__方法,
# hash(obj) 会调用obj这个对象的类(基类)的__hash__方法
# print(str(obj))  # 会触发__str__
# print(obj)  # 打印输出实例会触发__str__
# # print('此对象为%s' %obj)  # 格式化输出会触发__str__
# # print(obj)  # 触发__repr__
# print('此对象是%r' %obj)  # 触发__repr__
# # print(obj) 先触发__str__方法
# __call__ 方法的执行是由对象后加括号触发的，而构造方法的执行是由创建对象触发的
# print(a == b)  # 对一个类的两个对象进行比较操作,就会触发__eq__方法
# __new__ 构造方法
# __new__创造并返回一个新对象.
# 类名() 先触发__new__ 并且将类名自动传给cls.
# __item__对对象进行类似于字典的操作
# 对一个对象类似于进行with语句上下文管理的操作, 必须要在类中定义__enter__ __exit__
# 单列模式
# 这个类的对象不是个性化的,主要是实例化对象之后去执行类中的方法.
# 开辟一个空间__new__创造并返回一个空间
# __new__ 在执行__init__
# 自己定义的类继承于object
# 第1步 定义一个静态属性 执行自己的__new__
# 第2步 进行判断 执行父类__new__产生一个新空间
# 修改属性值 返回 第一次创造的对象
class A:
    __a=None
    def __new__(cls, *args, **kwargs):#类名等于 cls
        if not cls.__a:
            obj=object.__new__(cls)#执行父类__new__
            cls.__a=obj
        return cls.__a

len

class B:
    def __len__(self):
        print(666)

b = B()
len(b) # len 一个对象就会触发 __len__方法。

hash

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

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))

str

class A:
    def __init__(self):
        pass
    def __str__(self):
        return '太白'
a = A()
print(a)
print('%s' % a)

repr

如果一个类中定义了__repr__方法，那么在repr(对象) 时，默认输出该方法的返回值。

class A:
    def __init__(self):
        pass
    def __repr__(self):
        return '太白'
a = A()
print(repr(a))
print('%r'%a)

call

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

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

class Foo:

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

        print('__call__')


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

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)

del

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

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

new

class A:
    def __init__(self):
        self.x = 1
        print('in init function')
    def __new__(cls, *args, **kwargs):
        print('in new function')
        return object.__new__(A, *args, **kwargs)

a = A()
print(a.x)

__item__系列

class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)