# 两个内置函数 *
# 反射 *****
# 内置方法 ***
# 类(定义)
# 静态属性 类属性(变量) 直接写在类中,全大写
# 动态属性 方法(函数) 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__方法
