当前位置： 首页 > news >正文

Python星球日记 - 第6天：列表与元组

news 来源：原创 2025/6/19 0:09:38

🌟引言：

上一篇：Python星球日记 - 第5天：循环结构

名人说：路漫漫其修远兮，吾将上下而求索。 —— 屈原《离骚》
创作者：Code_流苏(CSDN)（一个喜欢古诗词和编程的Coder😊）

目录

    • 一、列表的定义与操作
      • 1. 列表的创建
      • 2. 访问列表元素
      • 3. 修改列表元素
      • 4. 添加元素
      • 5. 删除元素
      • 6. 列表切片
    • 二、列表方法
      • 1. 添加和扩展方法
      • 2. 删除方法
      • 3. 排序和反转方法
      • 4. 查询方法
      • 5. 其他有用的方法和函数
    • 三、元组的特点与使用场景
      • 1. 创建元组
      • 2. 访问元组元素
      • 3. 元组的不可变性
      • 4. 元组的方法
      • 5. 元组的使用场景
    • 四、列表与元组的区别
    • 五、练习：统计列表中偶数的个数
    • 六、总结
    • 练习题（将你的代码放到评论区）

更多硬核知识，请关注我、订阅专栏《 Python星球日记》，内容持续更新中…
专栏介绍： Python星球日记专栏介绍（持续更新ing）

欢迎来到Python星球的第6天！今天我们将探索Python中两个最基本也最常用的数据结构：列表和元组。

这两种数据结构能够存储多个值，是Python编程中不可或缺的工具。无论是数据处理、算法实现还是日常编程，列表和元组都扮演着重要角色。让我们一起深入了解这两个强大的数据容器！

一、列表的定义与操作

列表是Python中最常用的数据结构之一，它是一个可变的、有序的元素集合。列表可以包含不同类型的元素，如整数、字符串、浮点数，甚至其他列表。

1. 列表的创建

创建列表非常简单，只需使用方括号 [] 将元素括起来，并用逗号分隔：

# 创建一个空列表
empty_list = []
print(empty_list)
# 输出: []

# 创建包含整数的列表
numbers = [1, 2, 3, 4, 5]
print(numbers)
# 输出: [1, 2, 3, 4, 5]

# 创建包含不同类型元素的列表
mixed_list = [1, "Python", 3.14, True]
print(mixed_list)
# 输出: [1, 'Python', 3.14, True]

# 使用list()函数创建列表
another_list = list("Python")
print(another_list)
# 输出: ['P', 'y', 't', 'h', 'o', 'n']

输出结果：

[]
[1, 2, 3, 4, 5]
[1, 'Python', 3.14, True]
['P', 'y', 't', 'h', 'o', 'n']

2. 访问列表元素

列表是有序的，这意味着每个元素都有一个特定的位置或索引。在Python中，索引从0开始：

planets = ["水星", "金星", "地球", "火星", "木星"]
print(planets)
# 输出: ['水星', '金星', '地球', '火星', '木星']

# 访问第一个元素（索引为0）
first_planet = planets[0]
print(first_planet)
# 输出: 水星

# 访问最后一个元素
last_planet = planets[-1]
print(last_planet)
# 输出: 木星

# 使用索引范围访问多个元素（切片）
inner_planets = planets[0:3]
print(inner_planets)
# 输出: ['水星', '金星', '地球']

输出结果：

['水星', '金星', '地球', '火星', '木星']
水星
木星
['水星', '金星', '地球']

3. 修改列表元素

列表是可变的，这意味着我们可以更改其内容：

languages = ["Python", "Java", "C++", "JavaScript"]
print(languages)
# 输出: ['Python', 'Java', 'C++', 'JavaScript']

# 修改第二个元素
languages[1] = "Go"
print(languages)
# 输出: ['Python', 'Go', 'C++', 'JavaScript']

输出结果：

['Python', 'Java', 'C++', 'JavaScript']
['Python', 'Go', 'C++', 'JavaScript']

4. 添加元素

有多种方法可以向列表中添加元素：

fruits = ["苹果", "香蕉", "橙子"]
print(fruits)
# 输出: ['苹果', '香蕉', '橙子']

# 使用append()方法在列表末尾添加元素
fruits.append("草莓")
print(fruits)
# 输出: ['苹果', '香蕉', '橙子', '草莓']

