for循环与字符串列表

for循环与字符串列表

📋 内容导航

• 内容回顾 - 回顾数值类型与条件分支
• for循环 - 计数循环的语法与应用
• 列表 - Python最灵活的数据结构
• 字符串 - 文本处理的核心
• 通关挑战 - 练习题与解析
• 文档总结 - 知识点回顾与拓展

---

🎯 内容回顾

在前面文档的基础上继续Python学习征途，本文档的主要内容如下：

1. for 循环 - 学习计数循环的语法，掌握 range() 函数的使用，实现1到100的累加计算
2. 列表（List） - Python最常用的数据结构，学习创建、索引、切片、增删改查等操作
3. 字符串（String） - 学习字符串的表示方式、常用方法，以及与for循环的结合使用

---

for 循环

在日常工作和生活中，我们经常会遇到需要重复执行某些任务的场景：

• 统计全班50名学生的平均分
• 给1000个客户发送促销邮件
• 批量处理100张图片

这些任务如果手动完成，不仅效率低下，而且容易出错。幸运的是，计算机最擅长的就是快速、准确地执行重复性任务。

在Python中，for 循环是实现计数循环（按指定次数重复）的最佳工具。来看看怎么用！

在编程中，循环（Loop） 是一种控制结构，它允许程序重复执行某段代码。Python 提供了两种主要的循环类型：

循环类型	使用场景	Python实现	示例
计数循环	知道重复次数时	for 循环	计算1到100的和
条件循环	不知道重复次数，满足条件才停止	while 循环	猜数字游戏

本文重点学习 for 循环，while 循环将在后续文档中详细讲解。

for 语法

for 语句的一般格式如下：

for 变量 in 可迭代对象:
    循环体语句块

语法说明：

• 变量：每次循环从可迭代对象中取出的元素
• 可迭代对象：可以是列表、字符串、range()生成的序列等
• 循环体语句块：需要重复执行的代码，必须缩进

执行流程：

1. 从可迭代对象中取出第一个元素，赋值给变量
2. 执行循环体语句块
3. 取出下一个元素，重复步骤2
4. 直到所有元素都处理完毕，循环结束

for 循环的执行流程图如下：

示例讲解

了解了 for 循环的语法和执行流程，赶紧来编码实现功能：计算1到100所有整数的和，1+2+3+...+99+100。

咱们来一步步实现。

第一步：认识可迭代对象

通过for语句的语法，in 后面是一个可迭代对象。1 到 100 这100个数要怎么表示成可迭代对象呢？

在Python中可以使用列表（后面马上会学到）表示，比如1到5的列表可以表示成 [1, 2, 3, 4, 5]。

先通过一个简单的例子上手使用一下 for 循环：结合列表打印出5次 "晚上好"。

integer_list = [1, 2, 3, 4, 5]
for i in integer_list:
    print('晚上好')

# 运行结果
晚上好
晚上好
晚上好
晚上好
晚上好

💡 代码解析：列表中有5个元素，for循环就执行5次，每次取出列表中的一个元素赋值给变量 i，然后执行循环体（打印"晚上好"）。

第二步：计算1到5的和

有没有发现其实很简单？下面升级一下：计算列表 [1, 2, 3, 4, 5] 各项相加之和。

integer_list = [1, 2, 3, 4, 5]
total = 0              # 初始化累加器
for i in integer_list:
    total += i         # 等价于 total = total + i
print("1 到 5 各数相加之和 =", total)

# 运行结果
1 到 5 各数相加之和 = 15

💡 代码解析：

• total = 0：初始化一个变量用来存储累加结果
• total += i：每次循环将当前的 i 值加到 total 上
• 循环结束后，total 就是所有数的和

第三步：计算1到100的和 - 引入range()

搞定了1到5各数的相加，那么搞定1到100各数相加也应该是分分钟的事情。修改一下整数列表就OK了吗？

等等！修改整数列表的时候发现，这从1敲到100需要花费大量时间手动输入：

# 这样写太麻烦了！
integer_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ... , 100]  # 敲到手软

如果这样重复的事情要手动去敲，就没有发挥循环的优势了，能有好的办法吗？

对于这个问题，Python早就默默的为我们想到了，这里用到了一个超级重要的函数 —— range()。

range() 是一个内置函数，它可以为指定的整数生成一个数字序列（也就是可迭代对象）。range() 有三种用法：

range(stop)              # 从0开始，到stop结束（不包含stop），步长为1
range(start, stop)       # 从start开始，到stop结束（不包含stop），步长为1
range(start, stop, step) # 从start开始，到stop结束（不包含stop），步长为step

注意：无论选择哪一种，参数只能是整数。

通过代码我们来熟悉一下 range() 函数的三种用法：

# 用法1：range(stop) - 从0开始，到stop结束（不包含stop）
for i in range(5):
    print(i, end=' ')
# 输出: 0 1 2 3 4

# 用法2：range(start, stop) - 指定起始值
for i in range(1, 5):
    print(i, end=' ')
# 输出: 1 2 3 4

# 用法3：range(start, stop, step) - 指定步长
for i in range(0, 10, 2):
    print(i, end=' ')
# 输出: 0 2 4 6 8

# 负步长：倒序
for i in range(5, 0, -1):
    print(i, end=' ')
