• 售前

  • 售后

热门帖子
入门百科

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

[复制链接]
我是的十八簿 显示全部楼层 发表于 2021-8-13 21:59:18 |阅读模式 打印 上一主题 下一主题
目次


  • 前置知识
  • 有哪些可变对象,哪些不可变对象?
  • 不可变对象和可变对象的区别?

    • 不可变对象的应用场景

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

    • 不可变对象
    • 可变对象

  • 从代码角度看看区别

    • 不可变对象-整型
    • 不可变对象-字符串
    • 不可变对象-元组
    • 可变对象列表

  • Python 函数的参数通报

    • 概念
    • 参数通报不可变对象
    • 参数通报可变对象

  • 总结

前置知识


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

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


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

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


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

不可变对象的应用场景


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

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



不可变对象


Python 中的变量有一个内存空间
具体的数据(对象)也有一个内存空间
而变量生存(指向)的是存储数据(对象)的内存地址,一样寻常也叫对象引用
不可变对象是指对象内容本身不可变
变的是:改变了值,会创建新对象,然后变量改变了对象引用,指向了新对象,旧对象会被垃圾回收

可变对象


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

从代码角度看看区别



不可变对象-整型

  1. a = 123
  2. b = a
  3. print(id(a))
  4. print(id(b))
  5. print(a, b)
  6. a += 2
  7. print(id(a))
  8. print(id(b))
  9. print(a, b)
  10. # 输出结果
  11. 4473956912
  12. 4473956912
  13. 123 123
  14. 4473956976
  15. 4473956912
  16. 125 123
复制代码
从前两次打印可以看到,a、b 变量生存的内存地址是同一个,他们们都生存了 123 的内存地址(123 对象的引用)
预期环境:在 a 做了加法赋值运算之后,既然他们一开始都是指向同一个内存地址,按原理修改 123 后,他们也应该仍旧指向同一个内存地址呀,但是并没有!
实际环境:a 指向了新的内存地址,而 b 仍旧指向旧的内存地址,所以他们的值也不一样
可以看看下面的图
起首,这是一个内存地区

原理
由于数字(int、float) 是不可变对象,所以不能在 123 的内存地址上直接修改数据
加法赋值,实际上是将原来的 123 复制了一份到新的内存地址,然后再做加法,得到一个新的值 125,最后 a 再指向新的内存地址

不可变对象-字符串

  1. a = "test"
  2. b = a
  3. print(id(a))
  4. print(id(b))
  5. print(a, b)
  6. a += "123"
  7. print(id(a))
  8. print(id(b))
  9. print(a, b)
  10. # 输出结果
  11. 4455345392
  12. 4455345392
  13. test test
  14. 4455818288
  15. 4455345392
  16. test123 test
复制代码
不可变对象-元组

  1. a = (1, 2, 3)
  2. b = a
  3. print(id(a))
  4. print(id(b))
  5. print(a, b)
  6. a = a + a
  7. print(id(a))
  8. print(id(b))
  9. print(a, b)
  10. # 输出结果
  11. 4455410240
  12. 4455410240
  13. (1, 2, 3) (1, 2, 3)
  14. 4455359200
  15. 4455410240
  16. (1, 2, 3, 1, 2, 3) (1, 2, 3)
复制代码
可变对象列表

  1. # 列表
  2. a = [1, 2, 3]
  3. b = a
  4. print(id(a))
  5. print(id(b))
  6. print(a, b)
  7. a += [4, 5, 6]
  8. print(a, b)
  9. print(id(a))
  10. print(id(b))
  11. # 输出结果
  12. 4327665856
  13. 4327665856
  14. [1, 2, 3, 4, 5, 6] [1, 2, 3, 4, 5, 6]
  15. 4327665856
  16. 4327665856
复制代码
能看到 a 变量修改值之后,b 的值也随之修改了
可以看看下面的图

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

Python 函数的参数通报


这里先提前讲下函数的入门,由于参数通报是个挺重要的点

概念


开头有讲到,Python 的一切通报都是对象的引用,函数参数通报也不例外
当通报给函数的是一个变量,实际上通报的是变量生存的对象引用(变量指向的内存地址)
在函数内部修改变量时,会根据变量指向的内存地址,去修改对应的值才对,究竟真是云云吗

参数通报不可变对象

  1. # 函数
  2. def test_no_define(age, name):
  3.     age = 123
  4.     name = "poloyy"
  5.     print(age, name)
  6. age = 1
  7. name = "yy"
  8. print(age, name)
  9. test_no_define(age, name)
  10. print(age, name)
  11. # 输出结果
  12. 1 yy
  13. 123 poloyy
  14. 1 yy
复制代码
参数通报可变对象
  1. # 函数
  2. def test_define(dicts, sets):
  3.     dicts['age'] = 24
  4.     sets.pop()
  5.     print(dicts, sets)
  6. dicts = {"age": 123}
  7. sets = {1, 2}
  8. print(dicts, sets)
  9. test_define(dicts, sets)
  10. print(dicts, sets)
  11. # 输出结果
  12. 1 yy
  13. {'age': 123} {1, 2}
  14. {'age': 24} {2}
  15. {'age': 24} {2}
复制代码
总结


当函数参数通报的变量是不可变对象的时间,函数内改变变量值,函数外的变量不会随之改变
当函数参数通报的变量是可变对象的时间,函数内改变变量值,函数外的变量会随之改变
到此这篇关于Python中可变和不可变对象的文章就介绍到这了,更多相关Python可变和不可变对象内容请搜刮脚本之家以前的文章或继续浏览下面的相关文章盼望各人以后多多支持脚本之家!

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?立即注册

x

帖子地址: 

回复

使用道具 举报

分享
推广
火星云矿 | 预约S19Pro,享500抵1000!
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

草根技术分享(草根吧)是全球知名中文IT技术交流平台,创建于2021年,包含原创博客、精品问答、职业培训、技术社区、资源下载等产品服务,提供原创、优质、完整内容的专业IT技术开发社区。
  • 官方手机版

  • 微信公众号

  • 商务合作