# 使用insert()方法在特定位置插入元素
fruits.insert(1, "梨")
print(fruits)
# 输出: ['苹果', '梨', '香蕉', '橙子', '草莓']

# 使用extend()方法合并两个列表
more_fruits = ["西瓜", "葡萄"]
fruits.extend(more_fruits)
print(fruits)
# 输出: ['苹果', '梨', '香蕉', '橙子', '草莓', '西瓜', '葡萄']

输出结果：

['苹果', '香蕉', '橙子']
['苹果', '香蕉', '橙子', '草莓']
['苹果', '梨', '香蕉', '橙子', '草莓']
['苹果', '梨', '香蕉', '橙子', '草莓', '西瓜', '葡萄']

5. 删除元素

同样，有多种方法可以从列表中删除元素：

colors = ["红", "绿", "蓝", "黄", "紫"]
print(colors)
# 输出: ['红', '绿', '蓝', '黄', '紫']

# 使用remove()方法删除特定值
colors.remove("黄")
print(colors)
# 输出: ['红', '绿', '蓝', '紫']

# 使用pop()方法删除特定位置的元素并返回它
removed_color = colors.pop(1)
print("移除的颜色:", removed_color)
# 输出: 移除的颜色: 绿
print(colors)
# 输出: ['红', '蓝', '紫']

# 使用del语句删除特定位置的元素
del colors[0]
print(colors)
# 输出: ['蓝', '紫']

# 使用clear()方法清空列表
colors.clear()
print(colors)
# 输出: []

输出结果：

['红', '绿', '蓝', '黄', '紫']
['红', '绿', '蓝', '紫']
移除的颜色: 绿
['红', '蓝', '紫']
['蓝', '紫']
[]

6. 列表切片

切片是Python中一个强大的特性，允许我们访问列表的子序列：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers)
# 输出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取前五个元素
first_five = numbers[0:5]
print(first_five)
# 输出: [0, 1, 2, 3, 4]

# 简写形式
first_five = numbers[:5]
print(first_five)
# 输出: [0, 1, 2, 3, 4]

# 获取第五个元素之后的所有元素
after_fifth = numbers[5:]
print(after_fifth)
# 输出: [5, 6, 7, 8, 9]

# 使用步长参数获取偶数索引的元素
even_indices = numbers[::2]
print(even_indices)
# 输出: [0, 2, 4, 6, 8]

# 使用负步长反转列表
reversed_list = numbers[::-1]
print(reversed_list)
# 输出: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

输出结果：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
[5, 6, 7, 8, 9]
[0, 2, 4, 6, 8]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

列表切片可视化图示：

在这里插入图片描述

二、列表方法

Python列表提供了许多内置方法，使我们能够轻松地操作列表。以下是一些常用的列表方法：

在这里插入图片描述

1. 添加和扩展方法

  • append(元素): 在列表末尾添加一个元素
  • insert(索引, 元素): 在指定位置插入一个元素
  • extend(可迭代对象): 将可迭代对象的所有元素添加到列表末尾

2. 删除方法

  • remove(元素): 删除列表中第一个出现的指定元素
  • pop([索引]): 删除并返回指定位置的元素，默认为最后一个元素
  • clear(): 删除列表中的所有元素

3. 排序和反转方法

  • sort([key=函数, reverse=布尔值]): 对列表进行排序
  • reverse(): 将列表元素反转
numbers = [3, 1, 4, 1, 5, 9, 2]
print("原始列表:", numbers)
# 输出: 原始列表: [3, 1, 4, 1, 5, 9, 2]

# 对列表进行排序
numbers.sort()
print("升序排序后:", numbers)
# 输出: 升序排序后: [1, 1, 2, 3, 4, 5, 9]

# 降序排序
numbers.sort(reverse=True)
print("降序排序后:", numbers)
# 输出: 降序排序后: [9, 5, 4, 3, 2, 1, 1]

# 反转列表元素
numbers.reverse()
print("反转后:", numbers)
# 输出: 反转后: [1, 1, 2, 3, 4, 5, 9]

# 使用key参数按字符串长度排序
words = ["apple", "banana", "cherry", "date"]
print("原始单词列表:", words)
# 输出: 原始单词列表: ['apple', 'banana', 'cherry', 'date']
words.sort(key=len)
print("按长度排序后:", words)
# 输出: 按长度排序后: ['date', 'apple', 'cherry', 'banana']

输出结果：

