【30天玩转python】列表与元组

列表与元组

在 Python 中，列表和元组都是常用的序列数据类型。它们可以存储多个值，但有一些关键区别，例如列表是可变的，而元组是不可变的。本节将详细介绍列表与元组的用法及其不同之处。

---

1. 列表

1.1 列表的定义

列表（list）是 Python 中的一种可变序列，可以存储任意类型的数据，列表中的元素可以随时修改。列表使用方括号 [] 表示。

my_list = [1, 2, 3, 4, 5]
print(my_list)

输出结果：

[1, 2, 3, 4, 5]

1.2 列表常用操作

1. 访问列表元素
   可以通过索引访问列表中的元素。索引从 0 开始，也可以使用负数索引表示从后往前的元素。

   my_list = ['apple', 'banana', 'cherry']
   print(my_list[0])  # 输出：apple
   print(my_list[-1])  # 输出：cherry
   

2. 修改列表元素
   列表是可变的，因此可以通过索引修改列表中的元素。

   my_list = [1, 2, 3]
   my_list[1] = 20
   print(my_list)  # 输出：[1, 20, 3]
   

3. 添加元素

   • 使用 append() 在列表末尾添加元素。
   • 使用 insert() 在指定位置插入元素。

   my_list = [1, 2, 3]
   my_list.append(4)  # 添加元素 4
   print(my_list)  # 输出：[1, 2, 3, 4]
   
   my_list.insert(1, 100)  # 在索引 1 处插入 100
   print(my_list)  # 输出：[1, 100, 2, 3, 4]
   

4. 删除元素

   • 使用 remove() 删除指定的元素。
   • 使用 pop() 删除指定索引处的元素，若不指定索引，默认删除最后一个元素。

   my_list = [1, 2, 3, 4, 5]
   my_list.remove(3)  # 删除元素 3
   print(my_list)  # 输出：[1, 2, 4, 5]
   
   my_list.pop(1)  # 删除索引 1 处的元素
   print(my_list)  # 输出：[1, 4, 5]
   
   my_list.pop()  # 删除最后一个元素
   print(my_list)  # 输出：[1, 4]
   

5. 列表切片
   可以通过切片操作获取列表的一个子列表，语法为 list[start:stop:step]。

   my_list = [1, 2, 3, 4, 5, 6]
   print(my_list[1:4])  # 输出：[2, 3, 4]
   print(my_list[::2])  # 输出：[1, 3, 5]
   

6. 列表长度
   使用 len() 函数可以获取列表的长度。

   my_list = [1, 2, 3, 4, 5]
   print(len(my_list))  # 输出：5
   

1.3 列表的其他常用方法

• sort()：对列表进行排序（默认从小到大）。

  my_list = [5, 2, 9, 1]
  my_list.sort()
  print(my_list)  # 输出：[1, 2, 5, 9]
  

• reverse()：将列表中的元素反转。

  my_list = [1, 2, 3]
  my_list.reverse()
  print(my_list)  # 输出：[3, 2, 1]
  

• extend()：将另一个列表中的元素添加到当前列表中。

  my_list = [1, 2, 3]
  my_list.extend([4, 5])
  print(my_list)  # 输出：[1, 2, 3, 4, 5]
  

---

2. 元组

2.1 元组的定义

元组（tuple）是一个不可变的序列，创建后其中的元素不能被修改。元组使用圆括号 () 表示。

my_tuple = (1, 2, 3)
print(my_tuple)

输出结果：

(1, 2, 3)

2.2 元组的特点

• 不可变：一旦创建，元组中的元素就不能被修改。
• 可以包含不同类型的元素：元组可以存储任意类型的数据。

my_tuple = (1, "apple", 3.14)
print(my_tuple)  # 输出：(1, 'apple', 3.14)

2.3 元组常用操作

1. 访问元组元素
   与列表类似，元组中的元素可以通过索引来访问。

   my_tuple = ('apple', 'banana', 'cherry')
   print(my_tuple[1])  # 输出：banana
   

2. 元组切片
   元组支持切片操作，可以获取元组的子元组。

   my_tuple = (1, 2, 3, 4, 5)
   print(my_tuple[1:4])  # 输出：(2, 3, 4)
   

3. 元组解包
   可以将元组中的值解包赋值给多个变量。

   my_tuple = (1, 2, 3)
   a, b, c = my_tuple
   print(a, b, c)  # 输出：1 2 3
   

4. 不可变性
   元组是不可变的，因此不能修改其元素或对其使用添加、删除操作。

   my_tuple = (1, 2, 3)
   # my_tuple[0] = 10  # 报错：'tuple' object does not support item assignment
   

2.4 常用元组方法

• count()：返回元组中某个元素出现的次数。

  my_tuple = (1, 2, 3, 2)
  print(my_tuple.count(2))  # 输出：2
  

• index()：返回某个元素在元组中的索引位置。

  my_tuple = (1, 2, 3)
  print(my_tuple.index(2))  # 输出：1
  

---

3. 列表与元组的区别

特性	列表 (list)	元组 (tuple)
可变性	可变	不可变
语法	使用方括号 []	使用圆括号 ()
性能	较慢（由于可变，内存开销较大）	较快（由于不可变，内存开销小）
用途	需要频繁修改的集合	用于不可修改的数据集合

---

4. 小结

列表和元组是 Python 中常用的序列类型。列表可变且功能丰富，适用于需要修改数据的场景；而元组不可变，适合用来存储不需要修改的数据。根据不同的需求，选择合适的数据类型可以提高代码的效率和可读性。