daｙ 28 hasattr getattr serattr delattr 和带__内置__ 类的内置方法

反射 后边有关字符串的
# class Management:
#     role = '管理员'
#     def __init__(self,name,sex,phone,mail):
#         self.name = name
#         self.sex = sex
#         self.phone = phone
#         self.mail = mail
#     def creat_class(self):
#         print('创建了一个班级')
#     def creat_teacher(self):
#         print('新建了一条讲师信息')
#     def creat_student(self):
#         print('新建了一条学生信息')
# manager = Management('小雨','女',1233211234567,'xiaoyu@qq.com')
# print(hasattr(manager,'小华'))     #  D对象和属性 判断是否有  返回 布尔值  False
# print(hasattr(manager,'creat_student'))   #  返回  True
# ---------
# 属性的 hasattr()和 getattr组合用法
# if  hasattr(Management,'role'):                   #类名 和属性
#     print(getattr(Management, 'role'))
# else:
#     logging.warning('没有输入的属性')
#     管理员
# 获取方法  getattr
# func = getattr(manager,'creat_student')   #只是个函数名字 需要后边调用
# func()
# 新建了一条学生信息
# -------
# hasatt 和 getattr 组合用法
# import logging
# if hasattr(manager, 'hobby'):  # 类名 和属性
#     print(getattr(manager, 'hobby'))
# else:
#     logging.warning('没有输入的属性')

# manager = Management('小雨','女',111252,'1111@qq.com')
# if hasattr(manager,'sex1'):  # True
#     sex = getattr(manager,'sex1')#  False
#     print(sex)
# else:
#     print('没有你输入的属性')
#     没有你输入
#     ------------
# 设置属性 也就是修改 setattr
# setattr(Management,'role','小孩子') #先改变在打印
# print(getattr(Management,'role'))
# 小孩子

# -----
# 删除 delattr()
# print(getattr(manager,'name'))
# print(delattr(manager,'name'))
# manager.creat_class() 
# delattr(Management,'creat_class')   #删除方法 后边加括号
# manager.creat_class()

# -------
# 对象的反射
# 类的反射
# 模块的反射
# 本模块的反射：找到本模块sys.modules[__name__]
# python面向对象中的反射：通过字符串的形式操作对象相关的属性。
# python中的一切事物都是对象（都可以使用反射）

# hasattr() 函数用于判断对象是否包含对应的属性。
# getattr() 函数用于返回一个对象属性值。
# setattr 函数对应函数 getatt()，用于设置属性值，该属性必须存在。
# delattr 函数用于删除属性。
# delattr(x, 'foobar') 相等于 del x.foobar。

# import mkfs
# mkfs  作为另一个被引用的模块的py文件
# m= 'wangyan'
# def qqxing(arg):
#     print('qqxing','arg')
　　　　return ‘调用成功’
# --
# print(mkfs.m)    # 第一种 调用模块
# print(getattr(mkfs,'m'))   #反射调用
# ret = getattr(mkfs,'qqxing') #  反射函数名ret 因为是方法 后边在调用
# ret('arg')    #调用函数已经有上传参数了 必须和参数保持一致
# qq = getattr(mkfs,'qqxing')   # 函数名字
# ret=qq('www')   # 返回值  和调用
# print(ret)
# qqxing arg
# 调用成功
# ------------------------
# 其他内置函数的
# __str__方法
# class A:pass
# a = A()
# print(a) # <__main__.A object at 0x014BA450   内存地址 自己找不到到父类找 再找不到就是object
# l = list()
# print(l)  # []  为什么打出来长上面的不一样，因为list里面有内置方法
# print(a.__str__())  #<__main__.A object at 0x014BA450
# ****打印一个对象的时候，实际上是调用了这个对象所在类的__str__方法，打印的是这个方法的返回值
#  返回值必须是字符串

# print('%s'%a)  #<__main__.A object at 0x014BA450
# %s 就是__str__方法的返回值
# --------------------------
# # 类的双下划线方法  比较
# # __str__  和  __repr__
# 自己定制str方法  都有的话 各用各的
# class A:
#     def __str__(self):
#         return 'a的对象'     # str必须return一个字符串
#     def __repr__(self):
#         return 'repr：A的对象'
# a = A()
# print(a.__str__())  # a的对象
# print(a.__repr__())  #
# print('%s'%a)
# print('%r'%a)
# a的对象
# repr：A的对象
# a的对象
# repr：A的对象

