数据结构:List(列表)

引言

在前面的章节中,我们学习了三种基本的数据类型:

• 字符串(第3章):存储文字,比如“Hello“
• 数值(第4章):存储数字,比如42、3.14
• 布尔值(第5章):存储True或False

但是,如果我们想要存储多个数据呢?

比如:

• 存储一个班级所有学生的名字
• 存储一周7天的温度
• 存储购物清单上的所有商品

这时候,我们就需要一种新的数据类型:列表(List)。

列表(List)就像一个有顺序的容器,可以存放多个数据。它就像:

• 一串珍珠项链(每颗珍珠都是一个数据)
• 一列火车(每节车厢都是一个数据)
• 一个多层笔筒(每层都放一支笔)

这一章,我们将学习:

• 什么是列表
• 列表在计算机内存中是如何存储的
• 如何创建和使用列表
• 列表的基本操作(索引、切片、长度)
• 列表的常用方法(添加、删除、修改元素)
• 如何遍历列表
• 列表在数学中的应用(统计、排序)
• 元组(Tuple)简介

给家长的小贴士:

• 列表是Python中最常用的数据结构之一
• 可以用生活中的例子类比:购物清单、点名册、书架上的书
• 强调列表的“有序性“和“可变性“
• 本章会引入内存的概念,帮助孩子理解数据在计算机中的存储方式
• 鼓励孩子用列表解决实际问题(如记录朋友的名字)

列表在内存中的存储

在学习列表的操作之前,我们先来了解一个重要的问题:列表在计算机内存中是如何存储的?

什么是内存

还记得我们在第3章学过的“变量盒子“吗?每个变量都存储在计算机的内存(Memory)中。

内存就像一个巨大的储物柜,有很多个小格子(存储单元),每个格子都有一个编号,这个编号叫做地址。

内存示意图:
┌────┬────┬────┬────┬────┬────┬────┬────┐
│    │    │    │    │    │    │    │    │ ...
│ 0  │ 1  │ 2  │ 3  │ 4  │ 5  │ 6  │ 7  │  (内存地址)
└────┴────┴────┴────┴────┴────┴────┴────┘

重要特点:

• 每个格子都有唯一的地址编号
• 地址从0开始,依次递增
• 我们可以把数据存储在这些格子里

列表的连续存储

列表在内存中是连续存放的,这意味着列表的元素占据内存中相邻的格子。

示例:创建一个列表 numbers = [10, 20, 30, 40]

内存示意图:
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│     │     │     │     │     │     │     │     │
│ 10  │ 20  │ 30  │ 40  │ ... │     │     │     │
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
  ↑           ↑           ↑
地址: 1000     1004       1008
索引:   0           1          2

列表的"索引"就是从开头数的第几个
(这里假设每个数字占4个格子)

要点:

• 列表的元素在内存中挨着存放
• 索引0对应第一个元素,索引1对应第二个元素…
• 内存地址是连续的(比如1000, 1004, 1008…)

为什么列表要连续存储?

优点1:快速访问

• 因为元素是连续存放的,计算机可以通过索引快速计算出元素的内存地址
• 公式:元素地址 = 列表起始地址 + 索引 × 每个元素的大小
• 这就是为什么list[2]能立刻找到第三个元素!

优点2:内存利用率高

• 连续存储不会留下“空洞“
• 就像在电影院里,大家挨着坐,不浪费座位

缺点:插入和删除较慢

• 如果要在中间插入一个元素,需要把后面的元素都往后移动
• 就像排队时,中间插一个人,后面的人都要往后挪一步

给家长的小贴士:

• 这个概念比较抽象,可以用“电影院座位“类比
• 连续存储就像大家一起看电影,座位挨着
• 索引就像是“第几排第几座“
• 小学阶段只需要理解“列表是连续存放的“这个概念即可
• 不需要深入理解内存地址计算等细节

列表占用的内存

问题:一个列表占用多少内存?

答案:这取决于两个因素:

1. 元素的个数(列表长度)
2. 每个元素的大小(数据类型)

示例:

# 创建不同类型的列表
numbers = [1, 2, 3, 4, 5]        # 5个整数
names = ["小明", "小红", "小刚"]   # 3个字符串
mixed = [1, "你好", 3.14, True]   # 4个不同类型

内存占用估算(简化版):

• 整数(int):大约占用28个字节
• 小数(float):大约占用24个字节
• 字符串(str):占用字节数 = 字符数 + 一些额外开销

import sys  # 导入sys模块,用于查看内存占用

# 查看一个列表占用的字节数
numbers = [1, 2, 3, 4, 5]
print(f"列表占用内存:{sys.getsizeof(numbers)}字节")  # 约120字节

# 查看一个整数占用的字节数
print(f"一个整数占用内存:{sys.getsizeof(1)}字节")   # 约28字节

小练习:估算列表 [10, 20, 30, 40, 50] 占用的内存

• 5个整数 × 28字节 = 140字节
• 再加上列表本身的额外开销(大约40字节)
• 总共约180字节

给家长的小贴士:

• sys.getsizeof()函数可以查看Python对象占用的内存
• 这是一个很好的机会让孩子理解“数据占用空间“的概念
• 可以让孩子比较不同列表的内存占用,理解“空间换时间“的权衡
• 强调:不同的计算机系统可能略有差异

认识列表

什么是列表

列表是一个有序的数据集合,可以存储多个数据。列表中的每个数据称为元素(element)。

示例:

# 创建一个列表,存储几种水果
fruits = ["苹果", "香蕉", "橙子", "葡萄"]

print(fruits)  # 输出整个列表

运行结果:

['苹果', '香蕉', '橙子', '葡萄']

要点:

• 列表用方括号[]表示
• 元素之间用逗号,分隔
• 列表可以存储任意类型的数据
• 列表中的元素有顺序(从0开始编号)

创建列表的方法

