内置函数,反射,内置方法

1,内置函数,1>isinstance() 2>issubclass()

1.1>isinstance(),是判断对象所属类型,包括继承关系
isinstance(obiect,type)判断对象object是不是某某类型

class A:
    pass
class B(A):
    pass
b = B()  # print(isinstance(b,B)),判断对象b是不是属于B类(b是子类B实例化的对象,那肯定是)

1.2>issubclass(),是判断类与类之间的继承关系(即判断这2个之间是不是存在继承关系),得出的结果是True或者False
- print(issubclass(B,A)).......................判断类B是不是继承类A,这时返回的是True
- print(b,A)........................................此时报错,因为对象b和A没有继承关系,和B也不是继承关系
1.3>isinstance和is的区别

class Mystr(str):  #此时打印的是实例化对象空间里放了个"alex"
    pass


ms = Mystr("alex")
print(ms)  # 此时打印的是实例化对象空间里放了个"alex"
print(type(ms) is str)  # type(ms)是指向对象子类的空间(内存地址)
print(isinstance("alex", str))  # 判断"alex"是父类str

2,反射:用字符串数据类型的变量来访问这个变量,反射的方法:getatter hasatter setatter delatter

格式: 命名空间.xxx == getatter(命名空间,"xxx")

class Student:
    ROLE = "STUDENT"

    @classmethod
    def check_course(cls):
        print("查看课程")

    @staticmethod
    def login():
        print("登录")

2.1>反射查看属性(通过类名去调用)
- print(Student.ROLE)....................................普通查看类中静态属性的方法
- print(getatter(Student,"STUDENT"))..................用getattr去查看静态属性的方法
2.2>反射调用方法
- Student.login()..........................普通调用方法
- getattr(Student,"login")().........................使用getattr调用类中的函数
2.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")()  #使用getattr放法访问类中的方法

反射:

hasattr,getattr

类名,名字

　　getattr(类名,"名字")

对象名,名字

　　getattr(类名,"名字")

模块名,名字

　　import   模块

　　getattr(模块,名字)

自己文件,名字

　　import  sys

　　getattr(sys.modules["main"],"名字")

3,内置方法

类中的特殊方法内置方法
双下方法/魔术方法
类中的每一个双下方法都有它特殊的意义
3.1>__call__方法相当于对象()

class A :
    def __call__(self, *args, **kwargs):
        print("执行call方法了")

    def call(self):
        print("执行call方法")
class B:
    def __init__(self, cls):
        print("在实例化之前做了一些事")
        self.a = cls()
        self.a()
        print("在实例化之后做了一些事")
a = A()  # 实例化一个对象在后边加一个()就自动执行__call__方法:执行call方法了
a()  # 调用call方法
B(A)  # 实例化B类形成一个对象,把父类(A)的空间传给B类中的cls执行__init__方法

3.2>__len__方法:内置函数和类的内置方法是有联系的,__len__是查找

class Mylist:
    def __init__(self):
        self.lst = [1,2,3,4,5,6]
        self.age = 83
        self.name = name
    def __len__(self):
        print("执行__len__了")
        return len(self.__dict__)
# 这的self.__dict__是查找对象中封装了几个属性,当换成self.lst时,
# 就计算对象封装属性lst的长度,当后边跟一个self.name是查找name这个字符串的长度
l = Mylist()
print(len(l))

3.3>__new__方法(构造方法), __init__方法(初始化方法)

class Single:
    def __new__(cls,*args,**kwargs)
        print("在new方法里")
        obj = object.__new__(cls)
        print("在new方法里",obj)
        return obj
    def __init__(self):
        print("在init方法里",self)

- 3.3.1>在内存开辟一个空间,是属于对象的
- 3.3.2>把对象的空间传给self,执行init
- 3.3.3>将这个对象的空间返回给调用者
- 3.3.4>在实例化一个对象,在__init__之前执行__new__方法来创建一块空间
单类:如果一个类,从头到尾只能有一个实例,说明从头到尾就开辟了一块空间(有且只有一个空间),name这个类就是单例类
单例类:

class Single:
    __ISINSTANCE = None
    def __new__(cls,*args,**kwargs):
        if not cls__ISINSTANCE:
            cls.__ISINSTANCE = object.__new__(cls)
            return cls.__new__ISINSTANCE
    def __init__(self,name,age):
        self.name = name 
        self.age = age
        s1 = Single("alex",18)
        s2 = Single("taibai",40)
        print(s1.name)
        print(s2.name)
        print(s1,s2)

第一次输进去的"alex"被"taibai"覆盖掉了
3.4>__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')

huang = Student('huangdongyang','py14')

print('学生1 : %s'%he)  #

# 内置的数据类型,内置的类,相当于执行__str__

# print一个对象相当于调用一个对象的__str__方法
# str(obj),相当于执行obj.__str__方法
# '%s'%obj,相当于执行obj.__str__方法

内置函数,反射,内置方法

帅爆太阳的男人