简介：一份面向K12阶段Python学习者的期末复习知识点整理，覆盖输入输出、字符串操作、列表操作、自定义排序、桶排序、二分查找、条件执行、函数与模块、异常处理、面向对象等10个专题，适合备考期末、系统回顾基础语法与常见算法。资源为单个docx文档封装，共1个文件，压缩包仅865KB，下载后可直接用Word打开，按章节速览或打印复习均可。目前已有439人学习浏览，内容针对性强且示例丰富。文档以条目加代码示例的方式呈现，不仅梳理了列表去重并保持顺序、切片逆序的内存特征、深浅拷贝差异、进制转换等易错点，还通过具体案例演示了二分查找和桶排序的实现思路，能帮助读者在考前快速识别高频考点、巩固薄弱环节，也可作为日常上机练习的速查手册。

1. 一张Python期末复习地图：先看懂六类考点

期末复习最怕的不是题难，而是不知道从哪里下手。把考过的卷子翻出来对比一下，Python这门课其实就考六块内容：基础输入输出与字符串操作、列表与切片、排序与去重、常用算法与内置函数、数据类型的底层细节、函数与面向对象。对K12阶段用Python备考的人来说，前面两块是机考程序题的“送分题”，但很多人恰恰挂在input().split()和print()的参数上；后面两块是选择题和判断题的“扣分坑”，考的全是平时没留意的边界行为。这份复习笔记按“先基础操作、再算法、后理论细节”的顺序，把期末卷子上可能出现的考点全部串成一张地图，每一条都配上可直接默写的代码段，复习时对着过一遍就行。

2. 输入输出与字符串：机考的入场券

2.1 input().split() 与 map() 的三种组合

机考第一行代码多半是读数据，但这一行就有三种写法，分别对应三种场景，混用必出 bug。

第一种是用map()批量接收并转换类型：

a, b, c = map(int, input().split())

input()读进来的是字符串，.split()默认按空格把字符串切成一串，map(int, ...)再把每个切片转成整数，最后解包给三个变量。注意一点，input().split()的括号里如果什么都不写，就是按“任意空白字符”切分，空格、制表符、换行都算。

第二种是用一个变量接收，得到的是字符串列表：

A = input().split()

此时A的类型是list，里面的元素全是字符串。如果你后面拿它做数值运算，必须先转类型。

第三种是用多个变量直接接收字符串：

A, b = input().split()

这种方式适合“字符之间用什么分隔取决于 split() 函数”的题目，比如输入格式是a,b，就写input().split(',')。考试里最常见的翻车点是把第一种和第二种混用——接收端是两个变量，输入却有三段数据，直接抛ValueError。

2.2 print() 的参数：不只是把东西打出来

print()是期末选择题的常客，需要把签名记牢：

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

• objects：要输出的对象，可多个，用逗号分隔。
• sep：多个对象之间的分隔符，默认是空格。想输出逗号分隔就写sep=','。
• end：结尾字符，默认'\n'。写end=''可以取消换行。
• file：输出到哪，默认sys.stdout，可以改成文件对象。
• flush：是否刷新缓冲区，默认False。

考试里最容易出判断题的是file和flush这两个冷门参数。很多人只记得sep和end，看到file=sys.stdout就懵。其实你就理解成“print 默认往屏幕写，带上file=xxx就往文件写”，flush=True表示立即把缓冲区的内容写出去，一般只在实时日志场景用。

2.3 字符串处理的常用方法

字符串这边有一个高频操作：排序 + 去重。经典写法是先转成集合去重，再排序输出：

s = list(set(input())) s.sort() print(''.join(s))

拆开解释：字符串转set自动去重，list()包一下让它可以排序，sort()原地按字典序排列，最后''.join(s)把字符列表拼回字符串。这个组合套路在“统计字符种类”和“按字典序输出”的题目里几乎是模板。

