函数的进阶 和 反射

#                             ===========================   函数的进阶
#          ==========================   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__