探索Python数据容器之乐趣：列表与元组的奇妙旅程！

零 数据容器入门

• Python中的数据容器：

  • 一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
  • 每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

• 数据容器根据特点的不同，如：是否支持重复元素、是否可以修改、是否有序，等分为5类，分别是：
  列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

一 数据容器：list(列表)

1.1 列表的定义

• 在Python中，list（列表）是一种常用的数据容器，用于存储多个元素。列表是可变（mutable）的，可以在创建后随时修改它，添加或删除元素。
• 列表可以包含不同类型的元素，例如整数、字符串、浮点数等，甚至可以包含其他列表。
• 创建列表的语法为用方括号 [] 括起来的一系列元素，每个元素之间用逗号 , 分隔。例如：

my_list = [1, 2, 3, "hello", 3.14]
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])
1
2
3
4
5
6
7

• 列表索引从0开始，所以第一个元素可以通过 my_list[0] 来访问，第二个元素通过 my_list[1]，依此类推。

---

列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))
1
2
3
4

1.2 列表的下表索引

• 列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增
  
• 可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3…）
  
• 如果列表是嵌套的列表，同样支持下标索引

• 演示

# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])


# 取出嵌套列表的元素
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list[1][1])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.3 列表的常用操作

1.3.1 列表的查询功能

• 使用 index() 方法来查找列表中某个元素第一次出现的索引（下标）。

• index() 方法接受一个参数，即要查找的元素的值，并返回该元素在列表中的索引值。如果该元素不存在于列表中，该方法将引发一个 ValueError 异常。

• index() 方法查找元素的示例：

  my_list = [10, 20, 30, 40, 50]
  
  # 查找元素的索引
  index_30 = my_list.index(30)
  print(index_30)  # 输出: 2
  
  index_40 = my_list.index(40)
  print(index_40)  # 输出: 3
  
  # 查找不存在的元素会引发异常
  try:
      index_60 = my_list.index(60)
  except ValueError as e:
      print("元素不存在:", e)  # 输出: 元素不存在: 60 is not in list
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

• 请注意，index() 方法只会返回找到的第一个匹配项的索引。

---

• 如果有多个相同的元素，可能需要使用循环来找到所有匹配项的索引。

my_list = [10, 20, 30, 40, 30, 50]

# 找到所有匹配项的索引
target = 30
indices = []
for i in range(len(my_list)):
    if my_list[i] == target:
        indices.append(i)

print(indices)  # 输出: [2, 4]

1
2
3
4
5
6
7
8
9
10
11

1.3.2 列表的修改功能

1. 修改元素：通过索引来修改列表中的元素。

   my_list = [1, 2, 3, "hello", 3.14]
   my_list[2] = 42
   print(my_list)  # 输出: [1, 2, 42, 'hello', 3.14]
   my_list[-1]=-1
   print(my_list) # 输出: [1, 2, 42, 'hello', -1]
   1
   2
   3
   4
   5

2. 插入元素：使用insert()方法在指定位置插入指定元素
   • 第一个参数是要插入的索引，第二个参数是要插入的元素。

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

3. 添加元素

   • 使用 append() 方法在列表末尾添加元素。
   • append() 方法没有返回值（即返回值为None），它会直接在原列表上进行修改。

   my_list = [1, 2, 3, "hello", 3.14]
   my_list.append("world")
   print(my_list)  # 输出: [1, 2, 42, 'hello', 3.14, 'world']
   1
   2
   3

   • 使用extend()方法，将其它数据容器的内容取出，依次追加到列表尾部
   • 列表的 extend() 方法用于将一个可迭代对象的元素添加到列表的末尾。可迭代对象可以是另一个列表、元组、字符串，或者任何支持迭代的数据类型。extend() 方法会逐个迭代可迭代对象，并将其中的元素依次添加到列表中。

   # 列表扩展
   list1 = [1, 2, 3]
   list2 = [4, 5, 6]
   list1.extend(list2)
   print(list1)  # 输出: [1, 2, 3, 4, 5, 6]
   
   # 字符串扩展
   my_list = [1, 2, 3]
   my_string = "hello"
   my_list.extend(my_string)
   print(my_list)  # 输出: [1, 2, 3, 'h', 'e', 'l', 'l', 'o']
   
   # 可迭代对象扩展
   my_list = [1, 2, 3]
   my_tuple = (4, 5, 6)
   my_list.extend(my_tuple)
   print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18

