《Python》反射、内置方法（__str__，__repr__）

一、反射

　　　通过字符串的形式操作对象相关的属性。（使用字符串数据类型的变量名来获取这个变量的值）

　　　　Python中的一切事物都是对象（都可以使用反射）

　　　　　　反射类中的变量

　　　　　　反射对象中的变量

　　　　　　反射模板中的变量

　　　　　　反射本文件中的变量

　　　　用反射的场景：

　　　　　　input

　　　　　　网络

　　　　　　文件

#hasattr

def hasattr(*args, **kwargs): # real signature unknown
    """
    Return whether the object has an attribute with the given name.

    This is done by calling getattr(obj, name) and catching AttributeError.
    """
    pass

#getattr

def getattr(object, name, default=None): # known special case of getattr
    """
    getattr(object, name[, default]) -> value

    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
    When a default argument is given, it is returned when the attribute doesn't
    exist; without it, an exception is raised in that case.
    """
    pass

#setattr

def setattr(x, y, v): # real signature unknown; restored from __doc__
    """
    Sets the named attribute on the given object to the specified value.

    setattr(x, 'y', v) is equivalent to ``x.y = v''
    """
    pass

#delattr

def delattr(x, y): # real signature unknown; restored from __doc__
    """
    Deletes the named attribute from the given object.

    delattr(x, 'y') is equivalent to ``del x.y''
    """
    pass

反射的4种方法源码

　　

　　1、getattr()

　　　　getattr(变量名：命名空间，字符串：属于一个命名空间内的变量名)

　　　　　　类名.静态属性　　getattr(类名，‘静态属性’)

　　　　　　类名.类方法()　　 getattr(类名，‘类方法’)()

　　　　　　类名.静态方法()　 getattr(类名，‘静态方法’)()

　　　　　　

　　　　　　对象.对象属性　　getattr(对象，‘对象属性’)

　　　　　　对象.方法()　　　 getattr(对象，‘方法’)()

　　　　　　模块名.方法名

　　　　　　模块名.类名

　　　　　　模块名.变量

　　　　　　模块名.函数

　　　　　　本文件反射　　import sys

　　　　　　getattr(sys.modules[__name__],'所有定义在这个文件中的名字')

# 反射类中的变量: 静态属性、类方法、静态方法
class Foo:
    school = 'oldboy'
    country = 'china'
    language = 'chiness'

    @classmethod　　　　 # 类方法
    def class_method(cls):
        print(cls.school)

    @staticmethod　　　　# 静态方法
    def static_method():
        print('in staticmethod')

    def wahaha(self):　　# 普通方法
        print('wahaha')

print(Foo.school)   # oldboy
print(Foo.country)  # china
print(Foo.language) # chiness

# 判断实现
inp = input('>>>')
if inp == 'school': print(Foo.school)       # oldboy
elif inp == 'country': print(Foo.country)   # china
elif inp == 'language': print(Foo.language) # chiness

# 反射实现
while 1:
    inp = input('>>>')      # 输school，打印oldboy    输country，打印china    输language，打印chiness
    print(getattr(Foo,inp))

# 解析getattr方法
print(getattr(Foo,'school'))   # oldboy
Foo.class_method()              # oldboy
print(getattr(Foo,'class_method'))  # <bound method Foo.class_method of <class '__main__.Foo'>>
getattr(Foo,'class_method')()  # oldboy     相当于：Foo.class_method()
getattr(Foo,'static_method')() # in staticmethod    相当与：Foo.static_method()

　　　

# 反射对象中的变量

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eating(self):
        print('%s is eating' % self.name)
alex = Foo('alex',38)
print(getattr(alex,'name'))   # alex　　反射对象属性
print(getattr(alex,'age'))    # 38　　
getattr(alex,'eating')()     # alex is eating　　反射对象方法

# 反射模块中的变量
import os   # os就是一个模块
os.rename('D:\\python_task1.py','D:\\python_task2.py')
getattr(os,'rename')    # 把python_task1.py改成了python_task2.py
getattr(os,'D:\\python_task1.py','D:\\python_task2.py') # 效果同上

# 反射本文件中的变量

a = 1
b = 2
name = 'alex'

def qqxing():
    print('like eat qqxing')

class Foo:
    pass

import sys

print(sys.modules['__main__'])  # 本文件的命名空间
print(sys.modules['__main__'].a)    #
print([__name__])   # ['__main__']

print(sys.modules[__name__])    #  反射本文件中的变量 固定的使用这个命名空间
print(getattr(sys.modules[__name__],'a'))   #
print(getattr(sys.modules[__name__],'b'))   #
print(getattr(sys.modules[__name__],'name'))   # alex
getattr(sys.modules[__name__],'qqxing')()   # like eat qqxing
print(getattr(sys.modules[__name__],'Foo')) # <class '__main__.Foo'>     Foo类的地址
print(getattr(sys.modules[__name__],'Foo')())    # <__main__.Foo object at 0x0072BED0>    Foo类对象的地址

　　2、hasattr()

　　　　hasattr(变量名：命名空间，字符串：属于一个命名空间内的变量名)　　成立返回Ture，不成立返回False，一般与getattr搭配使用

class Foo:
    school = 'oldboy'
    country = 'china'
    language = 'chiness'

    @classmethod
    def class_method(cls):
        print(cls.school)

    @staticmethod
    def static_method():
        print('in staticmethod')

    def wahaha(self):
        print('wahaha')

