计算机二级 Python 简单应用题（25 分）真题笔记（0101 ~ 1902 全套）

本文整理计算机二级 Python「简单应用题（25 分）」的常考题型与代码笔记。 编号说明：0101 表示第 1 套第 1 题，0302 表示第 3 套第 2 题，依此类推。 每套 2 题，共整理 19 套（0101 ~ 1902）。
image

目录

第一套（0101 ~ 0102）

0101 四边形

1
2
3
4
5
6
7
8
9
10
import turtle
turtle.right(-30)
turtle.fd(200)  #考点
turtle.right(60)
turtle.fd(200)
turtle.right(120)  #考点
turtle.fd(200)
turtle.right(60)
turtle.fd(200)
turtle.right(120)

考点：turtle.right(角度) 为相对当前方向转弯；turtle.fd(距离) 前进画线。四条边+四个转角凑成 360°。

0102

1
2
3
4
5
6
7
8
9
10
11
12
13
data = input()  # 姓名 性别 年龄  （注解的位置有问题已改好）
s=0  #考点  代表年龄
n=0  #考点  代表男性数目
i=0  #考点  代表总人数     s/i（平均年龄）
while data:
    i=i+1              #考点  每循环一次i+1，题目i=3   i=i+1
    ls=data.split()    #考点  默认按空格切割字符串，把一行文本切分成列表ls
    s=s+int(ls[2])     #重点考点 千万别忘记了 获取年龄信息，转化成int类型，ls[2] int(ls[2])  s=s+int(ls[2])   s+=int(ls[2])
    if ls[1]=='男':    #考点  判断男性                if ls[i]=='男'  n=n+1
        n=n+1          #考点  是男性n+1
    data = input()     #在本轮循环末尾，读取下一行新的输入，更新data。
s=s/i  #考点
print("平均年龄是{:.2f} 男性人数是{}".format(s,n))  #考点

考点：while data: 配合末尾 data = input() 实现连续读入多行；int(ls[2]) 取年龄转整型累加；ls[1]=='男' 统计男性人数；最后求平均年龄并保留 2 位小数。

第二套（0201 ~ 0202）

0201

1
2
3
4
5
6
7
import turtle
turtle.pensize(2)
d = -45    #考点   定义变量d，保存画笔的朝向角度，初始值-45°。  和直角左边系一样
for i in range(4):
    turtle.seth(d)  #left()/right()是相对当前角度转弯；seth()是绝对角度。
    d  += 90   #考点  角度变量 d 增加 90°，下一次循环画笔朝向多逆时针转 90 度
    turtle.fd(200)  #考点  向前画 200 像素的直线

考点：turtle.seth() 设置绝对角度，left()/right() 是相对当前角度转弯；角度变量每次 +=90 实现旋转正方形。

0202（答案有问题）

1
2
3
4
5
6
7
8
9
10
11
12
13
names=input("请输入各个同学行业名称，行业名称之间用空格间隔（回车结束输入）：")
# --------第1个 ... 填空处----------
t = names.split()  #考点                   #把输入一行字符串按空格切割，变成行业名称列表。注意
# --------------------------------      #例："交通 金融 计算机 交通 计算机 计算机" → ["交通","金融","计算机","交通","计算机","计算机"]
d = {}
# --------第2个 ... 填空处----------
for i in range(len(t)):     #考点
    d[t[i]]=d.get(t[i],0)+1  #考点           整个全部都是
# --------------------------------
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse=True) # 按照数量降序排序
for k in ls:
    print("{}:{}".format(k[0],k[1])) # 下划线位置填 k[0],k[1]

考点：split() 按空格切分；d.get(键, 0) + 1 是字典计数万用写法；sort(key=lambda x:x[1], reverse=True) 按值降序排序。

第三套（0301 ~ 0302）

0301

1
2
3
4
5
import turtle
for i in range(4):
    turtle.fd(100)
    turtle.fd(-100)      #考点
    turtle.seth((i+1)*90)  #考点 #left()/right()是相对当前角度转弯；seth()是绝对角度。

考点：fd(-100) 表示倒退（原路返回）；seth((i+1)*90) 用循环变量算绝对角度。

0302

1
2
3
4
5
6
7
8
9
txt = input("请输入类型序列: ")
t = txt.split()  #考点
d = {}
for i in range(len(t)):     #考点
    d[t[i]]=d.get(t[i],0)+1  #考点
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse=True)  # 按照数量排序
for k in ls:
    print("{}:{}".format(k[0], k[1]))

考点：与 0202 同一模板 —— 切分 → 字典计数 → list(d.items()) → 按值降序排序 → 逐项输出。

第四套（0401 ~ 0402）

0401

1
2
3
4
import turtle as t   #t考点
for i in range(3):   #3考点
    t.seth(i*120)    #考点t.seth
    t.fd(200)

考点：import turtle as t 起别名；seth(i*120) 依次转 120° 画三角形。