# 输出: 5 4 3 2 1

⚠️ 重要提醒：对照输出结果，你是不是有疑惑——为什么没有包含结束值呢？

这是 range() 的一个重要特性：左闭右开区间 [start, stop)

• 包含起始值 start
• 不包含结束值 stop

编写代码时必须要考虑到这一点，正确调整范围来得到想要的循环次数！

第四步：正确计算1到100的和

有了 range()，实现 1 到 100 各数相加已经没有任何阻碍了。但是要注意范围设置：

# ❌ 错误示例：只加到99
total = 0
for i in range(100):      # 生成 0-99
    total += i
print('1到100各数相加的和 =', total)
# 运行结果: 1到100各数相加的和 = 4950  ← 错了！

咦，你有没有发现什么不对的地方？求得的和好像不对！

问题分析：

• range(100) 生成的是 0, 1, 2, ..., 99
• 我们需要的是 1, 2, 3, ..., 100
• 所以应该使用 range(1, 101)

# ✅ 正确示例
total = 0
for i in range(1, 101):   # 生成 1-100
    total += i
print('1到100各数相加的和 =', total)
# 运行结果: 1到100各数相加的和 = 5050  ← 正确！

💡 小技巧：计算 1 到 n 的和有个数学公式：n × (n + 1) / 2

验证一下：100 × 101 / 2 = 5050 ✓

range() 可以说是跟for循环"如胶似漆"，但 for循环可并不只有range() 一个小伙伴，它还可以跟其他很多的小伙伴配合，完成各种重复的工作，下面马上就来讲一讲 for 循环的两个小伙伴列表和字符串。

列表

在Python中，可包含其他对象的对象，称之为"容器"。容器是一种数据结构。

常用的容器主要划分为两种：

• 序列（如：列表、元组等）
• 映射（如：字典）

序列中，每个元素都有下标，它们是有序的。序列有通用的操作方法：索引、长度、组合（序列相加）、重复（乘法）、分片、检查成员、遍历、最小值和最大值。

映射中，每个元素都有名称（又称"键"），它们是无序的。

注意：除了序列和映射之外，还有一种需要注意的容器——"集合"。

列表（List） 是 Python 中最常用、最灵活的数据结构。你可以把它想象成一个有序的收纳盒，里面可以存放各种物品（数据），而且可以随时添加、移除或替换其中的物品。

列表的特点

特性	说明	示例
有序	元素按插入顺序排列，可通过索引访问	list[0] 获取第一个元素
可变	可以增删改元素，列表长度可动态变化	list.append(100) 添加元素
异构	元素可以是任意类型，甚至可以嵌套列表	[1, "hello", [2, 3]]

创建列表

使用方括号 [] 或 list() 函数 创建列表：

1. 方括号法：直接列出元素，用逗号分隔
2. list() 函数：将其他可迭代对象（如字符串）转换为列表

比如：

list1 = [1, 2, 3, 4, 5, 6]  # 使用英文中括号 [] 创建列表
list2 = ['渣男教父', 32, True]  # 元素类型可以不一样
list3 = list('渣男教父')  # 字符串转字符列表

print(list1)
print(list2)
print(list3)

# 运行结果
[1, 2, 3, 4, 5, 6]
['渣男教父', 32, True]
['渣', '男', '男', '教', '父']

索引与访问

列表中的每个元素都有一个索引（下标），用于定位和访问：

• 正向索引：从 0 开始，第一个元素是 0，第二个是 1，以此类推
• 反向索引：从 -1 开始，最后一个元素是 -1，倒数第二个是 -2

示意图：

列表:    [ 10,  20,  30,  40,  50 ]
正向索引:   0    1    2    3    4
反向索引:  -5   -4   -3   -2   -1

常用操作

num_list = [1, 2, 3, 4, 5, 6]

# 按下标取值
print(num_list[0], num_list[5])
print(num_list[-6], num_list[-1])

# 使用 index()方法获取 2在列表 num_list 中首次出现的下标
index = num_list.index(2)
print(index)

# 使用count()方法获取 2 在列表 num_list 中出现的次数
count = num_list.count(2)
print(count)

# 使用 len()方法获取列表判断长度
length = len(num_list)
print(length)

# 当且仅当列表为空，在if条件中被判断为False
if num_list:
    print("列表num_list不为空")

lst0 = []
if not lst0:
    print("列表lst0为空")

# 列表是否包含某个元素
# 使用 in 关键字可以检测一个列表中是否存在指定的值，如果存在，则返回 True；否则返回 False。
# 使用 not in 关键字也可以检测一个值，返回值与 in 关键字相反。
print(2 in num_list, 6 not in num_list)

# 使用min() 和 max() 方法获取最小值和最大值
print(min(num_list), max(num_list))

# 运行结果可以发现结果是一样的
1 6
1
1
6
列表num_list不为空
列表lst0为空
True False

除了按指定索引获取列表元素，还可以通过前面学过的随机模块 random 中的 choice() 方法可以从列表中随机获取一个元素，结合上一篇的猜数字游戏，假如我们得谜底数字不是0 到10之间，是指定列表中的一个值，来看看如何实现：

# 导入随机模块
import random

