企业官网建设流程全解析

简介：面向准备全国计算机等级考试二级Python科目的考生，这份题库也适合高校课程复习与编程入门自测，重点解决真题训练、答案核对和薄弱环节定位的问题。压缩包共205个文件、约831KB，主体为129个py脚本，覆盖编程题示例与可运行代码；50个txt多为题目、答案及解析文本，16个png和4个jpg用于界面与运行结果截图，另有md刷题经验、dat与csv测试数据及license说明，按题型检索较方便。已有4478人学习下载，在备考群体中具有一定参考价值。读者可用于选择题和操作题训练，对照答案复盘基础语法、函数、列表字典、面向对象、文件读写、异常处理与简单算法思路，并借助脚本和测试数据复现运行过程，逐步形成刷题、纠错与查漏补缺的完整路径，并熟悉考试常见题型与作答节奏。

1. 知识地图：二级 Python 的分数是怎么分布的

一份好用的 python计算机二级题库（附带答案），价值不在题多，而在它能让你看清分数分布。整套卷子 100 分：选择题 40 分，其中公共基础知识 10 分、Python 语法 30 分；操作题 60 分，分基本操作 15 分、简单应用 25 分、综合应用 20 分。反直觉的地方在于，很多人把时间全砸在最后一道综合题上，而真正拉开差距的是基本操作题和选择题里的语法细节——这两块几乎全是"记住就得分、记错就丢分"的硬知识点。这份笔记面向两类人：零基础想一次过线的，以及上次差几分、需要查漏补缺的。整条复习线是：先看知识地图，再按模块过要点，最后落到易错点和复习清单上。

2. 公共基础知识：四块最容易被跳过的送分题

公共基础知识只占 10 分，但它有个特点：考点极其固定，翻来覆去就那几十个结论。放弃它等于白送 10 分，认真过两天就能拿满。这部分不需要理解推导，需要的是把结论记准、把相似概念分清。

2.1 数据结构与算法：复杂度、栈队列、树与排序查找

先分清两大类：线性结构（线性表、栈、队列）和非线性结构（树、图）。线性表的两种存储方式几乎是必考对比点：

栈是"后进先出"，只在栈顶操作；队列是"先进先出"，队头删除、队尾插入。循环队列的元素个数公式是(rear - front + m) % m，其中 m 是容量，这个式子考过很多次，记不住就容易在选择题上翻车。

二叉树的四条性质必须背熟：第 k 层最多2^(k-1)个节点；深度为 m 的二叉树最多2^m - 1个节点；叶子节点数 = 度为 2 的节点数 + 1，即n0 = n2 + 1；完全二叉树按层编号后，节点 i 的左孩子是 2i、右孩子是 2i+1、父节点是 i//2。遍历方式记住"前序根左右、中序左根右、后序左右根"。

排序算法的对比表是选择题的高频来源：

这张表的重点只有三句话：快排最坏退化到 n²；堆排序额外空间只有 O(1)；稳定的只有冒泡、插入、归并。查找部分记两个数字——顺序查找最多比较 n 次，二分查找最多比较log₂n + 1次，且二分要求"有序 + 顺序存储"，链表上不能直接二分。

2.2 程序设计基础与软件工程：三条主线

这块内容看着杂，其实只有三条主线：程序设计方法、软件生命周期、测试与维护。

结构化程序设计的三条原则是自顶向下、逐步求精、模块化；三种基本结构是顺序、选择、循环。面向对象部分记四个概念：对象是属性加方法，类是对象的抽象，封装是把属性和操作包在一起，继承是多态的前提。

软件生命周期按顺序是：问题定义、可行性研究、需求分析、概要设计、详细设计、编码、测试、维护。需求分析阶段的常用工具是数据流图（DFD）、数据字典、判定树和判定表；详细设计阶段的工具是程序流程图、N-S 图、PAD 图和 HIPO 图。这两组工具特别容易混，记法很简单——带"数据"的在需求阶段，带"图"的偏设计阶段。