0402（有问题）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
data = input() # 课程名 考分
d={}
while data:
    ls = data.split(" ")
    d[ls[0]] = int(ls[1])
    data = input()

# 2、将字典转换成有顺序的列表，然后在排序
lt = list(d.items())
lt.sort(key=lambda x:x[1],reverse=True)

# 求平均值
avg = sum(d.values())/len(d.values())
print("最高分课程是{} {},最低分课程是{} {},平均分是{:.2f}".format(lt[0][0],lt[0][1],lt[len(lt)-1][0],lt[len(lt)-1][1],avg))

# 数据：
# 数学 90
# 语文 95
# 英语 86
# 物理 84
# 生物 87

考点：字典存「课程名→分数」；list(d.items()) + sort(key=..., reverse=True) 排序后，lt[0] 为最高分、lt[len(lt)-1]（即 lt[-1]）为最低分；sum(d.values())/len(d.values()) 求平均分。

第五套（0501 ~ 0502）

0501

1
2
3
4
5
6
7
import turtle
turtle.pensize(2)
d = 0
for i in range(1,9):
    turtle.fd(100)   #考点
    d += 45          #考点每次循环转动45度
    turtle.seth(d)   #d转动的角度

考点：循环 8 次、每次转 45°，seth(d) 累计角度画八角星形。

0502（原文标注为 0520）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'''
 
'''
f=open("name.txt")
names=f.readlines()
f.close()
f=open("vote.txt")
votes=f.readlines()
f.close()
f.close()
f=open("vote1.txt","w")
D={}
NUM=0
for vote in votes:  #考点1votes
    num = len(vote.split())
    if num==1 and vote in names:   #考点2names
        D[vote[:-1]]=D.get(vote[:-1],0)+1   #考点3
        NUM+=1
    else:
        f.write(vote)
f.close()
l=list(D.items())
l.sort(key=lambda s:s[1],reverse=True)  #考点4reverse=True
name=l[0][0]    #考点6
score=l[0][1]   #考点7
print("有效票数为：{} 当选村长村民为:{},票数为：{}".format(NUM,name,score))

考点：readlines() 一次读入所有行；len(vote.split())==1 判断是否为单名有效票；vote[:-1] 去掉行尾换行符；D.get(键,0)+1 计票；reverse=True 按票数降序取 l[0]。

第六套（0601 ~ 0602）

0601

1
2
3
4
5
6
7
import turtle
turtle.pensize(2)
d = 0
for i in range(1, 6): #考点
    turtle.fd(100) #考点
    d += 72  #考点
    turtle.seth(d)

考点：5 次循环、每次转 72°（360/5）画正五边形。

0602

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 第一问
f = open("vote.txt")  #打开当前目录下 vote.txt 文件（默认只读r模式）
names = f.readlines() #一次性读取文件所有行，返回列表，每行字符串带换行符\n
f.close()   #关闭文件
n = 0
for name in names:  #遍历文件每一行（name代表一行文本）
    num = len(name.split()) #考点
    if num==1: #考点  分割后只有 1 个单词，有效票 + 1
        n+=1   #考点
print("有效票{}张".format(n))

#第二问
f = open("vote.txt")
names = f.readlines()
f.close()
D = {}
for name in names:   #考点names
    if len(name.split())==1:
        D[name[:-1]]=D.get(name[:-1],0)+ 1  #考点
l = list(D.items())
l.sort(key=lambda s:s[1],reverse=True)   #reverse=True考点
name = l[0][0]
score = l[0][1]
print("最具人气明星为:{},票数为：{}".format(name,score))

考点：两问分别为「统计有效票数」和「统计得票最多的名字」；name[:-1] 去换行；D.get(键,0)+1 计数；按票数降序取第一名。

第七套（0701 ~ 0702）

0701

1
2
3
4
5
6
7
import turtle
turtle.pensize(2)
d=0
for i in range(1,13):
    turtle.fd(40)
    d += 30
    turtle.seth(d)

考点：12 次循环、每次转 30°（360/12）画正十二边形。

0702

1
2
3
4
5
6
7
#请补充若干行代码，完成向量积运算
ls = [111, 222, 333, 444, 555, 666, 777, 888, 999]
lt = [999, 777, 555, 333, 111, 888, 666, 444, 222]
s = 0
for i in range(len(ls)):
    s=ls[i]*lt[i]+s
print(s)

考点：两列表对应元素相乘再累加（向量内积）；注意累加语句写法 s = ls[i]*lt[i] + s。

第八套（0801 ~ 0802）

0801 棺材题画圆

1
2
3
4
5
6
7
8
9
10
11
'''
在横线处补充代码，不得修改其它代码
'''
#PY201.py
import turtle                # 导入turtle海龟绘图库
turtle.pensize(2)            # 设置画笔粗细为2像素
for i in range(4):           # 考点           循环执行4次，绘制正方形
    turtle.fd(200)           # 考点           画笔向前移动200像素（fd=forward）
    turtle.left(90)          # 画笔向左旋转90度
