面向对象之双下方法于元类

目录

• 反射实际案例
• 面向对象双下方法
• 笔试题讲解
• 元类简介
• 产生类的两种表现形式
• 元类的基本使用
• 元类的进阶操作
• 双下new方法
• 作业 编写元类规定对象的所有数据值转大写

反射实际案例

# 利用面向对象编写终端系统
class WinCmd:
    def cd(self):
        print('正在执行cd命令')

    def ls(self):
        print('正在执行ls命令')


def run(obj):
    while True:
        cmd = input('请输入指令:')
        if hasattr(obj, cmd):
            func_name = getattr(obj, cmd)
            func_name()
        else:
            print('指令不存在')


w1 = WinCmd()
run(w1)

面向对象双下方法

'''
面向对象中的双下方法，也被称之为 魔法方法
	有些双侠方法不需要刻意调用到达某个条件会自动触发
eg:  __init__  在对象实例化的时候就会自动触发
'''
1.__str__
    对象被执行打印操作时 自动触发，该方法必须返回字符串类型的数据，很多时候用来更加精准的描述对象
class Test:
    def __str__(self):
        pass

t1 = Test()
print(t1)   # TypeError: __str__ returned non-string (type NoneType)
    
    
2.__del__
	对象被执行删除操作（主动或者被动）之后自动执行
class Test:
    def __del__(self):
        print('hello')

t1 = Test()
>>>hello
       
3.__getattr__
	对象查找不到名字时自动执行
    
4.__call__
	对象被加括号调用的时候自动触发
    
5.__enter__
	对象被执行with上下文管理语法开始自动触发
    该方法返回什么as后面的变量名就会得到什么
  __exit__
	对象被执行with上下文管理语法结束后自动触发
    
6.__getattribute__
	只要对象查找名字，无论名字是否存在都会自动执行该方法
    如果类中有__getattribute__方法，就不会执行__getattr__方法
    
7.__new__
	给对象创建一个空的名称空间，__init__在这块空的名称空间的基础上往空间中添加名字
    
8.__setattr__
对象在执行添加属性操作的时候自动触发

笔试题讲解

# 1.让字典具备句点符查值的功能
class MyDic(dict):
    def __getattr__(self, item):
        return self.get(item)
    def __setattr__(self, key, value):
        self[key] = value

dic = MyDic({'name':'jason','age':21})
print(dic.name)
dic.gender = 'male'
print(dic.gender)

# 补全代码使其运行不报错
	"""
	class Context:
			pass
	with Context() as ctx:
			ctx.do_something()
	"""
class Context:
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
    def do_something(self):
        pass
	with Context() as ctx:
    	ctx.do_something()

元类简介

#元类，产生类的类
 print(type((1,2,3)))  # tuple
 print(type(123)  # int
 print(type({'name':'jason'}))  # dict
# type查看的是当前对象所属类名
class MyClass(object):
    pass
obj = MyClass()
print(type(obj))  # <class '__main__.MyClass'>
print(type(MyClass))  # <class 'type'>
       
class Teacher(MyClass):
    pass
print(type(Teacher))  # <class 'type'>
'''type就是所有类默认的元类!!!'''

产生类的两种表现形式

1.使用class关键字
class 类名(父类):
    类体代码
2.type元类
type(类名，父类，类的名称空间)
res = type('类名',(父类),{名称空间})

'''
学习元类的目的
	元类能够控制类的创建，也就意味着我们可以高度定制类的行为
	eg：掌握了物品的生成过程，就可以在过程中做任何额外的操作
	比如：要求类的名字必须首字母大写
'''

元类的基本使用

# 元类是不能通过继承的方式直接指定的
要通过关键字参数的形式进行修改
class C1(metaclass=指定元类):
    pass


class MyType(type):
    def __init__(cls, cls_name, cls_bases, cls_dict):
        if not cls_name.istitle():
            raise Exception("类名的首字母必须大写")
        super().__init__(cls_name, cls_bases, cls_dict)

class Test(metaclass=MyType):
    name = 'jason'

元类的进阶操作

1.回想__call__方法
	对象加括号会自动指向产生该对像类里的__call__，并且该方法返回什么，对象加括号就会得到什么
    那么类加括号，元类里面的__call__也是这样吗
# 类里面的__init__方法和 元类里__call__指执行的先后顺序
class MyType(type):
    def __call__(self, *args, **kwargs):
        print('call')

class Test(metaclass=MyType):
    def __init__(self,name):
        print('init')
t1 = Test('jason')  # call

# 定制对象的生成过程
class MyTypeClass(type):
    def __call__(self, *args, **kwargs):
        # print('__call__ run')
        # print(args,kwargs)
        if args:
            raise Exception('必须全部采用关键字参数')
        super().__call__(*args, **kwargs)

class MyClass(metaclass=MyTypeClass):
    def __init__(self, name):
        # print('__init__ run')
        self.name = name
'''强制规定：类在实例化产生对象的时候，对象的独有数据必须采用关键字参数
如果你想高度定制类的产生过程
	那么编写元类里面的__init__方法
如果你想高度定制对象的产生过程
	那么编写元类里面的__call__方法
'''

双下new方法

__new__用于产生一个空的对象
__init__用于实例化对象
"""
注意:并不是所有的地方都可以直接调用__new__ 该方法过于底层
	如果是在元类的__new__里面 可以直接调用
class Meta(type):
	def __new__(cls, *args, **kwargs):
		obj = type.__new__(cls,*args,**kwargs)
		return obj
	如果是在元类的__call__里面 需要间接调用
class Mate(type):
	def __call__(self, *args, **kwargs):
		obj = object.__new__(self) # 创建一个空对象
		self.__init__(obj,*args,**kwargs) # 让对象去初始化
         return obj
"""

作业 编写元类规定对象的所有数据值转大写

class MyType(type):
    def __new__(cls, name, bases, class_dic):
        dic = {}
        for k, v in class_dic.items():
            if not callable(v) and not k.startswith('__') and v.isalpha ():
                dic[k] = v.upper()
            else:
                dic[k] = v
        return type.__new__(cls, name, bases, dic)


class Student(metaclass=MyType):
    school = '清华'
    name = 'jason'
    def run(self):
        print(Student.school)

print(Student.__dict__)