zoukankan      html  css  js  c++  java
  • day 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__ 有两个内存的值
    #
  • 相关阅读:
    Serialize and Deserialize Binary Tree
    sliding window substring problem汇总贴
    10. Regular Expression Matching
    《深入理解计算机系统》(CSAPP)读书笔记 —— 第七章 链接
    程序员如何写一份合格的简历?(附简历模版)
    9个提高代码运行效率的小技巧你知道几个?
    《深入理解计算机系统》(CSAPP)读书笔记 —— 第六章 存储器层次结构
    24张图7000字详解计算机中的高速缓存
    《深入理解计算机系统》(CSAPP)实验四 —— Attack Lab
    《深入理解计算机系统》(CSAPP)读书笔记 —— 第五章 优化程序性能
  • 原文地址:https://www.cnblogs.com/xiaoluoboer/p/7896046.html
Copyright © 2011-2022 走看看