另外，蓝桥系算法题从 2022 年这类题的出法来看，字符串处理还会结合输入格式来考。比如读入一串逗号分隔的数据，然后按“首次出现顺序去重”输出：

s1 = input().split(',') s2 = list(set(s1)) print(sorted(s2, key=s1.index))

set(s1)去重，但集合本身无序，所以用sort(key=s1.index)按照它们在原列表里第一次出现的位置排序，达到“去重且保序”的效果。这里list(set(s1))的顺序是随机的，必须靠key参数拉回来，漏了这一步输出顺序就会跟原串对不上。

字符串的删除和填充方法也容易在选择题里出现：

• strip()：删除字符串两端的指定字符，默认删空白。
• lstrip()：只删左边。
• rstrip()：只删右边。
• ljust(n)：字符串长度不够n时，在右边补空格到n位，超了就直接返回原串。
• partition(sep)：按分隔符切成三段，返回三元组(分隔符之前, 分隔符本身, 分隔符之后)，没找到分隔符就返回(原字符串, '', '')。
• ''.join(x.split())：去掉字符串里的指定字符再拼回来，本质是“先切掉再重组”。

3. 列表操作与排序去重：最容易拿分的算法基础

3.1 列表的三种逆序方式和两种排序后果

列表逆序是期末必考点，三种方式各有各的脾气：

lst = [1, 2, 3, 4, 5] # 方式1：sort(reverse=True)，原地降序排序 lst.sort(reverse=True) # 方式2：reverse()，原地反转 lst.reverse() # 方式3：切片 [::-1]，生成新列表，原列表不变 new_lst = lst[::-1]

三者区别必须背清楚：前两种会改变原列表，第三种产生一份新副本，原列表原封不动。切片方式要额外占内存，因为它把元素复制了一份，而且可读性不如前两者；但如果你需要“保留原列表、单独拿逆序结果”，只能用切片。

排序场景下，sort()和sorted()的选择题陷阱：

• lst.sort()是原地排序，返回None，打印它输出None，但lst本身已经变了。
• sorted(lst)返回排序后的新列表，原列表不变。
• 同理，lst.reverse()返回None，reversed(lst)返回一个迭代器。

很多人考场上写print(lst.sort())，结果控制台输出None，当场蒙住。记住一句话：原地操作的方法返回 None，返回新对象的是函数。

3.2 sort() 的 key 参数：数位排序实战

sort()有两个可选参数：key和reverse。key接收一个函数，排序时先用这个函数算出每个元素的“排序键”；reverse=True表示降序。

竞赛真题的经典考法是按“数字各位之和”排序。比如给定 1 到 n，按每个数各位数字之和从小到大排序，求和相同就按数值本身排，然后输出第 m 个数：

n = int(input()) # 范围上界 m = int(input()) # 第 m 个数 s = list(range(1, n + 1)) s.sort(key=lambda x: sum(int(i) for i in str(x))) print(s[m - 1])

代码里str(x)把数字变成字符串，int(i) for i in str(x)遍历每一位并转回整数，sum()求和得到“数位和”，lambda 把它作为排序键。注意列表下标从 0 开始，取第 m 个要写成s[m - 1]。这道题的复习价值在于：排序不只是排数字大小，key参数让你完全自定义“按什么排”，这是期末最后一道大题的常见考点。

3.3 桶排序/计数思想：字典模拟桶

桶排序的应用题通常长这样：输入一串自然数，统计每个数字出现的次数，按自然数从小到大输出“数字 次数”。

n = int(input()) num_list = list(map(int, input().split())) count_dict = {} for num in num_list: count_dict[num] = count_dict.get(num, 0) + 1 sorted_nums = sorted(count_dict.keys()) for num in sorted_nums: if count_dict[num] > 0: print(num, count_dict[num])

这里的关键是dict.get(num, 0)：键不存在时返回默认值 0，存在就返回当前计数，然后加 1。这比写if num in count_dict再分支要简洁，是期末考里非常实用的计数模板。排序输出时只对键排序，因为count_dict.keys()已经天然去重。

