Python full stack-reflection

¿Qué es la reflexión?

Use el nombre de la variable del tipo de datos de cadena para acceder al valor de esta variable

Método de reflexión: un total de cuatro

1. getattr Obtiene el atributo de objeto del nombre de cadena especificado
2. hasattr Determinar si el objeto tiene un objeto correspondiente (cadena)
3. setattr establece un objeto para un objeto
4. delattr elimina el atributo especificado

¿Dónde se usa principalmente la reflexión?

• Clase
• Objeto
• Modulo
• ¿Por qué el concepto de reflexión en el módulo
  tiene el concepto de reflexión?

Hay tres funciones conocidas como fun1, fun2, fun 3. Si queremos llamar a una de estas funciones, solo la escribiremos en el código. Por ejemplo, escribí un código como este para lograr esta función:

espía

def func1():
	return "func1"
def func2():
	return "func2"
def func3():
	return "func3"

prueba.py

import s
call_str = input("input which function you want to call:")
if call_str == 'func1':
	print(s.func1())
elif call_str == 'func2':
	print(s.func2())
elif call_str == 'func3':
	print(s.func3())
else:
	print("404 NOT Found"）

Solo piense en ello, si hay miles de funciones en el módulo s a las que podemos llamar, entonces necesitamos escribir miles de declaraciones de juicio en test.py. Esto es demasiado problema.
En este momento, se introdujo el mecanismo de reflexión.

Añadir mecanismo de reflexión:

import s
call_str = input("input which function you want to call:")
"""
if call_str == 'func1':
	print(s.func1())
elif call_str == 'func2':
	print(s.func2())
elif call_str == 'func3':
	print(s.func3())
else:
	print("404 NOT Found"）
"""	
obj = getattr(s,call_str)
print(obj())

Después de ejecutar, podemos ingresar fun1, fun2, fun3, pero cuando ingresamos aleatoriamente una cadena, la función incorporada de getattr informa el siguiente error: En

este momento, podemos usar la función incorporada de hasattr:

import s
call_str = input("input which function you want to call:")
"""
if call_str == 'func1':
	print(s.func1())
elif call_str == 'func2':
	print(s.func2())
elif call_str == 'func3':
	print(s.func3())
else:
	print("404 NOT Found"）
"""	
if hasattr(s,call_str): #判断在s中是否存在函数call_str
	obj = getattr(s,call_str)
	print(obj())
else:
	print("404 NOT Found")

La reflexión se usa en la clase:

class Student:
	#ROLE是一个属性
	ROLE = 'User1'
	@classmethod	
	def check_course(self):
		print("查看课程")
	@staticmethod
	def login():
		print("登录")
#查看属性
print(Student.ROLE)
#反射查看属性，‘ROLE’，引号引着是一个字符串，也就是用字符串‘ROLE‘
#去反射Student类中的属性ROLE	
print(getattr(Student,'ROLE'))
#反射调用方法
getattr(Student,'check_course')()
#反射调用静态方法
getattr(Student,'login')()

La reflexión se usa en objetos:

class A:
	def __init__(self,name):
		self.name = name
	def func(self):
		print("in func")
#实例化对象，并给name赋值
a = A('rain')
#查看name属性
print(getattr(a,'name'))
#对象调用方法
getattr(a,'func')()

La reflexión se usa en el módulo:

import os
#rename('原名','要改成的名')
os.rename('__init__.py','init')
getattr(os,'rename')('init','__init__.py')