devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python计算机二级过考指南_有字典如下: dic = {'admin':'123456','administrator':'12

作者：从前慢现在也慢 | 2024-06-09 16:55:05

赞

踩

有字典如下: dic = {'admin':'123456','administrator':'12345678','root':'passw

目录

基本操作题

一.Python基本数据类型

考点1：format方法的格式控制

考点2：random随机库

 二.Python组合数据类型

考点1：列表

考点2：jieba分词

Turtle绘图题

简单应用题

字符串 

列表元组

集合

字典

文件

基本操作题

一.Python基本数据类型

考点1：format方法的格式控制

典例1： 接收用户输入的一个小于 20的正整数，在屏幕上逐行递增显示从 01 到该正整数，数字显示的宽度为 2，不足位置补 0，后面追加一个空格，然后显示‘>’号，‘>’号的个数等于行首数字。

n = input('请输入一个正整数:')   
for i in range(____________):
    print('____________'.format(i + 1, ____________))

  1. n = input('请输入一个正整数:')              
  2. for i in range(int(n)):
  3.     print('{:0>2} {}'.format(i+1,">"*(i+1) ))

# format()方法中，<左对齐，>右对齐，^居中对齐

典例2：键盘输入正整数 n，按要求把 n 输出到屏幕，格式要求：宽度为 25 个字符，等号字符 (=) 填充，右对齐，带千位分隔符。如果输入正整数超过 25 位，则按照真实长度输出。

s = input()
print("{_______(1)_________}".format(_______(2)_________))

  1. s = input()
  2. print("{:=>25,}".format(eval(s)))

典例3：从键盘上输入球的半径 r，输出球的表面积 S 和体积 V（ 1 个英文空格隔开，结果保留两位小数）。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

PI = 3.14
r = eval(input())
S = ______  # 球体表面积
V = ______  #球体体积
print("______".format(S,V))

  1. PI = 3.14
  2. r = eval(input())
  3. S = 4 * PI * pow(r,2)
  4. V = (4/3) * PI * pow(r,3)
  5. print("{:.2f} {:.2f}".format(S,V))

典例4：输入一个正整数（范围为65 - 96），请输出对应的 Unicode 字符。

# c: 表示输出整数和浮点数类型的格式规则，输出数值对应的Unicode字符。

  1. x = eval(input())
  2. print("{:c}".format(x))

典例5：从键盘接收输入十进制数，格式化输出其十六进制小写形式。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬要求：输出字符串长度为 30，十六进制小写形式居中，填充字符串为一个英文双引号。

s = input()
print("{__________}".format(_________))

  1. s = input()
  2. print("{:\"^30x}".format(eval(s)))

  # \" 表示 在""字符串内部显示一个英文单引号的方式，本题中如果没有增加\，显示出错
# ^ 表示s处于输出字符串的中间位置
# 30指字符串设定格式化输出总长度为30
# x表示小写十六进制输出,X表示大写十六进制输出
# 如果换成b,表示二进制方式输出；如果换成o,表示八进制方式输出；
# 如果换成d,表示十进制方式输出。

典例6：从键盘输入一个整数和一个字符，以逗号隔开，在屏幕上显示输出一条信息。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬

             示例：输入: "10,@‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬"        输出: "@@@@@@@@@@10@@@@@@@@@@‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬"

  1. ls= input().split(',') #将从键盘上输入的用逗号隔开的字符串转换为列表
  2.                        #例如输入:10,@  
  3.                        #ls为['10', '@']
  4.                        #ls[0]为'10' ,eval(ls[0])*2+len(ls[0])表达式值为22   
  5.                        #ls[1]为'@'
  6. print(ls[0].center(eval(ls[0])*2+len(ls[0]),ls[1]))
  7.                        #'10'.center(22,"@")即为输出结果,考察字符串的center方法

#str.center(x,y) 会用字符串str构造一个新的字符串，
#新的字符串长度是x, 两边填充y。此处的x是数字，y是填充字符

典例7：程序接收用户输入的五个数，以逗号分隔。将这些数按照输入顺序输出，每个数占 10 个字符宽度，右对齐，所有数字显示在同一行。

num = input().____________
for i in num:
    print(____________)

  1. num = input().split(',')
  2. for i in num:
  3.     print("{:>10}".format(i),end="")

典例8：从键盘输入一个整数，在屏幕上显示输出该整数的十六进制、八进制、二进制表示形式。

Tempstr = ___（1）___
print("___（2）___".format(Tempstr))

  1. Tempstr = eval(input())
  2. print("0x{0:x},0o{0:o},0b{0:b}".format(Tempstr))

考点2：random随机库

典例1：以100为随机数种子，随机生成3个在1（含）到9（含）之间的随机整数，计算这三个随机数的立方和。

import random
____________  # 此处可多行
s = 0  # 
____________  # 此处可多行
print(s)

  1. import random
  2. random.seed(100) 
  3. s = 0 
  4. for i in range(3):
  5.     n=random.randint(1,9)
  6.     s=s+n**3
  7. print(s)

典例2：利用 random 随机库里的函数，生成一个由四个大小写字母组成的验证码，显示在屏幕上。 

import random as r
zmb = 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz'
r.seed(1)
…
print(code)

  1. import random as r  # 用随机数要导入random库，并记别名为r
  2. zmb = 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz'  # 先定义好要使用的英文字母表；
  3. r.seed(1)
  4. code = ''  # 初始化密码code为一个空字符串
  5. # 循环4次，在循环里构造验证码的每个字符。从英文字母表里随机选取一个字母；用字符串的+=运算符，追加到密码变量上。
  6. for i in range(4):   
  7.     code += r.choice(zmb)
  8. print(code)

典例3：以 123 为随机数种子，随机生成 10 个在 1 (含)到 999 (含)之间的随机整数，每个随机数后跟随一个逗号进行分隔，屏幕输出这 10 个随机数。

import random
______
for i in range(______):
    print(______, end=",")

  1. import random
  2. random.seed(123)
  3. for i in range(10):
  4.     print(random.randint(1,999), end=",")

seed()方法的语法:
  import random
  random.seed([x])
  注意：seed()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。

random.randint(a,b)返回一个a至b区间（包含a和b）的整数。

典例4：输入一个正整数n，自动生成n个1-100范围内的随机浮点数，在屏幕上显示输出每个随机数，并显示平均值。 

import ___(1)________
random.seed(1)
n = eval(input())
sum = 0
for i in range(n):
    fl = random.______(2)___(1,100)
    sum += fl
    print(___(3)___)
print('The average is:{:.2f}'.___(4)___)

  1. import random
  2. random.seed(1)
  3. n = eval(input())
  4. sum = 0
  5. for i in range(n):
  6.     fl = random.uniform(1,100)
  7.     sum += fl
  8.     print('{:.2f}'.format(fl))
  9. print('The average is:{:.2f}'.format(sum/n))

 二.Python组合数据类型

考点1：列表

典例1：

示例代码里定义的列表变量 score 里面是 5 组同学在一次比赛中的成绩，每组成绩包括三项，分别记为a1, a2, a3，三个字段以逗号分隔，示例如下：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬score = [[87,79,90],[99,83,93],[90,75,89],[89,87,94],[95,85,84]]    计算每组同学比赛成绩的总成绩,计算公式为：total = a1 * 0.6 + a2 * 0.3 + a3 * 0.1。

  1. # 列表里每一个元素又是一个列表，对应一组的竞赛成绩
  2. # 利用 len(score) 求得总的组数；
  3. # 为了在输出语句里输出各组的编号数，所以需要使用带循环变量 i 的 for 循环
  4. # 在这个循环结构中，按照计算公式计算每一组的总成绩，并显示输出计算结果
  5. # 因为结果要求显示整数，格式定义里使用了int(final)。
  6. score = [[87,79,90],[99,83,93],[90,75,89],[89,87,94],[95,85,84]]
  7. for i in range(len(score)):
  8.     final = score[i][0]*0.6 + score[i][1]*0.3 + score[i][2]*0.1
  9.     print('the {} final score is {}'.format(i+1, int(final)))

考点2：jieba分词

典例1：从键盘输入一个字符串，使用中文分词库 jieba 输出精确模式的中文分词结果。

  1. import jieba
  2. Tempstr = input()
  3. ls = jieba.lcut(Tempstr)
  4. print(ls)

典例2：对data.text中的内容利用 jieba 库实现中文分词。对分词后的列表进行去重处理，然后将分词结果中字符数大于等于 3 的词语，按照字符顺序排序，写入到文件 out1.txt 文件中（每词一行）。

import jieba
f = open('out1.txt','w')
fi = open("data.txt","r",encoding="utf-8")
......
fi.close()
f.close()

  1. import jieba   #导入中文分词库
  2. f = open('out1.txt','w')   #以写的方式打开out1.txt文件
  3. fi = open("data.txt","r",encoding="utf-8") #以读的方式打开data.txt文件
  4. #使用jieba.lcut()对data.txt文件读出字符串进行中文分词，返回列表lst
  5. lst = jieba.lcut(fi.read())
  6. s = set(lst)    #使用set函数将列表lst转换为集合，实现元素去重  
  7. s1 = sorted(s) #将列表按字符顺序排序
  8. ls = list(s1)    #将集合重新变成列表ls
  9. for item in ls:        #遍历去重后ls每一个元素
  10.     if len(item) >=3:
  11.         f.write(item + "\n")  #将符合条件的字符串写入out1.txt中
  12. fi.close()  #关闭文件fi
  13. f.close()   #关闭文件f

典例3：从键盘输入一个中文字符串变量 s，内部包含中文标点符号。用 jieba 分词，计算字符串 s 中的中文词汇个数，不包括 “ ，。、” （左引号，逗号，句号，顿号，右引号）这5个中文标点符号。显示输出分词后的结果，用”/ ”分隔，以及中文词汇个数。

import jieba
s = input()

.....
print("\n中文词语数是：{}".format(len(k)))

  1. s = input()
  2. s = s.replace('，','').replace('。','').replace('、','').replace('“','').replace('”','')
  3. k = jieba.lcut(s)
  4. for i in k:
  5.     print(i, end= "/ ")
  6. print("\n中文词语数是：{}".format(len(k)))
  7.  
  8. # 要处理掉输入的各种标点符号，用replace（）函数
  9. # 如果要保存各个词出现次数可以用字典

典例4：苏格拉底是古希腊著名的思想家、哲学家、教育家、公民陪审员。苏格拉底的部分名言被翻译为中文，其部分内容由 sgld.txt 给出。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬读取文件，请过滤中文逗号、中文句号、中文冒号、中文引号，英文空格、换行符\n 之后，‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬对其中的内容进行中文分词，在屏幕上显示输出词语出现次数前5的词，用一个中文顿号、分割。

  1. # 模板
  2. import jieba
  3. with open("sgld.txt","r",encoding ="utf-8") as f:
  4.     lssgld = f.readlines()
  5. ......
  6. ls = list(d.items())                              
  7. ls.sort(key=lambda x:x[1], reverse = True)      
  8. ......
  9. # 正确解答
  10. import jieba                    #导入中文分词库，这是必考点
  11. with open("sgld.txt","r",encoding ="utf-8")as f:  #使用with语句以只读方式打开文件
  12.     lssgld = f.readlines()                        #按行读取文件构建lssgld列表
  13.  
  14. d = {}                                  #定义空字典
  15. for ls in lssgld: 
  16.     ls = ls.replace("\n","")            #数据清洗:去掉每一行最后的换行符
  17.     for c in "。，：”“ ":                       #中文分词前，将中文逗号、中文句号、中文冒号、中文引号，英文空格替换为空字符
  18.         ls = ls.replace(c, "")      #使用字符串函数replace将
  19.     wordlist = jieba.cut(ls)        #对每行进行中文分词
  20.     for word in wordlist:   
  21.         d[word] = d.get(word,0) + 1   #构建字典
  22.  
  23. ls = list(d.items())
  24. ls.sort(key=lambda x:x[1], reverse = True)  #列表排序
  25.  
  26. for i in range(5):
  27.     a = ls[i][0]
  28.     print("{}".format(a),end = "、")      #出现次数前5的词

*典例5：在数据文件 lizhi.txt 里有一堆励志短语，每句一行。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪用 jieba 分词库的 lcut() 函数分词，统计分词后的长度大于等于 2 的词组的出现次数，按照出现次数排序，在屏幕上显示出现次数最多的 10 个词。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬在画布上，用 tutle 的 circle 画填充为红色的圆圈，圆圈的半径为出现次数 n*4，最大的圆圈的起点在画布的坐标 (-300,0)，其余的圆按顺序沿着 x 轴向右边相邻，连续扩展。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬输出示例：                                                                                  

  1. # 模板代码
  2. import jieba
  3. import turtle as t
  4.  
  5. def drawCircle(x,y,radius,color,name):
  6.     t.pencolor(color)
  7.     t.penup()
  8.     t.____(1)____
  9.     t.write(name, font=('Arial', 10, 'normal'))
  10.     t.seth(__(2)___)
  11.     t.pendown()
  12.     t.circle(__(3)___)
  13.     return t.pos()
  14.  
  15. dws = {}
  16. with open('lizhi.txt', 'r') as f:
  17.     for l in f.readlines():
  18.         ws = _____(4)_______
  19.         for w in ws:
  20.             if ___(5)____:
  21.                dws[w] = dws.get(w,0) + 1
  22.  
  23. dls = list(dws.items())
  24. dls.sort(key = lambda x:x[1], reverse= True)
  25.  
  26. x,y = -300,0
  27. for i in range(10):
  28.     print(_____(6______)
  29.     x,y = drawCircle(x,y,dls[i][1]*4 ,'red',____(7)_____))
  30.     x +=  _____(8)______
  31. t.done()
  32.  
  33. # 正确代码
  34. import jieba                                #导入中文分词库jieba
  35. import turtle as t                          #导入turtle库，并给turtle去一个别名t
  36.  
  37. def drawCircle(x,y,radius,color,name):          #自定义函数drawCircle,包含了5个参数
  38.     t.pencolor(color)                           #设置绘圆的颜色,color是一个必选参数，调用函数时可以设置为'red'、'blue'...
  39.     t.penup()                                   #绘图笔提前起来，表示不落下去绘图，      
  40.     t.goto(x, y)                                #将笔的坐标定位到(x,y),x,y都是必选参数
  41.     t.write(name, font=('Arial', 10, 'normal')) #在当前的(x,y),写上name内容，文字属性由font决定。name是必选参数
  42.     t.seth(-90)                                 #将绘图方向设置为-90度方向
  43.     t.pendown()                                 #绘图笔放下，表示落下去绘图，有颜色啦:)
  44.     t.circle(radius)                            #按半径为radius绘制圆形
  45.     return t.pos()                              #返回t.pos()当前的位置,例如:(-300.00,0.00)
  46.  
  47. dws = {}                                            #定义一个字典，注意不是集合哦
  48. with open('lizhi.txt', 'r',encoding="utf-8") as f:  #用with语句以只读方式打开lizhi.txt文件
  49.     for l in f.readlines():                         #遍历列表f.readlines()中的每一个元素
  50.         ws = jieba.lcut(l.strip('\n'))              #去掉行字符串最后的"\n"不可显示换行符，
  51.                                                     #使用jieba.lcut(str)函数进行中文分词，返回一个列表
  52.         for w in ws: 
  53.             if len(w) >= 2:                         #统计词语长度>=2 的词语出现频次
  54.                dws[w] = dws.get(w,0) + 1            #逐步构建字典dws,词语:次数的键值对
  55.                                                     #如果w在dws的keys中，则键值+1，如果w不在dws的keys中，则构建健值对dws[w] = 0 + 1
  56.  
  57. dls = list(dws.items())                             #将dws.items()转换为列表并赋值给dls,形如[("abc",10),("edf","12"),...]，目前是无序的
  58. dls.sort(key = lambda x:x[1], reverse= True)        #对dls进行排序，按列表元素中索引为1，这行代码考试时会给出。但一定要理解。
  59.  
  60.  
  61. x,y = -300,0                                        #设置初始坐标位置        
  62. for i in range(10):                                 #根据统计结果绘制图形
  63.     print(dls[i][0],dls[i][1])                      #输出结果
  64.     x,y = drawCircle(x,y,dls[i][1]*4 ,'red',dls[i][0]+str(dls[i][1]))  #调用绘图函数实现绘图
  65.     x +=  dls[i][1] * 8                             #改变x初始位置，y值不变
  66. t.done()

 基本操作题是最好拿分的部分，只要熟记函数的作用，把例题都弄明白就肯定没有问题啦。

Turtle绘图题

大多数绘图题一般会和循环语句相结合，所以除了要背熟turtle相关的函数，也要注意观察图中循环的规律。此处的整理由易到难，但其实大多数的卷子里都是画一些多边形这样的基础图形。

turtle.fillcolor(colorstring)绘制图形的填充颜色
turtle.color(color1, color2)同时设置pencolor=color1, fillcolor=color2
turtle.filling()返回当前是否在填充状态
turtle.begin_fill()准备开始填充图形
turtle.end_fill()填充完成
turtle.hideturtle()隐藏画笔的turtle形状，简写hd()
turtle.showturtle()显示画笔形状
turtle.forward(distance)向当前画笔方向移动distance像素长度，简写fd()
turtle.backward(distance)向当前画笔相反方向移动distance像素长度
turtle.right(degree)顺时针移动degree°
turtle.left(degree)逆时针移动degree°
turtle.pendown()移动时绘制图形，缺省时也为绘制
turtle.goto(x,y)将画笔移动到坐标为x,y的位置
turtle.penup()提起笔移动，不绘制图形，用于另起一个地方绘制，简写pu()
turtle.circle()画圆，半径为正(负)，表示圆心在画笔的左边(右边)画圆
setx()将当前x轴移动到指定位置
sety()将当前x轴移动到指定位置
setheading(angle)设置当前朝向为angle角度，简写seth()
home()设置当前画笔位置为原点，朝向东。
dot(re)绘制一个指定直径和颜色的圆点
弧形绘制

1、给定半径画圆
turtle.circle(radius, extent=None, steps=None)

2、参数：

  • radius(半径)：半径为正(负)，表示圆心在画笔的左边(右边)画圆

  • extent(弧度) (optional)

  • steps (optional) (做半径为radius的圆的内切正多边形，多边形边数为steps)

典例1：使用 turtle 库绘制四个同心圆套圈，最小的圆圈半径为 10 像素，不同圆圈之间的半径差是 50 像素。模板如下：

import turtle
r = 10
dr = ____(1)_____
head = 90
for i  in range (4):
    turtle.pendown()
    turtle.____(2)____
    r +=  (____(3)____)
    turtle.penup()
    turtle.seth(-head)
    turtle.fd(dr)
    turtle.____(4)____
turtle.done()

  1. r = 10
  2. dr = 50  #设置不同圆圈之间半径的差是50像素
  3. head = 90
  4. for i  in range (4):
  5.     turtle.pendown()
  6.     turtle.circle(r)
  7.     r +=  dr
  8.     turtle.penup()
  9.     turtle.seth(-head)
  10.     turtle.fd(dr)
  11.     turtle.seth(0)
  12. turtle.done()

典例2：

 

  1. import turtle
  2. def drawCircle():         #定义画圆函数
  3.     turtle.pendown()
  4.     turtle.circle(20)
  5.     turtle.penup()
  6.     turtle.fd(40)
  7. def drawRowCircle(n):    # 定义画层次圆函数
  8.     for j  in range(n,1,-1):
  9.         for i in range(j):
  10.             drawCircle()   # *     
  11.         turtle.fd(-j*40-20)
  12.         turtle.right(90)
  13.         turtle.fd(40)
  14.         turtle.left(90)
  15.         turtle.fd(40)
  16.     drawCircle()
  17.  
  18. drawRowCircle(5)        #画圆（5行）
  19. turtle.hideturtle()
  20. turtle.done()

 典例3：

使用 turtle 库的 turtle.right() 函数和 turtle.circle() 函数绘制一个星星图形，圆弧的半径为 90。

 

  1. import turtle
  2. for i in range(4):
  3.     turtle.circle(-90,90) #注意第一个空为负值
  4.     turtle.right(180)

典例4：

 

  1. # 题目模板
  2. import turtle
  3. turtle._____(1)_______ #画笔颜色与填充设置
  4. turtle.begin_fill()
  5. #绘制太阳花形状
  6. for i in range(50):
  7.     turtle._____(2)_______ #先前200
  8.     turtle._____(3)_______  #右转170度
  9. turtle.end_fill()
  10. turtle.done()
  11. # 解答
  12. import turtle
  13. turtle.color("red","yellow")
  14. turtle.begin_fill()
  15. for i in range(50):
  16.     turtle.forward(200)
  17.     turtle.right(170)
  18. turtle.end_fill()
  19. turtle.done()

典例5：

 

  1. # 解题模板：
  2. ____________
  3. ls = [69, 292, 33, 131, 61, 254]
  4. X_len = 400
  5. Y_len = 300
  6. x0 = -200
  7. y0 = -100
  8.  
  9. t.penup()
  10. t.goto(x0, y0)
  11. t.pendown()
  12.  
  13. t.fd(X_len)
  14. t.fd(-X_len)
  15. t.seth(____________)
  16. t.fd(Y_len)
  17.  
  18. t.pencolor('red')
  19. t.pensize(5)
  20. for i in range(len(ls)):
  21.     t.____________
  22.     t.goto(x0 + (i+1)*50, ____________)
  23.     t.seth(90)
  24.     t.pendown()
  25.     t.fd(____________)
  26. t.done()
  27.  
  28. # 解答
  29. import turtle as t #更简洁地调用turtle库
  30. ls = [69, 292, 33, 131, 61, 254]
  31. X_len = 400
  32. Y_len = 300
  33. x0 = -200
  34. y0 = -100
  35.  
  36. t.penup()
  37. t.goto(x0, y0)
  38. t.pendown()
  39.  
  40. t.fd(X_len)
  41. t.fd(-X_len)
  42. t.seth(90) #设置笔的起始角度
  43. t.fd(Y_len)
  44.  
  45. t.pencolor('red')
  46. t.pensize(5)
  47. for i in range(len(ls)):
  48. t.penup() #提起画笔
  49. t.goto(x0 + (i+1)*50, y0) #移到绝对坐标处，这里x坐标动，y坐标不动
  50. t.seth(90)
  51. t.pendown() #放下画笔
  52. t.fd(ls[i]) #表示直线爬行的距离
  53. t.done()

简单应用题

简单应用题我主要分了几个知识点的部分来整理，实际应用当中就是把它们综合起来。总体整理也是由易到难。

字符串 

典例1：输入一个英文句子，以回车符结束，单词间以空格分隔，标点符号后跟至少一个空格，统计并输出单词的个数（仅统计单词，数字按单词计，不计算标点符号，重复单词出现几次就统计几次）。

  1. s = input()
  2. ls = s.split()
  3. print(len(ls))

典例2：程序每次读入一个正整数，然后输出按位逆序的数字。注意：当输入的数字含有结尾的0时，输出不应带有前导的0。比如输入65000，输出应该是56。

  1. num = input()          # 输入一个正整数的字符串
  2. print(int(num[::-1]))  # 对字符串逆序，再转整型，int()函数可去除整数前面的前导0
  3. # 或用字符串处理方法lstrip('0')去除字符串左侧的字符'0'
  4. print((num[::-1]).lstrip('0'))   # lstrip('0')去除字符串左侧的字符'0'

典例3：

月份的英文单词及其缩写如下所示：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬一月 Jan. January 二月 Feb. February 三月 Mar. March 四月 Apr. April 五月 May. May 六月 Jun. June 七月 Jul. July 八月 Aug. August 九月 Sept. September 十月 Oct. October 十一月 Nov. November 十二月 Dec. December‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬。月份的缩写为月份单词的前3个字母（9月为前4个），且首字母大写，以 '.' 做为缩写结束标记。编写一个程序，用户输入一个月份单词，不论输入的单词各字符是大写还是小写，请正确输出对应月份的缩写。当输入单词拼写错误时，输出“spelling mistake”。

  1. # 逻辑表达式实现
  2. month = input().lower().capitalize()
  3. if month ==  'September':
  4.     output = month[:4] + '.'
  5. elif month == 'January' or month == 'February' or month == 'March' or month == 'April' or month == 'May' or \
  6. 		month == 'July' or month == 'July' or month == 'August' or month == 'September' or month == 'October' or \
  7. 		month == 'November' or month == 'December':
  8.     output = month[:3] + '.'
  9. else:
  10.     output = 'spelling mistake'
  11. print(output)
  12.  
  13. # 列表实现
  14. month = input().lower().capitalize()
  15. month_lst = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October',
  16.              'November', 'December']
  17. if month == 'September':
  18.     print(month[:4] + '.')
  19. elif month in month_lst:
  20.     print(month[:3] + '.')
  21. else:
  22.     print('spelling mistake')

典例4*（此题有一定难度，可以选择性看）：

中国目前采用的是18位身份证号，其第7-10位数字是出生年，11-12位是出生月份，13-14是出生日期，第17位是性别，奇数为男性，偶数为女性，第18位是校验位。 如果身份证号码的其中一位填错了（包括最后一个校验位），则校验算法可以检测出来。如果身份证号的相邻2位填反了，则校验算法可以检测出来。校验规则如下：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

  1. 将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2。
  2. 将这17位数字和系数相乘的结果相加。
  3. 用加出来和除以11，看余数只可能是：0－1－2－3－4－5－6－7－8－9－10 分别对应的最后一位身份证的号码为：1－0－X－9－8－7－6－5－4－3－2 　　4. 通过上面得知如果余数是2，就会在身份证的第18位数字上出现罗马数字的X（大写英文字母X）。如果余数是10，身份证的最后一位号码就是2。 用户输入一个身份证号，校验其是否是合法的身份证号码，如身份证号码不合法输出 '身份证校验位错误!'，如身份证号码合法则分别在4行中输出'身份证号码校验为合法号码!'，并输出该人的出生年月日和性别。 
    1. def id_check(id_num):
    2.     """接收身份证号为参数，计算并检查校验和，返回布尔值"""
    3.     check_sum = sum([weight[i] * int(id_num[i]) for i in range(17)])
    4.     if id_num[17] == 'X':  # 若末位为'X'
    5.         return True if check_sum % 11 == 2 else False
    6.     return True if (check_sum % 11 + int(id_num[17])) % 11 == 1 else False
    7.  
    8.  
    9. def id_info(id_num):
    10.     """接收身份证号为参数，返回年、月、日和性别，均为字符串类型"""
    11.     year = id_num[6:10]
    12.     month = id_num[10:12]
    13.     date = id_num[12:14]
    14.     gender = '男' if id_num[16] in '13579' else '女'
    15.     return year, month, date, gender
    16.  
    17.  
    18. if __name__ == '__main__':
    19.     id_number = input()
    20.     weight = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1]
    21.     if id_check(id_number):
    22.         info = id_info(id_number)
    23.         print('身份证号码校验为合法号码!')
    24.         print('出生：{}年{}月{}日'.format(info[0], info[1], info[2]))
    25.         print('性别：{}'.format(info[3]))
    26.     else:
    27.         print('身份证校验位错误!')

    列表元组