原始列表: [3, 1, 4, 1, 5, 9, 2]
升序排序后: [1, 1, 2, 3, 4, 5, 9]
降序排序后: [9, 5, 4, 3, 2, 1, 1]
反转后: [1, 1, 2, 3, 4, 5, 9]
原始单词列表: ['apple', 'banana', 'cherry', 'date']
按长度排序后: ['date', 'apple', 'banana', 'cherry']

4. 查询方法

  • index(元素[, 开始[, 结束]]): 返回指定元素在列表中第一次出现的索引
  • count(元素): 返回指定元素在列表中出现的次数
  • in 运算符: 检查元素是否存在于列表中
fruits = ["苹果", "香蕉", "苹果", "橙子", "葡萄"]
print(fruits)
# 输出: ['苹果', '香蕉', '苹果', '橙子', '葡萄']

# 查找元素索引
apple_index = fruits.index("苹果")
print("苹果的索引:", apple_index)
# 输出: 苹果的索引: 0

# 计算元素出现次数
apple_count = fruits.count("苹果")
print("苹果出现的次数:", apple_count)
# 输出: 苹果出现的次数: 2

# 检查元素是否存在
has_pear = "梨" in fruits
print("梨是否在列表中:", has_pear)
# 输出: 梨是否在列表中: False

输出结果：

['苹果', '香蕉', '苹果', '橙子', '葡萄']
苹果的索引: 0
苹果出现的次数: 2
梨是否在列表中: False

5. 其他有用的方法和函数

  • len(列表): 返回列表的长度
  • max(列表): 返回列表中的最大元素
  • min(列表): 返回列表中的最小元素
  • sum(列表): 返回列表中所有数值的总和
numbers = [10, 20, 30, 40, 50]
print(numbers)
# 输出: [10, 20, 30, 40, 50]

# 获取列表长度
length = len(numbers)
print("列表长度:", length)
# 输出: 列表长度: 5

# 获取最大值
maximum = max(numbers)
print("最大值:", maximum)
# 输出: 最大值: 50

# 获取最小值
minimum = min(numbers)
print("最小值:", minimum)
# 输出: 最小值: 10

# 计算总和
total = sum(numbers)
print("总和:", total)
# 输出: 总和: 150

输出结果：

[10, 20, 30, 40, 50]
列表长度: 5
最大值: 50
最小值: 10
总和: 150

三、元组的特点与使用场景

元组是Python中另一种重要的序列类型，它与列表类似，但有一个关键区别：元组是不可变的。一旦创建，就不能修改、添加或删除其元素。

1. 创建元组

元组使用圆括号 () 创建：

# 创建一个空元组
empty_tuple = ()
print(empty_tuple)
# 输出: ()

# 创建包含整数的元组
numbers = (1, 2, 3, 4, 5)
print(numbers)
# 输出: (1, 2, 3, 4, 5)

# 创建包含不同类型元素的元组
mixed_tuple = (1, "Python", 3.14, True)
print(mixed_tuple)
# 输出: (1, 'Python', 3.14, True)

# 创建只有一个元素的元组（注意逗号）
single_item = (42,)
print(single_item)
# 输出: (42,)

# 对比不加逗号的情况
not_tuple = (42)
print(not_tuple, type(not_tuple))
# 输出: 42 <class 'int'>

# 使用tuple()函数创建元组
another_tuple = tuple("Python")
print(another_tuple)
# 输出: ('P', 'y', 't', 'h', 'o', 'n')

输出结果：

()
(1, 2, 3, 4, 5)
(1, 'Python', 3.14, True)
(42,)
42 <class 'int'>
('P', 'y', 't', 'h', 'o', 'n')

2. 访问元组元素

与列表一样，元组是有序的，可以使用索引访问元素：

planets = ("水星", "金星", "地球", "火星", "木星")
print(planets)
# 输出: ('水星', '金星', '地球', '火星', '木星')

# 访问第一个元素
first_planet = planets[0]
print(first_planet)
# 输出: 水星

# 使用切片
inner_planets = planets[0:3]
print(inner_planets)
# 输出: ('水星', '金星', '地球')

输出结果：

('水星', '金星', '地球', '火星', '木星')
水星
('水星', '金星', '地球')

3. 元组的不可变性

元组一旦创建，就不能修改其元素：

coordinates = (10, 20)

# 尝试修改元组元素会导致错误
# coordinates[0] = 15  # 这行代码会引发TypeError

