• 反射


    反射

    反射的概念:指程序可以访问、检测和修改它本身状态或行为的一种能力(自省)。

    反射是用字符串来操作类或者对象的属性,其中反射有以下四个内置函数:

    class People:
        def __init__(self,name):
            self.name = name
    
        def eat(self):
            print('%s is eating'% self.name)
    
    peo = People('zkim') 
    # 1:hasattr,判断一个方法是否存在于这个类中。
    print(hasattr(peo,'eat')) 
    # True# 
    
    # 2:getattr,根据字符串去获取obj对象里的对应的方法的内存地址,“()”括号即可执行。
    print(getattr(peo,'name')) 
    # zkim
    
    # 3:setattr,通过setattr将外部的一个函数绑定到实例中。
    setattr(peo,'age',18) 
    print(peo.__dict__) 
    # {'name': 'zkim', 'age': 18}
    
    # 4:delattr,删除一个实例或者类中的方法。
    delattr(peo,'name')
    print(peo.__dict__) 
    # {'age': 18}
    

    __str____repr__

    ​ 改变对象的字符串显示__str____reper__,这俩方法的返回值必须是字符串,否则抛出异常。

    # __str__ 会在对象被转换位字符串时,转换的结果就是这个函数的返回值。
    class Person:
    
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        def __str__(self):
            print('打印时触发')
            return f'{self.name},{self.age}'
    
    p = Person('zkim','26')
    print(p)
    # 打印时触发
    # zkim,26
    
    
    # __repr__ 会在 __str__ 没有被定义时代替输出。
    class Person:
    
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        # def __str__(self):
            # print('打印时触发')
            # return f'{self.name},{self.age}'
        
        def __repr__(self):
            print('__str__没有被定义时,__repr__代替输出')
            return f'{self.age},{self.name}'
    
    p = Person('zkim','26')
    print(p)
    # __str__没有被定义时,__repr__代替输出
    # 26,zkim
    

    item系列

    __getitem____setitem____delitem__

    class Foo:
        def __init__(self, name):
            self.name = name
    
        def __getitem__(self, item):
            print(self.__dict__[item])
    
        def __setitem__(self, key, value):
            print('f[key] = value时,我执行')
            self.__dict__[key] = value
    
        def __delitem__(self, key):
            print('del obj[key]时,我执行')
            self.__dict__.pop(key)
    
        def __delattr__(self, item):
            print('del obj.jey时,我执行')
            self.__dict__.pop(item)
    
    f = Foo('jason')
    f['age'] = 18
    f['age1'] = 19
    del f['age']
    del f.age1
    print(f.__dict__)
    # f[key] = value时,我执行
    # f[key] = value时,我执行
    # del obj[key]时,我执行
    # del obj.jey时,我执行
    # {'name': 'jason'}
    

    __del__

    ​ 当对象在内存中被释放是,自动触发执行。

    ​ 注:此方法一般无需定义,因为Python是一门高级语言,程序员在使用时无需关系内存的分配和释放,因为此工作都是叫给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

    class Foo:
        
        def __del__(self):
            print('我执行啦')
            
    f = Foo()
    del f
    # 我执行啦
    
    千里之行,始于足下。
  • 相关阅读:
    四元数
    Advanced Packaging Tool
    离散
    Functional programming
    异步传输同步传输
    没有动态库链接:可执行的文件大小一个就有几百兆 DynamicLink Libraries
    Levenshtein distance
    arguments
    prototype linkage can reduce object initialization time and memory consumption
    similar_text
  • 原文地址:https://www.cnblogs.com/jincoco/p/12935876.html
Copyright © 2020-2023  润新知