3.4 二分查找模板

二分查找是所有排序题的“后续动作”，在有序列表中查找目标值：

def find(nums, target): left, right = 0, len(nums) - 1 while left < right: mid = (left + right) // 2 if nums[mid] == target: return mid elif nums[mid] < target: left = mid + 1 else: right = mid - 1 return -1 a = list(map(int, input().split())) a.sort() target = int(input()) print(find(a, target))

复习时务必注意循环条件。上面这份代码里写的是while left < right，对应区间只有一个元素时不进循环，如果目标恰好是那个元素，会直接返回-1。更稳妥的写法是while left <= right，这样单个元素的区间也能被检查到。考场上如果发现“只有一个数查不到”，先检查这里。

4. 数据类型与比较运算：期末客观题的丢分重灾区

4.1 可变与不可变类型

期末考试判断题最爱问“下面哪个是可变类型”。把这张表背熟，考试时基本不用犹豫：

这道题还有一种考法：列表中存元素，哪些能放、哪些不能放。集合的元素可以是元组，因为元组不可变；但不能是列表，因为列表可变的 hash 值会变。同理，列表不能作为字典的键，字符串和元组可以。

4.2 序列、映射与集合的底层细节

序列类型包含字符串、列表、元组，共同点是元素之间存在先后关系、通过序号访问。字典是映射类型，存的是“键值对”，不支持双向索引——你能通过键找值，但不能通过值找键。

集合这边有三个容易混淆的考点：

• 集合自动升序排列，自动去重，所以无法添加相同数值。
• 集合不能用下标访问元素，也不能用del删除部分元素（要删就删除整个集合或用remove/discard）。
• 集合之间比较大小是看“包含关系”，不是看元素个数。{1,2} < {1,2,3}结果为True，因为后者包含前者。

还有一个经典的元组坑：

a = (3) # 类型是 int b = (3,) # 类型是 tuple

单个元素的元组必须有逗号，否则括号只是优先级的符号。

4.3 比较运算与进制转换的易错细节

这里集中整理几个选择题高频细节，每条都是“看懂了就不会错”的送分题：

• 0.4 - 0.1 == 0.3的结果是False。浮点数在二进制下无法精确表示，比较两个小数是否相等不要用==，用math.isclose()。
• 复数之间只能比较是否相等，不能比较大小。complex对象没有大小关系。
• 两个元组比较时，先比元素个数；个数相同再从左到右逐位比较元素，元素类型不同则无法比较。
• int('abc', x)表示把 x 进制下的字符串abc转换成十进制整数。x的范围是 2 到 36，且每一位数字不能超过x-1。例如int('123', 16) = 1*16^2 + 2*16 + 3 = 291。
• a & b、a | b是按二进制位进行的运算，不是逻辑与和逻辑或。
• a[:0] = [a, b]可以在列表头部插入元素；a[0:0]是空列表，切片本身就是浅复制。

4.4 赋值与拷贝：共享引用还是独立副本

这是列表考点里翻车率最高的一个，必须动手敲一遍：

x = [1, 2, 3] y = x # 共用同一个列表，id相同，一方改全变 z = x[:] # 浅拷贝，新列表，id不同，互不影响 y.append(4) # x 也变成 [1, 2, 3, 4] z.append(5) # x 不受影响，仍是 [1, 2, 3, 4]

y = x只是把x的引用复制了一份，两者指向同一块内存；“列表的切片是浅复制”这句话要背下来，x[:]虽然生成了新列表，但如果列表里装的是可变对象，内层对象仍然是共享引用。考试里画内存图题，只要看到=直接赋值，就默认两边联动；看到切片、copy()，就默认是独立头对象。

5. 函数、作用域与面向对象：从语法到设计思想

5.1 函数定义的边界行为

函数部分的选择题，通常围绕这几条展开：