典例1：在两行中分别输入一个字符串，分别将其转换为列表 a 和 b，按要求完成以下功能： 1. 输出两个列表的拼接结果 2. 输出列表 a 重复3次的结果 3.输出列表 b 中第3个元素和最后一个元素 4.输出列表 a 中序号1至4之间的元素 5. 输出列表 a 、b的长度，结果用逗号分隔 6. 输出列表 a 的中元素的最小值和 b 中元素的最大值 

  1. a = list(input())
  2. b = list(input())
  3. print(a + b)
  4. print(a * 3)
  5. print(b[2],b[-1],sep = ' ')
  6. print(a[1:4])
  7. print(len(a),len(b),sep = ',')
  8. print(min(a),max(b))

典例2：读入一行英文，单词之间以一个空格隔开，如果句中有标点符号，其后也用一个空格分隔。该行英文中可能包含0个或1个"and"，如果"and"在字符串中存在，请在"and"前面插入"Anna"，并输出。（列表元素的查找和添加）

  1. aList = input().split()
  2. if 'and' in aList:
  3.     ind = aList.index('and')
  4.     aList.insert(ind,'Anna')
  5.     
  6. print(' '.join(aList))

典例3：读入两行，两行的格式一样，都是用空格分隔的若干个整数，将这些数合并到一个列表中，降序排列后输出整个列表。

  1. lst_a = input().split()             # 输入转为列表
  2. lst_b = input().split()             # 输入转为列表
  3. lst_ab = lst_a + lst_b              # 两个列表拼接为一个列表
  4. lst_int = [int(x) for x in lst_ab]  # 将列表lst_ab中的元素转为整数，产生新列表
  5. lst_int.sort(reverse=True)          # 列表原地排序，逆序
  6. print(lst_int)

