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中的对象变更和内存管理有所帮助。如果你有任何问题或补充,欢迎在评论区留言。

相关推荐
内网渗透10 分钟前
Python 虚拟环境管理:venv 与 conda 的选择与配置
开发语言·python·conda·虚拟环境·venv
薄荷很无奈18 分钟前
CuML + Cudf (RAPIDS) 加速python数据分析脚本
python·机器学习·数据分析·gpu算力
yivifu24 分钟前
pyqt中以鼠标所在位置为锚点缩放图片
python·pyqt·以鼠标为锚点缩放图片
正在走向自律35 分钟前
AI数字人:繁荣背后的伦理困境与法律迷局(8/10)
人工智能·python·opencv·语音识别·ai数字人·ai伦理与法律
灏瀚星空1 小时前
Python在AI虚拟教学视频开发中的核心技术与前景展望
人工智能·python·音视频
一个天蝎座 白勺 程序猿1 小时前
Python爬虫(4)CSS核心机制:全面解析选择器分类、用法与实战应用
css·爬虫·python
进来有惊喜1 小时前
深度学习:迁移学习
python·深度学习
每次的天空1 小时前
kotlin与MVVM结合使用总结(三)
开发语言·microsoft·kotlin
keep intensify1 小时前
通讯录完善版本(详细讲解+源码)
c语言·开发语言·数据结构·算法
ephemerals__1 小时前
【c++11】c++11新特性(下)(可变参数模板、default和delete、容器新设定、包装器)
开发语言·c++