当前位置 博文首页 > Python中可变和不可变对象的深入讲解

    Python中可变和不可变对象的深入讲解

    作者:小菠萝测试笔记 时间:2021-08-03 17:45

    目录
    • 前置知识
    • 有哪些可变对象,哪些不可变对象?
    • 不可变对象和可变对象的区别?
      • 不可变对象的应用场景
    • 从内存角度出发说下有什么区别?
      • 不可变对象
      • 可变对象
    • 从代码角度看看区别
      • 不可变对象-整型
      • 不可变对象-字符串
      • 不可变对象-元组
      • 可变对象列表
    • Python 函数的参数传递
      • 概念
      • 参数传递不可变对象
      • 参数传递可变对象
    • 总结

      前置知识

      在 Python 中,一切皆为对象

      Python 中不存在值传递,一切传递的都是对象的引用,也可以认为是传址 

      有哪些可变对象,哪些不可变对象?

      不可变对象:字符串、元组、数字(int、float)

      可变对象:数组、字典、集合 

      不可变对象和可变对象的区别?

      可变对象:改变对象内容,对象在内存中的地址不会被改变

      不可变对象:改变对象内容,对象在内存中的地址会被改变;如果必须存储一个不同的值,则必须创建新的对象 

      不可变对象的应用场景

      它们在需要常量哈希值的地方起着重要作用,例如作为字典中的键

      从内存角度出发说下有什么区别?

      不可变对象

      Python 中的变量有一个内存空间

      具体的数据(对象)也有一个内存空间

      而变量保存(指向)的是存储数据(对象)的内存地址,一般也叫对象引用

      不可变对象是指对象内容本身不可变

      变的是:改变了值,会创建新对象,然后变量改变了对象引用,指向了新对象,旧对象会被垃圾回收

      可变对象

      变的是:原来对象的内容,不会创建新对象,而变量也还是指向原对象

      从代码角度看看区别

      不可变对象-整型

      a = 123
      b = a
      print(id(a))
      print(id(b))
      print(a, b)
      
      a += 2
      
      print(id(a))
      print(id(b))
      print(a, b)
      
      
      # 输出结果
      4473956912
      4473956912
      123 123
      4473956976
      4473956912
      125 123
      
      

      从前两次打印可以看到,a、b 变量保存的内存地址是同一个,他们们都保存了 123 的内存地址(123 对象的引用)

      预期情况:在 a 做了加法赋值运算之后,既然他们一开始都是指向同一个内存地址,按道理修改 123 后,他们也应该仍然指向同一个内存地址呀,但是并没有!

      实际情况:a 指向了新的内存地址,而 b 仍然指向旧的内存地址,所以他们的值也不一样 

      可以看看下面的图

      首先,这是一个内存区域

      原理

      因为数字(int、float) 是不可变对象,所以不能在 123 的内存地址上直接修改数据

      加法赋值,实际上是将原来的 123 复制了一份到新的内存地址,然后再做加法,得到一个新的值 125,最后 a 再指向新的内存地址

      不可变对象-字符串

      a = "test"
      b = a
      print(id(a))
      print(id(b))
      print(a, b)
      
      a += "123"
      
      print(id(a))
      print(id(b))
      print(a, b)
      
      
      # 输出结果
      4455345392
      4455345392
      test test
      4455818288
      4455345392
      test123 test
      
      

      不可变对象-元组

      a = (1, 2, 3)
      b = a
      print(id(a))
      print(id(b))
      print(a, b)
      
      a = a + a
      print(id(a))
      print(id(b))
      print(a, b)
      
      
      # 输出结果
      4455410240
      4455410240
      (1, 2, 3) (1, 2, 3)
      4455359200
      4455410240
      (1, 2, 3, 1, 2, 3) (1, 2, 3)
      
      

      可变对象列表

      # 列表
      a = [1, 2, 3]
      b = a
      
      print(id(a))
      print(id(b))
      print(a, b)
      
      a += [4, 5, 6]
      
      print(a, b)
      print(id(a))
      print(id(b))
      
      
      # 输出结果
      4327665856
      4327665856
      [1, 2, 3, 4, 5, 6] [1, 2, 3, 4, 5, 6]
      4327665856
      4327665856
      
      

      能看到 a 变量修改值之后,b 的值也随之修改了

      可以看看下面的图

       

      因为 list 是不可变对象,所以并不会将原来的值复制到新的内存地址再改变,而是直接在原来的内存地址上修改数据
      因为 a、b 都是指向原来的内存地址的,所以 a、b 变量保存的内存地址是一致的(对象引用是一致的),当然值也是一样的啦 

      Python 函数的参数传递

      这里先提前讲下函数的入门,因为参数传递是个挺重要的点

      概念

      开头有讲到,Python 的一切传递都是对象的引用,函数参数传递也不例外

      当传递给函数的是一个变量,实际上传递的是变量保存的对象引用(变量指向的内存地址)

      在函数内部修改变量时,会根据变量指向的内存地址,去修改对应的值才对,事实真是如此吗

      参数传递不可变对象

      # 函数
      def test_no_define(age, name):
          age = 123
          name = "poloyy"
          print(age, name)
      
      
      age = 1
      name = "yy"
      print(age, name)
      
      test_no_define(age, name)
      print(age, name)
      
      
      # 输出结果
      1 yy
      123 poloyy
      1 yy
      
      

      参数传递可变对象

      # 函数
      def test_define(dicts, sets):
          dicts['age'] = 24
          sets.pop()
          print(dicts, sets)
      
      
      dicts = {"age": 123}
      sets = {1, 2}
      print(dicts, sets)
      
      test_define(dicts, sets)
      print(dicts, sets)
      
      
      # 输出结果
      1 yy
      {'age': 123} {1, 2}
      {'age': 24} {2}
      {'age': 24} {2}
      
      

      总结

      当函数参数传递的变量是不可变对象的时候,函数内改变变量值,函数外的变量不会随之改变

      当函数参数传递的变量是可变对象的时候,函数内改变变量值,函数外的变量会随之改变

      jsjbwy