#常用魔术方法
1.del
#销毁魔术方法
触发时机：当一个对象在内存中被销毁的时候自动执行
#参数：至少有一个self。接收对象
返回值：无
#作用：在对象销毁的时候做一些操作
注意：程序自动调用此方法，不需要我们手动调用。
cl

ass Person:
    def __init__(self):
        print('init')
    def __del__(self):
       print('程序结束了')
 person=Person()
 print('完蛋了')

当程序对象不再使用继续执行的时候自动销毁

2. call

**
#call():可以让类的实例具有类似于函数的行为
进一步模糊了函数和对象的概念
使用方式：
对象后面加括号，触发执行。即：对象（）或者类（）
cl

ass Person:
     def __call__(self, *args, **kwargs):
         print('call...')
#person=Person()#将Person地址赋值给他
#person()#内存地址
#Person()()#内存地址
#把call当成函数

#斐波那契数列

#class Fibonacci(object):
   def __call__(self, num):
         a, b = 1, 1
         self.lst = []
         if num <= 2:
             self.lst.append(1)
             self.lst.append(2)
         else:
             for i in range(1, num + 1):
                 self.lst.append(a)
                 a, b = b, a + b
         return self.lst
     def __str__(self):
         return str(self.lst)
 f=Fibonacci()
 ret=f(100)
 print(ret)

3. _repr

repr():改变对象的字符串显示
此方法是__str__()的备胎，如果找不_str_()就会找到_repr_()方法。# -%r默认调用的是__repr()方法，如果是字符串会默认加上’’.
repr()方法默认调用__repr__（）方法

 class Person(object):
     def __init__(self,name,age):
         self.name=name
         self.age=age
     def __str__(self):#      
        return str(self.__dict__)
##     def __repr__(self):#         #是str的备胎  作用相同
#         msg='name={},sge={}'.format(self.name,self.age)
#         return msg
#
# person=Person('zs',33)
#有_str_方法就会调用_str_()方法
#如果没有_str_()方法就会调用_repr_()方法
# print(person)
# %r 调用字符串  默认给字符串添加
# text='l am said: %s.'% text
# text='l am said: %r.'% text
#%r  默认调用_repo_()
# print('l said: %r .'% per)#调用 _repr_()
# print('i say %s.,'% per)#调用_str_()
#repr() 默认调用_repr_方法
#print(repr(per))

4.new

实例化魔术方法
触发时机：在实例化是触发
参数：至少一个cls接收当前类
返回值：必须返回一个对象实例
作用：实例化对象
注意：实例化对象是objeck类底层实现，其他类继承了objeck的_new_才能够实现实例化对象。
#没事别碰这个魔术方法，先触发_new_才会触发_init_.

#
# class Dog(object):
#     # def __new__(cls, *args, **kwargs):
#     #     print('------_new1111--')
#     def __init__(self):
#         print('-----_init_22222---')
#     def __del__(self):
#         print('----_del_----')
# class Dog1(Dog):
#     def jiji(self):
#         print('dijia ')
# b=Dog()
# print('jffjfjjf扣积分抵扣')
# a=Dog()
# # dog1=Dog1
# # dog1()

5.str

#触发时机：使用print（对象）或者str（对象）的时候触发
#参数：一个self接收对象
#返回值：必须是字符串类型
#作用：print（对象时）进行操作，得到字符串，通常用于快捷操作
#注意：无在python中使用print（）函数输出对象名称的时候默认情况下，会打印对象名应用的内存地址，如果希望打印对象的属性值，可以使用_str_(self)

 class Cat:
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
#     def __str__(self):
#         return '姓名：{}，年龄；{}'.format(self.name,self.age)
# cat=Cat('zs',33)
# print(cat)

6.python中的比较is和

is比较俩个对象的id值是否相同，是否指向同一个内存地址；
#==比较的是俩个对象的内容是否相等，即内存地址可以不一样，内容一样就可以了。
#默认会调用对象的__eq__()方法，继承自object的_eq__方法比较俩个对象的id

lst1 = [1, 2, 3]
 lst2 = [1, 2, 3]
# print(lst1 == lst2)
# print(lst1 is lst2)
# #输出
# # True
# # False
# class Person(object):
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#
#
# per1 = Person('lee', 10)
# per2 = Person('lee', 10)
# print(per1 == per2)
# print(per1 is per2)
# # 打印结果：
# # False
# # False

是因为，它们在比较时候，调用的是对象中的__eq__方法比较，其默认比较的是内存地址。
如果要更改比较方式，则需要在__eq__方法中修改一下，如下代码所示

# class Person(object):
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#
#     def __eq__(self, other):
#         return self.__dict__ == other.__dict__
#
# per1 = Person('lee', 10)
# per2 = Person('lee', 10)
# print(per1 == per2)
# print(per1 is per2)
# # 输出为：
#
# True
# False

#哈希（hash）也翻译作散列。Hash算法，是将一个不定长的输入，通过哈希函数变换成一个定长的输出，即哈希值。

这种哈希变换是一种单向运算，具有不可逆性即不能根据哈希值还原出输入信息。常见的hash算法有：SM3、MD5、SHA-1等。

#Hash主要应用在数据结构以及密码学领域。
#在不同的应用场景下，hash函数的选择也会有所侧重。比如在管理数据结构时，主要要考虑运算的快速性。
#在python中有内置的哈希函数hash()，返回一个对象（数字、字符串，不能直接用于 list、set、dictionary）的哈希值。示例代码如下：

# s = 'hello'
# ret = hash(s)
# print(ret)

# 输出的结果为：

2362592656088286249

#在python中set集合要求数据类型是可哈希的，因为set集合会默认调用对象的__hash__函数进行快速查询，如果找到了则调用对象的__eq__判断两个是是否相同，如果相同则不添加。
#保证数据的唯一性(自动去重功能)。
#dict 数据结构的key必须是可哈希的，因为dict是无序的因此通过key的hash算法来快速查询，节约时间。

在自定义类中，如果没有实现__eq__()和__hash__()方法，会继承object的__eq__()方法和__hash__()方法。

#hash()函数默认调用Object类的__hash__()方法。Hash值是对象id值1/16。

自定义对象添加到集合中，我们一般认为两个对象的属性值相同就是同一个对象。因此需要我们手动复写__eq__方法和__hash__方法。

# 用__hash__方法和__eq__方法解释集合去重

# class Person(object):
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#
#     def __eq__(self, other):
#         return self.__dict__ == other.__dict__
#
#     def __hash__(self):
#         return hash(self.name) + hash(self.age)


# 集合自动去重
# 先根据hash去快速查询有没有一个对象的hash值和我的相同
# per1 = Person('zs', 10)
# per2 = Person('zs', 10)
# set1 = {per1, per2}
# print(set1)

# 输出为：

# {<__main__.Person object at 0x0000000001E7C8D0>}

python的常用魔法方法总结（初学者可以试着练习一下）

2. call

3. _repr

4.new

5.str

6.python中的比较is和

猜你喜欢