Python中的可变对象与不可变对象;Python中的六大标准数据类型哪些属于可变对象,哪些属于不可变对象

Python中的可变对象与不可变对象;Python中的六大标准数据类型哪些属于可变对象,哪些属于不可变对象

Python中的可变对象与不可变对象

在Python中,数据类型分为可变对象和不可变对象,它们在内存中的表现方式有所不同,特别是在进行数据修改时,是否会影响对象的内存地址。本文将通过Python中的六大标准数据类型(数字、字符串、列表、元组、集合、字典)来分析哪些属于可变对象,哪些属于不可变对象。

一、Python的六大标准数据类型

Python中有六大标准数据类型:

  • 数字 (Number) : int, float, bool, complex
  • 字符串 (String) : str
  • 列表 (List) : list
  • 元组 (Tuple) : tuple
  • 集合 (Set) : set
  • 字典 (Dictionary) : dict

1. 数字类型 (Number)

数字类型包括整数 int、浮点数 float、布尔值 bool 和复数 complex。这些类型的对象是不可变的。

2. 字符串 (String)

字符串类型 (str) 是不可变对象。这意味着字符串对象的内容一旦创建就不能改变。

3. 列表 (List)

列表类型 (list) 是可变对象。对列表的任何修改都会直接影响到原始列表对象。

4. 元组 (Tuple)

元组类型 (tuple) 是不可变对象。尽管元组本身是一个容器,它不能修改,但它可以包含可变类型的元素。

5. 集合 (Set)

集合类型 (set) 是可变对象。你可以在原有集合中添加或删除元素。

6. 字典 (Dictionary)

字典类型 (dict) 也是可变对象。你可以直接修改字典中的键值对。

二、可变对象与不可变对象的内存地址变化

1. 不可变对象的内存地址

不可变对象的内存地址在修改时会发生变化,每次修改都会创建新的对象,原始对象的内存地址保持不变。在实际应用中,尽量使用不可变对象。如tuple,是不可变对象,代码会安全。

2. 可变对象的内存地址

可变对象的内存地址不会改变,对对象内容的修改会直接影响原始对象。多个引用会指向同一个内存地址。

3. 示例代码

python 复制代码
# 1. 数字类型(不可变)
a = 10
b = a
print("数字类型示例:")
print(f"初始值: a = {a}, b = {b}")
print(f"初始地址: id(a) = {id(a)}, id(b) = {id(b)}")  # 初始时a和b地址相同

# 对不可变对象进行变更操作
a += 5  # 改变a的值
print(f"\n修改后的值: a = {a}, b = {b}")
print(f"修改后的地址: id(a) = {id(a)}, id(b) = {id(b)}")  # a的地址发生变化,b的地址不变

# 2. 字符串类型(不可变)
s1 = "hello"
s2 = s1
print("\n字符串类型示例:")
print(f"初始值: s1 = {s1}, s2 = {s2}")
print(f"初始地址: id(s1) = {id(s1)}, id(s2) = {id(s2)}")  # 初始时s1和s2地址相同

# 对不可变对象进行变更操作
s1 = "world"  # 重新赋值
print(f"\n修改后的值: s1 = {s1}, s2 = {s2}")
print(f"修改后的地址: id(s1) = {id(s1)}, id(s2) = {id(s2)}")  # s1的地址发生变化,s2的地址不变

# 3. 列表类型(可变)
lst1 = [1, 2, 3]
lst2 = lst1
print("\n列表类型示例:")
print(f"初始值: lst1 = {lst1}, lst2 = {lst2}")
print(f"初始地址: id(lst1) = {id(lst1)}, id(lst2) = {id(lst2)}")  # 初始时lst1和lst2地址相同

# 对可变对象进行变更操作
lst1.append(4)  # 直接修改列表
print(f"\n修改后的值: lst1 = {lst1}, lst2 = {lst2}")
print(f"修改后的地址: id(lst1) = {id(lst1)}, id(lst2) = {id(lst2)}")  # 地址不变,因为它们共享同一个对象

# 4. 元组类型(不可变)
t1 = (1, 2, 3)
t2 = t1
print("\n元组类型示例:")
print(f"初始值: t1 = {t1}, t2 = {t2}")
print(f"初始地址: id(t1) = {id(t1)}, id(t2) = {id(t2)}")  # 初始时t1和t2地址相同

# 对不可变对象进行变更操作
t1 = (4, 5, 6)  # 重新赋值
print(f"\n修改后的值: t1 = {t1}, t2 = {t2}")
print(f"修改后的地址: id(t1) = {id(t1)}, id(t2) = {id(t2)}")  # t1的地址发生变化,t2的地址不变

# 5. 集合类型(可变)
s1 = {1, 2, 3}
s2 = s1
print("\n集合类型示例:")
print(f"初始值: s1 = {s1}, s2 = {s2}")
print(f"初始地址: id(s1) = {id(s1)}, id(s2) = {id(s2)}")  # 初始时s1和s2地址相同