测试分两类：白盒测试看内部逻辑，包括语句覆盖、判定覆盖、条件覆盖、路径覆盖；黑盒测试看输入输出，方法有等价类划分、边界值分析和错误推测。测试步骤是单元测试、集成测试、确认测试、系统测试。维护分四种：正确性维护（改缺陷）、适应性维护（适应环境变化）、完善性维护（增加功能，占比最大）、预防性维护（为将来做准备）。

模块设计有一条铁律：高内聚、低耦合。内聚越高、耦合越低，模块独立性越强。选择题常把这句话反过来说，看到"高耦合低内聚"直接排除。

2.3 数据库与关系模型：三级模式与关系运算

数据库系统有三级模式：外模式（用户看到的视图）、概念模式（全局逻辑结构）、内模式（物理存储结构）。三级模式之间靠两级映射联系起来，从而保证数据的逻辑独立性和物理独立性。

E-R 图里，矩形是实体、椭圆是属性、菱形是联系。联系分一对一、一对多、多对多。多对多联系转成关系模式时，必须单独建一张表，把双方的主键都放进去当外键——这是设计题里最常丢分的一步。

关系模型的术语要能对上号：关系就是二维表，元组是行，属性是列，域是取值范围，主键是能唯一标识一行的属性组。关系运算里，选择是挑行、投影是挑列、连接是按条件拼表、笛卡尔积是两表全组合。SQL 部分掌握单表查询和简单分组就够：

-- 按班级统计平均分，只保留平均分超过 80 的班级 SELECT 班级, AVG(成绩) AS 平均分 FROM 学生成绩 WHERE 成绩 IS NOT NULL -- 行级过滤，在分组之前执行 GROUP BY 班级 -- 按班级聚合 HAVING AVG(成绩) > 80 -- 组级过滤，在分组之后执行 ORDER BY 平均分 DESC; -- 排序，DESC 表示降序

这段语句的关键在 WHERE 和 HAVING 的分工：WHERE 过滤的是原始行，不能跟聚合函数；HAVING 过滤的是分组结果，必须跟聚合函数或分组字段。搞混这两者，SQL 题基本就废了。

3. 语法底座：数据类型、运算符与控制流程

选择题的 30 分 Python 部分，绝大部分落在语言基础上。这一章的知识点看起来零散，但考试出题的角度很固定：要么考边界，要么考类型，要么考输出结果。

3.1 数值、字符串与类型转换

Python 的数值类型有 int、float、complex、bool 四种。int 是任意精度的，不会溢出；bool 是 int 的子类，True 参与运算时等于 1。进制前缀三个：0b二进制、0o八进制、0x十六进制。

字符串是不可变序列，支持索引和切片，支持单引号、双引号、三引号三种写法。转义符常用的就几个：\n换行、\t制表、\\反斜杠本身。原始字符串r"..."里的转义符不生效，写路径时特别好用。

类型转换这一组函数必须做到看到名字就知道输入输出：

print(int("12")) # 12，字符串必须是纯整数形式 print(int(float("3.9"))) # 3，先转 float 再截断；直接 int("3.9") 会抛异常 print(round(2.675, 2)) # 2.67，浮点数二进制表示的精度问题 print(7 // 2, -7 // 2) # 3 -4，整除是向下取整，不是截断 print(7 % 3, -7 % 3) # 1 2，取模结果的符号跟随除数

最后两行最容易错。很多人凭直觉以为-7 // 2等于 -3，实际是 -4，因为整除向下取整；取模的符号跟着除数走，所以-7 % 3是 2 而不是 -1。这类题在选择题里出现的频率很高，靠感觉做必错，靠规则做秒杀。

3.2 运算符与优先级

