python学习Day21--内置函数、反射

【知识点】

1、isinstance()  判断对象所属类型，包含继承关系

　　type()与isinstance()的区别

class mystr(str):pass
ms=mystr('alex')
print(ms)
print(type(ms) is str)    # 不包含继承关系，只管一层
print(isinstance(ms,str)) # 包含所有的继承关系

2、issubclass(B,A)    判断B是不是A的子类（判断类与类之间的继承关系）

3、反射：用字符串数据类型的变量名来访问这个变量的值 

　  方法：getattr   hasattr    setattr     delattr

　（1）在类的应用：静态属性（静态字段）、类方法、静态方法

　　　命名空间.XXX=getattr(命名空间，'XXX')   属性直接用，方法在后加（）

class Student:
    ROLE='STUDENT'

    @classmethod
    def check_course(cls):
        print("查看课程了")

    @staticmethod
    def login():
        print("登录")
# 反射查看属性
print(Student.ROLE)  # 通过类名调用
print(getattr(Student,'ROLE'))

# 反射调用方法
getattr(Student,'check_course')()     # 查看课程了  # 类方法
getattr(Student,'login')()            # 登录       # 静态方法

num=input("请输入要调用的方法>>>")
if hasattr(Student,num):         # 如果输入的num是Student这个命名空间里的方法，则返回True，否则返回Flase
    getattr(Student,num)()
else:
    num = input("你输入的有误，请重新输入要调用的方法>>>")

　　（2）在对象中应用：

# 在对象中
class A():
    def __init__(self,name):
        self.name=name

    def func(self):
        print("in func")

a=A('123')
print(a.name)            # 123
print(getattr(a,'name')) # 123
getattr(a,'func')()      # in func

　　（3）在模块中

# 在模块
import os
'''
# os.rename('__init__.py','init')
# getattr(os,'rename')('init','__init__.py')
rename=os.rename
rename2=getattr(os,'rename')  
rename('__init__.py','init')   # os.rename('__init__.py','init')
rename2('init','__init__.py')  # getattr(os,'rename')('init','__init__.py')
'''
# 反射自己模块中的内容，找到自己当前文件所在的命名空间
def wahaha():
    print("wahaha")

def qqxing():
    print("qqxing")

# wahaha()
# qqxing()

import sys
# print(sys.modules)
# sys.modules 这个方法，表示所有在当前这个python程序中导入的模块
# print(sys.modules['__main__'])
my_file=sys.modules['__main__']  # 当前文件所在模块
# my_file.wahaha()

getattr(my_file,'wahaha')()   # wahaha

　　【反射总结】

　　　　hasattr    getattr

　　　　① 类名.名字 

　　　　　　getattr(类名，'名字')

　　　　② 对象名.名字

　　　　　　getattr(对象，'名字')

　　　　③ 模块名.名字

　　　　　　import 模块

　　　　　　getattr(模块，'名字')

　　　　④ 自己文件.名字

　　　　　　import sys

　　　　　　getattr(sys.modules['__main__']，'名字')

　　【反射的应用】

# 一个选课查询系统
class Manager():
    OPERATE_DIC=[
        ('create_student','创建学生账号'),
        ('create_course','创建学生课程'),
        ('check_student','查看学生信息')
    ]

    def __init__(self,name):
        self.name=name

    def create_student(self):
        print("创建学生账号")

    def create_course(self):
        print("创建学生课程")

    def check_student(self):
        print("查看学生信息")


class Student():
    OPERATE_DIC = [
        ('choose_course', '学生选择课程'),
        ('check_course', '学生查询课程')
    ]

    def __init__(self,name):
        self.name=name

    def choose_course(self):
        print("学生选择课程")

    def check_course(self):
        print("学生查询课程")


def login():
    count=1
    while count<4:
        username=input("请输入用户名：")
        password=input("请输入密码：")
        with open('userinfo',mode='r',encoding='utf-8') as f:
            for line in f:
                user,pwd,ident=line.strip().split('|')
                if username == user and password == pwd:
                    print("登录成功")
                    return username,ident
                else:
                    print("输入错误，请重新输入,你还有%d次机会" % (3-count))
                    break
            count+=1

