Python高级 - 魔术方法

__call__

# __call__
class A:
    def __call__(self, *args, **kwargs):
        print('执行call方法')

a = A()
a()  # 对象()相当于调用__call__方法

A()()  # 类名()()相当于先实例化得到一个对象,再对对象(),调用__call__方法

class B():
    def __init__(self, cls):
        self.a = cls()
        self.a()

b = B(A)

__len__

# __len__
内置函数(len)和类的内置方法(__len__)是有奸情的
class mylist():
    def __init__(self):
        self.lst = [1,2,3]
        self.name = 'alex'
        self.age = 83

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

l = mylist()
print(len(l))
# len(obj)相当于调用了这个obj的__len__方法
# __len__方法return的值就是len函数的返回值
# 如果一个obj对象没有__len__方法，那么len函数就会报错
17 # 要求obj必须实现了__len__,要求这个方法的返回值必须是数字int类型

 

__new__

# __new__  # 构造方法 : 在实例化的过程中,最先执行的方法,在执行init之前,用来创建一个对象
# __init__ # 初始化方法 : 在实例化的过程中,在new执行之后,自动触发的一个初始化方法

class Single:
    def __new__(cls, *args, **kwargs):
        print("new方法")
        return object.__new__(cls)

    def __init__(self):
        print("init方法")

# 1.开辟一个空间，属于对象的
# 2.把对象的空间传给self,执行init
# 3.把这个对象的空间返回给调用者
class Single:
    def __new__(cls, *args, **kwargs):
        obj = object.__new__(cls)
        print("new方法", obj)
        return obj

    def __init__(self):
        print("init方法", self)

obj = Single()
# single的new, single没有， 只能调用object的new方法
# new方法在什么时候执行？
  # 在实例化之后,__init__之前先执行new来创建一块空间

单例类

# 如果一个类，从头到尾只能有一个实例，说明从头到尾只开辟了一块属于对象的空间，那么这个类就是一个单例类
class Single:
    __ISINSTANCE = None
    def __new__(cls, *args):
        if not cls.__ISINSTANCE:
            cls.__ISINSTANCE = object.__new__(cls)
        return cls.__ISINSTANCE

    def __init__(self, name, age):
        self.name = name
        self.age = age

s1 = Single("alex", 83)
s2 = Single("taibai", 43)
print(s1, s2)

 

__str__

class Student:
    def __str__(self):
        return '%s %s' % (self.name, self.school)

    def __init__(self, name):
        self.name = name
        self.school = "oldboy"

alex = Student("alex")
print(alex)
print(str(alex))   # 内置的数据类型， 内置的类， 相当于执行__str__
print('学生 : %s' % alex)

# print(obj) 相当于执行obj.__str__方法
# str(obj) 相当于执行obj.__str__方法
# '%s' 相当于执行obj.__str__方法
17 # str(obj),要求必须实现了__str__,要求这个方法的返回值必须是字符串str类型

__repr__

# __str__ : str(obj),要求必须实现__str__,要求这个方法的返回值必须是字符串str类型
            # print %s str
# __repr__ : 是__str__备胎.如果有__str__方法,那么# print %s str都先去执行__str__方法,并且使用str的返回值
#            如果没有__str__,那么print %s str都会执行__repr__
            # repr(obj), %r
# 如果子类没有__str__, 先找父类(除object)的__str__,没有再找子类的__repr__(备胎)
class A:
    def __repr__(self):
        return "A repr"

    def __str__(self):
        return "A str"

class B(A):
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return "B repr"

    # def __str__(self):
    #     return "B str"

a = B("alex")
print(str(a), repr(a))
print("%s | %r" % (a, a))

 

总结：

__call__  相当于 obj()
__len__  相当于 len(obj)
__new__  特别重要， 开辟内存空间，类的构造方法
__str__  str(obj)、print(obj)、'%s' % obj
__repr__  repr(obj)、'%r' % obj还是__str__的备胎
__repr__  在继承中父类__str__优先级高于子类(备胎)__repr__         
所有的双下方法，都没有 需要在外部直接调用的
而是总有一些其他的 内置函数 特殊的语法 来自动触发这些 双下方法

set集合的去重机制:先调用hash,再调用eq,eq不是每次都会触发,只有hash值相等的时候才会触发

hash(obj) # obj内部必须实现了__hash__方法

hash对同一个值在同一次执行python代码的时候hash值永远不变
对同一个值在多次执行python代码的时候hash值是不同的


hash的结果找到一块内存地址,只要这快地址没有数据,就说明之前没有重复的数据
如果这款地址上有数据存在了才判断这个值和要存储的值是否一样
如果一样覆盖去重
如果不一样,二次寻址给这个值换个地址存储