secret_value_list = [2, 5, 9, 10, 100]
secret_number = random.choice(secret_value_list)
print(secret_number)

# 运行结果
9

更新、添加

更新元素：通过索引来对列表的元素进行修改或更新。

添加元素：append() 方法、extend() 方法、insert() 方法、+ 运算符、*运算符

append() 方法、extend() 方法、+ 运算符、*运算符对列表添加元素，都是往列表的末尾添加数据。insert() 方法则可以添加元素到指定位置，insert()方法有两个参数：第一个参数指定待插入的位置（索引值），第二个参数是待插入的元素值。

更新元素

my_list = [1, 2, 3, 4, 5]
my_list[0] = 20  # 将列表第一个元素改成20
print('更新列表第一个元素后', my_list)

# 运行结果
更新列表第一个元素后 [20, 2, 3, 4, 5]

append() 方法

列表对象的 append() 方法用于在列表的末尾追加元素，语法如下：

list_name.append(obj)

其中，list_name 为要添加元素的列表名称，obj 为要添加到列表末尾的对象。比如:

my_list = [20, 10, 50, 30]
my_list.append(80)
print(my_list)

# 运行结果
[20, 10, 50, 30, 80]

extend() 方法

append() 方法是向列表中添加一个元素，如果想要将一个迭代对象中的全部元素添加当前列表对象的尾部，可以使用列表对象的 extend() 方法实现，用法如下：

list_name.extend(seq)

其中，list_name 为当前列表；seq 为要添加的迭代对象。语句执行后，seq 的内容将追加到 list_name 的后面，比如：

my_list = [20, 10, 50, 30]
my_list.extend([1, 2, 3])
print(my_list)

# 运行结果
[20, 10, 50, 30, 1, 2, 3]

insert() 方法

使用列表对象的 insert() 方法可以将元素添加到指定下标位置。语法格式如下：

list_name.insert(index, obj)

参数 index 表示插入的索引位置；obj 表示要插入列表中的对象。该方法没有返回值，只是在原列表指定位置插入对象。 上代码：

my_list = [1, 2, 3, 4, 5]
my_list.insert(0, 6)
print(my_list)

# 运行结果
[6, 1, 2, 3, 4, 5]

+ 运算符

与 extend() 方法功能类似，使用 + 运算符可以将两个列表对象合并为一个新的列表对象。

注意：+ 运算符实际上并不是在原列表中添加元素，而是创建了一个新列表，并将原列表中的元素和参数对象依次复制到新列表中。由于涉及大量元素的复制，该操作速度较慢，在涉及大量元素添加时不建议使用该方法。 上代码：

my_list = [20, 10, 50, 30]
my_list = my_list + [1, 2, 3]
print(my_list)

# 运行结果
[20, 10, 50, 30, 1, 2, 3]

* 运算符

使用 * 运算符可以扩展列表对象，将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复。 上代码：

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

# 运行结果
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

删除

从列表中删除元素，可以有三种方法实现：del 命令、pop() 方法、remove()方法、clear()方法

删除元素主要有两种情况：一种是根据索引删除；另一种是根据元素值进行删除。

remove() 方法

使用列表对象的 remove() 方法可以删除首次出现的指定元素。语法格式如下：

list_name.remove(obj)

参数 obj 表示列表中要移除的对象，即列表元素的值。该方法没有返回值，如果列表中不存在要删除的元素，则抛出异常。 上代码：

num_list = [1, 2, 2, 3, 4]
num_list.remove(2)  # 删除首次出现的2
print(num_list)

# 运行结果
[1, 2, 3, 4]

pop() 方法

使用列表的 pop() 方法可以删除并返回指定位置上的元素。语法格式如下：

list_name.pop([index=-1])

参数 index 表示要移除列表元素的索引值，默认值为-1，即删除最后一个列表值。如果给定的索引值超出了列表的范围，将抛出异常。 上代码：

num_list = [1, 2, 2, 3, 4]
num_list.pop()  # 默认删除列表最后一个元素
print(num_list)
num_list.pop(0)  # 删除列表第一个元素
print(num_list)

# 运行结果
[1, 2, 2, 3]
[2, 2, 3]

del 命令

可以使用 del 命令来删除列表指定位置的的元素。 上代码：

num_list = [1, 2, 3, 4]
del num_list[0]
print(num_list)

# 运行结果
[2, 3, 4]

clear() 方法

使用列表对象的 clear() 方法可以删除列表中所有的元素。该方法没有参数，也没有返回值。 上代码：

num_list = [1, 2, 3, 4]
num_list.clear()
print(num_list)

# 运行结果
[]

列表删除方法的总结：

• pop() 方法是删除索引对应的值，remove() 方法是删除列表对象中最左边的一个值。
• pop() 方法针对的是元素的索引进行操作，remove() 方法针对的是元素的值进行操作。
• del 是一条命令，而不是方法，使用频率不及 pop() 和 remove() 方法。

遍历

我们可以直接遍历列表内容，当需要获取元素值和对应下标的时候更推荐使用 enumerate() 函数，enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中，比如：

lst = list('Python')

for i in lst:
    print(i)

# 输出结果
P
y
t
h
o
n

for i, v in enumerate(lst):
    print(i, v)

# 输出结果
0 P
1 y
2 t
3 h
4 o
5 n

