一、先建立一个概念：序列

Python 里有一类东西叫序列——它是"排好队的一串值"，每个值都有一个位置编号（下标）。

本节讲三种：

二、下标：从 0 开始数

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

想象成这样一排带编号的格子：

>>> fruits[0]
'苹果'
>>> fruits[3]
'葡萄'
>>> fruits[-1]          # 负数从右边数：-1 是最后一个
'葡萄'
>>> fruits[-2]
'橙子'

越界会报错（Python 不会像 C 那样"悄悄读后面的内存"，这是它安全的地方）：

>>> fruits[10]
IndexError: list index out of range

三、切片：一次取一串

规则：[起点:终点:步长]。

最重要的一条（和 range 完全一致）：含头不含尾。

>>> nums = [10, 20, 30, 40, 50]

>>> nums[1:4]        # 下标 1、2、3（不含 4）
[20, 30, 40]

>>> nums[:3]         # 省略起点 = 从头开始
[10, 20, 30]

>>> nums[2:]         # 省略终点 = 一直到末尾
[30, 40, 50]

>>> nums[:]          # 全都要（可以理解成复制一份）
[10, 20, 30, 40, 50]

>>> nums[::2]        # 从头到尾，每隔一个取一个
[10, 30, 50]

>>> nums[::-1]       # 步长 -1 = 倒着取 → 反转！
[50, 40, 30, 20, 10]

切片最实用的用途：提取一段。 比如从日期字符串里取年份：

>>> date = "2026-09-24"
>>> date[:4]          # 前四个字符
'2026'
>>> date[5:7]         # 第 5、6 个（跳过 '2026-' 的横线？不，看下面）
'09'
>>> date.split("-")   # 更好的办法：直接切开
['2026', '09', '24']

四、列表：能改的一串

4.1 创建、查看、修改、增删

todos = ["买菜", "洗衣服"]           # 创建

todos[0] = "买菜和水果"               # 修改（列表能改）
print(todos)                         # ['买菜和水果', '洗衣服']

todos.append("遛狗")                  # 末尾追加（最常用）
print(todos)                         # ['买菜和水果', '洗衣服', '遛狗']

todos.insert(0, "起床")               # 插到指定位置
print(todos)                         # ['起床', '买菜和水果', '洗衣服', '遛狗']

todos.remove("洗衣服")                # 按内容删（删掉第一个匹配的）
print(todos)                         # ['起床', '买菜和水果', '遛狗']

last = todos.pop()                    # 弹出最后一个（并把它交给你）
print(last)                          # 遛狗
print(todos)                         # ['起床', '买菜和水果']

print(len(todos))                    # 2 —— 数个数
print(todos.count("起床"))            # 1 —— 数某个值出现几次
print("起床" in todos)                # True —— 在不在里面

最常用的六个方法（先记这四个就行）：

另外三个"函数"形式（不是方法，写在括号外面）：

>>> todos = ["买菜"]
>>> todos = todos.append("洗衣服")     # ❌ 想"更新一下"
>>> print(todos)
None                                   # 列表没了！

todos.append("洗衣服")                 # ✅ 直接调用，不要赋值

4.2 遍历列表（for 的真正用武之地）

todos = ["起床", "买菜", "做饭"]

for task in todos:
    print(f"○ {task}")

输出：

○ 起床
○ 买菜
○ 做饭

想要序号怎么办？用 enumerate()：

for i, task in enumerate(todos, 1):       # 第二个参数 1 表示"从 1 开始编号"
    print(f"{i}. {task}")

输出：

1. 起床
2. 买菜
3. 做饭

4.3 .sort() 的一个小脾气

nums = [30, 5, 100, 20]
nums.sort()
print(nums)              # [5, 20, 30, 100]  ✅ 数字会按大小排

words = ["banana", "Apple", "cherry"]
words.sort()
print(words)             # ['Apple', 'banana', 'cherry']  ← 大写排前面

字符串排序是按"字符编码"排的，所以大写字母全部排在小写字母前面（A=65，a=97）。别以为它坏了——想忽略大小写写 words.sort(key=str.lower)。

倒序：nums.sort(reverse=True)。

4.4 元组：不能改的列表

point = (3, 5)               # 元组用小括号
x, y = point                 # 解包
print(x, y)                  # 3 5

point[0] = 10                # ❌ TypeError: 'tuple' object does not support item assignment

