面向对象的魔法方法、元类

面向对象的魔法方法

魔法方法：类中定义的双下方法都成为魔方方法
不需要人为调用 在特定的条件下回自动触发运行	
eg:__init__创建空对象之后自动触发给对象添加独有的数据
1__init__
	对象添加独有数据的时候触发
2__str__
	对象被执行打印操作的时候自动触发
3__call__
	对象加括号调用的时候自动触发
4__getattr__
	对象. 不存在的名字的时候自动触发
5__getattribute__
	对象. 名字会自动触发 有它的存在就不会执行上面的__getattr__
6__setattr__
	给对象添加或修改数据的时候自动触发   对象.名字 = 值
7__enter__
	当对象被当作with上下文管理操作的开始自动触发，并且该方法返回as后面的变量名就会接收到什么
8__exit__
	with上下文管理语法运行完毕之后自动触发（子代码结束）

魔法方法笔试题

1补全下列代码使得运行不报错即可
class context:
    def do_something(self):
        pass
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
# context.do_something(context)
#
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.__dict__)#{'__module__': '__main__', '__setattr__': <function MyDict.__setattr__ at 0x0000020F45825F70>, '__getattr__': <function MyDict.__getattr__ at 0x0000020F45836040>, '__dict__': <attribute '__dict__' of 'MyDict' objects>, '__weakref__': <attribute '__weakref__' of 'MyDict' objects>, '__doc__': None, 'name': 'jason', 'pwd': 18, 'hobby': 'read'}
print(obj.name)#jason
print(obj.pwd)#18
print(obj.hobby)#read
print(type(obj))#<class 'type'>
print(obj)

元类简介

"""推导步骤1:如何查看数据的数据类型"""
# s1='hello world'
# l1=[11,22,33,44,]
# d1={'name':'jason','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'>
"""推导步骤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))#<class 'type'> <class 'type'>
"""结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)"""

创建类的两种方式

#方式1：使用关键字class
# class Teacher:
#     school_name='卷卷卷大学'
#     def func1(self):pass
# print(Teacher)
# print(Teacher.__dict__)
#方式2：利用元类type type(类名，类的父类，类的名称空间)
cls=type('Student',(object,),{'name':'jason'})
print(cls)
print(cls.__dict__)
了解知识:名称空间的产生
1.手动写键值对
    针对绑定方法不好定义
2.内置方法exec
    能够运行字符串类型的代码并产生名称空间

元组定制类的产生行为

推导
	对象是由类名加括号产生的  __init__
    类是由元类加括号产生的 __init__
所有类的首字母大写 否则无法产生
#1自定义元类：继承type的类也称之为元类
class MyMetaClass(type):
    def __init__(self,what,bases=None,dict=None):
        print('what',what)
        print('bases',bases)
        print('dict',dict)
        if not what.istitle():
            raise TypeError('首字母应该大写')
        super().__init__(what,bases,dict)
# class myclass(metaclass=MyMetaClass):
#     desc='元类很有趣哦'
class Student(metaclass=MyMetaClass):
        info='我是学生'
print(Student)
print(Student.__dict__)

元类定制对象的产生行为

推导
	对象加括号会执行产生该对象类里面的   __call__
	类加括号会执行产生该类的类里面的	__call__
"""给对象添加独有数据的时候 必须采用关键字参数传参"""

    class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        # 1.产生一个空对象(骨架)
        # 2.调用__init__给对象添加独有的数据(血肉)
        # 3.返回创建好的对象
        # print(args)
        # 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(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种
        创建型
        结构型
        行为型
 	ps:课下感兴趣可以简单看看
3.单例模式
	类加括号无论执行多少次永远只会产生一个对象
 	目的:
        当类中有很多非常强大的方法 我们在程序中很多地方都需要使用
        如果不做单例 会产生很多无用的对象浪费存储空间
        我们想着使用单例模式 整个程序就用一个对象