方法1:直接创建列表

# 创建空列表
empty_list = []

# 创建有元素的列表
numbers = [1, 2, 3, 4, 5]
names = ["小明", "小红", "小刚"]
mixed = [1, "你好", 3.14, True]  # 混合类型

方法2:使用list()函数

# 创建空列表
empty_list = list()

# 从字符串创建列表(字符串也是特殊的列表!)
chars = list("Hello")  # ['H', 'e', 'l', 'l', 'o']

给家长的小贴士:

• 空列表[]是创建列表的常用方式
• 列表可以混合不同类型的数据(但实际编程中通常放同类型数据)
• 可以用type()函数验证变量类型
• 让孩子试试创建自己的列表(如喜欢的颜色、朋友的名字)

列表的特点

特点1:有序性

# 顺序不同,就是不同的列表
list1 = [1, 2, 3]
list2 = [3, 2, 1]

print(list1 == list2)  # False(顺序不同,不相等)

特点2:可变性

# 列表可以修改
fruits = ["苹果", "香蕉", "橙子"]
fruits[0] = "草莓"  # 修改第一个元素
print(fruits)  # ['草莓', '香蕉', '橙子']

特点3:可重复

# 列表可以有重复元素
numbers = [1, 2, 2, 3, 3, 3]
print(numbers)  # [1, 2, 2, 3, 3, 3]

练习1:创建你自己的列表

题目:创建一个列表,存储你最喜欢的5种食物。

# 创建食物列表
favorite_foods = ["披萨", "冰淇淋", "汉堡", "寿司", "巧克力"]

print("我最喜欢的食物:")
print(favorite_foods)

访问列表元素

索引(Index)

列表中的每个元素都有一个编号,叫做索引(index)。索引从0开始,不是从1开始!

索引示意图:

列表:  ["苹果", "香蕉", "橙子", "葡萄"]
索引:    0      1      2      3

反向索引: -4     -3     -2     -1

内存地址示意:

内存:   [地址1] [地址2] [地址3] [地址4]
        ["苹果"] ["香蕉"] ["橙子"] ["葡萄"]
索引:      0       1       2       3

示例1:正向索引(从0开始)

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

print(fruits[0])  # 苹果(第一个元素)
print(fruits[1])  # 香蕉(第二个元素)
print(fruits[2])  # 橙子(第三个元素)
print(fruits[3])  # 葡萄(第四个元素)

示例2:反向索引(从-1开始)

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

print(fruits[-1])  # 葡萄(倒数第一个)
print(fruits[-2])  # 橙子(倒数第二个)
print(fruits[-3])  # 香蕉(倒数第三个)
print(fruits[-4])  # 苹果(倒数第四个)

给家长的小贴士:

• 重要:Python的索引从0开始,这是初学者最容易犯错的地方!
• 用“楼层数“类比:地面是0层,1楼是第1层
• 反向索引从-1开始:-1是最后一个,-2是倒数第2个
• 可以画图帮助孩子理解索引和位置的关系
• 强调:索引是相对于列表开头的“偏移量“

索引与内存地址的关系

深入理解:索引实际上就是相对于列表起始位置的“偏移量“

假设列表从内存地址1000开始:
每个元素占用8个字节(假设)

索引0:地址 = 1000 + 0×8 = 1000
索引1:地址 = 1000 + 1×8 = 1008
索引2:地址 = 1000 + 2×8 = 1016
索引3:地址 = 1000 + 3×8 = 1024

这就是为什么通过索引可以快速找到元素!

代码示例:

# 查看列表的内存地址
import sys

numbers = [10, 20, 30, 40]

# 打印列表的内存地址(十六进制)
print(f"列表的内存地址:{id(numbers)}")

# 打印每个元素的索引和值
for i in range(len(numbers)):
    print(f"索引{i}:值{numbers[i]}")

给家长的小贴士:

• 这个概念比较深,小学阶段只需要简单了解
• 核心思想:索引是用来“计算“内存位置的
• 这解释了为什么列表访问很快(O(1)时间复杂度)
• 不需要孩子掌握内存地址计算的细节

索引越界(IndexError)

如果访问一个不存在的索引,Python会报错:IndexError(索引错误)。

错误示例:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 这个列表有4个元素,索引是0, 1, 2, 3
print(fruits[4])  # 错误!索引4不存在!

错误信息:

IndexError: list index out of range

解释:

• 列表有4个元素,索引范围是0到3
• 访问索引4会越界
• 就像你想住5号房间,但宾馆只有4层楼

避免索引越界的方法:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 方法1:使用len()检查索引范围
if len(fruits) > 4:
    print(fruits[4])
else:
    print("索引4不存在")

# 方法2:使用反向索引(更安全)
print(fruits[-1])  # 最后一个元素

实践1:访问列表元素

题目:给定一个列表,完成以下任务。

# 学生成绩列表
scores = [85, 92, 78, 95, 88]

任务:

1. 打印第一个成绩
2. 打印最后一个成绩
3. 打印中间的成绩(第3个)
4. 打印倒数第二个成绩

# 学生成绩列表
scores = [85, 92, 78, 95, 88]

# 1. 第一个成绩
print(f"第一个成绩:{scores[0]}")  # 85

# 2. 最后一个成绩
print(f"最后一个成绩:{scores[-1]}")  # 88

# 3. 中间的成绩(第3个)
print(f"第3个成绩:{scores[2]}")  # 78

# 4. 倒数第二个成绩
print(f"倒数第二个成绩:{scores[-2]}")  # 95

第一个成绩:85
最后一个成绩:88
第3个成绩:78
倒数第二个成绩:95

练习2:索引练习

题目:下面的程序会输出什么?

colors = ["红", "橙", "黄", "绿", "青", "蓝", "紫"]

print(colors[2])
print(colors[-3])
print(colors[0])
print(colors[-1])