什么时候用元组：当这组值本来就不该被改（坐标、RGB 颜色、一条数据库记录）。用元组是一种"声明"：告诉读代码的人"这是固定的"。

五、字符串：不能改的一串字符

5.1 字符串也有下标和切片（规则完全一样）

>>> s = "Raspberry"
>>> s[0]
'R'
>>> s[-1]
'y'
>>> s[:9]
'Raspberry'
>>> s[::-1]
'yrettopsaR'          # 反转

5.2 字符串不能改（这是它和列表的根本区别）

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

想改怎么办？造一个新的：

>>> s = "hello"
>>> s = "H" + s[1:]          # 拼一个新的，赋回给 s
>>> s
'Hello'

>>> s = "  hello  "
>>> s.strip()          # 去掉两头空格
'hello'
>>> s                  # 原字符串没变！
'  hello  '

5.3 七个最常用的字符串方法

s = "  Hello, Raspberry Pi  "

s.strip()                  # 'Hello, Raspberry Pi'   ← 去掉两头空白（最常用！）
s.strip().lower()          # 'hello, raspberry pi'   ← 全变小写
s.strip().upper()          # 'HELLO, RASPBERRY PI'   ← 全变大写
s.strip().replace("Pi", "树莓派")   # 'Hello, Raspberry 树莓派'  ← 替换（全部替换）
s.strip().find("Rasp")     # 7   ← 找子串的位置，找不到返回 -1
s.strip().startswith("He") # True
s.strip().split(",")       # ['Hello', ' Raspberry Pi']  ← 按分隔符切成列表

answer = input("继续吗？(y/n) ").strip().lower()
if answer == "y":
    ...

5.4 split() 和 join()：字符串与列表之间的双向门

>>> line = "苹果,香蕉,橙子"
>>> parts = line.split(",")          # 字符串 → 列表
>>> parts
['苹果', '香蕉', '橙子']

>>> "-".join(parts)                  # 列表 → 字符串
'苹果-香蕉-橙子'

>>> " ".join(["你好", "世界"])        # 用空格拼
'你好 世界'

"分隔符".join(列表名)

5.5 好消息：Python 处理中文不用怕

这一点是 Python 相对 C++ 的一大优势，值得单独说。

在 字符数组 里踩过一个坑：UTF-8 下一个汉字占 3 个字节，用 substr 按字节切会把汉字切成两半、输出乱码。

在 Python 里完全没有这个问题：

>>> s = "你好树莓派"
>>> len(s)
5                      # ← 是 5 个"字"，不是 15 个字节！
>>> s[2]
'树'
>>> s[0:2]
'你好'
>>> list(s)
['你', '好', '树', '莓', '派']

六、动手 Demo：一个真正的待办清单

把本节所有东西串起来。在命令行里写：

cd ~/projects
nano todo.py

内容：

todos = []                                  # 空列表：一开始什么事都没有

print("=== 待办清单 ===")
print("一行一条，直接回车就结束。\n")

while True:
    task = input("任务：").strip()           # 先清洗（去掉两头空格）
    if not task:                            # 空字符串 → 结束录入
        break
    todos.append(task)                      # 追加到列表

if not todos:                               # 一条都没录
    print("\n什么都没录，走了。")
else:
    todos.sort()                            # 排个序，看着舒服
    print(f"\n你一共列了 {len(todos)} 件事：")
    for i, task in enumerate(todos, 1):     # 带序号遍历
        print(f"  {i}. {task}")

    print("\n最长的一条是：", max(todos, key=len))
    print("平均每条", round(sum(len(t) for t in todos) / len(todos), 1), "个字")

跑：

python3 todo.py

输入三件事，看到什么算成功：

=== 待办清单 ===
一行一条，直接回车就结束。

任务：买菜
任务：遛狗
任务：交电费
任务：

你一共列了 3 件事：
  1. 交电费
  2. 买菜
  3. 遛狗

最长的一条是： 交电费
平均每条 2.3 个字

读结果 —— 逐条对一遍：

这个 Demo 用到了本章几乎所有知识点：

七、30 秒实验

实验一：三种序列，规则完全一样

>>> lst = [10, 20, 30, 40]
>>> s = "abcd"
>>> t = (10, 20, 30, 40)
>>> lst[1], s[1], t[1]
(20, 'b', 20)
>>> lst[-1], s[-1], t[-1]
(40, 'd', 40)
>>> lst[1:3], s[1:3], t[1:3]
([20, 30], 'bc', (20, 30))
>>> lst[::-1], s[::-1], t[::-1]
([40, 30, 20, 10], 'dcba', (40, 30, 20, 10))