4. 删除元素：

   1. remove() 方法：通过值删除元素。该方法将从列表中删除第一个匹配到的值。如果要删除所有匹配的值，可以使用循环结合 remove() 方法来实现。

   my_list = [1, 2, 3, 2, 4]
   my_list.remove(2)
   print(my_list)  # 输出: [1, 3, 2, 4]
   1
   2
   3

   my_list = [1, 2, 3, 2, 4]
   
   # 删除所有匹配的值
   value_to_remove = 2
   while value_to_remove in my_list:
       my_list.remove(value_to_remove)
   
   print(my_list)  # 输出: [1, 3, 4]
   1
   2
   3
   4
   5
   6
   7
   8

   2. pop() 方法：通过索引删除元素，并返回被删除的元素。如果不提供索引，它将删除并返回列表的最后一个元素。

   my_list = [1, 2, 3, 4]
   deleted_element = my_list.pop(1)
   print(deleted_element)  # 输出: 2
   print(my_list)  # 输出: [1, 3, 4]
   
   deleted_element = my_list.pop()
   print(deleted_element)  # 输出: 4
   print(my_list)  # 输出: [1, 3]
   1
   2
   3
   4
   5
   6
   7
   8

   3. del 语句：通过索引使用 del 语句删除元素。与 pop() 方法不同，del 语句不返回被删除的元素。

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

   4. 使用切片删除多个元素：通过切片语法删除多个元素。

      • my_list[:2]：这是一个切片操作，表示获取从索引 0 到索引 2（不包括索引 2）的子列表。这将返回 [1, 2]，这是原列表 my_list 中索引为 0 和 1 的元素组成的子列表。

      • my_list[3:]：这也是一个切片操作，表示获取从索引 3 到列表末尾的子列表。这将返回 [4, 5]，这是原列表 my_list 中索引为 3 和 4 的元素组成的子列表。

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

   5. 清空列表：使用 clear() 方法可以清空列表中的所有元素。

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

   6. 统计某元素在列表内的数量：.count(元素)方法统计元素在列表中的个数

   mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
   count = len(mylist)
   print(f"列表的元素数量总共有：{count}个")
   1
   2
   3

   7. 统计元素个数：len() 方法用于获取列表（或其他可迭代对象）的长度,即列表中包含的元素个数
      • len() 方法是一个内置函数，它不仅可以用于列表，还可以用于字符串、元组、集合等可迭代对象。

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

1.3.3 列表常用方法总结

1.4 补充：append与extend对比

• append() 和 extend() 方法是两个常用的方法，但它们有着不同的用途和行为。

1. append() 方法：

• 用途：append() 方法用于将指定的元素作为一个整体添加到列表的末尾。
• 参数：append() 方法接受一个参数，即要添加到列表末尾的元素。
• 返回值：append() 方法没有返回值，其返回值为 None。
• 修改原列表：append() 方法直接在原列表上进行修改，将指定的元素添加到列表的末尾。
• 示例：

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出: [1, 2, 3, 4]

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

1
2
3
4
5
6
7

2. extend() 方法：

• 用途：extend() 方法用于将一个可迭代对象的元素逐个添加到列表的末尾。
• 参数：extend() 方法接受一个可迭代对象作为参数，例如列表、元组、字符串等。
• 返回值：extend() 方法没有返回值，其返回值为 None。
• 修改原列表：extend() 方法直接在原列表上进行修改，将可迭代对象中的元素逐个添加到列表的末尾。
• 示例：

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

总结：

• 使用 append() 方法，您可以将一个元素作为整体添加到列表的末尾。

• 使用 extend() 方法，您可以将一个可迭代对象中的元素逐个添加到列表的末尾。

• 两种方法都直接在原列表上进行修改，而且它们没有返回值，其返回值为 None。

• 选择使用 append() 还是 extend() 取决于您要添加的元素类型和添加的方式。如果您要将一个单一元素作为整体添加到列表，使用 append()。如果您有一个可迭代对象，希望将其中的所有元素逐个添加到列表，使用 extend()。