黄
绿
红
紫

切片(Slice)

切片可以获取列表的一部分,创建一个新的列表。

切片语法:list[start:end:step]

• start:起始索引(包含)
• end:结束索引(不包含!)
• step:步长(可选,默认为1)

基本切片

示例1:获取前几个元素

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

# 获取前3个元素(索引0, 1, 2)
print(numbers[0:3])  # [0, 1, 2]

# 简写:省略起始索引0
print(numbers[:3])  # [0, 1, 2]

示例2:获取中间的元素

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

# 获取索引2到6的元素(不包含6)
print(numbers[2:6])  # [2, 3, 4, 5]

示例3:获取后几个元素

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

# 获取最后3个元素
print(numbers[-3:])  # [7, 8, 9]

# 获取从索引7到最后的元素
print(numbers[7:])  # [7, 8, 9]

示例4:获取整个列表

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

# 方法1:省略start和end
print(numbers[:])  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 方法2:使用完整范围
print(numbers[0:len(numbers)])  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

带步长的切片

示例1:每隔几个元素取一个

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

# 每隔2个取一个(取索引0, 2, 4, 6, 8)
print(numbers[::2])  # [0, 2, 4, 6, 8]

# 每隔3个取一个
print(numbers[::3])  # [0, 3, 6, 9]

示例2:反向切片

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

# 反向列表(步长为-1)
print(numbers[::-1])  # [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  5  6  7  8  9

切片 [2:6]:
       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
              ↑        ↑
            start     end(不包含)
结果:          [2, 3, 4, 5]

练习3:切片练习

题目:预测下面的切片结果。

letters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']

# 预测结果
print(letters[2:5])
print(letters[:4])
print(letters[5:])
print(letters[::2])
print(letters[::-1])

['C', 'D', 'E']
['A', 'B', 'C', 'D']
['F', 'G', 'H']
['A', 'C', 'E', 'G']
['H', 'G', 'F', 'E', 'D', 'C', 'B', 'A']

列表的长度

使用len()函数可以获取列表中元素的个数。

示例:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 获取长度
print(len(fruits))  # 4

# 空列表的长度
empty_list = []
print(len(empty_list))  # 0

为什么长度很重要

场景1:避免索引越界

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 错误:直接访问可能不存在的索引
# print(fruits[10])  # IndexError!

# 正确:先检查长度
if len(fruits) > 10:
    print(fruits[10])
else:
    print("索引10不存在")

场景2:循环访问所有元素

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 使用range和len循环
for i in range(len(fruits)):
    print(f"索引{i}:{fruits[i]}")

输出:

索引0:苹果
索引1:香蕉
索引2:橙子
索引3:葡萄

实践2:使用长度

题目:打印列表的所有元素,格式为“第i个元素是:xxx“。

animals = ["猫", "狗", "兔子", "仓鼠"]

animals = ["猫", "狗", "兔子", "仓鼠"]

# 使用range和len
for i in range(len(animals)):
    print(f"第{i + 1}个元素是:{animals[i]}")

第1个元素是:猫
第2个元素是:狗
第3个元素是:兔子
第4个元素是:仓鼠

修改列表元素

列表是可变的(mutable),这意味着我们可以修改、添加或删除元素。

修改单个元素

语法:list[index] = new_value

示例:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 修改第1个元素(索引0)
fruits[0] = "草莓"
print(fruits)  # ['草莓', '香蕉', '橙子', '葡萄']

# 修改最后一个元素
fruits[-1] = "西瓜"
print(fruits)  # ['草莓', '香蕉', '橙子', '西瓜']

修改多个元素(使用切片)

示例1:用切片修改

numbers = [0, 1, 2, 3, 4, 5]

# 修改索引2到4的元素
numbers[2:5] = [20, 30, 40]
print(numbers)  # [0, 1, 20, 30, 40, 5]

示例2:替换不同数量的元素

numbers = [0, 1, 2, 3, 4, 5]

# 用2个元素替换3个元素
numbers[1:4] = [10, 20]
print(numbers)  # [0, 10, 20, 4, 5]

# 用4个元素替换2个元素
numbers[1:3] = [100, 200, 300, 400]
print(numbers)  # [0, 100, 200, 300, 400, 4, 5]

练习4:修改列表

题目:完成以下任务。

scores = [85, 92, 78, 95, 88]

1. 将第一个成绩修改为90
2. 将最后一个成绩修改为100
3. 将中间三个成绩修改为80, 85, 90

scores = [85, 92, 78, 95, 88]

# 1. 修改第一个成绩
scores[0] = 90
print(f"第一次修改后:{scores}")  # [90, 92, 78, 95, 88]

# 2. 修改最后一个成绩
scores[-1] = 100
print(f"第二次修改后:{scores}")  # [90, 92, 78, 95, 100]

# 3. 修改中间三个成绩
scores[1:4] = [80, 85, 90]
print(f"第三次修改后:{scores}")  # [90, 80, 85, 90, 100]

列表的常用方法

Python提供了很多列表方法(list methods),帮助我们方便地操作列表。

添加元素

append():在末尾添加元素

语法:list.append(item)

示例:

fruits = ["苹果", "香蕉"]

# 在末尾添加一个元素
fruits.append("橙子")
print(fruits)  # ['苹果', '香蕉', '橙子']

fruits.append("葡萄")
print(fruits)  # ['苹果', '香蕉', '橙子', '葡萄']

insert():在指定位置插入元素

语法:list.insert(index, item)

示例:

fruits = ["苹果", "香蕉", "葡萄"]

# 在索引1的位置插入"橙子"
fruits.insert(1, "橙子")
print(fruits)  # ['苹果', '橙子', '香蕉', '葡萄']

# 在开头插入
fruits.insert(0, "草莓")
print(fruits)  # ['草莓', '苹果', '橙子', '香蕉', '葡萄']

extend():合并两个列表

