深入学习和对比Python 列表与元组

• 列表用方括号 []，元组用圆括号 ()。
• 单元素元组需加逗号：(1,)，否则会被识别为普通括号表达式。

a = [1]       # 单元素列表
aa = [1,2,3,4] #多元素列表
l = [1, 2, 'hello', 'world'] # 列表中同时含有 int 和 string 类型的元素b = (1)       # 整数 1，不是元组
c = (1,)      # 单元素元组
cc = (1,2,3)  # 多元素元组
tup = ('jason', 22) # 元组中同时含有 int 和 string 类型的元素

2、相同的索引支持

l = [1, 2, 3, 4]
print(l[-1])
## 输出4
tup = (1, 2, 3, 4)
print(tup[-1])
## 输出4

l = [1, 2, 3, 4]
l[1:3] # 返回列表中索引从 1 到 2 的子列表
## 输出结果[2, 3]tup = (1, 2, 3, 4)
tup[1:3] # 返回元组中索引从 1 到 2 的子元组
## 输出结果(2, 3)

l = [[1, 2, 3], [4, 5]] # 列表的每一个元素也是一个列表
tup = ((1, 2, 3), (4, 5, 6)) # 元组的每一个元素也是一元组

# 元组转列表
list((1, 2, 3))
## 结果：列表结构 [1, 2, 3]# 列表转元组
tuple([1, 2, 3])
## 结果：元组结构 (1, 2, 3)

6、支持的方法丰富性不同

• 列表方法丰富：
  • list.append() ： 直接在列表末尾添加一个元素，无返回值。
  • list.extend()：将可迭代对象（如列表、元组、字符串）中的元素逐个添加到列表末尾，直接修改原列表，无返回值。
  • list.insert()：在指定索引位置插入元素，原元素后移。直接修改原列表。
  • list.remove()：删除列表中第一个匹配的元素。若不存在则引发 ValueError。
  • list.pop()：删除并返回指定索引的元素（默认最后一个元素），若索引越界引发 IndexError。
  • list.sort() ： 原地对列表排序（默认升序），无返回值。
  • list.reverse() ：原地反转列表元素顺序，无返回值。

          注： 详细使用示例参考文章：Python 列表常用函数介绍

• 元组仅支持基本操作：
  • count() 和 index()（与列表相同），但无修改方法。
  • tup.count(item) 表示统计列表 / 元组中 item 出现的次数。
  • tup.index(item) 表示返回列表 / 元组中 item 第一次出现的索引。
• reversed() 和 sorted() 新列表或元组的倒转和排序。
  • reversed() 和 sorted() 同样表示对列表 / 元组进行倒转和排序，但是会返回一个倒转后
    或者排好序的新的列表 / 元组。

l = [3, 2, 3, 7, 8, 1]
print(l.count(3)) 
## 结果 2
print(l.index(7))
## 结果3 
l.reverse()
##结果 1 
print(l)
## 结果 [1, 8, 7, 3, 2, 3]
l.sort() ## 排序
print(l)
## 结果 [1, 2, 3, 3, 7, 8]tup = (3, 2, 3, 7, 8, 1)
tup.count(3)
## 结果2 
tup.index(7)
## 结果 3
list(reversed(tup))
## 结果 [1, 8, 7, 3, 2, 3]
sorted(tup)
## 结果 [1, 2, 3, 3, 7, 8]

二、核心特性：可变性不同

• 列表：可变；列表是动态的，长度大小不固定，可以随意地增加、删减或者改变元素（mutable）。
• 元组：不可变；元组是静态的，长度大小固定，无法增加删减或者改变（immutable）。

l = [1, 2, 3, 4]
l[3] = 40 # 和很多语言类似，python 中索引同样从 0 开始，l[3] 表示访问列表的第四个元素
print(l) 
[1, 2, 3, 40] #打印列表结果，最后一个元素的值改变tup = (1, 2, 3, 4)
tup[3] = 40  #修改元组元素值报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

三、不可变性的深层理解

1、通过开辟新内存，创建新元组实现元组可变。

tup = (1, 2, 3, 4)
new_tup = tup + (5, ) # 创建新的元组 new_tup，并依次填充原元组的值
print(new _tup)
## 输出结果 (1, 2, 3, 4, 5)l = [1, 2, 3, 4]
l.append(5) # 添加元素 5 到原列表的末尾
## 输出结果 [1, 2, 3, 4, 5]

2、若元组包含可变对象（如列表），这些对象仍可修改。

mixed_tuple = (1, [2, 3], "hello")
mixed_tuple[1].append(4)  # 合法，变为 (1, [2, 3, 4], "hello")

四、存储方式的差异：内存占用不同

• 元组是静态的，其内存分配更紧凑，占用更小（不可变性允许优化）。
• 列表是动态的，其会预留额外空间以适应动态增长，内存占用更大。

示例一：放置相同元素，列表占用存储空间明显多于元组

l = [1, 2, 3]
l.__sizeof__()
## 结果 64tup = (1, 2, 3)
tup.__sizeof__()
## 结果 48

分析：事实上，由于列表是动态的，所以它需要存储指针，来指向对应的元素（上述例子中，对于 int 型，8 字节）。另外，由于列表可变，所以需要额外存储已经分配的长度大小（8 字节），这样才可以实时追踪列表空间的使用情况，当空间不足时，及时分配额外空间。

示例二：

l = []
l.__sizeof__() // 空列表的存储空间为 40 字节
## 结果 40
l.append(1)
l.__sizeof__() 
## 结果 72 // 加入了元素 1 之后，列表为其分配了可以存储 4 个元素的空间 (72 - 40)/8 = 4
l.append(2) 
l.__sizeof__()
## 结果 72 // 由于之前分配了空间，所以加入元素 2，列表空间不变
l.append(3)
l.__sizeof__() 
## 结果 72 // 同上
l.append(4)
l.__sizeof__() 
## 结果 72 // 同上
l.append(5)
l.__sizeof__() 
## 结果 104 // 加入元素 5 之后，列表的空间不足，所以又额外分配了可以存储 4 个元素的空间

分析：python. 为了减小每次增加 / 删减操作时空间分配的开销，Python 每次分配空间时都会额外多分配一些，这样的机制 （over-allocating）保证了其操作的高效性：增加 / 删除的时间复杂度均为 O(1)。