一、常用魔术方法

（一）__ 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 b
del c

（二）__ 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)

class Fib():
def __init__(self):
pass
def __call__(self, month):
a, b = 0, 1
n = 1
while n <= month:
a, b = b, a+b
n += 1
return a
f = Fib()
print(f(5))

（三）__ repr__()方法

__ str__()方法的备胎，如果找不到__ str__()就找__ repr__()
%r默认调用__ repr__()方法，如果是字符串，默认加上’’
repr()方法默认调用__ 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 '{}'.format(self.name)
a= Per('张三', 19)
print(str(a)) # 张三
print('我说：%r'%(a))  # %r调用__repr__()方法
print('我是：%s'%(a))  # %s调用__str__()方法
print(repr(a)) # 我叫张三，年龄19

（四）__ new__()方法

实例化魔术方法：
在实例化时触发
至少一个cls接受当前类
必须返回一个对象实例
先出发__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('张三', 19)
print(zs.name)

（五）is和==区别

is 比较两个对象的id值是否相等，是否指向统一内存地址
== 比较两个对象的内容是否相等，内存地址可以不一样

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)
print(a is b)
print(id(a))
print(id(b))

__ eq__：默认会调用__eq__()，会比较两个对象的id

class Stu():
def __init__(self, name, age):
self.name = name
self.age = age
def __eq__(self, other):
return self.__dict__==other.__dict__ # 比较两个字典的内容是否相同
a = Stu('张三', 19)
# print(a.__dict__)
b = Stu('张三', 19)
c = Stu('李四', 20)
# print(a == b) # __eq__注销时：False   没注销时：True -- ==调用了__eq__()方法
# print(a is b) # False

d = []
d.append(a)
if b not in d: # list 是通过in是用==进行判断，并调用__eq__()函数
d.append(b)
print(b)

（六）__ hash__()方法

在Python中内置的哈希函数hash()，返回一个对象（数字、字符串，不能直接用于list、set、dictionary）的哈希值

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('张三')
b = Stu('李四')
c = Stu('张三')
print(hex(id(a)))
print(hex(id(b)))
print(hex(id(c)))

d = {a, b, c}
print(d)  # set 通过__eq__()和__hash__()两个函数去重

a = {'name': 5}
a.keys()

二、类的常用函数

（一）issubclass()

查看一个类是否是另外一个类的子类

class A():
pass
class B(A):
pass
print(issubclass(B, A))  # True

（二）isinstance()

检测一个对象是否是某个类的对象

class A():
pass
class B():
pass
a = A()
print(isinstance(a, A)) # True
b = B()
print(isinstance(b, A)) # False

（三）反射方法

1、hasatter() - 判断是否有此变量

2、getatter() - 获取属性值或者获取方法变量的地址

class A():
xiaogou = 10
@staticmethod
def hehe(num):
print('我的数是', num)
print(hasattr(A, 'xiaogou')) # True

print(getattr(A, 'xiaogou')) # 10

a = A()
f = getattr(a, 'hehe') # 还可以获取方法
print(f(9))

3、setatter():给类或者对象设置属性或者方法

class A():
xiaogou = 199
print(A.__dict__)
setattr(A, 'zhutou', 200)
print(A.__dict__)

a = A()
print(a.__dict__)
setattr(a, 'haha', 1999)
print(a.__dict__)
a.hehe = 2022

4、反射导入模块中的属性、函数、类

第一个参数是模块名称，第二个参数是变量名称
demo12:

d = '周二'
def func(name):
print('你好是函数',name)

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

demo13:

import demo12

a = getattr(demo12, 'd')
print(a)

b = getattr(demo12, 'func')
b('李四')

l = getattr(demo12, 'A')
c = l('张三')
print(c.name)

5、反射自己模块中的属性和函数

借助sys模块获取当前模块的名称

import sys

def hahaha():
print('heheheheh')
zhutou = 299
# 所有模块以字典的形式输出
print(sys.modules)
print(sys.modules['__main__'])#反射当前模块

x = getattr(sys.modules['__main__'], 'zhutou')# 反射当前模块的zhutou变量
print(x)
x = getattr(sys.modules['__main__'], 'hahaha')
x()