1.5 list（列表）的遍历

• 在Python中，列表是一种可迭代对象，可以通过遍历来访问其中的元素。有几种方式可以对Python列表进行遍历：

1. 使用for循环：

   my_list = [1, 2, 3, 4, 5]
   
   for item in my_list:
       print(item)
   1
   2
   3
   4

---

2. 使用索引和range函数：

   my_list = [1, 2, 3, 4, 5]
   
   for i in range(len(my_list)):
       print(my_list[i])
   1
   2
   3
   4

---

3. 使用enumerate函数（同时获取索引和元素）：

   my_list = [1, 2, 3, 4, 5]
   
   for index, item in enumerate(my_list):
       print(f"Index: {index}, Item: {item}")
   1
   2
   3
   4

---

4. 使用while循环和索引：

   my_list = [1, 2, 3, 4, 5]
   index = 0
   
   while index < len(my_list):
       print(my_list[index])
       index += 1
   1
   2
   3
   4
   5
   6

---

1.6 补充：while循环和for循环对比

while循环和for循环，都是循环语句，但细节不同：

在循环控制上：

• while循环可以自定循环条件，并自行控制
• for循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上：

• while循环可以通过条件控制做到无限循环
• for循环理论上不可以，因为被遍历的容器容量不是无限的

在使用场景上：

• while循环适用于任何想要循环的场景
• for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

二 数据容器：tuple(元组)

2.1 元组的定义

• 元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于：元组一旦定义完成，就不可修改
• 元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

# 定义元组字面量
(元素,元素,元素,...)
# 定义元组变量
变量名称=(元素,元素,元素,...)
# 定义空元组
变量名称=()
变量名称=tuple()
1
2
3
4
5
6
7

# 定义一个空元组
empty_tuple = ()

# 定义一个包含多个元素的元组
my_tuple = (1, 2, "Hello", 3.14, [4, 5])

# 元组中也可以包含其他元组
nested_tuple = (1, (2, 3), ("a", "b", "c"))

# 单个元素的元组需要在元素后面加上逗号，以区分其与括号运算符的使用
single_element_tuple = (42,)
1
2
3
4
5
6
7
8
9
10
11

2.2 疑惑解答

• 元组只有一个数据，这个数据后面要添加逗号。

• 在Python中，如果要定义只有一个元素的元组，需要在元素后面添加逗号，否则Python会将其视为其他数据类型而不是元组。

• 这是因为在使用圆括号时，Python解释器需要通过逗号来区分表达式和元组。当只有一个元素且没有逗号时，解释器无法确定它是一个元组还是一个普通的表达式。

  • 以下是正确定义只包含一个元素的元组的示例：

  # 只包含一个元素的元组，需要在元素后面添加逗号
  single_element_tuple = (42,)
  print(type(single_element_tuple))  # 输出：<class 'tuple'>
  1
  2
  3

  • 如果没有添加逗号：

  # 没有添加逗号，解释器将不会将其识别为元组
  not_a_tuple = (42)
  print(type(not_a_tuple))  # 输出：<class 'int'>
  1
  2
  3

  • 所以，为了确保只包含一个元素的表达式被正确解释为元组，必须添加逗号。

2.3 元组的操作

• 元组由于不可修改的特性，所以其操作方法非常少
• Python元组的常见操作：

感谢您的提醒，这些方法是在处理元组时非常有用的功能，使得我们可以更方便地对元组进行操作和查询。

---

1. 访问元素：可以使用索引来访问元组中的元素。

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

2. 切片：可以使用切片来获取元组中的子集。

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

3. 连接：可以使用加号（+）将两个元组连接起来。

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
concatenated_tuple = tuple1 + tuple2
print(concatenated_tuple)  # 输出：(1, 2, 3, 4, 5, 6)
1
2
3
4

4. 复制：可以使用乘号（*）复制元组。

my_tuple = (1, 2, 3)
duplicated_tuple = my_tuple * 3
print(duplicated_tuple)  # 输出：(1, 2, 3, 1, 2, 3, 1, 2, 3)
1
2
3

5. 元素检查：可以使用 in 关键字检查元素是否在元组中。

my_tuple = (1, 2, 3)
print(2 in my_tuple)  # 输出：True
print(4 in my_tuple)  # 输出：False
1
2
3

