魔法方法/元类

内容概要

• 魔法方法
• 基于魔法方法的笔试题
• 元类
• 创建类的两种方式
• 元类定制类的产生行为
• 魔法方法之__new__方法

魔法方法

魔法方法：
    类中定义的双下方法都称为魔法方法
'''即不需要人为调用 在特定的条件下自动触发运行'''

__str__()  方法
    # 对象被执行打印操作的时候自动触发
    class Student(object):
    def __str__(self):
        return '666'

obj = Student() 
# 如果不使用__str__方法打印对象应该为 <__main__.Student object at 0x000001D19C965A30>
print(obj)  # 我们在类中使用__str__方法后就会将返回值赋值给对象obj 即输出的是 666
'''需要注意的是return的数据必须是字符串，如果不是字符串会报错~'''

__call__
	# 对象名加括号调用的时候会自动触发
    class Student:
    def __call__(self, *args, **kwargs):
        return args,kwargs  

obj = Student()
res = obj()  # 将返回值赋值给res
print(res)  # ((), {})

__getattr__
	# 对象通过句点符方式点一个不存在的名字时会自动触发
    class Teacher(object):
    def __init__(self,age):
        self.age = age 
    def __getattr__(self, item):
        print(item,type(item))  # name <class 'str'>

obj = Teacher(12)
print(obj.name)  # 点了一个不存在的属性 

__getattribute__
	# 对象点存在或不存在的名字都会自动触发
    #  如果类中有__getattribute__方法 那么就不会去执行__getattr__方法
class B1(object):
    def __init__(self,age,name):
        self.age = age
        self.name = name

    def __getattribute__(self, item):
        print(item,type(item))

obj = B1(1,'xiaoming')
print(obj.name)
print(obj.age)

__setattr__
# 给对象添加或者修改数据的时候自动触发  对象.名字 = 值
class Student(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __setattr__(self, key, value):
        print('我是setattr魔法方法')
obj = Student('xiaoming',18)
obj.name = 'oscar'

__enter__
	当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么

__exit__
	with上下文管理语法运行完毕之后自动触发(子代码结束)
    
    
    class Student(object):
    def __enter__(self):
        return '1'  # enter的返回值赋值给obj 又传给了变量名f
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass  

obj = Student()
with obj as f:  
    print(obj)  # <__main__.Student object at 0x00000276D71A5A30>
    print(f)  # 1

__init__方法
	# 创建空对象之后自动触发给对象添加独有的数据
    class Student(object):
    def __init__(self,name,age):
        print('99')  # 打印时先经过了__init__方法
        self.name = name
        self.age = age

obj = Student('kevin',123)
print(obj.name)  # kevin

魔法方法笔试题

1.补全代码使运行不报错即可
  class Context:
        pass
    with Context() as f:
        f.do_something()
        
# 我们刚刚在魔法方法中提到了 __enter__ 与 __exit__方法
# __enter__当对象被当做with上下文管理操作的开始自动触发
# 所以我们应该在 Context 类中添加 __enter__ 与 __exit__的方法
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()
# 注意 我们同过 f 点了一个方法，这个方法也应该在类中加上


2.让字典能通过使用句点符的方式操作键值对
class MyDict(dict):  
    def __getattr__(self, item):
        return self.get(item)

    def __setattr__(self, key, value):
        self[key] = value


obj = MyDict({'jason': 123, 'kevin': 521})
print(obj.jason)
obj.pwd =123
print(obj.pwd)

元类简介

元类：就是产生类的类
我们来看一下它的推导过程

1.查看数据类型

s1 = 'hello'
d1 = {'name': 'xiaoming', 'age': 12}
l1 = [1, 2, 3, 4, 5]
t1 = (1, 2, 3, 4, 5)
print(type(s1))  # <class 'str'>
print(type(t1))  # <class 'tuple'>
print(type(d1))  # <class 'dict'>
print(type(l1))  # <class 'list'>
'''我们可以看到基本数据类型使用type()方法输出的数据类型前面都有class'''
其实 这些数据类型就是 相关数据类型实例化出来的对象
它们都属于 相关数据 类

2.type方法是用来查看产生对象的类名

class B(object):
    pass
obj = B()
print(type(obj))  # <class '__main__.B'>
print(type(B))  # <class 'type'>

3.我们想看看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'>
"""结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)"""

创建类的两种方式

方式1：使用关键字 class
class Student():
    pass
方式2：通过元类 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 = '666'

class Student(metaclass=MyMetaClass):
    info = '222'

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__可以产生空对象
"""