运算符分七类：算术、比较、赋值、逻辑、位、成员（in / not in）、身份（is / is not）。优先级从高到低大致是：**> 一元正负号与~>* / // %>+ -> 移位 >&>^>|> 比较运算符 >not>and>or> 赋值。记不住全表也没关系，加括号永远不出错。

真正要理解的是 and 和 or 的行为：它们有短路特性，而且返回的不是 True/False，而是决定结果的那个操作数。

print(0 or "默认值") # 默认值，or 返回第一个为真的操作数 print("有值" and 100) # 100，and 返回最后一个为真的操作数 print([] or {}) # {}，空列表为假，继续看右边 name = "" print(name or "匿名") # 匿名，这是取默认值的常用写法

另一组高频对比是==和is：==比较值是否相等，is比较是不是同一个对象（内存地址）。小整数 -5 到 256 有缓存机制，两个相同的小整数用 is 判断会返回 True，超出这个范围就可能变 False。这种题看着像玄学，其实规则很明确：判断值用==，判断 None 用is None，其余场景别用 is。

3.3 分支与循环：range、break/continue 与循环 else

分支就三种写法：if、if-else、if-elif-else，外加一个条件表达式a if cond else b。注意 elif 可以有很多个，但 else 最多一个且必须放最后。

循环的重点全在 range 上。range(start, stop, step)三个参数，start 默认 0，step 默认 1，stop 永远取不到。三个参数都必须是整数，写成range(1, 5, 0.5)会直接报错。遍历字符串、列表、字典、文件对象都用 for，字典默认遍历的是键。

break 跳出当前这一层循环，continue 跳过本次进入下一次循环，这两个好理解。真正容易忽略的是循环的 else 子句：它不是在循环结束后无条件执行，而是在循环没有被 break 打断时才执行。

# 判断质数：else 属于 for，循环正常跑完才会执行 n = 97 for i in range(2, int(n ** 0.5) + 1): if n % i == 0: print(n, "不是质数") break # 一旦 break，下面的 else 就不执行 else: print(n, "是质数") # 一次都没被整除，说明是质数

这段代码有两个细节值得记：int(n ** 0.5) + 1里的加一是为了保证边界不漏，range 取不到终点；else的缩进和for对齐，不是和if对齐。嵌套循环里，break 只跳出最内层，想跳出多层要么用标志变量，要么用函数加 return。

3.4 输入输出与格式化

input()的返回值永远是字符串，这是操作题第一道坎。要拿数字就得转换，常见写法是n = int(input())或n = eval(input())。eval 能把"[1,2,3]"直接变成列表，做题时很方便，但要知道它本质是执行表达式。

print()的两个参数经常被忽略：sep控制多个值之间的分隔符，默认是空格；end控制结尾字符，默认是换行。输出一排数字不换行，就写print(x, end=" ")。

格式化有三种方式，考试三种都可能出现，但 f-string 最省事：

name, score = "A同学", 92.456 print("姓名：{}，成绩：{:.1f}".format(name, score)) # format 方式，按位置填 print(f"{name}的成绩是{score:.2f}分") # f-string，变量直接嵌进去 print(f"{'得分':>6}{score:>10.2f}") # 宽度写在冒号后，用来对齐表格 print(1, 2, 3, sep="-", end="\n") # sep 改分隔符，end 改结尾

对齐那一行是操作题里做出"好看输出"的关键：冒号后面的>表示右对齐、<左对齐、^居中，数字表示总宽度。格式符和数据类型必须匹配，{:.2f}套在字符串上会直接抛异常，这也是常见翻车点。

4. 组合数据类型、函数与文件：分值最重的骨架

操作题 60 分，几乎全部建立在组合数据类型、函数和文件这三块上。基本操作题考列表和字符串，简单应用题考字典和函数，综合应用题考文件加统计。这一章的内容必须能徒手写出来，不能只是看懂。

4.1 列表与元组：切片、排序与拷贝