6. 元素个数：使用 len() 函数可以获取元组中元素的个数。

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

7. 元素最值：可以使用 min() 和 max() 函数获取元组中的最小和最大值。

my_tuple = (5, 2, 8, 1, 3)
print(min(my_tuple))  # 输出：1
print(max(my_tuple))  # 输出：8
1
2
3

8. 元组解包：可以将元组的元素解包到多个变量中。

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

9. 查找元素索引：index() 方法用于查找元组中指定元素的索引（第一次出现的位置）。如果元素不存在于元组中，会引发 ValueError 错误。

my_tuple = (10, 20, 30, 40, 20, 50)

index_20 = my_tuple.index(20)
print("Index of 20:", index_20)  # 输出：Index of 20: 1

index_60 = my_tuple.index(60)  # 元素 60 不在元组中，会引发 ValueError 错误
1
2
3
4
5
6

10. 统计元素出现次数：count() 方法用于统计元组中指定元素的出现次数

my_tuple = (10, 20, 30, 40, 20, 50)

count_20 = my_tuple.count(20)
print("Count of 20:", count_20)  # 输出：Count of 20: 2

count_60 = my_tuple.count(60)
print("Count of 60:", count_60)  # 输出：Count of 60: 0

1
2
3
4
5
6
7
8

2.4 注意事项

• 如果元组中包含可变对象，例如列表，那么列表内的内容是可以修改的。虽然元组本身不能变，但是列表是可变的，因此可以对列表内的元素进行修改。
• 可以修改元组内的list的内容（修改元素、增加、删除、反转等）

  # 创建一个包含列表的元组
  my_tuple = ([1, 2, 3], [4, 5, 6])
  
  # 修改元组中列表的元素
  my_tuple[0][1] = 100
  my_tuple[1].append(7)
  my_tuple[1].remove(4)
  
  print(my_tuple)  # 输出：([1, 100, 3], [5, 6, 7])
  1
  2
  3
  4
  5
  6
  7
  8
  9

• 元组中list不可以替换list为其它list或其它类型

  # 创建一个包含列表的元组
  my_tuple = ([1, 2, 3], [4, 5, 6])
  
  # 尝试替换元组中的列表为其他列表
  new_list = [7, 8, 9]
  my_tuple[0] = new_list  # 会引发 TypeError 错误，元组不可赋值修改
  
  # 尝试直接替换列表为其他类型
  my_tuple[1] = "Hello"  # 会引发 TypeError 错误，元组不可赋值修改
  
  # 尝试修改元组内列表的元素
  my_tuple[0][1] = 100  # 这是可以的，因为元组中的列表是可变对象
  
  print(my_tuple)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

2.5 练习案例:元组的基本操作

• 定义一个元组，内容是：（‘周杰轮’, 11, [‘football’, ‘music’]），记录的是一个学生的信息（姓名、年龄、爱好）

• 请通过元组的功能（方法），对其进行

  1. 查询其年龄所在的下标位置
  2. 查询学生的姓名
  3. 删除学生爱好中的football
  4. 增加爱好：coding到爱好list内

• 示例代码：

  student_info = ('周杰轮', 11, ['football', 'music'])
  
  # 1. 查询年龄所在的下标位置
  age_index = student_info.index(11)
  print("年龄所在的下标位置:", age_index)
  
  # 2. 查询学生的姓名
  name = student_info[0]
  print("学生的姓名:", name)
  
  # 3. 删除学生爱好中的football
  hobbies = student_info[2]
  if 'football' in hobbies:
      hobbies.remove('football')
  print("删除后的爱好列表:", hobbies)
  
  # 4. 增加爱好：coding到爱好list内
  hobbies.append('coding')
  print("增加爱好后的列表:", hobbies)
  
  # 最终的学生信息元组
  updated_student_info = (name, 11, hobbies)
  print("最终的学生信息元组:", updated_student_info)
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24

• 运行结果：

  年龄所在的下标位置: 1
  学生的姓名: 周杰轮
  删除后的爱好列表: ['music']
  增加爱好后的列表: ['music', 'coding']
  最终的学生信息元组: ('周杰轮', 11, ['music', 'coding'])
  1
  2
  3
  4
  5