典例4：

有以下两个二维列表，第一个列表的元素是元组，请对其按列表元素的第 2 个元素值从小到大进行排序输出，输出其前 m 项；‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

第二个列表的元素仍是列表，请对其分别按每个元素的第 1 和第 3 个元素值从小到大进行排序，输出其前 n 项。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

m 和 n 是由用户输入的非负整数，当 m 或 n 大于列表长度时，对整个列表进行排序输出。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

列表一： [('dungeon',7),('winterfell',4),('bran',9),('meelo',6)]‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

列表二： [[ 'Angle', '0121701100106',99], [ 'Jack', '0121701100107',86], [ 'Tom', '0121701100109',65], [ 'Smith', '0121701100111', 100], ['Bob', '0121701100115',77], ['Lily', '0121701100117', 59]]

  1. #使用匿名函数lambda
  2. m = int(input())
  3. n = int(input())
  4.  
  5. myList = [('dungeon',7),('winterfell',4),('bran',9),('meelo',6)]
  6. if m > len(myList):
  7.     m = len(myList)
  8. print(sorted(myList, key=lambda x:x[1])[:m])
  9.  
  10. score = [[ 'Angle', '0121701100106',99], [ 'Jack', '0121701100107',86], [ 'Tom', '0121701100109',65], [ 'Smith', '0121701100111', 100], ['Bob', '0121701100115',77], ['Lily', '0121701100117', 59]]
  11. if n > len(score):
  12.     n = len(score)
  13. print(sorted(score, key=lambda x:x[0])[:n])
  14. print(sorted(score, key=lambda x:x[2])[:n])

