欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

方法和函数,isinstance/issubclass/type以及反射

程序员文章站 2022-06-05 16:54:08
一丶,isinstance/issubclass/type 1.isinstance检查第一个参数是否是第二个参数的 子子孙孙类 2.type获取当前对象是由那个类创建。 type练习 class Foo(object): pass class Bar(object): pass def func( ......

一丶,isinstance/issubclass/type

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

class foo():
    pass
class boo(foo):
    pass
class aoo(boo):
    pass
print(issubclass(boo,foo))      #true
print(issubclass(aoo,foo))      #true

  2.type获取当前对象是由那个类创建。

class foo(object):
    pass

obj = foo()

print(obj,type(obj))     #<__main__.foo object at 0x000001b58f579d68> <class '__main__.foo'>
if type(obj) == foo:
    print('obj是foo类型')  #obj是foo类型

  type练习

方法和函数,isinstance/issubclass/type以及反射
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)   #(2, 1)

v1,v2 = func(foo(),bar(),foo())
print(v1,v2)    #2 1
type练习

  3.isinstance,检查第一个参数(对象)是否是第二个参数(类及父类)的实例。

class base(object):
    pass

class foo(base):
    pass

obj1 = foo()
print(isinstance(obj1,foo))  # 检查第一个参数(对象)是否是第二个参数(类及父类)的实例。
print(isinstance(obj1,base)) # 检查第一个参数(对象)是否是第二个参数(类及父类)的实例。

obj2 = base()
print(isinstance(obj2,foo))  # 检查第一个参数(对象)是否是第二个参数(类及父类)的实例。
print(isinstance(obj2,base)) # 检查第一个参数(对象)是否是第二个参数(类及父类)的实例。

 

  

 二丶方法和函数

   称谓:

    类,方法

    外,函数

  到底什么是方法,什么是函数?

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

    类.xxx    ---> xxx就是函数

    xxx  --->  xxx就是函数

  打印查看:

    function

    method

 

代码演示:

from types import methodtype,functiontype
class foo:
    def display(self):
        pass
def check(arg):
    """
    检查arg是方法还是函数?
    :param arg:
    :return:
    """
    if isinstance(arg,methodtype):
        print('arg是一个方法')
    elif isinstance(arg,functiontype):
        print('arg是一个函数')
        
    else:
        print('不知道是什么')
check(check)        #arg是一个函数
obj = foo()
check(obj.display)      #arg是一个方法

 

三丶反射 

  1.getattr : 根据字符串的形式,去对象中找成员

class foo(object):

    country = "中国"

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

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

  2.hasattr : 根据字符串的形式,去判断对象中是否有成员.

a = 123
class foo(object):
    country = "中国"
    def func(self):
        pass
v2 = hasattr(foo,"a")       #判断foo中是否有a成员
v3 = hasattr(foo,'country') #判断foo中是否有country成员
v4 = hasattr(foo,"func")    #判断foo中是否有func成员
v5 = hasattr(foo,'xxxxxxx')

print(v2,v3,v4,v5)    # false true true false

  3.setattr : 根据字符串的形式,动态的设置一个成员(内存)

# 根据字符串的形式,动态的设置一个成员(内存)
x1 = 123
class foo:
    def f1(arg):
        print(arg,666)

setattr(foo,'x2',999)
v1 = getattr(foo,'x2')
print(v1)   #999

  4.根据字符串的形式,动态的删除一个成员(内存)

x1 = 123
class foo:
    def f1(arg):
        print(arg,666)
delattr(foo,'x1')
v9 = getattr(foo,'x1')
print(v9)

  应用

方法和函数,isinstance/issubclass/type以及反射
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(self, func_name)  # self.login
        func()

obj1 = account()
obj1.run()

obj2 = account()
obj2.run()
应用

 四丶callable 判断是否可以调用

def func():
    pass

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

print(callable(func))
print(callable(foo))
print(callable(obj))
print(callable(obj.func))