## 面向对象的魔法方法 ```python 魔法方法:类中定义的双下方法都称为魔法方法 不需要人为调用 在特定的条件下回自动触发运行 eg:__init__创建空对象之后自动触发给对象添加独有的数据 1.__init__ 对象添加独有数据的时候自动触发 2.___str__ 对象被执行打印操作的时候自动触发 3.__call__ 对象加括号调用的时候自动触发 4.__getattr__ 对象点不存在的名字的时候自动触发 5.__getattribute__ 对象点名字就会自动触发 有它的存在就不会执行上面的__getattr__ 6.__setattr__ 给对象添加或者修改数据的时候自动触发 对象.名字 = 值 7.__enter__ 当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么 8.__exit__ with上下文管理语法运行完毕之后自动触发(子代码结束) ``` ```python 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) ``` ### 魔法方法笔试题 ```python 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)) ``` ## 元类简介 ```python """推导步骤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'> ``` ## 创建类的两种方式 ```python # 第一种关键字 class Student: pass print(Student) # 第二种 元类创建 cls = type('Student', (object,), {}) # 第一个参数为类的名字 第二个是要继承的父类 第三个是类的名称空间 print(cls) """ 了解知识：名称空间的产生 1.手动填写键值对 针对绑定方法不好定义 2.内置方法exec 能够运行字符串类型的代码并产生名称空间 """ ``` ## 元类定制类的产生行为 ```python """ 推导 对象是由类名加括产生的 调用类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: 不是以大写之母开头报错 ``` ## 元类定制对象的产生行为 ```python """ 推导 对象加括号会执行产生该类里面的 __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 ```python 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__可以产生空对象 """ ``` 设计模式 ```python 1.设计模式 前人通过大量的验证创建出来解决一些问题的固定高效方法 2.IT行业 23种 创建型：5种 结构型：7种 行为型：11种 3.单例模式 类加括号无论执行多少次永远只会产生一个对象 目的： 当类中有很多非常强大的方法 我们在程序很多地方都需要使用 如果不做单例 会产生很多无用的对象浪费存储空间 我们想着使用单例模式 整个整型就用一个对象则可以节省大量内存空间 ``` ## 元类全流程 ```python """ 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()) return res # 用元类创建这个类对象，里面有类的名称空间，与这个类的继承,还有类种的方法与属性 # 不会立即返回出去也是等init执行完返回出去 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__) return res # 不会立即返回出去也是等init执行完返回出去 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) ``` Last modification：November 8th, 2022 at 11:03 pm © 允许规范转载 Support 如果觉得我的文章对你有用，请随意赞赏 ×Close Appreciate the author Sweeping payments
Comment here is closed