语法:list.extend(other_list)

示例:

fruits = ["苹果", "香蕉"]
more_fruits = ["橙子", "葡萄", "西瓜"]

# 将more_fruits的所有元素添加到fruits
fruits.extend(more_fruits)
print(fruits)  # ['苹果', '香蕉', '橙子', '葡萄', '西瓜']

对比append和extend:

list1 = [1, 2]
list2 = [3, 4]

# append:将list2作为一个元素添加
list1.append(list2)
print(list1)  # [1, 2, [3, 4]]

# extend:将list2的元素展开添加
list1 = [1, 2]
list1.extend(list2)
print(list1)  # [1, 2, 3, 4]

删除元素

del:根据索引删除

语法:del list[index]

示例:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 删除索引1的元素
del fruits[1]
print(fruits)  # ['苹果', '橙子', '葡萄']

# 删除第一个元素
del fruits[0]
print(fruits)  # ['橙子', '葡萄']

remove():根据值删除

语法:list.remove(value)

示例:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 删除值为"香蕉"的元素
fruits.remove("香蕉")
print(fruits)  # ['苹果', '橙子', '葡萄']

注意:如果值不存在,会报错ValueError。

安全的删除方法:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 先检查是否存在
if "西瓜" in fruits:
    fruits.remove("西瓜")
else:
    print("西瓜不在列表中")

pop():删除并返回元素

语法:list.pop(index)(默认删除最后一个)

示例:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 删除最后一个元素
last_fruit = fruits.pop()
print(last_fruit)  # 葡萄
print(fruits)  # ['苹果', '香蕉', '橙子']

# 删除指定索引的元素
second_fruit = fruits.pop(1)
print(second_fruit)  # 香蕉
print(fruits)  # ['苹果', '橙子']

排序

sort():原地排序

语法:list.sort()(默认升序)

示例:

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# 升序排序
numbers.sort()
print(numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]

# 降序排序
numbers.sort(reverse=True)
print(numbers)  # [9, 6, 5, 4, 3, 2, 1, 1]

字符串排序:

fruits = ["香蕉", "苹果", "橙子", "葡萄"]

# 按字母顺序排序
fruits.sort()
print(fruits)  # ['葡萄', '橙子', '苹果', '香蕉']

sorted():返回新列表

语法:sorted(list)

示例:

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# sorted返回新列表,原列表不变
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]
print(numbers)  # [3, 1, 4, 1, 5, 9, 2, 6](原列表不变)

反转

reverse():原地反转

numbers = [1, 2, 3, 4, 5]

numbers.reverse()
print(numbers)  # [5, 4, 3, 2, 1]

其他常用方法

给家长的小贴士:

• 列表方法分为“原地修改“和“返回新列表“两种
• append、insert、extend、sort、reverse是原地修改
• sorted返回新列表,原列表不变
• 强调in和not in的用法,非常实用
• 可以制作方法卡片,让孩子随时查阅

实践3:列表方法综合练习

题目:完成以下任务。

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

1. 在末尾添加数字8
2. 在开头添加数字0
3. 删除值为1的第一个元素
4. 统计数字1出现的次数
5. 判断数字7是否在列表中
6. 对列表进行升序排序

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# 1. 在末尾添加数字8
numbers.append(8)
print(f"添加8后:{numbers}")  # [3, 1, 4, 1, 5, 9, 2, 6, 8]

# 2. 在开头添加数字0
numbers.insert(0, 0)
print(f"添加0后:{numbers}")  # [0, 3, 1, 4, 1, 5, 9, 2, 6, 8]

# 3. 删除值为1的第一个元素
numbers.remove(1)
print(f"删除1后:{numbers}")  # [0, 3, 4, 1, 5, 9, 2, 6, 8]

# 4. 统计数字1出现的次数
count = numbers.count(1)
print(f"数字1出现{count}次")  # 数字1出现1次

# 5. 判断数字7是否在列表中
if 7 in numbers:
    print("数字7在列表中")
else:
    print("数字7不在列表中")

# 6. 对列表进行升序排序
numbers.sort()
print(f"排序后:{numbers}")  # [0, 1, 2, 3, 4, 5, 6, 8, 9]

遍历列表

遍历(Traverse)就是依次访问列表中的每个元素。我们有两种主要方式来遍历列表。

方式1:遍历元素(不需要索引)

语法:

for item in list:
    # 处理item

示例:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 直接遍历元素
for fruit in fruits:
    print(f"我喜欢吃{fruit}")

输出:

我喜欢吃苹果
我喜欢吃香蕉
我喜欢吃橙子
我喜欢吃葡萄

适用场景:

• 只需要访问元素,不需要知道索引
• 对每个元素执行相同的操作

方式2:遍历索引(需要索引)

语法:

for i in range(len(list)):
    # 通过list[i]访问元素

示例:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 遍历索引
for i in range(len(fruits)):
    print(f"索引{i}:{fruits[i]}")

输出:

索引0:苹果
索引1:香蕉
索引2:橙子
索引3:葡萄

适用场景:

• 需要修改列表元素
• 需要知道元素的索引位置
• 需要同时访问多个列表

方式3:同时获取索引和元素(enumerate)

语法:

for index, item in enumerate(list):
    # index是索引,item是元素

示例:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 使用enumerate同时获取索引和元素
for index, fruit in enumerate(fruits):
    print(f"索引{index}:{fruit}")

输出:

索引0:苹果
索引1:香蕉
索引2:橙子
索引3:葡萄

enumerate的起始索引参数:

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 从1开始编号
for index, fruit in enumerate(fruits, start=1):
    print(f"第{index}个:{fruit}")

输出:

第1个:苹果
第2个:香蕉
第3个:橙子
第4个:葡萄

两种遍历方式的对比

场景1:只需要访问元素

# 推荐:遍历元素
for fruit in fruits:
    print(fruit)