turtle.left(-45)             # 考点           向左旋转-45度，等价于向右旋转45度
turtle.circle(100*pow(2,0.5))# 考点           画圆，半径 = 100乘以根号2；pow(a,b)求a的b次方

考点：先画边长 200 的正方形，再转 -45° 让海龟朝向正方形顶点方向，用 100*pow(2,0.5)（100×√2 即正方形对角线的一半）画外接圆。

0802

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 循环，无限执行，直到遇到break跳出循环
while True:
    # 获取用户输入文本，要求输入不带数字的文本
    s = input("请输入不带数字的文本:")
    # 计数器i，用来统计字符串里数字字符的个数
    i = 0
    # 遍历字符串s中的每一个字符p
    for p in s:
        # 判断字符p是不是数字：字符比较，在"0"~"9"之间就是数字
        if "0" <= p <= "9":
            i = i + 1   # 如果是数字，计数器+1
    # 判断：如果数字个数i等于0，说明输入里面没有数字
    if i == 0:
        break   # 跳出while无限循环，结束输入环节
# 输出最终合法字符串s的长度
print(len(s))

考点：while True + break 做输入校验；"0" <= p <= "9" 判断字符是否为数字。

第九套（0901 ~ 0902）

0901 柱状图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import turtle as t          #考点 导入turtle库，取别名t
ls = [69, 292, 33, 131, 61, 254] # 柱状图每个柱子高度列表
X_len = 400                 # X轴总长度
Y_len = 300                 # Y轴总长度
x0 = -200                   # 坐标轴原点(左下角)x坐标
y0 = -100                   # 坐标轴原点(左下角)y坐标

t.penup()                   # 抬起画笔，移动不画线
t.goto(x0, y0)              # 移动到左下角原点位置
t.pendown()                 # 落下画笔，准备绘图

t.fd(X_len)                 # 向右画X轴（长度400）
t.fd(-X_len)                # 画笔退回原点位置
t.seth(90)                  # 考点 设置画笔朝向：向上（90度）
t.fd(Y_len)                 # 向上画Y轴（长度300）

t.pencolor('red')           # 设置画笔颜色为红色
t.pensize(5)                # 设置画笔粗细5像素
for i in range(len(ls)):    # 遍历ls列表，循环6次，画6根柱子
    t.penup()
    t.goto(x0 + (i+1)*50, y0) # 考点 y0 移动到第i根柱子底部坐标，每根柱子横向间隔50
    t.seth(90)               # 画笔朝上
    t.pendown()
    t.fd(ls[i])              # 向上画线，高度取自ls列表对应值
t.done()                    # 考点 绘图完成，保持窗口不关闭

考点：penup()/goto()/pendown() 组合实现抬笔移动；seth(90) 让画笔朝上；柱子底部 x 坐标按 x0 + (i+1)*50 依次排开；t.done() 保持窗口。

0902（有点难度）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import random
random.seed(2)
# 字典：key是人名，value是列表，里面存放手机号字符串
pdict={'Alice':['123456789'],
    'Bob':['234567891'],
    'Lily':['345678912'],
    'Jane':['456789123']}
name = input('请输入一个人名:')
# 判断输入的name是否是字典的键 以下是考点
if name in pdict:
    # 格式化输出：人名，手机号，4位随机整数
    # pdict.get(name) 获取对应的值（列表），[0]取出列表第一个元素（手机号）
    print("{} {} {}".format(name,pdict.get(name)[0],random.randint(1000,9999)))
else:
    # 字典中没有该人名，提示不存在
    print("对不起，您输入的用户信息不存在。")

考点：if name in pdict 判断字典键是否存在；pdict.get(name)[0] 取出列表中的手机号；random.randint(1000,9999) 生成 4 位随机数。

第十套（1001 ~ 1002）

1001

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import turtle as t                # 考点 导入海龟绘图库，别名t
import random as r                # 导入随机库，别名r
color = ['red','orange','blue','green','purple'] # 颜色列表，存放5种颜色字符串
r.seed(1)                         # 设置随机种子为1，固定随机结果，每次运行图形一样
for i in range(5):                # 循环5次，一共画5个圆
    rad = r.randint(20,50)        # 考点 随机生成半径rad，范围[20,50]整数
    x0 = r.randint(-100,100)      # 考点 随机圆心x坐标，范围[-100,100]
    y0 = r.randint(-100,100)      # 随机圆心y坐标，范围[-100,100]
    t.color(r.choice(color))      # 从color列表随机挑选一个颜色作为画笔颜色
    t.penup()                     # 抬笔，移动到圆心时不画线
    t.goto(x0,y0)                 # 考点 移动画笔到圆心坐标(x0,y0)
    t.pendown()                   # 落笔，准备绘制圆形
    t.circle(rad)                 # 考点 画圆，半径为rad
