面向对象---内置函数,反射,内置方法

一.内置函数

isinstance()  判断对象所属类型,包括继承关系

class A:pass
class B(A):pass
b = B()
print(isinstance(b,B)) #o,t
print(isinstance(b,A)) #o,t
结果为:
True
True

class mystr(str):pass
ms = mystr('alex')
print(ms)
print(type(ms) is str)  # 不包含继承关系,只管一层
print(isinstance('alex',str)) # 包含所有的继承关系
#alex
#False
#True

issubclass()  判断类与类之间的继承关系

class A:pass
class B(A):pass
print(issubclass(B,A))
print(issubclass(A,B))
#True
#False

二.反射

定义:用字符串数据类型的变量名来访问这个变量的值

方法:getattr hasattr setattr delattr

1.类 静态属性 类方法 静态方法

# 命名空间.XXX == getattr(命名空间,'XXX')

class Student:
    ROLE = 'STUDENT'
    @classmethod
    def check_course(cls):
        print('查看课程了')

    @staticmethod
    def login():
        print('登录')
# # 反射查看属性
print(Student.ROLE)
print(getattr(Student,'ROLE'))
>>>
STUDENT
STUDENT

2.反射调用方法

class Student:
    ROLE = 'STUDENT'
    @classmethod
    def check_course(cls):
        print('查看课程了')

    @staticmethod
    def login():
        print('登录')
# # 反射查看属性
print(Student.ROLE)
print(getattr(Student,'ROLE'))
getattr(Student,'check_course')()  # 类方法
getattr(Student,'login')()         # 静态方法
#hasattr
num = input('>>>')
if hasattr(Student,num):
    getattr(Student,num)()
>>>
查看课程了
登录
>>>login
登录

3.对象

方法 对象属性

class A():
    def __init__(self,name):
        self.name = name

    def func(self):
        print('in func')

a = A('alex')
print(a.name)
print(getattr(a,'name'))
getattr(a,'func')()
>>>>
alex
alex
in func

三.模块

os.rename('__init__.py','init')
getattr(os,'rename')('init','__init__.py') # == os.rename

def wahaha():
    print('wahaha')

def qqxing():
    print('qqxing')

import sys
my_file = sys.modules['__main__']

my_file.wahaha()
my_file.qqxing()
getattr(my_file,'wahaha')()
getattr(my_file,'qqxing')()

结果:
wahaha
qqxing
wahaha
qqxing

总结:

反射
hasattr,getattr
类名.名字
    getattr(类名,'名字')
对象名.名字
    getattr(对象,'名字')
模块名.名字
    import 模块
    getattr(模块,'名字')
自己文件.名字
    import sys
    getattr(sys.modules['__main__'],'名字')

四.内置方法

类中的每一个双下方法都有它自己的特殊意义

__call__ 相当于 对象()
__len__  len(obj)
__new__  特别重要   开辟内存空间的 类的构造方法

__call__

class A:
    def __call__(self, *args, **kwargs):
        print('执行call方法了')
    def call(self):
        print('执行call方法了')
class B:
    def __init__(self,cls):
        print('在实例化A之前做一些事情')
        self.a = cls()
        self.a()
        print('在实例化A之后做一些事情')
a = A()
a()  # 对象() == 相当于调用__call__方法
a.call()
#
A()() # 类名()() ,相当于先实例化得到一个对象,再对对象(),==>和上面的结果一样,相当于调用__call__方法
B(A)
结果:

执行call方法了
执行call方法了
执行call方法了
在实例化A之前做一些事情
执行call方法了
在实例化A之后做一些事情

__len__

lass mylist:
    def __init__(self):
        self.lst = [1,2,3,4,5,6]
        self.name = 'alex'
        self.age = 83
    def __len__(self):
        print('执行__len__了')
        return len(self.__dict__)

l = mylist()
print(len(l))
# len(obj)相当于调用了这个obj的__len__方法
# __len__方法return的值就是len函数的返回值
# 如果一个obj对象没有__len__方法,那么len函数会报错

练习:
class My:
    def __init__(self,s):
        self.s = s
    def __len__(self):
        return len(self.s)
my = My('abc')
print(len(my))

单例类:

定义:如果一个类 从头到尾只能有一个实例,说明从头到尾之开辟了一块儿属于对象的空间,那么这个类就是一个单例类

class Single:
    __ISINCTANCE = None
    def __new__(cls, *args, **kwargs):
        if not cls.__ISINCTANCE:
            cls.__ISINCTANCE = object.__new__(cls)
        return cls.__ISINCTANCE
    def __init__(self,name,age):
        self.name = name
        self.age = age

s1 = Single('alex',83)
s2 = Single('taibai',40)
print(s1.name)
print(s2.name)
print(s1,s2)
结果:

taibai
taibai
<__main__.Single object at 0x000001B2985D6630> <__main__.Single object at 0x000001B2985D6630>

__str__

class Student:
    def __str__(self):
        return '%s %s %s'%(self.school,self.cls,self.name)

    def __init__(self,name,stu_cls):
        self.school = 'oldboy'
        self.name = name
        self.cls = stu_cls

he = Student('hezewei','py14')
print(he)

print(str(he))   # 内置的数据类型,内置的类,相当于执行__str__
print('学生1 : %s'%he)

# print一个对象相当于调用一个对象的__str__方法
# str(obj),相当于执行obj.__str__方法
# '%s'%obj,相当于执行obj.__str__方法
结果:
oldboy py14 hezewei
oldboy py14 hezewei
学生1 : oldboy py14 hezewei