元组的可变性

最新推荐文章于 2024-01-05 14:29:15 发布

原创最新推荐文章于 2024-01-05 14:29:15 发布 · 994 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#元组 #tuple #可变性

Python 专栏收录该内容

20 篇文章

订阅专栏

本文探讨了Python中元组的不可变性及其对包含的可变对象的影响。通过实例展示了即使元组不可变，其内部的列表等可变对象仍可被修改，从而间接改变了元组的内容。

虽然元组对象本身是不可变的，但这并不意味着元组包含的可变对象也不可变。

t=([‘xyz’,123],23,56)

print t

([‘xyz’,123],23,56)

t[0][1]=[‘xyz’,232]

print t

([‘xyz’,232],23,56)

在上面的例子中，虽然t是一个元组类型变量，但是我们设法通过改变他的第一个元素(列表对象)的项来‘改变’他，虽然我们只是改变了一个可变对象，但在某种意义上，我们也改变了元组对象。

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

Woody891

关注关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

你知道吗？——元组其实是可变的序列！

菜鸟的后花园

07-10

3709

你知道吗？——元组其实是可变的序列！大家可能都知道，列表和元组都是序列而它俩的区别就是列表是可变的序列，元组是不可变的序列即元组的内容是不可修改的，不允许更新元素、删除元素但是，你知道吗？其实，元组其实也是“可变”的就让我来介绍介绍元组怎么“可变” 举例：首先，初始化一个元组 >>>tuple1=('1','2','3',['a','b','c']) 再修改元素...

元组的相对不可变性

weixin_30237281的博客

05-22

197

