python面向对象之反射

反射在类中的使用

1. isinstance(a对象, B类) 判断a对象是否属于B类，是返回Trun，不是返回False。

   class Aniaml:
       pass
   
   class Person(Aniaml):
       pass
   
   class Student(Person):
       pass
   
   aniaml = Aniaml()
   person = Person()
   student = Student()
   lis = list()
   
   print(isinstance(aniaml,Aniaml))
   print(isinstance(person,Aniaml))
   print(isinstance(student,Aniaml))
   print(isinstance(lis,Aniaml))
   

   True
   True
   True
   False
   

2. issubclass(A类,B类) 判断A类 是否 是B类的子类

   class Aniaml:
       pass
   
   class Person(Aniaml):
       pass
   
   class Student(Person):
       pass
   
   aniaml = Aniaml()
   person = Person()
   student = Student()
   lis = list()
   
   print(issubclass(Person,Aniaml))	# Person类是否是Aniaml类的子类，True
   print(issubclass(Aniaml,Person))	# Aniaml类是否是Person类的子类，False
   

   True
   False
   

3. 反射在类中的使用

   1. 反射就是通过字符串来操作类或者对象的属性

   2. 反射本质就是在使用内置函数，其中反射有以下四个内置函数

      • hasattr(a,'eat')：判断一个方法/属性是否存在与这个类中
      • getattr(a,'eat',default=None)：根据字符串取获取对象中方法名的内存地址，加“()”括号即可执行，如果没有这个方法名，返回default对应的值，不设置default 如果没有，则报错
      • setattr(a,'age',18)：等同于 a.age = 18
      • delattr(a,'name')：删除a对象的name属性

      class Person:
      	def __init__(self,name):
      		self.name = name
      	
          def eat(self):
              print(f'{self.name}正在吃东西')
      
      	def run(self):
              print(f'{self.name}正在跑步')
              
      zs = Person('张三')
      print(hasattr(zs,'eat'))	# 判断zs对象是否拥有eat方法，有返回true，无返回False
      print(getattr(zs,'eat'))	# 获取zs对象的eat方法名，加()可以直接运行
      print(setattr(zs,'age',18))	# zs.age = 18
      print(zs.age)
      
      delattr(zs,'name')   # del zs.name
      print(zs.__dict__)
      

反射应用

需求：通过用户输入命令启动功能

class Ftp:
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    def get(self):
        print('GET function')

    def put(self):
        print('PUT function')

    def run(self):
        while True:
            choice = input('>>>: ').strip()

            if choice == 'q':
                print('break')
                break


#             print(choice, type(choice))
#             if hasattr(self, choice):
#                 method = getattr(self, choice)
#                 method()
#             else:
#                 print('输入的命令不存在')

            method = getattr(self, choice, None)

            if method is None:
                print('输入的命令不存在')
            else:
                method()

>>>: time
输入的命令不存在
>>>: time
输入的命令不存在
>>>: q
break

缺点：输入run时，会进行递归，不推荐使用。可以将run方法，写成一个普通的函数。如下：

class Ftp:
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    def get(self):
        print('GET function')

    def put(self):
        print('PUT function')

def run(a):
    while True:
        choice = input('>>>: ').strip()

        if choice == 'q':
            print('break')
            break

        method = getattr(a, choice, None)

        if method is None:
            print('输入的命令不存在')
        else:
            method()

conn = Ftp('1.1.1.1', 23)
run(conn)

>>>: get
GET function
>>>: set
输入的命令不存在
>>>: put
PUT function
>>>: run
输入的命令不存在
>>>: q

反射在模块中的应用

test.py文件：

def f1():
    print('f1')


def f2():
    print('f2')


def f3():
    print('f3')


def f4():
    print('f4')


a = 1

one.py文件：

import test as ss

ss.f1()
ss.f2()
print(ss.a)

问题：我们要导入另外一个模块,可以使用import.现在有这样的需求,我动态输入一个模块名，可以随时访问到导入模块中的方法或者变量，怎么做呢？

更改后的one.py文件：

imp = input(“请输入你想导入的模块名:”)
CC = __import__(imp) 这种方式就是通过输入字符串导入你所想导入的模块 
CC.f1()  # 执行模块中的f1方法

上面的我们实现了动态输入模块名，但是执行的函数被我们写死了，我们将它改为动态输入函数名，并且执行了？

更改后的one.py文件：

imp = input("请输入模块:")		# 动态导入模块
dd = __import__(imp)			# 拿到模块变量名
# 等价于import imp
inp_func = input("请输入要执行的函数：")	# 动态输入函数

f = getattr(dd, inp_func,default=None)  # 作用:从导入模块中找到你需要调用的函数inp_func,然后返回一个该函数的引用.没有找到就返回None
f()  # 执行该函数

上面我们就实现了，动态导入一个模块，并且动态输入函数名然后执行相应功能。

当然，上面还存在一点点小问题:那就是我的模块名有可能不是在本级目录中存放着。有可能是如下图存放方式

|- day24
    |- lib
        |- common.py

那么这种方式我们该如何搞定呢?看下面代码：

dd = __import__("lib.text.commons")  # 这样仅仅导入了lib模块
dd = __import__("lib.text.commons", fromlist=True)  # 改用这种方式就能导入成功
# 等价于import config
inp_func = input("请输入要执行的函数：")
f = getattr(dd, inp_func)
f()

总结：

上面说了那么多，到底什么是反射机制呢?：

其实，反射就是通过字符串的形式，导入模块；通过字符串的形式，去模块寻找指定函数，并执行。利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！

getattr()

getattr()函数是Python自省的核心函数，具体使用大体如下:

class A:
    def __init__(self):
        self.name = 'nick'
        # self.age='18'

    def method(self):
        print("method print")
a = A()

print(getattr(a, 'name','not find'))  # 如果a 对象中有属性name则打印self.name的值，否则打印'not find'
print(getattr(a, 'age','not find'))  # 如果a 对象中有属性age则打印self.age的值，否则打印'not find'
print(getattr(a, 'method', 'default'))  # 如果有方法method，否则打印其地址，否则打印default
print(getattr(a, 'method', 'default')())  # 如果有方法method，运行函数并打印None否则打印default

hasattr(object, name)

说明：判断对象object是否包含名为name的特性（hasattr是通过调用getattr(ojbect, name)是否抛出异常来实现的

setattr(object, name, value)

这是相对应的getattr()。参数是一个对象,一个字符串和一个任意值。字符串可能会列出一个现有的属性或一个新的属性。这个函数将值赋给属性的。该对象允许它提供。例如,setattr(x,“foobar”,123)相当于x.foobar = 123。

delattr(object, name)

与setattr()相关的一组函数。参数是由一个对象(记住python中一切皆是对象)和一个字符串组成的。string参数必须是对象属性名之一。该函数删除该obj的一个由string指定的属性。delattr(x, 'foobar')=del x.foobar

我们可以利用上述的四个函数,来对模块进行一系列操作.

r = hasattr(commons, xxx)  # 判断某个函数或者变量是否存在
print(r)

setattr(commons, 'age', 18)  # 给commons模块增加一个全局变量age = 18，创建成功返回none

setattr(commons, 'age', lambda a: a + 1)  # 给模块添加一个函数

delattr(commons, 'age')  # 删除模块中某个变量或者函数

注意：getattr,hasattr,setattr,delattr对模块的修改都在内存中进行，并不会影响文件中真实内容