import sys
def main():
    while True:
        user,id=login()
        file=sys.modules['__main__']  # 拿到自己当前所在的模块
        cls=getattr(file,id)          # id=manager,student 所以可以拿到相应的类
        obj=cls(user)                 # 类的实例化，并传入参数
        lst=getattr(cls,'OPERATE_DIC')    # 通过类拿到静态属性值
        for num,el in enumerate(lst,1):   # enumerate()是将列表中元素添加上序号，从1开始则需要添加起始参数1
            print(num,el[1])             # num是序号，el是元组  el[1]获取元组的第二个参数
        i=int(input('请输入要选择项序号：'))
        getattr(obj,lst[i-1][0]) ()    # lst[i-1][0]得到的是字符串，故用getattr()方法
main()

4、内置函数

 　　__名字__

　　　　# 类中的特殊方法内置方法

　　　　#双下方法

　　　　#魔术方法

　　类中的每一个双下方法都有它自己的特殊意义

（1）__call__ 方法

　　对象() 相当于调用__call__方法

　　类名()() 相当于先实例化一个对象，再对对象()。与上面结果一样

# __call__
class A:
    def __call__(self,*args,**kwargs):
        print("执行call方法了")

class B:
    def __init__(self,cls):
        print("在实例化A之前做一些事")
        self.a=cls()
        self.a()
        print("在实例化A之后做一些事")
# a=A()
# a()    # 相当于调用__call__方法
#A()() # 和上面结果一样，相当于调用__call__
B(A)

（2）__len__方法

　　len(obj) 相当于调用了这个obj的__len__方法

　　__len__方法return的值就是len函数返回的值

　　#如果一个obj对象没有__len__方法，那么len函数就会报错

# __len__方法
#内置函数与类的内置方法是有奸情的
class Mylist:
    def __init__(self):
        self.lst=[1,2,3,4,5,6]
        self.name='123'
        self.age=45

    def __len__(self):
        print("执行__len__方法了")
        return len(self.__dict__)
m=Mylist()
print(len(m))   # 执行__len__方法了   3

（3）__new__方法（构造方法）

　　在执行__init__之前，开辟一个空间。

# __new__构造方法
class Single:
    def __new__(cls,*args,**kwargs):
        obj=object.__new__(cls)
        print("在new方法里",obj)
        return obj

    def __init__(self):
        print("在init方法里",self)
#1、开辟一个空间，属于对象的
#2、把这个对象的空间传给self，执行init
#3、将这个对象的空间返回给调用者
obj=Single()         #结果：在new方法里 <__main__.Single object at 0x0000019F309D1978>
                     #结果：在init方法里 <__main__.Single object at 0x0000019F309D1978>
#若是类中没有__nem__方法，则会调用object里的__new__来开辟空间

【一道面试题】

　　写出一个单例类？

　　#1、单例：如果一个类，从头到尾只能有一个实例（说明从头到尾只开辟了一块属于对象的空间），那么这个类就是一个单例类。

　　单例的例子代码：

# 写一个单例类
class Single:
    __ISINSTANCE=None
    def __new__(cls,*args,**kwargs):
        if not cls.__ISINSTANCE:
            cls.__ISINSTANCE=object.__new__(cls)
        return cls.__ISINSTANCE

    def __init__(self,name,age):
        self.name=name
        self.age=age

s1=Single('太白',23)
s2=Single('Alex',26)
print(s1.name)        # Alex
print(s2.name)        # Alex
# 原因：首先开辟一个空间，并且只有一个空间。最开始将name赋值“太白”,age赋值23，
# 然后执行S2=Single('Alex',26),由于只有一个空间，故将此前的值覆盖掉，所以最后打印都是“Alex”

注意：上述例子首先开辟了一个空间，并且只有一个空间。最开始将name赋值“太白”,age赋值23，然后执行S2=Single('Alex',26),由于只有一个空间，故将此前的值覆盖掉，所以最后打印都是“Alex”。

（4）__str__方法

　　print(对象)  相当于调用一个对象的__str__方法

　　str(obj)   相当于执行了obj.__str__方法

　　'%s' % obj  相当于执行obj.__str__方法

# __str__方法
class Student:
    def __str__(self):
        return '%s %s %s' % (self.school,self.stu_cls,self.name)

    def __init__(self,name,stu_cls):
        self.school='oldboy'
        self.name=name
        self.stu_cls=stu_cls

he=Student('菏泽微','py14')
# print(he)    # 执行了__str__方法   结果：oldboy py14 菏泽微
# print(str(he))  # 也执行了__str__方法，结果同上
print('学生1：%s' % he)  # 也执行了__str__方法，结果同上

【小结】所有的双下方法，没有需要你在外面调用的，而是总有一些其他的 内置函数 特殊的语法 来自动触发这些双下方法