• if __name__ == '__main__':的作用是保证代码可重用。当这个文件被当作脚本直接运行时，条件成立；被别的模块import时，条件不成立，避免执行测试代码。
• 函数内可以用global声明全局变量，用nonlocal修改嵌套函数外层的变量。
• 变量作用域的查找优先级：局部 > 外部（nonlocal）> 全局 > 内建。
• globals()返回当前作用域所有全局变量的字典，locals()返回局部变量的字典，这两个函数名在判断题里经常出现。
• 函数形参的默认值在定义时求值，不是每次调用时求值——这条虽然正文没细讲，但复习时看到“默认参数为可变对象”的题要警惕，建议用None占位再在函数内部判断。

迭代器与生成器也是一组固定考点：iter()和next()是迭代器的两个核心方法；函数里含yield语句就是生成器函数，调用它返回生成器对象。生成器是惰性求值的，用for遍历时逐个产生值。

5.2 lambda 与内置函数速查

期末卷子上有几组内置函数，基本年年出现：

• map(func, seq)：把seq的每个元素传给func，返回新序列。map(int, input().split())就是把每个字符串转成整数。
• enumerate(seq)：同时拿到计数器（默认从 0 开始）和元素值，返回元组序列。
• divmod(a, b)：返回(a // b, a % b)，用两个变量接收商和余数。
• ord(char)：查看字符的 Unicode 编码值。
• isinstance(obj, class)：判断对象是否属于某个类或类型的实例。任何对象都是object的实例，所以isinstance(x, object)永远为True。
• random.choices(population, k=length)：从序列中随机选 k 个字符，允许重复；random.sample(population, k)随机选 k 个，不允许重复。生成随机验证码常用string.ascii_letters + string.digits作为字符池。

5.3 类、构造函数与私有命名规则

面向对象这部分，先把基础背熟：

• 三个基本特征：封装、继承、多态。
• 构造函数名称固定为__init__，创建对象时自动调用。
• 类内部用def定义方法，实例方法的第一个参数必须是self，代表实例本身。
• 实例方法只能在创建对象之后调用，因为方法内部要引用实例的属性，而这些属性在__init__执行后才存在。
• 类的命名通常首字母大写，方法名全小写、单词间用下划线连接。

协变名词的那个坑：类里以下划线开头的命名有三种含义，判断题最爱混着考：

• _xxx：约定俗成的“私有”属性，提醒别人别直接调用，但 Python 不强制。
• __xxx：双下划线开头、不以双下划线结尾，会触发名字改名（Name Mangling），外部实际访问名变成_类名__xxx。
• __xxx__：双下划线开头结尾，是特殊方法，比如__init__，一般由 Python 解释器调用。

写类的时候最常见的报错是missing 1 required positional argument: 'self'，原因就是没创建对象直接调用了实例方法。记住先对象 = 类名()，再对象.方法()。

6. 考前一周的复习清单与查漏补缺方法

期末复习最后一周，不要再看整本书，直接对着下面的清单自测，每一条能不看代码写出来就算过关：

我的复习习惯是把所有“返回 None”的方法单独列一页纸。list.sort()、list.reverse()返回None，list.append()、list.extend()也返回None——它们都是原地操作，打印必出None。每次考场上看到有人盯着None发呆，我就知道他又踩了这个坑。从那以后，每次遇到“方法还是函数”的判断题，我强制自己先问一句“它会改变原对象吗”，再决定返回值是什么。这个方法帮我避开了几乎所有排序相关的选择题陷阱。

最后分享一个考前两小时的快速过法：把这份笔记里的代码块全部遮住，只看题目，脑子里默写代码，写不出来就标红，考前一小时只看标红部分。把输入输出三件套、排序 key 参数、去重保序、二分查找这四段模板背到肌肉记忆，期末程序题的基本盘就稳了。希望这份整理能帮到你，复习顺利。

本文还有配套的精品资源，点击获取