7.30 python 日学 魔术方法

1.del()方法
销毁魔术方法，当一个对象在内存中被销毁的时候自动执行
注意：程序自动调用此方法，不需要手动调用

class A():

num=0

def init(self,name):

A.num+=1

self.name=name

def del(self):

A.num-=1

print(self.name,‘被删除，还剩{}个对象’.format(A.num))

a=A(‘张三’)

b=A(‘李四’)

c=A(‘王五’)

print(A.num)

del a #垃圾回收机制，这三句即使被注释，只要不再使用，都会自动触发__del__函数

del b

del c

2.call()方法
该方法可以让类的实例具有类似函数的行为，进一步模糊了函数和对象之间的概念
使用方式：对象后面加括号，触发执行

class A():

def init(self,num):

self.num=num

def call(self,n):

return self.num*n

a=A(7)

b=a(9)

print(b)

使用__call__()函数实现斐波那契数列

class Fib():

def init(self):

pass

def call(self, month):

lst = []

a, b = 0, 1 #1,1

n = 1

while n <= month:

lst.append(a)

a, b = b, a + b

n += 1

return a #lst

f = Fib()

for i in range(1, 10):

print(f(i))

3.repr()方法
该方法改变对象的字符串显示
是__str__()函数的备胎，找不到str，就会找该方法。
%r默认调用__repr()方法，字符串默认加上’’

class Per():

def init(self,name,age):

self.name=name

self.age=age

def repr(self):

return ‘我叫{}，年龄{}’.format(self.name,self.age)

def str(self):

return ‘我叫{}，年龄{}(str() )’.format(self.name, self.age)

a=Per(‘张三’,19)

print(‘我是：%r’%(a))

print(‘我是：%s’%(a))

print(repr(a))

4.new()方法
实例化方法，触发时机：在实例化对象是触发
参数：至少一个cls接受当前类
返回值：必须返回一个对象实例
注意：实例化对象是object类底层实现
没事不要碰这个魔术方法，先触发__new__()，在__init__()方法

class Stu():

def new(cls, *args, **kwargs):#实例化，实际上是创建一个新的对象

print(‘111111111111’)

return object.new(cls)#用object类，去创建一个此类的对象实体cls，代表的是本类

def init(self,name,age):#初始化的时候触发

print(‘222222222222’)

self.name=name

self.age=age

zs=Stu(‘zs’,11)#先实例化zs，在对zs进行初始化

print(zs.name)

6.eq()和__hash__()
首先了解is 和==

a=[1,2,3]

b=[1,2,3]

print(a==b)

print(a is b)

print(id(a))

print(id(b))

class Stu():

def init(self,name,age):

self.name=name

self.age=age

def eq(self, other): #② 默认比较id

return self.dict==other.dict

a=Stu(‘zs’,19)

b=Stu(‘zs’,19)

c=Stu(‘ls’,20)

# print(a.dict)

print(a==b)#① 当①不注释，②注释时候，运行结果为 False，②不注释时，结果为True。解释：不通过equal进行比较，a和b是两个类对象进行比较，a和b不相等，故返回False；通过equal进行比较，则是根据equal方法的判断条件来返回真假，本例则是根据对象的dict来判断真假

print(a is b)

d=[]

d.append(a)

if b not in d:

d.append(b)

print(d)

hash也翻译成散列，哈希算法是一个不定长的输入，通过哈希函数变换成一个定长的输出，即哈希值
常见的哈希算法有：SM3，MD5，SHA-1等
在不同的应用场景下，hash函数的选择也会有所侧重，比如在管理数据结构时，主要考虑运算的快速性

class Stu():

def init(self,name):

self.name=name

def eq(self, other):

return self.name==other.name

def hash(self):

return hash(self.name)

a=Stu(‘zs’)

b=Stu(‘ls’)

c=Stu(‘zs’)

# print(hash(a))

# print(id(a)/16)

print(hex(id(a)))

print(hex(id(b)))

print(hex(id©))

print(hash(a))

print(hash(b))

print(hash©)

d={a,b,c}

print(d)

set集合要求数据类型是可哈希的，dict数据结构的key必须是可哈希的

7.类的常用函数
issubclass()
检测一个类是否是另外一个类
返回值：布尔值
格式：issubclass（被检测类（父类…））

isinstance()
检测一个对象是否是某个类的对象
返回值：布尔
格式：isinstance（对象，（类））

class A():

pass

class B(A):

pass

print(issubclass(B,A))

a=A()

print(isinstance(a,A))

反射方法
python面向对象中的反射：通过字符串的形式操作对象相关的属性
python中的一切事物都是对象（都可以使用反射）

getattr（）
获取对象/类的成员值
格式：getattr（对象，‘属性名’）
返回值：对象的值

hasattr（）
判断是否有此变量
格式：hasattr（对象/类，‘成员名’）
返回值：布尔值

setattr（）
设置或添加对象/类中的成员
格式：setattr（对象，‘成员名’，值）
返回值：None

delattr（）
删除对象/类中的成员
格式：delattr（对象，成员）
返回值：None

class A():

xiaogou=10

@staticmethod

def hehe(num):

print(num)

b=hasattr(A,‘xiaogou’)

print(b)

c=getattr(A,‘xiaogou’)

print©

delattr(A,‘xiaogou’)

a=A()

f=getattr(A,‘hehe’)

f(9)

导入反射模块的属性，函数，类
具体做法：新建一个py文件，在里面写入想要反射的代码，在另一个py文件导入

import test27im

‘’’
这是test27im的内容
d=‘周二’
def func(a):
print(‘这是函数’,a)
class A():
def init(self,name):
self.name=name
‘’’

x=getattr(test27im,‘d’)

print(x)

f=getattr(test27im,‘func’)

f(‘香蕉皮’)

cls=getattr(test27im,‘A’)

a=cls(‘张三’)

print(a.name)