# =========================== 函数的进阶
# ========================== isinstance和issubclass
# 对象与类之间的关系
# 判断第一个参数是否是第二个参数的实例
# 身份运算
# 2 , 3 # 值是否相等
# 2 is 3 # 内存地址是否相等】
# class A:pass
# class B(A):pass
# class C(B):pass
# c = C()
# print(isinstance(c,A)) # 包含继承关系的判断
# print(type(b) is B)
# print(type(b) is A) # type只关心创建这个对象的类
# 类与类之间的关系
# issubclass()
# class A:pass
# class B(A):pass
# print(issubclass(A,B))
# print(issubclass(B,A))
# 第一个参数是疑似子类,第二个参数是疑似父类.
# 最终结果如果真的是父子类关系,则返回True
# ============= 反射
# 反射的定义 : 通过字符串 来 操作python代码中的 变量 函数 甚至类和方法
# class A:
# name = 'alex' # 静态 属性
# age = 83 # 静态 属性
# hasattr getattr
# print(getattr(A,'name'))
# print(hasattr(A,'name'))
# 在类中使用 类中获取类的静态属性
# tag = input('>>>')
# if hasattr(A,tag):
# print(getattr(A,tag))
# 属性的值 = getattr(类名,字符串数据类型的属性名)
# 如果第二个参数是不存在的属性名,则会报错
#
# class Student:
# def __init__(self,name,age):
# self.name = name
# self.age = age
# def show(self):
# for key in self.__dict__:
# print(key,self.__dict__[key])
#
# yuan = Student('苑昊',38)
# # yuan.show()
# # 'show'
# if hasattr(yuan,'name'):
# print(getattr(yuan,'name'))
# if hasattr(yuan,'show'):
# func = getattr(yuan,'show')
# func()
# a.b getattr(a,'b')
# if hasattr(yuan,"name"):
# print(getattr(yuan,"name")())
# hasassr getattr
# 类.静态属性 getattr(类,'静态属性')
# 对象.方法
# getattr(对象,'方法')() 直接反射得到一个方法之后调用
# 对象.对象属性
# 应用场景 : 网络编程 从文件中读取信息反映到编程中
# setattr delattr
# class Student:
# def __init__(self,name,age):
# self.name = name
# self.age = age
# def show(self):
# for key in self.__dict__:
# print(key,self.__dict__[key])
#
# hei = Student('小黑',18)
# hei.sex = '不详'
# print(hei.sex)
# setattr(hei,'sex','不详') # 增改操作
# print(hei.sex)
# setattr(hei,'sex','male')
# print(hei.sex)
# delattr(hei,'sex') # 删除操作
# print(hei.__dict__)
# def wahaha(a,b): # 专属于某一个对象的静态方法
# print(a,b)
#
# setattr(hei,'func',wahaha) #这样写有问题
# print(hei.__dict__)
# hei.func(1,2)
# hasattr 判断某一个 变量 是否能够.调用一个名字,返回True或者False
# getattr 直接获取一个变量中的名字的值
# setattr 为一个变量增加或者修改一个属性
# delattr 删除一个变量中的属性或者方法
# d = {'k':'v'} #d.keys()
# print(getattr(d,'keys')())
# f = open() # f文件操作对象
# f.read() # 文件对象.read方法
# a.b
# 模块名.函数名
# import my_moudle
# print(my_moudle.money)
# print(getattr(my_moudle,'money'))
# getattr(my_moudle,'qqxing')()
# 包
# import 包名 ---> 包内的__init__文件
# def sww():
# print('爽歪歪')
# count = 0
import sys
# print(sys.modules[__name__]) # 一定是aaa.py
# print(sys.modules['__main__']) # 不确定的
# print(getattr(sys.modules[__name__],'count'))
# getattr(sys.modules[__name__],'sww')()
# print(sys.modules[__name__])
# # print(sys.modules['my_moudle'])
# # print(my_moudle)
# print(getattr(sys.modules['my_moudle'],'qqxing'))
# 反射类中的名字
# getattr(类名,'静态属性')
# getattr(类名,'类方法')()
# getattr(类名,'静态方法')()
# 反射对象中的名字
# getattr(对象名,'对象属性')
# getattr(对象名,'方法名')()
# 反射模块中的名字
# import 模块名
# getattr(模块名,'模块中的变量')
# getattr(模块名,'模块中的函数')()
# getattr(模块名,'模块中的类名')
# 反射当前模块中的名字
# import sys
# getattr(sys.modules[__name__],'变量')
# getattr(sys.modules[__name__],'函数')()
# getattr(sys.modules[__name__],'类名')
# sys.modules[__name__]
# import sys
# print(sys.modules[__name__]) # 所有导入过的模块
# {'字符串数据类型的模块名':模块的内存地址}
# {'__main__':当前模块的内存地址}
# 怎么反射类 ?
# class Student:
# def __init__(self,name,age):
# self.name = name
# self.age = age
# def show_student(self):
# for key in self.__dict__:
# print(key,self.__dict__[key])
#
# class Teacher:
# def __init__(self, name, age):
# self.name = name
# self.age = age
#
# def show_teacher(self):
# for key in self.__dict__:
# print(key, self.__dict__[key])
#
# class Manager:
# def __init__(self, name, age):
# self.name = name
# self.age = age
#
# def show_manager(self):
# for key in self.__dict__:
# print(key, self.__dict__[key])
# # hei = Student('小黑',18)
# import sys
# main = sys.modules[__name__]
# import my_moudle
# cls = getattr(my_moudle,'Student')
# hei = cls('小黑',18)
# print(hei,hei.__dict__)
# 'Manager' 'Teacher' 'Student'
# 获取字符串数据类型的类名
# cls_name = input('>>>')
# 根据输入反射找到具体的类
# if hasattr(main,cls_name):
# cls = getattr(main,cls_name)
# 实例化对象
# alex = cls('alex',81)
# print(type(alex))
# 展示这个对象中的所有方法
# for i in alex.__dict__:
# print(i,alex.__dict__[i])
# =========== 类中的内置方法
# 类中的内置方法 __方法名__
# 魔术方法 双下方法
# 内置方法 : 是直接和python的语法隐形相关
# len()内置函数 __len__()
# hash()哈希函数 __hash__()
# str() __str__()
# l = [1,2,3,4]
# len(l)
# class A:
# def __init__(self,name,cls,age,sex):
# self.name = name
# self.cls = cls
# self.age = age
# self.sex = sex
# def __eq__(self, other):
# # if self.__dict__ == other.__dict__:return True
# return True
# def __len__(self):
# return len(self.__dict__)
# hei = A('小黑','py10期',18,'无')
# hei2 = A('小2黑','py11期',17,'无')
# # def len(obj):
# # return obj.__len__()
# # print(len(hei))
# print(hei.__dict__)
# self.age = age
#
# def __eq__(self, other):
# if self.name == other.name:
# return True
#
#
# def __len__(self):
# return 5
#
# hei = Type("小二黑","man",13)
# hei2 = Type("二黑","man",17)
#
# # print(len(hei))
# # print(len(hei2))
# print(len(hei))
# print(len(hei2))
# print(hei2.__dict__)
# print(hei == hei2) # 两个对象就算值是完全相等的,但是仍然内存地址不同
# == 时间上是比较内存地址的
# == 实际上是调用了__eq__方法
# class Type:
# def __init__(self,name,sex,age):
# self.name = name
# self.sex = sex
#
# __ format ------------
# format_dict={
# 'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
# 'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
# 'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
# }
# class School:
# def __init__(self,name,addr,type):
# self.name=name
# self.addr=addr
# self.type=type
#
# def __format__(self, format_spec):
# return format_spec.format(obj=self)
#
# s1=School('oldboy1','北京','私立')
# print(format(s1,format_dict['tna']))
# print(format(s1,format_dict['nat']))
# print(format(s1,format_dict['tan']))
# print(format(s1,'tna'))
# print(format(s1,'tan'))
# __ str __ 和 __rept__
# class School:
# def __init__(self,name,addr,type):
# self.name=name
# self.addr=addr
# self.type=type
# def __str__(self):
# return str(self.__dict__) # 必须是字符串类型
# def __repr__(self): # repr是str的备胎
# return 'repr : school的repr对象'
# s1=School('oldboy1','北京','私立')
# print(str(s1))
# print('%s'%s1)
# print(s1)
#
# print(repr(s1))
# print('%r'%s1)
# print('%s'%s1) # str __str__
# %s str 直接打印 内部都是调用了__str__
# l = [1,2,3,4,5]
# print(l)
# object __eq__,__str__,__repr__