场景2:需要修改元素

# 推荐:遍历索引
for i in range(len(scores)):
    scores[i] = scores[i] + 5  # 每个成绩加5分

场景3:需要索引和元素

# 推荐:使用enumerate
for i, fruit in enumerate(fruits):
    print(f"索引{i}:{fruit}")

给家长的小贴士:

• 重要:遍历时如果需要修改元素,必须用索引方式
• 遍历元素更简洁,但无法修改元素
• enumerate是Python特有的,非常实用
• 可以让孩子对比三种方式,理解它们的区别
• 强调“从需求出发选择遍历方式“

练习5:遍历列表

题目1:计算列表中所有成绩的平均值。

scores = [85, 92, 78, 95, 88]

scores = [85, 92, 78, 95, 88]

# 方法1:遍历元素
total = 0
for score in scores:
    total = total + score

average = total / len(scores)
print(f"平均成绩:{average}")  # 平均成绩:87.6

# 方法2:使用sum函数(更简洁)
average = sum(scores) / len(scores)
print(f"平均成绩:{average}")  # 平均成绩:87.6

题目2:将列表中所有偶数乘以2。

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 需要修改元素,使用索引遍历
for i in range(len(numbers)):
    if numbers[i] % 2 == 0:  # 如果是偶数
        numbers[i] = numbers[i] * 2

print(numbers)  # [1, 4, 3, 8, 5, 12, 7, 16, 9, 20]

题目3:打印列表及其索引(从1开始)。

colors = ["红", "橙", "黄", "绿", "蓝"]

colors = ["红", "橙", "黄", "绿", "蓝"]

# 使用enumerate,从1开始
for i, color in enumerate(colors, start=1):
    print(f"第{i}种颜色:{color}")

第1种颜色:红
第2种颜色:橙
第3种颜色:黄
第4种颜色:绿
第5种颜色:蓝

数学应用:统计数据

列表在数学中有很多应用,特别是统计相关的问题。让我们用列表来解决一些数学问题!

基本统计量

在数学课上,你学过以下统计量:

• 平均数(Mean):所有数的和除以个数
• 中位数(Median):排序后中间的数
• 众数(Mode):出现次数最多的数
• 最大值(Max):最大的数
• 最小值(Min):最小的数
• 极差(Range):最大值减最小值

应用1:计算平均数

数学定义: $$ \text{平均数} = \frac{\text{所有数的总和}}{\text{数的个数}} $$

Python实现:

# 方法1:手动计算
scores = [85, 92, 78, 95, 88]

total = 0
for score in scores:
    total = total + score

average = total / len(scores)
print(f"平均数:{average}")  # 平均数:87.6

# 方法2:使用sum函数
average = sum(scores) / len(scores)
print(f"平均数:{average}")  # 平均数:87.6

应用2:找出最大值和最小值

Python实现:

scores = [85, 92, 78, 95, 88]

# 使用内置函数
max_score = max(scores)
min_score = min(scores)

print(f"最大值:{max_score}")  # 最大值:95
print(f"最小值:{min_score}")  # 最小值:78

# 计算极差
range_ = max_score - min_score
print(f"极差:{range_}")  # 极差:17

应用3:计算中位数

数学定义:

• 如果有奇数个数,中位数就是中间的数
• 如果有偶数个数,中位数就是中间两个数的平均数

示例:

# 奇数个元素
numbers1 = [1, 3, 5, 7, 9]
# 中位数是5(第3个数)

# 偶数个元素
numbers2 = [1, 3, 5, 7, 9, 11]
# 中位数是(5+7)/2=6(第3和第4个数的平均)

Python实现:

def calculate_median(numbers):
    # 先排序
    sorted_numbers = sorted(numbers)
    n = len(sorted_numbers)

    # 奇数个元素
    if n % 2 == 1:
        median = sorted_numbers[n // 2]
    # 偶数个元素
    else:
        middle1 = sorted_numbers[n // 2 - 1]
        middle2 = sorted_numbers[n // 2]
        median = (middle1 + middle2) / 2

    return median

# 测试奇数个
numbers1 = [1, 3, 5, 7, 9]
print(f"中位数:{calculate_median(numbers1)}")  # 中位数:5

# 测试偶数个
numbers2 = [1, 3, 5, 7, 9, 11]
print(f"中位数:{calculate_median(numbers2)}")  # 中位数:6.0

应用4:找众数

数学定义:众数是出现次数最多的数。

Python实现:

def find_mode(numbers):
    # 统计每个数出现的次数
    count_dict = {}
    for num in numbers:
        if num in count_dict:
            count_dict[num] = count_dict[num] + 1
        else:
            count_dict[num] = 1

    # 找出出现次数最多的数
    max_count = 0
    mode = numbers[0]
    for num, count in count_dict.items():
        if count > max_count:
            max_count = count
            mode = num

    return mode

# 测试
numbers = [1, 2, 2, 3, 3, 3, 4]
print(f"众数:{find_mode(numbers)}")  # 众数:3

给家长的小贴士:

• 这是很好的机会,用编程巩固数学知识
• 可以让孩子手动计算,再用程序验证
• 强调:数学公式和编程实现的对应关系
• 如果孩子还没学过中位数和众数,可以先跳过
• 鼓励孩子用列表解决实际问题(如统计考试成绩)

实践4:数学统计练习

题目:给定一组成绩,完成以下统计。

scores = [85, 92, 78, 95, 88, 65, 72, 58, 90, 82]

任务:

1. 计算平均分
2. 找出最高分和最低分
3. 计算极差
4. 统计及格人数(≥60分)
5. 将成绩从低到高排序

scores = [85, 92, 78, 95, 88, 65, 72, 58, 90, 82]

# 1. 计算平均分
average = sum(scores) / len(scores)
print(f"平均分:{average:.1f}")  # 平均分:80.5

# 2. 找出最高分和最低分
max_score = max(scores)
min_score = min(scores)
print(f"最高分:{max_score}")  # 最高分:95
print(f"最低分:{min_score}")  # 最低分:58

# 3. 计算极差
range_ = max_score - min_score
print(f"极差:{range_}")  # 极差:37

# 4. 统计及格人数
pass_count = 0
for score in scores:
    if score >= 60:
        pass_count = pass_count + 1

print(f"及格人数:{pass_count}")  # 及格人数:9

# 5. 排序
sorted_scores = sorted(scores)
print(f"排序后:{sorted_scores}")
# [58, 65, 72, 78, 82, 85, 88, 90, 92, 95]

数学应用:数列

列表非常适合表示数列。在数学中,数列是按照一定规律排列的一列数。

等差数列

数学定义:相邻两项的差相等(公差d)。

示例:

2, 5, 8, 11, 14, ...
公差是3(每个数比前一个数大3)

Python生成等差数列:

# 生成前n项等差数列
def arithmetic_sequence(a1, d, n):
    """生成首项为a1,公差为d,共n项的等差数列"""
    sequence = []
    for i in range(n):
        term = a1 + i * d
        sequence.append(term)
    return sequence

# 示例:首项2,公差3,共10项
seq = arithmetic_sequence(2, 3, 10)
print(seq)
# [2, 5, 8, 11, 14, 17, 20, 23, 26, 29]

等差数列求和:

def sum_arithmetic_sequence(a1, d, n):
    """计算等差数列前n项和"""
    # 公式:和 = (首项 + 末项) × 项数 / 2
    an = a1 + (n - 1) * d  # 末项
    total = (a1 + an) * n // 2
    return total

# 示例:1+2+3+...+100
total = sum_arithmetic_sequence(1, 1, 100)
print(f"1+2+3+...+100={total}")  # 1+2+3+...+100=5050

等比数列

数学定义:相邻两项的比相等(公比q)。

示例:

2, 4, 8, 16, 32, ...
公比是2(每个数是前一个数的2倍)

Python生成等比数列:

def geometric_sequence(a1, q, n):
    """生成首项为a1,公比为q,共n项的等比数列"""
    sequence = []
    term = a1
    for i in range(n):
        sequence.append(term)
        term = term * q
    return sequence

# 示例:首项2,公比2,共10项
seq = geometric_sequence(2, 2, 10)
print(seq)
# [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]

斐波那契数列

数学定义:

• 第1项是1
• 第2项是1
• 从第3项开始,每项等于前两项之和

1, 1, 2, 3, 5, 8, 13, 21, ...

Python生成斐波那契数列:

def fibonacci(n):
    """生成前n项斐波那契数列"""
    if n <= 0:
        return []
    elif n == 1:
        return [1]
    elif n == 2:
        return [1, 1]

    sequence = [1, 1]
    for i in range(2, n):
        next_term = sequence[-1] + sequence[-2]
        sequence.append(next_term)

    return sequence

# 示例:前15项
fib = fibonacci(15)
print(fib)
# [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]

练习6:数列练习

题目1:生成从1到100的所有偶数,并计算它们的和。

# 方法1:使用range
evens = list(range(2, 101, 2))  # 从2开始,每次加2,到100
print(f"偶数列表:{evens}")

total = sum(evens)
print(f"偶数和:{total}")  # 偶数和:2550

# 方法2:使用循环
evens = []
for i in range(1, 51):
    evens.append(2 * i)

print(f"偶数列表:{evens}")
print(f"偶数和:{sum(evens)}")  # 偶数和:2550

题目2:生成2的n次方数列(1, 2, 4, 8, 16, …),共10项。

# 生成2的n次方数列
powers = []
for i in range(10):
    powers.append(2 ** i)

print(f"2的n次方数列:{powers}")
# [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

# 计算总和
total = sum(powers)
print(f"总和:{total}")  # 总和:1023

题目3:找出100以内所有能被3整除的数,并统计个数。

# 方法1:使用range和list
multiples_of_3 = list(range(3, 101, 3))
print(f"能被3整除的数:{multiples_of_3}")
print(f"共{len(multiples_of_3)}个")  # 共33个

# 方法2:使用循环
multiples_of_3 = []
for i in range(1, 101):
    if i % 3 == 0:
        multiples_of_3.append(i)

print(f"能被3整除的数:{multiples_of_3}")
print(f"共{len(multiples_of_3)}个")  # 共33个

列表的综合应用

应用1:统计成绩分布

题目:给定一组成绩,统计不同等级的人数。

scores = [85, 92, 78, 95, 88, 65, 72, 58, 90, 82]

等级标准:

• 优秀:≥90分
• 良好:80-89分
• 及格:60-79分
• 不及格:<60分

scores = [85, 92, 78, 95, 88, 65, 72, 58, 90, 82]

# 统计各等级人数
excellent = 0  # 优秀(>=90)
good = 0       # 良好(80-89)
pass_ = 0      # 及格(60-79)
fail = 0       # 不及格(<60)

for score in scores:
    if score >= 90:
        excellent = excellent + 1
    elif score >= 80:
        good = good + 1
    elif score >= 60:
        pass_ = pass_ + 1
    else:
        fail = fail + 1

print("===== 成绩分布 =====")
print(f"优秀(≥90):{excellent}人")  # 优秀:3人
print(f"良好(80-89):{good}人")     # 良好:4人
print(f"及格(60-79):{pass_}人")     # 及格:2人
print(f"不及格(<60):{fail}人")      # 不及格:1人

===== 成绩分布 =====
优秀(≥90):3人
良好(80-89):4人
及格(60-79):2人
不及格(<60):1人

应用2:找最大值及其索引

题目:找出列表中的最大值及其索引位置。

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# 方法1:使用max和index
max_value = max(numbers)
max_index = numbers.index(max_value)
print(f"最大值:{max_value},索引:{max_index}")
# 输出:最大值:9,索引:5

# 方法2:手动查找(理解算法)
max_value = numbers[0]
max_index = 0

for i in range(1, len(numbers)):
    if numbers[i] > max_value:
        max_value = numbers[i]
        max_index = i

print(f"最大值:{max_value},索引:{max_index}")
# 输出:最大值:9,索引:5

应用3:列表倒序

题目:将列表倒序,不使用reverse方法。

numbers = [1, 2, 3, 4, 5]

numbers = [1, 2, 3, 4, 5]

# 方法1:创建新列表
reversed_numbers = []
for i in range(len(numbers) - 1, -1, -1):  # 从最后一个到第一个
    reversed_numbers.append(numbers[i])

print(reversed_numbers)  # [5, 4, 3, 2, 1]

# 方法2:交换位置(原地修改)
for i in range(len(numbers) // 2):
    # 交换第i个和倒数第i个
    temp = numbers[i]
    numbers[i] = numbers[len(numbers) - 1 - i]
    numbers[len(numbers) - 1 - i] = temp

print(numbers)  # [5, 4, 3, 2, 1]

# 方法3:使用切片(最简洁)
print(numbers[::-1])  # [5, 4, 3, 2, 1]

字符串也是特殊的列表

在第3章我们学习了字符串,其实字符串也是一种特殊的列表!

字符串的列表特性

相似之处:

# 字符串可以像列表一样使用索引和切片
text = "Hello"

# 索引
print(text[0])  # H
print(text[-1])  # o

# 切片
print(text[1:4])  # ell
print(text[::-1])  # olleH(反向)

# 长度
print(len(text))  # 5

# 遍历
for char in text:
    print(char)

不同之处:

# 字符串是不可变的(immutable)
text = "Hello"

# 错误!不能修改字符串
# text[0] = "h"  # TypeError!

# 列表是可变的
numbers = [1, 2, 3]
numbers[0] = 10  # 可以修改
print(numbers)  # [10, 2, 3]

字符串和列表的转换

字符串 → 列表(list)

# 将字符串转换为字符列表
text = "Hello"
chars = list(text)
print(chars)  # ['H', 'e', 'l', 'l', 'o']

# 分割字符串为单词列表
sentence = "I love Python"
words = sentence.split()  # 按空格分割
print(words)  # ['I', 'love', 'Python']

# 按指定字符分割
date = "2024-02-14"
parts = date.split("-")
print(parts)  # ['2024', '02', '14']

列表 → 字符串(join)

# 将字符列表连接为字符串
chars = ['H', 'e', 'l', 'l', 'o']
text = "".join(chars)
print(text)  # Hello

# 用指定字符连接
words = ["I", "love", "Python"]
sentence = " ".join(words)
print(sentence)  # I love Python

# 用其他字符连接
parts = ["2024", "02", "14"]
date = "-".join(parts)
print(date)  # 2024-02-14

给家长的小贴士:

• 强调字符串和列表的相似性,帮助孩子理解
• 用“珍珠项链“类比:字符串是焊死的,列表是可拆卸的
• split和join是非常实用的方法,重点讲解
• 可以让孩子用split和join处理文本(如句子、日期)

实践5:字符串和列表转换

题目1:统计一个句子中有多少个单词。

sentence = "I love Python programming"

sentence = "I love Python programming"

# 方法1:使用split
words = sentence.split()
word_count = len(words)
print(f"单词数量:{word_count}")  # 单词数量:4

# 方法2:手动统计(计算空格+1)
space_count = 0
for char in sentence:
    if char == " ":
        space_count = space_count + 1

word_count = space_count + 1
print(f"单词数量:{word_count}")  # 单词数量:4

题目2:反转一个字符串。

text = "Hello"

text = "Hello"

# 方法1:使用切片
reversed_text = text[::-1]
print(reversed_text)  # olleH

# 方法2:转换为列表,反转,再连接
chars = list(text)
chars.reverse()
reversed_text = "".join(chars)
print(reversed_text)  # olleH

# 方法3:手动构建
reversed_text = ""
for i in range(len(text) - 1, -1, -1):
    reversed_text = reversed_text + text[i]

print(reversed_text)  # olleH

元组(Tuple)简介

元组(Tuple)是另一种有序的数据结构,它和列表非常相似,但有一个关键区别:元组是不可变的(immutable)。

元组的创建

语法:使用圆括号()代替方括号[]

# 创建元组
empty_tuple = ()  # 空元组
numbers = (1, 2, 3, 4, 5)
fruits = ("苹果", "香蕉", "橙子")

# 单个元素的元组(注意逗号!)
single = (1,)  # 必须有逗号
print(type(single))  # <class 'tuple'>

# 如果没有逗号,就不是元组
not_tuple = (1)
print(type(not_tuple))  # <class 'int'>

元组和列表的对比

示例:

# 列表:可以修改
list1 = [1, 2, 3]
list1[0] = 10
print(list1)  # [10, 2, 3]

# 元组:不能修改
tuple1 = (1, 2, 3)
# tuple1[0] = 10  # TypeError!'tuple' object does not support item assignment

元组的常见用途

用途1:返回多个值

# 函数返回多个值(实际上是返回元组)
def get_user_info():
    name = "小明"
    age = 10
    grade = 5
    return name, age, grade  # 返回元组

user_info = get_user_info()
print(user_info)  # ('小明', 10, 5)

# 解包
name, age, grade = get_user_info()
print(f"姓名:{name},年龄:{age},年级:{grade}")

用途2:保护数据不被修改

# 常量配置
CONFIG = ("localhost", 8080, "admin")
# CONFIG[0] = "192.168.1.1"  # 错误!不能修改

用途3:字典的键

# 元组可以作为字典的键(后续章节学习)
coordinates = {(10, 20): "点A", (30, 40): "点B"}
# 列表不能作为字典的键

给家长的小贴士:

• 元组和列表的主要区别是“可变vs不可变“
• 用“相册“类比:元组是洗出来的照片,列表是电子相册
• 强调元组的不可变性,这是它存在的意义
• 元组通常用于“不应该被修改“的数据

常见错误和调试

错误1:索引越界

错误代码:

fruits = ["苹果", "香蕉", "橙子"]
print(fruits[3])  # IndexError!

原因:索引3不存在(有效索引是0, 1, 2)

修正:

fruits = ["苹果", "香蕉", "橙子"]

# 方法1:检查索引
if len(fruits) > 3:
    print(fruits[3])
else:
    print("索引3不存在")

# 方法2:使用反向索引
print(fruits[-1])  # 最后一个元素

错误2:缩进错误

错误代码:

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
print(fruit)  # IndentationError!

原因:for循环的循环体必须缩进

修正:

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(fruit)  # 正确缩进

错误3:修改正在遍历的列表

问题代码:

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)  # 危险!
print(numbers)  # 结果可能不正确

原因:遍历时修改列表会导致索引混乱

修正:

# 方法1:创建新列表
numbers = [1, 2, 3, 4, 5]
odd_numbers = []
for num in numbers:
    if num % 2 != 0:  # 只保留奇数
        odd_numbers.append(num)
numbers = odd_numbers
print(numbers)  # [1, 3, 5]

# 方法2:遍历副本
numbers = [1, 2, 3, 4, 5]
for num in numbers[:]:  # 遍历副本
    if num % 2 == 0:
        numbers.remove(num)
print(numbers)  # [1, 3, 5]

错误4:混淆append和extend

错误代码:

list1 = [1, 2]
list2 = [3, 4]
list1.append(list2)  # 本想合并,结果嵌套了
print(list1)  # [1, 2, [3, 4]](不是想要的!)

修正:

list1 = [1, 2]
list2 = [3, 4]

# 方法1:使用extend
list1.extend(list2)
print(list1)  # [1, 2, 3, 4]

# 方法2:使用+
list1 = [1, 2]
list2 = [3, 4]
list3 = list1 + list2
print(list3)  # [1, 2, 3, 4]

给家长的小贴士:

• 索引越界是最常见的错误,教孩子学会检查长度
• 缩进错误是初学者常犯的,强调Python对缩进的要求
• 遍历时修改列表是高级错误,建议使用新列表
• 鼓励孩子使用print调试法:打印中间结果

章节小结

我们学到了什么

1. 列表的概念:

   • 列表是有序的数据集合
   • 列表用方括号[]表示
   • 列表可以存储任意类型的数据
   • 列表是可变的(可以修改)

2. 列表在内存中的存储:

   • 列表在内存中连续存放
   • 索引是相对于起始位置的偏移量
   • 通过索引可以快速访问元素
   • 列表长度影响内存占用

3. 列表的基本操作:

   • 创建列表:[]或list()
   • 访问元素:使用索引(从0开始)
   • 切片:list[start:end:step]
   • 获取长度:len(list)

4. 列表的方法:

   • 添加元素:append(), insert(), extend()
   • 删除元素:del, remove(), pop()
   • 排序:sort(), sorted()
   • 其他:count(), index(), reverse()

5. 遍历列表:

   • 遍历元素:for item in list
   • 遍历索引:for i in range(len(list))
   • 同时获取索引和元素:enumerate(list)

6. 数学应用:

   • 统计量:平均数、中位数、众数、最大值、最小值
   • 数列:等差数列、等比数列、斐波那契数列
   • 数据排序和查找

7. 字符串和列表:

   • 字符串是特殊的列表
   • 字符串不可变,列表可变
   • 转换:list()和"".join()

8. 元组:

   • 元组是不可变的列表
   • 元组用圆括号()表示
   • 元组用于存储固定数据

重要概念对比

常用操作总结

编程技巧

1. 选择合适的遍历方式:

   • 只需要访问元素:遍历元素
   • 需要修改元素:遍历索引
   • 需要索引和元素:使用enumerate

2. 避免常见错误:

   • 索引从0开始,不是1
   • 切片不包括结束位置
   • 遍历时不要直接修改列表

3. 善用列表方法:

   • in和not in判断元素是否存在
   • sum(), max(), min()快速统计
   • split()和join()处理字符串

4. 理解内存原理:

   • 列表在内存中连续存放
   • 索引用于快速计算内存地址
   • 列表大小与内存占用相关

下一步

在下一章(第11章),我们将学习字典(Dictionary),这是一种用“键-值“对存储数据的数据结构。字典不像列表那样连续存储,而是使用一种叫做“哈希表“的技术,能快速查找数据!

挑战练习

1. 必做:

   • 创建一个存储你朋友名字的列表,并打印每个名字
   • 给定一个成绩列表,计算平均分、最高分、最低分
   • 将一个列表的所有元素乘以2

2. 选做:

   • 实现一个简单的待办事项列表程序
   • 统计一个句子中每个单词出现的次数
   • 合并两个列表并去除重复元素

3. 数学挑战:

   • 实现1+2+3+…+100的求和(用循环)
   • 生成前20项斐波那契数列
   • 找出一个列表的中位数
   • 统计数据的众数

4. 综合项目:

   • 设计一个学生成绩管理系统(使用列表存储学生信息)
   • 实现一个简单的井字棋游戏(使用列表表示棋盘)
   • 创建一个单词统计程序(统计文本中的单词频率)

加油!你已经掌握了Python中最常用的数据结构——列表!🎉

列表是程序员的“瑞士军刀“,几乎所有的Python程序都会用到列表。你现在不仅学会了如何使用列表,还理解了它在内存中的存储方式,以及如何用它来解决数学问题!

继续努力,接下来我们将学习字典,它会让你的程序更强大!💪