集合

基础知识

  1. # 集合添加元素
  2. s = set('Wuhan') 
  3. print(s)              # {'n', 'a', 'W', 'u', 'h'}
  4. s.add('A')            # 向集合中增加一个元素
  5. print(s)              # {'n', 'a', 'A', 'W', 'u', 'h'}
  6. print(s.add('Hubei')) # 本方法返回值为 None
  7. print(s)              # {'n', 'a', 'A', 'W', 'u', 'Hubei', 'h'}
  8.  
  9. # 集合元素删除
  10. s = set([1,2,3,4,5,6,7,8，9])
  11. s.remove(5)
  12. print(s)            # {1, 2, 3, 4, 6, 7, 8, 9}
  13. print(s.remove(4))  # None
  14. print(s)            # {1, 2, 3, 6, 7, 8, 9}
  15. s.remove(0)         # KeyError: 0
  16. s.discard(x) 
  17. # 从集合s 中随机删除一个元素，返回值为删除的元素。当集合为空时，触发 KeyError。
  18. s = set([1])
  19. print(s.pop())      # 1
  20. print(s)            # set()
  21. s.pop()             #  KeyError: 'pop from an empty set'

典例1：输入一系列以逗号分隔的英文人名，其中包含重复的名字，请将其中重复的名字去掉，输出包含不重复人名的列表，名字出现顺序与输入顺序相同。

  1. name_lst = input().split(',')                         # 输入的字符串节分为列表
  2. name_no_duplicate = list(set(name_lst))               # 去除重复的元素
  3. print(sorted(name_no_duplicate, key=name_lst.index))  # 按名字在原列表中出现的顺序排序

