反射---getattr，hasattr，setattr，delattr加插播enumerate

什么是反射？

用字符串数据类型的变量名来访问这个变量的值
反射的方法：getattr，hasattr，setattr，delattr
类：(通过类名反射类名空间里面的内容的)
类：静态属性，类方法，静态方法
命名空间.xxx = gettattr(命名空间，“xxx”)
引子

class Student:def __init__(self): passdef cheak_course(self):print("cheak_course")def choose_course(self):print("choose_course")def choosed_course(self):print("查看已选的课程")stu = Student()
num = input(">>>>")
if num == "cheak_course":stu.cheak_course()
elif num == "choose_course":stu.choose_course()
elif num == "choosed_course":stu.choosed_course()

如果类的方法越多，下面的判断就越多，代码太冗余。可以使用反射
怎么通过用户输入的字符串拿到对应的值？

class Student:ROLE = "STUDENT"  # 静态属性@classmethoddef cheak_course(cls):  # 类方法print("查看课程")@staticmethoddef login():  # 静态方法print("登录")# 反射查看属性
print(Student.ROLE)
# 用户输入input进来的永远是字符串"ROLE",那么怎么从Student里面拿到ROLE呢
# eval 这个东西，要明确的写在代码里面的，不能用户输入什么就eval()什么，太不安全
print(getattr(Student, "ROLE"))  # 第一个参数的命名空间中的，变量名为第二个参数的值。前面是命名空间，后面是变量名，字符串# 反射调用方法
getattr(Student, "cheak_course")()# 反射调用静态方法
getattr(Student, "login")()# 结果
# STUDENT
# STUDENT
# 查看课程
# 登录

接收用户的输入的字符串

class Student:ROLE = "STUDENT"  # 静态属性@classmethoddef cheak_course(cls):  # 类方法print("查看课程")@staticmethoddef login():  # 静态方法print("登录")num = input("请输入要操作的动作：")
getattr(Student, num)()     #加括号就调用

这样就保证程序的绝对安全了，有这个方法就直接执行，没有的话就报错
如果要做的好一点，可以用hasattr，有这个方法的话就返回True，没有的话就返回False

class Student:ROLE = "STUDENT"  # 静态属性@classmethoddef cheak_course(cls):  # 类方法print("查看课程")@staticmethoddef login():  # 静态方法print("登录")num = input("请输入要操作的动作：")
if hasattr(Student, num):  # 输入的字符串在Student里面找到就返回True，找不到就返回Falsegetattr(Student, num)()

对象

反射方法，对象属性

class A():age = 100  # 静态属性def __init__(self, name):self.name = name  # 属性def func(self):print("in func")a = A("Alex")  # 实例化
# 正常是访问属性
print(a.name)
# 通过反射取属性,方法
print(getattr(a, "name"))
getattr(a, "func")()
# 结果
# Alex
# Alex
# in func

模块

反射和直接调用效果是一样的

print(os.rename)  # 获取函数的内存地址
print(getattr(os, "rename"))
# 结果
# <built-in function rename>
# <built-in function rename>

反射别的模块中的内容

import osos.rename("__init__.py", "init")
# getattr(os, "rename")  就相当于os.rename   (没有括号)
getattr(os, "rename")('init', "__init__.py")  # 后面括号是参数
# 将文件名改回来再改回去

反射自己模块中的内容,找到自己当前文件的命名空间

#因为现在只能拿到字符串类型的数据，不知道模块名。要反射的话必须要有反射名
def wahaha():print("wahaha")def qqxing():print("qqixng")import sys# print(sys.modules)  # sys.modules表示所有在这个python程序中导入的模块
# 找到自己当前文件的命名空间
# print(sys.modules["__main__"])
# 结果：
# <module '__main__' from 'D:/参考/daydayup/day20/反射.py'>my_file = sys.modules["__main__"]
# my_file.wahaha()getattr(my_file, "wahaha")()
#结果
#wahaha

总结：

反射
getattr，hasattr
类名.名字
getattr(对象，“名字”)

对象名.名字
getattr(对象，“名字”)
模块名.名字
import 模块
getattr(模块，“名字”)
自己文件.名字
import sys
getattr(sys.modules[“main”]，“名字”)

反射演练

class Manager:def __init__(self, name):self.name = namedef create_student(self):print("创建学生账号")def create_course(self):print("创建课程")def ckeck_student_info(self):print("查看学生信息")class Student:def __init__(self, name):self.name = namedef cheak_course(self):print("cheak_course")def choose_course(self):print("choose_course")def choosed_course(self):print("查看已选的课程")def login():username = input("user: ")password = input("pwd: ")with open("userinfo") as f:for line in f:user, pwd, ident = line.strip().split("|")  # 解包，拿列表里面的每一个值。ident = "Manager\n",strip()去掉换行符if user == username and pwd == password:  # 判断输入法的用户名密码，是否和存的用户名密码对上print("登录成功")return username, ident  # 返回用户名，身份，知道具体是谁import sysdef main():# 程序的逻辑在main里面usr, id = login()  # 拿到用户名和身份，身份就是Student或Manager，刚好和上面的类名一样print("use,id", usr, id)  # 返回的是两个字符串file = sys.modules["__main__"]  # 获取当前所在的模块，就是当前文件的命名空间cls = getattr(file, id)  # getattr(当前文件,Manager)，从当前文件，找类Manager或Student的内存空间,id是从文件里拿的字符串，这样就能找到类名空间obj = cls(usr)  # 这个是实例化，拿到的就是对象print(Student, Manager)print(cls)  # 就是Manager类的内存地址main()

