面向对象Python反射演示

@classmethod

整个方法中没有用到对象命名空间中的名字,且用到了类的命名空间中的名字(普通方法和属性property除外)

类方法的默认参数:cls 调用这个发方法的类

类方法的调用方式:通过类名调用

通过类名调用的本质是方法

 

@statimethod

将一个普通函数放到类中来就给这个函数加一个@staticmethod装饰器

这个函数就不需要传默认的参数:self,cls

静态方法的调用方式:通过类名调用

通过类名调用本质是函数

 

from types import MethodType,FunctionType    配合isinstance使用,判断是方法还是函数

通过类名调用,@classmethod的是方法,@statimethod的是函数

from types importFunctionType,MethodType
classFoo:
    @classmethod
    def func1(cls):pass
    @staticmethod
    def  func2():pass

print('Foo.func1-Function:',isinstance(Foo.func1,FunctionType))     #判断类方法是否函数
print('Foo.func1-Method:',isinstance(Foo.func1,MethodType))         #判断类方法是否方法
print('----------------------------------------')
print('Foo.func2-Function:',isinstance(Foo.func2,FunctionType))     #判断静态方法是否函数
print('Foo.func2-Method:',isinstance(Foo.func2,MethodType))         #判断静态方法是否方法

'''Foo.func1-Function: False
Foo.func1-Method: True
----------------------------------------
Foo.func2-Function: True
Foo.func2-Method: False
'''

 

通过对象调用,@classmethod的是方法,@statimethod的是函数

from types importFunctionType,MethodType
classFoo:
    @classmethod
    def func1(cls):pass
    @staticmethod
    def  func2():pass
f =Foo()
print('Foo.func1-Function:',isinstance(f.func1,FunctionType))     #判断对象类方法是否函数
print('Foo.func1-Method:',isinstance(f.func1,MethodType))         #判断对象类方法是否方法
print('----------------------------------------')
print('Foo.func2-Function:',isinstance(f.func2,FunctionType))     #判断对象静态方法是否函数
print('Foo.func2-Method:',isinstance(f.func2,MethodType))         #判断对象静态方法是否方法

'''Foo.func1-Function: False
Foo.func1-Method: True
----------------------------------------
Foo.func2-Function: True
Foo.func2-Method: False
'''

 

类可以被调用,对象不能被调用

deffunc(args):
    ifcallable(args):
        print(args())
    else:
        print('not callable:',args)

class Foo:pass
f =Foo()
func(Foo)           #类     <__main__.Foo object at 0x0000016AE645C278>
func(f)             #对象    not callable: <__main__.Foo object at 0x0000016AE645C320>

总结:

需要明确传递参数的是function(函数),不需要明确传递参数的是method(方法)。类直接调用是function(函数),类的实例调用的是method(方法)

静态方法:类调用和对象调用都是function(函数)

#判断函数、方法、对象
from types importMethodType,FunctionType
def func(*args):
    function_count =0
    method_count =0
    foo_obj =0

    for item inargs:
        if isinstance(item,FunctionType):function_count += 1
        elif isinstance(item,MethodType):method_count += 1
        elif isinstance(item,Foo):foo_obj += 1

    return {'function_count': function_count, 'method_count': method_count, 'foo_obj': foo_obj}

def func1():pass
classFoo:
    def method1(self):pass
f1 =Foo()
ret =func(func1,f1.method1,Foo.method1,Foo(),func,f1)
print(ret)

'''{'function_count': 3, 'method_count': 1, 'foo_obj': 2}
'''

 

类、对象内存机制的解析

反射作用:使用字符串数据类型的变量名来获取这个变量的值

使用反射的三个场景:

① input

② 文件:从文件中读出的字符串,想转化成变量的名字

③ 网络:将网络传输的字符串转化成变量的名字,函数名是变量,类名也是变量,直接执行变量

反射变量的方式:

① 反射类中的变量(反射静态变量,类方法,静态方法)

② 反射对象中的变量(反射对象中的对象属性,普通方法)

③ 反射模块中的变量

④ 反射本文件中的变量

反射使用的常用函数:

① hasattr() 用于判断对象是否包含对应的属性

②getattr() 获取对象object的属性或者方法,如果存在打印出来,如果不存在,打印出默认值,默认值可选。
需要注意的是,如果是返回的对象的方法,返回的是方法的内存地址,如果需要运行这个方法,
可以在后面添加一对括号。

getattr(变量名:命名空间,字符串:属于一个命名类的变量名)

③ setattr() 给对象的属性赋值,若属性不存在,先创建再赋值

setattr() 接收三个参数,命名空间,‘变量名’,变量值

④ delattr()删除 object对象 中的 name属性

① 反射静态变量