下标、负下标、切片、反转——三种一模一样。 学一套，用三处。

实验二：中文长度，直观对比

>>> s = "你好树莓派"
>>> len(s)
5                 # Python 数的是"字"
>>> s[2]
'树'
>>> s[::-1]
'派莓树好你'       # 中文也能干净地反转

对照 C++ 的印象：如果按 UTF-8 字节算，这串是 15 字节，s[2] 会取到"好"字的中间那一个字节 → 乱码。Python 按字符算，所以不会。

实验三：字符串方法返回新值，原串不动

>>> s = "  hello  "
>>> s.strip()
'hello'
>>> s
'  hello  '          # ← 原串纹丝不动
>>> s = s.strip()    # 想生效，必须接回来
>>> s
'hello'

顺便对比列表：

>>> a = [3, 1]
>>> a.sort()         # 原地改，别接返回值
>>> a
[1, 3]

一个必须"接"、一个千万别"接"——这就是本节最容易混的一对。

实验四：split / join 双向门

>>> "a,b,c".split(",")
['a', 'b', 'c']
>>> ",".join(['a', 'b', 'c'])
'a,b,c'
>>> "".join(['你', '好'])
'你好'                 # 空分隔符 = 直接粘起来

八、常见误区

1. "a = a.append(x) 能更新列表" —— 不能，而且会把列表变成 None。原地修改的方法返回 None，直接调用就好，别接返回值。
2. "字符串也能像列表那样改" —— 不能。字符串不可变，所有方法都返回新值。想生效必须 s = s.strip() 这样接住（和上一条刚好相反，最容易混）。
3. "切片 [1:4] 会取到下标 4" —— 不会，含头不含尾，取的是 1、2、3。这条规则和 range 完全一致，记一次通用。
4. "len("你好") 是 6" —— 那是字节数（C++ 的算法）。Python 返回 2（字符数）。Python 处理中文不会乱码，这是它相对 C++ 的一大优势。
5. "排序把大写和小写混着排" —— 不是。默认按字符编码排，大写字母（65~90）全在小写（97~122）前面，所以 Apple 会排在 banana 前面。要忽略大小写：sort(key=str.lower)。
6. """.join(列表) 能用，那 列表.join("") 应该也行" —— 反了。join 是字符串的方法，不是列表的。只有一种写法："分隔符".join(列表)（分隔符写前面、join 挂在它身上）。写成 列表.join(...) 会报 AttributeError: 'list' object has no attribute 'join'。
7. "input() 拿到的就是干净的内容" —— 可能带两头空格。永远记得 .strip()，比较文字时再顺手 .lower()（"用户输入不可信"是这一章反复出现的主题）。

• ☑ 第六章 完结 —— 教材这一章已读完全部六节：认清 Python 是什么、学会在树莓派上写和跑程序、掌握变量与运算符、学会用流程控制让程序会判断会循环、用函数与模块整理代码并装库，最后能处理列表与字符串
• ☑ 第七章 GPIO 硬件接口 —— 已完结：Sense HAT 扩展板（让代码第一次碰到现实世界：认清 40 针引脚、拿到 gpiozero 这个工具、点亮 LED 也读通按钮、用 PWM 做出「半亮」、外接 ADC 芯片读模拟量，最后用 Sense HAT 把灯与传感器一次装好）

相关笔记

• Python 函数与模块 —— 上一节：本节的 enumerate 用了解包、max(key=...) 用了函数作参数
• 认识树莓派的 GPIO 引脚 —— 下一章起点：从这排 40 针开始，让代码第一次碰到现实世界
• Sense HAT 扩展板 —— 下一章小结：一块叠上去的板子，把彩灯、摇杆与传感器一次装好
• Python 流程控制 —— 本节 for task in todos: 是那里讲的 for 的真正用武之地
• 字符数组 —— 对照重点：那里踩过"UTF-8 下按字节切汉字出乱码"的坑，Python 没有这个问题
• 一维数组 —— 数组的对照；C++ 数组长度固定、Python 列表能自由增删
• Python 变量与运算符 —— 字符串拼接、f-string、input() 要转换，都在那里
• 🍓 树莓派 · 索引 —— 全课路线图