inp = input('>>>')  # 输入 haha
print(getattr(Foo, inp))
# 如果输入的不存在则报错
# AttributeError: type object 'Foo' has no attribute 'haha'
# 所以要给他定义一个判断条件

inp = input('>>>')
if hasattr(Foo,inp):    # 如果输入的字符串在这个类中，则成立
    print(getattr(Foo,inp))

　　3、setattr()

　　　　setattr(名称空间，变量名，变量值)　　更改变量的值

　　　　　　给命名空间的某一个名字设置一个值

# setattr：接受三个参数 命名空间 ‘变量名’ 变量值
class Foo:
    school = 'oldboy'

def func():
    print('wahaha')

Foo.school = 'OLDBOY'   # 直接更改
print(Foo.school)       # OLDBOY
setattr(Foo,'school','OLDOBY')  # 有school这个属性则更改
print(Foo.school)       # OLDBOY
print(getattr(Foo,'school'))
setattr(Foo,'name','alex')  # 没有name这个属性则添加
print(Foo.name)         # alex
print(Foo.__dict__)

setattr(Foo,'func',func)    # 往类中添加方法，不过一般没人这么做
Foo.func()                  #wahaha
func()                      #wahaha
print(Foo.__dict__)
'''
{'__module__': '__main__', 'Country': 'China', '__dict__': <attribute '__dict__' of 'Foo' objects>, 
'__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None, 'func': <function func at 0x00788D68>}
'''

　　4、delattr()

　　　　delattr(命名空间，变量)

　　　　　　删除某一个命名空间中变量对应的值

class Foo:
    school = 'oldboy'
    country = 'china'
    language = 'chiness'

    def wahaha(self):
        print('wahaha')

    def qqxing(self):
        print('qqxing')

del Foo.country         # 直接删除一个属性
print(Foo.__dict__)
delattr(Foo,'school')   # 使用delattr删除一个属性
print(Foo.__dict__)
del Foo.wahaha          # 直接删除一个方法
print(Foo.__dict__)
delattr(Foo,'qqxing')   # 使用delattr删除一个方法
print(Foo.__dict__)

二、内置方法

　　　　在不是需要程序员定义，本身就存在在类中的方法就是内置方法

　　　　内置的方法通常都长这样：__名字__

　　　　各种不同叫法：名字+（双下方法、魔术方法、内置方法）

　　　　所有的双下方法，都不需要我们直接去调用，都有另外一种自动触发它的语法

　　　__init__：

　　　　不需要我们主动调用，而是在实例化的时候内部自动调用的

　　　__str__ 和 __repr__：　　

　　　　这俩方法的返回值必须是字符串，否则抛出异常。　　

　　　__str__:
　　　　当你打印一个对象的时候 触发__str__
　　　　当你使用%s格式化的时候 触发__str__
　　　　str强转数据类型的时候  触发__str__

　　　__repr__:
　　　　repr是str的备胎
　　　　有__str__的时候执行__str__,没有实现__str__的时候，执行__repr__
　　　　repr(obj)内置函数对应的结果是 __repr__的返回值
　　　　当你使用%r格式化的时候 触发__repr__

class Course:

    def __init__(self,name,period,price,teacher):
        self.name = name
        self.period = period
        self.price = price
        self.teacher = teacher

    def __repr__(self):
        return 'repr : %s %s %s %s ' % (self.name,self.period,self.price,self.teacher)

    def __str__(self):
        return 'str : %s %s %s %s ' % (self.name, self.period, self.price, self.teacher)

course_lst = []
python = Course('python','6 month',29800,'alex')
course_lst.append(python)
linux = Course('linux','5 month',19800,'oldboy')
course_lst.append(linux)
for id,course in enumerate(course_lst,1):
    print(id,course)   # 1 str : python 6 month 29800 alex
                        # 2 str : linux 5 month 19800 oldboy

    print('%s %s' % (id,course))   # 效果同上

    print(str(course))      # str : python 6 month 29800 alex
                            # str : linux 5 month 19800 oldboy

    print(repr(course))     # repr : python 6 month 29800 alex
                            # repr : linux 5 month 19800 oldboy

    print('%r' % course)    # 效果同上

# __str__
# 当你打印一个对象的时候 触发__str__
# 当你使用%s格式化的时候 触发__str__
# str强转数据类型的时候  触发__str__

# __repr__
# repr是str的备胎
# 有__str__的时候执行__str__,没有实现__str__的时候，执行__repr__
# repr(obj)内置函数对应的结果是 __repr__的返回值
# 当你使用%r格式化的时候 触发__repr__

　　　　

#子类与父类的__str__和__repr__触发顺序：

class Foo:
    def __str__(self):
        return 'Foo.str'
    def __repr__(self):
        return 'Foo.repr'

class Son(Foo):
    def __str__(self):
        return 'Son.str'
    def __repr__(self):
        return 'Son.str'

obj = Son()
print(obj)
'''
当打印子类的对象时：
1、先从子类找__str__
2、子类中没有__str__，则到父类找__str__
3、子类和父类都没有__str__，则找子类的__repr__
4、子类和父类都没有__str__，且子类没有__repr__，则找父类的__repr__
'''