t.done()                          # 绘图结束，保持窗口打开

考点：r.choice(列表) 随机取色；r.randint() 随机半径与坐标；penup → goto → pendown → circle 是随机画圆的标准四步。

1002

1
2
3
4
5
6
7
8
9
10
11
12
13
14
img = [0.244, 0.832, 0.903, 0.145, 0.26, 0.452]
filter = [0.1,0.8,0.1]
res = []
# 外层循环：img长度6，len(img)-2 =4 → i取0,1,2,3
for i in range(len(img)-2):
    k=0 # 每次滑动窗口计算前，累加器清零
    for j in range(3): # filter一共3个元素，j取0,1,2
        k+=filter[j]*img[i+j] # 卷积：filter[j]乘img窗口内对应元素，累加
        # 格式化输出，:.3f 保留小数点后3位
        print('k={:.3f},filter[{}]={:.3f},img[{}+{}]={:.3f}'.format(k,j,filter[j],i,j,img[i+j]))
    res.append(k) # 将本次窗口计算结果存入res列表
# 遍历结果列表，左对齐，总宽度10字符，保留3位小数，end=""不换行
for r in res:
    print('{:<10.3f}'.format(r),end = "")

考点：滑动窗口卷积（一维），range(len(img)-2) 控制窗口个数，k += filter[j]*img[i+j] 累加；{:<10.3f} 左对齐、宽 10、保留 3 位小数。

第十一套（1101 ~ 1102）

1101 小花

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import turtle as t          # 导入海龟库，别名t
import random as r          # 导入随机库，别名r

r.seed(1)                   # 设置随机种子=1，固定随机结果，每次运行图形完全一样
t.pensize(2)                # 设置画笔粗细为2像素
t.pencolor('red')           # 考点 设置画笔颜色红色
angles = 6                  # 放射线条数量：一共6根
points= [[0,0],[50,40],[70,80],[-40,30]] # 4个绘图中心点坐标列表

for i in range(len(points)):# 考点 外层循环：遍历4个中心点，循环4次
    x0,y0 = points[i]       # 列表解包，取出当前中心点的x,y坐标
    t.penup()               # 抬笔，移动时不画线
    t.goto(x0,y0)           # 考点 画笔移动到当前中心点(x0,y0)
    t.pendown()             # 落笔，准备绘图

    length = r.randint(6, 16)# 随机生成线段长度，取值区间[6,16]整数
    for j in range(angles): # 内层循环，循环6次，画6条放射短线
        t.forward(length)   # 考点 向前画出一段长度为length的线段
        t.backward(length)  # 考点 画笔原路后退length，回到中心点
        t.right(360 / angles)# 顺时针右转 360/6=60度，准备画下一根射线
t.done()                    # 绘图结束，保持窗口不关闭

考点：for i in range(len(points)) 遍历坐标列表，x0,y0 = points[i] 解包；forward + backward 画出从中心点向外辐射的短线；360/angles 求相邻射线夹角。

1102（有点难 01）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 以只读方式打开data.txt文件，编码utf-8
f = open('data.txt','r',encoding='utf-8')
# 创建空字典，用于存放分组数据
dic={}
# 逐行读取文件
for line in f:
    # strip()去掉行首尾换行/空格，split(',')按逗号切分，得到列表l
    l=line.strip().split(',')
    # 如果切分后元素少于3个，说明该行数据无效，跳过这一行
    if len(l)<3:
        continue
    # 字典get方法：取键l[-1]对应的列表；不存在就默认空列表[]，然后追加l[1]
    dic[l[-1]]=dic.get(l[-1],[])+[l[1]]
# 将字典的键值对转成列表，每个元素是元组(键,值)
unis=list(dic.items())
# 排序：按每个元组第2项（列表）的长度排序，reverse=True降序（从大到小）
unis.sort(key=lambda x:len(x[1]),reverse=True)
# 遍历排序后的每一组
for d in unis:
    # 格式化输出：
    # {:>4} 右对齐，占4字符宽度；' '.join(d[1])把列表元素用空格拼成字符串
    print('{:>4}: {:>4} : {}'.format(d[0],len(d[1]),' '.join(d[1])))

考点：line.strip().split(',') 逐行清洗切分；dic.get(键, [])+[值] 向字典中的列表追加元素；sort(key=lambda x:len(x[1]), reverse=True) 按列表长度降序。 ⚠️ 原文最后一行末尾多了一个中文引号 ‘，实际运行需去掉。

第十二套（1201 ~ 1202）

