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

我会带着你远行 2024-03-23 19:02 114阅读 0赞

#### 文章目录 ####

*  零 数据容器入门
 *  一 数据容器：list(列表)
 *   *  1.1 列表的定义
     *  1.2 列表的下表索引
     *  1.3 列表的常用操作
     *   *  1.3.1 列表的查询功能
         *  1.3.2 列表的修改功能
         *  1.3.3 列表常用方法总结
     *  1.4 补充：append与extend对比
     *  1.5 list（列表）的遍历
     *  1.6 补充：while循环和for循环对比
 *  二 数据容器：tuple(元组)
 *   *  2.1 元组的定义
     *  2.2 疑惑解答
     *  2.3 元组的操作
     *  2.4 注意事项
     *  2.5 练习案例:元组的基本操作

## 零 数据容器入门 ##

*  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])

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

--------------------

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

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

### 1.2 列表的下表索引 ###

*  列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增  
    ![在这里插入图片描述][a247a7994aef41e7bf21dc3236f4ad0d.png]
 *  可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3…）  
    ![在这里插入图片描述][e8ce8bcb5d904a72bd7c3381db8232b9.png]
 *  如果列表是嵌套的列表，同样支持下标索引

![在这里插入图片描述][c7b7ef27d4c645e09d94fc04e540ea58.png]

*  演示

# 列表[下标索引], 从前向后从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.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
 *  请注意，`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.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]
2.  插入元素：使用`insert()`方法在指定位置插入指定元素
    
     *  第一个参数是要插入的索引，第二个参数是要插入的元素。

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

1.  添加元素
    
     *  使用 `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']
    
     *  使用`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]
2.  删除元素：
    
    1.  `remove()` 方法：通过值删除元素。该方法将从列表中删除第一个匹配到的值。**如果要删除所有匹配的值，可以使用循环结合** `remove()` 方法来实现。
    
        my_list = [1, 2, 3, 2, 4]
        my_list.remove(2)
        print(my_list)  # 输出: [1, 3, 2, 4]
    
        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.  `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.  `del` 语句：通过索引使用 `del` 语句删除元素。与 `pop()` 方法不同，`del` 语句不返回被删除的元素。
    
        my_list = [1, 2, 3, 4]
        del my_list[1]
        print(my_list)  # 输出: [1, 3, 4]
    
    1.  使用切片删除多个元素：通过切片语法删除多个元素。
        
         *  `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.  清空列表：使用 clear() 方法可以清空列表中的所有元素。
    
        my_list = [1, 2, 3, 4, 5]
        my_list.clear()
        print(my_list)  # 输出: []
    
    1.  统计某元素在列表内的数量：`.count(元素)`方法统计元素在列表中的个数
    
        mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
        count = len(mylist)
        print(f"列表的元素数量总共有：{
                count}个")
    
    1.  统计元素个数：`len()`方法用于获取列表（或其他可迭代对象）的长度,即列表中包含的元素个数
        
         *  `len()`方法是一个内置函数，它不仅可以用于列表，还可以用于字符串、元组、集合等可迭代对象。
    
        my_list = [1, 2, 3, 4, 5]
        length = len(my_list)
        print(length)  # 输出: 5

#### 1.3.3 列表常用方法总结 ####

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>append()</code></td> 
   <td>在列表末尾添加一个元素</td> 
   <td><code>my_list.append(10)</code></td> 
  </tr> 
  <tr> 
   <td><code>extend()</code></td> 
   <td>将一个可迭代对象中的元素逐个添加到列表末尾</td> 
   <td><code>my_list.extend([20, 30, 40])</code></td> 
  </tr> 
  <tr> 
   <td><code>insert()</code></td> 
   <td>在指定位置插入一个元素</td> 
   <td><code>my_list.insert(1, 15)</code></td> 
  </tr> 
  <tr> 
   <td><code>remove()</code></td> 
   <td>删除第一个匹配的元素</td> 
   <td><code>my_list.remove(30)</code></td> 
  </tr> 
  <tr> 
   <td><code>pop()</code></td> 
   <td>删除并返回指定索引的元素（默认为最后一个元素）</td> 
   <td><code>my_list.pop(1)</code></td> 
  </tr> 
  <tr> 
   <td><code>del</code> 语句</td> 
   <td>通过索引删除元素</td> 
   <td><code>del my_list[0]</code></td> 
  </tr> 
  <tr> 
   <td><code>clear()</code></td> 
   <td>删除列表中的所有元素</td> 
   <td><code>my_list.clear()</code></td> 
  </tr> 
  <tr> 
   <td><code>index()</code></td> 
   <td>返回指定元素的索引（第一个匹配项）</td> 
   <td><code>index = my_list.index(40)</code></td> 
  </tr> 
  <tr> 
   <td><code>count()</code></td> 
   <td>统计指定元素在列表中出现的次数</td> 
   <td><code>count = my_list.count(20)</code></td> 
  </tr> 
  <tr> 
   <td><code>sort()</code></td> 
   <td>对列表进行排序（原地排序，不返回新列表）</td> 
   <td><code>my_list.sort()</code></td> 
  </tr> 
  <tr> 
   <td><code>reverse()</code></td> 
   <td>反转列表中的元素顺序</td> 
   <td><code>my_list.reverse()</code></td> 
  </tr> 
  <tr> 
   <td>切片操作</td> 
   <td>从列表中获取子列表或修改多个元素</td> 
   <td><code>sub_list = my_list[1:4]</code>, <code>my_list[1:4] = [8, 9, 10]</code></td> 
  </tr> 
 </tbody> 
</table>

### 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.  `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]

