Python面向对象之反射

Posted 2021-01-03 Python小白白白白白白

一、补充

@classmethod

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

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

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

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

 

@statimethod

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

这个函数就不需要传默认的参数：self，cls

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

通过类名调用本质是函数

 

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

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

from types import FunctionType,MethodType
class Foo:
    @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 import FunctionType,MethodType
class Foo:
    @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
\'\'\'

 

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

def func(args):
    if callable(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（方法）

类方法：类调用和对象调用都是method（方法）

静态方法：类调用和对象调用都是function（函数）

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

    for item in args:
        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
class Foo:
    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属性

 

三、反射类中的变量

① 反射静态变量

class A:
    city = \'Shenzhen\'

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

 

② 反射类方法

class B:
    @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

 

③ 反射静态方法

class C:
    @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

 

四、反射对象中的变量

① 反射对象属性

class A:
    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)                   # 广州

 

② 反射普通方法

class B:
    def func(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

 

五、反射模块中的变量

import os
getattr(os,\'rename\')(\'a.txt\',\'b.txt\')   # 相当于 os.rename(\'a.txt\',\'b.txt\')
# os.rename(\'a.txt\',\'b.txt\')

 

六、反射本文件中的变量

import sys
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() 和 delattr()

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 -- 必须是对象的属性。

class B:
    city = \'上海\'

delattr(B,\'city\')               # 相当于 del B.city

 

八、内置方法

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

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

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

 

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

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

 

__str__

__str__的方法，必须return str类型

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

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

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

class A:
    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__

class A:
    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__