反射及内置方法

一.内置函数

　　1.instance()  判断对象与类的所属关系,包括继承关系

　　2.insubclass()  判读两个类是否有继承关系

class Person:
    def __len__(self, name ):
        self.name = name

class Student(Person):
    def work(self):
        print("好好学习,天天向上")

s1 = Student()
print(isinstance(s1, Student))   #instance() 判断对象的所属关系,包括继承关系
print(isinstance(s1, Person))

print(issubclass(Student, Person))  #issubclass()  判断两个类是否有继承关系
print(issubclass(Person, Student))

二. 反射

　　1.通过类名进行的反射

　　2.通过对象进行的反射

class Person:
    CLASS = "python 14"
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def work(self):
        print("鸭子")
    @classmethod
    def eat(cls):
        print("吃饭")
    @staticmethod
    def sleep():
        print("睡觉")
# print(Person.CLASS)
# print(getattr(Person,"CLASS"))  #通过类名反射查看静态属性
# # Person.work(11)
# getattr(Person, "work")(12)     #通过类名反射调用动态方法. 需要给self传值
# getattr(Person, "eat")()         #通过类名反射调用类方法,
# getattr(Person, "sleep")()         #通过类名反射调用静态方法

p1 = Person("胡双俊", 19)
print(getattr(p1,"CLASS"))            #通过对象反射查看静态属性
print(getattr(p1, "name"))              #通过对象反射查看动态属性
getattr(p1, "work")()                   #通过对象反射调用动态方法
getattr(p1, "eat")()                     #通过对象反射调用类方法
getattr(p1, "sleep")()                  #通过对象反射调用静态方法

　　3.模块反射

import os
os.rename("__init__.py", "胡帅哥")
getattr(os,"rename")("胡帅哥", "__init__.py")   

　　4.反射自己模块中的内容,

def wahaha():
    print('wahaha')

def qqxing():
    print('qqxing')

# 反射自己模块中的内容  找到自己当前文件所在的命名空间
wahaha()
qqxing()

import sys
print(sys.modules)
# import 都相当于导入了一个模块
# 模块哪个导入了 哪个没导入 在我的python解释器里应该记录下来
# import sys 是一个模块,这个模块里的所有的方法都是和python解释器相关的
# sys.modules 这个方法 表示所有在当前这个python程序中导入的模块
# '__main__': <module '__main__' from 'D:/sylar/python_workspace/day20/4.反射.py'>
print(sys.modules['__main__'])
my_file = sys.modules['__main__']
my_file.wahaha()
# my_file.qqxing()
# # 'qqxing'
# # 'wahaha'
# getattr(my_file,'wahaha')()
# getattr(my_file,'qqxing')()

　　5.setattr(对象名,'旧', "新")

　　　delattr(对象名,"变量")

三.单例类

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

四 内置方法

1.__名字__

　　　1.类中的特殊方法内置方法

　　　2.双下方法

　　　3.魔术方法

2.__call__

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

a1 = A()
a1()      #对象(),相当于执行了对象.__call__()

3.__new__  构造方法

4.__init__ 　初始化方法

5.__len__

# class 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函数会报错

6.__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)
# huang = Student('huangdongyang','py14')
# # print(huang)
# # print(str(he))   # 内置的数据类型,内置的类,相当于执行__str__
# print('学生1 : %s'%he)

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