目录
基本操作题
一.Python基本数据类型
考点1：format方法的格式控制
典例1： 接收用户输入的一个小于 20的正整数，在屏幕上逐行递增显示从 01 到该正整数，数字显示的宽度为 2，不足位置补 0，后面追加一个空格，然后显示‘>’号，‘>’号的个数等于行首数字。
n = input('请输入一个正整数:')
for i in range(____________):
print('____________'.format(i + 1, ____________))
n = input('请输入一个正整数:')
for i in range(int(n)):
print('{:0>2} {}'.format(i+1,">"*(i+1) ))典例2：键盘输入正整数 n，按要求把 n 输出到屏幕，格式要求：宽度为 25 个字符，等号字符 (=) 填充，右对齐，带千位分隔符。如果输入正整数超过 25 位，则按照真实长度输出。
s = input()
print("{_______(1)_________}".format(_______(2)_________))
s = input()
print("{:=>25,}".format(eval(s)))典例3：从键盘上输入球的半径 r，输出球的表面积 S 和体积 V（ 1 个英文空格隔开，结果保留两位小数）。
PI = 3.14
r = eval(input())
S = ______ # 球体表面积
V = ______ #球体体积
print("______".format(S,V))
PI = 3.14
r = eval(input())
S = 4 * PI * pow(r,2)
V = (4/3) * PI * pow(r,3)
print("{:.2f} {:.2f}".format(S,V))典例4：输入一个正整数（范围为65 - 96），请输出对应的 Unicode 字符。
x = eval(input())
print("{:c}".format(x))典例5：从键盘接收输入十进制数，格式化输出其十六进制小写形式。要求：输出字符串长度为 30，十六进制小写形式居中，填充字符串为一个英文双引号。
s = input()
print("{__________}".format(_________))
s = input()
print("{:\"^30x}".format(eval(s)))典例6：从键盘输入一个整数和一个字符，以逗号隔开，在屏幕上显示输出一条信息。
示例：输入: "10,@" 输出: "@@@@@@@@@@10@@@@@@@@@@"
ls= input().split(',') #将从键盘上输入的用逗号隔开的字符串转换为列表
#例如输入:10,@
#ls为['10', '@']
#ls[0]为'10' ,eval(ls[0])*2+len(ls[0])表达式值为22
#ls[1]为'@'
print(ls[0].center(eval(ls[0])*2+len(ls[0]),ls[1]))
#'10'.center(22,"@")即为输出结果,考察字符串的center方法典例7：程序接收用户输入的五个数，以逗号分隔。将这些数按照输入顺序输出，每个数占 10 个字符宽度，右对齐，所有数字显示在同一行。
num = input().____________
for i in num:
print(____________)
num = input().split(',')
for i in num:
print("{:>10}".format(i),end="")典例8：从键盘输入一个整数，在屏幕上显示输出该整数的十六进制、八进制、二进制表示形式。
Tempstr = ___（1）___
print("___（2）___".format(Tempstr))
Tempstr = eval(input())
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)
import random
random.seed(100)
s = 0
for i in range(3):
n=random.randint(1,9)
s=s+n**3
print(s)典例2：利用 random 随机库里的函数，生成一个由四个大小写字母组成的验证码，显示在屏幕上。
import random as r
zmb = 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz'
r.seed(1)
…
print(code)
import random as r # 用随机数要导入random库，并记别名为r
zmb = 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz' # 先定义好要使用的英文字母表；
r.seed(1)
code = '' # 初始化密码code为一个空字符串
# 循环4次，在循环里构造验证码的每个字符。从英文字母表里随机选取一个字母；用字符串的+=运算符，追加到密码变量上。
for i in range(4):
code += r.choice(zmb)
print(code)典例3：以 123 为随机数种子，随机生成 10 个在 1 (含)到 999 (含)之间的随机整数，每个随机数后跟随一个逗号进行分隔，屏幕输出这 10 个随机数。
import random
______
for i in range(______):
print(______, end=",")
import random
random.seed(123)
for i in range(10):
print(random.randint(1,999), end=",")典例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)___)
import random
random.seed(1)
n = eval(input())
sum = 0
for i in range(n):
fl = random.uniform(1,100)
sum += fl
print('{:.2f}'.format(fl))
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。
# 列表里每一个元素又是一个列表，对应一组的竞赛成绩
# 利用 len(score) 求得总的组数；
# 为了在输出语句里输出各组的编号数，所以需要使用带循环变量 i 的 for 循环
# 在这个循环结构中，按照计算公式计算每一组的总成绩，并显示输出计算结果
# 因为结果要求显示整数，格式定义里使用了int(final)。
score = [[87,79,90],[99,83,93],[90,75,89],[89,87,94],[95,85,84]]
for i in range(len(score)):
final = score[i][0]*0.6 + score[i][1]*0.3 + score[i][2]*0.1
print('the {} final score is {}'.format(i+1, int(final)))考点2：jieba分词
典例1：从键盘输入一个字符串，使用中文分词库 jieba 输出精确模式的中文分词结果。
import jieba
Tempstr = input()
ls = jieba.lcut(Tempstr)
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()
import jieba #导入中文分词库
f = open('out1.txt','w') #以写的方式打开out1.txt文件
fi = open("data.txt","r",encoding="utf-8") #以读的方式打开data.txt文件
#使用jieba.lcut()对data.txt文件读出字符串进行中文分词，返回列表lst
lst = jieba.lcut(fi.read())
s = set(lst) #使用set函数将列表lst转换为集合，实现元素去重
s1 = sorted(s) #将列表按字符顺序排序
ls = list(s1) #将集合重新变成列表ls
for item in ls: #遍历去重后ls每一个元素
if len(item) >=3:
f.write(item + "\n") #将符合条件的字符串写入out1.txt中
fi.close() #关闭文件fi
f.close() #关闭文件f典例3：从键盘输入一个中文字符串变量 s，内部包含中文标点符号。用 jieba 分词，计算字符串 s 中的中文词汇个数，不包括 “ ，。、” （左引号，逗号，句号，顿号，右引号）这5个中文标点符号。显示输出分词后的结果，用”/ ”分隔，以及中文词汇个数。
import jieba
s = input()
.....
print("\n中文词语数是：{}".format(len(k)))
s = input()
s = s.replace('，','').replace('。','').replace('、','').replace('“','').replace('”','')
k = jieba.lcut(s)
for i in k:
print(i, end= "/ ")
print("\n中文词语数是：{}".format(len(k)))
# 要处理掉输入的各种标点符号，用replace（）函数
# 如果要保存各个词出现次数可以用字典典例4：苏格拉底是古希腊著名的思想家、哲学家、教育家、公民陪审员。苏格拉底的部分名言被翻译为中文，其部分内容由 sgld.txt 给出。读取文件，请过滤中文逗号、中文句号、中文冒号、中文引号，英文空格、换行符\n 之后，对其中的内容进行中文分词，在屏幕上显示输出词语出现次数前5的词，用一个中文顿号、分割。
# 模板
import jieba
with open("sgld.txt","r",encoding ="utf-8") as f:
lssgld = f.readlines()
......
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse = True)
......
# 正确解答
import jieba #导入中文分词库，这是必考点
with open("sgld.txt","r",encoding ="utf-8")as f: #使用with语句以只读方式打开文件
lssgld = f.readlines() #按行读取文件构建lssgld列表
d = {} #定义空字典
for ls in lssgld:
ls = ls.replace("\n","") #数据清洗:去掉每一行最后的换行符
for c in "。，：”“ ": #中文分词前，将中文逗号、中文句号、中文冒号、中文引号，英文空格替换为空字符
ls = ls.replace(c, "") #使用字符串函数replace将
wordlist = jieba.cut(ls) #对每行进行中文分词
for word in wordlist:
d[word] = d.get(word,0) + 1 #构建字典
ls = list(d.items())
ls.sort(key=lambda x:x[1], reverse = True) #列表排序
for i in range(5):
a = ls[i][0]
print("{}".format(a),end = "、") #出现次数前5的词*典例5：在数据文件 lizhi.txt 里有一堆励志短语，每句一行。用 jieba 分词库的 lcut() 函数分词，统计分词后的长度大于等于 2 的词组的出现次数，按照出现次数排序，在屏幕上显示出现次数最多的 10 个词。在画布上，用 tutle 的 circle 画填充为红色的圆圈，圆圈的半径为出现次数 n*4，最大的圆圈的起点在画布的坐标 (-300,0)，其余的圆按顺序沿着 x 轴向右边相邻，连续扩展。输出示例： 
# 模板代码
import jieba
import turtle as t
def drawCircle(x,y,radius,color,name):
t.pencolor(color)
t.penup()
t.____(1)____
t.write(name, font=('Arial', 10, 'normal'))
t.seth(__(2)___)
t.pendown()
t.circle(__(3)___)
return t.pos()
dws = {}
with open('lizhi.txt', 'r') as f:
for l in f.readlines():
ws = _____(4)_______
for w in ws:
if ___(5)____:
dws[w] = dws.get(w,0) + 1
dls = list(dws.items())
dls.sort(key = lambda x:x[1], reverse= True)
x,y = -300,0
for i in range(10):
print(_____(6______)
x,y = drawCircle(x,y,dls[i][1]*4 ,'red',____(7)_____))
x += _____(8)______
t.done()
# 正确代码
import jieba #导入中文分词库jieba
import turtle as t #导入turtle库，并给turtle去一个别名t
def drawCircle(x,y,radius,color,name): #自定义函数drawCircle,包含了5个参数
t.pencolor(color) #设置绘圆的颜色,color是一个必选参数，调用函数时可以设置为'red'、'blue'...
t.penup() #绘图笔提前起来，表示不落下去绘图，
t.goto(x, y) #将笔的坐标定位到(x,y),x,y都是必选参数
t.write(name, font=('Arial', 10, 'normal')) #在当前的(x,y),写上name内容，文字属性由font决定。name是必选参数
t.seth(-90) #将绘图方向设置为-90度方向
t.pendown() #绘图笔放下，表示落下去绘图，有颜色啦:)
t.circle(radius) #按半径为radius绘制圆形
return t.pos() #返回t.pos()当前的位置,例如:(-300.00,0.00)
dws = {} #定义一个字典，注意不是集合哦
with open('lizhi.txt', 'r',encoding="utf-8") as f: #用with语句以只读方式打开lizhi.txt文件
for l in f.readlines(): #遍历列表f.readlines()中的每一个元素
ws = jieba.lcut(l.strip('\n')) #去掉行字符串最后的"\n"不可显示换行符，
#使用jieba.lcut(str)函数进行中文分词，返回一个列表
for w in ws:
if len(w) >= 2: #统计词语长度>=2 的词语出现频次
dws[w] = dws.get(w,0) + 1 #逐步构建字典dws,词语:次数的键值对
#如果w在dws的keys中，则键值+1，如果w不在dws的keys中，则构建健值对dws[w] = 0 + 1
dls = list(dws.items()) #将dws.items()转换为列表并赋值给dls,形如[("abc",10),("edf","12"),...]，目前是无序的
dls.sort(key = lambda x:x[1], reverse= True) #对dls进行排序，按列表元素中索引为1，这行代码考试时会给出。但一定要理解。
x,y = -300,0 #设置初始坐标位置
for i in range(10): #根据统计结果绘制图形
print(dls[i][0],dls[i][1]) #输出结果
x,y = drawCircle(x,y,dls[i][1]*4 ,'red',dls[i][0]+str(dls[i][1])) #调用绘图函数实现绘图
x += dls[i][1] * 8 #改变x初始位置，y值不变
t.done()Turtle绘图题
典例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()
r = 10
dr = 50 #设置不同圆圈之间半径的差是50像素
head = 90
for i in range (4):
turtle.pendown()
turtle.circle(r)
r += dr
turtle.penup()
turtle.seth(-head)
turtle.fd(dr)
turtle.seth(0)
turtle.done()典例2：
import turtle
def drawCircle(): #定义画圆函数
turtle.pendown()
turtle.circle(20)
turtle.penup()
turtle.fd(40)
def drawRowCircle(n): # 定义画层次圆函数
for j in range(n,1,-1):
for i in range(j):
drawCircle() # *
turtle.fd(-j*40-20)
turtle.right(90)
turtle.fd(40)
turtle.left(90)
turtle.fd(40)
drawCircle()
drawRowCircle(5) #画圆（5行）
turtle.hideturtle()
turtle.done()典例3：
使用 turtle 库的 turtle.right() 函数和 turtle.circle() 函数绘制一个星星图形，圆弧的半径为 90。
import turtle
for i in range(4):
turtle.circle(-90,90) #注意第一个空为负值
turtle.right(180)典例4：
# 题目模板
import turtle
turtle._____(1)_______ #画笔颜色与填充设置
turtle.begin_fill()
#绘制太阳花形状
for i in range(50):
turtle._____(2)_______ #先前200
turtle._____(3)_______ #右转170度
turtle.end_fill()
turtle.done()
# 解答
import turtle
turtle.color("red","yellow")
turtle.begin_fill()
for i in range(50):
turtle.forward(200)
turtle.right(170)
turtle.end_fill()
turtle.done()典例5：
# 解题模板：
____________
ls = [69, 292, 33, 131, 61, 254]
X_len = 400
Y_len = 300
x0 = -200
y0 = -100
t.penup()
t.goto(x0, y0)
t.pendown()
t.fd(X_len)
t.fd(-X_len)
t.seth(____________)
t.fd(Y_len)
t.pencolor('red')
t.pensize(5)
for i in range(len(ls)):
t.____________
t.goto(x0 + (i+1)*50, ____________)
t.seth(90)
t.pendown()
t.fd(____________)
t.done()
# 解答
import turtle as t #更简洁地调用turtle库
ls = [69, 292, 33, 131, 61, 254]
X_len = 400
Y_len = 300
x0 = -200
y0 = -100
t.penup()
t.goto(x0, y0)
t.pendown()
t.fd(X_len)
t.fd(-X_len)
t.seth(90) #设置笔的起始角度
t.fd(Y_len)
t.pencolor('red')
t.pensize(5)
for i in range(len(ls)):
t.penup() #提起画笔
t.goto(x0 + (i+1)*50, y0) #移到绝对坐标处，这里x坐标动，y坐标不动
t.seth(90)
t.pendown() #放下画笔
t.fd(ls[i]) #表示直线爬行的距离
t.done()
简单应用题
字符串
典例1：输入一个英文句子，以回车符结束，单词间以空格分隔，标点符号后跟至少一个空格，统计并输出单词的个数（仅统计单词，数字按单词计，不计算标点符号，重复单词出现几次就统计几次）。
s = input()
ls = s.split()
print(len(ls))典例2：程序每次读入一个正整数，然后输出按位逆序的数字。注意：当输入的数字含有结尾的0时，输出不应带有前导的0。比如输入65000，输出应该是56。
num = input() # 输入一个正整数的字符串
print(int(num[::-1])) # 对字符串逆序，再转整型，int()函数可去除整数前面的前导0
# 或用字符串处理方法lstrip('0')去除字符串左侧的字符'0'
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”。
# 逻辑表达式实现
month = input().lower().capitalize()
if month == 'September':
output = month[:4] + '.'
elif month == 'January' or month == 'February' or month == 'March' or month == 'April' or month == 'May' or \
month == 'July' or month == 'July' or month == 'August' or month == 'September' or month == 'October' or \
month == 'November' or month == 'December':
output = month[:3] + '.'
else:
output = 'spelling mistake'
print(output)
# 列表实现
month = input().lower().capitalize()
month_lst = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October',
'November', 'December']
if month == 'September':
print(month[:4] + '.')
elif month in month_lst:
print(month[:3] + '.')
else:
print('spelling mistake')典例4*（此题有一定难度，可以选择性看）：
中国目前采用的是18位身份证号，其第7-10位数字是出生年，11-12位是出生月份，13-14是出生日期，第17位是性别，奇数为男性，偶数为女性，第18位是校验位。 如果身份证号码的其中一位填错了（包括最后一个校验位），则校验算法可以检测出来。如果身份证号的相邻2位填反了，则校验算法可以检测出来。校验规则如下：
- 将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2。
- 将这17位数字和系数相乘的结果相加。
- 用加出来和除以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行中输出'身份证号码校验为合法号码!'，并输出该人的出生年月日和性别。
def id_check(id_num): """接收身份证号为参数，计算并检查校验和，返回布尔值""" check_sum = sum([weight[i] * int(id_num[i]) for i in range(17)]) if id_num[17] == 'X': # 若末位为'X' return True if check_sum % 11 == 2 else False return True if (check_sum % 11 + int(id_num[17])) % 11 == 1 else False def id_info(id_num): """接收身份证号为参数，返回年、月、日和性别，均为字符串类型""" year = id_num[6:10] month = id_num[10:12] date = id_num[12:14] gender = '男' if id_num[16] in '13579' else '女' return year, month, date, gender if __name__ == '__main__': id_number = input() weight = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1] if id_check(id_number): info = id_info(id_number) print('身份证号码校验为合法号码!') print('出生：{}年{}月{}日'.format(info[0], info[1], info[2])) print('性别：{}'.format(info[3])) else: print('身份证校验位错误!')列表元组
典例1：在两行中分别输入一个字符串，分别将其转换为列表 a 和 b，按要求完成以下功能： 1. 输出两个列表的拼接结果 2. 输出列表 a 重复3次的结果 3.输出列表 b 中第3个元素和最后一个元素 4.输出列表 a 中序号1至4之间的元素 5. 输出列表 a 、b的长度，结果用逗号分隔 6. 输出列表 a 的中元素的最小值和 b 中元素的最大值
a = list(input())
b = list(input())
print(a + b)
print(a * 3)
print(b[2],b[-1],sep = ' ')
print(a[1:4])
print(len(a),len(b),sep = ',')
print(min(a),max(b))典例2：读入一行英文，单词之间以一个空格隔开，如果句中有标点符号，其后也用一个空格分隔。该行英文中可能包含0个或1个"and"，如果"and"在字符串中存在，请在"and"前面插入"Anna"，并输出。（列表元素的查找和添加）
aList = input().split()
if 'and' in aList:
ind = aList.index('and')
aList.insert(ind,'Anna')
print(' '.join(aList))典例3：读入两行，两行的格式一样，都是用空格分隔的若干个整数，将这些数合并到一个列表中，降序排列后输出整个列表。
lst_a = input().split() # 输入转为列表
lst_b = input().split() # 输入转为列表
lst_ab = lst_a + lst_b # 两个列表拼接为一个列表
lst_int = [int(x) for x in lst_ab] # 将列表lst_ab中的元素转为整数，产生新列表
lst_int.sort(reverse=True) # 列表原地排序，逆序
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]]
#使用匿名函数lambda
m = int(input())
n = int(input())
myList = [('dungeon',7),('winterfell',4),('bran',9),('meelo',6)]
if m > len(myList):
m = len(myList)
print(sorted(myList, key=lambda x:x[1])[:m])
score = [[ 'Angle', '0121701100106',99], [ 'Jack', '0121701100107',86], [ 'Tom', '0121701100109',65], [ 'Smith', '0121701100111', 100], ['Bob', '0121701100115',77], ['Lily', '0121701100117', 59]]
if n > len(score):
n = len(score)
print(sorted(score, key=lambda x:x[0])[:n])
print(sorted(score, key=lambda x:x[2])[:n])集合
基础知识
# 集合添加元素
s = set('Wuhan')
print(s) # {'n', 'a', 'W', 'u', 'h'}
s.add('A') # 向集合中增加一个元素
print(s) # {'n', 'a', 'A', 'W', 'u', 'h'}
print(s.add('Hubei')) # 本方法返回值为 None
print(s) # {'n', 'a', 'A', 'W', 'u', 'Hubei', 'h'}
# 集合元素删除
s = set([1,2,3,4,5,6,7,8，9])
s.remove(5)
print(s) # {1, 2, 3, 4, 6, 7, 8, 9}
print(s.remove(4)) # None
print(s) # {1, 2, 3, 6, 7, 8, 9}
s.remove(0) # KeyError: 0
s.discard(x)
# 从集合s 中随机删除一个元素，返回值为删除的元素。当集合为空时，触发 KeyError。
s = set([1])
print(s.pop()) # 1
print(s) # set()
s.pop() # KeyError: 'pop from an empty set'典例1：输入一系列以逗号分隔的英文人名，其中包含重复的名字，请将其中重复的名字去掉，输出包含不重复人名的列表，名字出现顺序与输入顺序相同。
name_lst = input().split(',') # 输入的字符串节分为列表
name_no_duplicate = list(set(name_lst)) # 去除重复的元素
print(sorted(name_no_duplicate, key=name_lst.index)) # 按名字在原列表中出现的顺序排序典例2：输入一个非空字符串，去除重复的字符后，从小到大排序输出为一个新字符串。
ls = list(set(input())) # 字符串转集合去重，再转为列表
ls.sort() # 列表排序
print(''.join(ls)) # 列表中的字符串元素连接为一个字符串字典
典例1：用户登录
有字典如下： dic = {'admin':'123456','administrator':'12345678','root':'password'}
实现用户输入用户名和密码，当用户名与密码和字典中的键值对匹配时，显示“登录成功”，否则显示“登录失败”，登录失败时允许重复输入三次。
dic = {'admin':'123456','administrator':'12345678','root':'password'}
error_num = 0
while error_num < 3:
username = input()
password = input()
if username in dic.keys() and password == dic[username]:
print("登录成功")
break
else:
print("登录失败")
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大于元素个数时，按实际元素数量输出。
dic1 = {'Tom':21,'Bob':18,'Jack':23,'Ana':20}
dic2 = {'李雷':21,'韩梅梅':18,'小明':23,'小红':20}
n = int(input())
if n > len(dic1):
n = len(dic1)
print(sorted(dic1.keys())[:n])
print(sorted(dic2.items(),key = lambda item:item[1])[:n])典例3：字典统计词频
使用freqDict = eval(input()) 读入单词词频字典，再读入一段英文，默认按照英文输入的顺序，统计更新单词词频字典，并输出。
freqDict = eval(input())
for word in input().split():
freqDict[word] = freqDict.get(word,0)+1
print(freqDict)文件
典例1：编程统计文本中的单词数量，不包括空格和标点符号（!"#$%&()*+,./:;<=>@[\]^_‘{|}~\n），这些符号和空白符一样都是单词的分隔符。
def read_file(filename):
"""接收文件名为参数，读取文件内容为一个字符串
返回这个字符串。
"""
with open(filename, 'r') as file: # 只读模式打开文件
text = file.read() # 文件内容读入到一个字符串
return text # 返回字符串
def replace_txt(text):
"""接收一个字符串为参数，将其中的特殊字符替换为空格
将字符串根据空格切分为列表，返回这个列表
"""
for ch in '!"#$%&()*+,./:;<=>?@[\\]^_‘{|}~\n':
text = text.replace(ch, " ") # 将字符串中特殊字符替换为空格，注意要赋值回去
return text.split() # 根据空格将字符串切分为列表返回
if __name__ == '__main__':
name = input() # 输入文件名
txt = read_file(name) # 读文件，返回字符串
result = replace_txt(txt) # 字符串替换和切分
print(len(result)) 典例2：
描述
附件文件中存在一些缺失数据，请找出这些缺失值并用输入的字符串 s 来替换。
输入格式
输入一个字符串s
输出格式
处理结果以二维列表形式输出，元素为原文件的每一行切分成的列表
ls = []
fill = input()
with open('filldata.csv','r',encoding='utf-8') as fr:
for i in fr:
nofill = i.strip().split(',')
for j in range(len(nofill)):
if len(nofill[j]) == 0:
nofill[j] = fill
ls.append(nofill)
print(ls)典例3：读取附件是一篇英文短文，请编写程序统计这篇短文前 n 行中每一个英文字母出现的次数，结果按次数降序排列，次数相同时，按字母表顺序输出。若 n 值大于短文行数，输出整篇文章中每一个英文字母出现的次数（大写字母按小写字母统计）。
s = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())
with open('The Old Man and the Sea.txt','r',encoding='utf-8') as data:
txt = data.readlines()
if n > len(txt):
n = len(txt)
mystr = ' '.join(txt[:n])
# print(mystr)
ls = [[x,mystr.lower().count(x)] for x in s ]
ls.sort(key = lambda x:(-x[1],x[0]))
#print(ls)
for i in ls:
print('{} 的数量是 {:>3} 个'.format(i[0],i[1]))写了两天就写了这么多啦，狗子们加油
