python之反射和内置函数

Dear 丶 2024-04-17 15:14 51阅读 0赞

1、内置函数

isinstance() ：判断对象所属类型，包括继承关系（例如下面例子，返回结果都是True）

class A:
        pass
    
    class B(A):
        pass
    
    b = B()
    print(isinstance(b, B))
    print(isinstance(b, A))

注意：== 表示的是值相等，属于值运算

is 内存地址相等，属于身份运算，而且要求很苛刻（不仅要求值相等，还要求内存地址相等）

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

issubclass()：判断类与类之间的继承关系（以下例子，第一个返回True第二个返回False）

class A: pass
    
    class B(A): pass
    
    print(issubclass(B, A))
    print(issubclass(A, B))

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

反射的方法: getattr hasattr setattr delattr  
                getattr(类名,'名字')  
                getattr(对象,'名字')  
                getattr(模块,'名字')

自己文件.名字  
                import sys  
                getattr(sys.modules\['\_\_main\_\_'\],'名字')

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):
        getattr(Student, num)()

![2019082719572087.png][]

选课系统的代码：判断身份 并且根据身份实例化，根据每个身份对应的类 让用户选择能够做的事情

class Manager:
        OPERATE_DIC = [
            ('创造学生账号', 'create_student'),
            ('创建课程', 'create_course'),
            ('查看学生信息', 'check_student_info'),
        ]
    
        def __init__(self, name):
            self.name = name
    
        def create_student(self):
            print('创建学生账号')
    
        def create_course(self):
            print('创建课程')
    
        def check_student_info(self):
            print('查看学生信息')
    
    
    class Student:
        OPERATE_DIC = [
            ('查看所有课程', 'check_course'),
            ('选择课程', 'choose_course'),
            ('查看已选择的课程', 'choosed_course')
        ]
    
        def __init__(self, name):
            self.name = name
    
        def check_course(self):
            print('check_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'
                if user == username and pwd == password:
                    print('登录成功')
                    return username, ident
    
    
    import sys
    
    
    def main():
        usr, id = login()
        print('user,id :', usr, id)
        file = sys.modules['__main__']
        cls = getattr(file, id)  # Manager = getattr(当前文件,'Manager')
        obj = cls(usr)
        operate_dic = cls.OPERATE_DIC
        while True:
            for num, i in enumerate(operate_dic, 1):
                print(num, i[0])
            choice = int(input('num >>>'))
            choice_item = operate_dic[choice - 1]
            getattr(obj, choice_item[1])()
    
    
    main()

![20190827200431370.png][]

setattr和delattr

class A:
        def __init__(self, name):
            self.name = name
    
    
    a = A('alex')
    
    # 要求将alex改成alex_SB
    # 直接改
    a.name = 'alex_SB'
    # 使用setattr改
    getattr(a, 'name')
    setattr(a, 'name', 'alex_SB')
    print(a.name)
    # 删除name的值先普通删除方法
    print(a.__dict__)
    del a.name
    # 使用delattr删除
    print(a.__dict__)
    delattr(a, 'name')
    print(a.__dict__)

3、内置方法

\_\_名字\_\_ ：类中的特殊方法/内置方法

双下方法

魔术方法

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

\_\_call\_\_ 相当于 对象() （类名称()())

class A:
        def __call__(self, *args, **kwargs):
            print('执行call方法了')
        def call(self):
            print('执行call方法了')
    class B:
        def __init__(self,cls):
            print('在实例化A之前做一些事情')
            self.a = cls()
            self.a()
            print('在实例化A之后做一些事情')
    a = A()
    a()  # 对象() == 相当于调用__call__方法
    a.call()
    
    A()() # 类名()() ,相当于先实例化得到一个对象,再对对象(),==>和上面的结果一样,相当于调用__call__方法
    B(A)

\_\_len\_\_  len(obj) 内置函数和类的内置方法是由关联的

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 = 'alex'
            self.age = 83
    
        def __len__(self):
            print('执行__len__了')
            return len(self.__dict__)
    
    
    l = mylist()
    print(len(l))

class My:
        def __init__(self, s):
            self.s = s
    
        def __len__(self):
            return len(self.s)
    
    
    my = My('abc')
    print(len(my))

iter和next的例子

# __iter__  iter(obj)
    # __next__  next
    def iter(obj):
        return obj.__iter__()
    
    
    l = [1, 2, 3]
    print(iter(l))  # l.__iter__()

\_\_new\_\_  特别重要   开辟内存空间的 类的构造方法  
    \# 写一个单例类=

类：

1.开辟一个空间,属于对象的  
2.把对象的空间传给self,执行init  
3.将这个对象的空间返回给调用者

class Single:
        def __new__(cls, *args, **kwargs):
            print('在new方法里')
            obj = object.__new__(cls)
            print('在new方法里', obj)
            return obj
    
        def __init__(self):
            print('在init方法里', self)
    
    # 在实例化之后，执行__init__之前，执行__new__来创建一块空间
    Single()

普通的新类中没有new方法，只能调用object的new方法

单例： 如果一个类 从头到尾只能有一个实例,说明从头到尾之开辟了一块儿属于对象的空间,那么这个类就是一个单例类

单例类：

class Single:
        __ISINCTANCE = None
    
        def __new__(cls, *args, **kwargs):
            if not cls.__ISINCTANCE:
                cls.__ISINCTANCE = object.__new__(cls)
            return cls.__ISINCTANCE
    
        def __init__(self, name, age):
            self.name = name
            self.age = age
            print(self)
    
    
    s1 = Single('alex', 83)
    s2 = Single('taibai', 40)
    
    print(s1.name)
    print(s2.name)

![20190827203922981.png][]

\_\_str\_\_   print一个对象相当于调用一个对象的\_\_str\_\_方法  
               str(obj),相当于执行obj.\_\_str\_\_方法  
               '%s'%obj,相当于执行obj.\_\_str\_\_方法

class Student:
        def __str__(self):
            return '%s %s %s' % (self.school, self.cls, self.name)
    
        def __init__(self, name, stu_cls):
            self.school = 'oldboy'
            self.name = name
            self.cls = stu_cls
    
    
    he = Student('hezewei', 'py14')
    print(he)
    huang = Student('huangdongyang', 'py14')
    print(huang)
    print(str(he))  # 内置的数据类型,内置的类,相当于执行__str__
    print('学生1 : %s' % he)

![20190827204158410.png][]

[2019082719572087.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/ec058bd3ffee48788be7335a521d9274.png
[20190827200431370.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/5927d66f904946a884839b8350978fc0.png
[20190827203922981.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/1c472f88f5c14310a9270e1427d277bc.png
[20190827204158410.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/fe752714d0ed4b12a029e4ae1a3d2d10.png