目录
一、面向对象的魔法方法
魔法方法：类中定义的双下方法都称为魔法方法(以双下划线开头和结尾的方法)，这些方法不允许开发者自己定义
特点是：不需要人为调用，在特定的条件下会自动触发运行
eg: __init__创建空对象完成后自动触发，在对象初始化时给对象添加独有的数据
1.魔法方法介绍
（1）__init__
对象实例化的时候自动触发
class C(object):
def __init__(self, name):
"""类名加括号，给对象添加独有方法"""
self.name = name
print('__init__')
obj = C('duoduo')
# 调用类的时候__init__会自动触发，则会打印'__init__'，然后将空对象，以及调用时括号内传入的参数一同传给__init__方法
obj1 = C('qiuqiu')
print(obj.name)
print(obj1.name)
---------------
__init__
__init__
duoduo
qiuqiu
调用类的过程又称之为实例化，发生三件事
1、先产生一个空对象
2、python会自动调用类中的 __ init __方法然后将空对象以及调用类时括号内传入的参数一同传给 _ _init _ _方法
3、返回初始完成的对象总结
__init __方法1、会在调用类时自动触发执行，用来为对象初始化自己独有的数据
2、__init __内应该存放的是为对象初始化属性的功能，但是也可以存放任意其他代码，想要在类调用时就立刻执行的代码都可以放在该方法内
3、__init __方法必须返回None
（2）__str__
对象被执行打印(print、前端展示)操作的时候自动触发，方法必须返回字符串类型的数据，很多时候用来更加精准的描述对象（通过str方法可以区分打印的是哪个对象）
class C(object):
def __init__(self, name):
"""类名加括号，给对象添加独有方法"""
self.name = name
print('__init__')
def __str__(self):
"""
对象在被执行打印操作的时候自动触发，该方法返回什么打印的结果就是什么
并且该方法必须要返回一个字符串类型的数据
"""
# return f'{self}' 在str方法中不能返回对象本身，由于str方法会自动调用，在str中返回对象则会产生递归调用
return f'返回字符串类型{self.name}'
obj = C('duoduo')
print(obj) # __str__方法在打印对象的时候自动触发
-----------------
__init__
返回字符串类型duoduo
'''通过str方法可以区分打印的是哪个对象'''
# res = obj(123, 321, name='duoduo') # (123, 321) {'name': 'duoduo'}
# print(res)
如果类中没有
__str__方法，打印对象结果会是这个对象的类名，以及对象的内存地址<__main__.C object at 0x102ffaf40>
return f'{self}'在__str__方法中不能返回对象本身，由于str方法会自动调用，在__str__中返回对象则会产生递归调用
（3）__call__
对象加括号调用的时候自动触发，当类中没有__call__的时候该类产生的对象不可调用
class C(object):
def __init__(self, name):
"""类名加括号，给对象添加独有方法"""
self.name = name
def __call__(self, *args, **kwargs):
"""
对象加括号调用的时候自动触发，该方法返回什么对象调用之后的返回值就是什么
"""
print('__call__')
print(args, kwargs)
return 123
obj = C('duoduo')
obj1 = C('qiuqiu')
# 1 调用对象的时候没有传值
res = obj()
print(res)
---------------------
__call__
() {} # 表示该对象并没有独有的数据和功能
123 # __call__ 的返回值是什么，对象调用后的返回值就是什么
# 2 调用对象的时候给__call__的参数传值
re = obj1(123, 321, name='duoduo')
print(re)
-------------------
(123, 321) {'name': 'duoduo'}
123
print(args, kwargs)中为什么是不加*号的参数？ print中没有默认的 name，age参数，但你要
print(sep=',',end="\n")就可以。
一般print（只能打印 1,2,3,4，var， 如果用a=b）,则 a必须是print函数的有名参数。
所以在print中不能用*来打散参数
（4）__getattr__
对象查找不存在名字的时候自动触发
class C(object):
def __init__(self, name):
"""类名加括号，给对象添加独有方法"""
self.name = name
def __getattr__(self, item):
"""对象在查找无法使用的名字时自动触发，该方法返回什么，点不存在的名字就可以得到什么"""
print('__getattr__')
print(item)
obj = C('duoduo')
obj1 = C('qiuqiu')
obj.age
obj1.obj
-----------------------
__getattr__
age
__getattr__
obj
（5）__getattribute__
只要对象查找名字无论名字是否存在都会执行该方法，如果类中有__getattribute__方法 那么就不会去执行__getattr__方法
class C(object):
def __init__(self, name):
"""类名加括号，给对象添加独有方法"""
self.name = name
def __getattr__(self, item):
"""对象在查找无法使用的名字时自动触发，该方法返回什么，点不存在的名字就可以得到什么"""
print('__getattr__')
print(item)
# 当__getattribute__存在的时候，__getattr__方法就不会触发了
def 当__getattribute__存在的时候(self, item):
"""对象在查找名字的时候就会自动触发该方法"""
print('__getattribute__')
return '返回值'
obj = C('duoduo')
obj1 = C('qiuqiu')
res = obj.name # 调用名字后可以用变量名接收__getattribute__的返回值
print(res)
obj1.name
obj.age
obj1.obj
-----------------------
__getattribute__
返回值 # __getattribute__的返回值
__getattribute__
__getattribute__
__getattribute__
当
__getattribute__存在的时候，__getattr__方法就不会触发了
并且只要查找名字就会调用__getattribute__方法
（6）__setattr__
对象在执行添加属性操作的时候自动触发 >>> obj.变量名=变量值
class C(object):
def __init__(self, name):
"""类名加括号，给对象添加独有方法"""
self.name = name
def __setattr__(self, key, value):
"当给对象添加数据的时候，或者更改值的时候 也就是执行对象.名字=值的时候就会自动触发"
print('__setattr__')
print(key, value)
obj = C('duoduo') # 在类调用的时候，括号内传参也有赋值语句的产生，也会调用__setattr__方法
obj.name = 'deft'
obj.age = 13
----------------------
__setattr__
name duoduo
__setattr__
name deft
__setattr__
age 13
# 当类中没有赋值语句时，类名加括号内没有填写的参数的时候，就不会调用__setattr__方法
class C(object):
name = 'duoduo'
def __setattr__(self, key, value):
"当给对象添加数据的时候，或者更改值的时候 也就是执行对象.名字=值的时候就会自动触发"
print('__setattr__')
print(key, value)
obj = C()
obj.name = 'deft'
obj.age = 13
---------------
__setattr__
name deft
__setattr__
age 13
（7）__enter__
当对象被当做with上下文管理操作的开始自动触发，并且该方法返回什么 as后面的变量名就会接收到什么
（8）__exit__
对象被执行with上下文管理语法结束之后自动触发
class C(object):
def __init__(self, name):
"""类名加括号，给对象添加独有方法"""
self.name = name
def __enter__(self):
"""当对象被当作with上下文管理操作的开始自佛难过触发，
并且该方法返回什么，as后面就会收到什么"""
return self
def __exit__(self, exc_type, exc_val, exc_tb): # AttributeError: __exit__
"""当对象参与的with上下文管理语法运行完毕之后自动触发（子代码结束）"""
# __exit__ 方法相当于自动调用了一个f.close方法，用来回收资源，所以当用with方法来管理对象的时候，需要在产生对象的类中有__exit__方法
"with 方法"
with C('duoduo') as f:
f.name = 'deft'
f.age = 13
print(f.__dict__)
----------------------
{'name': 'deft', 'age': 13}
with方法将类产生的实例用as后面的别名f来接收，可以通过f加.的方法来对这个实例进行添加和更改属性
（9）__del__
对象被执行(被动、主动)删除操作之后自动执行
class A:
def __init__(self, name):
self.name = name
def __call__(self):
print(f"{self.name}对象被调用")
return 10
def __del__(self):
print(f"{self.name}对象被销毁")
a = A('a')
a2 = A('a2')
a()
a2()
del a # 会主动执行__del__方法
print('================')
-------------------------
a对象被调用
a2对象被调用
a对象被销毁
================
a2对象被销毁 # 当程序运行结束，要回收整个程序内存空间，相当于资源全部删除，a2对象也会被__del__方法回收
2.魔法方法笔试题
1）补全下列代码使得运行不报错
（1）有with上下文管理需要有__enter __，as后面的变量名f 接收该返回值
（2）有with上下文管理结束需要有__exit__
（3）添加do_something方法
class Context: # 1定义一个类
def do_something(self): # （3）添加do_something方法
pass
def __enter__(self): # （1）有with上下文管理需要有__enter__
# as后面的变量名f 接收该返回值
return self
def __exit__(self, exc_type, exc_val, exc_tb): # （2）有with上下文管理结束需要有__exit__
pass
with Context() as f: # 2 Context加()产生对象
f.do_something() # 3 对象执行do_something方法
2）自定义字典类型并让字典可以用点的方式点出字典的方式
# 2.自定义字典类型并让字典可以用点的方式点出字典的方式
class My_dict(dict):
def __setattr__(self, key, value):
"""重写了__setattr__方法，在新的字典中添加键值对"""
self[key] = value
def __getattr__(self, item):
"""重写了__getattr__方法，在新的字典中通过get方法取得键的值"""
return self.get(item)
obj = My_dict()
"通过重写的setattr方法，来为自定义字典添加键值对"
obj.name = 'duoduo'
obj.age = 19
obj.gender = 'male'
# print(obj) # 字典存储的数据 {}
# print(obj.__dict__) # 字典对象名称空间
"通过重写的__getattr__方法，来为获取自定义字典中键对应的数据值"
print(obj.name) # duoduo
print(obj.age) # 19
print(obj.gender) # male
二、元类
0.元类type
推导步骤1 : 如何查看数据的数据类型
s1 = 'hello world'
l1 = [11, 22, 33, 44]
d1 = {'name': 'duoduo', 'pwd': 123}
t1 = (11, 22, 33, 44)
print(type(s1)) # <class 'str'>
print(type(l1)) # <class 'list'>
print(type(d1)) # <class 'dict'>
print(type(t1)) # <class 'tuple'>
"str方法是一个类"
推导步骤2：其实type方法是用来查看产生对象的类
class Student:
pass
obj = Student()
print(type(obj)) # <class '__main__.Student'>
推导步骤3：python中一切皆对象，那么type查看类名显示的是什么
class Student:
pass
obj = Student()
print(type(Student)) # <class 'type'>
print(type(type)) # <class 'type'> type 也是由自身type产生的
"""
结论：我们定义的类其实都是有type类产生的>>>:元类
类本身不过是一个名为 type 类的实例
"""
结论：我们定义的类其实都是有type类产生的>>>type类被称为元类
类本身不过是一个名为 type 类的实例
1.元类定制类的行为
了解元类如何定制类的行为，则可以去对类的行为进行干预，产生出我们想要的类
（1）创建类的两种方法
- 方式1：使用关键字class
class MyClass:
pass
print(MyClass)
print(MyClass.__dict__)
-------------结果-------------
<class '__main__.MyClass'>
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None}
- 方式2：利用元类type
通过查看type源码发现元类初始化实例的参数为：type(类名what， 类的父类bases，类的名称空间dict)
# 则可以用变量名来接收元类type初始化实例后的结果，其结果就是一个type元类产生的类
cls = type('Student', (object,), {})
print(cls)
print(cls.__dict__)
-----------结果--------------
<class '__main__.Student'>
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
# 通过type也可以产生类，并且cls的名称空间中也具有和关键字class所产生的类一样的名字
type产生的类，其名称空间如何产生数据和方法：
1.手动写键值对（定义函数的话很难写）
但是针对绑定方法不好定义
2.内置方法exec可以产生一个名称空间，
编写一个字符串代码，用exec来产生名称空间
（2）元类定制类的产生行为
我们知道，对象由类名加括号(类的调用)所产生，而对象的独特方法由类的__init__方法产生
以此类推，类是由元类加括号产生 ，则类的方法则会由元类的__init__产生，那么我们可以通过定制元类的__init__方法来定制类的方法
比如：**我们想要定制所有类必须首字母大写，否则无法产生 ** --> 定制类的行为，所以要用到元类type
1.自定义元类：继承了type到类也称之为元类
class MyMetaClass(type):
def __init__(self, what, bases=None, dict=None):
"""what是类名，bases是父类，dict是名称空间
所以想对类名
"""
# print('what', what) # what myclass
# print('bases', bases) # bases ()
# print('dict', dict) # dict {'__module__': '__main__', '__qualname__': 'myclass'}
if not what.istitle():
raise TypeError('类名首字母应该大写')
super().__init__(what, bases, dict)
2.指定类的元类:利用关键值metaclass指定类的元类
class myclass(metaclass=MyMetaClass): # TypeError: 类名首字母应该大写 当首字母没有大写当时候，则会报错
desc = '你好'
class Myclass(metaclass=MyMetaClass): # 类名首字母大写则不会报错
desc = '你好'
（3）元类定制对象的产生行为
我们知道，对象加括号会执行产生该对象类里面的 __call__
以此类推，类加括号会执行产生该类的类（元类）里面的 __call__，那么我们可以通过定制元类的__call__方法来定制类产生对象的方法
比如：**我们想要定制：给对象添加独有数据的时候，必须采用关键字参数传参 ** --> 定制对象的产生行为，可以通过元类type的__call__方法来定制
class MyMetaClass(type):
def __call__(self, *args, **kwargs):
"""
当有对象产生的时候，__call__做的事情：
1。产生一个空对象
2。调用__init__给对象添加独有的数据
3。返回创建好的对象
"""
# print('call')
# print(args) # ('duoduo', 18, 'read')
# print(kwargs) # {}
if args:
raise TypeError('无法位置传参')
return super().__call__(*args, **kwargs) # __call__的值必须返回才能获得
class Student(metaclass=MyMetaClass):
def __init__(self, name, age, hobby):
print('init')
self.name = name
self.age = age
self.hobby = hobby
obj = Student(name='duoduo', age=18, hobby='read')
print(obj.__dict__) # {'name': 'duoduo', 'age': 18, 'hobby': 'read'}
三、魔法方法之__new__方法
class MyMetaClass(type):
def __call__(cls, *args, **kwargs):
"""
当有对象产生的时候，__call__做的事情：
1。产生一个空对象
1>>> __new__方法来产生的一个空对象
2。调用__init__给对象添加独有的数据
3。返回创建好的对象
"""
__obj = cls.__new__(cls, args, kwargs)
cls.__init__(__obj, *args, **kwargs)
return __obj
# return 123 当返回123的时候，对象就是123
class Student(metaclass=MyMetaClass):
def __init__(self, name):
print('init')
self.name = name
obj = Student('duoduo')
# print(obj) # 123
print(obj.name) # duoduo