# 两个内置函数 *# 反射  *****# 内置方法 ***

# 类(定义)    # 静态属性  类属性(变量)  直接写在类中,全大写    # 动态属性  方法(函数)     self    # 类方法    @classmethod   cls    # 静态方法  @staticmethod  没有默认参数        # 选课系统 专门给面向对象编程的时候 的函数准备的    # 特性      @property# class Person:#     @staticmethod#     def login():#         pass# class Teacher(Person):#     pass

# 调用    # 对象名.动态属性()/类名.动态属性(对象)    # 类名.静态属性/对象名.静态属性    # 类名.类方法()/对象名.类方法()    # 类名.静态方法/对象名.静态方法()

# 对象的命名空间中能存的:    # 属性# 对象能调用的:    # 对象属性    # 类中的普通方法

# 私有的    # __名字        # 静态属性        # 动态属性        # 类方法        # 静态方法        # 属性    # 私有的有什么特点        # 只能在类的内部调用        # 不能被继承    # 什么时候用私有的?        # 当不想被外部调用也不想被继承,只想在类内部使用的时候        # 当在外部使用的时候,想给用户的使用前\后直接加上某些功能            # 私有 + property使用

# 3w1h# what  这个东西是什么# where 在哪儿用# why   为什么这么用# how   怎么用

-----------------------------------------------内置函数--------------------------------------

# isinstance()  判断对象所属类型,包括继承关系# issubclass()  判断类与类之间的继承关系

# class A:pass# class B(A):pass# b = B()# print(isinstance(b,B)) #o,t# print(isinstance(b,A)) #o,t# l = list()# print(l)  # type(l)# class mystr(str):pass# ms = mystr('alex')# print(ms)# print(type(ms) is str)  # 不包含继承关系,只管一层# print(isinstance('alex',str)) # 包含所有的继承关系

# == 值相等        值运算# is 内存地址相等  身份运算# is要求更苛刻    # 不仅要求值相等,还要求内存地址相同

# a = 1111# b = 1111# a == b# a is b

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

---------------------------------------------反射------------------------------------------------------------

# 什么是反射?# 用字符串数据类型的变量名来访问这个变量的值# 反射的方法: getattr hasattr setattr delattr

# class Student:#     def __init__(self,name):#         self.name = name#     def check_course(self):#         print('check_course')#     def choose_course(self):#         print('choose_course')#     def choosed_course(self):#         print('查看已选择的课程')# stu = Student()# num = input('>>>')# if num == 'check_course':#     stu.check_course()# elif num == 'choose_course':#     stu.choose_course()# elif num == 'choosed_course':#     stu.choosed_course()

# eval 这个东西 明确的写在你的代码里

# 类  静态属性 类方法 静态方法# 命名空间.XXX == getattr(命名空间,'XXX')# 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')()         # 静态方法## num = input('>>>')# if hasattr(Student,num):#     getattr(Student,num)()

# 对象# 方法 对象属性# 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')()

# 模块# import os   # 别人写好的python代码的结合# # os.rename('__init__.py','init')# # getattr(os,'rename')('init','__init__.py') # == os.rename# rename = os.rename# rename2 = getattr(os,'rename')# rename2('__init__.py','init')  # os.rename('__init__.py','init')# rename('init','init2')          # os.rename('init','init2')

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

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

------------------------------------------------内置方法-------------------------------------------------------

# __名字__    # 类中的特殊方法\内置方法    # 双下方法    # 魔术方法   magic_method# 类中的每一个双下方法都有它自己的特殊意义

# __call__ 相当于 对象()# __len__  len(obj)# __new__  特别重要   开辟内存空间的 类的构造方法    # 写一个单例类=# __str__  str(obj),'%s'%obj,print(obj)

# 所有的双下方法 没有 需要你在外部直接调用的# 而是总有一些其他的 内置函数 特殊的语法 来自动触发这些 双下方法

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

# __len__# 内置函数和类的内置方法是由奸情的# len(dict)# len(tuple) str list set# 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函数会报错

# iter和next的例子# __iter__  iter(obj)# __next__  next# def iter(obj):#     return obj.__iter__()# l = [1,2,3]# iter(l) # l.__iter__()

# 练习# 类# self.s = ''# len(obj) = str的长度# class My:#     def __init__(self,s):#         self.s = s#     def __len__(self):#         return len(self.s)# my = My('abc')# print(len(my))

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

# 1.开辟一个空间,属于对象的# 2.把对象的空间传给self,执行init# 3.将这个对象的空间返回给调用者# obj = Single()# single的new,single没有,只能调用object的new方法# new方法在什么时候执行???    # 在实例化之后,__init__之前先执行new来创建一块空间

# 单例# 如果一个类 从头到尾只能有一个实例,说明从头到尾之开辟了一块儿属于对象的空间,那么这个类就是一个单例类# class A:pass# a = A()# a2 = A()# a3 = A()# print(a,a2,a3)

# 单例类# 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)

# __str__# l = [1,2,3]  # 实例化一个list的对象# # l是个对象# print(l)

# 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__方法