题目考点
这道题主要考的是这几件事：
- 列表 list 的基本操作
- 输入处理
- 字符串拆分
split() - 条件判断
if / elif - 按命令执行不同操作
它本质上不是一道“算法很难”的题，而是一道“按要求模拟”的题。
也就是说，题目给你一条命令，你就老老实实执行一条；再给一条，再执行一条。
这种题的核心能力不是公式，而是：
看懂输入长什么样，然后把输入翻译成对应的 Python 列表操作。
审题
输入是什么
第一行输入一个整数 n，表示后面一共有 n 行命令。
接下来每一行，都是一条命令。命令一共可能有 7 种：
insert i eprintremove eappend esortpopreverse
输出是什么
只有遇到 print 命令的时候，才输出当前列表。
题目要我们做什么
先准备一个空列表，然后：
- 读入一条命令
- 判断这是什么命令
- 对列表执行对应操作
最后不是统一输出，而是：
每出现一次 print，就立刻打印一次当前列表。
容易忽略的点
这里最容易错的不是列表操作本身，而是下面这几个点：
第一点：列表一开始是空的
要先写：
arr = []
第二点：每一行命令要拆开读
比如输入：
insert 1 3
你不能把它当成一个整体乱处理，而是要拆成：
['insert', '1', '3']
这样才能知道：
- 命令名是
insert - 第一个参数是
1 - 第二个参数是
3
第三点：参数默认读进来是字符串
input().split() 得到的内容都是字符串。
比如：
command = input().split()
如果输入是：
append 5
那么 command 实际上是：
['append', '5']
这里的 '5' 还是字符串，不是整数。
所以如果要放进列表里，必须先转成 int。
思路提示
先不要急着写完整代码，先把思路建立起来。
你可以把这道题理解成“命令解释器”：
第一步：准备一个空列表
题目没有直接给你一个现成列表，所以要自己先建一个：
arr = []
第二步：先读有多少条命令
第一行的 n 决定后面要循环读多少次命令。
第三步：每次读一整行命令并拆开
例如：
command = input().split()
这样一行命令就被拆成若干部分。
比如：
insert 1 3
会变成：
['insert', '1', '3']
第四步：先看命令名，再决定做什么
命令名永远在第 0 个位置：
command[0]
所以可以这样判断：
- 如果是
insert，就调用arr.insert(...) - 如果是
append，就调用arr.append(...) - 如果是
print，就print(arr) - 其他命令同理
第五步：有参数的命令，记得把参数转成整数
比如：
arr.append(int(command[1]))
因为 command[1] 本来是字符串。
完整设计思路
这道题可以拆成 4 步来做。
第 1 步：创建空列表
因为题目要求我们“初始化你的列表”。
所以先写：
arr = []
第 2 步：读取命令总数
第一行输入的是 n，表示接下来一共有多少条命令。
n = int(input())
第 3 步：循环读入每一条命令
因为有 n 条命令，所以循环 n 次：
for _ in range(n):
每次读一行，并用 split() 拆开：
command = input().split()
第 4 步：根据命令执行对应列表操作
这里是整题的核心。
情况 1：insert i e
表示在下标 i 的位置插入元素 e。
arr.insert(int(command[1]), int(command[2]))
情况 2：print
表示打印当前列表。
print(arr)
情况 3：remove e
表示删除列表中第一个值等于 e 的元素。
arr.remove(int(command[1]))
情况 4：append e
表示在列表末尾添加元素。
arr.append(int(command[1]))
情况 5：sort
表示原地排序。
arr.sort()
情况 6：pop
表示删除最后一个元素。
arr.pop()
情况 7：reverse
表示把列表反转。
arr.reverse()
代码实现
下面给你一份最基础、最适合初学者理解的写法。
if __name__ == '__main__':
n = int(input())
arr = []
for _ in range(n):
command = input().split()
if command[0] == 'insert':
i = int(command[1])
e = int(command[2])
arr.insert(i, e)
elif command[0] == 'print':
print(arr)
elif command[0] == 'remove':
e = int(command[1])
arr.remove(e)
elif command[0] == 'append':
e = int(command[1])
arr.append(e)
elif command[0] == 'sort':
arr.sort()
elif command[0] == 'pop':
arr.pop()
elif command[0] == 'reverse':
arr.reverse()
运行演示
我们用题目里的例子手动走一遍。
输入：
4
append 1
append 2
insert 1 3
print
开始时
arr = []
第 1 条命令：append 1
拆开后：
['append', '1']
执行：
arr.append(1)
此时：
arr = [1]
第 2 条命令：append 2
拆开后：
['append', '2']
执行：
arr.append(2)
此时：
arr = [1, 2]
第 3 条命令：insert 1 3
拆开后：
['insert', '1', '3']
执行：
arr.insert(1, 3)
意思是：在下标 1 的位置插入 3。
原来：
[1, 2]
插入后：
[1, 3, 2]
第 4 条命令：print
执行：
print(arr)
输出：
[1, 3, 2]
这道题到底该怎么想
这类题最关键的，不是死记命令，而是形成一个固定套路。
以后你看到这种“输入若干条操作命令，让你模拟执行”的题，直接按这个顺序想：
第一步：先问自己，操作对象是什么
这里操作对象是一个列表，所以先建：
arr = []
第二步：命令是怎么输入的
这里每条命令是一整行字符串，所以要用：
input().split()
拆成若干部分。
第三步：命令名放在哪里
通常命令名就在拆分后的第一个位置，也就是：
command[0]
第四步：参数在哪里
后面的内容就是参数，比如：
command[1]command[2]
但要注意把字符串转成整数。
第五步：把“题目命令”翻译成“Python 方法”
例如：
append e对应arr.append(e)insert i e对应arr.insert(i, e)sort对应arr.sort()
你可以把这道题理解成：
题目只是让你做一个“命令 -> Python列表方法”的对照表。
易错点总结
1. 忘记把参数转成整数
错误写法：
arr.append(command[1])
这样放进去的是字符串。
正确写法：
arr.append(int(command[1]))
2. print 命令没有参数
print 这一行只有一个单词，所以不能写：
print(command[1])
这里要打印的是整个列表：
print(arr)
3. sort() 和 reverse() 是列表自己的方法
要写成：
arr.sort()
arr.reverse()
不是：
sort(arr)
reverse(arr)
4. insert 有两个参数
insert i e 不是只插一个值，而是：
- 在哪个位置插：
i - 插入什么值：
e
所以要写：
arr.insert(int(command[1]), int(command[2]))
本节小结
这道题属于非常典型的“模拟执行命令”题。
你以后遇到这类题，可以直接套这个思路：
- 先创建要操作的数据结构
- 读入命令条数
- 每次用
input().split()拆开命令 - 用
if / elif判断命令类型 - 调用对应的方法完成操作
- 遇到输出命令时及时输出
这道题真正练的，其实是你对下面三件事的熟悉程度：
input().split()- 字符串转整数
int() - 列表常用方法
练习
你先自己试一下这道同类型小题，不要急着看答案。
题目
输入若干条命令，对空列表进行操作。命令只有 4 种：
append xpopreverseprint
第一行输入整数 n，表示命令条数。
接下来 n 行，每行一条命令。
要求：按顺序执行命令；每遇到一次 print，输出当前列表。
提示
你可以直接照着今天这题的框架写，只需要把不需要的命令分支删掉即可。
关键提示有两个：
- 每条命令先用
split()拆开 - 先判断
command[0]是什么，再决定调用哪个列表方法
为什么 command = input().split() 是这道题的核心模板
这道题表面上是在考列表操作，实际上更核心的一层，是在考你：
如何把“用户输入的一行命令”拆开，然后交给程序理解。
也就是说，真正的难点不是 append()、insert()、remove() 这些列表方法本身，而是：
程序怎么知道这一行到底是 print，还是 append 3，还是 insert 1 5？
这时候，command = input().split() 就成了整道题最关键的入口。
先从题目的输入本质说起
这道题后面输入的每一行，其实都长这样：
append 1
insert 1 3
remove 2
print
sort
你会发现，这些命令虽然内容不同，但它们有一个共同点：
每一行本质上都是“几个单词拼在一起的一串字符串”。
比如：
"append 1"是两个部分"insert 1 3"是三个部分"print"是一个部分
程序如果想处理它们，就不能把整行当成一整块死字符串，而要先把它拆开。
这就是 split() 出场的原因。
input() 读到的到底是什么
先看这句：
input()
它的作用只是：
把用户输入的一整行读进来。
比如你输入：
append 1
那么：
line = input()
得到的其实是：
"append 1"
注意，这还是一个完整的字符串。
程序这时候只知道这一整行是 "append 1"，但还不知道：
- 命令名是
append - 参数是
1
所以还必须继续拆。
split() 到底做了什么
最常见写法
command = input().split()
这句可以拆成两步理解：
第一步：input()
先读入一整行字符串。
第二步：split()
按照空格，把这一行拆成若干个小字符串。
比如：
"append 1".split()
会得到：
['append', '1']
再比如：
"insert 1 3".split()
会得到：
['insert', '1', '3']
再比如：
"print".split()
会得到：
['print']
所以你可以把 split() 理解成一句很实用的话：
把一行命令，切成一个“单词列表”。
为什么它是“核心模板”
因为这道题的所有命令，虽然内容不同，但格式高度统一：
都是“一行命令 + 若干参数”的形式。
而 input().split() 恰好就能把这种格式统一处理掉。
也就是说，它不是只适合一条命令，而是适合全部命令。
拆开以后，程序就能“看懂命令”了
假设这一行输入是：
insert 1 3
那么：
command = input().split()
得到：
['insert', '1', '3']
这时候程序就能按位置读取信息：
command[0]是命令名：insertcommand[1]是第一个参数：1command[2]是第二个参数：3
所以后面就能写：
if command[0] == 'insert':
i = int(command[1])
e = int(command[2])
arr.insert(i, e)
这就形成了一个非常标准的处理流程：
先拆命令，再取命令名，再取参数，再执行操作。
这就是它为什么是“核心模板”。
为什么不能直接只用 input()
当然可以只写：
line = input()
但只用这个还不够。
因为如果你读到的是：
"append 1"
程序没法方便地直接从中拿出：
- 命令名
append - 参数
1
你当然也可以自己手动切字符串，但那样会非常麻烦，也不适合初学者。
而 split() 已经帮你把最常见的“按空格分隔”的输入场景处理好了。
所以：
input()负责把整行拿进来split()负责把整行拆成多个部分
这两个组合起来，刚好适合这类命令题。
为什么不能直接写成固定变量接收
你可能会想，能不能这样写：
cmd, x = input().split()
有时候可以，但这道题不适合这么写。
因为这道题的命令参数个数不固定：
print只有 1 个部分append 1有 2 个部分insert 1 3有 3 个部分
如果你写成固定两个变量：
cmd, x = input().split()
那遇到 print 时就不够拆，遇到 insert 1 3 时又多出来一个。
所以这种题更适合先统一写成：
command = input().split()
也就是：
先全部拆成列表，再根据具体命令决定要取几个参数。
这比固定变量接收更灵活。
这套模板的本质：统一处理“命令 + 参数”
你可以把它总结成一个通用模型：
一行输入通常长这样：
命令名 参数1 参数2 参数3 ...
经过：
command = input().split()
之后会变成：
[命令名, 参数1, 参数2, 参数3, ...]
然后程序按下面的方式理解：
command[0]：命令是什么command[1:]：命令后面的参数有哪些
这就是为什么很多题里都会看到这种写法。
它不是这道题特有，而是一种很常见的“命令解析模板”。
用几个具体例子彻底看懂
例子 1：append 5
输入：
append 5
拆开后：
['append', '5']
理解为：
- 命令名：
append - 参数：
5
执行：
arr.append(int(command[1]))
例子 2：insert 1 8
输入：
insert 1 8
拆开后：
['insert', '1', '8']
理解为：
- 命令名：
insert - 第一个参数：位置
1 - 第二个参数：值
8
执行：
arr.insert(int(command[1]), int(command[2]))
例子 3：print
输入：
print
拆开后：
['print']
理解为：
- 命令名：
print - 没有参数
执行：
print(arr)
为什么说它比“死记每条命令”更重要
因为列表方法你以后随时可以查，但“命令解析”是很多题都会重复出现的。
比如以后你还会遇到：
- 集合操作命令题
- 字典操作命令题
- 文本编辑器模拟题
- 简单计算器题
- 菜单选择题
它们的共同套路都很像：
- 一行输入一个命令
- 命令可能带参数
- 程序先拆开这行命令
- 再根据命令名执行不同逻辑
所以你真正要记住的不是“这题的 7 个命令”，而是这套框架：
command = input().split()
if command[0] == '...':
...
这才是可迁移的能力。
它和你以前见过的 map(int, input().split()) 有什么区别
这两个写法虽然都用了 split()，但用途不一样。
第一种：map(int, input().split())
适合这一行全都是数字的时候。
比如输入：
1 2 3 4
写成：
nums = list(map(int, input().split()))
得到：
[1, 2, 3, 4]
这里整行都是数字，所以可以统一转成 int。
第二种：command = input().split()
适合这一行既有文字命令，又有数字参数的时候。
比如：
append 5
如果你写：
list(map(int, input().split()))
就会出错，因为 append 不能转成整数。
所以这类命令题必须先保留字符串形式：
command = input().split()
然后再只把参数部分转成整数。
例如：
e = int(command[1])
这就是两者最大的区别。
这道题里的标准思维顺序
以后碰到这类题，你可以固定按下面的顺序想：
第一步：这一行输入是不是“命令 + 参数”结构
如果是，那么优先考虑：
command = input().split()
第二步：先取命令名
通常就是：
command[0]
第三步：看这个命令需要几个参数
例如：
print不要参数append需要 1 个参数insert需要 2 个参数
第四步：只把参数转成整数
例如：
int(command[1])
int(command[2])
第五步：执行对应操作
这样思路就很稳定，不容易乱。
初学者最容易犯的几个错误
错误 1：以为 split() 后就是整数
不是。
例如：
command = "append 5".split()
得到的是：
['append', '5']
这里的 '5' 还是字符串。
所以必须写：
int(command[1])
错误 2：忘了不同命令参数个数不同
比如 print 没有 command[1]。
所以不能统一写：
x = int(command[1])
否则遇到 print 就会报错。
一定要先判断命令类型，再决定要不要取参数。
错误 3：把命令名也拿去转整数
错误写法：
command = list(map(int, input().split()))
如果输入是：
append 5
程序会报错，因为 append 不能变成整数。
方法总结
command = input().split() 之所以是这道题的核心模板，不是因为它写法特殊，而是因为它正好解决了这道题最本质的问题：
如何把一整行“命令文本”变成程序能理解的结构。
你可以把它记成一句非常实用的话：
先把命令拆成列表，再按位置取命令名和参数。
以后只要题目是这种格式：
命令 参数1 参数2 ...
你都应该优先想到这套模板。
一眼识别这类题的标志
以后你如果看到题目有这些特征，基本就该想到 input().split()：
- 输入里有很多“一整行命令”
- 命令前面是英文单词
- 后面可能跟参数
- 不同命令参数个数不同
- 需要按顺序模拟执行
只要符合这几条，十有八九就是这个模板。
补一个更通用的理解
其实你可以把：
command = input().split()
理解成是在做一件事：
把“人说的话”翻译成“程序可以按位置读取的数据”。
例如人输入：
insert 1 3
程序不直接理解“在 1 的位置插入 3”这句话，
但它能理解：
['insert', '1', '3']
所以这一步，本质上是在做“格式化输入”。
这就是它的价值。
练习
你可以先自己做一个小练习，专门练这个模板。
题目
输入 5 行命令，每行命令只有两种可能：
add xshow
准备一个空列表：
- 遇到
add x，把整数x加到列表末尾 - 遇到
show，打印列表
提示
你只需要先想这两件事：
- 每行命令是不是应该先用
input().split()拆开？ add x和show拆开后，分别会长成什么样？