列表是可变有序序列，元组是不可变有序序列。两者的方法集差别很大，元组只有 count 和 index 两个方法。

这张表里最容易错的是返回值：append、extend、sort、reverse 全都返回 None，是原地修改。写成a = a.append(1)之后 a 就变成 None 了，这是血泪经验级别的坑。

切片是[start:stop:step]，三个参数都可省略，同样取头不取尾。负索引从 -1 开始，a[::-1]是反转，a[::2]是隔一个取一个。切片不会因为越界报错，a[0:100]超出长度也只是取到末尾为止。

a = [1, 2, 3] b = a # 别名：两个名字指向同一个列表对象 c = a[:] # 浅拷贝：新建一个列表，元素还是原来那些 b.append(4) print(a, c) # [1, 2, 3, 4] [1, 2, 3]，c 不受影响

浅拷贝只复制第一层，如果列表里装的是列表，内层仍然是共享的，要彻底独立就得用copy.deepcopy()。元组本身不可变，但如果元素是列表，列表内部还是能改，这个反直觉点选择题考过。

4.2 字典与集合：键值操作与去重

字典是键值对集合，键必须可哈希（数字、字符串、元组可以，列表和字典不行），键唯一，值随意。常用方法记住五个：get(k, default)取不到时返回默认值而不报错；keys()、values()、items()返回三个视图；pop(k)删除并返回；update(d)合并另一个字典。

集合用set()创建，注意空集合不能写{}，那是空字典。集合自动去重，支持交&、并|、差-、对称差^四种运算，判断子集用issubset()。

text = "数据 分析 数据 可视化 数据" freq = {} for w in text.split(): freq[w] = freq.get(w, 0) + 1 # get 给默认 0，避免 KeyError result = sorted(freq.items(), key=lambda kv: kv[1], reverse=True) print(result) # [('数据', 3), ('分析', 1), ('可视化', 1)]

这段是综合应用题的典型骨架：分词（或按分隔符切分）、用字典计数、按值排序输出。items()返回的是键值对元组，排序时用key=lambda kv: kv[1]指定按值排、reverse=True指定降序。这个 lambda 写法建议直接背下来，改一改就能用在各种统计题上。

4.3 函数：参数传递、作用域与 lambda

函数的参数有四种：位置参数、默认参数、关键字参数、可变参数。顺序必须是位置在前、默认在后，*args收集多余的位置参数成元组，**kwargs收集多余的关键字参数成字典。

Python 的参数传递是"对象引用传递"，可以理解为传的是地址。所以传列表进函数、在函数里 append，外面的列表也会变；但如果函数里写a = a + [1]这种重新赋值，外面的就不受影响。这个区别是简单应用题的常见考点。

def add_item(item, box=[]): # 默认参数在函数定义时只求值一次 box.append(item) return box print(add_item(1)) # [1] print(add_item(2)) # [1, 2]，不是 [2]，默认列表被复用了

要避开这个坑，默认值写 None，进函数再判断：if box is None: box = []。作用域遵循 LEGB 顺序——局部、嵌套、全局、内置。函数内部想改全局变量要声明global，嵌套函数里想改外层函数的局部变量要声明nonlocal。

lambda 是匿名函数，语法是lambda 参数: 表达式，表达式的结果就是返回值。它最常见的搭档是 sorted 的 key 和 map、filter。递归要记两个要素：终止条件和递推关系，阶乘和斐波那契是标准模板，写的时候先写终止条件再写递推，不容易死循环。

4.4 文件读写：open 模式、with 语句与编码

文件操作的第一关是打开模式：

读有三个层次：read()一次读完整个文件返回字符串，readline()读一行，readlines()读全部返回列表（每行带换行符）。写有write()写字符串，writelines()写字符串列表（不会自动加换行）。用 with 语句打开，文件会在代码块结束时自动关闭，不用手动 close。

