面向对象魔法方法与元类

阅读目录

• 面对对象的魔法方法
• 魔法方法笔试题
• 元类简介
• 创建类的两种方式
• 元类定制类的产生行为
• 元类定制对象的产生行为
• 魔法方法之双下new
• 设计模式简介

 

---

今日内容

• 面向对象的魔法方法

• 基于魔法方法的笔试题

• 元类简介

• 创建类的两种方式

• 元类定制类的产生行为

• 元类定制对象的产生行为

• 魔法方法之双下new方法

• 设计模块简介及单例模式

回到顶部

面对对象的魔法方法

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

双下init方法(_init_)

class C(object):
    def __init__(self, name):
        """类名加括号 给对象添加独有数据时自动触发"""
        self.name = name
        print('__init__')


obj = C('jason')

双下str方法(_str_)

class C(object):
    def __init__(self, name):
        """类名加括号 给对象添加独有数据时自动触发"""
        self.name = name
        # print('__init__')

    def __str__(self):
        """
        对象在被执行打印操作的时候自动触发 该方法返回什么打印的结果就是什么
        并且该方法必须要返回一个字符串类型的数据
        """
        return '哈哈哈'
        # return 123  # 报错


obj = C('jason')
# print(obj)    # <__main__.C object at 0x000001A053043FD0> 产生对象的类中没有双下str
print(obj)      # 哈哈哈   产生对象的类中有双下str

双下call方法(_call_)

class C(object):
    def __init__(self, name):
        self.name = name

    def __call__(self, *args, **kwargs):
        """
        对象加括号调用的时候自动触发 该方法返回什么对象调用之后的返回值就是什么
        """
        print('__call__')
        print(args, kwargs)
        return 123


obj1 = C('jason')
# obj1()  # __call__
res = obj1(123, 456, name='jason')
print(res)

双下getattr方法(_getattr_)

class C(object):
    def __init__(self, name):
        self.name = name

    def __getattr__(self, item):
        """对象在查找无法使用的名字的时候自动触发 该方法返回什么 点不存在的名字就可以得到到什么"""
        # print('__getattr__')
        # print(item)
        return f'抱歉 您索要的名字{item}根本不存在'


obj1 = C('jason')
print(obj1.name)
print(obj1.age)

双下getattribute方法(_getattribute_)

class C(object):
    def __init__(self, name):
        self.name = name

    def __getattr__(self, item):
        """对象在查找无法使用的名字的时候自动触发 该方法返回什么 点不存在的名字就可以得到到什么"""
        # print('__getattr__')
        # print(item)
        return f'抱歉 您索要的名字{item}根本不存在'

    def __getattribute__(self, item):
        """对象在查找名字的时候就会自动触发该方法"""
        print('__getattribute')
        return '哈哈哈'

    # 如果类中有__getattribute__方法 那么就不会去执行__getattr__方法

obj1 = C('jason')
print(obj1.name)
# print(obj1.age)

双下setattr方法(_setattr_)

class C(object):
    def __init__(self, name):
        self.name = name
    """当对象执行 对象.名字 = 值 的时候就会自动触发"""
    def __setattr__(self, key, value):
        # print('__setattr__')
        print(key, value)


obj = C('jason')
obj.age = 18

双下enter方法(_enter_)

# 双下enter(enter) 和 双下exit（exit）必须一起使用 要不会报错

class C(object):
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        """当对象被当作with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量就会接收到什么"""
        return 123
    
obj = C('jason')
with obj as f:
    print(f)

双下exit方法(_exit_)

class C(object):
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        """当对象被当作with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量就会接收到什么"""
        return 123

    def __exit__(self, exc_type, exc_val, exc_tb):
        """当对象参与的with上下文管理语法运行完之后自动触发(子代码结束)"""
        print('今晚月色真美')


obj = C('jason')
with obj as f:
    print(f)

回到顶部

魔法方法笔试题

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': 'jason'}

        print(type(obj)) # <class '__main__.MyDict'>

回到顶部

元类简介

"""推导步骤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类产生的>>>:元类(产生类的类)"""

回到顶部

创建类的两种方式

方式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('你是不是python程序员 懂不懂规矩 类名首字母应该大写啊!!!')
        super().__init__(what, bases, dict)


        
2.指定类的元类:利用关键字metaclass指定类的元类
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)  # ('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种
        创建型
        结构型
        行为型
   ps:课下感兴趣可以简单看看
3.单例模式
  类加括号无论执行多少次永远只会产生一个对象
    目的:
        当类中有很多非常强大的方法 我们在程序中很多地方都需要使用
        如果不做单例 会产生很多无用的对象浪费存储空间
        我们想着使用单例模式 整个程序就用一个对象