在这里插入图片描述

尽管元组本身是不可变的，但如果元组包含可变对象（如列表），这些对象仍然可以被修改：

# 包含列表的元组
data = (1, 2, [3, 4])
print("原始元组:", data)
# 输出: 原始元组: (1, 2, [3, 4])

# 不能修改元组的元素
try:
    data[0] = 5
except TypeError as e:
    print("错误信息:", e)
# 输出: 错误信息: 'tuple' object does not support item assignment

# 但可以修改列表的内容
data[2][0] = 5
print("修改后的元组:", data)
# 输出: 修改后的元组: (1, 2, [5, 4])

输出结果：

原始元组: (1, 2, [3, 4])
错误信息: 'tuple' object does not support item assignment
修改后的元组: (1, 2, [5, 4])

4. 元组的方法

由于元组的不可变性，它只有两个方法：

  • count(元素): 返回指定元素在元组中出现的次数
  • index(元素): 返回指定元素在元组中第一次出现的索引
letters = ('a', 'b', 'c', 'a', 'd')
print(letters)
# 输出: ('a', 'b', 'c', 'a', 'd')

# 计数
a_count = letters.count('a')
print("'a'出现的次数:", a_count)
# 输出: 'a'出现的次数: 2

# 查找索引
b_index = letters.index('b')
print("'b'的索引:", b_index)
# 输出: 'b'的索引: 1

输出结果：

('a', 'b', 'c', 'a', 'd')
'a'出现的次数: 2
'b'的索引: 1

5. 元组的使用场景

尽管元组似乎受到更多限制，但在许多情况下，它们是比列表更好的选择：

  1. 数据不应被修改时：例如，表示坐标 (x, y) 或日期 (年, 月, 日)。
  2. 作为字典的键：由于元组是不可变的，它们可以用作字典的键，而列表不行。
  3. 函数返回多个值：当函数需要返回多个值时，通常会返回一个元组。
  4. 数据保护：当你不希望数据被意外修改时。
  5. 性能优化：在某些情况下，元组比列表更高效，因为Python可以对不可变对象进行优化。
# 作为函数返回多个值
def get_dimensions():
    return (1920, 1080)  # 返回宽度和高度

# 调用函数并接收返回值
dimensions = get_dimensions()
print("函数返回值:", dimensions)
# 输出: 函数返回值: (1920, 1080)

# 解包元组
width, height = get_dimensions()
print(f"宽度: {width}, 高度: {height}")
# 输出: 宽度: 1920, 高度: 1080

# 作为字典键
locations = {
    (39.9, 116.4): "北京",
    (31.2, 121.5): "上海",
    (23.1, 113.3): "广州"
}
print(locations)
# 输出: {(39.9, 116.4): '北京', (31.2, 121.5): '上海', (23.1, 113.3): '广州'}

# 通过坐标查找城市
beijing_coords = (39.9, 116.4)
print(f"坐标{beijing_coords}对应的城市是:", locations[beijing_coords])
# 输出: 坐标(39.9, 116.4)对应的城市是: 北京

输出结果：

函数返回值: (1920, 1080)
宽度: 1920, 高度: 1080
{(39.9, 116.4): '北京', (31.2, 121.5): '上海', (23.1, 113.3): '广州'}
坐标(39.9, 116.4)对应的城市是: 北京

四、列表与元组的区别

让我们总结一下列表和元组之间的主要区别：

特征列表元组
语法使用方括号 []使用圆括号 ()
可变性可变（可以修改、添加、删除元素）不可变（创建后不能修改）
方法有许多方法（如 append、remove、sort 等）只有 count 和 index 方法
性能较慢较快
内存使用较高较低
适用场景需要频繁修改的数据集合不需要修改的数据集合
作为字典键不可用可用

选择使用列表还是元组取决于你的具体需求：

  • 如果你需要一个可以修改的集合，选择列表
  • 如果你需要一个不可修改的集合，选择元组

在这里插入图片描述

五、练习：统计列表中偶数的个数

现在，让我们通过一个练习来巩固我们对列表的理解。我们将编写一个函数，统计列表中所有偶数的个数。

def count_even_numbers(numbers):
    """
    统计列表中偶数的个数
    
    参数:
        numbers: 包含整数的列表
    
    返回:
        列表中偶数的个数
    """
    count = 0
    for num in numbers:
        if num % 2 == 0:  # 如果数字能被2整除，它就是偶数
            count += 1
    return count

