面向对象中内置函数

issubclass方法:

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

返回 : 是一个布尔值

 class Base(object):

     pass

 class Foo(Base):

     pass

 class Bar(Foo):

     pass

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

type: 方法

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

返回: 类的类型 , if判断是否等于某个类

 class Foo(object):

     pass

 obj = Foo()

 print(obj,type(obj))   # 获取当前对象有哪个类创建

 if type(obj) == Foo:

     print("由类Foo创建")

 def func(*args):

     Foo_count = 0

     Base_count = 0

     for el in args:

         if type(el) == Foo:

             Foo_count += 1

         elif type(el) == Base:

             Base_count += 1

     return Foo_count,Base_count

 # ret = func(Base(),Base(),Foo(),Foo(),Foo())

 # print(ret)

 v,i = func(Base(),Base(),Foo(),Foo(),Foo())

 print(v,i)

例子

isinstance : 方法

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

返回值: 布尔型

class Base(object):

    pass

class Foo(Base):

    pass

obj = Foo()

print(isinstance(obj,Foo))

print(isinstance(obj,Base))

#

True

True

总结 : 给一个参数,判断对象是不是由某一个指定类创建, 用 type(obj) == Foo

　　　给一个参数,判断对象是不是由某一个指定类或父类创建 , 用 isinstance(obj,Foo)

方法和函数

对象.xxx xxx就是方法

类.xxx xxx就是函数

xxx xxx就是函数

判断是函数还是方法可以通过打印查看

打印显示的有 function 表示函数

打印显示的有 method 表示方法

 from types import FunctionType,MethodType

 def check(args):

     """

     检查args是函数还是方法

     :param args:

     :return:

     """

     if isinstance(args,FunctionType):

         print("是函数")

     elif isinstance(args,MethodType):

         print("是方法")

     else:

         print("是其他")

 check(参数)

代码检查

反射

getattr # 根据字符串的形式,去对象中找成员. 第一个参数是(模块或对象或类), 第二个参数是(用户输入或值)

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

 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 hasattr(handler,val):

                     func_or_val = getattr(handler,val)     # 根据字符串为参数，去模块中寻找与之同名的成员。

                     if isinstance(func_or_val,FunctionType):

                         func_or_val()

                     else:

                         print(func_or_val)

                 else:

                     print('handler中不存在输入的属性名')

                 # 正确方式

                 """

                 if val == 'f1':

                     handler.f1()

                 elif val == 'f2':

                     handler.f2()

                 elif val == 'f3':

                     handler.f3()

                 elif val == 'f4':

                     handler.f4()

                 elif val == 'f5':

                     handler.f5()

                 """

示例模块

             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()

示例类或对象

setattr # 根据字符串的形式 , 动态的设置一个成员(在内存中) (三个参数, 第一个参数是要设置的变量, 第三个变量是要设置的值)

delattr # 根据字符串的形式 , 动态的删除一个成员(在内存中) 语法 :

 class Foo(object):

     def __init__(self,a1):

         self.a1 = a1

         self.a2 = None

 obj = Foo(1)

 v1 = getattr(obj,'a1')

 print(v1)

 setattr(obj,'a2',2)

 v2 = getattr(obj,'a2')

 print(v2)

示例

callable 判断名() 是否可以执行

返回值 : bool类型

只有类 , 对象 , 函数 , 方法, 后面加 () 可以被调用

 def func():

     pass

 class Foo(object):

     def __call__(self, *args, **kwargs):

         pass

     def fun(self):

         pass

 obj = Foo()

 print(callable(func))

 print(callable(Foo))

 print(callable(obj))

 print(callable(obj.fun))

示例

巴特西

Python 面向对象 (补充) , 反射 , 内置函数

面向对象中内置函数

issubclass方法:

type: 方法

isinstance : 方法

方法和函数

对象.xxx xxx就是方法

类.xxx xxx就是函数

xxx xxx就是函数

判断是函数还是方法可以通过打印查看

反射

getattr # 根据字符串的形式,去对象中找成员. 第一个参数是(模块或对象或类), 第二个参数是(用户输入或值)

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

setattr # 根据字符串的形式 , 动态的设置一个成员(在内存中) (三个参数, 第一个参数是要设置的变量, 第三个变量是要设置的值)

delattr # 根据字符串的形式 , 动态的删除一个成员(在内存中) 语法 :

callable 判断名() 是否可以执行

返回值 : bool类型

只有类 , 对象 , 函数 , 方法, 后面加 () 可以被调用

最新文章

热门文章

巴特西

Python 面向对象 (补充) , 反射 , 内置函数

面向对象中内置函数

issubclass方法:

type: 方法

isinstance : 方法

方法和函数

对象.xxx xxx就是方法

类.xxx xxx就是函数

xxx xxx就是函数

判断是函数还是方法 可以通过打印查看

反射

getattr # 根据字符串的形式,去对象中找成员. 第一个参数是(模块或对象或类), 第二个参数是(用户输入或值)

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

setattr # 根据字符串的形式 , 动态的设置一个成员(在内存中) (三个参数, 第一个参数是 要设置的变量, 第三个变量是要设置的值)

delattr # 根据字符串的形式 , 动态的删除一个成员(在内存中) 语法 :

callable 判断 名() 是否可以执行

返回值 : bool类型

只有 类 , 对象 , 函数 , 方法, 后面加 () 可以被调用

最新文章

热门文章

判断是函数还是方法可以通过打印查看

setattr # 根据字符串的形式 , 动态的设置一个成员(在内存中) (三个参数, 第一个参数是要设置的变量, 第三个变量是要设置的值)

callable 判断名() 是否可以执行

只有类 , 对象 , 函数 , 方法, 后面加 () 可以被调用