1201 三个正方形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import turtle as t                # 导入turtle库，别名t
import random as r                # 导入random库，别名r
r.seed(1)                         # 设置随机种子=1，固定随机值，每次运行图形不变
t.pensize(2)                      # 设置画笔粗细2像素
for i in range(3):                # 外层循环，一共画3个图形
    length = r.randint(20,80)     # 考点 随机边长，20~80之间整数
    x0 = r.randint(-100, 100)     # 图形起点x坐标，-100~100随机
    y0 = r.randint(-100, 100)     # 图形起点y坐标，-100~100随机

    t.penup()                     # 抬笔，移动时不画线
    t.goto(x0,y0)                 # 考点 移动画笔到起点(x0,y0)
    t.pendown()                   # 考点 落笔，开始绘图
    for j in range(4):            # 内层循环4次，绘制正方形四条边
        t.forward(length)         # 考点forward 向前走length长度，画一条边
        t.setheading(90*(j+1))    # 考点setheading 设置画笔朝向：90°,180°,270°,360°，依次右转90度
t.done()                          # 绘图完成，窗口保持打开

考点：setheading(90*(j+1)) 用循环变量设置绝对朝向画正方形；外层控制图形个数、内层控制边数。

1202（有点难度）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
sumtime = 0                      # 初始化总耗时，累加用
percls = []                      # 定义空列表（本代码里没有用到）
ts = {}                          # 空字典，用于存储操作名称与占比

# with上下文打开文件，自动关闭文件，'r'只读模式
with open('out.txt', 'r') as f:
    for i in f:                  # 逐行读取文件每一行
        i = i.strip().split(',') # strip去除首尾换行空格，split按逗号切分成列表
        ts[i[0]] = i[2]          # 字典：键=i[0]操作名，值=i[2]占比字符串
        sumtime += eval(i[1])    # eval把字符串i[1]转为数字，累加到总耗时sumtime
print('the total execute time is ', sumtime) # 输出总执行时间

tns = list(ts.items())           # 将字典键值对转为列表，每个元素是元组(键,值)
# 排序：按元组第2项x[1]（占比）降序reverse=True，从大到小
tns.sort(key=lambda x: x[1], reverse=True)
for i in range(3):               # 循环3次，输出前3名
    print('the top {} percentage time is {}, spent in "{}" operation'.format(i, tns[i][1],tns[i][0]))

考点：with open(...) as f 自动关闭文件；eval(i[1]) 把字符串数字转数值累加；字典改列表后按占比降序，取前 3 名。

第十三套（1301 ~ 1302）

1301 靶场（有点特殊）

1
2
3
4
5
6
7
8
9
10
11
import turtle as t               # 导入海龟绘图库，简称为t
color = ['red','green','blue']    # 颜色列表：红、绿、蓝
rs = [10,30,60]                  # 半径列表：10，30，60

for i in range(3):               # 循环3次，画3个同心圆
    t.penup()                    # 抬笔，移动时不绘制线条
    t.goto(0,-rs[i])             # 考点-rs[i] 移动画笔坐标到(0, -半径)，作为画圆的起点
    t.pendown()                  # 考点pendown() 落笔，准备绘图
    t.pencolor(color[i])         # 考点color[i] 设置画笔颜色，依次取红、绿、蓝
    t.circle(rs[i])              # 考点rs[i] 画圆，参数是圆的半径
t.done()                         # 绘图完成，保持窗口不关闭

考点：画同心圆需把画笔移到 (0, -rs[i])（圆的最低点）作为起点；颜色与半径都从列表中按下标取。

1302（有点难度）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import jieba                              # 导入jieba中文分词库（Python二级高频）
s = input("请输入一段中文文本，句子之间以逗号或句号分隔：") # 接收输入整段文本
slist = jieba.lcut(s)                     # jieba.lcut：对中文做分词，返回词语列表
m = 0                                     # 词语计数变量，初始0

for i in slist:                           # 遍历分词后的每一个词语
    if i in ",。":                        # 如果这个词是逗号或者句号标点
        continue                          # 跳过，不计入词语数量
    m += 1                                # 不是标点，词语数量+1
    print(i, end="/")                     # 打印词语，用 / 分隔，不换行
print("\n中文词语数是：{}\n".format(m))    # 换行，输出总共中文词语数量

word = ""                                 # 用来临时保存一句话的字符
for j in s:                               # 遍历原始输入字符串的**每一个单个字符**
    if j in ",。":                        # 遇到逗号或句号（句子结束标记）
        print("{:^20}".format(word))      # 居中格式输出这句话，占20字符宽度
        word = ""                         # 清空临时变量，准备接收下一句
        continue
    word += j                             # 字符追加到word，拼接成完整句子

考点：jieba.lcut(s) 分词并用 if i in ",。" 过滤标点；第二段按字符遍历，用 word 拼接成句、遇标点用 {:^20} 居中输出。

第十四套（1401 ~ 1402）

1401 四个正方形

1
2
3
4
5
6
7
8
9
10
11
12
13
import turtle          # 导入海龟绘图库

n = 4                  # 考点 设置一共要画4个正方形

