魔法方法与元类
面向对象的魔法方法
魔法方法:类中定义的双下方法都称为魔法方法
不需要人为调用 在特定的条件下回自动触发运行
eg:__init__创建空对象之后自动触发给对象添加独有的数据
1.__init__
对象添加独有数据的时候自动触发
2.___str__
对象被执行打印操作的时候自动触发
3.__call__
对象加括号调用的时候自动触发
4.__getattr__
对象点不存在的名字的时候自动触发
5.__getattribute__
对象点名字就会自动触发 有它的存在就不会执行上面的__getattr__
6.__setattr__
给对象添加或者修改数据的时候自动触发 对象.名字 = 值
7.__enter__
当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么
8.__exit__
with上下文管理语法运行完毕之后自动触发(子代码结束)
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
"""打印对象则会自动触发"""
# return 'aaa'
# return '1231' # 必须返回字符串类型数据
def __call__(self, *args, **kwargs):
"""对象加括号则会触发调用"""
# print(args, kwargs) # (123, 456) {'name': 1234}
return self
def __getattr__(self, item):
"""对象点名字不存在，则会触发"""
# print(item)
# return self # 返回对象
# def __getattribute__(self, item):
"""无论对象点名字是否存在，都会自动触发，一般不建议使用，建议使用上面的"""
# print(item)
# return self # 返回对象
# def __setattr__(self, key, value):
"""给对象添加或修改对象数据，对象.name = 数据值 会自动触发"""
# self.key = value
# print(key,value)
# return
def __enter__(self):
"""当对象被当作上下文管理操作的开始自动触发 并且该方法返回什么 as 后面变量名就会接收到什么"""
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""with上下文管理语法运行完毕之后自动触发(子代码结束)"""
pass
obj = Student('张三', 18)
# print(obj.name)
# print(obj) # aaa
# print(obj(123, 456, name=1234)) # 1234
# print(obj.aaa) # 这里相当于又打印了
# obj.aaa = '123'
with obj as f:
print(f.age)
魔法方法笔试题
1.补全下列代码使得运行不报错即可
class Context:
pass
with Context() as f:
f.do_something()
class Context:
def do_something(self):
pass
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
with Context() as f:
f.do_something()
2.自定义字典类型并让字典能够通过句点符的方式操作键值对
class MyDict(dict):
def __setattr__(self, key, value):
self[key] = value
def __getattr__(self, item):
return self.get(item)
obj = MyDict()
obj.name = 'jason'
obj.pwd = 18
obj.hobby = 'read'
# print(obj)
print(obj.name)
print(obj.pwd)
print(obj.hobby)
# print(obj)
# print(obj) # 字典存储的数据 {}
# print(obj.__dict__) # 字典对象名称空间 {'name': 'jaso
print(type(obj))
元类简介
"""推导步骤1:如何查看数据的数据类型"""
# s1 = 'hello world' # str()
# l1 = [11, 22, 33, 44] # list()
# d1 = {'name': 'jason', 'pwd': 123} # dict()
# t1 = (11, 22, 33, 44) # tuple()
# print(type(s1)) # <class 'str'>
# print(type(l1)) # <class 'list'>
# print(type(d1)) # <class 'dict'>
# print(type(t1)) # <class 'tuple'>
"""推导步骤2:其实type方法是用来查看产生对象的类名"""
# class Student:
# pass
# obj = Student()
# print(type(obj)) # <class '__main__.Student'>
"""推导步骤3:python中一切皆对象 我们好奇type查看类名显示的是什么"""
class Student:
pass
obj = Student()
print(type(obj)) # <class '__main__.Student'>
print(type(Student)) # <class 'type'>
class A:pass
class B:pass
print(type(A), type(B))
"""结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)"""
print(type(type)) # <class 'type'>
创建类的两种方式
# 第一种关键字
class Student:
pass
print(Student)
# 第二种 元类创建
cls = type('Student', (object,), {}) # 第一个参数为类的名字 第二个是要继承的父类 第三个是类的名称空间
print(cls)
"""
了解知识：名称空间的产生
1.手动填写键值对
针对绑定方法不好定义
2.内置方法exec
能够运行字符串类型的代码并产生名称空间
"""
元类定制类的产生行为
"""
推导
对象是由类名加括产生的 调用类init方法
类是由元类加括号产生的 调用元类种init方法
"""
# 自定义元类：继承type的类也称之为元类
class MyClass(type):
def __init__(self, what: str, bases=None, dict=None):
if not what.istitle():
raise TypeError("不是以大写之母开头")
super().__init__(what, bases, dict)
# 指定类的元类：利用关键字metaclass指定类的元类
class A(metaclass=MyClass): # 类名加括号触发产生这个类(元类)的双下init方法
pass
obj = A() # 正常创建
class aA(metaclass=MyClass): # 类名加括号触发产生这个类的类里的双下init方法
pass
obj = aA() # TypeError: 不是以大写之母开头报错
元类定制对象的产生行为
"""
推导
对象加括号会执行产生该类里面的 __call__方法
类加括号会执行产生该类的元类里面的 __call__方法
"""
"""给对象添加独有数据的时候 必须采用关键字参数传参"""
class MyMetaClass(type):
def __call__(self, *args, **kwargs):
# 1.产生一个空对象(骨架)
# 2.调用__init__给对象添加独有的数据(血肉)
# 3.返回创建好的对象
# print(args) # ('jason', 18, 'male')
# print(kwargs) # {}
if args:
raise TypeError("你怎么回事 Jason要求对象的独有数据必须按照关键字参数传参 我看你是不想干了！！！")
return super().__call__(*args, **kwargs)
class Student(metaclass=MyMetaClass):
def __init__(self, name, age, gender):
# print('__init__')
self.name = name
self.age = age
self.gender = gender
# obj = Student('jason', 18, 'male')
obj = Student(name='jason',age= 18,gender= 'male')
print(obj.__dict__)
魔法方法之算个下new
class MyMetaClass(type):
def __call__(self, *args, **kwargs):
# 1.产生一个空对象(骨架)
obj = self.__new__(self)
# 2.调用__init__给对象添加独有的数据(血肉)
self.__init__(obj,*args, **kwargs)
# 3.返回创建好的对象
return obj
class Student(metaclass=MyMetaClass):
def __init__(self, name):
self.name = name
obj = Student('jason')
print(obj.name)
"""
__new__可以产生空对象
"""
设计模式
1.设计模式
前人通过大量的验证创建出来解决一些问题的固定高效方法
2.IT行业
23种
创建型：5种
结构型：7种
行为型：11种
3.单例模式
类加括号无论执行多少次永远只会产生一个对象
目的：
当类中有很多非常强大的方法 我们在程序很多地方都需要使用
如果不做单例 会产生很多无用的对象浪费存储空间
我们想着使用单例模式 整个整型就用一个对象则可以节省大量内存空间
元类全流程
"""
Author:clever-cat
time :2022/11/8-18:05
"""
class MyClass(type):
# 第二步 这个方法在没有双下new他来接管如果有，则这个当作辅助的东西,不管加不加括号都会执行,这个方法
def __init__(self, *args, **kwargs): # 只是执行一下，要不要无所谓 # 跟实例化后的obj()有没有括号也没有关系
print('init')
pass
"""下面的在有双下new的时候有没有都无所谓"""
# print('from MyClass __init__')
# print(args,kwargs)
# print(id(self), self, 'from MyClass __init__调用之前', type(self), self.__dict__)
# res = super().__init__(*args, **kwargs) # 调用的是type这个元类的init，创建这个类
# print(id(self), self, "from MyClass __init__调用之后", type(self), self.__dict__)
def __call__(cls, *args, **kwargs): # 第三步 把数据绑定给类
print("from MyClass __call__")
print(cls.__dict__, 'bbbbbbbb')
res = super().__call__(*args, **kwargs) # 第6步 接收到下面传来的值，把这值赋值给res
print(id(res), "from MyClass __call__", type(res), res.__dict__)
return res # 在由 这个是把绑定好数据的对象返回给obj
def __new__(cls, *args, **kwargs): # 第一步 创建T1这个类 相当于有了双下new这个这个方法init就可以不需要了
# print(args, kwargs)
if not args[0].istitle(): # 可以直接在这里加限制，init相当于辅助可有可无
raise NameError('名字必须大写')
"""用元类type里面的双下new方法创建类"""
res = super().__new__(cls, *args, **kwargs) # 用元类创建这个类对象，里面有类的名称空间，与这个类的继承,还有类种的方法与属性
print(id(res), res, type(res), res.__dict__, res.mro())
# 会自动执行init
return res # 用元类创建这个类对象，里面有类的名称空间，与这个类的继承,还有类种的方法与属性
class B:
pass
class T1(B, metaclass=MyClass):
def __init__(self, name): # 第五步 绑定数据给对象 然后返回给了 元类里面的super().__call__这个调用
print(id(self))
self.name = name
print("from T1 __init__", self.__dict__)
def __call__(self, *args, **kwargs): # 第9步，对象名加括号自动触发了这个，然后执行
print(args, kwargs)
print("from T1 __call__")
return self
def __new__(cls, *args, **kwargs): # 第四步 进入到里面 创建类的实例化的对象也就是obj
print("from T1 __new__")
"""用object类创建对象"""
res = super().__new__(cls) # 由object类创建对象
print(id(res), "from T1 __new__", res.__dict__)
# 会自动执行init
return res
cls = T1
obj1 = cls('张三') # 第7步接收
print(id(cls), 'T1这个类', cls, obj1)
obj1(1312,1231,'123123',namea='1231') # 第8步 对象名加括号可以传值
# print(id(MyClass),'MyClass这个元类')
# print(obj1.name)
# print(obj1(121,456))
# print(id(obj1),'obj这个对象')
# obj = T1(name='张')
# print(id(T1), 'main T1')
# print(id(obj), 'main obj')
# print(T1.mro())
# print(obj().name)