排序

使用列表对象的 sort() 方法可以进行自定义排序，此时列表对象本身被修改，list_name.sort() 方法包含 2个可选参数（设定比较关键字，应用情况较为复杂，暂时不用理解），先学习设定排序方式，默认是升序，想要降序排列时，添加参数 reverse=True 即可，sort() 方法无返回值。 上代码：

num_list = [2, 32, 344, 6, 56, 876]
num_list.sort()  # 默认升序
print(num_list)
num_list.sort(reverse=True)  # 降序
print(num_list)

# 运行结果
[2, 6, 32, 56, 344, 876]
[876, 344, 56, 32, 6, 2]

切片

切片（slice）语法的引入，使得Python的列表真正地走向了高端。切片让我们能够非常方便的来处理列表元素。

现在要求将列表list1中的三个元素取出来，放到列表list2里面。学了前面的知识，可以使用基础方法来实现：

num_list = [1, 2, 3, 4, 5]
num_list2 = [num_list[0], num_list[1], num_list[2]]
print("新列表：", num_list2)

# 运行结果
新列表： [1, 2, 3]

如果我们学会了切片，会大大地简化了这种操作，赶紧来试试：

num_list = [1, 2, 3, 4, 5]
num_list2 = num_list[0:3]
print("切片出来的列表：", num_list2)

# 运行结果
切片出来的列表： [1, 2, 3]

很简单对吧？只不过是用一个冒号隔开两个索引值，左边是开始位置，右边是结束位置。这里要注意的一点是：结束位置上的元素是不包含的（如上面例子中，4的索引值也是4，我们写的是list[0:3]，便不能将其包含进来）。

使用列表切片也可以"偷懒"，之前提到过Python是以简洁而闻名于世，所以你能想到的"便捷方案"，Python的作者以及Python社区的小伙伴们都已经想到了，并付诸实践，你要做的就是验证一下是否可行：

my_list = [1, 2, 3, 4, 5, 6]
print(my_list[:3])
print(my_list[3:])
print(my_list[:])   # 复制列表
print(my_list[::-1])  # 翻转列表

# 运行结果
[1, 2, 3]
[4, 5, 6]
[1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1]

如果省略了开始位置，Python会从0这个位置开始。同样道理，如果要得到从指定索引值到列表末尾的所有元素，把结束位置也省去即可。如果啥都没有，只有一个冒号，Python将返回整个列表的拷贝。

注意：列表切片并不会修改列表自身的组成结构和数据，它其实是为列表创建一个新的拷贝（副本）并返回。

字符串

几乎每个编程初学者的第一行代码都是 print('Hello World')，这就是字符串（String） —— Python 中用于表示文本数据的类型。

在实际开发中，字符串无处不在：

• 🌐 网页内容抓取与解析
• 📧 邮件和消息的内容处理
• 📊 数据清洗与格式化输出
• 📝 配置文件和日志记录

可以说，熟练掌握字符串操作是编程的基本功。

什么是字符串？

字符串是由零个或多个字符组成的序列，用单引号 ' 或双引号 " 包裹：

name = '张三'        # 单引号
greeting = "你好"    # 双引号
empty = ""           # 空字符串

💡 重要规则：引号必须成对使用，不能混用（如 'Hello" 是错误的）

常用表示方式

字符串有三种表示方式：普通字符串、原始字符串和长字符串。

普通字符串

普通字符串指用单引号（'）或双引号（"）括起来的字符串。

在使用单引号定义的字符串中，可以直接包含双引号，而不必进行转义；而在使用双引号定义的字符串中，可以直接包含单引号，而不必进行转义。即外单内双，外双内单。所以在使用普通字符串中重点需要注意的就是转义，什么是转义呢，看下图：

编码中比较常见的转义符如下：

简单的来看看代码：

s = 'Hi Python'
print(s)

s = 'Hi \'" \n Python'  # 了解转义符
print(s)

# 运行结果
Hi Python
Hi '" 
 Python

原始字符串

原始字符串（Raw String） 的作用是：取消转义，让字符串中的每个字符都按字面意思解释。

使用场景：

• Windows 文件路径：C:\Users\name\file.txt
• 正则表达式：\d+, \w+
• 避免大量的反斜杠转义

在字符串前加 r 或 R 前缀即可创建原始字符串：

# 普通字符串中的转义
path = "C:\\Users\\name\\file.txt"
print(path)  # C:\Users\name\file.txt

# 原始字符串 - 不需要转义
path = r"C:\Users\name\file.txt"
print(path)  # C:\Users\name\file.txt

# 正则表达式中使用原始字符串很常见
import re
pattern = r"\d+"  # 匹配数字，不需要写成 "\\d+"

长字符串