for j in range(n):     # 外层循环，循环n次，每次画一个正方形
    turtle.pendown()   # 考点 画笔落下，移动时可以画线
    for i in range(4): # 内层循环，画正方形的4条边
        turtle.fd(40)  # 考点 海龟向前移动40像素，画出一条边
        turtle.right(90)#  考点海龟右转90度，准备画下一条边
    turtle.penup()     # 画笔抬起，移动时不画线，只移动位置
    turtle.fd(80)      # 考点抬笔向前移动80像素，移动到下一个正方形起点

turtle.done()          # 绘图结束，保持绘图窗口不关闭

考点：外层循环画 n 个正方形；每个画完抬笔 fd(80) 移动到下一个起点（边长 40 不够，间隔要比边长大）。

1402

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import random as r
r.seed(0)
persons = ['Alice', 'Bob','lala', 'baicai']
flag = 3
while flag>0:
    flag -= 1
    name =input('请输入一个名字：')
    if name=='q':
        print('程序自动退出')
        break
    elif name in persons:
        num =r.randint(1000,9999)
        print('{} {}'.format(name, num))
    else:
        print('对不起，您输入的名字不存在。')

考点：while flag>0 限制最多 3 次循环；name in persons 判断名字是否在列表中；输入 q 提前 break 退出。

第十五套（1501 ~ 1502）

1501 画五个圆圈

1
2
3
4
5
6
7
8
9
10
11
12
import turtle as t                # 导入turtle库，取别名t
import random as r                # 导入random随机库，取别名r

color = ['red','green','blue','purple','black'] # 创建颜色列表，存放5种颜色
r.seed(1)                         # 设置随机种子为1，固定随机结果，每次运行图案一样
for j in range(5):                # 外层循环，一共画5个圆
    t.pencolor(color[r.randint(0,4)]) # 考点 随机从列表下标0~4选一个颜色，设置画笔颜色
    t.penup()                     # 抬起画笔，移动不画线
    t.goto(r.randint(-100,100),r.randint(-100,100)) # 考点 随机移动到坐标(x,y)，x、y范围都是-100到100
    t.pendown()                   # 考点 落下画笔，可以开始绘图
    t.circle(r.randint(10,30))    # 考点 画圆，半径随机取10~30之间整数
t.done()                          # 绘图完成，窗口保持打开不关闭

考点：color[r.randint(0,4)] 用随机下标取颜色；goto() 内直接写随机坐标表达式；circle() 参数为随机半径。

1502

1
2
3
4
5
6
7
8
9
10
11
import jieba                        # 导入jieba中文分词库
f = open('data2.txt','w')          # 以写模式打开data2.txt文件，文件对象f
s = input("请输入一个中文字符串，包含逗号和句号：") # 获取用户输入中文句子
k = jieba.lcut(s)                  # jieba.lcut()对字符串分词，返回词语列表
d1 = {}                            # 创建空字典d1，用来保存【词语:出现次数】
for i in k:                        # 遍历分词结果里每一个词语i
    if len(i) >= 2:                # 判断词语长度大于等于2，单字词语跳过不统计
        d1[i] = d1.get(i,0) + 1    # get(i,0)：字典没有i就返回0；词频+1
for j in d1:                       # 遍历字典d1里每一个键j（也就是词语）
    f.write(j + ':' + str(d1[j]) + '\n') # 写入文件：词语:次数，换行
f.close()                          # 关闭文件，释放资源

考点：jieba.lcut() 分词后 len(i) >= 2 过滤单字；d1.get(i,0)+1 统计词频；f.write() 写文件（写数字要用 str() 转换）。

第十六套（1601 ~ 1602）

1601 4 个交叉正方形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import turtle as t
import random as r #考点
color = ['red','blue','purple','black']
r.seed(1)
for j in range(4):
    t.pencolor(color[r.randint(0,3)]) #考点
    t.penup()
    t.goto(r.randint(-100,100),r.randint(-100,100))#考点
    t.pendown()
    ra = r.randint(50, 200)
    for i in range(1,5):  #考点
        t.fd(ra) #考点
        t.seth(90*i)
t.done()

考点：color[r.randint(0,3)] 随机取色；随机位置起笔；内层 seth(90*i) 画正方形（i 取 1~4）。

1602（有点难）

1
2
3
4
5
6
7
8
9
10
11
import jieba                         # 导入jieba中文分词库
dela = '-;:,.()<>'                   # 定义需要删除的标点符号字符串
s = input("请输入一句话:")           # 获取用户输入的一句话
print("\n这句话是:{}".format(s))     # 输出原始输入文本

for i in dela:                       # 遍历每一个要删除的标点
    s = s.replace(i,"")              # 将字符串s中的标点i替换为空，即删除标点

word = jieba.lcut(s)                 # jieba对去除标点后的字符串分词，返回词语列表
print("替换之后是:{}".format(s))     # 打印去掉标点后的句子
print("里面有{}个词语。".format(len(word))) # len(word)获取分词列表长度，输出词语总数