典例2：输入一个非空字符串，去除重复的字符后，从小到大排序输出为一个新字符串。

  1. ls = list(set(input()))  # 字符串转集合去重，再转为列表
  2. ls.sort()                # 列表排序 
  3. print(''.join(ls))       # 列表中的字符串元素连接为一个字符串

字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

Python字典包含了以下内置方法：

序号函数及描述
1dict.clear()
删除字典内所有元素
2dict.copy()
返回一个字典的浅复制
3dict.fromkeys(seq[, val])
创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4dict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
5dict.has_key(key)
如果键在字典dict里返回true，否则返回false
6dict.items()
以列表返回可遍历的(键, 值) 元组数组
7dict.keys()
以列表返回一个字典所有的键
8dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9dict.update(dict2)
把字典dict2的键/值对更新到dict里
10dict.values()
以列表返回字典中的所有值
11pop(key[,default])
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12popitem()
返回并删除字典中的最后一对键和值。

典例1：用户登录

有字典如下： dic = {'admin':'123456','administrator':'12345678','root':'password'}‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

实现用户输入用户名和密码，当用户名与密码和字典中的键值对匹配时，显示“登录成功”，否则显示“登录失败”，登录失败时允许重复输入三次。

  1. dic = {'admin':'123456','administrator':'12345678','root':'password'}
  2. error_num = 0
  3. while error_num < 3:
  4.     username = input()
  5.     password = input()
  6.     if username in dic.keys()  and password == dic[username]:
  7.         print("登录成功")
  8.         break
  9.     else:
  10.         print("登录失败")
  11.         error_num += 1