# 对可变对象进行变更操作
s1.add(4)  # 修改集合
print(f"\n修改后的值: s1 = {s1}, s2 = {s2}")
print(f"修改后的地址: id(s1) = {id(s1)}, id(s2) = {id(s2)}")  # 地址不变,因为它们共享同一个集合对象

# 6. 字典类型(可变)
d1 = {"a": 1, "b": 2}
d2 = d1
print("\n字典类型示例:")
print(f"初始值: d1 = {d1}, d2 = {d2}")
print(f"初始地址: id(d1) = {id(d1)}, id(d2) = {id(d2)}")  # 初始时d1和d2地址相同

# 对可变对象进行变更操作
d1["c"] = 3  # 修改字典
print(f"\n修改后的值: d1 = {d1}, d2 = {d2}")
print(f"修改后的地址: id(d1) = {id(d1)}, id(d2) = {id(d2)}")  # 地址不变,因为它们共享同一个字典对象

输出示例:

bash 复制代码
数字类型示例:
初始值: a = 10, b = 10
初始地址: id(a) = 140732924626120, id(b) = 140732924626120

修改后的值: a = 15, b = 10
修改后的地址: id(a) = 140732924626280, id(b) = 140732924626120

字符串类型示例:
初始值: s1 = hello, s2 = hello
初始地址: id(s1) = 1593406727024, id(s2) = 1593406727024

修改后的值: s1 = world, s2 = hello
修改后的地址: id(s1) = 1593406727984, id(s2) = 1593406727024

列表类型示例:
初始值: lst1 = [1, 2, 3], lst2 = [1, 2, 3]
初始地址: id(lst1) = 1593403419712, id(lst2) = 1593403419712

修改后的值: lst1 = [1, 2, 3, 4], lst2 = [1, 2, 3, 4]
修改后的地址: id(lst1) = 1593403419712, id(lst2) = 1593403419712

元组类型示例:
初始值: t1 = (1, 2, 3), t2 = (1, 2, 3)
初始地址: id(t1) = 1593406881728, id(t2) = 1593406881728

修改后的值: t1 = (4, 5, 6), t2 = (1, 2, 3)
修改后的地址: id(t1) = 1593406305152, id(t2) = 1593406881728

集合类型示例:
初始值: s1 = {1, 2, 3}, s2 = {1, 2, 3}
初始地址: id(s1) = 1593404393728, id(s2) = 1593404393728

修改后的值: s1 = {1, 2, 3, 4}, s2 = {1, 2, 3, 4}
修改后的地址: id(s1) = 1593404393728, id(s2) = 1593404393728

字典类型示例:
初始值: d1 = {'a': 1, 'b': 2}, d2 = {'a': 1, 'b': 2}
初始地址: id(d1) = 1593404749504, id(d2) = 1593404749504

修改后的值: d1 = {'a': 1, 'b': 2, 'c': 3}, d2 = {'a': 1, 'b': 2, 'c': 3}
修改后的地址: id(d1) = 1593404749504, id(d2) = 1593404749504

三、总结

  • 不可变对象 : 数字类型(intfloatboolcomplex)、字符串 (str)、元组 (tuple)
  • 可变对象 : 列表 (list)、集合 (set)、字典 (dict)

理解可变与不可变对象的区别对编写高效且没有bug的代码非常重要。在开发过程中,使用不可变对象可以避免意外修改数据,而使用可变对象则能够有效管理数据的动态变化。

希望本文对你理解Python中的对象变更和内存管理有所帮助。如果你有任何问题或补充,欢迎在评论区留言。

相关推荐
麻雀无能为力7 分钟前
python自学笔记14 NumPy 线性代数
笔记·python·numpy
大学生毕业题目41 分钟前
毕业项目推荐:28-基于yolov8/yolov5/yolo11的电塔危险物品检测识别系统(Python+卷积神经网络)
人工智能·python·yolo·cnn·pyqt·电塔·危险物品
##学无止境##1 小时前
解锁Java分布式魔法:CAP与BASE的奇幻冒险
java·开发语言·分布式
做一位快乐的码农2 小时前
基于Spring Boot的旅行足迹分享社区的设计与实现/基于java的在线论坛系统
java·开发语言·spring boot
程序猿小D3 小时前
【完整源码+数据集+部署教程】脑部CT图像分割系统源码和数据集:改进yolo11-CSwinTransformer
python·yolo·计算机视觉·数据集·yolo11·脑部ct图像分割
max5006003 小时前
北京大学MuMo多模态肿瘤分类模型复现与迁移学习
人工智能·python·机器学习·分类·数据挖掘·迁移学习
修一呀3 小时前
[后端快速搭建]基于 Django+DeepSeek API 快速搭建智能问答后端
后端·python·django
WSSWWWSSW3 小时前
Seaborn数据可视化实战:Seaborn数据可视化实战入门
python·信息可视化·数据挖掘·数据分析·matplotlib·seaborn
小石4 小时前
Python 装饰器核心知识点:无参装饰器构建、带参装饰器扩展及函数与类实现差异
python
巴厘猫4 小时前
从 Manim 中提取表格 / 坐标系并转 GIF:实用方案与核心代码
python·音视频开发