反射

一、反射的概念

1 什么是反射

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

2 python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

四个可以实现自省的函数

下列方法适用于类和对象（一切皆对象，类本身也是一个对象）

二、反射的四种方法

只要能通过 xx.xx 调用到的东西都可以用反射，如：

# 类.属性
# 类.方法
# 对象.属性
# 对象.方法
# 内置模块.属性
# 自定义模块.属性
# 模块.类

①hasattr

此方法是用来检查一个对象有没有一个XX，格式为：hansattr(对象,‘XX‘)，注意，第二个参数是一个字符串类型的。返回一个布尔值，如下：

class Person:
    kind = '人类'
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.changdu = 28
    def func(self):
        print('func.....')
p = Person('fuyong',18)

print(hasattr(p,'name'))        #True
print(hasattr(p,'func'))        #True
print(hasattr(Person,'kind'))   #True
print(hasattr(Person,'func'))   #True

②getattr

此方法是用来获取一个对象的XX，XX是字符串类型，它可以是类的属性，可以对象是属性及方法，可以是模块的类，等等……

最好搭配hasattr方法使用，判断它有此方法或者对象的时候才获取，以免找不到报错，也可以指定找不到的默认值。格式为getattr(对象，XX，默认值),如下：

class Person:
    kind = '人类'
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.changdu = 28
    def func(self):
        print('func.....')
p = Person('fuyong',18)

ret = getattr(p,'func',None)
if ret:
   ret()    #func.....

ret = getattr(p,'funcxxx','没有此方法')
print(ret)  #没有此方法

if hasattr(p,'func'):
    getattr(p,'func')() #func.....

③setattr

此方法用来设置一个对象的属性，格式为setattr(对象，属性名，属性值) ，如下：

class Person:
    kind = '人类'
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.changdu = 28
    def func(self):
        print('func.....')
p = Person('fuyong',18)

print(p.age)        #18
setattr(p,'age',19)
print(p.age)        #19
    

④delattr

此方法是用来删除一个对象的属性，格式为delattr(对象，XXX) ，如下：

class Person:
    kind = '人类'
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.changdu = 28
    def func(self):
        print('func.....')
p = Person('fuyong',18)

print(p.age)        #18
delattr(p,'age')
print(p.age)        #报错：AttributeError: 'Person' object has no attribute 'age'

三、类的内置方法

① __init__

此方法在类被实例化的时候被自动调用

② __str__和__repr__

__str__( )方法在三种情况下被自动调用

△ str(对象名)

△ print(对象名)

△ '%s'%对象名

如下：

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return '他是一个名叫%s的帅哥'%self.name

p = Person('fuyong',18)
print(str(p))           #他是一个名叫fuyong的帅哥
print(p)                #他是一个名叫fuyong的帅哥
print('%s'%p)           #他是一个名叫fuyong的帅哥

__repr__方法在以下三种情况下被调用：

△ repr(对象名)

△ '%r'%对象名

△ 当类没有__str__方法又被调用__str__方法的时候被调用

如下：

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __repr__(self):
        return '他是一个名叫%s的帅哥'%self.name

p = Person('fuyong',18)
print(repr(p))
print('%r'%p)
print(str(p))
print(p)
#打印结果如下
# 他是一个名叫fuyong的帅哥
# 他是一个名叫fuyong的帅哥
# 他是一个名叫fuyong的帅哥
# 他是一个名叫fuyong的帅哥

③ __del__

此方法会在对象被释放的时候被自动调用（一种情况是对象被删除，一种情况是程序执行完了被Python解释器释放），如下：

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __del__(self):
        print('程序执行完了')

p = Person('fuyong',18)

#程序执行完了

④ __call__

此方法会在对象后面加括号的时候被自动调用,如下：

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __call__(self):
        print('你在对象名后加了括号(类似一个函数)')
p = Person('fuyong',18)
p()
#你在对象名后加了括号(类似一个函数)

⑤ __len__

此方法在调用len(对象)的时候被执行，如下：

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.changdu = 28
    def __len__(self):
        return self.changdu
p = Person('fuyong',18)
print(len(p)) #28

⑥ __new__

此方法是在实例化一个对象的时候回自动触发（在__init__函数之前）。如下：

class Person:
    def __init__(self,name):
        self.name = name
        print('调用__init__函数........')

    def __new__(cls, *args, **kwargs):
        print('调用__new__函数.........')
        return object.__new__(Person)

p = Person('付勇')
print(p.name)

#调用__new__函数.........
# 调用__init__函数........
# 付勇

利用__new__方法实现单例模式：

class Person:
    _obj = None
    def __init__(self,name):
        self.name = name

    def __new__(cls, *args, **kwargs):
        if cls._obj:
            return _obj
        else:
            _obj = object.__new__(Person)

p1 = Person('付勇')
p2 = Person('小明')
print(p1 is p2)

⑦ __hash__

此方法在has(对象)的时候被调用，如下：

class Person:
    _obj = None
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __hash__(self):
        return hash(self.name)+hash(self.age)

p1 = Person('付勇',18)
p2 = Person('付勇',19)
print(hash(p1) == hash(p2))         #False

⑧__eq__

此方法在比较两个对象的时候被调用，如：obj1 == obj2  或者   如下：

class Person:
    _obj = None
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        if self.__dict__ == other.__dict__:
            return True
        else:
            return False

p1 = Person('付勇',18)
p2 = Person('付勇',18)
print(p1 == p2)         #True

⑨ __getitem__\__setitem__\__delitem__

一旦一个类中定义了这三种内置方法，操作类的属性的时候就可以像操作字典一样，如：

obj [属性]                 ---->   __getitem__

obj [属性] = 属性值         ----> __setitem__

del obj [属性]             ---->  __delitem__

  实例如下：

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

    def __getitem__(self, item):
        return self.__dict__[item]

    def __setitem__(self, key, value):
        self.__dict__[key] = value

    def __delitem__(self,key):
        del self.__dict__[key]

p = Person('付勇',18)

print(p['name'])      #付勇

p['age'] = 19
print(p['age'])      #19

del p['age']

print(p['age'])     #因为age属性已被删除，所以会报错！KeyError: 'age'