概要

• 反射实际案例

• 面向对象的双下方法

• 元类

• 元类进阶

内容

反射实际案例：利用面向对象编写系统终端功能

反射提供了一种不需要考虑代码层面的前提下 操作数据和功能

例题1：

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__
	对象(obj)被执行打印(print、前端展示)操作的时候自动触发
    该方法必须返回字符串类型的数据
    很多时候用来更加精确的描述对象
class Myclass(object):
    def __init__(self,name):
        self.name = name
        
    def __init__(self):
        print('我到底什么时候触发')
obj = Myclass('jason')
print(obj)
    
2.__del__
	对象被执行（被动、主动）删除操作之后自动执行
    
3.__getattr__
	对象查找"不存在"名字的时候自动触发
    
4.__setattr__
	对象在执行添加属性操作的时候自动触发>>>>obj.变量名 = 变量值
5.__call__
	对象被加括号调用的时候自动触发
6.__enter__
	对象被执行with上下文管理语法开始自动触发
    该方法返回什么as后面的变量名就会得到什么
7.__exit__
	对象被执行with上下文管理语法结束之后自动触发
8.__getattribute__
	只要对象查找名字无论名字是否存在都会执行该方法
    如果类中有__getattribute__方法 那么就不会去执行___getattr__方法
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))
# print(type([11,22,33,44,]))
# print(type({'name':'jason','pwd':123}))
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'>
"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__方法
 		对象的产生过程呢
 		类里面的__init__方法
 		方法:类比推理"""

元素的基本使用

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

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 = '清华大学'

元类进阶操作

1.回想__call__方法
	对象加括号会自动执行产生该对象的类里面___call__,并且该方法返回什么 对象加括号就会得到什么
    推导:类加括号会执行元类的里面的__call__该方法返回什么其实类加括号就会得到什么
    类里面的__init__方法和元类里面的__call__方法执行的先后顺序（一般是先使用元类的__call__,然后执行__init__方法
    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')
# 定制对象的产生过程
	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
  强制规定:类在实例化产生对象的时候 对象的独有数据必须采用关键字参数
    obj1 = MyClass('jason')
  obj2 = MyClass(name='jason')
如果你想高度定制类的产生过程
	那么编写元类里面的__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

标签：__,反射,obj,self,元类,案例,print,class,def
来源： https://www.cnblogs.com/wht488232/p/16131687.html