python -面向对象-设计模式-属性函数

    Python编程 wuya 61次浏览 已收录 0个评论

    设计模式

    • 说明:针对特定场景问题的特定解决方案
    • 单例模式:无论创建多少次对象,得到的始终都是同一个
    • 示例:
      class Person:
          def __new__(cls, *args, **kwargs):
              if not hasattr(cls, '_instance'):
                  print('执行创建对象操作')
                  cls._instance = object.__new__(cls)
              return cls._instance
          
      p1 = Person()
      p2 = Person()
      
      print(id(p1))
      print(id(p2))
      
      # 判断是否是同一对象
      print(p1 is p2)   

      面向对象

    • 说明:将成员方法当做属性一样访问
    • 作用:干预指定属性的操作(获取、设置)
    • 示例:
      class User:
          def __init__(self, username, password):
              self.username = username
              self.password = password
      
          # 获取器:获取指定属性时自动调用
          @property
          def password(self):
              return '你想干嘛'
      
          # 设置器:设置指定属性时自动调用
          @password.setter
          def password(self, password):
              print('设置新密码', password)
              self.__dict__['password'] = 'xxxx' + password + 'yyyy'
             
      u = User('xiaoming', '123456')
      
      print(u.password)
      # u.password = 'abcdef'
      print(u.__dict__)

    内存管理

    • 概念:保证无用的对象得到合理及时的释放
    • 引用计数:

      当创建一个对象赋值给一个变量时,将引用计数记为1;当多一个变量指向该对象,计数值加1,当少一个变量指向该对象,计数值减1。减到0时释放该对象,顺便调用对象的__del__方法。

    • 说明:引用计数针对的是可变变量及自定义对象,不可变变量的引用计数是没有意义的。
    • 示例:
      a = 100
      b = 100
      
      print(id(a))
      print(id(b))
      
      from sys import getrefcount
      
      # 不可变变量的引用计数没有意义
      print(getrefcount(a))
      
      lt = [1, 2, 3]
      # 多一个变量指向该对象,引用计数加1
      lt2 = lt
      # 该函数本身会对操作对象的引用计数加1
      print(getrefcount(lt))
      
      # 少一个变量指向该对象,引用计数减1
      del lt2
      print(getrefcount(lt))
      
      class Person:
          def __del__(self):
              print('对象即将释放')
       
      p = Person()
      print(getrefcount(p))
      
      del p
      print('OVER')        
    • 函数传参
      def test(n):
          n += 1
      
      num = 100
      
      # test(num)
      # 传递的是值,与num无关
      
      test(100)
      print(num)
      
      def demo(lt):
          lt[0] = 100
          print('in demo func', id(lt))
          
      x = [1, 2, 3]
      print('global', id(x))
      
      # 多一个引用,可以在函数中修改对象
      # 传递的是引用
      demo(x)
      print(x)
    • 深浅拷贝
      lt = [1, 2, 3]
      
      # 此处不是拷贝数据,只是多了一个引用而已
      lt2 = lt
      
      lt2[0] = 100
      print(lt)
      
      import copy
      
      l = [1, 2, [3, 4]]
      # 浅拷贝:拷贝当前对象,其中的数据引用计数加1
      # l2 = l.copy()
      # l2 = copy.copy(l)
      # 深拷贝:拷贝当前对象,里面的元素也进行拷贝
      l2 = copy.deepcopy(l)
      
      print(l is l2)
      l2[0] = 100
      l2[2][0] = 300
      print(l)
      
      class Person:
          # 浅拷贝时自动触发
          def __copy__(self):
              print('执行浅拷贝')
              # 返回值就是浅拷贝的结果
              return 'xxx'
      
          # 深拷贝时自动触发
          def __deepcopy__(self, memodict={}):
              print('执行深拷贝')
              return 'yyy'
          
      p = Person()
      
      # p2 = copy.copy(p)
      p2 = copy.deepcopy(p)
      
      print(p2)
      print(p is p2)

    学海无涯 , 版权所有丨如未注明 , 均为原创丨转载请注明python -面向对象-设计模式-属性函数
    喜欢 (0)
    发表我的评论
    取消评论
    表情 加粗 删除线 居中 斜体 签到

    Hi,您需要填写昵称和邮箱!

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址