典例2：

有两个字典数据如下： dic1 = {'Tom':21,'Bob':18,'Jack':23,'Ana':20} dic2 = {'李雷':21,'韩梅梅':18,'小明':23,'小红':20}‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

请将dic1 按键的大小升序排序，将dic2按值的大小升序排序，输出dic1的前n个键的内容，输出dic2前n个键值对。当n大于元素个数时，按实际元素数量输出。

  1. dic1 = {'Tom':21,'Bob':18,'Jack':23,'Ana':20}
  2. dic2 = {'李雷':21,'韩梅梅':18,'小明':23,'小红':20}
  3. n = int(input())
  4. if n > len(dic1):
  5.     n = len(dic1)
  6. print(sorted(dic1.keys())[:n])
  7. print(sorted(dic2.items(),key = lambda  item:item[1])[:n])

典例3：字典统计词频

使用freqDict = eval(input()) 读入单词词频字典，再读入一段英文，默认按照英文输入的顺序，统计更新单词词频字典，并输出。

  1. freqDict = eval(input())
  2. for word in input().split():
  3.     freqDict[word] = freqDict.get(word,0)+1
  4. print(freqDict)

文件

t文本模式 (默认)。
x写模式，新建一个文件，如果该文件已存在则会报错。
b二进制模式。
+打开一个文件进行更新(可读可写)。
U通用换行模式（不推荐）。
r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+打开一个文件用于读写。文件指针将会放在文件的开头。
rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

