您的位置: 首页  >  IT文章  >  面向对象2 面向对象之反射 面向对象之内置方法

面向对象2 面向对象之反射 面向对象之内置方法

分类: IT文章 • 2023-12-19 10:09:13

参考 ：https://www.cnblogs.com/yuliangkaiyue/p/9516427.html

面向对象之内置方法

__setattr__ ,__getattr__,__delattr__

  1. class Foo:
  2. x = 1
  4. def __init__(self, y):
  5. self.y = y
  7. def __setattr__(self, key, value):
  8. print('----->setattr')
  9. # self.key =value #等同于赋值，不断触发setattr，造成递归循环
  10. self.__dict__[key] = value
  12. def __getattr__(self, item):
  13. print('------->getattr')
  14. print('%s不存在' % item)
  16. def __delattr__(self, item):
  17. print('-------delete')
  18. # del self.item # 同上理
  19. self.__dict__.pop(item)
  22. f = Foo(6)
  23. print(f.__dict__)
  26. f.z
  28. f.z =2
  29. print(f.__dict__)
  31. f.__dict__['a'] = 10 # 直接调用字典赋值并不会触发setattr方法
  32. del f.a
  33. print(f.__dict__)
  36. 执行结果：
  37. ----->setattr 因为初始化触发了__setattr__方法执行
  38. {'y': 6}
  39. ------->getattr 属性Z不存在，触发了getattr方法，所以找不到属性才触发
  40. z不存在
  41. ----->setattr
  42. {'y': 6, 'z': 2}
  43. -------delete
  44. {'y': 6, 'z': 2}

item系列

　　__setitem__,__getitem__,__delitem__ 在功能上和上边的有些类似，但是又稍有不同。item系列的特点是把类操作弄得像字典一样。


  1. class Foo:
  2. def __init__(self, name):
  3. self.name = name
  5. def __setitem__(self, key, value):
  6. print('from setitem')
  7. self.__dict__[key]=value
  9. def __getitem__(self, item):
  10. print('from getitem')
  11. print(self.__dict__.get(item))
  13. def __delitem__(self, key):
  14. print('from delitem del 类[key]')
  15. self.__dict__.pop(key)
  17. def __delattr__(self, item):
  18. print('from delattr del 类.属性')
  19. self.__dict__.pop(item)
  22. f1=Foo('李四')
  23. print(f1.__dict__)
  24. f1['age']=18
  25. f1['sex']='男'
  26. print(f1.__dict__)
  27. del f1.age
  28. del f1['sex']
  29. f1['home']='滨州'
  30. print(f1.__dict__)
  32. # {'name': '李四'}
  33. # from setitem
  34. # from setitem
  35. # {'name': '李四', 'age': 18, 'sex': '男'}
  36. # from delattr
  37. # from delitem
  38. # from setitem
  39. # {'name': '李四', 'home': '滨州'}

为类设置输出 __str__,__repr__,__format__

　　改变对象的字符串显示__str__,__repr__

　　自定制格式化字符串__format__

  1. format_dict={
  2. 'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
  3. 'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
  4. 'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
  5. }
  6. class School:
  7. def __init__(self,name,addr,type):
  8. self.name=name
  9. self.addr=addr
  10. self.type=type
  12. def __repr__(self):
  13. return 'School(%s,%s)' %(self.name,self.addr)
  14. def __str__(self):
  15. return '(%s,%s)' %(self.name,self.addr)
  17. def __format__(self, format_spec):
  18. # if format_spec
  19. if not format_spec or format_spec not in format_dict:
  20. format_spec='nat'
  21. fmt=format_dict[format_spec]
  22. return fmt.format(obj=self)
  24. s1=School('oldboy1','北京','私立')
  25. print('from repr: ',repr(s1))
  26. print('from str: ',str(s1))
  27. print(s1)
  29. # from repr: School(oldboy1,北京)
  30. # from str: (oldboy1,北京)
  31. # (oldboy1,北京)
  32. '''
  33. str函数或者print函数--->obj.__str__()
  34. repr或者交互式解释器--->obj.__repr__()
  35. 如果__str__没有被定义,那么就会使用__repr__来代替输出
  36. 注意:这俩方法的返回值必须是字符串,否则抛出异常
  37. '''
  38. print(format(s1,'nat'))
  39. print(format(s1,'tna'))
  40. print(format(s1,'tan'))
  41. print(format(s1,'a'))
  43. # oldboy1-北京-私立
  44. # 私立:oldboy1:北京
  45. # 私立/北京/oldboy1
  46. # oldboy1-北京-私立

 