# 统计文本文件的行数与最长行 with open("score.txt", "r", encoding="utf-8") as f: lines = f.readlines() print("行数：", len(lines)) longest = max(lines, key=len).strip() # strip 去掉行尾的换行符 print("最长行：", longest) # 追加写入，a 模式不会清空原内容 with open("result.txt", "a", encoding="utf-8") as f: f.write(f"共{len(lines)}行\n")

encoding="utf-8"这一项强烈建议每次都写。不写的话，很多环境会用系统默认编码，读中文文本直接抛 UnicodeDecodeError，或者读出来是乱码。这类问题不报错但结果不对，比报错更难查。读 CSV 文件用 csv 模块的 reader 和 writer，比手工 split 靠谱，因为带引号的字段里可能有逗号。

4.5 标准库与面向对象：turtle、random、jieba、PyInstaller

二级 Python 涉及的库不多，但每个都有固定考点：

random 的两个函数特别容易混：random()返回 [0,1) 之间的小数，randint(a, b)返回 [a, b] 之间的整数且包含两端；randrange(a, b)才是取头不取尾。这个差别几乎每年都以不同形式出现。

import turtle t = turtle.Turtle() t.pensize(2) for i in range(5): # 正五边形，5 条边 t.forward(100) # 每次前进 100 像素 t.right(72) # 外角 = 360 / 5 = 72 度 turtle.done() # 保持窗口不关闭

画正多边形的通用模板就是"边数循环 + 每次转 360/边数 度"，把 5 换成 6 就是六边形。如果题目要求填充颜色，就在循环前begin_fill()、循环后end_fill()，中间用fillcolor()设颜色。

# -F 打包成一个独立的可执行文件，-w 运行时隐藏命令行窗口 pyinstaller -F -w main.py

-F和-w是最常考的两个参数，前者控制"一个文件"，后者控制"窗口程序"。打包后的可执行文件在 dist 目录下。

面向对象部分掌握最小集就够：用 class 定义类，__init__是构造方法，第一个参数固定写 self，self.属性名定义实例属性。继承写成class 子类(父类)，子类里用super().__init__()调父类构造。异常处理记try / except / else / finally四个块的分工：try 放可能出错的代码，except 捕获指定异常，else 在没有异常时执行，finally 无论怎样都执行。

class Student: def __init__(self, name, score): self.name = name self.score = score def level(self): return "优秀" if self.score >= 90 else "合格" s = Student("A同学", 95) print(s.level()) # 优秀，方法调用时要带括号

注意最后一行：s.level是方法对象，s.level()才是调用结果。选择题里经常给一个不带括号的方法名让你判断输出，答案是打印出方法的内存地址描述，不是"优秀"。

5. 易错点清单：五个最容易翻车的地方

刷题库时你会发现，错的题来来回回就那么几类。把它们单独摘出来，比多刷一百道新题有用。

5.1 边界差一：range 与切片的"取头不取尾"

易漏点：几乎所有和范围有关的题，都栽在这个"取不到终点"上。range(1, 10)是 1 到 9，a[0:3]取的是前三个元素，循环里for i in range(len(a))最后一个下标是 len(a)-1。

为什么漏：日常说话习惯"1 到 10"包含 10，写代码时手比脑快，凭语感就写成了range(1, 10)。这个偏差在计数类题目里会被放大——统计个数、累加和、输出序号，差一个就是全错。

怎么补：写完之后立刻做个自检，把 range 的两个端点念出来："从几开始、到几之前停"。涉及长度的地方统一用len(a)和range(len(a))配对，涉及第 n 个元素的地方明确写成a[n-1]。切片反向同理，a[-1]是最后一个，a[-2:]是最后两个。

5.2 可变对象：别名、浅拷贝与默认参数

易漏点：b = a不是复制而是起别名；a[:]只复制一层；函数的默认参数如果是列表或字典，会在多次调用之间共享。

