python-面向对象--反射&&方法与函数区别&&两者常用的内置函数

1     和面向对象相关的常用内置函数

1.1   issubclass

作用：

检查第一个参数是否是第二个参数的 子子孙孙类

案例：

class Base(object):
    pass

class Foo(Base):
    pass

class Bar(Foo):
    pass
# 检查第一个参数是否是第二个参数的 子子孙孙类
print(issubclass(Bar,Base)) #True

 

1.2   type

作用：

获取当前对象是由那个类创建

实例：

class Foo(object):
    pass

obj = Foo()

print(obj,type(obj)) # 获取当前对象是由那个类创建。
if type(obj) == Foo:
    print('obj是Foo类型')

答案：
# <__main__.Foo object at 0x0000014F613E83C8> <class '__main__.Foo'>
# obj是Foo类型

 

 

class Foo(object):
    pass

class Bar(object):
    pass

def func(*args):
    foo_counter =0
    bar_counter =0
    for item in args:
        if type(item) == Foo:
            foo_counter += 1
        elif type(item) == Bar:
            bar_counter += 1
    return foo_counter,bar_counter

# result = func(Foo(),Bar(),Foo())
# print(result)
v1,v2 = func(Foo(),Bar(),Foo())
print(v1,v2)    #2 1

 

1.3   isinstance

作用：

检查第一个参数（对象）是否是第二个参数（类及父类）的实例

案例：

class Base(object):
    pass

class Foo(Base):
    pass