# # #------------------# repr是str的备胎，没有str就用repr没有__str__ 使用备胎的__repr__
# class A:
#     def __repr__(self):
#         return 'repr：A的对象'
# a = A()
# print(a.__str__())  # a的对象
# print(a.__repr__())
# print('%s'%a)
# print('%r'%a)
# repr：A的对象
# repr：A的对象
# repr：A的对象
# repr：A的对象
# ---------------
# # repr是str的备胎，没有str就用repr （repr比较随和）
# # str 却不能给repr做备胎  （str高冷 ）
# ----------没有repr 不能用str
# class A:
#     def __str__(self):
#         return 'repr：A的对象'
# a = A()
# print(a.__str__())  # a的对象
# print(a.__repr__())
# print('%s'%a)
# print('%r'%a)
# repr：A的对象
# <__main__.A object at 0x02AE3110>
# repr：A的对象
# <__main__.A object at 0x02AE3110>
# -----------------------------------------------------
# 自定制格式化字符串__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 __repr__(self):
#         return 'School(%s,%s)' %(self.name,self.addr)
#     def __str__(self):
#         return '(%s,%s)' %(self.name,self.addr)
#     def __format__(self, format_spec):
#         # if format_spec
#         if not format_spec or format_spec not in format_dict:
#             format_spec='nat'
#         fmt=format_dict[format_spec]
#         return fmt.format(obj=self)
# s1=School('oldboy1','北京','私立')
# print('from repr: ',repr(s1))
# print('from str: ',str(s1))
# print(s1)
# ----------
# __del__析构方法，当对象在内存中被释放时，自动触发执行。
# 这个方法只有在执行del A类的对象时候才会被触发  且执行代码中的内容，在删除对象
# 如果为删除了这个对象，他跟着还有些其他的附属的内容也没有了  我们就可以在这个方法中回收掉
# 注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放
# 因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

# class Foo:
#     def __del__(self):
#         print('执行我啦')
# f1=Foo()
# import time
# time.sleep(2)
# del f1  #要删除f1  在此时才会被触发
# print('删除成功')
# # 先执行 __del__(self): 在删除
# 执行我啦
# 删除成功
# --------------------------------
# __item__ 这个方法类似字典的操作
# 对象访问如果是对象名[]，是因为内部实现了item的方法
# class Foo:
#     def __init__(self,name):
#         self.name=name
#     def __getitem__(self, item):
#         print(self.__dict__[item])
#     def __setitem__(self, key, value):
#         self.__dict__[key]=value
#     def __delitem__(self, key):
#         print('del obj[key]时,我执行')
#         self.__dict__.pop(key)
#     def __delattr__(self, item):
#         print('del obj.key时,我执行')
#         self.__dict__.pop(item)
# f1=Foo('sb')
# f1['age']=18   #f1.age = 18  增加一个属性
# #  #print(f1.__dict__)
# # {'name': 'sb', 'age': 18}
# f1['age1']=19  #f1.age = 19
# del f1.age1    #方式 一删除
# del f1['age']  #方式 一删除
# f1['name']='alex'  # f1.name = 'alex'
# print(f1.__dict__)
# ------------------
# ****__new__方法
# 一般是objct 在创造的, __new__方法和 __init__方法 一定是new先执行
# 对象的实例化
    #创造一个裸地对象 —— __new__  ****
# 单例模式 —— 设计模式
# 一个类 从头到尾 只创建 一个对象
# class Singleton:
#     def __new__(cls, *args):
#         if not hasattr(cls, '_instance'):
#             cls._instance = object.__new__(cls)    #_instance 静态属性  因为前面是类  所有对象共用
#         return cls._instance
#     def __init__(self,name):
#         self.name = name
# one = Singleton('alex')
# print(one.name)
#
# two = Singleton('egon')
# print(two.name)
# print(one.name)
# print(id(one),id(two))
# alex
# egon
# egon
# 46805584 46805584
# two = one
# two.name = 'egon'
# 原因是单例模式 因为重写new 模式实现的
# ---------
# 单例模式 面试必问 ， 从头到尾一个类只有一个对象，可以多次实例化
# 但是只能是一个对象，
# class A:
#     def __init__(self):
#         self.x = 1
#         print('in init function')
#     def __new__(cls, *args, **kwargs):
#         print('in  new function')
#         return object.__new__(A, *args, **kwargs)
# a = A()
# print(a.x)
# in new function   打印出对象必须是先是new 然后是init
# in init function
# 1
# ----------------------------------------
# __call__
# 对象后面加括号，触发执行。
# 注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；
# 而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
# class Foo:
#     def __init__(self):
#         pass
#
#     def __call__(self, *args, **kwargs):
#         print('__call__')
# a = Foo()
# Foo()()    #类名（）（）
# a()     #对象名()
# __call__
# __call__
#  固定的用法 类名（）（） 和__call__是一对

# ----------------------------------------
# __len()__  长度
# class A:
#     def __init__(self):
#         self.a = 1
#         self.b = 2
#         self.c = 3
#
#     def __len__(self):
#         return len(self.__dict__)
# a = A()
# print(len(a))
 # 3   表示对象的长度  init 的属性多长就是多长
# ——————————————————
# hash 哈希调用 不可变的数据类型  针对不可变的类型
# class A:
#     def __init__(self):
#         self.a = 1
#         self.b = 2
#
#     def __hash__(self):
#         return hash(str(self.a)+str(self.b))
# a = A()
# print(hash(a))
# 1657541466  每次数值是不一样的额
# ---------------------------------
# equal 相等的  如没有条件 肯定不相等 是两个objec的 出来的
# class A:
#     def __eq__(self,obj):   #equal : 相等
#         # if  self.a == obj.a and self.b == obj.b:
#             return True
# a = A()
# b = A()
# # a.name = 'alex'
# # b.name = 'egon'
# print(a == b)
# -----------
# class A:pass
#
# a = A()
# b = A()
#
# print(a == b)
# False  inint属性有两个 根据__new__ 有两个内存的值
#