【python基础】魔术方法

　　魔术方法：就是类中的方法(预定义的方法)，在某个特定的时机会被自动的调用。

　　1、__del__()：销毁对象时，被自动的调用

class Person:
    def __init__(self, name):
        self.name = name
        print('%s 被初始化' % self.name)

    def __del__(self):
        print("%s 被删除 " % self.name)


p1 = Person("奶茶")
p2 = Person("蛋糕")

print('xixi')
del p1
print('haha')

# 奶茶 被初始化
# 蛋糕 被初始化
# xixi
# 奶茶 被删除
# haha
# 蛋糕 被删除

　　2、__call__()：

　　　　功能：让类的实例具有类似有函数(方法)的功能。让对象可以被调用, 调用时执行的就是__call__中的函数体

　　　　触发时机：调用对象的时候——对象()

class Person:
    def __init__(self, name, sex, age, sister=None, brother=None):
        self.name = name
        self.sex = sex
        self.age = age
        self.sister = sister
        self.brother = brother

    def __call__(self):  # 获取....
        if self.sex == "boy":
            print(self.sister)
        else:
            print(self.brother)

    def get_age(self):
        print(self.age)


p1 = Person("xixi", "boy", 18, "haha")
print(p1.name)  # xixi
p1.get_age()  # 18
p1()  # haha

　　3、__repr__()：print(对象) 打印对象时会被调用

　　　 __str__()：print(对象) 打印对象时会被调用
　　　

　　　　print(对象)默认情况下打印结果是，对象的内存地址
　　　　重写__str__()方法，返回什么，print(对象)打印的结果就是什么

　　　　区别与联系：

　　　　　　1、TypeError：__repr__ returned non-string (type NoneType)
　　　　　　　　以上两个函数都必须有返回值，且返回值类型为str类型;

　　　　　　2、打印对象时, 如果使用%s占位符, 默认调用的是__str__()方法
　　　　　　　　如果使用%r占位符, 默认调用的是__repr__()方法

　　　　　　3、有repr, 没有str时，%s、%r 都可调用repr方法；
　　　　　　　  没有repr, 有str时， %s 调用的是str的方法，%r 打印的是对象的地址(默认的)

　　　　　　4、print(repr(对象)) 默认调用__repr__()方法
　　　　　　　  print(str(对象)) 默认调用__str__()方法

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

    def __str__(self):
        return "我是str"

    def __repr__(self):
        return "我是repr"


p1 = Person("xixi")
# repr&str方法都没有
# print(p1)  # <__main__.Person object at 0x000000000214D198>

# repr&str方法都有
# print("%s" % p1)  # 我是str
# print("%r" % p1)  # 我是repr

# 只有repr方法:
# print("%s" % p1)  # 我是repr
# print("%r" % p1)  # 我是repr

# 只有str方法
# print("%s" % p1)  # 我是str
# print("%r" % p1)  # <__main__.Person object at 0x00000000026BD198>

print(repr(p1))
print(str(p1))

　　4、__new__(cls)：类方法

　　　　功能：实例化一个对象

　　　　触发时机：当实例化对象的时候，会被自动调用

　　　　返回值：实例化的那个对象;

　　　　__new__(cls)方法将实例化的对象传递给__init__(self)方法的第一个参数;

　　　　__new__()是object类底层的实现——单例

class Person:
    def __new__(cls, *args, **kwargs):  # 必须有返回值: 创建好的对象,类的实例
        print("我是new")
        return super().__new__(cls)

    def __init__(self):
        print("我是init")


p = Person()  # 创建对象
# 我是new
# 我是init
print(p)  # <__main__.Person object at 0x0000000001EA8358>

　　5、__eq__：　　　

　　　　只要俩对象的属性值都相等, 我们就认为这俩对象相等
　　　　通过__eq__()方法去实现，必须有返回值bool用来代表是否相等
　　　　使用__eq__()方法定义比较的规则，对象进行比较时需要使用 == 关系运算符进行比较

 

　　　　对象.__dict__ 获取当前对象的属性, 包括私有(字典{"属性名": "属性值", ...})

 

　　　　（1）基础数据类型的对象
　　　　　　is : 比较的是对象的地址
　　　　　　== : 比较的是对象的内容

 

　　　　　　cmd 对于小整数 [-5, 256] 之间的数字进行了缓存，所以可以在缓存中重复使用
　　　　　　pycharm做了优化，他把不可变数据类型中的很大范围的数据都做了缓存，所以在缓存中可以重复使用
　　　　　　在pycharm中对某些即使很大的整数进行地址的比较 is 都是相等的

 

　　　　（2）自定义类的对象
　　　　　　is 和 == 比较的都是对象的地址

 

a = "12345"
b = "12345"

print(a == b)  # True
print(a is b)  # True
print(id(a))  # 4772224
print(id(b))  # 4772224


list1 = [1, 2, 3, 4]
list2 = [1, 2, 3, 4]
print(list1 == list2)  # True
print(list1 is list2)  # False
print(id(list1))  # 63488968
print(id(list2))  # 63184328


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

    def __eq__(self, other):  # other, 另外一个要进行比较的对象
        if self.__dict__ == other.__dict__:  # 如果当前对象和被比较对象的所有属性值相等, 我们就认为这俩对象相等
            return True
        else:
            return False


p1 = Person('xixi', 6)
p2 = Person('xixi', 6)
print(p1 == p2)  # True
print(p1 is p2)  # False
print(id(p1))  # 43097840
print(id(p2))  # 43101544

 

　　6、__hash__() : 当获取对象的哈希值时，调用该魔术方法

　　　　hash(对象)

　　　　set, list, dict 没有__hash__()方法, hash(列表对象)：报错，不可被哈希
　　　　列表对象.__hash__ ——> None

　　　　如果只定义了__eq__()方法, 而没有定义__hash__(), 默认会将__hash__方法设置为None

# 设计二维坐标类Point判断2个坐标是否相等,
# 并能根据hash函数计算坐标的哈希值;

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        if self.x == other.x and self.y == other.y:
            return True
        else:
            return False

    def __hash__(self):
        return hash((self.x, self.y))

point1 = Point(3, 4)
point2 = Point(3, 4)

print(point1 == point2)  # True

print(hash(point1))  # 3713083796997400956
print(hash(point2))  # 3713083796997400956