classA:
    city = 'Shenzhen'

if hasattr(A,'city'):           #判断类中是否存在该变量名,变量名字符串格式,相当于 A.city in A
    ret = getattr(A,'city')     #getattr(类名,变量名的字符串格式),相当于 ret = A.city
    print(ret)                  #Shenzhen

② 反射类方法

classB:
    @classmethod
    def func(cls):              #类方法
        return 666

if hasattr(B,'func'):           #判断类中是否存在该变量名,变量名字符串格式,相当于B.func in B
    ret = getattr(B,'func')     #getattr(类名,变量名的字符串格式),相当于 ret = B.func
    print(ret)                  #<bound method B.func of <class '__main__.B'>>
    print(ret())                #执行B.func()    666

③ 反射静态方法

classC:
    @staticmethod
    def func():                 #静态方法
        return 333

if hasattr(C,'func'):           #判断类中是否存在该变量名,变量名字符串格式,相当于C.func in C
    ret = getattr(C,'func')     #getattr(类名,变量名的字符串格式),相当于 ret = C.func
    print(ret)                  #<function C.func at 0x000001D058918BF8>
    print(ret())                #执行C.func()    333

① 反射对象属性

classA:
    name = 'gg'
    def __init__(self,city):
        self.city = city            #对象属性

a = A('广州')
if hasattr(a,'city'):
    ret = getattr(a,'city')         #相当于 ret = a.city
    print(ret)                      #广州
    print(a.city)                   #广州

② 反射普通方法

classB:
    deffunc(self):
        print(666)

b =B()
if hasattr(b,'func'):
    ret = getattr(b,'func')         #相当于 ret = b.func
    print(ret)                      #<bound method B.func of <__main__.B object at 0x00000242F27DC5F8>>
    ret()                           #666
    b.func()                        #666
importos
getattr(os,'rename')('a.txt','b.txt')   #相当于 os.rename('a.txt','b.txt')#os.rename('a.txt','b.txt')
importsys
city = '北京'
print(sys.modules['__main__'])          #本文件的命名空间
print(sys.modules['__main__'].city)     #相当与 print(city)
print(sys.modules[__name__])            #本文件的命名空间(默认使用此方式)#__name__ == '__main__'
ret = getattr(sys.modules[__name__],'city')   #相当于 ret = city , 相当于 sys.modules['__main__'].city
ret = getattr(sys.modules[__name__],'city')   #相当于本文件中的city变量
print(ret)

setattr(object, name, value)
object — 对象。
name — 字符串,对象属性。
value — 属性值。

class A:pass
setattr(A,'city','广州')      #相当于 A.city = '广州'
print(A.__dict__)              
print(A.city)                 #广州

delattr(object, name)
object — 对象。
name — 必须是对象的属性。

classB:
    city = '上海'
delattr(B,'city')               #相当于 del B.city

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

内置方法的形式: __名字__

名字——双下方法,魔术方法,内置方法

__init__ 类的初始化方法,不需要主动调用,而是在类的实例化的时候内部自动调用的

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

__str__

__str__的方法,必须return str类型

①当打印一个对象的时候触发__str__,打印的是__方法的返回值

②当使用%s格式化的时候,触发__str__

③str强转数据类型的时候,触发__str__

classA:
    def __init__(self,city,province):
        self.city =city
        self.province =province

    def __str__(self):
        return '%s在%s内' %(self.city,self.province)

a = A('广州市','广东省')
print(a)                
print('%s' %a)
print(str(a))

'''广州市在广东省内
广州市在广东省内
广州市在广东省内
'''

__repr__

__repr__的方法,必须return str类型

__repr__相当于__str__的备胎,有__str__的时候执行__str__,没有__str__的时候,执行__repr__

repr()内置函数对应的结果是__repr__的返回值

① 当使用repr()的时候触发__repr__

② 当使用%r格式化输出的时候触发__repr__

③ 当打印一个对象的时候触发__repr__,打印的是__方法的返回值

④ 当使用%s格式化的时候,触发__repr__

⑤ str强转数据类型的时候,触发__repr__

classA:
    def __init__(self,city,province):
        self.city =city
        self.province =province

    def __repr__(self):
        return '%s在%s内' %(self.city,self.province)

a = A('深圳市','广东省')
print(a)
print('%s' %a)
print(str(a))
print(repr(a))
print('%r' %a)

'''深圳市在广东省内
深圳市在广东省内
深圳市在广东省内
深圳市在广东省内
深圳市在广东省内
'''

继承关系中,__str__和__repr__的优先级:

结论:子类的__str__ >>> 父类的__str__ >>>子类的__repr__ >>>父类的__repr__

未经允许不得转载:便宜云主机网 » 面向对象Python反射演示