# 测试函数
test_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("测试列表:", test_list)
# 输出: 测试列表: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

even_count = count_even_numbers(test_list)
print(f"列表中偶数的个数: {even_count}")
# 输出: 列表中偶数的个数: 5

# 逐步展示过程
print("\n过程演示:")
for num in test_list:
    if num % 2 == 0:
        print(f"{num} 是偶数")
    else:
        print(f"{num} 是奇数")

输出结果：

在这里插入图片描述

我们还可以使用Python的列表推导式来实现相同的功能，这样代码会更简洁：

def count_even_numbers_concise(numbers):
    return len([num for num in numbers if num % 2 == 0])

# 测试函数
test_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("测试列表:", test_list)
# 输出: 测试列表: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

even_count = count_even_numbers_concise(test_list)
print(f"列表中偶数的个数: {even_count}")
# 输出: 列表中偶数的个数: 5

# 显示列表推导式的结果
even_numbers = [num for num in test_list if num % 2 == 0]
print("所有偶数列表:", even_numbers)
# 输出: 所有偶数列表: [2, 4, 6, 8, 10]
print("偶数个数:", len(even_numbers))
# 输出: 偶数个数: 5

输出结果：

在这里插入图片描述

六、总结

在这一天的学习中，我们探索了Python中两个基本的数据结构：列表和元组。

  • 列表是 可变的，有序的 元素集合，提供了丰富的方法来添加、删除和修改元素。它适用于需要频繁修改的数据集合。

  • 元组是 不可变的，有序的 元素集合，一旦创建就不能修改。它适用于不需要修改的数据集合，如坐标、配置等。

两者都允许我们通过索引访问元素，使用切片获取子序列，并支持常见的操作如计数和查找。选择使用列表还是元组取决于你的具体需求和数据的特性。理解它们的异同将帮助你在Python编程中做出明智的选择。

练习题（将你的代码放到评论区）

  1. 创建一个包含前10个自然数的列表，然后使用切片获取其中的偶数。
  2. 编写一个函数，接收一个列表和一个元素，返回该元素在列表中出现的所有索引位置。
  3. 创建一个元组，包含你最喜欢的5种水果，然后尝试添加一个新水果，观察会发生什么。
  4. 编写一个程序，将一个列表中的元素按照奇数和偶数分组，生成两个新列表。
  5. 创建一个函数，接收一个列表，返回一个新列表，其中的元素都是原列表中的唯一元素（即删除重复项）。

下一篇，我们将探索Python中的另一种重要知识点：字典与集合。敬请期待！

创作者：Code_流苏(CSDN)（一个喜欢古诗词和编程的Coder😊）
如果你对今天的内容有任何问题，或者想分享你的学习心得，欢迎在评论区留言讨论！

相关文章：

  • 【大语言模型推理框架】VLLM
  • 左值与右值，空间与数据
  • Leetcode 3510. Minimum Pair Removal to Sort Array II
  • java基础自用笔记：文件、递归、常见的字符集、IO流
  • (done) 并行计算 CS149 Lecture1 (Why parallelism? Why efficiency?) (并行基本概念、硬件基础)
  • ctfshow VIP题目限免（后10题）
  • 消息队列(kafka 与 rocketMQ)
  • Llama 4 最新发布模型分析
  • rocketmq中的延迟队列使用详解
  • 深度学习图像分类数据集—十种西红柿病态叶识别分类
  • ISP算法从入门到精通：全面解析图像信号处理技术
  • 1Panel安装失败 国内docker安装失败
  • Qt -信号与槽
  • 第五章:架构安全性_《凤凰架构：构建可靠的大型分布式系统》
  • 掌握 JSON 到表格转换：全面指南
  • Neo4j基本命令使用
  • TPS入门DAY02 服务器篇
  • 剑指Offer（数据结构与算法面试题精讲）C++版——day6
  • lerobot[评估策略，训练策略]
  • C++ 标准库 vector（三十七）
  • 济南软件网站建设/广州网站优化步骤
  • 如何设计网站栏目/怎么在百度上推广自己的产品
  • 为什么网站突然打不开/宽带营销案例100例
  • 多媒体网站开发实战/西安seo引擎搜索优化
  • 黄页网址大全/涟源网站seo
  • 北京做网站好的公司/夜夜草