一、反射
通过字符串的形式操作对象相关的属性。（使用字符串数据类型的变量名来获取这个变量的值）
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__
'''