Python攻城师的成长————面向对象收尾（反射、双下方法、元类）

今日学习目标

• 理解上去运用反射及双下方法，体会元类的意义，牢记部分用法

---

---

今日学习内容

• 反射
• 面向对象的双下方法
• 元类

---

一、反射

1.什么是反射？

反射就是通过字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动

可使用反射的地方：

1、反射类中的变量 : 静态属性,类方法，静态方法
2、反射对象中的变量、对象属性、普通方法
3、 反射模块中的变量
4、反射本文件中的变量

getattr(核心）

判断类、对象或者模块中是否有相应的属性或方法。用法：getattr(obj,str,default=None) 判断obj中是否有str属性，有就返回，没有时有传入第三参数就返回第三参数，没有就报错。

class A:
    name = 'zs'
    age = 18
print(getattr(A,'name'))
print(getattr(A,'language','notfound'))

'''
# 执行结果
zs
notfound
'''

settattr

设置属性。第三参数为新的属性值

class A:
    name = 'zs'
    age = 18
setattr(A,'name','ls')
setattr(A,'language','Chinese')
print(getattr(A,'name'))
print(getattr(A,'language','notfound'))

'''
# 执行结果
ls
Chinese
'''

hasattr

判断时候有某个属性，有就返回True，没有就返回False

class A:
    name = 'zs'
    age = 18
if hasattr(A,'name'):
    print(getattr(A,'name'))

'''
# 执行结果
zs
'''

delattr

删除某个属性

class A:
    name = 'zs'
    age = 18

delattr(A,'name')
print(hasattr(A,'name'))

'''
# 执行结果
False
'''

反射本文件

sys.modulses[__ name__]就是本文件对象。

import sys
class A:
    def __repr__(self):
        return '666'
if hasattr(sys.modules[__name__],'A'):
    print(getattr(sys.modules[__name__],'A')())

'''
# 执行结果
666
'''

使用场景

程序：用户输入的如果是a，那么就打印1，如果输入的是b就打印2
文件：从文件中读出的字符串，想转换成变量的名字
网络：将网络传输的字符串转换成变量的名字

来个例子

# 利用面向对象编写系统终端功能
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')   

---

二、面向对象的双下方法

1.方法（部分）

项目	Value
__ init__	对象实例化的时候自动触发
__ str__	对象被执行打印(print、前端展示)操作的时候自动触发，该方法必须返回字符串类型的数据，很多时候用来更加精准的描述对象
__ del__	对象被执行(被动、主动)删除操作之后自动执行
__ getattr__	对象查找不存在名字的时候自动触发
__ setattr__	对象在执行添加属性操作的时候自动触发 >>> obj.变量名=变量值
__ call__	对象被加括号调用的时候自动触发
__ enter__	对象被执行with上下文管理语法开始自动触发 ，该方法返回什么as后面的变量名就会得到什么
__ exit__	对象被执行with上下文管理语法结束之后自动触发
__ getattribute__	只要对象查找名字无论名字是否存在都会执行该方法，如果类中有__getattribute__方法 那么就不会去执行__getattr__方法
__ new__	在类被实例化前，最先被执行的方法，主要用来去创建一个完全空白的对象

2.举例说明（部分）

class A(object):
    def __init__(self):
        print("init方法")

    def __del__(self):
        print("del方法")

    def __str__(self):
        print("str 方法")

    def __new__(cls):  
        print("new方法")
        return object.__new__(cls)

a = A()

'''
# 执行结果
new方法
init方法
del方法
'''

当执行 a = A() 时，首先执行 等号右边"A()"

（1）调用__new__方法创建对象，然后找一个特殊变量接收__new__ 返回值，这个返回值就是创建对象的引用；（而这个特殊变量指向这个对象 ）

（2）这个对象调用__init__(self)方法,传入对象引用，self 指向刚刚创建的对象（__ new__ 方法返回的特殊变量传给self）

（3）返回对象的引用 这个a自然就指向了这个对象

（4）最后对象被执行(被动、主动)删除操作之后自动执行了__dal__方法

总结：__new__方法只负责创建，__init__方法只负责初始化， __dal__用来删除（垃圾回收）

NOTE：不是说在这里调用__new__方法，__new__方法自己调用__init__方法，而是先调用__new__方法，__new__方法执行完后保存其返回值，再去调用__init__方法

---

三、元类

元类简介

元类即产生类的类

#type查看的其实是当前对象所属的类名称
print(type(123))
print(type([12, 33, 44]))
print(type({'name':'jason','pwd':123}))

'''
# 执行结果
<class 'int'>
<class 'list'>
<class 'dict'>
'''

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:掌握了物品的生产过程 就可以在过程中做任何的额外操作

元类的基本使用

元类是不能通过继承的方式直接指定的，需要通过关键字参数的形式修改

举例：限制类的创建必须首字母大写

class C1(metaclass=MyTypeClass):
    	pass
    
class MyTypeClass(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 C1(metaclass=MyTypeClass):
    name = 'zs'

class a(metaclass=MyTypeClass):
    name = 'zs'

元类进阶操作

1.回想__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')
  
#定制对象的产生过程
	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__方法

---

总结

• 技术博客一篇
• 学习心得一段