python 15-17

实验15(综合练习01)

一、编程题（共10小题，100分）
题型得分 95
【描述】
输入一行字符串（可能包含大小写字母、数字、标点符号、空格等），现只考虑其中字母和数字，并忽略大小写，判断其是否为回文串。回文串是一个正读和反读都一样的字符串，比如""（空串），“a”，"level"或者"noon"等等就是回文串。
【输入】
一行字符串。
【输出】
如果是回文串，输出True，否则输出False。
【输入示例】
Aman, a plan, a canal: Panama
【输出示例】
True
（10分）
我的答案：

s=input()
s="".join(filter(str.isalnum,s))
s=s.lower()
i=0
count=False
while i<len(s)/2:
    if s[i]==s[len(s)-i-1]:
        count=True
        i+=1
    else:
        count=False
        break
print(count)

题目得分 10
【描述】
你的程序要读入一行文本，其中以空格分隔为若干个单词，以’.‘结束。你要输出这行文本中每个单词的长度。这里的单词与语言无关，可以包括各种符号，比如"it’s"算一个单词，长度为4。注意，行中可能出现连续的空格。
【输入】
输入在一行中给出一行文本，以’.'结束，结尾的句号不能计算在最后一个单词的长度内。
【输出】
在一行中输出这行文本对应的单词的长度，每个长度之间以空格隔开，行末没有最后的空格。
【输入示例】
It’s great to see you here.
【输出示例】
4 5 2 3 3 4
（10分）
我的答案：

s=input()
s_list=s.split()
for i in range(len(s_list)):
    if i<len(s_list)-1:
        print(len(s_list[i]),end=' ')
    else: print(len(s_list[i])-1)

题目得分 10
【描述】
给定一个字符串a和字符串b，1≤a的长度≤100, 1≤b的长度≤a的长度。求b在a中的出现次数。
【输入】
有两行。
第一行给出字符串a。
第二行给出字符串b。
【输出】
一个整数，表示b在a中的出现次数。
【输入示例】

ababac
aba
【输出示例】
2
（10分）
我的答案：

sa=input()
sb=input()
print(sa.count(sb))

题目得分 5
【描述】
某辆卡车违犯交通规则，撞人后逃跑。现场有三人目击事件，但都没记住车号，只记下车号的一些特征。甲说：牌照的前两位数字是相同的；乙说：牌照的后两位数字是相同的，但与前两位不同；丙是位数学家，他说：四位的车号刚好是一个整数的平方。现在请根据以上线索帮助警方找出车号以便尽快破案。
【输入】
没有输入。
【输出】
输出车号和整数，以空格间隔
【输入示例】
没有输入。
【输出示例】

1234 56
【提示】
输出示例只是格式说明，并非正确答案。
（10分）
我的答案：

a=0
b=0
c=0
s=0
for a in range(0,10):
    for b in range(0,10):
        if b!=a:
            s=1000*a+100*a+b*10+b
            for c in range(0,round(s**0.5+1)):
                if c*c==s:
                    print(s,round(s**0.5))

题目得分 10
【描述】
有三个回文数字，第一个是两位数，第二个是三位数。将这两个回文数字相加得到第三个数字，这是个四位数。请问第三个回文数字是多少？
【输入】
没有输入。
【输出】
输出第三个回文数字。
（10分）
我的答案：

import random