obj1 = Foo()
print(isinstance(obj1,Foo))  # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。    #True
print(isinstance(obj1,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。    #True

obj2 = Base()
print(isinstance(obj2,Foo))  # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。   #False
print(isinstance(obj2,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。    #True

 

 

1.4   type与isinstance的区别

给你一个参数，判断对象是不是由某一个指定类？ type                  --> type(obj) == Foo

给你一个参数，判断对象是不是由某一个指定类或其父类？ isinstance    --> instance(obj,Foo)

 

形象一点：

type：只认她岳父岳母（具体）

isinstance:认她岳父岳母以及她的所有长辈

 

2     方法和函数的区别

2.1   介绍

称谓：

       类，方法

       外，函数

到底方法函数？

       对象.xxx  --> xxx就是方法

       类.xxx    --> xxx就是函数

       xxx       --> xxx就是函数

打印查看：

       function

       method

 

 

实例

class Foo(object):

    def detail(self):
        pass

    @staticmethod
    def ss():
        pass
def func():
    pass

obj = Foo()
print(obj.detail)  #<bound method Foo.detail of <__main__.Foo object at 0x000001BBBAC38470>>
print(Foo.ss)   #<function Foo.ss at 0x000001BBBAC39A60>
print(func)     #<function func at 0x00000145E2659950>

 

2.2   最科学的区分函数和方法

from types import MethodType,FunctionType
def check(arg):
    '''
    检查arg是方法还是函数？
    :param arg:
    :return:
    '''
    if isinstance(arg,MethodType):
        print('这是一个方法')
    elif isinstance(arg,FunctionType):
        print('这是一个函数')
    else:
        print('不知道是什么')

def func():
    pass

class Foo(object):
    def detail(self):
        pass
    @staticmethod
    def xxx():
        pass


check(func)   #这是一个函数

obj = Foo()
check(obj.detail)       #这是一个方法
check(obj.xxx)          #这是一个函数

 

2.3   特点（与调用者有关系，调用的方式不同，就不同）

class Foo(object):

    def f1(self):
        pass

    def f2(self):
        pass

    def f3(self):
        pass


obj = Foo()
print(Foo.f1) # 把f1当做函数，类的调用方式不能直接传参 #<function Foo.f1 at 0x00000159EFB698C8>

obj = Foo()
print(obj.f1)    # 把f1当做方法，自动传self值  #<bound method Foo.f1 of <__main__.Foo object at 0x00000159EFB689E8>>
总结：类.    是函数
    对象.   是方法

 

3     如何判断一个参数一个类还是对象呢？

#判断一个对象是不是类
class Foo:
    pass

print(type(Foo)==type)    #True    #返回True表示是类

 

 

4      callable() 如何判断一个对象是否能被调用呢？

4.1   什么可以被调用？

- 类()

- 对象()

- 函数()

- 方法()

4.2   callable() 那么如何判断一个对象是否能被调用？

# callable()判断一个对象是否可以被调用
def func():
   pass

class Foo(object):
    def __call__(self, *args, **kwargs):
        pass
    def func(self):
        pass
obj = Foo()


print(callable(func))   #True
print(callable(Foo))    #True
print(callable(obj))    #True
print(callable(obj.func))   #True

 

 

5     为什么要有方法与函数的划分呢

下面是个人的浅见：

方法可以自动传参，这就是区别，但是这只不过是省了一个步骤而已，为何要多此一举的在区分函数和方法呢？在这里你应该把这个self参数当作一个封装的包裹，里面的东西不仅仅是一个东西，这样的话，就有必要区分函数和方法

 

6     反射

所谓反射，就是一种映射关系。

下面我们由一种需求来引出反射的必要性

 

 

v = getattr(obj,"func")  # 根据字符串为参数（第二个参数），去对象（第一个参数）中寻找与之同名的成员

6.1   需求

6.1.1 之前的方式

while True:
    print("""
    系统支持的函数有：
        1. f1
        2. f2
        3. f3
        4. f4
        5. f5
    """)
    val = int(input("请输入要执行的函数："))
    
    if val == 1:
        pass
    elif val == 2:
        pass
    elif val == 3:
        pass
    elif val == 4:
        pass
    elif val == 5:
        pass

如上面的方式，我们需要用到if ... elif ... elif ... else ... 。但这种方式对于判断大量数据的时候就有些不好了，下面看反射的方式

 

6.1.2 反射的方式（在模块中的应用）

##handler.py 

f0 = 9

 

def f1():

    print('F1')

 

def f2():

    print('F2')

 

def f3():

    print('F3')

 

def f4():

    print('F4')

 

def f5():

    print('F5')

 

 

from types import FunctionType
import handler

while True:
    print("""
    系统支持的函数有：
        1. f1
        2. f2
        3. f3
        4. f4
        5. f5
    """)
    val = input("请输入要执行的函数：")  # val = "f1"
    # 错误
    # handler.val()       #用这种方式代替if ...elif....elif...else，但尝试失败。因为val本质是一个字符串并不是一个内存地址

    if hasattr(handler, val):  # 判断handler模块是否有val变量的内容所代表的函数
        func_or_val = getattr(handler, val)  # 根据字符串为参数，去handler模块中寻找与之同名的成员。
        if isinstance(func_or_val, FunctionType):
            func_or_val()  # 如果是方法就执行这个方法，否则打印
        else:
            print(func_or_val)
    else:
        print('handler中不存在输入的属性名')

 

注意：从上面可以看是怎么体现反射的，所谓反射就是映射关系。通过getattr来判断映射项中是否有与之对应的。

 

案例1：在面向对象中的应用

class Foo(object):

    country = "中国"

    def func(self):
        pass


v = getattr(Foo,'func') # Foo.func # 根据字符串为参数，去类中寻找与之同名的成员。
print(v)            #<function Foo.func at 0x00000153C64198C8>

obj = Foo()
v = getattr(obj,"func") # obj.func # 根据字符串为参数，去对象中寻找与之同名的成员。
print(v)                #<bound method Foo.func of <__main__.Foo object at 0x00000153C64184E0>>

案例2：

class Foo(object):
    
    def __init__(self,a1):
        self.a1 = a1
        self.a2 = None

obj = Foo(1)

v1 = getattr(obj,'a1')
print(v1)           #1

setattr(obj,'a2',2) #更改变量

v2 = getattr(obj,'a2')
print(v2)           #2

案例3：

class Account(object):

    func_list = ['login', 'logout', 'register']

 

    def login(self):

        """

        登录

        :return:

        """

        print('登录111')

 

    def logout(self):

        """

        注销

        :return:

        """

        print('注销111')

 

    def register(self):

        """

        注册

        :return:

        """

        print('注册111')

 

    def run(self):

        """

        主代码

        :return:

        """

        print("""

            请输入要执行的功能：

                1. 登录

                2. 注销

                3. 注册

        """)

 

        choice = int(input('请输入要执行的序号:'))

        func_name = Account.func_list[choice-1]

 

        # func = getattr(Account,func_name) # Account.login

        # func(self)

 

        func = getattr(self, func_name)  # self.login

        func()

 

obj1 = Account()

obj1.run()

 

obj2 = Account()

obj2.run()