典例1：编程统计文本中的单词数量，不包括空格和标点符号（!"#$%&()*+,./:;<=>@[\]^_‘{|}~\n），这些符号和空白符一样都是单词的分隔符。 

  1. def read_file(filename):
  2.     """接收文件名为参数，读取文件内容为一个字符串
  3.     返回这个字符串。
  4.     """
  5.     with open(filename, 'r') as file:  # 只读模式打开文件
  6.         text = file.read()  # 文件内容读入到一个字符串
  7.     return text  # 返回字符串
  8.  
  9.  
  10. def replace_txt(text):
  11.     """接收一个字符串为参数，将其中的特殊字符替换为空格
  12.     将字符串根据空格切分为列表，返回这个列表
  13.     """
  14.     for ch in '!"#$%&()*+,./:;<=>?@[\\]^_‘{|}~\n':
  15.         text = text.replace(ch, " ")  # 将字符串中特殊字符替换为空格，注意要赋值回去
  16.     return text.split()              # 根据空格将字符串切分为列表返回
  17.  
  18.  
  19. if __name__ == '__main__':
  20.     name = input()                 # 输入文件名
  21.     txt = read_file(name)      # 读文件，返回字符串
  22.     result = replace_txt(txt)  # 字符串替换和切分
  23.     print(len(result))