插播enumerate

l = ["a", "b", "c"]
for i in l:print(i)
# 结果
# a
# b
# c

l = ["a", "b", "c"]
for i in enumerate(l):print(i)
# 结果
# (0, 'a')
# (1, 'b')
# (2, 'c')

原地解包1

l = ["a", "b", "c"]
for num, i in enumerate(l):  # 从0开始print(num, i)
# 结果
# 0 a
# 1 b
# 2 c

原地解包2

l = ["a", "b", "c"]
for num, i in enumerate(l,1):  # 从1开始print(num, i)
#结果
# 1 a
# 2 b
# 3 c

主程序的逻辑不需要动，尽管添加学生和老师的方法就行。

class Manager:OPERATE_LIST = [("创造学生账号", "create_student"),("创建课程", "create_course"),("查看学生信息", "ckeck_student_info")]def __init__(self, name):self.name = namedef create_student(self):print("创建学生账号")def create_course(self):print("创建课程")def ckeck_student_info(self):print("查看学生信息")class Student:OPERATE_DIC = [('查看所有课程', 'check_course'),('选择课程', 'choose_course'),('查看已选择的课程', 'choosed_course')]def __init__(self, name):self.name = namedef cheak_course(self):print("cheak_course")def choose_course(self):print("choose_course")def choosed_course(self):print("查看已选的课程")def login():username = input("user: ")password = input("pwd: ")with open("userinfo") as f:for line in f:user, pwd, ident = line.strip().split("|")  # 解包，拿列表里面的每一个值。ident = "Manager\n",strip()去掉换行符if user == username and pwd == password:  # 判断输入法的用户名密码，是否和存的用户名密码对上print("登录成功")return username, ident  # 返回用户名，身份，知道具体是谁import sysdef main():# 程序的逻辑在main里面usr, id = login()  # 拿到用户名和身份，身份就是Student或Manager，刚好和上面的类名一样print("use,id", usr, id)  # 返回的是两个字符串file = sys.modules["__main__"]  # 获取当前所在的模块，就是当前文件的命名空间cls = getattr(file, id)  # getattr(当前文件,Manager)，从当前文件，找类Manager或Student的内存空间,id是从文件里拿的字符串，这样就能找到类名空间obj = cls(usr)  # 这个是实例化，拿到的就是对象operate_list = cls.OPERATE_LIST  # 通过类名拿静态变量while True:  # 循环起来for num, i in enumerate(operate_list,1):  # 1 ('创造学生账号', 'create_student')   2 ('创建课程', 'create_course')  3 ('查看学生信息', 'ckeck_student_info')print(num, i[0])  # 1 创造学生账号2 创建课程3 查看学生信息choise = int(input("请输入要操作的序号："))  # 拿到用户要操作的序号,转成证书类型choice_item = operate_list[choise - 1]  # 需要从1开始的，是("创造学生账号", "create_student")这样的元组getattr(obj, choice_item[1])()  # choice_item[1]这个就是要找的字符串main()
#结果：
# user: Alex
# pwd: 123456
# 登录成功
# use,id Alex Manager
# 1 创造学生账号
# 2 创建课程
# 3 查看学生信息
# 请输入要操作的序号：1
# 创建学生账号
# 1 创造学生账号
# 2 创建课程
# 3 查看学生信息
# 请输入要操作的序号：2
# 创建课程
# 1 创造学生账号
# 2 创建课程
# 3 查看学生信息
# 请输入要操作的序号：3
# 查看学生信息
# 1 创造学生账号
# 2 创建课程
# 3 查看学生信息
# 请输入要操作的序号：

setattr 修改（了解）

class A:def __init__(self, name):self.name = namea = A("alex")
# a.name = "alex_SB"  # 一般正常这样用
# getattr(a,"name")   #取值
setattr(a, "name", "alex_SB")  # 修改，最后一个是修改后的数据
print(a.name)
# 结果
# alex_SB

delatter删除（了解）

不用反射

class A:def __init__(self, name):self.name = namea = A("alex")
print(a.__dict__)
del a.name
print(a.__dict__)# 结果
# {'name': 'alex'}
# {}

用反射

class A:def __init__(self, name):self.name = namea = A("alex")
print(a.__dict__)
delattr(a,"name")
print(a.__dict__)# 结果
# {'name': 'alex'}
# {}