考点：遍历标点字符串用 s.replace(i,"") 循环删除标点；jieba.lcut() 分词后 len() 得词语数。

第十七套（1701 ~ 1702）

1701 日本国旗（有点难）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import turtle as t  # 导入turtle库，取别名t

for i in range(4):  # 循环4次，绘制正方形4条边
    t.forward(200)  # 海龟向前移动200像素，画一条边
    t.left(90)  # 海龟左转90度，准备画下一条边
t.penup()  # 抬起画笔，移动时不画线
t.goto(100, 0)  # 移动到坐标(100,0)，正方形内切圆的切点位置
t.pendown()  # 落下画笔，开始绘图
t.color('green', 'red')  # 设置：线条颜色green绿色，填充颜色red红色
t.pensize(5)  # 设置画笔粗细为5像素
t.begin_fill()  # 开始填充图形，后面画的图形会填充颜色
t.circle(100)  # 画半径100的圆，刚好是正方形内切圆
t.end_fill()  # 结束填充，完成颜色填充
t.done()  # 绘图结束，窗口保持打开

考点：t.color('画笔色', '填充色') 双参数写法；begin_fill() / end_fill() 成对使用填充颜色；t.pensize(5) 在填充前设置粗细。

1702（有点难）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import jieba                                  # 导入jieba中文分词库
fuhao=[",",":","、","。","；","，","“","”"]    # 定义需要剔除的标点符号列表
with open("data_19report.txt","r",encoding="utf-8") as f: # with语句打开文件，只读模式，utf-8编码，自动关闭文件
    all_txt=f.read()                          # read()一次性读取文件全部内容，存入all_txt

for ch in fuhao:                              # 遍历每一个标点符号
    all_txt=all_txt.replace(ch,"")            # 将文本中的标点替换为空字符串，删除标点

data = jieba.lcut(all_txt, cut_all=False)    # 精确模式分词（cut_all=False默认精确模式），返回词语列表
print('/'.join(data))                         # 用斜杠/连接分词列表里所有词语并打印

result = {}                                   # 创建空字典，用来统计词频：{词语:次数}
for item in data:                             # 遍历分词后的每一个词语
    if len(item) > 1:                         # 只保留长度大于1的词语，过滤掉单字
        if result.get(item):                  # 判断字典里是否已经存在该词语（get找不到返回None，视为False）
            result[item] += 1                 # 存在，次数+1
        else:
            result[item] = 1                  # 不存在，这个词语次数初始化为1

# 将字典的键值对转为列表，按词频（x[1]代表次数）降序排序
result = sorted(result.items(), key=lambda x : x[1], reverse=True)

for item in result[:5]:                       # 切片取排序后的前5个高频词
    print(item[0] + ':' + str(item[1]))       # 词语:次数，拼接字符串输出

考点：with open(..., encoding="utf-8") 读文件、f.read() 一次读完；循环 replace 去标点；jieba.lcut(x, cut_all=False) 精确模式；sorted(..., key=lambda x:x[1], reverse=True) 按词频降序；result[:5] 取前 5。

第十八套（1801 ~ 1802）

1801 4 条头发（有点难）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import random as r                  # 导入random库，别名r
import turtle as t                  # 导入turtle库，别名t

def drawSnake(angl):                # 定义画蛇函数，angl是形参，接收角度
    t.penup()                       # 抬笔，移动不画线
    t.goto(0,200)                   # 移动到坐标(0,200)
    t.pendown()                     # 落笔，开始绘图
    t.seth(-1*angl)                 # 设置海龟朝向：角度 = -angl
    for i in range(length):         # 循环length次（length=3，循环3次）
        t.circle(radius, angl)      # 画圆弧：半径radius，圆心角angl
        t.circle(-radius, angl)     # 反向画圆弧：半径-radius，圆心角angl，形成S形蛇身

length, radius = 3, 40              # 全局变量：length循环次数，radius圆弧半径
r.seed(1)                           # 设置随机种子，固定随机结果，每次运行图形相同
color = ['red','blue','purple','black'] # 颜色列表

for i in range(4):                  # 循环4次，画4条蛇
    t.pencolor(r.choice(color))     # r.choice()从颜色列表随机挑选一个颜色
    angl = r.randint(30, 180)       # 随机生成[30,180]之间整数，作为角度
    drawSnake(angl)                 # 调用画蛇函数，传入随机角度angl

t.done()                            # 绘图完成，保持窗口

考点：自定义函数封装绘图，t.circle(半径, 圆心角) 只画圆弧；circle(r, a) 与 circle(-r, a) 交替形成 S 形；函数内用全局变量 length、radius。

