一、反射的定义

反射是根据命名空间，通过变量名或者方法名的字符串形式来判断、查找、修改或者删除对应的值或者返回值
格式为：has/get/set/delattr(命名空间, 字符串形式的变量名/方法名)

  2.     '''案例类''' 
  3.     class Student:
  4.         ROLE = 'student'
  6.         @classmethod
  7.         def check_course(cls):
  8.             print("检查课程")
  10.         def choose_course(self):
  11.             print("选择课程")
  13.         def choosed_course(self):
  14.             print("以选择的课程")
  16.         @staticmethod
  17.         def login(username, password):
  18.             if username == '李镇' and password == '1234':
  19.                 print('登陆成功')
  20.             else:
  21.                 print('登陆失败')
  24.     class Level(Student):
  25.         pass

二、判断变量或者方法是否存在

  • 判断是否存在
  1.     i = 0
  2.     while i <= 3:
  3.         name = input('请输入方法名:')
  4.         # getattr(Level, name)()
  5.         # 这里获取的是方法，所以需要加上括号
  7.         if hasattr(Student, name):
  8.             # hasattr()判断的是是否存在属性/方法
  9.             getattr(Student, name)()
  10.             # 如果存在则获取
  11.         else:
  12.             print('方法名不存在')
  13.         i += 1

三、获取对应的值或者返回值

  • 反射查看属性对应的值
  1.     '''反射查看属性'''
  2.     print(getattr(Student, 'ROLE'))
  3.     print(getattr(Level, 'ROLE'))
  4.     print(getattr(s1, 'ROLE'))
  5.     # getattr()第一个参数是命名空间， 第二个参数是命名空间中变量名的字符串格式名称，获取的是变量名对应的值
  6.     # 命名空间可以是类、实例化对象等
  • 反射查看方法对应的返回值
  1.     '''反射查看方法'''
  3.     getattr(Student, 'check_course')()
  4.     # 反射调用类方法
  5.     # print(getattr(Student, 'choose_course')())
  6.     getattr(Student, 'login')('李镇', '1234')
  7.     # 反射调用静态方法
  8.     # getattr()第一个参数是命名空间， 第二个参数是命名空间中方法名的字符串格式名称，获取的是方法对应的返回值
  9.     # getattr(Student, 'login'）获取的只是方法对应的内存地址，需要加上括号来执行获取返回值

Note 需要注意的是：命名空间可以是类，也可以是实例化后的对象，当getattr()查看方法的时候获取到的是对应的内存空间，需要加上()才能获取到值 也可以通过子类来调用父类中的方法或者变量

  • 模块中反射的使用

  • 模块本质上还是有类组成的py文件或者类，所以模块的名即为命名空间，字符串为方法名

    • python模块反射案例(必须先导入使用的模块)

      1. '''模块的反射'''
      2. # import os
      3. # getattr(os, 'rename')('t2.py', 't1.py')
      4. # # 通过模块来修改文件的名称， rename本质上是一个函数
      5.                                             i
      7. import os
      8. rename = os.rename
      9. # os.rename得到的是rename函数的内存地址
      10. result = getattr(os, 'rename')
      11. result = result('t2.py', 't1.py')
      12. '''模块的反射，命名空间是模块名，字符串是模块中的方法名'''

    • 把自己写的文件当作模块，反射模块中的函数，获取结果

      • 第一步：导入sys模块，获取py文件的内存地址，赋值给my_file变量，把内存地址作为getattr()的第一个参数
      • 第二步：在进行getattr(my_file，’文件中的函数’)()
  1.     def func1():
  2.         print("这是一个测试的程序")
  4.     def func2():
  5.         print("第二个程序")
  7.     # func1()
  8.     # func2()
  9.     import sys
  10.     # print(sys.modules)
  11.     # print("-------------------")
  12.     # print(sys.modules['__main__'])
  13.     # # 这里打印的是py文件的内存地址(__main__)
  14.     # my_file = sys.modules['__main__']
  15.     # getattr(my_file, 'func1')()
  16.     # # 把自己的py文件作为单独模块，反射文件中程序的结果
  18.     my_file = sys.modules['__main__']
  19.     # 先获取py文件的内存地址，这是固定格式
  20.     getattr(my_file, 'func2')()
  21.     # getattr()的第一个参数就是命名空间，也就是内存地址
  22.     # 根据内存地址来调取函数，获取的是文件中函数的内存地址，在加括号执行函数返回结果