当字符串跨越多行时，可以使用三引号（''' 或 """）创建长字符串：

# 使用三引号创建多行字符串
poem = '''
春眠不觉晓，
处处闻啼鸟。
夜来风雨声，
花落知多少。
'''
print(poem)

# 也可以用于包含特殊格式的文本
sql = """
SELECT * FROM users
WHERE age > 18
ORDER BY name;
"""

字符串常用操作

字符串拼接与重复

# 使用 + 拼接字符串
first_name = "张"
last_name = "三"
full_name = first_name + last_name
print(full_name)  # 张三

# 使用 * 重复字符串
line = "-" * 20
print(line)  # --------------------

# 使用 join() 方法拼接多个字符串
words = ["Hello", "Python", "World"]
sentence = " ".join(words)
print(sentence)  # Hello Python World

字符串索引与切片

字符串和列表一样支持索引和切片操作：

s = "Python"

# 索引
print(s[0])    # P
print(s[-1])   # n

# 切片
print(s[0:2])  # Py
print(s[2:])   # thon
print(s[::-1]) # nohtyP (反转)

# 注意：字符串是不可变的
# s[0] = "p"  # 这会报错！

字符串常用方法

text = "  Hello Python  "

# 去除空白
print(text.strip())      # "Hello Python"
print(text.lstrip())     # "Hello Python  "
print(text.rstrip())     # "  Hello Python"

# 大小写转换
print("python".upper())  # PYTHON
print("PYTHON".lower())  # python
print("hello world".title())  # Hello World

# 查找与替换
print("banana".count("a"))      # 3
print("hello world".find("o"))  # 4 (返回第一次出现的索引)
print("hello world".replace("o", "0"))  # hell0 w0rld

# 分割与连接
print("a,b,c".split(","))  # ['a', 'b', 'c']
print("-".join(["2024", "01", "15"]))  # 2024-01-15

# 判断方法
print("123".isdigit())     # True
print("abc".isalpha())     # True
print("abc123".isalnum())  # True
print(" ".isspace())       # True

字符串与 for 循环

字符串是可迭代对象，可以直接用 for 循环遍历：

# 遍历字符串中的每个字符
for char in "Python":
    print(char)

# 使用 enumerate 获取索引和字符
for index, char in enumerate("Python"):
    print(f"索引 {index}: {char}")

# 统计字符串中某个字符出现的次数
count = 0
for char in "programming":
    if char == "m":
        count += 1
print(f"'m' 出现了 {count} 次")  # 'm' 出现了 2 次

---

🏆 通关挑战

一、选择题

1. 以下代码的输出结果是什么？

for i in range(3, 10, 2):
    print(i, end=" ")

A. 3 4 5 6 7 8 9
B. 3 5 7 9
C. 3 5 7 9 10
D. 4 6 8 10

点击查看答案与解析

答案：B

解析过程：

1. range(3, 10, 2) 表示从3开始，到10结束（不包含10），步长为2
2. 生成的序列是：3, 5, 7, 9
3. 注意：
   • 起始值3包含在内
   • 结束值10不包含
   • 每次增加2（步长）
4. 所以输出是：3 5 7 9

易错点： 容易混淆步长的含义，或者误以为结束值包含在内。

---

2. 以下代码执行后，列表 nums 的内容是什么？

nums = [1, 2, 3]
nums.append([4, 5])

A. [1, 2, 3, 4, 5]
B. [1, 2, 3, [4, 5]]
C. [5, 4, 3, 2, 1]
D. 报错

点击查看答案与解析

答案：B

解析过程：

1. append() 方法会将参数作为一个单个元素添加到列表末尾
2. [4, 5] 是一个列表对象，append() 会将它整体作为一个元素添加
3. 如果要将 [4, 5] 的元素逐个添加，应该使用 extend() 方法
4. 对比：
   • nums.append([4, 5]) → [1, 2, 3, [4, 5]]
   • nums.extend([4, 5]) → [1, 2, 3, 4, 5]

易错点： append() 和 extend() 的区别是初学者常混淆的地方。

---

3. 执行 list("Python") 的结果是什么？

A. ["Python"]
B. ['P', 'y', 't', 'h', 'o', 'n']
C. 报错
D. ['PYTHON']

点击查看答案与解析

答案：B

解析过程：

1. list() 是列表的构造函数，接受一个可迭代对象
2. 字符串是可迭代对象，list("Python") 会将字符串的每个字符作为列表的一个元素
3. "Python" 有6个字符：P, y, t, h, o, n
4. 所以结果是 ['P', 'y', 't', 'h', 'o', 'n']

延伸： 如果想创建包含整个字符串的列表，应该使用 ["Python"]。

---

4. 以下代码的输出是什么？

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

A. [1, 2, 3, 4]
B. [2, 3, 4]
C. [2, 3, 4, 5]
D. [1, 2, 3]

点击查看答案与解析

答案：B

解析过程：

1. 切片语法 [start:end] 中，start 包含，end 不包含
2. my_list[1:4] 表示：
   • 从索引1开始（值为2）
   • 到索引4结束（值为5），但不包含索引4
   • 所以取索引1、2、3的元素：2, 3, 4
3. 结果是 [2, 3, 4]

记忆技巧： 切片区间是左闭右开 [ )

---

5. 以下哪个方法可以将字符串 "hello world" 中的 "world" 替换为 "Python"？

A. replace("world", "Python")
B. substitute("world", "Python")
C. swap("world", "Python")
D. change("world", "Python")

点击查看答案与解析

答案：A

解析过程：

1. Python字符串的 replace(old, new) 方法用于替换子串
2. 用法："hello world".replace("world", "Python") → "hello Python"
3. 其他选项：
   • substitute()：不是Python字符串方法
   • swap()：不是Python字符串方法
   • change()：不是Python字符串方法

注意： replace() 返回新字符串，原字符串不变（字符串不可变）。

---

二、编程题

1. 列表元素求和与平均值

编写程序，计算列表 [23, 45, 67, 12, 89, 34] 中所有元素的和与平均值。

点击查看答案与解析

参考代码：

nums = [23, 45, 67, 12, 89, 34]

# 方法1：使用 for 循环
total = 0
for num in nums:
    total += num
average = total / len(nums)

print(f"列表元素之和: {total}")
print(f"列表元素平均值: {average:.2f}")

# 方法2：使用内置函数（更简洁）
total = sum(nums)
average = total / len(nums)
print(f"和: {total}, 平均值: {average:.2f}")

运行结果：

列表元素之和: 270
列表元素平均值: 45.00

思路解析：

1. 求和需要遍历列表，将每个元素累加到一个变量中
2. 平均值 = 总和 / 元素个数
3. len() 函数可以获取列表长度
4. Python内置 sum() 函数可以直接求和，但实际开发中建议先掌握循环实现

扩展思考：

• 如何找出列表中的最大值和最小值？
• 如何计算大于平均值的元素个数？

---

2. 字符串反转与判断回文

编写程序，输入一个字符串，判断它是否是回文字符串（正读反读都相同的字符串，如 "level"、"上海自来水来自海上"）。

点击查看答案与解析

参考代码：

# 获取用户输入
text = input("请输入一个字符串: ")

# 方法1：使用切片反转
reversed_text = text[::-1]

if text == reversed_text:
    print(f"'{text}' 是回文字符串！")
else:
    print(f"'{text}' 不是回文字符串。")
    print(f"反转后: {reversed_text}")

# 方法2：使用 reversed() 函数（返回迭代器，需要转换）
reversed_text2 = ''.join(reversed(text))
print(f"方法2反转结果: {reversed_text2}")

运行示例：

请输入一个字符串: level
'level' 是回文字符串！
方法2反转结果: level

请输入一个字符串: hello
'hello' 不是回文字符串。
反转后: olleh

思路解析：

1. 回文的判断核心是：原字符串 == 反转后的字符串
2. Python切片 [::-1] 是反转序列最简洁的方式：
   • start 和 end 省略表示整个序列
   • 步长 -1 表示从后向前取
3. reversed() 函数返回迭代器，需要用 ''.join() 转成字符串

扩展思考：

• 如何忽略空格和标点判断回文？（如 "A man, a plan, a canal: Panama"）
• 如何实现不区分大小写的回文判断？

---

3. 列表去重与排序

给定列表 [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]，请编写程序：

1. 去除重复元素
2. 按升序排列
3. 输出处理后的列表

点击查看答案与解析

参考代码：

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

# 方法1：使用 set 去重（最简单）
unique_nums = list(set(nums))
unique_nums.sort()
print(f"方法1结果: {unique_nums}")

# 方法2：使用循环去重（理解原理）
unique_nums2 = []
for num in nums:
    if num not in unique_nums2:
        unique_nums2.append(num)
unique_nums2.sort()
print(f"方法2结果: {unique_nums2}")

# 方法3：一行代码（最Pythonic）
result = sorted(list(set(nums)))
print(f"方法3结果: {result}")

运行结果：

方法1结果: [1, 2, 3, 4, 5, 6, 9]
方法2结果: [1, 2, 3, 4, 5, 6, 9]
方法3结果: [1, 2, 3, 4, 5, 6, 9]

思路解析：

1. 去重原理：

   • set 是集合类型，天然去重（元素唯一）
   • 循环去重时，用 if num not in unique_nums2 判断是否已经存在

2. 排序方法：

   • list.sort()：原地排序，修改原列表，返回 None
   • sorted(list)：返回新列表，原列表不变

3. 选择建议：

   • 方法1最常用，简洁高效
   • 方法2帮助理解去重原理
   • 方法3适合快速处理

注意： set 去重会丢失原始顺序，如果需要保持原顺序，需要用方法2。

---

4. 统计字符出现次数

编写程序，统计字符串 "Life is short, you need Python." 中每个字母出现的次数（不区分大小写，忽略非字母字符）。

点击查看答案与解析

参考代码：

text = "Life is short, you need Python."

# 方法1：使用字典统计
char_count = {}

for char in text.lower():  # 转小写，不区分大小写
    if char.isalpha():     # 只统计字母
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1

# 按字母顺序输出
for char in sorted(char_count):
    print(f"'{char}': {char_count[char]}")

print(f"\n总字母数: {sum(char_count.values())}")

# 方法2：使用 collections.Counter（更高级）
from collections import Counter

# 过滤出字母并转小写
letters = [c for c in text.lower() if c.isalpha()]
count = Counter(letters)
print(f"\n使用Counter: {dict(count)}")

运行结果：

'e': 3
'f': 1
'h': 2
'i': 2
'l': 1
'n': 3
'o': 3
'p': 1
's': 2
't': 2
'u': 1
'y': 2

总字母数: 23

思路解析：

1. 数据清洗：

   • .lower()：统一转小写，实现不区分大小写
   • .isalpha()：判断是否为字母，过滤标点空格

2. 统计逻辑：

   • 遍历每个字符
   • 如果字符已在字典中，计数+1
   • 如果不在，初始化计数为1

3. 字典操作：

   • char_count.keys()：获取所有键（字母）
   • char_count.values()：获取所有值（次数）
   • sorted(char_count)：按键排序

扩展思考：

• 如何找出出现次数最多的字母？
• 如何用 get() 方法简化字典操作？

---

5. 打印九九乘法表（for循环版）

使用 for 循环和 range() 函数，打印九九乘法表。

点击查看答案与解析

参考代码：

# 打印九九乘法表
print("=" * 50)
print("           九九乘法表")
print("=" * 50)

for i in range(1, 10):      # 外层循环：被乘数
    for j in range(1, i+1): # 内层循环：乘数（只打印到i，形成下三角）
        print(f"{j}×{i}={i*j:2}", end="  ")
    print()  # 每行结束后换行

print("=" * 50)

# 扩展：打印上三角版本
print("\n上三角版本：")
for i in range(1, 10):
    # 先打印空格对齐
    print("      " * (9 - i), end="")
    for j in range(i, 10):
        print(f"{i}×{j}={i*j:2}", end="  ")
    print()

运行结果：

==================================================
           九九乘法表
==================================================
1×1= 1  
1×2= 2  2×2= 4  
1×3= 3  2×3= 6  3×3= 9  
1×4= 4  2×4= 8  3×4=12  4×4=16  
...
==================================================

思路解析：

1. 双重循环结构：

   • 外层循环 i 控制行数（被乘数）
   • 内层循环 j 控制每行的列数（乘数）

2. 下三角特点：

   • 第1行：1个算式（1×1）
   • 第2行：2个算式（1×2, 2×2）
   • 第i行：i个算式
   • 所以内层循环是 range(1, i+1)

3. 格式化输出：

   • {i*j:2}：占2个字符宽度，右对齐
   • end=" "：每个算式后用两个空格分隔
   • print()：内层循环结束后换行

4. 上三角版本：

   • 需要计算空格让输出对齐
   • 内层循环从i开始而不是从1开始

扩展思考：

• 如何实现完整的9×9方阵？
• 如何让用户输入数字n，打印n×n乘法表？

---

🎉 文档总结

一、核心知识点回顾

1. for 循环

知识点	说明	示例
基本语法	for 变量 in 可迭代对象:	for i in range(5):
range()	生成数字序列	range(5), range(1, 10), range(0, 10, 2)
遍历列表	直接遍历元素	for item in list:
enumerate()	同时获取索引和值	for i, v in enumerate(list):

range() 三种形式对比：

range(5)        # [0, 1, 2, 3, 4]      从0开始，到5结束（不含）
range(2, 5)     # [2, 3, 4]            从2开始，到5结束（不含）
range(0, 6, 2)  # [0, 2, 4]            从0开始，步长为2

⚠️ 重要提醒： range(start, stop, step) 的结束值 stop 不包含在内！

---

2. 列表（List）

列表特点：

• ✅ 有序：元素有固定顺序，可通过索引访问
• ✅ 可变：可以添加、删除、修改元素
• ✅ 异构：元素可以是不同类型

常用操作速查表：

操作类型	方法/语法	说明
创建	[], list()	空列表或从可迭代对象创建
索引	list[0], list[-1]	正向/反向索引
切片	list[1:4], list[::-1]	截取/反转
添加	append(), extend(), insert()	末尾添加/扩展/指定位置插入
删除	remove(), pop(), del, clear()	按值删/按索引删/清空
查询	index(), count(), in	查索引/统计/判断存在
排序	sort(), sorted()	原地排序/返回新列表
其他	len(), min(), max()	长度/最值

添加元素方法对比：

lst = [1, 2, 3]

lst.append(4)       # [1, 2, 3, 4]         添加单个元素
lst.append([5, 6])  # [1, 2, 3, 4, [5, 6]] 添加列表作为单个元素
lst.extend([7, 8])  # [..., 7, 8]          扩展多个元素
lst.insert(0, 0)    # [0, ..., 8]          在索引0处插入0

删除元素方法对比：

lst = [1, 2, 3, 2, 4]

lst.remove(2)   # [1, 3, 2, 4]  删除第一个值为2的元素
lst.pop()       # [1, 3, 2]     删除并返回最后一个元素
lst.pop(0)      # [3, 2]        删除并返回索引0的元素
del lst[0]      # [2]           删除索引0的元素
lst.clear()     # []            清空列表

---

3. 字符串（String）

字符串特点：

• ✅ 不可变：创建后不能修改，操作返回新字符串
• ✅ 有序：支持索引和切片
• ✅ 可迭代：可用 for 循环遍历

三种表示方式：

# 普通字符串
s1 = 'Hello'
s2 = "World"
s3 = '他说："你好"'  # 外单内双

# 原始字符串（不转义）
path = r"C:\Users\name"  # 前缀 r

# 长字符串（多行）
text = '''
第一行
第二行
第三行
'''

常用方法速查表：

方法	功能	示例
upper() / lower()	大小写转换	"abc".upper() → "ABC"
strip()	去除首尾空白	" a ".strip() → "a"
split()	分割字符串	"a,b,c".split(",") → ['a','b','c']
join()	连接字符串	"-".join(['a','b']) → "a-b"
replace()	替换子串	"abc".replace("b", "X") → "aXc"
find() / index()	查找子串位置	"abc".find("b") → 1
startswith() / endswith()	前缀/后缀判断	"abc".startswith("a") → True
isdigit() / isalpha()	类型判断	"123".isdigit() → True

---

二、编程思维培养

1. 循环思维

什么时候用 for 循环？

• 知道循环次数时（如遍历列表、固定次数）
• 需要逐个处理序列中的元素时

循环三要素：

1. 初始化：设置初始状态（如 total = 0）
2. 条件/范围：确定循环执行的条件或范围
3. 更新：每次循环改变状态（如 total += i）

# 示例：计算1到100的和
total = 0           # 1. 初始化
for i in range(1, 101):  # 2. 范围
total += i          # 3. 更新

2. 数据结构思维

列表使用场景：

• 需要存储一组相关数据
• 数据需要频繁增删改
• 需要保持数据顺序

字符串使用场景：

• 处理文本数据
• 格式化输出
• 数据清洗和转换

3. 切片思维

切片是 Python 的强大特性，记住这个通用模式：

sequence[start:end:step]

切片写法	含义	示例 s = "Python"
s[:3]	前3个	"Pyt"
s[3:]	第3个之后	"hon"
s[-3:]	后3个	"hon"
s[::2]	每隔1个取	"Pto"
s[::-1]	反转	"nohtyP"

---

三、常见错误与避坑指南

❌ 错误1：range() 结束值理解错误

# 错误：想生成1-10，结果只到9
for i in range(10):  # 生成0-9
    print(i)

# 正确
for i in range(1, 11):  # 生成1-10
    print(i)

❌ 错误2：遍历列表时修改列表

# 错误：遍历中删除元素会导致跳过某些元素
nums = [1, 2, 3, 4]
for num in nums:
    if num % 2 == 0:
        nums.remove(num)  # ❌ 危险操作！
print(nums)  # 结果可能不符合预期

# 正确：创建新列表或倒序遍历
nums = [1, 2, 3, 4]
nums = [num for num in nums if num % 2 != 0]  # 列表推导式

❌ 错误3：字符串不可变却试图修改

# 错误
s = "hello"
s[0] = "H"  # TypeError: 'str' object does not support item assignment

# 正确：创建新字符串
s = "H" + s[1:]  # "Hello"
s = s.replace("h", "H")  # "Hello"

❌ 错误4：append() 和 extend() 混淆

lst = [1, 2, 3]

# 错误理解：想添加多个元素，结果添加了列表
lst.append([4, 5])  # [1, 2, 3, [4, 5]]

# 正确
lst.extend([4, 5])  # [1, 2, 3, 4, 5]

❌ 错误5：切片赋值理解错误

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

# 切片返回的是新列表，不影响原列表
new_lst = lst[1:3]  # [2, 3]
new_lst[0] = 100
print(lst)  # [1, 2, 3, 4, 5] 原列表没变！

---

四、知识延伸与拓展

1. 列表推导式（List Comprehension）

更简洁地创建列表：

# 传统方式
squares = []
for i in range(10):
    squares.append(i ** 2)

# 列表推导式（一行搞定）
squares = [i ** 2 for i in range(10)]

# 带条件的列表推导式
evens = [i for i in range(10) if i % 2 == 0]  # [0, 2, 4, 6, 8]

2. 字符串格式化进阶

name = "张三"
age = 25

# f-string（推荐，Python 3.6+）
info = f"姓名: {name}, 年龄: {age}"

# format() 方法
info = "姓名: {}, 年龄: {}".format(name, age)

# % 格式化（旧式）
info = "姓名: %s, 年龄: %d" % (name, age)

3. 解包操作

# 列表解包
a, b, c = [1, 2, 3]

# 使用 * 收集剩余元素
first, *rest = [1, 2, 3, 4, 5]  # first=1, rest=[2,3,4,5]

# 字符串解包
a, b, c = "abc"  # a='a', b='b', c='c'

4. zip() 函数 - 并行遍历

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]

# 同时遍历两个列表
for name, age in zip(names, ages):
    print(f"{name}: {age}")

# 输出:
# Alice: 25
# Bob: 30
# Charlie: 35

---

五、下篇预告

在下一篇文档中，我们将学习：

📚 第四阶段：while 循环与九九乘法表

核心内容：

1. while 循环语法 - 条件循环的实现方式
2. break 和 continue - 循环控制语句
3. 循环嵌套 - 多重循环的应用
4. 九九乘法表 - 经典案例实战

学习目标：

• 掌握 while 循环与 for 循环的区别和使用场景
• 学会使用 break 和 continue 控制循环流程
• 理解循环嵌套的执行逻辑
• 能够独立编写九九乘法表程序

预习思考：

• for 循环和 while 循环各有什么优缺点？
• 什么时候应该用 break 提前结束循环？
• 如何避免写出死循环？

---

💡 学习建议： 列表和字符串是 Python 中最常用的数据类型，建议多动手练习，熟练掌握它们的常用方法。可以尝试用今天学到的知识，编写一个简单的文本处理工具或数据整理脚本！