1802（有点难）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 带完整注释代码
fs = open("score202.txt","r",encoding='utf-8')  # 只读打开score202.txt文件
ls = fs.readline().split(';')                   # readline读取一行，按;分割得到列表ls
fb = open("base202.txt","r",encoding='utf-8')   # 只读打开base202.txt文件
lb = fb.readline().split(';')                   # readline读取一行，按;分割得到列表lb
fo = open("stud202.txt","w")                    # 以写模式打开输出文件stud202.txt
ds = {}                                         # 空字典ds，用于合并存储学生信息
db = {}                                         # 空字典db（本题代码里未实际使用）

for l in ls:                                    # 遍历score文件分割后的每一条学生记录字符串l
    data=l.split(',')                           # 把单条记录按逗号,拆分，得到列表data
    if len(data)>2:                             # 如果拆分后的列表长度大于2（数据有效）
        ds[data[0]]=data[1:]                    # 字典键：学生编号data[0]；值：该学生后面所有信息列表

for l in lb:                                    # 遍历base文件分割后的每一条学生记录字符串l
    data=l.split(',')                           # 按逗号拆分单条记录
    if len(data)>2:                             # 数据有效判断
        ds[data[0]]+=[data[1]]                  # 找到同学号的字典项，追加基础信息到列表中

ll=list(ds.items())                             # 将字典的键值对转为列表，格式：[(学号,[信息1,信息2...]),...]
for i in ll:                                    # 遍历每一条学生键值对i
    fo.write('{},{};\n'.format(i[0],','.join(i[1]))) # 格式化写入文件：学号,信息1,信息2; 换行

fs.close()  # 关闭score文件
fb.close()  # 关闭base文件
fo.close()  # 关闭输出文件

考点：两次文件读取 + 字典合并（键为学号），ds[学号] += [新信息] 追加；','.join(i[1]) 用逗号连接列表；fo.write('{},{};\n'.format(...)) 写回文件；三个文件对象都要 close()。

第十九套（1901 ~ 1902）

1901 五个正五边形（有点难）

1
2
3
4
5
6
7
8
9
import turtle as t                 # 导入turtle库，别名t
color = ['red','green','blue','orange','pink'] # 定义颜色列表，5种颜色
for i in range(5):                 # 循环执行5次，画5个图形
    t.penup()                      # 抬笔，移动时不画线
    t.goto(-200+i*70,0)            # 计算每个图形x坐标：-200，-130，-60，10，80；y固定0，横向依次排开
    t.pendown()                    # 落笔，准备绘图
    t.pencolor(color[i])           # 设置画笔颜色，依次取列表第i个颜色
    t.circle(50, steps = 5)        # 画半径50的正五边形；steps参数：画多边形，steps=5就是正5边形
t.done()                           # 绘图结束，窗口保持打开

考点：t.circle(半径, steps=n) 用 steps 参数直接画正 n 边形（本题 steps=5 画正五边形）；用 -200+i*70 让图形横向排开。

1902（有点难）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import random as r

# 定义函数 calpi，形参 c、darts
def calpi(c,darts):
    p = 0
    for j in range(darts):                # 循环 darts 次
        p = p + r.randint(0,darts)        # 生成 [0,darts] 的随机整数，累加到p
    print("{:2} {:12} {:12}".format(c, darts, p)) # 格式化输出：c占2字符，darts占12，p占12

n = 4
DART = 3
r.seed(1)                                 # 设置随机种子，固定随机序列

for i in range(n):                        # i取0,1,2,3，一共循环4次
    calpi(i+1,(i+1)*DART)                 # 调用函数：c=i+1，darts=(i+1)*3

考点：自定义函数 + 循环调用；calpi(i+1, (i+1)*DART) 用循环变量计算结果作实参；{:2}、{:12} 为定宽格式化输出。

总结 · 高频考点速查

考点关键写法turtle 画图fd()、seth()/setheading()、circle(半径, steps=n)、circle(r, 角度)turtle 定点penup() → goto(x, y) / goto(x0,-rs[i]) → pendown()turtle 填充color('画笔色','填充色') + begin_fill() / end_fill()turtle 别名import turtle as t随机数random.seed()、randint(a,b)、choice(列表)、import random as r字典计数d[x] = d.get(x, 0) + 1字典分组dic[k] = dic.get(k, []) + [v]字典排序ls = list(d.items()) + sort(key=lambda x:x[1], reverse=True)字典转列表list(d.items())、d.keys()、d.values()、sum(d.values())/len(d.values())文件读open(f, 'r', encoding='utf-8')、readlines()、readline()、f.read()、with open(...) as f文件写open(f, 'w')、f.write('{},{};\n'.format(...))、f.close()字符串split()、strip()、replace(a,'')、join()、[:-1]、切片中文分词jieba.lcut(s)、jieba.lcut(s, cut_all=False)格式化{:.2f}、{:.3f}、{:<10.3f}、{:>4}、{:^20}数值eval() 转数值、pow(a, b)、len(t)-2 滑动窗口