总结：

*  使用 `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.  使用索引和range函数：
    
        my_list = [1, 2, 3, 4, 5]
        
        for i in range(len(my_list)):
            print(my_list[i])

--------------------

1.  使用enumerate函数（同时获取索引和元素）：
    
        my_list = [1, 2, 3, 4, 5]
        
        for index, item in enumerate(my_list):
            print(f"Index: {
                index}, Item: {
                item}")

--------------------

1.  使用while循环和索引：
    
        my_list = [1, 2, 3, 4, 5]
        index = 0
        
        while index < len(my_list):
            print(my_list[index])
            index += 1

--------------------

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

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

在循环控制上：

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

在无限循环上：

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

在使用场景上：

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

## 二 数据容器：tuple(元组) ##

### 2.1 元组的定义 ###

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

# 定义元组字面量
    (元素,元素,元素,...)
    # 定义元组变量
    变量名称=(元素,元素,元素,...)
    # 定义空元组
    变量名称=()
    变量名称=tuple()

# 定义一个空元组
    empty_tuple = ()
    
    # 定义一个包含多个元素的元组
    my_tuple = (1, 2, "Hello", 3.14, [4, 5])
    
    # 元组中也可以包含其他元组
    nested_tuple = (1, (2, 3), ("a", "b", "c"))
    
    # 单个元素的元组需要在元素后面加上逗号，以区分其与括号运算符的使用
    single_element_tuple = (42,)

### 2.2 疑惑解答 ###

*  元组只有一个数据，这个数据后面要添加逗号。
 *  在Python中，**如果要定义只有一个元素的元组，需要在元素后面添加逗号，否则Python会将其视为其他数据类型而不是元组。**
 *  这是因为**在使用圆括号时，Python解释器需要通过逗号来区分表达式和元组。当只有一个元素且没有逗号时，解释器无法确定它是一个元组还是一个普通的表达式。**
    
     *  以下是正确定义只包含一个元素的元组的示例：
    
        # 只包含一个元素的元组，需要在元素后面添加逗号
        single_element_tuple = (42,)
        print(type(single_element_tuple))  # 输出：<class 'tuple'>
    
     *  如果没有添加逗号：
    
        # 没有添加逗号，解释器将不会将其识别为元组
        not_a_tuple = (42)
        print(type(not_a_tuple))  # 输出：<class 'int'>
    
     *  所以，为了确保只包含一个元素的表达式被正确解释为元组，必须添加逗号。

### 2.3 元组的操作 ###

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

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>示例</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>访问元素</td> 
   <td><code>my_tuple[0]</code></td> 
   <td>使用索引访问元组中的元素。</td> 
  </tr> 
  <tr> 
   <td>切片</td> 
   <td><code>my_tuple[1:4]</code></td> 
   <td>使用切片获取元组中的子集。</td> 
  </tr> 
  <tr> 
   <td>连接</td> 
   <td><code>tuple1 + tuple2</code></td> 
   <td>使用加号（+）将两个元组连接起来。</td> 
  </tr> 
  <tr> 
   <td>复制</td> 
   <td><code>my_tuple * 3</code></td> 
   <td>使用乘号（*）复制元组。</td> 
  </tr> 
  <tr> 
   <td>元素检查</td> 
   <td><code>element in my_tuple</code></td> 
   <td>使用<code>in</code>关键字检查元素是否在元组中。</td> 
  </tr> 
  <tr> 
   <td>元素个数</td> 
   <td><code>len(my_tuple)</code></td> 
   <td>使用<code>len()</code>函数获取元组中元素的个数。</td> 
  </tr> 
  <tr> 
   <td>元素最值</td> 
   <td><code>min(my_tuple)</code><br><code>max(my_tuple)</code></td> 
   <td>使用<code>min()</code>和<code>max()</code>函数获取元组中的最小和最大值。</td> 
  </tr> 
  <tr> 
   <td>元组解包</td> 
   <td><code>a, b, c = my_tuple</code></td> 
   <td>将元组的元素解包到多个变量中。</td> 
  </tr> 
  <tr> 
   <td>查找元素索引</td> 
   <td><code>my_tuple.index(element)</code></td> 
   <td>返回元素在元组中第一次出现的索引。</td> 
  </tr> 
  <tr> 
   <td>统计元素出现次数</td> 
   <td><code>my_tuple.count(element)</code></td> 
   <td>返回元素在元组中出现的次数。</td> 
  </tr> 
 </tbody> 
</table>

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

--------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1.  查找元素索引：`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.  统计元素出现次数：`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

### 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])
 *  元组中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)

### 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
        学生的姓名: 周杰轮
        删除后的爱好列表: ['music']
        增加爱好后的列表: ['music', 'coding']
        最终的学生信息元组: ('周杰轮', 11, ['music', 'coding'])

[a247a7994aef41e7bf21dc3236f4ad0d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0ea182214f88479b8246950f3bc2e279.png
[e8ce8bcb5d904a72bd7c3381db8232b9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/93e0de755d9148e6a54b0fc0cb3a62ca.png
[c7b7ef27d4c645e09d94fc04e540ea58.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/2fe2c2a87edd4788bdfe2e79bd134b5a.png