为什么漏：这三种写法在语法上都完全合法，运行也不报错，只是结果和预期不一样。没有报错提示，人就不会警觉，只有对答案的时候才发现数值不对。

怎么补：记住一条判断标准——只要涉及列表、字典、集合的"复制"，先问自己要不要独立。要独立就用list(a)、a[:]、dict(a)，嵌套结构用copy.deepcopy()。函数默认参数一律写 None，函数体第一行判断并初始化。做题时看到函数定义里出现=[]或={}，条件反射地标个红。

5.3 循环里边遍历边删除

易漏点：for x in a: if 条件: a.remove(x)这种写法会漏删元素，因为删除后后面的元素整体前移，而迭代器下标还在往前走。

为什么漏：逻辑上完全说得通——遍历每个元素，不合格就删掉。问题出在迭代过程依赖下标，而删除操作改变了长度，遍历和修改同时进行，行为就不可预期了。

怎么补：要么遍历副本for x in a[:]，删的还是原列表；要么用列表推导式重建a = [x for x in a if 条件]；要么倒着遍历for i in range(len(a)-1, -1, -1)。三种写法里第二种最稳，也最像 Python 的写法。

5.4 文件编码与关闭

易漏点：open 时不写 encoding 导致中文乱码或抛异常；忘记 close 导致内容没真正写进文件；w 模式打开已存在的文件会把内容清空。

为什么漏：编码问题和运行环境有关，本机跑得好好的，换台机器就出错。close 的问题更隐蔽，程序没结束前看不出差异，等发现时文件内容已经丢了。

怎么补：所有 open 一律写encoding="utf-8"，养成肌肉记忆。读写统一用 with 语句，让它自动关。想追加内容就用 a 模式，别用 w。处理 CSV 用 csv 模块，别自己 split 逗号。

5.5 格式化符号与类型不匹配

易漏点：{:.2f}用在字符串上、{:d}用在浮点上、input 拿到的字符串直接参与算术运算。

为什么漏：格式符看起来只是"控制显示",实际还隐含了类型检查。类型不对时抛的是 ValueError 或 TypeError，报错信息指向格式化那一行，容易误以为是引号写错了。

怎么补：写格式化之前先确认变量类型，input 之后立刻转换，别留到后面。记牢三组对应关系：d对整数、f对浮点、s对字符串。数字要显示成百分比用{:.2%}，会自动乘 100，不需要自己先乘。

6. 复习清单：三轮推进与错题三遍法

复习到后期，最大的问题不是不会，而是不知道自己哪里不会。这时候需要的不是再刷一套新题，而是一张能对照检查的清单和一套可执行的复盘流程。

先给一个可直接照搬的三轮安排：

第二轮是重心，也是最容易走过场的一轮。刷题时建议按模块而不是按套卷推进：先集中把组合数据类型刷透，再刷函数，再刷文件。同一类题连着做，规律会自己浮出来；打散了做，每道题都像新题，效率反而低。

错题的处理用"三遍法"：当天做错的题，当晚重做一遍；三天后再重做一遍；考前一天只看还错的那几道。每一遍只记一件事——为什么错，不抄题干、不抄答案。把原因归到第 5 章那五类易错点里，归类完成，你就知道自己真正的薄弱环节在边界、在可变对象，还是在类型转换。

下面这张自查表可以贴在桌边，每天睡前扫一眼：

还有一个小技巧：把题库里所有操作题的题干通读一遍，只做一件事——给每道题标注它考的是哪个知识点。标完二十道，你会发现高频考点高度集中，重复率远超想象。这一步花不了半小时，但能让你后面每一道题都刷在刀刃上。

我自己的教训是第一次备考时只刷题不整理，错题错了三遍还在错，因为每次都只记住了"这题选 C"，没记住为什么。从那以后我每次做完一套，都强制先走一遍"标知识点、归易错类、写一句原因"的流程，再开始下一套。慢是慢了点，但同样的坑不会再踩第二次。希望帮到你。

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