def is_huiwen(x):
    s=str(x)
    f=True
    for i in range(len(s)//2):
        if s[i]!=s[-1-i]:
            f=False
            break
    return f

list1=[i for i in range(10,100)]
j=0
while True:
    if j>=len(list1):
        break
    if not(is_huiwen(list1[j])):
        del list1[j]
    else:
        j+=1


list2=[i for i in range(100,1000)]
j=0
while True:
    if j>=len(list2):
        break
    if not(is_huiwen(list2[j])):
        del list2[j]
    else:
        j+=1


list3=[i for i in range(1000,10000)]
j=0
while True:
    if j>=len(list3):
        break
    if not(is_huiwen(list3[j])):
        del list3[j]
    else:
        j+=1

k=1
while k:
    o = random.sample(list1,1)
    p = random.sample(list2,1)
    q = random.sample(list3,1)

    qian=o
    zhong=p
    hou=q
    math_qian=eval(str(qian[0]))
    math_zhong=eval(str(zhong[0]))
    math_hou=eval(str(hou[0]))

    k=math_qian+math_zhong-math_hou

print(str(hou[0]))

题目得分 10
【描述】
计算位于二维列表边缘的元素之和。所谓二维列表边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。
【输入】
第一行为整数k，表示有k组数据。
每组数据有多行组成，表示一个二维列表：第一行分别为矩阵的行数m和列数n（m < 100，n < 100），两者之间以一个空格分开。接下来输入的m行数据中，每行包含n个整数，整数之间以一个空格分开。
【输出】
对应二维列表的边缘元素和，一个一行。
【输入示例】

2
4 4
1 1 1 1
0 0 0 0
1 0 1 0
0 0 0 0
3 3
3 4 1
3 7 1
2 0 1
【输出示例】
5
15
【来源】
《Python程序设计基础》第5章编程题10
（10分）
我的答案：

n=int(input())
sum=[]
for i in range(0,n):
    x = []
    s = 0
    n, m = map(int, input().split())
    for i in range(n):
        x.append([])
        line = [int(value) for value in input().split()]
        for j in range(m):
            x[i].append(line[j])
    for row in range(len(x)):
        for column in range(len(x[row])):
            if row == 0 or row == n - 1 or column == 0 or column == m - 1:
                s += x[row][column]
    sum.append(s)
for i in range(0,n-1):
    print(sum[i])

题目得分 10
【描述】
编写程序，从键盘输入一个个单词，每接收到一个单词后，输出该单词曾经出现过的次数，接收到"QUIT"单词后程序直接退出。
【输入】
一行一个单词，"QUIT"结束。
【输出】
每行输出为相应单词统计结果
【输入示例

C++
map
set
map
vector
set
multiset
C++
QUIT
【输出示例】
0
0
0
1
0
1
0
1
（10分）
我的答案：

c=''
d={}
l1=[]
while c!='QUIT':
    c=input()
    l1.append(c)
    if c in d:
        d[c]+=1
    else:
        d[c]=1
    if c!='QUIT':
        print(d[c]-1)
    
# print(l1)

题目得分 10
【描述】
定义函数：def n_letter_dictionary(s)，该函数接受一个字符串s作为参数；返回一个字典，它的键是数字，它的值是列表，其中包含惟一的单词，这些单词的长度与键相等。
例如：
若输入的字符串是"The way you see people is the way you treat them and the Way you treat them is what they become"
函数应该返回{2: [‘is’], 3: [‘and’, ‘see’, ‘the’, ‘way’, ‘you’], 4: [‘them’, ‘they’, ‘what’], 5: [‘treat’], 6: [‘become’, ‘people’]}
字符串中的单词以一个空格间隔。
字典的值是具有相同长度的单词列表，且按升序排序。
单词列表中的单词是惟一的。上述字符串中"them"单词出现了两次，但单词列表中只有一个"them"。
单词列表中的所有单词应该转换为小写。上述字符串中"The"和"the"单词，在单词列表中只有一个"the"。
【输入】
一个字符串。
【输出】
输出一个字典。
【输入示例】

The way you see people is the way you treat them and the Way you treat them is what they become
【输出示例】
{2: [‘is’], 3: [‘and’, ‘see’, ‘the’, ‘way’, ‘you’], 4: [‘them’, ‘they’, ‘what’], 5: [‘treat’], 6: [‘become’, ‘people’]}
（10分）
我的答案：

from operator import itemgetter

def n_letter_dictionary(s):
    s=s.lower()
    s=s.split()
    d={}
    for i in range(len(s)):
        for j in range(len(s)):
            if len(s[i])==len(s[j]):
                if len(s[i]) not in d:
                    d[len(s[i])] = s[i].split()
                elif s[i] not in d[len(s[i])]:
                    d[len(s[i])].append(s[i])
    for i in d:
        d[i].sort()
    b=sorted(d.items(),key=itemgetter(0))
    b1=dict(b)
    return b1

str1=input()
print(n_letter_dictionary(str1))

题目得分 10
【描述】
定义函数：def dictionary_to_tuples(dictionary)，该函数接受一个字典作为参数；返回一个二维元组，第一个内嵌元组是字典的键，第二个内嵌元组是字典的值。
例如，如果输入的字典是：{1:‘a’, 2:‘b’, 3:‘c’, 4:‘d’}，函数返回元组：((1, 2, 3, 4), (‘a’, ‘b’, ‘c’, ‘d’))。
【输入】
每一行输入键（整数）及其对应的值（字符串），其间以逗号分隔。每行数据构成字典的一个键值对。可能会有多行输入。
【输出】
输出一个二维元组，按字典的键升序输出，第一个内嵌元组是字典的键，第二个内嵌元组是字典的键对应的值 。
【输入示例】

1,a
2,b
3,c
4,d
【输出示例】
((1, 2, 3, 4), (‘a’, ‘b’, ‘c’, ‘d’))
（10分）
我的答案：

def dictionary_to_tuples(dictionary):
    keys=dictionary.keys()
    items=dictionary.items()
    l1=list(keys)
    l2=tuple(items)
    l3=[]
    for j in range(len(l1)):
        l1[j]=int(l1[j])
    l1=tuple(l1)
    for i in range(len(l2)):
        l3.append(l2[i][1])
    l3=tuple(l3)
    return l1,l3
d={}
n=4
i=0
while(i<n):
    a,b=input().split(',')
    d[a]=b
    i=i+1

print(d)

print(dictionary_to_tuples(d))
题目得分 10
【描述】
某校大门外长度为L的马路上有一排树，每两棵相邻的树之间的间隔都是1米。我们可以把马路看成一个数轴，马路的一端在数轴0的位置，另一端在L的位置；数轴上的每个整数点，即0，1，2…L，都种有一棵树。
马路上有一些区域要用来建地铁，这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。
【输入】
输入的第一行有两个整数L（1≤L≤10000）和 M（1≤M≤100），L代表马路的长度，M代表区域的数目，L和M之间用一个空格隔开。
接下来的M行每行包含两个不同的整数，用一个空格隔开，表示一个区域的起始点和终止点的坐标。
【输出】
输出一个整数，表示马路上剩余的树的数目。
【输入示例】
500 3
150 300
100 200
470 471
【输出示例】
298
（10分）
我的答案：

a=[]
c=0
for i in range(0,10001):
    a.append(1)
l,m=input().split()
l=int(l)
m=int(m)
for i in range(0,m):
    u,v=input().split()
    u=int(u)
    v=int(v)
    for j in range(u,v+1):
        a[j]=0
for k in range(0,l+1):
    if a[k]==1:
        c=c+1
print(c)
i=i+1

题目得分 10

实验16(综合练习02)

一、编程题（共10小题，100分）
题型得分 100
【描述】
每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如"x-xxx-xxxxx-x"，其中符号"-“就是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。ISBN码的首位数字表示书籍的出版语言，例如0代表英语；第一个分隔符”-“之后的三位数字代表出版社，例如670代表维京出版社；第二个分隔符后的五位数字代表该书在该出版社的编号；最后一位为识别码。
识别码的计算方法如下：
首位数字乘以1加上次位数字乘以2……以此类推，用所得的结果mod 11，所得的余数即为识别码，如果余数为10，则识别码为大写字母X。例如ISBN号码0-670-82162-4中的识别码4是这样得到的：对067082162这9个数字，从左至右，分别乘以1，2，…,9，再求和，即0×1+6×2+……+2×9=158，然后取158 mod 11的结果4作为识别码。
你的任务是编写程序判断输入的ISBN号码中识别码是否正确，如果正确，则仅输出"Right”；如果错误，则输出你认为是正确的ISBN号码。
【输入】
输入只有一行，是一个字符序列，表示一本书的ISBN号码（保证输入符合ISBN的格式要求）。
【输出】
输出共一行，假如输入的ISBN号码的识别码正确，那么输出"Right"，否则，按照规定的格式，输出正确的ISBN号码（包括分隔符"-"）。
【输入示例】
0-123-41562-4
【输出示例】
Right
（10分）
我的答案：

ISBN=input()
z=0
k=0
for i in range(len(ISBN)-1):
    if ISBN[i]>='0' and ISBN[i]<='9':
        k=k+1
        z=z+((int(ISBN[i]))*k)
ans=z%11
# print(ans)
if ISBN[len(ISBN)-1]!='X':
    if ans!=10 and ans==int(ISBN[len(ISBN)-1]):
        print("Right")
    else:
        for i in range(len(ISBN)-1):
            print(ISBN[i],end='')
        if ans!=10:
            print(ans)
        else:
            print('X')
else:
    if ans==10 and ISBN[len(ISBN)-1]=='X':
        print("Right")
    else:
        for i in range(len(ISBN)-1):
            print(ISBN[i],end='')
        print(ans)

题目得分 10
【描述】
一个IP地址是用四个字节（每个字节8个位）的二进制码组成。请将32位二进制码表示的IP地址转换为十进制格式表示的IP地址输出。
【输入】
一行中给出32位二进制字符串。
【输出】
一行中输出十进制格式的IP地址，其由4个十进制数组成（分别对应4个8位的二进制数），中间用’.'分隔开。
【输入示例】

11001100100101000001010101110010
【输出示例】
204.148.21.114
（10分）
我的答案：

str=input()
count=0
list=[]
k=0
sum=0
for i in range(31,-1,-1):
    if str[i]=='1':
        sum=sum+pow(2,count)
    count=count+1
    if count%8==0:
        list.append(sum)
        sum=0
        k=k+1
        count=0

for j in range(3,-1,-1):
    print(list[j],end='')
    if j!=0:
        print('.',end='')

题目得分 10
【描述】
输入一个字符串和一个非负整数N，要求将字符串循环右移N次。
【输入】
第一行中给出一个字符串，以’#‘表示结束，’#'不是字符串的一部分，字符串的长度未知，但至少有一个字符。
第二行中给出非负整数N。
【输出】
在一行中输出循环右移N次后的字符串。
【输入示例】

Hello World!#
2
【输出示例】
d!Hello Worl
（10分）
我的答案：

str1=input()
n=int(input())
lst=list(str1)
lst.pop()
j=0
while(j<n):
    lst.append(lst[len(lst) - 1])
    for i in range(len(lst) - 2, -1, -1):
        # print(i)
        lst[i + 1] = lst[i]
    lst[0] = lst[len(lst) - 1]
    lst.pop()
    j=j+1
lst2 = ''.join(lst)
print(lst2)

题目得分 10
【描述】
突然有一天，你忘记了今天是星期几，中国人凑吉利，所以你找来了八个人，让他们每人说两句话，第一句为今天星期几，另一句为今天不是星期几，并且两句中一句真，一句假。可能第一句是真，也可能第二句是真。最后请你确定今天是星期几，并输出。
【输入】
8行，每行是两个星期几的阿拉伯数字表示，用空格分开。
【输出】
一个数字，表示今天星期几。
【输入示例】

1 2
2 6
3 4
5 1
7 7
1 5
1 4
4 2
【输出示例】
7
（10分）
我的答案：

lines = []
line2=[]
sum=0
for i in range(8):
    lines.append(input().split())
for i in range(8):
    for j in range(0,2):
        line2.append(int(lines[i][j]))
for i in range(1,8):
    sum=0
    for j in range(0,16,2):
        if (i==line2[j]) + (i!=line2[j+1]) ==1:
            sum=sum+1
    if sum==8:
        print(i)

题目得分 10
【描述】
有些文档中会出现很多数字，有时我们需要将其中的数字提取出来进行处理。
编写程序，求字符串中出现的整数的和。如下字符串：
China’s economy grew 7 percent in 2014.
其中整数为7和2014，它们的和为2021.
注意，字符串中的整数可能为正数或负数，正数可能有正号，也可能没有正号。如果没有整数，输出0。不在数字前面的正负符号不算整数，如a-b+c，结果应是0。-2-3是两个整数-2和-3。字符串中不会出现小数。但字符串中会有空格。
【输入】
带有字母、数字、标点符号、正负号、空格的英文字符串。字符串的长度不大于100.
【输出】
字符串中整数的和。如果没有整数，输出0
【输入示例】

China’s economy grew 7 percent in 2014
【输出示例】
2021
（10分）
我的答案：

import re
s1=input()
pattern = re.compile(r'-\d+|\d+')             
values = pattern.findall(s1)
s=0
for i in values:
   s=s+int(i) 
print(s)

题目得分 10
【描述】
定义函数：def calculate_grades(two_dimensional_list)，该函数接受一个二维列表作为参数，内嵌列表的元素由姓名、4门课成绩构成；返回一个二维元组，内嵌元组的元素由姓名、4门课平均分构成。二维元组按姓名升序排序。
例如，如果输入的二维列表是：
[[‘john’, 89, 94, 81, 97], [‘eva’, 40, 45, 65, 90], [‘joseph’, 0, 0,54, 99], [‘tim’, 73, 74, 89, 91]]
函数返回元组：
((‘eva’,60.0), (‘john’, 90.25), (‘joseph’, 38.25), (‘tim’, 81.75))
【输入】
每一行输入姓名、4门课成绩，其间以逗号分隔。每行数据构成二维列表的一个内嵌列表。可能会有多行输入。
【输出】
一个二维元组。
【输入示例】

john,89,94,81,97
eva,40,45,65,90
joseph,0,0,54,99
tim,73,74,89,91
【输出示例】

(('eva', 60.0), ('john', 90.25), ('joseph', 38.25), ('tim', 81.75))
（10分）
我的答案：
def calculate_grades(two_dimensional_list):
    # t=[]
    t2=[]
    for i in range(len(two_dimensional_list)):
        avg=(two_dimensional_list[i][1]+two_dimensional_list[i][2]+two_dimensional_list[i][3]+two_dimensional_list[i][4])/4
        t=[]
        t.append(two_dimensional_list[i][0])
        t.append(avg)
        t2.append(t)
    return t2

Input=input()
InputList=[]
while Input!="":
    InputList.append(Input.split(','))
    Input=input()
for i in range(len(InputList)):
    for j in range(1,5):
        InputList[i][j]=int(InputList[i][j])
lst2=calculate_grades(InputList)
lst2.sort()
for i in range(len(lst2)):
    lst2[i]=tuple(lst2[i])
print(tuple(lst2))

题目得分 10
【描述】
定义函数：def row_maximums(two_dimensional_list)，该函数接受一个二维数值列表作为参数，二维数值列表中的每一行可能有不同的列数；返回一个二维元组，内嵌元组的元素由形如"row i max"的字符串（i表示行数，从0开始）和对应行的最大值构成。二维元组按"row i max"升序排序。
例如，如果输入的二维列表是：[[5, 0, 0, 0, 13], [0, 12, 0, 0], [20, 0, 11, 0], [6, 0, 0, 8]]，函数返回二维元组：((‘row 0 max’, 13), (‘row 1 max’, 12),(‘row 2 max’, 20), (‘row 3 max’, 8))。
【输入】
每一行输入数值，数值间以一个空格分隔。每行数据构成二维列表的一个内嵌列表。可能会有多行输入。
【输出】
一个二维元组。
【输入示例】

5 0 0 0 13
0 12 0 0
20 0 11 0
6 0 0 8
【输出示例】

(('row 0 max', 13), ('row 1 max', 12), ('row 2 max', 20), ('row 3 max', 8))
（10分）
我的答案：
def row_maximums(two_dimensional_list):
    lst2=[]
    for i in range(len(two_dimensional_list)):
        lst=[]
        max_item=max(two_dimensional_list[i])
        str1='row '+str(i)+' max'
        lst.append(str1)
        lst.append(max_item)
        lst2.append(lst)
    return lst2
lst3=[]
for i in range(0,4):
    str2=input().split(' ')
    # print(type(str2))
    for j in range(len(str2)):
        str2[j]=int(str2[j])
    lst3.append(str2)
# print(lst3)
lst4=row_maximums(lst3)
for i in range(len(lst4)):
    lst4[i]=tuple(lst4[i])
print(tuple(lst4))

# l=[1,2,3,4,5]
# print(max(l))

题目得分 10
【描述】
计算个人在物品上的花费。
【输入】
每一行输入物品名、价格，其间以逗号分隔。在物品名或价格之前或之后可能存在空格。可能会有多行输入。
【输出】
返回一个基于物品名排序的元组列表。每个元组由物品名和购买该物品的总费用组成。物品的总费用由$开头，保留2位小数。
【输入示例】

milk,2.35
bread , 1.95
chips , 2.54
milk , 2.38
milk,2.31
bread, 1.90
【输出示例】
[(‘bread’, ‘$3.85’), (‘chips’, ‘$2.54’), (‘milk’, ‘$7.04’)]
（10分）
我的答案：

from operator import itemgetter
Input=input()
InputList=[]
while Input!="":
    InputList.append(Input.split(','))
    Input=input()
for i in range(len(InputList)):
    for j in range(len(InputList[i])):
        # print(InputList[i][j])
        InputList[i][j]=InputList[i][j].replace(' ','')
for i in range(len(InputList)):
    InputList[i][1]=eval(InputList[i][1])

# InputList.sort()
# print(InputList)
s1=set()
for i in range(len(InputList)):
    # print(InputList[i][0])
    s1.add(InputList[i][0])
d={}
for i in s1:
    d[i]=0
# print(d)
for i in range(len(InputList)):
    d[InputList[i][0]]=d[InputList[i][0]]+InputList[i][1]

l2=[]
for k in d:
    l1 = []
    l1.append(k)
    l1.append(round(d[k],2))
    l2.append(l1)

for i in range(len(l2)):
    l2[i][1]='$'+str(l2[i][1])
l2.sort()
for i in range(len(l2)):
    l2[i]=tuple(l2[i])
print(l2)

题目得分 10
【描述】
输入n个整数，对这n个整数去重之后排序，并输出从小到大排序结果。
【输入】
一行中输入n个整数。其中1≤n≤100，每个数的范围1≤x≤n。整数之间以空格间隔。
【输出】
输出去重之后从小到大排序结果
【输入示例】

1 3 2 1 3
【输出示例】
1
2
3
（10分）
我的答案：

line=list(map(int,input().split(" ")))
line.sort()
set1=set(line)
line2=list(set1)
for i in range(len(line2)):
    print(line2[i])

题目得分 10
【描述】
输入一个长度为n的整数序列，整数之间以空格间隔，其中含有重复的整数，需要移除里面重复的整数，对于每种重复的整数保留最后出现的那个。
【输入】
一行中输入n个整数，整数之间以空格分隔。
【输出】
消除重复整数之后的整数序列，整数之间以空格分隔，行末无空格。
【输入示例】
100 100 100 99 99 99 100 100 100
【输出示例】
99 100
（10分）
我的答案：

line=list(map(int,input().split()))
line1=line[::-1]
line2=sorted(set(line1),key=line1.index)
line3=line2[::-1]
# print(line2)
for i in range(len(line3)):
    print(line3[i],end=' ')

题目得分 10

实验17(综合练习03)

一、编程题（共8小题，80分）
题型得分 80
【描述】
编写程序，打开words.txt文件，读取文件中的内容并将该内容以大写的形式输出在屏幕上。
可以右键点下面链接下载words.txt文件：
点击打开链接
【输入】
文件words.txt。（该文件已经存在，无需自己创建）
【输出】
以大写的形式在屏幕上输出words.txt文件中的内容。
【输入示例】
文件words.txt。
【输出示例】
略。（10分）
我的答案：

with open("words.txt","r") as fo:
    lines=fo.read()
    print(lines.upper())

题目得分 10
【描述】
处理mbox-short.txt文件，寻找以“From ”开头的行，例如：
From stephen.marquard@uct.ac.za Sat Jan 509:14:16 2008
解析该行，输出该行的第二个单词（电子邮件地址）。直至文件结束。
最后输出文件中以“From ”开头的行的数量。
可以右键点下面链接下载mbox-short.txt文件：
点击打开链接
【输入】
文件mbox-short.txt。（该文件已经存在，无需自己创建）
【输出】
在屏幕上分行输出mbox-short.txt文件中以“From ”开头的行的第二个单词（电子邮件地址），最后输出文件中以“From ”开头的行的数量。
【输入示例】
文件mbox-short.txt。
【输出示例】

stephen.marquard@uct.ac.za
louis@media.berkeley.edu
zqian@umich.edu
rjlowe@iupui.edu
zqian@umich.edu
…
88
【提示】
输出示例只是格式说明，并非正确答案。（10分）
我的答案：

import re
text=re.compile(r".*[0-9]$")
s=0
with open("mbox-short.txt","r") as fo:
    lines=fo.readlines()
    for line in lines:
       if line.startswith("From")and not text.match(line):
           print(line[5:])
           s=s+1
    print(s)

题目得分 10
【描述】
编写程序，打开mbox-short.txt文件，读取文件中如下形式的行（以X-DSPAM-Confidence:开头）：
X-DSPAM-Confidence: 0.8475
统计文件中以X-DSPAM-Confidence:开头的行数，并提取出行中的浮点数值，计算这些浮点数值的平均值并输出。
可以右键点下面链接下载mbox-short.txt文件：
点击打开链接
【输入】
文件mbox-short.txt。（该文件已经存在，无需自己创建）
【输出】
文件中以X-DSPAM-Confidence:开头的行中浮点数值的平均值并输出。
【输入示例】
文件mbox-short.txt。
【输出示例】
Average spam confidence: 平均值（平均值要以具体数值替代）。（10分）
我的答案：

s=0
co=0
with open("mbox-short.txt","r") as fo:
    lines=fo.readlines()
    for line in lines:
        if line.startswith("X-DSPAM-Confidence:"):
            fl=float(line[20:])
            s=s+fl
            co=co+1
    print("Average spam confidence:",end="")
    #print("%.4f"%(s/co))
    print(s/co)

题目得分 10
【描述】
处理日志文件，日志文件的储存格式为"年/月/日 时:分:秒 用户名 操作"。
日志文件有多条记录：
2015/4/21 8:00:33 37c3b6b58c6ac3 LOGIN
2015/4/21 8:15:35 11734e186f24fe4c LOGIN
2015/4/21 8:34:57 9f3cf331d19a9f LOGIN
2015/4/21 9:00:29 389bcca2159f5de7 LOGIN
2015/4/21 9:08:29 c3bde693fdb3c3d LOGIN
……
可以右键点下面链接下载日志文件：
点击打开链接
【输入】
日志文件log.txt。（该文件已经存在，无需自己创建）
【输出】
日志文件中记录数。
【输入示例】
日志文件log.txt。
【输出示例】
略。（10分）
我的答案：

s=0
with open("log.txt","r") as fo:
    lines=fo.readlines()
    for line in lines:
        s=s+1
    print(s)

题目得分 10
【描述】
处理日志文件，日志文件的储存格式为"年/月/日 时:分:秒 用户名 操作"。
日志文件有多条记录：
2015/4/218:00:33 37c3b6b58c6ac3 LOGIN
2015/4/218:15:35 11734e186f24fe4c LOGIN
2015/4/218:34:57 9f3cf331d19a9f LOGIN
2015/4/219:00:29 389bcca2159f5de7 LOGIN
2015/4/219:08:29 c3bde693fdb3c3d LOGIN
……
可以右键点下面链接下载日志文件：
点击打开链接
【输入】
日志文件log.txt。（该文件已经存在，无需自己创建）
【输出】
日志文件中活跃用户的数量。
【输入示例】
日志文件log.txt。
【输出示例】

123
【提示】
活跃用户指的是在日志文件中有过操作的用户，记得把重复出现的用户去掉。
输出示例只是格式说明，并非正确答案。（10分）
我的答案：

s=set()
with open("log.txt","r") as fo:
    lines=fo.readlines()
    for line in lines:
        lst =line.split()
        #print(lst[2])
        s.add(lst[2])
    print(len(s))

题目得分 10
【描述】
输入一篇英文文章，求出现次数前三名的字母，不区分大小写（即出现A也计入出现a的次数中），按照次数由大到小输出，如果出现次数一样，按字典顺序输出。其它字符不予考虑。

附带说明：英文中，每个字母出现的频率是不一样的，在破译英文密码时，尤其是凯撒密码，统计每个字母出现的频率有着重要意义。

可以右键点下面链接下载英文文章：
点击打开链接
【输入】
英文文章news.txt。（该文件已经存在，无需自己创建）
【输出】
以如下格式：
字母:出现次数
显示出现次数前三名的字母和出现次数。
【输入示例】
英文文章news.txt。
【输出示例】

a:123
b:456
c:789
【提示】
输出示例只是格式说明，并非正确答案。（10分）
我的答案：

d={}
co=0
with open("news.txt","r") as fo:
    lines=fo.read()
    for i in lines:
        i=i.lower()
        if i not in d:
            d[i]=0
        if i in d:
            d[i]=d[i]+1
    for k in sorted(d,key=d.__getitem__,reverse=True):
        if co>0 and co<4:
            print(str(k)+":"+str(d[k]))
        co=co+1

题目得分 10
描述】
需要计算一些学生的加权平均分。给定输入文件gpa.txt，文件中每个学生的信息都由两行内容组成。第一行是学生姓名，第二行是该学生若干门课程的学分和成绩。下面是某个输入文件gpa.txt的内容：

张三
3 2.8 4 3.9 3 3.1
李四
3 3.9 3 4.0 4 3.9
王五
2 4.0 3 3.6 4 3.8 1 2.8
刘六
3 3.0 4 2.9 3 3.2 2 2.5
可以右键点下面链接下载文件：
点击打开链接
例如，张三同学：第一门课，学分3，成绩2.8；第二门课，学分4，成绩3.9；第三门课，学分3，成绩3.1。
总平均分等于学分乘以成绩，加权平均分等于总平均分除以总学分数。加权平均分最低0.0，最高4.0。
【输入】
文件gpa.txt。（该文件已经存在，无需自己创建）
【输出】
在屏幕上显示每个学生的加权平均分以及加权平均分的最大和最小值。
【输入示例】
文件gpa.txt，其中内容：
张三
3 2.8 4 3.9 3 3.1
李四
3 3.9 3 4.0 4 3.9
王五
2 4.0 3 3.6 4 3.8 1 2.8
刘六
3 3.0 4 2.9 3 3.2 2 2.5
【输出示例】
GPA for 张三 = 3.33
GPA for 李四 = 3.93
GPA for 王五 = 3.68
GPA for 刘六 = 2.93
max GPA= 3.93
min GPA= 2.93
（10分）
我的答案：

gpa=[]
s=0
cr=0
with open("gpa.txt","r") as fo:
    lines=fo.readlines()
    for i in range(1,len(lines),2):
        lines[i]=lines[i].split()
        for j in range(len(lines[i])):
            lines[i][j]=eval(lines[i][j])
            s=0
            cr=0
        for k in range(0,len(lines[i]),2):
            s=s+lines[i][k]*lines[i][k+1]
            cr=cr+lines[i][k]
        gpa.append("%.2f"%(s/cr))
    for m in range(0,len(lines),2):
        lines[m]= lines[m].replace('Q\n','')
        print("GPA for "+str(lines[m]),end=" ")
        print("= "+str(gpa[m//2]))
    print("max GPA= "+str(max(gpa)))
    print("min GPA= "+str(min(gpa)))

题目得分 10
【描述】
处理emma.txt文件，输出前10个最常见的单词（按出现次数从大到小排序）。
可以右键点下面链接下载emma.txt文件：
点击打开链接
【输入】
文件emma.txt。（该文件已经存在，无需自己创建）
【输出】
在屏幕上输出emma.txt文件中前10个最常见的单词。
【输入示例】
文件emma.txt。
【输出示例】

a
I
was
in
not
…
【提示】
输出示例只是格式说明，并非正确答案。
（10分）
我的答案：

with open("emma.txt",'r') as fo:
    d={}
    for line in fo.readlines():
        a=line.split()
        for k in a:
            if k.isalpha():
                if k not in d.keys():
                    d[k]=1
                else:
                    d[k]=d[k]+1
    d1=sorted(d,key=d.__getitem__,reverse=True)
    # print(d1)
    for i in range(10):
        print(d1[i])

题目得分 10