元组与多数 Python 集合（列表、字典、集，等等）一样，保存的是对象的引用。如果引用的元素是可变的，即便元组本身不可变，元素依然可变。也就是说，元组的不可变性其实是指 tuple 数据结构的物理内容（即保存的引用）不可变，与引用的对象无关。 t1 = (1, 2, [30, 40]) t2 = (1, 2, [30, 40]) print(id(t1)) print(id(t...

参与评论您还未登录，请先登录后发表或查看评论

python“可变”的元组

sunflower_day的博客

12-09

367

实际上不是元组变了，而是list变了元组的指向是不变的

python列表的长度可变吗_Python：可变长度元组

weixin_39710041的博客

12-06

628

[Python 3.1]I'm following up on the design concept that tuples should be of known length (see this comment), and unknown length tuples should be replaced with lists in most circumstances. My question ...

可变长参数元组

ustbclearwang的博客

06-07

865

编写一个函数，接收任意个数的参数并返回它们的和。def fun(*args): sum1=0 for i in args: sum1=sum1+i return sum1以*开头的参数名会收集所有的参数到一个元组上。收集的反面是分散，如果有一个序列的值想将他们作为可变长参数传入到函数中，也可使用*操作符。t=(7,3)divmod(*t)...

序列类型之元组(可变与不可变）

best_of_times的博客

04-01

4238

元组(tuple)是序列类型中比较特殊的类型。元组一旦创建就不能被修改。常用情况：元组类型在表达固定数据项、函数多返回值、多变量同步赋值、循环遍历。 Python中元组采用逗号和圆括号（可选）来表示，其中，逗号 “ ， ”是必须的。 >>> type(creature) <class 'tuple'> >>> creature1 = ("c...

[Python入门及进阶笔记]Python-基础-元组小结

jishublog

03-09

182

Python笔记之元组的相对不可变性

Don_Sherry的博客

10-28

582

元组的相对不可变性 元组与多数Python集合（列表，字典，集，等待）一样，保存的是对象的引用。如果引用的元素是可变的，即元组本身不可变，元素依然可变。也就是说，元组的不可变性其实是指的是tuple数据结构的物理内容（即保存的引用）不可变，与引用的对象无关。如示例1表明，元组的值会随着引用的可变对象的变化而变。元组中不可变的是元素发标识。 #示例1 >>> t1 =...

元组不可变性（其实内部可变）

qq_46704213的博客

03-13

295

元组一级元素不可变，但是二级元素可变

元组也不是那么“不可变”

wmdwmd73的博客

12-13

2223

6.18.2 元组也不是那么“不可变” 虽然元组是被定义成不可变的，但这并不影响它的灵活性。元组并不像我们想的那么不可变，这是什么意思？其实元组几个特定的行为让它看起来并不像我们先前声称的那么不可变. 比如说，既然我们可以把字符串组合在一起形成一个大字符串。那么把元组组合在一起形成一个大的元组也没什么不对，所以，连接操作可用，这个操作一点都没有改变那些小元组。我们所作的是把它们的元素

元组不可变，你真的确定吗？有了列表，元组存在的意义又是什么？【一文搞懂】

曲鸟

08-25

1万+

一、前言好好学过几天python的小伙伴肯定知道，python有一种数据类型叫元组！它与列表很相似，元组用小括号表示(1,2),列表用方括号表示[1,2] 但元组与列表最重要的区别就在于元组一经定义就不能改变其内容！类似下面的代码执行的话会直接报错： a=(1,2) a[1]=3 print(a) 报错信息但元组中的内容真的是不可改变的吗？下面的这段代码可能会让你心生疑惑 a = (1, {'key': 1}) a[1]['key'] = 2 print(a) 输出结果：这结果不是

python知识点1--元组不可变性

weixin_30593443的博客

03-18

441

元组长度是不可变的，列表长度确实可变的，但是这样的代码呢？ mytuple = (1,2,[3,4,5]) mytuple[2] = mytuple[2]+[6,7,8] 结果肯定是不能运行的，因为元组地址空间是分配好的，不能该表，该表mytuple[2]，就会该表整个地址空间的长度，所以会报错。转载于:https://www.cnblogs.com/jilic...

python元组-不可变性

qq_26126831的博客

12-08

345

《 Learning python》 chap9 元组 20191208 元组是不可变数据类型 # 元组的不可变性只适用于元素本身顶层而并非其内容 t = (1,[2,3],4) t [1][0] = 'spam' print(t) 运行结果： (1, [‘spam’, 3], 4) 列表和元组的区别：元组的不可变性，确保了在程序中不会被另一个引用修改，类似于常数 ...

python数据类型之元组（不可变的数据类型）

bread_winner的博客

09-05

5027

元组是什么元组(tuple)是Python中一种内置的存储有序数据的结构。与列表类似，可以存储不同类型的数据。但是元组是不可以改变的，创建后不能再做任何的修改。元组的主要作用是作为参数传递给函数调用或者从函数调用那里获得参数时，保护其内容不被外部接口修改。因为元组是不可变的数据类型，因此元组没有增删改查元组的创建（1）空元组的创建——tup = () （2）当元组中只有一个数据时——tup...

Python元组（tuple）一种不可变的有序数据类型的使用

captain

01-05

1175

元组的元素可以是不同的数据类型，如整数、浮点数、字符串等，并使用逗号进行分隔。元组的原理是使用内存中的连续空间来存储元素，通过索引进行访问。这两种方式都可以实现遍历元组的功能，按照索引顺序逐个访问元组中的元素并进行操作。需要注意的是，元组的不可变性并不代表元组中的元素本身是不可变的，如果元组中的元素是可变对象（如列表），则可以修改可变对象的内容。元组是不可变的数据类型，所以没有可以直接修改元组的函数。修改元组中的元素是无法实现的，但可以通过元组拼接或切片生成新的元组来修改元组的内容。

Python 元组的相对不可变性

liguandong

04-18

1142

元组与多数的 Python 集合（列表，字典，集等）一样，保持的是对象的引用，如果引用的元素是可变的，即便元组本身不可变，元素依然可变。也就是说，元组的不可变性其实是指 tuple 数据结构的物理内容（即保存的引用）不可变，与引用的对象无关。元组中的值会随着引用的可变对象的变化而变，元组中不可变的是元素的标识。一开始，t1 和 t2 相等，但是修改 t1 中的一个可变元素之后，二者就不相...

第8章：对象引用、可变性和垃圾回收-对象引用概念、元组的相对不可变性

waitan2018的博客

07-30

208

8.1 变量不是盒子人们经常使用“变量是盒子”这样的比喻，但是这有碍于理解面对对象语言中的引用式变量，Python 变量类似于 Java 中的引用式变量，因此最好把变量理解为附加在对象上的标注，或者是贴在对象上的便利贴。示例 8-1 变量 a 和 b 引用同一个列表，而不是那个列表的副本 a = [1, 2, 3] b = a a.append(4) print(b) # [1, 2, 3, 4] 8.2 标识、相等性和别...

python元组的可变与不可变详解

最新发布

10-14

<think>我们之前讨论了元组是否可变的问题。根据引用[1]和引用[2]，元组在创建后是不可变的，即不能修改其中的元素。但是，引用[3]提到一个有趣的现象：元组不可变，但有时似乎可以“改变”。这实际上是因为元组中如果包含可变对象，那么可变对象的内容可以改变，但元组中存储的是对这些对象的引用，引用本身不变。因此，我们需要明确： 1. 元组本身不可变：不能添加、删除或替换元素。 2. 如果元组中的元素是可变对象（如列表），则这些可变对象的内容可以改变。我们来看引用[2]中的例子： ```python tupleA = (1, 2, 3, 4) # tupleA[0] = 0 # 这行会报错，因为元组不支持元素赋值 ``` 但是，如果元组中包含列表： ```python t = ([1, 2], 3, 4) t[0].append(3) # 这是允许的，因为t[0]是一个列表，列表可变 # 此时t变为([1,2,3], 3, 4) ``` 另外，引用[3]还提到了具名元组（namedtuple），它是元组的子类，具有字段名，但同样不可变。因此，回答用户的问题：元组本身是不可变的，但如果元组中包含可变对象，那么这些可变对象的内容可以改变。我们再整理一下： 1. 元组的不可变性是指元组的数据结构不可变，即元组中的每个元素的引用（地址）不可变。 2. 如果元组中的元素是可变对象，那么这些对象内部的变化不会改变元组中存储的引用值（地址），因此是允许的。下面我们来组织回答： </think>在Python中，元组（tuple）是**不可变的数据结构**，这意味着创建后其内容不能修改。以下是关键说明： ### 一、元组不可变的证据 1. **元素赋值禁止** 尝试修改元组元素会触发`TypeError`： ```python t = (1, 2, 3) t[0] = 10 # 报错: TypeError: 'tuple' object does not support item assignment [^2] ``` 2. **可变操作均无效** - 无法添加元素：`t.append(4)` ❌ - 无法删除元素：`del t[1]` ❌ - 无法排序：`t.sort()` ❌ 3. **内存地址不变性** 重新赋值会产生全新对象（内存地址改变），而非就地修改： ```python t1 = (1, 2) print(id(t1)) # 输出地址: 140246384265792 t1 = (3, 4) # 实际是创建新元组 print(id(t1)) # 新地址: 140246384267712 [^2] ``` ### 二、例外情况：包含可变元素时元组存储的是对象的**引用**。若元素本身可变（如列表），其内部可修改： ```python t = ([1, 2], "a") t[0][0] = 99 # 允许！修改列表元素 print(t) # 输出: ([99, 2], "a") ``` ⚠️ 此时元组自身未变（存储的列表引用地址未变），但列表内容改变了[^3]。 ### 三、元组存在的意义 | 特性 | 优势说明 | 应用场景 | |-------------|-----------------------------------|------------------------------| | 内存效率更高 | 比列表节省内存约40% | 大规模只读数据存储 | | 数据保护 | 防止意外修改 | 字典键值、函数参数传递[^1] | | 线程安全 | 天然支持并发读取 | 多线程环境共享数据 | | 哈希支持 | 可哈希特性使其能作为字典键 | 创建复杂键值对 | ### 四、操作元组的正确方式 1. **创建新元组代替修改** ```python t = (1, 2) new_t = t + (3,) # 创建新元组 (1, 2, 3) ``` 2. **利用具名元组增强可读性** ```python from collections import namedtuple Point = namedtuple("Point", ["x", "y"]) p = Point(11, y=22) print(p.x, p[0]) # 均可输出11 [^3] ``` 3. **遍历与查询（不改变元组）** ```python t = ('d', 'a', 't', 'a') # 遍历 for char in t: print(char) # 查询存在性 print('a' in t) # 输出True [^4] ``` > **总结**：元组的核心不可变性体现在其**结构不可修改**（长度、元素引用不变）。这种特性使其成为安全的数据容器，尤其适用于需要数据保护的场景[^1]。