四、反射并修改内容

  • 修改内容的基本格式：setattr(命名空间， 变量名/方法名，替换内容)
  1.  '''修改属性setattr()'''
  2.  class A:
  3.      def __init__(self, name):
  4.          self.name = name
  6.  a = A('李志')
  7.  setattr(a, 'name', '刘欢')
  8.  # setattr中的三个参数：第一个是命名空间/内存空间，第二个是需要被修改的变量/方法名，第三个是替换的内容
  9.  print(a.name)
  10.  # 结果是：刘欢

五、反射删除内容

  • 反射删除内容的基本格式：delattr(命名空间, 需要被删除的变量名/方法)
  1.     class A:
  2.     def __init__(self, name):
  3.         self.name = name
  5.     def func(self):
  6.         print(self, '类的内存地址')
  8.     '''删除属性delattr()'''
  9.     delattr(a, 'name')
  10.     # print(a.name)
  11.     # 删除类中的属性
  12.     delattr(a, 'func')
  13.     getattr(a, 'func')()
  14.     # 删除类中方法

六、综合利用反射，创建简单的教务管理系统

  1. import sys
  4. class Teacher:
  5.     operate_list = [('打印教师信息', 'func'), ] 
  6.     # 把方法和提示信息作为元组组成一个方法信息列表
  8.     def __init__(self, name):
  9.         self.name = name
  11.     def func(self):
  12.         print('教师')
  14.     @classmethod
  15.     def status_attr(cls):
  16.         return cls.operate_list
  19. class Student:
  20.     operate_list = [('查看课程', 'check_course'), ('选择课程', 'choose_course')]
  22.     def __init__(self, name):
  23.         self.name = name
  25.     def check_course(self):
  26.         print('查看课程')
  28.     def choose_course(self):
  29.         print("请选择课程")
  31.     @classmethod
  32.     def status_attr(cls):
  33.         return cls.operate_list
  36. class Manager:
  37.     operate_list = [('创建学生信息','create_student'), ('创建课程', 'create_course'), ('查看学生信息', 'check_student_info')]
  39.     def __init__(self, name):
  40.         self.name = name
  42.     def create_student(self):
  43.         print('创建学生对象')
  45.     def create_course(self):
  46.         print('创建课程')
  48.     def check_student_info(self):
  49.         print('核对学生对象')
  51.     @classmethod
  52.     def status_attr(cls):
  53.         return cls.operate_list
  56. def login():
  57.     with open('userinfo.txt', mode='r', encoding='utf-8') as f:
  58.         username = input('请输入用户名:')
  59.         password = input('请输入密码:')
  60.         # 提示用户输入用户名和密码
  61.         for line in f:
  62.             line = line.rstrip('\n')
  63.             user, pwd, ident = line.split('|')
  64.             # 从文件中读取用户名、密码和身份信息
  65.             if user == username and pwd == password:
  66.                 print("登陆成功")
  67.                 return username, ident 
  68.                 # 判断信息是否一致，一致返回用户名和身份
  71. # 程序的入口
  73. import sys
  76. def main():
  77.     global i
  78.     file = sys.modules['__main__']
  79.     # 获取文件所在的内存空间地址，需要用sys模块
  80.     user, ident = login()
  81.     # 接收信息
  82.     if hasattr(file, ident):
  83.         # 注意：文件中的ident和程序中的类名是完全一样的，所以可以把ident作为类名来使用
  84.         obj = getattr(file, ident)(user)
  85.         # 获取类的内存地址，并实例化对象
  86.         print(obj.name)
  87.         operate_list = getattr(obj, 'operate_list')
  88.         # 反射类中的静态字段
  89.         for num, i in enumerate(operate_list, 1):
  90.             print(num, i[0]) 
  91.             # 利用枚举获取静态字段信息，序号和信息共同组成，enuerate(可迭代对象, 设定的第一个序号值) 
  92.         while True:
  93.             num = int(input("请输入选项序号:"))
  94.             choose_name = operate_list[num - 1][1] 
  95.             # 提示用户输入需要，根据序号找到方法对应的提示信息
  96.             getattr(obj, choose_name)()
  97.             # 再根据信息找到对应的方法，并反射内容
  98.         # getattr(operate_list, i[num - 1])
  101. main()