典例2：

描述‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

附件文件中存在一些缺失数据，请找出这些缺失值并用输入的字符串 s 来替换。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

输入一个字符串s‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

处理结果以二维列表形式输出，元素为原文件的每一行切分成的列表

  1. ls = []
  2. fill = input()
  3. with open('filldata.csv','r',encoding='utf-8') as fr:
  4. 	for i in fr:
  5. 		nofill = i.strip().split(',')
  6. 		for j in range(len(nofill)):
  7. 			if len(nofill[j]) == 0:
  8. 				nofill[j] = fill
  9. 		ls.append(nofill)
  10. print(ls)

典例3：读取附件是一篇英文短文，请编写程序统计这篇短文前 n 行中每一个英文字母出现的次数，结果按次数降序排列，次数相同时，按字母表顺序输出。若 n 值大于短文行数，输出整篇文章中每一个英文字母出现的次数（大写字母按小写字母统计）。

  1. s = 'abcdefghijklmnopqrstuvwxyz'
  2. n = int(input())
  3. with open('The Old Man and the Sea.txt','r',encoding='utf-8') as data:
  4. 	txt = data.readlines()
  5. if n > len(txt):
  6. 	n = len(txt)
  7. mystr = ' '.join(txt[:n])
  8. # print(mystr)
  9. ls = [[x,mystr.lower().count(x)] for x in s ]
  10. ls.sort(key = lambda x:(-x[1],x[0]))
  11. #print(ls)
  12. for i in ls:
  13. 	print('{} 的数量是 {:>3} 个'.format(i[0],i[1]))

写了两天就写了这么多啦，狗子们加油

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/695012
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号