Python面向对象的双下方法和元类

目录

• 反射实际案例
• 面向对象的双下方法
• 元类
  • 简介
  • 产生类的两种表现形式
  • 学习元类的目的
  • 元类的基本使用
  • 元类的进阶操作
  • 双下new方法

反射实际案例

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

class LinuxCmd(object):
    def ls(self):
        print('Linux系统正在执行ls命令')
    def dir(self):
        print('Linux系统正在执行dir命令')
    def cd(self):
        print('Linux系统正在执行cd命令')

obj = WinCmd()
obj1 = LinuxCmd()
"""反射提供了一种不需要考虑代码的前提下 操作数据和功能"""
def run(obj):
    while True:
        cmd = input('请输入您的指令>>>:')
        if hasattr(obj, cmd):
            func_name = getattr(obj, cmd)
            func_name()
        else:
            print('cmd command not found')   
run(obj1)
run(obj)

---

面向对象的双下方法

面向对象中的双下方法也有一些人称之为是魔法方法。有些双下方法不需要刻意调用，到达某个条件会自动触发。比如双下init，对象实例化的时候会自动触发。

1.__str__
对象被执行打印(print、前端展示)操作的时候自动触发,该方法必须返回字符串类型的数据,用来更加精准的描述对象。
class MyClass(object):
    def __str__(self):
        return '返回内容'
obj = MyClass()
print(obj)  # 返回内容

2.__del__
对象被执行(被动、主动)删除操作之后自动执行
class MyClass(object):
    def __del__(self):
        print("被删除了")
obj = MyClass()  # 被删除了

3.__getattr__
对象查找不存在名字的时候自动触发。
class MyClass(object):
    def __getattr__(self, item):
        """对象查找不存在名字的时候自动触发"""
        # print('__getattr__方法', item)
        return '不好意思 没有%s这个名字' % item
        # pass
obj = MyClass() 
print(obj.tom)  # 不好意思 没有tom这个名字

4.__setattr__
对象在执行添加属性操作的时候自动触发	>>>	obj.变量名=变量值
class MyClass(object):
    def __setattr__(self, key, value):
        """对象在执行添加属性操作的时候自动触发>>>obj.变量名=变量值"""
        print(key, value)
        if key == 'gender':
            raise Exception('你没有资格拥有gender')
        if not key.islower():
            raise Exception('名字只能小写')
        super().__setattr__(key, value)
obj = MyClass()
obj.tom='jason'  # tom jason

5.__call__
对象被加括号调用的时候自动触发。
class MyClass(object):
    def __call__(self, *args, **kwargs):
        """对象被加括号调用的时候自动触发"""
        print('__call__方法', args, kwargs)
        return '嘿嘿嘿'
obj = MyClass()
print(obj())  # __call__方法 () {}  嘿嘿嘿

6.__enter__
对象被执行with上下文管理语法开始自动触发，该方法返回什么as后面的变量名就会得到什么。
7.__exit__
对象被执行with上下文管理语法结束之后自动触发
class MyClass(object):
    def __enter__(self):
        print('__enter__方法')
        return '这是给as后面的变量的'
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('__exit__方法')

obj = MyClass()
with obj as o:
    print(o)
'''
__enter__方法
这是给as后面的变量的
__exit__方法
'''

8.__getattribute__
只要对象查找名字无论名字是否存在都会执行该方法，如果类中有__getattribute__方法 那么就不会去执行__getattr__方法
class MyClass(object):
    def __getattribute__(self, item):
        """
        只要对象查找名字无论名字是否存在都会执行该方法
            如果类中有__getattribute__方法 那么就不会去执行__getattr__方法
        """
        print('__getattribute__方法', item)


obj = MyClass()  
print(obj.tom)  # __getattribute__方法 tom

 9.__new__
   元类里讲

实例应用

1.让字典具备句点符查找值的功能

# 1.定义一个类继承字典
  class MyDict(dict):
      def __getattr__(self, item):
          return self.get(item)

      def __setattr__(self, key, value):
          self[key] = value
  '''要区别是名称空间的名字还是数据k:v键值对'''
  obj = MyDict({'name':'jason','age':18})
  # 1.具备句点符取v
  # print(obj.name)
  # print(obj.age)
  # 2.具备句点符设k:v
  # obj['gender'] = 'male'
  obj.pwd = 123  # 给字典名称空间添加名字  不是数据k:v
  print(obj)

2.补全下列代码 使其运行不报错

"""
	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(123))  # <class 'int'>
print(type([12, 33, 44]))  # <class 'list'>
print(type({'name':'jason','pwd':123}))  # <class 'dict'>
# type查看的其实是当前对象所属的类名称
class MyClass(object):
    pass
obj = MyClass()
print(type(obj))
print(type(MyClass))  # <class 'type'>

class Student:
    pass
print(type(Student))  # <class 'type'>
class Teacher(MyClass):
    pass
print(type(Teacher))  # <class 'type'>

产生类的两种表现形式

1. class关键字

class C1(object):
    pass
print(C1)  # <class '__main__.C1'>

2. type元类

type(类名,父类,类的名称空间)
  	res = type('C1', (), {})
print(res)  # <class '__main__.C1'>

学习元类的目的

元类能够控制类的创建,也就意味着我们可以高度定制类的行为。掌握了物品的生产过程，就可以在过程中做任何的额外操作。eg:要求类的名字必须首字母大写，可以通过修改双下init里的代码实现。

元类的基本使用

以要求类的名字必须首字母大写的案例为例子使用元类。

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

class C1(metaclass=MyTypeClass):
    school = '清华大学'

class a(metaclass=MyTypeClass):
    school = '清华大学'

元类的进阶操作

双下call方法，对象加括号会自动执行产生该对象的类里面的双下call方法,并且该方法返回什么对象加括号就会得到什么。

推导:类加括号会执行元类的里面的双下call该方法返回什么其实类加括号就会得到什么。

'''类里面的__init__方法和元类里面的__call__方法执行的先后顺序'''
class MyTypeClass(type):
    def __call__(self, *args, **kwargs):
        print('__call__ run')
        super().__call__(*args, **kwargs)
class MyClass(metaclass=MyTypeClass):
      def __init__(self, name):
          print('__init__ run')
          self.name = name
obj = MyClass('jason')
'''
是先执行元类里面的__call__方法，再执行类里面的__init__方法。
'''

定制对象的产生过程

"""强制规定:类在实例化产生对象的时候,对象的独有数据必须采用关键字参数"""
class MyTypeClass(type):
    def __call__(self, *args, **kwargs):
        # 1.会产生一个空对象
        # 2.调用类里面的__init__实例化
        # 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       
        
# obj1 = MyClass('jason')
obj2 = MyClass(name='jason')

1.如果你想高度定制类的产生过程,那么编写元类里面的__init__方法
2.如果你想高度定制对象的产生过程,那么编写元类里面的__call__方法

双下new方法

双下new是用于产生空对象用的，它会返回一个空对象。双下init和双下new执行都会产生一个空对象，这个空对象就是由双下new产生的。

__new__用于产生空对象(类)		骨架
__init__用于实例化对象(类)		血肉

如果是在元类的__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