　　当然也可以在__str__()中调用format方法，以显示想要的效果 

 析构方法  __del__

　　析构方法，当对象在内存中被释放时，自动触发执行。

　　注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，这就用到了__del__。简而言之，操作系统资源要通过代码手动调用管理的，用完就关闭它，用del方式可以防止忘记关闭操作系统资源而出错，也使代码简洁。

  1. class Foo:
  3. def __del__(self):
  4. print('回收')
  6. f1=Foo()
  7. del f1
  8. print('------->')
  10. #输出结果
  11. # 回收
  12. # ------->

 

描述符（__get__, __set__, __delete__）

描述符

本质就是一个新式类，在这个类中至少实现了__get__, __set__, __delete__中的一个，这也被称为描述符协议。

　　__get__()：调用一个属性时触发

　　__set__()：为一个属性赋值时触发

　　__delete__()：采用del删除一个属性时触发

作用

描述符的作用是用来代理另外一个类的属性的(必须把描述符定义成这个类的类属性，不能定义到构造函数中)

  1. class Foo:
  2. def __get__(self, instance, owner):
  3. print('触发get')
  4. def __set__(self, instance, value):
  5. print('触发set')
  6. def __delete__(self, instance):
  7. print('触发delete')
  10. f1=Foo()
  11. f1.name='egon'
  12. f1.name
  13. del f1.name

 

　　但是，这样子并没有触发三个方法的执行

　　那如何才会触发执行呢？

  1. #描述符Str
  2. class Str:
  3. def __get__(self, instance, owner):
  4. print('Str调用')
  5. def __set__(self, instance, value):
  6. print('Str设置...')
  7. def __delete__(self, instance):
  8. print('Str删除...')
  10. #描述符Int
  11. class Int:
  12. def __get__(self, instance, owner):
  13. print('Int调用')
  14. def __set__(self, instance, value):
  15. print('Int设置...')
  16. def __delete__(self, instance):
  17. print('Int删除...')
  19. class People:
  20. name=Str()
  21. age=Int()
  22. def __init__(self,name,age): #name被Str类代理,age被Int类代理,
  23. self.name=name
  24. self.age=age
  26. #何地？：定义成另外一个类的类属性
  28. #何时？：且看下列演示
  30. p1=People('alex',18)
  32. #描述符Str的使用
  33. p1.name
  34. p1.name='egon'
  35. del p1.name
  37. #描述符Int的使用
  38. p1.age
  39. p1.age=18
  40. del p1.age
  42. #我们来瞅瞅到底发生了什么
  43. print(p1.__dict__)
  44. print(People.__dict__)
  46. #补充
  47. print(type(p1) == People) #type(obj)其实是查看obj是由哪个类实例化来的
  48. print(type(p1).__dict__ == People.__dict__)
  51. 执行结果：
  53. Str设置...
  54. Int设置...
  55. Str调用
  56. Str设置...
  57. Str删除...
  58. Int调用
  59. Int设置...
  60. Int删除...
  61. {}
  62. {'__module__': '__main__', 'name': <__main__.Str object at 0x0000000A51974438>, 'age': <__main__.Int object at 0x0000000A51ACFC18>, '__init__': <function People.__init__ at 0x0000000A51AD3BF8>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}
  63. True
  64. True

 

注意事项

　　一 描述符本身应该定义成新式类,被代理的类也应该是新式类
　　二 必须把描述符定义成这个类的类属性，不能为定义到构造函数中
　　三 要严格遵循该优先级,优先级由高到底分别是
           1.类属性
           2.数据描述符
           3.实例属性
           4.非数据描述符
           5.找不到的属性触发__getattr__()

  

相关推荐